error: no matching function for call to 'rb_rescue2' on M1 Mac and v0.6.0 #223
Comments
|
What version of ruby are you running? `ruby --version` ?
…On Wed, Jan 5, 2022 at 2:47 AM Charlie Moad ***@***.***> wrote:
I receive the following error when trying to upgrade mini_racer on an M1 Mac running macOS 12 (Monterey).
mini_racer_extension.cc:1278:14: error: no matching function for call to 'rb_rescue2'
result = rb_rescue2(protected_callback, callback_data_value,
^~~~~~~~~~
gem_make.out.log
—
Reply to this email directly, view it on GitHub, or unsubscribe.
Triage notifications on the go with GitHub Mobile for iOS or Android.
You are receiving this because you are subscribed to this thread.Message ID: ***@***.***>
|
2.6.3 |
|
I see, 2.6.3 is missing some backported functions (and a bunch of critical security fixes) can you upgrade to 2.6.9? |
|
@SamSaffron I do get the same with Ruby 2.6.9 on Full output of installation |
|
This is very confusing cause that function exists on 2.6.9, this dockerfile works right I wonder if this is something about the toolchain here, some llvm quirk? How is Ruby installed, is this via chruby / rbenv / system? |
|
Also seeing the same error with Ruby 2.6.9: Ruby is being managed by asdf. I compared the ruby.h included in the 2.6.9 install with https://github.com/ruby/ruby/blob/v2_6_9/include/ruby/ruby.h and they match exactly. That file hasn't been touched in 3 years according as of the 2.6.9 release. |
|
This does feel like something that may be related to the llvm compilations. If you asdf install 2.7 or 3.0 or 3.1 does it work? If so can you do a quick diff of the signature in ruby.h on rb_resecue2? |
|
Indeed it compiled on the most recent 2.7. (2.7.5). Upgrading to 2.7 should resolve this issue for me, but changes the stated supported versions of Ruby for this project. Also, I'm now encountering #227 in our CI/CD, GitHub Actions. Full diff between 2.6.9 and 2.7.5 of ruby.h5c5
< $Author: naruse $
---
> $Author$
29a30
> #include "ruby/assert.h"
514a516
> RUBY_T_MOVED = 0x1e,
544a547
> #define T_MOVED RUBY_T_MOVED
604,607c607
< #define SafeStringValue(v) do {\
< StringValue(v);\
< rb_check_safe_obj(v);\
< } while (0)
---
> #define SafeStringValue(v) StringValue(v)
609c609
< void rb_check_safe_str(VALUE) __attribute__((error("rb_check_safe_str() and Check_SafeStr() are obsolete; use SafeStringValue() instead")));
---
> void rb_check_safe_str(VALUE) __attribute__((error("rb_check_safe_str() and Check_SafeStr() are obsolete; use StringValue() instead")));
612,613c612,613
< # define rb_check_safe_str(x) [<"rb_check_safe_str() is obsolete; use SafeStringValue() instead">]
< # define Check_SafeStr(v) [<"Check_SafeStr() is obsolete; use SafeStringValue() instead">]
---
> # define rb_check_safe_str(x) [<"rb_check_safe_str() is obsolete; use StringValue() instead">]
> # define Check_SafeStr(v) [<"Check_SafeStr() is obsolete; use StringValue() instead">]
618c618
< SafeStringValue(v);\
---
> StringValue(v);\
627c627
< #define FilePathStringValue(v) ((v) = rb_get_path_no_checksafe(v))
---
> #define FilePathStringValue(v) ((v) = rb_get_path(v))
628a629
> /* Remove in 3.0 */
847a849
> RUBY_FL_SEEN_OBJ_ID = (1<<9),
905a908,912
> #define RVALUE_EMBED_LEN_MAX RVALUE_EMBED_LEN_MAX
> enum ruby_rvalue_flags {
> RVALUE_EMBED_LEN_MAX = 3,
> };
>
909c916
< ROBJECT_EMBED_LEN_MAX = 3,
---
> ROBJECT_EMBED_LEN_MAX = RVALUE_EMBED_LEN_MAX,
975c982
< RSTRING_EMBED_LEN_MAX = (int)((sizeof(VALUE)*3)/sizeof(char)-1),
---
> RSTRING_EMBED_LEN_MAX = (int)((sizeof(VALUE)*RVALUE_EMBED_LEN_MAX)/sizeof(char)-1),
1021c1028
< RARRAY_EMBED_LEN_MAX = 3,
---
> RARRAY_EMBED_LEN_MAX = RVALUE_EMBED_LEN_MAX,
1048c1055,1060
< VALUE shared;
---
> #if defined(__clang__) /* <- clang++ is sane */ || \
> !defined(__cplusplus) /* <- C99 is sane */ || \
> (__cplusplus > 199711L) /* <- C++11 is sane */
> const
> #endif
> VALUE shared_root;
1142c1154,1155
< void *reserved[2]; /* For future extension.
---
> void (*dcompact)(void*);
> void *reserved[1]; /* For future extension.
1208c1221
< #define Data_Make_Struct(klass,type,mark,free,sval) RB_GNUC_EXTENSION_BLOCK(\
---
> #define Data_Make_Struct(klass,type,mark,free,sval) ({\
1210,1211c1223,1224
< data_struct_obj \
< )
---
> data_struct_obj; \
> })
1226c1239
< #define TypedData_Make_Struct(klass, type, data_type, sval) RB_GNUC_EXTENSION_BLOCK(\
---
> #define TypedData_Make_Struct(klass, type, data_type, sval) ({\
1228,1229c1241,1242
< data_struct_obj \
< )
---
> data_struct_obj; \
> })
1252a1266
> #define RMOVED(obj) (R_CAST(RMoved)(obj))
1270a1285
> #define FL_SEEN_OBJ_ID ((VALUE)RUBY_FL_SEEN_OBJ_ID)
1295c1310
< #define FL_USER19 ((VALUE)RUBY_FL_USER19)
---
> #define FL_USER19 ((VALUE)(unsigned int)RUBY_FL_USER19)
1740a1756,1764
> #ifdef __GLIBC__
> static inline void *
> ruby_nonempty_memcpy(void *dest, const void *src, size_t n)
> {
> /* if nothing to be copied, src may be NULL */
> return (n ? memcpy(dest, src, n) : dest);
> }
> #define memcpy(p1,p2,n) ruby_nonempty_memcpy(p1, p2, n)
> #endif
1758,1761c1782,1783
< struct rb_global_variable;
<
< typedef VALUE rb_gvar_getter_t(ID id, void *data, struct rb_global_variable *gvar);
< typedef void rb_gvar_setter_t(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
---
> typedef VALUE rb_gvar_getter_t(ID id, VALUE *data);
> typedef void rb_gvar_setter_t(VALUE val, ID id, VALUE *data);
1764,1774c1786,1796
< VALUE rb_gvar_undef_getter(ID id, void *data, struct rb_global_variable *gvar);
< void rb_gvar_undef_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
< void rb_gvar_undef_marker(VALUE *var);
<
< VALUE rb_gvar_val_getter(ID id, void *data, struct rb_global_variable *gvar);
< void rb_gvar_val_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
< void rb_gvar_val_marker(VALUE *var);
<
< VALUE rb_gvar_var_getter(ID id, void *data, struct rb_global_variable *gvar);
< void rb_gvar_var_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar);
< void rb_gvar_var_marker(VALUE *var);
---
> rb_gvar_getter_t rb_gvar_undef_getter;
> rb_gvar_setter_t rb_gvar_undef_setter;
> rb_gvar_marker_t rb_gvar_undef_marker;
>
> rb_gvar_getter_t rb_gvar_val_getter;
> rb_gvar_setter_t rb_gvar_val_setter;
> rb_gvar_marker_t rb_gvar_val_marker;
>
> rb_gvar_getter_t rb_gvar_var_getter;
> rb_gvar_setter_t rb_gvar_var_setter;
> rb_gvar_marker_t rb_gvar_var_marker;
1776c1798
< NORETURN(void rb_gvar_readonly_setter(VALUE val, ID id, void *data, struct rb_global_variable *gvar));
---
> NORETURN(rb_gvar_setter_t rb_gvar_readonly_setter);
1779,1780c1801,1802
< void rb_define_virtual_variable(const char*,VALUE(*)(ANYARGS),void(*)(ANYARGS));
< void rb_define_hooked_variable(const char*,VALUE*,VALUE(*)(ANYARGS),void(*)(ANYARGS));
---
> void rb_define_virtual_variable(const char*,rb_gvar_getter_t*,rb_gvar_setter_t*);
> void rb_define_hooked_variable(const char*,VALUE*,rb_gvar_getter_t*,rb_gvar_setter_t*);
1785d1806
< #define RUBY_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
1810,1811c1831
< #define RUBY_CONST_ID_CACHE(result, str) \
< { \
---
> #define RUBY_CONST_ID_CACHE_NB(result, str) \
1815c1835,1838
< result rb_intern_id_cache; \
---
> result rb_intern_id_cache;
> #define RUBY_CONST_ID_CACHE(result, str) \
> { \
> RUBY_CONST_ID_CACHE_NB(result, str) \
1826c1849
< __extension__ (RUBY_CONST_ID_CACHE((ID), (str))) : \
---
> __extension__ ({RUBY_CONST_ID_CACHE_NB((ID), (str))}) : \
1870a1894
> VALUE rb_funcallv_kw(VALUE, ID, int, const VALUE*, int);
1871a1896
> VALUE rb_funcallv_public_kw(VALUE, ID, int, const VALUE*, int);
1874a1900
> VALUE rb_funcall_passing_block_kw(VALUE, ID, int, const VALUE*, int);
1875a1902
> VALUE rb_funcall_with_block_kw(VALUE, ID, int, const VALUE*, VALUE, int);
1876a1904,1908
> #define RB_SCAN_ARGS_PASS_CALLED_KEYWORDS 0
> #define RB_SCAN_ARGS_KEYWORDS 1
> #define RB_SCAN_ARGS_EMPTY_KEYWORDS 2 /* Will be removed in 3.0 */
> #define RB_SCAN_ARGS_LAST_HASH_KEYWORDS 3
> int rb_scan_args_kw(int, int, const VALUE*, const char*, ...);
1877a1910
> VALUE rb_call_super_kw(int, const VALUE*, int);
1930a1964
> #define RB_BLOCK_CALL_FUNC_STRICT 1
1935,1936d1968
<
< #if defined RB_BLOCK_CALL_FUNC_STRICT && RB_BLOCK_CALL_FUNC_STRICT
1938,1940d1969
< #else
< typedef VALUE (*rb_block_call_func_t)(ANYARGS);
< #endif
1945a1975
> VALUE rb_yield_values_kw(int n, const VALUE *argv, int kw_splat);
1947c1977,1983
< VALUE rb_yield_block(VALUE, VALUE, int, const VALUE *, VALUE); /* rb_block_call_func */
---
> VALUE rb_yield_splat_kw(VALUE, int);
> VALUE rb_yield_block(RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg)); /* rb_block_call_func */
> #define RB_NO_KEYWORDS 0
> #define RB_PASS_KEYWORDS 1
> #define RB_PASS_EMPTY_KEYWORDS 2 /* Will be removed in 3.0 */
> #define RB_PASS_CALLED_KEYWORDS 3
> int rb_keyword_given_p(void);
1950c1986
< VALUE rb_iterate(VALUE(*)(VALUE),VALUE,VALUE(*)(ANYARGS),VALUE);
---
> VALUE rb_iterate(VALUE(*)(VALUE),VALUE,rb_block_call_func_t,VALUE);
1952,1956c1988,1994
< VALUE rb_rescue(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE);
< VALUE rb_rescue2(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE,...);
< VALUE rb_ensure(VALUE(*)(ANYARGS),VALUE,VALUE(*)(ANYARGS),VALUE);
< VALUE rb_catch(const char*,VALUE(*)(ANYARGS),VALUE);
< VALUE rb_catch_obj(VALUE,VALUE(*)(ANYARGS),VALUE);
---
> VALUE rb_block_call_kw(VALUE,ID,int,const VALUE*,rb_block_call_func_t,VALUE,int);
> VALUE rb_rescue(VALUE(*)(VALUE),VALUE,VALUE(*)(VALUE,VALUE),VALUE);
> VALUE rb_rescue2(VALUE(*)(VALUE),VALUE,VALUE(*)(VALUE,VALUE),VALUE,...);
> VALUE rb_vrescue2(VALUE(*)(VALUE),VALUE,VALUE(*)(VALUE,VALUE),VALUE,va_list);
> VALUE rb_ensure(VALUE(*)(VALUE),VALUE,VALUE(*)(VALUE),VALUE);
> VALUE rb_catch(const char*,rb_block_call_func_t,VALUE);
> VALUE rb_catch_obj(VALUE,rb_block_call_func_t,VALUE);
2044a2083
> RUBY_EXTERN VALUE rb_eNoMatchingPatternError;
2179a2219
> (void)allow_transient;
2189a2230
> (void)allow_transient;
2274a2316,2318
> #define ISBLANK(c) rb_isblank(c)
> #define ISCNTRL(c) rb_iscntrl(c)
> #define ISPUNCT(c) rb_ispunct(c)
2291a2336,2338
> /* -- Remove In 3.0, Only public for rb_scan_args optimized version -- */
> int rb_empty_keyword_given_p(void);
>
2298c2345
< rb_scan_args(argc,argvp,fmt,__VA_ARGS__))
---
> rb_scan_args(argc,argvp,fmt,##__VA_ARGS__))
2300,2301c2347,2348
< ERRORFUNC(("bad scan arg format"), int rb_scan_args_bad_format(const char*));
< ERRORFUNC(("variable argument length doesn't match"), int rb_scan_args_length_mismatch(const char*,int));
---
> ERRORFUNC(("bad scan arg format"), void rb_scan_args_bad_format(const char*));
> ERRORFUNC(("variable argument length doesn't match"), void rb_scan_args_length_mismatch(const char*,int));
2303,2304c2350,2351
< # define rb_scan_args_bad_format(fmt) 0
< # define rb_scan_args_length_mismatch(fmt, varc) 0
---
> # define rb_scan_args_bad_format(fmt) ((void)0)
> # define rb_scan_args_length_mismatch(fmt, varc) ((void)0)
2309,2318c2356,2357
< #if !defined(__has_attribute)
< #define __has_attribute(x) 0
< #endif
< # if __has_attribute(diagnose_if)
< # define rb_scan_args_count_end(fmt, ofs, varc, vari) \
< (fmt[ofs] ? rb_scan_args_bad_format(fmt) : (vari))
< # else
< # define rb_scan_args_count_end(fmt, ofs, varc, vari) \
< ((vari)/(!fmt[ofs] || rb_scan_args_bad_format(fmt)))
< # endif
---
> # define rb_scan_args_count_end(fmt, ofs, vari) \
> (fmt[ofs] ? -1 : (vari))
2320c2359
< # define rb_scan_args_count_block(fmt, ofs, varc, vari) \
---
> # define rb_scan_args_count_block(fmt, ofs, vari) \
2322,2323c2361,2362
< rb_scan_args_count_end(fmt, ofs, varc, vari) : \
< rb_scan_args_count_end(fmt, ofs+1, varc, vari+1))
---
> rb_scan_args_count_end(fmt, ofs, vari) : \
> rb_scan_args_count_end(fmt, ofs+1, vari+1))
2325c2364
< # define rb_scan_args_count_hash(fmt, ofs, varc, vari) \
---
> # define rb_scan_args_count_hash(fmt, ofs, vari) \
2327,2328c2366,2367
< rb_scan_args_count_block(fmt, ofs, varc, vari) : \
< rb_scan_args_count_block(fmt, ofs+1, varc, vari+1))
---
> rb_scan_args_count_block(fmt, ofs, vari) : \
> rb_scan_args_count_block(fmt, ofs+1, vari+1))
2330c2369
< # define rb_scan_args_count_trail(fmt, ofs, varc, vari) \
---
> # define rb_scan_args_count_trail(fmt, ofs, vari) \
2332,2333c2371,2372
< rb_scan_args_count_hash(fmt, ofs, varc, vari) : \
< rb_scan_args_count_hash(fmt, ofs+1, varc, vari+(fmt[ofs]-'0')))
---
> rb_scan_args_count_hash(fmt, ofs, vari) : \
> rb_scan_args_count_hash(fmt, ofs+1, vari+(fmt[ofs]-'0')))
2335c2374
< # define rb_scan_args_count_var(fmt, ofs, varc, vari) \
---
> # define rb_scan_args_count_var(fmt, ofs, vari) \
2337,2338c2376,2382
< rb_scan_args_count_trail(fmt, ofs, varc, vari) : \
< rb_scan_args_count_trail(fmt, ofs+1, varc, vari+1))
---
> rb_scan_args_count_trail(fmt, ofs, vari) : \
> rb_scan_args_count_trail(fmt, ofs+1, vari+1))
>
> # define rb_scan_args_count_opt(fmt, ofs, vari) \
> (!rb_scan_args_isdigit(fmt[ofs]) ? \
> rb_scan_args_count_var(fmt, ofs, vari) : \
> rb_scan_args_count_var(fmt, ofs+1, vari+fmt[ofs]-'0'))
2340,2352c2384,2389
< # define rb_scan_args_count_opt(fmt, ofs, varc, vari) \
< (!rb_scan_args_isdigit(fmt[1]) ? \
< rb_scan_args_count_var(fmt, ofs, varc, vari) : \
< rb_scan_args_count_var(fmt, ofs+1, varc, vari+fmt[ofs]-'0'))
<
< # define rb_scan_args_count(fmt, varc) \
< (!rb_scan_args_isdigit(fmt[0]) ? \
< rb_scan_args_count_var(fmt, 0, varc, 0) : \
< rb_scan_args_count_opt(fmt, 1, varc, fmt[0]-'0'))
<
< # define rb_scan_args_verify_count(fmt, varc) \
< ((varc)/(rb_scan_args_count(fmt, varc) == (varc) || \
< rb_scan_args_length_mismatch(fmt, varc)))
---
> # define rb_scan_args_count_lead(fmt, ofs, vari) \
> (!rb_scan_args_isdigit(fmt[ofs]) ? \
> rb_scan_args_count_var(fmt, ofs, vari) : \
> rb_scan_args_count_opt(fmt, ofs+1, vari+fmt[ofs]-'0'))
>
> # define rb_scan_args_count(fmt) rb_scan_args_count_lead(fmt, 0, 0)
2356,2365d2392
< # elif defined(__GNUC__)
< # define rb_scan_args_verify(fmt, varc) \
< (void)__extension__ ({ \
< int verify; \
< _Pragma("GCC diagnostic push"); \
< _Pragma("GCC diagnostic ignored \"-Warray-bounds\""); \
< verify = rb_scan_args_verify_count(fmt, varc); \
< _Pragma("GCC diagnostic pop"); \
< verify; \
< })
2368c2395,2399
< (void)rb_scan_args_verify_count(fmt, varc)
---
> (sizeof(char[1-2*(rb_scan_args_count(fmt)<0)])!=1 ? \
> rb_scan_args_bad_format(fmt) : \
> sizeof(char[1-2*(rb_scan_args_count(fmt)!=(varc))])!=1 ? \
> rb_scan_args_length_mismatch(fmt, varc) : \
> (void)0)
2492,2493c2523,2524
< __attribute__((diagnose_if(rb_scan_args_count(fmt,varc)==0,"bad scan arg format","error")))
< __attribute__((diagnose_if(rb_scan_args_count(fmt,varc)!=varc,"variable argument length doesn't match","error")))
---
> __attribute__((diagnose_if(rb_scan_args_count(fmt)<0,"bad scan arg format","error")))
> __attribute__((diagnose_if(rb_scan_args_count(fmt)!=varc,"variable argument length doesn't match","error")))
2498a2530,2532
> int keyword_given = rb_keyword_given_p();
> int empty_keyword_given = 0;
> VALUE tmp_buffer = 0;
2500,2502c2534,2536
< /* capture an option hash - phase 1: pop */
< if (f_hash && n_mand < argc) {
< VALUE last = argv[argc - 1];
---
> if (!keyword_given) {
> empty_keyword_given = rb_empty_keyword_given_p();
> }
2504,2519c2538,2598
< if (RB_NIL_P(last)) {
< /* nil is taken as an empty option hash only if it is not
< ambiguous; i.e. '*' is not specified and arguments are
< given more than sufficient */
< if (!f_var && n_mand + n_opt < argc)
< argc--;
< }
< else {
< hash = rb_check_hash_type(last);
< if (!RB_NIL_P(hash)) {
< VALUE opts = rb_extract_keywords(&hash);
< if (!(last_hash = hash)) argc--;
< else last_idx = argc - 1;
< hash = opts ? opts : Qnil;
< }
< }
---
> /* capture an option hash - phase 1: pop */
> /* Ignore final positional hash if empty keywords given */
> if (argc > 0 && !(f_hash && empty_keyword_given)) {
> VALUE last = argv[argc - 1];
>
> if (f_hash && n_mand < argc) {
> if (keyword_given) {
> if (!RB_TYPE_P(last, T_HASH)) {
> rb_warn("Keyword flag set when calling rb_scan_args, but last entry is not a hash");
> }
> else {
> hash = last;
> }
> }
> else if (NIL_P(last)) {
> /* For backwards compatibility, nil is taken as an empty
> option hash only if it is not ambiguous; i.e. '*' is
> not specified and arguments are given more than sufficient.
> This will be removed in Ruby 3. */
> if (!f_var && n_mand + n_opt < argc) {
> rb_warn("The last argument is nil, treating as empty keywords");
> argc--;
> }
> }
> else {
> hash = rb_check_hash_type(last);
> }
>
> /* Ruby 3: Remove if branch, as it will not attempt to split hashes */
> if (!NIL_P(hash)) {
> VALUE opts = rb_extract_keywords(&hash);
>
> if (!(last_hash = hash)) {
> if (!keyword_given) {
> /* Warn if treating positional as keyword, as in Ruby 3,
> this will be an error */
> rb_warn("Using the last argument as keyword parameters is deprecated");
> }
> argc--;
> }
> else {
> /* Warn if splitting either positional hash to keywords or keywords
> to positional hash, as in Ruby 3, no splitting will be done */
> rb_warn("The last argument is split into positional and keyword parameters");
> last_idx = argc - 1;
> }
> hash = opts ? opts : Qnil;
> }
> }
> else if (f_hash && keyword_given && n_mand == argc) {
> /* Warn if treating keywords as positional, as in Ruby 3, this will be an error */
> rb_warn("Passing the keyword argument as the last hash parameter is deprecated");
> }
> }
> if (f_hash && n_mand > 0 && n_mand == argc+1 && empty_keyword_given) {
> VALUE *ptr = (VALUE *)rb_alloc_tmp_buffer2(&tmp_buffer, argc+1, sizeof(VALUE));
> memcpy(ptr, argv, sizeof(VALUE)*argc);
> ptr[argc] = rb_hash_new();
> argc++;
> *(&argv) = ptr;
> rb_warn("Passing the keyword argument as the last hash parameter is deprecated");
2522c2601,2604
< rb_check_arity(argc, n_mand, f_var ? UNLIMITED_ARGUMENTS : n_mand + n_opt);
---
>
> if (argc < n_mand) {
> goto argc_error;
> }
2579a2662,2668
> if (argi < argc) {
> argc_error:
> if (tmp_buffer) rb_free_tmp_buffer(&tmp_buffer);
> rb_error_arity(argc, n_mand, f_var ? UNLIMITED_ARGUMENTS : n_mand + n_opt);
> }
>
> if (tmp_buffer) rb_free_tmp_buffer(&tmp_buffer);
2602c2691
< rb_funcallv(recv, mid, \
---
> rb_funcallv(recv, mid, \
2646,2649d2734
< #ifdef __ia64
< void ruby_init_stack(volatile VALUE*, void*);
< #define ruby_init_stack(addr) ruby_init_stack((addr), rb_ia64_bsp())
< #else
2651,2652d2735
< #endif
< #define Init_stack(addr) ruby_init_stack(addr)
2688a2772
> extern "C++" {
2689a2774,2872
>
> #ifdef RB_METHOD_DEFINITION_DECL
>
> RB_METHOD_DEFINITION_DECL(rb_define_method, (2,3), (VALUE klass, const char *name), (klass, name))
> #ifdef __cplusplus
> #define rb_define_method(m, n, f, a) rb_define_method_tmpl<a>::define(m, n, f)
> #else
> #define rb_define_method_if_constexpr(x, t, f) __builtin_choose_expr(__builtin_choose_expr(__builtin_constant_p(x),(x),0),(t),(f))
> #define rb_define_method_choose_prototype15(n) rb_define_method_if_constexpr((n)==15,rb_define_method15,rb_define_methodm3)
> #define rb_define_method_choose_prototype14(n) rb_define_method_if_constexpr((n)==14,rb_define_method14,rb_define_method_choose_prototype15(n))
> #define rb_define_method_choose_prototype13(n) rb_define_method_if_constexpr((n)==13,rb_define_method13,rb_define_method_choose_prototype14(n))
> #define rb_define_method_choose_prototype12(n) rb_define_method_if_constexpr((n)==12,rb_define_method12,rb_define_method_choose_prototype13(n))
> #define rb_define_method_choose_prototype11(n) rb_define_method_if_constexpr((n)==11,rb_define_method11,rb_define_method_choose_prototype12(n))
> #define rb_define_method_choose_prototype10(n) rb_define_method_if_constexpr((n)==10,rb_define_method10,rb_define_method_choose_prototype11(n))
> #define rb_define_method_choose_prototype9(n) rb_define_method_if_constexpr((n)== 9,rb_define_method9, rb_define_method_choose_prototype10(n))
> #define rb_define_method_choose_prototype8(n) rb_define_method_if_constexpr((n)== 8,rb_define_method8, rb_define_method_choose_prototype9(n))
> #define rb_define_method_choose_prototype7(n) rb_define_method_if_constexpr((n)== 7,rb_define_method7, rb_define_method_choose_prototype8(n))
> #define rb_define_method_choose_prototype6(n) rb_define_method_if_constexpr((n)== 6,rb_define_method6, rb_define_method_choose_prototype7(n))
> #define rb_define_method_choose_prototype5(n) rb_define_method_if_constexpr((n)== 5,rb_define_method5, rb_define_method_choose_prototype6(n))
> #define rb_define_method_choose_prototype4(n) rb_define_method_if_constexpr((n)== 4,rb_define_method4, rb_define_method_choose_prototype5(n))
> #define rb_define_method_choose_prototype3(n) rb_define_method_if_constexpr((n)== 3,rb_define_method3, rb_define_method_choose_prototype4(n))
> #define rb_define_method_choose_prototype2(n) rb_define_method_if_constexpr((n)== 2,rb_define_method2, rb_define_method_choose_prototype3(n))
> #define rb_define_method_choose_prototype1(n) rb_define_method_if_constexpr((n)== 1,rb_define_method1, rb_define_method_choose_prototype2(n))
> #define rb_define_method_choose_prototype0(n) rb_define_method_if_constexpr((n)== 0,rb_define_method0, rb_define_method_choose_prototype1(n))
> #define rb_define_method_choose_prototypem1(n) rb_define_method_if_constexpr((n)==-1,rb_define_methodm1,rb_define_method_choose_prototype0(n))
> #define rb_define_method_choose_prototypem2(n) rb_define_method_if_constexpr((n)==-2,rb_define_methodm2,rb_define_method_choose_prototypem1(n))
> #define rb_define_method_choose_prototypem3(n, f) rb_define_method_if_constexpr(rb_f_notimplement_p(f),rb_define_methodm3,rb_define_method_choose_prototypem2(n))
> #define rb_define_method(klass, mid, func, arity) rb_define_method_choose_prototypem3((arity),(func))((klass),(mid),(func),(arity));
> #endif
>
> RB_METHOD_DEFINITION_DECL(rb_define_module_function, (2,3), (VALUE klass, const char *name), (klass, name))
> #ifdef __cplusplus
> #define rb_define_module_function(m, n, f, a) rb_define_module_function_tmpl<a>::define(m, n, f)
> #else
> #define rb_define_module_function_choose_prototype15(n) rb_define_method_if_constexpr((n)==15,rb_define_module_function15,rb_define_module_functionm3)
> #define rb_define_module_function_choose_prototype14(n) rb_define_method_if_constexpr((n)==14,rb_define_module_function14,rb_define_module_function_choose_prototype15(n))
> #define rb_define_module_function_choose_prototype13(n) rb_define_method_if_constexpr((n)==13,rb_define_module_function13,rb_define_module_function_choose_prototype14(n))
> #define rb_define_module_function_choose_prototype12(n) rb_define_method_if_constexpr((n)==12,rb_define_module_function12,rb_define_module_function_choose_prototype13(n))
> #define rb_define_module_function_choose_prototype11(n) rb_define_method_if_constexpr((n)==11,rb_define_module_function11,rb_define_module_function_choose_prototype12(n))
> #define rb_define_module_function_choose_prototype10(n) rb_define_method_if_constexpr((n)==10,rb_define_module_function10,rb_define_module_function_choose_prototype11(n))
> #define rb_define_module_function_choose_prototype9(n) rb_define_method_if_constexpr((n)== 9,rb_define_module_function9, rb_define_module_function_choose_prototype10(n))
> #define rb_define_module_function_choose_prototype8(n) rb_define_method_if_constexpr((n)== 8,rb_define_module_function8, rb_define_module_function_choose_prototype9(n))
> #define rb_define_module_function_choose_prototype7(n) rb_define_method_if_constexpr((n)== 7,rb_define_module_function7, rb_define_module_function_choose_prototype8(n))
> #define rb_define_module_function_choose_prototype6(n) rb_define_method_if_constexpr((n)== 6,rb_define_module_function6, rb_define_module_function_choose_prototype7(n))
> #define rb_define_module_function_choose_prototype5(n) rb_define_method_if_constexpr((n)== 5,rb_define_module_function5, rb_define_module_function_choose_prototype6(n))
> #define rb_define_module_function_choose_prototype4(n) rb_define_method_if_constexpr((n)== 4,rb_define_module_function4, rb_define_module_function_choose_prototype5(n))
> #define rb_define_module_function_choose_prototype3(n) rb_define_method_if_constexpr((n)== 3,rb_define_module_function3, rb_define_module_function_choose_prototype4(n))
> #define rb_define_module_function_choose_prototype2(n) rb_define_method_if_constexpr((n)== 2,rb_define_module_function2, rb_define_module_function_choose_prototype3(n))
> #define rb_define_module_function_choose_prototype1(n) rb_define_method_if_constexpr((n)== 1,rb_define_module_function1, rb_define_module_function_choose_prototype2(n))
> #define rb_define_module_function_choose_prototype0(n) rb_define_method_if_constexpr((n)== 0,rb_define_module_function0, rb_define_module_function_choose_prototype1(n))
> #define rb_define_module_function_choose_prototypem1(n) rb_define_method_if_constexpr((n)==-1,rb_define_module_functionm1,rb_define_module_function_choose_prototype0(n))
> #define rb_define_module_function_choose_prototypem2(n) rb_define_method_if_constexpr((n)==-2,rb_define_module_functionm2,rb_define_module_function_choose_prototypem1(n))
> #define rb_define_module_function_choose_prototypem3(n, f) rb_define_method_if_constexpr(rb_f_notimplement_p(f),rb_define_module_functionm3,rb_define_module_function_choose_prototypem2(n))
> #define rb_define_module_function(klass, mid, func, arity) rb_define_module_function_choose_prototypem3((arity),(func))((klass),(mid),(func),(arity));
> #endif
>
> RB_METHOD_DEFINITION_DECL(rb_define_global_function, (1,2), (const char *name), (name))
> #ifdef __cplusplus
> #define rb_define_global_function(n, f, a) rb_define_global_function_tmpl<a>::define(n, f)
> #else
> #define rb_define_global_function_choose_prototype15(n) rb_define_method_if_constexpr((n)==15,rb_define_global_function15,rb_define_global_functionm3)
> #define rb_define_global_function_choose_prototype14(n) rb_define_method_if_constexpr((n)==14,rb_define_global_function14,rb_define_global_function_choose_prototype15(n))
> #define rb_define_global_function_choose_prototype13(n) rb_define_method_if_constexpr((n)==13,rb_define_global_function13,rb_define_global_function_choose_prototype14(n))
> #define rb_define_global_function_choose_prototype12(n) rb_define_method_if_constexpr((n)==12,rb_define_global_function12,rb_define_global_function_choose_prototype13(n))
> #define rb_define_global_function_choose_prototype11(n) rb_define_method_if_constexpr((n)==11,rb_define_global_function11,rb_define_global_function_choose_prototype12(n))
> #define rb_define_global_function_choose_prototype10(n) rb_define_method_if_constexpr((n)==10,rb_define_global_function10,rb_define_global_function_choose_prototype11(n))
> #define rb_define_global_function_choose_prototype9(n) rb_define_method_if_constexpr((n)== 9,rb_define_global_function9, rb_define_global_function_choose_prototype10(n))
> #define rb_define_global_function_choose_prototype8(n) rb_define_method_if_constexpr((n)== 8,rb_define_global_function8, rb_define_global_function_choose_prototype9(n))
> #define rb_define_global_function_choose_prototype7(n) rb_define_method_if_constexpr((n)== 7,rb_define_global_function7, rb_define_global_function_choose_prototype8(n))
> #define rb_define_global_function_choose_prototype6(n) rb_define_method_if_constexpr((n)== 6,rb_define_global_function6, rb_define_global_function_choose_prototype7(n))
> #define rb_define_global_function_choose_prototype5(n) rb_define_method_if_constexpr((n)== 5,rb_define_global_function5, rb_define_global_function_choose_prototype6(n))
> #define rb_define_global_function_choose_prototype4(n) rb_define_method_if_constexpr((n)== 4,rb_define_global_function4, rb_define_global_function_choose_prototype5(n))
> #define rb_define_global_function_choose_prototype3(n) rb_define_method_if_constexpr((n)== 3,rb_define_global_function3, rb_define_global_function_choose_prototype4(n))
> #define rb_define_global_function_choose_prototype2(n) rb_define_method_if_constexpr((n)== 2,rb_define_global_function2, rb_define_global_function_choose_prototype3(n))
> #define rb_define_global_function_choose_prototype1(n) rb_define_method_if_constexpr((n)== 1,rb_define_global_function1, rb_define_global_function_choose_prototype2(n))
> #define rb_define_global_function_choose_prototype0(n) rb_define_method_if_constexpr((n)== 0,rb_define_global_function0, rb_define_global_function_choose_prototype1(n))
> #define rb_define_global_function_choose_prototypem1(n) rb_define_method_if_constexpr((n)==-1,rb_define_global_functionm1,rb_define_global_function_choose_prototype0(n))
> #define rb_define_global_function_choose_prototypem2(n) rb_define_method_if_constexpr((n)==-2,rb_define_global_functionm2,rb_define_global_function_choose_prototypem1(n))
> #define rb_define_global_function_choose_prototypem3(n, f) rb_define_method_if_constexpr(rb_f_notimplement_p(f),rb_define_global_functionm3,rb_define_global_function_choose_prototypem2(n))
> #define rb_define_global_function(mid, func, arity) rb_define_global_function_choose_prototypem3((arity),(func))((mid),(func),(arity));
> #endif
>
> #endif
>
> #if defined(RUBY_DEVEL) && RUBY_DEVEL && (!defined(__cplusplus) || defined(RB_METHOD_DEFINITION_DECL))
> # define RUBY_METHOD_FUNC(func) (func)
> #else
> # define RUBY_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))(func))
> #endif
>
> #ifdef __cplusplus
> #include "backward/cxxanyargs.hpp"
>
> #if 0
> { /* satisfy cc-mode */
> #endif
> } /* extern "C++" { */
> #endif
> |
2 tasks
|
I just pushed a fix, is it working now when sourced from GitHub? |
|
Using GitHub Actions, I confirmed that mini_racer 0.6.2 is installed successfully on macos-latest + Ruby 2.6. |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
I receive the following error when trying to upgrade mini_racer on an M1 Mac running macOS 12 (Monterey).
Ruby 2.6.3
gem_make.out.log
The text was updated successfully, but these errors were encountered: