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 8ac7210a5d76..8034d75ebe84 100644 --- a/embed.h +++ b/embed.h @@ -91,9 +91,9 @@ !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 */ +/* 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) @@ -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) @@ -2488,6 +2494,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/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 7bc47bf8dea5..dd90bcbb66e5 100644 --- a/mathoms.c +++ b/mathoms.c @@ -27,14 +27,14 @@ * 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 * 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 ceb3022b65e2..5f28fc5075c1 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 @@ -85,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__ @@ -342,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 \ @@ -791,9 +782,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"); @@ -853,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"); @@ -1049,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); @@ -1110,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 \ @@ -1298,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 @@ -1344,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 \ @@ -1362,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 \ @@ -1398,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 \ @@ -1436,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 \ @@ -1450,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 \ @@ -1552,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 \ @@ -1586,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 \ @@ -1627,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__; @@ -1654,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 \ @@ -1707,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 \ @@ -1790,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 @@ -1820,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_ @@ -1836,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__; @@ -1871,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__ @@ -1881,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__; @@ -1899,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__ @@ -2649,9 +2503,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 +2540,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 @@ -2753,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__; @@ -2863,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__; @@ -2888,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__; @@ -3007,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__; @@ -3111,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__; @@ -3292,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 @@ -3574,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 @@ -3878,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__ @@ -3984,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 \ @@ -4030,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 \ @@ -4069,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 \ @@ -4101,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 @@ -4351,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"); @@ -4391,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 \ @@ -4409,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 \ @@ -4432,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 \ @@ -4523,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 \ @@ -4581,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 @@ -4671,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 \ @@ -4728,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 \ @@ -4781,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__; @@ -4803,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 @@ -4834,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 \ @@ -5057,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 \ @@ -5080,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 @@ -5101,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__; @@ -5130,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 \ @@ -5148,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 \ @@ -5275,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_ \ @@ -5359,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__; @@ -5390,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 \ @@ -5450,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) @@ -5572,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 \ @@ -6303,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 * @@ -6885,21 +6496,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) @@ -10661,105 +10263,707 @@ 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) - -#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_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) -/* PERL_CALLCONV void -free_c_backtrace(pTHX_ Perl_c_backtrace *bt); */ +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_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_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_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 void * +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 \ @@ -10908,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) @@ -10928,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 7254be71b47a..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/ ); @@ -184,11 +185,22 @@ 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]/; + + # 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/; } + # 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) { @@ -337,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)"; } @@ -429,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 @@ -467,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" @@ -628,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; @@ -703,9 +733,9 @@ 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 */ + /* Create short name macros that hide any need for thread context */ END @@ -715,7 +745,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 @@ -810,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 \