add mruby sources

1 files changed, 623 insertions, 0 deletions

diff --git a/include/mruby.h b/include/mruby.h
new file mode 100644
index 000000000..506158d3c
--- /dev/null
+++ b/include/mruby.h
@@ -0,0 +1,623 @@
+#ifndef MRUBY_H
+#define MRUBY_H
+
+#include <stdlib.h>
+#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 = 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_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"
+
+#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 <ctype.h> 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
+static inline char
+NUM2CHR(mrb_value x)
+{
+    return 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)
+
+#if defined PRIdPTR && !defined PRI_VALUE_PREFIX
+#define PRIdVALUE PRIdPTR
+#define PRIiVALUE PRIiPTR
+#define PRIoVALUE PRIoPTR
+#define PRIuVALUE PRIuPTR
+#define PRIxVALUE PRIxPTR
+#define PRIXVALUE PRIXPTR
+#else
+#define PRIdVALUE PRI_VALUE_PREFIX"d"
+#define PRIiVALUE PRI_VALUE_PREFIX"i"
+#define PRIoVALUE PRI_VALUE_PREFIX"o"
+#define PRIuVALUE PRI_VALUE_PREFIX"u"
+#define PRIxVALUE PRI_VALUE_PREFIX"x"
+#define PRIXVALUE PRI_VALUE_PREFIX"X"
+#endif
+#ifndef PRI_VALUE_PREFIX
+# define PRI_VALUE_PREFIX ""
+#endif
+
+#if defined PRIdPTR
+# define PRI_PTRDIFF_PREFIX "t"
+#elif SIZEOF_PTRDIFF_T == SIZEOF_INT
+# define PRI_PTRDIFF_PREFIX
+#elif SIZEOF_PTRDIFF_T == SIZEOF_LONG
+# define PRI_PTRDIFF_PREFIX "l"
+#elif SIZEOF_PTRDIFF_T == SIZEOF_LONG_LONG
+# define PRI_PTRDIFF_PREFIX "ll"
+#else
+# define PRI_PTRDIFF_PREFIX
+#endif
+#define PRIdPTRDIFF PRI_PTRDIFF_PREFIX"d"
+#define PRIiPTRDIFF PRI_PTRDIFF_PREFIX"i"
+#define PRIoPTRDIFF PRI_PTRDIFF_PREFIX"o"
+#define PRIuPTRDIFF PRI_PTRDIFF_PREFIX"u"
+#define PRIxPTRDIFF PRI_PTRDIFF_PREFIX"x"
+#define PRIXPTRDIFF PRI_PTRDIFF_PREFIX"X"
+
+#if defined PRIdPTR
+# define PRI_SIZE_PREFIX "z"
+#elif SIZEOF_SIZE_T == SIZEOF_INT
+# define PRI_SIZE_PREFIX
+#elif SIZEOF_SIZE_T == SIZEOF_LONG
+# define PRI_SIZE_PREFIX "l"
+#elif SIZEOF_SIZE_T == SIZEOF_LONG_LONG
+# define PRI_SIZE_PREFIX "ll"
+#endif
+#define PRIdSIZE PRI_SIZE_PREFIX"d"
+#define PRIiSIZE PRI_SIZE_PREFIX"i"
+#define PRIoSIZE PRI_SIZE_PREFIX"o"
+#define PRIuSIZE PRI_SIZE_PREFIX"u"
+#define PRIxSIZE PRI_SIZE_PREFIX"x"
+#define PRIXSIZE PRI_SIZE_PREFIX"X"
+#define PRIdPTRDIFF PRI_PTRDIFF_PREFIX"d"
+
+#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 st_foreach_safe(mrb_state *mrb, void *table, int (*func)(ANYARGS), void * a);
+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 */