Updated Xcode project build settings in conformity with 10.8/Xcode 4.4

AUTHORS

@@ -6,3 +6,6 @@ Original Authors "mruby developers" are:
    Daniel Bovensiepen
    Jon Maken
    Bjorn De Meyer
+   Yuichiro MASUI
+   Masamitsu MURASE
+   Masaki Muranaka

CMakeLists.txt

@@ -33,12 +33,13 @@ project(mruby C)
 # TODO stop polluting source tree with CMakeFiles/ and CMakeCache.txt
 #      on build location check failure
 # Make sure we are not trying to generate in in-tree build unless building
-# with a MSVC IDE where it's OK.
-if(CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR AND NOT MSVC_IDE)
+# with an MSVC or Xcode IDE where it's OK.
+if(CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR AND NOT (MSVC_IDE OR XCODE))
   message(FATAL_ERROR
           "\nIn-source builds are not allowed as CMake would overwrite the "
-          "Makefiles distributed with mruby. Please change to the 'build' "
-          "subdirectory and run CMake from there.")
+          "Makefiles distributed with mruby. Delete any created 'CMakeFiles' "
+          "subdirectory and 'CMakeCache.txt' file from the current directory, "
+          "change to the 'build' subdirectory, and re-run CMake from there.")
 endif()
 
 if(COMMAND cmake_policy)

Makefile

@@ -7,12 +7,19 @@ export LL = gcc
 export AR = ar
 export YACC = bison
 
-DEBUG_MODE = 1
-ifeq ($(DEBUG_MODE),1)
-CFLAGS = -g -O3
-else
-CFLAGS = -O3
+ifeq ($(strip $(COMPILE_MODE)),)
+  # default compile option
+  COMPILE_MODE = debug
+endif
+
+ifeq ($(COMPILE_MODE),debug)
+  CFLAGS = -g -O3
+else ifeq ($(COMPILE_MODE),release)
+  CFLAGS = -O3
+else ifeq ($(COMPILE_MODE),small)
+  CFLAGS = -Os
 endif
+
 ALL_CFLAGS = -Wall -Werror-implicit-function-declaration $(CFLAGS)
 ifeq ($(OS),Windows_NT)
   MAKE_FLAGS = --no-print-directory CC=$(CC) LL=$(LL) ALL_CFLAGS='$(ALL_CFLAGS)'

benchmark/ao-render.rb

+# AO render benchmark
+# Original program (C) Syoyo Fujita in Javascript (and other languages)
+#      http://lucille.atso-net.jp/blog/?p=642
+#      http://lucille.atso-net.jp/blog/?p=711
+# Ruby(yarv2llvm) version by Hideki Miura
+# mruby version by Hideki Miura
+#
+
+IMAGE_WIDTH = 256
+IMAGE_HEIGHT = 256
+NSUBSAMPLES = 2
+NAO_SAMPLES = 8
+
+module Rand
+  # Use xorshift
+  @@x = 123456789
+  @@y = 362436069
+  @@z = 521288629
+  @@w = 88675123
+  BNUM = 1 << 29
+  BNUMF = BNUM.to_f
+  def self.rand
+    x = @@x
+    t = x ^ ((x & 0xfffff) << 11)
+    w = @@w
+    @@x, @@y, @@z = @@y, @@z, w
+    w = @@w = (w ^ (w >> 19) ^ (t ^ (t >> 8)))
+    (w % BNUM) / BNUMF
+  end
+end
+
+class Vec
+  def initialize(x, y, z)
+    @x = x
+    @y = y
+    @z = z
+  end
+
+  def x=(v); @x = v; end
+  def y=(v); @y = v; end
+  def z=(v); @z = v; end
+  def x; @x; end
+  def y; @y; end
+  def z; @z; end
+
+  def vadd(b)
+    Vec.new(@x + b.x, @y + b.y, @z + b.z)
+  end
+
+  def vsub(b)
+    Vec.new(@x - b.x, @y - b.y, @z - b.z)
+  end
+
+  def vcross(b)
+    Vec.new(@y * b.z - @z * b.y,
+            @z * b.x - @x * b.z,
+            @x * b.y - @y * b.x)
+  end
+
+  def vdot(b)
+    r = @x * b.x + @y * b.y + @z * b.z
+    r
+  end
+
+  def vlength
+    Math.sqrt(@x * @x + @y * @y + @z * @z)
+  end
+
+  def vnormalize
+    len = vlength
+    v = Vec.new(@x, @y, @z)
+    if len > 1.0e-17 then
+      v.x = v.x / len
+      v.y = v.y / len
+      v.z = v.z / len
+    end
+    v
+  end
+end
+
+
+class Sphere
+  def initialize(center, radius)
+    @center = center
+    @radius = radius
+  end
+
+  def center; @center; end
+  def radius; @radius; end
+
+  def intersect(ray, isect)
+    rs = ray.org.vsub(@center)
+    b = rs.vdot(ray.dir)
+    c = rs.vdot(rs) - (@radius * @radius)
+    d = b * b - c
+    if d > 0.0 then
+      t = - b - Math.sqrt(d)
+
+      if t > 0.0 and t < isect.t then
+        isect.t = t
+        isect.hit = true
+        isect.pl = Vec.new(ray.org.x + ray.dir.x * t,
+                          ray.org.y + ray.dir.y * t,
+                          ray.org.z + ray.dir.z * t)
+        n = isect.pl.vsub(@center)
+        isect.n = n.vnormalize
+      end
+    end
+  end
+end
+
+class Plane
+  def initialize(p, n)
+    @p = p
+    @n = n
+  end
+
+  def intersect(ray, isect)
+    d = -@p.vdot(@n)
+    v = ray.dir.vdot(@n)
+    v0 = v
+    if v < 0.0 then
+      v0 = -v
+    end
+    if v0 < 1.0e-17 then
+      return
+    end
+
+    t = -(ray.org.vdot(@n) + d) / v
+
+    if t > 0.0 and t < isect.t then
+      isect.hit = true
+      isect.t = t
+      isect.n = @n
+      isect.pl = Vec.new(ray.org.x + t * ray.dir.x,
+                        ray.org.y + t * ray.dir.y,
+                        ray.org.z + t * ray.dir.z)
+    end
+  end
+end
+
+class Ray
+  def initialize(org, dir)
+    @org = org
+    @dir = dir
+  end
+
+  def org; @org; end
+  def org=(v); @org = v; end
+  def dir; @dir; end
+  def dir=(v); @dir = v; end
+end
+
+class Isect
+  def initialize
+    @t = 10000000.0
+    @hit = false
+    @pl = Vec.new(0.0, 0.0, 0.0)
+    @n = Vec.new(0.0, 0.0, 0.0)
+  end
+
+  def t; @t; end
+  def t=(v); @t = v; end
+  def hit; @hit; end
+  def hit=(v); @hit = v; end
+  def pl; @pl; end
+  def pl=(v); @pl = v; end
+  def n; @n; end
+  def n=(v); @n = v; end
+end
+
+def clamp(f)
+  i = f * 255.5
+  if i > 255.0 then
+    i = 255.0
+  end
+  if i < 0.0 then
+    i = 0.0
+  end
+  i.to_i
+end
+
+def otherBasis(basis, n)
+  basis[2] = Vec.new(n.x, n.y, n.z)
+  basis[1] = Vec.new(0.0, 0.0, 0.0)
+
+  if n.x < 0.6 and n.x > -0.6 then
+    basis[1].x = 1.0
+  elsif n.y < 0.6 and n.y > -0.6 then
+    basis[1].y = 1.0
+  elsif n.z < 0.6 and n.z > -0.6 then
+    basis[1].z = 1.0
+  else
+    basis[1].x = 1.0
+  end
+
+  basis[0] = basis[1].vcross(basis[2])
+  basis[0] = basis[0].vnormalize
+
+  basis[1] = basis[2].vcross(basis[0])
+  basis[1] = basis[1].vnormalize
+end
+
+class Scene
+  def initialize
+    @spheres = Array.new
+    @spheres[0] = Sphere.new(Vec.new(-2.0, 0.0, -3.5), 0.5)
+    @spheres[1] = Sphere.new(Vec.new(-0.5, 0.0, -3.0), 0.5)
+    @spheres[2] = Sphere.new(Vec.new(1.0, 0.0, -2.2), 0.5)
+    @plane = Plane.new(Vec.new(0.0, -0.5, 0.0), Vec.new(0.0, 1.0, 0.0))
+  end
+
+  def ambient_occlusion(isect)
+    basis = Array.new(3)
+    otherBasis(basis, isect.n)
+
+    ntheta    = NAO_SAMPLES
+    nphi      = NAO_SAMPLES
+    eps       = 0.0001
+    occlusion = 0.0
+
+    p0 = Vec.new(isect.pl.x + eps * isect.n.x,
+                isect.pl.y + eps * isect.n.y,
+                isect.pl.z + eps * isect.n.z)
+    nphi.times do |j|
+      ntheta.times do |i|
+        r = Rand::rand
+        phi = 2.0 * 3.14159265 * Rand::rand
+        x = Math.cos(phi) * Math.sqrt(1.0 - r)
+        y = Math.sin(phi) * Math.sqrt(1.0 - r)
+        z = Math.sqrt(r)
+
+        rx = x * basis[0].x + y * basis[1].x + z * basis[2].x
+        ry = x * basis[0].y + y * basis[1].y + z * basis[2].y
+        rz = x * basis[0].z + y * basis[1].z + z * basis[2].z
+
+        raydir = Vec.new(rx, ry, rz)
+        ray = Ray.new(p0, raydir)
+
+        occisect = Isect.new
+        @spheres[0].intersect(ray, occisect)
+        @spheres[1].intersect(ray, occisect)
+        @spheres[2].intersect(ray, occisect)
+        @plane.intersect(ray, occisect)
+        if occisect.hit then
+          occlusion = occlusion + 1.0
+        else
+          0.0
+        end
+      end
+    end
+
+    occlusion = (ntheta.to_f * nphi.to_f - occlusion) / (ntheta.to_f * nphi.to_f)
+    Vec.new(occlusion, occlusion, occlusion)
+  end
+
+  def render(w, h, nsubsamples)
+    cnt = 0
+    nsf = nsubsamples.to_f
+    h.times do |y|
+      w.times do |x|
+        rad = Vec.new(0.0, 0.0, 0.0)
+
+        # Subsmpling
+        nsubsamples.times do |v|
+          nsubsamples.times do |u|
+            cnt = cnt + 1
+            wf = w.to_f
+            hf = h.to_f
+            xf = x.to_f
+            yf = y.to_f
+            uf = u.to_f
+            vf = v.to_f
+
+            px = (xf + (uf / nsf) - (wf / 2.0)) / (wf / 2.0)
+            py = -(yf + (vf / nsf) - (hf / 2.0)) / (hf / 2.0)
+
+            eye = Vec.new(px, py, -1.0).vnormalize
+
+            ray = Ray.new(Vec.new(0.0, 0.0, 0.0), eye)
+
+            isect = Isect.new
+            @spheres[0].intersect(ray, isect)
+            @spheres[1].intersect(ray, isect)
+            @spheres[2].intersect(ray, isect)
+            @plane.intersect(ray, isect)
+            if isect.hit then
+              col = ambient_occlusion(isect)
+              rad.x = rad.x + col.x
+              rad.y = rad.y + col.y
+              rad.z = rad.z + col.z
+            else
+              0.0
+            end
+          end
+        end
+
+        r = rad.x / (nsf * nsf)
+        g = rad.y / (nsf * nsf)
+        b = rad.z / (nsf * nsf)
+        printf("%c", clamp(r))
+        printf("%c", clamp(g))
+        printf("%c", clamp(b))
+      end
+    end
+  end
+end
+
+# File.open("ao.ppm", "w") do |fp|
+  printf("P6\n")
+  printf("%d %d\n", IMAGE_WIDTH, IMAGE_HEIGHT)
+  printf("255\n", IMAGE_WIDTH, IMAGE_HEIGHT)
+  Scene.new.render(IMAGE_WIDTH, IMAGE_HEIGHT, NSUBSAMPLES)
+#  Scene.new.render(256, 256, 2)
+# end

benchmark/bm_so_lists.rb

+#from http://www.bagley.org/~doug/shootout/bench/lists/lists.ruby
+
+NUM = 300
+SIZE = 10000
+
+def test_lists()
+  # create a list of integers (Li1) from 1 to SIZE
+  li1 = (1..SIZE).to_a
+  # copy the list to li2 (not by individual items)
+  li2 = li1.dup
+  # remove each individual item from left side of li2 and
+  # append to right side of li3 (preserving order)
+  li3 = Array.new
+  while (not li2.empty?)
+    li3.push(li2.shift)
+  end
+  # li2 must now be empty
+  # remove each individual item from right side of li3 and
+  # append to right side of li2 (reversing list)
+  while (not li3.empty?)
+    li2.push(li3.pop)
+  end
+  # li3 must now be empty
+  # reverse li1 in place
+  li1.reverse!
+  # check that first item is now SIZE
+  if li1[0] != SIZE then
+    p "not SIZE"
+    0
+  else
+    # compare li1 and li2 for equality
+    if li1 != li2 then
+      return(0)
+    else
+      # return the length of the list
+      li1.length
+    end
+  end
+end
+
+i = 0
+while i<NUM
+  i+=1
+  result = test_lists()
+end
+
+result

cmake/Toolchain-OpenWRT-ANY.cmake

+# Toolchain file for building with OpenWRT Toolchain for ANY OpenWRT Target.
+# Following prequisition are necessary:
+#   - latest cmake version
+#   - mruby OpenWRT Package file (not yet in distribution)
+
+# Switch to Cross Compile by setting the system name
+SET(CMAKE_SYSTEM_NAME Linux)
+
+# We show CMAKE the compiler, the rest will be guessed by the Toolchain
+SET(CMAKE_C_COMPILER "$ENV{OPENWRT_TOOLCHAIN}/bin/$ENV{OPENWRT_TARGETCC}")
+
+# We define an own release flag so that we can adapt the optimal C_FLAGS
+SET(CMAKE_C_FLAGS_OPENWRT "$ENV{OPENWRT_TARGETFLAGS}")

cmake/Toolchain-Ubuntu-gnueabi.cmake.sample

+# Sample toolchain file for building for ARM from an Ubuntu Linux system.
+#
+# Typical usage:
+#    1) install cross compiler: `sudo apt-get install gcc-arm-linux-gnueabi`
+#    2) cp cmake/Toolchain-Ubuntu-gnueabi.cmake.sample ~/Toolchain-Ubuntu-gnueabi.cmake
+#    3) tweak toolchain values as needed
+#    4) cd build
+#    5) cmake -DCMAKE_TOOLCHAIN_FILE=~/Toolchain-Ubuntu-gnueabi.cmake ..
+
+# name of the target OS on which the built artifacts will run and the
+# toolchain prefix. if target is an embedded system without an OS, set
+# CMAKE_SYSTEM_NAME to `Generic`
+set(CMAKE_SYSTEM_NAME Linux)
+set(TOOLCHAIN_PREFIX arm-linux-gnueabi)
+
+# cross compilers to use for C
+set(CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}-gcc)
+
+# target environment on the build host system
+#   set 1st to dir with the cross compiler's C/C++ headers/libs
+#   set 2nd to dir containing personal cross development headers/libs
+set(CMAKE_FIND_ROOT_PATH /usr/${TOOLCHAIN_PREFIX} ~/crossdev/eabi)
+
+# modify default behavior of FIND_XXX() commands to
+# search for headers/libs in the target environment and
+# search for programs in the build host environment
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

cmake/Toolchain-Ubuntu-gnueabihf.cmake.sample

+# Sample toolchain file for building for ARM (w/hw float support) from an Ubuntu Linux system.
+#
+# Typical usage:
+#    1) install cross compiler: `sudo apt-get install gcc-arm-linux-gnueabihf`
+#    2) cp cmake/Toolchain-Ubuntu-gnueabihf.cmake.sample ~/Toolchain-Ubuntu-gnueabihf.cmake
+#    3) tweak toolchain values as needed
+#    4) cd build
+#    5) cmake -DCMAKE_TOOLCHAIN_FILE=~/Toolchain-Ubuntu-gnueabihf.cmake ..
+
+# name of the target OS on which the built artifacts will run and the
+# toolchain prefix. if target is an embedded system without an OS, set
+# CMAKE_SYSTEM_NAME to `Generic`
+set(CMAKE_SYSTEM_NAME Linux)
+set(TOOLCHAIN_PREFIX arm-linux-gnueabihf)
+
+# cross compilers to use for C
+set(CMAKE_C_COMPILER ${TOOLCHAIN_PREFIX}-gcc)
+
+# target environment on the build host system
+#   set 1st to dir with the cross compiler's C/C++ headers/libs
+#   set 2nd to dir containing personal cross development headers/libs
+set(CMAKE_FIND_ROOT_PATH /usr/${TOOLCHAIN_PREFIX} ~/crossdev/eabihf)
+
+# modify default behavior of FIND_XXX() commands to
+# search for headers/libs in the target environment and
+# search for programs in the build host environment
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)

include/mrbconf.h

@@ -8,7 +8,41 @@
 #define MRUBYCONF_H
 
 #include <stdint.h>
-#undef MRB_USE_FLOAT
+
+/* configuration options: */
+/* add -DMRB_USE_FLOAT to use float instead of double for floating point numbers */
+//#define MRB_USE_FLOAT
+
+/* argv max size in mrb_funcall */
+//#define MRB_FUNCALL_ARGC_MAX 16 
+
+/* number of object per heap page */
+//#define MRB_HEAP_PAGE_SIZE 1024
+
+/* initial size for IV khash */
+//#define MRB_IV_INITIAL_SIZE 8
+
+/* default size of khash table bucket */
+//#define KHASH_DEFAULT_SIZE 32
+
+/* allocated memory address alignment */
+//#define POOL_ALIGNMENT 4
+
+/* page size of memory pool */
+//#define POOL_PAGE_SIZE 16000
+
+/* -DDISABLE_XXXX to drop the feature */
+#define DISABLE_REGEXP	        /* regular expression classes */
+//#define DISABLE_SPRINTF	/* Kernel.sprintf method */
+//#define DISABLE_MATH		/* Math functions */
+//#define DISABLE_TIME		/* Time class */
+//#define DISABLE_STRUCT	/* Struct class */
+//#define DISABLE_STDIO		/* use of stdio */
+
+#undef  HAVE_UNISTD_H /* WINDOWS */
+#define HAVE_UNISTD_H /* LINUX */
+
+/* end of configuration */
 
 #ifdef MRB_USE_FLOAT
 typedef float mrb_float;
@@ -19,20 +53,26 @@ typedef double mrb_float;
 
 typedef int mrb_int;
 typedef intptr_t mrb_sym;
-#define readint(p,base) strtol((p),NULL,(base))
-
-#undef  INCLUDE_ENCODING   /* not use encoding classes (ascii only) */
-//#define INCLUDE_ENCODING   /* use UTF-8 encoding classes */
-
-#undef  INCLUDE_REGEXP     /* not use regular expression classes */
-//#define INCLUDE_REGEXP     /* use regular expression classes */
 
-#ifdef  INCLUDE_REGEXP
-# define INCLUDE_ENCODING  /* Regexp depends Encoding */
+/* define ENABLE_XXXX from DISABLE_XXX */
+#ifndef DISABLE_REGEXP
+#define ENABLE_REGEXP
+#endif
+#ifndef DISABLE_SPRINTF
+#define ENABLE_SPRINTF
+#endif
+#ifndef DISABLE_MATH
+#define ENABLE_MATH
+#endif
+#ifndef DISABLE_TIME
+#define ENABLE_TIME
+#endif
+#ifndef DISABLE_STRUCT
+#define ENABLE_STRUCT
+#endif
+#ifndef DISABLE_STDIO
+#define ENABLE_STDIO
 #endif
-
-#undef  HAVE_UNISTD_H /* WINDOWS */
-#define HAVE_UNISTD_H /* LINUX */
 
 #ifndef FALSE
 # define FALSE 0

include/mruby.h

@@ -60,9 +60,7 @@ enum mrb_vtype {
   MRB_TT_FILE,        /*  21 */
   MRB_TT_ENV,         /*  22 */
   MRB_TT_DATA,        /*  23 */
-  MRB_TT_THREAD,      /*  24 */
-  MRB_TT_THREADGRP,   /*  25 */
-  MRB_TT_MAXDEFINE    /*  26 */
+  MRB_TT_MAXDEFINE    /*  24 */
 };
 
 typedef struct mrb_value {
@@ -83,7 +81,7 @@ typedef struct mrb_value {
 #define mrb_symbol(o) (o).value.sym
 #define mrb_object(o) ((struct RBasic *) (o).value.p)
 #define FIXNUM_P(o)   ((o).tt == MRB_TT_FIXNUM)
-#define UNDEF_P(o)    ((o).tt == MRB_TT_UNDEF)
+#define mrb_undef_p(o) ((o).tt == MRB_TT_UNDEF)
 
 #include "mruby/object.h"
 
@@ -147,7 +145,7 @@ mrb_obj_value(void *p)
 }
 
 static inline mrb_value
-mrb_false_value()
+mrb_false_value(void)
 {
   mrb_value v;
 
@@ -157,7 +155,7 @@ mrb_false_value()
 }
 
 static inline mrb_value
-mrb_nil_value()
+mrb_nil_value(void)
 {
   mrb_value v;
 
@@ -167,7 +165,7 @@ mrb_nil_value()
 }
 
 static inline mrb_value
-mrb_true_value()
+mrb_true_value(void)
 {
   mrb_value v;
 
@@ -177,7 +175,7 @@ mrb_true_value()
 }
 
 static inline mrb_value
-mrb_undef_value()
+mrb_undef_value(void)
 {
   mrb_value v;
 
@@ -192,7 +190,9 @@ struct mrb_state;
 
 typedef void* (*mrb_allocf) (struct mrb_state *mrb, void*, size_t);
 
-#define MRB_ARENA_SIZE 1024  //256 up kusuda 2011/04/30
+#ifndef MRB_ARENA_SIZE
+#define MRB_ARENA_SIZE 1024
+#endif
 #define ruby_debug   (mrb_nil_value())
 #define ruby_verbose (mrb_nil_value())
 
@@ -279,7 +279,8 @@ typedef struct mrb_state {
 
   struct RClass *eException_class;
   struct RClass *eStandardError_class;
-  struct RClass *eRuntimeError_class;
+
+  void *ud; /* auxiliary data */
 } mrb_state;
 
 typedef mrb_value (*mrb_func_t)(mrb_state *mrb, mrb_value);
@@ -295,10 +296,10 @@ void mrb_define_singleton_method(mrb_state*, struct RObject*, const char*, mrb_f
 void mrb_define_module_function(mrb_state*, struct RClass*, const char*, mrb_func_t,int);
 void mrb_define_const(mrb_state*, struct RClass*, const char *name, mrb_value);
 void mrb_undef_method(mrb_state*, struct RClass*, const char*);
+void mrb_undef_class_method(mrb_state*, struct RClass*, const char*);
 mrb_value mrb_instance_new(mrb_state *mrb, mrb_value cv);
 struct RClass * mrb_class_new(mrb_state *mrb, struct RClass *super);
 struct RClass * mrb_module_new(mrb_state *mrb);
-struct RClass * mrb_class_from_sym(mrb_state *mrb, struct RClass *klass, mrb_sym name);
 struct RClass * mrb_class_get(mrb_state *mrb, const char *name);
 struct RClass * mrb_class_obj_get(mrb_state *mrb, const char *name);
 
@@ -329,10 +330,13 @@ struct RClass * mrb_define_module_under(mrb_state *mrb, struct RClass *outer, co
 int mrb_get_args(mrb_state *mrb, const char *format, ...);
 
 mrb_value mrb_funcall(mrb_state*, mrb_value, const char*, int,...);
-mrb_value mrb_funcall_argv(mrb_state*, mrb_value, const char*, int, mrb_value*);
-mrb_value mrb_funcall_with_block(mrb_state*, mrb_value, const char*, int, mrb_value*, mrb_value);
+mrb_value mrb_funcall_argv(mrb_state*, mrb_value, mrb_sym, int, mrb_value*);
+mrb_value mrb_funcall_with_block(mrb_state*, mrb_value, mrb_sym, int, mrb_value*, mrb_value);
 mrb_sym mrb_intern(mrb_state*,const char*);
+mrb_sym mrb_intern2(mrb_state*,const char*,int);
+mrb_sym mrb_intern_str(mrb_state*,mrb_value);
 const char *mrb_sym2name(mrb_state*,mrb_sym);
+const char *mrb_sym2name_len(mrb_state*,mrb_sym,int*);
 mrb_value mrb_str_format(mrb_state *, int, const mrb_value *, mrb_value);
 
 void *mrb_malloc(mrb_state*, size_t);
@@ -353,8 +357,8 @@ int mrb_checkstack(mrb_state*,int);
 mrb_value mrb_top_self(mrb_state *);
 mrb_value mrb_run(mrb_state*, struct RProc*, mrb_value);
 
-mrb_value mrb_p(mrb_state*, mrb_value);
-int mrb_obj_id(mrb_value obj);
+void mrb_p(mrb_state*, mrb_value);
+mrb_int mrb_obj_id(mrb_value obj);
 mrb_sym mrb_to_id(mrb_state *mrb, mrb_value name);
 
 int mrb_obj_equal(mrb_state*, mrb_value, mrb_value);
@@ -416,13 +420,16 @@ mrb_value mrb_check_funcall(mrb_state *mrb, mrb_value recv, mrb_sym mid, int arg
 #define ISXDIGIT(c) (ISASCII(c) && isxdigit((int)(unsigned char)(c)))
 #endif
 
+mrb_value mrb_exc_new(mrb_state *mrb, struct RClass *c, const char *ptr, long len);
+void mrb_exc_raise(mrb_state *mrb, mrb_value exc);
+
 int mrb_block_given_p(void);
 void mrb_raise(mrb_state *mrb, struct RClass *c, const char *fmt, ...);
 void rb_raise(struct RClass *c, const char *fmt, ...);
 void mrb_warn(const char *fmt, ...);
-void mrb_warning(const char *fmt, ...);
 void mrb_bug(const char *fmt, ...);
 
+#define E_RUNTIME_ERROR             (mrb_class_obj_get(mrb, "RuntimeError"))
 #define E_TYPE_ERROR                (mrb_class_obj_get(mrb, "TypeError"))
 #define E_ARGUMENT_ERROR            (mrb_class_obj_get(mrb, "ArgumentError"))
 #define E_INDEX_ERROR               (mrb_class_obj_get(mrb, "IndexError"))
@@ -431,13 +438,9 @@ void mrb_bug(const char *fmt, ...);
 #define E_NOMETHOD_ERROR            (mrb_class_obj_get(mrb, "NoMethodError"))
 #define E_SCRIPT_ERROR              (mrb_class_obj_get(mrb, "ScriptError"))
 #define E_SYNTAX_ERROR              (mrb_class_obj_get(mrb, "SyntaxError"))
-#define E_LOAD_ERROR                (mrb_class_obj_get(mrb, "LoadError"))
-#define E_SYSTEMCALL_ERROR          (mrb_class_obj_get(mrb, "SystemCallError"))
 #define E_LOCALJUMP_ERROR           (mrb_class_obj_get(mrb, "LocalJumpError"))
 #define E_REGEXP_ERROR              (mrb_class_obj_get(mrb, "RegexpError"))
-#define E_ZERODIVISION_ERROR        (mrb_class_obj_get(mrb, "ZeroDivisionError"))
 
-#define E_ENCODING_ERROR            (mrb_class_obj_get(mrb, "EncodingError"))
 #define E_NOTIMP_ERROR              (mrb_class_obj_get(mrb, "NotImplementedError"))
 #define E_FLOATDOMAIN_ERROR         (mrb_class_obj_get(mrb, "FloatDomainError"))
 
@@ -462,20 +465,9 @@ NUM2CHR(mrb_value x)
 
 mrb_value mrb_yield(mrb_state *mrb, mrb_value v, mrb_value blk);
 mrb_value mrb_yield_argv(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv);
-mrb_value mrb_yield_with_self(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv, mrb_value self);
 mrb_value mrb_class_new_instance(mrb_state *mrb, int, mrb_value*, struct RClass *);
 mrb_value mrb_class_new_instance_m(mrb_state *mrb, mrb_value klass);
 
-mrb_value mrb_exec_recursive(mrb_state *mrb, mrb_value(*)(mrb_state *, mrb_value, mrb_value, int),mrb_value,void *);
-
-#ifndef xmalloc
-#define xmalloc     malloc
-#define xrealloc    realloc
-#define xcalloc     calloc
-#define xfree       free
-#endif
-
-void mrb_garbage_collect(mrb_state *mrb);
 void mrb_gc_protect(mrb_state *mrb, mrb_value obj);
 mrb_value mrb_to_int(mrb_state *mrb, mrb_value val);
 void mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t);

include/mruby/array.h

@@ -11,11 +11,20 @@
 extern "C" {
 #endif
 
+struct mrb_shared_array {
+  int refcnt;
+  mrb_value *ptr;
+  int len;
+};
+
 struct RArray {
   MRUBY_OBJECT_HEADER;
-  size_t len;
-  size_t capa;
-  mrb_value *buf;
+  int len;
+  union {
+    int capa;
+    struct mrb_shared_array *shared;
+  } aux;
+  mrb_value *ptr;
 };
 
 #define mrb_ary_ptr(v)    ((struct RArray*)((v).value.p))
@@ -23,30 +32,28 @@ struct RArray {
 #define RARRAY(v)  ((struct RArray*)((v).value.p))
 
 #define RARRAY_LEN(a) (RARRAY(a)->len)
-#define RARRAY_PTR(a) (RARRAY(a)->buf)
+#define RARRAY_PTR(a) (RARRAY(a)->ptr)
+#define MRB_ARY_SHARED      256
 
-mrb_value mrb_ary_new_capa(mrb_state*, size_t);
+void mrb_ary_decref(mrb_state*, struct mrb_shared_array*);
+mrb_value mrb_ary_new_capa(mrb_state*, int);
 mrb_value mrb_ary_new(mrb_state *mrb);
-mrb_value mrb_ary_new_elts(mrb_state *mrb, long n, const mrb_value *elts);
+mrb_value mrb_ary_new_elts(mrb_state *mrb, int n, const mrb_value *elts);
 void mrb_ary_concat(mrb_state*, mrb_value, mrb_value);
 mrb_value mrb_ary_splat(mrb_state*, mrb_value);
 void mrb_ary_push(mrb_state*, mrb_value, mrb_value);
 mrb_value mrb_ary_pop(mrb_state *mrb, mrb_value ary);
-mrb_value mrb_ary_new_from_values(mrb_state *mrb, size_t size, mrb_value *vals);
+mrb_value mrb_ary_new_from_values(mrb_state *mrb, int size, mrb_value *vals);
 mrb_value mrb_ary_aget(mrb_state *mrb, mrb_value self);
 mrb_value mrb_ary_ref(mrb_state *mrb, mrb_value ary, mrb_int n);
 void mrb_ary_set(mrb_state *mrb, mrb_value ary, mrb_int n, mrb_value val);
 int mrb_ary_len(mrb_state *mrb, mrb_value ary);
-mrb_value mrb_ary_replace_m(mrb_state *mrb, mrb_value self);
-void mrb_ary_replace(mrb_state *mrb, struct RArray *a, mrb_value *argv, size_t len);
+void mrb_ary_replace(mrb_state *mrb, mrb_value a, mrb_value b);
 mrb_value mrb_check_array_type(mrb_state *mrb, mrb_value self);
 mrb_value mrb_ary_unshift(mrb_state *mrb, mrb_value self, mrb_value item);
-mrb_value mrb_ary_new4(mrb_state *mrb, long n, const mrb_value *elts);
+mrb_value mrb_ary_new4(mrb_state *mrb, int n, const mrb_value *elts);
 mrb_value mrb_assoc_new(mrb_state *mrb, mrb_value car, mrb_value cdr);
-mrb_value mrb_ary_entry(mrb_value ary, long offset);
-void mrb_mem_clear(mrb_value *mem, long size);
-mrb_value mrb_ary_tmp_new(mrb_state *mrb, long capa);
-mrb_value mrb_ary_sort(mrb_state *mrb, mrb_value ary);
+mrb_value mrb_ary_entry(mrb_value ary, int offset);
 mrb_value mrb_ary_shift(mrb_state *mrb, mrb_value self);
 
 #if defined(__cplusplus)

include/mruby/class.h

@@ -28,7 +28,7 @@ mrb_class(mrb_state *mrb, mrb_value v)
 {
   switch (mrb_type(v)) {
   case MRB_TT_FALSE:
-    if (v.value.p)
+    if (v.value.i)
       return mrb->false_class;
     return mrb->nil_class;
   case MRB_TT_TRUE:
@@ -40,14 +40,7 @@ mrb_class(mrb_state *mrb, mrb_value v)
   case MRB_TT_FLOAT:
     return mrb->float_class;
 
-#ifdef INCLUDE_REGEXP
-//  case MRB_TT_REGEX:
-//    return mrb->regex_class;
-//  case MRB_TT_MATCH:
-//    return mrb->match_class;
-//  case MRB_TT_DATA:
-//    return mrb->encode_class;
-#else
+#ifdef ENABLE_REGEXP
   case MRB_TT_REGEX:
   case MRB_TT_MATCH:
     mrb_raise(mrb, E_TYPE_ERROR, "type mismatch: %s given",
@@ -78,6 +71,10 @@ struct RClass* mrb_class_real(struct RClass* cl);
 
 void mrb_obj_call_init(mrb_state *mrb, mrb_value obj, int argc, mrb_value *argv);
 
+void mrb_gc_mark_mt(mrb_state*, struct RClass*);
+size_t mrb_gc_mark_mt_size(mrb_state*, struct RClass*);
+void mrb_gc_free_mt(mrb_state*, struct RClass*);
+
 #if defined(__cplusplus)
 }  /* extern "C" { */
 #endif

include/mruby/compile.h

@@ -15,12 +15,27 @@ extern "C" {
 #include <stdio.h>
 #include <setjmp.h>
 
+/* load context */
+typedef struct mrbc_context {
+  mrb_sym *syms;
+  int slen;
+  char *filename;
+  int lineno;
+  int capture_errors:1;
+  int dump_result:1;
+  int no_exec:1;
+} mrbc_context;
+
+mrbc_context* mrbc_context_new(mrb_state *mrb);
+void mrbc_context_free(mrb_state *mrb, mrbc_context *cxt);
+const char *mrbc_filename(mrb_state *mrb, mrbc_context *c, const char *s);
+
+/* AST node structure */
 typedef struct mrb_ast_node {
   struct mrb_ast_node *car, *cdr;
 } mrb_ast_node;
 
-#include <stdio.h>
-
+/* lexer states */
 enum mrb_lex_state_enum {
     EXPR_BEG,                   /* ignore newline, +/- is a sign. */
     EXPR_END,                   /* newline significant, +/- is an operator. */
@@ -36,21 +51,23 @@ enum mrb_lex_state_enum {
     EXPR_MAX_STATE
 };
 
+/* saved error message */
 struct mrb_parser_message {
   int lineno;
   int column;
   char* message;
 };
 
+/* parser structure */
 struct mrb_parser_state {
   mrb_state *mrb;
   struct mrb_pool *pool;
   mrb_ast_node *cells;
   const char *s, *send;
   FILE *f;
+  char *filename;
   int lineno;
   int column;
-  const char *filename;
 
   enum mrb_lex_state_enum lstate;
   int sterm;
@@ -59,6 +76,8 @@ struct mrb_parser_state {
   unsigned int cmdarg_stack;
   int paren_nest;
   int lpar_beg;
+  int in_def, in_single, cmd_start;
+  mrb_ast_node *locals;
 
   mrb_ast_node *pb;
   char buf[1024];
@@ -66,9 +85,6 @@ struct mrb_parser_state {
 
   mrb_ast_node *heredoc;
 
-  int in_def, in_single, cmd_start;
-  mrb_ast_node *locals;
-
   void *ylval;
 
   int nerr;
@@ -82,21 +98,24 @@ struct mrb_parser_state {
   jmp_buf jmp;
 };
 
-/* parser structure */
 struct mrb_parser_state* mrb_parser_new(mrb_state*);
+void mrb_parser_free(struct mrb_parser_state*);
 const char *mrb_parser_filename(struct mrb_parser_state*, const char*);
-int mrb_parser_lineno(struct mrb_parser_state*, int);
-void mrb_parser_parse(struct mrb_parser_state*);
+void mrb_parser_parse(struct mrb_parser_state*,mrbc_context*);
 
 /* utility functions */
-struct mrb_parser_state* mrb_parse_file(mrb_state*,FILE*);
-struct mrb_parser_state* mrb_parse_string(mrb_state*,const char*);
-struct mrb_parser_state* mrb_parse_nstring(mrb_state*,const char*,size_t);
+struct mrb_parser_state* mrb_parse_file(mrb_state*,FILE*,mrbc_context*);
+struct mrb_parser_state* mrb_parse_string(mrb_state*,const char*,mrbc_context*);
+struct mrb_parser_state* mrb_parse_nstring(mrb_state*,const char*,int,mrbc_context*);
 int mrb_generate_code(mrb_state*, mrb_ast_node*);
 
-int mrb_compile_file(mrb_state*,FILE*);
-int mrb_compile_string(mrb_state*,char*);
-int mrb_compile_nstring(mrb_state*,char*,size_t);
+/* program load functions */
+mrb_value mrb_load_file(mrb_state*,FILE*);
+mrb_value mrb_load_string(mrb_state *mrb, const char *s);
+mrb_value mrb_load_nstring(mrb_state *mrb, const char *s, int len);
+mrb_value mrb_load_file_cxt(mrb_state*,FILE*, mrbc_context *cxt);
+mrb_value mrb_load_string_cxt(mrb_state *mrb, const char *s, mrbc_context *cxt);
+mrb_value mrb_load_nstring_cxt(mrb_state *mrb, const char *s, int len, mrbc_context *cxt);
 
 #if defined(__cplusplus)
 }  /* extern "C" { */

include/mruby/hash.h

@@ -17,27 +17,20 @@ struct RHash {
   struct kh_ht *ht;
 };
 
-#define mrb_hash_end(h) st_hash_end(h)
-#define mrb_hash_uint(h, i) st_hash_uint(h, i)
-
 #define mrb_hash_ptr(v)    ((struct RHash*)((v).value.p))
 #define mrb_hash_value(p)  mrb_obj_value((void*)(p))
 
-mrb_value mrb_hash_new_capa(mrb_state*, size_t);
-mrb_value mrb_hash_new(mrb_state *mrb, int capa);
+mrb_value mrb_hash_new_capa(mrb_state*, int);
+mrb_value mrb_hash_new(mrb_state *mrb);
 
 void mrb_hash_set(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value val);
 mrb_value mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key);
-mrb_value mrb_hash_getWithDef(mrb_state *mrb, mrb_value hash, mrb_value vkey, mrb_value def);
-mrb_value mrb_hash_delete_key(mrb_state *mrb, mrb_value hash, mrb_value key);
+mrb_value mrb_hash_fetch(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value def);
 mrb_value mrb_hash(mrb_state *mrb, mrb_value obj);
-mrb_value mrb_check_hash_type(mrb_state *mrb, mrb_value self);
 
 /* RHASH_TBL allocates st_table if not available. */
 #define RHASH(obj)   ((struct RHash*)((obj).value.p))
 #define RHASH_TBL(h)          (RHASH(h)->ht)
-#define RHASH_SIZE(h)         (RHASH_TBL(h)->size)
-#define RHASH_EMPTY_P(h)      (RHASH_SIZE(h) == 0)
 #define RHASH_IFNONE(h)       mrb_iv_get(mrb, (h), mrb_intern(mrb, "ifnone"))
 #define RHASH_PROCDEFAULT(h)  RHASH_IFNONE(h)
 struct kh_ht * mrb_hash_tbl(mrb_state *mrb, mrb_value hash);
@@ -47,6 +40,11 @@ struct kh_ht * mrb_hash_tbl(mrb_state *mrb, mrb_value hash);
 
 mrb_value mrb_obj_is_proc(mrb_value proc);
 
+/* GC functions */
+void mrb_gc_mark_ht(mrb_state*, struct RHash*);
+size_t mrb_gc_mark_ht_size(mrb_state*, struct RHash*);
+void mrb_gc_free_ht(mrb_state*, struct RHash*);
+
 #if defined(__cplusplus)
 }  /* extern "C" { */
 #endif

include/mruby/numeric.h

@@ -13,15 +13,18 @@ extern "C" {
 
 #include <limits.h>
 
-#define RSHIFT(x,y) ((x)>>(int)(y))
 #define POSFIXABLE(f) ((f) <= INT_MAX)
 #define NEGFIXABLE(f) ((f) >= INT_MIN)
 #define FIXABLE(f) (POSFIXABLE(f) && NEGFIXABLE(f))
 
 mrb_value mrb_flt2big(mrb_state *mrb, mrb_float d);
-void mrb_num_zerodiv(mrb_state *mrb);
 mrb_value mrb_fix2str(mrb_state *mrb, mrb_value x, int base);
 
+mrb_value mrb_fixnum_plus(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_value mrb_fixnum_minus(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_value mrb_fixnum_mul(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_value mrb_num_div(mrb_state *mrb, mrb_value x, mrb_value y);
+
 #if defined(__cplusplus)
 }  /* extern "C" { */
 #endif

include/mruby/object.h

@@ -13,7 +13,7 @@ extern "C" {
 
 #define MRUBY_OBJECT_HEADER \
   enum mrb_vtype tt:8; \
-  int color:3;\
+  unsigned int color:3;\
   unsigned int flags:21;\
   struct RClass *c;\
   struct RBasic *gcnext

include/mruby/proc.h

@@ -49,6 +49,10 @@ struct RProc {
 struct RProc *mrb_proc_new(mrb_state*, mrb_irep*);
 struct RProc *mrb_proc_new_cfunc(mrb_state*, mrb_func_t);
 struct RProc *mrb_closure_new(mrb_state*, mrb_irep*);
+void mrb_proc_copy(struct RProc *a, struct RProc *b);
+
+#include "mruby/khash.h"
+KHASH_DECLARE(mt, mrb_sym, struct RProc*, 1);
 
 #if defined(__cplusplus)
 }  /* extern "C" { */

include/mruby/string.h

@@ -25,34 +25,33 @@ extern "C" {
 
 extern const char mrb_digitmap[];
 
+struct mrb_shared_string {
+  int refcnt;
+  char *ptr;
+  int len;
+};
+
 struct RString {
   MRUBY_OBJECT_HEADER;
   int len;
   union {
     int capa;
-    struct RString *shared;
+    struct mrb_shared_string *shared;
   } aux;
-  char *buf;
+  char *ptr;
 };
 
 #define mrb_str_ptr(s)    ((struct RString*)((s).value.p))
 #define RSTRING(s)        ((struct RString*)((s).value.p))
-#define RSTRING_PTR(s)    (RSTRING(s)->buf)
+#define RSTRING_PTR(s)    (RSTRING(s)->ptr)
 #define RSTRING_LEN(s)    (RSTRING(s)->len)
 #define RSTRING_CAPA(s)   (RSTRING(s)->aux.capa)
-#define RSTRING_END(s)    (RSTRING(s)->buf + RSTRING(s)->len)
-
+#define RSTRING_END(s)    (RSTRING(s)->ptr + RSTRING(s)->len)
 #define MRB_STR_SHARED      256
-#define MRB_STR_SHARED_P(s) (FL_ALL(s, MRB_STR_SHARED))
-#define MRB_STR_NOCAPA      (MRB_STR_SHARED)
-#define MRB_STR_NOCAPA_P(s) (FL_ANY(s, MRB_STR_NOCAPA))
-#define MRB_STR_UNSET_NOCAPA(s) do {\
-  FL_UNSET(s, MRB_STR_NOCAPA);\
-} while (0)
 
+void mrb_str_decref(mrb_state*, struct mrb_shared_string*);
 mrb_value mrb_str_literal(mrb_state*, mrb_value);
 void mrb_str_concat(mrb_state*, mrb_value, mrb_value);
-mrb_value mrb_obj_to_str(mrb_state*, mrb_value);
 mrb_value mrb_str_plus(mrb_state*, mrb_value, mrb_value);
 mrb_value mrb_obj_as_string(mrb_state *mrb, mrb_value obj);
 mrb_value mrb_str_resize(mrb_state *mrb, mrb_value str, int len); /* mrb_str_resize */
@@ -78,8 +77,6 @@ int mrb_str_hash_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2);
 mrb_value mrb_str_buf_append(mrb_state *mrb, mrb_value str, mrb_value str2);
 mrb_value mrb_str_inspect(mrb_state *mrb, mrb_value str);
 int mrb_str_equal(mrb_state *mrb, mrb_value str1, mrb_value str2);
-mrb_value * mrb_svar(mrb_int cnt);
-mrb_value mrb_str_drop_bytes(mrb_state *mrb, mrb_value str, long len);
 mrb_value mrb_str_dump(mrb_state *mrb, mrb_value str);
 mrb_value mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, long len);
 mrb_value mrb_str_append(mrb_state *mrb, mrb_value str, mrb_value str2);

include/mruby/struct.h

@@ -20,9 +20,6 @@ struct RStruct {
 #define RSTRUCT_LEN(st) ((int)(RSTRUCT(st)->len))
 #define RSTRUCT_PTR(st) (RSTRUCT(st)->ptr)
 
-mrb_value mrb_yield_values(int n, ...);
-mrb_value mrb_mod_module_eval(mrb_state *mrb, int argc, mrb_value *argv, mrb_value mod);
-
 #if defined(__cplusplus)
 }  /* extern "C" { */
 #endif

include/mruby/variable.h

@@ -14,12 +14,13 @@ extern "C" {
 typedef struct global_variable {
     int   counter;
     mrb_value *data;
-    mrb_value (*getter)();
-    void  (*setter)();
+    mrb_value (*getter)(void);
+    void  (*setter)(void);
     //void  (*marker)();
     //int block_trace;
     //struct trace_var *trace;
 } global_variable;
+
 struct global_entry {
     global_variable *var;
     mrb_sym id;
@@ -41,12 +42,23 @@ mrb_value mrb_obj_iv_get(mrb_state*, struct RObject*, mrb_sym);
 void mrb_obj_iv_set(mrb_state*, struct RObject*, mrb_sym, mrb_value);
 const char * mrb_class2name(mrb_state *mrb, struct RClass* klass);
 mrb_value mrb_iv_get(mrb_state *mrb, mrb_value obj, mrb_sym sym);
-void mrb_iv_set(mrb_state *mrb, mrb_value obj, mrb_sym sym, mrb_value v); /* mrb_iv_set */
-void mrb_copy_generic_ivar(mrb_value clone, mrb_value obj);
+void mrb_iv_set(mrb_state *mrb, mrb_value obj, mrb_sym sym, mrb_value v);
+mrb_value mrb_iv_remove(mrb_state *mrb, mrb_value obj, mrb_sym sym);
 int mrb_const_defined_at(mrb_state *mrb, struct RClass *klass, mrb_sym id);
 mrb_value mrb_f_global_variables(mrb_state *mrb, mrb_value self);
 mrb_value mrb_gv_get(mrb_state *mrb, mrb_sym sym);
 void mrb_gv_set(mrb_state *mrb, mrb_sym sym, mrb_value val);
+mrb_value mrb_obj_instance_variables(mrb_state*, mrb_value);
+
+/* GC functions */
+void mrb_gc_mark_gv(mrb_state*);
+void mrb_gc_free_gv(mrb_state*);
+void mrb_gc_mark_iv(mrb_state*, struct RObject*);
+size_t mrb_gc_mark_iv_size(mrb_state*, struct RObject*);
+void mrb_gc_free_iv(mrb_state*, struct RObject*);
+
+#include "mruby/khash.h"
+KHASH_DECLARE(iv, mrb_sym, mrb_value, 1)
 
 #if defined(__cplusplus)
 }  /* extern "C" { */

mrblib/Makefile

@@ -18,12 +18,19 @@ LIBR := ../lib/libmruby.a
 # libraries, includes
 INCLUDES = -I../src -I../include
 
-DEBUG_MODE = 1
-ifeq ($(DEBUG_MODE),1)
-CFLAGS = -g
-else
-CFLAGS = -O3
+ifeq ($(strip $(COMPILE_MODE)),)
+  # default compile option
+  COMPILE_MODE = debug
+endif
+
+ifeq ($(COMPILE_MODE),debug)
+  CFLAGS = -g -O3
+else ifeq ($(COMPILE_MODE),release)
+  CFLAGS = -O3
+else ifeq ($(COMPILE_MODE),small)
+  CFLAGS = -Os
 endif
+
 ALL_CFLAGS = -Wall -Werror-implicit-function-declaration $(CFLAGS)
 ifeq ($(OS),Windows_NT)
   MAKE_FLAGS = CC=$(CC) LL=$(LL) ALL_CFLAGS="$(ALL_CFLAGS)"

mrblib/class.rb

+class Module
+  # 15.2.2.4.13
+  def attr_reader(*names)
+    names.each{|name|
+      name2 = ('@'+name.to_s).intern
+      define_method(name){self.instance_variable_get(name2)}
+    }
+  end
+  # 15.2.2.4.14
+  def attr_writer(*names)
+    names.each{|name|
+      name2 = ('@'+name.to_s).intern
+      name = (name.to_s+"=").intern
+      define_method(name){|v|self.instance_variable_set(name2,v)}
+    }
+  end
+  # 15.2.2.4.12
+  def attr_accessor(*names)
+    attr_reader(*names)
+    attr_writer(*names)
+  end
+  # 15.2.2.4.11
+  def attr(name)
+    attr_reader(name)
+  end
+end

mrblib/error.rb

@@ -12,3 +12,53 @@ class Exception
     self.new(*args, &block)
   end
 end
+
+# ISO 15.2.24
+class ArgumentError < StandardError
+end
+
+# ISO 15.2.25
+class LocalJumpError < StandardError
+end
+
+# ISO 15.2.26
+class RangeError < StandardError
+end
+
+class FloatDomainError < RangeError
+end
+
+# ISO 15.2.26
+class RegexpError < StandardError
+end
+
+# ISO 15.2.29
+class TypeError < StandardError
+end
+
+# ISO 15.2.31
+class NameError < StandardError
+end
+
+# ISO 15.2.32
+class NoMethodError < NameError
+end
+
+# ISO 15.2.33
+class IndexError < StandardError
+end
+
+class KeyError < IndexError
+end
+
+# ISO 15.2.37
+class ScriptError < Exception
+end
+
+# ISO 15.2.38
+class SyntaxError < ScriptError
+end
+
+class NotImplementedError < ScriptError
+end
+

mrblib/hash.rb

@@ -80,6 +80,62 @@ class Hash
     end
     h
   end
+
+  # 1.8/1.9 Hash#reject! returns Hash; ISO says nothing.
+  def reject!(&b)
+    keys = []
+    self.each_key{|k|
+      v = self[k]
+      if b.call(k, v)
+        keys.push(k)
+      end
+    }
+    return nil if keys.size == 0
+    keys.each{|k|
+      self.delete(k)
+    }
+    self
+  end
+
+  # 1.8/1.9 Hash#reject returns Hash; ISO says nothing.
+  def reject(&b)
+    h = {}
+    self.each_key{|k|
+      v = self[k]
+      unless b.call(k, v)
+        h[k] = v
+      end
+    }
+    h
+  end
+
+  # 1.9 Hash#select! returns Hash; ISO says nothing.
+  def select!(&b)
+    keys = []
+    self.each_key{|k|
+      v = self[k]
+      unless b.call(k, v)
+        keys.push(k)
+      end
+    }
+    return nil if keys.size == 0
+    keys.each{|k|
+      self.delete(k)
+    }
+    self
+  end
+
+  # 1.9 Hash#select returns Hash; ISO says nothing.
+  def select(&b)
+    h = {}
+    self.each_key{|k|
+      v = self[k]
+      if b.call(k, v)
+        h[k] = v
+      end
+    }
+    h
+  end
 end
 
 ##

mrblib/kernel.rb

@@ -3,17 +3,6 @@
 #
 # ISO 15.3.1
 module Kernel
-
-  ##
-  # Takes the given block, create a lambda
-  # out of it and +call+ it.
-  #
-  # ISO 15.3.1.2.6
-  def self.lambda(&block)
-    ### *** TODO *** ###
-    block  # dummy
-  end
-
   ##
   # Calls the given block repetitively.
   #
@@ -24,27 +13,14 @@ module Kernel
     end
   end
 
-  ##
-  # Alias for +send+.
-  #
-  # ISO 15.3.1.3.4
-  #def __send__(symbol, *args, &block)
-    ### *** TODO *** ###
-  #end
-
-  # 15.3.1.3.18
-  def instance_eval(string=nil, &block)
-    ### *** TODO *** ###
-    raise "Not implemented yet"
+  # 15.3.1.2.3
+  def self.eval(s)
+    raise NotImplementedError.new("eval not implemented")
   end
 
-  ##
-  # Alias for +Kernel.lambda+.
-  #
-  # ISO 15.3.1.3.27
-  def lambda(&block)
-    ### *** TODO *** ###
-    block # dummy
+  # 15.3.1.3.12
+  def eval(s)
+    Kernel.eval(s)
   end
 
   ##

mrblib/print.rb

@@ -3,47 +3,76 @@
 #
 # ISO 15.3.1
 module Kernel
+  unless Kernel.respond_to?(:__printstr__)
+    def print(*a)
+      raise NotImplementedError.new('print not available')
+    end
+    def puts(*a)
+      raise NotImplementedError.new('puts not available')
+    end
+    def p(*a)
+      raise NotImplementedError.new('p not available')
+    end
+    def printf(*args)
+      raise NotImplementedError.new('printf not available')
+    end
+  else
+    unless Kernel.respond_to?(:sprintf)
+      def printf(*args)
+        raise NotImplementedError.new('printf not available')
+      end
+      def sprintf(*args)
+        raise NotImplementedError.new('sprintf not available')
+      end
+    end
+
 
-  ##
-  # Invoke method +print+ on STDOUT and passing +*args+
-  #
-  # ISO 15.3.1.2.10
-  def print(*args)
-    i = 0
-    len = args.size
-    while i < len
-      __printstr__ args[i].to_s
-      i += 1
+    ##
+    # Invoke method +print+ on STDOUT and passing +*args+
+    #
+    # ISO 15.3.1.2.10
+    def print(*args)
+      i = 0
+      len = args.size
+      while i < len
+        __printstr__ args[i].to_s
+        i += 1
+      end
     end
-  end
 
-  ##
-  # Invoke method +puts+ on STDOUT and passing +*args*+
-  #
-  # ISO 15.3.1.2.11
-  def puts(*args)
-    i = 0
-    len = args.size
-    while i < len
-      __printstr__ args[i].to_s
-      __printstr__ "\n"
-      i += 1
-    end
-    __printstr__ "\n" if len == 0
-  end
+    ##
+    # Invoke method +puts+ on STDOUT and passing +*args*+
+    #
+    # ISO 15.3.1.2.11
+    def puts(*args)
+      i = 0
+      len = args.size
+      while i < len
+        __printstr__ args[i].to_s
+        __printstr__ "\n"
+        i += 1
+      end
+      __printstr__ "\n" if len == 0
+      nil
+    end
 
-  ##
-  # Print human readable object description
-  #
-  # ISO 15.3.1.3.34
-  def p(*args)
-    i = 0
-    len = args.size
-    while i < len
-      __printstr__ args[i].inspect
-      __printstr__ "\n"
-      i += 1
-    end
-    args[0]
+    ##
+    # Print human readable object description
+    #
+    # ISO 15.3.1.3.34
+    def p(*args)
+      i = 0
+      len = args.size
+      while i < len
+        __printstr__ args[i].inspect
+        __printstr__ "\n"
+        i += 1
+      end
+      args[0]
+    end
+
+    def printf(*args)
+      __printstr__(sprintf(*args))
+    end
   end
 end

mrblib/string.rb

@@ -33,12 +33,15 @@ class String
     end
 
     ### *** TODO *** ###
+    unless Object.const_defined?(:Regexp)
+      raise NotImplementedError, "gsub not available (yet)"
+    end
   end
 
   ##
   # Replace all matches of +pattern+ with +replacement+.
   # Call block (if given) for each match and replace
-  # +pattern+ with the value of the block. Modify 
+  # +pattern+ with the value of the block. Modify
   # +self+ with the final value.
   #
   # ISO 15.2.10.5.19
@@ -56,15 +59,18 @@ class String
   # Calls the given block for each match of +pattern+
   # If no block is given return an array with all
   # matches of +pattern+.
-  # 
+  #
   # ISO 15.2.10.5.32
   def scan(reg, &block)
     ### *** TODO *** ###
+    unless Object.const_defined?(:Regexp)
+      raise NotImplementedError, "scan not available (yet)"
+    end
   end
 
   ##
-  # Replace only the first match of +pattern+ with 
-  # +replacement+. Call block (if given) for each 
+  # Replace only the first match of +pattern+ with
+  # +replacement+. Call block (if given) for each
   # match and replace +pattern+ with the value of the
   # block. Return the final value.
   #
@@ -75,12 +81,15 @@ class String
     end
 
     ### *** TODO *** ###
+    unless Object.const_defined?(:Regexp)
+      raise NotImplementedError, "sub not available (yet)"
+    end
   end
 
   ##
-  # Replace only the first match of +pattern+ with   
-  # +replacement+. Call block (if given) for each 
-  # match and replace +pattern+ with the value of the 
+  # Replace only the first match of +pattern+ with
+  # +replacement+. Call block (if given) for each
+  # match and replace +pattern+ with the value of the
   # block. Modify +self+ with the final value.
   #
   # ISO 15.2.10.5.37

mrblib/struct.rb

@@ -2,45 +2,49 @@
 # Struct
 #
 # ISO 15.2.18
-class Struct
 
-  ##
-  # Calls the given block for each element of +self+
-  # and pass the respective element.
-  #
-  # ISO 15.2.18.4.4
-  def each(&block)
-    self.class.members.each{|field|
-      block.call(self[field])
-    }
-    self
-  end
+if Object.const_defined?(:Struct)
+  class Struct
 
-  ##
-  # Calls the given block for each element of +self+
-  # and pass the name and value of the respectiev
-  # element.
-  #
-  # ISO 15.2.18.4.5
-  def each_pair(&block)
-    self.class.members.each{|field|
-      block.call(field.to_sym, self[field])
-    }
-    self
-  end
+    ##
+    # Calls the given block for each element of +self+
+    # and pass the respective element.
+    #
+    # ISO 15.2.18.4.4
+    def each(&block)
+      self.class.members.each{|field|
+        block.call(self[field])
+      }
+      self
+    end
 
-  ##
-  # Calls the given block for each element of +self+
-  # and returns an array with all elements of which
-  # block is not false.
-  #
-  # ISO 15.2.18.4.7
-  def select(&block)
-    ary = []
-    self.class.members.each{|field|
-      val = self[field]
-      ary.push(val) if block.call(val)
-    }
-    ary
+    ##
+    # Calls the given block for each element of +self+
+    # and pass the name and value of the respectiev
+    # element.
+    #
+    # ISO 15.2.18.4.5
+    def each_pair(&block)
+      self.class.members.each{|field|
+        block.call(field.to_sym, self[field])
+      }
+      self
+    end
+
+    ##
+    # Calls the given block for each element of +self+
+    # and returns an array with all elements of which
+    # block is not false.
+    #
+    # ISO 15.2.18.4.7
+    def select(&block)
+      ary = []
+      self.class.members.each{|field|
+        val = self[field]
+        ary.push(val) if block.call(val)
+      }
+      ary
+    end
   end
 end
+

mruby/HelloMRuby/hello_mruby.c

-//
-//  hello_mruby.c
-//  mruby
-//
-//  Created by Paolo Bosetti on 5/22/12.
-//  Copyright (c) 2012 __MyCompanyName__. All rights reserved.
-//
-
-#include <stdio.h>

src/Makefile

@@ -19,12 +19,19 @@ OBJS := $(OBJ1) $(OBJ2) $(OBJ3)
 # libraries, includes
 INCLUDES = -I$(BASEDIR) -I$(BASEDIR)/../include
 
-DEBUG_MODE = 1
-ifeq ($(DEBUG_MODE),1)
-CFLAGS = -g -O3
-else
-CFLAGS = -O3
+ifeq ($(strip $(COMPILE_MODE)),)
+  # default compile option
+  COMPILE_MODE = debug
 endif
+
+ifeq ($(COMPILE_MODE),debug)
+  CFLAGS = -g -O3
+else ifeq ($(COMPILE_MODE),release)
+  CFLAGS = -O3
+else ifeq ($(COMPILE_MODE),small)
+  CFLAGS = -Os
+endif
+
 ALL_CFLAGS = -Wall -Werror-implicit-function-declaration $(CFLAGS)
 
 

src/cdump.c

@@ -10,7 +10,6 @@
 
 #include "mruby/irep.h"
 #include "mruby/string.h"
-#include "re.h"
 
 #define MRB_CDUMP_LINE_LEN 128
 
@@ -45,7 +44,7 @@ str_format_len(mrb_value str)
 
   char *src;
 
-  for (src = RSTRING_PTR(str); src < RSTRING_END(str);) {
+  for (src = RSTRING_PTR(str); src < RSTRING_END(str); src++) {
     switch (*src) {
     case 0x07:/* BEL */ /* fall through */
     case 0x08:/* BS  */ /* fall through */
@@ -58,11 +57,11 @@ str_format_len(mrb_value str)
     case 0x27:/* '   */ /* fall through */
     case 0x3F:/* ?   */ /* fall through */
     case 0x5C:/* \   */ /* fall through */
-      dump_len += 2; src += 2;
+      dump_len += 2;
       break;
 
     default:
-      dump_len++; src++;
+      dump_len++;
       break;
     }
   }
@@ -73,22 +72,23 @@ str_format_len(mrb_value str)
 static char*
 str_to_format(mrb_value str, char *buf)
 {
-  char *src, *dst;
+  char *src;
+  char *dst;
 
-  for (src = RSTRING_PTR(str), dst = buf; src < RSTRING_END(str);) {
+  for (src = RSTRING_PTR(str), dst = buf; src < RSTRING_END(str); src++) {
     switch (*src) {
-    case 0x07:/* BEL */  memcpy(dst, "\\a", 2); dst+=2; src+=2; break;
-    case 0x08:/* BS  */  memcpy(dst, "\\b", 2); dst+=2; src+=2; break;
-    case 0x09:/* HT  */  memcpy(dst, "\\t", 2); dst+=2; src+=2; break;
-    case 0x0A:/* LF  */  memcpy(dst, "\\n", 2); dst+=2; src+=2; break;
-    case 0x0B:/* VT  */  memcpy(dst, "\\v", 2); dst+=2; src+=2; break;
-    case 0x0C:/* FF  */  memcpy(dst, "\\f", 2); dst+=2; src+=2; break;
-    case 0x0D:/* CR  */  memcpy(dst, "\\r", 2); dst+=2; src+=2; break;
-    case 0x22:/* "   */  memcpy(dst, "\\\"", 2); dst+=2; src+=2; break;
-    case 0x27:/* '   */  memcpy(dst, "\\\'", 2); dst+=2; src+=2; break;
-    case 0x3F:/* ?   */  memcpy(dst, "\\\?", 2); dst+=2; src+=2; break;
-    case 0x5C:/* \   */  memcpy(dst, "\\\\", 2); dst+=2; src+=2; break;
-    default: *dst++ = *src++; break;
+    case 0x07:/* BEL */  *dst++ = '\\'; *dst++ = 'a'; break;
+    case 0x08:/* BS  */  *dst++ = '\\'; *dst++ = 'b'; break;
+    case 0x09:/* HT  */  *dst++ = '\\'; *dst++ = 't'; break;
+    case 0x0A:/* LF  */  *dst++ = '\\'; *dst++ = 'n'; break;
+    case 0x0B:/* VT  */  *dst++ = '\\'; *dst++ = 'v'; break;
+    case 0x0C:/* FF  */  *dst++ = '\\'; *dst++ = 'f'; break;
+    case 0x0D:/* CR  */  *dst++ = '\\'; *dst++ = 'r'; break;
+    case 0x22:/* "   */  *dst++ = '\\'; *dst++ = '\"'; break;
+    case 0x27:/* '   */  *dst++ = '\\'; *dst++ = '\''; break;
+    case 0x3F:/* ?   */  *dst++ = '\\'; *dst++ = '\?'; break;
+    case 0x5C:/* \   */  *dst++ = '\\'; *dst++ = '\\'; break;
+    default: *dst++ = *src; break;
     }
   }
 
@@ -107,10 +107,11 @@ make_cdump_irep(mrb_state *mrb, int irep_no, FILE *f)
     return -1;
 
   buf_len = MRB_CDUMP_LINE_LEN;
-  if ((buf = mrb_malloc(mrb, buf_len)) == 0 ) {
+  if ((buf = (char *)mrb_malloc(mrb, buf_len)) == 0 ) {
     return MRB_CDUMP_GENERAL_FAILURE;
   }
 
+  SOURCE_CODE0     ("  ai = mrb->arena_idx;");
   SOURCE_CODE0     ("  irep = mrb->irep[idx] = mrb_malloc(mrb, sizeof(mrb_irep));");
   SOURCE_CODE0     ("  irep->idx = idx++;");
   SOURCE_CODE      ("  irep->flags = %d | MRB_ISEQ_NOFREE;",                          irep->flags);
@@ -137,11 +138,13 @@ make_cdump_irep(mrb_state *mrb, int irep_no, FILE *f)
       switch (irep->pool[n].tt) {
       case MRB_TT_FLOAT:
         SOURCE_CODE("  irep->pool[%d] = mrb_float_value(%.16e);",                     n, irep->pool[n].value.f); break;
-      case MRB_TT_STRING:
+      case MRB_TT_FIXNUM:
+        SOURCE_CODE("  irep->pool[%d] = mrb_fixnum_value(%d);",                       n, irep->pool[n].value.i); break; 
+     case MRB_TT_STRING:
         str_len = str_format_len(irep->pool[n]) + 1;
         if ( str_len > buf_len ) {
           buf_len = str_len;
-          if ((buf = mrb_realloc(mrb, buf, buf_len)) == 0 ) {
+          if ((buf = (char *)mrb_realloc(mrb, buf, buf_len)) == 0 ) {
             return MRB_CDUMP_GENERAL_FAILURE;
           }
         }
@@ -154,6 +157,8 @@ make_cdump_irep(mrb_state *mrb, int irep_no, FILE *f)
   }
   else
     SOURCE_CODE0   ("  irep->pool = NULL;");
+  SOURCE_CODE0     ("  mrb->irep_len = idx;");
+  SOURCE_CODE0     ("  mrb->arena_idx = ai;");
   SOURCE_CODE0("");
   return MRB_CDUMP_OK;
 }
@@ -184,6 +189,7 @@ mrb_cdump_irep(mrb_state *mrb, int n, FILE *f,const char *initname)
   SOURCE_CODE0("{");
   SOURCE_CODE0("  int n = mrb->irep_len;");
   SOURCE_CODE0("  int idx = n;");
+  SOURCE_CODE0("  int ai;");
   SOURCE_CODE0("  mrb_irep *irep;");
   SOURCE_CODE0("");
   SOURCE_CODE ("  mrb_add_irep(mrb, idx+%d);",  irep_num);
@@ -193,9 +199,6 @@ mrb_cdump_irep(mrb_state *mrb, int n, FILE *f,const char *initname)
       return -1;
   }
 
-  SOURCE_CODE0("  mrb->irep_len = idx;");
-  SOURCE_CODE0("");
-  SOURCE_CODE0("  extern mrb_value mrb_top_self(mrb_state *mrb);");
   SOURCE_CODE0("  mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb));");
   SOURCE_CODE0("}");
 

src/compar.c

@@ -5,41 +5,6 @@
 */
 
 #include "mruby.h"
-#include "mruby/string.h"
-#include "mruby/numeric.h"
-
-void
-mrb_cmperr(mrb_state *mrb, mrb_value x, mrb_value y)
-{
-  const char *classname;
-
-  if (SPECIAL_CONST_P(y)) {
-    y = mrb_inspect(mrb, y);
-    classname = mrb_string_value_ptr(mrb, y);
-  }
-  else {
-    classname = mrb_obj_classname(mrb, y);
-  }
-  mrb_raise(mrb, E_ARGUMENT_ERROR, "comparison of %s with %s failed",
-            mrb_obj_classname(mrb, x), classname);
-}
-
-int
-mrb_cmpint(mrb_state *mrb, mrb_value val, mrb_value a, mrb_value b)
-{
-  if (mrb_nil_p(val)) {
-    mrb_cmperr(mrb, a, b);
-  }
-  if (FIXNUM_P(val)) {
-      long l = mrb_fixnum(val);
-      if (l > 0) return 1;
-      if (l < 0) return -1;
-      return 0;
-  }
-  if (mrb_test(mrb_funcall(mrb, val, ">", 1, mrb_fixnum_value(0)))) return 1;
-  if (mrb_test(mrb_funcall(mrb, val, "<", 1, mrb_fixnum_value(0)))) return -1;
-  return 0;
-}
 
 void
 mrb_init_comparable(mrb_state *mrb)

src/dump.c

@@ -8,7 +8,7 @@
 #include "mruby/dump.h"
 
 #include "mruby/string.h"
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
 #include "re.h"
 #endif
 #include "mruby/irep.h"
@@ -222,22 +222,23 @@ get_pool_block_size(mrb_state *mrb, mrb_irep *irep, int type)
 
   for (pool_no = 0; pool_no < irep->plen; pool_no++) {
     uint16_t nlen =0;
+    int len;
 
     switch (irep->pool[pool_no].tt) {
     case MRB_TT_FIXNUM:
-      sprintf( buf, "%d", irep->pool[pool_no].value.i);
-      size += strlen(buf);
+      len = sprintf( buf, "%d", irep->pool[pool_no].value.i);
+      size += (uint32_t)len;
       break;
     case MRB_TT_FLOAT:
-      sprintf( buf, "%.16e", irep->pool[pool_no].value.f);
-      size += strlen(buf);
+      len = sprintf( buf, "%.16e", irep->pool[pool_no].value.f);
+      size += (uint32_t)len;
       break;
     case MRB_TT_STRING:
       str = mrb_string_value( mrb, &irep->pool[pool_no]);
       nlen = str_dump_len(RSTRING_PTR(str), RSTRING_LEN(str), type);
       size += nlen;
       break;
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
     case MRB_TT_REGEX:
       str = mrb_reg_to_s(mrb, irep->pool[pool_no]);
       nlen = str_dump_len(RSTRING_PTR(str), RSTRING_LEN(str), type);
@@ -268,8 +269,10 @@ get_syms_block_size(mrb_state *mrb, mrb_irep *irep, int type)
 
     size += DUMP_SIZE(MRB_DUMP_SIZE_OF_SHORT, type); /* snl(n) */
     if (irep->syms[sym_no] != 0) {
-      name = mrb_sym2name(mrb, irep->syms[sym_no]);
-      nlen = str_dump_len((char*)name, strlen(name), type);
+      int len;
+
+      name = mrb_sym2name_len(mrb, irep->syms[sym_no], &len);
+      nlen = str_dump_len((char*)name, len, type);
       size += nlen; /* sn(n) */
     }
   }
@@ -329,9 +332,10 @@ write_pool_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type)
   char *buf_top = buf;
   char *char_buf;
   uint16_t buf_size =0;
+  int len;
 
   buf_size = MRB_DUMP_DEFAULT_STR_LEN;
-  if ((char_buf = mrb_malloc(mrb, buf_size)) == 0)
+  if ((char_buf = (char *)mrb_malloc(mrb, buf_size)) == 0)
     goto error_exit;
 
   buf += uint32_dump((uint32_t)irep->plen, buf, type); /* number of pool */
@@ -356,14 +360,14 @@ write_pool_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type)
       nlen = str_dump_len(RSTRING_PTR(str), RSTRING_LEN(str), type);
       if ( nlen > buf_size - 1) {
         buf_size = nlen + 1;
-        if ((char_buf = mrb_realloc(mrb, char_buf, buf_size)) == 0)
+        if ((char_buf = (char *)mrb_realloc(mrb, char_buf, buf_size)) == 0)
           goto error_exit;
         memset(char_buf, 0, buf_size);
       }
       str_dump(RSTRING_PTR(str), char_buf, RSTRING_LEN(str), type);
       break;
 
-#ifdef INCLUDE_REGEXP
+#ifdef ENABLE_REGEXP
     case MRB_TT_REGEX:
       str = mrb_reg_to_s(mrb, irep->pool[pool_no]);
       nlen = str_dump_len(RSTRING_PTR(str), RSTRING_LEN(str), type);
@@ -382,10 +386,12 @@ write_pool_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type)
       continue;
     }
 
-    buf += uint16_dump((uint16_t)strlen(char_buf), buf, type); /* data length */
+    len = strlen(char_buf);
 
-    memcpy(buf, char_buf, strlen(char_buf));
-    buf += strlen(char_buf);
+    buf += uint16_dump((uint16_t)len, buf, type); /* data length */
+
+    memcpy(buf, char_buf, len);
+    buf += len;
   }
 
 error_exit:
@@ -403,7 +409,7 @@ write_syms_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type)
   uint16_t buf_size =0;
 
   buf_size = MRB_DUMP_DEFAULT_STR_LEN;
-  if ((char_buf = mrb_malloc(mrb, buf_size)) == 0)
+  if ((char_buf = (char *)mrb_malloc(mrb, buf_size)) == 0)
     goto error_exit;
 
   buf += uint32_dump((uint32_t)irep->slen, buf, type); /* number of symbol */
@@ -413,15 +419,17 @@ write_syms_block(mrb_state *mrb, mrb_irep *irep, char *buf, int type)
     uint16_t nlen =0;
 
     if (irep->syms[sym_no] != 0) {
-      name = mrb_sym2name(mrb, irep->syms[sym_no]);
-      nlen = str_dump_len((char*)name, strlen(name), type);
+      int len;
+
+      name = mrb_sym2name_len(mrb, irep->syms[sym_no], &len);
+      nlen = str_dump_len((char*)name, len, type);
       if ( nlen > buf_size - 1) {
         buf_size = nlen + 1;
-        if ((char_buf = mrb_realloc(mrb, char_buf, buf_size)) == 0)
+        if ((char_buf = (char *)mrb_realloc(mrb, char_buf, buf_size)) == 0)
           goto error_exit;
       }
       memset(char_buf, 0, buf_size);
-      str_dump((char*)name, char_buf, strlen(name), type);
+      str_dump((char*)name, char_buf, len, type);
 
       buf += uint16_dump(nlen, buf, type); /* length of symbol name */
       memcpy(buf, char_buf, nlen); /* symbol name */
@@ -453,11 +461,10 @@ calc_crc_section(mrb_state *mrb, mrb_irep *irep, uint16_t *crc, int section)
   default: return MRB_DUMP_GENERAL_FAILURE;
   }
 
-  if ((buf = mrb_malloc(mrb, buf_size)) == 0)
+  if ((buf = (char *)mrb_calloc(mrb, 1, buf_size)) == 0)
     return MRB_DUMP_GENERAL_FAILURE;
 
   buf_top = buf;
-  memset(buf, 0, buf_size);
 
   switch (section) {
   case DUMP_IREP_HEADER: buf += write_irep_header(mrb, irep, buf, type); break;
@@ -591,13 +598,13 @@ dump_irep_record(mrb_state *mrb, int irep_no, FILE* fp, uint32_t *rlen)
   if (irep_record_size == 0)
     return MRB_DUMP_GENERAL_FAILURE;
 
-  if ((buf = mrb_malloc(mrb, irep_record_size)) == 0)
+  if ((buf = (char *)mrb_calloc(mrb, 1, irep_record_size)) == 0)
     return MRB_DUMP_GENERAL_FAILURE;
 
-  memset( buf, 0, irep_record_size);
-
-  if ((rc = write_irep_record(mrb, irep_no, buf, rlen, DUMP_TYPE_HEX)) != MRB_DUMP_OK)
+  if ((rc = write_irep_record(mrb, irep_no, buf, rlen, DUMP_TYPE_HEX)) != MRB_DUMP_OK) {
+    rc = MRB_DUMP_GENERAL_FAILURE;
     goto error_exit;
+  }
 
 
   if (fwrite(buf, irep_record_size, 1, fp) != 1)
@@ -683,7 +690,7 @@ mrb_bdump_irep(mrb_state *mrb, int n, FILE *f,const char *initname)
     buf_size += get_irep_record_size(mrb, irep_no, DUMP_TYPE_BIN);
   buf_size += MRB_DUMP_SIZE_OF_LONG; /* end of file */
 
-  if ((buf = mrb_malloc(mrb, buf_size)) == 0)
+  if ((buf = (char *)mrb_malloc(mrb, buf_size)) == 0)
     return MRB_DUMP_GENERAL_FAILURE;
 
   rc = mrb_write_irep(mrb, n, buf);

src/re.h

@@ -13,6 +13,7 @@
 #include "node.h"
 #include "regex.h"
 #include "encoding.h"
+#include "st.h"
 
 #define BEG(no) regs->beg[no]
 #define END(no) regs->end[no]