From e42adc9429d8588951a09009c2c6f023deedb574 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Sat, 4 Oct 2025 15:49:56 -0600 Subject: [PATCH 1/6] mathoms.c: Add a few coments --- mathoms.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/mathoms.c b/mathoms.c index 7bc47bf8dea5..cfce11e6e33f 100644 --- a/mathoms.c +++ b/mathoms.c @@ -27,6 +27,9 @@ * 1) A function has been replaced by a macro within a minor release, * so XS modules compiled against an older release will expect to * still be able to link against the function + * 2) A function is deprecated, and so placing it here will cause a compiler + * warning to be generated (for participating compilers). + * 3) A few other reasons, documented with the functions below * * It used to be that this was the way to handle the case were a function * Perl_foo(...) had been replaced by a macro. But see the 'm' flag discussion From bd5d0b1019284fa61e8e8e1acb49d83863846b31 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Sat, 4 Oct 2025 12:27:05 -0600 Subject: [PATCH 2/6] Make sure miniperl compiles with -DNO_SHORT_NAMES This simple change makes the perl core compile even with this flag. --- embed.h | 4 ++-- regen/embed.pl | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/embed.h b/embed.h index 8ac7210a5d76..12fe2f88fe94 100644 --- a/embed.h +++ b/embed.h @@ -91,7 +91,7 @@ !defined(PERL_WANT_VARARGS) */ # endif /* !defined(PERL_NOCOMPAT) */ #endif /* !defined(PERL_CORE) */ -#if !defined(PERL_NO_SHORT_NAMES) +#if defined(PERL_CORE) || !defined(PERL_NO_SHORT_NAMES) /* Hide global symbols */ @@ -2488,6 +2488,6 @@ # else # define get_context Perl_get_context # endif -#endif /* !defined(PERL_NO_SHORT_NAMES) */ +#endif /* defined(PERL_CORE) || !defined(PERL_NO_SHORT_NAMES) */ /* ex: set ro ft=c: */ diff --git a/regen/embed.pl b/regen/embed.pl index 7254be71b47a..d04bbe178d8b 100755 --- a/regen/embed.pl +++ b/regen/embed.pl @@ -703,7 +703,7 @@ sub generate_embed_h { * BEWARE that a bunch of macros don't have long names, so either must be * added or don't use them if you define this symbol */ - #ifndef PERL_NO_SHORT_NAMES + #if ! defined(PERL_NO_SHORT_NAMES) || defined(PERL_CORE) /* Hide global symbols */ @@ -715,7 +715,7 @@ sub generate_embed_h { print $em <<~'END'; - #endif /* #ifndef PERL_NO_SHORT_NAMES */ + #endif /* if !defined(PERL_NO_SHORT_NAMES) || defined(PERL_CORE) */ #if !defined(PERL_CORE) /* Compatibility stubs. Compile extensions with -DPERL_NOCOMPAT to From 8c6bfa56fe52f6c1f8cb1525a56deed1f79f0d76 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Sat, 4 Oct 2025 12:32:34 -0600 Subject: [PATCH 3/6] embed.h: Clarify comment --- embed.h | 2 +- regen/embed.pl | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/embed.h b/embed.h index 12fe2f88fe94..57661cfd5352 100644 --- a/embed.h +++ b/embed.h @@ -93,7 +93,7 @@ #endif /* !defined(PERL_CORE) */ #if defined(PERL_CORE) || !defined(PERL_NO_SHORT_NAMES) -/* Hide global symbols */ +/* Create short name macros that hide any need for thread context */ # define AvFILL_(a) Perl_AvFILL_(aTHX_ a) # define Gv_AMupdate(a,b) Perl_Gv_AMupdate(aTHX_ a,b) diff --git a/regen/embed.pl b/regen/embed.pl index d04bbe178d8b..8b454a5b39f1 100755 --- a/regen/embed.pl +++ b/regen/embed.pl @@ -705,7 +705,7 @@ sub generate_embed_h { #if ! defined(PERL_NO_SHORT_NAMES) || defined(PERL_CORE) - /* Hide global symbols */ + /* Create short name macros that hide any need for thread context */ END From 43f68369259e192c51b411ef516000a09f483a24 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Sat, 4 Oct 2025 15:35:29 -0600 Subject: [PATCH 4/6] regen/embed.pl: Don't create prototype for private macros Prior to this commit, a commented-out prototype was created for all macros that we have argument and return type information for. This might be useful information for a reader of proto.h. This commits stops doing this for private macros. It makes a future commit slightly easier, and I'm unsure of the usefulness of this anyway. But I could be persuaded otherwise. --- proto.h | 21 --------------------- regen/embed.pl | 4 ++++ 2 files changed, 4 insertions(+), 21 deletions(-) diff --git a/proto.h b/proto.h index ceb3022b65e2..30dcb2422173 100644 --- a/proto.h +++ b/proto.h @@ -791,9 +791,6 @@ Perl_die_unwind(pTHX_ SV *msv) #define PERL_ARGS_ASSERT_DIE_UNWIND \ assert(msv) -/* PERL_CALLCONV bool -Perl_do_aexec(pTHX_ SV *really, SV **mark, SV **sp); */ - PERL_CALLCONV bool Perl_do_aexec5(pTHX_ SV *really, SV **mark, SV **sp, int fd, int do_report) __attribute__visibility__("hidden"); @@ -2649,9 +2646,6 @@ PERL_CALLCONV Pid_t Perl_my_fork(void); #define PERL_ARGS_ASSERT_MY_FORK -/* PERL_CALLCONV I32 -Perl_my_lstat(pTHX); */ - PERL_CALLCONV I32 Perl_my_lstat_flags(pTHX_ const U32 flags); #define PERL_ARGS_ASSERT_MY_LSTAT_FLAGS @@ -2689,9 +2683,6 @@ PERL_CALLCONV int Perl_my_socketpair(int family, int type, int protocol, int fd[2]); #define PERL_ARGS_ASSERT_MY_SOCKETPAIR -/* PERL_CALLCONV I32 -Perl_my_stat(pTHX); */ - PERL_CALLCONV I32 Perl_my_stat_flags(pTHX_ const U32 flags); #define PERL_ARGS_ASSERT_MY_STAT_FLAGS @@ -6885,21 +6876,12 @@ S_do_trans_simple(pTHX_ SV * const sv, const OPtrans_map * const tbl) defined(PERL_IN_REGCOMP_ANY) || defined(PERL_IN_UTF8_C) # define PERL_ARGS_ASSERT__ADD_RANGE_TO_INVLIST -/* PERL_CALLCONV void -_invlist_intersection(pTHX_ SV * const a, SV * const b, SV **i); */ - # define PERL_ARGS_ASSERT__INVLIST_INTERSECTION_MAYBE_COMPLEMENT_2ND \ assert(b); assert(i) # define PERL_ARGS_ASSERT__INVLIST_INVERT \ assert(invlist) -/* PERL_CALLCONV void -_invlist_subtract(pTHX_ SV * const a, SV * const b, SV **result); */ - -/* PERL_CALLCONV void -_invlist_union(pTHX_ SV * const a, SV * const b, SV **output); */ - # define PERL_ARGS_ASSERT__INVLIST_UNION_MAYBE_COMPLEMENT_2ND \ assert(b); assert(output) @@ -10717,9 +10699,6 @@ Perl_dump_c_backtrace(pTHX_ PerlIO *fp, int max_depth, int skip); # define PERL_ARGS_ASSERT_DUMP_C_BACKTRACE \ assert(fp) -/* PERL_CALLCONV void -free_c_backtrace(pTHX_ Perl_c_backtrace *bt); */ - PERL_CALLCONV Perl_c_backtrace * Perl_get_c_backtrace(pTHX_ int max_depth, int skip) __attribute__visibility__("hidden"); diff --git a/regen/embed.pl b/regen/embed.pl index 8b454a5b39f1..aed8fd4c357d 100755 --- a/regen/embed.pl +++ b/regen/embed.pl @@ -184,6 +184,10 @@ sub generate_proto_h { if ($flags =~ /S/) { die_at_end "$plain_func: m and S flags are mutually exclusive"; } + + # Don't generate a prototype for a macro that is not usable by the + # outside world. + next unless $flags =~ /[ACE]/; } else { die_at_end "$plain_func: u flag only usable with m" if $flags =~ /u/; From 36938dde031f3e80c6213a2a2b67a70d7634029e Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Sat, 4 Oct 2025 15:38:35 -0600 Subject: [PATCH 5/6] regen/embed.pl: Don't create prototype for weird macros Where 'weird' is defined as meaning something that the normal rules don't apply, so something we generate is unlikely to be correct. This only affects one element, and it uses aTHX in a way that is incompatible with it being automated. --- proto.h | 3 --- regen/embed.pl | 3 +++ 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/proto.h b/proto.h index 30dcb2422173..28a9ae25fdb3 100644 --- a/proto.h +++ b/proto.h @@ -55,9 +55,6 @@ Perl_PerlLIO_open_cloexec(pTHX_ const char *file, int flag) #define PERL_ARGS_ASSERT_PERLLIO_OPEN_CLOEXEC \ assert(file) -/* PERL_CALLCONV const XOP * -Perl_custom_op_xop(pTHX_ const OP *o); */ - PERL_CALLCONV const char * Perl_langinfo(const nl_item item); #define PERL_ARGS_ASSERT_PERL_LANGINFO diff --git a/regen/embed.pl b/regen/embed.pl index aed8fd4c357d..6f467d4d30dd 100755 --- a/regen/embed.pl +++ b/regen/embed.pl @@ -188,6 +188,9 @@ sub generate_proto_h { # Don't generate a prototype for a macro that is not usable by the # outside world. next unless $flags =~ /[ACE]/; + + # Nor one that is weird, which would likely be a syntax error. + next if $flags =~ /u/; } else { die_at_end "$plain_func: u flag only usable with m" if $flags =~ /u/; From 5e195c6ae864d39d59bb9b635a003dd733f357eb Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Sat, 4 Oct 2025 15:51:04 -0600 Subject: [PATCH 6/6] Improve -DNO_SHORT_NAMES handling This option has been broken for a long time, but this commit goes a long way to fixing that. It works by creating a new file long_names.c that is automatically generated by regen/embed.pl. This file contains the API elements that normally are macros that don't have a separate long name. when NO_SHORT_NAMES is defined, those macros are suppressed, and instead the long-name functions in this file get compiled The next yak (maybe the only one) needing to be shaved after this is inline functions that use short names. Since they currently are included in the user space, those short names need to be defined, but we'rev compiling without short names, so it doesn't work. We could require inline functions to use long names, but I don't like that, and I suspect you don't either. To me, the easiest other option is to just not have inline functions outside the core when short names are forbidden. We could easily convert them from being inline, and only include them from long_names.c. Thus they would become like any other function in the file. --- Cross/Makefile-cross-SH | 4 +- MANIFEST | 1 + Makefile.SH | 4 +- embed.h | 480 ++++++++-------- long_names.c | 893 +++++++++++++++++++++++++++++ mathoms.c | 3 - proto.h | 1173 +++++++++++++++++++++++--------------- regen/embed.pl | 90 ++- t/porting/regen.t | 2 +- vms/descrip_mms.template | 4 +- win32/GNUmakefile | 1 + 11 files changed, 1931 insertions(+), 724 deletions(-) create mode 100644 long_names.c diff --git a/Cross/Makefile-cross-SH b/Cross/Makefile-cross-SH index 0abd0a43dd31..e9749de82dfc 100644 --- a/Cross/Makefile-cross-SH +++ b/Cross/Makefile-cross-SH @@ -342,14 +342,14 @@ h = $(h1) $(h2) $(h3) $(h4) $(h5) c1 = av.c scope.c op.c doop.c doio.c dquote.c dump.c gv.c hv.c mg.c reentr.c mro_core.c perl.c c2 = perly.c pp.c pp_hot.c pp_ctl.c pp_sys.c regcomp.c regexec.c utf8.c sv.c c3 = taint.c time64.c toke.c util.c deb.c run.c universal.c pad.c globals.c keywords.c -c4 = perlio.c numeric.c mathoms.c locale.c pp_pack.c pp_sort.c +c4 = perlio.c numeric.c mathoms.c locale.c long_names.c pp_pack.c pp_sort.c c5 = $(mallocsrc) c = $(c1) $(c2) $(c3) $(c4) $(c5) miniperlmain.c perlmain.c opmini.c obj1 = $(mallocobj) gv$(OBJ_EXT) toke$(OBJ_EXT) perly$(OBJ_EXT) op$(OBJ_EXT) pad$(OBJ_EXT) regcomp$(OBJ_EXT) dquote$(OBJ_EXT) dump$(OBJ_EXT) util$(OBJ_EXT) mg$(OBJ_EXT) reentr$(OBJ_EXT) mro_core$(OBJ_EXT) obj2 = hv$(OBJ_EXT) av$(OBJ_EXT) perl$(OBJ_EXT) run$(OBJ_EXT) pp_hot$(OBJ_EXT) sv$(OBJ_EXT) pp$(OBJ_EXT) scope$(OBJ_EXT) pp_ctl$(OBJ_EXT) pp_sys$(OBJ_EXT) -obj3 = doop$(OBJ_EXT) doio$(OBJ_EXT) regexec$(OBJ_EXT) utf8$(OBJ_EXT) taint$(OBJ_EXT) deb$(OBJ_EXT) universal$(OBJ_EXT) globals$(OBJ_EXT) perlio$(OBJ_EXT) numeric$(OBJ_EXT) mathoms$(OBJ_EXT) locale$(OBJ_EXT) pp_pack$(OBJ_EXT) pp_sort$(OBJ_EXT) time64$(OBJ_EXT) +obj3 = doop$(OBJ_EXT) doio$(OBJ_EXT) regexec$(OBJ_EXT) utf8$(OBJ_EXT) taint$(OBJ_EXT) deb$(OBJ_EXT) universal$(OBJ_EXT) globals$(OBJ_EXT) perlio$(OBJ_EXT) numeric$(OBJ_EXT) mathoms$(OBJ_EXT) locale$(OBJ_EXT) long_names($OBJ_EXT) pp_pack$(OBJ_EXT) pp_sort$(OBJ_EXT) time64$(OBJ_EXT) obj = $(obj1) $(obj2) $(obj3) $(ARCHOBJS) diff --git a/MANIFEST b/MANIFEST index 2ecec777eba2..9e908e694720 100644 --- a/MANIFEST +++ b/MANIFEST @@ -61,6 +61,7 @@ keywords.h The keyword numbers l1_char_class_tab.h 256 word bit table of character classes (for handy.h) locale.c locale-specific utility functions locale_table.h header for locale.c +long_names.c for use when NO_SHORT_NAMES is defined make_ext.pl Used by Makefile to execute extension Makefiles make_patchnum.pl Script to generate git_version.h and lib/Config_git.pl files for all OS'es makedef.pl Create symbol export lists for linking diff --git a/Makefile.SH b/Makefile.SH index b01c6e55ec58..8248e6f4116c 100755 --- a/Makefile.SH +++ b/Makefile.SH @@ -550,8 +550,8 @@ h = \ c_base = \ av.c builtin.c caretx.c class.c deb.c doio.c doop.c dquote.c dump.c \ - globals.c gv.c hv.c keywords.c locale.c mathoms.c mg.c mro_core.c \ - numeric.c op.c pad.c peep.c perl.c perlio.c perly.c \ + globals.c gv.c hv.c keywords.c locale.c long_names.c mathoms.c mg.c \ + mro_core.c numeric.c op.c pad.c peep.c perl.c perlio.c perly.c \ pp.c pp_ctl.c pp_hot.c pp_pack.c pp_sort.c pp_sys.c \ reentr.c regcomp.c regcomp_debug.c regcomp_invlist.c regcomp_study.c \ regcomp_trie.c regexec.c run.c scope.c sv.c taint.c time64.c toke.c \ diff --git a/embed.h b/embed.h index 57661cfd5352..8034d75ebe84 100644 --- a/embed.h +++ b/embed.h @@ -148,7 +148,6 @@ # define bytes_to_utf8(a,b) Perl_bytes_to_utf8(aTHX_ a,b) # define bytes_to_utf8_free_me(a,b,c) Perl_bytes_to_utf8_free_me(aTHX_ a,b,c) # define bytes_to_utf8_temp_pv(a,b) Perl_bytes_to_utf8_temp_pv(aTHX_ a,b) -# define Perl_c9strict_utf8_to_uv c9strict_utf8_to_uv # define call_argv(a,b,c) Perl_call_argv(aTHX_ a,b,c) # define call_atexit(a,b) Perl_call_atexit(aTHX_ a,b) # define call_list(a,b) Perl_call_list(aTHX_ a,b) @@ -219,7 +218,6 @@ # define dump_vindent(a,b,c,d) Perl_dump_vindent(aTHX_ a,b,c,d) # define eval_pv(a,b) Perl_eval_pv(aTHX_ a,b) # define eval_sv(a,b) Perl_eval_sv(aTHX_ a,b) -# define Perl_extended_utf8_to_uv extended_utf8_to_uv # define fatal_warner(a,...) Perl_fatal_warner(aTHX_ a,__VA_ARGS__) # define fbm_compile(a,b) Perl_fbm_compile(aTHX_ a,b) # define fbm_instr(a,b,c,d) Perl_fbm_instr(aTHX_ a,b,c,d) @@ -307,41 +305,29 @@ # define init_i18nl10n(a) Perl_init_i18nl10n(aTHX_ a) # define init_stacks() Perl_init_stacks(aTHX) # define init_tm(a) Perl_init_tm(aTHX_ a) -# define Perl_instr instr # define intro_my() Perl_intro_my(aTHX) # define isC9_STRICT_UTF8_CHAR Perl_isC9_STRICT_UTF8_CHAR # define isSTRICT_UTF8_CHAR Perl_isSTRICT_UTF8_CHAR # define isUTF8_CHAR Perl_isUTF8_CHAR # define isUTF8_CHAR_flags Perl_isUTF8_CHAR_flags -# define Perl_is_c9strict_utf8_string is_c9strict_utf8_string -# define Perl_is_c9strict_utf8_string_loc is_c9strict_utf8_string_loc # define is_c9strict_utf8_string_loclen Perl_is_c9strict_utf8_string_loclen # define is_in_locale_category_(a,b) Perl_is_in_locale_category_(aTHX_ a,b) # define is_lvalue_sub() Perl_is_lvalue_sub(aTHX) # define is_safe_syscall(a,b,c,d) Perl_is_safe_syscall(aTHX_ a,b,c,d) -# define Perl_is_strict_utf8_string is_strict_utf8_string -# define Perl_is_strict_utf8_string_loc is_strict_utf8_string_loc # define is_strict_utf8_string_loclen Perl_is_strict_utf8_string_loclen # define is_uni_FOO_(a,b) Perl_is_uni_FOO_(aTHX_ a,b) # define is_uni_perl_idcont_(a) Perl_is_uni_perl_idcont_(aTHX_ a) # define is_uni_perl_idstart_(a) Perl_is_uni_perl_idstart_(aTHX_ a) # define is_utf8_FF_helper_ Perl_is_utf8_FF_helper_ # define is_utf8_FOO_(a,b,c) Perl_is_utf8_FOO_(aTHX_ a,b,c) -# define Perl_is_utf8_char_buf is_utf8_char_buf # define is_utf8_char_helper_ Perl_is_utf8_char_helper_ -# define Perl_is_utf8_fixed_width_buf_flags is_utf8_fixed_width_buf_flags -# define Perl_is_utf8_fixed_width_buf_loc_flags is_utf8_fixed_width_buf_loc_flags # define is_utf8_fixed_width_buf_loclen_flags Perl_is_utf8_fixed_width_buf_loclen_flags # define is_utf8_invariant_string_loc Perl_is_utf8_invariant_string_loc # define is_utf8_perl_idcont_(a,b) Perl_is_utf8_perl_idcont_(aTHX_ a,b) # define is_utf8_perl_idstart_(a,b) Perl_is_utf8_perl_idstart_(aTHX_ a,b) -# define Perl_is_utf8_string is_utf8_string # define is_utf8_string_flags Perl_is_utf8_string_flags -# define Perl_is_utf8_string_loc is_utf8_string_loc -# define Perl_is_utf8_string_loc_flags is_utf8_string_loc_flags # define is_utf8_string_loclen Perl_is_utf8_string_loclen # define is_utf8_string_loclen_flags Perl_is_utf8_string_loclen_flags -# define Perl_is_utf8_valid_partial_char is_utf8_valid_partial_char # define is_utf8_valid_partial_char_flags Perl_is_utf8_valid_partial_char_flags # define isinfnan Perl_isinfnan # define leave_adjust_stacks(a,b,c,d) Perl_leave_adjust_stacks(aTHX_ a,b,c,d) @@ -664,7 +650,6 @@ # define stack_grow(a,b,c) Perl_stack_grow(aTHX_ a,b,c) # define start_subparse(a,b) Perl_start_subparse(aTHX_ a,b) # define str_to_version(a) Perl_str_to_version(aTHX_ a) -# define Perl_strict_utf8_to_uv strict_utf8_to_uv # define suspend_compcv(a) Perl_suspend_compcv(aTHX_ a) # define sv_2bool_flags(a,b) Perl_sv_2bool_flags(aTHX_ a,b) # define sv_2cv(a,b,c,d) Perl_sv_2cv(aTHX_ a,b,c,d) @@ -820,26 +805,18 @@ # define upg_version(a,b) Perl_upg_version(aTHX_ a,b) # define utf8_distance(a,b) Perl_utf8_distance(aTHX_ a,b) # define utf8_hop Perl_utf8_hop -# define Perl_utf8_hop_back utf8_hop_back # define utf8_hop_back_overshoot Perl_utf8_hop_back_overshoot -# define Perl_utf8_hop_forward utf8_hop_forward # define utf8_hop_forward_overshoot Perl_utf8_hop_forward_overshoot # define utf8_hop_overshoot Perl_utf8_hop_overshoot -# define Perl_utf8_hop_safe utf8_hop_safe # define utf8_length(a,b) Perl_utf8_length(aTHX_ a,b) # define utf8_to_bytes(a,b) Perl_utf8_to_bytes(aTHX_ a,b) # define utf8_to_bytes_(a,b,c,d) Perl_utf8_to_bytes_(aTHX_ a,b,c,d) # define utf8_to_bytes_new_pv(a,b,c) Perl_utf8_to_bytes_new_pv(aTHX_ a,b,c) # define utf8_to_bytes_overwrite(a,b) Perl_utf8_to_bytes_overwrite(aTHX_ a,b) # define utf8_to_bytes_temp_pv(a,b) Perl_utf8_to_bytes_temp_pv(aTHX_ a,b) -# define Perl_utf8_to_uv utf8_to_uv -# define Perl_utf8_to_uv_errors utf8_to_uv_errors -# define Perl_utf8_to_uv_flags utf8_to_uv_flags # define utf8_to_uv_msgs Perl_utf8_to_uv_msgs # define utf8_to_uv_msgs_helper_ Perl_utf8_to_uv_msgs_helper_ # define utf8_to_uv_or_die Perl_utf8_to_uv_or_die -# define Perl_utf8n_to_uvchr utf8n_to_uvchr -# define Perl_utf8n_to_uvchr_error utf8n_to_uvchr_error # define utf8n_to_uvchr_msgs Perl_utf8n_to_uvchr_msgs # define uv_to_utf8(a,b) Perl_uv_to_utf8(aTHX_ a,b) # define uv_to_utf8_flags(a,b,c) Perl_uv_to_utf8_flags(aTHX_ a,b,c) @@ -848,7 +825,6 @@ # define valid_identifier_pvn(a,b,c) Perl_valid_identifier_pvn(aTHX_ a,b,c) # define valid_identifier_sv(a) Perl_valid_identifier_sv(aTHX_ a) # define valid_utf8_to_uv Perl_valid_utf8_to_uv -# define Perl_valid_utf8_to_uvchr valid_utf8_to_uvchr # define vcmp(a,b) Perl_vcmp(aTHX_ a,b) # define vcroak(a,b) Perl_vcroak(aTHX_ a,b) # define vdeb(a,b) Perl_vdeb(aTHX_ a,b) @@ -1781,15 +1757,6 @@ # define quadmath_format_needed Perl_quadmath_format_needed # define quadmath_format_valid Perl_quadmath_format_valid # endif -# if defined(USE_THREADS) -# define Perl_do_aexec(mTHX,a,b,c) do_aexec(a,b,c) -# define Perl_my_lstat(mTHX) my_lstat() -# define Perl_my_stat(mTHX) my_stat() -# else -# define Perl_do_aexec do_aexec -# define Perl_my_lstat my_lstat -# define Perl_my_stat my_stat -# endif # if defined(WIN32) # define get_win32_message_utf8ness(a) Perl_get_win32_message_utf8ness(aTHX_ a) # else @@ -2199,6 +2166,247 @@ # define cx_topblock(a) Perl_cx_topblock(aTHX_ a) # define gimme_V() Perl_gimme_V(aTHX) # endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ +# if !defined(PERL_NO_SHORT_NAMES) +# define Perl_c9strict_utf8_to_uv c9strict_utf8_to_uv +# define Perl_extended_utf8_to_uv extended_utf8_to_uv +# define Perl_instr instr +# define Perl_is_c9strict_utf8_string is_c9strict_utf8_string +# define Perl_is_c9strict_utf8_string_loc is_c9strict_utf8_string_loc +# define Perl_is_strict_utf8_string is_strict_utf8_string +# define Perl_is_strict_utf8_string_loc is_strict_utf8_string_loc +# define Perl_is_utf8_char_buf is_utf8_char_buf +# define Perl_is_utf8_fixed_width_buf_flags is_utf8_fixed_width_buf_flags +# define Perl_is_utf8_fixed_width_buf_loc_flags is_utf8_fixed_width_buf_loc_flags +# define Perl_is_utf8_string is_utf8_string +# define Perl_is_utf8_string_loc is_utf8_string_loc +# define Perl_is_utf8_string_loc_flags is_utf8_string_loc_flags +# define Perl_is_utf8_valid_partial_char is_utf8_valid_partial_char +# define Perl_strict_utf8_to_uv strict_utf8_to_uv +# define Perl_utf8_hop_back utf8_hop_back +# define Perl_utf8_hop_forward utf8_hop_forward +# define Perl_utf8_hop_safe utf8_hop_safe +# define Perl_utf8_to_uv utf8_to_uv +# define Perl_utf8_to_uv_errors utf8_to_uv_errors +# define Perl_utf8_to_uv_flags utf8_to_uv_flags +# define Perl_utf8n_to_uvchr utf8n_to_uvchr +# define Perl_utf8n_to_uvchr_error utf8n_to_uvchr_error +# define Perl_valid_utf8_to_uvchr valid_utf8_to_uvchr +# if defined(USE_THREADS) +# define Perl_SvREFCNT_dec_set_NULL(mTHX,a) SvREFCNT_dec_set_NULL(a) +# define Perl_do_open(mTHX,a,b,c,d,e,f,g) do_open(a,b,c,d,e,f,g) +# define Perl_foldEQ_utf8(mTHX,a,b,c,d,e,f,g,h) foldEQ_utf8(a,b,c,d,e,f,g,h) +# define Perl_gv_AVadd(mTHX,a) gv_AVadd(a) +# define Perl_gv_HVadd(mTHX,a) gv_HVadd(a) +# define Perl_gv_IOadd(mTHX,a) gv_IOadd(a) +# define Perl_gv_efullname3(mTHX,a,b,c) gv_efullname3(a,b,c) +# define Perl_gv_fetchmeth(mTHX,a,b,c,d) gv_fetchmeth(a,b,c,d) +# define Perl_gv_fetchmeth_autoload(mTHX,a,b,c,d) gv_fetchmeth_autoload(a,b,c,d) +# define Perl_gv_fetchmethod(mTHX,a,b) gv_fetchmethod(a,b) +# define Perl_gv_fullname3(mTHX,a,b,c) gv_fullname3(a,b,c) +# define Perl_gv_init(mTHX,a,b,c,d,e) gv_init(a,b,c,d,e) +# define Perl_hv_delete(mTHX,a,b,c,d) hv_delete(a,b,c,d) +# define Perl_hv_delete_ent(mTHX,a,b,c,d) hv_delete_ent(a,b,c,d) +# define Perl_hv_exists(mTHX,a,b,c) hv_exists(a,b,c) +# define Perl_hv_exists_ent(mTHX,a,b,c) hv_exists_ent(a,b,c) +# define Perl_hv_fetch(mTHX,a,b,c,d) hv_fetch(a,b,c,d) +# define Perl_hv_fetch_ent(mTHX,a,b,c,d) hv_fetch_ent(a,b,c,d) +# define Perl_hv_iternext(mTHX,a) hv_iternext(a) +# define Perl_hv_magic(mTHX,a,b,c) hv_magic(a,b,c) +# define Perl_hv_store(mTHX,a,b,c,d,e) hv_store(a,b,c,d,e) +# define Perl_hv_store_ent(mTHX,a,b,c,d) hv_store_ent(a,b,c,d) +# define Perl_hv_store_flags(mTHX,a,b,c,d,e,f) hv_store_flags(a,b,c,d,e,f) +# define Perl_hv_stores(mTHX,a,b,c) hv_stores(a,b,c) +# define Perl_hv_undef(mTHX,a) hv_undef(a) +# define Perl_ibcmp(mTHX,a,b,c) ibcmp(a,b,c) +# define Perl_ibcmp_locale(mTHX,a,b,c) ibcmp_locale(a,b,c) +# define Perl_ibcmp_utf8(mTHX,a,b,c,d,e,f,g,h) ibcmp_utf8(a,b,c,d,e,f,g,h) +# define Perl_newATTRSUB(mTHX,a,b,c,d,e) newATTRSUB(a,b,c,d,e) +# define Perl_newAV(mTHX) newAV() +# define Perl_newAV_alloc_x(mTHX,a) newAV_alloc_x(a) +# define Perl_newAV_alloc_xz(mTHX,a) newAV_alloc_xz(a) +# define Perl_newAV_mortal(mTHX) newAV_mortal() +# define Perl_newGVgen(mTHX,a) newGVgen(a) +# define Perl_newHV(mTHX) newHV() +# define Perl_newIO(mTHX) newIO() +# define Perl_newSUB(mTHX,a,b,c,d) newSUB(a,b,c,d) +# define Perl_newSVsv(mTHX,a) newSVsv(a) +# define Perl_newSVsv_nomg(mTHX,a) newSVsv_nomg(a) +# define Perl_op_lvalue(mTHX,a,b) op_lvalue(a,b) +# define Perl_phase_name(mTHX,a) phase_name(a) +# define Perl_resume_compcv_and_save(mTHX,a) resume_compcv_and_save(a) +# define Perl_resume_compcv_final(mTHX,a) resume_compcv_final(a) +# define Perl_save_aelem(mTHX,a,b,c) save_aelem(a,b,c) +# define Perl_save_freeop(mTHX,a) save_freeop(a) +# define Perl_save_freepv(mTHX,a) save_freepv(a) +# define Perl_save_freesv(mTHX,a) save_freesv(a) +# define Perl_save_helem(mTHX,a,b,c) save_helem(a,b,c) +# define Perl_save_mortalizesv(mTHX,a) save_mortalizesv(a) +# define Perl_save_op(mTHX) save_op() +# define Perl_sv_2bool(mTHX,a) sv_2bool(a) +# define Perl_sv_2iv(mTHX,a) sv_2iv(a) +# define Perl_sv_2pv(mTHX,a,b) sv_2pv(a,b) +# define Perl_sv_2pv_nolen(mTHX,a) sv_2pv_nolen(a) +# define Perl_sv_2pvbyte(mTHX,a,b) sv_2pvbyte(a,b) +# define Perl_sv_2pvbyte_nolen(mTHX,a) sv_2pvbyte_nolen(a) +# define Perl_sv_2pvutf8(mTHX,a,b) sv_2pvutf8(a,b) +# define Perl_sv_2pvutf8_nolen(mTHX,a) sv_2pvutf8_nolen(a) +# define Perl_sv_2uv(mTHX,a) sv_2uv(a) +# define Perl_sv_catpvn(mTHX,a,b,c) sv_catpvn(a,b,c) +# define Perl_sv_catpvn_mg(mTHX,a,b,c) sv_catpvn_mg(a,b,c) +# define Perl_sv_catsv(mTHX,a,b) sv_catsv(a,b) +# define Perl_sv_catsv_mg(mTHX,a,b) sv_catsv_mg(a,b) +# define Perl_sv_copypv(mTHX,a,b) sv_copypv(a,b) +# define Perl_sv_copypv_nomg(mTHX,a,b) sv_copypv_nomg(a,b) +# define Perl_sv_eq(mTHX,a,b) sv_eq(a,b) +# define Perl_sv_force_normal(mTHX,a) sv_force_normal(a) +# define Perl_sv_insert(mTHX,a,b,c,d,e) sv_insert(a,b,c,d,e) +# define Perl_sv_mortalcopy(mTHX,a) sv_mortalcopy(a) +# define Perl_sv_numeq(mTHX,a,b) sv_numeq(a,b) +# define Perl_sv_pv(mTHX,a) sv_pv(a) +# define Perl_sv_pvbyte(mTHX,a) sv_pvbyte(a) +# define Perl_sv_pvn_force(mTHX,a,b) sv_pvn_force(a,b) +# define Perl_sv_pvutf8(mTHX,a) sv_pvutf8(a) +# define Perl_sv_setsv(mTHX,a,b) sv_setsv(a,b) +# define Perl_sv_streq(mTHX,a,b) sv_streq(a,b) +# define Perl_sv_taint(mTHX,a) sv_taint(a) +# define Perl_sv_unref(mTHX,a) sv_unref(a) +# define Perl_sv_usepvn(mTHX,a,b,c) sv_usepvn(a,b,c) +# define Perl_sv_usepvn_mg(mTHX,a,b,c) sv_usepvn_mg(a,b,c) +# define Perl_sv_utf8_downgrade(mTHX,a,b) sv_utf8_downgrade(a,b) +# define Perl_sv_utf8_downgrade_nomg(mTHX,a,b) sv_utf8_downgrade_nomg(a,b) +# define Perl_sv_utf8_upgrade(mTHX,a) sv_utf8_upgrade(a) +# define Perl_sv_utf8_upgrade_flags(mTHX,a,b) sv_utf8_upgrade_flags(a,b) +# define Perl_sv_utf8_upgrade_nomg(mTHX,a) sv_utf8_upgrade_nomg(a) +# define Perl_to_uni_fold(mTHX,a,b,c) to_uni_fold(a,b,c) +# define Perl_uv_to_utf8_msgs(mTHX,a,b,c,d) uv_to_utf8_msgs(a,b,c,d) +# define Perl_uvchr_to_utf8(mTHX,a,b) uvchr_to_utf8(a,b) +# define Perl_uvchr_to_utf8_flags(mTHX,a,b,c) uvchr_to_utf8_flags(a,b,c) +# define Perl_uvchr_to_utf8_flags_msgs(mTHX,a,b,c,d) uvchr_to_utf8_flags_msgs(a,b,c,d) +# define Perl_uvoffuni_to_utf8_flags(mTHX,a,b,c) uvoffuni_to_utf8_flags(a,b,c) +# define Perl_whichsig(mTHX,a) whichsig(a) +# if defined(PERL_CORE) +# define Perl_do_aexec(mTHX,a,b,c) do_aexec(a,b,c) +# define Perl_my_lstat(mTHX) my_lstat() +# define Perl_my_stat(mTHX) my_stat() +# endif +# if defined(PERL_DONT_CREATE_GVSV) +# define Perl_gv_SVadd(mTHX,a) gv_SVadd(a) +# endif +# if !defined(USE_ITHREADS) +# define Perl_CopFILEGV_set(mTHX,a,b) CopFILEGV_set(a,b) +# endif +# if defined(USE_LOCALE_COLLATE) +# define Perl_sv_collxfrm(mTHX,a,b) sv_collxfrm(a,b) +# endif +# else /* if !defined(USE_THREADS) */ +# define Perl_SvREFCNT_dec_set_NULL SvREFCNT_dec_set_NULL +# define Perl_do_open do_open +# define Perl_foldEQ_utf8 foldEQ_utf8 +# define Perl_gv_AVadd gv_AVadd +# define Perl_gv_HVadd gv_HVadd +# define Perl_gv_IOadd gv_IOadd +# define Perl_gv_efullname3 gv_efullname3 +# define Perl_gv_fetchmeth gv_fetchmeth +# define Perl_gv_fetchmeth_autoload gv_fetchmeth_autoload +# define Perl_gv_fetchmethod gv_fetchmethod +# define Perl_gv_fullname3 gv_fullname3 +# define Perl_gv_init gv_init +# define Perl_hv_delete hv_delete +# define Perl_hv_delete_ent hv_delete_ent +# define Perl_hv_exists hv_exists +# define Perl_hv_exists_ent hv_exists_ent +# define Perl_hv_fetch hv_fetch +# define Perl_hv_fetch_ent hv_fetch_ent +# define Perl_hv_iternext hv_iternext +# define Perl_hv_magic hv_magic +# define Perl_hv_store hv_store +# define Perl_hv_store_ent hv_store_ent +# define Perl_hv_store_flags hv_store_flags +# define Perl_hv_stores hv_stores +# define Perl_hv_undef hv_undef +# define Perl_ibcmp ibcmp +# define Perl_ibcmp_locale ibcmp_locale +# define Perl_ibcmp_utf8 ibcmp_utf8 +# define Perl_newATTRSUB newATTRSUB +# define Perl_newAV newAV +# define Perl_newAV_alloc_x newAV_alloc_x +# define Perl_newAV_alloc_xz newAV_alloc_xz +# define Perl_newAV_mortal newAV_mortal +# define Perl_newGVgen newGVgen +# define Perl_newHV newHV +# define Perl_newIO newIO +# define Perl_newSUB newSUB +# define Perl_newSVsv newSVsv +# define Perl_newSVsv_nomg newSVsv_nomg +# define Perl_op_lvalue op_lvalue +# define Perl_phase_name phase_name +# define Perl_resume_compcv_and_save resume_compcv_and_save +# define Perl_resume_compcv_final resume_compcv_final +# define Perl_save_aelem save_aelem +# define Perl_save_freeop save_freeop +# define Perl_save_freepv save_freepv +# define Perl_save_freesv save_freesv +# define Perl_save_helem save_helem +# define Perl_save_mortalizesv save_mortalizesv +# define Perl_save_op save_op +# define Perl_sv_2bool sv_2bool +# define Perl_sv_2iv sv_2iv +# define Perl_sv_2pv sv_2pv +# define Perl_sv_2pv_nolen sv_2pv_nolen +# define Perl_sv_2pvbyte sv_2pvbyte +# define Perl_sv_2pvbyte_nolen sv_2pvbyte_nolen +# define Perl_sv_2pvutf8 sv_2pvutf8 +# define Perl_sv_2pvutf8_nolen sv_2pvutf8_nolen +# define Perl_sv_2uv sv_2uv +# define Perl_sv_catpvn sv_catpvn +# define Perl_sv_catpvn_mg sv_catpvn_mg +# define Perl_sv_catsv sv_catsv +# define Perl_sv_catsv_mg sv_catsv_mg +# define Perl_sv_copypv sv_copypv +# define Perl_sv_copypv_nomg sv_copypv_nomg +# define Perl_sv_eq sv_eq +# define Perl_sv_force_normal sv_force_normal +# define Perl_sv_insert sv_insert +# define Perl_sv_mortalcopy sv_mortalcopy +# define Perl_sv_numeq sv_numeq +# define Perl_sv_pv sv_pv +# define Perl_sv_pvbyte sv_pvbyte +# define Perl_sv_pvn_force sv_pvn_force +# define Perl_sv_pvutf8 sv_pvutf8 +# define Perl_sv_setsv sv_setsv +# define Perl_sv_streq sv_streq +# define Perl_sv_taint sv_taint +# define Perl_sv_unref sv_unref +# define Perl_sv_usepvn sv_usepvn +# define Perl_sv_usepvn_mg sv_usepvn_mg +# define Perl_sv_utf8_downgrade sv_utf8_downgrade +# define Perl_sv_utf8_downgrade_nomg sv_utf8_downgrade_nomg +# define Perl_sv_utf8_upgrade sv_utf8_upgrade +# define Perl_sv_utf8_upgrade_flags sv_utf8_upgrade_flags +# define Perl_sv_utf8_upgrade_nomg sv_utf8_upgrade_nomg +# define Perl_to_uni_fold to_uni_fold +# define Perl_uv_to_utf8_msgs uv_to_utf8_msgs +# define Perl_uvchr_to_utf8 uvchr_to_utf8 +# define Perl_uvchr_to_utf8_flags uvchr_to_utf8_flags +# define Perl_uvchr_to_utf8_flags_msgs uvchr_to_utf8_flags_msgs +# define Perl_uvoffuni_to_utf8_flags uvoffuni_to_utf8_flags +# define Perl_whichsig whichsig +# if defined(PERL_CORE) +# define Perl_do_aexec do_aexec +# define Perl_my_lstat my_lstat +# define Perl_my_stat my_stat +# endif +# if defined(PERL_DONT_CREATE_GVSV) +# define Perl_gv_SVadd gv_SVadd +# endif +# if !defined(USE_ITHREADS) +# define Perl_CopFILEGV_set CopFILEGV_set +# endif +# if defined(USE_LOCALE_COLLATE) +# define Perl_sv_collxfrm sv_collxfrm +# endif +# endif /* !defined(USE_THREADS) */ +# endif /* !defined(PERL_NO_SHORT_NAMES) */ # if defined(PERL_RC_STACK) # define runops_wrap() Perl_runops_wrap(aTHX) # endif @@ -2247,12 +2455,7 @@ defined(PERL_IN_SV_C) ) # define mem_collxfrm_(a,b,c,d) Perl_mem_collxfrm_(aTHX_ a,b,c,d) # endif -# if defined(USE_THREADS) -# define Perl_sv_collxfrm(mTHX,a,b) sv_collxfrm(a,b) -# else -# define Perl_sv_collxfrm sv_collxfrm -# endif -# endif /* defined(USE_LOCALE_COLLATE) */ +# endif # if defined(USE_PERLIO) # define PerlIO_clearerr(a) Perl_PerlIO_clearerr(aTHX_ a) # define PerlIO_close(a) Perl_PerlIO_close(aTHX_ a) @@ -2278,206 +2481,9 @@ # define PerlIO_write(a,b,c) Perl_PerlIO_write(aTHX_ a,b,c) # endif /* defined(USE_PERLIO) */ # if defined(USE_THREADS) -# define Perl_SvREFCNT_dec_set_NULL(mTHX,a) SvREFCNT_dec_set_NULL(a) -# define Perl_do_open(mTHX,a,b,c,d,e,f,g) do_open(a,b,c,d,e,f,g) -# define Perl_foldEQ_utf8(mTHX,a,b,c,d,e,f,g,h) foldEQ_utf8(a,b,c,d,e,f,g,h) -# define Perl_gv_AVadd(mTHX,a) gv_AVadd(a) -# define Perl_gv_HVadd(mTHX,a) gv_HVadd(a) -# define Perl_gv_IOadd(mTHX,a) gv_IOadd(a) -# define Perl_gv_efullname3(mTHX,a,b,c) gv_efullname3(a,b,c) -# define Perl_gv_fetchmeth(mTHX,a,b,c,d) gv_fetchmeth(a,b,c,d) -# define Perl_gv_fetchmeth_autoload(mTHX,a,b,c,d) gv_fetchmeth_autoload(a,b,c,d) -# define Perl_gv_fetchmethod(mTHX,a,b) gv_fetchmethod(a,b) -# define Perl_gv_fullname3(mTHX,a,b,c) gv_fullname3(a,b,c) -# define Perl_gv_init(mTHX,a,b,c,d,e) gv_init(a,b,c,d,e) -# define Perl_hv_delete(mTHX,a,b,c,d) hv_delete(a,b,c,d) -# define Perl_hv_delete_ent(mTHX,a,b,c,d) hv_delete_ent(a,b,c,d) -# define Perl_hv_exists(mTHX,a,b,c) hv_exists(a,b,c) -# define Perl_hv_exists_ent(mTHX,a,b,c) hv_exists_ent(a,b,c) -# define Perl_hv_fetch(mTHX,a,b,c,d) hv_fetch(a,b,c,d) -# define Perl_hv_fetch_ent(mTHX,a,b,c,d) hv_fetch_ent(a,b,c,d) -# define Perl_hv_iternext(mTHX,a) hv_iternext(a) -# define Perl_hv_magic(mTHX,a,b,c) hv_magic(a,b,c) -# define Perl_hv_store(mTHX,a,b,c,d,e) hv_store(a,b,c,d,e) -# define Perl_hv_store_ent(mTHX,a,b,c,d) hv_store_ent(a,b,c,d) -# define Perl_hv_store_flags(mTHX,a,b,c,d,e,f) hv_store_flags(a,b,c,d,e,f) -# define Perl_hv_stores(mTHX,a,b,c) hv_stores(a,b,c) -# define Perl_hv_undef(mTHX,a) hv_undef(a) -# define Perl_ibcmp(mTHX,a,b,c) ibcmp(a,b,c) -# define Perl_ibcmp_locale(mTHX,a,b,c) ibcmp_locale(a,b,c) -# define Perl_ibcmp_utf8(mTHX,a,b,c,d,e,f,g,h) ibcmp_utf8(a,b,c,d,e,f,g,h) -# define Perl_newATTRSUB(mTHX,a,b,c,d,e) newATTRSUB(a,b,c,d,e) -# define Perl_newAV(mTHX) newAV() -# define Perl_newAV_alloc_x(mTHX,a) newAV_alloc_x(a) -# define Perl_newAV_alloc_xz(mTHX,a) newAV_alloc_xz(a) -# define Perl_newAV_mortal(mTHX) newAV_mortal() -# define Perl_newGVgen(mTHX,a) newGVgen(a) -# define Perl_newHV(mTHX) newHV() -# define Perl_newIO(mTHX) newIO() -# define Perl_newSUB(mTHX,a,b,c,d) newSUB(a,b,c,d) -# define Perl_newSVsv(mTHX,a) newSVsv(a) -# define Perl_newSVsv_nomg(mTHX,a) newSVsv_nomg(a) -# define Perl_op_lvalue(mTHX,a,b) op_lvalue(a,b) -# define Perl_phase_name(mTHX,a) phase_name(a) -# define Perl_resume_compcv_and_save(mTHX,a) resume_compcv_and_save(a) -# define Perl_resume_compcv_final(mTHX,a) resume_compcv_final(a) -# define Perl_save_aelem(mTHX,a,b,c) save_aelem(a,b,c) -# define Perl_save_freeop(mTHX,a) save_freeop(a) -# define Perl_save_freepv(mTHX,a) save_freepv(a) -# define Perl_save_freesv(mTHX,a) save_freesv(a) -# define Perl_save_helem(mTHX,a,b,c) save_helem(a,b,c) -# define Perl_save_mortalizesv(mTHX,a) save_mortalizesv(a) -# define Perl_save_op(mTHX) save_op() -# define Perl_sv_2bool(mTHX,a) sv_2bool(a) -# define Perl_sv_2iv(mTHX,a) sv_2iv(a) -# define Perl_sv_2pv(mTHX,a,b) sv_2pv(a,b) -# define Perl_sv_2pv_nolen(mTHX,a) sv_2pv_nolen(a) -# define Perl_sv_2pvbyte(mTHX,a,b) sv_2pvbyte(a,b) -# define Perl_sv_2pvbyte_nolen(mTHX,a) sv_2pvbyte_nolen(a) -# define Perl_sv_2pvutf8(mTHX,a,b) sv_2pvutf8(a,b) -# define Perl_sv_2pvutf8_nolen(mTHX,a) sv_2pvutf8_nolen(a) -# define Perl_sv_2uv(mTHX,a) sv_2uv(a) -# define Perl_sv_catpvn(mTHX,a,b,c) sv_catpvn(a,b,c) -# define Perl_sv_catpvn_mg(mTHX,a,b,c) sv_catpvn_mg(a,b,c) -# define Perl_sv_catsv(mTHX,a,b) sv_catsv(a,b) -# define Perl_sv_catsv_mg(mTHX,a,b) sv_catsv_mg(a,b) -# define Perl_sv_copypv(mTHX,a,b) sv_copypv(a,b) -# define Perl_sv_copypv_nomg(mTHX,a,b) sv_copypv_nomg(a,b) -# define Perl_sv_eq(mTHX,a,b) sv_eq(a,b) -# define Perl_sv_force_normal(mTHX,a) sv_force_normal(a) -# define Perl_sv_insert(mTHX,a,b,c,d,e) sv_insert(a,b,c,d,e) -# define Perl_sv_mortalcopy(mTHX,a) sv_mortalcopy(a) -# define Perl_sv_numeq(mTHX,a,b) sv_numeq(a,b) -# define Perl_sv_pv(mTHX,a) sv_pv(a) -# define Perl_sv_pvbyte(mTHX,a) sv_pvbyte(a) -# define Perl_sv_pvn_force(mTHX,a,b) sv_pvn_force(a,b) -# define Perl_sv_pvutf8(mTHX,a) sv_pvutf8(a) -# define Perl_sv_setsv(mTHX,a,b) sv_setsv(a,b) -# define Perl_sv_streq(mTHX,a,b) sv_streq(a,b) -# define Perl_sv_taint(mTHX,a) sv_taint(a) -# define Perl_sv_unref(mTHX,a) sv_unref(a) -# define Perl_sv_usepvn(mTHX,a,b,c) sv_usepvn(a,b,c) -# define Perl_sv_usepvn_mg(mTHX,a,b,c) sv_usepvn_mg(a,b,c) -# define Perl_sv_utf8_downgrade(mTHX,a,b) sv_utf8_downgrade(a,b) -# define Perl_sv_utf8_downgrade_nomg(mTHX,a,b) sv_utf8_downgrade_nomg(a,b) -# define Perl_sv_utf8_upgrade(mTHX,a) sv_utf8_upgrade(a) -# define Perl_sv_utf8_upgrade_flags(mTHX,a,b) sv_utf8_upgrade_flags(a,b) -# define Perl_sv_utf8_upgrade_nomg(mTHX,a) sv_utf8_upgrade_nomg(a) -# define Perl_to_uni_fold(mTHX,a,b,c) to_uni_fold(a,b,c) -# define Perl_uv_to_utf8_msgs(mTHX,a,b,c,d) uv_to_utf8_msgs(a,b,c,d) -# define Perl_uvchr_to_utf8(mTHX,a,b) uvchr_to_utf8(a,b) -# define Perl_uvchr_to_utf8_flags(mTHX,a,b,c) uvchr_to_utf8_flags(a,b,c) -# define Perl_uvchr_to_utf8_flags_msgs(mTHX,a,b,c,d) uvchr_to_utf8_flags_msgs(a,b,c,d) -# define Perl_uvoffuni_to_utf8_flags(mTHX,a,b,c) uvoffuni_to_utf8_flags(a,b,c) -# define Perl_whichsig(mTHX,a) whichsig(a) # define thread_locale_init() Perl_thread_locale_init(aTHX) # define thread_locale_term() Perl_thread_locale_term(aTHX) -# if defined(PERL_DONT_CREATE_GVSV) -# define Perl_gv_SVadd(mTHX,a) gv_SVadd(a) -# endif -# if !defined(USE_ITHREADS) -# define Perl_CopFILEGV_set(mTHX,a,b) CopFILEGV_set(a,b) -# endif -# else /* if !defined(USE_THREADS) */ -# define Perl_SvREFCNT_dec_set_NULL SvREFCNT_dec_set_NULL -# define Perl_do_open do_open -# define Perl_foldEQ_utf8 foldEQ_utf8 -# define Perl_gv_AVadd gv_AVadd -# define Perl_gv_HVadd gv_HVadd -# define Perl_gv_IOadd gv_IOadd -# define Perl_gv_efullname3 gv_efullname3 -# define Perl_gv_fetchmeth gv_fetchmeth -# define Perl_gv_fetchmeth_autoload gv_fetchmeth_autoload -# define Perl_gv_fetchmethod gv_fetchmethod -# define Perl_gv_fullname3 gv_fullname3 -# define Perl_gv_init gv_init -# define Perl_hv_delete hv_delete -# define Perl_hv_delete_ent hv_delete_ent -# define Perl_hv_exists hv_exists -# define Perl_hv_exists_ent hv_exists_ent -# define Perl_hv_fetch hv_fetch -# define Perl_hv_fetch_ent hv_fetch_ent -# define Perl_hv_iternext hv_iternext -# define Perl_hv_magic hv_magic -# define Perl_hv_store hv_store -# define Perl_hv_store_ent hv_store_ent -# define Perl_hv_store_flags hv_store_flags -# define Perl_hv_stores hv_stores -# define Perl_hv_undef hv_undef -# define Perl_ibcmp ibcmp -# define Perl_ibcmp_locale ibcmp_locale -# define Perl_ibcmp_utf8 ibcmp_utf8 -# define Perl_newATTRSUB newATTRSUB -# define Perl_newAV newAV -# define Perl_newAV_alloc_x newAV_alloc_x -# define Perl_newAV_alloc_xz newAV_alloc_xz -# define Perl_newAV_mortal newAV_mortal -# define Perl_newGVgen newGVgen -# define Perl_newHV newHV -# define Perl_newIO newIO -# define Perl_newSUB newSUB -# define Perl_newSVsv newSVsv -# define Perl_newSVsv_nomg newSVsv_nomg -# define Perl_op_lvalue op_lvalue -# define Perl_phase_name phase_name -# define Perl_resume_compcv_and_save resume_compcv_and_save -# define Perl_resume_compcv_final resume_compcv_final -# define Perl_save_aelem save_aelem -# define Perl_save_freeop save_freeop -# define Perl_save_freepv save_freepv -# define Perl_save_freesv save_freesv -# define Perl_save_helem save_helem -# define Perl_save_mortalizesv save_mortalizesv -# define Perl_save_op save_op -# define Perl_sv_2bool sv_2bool -# define Perl_sv_2iv sv_2iv -# define Perl_sv_2pv sv_2pv -# define Perl_sv_2pv_nolen sv_2pv_nolen -# define Perl_sv_2pvbyte sv_2pvbyte -# define Perl_sv_2pvbyte_nolen sv_2pvbyte_nolen -# define Perl_sv_2pvutf8 sv_2pvutf8 -# define Perl_sv_2pvutf8_nolen sv_2pvutf8_nolen -# define Perl_sv_2uv sv_2uv -# define Perl_sv_catpvn sv_catpvn -# define Perl_sv_catpvn_mg sv_catpvn_mg -# define Perl_sv_catsv sv_catsv -# define Perl_sv_catsv_mg sv_catsv_mg -# define Perl_sv_copypv sv_copypv -# define Perl_sv_copypv_nomg sv_copypv_nomg -# define Perl_sv_eq sv_eq -# define Perl_sv_force_normal sv_force_normal -# define Perl_sv_insert sv_insert -# define Perl_sv_mortalcopy sv_mortalcopy -# define Perl_sv_numeq sv_numeq -# define Perl_sv_pv sv_pv -# define Perl_sv_pvbyte sv_pvbyte -# define Perl_sv_pvn_force sv_pvn_force -# define Perl_sv_pvutf8 sv_pvutf8 -# define Perl_sv_setsv sv_setsv -# define Perl_sv_streq sv_streq -# define Perl_sv_taint sv_taint -# define Perl_sv_unref sv_unref -# define Perl_sv_usepvn sv_usepvn -# define Perl_sv_usepvn_mg sv_usepvn_mg -# define Perl_sv_utf8_downgrade sv_utf8_downgrade -# define Perl_sv_utf8_downgrade_nomg sv_utf8_downgrade_nomg -# define Perl_sv_utf8_upgrade sv_utf8_upgrade -# define Perl_sv_utf8_upgrade_flags sv_utf8_upgrade_flags -# define Perl_sv_utf8_upgrade_nomg sv_utf8_upgrade_nomg -# define Perl_to_uni_fold to_uni_fold -# define Perl_uv_to_utf8_msgs uv_to_utf8_msgs -# define Perl_uvchr_to_utf8 uvchr_to_utf8 -# define Perl_uvchr_to_utf8_flags uvchr_to_utf8_flags -# define Perl_uvchr_to_utf8_flags_msgs uvchr_to_utf8_flags_msgs -# define Perl_uvoffuni_to_utf8_flags uvoffuni_to_utf8_flags -# define Perl_whichsig whichsig -# if defined(PERL_DONT_CREATE_GVSV) -# define Perl_gv_SVadd gv_SVadd -# endif -# if !defined(USE_ITHREADS) -# define Perl_CopFILEGV_set CopFILEGV_set -# endif -# endif /* !defined(USE_THREADS) */ +# endif # if defined(VMS) || defined(WIN32) # define do_aspawn(a,b,c) Perl_do_aspawn(aTHX_ a,b,c) # define do_spawn(a) Perl_do_spawn(aTHX_ a) diff --git a/long_names.c b/long_names.c new file mode 100644 index 000000000000..10e1a092dd66 --- /dev/null +++ b/long_names.c @@ -0,0 +1,893 @@ +/* -*- mode: C; buffer-read-only: t -*- + * + * long_names.c + * + * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, + * 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, + * 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022 + * by Larry Wall and others + * + * You may distribute under the terms of either the GNU General Public + * License or the Artistic License, as specified in the README file. + * + * !!!!!!! DO NOT EDIT THIS FILE !!!!!!! + * This file is built by regen/embed.pl from embed.fnc, intrpvar.h, + * perlvars.h, regen/opcodes, regen/embed.pl, regen/embed_lib.pl and + * regen/HeaderParser.pm. + * Any changes made here will be lost! + * + * Edit those files and run 'make regen_headers' to effect changes. + */ + + +/* This file expands to (nearly) nothing unless PERL_NO_SHORT_NAMES is + #defined. It contains function definitions for elements that are + otherwise macros */ + +#include "EXTERN.h" +#define PERL_IN_LONG_NAMES_C +#include "perl.h" + +#if ! defined(PERL_NO_SHORT_NAMES) + /* ..." warning: ISO C forbids an empty source file" + So make sure we have something in here by processing the headers + anyway. */ +#else + +void +Perl_CopFILEGV_set(pTHX_ COP *c, GV *gv) +{ + PERL_ARGS_ASSERT_PERL_COPFILEGV_SET; + CopFILEGV_set(c, gv); +} + +void +Perl_SvREFCNT_dec_set_NULL(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_PERL_SVREFCNT_DEC_SET_NULL; + SvREFCNT_dec_set_NULL(sv); +} + +bool +Perl_c9strict_utf8_to_uv(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p) +{ + PERL_ARGS_ASSERT_PERL_C9STRICT_UTF8_TO_UV; + return c9strict_utf8_to_uv(s, e, cp_p, advance_p); +} + +bool +Perl_do_aexec(pTHX_ NULLOK SV *really, NN SV **mark, NN SV **sp) +{ + PERL_ARGS_ASSERT_PERL_DO_AEXEC; + return do_aexec(really, mark, sp); +} + +bool +Perl_do_open(pTHX_ GV *gv, const char *name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp) +{ + PERL_ARGS_ASSERT_PERL_DO_OPEN; + return do_open(gv, name, len, as_raw, rawmode, rawperm, supplied_fp); +} + +bool +Perl_extended_utf8_to_uv(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p) +{ + PERL_ARGS_ASSERT_PERL_EXTENDED_UTF8_TO_UV; + return extended_utf8_to_uv(s, e, cp_p, advance_p); +} + +I32 +Perl_foldEQ_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2) +{ + PERL_ARGS_ASSERT_PERL_FOLDEQ_UTF8; + return foldEQ_utf8(s1, pe1, l1, u1, s2, pe2, l2, u2); +} + +GV * +Perl_gv_AVadd(pTHX_ GV *gv) +{ + PERL_ARGS_ASSERT_PERL_GV_AVADD; + return gv_AVadd(gv); +} + +GV * +Perl_gv_HVadd(pTHX_ GV *gv) +{ + PERL_ARGS_ASSERT_PERL_GV_HVADD; + return gv_HVadd(gv); +} + +GV * +Perl_gv_IOadd(pTHX_ GV *gv) +{ + PERL_ARGS_ASSERT_PERL_GV_IOADD; + return gv_IOadd(gv); +} + +GV * +Perl_gv_SVadd(pTHX_ GV *gv) +{ + PERL_ARGS_ASSERT_PERL_GV_SVADD; + return gv_SVadd(gv); +} + +void +Perl_gv_efullname3(pTHX_ SV *sv, const GV *gv, const char *prefix) +{ + PERL_ARGS_ASSERT_PERL_GV_EFULLNAME3; + gv_efullname3(sv, gv, prefix); +} + +GV * +Perl_gv_fetchmeth(pTHX_ HV *stash, const char *name, STRLEN len, I32 level) +{ + PERL_ARGS_ASSERT_PERL_GV_FETCHMETH; + return gv_fetchmeth(stash, name, len, level); +} + +GV * +Perl_gv_fetchmeth_autoload(pTHX_ HV *stash, const char *name, STRLEN len, I32 level) +{ + PERL_ARGS_ASSERT_PERL_GV_FETCHMETH_AUTOLOAD; + return gv_fetchmeth_autoload(stash, name, len, level); +} + +GV * +Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name) +{ + PERL_ARGS_ASSERT_PERL_GV_FETCHMETHOD; + return gv_fetchmethod(stash, name); +} + +void +Perl_gv_fullname3(pTHX_ SV *sv, const GV *gv, const char *prefix) +{ + PERL_ARGS_ASSERT_PERL_GV_FULLNAME3; + gv_fullname3(sv, gv, prefix); +} + +void +Perl_gv_init(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, int multi) +{ + PERL_ARGS_ASSERT_PERL_GV_INIT; + gv_init(gv, stash, name, len, multi); +} + +SV * +Perl_hv_delete(pTHX_ HV *hv, const char *key, I32 klen, I32 flags) +{ + PERL_ARGS_ASSERT_PERL_HV_DELETE; + return hv_delete(hv, key, klen, flags); +} + +SV * +Perl_hv_delete_ent(pTHX_ HV *hv, SV *keysv, I32 flags, U32 hash) +{ + PERL_ARGS_ASSERT_PERL_HV_DELETE_ENT; + return hv_delete_ent(hv, keysv, flags, hash); +} + +bool +Perl_hv_exists(pTHX_ HV *hv, const char *key, I32 klen) +{ + PERL_ARGS_ASSERT_PERL_HV_EXISTS; + return hv_exists(hv, key, klen); +} + +bool +Perl_hv_exists_ent(pTHX_ HV *hv, SV *keysv, U32 hash) +{ + PERL_ARGS_ASSERT_PERL_HV_EXISTS_ENT; + return hv_exists_ent(hv, keysv, hash); +} + +SV ** +Perl_hv_fetch(pTHX_ HV *hv, const char *key, I32 klen, I32 lval) +{ + PERL_ARGS_ASSERT_PERL_HV_FETCH; + return hv_fetch(hv, key, klen, lval); +} + +HE * +Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, U32 hash) +{ + PERL_ARGS_ASSERT_PERL_HV_FETCH_ENT; + return hv_fetch_ent(hv, keysv, lval, hash); +} + +HE * +Perl_hv_iternext(pTHX_ HV *hv) +{ + PERL_ARGS_ASSERT_PERL_HV_ITERNEXT; + return hv_iternext(hv); +} + +void +Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how) +{ + PERL_ARGS_ASSERT_PERL_HV_MAGIC; + hv_magic(hv, gv, how); +} + +SV ** +Perl_hv_store(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash) +{ + PERL_ARGS_ASSERT_PERL_HV_STORE; + return hv_store(hv, key, klen, val, hash); +} + +HE * +Perl_hv_store_ent(pTHX_ HV *hv, SV *key, SV *val, U32 hash) +{ + PERL_ARGS_ASSERT_PERL_HV_STORE_ENT; + return hv_store_ent(hv, key, val, hash); +} + +SV ** +Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash, int flags) +{ + PERL_ARGS_ASSERT_PERL_HV_STORE_FLAGS; + return hv_store_flags(hv, key, klen, val, hash, flags); +} + +SV ** +Perl_hv_stores(pTHX_ HV *hv, const char * const key, SV *val) +{ + PERL_ARGS_ASSERT_PERL_HV_STORES; + return hv_stores(hv, key, val); +} + +void +Perl_hv_undef(pTHX_ HV *hv) +{ + PERL_ARGS_ASSERT_PERL_HV_UNDEF; + hv_undef(hv); +} + +I32 +Perl_ibcmp(pTHX_ const char *a, const char *b, I32 len) +{ + PERL_ARGS_ASSERT_PERL_IBCMP; + return ibcmp(a, b, len); +} + +I32 +Perl_ibcmp_locale(pTHX_ const char *a, const char *b, I32 len) +{ + PERL_ARGS_ASSERT_PERL_IBCMP_LOCALE; + return ibcmp_locale(a, b, len); +} + +I32 +Perl_ibcmp_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2) +{ + PERL_ARGS_ASSERT_PERL_IBCMP_UTF8; + return ibcmp_utf8(s1, pe1, l1, u1, s2, pe2, l2, u2); +} + +char * +Perl_instr(const char *big, const char *little) +{ + PERL_ARGS_ASSERT_PERL_INSTR; + return instr(big, little); +} + +bool +Perl_is_c9strict_utf8_string(const U8 *s, STRLEN len) +{ + PERL_ARGS_ASSERT_PERL_IS_C9STRICT_UTF8_STRING; + return is_c9strict_utf8_string(s, len); +} + +bool +Perl_is_c9strict_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep) +{ + PERL_ARGS_ASSERT_PERL_IS_C9STRICT_UTF8_STRING_LOC; + return is_c9strict_utf8_string_loc(s, len, ep); +} + +bool +Perl_is_strict_utf8_string(const U8 *s, STRLEN len) +{ + PERL_ARGS_ASSERT_PERL_IS_STRICT_UTF8_STRING; + return is_strict_utf8_string(s, len); +} + +bool +Perl_is_strict_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep) +{ + PERL_ARGS_ASSERT_PERL_IS_STRICT_UTF8_STRING_LOC; + return is_strict_utf8_string_loc(s, len, ep); +} + +STRLEN +Perl_is_utf8_char_buf(const U8 *buf, const U8 *buf_end) +{ + PERL_ARGS_ASSERT_PERL_IS_UTF8_CHAR_BUF; + return is_utf8_char_buf(buf, buf_end); +} + +bool +Perl_is_utf8_fixed_width_buf_flags(const U8 * const s, STRLEN len, const U32 flags) +{ + PERL_ARGS_ASSERT_PERL_IS_UTF8_FIXED_WIDTH_BUF_FLAGS; + return is_utf8_fixed_width_buf_flags(s, len, flags); +} + +bool +Perl_is_utf8_fixed_width_buf_loc_flags(const U8 * const s, STRLEN len, const U8 **ep, const U32 flags) +{ + PERL_ARGS_ASSERT_PERL_IS_UTF8_FIXED_WIDTH_BUF_LOC_FLAGS; + return is_utf8_fixed_width_buf_loc_flags(s, len, ep, flags); +} + +bool +Perl_is_utf8_string(const U8 *s, STRLEN len) +{ + PERL_ARGS_ASSERT_PERL_IS_UTF8_STRING; + return is_utf8_string(s, len); +} + +bool +Perl_is_utf8_string_loc(const U8 *s, const STRLEN len, const U8 **ep) +{ + PERL_ARGS_ASSERT_PERL_IS_UTF8_STRING_LOC; + return is_utf8_string_loc(s, len, ep); +} + +bool +Perl_is_utf8_string_loc_flags(const U8 *s, STRLEN len, const U8 **ep, const U32 flags) +{ + PERL_ARGS_ASSERT_PERL_IS_UTF8_STRING_LOC_FLAGS; + return is_utf8_string_loc_flags(s, len, ep, flags); +} + +bool +Perl_is_utf8_valid_partial_char(const U8 * const s0, const U8 * const e) +{ + PERL_ARGS_ASSERT_PERL_IS_UTF8_VALID_PARTIAL_CHAR; + return is_utf8_valid_partial_char(s0, e); +} + +I32 +Perl_my_lstat(pTHX_ ) +{ + PERL_ARGS_ASSERT_PERL_MY_LSTAT; + return my_lstat(); +} + +I32 +Perl_my_stat(pTHX_ ) +{ + PERL_ARGS_ASSERT_PERL_MY_STAT; + return my_stat(); +} + +CV * +Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block) +{ + PERL_ARGS_ASSERT_PERL_NEWATTRSUB; + return newATTRSUB(floor, o, proto, attrs, block); +} + +AV * +Perl_newAV(pTHX_ ) +{ + PERL_ARGS_ASSERT_PERL_NEWAV; + return newAV(); +} + +AV * +Perl_newAV_alloc_x(pTHX_ SSize_t size) +{ + PERL_ARGS_ASSERT_PERL_NEWAV_ALLOC_X; + return newAV_alloc_x(size); +} + +AV * +Perl_newAV_alloc_xz(pTHX_ SSize_t size) +{ + PERL_ARGS_ASSERT_PERL_NEWAV_ALLOC_XZ; + return newAV_alloc_xz(size); +} + +AV * +Perl_newAV_mortal(pTHX_ ) +{ + PERL_ARGS_ASSERT_PERL_NEWAV_MORTAL; + return newAV_mortal(); +} + +GV * +Perl_newGVgen(pTHX_ const char *pack) +{ + PERL_ARGS_ASSERT_PERL_NEWGVGEN; + return newGVgen(pack); +} + +HV * +Perl_newHV(pTHX_ ) +{ + PERL_ARGS_ASSERT_PERL_NEWHV; + return newHV(); +} + +IO * +Perl_newIO(pTHX_ ) +{ + PERL_ARGS_ASSERT_PERL_NEWIO; + return newIO(); +} + +CV * +Perl_newSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *block) +{ + PERL_ARGS_ASSERT_PERL_NEWSUB; + return newSUB(floor, o, proto, block); +} + +SV * +Perl_newSVsv(pTHX_ SV * const old) +{ + PERL_ARGS_ASSERT_PERL_NEWSVSV; + return newSVsv(old); +} + +SV * +Perl_newSVsv_nomg(pTHX_ SV * const old) +{ + PERL_ARGS_ASSERT_PERL_NEWSVSV_NOMG; + return newSVsv_nomg(old); +} + +OP * +Perl_op_lvalue(pTHX_ OP *o, I32 type) +{ + PERL_ARGS_ASSERT_PERL_OP_LVALUE; + return op_lvalue(o, type); +} + +const char * const +Perl_phase_name(pTHX_ enum perl_phase) +{ + PERL_ARGS_ASSERT_PERL_PHASE_NAME; + return phase_name(perl_phase); +} + +void +Perl_resume_compcv_and_save(pTHX_ struct suspended_compcv *buffer) +{ + PERL_ARGS_ASSERT_PERL_RESUME_COMPCV_AND_SAVE; + resume_compcv_and_save(buffer); +} + +void +Perl_resume_compcv_final(pTHX_ struct suspended_compcv *buffer) +{ + PERL_ARGS_ASSERT_PERL_RESUME_COMPCV_FINAL; + resume_compcv_final(buffer); +} + +void +Perl_save_aelem(pTHX_ AV *av, SSize_t idx, SV **sptr) +{ + PERL_ARGS_ASSERT_PERL_SAVE_AELEM; + save_aelem(av, idx, sptr); +} + +void +Perl_save_freeop(pTHX_ OP *o) +{ + PERL_ARGS_ASSERT_PERL_SAVE_FREEOP; + save_freeop(o); +} + +void +Perl_save_freepv(pTHX_ char *pv) +{ + PERL_ARGS_ASSERT_PERL_SAVE_FREEPV; + save_freepv(pv); +} + +void +Perl_save_freesv(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_PERL_SAVE_FREESV; + save_freesv(sv); +} + +void +Perl_save_helem(pTHX_ HV *hv, SV *key, SV **sptr) +{ + PERL_ARGS_ASSERT_PERL_SAVE_HELEM; + save_helem(hv, key, sptr); +} + +void +Perl_save_mortalizesv(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_PERL_SAVE_MORTALIZESV; + save_mortalizesv(sv); +} + +void +Perl_save_op(pTHX_ ) +{ + PERL_ARGS_ASSERT_PERL_SAVE_OP; + save_op(); +} + +bool +Perl_strict_utf8_to_uv(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p) +{ + PERL_ARGS_ASSERT_PERL_STRICT_UTF8_TO_UV; + return strict_utf8_to_uv(s, e, cp_p, advance_p); +} + +bool +Perl_sv_2bool(pTHX_ SV * const sv) +{ + PERL_ARGS_ASSERT_PERL_SV_2BOOL; + return sv_2bool(sv); +} + +IV +Perl_sv_2iv(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_PERL_SV_2IV; + return sv_2iv(sv); +} + +char * +Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp) +{ + PERL_ARGS_ASSERT_PERL_SV_2PV; + return sv_2pv(sv, lp); +} + +char * +Perl_sv_2pv_nolen(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_PERL_SV_2PV_NOLEN; + return sv_2pv_nolen(sv); +} + +char * +Perl_sv_2pvbyte(pTHX_ SV *sv, STRLEN * const lp) +{ + PERL_ARGS_ASSERT_PERL_SV_2PVBYTE; + return sv_2pvbyte(sv, lp); +} + +char * +Perl_sv_2pvbyte_nolen(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_PERL_SV_2PVBYTE_NOLEN; + return sv_2pvbyte_nolen(sv); +} + +char * +Perl_sv_2pvutf8(pTHX_ SV *sv, STRLEN * const lp) +{ + PERL_ARGS_ASSERT_PERL_SV_2PVUTF8; + return sv_2pvutf8(sv, lp); +} + +char * +Perl_sv_2pvutf8_nolen(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_PERL_SV_2PVUTF8_NOLEN; + return sv_2pvutf8_nolen(sv); +} + +UV +Perl_sv_2uv(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_PERL_SV_2UV; + return sv_2uv(sv); +} + +void +Perl_sv_catpvn(pTHX_ SV * const dsv, const char *sstr, STRLEN len) +{ + PERL_ARGS_ASSERT_PERL_SV_CATPVN; + sv_catpvn(dsv, sstr, len); +} + +void +Perl_sv_catpvn_mg(pTHX_ SV * const dsv, const char *sstr, STRLEN len) +{ + PERL_ARGS_ASSERT_PERL_SV_CATPVN_MG; + sv_catpvn_mg(dsv, sstr, len); +} + +void +Perl_sv_catsv(pTHX_ SV * const dsv, SV * const sstr) +{ + PERL_ARGS_ASSERT_PERL_SV_CATSV; + sv_catsv(dsv, sstr); +} + +void +Perl_sv_catsv_mg(pTHX_ SV * const dsv, SV * const sstr) +{ + PERL_ARGS_ASSERT_PERL_SV_CATSV_MG; + sv_catsv_mg(dsv, sstr); +} + +char * +Perl_sv_collxfrm(pTHX_ SV * const sv, STRLEN * const nxp) +{ + PERL_ARGS_ASSERT_PERL_SV_COLLXFRM; + return sv_collxfrm(sv, nxp); +} + +void +Perl_sv_copypv(pTHX_ SV * const dsv, SV * const ssv) +{ + PERL_ARGS_ASSERT_PERL_SV_COPYPV; + sv_copypv(dsv, ssv); +} + +void +Perl_sv_copypv_nomg(pTHX_ SV * const dsv, SV * const ssv) +{ + PERL_ARGS_ASSERT_PERL_SV_COPYPV_NOMG; + sv_copypv_nomg(dsv, ssv); +} + +I32 +Perl_sv_eq(pTHX_ SV *sv1, SV *sv2) +{ + PERL_ARGS_ASSERT_PERL_SV_EQ; + return sv_eq(sv1, sv2); +} + +void +Perl_sv_force_normal(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_PERL_SV_FORCE_NORMAL; + sv_force_normal(sv); +} + +void +Perl_sv_insert(pTHX_ SV * const bigstr, const STRLEN offset, const STRLEN len, const char * const little, const STRLEN littlelen) +{ + PERL_ARGS_ASSERT_PERL_SV_INSERT; + sv_insert(bigstr, offset, len, little, littlelen); +} + +SV * +Perl_sv_mortalcopy(pTHX_ SV * const oldsv) +{ + PERL_ARGS_ASSERT_PERL_SV_MORTALCOPY; + return sv_mortalcopy(oldsv); +} + +bool +Perl_sv_numeq(pTHX_ SV *sv1, SV *sv2) +{ + PERL_ARGS_ASSERT_PERL_SV_NUMEQ; + return sv_numeq(sv1, sv2); +} + +char * +Perl_sv_pv(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_PERL_SV_PV; + return sv_pv(sv); +} + +char * +Perl_sv_pvbyte(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_PERL_SV_PVBYTE; + return sv_pvbyte(sv); +} + +char * +Perl_sv_pvn_force(pTHX_ SV *sv, STRLEN *lp) +{ + PERL_ARGS_ASSERT_PERL_SV_PVN_FORCE; + return sv_pvn_force(sv, lp); +} + +char * +Perl_sv_pvutf8(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_PERL_SV_PVUTF8; + return sv_pvutf8(sv); +} + +void +Perl_sv_setsv(pTHX_ SV *dsv, SV *ssv) +{ + PERL_ARGS_ASSERT_PERL_SV_SETSV; + sv_setsv(dsv, ssv); +} + +bool +Perl_sv_streq(pTHX_ SV *sv1, SV *sv2) +{ + PERL_ARGS_ASSERT_PERL_SV_STREQ; + return sv_streq(sv1, sv2); +} + +void +Perl_sv_taint(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_PERL_SV_TAINT; + sv_taint(sv); +} + +void +Perl_sv_unref(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_PERL_SV_UNREF; + sv_unref(sv); +} + +void +Perl_sv_usepvn(pTHX_ SV *sv, char *ptr, STRLEN len) +{ + PERL_ARGS_ASSERT_PERL_SV_USEPVN; + sv_usepvn(sv, ptr, len); +} + +void +Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len) +{ + PERL_ARGS_ASSERT_PERL_SV_USEPVN_MG; + sv_usepvn_mg(sv, ptr, len); +} + +bool +Perl_sv_utf8_downgrade(pTHX_ SV * const sv, const bool fail_ok) +{ + PERL_ARGS_ASSERT_PERL_SV_UTF8_DOWNGRADE; + return sv_utf8_downgrade(sv, fail_ok); +} + +bool +Perl_sv_utf8_downgrade_nomg(pTHX_ SV * const sv, const bool fail_ok) +{ + PERL_ARGS_ASSERT_PERL_SV_UTF8_DOWNGRADE_NOMG; + return sv_utf8_downgrade_nomg(sv, fail_ok); +} + +STRLEN +Perl_sv_utf8_upgrade(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_PERL_SV_UTF8_UPGRADE; + return sv_utf8_upgrade(sv); +} + +STRLEN +Perl_sv_utf8_upgrade_flags(pTHX_ SV * const sv, const I32 flags) +{ + PERL_ARGS_ASSERT_PERL_SV_UTF8_UPGRADE_FLAGS; + return sv_utf8_upgrade_flags(sv, flags); +} + +STRLEN +Perl_sv_utf8_upgrade_nomg(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_PERL_SV_UTF8_UPGRADE_NOMG; + return sv_utf8_upgrade_nomg(sv); +} + +UV +Perl_to_uni_fold(pTHX_ UV c, U8 *p, STRLEN *lenp) +{ + PERL_ARGS_ASSERT_PERL_TO_UNI_FOLD; + return to_uni_fold(c, p, lenp); +} + +U8 * +Perl_utf8_hop_back(const U8 *s, SSize_t off, const U8 * const start) +{ + PERL_ARGS_ASSERT_PERL_UTF8_HOP_BACK; + return utf8_hop_back(s, off, start); +} + +U8 * +Perl_utf8_hop_forward(const U8 *s, SSize_t off, const U8 * const end) +{ + PERL_ARGS_ASSERT_PERL_UTF8_HOP_FORWARD; + return utf8_hop_forward(s, off, end); +} + +U8 * +Perl_utf8_hop_safe(const U8 *s, SSize_t off, const U8 * const start, const U8 * const end) +{ + PERL_ARGS_ASSERT_PERL_UTF8_HOP_SAFE; + return utf8_hop_safe(s, off, start, end); +} + +bool +Perl_utf8_to_uv(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p) +{ + PERL_ARGS_ASSERT_PERL_UTF8_TO_UV; + return utf8_to_uv(s, e, cp_p, advance_p); +} + +bool +Perl_utf8_to_uv_errors(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p, U32 flags, U32 *errors) +{ + PERL_ARGS_ASSERT_PERL_UTF8_TO_UV_ERRORS; + return utf8_to_uv_errors(s, e, cp_p, advance_p, flags, errors); +} + +bool +Perl_utf8_to_uv_flags(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p, U32 flags) +{ + PERL_ARGS_ASSERT_PERL_UTF8_TO_UV_FLAGS; + return utf8_to_uv_flags(s, e, cp_p, advance_p, flags); +} + +UV +Perl_utf8n_to_uvchr(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags) +{ + PERL_ARGS_ASSERT_PERL_UTF8N_TO_UVCHR; + return utf8n_to_uvchr(s, curlen, retlen, flags); +} + +UV +Perl_utf8n_to_uvchr_error(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 *errors) +{ + PERL_ARGS_ASSERT_PERL_UTF8N_TO_UVCHR_ERROR; + return utf8n_to_uvchr_error(s, curlen, retlen, flags, errors); +} + +U8 * +Perl_uv_to_utf8_msgs(pTHX_ U8 *d, UV uv, UV flags, HV **msgs) +{ + PERL_ARGS_ASSERT_PERL_UV_TO_UTF8_MSGS; + return uv_to_utf8_msgs(d, uv, flags, msgs); +} + +U8 * +Perl_uvchr_to_utf8(pTHX_ U8 *d, UV uv) +{ + PERL_ARGS_ASSERT_PERL_UVCHR_TO_UTF8; + return uvchr_to_utf8(d, uv); +} + +U8 * +Perl_uvchr_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags) +{ + PERL_ARGS_ASSERT_PERL_UVCHR_TO_UTF8_FLAGS; + return uvchr_to_utf8_flags(d, uv, flags); +} + +U8 * +Perl_uvchr_to_utf8_flags_msgs(pTHX_ U8 *d, UV uv, UV flags, HV **msgs) +{ + PERL_ARGS_ASSERT_PERL_UVCHR_TO_UTF8_FLAGS_MSGS; + return uvchr_to_utf8_flags_msgs(d, uv, flags, msgs); +} + +U8 * +Perl_uvoffuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags) +{ + PERL_ARGS_ASSERT_PERL_UVOFFUNI_TO_UTF8_FLAGS; + return uvoffuni_to_utf8_flags(d, uv, flags); +} + +UV +Perl_valid_utf8_to_uvchr(const U8 *s, STRLEN *retlen) +{ + PERL_ARGS_ASSERT_PERL_VALID_UTF8_TO_UVCHR; + return valid_utf8_to_uvchr(s, retlen); +} + +I32 +Perl_whichsig(pTHX_ const char *sig) +{ + PERL_ARGS_ASSERT_PERL_WHICHSIG; + return whichsig(sig); +} + +#endif + +/* ex: set ro ft=c: */ diff --git a/mathoms.c b/mathoms.c index cfce11e6e33f..dd90bcbb66e5 100644 --- a/mathoms.c +++ b/mathoms.c @@ -35,9 +35,6 @@ * Perl_foo(...) had been replaced by a macro. But see the 'm' flag discussion * in embed.fnc for a better way to handle this. * - * This file can't just be cleaned out periodically, because that would break - * builds with -DPERL_NO_SHORT_NAMES - * * NOTE: ALL FUNCTIONS IN THIS FILE should have an entry with the 'b' flag in * embed.fnc. * diff --git a/proto.h b/proto.h index 28a9ae25fdb3..5f28fc5075c1 100644 --- a/proto.h +++ b/proto.h @@ -82,9 +82,6 @@ Perl_Slab_Free(pTHX_ void *op); #define PERL_ARGS_ASSERT_SLAB_FREE \ assert(op) -/* PERL_CALLCONV void -Perl_SvREFCNT_dec_set_NULL(pTHX_ SV *sv); */ - PERL_CALLCONV_NO_RET void Perl_abort_execution(pTHX_ SV *msg_sv, const char * const name) __attribute__noreturn__ @@ -339,9 +336,6 @@ Perl_bytes_to_utf8_free_me(pTHX_ const U8 *s, STRLEN *lenp, void **free_me); #define PERL_ARGS_ASSERT_BYTES_TO_UTF8_FREE_ME \ assert(s); assert(lenp) -/* PERL_CALLCONV bool -Perl_c9strict_utf8_to_uv(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p); */ - PERL_CALLCONV SSize_t Perl_call_argv(pTHX_ const char *sub_name, I32 flags, char **argv); #define PERL_ARGS_ASSERT_CALL_ARGV \ @@ -847,9 +841,6 @@ Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, const OP *o); #define PERL_ARGS_ASSERT_DO_OP_DUMP \ assert(file) -/* PERL_CALLCONV bool -Perl_do_open(pTHX_ GV *gv, const char *name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp); */ - PERL_CALLCONV bool Perl_do_open6(pTHX_ GV *gv, const char *oname, STRLEN len, PerlIO *supplied_fp, SV **svp, U32 num) __attribute__visibility__("hidden"); @@ -1043,9 +1034,6 @@ Perl_eval_sv(pTHX_ SV *sv, I32 flags); #define PERL_ARGS_ASSERT_EXPECTED_SIZE -/* PERL_CALLCONV bool -Perl_extended_utf8_to_uv(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p); */ - PERL_CALLCONV void Perl_fatal_warner(pTHX_ U32 err, const char *pat, ...) __attribute__format__(__printf__,pTHX_2,pTHX_3); @@ -1104,9 +1092,6 @@ Perl_find_script(pTHX_ const char *scriptname, bool dosearch, const char * const #define PERL_ARGS_ASSERT_FIND_SCRIPT \ assert(scriptname) -/* PERL_CALLCONV I32 -Perl_foldEQ_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2); */ - PERL_CALLCONV I32 Perl_foldEQ_utf8_flags(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2, U32 flags); #define PERL_ARGS_ASSERT_FOLDEQ_UTF8_FLAGS \ @@ -1292,15 +1277,6 @@ Perl_grok_oct(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result); #define PERL_ARGS_ASSERT_GROK_OCT \ assert(start); assert(len_p); assert(flags) -/* PERL_CALLCONV GV * -Perl_gv_AVadd(pTHX_ GV *gv); */ - -/* PERL_CALLCONV GV * -Perl_gv_HVadd(pTHX_ GV *gv); */ - -/* PERL_CALLCONV GV * -Perl_gv_IOadd(pTHX_ GV *gv); */ - PERL_CALLCONV GV * Perl_gv_add_by_type(pTHX_ GV *gv, svtype type); #define PERL_ARGS_ASSERT_GV_ADD_BY_TYPE @@ -1338,9 +1314,6 @@ PERL_CALLCONV void Perl_gv_dump(pTHX_ GV *gv); #define PERL_ARGS_ASSERT_GV_DUMP -/* PERL_CALLCONV void -Perl_gv_efullname3(pTHX_ SV *sv, const GV *gv, const char *prefix); */ - PERL_CALLCONV void Perl_gv_efullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain); #define PERL_ARGS_ASSERT_GV_EFULLNAME4 \ @@ -1356,12 +1329,6 @@ Perl_gv_fetchfile_flags(pTHX_ const char * const name, const STRLEN len, const U #define PERL_ARGS_ASSERT_GV_FETCHFILE_FLAGS \ assert(name) -/* PERL_CALLCONV GV * -Perl_gv_fetchmeth(pTHX_ HV *stash, const char *name, STRLEN len, I32 level); */ - -/* PERL_CALLCONV GV * -Perl_gv_fetchmeth_autoload(pTHX_ HV *stash, const char *name, STRLEN len, I32 level); */ - PERL_CALLCONV GV * Perl_gv_fetchmeth_pv(pTHX_ HV *stash, const char *name, I32 level, U32 flags); #define PERL_ARGS_ASSERT_GV_FETCHMETH_PV \ @@ -1392,9 +1359,6 @@ Perl_gv_fetchmeth_sv_autoload(pTHX_ HV *stash, SV *namesv, I32 level, U32 flags) #define PERL_ARGS_ASSERT_GV_FETCHMETH_SV_AUTOLOAD \ assert(namesv) -/* PERL_CALLCONV GV * -Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name); */ - PERL_CALLCONV GV * Perl_gv_fetchmethod_autoload(pTHX_ HV *stash, const char *name, I32 autoload); #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_AUTOLOAD \ @@ -1430,9 +1394,6 @@ Perl_gv_fetchsv(pTHX_ SV *name, I32 flags, const svtype sv_type); #define PERL_ARGS_ASSERT_GV_FETCHSV \ assert(name) -/* PERL_CALLCONV void -Perl_gv_fullname3(pTHX_ SV *sv, const GV *gv, const char *prefix); */ - PERL_CALLCONV void Perl_gv_fullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain); #define PERL_ARGS_ASSERT_GV_FULLNAME4 \ @@ -1444,9 +1405,6 @@ Perl_gv_handler(pTHX_ HV *stash, I32 id) #define PERL_ARGS_ASSERT_GV_HANDLER \ assert(!stash || SvTYPE(stash) == SVt_PVHV) -/* PERL_CALLCONV void -Perl_gv_init(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, int multi); */ - PERL_CALLCONV void Perl_gv_init_pv(pTHX_ GV *gv, HV *stash, const char *name, U32 flags); #define PERL_ARGS_ASSERT_GV_INIT_PV \ @@ -1546,12 +1504,6 @@ Perl_hv_delayfree_ent(pTHX_ HV *notused, HE *entry); #define PERL_ARGS_ASSERT_HV_DELAYFREE_ENT \ assert(!notused || SvTYPE(notused) == SVt_PVHV) -/* PERL_CALLCONV SV * -Perl_hv_delete(pTHX_ HV *hv, const char *key, I32 klen, I32 flags); */ - -/* PERL_CALLCONV SV * -Perl_hv_delete_ent(pTHX_ HV *hv, SV *keysv, I32 flags, U32 hash); */ - PERL_CALLCONV void Perl_hv_dump(pTHX_ HV *hv); #define PERL_ARGS_ASSERT_HV_DUMP \ @@ -1580,20 +1532,6 @@ Perl_hv_ename_delete(pTHX_ HV *hv, const char *name, U32 len, U32 flags) #define PERL_ARGS_ASSERT_HV_ENAME_DELETE \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(name) -/* PERL_CALLCONV bool -Perl_hv_exists(pTHX_ HV *hv, const char *key, I32 klen) - __attribute__warn_unused_result__; */ - -/* PERL_CALLCONV bool -Perl_hv_exists_ent(pTHX_ HV *hv, SV *keysv, U32 hash) - __attribute__warn_unused_result__; */ - -/* PERL_CALLCONV SV ** -Perl_hv_fetch(pTHX_ HV *hv, const char *key, I32 klen, I32 lval); */ - -/* PERL_CALLCONV HE * -Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, U32 hash); */ - PERL_CALLCONV STRLEN Perl_hv_fill(pTHX_ HV * const hv); #define PERL_ARGS_ASSERT_HV_FILL \ @@ -1621,10 +1559,6 @@ Perl_hv_iterkeysv(pTHX_ HE *entry) #define PERL_ARGS_ASSERT_HV_ITERKEYSV \ assert(entry) -/* PERL_CALLCONV HE * -Perl_hv_iternext(pTHX_ HV *hv) - __attribute__warn_unused_result__; */ - PERL_CALLCONV HE * Perl_hv_iternext_flags(pTHX_ HV *hv, I32 flags) __attribute__warn_unused_result__; @@ -1648,9 +1582,6 @@ Perl_hv_ksplit(pTHX_ HV *hv, IV newmax); #define PERL_ARGS_ASSERT_HV_KSPLIT \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) -/* PERL_CALLCONV void -Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how); */ - PERL_CALLCONV void Perl_hv_name_set(pTHX_ HV *hv, const char *name, U32 len, U32 flags); #define PERL_ARGS_ASSERT_HV_NAME_SET \ @@ -1701,39 +1632,11 @@ Perl_hv_scalar(pTHX_ HV *hv) #define PERL_ARGS_ASSERT_HV_SCALAR \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) -/* PERL_CALLCONV SV ** -Perl_hv_store(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash); */ - -/* PERL_CALLCONV HE * -Perl_hv_store_ent(pTHX_ HV *hv, SV *key, SV *val, U32 hash); */ - -/* PERL_CALLCONV SV ** -Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash, int flags); */ - -/* PERL_CALLCONV SV ** -Perl_hv_stores(pTHX_ HV *hv, const char * const key, SV *val); */ - -/* PERL_CALLCONV void -Perl_hv_undef(pTHX_ HV *hv); */ - PERL_CALLCONV void Perl_hv_undef_flags(pTHX_ HV *hv, U32 flags); #define PERL_ARGS_ASSERT_HV_UNDEF_FLAGS \ assert(!hv || SvTYPE(hv) == SVt_PVHV) -/* PERL_CALLCONV I32 -Perl_ibcmp(pTHX_ const char *a, const char *b, I32 len) - __attribute__warn_unused_result__ - __attribute__pure__; */ - -/* PERL_CALLCONV I32 -Perl_ibcmp_locale(pTHX_ const char *a, const char *b, I32 len) - __attribute__warn_unused_result__ - __attribute__pure__; */ - -/* PERL_CALLCONV I32 -Perl_ibcmp_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2); */ - PERL_CALLCONV STRLEN Perl_infix_plugin_standard(pTHX_ char *operator_ptr, STRLEN operator_len, struct Perl_custom_infix **def); #define PERL_ARGS_ASSERT_INFIX_PLUGIN_STANDARD \ @@ -1784,11 +1687,6 @@ Perl_init_uniprops(pTHX) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_INIT_UNIPROPS -/* PERL_CALLCONV char * -Perl_instr(const char *big, const char *little) - __attribute__warn_unused_result__ - __attribute__pure__; */ - PERL_CALLCONV U32 Perl_intro_my(pTHX); #define PERL_ARGS_ASSERT_INTRO_MY @@ -1814,13 +1712,6 @@ Perl_io_close(pTHX_ IO *io, GV *gv, bool is_explicit, bool warn_on_fail) #define PERL_ARGS_ASSERT_IO_CLOSE \ assert(io) -/* PERL_CALLCONV bool -Perl_is_c9strict_utf8_string(const U8 *s, STRLEN len) - __attribute__warn_unused_result__; */ - -/* PERL_CALLCONV bool -Perl_is_c9strict_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep); */ - PERL_CALLCONV bool Perl_is_in_locale_category_(pTHX_ const bool compiling, const int category); #define PERL_ARGS_ASSERT_IS_IN_LOCALE_CATEGORY_ @@ -1830,13 +1721,6 @@ Perl_is_lvalue_sub(pTHX) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_LVALUE_SUB -/* PERL_CALLCONV bool -Perl_is_strict_utf8_string(const U8 *s, STRLEN len) - __attribute__warn_unused_result__; */ - -/* PERL_CALLCONV bool -Perl_is_strict_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep); */ - PERL_CALLCONV bool Perl_is_uni_FOO_(pTHX_ const U8 classnum, const UV c) __attribute__warn_unused_result__; @@ -1865,9 +1749,6 @@ Perl_is_utf8_FOO_(pTHX_ const U8 classnum, const U8 *p, const U8 * const e) #define PERL_ARGS_ASSERT_IS_UTF8_FOO_ \ assert(p); assert(e) -/* PERL_CALLCONV STRLEN -Perl_is_utf8_char_buf(const U8 *buf, const U8 *buf_end); */ - PERL_CALLCONV STRLEN Perl_is_utf8_char_helper_(const U8 * const s, const U8 *e, const U32 flags) __attribute__warn_unused_result__ @@ -1875,12 +1756,6 @@ Perl_is_utf8_char_helper_(const U8 * const s, const U8 *e, const U32 flags) #define PERL_ARGS_ASSERT_IS_UTF8_CHAR_HELPER_ \ assert(s); assert(e) -/* PERL_CALLCONV bool -Perl_is_utf8_fixed_width_buf_flags(const U8 * const s, STRLEN len, const U32 flags); */ - -/* PERL_CALLCONV bool -Perl_is_utf8_fixed_width_buf_loc_flags(const U8 * const s, STRLEN len, const U8 **ep, const U32 flags); */ - PERL_CALLCONV Size_t Perl_is_utf8_perl_idcont_(pTHX_ const U8 *p, const U8 * const e) __attribute__warn_unused_result__; @@ -1893,21 +1768,6 @@ Perl_is_utf8_perl_idstart_(pTHX_ const U8 *p, const U8 * const e) #define PERL_ARGS_ASSERT_IS_UTF8_PERL_IDSTART_ \ assert(p); assert(e) -/* PERL_CALLCONV bool -Perl_is_utf8_string(const U8 *s, STRLEN len) - __attribute__warn_unused_result__; */ - -/* PERL_CALLCONV bool -Perl_is_utf8_string_loc(const U8 *s, const STRLEN len, const U8 **ep); */ - -/* PERL_CALLCONV bool -Perl_is_utf8_string_loc_flags(const U8 *s, STRLEN len, const U8 **ep, const U32 flags); */ - -/* PERL_CALLCONV bool -Perl_is_utf8_valid_partial_char(const U8 * const s0, const U8 * const e) - __attribute__warn_unused_result__ - __attribute__pure__; */ - PERL_CALLCONV bool Perl_isinfnan(NV nv) __attribute__warn_unused_result__ @@ -2741,35 +2601,16 @@ Perl_newASSIGNOP(pTHX_ I32 flags, OP *left, I32 optype, OP *right) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWASSIGNOP -/* PERL_CALLCONV CV * -Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block); */ - PERL_CALLCONV CV * Perl_newATTRSUB_x(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block, bool o_is_gv); #define PERL_ARGS_ASSERT_NEWATTRSUB_X -/* PERL_CALLCONV AV * -Perl_newAV(pTHX) - __attribute__warn_unused_result__; */ - PERL_CALLCONV OP * Perl_newAVREF(pTHX_ OP *o) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWAVREF \ assert(o) -/* PERL_CALLCONV AV * -Perl_newAV_alloc_x(pTHX_ SSize_t size) - __attribute__warn_unused_result__; */ - -/* PERL_CALLCONV AV * -Perl_newAV_alloc_xz(pTHX_ SSize_t size) - __attribute__warn_unused_result__; */ - -/* PERL_CALLCONV AV * -Perl_newAV_mortal(pTHX) - __attribute__warn_unused_result__; */ - PERL_CALLCONV AV * Perl_newAVav(pTHX_ AV *oav) __attribute__warn_unused_result__; @@ -2851,19 +2692,12 @@ Perl_newGVREF(pTHX_ I32 type, OP *o) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWGVREF -/* PERL_CALLCONV GV * -Perl_newGVgen(pTHX_ const char *pack); */ - PERL_CALLCONV GV * Perl_newGVgen_flags(pTHX_ const char *pack, U32 flags) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWGVGEN_FLAGS \ assert(pack) -/* PERL_CALLCONV HV * -Perl_newHV(pTHX) - __attribute__warn_unused_result__; */ - PERL_CALLCONV OP * Perl_newHVREF(pTHX_ OP *o) __attribute__warn_unused_result__; @@ -2876,10 +2710,6 @@ Perl_newHVhv(pTHX_ HV *ohv) #define PERL_ARGS_ASSERT_NEWHVHV \ assert(!ohv || SvTYPE(ohv) == SVt_PVHV) -/* PERL_CALLCONV IO * -Perl_newIO(pTHX) - __attribute__warn_unused_result__; */ - PERL_CALLCONV OP * Perl_newLISTOP(pTHX_ I32 type, I32 flags, OP *first, OP *last) __attribute__warn_unused_result__; @@ -2995,9 +2825,6 @@ Perl_newSTUB(pTHX_ GV *gv, bool fake) #define PERL_ARGS_ASSERT_NEWSTUB \ assert(gv) -/* PERL_CALLCONV CV * -Perl_newSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *block); */ - PERL_CALLCONV SV * Perl_newSV(pTHX_ const STRLEN len) __attribute__warn_unused_result__; @@ -3099,20 +2926,12 @@ Perl_newSVrv(pTHX_ SV * const rv, const char * const classname); #define PERL_ARGS_ASSERT_NEWSVRV \ assert(rv) -/* PERL_CALLCONV SV * -Perl_newSVsv(pTHX_ SV * const old) - __attribute__warn_unused_result__; */ - PERL_CALLCONV SV * Perl_newSVsv_flags_NN(pTHX_ SV * const old, I32 flags) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWSVSV_FLAGS_NN \ assert(old) -/* PERL_CALLCONV SV * -Perl_newSVsv_nomg(pTHX_ SV * const old) - __attribute__warn_unused_result__; */ - PERL_CALLCONV SV * Perl_newSVuv(pTHX_ const UV u) __attribute__warn_unused_result__; @@ -3280,9 +3099,6 @@ Perl_op_linklist(pTHX_ OP *o); #define PERL_ARGS_ASSERT_OP_LINKLIST \ assert(o) -/* PERL_CALLCONV OP * -Perl_op_lvalue(pTHX_ OP *o, I32 type); */ - PERL_CALLCONV OP * Perl_op_lvalue_flags(pTHX_ OP *o, I32 type, U32 flags); #define PERL_ARGS_ASSERT_OP_LVALUE_FLAGS @@ -3562,9 +3378,6 @@ PERL_CALLCONV Signal_t Perl_perly_sighandler(int sig, Siginfo_t *info, void *uap, bool safe); #define PERL_ARGS_ASSERT_PERLY_SIGHANDLER -/* PERL_CALLCONV const char * const -Perl_phase_name(pTHX_ enum perl_phase); */ - PERL_CALLCONV void Perl_pmop_dump(pTHX_ PMOP *pm); #define PERL_ARGS_ASSERT_PMOP_DUMP @@ -3866,12 +3679,6 @@ Perl_resume_compcv(pTHX_ struct suspended_compcv *buffer, bool save); #define PERL_ARGS_ASSERT_RESUME_COMPCV \ assert(buffer) -/* PERL_CALLCONV void -Perl_resume_compcv_and_save(pTHX_ struct suspended_compcv *buffer); */ - -/* PERL_CALLCONV void -Perl_resume_compcv_final(pTHX_ struct suspended_compcv *buffer); */ - PERL_CALLCONV char * Perl_rninstr(const char *big, const char *bigend, const char *little, const char *lend) __attribute__warn_unused_result__ @@ -3972,9 +3779,6 @@ Perl_save_adelete(pTHX_ AV *av, SSize_t key); #define PERL_ARGS_ASSERT_SAVE_ADELETE \ assert(av); assert(SvTYPE(av) == SVt_PVAV) -/* PERL_CALLCONV void -Perl_save_aelem(pTHX_ AV *av, SSize_t idx, SV **sptr); */ - PERL_CALLCONV void Perl_save_aelem_flags(pTHX_ AV *av, SSize_t idx, SV **sptr, const U32 flags); #define PERL_ARGS_ASSERT_SAVE_AELEM_FLAGS \ @@ -4018,20 +3822,11 @@ PERL_CALLCONV void Perl_save_destructor_x(pTHX_ DESTRUCTORFUNC_t f, void *p); #define PERL_ARGS_ASSERT_SAVE_DESTRUCTOR_X -/* PERL_CALLCONV void -Perl_save_freeop(pTHX_ OP *o); */ - -/* PERL_CALLCONV void -Perl_save_freepv(pTHX_ char *pv); */ - PERL_CALLCONV void Perl_save_freercpv(pTHX_ char *rcpv); #define PERL_ARGS_ASSERT_SAVE_FREERCPV \ assert(rcpv) -/* PERL_CALLCONV void -Perl_save_freesv(pTHX_ SV *sv); */ - PERL_CALLCONV void Perl_save_generic_pvref(pTHX_ char **str); #define PERL_ARGS_ASSERT_SAVE_GENERIC_PVREF \ @@ -4057,9 +3852,6 @@ Perl_save_hdelete(pTHX_ HV *hv, SV *keysv); #define PERL_ARGS_ASSERT_SAVE_HDELETE \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(keysv) -/* PERL_CALLCONV void -Perl_save_helem(pTHX_ HV *hv, SV *key, SV **sptr); */ - PERL_CALLCONV void Perl_save_helem_flags(pTHX_ HV *hv, SV *key, SV **sptr, const U32 flags); #define PERL_ARGS_ASSERT_SAVE_HELEM_FLAGS \ @@ -4089,12 +3881,6 @@ Perl_save_iv(pTHX_ IV *ivp); #define PERL_ARGS_ASSERT_SAVE_IV \ assert(ivp) -/* PERL_CALLCONV void -Perl_save_mortalizesv(pTHX_ SV *sv); */ - -/* PERL_CALLCONV void -Perl_save_op(pTHX); */ - PERL_CALLCONV void Perl_save_padsv_and_mortalize(pTHX_ PADOFFSET off); #define PERL_ARGS_ASSERT_SAVE_PADSV_AND_MORTALIZE @@ -4339,9 +4125,6 @@ Perl_str_to_version(pTHX_ SV *sv) #define PERL_ARGS_ASSERT_STR_TO_VERSION \ assert(sv) -/* PERL_CALLCONV bool -Perl_strict_utf8_to_uv(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p); */ - PERL_CALLCONV void Perl_sub_crush_depth(pTHX_ CV *cv) __attribute__visibility__("hidden"); @@ -4379,9 +4162,6 @@ Perl_suspend_compcv(pTHX_ struct suspended_compcv *buffer); #define PERL_ARGS_ASSERT_SUSPEND_COMPCV \ assert(buffer) -/* PERL_CALLCONV bool -Perl_sv_2bool(pTHX_ SV * const sv); */ - PERL_CALLCONV bool Perl_sv_2bool_flags(pTHX_ SV *sv, I32 flags); #define PERL_ARGS_ASSERT_SV_2BOOL_FLAGS \ @@ -4397,9 +4177,6 @@ Perl_sv_2io(pTHX_ SV * const sv); #define PERL_ARGS_ASSERT_SV_2IO \ assert(sv) -/* PERL_CALLCONV IV -Perl_sv_2iv(pTHX_ SV *sv); */ - PERL_CALLCONV IV Perl_sv_2iv_flags(pTHX_ SV * const sv, const I32 flags); #define PERL_ARGS_ASSERT_SV_2IV_FLAGS \ @@ -4420,45 +4197,21 @@ Perl_sv_2nv_flags(pTHX_ SV * const sv, const I32 flags); #define PERL_ARGS_ASSERT_SV_2NV_FLAGS \ assert(sv) -/* PERL_CALLCONV char * -Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp); */ - PERL_CALLCONV char * Perl_sv_2pv_flags(pTHX_ SV * const sv, STRLEN * const lp, const U32 flags); #define PERL_ARGS_ASSERT_SV_2PV_FLAGS \ assert(sv) -/* PERL_CALLCONV char * -Perl_sv_2pv_nolen(pTHX_ SV *sv) - __attribute__warn_unused_result__; */ - -/* PERL_CALLCONV char * -Perl_sv_2pvbyte(pTHX_ SV *sv, STRLEN * const lp); */ - PERL_CALLCONV char * Perl_sv_2pvbyte_flags(pTHX_ SV *sv, STRLEN * const lp, const U32 flags); #define PERL_ARGS_ASSERT_SV_2PVBYTE_FLAGS \ assert(sv) -/* PERL_CALLCONV char * -Perl_sv_2pvbyte_nolen(pTHX_ SV *sv) - __attribute__warn_unused_result__; */ - -/* PERL_CALLCONV char * -Perl_sv_2pvutf8(pTHX_ SV *sv, STRLEN * const lp); */ - PERL_CALLCONV char * Perl_sv_2pvutf8_flags(pTHX_ SV *sv, STRLEN * const lp, const U32 flags); #define PERL_ARGS_ASSERT_SV_2PVUTF8_FLAGS \ assert(sv) -/* PERL_CALLCONV char * -Perl_sv_2pvutf8_nolen(pTHX_ SV *sv) - __attribute__warn_unused_result__; */ - -/* PERL_CALLCONV UV -Perl_sv_2uv(pTHX_ SV *sv); */ - PERL_CALLCONV UV Perl_sv_2uv_flags(pTHX_ SV * const sv, const I32 flags); #define PERL_ARGS_ASSERT_SV_2UV_FLAGS \ @@ -4511,28 +4264,16 @@ Perl_sv_catpvf_mg(pTHX_ SV * const sv, const char * const pat, ...) #define PERL_ARGS_ASSERT_SV_CATPVF_MG \ assert(sv); assert(pat) -/* PERL_CALLCONV void -Perl_sv_catpvn(pTHX_ SV * const dsv, const char *sstr, STRLEN len); */ - PERL_CALLCONV void Perl_sv_catpvn_flags(pTHX_ SV * const dsv, const char *sstr, const STRLEN len, const I32 flags); #define PERL_ARGS_ASSERT_SV_CATPVN_FLAGS \ assert(dsv); assert(sstr) -/* PERL_CALLCONV void -Perl_sv_catpvn_mg(pTHX_ SV * const dsv, const char *sstr, STRLEN len); */ - -/* PERL_CALLCONV void -Perl_sv_catsv(pTHX_ SV * const dsv, SV * const sstr); */ - PERL_CALLCONV void Perl_sv_catsv_flags(pTHX_ SV * const dsv, SV * const sstr, const I32 flags); #define PERL_ARGS_ASSERT_SV_CATSV_FLAGS \ assert(dsv) -/* PERL_CALLCONV void -Perl_sv_catsv_mg(pTHX_ SV * const dsv, SV * const sstr); */ - PERL_CALLCONV void Perl_sv_chop(pTHX_ SV * const sv, const char * const ptr); #define PERL_ARGS_ASSERT_SV_CHOP \ @@ -4569,17 +4310,11 @@ PERL_CALLCONV I32 Perl_sv_cmp_locale_flags(pTHX_ SV * const sv1, SV * const sv2, const U32 flags); #define PERL_ARGS_ASSERT_SV_CMP_LOCALE_FLAGS -/* PERL_CALLCONV void -Perl_sv_copypv(pTHX_ SV * const dsv, SV * const ssv); */ - PERL_CALLCONV void Perl_sv_copypv_flags(pTHX_ SV * const dsv, SV * const ssv, const I32 flags); #define PERL_ARGS_ASSERT_SV_COPYPV_FLAGS \ assert(dsv); assert(ssv) -/* PERL_CALLCONV void -Perl_sv_copypv_nomg(pTHX_ SV * const dsv, SV * const ssv); */ - PERL_CALLCONV void Perl_sv_dec(pTHX_ SV * const sv); #define PERL_ARGS_ASSERT_SV_DEC @@ -4659,16 +4394,10 @@ PERL_CALLCONV void Perl_sv_dump_depth(pTHX_ SV *sv, I32 depth); #define PERL_ARGS_ASSERT_SV_DUMP_DEPTH -/* PERL_CALLCONV I32 -Perl_sv_eq(pTHX_ SV *sv1, SV *sv2); */ - PERL_CALLCONV I32 Perl_sv_eq_flags(pTHX_ SV *sv1, SV *sv2, const U32 flags); #define PERL_ARGS_ASSERT_SV_EQ_FLAGS -/* PERL_CALLCONV void -Perl_sv_force_normal(pTHX_ SV *sv); */ - PERL_CALLCONV void Perl_sv_force_normal_flags(pTHX_ SV * const sv, const U32 flags); #define PERL_ARGS_ASSERT_SV_FORCE_NORMAL_FLAGS \ @@ -4716,9 +4445,6 @@ PERL_CALLCONV void Perl_sv_inc_nomg(pTHX_ SV * const sv); #define PERL_ARGS_ASSERT_SV_INC_NOMG -/* PERL_CALLCONV void -Perl_sv_insert(pTHX_ SV * const bigstr, const STRLEN offset, const STRLEN len, const char * const little, const STRLEN littlelen); */ - PERL_CALLCONV void Perl_sv_insert_flags(pTHX_ SV * const bigstr, const STRLEN offset, const STRLEN len, const char *little, const STRLEN littlelen, const U32 flags); #define PERL_ARGS_ASSERT_SV_INSERT_FLAGS \ @@ -4769,10 +4495,6 @@ Perl_sv_magicext(pTHX_ SV * const sv, SV * const obj, const int how, const MGVTB #define PERL_ARGS_ASSERT_SV_MAGICEXT_MGLOB \ assert(sv) -/* PERL_CALLCONV SV * -Perl_sv_mortalcopy(pTHX_ SV * const oldsv) - __attribute__warn_unused_result__; */ - PERL_CALLCONV SV * Perl_sv_mortalcopy_flags(pTHX_ SV * const oldsv, U32 flags) __attribute__warn_unused_result__; @@ -4791,9 +4513,6 @@ PERL_CALLCONV void Perl_sv_nosharing(pTHX_ SV *sv); #define PERL_ARGS_ASSERT_SV_NOSHARING -/* PERL_CALLCONV bool -Perl_sv_numeq(pTHX_ SV *sv1, SV *sv2); */ - PERL_CALLCONV bool Perl_sv_numeq_flags(pTHX_ SV *sv1, SV *sv2, const U32 flags); #define PERL_ARGS_ASSERT_SV_NUMEQ_FLAGS @@ -4822,31 +4541,16 @@ Perl_sv_pos_u2b_flags(pTHX_ SV * const sv, STRLEN uoffset, STRLEN * const lenp, #define PERL_ARGS_ASSERT_SV_POS_U2B_FLAGS \ assert(sv) -/* PERL_CALLCONV char * -Perl_sv_pv(pTHX_ SV *sv) - __attribute__warn_unused_result__; */ - -/* PERL_CALLCONV char * -Perl_sv_pvbyte(pTHX_ SV *sv) - __attribute__warn_unused_result__; */ - PERL_CALLCONV char * Perl_sv_pvbyten_force(pTHX_ SV * const sv, STRLEN * const lp); #define PERL_ARGS_ASSERT_SV_PVBYTEN_FORCE \ assert(sv) -/* PERL_CALLCONV char * -Perl_sv_pvn_force(pTHX_ SV *sv, STRLEN *lp); */ - PERL_CALLCONV char * Perl_sv_pvn_force_flags(pTHX_ SV * const sv, STRLEN * const lp, const U32 flags); #define PERL_ARGS_ASSERT_SV_PVN_FORCE_FLAGS \ assert(sv) -/* PERL_CALLCONV char * -Perl_sv_pvutf8(pTHX_ SV *sv) - __attribute__warn_unused_result__; */ - PERL_CALLCONV char * Perl_sv_pvutf8n_force(pTHX_ SV * const sv, STRLEN * const lp); #define PERL_ARGS_ASSERT_SV_PVUTF8N_FORCE \ @@ -5045,9 +4749,6 @@ Perl_sv_setrv_noinc_mg(pTHX_ SV * const sv, SV * const ref); #define PERL_ARGS_ASSERT_SV_SETRV_NOINC_MG \ assert(sv); assert(ref) -/* PERL_CALLCONV void -Perl_sv_setsv(pTHX_ SV *dsv, SV *ssv); */ - PERL_CALLCONV void Perl_sv_setsv_flags(pTHX_ SV *dsv, SV *ssv, const I32 flags); #define PERL_ARGS_ASSERT_SV_SETSV_FLAGS \ @@ -5068,9 +4769,6 @@ Perl_sv_setuv_mg(pTHX_ SV * const sv, const UV u); #define PERL_ARGS_ASSERT_SV_SETUV_MG \ assert(sv) -/* PERL_CALLCONV bool -Perl_sv_streq(pTHX_ SV *sv1, SV *sv2); */ - PERL_CALLCONV bool Perl_sv_streq_flags(pTHX_ SV *sv1, SV *sv2, const U32 flags); #define PERL_ARGS_ASSERT_SV_STREQ_FLAGS @@ -5089,9 +4787,6 @@ PERL_CALLCONV SV * Perl_sv_string_from_errnum(pTHX_ int errnum, SV *tgtsv); #define PERL_ARGS_ASSERT_SV_STRING_FROM_ERRNUM -/* PERL_CALLCONV void -Perl_sv_taint(pTHX_ SV *sv); */ - PERL_CALLCONV bool Perl_sv_tainted(pTHX_ SV * const sv) __attribute__warn_unused_result__; @@ -5118,9 +4813,6 @@ Perl_sv_unmagicext(pTHX_ SV * const sv, const int type, const MGVTBL *vtbl); #define PERL_ARGS_ASSERT_SV_UNMAGICEXT \ assert(sv) -/* PERL_CALLCONV void -Perl_sv_unref(pTHX_ SV *sv); */ - PERL_CALLCONV void Perl_sv_unref_flags(pTHX_ SV * const ref, const U32 flags); #define PERL_ARGS_ASSERT_SV_UNREF_FLAGS \ @@ -5136,52 +4828,31 @@ Perl_sv_upgrade(pTHX_ SV * const sv, svtype new_type); #define PERL_ARGS_ASSERT_SV_UPGRADE \ assert(sv) -/* PERL_CALLCONV void -Perl_sv_usepvn(pTHX_ SV *sv, char *ptr, STRLEN len); */ - PERL_CALLCONV void Perl_sv_usepvn_flags(pTHX_ SV * const sv, char *ptr, const STRLEN len, const U32 flags); #define PERL_ARGS_ASSERT_SV_USEPVN_FLAGS \ assert(sv) -/* PERL_CALLCONV void -Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len); */ - PERL_CALLCONV bool Perl_sv_utf8_decode(pTHX_ SV * const sv); #define PERL_ARGS_ASSERT_SV_UTF8_DECODE \ assert(sv) -/* PERL_CALLCONV bool -Perl_sv_utf8_downgrade(pTHX_ SV * const sv, const bool fail_ok); */ - PERL_CALLCONV bool Perl_sv_utf8_downgrade_flags(pTHX_ SV * const sv, const bool fail_ok, const U32 flags); #define PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE_FLAGS \ assert(sv) -/* PERL_CALLCONV bool -Perl_sv_utf8_downgrade_nomg(pTHX_ SV * const sv, const bool fail_ok); */ - PERL_CALLCONV void Perl_sv_utf8_encode(pTHX_ SV * const sv); #define PERL_ARGS_ASSERT_SV_UTF8_ENCODE \ assert(sv) -/* PERL_CALLCONV STRLEN -Perl_sv_utf8_upgrade(pTHX_ SV *sv); */ - -/* PERL_CALLCONV STRLEN -Perl_sv_utf8_upgrade_flags(pTHX_ SV * const sv, const I32 flags); */ - PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade_flags_grow(pTHX_ SV * const sv, const I32 flags, STRLEN extra); #define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_FLAGS_GROW \ assert(sv) -/* PERL_CALLCONV STRLEN -Perl_sv_utf8_upgrade_nomg(pTHX_ SV *sv); */ - PERL_CALLCONV void Perl_sv_vcatpvf(pTHX_ SV * const sv, const char * const pat, va_list * const args); #define PERL_ARGS_ASSERT_SV_VCATPVF \ @@ -5263,9 +4934,6 @@ PERL_CALLCONV SSize_t Perl_tmps_grow_p(pTHX_ SSize_t ix); #define PERL_ARGS_ASSERT_TMPS_GROW_P -/* PERL_CALLCONV UV -Perl_to_uni_fold(pTHX_ UV c, U8 *p, STRLEN *lenp); */ - PERL_CALLCONV UV Perl_to_uni_fold_flags_(pTHX_ UV c, U8 *p, STRLEN *lenp, U8 flags); #define PERL_ARGS_ASSERT_TO_UNI_FOLD_FLAGS_ \ @@ -5347,18 +5015,6 @@ Perl_upg_version(pTHX_ SV *ver, bool qv); #define PERL_ARGS_ASSERT_UTF16_TO_UTF8_REVERSED \ assert(p); assert(d); assert(newlen) -/* PERL_CALLCONV U8 * -Perl_utf8_hop_back(const U8 *s, SSize_t off, const U8 * const start) - __attribute__warn_unused_result__; */ - -/* PERL_CALLCONV U8 * -Perl_utf8_hop_forward(const U8 *s, SSize_t off, const U8 * const end) - __attribute__warn_unused_result__; */ - -/* PERL_CALLCONV U8 * -Perl_utf8_hop_safe(const U8 *s, SSize_t off, const U8 * const start, const U8 * const end) - __attribute__warn_unused_result__; */ - PERL_CALLCONV STRLEN Perl_utf8_length(pTHX_ const U8 *s0, const U8 *e) __attribute__warn_unused_result__; @@ -5378,47 +5034,17 @@ Perl_utf8_to_bytes_(pTHX_ U8 **s_ptr, STRLEN *lenp, void **free_me, Perl_utf8_to #define PERL_ARGS_ASSERT_UTF8_TO_UTF16_BASE \ assert(s); assert(d); assert(newlen) -/* PERL_CALLCONV bool -Perl_utf8_to_uv(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p); */ - -/* PERL_CALLCONV bool -Perl_utf8_to_uv_errors(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p, U32 flags, U32 *errors); */ - -/* PERL_CALLCONV bool -Perl_utf8_to_uv_flags(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p, U32 flags); */ - PERL_CALLCONV bool Perl_utf8_to_uv_msgs_helper_(const U8 * const s0, const U8 * const e, UV *cp_p, Size_t *advance_p, U32 flags, U32 *errors, AV **msgs); #define PERL_ARGS_ASSERT_UTF8_TO_UV_MSGS_HELPER_ \ assert(s0); assert(e); assert(cp_p) -/* PERL_CALLCONV UV -Perl_utf8n_to_uvchr(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags); */ - -/* PERL_CALLCONV UV -Perl_utf8n_to_uvchr_error(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 *errors); */ - PERL_CALLCONV void Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_UTILIZE \ assert(idop) -/* PERL_CALLCONV U8 * -Perl_uv_to_utf8_msgs(pTHX_ U8 *d, UV uv, UV flags, HV **msgs); */ - -/* PERL_CALLCONV U8 * -Perl_uvchr_to_utf8(pTHX_ U8 *d, UV uv); */ - -/* PERL_CALLCONV U8 * -Perl_uvchr_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags); */ - -/* PERL_CALLCONV U8 * -Perl_uvchr_to_utf8_flags_msgs(pTHX_ U8 *d, UV uv, UV flags, HV **msgs); */ - -/* PERL_CALLCONV U8 * -Perl_uvoffuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags); */ - PERL_CALLCONV U8 * Perl_uvoffuni_to_utf8_flags_msgs(pTHX_ U8 *d, UV input_uv, const UV flags, HV **msgs); #define PERL_ARGS_ASSERT_UVOFFUNI_TO_UTF8_FLAGS_MSGS \ @@ -5438,10 +5064,6 @@ PERL_CALLCONV bool Perl_valid_identifier_sv(pTHX_ SV *sv); #define PERL_ARGS_ASSERT_VALID_IDENTIFIER_SV -/* PERL_CALLCONV UV -Perl_valid_utf8_to_uvchr(const U8 *s, STRLEN *retlen) - __attribute__warn_unused_result__; */ - #define PERL_ARGS_ASSERT_VALIDATE_PROTO \ assert(name) @@ -5560,9 +5182,6 @@ Perl_watch(pTHX_ char **addr) #define PERL_ARGS_ASSERT_WATCH \ assert(addr) -/* PERL_CALLCONV I32 -Perl_whichsig(pTHX_ const char *sig); */ - PERL_CALLCONV I32 Perl_whichsig_pv(pTHX_ const char *sig); #define PERL_ARGS_ASSERT_WHICHSIG_PV \ @@ -6291,9 +5910,13 @@ Perl_do_exec(pTHX_ const char *cmd) #endif #if defined(PERL_DONT_CREATE_GVSV) -/* PERL_CALLCONV GV * -Perl_gv_SVadd(pTHX_ GV *gv); */ +# if defined(PERL_NO_SHORT_NAMES) +PERL_CALLCONV GV * +Perl_gv_SVadd(pTHX_ GV *gv); +# define PERL_ARGS_ASSERT_GV_SVADD + +# endif #endif #if defined(PERL_IMPLICIT_SYS) PERL_CALLCONV PerlInterpreter * @@ -10640,111 +10263,716 @@ Perl_get_context(void) # endif #endif /* !defined(PERL_NO_INLINE_FUNCTIONS) */ -#if defined(PERL_RC_STACK) -# define PERL_ARGS_ASSERT_PP_WRAP \ - assert(real_pp_fn) - -PERL_CALLCONV int -Perl_runops_wrap(pTHX); -# define PERL_ARGS_ASSERT_RUNOPS_WRAP - +#if defined(PERL_NO_SHORT_NAMES) PERL_CALLCONV void -Perl_xs_wrap(pTHX_ XSUBADDR_t xsub, CV *cv); -# define PERL_ARGS_ASSERT_XS_WRAP \ - assert(xsub); assert(cv); \ - assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) - -# if defined(PERL_CORE) || defined(PERL_EXT) -PERL_CALLCONV OP * -Perl_pp_wrap(pTHX_ Perl_ppaddr_t real_pp_fn, I32 nargs, int nlists); -# endif -#endif /* defined(PERL_RC_STACK) */ -#if defined(PERL_USE_3ARG_SIGHANDLER) -PERL_CALLCONV Signal_t -Perl_csighandler(int sig, Siginfo_t *info, void *uap); -# define PERL_ARGS_ASSERT_CSIGHANDLER - -PERL_CALLCONV Signal_t -Perl_sighandler(int sig, Siginfo_t *info, void *uap) - __attribute__visibility__("hidden"); -# define PERL_ARGS_ASSERT_SIGHANDLER +Perl_SvREFCNT_dec_set_NULL(pTHX_ SV *sv); +# define PERL_ARGS_ASSERT_SVREFCNT_DEC_SET_NULL -#else /* if !defined(PERL_USE_3ARG_SIGHANDLER) */ -PERL_CALLCONV Signal_t -Perl_csighandler(int sig); -# define PERL_ARGS_ASSERT_CSIGHANDLER +PERL_CALLCONV bool +Perl_c9strict_utf8_to_uv(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p); +# define PERL_ARGS_ASSERT_C9STRICT_UTF8_TO_UV \ + assert(s); assert(e); assert(cp_p) -PERL_CALLCONV Signal_t -Perl_sighandler(int sig) - __attribute__visibility__("hidden"); -# define PERL_ARGS_ASSERT_SIGHANDLER +PERL_CALLCONV bool +Perl_do_open(pTHX_ GV *gv, const char *name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp); +# define PERL_ARGS_ASSERT_DO_OPEN \ + assert(gv); assert(name) -#endif /* !defined(PERL_USE_3ARG_SIGHANDLER) */ -#if defined(U64TYPE) +PERL_CALLCONV bool +Perl_extended_utf8_to_uv(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p); +# define PERL_ARGS_ASSERT_EXTENDED_UTF8_TO_UV \ + assert(s); assert(e); assert(cp_p) -#endif -#if defined(UNLINK_ALL_VERSIONS) PERL_CALLCONV I32 -Perl_unlnk(pTHX_ const char *f); -# define PERL_ARGS_ASSERT_UNLNK \ - assert(f) +Perl_foldEQ_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2); +# define PERL_ARGS_ASSERT_FOLDEQ_UTF8 \ + assert(s1); assert(s2) -#endif -#if defined(USE_C_BACKTRACE) -PERL_CALLCONV bool -Perl_dump_c_backtrace(pTHX_ PerlIO *fp, int max_depth, int skip); -# define PERL_ARGS_ASSERT_DUMP_C_BACKTRACE \ - assert(fp) +PERL_CALLCONV GV * +Perl_gv_AVadd(pTHX_ GV *gv); +# define PERL_ARGS_ASSERT_GV_AVADD -PERL_CALLCONV Perl_c_backtrace * -Perl_get_c_backtrace(pTHX_ int max_depth, int skip) - __attribute__visibility__("hidden"); -# define PERL_ARGS_ASSERT_GET_C_BACKTRACE +PERL_CALLCONV GV * +Perl_gv_HVadd(pTHX_ GV *gv); +# define PERL_ARGS_ASSERT_GV_HVADD -PERL_CALLCONV SV * -Perl_get_c_backtrace_dump(pTHX_ int max_depth, int skip); -# define PERL_ARGS_ASSERT_GET_C_BACKTRACE_DUMP +PERL_CALLCONV GV * +Perl_gv_IOadd(pTHX_ GV *gv); +# define PERL_ARGS_ASSERT_GV_IOADD -#endif /* defined(USE_C_BACKTRACE) */ -#if defined(USE_DTRACE) -# define PERL_ARGS_ASSERT_DTRACE_PROBE_CALL \ - assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) +PERL_CALLCONV void +Perl_gv_efullname3(pTHX_ SV *sv, const GV *gv, const char *prefix); +# define PERL_ARGS_ASSERT_GV_EFULLNAME3 \ + assert(sv); assert(gv) -# define PERL_ARGS_ASSERT_DTRACE_PROBE_LOAD \ +PERL_CALLCONV GV * +Perl_gv_fetchmeth(pTHX_ HV *stash, const char *name, STRLEN len, I32 level); +# define PERL_ARGS_ASSERT_GV_FETCHMETH \ assert(name) -# define PERL_ARGS_ASSERT_DTRACE_PROBE_OP \ - assert(op) +PERL_CALLCONV GV * +Perl_gv_fetchmeth_autoload(pTHX_ HV *stash, const char *name, STRLEN len, I32 level); +# define PERL_ARGS_ASSERT_GV_FETCHMETH_AUTOLOAD \ + assert(name) -# define PERL_ARGS_ASSERT_DTRACE_PROBE_PHASE +PERL_CALLCONV GV * +Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name); +# define PERL_ARGS_ASSERT_GV_FETCHMETHOD \ + assert(stash); assert(name) -# if defined(PERL_CORE) || defined(PERL_EXT) -PERL_CALLCONV void -Perl_dtrace_probe_call(pTHX_ CV *cv, bool is_call); -PERL_CALLCONV void -Perl_dtrace_probe_load(pTHX_ const char *name, bool is_loading); -PERL_CALLCONV void -Perl_dtrace_probe_op(pTHX_ const OP *op); PERL_CALLCONV void -Perl_dtrace_probe_phase(pTHX_ enum perl_phase phase); -# endif -#endif /* defined(USE_DTRACE) */ -#if defined(USE_ITHREADS) -PERL_CALLCONV PADOFFSET -Perl_alloccopstash(pTHX_ HV *hv); -# define PERL_ARGS_ASSERT_ALLOCCOPSTASH \ - assert(hv); assert(SvTYPE(hv) == SVt_PVHV) - -PERL_CALLCONV void * -Perl_any_dup(pTHX_ void *v, const PerlInterpreter *proto_perl) - __attribute__warn_unused_result__; -# define PERL_ARGS_ASSERT_ANY_DUP \ - assert(proto_perl) +Perl_gv_fullname3(pTHX_ SV *sv, const GV *gv, const char *prefix); +# define PERL_ARGS_ASSERT_GV_FULLNAME3 \ + assert(sv); assert(gv) PERL_CALLCONV void -Perl_clone_params_del(CLONE_PARAMS *param); -# define PERL_ARGS_ASSERT_CLONE_PARAMS_DEL \ - assert(param) +Perl_gv_init(pTHX_ GV *gv, HV *stash, const char *name, STRLEN len, int multi); +# define PERL_ARGS_ASSERT_GV_INIT \ + assert(gv); assert(!stash || SvTYPE(stash) == SVt_PVHV); assert(name) + +PERL_CALLCONV SV * +Perl_hv_delete(pTHX_ HV *hv, const char *key, I32 klen, I32 flags); +# define PERL_ARGS_ASSERT_HV_DELETE \ + assert(!hv || SvTYPE(hv) == SVt_PVHV); assert(key) + +PERL_CALLCONV SV * +Perl_hv_delete_ent(pTHX_ HV *hv, SV *keysv, I32 flags, U32 hash); +# define PERL_ARGS_ASSERT_HV_DELETE_ENT \ + assert(!hv || SvTYPE(hv) == SVt_PVHV); assert(keysv) + +PERL_CALLCONV bool +Perl_hv_exists(pTHX_ HV *hv, const char *key, I32 klen) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_HV_EXISTS \ + assert(!hv || SvTYPE(hv) == SVt_PVHV); assert(key) + +PERL_CALLCONV bool +Perl_hv_exists_ent(pTHX_ HV *hv, SV *keysv, U32 hash) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_HV_EXISTS_ENT \ + assert(!hv || SvTYPE(hv) == SVt_PVHV); assert(keysv) + +PERL_CALLCONV SV ** +Perl_hv_fetch(pTHX_ HV *hv, const char *key, I32 klen, I32 lval); +# define PERL_ARGS_ASSERT_HV_FETCH \ + assert(!hv || SvTYPE(hv) == SVt_PVHV); assert(key) + +PERL_CALLCONV HE * +Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, U32 hash); +# define PERL_ARGS_ASSERT_HV_FETCH_ENT \ + assert(!hv || SvTYPE(hv) == SVt_PVHV); assert(keysv) + +PERL_CALLCONV HE * +Perl_hv_iternext(pTHX_ HV *hv) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_HV_ITERNEXT \ + assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + +PERL_CALLCONV void +Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how); +# define PERL_ARGS_ASSERT_HV_MAGIC \ + assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + +PERL_CALLCONV SV ** +Perl_hv_store(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash); +# define PERL_ARGS_ASSERT_HV_STORE \ + assert(!hv || SvTYPE(hv) == SVt_PVHV) + +PERL_CALLCONV HE * +Perl_hv_store_ent(pTHX_ HV *hv, SV *key, SV *val, U32 hash); +# define PERL_ARGS_ASSERT_HV_STORE_ENT \ + assert(!hv || SvTYPE(hv) == SVt_PVHV) + +PERL_CALLCONV SV ** +Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash, int flags); +# define PERL_ARGS_ASSERT_HV_STORE_FLAGS \ + assert(!hv || SvTYPE(hv) == SVt_PVHV) + +PERL_CALLCONV SV ** +Perl_hv_stores(pTHX_ HV *hv, const char * const key, SV *val); +# define PERL_ARGS_ASSERT_HV_STORES \ + assert(!hv || SvTYPE(hv) == SVt_PVHV) + +PERL_CALLCONV void +Perl_hv_undef(pTHX_ HV *hv); +# define PERL_ARGS_ASSERT_HV_UNDEF \ + assert(!hv || SvTYPE(hv) == SVt_PVHV) + +PERL_CALLCONV I32 +Perl_ibcmp(pTHX_ const char *a, const char *b, I32 len) + __attribute__warn_unused_result__ + __attribute__pure__; +# define PERL_ARGS_ASSERT_IBCMP \ + assert(a); assert(b) + +PERL_CALLCONV I32 +Perl_ibcmp_locale(pTHX_ const char *a, const char *b, I32 len) + __attribute__warn_unused_result__ + __attribute__pure__; +# define PERL_ARGS_ASSERT_IBCMP_LOCALE \ + assert(a); assert(b) + +PERL_CALLCONV I32 +Perl_ibcmp_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2); +# define PERL_ARGS_ASSERT_IBCMP_UTF8 \ + assert(s1); assert(s2) + +PERL_CALLCONV char * +Perl_instr(const char *big, const char *little) + __attribute__warn_unused_result__ + __attribute__pure__; +# define PERL_ARGS_ASSERT_INSTR \ + assert(big); assert(little) + +PERL_CALLCONV bool +Perl_is_c9strict_utf8_string(const U8 *s, STRLEN len) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_IS_C9STRICT_UTF8_STRING \ + assert(s) + +PERL_CALLCONV bool +Perl_is_c9strict_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep); +# define PERL_ARGS_ASSERT_IS_C9STRICT_UTF8_STRING_LOC \ + assert(s); assert(ep) + +PERL_CALLCONV bool +Perl_is_strict_utf8_string(const U8 *s, STRLEN len) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_IS_STRICT_UTF8_STRING \ + assert(s) + +PERL_CALLCONV bool +Perl_is_strict_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep); +# define PERL_ARGS_ASSERT_IS_STRICT_UTF8_STRING_LOC \ + assert(s); assert(ep) + +PERL_CALLCONV STRLEN +Perl_is_utf8_char_buf(const U8 *buf, const U8 *buf_end); +# define PERL_ARGS_ASSERT_IS_UTF8_CHAR_BUF \ + assert(buf); assert(buf_end) + +PERL_CALLCONV bool +Perl_is_utf8_fixed_width_buf_flags(const U8 * const s, STRLEN len, const U32 flags); +# define PERL_ARGS_ASSERT_IS_UTF8_FIXED_WIDTH_BUF_FLAGS \ + assert(s) + +PERL_CALLCONV bool +Perl_is_utf8_fixed_width_buf_loc_flags(const U8 * const s, STRLEN len, const U8 **ep, const U32 flags); +# define PERL_ARGS_ASSERT_IS_UTF8_FIXED_WIDTH_BUF_LOC_FLAGS \ + assert(s) + +PERL_CALLCONV bool +Perl_is_utf8_string(const U8 *s, STRLEN len) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_IS_UTF8_STRING \ + assert(s) + +PERL_CALLCONV bool +Perl_is_utf8_string_loc(const U8 *s, const STRLEN len, const U8 **ep); +# define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOC \ + assert(s); assert(ep) + +PERL_CALLCONV bool +Perl_is_utf8_string_loc_flags(const U8 *s, STRLEN len, const U8 **ep, const U32 flags); +# define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOC_FLAGS \ + assert(s); assert(ep) + +PERL_CALLCONV bool +Perl_is_utf8_valid_partial_char(const U8 * const s0, const U8 * const e) + __attribute__warn_unused_result__ + __attribute__pure__; +# define PERL_ARGS_ASSERT_IS_UTF8_VALID_PARTIAL_CHAR \ + assert(s0); assert(e) + +PERL_CALLCONV CV * +Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block); +# define PERL_ARGS_ASSERT_NEWATTRSUB + +PERL_CALLCONV AV * +Perl_newAV(pTHX) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_NEWAV + +PERL_CALLCONV AV * +Perl_newAV_alloc_x(pTHX_ SSize_t size) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_NEWAV_ALLOC_X + +PERL_CALLCONV AV * +Perl_newAV_alloc_xz(pTHX_ SSize_t size) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_NEWAV_ALLOC_XZ + +PERL_CALLCONV AV * +Perl_newAV_mortal(pTHX) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_NEWAV_MORTAL + +PERL_CALLCONV GV * +Perl_newGVgen(pTHX_ const char *pack); +# define PERL_ARGS_ASSERT_NEWGVGEN \ + assert(pack) + +PERL_CALLCONV HV * +Perl_newHV(pTHX) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_NEWHV + +PERL_CALLCONV IO * +Perl_newIO(pTHX) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_NEWIO + +PERL_CALLCONV CV * +Perl_newSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *block); +# define PERL_ARGS_ASSERT_NEWSUB + +PERL_CALLCONV SV * +Perl_newSVsv(pTHX_ SV * const old) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_NEWSVSV + +PERL_CALLCONV SV * +Perl_newSVsv_nomg(pTHX_ SV * const old) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_NEWSVSV_NOMG + +PERL_CALLCONV OP * +Perl_op_lvalue(pTHX_ OP *o, I32 type); +# define PERL_ARGS_ASSERT_OP_LVALUE + +PERL_CALLCONV const char * const +Perl_phase_name(pTHX_ enum perl_phase); +# define PERL_ARGS_ASSERT_PHASE_NAME + +PERL_CALLCONV void +Perl_resume_compcv_and_save(pTHX_ struct suspended_compcv *buffer); +# define PERL_ARGS_ASSERT_RESUME_COMPCV_AND_SAVE \ + assert(buffer) + +PERL_CALLCONV void +Perl_resume_compcv_final(pTHX_ struct suspended_compcv *buffer); +# define PERL_ARGS_ASSERT_RESUME_COMPCV_FINAL \ + assert(buffer) + +PERL_CALLCONV void +Perl_save_aelem(pTHX_ AV *av, SSize_t idx, SV **sptr); +# define PERL_ARGS_ASSERT_SAVE_AELEM \ + assert(av); assert(SvTYPE(av) == SVt_PVAV); assert(sptr) + +PERL_CALLCONV void +Perl_save_freeop(pTHX_ OP *o); +# define PERL_ARGS_ASSERT_SAVE_FREEOP + +PERL_CALLCONV void +Perl_save_freepv(pTHX_ char *pv); +# define PERL_ARGS_ASSERT_SAVE_FREEPV + +PERL_CALLCONV void +Perl_save_freesv(pTHX_ SV *sv); +# define PERL_ARGS_ASSERT_SAVE_FREESV + +PERL_CALLCONV void +Perl_save_helem(pTHX_ HV *hv, SV *key, SV **sptr); +# define PERL_ARGS_ASSERT_SAVE_HELEM \ + assert(hv); assert(SvTYPE(hv) == SVt_PVHV); assert(key); assert(sptr) + +PERL_CALLCONV void +Perl_save_mortalizesv(pTHX_ SV *sv); +# define PERL_ARGS_ASSERT_SAVE_MORTALIZESV \ + assert(sv) + +PERL_CALLCONV void +Perl_save_op(pTHX); +# define PERL_ARGS_ASSERT_SAVE_OP + +PERL_CALLCONV bool +Perl_strict_utf8_to_uv(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p); +# define PERL_ARGS_ASSERT_STRICT_UTF8_TO_UV \ + assert(s); assert(e); assert(cp_p) + +PERL_CALLCONV bool +Perl_sv_2bool(pTHX_ SV * const sv); +# define PERL_ARGS_ASSERT_SV_2BOOL \ + assert(sv) + +PERL_CALLCONV IV +Perl_sv_2iv(pTHX_ SV *sv); +# define PERL_ARGS_ASSERT_SV_2IV \ + assert(sv) + +PERL_CALLCONV char * +Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp); +# define PERL_ARGS_ASSERT_SV_2PV \ + assert(sv) + +PERL_CALLCONV char * +Perl_sv_2pv_nolen(pTHX_ SV *sv) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_SV_2PV_NOLEN \ + assert(sv) + +PERL_CALLCONV char * +Perl_sv_2pvbyte(pTHX_ SV *sv, STRLEN * const lp); +# define PERL_ARGS_ASSERT_SV_2PVBYTE \ + assert(sv) + +PERL_CALLCONV char * +Perl_sv_2pvbyte_nolen(pTHX_ SV *sv) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_SV_2PVBYTE_NOLEN \ + assert(sv) + +PERL_CALLCONV char * +Perl_sv_2pvutf8(pTHX_ SV *sv, STRLEN * const lp); +# define PERL_ARGS_ASSERT_SV_2PVUTF8 \ + assert(sv) + +PERL_CALLCONV char * +Perl_sv_2pvutf8_nolen(pTHX_ SV *sv) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_SV_2PVUTF8_NOLEN \ + assert(sv) + +PERL_CALLCONV UV +Perl_sv_2uv(pTHX_ SV *sv); +# define PERL_ARGS_ASSERT_SV_2UV \ + assert(sv) + +PERL_CALLCONV void +Perl_sv_catpvn(pTHX_ SV * const dsv, const char *sstr, STRLEN len); +# define PERL_ARGS_ASSERT_SV_CATPVN \ + assert(dsv); assert(sstr) + +PERL_CALLCONV void +Perl_sv_catpvn_mg(pTHX_ SV * const dsv, const char *sstr, STRLEN len); +# define PERL_ARGS_ASSERT_SV_CATPVN_MG \ + assert(dsv); assert(sstr) + +PERL_CALLCONV void +Perl_sv_catsv(pTHX_ SV * const dsv, SV * const sstr); +# define PERL_ARGS_ASSERT_SV_CATSV \ + assert(dsv) + +PERL_CALLCONV void +Perl_sv_catsv_mg(pTHX_ SV * const dsv, SV * const sstr); +# define PERL_ARGS_ASSERT_SV_CATSV_MG \ + assert(dsv) + +PERL_CALLCONV void +Perl_sv_copypv(pTHX_ SV * const dsv, SV * const ssv); +# define PERL_ARGS_ASSERT_SV_COPYPV \ + assert(dsv); assert(ssv) + +PERL_CALLCONV void +Perl_sv_copypv_nomg(pTHX_ SV * const dsv, SV * const ssv); +# define PERL_ARGS_ASSERT_SV_COPYPV_NOMG \ + assert(dsv); assert(ssv) + +PERL_CALLCONV I32 +Perl_sv_eq(pTHX_ SV *sv1, SV *sv2); +# define PERL_ARGS_ASSERT_SV_EQ + +PERL_CALLCONV void +Perl_sv_force_normal(pTHX_ SV *sv); +# define PERL_ARGS_ASSERT_SV_FORCE_NORMAL \ + assert(sv) + +PERL_CALLCONV void +Perl_sv_insert(pTHX_ SV * const bigstr, const STRLEN offset, const STRLEN len, const char * const little, const STRLEN littlelen); +# define PERL_ARGS_ASSERT_SV_INSERT \ + assert(bigstr); assert(little) + +PERL_CALLCONV SV * +Perl_sv_mortalcopy(pTHX_ SV * const oldsv) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_SV_MORTALCOPY + +PERL_CALLCONV bool +Perl_sv_numeq(pTHX_ SV *sv1, SV *sv2); +# define PERL_ARGS_ASSERT_SV_NUMEQ + +PERL_CALLCONV char * +Perl_sv_pv(pTHX_ SV *sv) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_SV_PV \ + assert(sv) + +PERL_CALLCONV char * +Perl_sv_pvbyte(pTHX_ SV *sv) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_SV_PVBYTE \ + assert(sv) + +PERL_CALLCONV char * +Perl_sv_pvn_force(pTHX_ SV *sv, STRLEN *lp); +# define PERL_ARGS_ASSERT_SV_PVN_FORCE \ + assert(sv) + +PERL_CALLCONV char * +Perl_sv_pvutf8(pTHX_ SV *sv) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_SV_PVUTF8 \ + assert(sv) + +PERL_CALLCONV void +Perl_sv_setsv(pTHX_ SV *dsv, SV *ssv); +# define PERL_ARGS_ASSERT_SV_SETSV \ + assert(dsv) + +PERL_CALLCONV bool +Perl_sv_streq(pTHX_ SV *sv1, SV *sv2); +# define PERL_ARGS_ASSERT_SV_STREQ + +PERL_CALLCONV void +Perl_sv_taint(pTHX_ SV *sv); +# define PERL_ARGS_ASSERT_SV_TAINT \ + assert(sv) + +PERL_CALLCONV void +Perl_sv_unref(pTHX_ SV *sv); +# define PERL_ARGS_ASSERT_SV_UNREF \ + assert(sv) + +PERL_CALLCONV void +Perl_sv_usepvn(pTHX_ SV *sv, char *ptr, STRLEN len); +# define PERL_ARGS_ASSERT_SV_USEPVN \ + assert(sv) + +PERL_CALLCONV void +Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len); +# define PERL_ARGS_ASSERT_SV_USEPVN_MG \ + assert(sv) + +PERL_CALLCONV bool +Perl_sv_utf8_downgrade(pTHX_ SV * const sv, const bool fail_ok); +# define PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE \ + assert(sv) + +PERL_CALLCONV bool +Perl_sv_utf8_downgrade_nomg(pTHX_ SV * const sv, const bool fail_ok); +# define PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE_NOMG \ + assert(sv) + +PERL_CALLCONV STRLEN +Perl_sv_utf8_upgrade(pTHX_ SV *sv); +# define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE \ + assert(sv) + +PERL_CALLCONV STRLEN +Perl_sv_utf8_upgrade_flags(pTHX_ SV * const sv, const I32 flags); +# define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_FLAGS \ + assert(sv) + +PERL_CALLCONV STRLEN +Perl_sv_utf8_upgrade_nomg(pTHX_ SV *sv); +# define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_NOMG \ + assert(sv) + +PERL_CALLCONV UV +Perl_to_uni_fold(pTHX_ UV c, U8 *p, STRLEN *lenp); +# define PERL_ARGS_ASSERT_TO_UNI_FOLD \ + assert(p); assert(lenp) + +PERL_CALLCONV U8 * +Perl_utf8_hop_back(const U8 *s, SSize_t off, const U8 * const start) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_UTF8_HOP_BACK \ + assert(s); assert(start) + +PERL_CALLCONV U8 * +Perl_utf8_hop_forward(const U8 *s, SSize_t off, const U8 * const end) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_UTF8_HOP_FORWARD \ + assert(s); assert(end) + +PERL_CALLCONV U8 * +Perl_utf8_hop_safe(const U8 *s, SSize_t off, const U8 * const start, const U8 * const end) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_UTF8_HOP_SAFE \ + assert(s); assert(start); assert(end) + +PERL_CALLCONV bool +Perl_utf8_to_uv(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p); +# define PERL_ARGS_ASSERT_UTF8_TO_UV \ + assert(s); assert(e); assert(cp_p) + +PERL_CALLCONV bool +Perl_utf8_to_uv_errors(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p, U32 flags, U32 *errors); +# define PERL_ARGS_ASSERT_UTF8_TO_UV_ERRORS \ + assert(s); assert(e); assert(cp_p) + +PERL_CALLCONV bool +Perl_utf8_to_uv_flags(const U8 * const s, const U8 * const e, UV *cp_p, Size_t *advance_p, U32 flags); +# define PERL_ARGS_ASSERT_UTF8_TO_UV_FLAGS \ + assert(s); assert(e); assert(cp_p) + +PERL_CALLCONV UV +Perl_utf8n_to_uvchr(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags); +# define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR \ + assert(s) + +PERL_CALLCONV UV +Perl_utf8n_to_uvchr_error(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 *errors); +# define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR_ERROR \ + assert(s) + +PERL_CALLCONV U8 * +Perl_uv_to_utf8_msgs(pTHX_ U8 *d, UV uv, UV flags, HV **msgs); +# define PERL_ARGS_ASSERT_UV_TO_UTF8_MSGS \ + assert(d) + +PERL_CALLCONV U8 * +Perl_uvchr_to_utf8(pTHX_ U8 *d, UV uv); +# define PERL_ARGS_ASSERT_UVCHR_TO_UTF8 \ + assert(d) + +PERL_CALLCONV U8 * +Perl_uvchr_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags); +# define PERL_ARGS_ASSERT_UVCHR_TO_UTF8_FLAGS \ + assert(d) + +PERL_CALLCONV U8 * +Perl_uvchr_to_utf8_flags_msgs(pTHX_ U8 *d, UV uv, UV flags, HV **msgs); +# define PERL_ARGS_ASSERT_UVCHR_TO_UTF8_FLAGS_MSGS \ + assert(d) + +PERL_CALLCONV U8 * +Perl_uvoffuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags); +# define PERL_ARGS_ASSERT_UVOFFUNI_TO_UTF8_FLAGS \ + assert(d) + +PERL_CALLCONV UV +Perl_valid_utf8_to_uvchr(const U8 *s, STRLEN *retlen) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVCHR \ + assert(s) + +PERL_CALLCONV I32 +Perl_whichsig(pTHX_ const char *sig); +# define PERL_ARGS_ASSERT_WHICHSIG \ + assert(sig) + +# if !defined(USE_ITHREADS) +PERL_CALLCONV void +Perl_CopFILEGV_set(pTHX_ COP *c, GV *gv); +# define PERL_ARGS_ASSERT_COPFILEGV_SET \ + assert(c); assert(gv) + +# endif +# if defined(USE_LOCALE_COLLATE) +PERL_CALLCONV char * +Perl_sv_collxfrm(pTHX_ SV * const sv, STRLEN * const nxp); +# define PERL_ARGS_ASSERT_SV_COLLXFRM \ + assert(sv); assert(nxp) + +# endif +#endif /* defined(PERL_NO_SHORT_NAMES) */ +#if defined(PERL_RC_STACK) +# define PERL_ARGS_ASSERT_PP_WRAP \ + assert(real_pp_fn) + +PERL_CALLCONV int +Perl_runops_wrap(pTHX); +# define PERL_ARGS_ASSERT_RUNOPS_WRAP + +PERL_CALLCONV void +Perl_xs_wrap(pTHX_ XSUBADDR_t xsub, CV *cv); +# define PERL_ARGS_ASSERT_XS_WRAP \ + assert(xsub); assert(cv); \ + assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) + +# if defined(PERL_CORE) || defined(PERL_EXT) +PERL_CALLCONV OP * +Perl_pp_wrap(pTHX_ Perl_ppaddr_t real_pp_fn, I32 nargs, int nlists); +# endif +#endif /* defined(PERL_RC_STACK) */ +#if defined(PERL_USE_3ARG_SIGHANDLER) +PERL_CALLCONV Signal_t +Perl_csighandler(int sig, Siginfo_t *info, void *uap); +# define PERL_ARGS_ASSERT_CSIGHANDLER + +PERL_CALLCONV Signal_t +Perl_sighandler(int sig, Siginfo_t *info, void *uap) + __attribute__visibility__("hidden"); +# define PERL_ARGS_ASSERT_SIGHANDLER + +#else /* if !defined(PERL_USE_3ARG_SIGHANDLER) */ +PERL_CALLCONV Signal_t +Perl_csighandler(int sig); +# define PERL_ARGS_ASSERT_CSIGHANDLER + +PERL_CALLCONV Signal_t +Perl_sighandler(int sig) + __attribute__visibility__("hidden"); +# define PERL_ARGS_ASSERT_SIGHANDLER + +#endif /* !defined(PERL_USE_3ARG_SIGHANDLER) */ +#if defined(U64TYPE) + +#endif +#if defined(UNLINK_ALL_VERSIONS) +PERL_CALLCONV I32 +Perl_unlnk(pTHX_ const char *f); +# define PERL_ARGS_ASSERT_UNLNK \ + assert(f) + +#endif +#if defined(USE_C_BACKTRACE) +PERL_CALLCONV bool +Perl_dump_c_backtrace(pTHX_ PerlIO *fp, int max_depth, int skip); +# define PERL_ARGS_ASSERT_DUMP_C_BACKTRACE \ + assert(fp) + +PERL_CALLCONV Perl_c_backtrace * +Perl_get_c_backtrace(pTHX_ int max_depth, int skip) + __attribute__visibility__("hidden"); +# define PERL_ARGS_ASSERT_GET_C_BACKTRACE + +PERL_CALLCONV SV * +Perl_get_c_backtrace_dump(pTHX_ int max_depth, int skip); +# define PERL_ARGS_ASSERT_GET_C_BACKTRACE_DUMP + +#endif /* defined(USE_C_BACKTRACE) */ +#if defined(USE_DTRACE) +# define PERL_ARGS_ASSERT_DTRACE_PROBE_CALL \ + assert(cv); assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM) + +# define PERL_ARGS_ASSERT_DTRACE_PROBE_LOAD \ + assert(name) + +# define PERL_ARGS_ASSERT_DTRACE_PROBE_OP \ + assert(op) + +# define PERL_ARGS_ASSERT_DTRACE_PROBE_PHASE + +# if defined(PERL_CORE) || defined(PERL_EXT) +PERL_CALLCONV void +Perl_dtrace_probe_call(pTHX_ CV *cv, bool is_call); +PERL_CALLCONV void +Perl_dtrace_probe_load(pTHX_ const char *name, bool is_loading); +PERL_CALLCONV void +Perl_dtrace_probe_op(pTHX_ const OP *op); +PERL_CALLCONV void +Perl_dtrace_probe_phase(pTHX_ enum perl_phase phase); +# endif +#endif /* defined(USE_DTRACE) */ +#if defined(USE_ITHREADS) +PERL_CALLCONV PADOFFSET +Perl_alloccopstash(pTHX_ HV *hv); +# define PERL_ARGS_ASSERT_ALLOCCOPSTASH \ + assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + +PERL_CALLCONV void * +Perl_any_dup(pTHX_ void *v, const PerlInterpreter *proto_perl) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_ANY_DUP \ + assert(proto_perl) + +PERL_CALLCONV void +Perl_clone_params_del(CLONE_PARAMS *param); +# define PERL_ARGS_ASSERT_CLONE_PARAMS_DEL \ + assert(param) PERL_CALLCONV CLONE_PARAMS * Perl_clone_params_new(PerlInterpreter * const from, PerlInterpreter * const to) @@ -10884,8 +11112,6 @@ Perl_op_relocate_sv(pTHX_ SV **svp, PADOFFSET *targp) # endif #else /* if !defined(USE_ITHREADS) */ -/* PERL_CALLCONV void -Perl_CopFILEGV_set(pTHX_ COP *c, GV *gv); */ #endif #if defined(USE_LOCALE_COLLATE) @@ -10904,9 +11130,6 @@ Perl_magic_setcollxfrm(pTHX_ SV *sv, MAGIC *mg) # define PERL_ARGS_ASSERT_STRXFRM \ assert(src) -/* PERL_CALLCONV char * -Perl_sv_collxfrm(pTHX_ SV * const sv, STRLEN * const nxp); */ - PERL_CALLCONV char * Perl_sv_collxfrm_flags(pTHX_ SV * const sv, STRLEN * const nxp, I32 const flags); # define PERL_ARGS_ASSERT_SV_COLLXFRM_FLAGS \ diff --git a/regen/embed.pl b/regen/embed.pl index 6f467d4d30dd..60977db68d9a 100755 --- a/regen/embed.pl +++ b/regen/embed.pl @@ -59,6 +59,8 @@ BEGIN my $unflagged_pointers; my @az = ('a'..'z'); +my %need_longs; # For long function names + # # See database of global and static function prototypes in embed.fnc # This is used to generate prototype headers under various configurations, @@ -156,7 +158,6 @@ sub generate_proto_h { } my @nonnull; - my $args_assert_line = ( $flags !~ /m/ ); my $has_depth = ( $flags =~ /W/ ); my $has_context = ( $flags !~ /T/ ); my $never_returns = ( $flags =~ /r/ ); @@ -196,6 +197,10 @@ sub generate_proto_h { die_at_end "$plain_func: u flag only usable with m" if $flags =~ /u/; } + # A macro only gets assertions for it if it is to get Perl_ added to + # it. + my $args_assert_line = ! $has_mflag || $flags =~ tr/mp// > 1; + my ($static_flag, @extra_static_flags)= $flags =~/([SsIi])/g; if (@extra_static_flags) { @@ -344,7 +349,10 @@ sub generate_proto_h { } my $argname = $1; - if (defined $argname && (! $has_mflag || $binarycompat)) { + if (defined $argname && ( ! $has_mflag + || $binarycompat + || $args_assert_line)) + { if ($nn||$nz) { push @asserts, "assert($argname)"; } @@ -436,7 +444,6 @@ sub generate_proto_h { $ret .= join( "\n", map { (" " x 8) . $_ } @attrs ); } $ret .= ";"; - $ret = "/* $ret */" if $has_mflag; # Hide the prototype from non-authorized code. This acts kind of like # __attribute__visibility__("hidden") for cases where that can't be @@ -474,6 +481,13 @@ sub generate_proto_h { } $ret .= "\n"; + # These become functions in this case. + if ($flags =~ tr/mp// > 1) { # Has both m and p + $ret = "#${ind}if defined(PERL_NO_SHORT_NAMES)\n" + . "$ret\n" + . "#${ind}endif\n"; + } + $ret = "#${ind}ifndef PERL_NO_INLINE_FUNCTIONS\n$ret\n#${ind}endif" if $static_inline; $ret = "#${ind}ifndef NO_MATHOMS\n$ret\n#${ind}endif" @@ -635,6 +649,15 @@ sub embed_h { . "$ind $no_thread_full_define" # No \n because no chomp . "#${ind}endif\n"; } + + # These remain macros when short names are allowed + $ret = "#${ind}if !defined(PERL_NO_SHORT_NAMES)\n" + . "$ind $ret" + . "#${ind}endif\n"; + + # And tell later code that this needs to be handled when short + # names are not allowed. + $need_longs{$full_name} = $embed; } elsif ($flags !~ /[omM]/) { my $argc = scalar @$args; @@ -817,11 +840,72 @@ sub generate_embedvar_h { unless $error_count; } +sub generate_long_names_c { + my $longs = shift; + my $fh = open_print_header("long_names.c"); + + print $fh <<~'EOT'; + + /* This file expands to (nearly) nothing unless PERL_NO_SHORT_NAMES is + #defined. It contains function definitions for elements that are + otherwise macros */ + + #include "EXTERN.h" + #define PERL_IN_LONG_NAMES_C + #include "perl.h" + + #if ! defined(PERL_NO_SHORT_NAMES) + /* ..." warning: ISO C forbids an empty source file" + So make sure we have something in here by processing the headers + anyway. */ + #else + EOT + + for my $full_name (sort keys %{$longs}) { + my $entry = $longs->{$full_name}; + my $return_type = $entry->{return_type}; + + print $fh "\n", $entry->{return_type}, "\n"; + + print $fh $full_name, "("; + print $fh 'pTHX_ ' unless $entry->{flags} =~ /T/; + print $fh join ", ", @{$entry->{args}} if $entry->{args}; + print $fh ")\n"; + + print $fh <<~EOT; + { + PERL_ARGS_ASSERT_\U$full_name; + EOT + + # Now the definition, which is to just call the short name macro. + # Since this is compiled as part of the core, the short name is + # available + print $fh " " x 4; + print $fh "return " if $return_type ne 'void'; + print $fh $entry->{name}, "("; + + # This assumes the parameter name is the final \w+ chars + print $fh join ", ", map { s/ .*? (\w+) $ /$1/rx } @{$entry->{args}} + if @{$entry->{args}}; + print $fh ");\n"; + + print $fh "}\n"; + } + + print $fh <<~"EOF"; + + #endif + EOF + + read_only_bottom_close_and_rename($fh) if ! $error_count; +} + sub update_headers { my ($all, $api, $ext, $core) = setup_embed(); # see regen/embed_lib.pl generate_proto_h($all); die_at_end "$unflagged_pointers pointer arguments to clean up\n" if $unflagged_pointers; generate_embed_h($all, $api, $ext, $core); + generate_long_names_c(\%need_longs); generate_embedvar_h(); die "$error_count errors found" if $error_count; } diff --git a/t/porting/regen.t b/t/porting/regen.t index ff0a3da75791..f84f78cca744 100644 --- a/t/porting/regen.t +++ b/t/porting/regen.t @@ -27,7 +27,7 @@ if ( $Config{usecrosscompile} ) { skip_all( "Not all files are available during cross-compilation" ); } -my $tests = 28; # I can't see a clean way to calculate this automatically. +my $tests = 29; # I can't see a clean way to calculate this automatically. my %skip = ("regen_perly.pl" => [qw(perly.act perly.h perly.tab)], "regen/keywords.pl" => [qw(keywords.c keywords.h)], diff --git a/vms/descrip_mms.template b/vms/descrip_mms.template index 9df7455b4f78..0c271bc357fc 100644 --- a/vms/descrip_mms.template +++ b/vms/descrip_mms.template @@ -210,7 +210,7 @@ FULLLIBS2 = $(LIBS2)|$(THRLIBS1)|$(THRLIBS2) #### End of system configuration section. #### c0 = $(MALLOC_C) av.c builtin.c caretx.c class.c deb.c doio.c doop.c dquote.c dump.c globals.c gv.c hv.c mro_core.c -c1 = mg.c locale.c mathoms.c miniperlmain.c numeric.c op.c pad.c peep.c perl.c perlio.c +c1 = mg.c locale.c long_names.c mathoms.c miniperlmain.c numeric.c op.c pad.c peep.c perl.c perlio.c c2 = perly.c pp.c pp_ctl.c pp_hot.c pp_pack.c pp_sort.c pp_sys.c regcomp.c regcomp_debug.c c3 = regcomp_invlist.c regcomp_study.c regcomp_trie.c regexec.c reentr.c c4 = run.c scope.c sv.c taint.c time64.c toke.c universal.c utf8.c util.c vms.c keywords.c @@ -636,6 +636,8 @@ keywords$(O) : keywords.c $(h) $(CC) $(CORECFLAGS) $(MMS$SOURCE) locale$(O) : locale.c $(h) $(CC) $(CORECFLAGS) $(MMS$SOURCE) +long_names$(O) : long_names.c $(h) + $(CC) $(CORECFLAGS) $(MMS$SOURCE) malloc$(O) : malloc.c $(h) $(CC) $(CORECFLAGS) $(MMS$SOURCE) mathoms$(O) : mathoms.c $(h) diff --git a/win32/GNUmakefile b/win32/GNUmakefile index b5a0c765f444..d9ee22b4fd94 100644 --- a/win32/GNUmakefile +++ b/win32/GNUmakefile @@ -961,6 +961,7 @@ MICROCORE_SRC = \ ..\globals.c \ ..\mro_core.c \ ..\locale.c \ + ..\long_names.c \ ..\keywords.c \ ..\mathoms.c \ ..\mg.c \