diff --git a/CMakeLists.txt b/CMakeLists.txt index c460007..bbad3e3 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -20,12 +20,15 @@ add_executable(mrubypp main.cpp example/Point.h) -set(mruby_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/deps/mruby") +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 - ws2_32.lib wsock32.lib ws2_32.lib) + libmruby ws2_32.lib wsock32.lib ws2_32.lib) include_directories(${CMAKE_CURRENT_LIST_DIR}) diff --git a/deps/mruby/LEGAL b/deps/mruby/LEGAL new file mode 100644 index 0000000..7076809 --- /dev/null +++ b/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 diff --git a/deps/mruby/bin/mirb.exe b/deps/mruby/bin/mirb.exe new file mode 100644 index 0000000..b85523d Binary files /dev/null and b/deps/mruby/bin/mirb.exe differ diff --git a/deps/mruby/bin/mrbc.exe b/deps/mruby/bin/mrbc.exe new file mode 100644 index 0000000..e897205 Binary files /dev/null and b/deps/mruby/bin/mrbc.exe differ diff --git a/deps/mruby/bin/mruby-config.bat b/deps/mruby/bin/mruby-config.bat new file mode 100644 index 0000000..224806f --- /dev/null +++ b/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 diff --git a/deps/mruby/bin/mruby-strip.exe b/deps/mruby/bin/mruby-strip.exe new file mode 100644 index 0000000..79d2217 Binary files /dev/null and b/deps/mruby/bin/mruby-strip.exe differ diff --git a/deps/mruby/bin/mruby.exe b/deps/mruby/bin/mruby.exe new file mode 100644 index 0000000..b32949b Binary files /dev/null and b/deps/mruby/bin/mruby.exe differ diff --git a/deps/mruby/include/mrbconf.h b/deps/mruby/include/mrbconf.h new file mode 100644 index 0000000..52bd17a --- /dev/null +++ b/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 +#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 */ diff --git a/deps/mruby/include/mruby.h b/deps/mruby/include/mruby.h new file mode 100644 index 0000000..fe29b1e --- /dev/null +++ b/deps/mruby/include/mruby.h @@ -0,0 +1,1567 @@ +/* +** mruby - An embeddable Ruby implementation +** +** Copyright (c) mruby developers 2010- +** +** 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. +** +** [ MIT license: https://www.opensource.org/licenses/mit-license.php ] +*/ + +/** + * @file mruby.h + */ + +#ifndef MRUBY_H +#define MRUBY_H + +#ifdef __cplusplus +#define __STDC_LIMIT_MACROS +#define __STDC_CONSTANT_MACROS +#define __STDC_FORMAT_MACROS +#endif + +#include +#include +#include +#include + +#ifdef __cplusplus +#ifndef UINTPTR_MAX +#error Must be placed `#include ` before `#include ` +#endif +#ifndef SIZE_MAX +#ifdef __SIZE_MAX__ +#define SIZE_MAX __SIZE_MAX__ +#else +#define SIZE_MAX std::numeric_limits::max() +#endif +#endif +#endif + +#ifdef _MSC_VER +# define __func__ __FUNCTION__ +#endif + +#ifdef MRB_DEBUG +#include +#define mrb_assert(p) assert(p) +#define mrb_assert_int_fit(t1,n,t2,max) assert((n)>=0 && ((sizeof(n)<=sizeof(t2))||(n<=(t1)(max)))) +#else +#define mrb_assert(p) ((void)0) +#define mrb_assert_int_fit(t1,n,t2,max) ((void)0) +#endif + +#if (defined __cplusplus && __cplusplus >= 201703L) +# define mrb_static_assert(...) static_assert(__VA_ARGS__) +# define mrb_static_assert1(exp) static_assert(exp) +# define mrb_static_assert2(exp, str) static_assert(exp, str) +#elif (defined __cplusplus && __cplusplus >= 201103L) || \ + (defined _MSC_VER) || \ + (defined __GXX_EXPERIMENTAL_CXX0X__) /* for old G++/Clang++ */ +# define mrb_static_assert2(exp, str) static_assert(exp, str) +#elif defined __STDC_VERSION__ && \ + ((__STDC_VERSION__ >= 201112L) || \ + (defined __GNUC__ && __GNUC__ * 100 + __GNUC_MINOR__ >= 406)) +# define mrb_static_assert2(exp, str) _Static_assert(exp, str) +#else +# /* alternative implementation of static_assert() */ +# define _mrb_static_assert_cat0(a, b) a##b +# define _mrb_static_assert_cat(a, b) _mrb_static_assert_cat0(a, b) +# ifdef __COUNTER__ +# define _mrb_static_assert_id(prefix) _mrb_static_assert_cat(prefix, __COUNTER__) +# else +# define _mrb_static_assert_id(prefix) _mrb_static_assert_cat(prefix, __LINE__) +# endif +# define mrb_static_assert2(exp, str) \ + struct _mrb_static_assert_id(_mrb_static_assert_) { char x[(exp) ? 1 : -1]; } +#endif + +#ifndef mrb_static_assert +# define mrb_static_assert1(exp) mrb_static_assert2(exp, #exp) +# define mrb_static_assert_expand(...) __VA_ARGS__ /* for MSVC behaviour - https://stackoverflow.com/q/5530505 */ +# define mrb_static_assert_selector(a, b, name, ...) name +/** + * The `mrb_static_assert()` macro function takes one or two arguments. + * + * !!!c + * mrb_static_assert(expect_condition); + * mrb_static_assert(expect_condition, error_message); + */ +# define mrb_static_assert(...) \ + mrb_static_assert_expand(mrb_static_assert_selector(__VA_ARGS__, mrb_static_assert2, mrb_static_assert1, _)(__VA_ARGS__)) +#endif + +#define mrb_static_assert_powerof2(num) mrb_static_assert((num) > 0 && (num) == ((num) & -(num)), "need power of 2 for " #num) + +#include "mrbconf.h" + +#include +#include +#include +#include + +#ifndef MRB_NO_FLOAT +#include +#include +#ifndef FLT_EPSILON +#define FLT_EPSILON (1.19209290e-07f) +#endif +#ifndef DBL_EPSILON +#define DBL_EPSILON ((double)2.22044604925031308085e-16L) +#endif +#ifndef LDBL_EPSILON +#define LDBL_EPSILON (1.08420217248550443401e-19L) +#endif + +#ifdef MRB_USE_FLOAT32 +#define MRB_FLOAT_EPSILON FLT_EPSILON +#else +#define MRB_FLOAT_EPSILON DBL_EPSILON +#endif +#endif + +/** + * mruby C API entry point + */ +MRB_BEGIN_DECL + +typedef uint8_t mrb_code; + +/** + * \class mrb_aspec + * + * Specifies the number of arguments a function takes + * + * Example: `MRB_ARGS_REQ(2) | MRB_ARGS_OPT(1)` for a method that expects 2..3 arguments + */ +typedef uint32_t mrb_aspec; + +typedef struct mrb_irep mrb_irep; +struct mrb_state; + +/** + * Function pointer type of custom allocator used in @see mrb_open_allocf. + * + * The function pointing it must behave similarly as realloc except: + * - If ptr is NULL it must allocate new space. + * - If size is zero, ptr must be freed. + * + * See @see mrb_default_allocf for the default implementation. + */ +typedef void* (*mrb_allocf) (struct mrb_state *mrb, void *ptr, size_t size, void *ud); + +#ifndef MRB_FIXED_STATE_ATEXIT_STACK_SIZE +#define MRB_FIXED_STATE_ATEXIT_STACK_SIZE 5 +#endif + +typedef struct { + uint8_t n:4; /* (15=*) c=n|nk<<4 */ + uint8_t nk:4; /* (15=*) */ + uint8_t cci; /* called from C function */ + uint8_t vis; /* visibility in the current scope */ + mrb_sym mid; + const struct RProc *proc; + struct RProc *blk; + mrb_value *stack; + const mrb_code *pc; /* current address on iseq of this proc */ + union { + struct REnv *env; + struct RClass *target_class; + const void *keep_context; /* if NULL, it means that the fiber has switched; for internal use */ + } u; +} mrb_callinfo; + +enum mrb_fiber_state { + MRB_FIBER_CREATED = 0, + MRB_FIBER_RUNNING, + MRB_FIBER_RESUMED, + MRB_FIBER_SUSPENDED, + MRB_FIBER_TRANSFERRED, + MRB_FIBER_TERMINATED, +}; + +struct mrb_context { + struct mrb_context *prev; + + mrb_value *stbase, *stend; /* stack of virtual machine */ + + mrb_callinfo *ci; + mrb_callinfo *cibase, *ciend; + + enum mrb_fiber_state status : 4; + mrb_bool vmexec : 1; + struct RFiber *fib; +}; + +#ifdef MRB_METHOD_CACHE_SIZE +# undef MRB_NO_METHOD_CACHE +mrb_static_assert_powerof2(MRB_METHOD_CACHE_SIZE); +#else +/* default method cache size: 256 */ +/* cache size needs to be power of 2 */ +# define MRB_METHOD_CACHE_SIZE (1<<8) +#endif + +/** + * Function pointer type for a function callable by mruby. + * + * The arguments to the function are stored on the mrb_state. To get them see mrb_get_args + * + * @param mrb The mruby state + * @param self The self object + * @return [mrb_value] The function's return value + */ +typedef mrb_value (*mrb_func_t)(struct mrb_state *mrb, mrb_value self); + +typedef struct { + uint32_t flags; /* compatible with mt keys in class.c */ + + union { + const struct RProc *proc; + mrb_func_t func; + } as; +} mrb_method_t; + +#ifndef MRB_NO_METHOD_CACHE +struct mrb_cache_entry { + struct RClass *c, *c0; + /* mrb_sym mid; // mid is stored in mrb_method_t::flags */ + mrb_method_t m; +}; +#endif + +struct mrb_jmpbuf; + +typedef void (*mrb_atexit_func)(struct mrb_state*); + +typedef struct mrb_state { + struct mrb_jmpbuf *jmp; + + mrb_allocf allocf; /* memory allocation function */ + void *allocf_ud; /* auxiliary data of allocf */ + + struct mrb_context *c; + struct mrb_context *root_c; + struct iv_tbl *globals; /* global variable table */ + + struct RObject *exc; /* exception */ + + struct RObject *top_self; + struct RClass *object_class; /* Object class */ + struct RClass *class_class; + struct RClass *module_class; + struct RClass *proc_class; + struct RClass *string_class; + struct RClass *array_class; + struct RClass *hash_class; + struct RClass *range_class; + +#ifndef MRB_NO_FLOAT + struct RClass *float_class; +#endif + struct RClass *integer_class; + struct RClass *true_class; + struct RClass *false_class; + struct RClass *nil_class; + struct RClass *symbol_class; + struct RClass *kernel_module; + + mrb_gc gc; + +#ifndef MRB_NO_METHOD_CACHE + struct mrb_cache_entry cache[MRB_METHOD_CACHE_SIZE]; +#endif + + mrb_sym symidx; + const char **symtbl; + uint8_t *symlink; + uint8_t *symflags; + mrb_sym symhash[256]; + size_t symcapa; +#ifndef MRB_USE_ALL_SYMBOLS + char symbuf[8]; /* buffer for small symbol names */ +#endif + +#ifdef MRB_USE_DEBUG_HOOK + void (*code_fetch_hook)(struct mrb_state* mrb, const struct mrb_irep *irep, const mrb_code *pc, mrb_value *regs); + void (*debug_op_hook)(struct mrb_state* mrb, const struct mrb_irep *irep, const mrb_code *pc, mrb_value *regs); +#endif + +#ifdef MRB_BYTECODE_DECODE_OPTION + mrb_code (*bytecode_decoder)(struct mrb_state* mrb, mrb_code code); +#endif + + struct RClass *eException_class; + struct RClass *eStandardError_class; + struct RObject *nomem_err; /* pre-allocated NoMemoryError */ + struct RObject *stack_err; /* pre-allocated SystemStackError */ +#ifdef MRB_GC_FIXED_ARENA + struct RObject *arena_err; /* pre-allocated arena overflow error */ +#endif + + void *ud; /* auxiliary data */ + +#ifdef MRB_FIXED_STATE_ATEXIT_STACK + mrb_atexit_func atexit_stack[MRB_FIXED_STATE_ATEXIT_STACK_SIZE]; +#else + mrb_atexit_func *atexit_stack; +#endif + uint16_t atexit_stack_len; +} mrb_state; + +/** + * Defines a new class. + * + * If you're creating a gem it may look something like this: + * + * !!!c + * void mrb_example_gem_init(mrb_state* mrb) { + * struct RClass *example_class; + * example_class = mrb_define_class(mrb, "Example_Class", mrb->object_class); + * } + * + * void mrb_example_gem_final(mrb_state* mrb) { + * //free(TheAnimals); + * } + * + * @param mrb The current mruby state. + * @param name The name of the defined class. + * @param super The new class parent. + * @return [struct RClass *] Reference to the newly defined class. + * @see mrb_define_class_under + */ +MRB_API struct RClass *mrb_define_class(mrb_state *mrb, const char *name, struct RClass *super); +MRB_API struct RClass *mrb_define_class_id(mrb_state *mrb, mrb_sym name, struct RClass *super); + +/** + * Defines a new module. + * + * @param mrb The current mruby state. + * @param name The name of the module. + * @return [struct RClass *] Reference to the newly defined module. + */ +MRB_API struct RClass *mrb_define_module(mrb_state *mrb, const char *name); +MRB_API struct RClass *mrb_define_module_id(mrb_state *mrb, mrb_sym name); + +/** + * Returns the singleton class of an object. + * + * Raises a `TypeError` exception for immediate values. + */ +MRB_API mrb_value mrb_singleton_class(mrb_state *mrb, mrb_value val); + +/** + * Returns the singleton class of an object. + * + * Returns `NULL` for immediate values, + */ +MRB_API struct RClass *mrb_singleton_class_ptr(mrb_state *mrb, mrb_value val); + +/** + * Include a module in another class or module. + * Equivalent to: + * + * module B + * include A + * end + * @param mrb The current mruby state. + * @param cla A reference to module or a class. + * @param included A reference to the module to be included. + */ +MRB_API void mrb_include_module(mrb_state *mrb, struct RClass *cla, struct RClass *included); + +/** + * Prepends a module in another class or module. + * + * Equivalent to: + * module B + * prepend A + * end + * @param mrb The current mruby state. + * @param cla A reference to module or a class. + * @param prepended A reference to the module to be prepended. + */ +MRB_API void mrb_prepend_module(mrb_state *mrb, struct RClass *cla, struct RClass *prepended); + +/** + * Defines a global function in ruby. + * + * If you're creating a gem it may look something like this + * + * Example: + * + * mrb_value example_method(mrb_state* mrb, mrb_value self) + * { + * puts("Executing example command!"); + * return self; + * } + * + * void mrb_example_gem_init(mrb_state* mrb) + * { + * mrb_define_method(mrb, mrb->kernel_module, "example_method", example_method, MRB_ARGS_NONE()); + * } + * + * @param mrb The mruby state reference. + * @param cla The class pointer where the method will be defined. + * @param name The name of the method being defined. + * @param func The function pointer to the method definition. + * @param aspec The method parameters declaration. + */ + +MRB_API void mrb_define_method(mrb_state *mrb, struct RClass *cla, const char *name, mrb_func_t func, mrb_aspec aspec); +MRB_API void mrb_define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t func, mrb_aspec aspec); +MRB_API void mrb_define_private_method(mrb_state *mrb, struct RClass *cla, const char *name, mrb_func_t func, mrb_aspec aspec); +MRB_API void mrb_define_private_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t func, mrb_aspec aspec); + +/** + * Defines a class method. + * + * Example: + * + * # Ruby style + * class Foo + * def Foo.bar + * end + * end + * // C style + * mrb_value bar_method(mrb_state* mrb, mrb_value self){ + * return mrb_nil_value(); + * } + * void mrb_example_gem_init(mrb_state* mrb){ + * struct RClass *foo; + * foo = mrb_define_class(mrb, "Foo", mrb->object_class); + * mrb_define_class_method(mrb, foo, "bar", bar_method, MRB_ARGS_NONE()); + * } + * @param mrb The mruby state reference. + * @param cla The class where the class method will be defined. + * @param name The name of the class method being defined. + * @param fun The function pointer to the class method definition. + * @param aspec The method parameters declaration. + */ +MRB_API void mrb_define_class_method(mrb_state *mrb, struct RClass *cla, const char *name, mrb_func_t fun, mrb_aspec aspec); +MRB_API void mrb_define_class_method_id(mrb_state *mrb, struct RClass *cla, mrb_sym name, mrb_func_t fun, mrb_aspec aspec); + +/** + * Defines a singleton method + * + * @see mrb_define_class_method + */ +MRB_API void mrb_define_singleton_method(mrb_state *mrb, struct RObject *cla, const char *name, mrb_func_t fun, mrb_aspec aspec); +MRB_API void mrb_define_singleton_method_id(mrb_state *mrb, struct RObject *cla, mrb_sym name, mrb_func_t fun, mrb_aspec aspec); + +/** + * Defines a module function. + * + * Example: + * + * # Ruby style + * module Foo + * def Foo.bar + * end + * end + * // C style + * mrb_value bar_method(mrb_state* mrb, mrb_value self){ + * return mrb_nil_value(); + * } + * void mrb_example_gem_init(mrb_state* mrb){ + * struct RClass *foo; + * foo = mrb_define_module(mrb, "Foo"); + * mrb_define_module_function(mrb, foo, "bar", bar_method, MRB_ARGS_NONE()); + * } + * @param mrb The mruby state reference. + * @param cla The module where the module function will be defined. + * @param name The name of the module function being defined. + * @param fun The function pointer to the module function definition. + * @param aspec The method parameters declaration. + */ +MRB_API void mrb_define_module_function(mrb_state *mrb, struct RClass *cla, const char *name, mrb_func_t fun, mrb_aspec aspec); +MRB_API void mrb_define_module_function_id(mrb_state *mrb, struct RClass *cla, mrb_sym name, mrb_func_t fun, mrb_aspec aspec); + +/** + * Defines a constant. + * + * Example: + * + * # Ruby style + * class ExampleClass + * AGE = 22 + * end + * // C style + * #include + * #include + * + * void + * mrb_example_gem_init(mrb_state* mrb){ + * mrb_define_const(mrb, mrb->kernel_module, "AGE", mrb_fixnum_value(22)); + * } + * + * mrb_value + * mrb_example_gem_final(mrb_state* mrb){ + * } + * @param mrb The mruby state reference. + * @param cla A class or module the constant is defined in. + * @param name The name of the constant being defined. + * @param val The value for the constant. + */ +MRB_API void mrb_define_const(mrb_state* mrb, struct RClass* cla, const char *name, mrb_value val); +MRB_API void mrb_define_const_id(mrb_state* mrb, struct RClass* cla, mrb_sym name, mrb_value val); + +/** + * Undefines a method. + * + * Example: + * + * # Ruby style + * + * class ExampleClassA + * def example_method + * "example" + * end + * end + * ExampleClassA.new.example_method # => example + * + * class ExampleClassB < ExampleClassA + * undef_method :example_method + * end + * + * ExampleClassB.new.example_method # => undefined method 'example_method' for ExampleClassB (NoMethodError) + * + * // C style + * #include + * #include + * + * mrb_value + * mrb_example_method(mrb_state *mrb){ + * return mrb_str_new_lit(mrb, "example"); + * } + * + * void + * mrb_example_gem_init(mrb_state* mrb){ + * struct RClass *example_class_a; + * struct RClass *example_class_b; + * struct RClass *example_class_c; + * + * example_class_a = mrb_define_class(mrb, "ExampleClassA", mrb->object_class); + * mrb_define_method(mrb, example_class_a, "example_method", mrb_example_method, MRB_ARGS_NONE()); + * example_class_b = mrb_define_class(mrb, "ExampleClassB", example_class_a); + * example_class_c = mrb_define_class(mrb, "ExampleClassC", example_class_b); + * mrb_undef_method(mrb, example_class_c, "example_method"); + * } + * + * mrb_example_gem_final(mrb_state* mrb){ + * } + * @param mrb The mruby state reference. + * @param cla The class the method will be undefined from. + * @param name The name of the method to be undefined. + */ +MRB_API void mrb_undef_method(mrb_state *mrb, struct RClass *cla, const char *name); +MRB_API void mrb_undef_method_id(mrb_state*, struct RClass*, mrb_sym); + +/** + * Undefine a class method. + * Example: + * + * # Ruby style + * class ExampleClass + * def self.example_method + * "example" + * end + * end + * + * ExampleClass.example_method + * + * // C style + * #include + * #include + * + * mrb_value + * mrb_example_method(mrb_state *mrb){ + * return mrb_str_new_lit(mrb, "example"); + * } + * + * void + * mrb_example_gem_init(mrb_state* mrb){ + * struct RClass *example_class; + * example_class = mrb_define_class(mrb, "ExampleClass", mrb->object_class); + * mrb_define_class_method(mrb, example_class, "example_method", mrb_example_method, MRB_ARGS_NONE()); + * mrb_undef_class_method(mrb, example_class, "example_method"); + * } + * + * void + * mrb_example_gem_final(mrb_state* mrb){ + * } + * @param mrb The mruby state reference. + * @param cls A class the class method will be undefined from. + * @param name The name of the class method to be undefined. + */ +MRB_API void mrb_undef_class_method(mrb_state *mrb, struct RClass *cls, const char *name); +MRB_API void mrb_undef_class_method_id(mrb_state *mrb, struct RClass *cls, mrb_sym name); + +/** + * Initialize a new object instance of c class. + * + * Example: + * + * # Ruby style + * class ExampleClass + * end + * + * p ExampleClass # => # + * // C style + * #include + * #include + * + * void + * mrb_example_gem_init(mrb_state* mrb) { + * struct RClass *example_class; + * mrb_value obj; + * example_class = mrb_define_class(mrb, "ExampleClass", mrb->object_class); # => class ExampleClass; end + * obj = mrb_obj_new(mrb, example_class, 0, NULL); # => ExampleClass.new + * mrb_p(mrb, obj); // => Kernel#p + * } + * @param mrb The current mruby state. + * @param c Reference to the class of the new object. + * @param argc Number of arguments in argv + * @param argv Array of mrb_value to initialize the object + * @return [mrb_value] The newly initialized object + */ +MRB_API mrb_value mrb_obj_new(mrb_state *mrb, struct RClass *c, mrb_int argc, const mrb_value *argv); + +/** @see mrb_obj_new */ +MRB_INLINE mrb_value mrb_class_new_instance(mrb_state *mrb, mrb_int argc, const mrb_value *argv, struct RClass *c) +{ + return mrb_obj_new(mrb,c,argc,argv); +} + +/** + * Creates a new instance of Class, Class. + * + * Example: + * + * void + * mrb_example_gem_init(mrb_state* mrb) { + * struct RClass *example_class; + * + * mrb_value obj; + * example_class = mrb_class_new(mrb, mrb->object_class); + * obj = mrb_obj_new(mrb, example_class, 0, NULL); // => #<#:0x9a94588> + * mrb_p(mrb, obj); // => Kernel#p + * } + * + * @param mrb The current mruby state. + * @param super The super class or parent. + * @return [struct RClass *] Reference to the new class. + */ +MRB_API struct RClass * mrb_class_new(mrb_state *mrb, struct RClass *super); + +/** + * Creates a new module, Module. + * + * Example: + * void + * mrb_example_gem_init(mrb_state* mrb) { + * struct RClass *example_module; + * + * example_module = mrb_module_new(mrb); + * } + * + * @param mrb The current mruby state. + * @return [struct RClass *] Reference to the new module. + */ +MRB_API struct RClass * mrb_module_new(mrb_state *mrb); + +/** + * Returns an mrb_bool. True if class was defined, and false if the class was not defined. + * + * Example: + * void + * mrb_example_gem_init(mrb_state* mrb) { + * struct RClass *example_class; + * mrb_bool cd; + * + * example_class = mrb_define_class(mrb, "ExampleClass", mrb->object_class); + * cd = mrb_class_defined(mrb, "ExampleClass"); + * + * // If mrb_class_defined returns TRUE then puts "True" + * // If mrb_class_defined returns FALSE then puts "False" + * if (cd) { + * puts("True"); + * } + * else { + * puts("False"); + * } + * } + * + * @param mrb The current mruby state. + * @param name A string representing the name of the class. + * @return [mrb_bool] A boolean value. + */ +MRB_API mrb_bool mrb_class_defined(mrb_state *mrb, const char *name); +MRB_API mrb_bool mrb_class_defined_id(mrb_state *mrb, mrb_sym name); + +/** + * Gets a class. + * @param mrb The current mruby state. + * @param name The name of the class. + * @return [struct RClass *] A reference to the class. +*/ +MRB_API struct RClass* mrb_class_get(mrb_state *mrb, const char *name); +MRB_API struct RClass* mrb_class_get_id(mrb_state *mrb, mrb_sym name); + +/** + * Gets a exception class. + * @param mrb The current mruby state. + * @param name The name of the class. + * @return [struct RClass *] A reference to the class. +*/ +MRB_API struct RClass* mrb_exc_get_id(mrb_state *mrb, mrb_sym name); +#define mrb_exc_get(mrb, name) mrb_exc_get_id(mrb, mrb_intern_cstr(mrb, name)) + +/** + * Returns an mrb_bool. True if inner class was defined, and false if the inner class was not defined. + * + * Example: + * void + * mrb_example_gem_init(mrb_state* mrb) { + * struct RClass *example_outer, *example_inner; + * mrb_bool cd; + * + * example_outer = mrb_define_module(mrb, "ExampleOuter"); + * + * example_inner = mrb_define_class_under(mrb, example_outer, "ExampleInner", mrb->object_class); + * cd = mrb_class_defined_under(mrb, example_outer, "ExampleInner"); + * + * // If mrb_class_defined_under returns TRUE then puts "True" + * // If mrb_class_defined_under returns FALSE then puts "False" + * if (cd) { + * puts("True"); + * } + * else { + * puts("False"); + * } + * } + * + * @param mrb The current mruby state. + * @param outer The name of the outer class. + * @param name A string representing the name of the inner class. + * @return [mrb_bool] A boolean value. + */ +MRB_API mrb_bool mrb_class_defined_under(mrb_state *mrb, struct RClass *outer, const char *name); +MRB_API mrb_bool mrb_class_defined_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name); + +/** + * Gets a child class. + * @param mrb The current mruby state. + * @param outer The name of the parent class. + * @param name The name of the class. + * @return [struct RClass *] A reference to the class. +*/ +MRB_API struct RClass * mrb_class_get_under(mrb_state *mrb, struct RClass *outer, const char *name); +MRB_API struct RClass * mrb_class_get_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name); + +/** + * Gets a module. + * @param mrb The current mruby state. + * @param name The name of the module. + * @return [struct RClass *] A reference to the module. +*/ +MRB_API struct RClass * mrb_module_get(mrb_state *mrb, const char *name); +MRB_API struct RClass * mrb_module_get_id(mrb_state *mrb, mrb_sym name); + +/** + * Gets a module defined under another module. + * @param mrb The current mruby state. + * @param outer The name of the outer module. + * @param name The name of the module. + * @return [struct RClass *] A reference to the module. +*/ +MRB_API struct RClass * mrb_module_get_under(mrb_state *mrb, struct RClass *outer, const char *name); +MRB_API struct RClass * mrb_module_get_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name); + +/* a function to raise NotImplementedError with current method name */ +MRB_API void mrb_notimplement(mrb_state*); +/* a function to be replacement of unimplemented method */ +MRB_API mrb_value mrb_notimplement_m(mrb_state*, mrb_value); +/* just return it self */ +MRB_API mrb_value mrb_obj_itself(mrb_state*, mrb_value); + +/** + * Duplicate an object. + * + * Equivalent to: + * Object#dup + * @param mrb The current mruby state. + * @param obj Object to be duplicate. + * @return [mrb_value] The newly duplicated object. + */ +MRB_API mrb_value mrb_obj_dup(mrb_state *mrb, mrb_value obj); + +/** + * Returns true if obj responds to the given method. If the method was defined for that + * class it returns true, it returns false otherwise. + * + * Example: + * # Ruby style + * class ExampleClass + * def example_method + * end + * end + * + * ExampleClass.new.respond_to?(:example_method) # => true + * + * // C style + * void + * mrb_example_gem_init(mrb_state* mrb) { + * struct RClass *example_class; + * mrb_sym mid; + * mrb_bool obj_resp; + * + * example_class = mrb_define_class(mrb, "ExampleClass", mrb->object_class); + * mrb_define_method(mrb, example_class, "example_method", exampleMethod, MRB_ARGS_NONE()); + * mid = mrb_intern_str(mrb, mrb_str_new_lit(mrb, "example_method" )); + * obj_resp = mrb_obj_respond_to(mrb, example_class, mid); // => TRUE (true in Ruby world) + * + * // If mrb_obj_respond_to returns TRUE then puts "True" + * // If mrb_obj_respond_to returns FALSE then puts "False" + * if (obj_resp) { + * puts("True"); + * } + * else { + * puts("False"); + * } + * } + * + * @param mrb The current mruby state. + * @param c A reference to a class. + * @param mid A symbol referencing a method id. + * @return [mrb_bool] A boolean value. + */ +MRB_API mrb_bool mrb_obj_respond_to(mrb_state *mrb, struct RClass* c, mrb_sym mid); + +/** + * Defines a new class under a given module + * + * @param mrb The current mruby state. + * @param outer Reference to the module under which the new class will be defined + * @param name The name of the defined class + * @param super The new class parent + * @return [struct RClass *] Reference to the newly defined class + * @see mrb_define_class + */ +MRB_API struct RClass* mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super); +MRB_API struct RClass* mrb_define_class_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name, struct RClass *super); + +MRB_API struct RClass* mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name); +MRB_API struct RClass* mrb_define_module_under_id(mrb_state *mrb, struct RClass *outer, mrb_sym name); + +/** + * Function requires n arguments. + * + * @param n + * The number of required arguments. + */ +#define MRB_ARGS_REQ(n) ((mrb_aspec)((n)&0x1f) << 18) + +/** + * Function takes n optional arguments + * + * @param n + * The number of optional arguments. + */ +#define MRB_ARGS_OPT(n) ((mrb_aspec)((n)&0x1f) << 13) + +/** + * Function takes n1 mandatory arguments and n2 optional arguments + * + * @param n1 + * The number of required arguments. + * @param n2 + * The number of optional arguments. + */ +#define MRB_ARGS_ARG(n1,n2) (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2)) + +/** rest argument */ +#define MRB_ARGS_REST() ((mrb_aspec)(1 << 12)) + +/** required arguments after rest */ +#define MRB_ARGS_POST(n) ((mrb_aspec)((n)&0x1f) << 7) + +/** keyword arguments (n of keys, kdict) */ +#define MRB_ARGS_KEY(n1,n2) ((mrb_aspec)((((n1)&0x1f) << 2) | ((n2)?(1<<1):0))) + +/** + * Function takes a block argument + */ +#define MRB_ARGS_BLOCK() ((mrb_aspec)1) + +/** + * Function accepts any number of arguments + */ +#define MRB_ARGS_ANY() MRB_ARGS_REST() + +/** + * Function accepts no arguments + */ +#define MRB_ARGS_NONE() ((mrb_aspec)0) + +/** + * Format specifiers for {mrb_get_args} function + * + * Must be a C string composed of the following format specifiers: + * + * | char | Ruby type | C types | Notes | + * |:----:|----------------|-------------------|----------------------------------------------------| + * | `o` | {Object} | {mrb_value} | Could be used to retrieve any type of argument | + * | `C` | {Class}/{Module} | {mrb_value} | when `!` follows, the value may be `nil` | + * | `S` | {String} | {mrb_value} | when `!` follows, the value may be `nil` | + * | `A` | {Array} | {mrb_value} | when `!` follows, the value may be `nil` | + * | `H` | {Hash} | {mrb_value} | when `!` follows, the value may be `nil` | + * | `s` | {String} | const char *, {mrb_int} | Receive two arguments; `s!` gives (`NULL`,`0`) for `nil` | + * | `z` | {String} | const char * | `NULL` terminated string; `z!` gives `NULL` for `nil` | + * | `a` | {Array} | const {mrb_value} *, {mrb_int} | Receive two arguments; `a!` gives (`NULL`,`0`) for `nil` | + * | `c` | {Class}/{Module} | strcut RClass * | `c!` gives `NULL` for `nil` | + * | `f` | {Integer}/{Float} | {mrb_float} | | + * | `i` | {Integer}/{Float} | {mrb_int} | | + * | `b` | boolean | {mrb_bool} | | + * | `n` | {String}/{Symbol} | {mrb_sym} | | + * | `d` | data | void *, {mrb_data_type} const | 2nd argument will be used to check data type so it won't be modified; when `!` follows, the value may be `nil` | + * | `I` | inline struct | void *, struct RClass | `I!` gives `NULL` for `nil` | + * | `&` | block | {mrb_value} | &! raises exception if no block given. | + * | `*` | rest arguments | const {mrb_value} *, {mrb_int} | Receive the rest of arguments as an array; `*!` avoid copy of the stack. | + * | \| | optional | | After this spec following specs would be optional. | + * | `?` | optional given | {mrb_bool} | `TRUE` if preceding argument is given. Used to check optional argument is given. | + * | `:` | keyword args | {mrb_kwargs} const | Get keyword arguments. @see mrb_kwargs | + * + * @see mrb_get_args + * + * Immediately after format specifiers it can add format modifiers: + * + * | char | Notes | + * |:----:|-----------------------------------------------------------------------------------------| + * | `!` | Switch to the alternate mode; The behaviour changes depending on the format specifier | + * | `+` | Request a not frozen object; However, except nil value | + */ +typedef const char *mrb_args_format; + +/** + * Get keyword arguments by `mrb_get_args()` with `:` specifier. + * + * `mrb_kwargs::num` indicates that the total number of keyword values. + * + * `mrb_kwargs::required` indicates that the specified number of keywords starting from the beginning of the `mrb_sym` array are required. + * + * `mrb_kwargs::table` accepts a `mrb_sym` array of C. + * + * `mrb_kwargs::values` is an object array of C, and the keyword argument corresponding to the `mrb_sym` array is assigned. + * Note that `undef` is assigned if there is no keyword argument corresponding over `mrb_kwargs::required` to `mrb_kwargs::num`. + * + * `mrb_kwargs::rest` is the remaining keyword argument that can be accepted as `**rest` in Ruby. + * If `NULL` is specified, `ArgumentError` is raised when there is an undefined keyword. + * + * Examples: + * + * // def method(a: 1, b: 2) + * + * mrb_int kw_num = 2; + * mrb_int kw_required = 0; + * mrb_sym kw_names[] = { mrb_intern_lit(mrb, "a"), mrb_intern_lit(mrb, "b") }; + * mrb_value kw_values[kw_num]; + * mrb_kwargs kwargs = { kw_num, kw_required, kw_names, kw_values, NULL }; + * + * mrb_get_args(mrb, ":", &kwargs); + * if (mrb_undef_p(kw_values[0])) { kw_values[0] = mrb_fixnum_value(1); } + * if (mrb_undef_p(kw_values[1])) { kw_values[1] = mrb_fixnum_value(2); } + * + * + * // def method(str, x:, y: 2, z: "default string", **opts) + * + * mrb_value str, kw_rest; + * uint32_t kw_num = 3; + * uint32_t kw_required = 1; + * // Note that `#include ` is required beforehand because `MRB_SYM()` is used. + * // If the usage of `MRB_SYM()` is not desired, replace it with `mrb_intern_lit()`. + * mrb_sym kw_names[] = { MRB_SYM(x), MRB_SYM(y), MRB_SYM(z) }; + * mrb_value kw_values[kw_num]; + * mrb_kwargs kwargs = { kw_num, kw_required, kw_names, kw_values, &kw_rest }; + * + * mrb_get_args(mrb, "S:", &str, &kwargs); + * // or: mrb_get_args(mrb, ":S", &kwargs, &str); + * if (mrb_undef_p(kw_values[1])) { kw_values[1] = mrb_fixnum_value(2); } + * if (mrb_undef_p(kw_values[2])) { kw_values[2] = mrb_str_new_cstr(mrb, "default string"); } + */ +typedef struct mrb_kwargs mrb_kwargs; + +struct mrb_kwargs +{ + mrb_int num; /* number of keyword arguments */ + mrb_int required; /* number of required keyword arguments */ + const mrb_sym *table; /* C array of symbols for keyword names */ + mrb_value *values; /* keyword argument values */ + mrb_value *rest; /* keyword rest (dict) */ +}; + +/** + * Retrieve arguments from mrb_state. + * + * @param mrb The current mruby state. + * @param format is a list of format specifiers + * @param ... The passing variadic arguments must be a pointer of retrieving type. + * @return the number of arguments retrieved. + * @see mrb_args_format + * @see mrb_kwargs + */ +MRB_API mrb_int mrb_get_args(mrb_state *mrb, mrb_args_format format, ...); + +/** + * Array version of mrb_get_args() + * + * @param ptr Array of void*, in the same order as the varargs version. + */ +MRB_API mrb_int mrb_get_args_a(mrb_state *mrb, mrb_args_format format, void** ptr); + +MRB_INLINE mrb_sym +mrb_get_mid(mrb_state *mrb) /* get method symbol */ +{ + return mrb->c->ci->mid; +} + +/** + * Retrieve number of arguments from mrb_state. + * + * Correctly handles *splat arguments. + */ +MRB_API mrb_int mrb_get_argc(mrb_state *mrb); + +/** + * Retrieve an array of arguments from mrb_state. + * + * Correctly handles *splat arguments. + */ +MRB_API const mrb_value *mrb_get_argv(mrb_state *mrb); + +/** + * Retrieve the first and only argument from mrb_state. + * Raises ArgumentError unless the number of arguments is exactly one. + * + * Correctly handles *splat arguments. + */ +MRB_API mrb_value mrb_get_arg1(mrb_state *mrb); + +/** + * Check if a block argument is given from mrb_state. + */ +MRB_API mrb_bool mrb_block_given_p(mrb_state *mrb); + +/* `strlen` for character string literals (use with caution or `strlen` instead) + Adjacent string literals are concatenated in C/C++ in translation phase 6. + If `lit` is not one, the compiler will report a syntax error: + MSVC: "error C2143: syntax error : missing ')' before 'string'" + GCC: "error: expected ')' before string constant" +*/ +#define mrb_strlen_lit(lit) (sizeof(lit "") - 1) + +/** + * Call existing ruby functions. + * + * Example: + * + * #include + * #include + * #include + * + * int + * main() + * { + * mrb_int i = 99; + * mrb_state *mrb = mrb_open(); + * + * if (!mrb) { } + * FILE *fp = fopen("test.rb","r"); + * mrb_value obj = mrb_load_file(mrb,fp); + * mrb_funcall(mrb, obj, "method_name", 1, mrb_fixnum_value(i)); + * mrb_funcall_id(mrb, obj, MRB_SYM(method_name), 1, mrb_fixnum_value(i)); + * fclose(fp); + * mrb_close(mrb); + * } + * + * @param mrb The current mruby state. + * @param val A reference to an mruby value. + * @param name The name of the method. + * @param argc The number of arguments the method has. + * @param ... Variadic values(not type safe!). + * @return [mrb_value] mruby function value. + */ +MRB_API mrb_value mrb_funcall(mrb_state *mrb, mrb_value val, const char *name, mrb_int argc, ...); +MRB_API mrb_value mrb_funcall_id(mrb_state *mrb, mrb_value val, mrb_sym mid, mrb_int argc, ...); +/** + * Call existing ruby functions. This is basically the type safe version of mrb_funcall. + * + * #include + * #include + * #include + * int + * main() + * { + * mrb_state *mrb = mrb_open(); + * mrb_value obj = mrb_fixnum_value(1); + * + * if (!mrb) { } + * + * FILE *fp = fopen("test.rb","r"); + * mrb_value obj = mrb_load_file(mrb,fp); + * mrb_funcall_argv(mrb, obj, MRB_SYM(method_name), 1, &obj); // Calling ruby function from test.rb. + * fclose(fp); + * mrb_close(mrb); + * } + * @param mrb The current mruby state. + * @param val A reference to an mruby value. + * @param name_sym The symbol representing the method. + * @param argc The number of arguments the method has. + * @param obj Pointer to the object. + * @return [mrb_value] mrb_value mruby function value. + * @see mrb_funcall + */ +MRB_API mrb_value mrb_funcall_argv(mrb_state *mrb, mrb_value val, mrb_sym name, mrb_int argc, const mrb_value *argv); +/** + * Call existing ruby functions with a block. + */ +MRB_API mrb_value mrb_funcall_with_block(mrb_state *mrb, mrb_value val, mrb_sym name, mrb_int argc, const mrb_value *argv, mrb_value block); +/** + * Create a symbol from C string. But usually it's better to + * use MRB_SYM, MRB_OPSYM, MRB_CVSYM, MRB_IVSYM, MRB_GVSYM, + * MRB_SYM_B, MRB_SYM_Q, MRB_SYM_E macros. + * + * Example: + * + * # Ruby style: + * :pizza # => :pizza + * + * // C style: + * mrb_sym sym1 = mrb_intern_lit(mrb, "pizza"); // => :pizza + * mrb_sym sym2 = MRB_SYM(pizza); // => :pizza + * mrb_sym sym3 = MRB_SYM_Q(pizza); // => :pizza? + * + * @param mrb The current mruby state. + * @param str The string to be symbolized + * @return [mrb_sym] mrb_sym A symbol. + */ +MRB_API mrb_sym mrb_intern_cstr(mrb_state *mrb, const char* str); +MRB_API mrb_sym mrb_intern(mrb_state*,const char*,size_t); +MRB_API mrb_sym mrb_intern_static(mrb_state*,const char*,size_t); +#define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, (lit ""), mrb_strlen_lit(lit)) +MRB_API mrb_sym mrb_intern_str(mrb_state*,mrb_value); +/* mrb_intern_check series functions returns 0 if the symbol is not defined */ +MRB_API mrb_sym mrb_intern_check_cstr(mrb_state*,const char*); +MRB_API mrb_sym mrb_intern_check(mrb_state*,const char*,size_t); +MRB_API mrb_sym mrb_intern_check_str(mrb_state*,mrb_value); +/* mrb_check_intern series functions returns nil if the symbol is not defined */ +/* otherwise returns mrb_value */ +MRB_API mrb_value mrb_check_intern_cstr(mrb_state*,const char*); +MRB_API mrb_value mrb_check_intern(mrb_state*,const char*,size_t); +MRB_API mrb_value mrb_check_intern_str(mrb_state*,mrb_value); +MRB_API const char *mrb_sym_name(mrb_state*,mrb_sym); +MRB_API const char *mrb_sym_name_len(mrb_state*,mrb_sym,mrb_int*); +MRB_API const char *mrb_sym_dump(mrb_state*,mrb_sym); +MRB_API mrb_value mrb_sym_str(mrb_state*,mrb_sym); +#define mrb_sym2name(mrb,sym) mrb_sym_name(mrb,sym) +#define mrb_sym2name_len(mrb,sym,len) mrb_sym_name_len(mrb,sym,len) +#define mrb_sym2str(mrb,sym) mrb_sym_str(mrb,sym) + +MRB_API void *mrb_malloc(mrb_state*, size_t); /* raise RuntimeError if no mem */ +MRB_API void *mrb_calloc(mrb_state*, size_t, size_t); /* ditto */ +MRB_API void *mrb_realloc(mrb_state*, void*, size_t); /* ditto */ +MRB_API void *mrb_realloc_simple(mrb_state*, void*, size_t); /* return NULL if no memory available */ +MRB_API void *mrb_malloc_simple(mrb_state*, size_t); /* return NULL if no memory available */ +MRB_API struct RBasic *mrb_obj_alloc(mrb_state*, enum mrb_vtype, struct RClass*); +MRB_API void mrb_free(mrb_state*, void*); + +/** + * Allocates a Ruby object that matches the constant literal defined in + * `enum mrb_vtype` and returns a pointer to the corresponding C type. + * + * @param mrb The current mruby state + * @param tt The constant literal of `enum mrb_vtype` + * @param klass A Class object + * @return Reference to the newly created object + */ +#define MRB_OBJ_ALLOC(mrb, tt, klass) ((MRB_VTYPE_TYPEOF(tt)*)mrb_obj_alloc(mrb, tt, klass)) + +MRB_API mrb_value mrb_str_new(mrb_state *mrb, const char *p, mrb_int len); + +/** + * Turns a C string into a Ruby string value. + */ +MRB_API mrb_value mrb_str_new_cstr(mrb_state*, const char*); +MRB_API mrb_value mrb_str_new_static(mrb_state *mrb, const char *p, mrb_int len); +#define mrb_str_new_lit(mrb, lit) mrb_str_new_static(mrb, (lit), mrb_strlen_lit(lit)) + +MRB_API mrb_value mrb_obj_freeze(mrb_state*, mrb_value); +#define mrb_str_new_frozen(mrb,p,len) mrb_obj_freeze(mrb,mrb_str_new(mrb,p,len)) +#define mrb_str_new_cstr_frozen(mrb,p) mrb_obj_freeze(mrb,mrb_str_new_cstr(mrb,p)) +#define mrb_str_new_static_frozen(mrb,p,len) mrb_obj_freeze(mrb,mrb_str_new_static(mrb,p,len)) +#define mrb_str_new_lit_frozen(mrb,lit) mrb_obj_freeze(mrb,mrb_str_new_lit(mrb,lit)) + +#ifdef _WIN32 +MRB_API char* mrb_utf8_from_locale(const char *p, int len); +MRB_API char* mrb_locale_from_utf8(const char *p, int len); +#define mrb_locale_free(p) free(p) +#define mrb_utf8_free(p) free(p) +#else +#define mrb_utf8_from_locale(p, l) ((char*)(p)) +#define mrb_locale_from_utf8(p, l) ((char*)(p)) +#define mrb_locale_free(p) +#define mrb_utf8_free(p) +#endif + +/** + * Creates new mrb_state. + * + * @return + * Pointer to the newly created mrb_state. + */ +MRB_API mrb_state* mrb_open(void); + +/** + * Create new mrb_state with custom allocators. + * + * @param f + * Reference to the allocation function. + * @param ud + * User data will be passed to custom allocator f. + * If user data isn't required just pass NULL. + * @return + * Pointer to the newly created mrb_state. + */ +MRB_API mrb_state* mrb_open_allocf(mrb_allocf f, void *ud); + +/** + * Create new mrb_state with just the mruby core + * + * @param f + * Reference to the allocation function. + * Use mrb_default_allocf for the default + * @param ud + * User data will be passed to custom allocator f. + * If user data isn't required just pass NULL. + * @return + * Pointer to the newly created mrb_state. + */ +MRB_API mrb_state* mrb_open_core(mrb_allocf f, void *ud); + +/** + * Closes and frees a mrb_state. + * + * @param mrb + * Pointer to the mrb_state to be closed. + */ +MRB_API void mrb_close(mrb_state *mrb); + +/** + * The default allocation function. + * + * @see mrb_allocf + */ +MRB_API void* mrb_default_allocf(mrb_state*, void*, size_t, void*); + +MRB_API mrb_value mrb_top_self(mrb_state *mrb); + +/** + * Enter the mruby VM and execute the proc. + * + * @param mrb + * The current mruby state. + * @param proc + * An object containing `irep`. + * If supplied an object containing anything other than `irep`, it will probably crash. + * @param self + * `self` on the execution context of `proc`. + * @param stack_keep + * Specifies the number of values to hold from the stack top. + * Values on the stack outside this range will be initialized to `nil`. + * + * @note + * When called from a C function defined as a method, the current stack is destroyed. + * If you want to use arguments obtained by `mrb_get_args()` or other methods after `mrb_top_run()`, + * you must protect them by `mrb_gc_protect()` or other ways before this function. + * Or consider using `mrb_yield()` family functions. + */ +MRB_API mrb_value mrb_top_run(mrb_state *mrb, const struct RProc *proc, mrb_value self, mrb_int stack_keep); + +MRB_API mrb_value mrb_vm_run(mrb_state *mrb, const struct RProc *proc, mrb_value self, mrb_int stack_keep); +MRB_API mrb_value mrb_vm_exec(mrb_state *mrb, const struct RProc *proc, const mrb_code *iseq); +/* compatibility macros */ +#define mrb_toplevel_run_keep(m,p,k) mrb_top_run((m),(p),mrb_top_self(m),(k)) +#define mrb_toplevel_run(m,p) mrb_toplevel_run_keep((m),(p),0) +#define mrb_context_run(m,p,s,k) mrb_vm_run((m),(p),(s),(k)) + +MRB_API void mrb_p(mrb_state*, mrb_value); +MRB_API mrb_int mrb_obj_id(mrb_value obj); +MRB_API mrb_sym mrb_obj_to_sym(mrb_state *mrb, mrb_value name); + +MRB_API mrb_bool mrb_obj_eq(mrb_state *mrb, mrb_value a, mrb_value b); +MRB_API mrb_bool mrb_obj_equal(mrb_state *mrb, mrb_value a, mrb_value b); +MRB_API mrb_bool mrb_equal(mrb_state *mrb, mrb_value obj1, mrb_value obj2); +#ifndef MRB_NO_FLOAT +MRB_API mrb_value mrb_ensure_float_type(mrb_state *mrb, mrb_value val); +#define mrb_as_float(mrb, x) mrb_float(mrb_ensure_float_type(mrb, x)) +/* obsolete: use mrb_ensure_float_type() instead */ +#define mrb_to_float(mrb, val) mrb_ensure_float_type(mrb, val) +#endif +MRB_API mrb_value mrb_inspect(mrb_state *mrb, mrb_value obj); +MRB_API mrb_bool mrb_eql(mrb_state *mrb, mrb_value obj1, mrb_value obj2); +/* mrb_cmp(mrb, obj1, obj2): 1:0:-1; -2 for error */ +MRB_API mrb_int mrb_cmp(mrb_state *mrb, mrb_value obj1, mrb_value obj2); + +#define mrb_gc_arena_save(mrb) ((mrb)->gc.arena_idx) +#define mrb_gc_arena_restore(mrb, idx) ((mrb)->gc.arena_idx = (idx)) + +MRB_API void mrb_garbage_collect(mrb_state*); +MRB_API void mrb_full_gc(mrb_state*); +MRB_API void mrb_incremental_gc(mrb_state*); +MRB_API void mrb_gc_mark(mrb_state*,struct RBasic*); +#define mrb_gc_mark_value(mrb,val) do {\ + if (!mrb_immediate_p(val)) mrb_gc_mark((mrb), mrb_basic_ptr(val)); \ +} while (0) +MRB_API void mrb_field_write_barrier(mrb_state*, struct RBasic*, struct RBasic*); +#define mrb_field_write_barrier_value(mrb, obj, val) do{\ + if (!mrb_immediate_p(val)) mrb_field_write_barrier((mrb), (obj), mrb_basic_ptr(val)); \ +} while (0) +MRB_API void mrb_write_barrier(mrb_state *, struct RBasic*); + +MRB_API mrb_value mrb_type_convert(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym method); +#define mrb_convert_type(mrb, val, type, tname, method) mrb_type_convert(mrb, val, type, mrb_intern_lit(mrb, method)) +MRB_API mrb_value mrb_type_convert_check(mrb_state *mrb, mrb_value val, enum mrb_vtype type, mrb_sym method); +#define mrb_check_convert_type(mrb, val, type, tname, method) mrb_type_convert_check(mrb, val, type, mrb_intern_lit(mrb, method)) + +MRB_API mrb_value mrb_any_to_s(mrb_state *mrb, mrb_value obj); +MRB_API const char * mrb_obj_classname(mrb_state *mrb, mrb_value obj); +MRB_API struct RClass* mrb_obj_class(mrb_state *mrb, mrb_value obj); +MRB_API mrb_value mrb_class_path(mrb_state *mrb, struct RClass *c); +MRB_API mrb_bool mrb_obj_is_kind_of(mrb_state *mrb, mrb_value obj, struct RClass *c); +MRB_API mrb_value mrb_obj_inspect(mrb_state *mrb, mrb_value self); +MRB_API mrb_value mrb_obj_clone(mrb_state *mrb, mrb_value self); + +#ifndef ISPRINT +#define ISASCII(c) ((unsigned)(c) <= 0x7f) +#define ISPRINT(c) (((unsigned)(c) - 0x20) < 0x5f) +#define ISSPACE(c) ((c) == ' ' || (unsigned)(c) - '\t' < 5) +#define ISUPPER(c) (((unsigned)(c) - 'A') < 26) +#define ISLOWER(c) (((unsigned)(c) - 'a') < 26) +#define ISALPHA(c) ((((unsigned)(c) | 0x20) - 'a') < 26) +#define ISDIGIT(c) (((unsigned)(c) - '0') < 10) +#define ISXDIGIT(c) (ISDIGIT(c) || ((unsigned)(c) | 0x20) - 'a' < 6) +#define ISALNUM(c) (ISALPHA(c) || ISDIGIT(c)) +#define ISBLANK(c) ((c) == ' ' || (c) == '\t') +#define ISCNTRL(c) ((unsigned)(c) < 0x20 || (c) == 0x7f) +#define TOUPPER(c) (ISLOWER(c) ? ((c) & 0x5f) : (c)) +#define TOLOWER(c) (ISUPPER(c) ? ((c) | 0x20) : (c)) +#endif + +MRB_API mrb_value mrb_exc_new(mrb_state *mrb, struct RClass *c, const char *ptr, mrb_int len); +MRB_API mrb_noreturn void mrb_exc_raise(mrb_state *mrb, mrb_value exc); + +MRB_API mrb_noreturn void mrb_raise(mrb_state *mrb, struct RClass *c, const char *msg); +MRB_API mrb_noreturn void mrb_raisef(mrb_state *mrb, struct RClass *c, const char *fmt, ...); +MRB_API mrb_noreturn void mrb_name_error(mrb_state *mrb, mrb_sym id, const char *fmt, ...); +MRB_API mrb_noreturn void mrb_frozen_error(mrb_state *mrb, void *frozen_obj); +MRB_API mrb_noreturn void mrb_argnum_error(mrb_state *mrb, mrb_int argc, int min, int max); +MRB_API void mrb_warn(mrb_state *mrb, const char *fmt, ...); +MRB_API mrb_noreturn void mrb_bug(mrb_state *mrb, const char *mesg); +MRB_API void mrb_print_backtrace(mrb_state *mrb); +MRB_API void mrb_print_error(mrb_state *mrb); +/* function for `raisef` formatting */ +MRB_API mrb_value mrb_vformat(mrb_state *mrb, const char *format, va_list ap); + +/* macros to get typical exception objects + note: + + those E_* macros requires mrb_state* variable named mrb. + + exception objects obtained from those macros are local to mrb +*/ +#define MRB_ERROR_SYM(sym) mrb_intern_lit(mrb, #sym) +#define E_EXCEPTION mrb->eException_class +#define E_STANDARD_ERROR mrb->eStandardError_class +#define E_RUNTIME_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(RuntimeError)) +#define E_TYPE_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(TypeError)) +#define E_ZERODIV_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(ZeroDivisionError)) +#define E_ARGUMENT_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(ArgumentError)) +#define E_INDEX_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(IndexError)) +#define E_RANGE_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(RangeError)) +#define E_NAME_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(NameError)) +#define E_NOMETHOD_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(NoMethodError)) +#define E_SCRIPT_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(ScriptError)) +#define E_SYNTAX_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(SyntaxError)) +#define E_LOCALJUMP_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(LocalJumpError)) +#define E_REGEXP_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(RegexpError)) +#define E_FROZEN_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(FrozenError)) +#define E_NOTIMP_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(NotImplementedError)) +#define E_KEY_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(KeyError)) +#ifndef MRB_NO_FLOAT +# define E_FLOATDOMAIN_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(FloatDomainError)) +#endif + +MRB_API mrb_value mrb_yield(mrb_state *mrb, mrb_value b, mrb_value arg); +MRB_API mrb_value mrb_yield_argv(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value *argv); +MRB_API mrb_value mrb_yield_with_class(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value *argv, mrb_value self, struct RClass *c); + +/* continue execution to the proc */ +/* this function should always be called as the last function of a method */ +/* e.g. return mrb_yield_cont(mrb, proc, self, argc, argv); */ +mrb_value mrb_yield_cont(mrb_state *mrb, mrb_value b, mrb_value self, mrb_int argc, const mrb_value *argv); + +/* mrb_gc_protect() leaves the object in the arena */ +MRB_API void mrb_gc_protect(mrb_state *mrb, mrb_value obj); +/* mrb_gc_register() keeps the object from GC. */ +MRB_API void mrb_gc_register(mrb_state *mrb, mrb_value obj); +/* mrb_gc_unregister() removes the object from GC root. */ +MRB_API void mrb_gc_unregister(mrb_state *mrb, mrb_value obj); + +/* type conversion/check functions */ +MRB_API mrb_value mrb_ensure_array_type(mrb_state *mrb, mrb_value self); +MRB_API mrb_value mrb_check_array_type(mrb_state *mrb, mrb_value self); +MRB_API mrb_value mrb_ensure_hash_type(mrb_state *mrb, mrb_value hash); +MRB_API mrb_value mrb_check_hash_type(mrb_state *mrb, mrb_value hash); +MRB_API mrb_value mrb_ensure_string_type(mrb_state *mrb, mrb_value str); +MRB_API mrb_value mrb_check_string_type(mrb_state *mrb, mrb_value str); +/* obsolete: use mrb_ensure_string_type() instead */ +#define mrb_string_type(mrb, str) mrb_ensure_string_type(mrb,str) +#define mrb_to_str(mrb, str) mrb_ensure_string_type(mrb,str) +/* obsolete: use mrb_obj_as_string() instead */ +#define mrb_str_to_str(mrb, str) mrb_obj_as_string(mrb, str) +/* check if val is an integer (including Bigint) */ +MRB_API mrb_value mrb_ensure_integer_type(mrb_state *mrb, mrb_value val); +/* check if val fit in mrb_int */ +MRB_API mrb_value mrb_ensure_int_type(mrb_state *mrb, mrb_value val); +#define mrb_as_int(mrb, val) mrb_integer(mrb_ensure_int_type(mrb, val)) +/* obsolete: use mrb_ensure_int_type() instead */ +#define mrb_to_integer(mrb, val) mrb_ensure_int_type(mrb, val) +#define mrb_to_int(mrb, val) mrb_ensure_int_type(mrb, val) + +/* string type checking (contrary to the name, it doesn't convert) */ +MRB_API void mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t); +MRB_API void mrb_check_frozen(mrb_state *mrb, void *); +MRB_API void mrb_check_frozen_value(mrb_state *mrb, mrb_value v); +MRB_API void mrb_define_alias(mrb_state *mrb, struct RClass *c, const char *a, const char *b); +MRB_API void mrb_define_alias_id(mrb_state *mrb, struct RClass *c, mrb_sym a, mrb_sym b); +MRB_API const char *mrb_class_name(mrb_state *mrb, struct RClass* klass); +MRB_API void mrb_define_global_const(mrb_state *mrb, const char *name, mrb_value val); + +MRB_API mrb_value mrb_attr_get(mrb_state *mrb, mrb_value obj, mrb_sym id); + +MRB_API mrb_bool mrb_respond_to(mrb_state *mrb, mrb_value obj, mrb_sym mid); +MRB_API mrb_bool mrb_obj_is_instance_of(mrb_state *mrb, mrb_value obj, const struct RClass* c); +MRB_API mrb_bool mrb_func_basic_p(mrb_state *mrb, mrb_value obj, mrb_sym mid, mrb_func_t func); + +/* obsolete function(s); will be removed */ +#define mrb_int(mrb, val) mrb_as_int(mrb, val) + +/** + * Create a new Fiber from proc object + * + * Implemented in mruby-fiber + */ +MRB_API mrb_value mrb_fiber_new(mrb_state *mrb, const struct RProc *proc); + +/** + * Resume a Fiber + * + * Implemented in mruby-fiber + * + * Switches to the specified fiber and executes. Like the `Fiber#resume` method. + */ +MRB_API mrb_value mrb_fiber_resume(mrb_state *mrb, mrb_value fib, mrb_int argc, const mrb_value *argv); + +/** + * Yield a Fiber + * + * Implemented in mruby-fiber + * + * Passes control to the caller fiber of the running fiber. Like the `Fiber.yield` method. + * + * @note This function is only available from inside a function defined as a method by, + * for example, `mrb_define_method()`. + * Also, the work following `mrb_fiber_yield()` cannot be performed, + * and the return value of `mrb_fiber_yield()` must be returned as is. + * + * return mrb_fiber_yield(mrb, argc, argv); + */ +MRB_API mrb_value mrb_fiber_yield(mrb_state *mrb, mrb_int argc, const mrb_value *argv); + +/** + * Check if a Fiber is alive + * + * Implemented in mruby-fiber + */ +MRB_API mrb_value mrb_fiber_alive_p(mrb_state *mrb, mrb_value fib); + +/** + * FiberError reference + * + * Implemented in mruby-fiber + */ +#define E_FIBER_ERROR mrb_exc_get_id(mrb, MRB_ERROR_SYM(FiberError)) +MRB_API void mrb_stack_extend(mrb_state*, mrb_int); + +/* temporary memory allocation, only effective while GC arena is kept */ +MRB_API void* mrb_alloca(mrb_state *mrb, size_t); + +MRB_API void mrb_state_atexit(mrb_state *mrb, mrb_atexit_func func); + +MRB_API void mrb_show_version(mrb_state *mrb); +MRB_API void mrb_show_copyright(mrb_state *mrb); + +MRB_API mrb_value mrb_format(mrb_state *mrb, const char *format, ...); + +#ifdef MRB_PRESYM_SCANNING +# include +#endif + +#if 0 +/* memcpy and memset does not work with gdb reverse-next on my box */ +/* use naive memcpy and memset instead */ +#undef memcpy +#undef memset +static void* +mrbmemcpy(void *dst, const void *src, size_t n) +{ + char *d = (char*)dst; + const char *s = (const char*)src; + while (n--) + *d++ = *s++; + return d; +} +#define memcpy(a,b,c) mrbmemcpy(a,b,c) + +static void* +mrbmemset(void *s, int c, size_t n) +{ + char *t = (char*)s; + while (n--) + *t++ = c; + return s; +} +#define memset(a,b,c) mrbmemset(a,b,c) +#endif + +#define mrb_int_hash_func(mrb,key) (uint32_t)((key)^((key)<<2)^((key)>>2)) + +MRB_END_DECL + +#endif /* MRUBY_H */ diff --git a/deps/mruby/include/mruby/array.h b/deps/mruby/include/mruby/array.h new file mode 100644 index 0000000..df5a16a --- /dev/null +++ b/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 */ diff --git a/deps/mruby/include/mruby/boxing_nan.h b/deps/mruby/include/mruby/boxing_nan.h new file mode 100644 index 0000000..d76759a --- /dev/null +++ b/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 */ diff --git a/deps/mruby/include/mruby/boxing_no.h b/deps/mruby/include/mruby/boxing_no.h new file mode 100644 index 0000000..efb108b --- /dev/null +++ b/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 */ diff --git a/deps/mruby/include/mruby/boxing_word.h b/deps/mruby/include/mruby/boxing_word.h new file mode 100644 index 0000000..80736ad --- /dev/null +++ b/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 */ diff --git a/deps/mruby/include/mruby/class.h b/deps/mruby/include/mruby/class.h new file mode 100644 index 0000000..5be1b8e --- /dev/null +++ b/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 */ diff --git a/deps/mruby/include/mruby/common.h b/deps/mruby/include/mruby/common.h new file mode 100644 index 0000000..e70fd40 --- /dev/null +++ b/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 +#if defined _MSC_VER +#include +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 */ diff --git a/deps/mruby/include/mruby/compile.h b/deps/mruby/include/mruby/compile.h new file mode 100644 index 0000000..652cb73 --- /dev/null +++ b/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 + +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 */ diff --git a/deps/mruby/include/mruby/data.h b/deps/mruby/include/mruby/data.h new file mode 100644 index 0000000..a64301a --- /dev/null +++ b/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 */ diff --git a/deps/mruby/include/mruby/debug.h b/deps/mruby/include/mruby/debug.h new file mode 100644 index 0000000..f040935 --- /dev/null +++ b/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 */ diff --git a/deps/mruby/include/mruby/dump.h b/deps/mruby/include/mruby/dump.h new file mode 100644 index 0000000..1f587bc --- /dev/null +++ b/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 +#include +#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 */ diff --git a/deps/mruby/include/mruby/endian.h b/deps/mruby/include/mruby/endian.h new file mode 100644 index 0000000..940c47e --- /dev/null +++ b/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 + +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 */ diff --git a/deps/mruby/include/mruby/error.h b/deps/mruby/include/mruby/error.h new file mode 100644 index 0000000..e8c63dc --- /dev/null +++ b/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 and */ +#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 */ diff --git a/deps/mruby/include/mruby/gc.h b/deps/mruby/include/mruby/gc.h new file mode 100644 index 0000000..6ed8211 --- /dev/null +++ b/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 */ diff --git a/deps/mruby/include/mruby/gems/mruby-io/include/mruby/ext/io.h b/deps/mruby/include/mruby/gems/mruby-io/include/mruby/ext/io.h new file mode 100644 index 0000000..a12903f --- /dev/null +++ b/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 + +#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 */ diff --git a/deps/mruby/include/mruby/gems/mruby-time/include/mruby/time.h b/deps/mruby/include/mruby/gems/mruby-time/include/mruby/time.h new file mode 100644 index 0000000..9149e0a --- /dev/null +++ b/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 +#include + +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 */ diff --git a/deps/mruby/include/mruby/hash.h b/deps/mruby/include/mruby/hash.h new file mode 100644 index 0000000..e591172 --- /dev/null +++ b/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 */ diff --git a/deps/mruby/include/mruby/internal.h b/deps/mruby/include/mruby/internal.h new file mode 100644 index 0000000..b8387b3 --- /dev/null +++ b/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 */ diff --git a/deps/mruby/include/mruby/irep.h b/deps/mruby/include/mruby/irep.h new file mode 100644 index 0000000..924e722 --- /dev/null +++ b/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 + +/** + * 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 */ diff --git a/deps/mruby/include/mruby/istruct.h b/deps/mruby/include/mruby/istruct.h new file mode 100644 index 0000000..d36d280 --- /dev/null +++ b/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 + +/** + * 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 */ diff --git a/deps/mruby/include/mruby/khash.h b/deps/mruby/include/mruby/khash.h new file mode 100644 index 0000000..c603204 --- /dev/null +++ b/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 + +#include +#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; isize >= 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 */ diff --git a/deps/mruby/include/mruby/mempool.h b/deps/mruby/include/mruby/mempool.h new file mode 100644 index 0000000..d669001 --- /dev/null +++ b/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); diff --git a/deps/mruby/include/mruby/numeric.h b/deps/mruby/include/mruby/numeric.h new file mode 100644 index 0000000..48adea3 --- /dev/null +++ b/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 */ diff --git a/deps/mruby/include/mruby/object.h b/deps/mruby/include/mruby/object.h new file mode 100644 index 0000000..57e56dc --- /dev/null +++ b/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 */ diff --git a/deps/mruby/include/mruby/opcode.h b/deps/mruby/include/mruby/opcode.h new file mode 100644 index 0000000..a0f6644 --- /dev/null +++ b/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 +#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 */ diff --git a/deps/mruby/include/mruby/ops.h b/deps/mruby/include/mruby/ops.h new file mode 100644 index 0000000..05bf30f --- /dev/null +++ b/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(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 */ diff --git a/deps/mruby/include/mruby/presym.h b/deps/mruby/include/mruby/presym.h new file mode 100644 index 0000000..7c6374a --- /dev/null +++ b/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 +#elif !defined(MRB_PRESYM_SCANNING) +# include +#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 */ diff --git a/deps/mruby/include/mruby/presym/disable.h b/deps/mruby/include/mruby/presym/disable.h new file mode 100644 index 0000000..6708858 --- /dev/null +++ b/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 + +#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 */ diff --git a/deps/mruby/include/mruby/presym/enable.h b/deps/mruby/include/mruby/presym/enable.h new file mode 100644 index 0000000..44b6064 --- /dev/null +++ b/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 + +#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 */ diff --git a/deps/mruby/include/mruby/presym/id.h b/deps/mruby/include/mruby/presym/id.h new file mode 100644 index 0000000..db38206 --- /dev/null +++ b/deps/mruby/include/mruby/presym/id.h @@ -0,0 +1,1489 @@ +enum mruby_presym { + MRB_OPSYM__not = 1, + MRB_OPSYM__mod = 2, + MRB_OPSYM__and = 3, + MRB_OPSYM__mul = 4, + MRB_OPSYM__add = 5, + MRB_OPSYM__sub = 6, + MRB_OPSYM__div = 7, + MRB_OPSYM__lt = 8, + MRB_OPSYM__gt = 9, + MRB_SYM__E = 10, + MRB_OPSYM__xor = 11, + MRB_OPSYM__tick = 12, + MRB_SYM__a = 13, + MRB_SYM__b = 14, + MRB_SYM__c = 15, + MRB_SYM__d = 16, + MRB_SYM__e = 17, + MRB_SYM__f = 18, + MRB_SYM__h = 19, + MRB_SYM__i = 20, + MRB_SYM__j = 21, + MRB_SYM__k = 22, + MRB_SYM__l = 23, + MRB_SYM__m = 24, + MRB_SYM__n = 25, + MRB_SYM__o = 26, + MRB_SYM__p = 27, + MRB_SYM__r = 28, + MRB_SYM__s = 29, + MRB_SYM__t = 30, + MRB_SYM__v = 31, + MRB_SYM__w = 32, + MRB_SYM__x = 33, + MRB_SYM__y = 34, + MRB_SYM__z = 35, + MRB_OPSYM__or = 36, + MRB_OPSYM__neg = 37, + MRB_OPSYM__neq = 38, + MRB_OPSYM__nmatch = 39, + MRB_OPSYM__andand = 42, + MRB_OPSYM__pow = 43, + MRB_OPSYM__plus = 44, + MRB_OPSYM__minus = 45, + MRB_OPSYM__lshift = 46, + MRB_OPSYM__le = 47, + MRB_OPSYM__eq = 48, + MRB_OPSYM__match = 49, + MRB_OPSYM__ge = 50, + MRB_OPSYM__rshift = 51, + MRB_SYM__GC = 52, + MRB_SYM__IO = 53, + MRB_SYM__PI = 54, + MRB_OPSYM__aref = 55, + MRB_SYM__af = 56, + MRB_SYM__ai = 57, + MRB_SYM__ar = 58, + MRB_SYM__at = 59, + MRB_SYM__bi = 60, + MRB_SYM__bs = 61, + MRB_SYM__cp = 62, + MRB_SYM__e0 = 63, + MRB_SYM__e2 = 64, + MRB_SYM__e3 = 65, + MRB_SYM__ed = 66, + MRB_SYM__ei = 67, + MRB_SYM__fd = 68, + MRB_SYM__gm = 69, + MRB_SYM__in = 70, + MRB_SYM__io = 71, + MRB_SYM__ip = 72, + MRB_SYM__lz = 73, + MRB_SYM__nv = 74, + MRB_SYM__pc = 75, + MRB_SYM__sa = 76, + MRB_SYM__sv = 77, + MRB_SYM__tr = 78, + MRB_SYM__vs = 79, + MRB_SYM__wd = 80, + MRB_OPSYM__oror = 81, + MRB_OPSYM__cmp = 82, + MRB_OPSYM__eqq = 83, + MRB_IVSYM__af = 84, + MRB_SYM__DIG = 85, + MRB_SYM__Dir = 86, + MRB_SYM__EIO = 87, + MRB_SYM__MAX = 88, + MRB_SYM__MIN = 89, + MRB_SYM__NAN = 90, + MRB_SYM__Set = 91, + MRB_OPSYM__aset = 92, + MRB_SYM__abs = 93, + MRB_SYM__add = 94, + MRB_SYM__arg = 95, + MRB_SYM__arr = 96, + MRB_SYM__ary = 97, + MRB_SYM__beg = 98, + MRB_SYM__blk = 99, + MRB_SYM__chr = 100, + MRB_SYM__cmd = 101, + MRB_SYM__cmp = 102, + MRB_SYM__cos = 103, + MRB_SYM__day = 104, + MRB_SYM__dig = 105, + MRB_SYM__div = 106, + MRB_SYM__dup = 107, + MRB_SYM__end = 108, + MRB_SYM__env = 109, + MRB_SYM__eof = 110, + MRB_SYM__erf = 111, + MRB_SYM__err = 112, + MRB_SYM__exp = 113, + MRB_SYM__fib = 114, + MRB_SYM__hex = 115, + MRB_SYM__idx = 116, + MRB_SYM__int = 117, + MRB_SYM_Q__ip = 118, + MRB_SYM__key = 119, + MRB_SYM__kwd = 120, + MRB_SYM__len = 121, + MRB_SYM__lhs = 122, + MRB_SYM__lim = 123, + MRB_SYM__log = 124, + MRB_SYM__low = 125, + MRB_SYM__map = 126, + MRB_SYM__max = 127, + MRB_SYM__mid = 128, + MRB_SYM__min = 129, + MRB_SYM__mod = 130, + MRB_SYM__mon = 131, + MRB_SYM__msg = 132, + MRB_SYM__new = 133, + MRB_SYM__now = 134, + MRB_SYM__num = 135, + MRB_SYM__obj = 136, + MRB_SYM__oct = 137, + MRB_SYM__opt = 138, + MRB_SYM__ord = 139, + MRB_SYM__out = 140, + MRB_SYM__pat = 141, + MRB_SYM__pid = 142, + MRB_SYM__pop = 143, + MRB_SYM__pos = 144, + MRB_SYM__pow = 145, + MRB_SYM__pre = 146, + MRB_SYM__pwd = 147, + MRB_SYM__quo = 148, + MRB_SYM__red = 149, + MRB_SYM__req = 150, + MRB_SYM__res = 151, + MRB_SYM__rhs = 152, + MRB_SYM__row = 153, + MRB_SYM__sec = 154, + MRB_SYM__sep = 155, + MRB_SYM__set = 156, + MRB_SYM__sin = 157, + MRB_SYM__str = 158, + MRB_SYM__sub = 159, + MRB_SYM__sum = 160, + MRB_SYM__sym = 161, + MRB_SYM__tag = 162, + MRB_SYM__tan = 163, + MRB_SYM__tap = 164, + MRB_SYM__tcp = 165, + MRB_SYM__tmp = 166, + MRB_SYM_B__tr = 167, + MRB_SYM__udp = 168, + MRB_SYM__utc = 169, + MRB_SYM__val = 170, + MRB_SYM__zip = 171, + MRB_IVSYM__dst = 172, + MRB_IVSYM__fib = 173, + MRB_IVSYM__kwd = 174, + MRB_IVSYM__obj = 175, + MRB_IVSYM__pos = 176, + MRB_IVSYM__tag = 177, + MRB_SYM__ARGV = 178, + MRB_SYM__Data = 179, + MRB_SYM__EADV = 180, + MRB_SYM__EDOM = 181, + MRB_SYM__EXCL = 182, + MRB_SYM__FREE = 183, + MRB_SYM__File = 184, + MRB_SYM__Hash = 185, + MRB_SYM__JSON = 186, + MRB_SYM__Lazy = 187, + MRB_SYM__Math = 188, + MRB_SYM__NONE = 189, + MRB_SYM__NULL = 190, + MRB_SYM__Proc = 191, + MRB_SYM__RDWR = 192, + MRB_SYM__SYNC = 193, + MRB_SYM__Time = 194, + MRB_SYM__abs2 = 195, + MRB_SYM__acos = 196, + MRB_SYM_Q__add = 197, + MRB_SYM__addr = 198, + MRB_SYM_Q__all = 199, + MRB_SYM_Q__any = 200, + MRB_SYM__arg0 = 201, + MRB_SYM__arg1 = 202, + MRB_SYM__arg2 = 203, + MRB_SYM__args = 204, + MRB_SYM__argv = 205, + MRB_SYM__arys = 206, + MRB_SYM__asin = 207, + MRB_SYM__atan = 208, + MRB_SYM__attr = 209, + MRB_SYM__bind = 210, + MRB_SYM__blue = 211, + MRB_SYM__bold = 212, + MRB_SYM__bool = 213, + MRB_SYM__bsiz = 214, + MRB_SYM__byte = 215, + MRB_SYM__call = 216, + MRB_SYM__cbrt = 217, + MRB_SYM__ceil = 218, + MRB_SYM__char = 219, + MRB_SYM__chop = 220, + MRB_SYM__conj = 221, + MRB_SYM__cosh = 222, + MRB_SYM__curr = 223, + MRB_SYM__cyan = 224, + MRB_SYM__data = 225, + MRB_SYM__drop = 226, + MRB_SYM_Q__dst = 227, + MRB_SYM__dump = 228, + MRB_SYM__e_id = 229, + MRB_SYM__each = 230, + MRB_SYM__elem = 231, + MRB_SYM__enum = 232, + MRB_SYM_Q__eof = 233, + MRB_SYM__epos = 234, + MRB_SYM_Q__eql = 235, + MRB_SYM__erfc = 236, + MRB_SYM__eval = 237, + MRB_SYM__exit = 238, + MRB_SYM__fail = 239, + MRB_SYM__fdiv = 240, + MRB_SYM__feed = 241, + MRB_SYM__file = 242, + MRB_SYM__fill = 243, + MRB_SYM__find = 244, + MRB_SYM__flag = 245, + MRB_SYM__func = 246, + MRB_SYM__getc = 247, + MRB_SYM__gets = 248, + MRB_SYM_Q__gmt = 249, + MRB_SYM__gray = 250, + MRB_SYM__grep = 251, + MRB_SYM__gsub = 252, + MRB_SYM__hash = 253, + MRB_SYM__high = 254, + MRB_SYM__host = 255, + MRB_SYM__hour = 256, + MRB_SYM__idx2 = 257, + MRB_SYM__imag = 258, + MRB_SYM__init = 259, + MRB_SYM__join = 260, + MRB_SYM__json = 261, + MRB_SYM_Q__key = 262, + MRB_SYM__keys = 263, + MRB_SYM__last = 264, + MRB_SYM__lazy = 265, + MRB_SYM__line = 266, + MRB_SYM__list = 267, + MRB_SYM__load = 268, + MRB_SYM__log2 = 269, + MRB_SYM__loop = 270, + MRB_SYM_B__map = 271, + MRB_SYM__mask = 272, + MRB_SYM__mday = 273, + MRB_SYM__mesg = 274, + MRB_SYM__meth = 275, + MRB_SYM__mode = 276, + MRB_SYM__name = 277, + MRB_SYM_Q__nan = 278, + MRB_SYM__next = 279, + MRB_SYM_Q__nil = 280, + MRB_SYM__none = 281, + MRB_SYM__ntop = 282, + MRB_SYM_Q__odd = 283, + MRB_SYM_Q__one = 284, + MRB_SYM__open = 285, + MRB_SYM__opts = 286, + MRB_SYM__orig = 287, + MRB_SYM__pack = 288, + MRB_SYM__pad1 = 289, + MRB_SYM__pad2 = 290, + MRB_SYM__pair = 291, + MRB_SYM__path = 292, + MRB_SYM__peek = 293, + MRB_SYM__perm = 294, + MRB_SYM__pipe = 295, + MRB_SYM__plen = 296, + MRB_SYM__port = 297, + MRB_SYM_E__pos = 298, + MRB_SYM__proc = 299, + MRB_SYM__pton = 300, + MRB_SYM__push = 301, + MRB_SYM__puts = 302, + MRB_SYM__rand = 303, + MRB_SYM__read = 304, + MRB_SYM__real = 305, + MRB_SYM__rect = 306, + MRB_SYM__recv = 307, + MRB_SYM__rest = 308, + MRB_SYM__sary = 309, + MRB_SYM__seek = 310, + MRB_SYM__seen = 311, + MRB_SYM__send = 312, + MRB_SYM__sinh = 313, + MRB_SYM__size = 314, + MRB_SYM__sock = 315, + MRB_SYM__sort = 316, + MRB_SYM__sqrt = 317, + MRB_SYM__step = 318, + MRB_SYM__str2 = 319, + MRB_SYM_B__sub = 320, + MRB_SYM__succ = 321, + MRB_SYM__sync = 322, + MRB_SYM__take = 323, + MRB_SYM__tanh = 324, + MRB_SYM__tell = 325, + MRB_SYM__then = 326, + MRB_SYM__to_a = 327, + MRB_SYM__to_c = 328, + MRB_SYM__to_f = 329, + MRB_SYM__to_h = 330, + MRB_SYM__to_i = 331, + MRB_SYM__to_r = 332, + MRB_SYM__to_s = 333, + MRB_SYM__tr_s = 334, + MRB_SYM_Q__tty = 335, + MRB_SYM__type = 336, + MRB_SYM__uniq = 337, + MRB_SYM__unix = 338, + MRB_SYM__upto = 339, + MRB_SYM__usec = 340, + MRB_SYM_Q__utc = 341, + MRB_SYM__vals = 342, + MRB_SYM__wday = 343, + MRB_SYM__yday = 344, + MRB_SYM__year = 345, + MRB_SYM__zone = 346, + MRB_IVSYM__args = 347, + MRB_IVSYM__hash = 348, + MRB_IVSYM__meth = 349, + MRB_IVSYM__name = 350, + MRB_IVSYM__path = 351, + MRB_IVSYM__proc = 352, + MRB_IVSYM__size = 353, + MRB_SYM__Array = 354, + MRB_SYM__CMath = 355, + MRB_SYM__CREAT = 356, + MRB_SYM__Chain = 357, + MRB_SYM__Class = 358, + MRB_SYM__DSYNC = 359, + MRB_SYM__E2BIG = 360, + MRB_SYM__EAUTH = 361, + MRB_SYM__EBADE = 362, + MRB_SYM__EBADF = 363, + MRB_SYM__EBADR = 364, + MRB_SYM__EBUSY = 365, + MRB_SYM__ECOMM = 366, + MRB_SYM__EFBIG = 367, + MRB_SYM__EIDRM = 368, + MRB_SYM__EINTR = 369, + MRB_SYM__ELOOP = 370, + MRB_SYM__ENOSR = 371, + MRB_SYM__ENXIO = 372, + MRB_SYM__EPERM = 373, + MRB_SYM__EPIPE = 374, + MRB_SYM__EROFS = 375, + MRB_SYM__ESRCH = 376, + MRB_SYM__ETIME = 377, + MRB_SYM__EXDEV = 378, + MRB_SYM__Errno = 379, + MRB_SYM__Fiber = 380, + MRB_SYM__Float = 381, + MRB_SYM__RADIX = 382, + MRB_SYM__RSYNC = 383, + MRB_SYM__Range = 384, + MRB_SYM__STDIN = 385, + MRB_SYM__TOTAL = 386, + MRB_SYM__TRUNC = 387, + MRB_SYM__T_ENV = 388, + MRB_SYM__UTF_8 = 389, + MRB_SYM___bind = 390, + MRB_SYM___name = 391, + MRB_SYM___pipe = 392, + MRB_SYM___proc = 393, + MRB_SYM___recv = 394, + MRB_SYM__acosh = 395, + MRB_SYM__angle = 396, + MRB_SYM__arity = 397, + MRB_SYM__array = 398, + MRB_SYM__ary_F = 399, + MRB_SYM__ary_T = 400, + MRB_SYM__asinh = 401, + MRB_SYM__assoc = 402, + MRB_SYM__atan2 = 403, + MRB_SYM__atanh = 404, + MRB_SYM__atime = 405, + MRB_SYM__begin = 406, + MRB_SYM__black = 407, + MRB_SYM__blink = 408, + MRB_SYM__block = 409, + MRB_SYM__bytes = 410, + MRB_SYM__catch = 411, + MRB_SYM__chain = 412, + MRB_SYM__chars = 413, + MRB_SYM__chdir = 414, + MRB_SYM__chmod = 415, + MRB_SYM__chomp = 416, + MRB_SYM_B__chop = 417, + MRB_SYM__chunk = 418, + MRB_SYM__clamp = 419, + MRB_SYM__class = 420, + MRB_SYM__clear = 421, + MRB_SYM__clone = 422, + MRB_SYM__close = 423, + MRB_SYM__color = 424, + MRB_SYM__count = 425, + MRB_SYM__ctime = 426, + MRB_SYM__curry = 427, + MRB_SYM__cycle = 428, + MRB_SYM__depth = 429, + MRB_SYM__enums = 430, + MRB_SYM__errno = 431, + MRB_SYM_Q__even = 432, + MRB_SYM_B__exit = 433, + MRB_SYM__fetch = 434, + MRB_SYM__field = 435, + MRB_SYM_Q__file = 436, + MRB_SYM__first = 437, + MRB_SYM__flags = 438, + MRB_SYM__flock = 439, + MRB_SYM__floor = 440, + MRB_SYM__flush = 441, + MRB_SYM__fname = 442, + MRB_SYM__force = 443, + MRB_SYM__found = 444, + MRB_SYM__frexp = 445, + MRB_SYM__getgm = 446, + MRB_SYM__getwd = 447, + MRB_SYM__green = 448, + MRB_SYM__group = 449, + MRB_SYM_B__gsub = 450, + MRB_SYM__hypot = 451, + MRB_SYM__index = 452, + MRB_SYM_Q__ipv4 = 453, + MRB_SYM_Q__ipv6 = 454, + MRB_SYM_Q__is_a = 455, + MRB_SYM__ldexp = 456, + MRB_SYM__level = 457, + MRB_SYM__lines = 458, + MRB_SYM__ljust = 459, + MRB_SYM__local = 460, + MRB_SYM__log10 = 461, + MRB_SYM__merge = 462, + MRB_SYM__mkdir = 463, + MRB_SYM__month = 464, + MRB_SYM__mtime = 465, + MRB_SYM__names = 466, + MRB_SYM_B__next = 467, + MRB_SYM_Q__none = 468, + MRB_SYM__other = 469, + MRB_SYM__owner = 470, + MRB_SYM__parse = 471, + MRB_SYM__phase = 472, + MRB_SYM_Q__pipe = 473, + MRB_SYM__polar = 474, + MRB_SYM__popen = 475, + MRB_SYM__pproc = 476, + MRB_SYM__pread = 477, + MRB_SYM__print = 478, + MRB_SYM__proto = 479, + MRB_SYM__raise = 480, + MRB_SYM_Q__real = 481, + MRB_SYM__reset = 482, + MRB_SYM__rjust = 483, + MRB_SYM__rmdir = 484, + MRB_SYM__round = 485, + MRB_SYM__shift = 486, + MRB_SYM_Q__size = 487, + MRB_SYM__sleep = 488, + MRB_SYM__slice = 489, + MRB_SYM_B__sort = 490, + MRB_SYM__split = 491, + MRB_SYM__srand = 492, + MRB_SYM__start = 493, + MRB_SYM__state = 494, + MRB_SYM__store = 495, + MRB_SYM__strip = 496, + MRB_SYM_B__succ = 497, + MRB_SYM_E__sync = 498, + MRB_SYM__taken = 499, + MRB_SYM__tally = 500, + MRB_SYM__throw = 501, + MRB_SYM__times = 502, + MRB_SYM__to_io = 503, + MRB_SYM__total = 504, + MRB_SYM_B__tr_s = 505, + MRB_SYM__umask = 506, + MRB_SYM__union = 507, + MRB_SYM_B__uniq = 508, + MRB_SYM_Q__unix = 509, + MRB_SYM__value = 510, + MRB_SYM__white = 511, + MRB_SYM__width = 512, + MRB_SYM__write = 513, + MRB_SYM__yield = 514, + MRB_SYM_Q__zero = 515, + MRB_GVSYM__DEBUG = 516, + MRB_GVSYM__stdin = 517, + MRB_IVSYM__enums = 518, + MRB_IVSYM__value = 519, + MRB_SYM__AF_MAX = 520, + MRB_SYM__APPEND = 521, + MRB_SYM__BINARY = 522, + MRB_SYM__DIRECT = 523, + MRB_SYM__EACCES = 524, + MRB_SYM__EAGAIN = 525, + MRB_SYM__EBADFD = 526, + MRB_SYM__EBFONT = 527, + MRB_SYM__ECHILD = 528, + MRB_SYM__ECHRNG = 529, + MRB_SYM__EDQUOT = 530, + MRB_SYM__EEXIST = 531, + MRB_SYM__EFAULT = 532, + MRB_SYM__EFTYPE = 533, + MRB_SYM__EILSEQ = 534, + MRB_SYM__EINVAL = 535, + MRB_SYM__EIPSEC = 536, + MRB_SYM__EISDIR = 537, + MRB_SYM__EISNAM = 538, + MRB_SYM__EL2HLT = 539, + MRB_SYM__EL3HLT = 540, + MRB_SYM__EL3RST = 541, + MRB_SYM__ELNRNG = 542, + MRB_SYM__EMFILE = 543, + MRB_SYM__EMLINK = 544, + MRB_SYM__ENFILE = 545, + MRB_SYM__ENOANO = 546, + MRB_SYM__ENOCSI = 547, + MRB_SYM__ENODEV = 548, + MRB_SYM__ENOENT = 549, + MRB_SYM__ENOKEY = 550, + MRB_SYM__ENOLCK = 551, + MRB_SYM__ENOMEM = 552, + MRB_SYM__ENOMSG = 553, + MRB_SYM__ENONET = 554, + MRB_SYM__ENOPKG = 555, + MRB_SYM__ENOSPC = 556, + MRB_SYM__ENOSTR = 557, + MRB_SYM__ENOSYS = 558, + MRB_SYM__ENOTTY = 559, + MRB_SYM__EPROTO = 560, + MRB_SYM__EQFULL = 561, + MRB_SYM__ERANGE = 562, + MRB_SYM__ESPIPE = 563, + MRB_SYM__ESRMNT = 564, + MRB_SYM__ESTALE = 565, + MRB_SYM__EUSERS = 566, + MRB_SYM__EXFULL = 567, + MRB_SYM__Fixnum = 568, + MRB_SYM__IP_MTU = 569, + MRB_SYM__IP_TOS = 570, + MRB_SYM__IP_TTL = 571, + MRB_SYM__Kernel = 572, + MRB_SYM__Method = 573, + MRB_SYM__Module = 574, + MRB_SYM__NOCTTY = 575, + MRB_SYM__Object = 576, + MRB_SYM__Option = 577, + MRB_SYM__RDONLY = 578, + MRB_SYM__Random = 579, + MRB_SYM__Regexp = 580, + MRB_SYM__SOL_IP = 581, + MRB_SYM__STDERR = 582, + MRB_SYM__STDOUT = 583, + MRB_SYM__Socket = 584, + MRB_SYM__Status = 585, + MRB_SYM__String = 586, + MRB_SYM__Struct = 587, + MRB_SYM__Symbol = 588, + MRB_SYM__T_CPTR = 589, + MRB_SYM__T_DATA = 590, + MRB_SYM__T_HASH = 591, + MRB_SYM__T_PROC = 592, + MRB_SYM__WRONLY = 593, + MRB_SYM____id__ = 594, + MRB_SYM___alone = 595, + MRB_SYM___atime = 596, + MRB_SYM___chdir = 597, + MRB_SYM___ctime = 598, + MRB_SYM___klass = 599, + MRB_SYM___mtime = 600, + MRB_SYM___owner = 601, + MRB_SYM___popen = 602, + MRB_SYM__accept = 603, + MRB_SYM_Q__alive = 604, + MRB_SYM__append = 605, + MRB_SYM__caller = 606, + MRB_SYM__center = 607, + MRB_SYM_B__chomp = 608, + MRB_SYM__chroot = 609, + MRB_SYM__concat = 610, + MRB_SYM_Q__cover = 611, + MRB_SYM__define = 612, + MRB_SYM__delete = 613, + MRB_SYM__detect = 614, + MRB_SYM__digits = 615, + MRB_SYM__divide = 616, + MRB_SYM__divmod = 617, + MRB_SYM__domain = 618, + MRB_SYM__downto = 619, + MRB_SYM_Q__empty = 620, + MRB_SYM__enable = 621, + MRB_SYM_Q__equal = 622, + MRB_SYM__except = 623, + MRB_SYM_Q__exist = 624, + MRB_SYM__extend = 625, + MRB_SYM__family = 626, + MRB_SYM__fileno = 627, + MRB_SYM__filter = 628, + MRB_SYM__for_fd = 629, + MRB_SYM__format = 630, + MRB_SYM__freeze = 631, + MRB_SYM__getutc = 632, + MRB_SYM__gmtime = 633, + MRB_SYM__grep_v = 634, + MRB_SYM__ifnone = 635, + MRB_SYM__inject = 636, + MRB_SYM__insert = 637, + MRB_SYM__intern = 638, + MRB_SYM__invert = 639, + MRB_SYM__isatty = 640, + MRB_SYM__itself = 641, + MRB_SYM__lambda = 642, + MRB_SYM__length = 643, + MRB_SYM__linger = 644, + MRB_SYM__listen = 645, + MRB_SYM__longer = 646, + MRB_SYM__lstrip = 647, + MRB_SYM__max_by = 648, + MRB_SYM__maxlen = 649, + MRB_SYM_B__merge = 650, + MRB_SYM__method = 651, + MRB_SYM__min_by = 652, + MRB_SYM__minmax = 653, + MRB_SYM__mktime = 654, + MRB_SYM__modulo = 655, + MRB_SYM__object = 656, + MRB_SYM__offset = 657, + MRB_SYM__others = 658, + MRB_SYM__padstr = 659, + MRB_SYM__printf = 660, + MRB_SYM__public = 661, + MRB_SYM__pwrite = 662, + MRB_SYM__random = 663, + MRB_SYM__rassoc = 664, + MRB_SYM__reduce = 665, + MRB_SYM__rehash = 666, + MRB_SYM__reject = 667, + MRB_SYM__rename = 668, + MRB_SYM__result = 669, + MRB_SYM__resume = 670, + MRB_SYM__rewind = 671, + MRB_SYM__rindex = 672, + MRB_SYM__rotate = 673, + MRB_SYM__rstrip = 674, + MRB_SYM__sample = 675, + MRB_SYM__select = 676, + MRB_SYM_B__slice = 677, + MRB_SYM__status = 678, + MRB_SYM__string = 679, + MRB_SYM_B__strip = 680, + MRB_SYM__to_int = 681, + MRB_SYM__to_str = 682, + MRB_SYM__to_sym = 683, + MRB_SYM__unbind = 684, + MRB_SYM__ungetc = 685, + MRB_SYM__unlink = 686, + MRB_SYM__unpack = 687, + MRB_SYM__upcase = 688, + MRB_SYM__update = 689, + MRB_SYM__usleep = 690, + MRB_SYM_Q__valid = 691, + MRB_SYM_Q__value = 692, + MRB_SYM__values = 693, + MRB_SYM__yellow = 694, + MRB_GVSYM__stderr = 695, + MRB_GVSYM__stdout = 696, + MRB_IVSYM__family = 697, + MRB_SYM__AF_INET = 698, + MRB_SYM__AF_UNIX = 699, + MRB_SYM__AI_FQDN = 700, + MRB_SYM__Binding = 701, + MRB_SYM__Complex = 702, + MRB_SYM__EBADMSG = 703, + MRB_SYM__EBADRPC = 704, + MRB_SYM__EBADRQC = 705, + MRB_SYM__EBADSLT = 706, + MRB_SYM__EDEADLK = 707, + MRB_SYM__EDEVERR = 708, + MRB_SYM__EDOOFUS = 709, + MRB_SYM__EDOTDOT = 710, + MRB_SYM__EISCONN = 711, + MRB_SYM__ELIBACC = 712, + MRB_SYM__ELIBBAD = 713, + MRB_SYM__ELIBMAX = 714, + MRB_SYM__ELIBSCN = 715, + MRB_SYM__ENAVAIL = 716, + MRB_SYM__ENOATTR = 717, + MRB_SYM__ENOBUFS = 718, + MRB_SYM__ENODATA = 719, + MRB_SYM__ENOEXEC = 720, + MRB_SYM__ENOLINK = 721, + MRB_SYM__ENOTBLK = 722, + MRB_SYM__ENOTDIR = 723, + MRB_SYM__ENOTNAM = 724, + MRB_SYM__ENOTSUP = 725, + MRB_SYM__EPSILON = 726, + MRB_SYM__EPWROFF = 727, + MRB_SYM__EREMCHG = 728, + MRB_SYM__EREMOTE = 729, + MRB_SYM__ERFKILL = 730, + MRB_SYM__ETXTBSY = 731, + MRB_SYM__EUCLEAN = 732, + MRB_SYM__EUNATCH = 733, + MRB_SYM__IOError = 734, + MRB_SYM__Integer = 735, + MRB_SYM__LOCK_EX = 736, + MRB_SYM__LOCK_NB = 737, + MRB_SYM__LOCK_SH = 738, + MRB_SYM__LOCK_UN = 739, + MRB_SYM__MAX_EXP = 740, + MRB_SYM__MIN_EXP = 741, + MRB_SYM__MSG_OOB = 742, + MRB_SYM__NOATIME = 743, + MRB_SYM__NOERROR = 744, + MRB_SYM__Numeric = 745, + MRB_SYM__PF_INET = 746, + MRB_SYM__PF_UNIX = 747, + MRB_SYM__Process = 748, + MRB_SYM__SO_TYPE = 749, + MRB_SYM__TMPFILE = 750, + MRB_SYM__T_ARRAY = 751, + MRB_SYM__T_BREAK = 752, + MRB_SYM__T_CLASS = 753, + MRB_SYM__T_FIBER = 754, + MRB_SYM__T_FLOAT = 755, + MRB_SYM__T_RANGE = 756, + MRB_SYM__Yielder = 757, + MRB_SYM____lines = 758, + MRB_SYM____merge = 759, + MRB_SYM___accept = 760, + MRB_SYM___listen = 761, + MRB_SYM___socket = 762, + MRB_SYM__afamily = 763, + MRB_SYM__asctime = 764, + MRB_SYM__backlog = 765, + MRB_SYM__binding = 766, + MRB_SYM__bsearch = 767, + MRB_SYM__casecmp = 768, + MRB_SYM__ceildiv = 769, + MRB_SYM_Q__closed = 770, + MRB_SYM__collect = 771, + MRB_SYM__command = 772, + MRB_SYM__compact = 773, + MRB_SYM__compile = 774, + MRB_SYM__connect = 775, + MRB_SYM__current = 776, + MRB_SYM__default = 777, + MRB_SYM_B__delete = 778, + MRB_SYM_Q__delete = 779, + MRB_SYM__dirname = 780, + MRB_SYM__disable = 781, + MRB_SYM__dropped = 782, + MRB_SYM__element = 783, + MRB_SYM__entries = 784, + MRB_SYM_Q__exists = 785, + MRB_SYM__extname = 786, + MRB_SYM_B__filter = 787, + MRB_SYM_Q__finite = 788, + MRB_SYM__flatten = 789, + MRB_SYM__foreach = 790, + MRB_SYM_Q__friday = 791, + MRB_SYM_Q__frozen = 792, + MRB_SYM__getbyte = 793, + MRB_SYM__include = 794, + MRB_SYM__inspect = 795, + MRB_SYM__ip_port = 796, + MRB_SYM__keep_if = 797, + MRB_SYM__keyrest = 798, + MRB_SYM_Q__lambda = 799, + MRB_SYM_B__lstrip = 800, + MRB_SYM__magenta = 801, + MRB_SYM__max_cmp = 802, + MRB_SYM_Q__member = 803, + MRB_SYM__members = 804, + MRB_SYM__message = 805, + MRB_SYM__methods = 806, + MRB_SYM__min_cmp = 807, + MRB_SYM__modules = 808, + MRB_SYM_Q__monday = 809, + MRB_SYM__nesting = 810, + MRB_SYM__new_key = 811, + MRB_SYM_Q__nobits = 812, + MRB_SYM__numeric = 813, + MRB_SYM__optname = 814, + MRB_SYM__padding = 815, + MRB_SYM__pattern = 816, + MRB_SYM__pfamily = 817, + MRB_SYM__pointer = 818, + MRB_SYM__prepend = 819, + MRB_SYM__private = 820, + MRB_SYM__produce = 821, + MRB_SYM__product = 822, + MRB_SYM_B__reject = 823, + MRB_SYM__replace = 824, + MRB_SYM_E__result = 825, + MRB_SYM__reverse = 826, + MRB_SYM_B__rotate = 827, + MRB_SYM_B__rstrip = 828, + MRB_SYM_B__select = 829, + MRB_SYM__sep_len = 830, + MRB_SYM__service = 831, + MRB_SYM__setbyte = 832, + MRB_SYM__shorter = 833, + MRB_SYM__shuffle = 834, + MRB_SYM_Q__socket = 835, + MRB_SYM__sort_by = 836, + MRB_SYM__sprintf = 837, + MRB_SYM__squeeze = 838, + MRB_SYM_Q__subset = 839, + MRB_SYM_Q__sunday = 840, + MRB_SYM__symlink = 841, + MRB_SYM__sysopen = 842, + MRB_SYM__sysread = 843, + MRB_SYM__sysseek = 844, + MRB_SYM__to_enum = 845, + MRB_SYM__to_hash = 846, + MRB_SYM__to_json = 847, + MRB_SYM__to_proc = 848, + MRB_SYM__unpack1 = 849, + MRB_SYM__unshift = 850, + MRB_SYM_B__upcase = 851, + MRB_SYM__yielder = 852, + MRB_SYM__AF_INET6 = 853, + MRB_SYM__Addrinfo = 854, + MRB_SYM__EALREADY = 855, + MRB_SYM__EBADARCH = 856, + MRB_SYM__EBADEXEC = 857, + MRB_SYM__ECAPMODE = 858, + MRB_SYM__EL2NSYNC = 859, + MRB_SYM__ELIBEXEC = 860, + MRB_SYM__EMSGSIZE = 861, + MRB_SYM__ENETDOWN = 862, + MRB_SYM__ENOTCONN = 863, + MRB_SYM__ENOTSOCK = 864, + MRB_SYM__ENOTUNIQ = 865, + MRB_SYM__EOFError = 866, + MRB_SYM__EPROCLIM = 867, + MRB_SYM__ERESTART = 868, + MRB_SYM__ESTRPIPE = 869, + MRB_SYM__Encoding = 870, + MRB_SYM__FileTest = 871, + MRB_SYM__INFINITY = 872, + MRB_SYM__IPSocket = 873, + MRB_SYM__KeyError = 874, + MRB_SYM__MANT_DIG = 875, + MRB_SYM__MSG_PEEK = 876, + MRB_SYM__NI_DGRAM = 877, + MRB_SYM__NOFOLLOW = 878, + MRB_SYM__NONBLOCK = 879, + MRB_SYM__NilClass = 880, + MRB_SYM__PF_INET6 = 881, + MRB_SYM__Rational = 882, + MRB_SYM__SEEK_CUR = 883, + MRB_SYM__SEEK_END = 884, + MRB_SYM__SEEK_SET = 885, + MRB_SYM__SOCK_RAW = 886, + MRB_SYM__SO_DEBUG = 887, + MRB_SYM__SO_ERROR = 888, + MRB_SYM__T_BIGINT = 889, + MRB_SYM__T_ICLASS = 890, + MRB_SYM__T_MODULE = 891, + MRB_SYM__T_OBJECT = 892, + MRB_SYM__T_SCLASS = 893, + MRB_SYM__T_STRING = 894, + MRB_SYM__T_STRUCT = 895, + MRB_SYM____delete = 896, + MRB_SYM____send__ = 897, + MRB_SYM____svalue = 898, + MRB_SYM____to_int = 899, + MRB_SYM___accept2 = 900, + MRB_SYM___connect = 901, + MRB_SYM_Q__allbits = 902, + MRB_SYM__allocate = 903, + MRB_SYM_Q__anybits = 904, + MRB_SYM__basename = 905, + MRB_SYM_Q__between = 906, + MRB_SYM__bytesize = 907, + MRB_SYM_Q__casecmp = 908, + MRB_SYM__children = 909, + MRB_SYM__classify = 910, + MRB_SYM_B__collect = 911, + MRB_SYM__colorize = 912, + MRB_SYM_B__compact = 913, + MRB_SYM_E__default = 914, + MRB_SYM__downcase = 915, + MRB_SYM__dropping = 916, + MRB_SYM__each_key = 917, + MRB_SYM__encoding = 918, + MRB_SYM__enum_for = 919, + MRB_SYM__extended = 920, + MRB_SYM__filename = 921, + MRB_SYM__find_all = 922, + MRB_SYM__flat_map = 923, + MRB_SYM_B__flatten = 924, + MRB_SYM__generate = 925, + MRB_SYM__getlocal = 926, + MRB_SYM__group_by = 927, + MRB_SYM_Q__has_key = 928, + MRB_SYM_Q__include = 929, + MRB_SYM__included = 930, + MRB_SYM_Q__integer = 931, + MRB_SYM_Q__kind_of = 932, + MRB_SYM__modified = 933, + MRB_SYM__new_args = 934, + MRB_SYM__nodename = 935, + MRB_SYM_Q__nonzero = 936, + MRB_SYM_Q__overlap = 937, + MRB_SYM__peeraddr = 938, + MRB_SYM__protocol = 939, + MRB_SYM__readbyte = 940, + MRB_SYM__readchar = 941, + MRB_SYM__readline = 942, + MRB_SYM__readlink = 943, + MRB_SYM__realpath = 944, + MRB_SYM__receiver = 945, + MRB_SYM__recvfrom = 946, + MRB_SYM_B__reverse = 947, + MRB_SYM__self_end = 948, + MRB_SYM__self_len = 949, + MRB_SYM__servname = 950, + MRB_SYM_B__shuffle = 951, + MRB_SYM__shutdown = 952, + MRB_SYM__sockaddr = 953, + MRB_SYM__socktype = 954, + MRB_SYM_B__sort_by = 955, + MRB_SYM_B__squeeze = 956, + MRB_SYM__str_each = 957, + MRB_SYM__subtract = 958, + MRB_SYM__swapcase = 959, + MRB_SYM_Q__symlink = 960, + MRB_SYM__syswrite = 961, + MRB_SYM__transfer = 962, + MRB_SYM__truncate = 963, + MRB_SYM_Q__tuesday = 964, + MRB_IVSYM__hostname = 965, + MRB_IVSYM__protocol = 966, + MRB_IVSYM__sockaddr = 967, + MRB_IVSYM__socktype = 968, + MRB_IVSYM__stop_exc = 969, + MRB_SYM__AF_UNSPEC = 970, + MRB_SYM__Constants = 971, + MRB_SYM__EBADMACHO = 972, + MRB_SYM__ECANCELED = 973, + MRB_SYM__EDEADLOCK = 974, + MRB_SYM__EHOSTDOWN = 975, + MRB_SYM__EMULTIHOP = 976, + MRB_SYM__ENEEDAUTH = 977, + MRB_SYM__ENETRESET = 978, + MRB_SYM__ENOMEDIUM = 979, + MRB_SYM__ENOPOLICY = 980, + MRB_SYM__ENOTEMPTY = 981, + MRB_SYM__EOVERFLOW = 982, + MRB_SYM__EREMOTEIO = 983, + MRB_SYM__ESHUTDOWN = 984, + MRB_SYM__ETIMEDOUT = 985, + MRB_SYM__Exception = 986, + MRB_SYM__Generator = 987, + MRB_SYM__MSG_BCAST = 988, + MRB_SYM__MSG_MCAST = 989, + MRB_SYM__MSG_TRUNC = 990, + MRB_SYM__NI_NOFQDN = 991, + MRB_SYM__NameError = 992, + MRB_SYM__PF_UNSPEC = 993, + MRB_SYM__SEPARATOR = 994, + MRB_SYM__SHUT_RDWR = 995, + MRB_SYM__SO_LINGER = 996, + MRB_SYM__SO_RCVBUF = 997, + MRB_SYM__SO_SNDBUF = 998, + MRB_SYM__TCPServer = 999, + MRB_SYM__TCPSocket = 1000, + MRB_SYM__T_COMPLEX = 1001, + MRB_SYM__T_INTEGER = 1002, + MRB_SYM__T_ISTRUCT = 1003, + MRB_SYM__TrueClass = 1004, + MRB_SYM__TypeError = 1005, + MRB_SYM__UDPSocket = 1006, + MRB_SYM____compact = 1007, + MRB_SYM____outer__ = 1008, + MRB_SYM___allocate = 1009, + MRB_SYM___gc_root_ = 1010, + MRB_SYM___recvfrom = 1011, + MRB_SYM___sys_fail = 1012, + MRB_SYM___sysclose = 1013, + MRB_SYM___to_array = 1014, + MRB_SYM__ancestors = 1015, + MRB_SYM__backtrace = 1016, + MRB_SYM__bind_call = 1017, + MRB_SYM__byteindex = 1018, + MRB_SYM__byteslice = 1019, + MRB_SYM__conjugate = 1020, + MRB_SYM__const_get = 1021, + MRB_SYM__const_set = 1022, + MRB_SYM__constants = 1023, + MRB_SYM__delete_at = 1024, + MRB_SYM__delete_if = 1025, + MRB_SYM_Q__disjoint = 1026, + MRB_SYM_B__downcase = 1027, + MRB_SYM__each_byte = 1028, + MRB_SYM__each_char = 1029, + MRB_SYM__each_cons = 1030, + MRB_SYM__each_line = 1031, + MRB_SYM__each_pair = 1032, + MRB_SYM_Q__end_with = 1033, + MRB_SYM__exception = 1034, + MRB_SYM__exclusive = 1035, + MRB_SYM__feedvalue = 1036, + MRB_SYM__imaginary = 1037, + MRB_SYM_Q__infinite = 1038, + MRB_SYM__inherited = 1039, + MRB_SYM__invisible = 1040, + MRB_SYM__ip_unpack = 1041, + MRB_SYM_Q__iterator = 1042, + MRB_SYM__load_file = 1043, + MRB_SYM__localtime = 1044, + MRB_SYM__magnitude = 1045, + MRB_SYM__minmax_by = 1046, + MRB_SYM_Q__negative = 1047, + MRB_SYM__numerator = 1048, + MRB_SYM__object_id = 1049, + MRB_SYM__other_end = 1050, + MRB_SYM__partition = 1051, + MRB_SYM_Q__positive = 1052, + MRB_SYM__prepended = 1053, + MRB_SYM__protected = 1054, + MRB_SYM__readlines = 1055, + MRB_SYM__remainder = 1056, + MRB_SYM__satisfied = 1057, + MRB_SYM_Q__saturday = 1058, + MRB_SYM__self_excl = 1059, + MRB_SYM__separator = 1060, + MRB_SYM__set_color = 1061, + MRB_SYM_Q__superset = 1062, + MRB_SYM_B__swapcase = 1063, + MRB_SYM__sysaccept = 1064, + MRB_SYM_Q__thursday = 1065, + MRB_SYM__transpose = 1066, + MRB_SYM__underline = 1067, + MRB_SYM__ungetbyte = 1068, + MRB_SYM__unix_path = 1069, + MRB_SYM__validated = 1070, + MRB_SYM__values_at = 1071, + MRB_IVSYM__feedvalue = 1072, + MRB_IVSYM__lookahead = 1073, + MRB_SYM__AI_PASSIVE = 1074, + MRB_SYM__ASCII_8BIT = 1075, + MRB_SYM__Comparable = 1076, + MRB_SYM__EADDRINUSE = 1077, + MRB_SYM__ECONNRESET = 1078, + MRB_SYM__EINTEGRITY = 1079, + MRB_SYM__EOPNOTSUPP = 1080, + MRB_SYM__EOWNERDEAD = 1081, + MRB_SYM__EPROTOTYPE = 1082, + MRB_SYM__ESHLIBVERS = 1083, + MRB_SYM__Enumerable = 1084, + MRB_SYM__Enumerator = 1085, + MRB_SYM__FalseClass = 1086, + MRB_SYM__FiberError = 1087, + MRB_SYM__IPPROTO_AH = 1088, + MRB_SYM__IPPROTO_IP = 1089, + MRB_SYM__IP_HDRINCL = 1090, + MRB_SYM__IP_OPTIONS = 1091, + MRB_SYM__IP_PKTINFO = 1092, + MRB_SYM__IP_RECVERR = 1093, + MRB_SYM__IP_RECVTOS = 1094, + MRB_SYM__IP_RECVTTL = 1095, + MRB_SYM__IndexError = 1096, + MRB_SYM__MAX_10_EXP = 1097, + MRB_SYM__MIN_10_EXP = 1098, + MRB_SYM__MSG_CTRUNC = 1099, + MRB_SYM__NI_MAXHOST = 1100, + MRB_SYM__NI_MAXSERV = 1101, + MRB_SYM__RangeError = 1102, + MRB_SYM__SOCK_DGRAM = 1103, + MRB_SYM__SOL_SOCKET = 1104, + MRB_SYM__SystemExit = 1105, + MRB_SYM__TCP_MAXSEG = 1106, + MRB_SYM__T_RATIONAL = 1107, + MRB_SYM__UNIXServer = 1108, + MRB_SYM__UNIXSocket = 1109, + MRB_SYM____callee__ = 1110, + MRB_SYM____case_eqq = 1111, + MRB_SYM____get_hash = 1112, + MRB_SYM____method__ = 1113, + MRB_SYM____num_to_a = 1114, + MRB_SYM___separator = 1115, + MRB_SYM__bright_red = 1116, + MRB_SYM__byterindex = 1117, + MRB_SYM__bytesplice = 1118, + MRB_SYM__capitalize = 1119, + MRB_SYM__class_eval = 1120, + MRB_SYM__class_exec = 1121, + MRB_SYM__codepoints = 1122, + MRB_SYM__color_null = 1123, + MRB_SYM__difference = 1124, + MRB_SYM_Q__directory = 1125, + MRB_SYM__drop_while = 1126, + MRB_SYM__each_child = 1127, + MRB_SYM__each_entry = 1128, + MRB_SYM__each_index = 1129, + MRB_SYM__each_slice = 1130, + MRB_SYM__each_value = 1131, + MRB_SYM__fd_or_path = 1132, + MRB_SYM__filter_map = 1133, + MRB_SYM__find_index = 1134, + MRB_SYM__getaddress = 1135, + MRB_SYM__getpeereid = 1136, + MRB_SYM__getsockopt = 1137, + MRB_SYM__given_args = 1138, + MRB_SYM_Q__has_value = 1139, + MRB_SYM__initialize = 1140, + MRB_SYM_Q__intersect = 1141, + MRB_SYM__ip_address = 1142, + MRB_SYM__last_value = 1143, + MRB_SYM__local_host = 1144, + MRB_SYM__make_curry = 1145, + MRB_SYM__memsize_of = 1146, + MRB_SYM__other_excl = 1147, + MRB_SYM__parameters = 1148, + MRB_SYM__rpartition = 1149, + MRB_SYM__self_arity = 1150, + MRB_SYM__self_begin = 1151, + MRB_SYM__setsockopt = 1152, + MRB_SYM__socketpair = 1153, + MRB_SYM__step_ratio = 1154, + MRB_SYM__subclasses = 1155, + MRB_SYM__superclass = 1156, + MRB_SYM__take_while = 1157, + MRB_SYM_Q__wednesday = 1158, + MRB_SYM__with_index = 1159, + MRB_SYM__yield_self = 1160, + MRB_IVSYM__color_null = 1161, + MRB_SYM__BasicObject = 1162, + MRB_SYM__BasicSocket = 1163, + MRB_SYM__DomainError = 1164, + MRB_SYM__EINPROGRESS = 1165, + MRB_SYM__EKEYEXPIRED = 1166, + MRB_SYM__EKEYREVOKED = 1167, + MRB_SYM__EMEDIUMTYPE = 1168, + MRB_SYM__ENETUNREACH = 1169, + MRB_SYM__ENOPROTOOPT = 1170, + MRB_SYM__ENOTCAPABLE = 1171, + MRB_SYM__EWOULDBLOCK = 1172, + MRB_SYM__FNM_SYSCASE = 1173, + MRB_SYM__FrozenError = 1174, + MRB_SYM__IPPROTO_ESP = 1175, + MRB_SYM__IPPROTO_RAW = 1176, + MRB_SYM__IPPROTO_TCP = 1177, + MRB_SYM__IPPROTO_UDP = 1178, + MRB_SYM__IPV6_V6ONLY = 1179, + MRB_SYM__NI_NAMEREQD = 1180, + MRB_SYM__ObjectSpace = 1181, + MRB_SYM__ParserError = 1182, + MRB_SYM__RUBY_ENGINE = 1183, + MRB_SYM__RegexpError = 1184, + MRB_SYM__SOCK_STREAM = 1185, + MRB_SYM__SO_RCVLOWAT = 1186, + MRB_SYM__SO_RCVTIMEO = 1187, + MRB_SYM__SO_SNDLOWAT = 1188, + MRB_SYM__SO_SNDTIMEO = 1189, + MRB_SYM__ScriptError = 1190, + MRB_SYM__SocketError = 1191, + MRB_SYM__SyntaxError = 1192, + MRB_SYM__TCP_KEEPCNT = 1193, + MRB_SYM__TCP_NODELAY = 1194, + MRB_SYM__T_EXCEPTION = 1195, + MRB_SYM____members__ = 1196, + MRB_SYM_E___is_socket = 1197, + MRB_SYM_Q__ascii_only = 1198, + MRB_SYM__attr_reader = 1199, + MRB_SYM__attr_writer = 1200, + MRB_SYM__bright_blue = 1201, + MRB_SYM__bright_cyan = 1202, + MRB_SYM_B__capitalize = 1203, + MRB_SYM__chunk_while = 1204, + MRB_SYM__close_write = 1205, + MRB_SYM_E__color_null = 1206, + MRB_SYM__combination = 1207, + MRB_SYM__denominator = 1208, + MRB_SYM__each_object = 1209, + MRB_SYM__expand_path = 1210, + MRB_SYM__getaddrinfo = 1211, + MRB_SYM__gethostname = 1212, + MRB_SYM__getnameinfo = 1213, + MRB_SYM__getpeername = 1214, + MRB_SYM__getsockname = 1215, + MRB_SYM__max_nesting = 1216, + MRB_SYM__module_eval = 1217, + MRB_SYM__module_exec = 1218, + MRB_SYM__next_values = 1219, + MRB_SYM__other_begin = 1220, + MRB_SYM__peek_values = 1221, + MRB_SYM__permutation = 1222, + MRB_SYM__rectangular = 1223, + MRB_SYM_Q__respond_to = 1224, + MRB_SYM__sockaddr_in = 1225, + MRB_SYM__sockaddr_un = 1226, + MRB_SYM_Q__start_with = 1227, + MRB_SYM_E__step_ratio = 1228, + MRB_SYM__to_sockaddr = 1229, + MRB_SYM_Q__valid_mode = 1230, + MRB_SYM__with_object = 1231, + MRB_SYM__AI_CANONNAME = 1232, + MRB_SYM__EAFNOSUPPORT = 1233, + MRB_SYM__ECONNABORTED = 1234, + MRB_SYM__ECONNREFUSED = 1235, + MRB_SYM__EDESTADDRREQ = 1236, + MRB_SYM__EHOSTUNREACH = 1237, + MRB_SYM__EKEYREJECTED = 1238, + MRB_SYM__ENAMETOOLONG = 1239, + MRB_SYM__EPFNOSUPPORT = 1240, + MRB_SYM__EPROCUNAVAIL = 1241, + MRB_SYM__EPROGUNAVAIL = 1242, + MRB_SYM__ERPCMISMATCH = 1243, + MRB_SYM__ETOOMANYREFS = 1244, + MRB_SYM__FNM_CASEFOLD = 1245, + MRB_SYM__FNM_DOTMATCH = 1246, + MRB_SYM__FNM_NOESCAPE = 1247, + MRB_SYM__FNM_PATHNAME = 1248, + MRB_SYM__IPPROTO_ICMP = 1249, + MRB_SYM__IPPROTO_IPV6 = 1250, + MRB_SYM__IPPROTO_NONE = 1251, + MRB_SYM__NestingError = 1252, + MRB_SYM__RUBY_VERSION = 1253, + MRB_SYM__RuntimeError = 1254, + MRB_SYM__SHARE_DELETE = 1255, + MRB_SYM__SO_BROADCAST = 1256, + MRB_SYM__SO_DONTROUTE = 1257, + MRB_SYM__SO_KEEPALIVE = 1258, + MRB_SYM__SO_OOBINLINE = 1259, + MRB_SYM__SO_REUSEADDR = 1260, + MRB_SYM__TCP_KEEPIDLE = 1261, + MRB_SYM____ENCODING__ = 1262, + MRB_SYM____attached__ = 1263, + MRB_SYM____codepoints = 1264, + MRB_SYM____errno_list = 1265, + MRB_SYM___setnonblock = 1266, + MRB_SYM___sockaddr_in = 1267, + MRB_SYM__alias_method = 1268, + MRB_SYM_Q__block_given = 1269, + MRB_SYM__bright_black = 1270, + MRB_SYM__bright_green = 1271, + MRB_SYM__bright_white = 1272, + MRB_SYM__color_number = 1273, + MRB_SYM__color_string = 1274, + MRB_SYM__column_count = 1275, + MRB_SYM__column_index = 1276, + MRB_SYM__default_proc = 1277, + MRB_SYM_Q__exclude_end = 1278, + MRB_SYM__fetch_values = 1279, + MRB_SYM_Q__instance_of = 1280, + MRB_SYM__intersection = 1281, + MRB_SYM__method_added = 1282, + MRB_SYM__mruby_Random = 1283, + MRB_SYM__pretty_print = 1284, + MRB_SYM__remove_const = 1285, + MRB_SYM__reverse_each = 1286, + MRB_SYM__super_method = 1287, + MRB_SYM__undef_method = 1288, + MRB_IVSYM__color_string = 1289, + MRB_IVSYM__init_with_fd = 1290, + MRB_SYM__ALT_SEPARATOR = 1291, + MRB_SYM__ArgumentError = 1292, + MRB_SYM__EADDRNOTAVAIL = 1293, + MRB_SYM__EPROGMISMATCH = 1294, + MRB_SYM__MRUBY_VERSION = 1295, + MRB_SYM__MSG_DONTROUTE = 1296, + MRB_SYM__NoMemoryError = 1297, + MRB_SYM__NoMethodError = 1298, + MRB_SYM__StandardError = 1299, + MRB_SYM__StopIteration = 1300, + MRB_SYM__TCP_KEEPALIVE = 1301, + MRB_SYM__TCP_KEEPINTVL = 1302, + MRB_SYM__TerminalColor = 1303, + MRB_SYM__UnboundMethod = 1304, + MRB_SYM____classname__ = 1305, + MRB_SYM____sub_replace = 1306, + MRB_SYM____update_hash = 1307, + MRB_SYM__absolute_path = 1308, + MRB_SYM__attr_accessor = 1309, + MRB_SYM__bright_yellow = 1310, + MRB_SYM__bsearch_index = 1311, + MRB_SYM__color_boolean = 1312, + MRB_SYM_E__color_string = 1313, + MRB_SYM__const_missing = 1314, + MRB_SYM__count_objects = 1315, + MRB_SYM_E__default_proc = 1316, + MRB_SYM__define_method = 1317, + MRB_SYM__delete_prefix = 1318, + MRB_SYM__delete_suffix = 1319, + MRB_SYM__extend_object = 1320, + MRB_SYM__fast_generate = 1321, + MRB_SYM__flatten_merge = 1322, + MRB_SYM__in_lower_half = 1323, + MRB_SYM__instance_eval = 1324, + MRB_SYM__instance_exec = 1325, + MRB_SYM__local_address = 1326, + MRB_SYM__local_service = 1327, + MRB_SYM__recv_nonblock = 1328, + MRB_SYM__remove_method = 1329, + MRB_SYM__set_backtrace = 1330, + MRB_IVSYM__color_boolean = 1331, + MRB_SYM__AI_NUMERICHOST = 1332, + MRB_SYM__AI_NUMERICSERV = 1333, + MRB_SYM__GeneratorError = 1334, + MRB_SYM__IPPROTO_ICMPV6 = 1335, + MRB_SYM__IP_RECVDSTADDR = 1336, + MRB_SYM__LocalJumpError = 1337, + MRB_SYM__NI_NUMERICHOST = 1338, + MRB_SYM__NI_NUMERICSERV = 1339, + MRB_SYM__PATH_SEPARATOR = 1340, + MRB_SYM__SOCK_SEQPACKET = 1341, + MRB_SYM____do_with_enum = 1342, + MRB_SYM_Q____empty_range = 1343, + MRB_SYM____errno_define = 1344, + MRB_SYM____upto_endless = 1345, + MRB_SYM_Q__absolute_path = 1346, + MRB_SYM__bright_magenta = 1347, + MRB_SYM_E__close_on_exec = 1348, + MRB_SYM_Q__close_on_exec = 1349, + MRB_SYM__collect_concat = 1350, + MRB_SYM_E__color_boolean = 1351, + MRB_SYM_Q__const_defined = 1352, + MRB_SYM_B__delete_prefix = 1353, + MRB_SYM_B__delete_suffix = 1354, + MRB_SYM__each_codepoint = 1355, + MRB_SYM__force_encoding = 1356, + MRB_SYM__interval_ratio = 1357, + MRB_SYM__memsize_of_all = 1358, + MRB_SYM__method_missing = 1359, + MRB_SYM__method_removed = 1360, + MRB_SYM__paragraph_mode = 1361, + MRB_SYM_Q__proper_subset = 1362, + MRB_SYM__public_methods = 1363, + MRB_SYM__remote_address = 1364, + MRB_SYM__transform_keys = 1365, + MRB_SYM__ANSI_MODE_CODES = 1366, + MRB_SYM__ENOTRECOVERABLE = 1367, + MRB_SYM__EPROTONOSUPPORT = 1368, + MRB_SYM__ESOCKTNOSUPPORT = 1369, + MRB_SYM__IPPROTO_DSTOPTS = 1370, + MRB_SYM__IPPROTO_ROUTING = 1371, + MRB_SYM__IPV6_JOIN_GROUP = 1372, + MRB_SYM__IP_BLOCK_SOURCE = 1373, + MRB_SYM__IP_MTU_DISCOVER = 1374, + MRB_SYM__IP_MULTICAST_IF = 1375, + MRB_SYM__MRUBY_COPYRIGHT = 1376, + MRB_SYM__SystemCallError = 1377, + MRB_SYM__accept_nonblock = 1378, + MRB_SYM__append_as_bytes = 1379, + MRB_SYM__append_features = 1380, + MRB_SYM__attached_object = 1381, + MRB_SYM__class_variables = 1382, + MRB_SYM__each_with_index = 1383, + MRB_SYM__initialize_copy = 1384, + MRB_SYM__instance_method = 1385, + MRB_SYM_E__interval_ratio = 1386, + MRB_SYM__local_variables = 1387, + MRB_SYM_Q__method_defined = 1388, + MRB_SYM__module_function = 1389, + MRB_SYM__pad_repetitions = 1390, + MRB_SYM__pretty_generate = 1391, + MRB_SYM__private_methods = 1392, + MRB_SYM__singleton_class = 1393, + MRB_SYM__source_location = 1394, + MRB_SYM__symbolize_names = 1395, + MRB_SYM_B__transform_keys = 1396, + MRB_SYM_Q__valid_encoding = 1397, + MRB_SYM__ANSI_COLOR_CODES = 1398, + MRB_SYM__FloatDomainError = 1399, + MRB_SYM__IPPROTO_FRAGMENT = 1400, + MRB_SYM__IPV6_LEAVE_GROUP = 1401, + MRB_SYM__IP_MULTICAST_TTL = 1402, + MRB_SYM__MCAST_JOIN_GROUP = 1403, + MRB_SYM__MRUBY_RELEASE_NO = 1404, + MRB_SYM__SystemStackError = 1405, + MRB_SYM_Q____errno_defined = 1406, + MRB_SYM___sockaddr_family = 1407, + MRB_SYM__color_object_key = 1408, + MRB_SYM__connect_nonblock = 1409, + MRB_SYM__each_with_object = 1410, + MRB_SYM__global_variables = 1411, + MRB_SYM__included_modules = 1412, + MRB_SYM__inspect_sockaddr = 1413, + MRB_SYM__instance_methods = 1414, + MRB_SYM__method_undefined = 1415, + MRB_SYM__pack_sockaddr_in = 1416, + MRB_SYM__pack_sockaddr_un = 1417, + MRB_SYM__prepend_features = 1418, + MRB_SYM_Q__proper_superset = 1419, + MRB_SYM_Q__singleton_class = 1420, + MRB_SYM__singleton_method = 1421, + MRB_SYM__transform_values = 1422, + MRB_IVSYM__color_object_key = 1423, + MRB_SYM__IPV6_MULTICAST_IF = 1424, + MRB_SYM__IPV6_UNICAST_HOPS = 1425, + MRB_SYM__IP_ADD_MEMBERSHIP = 1426, + MRB_SYM__IP_MULTICAST_LOOP = 1427, + MRB_SYM__IP_UNBLOCK_SOURCE = 1428, + MRB_SYM__MCAST_LEAVE_GROUP = 1429, + MRB_SYM__MRUBY_DESCRIPTION = 1430, + MRB_SYM__ZeroDivisionError = 1431, + MRB_SYM___new_with_prelude = 1432, + MRB_SYM__colorize_generate = 1433, + MRB_SYM__generational_mode = 1434, + MRB_SYM__protected_methods = 1435, + MRB_SYM__recvfrom_nonblock = 1436, + MRB_SYM__singleton_methods = 1437, + MRB_SYM_B__transform_values = 1438, + MRB_SYM__IP_DROP_MEMBERSHIP = 1439, + MRB_SYM__MCAST_BLOCK_SOURCE = 1440, + MRB_SYM__MRUBY_RELEASE_DATE = 1441, + MRB_SYM__UncaughtThrowError = 1442, + MRB_SYM__class_variable_get = 1443, + MRB_SYM__class_variable_set = 1444, + MRB_SYM_E__generational_mode = 1445, + MRB_SYM__instance_variables = 1446, + MRB_SYM__local_variable_get = 1447, + MRB_SYM__local_variable_set = 1448, + MRB_SYM__unpack_sockaddr_in = 1449, + MRB_SYM__unpack_sockaddr_un = 1450, + MRB_SYM__ANSI_BG_COLOR_CODES = 1451, + MRB_SYM__IPV6_MULTICAST_HOPS = 1452, + MRB_SYM__IPV6_MULTICAST_LOOP = 1453, + MRB_SYM__NotImplementedError = 1454, + MRB_SYM__RUBY_ENGINE_VERSION = 1455, + MRB_SYM_Q__respond_to_missing = 1456, + MRB_SYM__MCAST_UNBLOCK_SOURCE = 1457, + MRB_SYM_Q____inspect_recursive = 1458, + MRB_SYM__repeated_combination = 1459, + MRB_SYM__repeated_permutation = 1460, + MRB_SYM__set_color_object_key = 1461, + MRB_SYM____coerce_step_counter = 1462, + MRB_SYM__do_not_reverse_lookup = 1463, + MRB_SYM__instance_variable_get = 1464, + MRB_SYM__instance_variable_set = 1465, + MRB_SYM__remove_class_variable = 1466, + MRB_IVSYM__do_not_reverse_lookup = 1467, + MRB_SYM____repeated_combination = 1468, + MRB_SYM_E__do_not_reverse_lookup = 1469, + MRB_SYM__singleton_method_added = 1470, + MRB_CVSYM__do_not_reverse_lookup = 1471, + MRB_SYM__MCAST_JOIN_SOURCE_GROUP = 1472, + MRB_SYM____enumerator_block_call = 1473, + MRB_SYM_Q__class_variable_defined = 1474, + MRB_SYM__define_singleton_method = 1475, + MRB_SYM_Q__local_variable_defined = 1476, + MRB_SYM__public_instance_methods = 1477, + MRB_SYM__IP_ADD_SOURCE_MEMBERSHIP = 1478, + MRB_SYM__MCAST_LEAVE_SOURCE_GROUP = 1479, + MRB_SYM__private_instance_methods = 1480, + MRB_SYM__remove_instance_variable = 1481, + MRB_SYM__singleton_method_removed = 1482, + MRB_SYM__IP_DROP_SOURCE_MEMBERSHIP = 1483, + MRB_SYM_Q__instance_variable_defined = 1484, + MRB_SYM__protected_instance_methods = 1485, + MRB_SYM__singleton_method_undefined = 1486, + MRB_SYM__undefined_instance_methods = 1487, +}; + +#define MRB_PRESYM_MAX 1487 diff --git a/deps/mruby/include/mruby/presym/scanning.h b/deps/mruby/include/mruby/presym/scanning.h new file mode 100644 index 0000000..9a3d75b --- /dev/null +++ b/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 */ diff --git a/deps/mruby/include/mruby/presym/table.h b/deps/mruby/include/mruby/presym/table.h new file mode 100644 index 0000000..9b0f668 --- /dev/null +++ b/deps/mruby/include/mruby/presym/table.h @@ -0,0 +1,2979 @@ +static const uint16_t presym_length_table[] = { + 1, /* ! */ + 1, /* % */ + 1, /* & */ + 1, /* * */ + 1, /* + */ + 1, /* - */ + 1, /* / */ + 1, /* < */ + 1, /* > */ + 1, /* E */ + 1, /* ^ */ + 1, /* ` */ + 1, /* a */ + 1, /* b */ + 1, /* c */ + 1, /* d */ + 1, /* e */ + 1, /* f */ + 1, /* h */ + 1, /* i */ + 1, /* j */ + 1, /* k */ + 1, /* l */ + 1, /* m */ + 1, /* n */ + 1, /* o */ + 1, /* p */ + 1, /* r */ + 1, /* s */ + 1, /* t */ + 1, /* v */ + 1, /* w */ + 1, /* x */ + 1, /* y */ + 1, /* z */ + 1, /* | */ + 1, /* ~ */ + 2, /* != */ + 2, /* !~ */ + 2, /* $0 */ + 2, /* $? */ + 2, /* && */ + 2, /* ** */ + 2, /* +@ */ + 2, /* -@ */ + 2, /* << */ + 2, /* <= */ + 2, /* == */ + 2, /* =~ */ + 2, /* >= */ + 2, /* >> */ + 2, /* GC */ + 2, /* IO */ + 2, /* PI */ + 2, /* [] */ + 2, /* af */ + 2, /* ai */ + 2, /* ar */ + 2, /* at */ + 2, /* bi */ + 2, /* bs */ + 2, /* cp */ + 2, /* e0 */ + 2, /* e2 */ + 2, /* e3 */ + 2, /* ed */ + 2, /* ei */ + 2, /* fd */ + 2, /* gm */ + 2, /* in */ + 2, /* io */ + 2, /* ip */ + 2, /* lz */ + 2, /* nv */ + 2, /* pc */ + 2, /* sa */ + 2, /* sv */ + 2, /* tr */ + 2, /* vs */ + 2, /* wd */ + 2, /* || */ + 3, /* <=> */ + 3, /* === */ + 3, /* @af */ + 3, /* DIG */ + 3, /* Dir */ + 3, /* EIO */ + 3, /* MAX */ + 3, /* MIN */ + 3, /* NAN */ + 3, /* Set */ + 3, /* []= */ + 3, /* abs */ + 3, /* add */ + 3, /* arg */ + 3, /* arr */ + 3, /* ary */ + 3, /* beg */ + 3, /* blk */ + 3, /* chr */ + 3, /* cmd */ + 3, /* cmp */ + 3, /* cos */ + 3, /* day */ + 3, /* dig */ + 3, /* div */ + 3, /* dup */ + 3, /* end */ + 3, /* env */ + 3, /* eof */ + 3, /* erf */ + 3, /* err */ + 3, /* exp */ + 3, /* fib */ + 3, /* hex */ + 3, /* idx */ + 3, /* int */ + 3, /* ip? */ + 3, /* key */ + 3, /* kwd */ + 3, /* len */ + 3, /* lhs */ + 3, /* lim */ + 3, /* log */ + 3, /* low */ + 3, /* map */ + 3, /* max */ + 3, /* mid */ + 3, /* min */ + 3, /* mod */ + 3, /* mon */ + 3, /* msg */ + 3, /* new */ + 3, /* now */ + 3, /* num */ + 3, /* obj */ + 3, /* oct */ + 3, /* opt */ + 3, /* ord */ + 3, /* out */ + 3, /* pat */ + 3, /* pid */ + 3, /* pop */ + 3, /* pos */ + 3, /* pow */ + 3, /* pre */ + 3, /* pwd */ + 3, /* quo */ + 3, /* red */ + 3, /* req */ + 3, /* res */ + 3, /* rhs */ + 3, /* row */ + 3, /* sec */ + 3, /* sep */ + 3, /* set */ + 3, /* sin */ + 3, /* str */ + 3, /* sub */ + 3, /* sum */ + 3, /* sym */ + 3, /* tag */ + 3, /* tan */ + 3, /* tap */ + 3, /* tcp */ + 3, /* tmp */ + 3, /* tr! */ + 3, /* udp */ + 3, /* utc */ + 3, /* val */ + 3, /* zip */ + 4, /* @dst */ + 4, /* @fib */ + 4, /* @kwd */ + 4, /* @obj */ + 4, /* @pos */ + 4, /* @tag */ + 4, /* ARGV */ + 4, /* Data */ + 4, /* EADV */ + 4, /* EDOM */ + 4, /* EXCL */ + 4, /* FREE */ + 4, /* File */ + 4, /* Hash */ + 4, /* JSON */ + 4, /* Lazy */ + 4, /* Math */ + 4, /* NONE */ + 4, /* NULL */ + 4, /* Proc */ + 4, /* RDWR */ + 4, /* SYNC */ + 4, /* Time */ + 4, /* abs2 */ + 4, /* acos */ + 4, /* add? */ + 4, /* addr */ + 4, /* all? */ + 4, /* any? */ + 4, /* arg0 */ + 4, /* arg1 */ + 4, /* arg2 */ + 4, /* args */ + 4, /* argv */ + 4, /* arys */ + 4, /* asin */ + 4, /* atan */ + 4, /* attr */ + 4, /* bind */ + 4, /* blue */ + 4, /* bold */ + 4, /* bool */ + 4, /* bsiz */ + 4, /* byte */ + 4, /* call */ + 4, /* cbrt */ + 4, /* ceil */ + 4, /* char */ + 4, /* chop */ + 4, /* conj */ + 4, /* cosh */ + 4, /* curr */ + 4, /* cyan */ + 4, /* data */ + 4, /* drop */ + 4, /* dst? */ + 4, /* dump */ + 4, /* e_id */ + 4, /* each */ + 4, /* elem */ + 4, /* enum */ + 4, /* eof? */ + 4, /* epos */ + 4, /* eql? */ + 4, /* erfc */ + 4, /* eval */ + 4, /* exit */ + 4, /* fail */ + 4, /* fdiv */ + 4, /* feed */ + 4, /* file */ + 4, /* fill */ + 4, /* find */ + 4, /* flag */ + 4, /* func */ + 4, /* getc */ + 4, /* gets */ + 4, /* gmt? */ + 4, /* gray */ + 4, /* grep */ + 4, /* gsub */ + 4, /* hash */ + 4, /* high */ + 4, /* host */ + 4, /* hour */ + 4, /* idx2 */ + 4, /* imag */ + 4, /* init */ + 4, /* join */ + 4, /* json */ + 4, /* key? */ + 4, /* keys */ + 4, /* last */ + 4, /* lazy */ + 4, /* line */ + 4, /* list */ + 4, /* load */ + 4, /* log2 */ + 4, /* loop */ + 4, /* map! */ + 4, /* mask */ + 4, /* mday */ + 4, /* mesg */ + 4, /* meth */ + 4, /* mode */ + 4, /* name */ + 4, /* nan? */ + 4, /* next */ + 4, /* nil? */ + 4, /* none */ + 4, /* ntop */ + 4, /* odd? */ + 4, /* one? */ + 4, /* open */ + 4, /* opts */ + 4, /* orig */ + 4, /* pack */ + 4, /* pad1 */ + 4, /* pad2 */ + 4, /* pair */ + 4, /* path */ + 4, /* peek */ + 4, /* perm */ + 4, /* pipe */ + 4, /* plen */ + 4, /* port */ + 4, /* pos= */ + 4, /* proc */ + 4, /* pton */ + 4, /* push */ + 4, /* puts */ + 4, /* rand */ + 4, /* read */ + 4, /* real */ + 4, /* rect */ + 4, /* recv */ + 4, /* rest */ + 4, /* sary */ + 4, /* seek */ + 4, /* seen */ + 4, /* send */ + 4, /* sinh */ + 4, /* size */ + 4, /* sock */ + 4, /* sort */ + 4, /* sqrt */ + 4, /* step */ + 4, /* str2 */ + 4, /* sub! */ + 4, /* succ */ + 4, /* sync */ + 4, /* take */ + 4, /* tanh */ + 4, /* tell */ + 4, /* then */ + 4, /* to_a */ + 4, /* to_c */ + 4, /* to_f */ + 4, /* to_h */ + 4, /* to_i */ + 4, /* to_r */ + 4, /* to_s */ + 4, /* tr_s */ + 4, /* tty? */ + 4, /* type */ + 4, /* uniq */ + 4, /* unix */ + 4, /* upto */ + 4, /* usec */ + 4, /* utc? */ + 4, /* vals */ + 4, /* wday */ + 4, /* yday */ + 4, /* year */ + 4, /* zone */ + 5, /* @args */ + 5, /* @hash */ + 5, /* @meth */ + 5, /* @name */ + 5, /* @path */ + 5, /* @proc */ + 5, /* @size */ + 5, /* Array */ + 5, /* CMath */ + 5, /* CREAT */ + 5, /* Chain */ + 5, /* Class */ + 5, /* DSYNC */ + 5, /* E2BIG */ + 5, /* EAUTH */ + 5, /* EBADE */ + 5, /* EBADF */ + 5, /* EBADR */ + 5, /* EBUSY */ + 5, /* ECOMM */ + 5, /* EFBIG */ + 5, /* EIDRM */ + 5, /* EINTR */ + 5, /* ELOOP */ + 5, /* ENOSR */ + 5, /* ENXIO */ + 5, /* EPERM */ + 5, /* EPIPE */ + 5, /* EROFS */ + 5, /* ESRCH */ + 5, /* ETIME */ + 5, /* EXDEV */ + 5, /* Errno */ + 5, /* Fiber */ + 5, /* Float */ + 5, /* RADIX */ + 5, /* RSYNC */ + 5, /* Range */ + 5, /* STDIN */ + 5, /* TOTAL */ + 5, /* TRUNC */ + 5, /* T_ENV */ + 5, /* UTF_8 */ + 5, /* _bind */ + 5, /* _name */ + 5, /* _pipe */ + 5, /* _proc */ + 5, /* _recv */ + 5, /* acosh */ + 5, /* angle */ + 5, /* arity */ + 5, /* array */ + 5, /* ary_F */ + 5, /* ary_T */ + 5, /* asinh */ + 5, /* assoc */ + 5, /* atan2 */ + 5, /* atanh */ + 5, /* atime */ + 5, /* begin */ + 5, /* black */ + 5, /* blink */ + 5, /* block */ + 5, /* bytes */ + 5, /* catch */ + 5, /* chain */ + 5, /* chars */ + 5, /* chdir */ + 5, /* chmod */ + 5, /* chomp */ + 5, /* chop! */ + 5, /* chunk */ + 5, /* clamp */ + 5, /* class */ + 5, /* clear */ + 5, /* clone */ + 5, /* close */ + 5, /* color */ + 5, /* count */ + 5, /* ctime */ + 5, /* curry */ + 5, /* cycle */ + 5, /* depth */ + 5, /* enums */ + 5, /* errno */ + 5, /* even? */ + 5, /* exit! */ + 5, /* fetch */ + 5, /* field */ + 5, /* file? */ + 5, /* first */ + 5, /* flags */ + 5, /* flock */ + 5, /* floor */ + 5, /* flush */ + 5, /* fname */ + 5, /* force */ + 5, /* found */ + 5, /* frexp */ + 5, /* getgm */ + 5, /* getwd */ + 5, /* green */ + 5, /* group */ + 5, /* gsub! */ + 5, /* hypot */ + 5, /* index */ + 5, /* ipv4? */ + 5, /* ipv6? */ + 5, /* is_a? */ + 5, /* ldexp */ + 5, /* level */ + 5, /* lines */ + 5, /* ljust */ + 5, /* local */ + 5, /* log10 */ + 5, /* merge */ + 5, /* mkdir */ + 5, /* month */ + 5, /* mtime */ + 5, /* names */ + 5, /* next! */ + 5, /* none? */ + 5, /* other */ + 5, /* owner */ + 5, /* parse */ + 5, /* phase */ + 5, /* pipe? */ + 5, /* polar */ + 5, /* popen */ + 5, /* pproc */ + 5, /* pread */ + 5, /* print */ + 5, /* proto */ + 5, /* raise */ + 5, /* real? */ + 5, /* reset */ + 5, /* rjust */ + 5, /* rmdir */ + 5, /* round */ + 5, /* shift */ + 5, /* size? */ + 5, /* sleep */ + 5, /* slice */ + 5, /* sort! */ + 5, /* split */ + 5, /* srand */ + 5, /* start */ + 5, /* state */ + 5, /* store */ + 5, /* strip */ + 5, /* succ! */ + 5, /* sync= */ + 5, /* taken */ + 5, /* tally */ + 5, /* throw */ + 5, /* times */ + 5, /* to_io */ + 5, /* total */ + 5, /* tr_s! */ + 5, /* umask */ + 5, /* union */ + 5, /* uniq! */ + 5, /* unix? */ + 5, /* value */ + 5, /* white */ + 5, /* width */ + 5, /* write */ + 5, /* yield */ + 5, /* zero? */ + 6, /* $DEBUG */ + 6, /* $stdin */ + 6, /* @enums */ + 6, /* @value */ + 6, /* AF_MAX */ + 6, /* APPEND */ + 6, /* BINARY */ + 6, /* DIRECT */ + 6, /* EACCES */ + 6, /* EAGAIN */ + 6, /* EBADFD */ + 6, /* EBFONT */ + 6, /* ECHILD */ + 6, /* ECHRNG */ + 6, /* EDQUOT */ + 6, /* EEXIST */ + 6, /* EFAULT */ + 6, /* EFTYPE */ + 6, /* EILSEQ */ + 6, /* EINVAL */ + 6, /* EIPSEC */ + 6, /* EISDIR */ + 6, /* EISNAM */ + 6, /* EL2HLT */ + 6, /* EL3HLT */ + 6, /* EL3RST */ + 6, /* ELNRNG */ + 6, /* EMFILE */ + 6, /* EMLINK */ + 6, /* ENFILE */ + 6, /* ENOANO */ + 6, /* ENOCSI */ + 6, /* ENODEV */ + 6, /* ENOENT */ + 6, /* ENOKEY */ + 6, /* ENOLCK */ + 6, /* ENOMEM */ + 6, /* ENOMSG */ + 6, /* ENONET */ + 6, /* ENOPKG */ + 6, /* ENOSPC */ + 6, /* ENOSTR */ + 6, /* ENOSYS */ + 6, /* ENOTTY */ + 6, /* EPROTO */ + 6, /* EQFULL */ + 6, /* ERANGE */ + 6, /* ESPIPE */ + 6, /* ESRMNT */ + 6, /* ESTALE */ + 6, /* EUSERS */ + 6, /* EXFULL */ + 6, /* Fixnum */ + 6, /* IP_MTU */ + 6, /* IP_TOS */ + 6, /* IP_TTL */ + 6, /* Kernel */ + 6, /* Method */ + 6, /* Module */ + 6, /* NOCTTY */ + 6, /* Object */ + 6, /* Option */ + 6, /* RDONLY */ + 6, /* Random */ + 6, /* Regexp */ + 6, /* SOL_IP */ + 6, /* STDERR */ + 6, /* STDOUT */ + 6, /* Socket */ + 6, /* Status */ + 6, /* String */ + 6, /* Struct */ + 6, /* Symbol */ + 6, /* T_CPTR */ + 6, /* T_DATA */ + 6, /* T_HASH */ + 6, /* T_PROC */ + 6, /* WRONLY */ + 6, /* __id__ */ + 6, /* _alone */ + 6, /* _atime */ + 6, /* _chdir */ + 6, /* _ctime */ + 6, /* _klass */ + 6, /* _mtime */ + 6, /* _owner */ + 6, /* _popen */ + 6, /* accept */ + 6, /* alive? */ + 6, /* append */ + 6, /* caller */ + 6, /* center */ + 6, /* chomp! */ + 6, /* chroot */ + 6, /* concat */ + 6, /* cover? */ + 6, /* define */ + 6, /* delete */ + 6, /* detect */ + 6, /* digits */ + 6, /* divide */ + 6, /* divmod */ + 6, /* domain */ + 6, /* downto */ + 6, /* empty? */ + 6, /* enable */ + 6, /* equal? */ + 6, /* except */ + 6, /* exist? */ + 6, /* extend */ + 6, /* family */ + 6, /* fileno */ + 6, /* filter */ + 6, /* for_fd */ + 6, /* format */ + 6, /* freeze */ + 6, /* getutc */ + 6, /* gmtime */ + 6, /* grep_v */ + 6, /* ifnone */ + 6, /* inject */ + 6, /* insert */ + 6, /* intern */ + 6, /* invert */ + 6, /* isatty */ + 6, /* itself */ + 6, /* lambda */ + 6, /* length */ + 6, /* linger */ + 6, /* listen */ + 6, /* longer */ + 6, /* lstrip */ + 6, /* max_by */ + 6, /* maxlen */ + 6, /* merge! */ + 6, /* method */ + 6, /* min_by */ + 6, /* minmax */ + 6, /* mktime */ + 6, /* modulo */ + 6, /* object */ + 6, /* offset */ + 6, /* others */ + 6, /* padstr */ + 6, /* printf */ + 6, /* public */ + 6, /* pwrite */ + 6, /* random */ + 6, /* rassoc */ + 6, /* reduce */ + 6, /* rehash */ + 6, /* reject */ + 6, /* rename */ + 6, /* result */ + 6, /* resume */ + 6, /* rewind */ + 6, /* rindex */ + 6, /* rotate */ + 6, /* rstrip */ + 6, /* sample */ + 6, /* select */ + 6, /* slice! */ + 6, /* status */ + 6, /* string */ + 6, /* strip! */ + 6, /* to_int */ + 6, /* to_str */ + 6, /* to_sym */ + 6, /* unbind */ + 6, /* ungetc */ + 6, /* unlink */ + 6, /* unpack */ + 6, /* upcase */ + 6, /* update */ + 6, /* usleep */ + 6, /* valid? */ + 6, /* value? */ + 6, /* values */ + 6, /* yellow */ + 7, /* $stderr */ + 7, /* $stdout */ + 7, /* @family */ + 7, /* AF_INET */ + 7, /* AF_UNIX */ + 7, /* AI_FQDN */ + 7, /* Binding */ + 7, /* Complex */ + 7, /* EBADMSG */ + 7, /* EBADRPC */ + 7, /* EBADRQC */ + 7, /* EBADSLT */ + 7, /* EDEADLK */ + 7, /* EDEVERR */ + 7, /* EDOOFUS */ + 7, /* EDOTDOT */ + 7, /* EISCONN */ + 7, /* ELIBACC */ + 7, /* ELIBBAD */ + 7, /* ELIBMAX */ + 7, /* ELIBSCN */ + 7, /* ENAVAIL */ + 7, /* ENOATTR */ + 7, /* ENOBUFS */ + 7, /* ENODATA */ + 7, /* ENOEXEC */ + 7, /* ENOLINK */ + 7, /* ENOTBLK */ + 7, /* ENOTDIR */ + 7, /* ENOTNAM */ + 7, /* ENOTSUP */ + 7, /* EPSILON */ + 7, /* EPWROFF */ + 7, /* EREMCHG */ + 7, /* EREMOTE */ + 7, /* ERFKILL */ + 7, /* ETXTBSY */ + 7, /* EUCLEAN */ + 7, /* EUNATCH */ + 7, /* IOError */ + 7, /* Integer */ + 7, /* LOCK_EX */ + 7, /* LOCK_NB */ + 7, /* LOCK_SH */ + 7, /* LOCK_UN */ + 7, /* MAX_EXP */ + 7, /* MIN_EXP */ + 7, /* MSG_OOB */ + 7, /* NOATIME */ + 7, /* NOERROR */ + 7, /* Numeric */ + 7, /* PF_INET */ + 7, /* PF_UNIX */ + 7, /* Process */ + 7, /* SO_TYPE */ + 7, /* TMPFILE */ + 7, /* T_ARRAY */ + 7, /* T_BREAK */ + 7, /* T_CLASS */ + 7, /* T_FIBER */ + 7, /* T_FLOAT */ + 7, /* T_RANGE */ + 7, /* Yielder */ + 7, /* __lines */ + 7, /* __merge */ + 7, /* _accept */ + 7, /* _listen */ + 7, /* _socket */ + 7, /* afamily */ + 7, /* asctime */ + 7, /* backlog */ + 7, /* binding */ + 7, /* bsearch */ + 7, /* casecmp */ + 7, /* ceildiv */ + 7, /* closed? */ + 7, /* collect */ + 7, /* command */ + 7, /* compact */ + 7, /* compile */ + 7, /* connect */ + 7, /* current */ + 7, /* default */ + 7, /* delete! */ + 7, /* delete? */ + 7, /* dirname */ + 7, /* disable */ + 7, /* dropped */ + 7, /* element */ + 7, /* entries */ + 7, /* exists? */ + 7, /* extname */ + 7, /* filter! */ + 7, /* finite? */ + 7, /* flatten */ + 7, /* foreach */ + 7, /* friday? */ + 7, /* frozen? */ + 7, /* getbyte */ + 7, /* include */ + 7, /* inspect */ + 7, /* ip_port */ + 7, /* keep_if */ + 7, /* keyrest */ + 7, /* lambda? */ + 7, /* lstrip! */ + 7, /* magenta */ + 7, /* max_cmp */ + 7, /* member? */ + 7, /* members */ + 7, /* message */ + 7, /* methods */ + 7, /* min_cmp */ + 7, /* modules */ + 7, /* monday? */ + 7, /* nesting */ + 7, /* new_key */ + 7, /* nobits? */ + 7, /* numeric */ + 7, /* optname */ + 7, /* padding */ + 7, /* pattern */ + 7, /* pfamily */ + 7, /* pointer */ + 7, /* prepend */ + 7, /* private */ + 7, /* produce */ + 7, /* product */ + 7, /* reject! */ + 7, /* replace */ + 7, /* result= */ + 7, /* reverse */ + 7, /* rotate! */ + 7, /* rstrip! */ + 7, /* select! */ + 7, /* sep_len */ + 7, /* service */ + 7, /* setbyte */ + 7, /* shorter */ + 7, /* shuffle */ + 7, /* socket? */ + 7, /* sort_by */ + 7, /* sprintf */ + 7, /* squeeze */ + 7, /* subset? */ + 7, /* sunday? */ + 7, /* symlink */ + 7, /* sysopen */ + 7, /* sysread */ + 7, /* sysseek */ + 7, /* to_enum */ + 7, /* to_hash */ + 7, /* to_json */ + 7, /* to_proc */ + 7, /* unpack1 */ + 7, /* unshift */ + 7, /* upcase! */ + 7, /* yielder */ + 8, /* AF_INET6 */ + 8, /* Addrinfo */ + 8, /* EALREADY */ + 8, /* EBADARCH */ + 8, /* EBADEXEC */ + 8, /* ECAPMODE */ + 8, /* EL2NSYNC */ + 8, /* ELIBEXEC */ + 8, /* EMSGSIZE */ + 8, /* ENETDOWN */ + 8, /* ENOTCONN */ + 8, /* ENOTSOCK */ + 8, /* ENOTUNIQ */ + 8, /* EOFError */ + 8, /* EPROCLIM */ + 8, /* ERESTART */ + 8, /* ESTRPIPE */ + 8, /* Encoding */ + 8, /* FileTest */ + 8, /* INFINITY */ + 8, /* IPSocket */ + 8, /* KeyError */ + 8, /* MANT_DIG */ + 8, /* MSG_PEEK */ + 8, /* NI_DGRAM */ + 8, /* NOFOLLOW */ + 8, /* NONBLOCK */ + 8, /* NilClass */ + 8, /* PF_INET6 */ + 8, /* Rational */ + 8, /* SEEK_CUR */ + 8, /* SEEK_END */ + 8, /* SEEK_SET */ + 8, /* SOCK_RAW */ + 8, /* SO_DEBUG */ + 8, /* SO_ERROR */ + 8, /* T_BIGINT */ + 8, /* T_ICLASS */ + 8, /* T_MODULE */ + 8, /* T_OBJECT */ + 8, /* T_SCLASS */ + 8, /* T_STRING */ + 8, /* T_STRUCT */ + 8, /* __delete */ + 8, /* __send__ */ + 8, /* __svalue */ + 8, /* __to_int */ + 8, /* _accept2 */ + 8, /* _connect */ + 8, /* allbits? */ + 8, /* allocate */ + 8, /* anybits? */ + 8, /* basename */ + 8, /* between? */ + 8, /* bytesize */ + 8, /* casecmp? */ + 8, /* children */ + 8, /* classify */ + 8, /* collect! */ + 8, /* colorize */ + 8, /* compact! */ + 8, /* default= */ + 8, /* downcase */ + 8, /* dropping */ + 8, /* each_key */ + 8, /* encoding */ + 8, /* enum_for */ + 8, /* extended */ + 8, /* filename */ + 8, /* find_all */ + 8, /* flat_map */ + 8, /* flatten! */ + 8, /* generate */ + 8, /* getlocal */ + 8, /* group_by */ + 8, /* has_key? */ + 8, /* include? */ + 8, /* included */ + 8, /* integer? */ + 8, /* kind_of? */ + 8, /* modified */ + 8, /* new_args */ + 8, /* nodename */ + 8, /* nonzero? */ + 8, /* overlap? */ + 8, /* peeraddr */ + 8, /* protocol */ + 8, /* readbyte */ + 8, /* readchar */ + 8, /* readline */ + 8, /* readlink */ + 8, /* realpath */ + 8, /* receiver */ + 8, /* recvfrom */ + 8, /* reverse! */ + 8, /* self_end */ + 8, /* self_len */ + 8, /* servname */ + 8, /* shuffle! */ + 8, /* shutdown */ + 8, /* sockaddr */ + 8, /* socktype */ + 8, /* sort_by! */ + 8, /* squeeze! */ + 8, /* str_each */ + 8, /* subtract */ + 8, /* swapcase */ + 8, /* symlink? */ + 8, /* syswrite */ + 8, /* transfer */ + 8, /* truncate */ + 8, /* tuesday? */ + 9, /* @hostname */ + 9, /* @protocol */ + 9, /* @sockaddr */ + 9, /* @socktype */ + 9, /* @stop_exc */ + 9, /* AF_UNSPEC */ + 9, /* Constants */ + 9, /* EBADMACHO */ + 9, /* ECANCELED */ + 9, /* EDEADLOCK */ + 9, /* EHOSTDOWN */ + 9, /* EMULTIHOP */ + 9, /* ENEEDAUTH */ + 9, /* ENETRESET */ + 9, /* ENOMEDIUM */ + 9, /* ENOPOLICY */ + 9, /* ENOTEMPTY */ + 9, /* EOVERFLOW */ + 9, /* EREMOTEIO */ + 9, /* ESHUTDOWN */ + 9, /* ETIMEDOUT */ + 9, /* Exception */ + 9, /* Generator */ + 9, /* MSG_BCAST */ + 9, /* MSG_MCAST */ + 9, /* MSG_TRUNC */ + 9, /* NI_NOFQDN */ + 9, /* NameError */ + 9, /* PF_UNSPEC */ + 9, /* SEPARATOR */ + 9, /* SHUT_RDWR */ + 9, /* SO_LINGER */ + 9, /* SO_RCVBUF */ + 9, /* SO_SNDBUF */ + 9, /* TCPServer */ + 9, /* TCPSocket */ + 9, /* T_COMPLEX */ + 9, /* T_INTEGER */ + 9, /* T_ISTRUCT */ + 9, /* TrueClass */ + 9, /* TypeError */ + 9, /* UDPSocket */ + 9, /* __compact */ + 9, /* __outer__ */ + 9, /* _allocate */ + 9, /* _gc_root_ */ + 9, /* _recvfrom */ + 9, /* _sys_fail */ + 9, /* _sysclose */ + 9, /* _to_array */ + 9, /* ancestors */ + 9, /* backtrace */ + 9, /* bind_call */ + 9, /* byteindex */ + 9, /* byteslice */ + 9, /* conjugate */ + 9, /* const_get */ + 9, /* const_set */ + 9, /* constants */ + 9, /* delete_at */ + 9, /* delete_if */ + 9, /* disjoint? */ + 9, /* downcase! */ + 9, /* each_byte */ + 9, /* each_char */ + 9, /* each_cons */ + 9, /* each_line */ + 9, /* each_pair */ + 9, /* end_with? */ + 9, /* exception */ + 9, /* exclusive */ + 9, /* feedvalue */ + 9, /* imaginary */ + 9, /* infinite? */ + 9, /* inherited */ + 9, /* invisible */ + 9, /* ip_unpack */ + 9, /* iterator? */ + 9, /* load_file */ + 9, /* localtime */ + 9, /* magnitude */ + 9, /* minmax_by */ + 9, /* negative? */ + 9, /* numerator */ + 9, /* object_id */ + 9, /* other_end */ + 9, /* partition */ + 9, /* positive? */ + 9, /* prepended */ + 9, /* protected */ + 9, /* readlines */ + 9, /* remainder */ + 9, /* satisfied */ + 9, /* saturday? */ + 9, /* self_excl */ + 9, /* separator */ + 9, /* set_color */ + 9, /* superset? */ + 9, /* swapcase! */ + 9, /* sysaccept */ + 9, /* thursday? */ + 9, /* transpose */ + 9, /* underline */ + 9, /* ungetbyte */ + 9, /* unix_path */ + 9, /* validated */ + 9, /* values_at */ + 10, /* @feedvalue */ + 10, /* @lookahead */ + 10, /* AI_PASSIVE */ + 10, /* ASCII_8BIT */ + 10, /* Comparable */ + 10, /* EADDRINUSE */ + 10, /* ECONNRESET */ + 10, /* EINTEGRITY */ + 10, /* EOPNOTSUPP */ + 10, /* EOWNERDEAD */ + 10, /* EPROTOTYPE */ + 10, /* ESHLIBVERS */ + 10, /* Enumerable */ + 10, /* Enumerator */ + 10, /* FalseClass */ + 10, /* FiberError */ + 10, /* IPPROTO_AH */ + 10, /* IPPROTO_IP */ + 10, /* IP_HDRINCL */ + 10, /* IP_OPTIONS */ + 10, /* IP_PKTINFO */ + 10, /* IP_RECVERR */ + 10, /* IP_RECVTOS */ + 10, /* IP_RECVTTL */ + 10, /* IndexError */ + 10, /* MAX_10_EXP */ + 10, /* MIN_10_EXP */ + 10, /* MSG_CTRUNC */ + 10, /* NI_MAXHOST */ + 10, /* NI_MAXSERV */ + 10, /* RangeError */ + 10, /* SOCK_DGRAM */ + 10, /* SOL_SOCKET */ + 10, /* SystemExit */ + 10, /* TCP_MAXSEG */ + 10, /* T_RATIONAL */ + 10, /* UNIXServer */ + 10, /* UNIXSocket */ + 10, /* __callee__ */ + 10, /* __case_eqq */ + 10, /* __get_hash */ + 10, /* __method__ */ + 10, /* __num_to_a */ + 10, /* _separator */ + 10, /* bright_red */ + 10, /* byterindex */ + 10, /* bytesplice */ + 10, /* capitalize */ + 10, /* class_eval */ + 10, /* class_exec */ + 10, /* codepoints */ + 10, /* color_null */ + 10, /* difference */ + 10, /* directory? */ + 10, /* drop_while */ + 10, /* each_child */ + 10, /* each_entry */ + 10, /* each_index */ + 10, /* each_slice */ + 10, /* each_value */ + 10, /* fd_or_path */ + 10, /* filter_map */ + 10, /* find_index */ + 10, /* getaddress */ + 10, /* getpeereid */ + 10, /* getsockopt */ + 10, /* given_args */ + 10, /* has_value? */ + 10, /* initialize */ + 10, /* intersect? */ + 10, /* ip_address */ + 10, /* last_value */ + 10, /* local_host */ + 10, /* make_curry */ + 10, /* memsize_of */ + 10, /* other_excl */ + 10, /* parameters */ + 10, /* rpartition */ + 10, /* self_arity */ + 10, /* self_begin */ + 10, /* setsockopt */ + 10, /* socketpair */ + 10, /* step_ratio */ + 10, /* subclasses */ + 10, /* superclass */ + 10, /* take_while */ + 10, /* wednesday? */ + 10, /* with_index */ + 10, /* yield_self */ + 11, /* @color_null */ + 11, /* BasicObject */ + 11, /* BasicSocket */ + 11, /* DomainError */ + 11, /* EINPROGRESS */ + 11, /* EKEYEXPIRED */ + 11, /* EKEYREVOKED */ + 11, /* EMEDIUMTYPE */ + 11, /* ENETUNREACH */ + 11, /* ENOPROTOOPT */ + 11, /* ENOTCAPABLE */ + 11, /* EWOULDBLOCK */ + 11, /* FNM_SYSCASE */ + 11, /* FrozenError */ + 11, /* IPPROTO_ESP */ + 11, /* IPPROTO_RAW */ + 11, /* IPPROTO_TCP */ + 11, /* IPPROTO_UDP */ + 11, /* IPV6_V6ONLY */ + 11, /* NI_NAMEREQD */ + 11, /* ObjectSpace */ + 11, /* ParserError */ + 11, /* RUBY_ENGINE */ + 11, /* RegexpError */ + 11, /* SOCK_STREAM */ + 11, /* SO_RCVLOWAT */ + 11, /* SO_RCVTIMEO */ + 11, /* SO_SNDLOWAT */ + 11, /* SO_SNDTIMEO */ + 11, /* ScriptError */ + 11, /* SocketError */ + 11, /* SyntaxError */ + 11, /* TCP_KEEPCNT */ + 11, /* TCP_NODELAY */ + 11, /* T_EXCEPTION */ + 11, /* __members__ */ + 11, /* _is_socket= */ + 11, /* ascii_only? */ + 11, /* attr_reader */ + 11, /* attr_writer */ + 11, /* bright_blue */ + 11, /* bright_cyan */ + 11, /* capitalize! */ + 11, /* chunk_while */ + 11, /* close_write */ + 11, /* color_null= */ + 11, /* combination */ + 11, /* denominator */ + 11, /* each_object */ + 11, /* expand_path */ + 11, /* getaddrinfo */ + 11, /* gethostname */ + 11, /* getnameinfo */ + 11, /* getpeername */ + 11, /* getsockname */ + 11, /* max_nesting */ + 11, /* module_eval */ + 11, /* module_exec */ + 11, /* next_values */ + 11, /* other_begin */ + 11, /* peek_values */ + 11, /* permutation */ + 11, /* rectangular */ + 11, /* respond_to? */ + 11, /* sockaddr_in */ + 11, /* sockaddr_un */ + 11, /* start_with? */ + 11, /* step_ratio= */ + 11, /* to_sockaddr */ + 11, /* valid_mode? */ + 11, /* with_object */ + 12, /* AI_CANONNAME */ + 12, /* EAFNOSUPPORT */ + 12, /* ECONNABORTED */ + 12, /* ECONNREFUSED */ + 12, /* EDESTADDRREQ */ + 12, /* EHOSTUNREACH */ + 12, /* EKEYREJECTED */ + 12, /* ENAMETOOLONG */ + 12, /* EPFNOSUPPORT */ + 12, /* EPROCUNAVAIL */ + 12, /* EPROGUNAVAIL */ + 12, /* ERPCMISMATCH */ + 12, /* ETOOMANYREFS */ + 12, /* FNM_CASEFOLD */ + 12, /* FNM_DOTMATCH */ + 12, /* FNM_NOESCAPE */ + 12, /* FNM_PATHNAME */ + 12, /* IPPROTO_ICMP */ + 12, /* IPPROTO_IPV6 */ + 12, /* IPPROTO_NONE */ + 12, /* NestingError */ + 12, /* RUBY_VERSION */ + 12, /* RuntimeError */ + 12, /* SHARE_DELETE */ + 12, /* SO_BROADCAST */ + 12, /* SO_DONTROUTE */ + 12, /* SO_KEEPALIVE */ + 12, /* SO_OOBINLINE */ + 12, /* SO_REUSEADDR */ + 12, /* TCP_KEEPIDLE */ + 12, /* __ENCODING__ */ + 12, /* __attached__ */ + 12, /* __codepoints */ + 12, /* __errno_list */ + 12, /* _setnonblock */ + 12, /* _sockaddr_in */ + 12, /* alias_method */ + 12, /* block_given? */ + 12, /* bright_black */ + 12, /* bright_green */ + 12, /* bright_white */ + 12, /* color_number */ + 12, /* color_string */ + 12, /* column_count */ + 12, /* column_index */ + 12, /* default_proc */ + 12, /* exclude_end? */ + 12, /* fetch_values */ + 12, /* instance_of? */ + 12, /* intersection */ + 12, /* method_added */ + 12, /* mruby_Random */ + 12, /* pretty_print */ + 12, /* remove_const */ + 12, /* reverse_each */ + 12, /* super_method */ + 12, /* undef_method */ + 13, /* @color_string */ + 13, /* @init_with_fd */ + 13, /* ALT_SEPARATOR */ + 13, /* ArgumentError */ + 13, /* EADDRNOTAVAIL */ + 13, /* EPROGMISMATCH */ + 13, /* MRUBY_VERSION */ + 13, /* MSG_DONTROUTE */ + 13, /* NoMemoryError */ + 13, /* NoMethodError */ + 13, /* StandardError */ + 13, /* StopIteration */ + 13, /* TCP_KEEPALIVE */ + 13, /* TCP_KEEPINTVL */ + 13, /* TerminalColor */ + 13, /* UnboundMethod */ + 13, /* __classname__ */ + 13, /* __sub_replace */ + 13, /* __update_hash */ + 13, /* absolute_path */ + 13, /* attr_accessor */ + 13, /* bright_yellow */ + 13, /* bsearch_index */ + 13, /* color_boolean */ + 13, /* color_string= */ + 13, /* const_missing */ + 13, /* count_objects */ + 13, /* default_proc= */ + 13, /* define_method */ + 13, /* delete_prefix */ + 13, /* delete_suffix */ + 13, /* extend_object */ + 13, /* fast_generate */ + 13, /* flatten_merge */ + 13, /* in_lower_half */ + 13, /* instance_eval */ + 13, /* instance_exec */ + 13, /* local_address */ + 13, /* local_service */ + 13, /* recv_nonblock */ + 13, /* remove_method */ + 13, /* set_backtrace */ + 14, /* @color_boolean */ + 14, /* AI_NUMERICHOST */ + 14, /* AI_NUMERICSERV */ + 14, /* GeneratorError */ + 14, /* IPPROTO_ICMPV6 */ + 14, /* IP_RECVDSTADDR */ + 14, /* LocalJumpError */ + 14, /* NI_NUMERICHOST */ + 14, /* NI_NUMERICSERV */ + 14, /* PATH_SEPARATOR */ + 14, /* SOCK_SEQPACKET */ + 14, /* __do_with_enum */ + 14, /* __empty_range? */ + 14, /* __errno_define */ + 14, /* __upto_endless */ + 14, /* absolute_path? */ + 14, /* bright_magenta */ + 14, /* close_on_exec= */ + 14, /* close_on_exec? */ + 14, /* collect_concat */ + 14, /* color_boolean= */ + 14, /* const_defined? */ + 14, /* delete_prefix! */ + 14, /* delete_suffix! */ + 14, /* each_codepoint */ + 14, /* force_encoding */ + 14, /* interval_ratio */ + 14, /* memsize_of_all */ + 14, /* method_missing */ + 14, /* method_removed */ + 14, /* paragraph_mode */ + 14, /* proper_subset? */ + 14, /* public_methods */ + 14, /* remote_address */ + 14, /* transform_keys */ + 15, /* ANSI_MODE_CODES */ + 15, /* ENOTRECOVERABLE */ + 15, /* EPROTONOSUPPORT */ + 15, /* ESOCKTNOSUPPORT */ + 15, /* IPPROTO_DSTOPTS */ + 15, /* IPPROTO_ROUTING */ + 15, /* IPV6_JOIN_GROUP */ + 15, /* IP_BLOCK_SOURCE */ + 15, /* IP_MTU_DISCOVER */ + 15, /* IP_MULTICAST_IF */ + 15, /* MRUBY_COPYRIGHT */ + 15, /* SystemCallError */ + 15, /* accept_nonblock */ + 15, /* append_as_bytes */ + 15, /* append_features */ + 15, /* attached_object */ + 15, /* class_variables */ + 15, /* each_with_index */ + 15, /* initialize_copy */ + 15, /* instance_method */ + 15, /* interval_ratio= */ + 15, /* local_variables */ + 15, /* method_defined? */ + 15, /* module_function */ + 15, /* pad_repetitions */ + 15, /* pretty_generate */ + 15, /* private_methods */ + 15, /* singleton_class */ + 15, /* source_location */ + 15, /* symbolize_names */ + 15, /* transform_keys! */ + 15, /* valid_encoding? */ + 16, /* ANSI_COLOR_CODES */ + 16, /* FloatDomainError */ + 16, /* IPPROTO_FRAGMENT */ + 16, /* IPV6_LEAVE_GROUP */ + 16, /* IP_MULTICAST_TTL */ + 16, /* MCAST_JOIN_GROUP */ + 16, /* MRUBY_RELEASE_NO */ + 16, /* SystemStackError */ + 16, /* __errno_defined? */ + 16, /* _sockaddr_family */ + 16, /* color_object_key */ + 16, /* connect_nonblock */ + 16, /* each_with_object */ + 16, /* global_variables */ + 16, /* included_modules */ + 16, /* inspect_sockaddr */ + 16, /* instance_methods */ + 16, /* method_undefined */ + 16, /* pack_sockaddr_in */ + 16, /* pack_sockaddr_un */ + 16, /* prepend_features */ + 16, /* proper_superset? */ + 16, /* singleton_class? */ + 16, /* singleton_method */ + 16, /* transform_values */ + 17, /* @color_object_key */ + 17, /* IPV6_MULTICAST_IF */ + 17, /* IPV6_UNICAST_HOPS */ + 17, /* IP_ADD_MEMBERSHIP */ + 17, /* IP_MULTICAST_LOOP */ + 17, /* IP_UNBLOCK_SOURCE */ + 17, /* MCAST_LEAVE_GROUP */ + 17, /* MRUBY_DESCRIPTION */ + 17, /* ZeroDivisionError */ + 17, /* _new_with_prelude */ + 17, /* colorize_generate */ + 17, /* generational_mode */ + 17, /* protected_methods */ + 17, /* recvfrom_nonblock */ + 17, /* singleton_methods */ + 17, /* transform_values! */ + 18, /* IP_DROP_MEMBERSHIP */ + 18, /* MCAST_BLOCK_SOURCE */ + 18, /* MRUBY_RELEASE_DATE */ + 18, /* UncaughtThrowError */ + 18, /* class_variable_get */ + 18, /* class_variable_set */ + 18, /* generational_mode= */ + 18, /* instance_variables */ + 18, /* local_variable_get */ + 18, /* local_variable_set */ + 18, /* unpack_sockaddr_in */ + 18, /* unpack_sockaddr_un */ + 19, /* ANSI_BG_COLOR_CODES */ + 19, /* IPV6_MULTICAST_HOPS */ + 19, /* IPV6_MULTICAST_LOOP */ + 19, /* NotImplementedError */ + 19, /* RUBY_ENGINE_VERSION */ + 19, /* respond_to_missing? */ + 20, /* MCAST_UNBLOCK_SOURCE */ + 20, /* __inspect_recursive? */ + 20, /* repeated_combination */ + 20, /* repeated_permutation */ + 20, /* set_color_object_key */ + 21, /* __coerce_step_counter */ + 21, /* do_not_reverse_lookup */ + 21, /* instance_variable_get */ + 21, /* instance_variable_set */ + 21, /* remove_class_variable */ + 22, /* @do_not_reverse_lookup */ + 22, /* __repeated_combination */ + 22, /* do_not_reverse_lookup= */ + 22, /* singleton_method_added */ + 23, /* @@do_not_reverse_lookup */ + 23, /* MCAST_JOIN_SOURCE_GROUP */ + 23, /* __enumerator_block_call */ + 23, /* class_variable_defined? */ + 23, /* define_singleton_method */ + 23, /* local_variable_defined? */ + 23, /* public_instance_methods */ + 24, /* IP_ADD_SOURCE_MEMBERSHIP */ + 24, /* MCAST_LEAVE_SOURCE_GROUP */ + 24, /* private_instance_methods */ + 24, /* remove_instance_variable */ + 24, /* singleton_method_removed */ + 25, /* IP_DROP_SOURCE_MEMBERSHIP */ + 26, /* instance_variable_defined? */ + 26, /* protected_instance_methods */ + 26, /* singleton_method_undefined */ + 26, /* undefined_instance_methods */ +}; + +static const char * const presym_name_table[] = { + "!", + "%", + "&", + "*", + "+", + "-", + "/", + "<", + ">", + "E", + "^", + "`", + "a", + "b", + "c", + "d", + "e", + "f", + "h", + "i", + "j", + "k", + "l", + "m", + "n", + "o", + "p", + "r", + "s", + "t", + "v", + "w", + "x", + "y", + "z", + "|", + "~", + "!=", + "!~", + "$0", + "$?", + "&&", + "**", + "+@", + "-@", + "<<", + "<=", + "==", + "=~", + ">=", + ">>", + "GC", + "IO", + "PI", + "[]", + "af", + "ai", + "ar", + "at", + "bi", + "bs", + "cp", + "e0", + "e2", + "e3", + "ed", + "ei", + "fd", + "gm", + "in", + "io", + "ip", + "lz", + "nv", + "pc", + "sa", + "sv", + "tr", + "vs", + "wd", + "||", + "<=>", + "===", + "@af", + "DIG", + "Dir", + "EIO", + "MAX", + "MIN", + "NAN", + "Set", + "[]=", + "abs", + "add", + "arg", + "arr", + "ary", + "beg", + "blk", + "chr", + "cmd", + "cmp", + "cos", + "day", + "dig", + "div", + "dup", + "end", + "env", + "eof", + "erf", + "err", + "exp", + "fib", + "hex", + "idx", + "int", + "ip?", + "key", + "kwd", + "len", + "lhs", + "lim", + "log", + "low", + "map", + "max", + "mid", + "min", + "mod", + "mon", + "msg", + "new", + "now", + "num", + "obj", + "oct", + "opt", + "ord", + "out", + "pat", + "pid", + "pop", + "pos", + "pow", + "pre", + "pwd", + "quo", + "red", + "req", + "res", + "rhs", + "row", + "sec", + "sep", + "set", + "sin", + "str", + "sub", + "sum", + "sym", + "tag", + "tan", + "tap", + "tcp", + "tmp", + "tr!", + "udp", + "utc", + "val", + "zip", + "@dst", + "@fib", + "@kwd", + "@obj", + "@pos", + "@tag", + "ARGV", + "Data", + "EADV", + "EDOM", + "EXCL", + "FREE", + "File", + "Hash", + "JSON", + "Lazy", + "Math", + "NONE", + "NULL", + "Proc", + "RDWR", + "SYNC", + "Time", + "abs2", + "acos", + "add?", + "addr", + "all?", + "any?", + "arg0", + "arg1", + "arg2", + "args", + "argv", + "arys", + "asin", + "atan", + "attr", + "bind", + "blue", + "bold", + "bool", + "bsiz", + "byte", + "call", + "cbrt", + "ceil", + "char", + "chop", + "conj", + "cosh", + "curr", + "cyan", + "data", + "drop", + "dst?", + "dump", + "e_id", + "each", + "elem", + "enum", + "eof?", + "epos", + "eql?", + "erfc", + "eval", + "exit", + "fail", + "fdiv", + "feed", + "file", + "fill", + "find", + "flag", + "func", + "getc", + "gets", + "gmt?", + "gray", + "grep", + "gsub", + "hash", + "high", + "host", + "hour", + "idx2", + "imag", + "init", + "join", + "json", + "key?", + "keys", + "last", + "lazy", + "line", + "list", + "load", + "log2", + "loop", + "map!", + "mask", + "mday", + "mesg", + "meth", + "mode", + "name", + "nan?", + "next", + "nil?", + "none", + "ntop", + "odd?", + "one?", + "open", + "opts", + "orig", + "pack", + "pad1", + "pad2", + "pair", + "path", + "peek", + "perm", + "pipe", + "plen", + "port", + "pos=", + "proc", + "pton", + "push", + "puts", + "rand", + "read", + "real", + "rect", + "recv", + "rest", + "sary", + "seek", + "seen", + "send", + "sinh", + "size", + "sock", + "sort", + "sqrt", + "step", + "str2", + "sub!", + "succ", + "sync", + "take", + "tanh", + "tell", + "then", + "to_a", + "to_c", + "to_f", + "to_h", + "to_i", + "to_r", + "to_s", + "tr_s", + "tty?", + "type", + "uniq", + "unix", + "upto", + "usec", + "utc?", + "vals", + "wday", + "yday", + "year", + "zone", + "@args", + "@hash", + "@meth", + "@name", + "@path", + "@proc", + "@size", + "Array", + "CMath", + "CREAT", + "Chain", + "Class", + "DSYNC", + "E2BIG", + "EAUTH", + "EBADE", + "EBADF", + "EBADR", + "EBUSY", + "ECOMM", + "EFBIG", + "EIDRM", + "EINTR", + "ELOOP", + "ENOSR", + "ENXIO", + "EPERM", + "EPIPE", + "EROFS", + "ESRCH", + "ETIME", + "EXDEV", + "Errno", + "Fiber", + "Float", + "RADIX", + "RSYNC", + "Range", + "STDIN", + "TOTAL", + "TRUNC", + "T_ENV", + "UTF_8", + "_bind", + "_name", + "_pipe", + "_proc", + "_recv", + "acosh", + "angle", + "arity", + "array", + "ary_F", + "ary_T", + "asinh", + "assoc", + "atan2", + "atanh", + "atime", + "begin", + "black", + "blink", + "block", + "bytes", + "catch", + "chain", + "chars", + "chdir", + "chmod", + "chomp", + "chop!", + "chunk", + "clamp", + "class", + "clear", + "clone", + "close", + "color", + "count", + "ctime", + "curry", + "cycle", + "depth", + "enums", + "errno", + "even?", + "exit!", + "fetch", + "field", + "file?", + "first", + "flags", + "flock", + "floor", + "flush", + "fname", + "force", + "found", + "frexp", + "getgm", + "getwd", + "green", + "group", + "gsub!", + "hypot", + "index", + "ipv4?", + "ipv6?", + "is_a?", + "ldexp", + "level", + "lines", + "ljust", + "local", + "log10", + "merge", + "mkdir", + "month", + "mtime", + "names", + "next!", + "none?", + "other", + "owner", + "parse", + "phase", + "pipe?", + "polar", + "popen", + "pproc", + "pread", + "print", + "proto", + "raise", + "real?", + "reset", + "rjust", + "rmdir", + "round", + "shift", + "size?", + "sleep", + "slice", + "sort!", + "split", + "srand", + "start", + "state", + "store", + "strip", + "succ!", + "sync=", + "taken", + "tally", + "throw", + "times", + "to_io", + "total", + "tr_s!", + "umask", + "union", + "uniq!", + "unix?", + "value", + "white", + "width", + "write", + "yield", + "zero?", + "$DEBUG", + "$stdin", + "@enums", + "@value", + "AF_MAX", + "APPEND", + "BINARY", + "DIRECT", + "EACCES", + "EAGAIN", + "EBADFD", + "EBFONT", + "ECHILD", + "ECHRNG", + "EDQUOT", + "EEXIST", + "EFAULT", + "EFTYPE", + "EILSEQ", + "EINVAL", + "EIPSEC", + "EISDIR", + "EISNAM", + "EL2HLT", + "EL3HLT", + "EL3RST", + "ELNRNG", + "EMFILE", + "EMLINK", + "ENFILE", + "ENOANO", + "ENOCSI", + "ENODEV", + "ENOENT", + "ENOKEY", + "ENOLCK", + "ENOMEM", + "ENOMSG", + "ENONET", + "ENOPKG", + "ENOSPC", + "ENOSTR", + "ENOSYS", + "ENOTTY", + "EPROTO", + "EQFULL", + "ERANGE", + "ESPIPE", + "ESRMNT", + "ESTALE", + "EUSERS", + "EXFULL", + "Fixnum", + "IP_MTU", + "IP_TOS", + "IP_TTL", + "Kernel", + "Method", + "Module", + "NOCTTY", + "Object", + "Option", + "RDONLY", + "Random", + "Regexp", + "SOL_IP", + "STDERR", + "STDOUT", + "Socket", + "Status", + "String", + "Struct", + "Symbol", + "T_CPTR", + "T_DATA", + "T_HASH", + "T_PROC", + "WRONLY", + "__id__", + "_alone", + "_atime", + "_chdir", + "_ctime", + "_klass", + "_mtime", + "_owner", + "_popen", + "accept", + "alive?", + "append", + "caller", + "center", + "chomp!", + "chroot", + "concat", + "cover?", + "define", + "delete", + "detect", + "digits", + "divide", + "divmod", + "domain", + "downto", + "empty?", + "enable", + "equal?", + "except", + "exist?", + "extend", + "family", + "fileno", + "filter", + "for_fd", + "format", + "freeze", + "getutc", + "gmtime", + "grep_v", + "ifnone", + "inject", + "insert", + "intern", + "invert", + "isatty", + "itself", + "lambda", + "length", + "linger", + "listen", + "longer", + "lstrip", + "max_by", + "maxlen", + "merge!", + "method", + "min_by", + "minmax", + "mktime", + "modulo", + "object", + "offset", + "others", + "padstr", + "printf", + "public", + "pwrite", + "random", + "rassoc", + "reduce", + "rehash", + "reject", + "rename", + "result", + "resume", + "rewind", + "rindex", + "rotate", + "rstrip", + "sample", + "select", + "slice!", + "status", + "string", + "strip!", + "to_int", + "to_str", + "to_sym", + "unbind", + "ungetc", + "unlink", + "unpack", + "upcase", + "update", + "usleep", + "valid?", + "value?", + "values", + "yellow", + "$stderr", + "$stdout", + "@family", + "AF_INET", + "AF_UNIX", + "AI_FQDN", + "Binding", + "Complex", + "EBADMSG", + "EBADRPC", + "EBADRQC", + "EBADSLT", + "EDEADLK", + "EDEVERR", + "EDOOFUS", + "EDOTDOT", + "EISCONN", + "ELIBACC", + "ELIBBAD", + "ELIBMAX", + "ELIBSCN", + "ENAVAIL", + "ENOATTR", + "ENOBUFS", + "ENODATA", + "ENOEXEC", + "ENOLINK", + "ENOTBLK", + "ENOTDIR", + "ENOTNAM", + "ENOTSUP", + "EPSILON", + "EPWROFF", + "EREMCHG", + "EREMOTE", + "ERFKILL", + "ETXTBSY", + "EUCLEAN", + "EUNATCH", + "IOError", + "Integer", + "LOCK_EX", + "LOCK_NB", + "LOCK_SH", + "LOCK_UN", + "MAX_EXP", + "MIN_EXP", + "MSG_OOB", + "NOATIME", + "NOERROR", + "Numeric", + "PF_INET", + "PF_UNIX", + "Process", + "SO_TYPE", + "TMPFILE", + "T_ARRAY", + "T_BREAK", + "T_CLASS", + "T_FIBER", + "T_FLOAT", + "T_RANGE", + "Yielder", + "__lines", + "__merge", + "_accept", + "_listen", + "_socket", + "afamily", + "asctime", + "backlog", + "binding", + "bsearch", + "casecmp", + "ceildiv", + "closed?", + "collect", + "command", + "compact", + "compile", + "connect", + "current", + "default", + "delete!", + "delete?", + "dirname", + "disable", + "dropped", + "element", + "entries", + "exists?", + "extname", + "filter!", + "finite?", + "flatten", + "foreach", + "friday?", + "frozen?", + "getbyte", + "include", + "inspect", + "ip_port", + "keep_if", + "keyrest", + "lambda?", + "lstrip!", + "magenta", + "max_cmp", + "member?", + "members", + "message", + "methods", + "min_cmp", + "modules", + "monday?", + "nesting", + "new_key", + "nobits?", + "numeric", + "optname", + "padding", + "pattern", + "pfamily", + "pointer", + "prepend", + "private", + "produce", + "product", + "reject!", + "replace", + "result=", + "reverse", + "rotate!", + "rstrip!", + "select!", + "sep_len", + "service", + "setbyte", + "shorter", + "shuffle", + "socket?", + "sort_by", + "sprintf", + "squeeze", + "subset?", + "sunday?", + "symlink", + "sysopen", + "sysread", + "sysseek", + "to_enum", + "to_hash", + "to_json", + "to_proc", + "unpack1", + "unshift", + "upcase!", + "yielder", + "AF_INET6", + "Addrinfo", + "EALREADY", + "EBADARCH", + "EBADEXEC", + "ECAPMODE", + "EL2NSYNC", + "ELIBEXEC", + "EMSGSIZE", + "ENETDOWN", + "ENOTCONN", + "ENOTSOCK", + "ENOTUNIQ", + "EOFError", + "EPROCLIM", + "ERESTART", + "ESTRPIPE", + "Encoding", + "FileTest", + "INFINITY", + "IPSocket", + "KeyError", + "MANT_DIG", + "MSG_PEEK", + "NI_DGRAM", + "NOFOLLOW", + "NONBLOCK", + "NilClass", + "PF_INET6", + "Rational", + "SEEK_CUR", + "SEEK_END", + "SEEK_SET", + "SOCK_RAW", + "SO_DEBUG", + "SO_ERROR", + "T_BIGINT", + "T_ICLASS", + "T_MODULE", + "T_OBJECT", + "T_SCLASS", + "T_STRING", + "T_STRUCT", + "__delete", + "__send__", + "__svalue", + "__to_int", + "_accept2", + "_connect", + "allbits?", + "allocate", + "anybits?", + "basename", + "between?", + "bytesize", + "casecmp?", + "children", + "classify", + "collect!", + "colorize", + "compact!", + "default=", + "downcase", + "dropping", + "each_key", + "encoding", + "enum_for", + "extended", + "filename", + "find_all", + "flat_map", + "flatten!", + "generate", + "getlocal", + "group_by", + "has_key?", + "include?", + "included", + "integer?", + "kind_of?", + "modified", + "new_args", + "nodename", + "nonzero?", + "overlap?", + "peeraddr", + "protocol", + "readbyte", + "readchar", + "readline", + "readlink", + "realpath", + "receiver", + "recvfrom", + "reverse!", + "self_end", + "self_len", + "servname", + "shuffle!", + "shutdown", + "sockaddr", + "socktype", + "sort_by!", + "squeeze!", + "str_each", + "subtract", + "swapcase", + "symlink?", + "syswrite", + "transfer", + "truncate", + "tuesday?", + "@hostname", + "@protocol", + "@sockaddr", + "@socktype", + "@stop_exc", + "AF_UNSPEC", + "Constants", + "EBADMACHO", + "ECANCELED", + "EDEADLOCK", + "EHOSTDOWN", + "EMULTIHOP", + "ENEEDAUTH", + "ENETRESET", + "ENOMEDIUM", + "ENOPOLICY", + "ENOTEMPTY", + "EOVERFLOW", + "EREMOTEIO", + "ESHUTDOWN", + "ETIMEDOUT", + "Exception", + "Generator", + "MSG_BCAST", + "MSG_MCAST", + "MSG_TRUNC", + "NI_NOFQDN", + "NameError", + "PF_UNSPEC", + "SEPARATOR", + "SHUT_RDWR", + "SO_LINGER", + "SO_RCVBUF", + "SO_SNDBUF", + "TCPServer", + "TCPSocket", + "T_COMPLEX", + "T_INTEGER", + "T_ISTRUCT", + "TrueClass", + "TypeError", + "UDPSocket", + "__compact", + "__outer__", + "_allocate", + "_gc_root_", + "_recvfrom", + "_sys_fail", + "_sysclose", + "_to_array", + "ancestors", + "backtrace", + "bind_call", + "byteindex", + "byteslice", + "conjugate", + "const_get", + "const_set", + "constants", + "delete_at", + "delete_if", + "disjoint?", + "downcase!", + "each_byte", + "each_char", + "each_cons", + "each_line", + "each_pair", + "end_with?", + "exception", + "exclusive", + "feedvalue", + "imaginary", + "infinite?", + "inherited", + "invisible", + "ip_unpack", + "iterator?", + "load_file", + "localtime", + "magnitude", + "minmax_by", + "negative?", + "numerator", + "object_id", + "other_end", + "partition", + "positive?", + "prepended", + "protected", + "readlines", + "remainder", + "satisfied", + "saturday?", + "self_excl", + "separator", + "set_color", + "superset?", + "swapcase!", + "sysaccept", + "thursday?", + "transpose", + "underline", + "ungetbyte", + "unix_path", + "validated", + "values_at", + "@feedvalue", + "@lookahead", + "AI_PASSIVE", + "ASCII_8BIT", + "Comparable", + "EADDRINUSE", + "ECONNRESET", + "EINTEGRITY", + "EOPNOTSUPP", + "EOWNERDEAD", + "EPROTOTYPE", + "ESHLIBVERS", + "Enumerable", + "Enumerator", + "FalseClass", + "FiberError", + "IPPROTO_AH", + "IPPROTO_IP", + "IP_HDRINCL", + "IP_OPTIONS", + "IP_PKTINFO", + "IP_RECVERR", + "IP_RECVTOS", + "IP_RECVTTL", + "IndexError", + "MAX_10_EXP", + "MIN_10_EXP", + "MSG_CTRUNC", + "NI_MAXHOST", + "NI_MAXSERV", + "RangeError", + "SOCK_DGRAM", + "SOL_SOCKET", + "SystemExit", + "TCP_MAXSEG", + "T_RATIONAL", + "UNIXServer", + "UNIXSocket", + "__callee__", + "__case_eqq", + "__get_hash", + "__method__", + "__num_to_a", + "_separator", + "bright_red", + "byterindex", + "bytesplice", + "capitalize", + "class_eval", + "class_exec", + "codepoints", + "color_null", + "difference", + "directory?", + "drop_while", + "each_child", + "each_entry", + "each_index", + "each_slice", + "each_value", + "fd_or_path", + "filter_map", + "find_index", + "getaddress", + "getpeereid", + "getsockopt", + "given_args", + "has_value?", + "initialize", + "intersect?", + "ip_address", + "last_value", + "local_host", + "make_curry", + "memsize_of", + "other_excl", + "parameters", + "rpartition", + "self_arity", + "self_begin", + "setsockopt", + "socketpair", + "step_ratio", + "subclasses", + "superclass", + "take_while", + "wednesday?", + "with_index", + "yield_self", + "@color_null", + "BasicObject", + "BasicSocket", + "DomainError", + "EINPROGRESS", + "EKEYEXPIRED", + "EKEYREVOKED", + "EMEDIUMTYPE", + "ENETUNREACH", + "ENOPROTOOPT", + "ENOTCAPABLE", + "EWOULDBLOCK", + "FNM_SYSCASE", + "FrozenError", + "IPPROTO_ESP", + "IPPROTO_RAW", + "IPPROTO_TCP", + "IPPROTO_UDP", + "IPV6_V6ONLY", + "NI_NAMEREQD", + "ObjectSpace", + "ParserError", + "RUBY_ENGINE", + "RegexpError", + "SOCK_STREAM", + "SO_RCVLOWAT", + "SO_RCVTIMEO", + "SO_SNDLOWAT", + "SO_SNDTIMEO", + "ScriptError", + "SocketError", + "SyntaxError", + "TCP_KEEPCNT", + "TCP_NODELAY", + "T_EXCEPTION", + "__members__", + "_is_socket=", + "ascii_only?", + "attr_reader", + "attr_writer", + "bright_blue", + "bright_cyan", + "capitalize!", + "chunk_while", + "close_write", + "color_null=", + "combination", + "denominator", + "each_object", + "expand_path", + "getaddrinfo", + "gethostname", + "getnameinfo", + "getpeername", + "getsockname", + "max_nesting", + "module_eval", + "module_exec", + "next_values", + "other_begin", + "peek_values", + "permutation", + "rectangular", + "respond_to?", + "sockaddr_in", + "sockaddr_un", + "start_with?", + "step_ratio=", + "to_sockaddr", + "valid_mode?", + "with_object", + "AI_CANONNAME", + "EAFNOSUPPORT", + "ECONNABORTED", + "ECONNREFUSED", + "EDESTADDRREQ", + "EHOSTUNREACH", + "EKEYREJECTED", + "ENAMETOOLONG", + "EPFNOSUPPORT", + "EPROCUNAVAIL", + "EPROGUNAVAIL", + "ERPCMISMATCH", + "ETOOMANYREFS", + "FNM_CASEFOLD", + "FNM_DOTMATCH", + "FNM_NOESCAPE", + "FNM_PATHNAME", + "IPPROTO_ICMP", + "IPPROTO_IPV6", + "IPPROTO_NONE", + "NestingError", + "RUBY_VERSION", + "RuntimeError", + "SHARE_DELETE", + "SO_BROADCAST", + "SO_DONTROUTE", + "SO_KEEPALIVE", + "SO_OOBINLINE", + "SO_REUSEADDR", + "TCP_KEEPIDLE", + "__ENCODING__", + "__attached__", + "__codepoints", + "__errno_list", + "_setnonblock", + "_sockaddr_in", + "alias_method", + "block_given?", + "bright_black", + "bright_green", + "bright_white", + "color_number", + "color_string", + "column_count", + "column_index", + "default_proc", + "exclude_end?", + "fetch_values", + "instance_of?", + "intersection", + "method_added", + "mruby_Random", + "pretty_print", + "remove_const", + "reverse_each", + "super_method", + "undef_method", + "@color_string", + "@init_with_fd", + "ALT_SEPARATOR", + "ArgumentError", + "EADDRNOTAVAIL", + "EPROGMISMATCH", + "MRUBY_VERSION", + "MSG_DONTROUTE", + "NoMemoryError", + "NoMethodError", + "StandardError", + "StopIteration", + "TCP_KEEPALIVE", + "TCP_KEEPINTVL", + "TerminalColor", + "UnboundMethod", + "__classname__", + "__sub_replace", + "__update_hash", + "absolute_path", + "attr_accessor", + "bright_yellow", + "bsearch_index", + "color_boolean", + "color_string=", + "const_missing", + "count_objects", + "default_proc=", + "define_method", + "delete_prefix", + "delete_suffix", + "extend_object", + "fast_generate", + "flatten_merge", + "in_lower_half", + "instance_eval", + "instance_exec", + "local_address", + "local_service", + "recv_nonblock", + "remove_method", + "set_backtrace", + "@color_boolean", + "AI_NUMERICHOST", + "AI_NUMERICSERV", + "GeneratorError", + "IPPROTO_ICMPV6", + "IP_RECVDSTADDR", + "LocalJumpError", + "NI_NUMERICHOST", + "NI_NUMERICSERV", + "PATH_SEPARATOR", + "SOCK_SEQPACKET", + "__do_with_enum", + "__empty_range?", + "__errno_define", + "__upto_endless", + "absolute_path?", + "bright_magenta", + "close_on_exec=", + "close_on_exec?", + "collect_concat", + "color_boolean=", + "const_defined?", + "delete_prefix!", + "delete_suffix!", + "each_codepoint", + "force_encoding", + "interval_ratio", + "memsize_of_all", + "method_missing", + "method_removed", + "paragraph_mode", + "proper_subset?", + "public_methods", + "remote_address", + "transform_keys", + "ANSI_MODE_CODES", + "ENOTRECOVERABLE", + "EPROTONOSUPPORT", + "ESOCKTNOSUPPORT", + "IPPROTO_DSTOPTS", + "IPPROTO_ROUTING", + "IPV6_JOIN_GROUP", + "IP_BLOCK_SOURCE", + "IP_MTU_DISCOVER", + "IP_MULTICAST_IF", + "MRUBY_COPYRIGHT", + "SystemCallError", + "accept_nonblock", + "append_as_bytes", + "append_features", + "attached_object", + "class_variables", + "each_with_index", + "initialize_copy", + "instance_method", + "interval_ratio=", + "local_variables", + "method_defined?", + "module_function", + "pad_repetitions", + "pretty_generate", + "private_methods", + "singleton_class", + "source_location", + "symbolize_names", + "transform_keys!", + "valid_encoding?", + "ANSI_COLOR_CODES", + "FloatDomainError", + "IPPROTO_FRAGMENT", + "IPV6_LEAVE_GROUP", + "IP_MULTICAST_TTL", + "MCAST_JOIN_GROUP", + "MRUBY_RELEASE_NO", + "SystemStackError", + "__errno_defined?", + "_sockaddr_family", + "color_object_key", + "connect_nonblock", + "each_with_object", + "global_variables", + "included_modules", + "inspect_sockaddr", + "instance_methods", + "method_undefined", + "pack_sockaddr_in", + "pack_sockaddr_un", + "prepend_features", + "proper_superset?", + "singleton_class?", + "singleton_method", + "transform_values", + "@color_object_key", + "IPV6_MULTICAST_IF", + "IPV6_UNICAST_HOPS", + "IP_ADD_MEMBERSHIP", + "IP_MULTICAST_LOOP", + "IP_UNBLOCK_SOURCE", + "MCAST_LEAVE_GROUP", + "MRUBY_DESCRIPTION", + "ZeroDivisionError", + "_new_with_prelude", + "colorize_generate", + "generational_mode", + "protected_methods", + "recvfrom_nonblock", + "singleton_methods", + "transform_values!", + "IP_DROP_MEMBERSHIP", + "MCAST_BLOCK_SOURCE", + "MRUBY_RELEASE_DATE", + "UncaughtThrowError", + "class_variable_get", + "class_variable_set", + "generational_mode=", + "instance_variables", + "local_variable_get", + "local_variable_set", + "unpack_sockaddr_in", + "unpack_sockaddr_un", + "ANSI_BG_COLOR_CODES", + "IPV6_MULTICAST_HOPS", + "IPV6_MULTICAST_LOOP", + "NotImplementedError", + "RUBY_ENGINE_VERSION", + "respond_to_missing?", + "MCAST_UNBLOCK_SOURCE", + "__inspect_recursive?", + "repeated_combination", + "repeated_permutation", + "set_color_object_key", + "__coerce_step_counter", + "do_not_reverse_lookup", + "instance_variable_get", + "instance_variable_set", + "remove_class_variable", + "@do_not_reverse_lookup", + "__repeated_combination", + "do_not_reverse_lookup=", + "singleton_method_added", + "@@do_not_reverse_lookup", + "MCAST_JOIN_SOURCE_GROUP", + "__enumerator_block_call", + "class_variable_defined?", + "define_singleton_method", + "local_variable_defined?", + "public_instance_methods", + "IP_ADD_SOURCE_MEMBERSHIP", + "MCAST_LEAVE_SOURCE_GROUP", + "private_instance_methods", + "remove_instance_variable", + "singleton_method_removed", + "IP_DROP_SOURCE_MEMBERSHIP", + "instance_variable_defined?", + "protected_instance_methods", + "singleton_method_undefined", + "undefined_instance_methods", +}; diff --git a/deps/mruby/include/mruby/proc.h b/deps/mruby/include/mruby/proc.h new file mode 100644 index 0000000..f35d64d --- /dev/null +++ b/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 +#include + +/** + * 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 + * #include + * #include + * + * 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 */ diff --git a/deps/mruby/include/mruby/range.h b/deps/mruby/include/mruby/range.h new file mode 100644 index 0000000..3898ef3 --- /dev/null +++ b/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 */ diff --git a/deps/mruby/include/mruby/re.h b/deps/mruby/include/mruby/re.h new file mode 100644 index 0000000..2d48019 --- /dev/null +++ b/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 */ diff --git a/deps/mruby/include/mruby/string.h b/deps/mruby/include/mruby/string.h new file mode 100644 index 0000000..b882594 --- /dev/null +++ b/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 */ diff --git a/deps/mruby/include/mruby/throw.h b/deps/mruby/include/mruby/throw.h new file mode 100644 index 0000000..f2984de --- /dev/null +++ b/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 + +#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 */ diff --git a/deps/mruby/include/mruby/value.h b/deps/mruby/include/mruby/value.h new file mode 100644 index 0000000..6aa7c92 --- /dev/null +++ b/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 +#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 + +#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 +#include // 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 */ diff --git a/deps/mruby/include/mruby/variable.h b/deps/mruby/include/mruby/variable.h new file mode 100644 index 0000000..0a7b7b4 --- /dev/null +++ b/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 */ diff --git a/deps/mruby/include/mruby/version.h b/deps/mruby/include/mruby/version.h new file mode 100644 index 0000000..d95263f --- /dev/null +++ b/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 */ diff --git a/deps/mruby/lib/libmruby.flags.mak b/deps/mruby/lib/libmruby.flags.mak new file mode 100644 index 0000000..18b824e --- /dev/null +++ b/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 diff --git a/deps/mruby/lib/libmruby.lib b/deps/mruby/lib/libmruby.lib new file mode 100644 index 0000000..8283995 Binary files /dev/null and b/deps/mruby/lib/libmruby.lib differ diff --git a/deps/mruby/lib/libmruby_core.lib b/deps/mruby/lib/libmruby_core.lib new file mode 100644 index 0000000..948dc8a Binary files /dev/null and b/deps/mruby/lib/libmruby_core.lib differ diff --git a/deps/mruby/presym b/deps/mruby/presym new file mode 100644 index 0000000..656eb3e --- /dev/null +++ b/deps/mruby/presym @@ -0,0 +1,1487 @@ +! +% +& +* ++ +- +/ +< +> +E +^ +` +a +b +c +d +e +f +h +i +j +k +l +m +n +o +p +r +s +t +v +w +x +y +z +| +~ +!= +!~ +$0 +$? +&& +** ++@ +-@ +<< +<= +== +=~ +>= +>> +GC +IO +PI +[] +af +ai +ar +at +bi +bs +cp +e0 +e2 +e3 +ed +ei +fd +gm +in +io +ip +lz +nv +pc +sa +sv +tr +vs +wd +|| +<=> +=== +@af +DIG +Dir +EIO +MAX +MIN +NAN +Set +[]= +abs +add +arg +arr +ary +beg +blk +chr +cmd +cmp +cos +day +dig +div +dup +end +env +eof +erf +err +exp +fib +hex +idx +int +ip? +key +kwd +len +lhs +lim +log +low +map +max +mid +min +mod +mon +msg +new +now +num +obj +oct +opt +ord +out +pat +pid +pop +pos +pow +pre +pwd +quo +red +req +res +rhs +row +sec +sep +set +sin +str +sub +sum +sym +tag +tan +tap +tcp +tmp +tr! +udp +utc +val +zip +@dst +@fib +@kwd +@obj +@pos +@tag +ARGV +Data +EADV +EDOM +EXCL +FREE +File +Hash +JSON +Lazy +Math +NONE +NULL +Proc +RDWR +SYNC +Time +abs2 +acos +add? +addr +all? +any? +arg0 +arg1 +arg2 +args +argv +arys +asin +atan +attr +bind +blue +bold +bool +bsiz +byte +call +cbrt +ceil +char +chop +conj +cosh +curr +cyan +data +drop +dst? +dump +e_id +each +elem +enum +eof? +epos +eql? +erfc +eval +exit +fail +fdiv +feed +file +fill +find +flag +func +getc +gets +gmt? +gray +grep +gsub +hash +high +host +hour +idx2 +imag +init +join +json +key? +keys +last +lazy +line +list +load +log2 +loop +map! +mask +mday +mesg +meth +mode +name +nan? +next +nil? +none +ntop +odd? +one? +open +opts +orig +pack +pad1 +pad2 +pair +path +peek +perm +pipe +plen +port +pos= +proc +pton +push +puts +rand +read +real +rect +recv +rest +sary +seek +seen +send +sinh +size +sock +sort +sqrt +step +str2 +sub! +succ +sync +take +tanh +tell +then +to_a +to_c +to_f +to_h +to_i +to_r +to_s +tr_s +tty? +type +uniq +unix +upto +usec +utc? +vals +wday +yday +year +zone +@args +@hash +@meth +@name +@path +@proc +@size +Array +CMath +CREAT +Chain +Class +DSYNC +E2BIG +EAUTH +EBADE +EBADF +EBADR +EBUSY +ECOMM +EFBIG +EIDRM +EINTR +ELOOP +ENOSR +ENXIO +EPERM +EPIPE +EROFS +ESRCH +ETIME +EXDEV +Errno +Fiber +Float +RADIX +RSYNC +Range +STDIN +TOTAL +TRUNC +T_ENV +UTF_8 +_bind +_name +_pipe +_proc +_recv +acosh +angle +arity +array +ary_F +ary_T +asinh +assoc +atan2 +atanh +atime +begin +black +blink +block +bytes +catch +chain +chars +chdir +chmod +chomp +chop! +chunk +clamp +class +clear +clone +close +color +count +ctime +curry +cycle +depth +enums +errno +even? +exit! +fetch +field +file? +first +flags +flock +floor +flush +fname +force +found +frexp +getgm +getwd +green +group +gsub! +hypot +index +ipv4? +ipv6? +is_a? +ldexp +level +lines +ljust +local +log10 +merge +mkdir +month +mtime +names +next! +none? +other +owner +parse +phase +pipe? +polar +popen +pproc +pread +print +proto +raise +real? +reset +rjust +rmdir +round +shift +size? +sleep +slice +sort! +split +srand +start +state +store +strip +succ! +sync= +taken +tally +throw +times +to_io +total +tr_s! +umask +union +uniq! +unix? +value +white +width +write +yield +zero? +$DEBUG +$stdin +@enums +@value +AF_MAX +APPEND +BINARY +DIRECT +EACCES +EAGAIN +EBADFD +EBFONT +ECHILD +ECHRNG +EDQUOT +EEXIST +EFAULT +EFTYPE +EILSEQ +EINVAL +EIPSEC +EISDIR +EISNAM +EL2HLT +EL3HLT +EL3RST +ELNRNG +EMFILE +EMLINK +ENFILE +ENOANO +ENOCSI +ENODEV +ENOENT +ENOKEY +ENOLCK +ENOMEM +ENOMSG +ENONET +ENOPKG +ENOSPC +ENOSTR +ENOSYS +ENOTTY +EPROTO +EQFULL +ERANGE +ESPIPE +ESRMNT +ESTALE +EUSERS +EXFULL +Fixnum +IP_MTU +IP_TOS +IP_TTL +Kernel +Method +Module +NOCTTY +Object +Option +RDONLY +Random +Regexp +SOL_IP +STDERR +STDOUT +Socket +Status +String +Struct +Symbol +T_CPTR +T_DATA +T_HASH +T_PROC +WRONLY +__id__ +_alone +_atime +_chdir +_ctime +_klass +_mtime +_owner +_popen +accept +alive? +append +caller +center +chomp! +chroot +concat +cover? +define +delete +detect +digits +divide +divmod +domain +downto +empty? +enable +equal? +except +exist? +extend +family +fileno +filter +for_fd +format +freeze +getutc +gmtime +grep_v +ifnone +inject +insert +intern +invert +isatty +itself +lambda +length +linger +listen +longer +lstrip +max_by +maxlen +merge! +method +min_by +minmax +mktime +modulo +object +offset +others +padstr +printf +public +pwrite +random +rassoc +reduce +rehash +reject +rename +result +resume +rewind +rindex +rotate +rstrip +sample +select +slice! +status +string +strip! +to_int +to_str +to_sym +unbind +ungetc +unlink +unpack +upcase +update +usleep +valid? +value? +values +yellow +$stderr +$stdout +@family +AF_INET +AF_UNIX +AI_FQDN +Binding +Complex +EBADMSG +EBADRPC +EBADRQC +EBADSLT +EDEADLK +EDEVERR +EDOOFUS +EDOTDOT +EISCONN +ELIBACC +ELIBBAD +ELIBMAX +ELIBSCN +ENAVAIL +ENOATTR +ENOBUFS +ENODATA +ENOEXEC +ENOLINK +ENOTBLK +ENOTDIR +ENOTNAM +ENOTSUP +EPSILON +EPWROFF +EREMCHG +EREMOTE +ERFKILL +ETXTBSY +EUCLEAN +EUNATCH +IOError +Integer +LOCK_EX +LOCK_NB +LOCK_SH +LOCK_UN +MAX_EXP +MIN_EXP +MSG_OOB +NOATIME +NOERROR +Numeric +PF_INET +PF_UNIX +Process +SO_TYPE +TMPFILE +T_ARRAY +T_BREAK +T_CLASS +T_FIBER +T_FLOAT +T_RANGE +Yielder +__lines +__merge +_accept +_listen +_socket +afamily +asctime +backlog +binding +bsearch +casecmp +ceildiv +closed? +collect +command +compact +compile +connect +current +default +delete! +delete? +dirname +disable +dropped +element +entries +exists? +extname +filter! +finite? +flatten +foreach +friday? +frozen? +getbyte +include +inspect +ip_port +keep_if +keyrest +lambda? +lstrip! +magenta +max_cmp +member? +members +message +methods +min_cmp +modules +monday? +nesting +new_key +nobits? +numeric +optname +padding +pattern +pfamily +pointer +prepend +private +produce +product +reject! +replace +result= +reverse +rotate! +rstrip! +select! +sep_len +service +setbyte +shorter +shuffle +socket? +sort_by +sprintf +squeeze +subset? +sunday? +symlink +sysopen +sysread +sysseek +to_enum +to_hash +to_json +to_proc +unpack1 +unshift +upcase! +yielder +AF_INET6 +Addrinfo +EALREADY +EBADARCH +EBADEXEC +ECAPMODE +EL2NSYNC +ELIBEXEC +EMSGSIZE +ENETDOWN +ENOTCONN +ENOTSOCK +ENOTUNIQ +EOFError +EPROCLIM +ERESTART +ESTRPIPE +Encoding +FileTest +INFINITY +IPSocket +KeyError +MANT_DIG +MSG_PEEK +NI_DGRAM +NOFOLLOW +NONBLOCK +NilClass +PF_INET6 +Rational +SEEK_CUR +SEEK_END +SEEK_SET +SOCK_RAW +SO_DEBUG +SO_ERROR +T_BIGINT +T_ICLASS +T_MODULE +T_OBJECT +T_SCLASS +T_STRING +T_STRUCT +__delete +__send__ +__svalue +__to_int +_accept2 +_connect +allbits? +allocate +anybits? +basename +between? +bytesize +casecmp? +children +classify +collect! +colorize +compact! +default= +downcase +dropping +each_key +encoding +enum_for +extended +filename +find_all +flat_map +flatten! +generate +getlocal +group_by +has_key? +include? +included +integer? +kind_of? +modified +new_args +nodename +nonzero? +overlap? +peeraddr +protocol +readbyte +readchar +readline +readlink +realpath +receiver +recvfrom +reverse! +self_end +self_len +servname +shuffle! +shutdown +sockaddr +socktype +sort_by! +squeeze! +str_each +subtract +swapcase +symlink? +syswrite +transfer +truncate +tuesday? +@hostname +@protocol +@sockaddr +@socktype +@stop_exc +AF_UNSPEC +Constants +EBADMACHO +ECANCELED +EDEADLOCK +EHOSTDOWN +EMULTIHOP +ENEEDAUTH +ENETRESET +ENOMEDIUM +ENOPOLICY +ENOTEMPTY +EOVERFLOW +EREMOTEIO +ESHUTDOWN +ETIMEDOUT +Exception +Generator +MSG_BCAST +MSG_MCAST +MSG_TRUNC +NI_NOFQDN +NameError +PF_UNSPEC +SEPARATOR +SHUT_RDWR +SO_LINGER +SO_RCVBUF +SO_SNDBUF +TCPServer +TCPSocket +T_COMPLEX +T_INTEGER +T_ISTRUCT +TrueClass +TypeError +UDPSocket +__compact +__outer__ +_allocate +_gc_root_ +_recvfrom +_sys_fail +_sysclose +_to_array +ancestors +backtrace +bind_call +byteindex +byteslice +conjugate +const_get +const_set +constants +delete_at +delete_if +disjoint? +downcase! +each_byte +each_char +each_cons +each_line +each_pair +end_with? +exception +exclusive +feedvalue +imaginary +infinite? +inherited +invisible +ip_unpack +iterator? +load_file +localtime +magnitude +minmax_by +negative? +numerator +object_id +other_end +partition +positive? +prepended +protected +readlines +remainder +satisfied +saturday? +self_excl +separator +set_color +superset? +swapcase! +sysaccept +thursday? +transpose +underline +ungetbyte +unix_path +validated +values_at +@feedvalue +@lookahead +AI_PASSIVE +ASCII_8BIT +Comparable +EADDRINUSE +ECONNRESET +EINTEGRITY +EOPNOTSUPP +EOWNERDEAD +EPROTOTYPE +ESHLIBVERS +Enumerable +Enumerator +FalseClass +FiberError +IPPROTO_AH +IPPROTO_IP +IP_HDRINCL +IP_OPTIONS +IP_PKTINFO +IP_RECVERR +IP_RECVTOS +IP_RECVTTL +IndexError +MAX_10_EXP +MIN_10_EXP +MSG_CTRUNC +NI_MAXHOST +NI_MAXSERV +RangeError +SOCK_DGRAM +SOL_SOCKET +SystemExit +TCP_MAXSEG +T_RATIONAL +UNIXServer +UNIXSocket +__callee__ +__case_eqq +__get_hash +__method__ +__num_to_a +_separator +bright_red +byterindex +bytesplice +capitalize +class_eval +class_exec +codepoints +color_null +difference +directory? +drop_while +each_child +each_entry +each_index +each_slice +each_value +fd_or_path +filter_map +find_index +getaddress +getpeereid +getsockopt +given_args +has_value? +initialize +intersect? +ip_address +last_value +local_host +make_curry +memsize_of +other_excl +parameters +rpartition +self_arity +self_begin +setsockopt +socketpair +step_ratio +subclasses +superclass +take_while +wednesday? +with_index +yield_self +@color_null +BasicObject +BasicSocket +DomainError +EINPROGRESS +EKEYEXPIRED +EKEYREVOKED +EMEDIUMTYPE +ENETUNREACH +ENOPROTOOPT +ENOTCAPABLE +EWOULDBLOCK +FNM_SYSCASE +FrozenError +IPPROTO_ESP +IPPROTO_RAW +IPPROTO_TCP +IPPROTO_UDP +IPV6_V6ONLY +NI_NAMEREQD +ObjectSpace +ParserError +RUBY_ENGINE +RegexpError +SOCK_STREAM +SO_RCVLOWAT +SO_RCVTIMEO +SO_SNDLOWAT +SO_SNDTIMEO +ScriptError +SocketError +SyntaxError +TCP_KEEPCNT +TCP_NODELAY +T_EXCEPTION +__members__ +_is_socket= +ascii_only? +attr_reader +attr_writer +bright_blue +bright_cyan +capitalize! +chunk_while +close_write +color_null= +combination +denominator +each_object +expand_path +getaddrinfo +gethostname +getnameinfo +getpeername +getsockname +max_nesting +module_eval +module_exec +next_values +other_begin +peek_values +permutation +rectangular +respond_to? +sockaddr_in +sockaddr_un +start_with? +step_ratio= +to_sockaddr +valid_mode? +with_object +AI_CANONNAME +EAFNOSUPPORT +ECONNABORTED +ECONNREFUSED +EDESTADDRREQ +EHOSTUNREACH +EKEYREJECTED +ENAMETOOLONG +EPFNOSUPPORT +EPROCUNAVAIL +EPROGUNAVAIL +ERPCMISMATCH +ETOOMANYREFS +FNM_CASEFOLD +FNM_DOTMATCH +FNM_NOESCAPE +FNM_PATHNAME +IPPROTO_ICMP +IPPROTO_IPV6 +IPPROTO_NONE +NestingError +RUBY_VERSION +RuntimeError +SHARE_DELETE +SO_BROADCAST +SO_DONTROUTE +SO_KEEPALIVE +SO_OOBINLINE +SO_REUSEADDR +TCP_KEEPIDLE +__ENCODING__ +__attached__ +__codepoints +__errno_list +_setnonblock +_sockaddr_in +alias_method +block_given? +bright_black +bright_green +bright_white +color_number +color_string +column_count +column_index +default_proc +exclude_end? +fetch_values +instance_of? +intersection +method_added +mruby_Random +pretty_print +remove_const +reverse_each +super_method +undef_method +@color_string +@init_with_fd +ALT_SEPARATOR +ArgumentError +EADDRNOTAVAIL +EPROGMISMATCH +MRUBY_VERSION +MSG_DONTROUTE +NoMemoryError +NoMethodError +StandardError +StopIteration +TCP_KEEPALIVE +TCP_KEEPINTVL +TerminalColor +UnboundMethod +__classname__ +__sub_replace +__update_hash +absolute_path +attr_accessor +bright_yellow +bsearch_index +color_boolean +color_string= +const_missing +count_objects +default_proc= +define_method +delete_prefix +delete_suffix +extend_object +fast_generate +flatten_merge +in_lower_half +instance_eval +instance_exec +local_address +local_service +recv_nonblock +remove_method +set_backtrace +@color_boolean +AI_NUMERICHOST +AI_NUMERICSERV +GeneratorError +IPPROTO_ICMPV6 +IP_RECVDSTADDR +LocalJumpError +NI_NUMERICHOST +NI_NUMERICSERV +PATH_SEPARATOR +SOCK_SEQPACKET +__do_with_enum +__empty_range? +__errno_define +__upto_endless +absolute_path? +bright_magenta +close_on_exec= +close_on_exec? +collect_concat +color_boolean= +const_defined? +delete_prefix! +delete_suffix! +each_codepoint +force_encoding +interval_ratio +memsize_of_all +method_missing +method_removed +paragraph_mode +proper_subset? +public_methods +remote_address +transform_keys +ANSI_MODE_CODES +ENOTRECOVERABLE +EPROTONOSUPPORT +ESOCKTNOSUPPORT +IPPROTO_DSTOPTS +IPPROTO_ROUTING +IPV6_JOIN_GROUP +IP_BLOCK_SOURCE +IP_MTU_DISCOVER +IP_MULTICAST_IF +MRUBY_COPYRIGHT +SystemCallError +accept_nonblock +append_as_bytes +append_features +attached_object +class_variables +each_with_index +initialize_copy +instance_method +interval_ratio= +local_variables +method_defined? +module_function +pad_repetitions +pretty_generate +private_methods +singleton_class +source_location +symbolize_names +transform_keys! +valid_encoding? +ANSI_COLOR_CODES +FloatDomainError +IPPROTO_FRAGMENT +IPV6_LEAVE_GROUP +IP_MULTICAST_TTL +MCAST_JOIN_GROUP +MRUBY_RELEASE_NO +SystemStackError +__errno_defined? +_sockaddr_family +color_object_key +connect_nonblock +each_with_object +global_variables +included_modules +inspect_sockaddr +instance_methods +method_undefined +pack_sockaddr_in +pack_sockaddr_un +prepend_features +proper_superset? +singleton_class? +singleton_method +transform_values +@color_object_key +IPV6_MULTICAST_IF +IPV6_UNICAST_HOPS +IP_ADD_MEMBERSHIP +IP_MULTICAST_LOOP +IP_UNBLOCK_SOURCE +MCAST_LEAVE_GROUP +MRUBY_DESCRIPTION +ZeroDivisionError +_new_with_prelude +colorize_generate +generational_mode +protected_methods +recvfrom_nonblock +singleton_methods +transform_values! +IP_DROP_MEMBERSHIP +MCAST_BLOCK_SOURCE +MRUBY_RELEASE_DATE +UncaughtThrowError +class_variable_get +class_variable_set +generational_mode= +instance_variables +local_variable_get +local_variable_set +unpack_sockaddr_in +unpack_sockaddr_un +ANSI_BG_COLOR_CODES +IPV6_MULTICAST_HOPS +IPV6_MULTICAST_LOOP +NotImplementedError +RUBY_ENGINE_VERSION +respond_to_missing? +MCAST_UNBLOCK_SOURCE +__inspect_recursive? +repeated_combination +repeated_permutation +set_color_object_key +__coerce_step_counter +do_not_reverse_lookup +instance_variable_get +instance_variable_set +remove_class_variable +@do_not_reverse_lookup +__repeated_combination +do_not_reverse_lookup= +singleton_method_added +@@do_not_reverse_lookup +MCAST_JOIN_SOURCE_GROUP +__enumerator_block_call +class_variable_defined? +define_singleton_method +local_variable_defined? +public_instance_methods +IP_ADD_SOURCE_MEMBERSHIP +MCAST_LEAVE_SOURCE_GROUP +private_instance_methods +remove_instance_variable +singleton_method_removed +IP_DROP_SOURCE_MEMBERSHIP +instance_variable_defined? +protected_instance_methods +singleton_method_undefined +undefined_instance_methods