/* ** mruby - An embeddable Ruby implementaion ** ** Copyright (c) mruby developers 2010-2012 ** ** Permission is hereby granted, free of charge, to any person obtaining ** a copy of this software and associated documentation files (the ** "Software"), to deal in the Software without restriction, including ** without limitation the rights to use, copy, modify, merge, publish, ** distribute, sublicense, and/or sell copies of the Software, and to ** permit persons to whom the Software is furnished to do so, subject to ** the following conditions: ** ** The above copyright notice and this permission notice shall be ** included in all copies or substantial portions of the Software. ** ** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE ** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ** ** [ MIT license: http://www.opensource.org/licenses/mit-license.php ] */ #ifndef MRUBY_H #define MRUBY_H #include #include "mrbconf.h" enum mrb_vtype { MRB_TT_FALSE = 0, /* 0 */ MRB_TT_FREE, /* 1 */ MRB_TT_TRUE, /* 2 */ MRB_TT_FIXNUM, /* 3 */ MRB_TT_SYMBOL, /* 4 */ MRB_TT_UNDEF, /* 5 */ MRB_TT_FLOAT, /* 6 */ MRB_TT_OBJECT, /* 7 */ MRB_TT_CLASS, /* 8 */ MRB_TT_MODULE, /* 9 */ MRB_TT_ICLASS, /* 10 */ MRB_TT_SCLASS, /* 11 */ MRB_TT_PROC, /* 12 */ MRB_TT_ARRAY, /* 13 */ MRB_TT_HASH, /* 14 */ MRB_TT_STRING, /* 15 */ MRB_TT_RANGE, /* 16 */ MRB_TT_REGEX, /* 17 */ MRB_TT_STRUCT, /* 18 */ MRB_TT_EXCEPTION, /* 19 */ MRB_TT_MATCH, /* 20 */ MRB_TT_FILE, /* 21 */ MRB_TT_ENV, /* 22 */ MRB_TT_DATA, /* 23 */ MRB_TT_THREAD, /* 24 */ MRB_TT_THREADGRP, /* 25 */ MRB_TT_MAXDEFINE /* 26 */ }; typedef struct mrb_value { union { mrb_float f; void *p; mrb_int i; mrb_sym sym; } value; enum mrb_vtype tt:8; } mrb_value; #define mrb_type(o) (o).tt #define mrb_nil_p(o) ((o).tt == MRB_TT_FALSE && !(o).value.i) #define mrb_test(o) ((o).tt != MRB_TT_FALSE) #define mrb_fixnum(o) (o).value.i #define mrb_float(o) (o).value.f #define mrb_symbol(o) (o).value.sym #define mrb_object(o) (o).value.p #define FIXNUM_P(o) ((o).tt == MRB_TT_FIXNUM) #define UNDEF_P(o) ((o).tt == MRB_TT_UNDEF) #include "mruby/object.h" #define IMMEDIATE_P(x) ((mrb_type(x) >= MRB_TT_FALSE) && (mrb_type(x) <= MRB_TT_FLOAT)) #define SPECIAL_CONST_P(x) IMMEDIATE_P(x) #define SYMBOL_P(o) (mrb_type(o) == MRB_TT_SYMBOL) #define RTEST(o) mrb_test(o) #define FL_ABLE(x) (!SPECIAL_CONST_P(x)) #define FL_TEST(x,f) (FL_ABLE(x)?(RBASIC(x)->flags&(f)):0) #define FL_ANY(x,f) FL_TEST(x,f) #define FL_ALL(x,f) (FL_TEST(x,f) == (f)) #define FL_SET(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags |= (f);} while (0) #define FL_UNSET(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags &= ~(f);} while (0) static inline mrb_int mrb_special_const_p(mrb_value obj) { if (SPECIAL_CONST_P(obj)) return 1; return 0; } static inline mrb_value mrb_fixnum_value(mrb_int i) { mrb_value v; v.tt = MRB_TT_FIXNUM; v.value.i = i; return v; } static inline mrb_value mrb_float_value(mrb_float f) { mrb_value v; v.tt = MRB_TT_FLOAT; v.value.f = f; return v; } static inline mrb_value mrb_symbol_value(mrb_sym i) { mrb_value v; v.tt = MRB_TT_SYMBOL; v.value.sym = i; return v; } static inline mrb_value mrb_obj_value(void *p) { mrb_value v; struct RBasic *b = (struct RBasic*) p; v.tt = b->tt; v.value.p = p; return v; } static inline mrb_value mrb_false_value() { mrb_value v; v.tt = MRB_TT_FALSE; v.value.i = 1; return v; } static inline mrb_value mrb_nil_value() { mrb_value v; v.tt = MRB_TT_FALSE; v.value.p = 0; return v; } static inline mrb_value mrb_true_value() { mrb_value v; v.tt = MRB_TT_TRUE; v.value.i = 1; return v; } static inline mrb_value mrb_undef_value() { mrb_value v; v.tt = MRB_TT_UNDEF; v.value.i = 0; return v; } typedef int32_t mrb_code; struct mrb_state; typedef void* (*mrb_allocf) (struct mrb_state *mrb, void*, size_t); #define MRB_ARENA_SIZE 1024 //256 up kusuda 2011/04/30 #define ruby_debug (mrb_nil_value()) #define ruby_verbose (mrb_nil_value()) typedef struct { mrb_sym mid; struct RProc *proc; int stackidx; int nregs; int argc; mrb_code *pc; int acc; struct RClass *target_class; int ridx; int eidx; struct REnv *env; } mrb_callinfo; enum gc_state { GC_STATE_NONE = 0, GC_STATE_MARK, GC_STATE_SWEEP }; typedef struct mrb_state { void *jmp; mrb_allocf allocf; mrb_value *stack; mrb_value *stbase, *stend; mrb_callinfo *ci; mrb_callinfo *cibase, *ciend; mrb_code **rescue; int rsize; struct RProc **ensure; int esize; struct RObject *exc; struct kh_iv *globals; struct mrb_irep **irep; size_t irep_len, irep_capa; struct RClass *object_class; struct RClass *class_class; struct RClass *module_class; struct RClass *proc_class; struct RClass *string_class; struct RClass *array_class; struct RClass *hash_class; struct RClass *range_class; #ifdef INCLUDE_REGEXP struct RClass *regex_class; struct RClass *match_class; #endif #ifdef INCLUDE_ENCODING struct RClass *encode_class; struct RClass *converter_class; #endif struct RClass *float_class; struct RClass *fixnum_class; struct RClass *true_class; struct RClass *false_class; struct RClass *nil_class; struct RClass *symbol_class; struct RClass *kernel_module; struct heap_page *heaps; struct heap_page *sweeps; struct heap_page *free_heaps; size_t live; /* count of live objects */ struct RBasic *arena[MRB_ARENA_SIZE]; int arena_idx; enum gc_state gc_state; /* state of gc */ int current_white_part; /* make white object by white_part */ struct RBasic *gray_list; /* list of gray objects */ struct RBasic *variable_gray_list; /* list of objects to be traversed atomically */ size_t gc_live_after_mark; size_t gc_threshold; mrb_int gc_interval_ratio; mrb_int gc_step_ratio; mrb_sym symidx; struct kh_n2s *name2sym; /* symbol table */ struct kh_s2n *sym2name; /* reverse symbol table */ struct RNode *local_svar;/* regexp */ struct RClass *eException_class; struct RClass *eStandardError_class; struct RClass *eRuntimeError_class; } mrb_state; typedef mrb_value (*mrb_func_t)(mrb_state *mrb, mrb_value); typedef mrb_value (*mrb_funcargv_t)(mrb_state *mrb, mrb_value, int argc, mrb_value* argv); struct RClass *mrb_define_class(mrb_state *, const char*, struct RClass*); struct RClass *mrb_define_module(mrb_state *, const char*); mrb_value mrb_singleton_class(mrb_state*, mrb_value); void mrb_include_module(mrb_state*, struct RClass*, struct RClass*); void mrb_define_method(mrb_state*, struct RClass*, const char*, mrb_func_t,int); void mrb_define_class_method(mrb_state *, struct RClass *, const char *, mrb_func_t, int); void mrb_define_singleton_method(mrb_state*, void*, const char*, mrb_func_t,int); void mrb_define_const(mrb_state*, struct RClass*, const char *name, mrb_value); mrb_value mrb_instance_new(mrb_state *mrb, mrb_value cv); struct RClass * mrb_class_new(mrb_state *mrb, struct RClass *super); struct RClass * mrb_module_new(mrb_state *mrb); struct RClass * mrb_class_from_sym(mrb_state *mrb, struct RClass *klass, mrb_sym name); struct RClass * mrb_class_get(mrb_state *mrb, char *name); struct RClass * mrb_class_obj_get(mrb_state *mrb, char *name); mrb_value mrb_obj_dup(mrb_state *mrb, mrb_value obj); mrb_value mrb_check_to_integer(mrb_state *mrb, mrb_value val, const char *method); int mrb_obj_respond_to(struct RClass* c, mrb_sym mid); struct RClass * mrb_define_class_under(mrb_state *mrb, struct RClass *outer, const char *name, struct RClass *super); struct RClass * mrb_define_module_under(mrb_state *mrb, struct RClass *outer, const char *name); /* required arguments */ #define ARGS_REQ(n) (((n)&0x1f) << 19) /* optional arguments */ #define ARGS_OPT(n) (((n)&0x1f) << 14) /* rest argument */ #define ARGS_REST() (1 << 13) /* required arguments after rest */ #define ARGS_POST(n) (((n)&0x1f) << 8) /* keyword arguments (n of keys, kdict) */ #define ARGS_KEY(n1,n2) ((((n1)&0x1f) << 3) | ((n2)?(1<<2):0)) /* block argument */ #define ARGS_BLOCK() (1 << 1) /* accept any number of arguments */ #define ARGS_ANY() ARGS_REST() /* accept no arguments */ #define ARGS_NONE() 0 int mrb_get_args(mrb_state *mrb, const char *format, ...); mrb_value mrb_funcall(mrb_state*, mrb_value, const char*, int,...); mrb_value mrb_funcall_argv(mrb_state*, mrb_value, const char*, int, mrb_value*); mrb_value mrb_funcall_with_block(mrb_state*, mrb_value, const char*, int, mrb_value*, struct RProc*); mrb_sym mrb_intern(mrb_state*,const char*); const char *mrb_sym2name(mrb_state*,mrb_sym); mrb_value mrb_str_format(mrb_state *, int, const mrb_value *, mrb_value); void *mrb_malloc(mrb_state*, size_t); void *mrb_calloc(mrb_state*, size_t, size_t); void *mrb_realloc(mrb_state*, void*, size_t); void *mrb_obj_alloc(mrb_state*, enum mrb_vtype, struct RClass*); void *mrb_free(mrb_state*, void*); mrb_value mrb_str_new_cstr(mrb_state*, const char*); mrb_state* mrb_open(void); mrb_state* mrb_open_allocf(mrb_allocf); void mrb_close(mrb_state*); int mrb_checkstack(mrb_state*,int); mrb_value mrb_top_self(mrb_state *); mrb_value mrb_run(mrb_state*, struct RProc*, mrb_value); mrb_value mrb_p(mrb_state*, mrb_value); int mrb_obj_id(mrb_value obj); mrb_sym mrb_to_id(mrb_state *mrb, mrb_value name); int mrb_obj_equal(mrb_state*, mrb_value, mrb_value); int mrb_equal(mrb_state *mrb, mrb_value obj1, mrb_value obj2); mrb_value mrb_Integer(mrb_state *mrb, mrb_value val); mrb_value mrb_Float(mrb_state *mrb, mrb_value val); mrb_value mrb_inspect(mrb_state *mrb, mrb_value obj); int mrb_eql(mrb_state *mrb, mrb_value obj1, mrb_value obj2); void mrb_garbage_collect(mrb_state*); void mrb_incremental_gc(mrb_state *); int mrb_gc_arena_save(mrb_state*); void mrb_gc_arena_restore(mrb_state*,int); void mrb_gc_mark(mrb_state*,struct RBasic*); #define mrb_gc_mark_value(mrb,val) do {\ if ((val).tt >= MRB_TT_OBJECT) mrb_gc_mark((mrb), mrb_object(val));\ } while (0); void mrb_gc_mark_gv(mrb_state*); void mrb_gc_free_gv(mrb_state*); void mrb_gc_mark_iv(mrb_state*, struct RObject*); size_t mrb_gc_mark_iv_size(mrb_state*, struct RObject*); void mrb_gc_free_iv(mrb_state*, struct RObject*); void mrb_gc_mark_mt(mrb_state*, struct RClass*); size_t mrb_gc_mark_mt_size(mrb_state*, struct RClass*); void mrb_gc_free_mt(mrb_state*, struct RClass*); void mrb_gc_mark_ht(mrb_state*, struct RClass*); size_t mrb_gc_mark_ht_size(mrb_state*, struct RClass*); void mrb_gc_free_ht(mrb_state*, struct RClass*); void mrb_field_write_barrier(mrb_state *, struct RBasic*, struct RBasic*); #define mrb_field_write_barrier_value(mrb, obj, val) do{\ if ((val.tt >= MRB_TT_OBJECT)) mrb_field_write_barrier((mrb), (obj), mrb_object(val));\ } while (0); void mrb_write_barrier(mrb_state *, struct RBasic*); #define MRUBY_VERSION "Rite" #ifdef DEBUG #undef DEBUG #endif #if 0 #define DEBUG(x) x #else #define DEBUG(x) #endif mrb_value mrb_check_convert_type(mrb_state *mrb, mrb_value val, mrb_int type, const char *tname, const char *method); mrb_value mrb_any_to_s(mrb_state *mrb, mrb_value obj); const char * mrb_obj_classname(mrb_state *mrb, mrb_value obj); struct RClass* mrb_obj_class(mrb_state *mrb, mrb_value obj); mrb_value mrb_class_path(mrb_state *mrb, struct RClass *c); mrb_value mrb_convert_type(mrb_state *mrb, mrb_value val, mrb_int type, const char *tname, const char *method); mrb_int mrb_obj_is_kind_of(mrb_state *mrb, mrb_value obj, struct RClass *c); mrb_value mrb_obj_inspect(mrb_state *mrb, mrb_value self); mrb_value mrb_obj_clone(mrb_state *mrb, mrb_value self); mrb_value mrb_check_funcall(mrb_state *mrb, mrb_value recv, mrb_sym mid, int argc, mrb_value *argv); /* need to include to use these macros */ #ifndef ISPRINT //#define ISASCII(c) isascii((int)(unsigned char)(c)) #define ISASCII(c) 1 #undef ISPRINT #define ISPRINT(c) (ISASCII(c) && isprint((int)(unsigned char)(c))) #define ISSPACE(c) (ISASCII(c) && isspace((int)(unsigned char)(c))) #define ISUPPER(c) (ISASCII(c) && isupper((int)(unsigned char)(c))) #define ISLOWER(c) (ISASCII(c) && islower((int)(unsigned char)(c))) #define ISALNUM(c) (ISASCII(c) && isalnum((int)(unsigned char)(c))) #define ISALPHA(c) (ISASCII(c) && isalpha((int)(unsigned char)(c))) #define ISDIGIT(c) (ISASCII(c) && isdigit((int)(unsigned char)(c))) #define ISXDIGIT(c) (ISASCII(c) && isxdigit((int)(unsigned char)(c))) #endif extern mrb_value mrb_rs; extern mrb_value mrb_default_rs; int mrb_block_given_p(void); void mrb_raise(mrb_state *mrb, struct RClass *c, const char *fmt, ...); void rb_raise(struct RClass *c, const char *fmt, ...); void mrb_warn(const char *fmt, ...); void mrb_warning(const char *fmt, ...); void mrb_bug(const char *fmt, ...); #define E_TYPE_ERROR (mrb_class_obj_get(mrb, "TypeError")) #define E_ARGUMENT_ERROR (mrb_class_obj_get(mrb, "ArgumentError")) #define E_INDEX_ERROR (mrb_class_obj_get(mrb, "IndexError")) #define E_RANGE_ERROR (mrb_class_obj_get(mrb, "RangeError")) #define E_NAME_ERROR (mrb_class_obj_get(mrb, "NameError")) #define E_NOMETHOD_ERROR (mrb_class_obj_get(mrb, "NoMethodError")) #define E_SCRIPT_ERROR (mrb_class_obj_get(mrb, "ScriptError")) #define E_SYNTAX_ERROR (mrb_class_obj_get(mrb, "SyntaxError")) #define E_LOAD_ERROR (mrb_class_obj_get(mrb, "LoadError")) #define E_SYSTEMCALL_ERROR (mrb_class_obj_get(mrb, "SystemCallError")) #define E_LOCALJUMP_ERROR (mrb_class_obj_get(mrb, "LocalJumpError")) #define E_REGEXP_ERROR (mrb_class_obj_get(mrb, "RegexpError")) #define E_ZERODIVISION_ERROR (mrb_class_obj_get(mrb, "ZeroDivisionError")) #define E_ENCODING_ERROR (mrb_class_obj_get(mrb, "EncodingError")) #define E_NOTIMP_ERROR (mrb_class_obj_get(mrb, "NotImplementedError")) #define E_FLOATDOMAIN_ERROR (mrb_class_obj_get(mrb, "FloatDomainError")) #define E_KEY_ERROR (mrb_class_obj_get(mrb, "KeyError")) #define SYM2ID(x) ((x).value.sym) #define CONST_ID_CACHE(mrb, result, str) \ { \ static mrb_sym mrb_intern_id_cache;\ if (!mrb_intern_id_cache) \ mrb_intern_id_cache = mrb_intern(mrb, str); \ result mrb_intern_id_cache; \ } #define CONST_ID(mrb, var, str) \ do CONST_ID_CACHE(mrb, var =, str) while (0) #define NUM2CHR_internal(x) (((mrb_type(x) == MRB_TT_STRING)&&(RSTRING_LEN(x)>=1))?\ RSTRING_PTR(x)[0]:(char)(mrb_fixnum_number(x)&0xff)) #ifdef __GNUC__ # define NUM2CHR(x) __extension__ ({mrb_value num2chr_x = (x); NUM2CHR_internal(num2chr_x);}) #else /* TODO: there is no definitions of RSTRING_* here, so cannot compile. static inline char NUM2CHR(mrb_value x) { return NUM2CHR_internal(x); } */ #define NUM2CHR(x) NUM2CHR_internal(x) #endif mrb_value mrb_io_gets(mrb_state *mrb, mrb_value); mrb_value mrb_io_getbyte(mrb_state *mrb, mrb_value); mrb_value mrb_io_ungetc(mrb_state *, mrb_value, mrb_value); mrb_value mrb_io_ungetbyte(mrb_state *mrb, mrb_value, mrb_value); mrb_value mrb_io_close(mrb_state *mrb, mrb_value); mrb_value mrb_io_flush(mrb_state *mrb, mrb_value); mrb_value mrb_io_eof(mrb_value); mrb_value mrb_io_binmode(mrb_state *mrb, mrb_value); mrb_value mrb_io_ascii8bit_binmode(mrb_value); mrb_value mrb_io_addstr(mrb_state *mrb, mrb_value, mrb_value); mrb_value mrb_io_printf(mrb_state *mrb, int, mrb_value*, mrb_value); mrb_value mrb_io_print(mrb_state *mrb, int, mrb_value*, mrb_value); mrb_value mrb_io_puts(mrb_state *mrb, /*int argc, mrb_value *argv,*/ mrb_value); mrb_value mrb_io_fdopen(int, int, const char*); mrb_value mrb_io_get_io(mrb_state *mrb, mrb_value); mrb_value mrb_file_open(mrb_state *mrb, const char*, const char*); mrb_value mrb_file_open_str(mrb_value, const char*); mrb_value mrb_gets(mrb_state *mrb); mrb_value mrb_yield(mrb_state *mrb, mrb_value v, mrb_value blk); mrb_value mrb_yield_argv(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv); mrb_value mrb_yield_with_self(mrb_state *mrb, mrb_value b, int argc, mrb_value *argv, mrb_value self); mrb_value mrb_class_new_instance(mrb_state *mrb, int, mrb_value*, struct RClass *); mrb_value mrb_class_new_instance_m(mrb_state *mrb, mrb_value klass); mrb_value mrb_exec_recursive(mrb_state *mrb, mrb_value(*)(mrb_state *, mrb_value, mrb_value, int),mrb_value,void *); #ifndef xmalloc #define xmalloc malloc #define xrealloc realloc #define xcalloc calloc #define xfree free #endif void mrb_gc(void); #define thread_debug if(0)printf #define RUBY_VM 1 /* YARV */ #define HAVE_NATIVETHREAD int ruby_native_thread_p(void); #define RUBY_EVENT_NONE 0x0000 #define RUBY_EVENT_LINE 0x0001 #define RUBY_EVENT_CLASS 0x0002 #define RUBY_EVENT_END 0x0004 #define RUBY_EVENT_CALL 0x0008 #define RUBY_EVENT_RETURN 0x0010 #define RUBY_EVENT_C_CALL 0x0020 #define RUBY_EVENT_C_RETURN 0x0040 #define RUBY_EVENT_RAISE 0x0080 #define RUBY_EVENT_ALL 0xffff #define RUBY_EVENT_VM 0x10000 #define RUBY_EVENT_SWITCH 0x20000 #define RUBY_EVENT_COVERAGE 0x40000 typedef unsigned int mrb_event_flag_t; typedef void (*mrb_event_hook_func_t)(mrb_state *mrb, mrb_event_flag_t, mrb_value data, mrb_value, mrb_sym, mrb_value klass); typedef struct mrb_event_hook_struct { mrb_event_flag_t flag; mrb_event_hook_func_t func; mrb_value data; struct mrb_event_hook_struct *next; } mrb_event_hook_t; #define RB_EVENT_HOOKS_HAVE_CALLBACK_DATA 1 void mrb_add_event_hook(mrb_state *mrb, mrb_event_hook_func_t func, mrb_event_flag_t events, mrb_value data); int mrb_remove_event_hook(mrb_event_hook_func_t func); mrb_value mrb_to_int(mrb_state *mrb, mrb_value val); void mrb_check_type(mrb_state *mrb, mrb_value x, enum mrb_vtype t); //#define RUBY_SETJMP(env) ${setjmp_prefix}setjmp(env${setjmp_sigmask+,0}) //#define RUBY_LONGJMP(env,val) ${setjmp_prefix}longjmp(env,val) //#define RUBY_JMP_BUF ${setjmp_sigmask+${setjmp_prefix}}jmp_buf #define RUBY_SETJMP(env) __builtin_setjmp(env) #define RUBY_LONGJMP(env,val) __builtin_longjmp(env,1)//(env,val) //#define RUBY_JMP_BUF ${setjmp_sigmask+${setjmp_prefix}}jmp_buf #define select(n, r, w, e, t) select_large_fdset(n, r, w, e, t) //int RUBY_SETJMP(mrb_jmpbuf_t env); /* add kusuda */ #define ruby_setjmp(env) RUBY_SETJMP(env) #define ruby_longjmp(env,val) RUBY_LONGJMP(env,val) #define KHASH 0 #define STHASH 1 #define BASICHASH 2 #define HASH_CLASS_METHOD BASICHASH typedef enum call_type { CALL_PUBLIC, CALL_FCALL, CALL_VCALL, CALL_TYPE_MAX } call_type; /* compar.c */ void mrb_cmperr(mrb_state *mrb, mrb_value x, mrb_value y); int mrb_cmpint(mrb_state *mrb, mrb_value val, mrb_value a, mrb_value b); #define REALLOC_N(mrb,var,type,n) (var)=(type*)mrb_realloc(mrb, (char*)(var), sizeof(type)*(n)) #ifndef ANYARGS # ifdef __cplusplus # define ANYARGS ... # else # define ANYARGS # endif #endif void mrb_define_alias(mrb_state *mrb, struct RClass *klass, const char *name1, const char *name2); const char *mrb_class_name(mrb_state *mrb, struct RClass* klass); void mrb_define_global_const(mrb_state *mrb, const char *name, mrb_value val); mrb_value mrb_block_proc(void); int mrb_sourceline(void); void ruby_default_signal(int sig); mrb_value mrb_attr_get(mrb_state *mrb, mrb_value obj, mrb_sym id); #endif /* MRUBY_H */