rubinius-melbourne 2.1.0.0 → 2.2.0.0

data/ext/rubinius/melbourne/grammar.y

@@ -15,6 +15,8 @@
 #define YYDEBUG 1
 #define YYERROR_VERBOSE 1
 
+#include <string.h>
+
 #include "namespace.h"
 #include "melbourne.hpp"
 #include "grammar.hpp"
@@ -54,17 +56,17 @@ static int parser_yyerror(rb_parser_state*, const char *);
 
 static int yylex(void*, void *);
 
-#define BITSTACK_PUSH(stack, n) (stack = (stack<<1)|((n)&1))
-#define BITSTACK_POP(stack)     (stack >>= 1)
-#define BITSTACK_LEXPOP(stack)  (stack = (stack >> 1) | (stack & 1))
-#define BITSTACK_SET_P(stack)   (stack&1)
+#define BITSTACK_PUSH(stack, n)   ((stack) = ((stack)<<1)|((n)&1))
+#define BITSTACK_POP(stack)       ((stack) = (stack) >> 1)
+#define BITSTACK_LEXPOP(stack)    ((stack) = ((stack) >> 1) | ((stack) & 1))
+#define BITSTACK_SET_P(stack)     ((stack)&1)
 
-#define COND_PUSH(n)    BITSTACK_PUSH(cond_stack, n)
+#define COND_PUSH(n)    BITSTACK_PUSH(cond_stack, (n))
 #define COND_POP()      BITSTACK_POP(cond_stack)
 #define COND_LEXPOP()   BITSTACK_LEXPOP(cond_stack)
 #define COND_P()        BITSTACK_SET_P(cond_stack)
 
-#define CMDARG_PUSH(n)  BITSTACK_PUSH(cmdarg_stack, n)
+#define CMDARG_PUSH(n)  BITSTACK_PUSH(cmdarg_stack, (n))
 #define CMDARG_POP()    BITSTACK_POP(cmdarg_stack)
 #define CMDARG_LEXPOP() BITSTACK_LEXPOP(cmdarg_stack)
 #define CMDARG_P()      BITSTACK_SET_P(cmdarg_stack)
@@ -101,7 +103,8 @@ static NODE *parser_new_evstr(rb_parser_state*, NODE*);
 static NODE *parser_evstr2dstr(rb_parser_state*, NODE*);
 static NODE *parser_call_bin_op(rb_parser_state*, NODE*, ID, NODE*);
 static NODE *parser_call_uni_op(rb_parser_state*, NODE*, ID);
-static NODE *parser_new_args(rb_parser_state*, NODE*, NODE*, ID, NODE*, ID);
+static NODE *parser_new_args(rb_parser_state*, NODE*, NODE*, ID, NODE*, NODE*);
+static NODE *parser_new_args_tail(rb_parser_state*, NODE*, ID, ID);
 static NODE *splat_array(NODE*);
 
 static NODE *parser_negate_lit(rb_parser_state*, NODE*);
@@ -125,6 +128,9 @@ static NODE *parser_aryset(rb_parser_state*, NODE*, NODE*);
 static NODE *parser_attrset(rb_parser_state*, NODE*, ID);
 static void rb_parser_backref_error(rb_parser_state*, NODE*);
 static NODE *parser_node_assign(rb_parser_state*, NODE*, NODE*);
+static NODE *parser_new_op_assign(rb_parser_state*, NODE*, ID, NODE*);
+static NODE *parser_new_attr_op_assign(rb_parser_state*, NODE*, ID, ID, NODE*);
+static NODE *parser_new_const_op_assign(rb_parser_state*, NODE*, ID, NODE*);
 
 static NODE *parser_match_op(rb_parser_state*, NODE*, NODE*);
 static int parser_arg_var(rb_parser_state*, ID);
@@ -155,6 +161,7 @@ rb_parser_state *parser_alloc_state() {
   class_nest = 0;
   in_single = 0;
   in_def = 0;
+  brace_nest = 0;
   compile_for_eval = 0;
   cur_mid = 0;
   tokenbuf = NULL;
@@ -241,6 +248,23 @@ static int rb_compile_error(rb_parser_state* parser_state, const char *fmt, ...)
   return count;
 }
 
+static void
+rb_name_error(ID id, const char *fmt, ...)
+{
+  char msg[BUFSIZ];
+  VALUE exc, argv[2];
+  va_list args;
+
+  va_start(args, fmt);
+  vsnprintf(msg, BUFSIZ, fmt, args);
+  argv[0] = rb_str_new2(msg);
+  va_end(args);
+
+  argv[1] = ID2SYM(id);
+  exc = rb_class_new_instance(2, argv, rb_eNameError);
+  rb_exc_raise(exc);
+}
+
 static int _debug_print(const char *fmt, ...) {
 #if SHOW_PARSER_WARNS
   va_list ar;
@@ -285,9 +309,13 @@ static int scan_hex(const char *start, size_t len, size_t *retlen);
 #define arg_concat(a, b)          parser_arg_concat(parser_state, a, b)
 #define list_append(l, i)         parser_list_append(parser_state, l, i)
 #define node_assign(a, b)         parser_node_assign(parser_state, a, b)
+#define new_op_assign(l, o, r)    parser_new_op_assign(parser_state, l, o, r)
+#define new_attr_op_assign(l,a,o,r) parser_new_attr_op_assign(parser_state, l, a, o, r)
+#define new_const_op_assign(l,o,r)  parser_new_const_op_assign(parser_state, l, o, r)
 #define call_bin_op(a, s, b)      parser_call_bin_op(parser_state, a, s, b)
 #define call_uni_op(n, s)         parser_call_uni_op(parser_state, n, s)
-#define new_args(f,o,r,p,b)       parser_new_args(parser_state, f, o, r, p, b)
+#define new_args(f,o,r,p,t)       parser_new_args(parser_state, f, o, r, p, t)
+#define new_args_tail(k,kr,b)     parser_new_args_tail(parser_state, k, kr, b)
 #define negate_lit(n)             parser_negate_lit(parser_state, n)
 #define ret_args(n)               parser_ret_args(parser_state, n)
 #define assignable(a, b)          parser_assignable(parser_state, a, b)
@@ -378,7 +406,8 @@ static int scan_hex(const char *start, size_t len, size_t *retlen);
 #define ENC_SINGLE(cr)        ((cr)==ENC_CODERANGE_7BIT)
 #define TOK_INTERN(mb)        parser_intern3(tok(), toklen(), parser_state->enc)
 
-#define NEW_BLOCK_VAR(b, v) NEW_NODE(NODE_BLOCK_PASS, 0, b, v)
+#define NEW_BLOCK_VAR(b, v)   NEW_NODE(NODE_BLOCK_PASS, 0, b, v)
+#define NEW_REQ_KW            NEW_LIT(ID2SYM(parser_intern("*")))
 
 /* Older versions of Yacc set YYMAXDEPTH to a very low value by default (150,
    for instance).  This is too low for Ruby to parse some files, such as
@@ -455,32 +484,34 @@ static int scan_hex(const char *start, size_t len, size_t *retlen);
   keyword__ENCODING__
 
 %token <id>   tIDENTIFIER tFID tGVAR tIVAR tCONSTANT tCVAR tLABEL
-%token <node> tINTEGER tFLOAT tSTRING_CONTENT tCHAR
+%token <node> tINTEGER tFLOAT tRATIONAL tIMAGINARY tSTRING_CONTENT tCHAR
 %token <node> tNTH_REF tBACK_REF
 %token <num>  tREGEXP_END
 
 %type <node> singleton strings string string1 xstring regexp
 %type <node> string_contents xstring_contents regexp_contents string_content
-%type <node> words qwords word_list qword_list word
-%type <node> literal numeric dsym cpath
+%type <node> words symbols symbol_list qwords qsymbols word_list qword_list qsym_list word
+%type <node> literal numeric simple_numeric dsym cpath
 %type <node> top_compstmt top_stmts top_stmt
-%type <node> bodystmt compstmt stmts stmt expr arg primary command command_call method_call
-%type <node> expr_value arg_value primary_value
+%type <node> bodystmt compstmt stmts stmt_or_begin stmt expr arg primary command command_call method_call
+%type <node> expr_value arg_value primary_value fcall
 %type <node> if_tail opt_else case_body cases opt_rescue exc_list exc_var opt_ensure
 %type <node> args call_args opt_call_args
-%type <node> paren_args opt_paren_args
+%type <node> paren_args opt_paren_args args_tail opt_args_tail block_args_tail opt_block_args_tail
 %type <node> command_args aref_args opt_block_arg block_arg var_ref var_lhs
-%type <node> command_asgn mrhs superclass block_call block_command
+%type <node> command_asgn mrhs mrhs_arg superclass block_call block_command
 %type <node> f_block_optarg f_block_opt
 %type <node> f_arglist f_args f_arg f_arg_item f_optarg f_marg f_marg_list f_margs
 %type <node> assoc_list assocs assoc undef_list backref string_dvar for_var
 %type <node> block_param opt_block_param block_param_def f_opt
+%type <node> f_kwarg f_kw f_block_kwarg f_block_kw
 %type <node> bv_decls opt_bv_decl bvar
 %type <node> lambda f_larglist lambda_body
 %type <node> brace_block cmd_brace_block do_block lhs none fitem
 %type <node> mlhs mlhs_head mlhs_basic mlhs_item mlhs_node mlhs_post mlhs_inner
 %type <id>   fsym keyword_variable user_variable sym symbol operation operation2 operation3
 %type <id>   cname fname op f_rest_arg f_block_arg opt_f_block_arg f_norm_arg f_bad_arg
+%type <id>   f_kwrest f_label
 
 %token tUPLUS           /* unary+ */
 %token tUMINUS          /* unary- */
@@ -507,10 +538,11 @@ static int scan_hex(const char *start, size_t len, size_t *retlen);
 %token tLBRACE          /* { */
 %token tLBRACE_ARG      /* { */
 %token tSTAR            /* * */
+%token tDSTAR           /* ** */
 %token tAMPER           /* & */
 %token tLAMBDA          /* -> */
-%token tSYMBEG tSTRING_BEG tXSTRING_BEG tREGEXP_BEG tWORDS_BEG tQWORDS_BEG
-%token tSTRING_DBEG tSTRING_DVAR tSTRING_END tLAMBEG
+%token tSYMBEG tSTRING_BEG tXSTRING_BEG tREGEXP_BEG tWORDS_BEG tQWORDS_BEG tSYMBOLS_BEG tQSYMBOLS_BEG
+%token tSTRING_DBEG tSTRING_DEND tSTRING_DVAR tSTRING_END tLAMBEG
 
 /*
  *      precedence table
@@ -640,11 +672,11 @@ stmts           : none
                   {
                     $$ = NEW_BEGIN(0);
                   }
-                | stmt
+                | stmt_or_begin
                   {
                     $$ = newline_node($1);
                   }
-                | stmts terms stmt
+                | stmts terms stmt_or_begin
                   {
                     $$ = block_append($1, newline_node($3));
                   }
@@ -654,6 +686,20 @@ stmts           : none
                   }
                 ;
 
+stmt_or_begin   : stmt
+                  {
+                    $$ = $1;
+                  }
+                | keyword_BEGIN
+                  {
+                    yy_error("BEGIN is permitted only at toplevel");
+                  }
+                '{' top_compstmt '}'
+                  {
+                    $$ = NEW_BEGIN(0);
+                  }
+                ;
+
 stmt            : keyword_alias fitem {lex_state = EXPR_FNAME;} fitem
                   {
                     $$ = NEW_ALIAS($2, $4);
@@ -722,30 +768,13 @@ stmt            : keyword_alias fitem {lex_state = EXPR_FNAME;} fitem
                 | mlhs '=' command_call
                   {
                     value_expr($3);
-                    $1->nd_value = ($1->nd_head) ? NEW_TO_ARY($3) : NEW_ARRAY($3);
+                    $1->nd_value = $3;
                     $$ = $1;
                   }
                 | var_lhs tOP_ASGN command_call
                   {
                     value_expr($3);
-                    if($1) {
-                      ID vid = $1->nd_vid;
-                      if($2 == tOROP) {
-                        $1->nd_value = $3;
-                        $$ = NEW_OP_ASGN_OR(gettable(vid), $1);
-                        if(is_asgn_or_id(vid)) {
-                          $$->nd_aid = vid;
-                        }
-                      } else if($2 == tANDOP) {
-                        $1->nd_value = $3;
-                        $$ = NEW_OP_ASGN_AND(gettable(vid), $1);
-                      } else {
-                        $$ = $1;
-                        $$->nd_value = call_bin_op(gettable(vid), $2, $3);
-                      }
-                    } else {
-                      $$ = NEW_BEGIN(0);
-                    }
+                    $$ = new_op_assign($1, $2, $3);
                   }
                 | primary_value '[' opt_call_args rbracket tOP_ASGN command_call
                   {
@@ -767,69 +796,41 @@ stmt            : keyword_alias fitem {lex_state = EXPR_FNAME;} fitem
                 | primary_value '.' tIDENTIFIER tOP_ASGN command_call
                   {
                     value_expr($5);
-                    if($4 == tOROP) {
-                      $4 = 0;
-                    } else if($4 == tANDOP) {
-                      $4 = 1;
-                    } else {
-                      $4 = convert_op($4);
-                    }
-                    $$ = NEW_OP_ASGN2($1, $3, $4, $5);
-                    fixpos($$, $1);
+                    $$ = new_attr_op_assign($1, $3, $4, $5);
                   }
                 | primary_value '.' tCONSTANT tOP_ASGN command_call
                   {
                     value_expr($5);
-                    if($4 == tOROP) {
-                      $4 = 0;
-                    } else if($4 == tANDOP) {
-                      $4 = 1;
-                    } else {
-                      $4 = convert_op($4);
-                    }
-                    $$ = NEW_OP_ASGN2($1, $3, $4, $5);
-                    fixpos($$, $1);
+                    $$ = new_attr_op_assign($1, $3, $4, $5);
                   }
                 | primary_value tCOLON2 tCONSTANT tOP_ASGN command_call
                   {
-                    yy_error("constant re-assignment");
-                    $$ = 0;
+                    $$ = NEW_COLON2($1, $3);
+                    $$ = new_const_op_assign($$, $4, $5);
                   }
                 | primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_call
                   {
                     value_expr($5);
-                    if($4 == tOROP) {
-                      $4 = 0;
-                    } else if($4 == tANDOP) {
-                      $4 = 1;
-                    } else {
-                      $4 = convert_op($4);
-                    }
-                    $$ = NEW_OP_ASGN2($1, $3, $4, $5);
-                    fixpos($$, $1);
+                    $$ = new_attr_op_assign($1, $3, $4, $5);
                   }
                 | backref tOP_ASGN command_call
                   {
                     rb_backref_error($1);
-                    $$ = 0;
+                    $$ = NEW_BEGIN(0);
                   }
                 | lhs '=' mrhs
                   {
                     value_expr($3);
                     $$ = node_assign($1, $3);
                   }
-                | mlhs '=' arg_value
-                  {
-                    $1->nd_value = ($1->nd_head) ? NEW_TO_ARY($3) : NEW_ARRAY($3);
-                    $$ = $1;
-                  }
-                | mlhs '=' mrhs
+                | mlhs '=' mrhs_arg
                   {
                     $1->nd_value = $3;
                     $$ = $1;
                   }
                 | expr
                 ;
+
 command_asgn    : lhs '=' command_call
                   {
                     value_expr($3);
@@ -841,6 +842,7 @@ command_asgn    : lhs '=' command_call
                     $$ = node_assign($1, $3);
                   }
                 ;
+
 expr            : command_call
                 | expr keyword_and expr
                   {
@@ -874,11 +876,7 @@ command_call    : command
                 ;
 
 block_command   : block_call
-                | block_call '.' operation2 command_args
-                  {
-                    $$ = NEW_CALL($1, $3, $4);
-                  }
-                | block_call tCOLON2 operation2 command_args
+                | block_call dot_or_colon operation2 command_args
                   {
                     $$ = NEW_CALL($1, $3, $4);
                   }
@@ -899,17 +897,25 @@ cmd_brace_block : tLBRACE_ARG
                   }
                 ;
 
-command         : operation command_args       %prec tLOWEST
+fcall           : operation
                   {
-                    $$ = NEW_FCALL($1, $2);
-                    fixpos($$, $2);
+                    $$ = NEW_FCALL($1, 0);
+                    nd_set_line($$, tokline);
+                  }
+                ;
+
+command         : fcall command_args       %prec tLOWEST
+                  {
+                    $$ = $1;
+                    $$->nd_args = $2;
                  }
-                | operation command_args cmd_brace_block
+                | fcall command_args cmd_brace_block
                   {
                     block_dup_check($2, $3);
-                    $3->nd_iter = NEW_FCALL($1, $2);
+                    $1->nd_args = $2;
+                    $3->nd_iter = $1;
                     $$ = $3;
-                    fixpos($$, $2);
+                    fixpos($$, $1);
                  }
                 | primary_value '.' operation2 command_args     %prec tLOWEST
                   {
@@ -1209,6 +1215,7 @@ op              : '|'           { $$ = '|'; }
                 | '/'           { $$ = '/'; }
                 | '%'           { $$ = '%'; }
                 | tPOW          { $$ = tPOW; }
+                | tDSTAR        { $$ = tDSTAR; }
                 | '!'           { $$ = '!'; }
                 | '~'           { $$ = '~'; }
                 | tUPLUS        { $$ = tUPLUS; }
@@ -1246,47 +1253,13 @@ arg             : lhs '=' arg
                 | var_lhs tOP_ASGN arg
                   {
                     value_expr($3);
-                    if($1) {
-                      ID vid = $1->nd_vid;
-                      if($2 == tOROP) {
-                        $1->nd_value = $3;
-                        $$ = NEW_OP_ASGN_OR(gettable(vid), $1);
-                        if(is_asgn_or_id(vid)) {
-                          $$->nd_aid = vid;
-                        }
-                      } else if($2 == tANDOP) {
-                        $1->nd_value = $3;
-                        $$ = NEW_OP_ASGN_AND(gettable(vid), $1);
-                      } else {
-                        $$ = $1;
-                        $$->nd_value = NEW_CALL(gettable(vid), $2, NEW_LIST($3));
-                      }
-                    } else {
-                      $$ = NEW_BEGIN(0);
-                    }
+                    $$ = new_op_assign($1, $2, $3);
                   }
                 | var_lhs tOP_ASGN arg modifier_rescue arg
                   {
                     value_expr($3);
                     $3 = NEW_RESCUE($3, NEW_RESBODY(0, $5, 0), 0);
-                    if($1) {
-                      ID vid = $1->nd_vid;
-                      if($2 == tOROP) {
-                        $1->nd_value = $3;
-                        $$ = NEW_OP_ASGN_OR(gettable(vid), $1);
-                        if(is_asgn_or_id(vid)) {
-                          $$->nd_aid = vid;
-                        }
-                      } else if($2 == tANDOP) {
-                        $1->nd_value = $3;
-                        $$ = NEW_OP_ASGN_AND(gettable(vid), $1);
-                      } else {
-                        $$ = $1;
-                        $$->nd_value = NEW_CALL(gettable(vid), $2, NEW_LIST($3));
-                      }
-                    } else {
-                      $$ = NEW_BEGIN(0);
-                    }
+                    new_op_assign($1, $2, $3);
                   }
                 | primary_value '[' opt_call_args rbracket tOP_ASGN arg
                   {
@@ -1312,51 +1285,27 @@ arg             : lhs '=' arg
                 | primary_value '.' tIDENTIFIER tOP_ASGN arg
                   {
                     value_expr($5);
-                    if($4 == tOROP) {
-                      $4 = 0;
-                    } else if($4 == tANDOP) {
-                      $4 = 1;
-                    } else {
-                      $4 = convert_op($4);
-                    }
-                    $$ = NEW_OP_ASGN2($1, $3, $4, $5);
-                    fixpos($$, $1);
+                    $$ = new_attr_op_assign($1, $3, $4, $5);
                   }
                 | primary_value '.' tCONSTANT tOP_ASGN arg
                   {
                     value_expr($5);
-                    if($4 == tOROP) {
-                      $4 = 0;
-                    } else if($4 == tANDOP) {
-                      $4 = 1;
-                    } else {
-                      $4 = convert_op($4);
-                    }
-                    $$ = NEW_OP_ASGN2($1, $3, $4, $5);
-                    fixpos($$, $1);
+                    $$ = new_attr_op_assign($1, $3, $4, $5);
                   }
                 | primary_value tCOLON2 tIDENTIFIER tOP_ASGN arg
                   {
                     value_expr($5);
-                    if($4 == tOROP) {
-                      $4 = 0;
-                    } else if($4 == tANDOP) {
-                      $4 = 1;
-                    } else {
-                      $4 = convert_op($4);
-                    }
-                    $$ = NEW_OP_ASGN2($1, $3, $4, $5);
-                    fixpos($$, $1);
+                    $$ = new_attr_op_assign($1, $3, $4, $5);
                   }
                 | primary_value tCOLON2 tCONSTANT tOP_ASGN arg
                   {
-                    yy_error("constant re-assignment");
-                    $$ = NEW_BEGIN(0);
+                    $$ = NEW_COLON2($1, $3);
+                    $$ = new_const_op_assign($$, $4, $5);
                   }
                 | tCOLON3 tCONSTANT tOP_ASGN arg
                   {
-                    yy_error("constant re-assignment");
-                    $$ = NEW_BEGIN(0);
+                    $$ = NEW_COLON3($2);
+                    $$ = new_const_op_assign($$, $3, $4);
                   }
                 | backref tOP_ASGN arg
                   {
@@ -1399,11 +1348,7 @@ arg             : lhs '=' arg
                   {
                     $$ = call_bin_op($1, tPOW, $3);
                   }
-                | tUMINUS_NUM tINTEGER tPOW arg
-                  {
-                    $$ = NEW_CALL(call_bin_op($2, tPOW, $4), tUMINUS, 0);
-                  }
-                | tUMINUS_NUM tFLOAT tPOW arg
+                | tUMINUS_NUM simple_numeric tPOW arg
                   {
                     $$ = NEW_CALL(call_bin_op($2, tPOW, $4), tUMINUS, 0);
                   }
@@ -1549,6 +1494,18 @@ opt_paren_args  : none
 
 opt_call_args   : none
                 | call_args
+                | args ','
+                  {
+                    $$ = $1;
+                  }
+                | args ',' assocs ','
+                  {
+                    $$ = arg_append($1, NEW_HASH($3));
+                  }
+                | assocs ','
+                  {
+                    $$ = NEW_LIST(NEW_HASH($1));
+                  }
                 ;
 
 call_args       : command
@@ -1595,10 +1552,6 @@ opt_block_arg   : ',' block_arg
                   {
                     $$ = $2;
                   }
-                | ','
-                  {
-                    $$ = 0;
-                  }
                 | none
                   {
                     $$ = 0;
@@ -1633,6 +1586,10 @@ args            : arg_value
                   }
                 ;
 
+mrhs_arg        : mrhs
+                | arg_value
+                ;
+
 mrhs            : args ',' arg_value
                   {
                     NODE *n1;
@@ -1663,6 +1620,8 @@ primary         : literal
                 | regexp
                 | words
                 | qwords
+                | symbols
+                | qsymbols
                 | var_ref
                 | backref
                 | tFID
@@ -1671,11 +1630,14 @@ primary         : literal
                   }
                 | k_begin
                   {
+                    $<val>1 = cmdarg_stack;
+                    cmdarg_stack = 0;
                     $<num>$ = sourceline;
                   }
                   bodystmt
                   k_end
                   {
+                    cmdarg_stack = $<val>1;
                     if($3 == NULL) {
                       $$ = NEW_NIL();
                     } else {
@@ -1686,9 +1648,12 @@ primary         : literal
                     }
                     nd_set_line($$, $<num>2);
                   }
+                | tLPAREN_ARG {lex_state = EXPR_ENDARG;} rparen
+                  {
+                    $$ = 0;
+                  }
                 | tLPAREN_ARG expr {lex_state = EXPR_ENDARG;} rparen
                   {
-                    rb_warning("(...) interpreted as grouped expression");
                     $$ = $2;
                   }
                 | tLPAREN compstmt ')'
@@ -1744,9 +1709,9 @@ primary         : literal
                   {
                     $$ = call_uni_op(cond(NEW_NIL()), '!');
                   }
-                | operation brace_block
+                | fcall brace_block
                   {
-                    $2->nd_iter = NEW_FCALL($1, 0);
+                    $2->nd_iter = $1;
                     $$ = $2;
                     fixpos($2->nd_iter, $2);
                   }
@@ -2095,63 +2060,91 @@ f_margs         : f_marg_list
                   }
                 ;
 
-block_param     : f_arg ',' f_block_optarg ',' f_rest_arg opt_f_block_arg
+block_args_tail : f_block_kwarg ',' f_kwrest opt_f_block_arg
+                  {
+                    $$ = new_args_tail($1, $3, $4);
+                  }
+                | f_block_kwarg opt_f_block_arg
+                  {
+                    $$ = new_args_tail($1, 0, $2);
+                  }
+                | f_kwrest opt_f_block_arg
+                  {
+                    $$ = new_args_tail(0, $1, $2);
+                  }
+                | f_block_arg
+                  {
+                    $$ = new_args_tail(0, 0, $1);
+                  }
+                ;
+
+opt_block_args_tail : ',' block_args_tail
+                  {
+                    $$ = $2;
+                  }
+                | /* none */
+                  {
+                    $$ = new_args_tail(0, 0, 0);
+                  }
+                ;
+
+block_param     : f_arg ',' f_block_optarg ',' f_rest_arg opt_block_args_tail
                   {
                     $$ = new_args($1, $3, $5, 0, $6);
                   }
-                | f_arg ',' f_block_optarg ',' f_rest_arg ',' f_arg opt_f_block_arg
+                | f_arg ',' f_block_optarg ',' f_rest_arg ',' f_arg opt_block_args_tail
                   {
                     $$ = new_args($1, $3, $5, $7, $8);
                   }
-                | f_arg ',' f_block_optarg opt_f_block_arg
+                | f_arg ',' f_block_optarg opt_block_args_tail
                   {
                     $$ = new_args($1, $3, 0, 0, $4);
                   }
-                | f_arg ',' f_block_optarg ',' f_arg opt_f_block_arg
+                | f_arg ',' f_block_optarg ',' f_arg opt_block_args_tail
                   {
                     $$ = new_args($1, $3, 0, $5, $6);
                   }
-                | f_arg ',' f_rest_arg opt_f_block_arg
+                | f_arg ',' f_rest_arg opt_block_args_tail
                   {
                     $$ = new_args($1, 0, $3, 0, $4);
                   }
                 | f_arg ','
                   {
-                    $$ = new_args($1, 0, 1, 0, 0);
+                    $$ = new_args($1, 0, 1, 0, new_args_tail(0, 0, 0));
                   }
-                | f_arg ',' f_rest_arg ',' f_arg opt_f_block_arg
+                | f_arg ',' f_rest_arg ',' f_arg opt_block_args_tail
                   {
                     $$ = new_args($1, 0, $3, $5, $6);
                   }
-                | f_arg opt_f_block_arg
+                | f_arg opt_block_args_tail
                   {
                     $$ = new_args($1, 0, 0, 0, $2);
                   }
-                | f_block_optarg ',' f_rest_arg opt_f_block_arg
+                | f_block_optarg ',' f_rest_arg opt_block_args_tail
                   {
                     $$ = new_args(0, $1, $3, 0, $4);
                   }
-                | f_block_optarg ',' f_rest_arg ',' f_arg opt_f_block_arg
+                | f_block_optarg ',' f_rest_arg ',' f_arg opt_block_args_tail
                   {
                     $$ = new_args(0, $1, $3, $5, $6);
                   }
-                | f_block_optarg opt_f_block_arg
+                | f_block_optarg opt_block_args_tail
                   {
                     $$ = new_args(0, $1, 0, 0, $2);
                   }
-                | f_block_optarg ',' f_arg opt_f_block_arg
+                | f_block_optarg ',' f_arg opt_block_args_tail
                   {
                     $$ = new_args(0, $1, 0, $3, $4);
                   }
-                | f_rest_arg opt_f_block_arg
+                | f_rest_arg opt_block_args_tail
                   {
                     $$ = new_args(0, 0, $1, 0, $2);
                   }
-                | f_rest_arg ',' f_arg opt_f_block_arg
+                | f_rest_arg ',' f_arg opt_block_args_tail
                   {
                     $$ = new_args(0, 0, $1, $3, $4);
                   }
-                | f_block_arg
+                | block_args_tail
                   {
                     $$ = new_args(0, 0, 0, 0, $1);
                   }
@@ -2166,7 +2159,8 @@ opt_block_param : none
 
 block_param_def : '|' opt_bv_decl '|'
                   {
-                    $$ = $2 ? NEW_ARGS_AUX(0,$2) : 0;
+                    // This is deliberately different than MRI.
+                    $$ = $2 ? NEW_ARGS_AUX(0, $2) : 0;
                   }
                 | tOROP
                   {
@@ -2174,30 +2168,30 @@ block_param_def : '|' opt_bv_decl '|'
                   }
                 | '|' block_param opt_bv_decl '|'
                   {
-                    if($3) {
-                      $$ = NEW_ARGS_AUX($2, $3);
-                    } else {
-                      $$ = $2;
-                    }
+                    // This is deliberately different than MRI.
+                    $$ = $3 ? NEW_ARGS_AUX($2, $3) : $2;
                   }
                 ;
 
-opt_bv_decl     : none
+opt_bv_decl     : opt_nl
                   {
                     $$ = 0;
                   }
-                | ';' bv_decls
+                | opt_nl ';' bv_decls
                   {
-                    $$ = $2;
+                    // This is deliberately different than MRI.
+                    $$ = $3;
                   }
                 ;
 
 bv_decls        : bvar
                   {
+                    // This is deliberately different than MRI.
                     $$ = NEW_LIST($1);
                   }
                 | bv_decls ',' bvar
                   {
+                    // This is deliberately different than MRI.
                     $$ = list_append($1, $3);
                   }
                 ;
@@ -2205,6 +2199,7 @@ bv_decls        : bvar
 bvar            : tIDENTIFIER
                   {
                     new_bv(get_id($1));
+                    // This is deliberately different than MRI.
                     $$ = NEW_LIT(ID2SYM(get_id($1)));
                   }
                 | f_bad_arg
@@ -2221,22 +2216,25 @@ lambda          : {
                     lpar_beg = ++paren_nest;
                   }
                   f_larglist
+                  {
+                    $<num>$ = sourceline;
+                  }
                   lambda_body
                   {
                     lpar_beg = $<num>2;
-                    $$ = $3;
-                    $$->nd_body = NEW_SCOPE($3->nd_head, $4);
+                    $$ = NEW_LAMBDA($3, $5);
+                    nd_set_line($$, $<num>4);
                     bv_pop($<vars>1);
                   }
                 ;
 
-f_larglist      : '(' f_args opt_bv_decl rparen
+f_larglist      : '(' f_args opt_bv_decl ')'
                   {
-                    $$ = NEW_LAMBDA($2);
+                    $$ = $2;
                   }
                 | f_args
                   {
-                    $$ = NEW_LAMBDA($1);
+                    $$ = $1;
                   }
                 ;
 
@@ -2276,44 +2274,71 @@ block_call      : command do_block
                     $$ = $2;
                     fixpos($$, $1);
                   }
-                | block_call '.' operation2 opt_paren_args
+                | block_call dot_or_colon operation2 opt_paren_args
                   {
                     $$ = NEW_CALL($1, $3, $4);
                   }
-                | block_call tCOLON2 operation2 opt_paren_args
+                | block_call dot_or_colon operation2 opt_paren_args brace_block
                   {
-                    $$ = NEW_CALL($1, $3, $4);
+                    block_dup_check($4, $5);
+                    $5->nd_iter = NEW_CALL($1, $3, $4);
+                    $$ = $5;
+                    fixpos($$, $1);
+                  }
+                | block_call dot_or_colon operation2 command_args do_block
+                  {
+                    block_dup_check($4, $5);
+                    $5->nd_iter = NEW_CALL($1, $3, $4);
+                    $$ = $5;
+                    fixpos($$, $1);
                   }
                 ;
 
-method_call     : operation paren_args
+method_call     : fcall paren_args
                   {
-                    $$ = NEW_FCALL($1, $2);
+                    $$ = $1;
+                    $$->nd_args = $2;
                     fixpos($$, $2);
                   }
-                | primary_value '.' operation2 opt_paren_args
+                | primary_value '.' operation2
                   {
-                    $$ = NEW_CALL($1, $3, $4);
-                    fixpos($$, $1);
+                    $<num>$ = sourceline;
                   }
-                | primary_value tCOLON2 operation2 paren_args
+                  opt_paren_args
                   {
-                    $$ = NEW_CALL($1, $3, $4);
-                    fixpos($$, $1);
+                    $$ = NEW_CALL($1, $3, $5);
+                    nd_set_line($$, $<num>4);
+                  }
+                | primary_value tCOLON2 operation2
+                  {
+                    $<num>$ = sourceline;
+                  }
+                  paren_args
+                  {
+                    $$ = NEW_CALL($1, $3, $5);
+                    nd_set_line($$, $<num>4);
                   }
                 | primary_value tCOLON2 operation3
                   {
                     $$ = NEW_CALL($1, $3, 0);
                   }
-                | primary_value '.' paren_args
+                | primary_value '.'
                   {
-                    $$ = NEW_CALL($1, parser_intern("call"), $3);
-                    fixpos($$, $1);
+                    $<num>$ = sourceline;
                   }
-                | primary_value tCOLON2 paren_args
+                  paren_args
                   {
-                    $$ = NEW_CALL($1, parser_intern("call"), $3);
-                    fixpos($$, $1);
+                    $$ = NEW_CALL($1, parser_intern("call"), $4);
+                    nd_set_line($$, $<num>3);
+                  }
+                | primary_value tCOLON2
+                  {
+                    $<num>$ = sourceline;
+                  }
+                  paren_args
+                  {
+                    $$ = NEW_CALL($1, parser_intern("call"), $4);
+                    nd_set_line($$, $<num>3);
                   }
                 | keyword_super paren_args
                   {
@@ -2555,6 +2580,28 @@ word            : string_content
                   }
                 ;
 
+symbols         : tSYMBOLS_BEG ' ' tSTRING_END
+                  {
+                    $$ = NEW_ZARRAY();
+                  }
+                | tSYMBOLS_BEG symbol_list tSTRING_END
+                  {
+                    $$ = $2;
+                  }
+                ;
+
+symbol_list     : /* none */
+                  {
+                    $$ = 0;
+                  }
+                | symbol_list word ' '
+                  {
+                    $2 = evstr2dstr($2);
+                    nd_set_type($2, NODE_DSYM);
+                    $$ = list_append($1, $2);
+                  }
+                ;
+
 qwords          : tQWORDS_BEG ' ' tSTRING_END
                   {
                     $$ = NEW_ZARRAY();
@@ -2565,6 +2612,16 @@ qwords          : tQWORDS_BEG ' ' tSTRING_END
                   }
                 ;
 
+qsymbols        : tQSYMBOLS_BEG ' ' tSTRING_END
+                  {
+                    $$ = NEW_ZARRAY();
+                  }
+                | tQSYMBOLS_BEG qsym_list tSTRING_END
+                  {
+                    $$ = $2;
+                  }
+                ;
+
 qword_list      : /* none */
                   {
                     $$ = 0;
@@ -2575,6 +2632,20 @@ qword_list      : /* none */
                   }
                 ;
 
+qsym_list       : /* none */
+                  {
+                    $$ = 0;
+                  }
+                | qsym_list tSTRING_CONTENT ' '
+                  {
+                    VALUE lit;
+                    lit = $2->nd_lit;
+                    $2->nd_lit = ID2SYM(parser_intern_str(lit));
+                    nd_set_type($2, NODE_LIT);
+                    $$ = list_append($1, $2);
+                  }
+                ;
+
 string_contents : /* none */
                   {
                     $$ = 0;
@@ -2646,14 +2717,19 @@ string_content  : tSTRING_CONTENT
                     lex_strterm = 0;
                     lex_state = EXPR_BEG;
                   }
-                  compstmt '}'
+                  {
+                    $<num>$ = brace_nest;
+                    brace_nest = 0;
+                  }
+                  compstmt tSTRING_DEND
                   {
                     cond_stack = $<val>1;
                     cmdarg_stack = $<val>2;
                     lex_strterm = $<node>3;
+                    brace_nest = $<num>4;
 
-                    if($4) $4->flags &= ~NODE_FL_NEWLINE;
-                    $$ = new_evstr($4);
+                    if($5) $5->flags &= ~NODE_FL_NEWLINE;
+                    $$ = new_evstr($5);
                   }
                 ;
 
@@ -2679,6 +2755,7 @@ sym             : fname
 dsym            : tSYMBEG xstring_contents tSTRING_END
                   {
                     lex_state = EXPR_END;
+                    // TODO dsym_node($2);
                     if(!($$ = $2)) {
                       $$ = NEW_LIT(ID2SYM(parser_intern("")));
                     } else {
@@ -2701,18 +2778,19 @@ dsym            : tSYMBEG xstring_contents tSTRING_END
                   }
                 ;
 
-numeric         : tINTEGER
-                | tFLOAT
-                | tUMINUS_NUM tINTEGER         %prec tLOWEST
-                  {
-                    $$ = negate_lit($2);
-                  }
-                | tUMINUS_NUM tFLOAT           %prec tLOWEST
+numeric         : simple_numeric
+                | tUMINUS_NUM simple_numeric   %prec tLOWEST
                   {
                     $$ = negate_lit($2);
                   }
                 ;
 
+simple_numeric  : tINTEGER
+                | tFLOAT
+                | tRATIONAL
+                | tIMAGINARY
+                ;
+
 user_variable   : tIDENTIFIER
                 | tIVAR
                 | tGVAR
@@ -2764,6 +2842,7 @@ superclass      : term
                 | '<'
                   {
                     lex_state = EXPR_BEG;
+                    command_start = TRUE;
                   }
                   expr_value term
                   {
@@ -2790,65 +2869,94 @@ f_arglist       : '(' f_args rparen
                   }
                 ;
 
-f_args          : f_arg ',' f_optarg ',' f_rest_arg opt_f_block_arg
+args_tail       : f_kwarg ',' f_kwrest opt_f_block_arg
+                  {
+                    $$ = new_args_tail($1, $3, $4);
+                  }
+                | f_kwarg opt_f_block_arg
+                  {
+                    $$ = new_args_tail($1, 0, $2);
+                  }
+                | f_kwrest opt_f_block_arg
+                  {
+                    $$ = new_args_tail(0, $1, $2);
+                  }
+                | f_block_arg
+                  {
+                    $$ = new_args_tail(0, 0, $1);
+                  }
+                ;
+
+opt_args_tail   : ',' args_tail
+                  {
+                    $$ = $2;
+                  }
+                | /* none */
+                  {
+                    $$ = new_args_tail(0, 0, 0);
+                  }
+                ;
+
+f_args          : f_arg ',' f_optarg ',' f_rest_arg opt_args_tail
                   {
                     $$ = new_args($1, $3, $5, 0, $6);
                   }
-                | f_arg ',' f_optarg ',' f_rest_arg ',' f_arg opt_f_block_arg
+                | f_arg ',' f_optarg ',' f_rest_arg ',' f_arg opt_args_tail
                   {
                     $$ = new_args($1, $3, $5, $7, $8);
                   }
-                | f_arg ',' f_optarg opt_f_block_arg
+                | f_arg ',' f_optarg opt_args_tail
                   {
                     $$ = new_args($1, $3, 0, 0, $4);
                   }
-                | f_arg ',' f_optarg ',' f_arg opt_f_block_arg
+                | f_arg ',' f_optarg ',' f_arg opt_args_tail
                   {
                     $$ = new_args($1, $3, 0, $5, $6);
                   }
-                | f_arg ',' f_rest_arg opt_f_block_arg
+                | f_arg ',' f_rest_arg opt_args_tail
                   {
                     $$ = new_args($1, 0, $3, 0, $4);
                   }
-                | f_arg ',' f_rest_arg ',' f_arg opt_f_block_arg
+                | f_arg ',' f_rest_arg ',' f_arg opt_args_tail
                   {
                     $$ = new_args($1, 0, $3, $5, $6);
                   }
-                | f_arg opt_f_block_arg
+                | f_arg opt_args_tail
                   {
                     $$ = new_args($1, 0, 0, 0, $2);
                   }
-                | f_optarg ',' f_rest_arg opt_f_block_arg
+                | f_optarg ',' f_rest_arg opt_args_tail
                   {
                     $$ = new_args(0, $1, $3, 0, $4);
                   }
-                | f_optarg ',' f_rest_arg ',' f_arg opt_f_block_arg
+                | f_optarg ',' f_rest_arg ',' f_arg opt_args_tail
                   {
                     $$ = new_args(0, $1, $3, $5, $6);
                   }
-                | f_optarg opt_f_block_arg
+                | f_optarg opt_args_tail
                   {
                     $$ = new_args(0, $1, 0, 0, $2);
                   }
-                | f_optarg ',' f_arg opt_f_block_arg
+                | f_optarg ',' f_arg opt_args_tail
                   {
                     $$ = new_args(0, $1, 0, $3, $4);
                   }
-                | f_rest_arg opt_f_block_arg
+                | f_rest_arg opt_args_tail
                   {
                     $$ = new_args(0, 0, $1, 0, $2);
                   }
-                | f_rest_arg ',' f_arg opt_f_block_arg
+                | f_rest_arg ',' f_arg opt_args_tail
                   {
                     $$ = new_args(0, 0, $1, $3, $4);
                   }
-                | f_block_arg
+                | args_tail
                   {
                     $$ = new_args(0, 0, 0, 0, $1);
                   }
                 | /* none */
                   {
-                    $$ = new_args(0, 0, 0, 0, 0);
+                    $$ = new_args_tail(0, 0, 0);
+                    $$ = new_args(0, 0, 0, 0, $$);
                   }
                 ;
 
@@ -2887,36 +2995,112 @@ f_arg_item      : f_norm_arg
                     arg_var(get_id($1));
                     $$ = NEW_ARGS_AUX($1, 1);
                   }
-                | tLPAREN f_margs rparen
+                | tLPAREN f_margs rparen
+                  {
+                    ID tid = internal_id();
+                    arg_var(tid);
+                    $2->nd_value = NEW_LVAR(tid);
+                    $$ = NEW_ARGS_AUX(tid, 1);
+                    $$->nd_next = $2;
+                  }
+                ;
+
+f_arg           : f_arg_item
+                | f_arg ',' f_arg_item
+                  {
+                    $$ = $1;
+                    $$->nd_plen++;
+                    $$->nd_next = block_append($$->nd_next, $3->nd_next);
+                  }
+                ;
+
+f_label         : tLABEL
+                  {
+                    arg_var(formal_argument(get_id($1)));
+                    $$ = $1;
+                  }
+                ;
+
+f_kw            : f_label arg_value
+                  {
+                    $$ = assignable($1, $2);
+                    $$ = NEW_KW_ARG(0, $$);
+                  }
+                | f_label
+                  {
+                    $$ = assignable($1, NEW_REQ_KW);
+                    $$ = NEW_KW_ARG(0, $$);
+                  }
+                ;
+
+f_block_kw      : f_label primary_value
+                  {
+                    $$ = assignable($1, $2);
+                    $$ = NEW_KW_ARG(0, $$);
+                  }
+                | f_label
+                  {
+                    $$ = assignable($1, NEW_REQ_KW);
+                    $$ = NEW_KW_ARG(0, $$);
+                  }
+                ;
+
+f_block_kwarg   : f_block_kw
+                  {
+                    $$ = $1;
+                  }
+                | f_block_kwarg ',' f_block_kw
+                  {
+                    NODE *kws = $1;
+                    while (kws->nd_next) {
+                      kws = kws->nd_next;
+                    }
+                    kws->nd_next = $3;
+                    $$ = $1;
+                  }
+                ;
+
+f_kwarg         : f_kw
+                  {
+                    $$ = $1;
+                  }
+                | f_kwarg ',' f_kw
                   {
-                    ID tid = internal_id();
-                    arg_var(tid);
-                    $2->nd_value = NEW_LVAR(tid);
-                    $$ = NEW_ARGS_AUX(tid, 1);
-                    $$->nd_next = $2;
+                    NODE *kws = $1;
+                    while (kws->nd_next) {
+                      kws = kws->nd_next;
+                    }
+                    kws->nd_next = $3;
+                    $$ = $1;
                   }
                 ;
 
-f_arg           : f_arg_item
-                | f_arg ',' f_arg_item
+kwrest_mark     : tPOW
+                | tDSTAR
+                ;
+
+f_kwrest        : kwrest_mark tIDENTIFIER
                   {
-                    $$ = $1;
-                    $$->nd_plen++;
-                    $$->nd_next = block_append($$->nd_next, $3->nd_next);
+                    shadowing_lvar(get_id($2));
+                    $$ = $2;
+                  }
+                | kwrest_mark
+                  {
+                    $$ = internal_id();
                   }
                 ;
 
-f_opt           : tIDENTIFIER '=' arg_value
+f_opt           : f_norm_arg '=' arg_value
                   {
-                    arg_var(formal_argument(get_id($1)));
+                    arg_var(get_id($1));
                     $$ = assignable($1, $3);
                     $$ = NEW_OPT_ARG(0, $$);
                   }
                 ;
 
-f_block_opt     : tIDENTIFIER '=' primary_value
+f_block_opt     : f_norm_arg '=' primary_value
                   {
-                    arg_var(formal_argument(get_id($1)));
+                    arg_var(get_id($1));
                     $$ = assignable($1, $3);
                     $$ = NEW_OPT_ARG(0, $$);
                   }
@@ -3048,6 +3232,10 @@ assoc           : arg_value tASSOC arg_value
                   {
                     $$ = list_append(NEW_LIST(NEW_LIT(ID2SYM($1))), $2);
                   }
+                | tDSTAR arg_value
+                  {
+                    $$ = list_append(NEW_LIST(0), $2);
+                  }
                 ;
 
 operation       : tIDENTIFIER
@@ -3114,21 +3302,24 @@ static int parser_here_document(rb_parser_state*, NODE*);
 
 
 #define nextc()                   parser_nextc(parser_state)
-#define pushback(c)               parser_pushback(parser_state, c)
+#define pushback(c)               parser_pushback(parser_state, (c))
 #define newtok()                  parser_newtok(parser_state)
-#define tokspace(n)               parser_tokspace(parser_state, n)
-#define tokadd(c)                 parser_tokadd(parser_state, c)
-#define tok_hex(numlen)           parser_tok_hex(parser_state, numlen)
-#define read_escape(flags,e)      parser_read_escape(parser_state, flags, e)
-#define tokadd_escape(e)          parser_tokadd_escape(parser_state, e)
+#define tokspace(n)               parser_tokspace(parser_state, (n))
+#define tokadd(c)                 parser_tokadd(parser_state, (c))
+#define tok_hex(numlen)           parser_tok_hex(parser_state, (numlen))
+#define read_escape(flags,e)      parser_read_escape(parser_state, (flags), (e))
+#define tokadd_escape(e)          parser_tokadd_escape(parser_state, (e))
 #define regx_options()            parser_regx_options(parser_state)
-#define tokadd_string(f,t,p,n,e)  parser_tokadd_string(parser_state,f,t,p,n,e)
-#define parse_string(n)           parser_parse_string(parser_state,n)
-#define tokaddmbc(c, enc)         parser_tokaddmbc(parser_state, c, enc)
-#define here_document(n)          parser_here_document(parser_state,n)
+#define tokadd_string(f,t,p,n,e)  parser_tokadd_string(parser_state, (f), (t), (p), (n), (e))
+#define parse_string(n)           parser_parse_string(parser_state, (n))
+#define tokaddmbc(c, enc)         parser_tokaddmbc(parser_state, (c), (enc))
+#define here_document(n)          parser_here_document(parser_state, (n))
 #define heredoc_identifier()      parser_heredoc_identifier(parser_state)
-#define heredoc_restore(n)        parser_heredoc_restore(parser_state,n)
-#define whole_match_p(e,l,i)      parser_whole_match_p(parser_state,e,l,i)
+#define heredoc_restore(n)        parser_heredoc_restore(parser_state, (n))
+#define whole_match_p(e,l,i)      parser_whole_match_p(parser_state, (e), (l), (i))
+#define number_literal_suffix(f)  parser_number_literal_suffix(parser_state, (f))
+#define set_number_literal(v,t,f) parser_set_number_literal(parser_state, (v), (t), (f))
+#define set_integer_literal(v,f)  parser_set_integer_literal(parser_state, (v), (f))
 
 #define set_yylval_str(x)         yylval.node = NEW_STR(x)
 #define set_yylval_num(x)         yylval.num = x
@@ -3137,6 +3328,8 @@ static int parser_here_document(rb_parser_state*, NODE*);
 #define set_yylval_literal(x)     yylval.node = NEW_LIT(x)
 #define set_yylval_number(x)      yylval.node = NEW_NUMBER(x)
 #define set_yylval_float(x)       yylval.node = NEW_FLOAT(x)
+#define set_yylval_rational(x)    yylval.node = NEW_RATIONAL(x)
+#define set_yylval_imaginary(x)   yylval.node = NEW_IMAGINARY(x)
 #define set_yylval_node(x)        yylval.node = x
 #define yylval_id()               yylval.id
 
@@ -3193,7 +3386,6 @@ yycompile(rb_parser_state* parser_state, char *f, int line)
   compile_for_eval = 0;
   cond_stack = 0;
   cmdarg_stack = 0;
-  command_start = TRUE;
   class_nest = 0;
   in_single = 0;
   in_def = 0;
@@ -3440,8 +3632,6 @@ parser_pushback(rb_parser_state* parser_state, int c)
   lex_p--;
 }
 
-#define pushback(c)   parser_pushback(parser_state, c)
-
 /* Indicates if we're currently at the beginning of a line. */
 #define was_bol() (lex_p == lex_pbeg + 1)
 
@@ -3457,6 +3647,7 @@ static char*
 parser_newtok(rb_parser_state* parser_state)
 {
   tokidx = 0;
+  tokline = sourceline;
   if(!tokenbuf) {
     toksiz = 60;
     tokenbuf = ALLOC_N(char, 60);
@@ -3849,7 +4040,7 @@ parser_tokadd_string(rb_parser_state *parser_state,
   }
 
 #define mixed_escape(beg, enc1, enc2) do {	\
-    char *pos = lex_p;		\
+    const char *pos = lex_p;		\
     lex_p = beg;				\
     mixed_error(enc1, enc2);		\
     lex_p = pos;				\
@@ -3871,7 +4062,7 @@ parser_tokadd_string(rb_parser_state *parser_state,
         break;
       }
     } else if(c == '\\') {
-      char *beg = lex_p - 1;
+      const char *beg = lex_p - 1;
       c = nextc();
       switch(c) {
       case '\n':
@@ -3950,6 +4141,65 @@ parser_tokadd_string(rb_parser_state *parser_state,
   node_newnode(NODE_STRTERM, (VALUE)(func), \
                (VALUE)((term) | ((paren) << (CHAR_BIT * 2))), 0)
 #define pslval ((YYSTYPE *)lval)
+
+#define BIT(c, idx) (((c) / 32 - 1 == idx) ? (1U << ((c) % 32)) : 0)
+#define SPECIAL_PUNCT(idx) ( \
+	BIT('~', idx) | BIT('*', idx) | BIT('$', idx) | BIT('?', idx) | \
+	BIT('!', idx) | BIT('@', idx) | BIT('/', idx) | BIT('\\', idx) | \
+	BIT(';', idx) | BIT(',', idx) | BIT('.', idx) | BIT('=', idx) | \
+	BIT(':', idx) | BIT('<', idx) | BIT('>', idx) | BIT('\"', idx) | \
+	BIT('&', idx) | BIT('`', idx) | BIT('\'', idx) | BIT('+', idx) | \
+	BIT('0', idx))
+const unsigned int ruby_global_name_punct_bits[] = {
+    SPECIAL_PUNCT(0),
+    SPECIAL_PUNCT(1),
+    SPECIAL_PUNCT(2),
+};
+#undef BIT
+#undef SPECIAL_PUNCT
+
+static inline int
+is_global_name_punct(const int c)
+{
+  if(c <= 0x20 || 0x7e < c) return 0;
+  return (ruby_global_name_punct_bits[(c - 0x20) / 32] >> (c % 32)) & 1;
+}
+
+static int
+parser_peek_variable_name(rb_parser_state* parser_state)
+{
+  int c;
+  const char *p = lex_p;
+
+  if(p + 1 >= lex_pend) return 0;
+  c = *p++;
+  switch(c) {
+  case '$':
+    if((c = *p) == '-') {
+      if (++p >= lex_pend) return 0;
+      c = *p;
+    } else if(is_global_name_punct(c) || ISDIGIT(c)) {
+      return tSTRING_DVAR;
+    }
+    break;
+  case '@':
+    if((c = *p) == '@') {
+      if(++p >= lex_pend) return 0;
+      c = *p;
+    }
+    break;
+  case '{':
+    lex_p = p;
+    command_start = TRUE;
+    return tSTRING_DBEG;
+  default:
+    return 0;
+  }
+  if(!ISASCII(c) || c == '_' || ISALPHA(c)) return tSTRING_DVAR;
+
+  return 0;
+}
+
 static int
 parser_parse_string(rb_parser_state* parser_state, NODE *quote)
 {
@@ -3982,15 +4232,10 @@ parser_parse_string(rb_parser_state* parser_state, NODE *quote)
   }
   newtok();
   if((func & STR_FUNC_EXPAND) && c == '#') {
-    switch(c = nextc()) {
-    case '$':
-    case '@':
-      pushback(c);
-      return tSTRING_DVAR;
-    case '{':
-      return tSTRING_DBEG;
-    }
+    int t = parser_peek_variable_name(parser_state);
+    if(t) return t;
     tokadd('#');
+    c = nextc();
   }
   pushback(c);
   if(tokadd_string(func, term, paren, &quote->nd_nest, &enc) == -1) {
@@ -4103,6 +4348,7 @@ parser_heredoc_restore(rb_parser_state* parser_state, NODE *here)
 {
   VALUE line;
 
+  lex_strterm = 0;
   line = here->nd_orig;
   lex_lastline = line;
   lex_pbeg = RSTRING_PTR(line);
@@ -4115,16 +4361,93 @@ parser_heredoc_restore(rb_parser_state* parser_state, NODE *here)
 static int
 parser_whole_match_p(rb_parser_state* parser_state, const char *eos, ssize_t len, int indent)
 {
-  char *p = lex_pbeg;
+  const char *p = lex_pbeg;
   ssize_t 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 FALSE;
-  if(strncmp(eos, p, len) == 0) return TRUE;
-  return FALSE;
+  if(n < 0) return FALSE;
+  if(n > 0 && p[len] != '\n') {
+    if(p[len] != '\r') return FALSE;
+    if(n <= 1 || p[len+1] != '\n') return FALSE;
+  }
+  return strncmp(eos, p, len) == 0;
+}
+
+#define NUM_SUFFIX_R   (1<<0)
+#define NUM_SUFFIX_I   (1<<1)
+#define NUM_SUFFIX_ALL 3
+
+static int
+parser_number_literal_suffix(rb_parser_state* parser_state, int mask)
+{
+  int c, result = 0;
+  const char *lastp = lex_p;
+
+  while((c = nextc()) != -1) {
+    if((mask & NUM_SUFFIX_I) && c == 'i') {
+      result |= (mask & NUM_SUFFIX_I);
+      mask &= ~NUM_SUFFIX_I;
+      /* r after i, rational of complex is disallowed */
+      mask &= ~NUM_SUFFIX_R;
+      continue;
+    }
+    if((mask & NUM_SUFFIX_R) && c == 'r') {
+      result |= (mask & NUM_SUFFIX_R);
+      mask &= ~NUM_SUFFIX_R;
+      continue;
+    }
+    if(!ISASCII(c) || ISALPHA(c) || c == '_') {
+      lex_p = lastp;
+      return 0;
+    }
+    pushback(c);
+    break;
+  }
+
+  return result;
+}
+
+static int
+parser_set_number_literal(rb_parser_state* parser_state, VALUE v, int type, int suffix)
+{
+  if(suffix & NUM_SUFFIX_I) {
+    v = rb_funcall(rb_cObject, rb_intern("Complex"), 2, INT2FIX(0), v);
+    type = tIMAGINARY;
+  }
+
+  switch(type) {
+  case tFLOAT:
+    set_yylval_float(v);
+    break;
+  case tINTEGER:
+    set_yylval_number(v);
+    break;
+  case tRATIONAL:
+    set_yylval_rational(v);
+    break;
+  case tIMAGINARY:
+    set_yylval_imaginary(v);
+    break;
+  default:
+    set_yylval_literal(v);
+    break;
+  }
+
+  return type;
+}
+
+static int
+parser_set_integer_literal(rb_parser_state* parser_state, VALUE v, int suffix)
+{
+  int type = tINTEGER;
+  if (suffix & NUM_SUFFIX_R) {
+    v = rb_funcall(rb_cObject, rb_intern("Rational"), 1, v);
+    type = tRATIONAL;
+  }
+  return set_number_literal(v, type, suffix);
 }
 
 /* Called when the lexer knows it's inside a heredoc. This function
@@ -4135,7 +4458,7 @@ static int
 parser_here_document(rb_parser_state* parser_state, NODE *here)
 {
   int c, func, indent = 0;
-  char *eos, *p, *pend;
+  const char *eos, *p, *pend;
   ssize_t len;
   VALUE str = 0;
   rb_encoding* enc = parser_state->enc;
@@ -4153,7 +4476,6 @@ parser_here_document(rb_parser_state* parser_state, NODE *here)
     rb_compile_error(parser_state, "can't find string \"%s\" anywhere before EOF", eos);
   restore:
     heredoc_restore(lex_strterm);
-    lex_strterm = 0;
     return 0;
   }
   /* Gr. not yet sure what was_bol() means other than it seems like
@@ -4196,15 +4518,10 @@ parser_here_document(rb_parser_state* parser_state, NODE *here)
   } else {
     newtok();
     if(c == '#') {
-      switch(c = nextc()) {
-      case '$':
-      case '@':
-        pushback(c);
-        return tSTRING_DVAR;
-      case '{':
-        return tSTRING_DBEG;
-      }
+      int t = parser_peek_variable_name(parser_state);
+      if(t) return t;
       tokadd('#');
+      c = nextc();
     }
 
     /* Loop while we haven't found a the heredoc ident. */
@@ -4245,8 +4562,6 @@ arg_ambiguous()
   return 1;
 }
 
-#define IS_ARG() (lex_state == EXPR_ARG || lex_state == EXPR_CMDARG)
-
 static ID
 parser_formal_argument(rb_parser_state* parser_state, ID lhs)
 {
@@ -4535,33 +4850,28 @@ parser_prepare(rb_parser_state* parser_state)
   parser_state->enc = parser_enc_get(lex_lastline);
 }
 
-#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))
-#define IS_LABEL_POSSIBLE() ((lex_state == EXPR_BEG && !cmd_state) || IS_ARG())
-#define IS_LABEL_SUFFIX(n) (peek_n(':',(n)) && !peek_n(':', (n)+1))
+#define IS_ARG()              lex_state_p(EXPR_ARG_ANY)
+#define IS_END()              lex_state_p(EXPR_END_ANY)
+#define IS_BEG()              lex_state_p(EXPR_BEG_ANY)
+#define IS_SPCARG(c)          (IS_ARG() && space_seen && !ISSPACE(c))
+#define IS_LABEL_POSSIBLE()   ((lex_state_p(EXPR_BEG | EXPR_ENDFN) && !cmd_state) \
+                                || IS_ARG())
+#define IS_LABEL_SUFFIX(n)    (peek_n(':',(n)) && !peek_n(':', (n)+1))
+#define IS_AFTER_OPERATOR()   lex_state_p(EXPR_FNAME | EXPR_DOT)
 
 #define ambiguous_operator(op, syn) ( \
-    rb_warning0("`"op"' after local variable is interpreted as binary operator"), \
-    rb_warning0("even though it seems like "syn""))
-#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))
+    rb_warning0("`" op "' after local variable is interpreted as binary operator"), \
+    rb_warning0("even though it seems like " syn ""))
+#define warn_balanced(op, syn) ((void) \
+    (!lex_state_of_p(last_state, \
+      EXPR_CLASS|EXPR_DOT|EXPR_FNAME|EXPR_ENDFN|EXPR_ENDARG) && \
+    space_seen && !ISSPACE(c) && \
+    (ambiguous_operator(op, syn), 0)))
 
 static int
 parser_yylex(rb_parser_state *parser_state)
 {
-  register int c;
+  int c;
   int space_seen = 0;
   int cmd_state;
   enum lex_state_e last_state;
@@ -4614,15 +4924,8 @@ retry:
     lex_p = lex_pend;
     /* fall through */
   case '\n':
-    switch(lex_state) {
-    case EXPR_BEG:
-    case EXPR_FNAME:
-    case EXPR_DOT:
-    case EXPR_CLASS:
-    case EXPR_VALUE:
+    if(lex_state_p(EXPR_BEG | EXPR_VALUE | EXPR_CLASS | EXPR_FNAME | EXPR_DOT)) {
       goto retry;
-    default:
-      break;
     }
 
     while((c = nextc())) {
@@ -4660,7 +4963,15 @@ retry:
         return tOP_ASGN;
       }
       pushback(c);
-      c = tPOW;
+      if (IS_SPCARG(c)) {
+        rb_warning0("`**' interpreted as argument prefix");
+        c = tDSTAR;
+      } else if (IS_BEG()) {
+        c = tDSTAR;
+      } else {
+        warn_balanced("**", "argument prefix");
+        c = tPOW;
+      }
     } else {
       if(c == '=') {
         set_yylval_id('*');
@@ -4678,17 +4989,12 @@ retry:
         c = '*';
       }
     }
-    switch(lex_state) {
-    case EXPR_FNAME: case EXPR_DOT:
-      lex_state = EXPR_ARG; break;
-    default:
-      lex_state = EXPR_BEG; break;
-    }
+    lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
     return c;
 
   case '!':
     c = nextc();
-    if(lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
+    if(IS_AFTER_OPERATOR()) {
       lex_state = EXPR_ARG;
       if(c == '@') {
         return '!';
@@ -4727,12 +5033,7 @@ retry:
       }
     }
 
-    switch(lex_state) {
-    case EXPR_FNAME: case EXPR_DOT:
-      lex_state = EXPR_ARG; break;
-    default:
-      lex_state = EXPR_BEG; break;
-    }
+    lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
     if((c = nextc()) == '=') {
       if((c = nextc()) == '=') {
         return tEQQ;
@@ -4752,18 +5053,19 @@ retry:
     last_state = lex_state;
     c = nextc();
     if(c == '<' &&
-      lex_state != EXPR_DOT &&
-      lex_state != EXPR_CLASS &&
+      !lex_state_p(EXPR_DOT | EXPR_CLASS) &&
       !IS_END() &&
       (!IS_ARG() || space_seen)) {
       int token = heredoc_identifier();
       if(token) return token;
     }
-    switch(lex_state) {
-    case EXPR_FNAME: case EXPR_DOT:
-      lex_state = EXPR_ARG; break;
-    default:
-      lex_state = EXPR_BEG; break;
+    if(IS_AFTER_OPERATOR()) {
+      lex_state = EXPR_ARG;
+    } else {
+      if(lex_state_p(EXPR_CLASS)) {
+        command_start = TRUE;
+      }
+      lex_state = EXPR_BEG;
     }
     if(c == '=') {
       if((c = nextc()) == '>') {
@@ -4786,12 +5088,7 @@ retry:
     return '<';
 
   case '>':
-    switch(lex_state) {
-    case EXPR_FNAME: case EXPR_DOT:
-      lex_state = EXPR_ARG; break;
-    default:
-      lex_state = EXPR_BEG; break;
-    }
+    lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
     if((c = nextc()) == '=') {
       return tGEQ;
     }
@@ -4812,15 +5109,16 @@ retry:
     return tSTRING_BEG;
 
   case '`':
-    if(lex_state == EXPR_FNAME) {
+    if(lex_state_p(EXPR_FNAME)) {
       lex_state = EXPR_ENDFN;
       return c;
     }
-    if(lex_state == EXPR_DOT) {
-      if(cmd_state)
+    if(lex_state_p(EXPR_DOT)) {
+      if(cmd_state) {
         lex_state = EXPR_CMDARG;
-      else
+      } else {
         lex_state = EXPR_ARG;
+      }
       return c;
     }
     lex_strterm = NEW_STRTERM(str_xquote, '`', 0);
@@ -4929,13 +5227,7 @@ retry:
       warn_balanced("&", "argument prefix");
       c = '&';
     }
-    switch(lex_state) {
-    case EXPR_FNAME: case EXPR_DOT:
-      lex_state = EXPR_ARG;
-      break;
-    default:
-      lex_state = EXPR_BEG;
-    }
+    lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
     return c;
 
   case '|':
@@ -4954,17 +5246,13 @@ retry:
       lex_state = EXPR_BEG;
       return tOP_ASGN;
     }
-    if(lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
-      lex_state = EXPR_ARG;
-    } else {
-      lex_state = EXPR_BEG;
-    }
+    lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
     pushback(c);
     return '|';
 
   case '+':
     c = nextc();
-    if(lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
+    if(IS_AFTER_OPERATOR()) {
       lex_state = EXPR_ARG;
       if(c == '@') {
         return tUPLUS;
@@ -4993,7 +5281,7 @@ retry:
 
   case '-':
     c = nextc();
-    if(lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
+    if(IS_AFTER_OPERATOR()) {
       lex_state = EXPR_ARG;
       if(c == '@') {
         return tUMINUS;
@@ -5007,7 +5295,7 @@ retry:
       return tOP_ASGN;
     }
     if(c == '>') {
-      lex_state = EXPR_ARG;
+      lex_state = EXPR_ENDFN;
       return tLAMBDA;
     }
     if(IS_BEG() || (IS_SPCARG(c) && arg_ambiguous())) {
@@ -5043,7 +5331,7 @@ retry:
   case '0': case '1': case '2': case '3': case '4':
   case '5': case '6': case '7': case '8': case '9':
     {
-      int is_float, seen_point, seen_e, nondigit;
+      int is_float, seen_point, seen_e, nondigit, suffix;
 
       is_float = seen_point = seen_e = nondigit = 0;
       lex_state = EXPR_END;
@@ -5078,8 +5366,8 @@ retry:
           } else if(nondigit) {
             goto trailing_uc;
           }
-          set_yylval_number(rb_cstr_to_inum(tok(), 16, FALSE));
-          return tINTEGER;
+          suffix = number_literal_suffix(NUM_SUFFIX_ALL);
+          return set_integer_literal(rb_cstr_to_inum(tok(), 16, FALSE), suffix);
         }
 
         if(c == 'b' || c == 'B') {
@@ -5104,8 +5392,8 @@ retry:
           } else if(nondigit) {
             goto trailing_uc;
           }
-          set_yylval_number(rb_cstr_to_inum(tok(), 2, FALSE));
-          return tINTEGER;
+          suffix = number_literal_suffix(NUM_SUFFIX_ALL);
+          return set_integer_literal(rb_cstr_to_inum(tok(), 2, FALSE), suffix);
         }
 
         if(c == 'd' || c == 'D') {
@@ -5130,8 +5418,8 @@ retry:
           } else if(nondigit) {
             goto trailing_uc;
           }
-          set_yylval_number(rb_cstr_to_inum(tok(), 10, FALSE));
-          return tINTEGER;
+          suffix = number_literal_suffix(NUM_SUFFIX_ALL);
+          return set_integer_literal(rb_cstr_to_inum(tok(), 10, FALSE), suffix);
         }
 
         if(c == '_') {
@@ -5166,8 +5454,8 @@ retry:
             pushback(c);
             tokfix();
             if(nondigit) goto trailing_uc;
-            set_yylval_number(rb_cstr_to_inum(tok(), 8, FALSE));
-            return tINTEGER;
+            suffix = number_literal_suffix(NUM_SUFFIX_ALL);
+            return set_integer_literal(rb_cstr_to_inum(tok(), 8, FALSE), suffix);
           }
           if(nondigit) {
             pushback(c);
@@ -5182,8 +5470,8 @@ retry:
           tokadd('0');
         } else {
           pushback(c);
-          set_yylval_number(INT2FIX(0));
-          return tINTEGER;
+          suffix = number_literal_suffix(NUM_SUFFIX_ALL);
+          return set_integer_literal(INT2FIX(0), suffix);
         }
       }
 
@@ -5207,10 +5495,10 @@ retry:
             }
             c = c0;
           }
+          seen_point = toklen();
           tokadd('.');
           tokadd(c);
           is_float++;
-          seen_point++;
           nondigit = 0;
           break;
 
@@ -5224,14 +5512,18 @@ retry:
           if(seen_e) {
             goto decode_num;
           }
-          tokadd(c);
-          seen_e++;
-          is_float++;
           nondigit = c;
           c = nextc();
-          if(c != '-' && c != '+') continue;
+          if(c != '-' && c != '+' && !ISDIGIT(c)) {
+            pushback(c);
+            nondigit = 0;
+            goto decode_num;
+          }
+          tokadd(nondigit);
+          seen_e++;
+          is_float++;
           tokadd(c);
-          nondigit = c;
+          nondigit = (c == '-' || c == '+') ? c : 0;
           break;
 
         case '_':      /* `_' in number just ignored */
@@ -5255,16 +5547,30 @@ retry:
     }
     tokfix();
     if(is_float) {
-      double d = strtod(tok(), 0);
-      if(errno == ERANGE) {
-        rb_warningS("Float %s out of range", tok());
-        errno = 0;
+      int type = tFLOAT;
+      VALUE v;
+
+      suffix = number_literal_suffix(seen_e ? NUM_SUFFIX_I : NUM_SUFFIX_ALL);
+      if(suffix & NUM_SUFFIX_R) {
+        char *point = &tok()[seen_point];
+        size_t fraclen = toklen()-seen_point-1;
+        type = tRATIONAL;
+        memmove(point, point+1, fraclen+1);
+        v = rb_cstr_to_inum(tok(), 10, FALSE);
+        v = rb_rational_new(v,
+              rb_funcall(INT2FIX(10), rb_intern("**"), 1, INT2NUM(fraclen)));
+      } else {
+        double d = strtod(tok(), 0);
+        if(errno == ERANGE) {
+          rb_warningS("Float %s out of range", tok());
+          errno = 0;
+        }
+        v = rb_float_new(d);
       }
-      set_yylval_float(rb_float_new(d));
-      return tFLOAT;
+      return set_number_literal(v, type, suffix);
     }
-    set_yylval_number(rb_cstr_to_inum(tok(), 10, FALSE));
-    return tINTEGER;
+    suffix = number_literal_suffix(NUM_SUFFIX_ALL);
+    return set_integer_literal(rb_cstr_to_inum(tok(), 10, FALSE), suffix);
   }
 
   case ')':
@@ -5278,12 +5584,15 @@ retry:
     } else {
       lex_state = EXPR_ENDARG;
     }
+    if(c == '}') {
+      if (!brace_nest--) c = tSTRING_DEND;
+    }
     return c;
 
   case ':':
     c = nextc();
     if(c == ':') {
-      if(IS_BEG() || lex_state == EXPR_CLASS || IS_SPCARG(-1)) {
+      if(IS_BEG() || lex_state_p(EXPR_CLASS) || IS_SPCARG(-1)) {
         lex_state = EXPR_BEG;
         return tCOLON3;
       }
@@ -5311,7 +5620,7 @@ retry:
     return tSYMBEG;
 
   case '/':
-    if(IS_BEG()) {
+    if(lex_state_p(EXPR_BEG_ANY)) {
       lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
       return tREGEXP_BEG;
     }
@@ -5326,14 +5635,7 @@ retry:
       lex_strterm = NEW_STRTERM(str_regexp, '/', 0);
       return tREGEXP_BEG;
     }
-    switch(lex_state) {
-    case EXPR_FNAME: case EXPR_DOT:
-      lex_state = EXPR_ARG;
-      break;
-    default:
-      lex_state = EXPR_BEG;
-      break;
-    }
+    lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
     warn_balanced("/", "regexp literal");
     return '/';
 
@@ -5343,14 +5645,7 @@ retry:
       lex_state = EXPR_BEG;
       return tOP_ASGN;
     }
-    switch(lex_state) {
-    case EXPR_FNAME: case EXPR_DOT:
-      lex_state = EXPR_ARG;
-      break;
-    default:
-      lex_state = EXPR_BEG;
-      break;
-    }
+    lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
     pushback(c);
     return '^';
 
@@ -5358,12 +5653,13 @@ retry:
     lex_state = EXPR_BEG;
     command_start = TRUE;
     return ';';
+
   case ',':
     lex_state = EXPR_BEG;
     return ',';
 
   case '~':
-    if(lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
+    if(IS_AFTER_OPERATOR()) {
       if((c = nextc()) != '@') {
         pushback(c);
       }
@@ -5387,7 +5683,7 @@ retry:
 
   case '[':
     paren_nest++;
-    if(lex_state == EXPR_FNAME || lex_state == EXPR_DOT) {
+    if(IS_AFTER_OPERATOR()) {
       lex_state = EXPR_ARG;
       if((c = nextc()) == ']') {
         if((c = nextc()) == '=') {
@@ -5409,6 +5705,7 @@ retry:
     return c;
 
   case '{':
+    ++brace_nest;
     if(lpar_beg && lpar_beg == paren_nest) {
       lex_state = EXPR_BEG;
       lpar_beg = 0;
@@ -5417,12 +5714,13 @@ retry:
       CMDARG_PUSH(0);
       return tLAMBEG;
     }
-    if(IS_ARG() || lex_state == EXPR_END || lex_state == EXPR_ENDFN)
+    if(IS_ARG() || lex_state_p(EXPR_END | EXPR_ENDFN)) {
       c = '{';          /* block (primary) */
-    else if(lex_state == EXPR_ENDARG)
+    } else if(lex_state_p(EXPR_ENDARG)) {
       c = tLBRACE_ARG;  /* block (expr) */
-    else
+    } else {
       c = tLBRACE;      /* hash */
+    }
     COND_PUSH(0);
     CMDARG_PUSH(0);
     lex_state = EXPR_BEG;
@@ -5439,7 +5737,7 @@ retry:
     return '\\';
 
   case '%':
-    if(IS_BEG()) {
+    if(lex_state_p(EXPR_BEG_ANY)) {
       intptr_t term;
       intptr_t paren;
 
@@ -5487,6 +5785,18 @@ retry:
         pushback(c);
         return tQWORDS_BEG;
 
+      case 'I':
+        lex_strterm = NEW_STRTERM(str_dword, term, paren);
+        do {c = nextc();} while (ISSPACE(c));
+        pushback(c);
+        return tSYMBOLS_BEG;
+
+      case 'i':
+        lex_strterm = NEW_STRTERM(str_sword, term, paren);
+        do {c = nextc();} while (ISSPACE(c));
+        pushback(c);
+        return tQSYMBOLS_BEG;
+
       case 'x':
         lex_strterm = NEW_STRTERM(str_xquote, term, paren);
         return tXSTRING_BEG;
@@ -5513,14 +5823,7 @@ retry:
     if(IS_SPCARG(c)) {
       goto quotation;
     }
-    switch(lex_state) {
-    case EXPR_FNAME: case EXPR_DOT:
-      lex_state = EXPR_ARG;
-      break;
-    default:
-      lex_state = EXPR_BEG;
-      break;
-    }
+    lex_state = IS_AFTER_OPERATOR() ? EXPR_ARG : EXPR_BEG;
     pushback(c);
     warn_balanced("%%", "string literal");
     return '%';
@@ -5558,9 +5861,7 @@ retry:
     case '\"':  /* $": already loaded files */
       tokadd('$');
       tokadd(c);
-      tokfix();
-      set_yylval_name(parser_intern(tok()));
-      return tGVAR;
+      goto gvar;
 
     case '-':
       tokadd('$');
@@ -5570,9 +5871,12 @@ retry:
         if(tokadd_mbchar(c) == -1) return 0;
       } else {
         pushback(c);
+        pushback('-');
+        return '$';
       }
     gvar:
       tokfix();
+      // TODO rb_intern3(tok(), tokidx, current_enc);
       set_yylval_name(parser_intern(tok()));
       return tGVAR;
 
@@ -5580,7 +5884,7 @@ retry:
     case '`':             /* $`: string before last match */
     case '\'':            /* $': string after last match */
     case '+':             /* $+: string matches last paren. */
-      if(last_state == EXPR_FNAME) {
+      if(lex_state_of_p(last_state, EXPR_FNAME)) {
         tokadd('$');
         tokadd(c);
         goto gvar;
@@ -5597,7 +5901,7 @@ retry:
         c = nextc();
       } while(c != -1 && ISDIGIT(c));
       pushback(c);
-      if(last_state == EXPR_FNAME) goto gvar;
+      if(lex_state_of_p(last_state, EXPR_FNAME)) goto gvar;
       tokfix();
       set_yylval_node(NEW_NTH_REF(atoi(tok()+1)));
       return tNTH_REF;
@@ -5605,7 +5909,9 @@ retry:
     default:
       if(!parser_is_identchar()) {
         pushback(c);
-        return '$';
+        rb_compile_error(parser_state,
+                         "`$%c' is not allowed as a global variable name", c);
+        return 0;
       }
     case '0':
       tokadd('$');
@@ -5620,7 +5926,7 @@ retry:
       tokadd('@');
       c = nextc();
     }
-    if(c != -1 && ISDIGIT(c)) {
+    if(c != -1 && (ISDIGIT(c) || !parser_is_identchar())) {
       if(tokidx == 1) {
         rb_compile_error(parser_state,
                          "`@%c' is not allowed as an instance variable name", c);
@@ -5630,10 +5936,6 @@ retry:
       }
       return 0;
     }
-    if(!parser_is_identchar()) {
-      pushback(c);
-      return '@';
-    }
     break;
 
   case '_':
@@ -5694,7 +5996,7 @@ retry:
       if(toklast() == '!' || toklast() == '?') {
         result = tFID;
       } else {
-        if(lex_state == EXPR_FNAME) {
+        if(lex_state_p(EXPR_FNAME)) {
           if((c = nextc()) == '=' && !peek('~') && !peek('>') &&
               (!peek('=') || (peek_n('>', 1)))) {
             result = tIDENTIFIER;
@@ -5727,25 +6029,27 @@ retry:
         if(kw) {
           enum lex_state_e state = lex_state;
           lex_state = kw->state;
-          if(state == EXPR_FNAME) {
+          if(lex_state_of_p(state, EXPR_FNAME)) {
             set_yylval_name(parser_intern(kw->name));
             return kw->id[0];
           }
-          if(kw->id[0] == keyword_do) {
+          if(lex_state_p(EXPR_BEG)) {
             command_start = TRUE;
+          }
+          if(kw->id[0] == keyword_do) {
             if(lpar_beg && lpar_beg == paren_nest) {
               lpar_beg = 0;
               --paren_nest;
               return keyword_do_LAMBDA;
             }
             if(COND_P()) return keyword_do_cond;
-            if(CMDARG_P() && state != EXPR_CMDARG)
+            if(CMDARG_P() && !lex_state_of_p(state, EXPR_CMDARG))
               return keyword_do_block;
-            if(state == EXPR_ENDARG || state == EXPR_BEG)
+            if(lex_state_of_p(state, EXPR_BEG | EXPR_ENDARG))
               return keyword_do_block;
             return keyword_do;
           }
-          if(state == EXPR_BEG || state == EXPR_VALUE)
+          if(lex_state_of_p(state, EXPR_BEG | EXPR_VALUE))
             return kw->id[0];
           else {
             if(kw->id[0] != kw->id[1])
@@ -5755,9 +6059,7 @@ retry:
         }
       }
 
-      if(IS_BEG() ||
-          lex_state == EXPR_DOT ||
-          IS_ARG()) {
+      if(lex_state_p(EXPR_BEG_ANY | EXPR_ARG_ANY | EXPR_DOT)) {
         if(cmd_state) {
           lex_state = EXPR_CMDARG;
         } else {
@@ -5773,7 +6075,7 @@ retry:
       ID ident = TOK_INTERN(!ENC_SINGLE(mb));
 
       set_yylval_name(ident);
-      if(last_state != EXPR_DOT && last_state != EXPR_FNAME &&
+      if(!lex_state_of_p(last_state, EXPR_DOT | EXPR_FNAME) &&
           is_local_id(ident) && lvar_defined(ident)) {
         lex_state = EXPR_END;
       }
@@ -6031,6 +6333,8 @@ static NODE *
 parser_literal_concat(rb_parser_state* parser_state, NODE *head, NODE *tail)
 {
   enum node_type htype;
+  NODE *headlast;
+  VALUE lit;
 
   if(!head) return tail;
   if(!tail) return head;
@@ -6039,11 +6343,20 @@ parser_literal_concat(rb_parser_state* parser_state, NODE *head, NODE *tail)
   if(htype == NODE_EVSTR) {
     NODE *node = NEW_DSTR(STR_NEW0());
     head = list_append(node, head);
+    htype = NODE_DSTR;
   }
   switch(nd_type(tail)) {
   case NODE_STR:
+    if(htype == NODE_DSTR
+       && (headlast = head->nd_next->nd_end->nd_head)
+       && nd_type(headlast) == NODE_STR) {
+      htype = NODE_STR;
+      lit = headlast->nd_lit;
+    } else {
+      lit = head->nd_lit;
+    }
     if(htype == NODE_STR) {
-      if(!literal_concat0(head->nd_lit, tail->nd_lit)) {
+      if(!literal_concat0(lit, tail->nd_lit)) {
       error:
         return 0;
       }
@@ -6059,9 +6372,18 @@ parser_literal_concat(rb_parser_state* parser_state, NODE *head, NODE *tail)
       tail->nd_lit = head->nd_lit;
       head = tail;
     } else if(NIL_P(tail->nd_lit)) {
+    append:
       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;
+    } else if(htype == NODE_DSTR
+              && (headlast = head->nd_next->nd_end->nd_head)
+              && nd_type(headlast) == NODE_STR) {
+      lit = headlast->nd_lit;
+      if (!literal_concat0(lit, tail->nd_lit))
+      goto error;
+      tail->nd_lit = Qnil;
+      goto append;
     } else {
       nd_set_type(tail, NODE_ARRAY);
       tail->nd_head = NEW_STR(tail->nd_lit);
@@ -6125,6 +6447,7 @@ static const struct {
   {tDOT2,	  ".."},
   {tDOT3,	  "..."},
   {tPOW,	  "**"},
+  {tDSTAR,  "**"},
   {tUPLUS,	"+@"},
   {tUMINUS,	"-@"},
   {tCMP,	  "<=>"},
@@ -6379,8 +6702,6 @@ parser_aryset(rb_parser_state* parser_state, NODE *recv, NODE *idx)
 {
   if(recv && nd_type(recv) == NODE_SELF) {
     recv = (NODE *)1;
-  } else {
-    value_expr(recv);
   }
   return NEW_ATTRASGN(recv, convert_op(tASET), idx);
 }
@@ -6393,9 +6714,44 @@ parser_block_dup_check(rb_parser_state* parser_state, NODE *node1, NODE *node2)
   }
 }
 
+static const char id_type_names[][9] = {
+  "LOCAL",
+  "INSTANCE",
+  "",				/* INSTANCE2 */
+  "GLOBAL",
+  "ATTRSET",
+  "CONST",
+  "CLASS",
+  "JUNK",
+};
+
 static ID
 rb_id_attrset(ID id)
 {
+  if(!is_notop_id(id)) {
+    switch (id) {
+    case tAREF:
+    case tASET:
+      return tASET;	/* only exception */
+    }
+    rb_name_error(id, "cannot make operator ID :%s attrset", rb_id2name(id));
+  } else {
+    int scope = (int)(id & ID_SCOPE_MASK);
+    switch(scope) {
+    case ID_LOCAL:
+    case ID_INSTANCE:
+    case ID_GLOBAL:
+    case ID_CONST:
+    case ID_CLASS:
+    case ID_JUNK:
+      break;
+    case ID_ATTRSET:
+      return id;
+    default:
+      rb_name_error(id, "cannot make %s ID %+ld attrset",
+                    id_type_names[scope], ID2SYM(id));
+    }
+  }
   id &= ~ID_SCOPE_MASK;
   id |= ID_ATTRSET;
   return id;
@@ -6448,18 +6804,6 @@ parser_arg_append(rb_parser_state* parser_state, NODE *node1, NODE *node2)
   return NEW_ARGSPUSH(node1, node2);
 }
 
-static NODE *
-arg_add(rb_parser_state* parser_state, NODE *node1, NODE *node2)
-{
-  if(!node1) return NEW_LIST(node2);
-  if(nd_type(node1) == NODE_ARRAY) {
-    return list_append(node1, node2);
-  }
-  else {
-    return NEW_ARGSPUSH(node1, node2);
-  }
-}
-
 static NODE *
 splat_array(NODE* node)
 {
@@ -6473,7 +6817,6 @@ parser_node_assign(rb_parser_state* parser_state, NODE *lhs, NODE *rhs)
 {
   if(!lhs) return 0;
 
-  value_expr(rhs);
   switch(nd_type(lhs)) {
   case NODE_GASGN:
   case NODE_IASGN:
@@ -6482,14 +6825,13 @@ parser_node_assign(rb_parser_state* parser_state, NODE *lhs, NODE *rhs)
   case NODE_DASGN_CURR:
   case NODE_MASGN:
   case NODE_CDECL:
-  case NODE_CVDECL:
   case NODE_CVASGN:
     lhs->nd_value = rhs;
     break;
 
   case NODE_ATTRASGN:
   case NODE_CALL:
-    lhs->nd_args = arg_add(parser_state, lhs->nd_args, rhs);
+    lhs->nd_args = arg_append(lhs->nd_args, rhs);
     break;
 
   default:
@@ -6500,6 +6842,76 @@ parser_node_assign(rb_parser_state* parser_state, NODE *lhs, NODE *rhs)
   return lhs;
 }
 
+static NODE*
+parser_new_op_assign(rb_parser_state* parser_state, NODE *lhs, ID op, NODE *rhs)
+{
+  NODE *asgn;
+
+  if(lhs) {
+    ID vid = lhs->nd_vid;
+    if(op == tOROP) {
+      lhs->nd_value = rhs;
+      asgn = NEW_OP_ASGN_OR(gettable(vid), lhs);
+      if(is_asgn_or_id(vid)) {
+        asgn->nd_aid = vid;
+      }
+    } else if(op == tANDOP) {
+      lhs->nd_value = rhs;
+      asgn = NEW_OP_ASGN_AND(gettable(vid), lhs);
+    } else {
+      asgn = lhs;
+      // TODO: is NEW_LIST(rhs) needed?
+      asgn->nd_value = call_bin_op(gettable(vid), op, rhs);
+    }
+  } else {
+    asgn = NEW_BEGIN(0);
+  }
+
+  return asgn;
+}
+
+static NODE*
+parser_new_attr_op_assign(rb_parser_state* parser_state,
+                          NODE *lhs, ID attr, ID op, NODE *rhs)
+{
+  NODE *asgn;
+
+  if(op == tOROP) {
+    op = 0;
+  } else if(op == tANDOP) {
+    op = 1;
+  } else {
+    op = convert_op(op);
+  }
+  asgn = NEW_OP_ASGN2(lhs, attr, op, rhs);
+  fixpos(asgn, lhs);
+
+  return asgn;
+}
+
+static NODE*
+parser_new_const_op_assign(rb_parser_state* parser_state, NODE *lhs, ID op, NODE *rhs)
+{
+  NODE *asgn;
+
+  if(op == tOROP) {
+    op = 0;
+  } else if(op == tANDOP) {
+    op = 1;
+  } else {
+    op = convert_op(op);
+  }
+
+  if(lhs) {
+    asgn = NEW_OP_CDECL(lhs, op, rhs);
+  } else {
+    asgn = NEW_BEGIN(0);
+  }
+  fixpos(asgn, lhs);
+
+  return asgn;
+}
+
 static int
 parser_value_expr(rb_parser_state* parser_state, NODE *node)
 {
@@ -6511,11 +6923,6 @@ parser_value_expr(rb_parser_state* parser_state, NODE *node)
 
   while(node) {
     switch(nd_type(node)) {
-    case NODE_DEFN:
-    case NODE_DEFS:
-      parser_warning(node, "void value expression");
-      return FALSE;
-
     case NODE_RETURN:
     case NODE_BREAK:
     case NODE_NEXT:
@@ -6899,6 +7306,8 @@ parser_negate_lit(rb_parser_state* parser_state, NODE *node)
     node->nd_lit = LONG2FIX(-FIX2LONG(node->nd_lit));
     break;
   case T_BIGNUM:
+  case T_RATIONAL:
+  case T_COMPLEX:
     node->nd_lit = REF(rb_funcall(node->nd_lit, rb_intern("-@"), 0, 0));
     break;
   case T_FLOAT:
@@ -6921,25 +7330,50 @@ arg_blk_pass(NODE *node1, NODE *node2)
 }
 
 static NODE*
-parser_new_args(rb_parser_state* parser_state, NODE *m, NODE *o, ID r, NODE *p, ID b)
+parser_new_args(rb_parser_state* parser_state, NODE *m, NODE *o, ID r, NODE *p, NODE *tail)
+{
+  int saved_line = sourceline;
+  struct rb_args_info *args = tail->nd_ainfo;
+
+  args->pre_args_num   = m ? rb_long2int(m->nd_plen) : 0;
+  args->pre_init       = m ? m->nd_next : 0;
+
+  args->post_args_num  = p ? rb_long2int(p->nd_plen) : 0;
+  args->post_init      = p ? p->nd_next : 0;
+  args->first_post_arg = p ? p->nd_pid : 0;
+
+  args->rest_arg       = r;
+
+  args->opt_args       = o;
+
+  sourceline = saved_line;
+  return tail;
+}
+
+static NODE*
+parser_new_args_tail(rb_parser_state* parser_state, NODE *k, ID kr, ID b)
 {
   int saved_line = sourceline;
+  struct rb_args_info *args;
+  NODE *kw_rest_arg = 0;
   NODE *node;
-  NODE *i1, *i2 = 0;
 
-  node = NEW_ARGS(m ? m->nd_plen : 0, o);
-  i1 = m ? m->nd_next : 0;
-  node->nd_next = NEW_ARGS_AUX(r, b);
+  args = ALLOC(struct rb_args_info);
+  MEMZERO(args, struct rb_args_info, 1);
+  node = NEW_NODE(NODE_ARGS, 0, 0, args);
 
-  if(p) {
-    i2 = p->nd_next;
-    node->nd_next->nd_next = NEW_ARGS_AUX(p->nd_pid, p->nd_plen);
-  } else if(i1) {
-    node->nd_next->nd_next = NEW_ARGS_AUX(0, 0);
-  }
-  if(i1 || i2) {
-    node->nd_next->nd_next->nd_next = NEW_NODE(NODE_AND, i1, i2, 0);
+  args->block_arg      = b;
+  args->kw_args        = k;
+  if(kr) {
+    if(kr == 1) {
+      kw_rest_arg = (NODE*)kr;
+    } else {
+      arg_var(kr);
+      kw_rest_arg  = NEW_DVAR(kr);
+    }
   }
+  args->kw_rest_arg    = kw_rest_arg;
+
   sourceline = saved_line;
   return node;
 }
@@ -7109,8 +7543,8 @@ parser_id2name(ID id)
 static int
 scan_oct(const char *start, size_t len, size_t *retlen)
 {
-  register const char *s = start;
-  register int retval = 0;
+  const char *s = start;
+  int retval = 0;
 
   while(len-- && *s >= '0' && *s <= '7') {
     retval <<= 3;
@@ -7124,8 +7558,8 @@ static int
 scan_hex(const char *start, size_t len, size_t *retlen)
 {
   static const char hexdigit[] = "0123456789abcdef0123456789ABCDEF";
-  register const char *s = start;
-  register int retval = 0;
+  const char *s = start;
+  int retval = 0;
   const char *tmp;
 
   while(len-- && *s && (tmp = strchr(hexdigit, *s))) {