webruby 0.2.5 → 0.2.7

data/modules/emscripten/tools/js_optimizer.py

@@ -24,41 +24,16 @@ import_sig = re.compile('var ([_\w$]+) *=[^;]+;')
 
 class Minifier:
   '''
-    asm.js minification support. We calculate possible names and minification of
+    asm.js minification support. We calculate minification of
     globals here, then pass that into the parallel js-optimizer.js runners which
     during registerize perform minification of locals.
   '''
 
-  def __init__(self, js, js_engine, MAX_NAMES):
+  def __init__(self, js, js_engine):
     self.js = js
     self.js_engine = js_engine
-    MAX_NAMES = min(MAX_NAMES, 120000)
-
-    # Create list of valid short names
-
-    INVALID_2 = set(['do', 'if', 'in'])
-    INVALID_3 = set(['for', 'new', 'try', 'var', 'env', 'let'])
-
-    self.names = []
-    init_possibles = string.ascii_letters + '_$'
-    later_possibles = init_possibles + string.digits
-    for a in init_possibles:
-      if len(self.names) >= MAX_NAMES: break
-      self.names.append(a)
-    for a in init_possibles:
-      for b in later_possibles:
-        if len(self.names) >= MAX_NAMES: break
-        curr = a + b
-        if curr not in INVALID_2: self.names.append(curr)
-    for a in init_possibles:
-      for b in later_possibles:
-        for c in later_possibles:
-          if len(self.names) >= MAX_NAMES: break
-          curr = a + b + c
-          if curr not in INVALID_3: self.names.append(curr)
 
   def minify_shell(self, shell, minify_whitespace, source_map=False):
-    #print >> sys.stderr, "MINIFY SHELL 1111111111", shell, "\n222222222222222"
     # Run through js-optimizer.js to find and minify the global symbols
     # We send it the globals, which it parses at the proper time. JS decides how
     # to minify all global names, we receive a dictionary back, which is then
@@ -91,7 +66,6 @@ class Minifier:
 
   def serialize(self):
     return {
-      'names': self.names,
       'globals': self.globs
     }
 
@@ -187,7 +161,7 @@ EMSCRIPTEN_FUNCS();
       js = js[start_funcs + len(start_funcs_marker):end_funcs]
 
       # we assume there is a maximum of one new name per line
-      minifier = Minifier(js, js_engine, js.count('\n') + asm_shell.count('\n'))
+      minifier = Minifier(js, js_engine)
       asm_shell_pre, asm_shell_post = minifier.minify_shell(asm_shell, 'minifyWhitespace' in passes, source_map).split('EMSCRIPTEN_FUNCS();');
       asm_shell_post = asm_shell_post.replace('});', '})');
       pre += asm_shell_pre + '\n' + start_funcs_marker

data/modules/emscripten/tools/shared.py

@@ -272,9 +272,17 @@ if EM_POPEN_WORKAROUND and os.name == 'nt':
 
 EXPECTED_LLVM_VERSION = (3,2)
 
+actual_clang_version = None
+
+def get_clang_version():
+  global actual_clang_version
+  if actual_clang_version is None:
+    actual_clang_version = Popen([CLANG, '-v'], stderr=PIPE).communicate()[1].split('\n')[0].split(' ')[2]
+  return actual_clang_version
+
 def check_clang_version():
-  expected = 'clang version ' + '.'.join(map(str, EXPECTED_LLVM_VERSION))
-  actual = Popen([CLANG, '-v'], stderr=PIPE).communicate()[1].split('\n')[0]
+  expected = '.'.join(map(str, EXPECTED_LLVM_VERSION))
+  actual = get_clang_version()
   if expected in actual:
     return True
   logging.warning('LLVM version appears incorrect (seeing "%s", expected "%s")' % (actual, expected))
@@ -286,6 +294,21 @@ def check_llvm_version():
   except Exception, e:
     logging.warning('Could not verify LLVM version: %s' % str(e))
 
+def check_fastcomp():
+  try:
+    llc_version_info = Popen([LLVM_COMPILER, '--version'], stdout=PIPE).communicate()[0]
+    pre, targets = llc_version_info.split('Registered Targets:')
+    if 'js' not in targets or 'JavaScript (asm.js, emscripten) backend' not in targets:
+      logging.critical('fastcomp in use, but LLVM has not been built with the JavaScript backend as a target, llc reports:')
+      print >> sys.stderr, '==========================================================================='
+      print >> sys.stderr, llc_version_info,
+      print >> sys.stderr, '==========================================================================='
+      return False
+    return True
+  except Exception, e:
+    logging.warning('cound not check fastcomp: %s' % str(e))
+    return True
+
 EXPECTED_NODE_VERSION = (0,8,0)
 
 def check_node_version():
@@ -322,10 +345,10 @@ def find_temp_directory():
 # we re-check sanity when the settings are changed)
 # We also re-check sanity and clear the cache when the version changes
 
-EMSCRIPTEN_VERSION = '1.8.0'
+EMSCRIPTEN_VERSION = '1.8.6'
 
 def generate_sanity():
-  return EMSCRIPTEN_VERSION + '|' + get_llvm_target() + '|' + LLVM_ROOT
+  return EMSCRIPTEN_VERSION + '|' + get_llvm_target() + '|' + LLVM_ROOT + '|' + get_clang_version()
 
 def check_sanity(force=False):
   try:
@@ -353,9 +376,11 @@ def check_sanity(force=False):
       Cache.erase()
       force = False # the check actually failed, so definitely write out the sanity file, to avoid others later seeing failures too
 
-    # some warning, not fatal checks - do them even if EM_IGNORE_SANITY is on
+    # some warning, mostly not fatal checks - do them even if EM_IGNORE_SANITY is on
     check_llvm_version()
     check_node_version()
+    if os.environ.get('EMCC_FAST_COMPILER') == '1':
+      fastcomp_ok = check_fastcomp()
 
     if os.environ.get('EM_IGNORE_SANITY'):
       logging.info('EM_IGNORE_SANITY set, ignoring sanity checks')
@@ -377,6 +402,11 @@ def check_sanity(force=False):
         logging.critical('Cannot find %s, check the paths in %s' % (cmd, EM_CONFIG))
         sys.exit(1)
 
+    if os.environ.get('EMCC_FAST_COMPILER') == '1':
+      if not fastcomp_ok:
+        logging.critical('failing sanity checks due to previous fastcomp failure')
+        sys.exit(1)
+
     try:
       subprocess.call([JAVA, '-version'], stdout=PIPE, stderr=PIPE)
     except:
@@ -1141,6 +1171,8 @@ class Building:
     if type(opts) is int:
       opts = Building.pick_llvm_opts(opts)
     #opts += ['-debug-pass=Arguments']
+    if get_clang_version() == '3.4' and not Settings.SIMD:
+      opts += ['-disable-loop-vectorization', '-disable-slp-vectorization'] # llvm 3.4 has these on by default
     logging.debug('emcc: LLVM opts: ' + str(opts))
     target = out or (filename + '.opt.bc')
     output = Popen([LLVM_OPT, filename] + opts + ['-o', target], stdout=PIPE).communicate()[0]
@@ -1382,6 +1414,8 @@ class Building:
     if not os.path.exists(CLOSURE_COMPILER):
       raise Exception('Closure compiler appears to be missing, looked at: ' + str(CLOSURE_COMPILER))
 
+    CLOSURE_EXTERNS = path_from_root('src', 'closure-externs.js')
+
     # Something like this (adjust memory as needed):
     #   java -Xmx1024m -jar CLOSURE_COMPILER --compilation_level ADVANCED_OPTIMIZATIONS --variable_map_output_file src.cpp.o.js.vars --js src.cpp.o.js --js_output_file src.cpp.o.cc.js
     args = [JAVA,
@@ -1389,6 +1423,7 @@ class Building:
             '-jar', CLOSURE_COMPILER,
             '--compilation_level', 'ADVANCED_OPTIMIZATIONS',
             '--language_in', 'ECMASCRIPT5',
+            '--externs', CLOSURE_EXTERNS,
             #'--variable_map_output_file', filename + '.vars',
             '--js', filename, '--js_output_file', filename + '.cc.js']
     if pretty: args += ['--formatting', 'PRETTY_PRINT']
@@ -1438,7 +1473,7 @@ class Building:
   @staticmethod
   def ensure_relooper(relooper):
     if os.path.exists(relooper): return
-    if os.environ.get('EMCC_FAST_COMPILER'):
+    if os.environ.get('EMCC_FAST_COMPILER') == '1':
       logging.debug('not building relooper to js, using it in c++ backend')
       return
 
@@ -1513,6 +1548,8 @@ class Building:
       text = m.groups(0)[0]
       assert text.count('(') == 1 and text.count(')') == 1, 'must have simple expressions in emscripten_jcache_printf calls, no parens'
       assert text.count('"') == 2, 'must have simple expressions in emscripten_jcache_printf calls, no strings as varargs parameters'
+      if os.environ.get('EMCC_FAST_COMPILER') == '1': # fake it in fastcomp
+        return text.replace('emscripten_jcache_printf', 'printf')
       start = text.index('(')
       end = text.rindex(')')
       args = text[start+1:end].split(',')

data/modules/mruby/include/mruby/value.h

@@ -155,7 +155,7 @@ typedef struct mrb_value {
 #define mrb_tt(o)       (((o).value.ttt & 0xfc000)>>14)
 #define mrb_mktt(tt)    (0xfff00000|((tt)<<14))
 #define mrb_type(o)     ((uint32_t)0xfff00000 < (o).value.ttt ? mrb_tt(o) : MRB_TT_FLOAT)
-#define mrb_ptr(o)      ((void*)((((intptr_t)0x3fffffffffff)&((intptr_t)((o).value.p)))<<2))
+#define mrb_ptr(o)      ((void*)((((uintptr_t)0x3fffffffffff)&((uintptr_t)((o).value.p)))<<2))
 #define mrb_float(o)    (o).f
 
 #define MRB_SET_VALUE(o, tt, attr, v) do {\
@@ -166,7 +166,7 @@ typedef struct mrb_value {
   case MRB_TT_UNDEF:\
   case MRB_TT_FIXNUM:\
   case MRB_TT_SYMBOL: (o).attr = (v); break;\
-  default: (o).value.i = 0; (o).value.p = (void*)((intptr_t)(o).value.p | (((intptr_t)(v))>>2)); break;\
+  default: (o).value.i = 0; (o).value.p = (void*)((uintptr_t)(o).value.p | (((uintptr_t)(v))>>2)); break;\
   }\
 } while (0)
 
@@ -315,6 +315,7 @@ mrb_float_value(struct mrb_state *mrb, mrb_float f)
 #define mrb_bool(o)   ((o).w != MRB_Qnil && (o).w != MRB_Qfalse)
 
 #else
+
 #define mrb_cptr(o) mrb_ptr(o)
 #define mrb_fixnum_p(o) (mrb_type(o) == MRB_TT_FIXNUM)
 #define mrb_undef_p(o) (mrb_type(o) == MRB_TT_UNDEF)

data/modules/mruby/mrbgems/mruby-bin-mirb/tools/mirb/mirb.c

@@ -8,21 +8,17 @@
 
 #include <stdlib.h>
 #include <string.h>
-
-#include <mruby.h>
+#include "mruby.h"
 #include "mruby/array.h"
-#include <mruby/proc.h>
-#include <mruby/data.h>
-#include <mruby/compile.h>
+#include "mruby/proc.h"
+#include "mruby/compile.h"
+#include "mruby/string.h"
+
 #ifdef ENABLE_READLINE
 #include <limits.h>
 #include <readline/readline.h>
 #include <readline/history.h>
-#endif
-#include <mruby/string.h>
 
-
-#ifdef ENABLE_READLINE
 static const char *history_file_name = ".mirb_history";
 char history_path[PATH_MAX];
 #endif

data/modules/mruby/mrbgems/mruby-bin-mruby/tools/mruby/mruby.c

@@ -1,13 +1,11 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
 #include "mruby.h"
-#include "mruby/proc.h"
 #include "mruby/array.h"
-#include "mruby/string.h"
 #include "mruby/compile.h"
 #include "mruby/dump.h"
 #include "mruby/variable.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
 
 #ifndef ENABLE_STDIO
 static void

data/modules/mruby/mrbgems/mruby-hash-ext/src/hash-ext.c

@@ -6,11 +6,8 @@
 
 #include "mruby.h"
 #include "mruby/array.h"
-#include "mruby/class.h"
 #include "mruby/hash.h"
 #include "mruby/khash.h"
-#include "mruby/string.h"
-#include "mruby/variable.h"
 
 /*
  * call-seq:

data/modules/mruby/mrbgems/mruby-numeric-ext/src/numeric_ext.c

@@ -1,6 +1,5 @@
 #include <limits.h>
 #include "mruby.h"
-#include "mruby/numeric.h"
 
 static mrb_value
 mrb_int_chr(mrb_state *mrb, mrb_value x)

data/modules/mruby/mrbgems/mruby-random/src/mt19937ar.c

@@ -4,7 +4,6 @@
 ** See Copyright Notice in mruby.h
 */
 
-#include <stdio.h>
 #include "mt19937ar.h"
 
 /* Period parameters */  

data/modules/mruby/mrbgems/mruby-range-ext/src/range.c

@@ -7,7 +7,7 @@ r_le(mrb_state *mrb, mrb_value a, mrb_value b)
   mrb_value r = mrb_funcall(mrb, a, "<=>", 1, b); /* compare result */
   /* output :a < b => -1, a = b =>  0, a > b => +1 */
 
-  if (mrb_type(r) == MRB_TT_FIXNUM) {
+  if (mrb_fixnum_p(r)) {
     mrb_int c = mrb_fixnum(r);
     if (c == 0 || c == -1) return TRUE;
   }
@@ -21,11 +21,7 @@ r_lt(mrb_state *mrb, mrb_value a, mrb_value b)
   mrb_value r = mrb_funcall(mrb, a, "<=>", 1, b);
   /* output :a < b => -1, a = b =>  0, a > b => +1 */
 
-  if (mrb_type(r) == MRB_TT_FIXNUM) {
-    if (mrb_fixnum(r) == -1) return TRUE;
-  }
-
-  return FALSE;
+  return mrb_fixnum_p(r) && mrb_fixnum(r) == -1;
 }
 
 /*

data/modules/mruby/mrbgems/mruby-sprintf/src/sprintf.c

@@ -15,10 +15,6 @@
 #include <math.h>
 #include <ctype.h>
 
-#ifdef HAVE_IEEEFP_H
-#include <ieeefp.h>
-#endif
-
 #define BIT_DIGITS(N)   (((N)*146)/485 + 1)  /* log2(10) =~ 146/485 */
 #define BITSPERDIG (sizeof(mrb_int)*CHAR_BIT)
 #define EXTENDSIGN(n, l) (((~0 << (n)) >> (((n)*(l)) % BITSPERDIG)) & ~(~0 << (n)))

data/modules/mruby/mrbgems/mruby-string-ext/mrblib/string.rb

@@ -49,4 +49,26 @@ class String
   def casecmp(str)
     self.downcase <=> str.downcase
   end
+
+  def partition(sep)
+    raise TypeError, "type mismatch: #{sep.class} given" unless sep.is_a? String
+    n = index(sep)
+    unless n.nil?
+      m = n + sep.size
+      [ slice(0, n), sep, slice(m, size - m) ]
+    else
+      [ self, "", "" ]
+    end
+  end
+
+  def rpartition(sep)
+    raise TypeError, "type mismatch: #{sep.class} given" unless sep.is_a? String
+    n = rindex(sep)
+    unless n.nil?
+      m = n + sep.size
+      [ slice(0, n), sep, slice(m, size - m) ]
+    else
+      [ "", "", self ]
+    end
+  end
 end

data/modules/mruby/mrbgems/mruby-string-ext/src/string.c

@@ -1,7 +1,7 @@
-#include "mruby.h"
-#include "mruby/string.h"
 #include <ctype.h>
 #include <string.h>
+#include "mruby.h"
+#include "mruby/string.h"
 
 static mrb_value
 mrb_str_getbyte(mrb_state *mrb, mrb_value str)

data/modules/mruby/mrbgems/mruby-string-ext/test/string.rb

@@ -20,8 +20,7 @@ assert('String#dump') do
 end
 
 assert('String#strip') do
-  s = "  abc  " 
-  s.strip
+  s = "  abc  "
   "".strip == "" and " \t\r\n\f\v".strip == "" and
   "\0a\0".strip == "\0a" and
   "abc".strip     == "abc" and
@@ -114,3 +113,23 @@ assert('String#end_with?') do
   assert_true !"ng".end_with?("ing", "mng")
   assert_raise TypeError do "hello".end_with?(true) end
 end
+
+assert('String#partition') do
+  assert_equal ["a", "x", "axa"], "axaxa".partition("x")
+  assert_equal ["aaaaa", "", ""], "aaaaa".partition("x")
+  assert_equal ["", "", "aaaaa"], "aaaaa".partition("") 
+  assert_equal ["", "a", "aaaa"], "aaaaa".partition("a")
+  assert_equal ["aaaa", "b", ""], "aaaab".partition("b")
+  assert_equal ["", "b", "aaaa"], "baaaa".partition("b")
+  assert_equal ["", "", ""],      "".partition("a")
+end
+
+assert('String#rpartition') do
+  assert_equal ["axa", "x", "a"], "axaxa".rpartition("x")
+  assert_equal ["", "", "aaaaa"], "aaaaa".rpartition("x")
+  assert_equal ["aaaaa", "", ""], "aaaaa".rpartition("") 
+  assert_equal ["aaaa", "a", ""], "aaaaa".rpartition("a")
+  assert_equal ["aaaa", "b", ""], "aaaab".rpartition("b")
+  assert_equal ["", "b", "aaaa"], "baaaa".rpartition("b")
+  assert_equal ["", "", ""],      "".rpartition("a")
+end

data/modules/mruby/mrbgems/mruby-string-utf8/mrbgem.rake

@@ -0,0 +1,4 @@
+MRuby::Gem::Specification.new('mruby-string-utf8') do |spec|
+  spec.license = 'MIT'
+  spec.author  = 'mruby developers'
+end

data/modules/mruby/mrbgems/mruby-string-utf8/src/string.c

@@ -0,0 +1,297 @@
+#include "mruby.h"
+#include "mruby/string.h"
+#include "mruby/range.h"
+#include <ctype.h>
+#include <string.h>
+
+/* TODO: duplicate definition in src/re.h */
+#define REGEXP_CLASS "Regexp"
+
+static size_t utf8len_tab[256] =
+{
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+  3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,6,6,1,1,
+};
+
+static size_t
+utf8len(unsigned char* p)
+{
+  size_t    len;
+  int    i;
+
+  if (*p == 0)
+    return 1;
+  len = utf8len_tab[*p];
+  for (i = 1; i < len; ++i)
+    if ((p[i] & 0xc0) != 0x80)
+      return 1;
+  return len;
+}
+
+static size_t
+mrb_utf8_strlen(mrb_value str)
+{
+  size_t total = 0;
+  unsigned char* p = (unsigned char*) RSTRING_PTR(str);
+  unsigned char* e = p + RSTRING_LEN(str);
+  while (p<e) {
+    p += utf8len(p);
+    total++;
+  }
+  return total;
+}
+
+static mrb_value
+mrb_str_size(mrb_state *mrb, mrb_value str)
+{
+  size_t size = mrb_utf8_strlen(str);
+
+  return mrb_fixnum_value(size);
+}
+
+#define RSTRING_LEN_UTF8(s) mrb_utf8_strlen(s)
+
+static mrb_value
+noregexp(mrb_state *mrb, mrb_value self)
+{
+  mrb_raise(mrb, E_NOTIMP_ERROR, "Regexp class not implemented");
+  return mrb_nil_value();
+}
+
+static void
+regexp_check(mrb_state *mrb, mrb_value obj)
+{
+  if (!memcmp(mrb_obj_classname(mrb, obj), REGEXP_CLASS, sizeof(REGEXP_CLASS) - 1)) {
+    noregexp(mrb, obj);
+  }
+}
+
+static inline mrb_int
+mrb_memsearch_qs(const unsigned char *xs, mrb_int m, const unsigned char *ys, mrb_int n)
+{
+  const unsigned char *x = xs, *xe = xs + m;
+  const unsigned char *y = ys;
+  int i, qstable[256];
+
+  /* Preprocessing */
+  for (i = 0; i < 256; ++i)
+    qstable[i] = m + 1;
+  for (; x < xe; ++x)
+    qstable[*x] = xe - x;
+ /* Searching */
+  for (; y + m <= ys + n; y += *(qstable + y[m])) {
+    if (*xs == *y && memcmp(xs, y, m) == 0)
+        return y - ys;
+  }
+  return -1;
+}
+static mrb_int
+mrb_memsearch(const void *x0, mrb_int m, const void *y0, mrb_int n)
+{
+  const unsigned char *x = (const unsigned char *)x0, *y = (const unsigned char *)y0;
+
+  if (m > n) return -1;
+  else if (m == n) {
+    return memcmp(x0, y0, m) == 0 ? 0 : -1;
+  }
+  else if (m < 1) {
+    return 0;
+  }
+  else if (m == 1) {
+    const unsigned char *ys = y, *ye = ys + n;
+    for (; y < ye; ++y) {
+      if (*x == *y)
+        return y - ys;
+    }
+    return -1;
+  }
+  return mrb_memsearch_qs((const unsigned char *)x0, m, (const unsigned char *)y0, n);
+}
+
+static mrb_value
+str_subseq(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len)
+{
+  int i;
+  unsigned char *p = (unsigned char*) RSTRING_PTR(str), *t;
+  unsigned char *e = p + RSTRING_LEN(str);
+  
+
+  for (i = 0; i < beg && p<e; i++) {
+    p += utf8len(p);
+  }
+  t = p;
+  for (i = 0; i < len && t<e; i++) {
+    t += utf8len(t);
+  }
+  return mrb_str_new(mrb, (const char*)p, (int)(t - p));
+}
+
+static mrb_value
+str_substr(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len)
+{
+  mrb_value str2;
+  int len8 = RSTRING_LEN_UTF8(str);
+
+  if (len < 0) return mrb_nil_value();
+  if (len8 == 0) {
+    len = 0;
+  }
+  else if (beg < 0) {
+    beg = len8 + beg;
+  }
+  if (beg > len8) return mrb_nil_value();
+  if (beg < 0) {
+    beg += len8;
+    if (beg < 0) return mrb_nil_value();
+  }
+  if (beg + len > len8)
+    len = len8 - beg;
+  if (len <= 0) {
+    len = 0;
+  }
+  str2 = str_subseq(mrb, str, beg, len);
+
+  return str2;
+}
+
+static mrb_int
+str_index(mrb_state *mrb, mrb_value str, mrb_value sub, mrb_int offset)
+{
+  mrb_int pos;
+  char *s, *sptr;
+  mrb_int len, slen;
+
+  len = RSTRING_LEN(str);
+  slen = RSTRING_LEN(sub);
+  if (offset < 0) {
+    offset += len;
+    if (offset < 0) return -1;
+  }
+  if (len - offset < slen) return -1;
+  s = RSTRING_PTR(str);
+  if (offset) {
+    s += offset;
+  }
+  if (slen == 0) return offset;
+  /* need proceed one character at a time */
+  sptr = RSTRING_PTR(sub);
+  slen = RSTRING_LEN(sub);
+  len = RSTRING_LEN(str) - offset;
+  pos = mrb_memsearch(sptr, slen, s, len);
+  if (pos < 0) return pos;
+  return pos + offset;
+}
+
+static mrb_value
+mrb_str_aref(mrb_state *mrb, mrb_value str, mrb_value indx)
+{
+  mrb_int idx;
+
+  regexp_check(mrb, indx);
+  switch (mrb_type(indx)) {
+    case MRB_TT_FIXNUM:
+      idx = mrb_fixnum(indx);
+
+num_index:
+      str = str_substr(mrb, str, idx, 1);
+      if (!mrb_nil_p(str) && RSTRING_LEN(str) == 0) return mrb_nil_value();
+      return str;
+
+    case MRB_TT_STRING:
+      if (str_index(mrb, str, indx, 0) != -1)
+        return mrb_str_dup(mrb, indx);
+      return mrb_nil_value();
+
+    case MRB_TT_RANGE:
+      /* check if indx is Range */
+      {
+        mrb_int beg, len;
+        mrb_value tmp;
+
+        len = RSTRING_LEN_UTF8(str);
+        if (mrb_range_beg_len(mrb, indx, &beg, &len, len)) {
+          tmp = str_subseq(mrb, str, beg, len);
+          return tmp;
+        }
+        else {
+          return mrb_nil_value();
+        }
+      }
+    default:
+      idx = mrb_fixnum(indx);
+      goto num_index;
+    }
+    return mrb_nil_value();    /* not reached */
+}
+
+static mrb_value
+mrb_str_aref_m(mrb_state *mrb, mrb_value str)
+{
+  mrb_value a1, a2;
+  int argc;
+
+  argc = mrb_get_args(mrb, "o|o", &a1, &a2);
+  if (argc == 2) {
+    regexp_check(mrb, a1);
+    return str_substr(mrb, str, mrb_fixnum(a1), mrb_fixnum(a2));
+  }
+  if (argc != 1) {
+    mrb_raisef(mrb, E_ARGUMENT_ERROR, "wrong number of arguments (%S for 1)", mrb_fixnum_value(argc));
+  }
+  return mrb_str_aref(mrb, str, a1);
+}
+
+static mrb_value
+mrb_str_reverse_bang(mrb_state *mrb, mrb_value str)
+{
+  int utf8_len = mrb_utf8_strlen(str);
+  if (utf8_len > 1) {
+    int len = RSTRING_LEN(str);
+    char *buf = (char *)mrb_malloc(mrb, len);
+    unsigned char* p = (unsigned char*)buf;
+    unsigned char* e = (unsigned char*)buf + len;
+    unsigned char* r = (unsigned char*)RSTRING_END(str);
+    
+    memcpy(buf, RSTRING_PTR(str), len);
+    mrb_str_modify(mrb, mrb_str_ptr(str));
+    
+    while (p<e) {
+      int clen = utf8len(p);
+      r -= clen;
+      memcpy(r, p, clen);
+      p += clen;
+    }
+    mrb_free(mrb, buf);
+  }
+  
+  return str;
+}
+
+static mrb_value
+mrb_str_reverse(mrb_state *mrb, mrb_value str)
+{
+  return mrb_str_reverse_bang(mrb, mrb_str_dup(mrb, str));
+}
+
+void
+mrb_mruby_string_utf8_gem_init(mrb_state* mrb)
+{
+  struct RClass * s = mrb->string_class;
+
+  mrb_define_method(mrb, s, "size", mrb_str_size, MRB_ARGS_NONE());
+  mrb_define_method(mrb, s, "[]", mrb_str_aref_m, MRB_ARGS_ANY());
+  mrb_define_method(mrb, s, "slice", mrb_str_aref_m, MRB_ARGS_ANY());
+  mrb_define_method(mrb, s, "reverse",  mrb_str_reverse,      MRB_ARGS_NONE());
+  mrb_define_method(mrb, s, "reverse!", mrb_str_reverse_bang, MRB_ARGS_NONE());
+}
+
+void
+mrb_mruby_string_utf8_gem_final(mrb_state* mrb)
+{
+}