Import files from MRI 3.0.3

Author: eregon

lib/cext/include/internal/imemo.h

@@ -137,17 +137,9 @@ static inline enum imemo_type imemo_type(VALUE imemo);
 static inline int imemo_type_p(VALUE imemo, enum imemo_type imemo_type);
 static inline bool imemo_throw_data_p(VALUE imemo);
 static inline struct vm_ifunc *rb_vm_ifunc_proc_new(rb_block_call_func_t func, const void *data);
-#ifdef TRUFFLERUBY
-VALUE rb_imemo_tmpbuf_auto_free_pointer(void);
-#else
 static inline VALUE rb_imemo_tmpbuf_auto_free_pointer(void);
-#endif
 static inline void *RB_IMEMO_TMPBUF_PTR(VALUE v);
-#ifdef TRUFFLERUBY
-void *rb_imemo_tmpbuf_set_ptr(VALUE v, void *ptr);
-#else
 static inline void *rb_imemo_tmpbuf_set_ptr(VALUE v, void *ptr);
-#endif
 static inline VALUE rb_imemo_tmpbuf_auto_free_pointer_new_from_an_RString(VALUE str);
 static inline void MEMO_V1_SET(struct MEMO *m, VALUE v);
 static inline void MEMO_V2_SET(struct MEMO *m, VALUE v);
@@ -197,13 +189,11 @@ rb_vm_ifunc_proc_new(rb_block_call_func_t func, const void *data)
     return rb_vm_ifunc_new(func, data, 0, UNLIMITED_ARGUMENTS);
 }
 
-#ifndef TRUFFLERUBY
 static inline VALUE
 rb_imemo_tmpbuf_auto_free_pointer(void)
 {
     return rb_imemo_new(imemo_tmpbuf, 0, 0, 0, 0);
 }
-#endif
 
 static inline void *
 RB_IMEMO_TMPBUF_PTR(VALUE v)
@@ -212,13 +202,11 @@ RB_IMEMO_TMPBUF_PTR(VALUE v)
     return p->ptr;
 }
 
-#ifndef TRUFFLERUBY
 static inline void *
 rb_imemo_tmpbuf_set_ptr(VALUE v, void *ptr)
 {
     return ((rb_imemo_tmpbuf_t *)v)->ptr = ptr;
 }
-#endif
 
 static inline VALUE
 rb_imemo_tmpbuf_auto_free_pointer_new_from_an_RString(VALUE str)

lib/cext/include/ruby/encoding.h

@@ -30,27 +30,18 @@ enum ruby_encoding_consts {
 #define ENCODING_SHIFT RUBY_ENCODING_SHIFT
 #define ENCODING_MASK RUBY_ENCODING_MASK
 
-#ifdef TRUFFLERUBY
-#define RB_ENCODING_SET_INLINED(obj,i) RB_ENCODING_SET(obj,i)
-#else
 #define RB_ENCODING_SET_INLINED(obj,i) do {\
     RBASIC(obj)->flags &= ~RUBY_ENCODING_MASK;\
     RBASIC(obj)->flags |= (VALUE)(i) << RUBY_ENCODING_SHIFT;\
 } while (0)
-#endif
 #define RB_ENCODING_SET(obj,i) rb_enc_set_index((obj), (i))
 
-#ifdef TRUFFLERUBY
-#define RB_ENCODING_GET_INLINED(obj) RB_ENCODING_GET(obj)
-#define RB_ENCODING_GET(obj) rb_enc_get_index(obj)
-#else
 #define RB_ENCODING_GET_INLINED(obj) \
     (int)((RBASIC(obj)->flags & RUBY_ENCODING_MASK)>>RUBY_ENCODING_SHIFT)
 #define RB_ENCODING_GET(obj) \
     (RB_ENCODING_GET_INLINED(obj) != RUBY_ENCODING_INLINE_MAX ? \
      RB_ENCODING_GET_INLINED(obj) : \
      rb_enc_get_index(obj))
-#endif
 
 #define RB_ENCODING_IS_ASCII8BIT(obj) (RB_ENCODING_GET_INLINED(obj) == 0)
 
@@ -63,18 +54,12 @@ enum ruby_encoding_consts {
 
 enum ruby_coderange_type {
     RUBY_ENC_CODERANGE_UNKNOWN	= 0,
-#ifdef TRUFFLERUBY
-    RUBY_ENC_CODERANGE_7BIT     = 1,
-    RUBY_ENC_CODERANGE_VALID    = 2,
-    RUBY_ENC_CODERANGE_BROKEN   = 4
-#else
     RUBY_ENC_CODERANGE_7BIT	= ((int)RUBY_FL_USER8),
     RUBY_ENC_CODERANGE_VALID	= ((int)RUBY_FL_USER9),
     RUBY_ENC_CODERANGE_BROKEN	= ((int)(RUBY_FL_USER8|RUBY_FL_USER9)),
     RUBY_ENC_CODERANGE_MASK	= (RUBY_ENC_CODERANGE_7BIT|
 				   RUBY_ENC_CODERANGE_VALID|
 				   RUBY_ENC_CODERANGE_BROKEN)
-#endif
 };
 
 static inline int
@@ -83,23 +68,12 @@ rb_enc_coderange_clean_p(int cr)
     return (cr ^ (cr >> 1)) & RUBY_ENC_CODERANGE_7BIT;
 }
 #define RB_ENC_CODERANGE_CLEAN_P(cr) rb_enc_coderange_clean_p(cr)
-#ifdef TRUFFLERUBY
-enum ruby_coderange_type RB_ENC_CODERANGE(VALUE obj);
-#else
 #define RB_ENC_CODERANGE(obj) ((int)RBASIC(obj)->flags & RUBY_ENC_CODERANGE_MASK)
-#endif
 #define RB_ENC_CODERANGE_ASCIIONLY(obj) (RB_ENC_CODERANGE(obj) == RUBY_ENC_CODERANGE_7BIT)
-
-#ifdef TRUFFLERUBY
-void RB_ENC_CODERANGE_SET(VALUE obj, int cr);
-void rb_enc_coderange_clear(VALUE);
-#define RB_ENC_CODERANGE_CLEAR(obj) rb_enc_coderange_clear(obj)
-#else
 #define RB_ENC_CODERANGE_SET(obj,cr) (\
 	RBASIC(obj)->flags = \
 	(RBASIC(obj)->flags & ~RUBY_ENC_CODERANGE_MASK) | (cr))
 #define RB_ENC_CODERANGE_CLEAR(obj) RB_ENC_CODERANGE_SET((obj),0)
-#endif
 
 /* assumed ASCII compatibility */
 #define RB_ENC_CODERANGE_AND(a, b) \
@@ -164,9 +138,6 @@ 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_with_enc(VALUE string, rb_encoding *eenc);
-rb_encoding *get_encoding(VALUE string);
-#define STR_ENC_GET(string) get_encoding(string)
 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);
@@ -197,13 +168,8 @@ rb_encoding *rb_enc_find(const char *name);
 #define rb_enc_name(enc) (enc)->name
 
 /* rb_encoding * -> minlen/maxlen */
-#ifdef TRUFFLERUBY
-int rb_enc_mbminlen(rb_encoding *enc);
-int rb_enc_mbmaxlen(rb_encoding *enc);
-#else
 #define rb_enc_mbminlen(enc) (enc)->min_enc_len
 #define rb_enc_mbmaxlen(enc) (enc)->max_enc_len
-#endif
 
 /* -> mbclen (no error notification: 0 < ret <= e-p, no exception) */
 int rb_enc_mbclen(const char *p, const char *e, rb_encoding *enc);
@@ -230,12 +196,7 @@ unsigned int rb_enc_codepoint_len(const char *p, const char *e, int *len, rb_enc
 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))
-#ifdef TRUFFLERUBY
-int rb_enc_mbc_to_codepoint(char *p, char *e, rb_encoding *enc);
-#define rb_enc_mbc_to_codepoint(p, e, enc) rb_enc_mbc_to_codepoint(p, e, enc)
-#else
 #define rb_enc_mbc_to_codepoint(p, e, enc) ONIGENC_MBC_TO_CODE((enc),(UChar*)(p),(UChar*)(e))
-#endif
 
 /* -> codelen>0 or raise exception */
 int rb_enc_codelen(int code, rb_encoding *enc);
@@ -249,11 +210,7 @@ int rb_enc_code_to_mbclen(int code, rb_encoding *enc);
 /* 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 */
-#ifdef TRUFFLERUBY
-char* rb_enc_left_char_head(char *start, char *p, char *end, rb_encoding *enc);
-#else
 #define rb_enc_left_char_head(s,p,e,enc) ((char *)onigenc_get_left_adjust_char_head((enc),(UChar*)(s),(UChar*)(p),(UChar*)(e)))
-#endif
 #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)))
 
@@ -266,31 +223,17 @@ char* rb_enc_left_char_head(char *start, char *p, char *end, rb_encoding *enc);
 #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))
-#ifdef TRUFFLERUBY
-int rb_enc_isalnum(unsigned char c, rb_encoding *enc);
-#define rb_enc_isalnum(c,enc) rb_enc_isalnum(c,enc)
-#else
 #define rb_enc_isalnum(c,enc) ONIGENC_IS_CODE_ALNUM((enc),(c))
-#endif
 #define rb_enc_isprint(c,enc) ONIGENC_IS_CODE_PRINT((enc),(c))
-#ifdef TRUFFLERUBY
-int rb_enc_isspace(unsigned char c, rb_encoding *enc);
-#define rb_enc_isspace(c,enc) rb_enc_isspace(c,enc)
-#else
 #define rb_enc_isspace(c,enc) ONIGENC_IS_CODE_SPACE((enc),(c))
-#endif
 #define rb_enc_isdigit(c,enc) ONIGENC_IS_CODE_DIGIT((enc),(c))
 
-#ifdef TRUFFLERUBY
-int rb_enc_asciicompat(rb_encoding *enc);
-#else
 static inline int
 rb_enc_asciicompat_inline(rb_encoding *enc)
 {
     return rb_enc_mbminlen(enc)==1 && !rb_enc_dummy_p(enc);
 }
 #define rb_enc_asciicompat(enc) rb_enc_asciicompat_inline(enc)
-#endif
 
 int rb_enc_casefold(char *to, const char *p, const char *e, rb_encoding *enc);
 CONSTFUNC(int rb_enc_toupper(int c, rb_encoding *enc));
@@ -341,9 +284,6 @@ VALUE rb_check_symbol_cstr(const char *ptr, long len, rb_encoding *enc);
 RUBY_EXTERN VALUE rb_cEncoding;
 
 /* econv stuff */
-#ifdef TRUFFLERUBY
-struct rb_econv_t {};
-#endif
 
 typedef enum {
     econv_invalid_byte_sequence,

lib/cext/include/ruby/internal/arithmetic/fixnum.h

@@ -35,19 +35,10 @@
  * represent  is   4,611,686,018,427,387,904,  which   is  not   fixable.   The
  * seemingly-stragne "< FIXNUM_MAX + 1" expression below is due to this.
  */
-#ifdef TRUFFLERUBY
-#define RB_POSFIXABLE(f) ((f) <= RUBY_FIXNUM_MAX)
-#else
 #define RB_POSFIXABLE(_) ((_) <  RUBY_FIXNUM_MAX + 1)
-#endif
 #define RB_NEGFIXABLE(_) ((_) >= RUBY_FIXNUM_MIN)
 #define RB_FIXABLE(_)    (RB_POSFIXABLE(_) && RB_NEGFIXABLE(_))
-#ifdef TRUFFLERUBY
-#define RUBY_FIXNUM_MAX LONG_MAX
-#define RUBY_FIXNUM_MIN LONG_MIN
-#else
 #define RUBY_FIXNUM_MAX  (LONG_MAX / 2)
 #define RUBY_FIXNUM_MIN  (LONG_MIN / 2)
-#endif
 
 #endif /* RBIMPL_ARITHMETIC_FIXNUM_H */

lib/cext/include/ruby/internal/arithmetic/long.h

@@ -50,28 +50,16 @@
 #define LONG2NUM     RB_LONG2NUM
 #define NUM2LONG     RB_NUM2LONG
 #define NUM2ULONG    RB_NUM2ULONG
-#ifdef TRUFFLERUBY
-#define RB_FIX2LONG(x) ((long)polyglot_as_i64(rb_tr_unwrap(x)))
-#else
 #define RB_FIX2LONG  rb_fix2long
-#endif
 #define RB_FIX2ULONG rb_fix2ulong
-#ifdef TRUFFLERUBY
-#define RB_LONG2FIX(i) (VALUE)rb_tr_longwrap((long)(i))
-#else
 #define RB_LONG2FIX  RB_INT2FIX
-#endif
 #define RB_LONG2NUM  rb_long2num_inline
 #define RB_NUM2LONG  rb_num2long_inline
 #define RB_NUM2ULONG rb_num2ulong_inline
 #define RB_ULONG2NUM rb_ulong2num_inline
 #define ULONG2NUM    RB_ULONG2NUM
 #define rb_fix_new   RB_INT2FIX
-#ifdef TRUFFLERUBY
-#define rb_long2int  rb_long2int
-#else
 #define rb_long2int  rb_long2int_inline
-#endif
 
 /** @cond INTERNAL_MACRO */
 #define RB_INT2FIX RB_INT2FIX
@@ -85,9 +73,6 @@ void rb_out_of_int(SIGNED_VALUE num);
 
 long rb_num2long(VALUE num);
 unsigned long rb_num2ulong(VALUE num);
-#ifdef TRUFFLERUBY
-int rb_long2int(long value);
-#endif
 RBIMPL_SYMBOL_EXPORT_END()
 
 RBIMPL_ATTR_CONST_UNLESS_DEBUG()
@@ -110,7 +95,6 @@ RB_INT2FIX(long i)
     return n;
 }
 
-#ifndef TRUFFLERUBY
 static inline int
 rb_long2int_inline(long n)
 {
@@ -125,7 +109,6 @@ rb_long2int_inline(long n)
 
     return i;
 }
-#endif
 
 RBIMPL_ATTR_CONST_UNLESS_DEBUG()
 RBIMPL_ATTR_CONSTEXPR_UNLESS_DEBUG(CXX14)
@@ -171,22 +154,16 @@ rbimpl_right_shift_is_arithmetic_p(void)
 }
 
 RBIMPL_ATTR_CONST_UNLESS_DEBUG()
-#ifndef TRUFFLERUBY
 RBIMPL_ATTR_CONSTEXPR_UNLESS_DEBUG(CXX14)
-#endif
 static inline long
 rb_fix2long(VALUE x)
 {
-#ifdef TRUFFLERUBY
-    return ((long)polyglot_as_i64(rb_tr_unwrap(x)));
-#else
     if /* constexpr */ (rbimpl_right_shift_is_arithmetic_p()) {
         return rbimpl_fix2long_by_shift(x);
     }
     else {
         return rbimpl_fix2long_by_idiv(x);
     }
-#endif
 }
 
 RBIMPL_ATTR_CONST_UNLESS_DEBUG()
@@ -236,11 +213,7 @@ rb_ulong2num_inline(unsigned long v)
     if (RB_POSFIXABLE(v))
         return RB_LONG2FIX(v);
     else
-#ifdef TRUFFLERUBY
-        return rb_tr_wrap(polyglot_invoke(RUBY_CEXT, "rb_ulong2num", (long) v));
-#else
         return rb_uint2big(v);
-#endif
 }
 
 /**

lib/cext/include/ruby/internal/attr/const.h

@@ -23,7 +23,6 @@
 #include "ruby/internal/compiler_since.h"
 #include "ruby/internal/has/attribute.h"
 #include "ruby/internal/has/declspec_attribute.h"
-#include "ruby/assert.h"
 
 /** Wraps (or simulates) `__attribute__((const))` */
 #if RBIMPL_HAS_ATTRIBUTE(const)

lib/cext/include/ruby/internal/config.h

@@ -20,8 +20,6 @@
  *             extension libraries. They could be written in C++98.
  * @brief      Thin wrapper to ruby/config.h
  */
-// Must be first, as it defines feature test macros like _GNU_SOURCE,
-// which influences the definitions exposed by system header files.
 #include "ruby/config.h"
 
 #ifdef RUBY_EXTCONF_H
@@ -143,7 +141,4 @@
 # undef RBIMPL_TEST3
 #endif /* HAVE_VA_ARGS_MACRO */
 
-// Loaded at the end of config.h, included from defines.h. Needs STRINGIZE().
-#include <truffleruby/truffleruby-pre.h>
-
 #endif /* RBIMPL_CONFIG_H */