esruby 0.0.9 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c4a8a81262ba6285384d5346b58cdc2022ba9624
-  data.tar.gz: bfff4025687aeed38eb7048ab2667986903e6f74
+  metadata.gz: a16d0112d53861ad14f8c825229b924f1a980cdf
+  data.tar.gz: 0df764960a1cdff6f71723c596825a92995f4709
 SHA512:
-  metadata.gz: 1b4eccc319bbc4c23958d287920e51a37c35b4b2101e1b6748d63cf2d34717fe88ad7c3a48179fec8ae906e0ab08a4ef2fef4ee756a994ee1da2ffc728178233
-  data.tar.gz: 8c42461e416dbd33d53ab2fe903e96a5782b9ec87cacdfc2029991406adaeb7054e16e6a6e70afbd07966e99e7b0770b10292f91832eb38193e3a24a5244c00c
+  metadata.gz: 233b64432005b46c61fdcad9a06ef7e9a84f9a1eb79ce02ac38c6172a1e0c8a16a584f6e35b8b340b412d34e84a608468356a67fe6677df5e1e0d13e76957c30
+  data.tar.gz: 65d573fe29d8430b7ac4a55a8590c3e1396f0a43cc559d1050834b73eda6fcf0b3de97ba0314965463424f9ddbbe811c58b7811ff6ccbaae1c3ba0b5f50ef720

data/README.md

@@ -1,9 +1,9 @@
-# ESRuby
+# esruby
 This project brings *mruby* to the browser. It uses [*emscripten*](https://github.com/kripken/emscripten) to compile the mruby source code into
 JavaScript (ECMAScript) and runs in the browser. It is heavily based off [*webruby*](https://github.com/xxuejie/webruby) but has been adjusted to work with the updates to *emscripten* and *mruby*.
 
 # Install
-*ESRuby* depends on [emsdk](http://kripken.github.io/emscripten-site/index.html) to provide a tool chain consisting of *emscripten* and *LLVM*. Although the tool chain is available from `apt-get` we will need to build emscripten from source using my branch as I have introduced some new features that have not made it into the release yet.
+*esruby* depends on [emsdk](http://kripken.github.io/emscripten-site/index.html) to provide a tool chain consisting of *emscripten* and *LLVM*. Although the tool chain is available from `apt-get` we will need to build emscripten from source using my branch as I have introduced some new features that have not made it into the release yet.
 
 * we will start with a clean instance of Ubuntu 16.04 with ruby MRI installed
 * `sudo apt-get install build-essential cmake`

data/lib/esruby/build.rb

@@ -13,7 +13,7 @@ module ESRuby
       new_build
     end
     
-    def_delegators :@configuration, :root_directory, :ruby_sources, :build_directory,
+    def_delegators :@configuration, :root_directory, :build_directory,
       :build_mode, :output, :mruby_directory, :gems
     
     def initialize(&block)
@@ -55,10 +55,13 @@ module ESRuby
         js_files += specification.appended_js_sources
       end
       js_files += @configuration.appended_js_sources
-      js_files << "#{gem_directory}/resources/js/esruby.js"
       js_files
     end
     
+    def ruby_sources
+      @configuration.ruby_sources + ["#{gem_directory}/resources/rb/append.rb"]
+    end
+    
     def build_mruby_config
       template = File.read("#{gem_directory}/resources/build_config.eruby")
       eruby = Erubis::Eruby.new(template)
@@ -117,8 +120,8 @@ module ESRuby
       js_arguments += appended_js_sources.map { |path| "--post-js #{path}" }.join(" ")
       RakeFileUtils.sh "#{mrbc} -B app -o #{build_directory}/app.c #{ruby_sources.join(" ")}"
       RakeFileUtils.sh "emcc --bind -I #{mruby_directory}/include #{build_directory}/app.c -o #{build_directory}/app.o #{build_directory}/emscripten/lib/libmruby.a -lm #{js_arguments} #{optimization_argument} #{closure_argument} #{debug_argument}"
-      RakeFileUtils.sh "emcc -std=c++11 --bind -I #{mruby_directory}/include #{gem_directory}/resources/cpp/esruby.cpp -o #{build_directory}/esruby.o #{build_directory}/emscripten/lib/libmruby.a -lm #{js_arguments} #{optimization_argument} #{closure_argument} #{debug_argument}"
-      RakeFileUtils.sh "emcc --bind -I #{mruby_directory}/include -o #{build_directory}/output.js #{build_directory}/app.o #{build_directory}/esruby.o #{build_directory}/emscripten/lib/libmruby.a -lm #{js_arguments} #{optimization_argument} #{closure_argument} #{debug_argument}"
+      RakeFileUtils.sh "emcc -std=c++11 --bind -I #{mruby_directory}/include #{gem_directory}/resources/cpp/main.cpp -o #{build_directory}/main.o #{build_directory}/emscripten/lib/libmruby.a -lm #{js_arguments} #{optimization_argument} #{closure_argument} #{debug_argument}"
+      RakeFileUtils.sh "emcc --bind -I #{mruby_directory}/include -o #{build_directory}/output.js #{build_directory}/app.o #{build_directory}/main.o #{build_directory}/emscripten/lib/libmruby.a -lm #{js_arguments} #{optimization_argument} #{closure_argument} #{debug_argument}"
       #if build.build_mode == 'production'
       #  sh "java -jar #{PROJECT_DIRECTORY}/emsdk/emscripten/incoming/third_party/closure-compiler/compiler.jar --js #{build.absolute_build_directory}/output.js --js_output_file #{build.absolute_output}"
       #else

data/resources/build_config.eruby

@@ -46,6 +46,7 @@ MRuby::CrossBuild.new('app') do |conf|
   end
   
   conf.gembox('default')
+  #conf.gem :github => 'robfors/esruby-esruby'
   <% for gem in gems %>
   conf.gem(<%= gem.inspect %>)
   <% end %>

data/resources/cpp/main.cpp

@@ -0,0 +1,14 @@
+#include "/media/file_server/file_drive/projects/esruby/esruby-esruby/include/esruby.hpp"
+
+// we need to load the esruby bindings here, see issue:
+//   https://github.com/kripken/emscripten/issues/5537
+// although you can observe that the bindings in esruby-bind do work
+//   so im not sure what the problem is
+// idealy i would like to use a compiler option like EXPORTED_FUNCTIONS, for classes
+EMSCRIPTEN_BINDINGS(esruby)
+{
+  emscripten::class_<ESRuby>("ESRuby")
+    .class_function("start", &ESRuby::start)
+    .class_function("stop", &ESRuby::stop)
+  ;
+}

data/resources/mruby/doc/guides/mrbgems.md

@@ -26,6 +26,11 @@ conf.gem :github => 'masuidrive/mrbgems-example', :branch => 'master'
 conf.gem :bitbucket => 'mruby/mrbgems-example', :branch => 'master'
 ```
 
+You can specify the sub directory of the repository with `:path` option:
+```ruby
+conf.gem github: 'mruby/mruby', path: 'mrbgems/mruby-socket'
+```
+
 To use mrbgem from [mgem-list](https://github.com/mruby/mgem-list) use `:mgem` option:
 ```ruby
 conf.gem :mgem => 'mruby-yaml'

data/resources/mruby/include/mrbconf.h

@@ -36,12 +36,10 @@
 /* size of the method cache (need to be the power of 2) */
 //#define MRB_METHOD_CACHE_SIZE (1<<7)
 
-/* add -DMRB_METHOD_TABLE_INLINE unless platform uses MSB of pointers */
+/* add -DMRB_METHOD_TABLE_INLINE to reduce the size of method table */
+/* MRB_METHOD_TABLE_INLINE requires LSB of function pointers to be zero */
+/* you might need to specify --falign-functions=n (where n>1) */
 //#define MRB_METHOD_TABLE_INLINE
-/* turn MRB_METHOD_TABLE_INLINE on for linux by default */
-#if !defined(MRB_METHOD_TABLE_INLINE) && defined(__linux__)
-# define MRB_METHOD_TABLE_INLINE
-#endif
 
 /* add -DMRB_INT16 to use 16bit integer for mrb_int; conflict with MRB_INT64 */
 //#define MRB_INT16

data/resources/mruby/include/mruby/proc.h

@@ -98,8 +98,8 @@ MRB_API mrb_value mrb_proc_cfunc_env_get(mrb_state*, mrb_int);
 
 #ifdef MRB_METHOD_TABLE_INLINE
 
-#define MRB_METHOD_FUNC_FL ((uintptr_t)1U<<(sizeof(uintptr_t)*8-1))
-#define MRB_METHOD_FUNC_P(m) ((uintptr_t)(m)&MRB_METHOD_FUNC_FL)
+#define MRB_METHOD_FUNC_FL ((uintptr_t)1)
+#define MRB_METHOD_FUNC_P(m) (((uintptr_t)(m))&MRB_METHOD_FUNC_FL)
 #define MRB_METHOD_FUNC(m) ((mrb_func_t)((uintptr_t)(m)&(~MRB_METHOD_FUNC_FL)))
 #define MRB_METHOD_FROM_FUNC(m,fn) m=(mrb_method_t)((struct RProc*)((uintptr_t)(fn)|MRB_METHOD_FUNC_FL))
 #define MRB_METHOD_FROM_PROC(m,pr) m=(mrb_method_t)(struct RProc*)(pr)

data/resources/mruby/include/mruby.h

@@ -829,22 +829,22 @@ MRB_API struct RClass * mrb_define_module_under(mrb_state *mrb, struct RClass *o
  *
  * Must be a C string composed of the following format specifiers:
  *
- * | char | Ruby type      | C types           | Notes                                               |
+ * | char | Ruby type      | C types           | Notes                                              |
  * |:----:|----------------|-------------------|----------------------------------------------------|
  * | `o`  | {Object}       | {mrb_value}       | Could be used to retrieve any type of argument     |
  * | `C`  | {Class}/{Module} | {mrb_value}     |                                                    |
  * | `S`  | {String}       | {mrb_value}       | when `!` follows, the value may be `nil`           |
  * | `A`  | {Array}        | {mrb_value}       | when `!` follows, the value may be `nil`           |
  * | `H`  | {Hash}         | {mrb_value}       | when `!` follows, the value may be `nil`           |
- * | `s`  | {String}       | char *, {mrb_int} |  Receive two arguments; `s!` gives (`NULL`,`0`) for `nil`       |
+ * | `s`  | {String}       | char *, {mrb_int} | Receive two arguments; `s!` gives (`NULL`,`0`) for `nil`       |
  * | `z`  | {String}       | char *            | `NULL` terminated string; `z!` gives `NULL` for `nil`           |
  * | `a`  | {Array}        | {mrb_value} *, {mrb_int} | Receive two arguments; `a!` gives (`NULL`,`0`) for `nil` |
  * | `f`  | {Float}        | {mrb_float}       |                                                    |
  * | `i`  | {Integer}      | {mrb_int}         |                                                    |
  * | `b`  | boolean        | {mrb_bool}        |                                                    |
  * | `n`  | {Symbol}       | {mrb_sym}         |                                                    |
- * | `&`  | block          | {mrb_value}       |                                                    |
- * | `*`  | rest arguments | {mrb_value} *, {mrb_int} | Receive the rest of arguments as an array.  |
+ * | `&`  | block          | {mrb_value}       | &! raises exception if no block given.             |
+ * | `*`  | rest arguments | {mrb_value} *, {mrb_int} | Receive the rest of arguments as an array; *! avoid copy of the stack.  |
  * | | | optional     |                   | After this spec following specs would be optional. |
  * | `?`  | optional given | {mrb_bool}        | `TRUE` if preceding argument is given. Used to check optional argument is given. |
  *
@@ -1225,6 +1225,13 @@ MRB_API mrb_value mrb_fiber_resume(mrb_state *mrb, mrb_value fib, mrb_int argc,
  */
 MRB_API mrb_value mrb_fiber_yield(mrb_state *mrb, mrb_int argc, const mrb_value *argv);
 
+/*
+ * Check if a Fiber is alive
+ *
+ * @mrbgem mruby-fiber
+ */
+MRB_API mrb_value mrb_fiber_alive_p(mrb_state *mrb, mrb_value fib);
+
 /*
  * FiberError reference
  *

data/resources/mruby/lib/mruby/build/load_gems.rb

@@ -76,9 +76,6 @@ module MRuby
 
       if params[:core]
         gemdir = "#{root}/mrbgems/#{params[:core]}"
-      elsif params[:path]
-        require 'pathname'
-        gemdir = Pathname.new(params[:path]).absolute? ? params[:path] : "#{root}/#{params[:path]}"
       elsif params[:git]
         url = params[:git]
         gemdir = "#{gem_clone_dir}/#{url.match(/([-\w]+)(\.[-\w]+|)$/).to_a[1]}"
@@ -108,6 +105,11 @@ module MRuby
           # Jump to the top of the branch
           git.run_checkout gemdir, branch if $pull_gems
         end
+
+        gemdir << "/#{params[:path]}" if params[:path]
+      elsif params[:path]
+        require 'pathname'
+        gemdir = Pathname.new(params[:path]).absolute? ? params[:path] : "#{root}/#{params[:path]}"
       else
         fail "unknown gem option #{params}"
       end

data/resources/mruby/lib/mruby/build.rb

@@ -334,6 +334,7 @@ EOS
     attr_accessor :host_target, :build_target
 
     def initialize(name, build_dir=nil, &block)
+      @endian = nil
       @test_runner = Command::CrossTestRunner.new(self)
       super
     end
@@ -343,6 +344,7 @@ EOS
     end
 
     def run_test
+      @test_runner.runner_options << ' -v' if $verbose
       mrbtest = exefile("#{build_dir}/bin/mrbtest")
       if (@test_runner.command == nil)
         puts "You should run #{mrbtest} on target device."
@@ -351,5 +353,26 @@ EOS
         @test_runner.run(mrbtest)
       end
     end
+
+    def big_endian
+      if @endian
+        puts "Endian has already specified as #{@endian}."
+        return
+      end
+      @endian = :big
+      @mrbc.compile_options += ' -E'
+      compilers.each do |c|
+        c.defines += %w(MRB_ENDIAN_BIG)
+      end
+    end
+
+    def little_endian
+      if @endian
+        puts "Endian has already specified as #{@endian}."
+        return
+      end
+      @endian = :little
+      @mrbc.compile_options += ' -e'
+    end
   end # CrossBuild
 end # MRuby

data/resources/mruby/lib/mruby/gem.rb

@@ -176,6 +176,7 @@ module MRuby
             f.puts %Q[  mrb_load_irep(mrb, gem_mrblib_irep_#{funcname});]
             f.puts %Q[  if (mrb->exc) {]
             f.puts %Q[    mrb_print_error(mrb);]
+            f.puts %Q[    mrb_close(mrb);]
             f.puts %Q[    exit(EXIT_FAILURE);]
             f.puts %Q[  }]
           end
@@ -323,20 +324,22 @@ module MRuby
         @ary.empty?
       end
 
+      def default_gem_params dep
+        if dep[:default]; dep
+        elsif File.exist? "#{MRUBY_ROOT}/mrbgems/#{dep[:gem]}" # check core
+          { :gem => dep[:gem], :default => { :core => dep[:gem] } }
+        else # fallback to mgem-list
+          { :gem => dep[:gem], :default => { :mgem => dep[:gem] } }
+        end
+      end
+
       def generate_gem_table build
         gem_table = @ary.reduce({}) { |res,v| res[v.name] = v; res }
 
         default_gems = []
         each do |g|
           g.dependencies.each do |dep|
-            unless gem_table.key? dep[:gem]
-              if dep[:default]; default_gems << dep
-              elsif File.exist? "#{MRUBY_ROOT}/mrbgems/#{dep[:gem]}" # check core
-                default_gems << { :gem => dep[:gem], :default => { :core => dep[:gem] } }
-              else # fallback to mgem-list
-                default_gems << { :gem => dep[:gem], :default => { :mgem => dep[:gem] } }
-              end
-            end
+            default_gems << default_gem_params(dep) unless gem_table.key? dep[:gem]
           end
         end
 
@@ -348,11 +351,7 @@ module MRuby
           spec.setup
 
           spec.dependencies.each do |dep|
-            unless gem_table.key? dep[:gem]
-              if dep[:default]; default_gems << dep
-              else default_gems << { :gem => dep[:gem], :default => { :mgem => dep[:gem] } }
-              end
-            end
+            default_gems << default_gem_params(dep) unless gem_table.key? dep[:gem]
           end
           gem_table[spec.name] = spec
         end

data/resources/mruby/mrbgems/default.gembox

@@ -1,4 +1,10 @@
 MRuby::GemBox.new do |conf|
+  # Use standard IO/File class
+  conf.gem :core => "mruby-io"
+
+  # Use standard Array#pack, String#unpack methods
+  conf.gem :core => "mruby-pack"
+
   # Use standard Kernel#sprintf method
   conf.gem :core => "mruby-sprintf"
 

data/resources/mruby/mrbgems/mruby-compiler/core/codegen.c

@@ -149,8 +149,14 @@ new_label(codegen_scope *s)
 static inline int
 genop(codegen_scope *s, mrb_code i)
 {
-  if (s->pc == s->icapa) {
+  if (s->pc >= s->icapa) {
     s->icapa *= 2;
+    if (s->pc >= MAXARG_sBx) {
+      codegen_error(s, "too big code block");
+    }
+    if (s->icapa > MAXARG_sBx) {
+      s->icapa = MAXARG_sBx;
+    }
     s->iseq = (mrb_code *)codegen_realloc(s, s->iseq, sizeof(mrb_code)*s->icapa);
     if (s->lines) {
       s->lines = (uint16_t*)codegen_realloc(s, s->lines, sizeof(short)*s->icapa);

data/resources/mruby/mrbgems/mruby-compiler/core/parse.y

@@ -781,7 +781,7 @@ new_dxstr(parser_state *p, node *a)
 static node*
 new_dsym(parser_state *p, node *a)
 {
-  return cons((node*)NODE_DSYM, new_dstr(p, a));
+  return cons((node*)NODE_DSYM, a);
 }
 
 /* (:regx . (s . (opt . enc))) */
@@ -1106,9 +1106,9 @@ heredoc_end(parser_state *p)
         keyword__FILE__
         keyword__ENCODING__
 
-%token <id>  tIDENTIFIER tFID tGVAR tIVAR tCONSTANT tCVAR tLABEL
+%token <id>  tIDENTIFIER tFID tGVAR tIVAR tCONSTANT tCVAR tLABEL_TAG
 %token <nd>  tINTEGER tFLOAT tCHAR tXSTRING tREGEXP
-%token <nd>  tSTRING tSTRING_PART tSTRING_MID tLABEL_END
+%token <nd>  tSTRING tSTRING_PART tSTRING_MID
 %token <nd>  tNTH_REF tBACK_REF
 %token <num> tREGEXP_END
 
@@ -1180,7 +1180,7 @@ heredoc_end(parser_state *p)
 %right keyword_not
 %right '=' tOP_ASGN
 %left modifier_rescue
-%right '?' ':'
+%right '?' ':' tLABEL_TAG
 %nonassoc tDOT2 tDOT3
 %left  tOROP
 %left  tANDOP
@@ -1926,6 +1926,10 @@ arg             : lhs '=' arg_rhs
                     {
                       $$ = new_if(p, cond($1), $3, $6);
                     }
+                | arg '?' arg opt_nl tLABEL_TAG arg
+                    {
+                      $$ = new_if(p, cond($1), $3, $6);
+                    }
                 | primary
                     {
                       $$ = $1;
@@ -2568,7 +2572,7 @@ lambda_body     : tLAMBEG compstmt '}'
                     {
                       $$ = $2;
                     }
-                | keyword_do_LAMBDA compstmt keyword_end
+                | keyword_do_LAMBDA bodystmt keyword_end
                     {
                       $$ = $2;
                     }
@@ -2861,7 +2865,7 @@ symbol          : basic_symbol
                 | tSYMBEG tSTRING_BEG string_rep tSTRING
                     {
                       p->lstate = EXPR_ENDARG;
-                      $$ = new_dsym(p, push($3, $4));
+                      $$ = new_dsym(p, new_dstr(p, push($3, $4)));
                     }
                 ;
 
@@ -3266,25 +3270,20 @@ assoc           : arg tASSOC arg
                       void_expr_error(p, $3);
                       $$ = cons($1, $3);
                     }
-                | tLABEL arg
-                    {
-                      void_expr_error(p, $2);
-                      $$ = cons(new_sym(p, $1), $2);
-                    }
-                | tLABEL_END arg
-                    {
-                      void_expr_error(p, $2);
-                      $$ = cons(new_sym(p, new_strsym(p, $1)), $2);
-                    }
-                | tSTRING_BEG tLABEL_END arg
+                | tIDENTIFIER tLABEL_TAG arg
                     {
                       void_expr_error(p, $3);
-                      $$ = cons(new_sym(p, new_strsym(p, $2)), $3);
+                      $$ = cons(new_sym(p, $1), $3);
                     }
-                | tSTRING_BEG string_rep tLABEL_END arg
+                | string tLABEL_TAG arg
                     {
-                      void_expr_error(p, $4);
-                      $$ = cons(new_dsym(p, push($2, $3)), $4);
+                      void_expr_error(p, $3);
+                      if ($1->car == (node*)NODE_DSTR) {
+                        $$ = cons(new_dsym(p, $1), $3);
+                      }
+                      else {
+                        $$ = cons(new_sym(p, new_strsym(p, $1)), $3);
+                      }
                     }
                 ;
 
@@ -3973,7 +3972,6 @@ parse_string(parser_state *p)
   int beg = intn(p->lex_strterm->cdr->cdr->car);
   int end = intn(p->lex_strterm->cdr->cdr->cdr);
   parser_heredoc_info *hinf = (type & STR_FUNC_HEREDOC) ? parsing_heredoc_inf(p) : NULL;
-  int cmd_state = p->cmd_start;
 
   if (beg == 0) beg = -3;       /* should never happen */
   if (end == 0) end = -3;
@@ -4188,13 +4186,6 @@ parse_string(parser_state *p)
     return tREGEXP;
   }
   pylval.nd = new_str(p, tok(p), toklen(p));
-  if (IS_LABEL_POSSIBLE()) {
-    if (IS_LABEL_SUFFIX(0)) {
-      p->lstate = EXPR_BEG;
-      nextc(p);
-      return tLABEL_END;
-    }
-  }
 
   return tSTRING;
 }
@@ -5012,14 +5003,19 @@ parser_yylex(parser_state *p)
       p->lstate = EXPR_DOT;
       return tCOLON2;
     }
-    if (IS_END() || ISSPACE(c)) {
+    if (!space_seen && IS_END()) {
       pushback(p, c);
       p->lstate = EXPR_BEG;
-      return ':';
+      return tLABEL_TAG;
+    }
+    if (!ISSPACE(c) || IS_BEG()) {
+      pushback(p, c);
+      p->lstate = EXPR_FNAME;
+      return tSYMBEG;
     }
     pushback(p, c);
-    p->lstate = EXPR_FNAME;
-    return tSYMBEG;
+    p->lstate = EXPR_BEG;
+    return ':';
 
   case '/':
     if (IS_BEG()) {
@@ -5443,11 +5439,10 @@ parser_yylex(parser_state *p)
 
       if (IS_LABEL_POSSIBLE()) {
         if (IS_LABEL_SUFFIX(0)) {
-          p->lstate = EXPR_BEG;
-          nextc(p);
+          p->lstate = EXPR_END;
           tokfix(p);
           pylval.id = intern_cstr(tok(p));
-          return tLABEL;
+          return tIDENTIFIER;
         }
       }
       if (p->lstate != EXPR_DOT) {

data/resources/mruby/mrbgems/mruby-enum-ext/mrblib/enum.rb

@@ -201,7 +201,7 @@ module Enumerable
       ary.push([block.call(e), i])
     }
     if ary.size > 1
-      __sort_sub__(ary, 0, ary.size - 1) do |a,b|
+      ary.__sort_sub__(0, ary.size - 1) do |a,b|
         a <=> b
       end
     end
@@ -610,9 +610,7 @@ module Enumerable
   #     #=> [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
   #
 
-  def each_with_object(obj=nil, &block)
-    raise ArgumentError, "wrong number of arguments (0 for 1)" if obj.nil?
-
+  def each_with_object(obj, &block)
     return to_enum(:each_with_object, obj) unless block
 
     self.each {|*val| block.call(val.__svalue, obj) }
@@ -742,18 +740,39 @@ module Enumerable
   ##
   #  call-seq:
   #     enum.zip(arg, ...)                  -> an_array_of_array
+  #     enum.zip(arg, ...) { |arr| block }  -> nil
   #
   #  Takes one element from <i>enum</i> and merges corresponding
   #  elements from each <i>args</i>.  This generates a sequence of
   #  <em>n</em>-element arrays, where <em>n</em> is one more than the
   #  count of arguments.  The length of the resulting sequence will be
   #  <code>enum#size</code>.  If the size of any argument is less than
-  #  <code>enum#size</code>, <code>nil</code> values are supplied.
+  #  <code>enum#size</code>, <code>nil</code> values are supplied. If
+  #  a block is given, it is invoked for each output array, otherwise
+  #  an array of arrays is returned.
+  #
+  #     a = [ 4, 5, 6 ]
+  #     b = [ 7, 8, 9 ]
+  #
+  #     a.zip(b)                 #=> [[4, 7], [5, 8], [6, 9]]
+  #     [1, 2, 3].zip(a, b)      #=> [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
+  #     [1, 2].zip(a, b)         #=> [[1, 4, 7], [2, 5, 8]]
+  #     a.zip([1, 2], [8])       #=> [[4, 1, 8], [5, 2, nil], [6, nil, nil]]
+  #
+  #     c = []
+  #     a.zip(b) { |x, y| c << x + y }  #=> nil
+  #     c                               #=> [11, 13, 15]
   #
 
-  def zip(*arg)
-    ary = []
-    arg = arg.map{|a|a.to_a}
+  def zip(*arg, &block)
+    result = block ? nil : []
+    arg = arg.map do |a|
+      unless a.respond_to?(:to_a)
+        raise TypeError, "wrong argument type #{a.class} (must respond to :to_a)"
+      end
+      a.to_a
+    end
+
     i = 0
     self.each do |*val|
       a = []
@@ -763,10 +782,14 @@ module Enumerable
         a.push(arg[idx][i])
         idx += 1
       end
-      ary.push(a)
       i += 1
+      if result.nil?
+        block.call(a)
+      else
+        result.push(a)
+      end
     end
-    ary
+    result
   end
 
   ##

data/resources/mruby/mrbgems/mruby-enum-ext/test/enum.rb

@@ -166,6 +166,12 @@ assert("Enumerable#zip") do
   assert_equal [[1, 4, 7], [2, 5, 8], [3, 6, 9]], [1, 2, 3].zip(a, b)
   assert_equal [[1, 4, 7], [2, 5, 8]], [1, 2].zip(a, b)
   assert_equal [[4, 1, 8], [5, 2, nil], [6, nil, nil]], a.zip([1, 2], [8])
+
+  ret = []
+  assert_equal nil, a.zip([1, 2], [8]) { |i| ret << i }
+  assert_equal [[4, 1, 8], [5, 2, nil], [6, nil, nil]], ret
+
+  assert_raise(TypeError) { [1].zip(1) }
 end
 
 assert("Enumerable#to_h") do

data/resources/mruby/mrbgems/mruby-enum-lazy/test/lazy.rb

@@ -40,7 +40,7 @@ assert("Enumerator::Lazy laziness") do
   assert_equal [10,20], a.b
 end
 
-assert("Enumrator::Lazy#to_enum") do
+assert("Enumerator::Lazy#to_enum") do
   lazy_enum = (0..Float::INFINITY).lazy.to_enum(:each_slice, 2)
   assert_kind_of Enumerator::Lazy, lazy_enum
   assert_equal [0*1, 2*3, 4*5, 6*7], lazy_enum.map { |a| a.first * a.last }.first(4)

data/resources/mruby/mrbgems/mruby-enumerator/mrblib/enumerator.rb

@@ -621,25 +621,40 @@ end
 
 module Enumerable
   # use Enumerator to use infinite sequence
-  def zip(*arg)
-    ary = []
-    arg = arg.map{|a|a.each}
-    i = 0
-    self.each do |*val|
-      a = []
-      a.push(val.__svalue)
-      idx = 0
-      while idx < arg.size
-        begin
-          a.push(arg[idx].next)
-        rescue StopIteration
-          a.push(nil)
+  def zip(*args, &block)
+    args = args.map do |a|
+      if a.respond_to?(:to_ary)
+        a.to_ary.to_enum(:each)
+      elsif a.respond_to?(:each)
+        a.to_enum(:each)
+      else
+        raise TypeError, "wrong argument type #{a.class} (must respond to :each)"
+      end
+    end
+
+    result = block ? nil : []
+
+    each do |*val|
+      tmp = [val.__svalue]
+      args.each do |arg|
+        v = if arg.nil?
+          nil
+        else
+          begin
+            arg.next
+          rescue StopIteration
+            nil
+          end
         end
-        idx += 1
+        tmp.push(v)
+      end
+      if result.nil?
+        block.call(tmp)
+      else
+        result.push(tmp)
       end
-      ary.push(a)
-      i += 1
     end
-    ary
+
+    result
   end
 end

data/resources/mruby/mrbgems/mruby-enumerator/test/enumerator.rb

@@ -544,3 +544,13 @@ assert 'Range#each' do
   end
   assert_equal [1,2,3,4,5], c
 end
+
+assert 'Enumerable#zip' do
+  assert_equal [[1, 10], [2, 11], [3, 12]], [1,2,3].zip(10..Float::INFINITY)
+
+  ret = []
+  assert_equal nil, [1,2,3].zip(10..Float::INFINITY) { |i| ret << i }
+  assert_equal [[1, 10], [2, 11], [3, 12]], ret
+
+  assert_raise(TypeError) { [1].zip(1) }
+end

data/resources/mruby/mrbgems/mruby-fiber/src/fiber.c

@@ -274,12 +274,13 @@ mrb_fiber_resume(mrb_state *mrb, mrb_value fib, mrb_int len, const mrb_value *a)
  *  Returns true if the fiber can still be resumed. After finishing
  *  execution of the fiber block this method will always return false.
  */
-static mrb_value
-fiber_alive_p(mrb_state *mrb, mrb_value self)
+MRB_API mrb_value
+mrb_fiber_alive_p(mrb_state *mrb, mrb_value self)
 {
   struct mrb_context *c = fiber_check(mrb, self);
   return mrb_bool_value(c->status != MRB_FIBER_TERMINATED);
 }
+#define fiber_alive_p mrb_fiber_alive_p
 
 static mrb_value
 fiber_eq(mrb_state *mrb, mrb_value self)