default mruby build

CMakeLists.txt

@@ -20,12 +20,15 @@ add_executable(mrubypp main.cpp
         example/Point.h)
 
 
+if (NOT mruby_ROOT)
+    message(NOTICE "[mrubypp] Using default mruby build")
     set(mruby_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/deps/mruby")
+endif ()
+
 target_include_directories(mrubypp PUBLIC "${mruby_ROOT}/include")
 target_link_directories(mrubypp PUBLIC "${mruby_ROOT}/lib")
 target_link_libraries(mrubypp PUBLIC
-        libmruby
+        libmruby ws2_32.lib wsock32.lib ws2_32.lib)
-        ws2_32.lib wsock32.lib ws2_32.lib)
 
 include_directories(${CMAKE_CURRENT_LIST_DIR})
 

deps/mruby/LEGAL

@@ -0,0 +1,240 @@
+Copyright (c) 2025 mruby developers
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+Additional Licenses
+
+Due to the reason that you chose additional mruby packages (GEMS),
+please check the following additional licenses too:
+
+GEM: mruby-string-ext
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-terminal-color
+Copyright (c) 2025 buty4649@gmail.com
+License: MIT
+
+GEM: mruby-yyjson
+Copyright (c) 2025 buty4649@gmail.com
+License: MIT
+
+GEM: mruby-array-ext
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-bigint
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-bin-config
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-compiler
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-bin-mirb
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-bin-mrbc
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-bin-mruby
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-bin-strip
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-binding
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-catch
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-class-ext
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-math
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-complex
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-cmath
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-compar-ext
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-data
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-dir
+Copyright (c) 2025 Internet Initiative Japan Inc., Kevlin Henney
+License: MIT and MIT-like license
+
+GEM: mruby-encoding
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-fiber
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-enumerator
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-enum-chain
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-enum-ext
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-enum-lazy
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-errno
+Copyright (c) 2025 Internet Initiative Japan Inc.
+License: MIT
+
+GEM: mruby-error
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-eval
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-exit
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-hash-ext
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-io
+Copyright (c) 2025 Internet Initiative Japan Inc., mruby developers
+License: MIT
+
+GEM: mruby-kernel-ext
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-metaprog
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-proc-ext
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-method
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-numeric-ext
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-object-ext
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-objectspace
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-os-memsize
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-pack
+Copyright (c) 2025 Internet Initiative Japan Inc., mruby developers
+License: MIT
+
+GEM: mruby-proc-binding
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-random
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-range-ext
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-rational
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-set
+Copyright (c) 2025 yui-knk
+License: MIT
+
+GEM: mruby-sleep
+Copyright (c) 2025 MATSUMOTO Ryosuke, mruby developers
+License: MIT
+
+GEM: mruby-socket
+Copyright (c) 2025 Internet Initiative Japan Inc., mruby developers
+License: MIT
+
+GEM: mruby-sprintf
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-struct
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-symbol-ext
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-test-inline-struct
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-time
+Copyright (c) 2025 mruby developers
+License: MIT
+
+GEM: mruby-toplevel-ext
+Copyright (c) 2025 mruby developers
+License: MIT

deps/mruby/bin/mruby-config.bat

@@ -0,0 +1,92 @@
+@echo off
+
+set MRUBY_PACKAGE_DIR=%~dp0..
+
+:top
+shift
+if "%0" equ "" goto :eof
+if "%0" equ "--cc" goto cc
+if "%0" equ "--cflags" goto cflags
+if "%0" equ "--cxx" goto cxx
+if "%0" equ "--cxxflags" goto cxxflags
+if "%0" equ "--as" goto as
+if "%0" equ "--asflags" goto asflags
+if "%0" equ "--objc" goto objc
+if "%0" equ "--objcflags" goto objcflags
+if "%0" equ "--ld" goto ld
+if "%0" equ "--ldflags" goto ldflags
+if "%0" equ "--ldflags-before-libs" goto ldflagsbeforelibs
+if "%0" equ "--libs" goto libs
+if "%0" equ "--libmruby-path" goto libmrubypath
+if "%0" equ "--help" goto showhelp
+echo Invalid Option
+goto :eof
+
+:cc
+echo cl.exe
+goto top
+
+:cflags
+echo /nologo /W3 /MD /O2 /D_CRT_SECURE_NO_WARNINGS /we4013 /DMRB_STACK_EXTEND_DOUBLING /DMRB_UTF8_STRING /DMRB_USE_BIGINT /DMRB_USE_COMPLEX /DHAVE_MRUBY_ENCODING_GEM /DMRB_UTF8_STRING /DHAVE_MRUBY_IO_GEM /DMRB_USE_RATIONAL /I"%MRUBY_PACKAGE_DIR%\include" /I"%MRUBY_PACKAGE_DIR%\include\mruby\gems\mruby-io\include" /I"%MRUBY_PACKAGE_DIR%\include\mruby\gems\mruby-time\include"
+goto top
+
+:cxx
+echo cl.exe
+goto top
+
+:cxxflags
+echo /nologo /W3 /MD /O2 /D_CRT_SECURE_NO_WARNINGS /EHs /DMRB_STACK_EXTEND_DOUBLING /DMRB_UTF8_STRING /DMRB_USE_BIGINT /DMRB_USE_COMPLEX /DHAVE_MRUBY_ENCODING_GEM /DMRB_UTF8_STRING /DHAVE_MRUBY_IO_GEM /DMRB_USE_RATIONAL /I"%MRUBY_PACKAGE_DIR%\include" /I"%MRUBY_PACKAGE_DIR%\include\mruby\gems\mruby-io\include" /I"%MRUBY_PACKAGE_DIR%\include\mruby\gems\mruby-time\include"
+goto top
+
+:as
+echo cc
+goto top
+
+:asflags
+echo -D"MRB_UTF8_STRING" -D"MRB_USE_BIGINT" -D"MRB_USE_COMPLEX" -D"HAVE_MRUBY_ENCODING_GEM" -D"MRB_UTF8_STRING" -D"HAVE_MRUBY_IO_GEM" -D"MRB_USE_RATIONAL" -I"%MRUBY_PACKAGE_DIR%\include" -I"%MRUBY_PACKAGE_DIR%\include\mruby\gems\mruby-io\include" -I"%MRUBY_PACKAGE_DIR%\include\mruby\gems\mruby-time\include"
+goto top
+
+:objc
+echo cc
+goto top
+
+:objcflags
+echo -D"MRB_UTF8_STRING" -D"MRB_USE_BIGINT" -D"MRB_USE_COMPLEX" -D"HAVE_MRUBY_ENCODING_GEM" -D"MRB_UTF8_STRING" -D"HAVE_MRUBY_IO_GEM" -D"MRB_USE_RATIONAL" -I"%MRUBY_PACKAGE_DIR%\include" -I"%MRUBY_PACKAGE_DIR%\include\mruby\gems\mruby-io\include" -I"%MRUBY_PACKAGE_DIR%\include\mruby\gems\mruby-time\include"
+goto top
+
+:ld
+echo link.exe
+goto top
+
+:libs
+echo libmruby.lib ws2_32.lib wsock32.lib ws2_32.lib
+goto top
+
+:ldflags
+echo /NOLOGO /DEBUG /INCREMENTAL:NO /OPT:ICF /OPT:REF /DEBUG:NONE /LIBPATH:%MRUBY_PACKAGE_DIR%/lib
+goto top
+
+:ldflagsbeforelibs
+
+goto top
+
+:libmrubypath
+echo %MRUBY_PACKAGE_DIR%/lib/libmruby.lib
+goto top
+
+:showhelp
+echo Usage: mruby-config [switches]
+echo   switches:
+echo   --cc                       print C compiler name
+echo   --cflags                   print flags passed to C compiler
+echo   --cxx                      print C++ compiler name
+echo   --cxxflags                 print flags passed to C++ compiler
+echo   --as                       print assembler name
+echo   --asflags                  print flags passed to assembler
+echo   --objc                     print Objective C compiler name
+echo   --objcflags                print flags passed to Objective C compiler
+echo   --ld                       print linker name
+echo   --ldflags                  print flags passed to linker
+echo   --ldflags-before-libs      print flags passed to linker before linked libraries
+echo   --libs                     print linked libraries
+echo   --libmruby-path            print libmruby path

deps/mruby/include/mrbconf.h

@@ -0,0 +1,230 @@
+/*
+** mrbconf.h - mruby core configuration
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBYCONF_H
+#define MRUBYCONF_H
+
+/* architecture selection: */
+/* specify -DMRB_32BIT or -DMRB_64BIT to override */
+#if !defined(MRB_32BIT) && !defined(MRB_64BIT)
+#if UINT64_MAX == SIZE_MAX
+#define MRB_64BIT
+#else
+#define MRB_32BIT
+#endif
+#endif
+
+#if defined(MRB_32BIT) && defined(MRB_64BIT)
+#error Cannot build for 32 and 64-bit architecture at the same time
+#endif
+
+/* configuration options: */
+/* add -DMRB_USE_FLOAT32 to use float instead of double for floating-point numbers */
+//#define MRB_USE_FLOAT32
+
+/* exclude floating-point numbers */
+//#define MRB_NO_FLOAT
+
+/* obsolete configuration */
+#if defined(MRB_USE_FLOAT)
+# define MRB_USE_FLOAT32
+#endif
+
+/* obsolete configuration */
+#if defined(MRB_WITHOUT_FLOAT)
+# define MRB_NO_FLOAT
+#endif
+
+#if defined(MRB_USE_FLOAT32) && defined(MRB_NO_FLOAT)
+#error Cannot define MRB_USE_FLOAT32 and MRB_NO_FLOAT at the same time
+#endif
+
+/* add -DMRB_NO_METHOD_CACHE to disable method cache to save memory */
+//#define MRB_NO_METHOD_CACHE
+/* size of the method cache (need to be the power of 2) */
+//#define MRB_METHOD_CACHE_SIZE (1<<8)
+//#define MRB_USE_INLINE_METHOD_CACHE
+
+/* define on big endian machines; used by MRB_NAN_BOXING, etc. */
+#ifndef MRB_ENDIAN_BIG
+# if (defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN) || \
+     (defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
+#  define MRB_ENDIAN_BIG
+# endif
+#endif
+
+/* represent mrb_value in boxed double; conflict with MRB_USE_FLOAT32 and MRB_NO_FLOAT */
+//#define MRB_NAN_BOXING
+
+/* represent mrb_value as a word (natural unit of data for the processor) */
+//#define MRB_WORD_BOXING
+
+/* represent mrb_value as a struct; occupies 2 words */
+//#define MRB_NO_BOXING
+
+/* if no specific boxing type is chosen */
+#if !defined(MRB_NAN_BOXING) && !defined(MRB_WORD_BOXING) && !defined(MRB_NO_BOXING)
+# define MRB_WORD_BOXING
+#endif
+
+/* if defined mruby allocates Float objects in the heap to keep full precision if needed */
+//#define MRB_WORDBOX_NO_FLOAT_TRUNCATE
+
+/* add -DMRB_INT32 to use 32-bit integer for mrb_int; conflict with MRB_INT64;
+   Default for 32-bit CPU mode. */
+//#define MRB_INT32
+
+/* add -DMRB_INT64 to use 64-bit integer for mrb_int; conflict with MRB_INT32;
+   Default for 64-bit CPU mode (unless using MRB_NAN_BOXING). */
+//#define MRB_INT64
+
+/* if no specific integer type is chosen */
+#if !defined(MRB_INT32) && !defined(MRB_INT64)
+# if defined(MRB_64BIT) && !defined(MRB_NAN_BOXING)
+/* Use 64-bit integers on 64-bit architecture (without MRB_NAN_BOXING) */
+#  define MRB_INT64
+# else
+/* Otherwise use 32-bit integers */
+#  define MRB_INT32
+# endif
+#endif
+
+/* call malloc_trim(0) from mrb_full_gc() */
+//#define MRB_USE_MALLOC_TRIM
+
+/* string class to handle UTF-8 encoding */
+//#define MRB_UTF8_STRING
+
+/* maximum length of strings */
+/* the default value is 1MB */
+/* set this value to zero to skip the check */
+//#define MRB_STR_LENGTH_MAX 1048576
+
+/* maximum length of arrays */
+/* the default value is 2**17 entries */
+/* set this value to zero to skip the check */
+//#define MRB_ARY_LENGTH_MAX 131072
+
+/* argv max size in mrb_funcall */
+//#define MRB_FUNCALL_ARGC_MAX 16
+
+/* number of object per heap page */
+//#define MRB_HEAP_PAGE_SIZE 1024
+
+/* define if your platform does not support etext, edata */
+//#define MRB_NO_DEFAULT_RO_DATA_P
+
+/* define if your platform supports etext, edata */
+//#define MRB_USE_RO_DATA_P_ETEXT
+/* use MRB_USE_ETEXT_RO_DATA_P by default on Linux */
+#if (defined(__linux__) && !defined(__KERNEL__))
+#define MRB_USE_ETEXT_RO_DATA_P
+#endif
+
+/* you can provide and use mrb_ro_data_p() for your platform.
+   prototype is `mrb_bool mrb_ro_data_p(const char *ptr)` */
+//#define MRB_USE_CUSTOM_RO_DATA_P
+
+/* turn off generational GC by default */
+//#define MRB_GC_TURN_OFF_GENERATIONAL
+
+/* default size of khash table bucket */
+//#define KHASH_DEFAULT_SIZE 32
+
+/* allocated memory address alignment */
+//#define POOL_ALIGNMENT 4
+
+/* page size of memory pool */
+//#define POOL_PAGE_SIZE 16000
+
+/* arena size */
+//#define MRB_GC_ARENA_SIZE 100
+
+/* fixed size GC arena */
+//#define MRB_GC_FIXED_ARENA
+
+/* state atexit stack size */
+//#define MRB_FIXED_STATE_ATEXIT_STACK_SIZE 5
+
+/* fixed size state atexit stack */
+//#define MRB_FIXED_STATE_ATEXIT_STACK
+
+/* -DMRB_NO_XXXX to drop following features */
+//#define MRB_NO_STDIO /* use of stdio */
+
+/* -DMRB_USE_XXXX to enable following features */
+//#define MRB_USE_DEBUG_HOOK /* hooks for debugger */
+//#define MRB_USE_ALL_SYMBOLS /* Symbol.all_symbols */
+
+/* obsolete configurations */
+#if defined(DISABLE_STDIO) || defined(MRB_DISABLE_STDIO)
+# define MRB_NO_STDIO
+#endif
+#if defined(MRB_DISABLE_DIRECT_THREADING) || defined(MRB_NO_DIRECT_THREADING)
+# define MRB_USE_VM_SWITCH_DISPATCH
+#endif
+#if defined(ENABLE_DEBUG) || defined(MRB_ENABLE_DEBUG_HOOK)
+# define MRB_USE_DEBUG_HOOK
+#endif
+#ifdef MRB_ENABLE_ALL_SYMBOLS
+# define MRB_USE_ALL_SYMBOLS
+#endif
+#ifdef MRB_ENABLE_CXX_ABI
+# define MRB_USE_CXX_ABI
+#endif
+#ifdef MRB_ENABLE_CXX_EXCEPTION
+# define MRB_USE_CXX_EXCEPTION
+#endif
+
+/* end of configuration */
+
+#ifndef MRB_NO_STDIO
+# include <stdio.h>
+#endif
+
+/*
+** mruby tuning profiles
+**/
+
+/* A profile for micro controllers */
+#if defined(MRB_CONSTRAINED_BASELINE_PROFILE)
+# ifndef MRB_NO_METHOD_CACHE
+#  define MRB_NO_METHOD_CACHE
+# endif
+
+# ifndef KHASH_DEFAULT_SIZE
+#  define KHASH_DEFAULT_SIZE 16
+# endif
+
+# ifndef MRB_HEAP_PAGE_SIZE
+#  define MRB_HEAP_PAGE_SIZE 256
+# endif
+
+/* A profile for default mruby */
+#elif defined(MRB_BASELINE_PROFILE)
+
+/* A profile for desktop computers or workstations; rich memory! */
+#elif defined(MRB_MAIN_PROFILE)
+# ifndef MRB_METHOD_CACHE_SIZE
+#  define MRB_METHOD_CACHE_SIZE (1<<10)
+# endif
+
+# ifndef MRB_HEAP_PAGE_SIZE
+#  define MRB_HEAP_PAGE_SIZE 4096
+# endif
+
+/* A profile for server; mruby vm is long life */
+#elif defined(MRB_HIGH_PROFILE)
+# ifndef MRB_METHOD_CACHE_SIZE
+#  define MRB_METHOD_CACHE_SIZE (1<<12)
+# endif
+
+# ifndef MRB_HEAP_PAGE_SIZE
+#  define MRB_HEAP_PAGE_SIZE 4096
+# endif
+#endif
+
+#endif  /* MRUBYCONF_H */

deps/mruby/include/mruby/array.h

@@ -0,0 +1,301 @@
+/**
+** @file mruby/array.h - Array class
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_ARRAY_H
+#define MRUBY_ARRAY_H
+
+#include "common.h"
+
+/*
+ * Array class
+ */
+MRB_BEGIN_DECL
+
+typedef struct mrb_shared_array {
+  int refcnt;
+  mrb_ssize len;
+  mrb_value *ptr;
+} mrb_shared_array;
+
+#if defined(MRB_32BIT) && defined(MRB_NO_BOXING) && !defined(MRB_USE_FLOAT32) && !defined(MRB_ARY_NO_EMBED)
+# define MRB_ARY_NO_EMBED
+#endif
+
+#ifdef MRB_ARY_NO_EMBED
+# define MRB_ARY_EMBED_LEN_MAX 0
+#else
+# define MRB_ARY_EMBED_LEN_MAX ((mrb_int)(sizeof(void*)*3/sizeof(mrb_value)))
+mrb_static_assert(MRB_ARY_EMBED_LEN_MAX > 0, "MRB_ARY_EMBED_LEN_MAX > 0");
+#endif
+
+struct RArray {
+  MRB_OBJECT_HEADER;
+  union {
+    struct {
+      mrb_ssize len;
+      union {
+        mrb_ssize capa;
+        mrb_shared_array *shared;
+      } aux;
+      mrb_value *ptr;
+    } heap;
+#ifndef MRB_ARY_NO_EMBED
+    mrb_value ary[MRB_ARY_EMBED_LEN_MAX];
+#endif
+  } as;
+};
+
+#define mrb_ary_ptr(v)    ((struct RArray*)(mrb_ptr(v)))
+#define mrb_ary_value(p)  mrb_obj_value((void*)(p))
+#define RARRAY(v)  ((struct RArray*)(mrb_ptr(v)))
+
+#ifdef MRB_ARY_NO_EMBED
+#define ARY_EMBED_P(a) 0
+#define ARY_UNSET_EMBED_FLAG(a) (void)0
+#define ARY_EMBED_LEN(a) 0
+#define ARY_SET_EMBED_LEN(a,len) (void)0
+#define ARY_EMBED_PTR(a) 0
+#else
+#define MRB_ARY_EMBED_MASK  7
+#define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
+#define ARY_UNSET_EMBED_FLAG(a) ((a)->flags &= ~(MRB_ARY_EMBED_MASK))
+#define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
+#define ARY_SET_EMBED_LEN(a,len) ((a)->flags = ((a)->flags&~MRB_ARY_EMBED_MASK) | ((uint32_t)(len) + 1))
+#define ARY_EMBED_PTR(a) ((a)->as.ary)
+#endif
+
+#define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(mrb_int)(a)->as.heap.len)
+#define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
+#define RARRAY_LEN(a) ARY_LEN(RARRAY(a))
+#define RARRAY_PTR(a) ARY_PTR(RARRAY(a))
+#define ARY_SET_LEN(a,n) do {\
+  if (ARY_EMBED_P(a)) {\
+    mrb_assert((n) <= MRB_ARY_EMBED_LEN_MAX); \
+    ARY_SET_EMBED_LEN(a,n);\
+  }\
+  else\
+    (a)->as.heap.len = (n);\
+} while (0)
+#define ARY_CAPA(a) (ARY_EMBED_P(a)?MRB_ARY_EMBED_LEN_MAX:(a)->as.heap.aux.capa)
+#define MRB_ARY_SHARED      256
+#define ARY_SHARED_P(a) ((a)->flags & MRB_ARY_SHARED)
+#define ARY_SET_SHARED_FLAG(a) ((a)->flags |= MRB_ARY_SHARED)
+#define ARY_UNSET_SHARED_FLAG(a) ((a)->flags &= ~MRB_ARY_SHARED)
+
+MRB_API void mrb_ary_modify(mrb_state*, struct RArray*);
+MRB_API mrb_value mrb_ary_new_capa(mrb_state*, mrb_int);
+
+/*
+ * Initializes a new array.
+ *
+ * Equivalent to:
+ *
+ *      Array.new
+ *
+ * @param mrb The mruby state reference.
+ * @return The initialized array.
+ */
+MRB_API mrb_value mrb_ary_new(mrb_state *mrb);
+
+/*
+ * Initializes a new array with initial values
+ *
+ * Equivalent to:
+ *
+ *      Array[value1, value2, ...]
+ *
+ * @param mrb The mruby state reference.
+ * @param size The number of values.
+ * @param vals The actual values.
+ * @return The initialized array.
+ */
+MRB_API mrb_value mrb_ary_new_from_values(mrb_state *mrb, mrb_int size, const mrb_value *vals);
+
+/*
+ * Initializes a new array with two initial values
+ *
+ * Equivalent to:
+ *
+ *      Array[car, cdr]
+ *
+ * @param mrb The mruby state reference.
+ * @param car The first value.
+ * @param cdr The second value.
+ * @return The initialized array.
+ */
+MRB_API mrb_value mrb_assoc_new(mrb_state *mrb, mrb_value car, mrb_value cdr);
+
+/*
+ * Concatenate two arrays. The target array will be modified
+ *
+ * Equivalent to:
+ *      ary.concat(other)
+ *
+ * @param mrb The mruby state reference.
+ * @param self The target array.
+ * @param other The array that will be concatenated to self.
+ */
+MRB_API void mrb_ary_concat(mrb_state *mrb, mrb_value self, mrb_value other);
+
+/*
+ * Create an array from the input. It tries calling to_a on the
+ * value. If value does not respond to that, it creates a new
+ * array with just this value.
+ *
+ * @param mrb The mruby state reference.
+ * @param value The value to change into an array.
+ * @return An array representation of value.
+ */
+MRB_API mrb_value mrb_ary_splat(mrb_state *mrb, mrb_value value);
+
+/*
+ * Pushes value into array.
+ *
+ * Equivalent to:
+ *
+ *      ary << value
+ *
+ * @param mrb The mruby state reference.
+ * @param ary The array in which the value will be pushed
+ * @param value The value to be pushed into array
+ */
+MRB_API void mrb_ary_push(mrb_state *mrb, mrb_value array, mrb_value value);
+
+/*
+ * Pops the last element from the array.
+ *
+ * Equivalent to:
+ *
+ *      ary.pop
+ *
+ * @param mrb The mruby state reference.
+ * @param ary The array from which the value will be popped.
+ * @return The popped value.
+ */
+MRB_API mrb_value mrb_ary_pop(mrb_state *mrb, mrb_value ary);
+
+/*
+ * Sets a value on an array at the given index
+ *
+ * Equivalent to:
+ *
+ *      ary[n] = val
+ *
+ * @param mrb The mruby state reference.
+ * @param ary The target array.
+ * @param n The array index being referenced.
+ * @param val The value being set.
+ */
+MRB_API void mrb_ary_set(mrb_state *mrb, mrb_value ary, mrb_int n, mrb_value val);
+
+/*
+ * Replace the array with another array
+ *
+ * Equivalent to:
+ *
+ *      ary.replace(other)
+ *
+ * @param mrb The mruby state reference
+ * @param self The target array.
+ * @param other The array to replace it with.
+ */
+MRB_API void mrb_ary_replace(mrb_state *mrb, mrb_value self, mrb_value other);
+
+/*
+ * Unshift an element into the array
+ *
+ * Equivalent to:
+ *
+ *     ary.unshift(item)
+ *
+ * @param mrb The mruby state reference.
+ * @param self The target array.
+ * @param item The item to unshift.
+ */
+MRB_API mrb_value mrb_ary_unshift(mrb_state *mrb, mrb_value self, mrb_value item);
+
+/*
+ * Get nth element in the array
+ *
+ * Equivalent to:
+ *
+ *     ary[offset]
+ *
+ * @param ary The target array.
+ * @param offset The element position (negative counts from the tail).
+ */
+MRB_API mrb_value mrb_ary_entry(mrb_value ary, mrb_int offset);
+#define mrb_ary_ref(mrb, ary, n) mrb_ary_entry(ary, n)
+
+/*
+ * Replace subsequence of an array.
+ *
+ * Equivalent to:
+ *
+ *      ary[head, len] = rpl
+ *
+ * @param mrb The mruby state reference.
+ * @param self The array from which the value will be partiality replaced.
+ * @param head Beginning position of a replacement subsequence.
+ * @param len Length of a replacement subsequence.
+ * @param rpl The array of replacement elements.
+ *            It is possible to pass `mrb_undef_value()` instead of an empty array.
+ * @return The receiver array.
+ */
+MRB_API mrb_value mrb_ary_splice(mrb_state *mrb, mrb_value self, mrb_int head, mrb_int len, mrb_value rpl);
+
+/*
+ * Shifts the first element from the array.
+ *
+ * Equivalent to:
+ *
+ *      ary.shift
+ *
+ * @param mrb The mruby state reference.
+ * @param self The array from which the value will be shifted.
+ * @return The shifted value.
+ */
+MRB_API mrb_value mrb_ary_shift(mrb_state *mrb, mrb_value self);
+
+/*
+ * Removes all elements from the array
+ *
+ * Equivalent to:
+ *
+ *      ary.clear
+ *
+ * @param mrb The mruby state reference.
+ * @param self The target array.
+ * @return self
+ */
+MRB_API mrb_value mrb_ary_clear(mrb_state *mrb, mrb_value self);
+
+/*
+ * Join the array elements together in a string
+ *
+ * Equivalent to:
+ *
+ *      ary.join(sep="")
+ *
+ * @param mrb The mruby state reference.
+ * @param ary The target array
+ * @param sep The separator, can be NULL
+ */
+MRB_API mrb_value mrb_ary_join(mrb_state *mrb, mrb_value ary, mrb_value sep);
+
+/*
+ * Update the capacity of the array
+ *
+ * @param mrb The mruby state reference.
+ * @param ary The target array.
+ * @param new_len The new capacity of the array
+ */
+MRB_API mrb_value mrb_ary_resize(mrb_state *mrb, mrb_value ary, mrb_int new_len);
+
+
+MRB_END_DECL
+
+#endif  /* MRUBY_ARRAY_H */

deps/mruby/include/mruby/boxing_nan.h

@@ -0,0 +1,169 @@
+/**
+** @file mruby/boxing_nan.h - nan boxing mrb_value definition
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_BOXING_NAN_H
+#define MRUBY_BOXING_NAN_H
+
+#ifdef MRB_USE_FLOAT32
+# error ---->> MRB_NAN_BOXING and MRB_USE_FLOAT32 conflict <<----
+#endif
+
+#ifdef MRB_NO_FLOAT
+# error ---->> MRB_NAN_BOXING and MRB_NO_FLOAT conflict <<----
+#endif
+
+#define MRB_FIXNUM_MIN INT32_MIN
+#define MRB_FIXNUM_MAX INT32_MAX
+
+enum mrb_nanbox_tt_inline {
+  MRB_NANBOX_TT_OBJECT = 0,
+  MRB_NANBOX_TT_INTEGER = 1,
+  MRB_NANBOX_TT_MISC = 2,
+  MRB_NANBOX_TT_CPTR = 3,
+};
+
+/* value representation by nan-boxing:
+ *   float : SEEEEEEE EEEEFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF
+ *   +/-inf: S1111111 11110000 00000000 00000000 00000000 00000000 00000000 00000000
+ *   nan   : 01111111 11111000 00000000 00000000 00000000 00000000 00000000 00000000
+ *   int   : 01111111 11111001 00000000 00000000 IIIIIIII IIIIIIII IIIIIIII IIIIIIII
+ *   sym   : 01111111 11111110 00000000 00TTTTTT SSSSSSSS SSSSSSSS SSSSSSSS SSSSSSSS
+ *   misc  : 01111111 11111110 00000000 00TTTTTT 00000000 00000000 00000000 0000MMMM
+ *   object: 01111111 11111100 PPPPPPPP PPPPPPPP PPPPPPPP PPPPPPPP PPPPPPPP PPPPPP00
+ *   cptr  : 01111111 11111111 PPPPPPPP PPPPPPPP PPPPPPPP PPPPPPPP PPPPPPPP PPPPPPPP
+ * Stored as O = R + 0x8004000000000000, retrieved as R = O - 0x8004000000000000.
+ * This makes pointers have all zeros in the top 32 bits.
+ */
+typedef struct mrb_value {
+  uint64_t u;
+} mrb_value;
+
+static inline mrb_float
+mrb_nan_boxing_value_float(mrb_value v)
+{
+  union {
+    mrb_float f;
+    uint64_t u;
+  } x;
+  x.u = v.u - 0x8004000000000000;
+  return x.f;
+}
+
+#define SET_FLOAT_VALUE(mrb,r,f) do { \
+  union { \
+    mrb_float f; \
+    uint64_t u; \
+  } float_uint_union; \
+  if ((f) != (f)) { /* NaN */ \
+    float_uint_union.u = 0x7ff8000000000000UL; \
+  } \
+  else { \
+    float_uint_union.f = (f); \
+  } \
+  r.u = float_uint_union.u + 0x8004000000000000; \
+} while(0)
+
+#define mrb_float_p(o) (((uint64_t)((o).u)&0xfffc000000000000) != 0)
+
+struct RInteger {
+  MRB_OBJECT_HEADER;
+  mrb_int i;
+};
+
+#define mrb_nb_tt(o) ((enum mrb_nanbox_tt_inline)((uint32_t)((o).u>>48)&3))
+
+MRB_INLINE enum mrb_vtype
+mrb_type(mrb_value o)
+{
+  if (mrb_float_p(o)) return MRB_TT_FLOAT;
+
+  int64_t u = o.u;
+  switch (mrb_nb_tt(o)) {
+  case MRB_NANBOX_TT_OBJECT: {
+    if (u == 0) return MRB_TT_FALSE;
+    return ((struct RBasic*)(uintptr_t)u)->tt;
+  }
+  case MRB_NANBOX_TT_INTEGER:
+    return MRB_TT_INTEGER;
+  case MRB_NANBOX_TT_MISC:
+    return (enum mrb_vtype)((uint32_t)(o.u >> 32) & 0x1f);
+  case MRB_NANBOX_TT_CPTR:
+    return MRB_TT_CPTR;
+  default:
+    /* never happen */
+    return MRB_TT_FLOAT;
+  }
+}
+
+MRB_INLINE enum mrb_vtype
+mrb_unboxed_type(mrb_value o)
+{
+  if (!mrb_float_p(o) && mrb_nb_tt(o) == MRB_NANBOX_TT_OBJECT && o.u != 0) {
+    return ((struct RBasic*)(uintptr_t)o.u)->tt;
+  } else {
+    return MRB_TT_FALSE;
+  }
+}
+
+#define NANBOX_SET_MISC_VALUE(r,t,i) NANBOX_SET_VALUE(r, MRB_NANBOX_TT_MISC, ((uint64_t)(t)<<32) | (i))
+
+#define mrb_float(o) mrb_nan_boxing_value_float(o)
+#ifdef MRB_INT64
+/*
+#ifdef MRB_32BIT
+#define mrb_fixnum(o)  ((mrb_int)((intptr_t)0xffffffffffff&((o).u))|(((o).u & 0x800000000000)?0xffff000000000000:0))
+#else
+#define mrb_fixnum(o)  ((mrb_int)(int32_t)((o).u))
+#endif
+*/
+
+#define mrb_fixnum(o)  ((mrb_int)(int32_t)((o).u))
+
+static inline mrb_int
+mrb_nan_boxing_value_int(mrb_value v)
+{
+  uint64_t u = v.u;
+  if (mrb_nb_tt(v)==MRB_NANBOX_TT_OBJECT) {
+    struct RInteger *p = (struct RInteger*)(uintptr_t)u;
+    return p->i;
+  }
+  return mrb_fixnum(v);
+}
+#define mrb_integer(o) mrb_nan_boxing_value_int(o)
+#else
+#define mrb_fixnum(o)  ((mrb_int)(((uintptr_t)0xffffffff)&((o).u)))
+#define mrb_integer(o) mrb_fixnum(o)
+#endif
+#define mrb_symbol(o)  ((mrb_sym)((uintptr_t)0xffffffff)&((o).u))
+#define mrb_ptr(o)     ((void*)(uintptr_t)(o).u)
+#define mrb_cptr(o)    ((void*)(uintptr_t)(0xffffffffffffULL&(o).u))
+
+#define NANBOX_SET_VALUE(o, tt, v) do { \
+  (o).u = ((uint64_t)(tt)<<48) | ((uint64_t)(v)); \
+} while (0)
+
+#define SET_NIL_VALUE(r) ((r).u = 0)
+#define SET_FALSE_VALUE(r) NANBOX_SET_MISC_VALUE(r, MRB_TT_FALSE, 1)
+#define SET_TRUE_VALUE(r) NANBOX_SET_MISC_VALUE(r, MRB_TT_TRUE, 1)
+#define SET_BOOL_VALUE(r,b) NANBOX_SET_MISC_VALUE(r, (b) ? MRB_TT_TRUE : MRB_TT_FALSE, 1)
+#ifdef MRB_INT64
+MRB_API mrb_value mrb_boxing_int_value(struct mrb_state*, mrb_int);
+#define SET_INT_VALUE(mrb, r, n) ((r) = mrb_boxing_int_value(mrb, n))
+#else
+#define SET_INT_VALUE(mrb, r, n) SET_FIXNUM_VALUE(r, n)
+#endif
+#define SET_FIXNUM_VALUE(r,n) NANBOX_SET_VALUE(r, MRB_NANBOX_TT_INTEGER, (uint32_t)(n))
+#define SET_SYM_VALUE(r,v) NANBOX_SET_MISC_VALUE(r, MRB_TT_SYMBOL, (uint32_t)(v))
+#define SET_OBJ_VALUE(r,v) do {(r).u = (uint64_t)(uintptr_t)(v);} while (0)
+#define SET_CPTR_VALUE(mrb,r,v) NANBOX_SET_VALUE(r, MRB_NANBOX_TT_CPTR, (uint64_t)(uintptr_t)(v) & 0x0000ffffffffffffULL)
+#define SET_UNDEF_VALUE(r) NANBOX_SET_MISC_VALUE(r, MRB_TT_UNDEF, 4)
+
+#define mrb_immediate_p(o) ((mrb_float_p(o) || mrb_nb_tt(o) != MRB_NANBOX_TT_OBJECT) || (o).u == 0)
+#define mrb_nil_p(o)  ((o).u == 0)
+#define mrb_false_p(o) (mrb_type(o) == MRB_TT_FALSE || (o).u == 0)
+#define mrb_fixnum_p(o) (!mrb_float_p(o) && mrb_nb_tt(o)==MRB_NANBOX_TT_INTEGER)
+
+#endif  /* MRUBY_BOXING_NAN_H */

deps/mruby/include/mruby/boxing_no.h

@@ -0,0 +1,59 @@
+/**
+** @file mruby/boxing_no.h - unboxed mrb_value definition
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_BOXING_NO_H
+#define MRUBY_BOXING_NO_H
+
+#define MRB_FIXNUM_SHIFT 0
+#define MRB_SYMBOL_SHIFT 0
+#define MRB_FIXNUM_MIN MRB_INT_MIN
+#define MRB_FIXNUM_MAX MRB_INT_MAX
+
+union mrb_value_union {
+#ifndef MRB_NO_FLOAT
+  mrb_float f;
+#endif
+  void *p;
+  mrb_int i;
+  mrb_sym sym;
+};
+
+typedef struct mrb_value {
+  union mrb_value_union value;
+  enum mrb_vtype tt;
+} mrb_value;
+
+#define mrb_ptr(o)          (o).value.p
+#define mrb_cptr(o)         mrb_ptr(o)
+#ifndef MRB_NO_FLOAT
+#define mrb_float(o)        (o).value.f
+#endif
+#define mrb_fixnum(o)       (o).value.i
+#define mrb_integer(o)      mrb_fixnum(o)
+#define mrb_symbol(o)       (o).value.sym
+#define mrb_type(o)         (o).tt
+#define mrb_unboxed_type(o) (o).tt
+
+#define BOXNO_SET_VALUE(o, ttt, attr, v) do {\
+  (o).tt = ttt;\
+  (o).attr = v;\
+} while (0)
+
+#define SET_NIL_VALUE(r) BOXNO_SET_VALUE(r, MRB_TT_FALSE, value.i, 0)
+#define SET_FALSE_VALUE(r) BOXNO_SET_VALUE(r, MRB_TT_FALSE, value.i, 1)
+#define SET_TRUE_VALUE(r) BOXNO_SET_VALUE(r, MRB_TT_TRUE, value.i, 1)
+#define SET_BOOL_VALUE(r,b) BOXNO_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, value.i, 1)
+#define SET_INT_VALUE(mrb,r,n) BOXNO_SET_VALUE(r, MRB_TT_INTEGER, value.i, (n))
+#define SET_FIXNUM_VALUE(r,n) BOXNO_SET_VALUE(r, MRB_TT_INTEGER, value.i, (n))
+#ifndef MRB_NO_FLOAT
+#define SET_FLOAT_VALUE(mrb,r,v) BOXNO_SET_VALUE(r, MRB_TT_FLOAT, value.f, (v))
+#endif
+#define SET_SYM_VALUE(r,v) BOXNO_SET_VALUE(r, MRB_TT_SYMBOL, value.sym, (v))
+#define SET_OBJ_VALUE(r,v) BOXNO_SET_VALUE(r, (((struct RObject*)(v))->tt), value.p, (v))
+#define SET_CPTR_VALUE(mrb,r,v) BOXNO_SET_VALUE(r, MRB_TT_CPTR, value.p, v)
+#define SET_UNDEF_VALUE(r) BOXNO_SET_VALUE(r, MRB_TT_UNDEF, value.i, 0)
+
+#endif  /* MRUBY_BOXING_NO_H */

deps/mruby/include/mruby/boxing_word.h

@@ -0,0 +1,244 @@
+/**
+** @file mruby/boxing_word.h - word boxing mrb_value definition
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_BOXING_WORD_H
+#define MRUBY_BOXING_WORD_H
+
+#if defined(MRB_32BIT) && !defined(MRB_USE_FLOAT32) && !defined(MRB_WORDBOX_NO_FLOAT_TRUNCATE)
+# define MRB_WORDBOX_NO_FLOAT_TRUNCATE
+#endif
+
+#if !defined(MRB_NO_FLOAT) && defined(MRB_WORDBOX_NO_FLOAT_TRUNCATE)
+struct RFloat {
+  MRB_OBJECT_HEADER;
+  mrb_float f;
+};
+#endif
+
+struct RInteger {
+  MRB_OBJECT_HEADER;
+  mrb_int i;
+};
+
+enum mrb_special_consts {
+  MRB_Qnil    =  0,
+  MRB_Qfalse  =  4,
+  MRB_Qtrue   = 12,
+  MRB_Qundef  = 20,
+};
+
+#if defined(MRB_64BIT) && defined(MRB_INT32)
+#define MRB_FIXNUM_SHIFT        0
+#else
+#define MRB_FIXNUM_SHIFT        WORDBOX_FIXNUM_SHIFT
+#endif
+#define MRB_SYMBOL_SHIFT        WORDBOX_SYMBOL_SHIFT
+
+#if defined(MRB_64BIT) && defined(MRB_INT64)
+# define MRB_FIXNUM_MIN (INT64_MIN>>MRB_FIXNUM_SHIFT)
+# define MRB_FIXNUM_MAX (INT64_MAX>>MRB_FIXNUM_SHIFT)
+#else
+# define MRB_FIXNUM_MIN (INT32_MIN>>MRB_FIXNUM_SHIFT)
+# define MRB_FIXNUM_MAX (INT32_MAX>>MRB_FIXNUM_SHIFT)
+#endif
+
+#define WORDBOX_FIXNUM_BIT_POS  1
+#define WORDBOX_FIXNUM_SHIFT    WORDBOX_FIXNUM_BIT_POS
+#define WORDBOX_FIXNUM_FLAG     (1 << (WORDBOX_FIXNUM_BIT_POS - 1))
+#define WORDBOX_FIXNUM_MASK     ((1 << WORDBOX_FIXNUM_BIT_POS) - 1)
+
+#if defined(MRB_WORDBOX_NO_FLOAT_TRUNCATE)
+/* floats are allocated in heaps */
+#define WORDBOX_SYMBOL_BIT_POS  2
+#define WORDBOX_SYMBOL_SHIFT    WORDBOX_SYMBOL_BIT_POS
+#define WORDBOX_SYMBOL_FLAG     (1 << (WORDBOX_SYMBOL_BIT_POS - 1))
+#define WORDBOX_SYMBOL_MASK     ((1 << WORDBOX_SYMBOL_BIT_POS) - 1)
+#else
+#define WORDBOX_FLOAT_FLAG      2
+#define WORDBOX_FLOAT_MASK      3
+#if defined(MRB_64BIT)
+#define WORDBOX_SYMBOL_SHIFT    32
+#else  /* MRB_32BIT */
+#define WORDBOX_SYMBOL_SHIFT    5
+#endif
+#define WORDBOX_SYMBOL_FLAG     0x1c
+#define WORDBOX_SYMBOL_MASK     0x1f
+#endif
+
+#define WORDBOX_IMMEDIATE_MASK  0x07
+
+#define WORDBOX_SET_SHIFT_VALUE(o,n,v) \
+  ((o).w = (((uintptr_t)(v)) << WORDBOX_##n##_SHIFT) | WORDBOX_##n##_FLAG)
+#define WORDBOX_SHIFT_VALUE_P(o,n) \
+  (((o).w & WORDBOX_##n##_MASK) == WORDBOX_##n##_FLAG)
+#define WORDBOX_OBJ_TYPE_P(o,n) \
+  (!mrb_immediate_p(o) && mrb_val_union(o).bp->tt == MRB_TT_##n)
+
+/*
+ * mrb_value representation:
+ *
+ * 64-bit word with inline float:
+ *   nil   : ...0000 0000 (all bits are 0)
+ *   false : ...0000 0100 (mrb_fixnum(v) != 0)
+ *   true  : ...0000 1100
+ *   undef : ...0001 0100
+ *   symbol: ...0001 1100 (use only upper 32-bit as symbol value with MRB_64BIT)
+ *   fixnum: ...IIII III1
+ *   float : ...FFFF FF10 (51 bit significands; require MRB_64BIT)
+ *   object: ...PPPP P000
+ *
+ * 32-bit word with inline float:
+ *   nil   : ...0000 0000 (all bits are 0)
+ *   false : ...0000 0100 (mrb_fixnum(v) != 0)
+ *   true  : ...0000 1100
+ *   undef : ...0001 0100
+ *   symbol: ...SSS1 0100 (symbol occupies 20bits)
+ *   fixnum: ...IIII III1
+ *   float : ...FFFF FF10 (22 bit significands; require MRB_64BIT)
+ *   object: ...PPPP P000
+ *
+ * and word boxing without inline float (MRB_WORDBOX_NO_FLOAT_TRUNCATE):
+ *   nil   : ...0000 0000 (all bits are 0)
+ *   false : ...0000 0100 (mrb_fixnum(v) != 0)
+ *   true  : ...0000 1100
+ *   undef : ...0001 0100
+ *   fixnum: ...IIII III1
+ *   symbol: ...SSSS SS10
+ *   object: ...PPPP P000 (any bits are 1)
+ */
+typedef struct mrb_value {
+  uintptr_t w;
+} mrb_value;
+
+union mrb_value_ {
+  void *p;
+  struct RBasic *bp;
+#ifndef MRB_NO_FLOAT
+#ifndef MRB_WORDBOX_NO_FLOAT_TRUNCATE
+  mrb_float f;
+#else
+  struct RFloat *fp;
+#endif
+#endif
+  struct RInteger *ip;
+  struct RCptr *vp;
+  uintptr_t w;
+  mrb_value value;
+};
+
+mrb_static_assert(sizeof(mrb_value) == sizeof(union mrb_value_));
+
+static inline union mrb_value_
+mrb_val_union(mrb_value v)
+{
+  union mrb_value_ x;
+  x.value = v;
+  return x;
+}
+
+MRB_API mrb_value mrb_word_boxing_cptr_value(struct mrb_state*, void*);
+#ifndef MRB_NO_FLOAT
+MRB_API mrb_value mrb_word_boxing_float_value(struct mrb_state*, mrb_float);
+#endif
+MRB_API mrb_value mrb_boxing_int_value(struct mrb_state*, mrb_int);
+
+#define mrb_immediate_p(o) ((o).w & WORDBOX_IMMEDIATE_MASK || (o).w == MRB_Qnil)
+
+#define mrb_ptr(o)     mrb_val_union(o).p
+#define mrb_cptr(o)    mrb_val_union(o).vp->p
+#ifndef MRB_NO_FLOAT
+#ifndef MRB_WORDBOX_NO_FLOAT_TRUNCATE
+MRB_API mrb_float mrb_word_boxing_value_float(mrb_value v);
+#define mrb_float(o) mrb_word_boxing_value_float(o)
+#else
+#define mrb_float(o) mrb_val_union(o).fp->f
+#endif
+#endif
+#define mrb_fixnum(o)  (mrb_int)(((intptr_t)(o).w) >> WORDBOX_FIXNUM_SHIFT)
+MRB_INLINE mrb_int
+mrb_integer_func(mrb_value o) {
+  if (mrb_immediate_p(o)) return mrb_fixnum(o);
+  return mrb_val_union(o).ip->i;
+}
+#define mrb_integer(o) mrb_integer_func(o)
+#define mrb_symbol(o)  (mrb_sym)(((o).w) >> WORDBOX_SYMBOL_SHIFT)
+#define mrb_bool(o)    (((o).w & ~(uintptr_t)MRB_Qfalse) != 0)
+
+#define mrb_fixnum_p(o) WORDBOX_SHIFT_VALUE_P(o, FIXNUM)
+#define mrb_integer_p(o) (WORDBOX_SHIFT_VALUE_P(o, FIXNUM)||WORDBOX_OBJ_TYPE_P(o, INTEGER))
+#define mrb_symbol_p(o) WORDBOX_SHIFT_VALUE_P(o, SYMBOL)
+#define mrb_undef_p(o) ((o).w == MRB_Qundef)
+#define mrb_nil_p(o)  ((o).w == MRB_Qnil)
+#define mrb_false_p(o) ((o).w == MRB_Qfalse)
+#define mrb_true_p(o)  ((o).w == MRB_Qtrue)
+#ifndef MRB_NO_FLOAT
+#ifndef MRB_WORDBOX_NO_FLOAT_TRUNCATE
+#define mrb_float_p(o) WORDBOX_SHIFT_VALUE_P(o, FLOAT)
+#else
+#define mrb_float_p(o) WORDBOX_OBJ_TYPE_P(o, FLOAT)
+#endif
+#else
+#define mrb_float_p(o) FALSE
+#endif
+#define mrb_array_p(o) WORDBOX_OBJ_TYPE_P(o, ARRAY)
+#define mrb_string_p(o) WORDBOX_OBJ_TYPE_P(o, STRING)
+#define mrb_hash_p(o) WORDBOX_OBJ_TYPE_P(o, HASH)
+#define mrb_cptr_p(o) WORDBOX_OBJ_TYPE_P(o, CPTR)
+#define mrb_exception_p(o) WORDBOX_OBJ_TYPE_P(o, EXCEPTION)
+#define mrb_free_p(o) WORDBOX_OBJ_TYPE_P(o, FREE)
+#define mrb_object_p(o) WORDBOX_OBJ_TYPE_P(o, OBJECT)
+#define mrb_class_p(o) WORDBOX_OBJ_TYPE_P(o, CLASS)
+#define mrb_module_p(o) WORDBOX_OBJ_TYPE_P(o, MODULE)
+#define mrb_iclass_p(o) WORDBOX_OBJ_TYPE_P(o, ICLASS)
+#define mrb_sclass_p(o) WORDBOX_OBJ_TYPE_P(o, SCLASS)
+#define mrb_proc_p(o) WORDBOX_OBJ_TYPE_P(o, PROC)
+#define mrb_range_p(o) WORDBOX_OBJ_TYPE_P(o, RANGE)
+#define mrb_env_p(o) WORDBOX_OBJ_TYPE_P(o, ENV)
+#define mrb_data_p(o) WORDBOX_OBJ_TYPE_P(o, DATA)
+#define mrb_fiber_p(o) WORDBOX_OBJ_TYPE_P(o, FIBER)
+#define mrb_istruct_p(o) WORDBOX_OBJ_TYPE_P(o, ISTRUCT)
+#define mrb_break_p(o) WORDBOX_OBJ_TYPE_P(o, BREAK)
+
+#ifndef MRB_NO_FLOAT
+#define SET_FLOAT_VALUE(mrb,r,v) ((r) = mrb_word_boxing_float_value(mrb, v))
+#endif
+#define SET_CPTR_VALUE(mrb,r,v) ((r) = mrb_word_boxing_cptr_value(mrb, v))
+#define SET_UNDEF_VALUE(r) ((r).w = MRB_Qundef)
+#define SET_NIL_VALUE(r) ((r).w = MRB_Qnil)
+#define SET_FALSE_VALUE(r) ((r).w = MRB_Qfalse)
+#define SET_TRUE_VALUE(r) ((r).w = MRB_Qtrue)
+#define SET_BOOL_VALUE(r,b) ((b) ? SET_TRUE_VALUE(r) : SET_FALSE_VALUE(r))
+#define SET_INT_VALUE(mrb,r,n) ((r) = mrb_boxing_int_value(mrb, n))
+#define SET_FIXNUM_VALUE(r,n) WORDBOX_SET_SHIFT_VALUE(r, FIXNUM, n)
+#define SET_SYM_VALUE(r,n) WORDBOX_SET_SHIFT_VALUE(r, SYMBOL, n)
+#define SET_OBJ_VALUE(r,v) ((r).w = (uintptr_t)(v))
+
+MRB_INLINE enum mrb_vtype
+mrb_type(mrb_value o)
+{
+  return !mrb_bool(o)    ? MRB_TT_FALSE :
+         mrb_true_p(o)   ? MRB_TT_TRUE :
+         mrb_fixnum_p(o) ? MRB_TT_INTEGER :
+         mrb_symbol_p(o) ? MRB_TT_SYMBOL :
+         mrb_undef_p(o)  ? MRB_TT_UNDEF :
+         mrb_float_p(o)  ? MRB_TT_FLOAT :
+         mrb_val_union(o).bp->tt;
+}
+
+MRB_INLINE enum mrb_vtype
+mrb_unboxed_type(mrb_value o)
+{
+  if (mrb_nil_p(o)) {
+    return MRB_TT_FALSE;
+  } else if ((o.w & WORDBOX_IMMEDIATE_MASK) == 0) {
+    return mrb_val_union(o).bp->tt;
+  } else {
+    return MRB_TT_FALSE;
+  }
+}
+
+
+#endif  /* MRUBY_BOXING_WORD_H */

deps/mruby/include/mruby/class.h

@@ -0,0 +1,104 @@
+/**
+** @file mruby/class.h - Class class
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_CLASS_H
+#define MRUBY_CLASS_H
+
+#include "common.h"
+
+/**
+ * Class class
+ */
+MRB_BEGIN_DECL
+
+struct RClass {
+  MRB_OBJECT_HEADER;
+  struct iv_tbl *iv;
+  struct mt_tbl *mt;
+  struct RClass *super;
+};
+
+#define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
+
+MRB_INLINE struct RClass*
+mrb_class(mrb_state *mrb, mrb_value v)
+{
+  if (!mrb_immediate_p(v)) {
+    return mrb_obj_ptr(v)->c;
+  }
+
+  switch (mrb_type(v)) {
+  case MRB_TT_FALSE:
+    if (mrb_fixnum(v))
+      return mrb->false_class;
+    return mrb->nil_class;
+  case MRB_TT_TRUE:
+    return mrb->true_class;
+  case MRB_TT_SYMBOL:
+    return mrb->symbol_class;
+  case MRB_TT_INTEGER:
+    return mrb->integer_class;
+#ifndef MRB_NO_FLOAT
+  case MRB_TT_FLOAT:
+    return mrb->float_class;
+#endif
+  case MRB_TT_CPTR:
+    return mrb->object_class;
+  default:
+    return NULL;
+  }
+}
+
+/* flags:
+   20:   frozen
+   19:   is_prepended
+   18:   is_origin
+   17:   is_inherited (used by method cache)
+   7-16: unused
+   6:    prohibit Class#allocate
+   0-5:  instance type
+*/
+#define MRB_FL_CLASS_IS_PREPENDED (1 << 19)
+#define MRB_FL_CLASS_IS_ORIGIN (1 << 18)
+#define MRB_CLASS_ORIGIN(c) do {\
+  if ((c)->flags & MRB_FL_CLASS_IS_PREPENDED) {\
+    (c) = (c)->super;\
+    while (!((c)->flags & MRB_FL_CLASS_IS_ORIGIN)) {\
+      (c) = (c)->super;\
+    }\
+  }\
+} while (0)
+#define MRB_FL_CLASS_IS_INHERITED (1 << 17)
+#define MRB_INSTANCE_TT_MASK (0x1F)
+#define MRB_SET_INSTANCE_TT(c, tt) ((c)->flags = (((c)->flags & ~MRB_INSTANCE_TT_MASK) | (char)(tt)))
+#define MRB_INSTANCE_TT(c) (enum mrb_vtype)((c)->flags & MRB_INSTANCE_TT_MASK)
+#define MRB_FL_UNDEF_ALLOCATE (1 << 6)
+#define MRB_UNDEF_ALLOCATOR(c) (mrb_assert((c)->tt == MRB_TT_CLASS), (c)->flags |= MRB_FL_UNDEF_ALLOCATE)
+#define MRB_UNDEF_ALLOCATOR_P(c) ((c)->flags & MRB_FL_UNDEF_ALLOCATE)
+#define MRB_DEFINE_ALLOCATOR(c) ((c)->flags &= ~MRB_FL_UNDEF_ALLOCATE)
+
+MRB_API void mrb_define_method_raw(mrb_state*, struct RClass*, mrb_sym, mrb_method_t);
+MRB_API void mrb_alias_method(mrb_state*, struct RClass *c, mrb_sym a, mrb_sym b);
+MRB_API void mrb_remove_method(mrb_state *mrb, struct RClass *c, mrb_sym sym);
+
+MRB_API mrb_method_t mrb_method_search_vm(mrb_state*, struct RClass**, mrb_sym);
+MRB_API mrb_method_t mrb_method_search(mrb_state*, struct RClass*, mrb_sym);
+
+MRB_API struct RClass* mrb_class_real(struct RClass* cl);
+
+#ifndef MRB_NO_METHOD_CACHE
+void mrb_mc_clear_by_class(mrb_state *mrb, struct RClass* c);
+#else
+#define mrb_mc_clear_by_class(mrb,c)
+#endif
+
+/* return non zero to break the loop */
+typedef int (mrb_mt_foreach_func)(mrb_state*,mrb_sym,mrb_method_t,void*);
+MRB_API void mrb_mt_foreach(mrb_state*, struct RClass*, mrb_mt_foreach_func*, void*);
+
+MRB_END_DECL
+
+#endif  /* MRUBY_CLASS_H */

deps/mruby/include/mruby/common.h

@@ -0,0 +1,118 @@
+/**
+** @file common.h - mruby common platform definition"
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_COMMON_H
+#define MRUBY_COMMON_H
+
+#ifdef __APPLE__
+  #ifndef __TARGETCONDITIONALS__
+  #include "TargetConditionals.h"
+  #endif
+#endif
+
+#ifdef __cplusplus
+#ifdef MRB_USE_CXX_ABI
+#define MRB_BEGIN_DECL
+#define MRB_END_DECL
+#else
+# define MRB_BEGIN_DECL extern "C" {
+# define MRB_END_DECL }
+#endif
+#else
+/** Start declarations in C mode */
+# define MRB_BEGIN_DECL
+/** End declarations in C mode */
+# define MRB_END_DECL
+#endif
+
+#include <sys/types.h>
+#if defined _MSC_VER
+#include <BaseTsd.h>
+typedef SSIZE_T ssize_t;
+#endif
+
+/**
+ * Shared compiler macros
+ */
+MRB_BEGIN_DECL
+
+/** Declare a function that never returns. */
+#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 201112L
+# define mrb_noreturn _Noreturn
+#elif defined __GNUC__ && !defined __STRICT_ANSI__
+# define mrb_noreturn __attribute__((noreturn))
+#elif defined _MSC_VER
+# define mrb_noreturn __declspec(noreturn)
+#else
+# define mrb_noreturn
+#endif
+
+/** Mark a function as deprecated. */
+#if defined __GNUC__ && !defined __STRICT_ANSI__
+# define mrb_deprecated __attribute__((deprecated))
+#elif defined _MSC_VER
+# define mrb_deprecated __declspec(deprecated)
+#else
+# define mrb_deprecated
+#endif
+
+/** Declare a type or object as an alignment requirement. */
+#ifndef mrb_alignas
+# if defined(__cplusplus) && __cplusplus >= 201103L
+#  // https://en.cppreference.com/w/cpp/language/alignas
+#  define mrb_alignas(n) alignas(n)
+# elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
+#  // https://en.cppreference.com/w/c/language/_Alignas
+#  define mrb_alignas(n) _Alignas(n)
+# elif defined(_MSC_VER) || defined(__INTEL_COMPILER)
+#  // https://learn.microsoft.com/en-us/cpp/cpp/align-cpp?view=msvc-170
+#  define mrb_alignas(n) __declspec(align(n))
+# elif defined(__GNUC__) || defined(__clang__)
+#  // https://gcc.gnu.org/onlinedocs/gcc/Common-Type-Attributes.html#index-aligned-type-attribute
+#  define mrb_alignas(n) __attribute__((aligned(n)))
+# else
+#  // `mrb_alignas` defined as dummy. If necessary, send issues to https://github.com/mruby/mruby .
+#  define mrb_alignas(n)
+# endif
+#endif
+
+/** Declare a function as always inlined. */
+#if defined _MSC_VER && _MSC_VER < 1900
+# ifndef __cplusplus
+#  define inline __inline
+# endif
+#endif
+#define MRB_INLINE static inline
+
+/** Declare a public mruby API function. */
+#ifndef MRB_API
+#if defined(MRB_BUILD_AS_DLL)
+#if defined(MRB_CORE) || defined(MRB_LIB)
+# define MRB_API __declspec(dllexport)
+#else
+# define MRB_API __declspec(dllimport)
+#endif
+#else
+# define MRB_API extern
+#endif
+#endif
+
+/** Declare mingw versions */
+#if defined(__MINGW32__) || defined(__MINGW64__)
+# include <_mingw.h>
+# if defined(__MINGW64_VERSION_MAJOR)
+#  define MRB_MINGW64_VERSION  (__MINGW64_VERSION_MAJOR * 1000 + __MINGW64_VERSION_MINOR)
+# elif defined(__MINGW32_MAJOR_VERSION)
+#  define MRB_MINGW32_VERSION  (__MINGW32_MAJOR_VERSION * 1000 + __MINGW32_MINOR_VERSION)
+# endif
+# if defined(__MINGW32__) && !defined(__MINGW64__)
+#   define MRB_MINGW32_LEGACY
+# endif
+#endif
+
+MRB_END_DECL
+
+#endif  /* MRUBY_COMMON_H */

deps/mruby/include/mruby/compile.h

@@ -0,0 +1,223 @@
+/**
+** @file mruby/compile.h - mruby parser
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_COMPILE_H
+#define MRUBY_COMPILE_H
+
+#include "common.h"
+#include "mruby/mempool.h"
+
+/**
+ * mruby Compiler
+ */
+MRB_BEGIN_DECL
+
+#include <mruby.h>
+
+struct mrb_parser_state;
+/* load context */
+typedef struct mrb_ccontext {
+  mrb_sym *syms;
+  int slen;
+  char *filename;
+  uint16_t lineno;
+  int (*partial_hook)(struct mrb_parser_state*);
+  void *partial_data;
+  struct RClass *target_class;
+  mrb_bool capture_errors:1;
+  mrb_bool dump_result:1;
+  mrb_bool no_exec:1;
+  mrb_bool keep_lv:1;
+  mrb_bool no_optimize:1;
+  mrb_bool no_ext_ops:1;
+  const struct RProc *upper;
+
+  size_t parser_nerr;
+} 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_state *mrb, mrb_ccontext *c, int (*partial_hook)(struct mrb_parser_state*), void*data);
+MRB_API void mrb_ccontext_cleanup_local_variables(mrb_state *mrb, 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;
+
+/* lexer states */
+enum mrb_lex_state_enum {
+  EXPR_BEG,                   /* ignore newline, +/- is a sign. */
+  EXPR_END,                   /* newline significant, +/- is an operator. */
+  EXPR_ENDARG,                /* ditto, and unbound braces. */
+  EXPR_ENDFN,                 /* ditto, and unbound braces. */
+  EXPR_ARG,                   /* newline significant, +/- is an operator. */
+  EXPR_CMDARG,                /* newline significant, +/- is an operator. */
+  EXPR_MID,                   /* newline significant, +/- is a sign. */
+  EXPR_FNAME,                 /* ignore newline, no reserved words. */
+  EXPR_DOT,                   /* right after '.' or '::', no reserved words. */
+  EXPR_CLASS,                 /* immediate after 'class', no here document. */
+  EXPR_VALUE,                 /* alike EXPR_BEG but label is disallowed. */
+  EXPR_MAX_STATE
+};
+
+/* saved error message */
+struct mrb_parser_message {
+  uint16_t lineno;
+  int column;
+  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;
+  mrb_bool line_head:1;
+  size_t indent;
+  mrb_ast_node *indented;
+  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_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
+  mrb_ccontext *cxt;
+  mrb_sym filename_sym;
+  uint16_t lineno;
+  int column;
+
+  enum mrb_lex_state_enum lstate;
+  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;
+  mrb_bool cmd_start:1;
+  mrb_ast_node *locals;
+
+  mrb_ast_node *pb;
+  char *tokbuf;
+  char buf[MRB_PARSER_TOKBUF_SIZE];
+  int tidx;
+  int tsiz;
+
+  mrb_ast_node *heredocs_from_nextline;
+  mrb_ast_node *parsing_heredoc;
+
+  void *ylval;
+
+  size_t nerr;
+  size_t nwarn;
+  mrb_ast_node *tree;
+
+  mrb_bool no_optimize:1;
+  mrb_bool capture_errors:1;
+  mrb_bool no_ext_ops:1;
+  const struct RProc *upper;
+  struct mrb_parser_message error_buffer[10];
+  struct mrb_parser_message warn_buffer[10];
+
+  mrb_sym* filename_table;
+  uint16_t filename_table_length;
+  uint16_t current_filename_index;
+
+  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*,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*,mrb_ccontext*);
+#endif
+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, 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*, 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, 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
+
+#endif /* MRUBY_COMPILE_H */

deps/mruby/include/mruby/data.h

@@ -0,0 +1,76 @@
+/**
+** @file mruby/data.h - Data class
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_DATA_H
+#define MRUBY_DATA_H
+
+#include "common.h"
+
+/**
+ * Custom C wrapped data.
+ *
+ * Defining Ruby wrappers around native objects.
+ */
+MRB_BEGIN_DECL
+
+/**
+ * Custom data type description.
+ */
+typedef struct mrb_data_type {
+  /** data type name */
+  const char *struct_name;
+
+  /** data type release function pointer */
+  void (*dfree)(mrb_state *mrb, void*);
+} mrb_data_type;
+
+struct RData {
+  MRB_OBJECT_HEADER;
+  struct iv_tbl *iv;
+  const mrb_data_type *type;
+  void *data;
+};
+
+MRB_API struct RData *mrb_data_object_alloc(mrb_state *mrb, struct RClass* klass, void *datap, const mrb_data_type *type);
+
+#define Data_Wrap_Struct(mrb,klass,type,ptr)\
+  mrb_data_object_alloc(mrb,klass,ptr,type)
+
+#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));                     \
+  { static const strct zero = { 0 }; *(sval) = zero; };\
+  (data_obj)->data = (sval);\
+} while (0)
+
+#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*);
+MRB_API void *mrb_data_get_ptr(mrb_state *mrb, mrb_value, const mrb_data_type*);
+#define DATA_GET_PTR(mrb,obj,dtype,type) (type*)mrb_data_get_ptr(mrb,obj,dtype)
+MRB_API void *mrb_data_check_get_ptr(mrb_state *mrb, mrb_value, const mrb_data_type*);
+#define DATA_CHECK_GET_PTR(mrb,obj,dtype,type) (type*)mrb_data_check_get_ptr(mrb,obj,dtype)
+
+/* obsolete functions and macros */
+#define mrb_data_check_and_get(mrb,obj,dtype) mrb_data_get_ptr(mrb,obj,dtype)
+#define mrb_get_datatype(mrb,val,type) mrb_data_get_ptr(mrb, val, type)
+#define mrb_check_datatype(mrb,val,type) mrb_data_get_ptr(mrb, val, type)
+#define Data_Get_Struct(mrb,obj,type,sval) do {\
+  *(void**)&sval = mrb_data_get_ptr(mrb, obj, type); \
+} while (0)
+
+MRB_INLINE void
+mrb_data_init(mrb_value v, void *ptr, const mrb_data_type *type)
+{
+  mrb_assert(mrb_data_p(v));
+  DATA_PTR(v) = ptr;
+  DATA_TYPE(v) = type;
+}
+
+MRB_END_DECL
+
+#endif /* MRUBY_DATA_H */

deps/mruby/include/mruby/debug.h

@@ -0,0 +1,75 @@
+/**
+** @file mruby/debug.h - mruby debug info
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_DEBUG_H
+#define MRUBY_DEBUG_H
+
+#include "common.h"
+
+/**
+ * mruby Debugging.
+ */
+MRB_BEGIN_DECL
+
+typedef enum mrb_debug_line_type {
+  mrb_debug_line_ary = 0,
+  mrb_debug_line_flat_map,
+  mrb_debug_line_packed_map
+} mrb_debug_line_type;
+
+typedef struct mrb_irep_debug_info_line {
+  uint32_t start_pos;
+  uint16_t line;
+} mrb_irep_debug_info_line;
+
+typedef struct mrb_irep_debug_info_file {
+  uint32_t start_pos;
+  mrb_sym filename_sym;
+  uint32_t line_entry_count;
+  mrb_debug_line_type line_type;
+  union {
+    const char *s;
+    void *ptr;
+    const uint16_t *ary;
+    const mrb_irep_debug_info_line *flat_map;
+    const uint8_t *packed_map;
+  } lines;
+} mrb_irep_debug_info_file;
+
+typedef struct mrb_irep_debug_info {
+  uint32_t pc_count;
+  uint16_t flen;
+  mrb_irep_debug_info_file **files;
+} mrb_irep_debug_info;
+
+/*
+ * 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);
+
+/*
+ * get line from irep's debug info and program counter
+ * @return returns -1 if not found
+ */
+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,
+    const char *filename, uint16_t *lines,
+    uint32_t start_pos, uint32_t end_pos);
+MRB_API void mrb_debug_info_free(mrb_state *mrb, mrb_irep_debug_info *d);
+
+MRB_END_DECL
+
+#endif /* MRUBY_DEBUG_H */

deps/mruby/include/mruby/dump.h

@@ -0,0 +1,159 @@
+/**
+** @file mruby/dump.h - mruby binary dumper (mrbc binary format)
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_DUMP_H
+#define MRUBY_DUMP_H
+
+#include <mruby.h>
+#include <mruby/irep.h>
+#include "common.h"
+
+/**
+ * Dumping compiled mruby script.
+ */
+MRB_BEGIN_DECL
+
+/* flags for mrb_dump_irep{,_binary,_cfunc,_cstruct} */
+#define MRB_DUMP_DEBUG_INFO 1
+#define MRB_DUMP_STATIC 2
+#define MRB_DUMP_NO_LVAR 4
+
+#ifndef MRB_NO_STDIO
+MRB_API mrb_value mrb_load_irep_file(mrb_state*,FILE*);
+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);
+
+/* dump/load error code
+ *
+ * NOTE: MRB_DUMP_GENERAL_FAILURE is caused by
+ * unspecified issues like malloc failed.
+ */
+#define MRB_DUMP_OK                     0
+#define MRB_DUMP_GENERAL_FAILURE      (-1)
+#define MRB_DUMP_WRITE_FAULT          (-2)
+#define MRB_DUMP_READ_FAULT           (-3)
+#define MRB_DUMP_INVALID_FILE_HEADER  (-4)
+#define MRB_DUMP_INVALID_IREP         (-5)
+#define MRB_DUMP_INVALID_ARGUMENT     (-6)
+
+/* null symbol length */
+#define MRB_DUMP_NULL_SYM_LEN         0xFFFF
+
+/* Rite Binary File header */
+#define RITE_BINARY_IDENT              "RITE"
+/* 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_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_BINARY_EOF                "END\0"
+#define RITE_SECTION_IREP_IDENT        "IREP"
+#define RITE_SECTION_DEBUG_IDENT       "DBG\0"
+#define RITE_SECTION_LV_IDENT          "LVAR"
+
+#define MRB_DUMP_DEFAULT_STR_LEN      128
+#define MRB_DUMP_ALIGNMENT            sizeof(uint32_t)
+
+/* binary header */
+struct rite_binary_header {
+  uint8_t binary_ident[4];    /* Binary Identifier */
+  uint8_t major_version[2];   /* Binary Format Major Version */
+  uint8_t minor_version[2];   /* Binary Format Minor Version */
+  uint8_t binary_size[4];     /* Binary Size */
+  uint8_t compiler_name[4];   /* Compiler name */
+  uint8_t compiler_version[4];
+};
+
+/* section header */
+#define RITE_SECTION_HEADER \
+  uint8_t section_ident[4]; \
+  uint8_t section_size[4]
+
+struct rite_section_header {
+  RITE_SECTION_HEADER;
+};
+
+struct rite_section_irep_header {
+  RITE_SECTION_HEADER;
+
+  uint8_t rite_version[4];    /* Rite Instruction Specification Version */
+};
+
+struct rite_section_debug_header {
+  RITE_SECTION_HEADER;
+};
+
+struct rite_section_lv_header {
+  RITE_SECTION_HEADER;
+};
+
+#define RITE_LV_NULL_MARK              UINT16_MAX
+
+struct rite_binary_footer {
+  RITE_SECTION_HEADER;
+};
+
+static inline size_t
+uint8_to_bin(uint8_t s, uint8_t *bin)
+{
+  *bin = s;
+  return sizeof(uint8_t);
+}
+
+static inline size_t
+uint16_to_bin(uint16_t s, uint8_t *bin)
+{
+  *bin++ = (s >> 8) & 0xff;
+  *bin   = s & 0xff;
+  return sizeof(uint16_t);
+}
+
+static inline size_t
+uint32_to_bin(uint32_t l, uint8_t *bin)
+{
+  *bin++ = (l >> 24) & 0xff;
+  *bin++ = (l >> 16) & 0xff;
+  *bin++ = (l >> 8) & 0xff;
+  *bin   = l & 0xff;
+  return sizeof(uint32_t);
+}
+
+static inline uint32_t
+bin_to_uint32(const uint8_t *bin)
+{
+  return (uint32_t)bin[0] << 24 |
+         (uint32_t)bin[1] << 16 |
+         (uint32_t)bin[2] << 8  |
+         (uint32_t)bin[3];
+}
+
+static inline uint16_t
+bin_to_uint16(const uint8_t *bin)
+{
+  return (uint16_t)bin[0] << 8 |
+         (uint16_t)bin[1];
+}
+
+static inline uint8_t
+bin_to_uint8(const uint8_t *bin)
+{
+  return (uint8_t)bin[0];
+}
+
+MRB_END_DECL
+
+#endif  /* MRUBY_DUMP_H */

deps/mruby/include/mruby/endian.h

@@ -0,0 +1,44 @@
+/**
+** @file mruby/endian.h - detect endian-ness
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_ENDIAN_H
+#define MRUBY_ENDIAN_H
+
+#include <limits.h>
+
+MRB_BEGIN_DECL
+
+#if !defined(BYTE_ORDER) && defined(__BYTE_ORDER__)
+# define BYTE_ORDER __BYTE_ORDER__
+#endif
+#if !defined(BIG_ENDIAN) && defined(__ORDER_BIG_ENDIAN__)
+# define BIG_ENDIAN __ORDER_BIG_ENDIAN__
+#endif
+#if !defined(LITTLE_ENDIAN) && defined(__ORDER_LITTLE_ENDIAN__)
+# define LITTLE_ENDIAN __ORDER_LITTLE_ENDIAN__
+#endif
+
+#ifdef BYTE_ORDER
+# if BYTE_ORDER == BIG_ENDIAN
+#  define littleendian 0
+# elif BYTE_ORDER == LITTLE_ENDIAN
+#  define littleendian 1
+# endif
+#endif
+#ifndef littleendian
+/* can't distinguish endian in compile time */
+static inline int
+check_little_endian(void)
+{
+  unsigned int n = 1;
+  return (*(unsigned char*)&n == 1);
+}
+#  define littleendian check_little_endian()
+#endif
+
+MRB_END_DECL
+
+#endif  /* MRUBY_ENDIAN_H */

deps/mruby/include/mruby/error.h

@@ -0,0 +1,132 @@
+/**
+** @file mruby/error.h - Exception class
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_ERROR_H
+#define MRUBY_ERROR_H
+
+#include "common.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_64BIT) || defined(MRB_USE_FLOAT32) || defined(MRB_NAN_BOXING) || defined(MRB_WORD_BOXING)
+#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
+  union mrb_value_union value;
+#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;
+  val.value = brk->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)
+{
+  brk->value = 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);
+
+MRB_END_DECL
+
+#endif  /* MRUBY_ERROR_H */

deps/mruby/include/mruby/gc.h

@@ -0,0 +1,72 @@
+/**
+** @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
+
+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 RBasic *gray_list;        /* list of gray objects to be traversed incrementally */
+  struct RBasic *atomic_gray_list; /* list of objects to be traversed atomically */
+  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);
+
+#define MRB_GC_RED 7
+
+MRB_END_DECL
+
+#endif  /* MRUBY_GC_H */

deps/mruby/include/mruby/gems/mruby-io/include/mruby/ext/io.h

@@ -0,0 +1,76 @@
+/*
+** io.h - IO class
+*/
+
+#ifndef MRUBY_IO_H
+#define MRUBY_IO_H
+
+#include <mruby.h>
+
+#ifdef MRB_NO_STDIO
+# error IO and File conflicts 'MRB_NO_STDIO' in your build configuration
+#endif
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#if defined(MRB_NO_IO_PREAD_PWRITE) || defined(MRB_WITHOUT_IO_PREAD_PWRITE)
+# undef MRB_USE_IO_PREAD_PWRITE
+#elif !defined(MRB_USE_IO_PREAD_PWRITE)
+# if defined(__unix__) || defined(__MACH__) || defined(MRB_WITH_IO_PREAD_PWRITE)
+#  define MRB_USE_IO_PREAD_PWRITE
+# endif
+#endif
+
+#define MRB_IO_BUF_SIZE 4096
+
+struct mrb_io_buf {
+  short start;
+  short len;
+  char mem[MRB_IO_BUF_SIZE];
+};
+
+struct mrb_io {
+  unsigned int readable:1,
+               writable:1,
+               eof:1,
+               sync:1,
+               is_socket:1,
+               close_fd:1,
+               close_fd2:1;
+  int fd;   /* file descriptor, or -1 */
+  int fd2;  /* file descriptor to write if it's different from fd, or -1 */
+  int pid;  /* child's pid (for pipes)  */
+  struct mrb_io_buf *buf;
+};
+
+#define MRB_O_RDONLY            0x0000
+#define MRB_O_WRONLY            0x0001
+#define MRB_O_RDWR              0x0002
+#define MRB_O_ACCMODE           (MRB_O_RDONLY | MRB_O_WRONLY | MRB_O_RDWR)
+#define MRB_O_NONBLOCK          0x0004
+#define MRB_O_APPEND            0x0008
+#define MRB_O_SYNC              0x0010
+#define MRB_O_NOFOLLOW          0x0020
+#define MRB_O_CREAT             0x0040
+#define MRB_O_TRUNC             0x0080
+#define MRB_O_EXCL              0x0100
+#define MRB_O_NOCTTY            0x0200
+#define MRB_O_DIRECT            0x0400
+#define MRB_O_BINARY            0x0800
+#define MRB_O_SHARE_DELETE      0x1000
+#define MRB_O_TMPFILE           0x2000
+#define MRB_O_NOATIME           0x4000
+#define MRB_O_DSYNC             0x00008000
+#define MRB_O_RSYNC             0x00010000
+
+#define E_IO_ERROR              mrb_exc_get_id(mrb, MRB_ERROR_SYM(IOError))
+#define E_EOF_ERROR             mrb_exc_get_id(mrb, MRB_ERROR_SYM(EOFError))
+
+int mrb_io_fileno(mrb_state *mrb, mrb_value io);
+
+#if defined(__cplusplus)
+} /* extern "C" { */
+#endif
+#endif /* MRUBY_IO_H */

deps/mruby/include/mruby/gems/mruby-time/include/mruby/time.h

@@ -0,0 +1,26 @@
+/*
+** mruby/time.h - Time class
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_TIME_H
+#define MRUBY_TIME_H
+
+#include <mruby/common.h>
+#include <time.h>
+
+MRB_BEGIN_DECL
+
+typedef enum mrb_timezone {
+  MRB_TIMEZONE_NONE   = 0,
+  MRB_TIMEZONE_UTC    = 1,
+  MRB_TIMEZONE_LOCAL  = 2,
+  MRB_TIMEZONE_LAST   = 3
+} mrb_timezone;
+
+MRB_API mrb_value mrb_time_at(mrb_state *mrb, time_t sec, time_t usec, mrb_timezone timezone);
+
+MRB_END_DECL
+
+#endif /* MRUBY_TIME_H */

deps/mruby/include/mruby/hash.h

@@ -0,0 +1,234 @@
+/**
+** @file mruby/hash.h - Hash class
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_HASH_H
+#define MRUBY_HASH_H
+
+#include "common.h"
+
+/**
+ * Hash class
+ */
+MRB_BEGIN_DECL
+
+/* offset of `iv` must be 3 words */
+struct RHash {
+  MRB_OBJECT_HEADER;
+#ifdef MRB_64BIT
+  uint32_t size;
+  struct iv_tbl *iv;
+  uint32_t ea_capa;
+  uint32_t ea_n_used;
+#else
+  struct iv_tbl *iv;
+  uint32_t size;
+#endif
+  union {
+    struct hash_entry *ea;
+    struct hash_table *ht;
+  } hsh;
+};
+
+#define mrb_hash_ptr(v)    ((struct RHash*)(mrb_ptr(v)))
+#define mrb_hash_value(p)  mrb_obj_value((void*)(p))
+
+MRB_API mrb_value mrb_hash_new_capa(mrb_state *mrb, mrb_int capa);
+
+/*
+ * Initializes a new hash.
+ *
+ * Equivalent to:
+ *
+ *      Hash.new
+ *
+ * @param mrb The mruby state reference.
+ * @return The initialized hash.
+ */
+MRB_API mrb_value mrb_hash_new(mrb_state *mrb);
+
+/*
+ * Sets a keys and values to hashes.
+ *
+ * Equivalent to:
+ *
+ *      hash[key] = val
+ *
+ * @param mrb The mruby state reference.
+ * @param hash The target hash.
+ * @param key The key to set.
+ * @param val The value to set.
+ * @return The value.
+ */
+MRB_API void mrb_hash_set(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value val);
+
+/*
+ * Gets a value from a key. If the key is not found, the default of the
+ * hash is used.
+ *
+ * Equivalent to:
+ *
+ *     hash[key]
+ *
+ * @param mrb The mruby state reference.
+ * @param hash The target hash.
+ * @param key The key to get.
+ * @return The found value.
+ */
+MRB_API mrb_value mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key);
+
+/*
+ * Gets a value from a key. If the key is not found, the default parameter is
+ * used.
+ *
+ * Equivalent to:
+ *
+ *     hash.key?(key) ? hash[key] : def
+ *
+ * @param mrb The mruby state reference.
+ * @param hash The target hash.
+ * @param key The key to get.
+ * @param def The default value.
+ * @return The found value.
+ */
+MRB_API mrb_value mrb_hash_fetch(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value def);
+
+/*
+ * Deletes hash key and value pair.
+ *
+ * Equivalent to:
+ *
+ *     hash.delete(key)
+ *
+ * @param mrb The mruby state reference.
+ * @param hash The target hash.
+ * @param key The key to delete.
+ * @return The deleted value. This value is not protected from GC. Use `mrb_gc_protect()` if necessary.
+ */
+MRB_API mrb_value mrb_hash_delete_key(mrb_state *mrb, mrb_value hash, mrb_value key);
+
+/*
+ * Gets an array of keys.
+ *
+ * Equivalent to:
+ *
+ *     hash.keys
+ *
+ * @param mrb The mruby state reference.
+ * @param hash The target hash.
+ * @return An array with the keys of the hash.
+ */
+MRB_API mrb_value mrb_hash_keys(mrb_state *mrb, mrb_value hash);
+/*
+ * Check if the hash has the key.
+ *
+ * Equivalent to:
+ *
+ *     hash.key?(key)
+ *
+ * @param mrb The mruby state reference.
+ * @param hash The target hash.
+ * @param key The key to check existence.
+ * @return True if the hash has the key
+ */
+MRB_API mrb_bool mrb_hash_key_p(mrb_state *mrb, mrb_value hash, mrb_value key);
+
+/*
+ * Check if the hash is empty
+ *
+ * Equivalent to:
+ *
+ *     hash.empty?
+ *
+ * @param mrb The mruby state reference.
+ * @param self The target hash.
+ * @return True if the hash is empty, false otherwise.
+ */
+MRB_API mrb_bool mrb_hash_empty_p(mrb_state *mrb, mrb_value self);
+
+/*
+ * Gets an array of values.
+ *
+ * Equivalent to:
+ *
+ *     hash.values
+ *
+ * @param mrb The mruby state reference.
+ * @param hash The target hash.
+ * @return An array with the values of the hash.
+ */
+MRB_API mrb_value mrb_hash_values(mrb_state *mrb, mrb_value hash);
+
+/*
+ * Clears the hash.
+ *
+ * Equivalent to:
+ *
+ *     hash.clear
+ *
+ * @param mrb The mruby state reference.
+ * @param hash The target hash.
+ * @return The hash
+ */
+MRB_API mrb_value mrb_hash_clear(mrb_state *mrb, mrb_value hash);
+
+/*
+ * Get hash size.
+ *
+ * Equivalent to:
+ *
+ *      hash.size
+ *
+ * @param mrb The mruby state reference.
+ * @param hash The target hash.
+ * @return The hash size.
+ */
+MRB_API mrb_int mrb_hash_size(mrb_state *mrb, mrb_value hash);
+
+/*
+ * Copies the hash. This function does NOT copy the instance variables
+ * (except for the default value). Use mrb_obj_dup() to copy the instance
+ * variables as well.
+ *
+ * @param mrb The mruby state reference.
+ * @param hash The target hash.
+ * @return The copy of the hash
+ */
+MRB_API mrb_value mrb_hash_dup(mrb_state *mrb, mrb_value hash);
+
+/*
+ * Merges two hashes. The first hash will be modified by the
+ * second hash.
+ *
+ * @param mrb The mruby state reference.
+ * @param hash1 The target hash.
+ * @param hash2 Updating hash
+ */
+MRB_API void mrb_hash_merge(mrb_state *mrb, mrb_value hash1, mrb_value hash2);
+
+#define RHASH(hash) ((struct RHash*)(mrb_ptr(hash)))
+
+#define MRB_HASH_IB_BIT_BIT         5
+#define MRB_HASH_AR_EA_CAPA_BIT     5
+#define MRB_HASH_IB_BIT_SHIFT       0
+#define MRB_HASH_AR_EA_CAPA_SHIFT   0
+#define MRB_HASH_AR_EA_N_USED_SHIFT MRB_HASH_AR_EA_CAPA_BIT
+#define MRB_HASH_SIZE_FLAGS_SHIFT   (MRB_HASH_AR_EA_CAPA_BIT * 2)
+#define MRB_HASH_IB_BIT_MASK        ((1 << MRB_HASH_IB_BIT_BIT) - 1)
+#define MRB_HASH_AR_EA_CAPA_MASK    ((1 << MRB_HASH_AR_EA_CAPA_BIT) - 1)
+#define MRB_HASH_AR_EA_N_USED_MASK  (MRB_HASH_AR_EA_CAPA_MASK << MRB_HASH_AR_EA_N_USED_SHIFT)
+#define MRB_HASH_DEFAULT            (1 << (MRB_HASH_SIZE_FLAGS_SHIFT + 0))
+#define MRB_HASH_PROC_DEFAULT       (1 << (MRB_HASH_SIZE_FLAGS_SHIFT + 1))
+#define MRB_HASH_HT                 (1 << (MRB_HASH_SIZE_FLAGS_SHIFT + 2))
+#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)
+
+/* 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);
+
+MRB_END_DECL
+
+#endif  /* MRUBY_HASH_H */

deps/mruby/include/mruby/internal.h

@@ -0,0 +1,252 @@
+/**
+** @file mruby/internal.h - Functions only called from within the library
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_INTERNAL_H
+#define MRUBY_INTERNAL_H
+
+#ifdef MRUBY_ARRAY_H
+void mrb_ary_decref(mrb_state*, mrb_shared_array*);
+mrb_value mrb_ary_subseq(mrb_state *mrb, mrb_value ary, mrb_int beg, mrb_int len);
+#endif
+
+mrb_bool mrb_inspect_recursive_p(mrb_state *mrb, mrb_value self);
+
+#ifdef MRUBY_CLASS_H
+struct RClass *mrb_vm_define_class(mrb_state*, mrb_value, mrb_value, mrb_sym);
+struct RClass *mrb_vm_define_module(mrb_state*, mrb_value, mrb_sym);
+mrb_value mrb_instance_new(mrb_state *mrb, mrb_value cv);
+void mrb_class_name_class(mrb_state*, struct RClass*, struct RClass*, mrb_sym);
+mrb_bool mrb_const_name_p(mrb_state*, const char*, mrb_int);
+mrb_value mrb_class_find_path(mrb_state*, struct RClass*);
+mrb_value mrb_mod_to_s(mrb_state *, mrb_value);
+void mrb_method_added(mrb_state *mrb, struct RClass *c, mrb_sym mid);
+mrb_noreturn void mrb_method_missing(mrb_state *mrb, mrb_sym name, mrb_value self, mrb_value args);
+mrb_method_t mrb_vm_find_method(mrb_state *mrb, struct RClass *c, struct RClass **cp, mrb_sym mid);
+mrb_value mrb_mod_const_missing(mrb_state *mrb, mrb_value mod);
+mrb_value mrb_const_missing(mrb_state *mrb, mrb_value mod, mrb_sym sym);
+size_t mrb_class_mt_memsize(mrb_state*, struct RClass*);
+#endif
+
+mrb_value mrb_obj_equal_m(mrb_state *mrb, mrb_value);
+
+/* debug */
+size_t mrb_packed_int_len(uint32_t num);
+size_t mrb_packed_int_encode(uint32_t num, uint8_t *p);
+uint32_t mrb_packed_int_decode(const uint8_t *p, const uint8_t **newpos);
+
+/* dump */
+#ifdef MRUBY_IREP_H
+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_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);
+#endif
+#endif
+
+/* codedump */
+void mrb_codedump_all(mrb_state *mrb, struct RProc *proc);
+#ifndef MRB_NO_STDIO
+void mrb_codedump_all_file(mrb_state *mrb, struct RProc *proc, FILE *out);
+#endif
+
+/* error */
+mrb_value mrb_exc_inspect(mrb_state *mrb, mrb_value exc);
+mrb_value mrb_exc_backtrace(mrb_state *mrb, mrb_value exc);
+mrb_value mrb_get_backtrace(mrb_state *mrb);
+void mrb_exc_mesg_set(mrb_state *mrb, struct RException *exc, mrb_value mesg);
+mrb_value mrb_exc_mesg_get(mrb_state *mrb, struct RException *exc);
+mrb_value mrb_f_raise(mrb_state*, mrb_value);
+mrb_value mrb_make_exception(mrb_state *mrb, mrb_value exc, mrb_value mesg);
+
+struct RBacktrace {
+  MRB_OBJECT_HEADER;
+  size_t len;
+  struct mrb_backtrace_location *locations;
+};
+
+struct mrb_backtrace_location {
+  mrb_sym method_id;
+  int32_t idx;
+  const mrb_irep *irep;
+};
+
+/* gc */
+size_t mrb_gc_mark_mt(mrb_state*, struct RClass*);
+void mrb_gc_free_mt(mrb_state*, struct RClass*);
+
+/* hash */
+size_t mrb_hash_memsize(mrb_value obj);
+size_t mrb_gc_mark_hash(mrb_state*, struct RHash*);
+void mrb_gc_free_hash(mrb_state*, struct RHash*);
+mrb_value mrb_hash_first_key(mrb_state*, mrb_value);
+
+/* irep */
+struct mrb_insn_data mrb_decode_insn(const mrb_code *pc);
+#ifdef MRUBY_IREP_H
+void mrb_irep_free(mrb_state*, struct mrb_irep*);
+
+static inline const struct mrb_irep_catch_handler *
+mrb_irep_catch_handler_table(const struct mrb_irep *irep)
+{
+  if (irep->clen > 0) {
+    return (const struct mrb_irep_catch_handler*)(irep->iseq + irep->ilen);
+  }
+  else {
+    return (const struct mrb_irep_catch_handler*)NULL;
+  }
+}
+#endif
+
+/* numeric */
+mrb_value mrb_div_int_value(mrb_state *mrb, mrb_int x, mrb_int y);
+mrb_int mrb_div_int(mrb_int x, mrb_int y);
+mrb_value mrb_int_add(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_value mrb_int_sub(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_value mrb_int_mul(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_noreturn void mrb_int_zerodiv(mrb_state *mrb);
+mrb_noreturn void mrb_int_overflow(mrb_state *mrb, const char *reason);
+#ifndef MRB_NO_FLOAT
+void mrb_check_num_exact(mrb_state *mrb, mrb_float num);
+#endif
+
+#ifdef MRB_USE_COMPLEX
+mrb_value mrb_complex_new(mrb_state *mrb, mrb_float x, mrb_float y);
+mrb_value mrb_complex_add(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_value mrb_complex_sub(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_value mrb_complex_mul(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_value mrb_complex_div(mrb_state *mrb, mrb_value x, mrb_value y);
+void mrb_complex_copy(mrb_state *mrb, mrb_value x, mrb_value y);
+#endif
+#ifdef MRB_USE_RATIONAL
+mrb_value mrb_rational_new(mrb_state *mrb, mrb_int x, mrb_int y);
+mrb_value mrb_rational_add(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_value mrb_rational_sub(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_value mrb_rational_mul(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_value mrb_rational_div(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_value mrb_as_rational(mrb_state *mrb, mrb_value x);
+void mrb_rational_copy(mrb_state *mrb, mrb_value x, mrb_value y);
+int mrb_rational_mark(mrb_state *mrb, struct RBasic *rat);
+#endif
+
+#ifdef MRUBY_PROC_H
+struct RProc *mrb_closure_new(mrb_state*, const mrb_irep*);
+void mrb_proc_copy(mrb_state *mrb, struct RProc *a, const struct RProc *b);
+mrb_int mrb_proc_arity(const struct RProc *p);
+struct REnv *mrb_env_new(mrb_state *mrb, struct mrb_context *c, mrb_callinfo *ci, int nstacks, mrb_value *stack, struct RClass *tc);
+void mrb_proc_merge_lvar(mrb_state *mrb, mrb_irep *irep, struct REnv *env, int num, const mrb_sym *lv, const mrb_value *stack);
+mrb_value mrb_proc_local_variables(mrb_state *mrb, const struct RProc *proc);
+const struct RProc *mrb_proc_get_caller(mrb_state *mrb, struct REnv **env);
+mrb_value mrb_proc_get_self(mrb_state *mrb, const struct RProc *p, struct RClass **target_class_p);
+mrb_bool mrb_proc_eql(mrb_state *mrb, mrb_value self, mrb_value other);
+#endif
+
+/* range */
+#ifdef MRUBY_RANGE_H
+mrb_value mrb_get_values_at(mrb_state *mrb, mrb_value obj, mrb_int olen, mrb_int argc, const mrb_value *argv, mrb_value (*func)(mrb_state*, mrb_value, mrb_int));
+size_t mrb_gc_mark_range(mrb_state *mrb, struct RRange *r);
+#endif
+
+/* string */
+void mrb_gc_free_str(mrb_state*, struct RString*);
+uint32_t mrb_str_hash(mrb_state *mrb, mrb_value str);
+mrb_value mrb_str_dump(mrb_state *mrb, mrb_value str);
+mrb_value mrb_str_inspect(mrb_state *mrb, mrb_value str);
+mrb_bool mrb_str_beg_len(mrb_int str_len, mrb_int *begp, mrb_int *lenp);
+mrb_value mrb_str_byte_subseq(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len);
+mrb_value mrb_str_aref(mrb_state *mrb, mrb_value str, mrb_value idx, mrb_value len);
+uint32_t mrb_byte_hash(const uint8_t*, mrb_int);
+uint32_t mrb_byte_hash_step(const uint8_t*, mrb_int, uint32_t);
+
+#ifdef MRB_UTF8_STRING
+mrb_int mrb_utf8len(const char *str, const char *end);
+mrb_int mrb_utf8_strlen(const char *str, mrb_int byte_len);
+#endif
+
+/* variable */
+mrb_value mrb_vm_special_get(mrb_state*, mrb_sym);
+void mrb_vm_special_set(mrb_state*, mrb_sym, mrb_value);
+mrb_value mrb_vm_cv_get(mrb_state*, mrb_sym);
+void mrb_vm_cv_set(mrb_state*, mrb_sym, mrb_value);
+mrb_value mrb_vm_const_get(mrb_state*, mrb_sym);
+void mrb_vm_const_set(mrb_state*, mrb_sym, mrb_value);
+size_t mrb_obj_iv_tbl_memsize(mrb_value);
+mrb_value mrb_obj_iv_inspect(mrb_state*, struct RObject*);
+void mrb_obj_iv_set_force(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v);
+mrb_value mrb_mod_constants(mrb_state *mrb, mrb_value mod);
+mrb_value mrb_f_global_variables(mrb_state *mrb, mrb_value self);
+mrb_value mrb_obj_instance_variables(mrb_state*, mrb_value);
+mrb_value mrb_mod_class_variables(mrb_state*, mrb_value);
+mrb_value mrb_mod_cv_get(mrb_state *mrb, struct RClass * c, mrb_sym sym);
+mrb_bool mrb_mod_cv_defined(mrb_state *mrb, struct RClass * c, mrb_sym sym);
+mrb_bool mrb_ident_p(const char *s, mrb_int len);
+mrb_value mrb_exc_const_get(mrb_state *mrb, mrb_sym sym);
+
+/* GC functions */
+void mrb_gc_mark_gv(mrb_state*);
+void mrb_gc_free_gv(mrb_state*);
+size_t mrb_gc_mark_iv(mrb_state*, struct RObject*);
+void mrb_gc_free_iv(mrb_state*, struct RObject*);
+
+/* VM */
+mrb_int mrb_ci_bidx(mrb_callinfo *ci);
+mrb_int mrb_ci_nregs(mrb_callinfo *ci);
+mrb_value mrb_exec_irep(mrb_state *mrb, mrb_value self, const struct RProc *p);
+mrb_value mrb_obj_instance_eval(mrb_state*, mrb_value);
+mrb_value mrb_object_exec(mrb_state *mrb, mrb_value self, struct RClass *target_class);
+mrb_value mrb_mod_module_eval(mrb_state*, mrb_value);
+mrb_value mrb_f_send(mrb_state *mrb, mrb_value self);
+
+#ifdef MRB_USE_BIGINT
+mrb_value mrb_bint_new_int(mrb_state *mrb, mrb_int x);
+#ifdef MRB_INT64
+#define mrb_bint_new_int64(mrb,x) mrb_bint_new_int((mrb),(mrb_int)(x))
+#else
+mrb_value mrb_bint_new_int64(mrb_state *mrb, int64_t x);
+#endif
+mrb_value mrb_bint_new_uint64(mrb_state *mrb, uint64_t x);
+mrb_value mrb_bint_new_str(mrb_state *mrb, const char *x, mrb_int len, mrb_int base);
+mrb_value mrb_as_bint(mrb_state *mrb, mrb_value x);
+mrb_value mrb_bint_add(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_value mrb_bint_sub(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_value mrb_bint_add_n(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_value mrb_bint_sub_n(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_value mrb_bint_mul(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_value mrb_bint_div(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_value mrb_bint_divmod(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_value mrb_bint_add_ii(mrb_state *mrb, mrb_int x, mrb_int y);
+mrb_value mrb_bint_sub_ii(mrb_state *mrb, mrb_int x, mrb_int y);
+mrb_value mrb_bint_mul_ii(mrb_state *mrb, mrb_int x, mrb_int y);
+mrb_value mrb_bint_mod(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_value mrb_bint_rem(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_value mrb_bint_pow(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_value mrb_bint_powm(mrb_state *mrb, mrb_value x, mrb_value y, mrb_value z);
+mrb_value mrb_bint_and(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_value mrb_bint_or(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_value mrb_bint_neg(mrb_state *mrb, mrb_value x);
+mrb_value mrb_bint_xor(mrb_state *mrb, mrb_value x, mrb_value y);
+mrb_value mrb_bint_rev(mrb_state *mrb, mrb_value x);
+mrb_value mrb_bint_lshift(mrb_state *mrb, mrb_value x, mrb_int width);
+mrb_value mrb_bint_rshift(mrb_state *mrb, mrb_value x, mrb_int width);
+mrb_value mrb_bint_to_s(mrb_state *mrb, mrb_value x, mrb_int base);
+#ifndef MRB_NO_FLOAT
+mrb_value mrb_bint_new_float(mrb_state *mrb, mrb_float x);
+mrb_float mrb_bint_as_float(mrb_state *mrb, mrb_value x);
+#endif
+mrb_int mrb_bint_as_int(mrb_state *mrb, mrb_value x);
+#ifdef MRB_INT64
+#define mrb_bint_as_int64(mrb, x) mrb_bint_as_int((mrb), (x))
+#else
+int64_t mrb_bint_as_int64(mrb_state *mrb, mrb_value x);
+#endif
+uint64_t mrb_bint_as_uint64(mrb_state *mrb, mrb_value x);
+mrb_int mrb_bint_cmp(mrb_state *mrb, mrb_value x, mrb_value y);
+void mrb_gc_free_bint(mrb_state *mrb, struct RBasic *x);
+void mrb_bint_copy(mrb_state *mrb, mrb_value x, mrb_value y);
+size_t mrb_bint_memsize(mrb_value x);
+mrb_value mrb_bint_hash(mrb_state *mrb, mrb_value x);
+#endif
+
+#endif  /* MRUBY_INTERNAL_H */

deps/mruby/include/mruby/irep.h

@@ -0,0 +1,142 @@
+/**
+** @file mruby/irep.h - mrb_irep structure
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_IREP_H
+#define MRUBY_IREP_H
+
+#include "common.h"
+#include <mruby/compile.h>
+
+/**
+ * Compiled mruby scripts.
+ */
+MRB_BEGIN_DECL
+
+enum irep_pool_type {
+  IREP_TT_STR = 0,    /* string (need free) */
+  IREP_TT_SSTR = 2,   /* string (static) */
+  IREP_TT_INT32 = 1,  /* 32-bit integer */
+  IREP_TT_INT64 = 3,  /* 64-bit integer */
+  IREP_TT_BIGINT = 7, /* big integer (not yet supported) */
+  IREP_TT_FLOAT = 5,  /* float (double/float) */
+};
+
+#define IREP_TT_NFLAG 1 /* number (non string) flag */
+#define IREP_TT_SFLAG 2 /* static string flag */
+
+typedef struct mrb_irep_pool {
+  uint32_t tt; /* packed type and length (for string) */
+  union {
+    const char *str;
+    int32_t i32;
+    int64_t i64;
+#ifndef MRB_NO_FLOAT
+    mrb_float f;
+#endif
+  } u;
+} mrb_irep_pool;
+
+enum mrb_catch_type {
+  MRB_CATCH_RESCUE = 0,
+  MRB_CATCH_ENSURE = 1,
+};
+
+struct mrb_irep_catch_handler {
+  uint8_t type; /* enum mrb_catch_type */
+  uint8_t begin[4];  /* The starting address to match the handler. Includes this. */
+  uint8_t end[4];    /* The endpoint address that matches the handler. Not Includes this. */
+  uint8_t target[4]; /* The address to jump to if a match is made. */
+};
+
+/* Program data array struct */
+struct mrb_irep {
+  uint16_t nlocals; /* Number of local variables */
+  uint16_t nregs;   /* Number of register variables */
+  uint16_t clen;    /* Number of catch handlers */
+  uint8_t flags;
+
+  const mrb_code *iseq;
+  /*
+   * A catch handler table is placed after the iseq entity.
+   * The reason it doesn't add fields to the structure is to keep the mrb_irep
+   * structure from bloating. The catch handler table can be obtained with
+   * `mrb_irep_catch_handler_table(irep)`.
+   */
+  const mrb_irep_pool *pool;
+  const mrb_sym *syms;
+  const struct mrb_irep *const *reps;
+
+  const mrb_sym *lv;
+  /* debug info */
+  struct mrb_irep_debug_info *debug_info;
+
+  uint32_t ilen;
+  uint16_t plen, slen;
+  uint16_t rlen;
+  uint16_t refcnt;
+};
+
+#define MRB_ISEQ_NO_FREE 1
+#define MRB_IREP_NO_FREE 2
+#define MRB_IREP_STATIC (MRB_ISEQ_NO_FREE | MRB_IREP_NO_FREE)
+
+MRB_API mrb_irep *mrb_add_irep(mrb_state *mrb);
+
+/**
+ * load mruby bytecode 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_irep(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.
+ */
+
+/* @param [const uint8_t*] irep code, expected as a literal */
+MRB_API mrb_value mrb_load_irep(mrb_state *, const uint8_t *);
+
+/*
+ * @param [const void*] irep code
+ * @param [size_t] size of irep buffer.
+ */
+MRB_API mrb_value mrb_load_irep_buf(mrb_state *, const void *, size_t);
+
+/* @param [const uint8_t*] irep code, expected as a literal */
+MRB_API mrb_value mrb_load_irep_cxt(mrb_state *, const uint8_t *,
+                                    mrbc_context *);
+
+/*
+ * @param [const void*] irep code
+ * @param [size_t] size of irep buffer.
+ */
+MRB_API mrb_value mrb_load_irep_buf_cxt(mrb_state *, const void *, size_t,
+                                        mrbc_context *);
+
+struct mrb_insn_data {
+  uint8_t insn;
+  uint32_t a;
+  uint16_t b;
+  uint16_t c;
+  const mrb_code *addr;
+};
+
+#define mrb_irep_catch_handler_pack(n, v) uint32_to_bin(n, v)
+#define mrb_irep_catch_handler_unpack(v) bin_to_uint32(v)
+
+void mrb_irep_incref(mrb_state *, struct mrb_irep *);
+void mrb_irep_decref(mrb_state *, struct mrb_irep *);
+void mrb_irep_cutref(mrb_state *, struct mrb_irep *);
+
+MRB_END_DECL
+
+#endif /* MRUBY_IREP_H */

deps/mruby/include/mruby/istruct.h

@@ -0,0 +1,50 @@
+/**
+** @file mruby/istruct.h - Inline structures
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_ISTRUCT_H
+#define MRUBY_ISTRUCT_H
+
+#include "common.h"
+#include <string.h>
+
+/**
+ * Inline structures that fit in RVALUE
+ *
+ * They cannot have finalizer, and cannot have instance variables.
+ */
+MRB_BEGIN_DECL
+
+#define ISTRUCT_DATA_SIZE (sizeof(void*) * 3)
+
+struct RIStruct {
+  MRB_OBJECT_HEADER;
+  union {
+    intptr_t inline_alignment[3];
+    char inline_data[ISTRUCT_DATA_SIZE];
+  };
+};
+
+#define RISTRUCT(obj)         ((struct RIStruct*)(mrb_ptr(obj)))
+#define ISTRUCT_PTR(obj)      (RISTRUCT(obj)->inline_data)
+
+MRB_INLINE mrb_int mrb_istruct_size(void)
+{
+  return ISTRUCT_DATA_SIZE;
+}
+
+MRB_INLINE void* mrb_istruct_ptr(mrb_value object)
+{
+  return ISTRUCT_PTR(object);
+}
+
+MRB_INLINE void mrb_istruct_copy(mrb_value dest, mrb_value src)
+{
+  memcpy(ISTRUCT_PTR(dest), ISTRUCT_PTR(src), ISTRUCT_DATA_SIZE);
+}
+
+MRB_END_DECL
+
+#endif /* MRUBY_ISTRUCT_H */

deps/mruby/include/mruby/khash.h

@@ -0,0 +1,284 @@
+/**
+** @file mruby/khash.h - Hash for mruby
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_KHASH_H
+#define MRUBY_KHASH_H
+
+#include <string.h>
+
+#include <mruby.h>
+#include "common.h"
+
+/**
+ * khash definitions used in mruby's hash table.
+ */
+MRB_BEGIN_DECL
+
+typedef uint32_t khint_t;
+typedef khint_t khiter_t;
+
+#ifndef KHASH_DEFAULT_SIZE
+# define KHASH_DEFAULT_SIZE 32
+#endif
+#define KHASH_MIN_SIZE 8
+
+#define UPPER_BOUND(x) ((x)>>2|(x)>>1)
+
+/* extern uint8_t __m[]; */
+
+/* mask for flags */
+static const uint8_t __m_empty[]  = {0x02, 0x08, 0x20, 0x80};
+static const uint8_t __m_del[]    = {0x01, 0x04, 0x10, 0x40};
+static const uint8_t __m_either[] = {0x03, 0x0c, 0x30, 0xc0};
+
+
+#define __ac_isempty(ed_flag, i) (ed_flag[(i)/4]&__m_empty[(i)%4])
+#define __ac_isdel(ed_flag, i) (ed_flag[(i)/4]&__m_del[(i)%4])
+#define __ac_iseither(ed_flag, i) (ed_flag[(i)/4]&__m_either[(i)%4])
+#define khash_power2(v) do { \
+  v--;\
+  v |= v >> 1;\
+  v |= v >> 2;\
+  v |= v >> 4;\
+  v |= v >> 8;\
+  v |= v >> 16;\
+  v++;\
+} while (0)
+#define khash_mask(h) ((h)->n_buckets-1)
+#define khash_upper_bound(h) (UPPER_BOUND((h)->n_buckets))
+
+/* declare struct kh_xxx and kh_xxx_funcs
+
+   name: hash name
+   khkey_t: key data type
+   khval_t: value data type
+   kh_is_map: (0: hash set / 1: hash map)
+*/
+#define KHASH_DECLARE(name, khkey_t, khval_t, kh_is_map)                \
+  typedef struct kh_##name {                                            \
+    khint_t n_buckets;                                                  \
+    khint_t size;                                                       \
+    uint8_t *ed_flags;                                                  \
+    khkey_t *keys;                                                      \
+    khval_t *vals;                                                      \
+  } kh_##name##_t;                                                      \
+  void kh_alloc_##name(mrb_state *mrb, kh_##name##_t *h);               \
+  kh_##name##_t *kh_init_##name##_size(mrb_state *mrb, khint_t size);   \
+  kh_##name##_t *kh_init_##name(mrb_state *mrb);                        \
+  void kh_destroy_##name(mrb_state *mrb, kh_##name##_t *h);             \
+  void kh_clear_##name(mrb_state *mrb, kh_##name##_t *h);               \
+  khint_t kh_get_##name(mrb_state *mrb, kh_##name##_t *h, khkey_t key);           \
+  khint_t kh_put_##name(mrb_state *mrb, kh_##name##_t *h, khkey_t key, int *ret); \
+  void kh_resize_##name(mrb_state *mrb, kh_##name##_t *h, khint_t new_n_buckets); \
+  void kh_del_##name(mrb_state *mrb, kh_##name##_t *h, khint_t x);                \
+  kh_##name##_t *kh_copy_##name(mrb_state *mrb, kh_##name##_t *h);
+
+static inline void
+kh_fill_flags(uint8_t *p, uint8_t c, size_t len)
+{
+  while (len-- > 0) {
+    *p++ = c;
+  }
+}
+
+/* define kh_xxx_funcs
+
+   name: hash name
+   khkey_t: key data type
+   khval_t: value data type
+   kh_is_map: (0: hash set / 1: hash map)
+   __hash_func: hash function
+   __hash_equal: hash comparison function
+*/
+#define KHASH_DEFINE(name, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \
+  mrb_noreturn void mrb_raise_nomemory(mrb_state *mrb);                 \
+  int kh_alloc_simple_##name(mrb_state *mrb, kh_##name##_t *h)          \
+  {                                                                     \
+    khint_t sz = h->n_buckets;                                          \
+    size_t len = sizeof(khkey_t) + (kh_is_map ? sizeof(khval_t) : 0);   \
+    uint8_t *p = (uint8_t*)mrb_malloc_simple(mrb, sizeof(uint8_t)*sz/4+len*sz); \
+    if (!p) { return 1; }                                               \
+    h->size = 0;                                                        \
+    h->keys = (khkey_t*)p;                                              \
+    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);                             \
+    return 0;                                                           \
+  }                                                                     \
+  void kh_alloc_##name(mrb_state *mrb, kh_##name##_t *h)                \
+  {                                                                     \
+    if (kh_alloc_simple_##name(mrb, h)) {                               \
+      mrb_raise_nomemory(mrb);                                          \
+    }                                                                   \
+  }                                                                     \
+  kh_##name##_t *kh_init_##name##_size(mrb_state *mrb, khint_t size) {  \
+    kh_##name##_t *h = (kh_##name##_t*)mrb_calloc(mrb, 1, sizeof(kh_##name##_t)); \
+    if (size < KHASH_MIN_SIZE)                                          \
+      size = KHASH_MIN_SIZE;                                            \
+    khash_power2(size);                                                 \
+    h->n_buckets = size;                                                \
+    if (kh_alloc_simple_##name(mrb, h)) {                               \
+      mrb_free(mrb, h);                                                 \
+      mrb_raise_nomemory(mrb);                                          \
+    }                                                                   \
+    return h;                                                           \
+  }                                                                     \
+  kh_##name##_t *kh_init_##name(mrb_state *mrb) {                       \
+    return kh_init_##name##_size(mrb, KHASH_DEFAULT_SIZE);              \
+  }                                                                     \
+  void kh_destroy_##name(mrb_state *mrb, kh_##name##_t *h)              \
+  {                                                                     \
+    if (h) {                                                            \
+      mrb_free(mrb, h->keys);                                           \
+      mrb_free(mrb, h);                                                 \
+    }                                                                   \
+  }                                                                     \
+  void kh_clear_##name(mrb_state *mrb, kh_##name##_t *h)                \
+  {                                                                     \
+    (void)mrb;                                                          \
+    if (h && h->ed_flags) {                                             \
+      kh_fill_flags(h->ed_flags, 0xaa, h->n_buckets/4);                 \
+      h->size = 0;                                                      \
+    }                                                                   \
+  }                                                                     \
+  khint_t kh_get_##name(mrb_state *mrb, kh_##name##_t *h, khkey_t key)  \
+  {                                                                     \
+    khint_t k = __hash_func(mrb,key) & khash_mask(h), step = 0;         \
+    (void)mrb;                                                          \
+    while (!__ac_isempty(h->ed_flags, k)) {                             \
+      if (!__ac_isdel(h->ed_flags, k)) {                                \
+        if (__hash_equal(mrb,h->keys[k], key)) return k;                \
+      }                                                                 \
+      k = (k+(++step)) & khash_mask(h);                                 \
+    }                                                                   \
+    return kh_end(h);                                                   \
+  }                                                                     \
+  void kh_resize_##name(mrb_state *mrb, kh_##name##_t *h, khint_t new_n_buckets) \
+  {                                                                     \
+    if (new_n_buckets < KHASH_MIN_SIZE)                                 \
+      new_n_buckets = KHASH_MIN_SIZE;                                   \
+    khash_power2(new_n_buckets);                                        \
+    {                                                                   \
+      kh_##name##_t hh;                                                 \
+      uint8_t *old_ed_flags = h->ed_flags;                              \
+      khkey_t *old_keys = h->keys;                                      \
+      khval_t *old_vals = h->vals;                                      \
+      khint_t old_n_buckets = h->n_buckets;                             \
+      khint_t i;                                                        \
+      hh.n_buckets = new_n_buckets;                                     \
+      kh_alloc_##name(mrb, &hh);                                        \
+      /* relocate */                                                    \
+      for (i=0; i<old_n_buckets; i++) {                                 \
+        if (!__ac_iseither(old_ed_flags, i)) {                          \
+          khint_t k = kh_put_##name(mrb, &hh, old_keys[i], NULL);       \
+          if (kh_is_map) kh_value(&hh,k) = old_vals[i];                 \
+        }                                                               \
+      }                                                                 \
+      /* copy hh to h */                                                \
+      *h = hh;                                                          \
+      mrb_free(mrb, old_keys);                                          \
+    }                                                                   \
+  }                                                                     \
+  khint_t kh_put_##name(mrb_state *mrb, kh_##name##_t *h, khkey_t key, int *ret) \
+  {                                                                     \
+    khint_t k, del_k, step = 0;                                         \
+    if (h->size >= khash_upper_bound(h)) {                              \
+      kh_resize_##name(mrb, h, h->n_buckets*2);                         \
+    }                                                                   \
+    k = __hash_func(mrb,key) & khash_mask(h);                           \
+    del_k = kh_end(h);                                                  \
+    while (!__ac_isempty(h->ed_flags, k)) {                             \
+      if (!__ac_isdel(h->ed_flags, k)) {                                \
+        if (__hash_equal(mrb,h->keys[k], key)) {                        \
+          if (ret) *ret = 0;                                            \
+          return k;                                                     \
+        }                                                               \
+      }                                                                 \
+      else if (del_k == kh_end(h)) {                                    \
+        del_k = k;                                                      \
+      }                                                                 \
+      k = (k+(++step)) & khash_mask(h);                                 \
+    }                                                                   \
+    if (del_k != kh_end(h)) {                                           \
+      /* put at del */                                                  \
+      h->keys[del_k] = key;                                             \
+      h->ed_flags[del_k/4] &= ~__m_del[del_k%4];                        \
+      h->size++;                                                        \
+      if (ret) *ret = 2;                                                \
+      return del_k;                                                     \
+    }                                                                   \
+    else {                                                              \
+      /* put at empty */                                                \
+      h->keys[k] = key;                                                 \
+      h->ed_flags[k/4] &= ~__m_empty[k%4];                              \
+      h->size++;                                                        \
+      if (ret) *ret = 1;                                                \
+      return k;                                                         \
+    }                                                                   \
+  }                                                                     \
+  void kh_del_##name(mrb_state *mrb, kh_##name##_t *h, khint_t x)       \
+  {                                                                     \
+    (void)mrb;                                                          \
+    mrb_assert(x != h->n_buckets && !__ac_iseither(h->ed_flags, x));    \
+    h->ed_flags[x/4] |= __m_del[x%4];                                   \
+    h->size--;                                                          \
+  }                                                                     \
+  kh_##name##_t *kh_copy_##name(mrb_state *mrb, kh_##name##_t *h)       \
+  {                                                                     \
+    kh_##name##_t *h2;                                                  \
+    khiter_t k, k2;                                                     \
+                                                                        \
+    h2 = kh_init_##name(mrb);                                           \
+    for (k = kh_begin(h); k != kh_end(h); k++) {                        \
+      if (kh_exist(h, k)) {                                             \
+        k2 = kh_put_##name(mrb, h2, kh_key(h, k), NULL);                \
+        if (kh_is_map) kh_value(h2, k2) = kh_value(h, k);               \
+      }                                                                 \
+    }                                                                   \
+    return h2;                                                          \
+  }
+
+
+#define khash_t(name) kh_##name##_t
+
+#define kh_init_size(name,mrb,size) kh_init_##name##_size(mrb,size)
+#define kh_init(name,mrb) kh_init_##name(mrb)
+#define kh_destroy(name, mrb, h) kh_destroy_##name(mrb, h)
+#define kh_clear(name, mrb, h) kh_clear_##name(mrb, h)
+#define kh_resize(name, mrb, h, s) kh_resize_##name(mrb, h, s)
+#define kh_put(name, mrb, h, k) kh_put_##name(mrb, h, k, NULL)
+#define kh_put2(name, mrb, h, k, r) kh_put_##name(mrb, h, k, r)
+#define kh_get(name, mrb, h, k) kh_get_##name(mrb, h, k)
+#define kh_del(name, mrb, h, k) kh_del_##name(mrb, h, k)
+#define kh_copy(name, mrb, h) kh_copy_##name(mrb, h)
+
+#define kh_exist(h, x) (!__ac_iseither((h)->ed_flags, (x)))
+#define kh_key(h, x) ((h)->keys[x])
+#define kh_val(h, x) ((h)->vals[x])
+#define kh_value(h, x) ((h)->vals[x])
+#define kh_begin(h) (khint_t)(0)
+#define kh_end(h) ((h)->n_buckets)
+#define kh_size(h) ((h)->size)
+#define kh_n_buckets(h) ((h)->n_buckets)
+
+#define kh_int_hash_func(mrb,key) mrb_int_hash_func(mrb,key)
+#define kh_int_hash_equal(mrb,a, b) (a == b)
+#define kh_int64_hash_func(mrb,key) (khint_t)((key)>>33^(key)^(key)<<11)
+#define kh_int64_hash_equal(mrb,a, b) (a == b)
+static inline khint_t __ac_X31_hash_string(const char *s)
+{
+    khint_t h = *s;
+    if (h) for (++s; *s; ++s) h = (h << 5) - h + *s;
+    return h;
+}
+#define kh_str_hash_func(mrb,key) __ac_X31_hash_string(key)
+#define kh_str_hash_equal(mrb,a, b) (strcmp(a, b) == 0)
+
+typedef const char *kh_cstr_t;
+
+MRB_END_DECL
+
+#endif  /* MRUBY_KHASH_H */

deps/mruby/include/mruby/mempool.h

@@ -0,0 +1,13 @@
+/*
+** mempool.h - memory pool
+**
+** See Copyright Notice in mruby.h
+*/
+
+/* memory pool implementation */
+typedef struct mrb_mempool mrb_mempool;
+MRB_API struct mrb_mempool* mrb_mempool_open(mrb_state*);
+MRB_API void mrb_mempool_close(struct mrb_mempool*);
+MRB_API void* mrb_mempool_alloc(struct mrb_mempool*, size_t);
+MRB_API void* mrb_mempool_realloc(struct mrb_mempool*, void*, size_t oldlen, size_t newlen);
+MRB_API mrb_bool mrb_mempool_can_realloc(struct mrb_mempool*, void*, size_t);

deps/mruby/include/mruby/numeric.h

@@ -0,0 +1,174 @@
+/**
+** @file mruby/numeric.h - Numeric, Integer, Float class
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_NUMERIC_H
+#define MRUBY_NUMERIC_H
+
+#include "common.h"
+
+/**
+ * Numeric class and it's sub-classes.
+ *
+ * Integer and Float
+ */
+MRB_BEGIN_DECL
+
+#define TYPED_POSFIXABLE(f,t) ((f) <= (t)MRB_FIXNUM_MAX)
+#define TYPED_NEGFIXABLE(f,t) ((f) >= (t)MRB_FIXNUM_MIN)
+#define TYPED_FIXABLE(f,t) (TYPED_POSFIXABLE(f,t) && TYPED_NEGFIXABLE(f,t))
+#define POSFIXABLE(f) TYPED_POSFIXABLE(f,mrb_int)
+#define NEGFIXABLE(f) TYPED_NEGFIXABLE(f,mrb_int)
+#define FIXABLE(f) TYPED_FIXABLE(f,mrb_int)
+#ifndef MRB_NO_FLOAT
+#ifdef MRB_INT64
+#define FIXABLE_FLOAT(f) ((f)>=-9223372036854775808.0 && (f)<9223372036854775808.0)
+#else
+#define FIXABLE_FLOAT(f) TYPED_FIXABLE(f,mrb_float)
+#endif
+#endif
+
+/* utility functions */
+MRB_API mrb_value mrb_num_add(mrb_state *mrb, mrb_value x, mrb_value y);
+MRB_API mrb_value mrb_num_sub(mrb_state *mrb, mrb_value x, mrb_value y);
+MRB_API mrb_value mrb_num_mul(mrb_state *mrb, mrb_value x, mrb_value y);
+/* obsolete old names */
+#define mrb_num_plus(mrb, x, y) mrb_num_add(mrb, x, y)
+#define mrb_num_minus(mrb, x, y) mrb_num_sub(mrb, x, y)
+
+MRB_API mrb_value mrb_integer_to_str(mrb_state *mrb, mrb_value x, mrb_int base);
+MRB_API char *mrb_int_to_cstr(char *buf, size_t len, mrb_int n, mrb_int base);
+
+/* obsolete function(s); will be removed */
+#define mrb_fixnum_to_str(mrb, x, base) mrb_integer_to_str(mrb, x, base)
+
+#ifndef __has_builtin
+  #define __has_builtin(x) 0
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ >= 5) ||   \
+    (__has_builtin(__builtin_add_overflow) && \
+     __has_builtin(__builtin_sub_overflow) && \
+     __has_builtin(__builtin_mul_overflow))
+# define MRB_HAVE_TYPE_GENERIC_CHECKED_ARITHMETIC_BUILTINS
+#endif
+
+/*
+// Clang 3.8 and 3.9 have problem compiling mruby in 32-bit mode, when MRB_INT64 is set
+// because of missing __mulodi4 and similar functions in its runtime. We need to use custom
+// implementation for them.
+*/
+#ifdef MRB_HAVE_TYPE_GENERIC_CHECKED_ARITHMETIC_BUILTINS
+#if defined(__clang__) && (__clang_major__ == 3) && (__clang_minor__ >= 8) && \
+    defined(MRB_32BIT) && defined(MRB_INT64)
+#undef MRB_HAVE_TYPE_GENERIC_CHECKED_ARITHMETIC_BUILTINS
+#endif
+#endif
+
+#ifdef MRB_HAVE_TYPE_GENERIC_CHECKED_ARITHMETIC_BUILTINS
+
+static inline mrb_bool
+mrb_int_add_overflow(mrb_int augend, mrb_int addend, mrb_int *sum)
+{
+  return __builtin_add_overflow(augend, addend, sum);
+}
+
+static inline mrb_bool
+mrb_int_sub_overflow(mrb_int minuend, mrb_int subtrahend, mrb_int *difference)
+{
+  return __builtin_sub_overflow(minuend, subtrahend, difference);
+}
+
+static inline mrb_bool
+mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product)
+{
+  return __builtin_mul_overflow(multiplier, multiplicand, product);
+}
+
+#else
+
+#define MRB_INT_OVERFLOW_MASK ((mrb_uint)1 << (MRB_INT_BIT - 1))
+
+static inline mrb_bool
+mrb_int_add_overflow(mrb_int a, mrb_int b, mrb_int *c)
+{
+  mrb_uint x = (mrb_uint)a;
+  mrb_uint y = (mrb_uint)b;
+  mrb_uint z = (mrb_uint)(x + y);
+  *c = (mrb_int)z;
+  return !!(((x ^ z) & (y ^ z)) & MRB_INT_OVERFLOW_MASK);
+}
+
+static inline mrb_bool
+mrb_int_sub_overflow(mrb_int a, mrb_int b, mrb_int *c)
+{
+  mrb_uint x = (mrb_uint)a;
+  mrb_uint y = (mrb_uint)b;
+  mrb_uint z = (mrb_uint)(x - y);
+  *c = (mrb_int)z;
+  return !!(((x ^ z) & (~y ^ z)) & MRB_INT_OVERFLOW_MASK);
+}
+
+static inline mrb_bool
+mrb_int_mul_overflow(mrb_int a, mrb_int b, mrb_int *c)
+{
+#ifdef MRB_INT32
+  int64_t n = (int64_t)a * b;
+  *c = (mrb_int)n;
+  return n > MRB_INT_MAX || n < MRB_INT_MIN;
+#else /* MRB_INT64 */
+  if (a > 0 && b > 0 && a > MRB_INT_MAX / b) return TRUE;
+  if (a < 0 && b > 0 && a < MRB_INT_MIN / b) return TRUE;
+  if (a > 0 && b < 0 && b < MRB_INT_MIN / a) return TRUE;
+  if (a < 0 && b < 0 && (a <= MRB_INT_MIN || b <= MRB_INT_MIN || -a > MRB_INT_MAX / -b))
+    return TRUE;
+  *c = a * b;
+  return FALSE;
+#endif
+}
+
+#undef MRB_INT_OVERFLOW_MASK
+
+#endif
+
+#ifndef MRB_NO_FLOAT
+
+# define MRB_FLT_RADIX          FLT_RADIX
+
+# ifdef MRB_USE_FLOAT32
+#  define MRB_FLT_MANT_DIG      FLT_MANT_DIG
+#  define MRB_FLT_EPSILON       FLT_EPSILON
+#  define MRB_FLT_DIG           FLT_DIG
+#  define MRB_FLT_MIN_EXP       FLT_MIN_EXP
+#  define MRB_FLT_MIN           FLT_MIN
+#  define MRB_FLT_MIN_10_EXP    FLT_MIN_10_EXP
+#  define MRB_FLT_MAX_EXP       FLT_MAX_EXP
+#  define MRB_FLT_MAX           FLT_MAX
+#  define MRB_FLT_MAX_10_EXP    FLT_MAX_10_EXP
+
+# else /* not MRB_USE_FLOAT32 */
+#  define MRB_FLT_MANT_DIG      DBL_MANT_DIG
+#  define MRB_FLT_EPSILON       DBL_EPSILON
+#  define MRB_FLT_DIG           DBL_DIG
+#  define MRB_FLT_MIN_EXP       DBL_MIN_EXP
+#  define MRB_FLT_MIN           DBL_MIN
+#  define MRB_FLT_MIN_10_EXP    DBL_MIN_10_EXP
+#  define MRB_FLT_MAX_EXP       DBL_MAX_EXP
+#  define MRB_FLT_MAX           DBL_MAX
+#  define MRB_FLT_MAX_10_EXP    DBL_MAX_10_EXP
+# endif /* MRB_USE_FLOAT32 */
+
+MRB_API mrb_value mrb_float_to_integer(mrb_state *mrb, mrb_value val);
+
+/* internal functions */
+mrb_float mrb_div_float(mrb_float x, mrb_float y);
+mrb_value mrb_float_to_str(mrb_state *mrb, mrb_value x, const char *fmt);
+int mrb_format_float(mrb_float f, char *buf, size_t buf_size, char fmt, int prec, char sign);
+
+#endif /* MRB_NO_FLOAT */
+
+MRB_END_DECL
+
+#endif  /* MRUBY_NUMERIC_H */

deps/mruby/include/mruby/object.h

@@ -0,0 +1,45 @@
+/**
+** @file mruby/object.h - mruby object definition
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_OBJECT_H
+#define MRUBY_OBJECT_H
+
+#define MRB_OBJECT_HEADER \
+  struct RClass *c;       \
+  struct RBasic *gcnext;  \
+  enum mrb_vtype tt:8;    \
+  unsigned int gc_color:3; \
+  unsigned int frozen:1;  \
+  uint32_t flags:20
+
+#define MRB_FLAG_TEST(obj, flag) ((obj)->flags & (flag))
+
+struct RBasic {
+  MRB_OBJECT_HEADER;
+};
+#define mrb_basic_ptr(v) ((struct RBasic*)(mrb_ptr(v)))
+
+#define MRB_OBJ_IS_FROZEN 1
+#define mrb_frozen_p(o) ((o)->frozen)
+
+struct RObject {
+  MRB_OBJECT_HEADER;
+  struct iv_tbl *iv;
+};
+#define mrb_obj_ptr(v)   ((struct RObject*)(mrb_ptr(v)))
+
+#define mrb_special_const_p(x) mrb_immediate_p(x)
+
+struct RFiber {
+  MRB_OBJECT_HEADER;
+  struct mrb_context *cxt;
+};
+
+#define mrb_static_assert_object_size(st) \
+  mrb_static_assert(sizeof(st) <= sizeof(void*) * 6, \
+                    #st " size must be within 6 words")
+
+#endif  /* MRUBY_OBJECT_H */

deps/mruby/include/mruby/opcode.h

@@ -0,0 +1,69 @@
+/**
+** @file mruby/opcode.h - RiteVM operation codes
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_OPCODE_H
+#define MRUBY_OPCODE_H
+
+enum mrb_insn {
+#define OPCODE(x,_) OP_ ## x,
+#include <mruby/ops.h>
+#undef OPCODE
+};
+
+#define OP_L_STRICT  1
+#define OP_L_CAPTURE 2
+#define OP_L_METHOD  OP_L_STRICT
+#define OP_L_LAMBDA  (OP_L_STRICT|OP_L_CAPTURE)
+#define OP_L_BLOCK   OP_L_CAPTURE
+
+#define PEEK_B(pc) (*(pc))
+#define PEEK_S(pc) ((pc)[0]<<8|(pc)[1])
+#define PEEK_W(pc) ((pc)[0]<<16|(pc)[1]<<8|(pc)[2])
+
+#define READ_B() PEEK_B(pc++)
+#define READ_S() (pc+=2, PEEK_S(pc-2))
+#define READ_W() (pc+=3, PEEK_W(pc-3))
+
+#define FETCH_Z() /* nothing */
+#define FETCH_B() do {a=READ_B();} while (0)
+#define FETCH_BB() do {a=READ_B(); b=READ_B();} while (0)
+#define FETCH_BBB() do {a=READ_B(); b=READ_B(); c=READ_B();} while (0)
+#define FETCH_BS() do {a=READ_B(); b=READ_S();} while (0)
+#define FETCH_BSS() do {a=READ_B(); b=READ_S(); c=READ_S();} while (0)
+#define FETCH_S() do {a=READ_S();} while (0)
+#define FETCH_W() do {a=READ_W();} while (0)
+
+/* with OP_EXT1 (1st 16bit) */
+#define FETCH_Z_1() FETCH_Z()
+#define FETCH_B_1() FETCH_S()
+#define FETCH_BB_1() do {a=READ_S(); b=READ_B();} while (0)
+#define FETCH_BBB_1() do {a=READ_S(); b=READ_B(); c=READ_B();} while (0)
+#define FETCH_BS_1() do {a=READ_S(); b=READ_S();} while (0)
+#define FETCH_BSS_1() do {a=READ_S(); b=READ_S();c=READ_S();} while (0)
+#define FETCH_S_1() FETCH_S()
+#define FETCH_W_1() FETCH_W()
+
+/* with OP_EXT2 (2nd 16bit) */
+#define FETCH_Z_2() FETCH_Z()
+#define FETCH_B_2() FETCH_B()
+#define FETCH_BB_2() do {a=READ_B(); b=READ_S();} while (0)
+#define FETCH_BBB_2() do {a=READ_B(); b=READ_S(); c=READ_B();} while (0)
+#define FETCH_BS_2() FETCH_BS()
+#define FETCH_BSS_2() FETCH_BSS()
+#define FETCH_S_2() FETCH_S()
+#define FETCH_W_2() FETCH_W()
+
+/* with OP_EXT3 (1st & 2nd 16bit) */
+#define FETCH_Z_3() FETCH_Z()
+#define FETCH_B_3() FETCH_B()
+#define FETCH_BB_3() do {a=READ_S(); b=READ_S();} while (0)
+#define FETCH_BBB_3() do {a=READ_S(); b=READ_S(); c=READ_B();} while (0)
+#define FETCH_BS_3() do {a=READ_S(); b=READ_S();} while (0)
+#define FETCH_BSS_3() FETCH_BSS_1()
+#define FETCH_S_3() FETCH_S()
+#define FETCH_W_3() FETCH_W()
+
+#endif  /* MRUBY_OPCODE_H */

deps/mruby/include/mruby/ops.h

@@ -0,0 +1,120 @@
+/* operand types:
+   + Z: no operand
+   + B: 8bit
+   + BB: 8+8bit
+   + BBB: 8+8+8bit
+   + BS: 8+16bit
+   + BSS: 8+16+16bit
+   + S: 16bit
+   + W: 24bit
+*/
+
+/*-----------------------------------------------------------------------
+operation code    operands      semantics
+------------------------------------------------------------------------*/
+OPCODE(NOP,        Z)        /* no operation */
+OPCODE(MOVE,       BB)       /* R[a] = R[b] */
+OPCODE(LOADL,      BB)       /* R[a] = Pool[b] */
+OPCODE(LOADI8,     BB)       /* R[a] = mrb_int(b) */
+OPCODE(LOADINEG,   BB)       /* R[a] = mrb_int(-b) */
+OPCODE(LOADI__1,   B)        /* R[a] = mrb_int(-1) */
+OPCODE(LOADI_0,    B)        /* R[a] = mrb_int(0) */
+OPCODE(LOADI_1,    B)        /* R[a] = mrb_int(1) */
+OPCODE(LOADI_2,    B)        /* R[a] = mrb_int(2) */
+OPCODE(LOADI_3,    B)        /* R[a] = mrb_int(3) */
+OPCODE(LOADI_4,    B)        /* R[a] = mrb_int(4) */
+OPCODE(LOADI_5,    B)        /* R[a] = mrb_int(5) */
+OPCODE(LOADI_6,    B)        /* R[a] = mrb_int(6) */
+OPCODE(LOADI_7,    B)        /* R[a] = mrb_int(7) */
+OPCODE(LOADI16,    BS)       /* R[a] = mrb_int(b) */
+OPCODE(LOADI32,    BSS)      /* R[a] = mrb_int((b<<16)+c) */
+OPCODE(LOADSYM,    BB)       /* R[a] = Syms[b] */
+OPCODE(LOADNIL,    B)        /* R[a] = nil */
+OPCODE(LOADSELF,   B)        /* R[a] = self */
+OPCODE(LOADT,      B)        /* R[a] = true */
+OPCODE(LOADF,      B)        /* R[a] = false */
+OPCODE(GETGV,      BB)       /* R[a] = getglobal(Syms[b]) */
+OPCODE(SETGV,      BB)       /* setglobal(Syms[b], R[a]) */
+OPCODE(GETSV,      BB)       /* R[a] = Special[Syms[b]] */
+OPCODE(SETSV,      BB)       /* Special[Syms[b]] = R[a] */
+OPCODE(GETIV,      BB)       /* R[a] = ivget(Syms[b]) */
+OPCODE(SETIV,      BB)       /* ivset(Syms[b],R[a]) */
+OPCODE(GETCV,      BB)       /* R[a] = cvget(Syms[b]) */
+OPCODE(SETCV,      BB)       /* cvset(Syms[b],R[a]) */
+OPCODE(GETCONST,   BB)       /* R[a] = constget(Syms[b]) */
+OPCODE(SETCONST,   BB)       /* constset(Syms[b],R[a]) */
+OPCODE(GETMCNST,   BB)       /* R[a] = R[a]::Syms[b] */
+OPCODE(SETMCNST,   BB)       /* R[a+1]::Syms[b] = R[a] */
+OPCODE(GETUPVAR,   BBB)      /* R[a] = uvget(b,c) */
+OPCODE(SETUPVAR,   BBB)      /* uvset(b,c,R[a]) */
+OPCODE(GETIDX,     B)        /* R[a] = R[a][R[a+1]] */
+OPCODE(SETIDX,     B)        /* R[a][R[a+1]] = R[a+2] */
+OPCODE(JMP,        S)        /* pc+=a */
+OPCODE(JMPIF,      BS)       /* if R[a] pc+=b */
+OPCODE(JMPNOT,     BS)       /* if !R[a] pc+=b */
+OPCODE(JMPNIL,     BS)       /* if R[a]==nil pc+=b */
+OPCODE(JMPUW,      S)        /* unwind_and_jump_to(a) */
+OPCODE(EXCEPT,     B)        /* R[a] = exc */
+OPCODE(RESCUE,     BB)       /* R[b] = R[a].isa?(R[b]) */
+OPCODE(RAISEIF,    B)        /* raise(R[a]) if R[a] */
+OPCODE(SSEND,      BBB)      /* R[a] = self.send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..) (c=n|k<<4) */
+OPCODE(SSENDB,     BBB)      /* R[a] = self.send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..,&R[a+n+2k+1]) */
+OPCODE(SEND,       BBB)      /* R[a] = R[a].send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..) (c=n|k<<4) */
+OPCODE(SENDB,      BBB)      /* R[a] = R[a].send(Syms[b],R[a+1]..,R[a+n+1]:R[a+n+2]..,&R[a+n+2k+1]) */
+OPCODE(CALL,       Z)        /* self.call(*, **, &) (But overlay the current call frame; tailcall) */
+OPCODE(SUPER,      BB)       /* R[a] = super(R[a+1],... ,R[a+b+1]) */
+OPCODE(ARGARY,     BS)       /* R[a] = argument array (16=m5:r1:m5:d1:lv4) */
+OPCODE(ENTER,      W)        /* arg setup according to flags (23=m5:o5:r1:m5:k5:d1:b1) */
+OPCODE(KEY_P,      BB)       /* R[a] = kdict.key?(Syms[b]) */
+OPCODE(KEYEND,     Z)        /* raise unless kdict.empty? */
+OPCODE(KARG,       BB)       /* R[a] = kdict[Syms[b]]; kdict.delete(Syms[b]) */
+OPCODE(RETURN,     B)        /* return R[a] (normal) */
+OPCODE(RETURN_BLK, B)        /* return R[a] (in-block return) */
+OPCODE(BREAK,      B)        /* break R[a] */
+OPCODE(BLKPUSH,    BS)       /* R[a] = block (16=m5:r1:m5:d1:lv4) */
+OPCODE(ADD,        B)        /* R[a] = R[a]+R[a+1] */
+OPCODE(ADDI,       BB)       /* R[a] = R[a]+mrb_int(b) */
+OPCODE(SUB,        B)        /* R[a] = R[a]-R[a+1] */
+OPCODE(SUBI,       BB)       /* R[a] = R[a]-mrb_int(b) */
+OPCODE(MUL,        B)        /* R[a] = R[a]*R[a+1] */
+OPCODE(DIV,        B)        /* R[a] = R[a]/R[a+1] */
+OPCODE(EQ,         B)        /* R[a] = R[a]==R[a+1] */
+OPCODE(LT,         B)        /* R[a] = R[a]<R[a+1] */
+OPCODE(LE,         B)        /* R[a] = R[a]<=R[a+1] */
+OPCODE(GT,         B)        /* R[a] = R[a]>R[a+1] */
+OPCODE(GE,         B)        /* R[a] = R[a]>=R[a+1] */
+OPCODE(ARRAY,      BB)       /* R[a] = ary_new(R[a],R[a+1]..R[a+b]) */
+OPCODE(ARRAY2,     BBB)      /* R[a] = ary_new(R[b],R[b+1]..R[b+c]) */
+OPCODE(ARYCAT,     B)        /* ary_cat(R[a],R[a+1]) */
+OPCODE(ARYPUSH,    BB)       /* ary_push(R[a],R[a+1]..R[a+b]) */
+OPCODE(ARYSPLAT,   B)        /* R[a] = ary_splat(R[a]) */
+OPCODE(AREF,       BBB)      /* R[a] = R[b][c] */
+OPCODE(ASET,       BBB)      /* R[b][c] = R[a] */
+OPCODE(APOST,      BBB)      /* *R[a],R[a+1]..R[a+c] = R[a][b..] */
+OPCODE(INTERN,     B)        /* R[a] = intern(R[a]) */
+OPCODE(SYMBOL,     BB)       /* R[a] = intern(Pool[b]) */
+OPCODE(STRING,     BB)       /* R[a] = str_dup(Pool[b]) */
+OPCODE(STRCAT,     B)        /* str_cat(R[a],R[a+1]) */
+OPCODE(HASH,       BB)       /* R[a] = hash_new(R[a],R[a+1]..R[a+b*2-1]) */
+OPCODE(HASHADD,    BB)       /* hash_push(R[a],R[a+1]..R[a+b*2]) */
+OPCODE(HASHCAT,    B)        /* R[a] = hash_cat(R[a],R[a+1]) */
+OPCODE(LAMBDA,     BB)       /* R[a] = lambda(Irep[b],L_LAMBDA) */
+OPCODE(BLOCK,      BB)       /* R[a] = lambda(Irep[b],L_BLOCK) */
+OPCODE(METHOD,     BB)       /* R[a] = lambda(Irep[b],L_METHOD) */
+OPCODE(RANGE_INC,  B)        /* R[a] = range_new(R[a],R[a+1],FALSE) */
+OPCODE(RANGE_EXC,  B)        /* R[a] = range_new(R[a],R[a+1],TRUE) */
+OPCODE(OCLASS,     B)        /* R[a] = ::Object */
+OPCODE(CLASS,      BB)       /* R[a] = newclass(R[a],Syms[b],R[a+1]) */
+OPCODE(MODULE,     BB)       /* R[a] = newmodule(R[a],Syms[b]) */
+OPCODE(EXEC,       BB)       /* R[a] = blockexec(R[a],Irep[b]) */
+OPCODE(DEF,        BB)       /* R[a].newmethod(Syms[b],R[a+1]); R[a] = Syms[b] */
+OPCODE(ALIAS,      BB)       /* alias_method(target_class,Syms[a],Syms[b]) */
+OPCODE(UNDEF,      B)        /* undef_method(target_class,Syms[a]) */
+OPCODE(SCLASS,     B)        /* R[a] = R[a].singleton_class */
+OPCODE(TCLASS,     B)        /* R[a] = target_class */
+OPCODE(DEBUG,      BBB)      /* print a,b,c */
+OPCODE(ERR,        B)        /* raise(LocalJumpError, Pool[a]) */
+OPCODE(EXT1,       Z)        /* make 1st operand (a) 16bit */
+OPCODE(EXT2,       Z)        /* make 2nd operand (b) 16bit */
+OPCODE(EXT3,       Z)        /* make 1st and 2nd operands 16bit */
+OPCODE(STOP,       Z)        /* stop VM */

deps/mruby/include/mruby/presym.h

@@ -0,0 +1,41 @@
+/**
+** @file mruby/presym.h - Preallocated Symbols
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_PRESYM_H
+#define MRUBY_PRESYM_H
+
+#if defined(MRB_NO_PRESYM)
+# include <mruby/presym/disable.h>
+#elif !defined(MRB_PRESYM_SCANNING)
+# include <mruby/presym/enable.h>
+#endif
+
+/*
+ * Where `mrb_intern_lit` is allowed for symbol interning, it is directly
+ * replaced by the symbol ID if presym is enabled by using the following
+ * macros.
+ *
+ *   MRB_OPSYM(xor)  //=> ^      (Operator)
+ *   MRB_GVSYM(xor)  //=> $xor   (Global Variable)
+ *   MRB_CVSYM(xor)  //=> @@xor  (Class Variable)
+ *   MRB_IVSYM(xor)  //=> @xor   (Instance Variable)
+ *   MRB_SYM_B(xor)  //=> xor!   (Method with Bang)
+ *   MRB_SYM_Q(xor)  //=> xor?   (Method with Question mark)
+ *   MRB_SYM_E(xor)  //=> xor=   (Method with Equal)
+ *   MRB_SYM(xor)    //=> xor    (Word characters)
+ *
+ * For `MRB_OPSYM`, specify the names corresponding to operators (see
+ * `MRuby::Presym::OPERATORS` in `lib/mruby/presym.rb` for the names that
+ * can be specified for it). Other than that, describe only word characters
+ * excluding leading and ending punctuations.
+ *
+ * These macros are expanded to `mrb_intern_lit` if presym is disabled,
+ * therefore the mruby state variable is required. The above macros can be
+ * used when the variable name is `mrb`. If you want to use other variable
+ * names, you need to use macros with `_2` suffix, such as `MRB_SYM_2`.
+ */
+
+#endif  /* MRUBY_PRESYM_H */

deps/mruby/include/mruby/presym/disable.h

@@ -0,0 +1,72 @@
+/**
+** @file mruby/presym/disable.h - Disable Preallocated Symbols
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_PRESYM_DISABLE_H
+#define MRUBY_PRESYM_DISABLE_H
+
+#include <string.h>
+
+#define MRB_PRESYM_MAX 0
+
+#define MRB_OPSYM(name) MRB_OPSYM__##name(mrb)
+#define MRB_GVSYM(name) mrb_intern_lit(mrb, "$" #name)
+#define MRB_CVSYM(name) mrb_intern_lit(mrb, "@@" #name)
+#define MRB_IVSYM(name) mrb_intern_lit(mrb, "@" #name)
+#define MRB_SYM_B(name) mrb_intern_lit(mrb, #name "!")
+#define MRB_SYM_Q(name) mrb_intern_lit(mrb, #name "?")
+#define MRB_SYM_E(name) mrb_intern_lit(mrb, #name "=")
+#define MRB_SYM(name) mrb_intern_lit(mrb, #name)
+
+#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name(mrb)
+#define MRB_GVSYM_2(mrb, name) mrb_intern_lit(mrb, "$" #name)
+#define MRB_CVSYM_2(mrb, name) mrb_intern_lit(mrb, "@@" #name)
+#define MRB_IVSYM_2(mrb, name) mrb_intern_lit(mrb, "@" #name)
+#define MRB_SYM_B_2(mrb, name) mrb_intern_lit(mrb, #name "!")
+#define MRB_SYM_Q_2(mrb, name) mrb_intern_lit(mrb, #name "?")
+#define MRB_SYM_E_2(mrb, name) mrb_intern_lit(mrb, #name "=")
+#define MRB_SYM_2(mrb, name) mrb_intern_lit(mrb, #name)
+
+#define MRB_OPSYM__not(mrb) mrb_intern_lit(mrb, "!")
+#define MRB_OPSYM__mod(mrb) mrb_intern_lit(mrb, "%")
+#define MRB_OPSYM__and(mrb) mrb_intern_lit(mrb, "&")
+#define MRB_OPSYM__mul(mrb) mrb_intern_lit(mrb, "*")
+#define MRB_OPSYM__add(mrb) mrb_intern_lit(mrb, "+")
+#define MRB_OPSYM__sub(mrb) mrb_intern_lit(mrb, "-")
+#define MRB_OPSYM__div(mrb) mrb_intern_lit(mrb, "/")
+#define MRB_OPSYM__lt(mrb) mrb_intern_lit(mrb, "<")
+#define MRB_OPSYM__gt(mrb) mrb_intern_lit(mrb, ">")
+#define MRB_OPSYM__xor(mrb) mrb_intern_lit(mrb, "^")
+#define MRB_OPSYM__tick(mrb) mrb_intern_lit(mrb, "`")
+#define MRB_OPSYM__or(mrb) mrb_intern_lit(mrb, "|")
+#define MRB_OPSYM__neg(mrb) mrb_intern_lit(mrb, "~")
+#define MRB_OPSYM__neq(mrb) mrb_intern_lit(mrb, "!=")
+#define MRB_OPSYM__nmatch(mrb) mrb_intern_lit(mrb, "!~")
+#define MRB_OPSYM__andand(mrb) mrb_intern_lit(mrb, "&&")
+#define MRB_OPSYM__pow(mrb) mrb_intern_lit(mrb, "**")
+#define MRB_OPSYM__plus(mrb) mrb_intern_lit(mrb, "+@")
+#define MRB_OPSYM__minus(mrb) mrb_intern_lit(mrb, "-@")
+#define MRB_OPSYM__lshift(mrb) mrb_intern_lit(mrb, "<<")
+#define MRB_OPSYM__le(mrb) mrb_intern_lit(mrb, "<=")
+#define MRB_OPSYM__eq(mrb) mrb_intern_lit(mrb, "==")
+#define MRB_OPSYM__match(mrb) mrb_intern_lit(mrb, "=~")
+#define MRB_OPSYM__ge(mrb) mrb_intern_lit(mrb, ">=")
+#define MRB_OPSYM__rshift(mrb) mrb_intern_lit(mrb, ">>")
+#define MRB_OPSYM__aref(mrb) mrb_intern_lit(mrb, "[]")
+#define MRB_OPSYM__oror(mrb) mrb_intern_lit(mrb, "||")
+#define MRB_OPSYM__cmp(mrb) mrb_intern_lit(mrb, "<=>")
+#define MRB_OPSYM__eqq(mrb) mrb_intern_lit(mrb, "===")
+#define MRB_OPSYM__aset(mrb) mrb_intern_lit(mrb, "[]=")
+
+#define MRB_PRESYM_DEFINE_VAR_AND_INITER(name, size, ...)                     \
+  static mrb_sym name[size];                                                  \
+  static void presym_init_##name(mrb_state *mrb) {                            \
+    mrb_sym name__[] = {__VA_ARGS__};                                         \
+    memcpy(name, name__, sizeof(name));                                       \
+  }
+
+#define MRB_PRESYM_INIT_SYMBOLS(mrb, name) presym_init_##name(mrb)
+
+#endif  /* MRUBY_PRESYM_DISABLE_H */

deps/mruby/include/mruby/presym/enable.h

@@ -0,0 +1,39 @@
+/**
+** @file mruby/presym/enable.h - Enable Preallocated Symbols
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_PRESYM_ENABLE_H
+#define MRUBY_PRESYM_ENABLE_H
+
+#include <mruby/presym/id.h>
+
+#define MRB_OPSYM(name) MRB_OPSYM__##name
+#define MRB_GVSYM(name) MRB_GVSYM__##name
+#define MRB_CVSYM(name) MRB_CVSYM__##name
+#define MRB_IVSYM(name) MRB_IVSYM__##name
+#define MRB_SYM_B(name) MRB_SYM_B__##name
+#define MRB_SYM_Q(name) MRB_SYM_Q__##name
+#define MRB_SYM_E(name) MRB_SYM_E__##name
+#define MRB_SYM(name) MRB_SYM__##name
+
+#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name
+#define MRB_GVSYM_2(mrb, name) MRB_GVSYM__##name
+#define MRB_CVSYM_2(mrb, name) MRB_CVSYM__##name
+#define MRB_IVSYM_2(mrb, name) MRB_IVSYM__##name
+#define MRB_SYM_B_2(mrb, name) MRB_SYM_B__##name
+#define MRB_SYM_Q_2(mrb, name) MRB_SYM_Q__##name
+#define MRB_SYM_E_2(mrb, name) MRB_SYM_E__##name
+#define MRB_SYM_2(mrb, name) MRB_SYM__##name
+
+#define MRB_PRESYM_DEFINE_VAR_AND_INITER(name, size, ...)                     \
+  static const mrb_sym name[] = {__VA_ARGS__};
+
+#define MRB_PRESYM_INIT_SYMBOLS(mrb, name) (void)(mrb)
+
+/* use MRB_SYM() for E_RUNTIME_ERROR etc. */
+#undef MRB_ERROR_SYM
+#define MRB_ERROR_SYM(sym) MRB_SYM(sym)
+
+#endif  /* MRUBY_PRESYM_ENABLE_H */

deps/mruby/include/mruby/presym/scanning.h

@@ -0,0 +1,81 @@
+/**
+** @file mruby/presym/scanning.h - Scanning Preallocated Symbols
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_PRESYM_SCANNING_H
+#define MRUBY_PRESYM_SCANNING_H
+
+#define MRB_PRESYM_SCANNING_TAGGED(arg) <@! arg !@>
+
+#undef mrb_intern_lit
+#define mrb_intern_lit(mrb, name) MRB_PRESYM_SCANNING_TAGGED(name)
+#define mrb_intern_cstr(mrb, name) MRB_PRESYM_SCANNING_TAGGED(name)
+#define mrb_define_method(mrb, c, name, ...) MRB_PRESYM_SCANNING_TAGGED(name) (c) (__VA_ARGS__)
+#define mrb_define_class_method(mrb, c, name, ...) MRB_PRESYM_SCANNING_TAGGED(name) (c) (__VA_ARGS__)
+#define mrb_define_singleton_method(mrb, c, name, ...) MRB_PRESYM_SCANNING_TAGGED(name) (c) (__VA_ARGS__)
+#define mrb_define_class(mrb, name, s) MRB_PRESYM_SCANNING_TAGGED(name) (s)
+#define mrb_define_class_under(mrb, o, name, s) MRB_PRESYM_SCANNING_TAGGED(name) (o) (s)
+#define mrb_define_module(mrb, name) MRB_PRESYM_SCANNING_TAGGED(name)
+#define mrb_define_module_under(mrb, o, name) MRB_PRESYM_SCANNING_TAGGED(name) (o)
+#define mrb_define_module_function(mrb, c, name, ...) MRB_PRESYM_SCANNING_TAGGED(name) (c) (__VA_ARGS__)
+#define mrb_define_const(mrb, c, name, v) MRB_PRESYM_SCANNING_TAGGED(name) (c) (v)
+#define mrb_define_global_const(mrb, name, v) MRB_PRESYM_SCANNING_TAGGED(name) (v)
+#define mrb_define_alias(mrb, c, a, b) MRB_PRESYM_SCANNING_TAGGED(a) MRB_PRESYM_SCANNING_TAGGED(b) (c)
+#define mrb_class_get(mrb, name) MRB_PRESYM_SCANNING_TAGGED(name)
+#define mrb_class_get_under(mrb, outer, name) MRB_PRESYM_SCANNING_TAGGED(name) (outer)
+#define mrb_module_get(mrb, name) MRB_PRESYM_SCANNING_TAGGED(name)
+#define mrb_module_get_under(mrb, outer, name) MRB_PRESYM_SCANNING_TAGGED(name) (outer)
+#define mrb_funcall(mrb, v, name, ...) MRB_PRESYM_SCANNING_TAGGED(name) (v) (__VA_ARGS__)
+
+#define MRB_OPSYM(name) MRB_OPSYM__##name(mrb)
+#define MRB_GVSYM(name) MRB_PRESYM_SCANNING_TAGGED("$" #name)
+#define MRB_CVSYM(name) MRB_PRESYM_SCANNING_TAGGED("@@" #name)
+#define MRB_IVSYM(name) MRB_PRESYM_SCANNING_TAGGED("@" #name)
+#define MRB_SYM_B(name) MRB_PRESYM_SCANNING_TAGGED(#name "!")
+#define MRB_SYM_Q(name) MRB_PRESYM_SCANNING_TAGGED(#name "?")
+#define MRB_SYM_E(name) MRB_PRESYM_SCANNING_TAGGED(#name "=")
+#define MRB_SYM(name) MRB_PRESYM_SCANNING_TAGGED(#name)
+
+#define MRB_OPSYM_2(mrb, name) MRB_OPSYM__##name(mrb)
+#define MRB_GVSYM_2(mrb, name) MRB_PRESYM_SCANNING_TAGGED("$" #name)
+#define MRB_CVSYM_2(mrb, name) MRB_PRESYM_SCANNING_TAGGED("@@" #name)
+#define MRB_IVSYM_2(mrb, name) MRB_PRESYM_SCANNING_TAGGED("@" #name)
+#define MRB_SYM_B_2(mrb, name) MRB_PRESYM_SCANNING_TAGGED(#name "!")
+#define MRB_SYM_Q_2(mrb, name) MRB_PRESYM_SCANNING_TAGGED(#name "?")
+#define MRB_SYM_E_2(mrb, name) MRB_PRESYM_SCANNING_TAGGED(#name "=")
+#define MRB_SYM_2(mrb, name) MRB_PRESYM_SCANNING_TAGGED(#name)
+
+#define MRB_OPSYM__not(mrb) MRB_PRESYM_SCANNING_TAGGED("!")
+#define MRB_OPSYM__mod(mrb) MRB_PRESYM_SCANNING_TAGGED("%")
+#define MRB_OPSYM__and(mrb) MRB_PRESYM_SCANNING_TAGGED("&")
+#define MRB_OPSYM__mul(mrb) MRB_PRESYM_SCANNING_TAGGED("*")
+#define MRB_OPSYM__add(mrb) MRB_PRESYM_SCANNING_TAGGED("+")
+#define MRB_OPSYM__sub(mrb) MRB_PRESYM_SCANNING_TAGGED("-")
+#define MRB_OPSYM__div(mrb) MRB_PRESYM_SCANNING_TAGGED("/")
+#define MRB_OPSYM__lt(mrb) MRB_PRESYM_SCANNING_TAGGED("<")
+#define MRB_OPSYM__gt(mrb) MRB_PRESYM_SCANNING_TAGGED(">")
+#define MRB_OPSYM__xor(mrb) MRB_PRESYM_SCANNING_TAGGED("^")
+#define MRB_OPSYM__tick(mrb) MRB_PRESYM_SCANNING_TAGGED("`")
+#define MRB_OPSYM__or(mrb) MRB_PRESYM_SCANNING_TAGGED("|")
+#define MRB_OPSYM__neg(mrb) MRB_PRESYM_SCANNING_TAGGED("~")
+#define MRB_OPSYM__neq(mrb) MRB_PRESYM_SCANNING_TAGGED("!=")
+#define MRB_OPSYM__nmatch(mrb) MRB_PRESYM_SCANNING_TAGGED("!~")
+#define MRB_OPSYM__andand(mrb) MRB_PRESYM_SCANNING_TAGGED("&&")
+#define MRB_OPSYM__pow(mrb) MRB_PRESYM_SCANNING_TAGGED("**")
+#define MRB_OPSYM__plus(mrb) MRB_PRESYM_SCANNING_TAGGED("+@")
+#define MRB_OPSYM__minus(mrb) MRB_PRESYM_SCANNING_TAGGED("-@")
+#define MRB_OPSYM__lshift(mrb) MRB_PRESYM_SCANNING_TAGGED("<<")
+#define MRB_OPSYM__le(mrb) MRB_PRESYM_SCANNING_TAGGED("<=")
+#define MRB_OPSYM__eq(mrb) MRB_PRESYM_SCANNING_TAGGED("==")
+#define MRB_OPSYM__match(mrb) MRB_PRESYM_SCANNING_TAGGED("=~")
+#define MRB_OPSYM__ge(mrb) MRB_PRESYM_SCANNING_TAGGED(">=")
+#define MRB_OPSYM__rshift(mrb) MRB_PRESYM_SCANNING_TAGGED(">>")
+#define MRB_OPSYM__aref(mrb) MRB_PRESYM_SCANNING_TAGGED("[]")
+#define MRB_OPSYM__oror(mrb) MRB_PRESYM_SCANNING_TAGGED("||")
+#define MRB_OPSYM__cmp(mrb) MRB_PRESYM_SCANNING_TAGGED("<=>")
+#define MRB_OPSYM__eqq(mrb) MRB_PRESYM_SCANNING_TAGGED("===")
+#define MRB_OPSYM__aset(mrb) MRB_PRESYM_SCANNING_TAGGED("[]=")
+
+#endif  /* MRUBY_PRESYM_SCANNING_H */

deps/mruby/include/mruby/proc.h

@@ -0,0 +1,182 @@
+/**
+** @file mruby/proc.h - Proc class
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_PROC_H
+#define MRUBY_PROC_H
+
+#include "common.h"
+#include <mruby/irep.h>
+#include <string.h>
+
+/**
+ * Proc class
+ */
+MRB_BEGIN_DECL
+
+/*
+ * env object (for internal used)
+ *
+ * - don't create multiple envs on one ci.
+ * - don't share a env to different ci.
+ * - don't attach a closed env to any ci.
+ */
+struct REnv {
+  MRB_OBJECT_HEADER;
+  mrb_value *stack;
+  struct mrb_context *cxt; /* if not null, it means that the stack is shared with the call frame */
+  mrb_sym mid;
+};
+
+/* flags (21bits): 5(ZERO):8(cioff/bidx):8(stack_len) */
+#define MRB_ENV_SET_LEN(e,len) ((e)->flags = (((e)->flags & ~0xff)|((unsigned int)(len) & 0xff)))
+#define MRB_ENV_LEN(e) ((mrb_int)((e)->flags & 0xff))
+#define MRB_ENV_CLOSE(e) ((e)->cxt = NULL)
+#define MRB_ENV_ONSTACK_P(e) ((e)->cxt != NULL)
+#define MRB_ENV_BIDX(e) (((e)->flags >> 8) & 0xff)
+#define MRB_ENV_SET_BIDX(e,idx) ((e)->flags = (((e)->flags & ~(0xff<<8))|((unsigned int)(idx) & 0xff)<<8))
+
+/*
+ * Returns TRUE on success.
+ * If the function fails:
+ * * Returns FALSE if noraise is TRUE.
+ * * Raises a NoMemoryError exception if noraise is FALSE.
+ */
+mrb_bool mrb_env_unshare(mrb_state*, struct REnv*, mrb_bool noraise);
+
+struct RProc {
+  MRB_OBJECT_HEADER;
+  union {
+    const mrb_irep *irep;
+    mrb_func_t func;
+    mrb_sym mid;
+  } body;
+  const struct RProc *upper;
+  union {
+    struct RClass *target_class;
+    struct REnv *env;
+  } e;
+};
+
+/* aspec access */
+#define MRB_ASPEC_REQ(a)          (((a) >> 18) & 0x1f)
+#define MRB_ASPEC_OPT(a)          (((a) >> 13) & 0x1f)
+#define MRB_ASPEC_REST(a)         (((a) >> 12) & 0x1)
+#define MRB_ASPEC_POST(a)         (((a) >> 7) & 0x1f)
+#define MRB_ASPEC_KEY(a)          (((a) >> 2) & 0x1f)
+#define MRB_ASPEC_KDICT(a)        (((a) >> 1) & 0x1)
+#define MRB_ASPEC_BLOCK(a)        ((a) & 1)
+
+#define MRB_PROC_CFUNC_FL 128
+#define MRB_PROC_CFUNC_P(p) (((p)->flags & MRB_PROC_CFUNC_FL) != 0)
+#define MRB_PROC_CFUNC(p) (p)->body.func
+#define MRB_PROC_STRICT 256
+#define MRB_PROC_STRICT_P(p) (((p)->flags & MRB_PROC_STRICT) != 0)
+#define MRB_PROC_ORPHAN 512
+#define MRB_PROC_ORPHAN_P(p) (((p)->flags & MRB_PROC_ORPHAN) != 0)
+#define MRB_PROC_ENVSET 1024
+#define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
+#define MRB_PROC_ENV(p) (MRB_PROC_ENV_P(p) ? (p)->e.env : NULL)
+#define MRB_PROC_TARGET_CLASS(p) (MRB_PROC_ENV_P(p) ? (p)->e.env->c : (p)->e.target_class)
+#define MRB_PROC_SET_TARGET_CLASS(p,tc) do {\
+  if (MRB_PROC_ENV_P(p)) {\
+    (p)->e.env->c = (tc);\
+    mrb_field_write_barrier(mrb, (struct RBasic*)(p)->e.env, (struct RBasic*)(tc));\
+  }\
+  else {\
+    (p)->e.target_class = (tc);\
+    mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)(tc));\
+  }\
+} while (0)
+#define MRB_PROC_SCOPE 2048
+#define MRB_PROC_SCOPE_P(p) (((p)->flags & MRB_PROC_SCOPE) != 0)
+#define MRB_PROC_NOARG 4096 /* for MRB_PROC_CFUNC_FL, it would be something like MRB_ARGS_NONE() or MRB_METHOD_NOARG_FL */
+#define MRB_PROC_NOARG_P(p) (((p)->flags & MRB_PROC_NOARG) != 0)
+#define MRB_PROC_ALIAS 8192
+#define MRB_PROC_ALIAS_P(p) (((p)->flags & MRB_PROC_ALIAS) != 0)
+
+#define mrb_proc_ptr(v)    ((struct RProc*)(mrb_ptr(v)))
+
+struct RProc *mrb_proc_new(mrb_state*, const mrb_irep*);
+MRB_API struct RProc *mrb_proc_new_cfunc(mrb_state*, mrb_func_t);
+MRB_API struct RProc *mrb_closure_new_cfunc(mrb_state *mrb, mrb_func_t func, int nlocals);
+
+/* following functions are defined in mruby-proc-ext so please include it when using */
+MRB_API struct RProc *mrb_proc_new_cfunc_with_env(mrb_state *mrb, mrb_func_t func, mrb_int argc, const mrb_value *argv);
+MRB_API mrb_value mrb_proc_cfunc_env_get(mrb_state *mrb, mrb_int idx);
+/* old name */
+#define mrb_cfunc_env_get(mrb, idx) mrb_proc_cfunc_env_get(mrb, idx)
+
+#define MRB_METHOD_FUNC_FL 8
+#define MRB_METHOD_NOARG_FL 4
+#define MRB_METHOD_PUBLIC_FL 0
+#define MRB_METHOD_PRIVATE_FL 1
+#define MRB_METHOD_PROTECTED_FL 2
+#define MRB_METHOD_VDEFAULT_FL 3
+#define MRB_METHOD_VISIBILITY_MASK 3
+
+#define MRB_METHOD_FUNC_P(m) ((m).flags&MRB_METHOD_FUNC_FL)
+#define MRB_METHOD_NOARG_P(m) (((m).flags&MRB_METHOD_NOARG_FL)?1:0)
+#define MRB_METHOD_FUNC(m) ((m).as.func)
+#define MRB_METHOD_NOARG_SET(m) do{(m).flags|=MRB_METHOD_NOARG_FL;}while(0)
+#define MRB_METHOD_FROM_FUNC(m,fn) do{(m).flags=MRB_METHOD_FUNC_FL;(m).as.func=(fn);}while(0)
+#define MRB_METHOD_FROM_PROC(m,pr) do{(m).flags=0;(m).as.proc=(pr);}while(0)
+#define MRB_METHOD_PROC_P(m) (!MRB_METHOD_FUNC_P(m))
+#define MRB_METHOD_PROC(m) ((m).as.proc)
+#define MRB_METHOD_UNDEF_P(m) ((m).as.proc==NULL)
+#define MRB_METHOD_VISIBILITY(m) ((m).flags & MRB_METHOD_VISIBILITY_MASK)
+#define MRB_SET_VISIBILITY(f,v) ((f)=(((f)&~MRB_METHOD_VISIBILITY_MASK)|(v)))
+#define MRB_METHOD_SET_VISIBILITY(m,v) MRB_SET_VISIBILITY((m).flags,(v))
+
+#define MRB_METHOD_CFUNC_P(m) (MRB_METHOD_FUNC_P(m) || (MRB_METHOD_PROC(m)?(MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m))):FALSE))
+/* use MRB_METHOD_CFUNC(m) only when MRB_METHOD_CFUNC_P(m) is true */
+#define MRB_METHOD_CFUNC(m) (MRB_METHOD_FUNC_P(m)?MRB_METHOD_FUNC(m):MRB_PROC_CFUNC(MRB_METHOD_PROC(m)))
+
+MRB_API mrb_value mrb_load_proc(mrb_state *mrb, const struct RProc *proc);
+
+/**
+ *  It can be used to isolate top-level scopes referenced by blocks generated by
+ *  `mrb_load_string_cxt()` or similar called before entering the mruby VM (e.g. from `main()`).
+ *  In that case, the `ci` parameter should be `mrb->c->cibase`.
+ *
+ *      #include <mruby.h>
+ *      #include <mruby/compile.h>
+ *      #include <mruby/proc.h>
+ *
+ *      int
+ *      main(int argc, char **argv)
+ *      {
+ *        mrb_state *mrb;
+ *        mrb_ccontext *cxt;
+ *        mrb_value blk, ret;
+ *
+ *        mrb = mrb_open();
+ *        cxt = mrb_ccontext_new(mrb);
+ *        blk = mrb_load_string_cxt(mrb, "x, y, z = 1, 2, 3; proc { [x, y, z] }", cxt);
+ *        mrb_vm_ci_env_clear(mrb, mrb->c->cibase);
+ *        mrb_load_string_cxt(mrb, "x, y, z = 4, 5, 6", cxt);
+ *        ret = mrb_funcall(mrb, blk, "call", 0);
+ *        mrb_p(mrb, ret);  // => [1, 2, 3]
+ *                          // => [4, 5, 6] if `mrb_vm_ci_env_clear()` is commented out
+ *        mrb_ccontext_free(mrb, cxt);
+ *        mrb_close(mrb);
+ *
+ *        return 0;
+ *      }
+ *
+ *  The top-level local variable names stored in `mrb_ccontext` are retained.
+ *  Use also `mrb_ccontext_cleanup_local_variables()` at the same time, if necessary.
+ */
+MRB_API void mrb_vm_ci_env_clear(mrb_state *mrb, mrb_callinfo *ci);
+
+void mrb_vm_ci_proc_set(mrb_callinfo *ci, const struct RProc *p);
+struct RClass * mrb_vm_ci_target_class(const mrb_callinfo *ci);
+void mrb_vm_ci_target_class_set(mrb_callinfo *ci, struct RClass *tc);
+struct REnv * mrb_vm_ci_env(const mrb_callinfo *ci);
+void mrb_vm_ci_env_set(mrb_callinfo *ci, struct REnv *e);
+
+MRB_END_DECL
+
+#endif  /* MRUBY_PROC_H */

deps/mruby/include/mruby/range.h

@@ -0,0 +1,77 @@
+/**
+** @file mruby/range.h - Range class
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_RANGE_H
+#define MRUBY_RANGE_H
+
+#include "common.h"
+
+/**
+ * Range class
+ */
+MRB_BEGIN_DECL
+
+#if defined(MRB_NAN_BOXING) && defined(MRB_64BIT) || defined(MRB_WORD_BOXING)
+# define MRB_RANGE_EMBED
+#endif
+
+#ifdef MRB_RANGE_EMBED
+struct RRange {
+  MRB_OBJECT_HEADER;
+  mrb_value beg;
+  mrb_value end;
+  mrb_bool excl;
+};
+# define mrb_gc_free_range(mrb, p) ((void)0)
+# define RANGE_BEG(p) ((p)->beg)
+# define RANGE_END(p) ((p)->end)
+#else
+typedef struct mrb_range_edges {
+  mrb_value beg;
+  mrb_value end;
+} mrb_range_edges;
+struct RRange {
+  MRB_OBJECT_HEADER;
+  mrb_range_edges *edges;
+  mrb_bool excl;
+};
+# define mrb_gc_free_range(mrb, p) mrb_free(mrb, (p)->edges)
+# define RANGE_BEG(p) ((p)->edges->beg)
+# define RANGE_END(p) ((p)->edges->end)
+#endif
+
+#define mrb_range_beg(mrb, r) RANGE_BEG(mrb_range_ptr(mrb, r))
+#define mrb_range_end(mrb, r) RANGE_END(mrb_range_ptr(mrb, r))
+#define mrb_range_excl_p(mrb, r) RANGE_EXCL(mrb_range_ptr(mrb, r))
+#define mrb_range_raw_ptr(r) ((struct RRange*)mrb_ptr(r))
+#define mrb_range_value(p) mrb_obj_value((void*)(p))
+#define RANGE_EXCL(p) ((p)->excl)
+
+MRB_API struct RRange* mrb_range_ptr(mrb_state *mrb, mrb_value range);
+
+/*
+ * Initializes a Range.
+ *
+ * If the third parameter is FALSE then it includes the last value in the range.
+ * If the third parameter is TRUE then it excludes the last value in the range.
+ *
+ * @param start the beginning value.
+ * @param end the ending value.
+ * @param exclude represents the inclusion or exclusion of the last value.
+ */
+MRB_API mrb_value mrb_range_new(mrb_state *mrb, mrb_value start, mrb_value end, mrb_bool exclude);
+
+enum mrb_range_beg_len {
+  MRB_RANGE_TYPE_MISMATCH = 0,  /* (failure) not range */
+  MRB_RANGE_OK = 1,             /* (success) range */
+  MRB_RANGE_OUT = 2             /* (failure) out of range */
+};
+
+MRB_API enum mrb_range_beg_len mrb_range_beg_len(mrb_state *mrb, mrb_value range, mrb_int *begp, mrb_int *lenp, mrb_int len, mrb_bool trunc);
+
+MRB_END_DECL
+
+#endif  /* MRUBY_RANGE_H */

deps/mruby/include/mruby/re.h

@@ -0,0 +1,16 @@
+/**
+** @file mruby/re.h - Regexp class
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_RE_H
+#define MRUBY_RE_H
+
+MRB_BEGIN_DECL
+
+#define REGEXP_CLASS          "Regexp"
+
+MRB_END_DECL
+
+#endif  /* RE_H */

deps/mruby/include/mruby/string.h

@@ -0,0 +1,428 @@
+/**
+** @file mruby/string.h - String class
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_STRING_H
+#define MRUBY_STRING_H
+
+#include "common.h"
+
+/**
+ * String class
+ */
+MRB_BEGIN_DECL
+
+extern const char mrb_digitmap[];
+
+#define RSTRING_EMBED_LEN_MAX \
+  ((mrb_int)(sizeof(void*) * 3 + sizeof(void*) - 32 / CHAR_BIT - 1))
+
+struct RString {
+  MRB_OBJECT_HEADER;
+  union {
+    struct {
+      mrb_ssize len;
+      union {
+        mrb_ssize capa;
+        struct mrb_shared_string *shared;
+        struct RString *fshared;
+      } aux;
+      char *ptr;
+    } heap;
+  } as;
+};
+struct RStringEmbed {
+  MRB_OBJECT_HEADER;
+  char ary[RSTRING_EMBED_LEN_MAX+1];
+};
+
+#define RSTR_SET_TYPE(s, type) ((s)->flags = ((s)->flags & ~(MRB_STR_TYPE_MASK|MRB_STR_EMBED_LEN_MASK)) | MRB_STR_##type)
+
+#define MRB_STR_NORMAL    0
+#define MRB_STR_SHARED    1
+#define MRB_STR_FSHARED   2
+#define MRB_STR_NOFREE    4
+#define MRB_STR_EMBED     8
+#define MRB_STR_TYPE_MASK 15
+
+#define MRB_STR_EMBED_LEN_SHIFT 6
+#define MRB_STR_EMBED_LEN_BITS 5
+#define MRB_STR_EMBED_LEN_MASK (((1 << MRB_STR_EMBED_LEN_BITS) - 1) << MRB_STR_EMBED_LEN_SHIFT)
+
+#define MRB_STR_BINARY    16
+#define MRB_STR_SINGLE_BYTE 32
+#define MRB_STR_STATE_MASK 48
+
+#define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
+#define RSTR_SET_EMBED_FLAG(s) ((s)->flags |= MRB_STR_EMBED)
+#define RSTR_SET_EMBED_LEN(s, n) do {\
+  size_t tmp_n = (n);\
+  (s)->flags &= ~MRB_STR_EMBED_LEN_MASK;\
+  (s)->flags |= (tmp_n) << MRB_STR_EMBED_LEN_SHIFT;\
+} while (0)
+#define RSTR_SET_LEN(s, n) do {\
+  if (RSTR_EMBED_P(s)) {\
+    RSTR_SET_EMBED_LEN((s),(n));\
+  }\
+  else {\
+    (s)->as.heap.len = (mrb_ssize)(n);\
+  }\
+} while (0)
+#define RSTR_EMBED_PTR(s) (((struct RStringEmbed*)(s))->ary)
+#define RSTR_EMBED_LEN(s)\
+  (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
+#define RSTR_EMBEDDABLE_P(len) ((len) <= RSTRING_EMBED_LEN_MAX)
+
+#define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_PTR(s) : (s)->as.heap.ptr)
+#define RSTR_LEN(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_LEN(s) : (s)->as.heap.len)
+#define RSTR_CAPA(s) (RSTR_EMBED_P(s) ? RSTRING_EMBED_LEN_MAX : (s)->as.heap.aux.capa)
+
+#define RSTR_SHARED_P(s) ((s)->flags & MRB_STR_SHARED)
+#define RSTR_FSHARED_P(s) ((s)->flags & MRB_STR_FSHARED)
+#define RSTR_NOFREE_P(s) ((s)->flags & MRB_STR_NOFREE)
+
+#ifdef MRB_UTF8_STRING
+# define RSTR_SINGLE_BYTE_P(s) ((s)->flags & MRB_STR_SINGLE_BYTE)
+# define RSTR_SET_SINGLE_BYTE_FLAG(s) ((s)->flags |= MRB_STR_SINGLE_BYTE)
+# define RSTR_UNSET_SINGLE_BYTE_FLAG(s) ((s)->flags &= ~MRB_STR_SINGLE_BYTE)
+# define RSTR_WRITE_SINGLE_BYTE_FLAG(s, v) (RSTR_UNSET_SINGLE_BYTE_FLAG(s), (s)->flags |= v)
+# define RSTR_COPY_SINGLE_BYTE_FLAG(dst, src) RSTR_WRITE_SINGLE_BYTE_FLAG(dst, RSTR_SINGLE_BYTE_P(src))
+#else
+# define RSTR_SINGLE_BYTE_P(s) TRUE
+# define RSTR_SET_SINGLE_BYTE_FLAG(s) (void)0
+# define RSTR_UNSET_SINGLE_BYTE_FLAG(s) (void)0
+# define RSTR_WRITE_SINGLE_BYTE_FLAG(s, v) (void)0
+# define RSTR_COPY_SINGLE_BYTE_FLAG(dst, src) (void)0
+#endif
+#define RSTR_SET_ASCII_FLAG(s) RSTR_SET_SINGLE_BYTE_FLAG(s)
+#define RSTR_BINARY_P(s) ((s)->flags & MRB_STR_BINARY)
+
+/**
+ * Returns a pointer from a Ruby string
+ */
+#define mrb_str_ptr(s)       ((struct RString*)(mrb_ptr(s)))
+#define RSTRING(s)           mrb_str_ptr(s)
+#define RSTRING_PTR(s)       RSTR_PTR(RSTRING(s))
+#define RSTRING_EMBED_LEN(s) RSTR_EMBED_LEN(RSTRING(s))
+#define RSTRING_LEN(s)       RSTR_LEN(RSTRING(s))
+#define RSTRING_CAPA(s)      RSTR_CAPA(RSTRING(s))
+#define RSTRING_END(s)       (RSTRING_PTR(s) + RSTRING_LEN(s))
+#define RSTRING_CSTR(mrb,s)  mrb_string_cstr(mrb, s)
+
+MRB_API void mrb_str_modify(mrb_state *mrb, struct RString *s);
+/* mrb_str_modify() with keeping ASCII flag if set */
+MRB_API void mrb_str_modify_keep_ascii(mrb_state *mrb, struct RString *s);
+
+/**
+ * Finds the index of a substring in a string
+ */
+MRB_API mrb_int mrb_str_index(mrb_state *mrb, mrb_value str, const char *p, mrb_int len, mrb_int offset);
+#define mrb_str_index_lit(mrb, str, lit, off) mrb_str_index(mrb, str, lit, mrb_strlen_lit(lit), off);
+
+/**
+ * Appends self to other. Returns self as a concatenated string.
+ *
+ *
+ * Example:
+ *
+ *     int
+ *     main(int argc,
+ *          char **argv)
+ *     {
+ *       // Variable declarations.
+ *       mrb_value str1;
+ *       mrb_value str2;
+ *
+ *       mrb_state *mrb = mrb_open();
+ *       if (!mrb)
+ *       {
+ *          // handle error
+ *       }
+ *
+ *       // Creates new Ruby strings.
+ *       str1 = mrb_str_new_lit(mrb, "abc");
+ *       str2 = mrb_str_new_lit(mrb, "def");
+ *
+ *       // Concatenates str2 to str1.
+ *       mrb_str_concat(mrb, str1, str2);
+ *
+ *       // Prints new Concatenated Ruby string.
+ *       mrb_p(mrb, str1);
+ *
+ *       mrb_close(mrb);
+ *       return 0;
+ *     }
+ *
+ * Result:
+ *
+ *     => "abcdef"
+ *
+ * @param mrb The current mruby state.
+ * @param self String to concatenate.
+ * @param other String to append to self.
+ * @return [mrb_value] Returns a new String appending other to self.
+ */
+MRB_API void mrb_str_concat(mrb_state *mrb, mrb_value self, mrb_value other);
+
+/**
+ * Adds two strings together.
+ *
+ *
+ * Example:
+ *
+ *     int
+ *     main(int argc,
+ *          char **argv)
+ *     {
+ *       // Variable declarations.
+ *       mrb_value a;
+ *       mrb_value b;
+ *       mrb_value c;
+ *
+ *       mrb_state *mrb = mrb_open();
+ *       if (!mrb)
+ *       {
+ *          // handle error
+ *       }
+ *
+ *       // Creates two Ruby strings from the passed in C strings.
+ *       a = mrb_str_new_lit(mrb, "abc");
+ *       b = mrb_str_new_lit(mrb, "def");
+ *
+ *       // Prints both C strings.
+ *       mrb_p(mrb, a);
+ *       mrb_p(mrb, b);
+ *
+ *       // Concatenates both Ruby strings.
+ *       c = mrb_str_plus(mrb, a, b);
+ *
+ *       // Prints new Concatenated Ruby string.
+ *       mrb_p(mrb, c);
+ *
+ *       mrb_close(mrb);
+ *       return 0;
+ *     }
+ *
+ *
+ * Result:
+ *
+ *     => "abc"  # First string
+ *     => "def"  # Second string
+ *     => "abcdef" # First & Second concatenated.
+ *
+ * @param mrb The current mruby state.
+ * @param a First string to concatenate.
+ * @param b Second string to concatenate.
+ * @return [mrb_value] Returns a new String containing a concatenated to b.
+ */
+MRB_API mrb_value mrb_str_plus(mrb_state *mrb, mrb_value a, mrb_value b);
+
+/**
+ * Converts pointer into a Ruby string.
+ *
+ * @param mrb The current mruby state.
+ * @param p The pointer to convert to Ruby string.
+ * @return [mrb_value] Returns a new Ruby String.
+ */
+MRB_API mrb_value mrb_ptr_to_str(mrb_state *mrb, void *p);
+
+/**
+ * Returns an object as a Ruby string.
+ *
+ * @param mrb The current mruby state.
+ * @param obj An object to return as a Ruby string.
+ * @return [mrb_value] An object as a Ruby string.
+ */
+MRB_API mrb_value mrb_obj_as_string(mrb_state *mrb, mrb_value obj);
+
+/**
+ * Resizes the string's length. Returns the amount of characters
+ * in the specified by len.
+ *
+ * Example:
+ *
+ *     int
+ *     main(int argc,
+ *          char **argv)
+ *     {
+ *         // Variable declaration.
+ *         mrb_value str;
+ *
+ *         mrb_state *mrb = mrb_open();
+ *         if (!mrb)
+ *         {
+ *            // handle error
+ *         }
+ *         // Creates a new string.
+ *         str = mrb_str_new_lit(mrb, "Hello, world!");
+ *         // Returns 5 characters of
+ *         mrb_str_resize(mrb, str, 5);
+ *         mrb_p(mrb, str);
+ *
+ *         mrb_close(mrb);
+ *         return 0;
+ *      }
+ *
+ * Result:
+ *
+ *      => "Hello"
+ *
+ * @param mrb The current mruby state.
+ * @param str The Ruby string to resize.
+ * @param len The length.
+ * @return [mrb_value] An object as a Ruby string.
+ */
+MRB_API mrb_value mrb_str_resize(mrb_state *mrb, mrb_value str, mrb_int len);
+
+/**
+ * Returns a sub string.
+ *
+ * Example:
+ *
+ *     int
+ *     main(int argc,
+ *     char const **argv)
+ *     {
+ *       // Variable declarations.
+ *       mrb_value str1;
+ *       mrb_value str2;
+ *
+ *       mrb_state *mrb = mrb_open();
+ *       if (!mrb)
+ *       {
+ *         // handle error
+ *       }
+ *       // Creates new string.
+ *       str1 = mrb_str_new_lit(mrb, "Hello, world!");
+ *       // Returns a sub-string within the range of 0..2
+ *       str2 = mrb_str_substr(mrb, str1, 0, 2);
+ *
+ *       // Prints sub-string.
+ *       mrb_p(mrb, str2);
+ *
+ *       mrb_close(mrb);
+ *       return 0;
+ *     }
+ *
+ * Result:
+ *
+ *     => "He"
+ *
+ * @param mrb The current mruby state.
+ * @param str Ruby string.
+ * @param beg The beginning point of the sub-string.
+ * @param len The end point of the sub-string.
+ * @return [mrb_value] An object as a Ruby sub-string.
+ */
+MRB_API mrb_value mrb_str_substr(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len);
+
+MRB_API mrb_value mrb_str_new_capa(mrb_state *mrb, mrb_int capa);
+#define mrb_str_buf_new(mrb, capa) mrb_str_new_capa(mrb, (capa))
+
+/* NULL terminated C string from mrb_value */
+MRB_API const char *mrb_string_cstr(mrb_state *mrb, mrb_value str);
+/* NULL terminated C string from mrb_value; `str` will be updated */
+MRB_API const char *mrb_string_value_cstr(mrb_state *mrb, mrb_value *str);
+/* obsolete: use RSTRING_PTR() */
+#define mrb_string_value_ptr(mrb, str) RSTRING_PTR(str)
+/* obsolete: use RSTRING_LEN() */
+#define mrb_string_value_len(mrb, str) RSTRING_LEN(str)
+/* obsolete: substituted by a macro; shall be removed */
+#define mrb_str_strlen(mrb, s) strlen(RSTR_PTR(s))
+
+/**
+ * Duplicates a string object.
+ *
+ *
+ * @param mrb The current mruby state.
+ * @param str Ruby string.
+ * @return [mrb_value] Duplicated Ruby string.
+ */
+MRB_API mrb_value mrb_str_dup(mrb_state *mrb, mrb_value str);
+
+/**
+ * Returns a symbol from a passed in Ruby string.
+ *
+ * @param mrb The current mruby state.
+ * @param self Ruby string.
+ * @return [mrb_value] A symbol.
+ */
+MRB_API mrb_value mrb_str_intern(mrb_state *mrb, mrb_value self);
+
+MRB_API mrb_value mrb_str_to_integer(mrb_state *mrb, mrb_value str, mrb_int base, mrb_bool badcheck);
+/* obsolete: use mrb_str_to_integer() */
+#define mrb_str_to_inum(mrb, str, base, badcheck) mrb_str_to_integer(mrb, str, base, badcheck)
+MRB_API double mrb_str_to_dbl(mrb_state *mrb, mrb_value str, mrb_bool badcheck);
+
+/**
+ * Returns true if the strings match and false if the strings don't match.
+ *
+ * @param mrb The current mruby state.
+ * @param str1 Ruby string to compare.
+ * @param str2 Ruby string to compare.
+ * @return [mrb_value] boolean value.
+ */
+MRB_API mrb_bool mrb_str_equal(mrb_state *mrb, mrb_value str1, mrb_value str2);
+
+/**
+ * Returns a concatenated string comprised of a Ruby string and a C string.
+ *
+ * @param mrb The current mruby state.
+ * @param str Ruby string.
+ * @param ptr A C string.
+ * @param len length of C string.
+ * @return [mrb_value] A Ruby string.
+ * @see mrb_str_cat_cstr
+ */
+MRB_API mrb_value mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, size_t len);
+
+/**
+ * Returns a concatenated string comprised of a Ruby string and a C string.
+ *
+ * @param mrb The current mruby state.
+ * @param str Ruby string.
+ * @param ptr A C string.
+ * @return [mrb_value] A Ruby string.
+ * @see mrb_str_cat
+ */
+MRB_API mrb_value mrb_str_cat_cstr(mrb_state *mrb, mrb_value str, const char *ptr);
+MRB_API mrb_value mrb_str_cat_str(mrb_state *mrb, mrb_value str, mrb_value str2);
+#define mrb_str_cat_lit(mrb, str, lit) mrb_str_cat(mrb, str, lit, mrb_strlen_lit(lit))
+
+/**
+ * Adds str2 to the end of str1.
+ */
+MRB_API mrb_value mrb_str_append(mrb_state *mrb, mrb_value str, mrb_value str2);
+
+/**
+ * Returns 0 if both Ruby strings are equal. Returns a value < 0 if Ruby str1 is less than Ruby str2. Returns a value > 0 if Ruby str2 is greater than Ruby str1.
+ */
+MRB_API int mrb_str_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2);
+
+/**
+ * Returns a newly allocated C string from a Ruby string.
+ * This is an utility function to pass a Ruby string to C library functions.
+ *
+ * - Returned string does not contain any NUL characters (but terminator).
+ * - It raises an ArgumentError exception if Ruby string contains
+ *   NUL characters.
+ * - Returned string will be freed automatically on next GC.
+ * - Caller can modify returned string without affecting Ruby string
+ *   (e.g. it can be used for mkstemp(3)).
+ *
+ * @param mrb The current mruby state.
+ * @param str Ruby string. Must be an instance of String.
+ * @return [char *] A newly allocated C string.
+ */
+MRB_API char *mrb_str_to_cstr(mrb_state *mrb, mrb_value str);
+
+/* For backward compatibility */
+#define mrb_str_cat2(mrb, str, ptr) mrb_str_cat_cstr(mrb, str, ptr)
+#define mrb_str_buf_cat(mrb, str, ptr, len) mrb_str_cat(mrb, str, ptr, len)
+#define mrb_str_buf_append(mrb, str, str2) mrb_str_cat_str(mrb, str, str2)
+
+MRB_END_DECL
+
+#endif  /* MRUBY_STRING_H */

deps/mruby/include/mruby/throw.h

@@ -0,0 +1,57 @@
+/**
+** @file mruby/throw.h - mruby exception throwing handler
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRB_THROW_H
+#define MRB_THROW_H
+
+#if defined(MRB_USE_CXX_ABI) && !defined(__cplusplus)
+#  error Trying to use C++ exception handling in C code
+#endif
+
+#if defined(MRB_USE_CXX_EXCEPTION)
+
+# if defined(__cplusplus)
+
+#define MRB_TRY(buf) try {
+#define MRB_CATCH(buf) } catch(mrb_jmpbuf *e) { if (e != (buf)) { throw e; }
+#define MRB_END_EXC(buf)  }
+
+#define MRB_THROW(buf) throw(buf)
+typedef void *mrb_jmpbuf_impl;
+
+# else
+# error "need to be compiled with C++ compiler"
+# endif  /* __cplusplus */
+
+#else
+
+#include <setjmp.h>
+
+#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
+#define MRB_SETJMP _setjmp
+#define MRB_LONGJMP _longjmp
+#elif defined(__MINGW64__) && defined(__GNUC__) && __GNUC__ >= 4
+#define MRB_SETJMP __builtin_setjmp
+#define MRB_LONGJMP __builtin_longjmp
+#else
+#define MRB_SETJMP setjmp
+#define MRB_LONGJMP longjmp
+#endif
+
+#define MRB_TRY(buf) if (MRB_SETJMP((buf)->impl) == 0) {
+#define MRB_CATCH(buf) } else {
+#define MRB_END_EXC(buf) }
+
+#define MRB_THROW(buf) MRB_LONGJMP((buf)->impl, 1);
+#define mrb_jmpbuf_impl jmp_buf
+
+#endif
+
+struct mrb_jmpbuf {
+  mrb_jmpbuf_impl impl;
+};
+
+#endif  /* MRB_THROW_H */

deps/mruby/include/mruby/value.h

@@ -0,0 +1,467 @@
+/**
+** @file mruby/value.h - mruby value definitions
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_VALUE_H
+#define MRUBY_VALUE_H
+
+#include "common.h"
+
+/*
+ * mruby Value definition functions and macros.
+ */
+MRB_BEGIN_DECL
+
+/**
+ * mruby Symbol.
+ * @class mrb_sym
+ *
+ * You can create an mrb_sym by simply using mrb_str_intern() or mrb_intern_cstr()
+ */
+typedef uint32_t mrb_sym;
+
+/**
+ * mruby Boolean.
+ * @class mrb_bool
+ *
+ *
+ * Used internally to represent boolean. Can be TRUE or FALSE.
+ * Not to be confused with Ruby's boolean classes, which can be
+ * obtained using mrb_false_value() and mrb_true_value()
+ */
+#if defined(__cplusplus) || (defined(__bool_true_false_are_defined) && __bool_true_false_are_defined)
+typedef bool mrb_bool;
+
+# ifndef FALSE
+#  define FALSE false
+# endif
+# ifndef TRUE
+#  define TRUE true
+# endif
+#else
+# if __STDC_VERSION__ >= 199901L
+typedef _Bool mrb_bool;
+# else
+typedef uint8_t mrb_bool;
+# endif
+
+# ifndef FALSE
+#  define FALSE 0
+# endif
+# ifndef TRUE
+#  define TRUE 1
+# endif
+#endif
+
+struct mrb_state;
+
+#if defined _MSC_VER && _MSC_VER < 1800
+# define PRIo64 "llo"
+# define PRId64 "lld"
+# define PRIu64 "llu"
+# define PRIx64 "llx"
+# define PRIo16 "ho"
+# define PRId16 "hd"
+# define PRIu16 "hu"
+# define PRIx16 "hx"
+# define PRIo32 "o"
+# define PRId32 "d"
+# define PRIu32 "u"
+# define PRIx32 "x"
+#else
+# include <inttypes.h>
+#endif
+
+#if defined(MRB_INT64)
+  typedef int64_t mrb_int;
+  typedef uint64_t mrb_uint;
+# define MRB_INT_BIT 64
+# define MRB_INT_MIN INT64_MIN
+# define MRB_INT_MAX INT64_MAX
+# define MRB_PRIo PRIo64
+# define MRB_PRId PRId64
+# define MRB_PRIx PRIx64
+#else
+  typedef int32_t mrb_int;
+  typedef uint32_t mrb_uint;
+# define MRB_INT_BIT 32
+# define MRB_INT_MIN INT32_MIN
+# define MRB_INT_MAX INT32_MAX
+# define MRB_PRIo PRIo32
+# define MRB_PRId PRId32
+# define MRB_PRIx PRIx32
+#endif
+
+#ifdef MRB_ENDIAN_BIG
+# define MRB_ENDIAN_LOHI(a,b) a b
+#else
+# define MRB_ENDIAN_LOHI(a,b) b a
+#endif
+
+MRB_API mrb_bool mrb_read_int(const char *p, const char *e, char **endp, mrb_int *np);
+/* obsolete; do not use mrb_int_read() */
+MRB_API mrb_int mrb_int_read(const char*, const char*, char**);
+#ifndef MRB_NO_FLOAT
+MRB_API mrb_bool mrb_read_float(const char *p, char **endp, double *fp);
+/* obsolete; do not use mrb_float_read() */
+MRB_API double mrb_float_read(const char *p, char **endp);
+#ifdef MRB_USE_FLOAT32
+  typedef float mrb_float;
+#else
+  typedef double mrb_float;
+#endif
+#endif
+
+#if defined _MSC_VER && _MSC_VER < 1900
+MRB_API int mrb_msvc_vsnprintf(char *s, size_t n, const char *format, va_list arg);
+MRB_API int mrb_msvc_snprintf(char *s, size_t n, const char *format, ...);
+# define vsnprintf(s, n, format, arg) mrb_msvc_vsnprintf(s, n, format, arg)
+# define snprintf(s, n, format, ...) mrb_msvc_snprintf(s, n, format, __VA_ARGS__)
+# if _MSC_VER < 1800 && !defined MRB_NO_FLOAT
+#  define isfinite(n) _finite(n)
+#  define isnan _isnan
+#  define isinf(n) (!_finite(n) && !_isnan(n))
+#  define signbit(n) (_copysign(1.0, (n)) < 0.0)
+static const unsigned int IEEE754_INFINITY_BITS_SINGLE = 0x7F800000;
+#  define INFINITY (*(float*)&IEEE754_INFINITY_BITS_SINGLE)
+#  define NAN ((float)(INFINITY - INFINITY))
+# endif
+#endif
+
+#define MRB_VTYPE_FOREACH(f) \
+    /* mrb_vtype */     /* c type */        /* ruby class */ \
+  f(MRB_TT_FALSE,       void,               "false") \
+  f(MRB_TT_TRUE,        void,               "true") \
+  f(MRB_TT_SYMBOL,      void,               "Symbol") \
+  f(MRB_TT_UNDEF,       void,               "undefined") \
+  f(MRB_TT_FREE,        void,               "free") \
+  f(MRB_TT_FLOAT,       struct RFloat,      "Float") \
+  f(MRB_TT_INTEGER,     struct RInteger,    "Integer") \
+  f(MRB_TT_CPTR,        struct RCptr,       "cptr") \
+  f(MRB_TT_OBJECT,      struct RObject,     "Object") \
+  f(MRB_TT_CLASS,       struct RClass,      "Class") \
+  f(MRB_TT_MODULE,      struct RClass,      "Module") \
+  f(MRB_TT_SCLASS,      struct RClass,      "SClass") \
+  f(MRB_TT_HASH,        struct RHash,       "Hash") \
+  f(MRB_TT_CDATA,       struct RData,       "C data") \
+  f(MRB_TT_EXCEPTION,   struct RException,  "Exception") \
+  f(MRB_TT_ICLASS,      struct RClass,      "iClass") \
+  f(MRB_TT_PROC,        struct RProc,       "Proc") \
+  f(MRB_TT_ARRAY,       struct RArray,      "Array") \
+  f(MRB_TT_STRING,      struct RString,     "String") \
+  f(MRB_TT_RANGE,       struct RRange,      "Range") \
+  f(MRB_TT_ENV,         struct REnv,        "env") \
+  f(MRB_TT_FIBER,       struct RFiber,      "Fiber") \
+  f(MRB_TT_STRUCT,      struct RArray,      "Struct") \
+  f(MRB_TT_ISTRUCT,     struct RIStruct,    "istruct") \
+  f(MRB_TT_BREAK,       struct RBreak,      "break") \
+  f(MRB_TT_COMPLEX,     struct RComplex,    "Complex") \
+  f(MRB_TT_RATIONAL,    struct RRational,   "Rational") \
+  f(MRB_TT_BIGINT,      struct RBigint,     "Integer") \
+  f(MRB_TT_BACKTRACE,   struct RBacktrace,  "backtrace")
+
+enum mrb_vtype {
+#define MRB_VTYPE_DEFINE(tt, type, name) tt,
+  MRB_VTYPE_FOREACH(MRB_VTYPE_DEFINE)
+#undef MRB_VTYPE_DEFINE
+  MRB_TT_MAXDEFINE
+};
+
+/* obsolete name for MRB_TT_CDATA */
+#define MRB_TT_DATA MRB_TT_CDATA
+
+#define MRB_VTYPE_TYPEOF(tt) MRB_TYPEOF_##tt
+
+#define MRB_VTYPE_TYPEDEF(tt, type, name) typedef type MRB_VTYPE_TYPEOF(tt);
+MRB_VTYPE_FOREACH(MRB_VTYPE_TYPEDEF)
+#undef MRB_VTYPE_TYPEDEF
+
+/* for compatibility */
+#define MRB_TT_FIXNUM MRB_TT_INTEGER
+
+#include <mruby/object.h>
+
+#ifdef MRB_DOCUMENTATION_BLOCK
+
+/**
+ * @abstract
+ * mruby value boxing.
+ *
+ * Actual implementation depends on configured boxing type.
+ *
+ * @see mruby/boxing_word.h Word boxing representation (Default)
+ * @see mruby/boxing_no.h No boxing representation
+ * @see mruby/boxing_nan.h Boxed double representation
+ */
+typedef void mrb_value;
+
+#endif
+
+#if defined(MRB_WORD_BOXING) || (defined(MRB_NAN_BOXING) && defined(MRB_64BIT))
+struct RCptr {
+  MRB_OBJECT_HEADER;
+  void *p;
+};
+#endif
+
+#if defined(MRB_NAN_BOXING)
+#include "boxing_nan.h"
+#elif defined(MRB_WORD_BOXING)
+#include "boxing_word.h"
+#else
+#include "boxing_no.h"
+#endif
+
+#if INTPTR_MAX < MRB_INT_MAX
+  typedef intptr_t mrb_ssize;
+# define MRB_SSIZE_MAX INTPTR_MAX
+#else
+  typedef mrb_int mrb_ssize;
+# define MRB_SSIZE_MAX MRB_INT_MAX
+#endif
+
+#ifndef mrb_immediate_p
+#define mrb_immediate_p(o) (mrb_type(o) <= MRB_TT_CPTR)
+#endif
+#ifndef mrb_integer_p
+#define mrb_integer_p(o) (mrb_type(o) == MRB_TT_INTEGER)
+#endif
+#ifndef mrb_fixnum_p
+#define mrb_fixnum_p(o) mrb_integer_p(o)
+#endif
+#ifndef mrb_symbol_p
+#define mrb_symbol_p(o) (mrb_type(o) == MRB_TT_SYMBOL)
+#endif
+#ifndef mrb_undef_p
+#define mrb_undef_p(o) (mrb_type(o) == MRB_TT_UNDEF)
+#endif
+#ifndef mrb_nil_p
+#define mrb_nil_p(o)  (mrb_type(o) == MRB_TT_FALSE && !mrb_fixnum(o))
+#endif
+#ifndef mrb_false_p
+#define mrb_false_p(o) (mrb_type(o) == MRB_TT_FALSE && !!mrb_fixnum(o))
+#endif
+#ifndef mrb_true_p
+#define mrb_true_p(o)  (mrb_type(o) == MRB_TT_TRUE)
+#endif
+#ifndef mrb_float_p
+#ifndef MRB_NO_FLOAT
+#define mrb_float_p(o) (mrb_type(o) == MRB_TT_FLOAT)
+#else
+#define mrb_float_p(o) FALSE
+#endif
+#endif
+#ifndef mrb_array_p
+#define mrb_array_p(o) (mrb_type(o) == MRB_TT_ARRAY)
+#endif
+#ifndef mrb_string_p
+#define mrb_string_p(o) (mrb_type(o) == MRB_TT_STRING)
+#endif
+#ifndef mrb_hash_p
+#define mrb_hash_p(o) (mrb_type(o) == MRB_TT_HASH)
+#endif
+#ifndef mrb_cptr_p
+#define mrb_cptr_p(o) (mrb_type(o) == MRB_TT_CPTR)
+#endif
+#ifndef mrb_exception_p
+#define mrb_exception_p(o) (mrb_type(o) == MRB_TT_EXCEPTION)
+#endif
+#ifndef mrb_free_p
+#define mrb_free_p(o) (mrb_type(o) == MRB_TT_FREE)
+#endif
+#ifndef mrb_object_p
+#define mrb_object_p(o) (mrb_type(o) == MRB_TT_OBJECT)
+#endif
+#ifndef mrb_class_p
+#define mrb_class_p(o) (mrb_type(o) == MRB_TT_CLASS)
+#endif
+#ifndef mrb_module_p
+#define mrb_module_p(o) (mrb_type(o) == MRB_TT_MODULE)
+#endif
+#ifndef mrb_iclass_p
+#define mrb_iclass_p(o) (mrb_type(o) == MRB_TT_ICLASS)
+#endif
+#ifndef mrb_sclass_p
+#define mrb_sclass_p(o) (mrb_type(o) == MRB_TT_SCLASS)
+#endif
+#ifndef mrb_proc_p
+#define mrb_proc_p(o) (mrb_type(o) == MRB_TT_PROC)
+#endif
+#ifndef mrb_range_p
+#define mrb_range_p(o) (mrb_type(o) == MRB_TT_RANGE)
+#endif
+#ifndef mrb_env_p
+#define mrb_env_p(o) (mrb_type(o) == MRB_TT_ENV)
+#endif
+#ifndef mrb_data_p
+#define mrb_data_p(o) (mrb_type(o) == MRB_TT_CDATA)
+#endif
+#ifndef mrb_fiber_p
+#define mrb_fiber_p(o) (mrb_type(o) == MRB_TT_FIBER)
+#endif
+#ifndef mrb_istruct_p
+#define mrb_istruct_p(o) (mrb_type(o) == MRB_TT_ISTRUCT)
+#endif
+#ifndef mrb_break_p
+#define mrb_break_p(o) (mrb_type(o) == MRB_TT_BREAK)
+#endif
+#ifndef mrb_bool
+#define mrb_bool(o)   (mrb_type(o) != MRB_TT_FALSE)
+#endif
+#define mrb_test(o)   mrb_bool(o)
+#ifndef mrb_bigint_p
+#define mrb_bigint_p(o) (mrb_type(o) == MRB_TT_BIGINT)
+#endif
+
+/**
+ * Returns a float in Ruby.
+ *
+ * Takes a float and boxes it into an mrb_value
+ */
+#ifndef MRB_NO_FLOAT
+MRB_INLINE mrb_value
+mrb_float_value(struct mrb_state *mrb, mrb_float f)
+{
+  mrb_value v;
+  (void) mrb;
+  SET_FLOAT_VALUE(mrb, v, f);
+  return v;
+}
+#endif
+
+MRB_INLINE mrb_value
+mrb_cptr_value(struct mrb_state *mrb, void *p)
+{
+  mrb_value v;
+  (void) mrb;
+  SET_CPTR_VALUE(mrb,v,p);
+  return v;
+}
+
+/**
+ * Returns an integer in Ruby.
+ */
+MRB_INLINE mrb_value
+mrb_int_value(struct mrb_state *mrb, mrb_int i)
+{
+  mrb_value v;
+  SET_INT_VALUE(mrb, v, i);
+  return v;
+}
+
+MRB_INLINE mrb_value
+mrb_fixnum_value(mrb_int i)
+{
+  mrb_value v;
+  SET_FIXNUM_VALUE(v, i);
+  return v;
+}
+
+MRB_INLINE mrb_value
+mrb_symbol_value(mrb_sym i)
+{
+  mrb_value v;
+  SET_SYM_VALUE(v, i);
+  return v;
+}
+
+MRB_INLINE mrb_value
+mrb_obj_value(void *p)
+{
+  mrb_value v;
+  SET_OBJ_VALUE(v, (struct RBasic*)p);
+  return v;
+}
+
+/**
+ * Get a nil mrb_value object.
+ *
+ * @return
+ *      nil mrb_value object reference.
+ */
+MRB_INLINE mrb_value
+mrb_nil_value(void)
+{
+  mrb_value v;
+  SET_NIL_VALUE(v);
+  return v;
+}
+
+/**
+ * Returns false in Ruby.
+ */
+MRB_INLINE mrb_value
+mrb_false_value(void)
+{
+  mrb_value v;
+  SET_FALSE_VALUE(v);
+  return v;
+}
+
+/**
+ * Returns true in Ruby.
+ */
+MRB_INLINE mrb_value
+mrb_true_value(void)
+{
+  mrb_value v;
+  SET_TRUE_VALUE(v);
+  return v;
+}
+
+MRB_INLINE mrb_value
+mrb_bool_value(mrb_bool boolean)
+{
+  mrb_value v;
+  SET_BOOL_VALUE(v, boolean);
+  return v;
+}
+
+MRB_INLINE mrb_value
+mrb_undef_value(void)
+{
+  mrb_value v;
+  SET_UNDEF_VALUE(v);
+  return v;
+}
+
+#if defined(MRB_USE_CUSTOM_RO_DATA_P)
+/* If you define `MRB_USE_CUSTOM_RO_DATA_P`, you must implement `mrb_ro_data_p()`. */
+mrb_bool mrb_ro_data_p(const char *p);
+#elif !defined(MRB_NO_DEFAULT_RO_DATA_P)
+#if defined(MRB_USE_ETEXT_RO_DATA_P)
+#define MRB_LINK_TIME_RO_DATA_P
+extern char etext, edata;
+static inline mrb_bool
+mrb_ro_data_p(const char *p)
+{
+  return &etext < p && p < &edata;
+}
+#elif defined(__APPLE__)
+#define MRB_LINK_TIME_RO_DATA_P
+#include <mach-o/getsect.h>
+#include <crt_externs.h> // for _NSGetMachExecuteHeader
+static inline mrb_bool
+mrb_ro_data_p(const char *p)
+{
+#ifdef __LP64__
+  struct mach_header_64 *mhp;
+#else
+  struct mach_header *mhp;
+#endif
+  mhp = _NSGetMachExecuteHeader();
+  unsigned long textsize;
+  char *text = (char*)getsegmentdata(mhp, SEG_TEXT, &textsize);
+  return text <= p && p < text + textsize;
+}
+#endif  /* Linux or macOS */
+#endif  /* MRB_NO_DEFAULT_RO_DATA_P */
+#ifndef MRB_LINK_TIME_RO_DATA_P
+# define mrb_ro_data_p(p) FALSE
+#endif
+
+MRB_END_DECL
+
+#endif  /* MRUBY_VALUE_H */

deps/mruby/include/mruby/variable.h

@@ -0,0 +1,102 @@
+/**
+** @file mruby/variable.h - mruby variables
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_VARIABLE_H
+#define MRUBY_VARIABLE_H
+
+#include "common.h"
+
+/**
+ * Functions to access mruby variables.
+ */
+MRB_BEGIN_DECL
+
+MRB_API mrb_value mrb_const_get(mrb_state*, mrb_value, mrb_sym);
+MRB_API void mrb_const_set(mrb_state*, mrb_value, mrb_sym, mrb_value);
+MRB_API mrb_bool mrb_const_defined(mrb_state*, mrb_value, mrb_sym);
+MRB_API void mrb_const_remove(mrb_state*, mrb_value, mrb_sym);
+
+MRB_API mrb_bool mrb_iv_name_sym_p(mrb_state *mrb, mrb_sym sym);
+MRB_API void mrb_iv_name_sym_check(mrb_state *mrb, mrb_sym sym);
+MRB_API mrb_value mrb_obj_iv_get(mrb_state *mrb, struct RObject *obj, mrb_sym sym);
+MRB_API void mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v);
+MRB_API mrb_bool mrb_obj_iv_defined(mrb_state *mrb, struct RObject *obj, mrb_sym sym);
+MRB_API mrb_value mrb_iv_get(mrb_state *mrb, mrb_value obj, mrb_sym sym);
+MRB_API void mrb_iv_set(mrb_state *mrb, mrb_value obj, mrb_sym sym, mrb_value v);
+MRB_API mrb_bool mrb_iv_defined(mrb_state*, mrb_value, mrb_sym);
+MRB_API mrb_value mrb_iv_remove(mrb_state *mrb, mrb_value obj, mrb_sym sym);
+MRB_API void mrb_iv_copy(mrb_state *mrb, mrb_value dst, mrb_value src);
+MRB_API mrb_bool mrb_const_defined_at(mrb_state *mrb, mrb_value mod, mrb_sym id);
+
+/**
+ * Get a global variable. Will return nil if the var does not exist
+ *
+ * Example:
+ *
+ *     !!!ruby
+ *     # Ruby style
+ *     var = $value
+ *
+ *     !!!c
+ *     // C style
+ *     mrb_sym sym = mrb_intern_lit(mrb, "$value");
+ *     mrb_value var = mrb_gv_get(mrb, sym);
+ *
+ * @param mrb The mruby state reference
+ * @param sym The name of the global variable
+ * @return The value of that global variable. May be nil
+ */
+MRB_API mrb_value mrb_gv_get(mrb_state *mrb, mrb_sym sym);
+
+/**
+ * Set a global variable
+ *
+ * Example:
+ *
+ *     !!!ruby
+ *     # Ruby style
+ *     $value = "foo"
+ *
+ *     !!!c
+ *     // C style
+ *     mrb_sym sym = mrb_intern_lit(mrb, "$value");
+ *     mrb_gv_set(mrb, sym, mrb_str_new_lit("foo"));
+ *
+ * @param mrb The mruby state reference
+ * @param sym The name of the global variable
+ * @param val The value of the global variable
+ */
+MRB_API void mrb_gv_set(mrb_state *mrb, mrb_sym sym, mrb_value val);
+
+/**
+ * Remove a global variable.
+ *
+ * Example:
+ *
+ *     # Ruby style
+ *     $value = nil
+ *
+ *     // C style
+ *     mrb_sym sym = mrb_intern_lit(mrb, "$value");
+ *     mrb_gv_remove(mrb, sym);
+ *
+ * @param mrb The mruby state reference
+ * @param sym The name of the global variable
+ */
+MRB_API void mrb_gv_remove(mrb_state *mrb, mrb_sym sym);
+
+MRB_API mrb_value mrb_cv_get(mrb_state *mrb, mrb_value mod, mrb_sym sym);
+MRB_API void mrb_mod_cv_set(mrb_state *mrb, struct RClass * c, mrb_sym sym, mrb_value v);
+MRB_API void mrb_cv_set(mrb_state *mrb, mrb_value mod, mrb_sym sym, mrb_value v);
+MRB_API mrb_bool mrb_cv_defined(mrb_state *mrb, mrb_value mod, mrb_sym sym);
+
+/* return non zero to break the loop */
+typedef int (mrb_iv_foreach_func)(mrb_state*,mrb_sym,mrb_value,void*);
+MRB_API void mrb_iv_foreach(mrb_state *mrb, mrb_value obj, mrb_iv_foreach_func *func, void *p);
+
+MRB_END_DECL
+
+#endif  /* MRUBY_VARIABLE_H */

deps/mruby/include/mruby/version.h

@@ -0,0 +1,143 @@
+/**
+** @file mruby/version.h - mruby version definition
+**
+** See Copyright Notice in mruby.h
+*/
+
+#ifndef MRUBY_VERSION_H
+#define MRUBY_VERSION_H
+
+#include "common.h"
+
+/**
+ * mruby version definition macros
+ */
+MRB_BEGIN_DECL
+
+/*
+ * A passed in expression.
+ */
+#define MRB_STRINGIZE0(expr) #expr
+
+/*
+ * Passes in an expression to MRB_STRINGIZE0.
+ */
+#define MRB_STRINGIZE(expr) MRB_STRINGIZE0(expr)
+
+/*
+ * The version of Ruby used by mruby.
+ */
+#define MRUBY_RUBY_VERSION "3.4"
+
+/*
+ * Ruby engine.
+ */
+#define MRUBY_RUBY_ENGINE  "mruby"
+
+/*
+ * Major release version number.
+ */
+#define MRUBY_RELEASE_MAJOR 3
+
+/*
+ * Minor release version number.
+ */
+#define MRUBY_RELEASE_MINOR 4
+
+/*
+ * Tiny release version number.
+ */
+#define MRUBY_RELEASE_TEENY 0
+
+/*
+ * Patch level.
+ */
+#define MRUBY_PATCHLEVEL -1
+
+/*
+ * Patch level string. (optional)
+ */
+#define MRUBY_PATCHLEVEL_STR ""
+
+#ifndef MRUBY_PATCHLEVEL_STR
+# if MRUBY_PATCHLEVEL < 0
+#   define MRUBY_PATCHLEVEL_STR "dev"
+# else
+#   define MRUBY_PATCHLEVEL_STR "p"MRB_STRINGIZE(MRUBY_PATCHLEVEL)
+# endif
+#endif
+
+/*
+ * The mruby version.
+ */
+#define MRUBY_VERSION MRB_STRINGIZE(MRUBY_RELEASE_MAJOR) "." MRB_STRINGIZE(MRUBY_RELEASE_MINOR) "." MRB_STRINGIZE(MRUBY_RELEASE_TEENY)
+
+/*
+ * Release number.
+ */
+#define MRUBY_RELEASE_NO (MRUBY_RELEASE_MAJOR * 100 * 100 + MRUBY_RELEASE_MINOR * 100 + MRUBY_RELEASE_TEENY)
+
+/*
+ * Release year.
+ */
+#define MRUBY_RELEASE_YEAR 2025
+
+/*
+ * Release month.
+ */
+#define MRUBY_RELEASE_MONTH 4
+
+/*
+ * Release day.
+ */
+#define MRUBY_RELEASE_DAY 20
+
+/*
+ * Release date as a string.
+ */
+#define MRUBY_RELEASE_DATE    \
+  MRUBY_RELEASE_YEAR_STR "-"  \
+  MRUBY_RELEASE_MONTH_STR "-" \
+  MRUBY_RELEASE_DAY_STR
+#define MRUBY_RELEASE_YEAR_STR MRB_STRINGIZE(MRUBY_RELEASE_YEAR)
+#if MRUBY_RELEASE_MONTH < 10
+#define MRUBY_RELEASE_MONTH_STR "0" MRB_STRINGIZE(MRUBY_RELEASE_MONTH)
+#else
+#define MRUBY_RELEASE_MONTH_STR MRB_STRINGIZE(MRUBY_RELEASE_MONTH)
+#endif
+#if MRUBY_RELEASE_DAY < 10
+#define MRUBY_RELEASE_DAY_STR "0" MRB_STRINGIZE(MRUBY_RELEASE_DAY)
+#else
+#define MRUBY_RELEASE_DAY_STR MRB_STRINGIZE(MRUBY_RELEASE_DAY)
+#endif
+
+/*
+ * The year mruby was first created.
+ */
+#define MRUBY_BIRTH_YEAR 2010
+
+/*
+ * mruby's authors.
+ */
+#define MRUBY_AUTHOR "mruby developers"
+
+/*
+ * mruby's version, and release date.
+ */
+#define MRUBY_DESCRIPTION     \
+  "mruby " MRUBY_VERSION      \
+  MRUBY_PATCHLEVEL_STR        \
+  " (" MRUBY_RELEASE_DATE ")" \
+
+/*
+ * mruby's copyright information.
+ */
+#define MRUBY_COPYRIGHT                \
+  "mruby - Copyright (c) "             \
+  MRB_STRINGIZE(MRUBY_BIRTH_YEAR)"-"   \
+  MRB_STRINGIZE(MRUBY_RELEASE_YEAR)" " \
+  MRUBY_AUTHOR                         \
+
+MRB_END_DECL
+
+#endif  /* MRUBY_VERSION_H */

deps/mruby/lib/libmruby.flags.mak

@@ -0,0 +1,16 @@
+# GNU make is required to use this file.
+MRUBY_PACKAGE_DIR_GNU := $(shell dirname "$(lastword $(MAKEFILE_LIST))")
+MRUBY_PACKAGE_DIR != dirname "$(MRUBY_PACKAGE_DIR_GNU)"
+MRUBY_CC = cl.exe
+MRUBY_CFLAGS = /nologo /W3 /MD /O2 /D_CRT_SECURE_NO_WARNINGS /we4013 /DMRB_STACK_EXTEND_DOUBLING /DMRB_UTF8_STRING /DMRB_USE_BIGINT /DMRB_USE_COMPLEX /DHAVE_MRUBY_ENCODING_GEM /DMRB_UTF8_STRING /DHAVE_MRUBY_IO_GEM /DMRB_USE_RATIONAL /I"$(MRUBY_PACKAGE_DIR)\include" /I"$(MRUBY_PACKAGE_DIR)\include\mruby\gems\mruby-io\include" /I"$(MRUBY_PACKAGE_DIR)\include\mruby\gems\mruby-time\include"
+MRUBY_CXX = cl.exe
+MRUBY_CXXFLAGS = /nologo /W3 /MD /O2 /D_CRT_SECURE_NO_WARNINGS /EHs /DMRB_STACK_EXTEND_DOUBLING /DMRB_UTF8_STRING /DMRB_USE_BIGINT /DMRB_USE_COMPLEX /DHAVE_MRUBY_ENCODING_GEM /DMRB_UTF8_STRING /DHAVE_MRUBY_IO_GEM /DMRB_USE_RATIONAL /I"$(MRUBY_PACKAGE_DIR)\include" /I"$(MRUBY_PACKAGE_DIR)\include\mruby\gems\mruby-io\include" /I"$(MRUBY_PACKAGE_DIR)\include\mruby\gems\mruby-time\include"
+MRUBY_AS = cc
+MRUBY_ASFLAGS = -D"MRB_UTF8_STRING" -D"MRB_USE_BIGINT" -D"MRB_USE_COMPLEX" -D"HAVE_MRUBY_ENCODING_GEM" -D"MRB_UTF8_STRING" -D"HAVE_MRUBY_IO_GEM" -D"MRB_USE_RATIONAL" -I"$(MRUBY_PACKAGE_DIR)\include" -I"$(MRUBY_PACKAGE_DIR)\include\mruby\gems\mruby-io\include" -I"$(MRUBY_PACKAGE_DIR)\include\mruby\gems\mruby-time\include"
+MRUBY_OBJC = cc
+MRUBY_OBJCFLAGS = -D"MRB_UTF8_STRING" -D"MRB_USE_BIGINT" -D"MRB_USE_COMPLEX" -D"HAVE_MRUBY_ENCODING_GEM" -D"MRB_UTF8_STRING" -D"HAVE_MRUBY_IO_GEM" -D"MRB_USE_RATIONAL" -I"$(MRUBY_PACKAGE_DIR)\include" -I"$(MRUBY_PACKAGE_DIR)\include\mruby\gems\mruby-io\include" -I"$(MRUBY_PACKAGE_DIR)\include\mruby\gems\mruby-time\include"
+MRUBY_LD = link.exe
+MRUBY_LDFLAGS = /NOLOGO /DEBUG /INCREMENTAL:NO /OPT:ICF /OPT:REF /DEBUG:NONE /LIBPATH:$(MRUBY_PACKAGE_DIR)/lib
+MRUBY_LDFLAGS_BEFORE_LIBS = 
+MRUBY_LIBS = libmruby.lib ws2_32.lib wsock32.lib ws2_32.lib
+MRUBY_LIBMRUBY_PATH = $(MRUBY_PACKAGE_DIR)/lib/libmruby.lib