zscan 1.3 → 2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 656c885fe2dcee21e852866ae02bf9fa960a3c9a
-  data.tar.gz: 1f5642a27ad99afc41494e556095fc46c98af22b
+  metadata.gz: 0789acb7433df9d0317d6a251d806493aa759d4c
+  data.tar.gz: b6d7b9277d6663684c8e993315942c829fafd994
 SHA512:
-  metadata.gz: 844ac1574f62522bfa329e091f1a55558e17a2db7b0c39e5599fe4ad4038c66e563f1bd36d9ddf55132746c9265a2678f2abb2f0904c1fd5e3f4fec810d3197a
-  data.tar.gz: b156b693586831fcf094984583442ab146946fded1564b5d70f24d62db1cf72c3df5a91286a6e6a7822186f0655347e825a1d4f391c735157a2bf6121808d313
+  metadata.gz: 73b6e41a15da25c3ac4475ed3ec41fd383b096ff7536c51aae0647db663c270026d4bddd4b79a85132eec496f5379b9134fd89ca31a6827bf3c4a199dea4f5ac
+  data.tar.gz: 6558b04a492b1ae055b2bf5a3c64cd055330077e74fe3e75df1ef57816164404fbc2a98b9303c688714b6c5fade50b0b3a925bdd2fec4bfc939eddce49828713

data/benchmark/vs-unpack.rb

@@ -1,9 +1,10 @@
 require_relative "../lib/zscan"
 require "benchmark"
 
-spec = ZScan.binary_spec do
+spec = ZScan::BSpec.new do
   int8
-  double_le 2
+  double_le
+  double_le
   single_be
 end
 
@@ -15,7 +16,7 @@ puts 'reference nop group'
 puts Benchmark.measure{ 100000.times{ z.pos = 0 } }
 puts 'ZScan#unpack'
 puts Benchmark.measure{ 100000.times{ z.pos = 0; z.unpack 'cE2g' } }
-puts 'ZScan#scan_binary'
-puts Benchmark.measure{ 100000.times{ z.pos = 0; z.scan_binary spec } }
+puts 'ZScan#scan_bytes'
+puts Benchmark.measure{ 100000.times{ z.pos = 0; z.scan_bytes spec } }
 puts 'String#unpack'
 puts Benchmark.measure{ 100000.times{ z.pos = 0; str.unpack 'cE2g' } }

data/ext/bspec.c

@@ -8,6 +8,7 @@ typedef struct {
   long s_size;
   long a_size;
   long a_cap;
+  long curr;
   void** code;
 } BSpec;
 
@@ -23,7 +24,7 @@ static size_t bspec_memsize(const void* pp) {
 }
 
 static const rb_data_type_t bspec_type = {
-  "ZScan::BinarySpec",
+  "ZScan::BSpec",
   {NULL, bspec_free, bspec_memsize}
 };
 
@@ -32,6 +33,7 @@ static VALUE bspec_alloc(VALUE klass) {
   bs->s_size = 0;
   bs->a_cap = 4;
   bs->a_size = 0;
+  bs->curr = 0;
   bs->code = (void**)malloc(bs->a_cap * sizeof(void*));
   for (long i = 0; i < bs->a_cap; i++) {
     bs->code[i] = bspec_opcodes[0];
@@ -39,15 +41,8 @@ static VALUE bspec_alloc(VALUE klass) {
   return TypedData_Wrap_Struct(klass, &bspec_type, bs);
 }
 
-static VALUE bspec_append(VALUE self, VALUE v_i) {
-  BSpec* bs = rb_check_typeddata(self, &bspec_type);
-  long i = NUM2LONG(v_i);
-  if (i < 0 || i >= bspec_opcodes_size) {
-    rb_raise(rb_eArgError, "bad opcode index");
-  }
-
-  // ensure size
-  if (bs->a_size == bs->a_cap - 1) { // end with 0:RET, always terminate
+static void bspec_ensure_size(BSpec* bs) {
+  if (bs->curr == bs->a_cap - 1) { // end with 0:RET, always terminate
     bs->code = (void**)realloc(bs->code, bs->a_cap * 2 * sizeof(void*));
     long j = bs->a_cap;
     bs->a_cap *= 2;
@@ -55,12 +50,31 @@ static VALUE bspec_append(VALUE self, VALUE v_i) {
       bs->code[j] = bspec_opcodes[0];
     }
   }
+}
+
+static VALUE bspec_append(VALUE klass, VALUE self, VALUE v_i) {
+  BSpec* bs = rb_check_typeddata(self, &bspec_type);
+  long i = NUM2LONG(v_i);
+  if (i < 0 || i >= bspec_opcodes_size) {
+    rb_raise(rb_eArgError, "bad opcode index");
+  }
 
-  bs->code[bs->a_size++] = bspec_opcodes[i];
+  bspec_ensure_size(bs);
+  bs->a_size++;
+  bs->code[bs->curr++] = bspec_opcodes[i];
   bs->s_size += bspec_s_sizes[i];
   return self;
 }
 
+static VALUE bspec_append_expect(VALUE klass, VALUE self, VALUE expect) {
+  BSpec* bs = rb_check_typeddata(self, &bspec_type);
+  bspec_ensure_size(bs);
+  bs->code[bs->curr] = 0;
+  memcpy(bs->code + bs->curr, RSTRING_PTR(expect), RSTRING_LEN(expect));
+  bs->curr++;
+  return self;
+}
+
 static VALUE bspec_big_endian_p(VALUE self) {
 # ifdef DYNAMIC_ENDIAN
   /* for universal binary of NEXTSTEP and MacOS X */
@@ -133,12 +147,8 @@ static VALUE bspec_inspect_opcodes(VALUE bspec, VALUE self) {
   return a;
 }
 
-static VALUE zscan_scan_binary(VALUE self, VALUE spec) {
+static VALUE zscan_scan_bytes(VALUE self, VALUE spec) {
   ZScan* p = rb_check_typeddata(self, zscan_type);
-  if (!rb_enc_str_asciicompat_p(p->s)) {
-    rb_raise(rb_eRuntimeError, "encoding of source string should be ascii-compatible");
-    return Qnil;
-  }
   BSpec* bs = rb_check_typeddata(spec, &bspec_type);
   if (bs->a_size == 0) {
     return rb_ary_new();
@@ -148,21 +158,23 @@ static VALUE zscan_scan_binary(VALUE self, VALUE spec) {
     return Qnil;
   }
   volatile VALUE a = rb_ary_new2(bs->a_size - 1);
-  bspec_exec(bs->code, RSTRING_PTR(p->s) + p->bytepos, a);
-  p->bytepos += s_size;
-  p->pos += s_size;
+  a = bspec_exec(bs->code, RSTRING_PTR(p->s) + p->bytepos, a);
+  if (a != Qnil) {
+    zscan_bytepos_eq(self, LONG2NUM(p->bytepos + s_size));
+  }
   return a;
 }
 
 void Init_zscan_bspec(VALUE zscan, const rb_data_type_t* _zscan_type) {
   zscan_type = _zscan_type;
-  rb_define_method(zscan, "scan_binary", zscan_scan_binary, 1);
+  rb_define_method(zscan, "scan_bytes", zscan_scan_bytes, 1);
 
   bspec_opcodes = (void**)bspec_exec(NULL, NULL, Qnil);
-  VALUE bs = rb_define_class_under(zscan, "BinarySpec", rb_cObject);
+  VALUE bs = rb_define_class_under(zscan, "BSpec", rb_cObject);
+  rb_define_singleton_method(bs, "_append", bspec_append, 2);
+  rb_define_singleton_method(bs, "_append_expect", bspec_append_expect, 2);
   rb_define_singleton_method(bs, "big_endian?", bspec_big_endian_p, 0);
   rb_define_singleton_method(bs, "_opcodes_to_a", bspec_opcodes_to_a, 0);
   rb_define_singleton_method(bs, "_inspect_opcodes", bspec_inspect_opcodes, 1);
   rb_define_alloc_func(bs, bspec_alloc);
-  rb_define_method(bs, "append", bspec_append, 1);
 }

data/ext/bspec_exec.inc

@@ -1,14 +1,51 @@
-// GENERATED WITH: rake gen
-#line 2 "ext/bspec_exec.inc"
+// generated by rake gen
 __attribute__((__noinline__))
 static VALUE bspec_exec(void** ip, char* s, VALUE a) {
-  static void* opcodes[] = { &&BS_RET, &&BS_INT8, &&BS_INT16, &&BS_INT16_SWAP, &&BS_INT32, &&BS_INT32_SWAP, &&BS_INT64, &&BS_INT64_SWAP, &&BS_UINT8, &&BS_UINT16, &&BS_UINT16_SWAP, &&BS_UINT32, &&BS_UINT32_SWAP, &&BS_UINT64, &&BS_UINT64_SWAP, &&BS_SINGLE, &&BS_SINGLE_SWAP, &&BS_DOUBLE, &&BS_DOUBLE_SWAP };
+  static void* opcodes[] = { &&BS_RET, &&BS_EXPECT8, &&BS_EXPECT16, &&BS_EXPECT32, &&BS_EXPECT64, &&BS_INT8, &&BS_UINT8, &&BS_INT16, &&BS_INT16_SWAP, &&BS_INT32, &&BS_INT32_SWAP, &&BS_INT64, &&BS_INT64_SWAP, &&BS_UINT16, &&BS_UINT16_SWAP, &&BS_UINT32, &&BS_UINT32_SWAP, &&BS_UINT64, &&BS_UINT64_SWAP, &&BS_SINGLE, &&BS_SINGLE_SWAP, &&BS_DOUBLE, &&BS_DOUBLE_SWAP };
   if (ip == NULL) {
     return (VALUE)opcodes;
   }
   goto **(ip++);
 BS_RET:
   return a;
+
+BS_EXPECT8:
+  {
+    char* expect = (char*)(ip++);
+    if (strncmp(s, expect, 1)) {
+      return Qnil;
+    }
+    goto **(ip++);
+  }
+
+BS_EXPECT16:
+  {
+    char* expect = (char*)(ip++);
+    if (strncmp(s, expect, 2)) {
+      return Qnil;
+    }
+    goto **(ip++);
+  }
+
+BS_EXPECT32:
+  {
+    char* expect = (char*)(ip++);
+    if (strncmp(s, expect, 4)) {
+      return Qnil;
+    }
+    goto **(ip++);
+  }
+
+BS_EXPECT64:
+  {
+    char* expect = (char*)(ip++);
+    if (strncmp(s, expect, 8)) {
+      return Qnil;
+    }
+    goto **(ip++);
+  }
+
+
 BS_INT8:
   {
     uint8_t r = ((uint8_t*)s)[0];
@@ -17,6 +54,14 @@ BS_INT8:
     goto **(ip++);
   }
 
+BS_UINT8:
+  {
+    uint8_t r = ((uint8_t*)s)[0];
+    rb_ary_push(a, INT2FIX(CAST(r, uint8_t)));
+    s += 1;
+    goto **(ip++);
+  }
+
 BS_INT16:
   {
     uint16_t r = ((uint16_t*)s)[0];
@@ -65,14 +110,6 @@ BS_INT64_SWAP:
     goto **(ip++);
   }
 
-BS_UINT8:
-  {
-    uint8_t r = ((uint8_t*)s)[0];
-    rb_ary_push(a, INT2FIX(CAST(r, uint8_t)));
-    s += 1;
-    goto **(ip++);
-  }
-
 BS_UINT16:
   {
     uint16_t r = ((uint16_t*)s)[0];

data/ext/bspec_init.inc

@@ -1,3 +1,3 @@
-// GENERATED WITH: rake gen
-static const long bspec_s_sizes[] = {0, 1, 2, 2, 4, 4, 8, 8, 1, 2, 2, 4, 4, 8, 8, 4, 4, 8, 8};
-static const long bspec_opcodes_size = 19;
+// generated by rake gen
+static const long bspec_s_sizes[] = {0, 0, 0, 0, 0, 1, 1, 2, 2, 4, 4, 8, 8, 2, 2, 4, 4, 8, 8, 4, 4, 8, 8};
+static const long bspec_opcodes_size = 23;

data/ext/extconf.rb

@@ -2,7 +2,18 @@ require "mkmf"
 
 create_makefile 'zscan'
 
-headers = Dir.glob('*.h').join ' '
-File.open 'Makefile', 'a' do |f|
+makefile = File.read 'Makefile'
+lines = makefile.lines.map do |line|
+  if line.start_with?('ORIG_SRCS =')
+    line.sub /$/, ' pack/pack.c'
+  elsif line.start_with?('OBJS =')
+    line.sub /$/, ' pack/pack.o'
+  else
+    line
+  end
+end
+headers = Dir.glob('**/*.h').join ' '
+File.open 'Makefile', 'w' do |f|
+  f.puts lines
   f.puts "\n$(OBJS): #{headers}"
 end

data/ext/pack/COPYING

@@ -0,0 +1,56 @@
+Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.jp>.
+You can redistribute it and/or modify it under either the terms of the
+2-clause BSDL (see the file BSDL), or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or binary form,
+     provided that you do at least ONE of the following:
+
+       a) distribute the binaries and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard binaries non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under these terms.
+
+     For the list of those files and their copying conditions, see the
+     file LEGAL.
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.

data/ext/pack/COPYING.ja

@@ -0,0 +1,51 @@
+本プログラムはフリーソフトウェアです．2-clause BSDL
+または以下に示す条件で本プログラムを再配布できます
+2-clause BSDLについてはBSDLファイルを参照して下さい．
+
+  1. 複製は制限なく自由です．
+
+  2. 以下の条件のいずれかを満たす時に本プログラムのソースを
+     自由に変更できます．
+
+     (a) ネットニューズにポストしたり，作者に変更を送付する
+         などの方法で，変更を公開する．
+
+     (b) 変更した本プログラムを自分の所属する組織内部だけで
+         使う．
+
+     (c) 変更点を明示したうえ，ソフトウェアの名前を変更する．
+         そのソフトウェアを配布する時には変更前の本プログラ
+         ムも同時に配布する．または変更前の本プログラムのソー
+         スの入手法を明示する．
+
+     (d) その他の変更条件を作者と合意する．
+
+  3. 以下の条件のいずれかを満たす時に本プログラムをコンパイ
+     ルしたオブジェクトコードや実行形式でも配布できます．
+
+     (a) バイナリを受け取った人がソースを入手できるように，
+         ソースの入手法を明示する．
+
+     (b) 機械可読なソースコードを添付する．
+
+     (c) 変更を行ったバイナリは名前を変更したうえ，オリジナ
+         ルのソースコードの入手法を明示する．
+
+     (d) その他の配布条件を作者と合意する．
+
+  4. 他のプログラムへの引用はいかなる目的であれ自由です．た
+     だし，本プログラムに含まれる他の作者によるコードは，そ
+     れぞれの作者の意向による制限が加えられる場合があります．
+
+     それらファイルの一覧とそれぞれの配布条件などに付いては
+     LEGALファイルを参照してください．
+
+  5. 本プログラムへの入力となるスクリプトおよび，本プログラ
+     ムからの出力の権利は本プログラムの作者ではなく，それぞ
+     れの入出力を生成した人に属します．また，本プログラムに
+     組み込まれるための拡張ライブラリについても同様です．
+
+  6. 本プログラムは無保証です．作者は本プログラムをサポート
+     する意志はありますが，プログラム自身のバグあるいは本プ
+     ログラムの実行などから発生するいかなる損害に対しても責
+     任を持ちません．

data/ext/pack/internal.h

@@ -0,0 +1,419 @@
+/**********************************************************************
+
+  internal.h -
+
+  $Author$
+  created at: Tue May 17 11:42:20 JST 2011
+
+  Copyright (C) 2011 Yukihiro Matsumoto
+
+**********************************************************************/
+
+#ifndef RUBY_INTERNAL_H
+#define RUBY_INTERNAL_H 1
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+#define GCC_VERSION_SINCE(major, minor, patchlevel) \
+  (defined(__GNUC__) && !defined(__INTEL_COMPILER) && \
+   ((__GNUC__ > (major)) ||  \
+    (__GNUC__ == (major) && __GNUC_MINOR__ > (minor)) || \
+    (__GNUC__ == (major) && __GNUC_MINOR__ == (minor) && __GNUC_PATCHLEVEL__ >= (patchlevel))))
+
+#if SIGNEDNESS_OF_TIME_T < 0	/* signed */
+# define TIMET_MAX (time_t)((~(unsigned_time_t)0) >> 1)
+# define TIMET_MIN (time_t)(((unsigned_time_t)1) << (sizeof(time_t) * CHAR_BIT - 1))
+#elif SIGNEDNESS_OF_TIME_T > 0	/* unsigned */
+# define TIMET_MAX (time_t)(~(unsigned_time_t)0)
+# define TIMET_MIN (time_t)0
+#endif
+#define TIMET_MAX_PLUS_ONE (2*(double)(TIMET_MAX/2+1))
+
+#define MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, min, max) ( \
+    (a) == 0 ? 0 : \
+    (a) == -1 ? (b) < -(max) : \
+    (a) > 0 ? \
+      ((b) > 0 ? (max) / (a) < (b) : (min) / (a) > (b)) : \
+      ((b) > 0 ? (min) / (a) < (b) : (max) / (a) > (b)))
+#define MUL_OVERFLOW_FIXNUM_P(a, b) MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, FIXNUM_MIN, FIXNUM_MAX)
+#define MUL_OVERFLOW_LONG_P(a, b) MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, LONG_MIN, LONG_MAX)
+#define MUL_OVERFLOW_INT_P(a, b) MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, INT_MIN, INT_MAX)
+
+struct rb_deprecated_classext_struct {
+    char conflict[sizeof(VALUE) * 3];
+};
+
+struct rb_classext_struct {
+    VALUE super;
+    struct st_table *iv_tbl;
+    struct st_table *const_tbl;
+    VALUE origin;
+    VALUE refined_class;
+    rb_alloc_func_t allocator;
+};
+
+#undef RCLASS_SUPER
+#define RCLASS_EXT(c) (RCLASS(c)->ptr)
+#define RCLASS_SUPER(c) (RCLASS_EXT(c)->super)
+#define RCLASS_IV_TBL(c) (RCLASS_EXT(c)->iv_tbl)
+#define RCLASS_CONST_TBL(c) (RCLASS_EXT(c)->const_tbl)
+#define RCLASS_M_TBL(c) (RCLASS(c)->m_tbl)
+#define RCLASS_IV_INDEX_TBL(c) (RCLASS(c)->iv_index_tbl)
+#define RCLASS_ORIGIN(c) (RCLASS_EXT(c)->origin)
+#define RCLASS_REFINED_CLASS(c) (RCLASS_EXT(c)->refined_class)
+
+struct vtm; /* defined by timev.h */
+
+/* array.c */
+VALUE rb_ary_last(int, VALUE *, VALUE);
+void rb_ary_set_len(VALUE, long);
+VALUE rb_ary_cat(VALUE, const VALUE *, long);
+void rb_ary_delete_same(VALUE, VALUE);
+
+/* bignum.c */
+VALUE rb_big_fdiv(VALUE x, VALUE y);
+VALUE rb_big_uminus(VALUE x);
+VALUE rb_integer_float_cmp(VALUE x, VALUE y);
+VALUE rb_integer_float_eq(VALUE x, VALUE y);
+
+/* class.c */
+VALUE rb_obj_methods(int argc, VALUE *argv, VALUE obj);
+VALUE rb_obj_protected_methods(int argc, VALUE *argv, VALUE obj);
+VALUE rb_obj_private_methods(int argc, VALUE *argv, VALUE obj);
+VALUE rb_obj_public_methods(int argc, VALUE *argv, VALUE obj);
+int rb_obj_basic_to_s_p(VALUE);
+VALUE rb_special_singleton_class(VALUE);
+VALUE rb_singleton_class_clone_and_attach(VALUE obj, VALUE attach);
+void Init_class_hierarchy(void);
+
+/* compar.c */
+VALUE rb_invcmp(VALUE, VALUE);
+
+/* compile.c */
+int rb_dvar_defined(ID);
+int rb_local_defined(ID);
+int rb_parse_in_eval(void);
+int rb_parse_in_main(void);
+const char * rb_insns_name(int i);
+VALUE rb_insns_name_array(void);
+
+/* cont.c */
+VALUE rb_obj_is_fiber(VALUE);
+void rb_fiber_reset_root_local_storage(VALUE);
+
+/* debug.c */
+PRINTF_ARGS(void ruby_debug_printf(const char*, ...), 1, 2);
+
+/* dmyext.c */
+void Init_ext(void);
+
+/* encoding.c */
+ID rb_id_encoding(void);
+
+/* encoding.c */
+void rb_gc_mark_encodings(void);
+
+/* error.c */
+NORETURN(PRINTF_ARGS(void rb_compile_bug(const char*, int, const char*, ...), 3, 4));
+VALUE rb_check_backtrace(VALUE);
+NORETURN(void rb_async_bug_errno(const char *,int));
+const char *rb_builtin_type_name(int t);
+const char *rb_builtin_class_name(VALUE x);
+
+/* eval.c */
+VALUE rb_refinement_module_get_refined_class(VALUE module);
+
+/* eval_error.c */
+void ruby_error_print(void);
+VALUE rb_get_backtrace(VALUE info);
+
+/* eval_jump.c */
+void rb_call_end_proc(VALUE data);
+void rb_mark_end_proc(void);
+
+/* file.c */
+VALUE rb_home_dir(const char *user, VALUE result);
+VALUE rb_realpath_internal(VALUE basedir, VALUE path, int strict);
+void rb_file_const(const char*, VALUE);
+int rb_file_load_ok(const char *);
+VALUE rb_file_expand_path_fast(VALUE, VALUE);
+VALUE rb_file_expand_path_internal(VALUE, VALUE, int, int, VALUE);
+VALUE rb_get_path_check_to_string(VALUE, int);
+VALUE rb_get_path_check_convert(VALUE, VALUE, int);
+void Init_File(void);
+
+#ifdef RUBY_FUNCTION_NAME_STRING
+# if defined __GNUC__ && __GNUC__ >= 4
+#   pragma GCC visibility push(default)
+# endif
+NORETURN(void rb_sys_fail_path_in(const char *func_name, VALUE path));
+# if defined __GNUC__ && __GNUC__ >= 4
+#   pragma GCC visibility pop
+# endif
+# define rb_sys_fail_path(path) rb_sys_fail_path_in(RUBY_FUNCTION_NAME_STRING, path)
+#else
+# define rb_sys_fail_path(path) rb_sys_fail_str(path)
+#endif
+
+#ifdef _WIN32
+/* file.c, win32/file.c */
+void rb_w32_init_file(void);
+#endif
+
+/* gc.c */
+void Init_heap(void);
+void *ruby_mimmalloc(size_t size);
+
+/* inits.c */
+void rb_call_inits(void);
+
+/* io.c */
+const char *ruby_get_inplace_mode(void);
+void ruby_set_inplace_mode(const char *);
+ssize_t rb_io_bufread(VALUE io, void *buf, size_t size);
+void rb_stdio_set_default_encoding(void);
+void rb_write_error_str(VALUE mesg);
+
+/* iseq.c */
+VALUE rb_iseq_clone(VALUE iseqval, VALUE newcbase);
+
+/* load.c */
+VALUE rb_get_load_path(void);
+VALUE rb_get_expanded_load_path(void);
+NORETURN(void rb_load_fail(VALUE, const char*));
+
+/* math.c */
+VALUE rb_math_atan2(VALUE, VALUE);
+VALUE rb_math_cos(VALUE);
+VALUE rb_math_cosh(VALUE);
+VALUE rb_math_exp(VALUE);
+VALUE rb_math_hypot(VALUE, VALUE);
+VALUE rb_math_log(int argc, VALUE *argv);
+VALUE rb_math_sin(VALUE);
+VALUE rb_math_sinh(VALUE);
+VALUE rb_math_sqrt(VALUE);
+
+/* newline.c */
+void Init_newline(void);
+
+/* numeric.c */
+int rb_num_to_uint(VALUE val, unsigned int *ret);
+VALUE ruby_num_interval_step_size(VALUE from, VALUE to, VALUE step, int excl);
+int ruby_float_step(VALUE from, VALUE to, VALUE step, int excl);
+double ruby_float_mod(double x, double y);
+int rb_num_negative_p(VALUE);
+VALUE rb_int_succ(VALUE num);
+VALUE rb_int_pred(VALUE num);
+
+/* object.c */
+VALUE rb_obj_equal(VALUE obj1, VALUE obj2);
+VALUE rb_obj_hide(VALUE obj);
+
+/* parse.y */
+VALUE rb_parser_get_yydebug(VALUE);
+VALUE rb_parser_set_yydebug(VALUE, VALUE);
+int rb_is_const_name(VALUE name);
+int rb_is_class_name(VALUE name);
+int rb_is_global_name(VALUE name);
+int rb_is_instance_name(VALUE name);
+int rb_is_attrset_name(VALUE name);
+int rb_is_local_name(VALUE name);
+int rb_is_method_name(VALUE name);
+int rb_is_junk_name(VALUE name);
+void rb_gc_mark_parser(void);
+void rb_gc_mark_symbols(void);
+
+/* proc.c */
+VALUE rb_proc_location(VALUE self);
+st_index_t rb_hash_proc(st_index_t hash, VALUE proc);
+
+/* process.c */
+#define RB_MAX_GROUPS (65536)
+
+struct rb_execarg {
+    int use_shell;
+    union {
+        struct {
+            VALUE shell_script;
+        } sh;
+        struct {
+            VALUE command_name;
+            VALUE command_abspath; /* full path string or nil */
+            VALUE argv_str;
+            VALUE argv_buf;
+        } cmd;
+    } invoke;
+    VALUE redirect_fds;
+    VALUE envp_str;
+    VALUE envp_buf;
+    VALUE dup2_tmpbuf;
+    unsigned pgroup_given : 1;
+    unsigned umask_given : 1;
+    unsigned unsetenv_others_given : 1;
+    unsigned unsetenv_others_do : 1;
+    unsigned close_others_given : 1;
+    unsigned close_others_do : 1;
+    unsigned chdir_given : 1;
+    unsigned new_pgroup_given : 1;
+    unsigned new_pgroup_flag : 1;
+    unsigned uid_given : 1;
+    unsigned gid_given : 1;
+    rb_pid_t pgroup_pgid; /* asis(-1), new pgroup(0), specified pgroup (0<V). */
+    VALUE rlimit_limits; /* Qfalse or [[rtype, softlim, hardlim], ...] */
+    mode_t umask_mask;
+    rb_uid_t uid;
+    rb_gid_t gid;
+    VALUE fd_dup2;
+    VALUE fd_close;
+    VALUE fd_open;
+    VALUE fd_dup2_child;
+    int close_others_maxhint;
+    VALUE env_modification; /* Qfalse or [[k1,v1], ...] */
+    VALUE chdir_dir;
+};
+
+/* argv_str contains extra two elements.
+ * The beginning one is for /bin/sh used by exec_with_sh.
+ * The last one for terminating NULL used by execve.
+ * See rb_exec_fillarg() in process.c. */
+#define ARGVSTR2ARGC(argv_str) (RSTRING_LEN(argv_str) / sizeof(char *) - 2)
+#define ARGVSTR2ARGV(argv_str) ((char **)RSTRING_PTR(argv_str) + 1)
+
+rb_pid_t rb_fork_ruby(int *status);
+void rb_last_status_clear(void);
+
+/* rational.c */
+VALUE rb_lcm(VALUE x, VALUE y);
+VALUE rb_rational_reciprocal(VALUE x);
+
+/* re.c */
+VALUE rb_reg_compile(VALUE str, int options, const char *sourcefile, int sourceline);
+VALUE rb_reg_check_preprocess(VALUE);
+
+/* signal.c */
+int rb_get_next_signal(void);
+int rb_sigaltstack_size(void);
+
+/* strftime.c */
+#ifdef RUBY_ENCODING_H
+size_t rb_strftime_timespec(char *s, size_t maxsize, const char *format, rb_encoding *enc,
+	const struct vtm *vtm, struct timespec *ts, int gmt);
+size_t rb_strftime(char *s, size_t maxsize, const char *format, rb_encoding *enc,
+            const struct vtm *vtm, VALUE timev, int gmt);
+#endif
+
+/* string.c */
+int rb_str_buf_cat_escaped_char(VALUE result, unsigned int c, int unicode_p);
+int rb_str_symname_p(VALUE);
+VALUE rb_str_quote_unprintable(VALUE);
+VALUE rb_id_quote_unprintable(ID);
+#define QUOTE(str) rb_str_quote_unprintable(str)
+#define QUOTE_ID(id) rb_id_quote_unprintable(id)
+
+/* struct.c */
+VALUE rb_struct_init_copy(VALUE copy, VALUE s);
+
+/* time.c */
+struct timeval rb_time_timeval(VALUE);
+
+/* thread.c */
+VALUE rb_obj_is_mutex(VALUE obj);
+VALUE rb_suppress_tracing(VALUE (*func)(VALUE), VALUE arg);
+void rb_thread_execute_interrupts(VALUE th);
+void rb_clear_trace_func(void);
+VALUE rb_get_coverages(void);
+VALUE rb_thread_shield_new(void);
+VALUE rb_thread_shield_wait(VALUE self);
+VALUE rb_thread_shield_release(VALUE self);
+VALUE rb_thread_shield_destroy(VALUE self);
+void rb_mutex_allow_trap(VALUE self, int val);
+VALUE rb_uninterruptible(VALUE (*b_proc)(ANYARGS), VALUE data);
+VALUE rb_mutex_owned_p(VALUE self);
+void ruby_kill(rb_pid_t pid, int sig);
+
+/* thread_pthread.c, thread_win32.c */
+void Init_native_thread(void);
+
+/* vm.c */
+VALUE rb_obj_is_thread(VALUE obj);
+void rb_vm_mark(void *ptr);
+void Init_BareVM(void);
+VALUE rb_vm_top_self(void);
+void rb_thread_recycle_stack_release(VALUE *);
+void rb_vm_change_state(void);
+void rb_vm_inc_const_missing_count(void);
+void rb_thread_mark(void *th);
+const void **rb_vm_get_insns_address_table(void);
+VALUE rb_sourcefilename(void);
+
+/* vm_dump.c */
+void rb_vm_bugreport(void);
+void rb_print_backtrace(void);
+
+/* vm_eval.c */
+void Init_vm_eval(void);
+VALUE rb_current_realfilepath(void);
+VALUE rb_check_block_call(VALUE, ID, int, VALUE *, VALUE (*)(ANYARGS), VALUE);
+typedef void rb_check_funcall_hook(int, VALUE, ID, int, VALUE *, VALUE);
+VALUE rb_check_funcall_with_hook(VALUE recv, ID mid, int argc, VALUE *argv,
+				 rb_check_funcall_hook *hook, VALUE arg);
+
+/* vm_method.c */
+void Init_eval_method(void);
+int rb_method_defined_by(VALUE obj, ID mid, VALUE (*cfunc)(ANYARGS));
+
+/* miniprelude.c, prelude.c */
+void Init_prelude(void);
+
+/* vm_backtrace.c */
+void Init_vm_backtrace(void);
+VALUE rb_vm_thread_backtrace(int argc, VALUE *argv, VALUE thval);
+VALUE rb_vm_thread_backtrace_locations(int argc, VALUE *argv, VALUE thval);
+
+VALUE rb_make_backtrace(void);
+void rb_backtrace_print_as_bugreport(void);
+int rb_backtrace_p(VALUE obj);
+VALUE rb_backtrace_to_str_ary(VALUE obj);
+VALUE rb_vm_backtrace_object();
+
+RUBY_SYMBOL_EXPORT_BEGIN
+const char *rb_objspace_data_type_name(VALUE obj);
+
+/* Temporary.  This API will be removed (renamed). */
+VALUE rb_thread_io_blocking_region(rb_blocking_function_t *func, void *data1, int fd);
+
+/* io.c */
+void rb_maygvl_fd_fix_cloexec(int fd);
+
+/* process.c */
+int rb_exec_async_signal_safe(const struct rb_execarg *e, char *errmsg, size_t errmsg_buflen);
+rb_pid_t rb_fork_async_signal_safe(int *status, int (*chfunc)(void*, char *, size_t), void *charg, VALUE fds, char *errmsg, size_t errmsg_buflen);
+VALUE rb_execarg_new(int argc, VALUE *argv, int accept_shell);
+struct rb_execarg *rb_execarg_get(VALUE execarg_obj); /* dangerous.  needs GC guard. */
+VALUE rb_execarg_init(int argc, VALUE *argv, int accept_shell, VALUE execarg_obj);
+int rb_execarg_addopt(VALUE execarg_obj, VALUE key, VALUE val);
+void rb_execarg_fixup(VALUE execarg_obj);
+int rb_execarg_run_options(const struct rb_execarg *e, struct rb_execarg *s, char* errmsg, size_t errmsg_buflen);
+VALUE rb_execarg_extract_options(VALUE execarg_obj, VALUE opthash);
+void rb_execarg_setenv(VALUE execarg_obj, VALUE env);
+
+/* variable.c */
+void rb_gc_mark_global_tbl(void);
+void rb_mark_generic_ivar(VALUE);
+void rb_mark_generic_ivar_tbl(void);
+
+RUBY_SYMBOL_EXPORT_END
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+}  /* extern "C" { */
+#endif
+
+#endif /* RUBY_INTERNAL_H */