mruby.h

00001 /*
00002 ** mruby - An embeddable Ruby implementation
00003 **
00004 ** Copyright (c) mruby developers 2010-2014
00005 **
00006 ** Permission is hereby granted, free of charge, to any person obtaining
00007 ** a copy of this software and associated documentation files (the
00008 ** "Software"), to deal in the Software without restriction, including
00009 ** without limitation the rights to use, copy, modify, merge, publish,
00010 ** distribute, sublicense, and/or sell copies of the Software, and to
00011 ** permit persons to whom the Software is furnished to do so, subject to
00012 ** the following conditions:
00013 **
00014 ** The above copyright notice and this permission notice shall be
00015 ** included in all copies or substantial portions of the Software.
00016 **
00017 ** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
00018 ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
00019 ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
00020 ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
00021 ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
00022 ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
00023 ** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
00024 **
00025 ** [ MIT license: http://www.opensource.org/licenses/mit-license.php ]
00026 */
00027 
00028 #ifndef MRUBY_H
00029 #define MRUBY_H
00030 
00031 #if defined(__cplusplus)
00032 extern "C" {
00033 #endif
00034 
00035 #include <stdint.h>
00036 #include <stddef.h>
00037 #include <limits.h>
00038 
00039 #include "mrbconf.h"
00040 #include "mruby/value.h"
00041 #include "mruby/version.h"
00042 
00043 typedef uint32_t mrb_code;
00044 typedef uint32_t mrb_aspec;
00045 
00046 struct mrb_irep;
00047 struct mrb_state;
00048 
00049 typedef void* (*mrb_allocf) (struct mrb_state *mrb, void*, size_t, void *ud);
00050 
00051 #ifndef MRB_GC_ARENA_SIZE
00052 #define MRB_GC_ARENA_SIZE 100
00053 #endif
00054 
00055 #ifndef MRB_FIXED_STATE_ATEXIT_STACK_SIZE
00056 #define MRB_FIXED_STATE_ATEXIT_STACK_SIZE 5
00057 #endif
00058 
00059 typedef struct {
00060   mrb_sym mid;
00061   struct RProc *proc;
00062   mrb_value *stackent;
00063   int nregs;
00064   int ridx;
00065   int eidx;
00066   struct REnv *env;
00067   mrb_code *pc;                 /* return address */
00068   mrb_code *err;                /* error position */
00069   int argc;
00070   int acc;
00071   struct RClass *target_class;
00072 } mrb_callinfo;
00073 
00074 enum mrb_fiber_state {
00075   MRB_FIBER_CREATED = 0,
00076   MRB_FIBER_RUNNING,
00077   MRB_FIBER_RESUMING,
00078   MRB_FIBER_SUSPENDED,
00079   MRB_FIBER_TRANSFERRED,
00080   MRB_FIBER_TERMINATED,
00081 };
00082 
00083 struct mrb_context {
00084   struct mrb_context *prev;
00085 
00086   mrb_value *stack;                       /* stack of virtual machine */
00087   mrb_value *stbase, *stend;
00088 
00089   mrb_callinfo *ci;
00090   mrb_callinfo *cibase, *ciend;
00091 
00092   mrb_code **rescue;                      /* exception handler stack */
00093   int rsize;
00094   struct RProc **ensure;                  /* ensure handler stack */
00095   int esize;
00096 
00097   enum mrb_fiber_state status;
00098   struct RFiber *fib;
00099 };
00100 
00101 enum gc_state {
00102   GC_STATE_ROOT = 0,
00103   GC_STATE_MARK,
00104   GC_STATE_SWEEP
00105 };
00106 
00107 struct mrb_jmpbuf;
00108 
00109 typedef void (*mrb_atexit_func)(struct mrb_state*);
00110 
00111 typedef struct mrb_state {
00112   struct mrb_jmpbuf *jmp;
00113 
00114   mrb_allocf allocf;                      /* memory allocation function */
00115   void *allocf_ud;                        /* auxiliary data of allocf */
00116 
00117   struct mrb_context *c;
00118   struct mrb_context *root_c;
00119 
00120   struct RObject *exc;                    /* exception */
00121   struct iv_tbl *globals;                 /* global variable table */
00122 
00123   struct RObject *top_self;
00124   struct RClass *object_class;            /* Object class */
00125   struct RClass *class_class;
00126   struct RClass *module_class;
00127   struct RClass *proc_class;
00128   struct RClass *string_class;
00129   struct RClass *array_class;
00130   struct RClass *hash_class;
00131 
00132   struct RClass *float_class;
00133   struct RClass *fixnum_class;
00134   struct RClass *true_class;
00135   struct RClass *false_class;
00136   struct RClass *nil_class;
00137   struct RClass *symbol_class;
00138   struct RClass *kernel_module;
00139 
00140   struct heap_page *heaps;                /* heaps for GC */
00141   struct heap_page *sweeps;
00142   struct heap_page *free_heaps;
00143   size_t live; /* count of live objects */
00144 #ifdef MRB_GC_FIXED_ARENA
00145   struct RBasic *arena[MRB_GC_ARENA_SIZE]; /* GC protection array */
00146 #else
00147   struct RBasic **arena;                   /* GC protection array */
00148   int arena_capa;
00149 #endif
00150   int arena_idx;
00151 
00152   enum gc_state gc_state; /* state of gc */
00153   int current_white_part; /* make white object by white_part */
00154   struct RBasic *gray_list; /* list of gray objects to be traversed incrementally */
00155   struct RBasic *atomic_gray_list; /* list of objects to be traversed atomically */
00156   size_t gc_live_after_mark;
00157   size_t gc_threshold;
00158   int gc_interval_ratio;
00159   int gc_step_ratio;
00160   mrb_bool gc_disabled:1;
00161   mrb_bool gc_full:1;
00162   mrb_bool is_generational_gc_mode:1;
00163   mrb_bool out_of_memory:1;
00164   size_t majorgc_old_threshold;
00165   struct alloca_header *mems;
00166 
00167   mrb_sym symidx;
00168   struct kh_n2s *name2sym;      /* symbol hash */
00169   struct symbol_name *symtbl;   /* symbol table */
00170   size_t symcapa;
00171 
00172 #ifdef ENABLE_DEBUG
00173   void (*code_fetch_hook)(struct mrb_state* mrb, struct mrb_irep *irep, mrb_code *pc, mrb_value *regs);
00174   void (*debug_op_hook)(struct mrb_state* mrb, struct mrb_irep *irep, mrb_code *pc, mrb_value *regs);
00175 #endif
00176 
00177   struct RClass *eException_class;
00178   struct RClass *eStandardError_class;
00179   struct RObject *nomem_err;              /* pre-allocated NoMemoryError */
00180 
00181   void *ud; /* auxiliary data */
00182 
00183 #ifdef MRB_FIXED_STATE_ATEXIT_STACK
00184   mrb_atexit_func atexit_stack[MRB_FIXED_STATE_ATEXIT_STACK_SIZE];
00185 #else
00186   mrb_atexit_func *atexit_stack;
00187 #endif
00188   mrb_int atexit_stack_len;
00189 } mrb_state;
00190 
00191 #if __STDC_VERSION__ >= 201112L
00192 # define mrb_noreturn _Noreturn
00193 #elif defined __GNUC__ && !defined __STRICT_ANSI__
00194 # define mrb_noreturn __attribute__((noreturn))
00195 #elif defined _MSC_VER
00196 # define mrb_noreturn __declspec(noreturn)
00197 #else
00198 # define mrb_noreturn
00199 #endif
00200 
00201 typedef mrb_value (*mrb_func_t)(mrb_state *mrb, mrb_value);
00202 MRB_API struct RClass *mrb_define_class(mrb_state *, const char*, struct RClass*);
00203 MRB_API struct RClass *mrb_define_module(mrb_state *, const char*);
00204 MRB_API mrb_value mrb_singleton_class(mrb_state*, mrb_value);
00205 MRB_API void mrb_include_module(mrb_state*, struct RClass*, struct RClass*);
00206 
00207 MRB_API void mrb_define_method(mrb_state*, struct RClass*, const char*, mrb_func_t, mrb_aspec);
00208 MRB_API void mrb_define_class_method(mrb_state *, struct RClass *, const char *, mrb_func_t, mrb_aspec);
00209 MRB_API void mrb_define_singleton_method(mrb_state*, struct RObject*, const char*, mrb_func_t, mrb_aspec);
00210 MRB_API void mrb_define_module_function(mrb_state*, struct RClass*, const char*, mrb_func_t, mrb_aspec);
00211 MRB_API void mrb_define_const(mrb_state*, struct RClass*, const char *name, mrb_value);
00212 MRB_API void mrb_undef_method(mrb_state*, struct RClass*, const char*);
00213 MRB_API void mrb_undef_class_method(mrb_state*, struct RClass*, const char*);
00214 MRB_API mrb_value mrb_obj_new(mrb_state *mrb, struct RClass *c, mrb_int argc, const mrb_value *argv);
00215 #define mrb_class_new_instance(mrb,argc,argv,c) mrb_obj_new(mrb,c,argc,argv)
00216 MRB_API mrb_value mrb_instance_new(mrb_state *mrb, mrb_value cv);
00217 MRB_API struct RClass * mrb_class_new(mrb_state *mrb, struct RClass *super);
00218 MRB_API struct RClass * mrb_module_new(mrb_state *mrb);
00219 MRB_API mrb_bool mrb_class_defined(mrb_state *mrb, const char *name);
00220 MRB_API struct RClass * mrb_class_get(mrb_state *mrb, const char *name);
00221 MRB_API struct RClass * mrb_class_get_under(mrb_state *mrb, struct RClass *outer, const char *name);
00222 MRB_API struct RClass * mrb_module_get(mrb_state *mrb, const char *name);
00223 MRB_API struct RClass * mrb_module_get_under(mrb_state *mrb, struct RClass *outer, const char *name);
00224 MRB_API mrb_value mrb_notimplement_m(mrb_state*, mrb_value);
00225 
00226 MRB_API mrb_value mrb_obj_dup(mrb_state *mrb, mrb_value obj);
00227 MRB_API mrb_value mrb_check_to_integer(mrb_state *mrb, mrb_value val, const char *method);
00228 MRB_API mrb_bool mrb_obj_respond_to(mrb_state *mrb, struct RClass* c, mrb_sym mid);
00229 MRB_API struct RClass * mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super);
00230 MRB_API struct RClass * mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name);
00231 
00232 /* required arguments */
00233 #define MRB_ARGS_REQ(n)     ((mrb_aspec)((n)&0x1f) << 18)
00234 /* optional arguments */
00235 #define MRB_ARGS_OPT(n)     ((mrb_aspec)((n)&0x1f) << 13)
00236 /* mandatory and optinal arguments */
00237 #define MRB_ARGS_ARG(n1,n2)   (MRB_ARGS_REQ(n1)|MRB_ARGS_OPT(n2))
00238 
00239 /* rest argument */
00240 #define MRB_ARGS_REST()     ((mrb_aspec)(1 << 12))
00241 /* required arguments after rest */
00242 #define MRB_ARGS_POST(n)    ((mrb_aspec)((n)&0x1f) << 7)
00243 /* keyword arguments (n of keys, kdict) */
00244 #define MRB_ARGS_KEY(n1,n2) ((mrb_aspec)((((n1)&0x1f) << 2) | ((n2)?(1<<1):0)))
00245 /* block argument */
00246 #define MRB_ARGS_BLOCK()    ((mrb_aspec)1)
00247 
00248 /* accept any number of arguments */
00249 #define MRB_ARGS_ANY()      MRB_ARGS_REST()
00250 /* accept no arguments */
00251 #define MRB_ARGS_NONE()     ((mrb_aspec)0)
00252 
00253 /* compatibility macros; will be removed */
00254 #define ARGS_REQ(n)         MRB_ARGS_REQ(n)
00255 #define ARGS_OPT(n)         MRB_ARGS_OPT(n)
00256 #define ARGS_REST()         MRB_ARGS_REST()
00257 #define ARGS_POST(n)        MRB_ARGS_POST()
00258 #define ARGS_KEY(n1,n2)     MRB_ARGS_KEY(n1,n2)
00259 #define ARGS_BLOCK()        MRB_ARGS_BLOCK()
00260 #define ARGS_ANY()          MRB_ARGS_ANY()
00261 #define ARGS_NONE()         MRB_ARGS_NONE()
00262 
00263 MRB_API mrb_int mrb_get_args(mrb_state *mrb, const char *format, ...);
00264 
00265 /* `strlen` for character string literals (use with caution or `strlen` instead)
00266     Adjacent string literals are concatenated in C/C++ in translation phase 6.
00267     If `lit` is not one, the compiler will report a syntax error:
00268      MSVC: "error C2143: syntax error : missing ')' before 'string'"
00269      GCC:  "error: expected ')' before string constant"
00270 */
00271 #define mrb_strlen_lit(lit) (sizeof(lit "") - 1)
00272 
00273 MRB_API mrb_value mrb_funcall(mrb_state*, mrb_value, const char*, mrb_int,...);
00274 MRB_API mrb_value mrb_funcall_argv(mrb_state*, mrb_value, mrb_sym, mrb_int, const mrb_value*);
00275 MRB_API mrb_value mrb_funcall_with_block(mrb_state*, mrb_value, mrb_sym, mrb_int, const mrb_value*, mrb_value);
00276 MRB_API mrb_sym mrb_intern_cstr(mrb_state*,const char*);
00277 MRB_API mrb_sym mrb_intern(mrb_state*,const char*,size_t);
00278 MRB_API mrb_sym mrb_intern_static(mrb_state*,const char*,size_t);
00279 #define mrb_intern_lit(mrb, lit) mrb_intern_static(mrb, lit, mrb_strlen_lit(lit))
00280 MRB_API mrb_sym mrb_intern_str(mrb_state*,mrb_value);
00281 MRB_API mrb_value mrb_check_intern_cstr(mrb_state*,const char*);
00282 MRB_API mrb_value mrb_check_intern(mrb_state*,const char*,size_t);
00283 MRB_API mrb_value mrb_check_intern_str(mrb_state*,mrb_value);
00284 MRB_API const char *mrb_sym2name(mrb_state*,mrb_sym);
00285 MRB_API const char *mrb_sym2name_len(mrb_state*,mrb_sym,mrb_int*);
00286 MRB_API mrb_value mrb_sym2str(mrb_state*,mrb_sym);
00287 
00288 MRB_API void *mrb_malloc(mrb_state*, size_t);         /* raise RuntimeError if no mem */
00289 MRB_API void *mrb_calloc(mrb_state*, size_t, size_t); /* ditto */
00290 MRB_API void *mrb_realloc(mrb_state*, void*, size_t); /* ditto */
00291 MRB_API void *mrb_realloc_simple(mrb_state*, void*, size_t); /* return NULL if no memory available */
00292 MRB_API void *mrb_malloc_simple(mrb_state*, size_t);  /* return NULL if no memory available */
00293 MRB_API struct RBasic *mrb_obj_alloc(mrb_state*, enum mrb_vtype, struct RClass*);
00294 MRB_API void mrb_free(mrb_state*, void*);
00295 
00296 MRB_API mrb_value mrb_str_new(mrb_state *mrb, const char *p, size_t len);
00297 MRB_API mrb_value mrb_str_new_cstr(mrb_state*, const char*);
00298 MRB_API mrb_value mrb_str_new_static(mrb_state *mrb, const char *p, size_t len);
00299 #define mrb_str_new_lit(mrb, lit) mrb_str_new_static(mrb, (lit), mrb_strlen_lit(lit))
00300 
00301 MRB_API mrb_state* mrb_open(void);
00302 MRB_API mrb_state* mrb_open_allocf(mrb_allocf, void *ud);
00303 MRB_API mrb_state* mrb_open_core(mrb_allocf, void *ud);
00304 MRB_API void mrb_close(mrb_state*);
00305 
00306 MRB_API void* mrb_default_allocf(mrb_state*, void*, size_t, void*);
00307 
00308 MRB_API mrb_value mrb_top_self(mrb_state *);
00309 MRB_API mrb_value mrb_run(mrb_state*, struct RProc*, mrb_value);
00310 MRB_API mrb_value mrb_toplevel_run(mrb_state*, struct RProc*);
00311 MRB_API mrb_value mrb_context_run(mrb_state*, struct RProc*, mrb_value, unsigned int);
00312 
00313 MRB_API void mrb_p(mrb_state*, mrb_value);
00314 MRB_API mrb_int mrb_obj_id(mrb_value obj);
00315 MRB_API mrb_sym mrb_obj_to_sym(mrb_state *mrb, mrb_value name);
00316 
00317 MRB_API mrb_bool mrb_obj_eq(mrb_state*, mrb_value, mrb_value);
00318 MRB_API mrb_bool mrb_obj_equal(mrb_state*, mrb_value, mrb_value);
00319 MRB_API mrb_bool mrb_equal(mrb_state *mrb, mrb_value obj1, mrb_value obj2);
00320 MRB_API mrb_value mrb_convert_to_integer(mrb_state *mrb, mrb_value val, int base);
00321 MRB_API mrb_value mrb_Integer(mrb_state *mrb, mrb_value val);
00322 MRB_API mrb_value mrb_Float(mrb_state *mrb, mrb_value val);
00323 MRB_API mrb_value mrb_inspect(mrb_state *mrb, mrb_value obj);
00324 MRB_API mrb_bool mrb_eql(mrb_state *mrb, mrb_value obj1, mrb_value obj2);
00325 
00326 MRB_API void mrb_garbage_collect(mrb_state*);
00327 MRB_API void mrb_full_gc(mrb_state*);
00328 MRB_API void mrb_incremental_gc(mrb_state *);
00329 MRB_API int mrb_gc_arena_save(mrb_state*);
00330 MRB_API void mrb_gc_arena_restore(mrb_state*,int);
00331 MRB_API void mrb_gc_mark(mrb_state*,struct RBasic*);
00332 #define mrb_gc_mark_value(mrb,val) do {\
00333   if (!mrb_immediate_p(val)) mrb_gc_mark((mrb), mrb_basic_ptr(val)); \
00334 } while (0)
00335 MRB_API void mrb_field_write_barrier(mrb_state *, struct RBasic*, struct RBasic*);
00336 #define mrb_field_write_barrier_value(mrb, obj, val) do{\
00337   if (!mrb_immediate_p(val)) mrb_field_write_barrier((mrb), (obj), mrb_basic_ptr(val)); \
00338 } while (0)
00339 MRB_API void mrb_write_barrier(mrb_state *, struct RBasic*);
00340 
00341 MRB_API mrb_value mrb_check_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char *tname, const char *method);
00342 MRB_API mrb_value mrb_any_to_s(mrb_state *mrb, mrb_value obj);
00343 MRB_API const char * mrb_obj_classname(mrb_state *mrb, mrb_value obj);
00344 MRB_API struct RClass* mrb_obj_class(mrb_state *mrb, mrb_value obj);
00345 MRB_API mrb_value mrb_class_path(mrb_state *mrb, struct RClass *c);
00346 MRB_API mrb_value mrb_convert_type(mrb_state *mrb, mrb_value val, enum mrb_vtype type, const char *tname, const char *method);
00347 MRB_API mrb_bool mrb_obj_is_kind_of(mrb_state *mrb, mrb_value obj, struct RClass *c);
00348 MRB_API mrb_value mrb_obj_inspect(mrb_state *mrb, mrb_value self);
00349 MRB_API mrb_value mrb_obj_clone(mrb_state *mrb, mrb_value self);
00350 
00351 /* need to include <ctype.h> to use these macros */
00352 #ifndef ISPRINT
00353 #define ISASCII(c) (!(((int)(unsigned char)(c)) & ~0x7f))
00354 #define ISPRINT(c) (ISASCII(c) && isprint((int)(unsigned char)(c)))
00355 #define ISSPACE(c) (ISASCII(c) && isspace((int)(unsigned char)(c)))
00356 #define ISUPPER(c) (ISASCII(c) && isupper((int)(unsigned char)(c)))
00357 #define ISLOWER(c) (ISASCII(c) && islower((int)(unsigned char)(c)))
00358 #define ISALNUM(c) (ISASCII(c) && isalnum((int)(unsigned char)(c)))
00359 #define ISALPHA(c) (ISASCII(c) && isalpha((int)(unsigned char)(c)))
00360 #define ISDIGIT(c) (ISASCII(c) && isdigit((int)(unsigned char)(c)))
00361 #define ISXDIGIT(c) (ISASCII(c) && isxdigit((int)(unsigned char)(c)))
00362 #define ISBLANK(c) (ISASCII(c) && isblank((int)(unsigned char)(c)))
00363 #define ISCNTRL(c) (ISASCII(c) && iscntrl((int)(unsigned char)(c)))
00364 #define TOUPPER(c) (ISASCII(c) ? toupper((int)(unsigned char)(c)) : (c))
00365 #define TOLOWER(c) (ISASCII(c) ? tolower((int)(unsigned char)(c)) : (c))
00366 #endif
00367 
00368 MRB_API mrb_value mrb_exc_new(mrb_state *mrb, struct RClass *c, const char *ptr, long len);
00369 MRB_API mrb_noreturn void mrb_exc_raise(mrb_state *mrb, mrb_value exc);
00370 
00371 MRB_API mrb_noreturn void mrb_raise(mrb_state *mrb, struct RClass *c, const char *msg);
00372 MRB_API mrb_noreturn void mrb_raisef(mrb_state *mrb, struct RClass *c, const char *fmt, ...);
00373 MRB_API mrb_noreturn void mrb_name_error(mrb_state *mrb, mrb_sym id, const char *fmt, ...);
00374 MRB_API void mrb_warn(mrb_state *mrb, const char *fmt, ...);
00375 MRB_API mrb_noreturn void mrb_bug(mrb_state *mrb, const char *fmt, ...);
00376 MRB_API void mrb_print_backtrace(mrb_state *mrb);
00377 MRB_API void mrb_print_error(mrb_state *mrb);
00378 
00379 /* macros to get typical exception objects
00380    note:
00381    + those E_* macros requires mrb_state* variable named mrb.
00382    + exception objects obtained from those macros are local to mrb
00383 */
00384 #define E_RUNTIME_ERROR             (mrb_class_get(mrb, "RuntimeError"))
00385 #define E_TYPE_ERROR                (mrb_class_get(mrb, "TypeError"))
00386 #define E_ARGUMENT_ERROR            (mrb_class_get(mrb, "ArgumentError"))
00387 #define E_INDEX_ERROR               (mrb_class_get(mrb, "IndexError"))
00388 #define E_RANGE_ERROR               (mrb_class_get(mrb, "RangeError"))
00389 #define E_NAME_ERROR                (mrb_class_get(mrb, "NameError"))
00390 #define E_NOMETHOD_ERROR            (mrb_class_get(mrb, "NoMethodError"))
00391 #define E_SCRIPT_ERROR              (mrb_class_get(mrb, "ScriptError"))
00392 #define E_SYNTAX_ERROR              (mrb_class_get(mrb, "SyntaxError"))
00393 #define E_LOCALJUMP_ERROR           (mrb_class_get(mrb, "LocalJumpError"))
00394 #define E_REGEXP_ERROR              (mrb_class_get(mrb, "RegexpError"))
00395 #define E_SYSSTACK_ERROR            (mrb_class_get(mrb, "SystemStackError"))
00396 
00397 #define E_NOTIMP_ERROR              (mrb_class_get(mrb, "NotImplementedError"))
00398 #define E_FLOATDOMAIN_ERROR         (mrb_class_get(mrb, "FloatDomainError"))
00399 
00400 #define E_KEY_ERROR                 (mrb_class_get(mrb, "KeyError"))
00401 
00402 MRB_API mrb_value mrb_yield(mrb_state *mrb, mrb_value b, mrb_value arg);
00403 MRB_API mrb_value mrb_yield_argv(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value *argv);
00404 MRB_API mrb_value mrb_yield_with_class(mrb_state *mrb, mrb_value b, mrb_int argc, const mrb_value *argv, mrb_value self, struct RClass *c);
00405 
00406 MRB_API void mrb_gc_protect(mrb_state *mrb, mrb_value obj);
00407 MRB_API mrb_value mrb_to_int(mrb_state *mrb, mrb_value val);
00408 #define mrb_int(mrb, val) mrb_fixnum(mrb_to_int(mrb, val))
00409 MRB_API void mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t);
00410 
00411 typedef enum call_type {
00412   CALL_PUBLIC,
00413   CALL_FCALL,
00414   CALL_VCALL,
00415   CALL_TYPE_MAX
00416 } call_type;
00417 
00418 MRB_API void mrb_define_alias(mrb_state *mrb, struct RClass *klass, const char *name1, const char *name2);
00419 MRB_API const char *mrb_class_name(mrb_state *mrb, struct RClass* klass);
00420 MRB_API void mrb_define_global_const(mrb_state *mrb, const char *name, mrb_value val);
00421 
00422 MRB_API mrb_value mrb_attr_get(mrb_state *mrb, mrb_value obj, mrb_sym id);
00423 
00424 MRB_API mrb_bool mrb_respond_to(mrb_state *mrb, mrb_value obj, mrb_sym mid);
00425 MRB_API mrb_bool mrb_obj_is_instance_of(mrb_state *mrb, mrb_value obj, struct RClass* c);
00426 
00427 /* fiber functions (you need to link mruby-fiber mrbgem to use) */
00428 MRB_API mrb_value mrb_fiber_yield(mrb_state *mrb, mrb_int argc, const mrb_value *argv);
00429 #define E_FIBER_ERROR (mrb_class_get(mrb, "FiberError"))
00430 
00431 /* memory pool implementation */
00432 typedef struct mrb_pool mrb_pool;
00433 MRB_API struct mrb_pool* mrb_pool_open(mrb_state*);
00434 MRB_API void mrb_pool_close(struct mrb_pool*);
00435 MRB_API void* mrb_pool_alloc(struct mrb_pool*, size_t);
00436 MRB_API void* mrb_pool_realloc(struct mrb_pool*, void*, size_t oldlen, size_t newlen);
00437 MRB_API mrb_bool mrb_pool_can_realloc(struct mrb_pool*, void*, size_t);
00438 MRB_API void* mrb_alloca(mrb_state *mrb, size_t);
00439 
00440 MRB_API void mrb_state_atexit(mrb_state *mrb, mrb_atexit_func func);
00441 
00442 #ifdef MRB_DEBUG
00443 #include <assert.h>
00444 #define mrb_assert(p) assert(p)
00445 #define mrb_assert_int_fit(t1,n,t2,max) assert((n)>=0 && ((sizeof(n)<=sizeof(t2))||(n<=(t1)(max))))
00446 #else
00447 #define mrb_assert(p) ((void)0)
00448 #define mrb_assert_int_fit(t1,n,t2,max) ((void)0)
00449 #endif
00450 
00451 #if __STDC_VERSION__ >= 201112L
00452 #define mrb_static_assert(exp, str) _Static_assert(exp, str)
00453 #else
00454 #define mrb_static_assert(exp, str) mrb_assert(exp)
00455 #endif
00456 
00457 MRB_API mrb_value mrb_format(mrb_state *mrb, const char *format, ...);
00458 
00459 #if defined(__cplusplus)
00460 }  /* extern "C" { */
00461 #endif
00462 
00463 #endif  /* MRUBY_H */
00464