webruby 0.2.2 → 0.2.4

data/modules/mruby/src/numeric.c

@@ -41,38 +41,6 @@ mrb_to_flo(mrb_state *mrb, mrb_value val)
   return mrb_float(val);
 }
 
-/*
- *  call-seq:
- *     +num  ->  num
- *
- *  Unary Plus---Returns the receiver's value.
- */
-
-static mrb_value
-num_uplus(mrb_state *mrb, mrb_value num)
-{
-  return num;
-}
-
-/*
- *  call-seq:
- *     -num  ->  numeric
- *
- *  Unary Minus---Returns the receiver's value, negated.
- */
-
-static mrb_value
-num_uminus(mrb_state *mrb, mrb_value num)
-{
-  return mrb_float_value(mrb, (mrb_float)0 - mrb_to_flo(mrb, num));
-}
-
-static mrb_value
-fix_uminus(mrb_state *mrb, mrb_value num)
-{
-  return mrb_fixnum_value(0 - mrb_fixnum(num));
-}
-
 /*
  * call-seq:
  *
@@ -131,27 +99,6 @@ num_div(mrb_state *mrb, mrb_value x)
   return mrb_float_value(mrb, mrb_to_flo(mrb, x) / y);
 }
 
-/*
- *  call-seq:
- *     num.abs        ->  numeric
- *     num.magnitude  ->  numeric
- *
- *  Returns the absolute value of <i>num</i>.
- *
- *     12.abs         #=> 12
- *     (-34.56).abs   #=> 34.56
- *     -34.56.abs     #=> 34.56
- */
-
-static mrb_value
-num_abs(mrb_state *mrb, mrb_value num)
-{
-  if (mrb_to_flo(mrb, num) < 0) {
-    return num_uminus(mrb, num);
-  }
-  return num;
-}
-
 /********************************************************************
  *
  * Document-class: Float
@@ -695,42 +642,6 @@ int_to_i(mrb_state *mrb, mrb_value num)
   return num;
 }
 
-/* 15.2.8.3.21 */
-/*
- *  call-seq:
- *     fixnum.next  ->  integer
- *     fixnum.succ  ->  integer
- *
- *  Returns the <code>Integer</code> equal to <i>int</i> + 1.
- *
- *     1.next      #=> 2
- *     (-1).next   #=> 0
- */
-
-static mrb_value
-fix_succ(mrb_state *mrb, mrb_value num)
-{
-  return mrb_fixnum_value(mrb_fixnum(num)+1);
-}
-
-/* 15.2.8.3.19 */
-/*
- *  call-seq:
- *     int.next  ->  integer
- *     int.succ  ->  integer
- *
- *  Returns the <code>Integer</code> equal to <i>int</i> + 1.
- *
- *     1.next      #=> 2
- *     (-1).next   #=> 0
- */
-static mrb_value
-int_succ(mrb_state *mrb, mrb_value num)
-{
-  if (mrb_fixnum_p(num)) return fix_succ(mrb, num);
-  return mrb_funcall(mrb, num, "+", 1, mrb_fixnum_value(1));
-}
-
 #define SQRT_INT_MAX ((mrb_int)1<<((sizeof(mrb_int)*CHAR_BIT-1)/2))
 /*tests if N*N would overflow*/
 #define FIT_SQRT_INT(n) (((n)<SQRT_INT_MAX)&&((n)>=-SQRT_INT_MAX))
@@ -873,6 +784,21 @@ fix_divmod(mrb_state *mrb, mrb_value x)
   }
 }
 
+static mrb_value
+flo_divmod(mrb_state *mrb, mrb_value x)
+{
+  mrb_value y;
+  mrb_float div, mod;
+  mrb_value a, b;
+
+  mrb_get_args(mrb, "o", &y);
+
+  flodivmod(mrb, mrb_float(x), mrb_to_flo(mrb, y), &div, &mod);
+  a = mrb_float_value(mrb, (mrb_int)div);
+  b = mrb_float_value(mrb, mod);
+  return mrb_assoc_new(mrb, a, b);
+}
+
 /* 15.2.8.3.7  */
 /*
  * call-seq:
@@ -1145,7 +1071,7 @@ mrb_flo_to_fixnum(mrb_state *mrb, mrb_value x)
 
   if (mrb_float_p(x)) {
      mrb_raise(mrb, E_TYPE_ERROR, "non float value");
-     z = 0; /* not reached. just supress warnings. */
+     z = 0; /* not reached. just suppress warnings. */
   }
   else {
     mrb_float d = mrb_float(x);
@@ -1359,14 +1285,10 @@ mrb_init_numeric(mrb_state *mrb)
 
   /* Numeric Class */
   numeric = mrb_define_class(mrb, "Numeric",  mrb->object_class);
-  mrb_include_module(mrb, numeric, mrb_class_get(mrb, "Comparable"));
 
-  mrb_define_method(mrb, numeric, "+@",       num_uplus,      MRB_ARGS_REQ(1));  /* 15.2.7.4.1  */
-  mrb_define_method(mrb, numeric, "-@",       num_uminus,     MRB_ARGS_REQ(1));  /* 15.2.7.4.2  */
   mrb_define_method(mrb, numeric, "**",       num_pow,        MRB_ARGS_REQ(1));
   mrb_define_method(mrb, numeric, "/",        num_div,        MRB_ARGS_REQ(1));  /* 15.2.8.3.4  */
   mrb_define_method(mrb, numeric, "quo",      num_div,        MRB_ARGS_REQ(1));  /* 15.2.7.4.5 (x) */
-  mrb_define_method(mrb, numeric, "abs",      num_abs,        MRB_ARGS_NONE());  /* 15.2.7.4.3  */
   mrb_define_method(mrb, numeric, "<=>",      num_cmp,        MRB_ARGS_REQ(1));  /* 15.2.9.3.6  */
 
   /* Integer Class */
@@ -1374,11 +1296,10 @@ mrb_init_numeric(mrb_state *mrb)
   mrb_undef_class_method(mrb, integer, "new");
   mrb_define_method(mrb, integer, "to_i", int_to_i, MRB_ARGS_NONE());              /* 15.2.8.3.24 */
   mrb_define_method(mrb, integer, "to_int", int_to_i, MRB_ARGS_NONE());
-  fixnum = mrb->fixnum_class = mrb_define_class(mrb, "Fixnum", integer);
 
+  fixnum = mrb->fixnum_class = mrb_define_class(mrb, "Fixnum", integer);
   mrb_define_method(mrb, fixnum,  "+",        fix_plus,          MRB_ARGS_REQ(1)); /* 15.2.8.3.1  */
   mrb_define_method(mrb, fixnum,  "-",        fix_minus,         MRB_ARGS_REQ(1)); /* 15.2.8.3.2  */
-  mrb_define_method(mrb, fixnum,  "-@",       fix_uminus,        MRB_ARGS_REQ(1)); /* 15.2.7.4.2  */
   mrb_define_method(mrb, fixnum,  "*",        fix_mul,           MRB_ARGS_REQ(1)); /* 15.2.8.3.3  */
   mrb_define_method(mrb, fixnum,  "%",        fix_mod,           MRB_ARGS_REQ(1)); /* 15.2.8.3.5  */
   mrb_define_method(mrb, fixnum,  "==",       fix_equal,         MRB_ARGS_REQ(1)); /* 15.2.8.3.7  */
@@ -1390,8 +1311,6 @@ mrb_init_numeric(mrb_state *mrb)
   mrb_define_method(mrb, fixnum,  ">>",       fix_rshift,        MRB_ARGS_REQ(1)); /* 15.2.8.3.13 */
   mrb_define_method(mrb, fixnum,  "eql?",     num_eql,           MRB_ARGS_REQ(1)); /* 15.2.8.3.16 */
   mrb_define_method(mrb, fixnum,  "hash",     flo_hash,          MRB_ARGS_NONE()); /* 15.2.8.3.18 */
-  mrb_define_method(mrb, fixnum,  "next",     int_succ,          MRB_ARGS_NONE()); /* 15.2.8.3.19 */
-  mrb_define_method(mrb, fixnum,  "succ",     fix_succ,          MRB_ARGS_NONE()); /* 15.2.8.3.21 */
   mrb_define_method(mrb, fixnum,  "to_f",     fix_to_f,          MRB_ARGS_NONE()); /* 15.2.8.3.23 */
   mrb_define_method(mrb, fixnum,  "to_s",     fix_to_s,          MRB_ARGS_NONE()); /* 15.2.8.3.25 */
   mrb_define_method(mrb, fixnum,  "inspect",  fix_to_s,          MRB_ARGS_NONE());
@@ -1414,6 +1333,7 @@ mrb_init_numeric(mrb_state *mrb)
   mrb_define_method(mrb, fl,      "to_i",      flo_truncate,     MRB_ARGS_NONE()); /* 15.2.9.3.14 */
   mrb_define_method(mrb, fl,      "to_int",    flo_truncate,     MRB_ARGS_NONE());
   mrb_define_method(mrb, fl,      "truncate",  flo_truncate,     MRB_ARGS_NONE()); /* 15.2.9.3.15 */
+  mrb_define_method(mrb, fl,      "divmod",    flo_divmod,       MRB_ARGS_REQ(1));
 
   mrb_define_method(mrb, fl,      "to_s",      flo_to_s,         MRB_ARGS_NONE()); /* 15.2.9.3.16(x) */
   mrb_define_method(mrb, fl,      "inspect",   flo_to_s,         MRB_ARGS_NONE());

data/modules/mruby/src/object.c

@@ -532,16 +532,14 @@ mrb_convert_to_integer(mrb_state *mrb, mrb_value val, int base)
       if (base != 0) goto arg_error;
       return val;
 
-    case MRB_TT_STRING:
-string_conv:
-      return mrb_str_to_inum(mrb, val, base, TRUE);
-
     default:
       break;
   }
   if (base != 0) {
     tmp = mrb_check_string_type(mrb, val);
-    if (!mrb_nil_p(tmp)) goto string_conv;
+    if (!mrb_nil_p(tmp)) {
+      return mrb_str_to_inum(mrb, val, base, TRUE);
+    }
 arg_error:
     mrb_raise(mrb, E_ARGUMENT_ERROR, "base specified for non string value");
   }

data/modules/mruby/src/parse.y

@@ -37,6 +37,7 @@ static void yyerror(parser_state *p, const char *s);
 static void yywarn(parser_state *p, const char *s);
 static void yywarning(parser_state *p, const char *s);
 static void backref_error(parser_state *p, node *n);
+static void tokadd(parser_state *p, int c);
 
 #ifndef isascii
 #define isascii(c) (((c) & ~0x7f) == 0)
@@ -65,23 +66,23 @@ typedef unsigned int stack_type;
 #define nsym(x) ((node*)(intptr_t)(x))
 
 static inline mrb_sym
-intern_gen(parser_state *p, const char *s)
+intern_cstr_gen(parser_state *p, const char *s)
 {
   return mrb_intern_cstr(p->mrb, s);
 }
-#define intern(s) intern_gen(p,(s))
+#define intern_cstr(s) intern_cstr_gen(p,(s))
 
 static inline mrb_sym
-intern_gen2(parser_state *p, const char *s, size_t len)
+intern_gen(parser_state *p, const char *s, size_t len)
 {
-  return mrb_intern2(p->mrb, s, len);
+  return mrb_intern(p->mrb, s, len);
 }
-#define intern2(s,len) intern_gen2(p,(s),(len))
+#define intern(s,len) intern_gen(p,(s),(len))
 
 static inline mrb_sym
 intern_gen_c(parser_state *p, const char c)
 {
-  return mrb_intern2(p->mrb, &c, 1);
+  return mrb_intern(p->mrb, &c, 1);
 }
 #define intern_c(c) intern_gen_c(p,(c))
 
@@ -537,7 +538,7 @@ new_strsym(parser_state *p, node* str)
   const char *s = (const char*)str->cdr->car;
   size_t len = (size_t)str->cdr->cdr;
 
-  return mrb_intern2(p->mrb, s, len);
+  return mrb_intern(p->mrb, s, len);
 }
 
 // (:lvar . a)
@@ -799,14 +800,14 @@ new_symbols(parser_state *p, node *a)
 static node*
 call_uni_op(parser_state *p, node *recv, char *m)
 {
-  return new_call(p, recv, intern(m), 0);
+  return new_call(p, recv, intern_cstr(m), 0);
 }
 
 // (:call a op b)
 static node*
 call_bin_op(parser_state *p, node *recv, char *m, node *arg1)
 {
-  return new_call(p, recv, intern(m), list1(list1(arg1)));
+  return new_call(p, recv, intern_cstr(m), list1(list1(arg1)));
 }
 
 static void
@@ -1283,7 +1284,7 @@ stmt		: keyword_alias fsym {p->lstate = EXPR_FNAME;} fsym
 		    }
 		| primary_value '[' opt_call_args rbracket tOP_ASGN command_call
 		    {
-		      $$ = new_op_asgn(p, new_call(p, $1, intern2("[]",2), $3), $5, $6);
+		      $$ = new_op_asgn(p, new_call(p, $1, intern("[]",2), $3), $5, $6);
 		    }
 		| primary_value '.' tIDENTIFIER tOP_ASGN command_call
 		    {
@@ -1522,7 +1523,7 @@ mlhs_node	: variable
 		    }
 		| primary_value '[' opt_call_args rbracket
 		    {
-		      $$ = new_call(p, $1, intern2("[]",2), $3);
+		      $$ = new_call(p, $1, intern("[]",2), $3);
 		    }
 		| primary_value '.' tIDENTIFIER
 		    {
@@ -1561,7 +1562,7 @@ lhs		: variable
 		    }
 		| primary_value '[' opt_call_args rbracket
 		    {
-		      $$ = new_call(p, $1, intern2("[]",2), $3);
+		      $$ = new_call(p, $1, intern("[]",2), $3);
 		    }
 		| primary_value '.' tIDENTIFIER
 		    {
@@ -1647,31 +1648,31 @@ undef_list	: fsym
 op		: '|'		{ $$ = intern_c('|'); }
 		| '^'		{ $$ = intern_c('^'); }
 		| '&'		{ $$ = intern_c('&'); }
-		| tCMP		{ $$ = intern2("<=>",3); }
-		| tEQ		{ $$ = intern2("==",2); }
-		| tEQQ		{ $$ = intern2("===",3); }
-		| tMATCH	{ $$ = intern2("=~",2); }
-		| tNMATCH	{ $$ = intern2("!~",2); }
+		| tCMP		{ $$ = intern("<=>",3); }
+		| tEQ		{ $$ = intern("==",2); }
+		| tEQQ		{ $$ = intern("===",3); }
+		| tMATCH	{ $$ = intern("=~",2); }
+		| tNMATCH	{ $$ = intern("!~",2); }
 		| '>'		{ $$ = intern_c('>'); }
-		| tGEQ		{ $$ = intern2(">=",2); }
+		| tGEQ		{ $$ = intern(">=",2); }
 		| '<'		{ $$ = intern_c('<'); }
-		| tLEQ		{ $$ = intern2("<=",2); }
-		| tNEQ		{ $$ = intern2("!=",2); }
-		| tLSHFT	{ $$ = intern2("<<",2); }
-		| tRSHFT	{ $$ = intern2(">>",2); }
+		| tLEQ		{ $$ = intern("<=",2); }
+		| tNEQ		{ $$ = intern("!=",2); }
+		| tLSHFT	{ $$ = intern("<<",2); }
+		| tRSHFT	{ $$ = intern(">>",2); }
 		| '+'		{ $$ = intern_c('+'); }
 		| '-'		{ $$ = intern_c('-'); }
 		| '*'		{ $$ = intern_c('*'); }
 		| tSTAR		{ $$ = intern_c('*'); }
 		| '/'		{ $$ = intern_c('/'); }
 		| '%'		{ $$ = intern_c('%'); }
-		| tPOW		{ $$ = intern2("**",2); }
+		| tPOW		{ $$ = intern("**",2); }
 		| '!'		{ $$ = intern_c('!'); }
 		| '~'		{ $$ = intern_c('~'); }
-		| tUPLUS	{ $$ = intern2("+@",2); }
-		| tUMINUS	{ $$ = intern2("-@",2); }
-		| tAREF		{ $$ = intern2("[]",2); }
-		| tASET		{ $$ = intern2("[]=",3); }
+		| tUPLUS	{ $$ = intern("+@",2); }
+		| tUMINUS	{ $$ = intern("-@",2); }
+		| tAREF		{ $$ = intern("[]",2); }
+		| tASET		{ $$ = intern("[]=",3); }
 		| '`'		{ $$ = intern_c('`'); }
 		;
 
@@ -1707,7 +1708,7 @@ arg		: lhs '=' arg
 		    }
 		| primary_value '[' opt_call_args rbracket tOP_ASGN arg
 		    {
-		      $$ = new_op_asgn(p, new_call(p, $1, intern2("[]",2), $3), $5, $6);
+		      $$ = new_op_asgn(p, new_call(p, $1, intern("[]",2), $3), $5, $6);
 		    }
 		| primary_value '.' tIDENTIFIER tOP_ASGN arg
 		    {
@@ -2519,11 +2520,11 @@ method_call	: operation paren_args
 		    }
 		| primary_value '.' paren_args
 		    {
-		      $$ = new_call(p, $1, intern2("call",4), $3);
+		      $$ = new_call(p, $1, intern("call",4), $3);
 		    }
 		| primary_value tCOLON2 paren_args
 		    {
-		      $$ = new_call(p, $1, intern2("call",4), $3);
+		      $$ = new_call(p, $1, intern("call",4), $3);
 		    }
 		| keyword_super paren_args
 		    {
@@ -2535,7 +2536,7 @@ method_call	: operation paren_args
 		    }
 		| primary_value '[' opt_call_args rbracket
 		    {
-		      $$ = new_call(p, $1, intern2("[]",2), $3);
+		      $$ = new_call(p, $1, intern("[]",2), $3);
 		    }
 		;
 
@@ -3315,14 +3316,14 @@ nextc(parser_state *p)
   else {
 #ifdef ENABLE_STDIO
     if (p->f) {
-      if (feof(p->f)) goto end_retry;
+      if (feof(p->f)) goto eof;
       c = fgetc(p->f);
-      if (c == EOF) goto end_retry;
+      if (c == EOF) goto eof;
     }
     else
 #endif
     if (!p->s || p->s >= p->send) {
-       goto end_retry;
+       goto eof;
     }
     else {
       c = (unsigned char)*p->s++;
@@ -3331,14 +3332,14 @@ nextc(parser_state *p)
   p->column++;
   return c;
 
- end_retry:
+ eof:
   if (!p->cxt) return -1;
   else {
     mrbc_context *cxt = p->cxt;
 
     if (cxt->partial_hook(p) < 0) return -1;
-    p->cxt = NULL;
-    c = nextc(p);
+    c = '\n';
+    p->lineno = 1;
     p->cxt = cxt;
     return c;
   }
@@ -3866,6 +3867,9 @@ heredoc_identifier(parser_state *p)
       return 0;
     }
   } else {
+    if (c == -1) {
+      return 0;                 /* missing here document identifier */
+    }
     if (! identchar(c)) {
       pushback(p, c);
       if (indent) pushback(p, '-');
@@ -3929,7 +3933,10 @@ parser_yylex(parser_state *p)
   case '\0':    /* NUL */
   case '\004':  /* ^D */
   case '\032':  /* ^Z */
+    return 0;
   case -1:      /* end of script. */
+    if (p->heredocs_from_nextline)
+      goto maybe_heredoc;
     return 0;
 
   /* white spaces */
@@ -3942,6 +3949,7 @@ parser_yylex(parser_state *p)
     skip(p, '\n');
   /* fall through */
   case '\n':
+  maybe_heredoc:
     heredoc_treat_nextline(p);
     switch (p->lstate) {
     case EXPR_BEG:
@@ -3988,7 +3996,7 @@ parser_yylex(parser_state *p)
   case '*':
     if ((c = nextc(p)) == '*') {
       if ((c = nextc(p)) == '=') {
-	yylval.id = intern2("**",2);
+	yylval.id = intern("**",2);
 	p->lstate = EXPR_BEG;
 	return tOP_ASGN;
       }
@@ -4097,7 +4105,7 @@ parser_yylex(parser_state *p)
     }
     if (c == '<') {
       if ((c = nextc(p)) == '=') {
-	yylval.id = intern2("<<",2);
+	yylval.id = intern("<<",2);
 	p->lstate = EXPR_BEG;
 	return tOP_ASGN;
       }
@@ -4118,7 +4126,7 @@ parser_yylex(parser_state *p)
     }
     if (c == '>') {
       if ((c = nextc(p)) == '=') {
-	yylval.id = intern2(">>",2);
+	yylval.id = intern(">>",2);
 	p->lstate = EXPR_BEG;
 	return tOP_ASGN;
       }
@@ -4232,7 +4240,7 @@ parser_yylex(parser_state *p)
     if ((c = nextc(p)) == '&') {
       p->lstate = EXPR_BEG;
       if ((c = nextc(p)) == '=') {
-	yylval.id = intern2("&&",2);
+	yylval.id = intern("&&",2);
 	p->lstate = EXPR_BEG;
 	return tOP_ASGN;
       }
@@ -4266,7 +4274,7 @@ parser_yylex(parser_state *p)
     if ((c = nextc(p)) == '|') {
       p->lstate = EXPR_BEG;
       if ((c = nextc(p)) == '=') {
-	yylval.id = intern2("||",2);
+	yylval.id = intern("||",2);
 	p->lstate = EXPR_BEG;
 	return tOP_ASGN;
       }
@@ -4870,7 +4878,7 @@ parser_yylex(parser_state *p)
       tokadd(p, '$');
       tokadd(p, c);
       tokfix(p);
-      yylval.id = intern(tok(p));
+      yylval.id = intern_cstr(tok(p));
       return tGVAR;
 
     case '-':
@@ -4880,7 +4888,7 @@ parser_yylex(parser_state *p)
       pushback(p, c);
     gvar:
       tokfix(p);
-      yylval.id = intern(tok(p));
+      yylval.id = intern_cstr(tok(p));
       return tGVAR;
 
     case '&':     /* $&: last match */
@@ -5032,7 +5040,7 @@ parser_yylex(parser_state *p)
 	  p->lstate = EXPR_BEG;
 	  nextc(p);
 	  tokfix(p);
-	  yylval.id = intern(tok(p));
+	  yylval.id = intern_cstr(tok(p));
 	  return tLABEL;
 	}
       }
@@ -5045,7 +5053,7 @@ parser_yylex(parser_state *p)
 	  enum mrb_lex_state_enum state = p->lstate;
 	  p->lstate = kw->state;
 	  if (state == EXPR_FNAME) {
-	    yylval.id = intern(kw->name);
+	    yylval.id = intern_cstr(kw->name);
 	    return kw->id[0];
 	  }
 	  if (p->lstate == EXPR_BEG) {
@@ -5090,7 +5098,7 @@ parser_yylex(parser_state *p)
       }
     }
     {
-      mrb_sym ident = intern(tok(p));
+      mrb_sym ident = intern_cstr(tok(p));
 
       yylval.id = ident;
 #if 0
@@ -5154,7 +5162,7 @@ parser_update_cxt(parser_state *p, mrbc_context *cxt)
   }
 }
 
-void codedump_all(mrb_state*, int);
+void codedump_all(mrb_state*, struct RProc*);
 void parser_dump(mrb_state *mrb, node *tree, int offset);
 
 void
@@ -5345,7 +5353,6 @@ load_exec(mrb_state *mrb, parser_state *p, mrbc_context *c)
 {
   struct RClass *target = mrb->object_class;
   struct RProc *proc;
-  int n;
   mrb_value v;
 
   if (!p) {
@@ -5354,6 +5361,7 @@ load_exec(mrb_state *mrb, parser_state *p, mrbc_context *c)
   if (!p->tree || p->nerr) {
     if (p->capture_errors) {
       char buf[256];
+      int n;
 
       n = snprintf(buf, sizeof(buf), "line %d: %s\n",
       p->error_buffer[0].lineno, p->error_buffer[0].message);
@@ -5368,26 +5376,25 @@ load_exec(mrb_state *mrb, parser_state *p, mrbc_context *c)
       return mrb_undef_value();
     }
   }
-  n = mrb_generate_code(mrb, p);
+  proc = mrb_generate_code(mrb, p);
   mrb_parser_free(p);
-  if (n < 0) {
+  if (proc == NULL) {
     static const char msg[] = "codegen error";
     mrb->exc = mrb_obj_ptr(mrb_exc_new(mrb, E_SCRIPT_ERROR, msg, sizeof(msg) - 1));
-    return mrb_nil_value();
+    return mrb_undef_value();
   }
   if (c) {
-    if (c->dump_result) codedump_all(mrb, n);
-    if (c->no_exec) return mrb_fixnum_value(n);
+    if (c->dump_result) codedump_all(mrb, proc);
+    if (c->no_exec) return mrb_obj_value(proc);
     if (c->target_class) {
       target = c->target_class;
     }
   }
-  proc = mrb_proc_new(mrb, mrb->irep[n]);
   proc->target_class = target;
   if (mrb->c->ci) {
     mrb->c->ci->target_class = target;
   }
-  v = mrb_run(mrb, proc, mrb_top_self(mrb));
+  v = mrb_context_run(mrb, proc, mrb_top_self(mrb), 0);
   if (mrb->exc) return mrb_nil_value();
   return v;
 }

data/modules/mruby/src/proc.c

@@ -22,6 +22,7 @@ mrb_proc_new(mrb_state *mrb, mrb_irep *irep)
   p->target_class = (mrb->c->ci) ? mrb->c->ci->target_class : 0;
   p->body.irep = irep;
   p->env = 0;
+  mrb_irep_incref(mrb, irep);
 
   return p;
 }
@@ -80,6 +81,9 @@ mrb_proc_copy(struct RProc *a, struct RProc *b)
 {
   a->flags = b->flags;
   a->body = b->body;
+  if (!MRB_PROC_CFUNC_P(a)) {
+    a->body.irep->refcnt++;
+  };
   a->target_class = b->target_class;
   a->env = b->env;
 }
@@ -181,15 +185,14 @@ void
 mrb_init_proc(mrb_state *mrb)
 {
   struct RProc *m;
-  mrb_irep *call_irep = (mrb_irep *)mrb_alloca(mrb, sizeof(mrb_irep));
+  mrb_irep *call_irep = (mrb_irep *)mrb_malloc(mrb, sizeof(mrb_irep));
   static const mrb_irep mrb_irep_zero = { 0 };
 
-  if ( call_iseq == NULL || call_irep == NULL )
+  if (call_irep == NULL)
     return;
 
   *call_irep = mrb_irep_zero;
   call_irep->flags = MRB_ISEQ_NO_FREE;
-  call_irep->idx = -1;
   call_irep->iseq = call_iseq;
   call_irep->ilen = 1;
 
@@ -201,8 +204,8 @@ mrb_init_proc(mrb_state *mrb)
   mrb_define_method(mrb, mrb->proc_class, "arity", mrb_proc_arity, MRB_ARGS_NONE());
 
   m = mrb_proc_new(mrb, call_irep);
-  mrb_define_method_raw(mrb, mrb->proc_class, mrb_intern2(mrb, "call", 4), m);
-  mrb_define_method_raw(mrb, mrb->proc_class, mrb_intern2(mrb, "[]", 2), m);
+  mrb_define_method_raw(mrb, mrb->proc_class, mrb_intern_lit(mrb, "call"), m);
+  mrb_define_method_raw(mrb, mrb->proc_class, mrb_intern_lit(mrb, "[]"), m);
 
   mrb_define_class_method(mrb, mrb->kernel_module, "lambda", proc_lambda, MRB_ARGS_NONE()); /* 15.3.1.2.6  */
   mrb_define_method(mrb, mrb->kernel_module,       "lambda", proc_lambda, MRB_ARGS_NONE()); /* 15.3.1.3.27 */

data/modules/mruby/src/re.h

@@ -8,6 +8,5 @@
 #define RE_H
 
 #define REGEXP_CLASS          "Regexp"
-#define REGEXP_CLASS_CSTR_LEN 6
 
 #endif