Imported Upstream version 1.9.3.p194upstream/1.9.3.p194

21 files changed, 5728 insertions, 0 deletions

diff --git a/include/ruby.h b/include/ruby.h
new file mode 100644
index 0000000..862b168
--- /dev/null
+++ b/include/ruby.h
@@ -0,0 +1,34 @@
+/**********************************************************************
+
+  ruby.h -
+
+  $Author$
+  created at: Sun 10 12:06:15 Jun JST 2007
+
+  Copyright (C) 2007-2008 Yukihiro Matsumoto
+
+**********************************************************************/
+
+#ifndef RUBY_H
+#define RUBY_H 1
+
+#define HAVE_RUBY_DEFINES_H     1
+#define HAVE_RUBY_ENCODING_H    1
+#define HAVE_RUBY_INTERN_H      1
+#define HAVE_RUBY_IO_H          1
+#define HAVE_RUBY_MISSING_H     1
+#define HAVE_RUBY_ONIGURUMA_H   1
+#define HAVE_RUBY_RE_H          1
+#define HAVE_RUBY_REGEX_H       1
+#define HAVE_RUBY_RUBY_H        1
+#define HAVE_RUBY_ST_H          1
+#define HAVE_RUBY_UTIL_H        1
+#define HAVE_RUBY_VERSION_H     1
+#define HAVE_RUBY_VM_H          1
+#ifdef _WIN32
+#define HAVE_RUBY_WIN32_H       1
+#endif
+
+#include "ruby/ruby.h"
+
+#endif /* RUBY_H */
diff --git a/include/ruby/backward/classext.h b/include/ruby/backward/classext.h
new file mode 100644
index 0000000..615e6f6
--- /dev/null
+++ b/include/ruby/backward/classext.h
@@ -0,0 +1,18 @@
+#if   defined __GNUC__
+#warning use of RClass internals is deprecated
+#elif defined _MSC_VER || defined __BORLANDC__
+#pragma message("warning: use of RClass internals is deprecated")
+#endif
+
+#ifndef RUBY_BACKWARD_CLASSEXT_H
+#define RUBY_BACKWARD_CLASSEXT_H 1
+
+typedef struct rb_deprecated_classext_struct {
+    VALUE super;
+} rb_deprecated_classext_t;
+
+#undef RCLASS_SUPER(c)
+#define RCLASS_EXT(c) ((rb_deprecated_classext_t *)RCLASS(c)->ptr)
+#define RCLASS_SUPER(c) (RCLASS_EXT(c)->super)
+
+#endif	/* RUBY_BACKWARD_CLASSEXT_H */
diff --git a/include/ruby/backward/rubyio.h b/include/ruby/backward/rubyio.h
new file mode 100644
index 0000000..d5246db
--- /dev/null
+++ b/include/ruby/backward/rubyio.h
@@ -0,0 +1,6 @@
+#if   defined __GNUC__
+#warning use "ruby/io.h" instead of "rubyio.h"
+#elif defined _MSC_VER || defined __BORLANDC__
+#pragma message("warning: use \"ruby/io.h\" instead of \"rubyio.h\"")
+#endif
+#include "ruby/io.h"
diff --git a/include/ruby/backward/rubysig.h b/include/ruby/backward/rubysig.h
new file mode 100644
index 0000000..60a67ec
--- /dev/null
+++ b/include/ruby/backward/rubysig.h
@@ -0,0 +1,48 @@
+/**********************************************************************
+
+  rubysig.h -
+
+  $Author: akr $
+  $Date: 2009-10-02 21:04:37 +0900 (Fri, 02 Oct 2009) $
+  created at: Wed Aug 16 01:15:38 JST 1995
+
+  Copyright (C) 1993-2008 Yukihiro Matsumoto
+
+**********************************************************************/
+
+#if   defined __GNUC__
+#warning rubysig.h is obsolete
+#elif defined _MSC_VER || defined __BORLANDC__
+#pragma message("warning: rubysig.h is obsolete")
+#endif
+
+#ifndef RUBYSIG_H
+#define RUBYSIG_H
+#include "ruby/ruby.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+struct rb_blocking_region_buffer;
+DEPRECATED(RUBY_EXTERN struct rb_blocking_region_buffer *rb_thread_blocking_region_begin(void));
+DEPRECATED(RUBY_EXTERN void rb_thread_blocking_region_end(struct rb_blocking_region_buffer *));
+#define TRAP_BEG do {struct rb_blocking_region_buffer *__region = rb_thread_blocking_region_begin();
+#define TRAP_END rb_thread_blocking_region_end(__region);} while (0)
+#define RUBY_CRITICAL(statements) do {statements;} while (0)
+#define DEFER_INTS (0)
+#define ENABLE_INTS (1)
+#define ALLOW_INTS do {CHECK_INTS;} while (0)
+#define CHECK_INTS rb_thread_check_ints()
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+#endif
diff --git a/include/ruby/backward/st.h b/include/ruby/backward/st.h
new file mode 100644
index 0000000..514128e
--- /dev/null
+++ b/include/ruby/backward/st.h
@@ -0,0 +1,6 @@
+#if   defined __GNUC__
+#warning use "ruby/st.h" instead of bare "st.h"
+#elif defined _MSC_VER || defined __BORLANDC__
+#pragma message("warning: use \"ruby/st.h\" instead of bare \"st.h\"")
+#endif
+#include "ruby/st.h"
diff --git a/include/ruby/backward/util.h b/include/ruby/backward/util.h
new file mode 100644
index 0000000..6b47940
--- /dev/null
+++ b/include/ruby/backward/util.h
@@ -0,0 +1,6 @@
+#if   defined __GNUC__
+#warning use "ruby/util.h" instead of bare "util.h"
+#elif defined _MSC_VER || defined __BORLANDC__
+#pragma message("warning: use \"ruby/util.h\" instead of bare \"util.h\"")
+#endif
+#include "ruby/util.h"
diff --git a/include/ruby/defines.h b/include/ruby/defines.h
new file mode 100644
index 0000000..38510fb
--- /dev/null
+++ b/include/ruby/defines.h
@@ -0,0 +1,334 @@
+/************************************************
+
+  defines.h -
+
+  $Author: kosaki $
+  created at: Wed May 18 00:21:44 JST 1994
+
+************************************************/
+
+#ifndef RUBY_DEFINES_H
+#define RUBY_DEFINES_H 1
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+#include "ruby/config.h"
+#ifdef RUBY_EXTCONF_H
+#include RUBY_EXTCONF_H
+#endif
+
+#define RUBY
+
+# include <stddef.h>
+#ifdef HAVE_STDLIB_H
+# include <stdlib.h>
+#endif
+#ifdef __cplusplus
+# ifndef  HAVE_PROTOTYPES
+#  define HAVE_PROTOTYPES 1
+# endif
+# ifndef  HAVE_STDARG_PROTOTYPES
+#  define HAVE_STDARG_PROTOTYPES 1
+# endif
+#endif
+
+#undef _
+#ifdef HAVE_PROTOTYPES
+# define _(args) args
+#else
+# define _(args) ()
+#endif
+
+#undef __
+#ifdef HAVE_STDARG_PROTOTYPES
+# define __(args) args
+#else
+# define __(args) ()
+#endif
+
+#ifdef __cplusplus
+#define ANYARGS ...
+#else
+#define ANYARGS
+#endif
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility push(default)
+#endif
+
+#define xmalloc ruby_xmalloc
+#define xmalloc2 ruby_xmalloc2
+#define xcalloc ruby_xcalloc
+#define xrealloc ruby_xrealloc
+#define xrealloc2 ruby_xrealloc2
+#define xfree ruby_xfree
+
+void *xmalloc(size_t);
+void *xmalloc2(size_t,size_t);
+void *xcalloc(size_t,size_t);
+void *xrealloc(void*,size_t);
+void *xrealloc2(void*,size_t,size_t);
+void xfree(void*);
+
+#define STRINGIZE(expr) STRINGIZE0(expr)
+#ifndef STRINGIZE0
+#define STRINGIZE0(expr) #expr
+#endif
+
+#if SIZEOF_LONG_LONG > 0
+# define LONG_LONG long long
+#elif SIZEOF___INT64 > 0
+# define HAVE_LONG_LONG 1
+# define LONG_LONG __int64
+# undef SIZEOF_LONG_LONG
+# define SIZEOF_LONG_LONG SIZEOF___INT64
+#endif
+
+#if SIZEOF_INT*2 <= SIZEOF_LONG_LONG
+# define BDIGIT unsigned int
+# define SIZEOF_BDIGITS SIZEOF_INT
+# define BDIGIT_DBL unsigned LONG_LONG
+# define BDIGIT_DBL_SIGNED LONG_LONG
+# define PRI_BDIGIT_PREFIX ""
+# define PRI_BDIGIT_DBL_PREFIX PRI_LL_PREFIX
+#elif SIZEOF_INT*2 <= SIZEOF_LONG
+# define BDIGIT unsigned int
+# define SIZEOF_BDIGITS SIZEOF_INT
+# define BDIGIT_DBL unsigned long
+# define BDIGIT_DBL_SIGNED long
+# define PRI_BDIGIT_PREFIX ""
+# define PRI_BDIGIT_DBL_PREFIX "l"
+#elif SIZEOF_SHORT*2 <= SIZEOF_LONG
+# define BDIGIT unsigned short
+# define SIZEOF_BDIGITS SIZEOF_SHORT
+# define BDIGIT_DBL unsigned long
+# define BDIGIT_DBL_SIGNED long
+# define PRI_BDIGIT_PREFIX "h"
+# define PRI_BDIGIT_DBL_PREFIX "l"
+#else
+# define BDIGIT unsigned short
+# define SIZEOF_BDIGITS (SIZEOF_LONG/2)
+# define BDIGIT_DBL unsigned long
+# define BDIGIT_DBL_SIGNED long
+# define PRI_BDIGIT_PREFIX "h"
+# define PRI_BDIGIT_DBL_PREFIX "l"
+#endif
+
+#define PRIdBDIGIT PRI_BDIGIT_PREFIX"d"
+#define PRIiBDIGIT PRI_BDIGIT_PREFIX"i"
+#define PRIoBDIGIT PRI_BDIGIT_PREFIX"o"
+#define PRIuBDIGIT PRI_BDIGIT_PREFIX"u"
+#define PRIxBDIGIT PRI_BDIGIT_PREFIX"x"
+#define PRIXBDIGIT PRI_BDIGIT_PREFIX"X"
+
+#define PRIdBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"d"
+#define PRIiBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"i"
+#define PRIoBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"o"
+#define PRIuBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"u"
+#define PRIxBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"x"
+#define PRIXBDIGIT_DBL PRI_BDIGIT_DBL_PREFIX"X"
+
+#ifdef __CYGWIN__
+#undef _WIN32
+#endif
+
+#if defined(_WIN32) || defined(__EMX__)
+#define DOSISH 1
+# define DOSISH_DRIVE_LETTER
+#endif
+
+#ifdef AC_APPLE_UNIVERSAL_BUILD
+#undef WORDS_BIGENDIAN
+#ifdef __BIG_ENDIAN__
+#define WORDS_BIGENDIAN
+#endif
+#endif
+
+#ifdef __NeXT__
+/* NextStep, OpenStep, Rhapsody */
+#ifndef S_IRUSR
+#define S_IRUSR 0000400        /* read permission, owner */
+#endif
+#ifndef S_IRGRP
+#define S_IRGRP 0000040        /* read permission, group */
+#endif
+#ifndef S_IROTH
+#define S_IROTH 0000004        /* read permission, other */
+#endif
+#ifndef S_IWUSR
+#define S_IWUSR 0000200        /* write permission, owner */
+#endif
+#ifndef S_IWGRP
+#define S_IWGRP 0000020        /* write permission, group */
+#endif
+#ifndef S_IWOTH
+#define S_IWOTH 0000002        /* write permission, other */
+#endif
+#ifndef S_IXUSR
+#define S_IXUSR 0000100        /* execute/search permission, owner */
+#endif
+#ifndef S_IXGRP
+#define S_IXGRP 0000010        /* execute/search permission, group */
+#endif
+#ifndef S_IXOTH
+#define S_IXOTH 0000001        /* execute/search permission, other */
+#endif
+#ifndef S_IRWXU
+#define S_IRWXU 0000700        /* read, write, execute permissions, owner */
+#endif
+#ifndef S_IRWXG
+#define S_IRWXG 0000070        /* read, write, execute permissions, group */
+#endif
+#ifndef S_IRWXO
+#define S_IRWXO 0000007        /* read, write, execute permissions, other */
+#endif
+#ifndef S_ISBLK
+#define S_ISBLK(mode)  (((mode) & (0170000)) == (0060000))
+#endif
+#ifndef S_ISCHR
+#define S_ISCHR(mode)  (((mode) & (0170000)) == (0020000))
+#endif
+#ifndef S_ISDIR
+#define S_ISDIR(mode)  (((mode) & (0170000)) == (0040000))
+#endif
+#ifndef S_ISFIFO
+#define S_ISFIFO(mode) (((mode) & (0170000)) == (0010000))
+#endif
+#ifndef S_ISREG
+#define S_ISREG(mode)  (((mode) & (0170000)) == (0100000))
+#endif
+#ifndef __APPLE__
+/* NextStep, OpenStep (but not Rhapsody) */
+#ifndef GETPGRP_VOID
+#define GETPGRP_VOID 1
+#endif
+#ifndef WNOHANG
+#define WNOHANG 01
+#endif
+#ifndef WUNTRACED
+#define WUNTRACED 02
+#endif
+#ifndef X_OK
+#define X_OK 1
+#endif
+#endif /* __APPLE__ */
+#endif /* NeXT */
+
+#ifdef _WIN32
+#include "ruby/win32.h"
+#endif
+
+#if defined(__BEOS__) && !defined(__HAIKU__) && !defined(BONE)
+#include <net/socket.h> /* intern.h needs fd_set definition */
+#elif defined (__SYMBIAN32__) && defined (HAVE_SYS_SELECT_H)
+# include <sys/select.h>
+#endif
+
+#ifdef __SYMBIAN32__
+# define FALSE 0
+# define TRUE 1
+#endif
+
+#ifdef RUBY_EXPORT
+#undef RUBY_EXTERN
+
+#ifndef FALSE
+# define FALSE 0
+#elif FALSE
+# error FALSE must be false
+#endif
+#ifndef TRUE
+# define TRUE 1
+#elif !TRUE
+# error TRUE must be true
+#endif
+
+#endif
+
+#ifndef RUBY_FUNC_EXPORTED
+#define RUBY_FUNC_EXPORTED
+#endif
+
+#ifndef RUBY_EXTERN
+#define RUBY_EXTERN extern
+#endif
+
+#ifndef EXTERN
+#define EXTERN RUBY_EXTERN	/* deprecated */
+#endif
+
+#ifndef RUBY_MBCHAR_MAXSIZE
+#define RUBY_MBCHAR_MAXSIZE INT_MAX
+        /* MB_CUR_MAX will not work well in C locale */
+#endif
+
+#if defined(sparc) || defined(__sparc__)
+void rb_sparc_flush_register_windows(void);
+#  define FLUSH_REGISTER_WINDOWS rb_sparc_flush_register_windows()
+#elif defined(__ia64)
+void *rb_ia64_bsp(void);
+void rb_ia64_flushrs(void);
+#  define FLUSH_REGISTER_WINDOWS rb_ia64_flushrs()
+#else
+#  define FLUSH_REGISTER_WINDOWS ((void)0)
+#endif
+
+#if defined(DOSISH)
+#define PATH_SEP ";"
+#else
+#define PATH_SEP ":"
+#endif
+#define PATH_SEP_CHAR PATH_SEP[0]
+
+#define PATH_ENV "PATH"
+
+#if defined(DOSISH) && !defined(__EMX__)
+#define ENV_IGNORECASE
+#endif
+
+#ifndef CASEFOLD_FILESYSTEM
+# if defined DOSISH
+#   define CASEFOLD_FILESYSTEM 1
+# else
+#   define CASEFOLD_FILESYSTEM 0
+# endif
+#endif
+
+#ifndef DLEXT_MAXLEN
+#define DLEXT_MAXLEN 4
+#endif
+
+#ifndef RUBY_PLATFORM
+#define RUBY_PLATFORM "unknown-unknown"
+#endif
+
+#ifndef RUBY_ALIAS_FUNCTION_TYPE
+#define RUBY_ALIAS_FUNCTION_TYPE(type, prot, name, args) \
+    type prot {return name args;}
+#endif
+#ifndef RUBY_ALIAS_FUNCTION_VOID
+#define RUBY_ALIAS_FUNCTION_VOID(prot, name, args) \
+    void prot {name args;}
+#endif
+#ifndef RUBY_ALIAS_FUNCTION
+#define RUBY_ALIAS_FUNCTION(prot, name, args) \
+    RUBY_ALIAS_FUNCTION_TYPE(VALUE, prot, name, args)
+#endif
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility pop
+#endif
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+#endif /* RUBY_DEFINES_H */
diff --git a/include/ruby/encoding.h b/include/ruby/encoding.h
new file mode 100644
index 0000000..058462f
--- /dev/null
+++ b/include/ruby/encoding.h
@@ -0,0 +1,344 @@
+/**********************************************************************
+
+  encoding.h -
+
+  $Author: matz $
+  created at: Thu May 24 11:49:41 JST 2007
+
+  Copyright (C) 2007 Yukihiro Matsumoto
+
+**********************************************************************/
+
+#ifndef RUBY_ENCODING_H
+#define RUBY_ENCODING_H 1
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+#include <stdarg.h>
+#include "ruby/oniguruma.h"
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility push(default)
+#endif
+
+#define ENCODING_INLINE_MAX 1023
+#define ENCODING_SHIFT (FL_USHIFT+10)
+#define ENCODING_MASK (((VALUE)ENCODING_INLINE_MAX)<<ENCODING_SHIFT)
+
+#define ENCODING_SET_INLINED(obj,i) do {\
+    RBASIC(obj)->flags &= ~ENCODING_MASK;\
+    RBASIC(obj)->flags |= (VALUE)(i) << ENCODING_SHIFT;\
+} while (0)
+#define ENCODING_SET(obj,i) do {\
+    VALUE rb_encoding_set_obj = (obj); \
+    int encoding_set_enc_index = (i); \
+    if (encoding_set_enc_index < ENCODING_INLINE_MAX) \
+        ENCODING_SET_INLINED(rb_encoding_set_obj, encoding_set_enc_index); \
+    else \
+        rb_enc_set_index(rb_encoding_set_obj, encoding_set_enc_index); \
+} while (0)
+
+#define ENCODING_GET_INLINED(obj) (int)((RBASIC(obj)->flags & ENCODING_MASK)>>ENCODING_SHIFT)
+#define ENCODING_GET(obj) \
+    (ENCODING_GET_INLINED(obj) != ENCODING_INLINE_MAX ? \
+     ENCODING_GET_INLINED(obj) : \
+     rb_enc_get_index(obj))
+
+#define ENCODING_IS_ASCII8BIT(obj) (ENCODING_GET_INLINED(obj) == 0)
+
+#define ENCODING_MAXNAMELEN 42
+
+#define ENC_CODERANGE_MASK	((int)(FL_USER8|FL_USER9))
+#define ENC_CODERANGE_UNKNOWN	0
+#define ENC_CODERANGE_7BIT	((int)FL_USER8)
+#define ENC_CODERANGE_VALID	((int)FL_USER9)
+#define ENC_CODERANGE_BROKEN	((int)(FL_USER8|FL_USER9))
+#define ENC_CODERANGE(obj) ((int)RBASIC(obj)->flags & ENC_CODERANGE_MASK)
+#define ENC_CODERANGE_ASCIIONLY(obj) (ENC_CODERANGE(obj) == ENC_CODERANGE_7BIT)
+#define ENC_CODERANGE_SET(obj,cr) (RBASIC(obj)->flags = \
+				   (RBASIC(obj)->flags & ~ENC_CODERANGE_MASK) | (cr))
+#define ENC_CODERANGE_CLEAR(obj) ENC_CODERANGE_SET((obj),0)
+
+/* assumed ASCII compatibility */
+#define ENC_CODERANGE_AND(a, b) \
+    ((a) == ENC_CODERANGE_7BIT ? (b) : \
+     (a) == ENC_CODERANGE_VALID ? ((b) == ENC_CODERANGE_7BIT ? ENC_CODERANGE_VALID : (b)) : \
+     ENC_CODERANGE_UNKNOWN)
+
+#define ENCODING_CODERANGE_SET(obj, encindex, cr) \
+    do { \
+        VALUE rb_encoding_coderange_obj = (obj); \
+        ENCODING_SET(rb_encoding_coderange_obj, (encindex)); \
+        ENC_CODERANGE_SET(rb_encoding_coderange_obj, (cr)); \
+    } while (0)
+
+typedef OnigEncodingType rb_encoding;
+
+int rb_char_to_option_kcode(int c, int *option, int *kcode);
+
+int rb_enc_replicate(const char *, rb_encoding *);
+int rb_define_dummy_encoding(const char *);
+#define rb_enc_to_index(enc) ((enc) ? ENC_TO_ENCINDEX(enc) : 0)
+int rb_enc_get_index(VALUE obj);
+void rb_enc_set_index(VALUE obj, int encindex);
+int rb_enc_find_index(const char *name);
+int rb_to_encoding_index(VALUE);
+rb_encoding* rb_to_encoding(VALUE);
+rb_encoding* rb_enc_get(VALUE);
+rb_encoding* rb_enc_compatible(VALUE,VALUE);
+rb_encoding* rb_enc_check(VALUE,VALUE);
+VALUE rb_enc_associate_index(VALUE, int);
+VALUE rb_enc_associate(VALUE, rb_encoding*);
+void rb_enc_copy(VALUE dst, VALUE src);
+
+VALUE rb_enc_str_new(const char*, long, rb_encoding*);
+VALUE rb_enc_reg_new(const char*, long, rb_encoding*, int);
+PRINTF_ARGS(VALUE rb_enc_sprintf(rb_encoding *, const char*, ...), 2, 3);
+VALUE rb_enc_vsprintf(rb_encoding *, const char*, va_list);
+long rb_enc_strlen(const char*, const char*, rb_encoding*);
+char* rb_enc_nth(const char*, const char*, long, rb_encoding*);
+VALUE rb_obj_encoding(VALUE);
+VALUE rb_enc_str_buf_cat(VALUE str, const char *ptr, long len, rb_encoding *enc);
+VALUE rb_enc_uint_chr(unsigned int code, rb_encoding *enc);
+
+VALUE rb_external_str_new_with_enc(const char *ptr, long len, rb_encoding *);
+VALUE rb_str_export_to_enc(VALUE, rb_encoding *);
+VALUE rb_str_conv_enc(VALUE str, rb_encoding *from, rb_encoding *to);
+VALUE rb_str_conv_enc_opts(VALUE str, rb_encoding *from, rb_encoding *to, int ecflags, VALUE ecopts);
+
+/* index -> rb_encoding */
+rb_encoding* rb_enc_from_index(int idx);
+
+/* name -> rb_encoding */
+rb_encoding * rb_enc_find(const char *name);
+
+/* rb_encoding * -> name */
+#define rb_enc_name(enc) (enc)->name
+
+/* rb_encoding * -> minlen/maxlen */
+#define rb_enc_mbminlen(enc) (enc)->min_enc_len
+#define rb_enc_mbmaxlen(enc) (enc)->max_enc_len
+
+/* -> mbclen (no error notification: 0 < ret <= e-p, no exception) */
+int rb_enc_mbclen(const char *p, const char *e, rb_encoding *enc);
+
+/* -> mbclen (only for valid encoding) */
+int rb_enc_fast_mbclen(const char *p, const char *e, rb_encoding *enc);
+
+/* -> chlen, invalid or needmore */
+int rb_enc_precise_mbclen(const char *p, const char *e, rb_encoding *enc);
+#define MBCLEN_CHARFOUND_P(ret)     ONIGENC_MBCLEN_CHARFOUND_P(ret)
+#define MBCLEN_CHARFOUND_LEN(ret)     ONIGENC_MBCLEN_CHARFOUND_LEN(ret)
+#define MBCLEN_INVALID_P(ret)       ONIGENC_MBCLEN_INVALID_P(ret)
+#define MBCLEN_NEEDMORE_P(ret)      ONIGENC_MBCLEN_NEEDMORE_P(ret)
+#define MBCLEN_NEEDMORE_LEN(ret)      ONIGENC_MBCLEN_NEEDMORE_LEN(ret)
+
+/* -> 0x00..0x7f, -1 */
+int rb_enc_ascget(const char *p, const char *e, int *len, rb_encoding *enc);
+
+
+/* -> code (and len) or raise exception */
+unsigned int rb_enc_codepoint_len(const char *p, const char *e, int *len, rb_encoding *enc);
+
+/* prototype for obsolete function */
+unsigned int rb_enc_codepoint(const char *p, const char *e, rb_encoding *enc);
+/* overriding macro */
+#define rb_enc_codepoint(p,e,enc) rb_enc_codepoint_len((p),(e),0,(enc))
+#define rb_enc_mbc_to_codepoint(p, e, enc) ONIGENC_MBC_TO_CODE((enc),(UChar*)(p),(UChar*)(e))
+
+/* -> codelen>0 or raise exception */
+int rb_enc_codelen(int code, rb_encoding *enc);
+
+/* code,ptr,encoding -> write buf */
+#define rb_enc_mbcput(c,buf,enc) ONIGENC_CODE_TO_MBC((enc),(c),(UChar*)(buf))
+
+/* start, ptr, end, encoding -> prev_char */
+#define rb_enc_prev_char(s,p,e,enc) ((char *)onigenc_get_prev_char_head((enc),(UChar*)(s),(UChar*)(p),(UChar*)(e)))
+/* start, ptr, end, encoding -> next_char */
+#define rb_enc_left_char_head(s,p,e,enc) ((char *)onigenc_get_left_adjust_char_head((enc),(UChar*)(s),(UChar*)(p),(UChar*)(e)))
+#define rb_enc_right_char_head(s,p,e,enc) ((char *)onigenc_get_right_adjust_char_head((enc),(UChar*)(s),(UChar*)(p),(UChar*)(e)))
+#define rb_enc_step_back(s,p,e,n,enc) ((char *)onigenc_step_back((enc),(UChar*)(s),(UChar*)(p),(UChar*)(e),(int)(n)))
+
+/* ptr, ptr, encoding -> newline_or_not */
+#define rb_enc_is_newline(p,end,enc)  ONIGENC_IS_MBC_NEWLINE((enc),(UChar*)(p),(UChar*)(end))
+
+#define rb_enc_isctype(c,t,enc) ONIGENC_IS_CODE_CTYPE((enc),(c),(t))
+#define rb_enc_isascii(c,enc) ONIGENC_IS_CODE_ASCII(c)
+#define rb_enc_isalpha(c,enc) ONIGENC_IS_CODE_ALPHA((enc),(c))
+#define rb_enc_islower(c,enc) ONIGENC_IS_CODE_LOWER((enc),(c))
+#define rb_enc_isupper(c,enc) ONIGENC_IS_CODE_UPPER((enc),(c))
+#define rb_enc_ispunct(c,enc) ONIGENC_IS_CODE_PUNCT((enc),(c))
+#define rb_enc_isalnum(c,enc) ONIGENC_IS_CODE_ALNUM((enc),(c))
+#define rb_enc_isprint(c,enc) ONIGENC_IS_CODE_PRINT((enc),(c))
+#define rb_enc_isspace(c,enc) ONIGENC_IS_CODE_SPACE((enc),(c))
+#define rb_enc_isdigit(c,enc) ONIGENC_IS_CODE_DIGIT((enc),(c))
+
+#define rb_enc_asciicompat(enc) (rb_enc_mbminlen(enc)==1 && !rb_enc_dummy_p(enc))
+
+int rb_enc_casefold(char *to, const char *p, const char *e, rb_encoding *enc);
+int rb_enc_toupper(int c, rb_encoding *enc);
+int rb_enc_tolower(int c, rb_encoding *enc);
+ID rb_intern3(const char*, long, rb_encoding*);
+ID rb_interned_id_p(const char *, long, rb_encoding *);
+int rb_enc_symname_p(const char*, rb_encoding*);
+int rb_enc_symname2_p(const char*, long, rb_encoding*);
+int rb_enc_str_coderange(VALUE);
+long rb_str_coderange_scan_restartable(const char*, const char*, rb_encoding*, int*);
+int rb_enc_str_asciionly_p(VALUE);
+#define rb_enc_str_asciicompat_p(str) rb_enc_asciicompat(rb_enc_get(str))
+VALUE rb_enc_from_encoding(rb_encoding *enc);
+int rb_enc_unicode_p(rb_encoding *enc);
+rb_encoding *rb_ascii8bit_encoding(void);
+rb_encoding *rb_utf8_encoding(void);
+rb_encoding *rb_usascii_encoding(void);
+rb_encoding *rb_locale_encoding(void);
+rb_encoding *rb_filesystem_encoding(void);
+rb_encoding *rb_default_external_encoding(void);
+rb_encoding *rb_default_internal_encoding(void);
+int rb_ascii8bit_encindex(void);
+int rb_utf8_encindex(void);
+int rb_usascii_encindex(void);
+int rb_locale_encindex(void);
+int rb_filesystem_encindex(void);
+VALUE rb_enc_default_external(void);
+VALUE rb_enc_default_internal(void);
+void rb_enc_set_default_external(VALUE encoding);
+void rb_enc_set_default_internal(VALUE encoding);
+VALUE rb_locale_charmap(VALUE klass);
+long rb_memsearch(const void*,long,const void*,long,rb_encoding*);
+
+RUBY_EXTERN VALUE rb_cEncoding;
+#define ENC_DUMMY_FLAG (1<<24)
+#define ENC_INDEX_MASK (~(~0U<<24))
+
+#define ENC_TO_ENCINDEX(enc) (int)((enc)->ruby_encoding_index & ENC_INDEX_MASK)
+
+#define ENC_DUMMY_P(enc) ((enc)->ruby_encoding_index & ENC_DUMMY_FLAG)
+#define ENC_SET_DUMMY(enc) ((enc)->ruby_encoding_index |= ENC_DUMMY_FLAG)
+
+static inline int
+rb_enc_dummy_p(rb_encoding *enc)
+{
+    return ENC_DUMMY_P(enc) != 0;
+}
+
+/* econv stuff */
+
+typedef enum {
+    econv_invalid_byte_sequence,
+    econv_undefined_conversion,
+    econv_destination_buffer_full,
+    econv_source_buffer_empty,
+    econv_finished,
+    econv_after_output,
+    econv_incomplete_input
+} rb_econv_result_t;
+
+typedef struct rb_econv_t rb_econv_t;
+
+VALUE rb_str_encode(VALUE str, VALUE to, int ecflags, VALUE ecopts);
+int rb_econv_has_convpath_p(const char* from_encoding, const char* to_encoding);
+
+int rb_econv_prepare_options(VALUE opthash, VALUE *ecopts, int ecflags);
+int rb_econv_prepare_opts(VALUE opthash, VALUE *ecopts);
+
+rb_econv_t *rb_econv_open(const char *source_encoding, const char *destination_encoding, int ecflags);
+rb_econv_t *rb_econv_open_opts(const char *source_encoding, const char *destination_encoding, int ecflags, VALUE ecopts);
+
+rb_econv_result_t rb_econv_convert(rb_econv_t *ec,
+    const unsigned char **source_buffer_ptr, const unsigned char *source_buffer_end,
+    unsigned char **destination_buffer_ptr, unsigned char *destination_buffer_end,
+    int flags);
+void rb_econv_close(rb_econv_t *ec);
+
+/* result: 0:success -1:failure */
+int rb_econv_set_replacement(rb_econv_t *ec, const unsigned char *str, size_t len, const char *encname);
+
+/* result: 0:success -1:failure */
+int rb_econv_decorate_at_first(rb_econv_t *ec, const char *decorator_name);
+int rb_econv_decorate_at_last(rb_econv_t *ec, const char *decorator_name);
+
+VALUE rb_econv_open_exc(const char *senc, const char *denc, int ecflags);
+
+/* result: 0:success -1:failure */
+int rb_econv_insert_output(rb_econv_t *ec,
+    const unsigned char *str, size_t len, const char *str_encoding);
+
+/* encoding that rb_econv_insert_output doesn't need conversion */
+const char *rb_econv_encoding_to_insert_output(rb_econv_t *ec);
+
+/* raise an error if the last rb_econv_convert is error */
+void rb_econv_check_error(rb_econv_t *ec);
+
+/* returns an exception object or nil */
+VALUE rb_econv_make_exception(rb_econv_t *ec);
+
+int rb_econv_putbackable(rb_econv_t *ec);
+void rb_econv_putback(rb_econv_t *ec, unsigned char *p, int n);
+
+/* returns the corresponding ASCII compatible encoding for encname,
+ * or NULL if encname is not ASCII incompatible encoding. */
+const char *rb_econv_asciicompat_encoding(const char *encname);
+
+VALUE rb_econv_str_convert(rb_econv_t *ec, VALUE src, int flags);
+VALUE rb_econv_substr_convert(rb_econv_t *ec, VALUE src, long byteoff, long bytesize, int flags);
+VALUE rb_econv_str_append(rb_econv_t *ec, VALUE src, VALUE dst, int flags);
+VALUE rb_econv_substr_append(rb_econv_t *ec, VALUE src, long byteoff, long bytesize, VALUE dst, int flags);
+
+void rb_econv_binmode(rb_econv_t *ec);
+
+/* flags for rb_econv_open */
+
+#define ECONV_ERROR_HANDLER_MASK                0x000000ff
+
+#define ECONV_INVALID_MASK                      0x0000000f
+#define ECONV_INVALID_REPLACE                   0x00000002
+
+#define ECONV_UNDEF_MASK                        0x000000f0
+#define ECONV_UNDEF_REPLACE                     0x00000020
+#define ECONV_UNDEF_HEX_CHARREF                 0x00000030
+
+#define ECONV_DECORATOR_MASK                    0x0000ff00
+#define ECONV_NEWLINE_DECORATOR_MASK            0x00003f00
+#define ECONV_NEWLINE_DECORATOR_READ_MASK       0x00000f00
+#define ECONV_NEWLINE_DECORATOR_WRITE_MASK      0x00003000
+
+#define ECONV_UNIVERSAL_NEWLINE_DECORATOR       0x00000100
+#define ECONV_CRLF_NEWLINE_DECORATOR            0x00001000
+#define ECONV_CR_NEWLINE_DECORATOR              0x00002000
+#define ECONV_XML_TEXT_DECORATOR                0x00004000
+#define ECONV_XML_ATTR_CONTENT_DECORATOR        0x00008000
+
+#define ECONV_STATEFUL_DECORATOR_MASK           0x00f00000
+#define ECONV_XML_ATTR_QUOTE_DECORATOR          0x00100000
+
+#if defined(RUBY_TEST_CRLF_ENVIRONMENT) || defined(_WIN32)
+#define ECONV_DEFAULT_NEWLINE_DECORATOR ECONV_CRLF_NEWLINE_DECORATOR
+#else
+#define ECONV_DEFAULT_NEWLINE_DECORATOR 0
+#endif
+
+/* end of flags for rb_econv_open */
+
+/* flags for rb_econv_convert */
+#define ECONV_PARTIAL_INPUT                     0x00010000
+#define ECONV_AFTER_OUTPUT                      0x00020000
+/* end of flags for rb_econv_convert */
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility pop
+#endif
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+#endif /* RUBY_ENCODING_H */
diff --git a/include/ruby/intern.h b/include/ruby/intern.h
new file mode 100644
index 0000000..fffd108
--- /dev/null
+++ b/include/ruby/intern.h
@@ -0,0 +1,912 @@
+/**********************************************************************
+
+  intern.h -
+
+  $Author: nobu $
+  created at: Thu Jun 10 14:22:17 JST 1993
+
+  Copyright (C) 1993-2007 Yukihiro Matsumoto
+  Copyright (C) 2000  Network Applied Communication Laboratory, Inc.
+  Copyright (C) 2000  Information-technology Promotion Agency, Japan
+
+**********************************************************************/
+
+#ifndef RUBY_INTERN_H
+#define RUBY_INTERN_H 1
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+#include "ruby/defines.h"
+#ifdef RUBY_EXTCONF_H
+#include RUBY_EXTCONF_H
+#endif
+
+#ifdef HAVE_STDARG_PROTOTYPES
+# include <stdarg.h>
+#else
+# include <varargs.h>
+#endif
+#include "ruby/st.h"
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility push(default)
+#endif
+
+/*
+ * Functions and variables that are used by more than one source file of
+ * the kernel.
+ */
+
+#define ID_ALLOCATOR 1
+
+/* array.c */
+void rb_mem_clear(register VALUE*, register long);
+VALUE rb_assoc_new(VALUE, VALUE);
+VALUE rb_check_array_type(VALUE);
+VALUE rb_ary_new(void);
+VALUE rb_ary_new2(long);
+VALUE rb_ary_new3(long,...);
+VALUE rb_ary_new4(long, const VALUE *);
+VALUE rb_ary_tmp_new(long);
+void rb_ary_free(VALUE);
+void rb_ary_modify(VALUE);
+VALUE rb_ary_freeze(VALUE);
+VALUE rb_ary_aref(int, VALUE*, VALUE);
+VALUE rb_ary_subseq(VALUE, long, long);
+void rb_ary_store(VALUE, long, VALUE);
+VALUE rb_ary_dup(VALUE);
+VALUE rb_ary_resurrect(VALUE ary);
+VALUE rb_ary_to_ary(VALUE);
+VALUE rb_ary_to_s(VALUE);
+VALUE rb_ary_push(VALUE, VALUE);
+VALUE rb_ary_pop(VALUE);
+VALUE rb_ary_shift(VALUE);
+VALUE rb_ary_unshift(VALUE, VALUE);
+VALUE rb_ary_entry(VALUE, long);
+VALUE rb_ary_each(VALUE);
+VALUE rb_ary_join(VALUE, VALUE);
+VALUE rb_ary_reverse(VALUE);
+VALUE rb_ary_sort(VALUE);
+VALUE rb_ary_sort_bang(VALUE);
+VALUE rb_ary_delete(VALUE, VALUE);
+VALUE rb_ary_delete_at(VALUE, long);
+VALUE rb_ary_clear(VALUE);
+VALUE rb_ary_plus(VALUE, VALUE);
+VALUE rb_ary_concat(VALUE, VALUE);
+VALUE rb_ary_assoc(VALUE, VALUE);
+VALUE rb_ary_rassoc(VALUE, VALUE);
+VALUE rb_ary_includes(VALUE, VALUE);
+VALUE rb_ary_cmp(VALUE, VALUE);
+VALUE rb_ary_replace(VALUE copy, VALUE orig);
+VALUE rb_get_values_at(VALUE, long, int, VALUE*, VALUE(*)(VALUE,long));
+VALUE rb_ary_resize(VALUE ary, long len);
+/* bignum.c */
+VALUE rb_big_new(long, int);
+int rb_bigzero_p(VALUE x);
+VALUE rb_big_clone(VALUE);
+void rb_big_2comp(VALUE);
+VALUE rb_big_norm(VALUE);
+void rb_big_resize(VALUE big, long len);
+VALUE rb_uint2big(VALUE);
+VALUE rb_int2big(SIGNED_VALUE);
+VALUE rb_uint2inum(VALUE);
+VALUE rb_int2inum(SIGNED_VALUE);
+VALUE rb_cstr_to_inum(const char*, int, int);
+VALUE rb_str_to_inum(VALUE, int, int);
+VALUE rb_cstr2inum(const char*, int);
+VALUE rb_str2inum(VALUE, int);
+VALUE rb_big2str(VALUE, int);
+VALUE rb_big2str0(VALUE, int, int);
+SIGNED_VALUE rb_big2long(VALUE);
+#define rb_big2int(x) rb_big2long(x)
+VALUE rb_big2ulong(VALUE);
+#define rb_big2uint(x) rb_big2ulong(x)
+VALUE rb_big2ulong_pack(VALUE x);
+#if HAVE_LONG_LONG
+VALUE rb_ll2inum(LONG_LONG);
+VALUE rb_ull2inum(unsigned LONG_LONG);
+LONG_LONG rb_big2ll(VALUE);
+unsigned LONG_LONG rb_big2ull(VALUE);
+#endif  /* HAVE_LONG_LONG */
+DEPRECATED(void rb_quad_pack(char*,VALUE));
+DEPRECATED(VALUE rb_quad_unpack(const char*,int));
+void rb_big_pack(VALUE val, unsigned long *buf, long num_longs);
+VALUE rb_big_unpack(unsigned long *buf, long num_longs);
+int rb_uv_to_utf8(char[6],unsigned long);
+VALUE rb_dbl2big(double);
+double rb_big2dbl(VALUE);
+VALUE rb_big_cmp(VALUE, VALUE);
+VALUE rb_big_eq(VALUE, VALUE);
+VALUE rb_big_plus(VALUE, VALUE);
+VALUE rb_big_minus(VALUE, VALUE);
+VALUE rb_big_mul(VALUE, VALUE);
+VALUE rb_big_div(VALUE, VALUE);
+VALUE rb_big_idiv(VALUE, VALUE);
+VALUE rb_big_modulo(VALUE, VALUE);
+VALUE rb_big_divmod(VALUE, VALUE);
+VALUE rb_big_pow(VALUE, VALUE);
+VALUE rb_big_and(VALUE, VALUE);
+VALUE rb_big_or(VALUE, VALUE);
+VALUE rb_big_xor(VALUE, VALUE);
+VALUE rb_big_lshift(VALUE, VALUE);
+VALUE rb_big_rshift(VALUE, VALUE);
+/* rational.c */
+VALUE rb_rational_raw(VALUE, VALUE);
+#define rb_rational_raw1(x) rb_rational_raw((x), INT2FIX(1))
+#define rb_rational_raw2(x,y) rb_rational_raw((x), (y))
+VALUE rb_rational_new(VALUE, VALUE);
+#define rb_rational_new1(x) rb_rational_new((x), INT2FIX(1))
+#define rb_rational_new2(x,y) rb_rational_new((x), (y))
+VALUE rb_Rational(VALUE, VALUE);
+#define rb_Rational1(x) rb_Rational((x), INT2FIX(1))
+#define rb_Rational2(x,y) rb_Rational((x), (y))
+/* complex.c */
+VALUE rb_complex_raw(VALUE, VALUE);
+#define rb_complex_raw1(x) rb_complex_raw((x), INT2FIX(0))
+#define rb_complex_raw2(x,y) rb_complex_raw((x), (y))
+VALUE rb_complex_new(VALUE, VALUE);
+#define rb_complex_new1(x) rb_complex_new((x), INT2FIX(0))
+#define rb_complex_new2(x,y) rb_complex_new((x), (y))
+VALUE rb_complex_polar(VALUE, VALUE);
+VALUE rb_Complex(VALUE, VALUE);
+#define rb_Complex1(x) rb_Complex((x), INT2FIX(0))
+#define rb_Complex2(x,y) rb_Complex((x), (y))
+/* class.c */
+VALUE rb_class_boot(VALUE);
+VALUE rb_class_new(VALUE);
+VALUE rb_mod_init_copy(VALUE, VALUE);
+VALUE rb_class_init_copy(VALUE, VALUE);
+VALUE rb_singleton_class_clone(VALUE);
+void rb_singleton_class_attached(VALUE,VALUE);
+VALUE rb_make_metaclass(VALUE, VALUE);
+void rb_check_inheritable(VALUE);
+VALUE rb_class_inherited(VALUE, VALUE);
+VALUE rb_define_class_id(ID, VALUE);
+VALUE rb_define_class_id_under(VALUE, ID, VALUE);
+VALUE rb_module_new(void);
+VALUE rb_define_module_id(ID);
+VALUE rb_define_module_id_under(VALUE, ID);
+VALUE rb_mod_included_modules(VALUE);
+VALUE rb_mod_include_p(VALUE, VALUE);
+VALUE rb_mod_ancestors(VALUE);
+VALUE rb_class_instance_methods(int, VALUE*, VALUE);
+VALUE rb_class_public_instance_methods(int, VALUE*, VALUE);
+VALUE rb_class_protected_instance_methods(int, VALUE*, VALUE);
+VALUE rb_class_private_instance_methods(int, VALUE*, VALUE);
+VALUE rb_obj_singleton_methods(int, VALUE*, VALUE);
+void rb_define_method_id(VALUE, ID, VALUE (*)(ANYARGS), int);
+void rb_frozen_class_p(VALUE);
+void rb_undef(VALUE, ID);
+void rb_define_protected_method(VALUE, const char*, VALUE (*)(ANYARGS), int);
+void rb_define_private_method(VALUE, const char*, VALUE (*)(ANYARGS), int);
+void rb_define_singleton_method(VALUE, const char*, VALUE(*)(ANYARGS), int);
+VALUE rb_singleton_class(VALUE);
+/* compar.c */
+int rb_cmpint(VALUE, VALUE, VALUE);
+NORETURN(void rb_cmperr(VALUE, VALUE));
+/* cont.c */
+VALUE rb_fiber_new(VALUE (*)(ANYARGS), VALUE);
+VALUE rb_fiber_resume(VALUE fib, int argc, VALUE *args);
+VALUE rb_fiber_yield(int argc, VALUE *args);
+VALUE rb_fiber_current(void);
+VALUE rb_fiber_alive_p(VALUE);
+/* enum.c */
+/* enumerator.c */
+VALUE rb_enumeratorize(VALUE, VALUE, int, VALUE *);
+#define RETURN_ENUMERATOR(obj, argc, argv) do {				\
+	if (!rb_block_given_p())					\
+	    return rb_enumeratorize((obj), ID2SYM(rb_frame_this_func()),\
+				    (argc), (argv));			\
+    } while (0)
+/* error.c */
+VALUE rb_exc_new(VALUE, const char*, long);
+VALUE rb_exc_new2(VALUE, const char*);
+VALUE rb_exc_new3(VALUE, VALUE);
+PRINTF_ARGS(NORETURN(void rb_loaderror(const char*, ...)), 1, 2);
+PRINTF_ARGS(NORETURN(void rb_name_error(ID, const char*, ...)), 2, 3);
+NORETURN(void rb_invalid_str(const char*, const char*));
+PRINTF_ARGS(void rb_compile_error(const char*, int, const char*, ...), 3, 4);
+PRINTF_ARGS(void rb_compile_error_with_enc(const char*, int, void *, const char*, ...), 4, 5);
+PRINTF_ARGS(void rb_compile_error_append(const char*, ...), 1, 2);
+NORETURN(void rb_load_fail(const char*));
+NORETURN(void rb_error_frozen(const char*));
+void rb_check_frozen(VALUE);
+#define rb_check_frozen_internal(obj) do { \
+	VALUE frozen_obj = (obj); \
+	if (OBJ_FROZEN(frozen_obj)) { \
+	    rb_error_frozen(rb_obj_classname(frozen_obj)); \
+	} \
+    } while (0)
+#ifdef __GNUC__
+#define rb_check_frozen(obj) __extension__({rb_check_frozen_internal(obj);})
+#else
+static inline void
+rb_check_frozen_inline(VALUE obj)
+{
+    rb_check_frozen_internal(obj);
+}
+#define rb_check_frozen(obj) rb_check_frozen_inline(obj)
+#endif
+
+/* eval.c */
+int rb_sourceline(void);
+const char *rb_sourcefile(void);
+VALUE rb_check_funcall(VALUE, ID, int, VALUE*);
+
+#if defined(NFDBITS) && defined(HAVE_RB_FD_INIT)
+typedef struct {
+    int maxfd;
+    fd_set *fdset;
+} rb_fdset_t;
+
+void rb_fd_init(rb_fdset_t *);
+void rb_fd_term(rb_fdset_t *);
+void rb_fd_zero(rb_fdset_t *);
+void rb_fd_set(int, rb_fdset_t *);
+void rb_fd_clr(int, rb_fdset_t *);
+int rb_fd_isset(int, const rb_fdset_t *);
+void rb_fd_copy(rb_fdset_t *, const fd_set *, int);
+void rb_fd_dup(rb_fdset_t *dst, const rb_fdset_t *src);
+int rb_fd_select(int, rb_fdset_t *, rb_fdset_t *, rb_fdset_t *, struct timeval *);
+
+#define rb_fd_ptr(f)	((f)->fdset)
+#define rb_fd_max(f)	((f)->maxfd)
+
+#elif defined(_WIN32)
+
+typedef struct {
+    int capa;
+    fd_set *fdset;
+} rb_fdset_t;
+
+void rb_fd_init(rb_fdset_t *);
+void rb_fd_term(rb_fdset_t *);
+#define rb_fd_zero(f)		((f)->fdset->fd_count = 0)
+void rb_fd_set(int, rb_fdset_t *);
+#define rb_fd_clr(n, f)		rb_w32_fdclr((n), (f)->fdset)
+#define rb_fd_isset(n, f)	rb_w32_fdisset((n), (f)->fdset)
+#define rb_fd_copy(d, s, n)	rb_w32_fd_copy((d), (s), (n))
+void rb_w32_fd_copy(rb_fdset_t *, const fd_set *, int);
+#define rb_fd_dup(d, s)	rb_w32_fd_dup((d), (s))
+void rb_w32_fd_dup(rb_fdset_t *dst, const rb_fdset_t *src);
+#define rb_fd_select(n, rfds, wfds, efds, timeout)	rb_w32_select((n), (rfds) ? ((rb_fdset_t*)(rfds))->fdset : NULL, (wfds) ? ((rb_fdset_t*)(wfds))->fdset : NULL, (efds) ? ((rb_fdset_t*)(efds))->fdset: NULL, (timeout))
+#define rb_fd_resize(n, f)	((void)(f))
+
+#define rb_fd_ptr(f)	((f)->fdset)
+#define rb_fd_max(f)	((f)->fdset->fd_count)
+
+#else
+
+typedef fd_set rb_fdset_t;
+#define rb_fd_zero(f)	FD_ZERO(f)
+#define rb_fd_set(n, f)	FD_SET((n), (f))
+#define rb_fd_clr(n, f)	FD_CLR((n), (f))
+#define rb_fd_isset(n, f) FD_ISSET((n), (f))
+#define rb_fd_copy(d, s, n) (*(d) = *(s))
+#define rb_fd_dup(d, s) (*(d) = *(s))
+#define rb_fd_resize(n, f)	((void)(f))
+#define rb_fd_ptr(f)	(f)
+#define rb_fd_init(f)	FD_ZERO(f)
+#define rb_fd_init_copy(d, s) (*(d) = *(s))
+#define rb_fd_term(f)	((void)(f))
+#define rb_fd_max(f)	FD_SETSIZE
+#define rb_fd_select(n, rfds, wfds, efds, timeout)	select((n), (rfds), (wfds), (efds), (timeout))
+
+#endif
+
+NORETURN(void rb_exc_raise(VALUE));
+NORETURN(void rb_exc_fatal(VALUE));
+VALUE rb_f_exit(int,VALUE*);
+VALUE rb_f_abort(int,VALUE*);
+void rb_remove_method(VALUE, const char*);
+void rb_remove_method_id(VALUE, ID);
+#define rb_disable_super(klass, name) ((void)0)
+#define rb_enable_super(klass, name) ((void)0)
+#define HAVE_RB_DEFINE_ALLOC_FUNC 1
+typedef VALUE (*rb_alloc_func_t)(VALUE);
+void rb_define_alloc_func(VALUE, rb_alloc_func_t);
+void rb_undef_alloc_func(VALUE);
+rb_alloc_func_t rb_get_alloc_func(VALUE);
+void rb_clear_cache(void);
+void rb_clear_cache_by_class(VALUE);
+void rb_alias(VALUE, ID, ID);
+void rb_attr(VALUE,ID,int,int,int);
+int rb_method_boundp(VALUE, ID, int);
+int rb_method_basic_definition_p(VALUE, ID);
+VALUE rb_eval_cmd(VALUE, VALUE, int);
+int rb_obj_respond_to(VALUE, ID, int);
+int rb_respond_to(VALUE, ID);
+VALUE rb_f_notimplement(int argc, VALUE *argv, VALUE obj);
+void rb_interrupt(void);
+VALUE rb_apply(VALUE, ID, VALUE);
+void rb_backtrace(void);
+ID rb_frame_this_func(void);
+VALUE rb_obj_instance_eval(int, VALUE*, VALUE);
+VALUE rb_obj_instance_exec(int, VALUE*, VALUE);
+VALUE rb_mod_module_eval(int, VALUE*, VALUE);
+VALUE rb_mod_module_exec(int, VALUE*, VALUE);
+void rb_load(VALUE, int);
+void rb_load_protect(VALUE, int, int*);
+NORETURN(void rb_jump_tag(int));
+int rb_provided(const char*);
+int rb_feature_provided(const char *, const char **);
+void rb_provide(const char*);
+VALUE rb_f_require(VALUE, VALUE);
+VALUE rb_require_safe(VALUE, int);
+void rb_obj_call_init(VALUE, int, VALUE*);
+VALUE rb_class_new_instance(int, VALUE*, VALUE);
+VALUE rb_block_proc(void);
+VALUE rb_f_lambda(void);
+VALUE rb_proc_new(VALUE (*)(ANYARGS/* VALUE yieldarg[, VALUE procarg] */), VALUE);
+VALUE rb_obj_is_proc(VALUE);
+VALUE rb_proc_call(VALUE, VALUE);
+VALUE rb_proc_call_with_block(VALUE, int argc, VALUE *argv, VALUE);
+int rb_proc_arity(VALUE);
+VALUE rb_proc_lambda_p(VALUE);
+VALUE rb_binding_new(void);
+VALUE rb_obj_method(VALUE, VALUE);
+VALUE rb_obj_is_method(VALUE);
+VALUE rb_method_call(int, VALUE*, VALUE);
+int rb_mod_method_arity(VALUE, ID);
+int rb_obj_method_arity(VALUE, ID);
+VALUE rb_protect(VALUE (*)(VALUE), VALUE, int*);
+void rb_set_end_proc(void (*)(VALUE), VALUE);
+void rb_mark_end_proc(void);
+void rb_exec_end_proc(void);
+void ruby_finalize(void);
+NORETURN(void ruby_stop(int));
+int ruby_cleanup(volatile int);
+DEPRECATED(void rb_gc_mark_threads(void));
+void rb_thread_schedule(void);
+void rb_thread_wait_fd(int);
+int rb_thread_fd_writable(int);
+void rb_thread_fd_close(int);
+int rb_thread_alone(void);
+void rb_thread_polling(void);
+void rb_thread_sleep(int);
+void rb_thread_sleep_forever(void);
+VALUE rb_thread_stop(void);
+VALUE rb_thread_wakeup(VALUE);
+VALUE rb_thread_wakeup_alive(VALUE);
+VALUE rb_thread_run(VALUE);
+VALUE rb_thread_kill(VALUE);
+VALUE rb_thread_create(VALUE (*)(ANYARGS), void*);
+DEPRECATED(int rb_thread_select(int, fd_set *, fd_set *, fd_set *, struct timeval *));
+int rb_thread_fd_select(int, rb_fdset_t *, rb_fdset_t *, rb_fdset_t *, struct timeval *);
+void rb_thread_wait_for(struct timeval);
+VALUE rb_thread_current(void);
+VALUE rb_thread_main(void);
+VALUE rb_thread_local_aref(VALUE, ID);
+VALUE rb_thread_local_aset(VALUE, ID, VALUE);
+void rb_thread_atfork(void);
+void rb_thread_atfork_before_exec(void);
+VALUE rb_exec_recursive(VALUE(*)(VALUE, VALUE, int),VALUE,VALUE);
+VALUE rb_exec_recursive_paired(VALUE(*)(VALUE, VALUE, int),VALUE,VALUE,VALUE);
+VALUE rb_exec_recursive_outer(VALUE(*)(VALUE, VALUE, int),VALUE,VALUE);
+/* dir.c */
+VALUE rb_dir_getwd(void);
+/* file.c */
+VALUE rb_file_s_expand_path(int, VALUE *);
+VALUE rb_file_expand_path(VALUE, VALUE);
+VALUE rb_file_s_absolute_path(int, VALUE *);
+VALUE rb_file_absolute_path(VALUE, VALUE);
+VALUE rb_file_dirname(VALUE fname);
+void rb_file_const(const char*, VALUE);
+int rb_file_load_ok(const char *);
+int rb_find_file_ext_safe(VALUE*, const char* const*, int);
+VALUE rb_find_file_safe(VALUE, int);
+int rb_find_file_ext(VALUE*, const char* const*);
+VALUE rb_find_file(VALUE);
+char *rb_path_next(const char *);
+char *rb_path_skip_prefix(const char *);
+char *rb_path_last_separator(const char *);
+char *rb_path_end(const char *);
+VALUE rb_file_directory_p(VALUE,VALUE);
+VALUE rb_str_encode_ospath(VALUE);
+int rb_is_absolute_path(const char *);
+const char *ruby_find_basename(const char *name, long *baselen, long *alllen);
+const char *ruby_find_extname(const char *name, long *len);
+/* gc.c */
+void ruby_set_stack_size(size_t);
+NORETURN(void rb_memerror(void));
+int ruby_stack_check(void);
+size_t ruby_stack_length(VALUE**);
+int rb_during_gc(void);
+void rb_gc_mark_locations(VALUE*, VALUE*);
+void rb_mark_tbl(struct st_table*);
+void rb_mark_set(struct st_table*);
+void rb_mark_hash(struct st_table*);
+void rb_gc_mark_maybe(VALUE);
+void rb_gc_mark(VALUE);
+void rb_gc_force_recycle(VALUE);
+void rb_gc(void);
+void rb_gc_copy_finalizer(VALUE,VALUE);
+void rb_gc_finalize_deferred(void);
+void rb_gc_call_finalizer_at_exit(void);
+VALUE rb_gc_enable(void);
+VALUE rb_gc_disable(void);
+VALUE rb_gc_start(void);
+#define Init_stack(addr) ruby_init_stack(addr)
+void rb_gc_set_params(void);
+/* hash.c */
+void st_foreach_safe(struct st_table *, int (*)(ANYARGS), st_data_t);
+VALUE rb_check_hash_type(VALUE);
+void rb_hash_foreach(VALUE, int (*)(ANYARGS), VALUE);
+VALUE rb_hash(VALUE);
+VALUE rb_hash_new(void);
+VALUE rb_hash_dup(VALUE);
+VALUE rb_hash_freeze(VALUE);
+VALUE rb_hash_aref(VALUE, VALUE);
+VALUE rb_hash_lookup(VALUE, VALUE);
+VALUE rb_hash_lookup2(VALUE, VALUE, VALUE);
+VALUE rb_hash_fetch(VALUE, VALUE);
+VALUE rb_hash_aset(VALUE, VALUE, VALUE);
+VALUE rb_hash_delete_if(VALUE);
+VALUE rb_hash_delete(VALUE,VALUE);
+typedef VALUE rb_hash_update_func(VALUE newkey, VALUE oldkey, VALUE value);
+VALUE rb_hash_update_by(VALUE hash1, VALUE hash2, rb_hash_update_func *func);
+struct st_table *rb_hash_tbl(VALUE);
+int rb_path_check(const char*);
+int rb_env_path_tainted(void);
+VALUE rb_env_clear(void);
+/* io.c */
+#define rb_defout rb_stdout
+RUBY_EXTERN VALUE rb_fs;
+RUBY_EXTERN VALUE rb_output_fs;
+RUBY_EXTERN VALUE rb_rs;
+RUBY_EXTERN VALUE rb_default_rs;
+RUBY_EXTERN VALUE rb_output_rs;
+VALUE rb_io_write(VALUE, VALUE);
+VALUE rb_io_gets(VALUE);
+VALUE rb_io_getbyte(VALUE);
+VALUE rb_io_ungetc(VALUE, VALUE);
+VALUE rb_io_ungetbyte(VALUE, VALUE);
+VALUE rb_io_close(VALUE);
+VALUE rb_io_flush(VALUE);
+VALUE rb_io_eof(VALUE);
+VALUE rb_io_binmode(VALUE);
+VALUE rb_io_ascii8bit_binmode(VALUE);
+VALUE rb_io_addstr(VALUE, VALUE);
+VALUE rb_io_printf(int, VALUE*, VALUE);
+VALUE rb_io_print(int, VALUE*, VALUE);
+VALUE rb_io_puts(int, VALUE*, VALUE);
+VALUE rb_io_fdopen(int, int, const char*);
+VALUE rb_io_get_io(VALUE);
+VALUE rb_file_open(const char*, const char*);
+VALUE rb_file_open_str(VALUE, const char*);
+VALUE rb_gets(void);
+void rb_write_error(const char*);
+void rb_write_error2(const char*, long);
+void rb_close_before_exec(int lowfd, int maxhint, VALUE noclose_fds);
+int rb_pipe(int *pipes);
+int rb_reserved_fd_p(int fd);
+#define RB_RESERVED_FD_P(fd) rb_reserved_fd_p(fd)
+void rb_update_max_fd(int fd);
+/* marshal.c */
+VALUE rb_marshal_dump(VALUE, VALUE);
+VALUE rb_marshal_load(VALUE);
+void rb_marshal_define_compat(VALUE newclass, VALUE oldclass, VALUE (*dumper)(VALUE), VALUE (*loader)(VALUE, VALUE));
+/* numeric.c */
+void rb_num_zerodiv(void);
+#define RB_NUM_COERCE_FUNCS_NEED_OPID 1
+VALUE rb_num_coerce_bin(VALUE, VALUE, ID);
+VALUE rb_num_coerce_cmp(VALUE, VALUE, ID);
+VALUE rb_num_coerce_relop(VALUE, VALUE, ID);
+VALUE rb_float_new(double);
+VALUE rb_num2fix(VALUE);
+VALUE rb_fix2str(VALUE, int);
+VALUE rb_dbl_cmp(double, double);
+/* object.c */
+int rb_eql(VALUE, VALUE);
+VALUE rb_any_to_s(VALUE);
+VALUE rb_inspect(VALUE);
+VALUE rb_obj_is_instance_of(VALUE, VALUE);
+VALUE rb_obj_is_kind_of(VALUE, VALUE);
+VALUE rb_obj_alloc(VALUE);
+VALUE rb_obj_clone(VALUE);
+VALUE rb_obj_dup(VALUE);
+VALUE rb_obj_init_copy(VALUE,VALUE);
+VALUE rb_obj_taint(VALUE);
+VALUE rb_obj_tainted(VALUE);
+VALUE rb_obj_untaint(VALUE);
+VALUE rb_obj_untrust(VALUE);
+VALUE rb_obj_untrusted(VALUE);
+VALUE rb_obj_trust(VALUE);
+VALUE rb_obj_freeze(VALUE);
+VALUE rb_obj_frozen_p(VALUE);
+VALUE rb_obj_id(VALUE);
+VALUE rb_obj_class(VALUE);
+VALUE rb_class_real(VALUE);
+VALUE rb_class_inherited_p(VALUE, VALUE);
+VALUE rb_class_superclass(VALUE);
+VALUE rb_class_get_superclass(VALUE);
+VALUE rb_convert_type(VALUE,int,const char*,const char*);
+VALUE rb_check_convert_type(VALUE,int,const char*,const char*);
+VALUE rb_check_to_integer(VALUE, const char *);
+VALUE rb_check_to_float(VALUE);
+VALUE rb_to_int(VALUE);
+VALUE rb_Integer(VALUE);
+VALUE rb_to_float(VALUE);
+VALUE rb_Float(VALUE);
+VALUE rb_String(VALUE);
+VALUE rb_Array(VALUE);
+double rb_cstr_to_dbl(const char*, int);
+double rb_str_to_dbl(VALUE, int);
+/* parse.y */
+RUBY_EXTERN int   ruby_sourceline;
+RUBY_EXTERN char *ruby_sourcefile;
+ID rb_id_attrset(ID);
+void rb_gc_mark_parser(void);
+int rb_is_const_id(ID);
+int rb_is_instance_id(ID);
+int rb_is_class_id(ID);
+int rb_is_local_id(ID);
+int rb_is_junk_id(ID);
+int rb_symname_p(const char*);
+int rb_sym_interned_p(VALUE);
+void rb_gc_mark_symbols(void);
+VALUE rb_backref_get(void);
+void rb_backref_set(VALUE);
+VALUE rb_lastline_get(void);
+void rb_lastline_set(VALUE);
+VALUE rb_sym_all_symbols(void);
+/* process.c */
+void rb_last_status_set(int status, rb_pid_t pid);
+VALUE rb_last_status_get(void);
+struct rb_exec_arg {
+    int argc;
+    VALUE *argv;
+    const char *prog;
+    VALUE options;
+    VALUE redirect_fds;
+};
+int rb_proc_exec_n(int, VALUE*, const char*);
+int rb_proc_exec(const char*);
+VALUE rb_exec_arg_init(int argc, VALUE *argv, int accept_shell, struct rb_exec_arg *e);
+int rb_exec_arg_addopt(struct rb_exec_arg *e, VALUE key, VALUE val);
+void rb_exec_arg_fixup(struct rb_exec_arg *e);
+int rb_run_exec_options(const struct rb_exec_arg *e, struct rb_exec_arg *s);
+int rb_run_exec_options_err(const struct rb_exec_arg *e, struct rb_exec_arg *s, char*, size_t);
+int rb_exec(const struct rb_exec_arg*);
+int rb_exec_err(const struct rb_exec_arg*, char*, size_t);
+rb_pid_t rb_fork(int*, int (*)(void*), void*, VALUE);
+rb_pid_t rb_fork_err(int*, int (*)(void*, char*, size_t), void*, VALUE, char*, size_t);
+VALUE rb_f_exec(int,VALUE*);
+rb_pid_t rb_waitpid(rb_pid_t pid, int *status, int flags);
+void rb_syswait(rb_pid_t pid);
+rb_pid_t rb_spawn(int, VALUE*);
+rb_pid_t rb_spawn_err(int, VALUE*, char*, size_t);
+VALUE rb_proc_times(VALUE);
+VALUE rb_detach_process(rb_pid_t pid);
+/* range.c */
+VALUE rb_range_new(VALUE, VALUE, int);
+VALUE rb_range_beg_len(VALUE, long*, long*, long, int);
+int rb_range_values(VALUE range, VALUE *begp, VALUE *endp, int *exclp);
+/* random.c */
+unsigned int rb_genrand_int32(void);
+double rb_genrand_real(void);
+void rb_reset_random_seed(void);
+VALUE rb_random_bytes(VALUE rnd, long n);
+VALUE rb_random_int(VALUE rnd, VALUE max);
+unsigned int rb_random_int32(VALUE rnd);
+double rb_random_real(VALUE rnd);
+unsigned long rb_genrand_ulong_limited(unsigned long i);
+/* re.c */
+#define rb_memcmp memcmp
+int rb_memcicmp(const void*,const void*,long);
+void rb_match_busy(VALUE);
+VALUE rb_reg_nth_defined(int, VALUE);
+VALUE rb_reg_nth_match(int, VALUE);
+int rb_reg_backref_number(VALUE match, VALUE backref);
+VALUE rb_reg_last_match(VALUE);
+VALUE rb_reg_match_pre(VALUE);
+VALUE rb_reg_match_post(VALUE);
+VALUE rb_reg_match_last(VALUE);
+#define HAVE_RB_REG_NEW_STR 1
+VALUE rb_reg_new_str(VALUE, int);
+VALUE rb_reg_new(const char *, long, int);
+VALUE rb_reg_alloc(void);
+VALUE rb_reg_init_str(VALUE re, VALUE s, int options);
+VALUE rb_reg_match(VALUE, VALUE);
+VALUE rb_reg_match2(VALUE);
+int rb_reg_options(VALUE);
+/* ruby.c */
+#define rb_argv rb_get_argv()
+RUBY_EXTERN VALUE rb_argv0;
+VALUE rb_get_argv(void);
+void *rb_load_file(const char*);
+void ruby_script(const char*);
+void ruby_prog_init(void);
+void ruby_set_argv(int, char**);
+void *ruby_process_options(int, char**);
+void ruby_init_loadpath(void);
+void ruby_incpush(const char*);
+/* signal.c */
+VALUE rb_f_kill(int, VALUE*);
+void rb_gc_mark_trap_list(void);
+#ifdef POSIX_SIGNAL
+#define posix_signal ruby_posix_signal
+RETSIGTYPE (*posix_signal(int, RETSIGTYPE (*)(int)))(int);
+#endif
+void ruby_sig_finalize(void);
+void rb_trap_exit(void);
+void rb_trap_exec(void);
+const char *ruby_signal_name(int);
+void ruby_default_signal(int);
+/* sprintf.c */
+VALUE rb_f_sprintf(int, const VALUE*);
+PRINTF_ARGS(VALUE rb_sprintf(const char*, ...), 1, 2);
+VALUE rb_vsprintf(const char*, va_list);
+PRINTF_ARGS(VALUE rb_str_catf(VALUE, const char*, ...), 2, 3);
+VALUE rb_str_vcatf(VALUE, const char*, va_list);
+VALUE rb_str_format(int, const VALUE *, VALUE);
+/* string.c */
+VALUE rb_str_new(const char*, long);
+VALUE rb_str_new_cstr(const char*);
+VALUE rb_str_new2(const char*);
+VALUE rb_str_new_shared(VALUE);
+VALUE rb_str_new3(VALUE);
+VALUE rb_str_new_frozen(VALUE);
+VALUE rb_str_new4(VALUE);
+VALUE rb_str_new_with_class(VALUE, const char*, long);
+VALUE rb_str_new5(VALUE, const char*, long);
+VALUE rb_tainted_str_new_cstr(const char*);
+VALUE rb_tainted_str_new(const char*, long);
+VALUE rb_tainted_str_new2(const char*);
+VALUE rb_external_str_new(const char*, long);
+VALUE rb_external_str_new_cstr(const char*);
+VALUE rb_locale_str_new(const char*, long);
+VALUE rb_locale_str_new_cstr(const char*);
+VALUE rb_filesystem_str_new(const char*, long);
+VALUE rb_filesystem_str_new_cstr(const char*);
+VALUE rb_str_buf_new(long);
+VALUE rb_str_buf_new_cstr(const char*);
+VALUE rb_str_buf_new2(const char*);
+VALUE rb_str_tmp_new(long);
+VALUE rb_usascii_str_new(const char*, long);
+VALUE rb_usascii_str_new_cstr(const char*);
+VALUE rb_usascii_str_new2(const char*);
+void rb_str_free(VALUE);
+void rb_str_shared_replace(VALUE, VALUE);
+VALUE rb_str_buf_append(VALUE, VALUE);
+VALUE rb_str_buf_cat(VALUE, const char*, long);
+VALUE rb_str_buf_cat2(VALUE, const char*);
+VALUE rb_str_buf_cat_ascii(VALUE, const char*);
+VALUE rb_obj_as_string(VALUE);
+VALUE rb_check_string_type(VALUE);
+VALUE rb_str_dup(VALUE);
+VALUE rb_str_resurrect(VALUE str);
+VALUE rb_str_locktmp(VALUE);
+VALUE rb_str_unlocktmp(VALUE);
+VALUE rb_str_dup_frozen(VALUE);
+#define rb_str_dup_frozen rb_str_new_frozen
+VALUE rb_str_plus(VALUE, VALUE);
+VALUE rb_str_times(VALUE, VALUE);
+long rb_str_sublen(VALUE, long);
+VALUE rb_str_substr(VALUE, long, long);
+VALUE rb_str_subseq(VALUE, long, long);
+void rb_str_modify(VALUE);
+void rb_str_modify_expand(VALUE, long);
+VALUE rb_str_freeze(VALUE);
+void rb_str_set_len(VALUE, long);
+VALUE rb_str_resize(VALUE, long);
+VALUE rb_str_cat(VALUE, const char*, long);
+VALUE rb_str_cat2(VALUE, const char*);
+VALUE rb_str_append(VALUE, VALUE);
+VALUE rb_str_concat(VALUE, VALUE);
+st_index_t rb_memhash(const void *ptr, long len);
+st_index_t rb_hash_start(st_index_t);
+st_index_t rb_hash_uint32(st_index_t, uint32_t);
+st_index_t rb_hash_uint(st_index_t, st_index_t);
+st_index_t rb_hash_end(st_index_t);
+#define rb_hash_uint32(h, i) st_hash_uint32((h), (i))
+#define rb_hash_uint(h, i) st_hash_uint((h), (i))
+#define rb_hash_end(h) st_hash_end(h)
+st_index_t rb_str_hash(VALUE);
+int rb_str_hash_cmp(VALUE,VALUE);
+int rb_str_comparable(VALUE, VALUE);
+int rb_str_cmp(VALUE, VALUE);
+VALUE rb_str_equal(VALUE str1, VALUE str2);
+VALUE rb_str_drop_bytes(VALUE, long);
+void rb_str_update(VALUE, long, long, VALUE);
+VALUE rb_str_replace(VALUE, VALUE);
+VALUE rb_str_inspect(VALUE);
+VALUE rb_str_dump(VALUE);
+VALUE rb_str_split(VALUE, const char*);
+void rb_str_associate(VALUE, VALUE);
+VALUE rb_str_associated(VALUE);
+void rb_str_setter(VALUE, ID, VALUE*);
+VALUE rb_str_intern(VALUE);
+VALUE rb_sym_to_s(VALUE);
+long rb_str_strlen(VALUE);
+VALUE rb_str_length(VALUE);
+long rb_str_offset(VALUE, long);
+size_t rb_str_capacity(VALUE);
+VALUE rb_str_ellipsize(VALUE, long);
+#if defined(__GNUC__) && !defined(__PCC__)
+#define rb_str_new_cstr(str) __extension__ (	\
+{						\
+    (__builtin_constant_p(str)) ?		\
+	rb_str_new((str), (long)strlen(str)) :	\
+	rb_str_new_cstr(str);			\
+})
+#define rb_tainted_str_new_cstr(str) __extension__ ( \
+{					       \
+    (__builtin_constant_p(str)) ?	       \
+	rb_tainted_str_new((str), (long)strlen(str)) : \
+	rb_tainted_str_new_cstr(str);	       \
+})
+#define rb_usascii_str_new_cstr(str) __extension__ ( \
+{					       \
+    (__builtin_constant_p(str)) ?	       \
+	rb_usascii_str_new((str), (long)strlen(str)) : \
+	rb_usascii_str_new_cstr(str);	       \
+})
+#define rb_external_str_new_cstr(str) __extension__ ( \
+{						\
+    (__builtin_constant_p(str)) ?		\
+	rb_external_str_new((str), (long)strlen(str)) : \
+	rb_external_str_new_cstr(str);		\
+})
+#define rb_locale_str_new_cstr(str) __extension__ ( \
+{					       \
+    (__builtin_constant_p(str)) ?	       \
+	rb_locale_str_new((str), (long)strlen(str)) :  \
+	rb_locale_str_new_cstr(str);	       \
+})
+#define rb_str_buf_new_cstr(str) __extension__ ( \
+{						\
+    (__builtin_constant_p(str)) ?		\
+	rb_str_buf_cat(rb_str_buf_new((long)strlen(str)), \
+		       (str), (long)strlen(str)) : \
+	rb_str_buf_new_cstr(str);		\
+})
+#define rb_str_buf_cat2(str, ptr) __extension__ ( \
+{						\
+    (__builtin_constant_p(ptr)) ?	        \
+	rb_str_buf_cat((str), (ptr), (long)strlen(ptr)) : \
+	rb_str_buf_cat2((str), (ptr));		\
+})
+#define rb_str_cat2(str, ptr) __extension__ (	\
+{						\
+    (__builtin_constant_p(ptr)) ?	        \
+	rb_str_cat((str), (ptr), (long)strlen(ptr)) : \
+	rb_str_cat2((str), (ptr));			\
+})
+#define rb_exc_new2(klass, ptr) __extension__ ( \
+{						\
+    (__builtin_constant_p(ptr)) ?	        \
+	rb_exc_new((klass), (ptr), (long)strlen(ptr)) : \
+	rb_exc_new2((klass), (ptr));		\
+})
+#endif
+#define rb_str_new2 rb_str_new_cstr
+#define rb_str_new3 rb_str_new_shared
+#define rb_str_new4 rb_str_new_frozen
+#define rb_str_new5 rb_str_new_with_class
+#define rb_tainted_str_new2 rb_tainted_str_new_cstr
+#define rb_str_buf_new2 rb_str_buf_new_cstr
+#define rb_usascii_str_new2 rb_usascii_str_new_cstr
+/* struct.c */
+VALUE rb_struct_new(VALUE, ...);
+VALUE rb_struct_define(const char*, ...);
+VALUE rb_struct_alloc(VALUE, VALUE);
+VALUE rb_struct_initialize(VALUE, VALUE);
+VALUE rb_struct_aref(VALUE, VALUE);
+VALUE rb_struct_aset(VALUE, VALUE, VALUE);
+VALUE rb_struct_getmember(VALUE, ID);
+DEPRECATED(VALUE rb_struct_iv_get(VALUE, const char*));
+VALUE rb_struct_s_members(VALUE);
+VALUE rb_struct_members(VALUE);
+VALUE rb_struct_alloc_noinit(VALUE);
+VALUE rb_struct_define_without_accessor(const char *, VALUE, rb_alloc_func_t, ...);
+/* thread.c */
+typedef void rb_unblock_function_t(void *);
+typedef VALUE rb_blocking_function_t(void *);
+void rb_thread_check_ints(void);
+int rb_thread_interrupted(VALUE thval);
+VALUE rb_thread_blocking_region(rb_blocking_function_t *func, void *data1,
+				rb_unblock_function_t *ubf, void *data2);
+#define RUBY_UBF_IO ((rb_unblock_function_t *)-1)
+#define RUBY_UBF_PROCESS ((rb_unblock_function_t *)-1)
+VALUE rb_mutex_new(void);
+VALUE rb_mutex_locked_p(VALUE mutex);
+VALUE rb_mutex_trylock(VALUE mutex);
+VALUE rb_mutex_lock(VALUE mutex);
+VALUE rb_mutex_unlock(VALUE mutex);
+VALUE rb_mutex_sleep(VALUE self, VALUE timeout);
+VALUE rb_mutex_synchronize(VALUE mutex, VALUE (*func)(VALUE arg), VALUE arg);
+VALUE rb_barrier_new(void);
+VALUE rb_barrier_wait(VALUE self);
+VALUE rb_barrier_release(VALUE self);
+VALUE rb_barrier_destroy(VALUE self);
+/* time.c */
+VALUE rb_time_new(time_t, long);
+VALUE rb_time_nano_new(time_t, long);
+VALUE rb_time_num_new(VALUE, VALUE);
+struct timeval rb_time_interval(VALUE num);
+struct timeval rb_time_timeval(VALUE time);
+struct timespec rb_time_timespec(VALUE time);
+/* variable.c */
+VALUE rb_mod_name(VALUE);
+VALUE rb_class_path(VALUE);
+void rb_set_class_path(VALUE, VALUE, const char*);
+void rb_set_class_path_string(VALUE, VALUE, VALUE);
+VALUE rb_path_to_class(VALUE);
+VALUE rb_path2class(const char*);
+void rb_name_class(VALUE, ID);
+VALUE rb_class_name(VALUE);
+void rb_autoload(VALUE, ID, const char*);
+VALUE rb_autoload_load(VALUE, ID);
+VALUE rb_autoload_p(VALUE, ID);
+void rb_gc_mark_global_tbl(void);
+VALUE rb_f_trace_var(int, VALUE*);
+VALUE rb_f_untrace_var(int, VALUE*);
+VALUE rb_f_global_variables(void);
+void rb_alias_variable(ID, ID);
+struct st_table* rb_generic_ivar_table(VALUE);
+void rb_copy_generic_ivar(VALUE,VALUE);
+void rb_mark_generic_ivar(VALUE);
+void rb_mark_generic_ivar_tbl(void);
+void rb_free_generic_ivar(VALUE);
+VALUE rb_ivar_get(VALUE, ID);
+VALUE rb_ivar_set(VALUE, ID, VALUE);
+VALUE rb_ivar_defined(VALUE, ID);
+void rb_ivar_foreach(VALUE, int (*)(ANYARGS), st_data_t);
+st_index_t rb_ivar_count(VALUE);
+VALUE rb_iv_set(VALUE, const char*, VALUE);
+VALUE rb_iv_get(VALUE, const char*);
+VALUE rb_attr_get(VALUE, ID);
+VALUE rb_obj_instance_variables(VALUE);
+VALUE rb_obj_remove_instance_variable(VALUE, VALUE);
+void *rb_mod_const_at(VALUE, void*);
+void *rb_mod_const_of(VALUE, void*);
+VALUE rb_const_list(void*);
+VALUE rb_mod_constants(int, VALUE *, VALUE);
+VALUE rb_mod_remove_const(VALUE, VALUE);
+int rb_const_defined(VALUE, ID);
+int rb_const_defined_at(VALUE, ID);
+int rb_const_defined_from(VALUE, ID);
+VALUE rb_const_get(VALUE, ID);
+VALUE rb_const_get_at(VALUE, ID);
+VALUE rb_const_get_from(VALUE, ID);
+void rb_const_set(VALUE, ID, VALUE);
+VALUE rb_const_remove(VALUE, ID);
+VALUE rb_mod_const_missing(VALUE,VALUE);
+VALUE rb_cvar_defined(VALUE, ID);
+void rb_cvar_set(VALUE, ID, VALUE);
+VALUE rb_cvar_get(VALUE, ID);
+void rb_cv_set(VALUE, const char*, VALUE);
+VALUE rb_cv_get(VALUE, const char*);
+void rb_define_class_variable(VALUE, const char*, VALUE);
+VALUE rb_mod_class_variables(VALUE);
+VALUE rb_mod_remove_cvar(VALUE, VALUE);
+/* version.c */
+void ruby_show_version(void);
+void ruby_show_copyright(void);
+
+ID rb_frame_callee(void);
+VALUE rb_str_succ(VALUE);
+VALUE rb_time_succ(VALUE);
+void rb_frame_pop(void);
+int rb_frame_method_id_and_class(ID *idp, VALUE *klassp);
+VALUE rb_make_backtrace(void);
+VALUE rb_make_exception(int, VALUE*);
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility pop
+#endif
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+#endif /* RUBY_INTERN_H */
diff --git a/include/ruby/io.h b/include/ruby/io.h
new file mode 100644
index 0000000..33d2a5d
--- /dev/null
+++ b/include/ruby/io.h
@@ -0,0 +1,202 @@
+/**********************************************************************
+
+  rubyio.h -
+
+  $Author: kosaki $
+  created at: Fri Nov 12 16:47:09 JST 1993
+
+  Copyright (C) 1993-2007 Yukihiro Matsumoto
+
+**********************************************************************/
+
+#ifndef RUBY_IO_H
+#define RUBY_IO_H 1
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+#include <stdio.h>
+#include <errno.h>
+#include "ruby/encoding.h"
+
+#if defined(HAVE_STDIO_EXT_H)
+#include <stdio_ext.h>
+#endif
+
+#include "ruby/config.h"
+#if defined(HAVE_POLL)
+#  include <poll.h>
+#  define RB_WAITFD_IN  POLLIN
+#  define RB_WAITFD_PRI POLLPRI
+#  define RB_WAITFD_OUT POLLOUT
+#else
+#  define RB_WAITFD_IN  0x001
+#  define RB_WAITFD_PRI 0x002
+#  define RB_WAITFD_OUT 0x004
+#endif
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility push(default)
+#endif
+
+typedef struct {
+    char *ptr;                  /* off + len <= capa */
+    int off;
+    int len;
+    int capa;
+} rb_io_buffer_t;
+
+typedef struct rb_io_t {
+    int fd;                     /* file descriptor */
+    FILE *stdio_file;		/* stdio ptr for read/write if available */
+    int mode;			/* mode flags: FMODE_XXXs */
+    rb_pid_t pid;		/* child's pid (for pipes) */
+    int lineno;			/* number of lines read */
+    VALUE pathv;		/* pathname for file */
+    void (*finalize)(struct rb_io_t*,int); /* finalize proc */
+
+    rb_io_buffer_t wbuf, rbuf;
+
+    VALUE tied_io_for_writing;
+
+    /*
+     * enc  enc2 read action                      write action
+     * NULL NULL force_encoding(default_external) write the byte sequence of str
+     * e1   NULL force_encoding(e1)               convert str.encoding to e1
+     * e1   e2   convert from e2 to e1            convert str.encoding to e2
+     */
+    struct rb_io_enc_t {
+        rb_encoding *enc;
+        rb_encoding *enc2;
+        int ecflags;
+        VALUE ecopts;
+    } encs;
+
+    rb_econv_t *readconv;
+    rb_io_buffer_t cbuf;
+
+    rb_econv_t *writeconv;
+    VALUE writeconv_asciicompat;
+    int writeconv_pre_ecflags;
+    VALUE writeconv_pre_ecopts;
+    int writeconv_initialized;
+
+    VALUE write_lock;
+} rb_io_t;
+
+#define HAVE_RB_IO_T 1
+
+#define FMODE_READABLE              0x00000001
+#define FMODE_WRITABLE              0x00000002
+#define FMODE_READWRITE             (FMODE_READABLE|FMODE_WRITABLE)
+#define FMODE_BINMODE               0x00000004
+#define FMODE_SYNC                  0x00000008
+#define FMODE_TTY                   0x00000010
+#define FMODE_DUPLEX                0x00000020
+#define FMODE_APPEND                0x00000040
+#define FMODE_CREATE                0x00000080
+/* #define FMODE_NOREVLOOKUP        0x00000100 */
+#define FMODE_WSPLIT                0x00000200
+#define FMODE_WSPLIT_INITIALIZED    0x00000400
+#define FMODE_TRUNC                 0x00000800
+#define FMODE_TEXTMODE              0x00001000
+/* #define FMODE_PREP               0x00010000 */
+#define FMODE_SETENC_BY_BOM         0x00100000
+
+#define GetOpenFile(obj,fp) rb_io_check_closed((fp) = RFILE(rb_io_taint_check(obj))->fptr)
+
+#define RB_IO_BUFFER_INIT(buf) do {\
+    (buf).ptr = NULL;\
+    (buf).off = 0;\
+    (buf).len = 0;\
+    (buf).capa = 0;\
+} while (0)
+
+#define MakeOpenFile(obj, fp) do {\
+    if (RFILE(obj)->fptr) {\
+	rb_io_close(obj);\
+	rb_io_fptr_finalize(RFILE(obj)->fptr);\
+	RFILE(obj)->fptr = 0;\
+    }\
+    (fp) = 0;\
+    RB_IO_FPTR_NEW(fp);\
+    RFILE(obj)->fptr = (fp);\
+} while (0)
+
+#define RB_IO_FPTR_NEW(fp) do {\
+    (fp) = ALLOC(rb_io_t);\
+    (fp)->fd = -1;\
+    (fp)->stdio_file = NULL;\
+    (fp)->mode = 0;\
+    (fp)->pid = 0;\
+    (fp)->lineno = 0;\
+    (fp)->pathv = Qnil;\
+    (fp)->finalize = 0;\
+    RB_IO_BUFFER_INIT((fp)->wbuf);\
+    RB_IO_BUFFER_INIT((fp)->rbuf);\
+    RB_IO_BUFFER_INIT((fp)->cbuf);\
+    (fp)->readconv = NULL;\
+    (fp)->writeconv = NULL;\
+    (fp)->writeconv_asciicompat = Qnil;\
+    (fp)->writeconv_pre_ecflags = 0;\
+    (fp)->writeconv_pre_ecopts = Qnil;\
+    (fp)->writeconv_initialized = 0;\
+    (fp)->tied_io_for_writing = 0;\
+    (fp)->encs.enc = NULL;\
+    (fp)->encs.enc2 = NULL;\
+    (fp)->encs.ecflags = 0;\
+    (fp)->encs.ecopts = Qnil;\
+    (fp)->write_lock = 0;\
+} while (0)
+
+FILE *rb_io_stdio_file(rb_io_t *fptr);
+
+FILE *rb_fdopen(int, const char*);
+int rb_io_modestr_fmode(const char *modestr);
+int rb_io_modestr_oflags(const char *modestr);
+int rb_io_oflags_fmode(int oflags);
+void rb_io_check_writable(rb_io_t*);
+void rb_io_check_readable(rb_io_t*);
+void rb_io_check_char_readable(rb_io_t *fptr);
+void rb_io_check_byte_readable(rb_io_t *fptr);
+int rb_io_fptr_finalize(rb_io_t*);
+void rb_io_synchronized(rb_io_t*);
+void rb_io_check_initialized(rb_io_t*);
+void rb_io_check_closed(rb_io_t*);
+VALUE rb_io_get_io(VALUE io);
+VALUE rb_io_get_write_io(VALUE io);
+VALUE rb_io_set_write_io(VALUE io, VALUE w);
+int rb_io_wait_readable(int);
+int rb_io_wait_writable(int);
+int rb_wait_for_single_fd(int fd, int events, struct timeval *tv);
+void rb_io_set_nonblock(rb_io_t *fptr);
+int rb_io_extract_encoding_option(VALUE opt, rb_encoding **enc_p, rb_encoding **enc2_p, int *fmode_p);
+ssize_t rb_io_bufwrite(VALUE io, const void *buf, size_t size);
+
+/* compatibility for ruby 1.8 and older */
+#define rb_io_mode_flags(modestr) rb_io_modestr_fmode(modestr)
+#define rb_io_modenum_flags(oflags) rb_io_oflags_fmode(oflags)
+
+VALUE rb_io_taint_check(VALUE);
+NORETURN(void rb_eof_error(void));
+
+void rb_io_read_check(rb_io_t*);
+int rb_io_read_pending(rb_io_t*);
+DEPRECATED(void rb_read_check(FILE*));
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility pop
+#endif
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+#endif /* RUBY_IO_H */
diff --git a/include/ruby/missing.h b/include/ruby/missing.h
new file mode 100644
index 0000000..13503d4
--- /dev/null
+++ b/include/ruby/missing.h
@@ -0,0 +1,237 @@
+/************************************************
+
+  missing.h - prototype for *.c in ./missing, and
+  	      for missing timeval struct
+
+  $Author: naruse $
+  created at: Sat May 11 23:46:03 JST 2002
+
+************************************************/
+
+#ifndef RUBY_MISSING_H
+#define RUBY_MISSING_H 1
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+#include "ruby/config.h"
+#include <stddef.h>
+#ifdef RUBY_EXTCONF_H
+#include RUBY_EXTCONF_H
+#endif
+
+#if defined(HAVE_SYS_TIME_H)
+#  include <sys/time.h>
+#elif !defined(_WIN32)
+#  define time_t long
+struct timeval {
+    time_t tv_sec;	/* seconds */
+    long tv_usec;	/* microseconds */
+};
+#endif
+#if defined(HAVE_SYS_TYPES_H)
+#  include <sys/types.h>
+#endif
+
+#if !defined(HAVE_STRUCT_TIMESPEC)
+struct timespec {
+    time_t tv_sec;	/* seconds */
+    long tv_nsec;	/* nanoseconds */
+};
+#endif
+
+#if !defined(HAVE_STRUCT_TIMEZONE)
+struct timezone {
+    int tz_minuteswest;
+    int tz_dsttime;
+};
+#endif
+
+#if defined(HAVE___SYSCALL) && defined(__APPLE__)
+/* Mac OS X has __syscall but doen't defined in headers */
+off_t __syscall(quad_t number, ...);
+#endif
+
+#ifdef RUBY_EXPORT
+#undef RUBY_EXTERN
+#endif
+#ifndef RUBY_EXTERN
+#define RUBY_EXTERN extern
+#endif
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility push(default)
+#endif
+
+#ifndef HAVE_ACOSH
+RUBY_EXTERN double acosh(double);
+RUBY_EXTERN double asinh(double);
+RUBY_EXTERN double atanh(double);
+#endif
+
+#ifndef HAVE_CRYPT
+RUBY_EXTERN char *crypt(const char *, const char *);
+#endif
+
+#ifndef HAVE_DUP2
+RUBY_EXTERN int dup2(int, int);
+#endif
+
+#ifndef HAVE_EACCESS
+RUBY_EXTERN int eaccess(const char*, int);
+#endif
+
+#ifndef HAVE_ROUND
+RUBY_EXTERN double round(double);	/* numeric.c */
+#endif
+
+#ifndef HAVE_FINITE
+RUBY_EXTERN int finite(double);
+#endif
+
+#ifndef HAVE_FLOCK
+RUBY_EXTERN int flock(int, int);
+#endif
+
+/*
+#ifndef HAVE_FREXP
+RUBY_EXTERN double frexp(double, int *);
+#endif
+*/
+
+#ifndef HAVE_HYPOT
+RUBY_EXTERN double hypot(double, double);
+#endif
+
+#ifndef HAVE_ERF
+RUBY_EXTERN double erf(double);
+RUBY_EXTERN double erfc(double);
+#endif
+
+#ifndef HAVE_TGAMMA
+RUBY_EXTERN double tgamma(double);
+#endif
+
+#ifndef HAVE_LGAMMA_R
+RUBY_EXTERN double lgamma_r(double, int *);
+#endif
+
+#ifndef HAVE_CBRT
+RUBY_EXTERN double cbrt(double);
+#endif
+
+#ifdef INFINITY
+# define HAVE_INFINITY
+#else
+/** @internal */
+RUBY_EXTERN const unsigned char rb_infinity[];
+# define INFINITY (*(float *)rb_infinity)
+#endif
+
+#ifdef NAN
+# define HAVE_NAN
+#else
+/** @internal */
+RUBY_EXTERN const unsigned char rb_nan[];
+# define NAN (*(float *)rb_nan)
+#endif
+
+#ifndef isinf
+# ifndef HAVE_ISINF
+#  if defined(HAVE_FINITE) && defined(HAVE_ISNAN)
+#    ifdef HAVE_IEEEFP_H
+#    include <ieeefp.h>
+#    endif
+#  define isinf(x) (!finite(x) && !isnan(x))
+#  else
+RUBY_EXTERN int isinf(double);
+#  endif
+# endif
+#endif
+
+#ifndef isnan
+# ifndef HAVE_ISNAN
+RUBY_EXTERN int isnan(double);
+# endif
+#endif
+
+/*
+#ifndef HAVE_MEMCMP
+RUBY_EXTERN int memcmp(const void *, const void *, size_t);
+#endif
+*/
+
+#ifndef HAVE_MEMMOVE
+RUBY_EXTERN void *memmove(void *, const void *, size_t);
+#endif
+
+/*
+#ifndef HAVE_MODF
+RUBY_EXTERN double modf(double, double *);
+#endif
+*/
+
+#ifndef HAVE_STRCHR
+RUBY_EXTERN char *strchr(const char *, int);
+RUBY_EXTERN char *strrchr(const char *, int);
+#endif
+
+#ifndef HAVE_STRERROR
+RUBY_EXTERN char *strerror(int);
+#endif
+
+#ifndef HAVE_STRSTR
+RUBY_EXTERN char *strstr(const char *, const char *);
+#endif
+
+/*
+#ifndef HAVE_STRTOL
+RUBY_EXTERN long strtol(const char *, char **, int);
+#endif
+*/
+
+#ifndef HAVE_STRLCPY
+RUBY_EXTERN size_t strlcpy(char *, const char*, size_t);
+#endif
+
+#ifndef HAVE_STRLCAT
+RUBY_EXTERN size_t strlcat(char *, const char*, size_t);
+#endif
+
+#ifndef HAVE_SIGNBIT
+RUBY_EXTERN int signbit(double x);
+#endif
+
+#ifndef HAVE_FFS
+RUBY_EXTERN int ffs(int);
+#endif
+
+#ifdef BROKEN_CLOSE
+#include <sys/types.h>
+#include <sys/socket.h>
+RUBY_EXTERN int ruby_getpeername(int, struct sockaddr *, socklen_t *);
+RUBY_EXTERN int ruby_getsockname(int, struct sockaddr *, socklen_t *);
+RUBY_EXTERN int ruby_shutdown(int, int);
+RUBY_EXTERN int ruby_close(int);
+#endif
+
+#ifndef HAVE_SETPROCTITLE
+RUBY_EXTERN void setproctitle(const char *fmt, ...);
+#endif
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility pop
+#endif
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+#endif /* RUBY_MISSING_H */
diff --git a/include/ruby/oniguruma.h b/include/ruby/oniguruma.h
new file mode 100644
index 0000000..67773aa
--- /dev/null
+++ b/include/ruby/oniguruma.h
@@ -0,0 +1,807 @@
+#ifndef ONIGURUMA_H
+#define ONIGURUMA_H
+/**********************************************************************
+  oniguruma.h - Oniguruma (regular expression library)
+**********************************************************************/
+/*-
+ * Copyright (c) 2002-2008  K.Kosako  <sndgk393 AT ybb DOT ne DOT jp>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+#define ONIGURUMA
+#define ONIGURUMA_VERSION_MAJOR   5
+#define ONIGURUMA_VERSION_MINOR   9
+#define ONIGURUMA_VERSION_TEENY   2
+
+#ifdef __cplusplus
+# ifndef  HAVE_PROTOTYPES
+#  define HAVE_PROTOTYPES 1
+# endif
+# ifndef  HAVE_STDARG_PROTOTYPES
+#  define HAVE_STDARG_PROTOTYPES 1
+# endif
+#endif
+
+/* escape Mac OS X/Xcode 2.4/gcc 4.0.1 problem */
+#if defined(__APPLE__) && defined(__GNUC__) && __GNUC__ >= 4
+# ifndef  HAVE_STDARG_PROTOTYPES
+#  define HAVE_STDARG_PROTOTYPES 1
+# endif
+#endif
+
+#ifdef HAVE_STDARG_H
+# ifndef  HAVE_STDARG_PROTOTYPES
+#  define HAVE_STDARG_PROTOTYPES 1
+# endif
+#endif
+
+#ifndef P_
+#if defined(__STDC__) || defined(_WIN32)
+# define P_(args) args
+#else
+# define P_(args) ()
+#endif
+#endif
+
+#ifndef PV_
+#ifdef HAVE_STDARG_PROTOTYPES
+# define PV_(args) args
+#else
+# define PV_(args) ()
+#endif
+#endif
+
+#ifndef ONIG_EXTERN
+#ifdef RUBY_EXTERN
+#define ONIG_EXTERN   RUBY_EXTERN
+#else
+#if defined(_WIN32) && !defined(__GNUC__)
+#if defined(EXPORT) || defined(RUBY_EXPORT)
+#define ONIG_EXTERN   extern __declspec(dllexport)
+#else
+#define ONIG_EXTERN   extern __declspec(dllimport)
+#endif
+#endif
+#endif
+#endif
+
+#ifndef ONIG_EXTERN
+#define ONIG_EXTERN   extern
+#endif
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility push(default)
+#endif
+
+/* PART: character encoding */
+
+#ifndef ONIG_ESCAPE_UCHAR_COLLISION
+#define UChar OnigUChar
+#endif
+
+typedef unsigned char  OnigUChar;
+typedef unsigned int  OnigCodePoint;
+typedef unsigned int   OnigCtype;
+typedef size_t         OnigDistance;
+
+#define ONIG_INFINITE_DISTANCE  ~((OnigDistance )0)
+
+typedef unsigned int OnigCaseFoldType; /* case fold flag */
+
+ONIG_EXTERN OnigCaseFoldType OnigDefaultCaseFoldFlag;
+
+/* #define ONIGENC_CASE_FOLD_HIRAGANA_KATAKANA  (1<<1) */
+/* #define ONIGENC_CASE_FOLD_KATAKANA_WIDTH     (1<<2) */
+#define ONIGENC_CASE_FOLD_TURKISH_AZERI         (1<<20)
+#define INTERNAL_ONIGENC_CASE_FOLD_MULTI_CHAR   (1<<30)
+
+#define ONIGENC_CASE_FOLD_MIN      INTERNAL_ONIGENC_CASE_FOLD_MULTI_CHAR
+#define ONIGENC_CASE_FOLD_DEFAULT  OnigDefaultCaseFoldFlag
+
+
+#define ONIGENC_MAX_COMP_CASE_FOLD_CODE_LEN       3
+#define ONIGENC_GET_CASE_FOLD_CODES_MAX_NUM      13
+/* 13 => Unicode:0x1ffc */
+
+/* code range */
+#define ONIGENC_CODE_RANGE_NUM(range)     ((int )range[0])
+#define ONIGENC_CODE_RANGE_FROM(range,i)  range[((i)*2) + 1]
+#define ONIGENC_CODE_RANGE_TO(range,i)    range[((i)*2) + 2]
+
+typedef struct {
+  int byte_len;  /* argument(original) character(s) byte length */
+  int code_len;  /* number of code */
+  OnigCodePoint code[ONIGENC_MAX_COMP_CASE_FOLD_CODE_LEN];
+} OnigCaseFoldCodeItem;
+
+typedef struct {
+  OnigCodePoint esc;
+  OnigCodePoint anychar;
+  OnigCodePoint anytime;
+  OnigCodePoint zero_or_one_time;
+  OnigCodePoint one_or_more_time;
+  OnigCodePoint anychar_anytime;
+} OnigMetaCharTableType;
+
+typedef int (*OnigApplyAllCaseFoldFunc)(OnigCodePoint from, OnigCodePoint* to, int to_len, void* arg);
+
+typedef struct OnigEncodingTypeST {
+  int    (*precise_mbc_enc_len)(const OnigUChar* p,const OnigUChar* e, struct OnigEncodingTypeST* enc);
+  const char*   name;
+  int           max_enc_len;
+  int           min_enc_len;
+  int    (*is_mbc_newline)(const OnigUChar* p, const OnigUChar* end, struct OnigEncodingTypeST* enc);
+  OnigCodePoint (*mbc_to_code)(const OnigUChar* p, const OnigUChar* end, struct OnigEncodingTypeST* enc);
+  int    (*code_to_mbclen)(OnigCodePoint code, struct OnigEncodingTypeST* enc);
+  int    (*code_to_mbc)(OnigCodePoint code, OnigUChar *buf, struct OnigEncodingTypeST* enc);
+  int    (*mbc_case_fold)(OnigCaseFoldType flag, const OnigUChar** pp, const OnigUChar* end, OnigUChar* to, struct OnigEncodingTypeST* enc);
+  int    (*apply_all_case_fold)(OnigCaseFoldType flag, OnigApplyAllCaseFoldFunc f, void* arg, struct OnigEncodingTypeST* enc);
+  int    (*get_case_fold_codes_by_str)(OnigCaseFoldType flag, const OnigUChar* p, const OnigUChar* end, OnigCaseFoldCodeItem acs[], struct OnigEncodingTypeST* enc);
+  int    (*property_name_to_ctype)(struct OnigEncodingTypeST* enc, OnigUChar* p, OnigUChar* end);
+  int    (*is_code_ctype)(OnigCodePoint code, OnigCtype ctype, struct OnigEncodingTypeST* enc);
+  int    (*get_ctype_code_range)(OnigCtype ctype, OnigCodePoint* sb_out, const OnigCodePoint* ranges[], struct OnigEncodingTypeST* enc);
+  OnigUChar* (*left_adjust_char_head)(const OnigUChar* start, const OnigUChar* p, const OnigUChar* end, struct OnigEncodingTypeST* enc);
+  int    (*is_allowed_reverse_match)(const OnigUChar* p, const OnigUChar* end, struct OnigEncodingTypeST* enc);
+  int ruby_encoding_index;
+} OnigEncodingType;
+
+typedef OnigEncodingType* OnigEncoding;
+
+ONIG_EXTERN OnigEncodingType OnigEncodingASCII;
+
+#define ONIG_ENCODING_ASCII        (&OnigEncodingASCII)
+
+#define ONIG_ENCODING_UNDEF    ((OnigEncoding )0)
+
+
+/* work size */
+#define ONIGENC_CODE_TO_MBC_MAXLEN       7
+#define ONIGENC_MBC_CASE_FOLD_MAXLEN    18
+/* 18: 6(max-byte) * 3(case-fold chars) */
+
+/* character types */
+#define ONIGENC_CTYPE_NEWLINE   0
+#define ONIGENC_CTYPE_ALPHA     1
+#define ONIGENC_CTYPE_BLANK     2
+#define ONIGENC_CTYPE_CNTRL     3
+#define ONIGENC_CTYPE_DIGIT     4
+#define ONIGENC_CTYPE_GRAPH     5
+#define ONIGENC_CTYPE_LOWER     6
+#define ONIGENC_CTYPE_PRINT     7
+#define ONIGENC_CTYPE_PUNCT     8
+#define ONIGENC_CTYPE_SPACE     9
+#define ONIGENC_CTYPE_UPPER    10
+#define ONIGENC_CTYPE_XDIGIT   11
+#define ONIGENC_CTYPE_WORD     12
+#define ONIGENC_CTYPE_ALNUM    13  /* alpha || digit */
+#define ONIGENC_CTYPE_ASCII    14
+#define ONIGENC_MAX_STD_CTYPE  ONIGENC_CTYPE_ASCII
+#define ONIGENC_CTYPE_SPECIAL_MASK        256
+#define ONIGENC_CTYPE_S            /* [\t\n\v\f\r\s] */ \
+    ONIGENC_CTYPE_SPECIAL_MASK | ONIGENC_CTYPE_SPACE
+#define ONIGENC_CTYPE_D            /* [0-9] */ \
+    ONIGENC_CTYPE_SPECIAL_MASK | ONIGENC_CTYPE_DIGIT
+#define ONIGENC_CTYPE_W            /* [0-9A-Za-z_] */ \
+    ONIGENC_CTYPE_SPECIAL_MASK | ONIGENC_CTYPE_WORD
+#define ONIGENC_CTYPE_SPECIAL_P(ctype) ((ctype) & ONIGENC_CTYPE_SPECIAL_MASK)
+
+
+#define onig_enc_len(enc,p,e)                ONIGENC_MBC_ENC_LEN(enc, p, e)
+
+#define ONIGENC_IS_UNDEF(enc)          ((enc) == ONIG_ENCODING_UNDEF)
+#define ONIGENC_IS_SINGLEBYTE(enc)     (ONIGENC_MBC_MAXLEN(enc) == 1)
+#define ONIGENC_IS_MBC_HEAD(enc,p,e)   (ONIGENC_MBC_ENC_LEN(enc,p,e) != 1)
+#define ONIGENC_IS_MBC_ASCII(p)           (*(p)   < 128)
+#define ONIGENC_IS_CODE_ASCII(code)       ((code) < 128)
+#define ONIGENC_IS_MBC_WORD(enc,s,end) \
+   ONIGENC_IS_CODE_WORD(enc,ONIGENC_MBC_TO_CODE(enc,s,end))
+
+
+#define ONIGENC_NAME(enc)                      ((enc)->name)
+
+#define ONIGENC_MBC_CASE_FOLD(enc,flag,pp,end,buf) \
+  (enc)->mbc_case_fold(flag,(const OnigUChar** )pp,end,buf,enc)
+#define ONIGENC_IS_ALLOWED_REVERSE_MATCH(enc,s,end) \
+        (enc)->is_allowed_reverse_match(s,end,enc)
+#define ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc,start,s,end) \
+        (enc)->left_adjust_char_head(start, s, end, enc)
+#define ONIGENC_APPLY_ALL_CASE_FOLD(enc,case_fold_flag,f,arg) \
+        (enc)->apply_all_case_fold(case_fold_flag,f,arg,enc)
+#define ONIGENC_GET_CASE_FOLD_CODES_BY_STR(enc,case_fold_flag,p,end,acs) \
+       (enc)->get_case_fold_codes_by_str(case_fold_flag,p,end,acs,enc)
+#define ONIGENC_STEP_BACK(enc,start,s,end,n) \
+        onigenc_step_back((enc),(start),(s),(end),(n))
+
+#define ONIGENC_CONSTRUCT_MBCLEN_CHARFOUND(n)   (n)
+#define ONIGENC_MBCLEN_CHARFOUND_P(r)           (0 < (r))
+#define ONIGENC_MBCLEN_CHARFOUND_LEN(r)         (r)
+
+#define ONIGENC_CONSTRUCT_MBCLEN_INVALID()      (-1)
+#define ONIGENC_MBCLEN_INVALID_P(r)             ((r) == -1)
+
+#define ONIGENC_CONSTRUCT_MBCLEN_NEEDMORE(n)    (-1-(n))
+#define ONIGENC_MBCLEN_NEEDMORE_P(r)            ((r) < -1)
+#define ONIGENC_MBCLEN_NEEDMORE_LEN(r)          (-1-(r))
+
+#define ONIGENC_PRECISE_MBC_ENC_LEN(enc,p,e)   (enc)->precise_mbc_enc_len(p,e,enc)
+
+ONIG_EXTERN
+int onigenc_mbclen_approximate P_((const OnigUChar* p,const OnigUChar* e, struct OnigEncodingTypeST* enc));
+
+#define ONIGENC_MBC_ENC_LEN(enc,p,e)           onigenc_mbclen_approximate(p,e,enc)
+#define ONIGENC_MBC_MAXLEN(enc)               ((enc)->max_enc_len)
+#define ONIGENC_MBC_MAXLEN_DIST(enc)           ONIGENC_MBC_MAXLEN(enc)
+#define ONIGENC_MBC_MINLEN(enc)               ((enc)->min_enc_len)
+#define ONIGENC_IS_MBC_NEWLINE(enc,p,end)      (enc)->is_mbc_newline((p),(end),enc)
+#define ONIGENC_MBC_TO_CODE(enc,p,end)         (enc)->mbc_to_code((p),(end),enc)
+#define ONIGENC_CODE_TO_MBCLEN(enc,code)       (enc)->code_to_mbclen(code,enc)
+#define ONIGENC_CODE_TO_MBC(enc,code,buf)      (enc)->code_to_mbc(code,buf,enc)
+#define ONIGENC_PROPERTY_NAME_TO_CTYPE(enc,p,end) \
+  (enc)->property_name_to_ctype(enc,p,end)
+
+#define ONIGENC_IS_CODE_CTYPE(enc,code,ctype)  (enc)->is_code_ctype(code,ctype,enc)
+
+#define ONIGENC_IS_CODE_NEWLINE(enc,code) \
+        ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_NEWLINE)
+#define ONIGENC_IS_CODE_GRAPH(enc,code) \
+        ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_GRAPH)
+#define ONIGENC_IS_CODE_PRINT(enc,code) \
+        ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_PRINT)
+#define ONIGENC_IS_CODE_ALNUM(enc,code) \
+        ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_ALNUM)
+#define ONIGENC_IS_CODE_ALPHA(enc,code) \
+        ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_ALPHA)
+#define ONIGENC_IS_CODE_LOWER(enc,code) \
+        ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_LOWER)
+#define ONIGENC_IS_CODE_UPPER(enc,code) \
+        ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_UPPER)
+#define ONIGENC_IS_CODE_CNTRL(enc,code) \
+        ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_CNTRL)
+#define ONIGENC_IS_CODE_PUNCT(enc,code) \
+        ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_PUNCT)
+#define ONIGENC_IS_CODE_SPACE(enc,code) \
+        ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_SPACE)
+#define ONIGENC_IS_CODE_BLANK(enc,code) \
+        ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_BLANK)
+#define ONIGENC_IS_CODE_DIGIT(enc,code) \
+        ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_DIGIT)
+#define ONIGENC_IS_CODE_XDIGIT(enc,code) \
+        ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_XDIGIT)
+#define ONIGENC_IS_CODE_WORD(enc,code) \
+        ONIGENC_IS_CODE_CTYPE(enc,code,ONIGENC_CTYPE_WORD)
+
+#define ONIGENC_GET_CTYPE_CODE_RANGE(enc,ctype,sbout,ranges) \
+        (enc)->get_ctype_code_range(ctype,sbout,ranges,enc)
+
+ONIG_EXTERN
+OnigUChar* onigenc_step_back P_((OnigEncoding enc, const OnigUChar* start, const OnigUChar* s, const OnigUChar* end, int n));
+
+
+/* encoding API */
+ONIG_EXTERN
+int onigenc_init P_((void));
+ONIG_EXTERN
+int onigenc_set_default_encoding P_((OnigEncoding enc));
+ONIG_EXTERN
+OnigEncoding onigenc_get_default_encoding P_((void));
+ONIG_EXTERN
+void  onigenc_set_default_caseconv_table P_((const OnigUChar* table));
+ONIG_EXTERN
+OnigUChar* onigenc_get_right_adjust_char_head_with_prev P_((OnigEncoding enc, const OnigUChar* start, const OnigUChar* s, const OnigUChar* end, const OnigUChar** prev));
+ONIG_EXTERN
+OnigUChar* onigenc_get_prev_char_head P_((OnigEncoding enc, const OnigUChar* start, const OnigUChar* s, const OnigUChar* end));
+ONIG_EXTERN
+OnigUChar* onigenc_get_left_adjust_char_head P_((OnigEncoding enc, const OnigUChar* start, const OnigUChar* s, const OnigUChar* end));
+ONIG_EXTERN
+OnigUChar* onigenc_get_right_adjust_char_head P_((OnigEncoding enc, const OnigUChar* start, const OnigUChar* s, const OnigUChar* end));
+ONIG_EXTERN
+int onigenc_strlen P_((OnigEncoding enc, const OnigUChar* p, const OnigUChar* end));
+ONIG_EXTERN
+int onigenc_strlen_null P_((OnigEncoding enc, const OnigUChar* p));
+ONIG_EXTERN
+int onigenc_str_bytelen_null P_((OnigEncoding enc, const OnigUChar* p));
+
+
+
+/* PART: regular expression */
+
+/* config parameters */
+#define ONIG_NREGION                          10
+#define ONIG_MAX_BACKREF_NUM                1000
+#define ONIG_MAX_REPEAT_NUM               100000
+#define ONIG_MAX_MULTI_BYTE_RANGES_NUM     10000
+/* constants */
+#define ONIG_MAX_ERROR_MESSAGE_LEN            90
+
+typedef unsigned int        OnigOptionType;
+
+#define ONIG_OPTION_DEFAULT            ONIG_OPTION_NONE
+
+/* options */
+#define ONIG_OPTION_NONE                 0U
+#define ONIG_OPTION_IGNORECASE           1U
+#define ONIG_OPTION_EXTEND               (ONIG_OPTION_IGNORECASE         << 1)
+#define ONIG_OPTION_MULTILINE            (ONIG_OPTION_EXTEND             << 1)
+#define ONIG_OPTION_SINGLELINE           (ONIG_OPTION_MULTILINE          << 1)
+#define ONIG_OPTION_FIND_LONGEST         (ONIG_OPTION_SINGLELINE         << 1)
+#define ONIG_OPTION_FIND_NOT_EMPTY       (ONIG_OPTION_FIND_LONGEST       << 1)
+#define ONIG_OPTION_NEGATE_SINGLELINE    (ONIG_OPTION_FIND_NOT_EMPTY     << 1)
+#define ONIG_OPTION_DONT_CAPTURE_GROUP   (ONIG_OPTION_NEGATE_SINGLELINE  << 1)
+#define ONIG_OPTION_CAPTURE_GROUP        (ONIG_OPTION_DONT_CAPTURE_GROUP << 1)
+/* options (search time) */
+#define ONIG_OPTION_NOTBOL               (ONIG_OPTION_CAPTURE_GROUP << 1)
+#define ONIG_OPTION_NOTEOL               (ONIG_OPTION_NOTBOL << 1)
+#define ONIG_OPTION_POSIX_REGION         (ONIG_OPTION_NOTEOL << 1)
+#define ONIG_OPTION_MAXBIT               ONIG_OPTION_POSIX_REGION  /* limit */
+
+#define ONIG_OPTION_ON(options,regopt)      ((options) |= (regopt))
+#define ONIG_OPTION_OFF(options,regopt)     ((options) &= ~(regopt))
+#define ONIG_IS_OPTION_ON(options,option)   ((options) & (option))
+
+/* syntax */
+typedef struct {
+  unsigned int   op;
+  unsigned int   op2;
+  unsigned int   behavior;
+  OnigOptionType options;   /* default option */
+  OnigMetaCharTableType meta_char_table;
+} OnigSyntaxType;
+
+ONIG_EXTERN const OnigSyntaxType OnigSyntaxASIS;
+ONIG_EXTERN const OnigSyntaxType OnigSyntaxPosixBasic;
+ONIG_EXTERN const OnigSyntaxType OnigSyntaxPosixExtended;
+ONIG_EXTERN const OnigSyntaxType OnigSyntaxEmacs;
+ONIG_EXTERN const OnigSyntaxType OnigSyntaxGrep;
+ONIG_EXTERN const OnigSyntaxType OnigSyntaxGnuRegex;
+ONIG_EXTERN const OnigSyntaxType OnigSyntaxJava;
+ONIG_EXTERN const OnigSyntaxType OnigSyntaxPerl;
+ONIG_EXTERN const OnigSyntaxType OnigSyntaxPerl_NG;
+ONIG_EXTERN const OnigSyntaxType OnigSyntaxRuby;
+
+/* predefined syntaxes (see regsyntax.c) */
+#define ONIG_SYNTAX_ASIS               (&OnigSyntaxASIS)
+#define ONIG_SYNTAX_POSIX_BASIC        (&OnigSyntaxPosixBasic)
+#define ONIG_SYNTAX_POSIX_EXTENDED     (&OnigSyntaxPosixExtended)
+#define ONIG_SYNTAX_EMACS              (&OnigSyntaxEmacs)
+#define ONIG_SYNTAX_GREP               (&OnigSyntaxGrep)
+#define ONIG_SYNTAX_GNU_REGEX          (&OnigSyntaxGnuRegex)
+#define ONIG_SYNTAX_JAVA               (&OnigSyntaxJava)
+#define ONIG_SYNTAX_PERL               (&OnigSyntaxPerl)
+#define ONIG_SYNTAX_PERL_NG            (&OnigSyntaxPerl_NG)
+#define ONIG_SYNTAX_RUBY               (&OnigSyntaxRuby)
+
+/* default syntax */
+ONIG_EXTERN const OnigSyntaxType*   OnigDefaultSyntax;
+#define ONIG_SYNTAX_DEFAULT   OnigDefaultSyntax
+
+/* syntax (operators) */
+#define ONIG_SYN_OP_VARIABLE_META_CHARACTERS    (1U<<0)
+#define ONIG_SYN_OP_DOT_ANYCHAR                 (1U<<1)   /* . */
+#define ONIG_SYN_OP_ASTERISK_ZERO_INF           (1U<<2)   /* * */
+#define ONIG_SYN_OP_ESC_ASTERISK_ZERO_INF       (1U<<3)
+#define ONIG_SYN_OP_PLUS_ONE_INF                (1U<<4)   /* + */
+#define ONIG_SYN_OP_ESC_PLUS_ONE_INF            (1U<<5)
+#define ONIG_SYN_OP_QMARK_ZERO_ONE              (1U<<6)   /* ? */
+#define ONIG_SYN_OP_ESC_QMARK_ZERO_ONE          (1U<<7)
+#define ONIG_SYN_OP_BRACE_INTERVAL              (1U<<8)   /* {lower,upper} */
+#define ONIG_SYN_OP_ESC_BRACE_INTERVAL          (1U<<9)   /* \{lower,upper\} */
+#define ONIG_SYN_OP_VBAR_ALT                    (1U<<10)   /* | */
+#define ONIG_SYN_OP_ESC_VBAR_ALT                (1U<<11)  /* \| */
+#define ONIG_SYN_OP_LPAREN_SUBEXP               (1U<<12)  /* (...)   */
+#define ONIG_SYN_OP_ESC_LPAREN_SUBEXP           (1U<<13)  /* \(...\) */
+#define ONIG_SYN_OP_ESC_AZ_BUF_ANCHOR           (1U<<14)  /* \A, \Z, \z */
+#define ONIG_SYN_OP_ESC_CAPITAL_G_BEGIN_ANCHOR  (1U<<15)  /* \G     */
+#define ONIG_SYN_OP_DECIMAL_BACKREF             (1U<<16)  /* \num   */
+#define ONIG_SYN_OP_BRACKET_CC                  (1U<<17)  /* [...]  */
+#define ONIG_SYN_OP_ESC_W_WORD                  (1U<<18)  /* \w, \W */
+#define ONIG_SYN_OP_ESC_LTGT_WORD_BEGIN_END     (1U<<19)  /* \<. \> */
+#define ONIG_SYN_OP_ESC_B_WORD_BOUND            (1U<<20)  /* \b, \B */
+#define ONIG_SYN_OP_ESC_S_WHITE_SPACE           (1U<<21)  /* \s, \S */
+#define ONIG_SYN_OP_ESC_D_DIGIT                 (1U<<22)  /* \d, \D */
+#define ONIG_SYN_OP_LINE_ANCHOR                 (1U<<23)  /* ^, $   */
+#define ONIG_SYN_OP_POSIX_BRACKET               (1U<<24)  /* [:xxxx:] */
+#define ONIG_SYN_OP_QMARK_NON_GREEDY            (1U<<25)  /* ??,*?,+?,{n,m}? */
+#define ONIG_SYN_OP_ESC_CONTROL_CHARS           (1U<<26)  /* \n,\r,\t,\a ... */
+#define ONIG_SYN_OP_ESC_C_CONTROL               (1U<<27)  /* \cx  */
+#define ONIG_SYN_OP_ESC_OCTAL3                  (1U<<28)  /* \OOO */
+#define ONIG_SYN_OP_ESC_X_HEX2                  (1U<<29)  /* \xHH */
+#define ONIG_SYN_OP_ESC_X_BRACE_HEX8            (1U<<30)  /* \x{7HHHHHHH} */
+
+#define ONIG_SYN_OP2_ESC_CAPITAL_Q_QUOTE        (1U<<0)  /* \Q...\E */
+#define ONIG_SYN_OP2_QMARK_GROUP_EFFECT         (1U<<1)  /* (?...) */
+#define ONIG_SYN_OP2_OPTION_PERL                (1U<<2)  /* (?imsx),(?-imsx) */
+#define ONIG_SYN_OP2_OPTION_RUBY                (1U<<3)  /* (?imx), (?-imx)  */
+#define ONIG_SYN_OP2_PLUS_POSSESSIVE_REPEAT     (1U<<4)  /* ?+,*+,++ */
+#define ONIG_SYN_OP2_PLUS_POSSESSIVE_INTERVAL   (1U<<5)  /* {n,m}+   */
+#define ONIG_SYN_OP2_CCLASS_SET_OP              (1U<<6)  /* [...&&..[..]..] */
+#define ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP       (1U<<7)  /* (?<name>...) */
+#define ONIG_SYN_OP2_ESC_K_NAMED_BACKREF        (1U<<8)  /* \k<name> */
+#define ONIG_SYN_OP2_ESC_G_SUBEXP_CALL          (1U<<9)  /* \g<name>, \g<n> */
+#define ONIG_SYN_OP2_ATMARK_CAPTURE_HISTORY     (1U<<10) /* (?@..),(?@<x>..) */
+#define ONIG_SYN_OP2_ESC_CAPITAL_C_BAR_CONTROL  (1U<<11) /* \C-x */
+#define ONIG_SYN_OP2_ESC_CAPITAL_M_BAR_META     (1U<<12) /* \M-x */
+#define ONIG_SYN_OP2_ESC_V_VTAB                 (1U<<13) /* \v as VTAB */
+#define ONIG_SYN_OP2_ESC_U_HEX4                 (1U<<14) /* \uHHHH */
+#define ONIG_SYN_OP2_ESC_GNU_BUF_ANCHOR         (1U<<15) /* \`, \' */
+#define ONIG_SYN_OP2_ESC_P_BRACE_CHAR_PROPERTY  (1U<<16) /* \p{...}, \P{...} */
+#define ONIG_SYN_OP2_ESC_P_BRACE_CIRCUMFLEX_NOT (1U<<17) /* \p{^..}, \P{^..} */
+/* #define ONIG_SYN_OP2_CHAR_PROPERTY_PREFIX_IS (1U<<18) */
+#define ONIG_SYN_OP2_ESC_H_XDIGIT               (1U<<19) /* \h, \H */
+#define ONIG_SYN_OP2_INEFFECTIVE_ESCAPE         (1U<<20) /* \ */
+
+/* syntax (behavior) */
+#define ONIG_SYN_CONTEXT_INDEP_ANCHORS           (1U<<31) /* not implemented */
+#define ONIG_SYN_CONTEXT_INDEP_REPEAT_OPS        (1U<<0)  /* ?, *, +, {n,m} */
+#define ONIG_SYN_CONTEXT_INVALID_REPEAT_OPS      (1U<<1)  /* error or ignore */
+#define ONIG_SYN_ALLOW_UNMATCHED_CLOSE_SUBEXP    (1U<<2)  /* ...)... */
+#define ONIG_SYN_ALLOW_INVALID_INTERVAL          (1U<<3)  /* {??? */
+#define ONIG_SYN_ALLOW_INTERVAL_LOW_ABBREV       (1U<<4)  /* {,n} => {0,n} */
+#define ONIG_SYN_STRICT_CHECK_BACKREF            (1U<<5)  /* /(\1)/,/\1()/ ..*/
+#define ONIG_SYN_DIFFERENT_LEN_ALT_LOOK_BEHIND   (1U<<6)  /* (?<=a|bc) */
+#define ONIG_SYN_CAPTURE_ONLY_NAMED_GROUP        (1U<<7)  /* see doc/RE */
+#define ONIG_SYN_ALLOW_MULTIPLEX_DEFINITION_NAME (1U<<8)  /* (?<x>)(?<x>) */
+#define ONIG_SYN_FIXED_INTERVAL_IS_GREEDY_ONLY   (1U<<9)  /* a{n}?=(?:a{n})? */
+
+/* syntax (behavior) in char class [...] */
+#define ONIG_SYN_NOT_NEWLINE_IN_NEGATIVE_CC      (1U<<20) /* [^...] */
+#define ONIG_SYN_BACKSLASH_ESCAPE_IN_CC          (1U<<21) /* [..\w..] etc.. */
+#define ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC         (1U<<22)
+#define ONIG_SYN_ALLOW_DOUBLE_RANGE_OP_IN_CC     (1U<<23) /* [0-9-a]=[0-9\-a] */
+/* syntax (behavior) warning */
+#define ONIG_SYN_WARN_CC_OP_NOT_ESCAPED          (1U<<24) /* [,-,] */
+#define ONIG_SYN_WARN_REDUNDANT_NESTED_REPEAT    (1U<<25) /* (?:a*)+ */
+#define ONIG_SYN_WARN_CC_DUP                     (1U<<26) /* [aa] */
+
+/* meta character specifiers (onig_set_meta_char()) */
+#define ONIG_META_CHAR_ESCAPE               0
+#define ONIG_META_CHAR_ANYCHAR              1
+#define ONIG_META_CHAR_ANYTIME              2
+#define ONIG_META_CHAR_ZERO_OR_ONE_TIME     3
+#define ONIG_META_CHAR_ONE_OR_MORE_TIME     4
+#define ONIG_META_CHAR_ANYCHAR_ANYTIME      5
+
+#define ONIG_INEFFECTIVE_META_CHAR          0
+
+/* error codes */
+#define ONIG_IS_PATTERN_ERROR(ecode)   ((ecode) <= -100 && (ecode) > -1000)
+/* normal return */
+#define ONIG_NORMAL                                            0
+#define ONIG_MISMATCH                                         -1
+#define ONIG_NO_SUPPORT_CONFIG                                -2
+
+/* internal error */
+#define ONIGERR_MEMORY                                         -5
+#define ONIGERR_TYPE_BUG                                       -6
+#define ONIGERR_PARSER_BUG                                    -11
+#define ONIGERR_STACK_BUG                                     -12
+#define ONIGERR_UNDEFINED_BYTECODE                            -13
+#define ONIGERR_UNEXPECTED_BYTECODE                           -14
+#define ONIGERR_MATCH_STACK_LIMIT_OVER                        -15
+#define ONIGERR_DEFAULT_ENCODING_IS_NOT_SETTED                -21
+#define ONIGERR_SPECIFIED_ENCODING_CANT_CONVERT_TO_WIDE_CHAR  -22
+/* general error */
+#define ONIGERR_INVALID_ARGUMENT                              -30
+/* syntax error */
+#define ONIGERR_END_PATTERN_AT_LEFT_BRACE                    -100
+#define ONIGERR_END_PATTERN_AT_LEFT_BRACKET                  -101
+#define ONIGERR_EMPTY_CHAR_CLASS                             -102
+#define ONIGERR_PREMATURE_END_OF_CHAR_CLASS                  -103
+#define ONIGERR_END_PATTERN_AT_ESCAPE                        -104
+#define ONIGERR_END_PATTERN_AT_META                          -105
+#define ONIGERR_END_PATTERN_AT_CONTROL                       -106
+#define ONIGERR_META_CODE_SYNTAX                             -108
+#define ONIGERR_CONTROL_CODE_SYNTAX                          -109
+#define ONIGERR_CHAR_CLASS_VALUE_AT_END_OF_RANGE             -110
+#define ONIGERR_CHAR_CLASS_VALUE_AT_START_OF_RANGE           -111
+#define ONIGERR_UNMATCHED_RANGE_SPECIFIER_IN_CHAR_CLASS      -112
+#define ONIGERR_TARGET_OF_REPEAT_OPERATOR_NOT_SPECIFIED      -113
+#define ONIGERR_TARGET_OF_REPEAT_OPERATOR_INVALID            -114
+#define ONIGERR_NESTED_REPEAT_OPERATOR                       -115
+#define ONIGERR_UNMATCHED_CLOSE_PARENTHESIS                  -116
+#define ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS       -117
+#define ONIGERR_END_PATTERN_IN_GROUP                         -118
+#define ONIGERR_UNDEFINED_GROUP_OPTION                       -119
+#define ONIGERR_INVALID_POSIX_BRACKET_TYPE                   -121
+#define ONIGERR_INVALID_LOOK_BEHIND_PATTERN                  -122
+#define ONIGERR_INVALID_REPEAT_RANGE_PATTERN                 -123
+/* values error (syntax error) */
+#define ONIGERR_TOO_BIG_NUMBER                               -200
+#define ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE              -201
+#define ONIGERR_UPPER_SMALLER_THAN_LOWER_IN_REPEAT_RANGE     -202
+#define ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS                    -203
+#define ONIGERR_MISMATCH_CODE_LENGTH_IN_CLASS_RANGE          -204
+#define ONIGERR_TOO_MANY_MULTI_BYTE_RANGES                   -205
+#define ONIGERR_TOO_SHORT_MULTI_BYTE_STRING                  -206
+#define ONIGERR_TOO_BIG_BACKREF_NUMBER                       -207
+#define ONIGERR_INVALID_BACKREF                              -208
+#define ONIGERR_NUMBERED_BACKREF_OR_CALL_NOT_ALLOWED         -209
+#define ONIGERR_TOO_LONG_WIDE_CHAR_VALUE                     -212
+#define ONIGERR_EMPTY_GROUP_NAME                             -214
+#define ONIGERR_INVALID_GROUP_NAME                           -215
+#define ONIGERR_INVALID_CHAR_IN_GROUP_NAME                   -216
+#define ONIGERR_UNDEFINED_NAME_REFERENCE                     -217
+#define ONIGERR_UNDEFINED_GROUP_REFERENCE                    -218
+#define ONIGERR_MULTIPLEX_DEFINED_NAME                       -219
+#define ONIGERR_MULTIPLEX_DEFINITION_NAME_CALL               -220
+#define ONIGERR_NEVER_ENDING_RECURSION                       -221
+#define ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY        -222
+#define ONIGERR_INVALID_CHAR_PROPERTY_NAME                   -223
+#define ONIGERR_INVALID_CODE_POINT_VALUE                     -400
+#define ONIGERR_INVALID_WIDE_CHAR_VALUE                      -400
+#define ONIGERR_TOO_BIG_WIDE_CHAR_VALUE                      -401
+#define ONIGERR_NOT_SUPPORTED_ENCODING_COMBINATION           -402
+#define ONIGERR_INVALID_COMBINATION_OF_OPTIONS               -403
+
+/* errors related to thread */
+#define ONIGERR_OVER_THREAD_PASS_LIMIT_COUNT                -1001
+
+
+/* must be smaller than BIT_STATUS_BITS_NUM (unsigned int * 8) */
+#define ONIG_MAX_CAPTURE_HISTORY_GROUP   31
+#define ONIG_IS_CAPTURE_HISTORY_GROUP(r, i) \
+  ((i) <= ONIG_MAX_CAPTURE_HISTORY_GROUP && (r)->list && (r)->list[i])
+
+typedef struct OnigCaptureTreeNodeStruct {
+  int group;   /* group number */
+  int beg;
+  int end;
+  int allocated;
+  int num_childs;
+  struct OnigCaptureTreeNodeStruct** childs;
+} OnigCaptureTreeNode;
+
+/* match result region type */
+struct re_registers {
+  int  allocated;
+  int  num_regs;
+  int* beg;
+  int* end;
+  /* extended */
+  OnigCaptureTreeNode* history_root;  /* capture history tree root */
+};
+
+/* capture tree traverse */
+#define ONIG_TRAVERSE_CALLBACK_AT_FIRST   1
+#define ONIG_TRAVERSE_CALLBACK_AT_LAST    2
+#define ONIG_TRAVERSE_CALLBACK_AT_BOTH \
+  ( ONIG_TRAVERSE_CALLBACK_AT_FIRST | ONIG_TRAVERSE_CALLBACK_AT_LAST )
+
+
+#define ONIG_REGION_NOTPOS            -1
+
+typedef struct re_registers   OnigRegion;
+
+typedef struct {
+  OnigEncoding enc;
+  OnigUChar* par;
+  OnigUChar* par_end;
+} OnigErrorInfo;
+
+typedef struct {
+  int lower;
+  int upper;
+} OnigRepeatRange;
+
+typedef void (*OnigWarnFunc) P_((const char* s));
+extern void onig_null_warn P_((const char* s));
+#define ONIG_NULL_WARN       onig_null_warn
+
+#define ONIG_CHAR_TABLE_SIZE   256
+
+/* regex_t state */
+#define ONIG_STATE_NORMAL              0
+#define ONIG_STATE_SEARCHING           1
+#define ONIG_STATE_COMPILING          -1
+#define ONIG_STATE_MODIFY             -2
+
+#define ONIG_STATE(reg) \
+  ((reg)->state > 0 ? ONIG_STATE_SEARCHING : (reg)->state)
+
+typedef struct re_pattern_buffer {
+  /* common members of BBuf(bytes-buffer) */
+  unsigned char* p;         /* compiled pattern */
+  unsigned int used;        /* used space for p */
+  unsigned int alloc;       /* allocated space for p */
+
+  int state;                     /* normal, searching, compiling */
+  int num_mem;                   /* used memory(...) num counted from 1 */
+  int num_repeat;                /* OP_REPEAT/OP_REPEAT_NG id-counter */
+  int num_null_check;            /* OP_NULL_CHECK_START/END id counter */
+  int num_comb_exp_check;        /* combination explosion check */
+  int num_call;                  /* number of subexp call */
+  unsigned int capture_history;  /* (?@...) flag (1-31) */
+  unsigned int bt_mem_start;     /* need backtrack flag */
+  unsigned int bt_mem_end;       /* need backtrack flag */
+  int stack_pop_level;
+  int repeat_range_alloc;
+  OnigRepeatRange* repeat_range;
+
+  OnigEncoding      enc;
+  OnigOptionType    options;
+  const OnigSyntaxType* syntax;
+  OnigCaseFoldType  case_fold_flag;
+  void*             name_table;
+
+  /* optimization info (string search, char-map and anchors) */
+  int            optimize;          /* optimize flag */
+  int            threshold_len;     /* search str-length for apply optimize */
+  int            anchor;            /* BEGIN_BUF, BEGIN_POS, (SEMI_)END_BUF */
+  OnigDistance   anchor_dmin;       /* (SEMI_)END_BUF anchor distance */
+  OnigDistance   anchor_dmax;       /* (SEMI_)END_BUF anchor distance */
+  int            sub_anchor;        /* start-anchor for exact or map */
+  unsigned char *exact;
+  unsigned char *exact_end;
+  unsigned char  map[ONIG_CHAR_TABLE_SIZE]; /* used as BM skip or char-map */
+  int           *int_map;                   /* BM skip for exact_len > 255 */
+  int           *int_map_backward;          /* BM skip for backward search */
+  OnigDistance   dmin;                      /* min-distance of exact or map */
+  OnigDistance   dmax;                      /* max-distance of exact or map */
+
+  /* regex_t link chain */
+  struct re_pattern_buffer* chain;  /* escape compile-conflict */
+} OnigRegexType;
+
+typedef OnigRegexType*  OnigRegex;
+
+#ifndef ONIG_ESCAPE_REGEX_T_COLLISION
+  typedef OnigRegexType  regex_t;
+#endif
+
+
+typedef struct {
+  int             num_of_elements;
+  OnigEncoding    pattern_enc;
+  OnigEncoding    target_enc;
+  OnigSyntaxType* syntax;
+  OnigOptionType  option;
+  OnigCaseFoldType   case_fold_flag;
+} OnigCompileInfo;
+
+/* Oniguruma Native API */
+ONIG_EXTERN
+int onig_init P_((void));
+ONIG_EXTERN
+int onig_error_code_to_str PV_((OnigUChar* s, int err_code, ...));
+ONIG_EXTERN
+void onig_set_warn_func P_((OnigWarnFunc f));
+ONIG_EXTERN
+void onig_set_verb_warn_func P_((OnigWarnFunc f));
+ONIG_EXTERN
+int onig_new P_((OnigRegex*, const OnigUChar* pattern, const OnigUChar* pattern_end, OnigOptionType option, OnigEncoding enc, const OnigSyntaxType* syntax, OnigErrorInfo* einfo));
+ONIG_EXTERN
+int  onig_reg_init P_((regex_t* reg, OnigOptionType option, OnigCaseFoldType case_fold_flag, OnigEncoding enc, const OnigSyntaxType* syntax));
+ONIG_EXTERN
+int onig_new_without_alloc P_((OnigRegex, const OnigUChar* pattern, const OnigUChar* pattern_end, OnigOptionType option, OnigEncoding enc, OnigSyntaxType* syntax, OnigErrorInfo* einfo));
+ONIG_EXTERN
+int onig_new_deluxe P_((OnigRegex* reg, const OnigUChar* pattern, const OnigUChar* pattern_end, OnigCompileInfo* ci, OnigErrorInfo* einfo));
+ONIG_EXTERN
+void onig_free P_((OnigRegex));
+ONIG_EXTERN
+void onig_free_body P_((OnigRegex));
+ONIG_EXTERN
+int onig_recompile P_((OnigRegex, const OnigUChar* pattern, const OnigUChar* pattern_end, OnigOptionType option, OnigEncoding enc, OnigSyntaxType* syntax, OnigErrorInfo* einfo));
+ONIG_EXTERN
+int onig_recompile_deluxe P_((OnigRegex reg, const OnigUChar* pattern, const OnigUChar* pattern_end, OnigCompileInfo* ci, OnigErrorInfo* einfo));
+ONIG_EXTERN
+long onig_search P_((OnigRegex, const OnigUChar* str, const OnigUChar* end, const OnigUChar* start, const OnigUChar* range, OnigRegion* region, OnigOptionType option));
+ONIG_EXTERN
+long onig_match P_((OnigRegex, const OnigUChar* str, const OnigUChar* end, const OnigUChar* at, OnigRegion* region, OnigOptionType option));
+ONIG_EXTERN
+OnigRegion* onig_region_new P_((void));
+ONIG_EXTERN
+void onig_region_init P_((OnigRegion* region));
+ONIG_EXTERN
+void onig_region_free P_((OnigRegion* region, int free_self));
+ONIG_EXTERN
+void onig_region_copy P_((OnigRegion* to, OnigRegion* from));
+ONIG_EXTERN
+void onig_region_clear P_((OnigRegion* region));
+ONIG_EXTERN
+int onig_region_resize P_((OnigRegion* region, int n));
+ONIG_EXTERN
+int onig_region_set P_((OnigRegion* region, int at, int beg, int end));
+ONIG_EXTERN
+int onig_name_to_group_numbers P_((OnigRegex reg, const OnigUChar* name, const OnigUChar* name_end, int** nums));
+ONIG_EXTERN
+int onig_name_to_backref_number P_((OnigRegex reg, const OnigUChar* name, const OnigUChar* name_end, OnigRegion *region));
+ONIG_EXTERN
+int onig_foreach_name P_((OnigRegex reg, int (*func)(const OnigUChar*, const OnigUChar*,int,int*,OnigRegex,void*), void* arg));
+ONIG_EXTERN
+int onig_number_of_names P_((OnigRegex reg));
+ONIG_EXTERN
+int onig_number_of_captures P_((OnigRegex reg));
+ONIG_EXTERN
+int onig_number_of_capture_histories P_((OnigRegex reg));
+ONIG_EXTERN
+OnigCaptureTreeNode* onig_get_capture_tree P_((OnigRegion* region));
+ONIG_EXTERN
+int onig_capture_tree_traverse P_((OnigRegion* region, int at, int(*callback_func)(int,int,int,int,int,void*), void* arg));
+ONIG_EXTERN
+int onig_noname_group_capture_is_active P_((OnigRegex reg));
+ONIG_EXTERN
+OnigEncoding onig_get_encoding P_((OnigRegex reg));
+ONIG_EXTERN
+OnigOptionType onig_get_options P_((OnigRegex reg));
+ONIG_EXTERN
+OnigCaseFoldType onig_get_case_fold_flag P_((OnigRegex reg));
+ONIG_EXTERN
+const OnigSyntaxType* onig_get_syntax P_((OnigRegex reg));
+ONIG_EXTERN
+int onig_set_default_syntax P_((const OnigSyntaxType* syntax));
+ONIG_EXTERN
+void onig_copy_syntax P_((OnigSyntaxType* to, const OnigSyntaxType* from));
+ONIG_EXTERN
+unsigned int onig_get_syntax_op P_((OnigSyntaxType* syntax));
+ONIG_EXTERN
+unsigned int onig_get_syntax_op2 P_((OnigSyntaxType* syntax));
+ONIG_EXTERN
+unsigned int onig_get_syntax_behavior P_((OnigSyntaxType* syntax));
+ONIG_EXTERN
+OnigOptionType onig_get_syntax_options P_((OnigSyntaxType* syntax));
+ONIG_EXTERN
+void onig_set_syntax_op P_((OnigSyntaxType* syntax, unsigned int op));
+ONIG_EXTERN
+void onig_set_syntax_op2 P_((OnigSyntaxType* syntax, unsigned int op2));
+ONIG_EXTERN
+void onig_set_syntax_behavior P_((OnigSyntaxType* syntax, unsigned int behavior));
+ONIG_EXTERN
+void onig_set_syntax_options P_((OnigSyntaxType* syntax, OnigOptionType options));
+ONIG_EXTERN
+int onig_set_meta_char P_((OnigSyntaxType* syntax, unsigned int what, OnigCodePoint code));
+ONIG_EXTERN
+void onig_copy_encoding P_((OnigEncoding to, OnigEncoding from));
+ONIG_EXTERN
+OnigCaseFoldType onig_get_default_case_fold_flag P_((void));
+ONIG_EXTERN
+int onig_set_default_case_fold_flag P_((OnigCaseFoldType case_fold_flag));
+ONIG_EXTERN
+unsigned int onig_get_match_stack_limit_size P_((void));
+ONIG_EXTERN
+int onig_set_match_stack_limit_size P_((unsigned int size));
+ONIG_EXTERN
+int onig_end P_((void));
+ONIG_EXTERN
+const char* onig_version P_((void));
+ONIG_EXTERN
+const char* onig_copyright P_((void));
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility pop
+#endif
+
+#ifdef __cplusplus
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}
+#endif
+
+#endif /* ONIGURUMA_H */
diff --git a/include/ruby/re.h b/include/ruby/re.h
new file mode 100644
index 0000000..96156d8
--- /dev/null
+++ b/include/ruby/re.h
@@ -0,0 +1,75 @@
+/**********************************************************************
+
+  re.h -
+
+  $Author: nobu $
+  created at: Thu Sep 30 14:18:32 JST 1993
+
+  Copyright (C) 1993-2007 Yukihiro Matsumoto
+
+**********************************************************************/
+
+#ifndef RUBY_RE_H
+#define RUBY_RE_H 1
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+#include <sys/types.h>
+#include <stdio.h>
+
+#include "ruby/regex.h"
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility push(default)
+#endif
+
+typedef struct re_pattern_buffer Regexp;
+
+struct rmatch_offset {
+    long beg;
+    long end;
+};
+
+struct rmatch {
+    struct re_registers regs;
+
+    int char_offset_updated;
+    int char_offset_num_allocated;
+    struct rmatch_offset *char_offset;
+};
+
+struct RMatch {
+    struct RBasic basic;
+    VALUE str;
+    struct rmatch *rmatch;
+    VALUE regexp;  /* RRegexp */
+};
+
+#define RMATCH(obj)  (R_CAST(RMatch)(obj))
+#define RMATCH_REGS(obj)  (&(R_CAST(RMatch)(obj))->rmatch->regs)
+
+VALUE rb_reg_regcomp(VALUE);
+long rb_reg_search(VALUE, VALUE, long, int);
+VALUE rb_reg_regsub(VALUE, VALUE, struct re_registers *, VALUE);
+long rb_reg_adjust_startpos(VALUE, VALUE, long, int);
+void rb_match_busy(VALUE);
+VALUE rb_reg_quote(VALUE);
+regex_t *rb_reg_prepare_re(VALUE re, VALUE str);
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility pop
+#endif
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+#endif /* RUBY_RE_H */
diff --git a/include/ruby/regex.h b/include/ruby/regex.h
new file mode 100644
index 0000000..fcd2d64
--- /dev/null
+++ b/include/ruby/regex.h
@@ -0,0 +1,50 @@
+/**********************************************************************
+
+  regex.h -
+
+  $Author: nobu $
+
+  Copyright (C) 1993-2007 Yukihiro Matsumoto
+
+**********************************************************************/
+
+#ifndef ONIGURUMA_REGEX_H
+#define ONIGURUMA_REGEX_H 1
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+#ifdef RUBY
+#include "ruby/oniguruma.h"
+#else
+#include "oniguruma.h"
+#endif
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility push(default)
+#endif
+
+#ifndef ONIG_RUBY_M17N
+
+ONIG_EXTERN OnigEncoding    OnigEncDefaultCharEncoding;
+
+#define mbclen(p,e,enc)  rb_enc_mbclen((p),(e),(enc))
+
+#endif /* ifndef ONIG_RUBY_M17N */
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility pop
+#endif
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+#endif /* ONIGURUMA_REGEX_H */
diff --git a/include/ruby/ruby.h b/include/ruby/ruby.h
new file mode 100644
index 0000000..3b72f8c
--- /dev/null
+++ b/include/ruby/ruby.h
@@ -0,0 +1,1490 @@
+/**********************************************************************
+
+  ruby/ruby.h -
+
+  $Author: naruse $
+  created at: Thu Jun 10 14:26:32 JST 1993
+
+  Copyright (C) 1993-2008 Yukihiro Matsumoto
+  Copyright (C) 2000  Network Applied Communication Laboratory, Inc.
+  Copyright (C) 2000  Information-technology Promotion Agency, Japan
+
+**********************************************************************/
+
+#ifndef RUBY_RUBY_H
+#define RUBY_RUBY_H 1
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+#include "ruby/config.h"
+#ifdef RUBY_EXTCONF_H
+#include RUBY_EXTCONF_H
+#endif
+
+#define NORETURN_STYLE_NEW 1
+#ifndef NORETURN
+# define NORETURN(x) x
+#endif
+#ifndef DEPRECATED
+# define DEPRECATED(x) x
+#endif
+#ifndef NOINLINE
+# define NOINLINE(x) x
+#endif
+
+#ifdef __GNUC__
+#define PRINTF_ARGS(decl, string_index, first_to_check) \
+  decl __attribute__((format(printf, string_index, first_to_check)))
+#else
+#define PRINTF_ARGS(decl, string_index, first_to_check) decl
+#endif
+
+#ifdef HAVE_STRING_H
+# include <string.h>
+#else
+# include <strings.h>
+#endif
+
+#ifdef HAVE_INTRINSICS_H
+# include <intrinsics.h>
+#endif
+
+#ifdef HAVE_STDINT_H
+# include <stdint.h>
+#endif
+#ifdef HAVE_INTTYPES_H
+# include <inttypes.h>
+#endif
+
+#include <stdarg.h>
+#include <stdio.h>
+
+#include "defines.h"
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility push(default)
+#endif
+
+#if defined(HAVE_ALLOCA_H)
+#include <alloca.h>
+#else
+#  ifdef _AIX
+#pragma alloca
+#  endif
+#endif
+
+#if defined HAVE_UINTPTR_T && 0
+typedef uintptr_t VALUE;
+typedef uintptr_t ID;
+# define SIGNED_VALUE intptr_t
+# define SIZEOF_VALUE SIZEOF_UINTPTR_T
+# undef PRI_VALUE_PREFIX
+#elif SIZEOF_LONG == SIZEOF_VOIDP
+typedef unsigned long VALUE;
+typedef unsigned long ID;
+# define SIGNED_VALUE long
+# define SIZEOF_VALUE SIZEOF_LONG
+# define PRI_VALUE_PREFIX "l"
+#elif SIZEOF_LONG_LONG == SIZEOF_VOIDP
+typedef unsigned LONG_LONG VALUE;
+typedef unsigned LONG_LONG ID;
+# define SIGNED_VALUE LONG_LONG
+# define LONG_LONG_VALUE 1
+# define SIZEOF_VALUE SIZEOF_LONG_LONG
+# define PRI_VALUE_PREFIX PRI_LL_PREFIX
+#else
+# error ---->> ruby requires sizeof(void*) == sizeof(long) to be compiled. <<----
+#endif
+
+typedef char ruby_check_sizeof_int[SIZEOF_INT == sizeof(int) ? 1 : -1];
+typedef char ruby_check_sizeof_long[SIZEOF_LONG == sizeof(long) ? 1 : -1];
+#ifdef SIZEOF_LONG_LONG
+typedef char ruby_check_sizeof_long_long[SIZEOF_LONG_LONG == sizeof(LONG_LONG) ? 1 : -1];
+#endif
+typedef char ruby_check_sizeof_voidp[SIZEOF_VOIDP == sizeof(void*) ? 1 : -1];
+
+#ifndef PRI_INT_PREFIX
+#define PRI_INT_PREFIX ""
+#endif
+#ifndef PRI_LONG_PREFIX
+#define PRI_LONG_PREFIX "l"
+#endif
+
+#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
+
+#ifndef PRI_TIMET_PREFIX
+# if SIZEOF_TIME_T == SIZEOF_INT
+#  define PRI_TIMET_PREFIX
+# elif SIZEOF_TIME_T == SIZEOF_LONG
+#  define PRI_TIMET_PREFIX "l"
+# elif SIZEOF_TIME_T == SIZEOF_LONG_LONG
+#  define PRI_TIMET_PREFIX PRI_LL_PREFIX
+# endif
+#endif
+
+#if defined PRI_PTRDIFF_PREFIX
+#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 PRI_LL_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 PRI_SIZE_PREFIX
+#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 PRI_LL_PREFIX
+#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"
+
+#ifdef __STDC__
+# include <limits.h>
+#else
+# ifndef LONG_MAX
+#  ifdef HAVE_LIMITS_H
+#   include <limits.h>
+#  else
+    /* assuming 32bit(2's compliment) long */
+#   define LONG_MAX 2147483647
+#  endif
+# endif
+# ifndef LONG_MIN
+#  define LONG_MIN (-LONG_MAX-1)
+# endif
+# ifndef CHAR_BIT
+#  define CHAR_BIT 8
+# endif
+#endif
+
+#ifdef HAVE_LONG_LONG
+# ifndef LLONG_MAX
+#  ifdef LONG_LONG_MAX
+#   define LLONG_MAX  LONG_LONG_MAX
+#  else
+#   ifdef _I64_MAX
+#    define LLONG_MAX _I64_MAX
+#   else
+    /* assuming 64bit(2's complement) long long */
+#    define LLONG_MAX 9223372036854775807LL
+#   endif
+#  endif
+# endif
+# ifndef LLONG_MIN
+#  ifdef LONG_LONG_MIN
+#   define LLONG_MIN  LONG_LONG_MIN
+#  else
+#   ifdef _I64_MIN
+#    define LLONG_MIN _I64_MIN
+#   else
+#    define LLONG_MIN (-LLONG_MAX-1)
+#   endif
+#  endif
+# endif
+#endif
+
+#define FIXNUM_MAX (LONG_MAX>>1)
+#define FIXNUM_MIN RSHIFT((long)LONG_MIN,1)
+
+#define INT2FIX(i) ((VALUE)(((SIGNED_VALUE)(i))<<1 | FIXNUM_FLAG))
+#define LONG2FIX(i) INT2FIX(i)
+#define rb_fix_new(v) INT2FIX(v)
+VALUE rb_int2inum(SIGNED_VALUE);
+
+#define rb_int_new(v) rb_int2inum(v)
+VALUE rb_uint2inum(VALUE);
+
+#define rb_uint_new(v) rb_uint2inum(v)
+
+#ifdef HAVE_LONG_LONG
+VALUE rb_ll2inum(LONG_LONG);
+#define LL2NUM(v) rb_ll2inum(v)
+VALUE rb_ull2inum(unsigned LONG_LONG);
+#define ULL2NUM(v) rb_ull2inum(v)
+#endif
+
+#if SIZEOF_OFF_T > SIZEOF_LONG && defined(HAVE_LONG_LONG)
+# define OFFT2NUM(v) LL2NUM(v)
+#elif SIZEOF_OFF_T == SIZEOF_LONG
+# define OFFT2NUM(v) LONG2NUM(v)
+#else
+# define OFFT2NUM(v) INT2NUM(v)
+#endif
+
+#if SIZEOF_SIZE_T > SIZEOF_LONG && defined(HAVE_LONG_LONG)
+# define SIZET2NUM(v) ULL2NUM(v)
+# define SSIZET2NUM(v) LL2NUM(v)
+#elif SIZEOF_SIZE_T == SIZEOF_LONG
+# define SIZET2NUM(v) ULONG2NUM(v)
+# define SSIZET2NUM(v) LONG2NUM(v)
+#else
+# define SIZET2NUM(v) UINT2NUM(v)
+# define SSIZET2NUM(v) INT2NUM(v)
+#endif
+
+#ifndef SIZE_MAX
+# if SIZEOF_SIZE_T > SIZEOF_LONG && defined(HAVE_LONG_LONG)
+#   define SIZE_MAX ULLONG_MAX
+#   define SIZE_MIN ULLONG_MIN
+# elif SIZEOF_SIZE_T == SIZEOF_LONG
+#   define SIZE_MAX ULONG_MAX
+#   define SIZE_MIN ULONG_MIN
+# elif SIZEOF_SIZE_T == SIZEOF_INT
+#   define SIZE_MAX UINT_MAX
+#   define SIZE_MIN UINT_MIN
+# else
+#   define SIZE_MAX USHRT_MAX
+#   define SIZE_MIN USHRT_MIN
+# endif
+#endif
+
+#ifndef SSIZE_MAX
+# if SIZEOF_SIZE_T > SIZEOF_LONG && defined(HAVE_LONG_LONG)
+#   define SSIZE_MAX LLONG_MAX
+#   define SSIZE_MIN LLONG_MIN
+# elif SIZEOF_SIZE_T == SIZEOF_LONG
+#   define SSIZE_MAX LONG_MAX
+#   define SSIZE_MIN LONG_MIN
+# elif SIZEOF_SIZE_T == SIZEOF_INT
+#   define SSIZE_MAX INT_MAX
+#   define SSIZE_MIN INT_MIN
+# else
+#   define SSIZE_MAX SHRT_MAX
+#   define SSIZE_MIN SHRT_MIN
+# endif
+#endif
+
+#if SIZEOF_INT < SIZEOF_VALUE
+NORETURN(void rb_out_of_int(SIGNED_VALUE num));
+#endif
+
+#if SIZEOF_INT < SIZEOF_LONG
+#define rb_long2int_internal(n, i) \
+    int (i) = (int)(n); \
+    if ((long)(i) != (n)) rb_out_of_int(n)
+#ifdef __GNUC__
+#define rb_long2int(n) __extension__ ({long i2l_n = (n); rb_long2int_internal(i2l_n, i2l_i); i2l_i;})
+#else
+static inline int
+rb_long2int(long n) {rb_long2int_internal(n, i); return i;}
+#endif
+#else
+#define rb_long2int(n) ((int)(n))
+#endif
+
+#ifndef PIDT2NUM
+#define PIDT2NUM(v) LONG2NUM(v)
+#endif
+#ifndef NUM2PIDT
+#define NUM2PIDT(v) NUM2LONG(v)
+#endif
+#ifndef UIDT2NUM
+#define UIDT2NUM(v) LONG2NUM(v)
+#endif
+#ifndef NUM2UIDT
+#define NUM2UIDT(v) NUM2LONG(v)
+#endif
+#ifndef GIDT2NUM
+#define GIDT2NUM(v) LONG2NUM(v)
+#endif
+#ifndef NUM2GIDT
+#define NUM2GIDT(v) NUM2LONG(v)
+#endif
+#ifndef NUM2MODET
+#define NUM2MODET(v) NUM2INT(v)
+#endif
+#ifndef MODET2NUM
+#define MODET2NUM(v) INT2NUM(v)
+#endif
+
+#define FIX2LONG(x) (long)RSHIFT((SIGNED_VALUE)(x),1)
+#define FIX2ULONG(x) ((((VALUE)(x))>>1)&LONG_MAX)
+#define FIXNUM_P(f) (((int)(SIGNED_VALUE)(f))&FIXNUM_FLAG)
+#define POSFIXABLE(f) ((f) < FIXNUM_MAX+1)
+#define NEGFIXABLE(f) ((f) >= FIXNUM_MIN)
+#define FIXABLE(f) (POSFIXABLE(f) && NEGFIXABLE(f))
+
+#define IMMEDIATE_P(x) ((VALUE)(x) & IMMEDIATE_MASK)
+
+#define SYMBOL_P(x) (((VALUE)(x)&~(~(VALUE)0<<RUBY_SPECIAL_SHIFT))==SYMBOL_FLAG)
+#define ID2SYM(x) (((VALUE)(x)<<RUBY_SPECIAL_SHIFT)|SYMBOL_FLAG)
+#define SYM2ID(x) RSHIFT((unsigned long)(x),RUBY_SPECIAL_SHIFT)
+
+/* Module#methods, #singleton_methods and so on return Symbols */
+#define USE_SYMBOL_AS_METHOD_NAME 1
+
+/* special constants - i.e. non-zero and non-fixnum constants */
+enum ruby_special_consts {
+    RUBY_Qfalse = 0,
+    RUBY_Qtrue  = 2,
+    RUBY_Qnil   = 4,
+    RUBY_Qundef = 6,
+
+    RUBY_IMMEDIATE_MASK = 0x03,
+    RUBY_FIXNUM_FLAG    = 0x01,
+    RUBY_SYMBOL_FLAG    = 0x0e,
+    RUBY_SPECIAL_SHIFT  = 8
+};
+
+#define Qfalse ((VALUE)RUBY_Qfalse)
+#define Qtrue  ((VALUE)RUBY_Qtrue)
+#define Qnil   ((VALUE)RUBY_Qnil)
+#define Qundef ((VALUE)RUBY_Qundef)	/* undefined value for placeholder */
+#define IMMEDIATE_MASK RUBY_IMMEDIATE_MASK
+#define FIXNUM_FLAG RUBY_FIXNUM_FLAG
+#define SYMBOL_FLAG RUBY_SYMBOL_FLAG
+
+#define RTEST(v) (((VALUE)(v) & ~Qnil) != 0)
+#define NIL_P(v) ((VALUE)(v) == Qnil)
+
+#define CLASS_OF(v) rb_class_of((VALUE)(v))
+
+enum ruby_value_type {
+    RUBY_T_NONE   = 0x00,
+
+    RUBY_T_OBJECT = 0x01,
+    RUBY_T_CLASS  = 0x02,
+    RUBY_T_MODULE = 0x03,
+    RUBY_T_FLOAT  = 0x04,
+    RUBY_T_STRING = 0x05,
+    RUBY_T_REGEXP = 0x06,
+    RUBY_T_ARRAY  = 0x07,
+    RUBY_T_HASH   = 0x08,
+    RUBY_T_STRUCT = 0x09,
+    RUBY_T_BIGNUM = 0x0a,
+    RUBY_T_FILE   = 0x0b,
+    RUBY_T_DATA   = 0x0c,
+    RUBY_T_MATCH  = 0x0d,
+    RUBY_T_COMPLEX  = 0x0e,
+    RUBY_T_RATIONAL = 0x0f,
+
+    RUBY_T_NIL    = 0x11,
+    RUBY_T_TRUE   = 0x12,
+    RUBY_T_FALSE  = 0x13,
+    RUBY_T_SYMBOL = 0x14,
+    RUBY_T_FIXNUM = 0x15,
+
+    RUBY_T_UNDEF  = 0x1b,
+    RUBY_T_NODE   = 0x1c,
+    RUBY_T_ICLASS = 0x1d,
+    RUBY_T_ZOMBIE = 0x1e,
+
+    RUBY_T_MASK   = 0x1f
+};
+
+#define T_NONE   RUBY_T_NONE
+#define T_NIL    RUBY_T_NIL
+#define T_OBJECT RUBY_T_OBJECT
+#define T_CLASS  RUBY_T_CLASS
+#define T_ICLASS RUBY_T_ICLASS
+#define T_MODULE RUBY_T_MODULE
+#define T_FLOAT  RUBY_T_FLOAT
+#define T_STRING RUBY_T_STRING
+#define T_REGEXP RUBY_T_REGEXP
+#define T_ARRAY  RUBY_T_ARRAY
+#define T_HASH   RUBY_T_HASH
+#define T_STRUCT RUBY_T_STRUCT
+#define T_BIGNUM RUBY_T_BIGNUM
+#define T_FILE   RUBY_T_FILE
+#define T_FIXNUM RUBY_T_FIXNUM
+#define T_TRUE   RUBY_T_TRUE
+#define T_FALSE  RUBY_T_FALSE
+#define T_DATA   RUBY_T_DATA
+#define T_MATCH  RUBY_T_MATCH
+#define T_SYMBOL RUBY_T_SYMBOL
+#define T_RATIONAL RUBY_T_RATIONAL
+#define T_COMPLEX RUBY_T_COMPLEX
+#define T_UNDEF  RUBY_T_UNDEF
+#define T_NODE   RUBY_T_NODE
+#define T_ZOMBIE RUBY_T_ZOMBIE
+#define T_MASK   RUBY_T_MASK
+
+#define BUILTIN_TYPE(x) (int)(((struct RBasic*)(x))->flags & T_MASK)
+
+static inline int rb_type(VALUE obj);
+#define TYPE(x) rb_type((VALUE)(x))
+
+#ifdef __GNUC__
+#define RB_GC_GUARD_PTR(ptr) \
+    __extension__ ({volatile VALUE *rb_gc_guarded_ptr = (ptr); rb_gc_guarded_ptr;})
+#else
+#ifdef _MSC_VER
+#pragma optimize("", off)
+#endif
+static inline volatile VALUE *rb_gc_guarded_ptr(volatile VALUE *ptr) {return ptr;}
+#ifdef _MSC_VER
+#pragma optimize("", on)
+#endif
+#define RB_GC_GUARD_PTR(ptr) rb_gc_guarded_ptr(ptr)
+#endif
+#define RB_GC_GUARD(v) (*RB_GC_GUARD_PTR(&(v)))
+
+void rb_check_type(VALUE,int);
+#define Check_Type(v,t) rb_check_type((VALUE)(v),(t))
+
+VALUE rb_str_to_str(VALUE);
+VALUE rb_string_value(volatile VALUE*);
+char *rb_string_value_ptr(volatile VALUE*);
+char *rb_string_value_cstr(volatile VALUE*);
+
+#define StringValue(v) rb_string_value(&(v))
+#define StringValuePtr(v) rb_string_value_ptr(&(v))
+#define StringValueCStr(v) rb_string_value_cstr(&(v))
+
+void rb_check_safe_obj(VALUE);
+DEPRECATED(void rb_check_safe_str(VALUE));
+#define SafeStringValue(v) do {\
+    StringValue(v);\
+    rb_check_safe_obj(v);\
+} while (0)
+/* obsolete macro - use SafeStringValue(v) */
+#define Check_SafeStr(v) rb_check_safe_str((VALUE)(v))
+
+VALUE rb_str_export(VALUE);
+#define ExportStringValue(v) do {\
+    SafeStringValue(v);\
+   (v) = rb_str_export(v);\
+} while (0)
+VALUE rb_str_export_locale(VALUE);
+
+VALUE rb_get_path(VALUE);
+#define FilePathValue(v) (RB_GC_GUARD(v) = rb_get_path(v))
+
+VALUE rb_get_path_no_checksafe(VALUE);
+#define FilePathStringValue(v) ((v) = rb_get_path_no_checksafe(v))
+
+void rb_secure(int);
+int rb_safe_level(void);
+void rb_set_safe_level(int);
+void rb_set_safe_level_force(int);
+void rb_secure_update(VALUE);
+NORETURN(void rb_insecure_operation(void));
+
+VALUE rb_errinfo(void);
+void rb_set_errinfo(VALUE);
+
+SIGNED_VALUE rb_num2long(VALUE);
+VALUE rb_num2ulong(VALUE);
+#define NUM2LONG_internal(x) ((long)(FIXNUM_P(x) ? FIX2LONG(x) : rb_num2long(x)))
+#ifdef __GNUC__
+#define NUM2LONG(x) \
+    __extension__ ({VALUE num2long_x = (x); NUM2LONG_internal(num2long_x);})
+#else
+static inline long
+NUM2LONG(VALUE x)
+{
+    return NUM2LONG_internal(x);
+}
+#endif
+#define NUM2ULONG(x) rb_num2ulong((VALUE)(x))
+#if SIZEOF_INT < SIZEOF_LONG
+long rb_num2int(VALUE);
+long rb_fix2int(VALUE);
+#define FIX2INT(x) ((int)rb_fix2int((VALUE)(x)))
+#define NUM2INT_internal(x) (FIXNUM_P(x) ? FIX2INT(x) : (int)rb_num2int(x))
+#ifdef __GNUC__
+#define NUM2INT(x) \
+    __extension__ ({VALUE num2int_x = (x); NUM2INT_internal(num2int_x);})
+#else
+static inline int
+NUM2INT(VALUE x)
+{
+    return NUM2INT_internal(x);
+}
+#endif
+unsigned long rb_num2uint(VALUE);
+#define NUM2UINT(x) ((unsigned int)rb_num2uint(x))
+unsigned long rb_fix2uint(VALUE);
+#define FIX2UINT(x) ((unsigned int)rb_fix2uint(x))
+#else
+#define NUM2INT(x) ((int)NUM2LONG(x))
+#define NUM2UINT(x) ((unsigned int)NUM2ULONG(x))
+#define FIX2INT(x) ((int)FIX2LONG(x))
+#define FIX2UINT(x) ((unsigned int)FIX2ULONG(x))
+#endif
+
+#ifdef HAVE_LONG_LONG
+LONG_LONG rb_num2ll(VALUE);
+unsigned LONG_LONG rb_num2ull(VALUE);
+# define NUM2LL_internal(x) (FIXNUM_P(x) ? FIX2LONG(x) : rb_num2ll(x))
+# ifdef __GNUC__
+#   define NUM2LL(x) \
+    __extension__ ({VALUE num2ll_x = (x); NUM2LL_internal(num2ll_x);})
+# else
+static inline LONG_LONG
+NUM2LL(VALUE x)
+{
+    return NUM2LL_internal(x);
+}
+# endif
+# define NUM2ULL(x) rb_num2ull((VALUE)(x))
+#endif
+
+#if defined(HAVE_LONG_LONG) && SIZEOF_OFF_T > SIZEOF_LONG
+# define NUM2OFFT(x) ((off_t)NUM2LL(x))
+#else
+# define NUM2OFFT(x) NUM2LONG(x)
+#endif
+
+#if defined(HAVE_LONG_LONG) && SIZEOF_SIZE_T > SIZEOF_LONG
+# define NUM2SIZET(x) ((size_t)NUM2ULL(x))
+# define NUM2SSIZET(x) ((size_t)NUM2LL(x))
+#else
+# define NUM2SIZET(x) NUM2ULONG(x)
+# define NUM2SSIZET(x) NUM2LONG(x)
+#endif
+
+double rb_num2dbl(VALUE);
+#define NUM2DBL(x) rb_num2dbl((VALUE)(x))
+
+VALUE rb_uint2big(VALUE);
+VALUE rb_int2big(SIGNED_VALUE);
+
+VALUE rb_newobj(void);
+#define NEWOBJ(obj,type) type *(obj) = (type*)rb_newobj()
+#define OBJSETUP(obj,c,t) do {\
+    RBASIC(obj)->flags = (t);\
+    RBASIC(obj)->klass = (c);\
+    if (rb_safe_level() >= 3) FL_SET((obj), FL_TAINT | FL_UNTRUSTED);\
+} while (0)
+#define CLONESETUP(clone,obj) do {\
+    OBJSETUP((clone),rb_singleton_class_clone((VALUE)(obj)),RBASIC(obj)->flags);\
+    rb_singleton_class_attached(RBASIC(clone)->klass, (VALUE)(clone));\
+    if (FL_TEST((obj), FL_EXIVAR)) rb_copy_generic_ivar((VALUE)(clone),(VALUE)(obj));\
+} while (0)
+#define DUPSETUP(dup,obj) do {\
+    OBJSETUP((dup),rb_obj_class(obj), (RBASIC(obj)->flags)&(T_MASK|FL_EXIVAR|FL_TAINT|FL_UNTRUSTED)); \
+    if (FL_TEST((obj), FL_EXIVAR)) rb_copy_generic_ivar((VALUE)(dup),(VALUE)(obj));\
+} while (0)
+
+struct RBasic {
+    VALUE flags;
+    VALUE klass;
+};
+
+#define ROBJECT_EMBED_LEN_MAX 3
+struct RObject {
+    struct RBasic basic;
+    union {
+	struct {
+	    long numiv;
+	    VALUE *ivptr;
+            struct st_table *iv_index_tbl; /* shortcut for RCLASS_IV_INDEX_TBL(rb_obj_class(obj)) */
+	} heap;
+	VALUE ary[ROBJECT_EMBED_LEN_MAX];
+    } as;
+};
+#define ROBJECT_EMBED FL_USER1
+#define ROBJECT_NUMIV(o) \
+    ((RBASIC(o)->flags & ROBJECT_EMBED) ? \
+     ROBJECT_EMBED_LEN_MAX : \
+     ROBJECT(o)->as.heap.numiv)
+#define ROBJECT_IVPTR(o) \
+    ((RBASIC(o)->flags & ROBJECT_EMBED) ? \
+     ROBJECT(o)->as.ary : \
+     ROBJECT(o)->as.heap.ivptr)
+#define ROBJECT_IV_INDEX_TBL(o) \
+    ((RBASIC(o)->flags & ROBJECT_EMBED) ? \
+     RCLASS_IV_INDEX_TBL(rb_obj_class(o)) : \
+     ROBJECT(o)->as.heap.iv_index_tbl)
+
+/** @internal */
+typedef struct rb_classext_struct rb_classext_t;
+
+struct RClass {
+    struct RBasic basic;
+    rb_classext_t *ptr;
+    struct st_table *m_tbl;
+    struct st_table *iv_index_tbl;
+};
+#define RCLASS_SUPER(c) rb_class_get_superclass(c)
+#define RMODULE_IV_TBL(m) RCLASS_IV_TBL(m)
+#define RMODULE_CONST_TBL(m) RCLASS_CONST_TBL(m)
+#define RMODULE_M_TBL(m) RCLASS_M_TBL(m)
+#define RMODULE_SUPER(m) RCLASS_SUPER(m)
+
+struct RFloat {
+    struct RBasic basic;
+    double float_value;
+};
+#define RFLOAT_VALUE(v) (RFLOAT(v)->float_value)
+#define DBL2NUM(dbl)  rb_float_new(dbl)
+
+#define ELTS_SHARED FL_USER2
+
+#define RSTRING_EMBED_LEN_MAX ((int)((sizeof(VALUE)*3)/sizeof(char)-1))
+struct RString {
+    struct RBasic basic;
+    union {
+	struct {
+	    long len;
+	    char *ptr;
+	    union {
+		long capa;
+		VALUE shared;
+	    } aux;
+	} heap;
+	char ary[RSTRING_EMBED_LEN_MAX + 1];
+    } as;
+};
+#define RSTRING_NOEMBED FL_USER1
+#define RSTRING_EMBED_LEN_MASK (FL_USER2|FL_USER3|FL_USER4|FL_USER5|FL_USER6)
+#define RSTRING_EMBED_LEN_SHIFT (FL_USHIFT+2)
+#define RSTRING_EMBED_LEN(str) \
+     (long)((RBASIC(str)->flags >> RSTRING_EMBED_LEN_SHIFT) & \
+            (RSTRING_EMBED_LEN_MASK >> RSTRING_EMBED_LEN_SHIFT))
+#define RSTRING_LEN(str) \
+    (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \
+     RSTRING_EMBED_LEN(str) : \
+     RSTRING(str)->as.heap.len)
+#define RSTRING_PTR(str) \
+    (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \
+     RSTRING(str)->as.ary : \
+     RSTRING(str)->as.heap.ptr)
+#define RSTRING_END(str) \
+    (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \
+     (RSTRING(str)->as.ary + RSTRING_EMBED_LEN(str)) : \
+     (RSTRING(str)->as.heap.ptr + RSTRING(str)->as.heap.len))
+#define RSTRING_LENINT(str) rb_long2int(RSTRING_LEN(str))
+#define RSTRING_GETMEM(str, ptrvar, lenvar) \
+    (!(RBASIC(str)->flags & RSTRING_NOEMBED) ? \
+     ((ptrvar) = RSTRING(str)->as.ary, (lenvar) = RSTRING_EMBED_LEN(str)) : \
+     ((ptrvar) = RSTRING(str)->as.heap.ptr, (lenvar) = RSTRING(str)->as.heap.len))
+
+#define RARRAY_EMBED_LEN_MAX 3
+struct RArray {
+    struct RBasic basic;
+    union {
+	struct {
+	    long len;
+	    union {
+		long capa;
+		VALUE shared;
+	    } aux;
+	    VALUE *ptr;
+	} heap;
+	VALUE ary[RARRAY_EMBED_LEN_MAX];
+    } as;
+};
+#define RARRAY_EMBED_FLAG FL_USER1
+/* FL_USER2 is for ELTS_SHARED */
+#define RARRAY_EMBED_LEN_MASK (FL_USER4|FL_USER3)
+#define RARRAY_EMBED_LEN_SHIFT (FL_USHIFT+3)
+#define RARRAY_LEN(a) \
+    ((RBASIC(a)->flags & RARRAY_EMBED_FLAG) ? \
+     (long)((RBASIC(a)->flags >> RARRAY_EMBED_LEN_SHIFT) & \
+	 (RARRAY_EMBED_LEN_MASK >> RARRAY_EMBED_LEN_SHIFT)) : \
+     RARRAY(a)->as.heap.len)
+#define RARRAY_PTR(a) \
+    ((RBASIC(a)->flags & RARRAY_EMBED_FLAG) ? \
+     RARRAY(a)->as.ary : \
+     RARRAY(a)->as.heap.ptr)
+#define RARRAY_LENINT(ary) rb_long2int(RARRAY_LEN(ary))
+
+struct RRegexp {
+    struct RBasic basic;
+    struct re_pattern_buffer *ptr;
+    VALUE src;
+    unsigned long usecnt;
+};
+#define RREGEXP_SRC(r) RREGEXP(r)->src
+#define RREGEXP_SRC_PTR(r) RSTRING_PTR(RREGEXP(r)->src)
+#define RREGEXP_SRC_LEN(r) RSTRING_LEN(RREGEXP(r)->src)
+#define RREGEXP_SRC_END(r) RSTRING_END(RREGEXP(r)->src)
+
+struct RHash {
+    struct RBasic basic;
+    struct st_table *ntbl;      /* possibly 0 */
+    int iter_lev;
+    VALUE ifnone;
+};
+/* RHASH_TBL allocates st_table if not available. */
+#define RHASH_TBL(h) rb_hash_tbl(h)
+#define RHASH_ITER_LEV(h) (RHASH(h)->iter_lev)
+#define RHASH_IFNONE(h) (RHASH(h)->ifnone)
+#define RHASH_SIZE(h) (RHASH(h)->ntbl ? RHASH(h)->ntbl->num_entries : 0)
+#define RHASH_EMPTY_P(h) (RHASH_SIZE(h) == 0)
+
+struct RFile {
+    struct RBasic basic;
+    struct rb_io_t *fptr;
+};
+
+struct RRational {
+    struct RBasic basic;
+    VALUE num;
+    VALUE den;
+};
+
+struct RComplex {
+    struct RBasic basic;
+    VALUE real;
+    VALUE imag;
+};
+
+struct RData {
+    struct RBasic basic;
+    void (*dmark)(void*);
+    void (*dfree)(void*);
+    void *data;
+};
+
+typedef struct rb_data_type_struct rb_data_type_t;
+
+struct rb_data_type_struct {
+    const char *wrap_struct_name;
+    struct {
+	void (*dmark)(void*);
+	void (*dfree)(void*);
+	size_t (*dsize)(const void *);
+	void *reserved[2]; /* For future extension.
+			      This array *must* be filled with ZERO. */
+    } function;
+    const rb_data_type_t *parent;
+    void *data;        /* This area can be used for any purpose
+                          by a programmer who define the type. */
+};
+
+#define HAVE_TYPE_RB_DATA_TYPE_T 1
+#define HAVE_RB_DATA_TYPE_T_FUNCTION 1
+#define HAVE_RB_DATA_TYPE_T_PARENT 1
+
+struct RTypedData {
+    struct RBasic basic;
+    const rb_data_type_t *type;
+    VALUE typed_flag; /* 1 or not */
+    void *data;
+};
+
+#define DATA_PTR(dta) (RDATA(dta)->data)
+
+#define RTYPEDDATA_P(v)    (RTYPEDDATA(v)->typed_flag == 1)
+#define RTYPEDDATA_TYPE(v) (RTYPEDDATA(v)->type)
+#define RTYPEDDATA_DATA(v) (RTYPEDDATA(v)->data)
+
+/*
+#define RUBY_DATA_FUNC(func) ((void (*)(void*))(func))
+*/
+typedef void (*RUBY_DATA_FUNC)(void*);
+
+VALUE rb_data_object_alloc(VALUE,void*,RUBY_DATA_FUNC,RUBY_DATA_FUNC);
+VALUE rb_data_typed_object_alloc(VALUE klass, void *datap, const rb_data_type_t *);
+int rb_typeddata_inherited_p(const rb_data_type_t *child, const rb_data_type_t *parent);
+int rb_typeddata_is_kind_of(VALUE, const rb_data_type_t *);
+void *rb_check_typeddata(VALUE, const rb_data_type_t *);
+#define Check_TypedStruct(v,t) rb_check_typeddata((VALUE)(v),(t))
+#define RUBY_DEFAULT_FREE ((RUBY_DATA_FUNC)-1)
+#define RUBY_NEVER_FREE   ((RUBY_DATA_FUNC)0)
+#define RUBY_TYPED_DEFAULT_FREE RUBY_DEFAULT_FREE
+#define RUBY_TYPED_NEVER_FREE   RUBY_NEVER_FREE
+
+#define Data_Wrap_Struct(klass,mark,free,sval)\
+    rb_data_object_alloc((klass),(sval),(RUBY_DATA_FUNC)(mark),(RUBY_DATA_FUNC)(free))
+
+#define Data_Make_Struct(klass,type,mark,free,sval) (\
+    (sval) = ALLOC(type),\
+    memset((sval), 0, sizeof(type)),\
+    Data_Wrap_Struct((klass),(mark),(free),(sval))\
+)
+
+#define TypedData_Wrap_Struct(klass,data_type,sval)\
+  rb_data_typed_object_alloc((klass),(sval),(data_type))
+
+#define TypedData_Make_Struct(klass, type, data_type, sval) (\
+    (sval) = ALLOC(type),\
+    memset((sval), 0, sizeof(type)),\
+    TypedData_Wrap_Struct((klass),(data_type),(sval))\
+)
+
+#define Data_Get_Struct(obj,type,sval) do {\
+    Check_Type((obj), T_DATA); \
+    (sval) = (type*)DATA_PTR(obj);\
+} while (0)
+
+#define TypedData_Get_Struct(obj,type,data_type,sval) do {\
+    (sval) = (type*)rb_check_typeddata((obj), (data_type)); \
+} while (0)
+
+#define RSTRUCT_EMBED_LEN_MAX 3
+struct RStruct {
+    struct RBasic basic;
+    union {
+	struct {
+	    long len;
+	    VALUE *ptr;
+	} heap;
+	VALUE ary[RSTRUCT_EMBED_LEN_MAX];
+    } as;
+};
+#define RSTRUCT_EMBED_LEN_MASK (FL_USER2|FL_USER1)
+#define RSTRUCT_EMBED_LEN_SHIFT (FL_USHIFT+1)
+#define RSTRUCT_LEN(st) \
+    ((RBASIC(st)->flags & RSTRUCT_EMBED_LEN_MASK) ? \
+     (long)((RBASIC(st)->flags >> RSTRUCT_EMBED_LEN_SHIFT) & \
+            (RSTRUCT_EMBED_LEN_MASK >> RSTRUCT_EMBED_LEN_SHIFT)) : \
+     RSTRUCT(st)->as.heap.len)
+#define RSTRUCT_PTR(st) \
+    ((RBASIC(st)->flags & RSTRUCT_EMBED_LEN_MASK) ? \
+     RSTRUCT(st)->as.ary : \
+     RSTRUCT(st)->as.heap.ptr)
+#define RSTRUCT_LENINT(st) rb_long2int(RSTRUCT_LEN(st))
+
+#define RBIGNUM_EMBED_LEN_MAX ((int)((sizeof(VALUE)*3)/sizeof(BDIGIT)))
+struct RBignum {
+    struct RBasic basic;
+    union {
+        struct {
+            long len;
+            BDIGIT *digits;
+        } heap;
+        BDIGIT ary[RBIGNUM_EMBED_LEN_MAX];
+    } as;
+};
+#define RBIGNUM_SIGN_BIT FL_USER1
+/* sign: positive:1, negative:0 */
+#define RBIGNUM_SIGN(b) ((RBASIC(b)->flags & RBIGNUM_SIGN_BIT) != 0)
+#define RBIGNUM_SET_SIGN(b,sign) \
+  ((sign) ? (RBASIC(b)->flags |= RBIGNUM_SIGN_BIT) \
+          : (RBASIC(b)->flags &= ~RBIGNUM_SIGN_BIT))
+#define RBIGNUM_POSITIVE_P(b) RBIGNUM_SIGN(b)
+#define RBIGNUM_NEGATIVE_P(b) (!RBIGNUM_SIGN(b))
+
+#define RBIGNUM_EMBED_FLAG FL_USER2
+#define RBIGNUM_EMBED_LEN_MASK (FL_USER5|FL_USER4|FL_USER3)
+#define RBIGNUM_EMBED_LEN_SHIFT (FL_USHIFT+3)
+#define RBIGNUM_LEN(b) \
+    ((RBASIC(b)->flags & RBIGNUM_EMBED_FLAG) ? \
+     (long)((RBASIC(b)->flags >> RBIGNUM_EMBED_LEN_SHIFT) & \
+            (RBIGNUM_EMBED_LEN_MASK >> RBIGNUM_EMBED_LEN_SHIFT)) : \
+     RBIGNUM(b)->as.heap.len)
+/* LSB:RBIGNUM_DIGITS(b)[0], MSB:RBIGNUM_DIGITS(b)[RBIGNUM_LEN(b)-1] */
+#define RBIGNUM_DIGITS(b) \
+    ((RBASIC(b)->flags & RBIGNUM_EMBED_FLAG) ? \
+     RBIGNUM(b)->as.ary : \
+     RBIGNUM(b)->as.heap.digits)
+#define RBIGNUM_LENINT(b) rb_long2int(RBIGNUM_LEN(b))
+
+#define R_CAST(st)   (struct st*)
+#define RBASIC(obj)  (R_CAST(RBasic)(obj))
+#define ROBJECT(obj) (R_CAST(RObject)(obj))
+#define RCLASS(obj)  (R_CAST(RClass)(obj))
+#define RMODULE(obj) RCLASS(obj)
+#define RFLOAT(obj)  (R_CAST(RFloat)(obj))
+#define RSTRING(obj) (R_CAST(RString)(obj))
+#define RREGEXP(obj) (R_CAST(RRegexp)(obj))
+#define RARRAY(obj)  (R_CAST(RArray)(obj))
+#define RHASH(obj)   (R_CAST(RHash)(obj))
+#define RDATA(obj)   (R_CAST(RData)(obj))
+#define RTYPEDDATA(obj)   (R_CAST(RTypedData)(obj))
+#define RSTRUCT(obj) (R_CAST(RStruct)(obj))
+#define RBIGNUM(obj) (R_CAST(RBignum)(obj))
+#define RFILE(obj)   (R_CAST(RFile)(obj))
+#define RRATIONAL(obj) (R_CAST(RRational)(obj))
+#define RCOMPLEX(obj) (R_CAST(RComplex)(obj))
+
+#define FL_SINGLETON FL_USER0
+#define FL_MARK      (((VALUE)1)<<5)
+#define FL_RESERVED  (((VALUE)1)<<6) /* will be used in the future GC */
+#define FL_FINALIZE  (((VALUE)1)<<7)
+#define FL_TAINT     (((VALUE)1)<<8)
+#define FL_UNTRUSTED (((VALUE)1)<<9)
+#define FL_EXIVAR    (((VALUE)1)<<10)
+#define FL_FREEZE    (((VALUE)1)<<11)
+
+#define FL_USHIFT    12
+
+#define FL_USER0     (((VALUE)1)<<(FL_USHIFT+0))
+#define FL_USER1     (((VALUE)1)<<(FL_USHIFT+1))
+#define FL_USER2     (((VALUE)1)<<(FL_USHIFT+2))
+#define FL_USER3     (((VALUE)1)<<(FL_USHIFT+3))
+#define FL_USER4     (((VALUE)1)<<(FL_USHIFT+4))
+#define FL_USER5     (((VALUE)1)<<(FL_USHIFT+5))
+#define FL_USER6     (((VALUE)1)<<(FL_USHIFT+6))
+#define FL_USER7     (((VALUE)1)<<(FL_USHIFT+7))
+#define FL_USER8     (((VALUE)1)<<(FL_USHIFT+8))
+#define FL_USER9     (((VALUE)1)<<(FL_USHIFT+9))
+#define FL_USER10    (((VALUE)1)<<(FL_USHIFT+10))
+#define FL_USER11    (((VALUE)1)<<(FL_USHIFT+11))
+#define FL_USER12    (((VALUE)1)<<(FL_USHIFT+12))
+#define FL_USER13    (((VALUE)1)<<(FL_USHIFT+13))
+#define FL_USER14    (((VALUE)1)<<(FL_USHIFT+14))
+#define FL_USER15    (((VALUE)1)<<(FL_USHIFT+15))
+#define FL_USER16    (((VALUE)1)<<(FL_USHIFT+16))
+#define FL_USER17    (((VALUE)1)<<(FL_USHIFT+17))
+#define FL_USER18    (((VALUE)1)<<(FL_USHIFT+18))
+#define FL_USER19    (((VALUE)1)<<(FL_USHIFT+19))
+
+#define SPECIAL_CONST_P(x) (IMMEDIATE_P(x) || !RTEST(x))
+
+#define FL_ABLE(x) (!SPECIAL_CONST_P(x) && BUILTIN_TYPE(x) != T_NODE)
+#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)
+#define FL_REVERSE(x,f) do {if (FL_ABLE(x)) RBASIC(x)->flags ^= (f);} while (0)
+
+#define OBJ_TAINTED(x) (!!FL_TEST((x), FL_TAINT))
+#define OBJ_TAINT(x) FL_SET((x), FL_TAINT)
+#define OBJ_UNTRUSTED(x) (!!FL_TEST((x), FL_UNTRUSTED))
+#define OBJ_UNTRUST(x) FL_SET((x), FL_UNTRUSTED)
+#define OBJ_INFECT(x,s) do {if (FL_ABLE(x) && FL_ABLE(s)) RBASIC(x)->flags |= RBASIC(s)->flags & (FL_TAINT | FL_UNTRUSTED);} while (0)
+
+#define OBJ_FROZEN(x) (!!FL_TEST((x), FL_FREEZE))
+#define OBJ_FREEZE(x) FL_SET((x), FL_FREEZE)
+
+#if SIZEOF_INT < SIZEOF_LONG
+# define INT2NUM(v) INT2FIX((int)(v))
+# define UINT2NUM(v) LONG2FIX((unsigned int)(v))
+#else
+# define INT2NUM_internal(v) (FIXABLE(v) ? INT2FIX(v) : rb_int2big(v))
+# ifdef __GNUC__
+#   define INT2NUM(v) __extension__ ({int int2num_v = (v); INT2NUM_internal(int2num_v);})
+# else
+static inline VALUE
+INT2NUM(int v)
+{
+    return INT2NUM_internal(v);
+}
+# endif
+
+# define UINT2NUM_internal(v) (POSFIXABLE(v) ? LONG2FIX(v) : rb_uint2big(v))
+# ifdef __GNUC__
+#   define UINT2NUM(v) __extension__ ({unsigned int uint2num_v = (v); UINT2NUM_internal(uint2num_v);})
+# else
+static inline VALUE
+UINT2NUM(unsigned int v)
+{
+    return UINT2NUM_internal(v);
+}
+# endif
+#endif
+
+#define LONG2NUM_internal(v) (FIXABLE(v) ? LONG2FIX(v) : rb_int2big(v))
+#ifdef __GNUC__
+# define LONG2NUM(v) __extension__ ({long long2num_v = (v); LONG2NUM_internal(long2num_v);})
+#else
+static inline VALUE
+LONG2NUM(long v)
+{
+    return LONG2NUM_internal(v);
+}
+#endif
+
+#define ULONG2NUM_internal(v) (POSFIXABLE(v) ? LONG2FIX(v) : rb_uint2big(v))
+#ifdef __GNUC__
+# define ULONG2NUM(v) __extension__ ({unsigned long ulong2num_v = (v); ULONG2NUM_internal(ulong2num_v);})
+#else
+static inline VALUE
+ULONG2NUM(unsigned long v)
+{
+    return ULONG2NUM_internal(v);
+}
+#endif
+
+#define NUM2CHR_internal(x) (((TYPE(x) == T_STRING)&&(RSTRING_LEN(x)>=1))?\
+                     RSTRING_PTR(x)[0]:(char)(NUM2INT(x)&0xff))
+#ifdef __GNUC__
+# define NUM2CHR(x) __extension__ ({VALUE num2chr_x = (x); NUM2CHR_internal(num2chr_x);})
+#else
+static inline char
+NUM2CHR(VALUE x)
+{
+    return NUM2CHR_internal(x);
+}
+#endif
+#define CHR2FIX(x) INT2FIX((long)((x)&0xff))
+
+#define ALLOC_N(type,n) ((type*)xmalloc2((n),sizeof(type)))
+#define ALLOC(type) ((type*)xmalloc(sizeof(type)))
+#define REALLOC_N(var,type,n) ((var)=(type*)xrealloc2((char*)(var),(n),sizeof(type)))
+
+#define ALLOCA_N(type,n) ((type*)alloca(sizeof(type)*(n)))
+
+void *rb_alloc_tmp_buffer(volatile VALUE *store, long len);
+void rb_free_tmp_buffer(volatile VALUE *store);
+/* allocates _n_ bytes temporary buffer and stores VALUE including it
+ * in _v_.  _n_ may be evaluated twice. */
+#ifdef C_ALLOCA
+# define ALLOCV(v, n) rb_alloc_tmp_buffer(&(v), (n))
+#else
+# define ALLOCV(v, n) ((n) < 1024 ? (RB_GC_GUARD(v) = 0, alloca(n)) : rb_alloc_tmp_buffer(&(v), (n)))
+#endif
+#define ALLOCV_N(type, v, n) ((type*)ALLOCV((v), sizeof(type)*(n)))
+#define ALLOCV_END(v) rb_free_tmp_buffer(&(v))
+
+#define MEMZERO(p,type,n) memset((p), 0, sizeof(type)*(n))
+#define MEMCPY(p1,p2,type,n) memcpy((p1), (p2), sizeof(type)*(n))
+#define MEMMOVE(p1,p2,type,n) memmove((p1), (p2), sizeof(type)*(n))
+#define MEMCMP(p1,p2,type,n) memcmp((p1), (p2), sizeof(type)*(n))
+
+void rb_obj_infect(VALUE,VALUE);
+
+typedef int ruby_glob_func(const char*,VALUE, void*);
+void rb_glob(const char*,void(*)(const char*,VALUE,void*),VALUE);
+int ruby_glob(const char*,int,ruby_glob_func*,VALUE);
+int ruby_brace_glob(const char*,int,ruby_glob_func*,VALUE);
+
+VALUE rb_define_class(const char*,VALUE);
+VALUE rb_define_module(const char*);
+VALUE rb_define_class_under(VALUE, const char*, VALUE);
+VALUE rb_define_module_under(VALUE, const char*);
+
+void rb_include_module(VALUE,VALUE);
+void rb_extend_object(VALUE,VALUE);
+
+struct rb_global_variable;
+
+typedef VALUE rb_gvar_getter_t(ID id, void *data, struct rb_global_variable *gvar);
+typedef void  rb_gvar_setter_t(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
+typedef void  rb_gvar_marker_t(VALUE *var);
+
+VALUE rb_gvar_undef_getter(ID id, void *data, struct rb_global_variable *gvar);
+void  rb_gvar_undef_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
+void  rb_gvar_undef_marker(VALUE *var);
+
+VALUE rb_gvar_val_getter(ID id, void *data, struct rb_global_variable *gvar);
+void  rb_gvar_val_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
+void  rb_gvar_val_marker(VALUE *var);
+
+VALUE rb_gvar_var_getter(ID id, void *data, struct rb_global_variable *gvar);
+void  rb_gvar_var_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
+void  rb_gvar_var_marker(VALUE *var);
+
+void  rb_gvar_readonly_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
+
+void rb_define_variable(const char*,VALUE*);
+void rb_define_virtual_variable(const char*,VALUE(*)(ANYARGS),void(*)(ANYARGS));
+void rb_define_hooked_variable(const char*,VALUE*,VALUE(*)(ANYARGS),void(*)(ANYARGS));
+void rb_define_readonly_variable(const char*,VALUE*);
+void rb_define_const(VALUE,const char*,VALUE);
+void rb_define_global_const(const char*,VALUE);
+
+#define RUBY_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
+void rb_define_method(VALUE,const char*,VALUE(*)(ANYARGS),int);
+void rb_define_module_function(VALUE,const char*,VALUE(*)(ANYARGS),int);
+void rb_define_global_function(const char*,VALUE(*)(ANYARGS),int);
+
+void rb_undef_method(VALUE,const char*);
+void rb_define_alias(VALUE,const char*,const char*);
+void rb_define_attr(VALUE,const char*,int,int);
+
+void rb_global_variable(VALUE*);
+void rb_gc_register_mark_object(VALUE);
+void rb_gc_register_address(VALUE*);
+void rb_gc_unregister_address(VALUE*);
+
+ID rb_intern(const char*);
+ID rb_intern2(const char*, long);
+ID rb_intern_str(VALUE str);
+const char *rb_id2name(ID);
+ID rb_to_id(VALUE);
+VALUE rb_id2str(ID);
+
+#define CONST_ID_CACHE(result, str)			\
+    {							\
+	static ID rb_intern_id_cache;			\
+	if (!rb_intern_id_cache)			\
+	    rb_intern_id_cache = rb_intern2((str), (long)strlen(str)); \
+	result rb_intern_id_cache;			\
+    }
+#define CONST_ID(var, str) \
+    do CONST_ID_CACHE((var) =, (str)) while (0)
+#ifdef __GNUC__
+/* __builtin_constant_p and statement expression is available
+ * since gcc-2.7.2.3 at least. */
+#define rb_intern(str) \
+    (__builtin_constant_p(str) ? \
+        __extension__ (CONST_ID_CACHE((ID), (str))) : \
+        rb_intern(str))
+#define rb_intern_const(str) \
+    (__builtin_constant_p(str) ? \
+     __extension__ (rb_intern2((str), (long)strlen(str))) : \
+     (rb_intern)(str))
+#else
+#define rb_intern_const(str) rb_intern2((str), (long)strlen(str))
+#endif
+
+const char *rb_class2name(VALUE);
+const char *rb_obj_classname(VALUE);
+
+void rb_p(VALUE);
+
+VALUE rb_eval_string(const char*);
+VALUE rb_eval_string_protect(const char*, int*);
+VALUE rb_eval_string_wrap(const char*, int*);
+VALUE rb_funcall(VALUE, ID, int, ...);
+VALUE rb_funcall2(VALUE, ID, int, const VALUE*);
+VALUE rb_funcall3(VALUE, ID, int, const VALUE*);
+VALUE rb_funcall_passing_block(VALUE, ID, int, const VALUE*);
+int rb_scan_args(int, const VALUE*, const char*, ...);
+VALUE rb_call_super(int, const VALUE*);
+
+VALUE rb_gv_set(const char*, VALUE);
+VALUE rb_gv_get(const char*);
+VALUE rb_iv_get(VALUE, const char*);
+VALUE rb_iv_set(VALUE, const char*, VALUE);
+
+VALUE rb_equal(VALUE,VALUE);
+
+VALUE *rb_ruby_verbose_ptr(void);
+VALUE *rb_ruby_debug_ptr(void);
+#define ruby_verbose (*rb_ruby_verbose_ptr())
+#define ruby_debug   (*rb_ruby_debug_ptr())
+
+PRINTF_ARGS(NORETURN(void rb_raise(VALUE, const char*, ...)), 2, 3);
+PRINTF_ARGS(NORETURN(void rb_fatal(const char*, ...)), 1, 2);
+PRINTF_ARGS(NORETURN(void rb_bug(const char*, ...)), 1, 2);
+NORETURN(void rb_bug_errno(const char*, int));
+NORETURN(void rb_sys_fail(const char*));
+NORETURN(void rb_sys_fail_str(VALUE));
+NORETURN(void rb_mod_sys_fail(VALUE, const char*));
+NORETURN(void rb_mod_sys_fail_str(VALUE, VALUE));
+NORETURN(void rb_iter_break(void));
+NORETURN(void rb_exit(int));
+NORETURN(void rb_notimplement(void));
+VALUE rb_syserr_new(int, const char *);
+VALUE rb_syserr_new_str(int n, VALUE arg);
+NORETURN(void rb_syserr_fail(int, const char*));
+NORETURN(void rb_syserr_fail_str(int, VALUE));
+NORETURN(void rb_mod_syserr_fail(VALUE, int, const char*));
+NORETURN(void rb_mod_syserr_fail_str(VALUE, int, VALUE));
+
+/* reports if `-W' specified */
+PRINTF_ARGS(void rb_warning(const char*, ...), 1, 2);
+PRINTF_ARGS(void rb_compile_warning(const char *, int, const char*, ...), 3, 4);
+PRINTF_ARGS(void rb_sys_warning(const char*, ...), 1, 2);
+/* reports always */
+PRINTF_ARGS(void rb_warn(const char*, ...), 1, 2);
+PRINTF_ARGS(void rb_compile_warn(const char *, int, const char*, ...), 3, 4);
+
+typedef VALUE rb_block_call_func(VALUE, VALUE, int, VALUE*);
+
+VALUE rb_each(VALUE);
+VALUE rb_yield(VALUE);
+VALUE rb_yield_values(int n, ...);
+VALUE rb_yield_values2(int n, const VALUE *argv);
+VALUE rb_yield_splat(VALUE);
+int rb_block_given_p(void);
+void rb_need_block(void);
+VALUE rb_iterate(VALUE(*)(VALUE),VALUE,VALUE(*)(ANYARGS),VALUE);
+VALUE rb_block_call(VALUE,ID,int,VALUE*,VALUE(*)(ANYARGS),VALUE);
+VALUE rb_rescue(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE);
+VALUE rb_rescue2(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE,...);
+VALUE rb_ensure(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE);
+VALUE rb_catch(const char*,VALUE(*)(ANYARGS),VALUE);
+VALUE rb_catch_obj(VALUE,VALUE(*)(ANYARGS),VALUE);
+NORETURN(void rb_throw(const char*,VALUE));
+NORETURN(void rb_throw_obj(VALUE,VALUE));
+
+VALUE rb_require(const char*);
+
+#ifdef __ia64
+void ruby_init_stack(volatile VALUE*, void*);
+#define ruby_init_stack(addr) ruby_init_stack((addr), rb_ia64_bsp())
+#else
+void ruby_init_stack(volatile VALUE*);
+#endif
+#define RUBY_INIT_STACK \
+    VALUE variable_in_this_stack_frame; \
+    ruby_init_stack(&variable_in_this_stack_frame);
+void ruby_init(void);
+void *ruby_options(int, char**);
+int ruby_run_node(void *);
+int ruby_exec_node(void *);
+int ruby_executable_node(void *n, int *status);
+
+RUBY_EXTERN VALUE rb_mKernel;
+RUBY_EXTERN VALUE rb_mComparable;
+RUBY_EXTERN VALUE rb_mEnumerable;
+RUBY_EXTERN VALUE rb_mErrno;
+RUBY_EXTERN VALUE rb_mFileTest;
+RUBY_EXTERN VALUE rb_mGC;
+RUBY_EXTERN VALUE rb_mMath;
+RUBY_EXTERN VALUE rb_mProcess;
+RUBY_EXTERN VALUE rb_mWaitReadable;
+RUBY_EXTERN VALUE rb_mWaitWritable;
+
+RUBY_EXTERN VALUE rb_cBasicObject;
+RUBY_EXTERN VALUE rb_cObject;
+RUBY_EXTERN VALUE rb_cArray;
+RUBY_EXTERN VALUE rb_cBignum;
+RUBY_EXTERN VALUE rb_cBinding;
+RUBY_EXTERN VALUE rb_cClass;
+RUBY_EXTERN VALUE rb_cCont;
+RUBY_EXTERN VALUE rb_cDir;
+RUBY_EXTERN VALUE rb_cData;
+RUBY_EXTERN VALUE rb_cFalseClass;
+RUBY_EXTERN VALUE rb_cEncoding;
+RUBY_EXTERN VALUE rb_cEnumerator;
+RUBY_EXTERN VALUE rb_cFile;
+RUBY_EXTERN VALUE rb_cFixnum;
+RUBY_EXTERN VALUE rb_cFloat;
+RUBY_EXTERN VALUE rb_cHash;
+RUBY_EXTERN VALUE rb_cInteger;
+RUBY_EXTERN VALUE rb_cIO;
+RUBY_EXTERN VALUE rb_cMatch;
+RUBY_EXTERN VALUE rb_cMethod;
+RUBY_EXTERN VALUE rb_cModule;
+RUBY_EXTERN VALUE rb_cNameErrorMesg;
+RUBY_EXTERN VALUE rb_cNilClass;
+RUBY_EXTERN VALUE rb_cNumeric;
+RUBY_EXTERN VALUE rb_cProc;
+RUBY_EXTERN VALUE rb_cRandom;
+RUBY_EXTERN VALUE rb_cRange;
+RUBY_EXTERN VALUE rb_cRational;
+RUBY_EXTERN VALUE rb_cComplex;
+RUBY_EXTERN VALUE rb_cRegexp;
+RUBY_EXTERN VALUE rb_cStat;
+RUBY_EXTERN VALUE rb_cString;
+RUBY_EXTERN VALUE rb_cStruct;
+RUBY_EXTERN VALUE rb_cSymbol;
+RUBY_EXTERN VALUE rb_cThread;
+RUBY_EXTERN VALUE rb_cTime;
+RUBY_EXTERN VALUE rb_cTrueClass;
+RUBY_EXTERN VALUE rb_cUnboundMethod;
+
+RUBY_EXTERN VALUE rb_eException;
+RUBY_EXTERN VALUE rb_eStandardError;
+RUBY_EXTERN VALUE rb_eSystemExit;
+RUBY_EXTERN VALUE rb_eInterrupt;
+RUBY_EXTERN VALUE rb_eSignal;
+RUBY_EXTERN VALUE rb_eFatal;
+RUBY_EXTERN VALUE rb_eArgError;
+RUBY_EXTERN VALUE rb_eEOFError;
+RUBY_EXTERN VALUE rb_eIndexError;
+RUBY_EXTERN VALUE rb_eStopIteration;
+RUBY_EXTERN VALUE rb_eKeyError;
+RUBY_EXTERN VALUE rb_eRangeError;
+RUBY_EXTERN VALUE rb_eIOError;
+RUBY_EXTERN VALUE rb_eRuntimeError;
+RUBY_EXTERN VALUE rb_eSecurityError;
+RUBY_EXTERN VALUE rb_eSystemCallError;
+RUBY_EXTERN VALUE rb_eThreadError;
+RUBY_EXTERN VALUE rb_eTypeError;
+RUBY_EXTERN VALUE rb_eZeroDivError;
+RUBY_EXTERN VALUE rb_eNotImpError;
+RUBY_EXTERN VALUE rb_eNoMemError;
+RUBY_EXTERN VALUE rb_eNoMethodError;
+RUBY_EXTERN VALUE rb_eFloatDomainError;
+RUBY_EXTERN VALUE rb_eLocalJumpError;
+RUBY_EXTERN VALUE rb_eSysStackError;
+RUBY_EXTERN VALUE rb_eRegexpError;
+RUBY_EXTERN VALUE rb_eEncodingError;
+RUBY_EXTERN VALUE rb_eEncCompatError;
+
+RUBY_EXTERN VALUE rb_eScriptError;
+RUBY_EXTERN VALUE rb_eNameError;
+RUBY_EXTERN VALUE rb_eSyntaxError;
+RUBY_EXTERN VALUE rb_eLoadError;
+
+RUBY_EXTERN VALUE rb_eMathDomainError;
+
+RUBY_EXTERN VALUE rb_stdin, rb_stdout, rb_stderr;
+
+static inline VALUE
+rb_class_of(VALUE obj)
+{
+    if (IMMEDIATE_P(obj)) {
+	if (FIXNUM_P(obj)) return rb_cFixnum;
+	if (obj == Qtrue)  return rb_cTrueClass;
+	if (SYMBOL_P(obj)) return rb_cSymbol;
+    }
+    else if (!RTEST(obj)) {
+	if (obj == Qnil)   return rb_cNilClass;
+	if (obj == Qfalse) return rb_cFalseClass;
+    }
+    return RBASIC(obj)->klass;
+}
+
+static inline int
+rb_type(VALUE obj)
+{
+    if (IMMEDIATE_P(obj)) {
+	if (FIXNUM_P(obj)) return T_FIXNUM;
+	if (obj == Qtrue) return T_TRUE;
+	if (SYMBOL_P(obj)) return T_SYMBOL;
+	if (obj == Qundef) return T_UNDEF;
+    }
+    else if (!RTEST(obj)) {
+	if (obj == Qnil) return T_NIL;
+	if (obj == Qfalse) return T_FALSE;
+    }
+    return BUILTIN_TYPE(obj);
+}
+
+#define RB_TYPE_P(obj, type) ( \
+	((type) == T_FIXNUM) ? FIXNUM_P(obj) : \
+	((type) == T_TRUE) ? ((obj) == Qtrue) : \
+	((type) == T_FALSE) ? ((obj) == Qfalse) : \
+	((type) == T_NIL) ? ((obj) == Qnil) : \
+	((type) == T_UNDEF) ? ((obj) == Qundef) : \
+	((type) == T_SYMBOL) ? SYMBOL_P(obj) : \
+	(!SPECIAL_CONST_P(obj) && BUILTIN_TYPE(obj) == (type)))
+
+#ifdef __GNUC__
+#define rb_type_p(obj, type) \
+    __extension__ (__builtin_constant_p(type) ? RB_TYPE_P((obj), (type)) : \
+		   rb_type(obj) == (type))
+#else
+#define rb_type_p(obj, type) (rb_type(obj) == (type))
+#endif
+
+#ifdef __GNUC__
+#define rb_special_const_p(obj) \
+    __extension__ ({VALUE special_const_obj = (obj); (int)(SPECIAL_CONST_P(special_const_obj) ? Qtrue : Qfalse);})
+#else
+static inline int
+rb_special_const_p(VALUE obj)
+{
+    if (SPECIAL_CONST_P(obj)) return (int)Qtrue;
+    return (int)Qfalse;
+}
+#endif
+
+#include "ruby/missing.h"
+#include "ruby/intern.h"
+
+#if defined(EXTLIB) && defined(USE_DLN_A_OUT)
+/* hook for external modules */
+static char *dln_libs_to_be_linked[] = { EXTLIB, 0 };
+#endif
+
+#if (defined(__APPLE__) || defined(__NeXT__)) && defined(__MACH__)
+#define RUBY_GLOBAL_SETUP /* use linker option to link startup code with ObjC support */
+#else
+#define RUBY_GLOBAL_SETUP
+#endif
+
+void ruby_sysinit(int *, char ***);
+
+#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 rb_event_flag_t;
+typedef void (*rb_event_hook_func_t)(rb_event_flag_t, VALUE data, VALUE, ID, VALUE klass);
+
+typedef struct rb_event_hook_struct {
+    rb_event_flag_t flag;
+    rb_event_hook_func_t func;
+    VALUE data;
+    struct rb_event_hook_struct *next;
+} rb_event_hook_t;
+
+#define RB_EVENT_HOOKS_HAVE_CALLBACK_DATA 1
+void rb_add_event_hook(rb_event_hook_func_t func, rb_event_flag_t events,
+		       VALUE data);
+int rb_remove_event_hook(rb_event_hook_func_t func);
+
+/* locale insensitive functions */
+
+#define rb_isascii(c) ((unsigned long)(c) < 128)
+int rb_isalnum(int c);
+int rb_isalpha(int c);
+int rb_isblank(int c);
+int rb_iscntrl(int c);
+int rb_isdigit(int c);
+int rb_isgraph(int c);
+int rb_islower(int c);
+int rb_isprint(int c);
+int rb_ispunct(int c);
+int rb_isspace(int c);
+int rb_isupper(int c);
+int rb_isxdigit(int c);
+int rb_tolower(int c);
+int rb_toupper(int c);
+
+#ifndef ISPRINT
+#define ISASCII(c) rb_isascii((unsigned char)(c))
+#undef ISPRINT
+#define ISPRINT(c) rb_isprint((unsigned char)(c))
+#define ISSPACE(c) rb_isspace((unsigned char)(c))
+#define ISUPPER(c) rb_isupper((unsigned char)(c))
+#define ISLOWER(c) rb_islower((unsigned char)(c))
+#define ISALNUM(c) rb_isalnum((unsigned char)(c))
+#define ISALPHA(c) rb_isalpha((unsigned char)(c))
+#define ISDIGIT(c) rb_isdigit((unsigned char)(c))
+#define ISXDIGIT(c) rb_isxdigit((unsigned char)(c))
+#endif
+#define TOUPPER(c) rb_toupper((unsigned char)(c))
+#define TOLOWER(c) rb_tolower((unsigned char)(c))
+
+int st_strcasecmp(const char *s1, const char *s2);
+int st_strncasecmp(const char *s1, const char *s2, size_t n);
+#define STRCASECMP(s1, s2) (st_strcasecmp((s1), (s2)))
+#define STRNCASECMP(s1, s2, n) (st_strncasecmp((s1), (s2), (n)))
+
+unsigned long ruby_strtoul(const char *str, char **endptr, int base);
+#define STRTOUL(str, endptr, base) (ruby_strtoul((str), (endptr), (base)))
+
+#define InitVM(ext) {void InitVM_##ext(void);InitVM_##ext();}
+
+PRINTF_ARGS(int ruby_snprintf(char *str, size_t n, char const *fmt, ...), 3, 4);
+int ruby_vsnprintf(char *str, size_t n, char const *fmt, va_list ap);
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility pop
+#endif
+
+#ifndef RUBY_DONT_SUBST
+#include "ruby/subst.h"
+#endif
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+#endif /* RUBY_RUBY_H */
diff --git a/include/ruby/st.h b/include/ruby/st.h
new file mode 100644
index 0000000..50f2a75
--- /dev/null
+++ b/include/ruby/st.h
@@ -0,0 +1,146 @@
+/* This is a public domain general purpose hash table package written by Peter Moore @ UCB. */
+
+/* @(#) st.h 5.1 89/12/14 */
+
+#ifndef RUBY_ST_H
+#define RUBY_ST_H 1
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+#include "ruby/defines.h"
+
+#if   defined STDC_HEADERS
+#include <stddef.h>
+#elif defined HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#ifdef HAVE_STDINT_H
+# include <stdint.h>
+#endif
+#ifdef HAVE_INTTYPES_H
+# include <inttypes.h>
+#endif
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility push(default)
+#endif
+
+#if SIZEOF_LONG == SIZEOF_VOIDP
+typedef unsigned long st_data_t;
+#elif SIZEOF_LONG_LONG == SIZEOF_VOIDP
+typedef unsigned LONG_LONG st_data_t;
+#else
+# error ---->> st.c requires sizeof(void*) == sizeof(long) to be compiled. <<----
+#endif
+#define ST_DATA_T_DEFINED
+
+#ifndef CHAR_BIT
+# ifdef HAVE_LIMITS_H
+#  include <limits.h>
+# else
+#  define CHAR_BIT 8
+# endif
+#endif
+#ifndef _
+# define _(args) args
+#endif
+#ifndef ANYARGS
+# ifdef __cplusplus
+#   define ANYARGS ...
+# else
+#   define ANYARGS
+# endif
+#endif
+
+typedef struct st_table st_table;
+
+typedef st_data_t st_index_t;
+typedef int st_compare_func(st_data_t, st_data_t);
+typedef st_index_t st_hash_func(st_data_t);
+
+typedef char st_check_for_sizeof_st_index_t[SIZEOF_VOIDP == (int)sizeof(st_index_t) ? 1 : -1];
+#define SIZEOF_ST_INDEX_T SIZEOF_VOIDP
+
+struct st_hash_type {
+    int (*compare)(ANYARGS /*st_data_t, st_data_t*/); /* st_compare_func* */
+    st_index_t (*hash)(ANYARGS /*st_data_t*/);        /* st_hash_func* */
+};
+
+#define ST_INDEX_BITS (sizeof(st_index_t) * CHAR_BIT)
+
+struct st_table {
+    const struct st_hash_type *type;
+    st_index_t num_bins;
+    unsigned int entries_packed : 1;
+#ifdef __GNUC__
+    /*
+     * C spec says,
+     *   A bit-field shall have a type that is a qualified or unqualified
+     *   version of _Bool, signed int, unsigned int, or some other
+     *   implementation-defined type. It is implementation-defined whether
+     *   atomic types are permitted.
+     * In short, long and long long bit-field are implementation-defined
+     * feature. Therefore we want to supress a warning explicitly.
+     */
+    __extension__
+#endif
+    st_index_t num_entries : ST_INDEX_BITS - 1;
+    struct st_table_entry **bins;
+    struct st_table_entry *head, *tail;
+};
+
+#define st_is_member(table,key) st_lookup((table),(key),(st_data_t *)0)
+
+enum st_retval {ST_CONTINUE, ST_STOP, ST_DELETE, ST_CHECK};
+
+st_table *st_init_table(const struct st_hash_type *);
+st_table *st_init_table_with_size(const struct st_hash_type *, st_index_t);
+st_table *st_init_numtable(void);
+st_table *st_init_numtable_with_size(st_index_t);
+st_table *st_init_strtable(void);
+st_table *st_init_strtable_with_size(st_index_t);
+st_table *st_init_strcasetable(void);
+st_table *st_init_strcasetable_with_size(st_index_t);
+int st_delete(st_table *, st_data_t *, st_data_t *); /* returns 0:notfound 1:deleted */
+int st_delete_safe(st_table *, st_data_t *, st_data_t *, st_data_t);
+int st_insert(st_table *, st_data_t, st_data_t);
+int st_insert2(st_table *, st_data_t, st_data_t, st_data_t (*)(st_data_t));
+int st_lookup(st_table *, st_data_t, st_data_t *);
+int st_get_key(st_table *, st_data_t, st_data_t *);
+int st_foreach(st_table *, int (*)(ANYARGS), st_data_t);
+int st_reverse_foreach(st_table *, int (*)(ANYARGS), st_data_t);
+void st_add_direct(st_table *, st_data_t, st_data_t);
+void st_free_table(st_table *);
+void st_cleanup_safe(st_table *, st_data_t);
+void st_clear(st_table *);
+st_table *st_copy(st_table *);
+int st_numcmp(st_data_t, st_data_t);
+st_index_t st_numhash(st_data_t);
+int st_strcasecmp(const char *s1, const char *s2);
+int st_strncasecmp(const char *s1, const char *s2, size_t n);
+size_t st_memsize(const st_table *);
+st_index_t st_hash(const void *ptr, size_t len, st_index_t h);
+st_index_t st_hash_uint32(st_index_t h, uint32_t i);
+st_index_t st_hash_uint(st_index_t h, st_index_t i);
+st_index_t st_hash_end(st_index_t h);
+st_index_t st_hash_start(st_index_t h);
+#define st_hash_start(h) ((st_index_t)(h))
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility pop
+#endif
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+#endif /* RUBY_ST_H */
diff --git a/include/ruby/subst.h b/include/ruby/subst.h
new file mode 100644
index 0000000..6c01b25
--- /dev/null
+++ b/include/ruby/subst.h
@@ -0,0 +1,20 @@
+#ifndef RUBY_SUBST_H
+#define RUBY_SUBST_H 1
+
+#undef snprintf
+#undef vsnprintf
+#define snprintf ruby_snprintf
+#define vsnprintf ruby_vsnprintf
+
+#ifdef BROKEN_CLOSE
+#undef getpeername
+#define getpeername ruby_getpeername
+#undef getsockname
+#define getsockname ruby_getsockname
+#undef shutdown
+#define shutdown ruby_shutdown
+#undef close
+#define close ruby_close
+#endif
+
+#endif
diff --git a/include/ruby/util.h b/include/ruby/util.h
new file mode 100644
index 0000000..c56d3f2
--- /dev/null
+++ b/include/ruby/util.h
@@ -0,0 +1,103 @@
+/**********************************************************************
+
+  util.h -
+
+  $Author: akr $
+  created at: Thu Mar  9 11:55:53 JST 1995
+
+  Copyright (C) 1993-2007 Yukihiro Matsumoto
+
+**********************************************************************/
+
+#ifndef RUBY_UTIL_H
+#define RUBY_UTIL_H 1
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+#include "ruby/defines.h"
+#ifdef RUBY_EXTCONF_H
+#include RUBY_EXTCONF_H
+#endif
+
+#ifndef _
+#ifdef __cplusplus
+# ifndef  HAVE_PROTOTYPES
+#  define HAVE_PROTOTYPES 1
+# endif
+# ifndef  HAVE_STDARG_PROTOTYPES
+#  define HAVE_STDARG_PROTOTYPES 1
+# endif
+#endif
+#ifdef HAVE_PROTOTYPES
+# define _(args) args
+#else
+# define _(args) ()
+#endif
+#ifdef HAVE_STDARG_PROTOTYPES
+# define __(args) args
+#else
+# define __(args) ()
+#endif
+#endif
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility push(default)
+#endif
+
+#define scan_oct(s,l,e) ((int)ruby_scan_oct((s),(l),(e)))
+unsigned long ruby_scan_oct(const char *, size_t, size_t *);
+#define scan_hex(s,l,e) ((int)ruby_scan_hex((s),(l),(e)))
+unsigned long ruby_scan_hex(const char *, size_t, size_t *);
+
+#if defined(__CYGWIN32__) || defined(_WIN32)
+void ruby_add_suffix(VALUE str, const char *suffix);
+#endif
+
+void ruby_qsort(void *, const size_t, const size_t,
+		int (*)(const void *, const void *, void *), void *);
+
+void ruby_setenv(const char *, const char *);
+void ruby_unsetenv(const char *);
+#undef setenv
+#undef unsetenv
+#define setenv(name,val) ruby_setenv((name),(val))
+#define unsetenv(name,val) ruby_unsetenv(name);
+
+char *ruby_strdup(const char *);
+#undef strdup
+#define strdup(s) ruby_strdup(s)
+
+char *ruby_getcwd(void);
+#define my_getcwd() ruby_getcwd()
+
+double ruby_strtod(const char *, char **);
+#undef strtod
+#define strtod(s,e) ruby_strtod((s),(e))
+
+#if defined _MSC_VER && _MSC_VER >= 1300
+#pragma warning(push)
+#pragma warning(disable:4723)
+#endif
+#if defined _MSC_VER && _MSC_VER >= 1300
+#pragma warning(pop)
+#endif
+
+void ruby_each_words(const char *, void (*)(const char*, int, void*), void *);
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility pop
+#endif
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+#endif /* RUBY_UTIL_H */
diff --git a/include/ruby/version.h b/include/ruby/version.h
new file mode 100644
index 0000000..39c8e43
--- /dev/null
+++ b/include/ruby/version.h
@@ -0,0 +1,78 @@
+/**********************************************************************
+
+  ruby/version.h -
+
+  $Author: nobu $
+  created at: Wed May 13 12:56:56 JST 2009
+
+  Copyright (C) 1993-2009 Yukihiro Matsumoto
+  Copyright (C) 2000  Network Applied Communication Laboratory, Inc.
+  Copyright (C) 2000  Information-technology Promotion Agency, Japan
+
+**********************************************************************/
+
+/*
+ * This file contains only
+ * - never-changable informations, and
+ * - interfaces accessible from extension libraries.
+ *
+ * Never try to check RUBY_VERSION_CODE etc in extension libraries,
+ * check the features with mkmf.rb instead.
+ */
+
+#ifndef RUBY_VERSION_H
+#define RUBY_VERSION_H 1
+
+/* The origin. */
+#define RUBY_AUTHOR "Yukihiro Matsumoto"
+#define RUBY_BIRTH_YEAR 1993
+#define RUBY_BIRTH_MONTH 2
+#define RUBY_BIRTH_DAY 24
+
+/* API version */
+#define RUBY_API_VERSION_MAJOR 1
+#define RUBY_API_VERSION_MINOR 9
+#define RUBY_API_VERSION_TEENY 1
+#define RUBY_API_VERSION_CODE (RUBY_API_VERSION_MAJOR*10000+RUBY_API_VERSION_MINOR*100+RUBY_API_VERSION_TEENY)
+
+#ifdef RUBY_EXTERN
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility push(default)
+#endif
+
+/*
+ * Interfaces from extension libraries.
+ *
+ * Before using these infos, think thrice whether they are really
+ * necessary or not, and if the answer was yes, think twice a week
+ * later again.
+ */
+RUBY_EXTERN const int ruby_api_version[3];
+RUBY_EXTERN const char ruby_version[];
+RUBY_EXTERN const char ruby_release_date[];
+RUBY_EXTERN const char ruby_platform[];
+RUBY_EXTERN const int  ruby_patchlevel;
+RUBY_EXTERN const char ruby_description[];
+RUBY_EXTERN const char ruby_copyright[];
+RUBY_EXTERN const char ruby_engine[];
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility pop
+#endif
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+#endif
+
+#endif
diff --git a/include/ruby/vm.h b/include/ruby/vm.h
new file mode 100644
index 0000000..ccc9c0e
--- /dev/null
+++ b/include/ruby/vm.h
@@ -0,0 +1,68 @@
+/**********************************************************************
+
+  ruby/vm.h -
+
+  $Author: shyouhei $
+  created at: Sat May 31 15:17:36 2008
+
+  Copyright (C) 2008 Yukihiro Matsumoto
+
+**********************************************************************/
+
+#ifndef RUBY_VM_H
+#define RUBY_VM_H 1
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility push(default)
+#endif
+
+/* Place holder.
+ *
+ * We will prepare VM creation/control APIs on 1.9.2 or later.
+ * If you have an interest about it, please see mvm branch.
+ * http://svn.ruby-lang.org/cgi-bin/viewvc.cgi/branches/mvm/
+ */
+
+/* VM type declaration */
+typedef struct rb_vm_struct ruby_vm_t;
+
+/* core API */
+int ruby_vm_destruct(ruby_vm_t *vm);
+
+/**
+ * ruby_vm_at_exit registers a function _func_ to be invoked when a VM
+ * passed away.  Functions registered this way runs in reverse order
+ * of registration, just like END {} block does.  The difference is
+ * its timing to be triggered. ruby_vm_at_exit functions runs when a
+ * VM _passed_ _away_, while END {} blocks runs just _before_ a VM
+ * _is_ _passing_ _away_.
+ *
+ * You cannot register a function to another VM than where you are in.
+ * So where to register is intuitive, omitted.  OTOH the argument
+ * _func_ cannot know which VM it is in because at the time of
+ * invocation, the VM has already died and there is no execution
+ * context.  The VM itself is passed as the first argument to it.
+ *
+ * @param[in] func the function to register.
+ */
+void ruby_vm_at_exit(void(*func)(ruby_vm_t *));
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility pop
+#endif
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+#endif /* RUBY_VM_H */
diff --git a/include/ruby/win32.h b/include/ruby/win32.h
new file mode 100644
index 0000000..3d15742
--- /dev/null
+++ b/include/ruby/win32.h
@@ -0,0 +1,744 @@
+#ifndef RUBY_WIN32_H
+#define RUBY_WIN32_H 1
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility push(default)
+#endif
+
+/*
+ *  Copyright (c) 1993, Intergraph Corporation
+ *
+ *  You may distribute under the terms of either the GNU General Public
+ *  License or the Artistic License, as specified in the perl README file.
+ *
+ */
+
+//
+// Definitions for NT port of Perl
+//
+
+
+//
+// Ok now we can include the normal include files.
+//
+
+// #include <stdarg.h> conflict with varargs.h?
+#if !defined(WSAAPI)
+#if defined(__cplusplus) && defined(_MSC_VER)
+extern "C++" {			/* template without extern "C++" */
+#endif
+#if !defined(_WIN64) && !defined(WIN32)
+#define WIN32
+#endif
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#if defined(__cplusplus) && defined(_MSC_VER)
+}
+#endif
+#endif
+
+#define NT 1			/* deprecated */
+
+//
+// We're not using Microsoft's "extensions" to C for
+// Structured Exception Handling (SEH) so we can nuke these
+//
+#undef try
+#undef except
+#undef finally
+#undef leave
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <direct.h>
+#include <process.h>
+#include <time.h>
+#if defined(__cplusplus) && defined(_MSC_VER) && _MSC_VER == 1200
+extern "C++" {			/* template without extern "C++" */
+#endif
+#include <math.h>
+#if defined(__cplusplus) && defined(_MSC_VER) && _MSC_VER == 1200
+}
+#endif
+#include <signal.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#ifdef HAVE_SYS_UTIME_H
+# include <sys/utime.h>
+#else
+# include <utime.h>
+#endif
+#include <io.h>
+#include <malloc.h>
+#if defined __MINGW32__ || __BORLANDC__ >= 0x0580
+# include <stdint.h>
+#else
+# if !defined(_INTPTR_T_DEFINED)
+#  ifdef _WIN64
+typedef __int64 intptr_t;
+#  else
+typedef int intptr_t;
+#  endif
+#  define _INTPTR_T_DEFINED
+# endif
+# if !defined(_UINTPTR_T_DEFINED)
+#  ifdef _WIN64
+typedef unsigned __int64 uintptr_t;
+#  else
+typedef unsigned int uintptr_t;
+#  endif
+#  define _UINTPTR_T_DEFINED
+# endif
+#endif
+#ifndef __MINGW32__
+# define mode_t int
+#endif
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+#ifdef WIN95
+extern DWORD rb_w32_osid(void);
+#define rb_w32_iswinnt()  (rb_w32_osid() == VER_PLATFORM_WIN32_NT)
+#define rb_w32_iswin95()  (rb_w32_osid() == VER_PLATFORM_WIN32_WINDOWS)
+#else
+#define rb_w32_iswinnt()  TRUE
+#define rb_w32_iswin95()  FALSE
+#endif
+
+#define WNOHANG -1
+
+#undef getc
+#undef putc
+#undef fgetc
+#undef fputc
+#undef getchar
+#undef putchar
+#undef fgetchar
+#undef fputchar
+#undef utime
+#undef lseek
+#undef fstat
+#define getc(_stream)		rb_w32_getc(_stream)
+#define getchar()		rb_w32_getc(stdin)
+#define putc(_c, _stream)	rb_w32_putc(_c, _stream)
+#define putchar(_c)		rb_w32_putc(_c, stdout)
+#ifdef RUBY_EXPORT
+#define fgetc(_stream)		getc(_stream)
+#define fputc(_c, _stream)	putc(_c, _stream)
+#define fgetchar()		getchar()
+#define fputchar(_c)		putchar(_c)
+#define utime(_p, _t)		rb_w32_utime(_p, _t)
+#define lseek(_f, _o, _w)	_lseeki64(_f, _o, _w)
+
+#define pipe(p)			rb_w32_pipe(p)
+#define open			rb_w32_open
+#define close(h)		rb_w32_close(h)
+#define fclose(f)		rb_w32_fclose(f)
+#define read(f, b, s)		rb_w32_read(f, b, s)
+#define write(f, b, s)		rb_w32_write(f, b, s)
+#define getpid()		rb_w32_getpid()
+#define getppid()		rb_w32_getppid()
+#define sleep(x)		rb_w32_Sleep((x)*1000)
+#define Sleep(msec)		(void)rb_w32_Sleep(msec)
+#ifdef __BORLANDC__
+#define creat(p, m)		_creat(p, m)
+#define eof()			_eof()
+#define filelength(h)		_filelength(h)
+#define mktemp(t)		_mktemp(t)
+#define tell(h)			_tell(h)
+#define _open			_sopen
+#define sopen			_sopen
+#define _fstati64(fd,st)	rb_w32_fstati64(fd,st)
+#undef fopen
+#define fopen(p, m)		rb_w32_fopen(p, m)
+#undef fdopen
+#define fdopen(h, m)		rb_w32_fdopen(h, m)
+#undef fsopen
+#define fsopen(p, m, sh)	rb_w32_fsopen(p, m, sh)
+#endif /* __BORLANDC__ */
+
+#undef execv
+#define execv(path,argv)	rb_w32_aspawn(P_OVERLAY,path,argv)
+#if !defined(__BORLANDC__)
+#undef isatty
+#define isatty(h)		rb_w32_isatty(h)
+#endif /* __BORLANDC__ */
+
+#undef mkdir
+#define mkdir(p, m)		rb_w32_mkdir(p, m)
+#undef rmdir
+#define rmdir(p)		rb_w32_rmdir(p)
+#undef unlink
+#define unlink(p)		rb_w32_unlink(p)
+#endif /* RUBY_EXPORT */
+
+#if SIZEOF_OFF_T == 8
+#define off_t __int64
+#define stat stati64
+#define fstat(fd,st)		_fstati64(fd,st)
+#if defined(__BORLANDC__)
+#define stati64(path, st) rb_w32_stati64(path, st)
+#elif !defined(_MSC_VER) || RT_VER < 80
+#define stati64 _stati64
+#ifndef _stati64
+#define _stati64(path, st) rb_w32_stati64(path, st)
+#endif
+#else
+#define stati64 _stat64
+#define _stat64(path, st) rb_w32_stati64(path, st)
+#define _fstati64 _fstat64
+#endif
+#else
+#define stat(path,st)		rb_w32_stat(path,st)
+#define fstat(fd,st)		rb_w32_fstat(fd,st)
+extern int rb_w32_stat(const char *, struct stat *);
+extern int rb_w32_fstat(int, struct stat *);
+#endif
+#define access(path,mode)	rb_w32_access(path,mode)
+
+#define strcasecmp		_stricmp
+#define strncasecmp		_strnicmp
+#define fsync			_commit
+
+struct timezone;
+
+#ifdef __MINGW32__
+#undef isascii
+#define isascii __isascii
+#endif
+
+struct iovec {
+    void *iov_base;
+    size_t iov_len;
+};
+struct msghdr {
+    void *msg_name;
+    int msg_namelen;
+    struct iovec *msg_iov;
+    int msg_iovlen;
+    void *msg_control;
+    int msg_controllen;
+    int msg_flags;
+};
+
+#define NtInitialize ruby_sysinit
+extern int    rb_w32_cmdvector(const char *, char ***);
+extern rb_pid_t  rb_w32_pipe_exec(const char *, const char *, int, int *, int *);
+extern int    flock(int fd, int oper);
+extern int    rb_w32_has_cancel_io(void);
+extern int    rb_w32_is_socket(int);
+extern int    WSAAPI rb_w32_accept(int, struct sockaddr *, int *);
+extern int    WSAAPI rb_w32_bind(int, const struct sockaddr *, int);
+extern int    WSAAPI rb_w32_connect(int, const struct sockaddr *, int);
+extern void   rb_w32_fdset(int, fd_set*);
+extern void   rb_w32_fdclr(int, fd_set*);
+extern int    rb_w32_fdisset(int, fd_set*);
+extern int    WSAAPI rb_w32_select(int, fd_set *, fd_set *, fd_set *, struct timeval *);
+extern int    WSAAPI rb_w32_getpeername(int, struct sockaddr *, int *);
+extern int    WSAAPI rb_w32_getsockname(int, struct sockaddr *, int *);
+extern int    WSAAPI rb_w32_getsockopt(int, int, int, char *, int *);
+extern int    WSAAPI rb_w32_ioctlsocket(int, long, u_long *);
+extern int    WSAAPI rb_w32_listen(int, int);
+extern int    WSAAPI rb_w32_recv(int, char *, int, int);
+extern int    WSAAPI rb_w32_recvfrom(int, char *, int, int, struct sockaddr *, int *);
+extern int    WSAAPI rb_w32_send(int, const char *, int, int);
+extern int    WSAAPI rb_w32_sendto(int, const char *, int, int, const struct sockaddr *, int);
+extern int    recvmsg(int, struct msghdr *, int);
+extern int    sendmsg(int, const struct msghdr *, int);
+extern int    WSAAPI rb_w32_setsockopt(int, int, int, const char *, int);
+extern int    WSAAPI rb_w32_shutdown(int, int);
+extern int    WSAAPI rb_w32_socket(int, int, int);
+extern SOCKET rb_w32_get_osfhandle(int);
+extern struct hostent *WSAAPI rb_w32_gethostbyaddr(const char *, int, int);
+extern struct hostent *WSAAPI rb_w32_gethostbyname(const char *);
+extern int    WSAAPI rb_w32_gethostname(char *, int);
+extern struct protoent *WSAAPI rb_w32_getprotobyname(const char *);
+extern struct protoent *WSAAPI rb_w32_getprotobynumber(int);
+extern struct servent  *WSAAPI rb_w32_getservbyname(const char *, const char *);
+extern struct servent  *WSAAPI rb_w32_getservbyport(int, const char *);
+extern int    rb_w32_socketpair(int, int, int, int *);
+extern char * rb_w32_getcwd(char *, int);
+extern char * rb_w32_getenv(const char *);
+extern int    rb_w32_rename(const char *, const char *);
+extern int    rb_w32_urename(const char *, const char *);
+extern char **rb_w32_get_environ(void);
+extern void   rb_w32_free_environ(char **);
+extern int    rb_w32_map_errno(DWORD);
+extern char * WSAAPI rb_w32_inet_ntop(int,void *,char *,size_t);
+extern DWORD  rb_w32_osver(void);
+
+extern int chown(const char *, int, int);
+extern int rb_w32_uchown(const char *, int, int);
+extern int link(const char *, const char *);
+extern int rb_w32_ulink(const char *, const char *);
+extern int gettimeofday(struct timeval *, struct timezone *);
+extern rb_pid_t waitpid (rb_pid_t, int *, int);
+extern rb_pid_t rb_w32_spawn(int, const char *, const char*);
+extern rb_pid_t rb_w32_aspawn(int, const char *, char *const *);
+extern rb_pid_t rb_w32_aspawn_flags(int, const char *, char *const *, DWORD);
+extern int kill(int, int);
+extern int fcntl(int, int, ...);
+extern rb_pid_t rb_w32_getpid(void);
+extern rb_pid_t rb_w32_getppid(void);
+#if !defined(__BORLANDC__)
+extern int rb_w32_isatty(int);
+#endif
+extern int rb_w32_uchdir(const char *);
+extern int rb_w32_mkdir(const char *, int);
+extern int rb_w32_umkdir(const char *, int);
+extern int rb_w32_rmdir(const char *);
+extern int rb_w32_urmdir(const char *);
+extern int rb_w32_unlink(const char *);
+extern int rb_w32_uunlink(const char *);
+extern int rb_w32_uchmod(const char *, int);
+extern int rb_w32_stati64(const char *, struct stati64 *);
+extern int rb_w32_ustati64(const char *, struct stati64 *);
+extern int rb_w32_access(const char *, int);
+extern int rb_w32_uaccess(const char *, int);
+extern char rb_w32_fd_is_text(int);
+
+#ifdef __BORLANDC__
+extern int rb_w32_fstati64(int, struct stati64 *);
+extern off_t _lseeki64(int, off_t, int);
+extern FILE *rb_w32_fopen(const char *, const char *);
+extern FILE *rb_w32_fdopen(int, const char *);
+extern FILE *rb_w32_fsopen(const char *, const char *, int);
+#endif
+
+#include <float.h>
+#if !defined __MINGW32__ || defined __NO_ISOCEXT
+#ifndef isnan
+#define isnan(x) _isnan(x)
+#endif
+static inline int
+finite(double x)
+{
+    return _finite(x);
+}
+#ifndef copysign
+#define copysign(a, b) _copysign(a, b)
+#endif
+static inline double
+scalb(double a, long b)
+{
+    return _scalb(a, b);
+}
+#endif
+
+#if !defined S_IFIFO && defined _S_IFIFO
+#define S_IFIFO _S_IFIFO
+#endif
+
+#if 0 && defined __BORLANDC__
+#undef S_ISDIR
+#undef S_ISFIFO
+#undef S_ISBLK
+#undef S_ISCHR
+#undef S_ISREG
+#define S_ISDIR(m)  (((unsigned short)(m) & S_IFMT) == S_IFDIR)
+#define S_ISFIFO(m) (((unsigned short)(m) & S_IFMT) == S_IFIFO)
+#define S_ISBLK(m)  (((unsigned short)(m) & S_IFMT) == S_IFBLK)
+#define S_ISCHR(m)  (((unsigned short)(m) & S_IFMT) == S_IFCHR)
+#define S_ISREG(m)  (((unsigned short)(m) & S_IFMT) == S_IFREG)
+#endif
+
+#if !defined S_IRUSR && !defined __MINGW32__
+#define S_IRUSR 0400
+#endif
+#ifndef S_IRGRP
+#define S_IRGRP 0040
+#endif
+#ifndef S_IROTH
+#define S_IROTH 0004
+#endif
+
+#if !defined S_IWUSR && !defined __MINGW32__
+#define S_IWUSR 0200
+#endif
+#ifndef S_IWGRP
+#define S_IWGRP 0020
+#endif
+#ifndef S_IWOTH
+#define S_IWOTH 0002
+#endif
+
+#if !defined S_IXUSR && !defined __MINGW32__
+#define S_IXUSR 0100
+#endif
+#ifndef S_IXGRP
+#define S_IXGRP 0010
+#endif
+#ifndef S_IXOTH
+#define S_IXOTH 0001
+#endif
+
+//
+// define this so we can do inplace editing
+//
+
+#define SUFFIX
+
+extern int 	 rb_w32_ftruncate(int fd, off_t length);
+extern int 	 rb_w32_truncate(const char *path, off_t length);
+extern off_t	 rb_w32_ftello(FILE *stream);
+extern int 	 rb_w32_fseeko(FILE *stream, off_t offset, int whence);
+
+#undef HAVE_FTRUNCATE
+#define HAVE_FTRUNCATE 1
+#if defined HAVE_FTRUNCATE64
+#define ftruncate ftruncate64
+#else
+#define ftruncate rb_w32_ftruncate
+#endif
+
+#undef HAVE_TRUNCATE
+#define HAVE_TRUNCATE 1
+#if defined HAVE_TRUNCATE64
+#define truncate truncate64
+#else
+#define truncate rb_w32_truncate
+#endif
+
+#undef HAVE_FSEEKO
+#define HAVE_FSEEKO 1
+#if defined HAVE_FSEEKO64
+#define fseeko fseeko64
+#else
+#define fseeko rb_w32_fseeko
+#endif
+
+#undef HAVE_FTELLO
+#define HAVE_FTELLO 1
+#if defined HAVE_FTELLO64
+#define ftello ftello64
+#else
+#define ftello rb_w32_ftello
+#endif
+
+//
+// stubs
+//
+extern int       ioctl (int, int, ...);
+extern rb_uid_t  getuid (void);
+extern rb_uid_t  geteuid (void);
+extern rb_gid_t  getgid (void);
+extern rb_gid_t  getegid (void);
+extern int       setuid (rb_uid_t);
+extern int       setgid (rb_gid_t);
+
+extern char *rb_w32_strerror(int);
+
+#ifdef RUBY_EXPORT
+#define strerror(e) rb_w32_strerror(e)
+#endif
+
+#define PIPE_BUF 1024
+
+#define LOCK_SH 1
+#define LOCK_EX 2
+#define LOCK_NB 4
+#define LOCK_UN 8
+
+
+#ifndef SIGINT
+#define SIGINT 2
+#endif
+#ifndef SIGKILL
+#define SIGKILL	9
+#endif
+
+
+/* #undef va_start */
+/* #undef va_end */
+
+/* winsock error map */
+#include <errno.h>
+
+#ifndef EWOULDBLOCK
+# define EWOULDBLOCK		WSAEWOULDBLOCK
+#endif
+#ifndef EINPROGRESS
+# define EINPROGRESS		WSAEINPROGRESS
+#endif
+#ifndef EALREADY
+# define EALREADY		WSAEALREADY
+#endif
+#ifndef ENOTSOCK
+# define ENOTSOCK		WSAENOTSOCK
+#endif
+#ifndef EDESTADDRREQ
+# define EDESTADDRREQ		WSAEDESTADDRREQ
+#endif
+#ifndef EMSGSIZE
+# define EMSGSIZE		WSAEMSGSIZE
+#endif
+#ifndef EPROTOTYPE
+# define EPROTOTYPE		WSAEPROTOTYPE
+#endif
+#ifndef ENOPROTOOPT
+# define ENOPROTOOPT		WSAENOPROTOOPT
+#endif
+#ifndef EPROTONOSUPPORT
+# define EPROTONOSUPPORT	WSAEPROTONOSUPPORT
+#endif
+#ifndef ESOCKTNOSUPPORT
+# define ESOCKTNOSUPPORT	WSAESOCKTNOSUPPORT
+#endif
+#ifndef EOPNOTSUPP
+# define EOPNOTSUPP		WSAEOPNOTSUPP
+#endif
+#ifndef EPFNOSUPPORT
+# define EPFNOSUPPORT		WSAEPFNOSUPPORT
+#endif
+#ifndef EAFNOSUPPORT
+# define EAFNOSUPPORT		WSAEAFNOSUPPORT
+#endif
+#ifndef EADDRINUSE
+# define EADDRINUSE		WSAEADDRINUSE
+#endif
+#ifndef EADDRNOTAVAIL
+# define EADDRNOTAVAIL		WSAEADDRNOTAVAIL
+#endif
+#ifndef ENETDOWN
+# define ENETDOWN		WSAENETDOWN
+#endif
+#ifndef ENETUNREACH
+# define ENETUNREACH		WSAENETUNREACH
+#endif
+#ifndef ENETRESET
+# define ENETRESET		WSAENETRESET
+#endif
+#ifndef ECONNABORTED
+# define ECONNABORTED		WSAECONNABORTED
+#endif
+#ifndef ECONNRESET
+# define ECONNRESET		WSAECONNRESET
+#endif
+#ifndef ENOBUFS
+# define ENOBUFS		WSAENOBUFS
+#endif
+#ifndef EISCONN
+# define EISCONN		WSAEISCONN
+#endif
+#ifndef ENOTCONN
+# define ENOTCONN		WSAENOTCONN
+#endif
+#ifndef ESHUTDOWN
+# define ESHUTDOWN		WSAESHUTDOWN
+#endif
+#ifndef ETOOMANYREFS
+# define ETOOMANYREFS		WSAETOOMANYREFS
+#endif
+#ifndef ETIMEDOUT
+# define ETIMEDOUT		WSAETIMEDOUT
+#endif
+#ifndef ECONNREFUSED
+# define ECONNREFUSED		WSAECONNREFUSED
+#endif
+#ifndef ELOOP
+# define ELOOP			WSAELOOP
+#endif
+/*#define ENAMETOOLONG	WSAENAMETOOLONG*/
+#ifndef EHOSTDOWN
+# define EHOSTDOWN		WSAEHOSTDOWN
+#endif
+#ifndef EHOSTUNREACH
+# define EHOSTUNREACH		WSAEHOSTUNREACH
+#endif
+/*#define ENOTEMPTY	WSAENOTEMPTY*/
+#ifndef EPROCLIM
+# define EPROCLIM		WSAEPROCLIM
+#endif
+#ifndef EUSERS
+# define EUSERS			WSAEUSERS
+#endif
+#ifndef EDQUOT
+# define EDQUOT			WSAEDQUOT
+#endif
+#ifndef ESTALE
+# define ESTALE			WSAESTALE
+#endif
+#ifndef EREMOTE
+# define EREMOTE		WSAEREMOTE
+#endif
+
+#define F_SETFL 1
+#define O_NONBLOCK 1
+
+#undef FD_SET
+#define FD_SET(f, s)		rb_w32_fdset(f, s)
+
+#undef FD_CLR
+#define FD_CLR(f, s)		rb_w32_fdclr(f, s)
+
+#undef FD_ISSET
+#define FD_ISSET(f, s)		rb_w32_fdisset(f, s)
+
+#ifdef RUBY_EXPORT
+#undef inet_ntop
+#define inet_ntop(f,a,n,l)      rb_w32_inet_ntop(f,a,n,l)
+
+#undef accept
+#define accept(s, a, l)		rb_w32_accept(s, a, l)
+
+#undef bind
+#define bind(s, a, l)		rb_w32_bind(s, a, l)
+
+#undef connect
+#define connect(s, a, l)	rb_w32_connect(s, a, l)
+
+#undef select
+#define select(n, r, w, e, t)	rb_w32_select(n, r, w, e, t)
+
+#undef getpeername
+#define getpeername(s, a, l)	rb_w32_getpeername(s, a, l)
+
+#undef getsockname
+#define getsockname(s, a, l)	rb_w32_getsockname(s, a, l)
+
+#undef getsockopt
+#define getsockopt(s, v, n, o, l) rb_w32_getsockopt(s, v, n, o, l)
+
+#undef ioctlsocket
+#define ioctlsocket(s, c, a)	rb_w32_ioctlsocket(s, c, a)
+
+#undef listen
+#define listen(s, b)		rb_w32_listen(s, b)
+
+#undef recv
+#define recv(s, b, l, f)	rb_w32_recv(s, b, l, f)
+
+#undef recvfrom
+#define recvfrom(s, b, l, f, fr, frl) rb_w32_recvfrom(s, b, l, f, fr, frl)
+
+#undef send
+#define send(s, b, l, f)	rb_w32_send(s, b, l, f)
+
+#undef sendto
+#define sendto(s, b, l, f, t, tl) rb_w32_sendto(s, b, l, f, t, tl)
+
+#undef setsockopt
+#define setsockopt(s, v, n, o, l) rb_w32_setsockopt(s, v, n, o, l)
+
+#undef shutdown
+#define shutdown(s, h)		rb_w32_shutdown(s, h)
+
+#undef socket
+#define socket(s, t, p)		rb_w32_socket(s, t, p)
+
+#undef gethostbyaddr
+#define gethostbyaddr(a, l, t)	rb_w32_gethostbyaddr(a, l, t)
+
+#undef gethostbyname
+#define gethostbyname(n)	rb_w32_gethostbyname(n)
+
+#undef gethostname
+#define gethostname(n, l)	rb_w32_gethostname(n, l)
+
+#undef getprotobyname
+#define getprotobyname(n)	rb_w32_getprotobyname(n)
+
+#undef getprotobynumber
+#define getprotobynumber(n)	rb_w32_getprotobynumber(n)
+
+#undef getservbyname
+#define getservbyname(n, p)	rb_w32_getservbyname(n, p)
+
+#undef getservbyport
+#define getservbyport(p, pr)	rb_w32_getservbyport(p, pr)
+
+#undef socketpair
+#define socketpair(a, t, p, s)	rb_w32_socketpair(a, t, p, s)
+
+#undef get_osfhandle
+#define get_osfhandle(h)	rb_w32_get_osfhandle(h)
+
+#undef getcwd
+#define getcwd(b, s)		rb_w32_getcwd(b, s)
+
+#undef getenv
+#define getenv(n)		rb_w32_getenv(n)
+
+#undef rename
+#define rename(o, n)		rb_w32_rename(o, n)
+
+#undef times
+#define times(t)		rb_w32_times(t)
+#endif
+
+struct tms {
+	long	tms_utime;
+	long	tms_stime;
+	long	tms_cutime;
+	long	tms_cstime;
+};
+
+int rb_w32_times(struct tms *);
+
+/* thread stuff */
+HANDLE GetCurrentThreadHandle(void);
+int  rb_w32_sleep(unsigned long msec);
+int  rb_w32_putc(int, FILE*);
+int  rb_w32_getc(FILE*);
+int  rb_w32_open(const char *, int, ...);
+int  rb_w32_uopen(const char *, int, ...);
+int  rb_w32_wopen(const WCHAR *, int, ...);
+int  rb_w32_close(int);
+int  rb_w32_fclose(FILE*);
+int  rb_w32_pipe(int[2]);
+ssize_t rb_w32_read(int, void *, size_t);
+ssize_t rb_w32_write(int, const void *, size_t);
+int  rb_w32_utime(const char *, const struct utimbuf *);
+int  rb_w32_uutime(const char *, const struct utimbuf *);
+long rb_w32_write_console(uintptr_t, int);	/* use uintptr_t instead of VALUE because it's not defined yet here */
+int  WINAPI rb_w32_Sleep(unsigned long msec);
+int  rb_w32_wait_events_blocking(HANDLE *events, int num, DWORD timeout);
+int  rb_w32_time_subtract(struct timeval *rest, const struct timeval *wait);
+
+/*
+== ***CAUTION***
+Since this function is very dangerous, ((*NEVER*))
+* lock any HANDLEs(i.e. Mutex, Semaphore, CriticalSection and so on) or,
+* use anything like TRAP_BEG...TRAP_END block structure,
+in asynchronous_func_t.
+*/
+typedef uintptr_t (*asynchronous_func_t)(uintptr_t self, int argc, uintptr_t* argv);
+uintptr_t rb_w32_asynchronize(asynchronous_func_t func, uintptr_t self, int argc, uintptr_t* argv, uintptr_t intrval);
+
+#if defined __GNUC__ && __GNUC__ >= 4
+#pragma GCC visibility pop
+#endif
+
+#ifdef __MINGW_ATTRIB_PURE
+/* get rid of bugs in math.h of mingw */
+#define frexp(_X, _Y) __extension__ ({\
+    int intpart_frexp_bug = intpart_frexp_bug;\
+    double result_frexp_bug = frexp((_X), &intpart_frexp_bug);\
+    *(_Y) = intpart_frexp_bug;\
+    result_frexp_bug;\
+})
+#define modf(_X, _Y) __extension__ ({\
+    double intpart_modf_bug = intpart_modf_bug;\
+    double result_modf_bug = modf((_X), &intpart_modf_bug);\
+    *(_Y) = intpart_modf_bug;\
+    result_modf_bug;\
+})
+#endif
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+#endif /* RUBY_WIN32_H */