webruby 0.2.2 → 0.2.4

data/modules/emscripten/tools/split.py

@@ -1,16 +1,13 @@
 import sys
 import os
+from sets import Set
 
 def split_javascript_file(input_filename, output_filename_prefix, max_part_size_in_bytes):
  
   try:
-    # Contains the entire Emscripten generated Javascript code
-    input_file = open(input_filename,'r')
-
     # Javascript main file. On execution, this file needs to be loaded at last (!)
     output_main_filename = output_filename_prefix + ".js"
     output_main_file = open(output_main_filename,'w')
-
     # File with HTML script tags to load the Javascript files in HTML later on
     output_html_include_file = open(output_filename_prefix + ".include.html",'w')
 
@@ -22,8 +19,19 @@ def split_javascript_file(input_filename, output_filename_prefix, max_part_size_
     function_buckets = {};
     
     output_part_file = None
-  
+
+    # Locate names of all the source files (.c/.cpp) that produced output to the .js file.
+    source_files = Set()
+    for line in open(input_filename,'r'):
+      if line.startswith("//FUNCTION_END_MARKER_OF_SOURCE_FILE_"):
+        associated_source_file_base = line[len("//FUNCTION_END_MARKER_OF_SOURCE_FILE_"):len(line)-1]
+        if not associated_source_file_base == "NO_SOURCE":
+          source_files.add(os.path.dirname(os.path.abspath(os.path.realpath(associated_source_file_base))))
+
+    common_source_file_prefix = os.path.commonprefix(list(source_files))
+
     # Iterate over Javascript source; write main file; parse function declarations.
+    input_file = open(input_filename,'r')
     for line in input_file:
       if line == "//FUNCTION_BEGIN_MARKER\n":
         js_function = "//Func\n"
@@ -36,8 +44,8 @@ def split_javascript_file(input_filename, output_filename_prefix, max_part_size_
           associated_source_file_base = output_filename_prefix + "_functions";
         else:
           # Functions with a known associated source file are stored in a file in the directory `output_filename_prefix`
-          associated_source_file_base = output_filename_prefix + os.path.realpath(associated_source_file_base)
-        
+          associated_source_file_base = os.path.join(output_filename_prefix, os.path.relpath(os.path.abspath(os.path.realpath(associated_source_file_base)), common_source_file_prefix))
+
         associated_source_file_base_lower = associated_source_file_base.lower()
         
         # Add the function to its respective file
@@ -68,7 +76,7 @@ def split_javascript_file(input_filename, output_filename_prefix, max_part_size_
       output_part_file = None
       for js_function in function_buckets[associated_source_file_base][1]:
         if output_part_file is None:
-          output_html_include_file.write("<script type=\"text/javascript\" src=\"" + js_source_file + "\"></script>")
+          output_html_include_file.write("<script type=\"text/javascript\" src=\"" + js_source_file.replace('\\', '/') + "\"></script>")
           output_part_file = open(js_source_file,'w')
         
         output_part_file.write(js_function)
@@ -85,13 +93,13 @@ def split_javascript_file(input_filename, output_filename_prefix, max_part_size_
       
     # Write the main Javascript file at last to the HTML includes because this file contains the code to start
     # the execution of the generated Emscripten application and requires all the extracted functions.
-    output_html_include_file.write("<script type=\"text/javascript\" src=\"" + output_main_filename + "\"></script>")
+    output_html_include_file.write("<script type=\"text/javascript\" src=\"" + output_main_filename.replace('\\', '/') + "\"></script>")
 
   except Exception, e:
     print >> sys.stderr, 'error: Splitting of Emscripten generated Javascript failed: %s' % str(e)
   
   finally:
-     if input_file is not None: input_file.close()
-     if output_main_file is not None: output_main_file.close()
-     if output_part_file is not None: output_part_file.close()
-     if output_html_include_file is not None: output_html_include_file.close()
+    if input_file is not None: input_file.close()
+    if output_main_file is not None: output_main_file.close()
+    if output_part_file is not None: output_part_file.close()
+    if output_html_include_file is not None: output_html_include_file.close()

data/modules/mruby/build_config.rb

@@ -1,6 +1,12 @@
 MRuby::Build.new do |conf|
   # load specific toolchain settings
-  toolchain :gcc
+
+  # Gets set by the VS command prompts.
+  if ENV['VisualStudioVersion']
+    toolchain :visualcpp
+  else
+    toolchain :gcc
+  end
 
   # Use mrbgems
   # conf.gem 'examples/mrbgems/ruby_extension_example'

data/modules/mruby/doc/compile/README.md

@@ -59,17 +59,13 @@ GCC toolchain.
 
 	toolchain :clang
 
-#### Visual Studio 2010
+#### Visual Studio 2010, 2012 and 2013
 
-Toolchain configuration for Visual Studio 2010 on Windows.
+Toolchain configuration for Visual Studio on Windows. If you use the
+[Visual Studio Command Prompt](http://msdn.microsoft.com/en-us/library/ms229859\(v=vs.110\).aspx),
+you normally do not have to specify this manually, since it gets automatically detected by our build process.
 
-	toolchain :vs2010
-
-#### Visual Studio 2012
-
-Toolchain configuration for Visual Studio 2012 on Windows.
-
-	toolchain :vs2012
+	toolchain :visualcpp
 
 #### Android
 

data/modules/mruby/include/mrbconf.h

@@ -56,8 +56,11 @@
 /* initial minimum size for string buffer */
 //#define MRB_STR_BUF_MIN_SIZE 128
 
-/* array size for parser buffer */
-//#define MRB_PARSER_BUF_SIZE 1024
+/* arena size */
+//#define MRB_GC_ARENA_SIZE 100
+
+/* fixed size GC arena */
+//#define MRB_GC_FIXED_ARENA
 
 /* -DDISABLE_XXXX to drop following features */
 //#define DISABLE_STDIO		/* use of stdio */

data/modules/mruby/include/mruby/array.h

@@ -35,6 +35,7 @@ struct RArray {
 #define RARRAY_PTR(a) (RARRAY(a)->ptr)
 #define MRB_ARY_SHARED      256
 
+void mrb_ary_modify(mrb_state*, struct RArray*);
 void mrb_ary_decref(mrb_state*, mrb_shared_array*);
 mrb_value mrb_ary_new_capa(mrb_state*, mrb_int);
 mrb_value mrb_ary_new(mrb_state *mrb);

data/modules/mruby/include/mruby/compile.h

@@ -96,9 +96,7 @@ struct mrb_parser_heredoc_info {
   mrb_ast_node *doc;
 };
 
-#ifndef MRB_PARSER_BUF_SIZE
-# define MRB_PARSER_BUF_SIZE 1024
-#endif
+#define MRB_PARSER_BUF_SIZE 1024
 
 /* parser structure */
 struct mrb_parser_state {
@@ -164,7 +162,7 @@ struct mrb_parser_state* mrb_parse_file(mrb_state*,FILE*,mrbc_context*);
 #endif
 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*, struct mrb_parser_state*);
+struct RProc* mrb_generate_code(mrb_state*, struct mrb_parser_state*);
 
 /* program load functions */
 #ifdef ENABLE_STDIO

data/modules/mruby/include/mruby/dump.h

@@ -12,17 +12,16 @@ extern "C" {
 #endif
 
 #include "mruby.h"
+#include "mruby/irep.h"
 
 #ifdef ENABLE_STDIO
-int mrb_dump_irep_binary(mrb_state*, size_t, int, FILE*);
-int mrb_dump_irep_cfunc(mrb_state *mrb, size_t n, int, FILE *f, const char *initname);
-int32_t mrb_read_irep_file(mrb_state*, FILE*);
-#endif
-int32_t mrb_read_irep(mrb_state*, const uint8_t*);
-
-#ifdef ENABLE_STDIO
+int mrb_dump_irep_binary(mrb_state*, mrb_irep*, int, FILE*);
+int mrb_dump_irep_cfunc(mrb_state *mrb, mrb_irep*, int, FILE *f, const char *initname);
+mrb_irep *mrb_read_irep_file(mrb_state*, FILE*);
 mrb_value mrb_load_irep_file(mrb_state*,FILE*);
+mrb_value mrb_load_irep_file_cxt(mrb_state*, FILE*, mrbc_context*);
 #endif
+mrb_irep *mrb_read_irep(mrb_state*, const uint8_t*);
 
 /* dump/load error code
  *
@@ -43,7 +42,7 @@ mrb_value mrb_load_irep_file(mrb_state*,FILE*);
 
 /* Rite Binary File header */
 #define RITE_BINARY_IDENTIFIER         "RITE"
-#define RITE_BINARY_FORMAT_VER         "0001"
+#define RITE_BINARY_FORMAT_VER         "0002"
 #define RITE_COMPILER_NAME             "MATZ"
 #define RITE_COMPILER_VERSION          "0000"
 
@@ -79,22 +78,14 @@ struct rite_section_irep_header {
   RITE_SECTION_HEADER;
 
   uint8_t rite_version[4];    // Rite Instruction Specification Version
-  uint8_t nirep[2];           // Number of ireps
-  uint8_t sirep[2];           // Start index
 };
 
 struct rite_section_lineno_header {
   RITE_SECTION_HEADER;
-
-  uint8_t nirep[2];           // Number of ireps
-  uint8_t sirep[2];           // Start index
 };
 
 struct rite_section_debug_header {
   RITE_SECTION_HEADER;
-
-  uint8_t nirep[2];           // Number of ireps
-  uint8_t sirep[2];           // Start index
 };
 
 struct rite_binary_footer {

data/modules/mruby/include/mruby/hash.h

@@ -35,7 +35,7 @@ mrb_value mrb_hash_clear(mrb_state *mrb, mrb_value hash);
 /* RHASH_TBL allocates st_table if not available. */
 #define RHASH(obj)   ((struct RHash*)(mrb_ptr(obj)))
 #define RHASH_TBL(h)          (RHASH(h)->ht)
-#define RHASH_IFNONE(h)       mrb_iv_get(mrb, (h), mrb_intern2(mrb, "ifnone", 6))
+#define RHASH_IFNONE(h)       mrb_iv_get(mrb, (h), mrb_intern_lit(mrb, "ifnone"))
 #define RHASH_PROCDEFAULT(h)  RHASH_IFNONE(h)
 struct kh_ht * mrb_hash_tbl(mrb_state *mrb, mrb_value hash);
 

data/modules/mruby/include/mruby/irep.h

@@ -11,9 +11,16 @@
 extern "C" {
 #endif
 
+#include "mruby/compile.h"
+
+enum irep_pool_type {
+  IREP_TT_STRING,
+  IREP_TT_FIXNUM,
+  IREP_TT_FLOAT,
+};
+
 /* Program data array struct */
 typedef struct mrb_irep {
-  uint32_t idx;
   uint16_t nlocals;        /* Number of local variables */
   uint16_t nregs;          /* Number of register variables */
   uint8_t flags;
@@ -21,19 +28,24 @@ typedef struct mrb_irep {
   mrb_code *iseq;
   mrb_value *pool;
   mrb_sym *syms;
+  struct mrb_irep **reps;
 
   /* debug info */
   const char *filename;
   uint16_t *lines;
   struct mrb_irep_debug_info* debug_info;
 
-  size_t ilen, plen, slen;
+  size_t ilen, plen, slen, rlen, refcnt;
 } mrb_irep;
 
 #define MRB_ISEQ_NO_FREE 1
 
 mrb_irep *mrb_add_irep(mrb_state *mrb);
 mrb_value mrb_load_irep(mrb_state*, const uint8_t*);
+mrb_value mrb_load_irep_cxt(mrb_state*, const uint8_t*, mrbc_context*);
+void mrb_irep_free(mrb_state*, struct mrb_irep*);
+void mrb_irep_incref(mrb_state*, struct mrb_irep*);
+void mrb_irep_decref(mrb_state*, struct mrb_irep*);
 
 #if defined(__cplusplus)
 }  /* extern "C" { */

data/modules/mruby/include/mruby/khash.h

@@ -50,7 +50,7 @@ static const uint8_t __m_either[8] = {0x03, 0x0c, 0x30, 0xc0};
    name: hash name
    khkey_t: key data type
    khval_t: value data type
-   kh_is_map: (not implemented / not used in RiteVM)
+   kh_is_map: (0: hash set / 1: hash map)
 */
 #define KHASH_DECLARE(name, khkey_t, khval_t, kh_is_map)                \
   typedef struct kh_##name {                                            \
@@ -89,7 +89,7 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
    name: hash name
    khkey_t: key data type
    khval_t: value data type
-   kh_is_map: (not implemented / not used in RiteVM)
+   kh_is_map: (0: hash set / 1: hash map)
    __hash_func: hash function
    __hash_equal: hash comparation function
 */
@@ -97,12 +97,13 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
   void kh_alloc_##name(kh_##name##_t *h)                                \
   {                                                                     \
     khint_t sz = h->n_buckets;                                          \
-    uint8_t *p = mrb_malloc(h->mrb, sizeof(uint8_t)*sz/4+(sizeof(khkey_t)+sizeof(khval_t))*sz); \
+    int len = sizeof(khkey_t) + (kh_is_map ? sizeof(khval_t) : 0);      \
+    uint8_t *p = mrb_malloc(h->mrb, sizeof(uint8_t)*sz/4+len*sz);       \
     h->size = h->n_occupied = 0;                                        \
     h->upper_bound = UPPER_BOUND(sz);                                   \
     h->keys = (khkey_t *)p;                                             \
-    h->vals = (khval_t *)(p+sizeof(khkey_t)*sz);                        \
-    h->ed_flags = (p+sizeof(khkey_t)*sz+sizeof(khval_t)*sz);            \
+    h->vals = kh_is_map ? (khval_t *)(p+sizeof(khkey_t)*sz) : NULL;     \
+    h->ed_flags = p+len*sz;                                             \
     kh_fill_flags(h->ed_flags, 0xaa, sz/4);                             \
     h->mask = sz-1;                                                     \
     h->inc = sz/2-1;                                                    \
@@ -162,7 +163,7 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
       for (i=0 ; i<old_n_buckets ; i++) {                               \
         if (!__ac_iseither(old_ed_flags, i)) {                          \
           khint_t k = kh_put_##name(h, old_keys[i]);                    \
-          kh_value(h,k) = old_vals[i];                                  \
+          if (kh_is_map) kh_value(h,k) = old_vals[i];			\
         }                                                               \
       }                                                                 \
       mrb_free(h->mrb, old_keys);                                       \
@@ -207,7 +208,7 @@ kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
     for (k = kh_begin(h); k != kh_end(h); k++) {                        \
       if (kh_exist(h, k)) {                                             \
         k2 = kh_put_##name(h2, kh_key(h, k));                           \
-        kh_value(h2, k2) = kh_value(h, k);                              \
+        if(kh_is_map) kh_value(h2, k2) = kh_value(h, k);                \
       }                                                                 \
     }                                                                   \
     return h2;                                                          \

data/modules/mruby/include/mruby/string.h

@@ -65,6 +65,7 @@ mrb_value mrb_str_append(mrb_state *mrb, mrb_value str, mrb_value str2);
 
 int mrb_str_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2);
 char *mrb_str_to_cstr(mrb_state *mrb, mrb_value str);
+mrb_value mrb_str_pool(mrb_state *mrb, mrb_value str);
 
 /* For backward compatibility */
 static inline mrb_value

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

@@ -183,6 +183,7 @@ mrb_float_value(struct mrb_state *mrb, mrb_float f)
   }
   return v;
 }
+#define mrb_float_pool(mrb,f) mrb_float_value(mrb,f)
 
 #else
 
@@ -215,6 +216,7 @@ enum mrb_vtype {
 
 #if defined(MRB_WORD_BOXING)
 
+#include <limits.h>
 #define MRB_TT_HAS_BASIC  MRB_TT_FLOAT
 
 enum mrb_special_consts {
@@ -263,8 +265,8 @@ typedef union mrb_value {
   }\
 } while (0)
 
-extern mrb_value
-mrb_float_value(struct mrb_state *mrb, mrb_float f);
+mrb_value mrb_float_value(struct mrb_state *mrb, mrb_float f);
+mrb_value mrb_float_pool(struct mrb_state *mrb, mrb_float f);
 
 #else /* No MRB_xxx_BOXING */
 
@@ -298,6 +300,7 @@ mrb_float_value(struct mrb_state *mrb, mrb_float f)
   MRB_SET_VALUE(v, MRB_TT_FLOAT, value.f, f);
   return v;
 }
+#define mrb_float_pool(mrb,f) mrb_float_value(mrb,f)
 
 #endif  /* no boxing */
 

data/modules/mruby/include/mruby.h

@@ -41,12 +41,13 @@ extern "C" {
 typedef uint32_t mrb_code;
 typedef uint32_t mrb_aspec;
 
+struct mrb_irep;
 struct mrb_state;
 
 typedef void* (*mrb_allocf) (struct mrb_state *mrb, void*, size_t, void *ud);
 
-#ifndef MRB_ARENA_SIZE
-#define MRB_ARENA_SIZE 100
+#ifndef MRB_GC_ARENA_SIZE
+#define MRB_GC_ARENA_SIZE 100
 #endif
 
 typedef struct {
@@ -105,8 +106,6 @@ typedef struct mrb_state {
 
   struct RObject *exc;                    /* exception */
   struct iv_tbl *globals;                 /* global variable table */
-  struct mrb_irep **irep;                 /* program data array */
-  size_t irep_len, irep_capa;
 
   struct RObject *top_self;
   struct RClass *object_class;            /* Object class */
@@ -129,7 +128,12 @@ typedef struct mrb_state {
   struct heap_page *sweeps;
   struct heap_page *free_heaps;
   size_t live; /* count of live objects */
-  struct RBasic *arena[MRB_ARENA_SIZE];   /* GC protection array */
+#ifdef MRB_GC_FIXED_ARENA
+  struct RBasic *arena[MRB_GC_ARENA_SIZE]; /* GC protection array */
+#else
+  struct RBasic **arena;                   /* GC protection array */
+  int arena_capa;
+#endif
   int arena_idx;
 
   enum gc_state gc_state; /* state of gc */
@@ -225,7 +229,7 @@ mrb_value mrb_funcall(mrb_state*, mrb_value, const char*, int,...);
 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_cstr(mrb_state*,const char*);
-mrb_sym mrb_intern2(mrb_state*,const char*,size_t);
+mrb_sym mrb_intern(mrb_state*,const char*,size_t);
 mrb_sym mrb_intern_str(mrb_state*,mrb_value);
 mrb_value mrb_check_intern_cstr(mrb_state*,const char*);
 mrb_value mrb_check_intern(mrb_state*,const char*,size_t);
@@ -235,12 +239,7 @@ const char *mrb_sym2name_len(mrb_state*,mrb_sym,size_t*);
 mrb_value mrb_sym2str(mrb_state*,mrb_sym);
 mrb_value mrb_str_format(mrb_state *, int, const mrb_value *, mrb_value);
 
-/* For backward compatibility. */
-static inline
-mrb_sym mrb_intern(mrb_state *mrb,const char *cstr)
-{
-  return mrb_intern_cstr(mrb, cstr);
-}
+#define mrb_intern_lit(mrb, lit) mrb_intern(mrb, (lit), sizeof(lit) - 1)
 
 void *mrb_malloc(mrb_state*, size_t);         /* raise RuntimeError if no mem */
 void *mrb_calloc(mrb_state*, size_t, size_t); /* ditto */
@@ -256,11 +255,11 @@ mrb_value mrb_str_new_static(mrb_state *mrb, const char *p, size_t len);
 
 mrb_state* mrb_open(void);
 mrb_state* mrb_open_allocf(mrb_allocf, void *ud);
-void mrb_irep_free(mrb_state*, struct mrb_irep*);
 void mrb_close(mrb_state*);
 
 mrb_value mrb_top_self(mrb_state *);
 mrb_value mrb_run(mrb_state*, struct RProc*, mrb_value);
+mrb_value mrb_context_run(mrb_state*, struct RProc*, mrb_value, unsigned int);
 
 void mrb_p(mrb_state*, mrb_value);
 mrb_int mrb_obj_id(mrb_value obj);

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

@@ -236,6 +236,8 @@ print_cmdline(int code_block_open)
   }
 }
 
+void codedump_all(mrb_state*, struct RProc*);
+
 int
 main(int argc, char **argv)
 {
@@ -255,6 +257,8 @@ main(int argc, char **argv)
   int n;
   int code_block_open = FALSE;
   int ai;
+  int first_command = 1;
+  unsigned int nregs;
 
   /* new interpreter instance */
   mrb = mrb_open();
@@ -361,13 +365,18 @@ main(int argc, char **argv)
       }
       else {
         /* generate bytecode */
-        n = mrb_generate_code(mrb, parser);
+        struct RProc *proc = mrb_generate_code(mrb, parser);
 
+        if (args.verbose) {
+          codedump_all(mrb, proc);
+        }
+        /* pass a proc for evaulation */
+        nregs = first_command ? 0: proc->body.irep->nregs;
         /* evaluate the bytecode */
-        result = mrb_run(mrb,
-            /* pass a proc for evaulation */
-            mrb_proc_new(mrb, mrb->irep[n]),
-            mrb_top_self(mrb));
+        result = mrb_context_run(mrb,
+            proc,
+            mrb_top_self(mrb),
+            nregs);
         /* did an exception occur? */
         if (mrb->exc) {
           p(mrb, mrb_obj_value(mrb->exc), 0);
@@ -375,7 +384,7 @@ main(int argc, char **argv)
         }
         else {
           /* no */
-          if (!mrb_respond_to(mrb, result, mrb_intern2(mrb, "inspect", 7))){
+          if (!mrb_respond_to(mrb, result, mrb_intern_lit(mrb, "inspect"))){
             result = mrb_any_to_s(mrb,result);
           }
           p(mrb, result, 1);
@@ -387,6 +396,7 @@ main(int argc, char **argv)
     }
     mrb_parser_free(parser);
     cxt->lineno++;
+    first_command = 0;
   }
   mrbc_context_free(mrb, cxt);
   mrb_close(mrb);

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

@@ -178,6 +178,8 @@ main(int argc, char **argv)
   int i;
   struct _args args;
   mrb_value ARGV;
+  mrbc_context *c;
+  mrb_value v;
 
   if (mrb == NULL) {
     fputs("Invalid mrb_state, exiting mruby\n", stderr);
@@ -197,29 +199,16 @@ main(int argc, char **argv)
   }
   mrb_define_global_const(mrb, "ARGV", ARGV);
 
+  c = mrbc_context_new(mrb);
+  if (args.verbose)
+    c->dump_result = 1;
+  if (args.check_syntax)
+    c->no_exec = 1;
   if (args.mrbfile) {
-    n = mrb_read_irep_file(mrb, args.rfp);
-    if (n < 0) {
-      fprintf(stderr, "failed to load mrb file: %s\n", args.cmdline);
-    }
-    else if (!args.check_syntax) {
-      mrb_run(mrb, mrb_proc_new(mrb, mrb->irep[n]), mrb_top_self(mrb));
-      n = 0;
-      if (mrb->exc) {
-        mrb_print_error(mrb);
-        n = -1;
-      }
-    }
+    v = mrb_load_irep_file_cxt(mrb, args.rfp, c);
   }
   else {
-    mrbc_context *c = mrbc_context_new(mrb);
-    mrb_sym zero_sym = mrb_intern2(mrb, "$0", 2);
-    mrb_value v;
-
-    if (args.verbose)
-      c->dump_result = 1;
-    if (args.check_syntax)
-      c->no_exec = 1;
+    mrb_sym zero_sym = mrb_intern_lit(mrb, "$0");
 
     if (args.rfp) {
       char *cmdline;
@@ -233,17 +222,16 @@ main(int argc, char **argv)
       mrb_gv_set(mrb, zero_sym, mrb_str_new(mrb, "-e", 2));
       v = mrb_load_string_cxt(mrb, args.cmdline, c);
     }
-
-    mrbc_context_free(mrb, c);
-    if (mrb->exc) {
-      if (!mrb_undef_p(v)) {
-        mrb_print_error(mrb);
-      }
-      n = -1;
-    }
-    else if (args.check_syntax) {
-      printf("Syntax OK\n");
+  }
+  mrbc_context_free(mrb, c);
+  if (mrb->exc) {
+    if (!mrb_undef_p(v)) {
+      mrb_print_error(mrb);
     }
+    n = -1;
+  }
+  else if (args.check_syntax) {
+    printf("Syntax OK\n");
   }
   cleanup(mrb, &args);
 

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

@@ -232,6 +232,26 @@ fiber_yield(mrb_state *mrb, mrb_value self)
   return fiber_result(mrb, a, len);
 }
 
+/*
+ *  call-seq:
+ *     Fiber.current() -> fiber
+ *
+ *  Returns the current fiber. You need to <code>require 'fiber'</code>
+ *  before using this method. If you are not running in the context of
+ *  a fiber this method will return the root fiber.
+ */
+static mrb_value
+fiber_current(mrb_state *mrb, mrb_value self)
+{
+  if (!mrb->c->fib) {
+    struct RFiber *f = (struct RFiber*)mrb_obj_alloc(mrb, MRB_TT_FIBER, mrb_class_ptr(self));
+
+    f->cxt = mrb->c;
+    mrb->c->fib = f;
+  }
+  return mrb_obj_value(mrb->c->fib);
+}
+  
 void
 mrb_mruby_fiber_gem_init(mrb_state* mrb)
 {
@@ -245,6 +265,7 @@ mrb_mruby_fiber_gem_init(mrb_state* mrb)
   mrb_define_method(mrb, c, "alive?",     fiber_alive_p, MRB_ARGS_NONE());
 
   mrb_define_class_method(mrb, c, "yield", fiber_yield, MRB_ARGS_ANY());
+  mrb_define_class_method(mrb, c, "current", fiber_current, MRB_ARGS_NONE());
 }
 
 void

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

@@ -89,7 +89,7 @@ erfc(double x)
 
 #endif
 
-#if (defined _MSC_VER && _MSC_VER < 1800) || defined __ANDROID__
+#if (defined _MSC_VER && _MSC_VER < 1800) || defined __ANDROID__ || (defined __FreeBSD__  &&  __FreeBSD_version < 803000)
 
 double
 log2(double x)