ruby2d 0.12.1 → 1.0.0

data/assets/{include → platform/include}/mruby/compile.h

@@ -8,9 +8,10 @@
 #define MRUBY_COMPILE_H
 
 #include "common.h"
+#include "mruby/mempool.h"
 
 /**
- * MRuby Compiler
+ * mruby Compiler
  */
 MRB_BEGIN_DECL
 
@@ -18,7 +19,7 @@ MRB_BEGIN_DECL
 
 struct mrb_parser_state;
 /* load context */
-typedef struct mrbc_context {
+typedef struct mrb_ccontext {
   mrb_sym *syms;
   int slen;
   char *filename;
@@ -32,22 +33,28 @@ typedef struct mrbc_context {
   mrb_bool keep_lv:1;
   mrb_bool no_optimize:1;
   mrb_bool no_ext_ops:1;
+  mrb_bool no_return_value:1;
   const struct RProc *upper;
 
   size_t parser_nerr;
-} mrbc_context;
-
-MRB_API mrbc_context* mrbc_context_new(mrb_state *mrb);
-MRB_API void mrbc_context_free(mrb_state *mrb, mrbc_context *cxt);
-MRB_API const char *mrbc_filename(mrb_state *mrb, mrbc_context *c, const char *s);
-MRB_API void mrbc_partial_hook(mrb_state *mrb, mrbc_context *c, int (*partial_hook)(struct mrb_parser_state*), void*data);
-MRB_API void mrbc_cleanup_local_variables(mrb_state *mrb, mrbc_context *c);
+} mrb_ccontext;                 /* compiler context */
+
+MRB_API mrb_ccontext* mrb_ccontext_new(mrb_state *mrb);
+MRB_API void mrb_ccontext_free(mrb_state *mrb, mrb_ccontext *cxt);
+MRB_API const char *mrb_ccontext_filename(mrb_state *mrb, mrb_ccontext *c, const char *s);
+MRB_API void mrb_ccontext_partial_hook(mrb_ccontext *c, int (*partial_hook)(struct mrb_parser_state*), void*data);
+MRB_API void mrb_ccontext_cleanup_local_variables(mrb_ccontext *c);
+
+/* compatibility macros */
+#define mrbc_context mrb_ccontext
+#define mrbc_context_new mrb_ccontext_new
+#define mrbc_context_free mrb_ccontext_free
+#define mrbc_filename mrb_ccontext_filename
+#define mrbc_partial_hook mrb_ccontext_partial_hook
+#define mrbc_cleanup_local_variables mrb_ccontext_cleanup_local_variables
 
 /* AST node structure */
-typedef struct mrb_ast_node {
-  struct mrb_ast_node *car, *cdr;
-  uint16_t lineno, filename_index;
-} mrb_ast_node;
+typedef struct mrb_ast_node mrb_ast_node;
 
 /* lexer states */
 enum mrb_lex_state_enum {
@@ -72,68 +79,32 @@ struct mrb_parser_message {
   char* message;
 };
 
-#define STR_FUNC_PARSING 0x01
-#define STR_FUNC_EXPAND  0x02
-#define STR_FUNC_REGEXP  0x04
-#define STR_FUNC_WORD    0x08
-#define STR_FUNC_SYMBOL  0x10
-#define STR_FUNC_ARRAY   0x20
-#define STR_FUNC_HEREDOC 0x40
-#define STR_FUNC_XQUOTE  0x80
-
-enum mrb_string_type {
-  str_not_parsing  = (0),
-  str_squote   = (STR_FUNC_PARSING),
-  str_dquote   = (STR_FUNC_PARSING|STR_FUNC_EXPAND),
-  str_regexp   = (STR_FUNC_PARSING|STR_FUNC_REGEXP|STR_FUNC_EXPAND),
-  str_sword    = (STR_FUNC_PARSING|STR_FUNC_WORD|STR_FUNC_ARRAY),
-  str_dword    = (STR_FUNC_PARSING|STR_FUNC_WORD|STR_FUNC_ARRAY|STR_FUNC_EXPAND),
-  str_ssym     = (STR_FUNC_PARSING|STR_FUNC_SYMBOL),
-  str_ssymbols = (STR_FUNC_PARSING|STR_FUNC_SYMBOL|STR_FUNC_ARRAY),
-  str_dsymbols = (STR_FUNC_PARSING|STR_FUNC_SYMBOL|STR_FUNC_ARRAY|STR_FUNC_EXPAND),
-  str_heredoc  = (STR_FUNC_PARSING|STR_FUNC_HEREDOC),
-  str_xquote   = (STR_FUNC_PARSING|STR_FUNC_XQUOTE|STR_FUNC_EXPAND),
-};
-
-/* heredoc structure */
-struct mrb_parser_heredoc_info {
-  mrb_bool allow_indent:1;
-  mrb_bool remove_indent:1;
-  size_t indent;
-  mrb_ast_node *indented;
-  mrb_bool line_head:1;
-  enum mrb_string_type type;
-  const char *term;
-  int term_len;
-  mrb_ast_node *doc;
-};
-
 #define MRB_PARSER_TOKBUF_MAX (UINT16_MAX-1)
 #define MRB_PARSER_TOKBUF_SIZE 256
 
 /* parser structure */
 struct mrb_parser_state {
   mrb_state *mrb;
-  struct mrb_pool *pool;
+  mempool *pool;
   mrb_ast_node *cells;
   const char *s, *send;
 #ifndef MRB_NO_STDIO
   /* If both f and s are non-null, it will be taken preferentially from s until s < send. */
   FILE *f;
 #endif
-  mrbc_context *cxt;
+  mrb_ccontext *cxt;
   mrb_sym filename_sym;
   uint16_t lineno;
   int column;
 
   enum mrb_lex_state_enum lstate;
-  mrb_ast_node *lex_strterm; /* (type nest_level beg . end) */
+  struct parser_lex_strterm *lex_strterm;
 
   unsigned int cond_stack;
   unsigned int cmdarg_stack;
   int paren_nest;
   int lpar_beg;
-  int in_def, in_single;
+  int in_def, in_single, in_kwarg;
   mrb_bool cmd_start:1;
   mrb_ast_node *locals;
 
@@ -143,10 +114,8 @@ struct mrb_parser_state {
   int tidx;
   int tsiz;
 
-  mrb_ast_node *all_heredocs; /* list of mrb_parser_heredoc_info* */
   mrb_ast_node *heredocs_from_nextline;
   mrb_ast_node *parsing_heredoc;
-  mrb_ast_node *lex_strterm_before_heredoc;
 
   void *ylval;
 
@@ -157,6 +126,7 @@ struct mrb_parser_state {
   mrb_bool no_optimize:1;
   mrb_bool capture_errors:1;
   mrb_bool no_ext_ops:1;
+  mrb_bool no_return_value:1;
   const struct RProc *upper;
   struct mrb_parser_message error_buffer[10];
   struct mrb_parser_message warn_buffer[10];
@@ -165,43 +135,51 @@ struct mrb_parser_state {
   uint16_t filename_table_length;
   uint16_t current_filename_index;
 
+  /* Variable-sized node management */
   mrb_ast_node *nvars;
 };
 
 MRB_API struct mrb_parser_state* mrb_parser_new(mrb_state*);
 MRB_API void mrb_parser_free(struct mrb_parser_state*);
-MRB_API void mrb_parser_parse(struct mrb_parser_state*,mrbc_context*);
+MRB_API void mrb_parser_parse(struct mrb_parser_state*,mrb_ccontext*);
 
 MRB_API void mrb_parser_set_filename(struct mrb_parser_state*, char const*);
 MRB_API mrb_sym mrb_parser_get_filename(struct mrb_parser_state*, uint16_t idx);
 
 /* utility functions */
 #ifndef MRB_NO_STDIO
-MRB_API struct mrb_parser_state* mrb_parse_file(mrb_state*,FILE*,mrbc_context*);
+MRB_API struct mrb_parser_state* mrb_parse_file(mrb_state*,FILE*,mrb_ccontext*);
 #endif
-MRB_API struct mrb_parser_state* mrb_parse_string(mrb_state*,const char*,mrbc_context*);
-MRB_API struct mrb_parser_state* mrb_parse_nstring(mrb_state*,const char*,size_t,mrbc_context*);
+MRB_API struct mrb_parser_state* mrb_parse_string(mrb_state*,const char*,mrb_ccontext*);
+MRB_API struct mrb_parser_state* mrb_parse_nstring(mrb_state*,const char*,size_t,mrb_ccontext*);
 MRB_API struct RProc* mrb_generate_code(mrb_state*, struct mrb_parser_state*);
-MRB_API mrb_value mrb_load_exec(mrb_state *mrb, struct mrb_parser_state *p, mrbc_context *c);
-
-/** program load functions
-* Please note! Currently due to interactions with the GC calling these functions will
-* leak one RProc object per function call.
-* To prevent this save the current memory arena before calling and restore the arena
-* right after, like so
-* int ai = mrb_gc_arena_save(mrb);
-* mrb_value status = mrb_load_string(mrb, buffer);
-* mrb_gc_arena_restore(mrb, ai);
-*/
+MRB_API mrb_value mrb_load_exec(mrb_state *mrb, struct mrb_parser_state *p, mrb_ccontext *c);
+
+/**
+ * program load functions
+ *
+ * Please note! Currently due to interactions with the GC calling these functions will
+ * leak one RProc object per function call.
+ * To prevent this save the current memory arena before calling and restore the arena
+ * right after, like so
+ *
+ *      int ai = mrb_gc_arena_save(mrb);
+ *      mrb_value status = mrb_load_string(mrb, buffer);
+ *      mrb_gc_arena_restore(mrb, ai);
+ *
+ * Also, when called from a C function defined as a method, the current stack is destroyed.
+ * If processing continues after this function, the objects obtained from the arguments
+ * must be protected as needed before this function.
+ */
 #ifndef MRB_NO_STDIO
 MRB_API mrb_value mrb_load_file(mrb_state*,FILE*);
-MRB_API mrb_value mrb_load_file_cxt(mrb_state*,FILE*, mrbc_context *cxt);
-MRB_API mrb_value mrb_load_detect_file_cxt(mrb_state *mrb, FILE *fp, mrbc_context *c);
+MRB_API mrb_value mrb_load_file_cxt(mrb_state*,FILE*, mrb_ccontext *cxt);
+MRB_API mrb_value mrb_load_detect_file_cxt(mrb_state *mrb, FILE *fp, mrb_ccontext *c);
 #endif
 MRB_API mrb_value mrb_load_string(mrb_state *mrb, const char *s);
 MRB_API mrb_value mrb_load_nstring(mrb_state *mrb, const char *s, size_t len);
-MRB_API mrb_value mrb_load_string_cxt(mrb_state *mrb, const char *s, mrbc_context *cxt);
-MRB_API mrb_value mrb_load_nstring_cxt(mrb_state *mrb, const char *s, size_t len, mrbc_context *cxt);
+MRB_API mrb_value mrb_load_string_cxt(mrb_state *mrb, const char *s, mrb_ccontext *cxt);
+MRB_API mrb_value mrb_load_nstring_cxt(mrb_state *mrb, const char *s, size_t len, mrb_ccontext *cxt);
 
 /** @} */
 MRB_END_DECL

data/assets/{include → platform/include}/mruby/data.h

@@ -41,12 +41,12 @@ MRB_API struct RData *mrb_data_object_alloc(mrb_state *mrb, struct RClass* klass
 
 #define Data_Make_Struct(mrb,klass,strct,type,sval,data_obj) do { \
   (data_obj) = Data_Wrap_Struct(mrb,klass,type,NULL);\
-  (sval) = (strct *)mrb_malloc(mrb, sizeof(strct));                     \
+  (sval) = (strct*)mrb_malloc(mrb, sizeof(strct));                     \
   { static const strct zero = { 0 }; *(sval) = zero; };\
   (data_obj)->data = (sval);\
 } while (0)
 
-#define RDATA(obj)         ((struct RData *)(mrb_ptr(obj)))
+#define RDATA(obj)         ((struct RData*)(mrb_ptr(obj)))
 #define DATA_PTR(d)        (RDATA(d)->data)
 #define DATA_TYPE(d)       (RDATA(d)->type)
 MRB_API void mrb_data_check_type(mrb_state *mrb, mrb_value, const mrb_data_type*);

data/assets/{include → platform/include}/mruby/debug.h

@@ -10,7 +10,7 @@
 #include "common.h"
 
 /**
- * MRuby Debugging.
+ * mruby Debugging.
  */
 MRB_BEGIN_DECL
 
@@ -31,10 +31,11 @@ typedef struct mrb_irep_debug_info_file {
   uint32_t line_entry_count;
   mrb_debug_line_type line_type;
   union {
+    const char *s;
     void *ptr;
-    uint16_t *ary;
-    mrb_irep_debug_info_line *flat_map;
-    uint8_t *packed_map;
+    const uint16_t *ary;
+    const mrb_irep_debug_info_line *flat_map;
+    const uint8_t *packed_map;
   } lines;
 } mrb_irep_debug_info_file;
 
@@ -45,7 +46,7 @@ typedef struct mrb_irep_debug_info {
 } mrb_irep_debug_info;
 
 /*
- * get line from irep's debug info and program counter
+ * get filename from irep's debug info and program counter
  * @return returns NULL if not found
  */
 MRB_API const char *mrb_debug_get_filename(mrb_state *mrb, const mrb_irep *irep, uint32_t pc);
@@ -56,6 +57,12 @@ MRB_API const char *mrb_debug_get_filename(mrb_state *mrb, const mrb_irep *irep,
  */
 MRB_API int32_t mrb_debug_get_line(mrb_state *mrb, const mrb_irep *irep, uint32_t pc);
 
+/*
+ * get line and filename from irep's debug info and program counter
+ * @return returns FALSE if not found
+ */
+MRB_API mrb_bool mrb_debug_get_position(mrb_state *mrb, const mrb_irep *irep, uint32_t pc, int32_t *lp, const char **fp);
+
 MRB_API mrb_irep_debug_info *mrb_debug_info_alloc(mrb_state *mrb, mrb_irep *irep);
 MRB_API mrb_irep_debug_info_file *mrb_debug_info_append_file(
     mrb_state *mrb, mrb_irep_debug_info *info,

data/assets/{include → platform/include}/mruby/dump.h

@@ -19,17 +19,15 @@ MRB_BEGIN_DECL
 /* flags for mrb_dump_irep{,_binary,_cfunc,_cstruct} */
 #define MRB_DUMP_DEBUG_INFO 1
 #define MRB_DUMP_STATIC 2
-#define DUMP_DEBUG_INFO MRB_DUMP_DEBUG_INFO  /* deprecated */
+#define MRB_DUMP_NO_LVAR 4
 
-int mrb_dump_irep(mrb_state *mrb, const mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size);
 #ifndef MRB_NO_STDIO
-int mrb_dump_irep_binary(mrb_state*, const mrb_irep*, uint8_t, FILE*);
-int mrb_dump_irep_cfunc(mrb_state *mrb, const mrb_irep*, uint8_t flags, FILE *f, const char *initname);
-int mrb_dump_irep_cstruct(mrb_state *mrb, const mrb_irep*, uint8_t flags, FILE *f, const char *initname);
-mrb_irep *mrb_read_irep_file(mrb_state*, FILE*);
 MRB_API mrb_value mrb_load_irep_file(mrb_state*,FILE*);
-MRB_API mrb_value mrb_load_irep_file_cxt(mrb_state*, FILE*, mrbc_context*);
+MRB_API mrb_value mrb_load_irep_file_cxt(mrb_state*, FILE*, mrb_ccontext*);
+mrb_irep *mrb_read_irep_file(mrb_state*, FILE*);
+int mrb_dump_irep_binary(mrb_state*, const mrb_irep*, uint8_t, FILE*);
 #endif
+/* avoid mrb_read_irep(); use mrb_read_irep_buf() instead (may cause buffer overflow) */
 MRB_API mrb_irep *mrb_read_irep(mrb_state*, const uint8_t*);
 MRB_API mrb_irep *mrb_read_irep_buf(mrb_state*, const void*, size_t);
 
@@ -54,13 +52,13 @@ MRB_API mrb_irep *mrb_read_irep_buf(mrb_state*, const void*, size_t);
 /* Binary Format Version Major:Minor */
 /*   Major: Incompatible to prior versions */
 /*   Minor: Upper-compatible to prior versions */
-#define RITE_BINARY_MAJOR_VER          "03"
+#define RITE_BINARY_MAJOR_VER          "04"
 #define RITE_BINARY_MINOR_VER          "00"
 #define RITE_BINARY_FORMAT_VER         RITE_BINARY_MAJOR_VER RITE_BINARY_MINOR_VER
 #define RITE_COMPILER_NAME             "MATZ"
 #define RITE_COMPILER_VERSION          "0000"
 
-#define RITE_VM_VER                    "0300"
+#define RITE_VM_VER                    "0400"
 
 #define RITE_BINARY_EOF                "END\0"
 #define RITE_SECTION_IREP_IDENT        "IREP"

data/assets/{include → platform/include}/mruby/endian.h

@@ -34,7 +34,7 @@ static inline int
 check_little_endian(void)
 {
   unsigned int n = 1;
-  return (*(unsigned char *)&n == 1);
+  return (*(unsigned char*)&n == 1);
 }
 #  define littleendian check_little_endian()
 #endif

data/assets/platform/include/mruby/error.h

@@ -0,0 +1,173 @@
+/**
+** @file mruby/error.h - Exception class
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_ERROR_H
+#define MRUBY_ERROR_H
+
+#include "common.h"
+#include <string.h>
+
+/**
+ * mruby error handling.
+ */
+MRB_BEGIN_DECL
+
+struct RException {
+  MRB_OBJECT_HEADER;
+  struct iv_tbl *iv;
+  struct RBasic *mesg;         // NULL or probably RString
+  struct RBasic *backtrace;    // NULL, RArray or RData
+};
+
+/* error that should terminate execution */
+#define MRB_EXC_EXIT 65536
+#define MRB_EXC_EXIT_P(e) ((e)->flags & MRB_EXC_EXIT)
+/* retrieve status value from exc; need <mruby/variable.h> and <mruby/presym.h> */
+#define MRB_EXC_EXIT_STATUS(mrb,e) ((int)mrb_as_int((mrb),mrb_obj_iv_get((mrb),(e),MRB_SYM(status))))
+/* exit with SystemExit status */
+#define MRB_EXC_CHECK_EXIT(mrb,e) do {if (MRB_EXC_EXIT_P(e)) exit(MRB_EXC_EXIT_STATUS((mrb),(e)));} while (0)
+
+#define mrb_exc_ptr(v) ((struct RException*)mrb_ptr(v))
+
+MRB_API mrb_noreturn void mrb_sys_fail(mrb_state *mrb, const char *mesg);
+MRB_API mrb_value mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str);
+#define mrb_exc_new_lit(mrb, c, lit) mrb_exc_new_str(mrb, c, mrb_str_new_lit(mrb, lit))
+MRB_API mrb_noreturn void mrb_no_method_error(mrb_state *mrb, mrb_sym id, mrb_value args, const char *fmt, ...);
+
+#if defined(MRB_NAN_BOXING) || defined(MRB_WORD_BOXING) || defined(MRB_64BIT)
+#undef MRB_USE_RBREAK_VALUE_UNION
+#else
+#define MRB_USE_RBREAK_VALUE_UNION 1
+#endif
+
+/*
+ *  flags:
+ *      0..7:   enum mrb_vtype (only when defined MRB_USE_RBREAK_VALUE_UNION)
+ *      8..10:  RBREAK_TAGs in src/vm.c (otherwise, set to 0)
+ */
+struct RBreak {
+  MRB_OBJECT_HEADER;
+  uintptr_t ci_break_index; // The top-level ci index to break. One before the return destination.
+#ifndef MRB_USE_RBREAK_VALUE_UNION
+  mrb_value val;
+#else
+  /* Store value as uint32_t words instead of union mrb_value_union
+     to avoid 8-byte alignment of int64_t/double on 32-bit platforms
+     (e.g., ARM, MIPS, PowerPC) which would inflate struct size beyond
+     the 5-word RVALUE limit due to padding. */
+  uint32_t value[sizeof(union mrb_value_union) / sizeof(uint32_t)];
+#endif
+};
+
+#ifndef MRB_USE_RBREAK_VALUE_UNION
+#define mrb_break_value_get(brk) ((brk)->val)
+#define mrb_break_value_set(brk, v) ((brk)->val = v)
+#else
+#define RBREAK_VALUE_TT_MASK ((1 << 8) - 1)
+static inline mrb_value
+mrb_break_value_get(struct RBreak *brk)
+{
+  mrb_value val;
+  memcpy(&val.value, brk->value, sizeof(val.value));
+  val.tt = (enum mrb_vtype)(brk->flags & RBREAK_VALUE_TT_MASK);
+  return val;
+}
+static inline void
+mrb_break_value_set(struct RBreak *brk, mrb_value val)
+{
+  memcpy(brk->value, &val.value, sizeof(val.value));
+  brk->flags &= ~RBREAK_VALUE_TT_MASK;
+  brk->flags |= val.tt;
+}
+#endif  /* MRB_USE_RBREAK_VALUE_UNION */
+
+/**
+ * Error check
+ *
+ */
+/* clear error status in the mrb_state structure */
+MRB_API void mrb_clear_error(mrb_state *mrb);
+/* returns TRUE if error in the previous call; internally calls mrb_clear_error() */
+MRB_API mrb_bool mrb_check_error(mrb_state *mrb);
+
+/**
+ * Protect
+ *
+ */
+typedef mrb_value mrb_protect_error_func(mrb_state *mrb, void *userdata);
+MRB_API mrb_value mrb_protect_error(mrb_state *mrb, mrb_protect_error_func *body, void *userdata, mrb_bool *error);
+
+/**
+ * Protect (takes mrb_value for body argument)
+ *
+ * Implemented in the mruby-error mrbgem
+ */
+MRB_API mrb_value mrb_protect(mrb_state *mrb, mrb_func_t body, mrb_value data, mrb_bool *state);
+
+/**
+ * Ensure
+ *
+ * Implemented in the mruby-error mrbgem
+ */
+MRB_API mrb_value mrb_ensure(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
+                             mrb_func_t ensure, mrb_value e_data);
+
+/**
+ * Rescue
+ *
+ * Implemented in the mruby-error mrbgem
+ */
+MRB_API mrb_value mrb_rescue(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
+                             mrb_func_t rescue, mrb_value r_data);
+
+/**
+ * Rescue exception
+ *
+ * Implemented in the mruby-error mrbgem
+ */
+MRB_API mrb_value mrb_rescue_exceptions(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
+                                        mrb_func_t rescue, mrb_value r_data,
+                                        mrb_int len, struct RClass **classes);
+
+/**
+ *  Calls `func` via `mrb_protect_error()` and then always executes the user block exactly once.
+ *  Even if a global jump (similar to a Ruby exception) occurs within `func`, the block will be executed,
+ *  and after the block's completion, the global jump will be re-thrown.
+ *
+ *  By checking `mrb->exc != NULL` within the block, you can determine if a global jump occurred in `func`.
+ *
+ *  If you want to suppress the global jump and continue processing, use `mrb_clear_error(mrb); break;`.
+ *
+ *  - `mrb`: The mruby state reference
+ *  - `result_var`: Pre-defined mrb_value type variable (to receive `func`'s return value)
+ *  - `func`: Function to call (compatible with `mrb_protect_error_func`)
+ *  - `data`: User data to pass to `func`
+ *
+ *  Example:
+ *
+ *      mrb_value result;
+ *      MRB_ENSURE(mrb, result, body_func, userdata) {
+ *        // This block is always executed (equivalent to Ruby's ensure)
+ *
+ *        if (mrb->exc) {
+ *          // Post-processing when an exception occurs
+ *        }
+ *
+ *        // To ignore the global jump, use `mrb_clear_error(mrb); break;` here
+ *      }
+ */
+#define MRB_ENSURE(mrb, result_var, func, data) \
+        for (mrb_bool MRB_UNIQNAME(_break_) = FALSE; \
+             !MRB_UNIQNAME(_break_) && \
+                (((result_var) = mrb_protect_error(mrb, func, data, &MRB_UNIQNAME(_break_))), \
+                 ((mrb)->exc = (MRB_UNIQNAME(_break_) ? mrb_obj_ptr((result_var)) : NULL)), \
+                 TRUE); \
+             (void)(MRB_UNIQNAME(_break_) && (mrb)->jmp && (mrb_exc_raise(mrb, result_var), TRUE)), \
+                MRB_UNIQNAME(_break_) = TRUE)
+
+MRB_END_DECL
+
+#endif  /* MRUBY_ERROR_H */

data/assets/platform/include/mruby/gc.h

@@ -0,0 +1,79 @@
+/**
+** @file mruby/gc.h - garbage collector for mruby
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_GC_H
+#define MRUBY_GC_H
+
+#include "common.h"
+
+/**
+ * Uncommon memory management stuffs.
+ */
+MRB_BEGIN_DECL
+
+
+struct mrb_state;
+
+#define MRB_EACH_OBJ_OK 0
+#define MRB_EACH_OBJ_BREAK 1
+typedef int (mrb_each_object_callback)(struct mrb_state *mrb, struct RBasic *obj, void *data);
+void mrb_objspace_each_objects(struct mrb_state *mrb, mrb_each_object_callback *callback, void *data);
+size_t mrb_objspace_page_slot_size(void);
+MRB_API void mrb_free_context(struct mrb_state *mrb, struct mrb_context *c);
+
+#ifndef MRB_GC_ARENA_SIZE
+#define MRB_GC_ARENA_SIZE 100
+#endif
+
+#ifndef MRB_GRAY_STACK_SIZE
+#define MRB_GRAY_STACK_SIZE 1024
+#endif
+
+typedef enum {
+  MRB_GC_STATE_ROOT = 0,
+  MRB_GC_STATE_MARK,
+  MRB_GC_STATE_SWEEP
+} mrb_gc_state;
+
+typedef struct mrb_gc {
+  struct mrb_heap_page *heaps;     /* all heaps pages */
+  struct mrb_heap_page *free_heaps;/* heaps for allocation */
+  struct mrb_heap_page *sweeps;    /* page where sweep starts */
+  struct mrb_heap_region *regions;  /* contiguous heap regions */
+  struct RBasic *gray_stack[MRB_GRAY_STACK_SIZE]; /* stack of gray objects */
+  size_t gray_stack_top;           /* top index of gray stack */
+  mrb_bool gray_overflow:1;        /* gray stack overflowed; needs heap rescan */
+  size_t live;                     /* count of live objects */
+  size_t live_after_mark;          /* old generation objects */
+  size_t threshold;                /* threshold to start GC */
+  size_t oldgen_threshold;         /* threshold to kick major GC */
+  mrb_gc_state state;              /* current state of gc */
+  int interval_ratio;
+  int step_ratio;
+  int current_white_part :2;       /* make white object by white_part */
+  mrb_bool iterating     :1;       /* currently iterating over objects */
+  mrb_bool disabled      :1;       /* GC disabled */
+  mrb_bool generational  :1;       /* generational GC mode */
+  mrb_bool full          :1;       /* major GC mode */
+  mrb_bool out_of_memory :1;       /* out-of-memory error occurred */
+
+#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;                          /* size of protection array */
+#endif
+  int arena_idx;
+} mrb_gc;
+
+MRB_API mrb_bool mrb_object_dead_p(struct mrb_state *mrb, struct RBasic *object);
+MRB_API int mrb_gc_add_region(struct mrb_state *mrb, void *start, size_t size);
+
+#define MRB_GC_RED 7
+
+MRB_END_DECL
+
+#endif  /* MRUBY_GC_H */

data/assets/{include → platform/include}/mruby/hash.h

@@ -14,7 +14,7 @@
  */
 MRB_BEGIN_DECL
 
-/* offset of `iv` must be 3 words */
+/* offset of `iv` must match struct RObject */
 struct RHash {
   MRB_OBJECT_HEADER;
 #ifdef MRB_64BIT
@@ -35,7 +35,6 @@ struct RHash {
 #define mrb_hash_ptr(v)    ((struct RHash*)(mrb_ptr(v)))
 #define mrb_hash_value(p)  mrb_obj_value((void*)(p))
 
-size_t mrb_hash_memsize(mrb_value obj);
 MRB_API mrb_value mrb_hash_new_capa(mrb_state *mrb, mrb_int capa);
 
 /*
@@ -226,11 +225,6 @@ MRB_API void mrb_hash_merge(mrb_state *mrb, mrb_value hash1, mrb_value hash2);
 #define MRB_RHASH_DEFAULT_P(hash) (RHASH(hash)->flags & MRB_HASH_DEFAULT)
 #define MRB_RHASH_PROCDEFAULT_P(hash) (RHASH(hash)->flags & MRB_HASH_PROC_DEFAULT)
 
-/* GC functions */
-void mrb_gc_mark_hash(mrb_state*, struct RHash*);
-size_t mrb_gc_mark_hash_size(mrb_state*, struct RHash*);
-void mrb_gc_free_hash(mrb_state*, struct RHash*);
-
 /* return non zero to break the loop */
 typedef int (mrb_hash_foreach_func)(mrb_state *mrb, mrb_value key, mrb_value val, void *data);
 MRB_API void mrb_hash_foreach(mrb_state *mrb, struct RHash *hash, mrb_hash_foreach_func *func, void *p);