├── .gitignore ├── Default-568h@2x.png ├── LICENSE ├── MRuby.framework ├── Headers ├── MRuby ├── Resources └── Versions │ ├── 1.0.0 │ ├── Headers │ │ ├── mrbconf.h │ │ ├── mruby.h │ │ └── mruby │ │ │ ├── array.h │ │ │ ├── class.h │ │ │ ├── compile.h │ │ │ ├── data.h │ │ │ ├── debug.h │ │ │ ├── dump.h │ │ │ ├── error.h │ │ │ ├── gc.h │ │ │ ├── hash.h │ │ │ ├── irep.h │ │ │ ├── khash.h │ │ │ ├── numeric.h │ │ │ ├── proc.h │ │ │ ├── range.h │ │ │ ├── re.h │ │ │ ├── string.h │ │ │ ├── value.h │ │ │ ├── variable.h │ │ │ └── version.h │ └── MRuby │ └── Current ├── MRubyiOSExample.xcodeproj ├── project.pbxproj └── project.xcworkspace │ └── contents.xcworkspacedata ├── MRubyiOSExample ├── AppDelegate.h ├── AppDelegate.m ├── FooData.h ├── FooData.m ├── FooUtil.h ├── FooUtil.m ├── MRubyiOSExample-Info.plist ├── MRubyiOSExample-Prefix.pch ├── ViewController.h ├── ViewController.m ├── en.lproj │ ├── InfoPlist.strings │ └── ViewController.xib ├── example.mrb ├── example.rb └── main.m └── README.md /.gitignore: -------------------------------------------------------------------------------- 1 | xcuserdata 2 | .DS_Store 3 | -------------------------------------------------------------------------------- /Default-568h@2x.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/carsonmcdonald/MRubyiOSExample/adfba4d3326160695201d7adbe1bca098e6506d2/Default-568h@2x.png -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2012 Carson McDonald 2 | 3 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and 4 | associated documentation files (the "Software"), to deal in the Software without restriction, including 5 | without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 6 | copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the 7 | following conditions: 8 | 9 | The above copyright notice and this permission notice shall be included in all copies or substantial 10 | portions of the Software. 11 | 12 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT 13 | LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO 14 | EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 15 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR 16 | THE USE OR OTHER DEALINGS IN THE SOFTWARE. 17 | -------------------------------------------------------------------------------- /MRuby.framework/Headers: -------------------------------------------------------------------------------- 1 | Versions/Current/Headers -------------------------------------------------------------------------------- /MRuby.framework/MRuby: -------------------------------------------------------------------------------- 1 | Versions/Current/MRuby -------------------------------------------------------------------------------- /MRuby.framework/Resources: -------------------------------------------------------------------------------- 1 | Versions/Current/Resources -------------------------------------------------------------------------------- /MRuby.framework/Versions/1.0.0/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 | /* configuration options: */ 11 | /* add -DMRB_USE_FLOAT to use float instead of double for floating point numbers */ 12 | //#define MRB_USE_FLOAT 13 | 14 | /* add -DMRB_INT16 to use 16bit integer for mrb_int; conflict with MRB_INT64 */ 15 | //#define MRB_INT16 16 | 17 | /* add -DMRB_INT64 to use 64bit integer for mrb_int; conflict with MRB_INT16 */ 18 | //#define MRB_INT64 19 | 20 | /* represent mrb_value in boxed double; conflict with MRB_USE_FLOAT */ 21 | //#define MRB_NAN_BOXING 22 | 23 | /* define on big endian machines; used by MRB_NAN_BOXING */ 24 | //#define MRB_ENDIAN_BIG 25 | 26 | /* represent mrb_value as a word (natural unit of data for the processor) */ 27 | // #define MRB_WORD_BOXING 28 | 29 | /* argv max size in mrb_funcall */ 30 | //#define MRB_FUNCALL_ARGC_MAX 16 31 | 32 | /* number of object per heap page */ 33 | //#define MRB_HEAP_PAGE_SIZE 1024 34 | 35 | /* use segmented list for IV table */ 36 | //#define MRB_USE_IV_SEGLIST 37 | 38 | /* initial size for IV khash; ignored when MRB_USE_IV_SEGLIST is set */ 39 | //#define MRB_IVHASH_INIT_SIZE 8 40 | 41 | /* turn off generational GC by default */ 42 | //#define MRB_GC_TURN_OFF_GENERATIONAL 43 | 44 | /* default size of khash table bucket */ 45 | //#define KHASH_DEFAULT_SIZE 32 46 | 47 | /* allocated memory address alignment */ 48 | //#define POOL_ALIGNMENT 4 49 | 50 | /* page size of memory pool */ 51 | //#define POOL_PAGE_SIZE 16000 52 | 53 | /* initial minimum size for string buffer */ 54 | //#define MRB_STR_BUF_MIN_SIZE 128 55 | 56 | /* arena size */ 57 | //#define MRB_GC_ARENA_SIZE 100 58 | 59 | /* fixed size GC arena */ 60 | //#define MRB_GC_FIXED_ARENA 61 | 62 | /* -DDISABLE_XXXX to drop following features */ 63 | //#define DISABLE_STDIO /* use of stdio */ 64 | 65 | /* -DENABLE_XXXX to enable following features */ 66 | //#define ENABLE_DEBUG /* hooks for debugger */ 67 | 68 | /* end of configuration */ 69 | 70 | /* define ENABLE_XXXX from DISABLE_XXX */ 71 | #ifndef DISABLE_STDIO 72 | #define ENABLE_STDIO 73 | #endif 74 | #ifndef ENABLE_DEBUG 75 | #define DISABLE_DEBUG 76 | #endif 77 | 78 | #ifdef ENABLE_STDIO 79 | # include 80 | #endif 81 | 82 | #ifndef FALSE 83 | # define FALSE 0 84 | #endif 85 | 86 | #ifndef TRUE 87 | # define TRUE 1 88 | #endif 89 | 90 | #endif /* MRUBYCONF_H */ 91 | -------------------------------------------------------------------------------- /MRuby.framework/Versions/1.0.0/Headers/mruby.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** mruby - An embeddable Ruby implementation 3 | ** 4 | ** Copyright (c) mruby developers 2010-2014 5 | ** 6 | ** Permission is hereby granted, free of charge, to any person obtaining 7 | ** a copy of this software and associated documentation files (the 8 | ** "Software"), to deal in the Software without restriction, including 9 | ** without limitation the rights to use, copy, modify, merge, publish, 10 | ** distribute, sublicense, and/or sell copies of the Software, and to 11 | ** permit persons to whom the Software is furnished to do so, subject to 12 | ** the following conditions: 13 | ** 14 | ** The above copyright notice and this permission notice shall be 15 | ** included in all copies or substantial portions of the Software. 16 | ** 17 | ** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 18 | ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 19 | ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 20 | ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 21 | ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 22 | ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 23 | ** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 24 | ** 25 | ** [ MIT license: http://www.opensource.org/licenses/mit-license.php ] 26 | */ 27 | 28 | #ifndef MRUBY_H 29 | #define MRUBY_H 30 | 31 | #if defined(__cplusplus) 32 | extern "C" { 33 | #endif 34 | 35 | #include 36 | #include 37 | #include 38 | 39 | #include "mrbconf.h" 40 | #include "mruby/value.h" 41 | #include "mruby/version.h" 42 | 43 | typedef uint32_t mrb_code; 44 | typedef uint32_t mrb_aspec; 45 | 46 | struct mrb_irep; 47 | struct mrb_state; 48 | 49 | typedef void* (*mrb_allocf) (struct mrb_state *mrb, void*, size_t, void *ud); 50 | 51 | #ifndef MRB_GC_ARENA_SIZE 52 | #define MRB_GC_ARENA_SIZE 100 53 | #endif 54 | 55 | typedef struct { 56 | mrb_sym mid; 57 | struct RProc *proc; 58 | mrb_value *stackent; 59 | int nregs; 60 | int ridx; 61 | int eidx; 62 | struct REnv *env; 63 | mrb_code *pc; /* return address */ 64 | mrb_code *err; /* error position */ 65 | int argc; 66 | int acc; 67 | struct RClass *target_class; 68 | } mrb_callinfo; 69 | 70 | enum mrb_fiber_state { 71 | MRB_FIBER_CREATED = 0, 72 | MRB_FIBER_RUNNING, 73 | MRB_FIBER_RESUMING, 74 | MRB_FIBER_SUSPENDED, 75 | MRB_FIBER_TRANSFERRED, 76 | MRB_FIBER_TERMINATED, 77 | }; 78 | 79 | struct mrb_context { 80 | struct mrb_context *prev; 81 | 82 | mrb_value *stack; /* stack of virtual machine */ 83 | mrb_value *stbase, *stend; 84 | 85 | mrb_callinfo *ci; 86 | mrb_callinfo *cibase, *ciend; 87 | 88 | mrb_code **rescue; /* exception handler stack */ 89 | int rsize; 90 | struct RProc **ensure; /* ensure handler stack */ 91 | int esize; 92 | 93 | enum mrb_fiber_state status; 94 | struct RFiber *fib; 95 | }; 96 | 97 | enum gc_state { 98 | GC_STATE_NONE = 0, 99 | GC_STATE_MARK, 100 | GC_STATE_SWEEP 101 | }; 102 | 103 | struct mrb_jmpbuf; 104 | 105 | typedef struct mrb_state { 106 | struct mrb_jmpbuf *jmp; 107 | 108 | mrb_allocf allocf; /* memory allocation function */ 109 | 110 | struct mrb_context *c; 111 | struct mrb_context *root_c; 112 | 113 | struct RObject *exc; /* exception */ 114 | struct iv_tbl *globals; /* global variable table */ 115 | 116 | struct RObject *top_self; 117 | struct RClass *object_class; /* Object class */ 118 | struct RClass *class_class; 119 | struct RClass *module_class; 120 | struct RClass *proc_class; 121 | struct RClass *string_class; 122 | struct RClass *array_class; 123 | struct RClass *hash_class; 124 | 125 | struct RClass *float_class; 126 | struct RClass *fixnum_class; 127 | struct RClass *true_class; 128 | struct RClass *false_class; 129 | struct RClass *nil_class; 130 | struct RClass *symbol_class; 131 | struct RClass *kernel_module; 132 | 133 | struct heap_page *heaps; /* heaps for GC */ 134 | struct heap_page *sweeps; 135 | struct heap_page *free_heaps; 136 | size_t live; /* count of live objects */ 137 | #ifdef MRB_GC_FIXED_ARENA 138 | struct RBasic *arena[MRB_GC_ARENA_SIZE]; /* GC protection array */ 139 | #else 140 | struct RBasic **arena; /* GC protection array */ 141 | int arena_capa; 142 | #endif 143 | int arena_idx; 144 | 145 | enum gc_state gc_state; /* state of gc */ 146 | int current_white_part; /* make white object by white_part */ 147 | struct RBasic *gray_list; /* list of gray objects to be traversed incrementally */ 148 | struct RBasic *atomic_gray_list; /* list of objects to be traversed atomically */ 149 | size_t gc_live_after_mark; 150 | size_t gc_threshold; 151 | int gc_interval_ratio; 152 | int gc_step_ratio; 153 | mrb_bool gc_disabled:1; 154 | mrb_bool gc_full:1; 155 | mrb_bool is_generational_gc_mode:1; 156 | mrb_bool out_of_memory:1; 157 | size_t majorgc_old_threshold; 158 | struct alloca_header *mems; 159 | 160 | mrb_sym symidx; 161 | struct kh_n2s *name2sym; /* symbol table */ 162 | 163 | #ifdef ENABLE_DEBUG 164 | void (*code_fetch_hook)(struct mrb_state* mrb, struct mrb_irep *irep, mrb_code *pc, mrb_value *regs); 165 | void (*debug_op_hook)(struct mrb_state* mrb, struct mrb_irep *irep, mrb_code *pc, mrb_value *regs); 166 | #endif 167 | 168 | struct RClass *eException_class; 169 | struct RClass *eStandardError_class; 170 | 171 | void *ud; /* auxiliary data */ 172 | } mrb_state; 173 | 174 | #if __STDC_VERSION__ >= 201112L 175 | # define mrb_noreturn _Noreturn 176 | #elif defined __GNUC__ && !defined __STRICT_ANSI__ 177 | # define mrb_noreturn __attribute__((noreturn)) 178 | #elif defined _MSC_VER 179 | # define mrb_noreturn __declspec(noreturn) 180 | #else 181 | # define mrb_noreturn 182 | #endif 183 | 184 | typedef mrb_value (*mrb_func_t)(mrb_state *mrb, mrb_value); 185 | struct RClass *mrb_define_class(mrb_state *, const char*, struct RClass*); 186 | struct RClass *mrb_define_module(mrb_state *, const char*); 187 | mrb_value mrb_singleton_class(mrb_state*, mrb_value); 188 | void mrb_include_module(mrb_state*, struct RClass*, struct RClass*); 189 | 190 | void mrb_define_method(mrb_state*, struct RClass*, const char*, mrb_func_t, mrb_aspec); 191 | void mrb_define_class_method(mrb_state *, struct RClass *, const char *, mrb_func_t, mrb_aspec); 192 | void mrb_define_singleton_method(mrb_state*, struct RObject*, const char*, mrb_func_t, mrb_aspec); 193 | void mrb_define_module_function(mrb_state*, struct RClass*, const char*, mrb_func_t, mrb_aspec); 194 | void mrb_define_const(mrb_state*, struct RClass*, const char *name, mrb_value); 195 | void mrb_undef_method(mrb_state*, struct RClass*, const char*); 196 | void mrb_undef_class_method(mrb_state*, struct RClass*, const char*); 197 | mrb_value mrb_obj_new(mrb_state *mrb, struct RClass *c, mrb_int argc, const mrb_value *argv); 198 | #define mrb_class_new_instance(mrb,argc,argv,c) mrb_obj_new(mrb,c,argc,argv) 199 | mrb_value mrb_instance_new(mrb_state *mrb, mrb_value cv); 200 | struct RClass * mrb_class_new(mrb_state *mrb, struct RClass *super); 201 | struct RClass * mrb_module_new(mrb_state *mrb); 202 | mrb_bool mrb_class_defined(mrb_state *mrb, const char *name); 203 | struct RClass * mrb_class_get(mrb_state *mrb, const char *name); 204 | struct RClass * mrb_class_get_under(mrb_state *mrb, struct RClass *outer, const char *name); 205 | struct RClass * mrb_module_get(mrb_state *mrb, const char *name); 206 | struct RClass * mrb_module_get_under(mrb_state *mrb, struct RClass *outer, const char *name); 207 | 208 | mrb_value mrb_obj_dup(mrb_state *mrb, mrb_value obj); 209 | mrb_value mrb_check_to_integer(mrb_state *mrb, mrb_value val, const char *method); 210 | mrb_bool mrb_obj_respond_to(mrb_state *mrb, struct RClass* c, mrb_sym mid); 211 | struct RClass * mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super); 212 | struct RClass * mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name); 213 | 214 | /* required arguments */ 215 | #define MRB_ARGS_REQ(n) ((mrb_aspec)((n)&0x1f) << 18) 216 | /* optional arguments */ 217 | #define MRB_ARGS_OPT(n) ((mrb_aspec)((n)&0x1f) << 13) 218 | /* mandatory and optinal arguments */ 219 | #define MRB_ARGS_ARG(n1,n2) (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2)) 220 | 221 | /* rest argument */ 222 | #define MRB_ARGS_REST() ((mrb_aspec)(1 << 12)) 223 | /* required arguments after rest */ 224 | #define MRB_ARGS_POST(n) ((mrb_aspec)((n)&0x1f) << 7) 225 | /* keyword arguments (n of keys, kdict) */ 226 | #define MRB_ARGS_KEY(n1,n2) ((mrb_aspec)((((n1)&0x1f) << 2) | ((n2)?(1<<1):0))) 227 | /* block argument */ 228 | #define MRB_ARGS_BLOCK() ((mrb_aspec)1) 229 | 230 | /* accept any number of arguments */ 231 | #define MRB_ARGS_ANY() MRB_ARGS_REST() 232 | /* accept no arguments */ 233 | #define MRB_ARGS_NONE() ((mrb_aspec)0) 234 | 235 | /* compatibility macros; will be removed */ 236 | #define ARGS_REQ(n) MRB_ARGS_REQ(n) 237 | #define ARGS_OPT(n) MRB_ARGS_OPT(n) 238 | #define ARGS_REST() MRB_ARGS_REST() 239 | #define ARGS_POST(n) MRB_ARGS_POST() 240 | #define ARGS_KEY(n1,n2) MRB_ARGS_KEY(n1,n2) 241 | #define ARGS_BLOCK() MRB_ARGS_BLOCK() 242 | #define ARGS_ANY() MRB_ARGS_ANY() 243 | #define ARGS_NONE() MRB_ARGS_NONE() 244 | 245 | mrb_int mrb_get_args(mrb_state *mrb, const char *format, ...); 246 | 247 | /* `strlen` for character string literals (use with caution or `strlen` instead) 248 | Adjacent string literals are concatenated in C/C++ in translation phase 6. 249 | If `lit` is not one, the compiler will report a syntax error: 250 | MSVC: "error C2143: syntax error : missing ')' before 'string'" 251 | GCC: "error: expected ')' before string constant" 252 | */ 253 | #define mrb_strlen_lit(lit) (sizeof(lit "") - 1) 254 | 255 | mrb_value mrb_funcall(mrb_state*, mrb_value, const char*, mrb_int,...); 256 | mrb_value mrb_funcall_argv(mrb_state*, mrb_value, mrb_sym, mrb_int, const mrb_value*); 257 | mrb_value mrb_funcall_with_block(mrb_state*, mrb_value, mrb_sym, mrb_int, const mrb_value*, mrb_value); 258 | mrb_sym mrb_intern_cstr(mrb_state*,const char*); 259 | mrb_sym mrb_intern(mrb_state*,const char*,size_t); 260 | mrb_sym mrb_intern_static(mrb_state*,const char*,size_t); 261 | #define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, lit, mrb_strlen_lit(lit)) 262 | mrb_sym mrb_intern_str(mrb_state*,mrb_value); 263 | mrb_value mrb_check_intern_cstr(mrb_state*,const char*); 264 | mrb_value mrb_check_intern(mrb_state*,const char*,size_t); 265 | mrb_value mrb_check_intern_str(mrb_state*,mrb_value); 266 | const char *mrb_sym2name(mrb_state*,mrb_sym); 267 | const char *mrb_sym2name_len(mrb_state*,mrb_sym,mrb_int*); 268 | mrb_value mrb_sym2str(mrb_state*,mrb_sym); 269 | 270 | void *mrb_malloc(mrb_state*, size_t); /* raise RuntimeError if no mem */ 271 | void *mrb_calloc(mrb_state*, size_t, size_t); /* ditto */ 272 | void *mrb_realloc(mrb_state*, void*, size_t); /* ditto */ 273 | void *mrb_realloc_simple(mrb_state*, void*, size_t); /* return NULL if no memory available */ 274 | void *mrb_malloc_simple(mrb_state*, size_t); /* return NULL if no memory available */ 275 | struct RBasic *mrb_obj_alloc(mrb_state*, enum mrb_vtype, struct RClass*); 276 | void mrb_free(mrb_state*, void*); 277 | 278 | mrb_value mrb_str_new(mrb_state *mrb, const char *p, size_t len); 279 | mrb_value mrb_str_new_cstr(mrb_state*, const char*); 280 | mrb_value mrb_str_new_static(mrb_state *mrb, const char *p, size_t len); 281 | #define mrb_str_new_lit(mrb, lit) mrb_str_new_static(mrb, (lit), mrb_strlen_lit(lit)) 282 | 283 | mrb_state* mrb_open(void); 284 | mrb_state* mrb_open_allocf(mrb_allocf, void *ud); 285 | void mrb_close(mrb_state*); 286 | 287 | mrb_value mrb_top_self(mrb_state *); 288 | mrb_value mrb_run(mrb_state*, struct RProc*, mrb_value); 289 | mrb_value mrb_toplevel_run(mrb_state*, struct RProc*); 290 | mrb_value mrb_context_run(mrb_state*, struct RProc*, mrb_value, unsigned int); 291 | 292 | void mrb_p(mrb_state*, mrb_value); 293 | mrb_int mrb_obj_id(mrb_value obj); 294 | mrb_sym mrb_obj_to_sym(mrb_state *mrb, mrb_value name); 295 | 296 | mrb_bool mrb_obj_eq(mrb_state*, mrb_value, mrb_value); 297 | mrb_bool mrb_obj_equal(mrb_state*, mrb_value, mrb_value); 298 | mrb_bool mrb_equal(mrb_state *mrb, mrb_value obj1, mrb_value obj2); 299 | mrb_value mrb_Integer(mrb_state *mrb, mrb_value val); 300 | mrb_value mrb_Float(mrb_state *mrb, mrb_value val); 301 | mrb_value mrb_inspect(mrb_state *mrb, mrb_value obj); 302 | mrb_bool mrb_eql(mrb_state *mrb, mrb_value obj1, mrb_value obj2); 303 | 304 | void mrb_garbage_collect(mrb_state*); 305 | void mrb_full_gc(mrb_state*); 306 | void mrb_incremental_gc(mrb_state *); 307 | int mrb_gc_arena_save(mrb_state*); 308 | void mrb_gc_arena_restore(mrb_state*,int); 309 | void mrb_gc_mark(mrb_state*,struct RBasic*); 310 | #define mrb_gc_mark_value(mrb,val) do {\ 311 | if (MRB_TT_HAS_BASIC_P(mrb_type(val))) mrb_gc_mark((mrb), mrb_basic_ptr(val)); \ 312 | } while (0) 313 | void mrb_field_write_barrier(mrb_state *, struct RBasic*, struct RBasic*); 314 | #define mrb_field_write_barrier_value(mrb, obj, val) do{\ 315 | if (MRB_TT_HAS_BASIC_P(val.tt)) mrb_field_write_barrier((mrb), (obj), mrb_basic_ptr(val)); \ 316 | } while (0) 317 | void mrb_write_barrier(mrb_state *, struct RBasic*); 318 | 319 | mrb_value mrb_check_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char *tname, const char *method); 320 | mrb_value mrb_any_to_s(mrb_state *mrb, mrb_value obj); 321 | const char * mrb_obj_classname(mrb_state *mrb, mrb_value obj); 322 | struct RClass* mrb_obj_class(mrb_state *mrb, mrb_value obj); 323 | mrb_value mrb_class_path(mrb_state *mrb, struct RClass *c); 324 | mrb_value mrb_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char *tname, const char *method); 325 | mrb_bool mrb_obj_is_kind_of(mrb_state *mrb, mrb_value obj, struct RClass *c); 326 | mrb_value mrb_obj_inspect(mrb_state *mrb, mrb_value self); 327 | mrb_value mrb_obj_clone(mrb_state *mrb, mrb_value self); 328 | 329 | /* need to include to use these macros */ 330 | #ifndef ISPRINT 331 | /* #define ISASCII(c) isascii((int)(unsigned char)(c)) */ 332 | #define ISASCII(c) 1 333 | #define ISPRINT(c) (ISASCII(c) && isprint((int)(unsigned char)(c))) 334 | #define ISSPACE(c) (ISASCII(c) && isspace((int)(unsigned char)(c))) 335 | #define ISUPPER(c) (ISASCII(c) && isupper((int)(unsigned char)(c))) 336 | #define ISLOWER(c) (ISASCII(c) && islower((int)(unsigned char)(c))) 337 | #define ISALNUM(c) (ISASCII(c) && isalnum((int)(unsigned char)(c))) 338 | #define ISALPHA(c) (ISASCII(c) && isalpha((int)(unsigned char)(c))) 339 | #define ISDIGIT(c) (ISASCII(c) && isdigit((int)(unsigned char)(c))) 340 | #define ISXDIGIT(c) (ISASCII(c) && isxdigit((int)(unsigned char)(c))) 341 | #define TOUPPER(c) (ISASCII(c) ? toupper((int)(unsigned char)(c)) : (c)) 342 | #define TOLOWER(c) (ISASCII(c) ? tolower((int)(unsigned char)(c)) : (c)) 343 | #endif 344 | 345 | mrb_value mrb_exc_new(mrb_state *mrb, struct RClass *c, const char *ptr, long len); 346 | mrb_noreturn void mrb_exc_raise(mrb_state *mrb, mrb_value exc); 347 | 348 | mrb_noreturn void mrb_raise(mrb_state *mrb, struct RClass *c, const char *msg); 349 | mrb_noreturn void mrb_raisef(mrb_state *mrb, struct RClass *c, const char *fmt, ...); 350 | mrb_noreturn void mrb_name_error(mrb_state *mrb, mrb_sym id, const char *fmt, ...); 351 | void mrb_warn(mrb_state *mrb, const char *fmt, ...); 352 | mrb_noreturn void mrb_bug(mrb_state *mrb, const char *fmt, ...); 353 | void mrb_print_backtrace(mrb_state *mrb); 354 | void mrb_print_error(mrb_state *mrb); 355 | 356 | /* macros to get typical exception objects 357 | note: 358 | + those E_* macros requires mrb_state* variable named mrb. 359 | + exception objects obtained from those macros are local to mrb 360 | */ 361 | #define E_RUNTIME_ERROR (mrb_class_get(mrb, "RuntimeError")) 362 | #define E_TYPE_ERROR (mrb_class_get(mrb, "TypeError")) 363 | #define E_ARGUMENT_ERROR (mrb_class_get(mrb, "ArgumentError")) 364 | #define E_INDEX_ERROR (mrb_class_get(mrb, "IndexError")) 365 | #define E_RANGE_ERROR (mrb_class_get(mrb, "RangeError")) 366 | #define E_NAME_ERROR (mrb_class_get(mrb, "NameError")) 367 | #define E_NOMETHOD_ERROR (mrb_class_get(mrb, "NoMethodError")) 368 | #define E_SCRIPT_ERROR (mrb_class_get(mrb, "ScriptError")) 369 | #define E_SYNTAX_ERROR (mrb_class_get(mrb, "SyntaxError")) 370 | #define E_LOCALJUMP_ERROR (mrb_class_get(mrb, "LocalJumpError")) 371 | #define E_REGEXP_ERROR (mrb_class_get(mrb, "RegexpError")) 372 | 373 | #define E_NOTIMP_ERROR (mrb_class_get(mrb, "NotImplementedError")) 374 | #define E_FLOATDOMAIN_ERROR (mrb_class_get(mrb, "FloatDomainError")) 375 | 376 | #define E_KEY_ERROR (mrb_class_get(mrb, "KeyError")) 377 | 378 | mrb_value mrb_yield(mrb_state *mrb, mrb_value b, mrb_value arg); 379 | mrb_value mrb_yield_argv(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value *argv); 380 | mrb_value mrb_yield_with_class(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value *argv, mrb_value self, struct RClass *c); 381 | 382 | void mrb_gc_protect(mrb_state *mrb, mrb_value obj); 383 | mrb_value mrb_to_int(mrb_state *mrb, mrb_value val); 384 | #define mrb_int(mrb, val) mrb_fixnum(mrb_to_int(mrb, val)) 385 | void mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t); 386 | 387 | typedef enum call_type { 388 | CALL_PUBLIC, 389 | CALL_FCALL, 390 | CALL_VCALL, 391 | CALL_TYPE_MAX 392 | } call_type; 393 | 394 | void mrb_define_alias(mrb_state *mrb, struct RClass *klass, const char *name1, const char *name2); 395 | const char *mrb_class_name(mrb_state *mrb, struct RClass* klass); 396 | void mrb_define_global_const(mrb_state *mrb, const char *name, mrb_value val); 397 | 398 | mrb_value mrb_attr_get(mrb_state *mrb, mrb_value obj, mrb_sym id); 399 | 400 | mrb_bool mrb_respond_to(mrb_state *mrb, mrb_value obj, mrb_sym mid); 401 | mrb_bool mrb_obj_is_instance_of(mrb_state *mrb, mrb_value obj, struct RClass* c); 402 | 403 | /* fiber functions (you need to link mruby-fiber mrbgem to use) */ 404 | mrb_value mrb_fiber_yield(mrb_state *mrb, mrb_int argc, const mrb_value *argv); 405 | #define E_FIBER_ERROR (mrb_class_get(mrb, "FiberError")) 406 | 407 | /* memory pool implementation */ 408 | typedef struct mrb_pool mrb_pool; 409 | struct mrb_pool* mrb_pool_open(mrb_state*); 410 | void mrb_pool_close(struct mrb_pool*); 411 | void* mrb_pool_alloc(struct mrb_pool*, size_t); 412 | void* mrb_pool_realloc(struct mrb_pool*, void*, size_t oldlen, size_t newlen); 413 | mrb_bool mrb_pool_can_realloc(struct mrb_pool*, void*, size_t); 414 | void* mrb_alloca(mrb_state *mrb, size_t); 415 | 416 | #ifdef MRB_DEBUG 417 | #include 418 | #define mrb_assert(p) assert(p) 419 | #define mrb_assert_int_fit(t1,n,t2,max) assert((n)>=0 && ((sizeof(n)<=sizeof(t2))||(n<=(t1)(max)))) 420 | #else 421 | #define mrb_assert(p) ((void)0) 422 | #define mrb_assert_int_fit(t1,n,t2,max) ((void)0) 423 | #endif 424 | 425 | #if defined(__cplusplus) 426 | } /* extern "C" { */ 427 | #endif 428 | 429 | #endif /* MRUBY_H */ 430 | -------------------------------------------------------------------------------- /MRuby.framework/Versions/1.0.0/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 | #if defined(__cplusplus) 11 | extern "C" { 12 | #endif 13 | 14 | typedef struct mrb_shared_array { 15 | int refcnt; 16 | mrb_int len; 17 | mrb_value *ptr; 18 | } mrb_shared_array; 19 | 20 | struct RArray { 21 | MRB_OBJECT_HEADER; 22 | mrb_int len; 23 | union { 24 | mrb_int capa; 25 | mrb_shared_array *shared; 26 | } aux; 27 | mrb_value *ptr; 28 | }; 29 | 30 | #define mrb_ary_ptr(v) ((struct RArray*)(mrb_ptr(v))) 31 | #define mrb_ary_value(p) mrb_obj_value((void*)(p)) 32 | #define RARRAY(v) ((struct RArray*)(mrb_ptr(v))) 33 | 34 | #define RARRAY_LEN(a) (RARRAY(a)->len) 35 | #define RARRAY_PTR(a) (RARRAY(a)->ptr) 36 | #define MRB_ARY_SHARED 256 37 | 38 | void mrb_ary_modify(mrb_state*, struct RArray*); 39 | void mrb_ary_decref(mrb_state*, mrb_shared_array*); 40 | mrb_value mrb_ary_new_capa(mrb_state*, mrb_int); 41 | mrb_value mrb_ary_new(mrb_state *mrb); 42 | mrb_value mrb_ary_new_from_values(mrb_state *mrb, mrb_int size, const mrb_value *vals); 43 | mrb_value mrb_assoc_new(mrb_state *mrb, mrb_value car, mrb_value cdr); 44 | void mrb_ary_concat(mrb_state*, mrb_value, mrb_value); 45 | mrb_value mrb_ary_splat(mrb_state*, mrb_value); 46 | void mrb_ary_push(mrb_state*, mrb_value, mrb_value); 47 | mrb_value mrb_ary_pop(mrb_state *mrb, mrb_value ary); 48 | mrb_value mrb_ary_ref(mrb_state *mrb, mrb_value ary, mrb_int n); 49 | void mrb_ary_set(mrb_state *mrb, mrb_value ary, mrb_int n, mrb_value val); 50 | void mrb_ary_replace(mrb_state *mrb, mrb_value a, mrb_value b); 51 | mrb_value mrb_check_array_type(mrb_state *mrb, mrb_value self); 52 | mrb_value mrb_ary_unshift(mrb_state *mrb, mrb_value self, mrb_value item); 53 | mrb_value mrb_ary_entry(mrb_value ary, mrb_int offset); 54 | mrb_value mrb_ary_shift(mrb_state *mrb, mrb_value self); 55 | mrb_value mrb_ary_clear(mrb_state *mrb, mrb_value self); 56 | mrb_value mrb_ary_join(mrb_state *mrb, mrb_value ary, mrb_value sep); 57 | 58 | static inline mrb_int 59 | mrb_ary_len(mrb_state *mrb, mrb_value ary) 60 | { 61 | (void)mrb; 62 | mrb_assert(mrb_array_p(ary)); 63 | return RARRAY_LEN(ary); 64 | } 65 | 66 | #if defined(__cplusplus) 67 | } /* extern "C" { */ 68 | #endif 69 | 70 | #endif /* MRUBY_ARRAY_H */ 71 | -------------------------------------------------------------------------------- /MRuby.framework/Versions/1.0.0/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 | #if defined(__cplusplus) 11 | extern "C" { 12 | #endif 13 | 14 | struct RClass { 15 | MRB_OBJECT_HEADER; 16 | struct iv_tbl *iv; 17 | struct kh_mt *mt; 18 | struct RClass *super; 19 | }; 20 | 21 | #define mrb_class_ptr(v) ((struct RClass*)(mrb_ptr(v))) 22 | #define RCLASS_SUPER(v) (((struct RClass*)(mrb_ptr(v)))->super) 23 | #define RCLASS_IV_TBL(v) (((struct RClass*)(mrb_ptr(v)))->iv) 24 | #define RCLASS_M_TBL(v) (((struct RClass*)(mrb_ptr(v)))->mt) 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 (v.value.i) 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 | case MRB_TT_FLOAT: 41 | return mrb->float_class; 42 | case MRB_TT_CPTR: 43 | return mrb->object_class; 44 | case MRB_TT_ENV: 45 | return NULL; 46 | default: 47 | return mrb_obj_ptr(v)->c; 48 | } 49 | } 50 | 51 | #define MRB_SET_INSTANCE_TT(c, tt) c->flags = ((c->flags & ~0xff) | (char)tt) 52 | #define MRB_INSTANCE_TT(c) (enum mrb_vtype)(c->flags & 0xff) 53 | 54 | struct RClass* mrb_define_class_id(mrb_state*, mrb_sym, struct RClass*); 55 | struct RClass* mrb_define_module_id(mrb_state*, mrb_sym); 56 | struct RClass *mrb_vm_define_class(mrb_state*, mrb_value, mrb_value, mrb_sym); 57 | struct RClass *mrb_vm_define_module(mrb_state*, mrb_value, mrb_sym); 58 | void mrb_define_method_vm(mrb_state*, struct RClass*, mrb_sym, mrb_value); 59 | void mrb_define_method_raw(mrb_state*, struct RClass*, mrb_sym, struct RProc *); 60 | void mrb_define_method_id(mrb_state *mrb, struct RClass *c, mrb_sym mid, mrb_func_t func, mrb_aspec aspec); 61 | void mrb_alias_method(mrb_state *mrb, struct RClass *c, mrb_sym a, mrb_sym b); 62 | 63 | struct RClass *mrb_class_outer_module(mrb_state*, struct RClass *); 64 | struct RProc *mrb_method_search_vm(mrb_state*, struct RClass**, mrb_sym); 65 | struct RProc *mrb_method_search(mrb_state*, struct RClass*, mrb_sym); 66 | 67 | struct RClass* mrb_class_real(struct RClass* cl); 68 | 69 | void mrb_gc_mark_mt(mrb_state*, struct RClass*); 70 | size_t mrb_gc_mark_mt_size(mrb_state*, struct RClass*); 71 | void mrb_gc_free_mt(mrb_state*, struct RClass*); 72 | 73 | #if defined(__cplusplus) 74 | } /* extern "C" { */ 75 | #endif 76 | 77 | #endif /* MRUBY_CLASS_H */ 78 | -------------------------------------------------------------------------------- /MRuby.framework/Versions/1.0.0/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 | #if defined(__cplusplus) 11 | extern "C" { 12 | #endif 13 | 14 | #include "../mruby.h" 15 | 16 | struct mrb_jmpbuf; 17 | 18 | struct mrb_parser_state; 19 | /* load context */ 20 | typedef struct mrbc_context { 21 | mrb_sym *syms; 22 | int slen; 23 | char *filename; 24 | short lineno; 25 | int (*partial_hook)(struct mrb_parser_state*); 26 | void *partial_data; 27 | struct RClass *target_class; 28 | mrb_bool capture_errors:1; 29 | mrb_bool dump_result:1; 30 | mrb_bool no_exec:1; 31 | } mrbc_context; 32 | 33 | mrbc_context* mrbc_context_new(mrb_state *mrb); 34 | void mrbc_context_free(mrb_state *mrb, mrbc_context *cxt); 35 | const char *mrbc_filename(mrb_state *mrb, mrbc_context *c, const char *s); 36 | void mrbc_partial_hook(mrb_state *mrb, mrbc_context *c, int (*partial_hook)(struct mrb_parser_state*), void*data); 37 | 38 | /* AST node structure */ 39 | typedef struct mrb_ast_node { 40 | struct mrb_ast_node *car, *cdr; 41 | uint16_t lineno, filename_index; 42 | } mrb_ast_node; 43 | 44 | /* lexer states */ 45 | enum mrb_lex_state_enum { 46 | EXPR_BEG, /* ignore newline, +/- is a sign. */ 47 | EXPR_END, /* newline significant, +/- is an operator. */ 48 | EXPR_ENDARG, /* ditto, and unbound braces. */ 49 | EXPR_ENDFN, /* ditto, and unbound braces. */ 50 | EXPR_ARG, /* newline significant, +/- is an operator. */ 51 | EXPR_CMDARG, /* newline significant, +/- is an operator. */ 52 | EXPR_MID, /* newline significant, +/- is an operator. */ 53 | EXPR_FNAME, /* ignore newline, no reserved words. */ 54 | EXPR_DOT, /* right after `.' or `::', no reserved words. */ 55 | EXPR_CLASS, /* immediate after `class', no here document. */ 56 | EXPR_VALUE, /* alike EXPR_BEG but label is disallowed. */ 57 | EXPR_MAX_STATE 58 | }; 59 | 60 | /* saved error message */ 61 | struct mrb_parser_message { 62 | int lineno; 63 | int column; 64 | char* message; 65 | }; 66 | 67 | #define STR_FUNC_PARSING 0x01 68 | #define STR_FUNC_EXPAND 0x02 69 | #define STR_FUNC_REGEXP 0x04 70 | #define STR_FUNC_WORD 0x08 71 | #define STR_FUNC_SYMBOL 0x10 72 | #define STR_FUNC_ARRAY 0x20 73 | #define STR_FUNC_HEREDOC 0x40 74 | #define STR_FUNC_XQUOTE 0x80 75 | 76 | enum mrb_string_type { 77 | str_not_parsing = (0), 78 | str_squote = (STR_FUNC_PARSING), 79 | str_dquote = (STR_FUNC_PARSING|STR_FUNC_EXPAND), 80 | str_regexp = (STR_FUNC_PARSING|STR_FUNC_REGEXP|STR_FUNC_EXPAND), 81 | str_sword = (STR_FUNC_PARSING|STR_FUNC_WORD|STR_FUNC_ARRAY), 82 | str_dword = (STR_FUNC_PARSING|STR_FUNC_WORD|STR_FUNC_ARRAY|STR_FUNC_EXPAND), 83 | str_ssym = (STR_FUNC_PARSING|STR_FUNC_SYMBOL), 84 | str_ssymbols = (STR_FUNC_PARSING|STR_FUNC_SYMBOL|STR_FUNC_ARRAY), 85 | str_dsymbols = (STR_FUNC_PARSING|STR_FUNC_SYMBOL|STR_FUNC_ARRAY|STR_FUNC_EXPAND), 86 | str_heredoc = (STR_FUNC_PARSING|STR_FUNC_HEREDOC), 87 | str_xquote = (STR_FUNC_PARSING|STR_FUNC_XQUOTE|STR_FUNC_EXPAND), 88 | }; 89 | 90 | /* heredoc structure */ 91 | struct mrb_parser_heredoc_info { 92 | mrb_bool allow_indent:1; 93 | mrb_bool line_head:1; 94 | enum mrb_string_type type; 95 | const char *term; 96 | int term_len; 97 | mrb_ast_node *doc; 98 | }; 99 | 100 | #define MRB_PARSER_BUF_SIZE 1024 101 | 102 | /* parser structure */ 103 | struct mrb_parser_state { 104 | mrb_state *mrb; 105 | struct mrb_pool *pool; 106 | mrb_ast_node *cells; 107 | const char *s, *send; 108 | #ifdef ENABLE_STDIO 109 | FILE *f; 110 | #endif 111 | mrbc_context *cxt; 112 | char const *filename; 113 | int lineno; 114 | int column; 115 | 116 | enum mrb_lex_state_enum lstate; 117 | mrb_ast_node *lex_strterm; /* (type nest_level beg . end) */ 118 | 119 | unsigned int cond_stack; 120 | unsigned int cmdarg_stack; 121 | int paren_nest; 122 | int lpar_beg; 123 | int in_def, in_single; 124 | mrb_bool cmd_start:1; 125 | mrb_ast_node *locals; 126 | 127 | mrb_ast_node *pb; 128 | char buf[MRB_PARSER_BUF_SIZE]; 129 | int bidx; 130 | 131 | mrb_ast_node *all_heredocs; /* list of mrb_parser_heredoc_info* */ 132 | mrb_ast_node *heredocs_from_nextline; 133 | mrb_ast_node *parsing_heredoc; 134 | mrb_ast_node *lex_strterm_before_heredoc; 135 | mrb_bool heredoc_end_now:1; /* for mirb */ 136 | 137 | void *ylval; 138 | 139 | size_t nerr; 140 | size_t nwarn; 141 | mrb_ast_node *tree; 142 | 143 | mrb_bool capture_errors:1; 144 | struct mrb_parser_message error_buffer[10]; 145 | struct mrb_parser_message warn_buffer[10]; 146 | 147 | mrb_sym* filename_table; 148 | size_t filename_table_length; 149 | int current_filename_index; 150 | 151 | struct mrb_jmpbuf* jmp; 152 | }; 153 | 154 | struct mrb_parser_state* mrb_parser_new(mrb_state*); 155 | void mrb_parser_free(struct mrb_parser_state*); 156 | void mrb_parser_parse(struct mrb_parser_state*,mrbc_context*); 157 | 158 | void mrb_parser_set_filename(struct mrb_parser_state*, char const*); 159 | char const* mrb_parser_get_filename(struct mrb_parser_state*, uint16_t idx); 160 | 161 | /* utility functions */ 162 | #ifdef ENABLE_STDIO 163 | struct mrb_parser_state* mrb_parse_file(mrb_state*,FILE*,mrbc_context*); 164 | #endif 165 | struct mrb_parser_state* mrb_parse_string(mrb_state*,const char*,mrbc_context*); 166 | struct mrb_parser_state* mrb_parse_nstring(mrb_state*,const char*,int,mrbc_context*); 167 | struct RProc* mrb_generate_code(mrb_state*, struct mrb_parser_state*); 168 | 169 | /* program load functions */ 170 | #ifdef ENABLE_STDIO 171 | mrb_value mrb_load_file(mrb_state*,FILE*); 172 | #endif 173 | mrb_value mrb_load_string(mrb_state *mrb, const char *s); 174 | mrb_value mrb_load_nstring(mrb_state *mrb, const char *s, int len); 175 | #ifdef ENABLE_STDIO 176 | mrb_value mrb_load_file_cxt(mrb_state*,FILE*, mrbc_context *cxt); 177 | #endif 178 | mrb_value mrb_load_string_cxt(mrb_state *mrb, const char *s, mrbc_context *cxt); 179 | mrb_value mrb_load_nstring_cxt(mrb_state *mrb, const char *s, int len, mrbc_context *cxt); 180 | 181 | #if defined(__cplusplus) 182 | } /* extern "C" { */ 183 | #endif 184 | 185 | #endif /* MRUBY_COMPILE_H */ 186 | -------------------------------------------------------------------------------- /MRuby.framework/Versions/1.0.0/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 | #if defined(__cplusplus) 11 | extern "C" { 12 | #endif 13 | 14 | typedef struct mrb_data_type { 15 | const char *struct_name; 16 | void (*dfree)(mrb_state *mrb, void*); 17 | } mrb_data_type; 18 | 19 | struct RData { 20 | MRB_OBJECT_HEADER; 21 | struct iv_tbl *iv; 22 | const mrb_data_type *type; 23 | void *data; 24 | }; 25 | 26 | struct RData *mrb_data_object_alloc(mrb_state *mrb, struct RClass* klass, void *datap, const mrb_data_type *type); 27 | 28 | #define Data_Wrap_Struct(mrb,klass,type,ptr)\ 29 | mrb_data_object_alloc(mrb,klass,ptr,type) 30 | 31 | #define Data_Make_Struct(mrb,klass,strct,type,sval,data) do { \ 32 | sval = mrb_malloc(mrb, sizeof(strct)); \ 33 | { static const strct zero = { 0 }; *sval = zero; };\ 34 | data = Data_Wrap_Struct(mrb,klass,type,sval);\ 35 | } while (0) 36 | 37 | #define RDATA(obj) ((struct RData *)(mrb_ptr(obj))) 38 | #define DATA_PTR(d) (RDATA(d)->data) 39 | #define DATA_TYPE(d) (RDATA(d)->type) 40 | void mrb_data_check_type(mrb_state *mrb, mrb_value, const mrb_data_type*); 41 | void *mrb_data_get_ptr(mrb_state *mrb, mrb_value, const mrb_data_type*); 42 | #define DATA_GET_PTR(mrb,obj,dtype,type) (type*)mrb_data_get_ptr(mrb,obj,dtype) 43 | void *mrb_data_check_get_ptr(mrb_state *mrb, mrb_value, const mrb_data_type*); 44 | #define DATA_CHECK_GET_PTR(mrb,obj,dtype,type) (type*)mrb_data_check_get_ptr(mrb,obj,dtype) 45 | 46 | /* obsolete functions and macros */ 47 | #define mrb_data_check_and_get(mrb,obj,dtype) mrb_data_get_ptr(mrb,obj,dtype) 48 | #define mrb_get_datatype(mrb,val,type) mrb_data_get_ptr(mrb, val, type) 49 | #define mrb_check_datatype(mrb,val,type) mrb_data_get_ptr(mrb, val, type) 50 | #define Data_Get_Struct(mrb,obj,type,sval) do {\ 51 | *(void**)&sval = mrb_data_get_ptr(mrb, obj, type); \ 52 | } while (0) 53 | 54 | #if defined(__cplusplus) 55 | } /* extern "C" { */ 56 | #endif 57 | 58 | #endif /* MRUBY_DATA_H */ 59 | -------------------------------------------------------------------------------- /MRuby.framework/Versions/1.0.0/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 | #if defined(__cplusplus) 11 | extern "C" { 12 | #endif 13 | 14 | typedef enum mrb_debug_line_type { 15 | mrb_debug_line_ary = 0, 16 | mrb_debug_line_flat_map = 1 17 | } mrb_debug_line_type; 18 | 19 | typedef struct mrb_irep_debug_info_line { 20 | uint32_t start_pos; 21 | uint16_t line; 22 | } mrb_irep_debug_info_line; 23 | 24 | typedef struct mrb_irep_debug_info_file { 25 | uint32_t start_pos; 26 | const char *filename; 27 | mrb_sym filename_sym; 28 | uint32_t line_entry_count; 29 | mrb_debug_line_type line_type; 30 | union { 31 | void *ptr; 32 | mrb_irep_debug_info_line *flat_map; 33 | uint16_t *ary; 34 | } lines; 35 | } mrb_irep_debug_info_file; 36 | 37 | typedef struct mrb_irep_debug_info { 38 | uint32_t pc_count; 39 | uint16_t flen; 40 | mrb_irep_debug_info_file **files; 41 | } mrb_irep_debug_info; 42 | 43 | /* 44 | * get line from irep's debug info and program counter 45 | * @return returns NULL if not found 46 | */ 47 | const char *mrb_debug_get_filename(mrb_irep *irep, uint32_t pc); 48 | 49 | /* 50 | * get line from irep's debug info and program counter 51 | * @return returns -1 if not found 52 | */ 53 | int32_t mrb_debug_get_line(mrb_irep *irep, uint32_t pc); 54 | 55 | mrb_irep_debug_info_file *mrb_debug_info_append_file( 56 | mrb_state *mrb, mrb_irep *irep, 57 | uint32_t start_pos, uint32_t end_pos); 58 | mrb_irep_debug_info *mrb_debug_info_alloc(mrb_state *mrb, mrb_irep *irep); 59 | void mrb_debug_info_free(mrb_state *mrb, mrb_irep_debug_info *d); 60 | 61 | #if defined(__cplusplus) 62 | } /* extern "C" { */ 63 | #endif 64 | 65 | #endif /* MRUBY_DEBUG_H */ 66 | -------------------------------------------------------------------------------- /MRuby.framework/Versions/1.0.0/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 | #if defined(__cplusplus) 11 | extern "C" { 12 | #endif 13 | 14 | #include "../mruby.h" 15 | #include "../mruby/irep.h" 16 | 17 | int mrb_dump_irep(mrb_state *mrb, mrb_irep *irep, int debug_info, uint8_t **bin, size_t *bin_size); 18 | #ifdef ENABLE_STDIO 19 | int mrb_dump_irep_binary(mrb_state*, mrb_irep*, int, FILE*); 20 | int mrb_dump_irep_cfunc(mrb_state *mrb, mrb_irep*, int, FILE *f, const char *initname); 21 | mrb_irep *mrb_read_irep_file(mrb_state*, FILE*); 22 | mrb_value mrb_load_irep_file(mrb_state*,FILE*); 23 | mrb_value mrb_load_irep_file_cxt(mrb_state*, FILE*, mrbc_context*); 24 | #endif 25 | mrb_irep *mrb_read_irep(mrb_state*, const uint8_t*); 26 | 27 | /* dump/load error code 28 | * 29 | * NOTE: MRB_DUMP_GENERAL_FAILURE is caused by 30 | * unspecified issues like malloc failed. 31 | */ 32 | #define MRB_DUMP_OK 0 33 | #define MRB_DUMP_GENERAL_FAILURE (-1) 34 | #define MRB_DUMP_WRITE_FAULT (-2) 35 | #define MRB_DUMP_READ_FAULT (-3) 36 | #define MRB_DUMP_CRC_ERROR (-4) 37 | #define MRB_DUMP_INVALID_FILE_HEADER (-5) 38 | #define MRB_DUMP_INVALID_IREP (-6) 39 | #define MRB_DUMP_INVALID_ARGUMENT (-7) 40 | 41 | /* null symbol length */ 42 | #define MRB_DUMP_NULL_SYM_LEN 0xFFFF 43 | 44 | /* Rite Binary File header */ 45 | #define RITE_BINARY_IDENTIFIER "RITE" 46 | #define RITE_BINARY_FORMAT_VER "0002" 47 | #define RITE_COMPILER_NAME "MATZ" 48 | #define RITE_COMPILER_VERSION "0000" 49 | 50 | #define RITE_VM_VER "0000" 51 | 52 | #define RITE_BINARY_EOF "END\0" 53 | #define RITE_SECTION_IREP_IDENTIFIER "IREP" 54 | #define RITE_SECTION_LINENO_IDENTIFIER "LINE" 55 | #define RITE_SECTION_DEBUG_IDENTIFIER "DBG\0" 56 | 57 | #define MRB_DUMP_DEFAULT_STR_LEN 128 58 | 59 | /* binary header */ 60 | struct rite_binary_header { 61 | uint8_t binary_identify[4]; /* Binary Identifier */ 62 | uint8_t binary_version[4]; /* Binary Format Version */ 63 | uint8_t binary_crc[2]; /* Binary CRC */ 64 | uint8_t binary_size[4]; /* Binary Size */ 65 | uint8_t compiler_name[4]; /* Compiler name */ 66 | uint8_t compiler_version[4]; 67 | }; 68 | 69 | /* section header */ 70 | #define RITE_SECTION_HEADER \ 71 | uint8_t section_identify[4]; \ 72 | uint8_t section_size[4] 73 | 74 | struct rite_section_header { 75 | RITE_SECTION_HEADER; 76 | }; 77 | 78 | struct rite_section_irep_header { 79 | RITE_SECTION_HEADER; 80 | 81 | uint8_t rite_version[4]; /* Rite Instruction Specification Version */ 82 | }; 83 | 84 | struct rite_section_lineno_header { 85 | RITE_SECTION_HEADER; 86 | }; 87 | 88 | struct rite_section_debug_header { 89 | RITE_SECTION_HEADER; 90 | }; 91 | 92 | struct rite_binary_footer { 93 | RITE_SECTION_HEADER; 94 | }; 95 | 96 | static inline size_t 97 | uint8_to_bin(uint8_t s, uint8_t *bin) 98 | { 99 | *bin = s; 100 | return sizeof(uint8_t); 101 | } 102 | 103 | static inline size_t 104 | uint16_to_bin(uint16_t s, uint8_t *bin) 105 | { 106 | *bin++ = (s >> 8) & 0xff; 107 | *bin = s & 0xff; 108 | return sizeof(uint16_t); 109 | } 110 | 111 | static inline size_t 112 | uint32_to_bin(uint32_t l, uint8_t *bin) 113 | { 114 | *bin++ = (l >> 24) & 0xff; 115 | *bin++ = (l >> 16) & 0xff; 116 | *bin++ = (l >> 8) & 0xff; 117 | *bin = l & 0xff; 118 | return sizeof(uint32_t); 119 | } 120 | 121 | static inline uint32_t 122 | bin_to_uint32(const uint8_t *bin) 123 | { 124 | return (uint32_t)bin[0] << 24 | 125 | (uint32_t)bin[1] << 16 | 126 | (uint32_t)bin[2] << 8 | 127 | (uint32_t)bin[3]; 128 | } 129 | 130 | static inline uint16_t 131 | bin_to_uint16(const uint8_t *bin) 132 | { 133 | return (uint16_t)bin[0] << 8 | 134 | (uint16_t)bin[1]; 135 | } 136 | 137 | static inline uint8_t 138 | bin_to_uint8(const uint8_t *bin) 139 | { 140 | return (uint8_t)bin[0]; 141 | } 142 | 143 | #if defined(__cplusplus) 144 | } /* extern "C" { */ 145 | #endif 146 | 147 | /* crc.c */ 148 | uint16_t 149 | calc_crc_16_ccitt(const uint8_t *src, size_t nbytes, uint16_t crc); 150 | 151 | #endif /* MRUBY_DUMP_H */ 152 | -------------------------------------------------------------------------------- /MRuby.framework/Versions/1.0.0/Headers/mruby/error.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** 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 | #if defined(__cplusplus) 11 | extern "C" { 12 | #endif 13 | 14 | void mrb_sys_fail(mrb_state *mrb, const char *mesg); 15 | mrb_value mrb_exc_new_str(mrb_state *mrb, struct RClass* c, mrb_value str); 16 | #define mrb_exc_new_str_lit(mrb, c, lit) mrb_exc_new_str(mrb, c, mrb_str_new_lit(mrb, lit)) 17 | mrb_value mrb_make_exception(mrb_state *mrb, int argc, const mrb_value *argv); 18 | mrb_value mrb_format(mrb_state *mrb, const char *format, ...); 19 | void mrb_exc_print(mrb_state *mrb, struct RObject *exc); 20 | void mrb_print_backtrace(mrb_state *mrb); 21 | mrb_value mrb_exc_backtrace(mrb_state *mrb, mrb_value exc); 22 | mrb_value mrb_get_backtrace(mrb_state *mrb); 23 | 24 | /* declaration for fail method */ 25 | mrb_value mrb_f_raise(mrb_state*, mrb_value); 26 | 27 | #if defined(__cplusplus) 28 | } /* extern "C" { */ 29 | #endif 30 | 31 | #endif /* MRUBY_ERROR_H */ 32 | -------------------------------------------------------------------------------- /MRuby.framework/Versions/1.0.0/Headers/mruby/gc.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** 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 | #if defined(__cplusplus) 11 | extern "C" { 12 | #endif 13 | 14 | typedef void (mrb_each_object_callback)(mrb_state *mrb, struct RBasic *obj, void *data); 15 | void mrb_objspace_each_objects(mrb_state *mrb, mrb_each_object_callback *callback, void *data); 16 | void mrb_free_context(mrb_state *mrb, struct mrb_context *c); 17 | 18 | #if defined(__cplusplus) 19 | } /* extern "C" { */ 20 | #endif 21 | 22 | #endif /* MRUBY_GC_H */ 23 | -------------------------------------------------------------------------------- /MRuby.framework/Versions/1.0.0/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 | #if defined(__cplusplus) 11 | extern "C" { 12 | #endif 13 | 14 | struct RHash { 15 | MRB_OBJECT_HEADER; 16 | struct iv_tbl *iv; 17 | struct kh_ht *ht; 18 | }; 19 | 20 | #define mrb_hash_ptr(v) ((struct RHash*)(mrb_ptr(v))) 21 | #define mrb_hash_value(p) mrb_obj_value((void*)(p)) 22 | 23 | mrb_value mrb_hash_new_capa(mrb_state*, int); 24 | mrb_value mrb_hash_new(mrb_state *mrb); 25 | 26 | void mrb_hash_set(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value val); 27 | mrb_value mrb_hash_get(mrb_state *mrb, mrb_value hash, mrb_value key); 28 | mrb_value mrb_hash_fetch(mrb_state *mrb, mrb_value hash, mrb_value key, mrb_value def); 29 | mrb_value mrb_hash_delete_key(mrb_state *mrb, mrb_value hash, mrb_value key); 30 | mrb_value mrb_hash_keys(mrb_state *mrb, mrb_value hash); 31 | mrb_value mrb_check_hash_type(mrb_state *mrb, mrb_value hash); 32 | mrb_value mrb_hash_empty_p(mrb_state *mrb, mrb_value self); 33 | mrb_value mrb_hash_clear(mrb_state *mrb, mrb_value hash); 34 | 35 | /* RHASH_TBL allocates st_table if not available. */ 36 | #define RHASH(obj) ((struct RHash*)(mrb_ptr(obj))) 37 | #define RHASH_TBL(h) (RHASH(h)->ht) 38 | #define RHASH_IFNONE(h) mrb_iv_get(mrb, (h), mrb_intern_lit(mrb, "ifnone")) 39 | #define RHASH_PROCDEFAULT(h) RHASH_IFNONE(h) 40 | struct kh_ht * mrb_hash_tbl(mrb_state *mrb, mrb_value hash); 41 | 42 | #define MRB_HASH_PROC_DEFAULT 256 43 | #define MRB_RHASH_PROCDEFAULT_P(h) (RHASH(h)->flags & MRB_HASH_PROC_DEFAULT) 44 | 45 | /* GC functions */ 46 | void mrb_gc_mark_hash(mrb_state*, struct RHash*); 47 | size_t mrb_gc_mark_hash_size(mrb_state*, struct RHash*); 48 | void mrb_gc_free_hash(mrb_state*, struct RHash*); 49 | 50 | #if defined(__cplusplus) 51 | } /* extern "C" { */ 52 | #endif 53 | 54 | #endif /* MRUBY_HASH_H */ 55 | -------------------------------------------------------------------------------- /MRuby.framework/Versions/1.0.0/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 | #if defined(__cplusplus) 11 | extern "C" { 12 | #endif 13 | 14 | #include "../mruby/compile.h" 15 | 16 | enum irep_pool_type { 17 | IREP_TT_STRING, 18 | IREP_TT_FIXNUM, 19 | IREP_TT_FLOAT, 20 | }; 21 | 22 | struct mrb_locals { 23 | mrb_sym name; 24 | size_t r; 25 | }; 26 | 27 | /* Program data array struct */ 28 | typedef struct mrb_irep { 29 | uint16_t nlocals; /* Number of local variables */ 30 | uint16_t nregs; /* Number of register variables */ 31 | uint8_t flags; 32 | 33 | mrb_code *iseq; 34 | mrb_value *pool; 35 | mrb_sym *syms; 36 | struct mrb_irep **reps; 37 | 38 | struct mrb_locals *lv; 39 | /* debug info */ 40 | const char *filename; 41 | uint16_t *lines; 42 | struct mrb_irep_debug_info* debug_info; 43 | 44 | size_t ilen, plen, slen, rlen, refcnt; 45 | } mrb_irep; 46 | 47 | #define MRB_ISEQ_NO_FREE 1 48 | 49 | mrb_irep *mrb_add_irep(mrb_state *mrb); 50 | mrb_value mrb_load_irep(mrb_state*, const uint8_t*); 51 | mrb_value mrb_load_irep_cxt(mrb_state*, const uint8_t*, mrbc_context*); 52 | void mrb_irep_free(mrb_state*, struct mrb_irep*); 53 | void mrb_irep_incref(mrb_state*, struct mrb_irep*); 54 | void mrb_irep_decref(mrb_state*, struct mrb_irep*); 55 | 56 | #if defined(__cplusplus) 57 | } /* extern "C" { */ 58 | #endif 59 | 60 | #endif /* MRUBY_IREP_H */ 61 | -------------------------------------------------------------------------------- /MRuby.framework/Versions/1.0.0/Headers/mruby/khash.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** mruby/khash.c - Hash for mruby 3 | ** 4 | ** See Copyright Notice in ../mruby.h 5 | */ 6 | 7 | #ifndef KHASH_H 8 | #define KHASH_H 9 | 10 | #if defined(__cplusplus) 11 | extern "C" { 12 | #endif 13 | 14 | #include "../mruby.h" 15 | #include 16 | 17 | typedef uint32_t khint_t; 18 | typedef khint_t khiter_t; 19 | 20 | #ifndef KHASH_DEFAULT_SIZE 21 | # define KHASH_DEFAULT_SIZE 32 22 | #endif 23 | #define KHASH_MIN_SIZE 8 24 | 25 | #define UPPER_BOUND(x) ((x)>>2|(x)>>1) 26 | 27 | /* extern uint8_t __m[]; */ 28 | 29 | /* mask for flags */ 30 | static const uint8_t __m_empty[] = {0x02, 0x08, 0x20, 0x80}; 31 | static const uint8_t __m_del[] = {0x01, 0x04, 0x10, 0x40}; 32 | static const uint8_t __m_either[] = {0x03, 0x0c, 0x30, 0xc0}; 33 | 34 | 35 | #define __ac_isempty(ed_flag, i) (ed_flag[(i)/4]&__m_empty[(i)%4]) 36 | #define __ac_isdel(ed_flag, i) (ed_flag[(i)/4]&__m_del[(i)%4]) 37 | #define __ac_iseither(ed_flag, i) (ed_flag[(i)/4]&__m_either[(i)%4]) 38 | #define khash_power2(v) do { \ 39 | v--;\ 40 | v |= v >> 1;\ 41 | v |= v >> 2;\ 42 | v |= v >> 4;\ 43 | v |= v >> 8;\ 44 | v |= v >> 16;\ 45 | v++;\ 46 | } while (0) 47 | #define khash_mask(h) ((h)->n_buckets-1) 48 | #define khash_upper_bound(h) (UPPER_BOUND((h)->n_buckets)) 49 | 50 | /* declare struct kh_xxx and kh_xxx_funcs 51 | 52 | name: hash name 53 | khkey_t: key data type 54 | khval_t: value data type 55 | kh_is_map: (0: hash set / 1: hash map) 56 | */ 57 | #define KHASH_DECLARE(name, khkey_t, khval_t, kh_is_map) \ 58 | typedef struct kh_##name { \ 59 | khint_t n_buckets; \ 60 | khint_t size; \ 61 | khint_t n_occupied; \ 62 | uint8_t *ed_flags; \ 63 | khkey_t *keys; \ 64 | khval_t *vals; \ 65 | } kh_##name##_t; \ 66 | void kh_alloc_##name(mrb_state *mrb, kh_##name##_t *h); \ 67 | kh_##name##_t *kh_init_##name##_size(mrb_state *mrb, khint_t size); \ 68 | kh_##name##_t *kh_init_##name(mrb_state *mrb); \ 69 | void kh_destroy_##name(mrb_state *mrb, kh_##name##_t *h); \ 70 | void kh_clear_##name(mrb_state *mrb, kh_##name##_t *h); \ 71 | khint_t kh_get_##name(mrb_state *mrb, kh_##name##_t *h, khkey_t key); \ 72 | khint_t kh_put_##name(mrb_state *mrb, kh_##name##_t *h, khkey_t key, int *ret); \ 73 | void kh_resize_##name(mrb_state *mrb, kh_##name##_t *h, khint_t new_n_buckets); \ 74 | void kh_del_##name(mrb_state *mrb, kh_##name##_t *h, khint_t x); \ 75 | kh_##name##_t *kh_copy_##name(mrb_state *mrb, kh_##name##_t *h); 76 | 77 | static inline void 78 | kh_fill_flags(uint8_t *p, uint8_t c, size_t len) 79 | { 80 | while (len-- > 0) { 81 | *p++ = c; 82 | } 83 | } 84 | 85 | /* define kh_xxx_funcs 86 | 87 | name: hash name 88 | khkey_t: key data type 89 | khval_t: value data type 90 | kh_is_map: (0: hash set / 1: hash map) 91 | __hash_func: hash function 92 | __hash_equal: hash comparation function 93 | */ 94 | #define KHASH_DEFINE(name, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \ 95 | void kh_alloc_##name(mrb_state *mrb, kh_##name##_t *h) \ 96 | { \ 97 | khint_t sz = h->n_buckets; \ 98 | size_t len = sizeof(khkey_t) + (kh_is_map ? sizeof(khval_t) : 0); \ 99 | uint8_t *p = (uint8_t*)mrb_malloc(mrb, sizeof(uint8_t)*sz/4+len*sz); \ 100 | h->size = h->n_occupied = 0; \ 101 | h->keys = (khkey_t *)p; \ 102 | h->vals = kh_is_map ? (khval_t *)(p+sizeof(khkey_t)*sz) : NULL; \ 103 | h->ed_flags = p+len*sz; \ 104 | kh_fill_flags(h->ed_flags, 0xaa, sz/4); \ 105 | } \ 106 | kh_##name##_t *kh_init_##name##_size(mrb_state *mrb, khint_t size) { \ 107 | kh_##name##_t *h = (kh_##name##_t*)mrb_calloc(mrb, 1, sizeof(kh_##name##_t)); \ 108 | if (size < KHASH_MIN_SIZE) \ 109 | size = KHASH_MIN_SIZE; \ 110 | khash_power2(size); \ 111 | h->n_buckets = size; \ 112 | kh_alloc_##name(mrb, h); \ 113 | return h; \ 114 | } \ 115 | kh_##name##_t *kh_init_##name(mrb_state *mrb){ \ 116 | return kh_init_##name##_size(mrb, KHASH_DEFAULT_SIZE); \ 117 | } \ 118 | void kh_destroy_##name(mrb_state *mrb, kh_##name##_t *h) \ 119 | { \ 120 | if (h) { \ 121 | mrb_free(mrb, h->keys); \ 122 | mrb_free(mrb, h); \ 123 | } \ 124 | } \ 125 | void kh_clear_##name(mrb_state *mrb, kh_##name##_t *h) \ 126 | { \ 127 | (void)mrb; \ 128 | if (h && h->ed_flags) { \ 129 | kh_fill_flags(h->ed_flags, 0xaa, h->n_buckets/4); \ 130 | h->size = h->n_occupied = 0; \ 131 | } \ 132 | } \ 133 | khint_t kh_get_##name(mrb_state *mrb, kh_##name##_t *h, khkey_t key) \ 134 | { \ 135 | khint_t k = __hash_func(mrb,key) & khash_mask(h), step = 0; \ 136 | (void)mrb; \ 137 | while (!__ac_isempty(h->ed_flags, k)) { \ 138 | if (!__ac_isdel(h->ed_flags, k)) { \ 139 | if (__hash_equal(mrb,h->keys[k], key)) return k; \ 140 | } \ 141 | k = (k+(++step)) & khash_mask(h); \ 142 | } \ 143 | return kh_end(h); \ 144 | } \ 145 | void kh_resize_##name(mrb_state *mrb, kh_##name##_t *h, khint_t new_n_buckets) \ 146 | { \ 147 | if (new_n_buckets < KHASH_MIN_SIZE) \ 148 | new_n_buckets = KHASH_MIN_SIZE; \ 149 | khash_power2(new_n_buckets); \ 150 | { \ 151 | uint8_t *old_ed_flags = h->ed_flags; \ 152 | khkey_t *old_keys = h->keys; \ 153 | khval_t *old_vals = h->vals; \ 154 | khint_t old_n_buckets = h->n_buckets; \ 155 | khint_t i; \ 156 | h->n_buckets = new_n_buckets; \ 157 | kh_alloc_##name(mrb, h); \ 158 | /* relocate */ \ 159 | for (i=0 ; in_occupied >= khash_upper_bound(h)) { \ 172 | kh_resize_##name(mrb, h, h->n_buckets*2); \ 173 | } \ 174 | k = __hash_func(mrb,key) & khash_mask(h); \ 175 | del_k = kh_end(h); \ 176 | while (!__ac_isempty(h->ed_flags, k)) { \ 177 | if (!__ac_isdel(h->ed_flags, k)) { \ 178 | if (__hash_equal(mrb,h->keys[k], key)) { \ 179 | if (ret) *ret = 0; \ 180 | return k; \ 181 | } \ 182 | } \ 183 | else if (del_k == kh_end(h)) { \ 184 | del_k = k; \ 185 | } \ 186 | k = (k+(++step)) & khash_mask(h); \ 187 | } \ 188 | if (del_k != kh_end(h)) { \ 189 | /* put at del */ \ 190 | h->keys[del_k] = key; \ 191 | h->ed_flags[del_k/4] &= ~__m_del[del_k%4]; \ 192 | h->size++; \ 193 | if (ret) *ret = 2; \ 194 | return del_k; \ 195 | } \ 196 | else { \ 197 | /* put at empty */ \ 198 | h->keys[k] = key; \ 199 | h->ed_flags[k/4] &= ~__m_empty[k%4]; \ 200 | h->size++; \ 201 | h->n_occupied++; \ 202 | if (ret) *ret = 1; \ 203 | return k; \ 204 | } \ 205 | } \ 206 | void kh_del_##name(mrb_state *mrb, kh_##name##_t *h, khint_t x) \ 207 | { \ 208 | (void)mrb; \ 209 | mrb_assert(x != h->n_buckets && !__ac_iseither(h->ed_flags, x)); \ 210 | h->ed_flags[x/4] |= __m_del[x%4]; \ 211 | h->size--; \ 212 | } \ 213 | kh_##name##_t *kh_copy_##name(mrb_state *mrb, kh_##name##_t *h) \ 214 | { \ 215 | kh_##name##_t *h2; \ 216 | khiter_t k, k2; \ 217 | \ 218 | h2 = kh_init_##name(mrb); \ 219 | for (k = kh_begin(h); k != kh_end(h); k++) { \ 220 | if (kh_exist(h, k)) { \ 221 | k2 = kh_put_##name(mrb, h2, kh_key(h, k), NULL); \ 222 | if (kh_is_map) kh_value(h2, k2) = kh_value(h, k); \ 223 | } \ 224 | } \ 225 | return h2; \ 226 | } 227 | 228 | 229 | #define khash_t(name) kh_##name##_t 230 | 231 | #define kh_init_size(name,mrb,size) kh_init_##name##_size(mrb,size) 232 | #define kh_init(name,mrb) kh_init_##name(mrb) 233 | #define kh_destroy(name, mrb, h) kh_destroy_##name(mrb, h) 234 | #define kh_clear(name, mrb, h) kh_clear_##name(mrb, h) 235 | #define kh_resize(name, mrb, h, s) kh_resize_##name(mrb, h, s) 236 | #define kh_put(name, mrb, h, k) kh_put_##name(mrb, h, k, NULL) 237 | #define kh_put2(name, mrb, h, k, r) kh_put_##name(mrb, h, k, r) 238 | #define kh_get(name, mrb, h, k) kh_get_##name(mrb, h, k) 239 | #define kh_del(name, mrb, h, k) kh_del_##name(mrb, h, k) 240 | #define kh_copy(name, mrb, h) kh_copy_##name(mrb, h) 241 | 242 | #define kh_exist(h, x) (!__ac_iseither((h)->ed_flags, (x))) 243 | #define kh_key(h, x) ((h)->keys[x]) 244 | #define kh_val(h, x) ((h)->vals[x]) 245 | #define kh_value(h, x) ((h)->vals[x]) 246 | #define kh_begin(h) (khint_t)(0) 247 | #define kh_end(h) ((h)->n_buckets) 248 | #define kh_size(h) ((h)->size) 249 | #define kh_n_buckets(h) ((h)->n_buckets) 250 | 251 | #define kh_int_hash_func(mrb,key) (khint_t)((key)^((key)<<2)^((key)>>2)) 252 | #define kh_int_hash_equal(mrb,a, b) (a == b) 253 | #define kh_int64_hash_func(mrb,key) (khint_t)((key)>>33^(key)^(key)<<11) 254 | #define kh_int64_hash_equal(mrb,a, b) (a == b) 255 | static inline khint_t __ac_X31_hash_string(const char *s) 256 | { 257 | khint_t h = *s; 258 | if (h) for (++s ; *s; ++s) h = (h << 5) - h + *s; 259 | return h; 260 | } 261 | #define kh_str_hash_func(mrb,key) __ac_X31_hash_string(key) 262 | #define kh_str_hash_equal(mrb,a, b) (strcmp(a, b) == 0) 263 | 264 | typedef const char *kh_cstr_t; 265 | 266 | #if defined(__cplusplus) 267 | } /* extern "C" { */ 268 | #endif 269 | 270 | #endif /* KHASH_H */ 271 | -------------------------------------------------------------------------------- /MRuby.framework/Versions/1.0.0/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 | #if defined(__cplusplus) 11 | extern "C" { 12 | #endif 13 | 14 | #define POSFIXABLE(f) ((f) <= MRB_INT_MAX) 15 | #define NEGFIXABLE(f) ((f) >= MRB_INT_MIN) 16 | #define FIXABLE(f) (POSFIXABLE(f) && NEGFIXABLE(f)) 17 | 18 | mrb_value mrb_flo_to_fixnum(mrb_state *mrb, mrb_value val); 19 | 20 | mrb_value mrb_fixnum_to_str(mrb_state *mrb, mrb_value x, int base); 21 | 22 | mrb_value mrb_fixnum_plus(mrb_state *mrb, mrb_value x, mrb_value y); 23 | mrb_value mrb_fixnum_minus(mrb_state *mrb, mrb_value x, mrb_value y); 24 | mrb_value mrb_fixnum_mul(mrb_state *mrb, mrb_value x, mrb_value y); 25 | mrb_value mrb_num_div(mrb_state *mrb, mrb_value x, mrb_value y); 26 | mrb_float mrb_to_flo(mrb_state *mrb, mrb_value x); 27 | 28 | #define MRB_UINT_MAKE2(n) uint ## n ## _t 29 | #define MRB_UINT_MAKE(n) MRB_UINT_MAKE2(n) 30 | #define mrb_uint MRB_UINT_MAKE(MRB_INT_BIT) 31 | 32 | #ifdef MRB_WORD_BOXING 33 | # define MRB_INT_OVERFLOW_MASK ((mrb_uint)1 << (MRB_INT_BIT - 1 - MRB_FIXNUM_SHIFT)) 34 | #else 35 | # define MRB_INT_OVERFLOW_MASK ((mrb_uint)1 << (MRB_INT_BIT - 1)) 36 | #endif 37 | 38 | static inline mrb_bool 39 | mrb_int_add_overflow(mrb_int augend, mrb_int addend, mrb_int *sum) 40 | { 41 | mrb_uint x = (mrb_uint)augend; 42 | mrb_uint y = (mrb_uint)addend; 43 | mrb_uint z = (mrb_uint)(x + y); 44 | *sum = (mrb_int)z; 45 | return !!(((x ^ z) & (y ^ z)) & MRB_INT_OVERFLOW_MASK); 46 | } 47 | 48 | static inline mrb_bool 49 | mrb_int_sub_overflow(mrb_int minuend, mrb_int subtrahend, mrb_int *difference) 50 | { 51 | mrb_uint x = (mrb_uint)minuend; 52 | mrb_uint y = (mrb_uint)subtrahend; 53 | mrb_uint z = (mrb_uint)(x - y); 54 | *difference = (mrb_int)z; 55 | return !!(((x ^ z) & (~y ^ z)) & MRB_INT_OVERFLOW_MASK); 56 | } 57 | 58 | #undef MRB_INT_OVERFLOW_MASK 59 | #undef mrb_uint 60 | #undef MRB_UINT_MAKE 61 | #undef MRB_UINT_MAKE2 62 | 63 | #if defined(__cplusplus) 64 | } /* extern "C" { */ 65 | #endif 66 | 67 | #endif /* MRUBY_NUMERIC_H */ 68 | -------------------------------------------------------------------------------- /MRuby.framework/Versions/1.0.0/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 "../mruby/irep.h" 11 | 12 | #if defined(__cplusplus) 13 | extern "C" { 14 | #endif 15 | 16 | struct REnv { 17 | MRB_OBJECT_HEADER; 18 | mrb_value *stack; 19 | mrb_sym mid; 20 | ptrdiff_t cioff; 21 | }; 22 | 23 | #define MRB_ENV_STACK_LEN(e) ((e)->flags) 24 | #define MRB_ENV_UNSHARE_STACK(e) ((e)->cioff = -1) 25 | #define MRB_ENV_STACK_SHARED_P(e) ((e)->cioff >= 0) 26 | 27 | struct RProc { 28 | MRB_OBJECT_HEADER; 29 | union { 30 | mrb_irep *irep; 31 | mrb_func_t func; 32 | } body; 33 | struct RClass *target_class; 34 | struct REnv *env; 35 | }; 36 | 37 | /* aspec access */ 38 | #define MRB_ASPEC_REQ(a) (((a) >> 18) & 0x1f) 39 | #define MRB_ASPEC_OPT(a) (((a) >> 13) & 0x1f) 40 | #define MRB_ASPEC_REST(a) ((a) & (1<<12)) 41 | #define MRB_ASPEC_POST(a) (((a) >> 7) & 0x1f) 42 | #define MRB_ASPEC_KEY(a) (((a) >> 2) & 0x1f) 43 | #define MRB_ASPEC_KDICT(a) ((a) & (1<<1)) 44 | #define MRB_ASPEC_BLOCK(a) ((a) & 1) 45 | 46 | #define MRB_PROC_CFUNC 128 47 | #define MRB_PROC_CFUNC_P(p) (((p)->flags & MRB_PROC_CFUNC) != 0) 48 | #define MRB_PROC_STRICT 256 49 | #define MRB_PROC_STRICT_P(p) (((p)->flags & MRB_PROC_STRICT) != 0) 50 | 51 | #define mrb_proc_ptr(v) ((struct RProc*)(mrb_ptr(v))) 52 | 53 | struct RProc *mrb_proc_new(mrb_state*, mrb_irep*); 54 | struct RProc *mrb_proc_new_cfunc(mrb_state*, mrb_func_t); 55 | struct RProc *mrb_closure_new(mrb_state*, mrb_irep*); 56 | struct RProc *mrb_closure_new_cfunc(mrb_state *mrb, mrb_func_t func, int nlocals); 57 | void mrb_proc_copy(struct RProc *a, struct RProc *b); 58 | 59 | /* implementation of #send method */ 60 | mrb_value mrb_f_send(mrb_state *mrb, mrb_value self); 61 | 62 | /* following functions are defined in mruby-proc-ext so please include it when using */ 63 | struct RProc *mrb_proc_new_cfunc_with_env(mrb_state*, mrb_func_t, mrb_int, const mrb_value*); 64 | mrb_value mrb_cfunc_env_get(mrb_state*, mrb_int); 65 | 66 | #include "../mruby/khash.h" 67 | KHASH_DECLARE(mt, mrb_sym, struct RProc*, TRUE) 68 | 69 | #if defined(__cplusplus) 70 | } /* extern "C" { */ 71 | #endif 72 | 73 | #endif /* MRUBY_PROC_H */ 74 | -------------------------------------------------------------------------------- /MRuby.framework/Versions/1.0.0/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 | #if defined(__cplusplus) 11 | extern "C" { 12 | #endif 13 | 14 | typedef struct mrb_range_edges { 15 | mrb_value beg; 16 | mrb_value end; 17 | } mrb_range_edges; 18 | 19 | struct RRange { 20 | MRB_OBJECT_HEADER; 21 | mrb_range_edges *edges; 22 | mrb_bool excl : 1; 23 | }; 24 | 25 | #define mrb_range_ptr(v) ((struct RRange*)(mrb_ptr(v))) 26 | #define mrb_range_value(p) mrb_obj_value((void*)(p)) 27 | 28 | mrb_value mrb_range_new(mrb_state*, mrb_value, mrb_value, mrb_bool); 29 | mrb_bool mrb_range_beg_len(mrb_state *mrb, mrb_value range, mrb_int *begp, mrb_int *lenp, mrb_int len); 30 | 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)); 31 | 32 | #if defined(__cplusplus) 33 | } /* extern "C" { */ 34 | #endif 35 | 36 | #endif /* MRUBY_RANGE_H */ 37 | -------------------------------------------------------------------------------- /MRuby.framework/Versions/1.0.0/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 | #ifdef __cplusplus 11 | extern "C" { 12 | #endif 13 | 14 | #define REGEXP_CLASS "Regexp" 15 | 16 | #ifdef __cplusplus 17 | } 18 | #endif 19 | 20 | #endif /* RE_H */ 21 | -------------------------------------------------------------------------------- /MRuby.framework/Versions/1.0.0/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 | #if defined(__cplusplus) 11 | extern "C" { 12 | #endif 13 | 14 | #define IS_EVSTR(p,e) ((p) < (e) && (*(p) == '$' || *(p) == '@' || *(p) == '{')) 15 | 16 | extern const char mrb_digitmap[]; 17 | 18 | #define RSTRING_EMBED_LEN_MAX ((mrb_int)(sizeof(void*) * 3 - 1)) 19 | 20 | struct RString { 21 | MRB_OBJECT_HEADER; 22 | union { 23 | struct { 24 | mrb_int len; 25 | union { 26 | mrb_int capa; 27 | struct mrb_shared_string *shared; 28 | } aux; 29 | char *ptr; 30 | } heap; 31 | char ary[RSTRING_EMBED_LEN_MAX + 1]; 32 | } as; 33 | }; 34 | 35 | #define mrb_str_ptr(s) ((struct RString*)(mrb_ptr(s))) 36 | #define RSTRING(s) ((struct RString*)(mrb_ptr(s))) 37 | #define RSTRING_PTR(s)\ 38 | ((RSTRING(s)->flags & MRB_STR_EMBED) ?\ 39 | RSTRING(s)->as.ary :\ 40 | RSTRING(s)->as.heap.ptr) 41 | #define RSTRING_LEN(s)\ 42 | ((RSTRING(s)->flags & MRB_STR_EMBED) ?\ 43 | (mrb_int)((RSTRING(s)->flags & MRB_STR_EMBED_LEN_MASK) >> MRB_STR_EMBED_LEN_SHIFT) :\ 44 | RSTRING(s)->as.heap.len) 45 | #define RSTRING_CAPA(s)\ 46 | ((RSTRING(s)->flags & MRB_STR_EMBED) ?\ 47 | RSTRING_EMBED_LEN_MAX :\ 48 | RSTRING(s)->as.heap.aux.capa) 49 | #define RSTRING_END(s) (RSTRING_PTR(s) + RSTRING_LEN(s)) 50 | mrb_int mrb_str_strlen(mrb_state*, struct RString*); 51 | 52 | #define MRB_STR_SHARED 1 53 | #define MRB_STR_NOFREE 2 54 | #define MRB_STR_EMBED 4 55 | #define MRB_STR_EMBED_LEN_MASK 0xf8 56 | #define MRB_STR_EMBED_LEN_SHIFT 3 57 | 58 | void mrb_gc_free_str(mrb_state*, struct RString*); 59 | void mrb_str_modify(mrb_state*, struct RString*); 60 | void mrb_str_concat(mrb_state*, mrb_value, mrb_value); 61 | mrb_value mrb_str_plus(mrb_state*, mrb_value, mrb_value); 62 | mrb_value mrb_ptr_to_str(mrb_state *, void*); 63 | mrb_value mrb_obj_as_string(mrb_state *mrb, mrb_value obj); 64 | mrb_value mrb_str_resize(mrb_state *mrb, mrb_value str, mrb_int len); 65 | mrb_value mrb_str_substr(mrb_state *mrb, mrb_value str, mrb_int beg, mrb_int len); 66 | mrb_value mrb_string_type(mrb_state *mrb, mrb_value str); 67 | mrb_value mrb_check_string_type(mrb_state *mrb, mrb_value str); 68 | mrb_value mrb_str_buf_new(mrb_state *mrb, size_t capa); 69 | 70 | char *mrb_string_value_cstr(mrb_state *mrb, mrb_value *ptr); 71 | char *mrb_string_value_ptr(mrb_state *mrb, mrb_value ptr); 72 | mrb_value mrb_str_dup(mrb_state *mrb, mrb_value str); 73 | mrb_value mrb_str_intern(mrb_state *mrb, mrb_value self); 74 | mrb_value mrb_str_to_inum(mrb_state *mrb, mrb_value str, mrb_int base, mrb_bool badcheck); 75 | double mrb_str_to_dbl(mrb_state *mrb, mrb_value str, mrb_bool badcheck); 76 | mrb_value mrb_str_to_str(mrb_state *mrb, mrb_value str); 77 | mrb_int mrb_str_hash(mrb_state *mrb, mrb_value str); 78 | mrb_value mrb_str_inspect(mrb_state *mrb, mrb_value str); 79 | mrb_bool mrb_str_equal(mrb_state *mrb, mrb_value str1, mrb_value str2); 80 | mrb_value mrb_str_dump(mrb_state *mrb, mrb_value str); 81 | mrb_value mrb_str_cat(mrb_state *mrb, mrb_value str, const char *ptr, size_t len); 82 | mrb_value mrb_str_cat_cstr(mrb_state *mrb, mrb_value str, const char *ptr); 83 | mrb_value mrb_str_cat_str(mrb_state *mrb, mrb_value str, mrb_value str2); 84 | #define mrb_str_cat_lit(mrb, str, lit) mrb_str_cat(mrb, str, lit, mrb_strlen_lit(lit)) 85 | mrb_value mrb_str_append(mrb_state *mrb, mrb_value str, mrb_value str2); 86 | 87 | int mrb_str_cmp(mrb_state *mrb, mrb_value str1, mrb_value str2); 88 | char *mrb_str_to_cstr(mrb_state *mrb, mrb_value str); 89 | mrb_value mrb_str_pool(mrb_state *mrb, mrb_value str); 90 | 91 | /* For backward compatibility */ 92 | static inline mrb_value 93 | mrb_str_cat2(mrb_state *mrb, mrb_value str, const char *ptr) { 94 | return mrb_str_cat_cstr(mrb, str, ptr); 95 | } 96 | 97 | static inline mrb_value 98 | mrb_str_buf_cat(mrb_state *mrb, mrb_value str, const char *ptr, size_t len) 99 | { 100 | return mrb_str_cat(mrb, str, ptr, len); 101 | } 102 | 103 | static inline mrb_value 104 | mrb_str_buf_append(mrb_state *mrb, mrb_value str, mrb_value str2) 105 | { 106 | return mrb_str_cat_str(mrb, str, str2); 107 | } 108 | 109 | #if defined(__cplusplus) 110 | } /* extern "C" { */ 111 | #endif 112 | 113 | #endif /* MRUBY_STRING_H */ 114 | -------------------------------------------------------------------------------- /MRuby.framework/Versions/1.0.0/Headers/mruby/value.h: -------------------------------------------------------------------------------- 1 | /* 2 | ** mruby/value.h - mrb_value definition 3 | ** 4 | ** See Copyright Notice in ../mruby.h 5 | */ 6 | 7 | #ifndef MRUBY_VALUE_H 8 | #define MRUBY_VALUE_H 9 | 10 | #ifdef MRB_USE_FLOAT 11 | typedef float mrb_float; 12 | # define mrb_float_to_str(buf, i) sprintf(buf, "%.7e", i) 13 | # define str_to_mrb_float(buf) strtof(buf, NULL) 14 | #else 15 | typedef double mrb_float; 16 | # define mrb_float_to_str(buf, i) sprintf(buf, "%.16e", i) 17 | # define str_to_mrb_float(buf) strtod(buf, NULL) 18 | #endif 19 | 20 | #if defined(MRB_INT16) && defined(MRB_INT64) 21 | # error "You can't define MRB_INT16 and MRB_INT64 at the same time." 22 | #endif 23 | 24 | #if defined(MRB_INT64) 25 | # ifdef MRB_NAN_BOXING 26 | # error Cannot use NaN boxing when mrb_int is 64bit 27 | # else 28 | typedef int64_t mrb_int; 29 | # define MRB_INT_BIT 64 30 | # define MRB_INT_MIN INT64_MIN 31 | # define MRB_INT_MAX INT64_MAX 32 | # define PRIdMRB_INT PRId64 33 | # define PRIiMRB_INT PRIi64 34 | # define PRIoMRB_INT PRIo64 35 | # define PRIxMRB_INT PRIx64 36 | # define PRIXMRB_INT PRIX64 37 | # endif 38 | #elif defined(MRB_INT16) 39 | typedef int16_t mrb_int; 40 | # define MRB_INT_BIT 16 41 | # define MRB_INT_MIN INT16_MIN 42 | # define MRB_INT_MAX INT16_MAX 43 | #else 44 | typedef int32_t mrb_int; 45 | # define MRB_INT_BIT 32 46 | # define MRB_INT_MIN INT32_MIN 47 | # define MRB_INT_MAX INT32_MAX 48 | # define PRIdMRB_INT PRId32 49 | # define PRIiMRB_INT PRIi32 50 | # define PRIoMRB_INT PRIo32 51 | # define PRIxMRB_INT PRIx32 52 | # define PRIXMRB_INT PRIX32 53 | #endif 54 | typedef short mrb_sym; 55 | 56 | #ifdef _MSC_VER 57 | # ifndef __cplusplus 58 | # define inline __inline 59 | # endif 60 | # define snprintf _snprintf 61 | # if _MSC_VER < 1800 62 | # include 63 | # define isfinite(n) _finite(n) 64 | # define isnan _isnan 65 | # define isinf(n) (!_finite(n) && !_isnan(n)) 66 | # define signbit(n) (_copysign(1.0, (n)) < 0.0) 67 | # define strtoll _strtoi64 68 | # define strtof (float)strtod 69 | # define PRId32 "I32d" 70 | # define PRIi32 "I32i" 71 | # define PRIo32 "I32o" 72 | # define PRIx32 "I32x" 73 | # define PRIX32 "I32X" 74 | # define PRId64 "I64d" 75 | # define PRIi64 "I64i" 76 | # define PRIo64 "I64o" 77 | # define PRIx64 "I64x" 78 | # define PRIX64 "I64X" 79 | static unsigned int IEEE754_INFINITY_BITS_SINGLE = 0x7F800000; 80 | # define INFINITY (*(float *)&IEEE754_INFINITY_BITS_SINGLE) 81 | # define NAN ((float)(INFINITY - INFINITY)) 82 | # else 83 | # include 84 | # endif 85 | #else 86 | # include 87 | #endif 88 | 89 | typedef uint8_t mrb_bool; 90 | struct mrb_state; 91 | 92 | #if defined(MRB_NAN_BOXING) 93 | 94 | #ifdef MRB_USE_FLOAT 95 | # error ---->> MRB_NAN_BOXING and MRB_USE_FLOAT conflict <<---- 96 | #endif 97 | 98 | #ifdef MRB_INT64 99 | # error ---->> MRB_NAN_BOXING and MRB_INT64 conflict <<---- 100 | #endif 101 | 102 | enum mrb_vtype { 103 | MRB_TT_FALSE = 1, /* 1 */ 104 | MRB_TT_FREE, /* 2 */ 105 | MRB_TT_TRUE, /* 3 */ 106 | MRB_TT_FIXNUM, /* 4 */ 107 | MRB_TT_SYMBOL, /* 5 */ 108 | MRB_TT_UNDEF, /* 6 */ 109 | MRB_TT_FLOAT, /* 7 */ 110 | MRB_TT_CPTR, /* 8 */ 111 | MRB_TT_OBJECT, /* 9 */ 112 | MRB_TT_CLASS, /* 10 */ 113 | MRB_TT_MODULE, /* 11 */ 114 | MRB_TT_ICLASS, /* 12 */ 115 | MRB_TT_SCLASS, /* 13 */ 116 | MRB_TT_PROC, /* 14 */ 117 | MRB_TT_ARRAY, /* 15 */ 118 | MRB_TT_HASH, /* 16 */ 119 | MRB_TT_STRING, /* 17 */ 120 | MRB_TT_RANGE, /* 18 */ 121 | MRB_TT_EXCEPTION, /* 19 */ 122 | MRB_TT_FILE, /* 20 */ 123 | MRB_TT_ENV, /* 21 */ 124 | MRB_TT_DATA, /* 22 */ 125 | MRB_TT_FIBER, /* 23 */ 126 | MRB_TT_MAXDEFINE /* 24 */ 127 | }; 128 | 129 | #define MRB_TT_HAS_BASIC MRB_TT_OBJECT 130 | 131 | #ifdef MRB_ENDIAN_BIG 132 | #define MRB_ENDIAN_LOHI(a,b) a b 133 | #else 134 | #define MRB_ENDIAN_LOHI(a,b) b a 135 | #endif 136 | 137 | typedef struct mrb_value { 138 | union { 139 | mrb_float f; 140 | union { 141 | void *p; 142 | struct { 143 | MRB_ENDIAN_LOHI( 144 | uint32_t ttt; 145 | ,union { 146 | mrb_int i; 147 | mrb_sym sym; 148 | }; 149 | ) 150 | }; 151 | } value; 152 | }; 153 | } mrb_value; 154 | 155 | /* value representation by nan-boxing: 156 | * float : FFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFF FFFFFFFFFFFFFFFF 157 | * object: 111111111111TTTT TTPPPPPPPPPPPPPP PPPPPPPPPPPPPPPP PPPPPPPPPPPPPPPP 158 | * int : 1111111111110001 0000000000000000 IIIIIIIIIIIIIIII IIIIIIIIIIIIIIII 159 | * sym : 1111111111110001 0100000000000000 SSSSSSSSSSSSSSSS SSSSSSSSSSSSSSSS 160 | * In order to get enough bit size to save TT, all pointers are shifted 2 bits 161 | * in the right direction. 162 | */ 163 | #define mrb_tt(o) ((enum mrb_vtype)(((o).value.ttt & 0xfc000)>>14)) 164 | #define mrb_mktt(tt) (0xfff00000|((tt)<<14)) 165 | #define mrb_type(o) ((uint32_t)0xfff00000 < (o).value.ttt ? mrb_tt(o) : MRB_TT_FLOAT) 166 | #define mrb_ptr(o) ((void*)((((uintptr_t)0x3fffffffffff)&((uintptr_t)((o).value.p)))<<2)) 167 | #define mrb_float(o) (o).f 168 | 169 | #define MRB_SET_VALUE(o, tt, attr, v) do {\ 170 | (o).value.ttt = mrb_mktt(tt);\ 171 | switch (tt) {\ 172 | case MRB_TT_FALSE:\ 173 | case MRB_TT_TRUE:\ 174 | case MRB_TT_UNDEF:\ 175 | case MRB_TT_FIXNUM:\ 176 | case MRB_TT_SYMBOL: (o).attr = (v); break;\ 177 | default: (o).value.i = 0; (o).value.p = (void*)((uintptr_t)(o).value.p | (((uintptr_t)(v))>>2)); break;\ 178 | }\ 179 | } while (0) 180 | 181 | static inline mrb_value 182 | mrb_float_value(struct mrb_state *mrb, mrb_float f) 183 | { 184 | mrb_value v; 185 | 186 | if (f != f) { 187 | v.value.ttt = 0x7ff80000; 188 | v.value.i = 0; 189 | } else { 190 | v.f = f; 191 | } 192 | return v; 193 | } 194 | #define mrb_float_pool(mrb,f) mrb_float_value(mrb,f) 195 | 196 | #else 197 | 198 | enum mrb_vtype { 199 | MRB_TT_FALSE = 0, /* 0 */ 200 | MRB_TT_FREE, /* 1 */ 201 | MRB_TT_TRUE, /* 2 */ 202 | MRB_TT_FIXNUM, /* 3 */ 203 | MRB_TT_SYMBOL, /* 4 */ 204 | MRB_TT_UNDEF, /* 5 */ 205 | MRB_TT_FLOAT, /* 6 */ 206 | MRB_TT_CPTR, /* 7 */ 207 | MRB_TT_OBJECT, /* 8 */ 208 | MRB_TT_CLASS, /* 9 */ 209 | MRB_TT_MODULE, /* 10 */ 210 | MRB_TT_ICLASS, /* 11 */ 211 | MRB_TT_SCLASS, /* 12 */ 212 | MRB_TT_PROC, /* 13 */ 213 | MRB_TT_ARRAY, /* 14 */ 214 | MRB_TT_HASH, /* 15 */ 215 | MRB_TT_STRING, /* 16 */ 216 | MRB_TT_RANGE, /* 17 */ 217 | MRB_TT_EXCEPTION, /* 18 */ 218 | MRB_TT_FILE, /* 19 */ 219 | MRB_TT_ENV, /* 20 */ 220 | MRB_TT_DATA, /* 21 */ 221 | MRB_TT_FIBER, /* 22 */ 222 | MRB_TT_MAXDEFINE /* 23 */ 223 | }; 224 | 225 | #if defined(MRB_WORD_BOXING) 226 | 227 | #include 228 | #define MRB_TT_HAS_BASIC MRB_TT_FLOAT 229 | 230 | enum mrb_special_consts { 231 | MRB_Qnil = 0, 232 | MRB_Qfalse = 2, 233 | MRB_Qtrue = 4, 234 | MRB_Qundef = 6, 235 | }; 236 | 237 | #define MRB_FIXNUM_FLAG 0x01 238 | #define MRB_FIXNUM_SHIFT 1 239 | #define MRB_SYMBOL_FLAG 0x0e 240 | #define MRB_SPECIAL_SHIFT 8 241 | 242 | typedef union mrb_value { 243 | union { 244 | void *p; 245 | struct { 246 | unsigned int i_flag : MRB_FIXNUM_SHIFT; 247 | mrb_int i : (MRB_INT_BIT - MRB_FIXNUM_SHIFT); 248 | }; 249 | struct { 250 | unsigned int sym_flag : MRB_SPECIAL_SHIFT; 251 | int sym : (sizeof(mrb_sym) * CHAR_BIT); 252 | }; 253 | struct RBasic *bp; 254 | struct RFloat *fp; 255 | struct RCptr *vp; 256 | } value; 257 | unsigned long w; 258 | } mrb_value; 259 | 260 | #define mrb_ptr(o) (o).value.p 261 | #define mrb_float(o) (o).value.fp->f 262 | 263 | #define MRB_SET_VALUE(o, ttt, attr, v) do {\ 264 | (o).w = 0;\ 265 | (o).attr = (v);\ 266 | switch (ttt) {\ 267 | case MRB_TT_FALSE: (o).w = (v) ? MRB_Qfalse : MRB_Qnil; break;\ 268 | case MRB_TT_TRUE: (o).w = MRB_Qtrue; break;\ 269 | case MRB_TT_UNDEF: (o).w = MRB_Qundef; break;\ 270 | case MRB_TT_FIXNUM: (o).value.i_flag = MRB_FIXNUM_FLAG; break;\ 271 | case MRB_TT_SYMBOL: (o).value.sym_flag = MRB_SYMBOL_FLAG; break;\ 272 | default: if ((o).value.bp) (o).value.bp->tt = ttt; break;\ 273 | }\ 274 | } while (0) 275 | 276 | mrb_value mrb_float_value(struct mrb_state *mrb, mrb_float f); 277 | mrb_value mrb_float_pool(struct mrb_state *mrb, mrb_float f); 278 | 279 | #else /* No MRB_xxx_BOXING */ 280 | 281 | #define MRB_TT_HAS_BASIC MRB_TT_OBJECT 282 | 283 | typedef struct mrb_value { 284 | union { 285 | mrb_float f; 286 | void *p; 287 | mrb_int i; 288 | mrb_sym sym; 289 | } value; 290 | enum mrb_vtype tt; 291 | } mrb_value; 292 | 293 | #define mrb_type(o) (o).tt 294 | #define mrb_ptr(o) (o).value.p 295 | #define mrb_float(o) (o).value.f 296 | 297 | #define MRB_SET_VALUE(o, ttt, attr, v) do {\ 298 | (o).tt = ttt;\ 299 | (o).attr = v;\ 300 | } while (0) 301 | 302 | static inline mrb_value 303 | mrb_float_value(struct mrb_state *mrb, mrb_float f) 304 | { 305 | mrb_value v; 306 | (void) mrb; 307 | 308 | MRB_SET_VALUE(v, MRB_TT_FLOAT, value.f, f); 309 | return v; 310 | } 311 | #define mrb_float_pool(mrb,f) mrb_float_value(mrb,f) 312 | 313 | #endif /* no boxing */ 314 | 315 | #endif 316 | 317 | #ifdef MRB_WORD_BOXING 318 | 319 | #define mrb_cptr(o) (o).value.vp->p 320 | #define mrb_fixnum_p(o) ((o).value.i_flag == MRB_FIXNUM_FLAG) 321 | #define mrb_undef_p(o) ((o).w == MRB_Qundef) 322 | #define mrb_nil_p(o) ((o).w == MRB_Qnil) 323 | #define mrb_bool(o) ((o).w != MRB_Qnil && (o).w != MRB_Qfalse) 324 | 325 | #else 326 | 327 | #define mrb_cptr(o) mrb_ptr(o) 328 | #define mrb_fixnum_p(o) (mrb_type(o) == MRB_TT_FIXNUM) 329 | #define mrb_undef_p(o) (mrb_type(o) == MRB_TT_UNDEF) 330 | #define mrb_nil_p(o) (mrb_type(o) == MRB_TT_FALSE && !(o).value.i) 331 | #define mrb_bool(o) (mrb_type(o) != MRB_TT_FALSE) 332 | 333 | #endif /* no boxing */ 334 | 335 | #define mrb_fixnum(o) (o).value.i 336 | #define mrb_symbol(o) (o).value.sym 337 | #define mrb_float_p(o) (mrb_type(o) == MRB_TT_FLOAT) 338 | #define mrb_symbol_p(o) (mrb_type(o) == MRB_TT_SYMBOL) 339 | #define mrb_array_p(o) (mrb_type(o) == MRB_TT_ARRAY) 340 | #define mrb_string_p(o) (mrb_type(o) == MRB_TT_STRING) 341 | #define mrb_hash_p(o) (mrb_type(o) == MRB_TT_HASH) 342 | #define mrb_cptr_p(o) (mrb_type(o) == MRB_TT_CPTR) 343 | #define mrb_test(o) mrb_bool(o) 344 | mrb_bool mrb_regexp_p(struct mrb_state*, mrb_value); 345 | 346 | #define MRB_OBJECT_HEADER \ 347 | enum mrb_vtype tt:8;\ 348 | uint32_t color:3;\ 349 | uint32_t flags:21;\ 350 | struct RClass *c;\ 351 | struct RBasic *gcnext 352 | 353 | /* white: 011, black: 100, gray: 000 */ 354 | #define MRB_GC_GRAY 0 355 | #define MRB_GC_WHITE_A 1 356 | #define MRB_GC_WHITE_B (1 << 1) 357 | #define MRB_GC_BLACK (1 << 2) 358 | #define MRB_GC_WHITES (MRB_GC_WHITE_A | MRB_GC_WHITE_B) 359 | #define MRB_GC_COLOR_MASK 7 360 | 361 | #define paint_gray(o) ((o)->color = MRB_GC_GRAY) 362 | #define paint_black(o) ((o)->color = MRB_GC_BLACK) 363 | #define paint_white(o) ((o)->color = MRB_GC_WHITES) 364 | #define paint_partial_white(s, o) ((o)->color = (s)->current_white_part) 365 | #define is_gray(o) ((o)->color == MRB_GC_GRAY) 366 | #define is_white(o) ((o)->color & MRB_GC_WHITES) 367 | #define is_black(o) ((o)->color & MRB_GC_BLACK) 368 | #define is_dead(s, o) (((o)->color & other_white_part(s) & MRB_GC_WHITES) || (o)->tt == MRB_TT_FREE) 369 | #define flip_white_part(s) ((s)->current_white_part = other_white_part(s)) 370 | #define other_white_part(s) ((s)->current_white_part ^ MRB_GC_WHITES) 371 | 372 | struct RBasic { 373 | MRB_OBJECT_HEADER; 374 | }; 375 | #define mrb_basic_ptr(v) ((struct RBasic*)(mrb_ptr(v))) 376 | /* obsolete macro mrb_basic; will be removed soon */ 377 | #define mrb_basic(v) mrb_basic_ptr(v) 378 | 379 | struct RObject { 380 | MRB_OBJECT_HEADER; 381 | struct iv_tbl *iv; 382 | }; 383 | #define mrb_obj_ptr(v) ((struct RObject*)(mrb_ptr(v))) 384 | /* obsolete macro mrb_object; will be removed soon */ 385 | #define mrb_object(o) mrb_obj_ptr(o) 386 | #define mrb_immediate_p(x) (mrb_type(x) <= MRB_TT_CPTR) 387 | #define mrb_special_const_p(x) mrb_immediate_p(x) 388 | 389 | struct RFiber { 390 | MRB_OBJECT_HEADER; 391 | struct mrb_context *cxt; 392 | }; 393 | 394 | #ifdef MRB_WORD_BOXING 395 | struct RFloat { 396 | MRB_OBJECT_HEADER; 397 | mrb_float f; 398 | }; 399 | 400 | struct RCptr { 401 | MRB_OBJECT_HEADER; 402 | void *p; 403 | }; 404 | 405 | static inline enum mrb_vtype 406 | mrb_type(mrb_value o) 407 | { 408 | switch (o.w) { 409 | case MRB_Qfalse: 410 | case MRB_Qnil: 411 | return MRB_TT_FALSE; 412 | case MRB_Qtrue: 413 | return MRB_TT_TRUE; 414 | case MRB_Qundef: 415 | return MRB_TT_UNDEF; 416 | } 417 | if (o.value.i_flag == MRB_FIXNUM_FLAG) { 418 | return MRB_TT_FIXNUM; 419 | } 420 | if (o.value.sym_flag == MRB_SYMBOL_FLAG) { 421 | return MRB_TT_SYMBOL; 422 | } 423 | return o.value.bp->tt; 424 | } 425 | #endif /* MRB_WORD_BOXING */ 426 | 427 | static inline mrb_value 428 | mrb_fixnum_value(mrb_int i) 429 | { 430 | mrb_value v; 431 | 432 | MRB_SET_VALUE(v, MRB_TT_FIXNUM, value.i, i); 433 | return v; 434 | } 435 | 436 | static inline mrb_value 437 | mrb_symbol_value(mrb_sym i) 438 | { 439 | mrb_value v; 440 | 441 | MRB_SET_VALUE(v, MRB_TT_SYMBOL, value.sym, i); 442 | return v; 443 | } 444 | 445 | static inline mrb_value 446 | mrb_obj_value(void *p) 447 | { 448 | mrb_value v; 449 | struct RBasic *b = (struct RBasic*)p; 450 | 451 | MRB_SET_VALUE(v, b->tt, value.p, p); 452 | return v; 453 | } 454 | 455 | #ifdef MRB_WORD_BOXING 456 | mrb_value 457 | mrb_cptr_value(struct mrb_state *mrb, void *p); 458 | #else 459 | static inline mrb_value 460 | mrb_cptr_value(struct mrb_state *mrb, void *p) 461 | { 462 | mrb_value v; 463 | (void) mrb; 464 | 465 | MRB_SET_VALUE(v, MRB_TT_CPTR, value.p, p); 466 | return v; 467 | } 468 | #endif 469 | /* obsolete macros; will be removed */ 470 | #define MRB_TT_VOIDP MRB_TT_CPTR 471 | #define mrb_voidp_value(m,p) mrb_cptr_value((m),(p)) 472 | #define mrb_voidp(o) mrb_cptr(o) 473 | #define mrb_voidp_p(o) mrb_cptr_p(o) 474 | 475 | #define MRB_TT_HAS_BASIC_P(tt) ((tt) >= MRB_TT_HAS_BASIC) 476 | 477 | static inline mrb_value 478 | mrb_false_value(void) 479 | { 480 | mrb_value v; 481 | 482 | MRB_SET_VALUE(v, MRB_TT_FALSE, value.i, 1); 483 | return v; 484 | } 485 | 486 | static inline mrb_value 487 | mrb_nil_value(void) 488 | { 489 | mrb_value v; 490 | 491 | MRB_SET_VALUE(v, MRB_TT_FALSE, value.i, 0); 492 | return v; 493 | } 494 | 495 | static inline mrb_value 496 | mrb_true_value(void) 497 | { 498 | mrb_value v; 499 | 500 | MRB_SET_VALUE(v, MRB_TT_TRUE, value.i, 1); 501 | return v; 502 | } 503 | 504 | static inline mrb_value 505 | mrb_undef_value(void) 506 | { 507 | mrb_value v; 508 | 509 | MRB_SET_VALUE(v, MRB_TT_UNDEF, value.i, 0); 510 | return v; 511 | } 512 | 513 | static inline mrb_value 514 | mrb_bool_value(mrb_bool boolean) 515 | { 516 | mrb_value v; 517 | 518 | MRB_SET_VALUE(v, boolean ? MRB_TT_TRUE : MRB_TT_FALSE, value.i, 1); 519 | return v; 520 | } 521 | 522 | #endif /* MRUBY_VALUE_H */ 523 | -------------------------------------------------------------------------------- /MRuby.framework/Versions/1.0.0/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 | #if defined(__cplusplus) 11 | extern "C" { 12 | #endif 13 | 14 | typedef struct global_variable { 15 | int counter; 16 | mrb_value *data; 17 | mrb_value (*getter)(void); 18 | void (*setter)(void); 19 | /* void (*marker)(); */ 20 | /* int block_trace; */ 21 | /* struct trace_var *trace; */ 22 | } global_variable; 23 | 24 | struct global_entry { 25 | global_variable *var; 26 | mrb_sym id; 27 | }; 28 | 29 | mrb_value mrb_vm_special_get(mrb_state*, mrb_sym); 30 | void mrb_vm_special_set(mrb_state*, mrb_sym, mrb_value); 31 | mrb_value mrb_vm_iv_get(mrb_state*, mrb_sym); 32 | void mrb_vm_iv_set(mrb_state*, mrb_sym, mrb_value); 33 | mrb_value mrb_vm_cv_get(mrb_state*, mrb_sym); 34 | void mrb_vm_cv_set(mrb_state*, mrb_sym, mrb_value); 35 | mrb_value mrb_vm_const_get(mrb_state*, mrb_sym); 36 | void mrb_vm_const_set(mrb_state*, mrb_sym, mrb_value); 37 | mrb_value mrb_const_get(mrb_state*, mrb_value, mrb_sym); 38 | void mrb_const_set(mrb_state*, mrb_value, mrb_sym, mrb_value); 39 | mrb_bool mrb_const_defined(mrb_state*, mrb_value, mrb_sym); 40 | void mrb_const_remove(mrb_state*, mrb_value, mrb_sym); 41 | 42 | mrb_value mrb_obj_iv_get(mrb_state *mrb, struct RObject *obj, mrb_sym sym); 43 | void mrb_obj_iv_set(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v); 44 | mrb_bool mrb_obj_iv_defined(mrb_state *mrb, struct RObject *obj, mrb_sym sym); 45 | void mrb_obj_iv_ifnone(mrb_state *mrb, struct RObject *obj, mrb_sym sym, mrb_value v); 46 | mrb_value mrb_iv_get(mrb_state *mrb, mrb_value obj, mrb_sym sym); 47 | void mrb_iv_set(mrb_state *mrb, mrb_value obj, mrb_sym sym, mrb_value v); 48 | mrb_bool mrb_iv_defined(mrb_state*, mrb_value, mrb_sym); 49 | mrb_value mrb_iv_remove(mrb_state *mrb, mrb_value obj, mrb_sym sym); 50 | void mrb_iv_copy(mrb_state *mrb, mrb_value dst, mrb_value src); 51 | int mrb_const_defined_at(mrb_state *mrb, struct RClass *klass, mrb_sym id); 52 | mrb_value mrb_mod_constants(mrb_state *mrb, mrb_value mod); 53 | mrb_value mrb_f_global_variables(mrb_state *mrb, mrb_value self); 54 | mrb_value mrb_gv_get(mrb_state *mrb, mrb_sym sym); 55 | void mrb_gv_set(mrb_state *mrb, mrb_sym sym, mrb_value val); 56 | void mrb_gv_remove(mrb_state *mrb, mrb_sym sym); 57 | mrb_value mrb_obj_instance_variables(mrb_state*, mrb_value); 58 | mrb_value mrb_obj_iv_inspect(mrb_state*, struct RObject*); 59 | mrb_sym mrb_class_sym(mrb_state *mrb, struct RClass *c, struct RClass *outer); 60 | mrb_value mrb_mod_class_variables(mrb_state*, mrb_value); 61 | mrb_value mrb_mod_cv_get(mrb_state *mrb, struct RClass * c, mrb_sym sym); 62 | mrb_value mrb_cv_get(mrb_state *mrb, mrb_value mod, mrb_sym sym); 63 | void mrb_mod_cv_set(mrb_state *mrb, struct RClass * c, mrb_sym sym, mrb_value v); 64 | void mrb_cv_set(mrb_state *mrb, mrb_value mod, mrb_sym sym, mrb_value v); 65 | mrb_bool mrb_mod_cv_defined(mrb_state *mrb, struct RClass * c, mrb_sym sym); 66 | mrb_bool mrb_cv_defined(mrb_state *mrb, mrb_value mod, mrb_sym sym); 67 | 68 | /* GC functions */ 69 | void mrb_gc_mark_gv(mrb_state*); 70 | void mrb_gc_free_gv(mrb_state*); 71 | void mrb_gc_mark_iv(mrb_state*, struct RObject*); 72 | size_t mrb_gc_mark_iv_size(mrb_state*, struct RObject*); 73 | void mrb_gc_free_iv(mrb_state*, struct RObject*); 74 | 75 | #if defined(__cplusplus) 76 | } /* extern "C" { */ 77 | #endif 78 | 79 | #endif /* MRUBY_VARIABLE_H */ 80 | -------------------------------------------------------------------------------- /MRuby.framework/Versions/1.0.0/Headers/mruby/version.h: -------------------------------------------------------------------------------- 1 | #ifndef MRUBY_VERSION_H 2 | #define MRUBY_VERSION_H 3 | 4 | #define MRUBY_RUBY_VERSION "1.9" 5 | #define MRUBY_RUBY_ENGINE "mruby" 6 | 7 | #define MRUBY_VERSION "1.0.0" 8 | #define MRUBY_RELEASE_MAJOR 1 9 | #define MRUBY_RELEASE_MINOR 0 10 | #define MRUBY_RELEASE_TEENY 1 11 | #define MRUBY_RELEASE_NO 10001 12 | #define MRUBY_RELEASE_DATE "2014-01-10" 13 | #define MRUBY_RELEASE_YEAR 2014 14 | #define MRUBY_RELEASE_MONTH 1 15 | #define MRUBY_RELEASE_DAY 10 16 | 17 | #define MRUBY_BIRTH_YEAR 2010 18 | 19 | #define MRUBY_AUTHOR "mruby developers" 20 | 21 | #define MRB_STRINGIZE0(expr) #expr 22 | #define MRB_STRINGIZE(expr) MRB_STRINGIZE0(expr) 23 | 24 | #define MRUBY_DESCRIPTION \ 25 | "mruby " MRUBY_VERSION \ 26 | " (" MRUBY_RELEASE_DATE ") " \ 27 | 28 | #define MRUBY_COPYRIGHT \ 29 | "mruby - Copyright (c) " \ 30 | MRB_STRINGIZE(MRUBY_BIRTH_YEAR)"-" \ 31 | MRB_STRINGIZE(MRUBY_RELEASE_YEAR)" " \ 32 | MRUBY_AUTHOR \ 33 | 34 | #endif /* MRUBY_VERSION_H */ 35 | -------------------------------------------------------------------------------- /MRuby.framework/Versions/1.0.0/MRuby: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/carsonmcdonald/MRubyiOSExample/adfba4d3326160695201d7adbe1bca098e6506d2/MRuby.framework/Versions/1.0.0/MRuby -------------------------------------------------------------------------------- /MRuby.framework/Versions/Current: -------------------------------------------------------------------------------- 1 | 1.0.0 -------------------------------------------------------------------------------- /MRubyiOSExample.xcodeproj/project.pbxproj: -------------------------------------------------------------------------------- 1 | // !$*UTF8*$! 2 | { 3 | archiveVersion = 1; 4 | classes = { 5 | }; 6 | objectVersion = 46; 7 | objects = { 8 | 9 | /* Begin PBXBuildFile section */ 10 | B65E3B60170AE80800523C00 /* example.mrb in Resources */ = {isa = PBXBuildFile; fileRef = B65E3B5F170AE80800523C00 /* example.mrb */; }; 11 | B66BF8221556D34D0026D500 /* UIKit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = B66BF8211556D34D0026D500 /* UIKit.framework */; }; 12 | B66BF8241556D34D0026D500 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = B66BF8231556D34D0026D500 /* Foundation.framework */; }; 13 | B66BF8261556D34D0026D500 /* CoreGraphics.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = B66BF8251556D34D0026D500 /* CoreGraphics.framework */; }; 14 | B66BF82C1556D34D0026D500 /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = B66BF82A1556D34D0026D500 /* InfoPlist.strings */; }; 15 | B66BF82E1556D34D0026D500 /* main.m in Sources */ = {isa = PBXBuildFile; fileRef = B66BF82D1556D34D0026D500 /* main.m */; }; 16 | B66BF8321556D34D0026D500 /* AppDelegate.m in Sources */ = {isa = PBXBuildFile; fileRef = B66BF8311556D34D0026D500 /* AppDelegate.m */; }; 17 | B66BF8351556D34D0026D500 /* ViewController.m in Sources */ = {isa = PBXBuildFile; fileRef = B66BF8341556D34D0026D500 /* ViewController.m */; }; 18 | B66BF8381556D34D0026D500 /* ViewController.xib in Resources */ = {isa = PBXBuildFile; fileRef = B66BF8361556D34D0026D500 /* ViewController.xib */; }; 19 | B66BF8441556D4F10026D500 /* example.rb in Resources */ = {isa = PBXBuildFile; fileRef = B66BF83E1556D4F00026D500 /* example.rb */; }; 20 | B66BF8451556D4F10026D500 /* FooData.m in Sources */ = {isa = PBXBuildFile; fileRef = B66BF8401556D4F00026D500 /* FooData.m */; }; 21 | B66BF8461556D4F10026D500 /* FooUtil.m in Sources */ = {isa = PBXBuildFile; fileRef = B66BF8421556D4F10026D500 /* FooUtil.m */; }; 22 | B66BF84B1556D60B0026D500 /* MRuby.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = B66BF84A1556D60B0026D500 /* MRuby.framework */; }; 23 | B6FBD16916A44B8300F27D50 /* Default-568h@2x.png in Resources */ = {isa = PBXBuildFile; fileRef = B6FBD16816A44B8300F27D50 /* Default-568h@2x.png */; }; 24 | /* End PBXBuildFile section */ 25 | 26 | /* Begin PBXFileReference section */ 27 | B65E3B5F170AE80800523C00 /* example.mrb */ = {isa = PBXFileReference; lastKnownFileType = file; path = example.mrb; sourceTree = ""; }; 28 | B66BF81D1556D34D0026D500 /* MRubyiOSExample.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = MRubyiOSExample.app; sourceTree = BUILT_PRODUCTS_DIR; }; 29 | B66BF8211556D34D0026D500 /* UIKit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = UIKit.framework; path = System/Library/Frameworks/UIKit.framework; sourceTree = SDKROOT; }; 30 | B66BF8231556D34D0026D500 /* Foundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Foundation.framework; path = System/Library/Frameworks/Foundation.framework; sourceTree = SDKROOT; }; 31 | B66BF8251556D34D0026D500 /* CoreGraphics.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreGraphics.framework; path = System/Library/Frameworks/CoreGraphics.framework; sourceTree = SDKROOT; }; 32 | B66BF8291556D34D0026D500 /* MRubyiOSExample-Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = "MRubyiOSExample-Info.plist"; sourceTree = ""; }; 33 | B66BF82B1556D34D0026D500 /* en */ = {isa = PBXFileReference; lastKnownFileType = text.plist.strings; name = en; path = en.lproj/InfoPlist.strings; sourceTree = ""; }; 34 | B66BF82D1556D34D0026D500 /* main.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = main.m; sourceTree = ""; }; 35 | B66BF82F1556D34D0026D500 /* MRubyiOSExample-Prefix.pch */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "MRubyiOSExample-Prefix.pch"; sourceTree = ""; }; 36 | B66BF8301556D34D0026D500 /* AppDelegate.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AppDelegate.h; sourceTree = ""; }; 37 | B66BF8311556D34D0026D500 /* AppDelegate.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = AppDelegate.m; sourceTree = ""; }; 38 | B66BF8331556D34D0026D500 /* ViewController.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ViewController.h; sourceTree = ""; }; 39 | B66BF8341556D34D0026D500 /* ViewController.m */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.objc; path = ViewController.m; sourceTree = ""; }; 40 | B66BF8371556D34D0026D500 /* en */ = {isa = PBXFileReference; lastKnownFileType = file.xib; name = en; path = en.lproj/ViewController.xib; sourceTree = ""; }; 41 | B66BF83E1556D4F00026D500 /* example.rb */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.script.ruby; path = example.rb; sourceTree = ""; }; 42 | B66BF83F1556D4F00026D500 /* FooData.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FooData.h; sourceTree = ""; }; 43 | B66BF8401556D4F00026D500 /* FooData.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = FooData.m; sourceTree = ""; }; 44 | B66BF8411556D4F00026D500 /* FooUtil.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FooUtil.h; sourceTree = ""; }; 45 | B66BF8421556D4F10026D500 /* FooUtil.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = FooUtil.m; sourceTree = ""; }; 46 | B66BF84A1556D60B0026D500 /* MRuby.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; path = MRuby.framework; sourceTree = ""; }; 47 | B6FBD16816A44B8300F27D50 /* Default-568h@2x.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = "Default-568h@2x.png"; sourceTree = ""; }; 48 | /* End PBXFileReference section */ 49 | 50 | /* Begin PBXFrameworksBuildPhase section */ 51 | B66BF81A1556D34D0026D500 /* Frameworks */ = { 52 | isa = PBXFrameworksBuildPhase; 53 | buildActionMask = 2147483647; 54 | files = ( 55 | B66BF84B1556D60B0026D500 /* MRuby.framework in Frameworks */, 56 | B66BF8221556D34D0026D500 /* UIKit.framework in Frameworks */, 57 | B66BF8241556D34D0026D500 /* Foundation.framework in Frameworks */, 58 | B66BF8261556D34D0026D500 /* CoreGraphics.framework in Frameworks */, 59 | ); 60 | runOnlyForDeploymentPostprocessing = 0; 61 | }; 62 | /* End PBXFrameworksBuildPhase section */ 63 | 64 | /* Begin PBXGroup section */ 65 | B66BF8121556D34D0026D500 = { 66 | isa = PBXGroup; 67 | children = ( 68 | B6FBD16816A44B8300F27D50 /* Default-568h@2x.png */, 69 | B66BF8271556D34D0026D500 /* MRubyiOSExample */, 70 | B66BF8201556D34D0026D500 /* Frameworks */, 71 | B66BF81E1556D34D0026D500 /* Products */, 72 | ); 73 | sourceTree = ""; 74 | }; 75 | B66BF81E1556D34D0026D500 /* Products */ = { 76 | isa = PBXGroup; 77 | children = ( 78 | B66BF81D1556D34D0026D500 /* MRubyiOSExample.app */, 79 | ); 80 | name = Products; 81 | sourceTree = ""; 82 | }; 83 | B66BF8201556D34D0026D500 /* Frameworks */ = { 84 | isa = PBXGroup; 85 | children = ( 86 | B66BF84A1556D60B0026D500 /* MRuby.framework */, 87 | B66BF8211556D34D0026D500 /* UIKit.framework */, 88 | B66BF8231556D34D0026D500 /* Foundation.framework */, 89 | B66BF8251556D34D0026D500 /* CoreGraphics.framework */, 90 | ); 91 | name = Frameworks; 92 | sourceTree = ""; 93 | }; 94 | B66BF8271556D34D0026D500 /* MRubyiOSExample */ = { 95 | isa = PBXGroup; 96 | children = ( 97 | B65E3B5F170AE80800523C00 /* example.mrb */, 98 | B66BF83E1556D4F00026D500 /* example.rb */, 99 | B66BF83F1556D4F00026D500 /* FooData.h */, 100 | B66BF8401556D4F00026D500 /* FooData.m */, 101 | B66BF8411556D4F00026D500 /* FooUtil.h */, 102 | B66BF8421556D4F10026D500 /* FooUtil.m */, 103 | B66BF8301556D34D0026D500 /* AppDelegate.h */, 104 | B66BF8311556D34D0026D500 /* AppDelegate.m */, 105 | B66BF8331556D34D0026D500 /* ViewController.h */, 106 | B66BF8341556D34D0026D500 /* ViewController.m */, 107 | B66BF8361556D34D0026D500 /* ViewController.xib */, 108 | B66BF8281556D34D0026D500 /* Supporting Files */, 109 | ); 110 | path = MRubyiOSExample; 111 | sourceTree = ""; 112 | }; 113 | B66BF8281556D34D0026D500 /* Supporting Files */ = { 114 | isa = PBXGroup; 115 | children = ( 116 | B66BF8291556D34D0026D500 /* MRubyiOSExample-Info.plist */, 117 | B66BF82A1556D34D0026D500 /* InfoPlist.strings */, 118 | B66BF82D1556D34D0026D500 /* main.m */, 119 | B66BF82F1556D34D0026D500 /* MRubyiOSExample-Prefix.pch */, 120 | ); 121 | name = "Supporting Files"; 122 | sourceTree = ""; 123 | }; 124 | /* End PBXGroup section */ 125 | 126 | /* Begin PBXNativeTarget section */ 127 | B66BF81C1556D34D0026D500 /* MRubyiOSExample */ = { 128 | isa = PBXNativeTarget; 129 | buildConfigurationList = B66BF83B1556D34D0026D500 /* Build configuration list for PBXNativeTarget "MRubyiOSExample" */; 130 | buildPhases = ( 131 | B66BF8191556D34D0026D500 /* Sources */, 132 | B66BF81A1556D34D0026D500 /* Frameworks */, 133 | B66BF81B1556D34D0026D500 /* Resources */, 134 | ); 135 | buildRules = ( 136 | ); 137 | dependencies = ( 138 | ); 139 | name = MRubyiOSExample; 140 | productName = MRubyiOSExample; 141 | productReference = B66BF81D1556D34D0026D500 /* MRubyiOSExample.app */; 142 | productType = "com.apple.product-type.application"; 143 | }; 144 | /* End PBXNativeTarget section */ 145 | 146 | /* Begin PBXProject section */ 147 | B66BF8141556D34D0026D500 /* Project object */ = { 148 | isa = PBXProject; 149 | attributes = { 150 | LastUpgradeCheck = 0500; 151 | }; 152 | buildConfigurationList = B66BF8171556D34D0026D500 /* Build configuration list for PBXProject "MRubyiOSExample" */; 153 | compatibilityVersion = "Xcode 3.2"; 154 | developmentRegion = English; 155 | hasScannedForEncodings = 0; 156 | knownRegions = ( 157 | en, 158 | ); 159 | mainGroup = B66BF8121556D34D0026D500; 160 | productRefGroup = B66BF81E1556D34D0026D500 /* Products */; 161 | projectDirPath = ""; 162 | projectRoot = ""; 163 | targets = ( 164 | B66BF81C1556D34D0026D500 /* MRubyiOSExample */, 165 | ); 166 | }; 167 | /* End PBXProject section */ 168 | 169 | /* Begin PBXResourcesBuildPhase section */ 170 | B66BF81B1556D34D0026D500 /* Resources */ = { 171 | isa = PBXResourcesBuildPhase; 172 | buildActionMask = 2147483647; 173 | files = ( 174 | B66BF82C1556D34D0026D500 /* InfoPlist.strings in Resources */, 175 | B66BF8381556D34D0026D500 /* ViewController.xib in Resources */, 176 | B66BF8441556D4F10026D500 /* example.rb in Resources */, 177 | B6FBD16916A44B8300F27D50 /* Default-568h@2x.png in Resources */, 178 | B65E3B60170AE80800523C00 /* example.mrb in Resources */, 179 | ); 180 | runOnlyForDeploymentPostprocessing = 0; 181 | }; 182 | /* End PBXResourcesBuildPhase section */ 183 | 184 | /* Begin PBXSourcesBuildPhase section */ 185 | B66BF8191556D34D0026D500 /* Sources */ = { 186 | isa = PBXSourcesBuildPhase; 187 | buildActionMask = 2147483647; 188 | files = ( 189 | B66BF82E1556D34D0026D500 /* main.m in Sources */, 190 | B66BF8321556D34D0026D500 /* AppDelegate.m in Sources */, 191 | B66BF8351556D34D0026D500 /* ViewController.m in Sources */, 192 | B66BF8451556D4F10026D500 /* FooData.m in Sources */, 193 | B66BF8461556D4F10026D500 /* FooUtil.m in Sources */, 194 | ); 195 | runOnlyForDeploymentPostprocessing = 0; 196 | }; 197 | /* End PBXSourcesBuildPhase section */ 198 | 199 | /* Begin PBXVariantGroup section */ 200 | B66BF82A1556D34D0026D500 /* InfoPlist.strings */ = { 201 | isa = PBXVariantGroup; 202 | children = ( 203 | B66BF82B1556D34D0026D500 /* en */, 204 | ); 205 | name = InfoPlist.strings; 206 | sourceTree = ""; 207 | }; 208 | B66BF8361556D34D0026D500 /* ViewController.xib */ = { 209 | isa = PBXVariantGroup; 210 | children = ( 211 | B66BF8371556D34D0026D500 /* en */, 212 | ); 213 | name = ViewController.xib; 214 | sourceTree = ""; 215 | }; 216 | /* End PBXVariantGroup section */ 217 | 218 | /* Begin XCBuildConfiguration section */ 219 | B66BF8391556D34D0026D500 /* Debug */ = { 220 | isa = XCBuildConfiguration; 221 | buildSettings = { 222 | ALWAYS_SEARCH_USER_PATHS = NO; 223 | CLANG_WARN_BOOL_CONVERSION = YES; 224 | CLANG_WARN_CONSTANT_CONVERSION = YES; 225 | CLANG_WARN_EMPTY_BODY = YES; 226 | CLANG_WARN_ENUM_CONVERSION = YES; 227 | CLANG_WARN_INT_CONVERSION = YES; 228 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 229 | CODE_SIGN_IDENTITY = "iPhone Developer: Chris Gavurin (9LXV288735)"; 230 | "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer: Chris Gavurin (9LXV288735)"; 231 | COPY_PHASE_STRIP = NO; 232 | GCC_C_LANGUAGE_STANDARD = gnu99; 233 | GCC_DYNAMIC_NO_PIC = NO; 234 | GCC_OPTIMIZATION_LEVEL = 0; 235 | GCC_PREPROCESSOR_DEFINITIONS = ( 236 | "DEBUG=1", 237 | "$(inherited)", 238 | ); 239 | GCC_SYMBOLS_PRIVATE_EXTERN = NO; 240 | GCC_VERSION = com.apple.compilers.llvm.clang.1_0; 241 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 242 | GCC_WARN_ABOUT_RETURN_TYPE = YES; 243 | GCC_WARN_UNDECLARED_SELECTOR = YES; 244 | GCC_WARN_UNINITIALIZED_AUTOS = YES; 245 | GCC_WARN_UNUSED_FUNCTION = YES; 246 | GCC_WARN_UNUSED_VARIABLE = YES; 247 | IPHONEOS_DEPLOYMENT_TARGET = 5.1; 248 | ONLY_ACTIVE_ARCH = YES; 249 | PROVISIONING_PROFILE = "56F4F1FA-F752-4339-84BB-51102630AAD5"; 250 | "PROVISIONING_PROFILE[sdk=iphoneos*]" = "56F4F1FA-F752-4339-84BB-51102630AAD5"; 251 | SDKROOT = iphoneos; 252 | }; 253 | name = Debug; 254 | }; 255 | B66BF83A1556D34D0026D500 /* Release */ = { 256 | isa = XCBuildConfiguration; 257 | buildSettings = { 258 | ALWAYS_SEARCH_USER_PATHS = NO; 259 | CLANG_WARN_BOOL_CONVERSION = YES; 260 | CLANG_WARN_CONSTANT_CONVERSION = YES; 261 | CLANG_WARN_EMPTY_BODY = YES; 262 | CLANG_WARN_ENUM_CONVERSION = YES; 263 | CLANG_WARN_INT_CONVERSION = YES; 264 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 265 | CODE_SIGN_IDENTITY = "iPhone Developer: Chris Gavurin (9LXV288735)"; 266 | "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer: Chris Gavurin (9LXV288735)"; 267 | COPY_PHASE_STRIP = YES; 268 | GCC_C_LANGUAGE_STANDARD = gnu99; 269 | GCC_VERSION = com.apple.compilers.llvm.clang.1_0; 270 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 271 | GCC_WARN_ABOUT_RETURN_TYPE = YES; 272 | GCC_WARN_UNDECLARED_SELECTOR = YES; 273 | GCC_WARN_UNINITIALIZED_AUTOS = YES; 274 | GCC_WARN_UNUSED_FUNCTION = YES; 275 | GCC_WARN_UNUSED_VARIABLE = YES; 276 | IPHONEOS_DEPLOYMENT_TARGET = 5.1; 277 | OTHER_CFLAGS = "-DNS_BLOCK_ASSERTIONS=1"; 278 | PROVISIONING_PROFILE = "56F4F1FA-F752-4339-84BB-51102630AAD5"; 279 | "PROVISIONING_PROFILE[sdk=iphoneos*]" = "56F4F1FA-F752-4339-84BB-51102630AAD5"; 280 | SDKROOT = iphoneos; 281 | VALIDATE_PRODUCT = YES; 282 | }; 283 | name = Release; 284 | }; 285 | B66BF83C1556D34D0026D500 /* Debug */ = { 286 | isa = XCBuildConfiguration; 287 | buildSettings = { 288 | FRAMEWORK_SEARCH_PATHS = ( 289 | "$(inherited)", 290 | "\"$(SRCROOT)\"", 291 | ); 292 | GCC_PRECOMPILE_PREFIX_HEADER = YES; 293 | GCC_PREFIX_HEADER = "MRubyiOSExample/MRubyiOSExample-Prefix.pch"; 294 | INFOPLIST_FILE = "MRubyiOSExample/MRubyiOSExample-Info.plist"; 295 | IPHONEOS_DEPLOYMENT_TARGET = 5.1; 296 | PRODUCT_NAME = "$(TARGET_NAME)"; 297 | WRAPPER_EXTENSION = app; 298 | }; 299 | name = Debug; 300 | }; 301 | B66BF83D1556D34D0026D500 /* Release */ = { 302 | isa = XCBuildConfiguration; 303 | buildSettings = { 304 | FRAMEWORK_SEARCH_PATHS = ( 305 | "$(inherited)", 306 | "\"$(SRCROOT)\"", 307 | ); 308 | GCC_PRECOMPILE_PREFIX_HEADER = YES; 309 | GCC_PREFIX_HEADER = "MRubyiOSExample/MRubyiOSExample-Prefix.pch"; 310 | INFOPLIST_FILE = "MRubyiOSExample/MRubyiOSExample-Info.plist"; 311 | IPHONEOS_DEPLOYMENT_TARGET = 5.1; 312 | PRODUCT_NAME = "$(TARGET_NAME)"; 313 | WRAPPER_EXTENSION = app; 314 | }; 315 | name = Release; 316 | }; 317 | /* End XCBuildConfiguration section */ 318 | 319 | /* Begin XCConfigurationList section */ 320 | B66BF8171556D34D0026D500 /* Build configuration list for PBXProject "MRubyiOSExample" */ = { 321 | isa = XCConfigurationList; 322 | buildConfigurations = ( 323 | B66BF8391556D34D0026D500 /* Debug */, 324 | B66BF83A1556D34D0026D500 /* Release */, 325 | ); 326 | defaultConfigurationIsVisible = 0; 327 | defaultConfigurationName = Release; 328 | }; 329 | B66BF83B1556D34D0026D500 /* Build configuration list for PBXNativeTarget "MRubyiOSExample" */ = { 330 | isa = XCConfigurationList; 331 | buildConfigurations = ( 332 | B66BF83C1556D34D0026D500 /* Debug */, 333 | B66BF83D1556D34D0026D500 /* Release */, 334 | ); 335 | defaultConfigurationIsVisible = 0; 336 | defaultConfigurationName = Release; 337 | }; 338 | /* End XCConfigurationList section */ 339 | }; 340 | rootObject = B66BF8141556D34D0026D500 /* Project object */; 341 | } 342 | -------------------------------------------------------------------------------- /MRubyiOSExample.xcodeproj/project.xcworkspace/contents.xcworkspacedata: -------------------------------------------------------------------------------- 1 | 2 | 4 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /MRubyiOSExample/AppDelegate.h: -------------------------------------------------------------------------------- 1 | #import 2 | 3 | @class ViewController; 4 | 5 | @interface AppDelegate : UIResponder 6 | 7 | @property (strong, nonatomic) UIWindow *window; 8 | 9 | @property (strong, nonatomic) ViewController *viewController; 10 | 11 | @end 12 | -------------------------------------------------------------------------------- /MRubyiOSExample/AppDelegate.m: -------------------------------------------------------------------------------- 1 | #import "AppDelegate.h" 2 | 3 | #import "ViewController.h" 4 | 5 | @implementation AppDelegate 6 | 7 | @synthesize window = _window; 8 | @synthesize viewController = _viewController; 9 | 10 | - (void)dealloc 11 | { 12 | [_window release]; 13 | [_viewController release]; 14 | [super dealloc]; 15 | } 16 | 17 | - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions 18 | { 19 | self.window = [[[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]] autorelease]; 20 | 21 | self.viewController = [[[ViewController alloc] initWithNibName:@"ViewController" bundle:nil] autorelease]; 22 | self.window.rootViewController = self.viewController; 23 | [self.window makeKeyAndVisible]; 24 | 25 | return YES; 26 | } 27 | 28 | - (void)applicationWillResignActive:(UIApplication *)application 29 | { 30 | } 31 | 32 | - (void)applicationDidEnterBackground:(UIApplication *)application 33 | { 34 | } 35 | 36 | - (void)applicationWillEnterForeground:(UIApplication *)application 37 | { 38 | } 39 | 40 | - (void)applicationDidBecomeActive:(UIApplication *)application 41 | { 42 | } 43 | 44 | - (void)applicationWillTerminate:(UIApplication *)application 45 | { 46 | } 47 | 48 | @end 49 | -------------------------------------------------------------------------------- /MRubyiOSExample/FooData.h: -------------------------------------------------------------------------------- 1 | #import 2 | 3 | @interface FooData : NSObject 4 | 5 | @property (assign, nonatomic) int count; 6 | 7 | - (void)increment; 8 | 9 | @end 10 | -------------------------------------------------------------------------------- /MRubyiOSExample/FooData.m: -------------------------------------------------------------------------------- 1 | #import "FooData.h" 2 | 3 | @implementation FooData 4 | 5 | @synthesize count; 6 | 7 | - (id)init 8 | { 9 | self = [super init]; 10 | if (self) 11 | { 12 | count = 0; 13 | } 14 | return self; 15 | } 16 | 17 | - (void)dealloc 18 | { 19 | [super dealloc]; 20 | } 21 | 22 | - (void)increment 23 | { 24 | count++; 25 | } 26 | 27 | @end 28 | -------------------------------------------------------------------------------- /MRubyiOSExample/FooUtil.h: -------------------------------------------------------------------------------- 1 | #import 2 | 3 | #include "mruby/mruby.h" 4 | #include "mruby/mruby/proc.h" 5 | #include "mruby/mruby/dump.h" 6 | #include "mruby/mruby/class.h" 7 | #include "mruby/mruby/variable.h" 8 | #include "mruby/mruby/data.h" 9 | #include "mruby/mruby/array.h" 10 | #include "mruby/mruby/string.h" 11 | 12 | typedef void (^ DebugBlock)(NSString *); 13 | 14 | @interface FooUtil : NSObject 15 | { 16 | @private 17 | mrb_state *mrb; 18 | struct RClass* foo_module; 19 | struct RClass* foo_class; 20 | mrb_irep *irep; 21 | mrb_value barInstance; 22 | } 23 | 24 | + (FooUtil *)sharedInstance; 25 | + (void)setDebugBlock:(DebugBlock) aDebugBlock; 26 | 27 | - (bool)loadFromBundle: (NSString *)filename; 28 | - (void)execute; 29 | - (void)cleanup; 30 | - (void)updateBarLocation; 31 | - (void)blockExample; 32 | 33 | @end 34 | -------------------------------------------------------------------------------- /MRubyiOSExample/FooUtil.m: -------------------------------------------------------------------------------- 1 | #import "FooUtil.h" 2 | #import "FooData.h" 3 | 4 | static DebugBlock debugBlock; 5 | 6 | static void foo_data_free(mrb_state *mrb, void *obj) 7 | { 8 | debugBlock(@"FooData free called"); 9 | 10 | FooData *fooData = (FooData *)obj; 11 | [fooData release]; 12 | } 13 | 14 | static const struct mrb_data_type foo_data_type = { 15 | "fooData", foo_data_free, 16 | }; 17 | 18 | static mrb_value foo_class_init(mrb_state *mrb, mrb_value obj) 19 | { 20 | debugBlock(@"FooData init"); 21 | 22 | FooData *fooData = [[FooData alloc] init]; 23 | 24 | mrb_iv_set(mrb, obj, mrb_intern_cstr(mrb, "fooData"), mrb_obj_value(Data_Wrap_Struct(mrb, mrb->object_class, &foo_data_type, (void*) fooData))); 25 | 26 | return obj; 27 | } 28 | 29 | static mrb_value foo_class_increment(mrb_state *mrb, mrb_value obj) 30 | { 31 | FooData *fooData = nil; 32 | 33 | mrb_value value_fooData = mrb_iv_get(mrb, obj, mrb_intern_cstr(mrb, "fooData")); 34 | fooData = DATA_GET_PTR(mrb, value_fooData, &foo_data_type, FooData); 35 | if (!fooData) { 36 | mrb_raise(mrb, E_ARGUMENT_ERROR, "Internal state corrupted"); 37 | } 38 | 39 | [fooData increment]; 40 | 41 | return mrb_nil_value(); 42 | } 43 | 44 | static mrb_value foo_class_get_count(mrb_state *mrb, mrb_value obj) 45 | { 46 | FooData *fooData = nil; 47 | 48 | mrb_value value_fooData = mrb_iv_get(mrb, obj, mrb_intern_cstr(mrb, "fooData")); 49 | fooData = DATA_GET_PTR(mrb, value_fooData, &foo_data_type, FooData); 50 | if (!fooData) { 51 | mrb_raise(mrb, E_ARGUMENT_ERROR, "Internal state corrupted"); 52 | } 53 | 54 | mrb_value count_value; 55 | count_value.tt = MRB_TT_FIXNUM; 56 | count_value.value.i = fooData.count; 57 | 58 | return mrb_Integer(mrb, count_value); 59 | } 60 | 61 | // Simple class method call 62 | static mrb_value foo_simple(mrb_state *mrb, mrb_value obj) 63 | { 64 | debugBlock(@"Foo::simple called"); 65 | 66 | return mrb_nil_value(); 67 | } 68 | 69 | // Message printing class method call 70 | static mrb_value foo_print_message(mrb_state* mrb, mrb_value obj) 71 | { 72 | char *message = NULL; 73 | mrb_get_args(mrb, "z", &message); 74 | 75 | debugBlock([NSString stringWithFormat:@"Foo::printMessage => %s", message]); 76 | 77 | return mrb_nil_value(); 78 | } 79 | 80 | static mrb_value bar_execute_with(mrb_state *mrb, mrb_value obj) 81 | { 82 | mrb_int x, y; 83 | mrb_get_args(mrb, "ii", &x, &y); 84 | 85 | debugBlock([NSString stringWithFormat:@"Values from within block: x=%d, y=%d", x, y]); 86 | 87 | mrb_value count_value; 88 | count_value.tt = MRB_TT_FIXNUM; 89 | count_value.value.i = x + y; 90 | 91 | return mrb_Integer(mrb, count_value); 92 | } 93 | 94 | @implementation FooUtil 95 | 96 | - (id)init 97 | { 98 | self = [super init]; 99 | if (self) 100 | { 101 | // Setup the mruby environment, define local modules/classes 102 | mrb = mrb_open(); 103 | 104 | foo_module = mrb_define_module(mrb, "Foo"); 105 | 106 | // Define a class method not no args 107 | mrb_define_class_method(mrb, foo_module, "simple", foo_simple, MRB_ARGS_NONE()); 108 | mrb_define_class_method(mrb, foo_module, "print", foo_print_message, MRB_ARGS_REQ(1)); 109 | 110 | // Define a class and a few methods 111 | foo_class = mrb_define_class_under(mrb, foo_module, "FooData", mrb->object_class); 112 | 113 | mrb_define_method(mrb, foo_class, "initialize", foo_class_init, MRB_ARGS_NONE()); 114 | mrb_define_method(mrb, foo_class, "increment", foo_class_increment, MRB_ARGS_NONE()); 115 | mrb_define_method(mrb, foo_class, "count", foo_class_get_count, MRB_ARGS_NONE()); 116 | } 117 | return self; 118 | } 119 | 120 | - (void)dealloc 121 | { 122 | [super dealloc]; 123 | } 124 | 125 | + (FooUtil *)sharedInstance 126 | { 127 | static FooUtil *sharedInstance = nil; 128 | static dispatch_once_t pred; 129 | 130 | dispatch_once(&pred, ^{ 131 | sharedInstance = [[FooUtil alloc] init]; 132 | }); 133 | 134 | return sharedInstance; 135 | } 136 | 137 | + (void)setDebugBlock:(DebugBlock) aDebugBlock 138 | { 139 | debugBlock = aDebugBlock; 140 | } 141 | 142 | - (bool)loadFromBundle: (NSString *)filename 143 | { 144 | NSString *bundleLocation = [[[NSBundle mainBundle] resourcePath] stringByAppendingPathComponent:filename]; 145 | 146 | if(!bundleLocation) 147 | { 148 | UIAlertView *errorView = [[UIAlertView alloc] initWithTitle:@"Error" message:[NSString stringWithFormat:@"%@ not found in bundle.", filename] delegate:self cancelButtonTitle:@"OK" otherButtonTitles:nil]; 149 | [errorView show]; 150 | 151 | return NO; 152 | } 153 | 154 | FILE *fp = fopen([bundleLocation UTF8String], "rb"); 155 | if (fp == NULL) 156 | { 157 | UIAlertView *errorView = [[UIAlertView alloc] initWithTitle:@"Error" message:@"Error loading bundled mrb file." delegate:self cancelButtonTitle:@"OK" otherButtonTitles:nil]; 158 | [errorView show]; 159 | 160 | return NO; 161 | } 162 | else 163 | { 164 | irep = mrb_read_irep_file(mrb, fp); 165 | fclose(fp); 166 | if(irep == NULL) 167 | { 168 | UIAlertView *errorView = [[UIAlertView alloc] initWithTitle:@"Error" message:@"Error reading bundled mrb irep." delegate:self cancelButtonTitle:@"OK" otherButtonTitles:nil]; 169 | [errorView show]; 170 | 171 | return NO; 172 | } 173 | } 174 | 175 | return YES; 176 | } 177 | 178 | - (void)execute 179 | { 180 | mrb_value return_value = mrb_run(mrb, mrb_proc_new(mrb, irep), mrb_top_self(mrb)); 181 | 182 | if(!mrb_eql(mrb, return_value, mrb_nil_value())) 183 | { 184 | mrb_value str = mrb_funcall(mrb, return_value, "inspect", 0); 185 | 186 | debugBlock([NSString stringWithFormat:@"Return value: %s", RSTRING_PTR(str)]); 187 | } 188 | 189 | // Set up an example instance of the Bar class from the script that was just run 190 | mrb_value argv[1]; 191 | 192 | // Example of setting an input value using an NSString 193 | argv[0] = mrb_str_new_cstr(mrb, [@"Bar1" UTF8String]); 194 | 195 | barInstance = mrb_class_new_instance(mrb, 1, argv, mrb_class_get(mrb, "Bar")); 196 | } 197 | 198 | - (void)cleanup 199 | { 200 | mrb_garbage_collect(mrb); 201 | } 202 | 203 | - (void)updateBarLocation 204 | { 205 | mrb_value bar_name = mrb_funcall_argv(mrb, barInstance, mrb_intern_cstr(mrb, "name"), 0, NULL); 206 | mrb_value bar_x = mrb_funcall_argv(mrb, barInstance, mrb_intern_cstr(mrb, "x"), 0, NULL); 207 | mrb_value bar_y = mrb_funcall_argv(mrb, barInstance, mrb_intern_cstr(mrb, "y"), 0, NULL); 208 | 209 | debugBlock([NSString stringWithFormat:@"Bar update location before => %s, %d, %d", RSTRING_PTR(bar_name), bar_x.value.i, bar_x.value.i]); 210 | 211 | mrb_funcall_argv(mrb, barInstance, mrb_intern_cstr(mrb, "move_bar"), 0, NULL); 212 | 213 | bar_x = mrb_funcall_argv(mrb, barInstance, mrb_intern_cstr(mrb, "x"), 0, NULL); 214 | bar_y = mrb_funcall_argv(mrb, barInstance, mrb_intern_cstr(mrb, "y"), 0, NULL); 215 | 216 | debugBlock([NSString stringWithFormat:@"Bar update location after => %s, %d, %d", RSTRING_PTR(bar_name), bar_x.value.i, bar_x.value.i]); 217 | } 218 | 219 | - (void)blockExample 220 | { 221 | struct RProc *b = mrb_proc_new_cfunc(mrb, bar_execute_with); 222 | mrb_value proc = mrb_obj_value(b); 223 | 224 | mrb_value r_val_proc = mrb_funcall_argv(mrb, barInstance, mrb_intern_cstr(mrb, "execute_with_proc"), 1, &proc); 225 | debugBlock([NSString stringWithFormat:@"Return from proc => %d", r_val_proc.value.i]); 226 | 227 | mrb_value r_val_yield = mrb_funcall_with_block(mrb, barInstance, mrb_intern_cstr(mrb, "execute_with_yield"), 0, NULL, proc); 228 | debugBlock([NSString stringWithFormat:@"Return from yield => %d", r_val_yield.value.i]); 229 | } 230 | 231 | @end 232 | -------------------------------------------------------------------------------- /MRubyiOSExample/MRubyiOSExample-Info.plist: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | CFBundleDevelopmentRegion 6 | en 7 | CFBundleDisplayName 8 | ${PRODUCT_NAME} 9 | CFBundleExecutable 10 | ${EXECUTABLE_NAME} 11 | CFBundleIdentifier 12 | net.ioncannon.${PRODUCT_NAME:rfc1034identifier} 13 | CFBundleInfoDictionaryVersion 14 | 6.0 15 | CFBundleName 16 | ${PRODUCT_NAME} 17 | CFBundlePackageType 18 | APPL 19 | CFBundleShortVersionString 20 | 1.0 21 | CFBundleSignature 22 | ???? 23 | CFBundleVersion 24 | 1.0 25 | LSRequiresIPhoneOS 26 | 27 | UIRequiredDeviceCapabilities 28 | 29 | armv7 30 | 31 | UISupportedInterfaceOrientations 32 | 33 | UIInterfaceOrientationPortrait 34 | UIInterfaceOrientationLandscapeLeft 35 | UIInterfaceOrientationLandscapeRight 36 | 37 | 38 | 39 | -------------------------------------------------------------------------------- /MRubyiOSExample/MRubyiOSExample-Prefix.pch: -------------------------------------------------------------------------------- 1 | #import 2 | 3 | #ifndef __IPHONE_4_0 4 | #warning "This project uses features only available in iOS SDK 4.0 and later." 5 | #endif 6 | 7 | #ifdef __OBJC__ 8 | #import 9 | #import 10 | #endif 11 | -------------------------------------------------------------------------------- /MRubyiOSExample/ViewController.h: -------------------------------------------------------------------------------- 1 | #import 2 | 3 | @interface ViewController : UIViewController 4 | 5 | @property (retain, nonatomic) IBOutlet UITextView *executionOutputTextView; 6 | 7 | - (IBAction)executeButtonAction:(id)sender; 8 | 9 | @end 10 | -------------------------------------------------------------------------------- /MRubyiOSExample/ViewController.m: -------------------------------------------------------------------------------- 1 | #import "ViewController.h" 2 | 3 | #import "FooUtil.h" 4 | 5 | @interface ViewController () 6 | 7 | @end 8 | 9 | @implementation ViewController 10 | 11 | @synthesize executionOutputTextView; 12 | 13 | - (void)viewDidLoad 14 | { 15 | [super viewDidLoad]; 16 | } 17 | 18 | - (void)viewDidUnload 19 | { 20 | [self setExecutionOutputTextView:nil]; 21 | [super viewDidUnload]; 22 | } 23 | 24 | - (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)interfaceOrientation 25 | { 26 | return (interfaceOrientation != UIInterfaceOrientationPortraitUpsideDown); 27 | } 28 | 29 | - (void)dealloc 30 | { 31 | [executionOutputTextView release]; 32 | [super dealloc]; 33 | } 34 | 35 | - (IBAction)executeButtonAction:(id)sender 36 | { 37 | [FooUtil setDebugBlock:^(NSString *debug) { 38 | // You can also just log to the console if you want 39 | // NSLog(@"Debug: %@", debug); 40 | 41 | if ([executionOutputTextView.text length] != 0) 42 | { 43 | executionOutputTextView.text = [NSString stringWithFormat:@"%@\n%@", executionOutputTextView.text, debug]; 44 | } 45 | else 46 | { 47 | executionOutputTextView.text = debug; 48 | } 49 | 50 | }]; 51 | 52 | FooUtil *fooUtil = [FooUtil sharedInstance]; 53 | if([fooUtil loadFromBundle:@"example.mrb"]) 54 | { 55 | [fooUtil execute]; 56 | [fooUtil updateBarLocation]; 57 | [fooUtil blockExample]; 58 | [fooUtil cleanup]; 59 | } 60 | } 61 | 62 | @end 63 | -------------------------------------------------------------------------------- /MRubyiOSExample/en.lproj/InfoPlist.strings: -------------------------------------------------------------------------------- 1 | /* Localized versions of Info.plist keys */ 2 | 3 | -------------------------------------------------------------------------------- /MRubyiOSExample/en.lproj/ViewController.xib: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 1296 5 | 11D50 6 | 2182 7 | 1138.32 8 | 568.00 9 | 10 | com.apple.InterfaceBuilder.IBCocoaTouchPlugin 11 | 1179 12 | 13 | 14 | IBUITextView 15 | IBUIButton 16 | IBUIView 17 | IBProxyObject 18 | 19 | 20 | com.apple.InterfaceBuilder.IBCocoaTouchPlugin 21 | 22 | 23 | PluginDependencyRecalculationVersion 24 | 25 | 26 | 27 | 28 | IBFilesOwner 29 | IBCocoaTouchFramework 30 | 31 | 32 | IBFirstResponder 33 | IBCocoaTouchFramework 34 | 35 | 36 | 37 | 274 38 | 39 | 40 | 41 | 292 42 | {{119, 403}, {82, 37}} 43 | 44 | 45 | 46 | _NS:9 47 | NO 48 | IBCocoaTouchFramework 49 | 0 50 | 0 51 | 1 52 | Execute 53 | 54 | 3 55 | MQA 56 | 57 | 58 | 1 59 | MC4xOTYwNzg0MzQ2IDAuMzA5ODAzOTMyOSAwLjUyMTU2ODY1NgA 60 | 61 | 62 | 3 63 | MC41AA 64 | 65 | 66 | 2 67 | 15 68 | 69 | 70 | Helvetica-Bold 71 | 15 72 | 16 73 | 74 | 75 | 76 | 77 | 292 78 | {{20, 20}, {280, 363}} 79 | 80 | 81 | _NS:9 82 | 83 | 1 84 | MSAxIDEAA 85 | 86 | YES 87 | YES 88 | IBCocoaTouchFramework 89 | NO 90 | 91 | 92 | IBCocoaTouchFramework 93 | 94 | 95 | 1 96 | 12 97 | 98 | 99 | Helvetica 100 | 12 101 | 16 102 | 103 | 104 | 105 | {{0, 20}, {320, 460}} 106 | 107 | 108 | 109 | 110 | 3 111 | MC43NQA 112 | 113 | 2 114 | 115 | 116 | NO 117 | 118 | IBCocoaTouchFramework 119 | 120 | 121 | 122 | 123 | 124 | 125 | view 126 | 127 | 128 | 129 | 7 130 | 131 | 132 | 133 | executionOutputTextView 134 | 135 | 136 | 137 | 10 138 | 139 | 140 | 141 | executeButtonAction: 142 | 143 | 144 | 7 145 | 146 | 11 147 | 148 | 149 | 150 | 151 | 152 | 0 153 | 154 | 155 | 156 | 157 | 158 | -1 159 | 160 | 161 | File's Owner 162 | 163 | 164 | -2 165 | 166 | 167 | 168 | 169 | 6 170 | 171 | 172 | 173 | 174 | 175 | 176 | 177 | 178 | 8 179 | 180 | 181 | 182 | 183 | 9 184 | 185 | 186 | 187 | 188 | 189 | 190 | ViewController 191 | com.apple.InterfaceBuilder.IBCocoaTouchPlugin 192 | UIResponder 193 | com.apple.InterfaceBuilder.IBCocoaTouchPlugin 194 | com.apple.InterfaceBuilder.IBCocoaTouchPlugin 195 | com.apple.InterfaceBuilder.IBCocoaTouchPlugin 196 | com.apple.InterfaceBuilder.IBCocoaTouchPlugin 197 | 198 | 199 | 200 | 201 | 202 | 11 203 | 204 | 205 | 206 | 207 | ViewController 208 | UIViewController 209 | 210 | executeButtonAction: 211 | id 212 | 213 | 214 | executeButtonAction: 215 | 216 | executeButtonAction: 217 | id 218 | 219 | 220 | 221 | executionOutputTextView 222 | UITextView 223 | 224 | 225 | executionOutputTextView 226 | 227 | executionOutputTextView 228 | UITextView 229 | 230 | 231 | 232 | IBProjectSource 233 | ./Classes/ViewController.h 234 | 235 | 236 | 237 | 238 | 0 239 | IBCocoaTouchFramework 240 | 241 | com.apple.InterfaceBuilder.CocoaTouchPlugin.iPhoneOS 242 | 243 | 244 | YES 245 | 3 246 | 1179 247 | 248 | 249 | -------------------------------------------------------------------------------- /MRubyiOSExample/example.mrb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/carsonmcdonald/MRubyiOSExample/adfba4d3326160695201d7adbe1bca098e6506d2/MRubyiOSExample/example.mrb -------------------------------------------------------------------------------- /MRubyiOSExample/example.rb: -------------------------------------------------------------------------------- 1 | class Bar 2 | attr_reader :name, :x, :y 3 | 4 | def initialize(name) 5 | @name = name 6 | @x = 0 7 | @y = 0 8 | end 9 | 10 | def move_bar 11 | @x += 10 12 | @y += 10 13 | end 14 | 15 | def execute_with_proc(p) 16 | p.call(@x, @y) 17 | end 18 | 19 | def execute_with_yield(&b) 20 | yield @x, @y 21 | end 22 | 23 | end 24 | 25 | class FiberOne 26 | def initialize(foo) 27 | @foo = foo 28 | @foo_fiber = Fiber.new { 29 | @foo.increment() 30 | Fiber.yield @foo.count 31 | @foo.increment() 32 | Fiber.yield @foo.count 33 | } 34 | end 35 | 36 | def go 37 | @foo_fiber.resume() 38 | end 39 | end 40 | 41 | Foo::print(MRUBY_DESCRIPTION) 42 | 43 | Foo::print("Calling Foo::simple()") 44 | Foo::simple() 45 | 46 | Foo::print("Calling Foo::FooData.new()") 47 | f = Foo::FooData.new() 48 | 49 | Foo::print("Calling Foo::FooData.increment()") 50 | f.increment() 51 | 52 | Foo::print("Count is currently: #{f.count}") 53 | f.increment() 54 | Foo::print("Count is currently: #{f.count}") 55 | 56 | f_one = FiberOne.new(f) 57 | Foo::print("Count is (Fiber): #{f_one.go()}") 58 | Foo::print("Count is (Fiber): #{f_one.go()}") 59 | 60 | Foo::print("Setting variable to nil") 61 | f = nil 62 | f_one = nil 63 | 64 | Foo::print("Done") 65 | 66 | "A return value" 67 | -------------------------------------------------------------------------------- /MRubyiOSExample/main.m: -------------------------------------------------------------------------------- 1 | #import 2 | 3 | #import "AppDelegate.h" 4 | 5 | int main(int argc, char *argv[]) 6 | { 7 | @autoreleasepool { 8 | return UIApplicationMain(argc, argv, nil, NSStringFromClass([AppDelegate class])); 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ## About 2 | 3 | This is a complete example of using [mruby](https://github.com/mruby/mruby) 4 | embedded in an iOS app. You should be able to clone this repo and open it using 5 | XCode 4 then build and run. It has examples of calling Ruby code from 6 | Objective-C and Objective-C code from Ruby. 7 | 8 | ## Notes/Details 9 | 10 | This example includes a framework called MRuby.framework that was created 11 | using the build script found in the [ios ruby embedded](https://github.com/carsonmcdonald/ios-ruby-embedded) 12 | repo. To modify the Ruby included in this example you will need to have the 13 | mruby compiler that can be obtained by building the ios-ruby-embedded project 14 | or by building the mruby project. 15 | 16 | Files of note: 17 | 18 | * example.rb - This is the Ruby code for the example and has to be compiled 19 | into example.mrb before changes will take place. 20 | * example.mrb - This is the compiled version of example.rb. 21 | * FooData.h/m - This is an example data class that is wrapped using a Ruby 22 | class named FooData. 23 | * FooUtil.h/m - This is where all the interaction with mruby happens. It 24 | coordinates different parts of the examples as well. 25 | 26 | ## License 27 | 28 | MIT to match the mruby license. See the LICENSE file for full license. 29 | --------------------------------------------------------------------------------