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 d294f4e3ee9a..545f37551795 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..64e4ac1caaaf 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 \ @@ -578,15 +578,15 @@ common_objs = \ av$(OBJ_EXT) builtin$(OBJ_EXT) caretx$(OBJ_EXT) class$(OBJ_EXT) \ deb$(OBJ_EXT) doio$(OBJ_EXT) doop$(OBJ_EXT) dquote$(OBJ_EXT) \ dump$(OBJ_EXT) globals$(OBJ_EXT) gv$(OBJ_EXT) hv$(OBJ_EXT) \ - keywords$(OBJ_EXT) locale$(OBJ_EXT) mathoms$(OBJ_EXT) mg$(OBJ_EXT) \ - mro_core$(OBJ_EXT) numeric$(OBJ_EXT) pad$(OBJ_EXT) peep$(OBJ_EXT) \ - perlio$(OBJ_EXT) perly$(OBJ_EXT) pp$(OBJ_EXT) pp_ctl$(OBJ_EXT) \ - pp_hot$(OBJ_EXT) pp_pack$(OBJ_EXT) pp_sort$(OBJ_EXT) pp_sys$(OBJ_EXT) \ - reentr$(OBJ_EXT) regcomp$(OBJ_EXT) regcomp_debug$(OBJ_EXT) \ - regcomp_invlist$(OBJ_EXT) regcomp_study$(OBJ_EXT) regcomp_trie$(OBJ_EXT) \ - regexec$(OBJ_EXT) run$(OBJ_EXT) scope$(OBJ_EXT) sv$(OBJ_EXT) \ - taint$(OBJ_EXT) time64$(OBJ_EXT) toke$(OBJ_EXT) utf8$(OBJ_EXT) \ - util$(OBJ_EXT) \ + keywords$(OBJ_EXT) locale$(OBJ_EXT) long_names$(OBJ_EXT) \ + mathoms$(OBJ_EXT) mg$(OBJ_EXT) mro_core$(OBJ_EXT) numeric$(OBJ_EXT) \ + pad$(OBJ_EXT) peep$(OBJ_EXT) perlio$(OBJ_EXT) perly$(OBJ_EXT) \ + pp$(OBJ_EXT) pp_ctl$(OBJ_EXT) pp_hot$(OBJ_EXT) pp_pack$(OBJ_EXT) \ + pp_sort$(OBJ_EXT) pp_sys$(OBJ_EXT) reentr$(OBJ_EXT) regcomp$(OBJ_EXT) \ + regcomp_debug$(OBJ_EXT) regcomp_invlist$(OBJ_EXT) \ + regcomp_study$(OBJ_EXT) regcomp_trie$(OBJ_EXT) regexec$(OBJ_EXT) \ + run$(OBJ_EXT) scope$(OBJ_EXT) sv$(OBJ_EXT) taint$(OBJ_EXT) \ + time64$(OBJ_EXT) toke$(OBJ_EXT) utf8$(OBJ_EXT) util$(OBJ_EXT) \ $(mallocobj) $(ARCHOBJS) miniperl_objs_nodt = $(mini_only_objs) $(common_objs) miniperlmain$(OBJ_EXT) diff --git a/embed.fnc b/embed.fnc index 55cc377346c9..24eb59220630 100644 --- a/embed.fnc +++ b/embed.fnc @@ -1117,7 +1117,7 @@ Adpr |OP * |die_sv |NN SV *baseex : Used in util.c pr |void |die_unwind |NN SV *msv : FIXME -mp |bool |do_aexec |NULLOK SV *really \ +m |bool |do_aexec |NULLOK SV *really \ |NN SV **mark \ |NN SV **sp : Used in pp_sys.c @@ -1699,9 +1699,6 @@ Ampx |SV ** |hv_store_flags |NULLOK HV *hv \ |NULLOK SV *val \ |U32 hash \ |int flags -Admp |SV ** |hv_stores |NULLOK HV *hv \ - |"key" \ - |NULLOK SV *val Admp |void |hv_undef |NULLOK HV *hv Xop |void |hv_undef_flags |NULLOK HV *hv \ |U32 flags @@ -2210,7 +2207,7 @@ Adpr |void |my_exit |U32 status Adpr |void |my_failure_exit Cdp |I32 |my_fflush_all CTdp |Pid_t |my_fork -mp |I32 |my_lstat +m |I32 |my_lstat Xp |I32 |my_lstat_flags |NULLOK const U32 flags RTop |int |my_mkostemp_cloexec \ |NN char *templte \ @@ -2231,7 +2228,7 @@ CTdp |int |my_socketpair |int family \ |int type \ |int protocol \ |int fd[2] -mp |I32 |my_stat +m |I32 |my_stat Xp |I32 |my_stat_flags |NULLOK const U32 flags p |const char *|my_strerror \ |const int errnum \ @@ -2690,8 +2687,7 @@ CTp |Signal_t|perly_sighandler \ |NULLOK void *uap \ |bool safe -Admp |const char * const|phase_name \ - |enum perl_phase +Admp |const char *|phase_name|enum perl_phase phase Adp |void |pmop_dump |NULLOK PMOP *pm : Used in perly.y p |OP * |pmruntime |NN OP *o \ diff --git a/embed.h b/embed.h index 5bda0aada78e..8590bc316042 100644 --- a/embed.h +++ b/embed.h @@ -21,77 +21,1941 @@ /* (Doing namespace management portably in C is really gross.) */ -/* By defining PERL_NO_SHORT_NAMES (not done by default) the short forms - * (like warn instead of Perl_warn) for the API are not defined. - * Not defining the short forms is a good thing for cleaner embedding. - * 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 */ +/* When this symbol is defined, we undef all the short name symbols we + * have defined before when this file was #included with the symbol + * undefined */ +#if defined(PERL_DO_UNDEF_SHORT_NAMES) +# if !defined(PERL_CORE) && defined(PERL_NO_SHORT_NAMES) +# undef abort_execution +# undef add_above_Latin1_folds +# undef add_cp_to_invlist +# undef add_multi_match +# undef add_range_to_invlist_ +# undef add_utf16_textfilter +# undef adjust_size_and_find_bucket +# undef advance_one_LB +# undef advance_one_SB +# undef advance_one_WB_ +# undef alloc_LOGOP +# undef alloccopstash +# undef allocmy +# undef amagic_applies +# undef amagic_call +# undef amagic_cmp +# undef amagic_cmp_desc +# undef amagic_cmp_locale +# undef amagic_cmp_locale_desc +# undef amagic_deref_call +# undef amagic_i_ncmp +# undef amagic_i_ncmp_desc +# undef amagic_is_enabled +# undef amagic_ncmp +# undef amagic_ncmp_desc +# undef anonymise_cv_maybe +# undef any_dup +# undef ao +# undef append_range_to_invlist_ +# undef append_utf8_from_native_byte +# undef apply +# undef apply_attrs +# undef apply_attrs_my +# undef apply_attrs_string +# undef apply_builtin_cv_attributes +# undef argvout_final +# undef assert_uft8_cache_coherent +# undef assignment_type +# undef atfork_child +# undef atfork_lock +# undef atfork_unlock +# undef av_clear +# undef av_count +# undef av_delete +# undef av_dump +# undef av_exists +# undef av_extend +# undef av_extend_guts +# undef av_fetch +# undef av_fetch_simple +# undef av_fill +# undef av_len +# undef av_make +# undef av_new_alloc +# undef av_nonelem +# undef av_pop +# undef av_push +# undef av_push_simple +# undef av_reify +# undef av_remove_offset +# undef av_shift +# undef av_store +# undef av_store_simple +# undef av_undef +# undef av_unshift +# undef AvFILL_ +# undef backup_one_GCB +# undef backup_one_LB_ +# undef backup_one_SB +# undef backup_one_WB_but_over_Extend_FO +# undef bad_type_gv +# undef bad_type_pv +# undef bind_match +# undef block_end +# undef block_gimme +# undef block_start +# undef bool_setlocale_2008_i +# undef boot_core_builtin +# undef boot_core_mro +# undef boot_core_PerlIO +# undef boot_core_UNIVERSAL +# undef build_infix_plugin +# undef byte_dump_string_ +# undef bytes_cmp_utf8 +# undef bytes_from_utf8 +# undef bytes_to_utf8 +# undef bytes_to_utf8_free_me +# undef bytes_to_utf8_temp_pv +# undef c9strict_utf8_to_uv +# undef calculate_LC_ALL_string +# undef call_argv +# undef call_atexit +# undef call_list +# undef call_method +# undef call_pv +# undef call_sv +# undef caller_cx +# undef cando +# undef capture_clear +# undef cast_i32 +# undef cast_iv +# undef cast_ulong +# undef cast_uv +# undef change_engine_size +# undef check_hash_fields_and_hekify +# undef check_locale_boundary_crossing +# undef check_regnode_after +# undef check_type_and_open +# undef check_unary +# undef check_utf8_print +# undef checkcomma +# undef ck_anoncode +# undef ck_backtick +# undef ck_bitop +# undef ck_classname +# undef ck_cmp +# undef ck_concat +# undef ck_defined +# undef ck_delete +# undef ck_each +# undef ck_entersub_args_list +# undef ck_entersub_args_proto +# undef ck_entersub_args_proto_or_list +# undef ck_eof +# undef ck_eval +# undef ck_exec +# undef ck_exists +# undef ck_ftst +# undef ck_fun +# undef ck_glob +# undef ck_grep +# undef ck_helemexistsor +# undef ck_index +# undef ck_isa +# undef ck_join +# undef ck_length +# undef ck_lfun +# undef ck_listiob +# undef ck_match +# undef ck_method +# undef ck_null +# undef ck_open +# undef ck_prototype +# undef ck_readline +# undef ck_refassign +# undef ck_repeat +# undef ck_require +# undef ck_return +# undef ck_rfun +# undef ck_rvconst +# undef ck_sassign +# undef ck_scmp +# undef ck_select +# undef ck_shift +# undef ck_smartmatch +# undef ck_sort +# undef ck_spair +# undef ck_split +# undef ck_stringify +# undef ck_subr +# undef ck_substr +# undef ck_svconst +# undef ck_tell +# undef ck_trunc +# undef ck_trycatch +# undef ck_warner +# undef ck_warner_d +# undef ckwarn_common +# undef class_add_ADJUST +# undef class_add_field +# undef class_apply_attributes +# undef class_apply_field_attributes +# undef class_cleanup_definition +# undef class_prepare_initfield_parse +# undef class_prepare_method_parse +# undef class_seal_stash +# undef class_set_field_defop +# undef class_setup_stash +# undef class_wrap_method_body +# undef clear_defarray +# undef clear_defarray_simple +# undef clear_placeholders +# undef clear_special_blocks +# undef closest_cop +# undef cmp_desc +# undef cmp_locale_desc +# undef cmpchain_extend +# undef cmpchain_finish +# undef cmpchain_start +# undef cntrl_to_mnemonic +# undef compile_wildcard +# undef compute_EXACTish +# undef construct_ahocorasick_from_trie +# undef cop_disable_warning +# undef cop_enable_warning +# undef cop_fetch_label +# undef cop_file_avn +# undef cop_free +# undef cop_has_warning +# undef cop_store_label +# undef CopFILEGV_set +# undef core_prototype +# undef coresub_op +# undef create_eval_scope +# undef croak_caller +# undef croak_kw_unless_class +# undef croak_memory_wrap +# undef croak_no_mem +# undef croak_no_mem_ext +# undef croak_no_modify +# undef croak_nocontext +# undef croak_popstack +# undef croak_sv +# undef croak_sv_setsv_flags +# undef croak_xs_usage +# undef csighandler +# undef csighandler1 +# undef csighandler3 +# undef current_re_engine +# undef curse +# undef custom_op_get_field +# undef cv_ckproto_len_flags +# undef cv_clone +# undef cv_clone_into +# undef cv_const_sv +# undef cv_const_sv_or_av +# undef cv_dump +# undef cv_forget_slab +# undef cv_get_call_checker +# undef cv_get_call_checker_flags +# undef cv_name +# undef cv_set_call_checker +# undef cv_set_call_checker_flags +# undef cv_undef +# undef cv_undef_flags +# undef cvgv_set +# undef cvstash_set +# undef cx_dump +# undef cx_dup +# undef cx_popblock +# undef cx_popeval +# undef cx_popformat +# undef cx_popgiven +# undef cx_poploop +# undef cx_popsub +# undef cx_popsub_args +# undef cx_popsub_common +# undef cx_popwhen +# undef cx_pushblock +# undef cx_pusheval +# undef cx_pushformat +# undef cx_pushgiven +# undef cx_pushloop_for +# undef cx_pushloop_plain +# undef cx_pushsub +# undef cx_pushtry +# undef cx_pushwhen +# undef cx_topblock +# undef cxinc +# undef deb +# undef deb_curcv +# undef deb_nocontext +# undef deb_stack_all +# undef deb_stack_n +# undef debop +# undef debprof +# undef debprofdump +# undef debstack +# undef debstackptrs +# undef debug_hash_seed +# undef debug_peep +# undef debug_show_study_flags +# undef debug_start_match +# undef debug_studydata +# undef defelem_target +# undef del_sv +# undef delete_eval_scope +# undef delimcpy +# undef delimcpy_no_escape +# undef despatch_signals +# undef destroy_matcher +# undef die_nocontext +# undef die_sv +# undef die_unwind +# undef dirp_dup +# undef div128 +# undef do_aexec5 +# undef do_aspawn +# undef do_chomp +# undef do_close +# undef do_delete_local +# undef do_dump_pad +# undef do_eof +# undef do_exec +# undef do_exec3 +# undef do_gv_dump +# undef do_gvgv_dump +# undef do_hv_dump +# undef do_ipcctl +# undef do_ipcget +# undef do_join +# undef do_magic_dump +# undef do_msgrcv +# undef do_msgsnd +# undef do_ncmp +# undef do_oddball +# undef do_op_dump +# undef do_open +# undef do_open6 +# undef do_open_raw +# undef do_openn +# undef do_pmop_dump +# undef do_print +# undef do_readline +# undef do_seek +# undef do_semop +# undef do_shmio +# undef do_smartmatch +# undef do_spawn +# undef do_spawn_nowait +# undef do_sprintf +# undef do_sv_dump +# undef do_sysseek +# undef do_tell +# undef do_trans +# undef do_trans_complex +# undef do_trans_count +# undef do_trans_count_invmap +# undef do_trans_invmap +# undef do_trans_simple +# undef do_uniprop_match +# undef do_vecget +# undef do_vecset +# undef do_vop +# undef docatch +# undef does_utf8_overflow +# undef doeval_compile +# undef dofile +# undef dofindlabel +# undef doform +# undef doing_taint +# undef dooneliner +# undef doopen_pm +# undef doparseform +# undef dopoptoeval +# undef dopoptogivenfor +# undef dopoptolabel +# undef dopoptoloop +# undef dopoptosub_at +# undef dopoptowhen +# undef doref +# undef dounwind +# undef dowantarray +# undef dump_all +# undef dump_all_perl +# undef dump_c_backtrace +# undef dump_eval +# undef dump_exec_pos +# undef dump_form +# undef dump_indent +# undef dump_mstats +# undef dump_packsubs +# undef dump_packsubs_perl +# undef dump_regex_sets_structures +# undef dump_sub +# undef dump_sub_perl +# undef dump_sv_child +# undef dump_trie +# undef dump_trie_interim_list +# undef dump_trie_interim_table +# undef dump_vindent +# undef dumpuntil +# undef dup_attrlist +# undef edit_distance +# undef emulate_langinfo +# undef eval_pv +# undef eval_sv +# undef exec_failed +# undef execute_wildcard +# undef expect_number +# undef extended_utf8_to_uv +# undef external_call_langinfo +# undef F0convert +# undef fatal_warner +# undef fbm_compile +# undef fbm_instr +# undef filter_add +# undef filter_del +# undef filter_gets +# undef filter_read +# undef finalize_op +# undef finalize_optree +# undef find_and_forget_pmops +# undef find_array_subscript +# undef find_beginning +# undef find_byclass +# undef find_default_stash +# undef find_first_differing_byte_pos +# undef find_hash_subscript +# undef find_in_my_stash +# undef find_lexical_cv +# undef find_locale_from_environment +# undef find_next_masked +# undef find_runcv +# undef find_runcv_where +# undef find_rundefsv +# undef find_script +# undef find_span_end +# undef find_span_end_mask +# undef find_uninit_var +# undef finish_export_lexical +# undef first_symbol +# undef fixup_errno_string +# undef fold_constants +# undef foldEQ +# undef foldEQ_latin1 +# undef foldEQ_latin1_s2_folded +# undef foldEQ_locale +# undef foldEQ_utf8 +# undef foldEQ_utf8_flags +# undef forbid_outofblock_ops +# undef forbid_setid +# undef force_ident +# undef force_ident_maybe_lex +# undef force_list +# undef force_locale_unlock +# undef force_next +# undef force_out_malformed_utf8_message_ +# undef force_strict_version +# undef force_version +# undef force_word +# undef forget_pmop +# undef form +# undef form_alien_digit_msg +# undef form_cp_too_large_msg +# undef form_nocontext +# undef fp_dup +# undef free_tied_hv_pool +# undef free_tmps +# undef gen_constant_list +# undef get_and_check_backslash_N_name +# undef get_and_check_backslash_N_name_wrapper +# undef get_ANYOF_cp_list_for_ssc +# undef get_ANYOFHbbm_contents +# undef get_ANYOFM_contents +# undef get_aux_mg +# undef get_av +# undef get_c_backtrace +# undef get_c_backtrace_dump +# undef get_category_index_helper +# undef get_context +# undef get_cv +# undef get_cvn_flags +# undef get_debug_opts +# undef get_deprecated_property_msg +# undef get_displayable_string +# undef get_displayable_tr_operand +# undef get_hash_seed +# undef get_hv +# undef get_invlist_iter_addr +# undef get_invlist_offset_addr +# undef get_invlist_previous_index_addr +# undef get_LC_ALL_display +# undef get_locale_string_utf8ness_i +# undef get_mstats +# undef get_no_modify +# undef get_num +# undef get_op_descs +# undef get_op_names +# undef get_opargs +# undef get_ppaddr +# undef get_prop_definition +# undef get_prop_values +# undef get_quantifier_value +# undef get_re_gclass_aux_data +# undef get_regclass_aux_data +# undef get_regex_charset_name +# undef get_sv +# undef get_vtbl +# undef get_win32_message_utf8ness +# undef getcwd_sv +# undef getenv_len +# undef gimme_V +# undef give_perl_locale_control +# undef glob_2number +# undef glob_assign_glob +# undef gp_dup +# undef gp_free +# undef gp_ref +# undef grok_atoUV +# undef grok_bin_oct_hex +# undef grok_bslash_c +# undef grok_bslash_N +# undef grok_bslash_o +# undef grok_bslash_x +# undef grok_infnan +# undef grok_number +# undef grok_number_flags +# undef grok_numeric_radix +# undef group_end +# undef gv_add_by_type +# undef Gv_AMupdate +# undef gv_autoload_pv +# undef gv_autoload_pvn +# undef gv_autoload_sv +# undef gv_AVadd +# undef gv_check +# undef gv_const_sv +# undef gv_dump +# undef gv_efullname3 +# undef gv_efullname4 +# undef gv_fetchfile +# undef gv_fetchfile_flags +# undef gv_fetchmeth +# undef gv_fetchmeth_autoload +# undef gv_fetchmeth_internal +# undef gv_fetchmeth_pv +# undef gv_fetchmeth_pv_autoload +# undef gv_fetchmeth_pvn +# undef gv_fetchmeth_pvn_autoload +# undef gv_fetchmeth_sv +# undef gv_fetchmeth_sv_autoload +# undef gv_fetchmethod +# undef gv_fetchmethod_autoload +# undef gv_fetchmethod_pv_flags +# undef gv_fetchmethod_pvn_flags +# undef gv_fetchmethod_sv_flags +# undef gv_fetchpv +# undef gv_fetchpvn_flags +# undef gv_fetchsv +# undef gv_fullname3 +# undef gv_fullname4 +# undef gv_handler +# undef gv_HVadd +# undef gv_init +# undef gv_init_pv +# undef gv_init_pvn +# undef gv_init_sv +# undef gv_init_svtype +# undef gv_IOadd +# undef gv_is_in_main +# undef gv_magicalize +# undef gv_magicalize_isa +# undef gv_name_set +# undef gv_override +# undef gv_setref +# undef gv_stashpv +# undef gv_stashpvn +# undef gv_stashpvn_internal +# undef gv_stashsv +# undef gv_stashsvpvn_cached +# undef gv_SVadd +# undef gv_try_downgrade +# undef handle_named_backref +# undef handle_names_wildcard +# undef handle_possible_posix +# undef handle_regex_sets +# undef handle_user_defined_property +# undef he_dup +# undef hek_dup +# undef hsplit +# undef hv_auxinit +# undef hv_bucket_ratio +# undef hv_clear +# undef hv_clear_placeholders +# undef hv_common +# undef hv_common_key_len +# undef hv_copy_hints_hv +# undef hv_delayfree_ent +# undef hv_delete +# undef hv_delete_common +# undef hv_delete_ent +# undef hv_dump +# undef hv_ename_add +# undef hv_ename_delete +# undef hv_exists +# undef hv_exists_ent +# undef hv_fetch +# undef hv_fetch_ent +# undef hv_free_ent +# undef hv_free_ent_ret +# undef hv_free_entries +# undef hv_iterinit +# undef hv_iterkey +# undef hv_iterkeysv +# undef hv_iternext +# undef hv_iternext_flags +# undef hv_iternextsv +# undef hv_iterval +# undef hv_ksplit +# undef hv_magic +# undef hv_magic_check +# undef hv_name_set +# undef hv_notallowed +# undef hv_pushkv +# undef hv_rand_set +# undef hv_scalar +# undef hv_store +# undef hv_store_ent +# undef hv_store_flags +# undef hv_undef +# undef ibcmp +# undef ibcmp_locale +# undef ibcmp_utf8 +# undef import_builtin_bundle +# undef incline +# undef incpush +# undef incpush_if_exists +# undef incpush_use_sep +# undef ingroup +# undef init_argv_symbols +# undef init_constants +# undef init_debugger +# undef init_i18nl10n +# undef init_ids +# undef init_interp +# undef init_main_stash +# undef init_named_cv +# undef init_perllib +# undef init_postdump_symbols +# undef init_predump_symbols +# undef init_stacks +# undef init_tm +# undef init_uniprops +# undef initialize_invlist_guts +# undef inplace_aassign +# undef instr +# undef intro_my +# undef ints_to_tm +# undef intuit_method +# undef intuit_more +# undef inverse_folds_ +# undef invert +# undef invlist_array +# undef invlist_array_init_ +# undef invlist_clear +# undef invlist_clone +# undef invlist_contains_cp_ +# undef invlist_contents +# undef invlist_dump_ +# undef invlist_extend +# undef invlist_highest +# undef invlist_highest_range_start +# undef invlist_intersection_maybe_complement_2nd_ +# undef invlist_invert_ +# undef invlist_is_iterating +# undef invlist_iterfinish +# undef invlist_iterinit +# undef invlist_iternext +# undef invlist_len_ +# undef invlist_lowest +# undef invlist_max +# undef invlist_previous_index +# undef invlist_replace_list_destroys_src +# undef invlist_search_ +# undef invlist_set_len +# undef invlist_set_previous_index +# undef invlist_trim +# undef invlist_union_maybe_complement_2nd_ +# undef invlistEQ_ +# undef invmap_dump +# undef invoke_exception_hook +# undef io_close +# undef is_an_int +# undef is_c9strict_utf8_string +# undef is_c9strict_utf8_string_loc +# undef is_c9strict_utf8_string_loclen +# undef is_codeset_name_UTF8 +# undef is_existing_identifier +# undef is_fork_open +# undef is_grapheme +# undef is_handle_constructor +# undef is_in_locale_category_ +# undef is_invlist +# undef is_locale_utf8 +# undef is_lvalue_sub +# undef is_safe_syscall +# undef is_ssc_worth_it +# undef is_standard_filehandle_name +# undef is_strict_utf8_string +# undef is_strict_utf8_string_loc +# undef is_strict_utf8_string_loclen +# undef is_uni_FOO_ +# undef is_uni_perl_idcont_ +# undef is_uni_perl_idstart_ +# undef is_utf8_char_buf +# undef is_utf8_char_helper_ +# undef is_utf8_FF_helper_ +# undef is_utf8_fixed_width_buf_flags +# undef is_utf8_fixed_width_buf_loc_flags +# undef is_utf8_fixed_width_buf_loclen_flags +# undef is_utf8_FOO_ +# undef is_utf8_invariant_string_loc +# undef is_utf8_non_invariant_string +# undef is_utf8_overlong +# undef is_utf8_perl_idcont_ +# undef is_utf8_perl_idstart_ +# undef is_utf8_string +# undef is_utf8_string_flags +# undef is_utf8_string_loc +# undef is_utf8_string_loc_flags +# undef is_utf8_string_loclen +# undef is_utf8_string_loclen_flags +# undef is_utf8_valid_partial_char +# undef is_utf8_valid_partial_char_flags +# undef isa_lookup +# undef isC9_STRICT_UTF8_CHAR +# undef isFF_overlong +# undef isFOO_lc +# undef isFOO_utf8_lc +# undef isGCB +# undef isinfnan +# undef isinfnansv +# undef isLB +# undef isSB +# undef isSCRIPT_RUN +# undef isSTRICT_UTF8_CHAR +# undef isUTF8_CHAR +# undef isUTF8_CHAR_flags +# undef isWB +# undef jmaybe +# undef join_exact +# undef keyword +# undef langinfo_sv_i +# undef leave_adjust_stacks +# undef leave_scope +# undef less_dicey_bool_setlocale_r +# undef less_dicey_setlocale_r +# undef lex_bufutf8 +# undef lex_discard_to +# undef lex_grow_linestr +# undef lex_next_chunk +# undef lex_peek_unichar +# undef lex_read_space +# undef lex_read_to +# undef lex_read_unichar +# undef lex_start +# undef lex_stuff_pv +# undef lex_stuff_pvn +# undef lex_stuff_sv +# undef lex_unstuff +# undef list +# undef listkids +# undef load_charnames +# undef load_module +# undef load_module_nocontext +# undef localize +# undef long_valid_utf8_to_uv +# undef looks_like_bool +# undef looks_like_number +# undef lop +# undef lossless_NV_to_IV +# undef lsbit_pos32 +# undef lsbit_pos64 +# undef magic_clear_all_env +# undef magic_cleararylen_p +# undef magic_clearenv +# undef magic_clearhint +# undef magic_clearhints +# undef magic_clearhook +# undef magic_clearhookall +# undef magic_clearisa +# undef magic_clearpack +# undef magic_clearsig +# undef magic_copycallchecker +# undef magic_dump +# undef magic_existspack +# undef magic_freearylen_p +# undef magic_freecollxfrm +# undef magic_freedestruct +# undef magic_freemglob +# undef magic_freeovrld +# undef magic_freeutf8 +# undef magic_get +# undef magic_getarylen +# undef magic_getdebugvar +# undef magic_getdefelem +# undef magic_getnkeys +# undef magic_getpack +# undef magic_getpos +# undef magic_getsig +# undef magic_getsubstr +# undef magic_gettaint +# undef magic_getuvar +# undef magic_getvec +# undef magic_killbackrefs +# undef magic_methcall1 +# undef magic_methpack +# undef magic_nextpack +# undef magic_regdata_cnt +# undef magic_regdatum_get +# undef magic_regdatum_set +# undef magic_scalarpack +# undef magic_set +# undef magic_set_all_env +# undef magic_setarylen +# undef magic_setcollxfrm +# undef magic_setdbline +# undef magic_setdebugvar +# undef magic_setdefelem +# undef magic_setenv +# undef magic_sethint +# undef magic_sethook +# undef magic_sethookall +# undef magic_setisa +# undef magic_setlvref +# undef magic_setmglob +# undef magic_setnkeys +# undef magic_setnonelem +# undef magic_setpack +# undef magic_setpos +# undef magic_setregexp +# undef magic_setsig +# undef magic_setsigall +# undef magic_setsubstr +# undef magic_settaint +# undef magic_setutf8 +# undef magic_setuvar +# undef magic_setvec +# undef magic_sizepack +# undef magic_wipepack +# undef make_exactf_invlist +# undef make_matcher +# undef make_trie +# undef malloc_good_size +# undef malloced_size +# undef markstack_grow +# undef matcher_matches_sv +# undef maybe_multimagic_gv +# undef mayberelocate +# undef mbtowc_ +# undef measure_struct +# undef mem_collxfrm_ +# undef mem_log_alloc +# undef mem_log_common +# undef mem_log_del_sv +# undef mem_log_free +# undef mem_log_new_sv +# undef mem_log_realloc +# undef mess +# undef mess_alloc +# undef mess_nocontext +# undef mess_sv +# undef mg_clear +# undef mg_copy +# undef mg_dup +# undef mg_find +# undef mg_find_mglob +# undef mg_findext +# undef mg_free +# undef mg_free_type +# undef mg_freeext +# undef mg_get +# undef mg_localize +# undef mg_magical +# undef mg_set +# undef mg_size +# undef mini_mktime +# undef minus_v +# undef missingterm +# undef mode_from_discipline +# undef modkids +# undef more_sv +# undef moreswitches +# undef mortal_destructor_sv +# undef mortal_getenv +# undef mortal_svfunc_x +# undef mortalized_pv_copy +# undef move_proto_attr +# undef mro_clean_isarev +# undef mro_gather_and_rename +# undef mro_get_linear_isa +# undef mro_get_linear_isa_dfs +# undef mro_isa_changed_in +# undef mro_meta_dup +# undef mro_method_changed_in +# undef mro_package_moved +# undef msbit_pos32 +# undef msbit_pos64 +# undef mul128 +# undef multiconcat_stringify +# undef multideref_stringify +# undef my_atof +# undef my_atof3 +# undef my_attrs +# undef my_bytes_to_utf8 +# undef my_chsize +# undef my_clearenv +# undef my_dirfd +# undef my_exit +# undef my_exit_jump +# undef my_failure_exit +# undef my_fflush_all +# undef my_fork +# undef my_kid +# undef my_localeconv +# undef my_lstat_flags +# undef my_memrchr +# undef my_pclose +# undef my_popen +# undef my_popen_list +# undef my_setenv +# undef my_setlocale_debug_string_i +# undef my_socketpair +# undef my_stat_flags +# undef my_strerror +# undef my_strftime +# undef my_strlcat +# undef my_strlcpy +# undef my_strnlen +# undef my_strtod +# undef my_unexec +# undef native_querylocale_i +# undef need_utf8 +# undef new_collate +# undef new_ctype +# undef new_he +# undef new_invlist_ +# undef new_invlist_C_array_ +# undef new_LC_ALL +# undef new_logop +# undef new_msg_hv +# undef new_numeric +# undef new_stackinfo +# undef new_stackinfo_flags +# undef new_version +# undef newANONATTRSUB +# undef newANONHASH +# undef newANONLIST +# undef newANONSUB +# undef newARGDEFELEMOP +# undef newASSIGNOP +# undef newATTRSUB +# undef newATTRSUB_x +# undef newAV +# undef newAV_alloc_x +# undef newAV_alloc_xz +# undef newAV_mortal +# undef newAVav +# undef newAVhv +# undef newAVREF +# undef newBINOP +# undef newCONDOP +# undef newCONSTSUB +# undef newCONSTSUB_flags +# undef newCVREF +# undef newDEFEROP +# undef newDEFSVOP +# undef newFORM +# undef newFOROP +# undef newGIVENOP +# undef newGIVWHENOP +# undef newGVgen +# undef newGVgen_flags +# undef newGVOP +# undef newGVREF +# undef newHV +# undef newHVhv +# undef newHVREF +# undef newIO +# undef newLISTOP +# undef newLISTOPn +# undef newLOGOP +# undef newLOOPEX +# undef newLOOPOP +# undef newMETHOP +# undef newMETHOP_internal +# undef newMETHOP_named +# undef newMYSUB +# undef newNULLLIST +# undef newOP +# undef newPADNAMELIST +# undef newPADNAMEouter +# undef newPADNAMEpvn +# undef newPADOP +# undef newPADxVOP +# undef newPMOP +# undef newPROG +# undef newPVOP +# undef newRANGE +# undef newRV +# undef newRV_noinc +# undef newSLICEOP +# undef newSTATEOP +# undef newSTUB +# undef newSUB +# undef newSV +# undef newSV_false +# undef newSV_true +# undef newSV_type +# undef newSV_type_mortal +# undef newSVavdefelem +# undef newSVbool +# undef newSVhek +# undef newSVhek_mortal +# undef newSViv +# undef newSVnv +# undef newSVOP +# undef newSVpv +# undef newSVpv_share +# undef newSVpvf +# undef newSVpvf_nocontext +# undef newSVpvn +# undef newSVpvn_flags +# undef newSVpvn_share +# undef newSVpvz +# undef newSVREF +# undef newSVrv +# undef newSVsv +# undef newSVsv_flags +# undef newSVsv_flags_NN +# undef newSVsv_nomg +# undef newSVuv +# undef newTRYCATCHOP +# undef newUNOP +# undef newUNOP_AUX +# undef newWHENOP +# undef newWHILEOP +# undef newXS +# undef newXS_deffile +# undef newXS_flags +# undef newXS_len_flags +# undef next_symbol +# undef nextargv +# undef nextchar +# undef no_bareword_allowed +# undef no_bareword_filehandle +# undef no_fh_allowed +# undef noperl_die +# undef noshutdownhook +# undef not_a_number +# undef not_incrementable +# undef nothreadhook +# undef notify_parser_that_encoding_changed +# undef nuke_stacks +# undef num_overflow +# undef oopsAV +# undef oopsHV +# undef op_append_elem +# undef op_append_list +# undef op_class +# undef op_clear +# undef op_contextualize +# undef op_convert_list +# undef op_dump +# undef op_force_list +# undef op_free +# undef op_integerize +# undef op_linklist +# undef op_lvalue +# undef op_null +# undef op_parent +# undef op_prepend_elem +# undef op_prune_chain_head +# undef op_refcnt_lock +# undef op_refcnt_unlock +# undef op_relocate_sv +# undef op_scope +# undef op_sibling_splice +# undef op_std_init +# undef op_unscope +# undef op_varname +# undef op_wrap_finally +# undef opdump_printf +# undef open_script +# undef openn_cleanup +# undef openn_setup +# undef opmethod_stash +# undef opslab_force_free +# undef opslab_free +# undef opslab_free_nopad +# undef opslab_slot_offset +# undef optimize_op +# undef optimize_optree +# undef optimize_regclass +# undef output_check_environment_warning +# undef output_non_portable +# undef output_posix_warnings +# undef pack_rec +# undef package +# undef package_version +# undef packlist +# undef pad_add_anon +# undef pad_add_name_pv +# undef pad_add_name_pvn +# undef pad_add_name_sv +# undef pad_add_weakref +# undef pad_alloc +# undef pad_alloc_name +# undef pad_block_start +# undef pad_check_dup +# undef pad_findlex +# undef pad_findmy_pv +# undef pad_findmy_pvn +# undef pad_findmy_sv +# undef pad_fixup_inner_anons +# undef pad_free +# undef pad_leavemy +# undef pad_new +# undef pad_push +# undef pad_reset +# undef pad_setsv +# undef pad_sv +# undef pad_swipe +# undef pad_tidy +# undef padlist_dup +# undef padlist_store +# undef padname_dup +# undef PadnameIN_SCOPE +# undef padnamelist_dup +# undef padnamelist_fetch +# undef padnamelist_store +# undef parse_arithexpr +# undef parse_barestmt +# undef parse_block +# undef parse_body +# undef parse_fullexpr +# undef parse_fullstmt +# undef parse_gv_stash_name +# undef parse_ident +# undef parse_ident_no_copy +# undef parse_label +# undef parse_LC_ALL_string +# undef parse_listexpr +# undef parse_lparen_question_flags +# undef parse_stmtseq +# undef parse_subsignature +# undef parse_termexpr +# undef parse_unicode_opts +# undef parse_uniprop_string +# undef parser_dup +# undef parser_free +# undef parser_free_nexttoke_ops +# undef path_is_searchable +# undef peep +# undef pending_ident +# undef Perl_deb_nocontext +# undef Perl_form_nocontext +# undef Perl_load_module_nocontext +# undef Perl_mess_nocontext +# undef Perl_newSVpvf_nocontext +# undef Perl_sv_catpvf_mg_nocontext +# undef Perl_sv_catpvf_nocontext +# undef Perl_sv_setpvf_mg_nocontext +# undef Perl_sv_setpvf_nocontext +# undef Perl_warn_nocontext +# undef Perl_warner_nocontext +# undef PerlEnv_putenv +# undef PerlIO_clearerr +# undef PerlIO_close +# undef PerlIO_eof +# undef PerlIO_error +# undef PerlIO_fileno +# undef PerlIO_fill +# undef PerlIO_flush +# undef PerlIO_get_base +# undef PerlIO_get_bufsiz +# undef PerlIO_get_cnt +# undef PerlIO_get_ptr +# undef PerlIO_read +# undef PerlIO_restore_errno +# undef PerlIO_save_errno +# undef PerlIO_seek +# undef PerlIO_set_cnt +# undef PerlIO_set_ptrcnt +# undef PerlIO_setlinebuf +# undef PerlIO_stderr +# undef PerlIO_stdin +# undef PerlIO_stdout +# undef PerlIO_tell +# undef PerlIO_unread +# undef PerlIO_write +# undef PerlLIO_dup2_cloexec +# undef PerlLIO_dup_cloexec +# undef PerlLIO_open3_cloexec +# undef PerlLIO_open_cloexec +# undef PerlProc_pipe_cloexec +# undef PerlSock_accept_cloexec +# undef PerlSock_socket_cloexec +# undef PerlSock_socketpair_cloexec +# undef perly_sighandler +# undef phase_name +# undef pidgone +# undef pm_description +# undef pmop_dump +# undef pmruntime +# undef pmtrans +# undef pop_scope +# undef pop_stackinfo +# undef populate_anyof_bitmap_from_invlist +# undef populate_bitmap_from_invlist +# undef populate_hash_from_C_localeconv +# undef populate_hash_from_localeconv +# undef populate_invlist_from_bitmap +# undef pregcomp +# undef pregexec +# undef pregfree +# undef pregfree2 +# undef prepare_export_lexical +# undef prescan_version +# undef print_collxfrm_input_and_return +# undef printbuf +# undef process_special_blocks +# undef ptr_hash +# undef ptr_table_fetch +# undef ptr_table_find +# undef ptr_table_free +# undef ptr_table_new +# undef ptr_table_split +# undef ptr_table_store +# undef push_scope +# undef push_stackinfo +# undef put_charclass_bitmap_innards +# undef put_charclass_bitmap_innards_common +# undef put_charclass_bitmap_innards_invlist +# undef put_code_point +# undef put_range +# undef pv_display +# undef pv_display_flags +# undef pv_escape +# undef pv_pretty +# undef pv_uni_display +# undef qerror +# undef quadmath_format_needed +# undef quadmath_format_valid +# undef querylocale_2008_i +# undef rck_elide_nothing +# undef rcpv_copy +# undef rcpv_free +# undef rcpv_new +# undef re_compile +# undef re_croak +# undef re_dup_guts +# undef re_exec_indentf +# undef re_indentf +# undef re_intuit_start +# undef re_intuit_string +# undef re_op_compile +# undef re_printf +# undef reentrant_free +# undef reentrant_init +# undef reentrant_retry +# undef reentrant_size +# undef ref_array_or_hash +# undef refcounted_he_chain_2hv +# undef refcounted_he_fetch_pv +# undef refcounted_he_fetch_pvn +# undef refcounted_he_fetch_sv +# undef refcounted_he_free +# undef refcounted_he_inc +# undef refcounted_he_new_pv +# undef refcounted_he_new_pvn +# undef refcounted_he_new_sv +# undef refcounted_he_value +# undef refkids +# undef refto +# undef reg +# undef reg1node +# undef reg2node +# undef reg_add_data +# undef reg_check_named_buff_matched +# undef reg_la_NOTHING +# undef reg_la_OPFAIL +# undef reg_named_buff +# undef reg_named_buff_all +# undef reg_named_buff_exists +# undef reg_named_buff_fetch +# undef reg_named_buff_firstkey +# undef reg_named_buff_iter +# undef reg_named_buff_nextkey +# undef reg_named_buff_scalar +# undef reg_node +# undef reg_numbered_buff_fetch +# undef reg_numbered_buff_fetch_flags +# undef reg_numbered_buff_length +# undef reg_numbered_buff_store +# undef reg_qr_package +# undef reg_scan_name +# undef reg_skipcomment +# undef reg_temp_copy +# undef regatom +# undef regbranch +# undef regclass +# undef regcp_restore +# undef regcppop +# undef regcppush +# undef regcurly +# undef regdump +# undef regdump_extflags +# undef regdump_intflags +# undef regdupe_internal +# undef regex_set_precedence +# undef regexec_flags +# undef regfree_internal +# undef reghop3 +# undef reghopmaybe3 +# undef reginclass +# undef reginitcolors +# undef reginsert +# undef regmatch +# undef regnext +# undef regnode_after +# undef regnode_guts +# undef regnode_guts_debug +# undef regpiece +# undef regpnode +# undef regprop +# undef regrepeat +# undef regtail +# undef regtail_study +# undef regtry +# undef release_RExC_state +# undef repeatcpy +# undef report_evil_fh +# undef report_redefined_cv +# undef report_uninit +# undef report_wrongway_fh +# undef require_pv +# undef require_tie_mod +# undef restore_magic +# undef resume_compcv_and_save +# undef resume_compcv_final +# undef rninstr +# undef rpeep +# undef rpp_context +# undef rpp_extend +# undef rpp_invoke_xs +# undef rpp_is_lone +# undef rpp_obliterate_stack_to +# undef rpp_pop_1_norc +# undef rpp_popfree_1 +# undef rpp_popfree_1_NN +# undef rpp_popfree_2 +# undef rpp_popfree_2_NN +# undef rpp_popfree_to +# undef rpp_popfree_to_NN +# undef rpp_push_1 +# undef rpp_push_1_norc +# undef rpp_push_2 +# undef rpp_push_IMM +# undef rpp_replace_1_1 +# undef rpp_replace_1_1_NN +# undef rpp_replace_1_IMM_NN +# undef rpp_replace_2_1 +# undef rpp_replace_2_1_COMMON +# undef rpp_replace_2_1_NN +# undef rpp_replace_2_IMM_NN +# undef rpp_replace_at +# undef rpp_replace_at_NN +# undef rpp_replace_at_norc +# undef rpp_replace_at_norc_NN +# undef rpp_stack_is_rc +# undef rpp_try_AMAGIC_1 +# undef rpp_try_AMAGIC_2 +# undef rpp_xpush_1 +# undef rpp_xpush_2 +# undef rpp_xpush_IMM +# undef rsignal +# undef rsignal_restore +# undef rsignal_save +# undef rsignal_state +# undef run_body +# undef run_user_filter +# undef runops_debug +# undef runops_standard +# undef runops_wrap +# undef rv2cv_op_cv +# undef rvpv_dup +# undef rxres_free +# undef rxres_restore +# undef rxres_save +# undef safesyscalloc +# undef safesysfree +# undef safesysmalloc +# undef safesysrealloc +# undef same_dirent +# undef save_adelete +# undef save_aelem +# undef save_aelem_flags +# undef save_alloc +# undef save_aptr +# undef save_ary +# undef save_bool +# undef save_clearsv +# undef save_delete +# undef save_destructor +# undef save_destructor_x +# undef save_freeop +# undef save_freepv +# undef save_freercpv +# undef save_freesv +# undef save_generic_pvref +# undef save_generic_svref +# undef save_gp +# undef save_hash +# undef save_hdelete +# undef save_hek_flags +# undef save_helem +# undef save_helem_flags +# undef save_hints +# undef save_hptr +# undef save_I16 +# undef save_I32 +# undef save_I8 +# undef save_int +# undef save_item +# undef save_iv +# undef save_lines +# undef save_magic_flags +# undef save_mortalizesv +# undef save_op +# undef save_padsv_and_mortalize +# undef save_pptr +# undef save_pushi32ptr +# undef save_pushptr +# undef save_pushptri32ptr +# undef save_pushptrptr +# undef save_rcpv +# undef save_re_context +# undef save_scalar +# undef save_scalar_at +# undef save_set_svflags +# undef save_shared_pvref +# undef save_sptr +# undef save_strlen +# undef save_svref +# undef save_to_buffer +# undef save_vptr +# undef savepv +# undef savepvn +# undef savesharedpv +# undef savesharedpvn +# undef savesharedsvpv +# undef savestack_grow +# undef savestack_grow_cnt +# undef savesvpv +# undef sawparens +# undef scalar +# undef scalar_mod_type +# undef scalarboolean +# undef scalarkids +# undef scalarvoid +# undef scan_bin +# undef scan_commit +# undef scan_const +# undef scan_formline +# undef scan_heredoc +# undef scan_hex +# undef scan_ident +# undef scan_inputsymbol +# undef scan_num +# undef scan_oct +# undef scan_pat +# undef scan_str +# undef scan_subst +# undef scan_trans +# undef scan_version +# undef scan_vstring +# undef scan_word +# undef search_const +# undef seed +# undef sequence_num +# undef set_ANYOF_arg +# undef set_caret_X +# undef set_context +# undef set_numeric_standard +# undef set_numeric_underlying +# undef set_padlist +# undef set_regex_pv +# undef set_save_buffer_min_size +# undef setdefout +# undef setfd_cloexec +# undef setfd_cloexec_for_nonsysfd +# undef setfd_cloexec_or_inhexec_by_sysfdness +# undef setfd_inhexec +# undef setfd_inhexec_for_sysfd +# undef setlocale_failure_panic_via_i +# undef setup_canned_invlist_ +# undef share_hek +# undef share_hek_flags +# undef should_warn_nl +# undef should_we_output_Debug_r +# undef si_dup +# undef sighandler +# undef sighandler1 +# undef sighandler3 +# undef simplify_sort +# undef single_1bit_pos32 +# undef single_1bit_pos64 +# undef size_to_psize +# undef skip_to_be_ignored_text +# undef skipspace_flags +# undef Slab_Alloc +# undef Slab_Free +# undef Slab_to_ro +# undef Slab_to_rw +# undef sortcv +# undef sortcv_stacked +# undef sortcv_xsub +# undef sortsv +# undef sortsv_flags +# undef sortsv_flags_impl +# undef space_join_names_mortal +# undef ss_dup +# undef ssc_add_range +# undef ssc_and +# undef ssc_anything +# undef ssc_clear_locale +# undef ssc_cp_and +# undef ssc_finalize +# undef ssc_init +# undef ssc_intersection +# undef ssc_is_anything +# undef ssc_is_cp_posixl_init +# undef ssc_or +# undef ssc_union +# undef stack_grow +# undef start_subparse +# undef str_to_version +# undef strftime8 +# undef strftime_tm +# undef strict_utf8_to_uv +# undef study_chunk +# undef sub_crush_depth +# undef sublex_done +# undef sublex_push +# undef sublex_start +# undef subsignature_append_fence_op +# undef subsignature_append_positional +# undef subsignature_append_slurpy +# undef subsignature_finish +# undef subsignature_start +# undef suspend_compcv +# undef sv_2bool +# undef sv_2bool_flags +# undef sv_2cv +# undef sv_2io +# undef sv_2iuv_common +# undef sv_2iuv_non_preserve +# undef sv_2iv +# undef sv_2iv_flags +# undef sv_2mortal +# undef sv_2num +# undef sv_2nv_flags +# undef sv_2pv +# undef sv_2pv_flags +# undef sv_2pv_nolen +# undef sv_2pvbyte +# undef sv_2pvbyte_flags +# undef sv_2pvbyte_nolen +# undef sv_2pvutf8 +# undef sv_2pvutf8_flags +# undef sv_2pvutf8_nolen +# undef sv_2uv +# undef sv_2uv_flags +# undef sv_add_arena +# undef sv_backoff +# undef sv_bless +# undef sv_buf_to_ro +# undef sv_buf_to_rw +# undef sv_can_swipe_pv_buf +# undef sv_cat_decode +# undef sv_catpv +# undef sv_catpv_flags +# undef sv_catpv_mg +# undef sv_catpvf +# undef sv_catpvf_mg +# undef sv_catpvf_mg_nocontext +# undef sv_catpvf_nocontext +# undef sv_catpvn +# undef sv_catpvn_flags +# undef sv_catpvn_mg +# undef sv_catsv +# undef sv_catsv_flags +# undef sv_catsv_mg +# undef sv_chop +# undef sv_clean_all +# undef sv_clean_objs +# undef sv_clear +# undef sv_cmp_flags +# undef sv_cmp_locale_flags +# undef sv_collxfrm +# undef sv_collxfrm_flags +# undef sv_copypv +# undef sv_copypv_flags +# undef sv_copypv_nomg +# undef sv_dec +# undef sv_dec_nomg +# undef sv_del_backref +# undef sv_derived_from +# undef sv_derived_from_hv +# undef sv_derived_from_pv +# undef sv_derived_from_pvn +# undef sv_derived_from_sv +# undef sv_derived_from_svpvn +# undef sv_destroyable +# undef sv_display +# undef sv_does +# undef sv_does_pv +# undef sv_does_pvn +# undef sv_does_sv +# undef sv_dump +# undef sv_dump_depth +# undef sv_dup +# undef sv_dup_common +# undef sv_dup_hvaux +# undef sv_dup_inc +# undef sv_dup_inc_multiple +# undef sv_eq +# undef sv_eq_flags +# undef sv_exp_grow +# undef sv_force_normal +# undef sv_force_normal_flags +# undef sv_free +# undef sv_free_arenas +# undef sv_get_backrefs +# undef sv_gets +# undef sv_grow +# undef sv_grow_fresh +# undef sv_i_ncmp +# undef sv_i_ncmp_desc +# undef sv_inc +# undef sv_inc_nomg +# undef sv_insert +# undef sv_insert_flags +# undef sv_isa +# undef sv_isa_sv +# undef sv_isobject +# undef sv_langinfo +# undef sv_len +# undef sv_len_utf8 +# undef sv_len_utf8_nomg +# undef sv_magic +# undef sv_magicext +# undef sv_magicext_mglob +# undef sv_mark_arenas +# undef sv_mortalcopy +# undef sv_mortalcopy_flags +# undef sv_ncmp +# undef sv_ncmp_desc +# undef sv_newmortal +# undef sv_newref +# undef sv_nosharing +# undef sv_numeq +# undef sv_numeq_flags +# undef sv_only_taint_gmagic +# undef sv_or_pv_pos_u2b +# undef sv_peek +# undef sv_pos_b2u +# undef sv_pos_b2u_flags +# undef sv_pos_b2u_midway +# undef sv_pos_u2b +# undef sv_pos_u2b_cached +# undef sv_pos_u2b_flags +# undef sv_pos_u2b_forwards +# undef sv_pos_u2b_midway +# undef sv_pv +# undef sv_pvbyte +# undef sv_pvbyten_force +# undef sv_pvbyten_force_wrapper +# undef sv_pvn_force +# undef sv_pvn_force_flags +# undef sv_pvutf8 +# undef sv_pvutf8n_force +# undef sv_pvutf8n_force_wrapper +# undef sv_recode_to_utf8 +# undef sv_ref +# undef sv_reftype +# undef sv_regex_global_pos_clear +# undef sv_regex_global_pos_get +# undef sv_regex_global_pos_set +# undef sv_replace +# undef sv_report_used +# undef sv_reset +# undef sv_resetpvn +# undef sv_rvunweaken +# undef sv_rvweaken +# undef sv_set_bool +# undef sv_set_false +# undef sv_set_true +# undef sv_set_undef +# undef sv_sethek +# undef sv_setiv +# undef sv_setiv_mg +# undef sv_setnv +# undef sv_setnv_mg +# undef sv_setpv +# undef sv_setpv_bufsize +# undef sv_setpv_freshbuf +# undef sv_setpv_mg +# undef sv_setpvf +# undef sv_setpvf_mg +# undef sv_setpvf_mg_nocontext +# undef sv_setpvf_nocontext +# undef sv_setpvn +# undef sv_setpvn_fresh +# undef sv_setpvn_mg +# undef sv_setref_iv +# undef sv_setref_nv +# undef sv_setref_pv +# undef sv_setref_pvn +# undef sv_setref_uv +# undef sv_setrv_inc +# undef sv_setrv_inc_mg +# undef sv_setrv_noinc +# undef sv_setrv_noinc_mg +# undef sv_setsv +# undef sv_setsv_cow +# undef sv_setsv_flags +# undef sv_setsv_mg +# undef sv_setuv +# undef sv_setuv_mg +# undef sv_streq +# undef sv_streq_flags +# undef sv_strftime_common +# undef sv_strftime_ints +# undef sv_strftime_tm +# undef sv_string_from_errnum +# undef sv_sweep_arenas +# undef sv_taint +# undef sv_tainted +# undef sv_true +# undef sv_unglob +# undef sv_uni_display +# undef sv_unmagic +# undef sv_unmagicext +# undef sv_unref +# undef sv_unref_flags +# undef sv_untaint +# undef sv_upgrade +# undef sv_usepvn +# undef sv_usepvn_flags +# undef sv_usepvn_mg +# undef sv_utf8_decode +# undef sv_utf8_downgrade +# undef sv_utf8_downgrade_flags +# undef sv_utf8_downgrade_nomg +# undef sv_utf8_encode +# undef sv_utf8_upgrade +# undef sv_utf8_upgrade_flags +# undef sv_utf8_upgrade_flags_grow +# undef sv_utf8_upgrade_nomg +# undef sv_vcatpvf +# undef sv_vcatpvf_mg +# undef sv_vcatpvfn +# undef sv_vcatpvfn_flags +# undef sv_vsetpvf +# undef sv_vsetpvf_mg +# undef sv_vsetpvfn +# undef sv_vstring_get +# undef SvAMAGIC_off +# undef SvAMAGIC_on +# undef SvGETMAGIC +# undef SvIV +# undef SvIV_nomg +# undef SvNV +# undef SvNV_nomg +# undef SvPV_helper +# undef SvPVXtrue +# undef SvREFCNT_dec_ret_NULL +# undef SvREFCNT_dec_set_NULL +# undef SvTRUE +# undef SvTRUE_common +# undef SvTRUE_NN +# undef SvTRUE_nomg +# undef SvUV +# undef SvUV_nomg +# undef swallow_bom +# undef switch_argstack +# undef switch_to_global_locale +# undef sync_locale +# undef sys_intern_clear +# undef sys_intern_dup +# undef sys_intern_init +# undef taint_env +# undef taint_proper +# undef thread_locale_init +# undef thread_locale_term +# undef tied_method +# undef tmps_grow_p +# undef to_byte_substr +# undef to_case_cp_list +# undef to_fold_latin1_ +# undef to_lower_latin1 +# undef to_uni_fold +# undef to_uni_fold_flags_ +# undef to_uni_lower +# undef to_uni_title +# undef to_uni_upper +# undef to_upper_title_latin1_ +# undef to_utf8_case_ +# undef to_utf8_fold_flags_ +# undef to_utf8_lower_flags_ +# undef to_utf8_substr +# undef to_utf8_title_flags_ +# undef to_utf8_upper_flags_ +# undef tokenize_use +# undef tokeq +# undef tokereport +# undef too_few_arguments_pv +# undef too_many_arguments_pv +# undef translate_substr_offsets +# undef traverse_op_tree +# undef turkic_fc +# undef turkic_lc +# undef turkic_uc +# undef uiv_2buf +# undef unexpected_non_continuation_text +# undef unlnk +# undef unpack_rec +# undef unpackstring +# undef unreferenced_to_tmp_stack +# undef unshare_hek +# undef unshare_hek_or_pvn +# undef unsharepvn +# undef unwind_handler_stack +# undef unwind_paren +# undef unwind_scan_frames +# undef update_debugger_info +# undef update_PL_curlocales_i +# undef upg_version +# undef usage +# undef use_curlocale_scratch +# undef utf16_textfilter +# undef utf16_to_utf8_base +# undef utf8_distance +# undef utf8_hop +# undef utf8_hop_back +# undef utf8_hop_back_overshoot +# undef utf8_hop_forward +# undef utf8_hop_forward_overshoot +# undef utf8_hop_overshoot +# undef utf8_hop_safe +# undef utf8_length +# undef utf8_mg_len_cache_update +# undef utf8_mg_pos_cache_update +# undef utf8_to_bytes +# undef utf8_to_bytes_ +# undef utf8_to_bytes_new_pv +# undef utf8_to_bytes_overwrite +# undef utf8_to_bytes_temp_pv +# undef utf8_to_utf16_base +# undef utf8_to_uv +# undef utf8_to_uv_errors +# undef utf8_to_uv_flags +# undef utf8_to_uv_msgs +# undef utf8_to_uv_msgs_helper_ +# undef utf8_to_uv_or_die +# undef utf8_to_uvchr +# undef utf8_to_uvuni +# undef utf8n_to_uvchr +# undef utf8n_to_uvchr_error +# undef utf8n_to_uvchr_msgs +# undef utf8n_to_uvuni +# undef utilize +# undef uv_to_utf8 +# undef uv_to_utf8_flags +# undef uv_to_utf8_msgs +# undef uvchr_to_utf8 +# undef uvchr_to_utf8_flags +# undef uvchr_to_utf8_flags_msgs +# undef uvoffuni_to_utf8_flags +# undef uvoffuni_to_utf8_flags_msgs +# undef uvuni_to_utf8 +# undef valid_identifier_pve +# undef valid_identifier_pvn +# undef valid_identifier_sv +# undef valid_utf8_to_uv +# undef valid_utf8_to_uvchr +# undef validate_proto +# undef variant_byte_number +# undef variant_under_utf8_count +# undef varname +# undef vcmp +# undef vcroak +# undef vdeb +# undef vfatal_warner +# undef vform +# undef visit +# undef vivify_defelem +# undef vivify_ref +# undef vload_module +# undef vmess +# undef vnewSVpvf +# undef vnormal +# undef vnumify +# undef voidnonfinal +# undef vstringify +# undef vverify +# undef vwarn +# undef vwarner +# undef wait4pid +# undef warn +# undef warn_elem_scalar_context +# undef warn_expect_operator +# undef warn_nocontext +# undef warn_not_dirhandle +# undef warn_on_first_deprecated_use +# undef warn_sv +# undef warner +# undef warner_nocontext +# undef watch +# undef whichsig +# undef whichsig_pv +# undef whichsig_pvn +# undef whichsig_sv +# undef win32_setlocale +# undef Win_byte_string_to_wstring +# undef Win_wstring_to_byte_string +# undef with_queued_errors +# undef wrap_infix_plugin +# undef wrap_keyword_plugin +# undef wrap_op_checker +# undef wrap_wsetlocale +# undef write_to_stderr +# undef xs_boot_epilog +# undef XS_builtin_indexed +# undef yyerror +# undef yyerror_non_ascii_message +# undef yyerror_pv +# undef yyerror_pvn +# undef yylex +# undef yyparse +# undef yyquit +# undef yyunlex +# undef yywarn +# endif /* !defined(PERL_CORE) && defined(PERL_NO_SHORT_NAMES) */ +#else /* if !defined(PERL_DO_UNDEF_SHORT_NAMES) */ -#if !defined(MULTIPLICITY) -/* undefined symbols, point them back at the usual ones */ -# define Perl_deb_nocontext Perl_deb -# define Perl_form_nocontext Perl_form -# define Perl_load_module_nocontext Perl_load_module -# define Perl_mess_nocontext Perl_mess -# define Perl_newSVpvf_nocontext Perl_newSVpvf -# define Perl_sv_catpvf_nocontext Perl_sv_catpvf -# define Perl_sv_catpvf_mg_nocontext Perl_sv_catpvf_mg -# define Perl_sv_setpvf_nocontext Perl_sv_setpvf -# define Perl_sv_setpvf_mg_nocontext Perl_sv_setpvf_mg -# define Perl_warn_nocontext Perl_warn -# define Perl_warner_nocontext Perl_warner -#endif /* !defined(MULTIPLICITY) */ -#if !defined(PERL_CORE) -/* Compatibility stubs. Compile extensions with -DPERL_NOCOMPAT to - * disable them. - */ -# define sv_setptrobj(rv,ptr,name) sv_setref_iv(rv,name,PTR2IV(ptr)) -# define sv_setptrref(rv,ptr) sv_setref_iv(rv,NULL,PTR2IV(ptr)) -# if !defined(PERL_NOCOMPAT) - -/* Compatibility for this renamed function. */ -# define perl_atexit(a,b) Perl_call_atexit(aTHX_ a,b) - -/* Compatibility for these functions that had a 'perl_' prefix before - * 'Perl_' became the standard */ -# define perl_call_argv(a,b,c) Perl_call_argv(aTHX_ a,b,c) -# define perl_call_method(a,b) Perl_call_method(aTHX_ a,b) -# define perl_call_pv(a,b) Perl_call_pv(aTHX_ a,b) -# define perl_call_sv(a,b) Perl_call_sv(aTHX_ a,b) -# define perl_eval_pv(a,b) Perl_eval_pv(aTHX_ a,b) -# define perl_eval_sv(a,b) Perl_eval_sv(aTHX_ a,b) -# define perl_get_av(a,b) Perl_get_av(aTHX_ a,b) -# define perl_get_cv(a,b) Perl_get_cv(aTHX_ a,b) -# define perl_get_hv(a,b) Perl_get_hv(aTHX_ a,b) -# define perl_get_sv(a,b) Perl_get_sv(aTHX_ a,b) -# define perl_init_i18nl10n(a) Perl_init_i18nl10n(aTHX_ a) -# define perl_require_pv(a) Perl_require_pv(aTHX_ a) - -/* Before C99, macros could not wrap varargs functions. This - provides a set of compatibility functions that don't take an - extra argument but grab the context pointer using the macro dTHX. - */ - -# if defined(MULTIPLICITY) && !defined(PERL_NO_SHORT_NAMES) && \ - !defined(PERL_WANT_VARARGS) -# define deb Perl_deb_nocontext -# define form Perl_form_nocontext -# define load_module Perl_load_module_nocontext -# define mess Perl_mess_nocontext -# define newSVpvf Perl_newSVpvf_nocontext -# define sv_catpvf Perl_sv_catpvf_nocontext -# define sv_catpvf_mg Perl_sv_catpvf_mg_nocontext -# define sv_setpvf Perl_sv_setpvf_nocontext -# define sv_setpvf_mg Perl_sv_setpvf_mg_nocontext -# define warn Perl_warn_nocontext -# define warner Perl_warner_nocontext -# endif /* defined(MULTIPLICITY) && !defined(PERL_NO_SHORT_NAMES) && - !defined(PERL_WANT_VARARGS) */ -# endif /* !defined(PERL_NOCOMPAT) */ -#endif /* !defined(PERL_CORE) */ -#if !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) @@ -146,7 +2010,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) @@ -217,7 +2080,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) @@ -305,41 +2167,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) @@ -663,7 +2513,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) @@ -819,26 +2668,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) @@ -847,7 +2688,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) @@ -910,7 +2750,20 @@ # define sv_setpvf_nocontext Perl_sv_setpvf_nocontext # define warn_nocontext Perl_warn_nocontext # define warner_nocontext Perl_warner_nocontext -# endif /* defined(MULTIPLICITY) */ +# else /* if !defined(MULTIPLICITY) */ + /* undefined symbols, point them back at the usual ones */ +# define Perl_deb_nocontext Perl_deb +# define Perl_form_nocontext Perl_form +# define Perl_load_module_nocontext Perl_load_module +# define Perl_mess_nocontext Perl_mess +# define Perl_newSVpvf_nocontext Perl_newSVpvf +# define Perl_sv_catpvf_nocontext Perl_sv_catpvf +# define Perl_sv_catpvf_mg_nocontext Perl_sv_catpvf_mg +# define Perl_sv_setpvf_nocontext Perl_sv_setpvf +# define Perl_sv_setpvf_mg_nocontext Perl_sv_setpvf_mg +# define Perl_warn_nocontext Perl_warn +# define Perl_warner_nocontext Perl_warner +# endif /* !defined(MULTIPLICITY) */ # if !defined(MULTIPLICITY) || defined(PERL_CORE) || \ defined(PERL_WANT_VARARGS) # define deb(...) Perl_deb(aTHX_ __VA_ARGS__) @@ -1830,21 +3683,57 @@ # 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 # define do_exec3(a,b,c) Perl_do_exec3(aTHX_ a,b,c) # endif -# endif /* defined(PERL_CORE) */ +# else /* if !defined(PERL_CORE) */ +/* Compatibility stubs. Compile extensions with -DPERL_NOCOMPAT to + * disable them. + */ +# define sv_setptrobj(rv,ptr,name) sv_setref_iv(rv,name,PTR2IV(ptr)) +# define sv_setptrref(rv,ptr) sv_setref_iv(rv,NULL,PTR2IV(ptr)) +# if !defined(PERL_NOCOMPAT) + +/* Compatibility for this renamed function. */ +# define perl_atexit(a,b) Perl_call_atexit(aTHX_ a,b) + +/* Compatibility for these functions that had a 'perl_' prefix before + * 'Perl_' became the standard */ +# define perl_call_argv(a,b,c) Perl_call_argv(aTHX_ a,b,c) +# define perl_call_method(a,b) Perl_call_method(aTHX_ a,b) +# define perl_call_pv(a,b) Perl_call_pv(aTHX_ a,b) +# define perl_call_sv(a,b) Perl_call_sv(aTHX_ a,b) +# define perl_eval_pv(a,b) Perl_eval_pv(aTHX_ a,b) +# define perl_eval_sv(a,b) Perl_eval_sv(aTHX_ a,b) +# define perl_get_av(a,b) Perl_get_av(aTHX_ a,b) +# define perl_get_cv(a,b) Perl_get_cv(aTHX_ a,b) +# define perl_get_hv(a,b) Perl_get_hv(aTHX_ a,b) +# define perl_get_sv(a,b) Perl_get_sv(aTHX_ a,b) +# define perl_init_i18nl10n(a) Perl_init_i18nl10n(aTHX_ a) +# define perl_require_pv(a) Perl_require_pv(aTHX_ a) + +/* Before C99, macros could not wrap varargs functions. This + provides a set of compatibility functions that don't take an + extra argument but grab the context pointer using the macro dTHX. + */ + +# if defined(MULTIPLICITY) && !defined(PERL_WANT_VARARGS) +# define deb Perl_deb_nocontext +# define form Perl_form_nocontext +# define load_module Perl_load_module_nocontext +# define mess Perl_mess_nocontext +# define newSVpvf Perl_newSVpvf_nocontext +# define sv_catpvf Perl_sv_catpvf_nocontext +# define sv_catpvf_mg Perl_sv_catpvf_mg_nocontext +# define sv_setpvf Perl_sv_setpvf_nocontext +# define sv_setpvf_mg Perl_sv_setpvf_mg_nocontext +# define warn Perl_warn_nocontext +# define warner Perl_warner_nocontext +# endif /* defined(MULTIPLICITY) && !defined(PERL_WANT_VARARGS) */ +# endif /* !defined(PERL_NOCOMPAT) */ +# endif /* !defined(PERL_CORE) */ # if defined(PERL_CORE) || defined(PERL_EXT) # define append_utf8_from_native_byte Perl_append_utf8_from_native_byte # define av_reify(a) Perl_av_reify(aTHX_ a) @@ -2245,12 +4134,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) @@ -2276,206 +4160,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) @@ -2486,6 +4173,6 @@ # else # define get_context Perl_get_context # endif -#endif /* !defined(PERL_NO_SHORT_NAMES) */ +#endif /* !defined(PERL_DO_UNDEF_SHORT_NAMES) */ /* ex: set ro ft=c: */ diff --git a/hv.h b/hv.h index f83dcc1b5ccf..ca055c9342e1 100644 --- a/hv.h +++ b/hv.h @@ -584,6 +584,7 @@ whether it is valid to call C. =for apidoc_defn Am|SV**|hv_fetchs|HV* hv|"key"|I32 lval =for apidoc_defn Am|SV *|hv_deletes|HV *hv|"key"|U32 flags =for apidoc_defn Am|void|hv_name_sets|HV *hv|"name"|U32 flags +=for apidoc_defn Am|SV**|hv_stores|HV *hv|"name"|U32 flags =cut */ #define hv_fetchs(hv, key, lval) \ diff --git a/lib/ExtUtils/t/Embed.t b/lib/ExtUtils/t/Embed.t index 1057f8179096..c62436f6552a 100644 --- a/lib/ExtUtils/t/Embed.t +++ b/lib/ExtUtils/t/Embed.t @@ -170,6 +170,7 @@ __END__ /* perl_test.c */ +#define PERL_NO_SHORT_NAMES #include #include @@ -202,6 +203,21 @@ int main(int argc, char **argv, char **env) { my_puts("ok 4"); +#ifdef newAV +# error newAV shouldnt be defined +#endif +#ifdef newSV +# error newSV shouldnt be defined +#endif +#ifdef av_count +# error av_count shouldnt be defined +#endif + + AV* av = Perl_newAV(aTHX); + SV * sptr = Perl_newSV(aTHX_ 10); + + Perl_save_aelem(aTHX_ av, 0, &sptr); + fflush(stdout); perl_run(my_perl); diff --git a/long_names.c b/long_names.c new file mode 100644 index 000000000000..b4c9b07e193a --- /dev/null +++ b/long_names.c @@ -0,0 +1,982 @@ +/* -*- 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 is automatically generated by embed.pl. It contains + functions with names that begin with "Perl_" that otherwise + wouldn't be defined. Its existence allows PERL_NO_SHORT_NAMES to + work */ + +#include "EXTERN.h" +#define PERL_IN_LONG_NAMES_C +#include "perl.h" + +#if !defined(USE_ITHREADS) +void +Perl_CopFILEGV_set(pTHX_ COP *c, GV *gv) +{ + PERL_ARGS_ASSERT_COPFILEGV_SET; + + CopFILEGV_set(c, gv); +} +#endif + +void +Perl_SvREFCNT_dec_set_NULL(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_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_C9STRICT_UTF8_TO_UV; + + return c9strict_utf8_to_uv(s, e, cp_p, advance_p); +} + +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_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_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_FOLDEQ_UTF8; + + return foldEQ_utf8(s1, pe1, l1, u1, s2, pe2, l2, u2); +} + +GV * +Perl_gv_AVadd(pTHX_ GV *gv) +{ + PERL_ARGS_ASSERT_GV_AVADD; + + return gv_AVadd(gv); +} + +GV * +Perl_gv_HVadd(pTHX_ GV *gv) +{ + PERL_ARGS_ASSERT_GV_HVADD; + + return gv_HVadd(gv); +} + +GV * +Perl_gv_IOadd(pTHX_ GV *gv) +{ + PERL_ARGS_ASSERT_GV_IOADD; + + return gv_IOadd(gv); +} + +#if defined(PERL_DONT_CREATE_GVSV) +GV * +Perl_gv_SVadd(pTHX_ GV *gv) +{ + PERL_ARGS_ASSERT_GV_SVADD; + + return gv_SVadd(gv); +} +#endif + +void +Perl_gv_efullname3(pTHX_ SV *sv, const GV *gv, const char *prefix) +{ + PERL_ARGS_ASSERT_GV_EFULLNAME3; + + gv_efullname3(sv, gv, prefix); +} + +GV * +Perl_gv_fetchmeth(pTHX_ HV *stash, const char *name, STRLEN len, I32 level) +{ + PERL_ARGS_ASSERT_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_GV_FETCHMETH_AUTOLOAD; + + return gv_fetchmeth_autoload(stash, name, len, level); +} + +GV * +Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name) +{ + PERL_ARGS_ASSERT_GV_FETCHMETHOD; + + return gv_fetchmethod(stash, name); +} + +void +Perl_gv_fullname3(pTHX_ SV *sv, const GV *gv, const char *prefix) +{ + PERL_ARGS_ASSERT_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_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_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_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_HV_EXISTS; + + return hv_exists(hv, key, klen); +} + +bool +Perl_hv_exists_ent(pTHX_ HV *hv, SV *keysv, U32 hash) +{ + PERL_ARGS_ASSERT_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_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_HV_FETCH_ENT; + + return hv_fetch_ent(hv, keysv, lval, hash); +} + +HE * +Perl_hv_iternext(pTHX_ HV *hv) +{ + PERL_ARGS_ASSERT_HV_ITERNEXT; + + return hv_iternext(hv); +} + +void +Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how) +{ + PERL_ARGS_ASSERT_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_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_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_HV_STORE_FLAGS; + + return hv_store_flags(hv, key, klen, val, hash, flags); +} + +void +Perl_hv_undef(pTHX_ HV *hv) +{ + PERL_ARGS_ASSERT_HV_UNDEF; + + hv_undef(hv); +} + +I32 +Perl_ibcmp(pTHX_ const char *a, const char *b, I32 len) +{ + PERL_ARGS_ASSERT_IBCMP; + + return ibcmp(a, b, len); +} + +I32 +Perl_ibcmp_locale(pTHX_ const char *a, const char *b, I32 len) +{ + PERL_ARGS_ASSERT_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_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_INSTR; + + return instr(big, little); +} + +bool +Perl_is_c9strict_utf8_string(const U8 *s, STRLEN len) +{ + PERL_ARGS_ASSERT_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_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_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_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_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_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_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_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_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_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_IS_UTF8_VALID_PARTIAL_CHAR; + + return is_utf8_valid_partial_char(s0, e); +} + +CV * +Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block) +{ + PERL_ARGS_ASSERT_NEWATTRSUB; + + return newATTRSUB(floor, o, proto, attrs, block); +} + +AV * +Perl_newAV(pTHX) +{ + PERL_ARGS_ASSERT_NEWAV; + + return newAV(); +} + +AV * +Perl_newAV_alloc_x(pTHX_ SSize_t size) +{ + PERL_ARGS_ASSERT_NEWAV_ALLOC_X; + + return newAV_alloc_x(size); +} + +AV * +Perl_newAV_alloc_xz(pTHX_ SSize_t size) +{ + PERL_ARGS_ASSERT_NEWAV_ALLOC_XZ; + + return newAV_alloc_xz(size); +} + +AV * +Perl_newAV_mortal(pTHX) +{ + PERL_ARGS_ASSERT_NEWAV_MORTAL; + + return newAV_mortal(); +} + +GV * +Perl_newGVgen(pTHX_ const char *pack) +{ + PERL_ARGS_ASSERT_NEWGVGEN; + + return newGVgen(pack); +} + +HV * +Perl_newHV(pTHX) +{ + PERL_ARGS_ASSERT_NEWHV; + + return newHV(); +} + +IO * +Perl_newIO(pTHX) +{ + PERL_ARGS_ASSERT_NEWIO; + + return newIO(); +} + +CV * +Perl_newSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *block) +{ + PERL_ARGS_ASSERT_NEWSUB; + + return newSUB(floor, o, proto, block); +} + +SV * +Perl_newSVsv(pTHX_ SV * const old) +{ + PERL_ARGS_ASSERT_NEWSVSV; + + return newSVsv(old); +} + +SV * +Perl_newSVsv_nomg(pTHX_ SV * const old) +{ + PERL_ARGS_ASSERT_NEWSVSV_NOMG; + + return newSVsv_nomg(old); +} + +OP * +Perl_op_lvalue(pTHX_ OP *o, I32 type) +{ + PERL_ARGS_ASSERT_OP_LVALUE; + + return op_lvalue(o, type); +} + +const char * +Perl_phase_name(pTHX_ enum perl_phase phase) +{ + PERL_ARGS_ASSERT_PHASE_NAME; + + return phase_name(phase); +} + +void +Perl_resume_compcv_and_save(pTHX_ struct suspended_compcv *buffer) +{ + PERL_ARGS_ASSERT_RESUME_COMPCV_AND_SAVE; + + resume_compcv_and_save(buffer); +} + +void +Perl_resume_compcv_final(pTHX_ struct suspended_compcv *buffer) +{ + PERL_ARGS_ASSERT_RESUME_COMPCV_FINAL; + + resume_compcv_final(buffer); +} + +void +Perl_save_aelem(pTHX_ AV *av, SSize_t idx, SV **sptr) +{ + PERL_ARGS_ASSERT_SAVE_AELEM; + + save_aelem(av, idx, sptr); +} + +void +Perl_save_freeop(pTHX_ OP *o) +{ + PERL_ARGS_ASSERT_SAVE_FREEOP; + + save_freeop(o); +} + +void +Perl_save_freepv(pTHX_ char *pv) +{ + PERL_ARGS_ASSERT_SAVE_FREEPV; + + save_freepv(pv); +} + +void +Perl_save_freesv(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_SAVE_FREESV; + + save_freesv(sv); +} + +void +Perl_save_helem(pTHX_ HV *hv, SV *key, SV **sptr) +{ + PERL_ARGS_ASSERT_SAVE_HELEM; + + save_helem(hv, key, sptr); +} + +void +Perl_save_mortalizesv(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_SAVE_MORTALIZESV; + + save_mortalizesv(sv); +} + +void +Perl_save_op(pTHX) +{ + PERL_ARGS_ASSERT_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_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_SV_2BOOL; + + return sv_2bool(sv); +} + +IV +Perl_sv_2iv(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_SV_2IV; + + return sv_2iv(sv); +} + +char * +Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp) +{ + PERL_ARGS_ASSERT_SV_2PV; + + return sv_2pv(sv, lp); +} + +char * +Perl_sv_2pv_nolen(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_SV_2PV_NOLEN; + + return sv_2pv_nolen(sv); +} + +char * +Perl_sv_2pvbyte(pTHX_ SV *sv, STRLEN * const lp) +{ + PERL_ARGS_ASSERT_SV_2PVBYTE; + + return sv_2pvbyte(sv, lp); +} + +char * +Perl_sv_2pvbyte_nolen(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_SV_2PVBYTE_NOLEN; + + return sv_2pvbyte_nolen(sv); +} + +char * +Perl_sv_2pvutf8(pTHX_ SV *sv, STRLEN * const lp) +{ + PERL_ARGS_ASSERT_SV_2PVUTF8; + + return sv_2pvutf8(sv, lp); +} + +char * +Perl_sv_2pvutf8_nolen(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_SV_2PVUTF8_NOLEN; + + return sv_2pvutf8_nolen(sv); +} + +UV +Perl_sv_2uv(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_SV_2UV; + + return sv_2uv(sv); +} + +void +Perl_sv_catpvn(pTHX_ SV * const dsv, const char *sstr, STRLEN len) +{ + PERL_ARGS_ASSERT_SV_CATPVN; + + sv_catpvn(dsv, sstr, len); +} + +void +Perl_sv_catpvn_mg(pTHX_ SV * const dsv, const char *sstr, STRLEN len) +{ + PERL_ARGS_ASSERT_SV_CATPVN_MG; + + sv_catpvn_mg(dsv, sstr, len); +} + +void +Perl_sv_catsv(pTHX_ SV * const dsv, SV * const sstr) +{ + PERL_ARGS_ASSERT_SV_CATSV; + + sv_catsv(dsv, sstr); +} + +void +Perl_sv_catsv_mg(pTHX_ SV * const dsv, SV * const sstr) +{ + PERL_ARGS_ASSERT_SV_CATSV_MG; + + sv_catsv_mg(dsv, sstr); +} + +#if defined(USE_LOCALE_COLLATE) +char * +Perl_sv_collxfrm(pTHX_ SV * const sv, STRLEN * const nxp) +{ + PERL_ARGS_ASSERT_SV_COLLXFRM; + + return sv_collxfrm(sv, nxp); +} +#endif + +void +Perl_sv_copypv(pTHX_ SV * const dsv, SV * const ssv) +{ + PERL_ARGS_ASSERT_SV_COPYPV; + + sv_copypv(dsv, ssv); +} + +void +Perl_sv_copypv_nomg(pTHX_ SV * const dsv, SV * const ssv) +{ + PERL_ARGS_ASSERT_SV_COPYPV_NOMG; + + sv_copypv_nomg(dsv, ssv); +} + +I32 +Perl_sv_eq(pTHX_ SV *sv1, SV *sv2) +{ + PERL_ARGS_ASSERT_SV_EQ; + + return sv_eq(sv1, sv2); +} + +void +Perl_sv_force_normal(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_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_SV_INSERT; + + sv_insert(bigstr, offset, len, little, littlelen); +} + +SV * +Perl_sv_mortalcopy(pTHX_ SV * const oldsv) +{ + PERL_ARGS_ASSERT_SV_MORTALCOPY; + + return sv_mortalcopy(oldsv); +} + +bool +Perl_sv_numeq(pTHX_ SV *sv1, SV *sv2) +{ + PERL_ARGS_ASSERT_SV_NUMEQ; + + return sv_numeq(sv1, sv2); +} + +char * +Perl_sv_pv(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_SV_PV; + + return sv_pv(sv); +} + +char * +Perl_sv_pvbyte(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_SV_PVBYTE; + + return sv_pvbyte(sv); +} + +char * +Perl_sv_pvn_force(pTHX_ SV *sv, STRLEN *lp) +{ + PERL_ARGS_ASSERT_SV_PVN_FORCE; + + return sv_pvn_force(sv, lp); +} + +char * +Perl_sv_pvutf8(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_SV_PVUTF8; + + return sv_pvutf8(sv); +} + +void +Perl_sv_setsv(pTHX_ SV *dsv, SV *ssv) +{ + PERL_ARGS_ASSERT_SV_SETSV; + + sv_setsv(dsv, ssv); +} + +bool +Perl_sv_streq(pTHX_ SV *sv1, SV *sv2) +{ + PERL_ARGS_ASSERT_SV_STREQ; + + return sv_streq(sv1, sv2); +} + +void +Perl_sv_taint(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_SV_TAINT; + + sv_taint(sv); +} + +void +Perl_sv_unref(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_SV_UNREF; + + sv_unref(sv); +} + +void +Perl_sv_usepvn(pTHX_ SV *sv, char *ptr, STRLEN len) +{ + PERL_ARGS_ASSERT_SV_USEPVN; + + sv_usepvn(sv, ptr, len); +} + +void +Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len) +{ + PERL_ARGS_ASSERT_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_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_SV_UTF8_DOWNGRADE_NOMG; + + return sv_utf8_downgrade_nomg(sv, fail_ok); +} + +STRLEN +Perl_sv_utf8_upgrade(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_SV_UTF8_UPGRADE; + + return sv_utf8_upgrade(sv); +} + +STRLEN +Perl_sv_utf8_upgrade_flags(pTHX_ SV * const sv, const I32 flags) +{ + PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_FLAGS; + + return sv_utf8_upgrade_flags(sv, flags); +} + +STRLEN +Perl_sv_utf8_upgrade_nomg(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_VALID_UTF8_TO_UVCHR; + + return valid_utf8_to_uvchr(s, retlen); +} + +I32 +Perl_whichsig(pTHX_ const char *sig) +{ + PERL_ARGS_ASSERT_WHICHSIG; + + return whichsig(sig); +} + + +/* ex: set ro ft=c: */ diff --git a/makedef.pl b/makedef.pl index 477defd1e76b..30bbebe4e3e9 100644 --- a/makedef.pl +++ b/makedef.pl @@ -396,6 +396,9 @@ sub readvar { if (!$define{USE_ITHREADS} || $define{WIN32}) { ++$skip{PL_main_thread}; } +if ($define{USE_ITHREADS}) { + ++$skip{Perl_CopFILEGV_set}; +} unless ($define{USE_POSIX_2008_LOCALE}) { @@ -658,7 +661,12 @@ sub readvar { or next; my ($flags, $retval, $func, $args) = @{$embed}{qw(flags return_type name args)}; next unless $func; - if (($flags =~ /[AXC]/ && $flags !~ $excludedre) + + # We don't export symbols that have unorthodox calling conventions + next if $flags =~ /u/; + + if ( ($flags =~ /[AXC]/ && ( $flags !~ $excludedre + || $flags =~ tr/mp// > 1)) || (!$define{'NO_MATHOMS'} && $flags =~ /b/)) { # public API, so export 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/perl.h b/perl.h index f63e298a3240..a92cb5f71c81 100644 --- a/perl.h +++ b/perl.h @@ -7972,6 +7972,12 @@ START_EXTERN_C # include "inline.h" # include "sv_inline.h" +/* #including a second time causes it to #undef any unwanted symbols to avoid + * polluting the user name space */ +# define PERL_DO_UNDEF_SHORT_NAMES +# include "embed.h" +# undef PERL_DO_UNDEF_SHORT_NAMES + END_EXTERN_C #endif diff --git a/plan9/mkfile b/plan9/mkfile index ce2dab04e4df..80430b5743fc 100644 --- a/plan9/mkfile +++ b/plan9/mkfile @@ -62,7 +62,7 @@ more_ext_xs = Socket.xs Dumper.xs more_ext_c = ${more_ext_xs:%.xs=%.c} more_ext_obj = ${more_ext_xs:%.xs=%.$O} -obj = av.$O caretx.$O deb.$O doio.$O doop.$O dquote.$O dump.$O globals.$O gv.$O hv.$O keywords.$O locale.$O malloc.$O mathoms.$O mg.$O mro_core.$O numeric.$O op.$O pad.$O perlapi.$O perlio.$O perly.$O pp.$O pp_ctl.$O pp_hot.$O pp_pack.$O pp_sort.$O pp_sys.$O reentr.$O regcomp.$O regexec.$O run.$O scope.$O sv.$O taint.$O time64.$O toke.$O universal.$O utf8.$O util.$O +obj = av.$O caretx.$O deb.$O doio.$O doop.$O dquote.$O dump.$O globals.$O gv.$O hv.$O keywords.$O locale.$O long_names.$O malloc.$O mathoms.$O mg.$O mro_core.$O numeric.$O op.$O pad.$O perlapi.$O perlio.$O perly.$O pp.$O pp_ctl.$O pp_hot.$O pp_pack.$O pp_sort.$O pp_sys.$O reentr.$O regcomp.$O regexec.$O run.$O scope.$O sv.$O taint.$O time64.$O toke.$O universal.$O utf8.$O util.$O OBJS = perl.$O plan9.$O $obj diff --git a/proto.h b/proto.h index 4f994928472b..8b947d9931d7 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,8 +82,9 @@ 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 void +Perl_SvREFCNT_dec_set_NULL(pTHX_ SV *sv); +#define PERL_ARGS_ASSERT_SVREFCNT_DEC_SET_NULL PERL_CALLCONV_NO_RET void Perl_abort_execution(pTHX_ SV *msg_sv, const char * const name) @@ -342,8 +340,10 @@ 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 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); assert(s <= e) PERL_CALLCONV SSize_t Perl_call_argv(pTHX_ const char *sub_name, I32 flags, char **argv); @@ -791,9 +791,6 @@ Perl_die_unwind(pTHX_ SV *msv) #define PERL_ARGS_ASSERT_DIE_UNWIND \ assert(msv) -/* PERL_CALLCONV bool -Perl_do_aexec(pTHX_ SV *really, SV **mark, SV **sp); */ - PERL_CALLCONV bool Perl_do_aexec5(pTHX_ SV *really, SV **mark, SV **sp, int fd, int do_report) __attribute__visibility__("hidden"); @@ -853,8 +850,10 @@ 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_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) PERL_CALLCONV bool Perl_do_open6(pTHX_ GV *gv, const char *oname, STRLEN len, PerlIO *supplied_fp, SV **svp, U32 num) @@ -1049,8 +1048,10 @@ 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 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); assert(s <= e) PERL_CALLCONV void Perl_fatal_warner(pTHX_ U32 err, const char *pat, ...) @@ -1110,8 +1111,10 @@ 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(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 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); @@ -1298,14 +1301,17 @@ 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_AVadd(pTHX_ GV *gv); +#define PERL_ARGS_ASSERT_GV_AVADD -/* PERL_CALLCONV GV * -Perl_gv_HVadd(pTHX_ GV *gv); */ +PERL_CALLCONV GV * +Perl_gv_HVadd(pTHX_ GV *gv); +#define PERL_ARGS_ASSERT_GV_HVADD -/* PERL_CALLCONV GV * -Perl_gv_IOadd(pTHX_ GV *gv); */ +PERL_CALLCONV GV * +Perl_gv_IOadd(pTHX_ GV *gv); +#define PERL_ARGS_ASSERT_GV_IOADD PERL_CALLCONV GV * Perl_gv_add_by_type(pTHX_ GV *gv, svtype type); @@ -1344,8 +1350,10 @@ 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_efullname3(pTHX_ SV *sv, const GV *gv, const char *prefix); +#define PERL_ARGS_ASSERT_GV_EFULLNAME3 \ + assert(sv); assert(gv) PERL_CALLCONV void Perl_gv_efullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain); @@ -1362,11 +1370,15 @@ 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(pTHX_ HV *stash, const char *name, STRLEN len, I32 level); +#define PERL_ARGS_ASSERT_GV_FETCHMETH \ + assert(name) -/* PERL_CALLCONV GV * -Perl_gv_fetchmeth_autoload(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); +#define PERL_ARGS_ASSERT_GV_FETCHMETH_AUTOLOAD \ + assert(name) PERL_CALLCONV GV * Perl_gv_fetchmeth_pv(pTHX_ HV *stash, const char *name, I32 level, U32 flags); @@ -1398,8 +1410,10 @@ 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(pTHX_ HV *stash, const char *name); +#define PERL_ARGS_ASSERT_GV_FETCHMETHOD \ + assert(stash); assert(name) PERL_CALLCONV GV * Perl_gv_fetchmethod_autoload(pTHX_ HV *stash, const char *name, I32 autoload); @@ -1436,8 +1450,10 @@ 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_fullname3(pTHX_ SV *sv, const GV *gv, const char *prefix); +#define PERL_ARGS_ASSERT_GV_FULLNAME3 \ + assert(sv); assert(gv) PERL_CALLCONV void Perl_gv_fullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain); @@ -1450,8 +1466,10 @@ 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(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_gv_init_pv(pTHX_ GV *gv, HV *stash, const char *name, U32 flags); @@ -1547,11 +1565,15 @@ 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(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); */ +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 void Perl_hv_dump(pTHX_ HV *hv); @@ -1581,19 +1603,27 @@ 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_CALLCONV bool Perl_hv_exists(pTHX_ HV *hv, const char *key, I32 klen) - __attribute__warn_unused_result__; */ + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_HV_EXISTS \ + assert(!hv || SvTYPE(hv) == SVt_PVHV); assert(key) -/* PERL_CALLCONV bool +PERL_CALLCONV bool Perl_hv_exists_ent(pTHX_ HV *hv, SV *keysv, U32 hash) - __attribute__warn_unused_result__; */ + __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); */ +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); */ +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 STRLEN Perl_hv_fill(pTHX_ HV * const hv); @@ -1622,9 +1652,11 @@ Perl_hv_iterkeysv(pTHX_ HE *entry) #define PERL_ARGS_ASSERT_HV_ITERKEYSV \ assert(entry) -/* PERL_CALLCONV HE * +PERL_CALLCONV HE * Perl_hv_iternext(pTHX_ HV *hv) - __attribute__warn_unused_result__; */ + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_HV_ITERNEXT \ + assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV HE * Perl_hv_iternext_flags(pTHX_ HV *hv, I32 flags) @@ -1649,8 +1681,10 @@ 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_magic(pTHX_ HV *hv, GV *gv, int how); +#define PERL_ARGS_ASSERT_HV_MAGIC \ + assert(hv); assert(SvTYPE(hv) == SVt_PVHV) PERL_CALLCONV void Perl_hv_name_set(pTHX_ HV *hv, const char *name, U32 len, U32 flags); @@ -1702,38 +1736,49 @@ 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(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 SV ** -Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash, int flags); */ +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_stores(pTHX_ HV *hv, const char * const key, SV *val); */ +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 void -Perl_hv_undef(pTHX_ HV *hv); */ +PERL_CALLCONV void +Perl_hv_undef(pTHX_ HV *hv); +#define PERL_ARGS_ASSERT_HV_UNDEF \ + assert(!hv || SvTYPE(hv) == SVt_PVHV) 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_CALLCONV I32 Perl_ibcmp(pTHX_ const char *a, const char *b, I32 len) __attribute__warn_unused_result__ - __attribute__pure__; */ + __attribute__pure__; +#define PERL_ARGS_ASSERT_IBCMP \ + assert(a); assert(b) -/* PERL_CALLCONV I32 +PERL_CALLCONV I32 Perl_ibcmp_locale(pTHX_ const char *a, const char *b, I32 len) __attribute__warn_unused_result__ - __attribute__pure__; */ + __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); */ +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 STRLEN Perl_infix_plugin_standard(pTHX_ char *operator_ptr, STRLEN operator_len, struct Perl_custom_infix **def); @@ -1785,10 +1830,12 @@ Perl_init_uniprops(pTHX) __attribute__visibility__("hidden"); #define PERL_ARGS_ASSERT_INIT_UNIPROPS -/* PERL_CALLCONV char * +PERL_CALLCONV char * Perl_instr(const char *big, const char *little) __attribute__warn_unused_result__ - __attribute__pure__; */ + __attribute__pure__; +#define PERL_ARGS_ASSERT_INSTR \ + assert(big); assert(little) PERL_CALLCONV U32 Perl_intro_my(pTHX); @@ -1815,12 +1862,16 @@ 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_CALLCONV bool Perl_is_c9strict_utf8_string(const U8 *s, STRLEN len) - __attribute__warn_unused_result__; */ + __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); */ +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_in_locale_category_(pTHX_ const bool compiling, const int category); @@ -1831,12 +1882,16 @@ Perl_is_lvalue_sub(pTHX) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_LVALUE_SUB -/* PERL_CALLCONV bool +PERL_CALLCONV bool Perl_is_strict_utf8_string(const U8 *s, STRLEN len) - __attribute__warn_unused_result__; */ + __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); */ +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 bool Perl_is_uni_FOO_(pTHX_ const U8 classnum, const UV c) @@ -1866,8 +1921,10 @@ 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); assert(p < e) -/* PERL_CALLCONV STRLEN -Perl_is_utf8_char_buf(const U8 *buf, const U8 *buf_end); */ +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); assert(buf <= buf_end) PERL_CALLCONV STRLEN Perl_is_utf8_char_helper_(const U8 * const s, const U8 *e, const U32 flags) @@ -1876,11 +1933,15 @@ 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); assert(s < 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_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); */ +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 Size_t Perl_is_utf8_perl_idcont_(pTHX_ const U8 *p, const U8 * const e) @@ -1894,20 +1955,28 @@ 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); assert(p < e) -/* PERL_CALLCONV bool +PERL_CALLCONV bool Perl_is_utf8_string(const U8 *s, STRLEN len) - __attribute__warn_unused_result__; */ + __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); */ +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); */ +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_CALLCONV bool Perl_is_utf8_valid_partial_char(const U8 * const s0, const U8 * const e) __attribute__warn_unused_result__ - __attribute__pure__; */ + __attribute__pure__; +#define PERL_ARGS_ASSERT_IS_UTF8_VALID_PARTIAL_CHAR \ + assert(s0); assert(e); assert(s0 < e) PERL_CALLCONV bool Perl_isinfnan(NV nv) @@ -2648,9 +2717,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 @@ -2688,9 +2754,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 @@ -2752,16 +2815,18 @@ 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(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block); +#define PERL_ARGS_ASSERT_NEWATTRSUB 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_CALLCONV AV * Perl_newAV(pTHX) - __attribute__warn_unused_result__; */ + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWAV PERL_CALLCONV OP * Perl_newAVREF(pTHX_ OP *o) @@ -2769,17 +2834,20 @@ Perl_newAVREF(pTHX_ OP *o) #define PERL_ARGS_ASSERT_NEWAVREF \ assert(o) -/* PERL_CALLCONV AV * +PERL_CALLCONV AV * Perl_newAV_alloc_x(pTHX_ SSize_t size) - __attribute__warn_unused_result__; */ + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWAV_ALLOC_X -/* PERL_CALLCONV AV * +PERL_CALLCONV AV * Perl_newAV_alloc_xz(pTHX_ SSize_t size) - __attribute__warn_unused_result__; */ + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWAV_ALLOC_XZ -/* PERL_CALLCONV AV * +PERL_CALLCONV AV * Perl_newAV_mortal(pTHX) - __attribute__warn_unused_result__; */ + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWAV_MORTAL PERL_CALLCONV AV * Perl_newAVav(pTHX_ AV *oav) @@ -2862,8 +2930,10 @@ 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(pTHX_ const char *pack); +#define PERL_ARGS_ASSERT_NEWGVGEN \ + assert(pack) PERL_CALLCONV GV * Perl_newGVgen_flags(pTHX_ const char *pack, U32 flags) @@ -2871,9 +2941,10 @@ Perl_newGVgen_flags(pTHX_ const char *pack, U32 flags) #define PERL_ARGS_ASSERT_NEWGVGEN_FLAGS \ assert(pack) -/* PERL_CALLCONV HV * +PERL_CALLCONV HV * Perl_newHV(pTHX) - __attribute__warn_unused_result__; */ + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWHV PERL_CALLCONV OP * Perl_newHVREF(pTHX_ OP *o) @@ -2887,9 +2958,10 @@ Perl_newHVhv(pTHX_ HV *ohv) #define PERL_ARGS_ASSERT_NEWHVHV \ assert(!ohv || SvTYPE(ohv) == SVt_PVHV) -/* PERL_CALLCONV IO * +PERL_CALLCONV IO * Perl_newIO(pTHX) - __attribute__warn_unused_result__; */ + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWIO PERL_CALLCONV OP * Perl_newLISTOP(pTHX_ I32 type, I32 flags, OP *first, OP *last) @@ -3006,8 +3078,9 @@ 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 CV * +Perl_newSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *block); +#define PERL_ARGS_ASSERT_NEWSUB PERL_CALLCONV SV * Perl_newSV(pTHX_ const STRLEN len) @@ -3110,9 +3183,10 @@ Perl_newSVrv(pTHX_ SV * const rv, const char * const classname); #define PERL_ARGS_ASSERT_NEWSVRV \ assert(rv) -/* PERL_CALLCONV SV * +PERL_CALLCONV SV * Perl_newSVsv(pTHX_ SV * const old) - __attribute__warn_unused_result__; */ + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWSVSV PERL_CALLCONV SV * Perl_newSVsv_flags_NN(pTHX_ SV * const old, I32 flags) @@ -3120,9 +3194,10 @@ Perl_newSVsv_flags_NN(pTHX_ SV * const old, I32 flags) #define PERL_ARGS_ASSERT_NEWSVSV_FLAGS_NN \ assert(old) -/* PERL_CALLCONV SV * +PERL_CALLCONV SV * Perl_newSVsv_nomg(pTHX_ SV * const old) - __attribute__warn_unused_result__; */ + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEWSVSV_NOMG PERL_CALLCONV SV * Perl_newSVuv(pTHX_ const UV u) @@ -3292,8 +3367,9 @@ 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(pTHX_ OP *o, I32 type); +#define PERL_ARGS_ASSERT_OP_LVALUE PERL_CALLCONV OP * Perl_op_lvalue_flags(pTHX_ OP *o, I32 type, U32 flags); @@ -3574,8 +3650,9 @@ 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 const char * +Perl_phase_name(pTHX_ enum perl_phase phase); +#define PERL_ARGS_ASSERT_PHASE_NAME PERL_CALLCONV void Perl_pmop_dump(pTHX_ PMOP *pm); @@ -3880,11 +3957,15 @@ 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_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); */ +PERL_CALLCONV void +Perl_resume_compcv_final(pTHX_ struct suspended_compcv *buffer); +#define PERL_ARGS_ASSERT_RESUME_COMPCV_FINAL \ + assert(buffer) PERL_CALLCONV char * Perl_rninstr(const char *big, const char *bigend, const char *little, const char *lend) @@ -3987,8 +4068,10 @@ 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(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_aelem_flags(pTHX_ AV *av, SSize_t idx, SV **sptr, const U32 flags); @@ -4033,19 +4116,22 @@ 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_freeop(pTHX_ OP *o); +#define PERL_ARGS_ASSERT_SAVE_FREEOP -/* PERL_CALLCONV void -Perl_save_freepv(pTHX_ char *pv); */ +PERL_CALLCONV void +Perl_save_freepv(pTHX_ char *pv); +#define PERL_ARGS_ASSERT_SAVE_FREEPV 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_freesv(pTHX_ SV *sv); +#define PERL_ARGS_ASSERT_SAVE_FREESV PERL_CALLCONV void Perl_save_generic_pvref(pTHX_ char **str); @@ -4072,8 +4158,10 @@ 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(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_helem_flags(pTHX_ HV *hv, SV *key, SV **sptr, const U32 flags); @@ -4104,11 +4192,14 @@ 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_mortalizesv(pTHX_ SV *sv); +#define PERL_ARGS_ASSERT_SAVE_MORTALIZESV \ + assert(sv) -/* PERL_CALLCONV void -Perl_save_op(pTHX); */ +PERL_CALLCONV void +Perl_save_op(pTHX); +#define PERL_ARGS_ASSERT_SAVE_OP PERL_CALLCONV void Perl_save_padsv_and_mortalize(pTHX_ PADOFFSET off); @@ -4354,8 +4445,10 @@ 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 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); assert(s <= e) PERL_CALLCONV void Perl_sub_crush_depth(pTHX_ CV *cv) @@ -4394,8 +4487,10 @@ 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(pTHX_ SV * const sv); +#define PERL_ARGS_ASSERT_SV_2BOOL \ + assert(sv) PERL_CALLCONV bool Perl_sv_2bool_flags(pTHX_ SV *sv, I32 flags); @@ -4412,8 +4507,10 @@ 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(pTHX_ SV *sv); +#define PERL_ARGS_ASSERT_SV_2IV \ + assert(sv) PERL_CALLCONV IV Perl_sv_2iv_flags(pTHX_ SV * const sv, const I32 flags); @@ -4435,44 +4532,58 @@ 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(pTHX_ SV *sv, STRLEN *lp); +#define PERL_ARGS_ASSERT_SV_2PV \ + assert(sv) 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_CALLCONV char * Perl_sv_2pv_nolen(pTHX_ SV *sv) - __attribute__warn_unused_result__; */ + __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); */ +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_flags(pTHX_ SV *sv, STRLEN * const lp, const U32 flags); #define PERL_ARGS_ASSERT_SV_2PVBYTE_FLAGS \ assert(sv) -/* PERL_CALLCONV char * +PERL_CALLCONV char * Perl_sv_2pvbyte_nolen(pTHX_ SV *sv) - __attribute__warn_unused_result__; */ + __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); */ +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_flags(pTHX_ SV *sv, STRLEN * const lp, const U32 flags); #define PERL_ARGS_ASSERT_SV_2PVUTF8_FLAGS \ assert(sv) -/* PERL_CALLCONV char * +PERL_CALLCONV char * Perl_sv_2pvutf8_nolen(pTHX_ SV *sv) - __attribute__warn_unused_result__; */ + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_SV_2PVUTF8_NOLEN \ + assert(sv) -/* PERL_CALLCONV UV -Perl_sv_2uv(pTHX_ SV *sv); */ +PERL_CALLCONV UV +Perl_sv_2uv(pTHX_ SV *sv); +#define PERL_ARGS_ASSERT_SV_2UV \ + assert(sv) PERL_CALLCONV UV Perl_sv_2uv_flags(pTHX_ SV * const sv, const I32 flags); @@ -4526,27 +4637,35 @@ 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(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_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_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); */ +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_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_catsv_mg(pTHX_ SV * const dsv, SV * const sstr); +#define PERL_ARGS_ASSERT_SV_CATSV_MG \ + assert(dsv) PERL_CALLCONV void Perl_sv_chop(pTHX_ SV * const sv, const char * const ptr); @@ -4584,16 +4703,20 @@ 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(pTHX_ SV * const dsv, SV * const ssv); +#define PERL_ARGS_ASSERT_SV_COPYPV \ + assert(dsv); assert(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_copypv_nomg(pTHX_ SV * const dsv, SV * const ssv); +#define PERL_ARGS_ASSERT_SV_COPYPV_NOMG \ + assert(dsv); assert(ssv) PERL_CALLCONV void Perl_sv_dec(pTHX_ SV * const sv); @@ -4674,15 +4797,18 @@ 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(pTHX_ SV *sv1, SV *sv2); +#define PERL_ARGS_ASSERT_SV_EQ 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(pTHX_ SV *sv); +#define PERL_ARGS_ASSERT_SV_FORCE_NORMAL \ + assert(sv) PERL_CALLCONV void Perl_sv_force_normal_flags(pTHX_ SV * const sv, const U32 flags); @@ -4731,8 +4857,10 @@ 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(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 void Perl_sv_insert_flags(pTHX_ SV * const bigstr, const STRLEN offset, const STRLEN len, const char *little, const STRLEN littlelen, const U32 flags); @@ -4784,9 +4912,10 @@ 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_CALLCONV SV * Perl_sv_mortalcopy(pTHX_ SV * const oldsv) - __attribute__warn_unused_result__; */ + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_SV_MORTALCOPY PERL_CALLCONV SV * Perl_sv_mortalcopy_flags(pTHX_ SV * const oldsv, U32 flags) @@ -4806,8 +4935,9 @@ 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(pTHX_ SV *sv1, SV *sv2); +#define PERL_ARGS_ASSERT_SV_NUMEQ PERL_CALLCONV bool Perl_sv_numeq_flags(pTHX_ SV *sv1, SV *sv2, const U32 flags); @@ -4837,30 +4967,38 @@ 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_CALLCONV char * Perl_sv_pv(pTHX_ SV *sv) - __attribute__warn_unused_result__; */ + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_SV_PV \ + assert(sv) -/* PERL_CALLCONV char * +PERL_CALLCONV char * Perl_sv_pvbyte(pTHX_ SV *sv) - __attribute__warn_unused_result__; */ + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_SV_PVBYTE \ + assert(sv) 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(pTHX_ SV *sv, STRLEN *lp); +#define PERL_ARGS_ASSERT_SV_PVN_FORCE \ + assert(sv) 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_CALLCONV char * Perl_sv_pvutf8(pTHX_ SV *sv) - __attribute__warn_unused_result__; */ + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_SV_PVUTF8 \ + assert(sv) PERL_CALLCONV char * Perl_sv_pvutf8n_force(pTHX_ SV * const sv, STRLEN * const lp); @@ -5060,8 +5198,10 @@ 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(pTHX_ SV *dsv, SV *ssv); +#define PERL_ARGS_ASSERT_SV_SETSV \ + assert(dsv) PERL_CALLCONV void Perl_sv_setsv_flags(pTHX_ SV *dsv, SV *ssv, const I32 flags); @@ -5083,8 +5223,9 @@ 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(pTHX_ SV *sv1, SV *sv2); +#define PERL_ARGS_ASSERT_SV_STREQ PERL_CALLCONV bool Perl_sv_streq_flags(pTHX_ SV *sv1, SV *sv2, const U32 flags); @@ -5104,8 +5245,10 @@ 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 void +Perl_sv_taint(pTHX_ SV *sv); +#define PERL_ARGS_ASSERT_SV_TAINT \ + assert(sv) PERL_CALLCONV bool Perl_sv_tainted(pTHX_ SV * const sv) @@ -5133,8 +5276,10 @@ 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(pTHX_ SV *sv); +#define PERL_ARGS_ASSERT_SV_UNREF \ + assert(sv) PERL_CALLCONV void Perl_sv_unref_flags(pTHX_ SV * const ref, const U32 flags); @@ -5151,51 +5296,65 @@ 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(pTHX_ SV *sv, char *ptr, STRLEN len); +#define PERL_ARGS_ASSERT_SV_USEPVN \ + assert(sv) 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 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_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(pTHX_ SV * const sv, const bool fail_ok); +#define PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE \ + assert(sv) 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 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 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(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); */ +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_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 STRLEN +Perl_sv_utf8_upgrade_nomg(pTHX_ SV *sv); +#define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_NOMG \ + assert(sv) PERL_CALLCONV void Perl_sv_vcatpvf(pTHX_ SV * const sv, const char * const pat, va_list * const args); @@ -5278,8 +5437,10 @@ 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(pTHX_ UV c, U8 *p, STRLEN *lenp); +#define PERL_ARGS_ASSERT_TO_UNI_FOLD \ + assert(p); assert(lenp) PERL_CALLCONV UV Perl_to_uni_fold_flags_(pTHX_ UV c, U8 *p, STRLEN *lenp, U8 flags); @@ -5362,17 +5523,24 @@ 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_CALLCONV U8 * Perl_utf8_hop_back(const U8 *s, SSize_t off, const U8 * const start) - __attribute__warn_unused_result__; */ + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_UTF8_HOP_BACK \ + assert(s); assert(start); assert(start <= s) -/* PERL_CALLCONV U8 * +PERL_CALLCONV U8 * Perl_utf8_hop_forward(const U8 *s, SSize_t off, const U8 * const end) - __attribute__warn_unused_result__; */ + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_UTF8_HOP_FORWARD \ + assert(s); assert(end) -/* PERL_CALLCONV U8 * +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__; */ + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_UTF8_HOP_SAFE \ + assert(s); assert(start); assert(end); assert(start <= s); \ + assert(s <= end) PERL_CALLCONV STRLEN Perl_utf8_length(pTHX_ const U8 *s0, const U8 *e) @@ -5393,25 +5561,35 @@ 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(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); assert(s <= e) -/* 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_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); assert(s <= e) -/* 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_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); assert(s <= e) 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); assert(s0 <= e) -/* PERL_CALLCONV UV -Perl_utf8n_to_uvchr(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags); */ +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); */ +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 void Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg) @@ -5419,20 +5597,30 @@ Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg) #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_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); */ +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); */ +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); */ +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); */ +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 U8 * Perl_uvoffuni_to_utf8_flags_msgs(pTHX_ U8 *d, UV input_uv, const UV flags, HV **msgs); @@ -5453,9 +5641,11 @@ PERL_CALLCONV bool Perl_valid_identifier_sv(pTHX_ SV *sv); #define PERL_ARGS_ASSERT_VALID_IDENTIFIER_SV -/* PERL_CALLCONV UV +PERL_CALLCONV UV Perl_valid_utf8_to_uvchr(const U8 *s, STRLEN *retlen) - __attribute__warn_unused_result__; */ + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVCHR \ + assert(s) #define PERL_ARGS_ASSERT_VALIDATE_PROTO \ assert(name) @@ -5575,8 +5765,10 @@ 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(pTHX_ const char *sig); +#define PERL_ARGS_ASSERT_WHICHSIG \ + assert(sig) PERL_CALLCONV I32 Perl_whichsig_pv(pTHX_ const char *sig); @@ -6306,8 +6498,9 @@ Perl_do_exec(pTHX_ const char *cmd) #endif #if defined(PERL_DONT_CREATE_GVSV) -/* PERL_CALLCONV GV * -Perl_gv_SVadd(pTHX_ GV *gv); */ +PERL_CALLCONV GV * +Perl_gv_SVadd(pTHX_ GV *gv); +# define PERL_ARGS_ASSERT_GV_SVADD #endif #if defined(PERL_IMPLICIT_SYS) @@ -6888,21 +7081,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) @@ -10749,9 +10933,6 @@ Perl_dump_c_backtrace(pTHX_ PerlIO *fp, int max_depth, int skip); # define PERL_ARGS_ASSERT_DUMP_C_BACKTRACE \ assert(fp) -/* PERL_CALLCONV void -free_c_backtrace(pTHX_ Perl_c_backtrace *bt); */ - PERL_CALLCONV Perl_c_backtrace * Perl_get_c_backtrace(pTHX_ int max_depth, int skip) __attribute__visibility__("hidden"); @@ -10940,8 +11121,10 @@ 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); */ +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) @@ -10960,8 +11143,10 @@ 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(pTHX_ SV * const sv, STRLEN * const nxp); +# define PERL_ARGS_ASSERT_SV_COLLXFRM \ + assert(sv); assert(nxp) PERL_CALLCONV char * Perl_sv_collxfrm_flags(pTHX_ SV * const sv, STRLEN * const nxp, I32 const flags); diff --git a/regen/embed.pl b/regen/embed.pl index 98090467fba2..38ebd822c881 100755 --- a/regen/embed.pl +++ b/regen/embed.pl @@ -60,7 +60,12 @@ BEGIN my $unflagged_pointers; my @az = ('a'..'z'); -# +my %need_longs; # For long function names + +# List of short names to keep out of user name space if PERL_NO_SHORT_NAMES is +# defined +my %undefs; + # See database of global and static function prototypes in embed.fnc # This is used to generate prototype headers under various configurations, # export symbols lists for different platforms, and macros to provide an @@ -162,7 +167,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/ ); @@ -191,12 +195,23 @@ sub generate_proto_h { 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) { @@ -367,14 +382,18 @@ sub generate_proto_h { my $temp_arg = $arg; $temp_arg =~ s/\*//g; - $temp_arg =~ s/\s*\bstruct\b\s*/ /g; + $temp_arg =~ + s/ \s* \b ( struct | enum | union ) \b \s*/ /xg; if ( ($temp_arg ne "...") && ($temp_arg !~ /\w+\s+(\w+)(?:\[\d+\])?\s*$/) ) { die_at_end "$func: $arg ($n) doesn't have a name\n"; } 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)"; } @@ -611,7 +630,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 @@ -739,6 +757,7 @@ sub add_indent { sub indent_define { my ($from, $to, $indent, $width) = @_; + $undefs{$from} = $to; # Potentially keep from user name space $indent = '' unless defined $indent; my $ret= "#${indent}define $from"; add_indent($ret,"$to\n",$width); @@ -759,12 +778,13 @@ sub embed_h { my $lines; foreach (@$funcs) { - if ($_->{type} ne "content") { - $lines .= $_->{line}; + my $object = $_; + if ($object->{type} ne "content") { + $lines .= $object->{line}; next; } - my $level= $_->{level}; - my $embed= $_->{embed} or next; + my $level= $object->{level}; + my $embed= $object->{embed} or next; my ($flags,$retval,$func,$args) = @{$embed}{qw(flags return_type name args)}; my $full_name = full_name($func, $flags); @@ -777,41 +797,13 @@ sub embed_h { if ($flags =~ tr/mp// > 1) { # Has both m and p - # Yields - # #define Perl_func func - # which works when there is no thread context. - $ret = indent_define($full_name, $func, $ind); - - if ($flags !~ /[T]/) { - - # But when there is the possibility of a thread context - # parameter, $ret works only on non-threaded builds - my $no_thread_full_define = $ret; - - # And we have to do more when there are threads. First, - # convert the input argument list to 'a', 'b' .... This keeps - # us from having to worry about all the extra stuff in the - # input list; stuff like the type declarations, things like - # NULLOK, and pointers '*'. - my $argname = 'a'; - my @stripped_args; - push @stripped_args, $argname++ for $args->@*; - my $arglist = join ",", @stripped_args; - - # In the threaded case, the Perl_ form is expecting an aTHX - # first argument. Use mTHX to match that, which isn't passed - # on to the short form name, as that is expecting an implicit - # aTHX. The non-threaded case just uses what we generated - # above for the /T/ flag case. - my $mTHX_ = "mTHX"; - $mTHX_ .= ',' if $arglist ne ""; - $ret = "#${ind}ifdef USE_THREADS\n" - . "#${ind} define $full_name($mTHX_$arglist)" - . " $func($arglist)\n" - . "#${ind}else\n" - . "$ind $no_thread_full_define" # No \n because no chomp - . "#${ind}endif\n"; - } + # In this case, the implementation already uses another macro, so + # the short name is already defined to expand to that. We need to + # instead to generate a Perl_ named function that calls that + # macro, and user name space, if the build asks for that. + $object->{guard} = $guard; + $need_longs{$full_name} = $object; + $undefs{$func} = 1; } elsif ($flags !~ /[omM]/) { my $argc = scalar @$args; @@ -837,6 +829,7 @@ sub embed_h { $use_va_list ? ("__VA_ARGS__") : ()); $ret = "#${ind}define $func($paramlist) "; add_indent($ret,full_name($func, $flags) . "(aTHX"); + $undefs{$func} = 1; # Potentially keep from user name space if ($replacelist) { $ret .= ($flags =~ /m/) ? "," : "_ "; $ret .= $replacelist; @@ -899,15 +892,12 @@ sub generate_embed_h { print $em <<~'END'; /* (Doing namespace management portably in C is really gross.) */ - /* By defining PERL_NO_SHORT_NAMES (not done by default) the short forms - * (like warn instead of Perl_warn) for the API are not defined. - * Not defining the short forms is a good thing for cleaner embedding. - * 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 + /* When this symbol is defined, we undef all the short name symbols we + * have defined before when this file was #included with the symbol + * undefined */ + #if ! defined(PERL_DO_UNDEF_SHORT_NAMES) - /* Hide global symbols */ + /* Create short name macros that hide any need for thread context */ END @@ -917,8 +907,6 @@ sub generate_embed_h { print $em <<~'END'; - #endif /* #ifndef PERL_NO_SHORT_NAMES */ - #if !defined(PERL_CORE) /* Compatibility stubs. Compile extensions with -DPERL_NOCOMPAT to * disable them. @@ -945,9 +933,7 @@ sub generate_embed_h { provides a set of compatibility functions that don't take an extra argument but grab the context pointer using the macro dTHX. */ - #if defined(MULTIPLICITY) \ - && !defined(PERL_NO_SHORT_NAMES) \ - && !defined(PERL_WANT_VARARGS) + #if defined(MULTIPLICITY) && !defined(PERL_WANT_VARARGS) END foreach (@have_compatibility_macros) { @@ -960,14 +946,27 @@ sub generate_embed_h { #endif /* !defined(PERL_CORE) && !defined(PERL_NOCOMPAT) */ #if !defined(MULTIPLICITY) - /* undefined symbols, point them back at the usual ones */ + /* undefined symbols, point them back at the usual ones */ END foreach (@have_compatibility_macros) { print $em indent_define("Perl_${_}_nocontext", "Perl_$_", " "); } + print $em <<~EOT; + #endif /* !defined(MULTIPLICITY) */ + #elif defined(PERL_NO_SHORT_NAMES) && ! defined(PERL_CORE) + EOT + + # We undefine all elements on the list of symbol names to keep from user + # name space if PERL_NO_SHORT_NAMES is in effect (which requests this), + # but override it if are compiling the core. + for my $name ( sort { lc $a cmp lc $b } keys %undefs) { + print $em "#undef $name\n"; + } + print $em "#endif\n"; + close $em; normalize_and_print('embed.h',$embed_buffer) @@ -1005,12 +1004,90 @@ 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 is automatically generated by embed.pl. It contains + functions with names that begin with "Perl_" that otherwise + wouldn't be defined. Its existence allows PERL_NO_SHORT_NAMES to + work */ + + #include "EXTERN.h" + #define PERL_IN_LONG_NAMES_C + #include "perl.h" + + EOT + + for my $full_name (sort keys %{$longs}) { + my $parser_object = $longs->{$full_name}; + my $entry = $parser_object->{embed}; + + # Store the definition of this function into @lines. It may have to + # have an #if guarding it. + my @lines; + push @lines, $parser_object->{guard} if $parser_object->{guard}; + + my $name = $entry->{name}; + my $return_type = $entry->{return_type}; + + # First in the actual definition is its return type + push @lines, $return_type; + + # Then the function name, and prototype + push @lines, "$full_name("; + $lines[-1] .= "pTHX" unless $entry->{flags} =~ /T/; + if ($entry->{args}->@*) { + $lines[-1] .= '_ ' unless $entry->{flags} =~ /T/; + $lines[-1] .= join ", ", @{$entry->{args}}; + } + $lines[-1] .= ")"; + + # Then the beginning of its definition + push @lines, <<~EOT; + { + PERL_ARGS_ASSERT_\U$name; + EOT + + # Then 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 + push @lines, " " x 4; + $lines[-1] .= "return " if $return_type ne 'void'; + $lines[-1] .= "$name("; + + # For each parameter, we need just its name. This assumes the + # parameter name is the final \w+ chars + $lines[-1] .= join ", ", map { s/ .*? (\w+) $ /$1/rx } + @{$entry->{args}} if @{$entry->{args}}; + $lines[-1] .= ");"; + + # Finally the closing brace< and any guard #endif + push @lines, "}"; + push @lines, "#endif" if $entry->{guard}; + + # Replace what the HeaderLine object thinks is the output line with + # the ones just calculated. + $parser_object->{line} = join "\n", @lines; + + # And get HeaderParser to surround that with any #if's that it found + # when parsing embed.fnc + my $hp= HeaderParser->new(); + my $group = $hp->group_content([$parser_object]); + print $fh $hp->lines_as_str($group), "\n";; + } + + 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/util.h b/util.h index 386f38935621..a339bbdf6be0 100644 --- a/util.h +++ b/util.h @@ -252,7 +252,7 @@ returning NULL if not found. The terminating NUL bytes are not compared. */ -#define instr(haystack, needle) strstr(haystack, needle) +#define instr(haystack, needle) strstr((char *) haystack, (char *) needle) #ifdef HAS_MEMMEM # define ninstr(big, bigend, little, lend) \ diff --git a/vms/descrip_mms.template b/vms/descrip_mms.template index 9df7455b4f78..9f7d42e0ec02 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 @@ -218,7 +218,7 @@ c = $(c0) $(c1) $(c2) $(c3) $(c4) obj0 = perl$(O) obj1 = $(MALLOC_O) av$(O) builtin$(O) caretx$(O) class$(O) deb$(O) doio$(O) doop$(O) dquote$(O) dump$(O) mro_core$(O) globals$(O) gv$(O) hv$(O) -obj2 = keywords$(O) locale$(O) mathoms$(O) mg$(O) miniperlmain$(O) numeric$(O) op$(O) pad$(O) peep$(O) perlio$(O) +obj2 = keywords$(O) locale$(O) long_names$(O) mathoms$(O) mg$(O) miniperlmain$(O) numeric$(O) op$(O) pad$(O) peep$(O) perlio$(O) obj3 = perly$(O) pp$(O) pp_ctl$(O) pp_hot$(O) reentr$(O) pp_pack$(O) pp_sort$(O) pp_sys$(O) regcomp$(O) obj4 = regcomp_debug$(O) regcomp_invlist$(O) regcomp_study$(O) regcomp_trie$(O) obj5 = regexec$(O) run$(O) scope$(O) sv$(O) taint$(O) time64$(O) toke$(O) universal$(O) utf8$(O) util$(O) vms$(O) @@ -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 \ diff --git a/win32/Makefile b/win32/Makefile index 316203ca434a..d7a206f82e33 100644 --- a/win32/Makefile +++ b/win32/Makefile @@ -673,8 +673,9 @@ MICROCORE_SRC = \ ..\gv.c \ ..\mro_core.c \ ..\hv.c \ - ..\locale.c \ ..\keywords.c \ + ..\locale.c \ + ..\long_names.c \ ..\mathoms.c \ ..\mg.c \ ..\numeric.c \