kanayago 0.2.0 → 0.4.0

data/ext/kanayago/internal/sanitizers.h

@@ -1,346 +0,0 @@
-#ifndef INTERNAL_SANITIZERS_H                            /*-*-C-*-vi:se ft=c:*/
-#define INTERNAL_SANITIZERS_H
-/**
- * @author     Ruby developers <ruby-core@ruby-lang.org>
- * @copyright  This  file  is   a  part  of  the   programming  language  Ruby.
- *             Permission  is hereby  granted,  to  either redistribute  and/or
- *             modify this file, provided that  the conditions mentioned in the
- *             file COPYING are met.  Consult the file for details.
- * @brief      Internal header for ASAN / MSAN / etc.
- */
-#include "ruby/internal/config.h"
-#include "internal/compilers.h" /* for __has_feature */
-
-#ifdef HAVE_VALGRIND_MEMCHECK_H
-# include <valgrind/memcheck.h>
-#endif
-
-#ifdef HAVE_SANITIZER_ASAN_INTERFACE_H
-# if __has_feature(address_sanitizer) || defined(__SANITIZE_ADDRESS__)
-#  define RUBY_ASAN_ENABLED
-#  include <sanitizer/asan_interface.h>
-# endif
-#endif
-
-#ifdef HAVE_SANITIZER_MSAN_INTERFACE_H
-# if __has_feature(memory_sanitizer)
-#  define RUBY_MSAN_ENABLED
-#  include <sanitizer/msan_interface.h>
-# endif
-#endif
-
-#ifdef HAVE_SANITIZER_TSAN_INTERFACE_H
-# if __has_feature(thread_sanitizer) || defined(__SANITIZE_THREAD__)
-#  define RUBY_TSAN_ENABLED
-#  include <sanitizer/tsan_interface.h>
-# endif
-#endif
-
-#include "ruby/internal/stdbool.h"     /* for bool */
-#include "ruby/ruby.h"          /* for VALUE */
-
-#if 0
-#elif defined(RUBY_ASAN_ENABLED) && defined(RUBY_MSAN_ENABLED)
-# define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
-    __attribute__((__no_sanitize__("memory, address"), __noinline__)) x
-#elif defined(RUBY_ASAN_ENABLED)
-# define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
-    __attribute__((__no_sanitize__("address"), __noinline__)) x
-#elif defined(RUBY_MSAN_ENABLED)
-    # define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
-    __attribute__((__no_sanitize__("memory"), __noinline__)) x
-#elif defined(RUBY_TSAN_ENABLED)
-# define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
-    __attribute__((__no_sanitize__("thread"), __noinline__)) x
-#elif defined(NO_SANITIZE_ADDRESS)
-# define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
-    NO_SANITIZE_ADDRESS(NOINLINE(x))
-#elif defined(NO_ADDRESS_SAFETY_ANALYSIS)
-# define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) \
-    NO_ADDRESS_SAFETY_ANALYSIS(NOINLINE(x))
-#else
-# define ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(x) x
-#endif
-
-#if defined(NO_SANITIZE) && RBIMPL_COMPILER_IS(GCC)
-/* GCC warns about unknown sanitizer, which is annoying. */
-# include "internal/warnings.h"
-# undef NO_SANITIZE
-# define NO_SANITIZE(x, y) \
-    COMPILER_WARNING_PUSH \
-    COMPILER_WARNING_IGNORED(-Wattributes) \
-    __attribute__((__no_sanitize__(x))) y; \
-    COMPILER_WARNING_POP \
-    y
-#endif
-
-#ifndef NO_SANITIZE
-# define NO_SANITIZE(x, y) y
-#endif
-
-#ifndef RUBY_ASAN_ENABLED
-# define __asan_poison_memory_region(x, y)
-# define __asan_unpoison_memory_region(x, y)
-# define __asan_region_is_poisoned(x, y) 0
-# define __asan_get_current_fake_stack() NULL
-# define __asan_addr_is_in_fake_stack(fake_stack, slot, start, end) NULL
-#endif
-
-#ifndef RUBY_MSAN_ENABLED
-# define __msan_allocated_memory(x, y) ((void)(x), (void)(y))
-# define __msan_poison(x, y) ((void)(x), (void)(y))
-# define __msan_unpoison(x, y) ((void)(x), (void)(y))
-# define __msan_unpoison_string(x) ((void)(x))
-#endif
-
-#ifdef VALGRIND_MAKE_READABLE
-# define VALGRIND_MAKE_MEM_DEFINED(p, n) VALGRIND_MAKE_READABLE((p), (n))
-#endif
-
-#ifdef VALGRIND_MAKE_WRITABLE
-# define VALGRIND_MAKE_MEM_UNDEFINED(p, n) VALGRIND_MAKE_WRITABLE((p), (n))
-#endif
-
-#ifndef VALGRIND_MAKE_MEM_DEFINED
-# define VALGRIND_MAKE_MEM_DEFINED(p, n) 0
-#endif
-
-#ifndef VALGRIND_MAKE_MEM_UNDEFINED
-# define VALGRIND_MAKE_MEM_UNDEFINED(p, n) 0
-#endif
-
-/**
- * This function asserts that a (continuous) memory region from ptr to size
- * being "poisoned".  Both read / write access to such memory region are
- * prohibited until properly unpoisoned.  The region must be previously
- * allocated (do not pass a freed pointer here), but not necessarily be an
- * entire object that the malloc returns.  You can punch hole a part of a
- * gigantic heap arena.  This is handy when you do not free an allocated memory
- * region to reuse later: poison when you keep it unused, and unpoison when you
- * reuse.
- *
- * @param[in]  ptr   pointer to the beginning of the memory region to poison.
- * @param[in]  size  the length of the memory region to poison.
- */
-static inline void
-asan_poison_memory_region(const volatile void *ptr, size_t size)
-{
-    __msan_poison(ptr, size);
-    __asan_poison_memory_region(ptr, size);
-}
-
-#ifdef RUBY_ASAN_ENABLED
-#define asan_poison_object_if(ptr, obj) do { \
-        if (ptr) rb_asan_poison_object(obj); \
-    } while (0)
-#else
-#define asan_poison_object_if(ptr, obj) ((void)(ptr), (void)(obj))
-#endif
-
-#ifdef RUBY_ASAN_ENABLED
-RUBY_SYMBOL_EXPORT_BEGIN
-/**
- * This is a variant of asan_poison_memory_region that takes a VALUE.
- *
- * @param[in]  obj   target object.
- */
-void rb_asan_poison_object(VALUE obj);
-
-/**
- * This function predicates if the given object is fully addressable or not.
- *
- * @param[in]  obj        target object.
- * @retval     0          the given object is fully addressable.
- * @retval     otherwise  pointer to first such byte who is poisoned.
- */
-void *rb_asan_poisoned_object_p(VALUE obj);
-
-/**
- * This is a variant of asan_unpoison_memory_region that takes a VALUE.
- *
- * @param[in]  obj       target object.
- * @param[in]  malloc_p  if the memory region is like a malloc's return value or not.
- */
-void rb_asan_unpoison_object(VALUE obj, bool newobj_p);
-
-RUBY_SYMBOL_EXPORT_END
-#else
-# define rb_asan_poison_object(obj) ((void)obj)
-# define rb_asan_poisoned_object_p(obj) ((void)obj, NULL)
-# define rb_asan_unpoison_object(obj, newobj_p) ((void)obj, (void)newobj_p)
-#endif
-
-/**
- * This function asserts that a (formally poisoned) memory region from ptr to
- * size is now addressable.  Write access to such memory region gets allowed.
- * However read access might or might not be possible depending on situations,
- * because the region can have contents of previous usages.  That information
- * should be passed by the malloc_p flag.  If that is true, the contents of the
- * region is _not_ fully defined (like the return value of malloc behaves).
- * Reading from there is NG; write something first.  If malloc_p is false on
- * the other hand, that memory region is fully defined and can be read
- * immediately.
- *
- * @param[in]  ptr       pointer to the beginning of the memory region to unpoison.
- * @param[in]  size      the length of the memory region.
- * @param[in]  malloc_p  if the memory region is like a malloc's return value or not.
- */
-static inline void
-asan_unpoison_memory_region(const volatile void *ptr, size_t size, bool malloc_p)
-{
-    __asan_unpoison_memory_region(ptr, size);
-    if (malloc_p) {
-        __msan_allocated_memory(ptr, size);
-    }
-    else {
-        __msan_unpoison(ptr, size);
-    }
-}
-
-static inline void *
-asan_unpoison_object_temporary(VALUE obj)
-{
-    void *ptr = rb_asan_poisoned_object_p(obj);
-    rb_asan_unpoison_object(obj, false);
-    return ptr;
-}
-
-static inline void *
-asan_poison_object_restore(VALUE obj, void *ptr)
-{
-    if (ptr) {
-        rb_asan_poison_object(obj);
-    }
-    return NULL;
-}
-
-#define asan_unpoisoning_object(obj) \
-    for (void *poisoned = asan_unpoison_object_temporary(obj), \
-              *unpoisoning = &poisoned; /* flag to loop just once */ \
-         unpoisoning; \
-         unpoisoning = asan_poison_object_restore(obj, poisoned))
-
-
-static inline void *
-asan_unpoison_memory_region_temporary(void *ptr, size_t len)
-{
-    void *poisoned_ptr = __asan_region_is_poisoned(ptr, len);
-    asan_unpoison_memory_region(ptr, len, false);
-    return poisoned_ptr;
-}
-
-static inline void *
-asan_poison_memory_region_restore(void *ptr, size_t len, void *poisoned_ptr)
-{
-    if (poisoned_ptr) {
-        asan_poison_memory_region(ptr, len);
-    }
-    return NULL;
-}
-
-#define asan_unpoisoning_memory_region(ptr, len) \
-    for (void *poisoned = asan_unpoison_memory_region_temporary(ptr, len), \
-              *unpoisoning = &poisoned; /* flag to loop just once */ \
-         unpoisoning; \
-         unpoisoning = asan_poison_memory_region_restore(ptr, len, poisoned))
-
-/**
- * Checks if the given pointer is on an ASAN fake stack. If so, it returns the
- * address this variable has on the real frame; if not, it returns the origin
- * address unmodified.
- *
- * n.b. - _dereferencing_ the returned address is meaningless and should not
- * be done; even though ASAN reserves space for the variable in both the real and
- * fake stacks, the _value_ of that variable is only in the fake stack.
- *
- * n.b. - this only works for addresses passed in from local variables on the same
- * thread, because the ASAN fake stacks are threadlocal.
- *
- * @param[in] slot  the address of some local variable
- * @retval          a pointer to something from that frame on the _real_ machine stack
- */
-static inline void *
-asan_get_real_stack_addr(void* slot)
-{
-    VALUE *addr;
-    addr = __asan_addr_is_in_fake_stack(__asan_get_current_fake_stack(), slot, NULL, NULL);
-    return addr ? addr : slot;
-}
-
-/**
- * Gets the current thread's fake stack handle, which can be passed into get_fake_stack_extents
- *
- * @retval An opaque value which can be passed to asan_get_fake_stack_extents
- */
-static inline void *
-asan_get_thread_fake_stack_handle(void)
-{
-    return __asan_get_current_fake_stack();
-}
-
-/**
- * Checks if the given VALUE _actually_ represents a pointer to an ASAN fake stack.
- *
- * If the given slot _is_ actually a reference to an ASAN fake stack, and that fake stack
- * contains the real values for the passed-in range of machine stack addresses, returns true
- * and the range of the fake stack through the outparams.
- *
- * Otherwise, returns false, and sets the outparams to NULL.
- *
- * Note that this function expects "start" to be > "end" on downward-growing stack architectures;
- *
- * @param[in]  thread_fake_stack_handle  The asan fake stack reference for the thread we're scanning
- * @param[in]  slot                      The value on the machine stack we want to inspect
- * @param[in]  machine_stack_start       The extents of the real machine stack on which slot lives
- * @param[in]  machine_stack_end         The extents of the real machine stack on which slot lives
- * @param[out] fake_stack_start_out      The extents of the fake stack which contains real VALUEs
- * @param[out] fake_stack_end_out        The extents of the fake stack which contains real VALUEs
- * @return                               Whether slot is a pointer to a fake stack for the given machine stack range
-*/
-
-static inline bool
-asan_get_fake_stack_extents(void *thread_fake_stack_handle, VALUE slot,
-                            void *machine_stack_start, void *machine_stack_end,
-                            void **fake_stack_start_out, void **fake_stack_end_out)
-{
-    /* the ifdef is needed here to suppress a warning about fake_frame_{start/end} being
-       uninitialized if __asan_addr_is_in_fake_stack is an empty macro */
-#ifdef RUBY_ASAN_ENABLED
-    void *fake_frame_start;
-    void *fake_frame_end;
-    void *real_stack_frame = __asan_addr_is_in_fake_stack(
-        thread_fake_stack_handle, (void *)slot, &fake_frame_start, &fake_frame_end
-    );
-    if (real_stack_frame) {
-        bool in_range;
-#if STACK_GROW_DIRECTION < 0
-        in_range = machine_stack_start >= real_stack_frame && real_stack_frame >= machine_stack_end;
-#else
-        in_range = machine_stack_start <= real_stack_frame && real_stack_frame <= machine_stack_end;
-#endif
-        if (in_range) {
-            *fake_stack_start_out = fake_frame_start;
-            *fake_stack_end_out = fake_frame_end;
-            return true;
-        }
-    }
-#endif
-    *fake_stack_start_out = 0;
-    *fake_stack_end_out = 0;
-    return false;
-}
-
-extern const char ruby_asan_default_options[];
-
-#ifdef RUBY_ASAN_ENABLED
-/* Compile in the ASAN options Ruby needs, rather than relying on environment variables, so
- * that even tests which fork ruby with a clean environment will run ASAN with the right
- * settings */
-# undef RUBY__ASAN_DEFAULT_OPTIONS
-# define RUBY__ASAN_DEFAULT_OPTIONS \
-    RBIMPL_SYMBOL_EXPORT_BEGIN() \
-    const char * __asan_default_options(void) {return ruby_asan_default_options;} \
-    RBIMPL_SYMBOL_EXPORT_END()
-#endif
-
-#endif /* INTERNAL_SANITIZERS_H */

data/ext/kanayago/internal/serial.h

@@ -1,23 +0,0 @@
-#ifndef INTERNAL_SERIAL_H                                /*-*-C-*-vi:se ft=c:*/
-#define INTERNAL_SERIAL_H
-/**
- * @author     Ruby developers <ruby-core@ruby-lang.org>
- * @copyright  This  file  is   a  part  of  the   programming  language  Ruby.
- *             Permission  is hereby  granted,  to  either redistribute  and/or
- *             modify this file, provided that  the conditions mentioned in the
- *             file COPYING are met.  Consult the file for details.
- * @brief      Internal header for rb_serial_t.
- */
-#include "ruby/internal/config.h"      /* for HAVE_LONG_LONG */
-#include "ruby/defines.h"       /* for LONG_LONG */
-
-#ifndef HAVE_LONG_LONG
-# error need C99+
-#endif
-
-typedef unsigned LONG_LONG rb_serial_t;
-#define SERIALT2NUM ULL2NUM
-#define PRI_SERIALT_PREFIX PRI_LL_PREFIX
-#define SIZEOF_SERIAL_T SIZEOF_LONG_LONG
-
-#endif /* INTERNAL_SERIAL_H */

data/ext/kanayago/internal/set_table.h

@@ -1,70 +0,0 @@
-#ifndef INTERNAL_SET_TABLE_H
-#define INTERNAL_SET_TABLE_H
-
-#include "include/ruby/st.h"
-
-struct set_table_entry;
-
-typedef struct set_table_entry set_table_entry;
-
-struct set_table {
-    /* Cached features of the table -- see st.c for more details.  */
-    unsigned char entry_power, bin_power, size_ind;
-    /* How many times the table was rebuilt.  */
-    unsigned int rebuilds_num;
-    const struct st_hash_type *type;
-    /* Number of entries currently in the table.  */
-    st_index_t num_entries;
-
-    /* Start and bound index of entries in array entries.
-       entries_starts and entries_bound are in interval
-       [0,allocated_entries].  */
-    st_index_t entries_start, entries_bound;
-
-    /**
-     * Array of size 2^entry_power.
-     * Followed by st_index_t *bins, Array of bins used for access by keys.
-     */
-    set_table_entry *entries;
-};
-
-typedef struct set_table set_table;
-
-typedef int set_foreach_callback_func(st_data_t, st_data_t);
-typedef int set_foreach_check_callback_func(st_data_t, st_data_t, int);
-typedef int set_update_callback_func(st_data_t *key, st_data_t arg, int existing);
-
-#define set_table_size rb_set_table_size
-size_t rb_set_table_size(const struct set_table *tbl);
-#define set_init_table_with_size rb_set_init_table_with_size
-set_table *rb_set_init_table_with_size(set_table *tab, const struct st_hash_type *, st_index_t);
-#define set_init_numtable rb_set_init_numtable
-set_table *rb_set_init_numtable(void);
-#define set_init_numtable_with_size rb_set_init_numtable_with_size
-set_table *rb_set_init_numtable_with_size(st_index_t size);
-#define set_table_delete rb_set_table_delete
-int rb_set_table_delete(set_table *, st_data_t *); /* returns 0:notfound 1:deleted */
-#define set_insert rb_set_insert
-int rb_set_insert(set_table *, st_data_t);
-#define set_table_lookup rb_set_table_lookup
-int rb_set_table_lookup(set_table *, st_data_t);
-#define set_foreach_with_replace rb_set_foreach_with_replace
-int rb_set_foreach_with_replace(set_table *tab, set_foreach_check_callback_func *func, set_update_callback_func *replace, st_data_t arg);
-#define set_table_foreach rb_set_table_foreach
-int rb_set_table_foreach(set_table *, set_foreach_callback_func *, st_data_t);
-#define set_foreach_check rb_set_foreach_check
-int rb_set_foreach_check(set_table *, set_foreach_check_callback_func *, st_data_t, st_data_t);
-#define set_keys rb_set_keys
-st_index_t rb_set_keys(set_table *table, st_data_t *keys, st_index_t size);
-#define set_free_table rb_set_free_table
-void rb_set_free_table(set_table *);
-#define set_table_clear rb_set_table_clear
-void rb_set_table_clear(set_table *);
-#define set_copy rb_set_copy
-set_table *rb_set_copy(set_table *new_table, set_table *old_table);
-#define set_memsize rb_set_memsize
-PUREFUNC(size_t rb_set_memsize(const set_table *));
-#define set_compact_table rb_set_compact_table
-void set_compact_table(set_table *tab);
-
-#endif

data/ext/kanayago/internal/static_assert.h

@@ -1,16 +0,0 @@
-#ifndef INTERNAL_STATIC_ASSERT_H                         /*-*-C-*-vi:se ft=c:*/
-#define INTERNAL_STATIC_ASSERT_H
-/**
- * @author     Ruby developers <ruby-core@ruby-lang.org>
- * @copyright  This  file  is   a  part  of  the   programming  language  Ruby.
- *             Permission  is hereby  granted,  to  either redistribute  and/or
- *             modify this file, provided that  the conditions mentioned in the
- *             file COPYING are met.  Consult the file for details.
- * @brief      C11 shim for _Static_assert.
- */
-#include "ruby/internal/static_assert.h"
-#ifndef STATIC_ASSERT
-# define STATIC_ASSERT RBIMPL_STATIC_ASSERT
-#endif
-
-#endif /* INTERNAL_STATIC_ASSERT_H */

data/ext/kanayago/internal/string.h

@@ -1,203 +0,0 @@
-#ifndef INTERNAL_STRING_H                                /*-*-C-*-vi:se ft=c:*/
-#define INTERNAL_STRING_H
-/**
- * @author     Ruby developers <ruby-core@ruby-lang.org>
- * @copyright  This  file  is   a  part  of  the   programming  language  Ruby.
- *             Permission  is hereby  granted,  to  either redistribute  and/or
- *             modify this file, provided that  the conditions mentioned in the
- *             file COPYING are met.  Consult the file for details.
- * @brief      Internal header for String.
- */
-#include "ruby/internal/config.h"
-#include <stddef.h>             /* for size_t */
-#include "internal/compilers.h" /* for __has_builtin */
-#include "ruby/internal/stdbool.h"     /* for bool */
-#include "ruby/encoding.h"      /* for rb_encoding */
-#include "ruby/ruby.h"          /* for VALUE */
-
-#define STR_SHARED                  FL_USER0 /* = ELTS_SHARED */
-#define STR_NOEMBED                 FL_USER1
-#define STR_CHILLED                 (FL_USER2 | FL_USER3)
-#define STR_CHILLED_LITERAL         FL_USER2
-#define STR_CHILLED_SYMBOL_TO_S     FL_USER3
-
-enum ruby_rstring_private_flags {
-    RSTRING_CHILLED = STR_CHILLED,
-};
-
-#ifdef rb_fstring_cstr
-# undef rb_fstring_cstr
-#endif
-
-/* string.c */
-VALUE rb_str_dup_m(VALUE str);
-VALUE rb_fstring(VALUE);
-VALUE rb_fstring_cstr(const char *str);
-VALUE rb_fstring_enc_new(const char *ptr, long len, rb_encoding *enc);
-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);
-char *rb_str_fill_terminator(VALUE str, const int termlen);
-void rb_str_change_terminator_length(VALUE str, const int oldtermlen, const int termlen);
-VALUE rb_str_locktmp_ensure(VALUE str, VALUE (*func)(VALUE), VALUE arg);
-VALUE rb_str_chomp_string(VALUE str, VALUE chomp);
-VALUE rb_external_str_with_enc(VALUE str, rb_encoding *eenc);
-VALUE rb_str_cat_conv_enc_opts(VALUE newstr, long ofs, const char *ptr, long len,
-                               rb_encoding *from, int ecflags, VALUE ecopts);
-VALUE rb_enc_str_scrub(rb_encoding *enc, VALUE str, VALUE repl);
-VALUE rb_str_escape(VALUE str);
-size_t rb_str_memsize(VALUE);
-char *rb_str_to_cstr(VALUE str);
-const char *ruby_escaped_char(int c);
-void rb_str_make_independent(VALUE str);
-int rb_enc_str_coderange_scan(VALUE str, rb_encoding *enc);
-int rb_ascii8bit_appendable_encoding_index(rb_encoding *enc, unsigned int code);
-VALUE rb_str_include(VALUE str, VALUE arg);
-VALUE rb_str_byte_substr(VALUE str, VALUE beg, VALUE len);
-VALUE rb_str_substr_two_fixnums(VALUE str, VALUE beg, VALUE len, int empty);
-VALUE rb_str_tmp_frozen_no_embed_acquire(VALUE str);
-void rb_str_make_embedded(VALUE);
-VALUE rb_str_upto_each(VALUE, VALUE, int, int (*each)(VALUE, VALUE), VALUE);
-size_t rb_str_size_as_embedded(VALUE);
-bool rb_str_reembeddable_p(VALUE);
-VALUE rb_str_upto_endless_each(VALUE, int (*each)(VALUE, VALUE), VALUE);
-VALUE rb_str_with_debug_created_info(VALUE, VALUE, int);
-VALUE rb_str_frozen_bare_string(VALUE);
-
-/* error.c */
-void rb_warn_unchilled_literal(VALUE str);
-void rb_warn_unchilled_symbol_to_s(VALUE str);
-
-static inline bool STR_EMBED_P(VALUE str);
-static inline bool STR_SHARED_P(VALUE str);
-static inline VALUE QUOTE(VALUE v);
-static inline VALUE QUOTE_ID(ID v);
-static inline bool is_ascii_string(VALUE str);
-static inline bool is_broken_string(VALUE str);
-static inline VALUE rb_str_eql_internal(const VALUE str1, const VALUE str2);
-
-RUBY_SYMBOL_EXPORT_BEGIN
-/* string.c (export) */
-VALUE rb_str_tmp_frozen_acquire(VALUE str);
-void rb_str_tmp_frozen_release(VALUE str, VALUE tmp);
-VALUE rb_setup_fake_str(struct RString *fake_str, const char *name, long len, rb_encoding *enc);
-RUBY_SYMBOL_EXPORT_END
-
-VALUE rb_fstring_new(const char *ptr, long len);
-void rb_gc_free_fstring(VALUE obj);
-bool rb_obj_is_fstring_table(VALUE obj);
-void Init_fstring_table();
-VALUE rb_obj_as_string_result(VALUE str, VALUE obj);
-VALUE rb_str_opt_plus(VALUE x, VALUE y);
-VALUE rb_str_concat_literals(size_t num, const VALUE *strary);
-VALUE rb_str_eql(VALUE str1, VALUE str2);
-VALUE rb_id_quote_unprintable(ID);
-VALUE rb_sym_proc_call(ID mid, int argc, const VALUE *argv, int kw_splat, VALUE passed_proc);
-VALUE rb_enc_literal_str(const char *ptr, long len, rb_encoding *enc);
-
-struct rb_execution_context_struct;
-VALUE rb_ec_str_resurrect(struct rb_execution_context_struct *ec, VALUE str, bool chilled);
-
-#define rb_fstring_lit(str) rb_fstring_new((str), rb_strlen_lit(str))
-#define rb_fstring_literal(str) rb_fstring_lit(str)
-#define rb_fstring_enc_lit(str, enc) rb_fstring_enc_new((str), rb_strlen_lit(str), (enc))
-#define rb_fstring_enc_literal(str, enc) rb_fstring_enc_lit(str, enc)
-
-static inline VALUE
-QUOTE(VALUE v)
-{
-    return rb_str_quote_unprintable(v);
-}
-
-static inline VALUE
-QUOTE_ID(ID i)
-{
-    return rb_id_quote_unprintable(i);
-}
-
-static inline bool
-STR_EMBED_P(VALUE str)
-{
-    return ! FL_TEST_RAW(str, STR_NOEMBED);
-}
-
-static inline bool
-STR_SHARED_P(VALUE str)
-{
-    return FL_ALL_RAW(str, STR_NOEMBED | STR_SHARED);
-}
-
-static inline bool
-CHILLED_STRING_P(VALUE obj)
-{
-    return RB_TYPE_P(obj, T_STRING) && FL_TEST_RAW(obj, STR_CHILLED);
-}
-
-static inline void
-CHILLED_STRING_MUTATED(VALUE str)
-{
-    VALUE chilled_reason = RB_FL_TEST_RAW(str, STR_CHILLED);
-    FL_UNSET_RAW(str, STR_CHILLED);
-    switch (chilled_reason) {
-      case STR_CHILLED_SYMBOL_TO_S:
-        rb_warn_unchilled_symbol_to_s(str);
-        break;
-      case STR_CHILLED_LITERAL:
-        rb_warn_unchilled_literal(str);
-        break;
-      default:
-        rb_bug("RString was chilled for multiple reasons");
-    }
-}
-
-static inline bool
-is_ascii_string(VALUE str)
-{
-    return rb_enc_str_coderange(str) == ENC_CODERANGE_7BIT;
-}
-
-static inline bool
-is_broken_string(VALUE str)
-{
-    return rb_enc_str_coderange(str) == ENC_CODERANGE_BROKEN;
-}
-
-static inline bool
-at_char_boundary(const char *s, const char *p, const char *e, rb_encoding *enc)
-{
-    return rb_enc_left_char_head(s, p, e, enc) == p;
-}
-
-static inline bool
-at_char_right_boundary(const char *s, const char *p, const char *e, rb_encoding *enc)
-{
-    RUBY_ASSERT(s <= p);
-    RUBY_ASSERT(p <= e);
-
-    return rb_enc_right_char_head(s, p, e, enc) == p;
-}
-
-/* expect tail call optimization */
-// YJIT needs this function to never allocate and never raise
-static inline VALUE
-rb_str_eql_internal(const VALUE str1, const VALUE str2)
-{
-    const long len = RSTRING_LEN(str1);
-    const char *ptr1, *ptr2;
-
-    if (len != RSTRING_LEN(str2)) return Qfalse;
-    if (!rb_str_comparable(str1, str2)) return Qfalse;
-    if ((ptr1 = RSTRING_PTR(str1)) == (ptr2 = RSTRING_PTR(str2)))
-        return Qtrue;
-    if (memcmp(ptr1, ptr2, len) == 0)
-        return Qtrue;
-    return Qfalse;
-}
-
-#if __has_builtin(__builtin_constant_p)
-# define rb_fstring_cstr(str) \
-    (__builtin_constant_p(str) ? \
-        rb_fstring_new((str), (long)strlen(str)) : \
-        (rb_fstring_cstr)(str))
-#endif
-#endif /* INTERNAL_STRING_H */