├── .gitmodules
├── Info.plist
├── README.md
├── Rakefile
├── build_config.rb
├── ios
    └── MRuby.framework
    │   ├── Headers
    │       ├── mrbconf.h
    │       ├── mruby.h
    │       └── mruby
    │       │   ├── array.h
    │       │   ├── boxing_nan.h
    │       │   ├── boxing_no.h
    │       │   ├── boxing_word.h
    │       │   ├── class.h
    │       │   ├── common.h
    │       │   ├── compile.h
    │       │   ├── data.h
    │       │   ├── debug.h
    │       │   ├── dump.h
    │       │   ├── error.h
    │       │   ├── gc.h
    │       │   ├── hash.h
    │       │   ├── irep.h
    │       │   ├── istruct.h
    │       │   ├── khash.h
    │       │   ├── numeric.h
    │       │   ├── object.h
    │       │   ├── opcode.h
    │       │   ├── ops.h
    │       │   ├── proc.h
    │       │   ├── range.h
    │       │   ├── re.h
    │       │   ├── string.h
    │       │   ├── throw.h
    │       │   ├── value.h
    │       │   ├── variable.h
    │       │   └── version.h
    │   ├── Info.plist
    │   └── MRuby
└── tvos
    └── MRuby.framework
        ├── Headers
            ├── mrbconf.h
            ├── mruby.h
            └── mruby
            │   ├── array.h
            │   ├── boxing_nan.h
            │   ├── boxing_no.h
            │   ├── boxing_word.h
            │   ├── class.h
            │   ├── common.h
            │   ├── compile.h
            │   ├── data.h
            │   ├── debug.h
            │   ├── dump.h
            │   ├── error.h
            │   ├── gc.h
            │   ├── hash.h
            │   ├── irep.h
            │   ├── istruct.h
            │   ├── khash.h
            │   ├── numeric.h
            │   ├── object.h
            │   ├── opcode.h
            │   ├── ops.h
            │   ├── proc.h
            │   ├── range.h
            │   ├── re.h
            │   ├── string.h
            │   ├── throw.h
            │   ├── value.h
            │   ├── variable.h
            │   └── version.h
        ├── Info.plist
        └── MRuby


/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "mruby"]
2 | 	path = mruby
3 | 	url = https://github.com/mruby/mruby.git
4 | 


--------------------------------------------------------------------------------
/Info.plist:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 3 | <plist version="1.0">
 4 | <dict>
 5 |   <key>CFBundleName</key>
 6 |   <string>MRuby</string>
 7 |   <key>CFBundleDevelopmentRegion</key>
 8 |   <string>en</string>
 9 |   <key>CFBundleInfoDictionaryVersion</key>
10 |   <string>6.0</string>
11 |   <key>CFBundlePackageType</key>
12 |   <string>FMWK</string>
13 |   <key>CFBundleIdentifier</key>
14 |   <string>MRuby.MRuby</string>
15 |   <key>CFBundleExecutable</key>
16 |   <string>MRuby</string>
17 |   <key>CFBundleVersion</key>
18 |   <string>1</string>
19 | </dict>
20 | </plist>
21 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # MRuby iOS and tvOS frameworks
2 | 
3 | Run `rake` to cross compile and build the frameworks. To update the MRuby submodule, use `rake mruby_latest` to set to the latest release and `rake mruby_master` to set the master branch.
4 | 
5 | The prebuilt frameworks are located in `ios/` and `tvos/`, respectively.
6 | 
7 | ⚠️ When using these frameworks in an Xcode project, make sure to add `"$(SRCROOT)/MRuby.framework/Headers"` to the "Header Search Paths" in the build settings.
8 | 


--------------------------------------------------------------------------------
/Rakefile:
--------------------------------------------------------------------------------
 1 | mruby_version = '2.0.0'
 2 | 
 3 | task default: 'build_mruby'
 4 | 
 5 | desc 'Clean the project build files'
 6 | task :clean do
 7 |   FileUtils.remove_dir 'ios/MRuby.framework', true
 8 |   FileUtils.remove_dir 'tvos/MRuby.framework', true
 9 |   FileUtils.remove_dir 'mruby/build', true
10 | end
11 | 
12 | desc 'Build MRuby for iOS and tvOS'
13 | task :build_mruby => :clean do
14 |   Dir.chdir('mruby') do
15 |     ENV['MRUBY_CONFIG'] = '../build_config.rb'
16 |     system 'rake'
17 | 
18 |     Dir.chdir('build') do
19 |       FileUtils.mkdir_p 'ios-universal'
20 |       `lipo ios/lib/libmruby.a ios-simulator/lib/libmruby.a -create -output ios-universal/libmruby.a`
21 | 
22 |       FileUtils.mkdir_p 'tvos-universal'
23 |       `lipo tvos/lib/libmruby.a tvos-simulator/lib/libmruby.a -create -output tvos-universal/libmruby.a`
24 |     end
25 |   end
26 | 
27 |   FileUtils.mkdir_p 'ios/MRuby.framework/Headers'
28 |   FileUtils.cp_r 'mruby/include/.', 'ios/MRuby.framework/Headers'
29 |   FileUtils.cp 'Info.plist', 'ios/MRuby.framework'
30 |   FileUtils.cp 'mruby/build/ios-universal/libmruby.a', 'ios/MRuby.framework/MRuby'
31 | 
32 |   FileUtils.mkdir_p 'tvos/MRuby.framework/Headers'
33 |   FileUtils.cp_r 'mruby/include/.', 'tvos/MRuby.framework/Headers'
34 |   FileUtils.cp 'Info.plist', 'tvos/MRuby.framework'
35 |   FileUtils.cp 'mruby/build/tvos-universal/libmruby.a', 'tvos/MRuby.framework/MRuby'
36 | end
37 | 
38 | desc 'Set MRuby submodule to latest release'
39 | task :mruby_latest do
40 |   system 'git submodule update --remote && '\
41 |          'cd mruby && '\
42 |          "git checkout tags/#{mruby_version}"
43 | end
44 | 
45 | desc 'Set MRuby submodule to master branch'
46 | task :mruby_master do
47 |   system 'git submodule update --remote && '\
48 |          'cd mruby && '\
49 |          'git checkout master && '\
50 |          'git pull --rebase'
51 | end
52 | 


--------------------------------------------------------------------------------
/build_config.rb:
--------------------------------------------------------------------------------
 1 | CC = `xcrun -find clang`.strip
 2 | 
 3 | def sdk_path(device); `xcrun --sdk #{device} --show-sdk-path`.strip end
 4 | IOS_FLAGS = %W(-Os -arch armv7 -arch arm64 -isysroot #{sdk_path 'iphoneos'})
 5 | IOSSIM_FLAGS = %W(-Os -arch i386 -arch x86_64 -isysroot #{sdk_path 'iphonesimulator'})
 6 | TVOS_FLAGS = %W(-Os -arch arm64 -isysroot #{sdk_path 'appletvos'})
 7 | TVOSSIM_FLAGS = %W(-Os -arch x86_64 -isysroot #{sdk_path 'appletvsimulator'})
 8 | 
 9 | 
10 | MRuby::Build.new do |conf|
11 |   toolchain :clang
12 |   conf.gembox 'default'
13 | end
14 | 
15 | MRuby::CrossBuild.new('ios') do |conf|
16 |   conf.gembox 'default'
17 | 
18 |   conf.cc do |cc|
19 |     cc.command = CC
20 |     cc.flags = IOS_FLAGS
21 |   end
22 | 
23 |   conf.linker do |linker|
24 |     linker.command = CC
25 |     linker.flags = IOS_FLAGS
26 |   end
27 | end
28 | 
29 | MRuby::CrossBuild.new('ios-simulator') do |conf|
30 |   conf.gembox 'default'
31 | 
32 |   conf.cc do |cc|
33 |     cc.command = CC
34 |     cc.flags = IOSSIM_FLAGS
35 |   end
36 | 
37 |   conf.linker do |linker|
38 |     linker.command = CC
39 |     linker.flags = IOSSIM_FLAGS
40 |   end
41 | end
42 | 
43 | MRuby::CrossBuild.new('tvos') do |conf|
44 |   conf.gembox 'default'
45 | 
46 |   conf.cc do |cc|
47 |     cc.command = CC
48 |     cc.flags = TVOS_FLAGS
49 |   end
50 | 
51 |   conf.linker do |linker|
52 |     linker.command = CC
53 |     linker.flags = TVOS_FLAGS
54 |   end
55 | end
56 | 
57 | MRuby::CrossBuild.new('tvos-simulator') do |conf|
58 |   conf.gembox 'default'
59 | 
60 |   conf.cc do |cc|
61 |     cc.command = CC
62 |     cc.flags = TVOSSIM_FLAGS
63 |   end
64 | 
65 |   conf.linker do |linker|
66 |     linker.command = CC
67 |     linker.flags = TVOSSIM_FLAGS
68 |   end
69 | end
70 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Headers/mrbconf.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** mrbconf.h - mruby core configuration
  3 | **
  4 | ** See Copyright Notice in mruby.h
  5 | */
  6 | 
  7 | #ifndef MRUBYCONF_H
  8 | #define MRUBYCONF_H
  9 | 
 10 | #include <limits.h>
 11 | #include <stdint.h>
 12 | 
 13 | /* architecture selection: */
 14 | /* specify -DMRB_32BIT or -DMRB_64BIT to override */
 15 | #if !defined(MRB_32BIT) && !defined(MRB_64BIT)
 16 | #if UINT64_MAX == SIZE_MAX
 17 | #define MRB_64BIT
 18 | #else
 19 | #define MRB_32BIT
 20 | #endif
 21 | #endif
 22 | 
 23 | #if defined(MRB_32BIT) && defined(MRB_64BIT)
 24 | #error Cannot build for 32 and 64 bit architecture at the same time
 25 | #endif
 26 | 
 27 | /* configuration options: */
 28 | /* add -DMRB_USE_FLOAT to use float instead of double for floating point numbers */
 29 | //#define MRB_USE_FLOAT
 30 | 
 31 | /* exclude floating point numbers */
 32 | //#define MRB_WITHOUT_FLOAT
 33 | 
 34 | /* add -DMRB_METHOD_CACHE to use method cache to improve performance */
 35 | //#define MRB_METHOD_CACHE
 36 | /* size of the method cache (need to be the power of 2) */
 37 | //#define MRB_METHOD_CACHE_SIZE (1<<7)
 38 | 
 39 | /* add -DMRB_METHOD_TABLE_INLINE to reduce the size of method table */
 40 | /* MRB_METHOD_TABLE_INLINE requires LSB of function pointers to be zero */
 41 | /* you might need to specify --falign-functions=n (where n>1) */
 42 | //#define MRB_METHOD_TABLE_INLINE
 43 | 
 44 | /* add -DMRB_INT16 to use 16bit integer for mrb_int; conflict with MRB_INT64 */
 45 | //#define MRB_INT16
 46 | 
 47 | /* add -DMRB_INT64 to use 64bit integer for mrb_int; conflict with MRB_INT16 */
 48 | //#define MRB_INT64
 49 | 
 50 | /* if no specific integer type is chosen */
 51 | #if !defined(MRB_INT16) && !defined(MRB_INT32) && !defined(MRB_INT64)
 52 | # if defined(MRB_64BIT) && !defined(MRB_NAN_BOXING)
 53 | /* Use 64bit integers on 64bit architecture (without MRB_NAN_BOXING) */
 54 | #  define MRB_INT64
 55 | # else
 56 | /* Otherwise use 32bit integers */
 57 | #  define MRB_INT32
 58 | # endif
 59 | #endif
 60 | 
 61 | /* represent mrb_value in boxed double; conflict with MRB_USE_FLOAT and MRB_WITHOUT_FLOAT */
 62 | //#define MRB_NAN_BOXING
 63 | 
 64 | /* define on big endian machines; used by MRB_NAN_BOXING */
 65 | //#define MRB_ENDIAN_BIG
 66 | 
 67 | /* represent mrb_value as a word (natural unit of data for the processor) */
 68 | //#define MRB_WORD_BOXING
 69 | 
 70 | /* string class to handle UTF-8 encoding */
 71 | //#define MRB_UTF8_STRING
 72 | 
 73 | /* argv max size in mrb_funcall */
 74 | //#define MRB_FUNCALL_ARGC_MAX 16
 75 | 
 76 | /* number of object per heap page */
 77 | //#define MRB_HEAP_PAGE_SIZE 1024
 78 | 
 79 | /* if _etext and _edata available, mruby can reduce memory used by symbols */
 80 | //#define MRB_USE_ETEXT_EDATA
 81 | 
 82 | /* do not use __init_array_start to determine readonly data section;
 83 |    effective only when MRB_USE_ETEXT_EDATA is defined */
 84 | //#define MRB_NO_INIT_ARRAY_START
 85 | 
 86 | /* turn off generational GC by default */
 87 | //#define MRB_GC_TURN_OFF_GENERATIONAL
 88 | 
 89 | /* default size of khash table bucket */
 90 | //#define KHASH_DEFAULT_SIZE 32
 91 | 
 92 | /* allocated memory address alignment */
 93 | //#define POOL_ALIGNMENT 4
 94 | 
 95 | /* page size of memory pool */
 96 | //#define POOL_PAGE_SIZE 16000
 97 | 
 98 | /* initial minimum size for string buffer */
 99 | //#define MRB_STR_BUF_MIN_SIZE 128
100 | 
101 | /* arena size */
102 | //#define MRB_GC_ARENA_SIZE 100
103 | 
104 | /* fixed size GC arena */
105 | //#define MRB_GC_FIXED_ARENA
106 | 
107 | /* state atexit stack size */
108 | //#define MRB_FIXED_STATE_ATEXIT_STACK_SIZE 5
109 | 
110 | /* fixed size state atexit stack */
111 | //#define MRB_FIXED_STATE_ATEXIT_STACK
112 | 
113 | /* -DMRB_DISABLE_XXXX to drop following features */
114 | //#define MRB_DISABLE_STDIO /* use of stdio */
115 | 
116 | /* -DMRB_ENABLE_XXXX to enable following features */
117 | //#define MRB_ENABLE_DEBUG_HOOK /* hooks for debugger */
118 | 
119 | /* end of configuration */
120 | 
121 | /* define MRB_DISABLE_XXXX from DISABLE_XXX (for compatibility) */
122 | #ifdef DISABLE_STDIO
123 | #define MRB_DISABLE_STDIO
124 | #endif
125 | 
126 | /* define MRB_ENABLE_XXXX from ENABLE_XXX (for compatibility) */
127 | #ifdef ENABLE_DEBUG
128 | #define MRB_ENABLE_DEBUG_HOOK
129 | #endif
130 | 
131 | #ifndef MRB_DISABLE_STDIO
132 | # include <stdio.h>
133 | #endif
134 | 
135 | #ifndef FALSE
136 | # define FALSE 0
137 | #endif
138 | 
139 | #ifndef TRUE
140 | # define TRUE 1
141 | #endif
142 | 
143 | #endif  /* MRUBYCONF_H */
144 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Headers/mruby/array.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** mruby/array.h - Array class
  3 | **
  4 | ** See Copyright Notice in mruby.h
  5 | */
  6 | 
  7 | #ifndef MRUBY_ARRAY_H
  8 | #define MRUBY_ARRAY_H
  9 | 
 10 | #include "common.h"
 11 | 
 12 | /*
 13 |  * Array class
 14 |  */
 15 | MRB_BEGIN_DECL
 16 | 
 17 | 
 18 | typedef struct mrb_shared_array {
 19 |   int refcnt;
 20 |   mrb_int len;
 21 |   mrb_value *ptr;
 22 | } mrb_shared_array;
 23 | 
 24 | #define MRB_ARY_EMBED_LEN_MAX ((mrb_int)(sizeof(void*)*3/sizeof(mrb_value)))
 25 | struct RArray {
 26 |   MRB_OBJECT_HEADER;
 27 |   union {
 28 |     struct {
 29 |       mrb_int len;
 30 |       union {
 31 |         mrb_int capa;
 32 |         mrb_shared_array *shared;
 33 |       } aux;
 34 |       mrb_value *ptr;
 35 |     } heap;
 36 |     mrb_value embed[MRB_ARY_EMBED_LEN_MAX];
 37 |   } as;
 38 | };
 39 | 
 40 | #define mrb_ary_ptr(v)    ((struct RArray*)(mrb_ptr(v)))
 41 | #define mrb_ary_value(p)  mrb_obj_value((void*)(p))
 42 | #define RARRAY(v)  ((struct RArray*)(mrb_ptr(v)))
 43 | 
 44 | #define MRB_ARY_EMBED_MASK  7
 45 | #define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
 46 | #define ARY_UNSET_EMBED_FLAG(a) ((a)->flags &= ~(MRB_ARY_EMBED_MASK))
 47 | #define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
 48 | #define ARY_SET_EMBED_LEN(a,len) ((a)->flags = ((a)->flags&~MRB_ARY_EMBED_MASK) | ((uint32_t)(len) + 1))
 49 | #define ARY_EMBED_PTR(a) (&((a)->as.embed[0]))
 50 | 
 51 | #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(a)->as.heap.len)
 52 | #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
 53 | #define RARRAY_LEN(a) ARY_LEN(RARRAY(a))
 54 | #define RARRAY_PTR(a) ARY_PTR(RARRAY(a))
 55 | #define ARY_SET_LEN(a,n) do {\
 56 |   if (ARY_EMBED_P(a)) {\
 57 |     mrb_assert((n) <= MRB_ARY_EMBED_LEN_MAX); \
 58 |     ARY_SET_EMBED_LEN(a,n);\
 59 |   }\
 60 |   else\
 61 |     (a)->as.heap.len = (n);\
 62 | } while (0)
 63 | #define ARY_CAPA(a) (ARY_EMBED_P(a)?MRB_ARY_EMBED_LEN_MAX:(a)->as.heap.aux.capa)
 64 | #define MRB_ARY_SHARED      256
 65 | #define ARY_SHARED_P(a) ((a)->flags & MRB_ARY_SHARED)
 66 | #define ARY_SET_SHARED_FLAG(a) ((a)->flags |= MRB_ARY_SHARED)
 67 | #define ARY_UNSET_SHARED_FLAG(a) ((a)->flags &= ~MRB_ARY_SHARED)
 68 | 
 69 | void mrb_ary_decref(mrb_state*, mrb_shared_array*);
 70 | MRB_API void mrb_ary_modify(mrb_state*, struct RArray*);
 71 | MRB_API mrb_value mrb_ary_new_capa(mrb_state*, mrb_int);
 72 | 
 73 | /*
 74 |  * Initializes a new array.
 75 |  *
 76 |  * Equivalent to:
 77 |  *
 78 |  *      Array.new
 79 |  *
 80 |  * @param mrb The mruby state reference.
 81 |  * @return The initialized array.
 82 |  */
 83 | MRB_API mrb_value mrb_ary_new(mrb_state *mrb);
 84 | 
 85 | /*
 86 |  * Initializes a new array with initial values
 87 |  *
 88 |  * Equivalent to:
 89 |  *
 90 |  *      Array[value1, value2, ...]
 91 |  *
 92 |  * @param mrb The mruby state reference.
 93 |  * @param size The numer of values.
 94 |  * @param vals The actual values.
 95 |  * @return The initialized array.
 96 |  */
 97 | MRB_API mrb_value mrb_ary_new_from_values(mrb_state *mrb, mrb_int size, const mrb_value *vals);
 98 | 
 99 | /*
100 |  * Initializes a new array with two initial values
101 |  *
102 |  * Equivalent to:
103 |  *
104 |  *      Array[car, cdr]
105 |  *
106 |  * @param mrb The mruby state reference.
107 |  * @param car The first value.
108 |  * @param cdr The second value.
109 |  * @return The initialized array.
110 |  */
111 | MRB_API mrb_value mrb_assoc_new(mrb_state *mrb, mrb_value car, mrb_value cdr);
112 | 
113 | /*
114 |  * Concatenate two arrays. The target array will be modified
115 |  *
116 |  * Equivalent to:
117 |  *      ary.concat(other)
118 |  *
119 |  * @param mrb The mruby state reference.
120 |  * @param self The target array.
121 |  * @param other The array that will be concatenated to self.
122 |  */
123 | MRB_API void mrb_ary_concat(mrb_state *mrb, mrb_value self, mrb_value other);
124 | 
125 | /*
126 |  * Create an array from the input. It tries calling to_a on the
127 |  * value. If value does not respond to that, it creates a new
128 |  * array with just this value.
129 |  *
130 |  * @param mrb The mruby state reference.
131 |  * @param value The value to change into an array.
132 |  * @return An array representation of value.
133 |  */
134 | MRB_API mrb_value mrb_ary_splat(mrb_state *mrb, mrb_value value);
135 | 
136 | /*
137 |  * Pushes value into array.
138 |  *
139 |  * Equivalent to:
140 |  *
141 |  *      ary << value
142 |  *
143 |  * @param mrb The mruby state reference.
144 |  * @param ary The array in which the value will be pushed
145 |  * @param value The value to be pushed into array
146 |  */
147 | MRB_API void mrb_ary_push(mrb_state *mrb, mrb_value array, mrb_value value);
148 | 
149 | /*
150 |  * Pops the last element from the array.
151 |  *
152 |  * Equivalent to:
153 |  *
154 |  *      ary.pop
155 |  *
156 |  * @param mrb The mruby state reference.
157 |  * @param ary The array from which the value will be popped.
158 |  * @return The popped value.
159 |  */
160 | MRB_API mrb_value mrb_ary_pop(mrb_state *mrb, mrb_value ary);
161 | 
162 | /*
163 |  * Returns a reference to an element of the array on the given index.
164 |  *
165 |  * Equivalent to:
166 |  *
167 |  *      ary[n]
168 |  *
169 |  * @param mrb The mruby state reference.
170 |  * @param ary The target array.
171 |  * @param n The array index being referenced
172 |  * @return The referenced value.
173 |  */
174 | MRB_API mrb_value mrb_ary_ref(mrb_state *mrb, mrb_value ary, mrb_int n);
175 | 
176 | /*
177 |  * Sets a value on an array at the given index
178 |  *
179 |  * Equivalent to:
180 |  *
181 |  *      ary[n] = val
182 |  *
183 |  * @param mrb The mruby state reference.
184 |  * @param ary The target array.
185 |  * @param n The array index being referenced.
186 |  * @param val The value being setted.
187 |  */
188 | MRB_API void mrb_ary_set(mrb_state *mrb, mrb_value ary, mrb_int n, mrb_value val);
189 | 
190 | /*
191 |  * Replace the array with another array
192 |  *
193 |  * Equivalent to:
194 |  *
195 |  *      ary.replace(other)
196 |  *
197 |  * @param mrb The mruby state reference
198 |  * @param self The target array.
199 |  * @param other The array to replace it with.
200 |  */
201 | MRB_API void mrb_ary_replace(mrb_state *mrb, mrb_value self, mrb_value other);
202 | MRB_API mrb_value mrb_ensure_array_type(mrb_state *mrb, mrb_value self);
203 | MRB_API mrb_value mrb_check_array_type(mrb_state *mrb, mrb_value self);
204 | 
205 | /*
206 |  * Unshift an element into the array
207 |  *
208 |  * Equivalent to:
209 |  *
210 |  *     ary.unshift(item)
211 |  *
212 |  * @param mrb The mruby state reference.
213 |  * @param self The target array.
214 |  * @param item The item to unshift.
215 |  */
216 | MRB_API mrb_value mrb_ary_unshift(mrb_state *mrb, mrb_value self, mrb_value item);
217 | 
218 | /*
219 |  * Get nth element in the array
220 |  *
221 |  * Equivalent to:
222 |  *
223 |  *     ary[offset]
224 |  *
225 |  * @param ary The target array.
226 |  * @param offset The element position (negative counts from the tail).
227 |  */
228 | MRB_API mrb_value mrb_ary_entry(mrb_value ary, mrb_int offset);
229 | 
230 | /*
231 |  * Shifts the first element from the array.
232 |  *
233 |  * Equivalent to:
234 |  *
235 |  *      ary.shift
236 |  *
237 |  * @param mrb The mruby state reference.
238 |  * @param self The array from which the value will be shifted.
239 |  * @return The shifted value.
240 |  */
241 | MRB_API mrb_value mrb_ary_shift(mrb_state *mrb, mrb_value self);
242 | 
243 | /*
244 |  * Removes all elements from the array
245 |  *
246 |  * Equivalent to:
247 |  *
248 |  *      ary.clear
249 |  *
250 |  * @param mrb The mruby state reference.
251 |  * @param self The target array.
252 |  * @return self
253 |  */
254 | MRB_API mrb_value mrb_ary_clear(mrb_state *mrb, mrb_value self);
255 | 
256 | /*
257 |  * Join the array elements together in a string
258 |  *
259 |  * Equivalent to:
260 |  *
261 |  *      ary.join(sep="")
262 |  *
263 |  * @param mrb The mruby state reference.
264 |  * @param ary The target array
265 |  * @param sep The separater, can be NULL
266 |  */
267 | MRB_API mrb_value mrb_ary_join(mrb_state *mrb, mrb_value ary, mrb_value sep);
268 | 
269 | /*
270 |  * Update the capacity of the array
271 |  *
272 |  * @param mrb The mruby state reference.
273 |  * @param ary The target array.
274 |  * @param new_len The new capacity of the array
275 |  */
276 | MRB_API mrb_value mrb_ary_resize(mrb_state *mrb, mrb_value ary, mrb_int new_len);
277 | 
278 | MRB_END_DECL
279 | 
280 | #endif  /* MRUBY_ARRAY_H */
281 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Headers/mruby/boxing_nan.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** mruby/boxing_nan.h - nan boxing mrb_value definition
  3 | **
  4 | ** See Copyright Notice in mruby.h
  5 | */
  6 | 
  7 | #ifndef MRUBY_BOXING_NAN_H
  8 | #define MRUBY_BOXING_NAN_H
  9 | 
 10 | #ifdef MRB_USE_FLOAT
 11 | # error ---->> MRB_NAN_BOXING and MRB_USE_FLOAT conflict <<----
 12 | #endif
 13 | 
 14 | #ifdef MRB_WITHOUT_FLOAT
 15 | # error ---->> MRB_NAN_BOXING and MRB_WITHOUT_FLOAT conflict <<----
 16 | #endif
 17 | 
 18 | #ifdef MRB_INT64
 19 | # error ---->> MRB_NAN_BOXING and MRB_INT64 conflict <<----
 20 | #endif
 21 | 
 22 | #define MRB_FIXNUM_SHIFT 0
 23 | #define MRB_TT_HAS_BASIC MRB_TT_OBJECT
 24 | 
 25 | #ifdef MRB_ENDIAN_BIG
 26 | #define MRB_ENDIAN_LOHI(a,b) a b
 27 | #else
 28 | #define MRB_ENDIAN_LOHI(a,b) b a
 29 | #endif
 30 | 
 31 | /* value representation by nan-boxing:
 32 |  *   float : FFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFF
 33 |  *   object: 111111111111TTTT TTPPPPPPPPPPPPPP PPPPPPPPPPPPPPPP PPPPPPPPPPPPPPPP
 34 |  *   int   : 1111111111110001 0000000000000000 IIIIIIIIIIIIIIII IIIIIIIIIIIIIIII
 35 |  *   sym   : 1111111111110001 0100000000000000 SSSSSSSSSSSSSSSS SSSSSSSSSSSSSSSS
 36 |  * In order to get enough bit size to save TT, all pointers are shifted 2 bits
 37 |  * in the right direction. Also, TTTTTT is the mrb_vtype + 1;
 38 |  */
 39 | typedef struct mrb_value {
 40 |   union {
 41 |     mrb_float f;
 42 |     union {
 43 |       void *p;
 44 |       struct {
 45 |         MRB_ENDIAN_LOHI(
 46 |           uint32_t ttt;
 47 |           ,union {
 48 |             mrb_int i;
 49 |             mrb_sym sym;
 50 |           };
 51 |         )
 52 |       };
 53 |     } value;
 54 |   };
 55 | } mrb_value;
 56 | 
 57 | #define mrb_float_pool(mrb,f) mrb_float_value(mrb,f)
 58 | 
 59 | #define mrb_tt(o)       ((enum mrb_vtype)(((o).value.ttt & 0xfc000)>>14)-1)
 60 | #define mrb_type(o)     (enum mrb_vtype)((uint32_t)0xfff00000 < (o).value.ttt ? mrb_tt(o) : MRB_TT_FLOAT)
 61 | #define mrb_ptr(o)      ((void*)((((uintptr_t)0x3fffffffffff)&((uintptr_t)((o).value.p)))<<2))
 62 | #define mrb_float(o)    (o).f
 63 | #define mrb_cptr(o)     mrb_ptr(o)
 64 | #define mrb_fixnum(o)   (o).value.i
 65 | #define mrb_symbol(o)   (o).value.sym
 66 | 
 67 | #ifdef MRB_64BIT
 68 | #define BOXNAN_SHIFT_LONG_POINTER(v) (((uintptr_t)(v)>>34)&0x3fff)
 69 | #else
 70 | #define BOXNAN_SHIFT_LONG_POINTER(v) 0
 71 | #endif
 72 | 
 73 | #define BOXNAN_SET_VALUE(o, tt, attr, v) do {\
 74 |   (o).attr = (v);\
 75 |   (o).value.ttt = 0xfff00000 | (((tt)+1)<<14);\
 76 | } while (0)
 77 | 
 78 | #define BOXNAN_SET_OBJ_VALUE(o, tt, v) do {\
 79 |   (o).value.p = (void*)((uintptr_t)(v)>>2);\
 80 |   (o).value.ttt = (0xfff00000|(((tt)+1)<<14)|BOXNAN_SHIFT_LONG_POINTER(v));\
 81 | } while (0)
 82 | 
 83 | #define SET_FLOAT_VALUE(mrb,r,v) do { \
 84 |   if (v != v) { \
 85 |     (r).value.ttt = 0x7ff80000; \
 86 |     (r).value.i = 0; \
 87 |   } \
 88 |   else { \
 89 |     (r).f = v; \
 90 |   }} while(0)
 91 | 
 92 | #define SET_NIL_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_FALSE, value.i, 0)
 93 | #define SET_FALSE_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_FALSE, value.i, 1)
 94 | #define SET_TRUE_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_TRUE, value.i, 1)
 95 | #define SET_BOOL_VALUE(r,b) BOXNAN_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, value.i, 1)
 96 | #define SET_INT_VALUE(r,n) BOXNAN_SET_VALUE(r, MRB_TT_FIXNUM, value.i, (n))
 97 | #define SET_SYM_VALUE(r,v) BOXNAN_SET_VALUE(r, MRB_TT_SYMBOL, value.sym, (v))
 98 | #define SET_OBJ_VALUE(r,v) BOXNAN_SET_OBJ_VALUE(r, (((struct RObject*)(v))->tt), (v))
 99 | #define SET_CPTR_VALUE(mrb,r,v) BOXNAN_SET_OBJ_VALUE(r, MRB_TT_CPTR, v)
100 | #define SET_UNDEF_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_UNDEF, value.i, 0)
101 | 
102 | #endif  /* MRUBY_BOXING_NAN_H */
103 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Headers/mruby/boxing_no.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** mruby/boxing_no.h - unboxed mrb_value definition
 3 | **
 4 | ** See Copyright Notice in mruby.h
 5 | */
 6 | 
 7 | #ifndef MRUBY_BOXING_NO_H
 8 | #define MRUBY_BOXING_NO_H
 9 | 
10 | #define MRB_FIXNUM_SHIFT 0
11 | #define MRB_TT_HAS_BASIC MRB_TT_OBJECT
12 | 
13 | typedef struct mrb_value {
14 |   union {
15 | #ifndef MRB_WITHOUT_FLOAT
16 |     mrb_float f;
17 | #endif
18 |     void *p;
19 |     mrb_int i;
20 |     mrb_sym sym;
21 |   } value;
22 |   enum mrb_vtype tt;
23 | } mrb_value;
24 | 
25 | #ifndef MRB_WITHOUT_FLOAT
26 | #define mrb_float_pool(mrb,f) mrb_float_value(mrb,f)
27 | #endif
28 | 
29 | #define mrb_ptr(o)      (o).value.p
30 | #define mrb_cptr(o)     mrb_ptr(o)
31 | #ifndef MRB_WITHOUT_FLOAT
32 | #define mrb_float(o)    (o).value.f
33 | #endif
34 | #define mrb_fixnum(o)   (o).value.i
35 | #define mrb_symbol(o)   (o).value.sym
36 | #define mrb_type(o)     (o).tt
37 | 
38 | #define BOXNIX_SET_VALUE(o, ttt, attr, v) do {\
39 |   (o).tt = ttt;\
40 |   (o).attr = v;\
41 | } while (0)
42 | 
43 | #define SET_NIL_VALUE(r) BOXNIX_SET_VALUE(r, MRB_TT_FALSE, value.i, 0)
44 | #define SET_FALSE_VALUE(r) BOXNIX_SET_VALUE(r, MRB_TT_FALSE, value.i, 1)
45 | #define SET_TRUE_VALUE(r) BOXNIX_SET_VALUE(r, MRB_TT_TRUE, value.i, 1)
46 | #define SET_BOOL_VALUE(r,b) BOXNIX_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, value.i, 1)
47 | #define SET_INT_VALUE(r,n) BOXNIX_SET_VALUE(r, MRB_TT_FIXNUM, value.i, (n))
48 | #ifndef MRB_WITHOUT_FLOAT
49 | #define SET_FLOAT_VALUE(mrb,r,v) BOXNIX_SET_VALUE(r, MRB_TT_FLOAT, value.f, (v))
50 | #endif
51 | #define SET_SYM_VALUE(r,v) BOXNIX_SET_VALUE(r, MRB_TT_SYMBOL, value.sym, (v))
52 | #define SET_OBJ_VALUE(r,v) BOXNIX_SET_VALUE(r, (((struct RObject*)(v))->tt), value.p, (v))
53 | #define SET_CPTR_VALUE(mrb,r,v) BOXNIX_SET_VALUE(r, MRB_TT_CPTR, value.p, v)
54 | #define SET_UNDEF_VALUE(r) BOXNIX_SET_VALUE(r, MRB_TT_UNDEF, value.i, 0)
55 | 
56 | #endif  /* MRUBY_BOXING_NO_H */
57 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Headers/mruby/boxing_word.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** mruby/boxing_word.h - word boxing mrb_value definition
  3 | **
  4 | ** See Copyright Notice in mruby.h
  5 | */
  6 | 
  7 | #ifndef MRUBY_BOXING_WORD_H
  8 | #define MRUBY_BOXING_WORD_H
  9 | 
 10 | #if defined(MRB_INT16)
 11 | # error MRB_INT16 is too small for MRB_WORD_BOXING.
 12 | #endif
 13 | 
 14 | #if defined(MRB_INT64) && !defined(MRB_64BIT)
 15 | #error MRB_INT64 cannot be used with MRB_WORD_BOXING in 32-bit mode.
 16 | #endif
 17 | 
 18 | #ifndef MRB_WITHOUT_FLOAT
 19 | struct RFloat {
 20 |   MRB_OBJECT_HEADER;
 21 |   mrb_float f;
 22 | };
 23 | #endif
 24 | 
 25 | struct RCptr {
 26 |   MRB_OBJECT_HEADER;
 27 |   void *p;
 28 | };
 29 | 
 30 | #define MRB_FIXNUM_SHIFT 1
 31 | #ifdef MRB_WITHOUT_FLOAT
 32 | #define MRB_TT_HAS_BASIC MRB_TT_CPTR
 33 | #else
 34 | #define MRB_TT_HAS_BASIC MRB_TT_FLOAT
 35 | #endif
 36 | 
 37 | enum mrb_special_consts {
 38 |   MRB_Qnil    = 0,
 39 |   MRB_Qfalse  = 2,
 40 |   MRB_Qtrue   = 4,
 41 |   MRB_Qundef  = 6,
 42 | };
 43 | 
 44 | #define MRB_FIXNUM_FLAG   0x01
 45 | #define MRB_SYMBOL_FLAG   0x0e
 46 | #define MRB_SPECIAL_SHIFT 8
 47 | 
 48 | #if defined(MRB_64BIT)
 49 | #define MRB_SYMBOL_BITSIZE  (sizeof(mrb_sym) * CHAR_BIT)
 50 | #define MRB_SYMBOL_MAX      UINT32_MAX
 51 | #else
 52 | #define MRB_SYMBOL_BITSIZE  (sizeof(mrb_sym) * CHAR_BIT - MRB_SPECIAL_SHIFT)
 53 | #define MRB_SYMBOL_MAX      (UINT32_MAX >> MRB_SPECIAL_SHIFT)
 54 | #endif
 55 | 
 56 | typedef union mrb_value {
 57 |   union {
 58 |     void *p;
 59 |     struct {
 60 |       unsigned int i_flag : MRB_FIXNUM_SHIFT;
 61 |       mrb_int i : (MRB_INT_BIT - MRB_FIXNUM_SHIFT);
 62 |     };
 63 |     struct {
 64 |       unsigned int sym_flag : MRB_SPECIAL_SHIFT;
 65 |       mrb_sym sym : MRB_SYMBOL_BITSIZE;
 66 |     };
 67 |     struct RBasic *bp;
 68 | #ifndef MRB_WITHOUT_FLOAT
 69 |     struct RFloat *fp;
 70 | #endif
 71 |     struct RCptr *vp;
 72 |   } value;
 73 |   unsigned long w;
 74 | } mrb_value;
 75 | 
 76 | MRB_API mrb_value mrb_word_boxing_cptr_value(struct mrb_state*, void*);
 77 | #ifndef MRB_WITHOUT_FLOAT
 78 | MRB_API mrb_value mrb_word_boxing_float_value(struct mrb_state*, mrb_float);
 79 | MRB_API mrb_value mrb_word_boxing_float_pool(struct mrb_state*, mrb_float);
 80 | #endif
 81 | 
 82 | #ifndef MRB_WITHOUT_FLOAT
 83 | #define mrb_float_pool(mrb,f) mrb_word_boxing_float_pool(mrb,f)
 84 | #endif
 85 | 
 86 | #define mrb_ptr(o)     (o).value.p
 87 | #define mrb_cptr(o)    (o).value.vp->p
 88 | #ifndef MRB_WITHOUT_FLOAT
 89 | #define mrb_float(o)   (o).value.fp->f
 90 | #endif
 91 | #define mrb_fixnum(o)  ((mrb_int)(o).value.i)
 92 | #define mrb_symbol(o)  (o).value.sym
 93 | 
 94 | static inline enum mrb_vtype
 95 | mrb_type(mrb_value o)
 96 | {
 97 |   switch (o.w) {
 98 |   case MRB_Qfalse:
 99 |   case MRB_Qnil:
100 |     return MRB_TT_FALSE;
101 |   case MRB_Qtrue:
102 |     return MRB_TT_TRUE;
103 |   case MRB_Qundef:
104 |     return MRB_TT_UNDEF;
105 |   }
106 |   if (o.value.i_flag == MRB_FIXNUM_FLAG) {
107 |     return MRB_TT_FIXNUM;
108 |   }
109 |   if (o.value.sym_flag == MRB_SYMBOL_FLAG) {
110 |     return MRB_TT_SYMBOL;
111 |   }
112 |   return o.value.bp->tt;
113 | }
114 | 
115 | #define mrb_bool(o)    ((o).w != MRB_Qnil && (o).w != MRB_Qfalse)
116 | #define mrb_fixnum_p(o) ((o).value.i_flag == MRB_FIXNUM_FLAG)
117 | #define mrb_undef_p(o) ((o).w == MRB_Qundef)
118 | #define mrb_nil_p(o)  ((o).w == MRB_Qnil)
119 | 
120 | #define BOXWORD_SET_VALUE(o, ttt, attr, v) do { \
121 |   switch (ttt) {\
122 |   case MRB_TT_FALSE:  (o).w = (v) ? MRB_Qfalse : MRB_Qnil; break;\
123 |   case MRB_TT_TRUE:   (o).w = MRB_Qtrue; break;\
124 |   case MRB_TT_UNDEF:  (o).w = MRB_Qundef; break;\
125 |   case MRB_TT_FIXNUM: (o).w = 0;(o).value.i_flag = MRB_FIXNUM_FLAG; (o).attr = (v); break;\
126 |   case MRB_TT_SYMBOL: (o).w = 0;(o).value.sym_flag = MRB_SYMBOL_FLAG; (o).attr = (v); break;\
127 |   default:            (o).w = 0; (o).attr = (v); if ((o).value.bp) (o).value.bp->tt = ttt; break;\
128 |   }\
129 | } while (0)
130 | 
131 | #ifndef MRB_WITHOUT_FLOAT
132 | #define SET_FLOAT_VALUE(mrb,r,v) r = mrb_word_boxing_float_value(mrb, v)
133 | #endif
134 | #define SET_CPTR_VALUE(mrb,r,v) r = mrb_word_boxing_cptr_value(mrb, v)
135 | #define SET_NIL_VALUE(r) BOXWORD_SET_VALUE(r, MRB_TT_FALSE, value.i, 0)
136 | #define SET_FALSE_VALUE(r) BOXWORD_SET_VALUE(r, MRB_TT_FALSE, value.i, 1)
137 | #define SET_TRUE_VALUE(r) BOXWORD_SET_VALUE(r, MRB_TT_TRUE, value.i, 1)
138 | #define SET_BOOL_VALUE(r,b) BOXWORD_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, value.i, 1)
139 | #define SET_INT_VALUE(r,n) BOXWORD_SET_VALUE(r, MRB_TT_FIXNUM, value.i, (n))
140 | #define SET_SYM_VALUE(r,v) BOXWORD_SET_VALUE(r, MRB_TT_SYMBOL, value.sym, (v))
141 | #define SET_OBJ_VALUE(r,v) BOXWORD_SET_VALUE(r, (((struct RObject*)(v))->tt), value.p, (v))
142 | #define SET_UNDEF_VALUE(r) BOXWORD_SET_VALUE(r, MRB_TT_UNDEF, value.i, 0)
143 | 
144 | #endif  /* MRUBY_BOXING_WORD_H */
145 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Headers/mruby/class.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** mruby/class.h - Class class
 3 | **
 4 | ** See Copyright Notice in mruby.h
 5 | */
 6 | 
 7 | #ifndef MRUBY_CLASS_H
 8 | #define MRUBY_CLASS_H
 9 | 
10 | #include "common.h"
11 | 
12 | /**
13 |  * Class class
14 |  */
15 | MRB_BEGIN_DECL
16 | 
17 | struct RClass {
18 |   MRB_OBJECT_HEADER;
19 |   struct iv_tbl *iv;
20 |   struct kh_mt *mt;
21 |   struct RClass *super;
22 | };
23 | 
24 | #define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
25 | 
26 | static inline struct RClass*
27 | mrb_class(mrb_state *mrb, mrb_value v)
28 | {
29 |   switch (mrb_type(v)) {
30 |   case MRB_TT_FALSE:
31 |     if (mrb_fixnum(v))
32 |       return mrb->false_class;
33 |     return mrb->nil_class;
34 |   case MRB_TT_TRUE:
35 |     return mrb->true_class;
36 |   case MRB_TT_SYMBOL:
37 |     return mrb->symbol_class;
38 |   case MRB_TT_FIXNUM:
39 |     return mrb->fixnum_class;
40 | #ifndef MRB_WITHOUT_FLOAT
41 |   case MRB_TT_FLOAT:
42 |     return mrb->float_class;
43 | #endif
44 |   case MRB_TT_CPTR:
45 |     return mrb->object_class;
46 |   case MRB_TT_ENV:
47 |     return NULL;
48 |   default:
49 |     return mrb_obj_ptr(v)->c;
50 |   }
51 | }
52 | 
53 | /* flags:
54 |    20: frozen
55 |    19: is_prepended
56 |    18: is_origin
57 |    17: is_inherited (used by method cache)
58 |    16: unused
59 |    0-15: instance type
60 | */
61 | #define MRB_FL_CLASS_IS_PREPENDED (1 << 19)
62 | #define MRB_FL_CLASS_IS_ORIGIN (1 << 18)
63 | #define MRB_CLASS_ORIGIN(c) do {\
64 |   if (c->flags & MRB_FL_CLASS_IS_PREPENDED) {\
65 |     c = c->super;\
66 |     while (!(c->flags & MRB_FL_CLASS_IS_ORIGIN)) {\
67 |       c = c->super;\
68 |     }\
69 |   }\
70 | } while (0)
71 | #define MRB_FL_CLASS_IS_INHERITED (1 << 17)
72 | #define MRB_INSTANCE_TT_MASK (0xFF)
73 | #define MRB_SET_INSTANCE_TT(c, tt) c->flags = ((c->flags & ~MRB_INSTANCE_TT_MASK) | (char)tt)
74 | #define MRB_INSTANCE_TT(c) (enum mrb_vtype)(c->flags & MRB_INSTANCE_TT_MASK)
75 | 
76 | MRB_API struct RClass* mrb_define_class_id(mrb_state*, mrb_sym, struct RClass*);
77 | MRB_API struct RClass* mrb_define_module_id(mrb_state*, mrb_sym);
78 | MRB_API struct RClass *mrb_vm_define_class(mrb_state*, mrb_value, mrb_value, mrb_sym);
79 | MRB_API struct RClass *mrb_vm_define_module(mrb_state*, mrb_value, mrb_sym);
80 | MRB_API void mrb_define_method_raw(mrb_state*, struct RClass*, mrb_sym, mrb_method_t);
81 | MRB_API void mrb_define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t func, mrb_aspec aspec);
82 | MRB_API void mrb_alias_method(mrb_state*, struct RClass *c, mrb_sym a, mrb_sym b);
83 | 
84 | MRB_API mrb_method_t mrb_method_search_vm(mrb_state*, struct RClass**, mrb_sym);
85 | MRB_API mrb_method_t mrb_method_search(mrb_state*, struct RClass*, mrb_sym);
86 | 
87 | MRB_API struct RClass* mrb_class_real(struct RClass* cl);
88 | 
89 | void mrb_class_name_class(mrb_state*, struct RClass*, struct RClass*, mrb_sym);
90 | mrb_value mrb_class_find_path(mrb_state*, struct RClass*);
91 | void mrb_gc_mark_mt(mrb_state*, struct RClass*);
92 | size_t mrb_gc_mark_mt_size(mrb_state*, struct RClass*);
93 | void mrb_gc_free_mt(mrb_state*, struct RClass*);
94 | 
95 | MRB_END_DECL
96 | 
97 | #endif  /* MRUBY_CLASS_H */
98 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Headers/mruby/common.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | **"common.h - mruby common platform definition"
 3 | **
 4 | ** See Copyright Notice in mruby.h
 5 | */
 6 | 
 7 | #ifndef MRUBY_COMMON_H
 8 | #define MRUBY_COMMON_H
 9 | 
10 | #ifdef __APPLE__
11 |   #ifndef __TARGETCONDITIONALS__
12 |   #include "TargetConditionals.h"
13 |   #endif
14 | #endif
15 | 
16 | #ifdef __cplusplus
17 | #ifdef MRB_ENABLE_CXX_ABI
18 | #define MRB_BEGIN_DECL
19 | #define MRB_END_DECL
20 | #else
21 | # define MRB_BEGIN_DECL extern "C" {
22 | # define MRB_END_DECL }
23 | #endif
24 | #else
25 | /** Start declarations in C mode */
26 | # define MRB_BEGIN_DECL
27 | /** End declarations in C mode */
28 | # define MRB_END_DECL
29 | #endif
30 | 
31 | /**
32 |  * Shared compiler macros
33 |  */
34 | MRB_BEGIN_DECL
35 | 
36 | /** Declare a function that never returns. */
37 | #if __STDC_VERSION__ >= 201112L
38 | # define mrb_noreturn _Noreturn
39 | #elif defined __GNUC__ && !defined __STRICT_ANSI__
40 | # define mrb_noreturn __attribute__((noreturn))
41 | #elif defined _MSC_VER
42 | # define mrb_noreturn __declspec(noreturn)
43 | #else
44 | # define mrb_noreturn
45 | #endif
46 | 
47 | /** Mark a function as deprecated. */
48 | #if defined __GNUC__ && !defined __STRICT_ANSI__
49 | # define mrb_deprecated __attribute__((deprecated))
50 | #elif defined _MSC_VER
51 | # define mrb_deprecated __declspec(deprecated)
52 | #else
53 | # define mrb_deprecated
54 | #endif
55 | 
56 | /** Declare a function as always inlined. */
57 | #if defined(_MSC_VER)
58 | # define MRB_INLINE static __inline
59 | #else
60 | # define MRB_INLINE static inline
61 | #endif
62 | 
63 | 
64 | /** Declare a public MRuby API function. */
65 | #if defined(MRB_BUILD_AS_DLL)
66 | #if defined(MRB_CORE) || defined(MRB_LIB)
67 | # define MRB_API __declspec(dllexport)
68 | #else
69 | # define MRB_API __declspec(dllimport)
70 | #endif
71 | #else
72 | # define MRB_API extern
73 | #endif
74 | 
75 | MRB_END_DECL
76 | 
77 | #endif  /* MRUBY_COMMON_H */
78 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Headers/mruby/compile.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** mruby/compile.h - mruby parser
  3 | **
  4 | ** See Copyright Notice in mruby.h
  5 | */
  6 | 
  7 | #ifndef MRUBY_COMPILE_H
  8 | #define MRUBY_COMPILE_H
  9 | 
 10 | #include "common.h"
 11 | 
 12 | /**
 13 |  * MRuby Compiler
 14 |  */
 15 | MRB_BEGIN_DECL
 16 | 
 17 | #include <mruby.h>
 18 | 
 19 | struct mrb_jmpbuf;
 20 | 
 21 | struct mrb_parser_state;
 22 | /* load context */
 23 | typedef struct mrbc_context {
 24 |   mrb_sym *syms;
 25 |   int slen;
 26 |   char *filename;
 27 |   short lineno;
 28 |   int (*partial_hook)(struct mrb_parser_state*);
 29 |   void *partial_data;
 30 |   struct RClass *target_class;
 31 |   mrb_bool capture_errors:1;
 32 |   mrb_bool dump_result:1;
 33 |   mrb_bool no_exec:1;
 34 |   mrb_bool keep_lv:1;
 35 |   mrb_bool no_optimize:1;
 36 |   mrb_bool on_eval:1;
 37 | 
 38 |   size_t parser_nerr;
 39 | } mrbc_context;
 40 | 
 41 | MRB_API mrbc_context* mrbc_context_new(mrb_state *mrb);
 42 | MRB_API void mrbc_context_free(mrb_state *mrb, mrbc_context *cxt);
 43 | MRB_API const char *mrbc_filename(mrb_state *mrb, mrbc_context *c, const char *s);
 44 | MRB_API void mrbc_partial_hook(mrb_state *mrb, mrbc_context *c, int (*partial_hook)(struct mrb_parser_state*), void*data);
 45 | 
 46 | /* AST node structure */
 47 | typedef struct mrb_ast_node {
 48 |   struct mrb_ast_node *car, *cdr;
 49 |   uint16_t lineno, filename_index;
 50 | } mrb_ast_node;
 51 | 
 52 | /* lexer states */
 53 | enum mrb_lex_state_enum {
 54 |   EXPR_BEG,                   /* ignore newline, +/- is a sign. */
 55 |   EXPR_END,                   /* newline significant, +/- is an operator. */
 56 |   EXPR_ENDARG,                /* ditto, and unbound braces. */
 57 |   EXPR_ENDFN,                 /* ditto, and unbound braces. */
 58 |   EXPR_ARG,                   /* newline significant, +/- is an operator. */
 59 |   EXPR_CMDARG,                /* newline significant, +/- is an operator. */
 60 |   EXPR_MID,                   /* newline significant, +/- is an operator. */
 61 |   EXPR_FNAME,                 /* ignore newline, no reserved words. */
 62 |   EXPR_DOT,                   /* right after '.' or '::', no reserved words. */
 63 |   EXPR_CLASS,                 /* immediate after 'class', no here document. */
 64 |   EXPR_VALUE,                 /* alike EXPR_BEG but label is disallowed. */
 65 |   EXPR_MAX_STATE
 66 | };
 67 | 
 68 | /* saved error message */
 69 | struct mrb_parser_message {
 70 |   int lineno;
 71 |   int column;
 72 |   char* message;
 73 | };
 74 | 
 75 | #define STR_FUNC_PARSING 0x01
 76 | #define STR_FUNC_EXPAND  0x02
 77 | #define STR_FUNC_REGEXP  0x04
 78 | #define STR_FUNC_WORD    0x08
 79 | #define STR_FUNC_SYMBOL  0x10
 80 | #define STR_FUNC_ARRAY   0x20
 81 | #define STR_FUNC_HEREDOC 0x40
 82 | #define STR_FUNC_XQUOTE  0x80
 83 | 
 84 | enum mrb_string_type {
 85 |   str_not_parsing  = (0),
 86 |   str_squote   = (STR_FUNC_PARSING),
 87 |   str_dquote   = (STR_FUNC_PARSING|STR_FUNC_EXPAND),
 88 |   str_regexp   = (STR_FUNC_PARSING|STR_FUNC_REGEXP|STR_FUNC_EXPAND),
 89 |   str_sword    = (STR_FUNC_PARSING|STR_FUNC_WORD|STR_FUNC_ARRAY),
 90 |   str_dword    = (STR_FUNC_PARSING|STR_FUNC_WORD|STR_FUNC_ARRAY|STR_FUNC_EXPAND),
 91 |   str_ssym     = (STR_FUNC_PARSING|STR_FUNC_SYMBOL),
 92 |   str_ssymbols = (STR_FUNC_PARSING|STR_FUNC_SYMBOL|STR_FUNC_ARRAY),
 93 |   str_dsymbols = (STR_FUNC_PARSING|STR_FUNC_SYMBOL|STR_FUNC_ARRAY|STR_FUNC_EXPAND),
 94 |   str_heredoc  = (STR_FUNC_PARSING|STR_FUNC_HEREDOC),
 95 |   str_xquote   = (STR_FUNC_PARSING|STR_FUNC_XQUOTE|STR_FUNC_EXPAND),
 96 | };
 97 | 
 98 | /* heredoc structure */
 99 | struct mrb_parser_heredoc_info {
100 |   mrb_bool allow_indent:1;
101 |   mrb_bool line_head:1;
102 |   enum mrb_string_type type;
103 |   const char *term;
104 |   int term_len;
105 |   mrb_ast_node *doc;
106 | };
107 | 
108 | #define MRB_PARSER_TOKBUF_MAX 65536
109 | #define MRB_PARSER_TOKBUF_SIZE 256
110 | 
111 | /* parser structure */
112 | struct mrb_parser_state {
113 |   mrb_state *mrb;
114 |   struct mrb_pool *pool;
115 |   mrb_ast_node *cells;
116 |   const char *s, *send;
117 | #ifndef MRB_DISABLE_STDIO
118 |   FILE *f;
119 | #endif
120 |   mrbc_context *cxt;
121 |   char const *filename;
122 |   int lineno;
123 |   int column;
124 | 
125 |   enum mrb_lex_state_enum lstate;
126 |   mrb_ast_node *lex_strterm; /* (type nest_level beg . end) */
127 | 
128 |   unsigned int cond_stack;
129 |   unsigned int cmdarg_stack;
130 |   int paren_nest;
131 |   int lpar_beg;
132 |   int in_def, in_single;
133 |   mrb_bool cmd_start:1;
134 |   mrb_ast_node *locals;
135 | 
136 |   mrb_ast_node *pb;
137 |   char *tokbuf;
138 |   char buf[MRB_PARSER_TOKBUF_SIZE];
139 |   int tidx;
140 |   int tsiz;
141 | 
142 |   mrb_ast_node *all_heredocs; /* list of mrb_parser_heredoc_info* */
143 |   mrb_ast_node *heredocs_from_nextline;
144 |   mrb_ast_node *parsing_heredoc;
145 |   mrb_ast_node *lex_strterm_before_heredoc;
146 | 
147 |   void *ylval;
148 | 
149 |   size_t nerr;
150 |   size_t nwarn;
151 |   mrb_ast_node *tree;
152 | 
153 |   mrb_bool no_optimize:1;
154 |   mrb_bool on_eval:1;
155 |   mrb_bool capture_errors:1;
156 |   struct mrb_parser_message error_buffer[10];
157 |   struct mrb_parser_message warn_buffer[10];
158 | 
159 |   mrb_sym* filename_table;
160 |   uint16_t filename_table_length;
161 |   uint16_t current_filename_index;
162 | 
163 |   struct mrb_jmpbuf* jmp;
164 | };
165 | 
166 | MRB_API struct mrb_parser_state* mrb_parser_new(mrb_state*);
167 | MRB_API void mrb_parser_free(struct mrb_parser_state*);
168 | MRB_API void mrb_parser_parse(struct mrb_parser_state*,mrbc_context*);
169 | 
170 | MRB_API void mrb_parser_set_filename(struct mrb_parser_state*, char const*);
171 | MRB_API char const* mrb_parser_get_filename(struct mrb_parser_state*, uint16_t idx);
172 | 
173 | /* utility functions */
174 | #ifndef MRB_DISABLE_STDIO
175 | MRB_API struct mrb_parser_state* mrb_parse_file(mrb_state*,FILE*,mrbc_context*);
176 | #endif
177 | MRB_API struct mrb_parser_state* mrb_parse_string(mrb_state*,const char*,mrbc_context*);
178 | MRB_API struct mrb_parser_state* mrb_parse_nstring(mrb_state*,const char*,size_t,mrbc_context*);
179 | MRB_API struct RProc* mrb_generate_code(mrb_state*, struct mrb_parser_state*);
180 | MRB_API mrb_value mrb_load_exec(mrb_state *mrb, struct mrb_parser_state *p, mrbc_context *c);
181 | 
182 | /* program load functions */
183 | #ifndef MRB_DISABLE_STDIO
184 | MRB_API mrb_value mrb_load_file(mrb_state*,FILE*);
185 | MRB_API mrb_value mrb_load_file_cxt(mrb_state*,FILE*, mrbc_context *cxt);
186 | #endif
187 | MRB_API mrb_value mrb_load_string(mrb_state *mrb, const char *s);
188 | MRB_API mrb_value mrb_load_nstring(mrb_state *mrb, const char *s, size_t len);
189 | MRB_API mrb_value mrb_load_string_cxt(mrb_state *mrb, const char *s, mrbc_context *cxt);
190 | MRB_API mrb_value mrb_load_nstring_cxt(mrb_state *mrb, const char *s, size_t len, mrbc_context *cxt);
191 | 
192 | /** @} */
193 | MRB_END_DECL
194 | 
195 | #endif /* MRUBY_COMPILE_H */
196 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Headers/mruby/data.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** mruby/data.h - Data class
 3 | **
 4 | ** See Copyright Notice in mruby.h
 5 | */
 6 | 
 7 | #ifndef MRUBY_DATA_H
 8 | #define MRUBY_DATA_H
 9 | 
10 | #include "common.h"
11 | 
12 | /**
13 |  * Custom C wrapped data.
14 |  *
15 |  * Defining Ruby wrappers around native objects.
16 |  */
17 | MRB_BEGIN_DECL
18 | 
19 | /**
20 |  * Custom data type description.
21 |  */
22 | typedef struct mrb_data_type {
23 |   /** data type name */
24 |   const char *struct_name;
25 | 
26 |   /** data type release function pointer */
27 |   void (*dfree)(mrb_state *mrb, void*);
28 | } mrb_data_type;
29 | 
30 | struct RData {
31 |   MRB_OBJECT_HEADER;
32 |   struct iv_tbl *iv;
33 |   const mrb_data_type *type;
34 |   void *data;
35 | };
36 | 
37 | MRB_API struct RData *mrb_data_object_alloc(mrb_state *mrb, struct RClass* klass, void *datap, const mrb_data_type *type);
38 | 
39 | #define Data_Wrap_Struct(mrb,klass,type,ptr)\
40 |   mrb_data_object_alloc(mrb,klass,ptr,type)
41 | 
42 | #define Data_Make_Struct(mrb,klass,strct,type,sval,data) do { \
43 |   sval = mrb_malloc(mrb, sizeof(strct));                     \
44 |   { static const strct zero = { 0 }; *sval = zero; };\
45 |   data = Data_Wrap_Struct(mrb,klass,type,sval);\
46 | } while (0)
47 | 
48 | #define RDATA(obj)         ((struct RData *)(mrb_ptr(obj)))
49 | #define DATA_PTR(d)        (RDATA(d)->data)
50 | #define DATA_TYPE(d)       (RDATA(d)->type)
51 | MRB_API void mrb_data_check_type(mrb_state *mrb, mrb_value, const mrb_data_type*);
52 | MRB_API void *mrb_data_get_ptr(mrb_state *mrb, mrb_value, const mrb_data_type*);
53 | #define DATA_GET_PTR(mrb,obj,dtype,type) (type*)mrb_data_get_ptr(mrb,obj,dtype)
54 | MRB_API void *mrb_data_check_get_ptr(mrb_state *mrb, mrb_value, const mrb_data_type*);
55 | #define DATA_CHECK_GET_PTR(mrb,obj,dtype,type) (type*)mrb_data_check_get_ptr(mrb,obj,dtype)
56 | 
57 | /* obsolete functions and macros */
58 | #define mrb_data_check_and_get(mrb,obj,dtype) mrb_data_get_ptr(mrb,obj,dtype)
59 | #define mrb_get_datatype(mrb,val,type) mrb_data_get_ptr(mrb, val, type)
60 | #define mrb_check_datatype(mrb,val,type) mrb_data_get_ptr(mrb, val, type)
61 | #define Data_Get_Struct(mrb,obj,type,sval) do {\
62 |   *(void**)&sval = mrb_data_get_ptr(mrb, obj, type); \
63 | } while (0)
64 | 
65 | static inline void
66 | mrb_data_init(mrb_value v, void *ptr, const mrb_data_type *type)
67 | {
68 |   mrb_assert(mrb_type(v) == MRB_TT_DATA);
69 |   DATA_PTR(v) = ptr;
70 |   DATA_TYPE(v) = type;
71 | }
72 | 
73 | MRB_END_DECL
74 | 
75 | #endif /* MRUBY_DATA_H */
76 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Headers/mruby/debug.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** mruby/debug.h - mruby debug info
 3 | **
 4 | ** See Copyright Notice in mruby.h
 5 | */
 6 | 
 7 | #ifndef MRUBY_DEBUG_H
 8 | #define MRUBY_DEBUG_H
 9 | 
10 | #include "common.h"
11 | 
12 | /**
13 |  * MRuby Debugging.
14 |  */
15 | MRB_BEGIN_DECL
16 | 
17 | typedef enum mrb_debug_line_type {
18 |   mrb_debug_line_ary = 0,
19 |   mrb_debug_line_flat_map = 1
20 | } mrb_debug_line_type;
21 | 
22 | typedef struct mrb_irep_debug_info_line {
23 |   uint32_t start_pos;
24 |   uint16_t line;
25 | } mrb_irep_debug_info_line;
26 | 
27 | typedef struct mrb_irep_debug_info_file {
28 |   uint32_t start_pos;
29 |   const char *filename;
30 |   mrb_sym filename_sym;
31 |   uint32_t line_entry_count;
32 |   mrb_debug_line_type line_type;
33 |   union {
34 |     void *ptr;
35 |     mrb_irep_debug_info_line *flat_map;
36 |     uint16_t *ary;
37 |   } lines;
38 | } mrb_irep_debug_info_file;
39 | 
40 | typedef struct mrb_irep_debug_info {
41 |   uint32_t pc_count;
42 |   uint16_t flen;
43 |   mrb_irep_debug_info_file **files;
44 | } mrb_irep_debug_info;
45 | 
46 | /*
47 |  * get line from irep's debug info and program counter
48 |  * @return returns NULL if not found
49 |  */
50 | MRB_API const char *mrb_debug_get_filename(mrb_irep *irep, ptrdiff_t pc);
51 | 
52 | /*
53 |  * get line from irep's debug info and program counter
54 |  * @return returns -1 if not found
55 |  */
56 | MRB_API int32_t mrb_debug_get_line(mrb_irep *irep, ptrdiff_t pc);
57 | 
58 | MRB_API mrb_irep_debug_info *mrb_debug_info_alloc(mrb_state *mrb, mrb_irep *irep);
59 | MRB_API mrb_irep_debug_info_file *mrb_debug_info_append_file(
60 |     mrb_state *mrb, mrb_irep_debug_info *info,
61 |     const char *filename, uint16_t *lines,
62 |     uint32_t start_pos, uint32_t end_pos);
63 | MRB_API void mrb_debug_info_free(mrb_state *mrb, mrb_irep_debug_info *d);
64 | 
65 | MRB_END_DECL
66 | 
67 | #endif /* MRUBY_DEBUG_H */
68 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Headers/mruby/dump.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** mruby/dump.h - mruby binary dumper (mrbc binary format)
  3 | **
  4 | ** See Copyright Notice in mruby.h
  5 | */
  6 | 
  7 | #ifndef MRUBY_DUMP_H
  8 | #define MRUBY_DUMP_H
  9 | 
 10 | #include <mruby.h>
 11 | #include <mruby/irep.h>
 12 | #include "common.h"
 13 | 
 14 | /**
 15 |  * Dumping compiled mruby script.
 16 |  */
 17 | MRB_BEGIN_DECL
 18 | 
 19 | #define DUMP_DEBUG_INFO 1
 20 | #define DUMP_ENDIAN_BIG 2
 21 | #define DUMP_ENDIAN_LIL 4
 22 | #define DUMP_ENDIAN_NAT 6
 23 | #define DUMP_ENDIAN_MASK 6
 24 | 
 25 | int mrb_dump_irep(mrb_state *mrb, mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size);
 26 | #ifndef MRB_DISABLE_STDIO
 27 | int mrb_dump_irep_binary(mrb_state*, mrb_irep*, uint8_t, FILE*);
 28 | int mrb_dump_irep_cfunc(mrb_state *mrb, mrb_irep*, uint8_t flags, FILE *f, const char *initname);
 29 | mrb_irep *mrb_read_irep_file(mrb_state*, FILE*);
 30 | MRB_API mrb_value mrb_load_irep_file(mrb_state*,FILE*);
 31 | MRB_API mrb_value mrb_load_irep_file_cxt(mrb_state*, FILE*, mrbc_context*);
 32 | #endif
 33 | MRB_API mrb_irep *mrb_read_irep(mrb_state*, const uint8_t*);
 34 | 
 35 | /* dump/load error code
 36 |  *
 37 |  * NOTE: MRB_DUMP_GENERAL_FAILURE is caused by
 38 |  * unspecified issues like malloc failed.
 39 |  */
 40 | #define MRB_DUMP_OK                     0
 41 | #define MRB_DUMP_GENERAL_FAILURE      (-1)
 42 | #define MRB_DUMP_WRITE_FAULT          (-2)
 43 | #define MRB_DUMP_READ_FAULT           (-3)
 44 | #define MRB_DUMP_CRC_ERROR            (-4)
 45 | #define MRB_DUMP_INVALID_FILE_HEADER  (-5)
 46 | #define MRB_DUMP_INVALID_IREP         (-6)
 47 | #define MRB_DUMP_INVALID_ARGUMENT     (-7)
 48 | 
 49 | /* null symbol length */
 50 | #define MRB_DUMP_NULL_SYM_LEN         0xFFFF
 51 | 
 52 | /* Rite Binary File header */
 53 | #define RITE_BINARY_IDENT              "RITE"
 54 | #define RITE_BINARY_IDENT_LIL          "ETIR"
 55 | #define RITE_BINARY_FORMAT_VER         "0005"
 56 | #define RITE_COMPILER_NAME             "MATZ"
 57 | #define RITE_COMPILER_VERSION          "0000"
 58 | 
 59 | #define RITE_VM_VER                    "0002"
 60 | 
 61 | #define RITE_BINARY_EOF                "END\0"
 62 | #define RITE_SECTION_IREP_IDENT        "IREP"
 63 | #define RITE_SECTION_LINENO_IDENT      "LINE"
 64 | #define RITE_SECTION_DEBUG_IDENT       "DBG\0"
 65 | #define RITE_SECTION_LV_IDENT          "LVAR"
 66 | 
 67 | #define MRB_DUMP_DEFAULT_STR_LEN      128
 68 | #define MRB_DUMP_ALIGNMENT            sizeof(uint32_t)
 69 | 
 70 | /* binary header */
 71 | struct rite_binary_header {
 72 |   uint8_t binary_ident[4];    /* Binary Identifier */
 73 |   uint8_t binary_version[4];  /* Binary Format Version */
 74 |   uint8_t binary_crc[2];      /* Binary CRC */
 75 |   uint8_t binary_size[4];     /* Binary Size */
 76 |   uint8_t compiler_name[4];   /* Compiler name */
 77 |   uint8_t compiler_version[4];
 78 | };
 79 | 
 80 | /* section header */
 81 | #define RITE_SECTION_HEADER \
 82 |   uint8_t section_ident[4]; \
 83 |   uint8_t section_size[4]
 84 | 
 85 | struct rite_section_header {
 86 |   RITE_SECTION_HEADER;
 87 | };
 88 | 
 89 | struct rite_section_irep_header {
 90 |   RITE_SECTION_HEADER;
 91 | 
 92 |   uint8_t rite_version[4];    /* Rite Instruction Specification Version */
 93 | };
 94 | 
 95 | struct rite_section_lineno_header {
 96 |   RITE_SECTION_HEADER;
 97 | };
 98 | 
 99 | struct rite_section_debug_header {
100 |   RITE_SECTION_HEADER;
101 | };
102 | 
103 | struct rite_section_lv_header {
104 |   RITE_SECTION_HEADER;
105 | };
106 | 
107 | #define RITE_LV_NULL_MARK              UINT16_MAX
108 | 
109 | struct rite_binary_footer {
110 |   RITE_SECTION_HEADER;
111 | };
112 | 
113 | static inline int
114 | bigendian_p()
115 | {
116 |   int i;
117 |   char *p;
118 | 
119 |   i = 1;
120 |   p = (char*)&i;
121 |   return p[0]?0:1;
122 | }
123 | 
124 | static inline size_t
125 | uint8_to_bin(uint8_t s, uint8_t *bin)
126 | {
127 |   *bin = s;
128 |   return sizeof(uint8_t);
129 | }
130 | 
131 | static inline size_t
132 | uint16_to_bin(uint16_t s, uint8_t *bin)
133 | {
134 |   *bin++ = (s >> 8) & 0xff;
135 |   *bin   = s & 0xff;
136 |   return sizeof(uint16_t);
137 | }
138 | 
139 | static inline size_t
140 | uint32_to_bin(uint32_t l, uint8_t *bin)
141 | {
142 |   *bin++ = (l >> 24) & 0xff;
143 |   *bin++ = (l >> 16) & 0xff;
144 |   *bin++ = (l >> 8) & 0xff;
145 |   *bin   = l & 0xff;
146 |   return sizeof(uint32_t);
147 | }
148 | 
149 | static inline size_t
150 | uint32l_to_bin(uint32_t l, uint8_t *bin)
151 | {
152 |   bin[3] = (l >> 24) & 0xff;
153 |   bin[2] = (l >> 16) & 0xff;
154 |   bin[1] = (l >> 8) & 0xff;
155 |   bin[0] = l & 0xff;
156 |   return sizeof(uint32_t);
157 | }
158 | 
159 | static inline uint32_t
160 | bin_to_uint32(const uint8_t *bin)
161 | {
162 |   return (uint32_t)bin[0] << 24 |
163 |          (uint32_t)bin[1] << 16 |
164 |          (uint32_t)bin[2] << 8  |
165 |          (uint32_t)bin[3];
166 | }
167 | 
168 | static inline uint32_t
169 | bin_to_uint32l(const uint8_t *bin)
170 | {
171 |   return (uint32_t)bin[3] << 24 |
172 |          (uint32_t)bin[2] << 16 |
173 |          (uint32_t)bin[1] << 8  |
174 |          (uint32_t)bin[0];
175 | }
176 | 
177 | static inline uint16_t
178 | bin_to_uint16(const uint8_t *bin)
179 | {
180 |   return (uint16_t)bin[0] << 8 |
181 |          (uint16_t)bin[1];
182 | }
183 | 
184 | static inline uint8_t
185 | bin_to_uint8(const uint8_t *bin)
186 | {
187 |   return (uint8_t)bin[0];
188 | }
189 | 
190 | MRB_END_DECL
191 | 
192 | /** @internal crc.c */
193 | uint16_t
194 | calc_crc_16_ccitt(const uint8_t *src, size_t nbytes, uint16_t crc);
195 | 
196 | #endif  /* MRUBY_DUMP_H */
197 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Headers/mruby/error.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** mruby/error.h - Exception class
 3 | **
 4 | ** See Copyright Notice in mruby.h
 5 | */
 6 | 
 7 | #ifndef MRUBY_ERROR_H
 8 | #define MRUBY_ERROR_H
 9 | 
10 | #include "common.h"
11 | 
12 | /**
13 |  * MRuby error handling.
14 |  */
15 | MRB_BEGIN_DECL
16 | 
17 | struct RException {
18 |   MRB_OBJECT_HEADER;
19 |   struct iv_tbl *iv;
20 | };
21 | 
22 | #define mrb_exc_ptr(v) ((struct RException*)mrb_ptr(v))
23 | 
24 | MRB_API void mrb_sys_fail(mrb_state *mrb, const char *mesg);
25 | MRB_API mrb_value mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str);
26 | #define mrb_exc_new_str_lit(mrb, c, lit) mrb_exc_new_str(mrb, c, mrb_str_new_lit(mrb, lit))
27 | MRB_API mrb_value mrb_make_exception(mrb_state *mrb, mrb_int argc, const mrb_value *argv);
28 | MRB_API mrb_value mrb_exc_backtrace(mrb_state *mrb, mrb_value exc);
29 | MRB_API mrb_value mrb_get_backtrace(mrb_state *mrb);
30 | MRB_API mrb_noreturn void mrb_no_method_error(mrb_state *mrb, mrb_sym id, mrb_value args, const char *fmt, ...);
31 | 
32 | /* declaration for fail method */
33 | MRB_API mrb_value mrb_f_raise(mrb_state*, mrb_value);
34 | 
35 | struct RBreak {
36 |   MRB_OBJECT_HEADER;
37 |   struct RProc *proc;
38 |   mrb_value val;
39 | };
40 | 
41 | /**
42 |  * Protect
43 |  *
44 |  * @mrbgem mruby-error
45 |  */
46 | MRB_API mrb_value mrb_protect(mrb_state *mrb, mrb_func_t body, mrb_value data, mrb_bool *state);
47 | 
48 | /**
49 |  * Ensure
50 |  *
51 |  * @mrbgem mruby-error
52 |  */
53 | MRB_API mrb_value mrb_ensure(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
54 |                              mrb_func_t ensure, mrb_value e_data);
55 | 
56 | /**
57 |  * Rescue
58 |  *
59 |  * @mrbgem mruby-error
60 |  */
61 | MRB_API mrb_value mrb_rescue(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
62 |                              mrb_func_t rescue, mrb_value r_data);
63 | 
64 | /**
65 |  * Rescue exception
66 |  *
67 |  * @mrbgem mruby-error
68 |  */
69 | MRB_API mrb_value mrb_rescue_exceptions(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
70 |                                         mrb_func_t rescue, mrb_value r_data,
71 |                                         mrb_int len, struct RClass **classes);
72 | 
73 | MRB_END_DECL
74 | 
75 | #endif  /* MRUBY_ERROR_H */
76 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Headers/mruby/gc.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** mruby/gc.h - garbage collector for mruby
 3 | **
 4 | ** See Copyright Notice in mruby.h
 5 | */
 6 | 
 7 | #ifndef MRUBY_GC_H
 8 | #define MRUBY_GC_H
 9 | 
10 | #include "common.h"
11 | 
12 | /**
13 |  * Uncommon memory management stuffs.
14 |  */
15 | MRB_BEGIN_DECL
16 | 
17 | 
18 | struct mrb_state;
19 | 
20 | #define MRB_EACH_OBJ_OK 0
21 | #define MRB_EACH_OBJ_BREAK 1
22 | typedef int (mrb_each_object_callback)(struct mrb_state *mrb, struct RBasic *obj, void *data);
23 | void mrb_objspace_each_objects(struct mrb_state *mrb, mrb_each_object_callback *callback, void *data);
24 | MRB_API void mrb_free_context(struct mrb_state *mrb, struct mrb_context *c);
25 | 
26 | #ifndef MRB_GC_ARENA_SIZE
27 | #define MRB_GC_ARENA_SIZE 100
28 | #endif
29 | 
30 | typedef enum {
31 |   MRB_GC_STATE_ROOT = 0,
32 |   MRB_GC_STATE_MARK,
33 |   MRB_GC_STATE_SWEEP
34 | } mrb_gc_state;
35 | 
36 | /* Disable MSVC warning "C4200: nonstandard extension used: zero-sized array
37 |  * in struct/union" when in C++ mode */
38 | #ifdef _MSC_VER
39 | #pragma warning(push)
40 | #pragma warning(disable : 4200)
41 | #endif
42 | 
43 | typedef struct mrb_heap_page {
44 |   struct RBasic *freelist;
45 |   struct mrb_heap_page *prev;
46 |   struct mrb_heap_page *next;
47 |   struct mrb_heap_page *free_next;
48 |   struct mrb_heap_page *free_prev;
49 |   mrb_bool old:1;
50 |   void *objects[];
51 | } mrb_heap_page;
52 | 
53 | #ifdef _MSC_VER
54 | #pragma warning(pop)
55 | #endif
56 | 
57 | typedef struct mrb_gc {
58 |   mrb_heap_page *heaps;                /* heaps for GC */
59 |   mrb_heap_page *sweeps;
60 |   mrb_heap_page *free_heaps;
61 |   size_t live; /* count of live objects */
62 | #ifdef MRB_GC_FIXED_ARENA
63 |   struct RBasic *arena[MRB_GC_ARENA_SIZE]; /* GC protection array */
64 | #else
65 |   struct RBasic **arena;                   /* GC protection array */
66 |   int arena_capa;
67 | #endif
68 |   int arena_idx;
69 | 
70 |   mrb_gc_state state; /* state of gc */
71 |   int current_white_part; /* make white object by white_part */
72 |   struct RBasic *gray_list; /* list of gray objects to be traversed incrementally */
73 |   struct RBasic *atomic_gray_list; /* list of objects to be traversed atomically */
74 |   size_t live_after_mark;
75 |   size_t threshold;
76 |   int interval_ratio;
77 |   int step_ratio;
78 |   mrb_bool iterating     :1;
79 |   mrb_bool disabled      :1;
80 |   mrb_bool full          :1;
81 |   mrb_bool generational  :1;
82 |   mrb_bool out_of_memory :1;
83 |   size_t majorgc_old_threshold;
84 | } mrb_gc;
85 | 
86 | MRB_API mrb_bool
87 | mrb_object_dead_p(struct mrb_state *mrb, struct RBasic *object);
88 | 
89 | MRB_END_DECL
90 | 
91 | #endif  /* MRUBY_GC_H */
92 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Headers/mruby/hash.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** mruby/hash.h - Hash class
  3 | **
  4 | ** See Copyright Notice in mruby.h
  5 | */
  6 | 
  7 | #ifndef MRUBY_HASH_H
  8 | #define MRUBY_HASH_H
  9 | 
 10 | #include "common.h"
 11 | #include <mruby/khash.h>
 12 | 
 13 | /**
 14 |  * Hash class
 15 |  */
 16 | MRB_BEGIN_DECL
 17 | 
 18 | struct RHash {
 19 |   MRB_OBJECT_HEADER;
 20 |   struct iv_tbl *iv;
 21 |   struct htable *ht;
 22 | };
 23 | 
 24 | #define mrb_hash_ptr(v)    ((struct RHash*)(mrb_ptr(v)))
 25 | #define mrb_hash_value(p)  mrb_obj_value((void*)(p))
 26 | 
 27 | MRB_API mrb_value mrb_hash_new_capa(mrb_state*, mrb_int);
 28 | MRB_API mrb_value mrb_ensure_hash_type(mrb_state *mrb, mrb_value hash);
 29 | MRB_API mrb_value mrb_check_hash_type(mrb_state *mrb, mrb_value hash);
 30 | 
 31 | /*
 32 |  * Initializes a new hash.
 33 |  *
 34 |  * Equivalent to:
 35 |  *
 36 |  *      Hash.new
 37 |  *
 38 |  * @param mrb The mruby state reference.
 39 |  * @return The initialized hash.
 40 |  */
 41 | MRB_API mrb_value mrb_hash_new(mrb_state *mrb);
 42 | 
 43 | /*
 44 |  * Sets a keys and values to hashes.
 45 |  *
 46 |  * Equivalent to:
 47 |  *
 48 |  *      hash[key] = val
 49 |  *
 50 |  * @param mrb The mruby state reference.
 51 |  * @param hash The target hash.
 52 |  * @param key The key to set.
 53 |  * @param val The value to set.
 54 |  * @return The value.
 55 |  */
 56 | MRB_API void mrb_hash_set(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value val);
 57 | 
 58 | /*
 59 |  * Gets a value from a key. If the key is not found, the default of the
 60 |  * hash is used.
 61 |  *
 62 |  * Equivalent to:
 63 |  *
 64 |  *     hash[key]
 65 |  *
 66 |  * @param mrb The mruby state reference.
 67 |  * @param hash The target hash.
 68 |  * @param key The key to get.
 69 |  * @return The found value.
 70 |  */
 71 | MRB_API mrb_value mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key);
 72 | 
 73 | /*
 74 |  * Gets a value from a key. If the key is not found, the default parameter is
 75 |  * used.
 76 |  *
 77 |  * Equivalent to:
 78 |  *
 79 |  *     hash.key?(key) ? hash[key] : def
 80 |  *
 81 |  * @param mrb The mruby state reference.
 82 |  * @param hash The target hash.
 83 |  * @param key The key to get.
 84 |  * @param def The default value.
 85 |  * @return The found value.
 86 |  */
 87 | MRB_API mrb_value mrb_hash_fetch(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value def);
 88 | 
 89 | /*
 90 |  * Deletes hash key and value pair.
 91 |  *
 92 |  * Equivalent to:
 93 |  *
 94 |  *     hash.delete(key)
 95 |  *
 96 |  * @param mrb The mruby state reference.
 97 |  * @param hash The target hash.
 98 |  * @param key The key to delete.
 99 |  * @return The deleted value.
100 |  */
101 | MRB_API mrb_value mrb_hash_delete_key(mrb_state *mrb, mrb_value hash, mrb_value key);
102 | 
103 | /*
104 |  * Gets an array of keys.
105 |  *
106 |  * Equivalent to:
107 |  *
108 |  *     hash.keys
109 |  *
110 |  * @param mrb The mruby state reference.
111 |  * @param hash The target hash.
112 |  * @return An array with the keys of the hash.
113 |  */
114 | MRB_API mrb_value mrb_hash_keys(mrb_state *mrb, mrb_value hash);
115 | /*
116 |  * Check if the hash has the key.
117 |  *
118 |  * Equivalent to:
119 |  *
120 |  *     hash.key?(key)
121 |  *
122 |  * @param mrb The mruby state reference.
123 |  * @param hash The target hash.
124 |  * @param key The key to check existence.
125 |  * @return True if the hash has the key
126 |  */
127 | MRB_API mrb_bool mrb_hash_key_p(mrb_state *mrb, mrb_value hash, mrb_value key);
128 | 
129 | /*
130 |  * Check if the hash is empty
131 |  *
132 |  * Equivalent to:
133 |  *
134 |  *     hash.empty?
135 |  *
136 |  * @param mrb The mruby state reference.
137 |  * @param self The target hash.
138 |  * @return True if the hash is empty, false otherwise.
139 |  */
140 | MRB_API mrb_bool mrb_hash_empty_p(mrb_state *mrb, mrb_value self);
141 | 
142 | /*
143 |  * Gets an array of values.
144 |  *
145 |  * Equivalent to:
146 |  *
147 |  *     hash.values
148 |  *
149 |  * @param mrb The mruby state reference.
150 |  * @param hash The target hash.
151 |  * @return An array with the values of the hash.
152 |  */
153 | MRB_API mrb_value mrb_hash_values(mrb_state *mrb, mrb_value hash);
154 | 
155 | /*
156 |  * Clears the hash.
157 |  *
158 |  * Equivalent to:
159 |  *
160 |  *     hash.clear
161 |  *
162 |  * @param mrb The mruby state reference.
163 |  * @param hash The target hash.
164 |  * @return The hash
165 |  */
166 | MRB_API mrb_value mrb_hash_clear(mrb_state *mrb, mrb_value hash);
167 | 
168 | /*
169 |  * Copies the hash.
170 |  *
171 |  *
172 |  * @param mrb The mruby state reference.
173 |  * @param hash The target hash.
174 |  * @return The copy of the hash
175 |  */
176 | MRB_API mrb_value mrb_hash_dup(mrb_state *mrb, mrb_value hash);
177 | 
178 | /*
179 |  * Merges two hashes. The first hash will be modified by the
180 |  * second hash.
181 |  *
182 |  * @param mrb The mruby state reference.
183 |  * @param hash1 The target hash.
184 |  * @param hash2 Updating hash
185 |  */
186 | MRB_API void mrb_hash_merge(mrb_state *mrb, mrb_value hash1, mrb_value hash2);
187 | 
188 | /* declaration of struct kh_ht */
189 | /* be careful when you touch the internal */
190 | typedef struct {
191 |   mrb_value v;
192 |   mrb_int n;
193 | } mrb_hash_value;
194 | 
195 | KHASH_DECLARE(ht, mrb_value, mrb_hash_value, TRUE)
196 | 
197 | /* RHASH_TBL allocates st_table if not available. */
198 | #define RHASH(obj)   ((struct RHash*)(mrb_ptr(obj)))
199 | #define RHASH_TBL(h)          (RHASH(h)->ht)
200 | #define RHASH_IFNONE(h)       mrb_iv_get(mrb, (h), mrb_intern_lit(mrb, "ifnone"))
201 | #define RHASH_PROCDEFAULT(h)  RHASH_IFNONE(h)
202 | 
203 | #define MRB_HASH_DEFAULT      1
204 | #define MRB_HASH_PROC_DEFAULT 2
205 | #define MRB_RHASH_DEFAULT_P(h) (RHASH(h)->flags & MRB_HASH_DEFAULT)
206 | #define MRB_RHASH_PROCDEFAULT_P(h) (RHASH(h)->flags & MRB_HASH_PROC_DEFAULT)
207 | 
208 | /* GC functions */
209 | void mrb_gc_mark_hash(mrb_state*, struct RHash*);
210 | size_t mrb_gc_mark_hash_size(mrb_state*, struct RHash*);
211 | void mrb_gc_free_hash(mrb_state*, struct RHash*);
212 | 
213 | MRB_END_DECL
214 | 
215 | #endif  /* MRUBY_HASH_H */
216 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Headers/mruby/irep.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** mruby/irep.h - mrb_irep structure
 3 | **
 4 | ** See Copyright Notice in mruby.h
 5 | */
 6 | 
 7 | #ifndef MRUBY_IREP_H
 8 | #define MRUBY_IREP_H
 9 | 
10 | #include "common.h"
11 | #include <mruby/compile.h>
12 | 
13 | /**
14 |  * Compiled mruby scripts.
15 |  */
16 | MRB_BEGIN_DECL
17 | 
18 | enum irep_pool_type {
19 |   IREP_TT_STRING,
20 |   IREP_TT_FIXNUM,
21 |   IREP_TT_FLOAT,
22 | };
23 | 
24 | struct mrb_locals {
25 |   mrb_sym name;
26 |   uint16_t r;
27 | };
28 | 
29 | /* Program data array struct */
30 | typedef struct mrb_irep {
31 |   uint16_t nlocals;        /* Number of local variables */
32 |   uint16_t nregs;          /* Number of register variables */
33 |   uint8_t flags;
34 | 
35 |   mrb_code *iseq;
36 |   mrb_value *pool;
37 |   mrb_sym *syms;
38 |   struct mrb_irep **reps;
39 | 
40 |   struct mrb_locals *lv;
41 |   /* debug info */
42 |   struct mrb_irep_debug_info* debug_info;
43 | 
44 |   uint16_t ilen, plen, slen, rlen;
45 |   uint32_t refcnt;
46 | } mrb_irep;
47 | 
48 | #define MRB_ISEQ_NO_FREE 1
49 | 
50 | MRB_API mrb_irep *mrb_add_irep(mrb_state *mrb);
51 | 
52 | /* @param [const uint8_t*] irep code, expected as a literal */
53 | MRB_API mrb_value mrb_load_irep(mrb_state*, const uint8_t*);
54 | 
55 | /* @param [const uint8_t*] irep code, expected as a literal */
56 | MRB_API mrb_value mrb_load_irep_cxt(mrb_state*, const uint8_t*, mrbc_context*);
57 | 
58 | void mrb_irep_free(mrb_state*, struct mrb_irep*);
59 | void mrb_irep_incref(mrb_state*, struct mrb_irep*);
60 | void mrb_irep_decref(mrb_state*, struct mrb_irep*);
61 | void mrb_irep_cutref(mrb_state*, struct mrb_irep*);
62 | void mrb_irep_remove_lv(mrb_state *mrb, mrb_irep *irep);
63 | 
64 | struct mrb_insn_data {
65 |   uint8_t insn;
66 |   uint16_t a;
67 |   uint16_t b;
68 |   uint8_t c;
69 | };
70 | 
71 | struct mrb_insn_data mrb_decode_insn(mrb_code *pc);
72 | 
73 | MRB_END_DECL
74 | 
75 | #endif  /* MRUBY_IREP_H */
76 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Headers/mruby/istruct.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** mruby/istruct.h - Inline structures
 3 | **
 4 | ** See Copyright Notice in mruby.h
 5 | */
 6 | 
 7 | #ifndef MRUBY_ISTRUCT_H
 8 | #define MRUBY_ISTRUCT_H
 9 | 
10 | #include "common.h"
11 | #include <string.h>
12 | 
13 | /**
14 |  * Inline structures that fit in RVALUE
15 |  *
16 |  * They cannot have finalizer, and cannot have instance variables.
17 |  */
18 | MRB_BEGIN_DECL
19 | 
20 | #define ISTRUCT_DATA_SIZE (sizeof(void*) * 3)
21 | 
22 | struct RIstruct {
23 |   MRB_OBJECT_HEADER;
24 |   char inline_data[ISTRUCT_DATA_SIZE];
25 | };
26 | 
27 | #define RISTRUCT(obj)         ((struct RIstruct*)(mrb_ptr(obj)))
28 | #define ISTRUCT_PTR(obj)      (RISTRUCT(obj)->inline_data)
29 | 
30 | MRB_INLINE mrb_int mrb_istruct_size()
31 | {
32 |   return ISTRUCT_DATA_SIZE;
33 | }
34 | 
35 | MRB_INLINE void* mrb_istruct_ptr(mrb_value object)
36 | {
37 |   return ISTRUCT_PTR(object);
38 | }
39 | 
40 | MRB_INLINE void mrb_istruct_copy(mrb_value dest, mrb_value src)
41 | {
42 |   memcpy(ISTRUCT_PTR(dest), ISTRUCT_PTR(src), ISTRUCT_DATA_SIZE);
43 | }
44 | 
45 | MRB_END_DECL
46 | 
47 | #endif /* MRUBY_ISTRUCT_H */
48 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Headers/mruby/numeric.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** mruby/numeric.h - Numeric, Integer, Float, Fixnum class
  3 | **
  4 | ** See Copyright Notice in mruby.h
  5 | */
  6 | 
  7 | #ifndef MRUBY_NUMERIC_H
  8 | #define MRUBY_NUMERIC_H
  9 | 
 10 | #include "common.h"
 11 | 
 12 | /**
 13 |  * Numeric class and it's sub-classes.
 14 |  *
 15 |  * Integer, Float and Fixnum
 16 |  */
 17 | MRB_BEGIN_DECL
 18 | 
 19 | #define TYPED_POSFIXABLE(f,t) ((f) <= (t)MRB_INT_MAX)
 20 | #define TYPED_NEGFIXABLE(f,t) ((f) >= (t)MRB_INT_MIN)
 21 | #define TYPED_FIXABLE(f,t) (TYPED_POSFIXABLE(f,t) && TYPED_NEGFIXABLE(f,t))
 22 | #define POSFIXABLE(f) TYPED_POSFIXABLE(f,mrb_int)
 23 | #define NEGFIXABLE(f) TYPED_NEGFIXABLE(f,mrb_int)
 24 | #define FIXABLE(f) TYPED_FIXABLE(f,mrb_int)
 25 | #ifndef MRB_WITHOUT_FLOAT
 26 | #define FIXABLE_FLOAT(f) TYPED_FIXABLE(f,double)
 27 | #endif
 28 | 
 29 | #ifndef MRB_WITHOUT_FLOAT
 30 | MRB_API mrb_value mrb_flo_to_fixnum(mrb_state *mrb, mrb_value val);
 31 | #endif
 32 | MRB_API mrb_value mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, mrb_int base);
 33 | /* ArgumentError if format string doesn't match /%(\.[0-9]+)?[aAeEfFgG]/ */
 34 | #ifndef MRB_WITHOUT_FLOAT
 35 | MRB_API mrb_value mrb_float_to_str(mrb_state *mrb, mrb_value x, const char *fmt);
 36 | MRB_API mrb_float mrb_to_flo(mrb_state *mrb, mrb_value x);
 37 | #endif
 38 | 
 39 | mrb_value mrb_fixnum_plus(mrb_state *mrb, mrb_value x, mrb_value y);
 40 | mrb_value mrb_fixnum_minus(mrb_state *mrb, mrb_value x, mrb_value y);
 41 | mrb_value mrb_fixnum_mul(mrb_state *mrb, mrb_value x, mrb_value y);
 42 | mrb_value mrb_num_div(mrb_state *mrb, mrb_value x, mrb_value y);
 43 | 
 44 | #ifndef __has_builtin
 45 |   #define __has_builtin(x) 0
 46 | #endif
 47 | 
 48 | #if (defined(__GNUC__) && __GNUC__ >= 5) ||   \
 49 |     (__has_builtin(__builtin_add_overflow) && \
 50 |      __has_builtin(__builtin_sub_overflow) && \
 51 |      __has_builtin(__builtin_mul_overflow))
 52 | # define MRB_HAVE_TYPE_GENERIC_CHECKED_ARITHMETIC_BUILTINS
 53 | #endif
 54 | 
 55 | /*
 56 | // Clang 3.8 and 3.9 have problem compiling mruby in 32-bit mode, when MRB_INT64 is set
 57 | // because of missing __mulodi4 and similar functions in its runtime. We need to use custom
 58 | // implementation for them.
 59 | */
 60 | #ifdef MRB_HAVE_TYPE_GENERIC_CHECKED_ARITHMETIC_BUILTINS
 61 | #if defined(__clang__) && (__clang_major__ == 3) && (__clang_minor__ >= 8) && \
 62 |     defined(MRB_32BIT) && defined(MRB_INT64)
 63 | #undef MRB_HAVE_TYPE_GENERIC_CHECKED_ARITHMETIC_BUILTINS
 64 | #endif
 65 | #endif
 66 | 
 67 | #ifdef MRB_HAVE_TYPE_GENERIC_CHECKED_ARITHMETIC_BUILTINS
 68 | 
 69 | #ifndef MRB_WORD_BOXING
 70 | # define WBCHK(x) 0
 71 | #else
 72 | # define WBCHK(x) !FIXABLE(x)
 73 | #endif
 74 | 
 75 | static inline mrb_bool
 76 | mrb_int_add_overflow(mrb_int augend, mrb_int addend, mrb_int *sum)
 77 | {
 78 |   return __builtin_add_overflow(augend, addend, sum) || WBCHK(*sum);
 79 | }
 80 | 
 81 | static inline mrb_bool
 82 | mrb_int_sub_overflow(mrb_int minuend, mrb_int subtrahend, mrb_int *difference)
 83 | {
 84 |   return __builtin_sub_overflow(minuend, subtrahend, difference) || WBCHK(*difference);
 85 | }
 86 | 
 87 | static inline mrb_bool
 88 | mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product)
 89 | {
 90 |   return __builtin_mul_overflow(multiplier, multiplicand, product) || WBCHK(*product);
 91 | }
 92 | 
 93 | #undef WBCHK
 94 | 
 95 | #else
 96 | 
 97 | #define MRB_UINT_MAKE2(n) uint ## n ## _t
 98 | #define MRB_UINT_MAKE(n) MRB_UINT_MAKE2(n)
 99 | #define mrb_uint MRB_UINT_MAKE(MRB_INT_BIT)
100 | 
101 | #define MRB_INT_OVERFLOW_MASK ((mrb_uint)1 << (MRB_INT_BIT - 1 - MRB_FIXNUM_SHIFT))
102 | 
103 | static inline mrb_bool
104 | mrb_int_add_overflow(mrb_int augend, mrb_int addend, mrb_int *sum)
105 | {
106 |   mrb_uint x = (mrb_uint)augend;
107 |   mrb_uint y = (mrb_uint)addend;
108 |   mrb_uint z = (mrb_uint)(x + y);
109 |   *sum = (mrb_int)z;
110 |   return !!(((x ^ z) & (y ^ z)) & MRB_INT_OVERFLOW_MASK);
111 | }
112 | 
113 | static inline mrb_bool
114 | mrb_int_sub_overflow(mrb_int minuend, mrb_int subtrahend, mrb_int *difference)
115 | {
116 |   mrb_uint x = (mrb_uint)minuend;
117 |   mrb_uint y = (mrb_uint)subtrahend;
118 |   mrb_uint z = (mrb_uint)(x - y);
119 |   *difference = (mrb_int)z;
120 |   return !!(((x ^ z) & (~y ^ z)) & MRB_INT_OVERFLOW_MASK);
121 | }
122 | 
123 | static inline mrb_bool
124 | mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product)
125 | {
126 | #if MRB_INT_BIT == 32
127 |   int64_t n = (int64_t)multiplier * multiplicand;
128 |   *product = (mrb_int)n;
129 |   return !FIXABLE(n);
130 | #else
131 |   if (multiplier > 0) {
132 |     if (multiplicand > 0) {
133 |       if (multiplier > MRB_INT_MAX / multiplicand) return TRUE;
134 |     }
135 |     else {
136 |       if (multiplicand < MRB_INT_MAX / multiplier) return TRUE;
137 |     }
138 |   }
139 |   else {
140 |     if (multiplicand > 0) {
141 |       if (multiplier < MRB_INT_MAX / multiplicand) return TRUE;
142 |     }
143 |     else {
144 |       if (multiplier != 0 && multiplicand < MRB_INT_MAX / multiplier) return TRUE;
145 |     }
146 |   }
147 |   *product = multiplier * multiplicand;
148 |   return FALSE;
149 | #endif
150 | }
151 | 
152 | #undef MRB_INT_OVERFLOW_MASK
153 | #undef mrb_uint
154 | #undef MRB_UINT_MAKE
155 | #undef MRB_UINT_MAKE2
156 | 
157 | #endif
158 | 
159 | MRB_END_DECL
160 | 
161 | #endif  /* MRUBY_NUMERIC_H */
162 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Headers/mruby/object.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** mruby/object.h - mruby object definition
 3 | **
 4 | ** See Copyright Notice in mruby.h
 5 | */
 6 | 
 7 | #ifndef MRUBY_OBJECT_H
 8 | #define MRUBY_OBJECT_H
 9 | 
10 | #define MRB_OBJECT_HEADER \
11 |   enum mrb_vtype tt:8;\
12 |   uint32_t color:3;\
13 |   uint32_t flags:21;\
14 |   struct RClass *c;\
15 |   struct RBasic *gcnext
16 | 
17 | #define MRB_FLAG_TEST(obj, flag) ((obj)->flags & flag)
18 | 
19 | 
20 | struct RBasic {
21 |   MRB_OBJECT_HEADER;
22 | };
23 | #define mrb_basic_ptr(v) ((struct RBasic*)(mrb_ptr(v)))
24 | 
25 | #define MRB_FL_OBJ_IS_FROZEN (1 << 20)
26 | #define MRB_FROZEN_P(o) ((o)->flags & MRB_FL_OBJ_IS_FROZEN)
27 | #define MRB_SET_FROZEN_FLAG(o) ((o)->flags |= MRB_FL_OBJ_IS_FROZEN)
28 | #define MRB_UNSET_FROZEN_FLAG(o) ((o)->flags &= ~MRB_FL_OBJ_IS_FROZEN)
29 | 
30 | struct RObject {
31 |   MRB_OBJECT_HEADER;
32 |   struct iv_tbl *iv;
33 | };
34 | #define mrb_obj_ptr(v)   ((struct RObject*)(mrb_ptr(v)))
35 | 
36 | #define mrb_immediate_p(x) (mrb_type(x) < MRB_TT_HAS_BASIC)
37 | #define mrb_special_const_p(x) mrb_immediate_p(x)
38 | 
39 | struct RFiber {
40 |   MRB_OBJECT_HEADER;
41 |   struct mrb_context *cxt;
42 | };
43 | 
44 | #endif  /* MRUBY_OBJECT_H */
45 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Headers/mruby/opcode.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** mruby/opcode.h - RiteVM operation codes
 3 | **
 4 | ** See Copyright Notice in mruby.h
 5 | */
 6 | 
 7 | #ifndef MRUBY_OPCODE_H
 8 | #define MRUBY_OPCODE_H
 9 | 
10 | enum mrb_insn {
11 | #define OPCODE(x,_) OP_ ## x,
12 | #include "mruby/ops.h"
13 | #undef OPCODE
14 | };
15 | 
16 | #define OP_L_STRICT  1
17 | #define OP_L_CAPTURE 2
18 | #define OP_L_METHOD  OP_L_STRICT
19 | #define OP_L_LAMBDA  (OP_L_STRICT|OP_L_CAPTURE)
20 | #define OP_L_BLOCK   OP_L_CAPTURE
21 | 
22 | #define OP_R_NORMAL 0
23 | #define OP_R_BREAK  1
24 | #define OP_R_RETURN 2
25 | 
26 | #define PEEK_B(pc) (*(pc))
27 | #define PEEK_S(pc) ((pc)[0]<<8|(pc)[1])
28 | #define PEEK_W(pc) ((pc)[0]<<16|(pc)[1]<<8|(pc)[2])
29 | 
30 | #define READ_B() PEEK_B(pc++)
31 | #define READ_S() (pc+=2, PEEK_S(pc-2))
32 | #define READ_W() (pc+=3, PEEK_W(pc-3))
33 | 
34 | #define FETCH_Z() /* nothing */
35 | #define FETCH_B() do {a=READ_B();} while (0)
36 | #define FETCH_BB() do {a=READ_B(); b=READ_B();} while (0)
37 | #define FETCH_BBB() do {a=READ_B(); b=READ_B(); c=READ_B();} while (0)
38 | #define FETCH_BS() do {a=READ_B(); b=READ_S();} while (0)
39 | #define FETCH_S() do {a=READ_S();} while (0)
40 | #define FETCH_W() do {a=READ_W();} while (0)
41 | 
42 | /* with OP_EXT1 (1st 16bit) */
43 | #define FETCH_Z_1() FETCH_Z()
44 | #define FETCH_B_1() FETCH_S()
45 | #define FETCH_BB_1() do {a=READ_S(); b=READ_B();} while (0)
46 | #define FETCH_BBB_1() do {a=READ_S(); b=READ_B(); c=READ_B();} while (0)
47 | #define FETCH_BS_1() do {a=READ_S(); b=READ_S();} while (0)
48 | #define FETCH_S_1() FETCH_S()
49 | #define FETCH_W_1() FETCH_W()
50 | 
51 | /* with OP_EXT2 (2nd 16bit) */
52 | #define FETCH_Z_2() FETCH_Z()
53 | #define FETCH_B_2() FETCH_B()
54 | #define FETCH_BB_2() do {a=READ_B(); b=READ_S();} while (0)
55 | #define FETCH_BBB_2() do {a=READ_B(); b=READ_S(); c=READ_B();} while (0)
56 | #define FETCH_BS_2() FETCH_BS()
57 | #define FETCH_S_2() FETCH_S()
58 | #define FETCH_W_2() FETCH_W()
59 | 
60 | /* with OP_EXT3 (1st & 2nd 16bit) */
61 | #define FETCH_Z_3() FETCH_Z()
62 | #define FETCH_B_3() FETCH_B()
63 | #define FETCH_BB_3() do {a=READ_S(); b=READ_S();} while (0)
64 | #define FETCH_BBB_3() do {a=READ_S(); b=READ_S(); c=READ_B();} while (0)
65 | #define FETCH_BS_3() do {a=READ_S(); b=READ_S();} while (0)
66 | #define FETCH_S_3() FETCH_S()
67 | #define FETCH_W_3() FETCH_W()
68 | 
69 | #endif  /* MRUBY_OPCODE_H */
70 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Headers/mruby/ops.h:
--------------------------------------------------------------------------------
  1 | /* operand types:
  2 |    + Z: no operand (Z,Z,Z,Z)
  3 |    + B: 8bit (B,S,B,B)
  4 |    + BB: 8+8bit (BB,SB,BS,SS)
  5 |    + BBB: 8+8+8bit (BBB,SBB,BSB,SSB)
  6 |    + BS: 8+16bit (BS,SS,BS,BS)
  7 |    + S: 16bit (S,S,S,S)
  8 |    + W: 24bit (W,W,W,W)
  9 | */
 10 | 
 11 | /*-----------------------------------------------------------------------
 12 | operation code    operands      semantics
 13 | ------------------------------------------------------------------------*/
 14 | OPCODE(NOP,        Z)        /* no operation */
 15 | OPCODE(MOVE,       BB)       /* R(a) = R(b) */
 16 | OPCODE(LOADL,      BB)       /* R(a) = Pool(b) */
 17 | OPCODE(LOADI,      BB)       /* R(a) = mrb_int(b) */
 18 | OPCODE(LOADINEG,   BB)       /* R(a) = mrb_int(-b) */
 19 | OPCODE(LOADI__1,   B)        /* R(a) = mrb_int(-1) */
 20 | OPCODE(LOADI_0,    B)        /* R(a) = mrb_int(0) */
 21 | OPCODE(LOADI_1,    B)        /* R(a) = mrb_int(1) */
 22 | OPCODE(LOADI_2,    B)        /* R(a) = mrb_int(2) */
 23 | OPCODE(LOADI_3,    B)        /* R(a) = mrb_int(3) */
 24 | OPCODE(LOADI_4,    B)        /* R(a) = mrb_int(4) */
 25 | OPCODE(LOADI_5,    B)        /* R(a) = mrb_int(5) */
 26 | OPCODE(LOADI_6,    B)        /* R(a) = mrb_int(6) */
 27 | OPCODE(LOADI_7,    B)        /* R(a) = mrb_int(7) */
 28 | OPCODE(LOADSYM,    BB)       /* R(a) = Syms(b) */
 29 | OPCODE(LOADNIL,    B)        /* R(a) = nil */
 30 | OPCODE(LOADSELF,   B)        /* R(a) = self */
 31 | OPCODE(LOADT,      B)        /* R(a) = true */
 32 | OPCODE(LOADF,      B)        /* R(a) = false */
 33 | OPCODE(GETGV,      BB)       /* R(a) = getglobal(Syms(b)) */
 34 | OPCODE(SETGV,      BB)       /* setglobal(Syms(b), R(a)) */
 35 | OPCODE(GETSV,      BB)       /* R(a) = Special[Syms(b)] */
 36 | OPCODE(SETSV,      BB)       /* Special[Syms(b)] = R(a) */
 37 | OPCODE(GETIV,      BB)       /* R(a) = ivget(Syms(b)) */
 38 | OPCODE(SETIV,      BB)       /* ivset(Syms(b),R(a)) */
 39 | OPCODE(GETCV,      BB)       /* R(a) = cvget(Syms(b)) */
 40 | OPCODE(SETCV,      BB)       /* cvset(Syms(b),R(a)) */
 41 | OPCODE(GETCONST,   BB)       /* R(a) = constget(Syms(b)) */
 42 | OPCODE(SETCONST,   BB)       /* constset(Syms(b),R(a)) */
 43 | OPCODE(GETMCNST,   BB)       /* R(a) = R(a)::Syms(b) */
 44 | OPCODE(SETMCNST,   BB)       /* R(a+1)::Syms(b) = R(a) */
 45 | OPCODE(GETUPVAR,   BBB)      /* R(a) = uvget(b,c) */
 46 | OPCODE(SETUPVAR,   BBB)      /* uvset(b,c,R(a)) */
 47 | OPCODE(JMP,        S)        /* pc=a */
 48 | OPCODE(JMPIF,      BS)       /* if R(b) pc=a */
 49 | OPCODE(JMPNOT,     BS)       /* if !R(b) pc=a */
 50 | OPCODE(JMPNIL,     BS)       /* if R(b)==nil pc=a */
 51 | OPCODE(ONERR,      S)        /* rescue_push(a) */
 52 | OPCODE(EXCEPT,     B)        /* R(a) = exc */
 53 | OPCODE(RESCUE,     BB)       /* R(b) = R(a).isa?(R(b)) */
 54 | OPCODE(POPERR,     B)        /* a.times{rescue_pop()} */
 55 | OPCODE(RAISE,      B)        /* raise(R(a)) */
 56 | OPCODE(EPUSH,      B)        /* ensure_push(SEQ[a]) */
 57 | OPCODE(EPOP,       B)        /* A.times{ensure_pop().call} */
 58 | OPCODE(SENDV,      BB)       /* R(a) = call(R(a),Syms(b),*R(a+1)) */
 59 | OPCODE(SENDVB,     BB)       /* R(a) = call(R(a),Syms(b),*R(a+1),&R(a+2)) */
 60 | OPCODE(SEND,       BBB)      /* R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c)) */
 61 | OPCODE(SENDB,      BBB)      /* R(a) = call(R(a),Syms(Bx),R(a+1),...,R(a+c),&R(a+c+1)) */
 62 | OPCODE(CALL,       Z)        /* R(0) = self.call(frame.argc, frame.argv) */
 63 | OPCODE(SUPER,      BB)       /* R(a) = super(R(a+1),... ,R(a+b+1)) */
 64 | OPCODE(ARGARY,     BS)       /* R(a) = argument array (16=m5:r1:m5:d1:lv4) */
 65 | OPCODE(ENTER,      W)        /* arg setup according to flags (23=m5:o5:r1:m5:k5:d1:b1) */
 66 | OPCODE(KEY_P,      BB)       /* R(a) = kdict.key?(Syms(b))                      # todo */
 67 | OPCODE(KEYEND,     Z)        /* raise unless kdict.empty?                       # todo */
 68 | OPCODE(KARG,       BB)       /* R(a) = kdict[Syms(b)]; kdict.delete(Syms(b))    # todo */
 69 | OPCODE(RETURN,     B)        /* return R(a) (normal) */
 70 | OPCODE(RETURN_BLK, B)        /* return R(a) (in-block return) */
 71 | OPCODE(BREAK,      B)        /* break R(a) */
 72 | OPCODE(BLKPUSH,    BS)       /* R(a) = block (16=m5:r1:m5:d1:lv4) */
 73 | OPCODE(ADD,        B)        /* R(a) = R(a)+R(a+1) */
 74 | OPCODE(ADDI,       BB)       /* R(a) = R(a)+mrb_int(c)  */
 75 | OPCODE(SUB,        B)        /* R(a) = R(a)-R(a+1) */
 76 | OPCODE(SUBI,       BB)       /* R(a) = R(a)-C */
 77 | OPCODE(MUL,        B)        /* R(a) = R(a)*R(a+1) */
 78 | OPCODE(DIV,        B)        /* R(a) = R(a)/R(a+1) */
 79 | OPCODE(EQ,         B)        /* R(a) = R(a)==R(a+1) */
 80 | OPCODE(LT,         B)        /* R(a) = R(a)<R(a+1) */
 81 | OPCODE(LE,         B)        /* R(a) = R(a)<=R(a+1) */
 82 | OPCODE(GT,         B)        /* R(a) = R(a)>R(a+1) */
 83 | OPCODE(GE,         B)        /* R(a) = R(a)>=R(a+1) */
 84 | OPCODE(ARRAY,      BB)       /* R(a) = ary_new(R(a),R(a+1)..R(a+b)) */
 85 | OPCODE(ARRAY2,     BBB)      /* R(a) = ary_new(R(b),R(b+1)..R(b+c)) */
 86 | OPCODE(ARYCAT,     B)        /* ary_cat(R(a),R(a+1)) */
 87 | OPCODE(ARYPUSH,    B)        /* ary_push(R(a),R(a+1)) */
 88 | OPCODE(ARYDUP,     B)        /* R(a) = ary_dup(R(a)) */
 89 | OPCODE(AREF,       BBB)      /* R(a) = R(b)[c] */
 90 | OPCODE(ASET,       BBB)      /* R(a)[c] = R(b) */
 91 | OPCODE(APOST,      BBB)      /* *R(a),R(a+1)..R(a+C) = R(a)[b..] */
 92 | OPCODE(INTERN,     B)        /* R(a) = intern(R(a)) */
 93 | OPCODE(STRING,     BB)       /* R(a) = str_dup(Lit(b)) */
 94 | OPCODE(STRCAT,     B)        /* str_cat(R(a),R(a+1)) */
 95 | OPCODE(HASH,       BB)       /* R(a) = hash_new(R(a),R(a+1)..R(a+b)) */
 96 | OPCODE(HASHADD,    BB)       /* R(a) = hash_push(R(a),R(a+1)..R(a+b)) */
 97 | OPCODE(HASHCAT,    B)        /* R(a) = hash_cat(R(a),R(a+1)) */
 98 | OPCODE(LAMBDA,     BB)       /* R(a) = lambda(SEQ[b],L_LAMBDA) */
 99 | OPCODE(BLOCK,      BB)       /* R(a) = lambda(SEQ[b],L_BLOCK) */
100 | OPCODE(METHOD,     BB)       /* R(a) = lambda(SEQ[b],L_METHOD) */
101 | OPCODE(RANGE_INC,  B)        /* R(a) = range_new(R(a),R(a+1),FALSE) */
102 | OPCODE(RANGE_EXC,  B)        /* R(a) = range_new(R(a),R(a+1),TRUE) */
103 | OPCODE(OCLASS,     B)        /* R(a) = ::Object */
104 | OPCODE(CLASS,      BB)       /* R(a) = newclass(R(a),Syms(b),R(a+1)) */
105 | OPCODE(MODULE,     BB)       /* R(a) = newmodule(R(a),Syms(b)) */
106 | OPCODE(EXEC,       BB)       /* R(a) = blockexec(R(a),SEQ[b]) */
107 | OPCODE(DEF,        BB)       /* R(a).newmethod(Syms(b),R(a+1)) */
108 | OPCODE(ALIAS,      BB)       /* alias_method(target_class,Syms(a),Syms(b)) */
109 | OPCODE(UNDEF,      B)        /* undef_method(target_class,Syms(a)) */
110 | OPCODE(SCLASS,     B)        /* R(a) = R(a).singleton_class */
111 | OPCODE(TCLASS,     B)        /* R(a) = target_class */
112 | OPCODE(DEBUG,      BBB)      /* print a,b,c */
113 | OPCODE(ERR,        B)        /* raise(LocalJumpError, Lit(a)) */
114 | OPCODE(EXT1,       Z)        /* make 1st operand 16bit */
115 | OPCODE(EXT2,       Z)        /* make 2nd operand 16bit */
116 | OPCODE(EXT3,       Z)        /* make 1st and 2nd operands 16bit */
117 | OPCODE(STOP,       Z)        /* stop VM */
118 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Headers/mruby/proc.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** mruby/proc.h - Proc class
  3 | **
  4 | ** See Copyright Notice in mruby.h
  5 | */
  6 | 
  7 | #ifndef MRUBY_PROC_H
  8 | #define MRUBY_PROC_H
  9 | 
 10 | #include "common.h"
 11 | #include <mruby/irep.h>
 12 | 
 13 | /**
 14 |  * Proc class
 15 |  */
 16 | MRB_BEGIN_DECL
 17 | 
 18 | struct REnv {
 19 |   MRB_OBJECT_HEADER;
 20 |   mrb_value *stack;
 21 |   struct mrb_context *cxt;
 22 |   mrb_sym mid;
 23 | };
 24 | 
 25 | /* flags (21bits): 1(shared flag):10(cioff/bidx):10(stack_len) */
 26 | #define MRB_ENV_SET_STACK_LEN(e,len) (e)->flags = (((e)->flags & ~0x3ff)|((unsigned int)(len) & 0x3ff))
 27 | #define MRB_ENV_STACK_LEN(e) ((mrb_int)((e)->flags & 0x3ff))
 28 | #define MRB_ENV_STACK_UNSHARED (1<<20)
 29 | #define MRB_ENV_UNSHARE_STACK(e) (e)->flags |= MRB_ENV_STACK_UNSHARED
 30 | #define MRB_ENV_STACK_SHARED_P(e) (((e)->flags & MRB_ENV_STACK_UNSHARED) == 0)
 31 | #define MRB_ENV_BIDX(e) (((e)->flags >> 10) & 0x3ff)
 32 | #define MRB_ENV_SET_BIDX(e,idx) (e)->flags = (((e)->flags & ~(0x3ff<<10))|((unsigned int)(idx) & 0x3ff)<<10)
 33 | 
 34 | void mrb_env_unshare(mrb_state*, struct REnv*);
 35 | 
 36 | struct RProc {
 37 |   MRB_OBJECT_HEADER;
 38 |   union {
 39 |     mrb_irep *irep;
 40 |     mrb_func_t func;
 41 |   } body;
 42 |   struct RProc *upper;
 43 |   union {
 44 |     struct RClass *target_class;
 45 |     struct REnv *env;
 46 |   } e;
 47 | };
 48 | 
 49 | /* aspec access */
 50 | #define MRB_ASPEC_REQ(a)          (((a) >> 18) & 0x1f)
 51 | #define MRB_ASPEC_OPT(a)          (((a) >> 13) & 0x1f)
 52 | #define MRB_ASPEC_REST(a)         (((a) >> 12) & 0x1)
 53 | #define MRB_ASPEC_POST(a)         (((a) >> 7) & 0x1f)
 54 | #define MRB_ASPEC_KEY(a)          (((a) >> 2) & 0x1f)
 55 | #define MRB_ASPEC_KDICT(a)        ((a) & (1<<1))
 56 | #define MRB_ASPEC_BLOCK(a)        ((a) & 1)
 57 | 
 58 | #define MRB_PROC_CFUNC_FL 128
 59 | #define MRB_PROC_CFUNC_P(p) (((p)->flags & MRB_PROC_CFUNC_FL) != 0)
 60 | #define MRB_PROC_CFUNC(p) (p)->body.func
 61 | #define MRB_PROC_STRICT 256
 62 | #define MRB_PROC_STRICT_P(p) (((p)->flags & MRB_PROC_STRICT) != 0)
 63 | #define MRB_PROC_ORPHAN 512
 64 | #define MRB_PROC_ORPHAN_P(p) (((p)->flags & MRB_PROC_ORPHAN) != 0)
 65 | #define MRB_PROC_ENVSET 1024
 66 | #define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
 67 | #define MRB_PROC_ENV(p) (MRB_PROC_ENV_P(p) ? (p)->e.env : NULL)
 68 | #define MRB_PROC_TARGET_CLASS(p) (MRB_PROC_ENV_P(p) ? (p)->e.env->c : (p)->e.target_class)
 69 | #define MRB_PROC_SET_TARGET_CLASS(p,tc) do {\
 70 |   if (MRB_PROC_ENV_P(p)) {\
 71 |     (p)->e.env->c = (tc);\
 72 |     mrb_field_write_barrier(mrb, (struct RBasic*)(p)->e.env, (struct RBasic*)tc);\
 73 |   }\
 74 |   else {\
 75 |     (p)->e.target_class = (tc);\
 76 |     mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)tc);\
 77 |   }\
 78 | } while (0)
 79 | #define MRB_PROC_SCOPE 2048
 80 | #define MRB_PROC_SCOPE_P(p) (((p)->flags & MRB_PROC_SCOPE) != 0)
 81 | 
 82 | #define mrb_proc_ptr(v)    ((struct RProc*)(mrb_ptr(v)))
 83 | 
 84 | struct RProc *mrb_proc_new(mrb_state*, mrb_irep*);
 85 | struct RProc *mrb_closure_new(mrb_state*, mrb_irep*);
 86 | MRB_API struct RProc *mrb_proc_new_cfunc(mrb_state*, mrb_func_t);
 87 | MRB_API struct RProc *mrb_closure_new_cfunc(mrb_state *mrb, mrb_func_t func, int nlocals);
 88 | void mrb_proc_copy(struct RProc *a, struct RProc *b);
 89 | 
 90 | /* implementation of #send method */
 91 | mrb_value mrb_f_send(mrb_state *mrb, mrb_value self);
 92 | 
 93 | /* following functions are defined in mruby-proc-ext so please include it when using */
 94 | MRB_API struct RProc *mrb_proc_new_cfunc_with_env(mrb_state*, mrb_func_t, mrb_int, const mrb_value*);
 95 | MRB_API mrb_value mrb_proc_cfunc_env_get(mrb_state*, mrb_int);
 96 | /* old name */
 97 | #define mrb_cfunc_env_get(mrb, idx) mrb_proc_cfunc_env_get(mrb, idx)
 98 | 
 99 | #ifdef MRB_METHOD_TABLE_INLINE
100 | 
101 | #define MRB_METHOD_FUNC_FL ((uintptr_t)1)
102 | #define MRB_METHOD_FUNC_P(m) (((uintptr_t)(m))&MRB_METHOD_FUNC_FL)
103 | #define MRB_METHOD_FUNC(m) ((mrb_func_t)((uintptr_t)(m)&(~MRB_METHOD_FUNC_FL)))
104 | #define MRB_METHOD_FROM_FUNC(m,fn) m=(mrb_method_t)((struct RProc*)((uintptr_t)(fn)|MRB_METHOD_FUNC_FL))
105 | #define MRB_METHOD_FROM_PROC(m,pr) m=(mrb_method_t)(struct RProc*)(pr)
106 | #define MRB_METHOD_PROC_P(m) (!MRB_METHOD_FUNC_P(m))
107 | #define MRB_METHOD_PROC(m) ((struct RProc*)(m))
108 | #define MRB_METHOD_UNDEF_P(m) ((m)==0)
109 | 
110 | #else
111 | 
112 | #define MRB_METHOD_FUNC_P(m) ((m).func_p)
113 | #define MRB_METHOD_FUNC(m) ((m).func)
114 | #define MRB_METHOD_FROM_FUNC(m,fn) do{(m).func_p=TRUE;(m).func=(fn);}while(0)
115 | #define MRB_METHOD_FROM_PROC(m,pr) do{(m).func_p=FALSE;(m).proc=(pr);}while(0)
116 | #define MRB_METHOD_PROC_P(m) (!MRB_METHOD_FUNC_P(m))
117 | #define MRB_METHOD_PROC(m) ((m).proc)
118 | #define MRB_METHOD_UNDEF_P(m) ((m).proc==NULL)
119 | 
120 | #endif /* MRB_METHOD_TABLE_INLINE */
121 | 
122 | #define MRB_METHOD_CFUNC_P(m) (MRB_METHOD_FUNC_P(m)?TRUE:(MRB_METHOD_PROC(m)?(MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m))):FALSE))
123 | #define MRB_METHOD_CFUNC(m) (MRB_METHOD_FUNC_P(m)?MRB_METHOD_FUNC(m):((MRB_METHOD_PROC(m)&&MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m)))?MRB_PROC_CFUNC(MRB_METHOD_PROC(m)):NULL))
124 | 
125 | 
126 | #include <mruby/khash.h>
127 | KHASH_DECLARE(mt, mrb_sym, mrb_method_t, TRUE)
128 | 
129 | MRB_END_DECL
130 | 
131 | #endif  /* MRUBY_PROC_H */
132 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Headers/mruby/range.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** mruby/range.h - Range class
 3 | **
 4 | ** See Copyright Notice in mruby.h
 5 | */
 6 | 
 7 | #ifndef MRUBY_RANGE_H
 8 | #define MRUBY_RANGE_H
 9 | 
10 | #include "common.h"
11 | 
12 | /**
13 |  * Range class
14 |  */
15 | MRB_BEGIN_DECL
16 | 
17 | typedef struct mrb_range_edges {
18 |   mrb_value beg;
19 |   mrb_value end;
20 | } mrb_range_edges;
21 | 
22 | struct RRange {
23 |   MRB_OBJECT_HEADER;
24 |   mrb_range_edges *edges;
25 |   mrb_bool excl : 1;
26 | };
27 | 
28 | MRB_API struct RRange* mrb_range_ptr(mrb_state *mrb, mrb_value v);
29 | #define mrb_range_raw_ptr(v) ((struct RRange*)mrb_ptr(v))
30 | #define mrb_range_value(p)  mrb_obj_value((void*)(p))
31 | 
32 | /*
33 |  * Initializes a Range.
34 |  *
35 |  * If the third parameter is FALSE then it includes the last value in the range.
36 |  * If the third parameter is TRUE then it excludes the last value in the range.
37 |  *
38 |  * @param start the beginning value.
39 |  * @param end the ending value.
40 |  * @param exclude represents the inclusion or exclusion of the last value.
41 |  */
42 | MRB_API mrb_value mrb_range_new(mrb_state *mrb, mrb_value start, mrb_value end, mrb_bool exclude);
43 | 
44 | MRB_API mrb_int mrb_range_beg_len(mrb_state *mrb, mrb_value range, mrb_int *begp, mrb_int *lenp, mrb_int len, mrb_bool trunc);
45 | 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));
46 | 
47 | MRB_END_DECL
48 | 
49 | #endif  /* MRUBY_RANGE_H */
50 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Headers/mruby/re.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** mruby/re.h - Regexp class
 3 | **
 4 | ** See Copyright Notice in mruby.h
 5 | */
 6 | 
 7 | #ifndef MRUBY_RE_H
 8 | #define MRUBY_RE_H
 9 | 
10 | MRB_BEGIN_DECL
11 | 
12 | #define REGEXP_CLASS          "Regexp"
13 | 
14 | MRB_END_DECL
15 | 
16 | #endif  /* RE_H */
17 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Headers/mruby/string.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** mruby/string.h - String class
  3 | **
  4 | ** See Copyright Notice in mruby.h
  5 | */
  6 | 
  7 | #ifndef MRUBY_STRING_H
  8 | #define MRUBY_STRING_H
  9 | 
 10 | #include "common.h"
 11 | 
 12 | /**
 13 |  * String class
 14 |  */
 15 | MRB_BEGIN_DECL
 16 | 
 17 | extern const char mrb_digitmap[];
 18 | 
 19 | #define RSTRING_EMBED_LEN_MAX ((mrb_int)(sizeof(void*) * 3 - 1))
 20 | 
 21 | struct RString {
 22 |   MRB_OBJECT_HEADER;
 23 |   union {
 24 |     struct {
 25 |       mrb_int len;
 26 |       union {
 27 |         mrb_int capa;
 28 |         struct mrb_shared_string *shared;
 29 |         struct RString *fshared;
 30 |       } aux;
 31 |       char *ptr;
 32 |     } heap;
 33 |     char ary[RSTRING_EMBED_LEN_MAX + 1];
 34 |   } as;
 35 | };
 36 | 
 37 | #define RSTR_EMBED_P(s) ((s)->flags & MRB_STR_EMBED)
 38 | #define RSTR_SET_EMBED_FLAG(s) ((s)->flags |= MRB_STR_EMBED)
 39 | #define RSTR_UNSET_EMBED_FLAG(s) ((s)->flags &= ~(MRB_STR_EMBED|MRB_STR_EMBED_LEN_MASK))
 40 | #define RSTR_SET_EMBED_LEN(s, n) do {\
 41 |   size_t tmp_n = (n);\
 42 |   s->flags &= ~MRB_STR_EMBED_LEN_MASK;\
 43 |   s->flags |= (tmp_n) << MRB_STR_EMBED_LEN_SHIFT;\
 44 | } while (0)
 45 | #define RSTR_SET_LEN(s, n) do {\
 46 |   if (RSTR_EMBED_P(s)) {\
 47 |     RSTR_SET_EMBED_LEN((s),(n));\
 48 |   }\
 49 |   else {\
 50 |     s->as.heap.len = (mrb_int)(n);\
 51 |   }\
 52 | } while (0)
 53 | #define RSTR_EMBED_LEN(s)\
 54 |   (mrb_int)(((s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT)
 55 | #define RSTR_PTR(s) ((RSTR_EMBED_P(s)) ? (s)->as.ary : (s)->as.heap.ptr)
 56 | #define RSTR_LEN(s) ((RSTR_EMBED_P(s)) ? RSTR_EMBED_LEN(s) : (s)->as.heap.len)
 57 | #define RSTR_CAPA(s) (RSTR_EMBED_P(s) ? RSTRING_EMBED_LEN_MAX : (s)->as.heap.aux.capa)
 58 | 
 59 | #define RSTR_SHARED_P(s) ((s)->flags & MRB_STR_SHARED)
 60 | #define RSTR_SET_SHARED_FLAG(s) ((s)->flags |= MRB_STR_SHARED)
 61 | #define RSTR_UNSET_SHARED_FLAG(s) ((s)->flags &= ~MRB_STR_SHARED)
 62 | 
 63 | #define RSTR_FSHARED_P(s) ((s)->flags & MRB_STR_FSHARED)
 64 | #define RSTR_SET_FSHARED_FLAG(s) ((s)->flags |= MRB_STR_FSHARED)
 65 | #define RSTR_UNSET_FSHARED_FLAG(s) ((s)->flags &= ~MRB_STR_FSHARED)
 66 | 
 67 | #define RSTR_NOFREE_P(s) ((s)->flags & MRB_STR_NOFREE)
 68 | #define RSTR_SET_NOFREE_FLAG(s) ((s)->flags |= MRB_STR_NOFREE)
 69 | #define RSTR_UNSET_NOFREE_FLAG(s) ((s)->flags &= ~MRB_STR_NOFREE)
 70 | 
 71 | #define RSTR_POOL_P(s) ((s)->flags & MRB_STR_POOL)
 72 | #define RSTR_SET_POOL_FLAG(s) ((s)->flags |= MRB_STR_POOL)
 73 | 
 74 | /*
 75 |  * Returns a pointer from a Ruby string
 76 |  */
 77 | #define mrb_str_ptr(s)       ((struct RString*)(mrb_ptr(s)))
 78 | #define RSTRING(s)           mrb_str_ptr(s)
 79 | #define RSTRING_PTR(s)       RSTR_PTR(RSTRING(s))
 80 | #define RSTRING_EMBED_LEN(s) RSTR_EMBED_LEN(RSTRING(s))
 81 | #define RSTRING_LEN(s)       RSTR_LEN(RSTRING(s))
 82 | #define RSTRING_CAPA(s)      RSTR_CAPA(RSTRING(s))
 83 | #define RSTRING_END(s)       (RSTRING_PTR(s) + RSTRING_LEN(s))
 84 | MRB_API mrb_int mrb_str_strlen(mrb_state*, struct RString*);
 85 | 
 86 | #define MRB_STR_SHARED    1
 87 | #define MRB_STR_FSHARED   2
 88 | #define MRB_STR_NOFREE    4
 89 | #define MRB_STR_POOL      8
 90 | #define MRB_STR_NO_UTF   16
 91 | #define MRB_STR_EMBED    32
 92 | #define MRB_STR_EMBED_LEN_MASK 0x7c0
 93 | #define MRB_STR_EMBED_LEN_SHIFT 6
 94 | 
 95 | void mrb_gc_free_str(mrb_state*, struct RString*);
 96 | MRB_API void mrb_str_modify(mrb_state*, struct RString*);
 97 | 
 98 | /*
 99 |  * Finds the index of a substring in a string
100 |  */
101 | MRB_API mrb_int mrb_str_index(mrb_state*, mrb_value, const char*, mrb_int, mrb_int);
102 | #define mrb_str_index_lit(mrb, str, lit, off) mrb_str_index(mrb, str, lit, mrb_strlen_lit(lit), off);
103 | 
104 | /*
105 |  * Appends self to other. Returns self as a concatenated string.
106 |  *
107 |  *
108 |  *  Example:
109 |  *
110 |  *     !!!c
111 |  *     int
112 |  *     main(int argc,
113 |  *          char **argv)
114 |  *     {
115 |  *       // Variable declarations.
116 |  *       mrb_value str1;
117 |  *       mrb_value str2;
118 |  *
119 |  *       mrb_state *mrb = mrb_open();
120 |  *       if (!mrb)
121 |  *       {
122 |  *          // handle error
123 |  *       }
124 |  *
125 |  *       // Creates new Ruby strings.
126 |  *       str1 = mrb_str_new_lit(mrb, "abc");
127 |  *       str2 = mrb_str_new_lit(mrb, "def");
128 |  *
129 |  *       // Concatenates str2 to str1.
130 |  *       mrb_str_concat(mrb, str1, str2);
131 |  *
132 |  *      // Prints new Concatenated Ruby string.
133 |  *      mrb_p(mrb, str1);
134 |  *
135 |  *      mrb_close(mrb);
136 |  *      return 0;
137 |  *    }
138 |  *
139 |  *
140 |  *  Result:
141 |  *
142 |  *     => "abcdef"
143 |  *
144 |  * @param [mrb_state] mrb The current mruby state.
145 |  * @param [mrb_value] self String to concatenate.
146 |  * @param [mrb_value] other String to append to self.
147 |  * @return [mrb_value] Returns a new String appending other to self.
148 |  */
149 | MRB_API void mrb_str_concat(mrb_state*, mrb_value, mrb_value);
150 | 
151 | /*
152 |  * Adds two strings together.
153 |  *
154 |  *
155 |  *  Example:
156 |  *
157 |  *     !!!c
158 |  *     int
159 |  *     main(int argc,
160 |  *          char **argv)
161 |  *     {
162 |  *       // Variable declarations.
163 |  *       mrb_value a;
164 |  *       mrb_value b;
165 |  *       mrb_value c;
166 |  *
167 |  *       mrb_state *mrb = mrb_open();
168 |  *       if (!mrb)
169 |  *       {
170 |  *          // handle error
171 |  *       }
172 |  *
173 |  *       // Creates two Ruby strings from the passed in C strings.
174 |  *       a = mrb_str_new_lit(mrb, "abc");
175 |  *       b = mrb_str_new_lit(mrb, "def");
176 |  *
177 |  *       // Prints both C strings.
178 |  *       mrb_p(mrb, a);
179 |  *       mrb_p(mrb, b);
180 |  *
181 |  *       // Concatenates both Ruby strings.
182 |  *       c = mrb_str_plus(mrb, a, b);
183 |  *
184 |  *      // Prints new Concatenated Ruby string.
185 |  *      mrb_p(mrb, c);
186 |  *
187 |  *      mrb_close(mrb);
188 |  *      return 0;
189 |  *    }
190 |  *
191 |  *
192 |  *  Result:
193 |  *
194 |  *     => "abc"  # First string
195 |  *     => "def"  # Second string
196 |  *     => "abcdef" # First & Second concatenated.
197 |  *
198 |  * @param [mrb_state] mrb The current mruby state.
199 |  * @param [mrb_value] a First string to concatenate.
200 |  * @param [mrb_value] b Second string to concatenate.
201 |  * @return [mrb_value] Returns a new String containing a concatenated to b.
202 |  */
203 | MRB_API mrb_value mrb_str_plus(mrb_state*, mrb_value, mrb_value);
204 | 
205 | /*
206 |  * Converts pointer into a Ruby string.
207 |  *
208 |  * @param [mrb_state] mrb The current mruby state.
209 |  * @param [void*] p The pointer to convert to Ruby string.
210 |  * @return [mrb_value] Returns a new Ruby String.
211 |  */
212 | MRB_API mrb_value mrb_ptr_to_str(mrb_state *, void*);
213 | 
214 | /*
215 |  * Returns an object as a Ruby string.
216 |  *
217 |  * @param [mrb_state] mrb The current mruby state.
218 |  * @param [mrb_value] obj An object to return as a Ruby string.
219 |  * @return [mrb_value] An object as a Ruby string.
220 |  */
221 | MRB_API mrb_value mrb_obj_as_string(mrb_state *mrb, mrb_value obj);
222 | 
223 | /*
224 |  * Resizes the string's length. Returns the amount of characters
225 |  * in the specified by len.
226 |  *
227 |  * Example:
228 |  *
229 |  *     !!!c
230 |  *     int
231 |  *     main(int argc,
232 |  *          char **argv)
233 |  *     {
234 |  *         // Variable declaration.
235 |  *         mrb_value str;
236 |  *
237 |  *         mrb_state *mrb = mrb_open();
238 |  *         if (!mrb)
239 |  *         {
240 |  *            // handle error
241 |  *         }
242 |  *         // Creates a new string.
243 |  *         str = mrb_str_new_lit(mrb, "Hello, world!");
244 |  *         // Returns 5 characters of
245 |  *         mrb_str_resize(mrb, str, 5);
246 |  *         mrb_p(mrb, str);
247 |  *
248 |  *         mrb_close(mrb);
249 |  *         return 0;
250 |  *      }
251 |  *
252 |  * Result:
253 |  *
254 |  *     => "Hello"
255 |  *
256 |  * @param [mrb_state] mrb The current mruby state.
257 |  * @param [mrb_value] str The Ruby string to resize.
258 |  * @param [mrb_value] len The length.
259 |  * @return [mrb_value] An object as a Ruby string.
260 |  */
261 | MRB_API mrb_value mrb_str_resize(mrb_state *mrb, mrb_value str, mrb_int len);
262 | 
263 | /*
264 |  * Returns a sub string.
265 |  *
266 |  *  Example:
267 |  *
268 |  *     !!!c
269 |  *     int
270 |  *     main(int argc,
271 |  *     char const **argv)
272 |  *     {
273 |  *       // Variable declarations.
274 |  *       mrb_value str1;
275 |  *       mrb_value str2;
276 |  *
277 |  *       mrb_state *mrb = mrb_open();
278 |  *       if (!mrb)
279 |  *       {
280 |  *         // handle error
281 |  *       }
282 |  *       // Creates new string.
283 |  *       str1 = mrb_str_new_lit(mrb, "Hello, world!");
284 |  *       // Returns a sub-string within the range of 0..2
285 |  *       str2 = mrb_str_substr(mrb, str1, 0, 2);
286 |  *
287 |  *       // Prints sub-string.
288 |  *       mrb_p(mrb, str2);
289 |  *
290 |  *       mrb_close(mrb);
291 |  *       return 0;
292 |  *     }
293 |  *
294 |  *  Result:
295 |  *
296 |  *     => "He"
297 |  *
298 |  * @param [mrb_state] mrb The current mruby state.
299 |  * @param [mrb_value] str Ruby string.
300 |  * @param [mrb_int] beg The beginning point of the sub-string.
301 |  * @param [mrb_int] len The end point of the sub-string.
302 |  * @return [mrb_value] An object as a Ruby sub-string.
303 |  */
304 | MRB_API mrb_value mrb_str_substr(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len);
305 | 
306 | /*
307 |  * Returns a Ruby string type.
308 |  *
309 |  *
310 |  * @param [mrb_state] mrb The current mruby state.
311 |  * @param [mrb_value] str Ruby string.
312 |  * @return [mrb_value] A Ruby string.
313 |  */
314 | MRB_API mrb_value mrb_ensure_string_type(mrb_state *mrb, mrb_value str);
315 | MRB_API mrb_value mrb_check_string_type(mrb_state *mrb, mrb_value str);
316 | /* obsolete: use mrb_ensure_string_type() instead */
317 | MRB_API mrb_value mrb_string_type(mrb_state *mrb, mrb_value str);
318 | 
319 | 
320 | MRB_API mrb_value mrb_str_new_capa(mrb_state *mrb, size_t capa);
321 | MRB_API mrb_value mrb_str_buf_new(mrb_state *mrb, size_t capa);
322 | 
323 | MRB_API const char *mrb_string_value_cstr(mrb_state *mrb, mrb_value *ptr);
324 | MRB_API const char *mrb_string_value_ptr(mrb_state *mrb, mrb_value str);
325 | /*
326 |  * Returns the length of the Ruby string.
327 |  *
328 |  *
329 |  * @param [mrb_state] mrb The current mruby state.
330 |  * @param [mrb_value] str Ruby string.
331 |  * @return [mrb_int] The length of the passed in Ruby string.
332 |  */
333 | MRB_API mrb_int mrb_string_value_len(mrb_state *mrb, mrb_value str);
334 | 
335 | /*
336 |  * Duplicates a string object.
337 |  *
338 |  *
339 |  * @param [mrb_state] mrb The current mruby state.
340 |  * @param [mrb_value] str Ruby string.
341 |  * @return [mrb_value] Duplicated Ruby string.
342 |  */
343 | MRB_API mrb_value mrb_str_dup(mrb_state *mrb, mrb_value str);
344 | 
345 | /*
346 |  * Returns a symbol from a passed in Ruby string.
347 |  *
348 |  * @param [mrb_state] mrb The current mruby state.
349 |  * @param [mrb_value] self Ruby string.
350 |  * @return [mrb_value] A symbol.
351 |  */
352 | MRB_API mrb_value mrb_str_intern(mrb_state *mrb, mrb_value self);
353 | 
354 | MRB_API mrb_value mrb_str_to_inum(mrb_state *mrb, mrb_value str, mrb_int base, mrb_bool badcheck);
355 | MRB_API double mrb_str_to_dbl(mrb_state *mrb, mrb_value str, mrb_bool badcheck);
356 | 
357 | /*
358 |  * Returns a converted string type.
359 |  * For type checking, non converting `mrb_to_str` is recommended.
360 |  */
361 | MRB_API mrb_value mrb_str_to_str(mrb_state *mrb, mrb_value str);
362 | 
363 | /*
364 |  * Returns true if the strings match and false if the strings don't match.
365 |  *
366 |  * @param [mrb_state] mrb The current mruby state.
367 |  * @param [mrb_value] str1 Ruby string to compare.
368 |  * @param [mrb_value] str2 Ruby string to compare.
369 |  * @return [mrb_value] boolean value.
370 |  */
371 | MRB_API mrb_bool mrb_str_equal(mrb_state *mrb, mrb_value str1, mrb_value str2);
372 | 
373 | /*
374 |  * Returns a concated string comprised of a Ruby string and a C string.
375 |  *
376 |  * @param [mrb_state] mrb The current mruby state.
377 |  * @param [mrb_value] str Ruby string.
378 |  * @param [const char *] ptr A C string.
379 |  * @param [size_t] len length of C string.
380 |  * @return [mrb_value] A Ruby string.
381 |  * @see mrb_str_cat_cstr
382 |  */
383 | MRB_API mrb_value mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, size_t len);
384 | 
385 | /*
386 |  * Returns a concated string comprised of a Ruby string and a C string.
387 |  *
388 |  * @param [mrb_state] mrb The current mruby state.
389 |  * @param [mrb_value] str Ruby string.
390 |  * @param [const char *] ptr A C string.
391 |  * @return [mrb_value] A Ruby string.
392 |  * @see mrb_str_cat
393 |  */
394 | MRB_API mrb_value mrb_str_cat_cstr(mrb_state *mrb, mrb_value str, const char *ptr);
395 | MRB_API mrb_value mrb_str_cat_str(mrb_state *mrb, mrb_value str, mrb_value str2);
396 | #define mrb_str_cat_lit(mrb, str, lit) mrb_str_cat(mrb, str, lit, mrb_strlen_lit(lit))
397 | 
398 | /*
399 |  * Adds str2 to the end of str1.
400 |  */
401 | MRB_API mrb_value mrb_str_append(mrb_state *mrb, mrb_value str, mrb_value str2);
402 | 
403 | /*
404 |  * 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.
405 |  */
406 | MRB_API int mrb_str_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2);
407 | 
408 | /*
409 |  * Returns a newly allocated C string from a Ruby string.
410 |  * This is an utility function to pass a Ruby string to C library functions.
411 |  *
412 |  * - Returned string does not contain any NUL characters (but terminator).
413 |  * - It raises an ArgumentError exception if Ruby string contains
414 |  *   NUL characters.
415 |  * - Retured string will be freed automatically on next GC.
416 |  * - Caller can modify returned string without affecting Ruby string
417 |  *   (e.g. it can be used for mkstemp(3)).
418 |  *
419 |  * @param [mrb_state *] mrb The current mruby state.
420 |  * @param [mrb_value] str Ruby string. Must be an instance of String.
421 |  * @return [char *] A newly allocated C string.
422 |  */
423 | MRB_API char *mrb_str_to_cstr(mrb_state *mrb, mrb_value str);
424 | 
425 | mrb_value mrb_str_pool(mrb_state *mrb, mrb_value str);
426 | uint32_t mrb_str_hash(mrb_state *mrb, mrb_value str);
427 | mrb_value mrb_str_dump(mrb_state *mrb, mrb_value str);
428 | 
429 | /*
430 |  * Returns a printable version of str, surrounded by quote marks, with special characters escaped.
431 |  */
432 | mrb_value mrb_str_inspect(mrb_state *mrb, mrb_value str);
433 | 
434 | void mrb_noregexp(mrb_state *mrb, mrb_value self);
435 | void mrb_regexp_check(mrb_state *mrb, mrb_value obj);
436 | 
437 | /* For backward compatibility */
438 | #define mrb_str_cat2(mrb, str, ptr) mrb_str_cat_cstr(mrb, str, ptr)
439 | #define mrb_str_buf_cat(mrb, str, ptr, len) mrb_str_cat(mrb, str, ptr, len)
440 | #define mrb_str_buf_append(mrb, str, str2) mrb_str_cat_str(mrb, str, str2)
441 | 
442 | MRB_END_DECL
443 | 
444 | #endif  /* MRUBY_STRING_H */
445 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Headers/mruby/throw.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** mruby/throw.h - mruby exception throwing handler
 3 | **
 4 | ** See Copyright Notice in mruby.h
 5 | */
 6 | 
 7 | #ifndef MRB_THROW_H
 8 | #define MRB_THROW_H
 9 | 
10 | #if defined(MRB_ENABLE_CXX_ABI)
11 | # if !defined(__cplusplus)
12 | #  error Trying to use C++ exception handling in C code
13 | # endif
14 | #endif
15 | 
16 | #if defined(MRB_ENABLE_CXX_EXCEPTION) && defined(__cplusplus)
17 | 
18 | #define MRB_TRY(buf) try {
19 | #define MRB_CATCH(buf) } catch(mrb_jmpbuf_impl e) { if (e != (buf)->impl) { throw e; }
20 | #define MRB_END_EXC(buf)  }
21 | 
22 | #define MRB_THROW(buf) throw((buf)->impl)
23 | typedef mrb_int mrb_jmpbuf_impl;
24 | 
25 | #else
26 | 
27 | #include <setjmp.h>
28 | 
29 | #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
30 | #define MRB_SETJMP _setjmp
31 | #define MRB_LONGJMP _longjmp
32 | #else
33 | #define MRB_SETJMP setjmp
34 | #define MRB_LONGJMP longjmp
35 | #endif
36 | 
37 | #define MRB_TRY(buf) if (MRB_SETJMP((buf)->impl) == 0) {
38 | #define MRB_CATCH(buf) } else {
39 | #define MRB_END_EXC(buf) }
40 | 
41 | #define MRB_THROW(buf) MRB_LONGJMP((buf)->impl, 1);
42 | #define mrb_jmpbuf_impl jmp_buf
43 | 
44 | #endif
45 | 
46 | struct mrb_jmpbuf {
47 |   mrb_jmpbuf_impl impl;
48 | 
49 | #if defined(MRB_ENABLE_CXX_EXCEPTION) && defined(__cplusplus)
50 |   static mrb_int jmpbuf_id;
51 |   mrb_jmpbuf() : impl(jmpbuf_id++) {}
52 | #endif
53 | };
54 | 
55 | #endif  /* MRB_THROW_H */
56 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Headers/mruby/value.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** mruby/value.h - mruby value definitions
  3 | **
  4 | ** See Copyright Notice in mruby.h
  5 | */
  6 | 
  7 | #ifndef MRUBY_VALUE_H
  8 | #define MRUBY_VALUE_H
  9 | 
 10 | #include "common.h"
 11 | 
 12 | /**
 13 |  * MRuby Value definition functions and macros.
 14 |  */
 15 | MRB_BEGIN_DECL
 16 | 
 17 | typedef uint32_t mrb_sym;
 18 | typedef uint8_t mrb_bool;
 19 | struct mrb_state;
 20 | 
 21 | #if defined(MRB_INT16) && defined(MRB_INT64)
 22 | # error "You can't define MRB_INT16 and MRB_INT64 at the same time."
 23 | #endif
 24 | 
 25 | #if defined _MSC_VER && _MSC_VER < 1800
 26 | # define PRIo64 "llo"
 27 | # define PRId64 "lld"
 28 | # define PRIx64 "llx"
 29 | # define PRIo16 "ho"
 30 | # define PRId16 "hd"
 31 | # define PRIx16 "hx"
 32 | # define PRIo32 "o"
 33 | # define PRId32 "d"
 34 | # define PRIx32 "x"
 35 | #else
 36 | # include <inttypes.h>
 37 | #endif
 38 | 
 39 | #if defined(MRB_INT64)
 40 |   typedef int64_t mrb_int;
 41 | # define MRB_INT_BIT 64
 42 | # define MRB_INT_MIN (INT64_MIN>>MRB_FIXNUM_SHIFT)
 43 | # define MRB_INT_MAX (INT64_MAX>>MRB_FIXNUM_SHIFT)
 44 | # define MRB_PRIo PRIo64
 45 | # define MRB_PRId PRId64
 46 | # define MRB_PRIx PRIx64
 47 | #elif defined(MRB_INT16)
 48 |   typedef int16_t mrb_int;
 49 | # define MRB_INT_BIT 16
 50 | # define MRB_INT_MIN (INT16_MIN>>MRB_FIXNUM_SHIFT)
 51 | # define MRB_INT_MAX (INT16_MAX>>MRB_FIXNUM_SHIFT)
 52 | # define MRB_PRIo PRIo16
 53 | # define MRB_PRId PRId16
 54 | # define MRB_PRIx PRIx16
 55 | #else
 56 |   typedef int32_t mrb_int;
 57 | # define MRB_INT_BIT 32
 58 | # define MRB_INT_MIN (INT32_MIN>>MRB_FIXNUM_SHIFT)
 59 | # define MRB_INT_MAX (INT32_MAX>>MRB_FIXNUM_SHIFT)
 60 | # define MRB_PRIo PRIo32
 61 | # define MRB_PRId PRId32
 62 | # define MRB_PRIx PRIx32
 63 | #endif
 64 | 
 65 | 
 66 | #ifndef MRB_WITHOUT_FLOAT
 67 | MRB_API double mrb_float_read(const char*, char**);
 68 | #ifdef MRB_USE_FLOAT
 69 |   typedef float mrb_float;
 70 | #else
 71 |   typedef double mrb_float;
 72 | #endif
 73 | #endif
 74 | 
 75 | #if defined _MSC_VER && _MSC_VER < 1900
 76 | # ifndef __cplusplus
 77 | #  define inline __inline
 78 | # endif
 79 | # include <stdarg.h>
 80 | MRB_API int mrb_msvc_vsnprintf(char *s, size_t n, const char *format, va_list arg);
 81 | MRB_API int mrb_msvc_snprintf(char *s, size_t n, const char *format, ...);
 82 | # define vsnprintf(s, n, format, arg) mrb_msvc_vsnprintf(s, n, format, arg)
 83 | # define snprintf(s, n, format, ...) mrb_msvc_snprintf(s, n, format, __VA_ARGS__)
 84 | # if _MSC_VER < 1800 && !defined MRB_WITHOUT_FLOAT
 85 | #  include <float.h>
 86 | #  define isfinite(n) _finite(n)
 87 | #  define isnan _isnan
 88 | #  define isinf(n) (!_finite(n) && !_isnan(n))
 89 | #  define signbit(n) (_copysign(1.0, (n)) < 0.0)
 90 | static const unsigned int IEEE754_INFINITY_BITS_SINGLE = 0x7F800000;
 91 | #  define INFINITY (*(float *)&IEEE754_INFINITY_BITS_SINGLE)
 92 | #  define NAN ((float)(INFINITY - INFINITY))
 93 | # endif
 94 | #endif
 95 | 
 96 | enum mrb_vtype {
 97 |   MRB_TT_FALSE = 0,   /*   0 */
 98 |   MRB_TT_FREE,        /*   1 */
 99 |   MRB_TT_TRUE,        /*   2 */
100 |   MRB_TT_FIXNUM,      /*   3 */
101 |   MRB_TT_SYMBOL,      /*   4 */
102 |   MRB_TT_UNDEF,       /*   5 */
103 |   MRB_TT_FLOAT,       /*   6 */
104 |   MRB_TT_CPTR,        /*   7 */
105 |   MRB_TT_OBJECT,      /*   8 */
106 |   MRB_TT_CLASS,       /*   9 */
107 |   MRB_TT_MODULE,      /*  10 */
108 |   MRB_TT_ICLASS,      /*  11 */
109 |   MRB_TT_SCLASS,      /*  12 */
110 |   MRB_TT_PROC,        /*  13 */
111 |   MRB_TT_ARRAY,       /*  14 */
112 |   MRB_TT_HASH,        /*  15 */
113 |   MRB_TT_STRING,      /*  16 */
114 |   MRB_TT_RANGE,       /*  17 */
115 |   MRB_TT_EXCEPTION,   /*  18 */
116 |   MRB_TT_FILE,        /*  19 */
117 |   MRB_TT_ENV,         /*  20 */
118 |   MRB_TT_DATA,        /*  21 */
119 |   MRB_TT_FIBER,       /*  22 */
120 |   MRB_TT_ISTRUCT,     /*  23 */
121 |   MRB_TT_BREAK,       /*  24 */
122 |   MRB_TT_MAXDEFINE    /*  25 */
123 | };
124 | 
125 | #include <mruby/object.h>
126 | 
127 | #ifdef MRB_DOCUMENTATION_BLOCK
128 | 
129 | /**
130 |  * @abstract
131 |  * MRuby value boxing.
132 |  *
133 |  * Actual implementation depends on configured boxing type.
134 |  *
135 |  * @see mruby/boxing_no.h Default boxing representation
136 |  * @see mruby/boxing_word.h Word representation
137 |  * @see mruby/boxing_nan.h Boxed double representation
138 |  */
139 | typedef void mrb_value;
140 | 
141 | #endif
142 | 
143 | #if defined(MRB_NAN_BOXING)
144 | #include "boxing_nan.h"
145 | #elif defined(MRB_WORD_BOXING)
146 | #include "boxing_word.h"
147 | #else
148 | #include "boxing_no.h"
149 | #endif
150 | 
151 | #ifndef mrb_fixnum_p
152 | #define mrb_fixnum_p(o) (mrb_type(o) == MRB_TT_FIXNUM)
153 | #endif
154 | #ifndef mrb_undef_p
155 | #define mrb_undef_p(o) (mrb_type(o) == MRB_TT_UNDEF)
156 | #endif
157 | #ifndef mrb_nil_p
158 | #define mrb_nil_p(o)  (mrb_type(o) == MRB_TT_FALSE && !mrb_fixnum(o))
159 | #endif
160 | #ifndef mrb_bool
161 | #define mrb_bool(o)   (mrb_type(o) != MRB_TT_FALSE)
162 | #endif
163 | #ifndef MRB_WITHOUT_FLOAT
164 | #define mrb_float_p(o) (mrb_type(o) == MRB_TT_FLOAT)
165 | #endif
166 | #define mrb_symbol_p(o) (mrb_type(o) == MRB_TT_SYMBOL)
167 | #define mrb_array_p(o) (mrb_type(o) == MRB_TT_ARRAY)
168 | #define mrb_string_p(o) (mrb_type(o) == MRB_TT_STRING)
169 | #define mrb_hash_p(o) (mrb_type(o) == MRB_TT_HASH)
170 | #define mrb_cptr_p(o) (mrb_type(o) == MRB_TT_CPTR)
171 | #define mrb_exception_p(o) (mrb_type(o) == MRB_TT_EXCEPTION)
172 | #define mrb_test(o)   mrb_bool(o)
173 | MRB_API mrb_bool mrb_regexp_p(struct mrb_state*, mrb_value);
174 | 
175 | /*
176 |  * Returns a float in Ruby.
177 |  */
178 | #ifndef MRB_WITHOUT_FLOAT
179 | MRB_INLINE mrb_value mrb_float_value(struct mrb_state *mrb, mrb_float f)
180 | {
181 |   mrb_value v;
182 |   (void) mrb;
183 |   SET_FLOAT_VALUE(mrb, v, f);
184 |   return v;
185 | }
186 | #endif
187 | 
188 | static inline mrb_value
189 | mrb_cptr_value(struct mrb_state *mrb, void *p)
190 | {
191 |   mrb_value v;
192 |   (void) mrb;
193 |   SET_CPTR_VALUE(mrb,v,p);
194 |   return v;
195 | }
196 | 
197 | /*
198 |  * Returns a fixnum in Ruby.
199 |  */
200 | MRB_INLINE mrb_value mrb_fixnum_value(mrb_int i)
201 | {
202 |   mrb_value v;
203 |   SET_INT_VALUE(v, i);
204 |   return v;
205 | }
206 | 
207 | static inline mrb_value
208 | mrb_symbol_value(mrb_sym i)
209 | {
210 |   mrb_value v;
211 |   SET_SYM_VALUE(v, i);
212 |   return v;
213 | }
214 | 
215 | static inline mrb_value
216 | mrb_obj_value(void *p)
217 | {
218 |   mrb_value v;
219 |   SET_OBJ_VALUE(v, (struct RBasic*)p);
220 |   mrb_assert(p == mrb_ptr(v));
221 |   mrb_assert(((struct RBasic*)p)->tt == mrb_type(v));
222 |   return v;
223 | }
224 | 
225 | 
226 | /*
227 |  * Get a nil mrb_value object.
228 |  *
229 |  * @return
230 |  *      nil mrb_value object reference.
231 |  */
232 | MRB_INLINE mrb_value mrb_nil_value(void)
233 | {
234 |   mrb_value v;
235 |   SET_NIL_VALUE(v);
236 |   return v;
237 | }
238 | 
239 | /*
240 |  * Returns false in Ruby.
241 |  */
242 | MRB_INLINE mrb_value mrb_false_value(void)
243 | {
244 |   mrb_value v;
245 |   SET_FALSE_VALUE(v);
246 |   return v;
247 | }
248 | 
249 | /*
250 |  * Returns true in Ruby.
251 |  */
252 | MRB_INLINE mrb_value mrb_true_value(void)
253 | {
254 |   mrb_value v;
255 |   SET_TRUE_VALUE(v);
256 |   return v;
257 | }
258 | 
259 | static inline mrb_value
260 | mrb_bool_value(mrb_bool boolean)
261 | {
262 |   mrb_value v;
263 |   SET_BOOL_VALUE(v, boolean);
264 |   return v;
265 | }
266 | 
267 | static inline mrb_value
268 | mrb_undef_value(void)
269 | {
270 |   mrb_value v;
271 |   SET_UNDEF_VALUE(v);
272 |   return v;
273 | }
274 | 
275 | #ifdef MRB_USE_ETEXT_EDATA
276 | #if (defined(__APPLE__) && defined(__MACH__))
277 | #include <mach-o/getsect.h>
278 | static inline mrb_bool
279 | mrb_ro_data_p(const char *p)
280 | {
281 |   return (const char*)get_etext() < p && p < (const char*)get_edata();
282 | }
283 | #else
284 | extern char _etext[];
285 | #ifdef MRB_NO_INIT_ARRAY_START
286 | extern char _edata[];
287 | 
288 | static inline mrb_bool
289 | mrb_ro_data_p(const char *p)
290 | {
291 |   return _etext < p && p < _edata;
292 | }
293 | #else
294 | extern char __init_array_start[];
295 | 
296 | static inline mrb_bool
297 | mrb_ro_data_p(const char *p)
298 | {
299 |   return _etext < p && p < (char*)&__init_array_start;
300 | }
301 | #endif
302 | #endif
303 | #else
304 | # define mrb_ro_data_p(p) FALSE
305 | #endif
306 | 
307 | MRB_END_DECL
308 | 
309 | #endif  /* MRUBY_VALUE_H */
310 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Headers/mruby/variable.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** mruby/variable.h - mruby variables
  3 | **
  4 | ** See Copyright Notice in mruby.h
  5 | */
  6 | 
  7 | #ifndef MRUBY_VARIABLE_H
  8 | #define MRUBY_VARIABLE_H
  9 | 
 10 | #include "common.h"
 11 | 
 12 | /**
 13 |  * Functions to access mruby variables.
 14 |  */
 15 | MRB_BEGIN_DECL
 16 | 
 17 | typedef struct global_variable {
 18 |   int   counter;
 19 |   mrb_value *data;
 20 |   mrb_value (*getter)(void);
 21 |   void  (*setter)(void);
 22 |   /* void  (*marker)(); */
 23 |   /* int block_trace; */
 24 |   /* struct trace_var *trace; */
 25 | } global_variable;
 26 | 
 27 | struct global_entry {
 28 |   global_variable *var;
 29 |   mrb_sym id;
 30 | };
 31 | 
 32 | mrb_value mrb_vm_special_get(mrb_state*, mrb_sym);
 33 | void mrb_vm_special_set(mrb_state*, mrb_sym, mrb_value);
 34 | mrb_value mrb_vm_cv_get(mrb_state*, mrb_sym);
 35 | void mrb_vm_cv_set(mrb_state*, mrb_sym, mrb_value);
 36 | mrb_value mrb_vm_const_get(mrb_state*, mrb_sym);
 37 | void mrb_vm_const_set(mrb_state*, mrb_sym, mrb_value);
 38 | MRB_API mrb_value mrb_const_get(mrb_state*, mrb_value, mrb_sym);
 39 | MRB_API void mrb_const_set(mrb_state*, mrb_value, mrb_sym, mrb_value);
 40 | MRB_API mrb_bool mrb_const_defined(mrb_state*, mrb_value, mrb_sym);
 41 | MRB_API void mrb_const_remove(mrb_state*, mrb_value, mrb_sym);
 42 | 
 43 | MRB_API mrb_bool mrb_iv_name_sym_p(mrb_state *mrb, mrb_sym sym);
 44 | MRB_API void mrb_iv_name_sym_check(mrb_state *mrb, mrb_sym sym);
 45 | MRB_API mrb_value mrb_obj_iv_get(mrb_state *mrb, struct RObject *obj, mrb_sym sym);
 46 | MRB_API void mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v);
 47 | MRB_API mrb_bool mrb_obj_iv_defined(mrb_state *mrb, struct RObject *obj, mrb_sym sym);
 48 | MRB_API mrb_value mrb_iv_get(mrb_state *mrb, mrb_value obj, mrb_sym sym);
 49 | MRB_API void mrb_iv_set(mrb_state *mrb, mrb_value obj, mrb_sym sym, mrb_value v);
 50 | MRB_API mrb_bool mrb_iv_defined(mrb_state*, mrb_value, mrb_sym);
 51 | MRB_API mrb_value mrb_iv_remove(mrb_state *mrb, mrb_value obj, mrb_sym sym);
 52 | MRB_API void mrb_iv_copy(mrb_state *mrb, mrb_value dst, mrb_value src);
 53 | MRB_API mrb_bool mrb_const_defined_at(mrb_state *mrb, mrb_value mod, mrb_sym id);
 54 | 
 55 | /**
 56 |  * Get a global variable. Will return nil if the var does not exist
 57 |  *
 58 |  * Example:
 59 |  *
 60 |  *     !!!ruby
 61 |  *     # Ruby style
 62 |  *     var = $value
 63 |  *
 64 |  *     !!!c
 65 |  *     // C style
 66 |  *     mrb_sym sym = mrb_intern_lit(mrb, "$value");
 67 |  *     mrb_value var = mrb_gv_get(mrb, sym);
 68 |  *
 69 |  * @param mrb The mruby state reference
 70 |  * @param sym The name of the global variable
 71 |  * @return The value of that global variable. May be nil
 72 |  */
 73 | MRB_API mrb_value mrb_gv_get(mrb_state *mrb, mrb_sym sym);
 74 | 
 75 | /**
 76 |  * Set a global variable
 77 |  *
 78 |  * Example:
 79 |  *
 80 |  *     !!!ruby
 81 |  *     # Ruby style
 82 |  *     $value = "foo"
 83 |  *
 84 |  *     !!!c
 85 |  *     // C style
 86 |  *     mrb_sym sym = mrb_intern_lit(mrb, "$value");
 87 |  *     mrb_gv_set(mrb, sym, mrb_str_new_lit("foo"));
 88 |  *
 89 |  * @param mrb The mruby state reference
 90 |  * @param sym The name of the global variable
 91 |  * @param val The value of the global variable
 92 |  */
 93 | MRB_API void mrb_gv_set(mrb_state *mrb, mrb_sym sym, mrb_value val);
 94 | 
 95 | /**
 96 |  * Remove a global variable.
 97 |  *
 98 |  * Example:
 99 |  *
100 |  *     !!!ruby
101 |  *     # Ruby style
102 |  *     $value = nil
103 |  *
104 |  *     !!!c
105 |  *     // C style
106 |  *     mrb_sym sym = mrb_intern_lit(mrb, "$value");
107 |  *     mrb_gv_remove(mrb, sym);
108 |  *
109 |  * @param mrb The mruby state reference
110 |  * @param sym The name of the global variable
111 |  * @param val The value of the global variable
112 |  */
113 | MRB_API void mrb_gv_remove(mrb_state *mrb, mrb_sym sym);
114 | 
115 | MRB_API mrb_value mrb_cv_get(mrb_state *mrb, mrb_value mod, mrb_sym sym);
116 | MRB_API void mrb_mod_cv_set(mrb_state *mrb, struct RClass * c, mrb_sym sym, mrb_value v);
117 | MRB_API void mrb_cv_set(mrb_state *mrb, mrb_value mod, mrb_sym sym, mrb_value v);
118 | MRB_API mrb_bool mrb_cv_defined(mrb_state *mrb, mrb_value mod, mrb_sym sym);
119 | mrb_value mrb_obj_iv_inspect(mrb_state*, struct RObject*);
120 | mrb_value mrb_mod_constants(mrb_state *mrb, mrb_value mod);
121 | mrb_value mrb_f_global_variables(mrb_state *mrb, mrb_value self);
122 | mrb_value mrb_obj_instance_variables(mrb_state*, mrb_value);
123 | mrb_value mrb_mod_class_variables(mrb_state*, mrb_value);
124 | mrb_value mrb_mod_cv_get(mrb_state *mrb, struct RClass * c, mrb_sym sym);
125 | mrb_bool mrb_mod_cv_defined(mrb_state *mrb, struct RClass * c, mrb_sym sym);
126 | 
127 | /* GC functions */
128 | void mrb_gc_mark_gv(mrb_state*);
129 | void mrb_gc_free_gv(mrb_state*);
130 | void mrb_gc_mark_iv(mrb_state*, struct RObject*);
131 | size_t mrb_gc_mark_iv_size(mrb_state*, struct RObject*);
132 | void mrb_gc_free_iv(mrb_state*, struct RObject*);
133 | 
134 | MRB_END_DECL
135 | 
136 | #endif  /* MRUBY_VARIABLE_H */
137 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Headers/mruby/version.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** mruby/version.h - mruby version definition
  3 | **
  4 | ** See Copyright Notice in mruby.h
  5 | */
  6 | 
  7 | #ifndef MRUBY_VERSION_H
  8 | #define MRUBY_VERSION_H
  9 | 
 10 | #include "common.h"
 11 | 
 12 | /**
 13 |  * mruby version definition macros
 14 |  */
 15 | MRB_BEGIN_DECL
 16 | 
 17 | /*
 18 |  * A passed in expression.
 19 |  */
 20 | #define MRB_STRINGIZE0(expr) #expr
 21 | 
 22 | /*
 23 |  * Passes in an expression to MRB_STRINGIZE0.
 24 |  */
 25 | #define MRB_STRINGIZE(expr) MRB_STRINGIZE0(expr)
 26 | 
 27 | /*
 28 |  * The version of Ruby used by mruby.
 29 |  */
 30 | #define MRUBY_RUBY_VERSION "2.0"
 31 | 
 32 | /*
 33 |  * Ruby engine.
 34 |  */
 35 | #define MRUBY_RUBY_ENGINE  "mruby"
 36 | 
 37 | /*
 38 |  * Major release version number.
 39 |  */
 40 | #define MRUBY_RELEASE_MAJOR 2
 41 | 
 42 | /*
 43 |  * Minor release version number.
 44 |  */
 45 | #define MRUBY_RELEASE_MINOR 0
 46 | 
 47 | /*
 48 |  * Tiny release version number.
 49 |  */
 50 | #define MRUBY_RELEASE_TEENY 0
 51 | 
 52 | /*
 53 |  * The mruby version.
 54 |  */
 55 | #define MRUBY_VERSION MRB_STRINGIZE(MRUBY_RELEASE_MAJOR) "." MRB_STRINGIZE(MRUBY_RELEASE_MINOR) "." MRB_STRINGIZE(MRUBY_RELEASE_TEENY)
 56 | 
 57 | /*
 58 |  * Release number.
 59 |  */
 60 | #define MRUBY_RELEASE_NO (MRUBY_RELEASE_MAJOR * 100 * 100 + MRUBY_RELEASE_MINOR * 100 + MRUBY_RELEASE_TEENY)
 61 | 
 62 | /*
 63 |  * Release year.
 64 |  */
 65 | #define MRUBY_RELEASE_YEAR 2018
 66 | 
 67 | /*
 68 |  * Release month.
 69 |  */
 70 | #define MRUBY_RELEASE_MONTH 12
 71 | 
 72 | /*
 73 |  * Release day.
 74 |  */
 75 | #define MRUBY_RELEASE_DAY 11
 76 | 
 77 | /*
 78 |  * Release date as a string.
 79 |  */
 80 | #define MRUBY_RELEASE_DATE MRB_STRINGIZE(MRUBY_RELEASE_YEAR) "-" MRB_STRINGIZE(MRUBY_RELEASE_MONTH) "-" MRB_STRINGIZE(MRUBY_RELEASE_DAY)
 81 | 
 82 | /*
 83 |  * The year mruby was first created.
 84 |  */
 85 | #define MRUBY_BIRTH_YEAR 2010
 86 | 
 87 | /*
 88 |  * MRuby's authors.
 89 |  */
 90 | #define MRUBY_AUTHOR "mruby developers"
 91 | 
 92 | /*
 93 |  * mruby's version, and release date.
 94 |  */
 95 | #define MRUBY_DESCRIPTION      \
 96 |   "mruby " MRUBY_VERSION       \
 97 |   " (" MRUBY_RELEASE_DATE ") " \
 98 | 
 99 | /*
100 |  * mruby's copyright information.
101 |  */
102 | #define MRUBY_COPYRIGHT                \
103 |   "mruby - Copyright (c) "             \
104 |   MRB_STRINGIZE(MRUBY_BIRTH_YEAR)"-"   \
105 |   MRB_STRINGIZE(MRUBY_RELEASE_YEAR)" " \
106 |   MRUBY_AUTHOR                         \
107 | 
108 | MRB_END_DECL
109 | 
110 | #endif  /* MRUBY_VERSION_H */
111 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/Info.plist:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 3 | <plist version="1.0">
 4 | <dict>
 5 |   <key>CFBundleName</key>
 6 |   <string>MRuby</string>
 7 |   <key>CFBundleDevelopmentRegion</key>
 8 |   <string>en</string>
 9 |   <key>CFBundleInfoDictionaryVersion</key>
10 |   <string>6.0</string>
11 |   <key>CFBundlePackageType</key>
12 |   <string>FMWK</string>
13 |   <key>CFBundleIdentifier</key>
14 |   <string>MRuby.MRuby</string>
15 |   <key>CFBundleExecutable</key>
16 |   <string>MRuby</string>
17 |   <key>CFBundleVersion</key>
18 |   <string>1</string>
19 | </dict>
20 | </plist>
21 | 


--------------------------------------------------------------------------------
/ios/MRuby.framework/MRuby:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ruby2d/mruby-frameworks/83906f0c55eba587a5b1a95e05a14dda1c31acf0/ios/MRuby.framework/MRuby


--------------------------------------------------------------------------------
/tvos/MRuby.framework/Headers/mrbconf.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** mrbconf.h - mruby core configuration
  3 | **
  4 | ** See Copyright Notice in mruby.h
  5 | */
  6 | 
  7 | #ifndef MRUBYCONF_H
  8 | #define MRUBYCONF_H
  9 | 
 10 | #include <limits.h>
 11 | #include <stdint.h>
 12 | 
 13 | /* architecture selection: */
 14 | /* specify -DMRB_32BIT or -DMRB_64BIT to override */
 15 | #if !defined(MRB_32BIT) && !defined(MRB_64BIT)
 16 | #if UINT64_MAX == SIZE_MAX
 17 | #define MRB_64BIT
 18 | #else
 19 | #define MRB_32BIT
 20 | #endif
 21 | #endif
 22 | 
 23 | #if defined(MRB_32BIT) && defined(MRB_64BIT)
 24 | #error Cannot build for 32 and 64 bit architecture at the same time
 25 | #endif
 26 | 
 27 | /* configuration options: */
 28 | /* add -DMRB_USE_FLOAT to use float instead of double for floating point numbers */
 29 | //#define MRB_USE_FLOAT
 30 | 
 31 | /* exclude floating point numbers */
 32 | //#define MRB_WITHOUT_FLOAT
 33 | 
 34 | /* add -DMRB_METHOD_CACHE to use method cache to improve performance */
 35 | //#define MRB_METHOD_CACHE
 36 | /* size of the method cache (need to be the power of 2) */
 37 | //#define MRB_METHOD_CACHE_SIZE (1<<7)
 38 | 
 39 | /* add -DMRB_METHOD_TABLE_INLINE to reduce the size of method table */
 40 | /* MRB_METHOD_TABLE_INLINE requires LSB of function pointers to be zero */
 41 | /* you might need to specify --falign-functions=n (where n>1) */
 42 | //#define MRB_METHOD_TABLE_INLINE
 43 | 
 44 | /* add -DMRB_INT16 to use 16bit integer for mrb_int; conflict with MRB_INT64 */
 45 | //#define MRB_INT16
 46 | 
 47 | /* add -DMRB_INT64 to use 64bit integer for mrb_int; conflict with MRB_INT16 */
 48 | //#define MRB_INT64
 49 | 
 50 | /* if no specific integer type is chosen */
 51 | #if !defined(MRB_INT16) && !defined(MRB_INT32) && !defined(MRB_INT64)
 52 | # if defined(MRB_64BIT) && !defined(MRB_NAN_BOXING)
 53 | /* Use 64bit integers on 64bit architecture (without MRB_NAN_BOXING) */
 54 | #  define MRB_INT64
 55 | # else
 56 | /* Otherwise use 32bit integers */
 57 | #  define MRB_INT32
 58 | # endif
 59 | #endif
 60 | 
 61 | /* represent mrb_value in boxed double; conflict with MRB_USE_FLOAT and MRB_WITHOUT_FLOAT */
 62 | //#define MRB_NAN_BOXING
 63 | 
 64 | /* define on big endian machines; used by MRB_NAN_BOXING */
 65 | //#define MRB_ENDIAN_BIG
 66 | 
 67 | /* represent mrb_value as a word (natural unit of data for the processor) */
 68 | //#define MRB_WORD_BOXING
 69 | 
 70 | /* string class to handle UTF-8 encoding */
 71 | //#define MRB_UTF8_STRING
 72 | 
 73 | /* argv max size in mrb_funcall */
 74 | //#define MRB_FUNCALL_ARGC_MAX 16
 75 | 
 76 | /* number of object per heap page */
 77 | //#define MRB_HEAP_PAGE_SIZE 1024
 78 | 
 79 | /* if _etext and _edata available, mruby can reduce memory used by symbols */
 80 | //#define MRB_USE_ETEXT_EDATA
 81 | 
 82 | /* do not use __init_array_start to determine readonly data section;
 83 |    effective only when MRB_USE_ETEXT_EDATA is defined */
 84 | //#define MRB_NO_INIT_ARRAY_START
 85 | 
 86 | /* turn off generational GC by default */
 87 | //#define MRB_GC_TURN_OFF_GENERATIONAL
 88 | 
 89 | /* default size of khash table bucket */
 90 | //#define KHASH_DEFAULT_SIZE 32
 91 | 
 92 | /* allocated memory address alignment */
 93 | //#define POOL_ALIGNMENT 4
 94 | 
 95 | /* page size of memory pool */
 96 | //#define POOL_PAGE_SIZE 16000
 97 | 
 98 | /* initial minimum size for string buffer */
 99 | //#define MRB_STR_BUF_MIN_SIZE 128
100 | 
101 | /* arena size */
102 | //#define MRB_GC_ARENA_SIZE 100
103 | 
104 | /* fixed size GC arena */
105 | //#define MRB_GC_FIXED_ARENA
106 | 
107 | /* state atexit stack size */
108 | //#define MRB_FIXED_STATE_ATEXIT_STACK_SIZE 5
109 | 
110 | /* fixed size state atexit stack */
111 | //#define MRB_FIXED_STATE_ATEXIT_STACK
112 | 
113 | /* -DMRB_DISABLE_XXXX to drop following features */
114 | //#define MRB_DISABLE_STDIO /* use of stdio */
115 | 
116 | /* -DMRB_ENABLE_XXXX to enable following features */
117 | //#define MRB_ENABLE_DEBUG_HOOK /* hooks for debugger */
118 | 
119 | /* end of configuration */
120 | 
121 | /* define MRB_DISABLE_XXXX from DISABLE_XXX (for compatibility) */
122 | #ifdef DISABLE_STDIO
123 | #define MRB_DISABLE_STDIO
124 | #endif
125 | 
126 | /* define MRB_ENABLE_XXXX from ENABLE_XXX (for compatibility) */
127 | #ifdef ENABLE_DEBUG
128 | #define MRB_ENABLE_DEBUG_HOOK
129 | #endif
130 | 
131 | #ifndef MRB_DISABLE_STDIO
132 | # include <stdio.h>
133 | #endif
134 | 
135 | #ifndef FALSE
136 | # define FALSE 0
137 | #endif
138 | 
139 | #ifndef TRUE
140 | # define TRUE 1
141 | #endif
142 | 
143 | #endif  /* MRUBYCONF_H */
144 | 


--------------------------------------------------------------------------------
/tvos/MRuby.framework/Headers/mruby/array.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** mruby/array.h - Array class
  3 | **
  4 | ** See Copyright Notice in mruby.h
  5 | */
  6 | 
  7 | #ifndef MRUBY_ARRAY_H
  8 | #define MRUBY_ARRAY_H
  9 | 
 10 | #include "common.h"
 11 | 
 12 | /*
 13 |  * Array class
 14 |  */
 15 | MRB_BEGIN_DECL
 16 | 
 17 | 
 18 | typedef struct mrb_shared_array {
 19 |   int refcnt;
 20 |   mrb_int len;
 21 |   mrb_value *ptr;
 22 | } mrb_shared_array;
 23 | 
 24 | #define MRB_ARY_EMBED_LEN_MAX ((mrb_int)(sizeof(void*)*3/sizeof(mrb_value)))
 25 | struct RArray {
 26 |   MRB_OBJECT_HEADER;
 27 |   union {
 28 |     struct {
 29 |       mrb_int len;
 30 |       union {
 31 |         mrb_int capa;
 32 |         mrb_shared_array *shared;
 33 |       } aux;
 34 |       mrb_value *ptr;
 35 |     } heap;
 36 |     mrb_value embed[MRB_ARY_EMBED_LEN_MAX];
 37 |   } as;
 38 | };
 39 | 
 40 | #define mrb_ary_ptr(v)    ((struct RArray*)(mrb_ptr(v)))
 41 | #define mrb_ary_value(p)  mrb_obj_value((void*)(p))
 42 | #define RARRAY(v)  ((struct RArray*)(mrb_ptr(v)))
 43 | 
 44 | #define MRB_ARY_EMBED_MASK  7
 45 | #define ARY_EMBED_P(a) ((a)->flags & MRB_ARY_EMBED_MASK)
 46 | #define ARY_UNSET_EMBED_FLAG(a) ((a)->flags &= ~(MRB_ARY_EMBED_MASK))
 47 | #define ARY_EMBED_LEN(a) ((mrb_int)(((a)->flags & MRB_ARY_EMBED_MASK) - 1))
 48 | #define ARY_SET_EMBED_LEN(a,len) ((a)->flags = ((a)->flags&~MRB_ARY_EMBED_MASK) | ((uint32_t)(len) + 1))
 49 | #define ARY_EMBED_PTR(a) (&((a)->as.embed[0]))
 50 | 
 51 | #define ARY_LEN(a) (ARY_EMBED_P(a)?ARY_EMBED_LEN(a):(a)->as.heap.len)
 52 | #define ARY_PTR(a) (ARY_EMBED_P(a)?ARY_EMBED_PTR(a):(a)->as.heap.ptr)
 53 | #define RARRAY_LEN(a) ARY_LEN(RARRAY(a))
 54 | #define RARRAY_PTR(a) ARY_PTR(RARRAY(a))
 55 | #define ARY_SET_LEN(a,n) do {\
 56 |   if (ARY_EMBED_P(a)) {\
 57 |     mrb_assert((n) <= MRB_ARY_EMBED_LEN_MAX); \
 58 |     ARY_SET_EMBED_LEN(a,n);\
 59 |   }\
 60 |   else\
 61 |     (a)->as.heap.len = (n);\
 62 | } while (0)
 63 | #define ARY_CAPA(a) (ARY_EMBED_P(a)?MRB_ARY_EMBED_LEN_MAX:(a)->as.heap.aux.capa)
 64 | #define MRB_ARY_SHARED      256
 65 | #define ARY_SHARED_P(a) ((a)->flags & MRB_ARY_SHARED)
 66 | #define ARY_SET_SHARED_FLAG(a) ((a)->flags |= MRB_ARY_SHARED)
 67 | #define ARY_UNSET_SHARED_FLAG(a) ((a)->flags &= ~MRB_ARY_SHARED)
 68 | 
 69 | void mrb_ary_decref(mrb_state*, mrb_shared_array*);
 70 | MRB_API void mrb_ary_modify(mrb_state*, struct RArray*);
 71 | MRB_API mrb_value mrb_ary_new_capa(mrb_state*, mrb_int);
 72 | 
 73 | /*
 74 |  * Initializes a new array.
 75 |  *
 76 |  * Equivalent to:
 77 |  *
 78 |  *      Array.new
 79 |  *
 80 |  * @param mrb The mruby state reference.
 81 |  * @return The initialized array.
 82 |  */
 83 | MRB_API mrb_value mrb_ary_new(mrb_state *mrb);
 84 | 
 85 | /*
 86 |  * Initializes a new array with initial values
 87 |  *
 88 |  * Equivalent to:
 89 |  *
 90 |  *      Array[value1, value2, ...]
 91 |  *
 92 |  * @param mrb The mruby state reference.
 93 |  * @param size The numer of values.
 94 |  * @param vals The actual values.
 95 |  * @return The initialized array.
 96 |  */
 97 | MRB_API mrb_value mrb_ary_new_from_values(mrb_state *mrb, mrb_int size, const mrb_value *vals);
 98 | 
 99 | /*
100 |  * Initializes a new array with two initial values
101 |  *
102 |  * Equivalent to:
103 |  *
104 |  *      Array[car, cdr]
105 |  *
106 |  * @param mrb The mruby state reference.
107 |  * @param car The first value.
108 |  * @param cdr The second value.
109 |  * @return The initialized array.
110 |  */
111 | MRB_API mrb_value mrb_assoc_new(mrb_state *mrb, mrb_value car, mrb_value cdr);
112 | 
113 | /*
114 |  * Concatenate two arrays. The target array will be modified
115 |  *
116 |  * Equivalent to:
117 |  *      ary.concat(other)
118 |  *
119 |  * @param mrb The mruby state reference.
120 |  * @param self The target array.
121 |  * @param other The array that will be concatenated to self.
122 |  */
123 | MRB_API void mrb_ary_concat(mrb_state *mrb, mrb_value self, mrb_value other);
124 | 
125 | /*
126 |  * Create an array from the input. It tries calling to_a on the
127 |  * value. If value does not respond to that, it creates a new
128 |  * array with just this value.
129 |  *
130 |  * @param mrb The mruby state reference.
131 |  * @param value The value to change into an array.
132 |  * @return An array representation of value.
133 |  */
134 | MRB_API mrb_value mrb_ary_splat(mrb_state *mrb, mrb_value value);
135 | 
136 | /*
137 |  * Pushes value into array.
138 |  *
139 |  * Equivalent to:
140 |  *
141 |  *      ary << value
142 |  *
143 |  * @param mrb The mruby state reference.
144 |  * @param ary The array in which the value will be pushed
145 |  * @param value The value to be pushed into array
146 |  */
147 | MRB_API void mrb_ary_push(mrb_state *mrb, mrb_value array, mrb_value value);
148 | 
149 | /*
150 |  * Pops the last element from the array.
151 |  *
152 |  * Equivalent to:
153 |  *
154 |  *      ary.pop
155 |  *
156 |  * @param mrb The mruby state reference.
157 |  * @param ary The array from which the value will be popped.
158 |  * @return The popped value.
159 |  */
160 | MRB_API mrb_value mrb_ary_pop(mrb_state *mrb, mrb_value ary);
161 | 
162 | /*
163 |  * Returns a reference to an element of the array on the given index.
164 |  *
165 |  * Equivalent to:
166 |  *
167 |  *      ary[n]
168 |  *
169 |  * @param mrb The mruby state reference.
170 |  * @param ary The target array.
171 |  * @param n The array index being referenced
172 |  * @return The referenced value.
173 |  */
174 | MRB_API mrb_value mrb_ary_ref(mrb_state *mrb, mrb_value ary, mrb_int n);
175 | 
176 | /*
177 |  * Sets a value on an array at the given index
178 |  *
179 |  * Equivalent to:
180 |  *
181 |  *      ary[n] = val
182 |  *
183 |  * @param mrb The mruby state reference.
184 |  * @param ary The target array.
185 |  * @param n The array index being referenced.
186 |  * @param val The value being setted.
187 |  */
188 | MRB_API void mrb_ary_set(mrb_state *mrb, mrb_value ary, mrb_int n, mrb_value val);
189 | 
190 | /*
191 |  * Replace the array with another array
192 |  *
193 |  * Equivalent to:
194 |  *
195 |  *      ary.replace(other)
196 |  *
197 |  * @param mrb The mruby state reference
198 |  * @param self The target array.
199 |  * @param other The array to replace it with.
200 |  */
201 | MRB_API void mrb_ary_replace(mrb_state *mrb, mrb_value self, mrb_value other);
202 | MRB_API mrb_value mrb_ensure_array_type(mrb_state *mrb, mrb_value self);
203 | MRB_API mrb_value mrb_check_array_type(mrb_state *mrb, mrb_value self);
204 | 
205 | /*
206 |  * Unshift an element into the array
207 |  *
208 |  * Equivalent to:
209 |  *
210 |  *     ary.unshift(item)
211 |  *
212 |  * @param mrb The mruby state reference.
213 |  * @param self The target array.
214 |  * @param item The item to unshift.
215 |  */
216 | MRB_API mrb_value mrb_ary_unshift(mrb_state *mrb, mrb_value self, mrb_value item);
217 | 
218 | /*
219 |  * Get nth element in the array
220 |  *
221 |  * Equivalent to:
222 |  *
223 |  *     ary[offset]
224 |  *
225 |  * @param ary The target array.
226 |  * @param offset The element position (negative counts from the tail).
227 |  */
228 | MRB_API mrb_value mrb_ary_entry(mrb_value ary, mrb_int offset);
229 | 
230 | /*
231 |  * Shifts the first element from the array.
232 |  *
233 |  * Equivalent to:
234 |  *
235 |  *      ary.shift
236 |  *
237 |  * @param mrb The mruby state reference.
238 |  * @param self The array from which the value will be shifted.
239 |  * @return The shifted value.
240 |  */
241 | MRB_API mrb_value mrb_ary_shift(mrb_state *mrb, mrb_value self);
242 | 
243 | /*
244 |  * Removes all elements from the array
245 |  *
246 |  * Equivalent to:
247 |  *
248 |  *      ary.clear
249 |  *
250 |  * @param mrb The mruby state reference.
251 |  * @param self The target array.
252 |  * @return self
253 |  */
254 | MRB_API mrb_value mrb_ary_clear(mrb_state *mrb, mrb_value self);
255 | 
256 | /*
257 |  * Join the array elements together in a string
258 |  *
259 |  * Equivalent to:
260 |  *
261 |  *      ary.join(sep="")
262 |  *
263 |  * @param mrb The mruby state reference.
264 |  * @param ary The target array
265 |  * @param sep The separater, can be NULL
266 |  */
267 | MRB_API mrb_value mrb_ary_join(mrb_state *mrb, mrb_value ary, mrb_value sep);
268 | 
269 | /*
270 |  * Update the capacity of the array
271 |  *
272 |  * @param mrb The mruby state reference.
273 |  * @param ary The target array.
274 |  * @param new_len The new capacity of the array
275 |  */
276 | MRB_API mrb_value mrb_ary_resize(mrb_state *mrb, mrb_value ary, mrb_int new_len);
277 | 
278 | MRB_END_DECL
279 | 
280 | #endif  /* MRUBY_ARRAY_H */
281 | 


--------------------------------------------------------------------------------
/tvos/MRuby.framework/Headers/mruby/boxing_nan.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** mruby/boxing_nan.h - nan boxing mrb_value definition
  3 | **
  4 | ** See Copyright Notice in mruby.h
  5 | */
  6 | 
  7 | #ifndef MRUBY_BOXING_NAN_H
  8 | #define MRUBY_BOXING_NAN_H
  9 | 
 10 | #ifdef MRB_USE_FLOAT
 11 | # error ---->> MRB_NAN_BOXING and MRB_USE_FLOAT conflict <<----
 12 | #endif
 13 | 
 14 | #ifdef MRB_WITHOUT_FLOAT
 15 | # error ---->> MRB_NAN_BOXING and MRB_WITHOUT_FLOAT conflict <<----
 16 | #endif
 17 | 
 18 | #ifdef MRB_INT64
 19 | # error ---->> MRB_NAN_BOXING and MRB_INT64 conflict <<----
 20 | #endif
 21 | 
 22 | #define MRB_FIXNUM_SHIFT 0
 23 | #define MRB_TT_HAS_BASIC MRB_TT_OBJECT
 24 | 
 25 | #ifdef MRB_ENDIAN_BIG
 26 | #define MRB_ENDIAN_LOHI(a,b) a b
 27 | #else
 28 | #define MRB_ENDIAN_LOHI(a,b) b a
 29 | #endif
 30 | 
 31 | /* value representation by nan-boxing:
 32 |  *   float : FFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFF
 33 |  *   object: 111111111111TTTT TTPPPPPPPPPPPPPP PPPPPPPPPPPPPPPP PPPPPPPPPPPPPPPP
 34 |  *   int   : 1111111111110001 0000000000000000 IIIIIIIIIIIIIIII IIIIIIIIIIIIIIII
 35 |  *   sym   : 1111111111110001 0100000000000000 SSSSSSSSSSSSSSSS SSSSSSSSSSSSSSSS
 36 |  * In order to get enough bit size to save TT, all pointers are shifted 2 bits
 37 |  * in the right direction. Also, TTTTTT is the mrb_vtype + 1;
 38 |  */
 39 | typedef struct mrb_value {
 40 |   union {
 41 |     mrb_float f;
 42 |     union {
 43 |       void *p;
 44 |       struct {
 45 |         MRB_ENDIAN_LOHI(
 46 |           uint32_t ttt;
 47 |           ,union {
 48 |             mrb_int i;
 49 |             mrb_sym sym;
 50 |           };
 51 |         )
 52 |       };
 53 |     } value;
 54 |   };
 55 | } mrb_value;
 56 | 
 57 | #define mrb_float_pool(mrb,f) mrb_float_value(mrb,f)
 58 | 
 59 | #define mrb_tt(o)       ((enum mrb_vtype)(((o).value.ttt & 0xfc000)>>14)-1)
 60 | #define mrb_type(o)     (enum mrb_vtype)((uint32_t)0xfff00000 < (o).value.ttt ? mrb_tt(o) : MRB_TT_FLOAT)
 61 | #define mrb_ptr(o)      ((void*)((((uintptr_t)0x3fffffffffff)&((uintptr_t)((o).value.p)))<<2))
 62 | #define mrb_float(o)    (o).f
 63 | #define mrb_cptr(o)     mrb_ptr(o)
 64 | #define mrb_fixnum(o)   (o).value.i
 65 | #define mrb_symbol(o)   (o).value.sym
 66 | 
 67 | #ifdef MRB_64BIT
 68 | #define BOXNAN_SHIFT_LONG_POINTER(v) (((uintptr_t)(v)>>34)&0x3fff)
 69 | #else
 70 | #define BOXNAN_SHIFT_LONG_POINTER(v) 0
 71 | #endif
 72 | 
 73 | #define BOXNAN_SET_VALUE(o, tt, attr, v) do {\
 74 |   (o).attr = (v);\
 75 |   (o).value.ttt = 0xfff00000 | (((tt)+1)<<14);\
 76 | } while (0)
 77 | 
 78 | #define BOXNAN_SET_OBJ_VALUE(o, tt, v) do {\
 79 |   (o).value.p = (void*)((uintptr_t)(v)>>2);\
 80 |   (o).value.ttt = (0xfff00000|(((tt)+1)<<14)|BOXNAN_SHIFT_LONG_POINTER(v));\
 81 | } while (0)
 82 | 
 83 | #define SET_FLOAT_VALUE(mrb,r,v) do { \
 84 |   if (v != v) { \
 85 |     (r).value.ttt = 0x7ff80000; \
 86 |     (r).value.i = 0; \
 87 |   } \
 88 |   else { \
 89 |     (r).f = v; \
 90 |   }} while(0)
 91 | 
 92 | #define SET_NIL_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_FALSE, value.i, 0)
 93 | #define SET_FALSE_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_FALSE, value.i, 1)
 94 | #define SET_TRUE_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_TRUE, value.i, 1)
 95 | #define SET_BOOL_VALUE(r,b) BOXNAN_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, value.i, 1)
 96 | #define SET_INT_VALUE(r,n) BOXNAN_SET_VALUE(r, MRB_TT_FIXNUM, value.i, (n))
 97 | #define SET_SYM_VALUE(r,v) BOXNAN_SET_VALUE(r, MRB_TT_SYMBOL, value.sym, (v))
 98 | #define SET_OBJ_VALUE(r,v) BOXNAN_SET_OBJ_VALUE(r, (((struct RObject*)(v))->tt), (v))
 99 | #define SET_CPTR_VALUE(mrb,r,v) BOXNAN_SET_OBJ_VALUE(r, MRB_TT_CPTR, v)
100 | #define SET_UNDEF_VALUE(r) BOXNAN_SET_VALUE(r, MRB_TT_UNDEF, value.i, 0)
101 | 
102 | #endif  /* MRUBY_BOXING_NAN_H */
103 | 


--------------------------------------------------------------------------------
/tvos/MRuby.framework/Headers/mruby/boxing_no.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** mruby/boxing_no.h - unboxed mrb_value definition
 3 | **
 4 | ** See Copyright Notice in mruby.h
 5 | */
 6 | 
 7 | #ifndef MRUBY_BOXING_NO_H
 8 | #define MRUBY_BOXING_NO_H
 9 | 
10 | #define MRB_FIXNUM_SHIFT 0
11 | #define MRB_TT_HAS_BASIC MRB_TT_OBJECT
12 | 
13 | typedef struct mrb_value {
14 |   union {
15 | #ifndef MRB_WITHOUT_FLOAT
16 |     mrb_float f;
17 | #endif
18 |     void *p;
19 |     mrb_int i;
20 |     mrb_sym sym;
21 |   } value;
22 |   enum mrb_vtype tt;
23 | } mrb_value;
24 | 
25 | #ifndef MRB_WITHOUT_FLOAT
26 | #define mrb_float_pool(mrb,f) mrb_float_value(mrb,f)
27 | #endif
28 | 
29 | #define mrb_ptr(o)      (o).value.p
30 | #define mrb_cptr(o)     mrb_ptr(o)
31 | #ifndef MRB_WITHOUT_FLOAT
32 | #define mrb_float(o)    (o).value.f
33 | #endif
34 | #define mrb_fixnum(o)   (o).value.i
35 | #define mrb_symbol(o)   (o).value.sym
36 | #define mrb_type(o)     (o).tt
37 | 
38 | #define BOXNIX_SET_VALUE(o, ttt, attr, v) do {\
39 |   (o).tt = ttt;\
40 |   (o).attr = v;\
41 | } while (0)
42 | 
43 | #define SET_NIL_VALUE(r) BOXNIX_SET_VALUE(r, MRB_TT_FALSE, value.i, 0)
44 | #define SET_FALSE_VALUE(r) BOXNIX_SET_VALUE(r, MRB_TT_FALSE, value.i, 1)
45 | #define SET_TRUE_VALUE(r) BOXNIX_SET_VALUE(r, MRB_TT_TRUE, value.i, 1)
46 | #define SET_BOOL_VALUE(r,b) BOXNIX_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, value.i, 1)
47 | #define SET_INT_VALUE(r,n) BOXNIX_SET_VALUE(r, MRB_TT_FIXNUM, value.i, (n))
48 | #ifndef MRB_WITHOUT_FLOAT
49 | #define SET_FLOAT_VALUE(mrb,r,v) BOXNIX_SET_VALUE(r, MRB_TT_FLOAT, value.f, (v))
50 | #endif
51 | #define SET_SYM_VALUE(r,v) BOXNIX_SET_VALUE(r, MRB_TT_SYMBOL, value.sym, (v))
52 | #define SET_OBJ_VALUE(r,v) BOXNIX_SET_VALUE(r, (((struct RObject*)(v))->tt), value.p, (v))
53 | #define SET_CPTR_VALUE(mrb,r,v) BOXNIX_SET_VALUE(r, MRB_TT_CPTR, value.p, v)
54 | #define SET_UNDEF_VALUE(r) BOXNIX_SET_VALUE(r, MRB_TT_UNDEF, value.i, 0)
55 | 
56 | #endif  /* MRUBY_BOXING_NO_H */
57 | 


--------------------------------------------------------------------------------
/tvos/MRuby.framework/Headers/mruby/boxing_word.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** mruby/boxing_word.h - word boxing mrb_value definition
  3 | **
  4 | ** See Copyright Notice in mruby.h
  5 | */
  6 | 
  7 | #ifndef MRUBY_BOXING_WORD_H
  8 | #define MRUBY_BOXING_WORD_H
  9 | 
 10 | #if defined(MRB_INT16)
 11 | # error MRB_INT16 is too small for MRB_WORD_BOXING.
 12 | #endif
 13 | 
 14 | #if defined(MRB_INT64) && !defined(MRB_64BIT)
 15 | #error MRB_INT64 cannot be used with MRB_WORD_BOXING in 32-bit mode.
 16 | #endif
 17 | 
 18 | #ifndef MRB_WITHOUT_FLOAT
 19 | struct RFloat {
 20 |   MRB_OBJECT_HEADER;
 21 |   mrb_float f;
 22 | };
 23 | #endif
 24 | 
 25 | struct RCptr {
 26 |   MRB_OBJECT_HEADER;
 27 |   void *p;
 28 | };
 29 | 
 30 | #define MRB_FIXNUM_SHIFT 1
 31 | #ifdef MRB_WITHOUT_FLOAT
 32 | #define MRB_TT_HAS_BASIC MRB_TT_CPTR
 33 | #else
 34 | #define MRB_TT_HAS_BASIC MRB_TT_FLOAT
 35 | #endif
 36 | 
 37 | enum mrb_special_consts {
 38 |   MRB_Qnil    = 0,
 39 |   MRB_Qfalse  = 2,
 40 |   MRB_Qtrue   = 4,
 41 |   MRB_Qundef  = 6,
 42 | };
 43 | 
 44 | #define MRB_FIXNUM_FLAG   0x01
 45 | #define MRB_SYMBOL_FLAG   0x0e
 46 | #define MRB_SPECIAL_SHIFT 8
 47 | 
 48 | #if defined(MRB_64BIT)
 49 | #define MRB_SYMBOL_BITSIZE  (sizeof(mrb_sym) * CHAR_BIT)
 50 | #define MRB_SYMBOL_MAX      UINT32_MAX
 51 | #else
 52 | #define MRB_SYMBOL_BITSIZE  (sizeof(mrb_sym) * CHAR_BIT - MRB_SPECIAL_SHIFT)
 53 | #define MRB_SYMBOL_MAX      (UINT32_MAX >> MRB_SPECIAL_SHIFT)
 54 | #endif
 55 | 
 56 | typedef union mrb_value {
 57 |   union {
 58 |     void *p;
 59 |     struct {
 60 |       unsigned int i_flag : MRB_FIXNUM_SHIFT;
 61 |       mrb_int i : (MRB_INT_BIT - MRB_FIXNUM_SHIFT);
 62 |     };
 63 |     struct {
 64 |       unsigned int sym_flag : MRB_SPECIAL_SHIFT;
 65 |       mrb_sym sym : MRB_SYMBOL_BITSIZE;
 66 |     };
 67 |     struct RBasic *bp;
 68 | #ifndef MRB_WITHOUT_FLOAT
 69 |     struct RFloat *fp;
 70 | #endif
 71 |     struct RCptr *vp;
 72 |   } value;
 73 |   unsigned long w;
 74 | } mrb_value;
 75 | 
 76 | MRB_API mrb_value mrb_word_boxing_cptr_value(struct mrb_state*, void*);
 77 | #ifndef MRB_WITHOUT_FLOAT
 78 | MRB_API mrb_value mrb_word_boxing_float_value(struct mrb_state*, mrb_float);
 79 | MRB_API mrb_value mrb_word_boxing_float_pool(struct mrb_state*, mrb_float);
 80 | #endif
 81 | 
 82 | #ifndef MRB_WITHOUT_FLOAT
 83 | #define mrb_float_pool(mrb,f) mrb_word_boxing_float_pool(mrb,f)
 84 | #endif
 85 | 
 86 | #define mrb_ptr(o)     (o).value.p
 87 | #define mrb_cptr(o)    (o).value.vp->p
 88 | #ifndef MRB_WITHOUT_FLOAT
 89 | #define mrb_float(o)   (o).value.fp->f
 90 | #endif
 91 | #define mrb_fixnum(o)  ((mrb_int)(o).value.i)
 92 | #define mrb_symbol(o)  (o).value.sym
 93 | 
 94 | static inline enum mrb_vtype
 95 | mrb_type(mrb_value o)
 96 | {
 97 |   switch (o.w) {
 98 |   case MRB_Qfalse:
 99 |   case MRB_Qnil:
100 |     return MRB_TT_FALSE;
101 |   case MRB_Qtrue:
102 |     return MRB_TT_TRUE;
103 |   case MRB_Qundef:
104 |     return MRB_TT_UNDEF;
105 |   }
106 |   if (o.value.i_flag == MRB_FIXNUM_FLAG) {
107 |     return MRB_TT_FIXNUM;
108 |   }
109 |   if (o.value.sym_flag == MRB_SYMBOL_FLAG) {
110 |     return MRB_TT_SYMBOL;
111 |   }
112 |   return o.value.bp->tt;
113 | }
114 | 
115 | #define mrb_bool(o)    ((o).w != MRB_Qnil && (o).w != MRB_Qfalse)
116 | #define mrb_fixnum_p(o) ((o).value.i_flag == MRB_FIXNUM_FLAG)
117 | #define mrb_undef_p(o) ((o).w == MRB_Qundef)
118 | #define mrb_nil_p(o)  ((o).w == MRB_Qnil)
119 | 
120 | #define BOXWORD_SET_VALUE(o, ttt, attr, v) do { \
121 |   switch (ttt) {\
122 |   case MRB_TT_FALSE:  (o).w = (v) ? MRB_Qfalse : MRB_Qnil; break;\
123 |   case MRB_TT_TRUE:   (o).w = MRB_Qtrue; break;\
124 |   case MRB_TT_UNDEF:  (o).w = MRB_Qundef; break;\
125 |   case MRB_TT_FIXNUM: (o).w = 0;(o).value.i_flag = MRB_FIXNUM_FLAG; (o).attr = (v); break;\
126 |   case MRB_TT_SYMBOL: (o).w = 0;(o).value.sym_flag = MRB_SYMBOL_FLAG; (o).attr = (v); break;\
127 |   default:            (o).w = 0; (o).attr = (v); if ((o).value.bp) (o).value.bp->tt = ttt; break;\
128 |   }\
129 | } while (0)
130 | 
131 | #ifndef MRB_WITHOUT_FLOAT
132 | #define SET_FLOAT_VALUE(mrb,r,v) r = mrb_word_boxing_float_value(mrb, v)
133 | #endif
134 | #define SET_CPTR_VALUE(mrb,r,v) r = mrb_word_boxing_cptr_value(mrb, v)
135 | #define SET_NIL_VALUE(r) BOXWORD_SET_VALUE(r, MRB_TT_FALSE, value.i, 0)
136 | #define SET_FALSE_VALUE(r) BOXWORD_SET_VALUE(r, MRB_TT_FALSE, value.i, 1)
137 | #define SET_TRUE_VALUE(r) BOXWORD_SET_VALUE(r, MRB_TT_TRUE, value.i, 1)
138 | #define SET_BOOL_VALUE(r,b) BOXWORD_SET_VALUE(r, b ? MRB_TT_TRUE : MRB_TT_FALSE, value.i, 1)
139 | #define SET_INT_VALUE(r,n) BOXWORD_SET_VALUE(r, MRB_TT_FIXNUM, value.i, (n))
140 | #define SET_SYM_VALUE(r,v) BOXWORD_SET_VALUE(r, MRB_TT_SYMBOL, value.sym, (v))
141 | #define SET_OBJ_VALUE(r,v) BOXWORD_SET_VALUE(r, (((struct RObject*)(v))->tt), value.p, (v))
142 | #define SET_UNDEF_VALUE(r) BOXWORD_SET_VALUE(r, MRB_TT_UNDEF, value.i, 0)
143 | 
144 | #endif  /* MRUBY_BOXING_WORD_H */
145 | 


--------------------------------------------------------------------------------
/tvos/MRuby.framework/Headers/mruby/class.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** mruby/class.h - Class class
 3 | **
 4 | ** See Copyright Notice in mruby.h
 5 | */
 6 | 
 7 | #ifndef MRUBY_CLASS_H
 8 | #define MRUBY_CLASS_H
 9 | 
10 | #include "common.h"
11 | 
12 | /**
13 |  * Class class
14 |  */
15 | MRB_BEGIN_DECL
16 | 
17 | struct RClass {
18 |   MRB_OBJECT_HEADER;
19 |   struct iv_tbl *iv;
20 |   struct kh_mt *mt;
21 |   struct RClass *super;
22 | };
23 | 
24 | #define mrb_class_ptr(v)    ((struct RClass*)(mrb_ptr(v)))
25 | 
26 | static inline struct RClass*
27 | mrb_class(mrb_state *mrb, mrb_value v)
28 | {
29 |   switch (mrb_type(v)) {
30 |   case MRB_TT_FALSE:
31 |     if (mrb_fixnum(v))
32 |       return mrb->false_class;
33 |     return mrb->nil_class;
34 |   case MRB_TT_TRUE:
35 |     return mrb->true_class;
36 |   case MRB_TT_SYMBOL:
37 |     return mrb->symbol_class;
38 |   case MRB_TT_FIXNUM:
39 |     return mrb->fixnum_class;
40 | #ifndef MRB_WITHOUT_FLOAT
41 |   case MRB_TT_FLOAT:
42 |     return mrb->float_class;
43 | #endif
44 |   case MRB_TT_CPTR:
45 |     return mrb->object_class;
46 |   case MRB_TT_ENV:
47 |     return NULL;
48 |   default:
49 |     return mrb_obj_ptr(v)->c;
50 |   }
51 | }
52 | 
53 | /* flags:
54 |    20: frozen
55 |    19: is_prepended
56 |    18: is_origin
57 |    17: is_inherited (used by method cache)
58 |    16: unused
59 |    0-15: instance type
60 | */
61 | #define MRB_FL_CLASS_IS_PREPENDED (1 << 19)
62 | #define MRB_FL_CLASS_IS_ORIGIN (1 << 18)
63 | #define MRB_CLASS_ORIGIN(c) do {\
64 |   if (c->flags & MRB_FL_CLASS_IS_PREPENDED) {\
65 |     c = c->super;\
66 |     while (!(c->flags & MRB_FL_CLASS_IS_ORIGIN)) {\
67 |       c = c->super;\
68 |     }\
69 |   }\
70 | } while (0)
71 | #define MRB_FL_CLASS_IS_INHERITED (1 << 17)
72 | #define MRB_INSTANCE_TT_MASK (0xFF)
73 | #define MRB_SET_INSTANCE_TT(c, tt) c->flags = ((c->flags & ~MRB_INSTANCE_TT_MASK) | (char)tt)
74 | #define MRB_INSTANCE_TT(c) (enum mrb_vtype)(c->flags & MRB_INSTANCE_TT_MASK)
75 | 
76 | MRB_API struct RClass* mrb_define_class_id(mrb_state*, mrb_sym, struct RClass*);
77 | MRB_API struct RClass* mrb_define_module_id(mrb_state*, mrb_sym);
78 | MRB_API struct RClass *mrb_vm_define_class(mrb_state*, mrb_value, mrb_value, mrb_sym);
79 | MRB_API struct RClass *mrb_vm_define_module(mrb_state*, mrb_value, mrb_sym);
80 | MRB_API void mrb_define_method_raw(mrb_state*, struct RClass*, mrb_sym, mrb_method_t);
81 | MRB_API void mrb_define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t func, mrb_aspec aspec);
82 | MRB_API void mrb_alias_method(mrb_state*, struct RClass *c, mrb_sym a, mrb_sym b);
83 | 
84 | MRB_API mrb_method_t mrb_method_search_vm(mrb_state*, struct RClass**, mrb_sym);
85 | MRB_API mrb_method_t mrb_method_search(mrb_state*, struct RClass*, mrb_sym);
86 | 
87 | MRB_API struct RClass* mrb_class_real(struct RClass* cl);
88 | 
89 | void mrb_class_name_class(mrb_state*, struct RClass*, struct RClass*, mrb_sym);
90 | mrb_value mrb_class_find_path(mrb_state*, struct RClass*);
91 | void mrb_gc_mark_mt(mrb_state*, struct RClass*);
92 | size_t mrb_gc_mark_mt_size(mrb_state*, struct RClass*);
93 | void mrb_gc_free_mt(mrb_state*, struct RClass*);
94 | 
95 | MRB_END_DECL
96 | 
97 | #endif  /* MRUBY_CLASS_H */
98 | 


--------------------------------------------------------------------------------
/tvos/MRuby.framework/Headers/mruby/common.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | **"common.h - mruby common platform definition"
 3 | **
 4 | ** See Copyright Notice in mruby.h
 5 | */
 6 | 
 7 | #ifndef MRUBY_COMMON_H
 8 | #define MRUBY_COMMON_H
 9 | 
10 | #ifdef __APPLE__
11 |   #ifndef __TARGETCONDITIONALS__
12 |   #include "TargetConditionals.h"
13 |   #endif
14 | #endif
15 | 
16 | #ifdef __cplusplus
17 | #ifdef MRB_ENABLE_CXX_ABI
18 | #define MRB_BEGIN_DECL
19 | #define MRB_END_DECL
20 | #else
21 | # define MRB_BEGIN_DECL extern "C" {
22 | # define MRB_END_DECL }
23 | #endif
24 | #else
25 | /** Start declarations in C mode */
26 | # define MRB_BEGIN_DECL
27 | /** End declarations in C mode */
28 | # define MRB_END_DECL
29 | #endif
30 | 
31 | /**
32 |  * Shared compiler macros
33 |  */
34 | MRB_BEGIN_DECL
35 | 
36 | /** Declare a function that never returns. */
37 | #if __STDC_VERSION__ >= 201112L
38 | # define mrb_noreturn _Noreturn
39 | #elif defined __GNUC__ && !defined __STRICT_ANSI__
40 | # define mrb_noreturn __attribute__((noreturn))
41 | #elif defined _MSC_VER
42 | # define mrb_noreturn __declspec(noreturn)
43 | #else
44 | # define mrb_noreturn
45 | #endif
46 | 
47 | /** Mark a function as deprecated. */
48 | #if defined __GNUC__ && !defined __STRICT_ANSI__
49 | # define mrb_deprecated __attribute__((deprecated))
50 | #elif defined _MSC_VER
51 | # define mrb_deprecated __declspec(deprecated)
52 | #else
53 | # define mrb_deprecated
54 | #endif
55 | 
56 | /** Declare a function as always inlined. */
57 | #if defined(_MSC_VER)
58 | # define MRB_INLINE static __inline
59 | #else
60 | # define MRB_INLINE static inline
61 | #endif
62 | 
63 | 
64 | /** Declare a public MRuby API function. */
65 | #if defined(MRB_BUILD_AS_DLL)
66 | #if defined(MRB_CORE) || defined(MRB_LIB)
67 | # define MRB_API __declspec(dllexport)
68 | #else
69 | # define MRB_API __declspec(dllimport)
70 | #endif
71 | #else
72 | # define MRB_API extern
73 | #endif
74 | 
75 | MRB_END_DECL
76 | 
77 | #endif  /* MRUBY_COMMON_H */
78 | 


--------------------------------------------------------------------------------
/tvos/MRuby.framework/Headers/mruby/compile.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** mruby/compile.h - mruby parser
  3 | **
  4 | ** See Copyright Notice in mruby.h
  5 | */
  6 | 
  7 | #ifndef MRUBY_COMPILE_H
  8 | #define MRUBY_COMPILE_H
  9 | 
 10 | #include "common.h"
 11 | 
 12 | /**
 13 |  * MRuby Compiler
 14 |  */
 15 | MRB_BEGIN_DECL
 16 | 
 17 | #include <mruby.h>
 18 | 
 19 | struct mrb_jmpbuf;
 20 | 
 21 | struct mrb_parser_state;
 22 | /* load context */
 23 | typedef struct mrbc_context {
 24 |   mrb_sym *syms;
 25 |   int slen;
 26 |   char *filename;
 27 |   short lineno;
 28 |   int (*partial_hook)(struct mrb_parser_state*);
 29 |   void *partial_data;
 30 |   struct RClass *target_class;
 31 |   mrb_bool capture_errors:1;
 32 |   mrb_bool dump_result:1;
 33 |   mrb_bool no_exec:1;
 34 |   mrb_bool keep_lv:1;
 35 |   mrb_bool no_optimize:1;
 36 |   mrb_bool on_eval:1;
 37 | 
 38 |   size_t parser_nerr;
 39 | } mrbc_context;
 40 | 
 41 | MRB_API mrbc_context* mrbc_context_new(mrb_state *mrb);
 42 | MRB_API void mrbc_context_free(mrb_state *mrb, mrbc_context *cxt);
 43 | MRB_API const char *mrbc_filename(mrb_state *mrb, mrbc_context *c, const char *s);
 44 | MRB_API void mrbc_partial_hook(mrb_state *mrb, mrbc_context *c, int (*partial_hook)(struct mrb_parser_state*), void*data);
 45 | 
 46 | /* AST node structure */
 47 | typedef struct mrb_ast_node {
 48 |   struct mrb_ast_node *car, *cdr;
 49 |   uint16_t lineno, filename_index;
 50 | } mrb_ast_node;
 51 | 
 52 | /* lexer states */
 53 | enum mrb_lex_state_enum {
 54 |   EXPR_BEG,                   /* ignore newline, +/- is a sign. */
 55 |   EXPR_END,                   /* newline significant, +/- is an operator. */
 56 |   EXPR_ENDARG,                /* ditto, and unbound braces. */
 57 |   EXPR_ENDFN,                 /* ditto, and unbound braces. */
 58 |   EXPR_ARG,                   /* newline significant, +/- is an operator. */
 59 |   EXPR_CMDARG,                /* newline significant, +/- is an operator. */
 60 |   EXPR_MID,                   /* newline significant, +/- is an operator. */
 61 |   EXPR_FNAME,                 /* ignore newline, no reserved words. */
 62 |   EXPR_DOT,                   /* right after '.' or '::', no reserved words. */
 63 |   EXPR_CLASS,                 /* immediate after 'class', no here document. */
 64 |   EXPR_VALUE,                 /* alike EXPR_BEG but label is disallowed. */
 65 |   EXPR_MAX_STATE
 66 | };
 67 | 
 68 | /* saved error message */
 69 | struct mrb_parser_message {
 70 |   int lineno;
 71 |   int column;
 72 |   char* message;
 73 | };
 74 | 
 75 | #define STR_FUNC_PARSING 0x01
 76 | #define STR_FUNC_EXPAND  0x02
 77 | #define STR_FUNC_REGEXP  0x04
 78 | #define STR_FUNC_WORD    0x08
 79 | #define STR_FUNC_SYMBOL  0x10
 80 | #define STR_FUNC_ARRAY   0x20
 81 | #define STR_FUNC_HEREDOC 0x40
 82 | #define STR_FUNC_XQUOTE  0x80
 83 | 
 84 | enum mrb_string_type {
 85 |   str_not_parsing  = (0),
 86 |   str_squote   = (STR_FUNC_PARSING),
 87 |   str_dquote   = (STR_FUNC_PARSING|STR_FUNC_EXPAND),
 88 |   str_regexp   = (STR_FUNC_PARSING|STR_FUNC_REGEXP|STR_FUNC_EXPAND),
 89 |   str_sword    = (STR_FUNC_PARSING|STR_FUNC_WORD|STR_FUNC_ARRAY),
 90 |   str_dword    = (STR_FUNC_PARSING|STR_FUNC_WORD|STR_FUNC_ARRAY|STR_FUNC_EXPAND),
 91 |   str_ssym     = (STR_FUNC_PARSING|STR_FUNC_SYMBOL),
 92 |   str_ssymbols = (STR_FUNC_PARSING|STR_FUNC_SYMBOL|STR_FUNC_ARRAY),
 93 |   str_dsymbols = (STR_FUNC_PARSING|STR_FUNC_SYMBOL|STR_FUNC_ARRAY|STR_FUNC_EXPAND),
 94 |   str_heredoc  = (STR_FUNC_PARSING|STR_FUNC_HEREDOC),
 95 |   str_xquote   = (STR_FUNC_PARSING|STR_FUNC_XQUOTE|STR_FUNC_EXPAND),
 96 | };
 97 | 
 98 | /* heredoc structure */
 99 | struct mrb_parser_heredoc_info {
100 |   mrb_bool allow_indent:1;
101 |   mrb_bool line_head:1;
102 |   enum mrb_string_type type;
103 |   const char *term;
104 |   int term_len;
105 |   mrb_ast_node *doc;
106 | };
107 | 
108 | #define MRB_PARSER_TOKBUF_MAX 65536
109 | #define MRB_PARSER_TOKBUF_SIZE 256
110 | 
111 | /* parser structure */
112 | struct mrb_parser_state {
113 |   mrb_state *mrb;
114 |   struct mrb_pool *pool;
115 |   mrb_ast_node *cells;
116 |   const char *s, *send;
117 | #ifndef MRB_DISABLE_STDIO
118 |   FILE *f;
119 | #endif
120 |   mrbc_context *cxt;
121 |   char const *filename;
122 |   int lineno;
123 |   int column;
124 | 
125 |   enum mrb_lex_state_enum lstate;
126 |   mrb_ast_node *lex_strterm; /* (type nest_level beg . end) */
127 | 
128 |   unsigned int cond_stack;
129 |   unsigned int cmdarg_stack;
130 |   int paren_nest;
131 |   int lpar_beg;
132 |   int in_def, in_single;
133 |   mrb_bool cmd_start:1;
134 |   mrb_ast_node *locals;
135 | 
136 |   mrb_ast_node *pb;
137 |   char *tokbuf;
138 |   char buf[MRB_PARSER_TOKBUF_SIZE];
139 |   int tidx;
140 |   int tsiz;
141 | 
142 |   mrb_ast_node *all_heredocs; /* list of mrb_parser_heredoc_info* */
143 |   mrb_ast_node *heredocs_from_nextline;
144 |   mrb_ast_node *parsing_heredoc;
145 |   mrb_ast_node *lex_strterm_before_heredoc;
146 | 
147 |   void *ylval;
148 | 
149 |   size_t nerr;
150 |   size_t nwarn;
151 |   mrb_ast_node *tree;
152 | 
153 |   mrb_bool no_optimize:1;
154 |   mrb_bool on_eval:1;
155 |   mrb_bool capture_errors:1;
156 |   struct mrb_parser_message error_buffer[10];
157 |   struct mrb_parser_message warn_buffer[10];
158 | 
159 |   mrb_sym* filename_table;
160 |   uint16_t filename_table_length;
161 |   uint16_t current_filename_index;
162 | 
163 |   struct mrb_jmpbuf* jmp;
164 | };
165 | 
166 | MRB_API struct mrb_parser_state* mrb_parser_new(mrb_state*);
167 | MRB_API void mrb_parser_free(struct mrb_parser_state*);
168 | MRB_API void mrb_parser_parse(struct mrb_parser_state*,mrbc_context*);
169 | 
170 | MRB_API void mrb_parser_set_filename(struct mrb_parser_state*, char const*);
171 | MRB_API char const* mrb_parser_get_filename(struct mrb_parser_state*, uint16_t idx);
172 | 
173 | /* utility functions */
174 | #ifndef MRB_DISABLE_STDIO
175 | MRB_API struct mrb_parser_state* mrb_parse_file(mrb_state*,FILE*,mrbc_context*);
176 | #endif
177 | MRB_API struct mrb_parser_state* mrb_parse_string(mrb_state*,const char*,mrbc_context*);
178 | MRB_API struct mrb_parser_state* mrb_parse_nstring(mrb_state*,const char*,size_t,mrbc_context*);
179 | MRB_API struct RProc* mrb_generate_code(mrb_state*, struct mrb_parser_state*);
180 | MRB_API mrb_value mrb_load_exec(mrb_state *mrb, struct mrb_parser_state *p, mrbc_context *c);
181 | 
182 | /* program load functions */
183 | #ifndef MRB_DISABLE_STDIO
184 | MRB_API mrb_value mrb_load_file(mrb_state*,FILE*);
185 | MRB_API mrb_value mrb_load_file_cxt(mrb_state*,FILE*, mrbc_context *cxt);
186 | #endif
187 | MRB_API mrb_value mrb_load_string(mrb_state *mrb, const char *s);
188 | MRB_API mrb_value mrb_load_nstring(mrb_state *mrb, const char *s, size_t len);
189 | MRB_API mrb_value mrb_load_string_cxt(mrb_state *mrb, const char *s, mrbc_context *cxt);
190 | MRB_API mrb_value mrb_load_nstring_cxt(mrb_state *mrb, const char *s, size_t len, mrbc_context *cxt);
191 | 
192 | /** @} */
193 | MRB_END_DECL
194 | 
195 | #endif /* MRUBY_COMPILE_H */
196 | 


--------------------------------------------------------------------------------
/tvos/MRuby.framework/Headers/mruby/data.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** mruby/data.h - Data class
 3 | **
 4 | ** See Copyright Notice in mruby.h
 5 | */
 6 | 
 7 | #ifndef MRUBY_DATA_H
 8 | #define MRUBY_DATA_H
 9 | 
10 | #include "common.h"
11 | 
12 | /**
13 |  * Custom C wrapped data.
14 |  *
15 |  * Defining Ruby wrappers around native objects.
16 |  */
17 | MRB_BEGIN_DECL
18 | 
19 | /**
20 |  * Custom data type description.
21 |  */
22 | typedef struct mrb_data_type {
23 |   /** data type name */
24 |   const char *struct_name;
25 | 
26 |   /** data type release function pointer */
27 |   void (*dfree)(mrb_state *mrb, void*);
28 | } mrb_data_type;
29 | 
30 | struct RData {
31 |   MRB_OBJECT_HEADER;
32 |   struct iv_tbl *iv;
33 |   const mrb_data_type *type;
34 |   void *data;
35 | };
36 | 
37 | MRB_API struct RData *mrb_data_object_alloc(mrb_state *mrb, struct RClass* klass, void *datap, const mrb_data_type *type);
38 | 
39 | #define Data_Wrap_Struct(mrb,klass,type,ptr)\
40 |   mrb_data_object_alloc(mrb,klass,ptr,type)
41 | 
42 | #define Data_Make_Struct(mrb,klass,strct,type,sval,data) do { \
43 |   sval = mrb_malloc(mrb, sizeof(strct));                     \
44 |   { static const strct zero = { 0 }; *sval = zero; };\
45 |   data = Data_Wrap_Struct(mrb,klass,type,sval);\
46 | } while (0)
47 | 
48 | #define RDATA(obj)         ((struct RData *)(mrb_ptr(obj)))
49 | #define DATA_PTR(d)        (RDATA(d)->data)
50 | #define DATA_TYPE(d)       (RDATA(d)->type)
51 | MRB_API void mrb_data_check_type(mrb_state *mrb, mrb_value, const mrb_data_type*);
52 | MRB_API void *mrb_data_get_ptr(mrb_state *mrb, mrb_value, const mrb_data_type*);
53 | #define DATA_GET_PTR(mrb,obj,dtype,type) (type*)mrb_data_get_ptr(mrb,obj,dtype)
54 | MRB_API void *mrb_data_check_get_ptr(mrb_state *mrb, mrb_value, const mrb_data_type*);
55 | #define DATA_CHECK_GET_PTR(mrb,obj,dtype,type) (type*)mrb_data_check_get_ptr(mrb,obj,dtype)
56 | 
57 | /* obsolete functions and macros */
58 | #define mrb_data_check_and_get(mrb,obj,dtype) mrb_data_get_ptr(mrb,obj,dtype)
59 | #define mrb_get_datatype(mrb,val,type) mrb_data_get_ptr(mrb, val, type)
60 | #define mrb_check_datatype(mrb,val,type) mrb_data_get_ptr(mrb, val, type)
61 | #define Data_Get_Struct(mrb,obj,type,sval) do {\
62 |   *(void**)&sval = mrb_data_get_ptr(mrb, obj, type); \
63 | } while (0)
64 | 
65 | static inline void
66 | mrb_data_init(mrb_value v, void *ptr, const mrb_data_type *type)
67 | {
68 |   mrb_assert(mrb_type(v) == MRB_TT_DATA);
69 |   DATA_PTR(v) = ptr;
70 |   DATA_TYPE(v) = type;
71 | }
72 | 
73 | MRB_END_DECL
74 | 
75 | #endif /* MRUBY_DATA_H */
76 | 


--------------------------------------------------------------------------------
/tvos/MRuby.framework/Headers/mruby/debug.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** mruby/debug.h - mruby debug info
 3 | **
 4 | ** See Copyright Notice in mruby.h
 5 | */
 6 | 
 7 | #ifndef MRUBY_DEBUG_H
 8 | #define MRUBY_DEBUG_H
 9 | 
10 | #include "common.h"
11 | 
12 | /**
13 |  * MRuby Debugging.
14 |  */
15 | MRB_BEGIN_DECL
16 | 
17 | typedef enum mrb_debug_line_type {
18 |   mrb_debug_line_ary = 0,
19 |   mrb_debug_line_flat_map = 1
20 | } mrb_debug_line_type;
21 | 
22 | typedef struct mrb_irep_debug_info_line {
23 |   uint32_t start_pos;
24 |   uint16_t line;
25 | } mrb_irep_debug_info_line;
26 | 
27 | typedef struct mrb_irep_debug_info_file {
28 |   uint32_t start_pos;
29 |   const char *filename;
30 |   mrb_sym filename_sym;
31 |   uint32_t line_entry_count;
32 |   mrb_debug_line_type line_type;
33 |   union {
34 |     void *ptr;
35 |     mrb_irep_debug_info_line *flat_map;
36 |     uint16_t *ary;
37 |   } lines;
38 | } mrb_irep_debug_info_file;
39 | 
40 | typedef struct mrb_irep_debug_info {
41 |   uint32_t pc_count;
42 |   uint16_t flen;
43 |   mrb_irep_debug_info_file **files;
44 | } mrb_irep_debug_info;
45 | 
46 | /*
47 |  * get line from irep's debug info and program counter
48 |  * @return returns NULL if not found
49 |  */
50 | MRB_API const char *mrb_debug_get_filename(mrb_irep *irep, ptrdiff_t pc);
51 | 
52 | /*
53 |  * get line from irep's debug info and program counter
54 |  * @return returns -1 if not found
55 |  */
56 | MRB_API int32_t mrb_debug_get_line(mrb_irep *irep, ptrdiff_t pc);
57 | 
58 | MRB_API mrb_irep_debug_info *mrb_debug_info_alloc(mrb_state *mrb, mrb_irep *irep);
59 | MRB_API mrb_irep_debug_info_file *mrb_debug_info_append_file(
60 |     mrb_state *mrb, mrb_irep_debug_info *info,
61 |     const char *filename, uint16_t *lines,
62 |     uint32_t start_pos, uint32_t end_pos);
63 | MRB_API void mrb_debug_info_free(mrb_state *mrb, mrb_irep_debug_info *d);
64 | 
65 | MRB_END_DECL
66 | 
67 | #endif /* MRUBY_DEBUG_H */
68 | 


--------------------------------------------------------------------------------
/tvos/MRuby.framework/Headers/mruby/dump.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** mruby/dump.h - mruby binary dumper (mrbc binary format)
  3 | **
  4 | ** See Copyright Notice in mruby.h
  5 | */
  6 | 
  7 | #ifndef MRUBY_DUMP_H
  8 | #define MRUBY_DUMP_H
  9 | 
 10 | #include <mruby.h>
 11 | #include <mruby/irep.h>
 12 | #include "common.h"
 13 | 
 14 | /**
 15 |  * Dumping compiled mruby script.
 16 |  */
 17 | MRB_BEGIN_DECL
 18 | 
 19 | #define DUMP_DEBUG_INFO 1
 20 | #define DUMP_ENDIAN_BIG 2
 21 | #define DUMP_ENDIAN_LIL 4
 22 | #define DUMP_ENDIAN_NAT 6
 23 | #define DUMP_ENDIAN_MASK 6
 24 | 
 25 | int mrb_dump_irep(mrb_state *mrb, mrb_irep *irep, uint8_t flags, uint8_t **bin, size_t *bin_size);
 26 | #ifndef MRB_DISABLE_STDIO
 27 | int mrb_dump_irep_binary(mrb_state*, mrb_irep*, uint8_t, FILE*);
 28 | int mrb_dump_irep_cfunc(mrb_state *mrb, mrb_irep*, uint8_t flags, FILE *f, const char *initname);
 29 | mrb_irep *mrb_read_irep_file(mrb_state*, FILE*);
 30 | MRB_API mrb_value mrb_load_irep_file(mrb_state*,FILE*);
 31 | MRB_API mrb_value mrb_load_irep_file_cxt(mrb_state*, FILE*, mrbc_context*);
 32 | #endif
 33 | MRB_API mrb_irep *mrb_read_irep(mrb_state*, const uint8_t*);
 34 | 
 35 | /* dump/load error code
 36 |  *
 37 |  * NOTE: MRB_DUMP_GENERAL_FAILURE is caused by
 38 |  * unspecified issues like malloc failed.
 39 |  */
 40 | #define MRB_DUMP_OK                     0
 41 | #define MRB_DUMP_GENERAL_FAILURE      (-1)
 42 | #define MRB_DUMP_WRITE_FAULT          (-2)
 43 | #define MRB_DUMP_READ_FAULT           (-3)
 44 | #define MRB_DUMP_CRC_ERROR            (-4)
 45 | #define MRB_DUMP_INVALID_FILE_HEADER  (-5)
 46 | #define MRB_DUMP_INVALID_IREP         (-6)
 47 | #define MRB_DUMP_INVALID_ARGUMENT     (-7)
 48 | 
 49 | /* null symbol length */
 50 | #define MRB_DUMP_NULL_SYM_LEN         0xFFFF
 51 | 
 52 | /* Rite Binary File header */
 53 | #define RITE_BINARY_IDENT              "RITE"
 54 | #define RITE_BINARY_IDENT_LIL          "ETIR"
 55 | #define RITE_BINARY_FORMAT_VER         "0005"
 56 | #define RITE_COMPILER_NAME             "MATZ"
 57 | #define RITE_COMPILER_VERSION          "0000"
 58 | 
 59 | #define RITE_VM_VER                    "0002"
 60 | 
 61 | #define RITE_BINARY_EOF                "END\0"
 62 | #define RITE_SECTION_IREP_IDENT        "IREP"
 63 | #define RITE_SECTION_LINENO_IDENT      "LINE"
 64 | #define RITE_SECTION_DEBUG_IDENT       "DBG\0"
 65 | #define RITE_SECTION_LV_IDENT          "LVAR"
 66 | 
 67 | #define MRB_DUMP_DEFAULT_STR_LEN      128
 68 | #define MRB_DUMP_ALIGNMENT            sizeof(uint32_t)
 69 | 
 70 | /* binary header */
 71 | struct rite_binary_header {
 72 |   uint8_t binary_ident[4];    /* Binary Identifier */
 73 |   uint8_t binary_version[4];  /* Binary Format Version */
 74 |   uint8_t binary_crc[2];      /* Binary CRC */
 75 |   uint8_t binary_size[4];     /* Binary Size */
 76 |   uint8_t compiler_name[4];   /* Compiler name */
 77 |   uint8_t compiler_version[4];
 78 | };
 79 | 
 80 | /* section header */
 81 | #define RITE_SECTION_HEADER \
 82 |   uint8_t section_ident[4]; \
 83 |   uint8_t section_size[4]
 84 | 
 85 | struct rite_section_header {
 86 |   RITE_SECTION_HEADER;
 87 | };
 88 | 
 89 | struct rite_section_irep_header {
 90 |   RITE_SECTION_HEADER;
 91 | 
 92 |   uint8_t rite_version[4];    /* Rite Instruction Specification Version */
 93 | };
 94 | 
 95 | struct rite_section_lineno_header {
 96 |   RITE_SECTION_HEADER;
 97 | };
 98 | 
 99 | struct rite_section_debug_header {
100 |   RITE_SECTION_HEADER;
101 | };
102 | 
103 | struct rite_section_lv_header {
104 |   RITE_SECTION_HEADER;
105 | };
106 | 
107 | #define RITE_LV_NULL_MARK              UINT16_MAX
108 | 
109 | struct rite_binary_footer {
110 |   RITE_SECTION_HEADER;
111 | };
112 | 
113 | static inline int
114 | bigendian_p()
115 | {
116 |   int i;
117 |   char *p;
118 | 
119 |   i = 1;
120 |   p = (char*)&i;
121 |   return p[0]?0:1;
122 | }
123 | 
124 | static inline size_t
125 | uint8_to_bin(uint8_t s, uint8_t *bin)
126 | {
127 |   *bin = s;
128 |   return sizeof(uint8_t);
129 | }
130 | 
131 | static inline size_t
132 | uint16_to_bin(uint16_t s, uint8_t *bin)
133 | {
134 |   *bin++ = (s >> 8) & 0xff;
135 |   *bin   = s & 0xff;
136 |   return sizeof(uint16_t);
137 | }
138 | 
139 | static inline size_t
140 | uint32_to_bin(uint32_t l, uint8_t *bin)
141 | {
142 |   *bin++ = (l >> 24) & 0xff;
143 |   *bin++ = (l >> 16) & 0xff;
144 |   *bin++ = (l >> 8) & 0xff;
145 |   *bin   = l & 0xff;
146 |   return sizeof(uint32_t);
147 | }
148 | 
149 | static inline size_t
150 | uint32l_to_bin(uint32_t l, uint8_t *bin)
151 | {
152 |   bin[3] = (l >> 24) & 0xff;
153 |   bin[2] = (l >> 16) & 0xff;
154 |   bin[1] = (l >> 8) & 0xff;
155 |   bin[0] = l & 0xff;
156 |   return sizeof(uint32_t);
157 | }
158 | 
159 | static inline uint32_t
160 | bin_to_uint32(const uint8_t *bin)
161 | {
162 |   return (uint32_t)bin[0] << 24 |
163 |          (uint32_t)bin[1] << 16 |
164 |          (uint32_t)bin[2] << 8  |
165 |          (uint32_t)bin[3];
166 | }
167 | 
168 | static inline uint32_t
169 | bin_to_uint32l(const uint8_t *bin)
170 | {
171 |   return (uint32_t)bin[3] << 24 |
172 |          (uint32_t)bin[2] << 16 |
173 |          (uint32_t)bin[1] << 8  |
174 |          (uint32_t)bin[0];
175 | }
176 | 
177 | static inline uint16_t
178 | bin_to_uint16(const uint8_t *bin)
179 | {
180 |   return (uint16_t)bin[0] << 8 |
181 |          (uint16_t)bin[1];
182 | }
183 | 
184 | static inline uint8_t
185 | bin_to_uint8(const uint8_t *bin)
186 | {
187 |   return (uint8_t)bin[0];
188 | }
189 | 
190 | MRB_END_DECL
191 | 
192 | /** @internal crc.c */
193 | uint16_t
194 | calc_crc_16_ccitt(const uint8_t *src, size_t nbytes, uint16_t crc);
195 | 
196 | #endif  /* MRUBY_DUMP_H */
197 | 


--------------------------------------------------------------------------------
/tvos/MRuby.framework/Headers/mruby/error.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** mruby/error.h - Exception class
 3 | **
 4 | ** See Copyright Notice in mruby.h
 5 | */
 6 | 
 7 | #ifndef MRUBY_ERROR_H
 8 | #define MRUBY_ERROR_H
 9 | 
10 | #include "common.h"
11 | 
12 | /**
13 |  * MRuby error handling.
14 |  */
15 | MRB_BEGIN_DECL
16 | 
17 | struct RException {
18 |   MRB_OBJECT_HEADER;
19 |   struct iv_tbl *iv;
20 | };
21 | 
22 | #define mrb_exc_ptr(v) ((struct RException*)mrb_ptr(v))
23 | 
24 | MRB_API void mrb_sys_fail(mrb_state *mrb, const char *mesg);
25 | MRB_API mrb_value mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str);
26 | #define mrb_exc_new_str_lit(mrb, c, lit) mrb_exc_new_str(mrb, c, mrb_str_new_lit(mrb, lit))
27 | MRB_API mrb_value mrb_make_exception(mrb_state *mrb, mrb_int argc, const mrb_value *argv);
28 | MRB_API mrb_value mrb_exc_backtrace(mrb_state *mrb, mrb_value exc);
29 | MRB_API mrb_value mrb_get_backtrace(mrb_state *mrb);
30 | MRB_API mrb_noreturn void mrb_no_method_error(mrb_state *mrb, mrb_sym id, mrb_value args, const char *fmt, ...);
31 | 
32 | /* declaration for fail method */
33 | MRB_API mrb_value mrb_f_raise(mrb_state*, mrb_value);
34 | 
35 | struct RBreak {
36 |   MRB_OBJECT_HEADER;
37 |   struct RProc *proc;
38 |   mrb_value val;
39 | };
40 | 
41 | /**
42 |  * Protect
43 |  *
44 |  * @mrbgem mruby-error
45 |  */
46 | MRB_API mrb_value mrb_protect(mrb_state *mrb, mrb_func_t body, mrb_value data, mrb_bool *state);
47 | 
48 | /**
49 |  * Ensure
50 |  *
51 |  * @mrbgem mruby-error
52 |  */
53 | MRB_API mrb_value mrb_ensure(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
54 |                              mrb_func_t ensure, mrb_value e_data);
55 | 
56 | /**
57 |  * Rescue
58 |  *
59 |  * @mrbgem mruby-error
60 |  */
61 | MRB_API mrb_value mrb_rescue(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
62 |                              mrb_func_t rescue, mrb_value r_data);
63 | 
64 | /**
65 |  * Rescue exception
66 |  *
67 |  * @mrbgem mruby-error
68 |  */
69 | MRB_API mrb_value mrb_rescue_exceptions(mrb_state *mrb, mrb_func_t body, mrb_value b_data,
70 |                                         mrb_func_t rescue, mrb_value r_data,
71 |                                         mrb_int len, struct RClass **classes);
72 | 
73 | MRB_END_DECL
74 | 
75 | #endif  /* MRUBY_ERROR_H */
76 | 


--------------------------------------------------------------------------------
/tvos/MRuby.framework/Headers/mruby/gc.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** mruby/gc.h - garbage collector for mruby
 3 | **
 4 | ** See Copyright Notice in mruby.h
 5 | */
 6 | 
 7 | #ifndef MRUBY_GC_H
 8 | #define MRUBY_GC_H
 9 | 
10 | #include "common.h"
11 | 
12 | /**
13 |  * Uncommon memory management stuffs.
14 |  */
15 | MRB_BEGIN_DECL
16 | 
17 | 
18 | struct mrb_state;
19 | 
20 | #define MRB_EACH_OBJ_OK 0
21 | #define MRB_EACH_OBJ_BREAK 1
22 | typedef int (mrb_each_object_callback)(struct mrb_state *mrb, struct RBasic *obj, void *data);
23 | void mrb_objspace_each_objects(struct mrb_state *mrb, mrb_each_object_callback *callback, void *data);
24 | MRB_API void mrb_free_context(struct mrb_state *mrb, struct mrb_context *c);
25 | 
26 | #ifndef MRB_GC_ARENA_SIZE
27 | #define MRB_GC_ARENA_SIZE 100
28 | #endif
29 | 
30 | typedef enum {
31 |   MRB_GC_STATE_ROOT = 0,
32 |   MRB_GC_STATE_MARK,
33 |   MRB_GC_STATE_SWEEP
34 | } mrb_gc_state;
35 | 
36 | /* Disable MSVC warning "C4200: nonstandard extension used: zero-sized array
37 |  * in struct/union" when in C++ mode */
38 | #ifdef _MSC_VER
39 | #pragma warning(push)
40 | #pragma warning(disable : 4200)
41 | #endif
42 | 
43 | typedef struct mrb_heap_page {
44 |   struct RBasic *freelist;
45 |   struct mrb_heap_page *prev;
46 |   struct mrb_heap_page *next;
47 |   struct mrb_heap_page *free_next;
48 |   struct mrb_heap_page *free_prev;
49 |   mrb_bool old:1;
50 |   void *objects[];
51 | } mrb_heap_page;
52 | 
53 | #ifdef _MSC_VER
54 | #pragma warning(pop)
55 | #endif
56 | 
57 | typedef struct mrb_gc {
58 |   mrb_heap_page *heaps;                /* heaps for GC */
59 |   mrb_heap_page *sweeps;
60 |   mrb_heap_page *free_heaps;
61 |   size_t live; /* count of live objects */
62 | #ifdef MRB_GC_FIXED_ARENA
63 |   struct RBasic *arena[MRB_GC_ARENA_SIZE]; /* GC protection array */
64 | #else
65 |   struct RBasic **arena;                   /* GC protection array */
66 |   int arena_capa;
67 | #endif
68 |   int arena_idx;
69 | 
70 |   mrb_gc_state state; /* state of gc */
71 |   int current_white_part; /* make white object by white_part */
72 |   struct RBasic *gray_list; /* list of gray objects to be traversed incrementally */
73 |   struct RBasic *atomic_gray_list; /* list of objects to be traversed atomically */
74 |   size_t live_after_mark;
75 |   size_t threshold;
76 |   int interval_ratio;
77 |   int step_ratio;
78 |   mrb_bool iterating     :1;
79 |   mrb_bool disabled      :1;
80 |   mrb_bool full          :1;
81 |   mrb_bool generational  :1;
82 |   mrb_bool out_of_memory :1;
83 |   size_t majorgc_old_threshold;
84 | } mrb_gc;
85 | 
86 | MRB_API mrb_bool
87 | mrb_object_dead_p(struct mrb_state *mrb, struct RBasic *object);
88 | 
89 | MRB_END_DECL
90 | 
91 | #endif  /* MRUBY_GC_H */
92 | 


--------------------------------------------------------------------------------
/tvos/MRuby.framework/Headers/mruby/hash.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** mruby/hash.h - Hash class
  3 | **
  4 | ** See Copyright Notice in mruby.h
  5 | */
  6 | 
  7 | #ifndef MRUBY_HASH_H
  8 | #define MRUBY_HASH_H
  9 | 
 10 | #include "common.h"
 11 | #include <mruby/khash.h>
 12 | 
 13 | /**
 14 |  * Hash class
 15 |  */
 16 | MRB_BEGIN_DECL
 17 | 
 18 | struct RHash {
 19 |   MRB_OBJECT_HEADER;
 20 |   struct iv_tbl *iv;
 21 |   struct htable *ht;
 22 | };
 23 | 
 24 | #define mrb_hash_ptr(v)    ((struct RHash*)(mrb_ptr(v)))
 25 | #define mrb_hash_value(p)  mrb_obj_value((void*)(p))
 26 | 
 27 | MRB_API mrb_value mrb_hash_new_capa(mrb_state*, mrb_int);
 28 | MRB_API mrb_value mrb_ensure_hash_type(mrb_state *mrb, mrb_value hash);
 29 | MRB_API mrb_value mrb_check_hash_type(mrb_state *mrb, mrb_value hash);
 30 | 
 31 | /*
 32 |  * Initializes a new hash.
 33 |  *
 34 |  * Equivalent to:
 35 |  *
 36 |  *      Hash.new
 37 |  *
 38 |  * @param mrb The mruby state reference.
 39 |  * @return The initialized hash.
 40 |  */
 41 | MRB_API mrb_value mrb_hash_new(mrb_state *mrb);
 42 | 
 43 | /*
 44 |  * Sets a keys and values to hashes.
 45 |  *
 46 |  * Equivalent to:
 47 |  *
 48 |  *      hash[key] = val
 49 |  *
 50 |  * @param mrb The mruby state reference.
 51 |  * @param hash The target hash.
 52 |  * @param key The key to set.
 53 |  * @param val The value to set.
 54 |  * @return The value.
 55 |  */
 56 | MRB_API void mrb_hash_set(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value val);
 57 | 
 58 | /*
 59 |  * Gets a value from a key. If the key is not found, the default of the
 60 |  * hash is used.
 61 |  *
 62 |  * Equivalent to:
 63 |  *
 64 |  *     hash[key]
 65 |  *
 66 |  * @param mrb The mruby state reference.
 67 |  * @param hash The target hash.
 68 |  * @param key The key to get.
 69 |  * @return The found value.
 70 |  */
 71 | MRB_API mrb_value mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key);
 72 | 
 73 | /*
 74 |  * Gets a value from a key. If the key is not found, the default parameter is
 75 |  * used.
 76 |  *
 77 |  * Equivalent to:
 78 |  *
 79 |  *     hash.key?(key) ? hash[key] : def
 80 |  *
 81 |  * @param mrb The mruby state reference.
 82 |  * @param hash The target hash.
 83 |  * @param key The key to get.
 84 |  * @param def The default value.
 85 |  * @return The found value.
 86 |  */
 87 | MRB_API mrb_value mrb_hash_fetch(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value def);
 88 | 
 89 | /*
 90 |  * Deletes hash key and value pair.
 91 |  *
 92 |  * Equivalent to:
 93 |  *
 94 |  *     hash.delete(key)
 95 |  *
 96 |  * @param mrb The mruby state reference.
 97 |  * @param hash The target hash.
 98 |  * @param key The key to delete.
 99 |  * @return The deleted value.
100 |  */
101 | MRB_API mrb_value mrb_hash_delete_key(mrb_state *mrb, mrb_value hash, mrb_value key);
102 | 
103 | /*
104 |  * Gets an array of keys.
105 |  *
106 |  * Equivalent to:
107 |  *
108 |  *     hash.keys
109 |  *
110 |  * @param mrb The mruby state reference.
111 |  * @param hash The target hash.
112 |  * @return An array with the keys of the hash.
113 |  */
114 | MRB_API mrb_value mrb_hash_keys(mrb_state *mrb, mrb_value hash);
115 | /*
116 |  * Check if the hash has the key.
117 |  *
118 |  * Equivalent to:
119 |  *
120 |  *     hash.key?(key)
121 |  *
122 |  * @param mrb The mruby state reference.
123 |  * @param hash The target hash.
124 |  * @param key The key to check existence.
125 |  * @return True if the hash has the key
126 |  */
127 | MRB_API mrb_bool mrb_hash_key_p(mrb_state *mrb, mrb_value hash, mrb_value key);
128 | 
129 | /*
130 |  * Check if the hash is empty
131 |  *
132 |  * Equivalent to:
133 |  *
134 |  *     hash.empty?
135 |  *
136 |  * @param mrb The mruby state reference.
137 |  * @param self The target hash.
138 |  * @return True if the hash is empty, false otherwise.
139 |  */
140 | MRB_API mrb_bool mrb_hash_empty_p(mrb_state *mrb, mrb_value self);
141 | 
142 | /*
143 |  * Gets an array of values.
144 |  *
145 |  * Equivalent to:
146 |  *
147 |  *     hash.values
148 |  *
149 |  * @param mrb The mruby state reference.
150 |  * @param hash The target hash.
151 |  * @return An array with the values of the hash.
152 |  */
153 | MRB_API mrb_value mrb_hash_values(mrb_state *mrb, mrb_value hash);
154 | 
155 | /*
156 |  * Clears the hash.
157 |  *
158 |  * Equivalent to:
159 |  *
160 |  *     hash.clear
161 |  *
162 |  * @param mrb The mruby state reference.
163 |  * @param hash The target hash.
164 |  * @return The hash
165 |  */
166 | MRB_API mrb_value mrb_hash_clear(mrb_state *mrb, mrb_value hash);
167 | 
168 | /*
169 |  * Copies the hash.
170 |  *
171 |  *
172 |  * @param mrb The mruby state reference.
173 |  * @param hash The target hash.
174 |  * @return The copy of the hash
175 |  */
176 | MRB_API mrb_value mrb_hash_dup(mrb_state *mrb, mrb_value hash);
177 | 
178 | /*
179 |  * Merges two hashes. The first hash will be modified by the
180 |  * second hash.
181 |  *
182 |  * @param mrb The mruby state reference.
183 |  * @param hash1 The target hash.
184 |  * @param hash2 Updating hash
185 |  */
186 | MRB_API void mrb_hash_merge(mrb_state *mrb, mrb_value hash1, mrb_value hash2);
187 | 
188 | /* declaration of struct kh_ht */
189 | /* be careful when you touch the internal */
190 | typedef struct {
191 |   mrb_value v;
192 |   mrb_int n;
193 | } mrb_hash_value;
194 | 
195 | KHASH_DECLARE(ht, mrb_value, mrb_hash_value, TRUE)
196 | 
197 | /* RHASH_TBL allocates st_table if not available. */
198 | #define RHASH(obj)   ((struct RHash*)(mrb_ptr(obj)))
199 | #define RHASH_TBL(h)          (RHASH(h)->ht)
200 | #define RHASH_IFNONE(h)       mrb_iv_get(mrb, (h), mrb_intern_lit(mrb, "ifnone"))
201 | #define RHASH_PROCDEFAULT(h)  RHASH_IFNONE(h)
202 | 
203 | #define MRB_HASH_DEFAULT      1
204 | #define MRB_HASH_PROC_DEFAULT 2
205 | #define MRB_RHASH_DEFAULT_P(h) (RHASH(h)->flags & MRB_HASH_DEFAULT)
206 | #define MRB_RHASH_PROCDEFAULT_P(h) (RHASH(h)->flags & MRB_HASH_PROC_DEFAULT)
207 | 
208 | /* GC functions */
209 | void mrb_gc_mark_hash(mrb_state*, struct RHash*);
210 | size_t mrb_gc_mark_hash_size(mrb_state*, struct RHash*);
211 | void mrb_gc_free_hash(mrb_state*, struct RHash*);
212 | 
213 | MRB_END_DECL
214 | 
215 | #endif  /* MRUBY_HASH_H */
216 | 


--------------------------------------------------------------------------------
/tvos/MRuby.framework/Headers/mruby/irep.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** mruby/irep.h - mrb_irep structure
 3 | **
 4 | ** See Copyright Notice in mruby.h
 5 | */
 6 | 
 7 | #ifndef MRUBY_IREP_H
 8 | #define MRUBY_IREP_H
 9 | 
10 | #include "common.h"
11 | #include <mruby/compile.h>
12 | 
13 | /**
14 |  * Compiled mruby scripts.
15 |  */
16 | MRB_BEGIN_DECL
17 | 
18 | enum irep_pool_type {
19 |   IREP_TT_STRING,
20 |   IREP_TT_FIXNUM,
21 |   IREP_TT_FLOAT,
22 | };
23 | 
24 | struct mrb_locals {
25 |   mrb_sym name;
26 |   uint16_t r;
27 | };
28 | 
29 | /* Program data array struct */
30 | typedef struct mrb_irep {
31 |   uint16_t nlocals;        /* Number of local variables */
32 |   uint16_t nregs;          /* Number of register variables */
33 |   uint8_t flags;
34 | 
35 |   mrb_code *iseq;
36 |   mrb_value *pool;
37 |   mrb_sym *syms;
38 |   struct mrb_irep **reps;
39 | 
40 |   struct mrb_locals *lv;
41 |   /* debug info */
42 |   struct mrb_irep_debug_info* debug_info;
43 | 
44 |   uint16_t ilen, plen, slen, rlen;
45 |   uint32_t refcnt;
46 | } mrb_irep;
47 | 
48 | #define MRB_ISEQ_NO_FREE 1
49 | 
50 | MRB_API mrb_irep *mrb_add_irep(mrb_state *mrb);
51 | 
52 | /* @param [const uint8_t*] irep code, expected as a literal */
53 | MRB_API mrb_value mrb_load_irep(mrb_state*, const uint8_t*);
54 | 
55 | /* @param [const uint8_t*] irep code, expected as a literal */
56 | MRB_API mrb_value mrb_load_irep_cxt(mrb_state*, const uint8_t*, mrbc_context*);
57 | 
58 | void mrb_irep_free(mrb_state*, struct mrb_irep*);
59 | void mrb_irep_incref(mrb_state*, struct mrb_irep*);
60 | void mrb_irep_decref(mrb_state*, struct mrb_irep*);
61 | void mrb_irep_cutref(mrb_state*, struct mrb_irep*);
62 | void mrb_irep_remove_lv(mrb_state *mrb, mrb_irep *irep);
63 | 
64 | struct mrb_insn_data {
65 |   uint8_t insn;
66 |   uint16_t a;
67 |   uint16_t b;
68 |   uint8_t c;
69 | };
70 | 
71 | struct mrb_insn_data mrb_decode_insn(mrb_code *pc);
72 | 
73 | MRB_END_DECL
74 | 
75 | #endif  /* MRUBY_IREP_H */
76 | 


--------------------------------------------------------------------------------
/tvos/MRuby.framework/Headers/mruby/istruct.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** mruby/istruct.h - Inline structures
 3 | **
 4 | ** See Copyright Notice in mruby.h
 5 | */
 6 | 
 7 | #ifndef MRUBY_ISTRUCT_H
 8 | #define MRUBY_ISTRUCT_H
 9 | 
10 | #include "common.h"
11 | #include <string.h>
12 | 
13 | /**
14 |  * Inline structures that fit in RVALUE
15 |  *
16 |  * They cannot have finalizer, and cannot have instance variables.
17 |  */
18 | MRB_BEGIN_DECL
19 | 
20 | #define ISTRUCT_DATA_SIZE (sizeof(void*) * 3)
21 | 
22 | struct RIstruct {
23 |   MRB_OBJECT_HEADER;
24 |   char inline_data[ISTRUCT_DATA_SIZE];
25 | };
26 | 
27 | #define RISTRUCT(obj)         ((struct RIstruct*)(mrb_ptr(obj)))
28 | #define ISTRUCT_PTR(obj)      (RISTRUCT(obj)->inline_data)
29 | 
30 | MRB_INLINE mrb_int mrb_istruct_size()
31 | {
32 |   return ISTRUCT_DATA_SIZE;
33 | }
34 | 
35 | MRB_INLINE void* mrb_istruct_ptr(mrb_value object)
36 | {
37 |   return ISTRUCT_PTR(object);
38 | }
39 | 
40 | MRB_INLINE void mrb_istruct_copy(mrb_value dest, mrb_value src)
41 | {
42 |   memcpy(ISTRUCT_PTR(dest), ISTRUCT_PTR(src), ISTRUCT_DATA_SIZE);
43 | }
44 | 
45 | MRB_END_DECL
46 | 
47 | #endif /* MRUBY_ISTRUCT_H */
48 | 


--------------------------------------------------------------------------------
/tvos/MRuby.framework/Headers/mruby/numeric.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** mruby/numeric.h - Numeric, Integer, Float, Fixnum class
  3 | **
  4 | ** See Copyright Notice in mruby.h
  5 | */
  6 | 
  7 | #ifndef MRUBY_NUMERIC_H
  8 | #define MRUBY_NUMERIC_H
  9 | 
 10 | #include "common.h"
 11 | 
 12 | /**
 13 |  * Numeric class and it's sub-classes.
 14 |  *
 15 |  * Integer, Float and Fixnum
 16 |  */
 17 | MRB_BEGIN_DECL
 18 | 
 19 | #define TYPED_POSFIXABLE(f,t) ((f) <= (t)MRB_INT_MAX)
 20 | #define TYPED_NEGFIXABLE(f,t) ((f) >= (t)MRB_INT_MIN)
 21 | #define TYPED_FIXABLE(f,t) (TYPED_POSFIXABLE(f,t) && TYPED_NEGFIXABLE(f,t))
 22 | #define POSFIXABLE(f) TYPED_POSFIXABLE(f,mrb_int)
 23 | #define NEGFIXABLE(f) TYPED_NEGFIXABLE(f,mrb_int)
 24 | #define FIXABLE(f) TYPED_FIXABLE(f,mrb_int)
 25 | #ifndef MRB_WITHOUT_FLOAT
 26 | #define FIXABLE_FLOAT(f) TYPED_FIXABLE(f,double)
 27 | #endif
 28 | 
 29 | #ifndef MRB_WITHOUT_FLOAT
 30 | MRB_API mrb_value mrb_flo_to_fixnum(mrb_state *mrb, mrb_value val);
 31 | #endif
 32 | MRB_API mrb_value mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, mrb_int base);
 33 | /* ArgumentError if format string doesn't match /%(\.[0-9]+)?[aAeEfFgG]/ */
 34 | #ifndef MRB_WITHOUT_FLOAT
 35 | MRB_API mrb_value mrb_float_to_str(mrb_state *mrb, mrb_value x, const char *fmt);
 36 | MRB_API mrb_float mrb_to_flo(mrb_state *mrb, mrb_value x);
 37 | #endif
 38 | 
 39 | mrb_value mrb_fixnum_plus(mrb_state *mrb, mrb_value x, mrb_value y);
 40 | mrb_value mrb_fixnum_minus(mrb_state *mrb, mrb_value x, mrb_value y);
 41 | mrb_value mrb_fixnum_mul(mrb_state *mrb, mrb_value x, mrb_value y);
 42 | mrb_value mrb_num_div(mrb_state *mrb, mrb_value x, mrb_value y);
 43 | 
 44 | #ifndef __has_builtin
 45 |   #define __has_builtin(x) 0
 46 | #endif
 47 | 
 48 | #if (defined(__GNUC__) && __GNUC__ >= 5) ||   \
 49 |     (__has_builtin(__builtin_add_overflow) && \
 50 |      __has_builtin(__builtin_sub_overflow) && \
 51 |      __has_builtin(__builtin_mul_overflow))
 52 | # define MRB_HAVE_TYPE_GENERIC_CHECKED_ARITHMETIC_BUILTINS
 53 | #endif
 54 | 
 55 | /*
 56 | // Clang 3.8 and 3.9 have problem compiling mruby in 32-bit mode, when MRB_INT64 is set
 57 | // because of missing __mulodi4 and similar functions in its runtime. We need to use custom
 58 | // implementation for them.
 59 | */
 60 | #ifdef MRB_HAVE_TYPE_GENERIC_CHECKED_ARITHMETIC_BUILTINS
 61 | #if defined(__clang__) && (__clang_major__ == 3) && (__clang_minor__ >= 8) && \
 62 |     defined(MRB_32BIT) && defined(MRB_INT64)
 63 | #undef MRB_HAVE_TYPE_GENERIC_CHECKED_ARITHMETIC_BUILTINS
 64 | #endif
 65 | #endif
 66 | 
 67 | #ifdef MRB_HAVE_TYPE_GENERIC_CHECKED_ARITHMETIC_BUILTINS
 68 | 
 69 | #ifndef MRB_WORD_BOXING
 70 | # define WBCHK(x) 0
 71 | #else
 72 | # define WBCHK(x) !FIXABLE(x)
 73 | #endif
 74 | 
 75 | static inline mrb_bool
 76 | mrb_int_add_overflow(mrb_int augend, mrb_int addend, mrb_int *sum)
 77 | {
 78 |   return __builtin_add_overflow(augend, addend, sum) || WBCHK(*sum);
 79 | }
 80 | 
 81 | static inline mrb_bool
 82 | mrb_int_sub_overflow(mrb_int minuend, mrb_int subtrahend, mrb_int *difference)
 83 | {
 84 |   return __builtin_sub_overflow(minuend, subtrahend, difference) || WBCHK(*difference);
 85 | }
 86 | 
 87 | static inline mrb_bool
 88 | mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product)
 89 | {
 90 |   return __builtin_mul_overflow(multiplier, multiplicand, product) || WBCHK(*product);
 91 | }
 92 | 
 93 | #undef WBCHK
 94 | 
 95 | #else
 96 | 
 97 | #define MRB_UINT_MAKE2(n) uint ## n ## _t
 98 | #define MRB_UINT_MAKE(n) MRB_UINT_MAKE2(n)
 99 | #define mrb_uint MRB_UINT_MAKE(MRB_INT_BIT)
100 | 
101 | #define MRB_INT_OVERFLOW_MASK ((mrb_uint)1 << (MRB_INT_BIT - 1 - MRB_FIXNUM_SHIFT))
102 | 
103 | static inline mrb_bool
104 | mrb_int_add_overflow(mrb_int augend, mrb_int addend, mrb_int *sum)
105 | {
106 |   mrb_uint x = (mrb_uint)augend;
107 |   mrb_uint y = (mrb_uint)addend;
108 |   mrb_uint z = (mrb_uint)(x + y);
109 |   *sum = (mrb_int)z;
110 |   return !!(((x ^ z) & (y ^ z)) & MRB_INT_OVERFLOW_MASK);
111 | }
112 | 
113 | static inline mrb_bool
114 | mrb_int_sub_overflow(mrb_int minuend, mrb_int subtrahend, mrb_int *difference)
115 | {
116 |   mrb_uint x = (mrb_uint)minuend;
117 |   mrb_uint y = (mrb_uint)subtrahend;
118 |   mrb_uint z = (mrb_uint)(x - y);
119 |   *difference = (mrb_int)z;
120 |   return !!(((x ^ z) & (~y ^ z)) & MRB_INT_OVERFLOW_MASK);
121 | }
122 | 
123 | static inline mrb_bool
124 | mrb_int_mul_overflow(mrb_int multiplier, mrb_int multiplicand, mrb_int *product)
125 | {
126 | #if MRB_INT_BIT == 32
127 |   int64_t n = (int64_t)multiplier * multiplicand;
128 |   *product = (mrb_int)n;
129 |   return !FIXABLE(n);
130 | #else
131 |   if (multiplier > 0) {
132 |     if (multiplicand > 0) {
133 |       if (multiplier > MRB_INT_MAX / multiplicand) return TRUE;
134 |     }
135 |     else {
136 |       if (multiplicand < MRB_INT_MAX / multiplier) return TRUE;
137 |     }
138 |   }
139 |   else {
140 |     if (multiplicand > 0) {
141 |       if (multiplier < MRB_INT_MAX / multiplicand) return TRUE;
142 |     }
143 |     else {
144 |       if (multiplier != 0 && multiplicand < MRB_INT_MAX / multiplier) return TRUE;
145 |     }
146 |   }
147 |   *product = multiplier * multiplicand;
148 |   return FALSE;
149 | #endif
150 | }
151 | 
152 | #undef MRB_INT_OVERFLOW_MASK
153 | #undef mrb_uint
154 | #undef MRB_UINT_MAKE
155 | #undef MRB_UINT_MAKE2
156 | 
157 | #endif
158 | 
159 | MRB_END_DECL
160 | 
161 | #endif  /* MRUBY_NUMERIC_H */
162 | 


--------------------------------------------------------------------------------
/tvos/MRuby.framework/Headers/mruby/object.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** mruby/object.h - mruby object definition
 3 | **
 4 | ** See Copyright Notice in mruby.h
 5 | */
 6 | 
 7 | #ifndef MRUBY_OBJECT_H
 8 | #define MRUBY_OBJECT_H
 9 | 
10 | #define MRB_OBJECT_HEADER \
11 |   enum mrb_vtype tt:8;\
12 |   uint32_t color:3;\
13 |   uint32_t flags:21;\
14 |   struct RClass *c;\
15 |   struct RBasic *gcnext
16 | 
17 | #define MRB_FLAG_TEST(obj, flag) ((obj)->flags & flag)
18 | 
19 | 
20 | struct RBasic {
21 |   MRB_OBJECT_HEADER;
22 | };
23 | #define mrb_basic_ptr(v) ((struct RBasic*)(mrb_ptr(v)))
24 | 
25 | #define MRB_FL_OBJ_IS_FROZEN (1 << 20)
26 | #define MRB_FROZEN_P(o) ((o)->flags & MRB_FL_OBJ_IS_FROZEN)
27 | #define MRB_SET_FROZEN_FLAG(o) ((o)->flags |= MRB_FL_OBJ_IS_FROZEN)
28 | #define MRB_UNSET_FROZEN_FLAG(o) ((o)->flags &= ~MRB_FL_OBJ_IS_FROZEN)
29 | 
30 | struct RObject {
31 |   MRB_OBJECT_HEADER;
32 |   struct iv_tbl *iv;
33 | };
34 | #define mrb_obj_ptr(v)   ((struct RObject*)(mrb_ptr(v)))
35 | 
36 | #define mrb_immediate_p(x) (mrb_type(x) < MRB_TT_HAS_BASIC)
37 | #define mrb_special_const_p(x) mrb_immediate_p(x)
38 | 
39 | struct RFiber {
40 |   MRB_OBJECT_HEADER;
41 |   struct mrb_context *cxt;
42 | };
43 | 
44 | #endif  /* MRUBY_OBJECT_H */
45 | 


--------------------------------------------------------------------------------
/tvos/MRuby.framework/Headers/mruby/opcode.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** mruby/opcode.h - RiteVM operation codes
 3 | **
 4 | ** See Copyright Notice in mruby.h
 5 | */
 6 | 
 7 | #ifndef MRUBY_OPCODE_H
 8 | #define MRUBY_OPCODE_H
 9 | 
10 | enum mrb_insn {
11 | #define OPCODE(x,_) OP_ ## x,
12 | #include "mruby/ops.h"
13 | #undef OPCODE
14 | };
15 | 
16 | #define OP_L_STRICT  1
17 | #define OP_L_CAPTURE 2
18 | #define OP_L_METHOD  OP_L_STRICT
19 | #define OP_L_LAMBDA  (OP_L_STRICT|OP_L_CAPTURE)
20 | #define OP_L_BLOCK   OP_L_CAPTURE
21 | 
22 | #define OP_R_NORMAL 0
23 | #define OP_R_BREAK  1
24 | #define OP_R_RETURN 2
25 | 
26 | #define PEEK_B(pc) (*(pc))
27 | #define PEEK_S(pc) ((pc)[0]<<8|(pc)[1])
28 | #define PEEK_W(pc) ((pc)[0]<<16|(pc)[1]<<8|(pc)[2])
29 | 
30 | #define READ_B() PEEK_B(pc++)
31 | #define READ_S() (pc+=2, PEEK_S(pc-2))
32 | #define READ_W() (pc+=3, PEEK_W(pc-3))
33 | 
34 | #define FETCH_Z() /* nothing */
35 | #define FETCH_B() do {a=READ_B();} while (0)
36 | #define FETCH_BB() do {a=READ_B(); b=READ_B();} while (0)
37 | #define FETCH_BBB() do {a=READ_B(); b=READ_B(); c=READ_B();} while (0)
38 | #define FETCH_BS() do {a=READ_B(); b=READ_S();} while (0)
39 | #define FETCH_S() do {a=READ_S();} while (0)
40 | #define FETCH_W() do {a=READ_W();} while (0)
41 | 
42 | /* with OP_EXT1 (1st 16bit) */
43 | #define FETCH_Z_1() FETCH_Z()
44 | #define FETCH_B_1() FETCH_S()
45 | #define FETCH_BB_1() do {a=READ_S(); b=READ_B();} while (0)
46 | #define FETCH_BBB_1() do {a=READ_S(); b=READ_B(); c=READ_B();} while (0)
47 | #define FETCH_BS_1() do {a=READ_S(); b=READ_S();} while (0)
48 | #define FETCH_S_1() FETCH_S()
49 | #define FETCH_W_1() FETCH_W()
50 | 
51 | /* with OP_EXT2 (2nd 16bit) */
52 | #define FETCH_Z_2() FETCH_Z()
53 | #define FETCH_B_2() FETCH_B()
54 | #define FETCH_BB_2() do {a=READ_B(); b=READ_S();} while (0)
55 | #define FETCH_BBB_2() do {a=READ_B(); b=READ_S(); c=READ_B();} while (0)
56 | #define FETCH_BS_2() FETCH_BS()
57 | #define FETCH_S_2() FETCH_S()
58 | #define FETCH_W_2() FETCH_W()
59 | 
60 | /* with OP_EXT3 (1st & 2nd 16bit) */
61 | #define FETCH_Z_3() FETCH_Z()
62 | #define FETCH_B_3() FETCH_B()
63 | #define FETCH_BB_3() do {a=READ_S(); b=READ_S();} while (0)
64 | #define FETCH_BBB_3() do {a=READ_S(); b=READ_S(); c=READ_B();} while (0)
65 | #define FETCH_BS_3() do {a=READ_S(); b=READ_S();} while (0)
66 | #define FETCH_S_3() FETCH_S()
67 | #define FETCH_W_3() FETCH_W()
68 | 
69 | #endif  /* MRUBY_OPCODE_H */
70 | 


--------------------------------------------------------------------------------
/tvos/MRuby.framework/Headers/mruby/ops.h:
--------------------------------------------------------------------------------
  1 | /* operand types:
  2 |    + Z: no operand (Z,Z,Z,Z)
  3 |    + B: 8bit (B,S,B,B)
  4 |    + BB: 8+8bit (BB,SB,BS,SS)
  5 |    + BBB: 8+8+8bit (BBB,SBB,BSB,SSB)
  6 |    + BS: 8+16bit (BS,SS,BS,BS)
  7 |    + S: 16bit (S,S,S,S)
  8 |    + W: 24bit (W,W,W,W)
  9 | */
 10 | 
 11 | /*-----------------------------------------------------------------------
 12 | operation code    operands      semantics
 13 | ------------------------------------------------------------------------*/
 14 | OPCODE(NOP,        Z)        /* no operation */
 15 | OPCODE(MOVE,       BB)       /* R(a) = R(b) */
 16 | OPCODE(LOADL,      BB)       /* R(a) = Pool(b) */
 17 | OPCODE(LOADI,      BB)       /* R(a) = mrb_int(b) */
 18 | OPCODE(LOADINEG,   BB)       /* R(a) = mrb_int(-b) */
 19 | OPCODE(LOADI__1,   B)        /* R(a) = mrb_int(-1) */
 20 | OPCODE(LOADI_0,    B)        /* R(a) = mrb_int(0) */
 21 | OPCODE(LOADI_1,    B)        /* R(a) = mrb_int(1) */
 22 | OPCODE(LOADI_2,    B)        /* R(a) = mrb_int(2) */
 23 | OPCODE(LOADI_3,    B)        /* R(a) = mrb_int(3) */
 24 | OPCODE(LOADI_4,    B)        /* R(a) = mrb_int(4) */
 25 | OPCODE(LOADI_5,    B)        /* R(a) = mrb_int(5) */
 26 | OPCODE(LOADI_6,    B)        /* R(a) = mrb_int(6) */
 27 | OPCODE(LOADI_7,    B)        /* R(a) = mrb_int(7) */
 28 | OPCODE(LOADSYM,    BB)       /* R(a) = Syms(b) */
 29 | OPCODE(LOADNIL,    B)        /* R(a) = nil */
 30 | OPCODE(LOADSELF,   B)        /* R(a) = self */
 31 | OPCODE(LOADT,      B)        /* R(a) = true */
 32 | OPCODE(LOADF,      B)        /* R(a) = false */
 33 | OPCODE(GETGV,      BB)       /* R(a) = getglobal(Syms(b)) */
 34 | OPCODE(SETGV,      BB)       /* setglobal(Syms(b), R(a)) */
 35 | OPCODE(GETSV,      BB)       /* R(a) = Special[Syms(b)] */
 36 | OPCODE(SETSV,      BB)       /* Special[Syms(b)] = R(a) */
 37 | OPCODE(GETIV,      BB)       /* R(a) = ivget(Syms(b)) */
 38 | OPCODE(SETIV,      BB)       /* ivset(Syms(b),R(a)) */
 39 | OPCODE(GETCV,      BB)       /* R(a) = cvget(Syms(b)) */
 40 | OPCODE(SETCV,      BB)       /* cvset(Syms(b),R(a)) */
 41 | OPCODE(GETCONST,   BB)       /* R(a) = constget(Syms(b)) */
 42 | OPCODE(SETCONST,   BB)       /* constset(Syms(b),R(a)) */
 43 | OPCODE(GETMCNST,   BB)       /* R(a) = R(a)::Syms(b) */
 44 | OPCODE(SETMCNST,   BB)       /* R(a+1)::Syms(b) = R(a) */
 45 | OPCODE(GETUPVAR,   BBB)      /* R(a) = uvget(b,c) */
 46 | OPCODE(SETUPVAR,   BBB)      /* uvset(b,c,R(a)) */
 47 | OPCODE(JMP,        S)        /* pc=a */
 48 | OPCODE(JMPIF,      BS)       /* if R(b) pc=a */
 49 | OPCODE(JMPNOT,     BS)       /* if !R(b) pc=a */
 50 | OPCODE(JMPNIL,     BS)       /* if R(b)==nil pc=a */
 51 | OPCODE(ONERR,      S)        /* rescue_push(a) */
 52 | OPCODE(EXCEPT,     B)        /* R(a) = exc */
 53 | OPCODE(RESCUE,     BB)       /* R(b) = R(a).isa?(R(b)) */
 54 | OPCODE(POPERR,     B)        /* a.times{rescue_pop()} */
 55 | OPCODE(RAISE,      B)        /* raise(R(a)) */
 56 | OPCODE(EPUSH,      B)        /* ensure_push(SEQ[a]) */
 57 | OPCODE(EPOP,       B)        /* A.times{ensure_pop().call} */
 58 | OPCODE(SENDV,      BB)       /* R(a) = call(R(a),Syms(b),*R(a+1)) */
 59 | OPCODE(SENDVB,     BB)       /* R(a) = call(R(a),Syms(b),*R(a+1),&R(a+2)) */
 60 | OPCODE(SEND,       BBB)      /* R(a) = call(R(a),Syms(b),R(a+1),...,R(a+c)) */
 61 | OPCODE(SENDB,      BBB)      /* R(a) = call(R(a),Syms(Bx),R(a+1),...,R(a+c),&R(a+c+1)) */
 62 | OPCODE(CALL,       Z)        /* R(0) = self.call(frame.argc, frame.argv) */
 63 | OPCODE(SUPER,      BB)       /* R(a) = super(R(a+1),... ,R(a+b+1)) */
 64 | OPCODE(ARGARY,     BS)       /* R(a) = argument array (16=m5:r1:m5:d1:lv4) */
 65 | OPCODE(ENTER,      W)        /* arg setup according to flags (23=m5:o5:r1:m5:k5:d1:b1) */
 66 | OPCODE(KEY_P,      BB)       /* R(a) = kdict.key?(Syms(b))                      # todo */
 67 | OPCODE(KEYEND,     Z)        /* raise unless kdict.empty?                       # todo */
 68 | OPCODE(KARG,       BB)       /* R(a) = kdict[Syms(b)]; kdict.delete(Syms(b))    # todo */
 69 | OPCODE(RETURN,     B)        /* return R(a) (normal) */
 70 | OPCODE(RETURN_BLK, B)        /* return R(a) (in-block return) */
 71 | OPCODE(BREAK,      B)        /* break R(a) */
 72 | OPCODE(BLKPUSH,    BS)       /* R(a) = block (16=m5:r1:m5:d1:lv4) */
 73 | OPCODE(ADD,        B)        /* R(a) = R(a)+R(a+1) */
 74 | OPCODE(ADDI,       BB)       /* R(a) = R(a)+mrb_int(c)  */
 75 | OPCODE(SUB,        B)        /* R(a) = R(a)-R(a+1) */
 76 | OPCODE(SUBI,       BB)       /* R(a) = R(a)-C */
 77 | OPCODE(MUL,        B)        /* R(a) = R(a)*R(a+1) */
 78 | OPCODE(DIV,        B)        /* R(a) = R(a)/R(a+1) */
 79 | OPCODE(EQ,         B)        /* R(a) = R(a)==R(a+1) */
 80 | OPCODE(LT,         B)        /* R(a) = R(a)<R(a+1) */
 81 | OPCODE(LE,         B)        /* R(a) = R(a)<=R(a+1) */
 82 | OPCODE(GT,         B)        /* R(a) = R(a)>R(a+1) */
 83 | OPCODE(GE,         B)        /* R(a) = R(a)>=R(a+1) */
 84 | OPCODE(ARRAY,      BB)       /* R(a) = ary_new(R(a),R(a+1)..R(a+b)) */
 85 | OPCODE(ARRAY2,     BBB)      /* R(a) = ary_new(R(b),R(b+1)..R(b+c)) */
 86 | OPCODE(ARYCAT,     B)        /* ary_cat(R(a),R(a+1)) */
 87 | OPCODE(ARYPUSH,    B)        /* ary_push(R(a),R(a+1)) */
 88 | OPCODE(ARYDUP,     B)        /* R(a) = ary_dup(R(a)) */
 89 | OPCODE(AREF,       BBB)      /* R(a) = R(b)[c] */
 90 | OPCODE(ASET,       BBB)      /* R(a)[c] = R(b) */
 91 | OPCODE(APOST,      BBB)      /* *R(a),R(a+1)..R(a+C) = R(a)[b..] */
 92 | OPCODE(INTERN,     B)        /* R(a) = intern(R(a)) */
 93 | OPCODE(STRING,     BB)       /* R(a) = str_dup(Lit(b)) */
 94 | OPCODE(STRCAT,     B)        /* str_cat(R(a),R(a+1)) */
 95 | OPCODE(HASH,       BB)       /* R(a) = hash_new(R(a),R(a+1)..R(a+b)) */
 96 | OPCODE(HASHADD,    BB)       /* R(a) = hash_push(R(a),R(a+1)..R(a+b)) */
 97 | OPCODE(HASHCAT,    B)        /* R(a) = hash_cat(R(a),R(a+1)) */
 98 | OPCODE(LAMBDA,     BB)       /* R(a) = lambda(SEQ[b],L_LAMBDA) */
 99 | OPCODE(BLOCK,      BB)       /* R(a) = lambda(SEQ[b],L_BLOCK) */
100 | OPCODE(METHOD,     BB)       /* R(a) = lambda(SEQ[b],L_METHOD) */
101 | OPCODE(RANGE_INC,  B)        /* R(a) = range_new(R(a),R(a+1),FALSE) */
102 | OPCODE(RANGE_EXC,  B)        /* R(a) = range_new(R(a),R(a+1),TRUE) */
103 | OPCODE(OCLASS,     B)        /* R(a) = ::Object */
104 | OPCODE(CLASS,      BB)       /* R(a) = newclass(R(a),Syms(b),R(a+1)) */
105 | OPCODE(MODULE,     BB)       /* R(a) = newmodule(R(a),Syms(b)) */
106 | OPCODE(EXEC,       BB)       /* R(a) = blockexec(R(a),SEQ[b]) */
107 | OPCODE(DEF,        BB)       /* R(a).newmethod(Syms(b),R(a+1)) */
108 | OPCODE(ALIAS,      BB)       /* alias_method(target_class,Syms(a),Syms(b)) */
109 | OPCODE(UNDEF,      B)        /* undef_method(target_class,Syms(a)) */
110 | OPCODE(SCLASS,     B)        /* R(a) = R(a).singleton_class */
111 | OPCODE(TCLASS,     B)        /* R(a) = target_class */
112 | OPCODE(DEBUG,      BBB)      /* print a,b,c */
113 | OPCODE(ERR,        B)        /* raise(LocalJumpError, Lit(a)) */
114 | OPCODE(EXT1,       Z)        /* make 1st operand 16bit */
115 | OPCODE(EXT2,       Z)        /* make 2nd operand 16bit */
116 | OPCODE(EXT3,       Z)        /* make 1st and 2nd operands 16bit */
117 | OPCODE(STOP,       Z)        /* stop VM */
118 | 


--------------------------------------------------------------------------------
/tvos/MRuby.framework/Headers/mruby/proc.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** mruby/proc.h - Proc class
  3 | **
  4 | ** See Copyright Notice in mruby.h
  5 | */
  6 | 
  7 | #ifndef MRUBY_PROC_H
  8 | #define MRUBY_PROC_H
  9 | 
 10 | #include "common.h"
 11 | #include <mruby/irep.h>
 12 | 
 13 | /**
 14 |  * Proc class
 15 |  */
 16 | MRB_BEGIN_DECL
 17 | 
 18 | struct REnv {
 19 |   MRB_OBJECT_HEADER;
 20 |   mrb_value *stack;
 21 |   struct mrb_context *cxt;
 22 |   mrb_sym mid;
 23 | };
 24 | 
 25 | /* flags (21bits): 1(shared flag):10(cioff/bidx):10(stack_len) */
 26 | #define MRB_ENV_SET_STACK_LEN(e,len) (e)->flags = (((e)->flags & ~0x3ff)|((unsigned int)(len) & 0x3ff))
 27 | #define MRB_ENV_STACK_LEN(e) ((mrb_int)((e)->flags & 0x3ff))
 28 | #define MRB_ENV_STACK_UNSHARED (1<<20)
 29 | #define MRB_ENV_UNSHARE_STACK(e) (e)->flags |= MRB_ENV_STACK_UNSHARED
 30 | #define MRB_ENV_STACK_SHARED_P(e) (((e)->flags & MRB_ENV_STACK_UNSHARED) == 0)
 31 | #define MRB_ENV_BIDX(e) (((e)->flags >> 10) & 0x3ff)
 32 | #define MRB_ENV_SET_BIDX(e,idx) (e)->flags = (((e)->flags & ~(0x3ff<<10))|((unsigned int)(idx) & 0x3ff)<<10)
 33 | 
 34 | void mrb_env_unshare(mrb_state*, struct REnv*);
 35 | 
 36 | struct RProc {
 37 |   MRB_OBJECT_HEADER;
 38 |   union {
 39 |     mrb_irep *irep;
 40 |     mrb_func_t func;
 41 |   } body;
 42 |   struct RProc *upper;
 43 |   union {
 44 |     struct RClass *target_class;
 45 |     struct REnv *env;
 46 |   } e;
 47 | };
 48 | 
 49 | /* aspec access */
 50 | #define MRB_ASPEC_REQ(a)          (((a) >> 18) & 0x1f)
 51 | #define MRB_ASPEC_OPT(a)          (((a) >> 13) & 0x1f)
 52 | #define MRB_ASPEC_REST(a)         (((a) >> 12) & 0x1)
 53 | #define MRB_ASPEC_POST(a)         (((a) >> 7) & 0x1f)
 54 | #define MRB_ASPEC_KEY(a)          (((a) >> 2) & 0x1f)
 55 | #define MRB_ASPEC_KDICT(a)        ((a) & (1<<1))
 56 | #define MRB_ASPEC_BLOCK(a)        ((a) & 1)
 57 | 
 58 | #define MRB_PROC_CFUNC_FL 128
 59 | #define MRB_PROC_CFUNC_P(p) (((p)->flags & MRB_PROC_CFUNC_FL) != 0)
 60 | #define MRB_PROC_CFUNC(p) (p)->body.func
 61 | #define MRB_PROC_STRICT 256
 62 | #define MRB_PROC_STRICT_P(p) (((p)->flags & MRB_PROC_STRICT) != 0)
 63 | #define MRB_PROC_ORPHAN 512
 64 | #define MRB_PROC_ORPHAN_P(p) (((p)->flags & MRB_PROC_ORPHAN) != 0)
 65 | #define MRB_PROC_ENVSET 1024
 66 | #define MRB_PROC_ENV_P(p) (((p)->flags & MRB_PROC_ENVSET) != 0)
 67 | #define MRB_PROC_ENV(p) (MRB_PROC_ENV_P(p) ? (p)->e.env : NULL)
 68 | #define MRB_PROC_TARGET_CLASS(p) (MRB_PROC_ENV_P(p) ? (p)->e.env->c : (p)->e.target_class)
 69 | #define MRB_PROC_SET_TARGET_CLASS(p,tc) do {\
 70 |   if (MRB_PROC_ENV_P(p)) {\
 71 |     (p)->e.env->c = (tc);\
 72 |     mrb_field_write_barrier(mrb, (struct RBasic*)(p)->e.env, (struct RBasic*)tc);\
 73 |   }\
 74 |   else {\
 75 |     (p)->e.target_class = (tc);\
 76 |     mrb_field_write_barrier(mrb, (struct RBasic*)p, (struct RBasic*)tc);\
 77 |   }\
 78 | } while (0)
 79 | #define MRB_PROC_SCOPE 2048
 80 | #define MRB_PROC_SCOPE_P(p) (((p)->flags & MRB_PROC_SCOPE) != 0)
 81 | 
 82 | #define mrb_proc_ptr(v)    ((struct RProc*)(mrb_ptr(v)))
 83 | 
 84 | struct RProc *mrb_proc_new(mrb_state*, mrb_irep*);
 85 | struct RProc *mrb_closure_new(mrb_state*, mrb_irep*);
 86 | MRB_API struct RProc *mrb_proc_new_cfunc(mrb_state*, mrb_func_t);
 87 | MRB_API struct RProc *mrb_closure_new_cfunc(mrb_state *mrb, mrb_func_t func, int nlocals);
 88 | void mrb_proc_copy(struct RProc *a, struct RProc *b);
 89 | 
 90 | /* implementation of #send method */
 91 | mrb_value mrb_f_send(mrb_state *mrb, mrb_value self);
 92 | 
 93 | /* following functions are defined in mruby-proc-ext so please include it when using */
 94 | MRB_API struct RProc *mrb_proc_new_cfunc_with_env(mrb_state*, mrb_func_t, mrb_int, const mrb_value*);
 95 | MRB_API mrb_value mrb_proc_cfunc_env_get(mrb_state*, mrb_int);
 96 | /* old name */
 97 | #define mrb_cfunc_env_get(mrb, idx) mrb_proc_cfunc_env_get(mrb, idx)
 98 | 
 99 | #ifdef MRB_METHOD_TABLE_INLINE
100 | 
101 | #define MRB_METHOD_FUNC_FL ((uintptr_t)1)
102 | #define MRB_METHOD_FUNC_P(m) (((uintptr_t)(m))&MRB_METHOD_FUNC_FL)
103 | #define MRB_METHOD_FUNC(m) ((mrb_func_t)((uintptr_t)(m)&(~MRB_METHOD_FUNC_FL)))
104 | #define MRB_METHOD_FROM_FUNC(m,fn) m=(mrb_method_t)((struct RProc*)((uintptr_t)(fn)|MRB_METHOD_FUNC_FL))
105 | #define MRB_METHOD_FROM_PROC(m,pr) m=(mrb_method_t)(struct RProc*)(pr)
106 | #define MRB_METHOD_PROC_P(m) (!MRB_METHOD_FUNC_P(m))
107 | #define MRB_METHOD_PROC(m) ((struct RProc*)(m))
108 | #define MRB_METHOD_UNDEF_P(m) ((m)==0)
109 | 
110 | #else
111 | 
112 | #define MRB_METHOD_FUNC_P(m) ((m).func_p)
113 | #define MRB_METHOD_FUNC(m) ((m).func)
114 | #define MRB_METHOD_FROM_FUNC(m,fn) do{(m).func_p=TRUE;(m).func=(fn);}while(0)
115 | #define MRB_METHOD_FROM_PROC(m,pr) do{(m).func_p=FALSE;(m).proc=(pr);}while(0)
116 | #define MRB_METHOD_PROC_P(m) (!MRB_METHOD_FUNC_P(m))
117 | #define MRB_METHOD_PROC(m) ((m).proc)
118 | #define MRB_METHOD_UNDEF_P(m) ((m).proc==NULL)
119 | 
120 | #endif /* MRB_METHOD_TABLE_INLINE */
121 | 
122 | #define MRB_METHOD_CFUNC_P(m) (MRB_METHOD_FUNC_P(m)?TRUE:(MRB_METHOD_PROC(m)?(MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m))):FALSE))
123 | #define MRB_METHOD_CFUNC(m) (MRB_METHOD_FUNC_P(m)?MRB_METHOD_FUNC(m):((MRB_METHOD_PROC(m)&&MRB_PROC_CFUNC_P(MRB_METHOD_PROC(m)))?MRB_PROC_CFUNC(MRB_METHOD_PROC(m)):NULL))
124 | 
125 | 
126 | #include <mruby/khash.h>
127 | KHASH_DECLARE(mt, mrb_sym, mrb_method_t, TRUE)
128 | 
129 | MRB_END_DECL
130 | 
131 | #endif  /* MRUBY_PROC_H */
132 | 


--------------------------------------------------------------------------------
/tvos/MRuby.framework/Headers/mruby/range.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** mruby/range.h - Range class
 3 | **
 4 | ** See Copyright Notice in mruby.h
 5 | */
 6 | 
 7 | #ifndef MRUBY_RANGE_H
 8 | #define MRUBY_RANGE_H
 9 | 
10 | #include "common.h"
11 | 
12 | /**
13 |  * Range class
14 |  */
15 | MRB_BEGIN_DECL
16 | 
17 | typedef struct mrb_range_edges {
18 |   mrb_value beg;
19 |   mrb_value end;
20 | } mrb_range_edges;
21 | 
22 | struct RRange {
23 |   MRB_OBJECT_HEADER;
24 |   mrb_range_edges *edges;
25 |   mrb_bool excl : 1;
26 | };
27 | 
28 | MRB_API struct RRange* mrb_range_ptr(mrb_state *mrb, mrb_value v);
29 | #define mrb_range_raw_ptr(v) ((struct RRange*)mrb_ptr(v))
30 | #define mrb_range_value(p)  mrb_obj_value((void*)(p))
31 | 
32 | /*
33 |  * Initializes a Range.
34 |  *
35 |  * If the third parameter is FALSE then it includes the last value in the range.
36 |  * If the third parameter is TRUE then it excludes the last value in the range.
37 |  *
38 |  * @param start the beginning value.
39 |  * @param end the ending value.
40 |  * @param exclude represents the inclusion or exclusion of the last value.
41 |  */
42 | MRB_API mrb_value mrb_range_new(mrb_state *mrb, mrb_value start, mrb_value end, mrb_bool exclude);
43 | 
44 | MRB_API mrb_int mrb_range_beg_len(mrb_state *mrb, mrb_value range, mrb_int *begp, mrb_int *lenp, mrb_int len, mrb_bool trunc);
45 | 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));
46 | 
47 | MRB_END_DECL
48 | 
49 | #endif  /* MRUBY_RANGE_H */
50 | 


--------------------------------------------------------------------------------
/tvos/MRuby.framework/Headers/mruby/re.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** mruby/re.h - Regexp class
 3 | **
 4 | ** See Copyright Notice in mruby.h
 5 | */
 6 | 
 7 | #ifndef MRUBY_RE_H
 8 | #define MRUBY_RE_H
 9 | 
10 | MRB_BEGIN_DECL
11 | 
12 | #define REGEXP_CLASS          "Regexp"
13 | 
14 | MRB_END_DECL
15 | 
16 | #endif  /* RE_H */
17 | 


--------------------------------------------------------------------------------
/tvos/MRuby.framework/Headers/mruby/throw.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** mruby/throw.h - mruby exception throwing handler
 3 | **
 4 | ** See Copyright Notice in mruby.h
 5 | */
 6 | 
 7 | #ifndef MRB_THROW_H
 8 | #define MRB_THROW_H
 9 | 
10 | #if defined(MRB_ENABLE_CXX_ABI)
11 | # if !defined(__cplusplus)
12 | #  error Trying to use C++ exception handling in C code
13 | # endif
14 | #endif
15 | 
16 | #if defined(MRB_ENABLE_CXX_EXCEPTION) && defined(__cplusplus)
17 | 
18 | #define MRB_TRY(buf) try {
19 | #define MRB_CATCH(buf) } catch(mrb_jmpbuf_impl e) { if (e != (buf)->impl) { throw e; }
20 | #define MRB_END_EXC(buf)  }
21 | 
22 | #define MRB_THROW(buf) throw((buf)->impl)
23 | typedef mrb_int mrb_jmpbuf_impl;
24 | 
25 | #else
26 | 
27 | #include <setjmp.h>
28 | 
29 | #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
30 | #define MRB_SETJMP _setjmp
31 | #define MRB_LONGJMP _longjmp
32 | #else
33 | #define MRB_SETJMP setjmp
34 | #define MRB_LONGJMP longjmp
35 | #endif
36 | 
37 | #define MRB_TRY(buf) if (MRB_SETJMP((buf)->impl) == 0) {
38 | #define MRB_CATCH(buf) } else {
39 | #define MRB_END_EXC(buf) }
40 | 
41 | #define MRB_THROW(buf) MRB_LONGJMP((buf)->impl, 1);
42 | #define mrb_jmpbuf_impl jmp_buf
43 | 
44 | #endif
45 | 
46 | struct mrb_jmpbuf {
47 |   mrb_jmpbuf_impl impl;
48 | 
49 | #if defined(MRB_ENABLE_CXX_EXCEPTION) && defined(__cplusplus)
50 |   static mrb_int jmpbuf_id;
51 |   mrb_jmpbuf() : impl(jmpbuf_id++) {}
52 | #endif
53 | };
54 | 
55 | #endif  /* MRB_THROW_H */
56 | 


--------------------------------------------------------------------------------
/tvos/MRuby.framework/Headers/mruby/value.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** mruby/value.h - mruby value definitions
  3 | **
  4 | ** See Copyright Notice in mruby.h
  5 | */
  6 | 
  7 | #ifndef MRUBY_VALUE_H
  8 | #define MRUBY_VALUE_H
  9 | 
 10 | #include "common.h"
 11 | 
 12 | /**
 13 |  * MRuby Value definition functions and macros.
 14 |  */
 15 | MRB_BEGIN_DECL
 16 | 
 17 | typedef uint32_t mrb_sym;
 18 | typedef uint8_t mrb_bool;
 19 | struct mrb_state;
 20 | 
 21 | #if defined(MRB_INT16) && defined(MRB_INT64)
 22 | # error "You can't define MRB_INT16 and MRB_INT64 at the same time."
 23 | #endif
 24 | 
 25 | #if defined _MSC_VER && _MSC_VER < 1800
 26 | # define PRIo64 "llo"
 27 | # define PRId64 "lld"
 28 | # define PRIx64 "llx"
 29 | # define PRIo16 "ho"
 30 | # define PRId16 "hd"
 31 | # define PRIx16 "hx"
 32 | # define PRIo32 "o"
 33 | # define PRId32 "d"
 34 | # define PRIx32 "x"
 35 | #else
 36 | # include <inttypes.h>
 37 | #endif
 38 | 
 39 | #if defined(MRB_INT64)
 40 |   typedef int64_t mrb_int;
 41 | # define MRB_INT_BIT 64
 42 | # define MRB_INT_MIN (INT64_MIN>>MRB_FIXNUM_SHIFT)
 43 | # define MRB_INT_MAX (INT64_MAX>>MRB_FIXNUM_SHIFT)
 44 | # define MRB_PRIo PRIo64
 45 | # define MRB_PRId PRId64
 46 | # define MRB_PRIx PRIx64
 47 | #elif defined(MRB_INT16)
 48 |   typedef int16_t mrb_int;
 49 | # define MRB_INT_BIT 16
 50 | # define MRB_INT_MIN (INT16_MIN>>MRB_FIXNUM_SHIFT)
 51 | # define MRB_INT_MAX (INT16_MAX>>MRB_FIXNUM_SHIFT)
 52 | # define MRB_PRIo PRIo16
 53 | # define MRB_PRId PRId16
 54 | # define MRB_PRIx PRIx16
 55 | #else
 56 |   typedef int32_t mrb_int;
 57 | # define MRB_INT_BIT 32
 58 | # define MRB_INT_MIN (INT32_MIN>>MRB_FIXNUM_SHIFT)
 59 | # define MRB_INT_MAX (INT32_MAX>>MRB_FIXNUM_SHIFT)
 60 | # define MRB_PRIo PRIo32
 61 | # define MRB_PRId PRId32
 62 | # define MRB_PRIx PRIx32
 63 | #endif
 64 | 
 65 | 
 66 | #ifndef MRB_WITHOUT_FLOAT
 67 | MRB_API double mrb_float_read(const char*, char**);
 68 | #ifdef MRB_USE_FLOAT
 69 |   typedef float mrb_float;
 70 | #else
 71 |   typedef double mrb_float;
 72 | #endif
 73 | #endif
 74 | 
 75 | #if defined _MSC_VER && _MSC_VER < 1900
 76 | # ifndef __cplusplus
 77 | #  define inline __inline
 78 | # endif
 79 | # include <stdarg.h>
 80 | MRB_API int mrb_msvc_vsnprintf(char *s, size_t n, const char *format, va_list arg);
 81 | MRB_API int mrb_msvc_snprintf(char *s, size_t n, const char *format, ...);
 82 | # define vsnprintf(s, n, format, arg) mrb_msvc_vsnprintf(s, n, format, arg)
 83 | # define snprintf(s, n, format, ...) mrb_msvc_snprintf(s, n, format, __VA_ARGS__)
 84 | # if _MSC_VER < 1800 && !defined MRB_WITHOUT_FLOAT
 85 | #  include <float.h>
 86 | #  define isfinite(n) _finite(n)
 87 | #  define isnan _isnan
 88 | #  define isinf(n) (!_finite(n) && !_isnan(n))
 89 | #  define signbit(n) (_copysign(1.0, (n)) < 0.0)
 90 | static const unsigned int IEEE754_INFINITY_BITS_SINGLE = 0x7F800000;
 91 | #  define INFINITY (*(float *)&IEEE754_INFINITY_BITS_SINGLE)
 92 | #  define NAN ((float)(INFINITY - INFINITY))
 93 | # endif
 94 | #endif
 95 | 
 96 | enum mrb_vtype {
 97 |   MRB_TT_FALSE = 0,   /*   0 */
 98 |   MRB_TT_FREE,        /*   1 */
 99 |   MRB_TT_TRUE,        /*   2 */
100 |   MRB_TT_FIXNUM,      /*   3 */
101 |   MRB_TT_SYMBOL,      /*   4 */
102 |   MRB_TT_UNDEF,       /*   5 */
103 |   MRB_TT_FLOAT,       /*   6 */
104 |   MRB_TT_CPTR,        /*   7 */
105 |   MRB_TT_OBJECT,      /*   8 */
106 |   MRB_TT_CLASS,       /*   9 */
107 |   MRB_TT_MODULE,      /*  10 */
108 |   MRB_TT_ICLASS,      /*  11 */
109 |   MRB_TT_SCLASS,      /*  12 */
110 |   MRB_TT_PROC,        /*  13 */
111 |   MRB_TT_ARRAY,       /*  14 */
112 |   MRB_TT_HASH,        /*  15 */
113 |   MRB_TT_STRING,      /*  16 */
114 |   MRB_TT_RANGE,       /*  17 */
115 |   MRB_TT_EXCEPTION,   /*  18 */
116 |   MRB_TT_FILE,        /*  19 */
117 |   MRB_TT_ENV,         /*  20 */
118 |   MRB_TT_DATA,        /*  21 */
119 |   MRB_TT_FIBER,       /*  22 */
120 |   MRB_TT_ISTRUCT,     /*  23 */
121 |   MRB_TT_BREAK,       /*  24 */
122 |   MRB_TT_MAXDEFINE    /*  25 */
123 | };
124 | 
125 | #include <mruby/object.h>
126 | 
127 | #ifdef MRB_DOCUMENTATION_BLOCK
128 | 
129 | /**
130 |  * @abstract
131 |  * MRuby value boxing.
132 |  *
133 |  * Actual implementation depends on configured boxing type.
134 |  *
135 |  * @see mruby/boxing_no.h Default boxing representation
136 |  * @see mruby/boxing_word.h Word representation
137 |  * @see mruby/boxing_nan.h Boxed double representation
138 |  */
139 | typedef void mrb_value;
140 | 
141 | #endif
142 | 
143 | #if defined(MRB_NAN_BOXING)
144 | #include "boxing_nan.h"
145 | #elif defined(MRB_WORD_BOXING)
146 | #include "boxing_word.h"
147 | #else
148 | #include "boxing_no.h"
149 | #endif
150 | 
151 | #ifndef mrb_fixnum_p
152 | #define mrb_fixnum_p(o) (mrb_type(o) == MRB_TT_FIXNUM)
153 | #endif
154 | #ifndef mrb_undef_p
155 | #define mrb_undef_p(o) (mrb_type(o) == MRB_TT_UNDEF)
156 | #endif
157 | #ifndef mrb_nil_p
158 | #define mrb_nil_p(o)  (mrb_type(o) == MRB_TT_FALSE && !mrb_fixnum(o))
159 | #endif
160 | #ifndef mrb_bool
161 | #define mrb_bool(o)   (mrb_type(o) != MRB_TT_FALSE)
162 | #endif
163 | #ifndef MRB_WITHOUT_FLOAT
164 | #define mrb_float_p(o) (mrb_type(o) == MRB_TT_FLOAT)
165 | #endif
166 | #define mrb_symbol_p(o) (mrb_type(o) == MRB_TT_SYMBOL)
167 | #define mrb_array_p(o) (mrb_type(o) == MRB_TT_ARRAY)
168 | #define mrb_string_p(o) (mrb_type(o) == MRB_TT_STRING)
169 | #define mrb_hash_p(o) (mrb_type(o) == MRB_TT_HASH)
170 | #define mrb_cptr_p(o) (mrb_type(o) == MRB_TT_CPTR)
171 | #define mrb_exception_p(o) (mrb_type(o) == MRB_TT_EXCEPTION)
172 | #define mrb_test(o)   mrb_bool(o)
173 | MRB_API mrb_bool mrb_regexp_p(struct mrb_state*, mrb_value);
174 | 
175 | /*
176 |  * Returns a float in Ruby.
177 |  */
178 | #ifndef MRB_WITHOUT_FLOAT
179 | MRB_INLINE mrb_value mrb_float_value(struct mrb_state *mrb, mrb_float f)
180 | {
181 |   mrb_value v;
182 |   (void) mrb;
183 |   SET_FLOAT_VALUE(mrb, v, f);
184 |   return v;
185 | }
186 | #endif
187 | 
188 | static inline mrb_value
189 | mrb_cptr_value(struct mrb_state *mrb, void *p)
190 | {
191 |   mrb_value v;
192 |   (void) mrb;
193 |   SET_CPTR_VALUE(mrb,v,p);
194 |   return v;
195 | }
196 | 
197 | /*
198 |  * Returns a fixnum in Ruby.
199 |  */
200 | MRB_INLINE mrb_value mrb_fixnum_value(mrb_int i)
201 | {
202 |   mrb_value v;
203 |   SET_INT_VALUE(v, i);
204 |   return v;
205 | }
206 | 
207 | static inline mrb_value
208 | mrb_symbol_value(mrb_sym i)
209 | {
210 |   mrb_value v;
211 |   SET_SYM_VALUE(v, i);
212 |   return v;
213 | }
214 | 
215 | static inline mrb_value
216 | mrb_obj_value(void *p)
217 | {
218 |   mrb_value v;
219 |   SET_OBJ_VALUE(v, (struct RBasic*)p);
220 |   mrb_assert(p == mrb_ptr(v));
221 |   mrb_assert(((struct RBasic*)p)->tt == mrb_type(v));
222 |   return v;
223 | }
224 | 
225 | 
226 | /*
227 |  * Get a nil mrb_value object.
228 |  *
229 |  * @return
230 |  *      nil mrb_value object reference.
231 |  */
232 | MRB_INLINE mrb_value mrb_nil_value(void)
233 | {
234 |   mrb_value v;
235 |   SET_NIL_VALUE(v);
236 |   return v;
237 | }
238 | 
239 | /*
240 |  * Returns false in Ruby.
241 |  */
242 | MRB_INLINE mrb_value mrb_false_value(void)
243 | {
244 |   mrb_value v;
245 |   SET_FALSE_VALUE(v);
246 |   return v;
247 | }
248 | 
249 | /*
250 |  * Returns true in Ruby.
251 |  */
252 | MRB_INLINE mrb_value mrb_true_value(void)
253 | {
254 |   mrb_value v;
255 |   SET_TRUE_VALUE(v);
256 |   return v;
257 | }
258 | 
259 | static inline mrb_value
260 | mrb_bool_value(mrb_bool boolean)
261 | {
262 |   mrb_value v;
263 |   SET_BOOL_VALUE(v, boolean);
264 |   return v;
265 | }
266 | 
267 | static inline mrb_value
268 | mrb_undef_value(void)
269 | {
270 |   mrb_value v;
271 |   SET_UNDEF_VALUE(v);
272 |   return v;
273 | }
274 | 
275 | #ifdef MRB_USE_ETEXT_EDATA
276 | #if (defined(__APPLE__) && defined(__MACH__))
277 | #include <mach-o/getsect.h>
278 | static inline mrb_bool
279 | mrb_ro_data_p(const char *p)
280 | {
281 |   return (const char*)get_etext() < p && p < (const char*)get_edata();
282 | }
283 | #else
284 | extern char _etext[];
285 | #ifdef MRB_NO_INIT_ARRAY_START
286 | extern char _edata[];
287 | 
288 | static inline mrb_bool
289 | mrb_ro_data_p(const char *p)
290 | {
291 |   return _etext < p && p < _edata;
292 | }
293 | #else
294 | extern char __init_array_start[];
295 | 
296 | static inline mrb_bool
297 | mrb_ro_data_p(const char *p)
298 | {
299 |   return _etext < p && p < (char*)&__init_array_start;
300 | }
301 | #endif
302 | #endif
303 | #else
304 | # define mrb_ro_data_p(p) FALSE
305 | #endif
306 | 
307 | MRB_END_DECL
308 | 
309 | #endif  /* MRUBY_VALUE_H */
310 | 


--------------------------------------------------------------------------------
/tvos/MRuby.framework/Headers/mruby/variable.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** mruby/variable.h - mruby variables
  3 | **
  4 | ** See Copyright Notice in mruby.h
  5 | */
  6 | 
  7 | #ifndef MRUBY_VARIABLE_H
  8 | #define MRUBY_VARIABLE_H
  9 | 
 10 | #include "common.h"
 11 | 
 12 | /**
 13 |  * Functions to access mruby variables.
 14 |  */
 15 | MRB_BEGIN_DECL
 16 | 
 17 | typedef struct global_variable {
 18 |   int   counter;
 19 |   mrb_value *data;
 20 |   mrb_value (*getter)(void);
 21 |   void  (*setter)(void);
 22 |   /* void  (*marker)(); */
 23 |   /* int block_trace; */
 24 |   /* struct trace_var *trace; */
 25 | } global_variable;
 26 | 
 27 | struct global_entry {
 28 |   global_variable *var;
 29 |   mrb_sym id;
 30 | };
 31 | 
 32 | mrb_value mrb_vm_special_get(mrb_state*, mrb_sym);
 33 | void mrb_vm_special_set(mrb_state*, mrb_sym, mrb_value);
 34 | mrb_value mrb_vm_cv_get(mrb_state*, mrb_sym);
 35 | void mrb_vm_cv_set(mrb_state*, mrb_sym, mrb_value);
 36 | mrb_value mrb_vm_const_get(mrb_state*, mrb_sym);
 37 | void mrb_vm_const_set(mrb_state*, mrb_sym, mrb_value);
 38 | MRB_API mrb_value mrb_const_get(mrb_state*, mrb_value, mrb_sym);
 39 | MRB_API void mrb_const_set(mrb_state*, mrb_value, mrb_sym, mrb_value);
 40 | MRB_API mrb_bool mrb_const_defined(mrb_state*, mrb_value, mrb_sym);
 41 | MRB_API void mrb_const_remove(mrb_state*, mrb_value, mrb_sym);
 42 | 
 43 | MRB_API mrb_bool mrb_iv_name_sym_p(mrb_state *mrb, mrb_sym sym);
 44 | MRB_API void mrb_iv_name_sym_check(mrb_state *mrb, mrb_sym sym);
 45 | MRB_API mrb_value mrb_obj_iv_get(mrb_state *mrb, struct RObject *obj, mrb_sym sym);
 46 | MRB_API void mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v);
 47 | MRB_API mrb_bool mrb_obj_iv_defined(mrb_state *mrb, struct RObject *obj, mrb_sym sym);
 48 | MRB_API mrb_value mrb_iv_get(mrb_state *mrb, mrb_value obj, mrb_sym sym);
 49 | MRB_API void mrb_iv_set(mrb_state *mrb, mrb_value obj, mrb_sym sym, mrb_value v);
 50 | MRB_API mrb_bool mrb_iv_defined(mrb_state*, mrb_value, mrb_sym);
 51 | MRB_API mrb_value mrb_iv_remove(mrb_state *mrb, mrb_value obj, mrb_sym sym);
 52 | MRB_API void mrb_iv_copy(mrb_state *mrb, mrb_value dst, mrb_value src);
 53 | MRB_API mrb_bool mrb_const_defined_at(mrb_state *mrb, mrb_value mod, mrb_sym id);
 54 | 
 55 | /**
 56 |  * Get a global variable. Will return nil if the var does not exist
 57 |  *
 58 |  * Example:
 59 |  *
 60 |  *     !!!ruby
 61 |  *     # Ruby style
 62 |  *     var = $value
 63 |  *
 64 |  *     !!!c
 65 |  *     // C style
 66 |  *     mrb_sym sym = mrb_intern_lit(mrb, "$value");
 67 |  *     mrb_value var = mrb_gv_get(mrb, sym);
 68 |  *
 69 |  * @param mrb The mruby state reference
 70 |  * @param sym The name of the global variable
 71 |  * @return The value of that global variable. May be nil
 72 |  */
 73 | MRB_API mrb_value mrb_gv_get(mrb_state *mrb, mrb_sym sym);
 74 | 
 75 | /**
 76 |  * Set a global variable
 77 |  *
 78 |  * Example:
 79 |  *
 80 |  *     !!!ruby
 81 |  *     # Ruby style
 82 |  *     $value = "foo"
 83 |  *
 84 |  *     !!!c
 85 |  *     // C style
 86 |  *     mrb_sym sym = mrb_intern_lit(mrb, "$value");
 87 |  *     mrb_gv_set(mrb, sym, mrb_str_new_lit("foo"));
 88 |  *
 89 |  * @param mrb The mruby state reference
 90 |  * @param sym The name of the global variable
 91 |  * @param val The value of the global variable
 92 |  */
 93 | MRB_API void mrb_gv_set(mrb_state *mrb, mrb_sym sym, mrb_value val);
 94 | 
 95 | /**
 96 |  * Remove a global variable.
 97 |  *
 98 |  * Example:
 99 |  *
100 |  *     !!!ruby
101 |  *     # Ruby style
102 |  *     $value = nil
103 |  *
104 |  *     !!!c
105 |  *     // C style
106 |  *     mrb_sym sym = mrb_intern_lit(mrb, "$value");
107 |  *     mrb_gv_remove(mrb, sym);
108 |  *
109 |  * @param mrb The mruby state reference
110 |  * @param sym The name of the global variable
111 |  * @param val The value of the global variable
112 |  */
113 | MRB_API void mrb_gv_remove(mrb_state *mrb, mrb_sym sym);
114 | 
115 | MRB_API mrb_value mrb_cv_get(mrb_state *mrb, mrb_value mod, mrb_sym sym);
116 | MRB_API void mrb_mod_cv_set(mrb_state *mrb, struct RClass * c, mrb_sym sym, mrb_value v);
117 | MRB_API void mrb_cv_set(mrb_state *mrb, mrb_value mod, mrb_sym sym, mrb_value v);
118 | MRB_API mrb_bool mrb_cv_defined(mrb_state *mrb, mrb_value mod, mrb_sym sym);
119 | mrb_value mrb_obj_iv_inspect(mrb_state*, struct RObject*);
120 | mrb_value mrb_mod_constants(mrb_state *mrb, mrb_value mod);
121 | mrb_value mrb_f_global_variables(mrb_state *mrb, mrb_value self);
122 | mrb_value mrb_obj_instance_variables(mrb_state*, mrb_value);
123 | mrb_value mrb_mod_class_variables(mrb_state*, mrb_value);
124 | mrb_value mrb_mod_cv_get(mrb_state *mrb, struct RClass * c, mrb_sym sym);
125 | mrb_bool mrb_mod_cv_defined(mrb_state *mrb, struct RClass * c, mrb_sym sym);
126 | 
127 | /* GC functions */
128 | void mrb_gc_mark_gv(mrb_state*);
129 | void mrb_gc_free_gv(mrb_state*);
130 | void mrb_gc_mark_iv(mrb_state*, struct RObject*);
131 | size_t mrb_gc_mark_iv_size(mrb_state*, struct RObject*);
132 | void mrb_gc_free_iv(mrb_state*, struct RObject*);
133 | 
134 | MRB_END_DECL
135 | 
136 | #endif  /* MRUBY_VARIABLE_H */
137 | 


--------------------------------------------------------------------------------
/tvos/MRuby.framework/Headers/mruby/version.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** mruby/version.h - mruby version definition
  3 | **
  4 | ** See Copyright Notice in mruby.h
  5 | */
  6 | 
  7 | #ifndef MRUBY_VERSION_H
  8 | #define MRUBY_VERSION_H
  9 | 
 10 | #include "common.h"
 11 | 
 12 | /**
 13 |  * mruby version definition macros
 14 |  */
 15 | MRB_BEGIN_DECL
 16 | 
 17 | /*
 18 |  * A passed in expression.
 19 |  */
 20 | #define MRB_STRINGIZE0(expr) #expr
 21 | 
 22 | /*
 23 |  * Passes in an expression to MRB_STRINGIZE0.
 24 |  */
 25 | #define MRB_STRINGIZE(expr) MRB_STRINGIZE0(expr)
 26 | 
 27 | /*
 28 |  * The version of Ruby used by mruby.
 29 |  */
 30 | #define MRUBY_RUBY_VERSION "2.0"
 31 | 
 32 | /*
 33 |  * Ruby engine.
 34 |  */
 35 | #define MRUBY_RUBY_ENGINE  "mruby"
 36 | 
 37 | /*
 38 |  * Major release version number.
 39 |  */
 40 | #define MRUBY_RELEASE_MAJOR 2
 41 | 
 42 | /*
 43 |  * Minor release version number.
 44 |  */
 45 | #define MRUBY_RELEASE_MINOR 0
 46 | 
 47 | /*
 48 |  * Tiny release version number.
 49 |  */
 50 | #define MRUBY_RELEASE_TEENY 0
 51 | 
 52 | /*
 53 |  * The mruby version.
 54 |  */
 55 | #define MRUBY_VERSION MRB_STRINGIZE(MRUBY_RELEASE_MAJOR) "." MRB_STRINGIZE(MRUBY_RELEASE_MINOR) "." MRB_STRINGIZE(MRUBY_RELEASE_TEENY)
 56 | 
 57 | /*
 58 |  * Release number.
 59 |  */
 60 | #define MRUBY_RELEASE_NO (MRUBY_RELEASE_MAJOR * 100 * 100 + MRUBY_RELEASE_MINOR * 100 + MRUBY_RELEASE_TEENY)
 61 | 
 62 | /*
 63 |  * Release year.
 64 |  */
 65 | #define MRUBY_RELEASE_YEAR 2018
 66 | 
 67 | /*
 68 |  * Release month.
 69 |  */
 70 | #define MRUBY_RELEASE_MONTH 12
 71 | 
 72 | /*
 73 |  * Release day.
 74 |  */
 75 | #define MRUBY_RELEASE_DAY 11
 76 | 
 77 | /*
 78 |  * Release date as a string.
 79 |  */
 80 | #define MRUBY_RELEASE_DATE MRB_STRINGIZE(MRUBY_RELEASE_YEAR) "-" MRB_STRINGIZE(MRUBY_RELEASE_MONTH) "-" MRB_STRINGIZE(MRUBY_RELEASE_DAY)
 81 | 
 82 | /*
 83 |  * The year mruby was first created.
 84 |  */
 85 | #define MRUBY_BIRTH_YEAR 2010
 86 | 
 87 | /*
 88 |  * MRuby's authors.
 89 |  */
 90 | #define MRUBY_AUTHOR "mruby developers"
 91 | 
 92 | /*
 93 |  * mruby's version, and release date.
 94 |  */
 95 | #define MRUBY_DESCRIPTION      \
 96 |   "mruby " MRUBY_VERSION       \
 97 |   " (" MRUBY_RELEASE_DATE ") " \
 98 | 
 99 | /*
100 |  * mruby's copyright information.
101 |  */
102 | #define MRUBY_COPYRIGHT                \
103 |   "mruby - Copyright (c) "             \
104 |   MRB_STRINGIZE(MRUBY_BIRTH_YEAR)"-"   \
105 |   MRB_STRINGIZE(MRUBY_RELEASE_YEAR)" " \
106 |   MRUBY_AUTHOR                         \
107 | 
108 | MRB_END_DECL
109 | 
110 | #endif  /* MRUBY_VERSION_H */
111 | 


--------------------------------------------------------------------------------
/tvos/MRuby.framework/Info.plist:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 3 | <plist version="1.0">
 4 | <dict>
 5 |   <key>CFBundleName</key>
 6 |   <string>MRuby</string>
 7 |   <key>CFBundleDevelopmentRegion</key>
 8 |   <string>en</string>
 9 |   <key>CFBundleInfoDictionaryVersion</key>
10 |   <string>6.0</string>
11 |   <key>CFBundlePackageType</key>
12 |   <string>FMWK</string>
13 |   <key>CFBundleIdentifier</key>
14 |   <string>MRuby.MRuby</string>
15 |   <key>CFBundleExecutable</key>
16 |   <string>MRuby</string>
17 |   <key>CFBundleVersion</key>
18 |   <string>1</string>
19 | </dict>
20 | </plist>
21 | 


--------------------------------------------------------------------------------
/tvos/MRuby.framework/MRuby:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ruby2d/mruby-frameworks/83906f0c55eba587a5b1a95e05a14dda1c31acf0/tvos/MRuby.framework/MRuby


--------------------------------------------------------------------------------