Re-apply changes on top of 3.0.3 files

Author: eregon

lib/cext/include/internal/imemo.h

@@ -137,9 +137,17 @@ 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);
@@ -189,11 +197,13 @@ 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)
@@ -202,11 +212,13 @@ 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,18 +30,27 @@ 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)
 
@@ -54,12 +63,18 @@ 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
@@ -68,12 +83,23 @@ 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) \
@@ -138,6 +164,9 @@ 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);
@@ -168,8 +197,13 @@ 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);
@@ -196,7 +230,12 @@ 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);
@@ -210,7 +249,11 @@ 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)))
 
@@ -223,17 +266,31 @@ int rb_enc_code_to_mbclen(int code, 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));
@@ -284,6 +341,9 @@ 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,10 +35,19 @@
  * 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,16 +50,28 @@
 #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
@@ -73,6 +85,9 @@ 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()
@@ -95,6 +110,7 @@ RB_INT2FIX(long i)
     return n;
 }
 
+#ifndef TRUFFLERUBY
 static inline int
 rb_long2int_inline(long n)
 {
@@ -109,6 +125,7 @@ rb_long2int_inline(long n)
 
     return i;
 }
+#endif
 
 RBIMPL_ATTR_CONST_UNLESS_DEBUG()
 RBIMPL_ATTR_CONSTEXPR_UNLESS_DEBUG(CXX14)
@@ -154,16 +171,22 @@ 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()
@@ -213,7 +236,11 @@ 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,6 +23,7 @@
 #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,6 +20,8 @@
  *             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
@@ -141,4 +143,7 @@
 # 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 */