webruby 0.2.7 → 0.9.1

data/modules/mruby/src/object.c

@@ -9,7 +9,7 @@
 #include "mruby/numeric.h"
 #include "mruby/string.h"
 
-mrb_bool
+MRB_API mrb_bool
 mrb_obj_eq(mrb_state *mrb, mrb_value v1, mrb_value v2)
 {
   if (mrb_type(v1) != mrb_type(v2)) return FALSE;
@@ -19,9 +19,9 @@ mrb_obj_eq(mrb_state *mrb, mrb_value v1, mrb_value v2)
 
   case MRB_TT_FALSE:
   case MRB_TT_FIXNUM:
-    return (v1.value.i == v2.value.i);
+    return (mrb_fixnum(v1) == mrb_fixnum(v2));
   case MRB_TT_SYMBOL:
-    return (v1.value.sym == v2.value.sym);
+    return (mrb_symbol(v1) == mrb_symbol(v2));
 
   case MRB_TT_FLOAT:
     return (mrb_float(v1) == mrb_float(v2));
@@ -31,14 +31,14 @@ mrb_obj_eq(mrb_state *mrb, mrb_value v1, mrb_value v2)
   }
 }
 
-mrb_bool
+MRB_API mrb_bool
 mrb_obj_equal(mrb_state *mrb, mrb_value v1, mrb_value v2)
 {
   /* temporary definition */
   return mrb_obj_eq(mrb, v1, v2);
 }
 
-mrb_bool
+MRB_API mrb_bool
 mrb_equal(mrb_state *mrb, mrb_value obj1, mrb_value obj2)
 {
   mrb_value result;
@@ -86,7 +86,7 @@ nil_to_s(mrb_state *mrb, mrb_value obj)
 static mrb_value
 nil_inspect(mrb_state *mrb, mrb_value obj)
 {
-  return mrb_str_new(mrb, "nil", 3);
+  return mrb_str_new_lit(mrb, "nil");
 }
 
 /***********************************************************************
@@ -147,7 +147,7 @@ true_xor(mrb_state *mrb, mrb_value obj)
 static mrb_value
 true_to_s(mrb_state *mrb, mrb_value obj)
 {
-  return mrb_str_new(mrb, "true", 4);
+  return mrb_str_new_lit(mrb, "true");
 }
 
 /* 15.2.5.3.4  */
@@ -254,7 +254,7 @@ false_or(mrb_state *mrb, mrb_value obj)
 static mrb_value
 false_to_s(mrb_state *mrb, mrb_value obj)
 {
-  return mrb_str_new(mrb, "false", 5);
+  return mrb_str_new_lit(mrb, "false");
 }
 
 void
@@ -302,7 +302,7 @@ inspect_type(mrb_state *mrb, mrb_value val)
 }
 
 static mrb_value
-convert_type(mrb_state *mrb, mrb_value val, const char *tname, const char *method, int raise)
+convert_type(mrb_state *mrb, mrb_value val, const char *tname, const char *method, mrb_bool raise)
 {
   mrb_sym m = 0;
 
@@ -310,16 +310,13 @@ convert_type(mrb_state *mrb, mrb_value val, const char *tname, const char *metho
   if (!mrb_respond_to(mrb, val, m)) {
     if (raise) {
       mrb_raisef(mrb, E_TYPE_ERROR, "can't convert %S into %S", inspect_type(mrb, val), mrb_str_new_cstr(mrb, tname));
-      return mrb_nil_value();
-    }
-    else {
-      return mrb_nil_value();
     }
+    return mrb_nil_value();
   }
   return mrb_funcall_argv(mrb, val, m, 0, 0);
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_check_to_integer(mrb_state *mrb, mrb_value val, const char *method)
 {
   mrb_value v;
@@ -332,13 +329,13 @@ mrb_check_to_integer(mrb_state *mrb, mrb_value val, const char *method)
   return v;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char *tname, const char *method)
 {
   mrb_value v;
 
   if (mrb_type(val) == type) return val;
-  v = convert_type(mrb, val, tname, method, 1/*Qtrue*/);
+  v = convert_type(mrb, val, tname, method, TRUE);
   if (mrb_type(v) != type) {
     mrb_raisef(mrb, E_TYPE_ERROR, "%S cannot be converted to %S by #%S", val,
                mrb_str_new_cstr(mrb, tname), mrb_str_new_cstr(mrb, method));
@@ -346,13 +343,13 @@ mrb_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char
   return v;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_check_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char *tname, const char *method)
 {
   mrb_value v;
 
   if (mrb_type(val) == type && type != MRB_TT_DATA) return val;
-  v = convert_type(mrb, val, tname, method, 0/*Qfalse*/);
+  v = convert_type(mrb, val, tname, method, FALSE);
   if (mrb_nil_p(v) || mrb_type(v) != type) return mrb_nil_value();
   return v;
 }
@@ -361,7 +358,7 @@ static const struct types {
   unsigned char type;
   const char *name;
 } builtin_types[] = {
-//    {MRB_TT_NIL,  "nil"},
+/*    {MRB_TT_NIL,  "nil"}, */
   {MRB_TT_FALSE,  "false"},
   {MRB_TT_TRUE,   "true"},
   {MRB_TT_FIXNUM, "Fixnum"},
@@ -377,20 +374,19 @@ static const struct types {
   {MRB_TT_HASH,   "Hash"},
   {MRB_TT_STRING, "String"},
   {MRB_TT_RANGE,  "Range"},
-//    {MRB_TT_BIGNUM,  "Bignum"},
+/*    {MRB_TT_BIGNUM,  "Bignum"}, */
   {MRB_TT_FILE,   "File"},
   {MRB_TT_DATA,   "Data"},  /* internal use: wrapped C pointers */
-//    {MRB_TT_VARMAP,  "Varmap"},  /* internal use: dynamic variables */
-//    {MRB_TT_NODE,  "Node"},  /* internal use: syntax tree node */
-//    {MRB_TT_UNDEF,  "undef"},  /* internal use: #undef; should not happen */
+/*    {MRB_TT_VARMAP,  "Varmap"}, */ /* internal use: dynamic variables */
+/*    {MRB_TT_NODE,  "Node"}, */ /* internal use: syntax tree node */
+/*    {MRB_TT_UNDEF,  "undef"}, */ /* internal use: #undef; should not happen */
     {-1,  0}
 };
 
-void
+MRB_API void
 mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t)
 {
   const struct types *type = builtin_types;
-  struct RString *s;
   enum mrb_vtype xt;
 
   xt = mrb_type(x);
@@ -408,9 +404,8 @@ mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t)
         else if (mrb_type(x) == MRB_TT_SYMBOL) {
           etype = "Symbol";
         }
-        else if (mrb_special_const_p(x)) {
-          s = mrb_str_ptr(mrb_obj_as_string(mrb, x));
-          etype = s->ptr;
+        else if (mrb_immediate_p(x)) {
+          etype = RSTRING_PTR(mrb_obj_as_string(mrb, x));
         }
         else {
           etype = mrb_obj_classname(mrb, x);
@@ -436,17 +431,17 @@ mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t)
  *  initial execution context of Ruby programs returns ``main.''
  */
 
-mrb_value
+MRB_API mrb_value
 mrb_any_to_s(mrb_state *mrb, mrb_value obj)
 {
   mrb_value str = mrb_str_buf_new(mrb, 20);
   const char *cname = mrb_obj_classname(mrb, obj);
 
-  mrb_str_buf_cat(mrb, str, "#<", 2);
-  mrb_str_cat2(mrb, str, cname);
-  mrb_str_cat(mrb, str, ":", 1);
+  mrb_str_cat_lit(mrb, str, "#<");
+  mrb_str_cat_cstr(mrb, str, cname);
+  mrb_str_cat_lit(mrb, str, ":");
   mrb_str_concat(mrb, str, mrb_ptr_to_str(mrb, mrb_cptr(obj)));
-  mrb_str_buf_cat(mrb, str, ">", 1);
+  mrb_str_cat_lit(mrb, str, ">");
 
   return str;
 }
@@ -477,7 +472,7 @@ mrb_any_to_s(mrb_state *mrb, mrb_value obj)
  *     b.kind_of? M       #=> true
  */
 
-mrb_bool
+MRB_API mrb_bool
 mrb_obj_is_kind_of(mrb_state *mrb, mrb_value obj, struct RClass *c)
 {
   struct RClass *cl = mrb_class(mrb, obj);
@@ -515,13 +510,13 @@ mrb_to_integer(mrb_state *mrb, mrb_value val, const char *method)
   return v;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_to_int(mrb_state *mrb, mrb_value val)
 {
   return mrb_to_integer(mrb, val, "to_int");
 }
 
-static mrb_value
+MRB_API mrb_value
 mrb_convert_to_integer(mrb_state *mrb, mrb_value val, int base)
 {
   mrb_value tmp;
@@ -542,13 +537,17 @@ 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)) {
-      return mrb_str_to_inum(mrb, val, base, TRUE);
+      goto string_conv;
     }
 arg_error:
     mrb_raise(mrb, E_ARGUMENT_ERROR, "base specified for non string value");
@@ -560,13 +559,13 @@ arg_error:
   return tmp;
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_Integer(mrb_state *mrb, mrb_value val)
 {
   return mrb_convert_to_integer(mrb, val, 0);
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_Float(mrb_state *mrb, mrb_value val)
 {
   if (mrb_nil_p(val)) {
@@ -587,13 +586,13 @@ mrb_Float(mrb_state *mrb, mrb_value val)
   }
 }
 
-mrb_value
+MRB_API mrb_value
 mrb_inspect(mrb_state *mrb, mrb_value obj)
 {
-  return mrb_obj_as_string(mrb, mrb_funcall(mrb, obj, "inspect", 0, 0));
+  return mrb_obj_as_string(mrb, mrb_funcall(mrb, obj, "inspect", 0));
 }
 
-mrb_bool
+MRB_API mrb_bool
 mrb_eql(mrb_state *mrb, mrb_value obj1, mrb_value obj2)
 {
   if (mrb_obj_eq(mrb, obj1, obj2)) return TRUE;

data/modules/mruby/src/opcode.h

@@ -1,160 +1,2 @@
-/*
-** opcode.h - RiteVM operation codes
-**
-** See Copyright Notice in mruby.h
-*/
-
-#ifndef OPCODE_H
-#define OPCODE_H
-
-#define MAXARG_Bx        (0xffff)
-#define MAXARG_sBx       (MAXARG_Bx>>1)         /* `sBx' is signed */
-
-/* instructions: packed 32 bit      */
-/* -------------------------------  */
-/*     A:B:C:OP = 9: 9: 7: 7        */
-/*      A:Bx:OP =    9:16: 7        */
-/*        Ax:OP =      25: 7        */
-/*   A:Bz:Cz:OP = 9:14: 2: 7        */
-
-#define GET_OPCODE(i)            ((int)(((mrb_code)(i)) & 0x7f))
-#define GETARG_A(i)              ((int)((((mrb_code)(i)) >> 23) & 0x1ff))
-#define GETARG_B(i)              ((int)((((mrb_code)(i)) >> 14) & 0x1ff))
-#define GETARG_C(i)              ((int)((((mrb_code)(i)) >>  7) & 0x7f))
-#define GETARG_Bx(i)             ((int)((((mrb_code)(i)) >>  7) & 0xffff))
-#define GETARG_sBx(i)            ((int)(GETARG_Bx(i)-MAXARG_sBx))
-#define GETARG_Ax(i)             ((int32_t)((((mrb_code)(i)) >>  7) & 0x1ffffff))
-#define GETARG_UNPACK_b(i,n1,n2) ((int)((((mrb_code)(i)) >> (7+(n2))) & (((1<<(n1))-1))))
-#define GETARG_UNPACK_c(i,n1,n2) ((int)((((mrb_code)(i)) >> 7) & (((1<<(n2))-1))))
-#define GETARG_b(i)              GETARG_UNPACK_b(i,14,2)
-#define GETARG_c(i)              GETARG_UNPACK_c(i,14,2)
-
-#define MKOPCODE(op)          ((op) & 0x7f)
-#define MKARG_A(c)            ((mrb_code)((c) & 0x1ff) << 23)
-#define MKARG_B(c)            ((mrb_code)((c) & 0x1ff) << 14)
-#define MKARG_C(c)            (((c) & 0x7f) <<  7)
-#define MKARG_Bx(v)           ((mrb_code)((v) & 0xffff) << 7)
-#define MKARG_sBx(v)          MKARG_Bx((v)+MAXARG_sBx)
-#define MKARG_Ax(v)           ((mrb_code)((v) & 0x1ffffff) << 7)
-#define MKARG_PACK(b,n1,c,n2) ((((b) & ((1<<n1)-1)) << (7+n2))|(((c) & ((1<<n2)-1)) << 7))
-#define MKARG_bc(b,c)         MKARG_PACK(b,14,c,2)
-
-#define MKOP_A(op,a)        (MKOPCODE(op)|MKARG_A(a))
-#define MKOP_AB(op,a,b)     (MKOP_A(op,a)|MKARG_B(b))
-#define MKOP_ABC(op,a,b,c)  (MKOP_AB(op,a,b)|MKARG_C(c))
-#define MKOP_ABx(op,a,bx)   (MKOP_A(op,a)|MKARG_Bx(bx))
-#define MKOP_Bx(op,bx)      (MKOPCODE(op)|MKARG_Bx(bx))
-#define MKOP_sBx(op,sbx)    (MKOPCODE(op)|MKARG_sBx(sbx))
-#define MKOP_AsBx(op,a,sbx) (MKOP_A(op,a)|MKARG_sBx(sbx))
-#define MKOP_Ax(op,ax)      (MKOPCODE(op)|MKARG_Ax(ax))
-#define MKOP_Abc(op,a,b,c)  (MKOP_A(op,a)|MKARG_bc(b,c))
-
-enum {
-  /*-----------------------------------------------------------------------
-  operation code  operand description
-  ------------------------------------------------------------------------*/
-  OP_NOP=0,/*                                                             */
-  OP_MOVE,/*      A B     R(A) := R(B)                                    */
-  OP_LOADL,/*     A Bx    R(A) := Lit(Bx)                                 */
-  OP_LOADI,/*     A sBx   R(A) := sBx                                     */
-  OP_LOADSYM,/*   A Bx    R(A) := Sym(Bx)                                 */
-  OP_LOADNIL,/*   A       R(A) := nil                                     */
-  OP_LOADSELF,/*  A       R(A) := self                                    */
-  OP_LOADT,/*     A       R(A) := true                                    */
-  OP_LOADF,/*     A       R(A) := false                                   */
-
-  OP_GETGLOBAL,/* A Bx    R(A) := getglobal(Sym(Bx))                      */
-  OP_SETGLOBAL,/* A Bx    setglobal(Sym(Bx), R(A))                        */
-  OP_GETSPECIAL,/*A Bx    R(A) := Special[Bx]                             */
-  OP_SETSPECIAL,/*A Bx    Special[Bx] := R(A)                             */
-  OP_GETIV,/*     A Bx    R(A) := ivget(Sym(Bx))                          */
-  OP_SETIV,/*     A Bx    ivset(Sym(Bx),R(A))                             */
-  OP_GETCV,/*     A Bx    R(A) := cvget(Sym(Bx))                          */
-  OP_SETCV,/*     A Bx    cvset(Sym(Bx),R(A))                             */
-  OP_GETCONST,/*  A Bx    R(A) := constget(Sym(Bx))                       */
-  OP_SETCONST,/*  A Bx    constset(Sym(Bx),R(A))                          */
-  OP_GETMCNST,/*  A Bx    R(A) := R(A)::Sym(B)                            */
-  OP_SETMCNST,/*  A Bx    R(A+1)::Sym(B) := R(A)                          */
-  OP_GETUPVAR,/*  A B C   R(A) := uvget(B,C)                              */
-  OP_SETUPVAR,/*  A B C   uvset(B,C,R(A))                                 */
-
-  OP_JMP,/*       sBx     pc+=sBx                                         */
-  OP_JMPIF,/*     A sBx   if R(A) pc+=sBx                                 */
-  OP_JMPNOT,/*    A sBx   if !R(A) pc+=sBx                                */
-  OP_ONERR,/*     sBx     rescue_push(pc+sBx)                             */
-  OP_RESCUE,/*    A       clear(exc); R(A) := exception (ignore when A=0) */
-  OP_POPERR,/*    A       A.times{rescue_pop()}                           */
-  OP_RAISE,/*     A       raise(R(A))                                     */
-  OP_EPUSH,/*     Bx      ensure_push(SEQ[Bx])                            */
-  OP_EPOP,/*      A       A.times{ensure_pop().call}                      */
-
-  OP_SEND,/*      A B C   R(A) := call(R(A),mSym(B),R(A+1),...,R(A+C))    */
-  OP_SENDB,/*     A B C   R(A) := call(R(A),mSym(B),R(A+1),...,R(A+C),&R(A+C+1))*/
-  OP_FSEND,/*     A B C   R(A) := fcall(R(A),mSym(B),R(A+1),...,R(A+C-1)) */
-  OP_CALL,/*      A B C   R(A) := self.call(R(A),.., R(A+C))              */
-  OP_SUPER,/*     A B C   R(A) := super(R(A+1),... ,R(A+C-1))             */
-  OP_ARGARY,/*    A Bx    R(A) := argument array (16=6:1:5:4)             */
-  OP_ENTER,/*     Ax      arg setup according to flags (24=5:5:1:5:5:1:1) */
-  OP_KARG,/*      A B C   R(A) := kdict[mSym(B)]; if C kdict.rm(mSym(B))  */
-  OP_KDICT,/*     A C     R(A) := kdict                                   */
-
-  OP_RETURN,/*    A B     return R(A) (B=normal,in-block return/break)    */
-  OP_TAILCALL,/*  A B C   return call(R(A),mSym(B),*R(C))                 */
-  OP_BLKPUSH,/*   A Bx    R(A) := block (16=6:1:5:4)                      */
-
-  OP_ADD,/*       A B C   R(A) := R(A)+R(A+1) (mSyms[B]=:+,C=1)           */
-  OP_ADDI,/*      A B C   R(A) := R(A)+C (mSyms[B]=:+)                    */
-  OP_SUB,/*       A B C   R(A) := R(A)-R(A+1) (mSyms[B]=:-,C=1)           */
-  OP_SUBI,/*      A B C   R(A) := R(A)-C (mSyms[B]=:-)                    */
-  OP_MUL,/*       A B C   R(A) := R(A)*R(A+1) (mSyms[B]=:*,C=1)           */
-  OP_DIV,/*       A B C   R(A) := R(A)/R(A+1) (mSyms[B]=:/,C=1)           */
-  OP_EQ,/*        A B C   R(A) := R(A)==R(A+1) (mSyms[B]=:==,C=1)         */
-  OP_LT,/*        A B C   R(A) := R(A)<R(A+1)  (mSyms[B]=:<,C=1)          */
-  OP_LE,/*        A B C   R(A) := R(A)<=R(A+1) (mSyms[B]=:<=,C=1)         */
-  OP_GT,/*        A B C   R(A) := R(A)>R(A+1)  (mSyms[B]=:>,C=1)          */
-  OP_GE,/*        A B C   R(A) := R(A)>=R(A+1) (mSyms[B]=:>=,C=1)         */
-
-  OP_ARRAY,/*     A B C   R(A) := ary_new(R(B),R(B+1)..R(B+C))            */
-  OP_ARYCAT,/*    A B     ary_cat(R(A),R(B))                              */
-  OP_ARYPUSH,/*   A B     ary_push(R(A),R(B))                             */
-  OP_AREF,/*      A B C   R(A) := R(B)[C]                                 */
-  OP_ASET,/*      A B C   R(B)[C] := R(A)                                 */
-  OP_APOST,/*     A B C   *R(A),R(A+1)..R(A+C) := R(A)                    */
-
-  OP_STRING,/*    A Bx    R(A) := str_dup(Lit(Bx))                        */
-  OP_STRCAT,/*    A B     str_cat(R(A),R(B))                              */
-
-  OP_HASH,/*      A B C   R(A) := hash_new(R(B),R(B+1)..R(B+C))           */
-  OP_LAMBDA,/*    A Bz Cz R(A) := lambda(SEQ[Bz],Cm)                      */
-  OP_RANGE,/*     A B C   R(A) := range_new(R(B),R(B+1),C)                */
-
-  OP_OCLASS,/*    A       R(A) := ::Object                                */
-  OP_CLASS,/*     A B     R(A) := newclass(R(A),mSym(B),R(A+1))           */
-  OP_MODULE,/*    A B     R(A) := newmodule(R(A),mSym(B))                 */
-  OP_EXEC,/*      A Bx    R(A) := blockexec(R(A),SEQ[Bx])                 */
-  OP_METHOD,/*    A B     R(A).newmethod(mSym(B),R(A+1))                  */
-  OP_SCLASS,/*    A B     R(A) := R(B).singleton_class                    */
-  OP_TCLASS,/*    A       R(A) := target_class                            */
-
-  OP_DEBUG,/*     A       print R(A)                                      */
-  OP_STOP,/*              stop VM                                         */
-  OP_ERR,/*       Bx      raise RuntimeError with message Lit(Bx)         */
-
-  OP_RSVD1,/*             reserved instruction #1                         */
-  OP_RSVD2,/*             reserved instruction #2                         */
-  OP_RSVD3,/*             reserved instruction #3                         */
-  OP_RSVD4,/*             reserved instruction #4                         */
-  OP_RSVD5,/*             reserved instruction #5                         */
-};
-
-#define OP_L_STRICT  1
-#define OP_L_CAPTURE 2
-#define OP_L_METHOD  OP_L_STRICT
-#define OP_L_LAMBDA  (OP_L_STRICT|OP_L_CAPTURE)
-#define OP_L_BLOCK   OP_L_CAPTURE
-
-#define OP_R_NORMAL 0
-#define OP_R_BREAK  1
-#define OP_R_RETURN 2
-
-#endif  /* OPCODE_H */
+/* this header file is to be removed soon. */
+#include "mruby/opcode.h"