did_you_mean 0.5.0 → 0.9.0

data/ext/did_you_mean/ruby_headers/220/ccan/str/str.h

@@ -0,0 +1,16 @@
+/* CC0 (Public domain) - see ccan/licenses/CC0 file for details */
+#ifndef CCAN_STR_H
+#define CCAN_STR_H
+/**
+ * stringify - Turn expression into a string literal
+ * @expr: any C expression
+ *
+ * Example:
+ *	#define PRINT_COND_IF_FALSE(cond) \
+ *		((cond) || printf("%s is false!", stringify(cond)))
+ */
+#define stringify(expr)		stringify_1(expr)
+/* Double-indirection required to stringify expansions */
+#define stringify_1(expr)	#expr
+
+#endif /* CCAN_STR_H */

data/ext/did_you_mean/ruby_headers/220/constant.h

@@ -13,9 +13,15 @@
 
 typedef enum {
     CONST_PUBLIC    = 0x00,
-    CONST_PRIVATE   = 0x01
+    CONST_PRIVATE,
+    CONST_VISIBILITY_MAX
 } rb_const_flag_t;
 
+#define RB_CONST_PRIVATE_P(ce) \
+    ((ce)->flag == CONST_PRIVATE)
+#define RB_CONST_PUBLIC_P(ce) \
+    ((ce)->flag == CONST_PUBLIC)
+
 typedef struct rb_const_entry_struct {
     rb_const_flag_t flag;
     int line;
@@ -23,8 +29,8 @@ typedef struct rb_const_entry_struct {
     const VALUE file;             /* should be mark */
 } rb_const_entry_t;
 
-VALUE rb_mod_private_constant(int argc, VALUE *argv, VALUE obj);
-VALUE rb_mod_public_constant(int argc, VALUE *argv, VALUE obj);
+VALUE rb_mod_private_constant(int argc, const VALUE *argv, VALUE obj);
+VALUE rb_mod_public_constant(int argc, const VALUE *argv, VALUE obj);
 void rb_free_const_table(st_table *tbl);
 VALUE rb_public_const_get(VALUE klass, ID id);
 VALUE rb_public_const_get_at(VALUE klass, ID id);
@@ -32,5 +38,6 @@ VALUE rb_public_const_get_from(VALUE klass, ID id);
 int rb_public_const_defined(VALUE klass, ID id);
 int rb_public_const_defined_at(VALUE klass, ID id);
 int rb_public_const_defined_from(VALUE klass, ID id);
+rb_const_entry_t *rb_const_lookup(VALUE klass, ID id);
 
 #endif /* CONSTANT_H */

data/ext/did_you_mean/ruby_headers/220/eval_intern.h

@@ -95,6 +95,15 @@ extern int select_large_fdset(int, fd_set *, fd_set *, fd_set *, struct timeval
 	      EXCEPTION_CONTINUE_SEARCH) { \
 	/* never reaches here */ \
     }
+#elif defined(__MINGW32__)
+LONG WINAPI rb_w32_stack_overflow_handler(struct _EXCEPTION_POINTERS *);
+#define SAVE_ROOT_JMPBUF_BEFORE_STMT \
+    do { \
+	PVOID _handler = AddVectoredExceptionHandler(1, rb_w32_stack_overflow_handler);
+
+#define SAVE_ROOT_JMPBUF_AFTER_STMT \
+	RemoveVectoredExceptionHandler(_handler); \
+    } while (0);
 #else
 #define SAVE_ROOT_JMPBUF_BEFORE_STMT
 #define SAVE_ROOT_JMPBUF_AFTER_STMT
@@ -128,6 +137,14 @@ extern int select_large_fdset(int, fd_set *, fd_set *, fd_set *, struct timeval
 #define PUSH_TAG() TH_PUSH_TAG(GET_THREAD())
 #define POP_TAG()      TH_POP_TAG()
 
+#if defined __GNUC__ && __GNUC__ == 4 && (__GNUC_MINOR__ >= 6 && __GNUC_MINOR__ <= 8)
+# define VAR_FROM_MEMORY(var) __extension__(*(__typeof__(var) volatile *)&(var))
+# define VAR_INITIALIZED(var) ((var) = VAR_FROM_MEMORY(var))
+#else
+# define VAR_FROM_MEMORY(var) (var)
+# define VAR_INITIALIZED(var) ((void)&(var))
+#endif
+
 /* clear th->state, and return the value */
 static inline int
 rb_threadptr_tag_state(rb_thread_t *th)
@@ -141,7 +158,8 @@ NORETURN(static inline void rb_threadptr_tag_jump(rb_thread_t *, int));
 static inline void
 rb_threadptr_tag_jump(rb_thread_t *th, int st)
 {
-    ruby_longjmp(th->tag->buf, (th->state = st));
+    th->state = st;
+    ruby_longjmp(th->tag->buf, 1);
 }
 
 /*
@@ -149,7 +167,7 @@ rb_threadptr_tag_jump(rb_thread_t *th, int st)
   [ISO/IEC 9899:1999] 7.13.1.1
 */
 #define TH_EXEC_TAG() \
-    (ruby_setjmp(_tag.buf) ? rb_threadptr_tag_state(_th) : (TH_REPUSH_TAG(), 0))
+    (ruby_setjmp(_tag.buf) ? rb_threadptr_tag_state(VAR_FROM_MEMORY(_th)) : (TH_REPUSH_TAG(), 0))
 
 #define EXEC_TAG() \
   TH_EXEC_TAG()
@@ -211,8 +229,8 @@ int rb_threadptr_reset_raised(rb_thread_t *th);
 #define rb_thread_raised_p(th, f)     (((th)->raised_flag & (f)) != 0)
 #define rb_thread_raised_clear(th)    ((th)->raised_flag = 0)
 
-VALUE rb_f_eval(int argc, VALUE *argv, VALUE self);
-VALUE rb_make_exception(int argc, VALUE *argv);
+VALUE rb_f_eval(int argc, const VALUE *argv, VALUE self);
+VALUE rb_make_exception(int argc, const VALUE *argv);
 
 NORETURN(void rb_method_name_error(VALUE, VALUE));
 
@@ -220,9 +238,10 @@ NORETURN(void rb_fiber_start(void));
 
 NORETURN(void rb_print_undef(VALUE, ID, int));
 NORETURN(void rb_print_undef_str(VALUE, VALUE));
+NORETURN(void rb_print_inaccessible(VALUE, ID, int));
 NORETURN(void rb_vm_localjump_error(const char *,VALUE, int));
 NORETURN(void rb_vm_jump_tag_but_local_jump(int));
-NORETURN(void rb_raise_method_missing(rb_thread_t *th, int argc, VALUE *argv,
+NORETURN(void rb_raise_method_missing(rb_thread_t *th, int argc, const VALUE *argv,
 				      VALUE obj, int call_status));
 
 VALUE rb_vm_make_jump_tag_but_local_jump(int state, VALUE val);

data/ext/did_you_mean/ruby_headers/220/gc.h

@@ -92,11 +92,16 @@ void rb_objspace_reachable_objects_from_root(void (func)(const char *category, V
 int rb_objspace_markable_object_p(VALUE obj);
 int rb_objspace_internal_object_p(VALUE obj);
 int rb_objspace_marked_object_p(VALUE obj);
+int rb_objspace_garbage_object_p(VALUE obj);
 
 void rb_objspace_each_objects(
     int (*callback)(void *start, void *end, size_t stride, void *data),
     void *data);
 
+void rb_objspace_each_objects_without_setup(
+    int (*callback)(void *, void *, size_t, void *),
+    void *data);
+
 RUBY_SYMBOL_EXPORT_END
 
 #endif /* RUBY_GC_H */

data/ext/did_you_mean/ruby_headers/220/id.h

@@ -14,18 +14,20 @@
 #define RUBY_ID_H
 
 enum ruby_id_types {
+    RUBY_ID_STATIC_SYM  = 0x01,
     RUBY_ID_LOCAL       = 0x00,
-    RUBY_ID_INSTANCE    = 0x01,
-    RUBY_ID_GLOBAL      = 0x03,
-    RUBY_ID_ATTRSET     = 0x04,
-    RUBY_ID_CONST       = 0x05,
-    RUBY_ID_CLASS       = 0x06,
-    RUBY_ID_JUNK        = 0x07,
+    RUBY_ID_INSTANCE    = (0x01<<1),
+    RUBY_ID_GLOBAL      = (0x03<<1),
+    RUBY_ID_ATTRSET     = (0x04<<1),
+    RUBY_ID_CONST       = (0x05<<1),
+    RUBY_ID_CLASS       = (0x06<<1),
+    RUBY_ID_JUNK        = (0x07<<1),
     RUBY_ID_INTERNAL    = RUBY_ID_JUNK,
-    RUBY_ID_SCOPE_SHIFT = 3,
-    RUBY_ID_SCOPE_MASK  = ~(~0U<<RUBY_ID_SCOPE_SHIFT)
+    RUBY_ID_SCOPE_SHIFT = 4,
+    RUBY_ID_SCOPE_MASK  = (~(~0U<<(RUBY_ID_SCOPE_SHIFT-1))<<1)
 };
 
+#define ID_STATIC_SYM  RUBY_ID_STATIC_SYM
 #define ID_SCOPE_SHIFT RUBY_ID_SCOPE_SHIFT
 #define ID_SCOPE_MASK  RUBY_ID_SCOPE_MASK
 #define ID_LOCAL       RUBY_ID_LOCAL
@@ -136,7 +138,7 @@ enum ruby_method_ids {
     tInitialize_clone,
     tInitialize_dup,
     tUScore,
-#define TOKEN2LOCALID(n) id##n = ((t##n<<ID_SCOPE_SHIFT)|ID_LOCAL)
+#define TOKEN2LOCALID(n) id##n = ((t##n<<ID_SCOPE_SHIFT)|ID_LOCAL|ID_STATIC_SYM)
     TOKEN2LOCALID(Freeze),
     TOKEN2LOCALID(Inspect),
     TOKEN2LOCALID(Intern),

data/ext/did_you_mean/ruby_headers/220/internal.h

@@ -40,6 +40,14 @@ extern "C" {
 #define UNINITIALIZED_VAR(x) x
 #endif
 
+#if __has_attribute(warn_unused_result)
+#define WARN_UNUSED_RESULT(x) x __attribute__((warn_unused_result))
+#elif defined(__GNUC__) && (__GNUC__ * 1000 + __GNUC_MINOR__) >= 3004
+#define WARN_UNUSED_RESULT(x) x __attribute__((warn_unused_result))
+#else
+#define WARN_UNUSED_RESULT(x) x
+#endif
+
 #ifdef HAVE_VALGRIND_MEMCHECK_H
 # include <valgrind/memcheck.h>
 # ifndef VALGRIND_MAKE_MEM_DEFINED
@@ -55,7 +63,8 @@ extern "C" {
 
 #define numberof(array) ((int)(sizeof(array) / sizeof((array)[0])))
 
-#define STATIC_ASSERT(name, expr) typedef int static_assert_##name##_check[1 - 2*!(expr)]
+#define STATIC_ASSERT_TYPE(name) static_assert_##name##_check
+#define STATIC_ASSERT(name, expr) typedef int STATIC_ASSERT_TYPE(name)[1 - 2*!(expr)]
 
 #define GCC_VERSION_SINCE(major, minor, patchlevel) \
   (defined(__GNUC__) && !defined(__INTEL_COMPILER) && \
@@ -308,28 +317,28 @@ struct method_table_wrapper {
 #ifndef BDIGIT
 # if SIZEOF_INT*2 <= SIZEOF_LONG_LONG
 #  define BDIGIT unsigned int
-#  define SIZEOF_BDIGITS SIZEOF_INT
+#  define SIZEOF_BDIGIT 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 SIZEOF_BDIGIT 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 SIZEOF_BDIGIT 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 SIZEOF_BDIGIT (SIZEOF_LONG/2)
 #  define SIZEOF_ACTUAL_BDIGIT SIZEOF_LONG
 #  define BDIGIT_DBL unsigned long
 #  define BDIGIT_DBL_SIGNED long
@@ -338,7 +347,7 @@ struct method_table_wrapper {
 # endif
 #endif
 #ifndef SIZEOF_ACTUAL_BDIGIT
-# define SIZEOF_ACTUAL_BDIGIT SIZEOF_BDIGITS
+# define SIZEOF_ACTUAL_BDIGIT SIZEOF_BDIGIT
 #endif
 
 #ifdef PRI_BDIGIT_PREFIX
@@ -372,7 +381,7 @@ struct RBignum {
     struct RBasic basic;
     union {
         struct {
-            long len;
+            size_t len;
             BDIGIT *digits;
         } heap;
         BDIGIT ary[BIGNUM_EMBED_LEN_MAX];
@@ -404,6 +413,54 @@ struct RBignum {
 
 #define RBIGNUM(obj) (R_CAST(RBignum)(obj))
 
+struct RRational {
+    struct RBasic basic;
+    const VALUE num;
+    const VALUE den;
+};
+
+#define RRATIONAL(obj) (R_CAST(RRational)(obj))
+
+struct RFloat {
+    struct RBasic basic;
+    double float_value;
+};
+
+#define RFLOAT(obj)  (R_CAST(RFloat)(obj))
+
+struct RComplex {
+    struct RBasic basic;
+    const VALUE real;
+    const VALUE imag;
+};
+
+#define RCOMPLEX(obj) (R_CAST(RComplex)(obj))
+
+#ifdef RCOMPLEX_SET_REAL        /* shortcut macro for internal only */
+#undef RCOMPLEX_SET_REAL
+#undef RCOMPLEX_SET_REAL
+#define RCOMPLEX_SET_REAL(cmp, r) RB_OBJ_WRITE((cmp), &((struct RComplex *)(cmp))->real,(r))
+#define RCOMPLEX_SET_IMAG(cmp, i) RB_OBJ_WRITE((cmp), &((struct RComplex *)(cmp))->imag,(i))
+#endif
+
+struct RHash {
+    struct RBasic basic;
+    struct st_table *ntbl;      /* possibly 0 */
+    int iter_lev;
+    const VALUE ifnone;
+};
+
+#define RHASH(obj)   (R_CAST(RHash)(obj))
+
+#ifdef RHASH_ITER_LEV
+#undef RHASH_ITER_LEV
+#undef RHASH_IFNONE
+#undef RHASH_SIZE
+#define RHASH_ITER_LEV(h) (RHASH(h)->iter_lev)
+#define RHASH_IFNONE(h) (RHASH(h)->ifnone)
+#define RHASH_SIZE(h) (RHASH(h)->ntbl ? (st_index_t)RHASH(h)->ntbl->num_entries : 0)
+#endif
+
 /* class.c */
 void rb_class_subclass_add(VALUE super, VALUE klass);
 void rb_class_remove_from_super_subclasses(VALUE);
@@ -449,9 +506,21 @@ RCLASS_SET_SUPER(VALUE klass, VALUE super)
 struct vtm; /* defined by timev.h */
 
 /* array.c */
-VALUE rb_ary_last(int, VALUE *, VALUE);
+VALUE rb_ary_last(int, const VALUE *, VALUE);
 void rb_ary_set_len(VALUE, long);
 void rb_ary_delete_same(VALUE, VALUE);
+VALUE rb_ary_tmp_new_fill(long capa);
+#ifdef __GNUC__
+#define rb_ary_new_from_args(n, ...) \
+    __extension__ ({ \
+	const VALUE args_to_new_ary[] = {__VA_ARGS__}; \
+	if (__builtin_constant_p(n)) { \
+	    STATIC_ASSERT(rb_ary_new_from_args, numberof(args_to_new_ary) == (n)); \
+	    (void)sizeof(STATIC_ASSERT_TYPE(rb_ary_new_from_args)); /* suppress warnings by gcc 4.8 or later */ \
+	} \
+	rb_ary_new_from_values(numberof(args_to_new_ary), args_to_new_ary); \
+    })
+#endif
 
 /* bignum.c */
 VALUE rb_big_fdiv(VALUE x, VALUE y);
@@ -464,10 +533,10 @@ void rb_class_foreach_subclass(VALUE klass, void(*f)(VALUE));
 void rb_class_detach_subclasses(VALUE);
 void rb_class_detach_module_subclasses(VALUE);
 void rb_class_remove_from_module_subclasses(VALUE);
-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);
+VALUE rb_obj_methods(int argc, const VALUE *argv, VALUE obj);
+VALUE rb_obj_protected_methods(int argc, const VALUE *argv, VALUE obj);
+VALUE rb_obj_private_methods(int argc, const VALUE *argv, VALUE obj);
+VALUE rb_obj_public_methods(int argc, const 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);
@@ -576,7 +645,11 @@ void Init_heap(void);
 void *ruby_mimmalloc(size_t size);
 void ruby_mimfree(void *ptr);
 void rb_objspace_set_event_hook(const rb_event_flag_t event);
-void rb_gc_writebarrier_remember_promoted(VALUE obj);
+#if USE_RGENGC
+void rb_gc_writebarrier_remember(VALUE obj);
+#else
+#define rb_gc_writebarrier_remember(obj) 0
+#endif
 void ruby_gc_set_params(int safe_level);
 
 #if defined(HAVE_MALLOC_USABLE_SIZE) || defined(HAVE_MALLOC_SIZE) || defined(_WIN32)
@@ -595,7 +668,10 @@ void rb_gc_resurrect(VALUE ptr);
 
 /* hash.c */
 struct st_table *rb_hash_tbl_raw(VALUE hash);
+VALUE rb_hash_has_key(VALUE hash, VALUE key);
+
 #define RHASH_TBL_RAW(h) rb_hash_tbl_raw(h)
+VALUE rb_hash_keys(VALUE hash);
 VALUE rb_hash_values(VALUE hash);
 #define HASH_DELETED  FL_USER1
 #define HASH_PROC_DEFAULT FL_USER2
@@ -632,10 +708,12 @@ 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_log(int argc, const VALUE *argv);
 VALUE rb_math_sin(VALUE);
 VALUE rb_math_sinh(VALUE);
+#if 0
 VALUE rb_math_sqrt(VALUE);
+#endif
 
 /* newline.c */
 void Init_newline(void);
@@ -714,7 +792,9 @@ rb_float_new_inline(double d)
 #define rb_float_new(d)   rb_float_new_inline(d)
 
 /* object.c */
+void rb_obj_copy_ivar(VALUE dest, VALUE obj);
 VALUE rb_obj_equal(VALUE obj1, VALUE obj2);
+VALUE rb_class_search_ancestor(VALUE klass, VALUE super);
 
 struct RBasicRaw {
     VALUE flags;
@@ -729,6 +809,9 @@ struct RBasicRaw {
 } while (0)
 
 /* parse.y */
+#ifndef USE_SYMBOL_GC
+#define USE_SYMBOL_GC 1
+#endif
 VALUE rb_parser_get_yydebug(VALUE);
 VALUE rb_parser_set_yydebug(VALUE, VALUE);
 int rb_is_const_name(VALUE name);
@@ -739,14 +822,15 @@ 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(int full_mark);
 ID rb_make_internal_id(void);
+void rb_gc_free_dsymbol(VALUE);
+ID rb_id_attrget(ID id);
 
 /* proc.c */
 VALUE rb_proc_location(VALUE self);
 st_index_t rb_hash_proc(st_index_t hash, VALUE proc);
 int rb_block_arity(void);
+VALUE rb_block_clear_env_self(VALUE proc);
 
 /* process.c */
 #define RB_MAX_GROUPS (65536)
@@ -810,6 +894,8 @@ 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);
+long rb_reg_search0(VALUE, VALUE, long, int, int);
+void rb_backref_set_string(VALUE string, long pos, long len);
 
 /* signal.c */
 int rb_get_next_signal(void);
@@ -824,7 +910,9 @@ size_t rb_strftime(char *s, size_t maxsize, const char *format, rb_encoding *enc
 #endif
 
 /* string.c */
+void Init_frozen_strings(void);
 VALUE rb_fstring(VALUE);
+VALUE rb_fstring_new(const char *ptr, long len);
 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);
@@ -874,6 +962,7 @@ rb_serial_t rb_next_class_serial(void);
 VALUE rb_obj_is_thread(VALUE obj);
 void rb_vm_mark(void *ptr);
 void Init_BareVM(void);
+void Init_vm_objects(void);
 VALUE rb_vm_top_self(void);
 void rb_thread_recycle_stack_release(VALUE *);
 void rb_vm_change_state(void);
@@ -884,7 +973,6 @@ VALUE rb_sourcefilename(void);
 void rb_vm_pop_cfunc_frame(void);
 
 /* vm_dump.c */
-void rb_vm_bugreport(void);
 void rb_print_backtrace(void);
 
 /* vm_eval.c */
@@ -910,8 +998,8 @@ 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_vm_thread_backtrace(int argc, const VALUE *argv, VALUE thval);
+VALUE rb_vm_thread_backtrace_locations(int argc, const VALUE *argv, VALUE thval);
 
 VALUE rb_make_backtrace(void);
 void rb_backtrace_print_as_bugreport(void);
@@ -963,9 +1051,9 @@ VALUE rb_int_positive_pow(long x, unsigned long y);
 /* 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);
+VALUE rb_execarg_new(int argc, const 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);
+VALUE rb_execarg_init(int argc, const 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);
@@ -978,6 +1066,12 @@ VALUE rb_gcd_normal(VALUE self, VALUE other);
 VALUE rb_gcd_gmp(VALUE x, VALUE y);
 #endif
 
+/* string.c */
+#ifdef RUBY_ENCODING_H
+/* internal use */
+VALUE rb_setup_fake_str(struct RString *fake_str, const char *name, long len, rb_encoding *enc);
+#endif
+
 /* util.c */
 extern const signed char ruby_digit36_to_number_table[];
 
@@ -993,6 +1087,7 @@ st_table *rb_st_copy(VALUE obj, struct st_table *orig_tbl);
 size_t rb_obj_memsize_of(VALUE);
 #define RB_OBJ_GC_FLAGS_MAX 5
 size_t rb_obj_gc_flags(VALUE, ID[], size_t);
+void rb_gc_mark_values(long n, const VALUE *values);
 
 RUBY_SYMBOL_EXPORT_END