diff --git a/av.h b/av.h index aaf3be64fb51..5913e416f032 100644 --- a/av.h +++ b/av.h @@ -236,8 +236,7 @@ to fit one element without extending: */ -#define Perl_newAV(mTHX) MUTABLE_AV(Perl_newSV_type(aTHX_ SVt_PVAV)) - +#define newAV() MUTABLE_AV(newSV_type(SVt_PVAV)) #define newAV_mortal() MUTABLE_AV(newSV_type_mortal(SVt_PVAV)) #define newAV_alloc_x(size) av_new_alloc(size,0) #define newAV_alloc_xz(size) av_new_alloc(size,1) diff --git a/embed.fnc b/embed.fnc index 90b518a03f0a..df81d68fd46f 100644 --- a/embed.fnc +++ b/embed.fnc @@ -447,31 +447,8 @@ : created that #defines 'foo' as 'Perl_foo'. This can be used to make : any macro have a long name, perhaps to avoid name collisions. If : instead you define the macro as 'PERL_FOO' (all uppercase), the -: embed.h entry will use all uppercase. -: -: It is particularly useful tp preserve backward compatibility when a -: function is converted to be a macro (remembering to not create a macro -: which evaluates its parameters more than once). Most of mathoms.c -: could be converted to use this facility. When there is no thread -: context involved, you just do something like -: -: #define Perl_foo(a, b, c) Perl_bar(a, b, 0, c) -: -: Otherwise consider this general case where there is a series of macros -: that build on the previous ones by calling something with a different -: name or with an extra parameter beyond what the previous one did: -: -: #define Perl_foo(mTHX, a) Perl_bar1(aTHX, a) -: #define Perl_bar1(mTHX, a) Perl_bar2(aTHX, a, 0) -: #define Perl_bar2(mTHX, a, b) Perl_bar3(aTHX, a, b, 0) -: #define Perl_bar3(mTHX, a, b, c) Perl_func(aTHX_ a, b, c, 0) -: -: Use the formal parameter name 'mTHX,' (which stands for "macro thread -: context") as the first in each macro definition, and call the next -: macro in the sequence with 'aTHX,' (Note the commas). Eventually, the -: sequence will end with a function call (or else there would be no need -: for thread context). For that instead call it with 'aTHX_' (with an -: underscore instead of a comma). +: embed.h entry will use all uppercase. Without the T flag the behavior +: is subject to change when both 'm' and 'p are specified. : : suppress proto.h entry (actually, not suppressed, but commented out) : suppress entry in the list of exported symbols available on all @@ -1016,7 +993,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 \ +Mbp |bool |do_aexec |NULLOK SV *really \ |NN SV **mark \ |NN SV **sp : Used in pp_sys.c @@ -1072,7 +1049,7 @@ Rp |I32 |do_ncmp |NN SV * const left \ Cp |void |do_op_dump |I32 level \ |NN PerlIO *file \ |NULLOK const OP *o -Amp |bool |do_open |NN GV *gv \ +AMbp |bool |do_open |NN GV *gv \ |NN const char *name \ |I32 len \ |int as_raw \ @@ -1344,12 +1321,12 @@ ARdp |GV * |gv_autoload_pvn|NULLOK NOCHECK HV *stash \ ARdp |GV * |gv_autoload_sv |NULLOK NOCHECK HV *stash \ |NN SV *namesv \ |U32 flags -Admp |GV * |gv_AVadd |NULLOK GV *gv +AMbdp |GV * |gv_AVadd |NULLOK GV *gv Cp |void |gv_check |NN HV *stash : Used in pp.c and pp_sys.c ARdp |SV * |gv_const_sv |NN GV *gv Adp |void |gv_dump |NULLOK GV *gv -Admp |void |gv_efullname3 |NN SV *sv \ +AMbdp |void |gv_efullname3 |NN SV *sv \ |NN const GV *gv \ |NULLOK const char *prefix Adp |void |gv_efullname4 |NN SV *sv \ @@ -1370,7 +1347,7 @@ Adm |GV * |gv_fetchmeth_autoload \ |NN const char *name \ |STRLEN len \ |I32 level -Admp |GV * |gv_fetchmethod |NN NOCHECK HV *stash \ +AMbdp |GV * |gv_fetchmethod |NN NOCHECK HV *stash \ |NN const char *name Adp |GV * |gv_fetchmethod_autoload \ |NN NOCHECK HV *stash \ @@ -1431,7 +1408,7 @@ Adp |GV * |gv_fetchpvn_flags \ Adp |GV * |gv_fetchsv |NN SV *name \ |I32 flags \ |const svtype sv_type -Admp |void |gv_fullname3 |NN SV *sv \ +AMbdp |void |gv_fullname3 |NN SV *sv \ |NN const GV *gv \ |NULLOK const char *prefix Adp |void |gv_fullname4 |NN SV *sv \ @@ -1440,7 +1417,7 @@ Adp |void |gv_fullname4 |NN SV *sv \ |bool keepmain CRdp |CV * |gv_handler |NULLOK HV *stash \ |I32 id -Admp |GV * |gv_HVadd |NULLOK GV *gv +AMbdp |GV * |gv_HVadd |NULLOK GV *gv Adm |void |gv_init |NN GV *gv \ |NULLOK HV *stash \ |NN const char *name \ @@ -1459,7 +1436,7 @@ Adp |void |gv_init_sv |NN GV *gv \ |NULLOK HV *stash \ |NN SV *namesv \ |U32 flags -Admp |GV * |gv_IOadd |NULLOK GV *gv +AMbdp |GV * |gv_IOadd |NULLOK GV *gv Adp |void |gv_name_set |NN GV *gv \ |NN const char *name \ |U32 len \ @@ -1507,11 +1484,11 @@ ARdp |HV * |hv_copy_hints_hv \ Cp |void |hv_delayfree_ent \ |NULLOK HV *notused \ |NULLOK HE *entry -Admp |SV * |hv_delete |NULLOK HV *hv \ +AMbdp |SV * |hv_delete |NULLOK HV *hv \ |NN const char *key \ |I32 klen \ |I32 flags -Admp |SV * |hv_delete_ent |NULLOK HV *hv \ +AMbdp |SV * |hv_delete_ent |NULLOK HV *hv \ |NN SV *keysv \ |I32 flags \ |U32 hash @@ -1527,17 +1504,17 @@ dp |void |hv_ename_delete|NN HV *hv \ |NN const char *name \ |U32 len \ |U32 flags -ARdmp |bool |hv_exists |NULLOK HV *hv \ +AMRbdp |bool |hv_exists |NULLOK HV *hv \ |NN const char *key \ |I32 klen -ARdmp |bool |hv_exists_ent |NULLOK HV *hv \ +AMRbdp |bool |hv_exists_ent |NULLOK HV *hv \ |NN SV *keysv \ |U32 hash -Admp |SV ** |hv_fetch |NULLOK HV *hv \ +AMbdp |SV ** |hv_fetch |NULLOK HV *hv \ |NN const char *key \ |I32 klen \ |I32 lval -Admp |HE * |hv_fetch_ent |NULLOK HV *hv \ +AMbdp |HE * |hv_fetch_ent |NULLOK HV *hv \ |NN SV *keysv \ |I32 lval \ |U32 hash @@ -1548,7 +1525,7 @@ Adp |I32 |hv_iterinit |NN HV *hv ARdp |char * |hv_iterkey |NN HE *entry \ |NN I32 *retlen ARdp |SV * |hv_iterkeysv |NN HE *entry -Admp |HE * |hv_iternext |NN HV *hv +AMRbdp |HE * |hv_iternext |NN HV *hv ARdpx |HE * |hv_iternext_flags \ |NN HV *hv \ |I32 flags @@ -1559,7 +1536,7 @@ ARdp |SV * |hv_iterval |NN HV *hv \ |NN HE *entry Adp |void |hv_ksplit |NN HV *hv \ |IV newmax -Admp |void |hv_magic |NN HV *hv \ +AMbdp |void |hv_magic |NN HV *hv \ |NULLOK GV *gv \ |int how Adp |void |hv_name_set |NN HV *hv \ @@ -1582,25 +1559,25 @@ Cdop |void |hv_riter_set |NN HV *hv \ |I32 riter ARdp |SV * |hv_scalar |NN HV *hv -Admp |SV ** |hv_store |NULLOK HV *hv \ +AMbdp |SV ** |hv_store |NULLOK HV *hv \ |NULLOK const char *key \ |I32 klen \ |NULLOK SV *val \ |U32 hash -Admp |HE * |hv_store_ent |NULLOK HV *hv \ +AMbdp |HE * |hv_store_ent |NULLOK HV *hv \ |NULLOK SV *key \ |NULLOK SV *val \ |U32 hash -Ampx |SV ** |hv_store_flags |NULLOK HV *hv \ +AMbpx |SV ** |hv_store_flags |NULLOK HV *hv \ |NULLOK const char *key \ |I32 klen \ |NULLOK SV *val \ |U32 hash \ |int flags -Admp |SV ** |hv_stores |NULLOK HV *hv \ +Adm |SV ** |hv_stores |NULLOK HV *hv \ |"key" \ |NULLOK SV *val -Admp |void |hv_undef |NULLOK HV *hv +Adm |void |hv_undef |NULLOK HV *hv Xop |void |hv_undef_flags |NULLOK HV *hv \ |U32 flags APdm |I32 |ibcmp |NN const char *a \ @@ -1703,7 +1680,7 @@ CRp |bool |_is_uni_perl_idstart \ |UV c ARTdip |Size_t |isUTF8_CHAR |NN const U8 * const s0 \ |NN const U8 * const e -ATdmp |STRLEN |is_utf8_char_buf \ +AMTbdp |STRLEN |is_utf8_char_buf \ |NN const U8 *buf \ |NN const U8 *buf_end ARTdip |Size_t |isUTF8_CHAR_flags \ @@ -2105,7 +2082,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 \ @@ -2126,7 +2103,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 \ @@ -2165,7 +2142,7 @@ ARdp |OP * |newASSIGNOP |I32 flags \ |NULLOK OP *left \ |I32 optype \ |NULLOK OP *right -Admp |CV * |newATTRSUB |I32 floor \ +Adm |CV * |newATTRSUB |I32 floor \ |NULLOK OP *o \ |NULLOK OP *proto \ |NULLOK OP *attrs \ @@ -2176,7 +2153,7 @@ Xdp |CV * |newATTRSUB_x |I32 floor \ |NULLOK OP *attrs \ |NULLOK OP *block \ |bool o_is_gv -ARdmp |AV * |newAV +AMRbdp |AV * |newAV ARdm |AV * |newAV_alloc_x |SSize_t size ARdm |AV * |newAV_alloc_xz |SSize_t size ARdp |AV * |newAVav |NULLOK AV *oav @@ -2226,10 +2203,10 @@ ARdp |OP * |newGVOP |I32 type \ |NN GV *gv ARdp |OP * |newGVREF |I32 type \ |NULLOK OP *o -ARdmp |HV * |newHV +AMRbdp |HV * |newHV ARdp |HV * |newHVhv |NULLOK HV *hv ARdp |OP * |newHVREF |NN OP *o -ARdmp |IO * |newIO +AMRbdp |IO * |newIO ARdp |OP * |newLISTOP |I32 type \ |I32 flags \ |NULLOK OP *first \ @@ -2295,7 +2272,7 @@ ARdp |OP * |newSTATEOP |I32 flags \ |NULLOK OP *o p |CV * |newSTUB |NN GV *gv \ |bool fake -Admp |CV * |newSUB |I32 floor \ +AMbdp |CV * |newSUB |I32 floor \ |NULLOK OP *o \ |NULLOK OP *proto \ |NULLOK OP *block @@ -2334,7 +2311,7 @@ ARdp |SV * |newSVpvz |const STRLEN len ARdp |OP * |newSVREF |NN OP *o Adp |SV * |newSVrv |NN SV * const rv \ |NULLOK const char * const classname -ARdmp |SV * |newSVsv |NULLOK SV * const old +AMRbdp |SV * |newSVsv |NULLOK SV * const old ARdp |SV * |newSVsv_flags |NULLOK SV * const old \ |I32 flags ARdm |SV * |newSVsv_nomg |NULLOK SV * const old @@ -2934,10 +2911,10 @@ Cp |void |save_destructor_x \ |DESTRUCTORFUNC_t f \ |NULLOK void *p : Used in SAVEFREOP(), used in op.c, pp_ctl.c -Cmp |void |save_freeop |NULLOK OP *o -Cmp |void |save_freepv |NULLOK char *pv +CMbp |void |save_freeop |NULLOK OP *o +CMbp |void |save_freepv |NULLOK char *pv Cdp |void |save_freercpv |NN char *rcpv -Cmp |void |save_freesv |NULLOK SV *sv +CMbp |void |save_freesv |NULLOK SV *sv Cdp |void |save_generic_pvref \ |NN char **str Cdp |void |save_generic_svref \ @@ -2963,10 +2940,10 @@ Cp |void |save_I8 |NN I8 *bytep Cp |void |save_int |NN int *intp Adhp |void |save_item |NN SV *item Cp |void |save_iv |NN IV *ivp -Cmp |void |save_mortalizesv \ +CMbp |void |save_mortalizesv \ |NN SV *sv : Used in SAVEFREOP(), used in gv.c, op.c, perl.c, pp_ctl.c, pp_sort.c -Cdmp |void |save_op +CMbdp |void |save_op Cdp |void |save_padsv_and_mortalize \ |PADOFFSET off Cp |void |save_pptr |NN char **pptr @@ -3113,7 +3090,7 @@ ATdip |void |SvAMAGIC_on |NN SV *sv ATdp |void |sv_backoff |NN SV * const sv Adp |SV * |sv_bless |NN SV * const sv \ |NN NOCHECK HV * const stash -Cdmp |bool |sv_2bool |NN SV * const sv +CMbdp |bool |sv_2bool |NN SV * const sv Cdp |bool |sv_2bool_flags |NN SV *sv \ |I32 flags Cp |bool |sv_can_swipe_pv_buf \ @@ -3137,22 +3114,22 @@ Adfpv |void |sv_catpvf_mg |NN SV * const sv \ |... Adp |void |sv_catpv_mg |NN SV * const dsv \ |NULLOK const char * const sstr -Admp |void |sv_catpvn |NN SV * const dsv \ +AMbdp |void |sv_catpvn |NN SV * const dsv \ |NN const char *sstr \ |STRLEN len Adp |void |sv_catpvn_flags|NN SV * const dsv \ |NN const char *sstr \ |const STRLEN len \ |const I32 flags -Admp |void |sv_catpvn_mg |NN SV * const dsv \ +AMbdp |void |sv_catpvn_mg |NN SV * const dsv \ |NN const char *sstr \ |STRLEN len -Admp |void |sv_catsv |NN SV * const dsv \ +AMbdp |void |sv_catsv |NN SV * const dsv \ |NULLOK SV * const sstr Adp |void |sv_catsv_flags |NN SV * const dsv \ |NULLOK SV * const sstr \ |const I32 flags -Admp |void |sv_catsv_mg |NN SV * const dsv \ +AMbdp |void |sv_catsv_mg |NN SV * const dsv \ |NULLOK SV * const sstr Adp |void |sv_chop |NN SV * const sv \ |NULLOK const char * const ptr @@ -3172,7 +3149,7 @@ Adp |I32 |sv_cmp_locale_flags \ |NULLOK SV * const sv1 \ |NULLOK SV * const sv2 \ |const U32 flags -Admp |void |sv_copypv |NN SV * const dsv \ +AMbdp |void |sv_copypv |NN SV * const dsv \ |NN SV * const ssv Adp |void |sv_copypv_flags|NN SV * const dsv \ |NN SV * const ssv \ @@ -3222,12 +3199,12 @@ ARdp |bool |sv_does_sv |NN SV *sv \ Adp |void |sv_dump |NULLOK SV *sv Adp |void |sv_dump_depth |NULLOK SV *sv \ |I32 depth -Admp |I32 |sv_eq |NULLOK SV *sv1 \ +AMbdp |I32 |sv_eq |NULLOK SV *sv1 \ |NULLOK SV *sv2 Adp |I32 |sv_eq_flags |NULLOK SV *sv1 \ |NULLOK SV *sv2 \ |const U32 flags -Admp |void |sv_force_normal|NN SV *sv +AMbdp |void |sv_force_normal|NN SV *sv Adp |void |sv_force_normal_flags \ |NN SV * const sv \ |const U32 flags @@ -3247,7 +3224,7 @@ Cdp |char * |sv_grow_fresh |NN SV * const sv \ |STRLEN newlen Adp |void |sv_inc |NULLOK SV * const sv Adp |void |sv_inc_nomg |NULLOK SV * const sv -Admp |void |sv_insert |NN SV * const bigstr \ +AMbdp |void |sv_insert |NN SV * const bigstr \ |const STRLEN offset \ |const STRLEN len \ |NN const char * const little \ @@ -3265,7 +3242,7 @@ ARdp |bool |sv_isa_sv |NN SV *sv \ |NN SV *namesv Adp |int |sv_isobject |NULLOK SV *sv Adip |IV |SvIV |NN SV *sv -Cmp |IV |sv_2iv |NN SV * const sv +CMbp |IV |sv_2iv |NN SV *sv Adp |IV |sv_2iv_flags |NN SV * const sv \ |const I32 flags Adip |IV |SvIV_nomg |NN SV *sv @@ -3289,7 +3266,7 @@ Adp |MAGIC *|sv_magicext |NN SV * const sv \ EXp |MAGIC *|sv_magicext_mglob \ |NN SV *sv Adp |SV * |sv_2mortal |NULLOK SV * const sv -ARdmp |SV * |sv_mortalcopy |NULLOK SV * const oldsv +AMRbdp |SV * |sv_mortalcopy |NULLOK SV * const oldsv ARdp |SV * |sv_mortalcopy_flags \ |NULLOK SV * const oldsv \ |U32 flags @@ -3307,7 +3284,6 @@ Adp |bool |sv_numeq_flags |NULLOK SV *sv1 \ |NULLOK SV *sv2 \ |const U32 flags Adip |NV |SvNV |NN SV *sv -Cmp |NV |sv_2nv |NN SV * const sv Adp |NV |sv_2nv_flags |NN SV * const sv \ |const I32 flags Adip |NV |SvNV_nomg |NN SV *sv @@ -3328,12 +3304,12 @@ Adp |STRLEN |sv_pos_u2b_flags \ |STRLEN uoffset \ |NULLOK STRLEN * const lenp \ |U32 flags -Admp |char * |sv_2pv |NN SV *sv \ +AMbdp |char * |sv_2pv |NN SV *sv \ |NULLOK STRLEN *lp -CRdmp |char * |sv_pv |NN SV *sv -Admp |char * |sv_2pvbyte |NN SV *sv \ +CMRbdp |char * |sv_pv |NN SV *sv +AMbdp |char * |sv_2pvbyte |NN SV *sv \ |NULLOK STRLEN * const lp -CRdmp |char * |sv_pvbyte |NN SV *sv +CMRbdp |char * |sv_pvbyte |NN SV *sv Adp |char * |sv_2pvbyte_flags \ |NN SV *sv \ |NULLOK STRLEN * const lp \ @@ -3345,21 +3321,21 @@ ip |char * |sv_pvbyten_force_wrapper \ |NN SV * const sv \ |NULLOK STRLEN * const lp \ |const U32 dummy -CRdmp |char * |sv_2pvbyte_nolen \ +CMRbdp |char * |sv_2pvbyte_nolen \ |NN SV *sv Adp |char * |sv_2pv_flags |NN SV * const sv \ |NULLOK STRLEN * const lp \ |const U32 flags -Cdmp |char * |sv_pvn_force |NN SV *sv \ +CMbdp |char * |sv_pvn_force |NN SV *sv \ |NULLOK STRLEN *lp Adp |char * |sv_pvn_force_flags \ |NN SV * const sv \ |NULLOK STRLEN * const lp \ |const U32 flags -CRdmp |char * |sv_2pv_nolen |NN SV *sv -Admp |char * |sv_2pvutf8 |NN SV *sv \ +CMRbdp |char * |sv_2pv_nolen |NN SV *sv +AMbdp |char * |sv_2pvutf8 |NN SV *sv \ |NULLOK STRLEN * const lp -CRdmp |char * |sv_pvutf8 |NN SV *sv +CMRbdp |char * |sv_pvutf8 |NN SV *sv Adp |char * |sv_2pvutf8_flags \ |NN SV *sv \ |NULLOK STRLEN * const lp \ @@ -3371,7 +3347,7 @@ ip |char * |sv_pvutf8n_force_wrapper \ |NN SV * const sv \ |NULLOK STRLEN * const lp \ |const U32 dummy -CRdmp |char * |sv_2pvutf8_nolen \ +CMRbdp |char * |sv_2pvutf8_nolen \ |NN SV *sv AIdp |bool |SvPVXtrue |NN SV *sv Adp |char * |sv_recode_to_utf8 \ @@ -3476,7 +3452,7 @@ Adp |void |sv_setrv_noinc |NN SV * const sv \ Adp |void |sv_setrv_noinc_mg \ |NN SV * const sv \ |NN SV * const ref -Admp |void |sv_setsv |NN SV *dsv \ +AMbdp |void |sv_setsv |NN SV *dsv \ |NULLOK SV *ssv Adp |void |sv_setsv_flags |NN SV *dsv \ |NULLOK SV *ssv \ @@ -3509,7 +3485,7 @@ Adp |SV * |sv_strftime_tm |NN SV *fmt \ Adp |SV * |sv_string_from_errnum \ |int errnum \ |NULLOK SV *tgtsv -Cdmp |void |sv_taint |NN SV *sv +CMbdp |void |sv_taint |NN SV *sv CRdp |bool |sv_tainted |NN SV * const sv Adip |bool |SvTRUE |NULLOK SV *sv Cdp |I32 |sv_true |NULLOK SV * const sv @@ -3526,24 +3502,24 @@ Adp |int |sv_unmagic |NN SV * const sv \ Adp |int |sv_unmagicext |NN SV * const sv \ |const int type \ |NULLOK const MGVTBL *vtbl -Admp |void |sv_unref |NN SV *sv +AMbdp |void |sv_unref |NN SV *sv Adp |void |sv_unref_flags |NN SV * const ref \ |const U32 flags Cdp |void |sv_untaint |NN SV * const sv Adp |void |sv_upgrade |NN SV * const sv \ |svtype new_type -Admp |void |sv_usepvn |NN SV *sv \ +AMbdp |void |sv_usepvn |NN SV *sv \ |NULLOK char *ptr \ |STRLEN len Adp |void |sv_usepvn_flags|NN SV * const sv \ |NULLOK char *ptr \ |const STRLEN len \ |const U32 flags -Admp |void |sv_usepvn_mg |NN SV *sv \ +AMbdp |void |sv_usepvn_mg |NN SV *sv \ |NULLOK char *ptr \ |STRLEN len Adp |bool |sv_utf8_decode |NN SV * const sv -Admp |bool |sv_utf8_downgrade \ +AMbdp |bool |sv_utf8_downgrade \ |NN SV * const sv \ |const bool fail_ok Adp |bool |sv_utf8_downgrade_flags \ @@ -3554,8 +3530,8 @@ Adm |bool |sv_utf8_downgrade_nomg \ |NN SV * const sv \ |const bool fail_ok Adp |void |sv_utf8_encode |NN SV * const sv -Admp |STRLEN |sv_utf8_upgrade|NN SV *sv -Admp |STRLEN |sv_utf8_upgrade_flags \ +AMbdp |STRLEN |sv_utf8_upgrade|NN SV *sv +Adm |STRLEN |sv_utf8_upgrade_flags \ |NN SV * const sv \ |const I32 flags Adp |STRLEN |sv_utf8_upgrade_flags_grow \ @@ -3565,7 +3541,7 @@ Adp |STRLEN |sv_utf8_upgrade_flags_grow \ Adm |STRLEN |sv_utf8_upgrade_nomg \ |NN SV *sv Adip |UV |SvUV |NN SV *sv -Cmp |UV |sv_2uv |NN SV * const sv +CMbp |UV |sv_2uv |NN SV *sv Adp |UV |sv_2uv_flags |NN SV * const sv \ |const I32 flags Adip |UV |SvUV_nomg |NN SV *sv @@ -3838,13 +3814,13 @@ p |void |utilize |int aver \ |NN OP *idop \ |NULLOK OP *arg -Admp |U8 * |uvchr_to_utf8 |NN U8 *d \ +Adm |U8 * |uvchr_to_utf8 |NN U8 *d \ |UV uv -Admp |U8 * |uvchr_to_utf8_flags \ +Adm |U8 * |uvchr_to_utf8_flags \ |NN U8 *d \ |UV uv \ |UV flags -Admp |U8 * |uvchr_to_utf8_flags_msgs \ +Adm |U8 * |uvchr_to_utf8_flags_msgs \ |NN U8 *d \ |UV uv \ |UV flags \ @@ -3859,13 +3835,13 @@ Cp |U8 * |uvoffuni_to_utf8_flags_msgs \ |const UV flags \ |NULLOK HV **msgs -Admp |U8 * |uv_to_utf8 |NN U8 *d \ +Adip |U8 * |uv_to_utf8 |NN U8 *d \ |UV uv -Admp |U8 * |uv_to_utf8_flags \ +Adip |U8 * |uv_to_utf8_flags \ |NN U8 *d \ |UV uv \ |UV flags -Admp |U8 * |uv_to_utf8_msgs|NN U8 *d \ +Adip |U8 * |uv_to_utf8_msgs|NN U8 *d \ |UV uv \ |UV flags \ |NULLOK HV **msgs @@ -4204,7 +4180,7 @@ Mp |bool |do_exec |NN const char *cmd p |bool |do_exec |NN const char *cmd #endif #if defined(PERL_DONT_CREATE_GVSV) -Admp |GV * |gv_SVadd |NULLOK GV *gv +AMbdp |GV * |gv_SVadd |NULLOK GV *gv #endif #if defined(PERL_IMPLICIT_SYS) CTo |PerlInterpreter *|perl_alloc_using \ @@ -4789,7 +4765,7 @@ ST |int |adjust_size_and_find_bucket \ #endif #if defined(PERL_IN_MATHOMS_C) || defined(PERL_IN_OP_C) || \ defined(PERL_IN_PERLY_C) || defined(PERL_IN_TOKE_C) -mp |OP * |ref |NULLOK OP *o \ +Mbp |OP * |ref |NULLOK OP *o \ |I32 type #endif #if defined(PERL_IN_MG_C) @@ -6403,7 +6379,7 @@ p |int |magic_setcollxfrm \ |NN MAGIC *mg EXop |SV * |strxfrm |NN SV *src : Defined in locale.c, used only in sv.c -Admp |char * |sv_collxfrm |NN SV * const sv \ +AMbdp |char * |sv_collxfrm |NN SV * const sv \ |NN STRLEN * const nxp Adp |char * |sv_collxfrm_flags \ |NN SV * const sv \ diff --git a/embed.h b/embed.h index d6926854177b..f2980ef5dcb1 100644 --- a/embed.h +++ b/embed.h @@ -209,7 +209,6 @@ # define do_join(a,b,c,d) Perl_do_join(aTHX_ a,b,c,d) # define do_magic_dump(a,b,c,d,e,f,g) Perl_do_magic_dump(aTHX_ a,b,c,d,e,f,g) # define do_op_dump(a,b,c) Perl_do_op_dump(aTHX_ a,b,c) -# define do_open(a,b,c,d,e,f,g) Perl_do_open(aTHX,a,b,c,d,e,f,g) # define do_openn(a,b,c,d,e,f,g,h,i) Perl_do_openn(aTHX_ a,b,c,d,e,f,g,h,i) # define do_pmop_dump(a,b,c) Perl_do_pmop_dump(aTHX_ a,b,c) # define do_sprintf(a,b,c) Perl_do_sprintf(aTHX_ a,b,c) @@ -259,9 +258,6 @@ # define grok_number(a,b,c) Perl_grok_number(aTHX_ a,b,c) # define grok_number_flags(a,b,c,d) Perl_grok_number_flags(aTHX_ a,b,c,d) # define grok_numeric_radix(a,b) Perl_grok_numeric_radix(aTHX_ a,b) -# define gv_AVadd(a) Perl_gv_AVadd(aTHX,a) -# define gv_HVadd(a) Perl_gv_HVadd(aTHX,a) -# define gv_IOadd(a) Perl_gv_IOadd(aTHX,a) # define gv_add_by_type(a,b) Perl_gv_add_by_type(aTHX_ a,b) # define gv_autoload_pv(a,b,c) Perl_gv_autoload_pv(aTHX_ a,b,c) # define gv_autoload_pvn(a,b,c,d) Perl_gv_autoload_pvn(aTHX_ a,b,c,d) @@ -269,7 +265,6 @@ # define gv_check(a) Perl_gv_check(aTHX_ a) # define gv_const_sv(a) Perl_gv_const_sv(aTHX_ a) # define gv_dump(a) Perl_gv_dump(aTHX_ a) -# define gv_efullname3(a,b,c) Perl_gv_efullname3(aTHX,a,b,c) # define gv_efullname4(a,b,c,d) Perl_gv_efullname4(aTHX_ a,b,c,d) # define gv_fetchfile(a) Perl_gv_fetchfile(aTHX_ a) # define gv_fetchfile_flags(a,b,c) Perl_gv_fetchfile_flags(aTHX_ a,b,c) @@ -279,7 +274,6 @@ # define gv_fetchmeth_pvn_autoload(a,b,c,d,e) Perl_gv_fetchmeth_pvn_autoload(aTHX_ a,b,c,d,e) # define gv_fetchmeth_sv(a,b,c,d) Perl_gv_fetchmeth_sv(aTHX_ a,b,c,d) # define gv_fetchmeth_sv_autoload(a,b,c,d) Perl_gv_fetchmeth_sv_autoload(aTHX_ a,b,c,d) -# define gv_fetchmethod(a,b) Perl_gv_fetchmethod(aTHX,a,b) # define gv_fetchmethod_autoload(a,b,c) Perl_gv_fetchmethod_autoload(aTHX_ a,b,c) # define gv_fetchmethod_pv_flags(a,b,c) Perl_gv_fetchmethod_pv_flags(aTHX_ a,b,c) # define gv_fetchmethod_pvn_flags(a,b,c,d) Perl_gv_fetchmethod_pvn_flags(aTHX_ a,b,c,d) @@ -287,7 +281,6 @@ # define gv_fetchpv(a,b,c) Perl_gv_fetchpv(aTHX_ a,b,c) # define gv_fetchpvn_flags(a,b,c,d) Perl_gv_fetchpvn_flags(aTHX_ a,b,c,d) # define gv_fetchsv(a,b,c) Perl_gv_fetchsv(aTHX_ a,b,c) -# define gv_fullname3(a,b,c) Perl_gv_fullname3(aTHX,a,b,c) # define gv_fullname4(a,b,c,d) Perl_gv_fullname4(aTHX_ a,b,c,d) # define gv_handler(a,b) Perl_gv_handler(aTHX_ a,b) # define gv_init_pv(a,b,c,d) Perl_gv_init_pv(aTHX_ a,b,c,d) @@ -304,31 +297,18 @@ # define hv_common_key_len(a,b,c,d,e,f) Perl_hv_common_key_len(aTHX_ a,b,c,d,e,f) # define hv_copy_hints_hv(a) Perl_hv_copy_hints_hv(aTHX_ a) # define hv_delayfree_ent(a,b) Perl_hv_delayfree_ent(aTHX_ a,b) -# define hv_delete(a,b,c,d) Perl_hv_delete(aTHX,a,b,c,d) -# define hv_delete_ent(a,b,c,d) Perl_hv_delete_ent(aTHX,a,b,c,d) # define hv_dump(a) Perl_hv_dump(aTHX_ a) -# define hv_exists(a,b,c) Perl_hv_exists(aTHX,a,b,c) -# define hv_exists_ent(a,b,c) Perl_hv_exists_ent(aTHX,a,b,c) -# define hv_fetch(a,b,c,d) Perl_hv_fetch(aTHX,a,b,c,d) -# define hv_fetch_ent(a,b,c,d) Perl_hv_fetch_ent(aTHX,a,b,c,d) # define hv_free_ent(a,b) Perl_hv_free_ent(aTHX_ a,b) # define hv_iterinit(a) Perl_hv_iterinit(aTHX_ a) # define hv_iterkey(a,b) Perl_hv_iterkey(aTHX_ a,b) # define hv_iterkeysv(a) Perl_hv_iterkeysv(aTHX_ a) -# define hv_iternext(a) Perl_hv_iternext(aTHX,a) # define hv_iternext_flags(a,b) Perl_hv_iternext_flags(aTHX_ a,b) # define hv_iternextsv(a,b,c) Perl_hv_iternextsv(aTHX_ a,b,c) # define hv_iterval(a,b) Perl_hv_iterval(aTHX_ a,b) # define hv_ksplit(a,b) Perl_hv_ksplit(aTHX_ a,b) -# define hv_magic(a,b,c) Perl_hv_magic(aTHX,a,b,c) # define hv_name_set(a,b,c,d) Perl_hv_name_set(aTHX_ a,b,c,d) # define hv_rand_set(a,b) Perl_hv_rand_set(aTHX_ a,b) # define hv_scalar(a) Perl_hv_scalar(aTHX_ a) -# define hv_store(a,b,c,d,e) Perl_hv_store(aTHX,a,b,c,d,e) -# define hv_store_ent(a,b,c,d) Perl_hv_store_ent(aTHX,a,b,c,d) -# define hv_store_flags(a,b,c,d,e,f) Perl_hv_store_flags(aTHX,a,b,c,d,e,f) -# define hv_stores(a,b,c) Perl_hv_stores(aTHX,a,b,c) -# define hv_undef(a) Perl_hv_undef(aTHX,a) # 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) @@ -344,7 +324,6 @@ # define is_safe_syscall(a,b,c,d) Perl_is_safe_syscall(aTHX_ a,b,c,d) # define is_strict_utf8_string_loclen Perl_is_strict_utf8_string_loclen # define is_utf8_FF_helper_ Perl_is_utf8_FF_helper_ -# define is_utf8_char_buf Perl_is_utf8_char_buf # define is_utf8_char_helper_ Perl_is_utf8_char_helper_ # 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 @@ -411,8 +390,6 @@ # define newANONSUB(a,b,c) Perl_newANONSUB(aTHX_ a,b,c) # define newARGDEFELEMOP(a,b,c) Perl_newARGDEFELEMOP(aTHX_ a,b,c) # define newASSIGNOP(a,b,c,d) Perl_newASSIGNOP(aTHX_ a,b,c,d) -# define newATTRSUB(a,b,c,d,e) Perl_newATTRSUB(aTHX,a,b,c,d,e) -# define newAV() Perl_newAV(aTHX) # define newAVREF(a) Perl_newAVREF(aTHX_ a) # define newAVav(a) Perl_newAVav(aTHX_ a) # define newAVhv(a) Perl_newAVhv(aTHX_ a) @@ -429,10 +406,8 @@ # define newGVOP(a,b,c) Perl_newGVOP(aTHX_ a,b,c) # define newGVREF(a,b) Perl_newGVREF(aTHX_ a,b) # define newGVgen_flags(a,b) Perl_newGVgen_flags(aTHX_ a,b) -# define newHV() Perl_newHV(aTHX) # define newHVREF(a) Perl_newHVREF(aTHX_ a) # define newHVhv(a) Perl_newHVhv(aTHX_ a) -# define newIO() Perl_newIO(aTHX) # define newLISTOP(a,b,c,d) Perl_newLISTOP(aTHX_ a,b,c,d) # define newLISTOPn(a,...) Perl_newLISTOPn(aTHX_ a,__VA_ARGS__) # define newLOGOP(a,b,c,d) Perl_newLOGOP(aTHX_ a,b,c,d) @@ -455,7 +430,6 @@ # define newRV_noinc(a) Perl_newRV_noinc(aTHX_ a) # define newSLICEOP(a,b,c) Perl_newSLICEOP(aTHX_ a,b,c) # define newSTATEOP(a,b,c) Perl_newSTATEOP(aTHX_ a,b,c) -# define newSUB(a,b,c,d) Perl_newSUB(aTHX,a,b,c,d) # define newSV(a) Perl_newSV(aTHX_ a) # define newSVOP(a,b,c) Perl_newSVOP(aTHX_ a,b,c) # define newSVREF(a) Perl_newSVREF(aTHX_ a) @@ -475,7 +449,6 @@ # define newSVpvn_share(a,b,c) Perl_newSVpvn_share(aTHX_ a,b,c) # define newSVpvz(a) Perl_newSVpvz(aTHX_ a) # define newSVrv(a,b) Perl_newSVrv(aTHX_ a,b) -# define newSVsv(a) Perl_newSVsv(aTHX,a) # define newSVsv_flags(a,b) Perl_newSVsv_flags(aTHX_ a,b) # define newSVuv(a) Perl_newSVuv(aTHX_ a) # define newTRYCATCHOP(a,b,c,d) Perl_newTRYCATCHOP(aTHX_ a,b,c,d) @@ -629,10 +602,7 @@ # define save_delete(a,b,c) Perl_save_delete(aTHX_ a,b,c) # define save_destructor(a,b) Perl_save_destructor(aTHX_ a,b) # define save_destructor_x(a,b) Perl_save_destructor_x(aTHX_ a,b) -# define save_freeop(a) Perl_save_freeop(aTHX,a) -# define save_freepv(a) Perl_save_freepv(aTHX,a) # define save_freercpv(a) Perl_save_freercpv(aTHX_ a) -# define save_freesv(a) Perl_save_freesv(aTHX,a) # define save_generic_pvref(a) Perl_save_generic_pvref(aTHX_ a) # define save_generic_svref(a) Perl_save_generic_svref(aTHX_ a) # define save_gp(a,b) Perl_save_gp(aTHX_ a,b) @@ -644,8 +614,6 @@ # define save_int(a) Perl_save_int(aTHX_ a) # define save_item(a) Perl_save_item(aTHX_ a) # define save_iv(a) Perl_save_iv(aTHX_ a) -# define save_mortalizesv(a) Perl_save_mortalizesv(aTHX,a) -# define save_op() Perl_save_op(aTHX) # define save_padsv_and_mortalize(a) Perl_save_padsv_and_mortalize(aTHX_ a) # define save_pptr(a) Perl_save_pptr(aTHX_ a) # define save_pushi32ptr(a,b,c) Perl_save_pushi32ptr(aTHX_ a,b,c) @@ -685,25 +653,15 @@ # define str_to_version(a) Perl_str_to_version(aTHX_ a) # define strict_utf8_to_uv Perl_strict_utf8_to_uv # define suspend_compcv(a) Perl_suspend_compcv(aTHX_ a) -# define sv_2bool(a) Perl_sv_2bool(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) # define sv_2io(a) Perl_sv_2io(aTHX_ a) -# define sv_2iv(a) Perl_sv_2iv(aTHX,a) # define sv_2iv_flags(a,b) Perl_sv_2iv_flags(aTHX_ a,b) # define sv_2mortal(a) Perl_sv_2mortal(aTHX_ a) -# define sv_2nv(a) Perl_sv_2nv(aTHX,a) # define sv_2nv_flags(a,b) Perl_sv_2nv_flags(aTHX_ a,b) -# define sv_2pv(a,b) Perl_sv_2pv(aTHX,a,b) # define sv_2pv_flags(a,b,c) Perl_sv_2pv_flags(aTHX_ a,b,c) -# define sv_2pv_nolen(a) Perl_sv_2pv_nolen(aTHX,a) -# define sv_2pvbyte(a,b) Perl_sv_2pvbyte(aTHX,a,b) # define sv_2pvbyte_flags(a,b,c) Perl_sv_2pvbyte_flags(aTHX_ a,b,c) -# define sv_2pvbyte_nolen(a) Perl_sv_2pvbyte_nolen(aTHX,a) -# define sv_2pvutf8(a,b) Perl_sv_2pvutf8(aTHX,a,b) # define sv_2pvutf8_flags(a,b,c) Perl_sv_2pvutf8_flags(aTHX_ a,b,c) -# define sv_2pvutf8_nolen(a) Perl_sv_2pvutf8_nolen(aTHX,a) -# define sv_2uv(a) Perl_sv_2uv(aTHX,a) # define sv_2uv_flags(a,b) Perl_sv_2uv_flags(aTHX_ a,b) # define sv_backoff Perl_sv_backoff # define sv_bless(a,b) Perl_sv_bless(aTHX_ a,b) @@ -712,17 +670,12 @@ # define sv_catpv(a,b) Perl_sv_catpv(aTHX_ a,b) # define sv_catpv_flags(a,b,c) Perl_sv_catpv_flags(aTHX_ a,b,c) # define sv_catpv_mg(a,b) Perl_sv_catpv_mg(aTHX_ a,b) -# define sv_catpvn(a,b,c) Perl_sv_catpvn(aTHX,a,b,c) # define sv_catpvn_flags(a,b,c,d) Perl_sv_catpvn_flags(aTHX_ a,b,c,d) -# define sv_catpvn_mg(a,b,c) Perl_sv_catpvn_mg(aTHX,a,b,c) -# define sv_catsv(a,b) Perl_sv_catsv(aTHX,a,b) # define sv_catsv_flags(a,b,c) Perl_sv_catsv_flags(aTHX_ a,b,c) -# define sv_catsv_mg(a,b) Perl_sv_catsv_mg(aTHX,a,b) # define sv_chop(a,b) Perl_sv_chop(aTHX_ a,b) # define sv_clear(a) Perl_sv_clear(aTHX_ a) # define sv_cmp_flags(a,b,c) Perl_sv_cmp_flags(aTHX_ a,b,c) # define sv_cmp_locale_flags(a,b,c) Perl_sv_cmp_locale_flags(aTHX_ a,b,c) -# define sv_copypv(a,b) Perl_sv_copypv(aTHX,a,b) # define sv_copypv_flags(a,b,c) Perl_sv_copypv_flags(aTHX_ a,b,c) # define sv_dec(a) Perl_sv_dec(aTHX_ a) # define sv_dec_nomg(a) Perl_sv_dec_nomg(aTHX_ a) @@ -738,9 +691,7 @@ # define sv_does_sv(a,b,c) Perl_sv_does_sv(aTHX_ a,b,c) # define sv_dump(a) Perl_sv_dump(aTHX_ a) # define sv_dump_depth(a,b) Perl_sv_dump_depth(aTHX_ a,b) -# define sv_eq(a,b) Perl_sv_eq(aTHX,a,b) # define sv_eq_flags(a,b,c) Perl_sv_eq_flags(aTHX_ a,b,c) -# define sv_force_normal(a) Perl_sv_force_normal(aTHX,a) # define sv_force_normal_flags(a,b) Perl_sv_force_normal_flags(aTHX_ a,b) # define sv_free(a) Perl_sv_free(aTHX_ a) # define sv_get_backrefs Perl_sv_get_backrefs @@ -749,7 +700,6 @@ # define sv_grow_fresh(a,b) Perl_sv_grow_fresh(aTHX_ a,b) # define sv_inc(a) Perl_sv_inc(aTHX_ a) # define sv_inc_nomg(a) Perl_sv_inc_nomg(aTHX_ a) -# define sv_insert(a,b,c,d,e) Perl_sv_insert(aTHX,a,b,c,d,e) # define sv_insert_flags(a,b,c,d,e,f) Perl_sv_insert_flags(aTHX_ a,b,c,d,e,f) # define sv_isa(a,b) Perl_sv_isa(aTHX_ a,b) # define sv_isa_sv(a,b) Perl_sv_isa_sv(aTHX_ a,b) @@ -760,7 +710,6 @@ # define sv_len_utf8_nomg(a) Perl_sv_len_utf8_nomg(aTHX_ a) # define sv_magic(a,b,c,d,e) Perl_sv_magic(aTHX_ a,b,c,d,e) # define sv_magicext(a,b,c,d,e,f) Perl_sv_magicext(aTHX_ a,b,c,d,e,f) -# define sv_mortalcopy(a) Perl_sv_mortalcopy(aTHX,a) # define sv_mortalcopy_flags(a,b) Perl_sv_mortalcopy_flags(aTHX_ a,b) # define sv_newmortal() Perl_sv_newmortal(aTHX) # define sv_newref(a) Perl_sv_newref(aTHX_ a) @@ -771,12 +720,8 @@ # define sv_pos_b2u_flags(a,b,c) Perl_sv_pos_b2u_flags(aTHX_ a,b,c) # define sv_pos_u2b(a,b,c) Perl_sv_pos_u2b(aTHX_ a,b,c) # define sv_pos_u2b_flags(a,b,c,d) Perl_sv_pos_u2b_flags(aTHX_ a,b,c,d) -# define sv_pv(a) Perl_sv_pv(aTHX,a) -# define sv_pvbyte(a) Perl_sv_pvbyte(aTHX,a) # define sv_pvbyten_force(a,b) Perl_sv_pvbyten_force(aTHX_ a,b) -# define sv_pvn_force(a,b) Perl_sv_pvn_force(aTHX,a,b) # define sv_pvn_force_flags(a,b,c) Perl_sv_pvn_force_flags(aTHX_ a,b,c) -# define sv_pvutf8(a) Perl_sv_pvutf8(aTHX,a) # define sv_pvutf8n_force(a,b) Perl_sv_pvutf8n_force(aTHX_ a,b) # define sv_recode_to_utf8(a,b) Perl_sv_recode_to_utf8(aTHX_ a,b) # define sv_ref(a,b,c) Perl_sv_ref(aTHX_ a,b,c) @@ -813,7 +758,6 @@ # define sv_setrv_inc_mg(a,b) Perl_sv_setrv_inc_mg(aTHX_ a,b) # define sv_setrv_noinc(a,b) Perl_sv_setrv_noinc(aTHX_ a,b) # define sv_setrv_noinc_mg(a,b) Perl_sv_setrv_noinc_mg(aTHX_ a,b) -# define sv_setsv(a,b) Perl_sv_setsv(aTHX,a,b) # define sv_setsv_flags(a,b,c) Perl_sv_setsv_flags(aTHX_ a,b,c) # define sv_setsv_mg(a,b) Perl_sv_setsv_mg(aTHX_ a,b) # define sv_setuv(a,b) Perl_sv_setuv(aTHX_ a,b) @@ -822,25 +766,18 @@ # define sv_strftime_ints(a,b,c,d,e,f,g,h) Perl_sv_strftime_ints(aTHX_ a,b,c,d,e,f,g,h) # define sv_strftime_tm(a,b) Perl_sv_strftime_tm(aTHX_ a,b) # define sv_string_from_errnum(a,b) Perl_sv_string_from_errnum(aTHX_ a,b) -# define sv_taint(a) Perl_sv_taint(aTHX,a) # define sv_tainted(a) Perl_sv_tainted(aTHX_ a) # define sv_true(a) Perl_sv_true(aTHX_ a) # define sv_uni_display(a,b,c,d) Perl_sv_uni_display(aTHX_ a,b,c,d) # define sv_unmagic(a,b) Perl_sv_unmagic(aTHX_ a,b) # define sv_unmagicext(a,b,c) Perl_sv_unmagicext(aTHX_ a,b,c) -# define sv_unref(a) Perl_sv_unref(aTHX,a) # define sv_unref_flags(a,b) Perl_sv_unref_flags(aTHX_ a,b) # define sv_untaint(a) Perl_sv_untaint(aTHX_ a) # define sv_upgrade(a,b) Perl_sv_upgrade(aTHX_ a,b) -# define sv_usepvn(a,b,c) Perl_sv_usepvn(aTHX,a,b,c) # define sv_usepvn_flags(a,b,c,d) Perl_sv_usepvn_flags(aTHX_ a,b,c,d) -# define sv_usepvn_mg(a,b,c) Perl_sv_usepvn_mg(aTHX,a,b,c) # define sv_utf8_decode(a) Perl_sv_utf8_decode(aTHX_ a) -# define sv_utf8_downgrade(a,b) Perl_sv_utf8_downgrade(aTHX,a,b) # define sv_utf8_downgrade_flags(a,b,c) Perl_sv_utf8_downgrade_flags(aTHX_ a,b,c) # define sv_utf8_encode(a) Perl_sv_utf8_encode(aTHX_ a) -# define sv_utf8_upgrade(a) Perl_sv_utf8_upgrade(aTHX,a) -# define sv_utf8_upgrade_flags(a,b) Perl_sv_utf8_upgrade_flags(aTHX,a,b) # define sv_utf8_upgrade_flags_grow(a,b,c) Perl_sv_utf8_upgrade_flags_grow(aTHX_ a,b,c) # define sv_vcatpvf(a,b,c) Perl_sv_vcatpvf(aTHX_ a,b,c) # define sv_vcatpvf_mg(a,b,c) Perl_sv_vcatpvf_mg(aTHX_ a,b,c) @@ -886,12 +823,9 @@ # define utf8n_to_uvchr Perl_utf8n_to_uvchr # define utf8n_to_uvchr_error Perl_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) -# define uv_to_utf8_msgs(a,b,c,d) Perl_uv_to_utf8_msgs(aTHX,a,b,c,d) -# define uvchr_to_utf8(a,b) Perl_uvchr_to_utf8(aTHX,a,b) -# define uvchr_to_utf8_flags(a,b,c) Perl_uvchr_to_utf8_flags(aTHX,a,b,c) -# define uvchr_to_utf8_flags_msgs(a,b,c,d) Perl_uvchr_to_utf8_flags_msgs(aTHX,a,b,c,d) +# 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) +# define uv_to_utf8_msgs(a,b,c,d) Perl_uv_to_utf8_msgs(aTHX_ a,b,c,d) # define uvoffuni_to_utf8_flags_msgs(a,b,c,d) Perl_uvoffuni_to_utf8_flags_msgs(aTHX_ a,b,c,d) # define valid_identifier_pve(a,b,c) Perl_valid_identifier_pve(aTHX_ a,b,c) # define valid_identifier_pvn(a,b,c) Perl_valid_identifier_pvn(aTHX_ a,b,c) @@ -1044,7 +978,6 @@ # define defelem_target(a,b) Perl_defelem_target(aTHX_ a,b) # define delete_eval_scope() Perl_delete_eval_scope(aTHX) # define die_unwind(a) Perl_die_unwind(aTHX_ a) -# define do_aexec(a,b,c) Perl_do_aexec(aTHX,a,b,c) # define do_aexec5(a,b,c,d,e) Perl_do_aexec5(aTHX_ a,b,c,d,e) # define do_dump_pad(a,b,c,d) Perl_do_dump_pad(aTHX_ a,b,c,d) # define do_eof(a) Perl_do_eof(aTHX_ a) @@ -1158,9 +1091,7 @@ # define mro_package_moved(a,b,c,d) Perl_mro_package_moved(aTHX_ a,b,c,d) # define my_attrs(a,b) Perl_my_attrs(aTHX_ a,b) # define my_clearenv() Perl_my_clearenv(aTHX) -# define my_lstat() Perl_my_lstat(aTHX) # define my_lstat_flags(a) Perl_my_lstat_flags(aTHX_ a) -# define my_stat() Perl_my_stat(aTHX) # define my_stat_flags(a) Perl_my_stat_flags(aTHX_ a) # define my_strerror(a,b) Perl_my_strerror(aTHX_ a,b) # define my_unexec() Perl_my_unexec(aTHX) @@ -1513,10 +1444,6 @@ # if defined(PERL_IN_MALLOC_C) # define adjust_size_and_find_bucket S_adjust_size_and_find_bucket # endif -# if defined(PERL_IN_MATHOMS_C) || defined(PERL_IN_OP_C) || \ - defined(PERL_IN_PERLY_C) || defined(PERL_IN_TOKE_C) -# define ref(a,b) Perl_ref(aTHX,a,b) -# endif # if defined(PERL_IN_MG_C) # define fixup_errno_string(a) S_fixup_errno_string(aTHX_ a) # define magic_methcall1(a,b,c,d,e,f) S_magic_methcall1(aTHX_ a,b,c,d,e,f) @@ -2129,9 +2056,6 @@ # define finalize_optree(a) Perl_finalize_optree(aTHX_ a) # define optimize_optree(a) Perl_optimize_optree(aTHX_ a) # endif -# if defined(PERL_DONT_CREATE_GVSV) -# define gv_SVadd(a) Perl_gv_SVadd(aTHX,a) -# endif # if !defined(PERL_IMPLICIT_SYS) # define my_pclose(a) Perl_my_pclose(aTHX_ a) # define my_popen(a,b) Perl_my_popen(aTHX_ a,b) @@ -2300,7 +2224,6 @@ # define sv_dup_inc(a,b) Perl_sv_dup_inc(aTHX_ a,b) # endif /* defined(USE_ITHREADS) */ # if defined(USE_LOCALE_COLLATE) -# define sv_collxfrm(a,b) Perl_sv_collxfrm(aTHX,a,b) # define sv_collxfrm_flags(a,b,c) Perl_sv_collxfrm_flags(aTHX_ a,b,c) # if ( defined(PERL_CORE) || defined(PERL_EXT) ) && \ ( defined(PERL_IN_LOCALE_C) || defined(PERL_IN_MATHOMS_C) || \ diff --git a/gv.h b/gv.h index 1eb6adeb8ee1..4b13e7df26e9 100644 --- a/gv.h +++ b/gv.h @@ -297,12 +297,9 @@ Return the CV from the GV. /* gv_fetchfile_flags() */ #define GVF_NOADD 0x01 /* don't add the glob if it doesn't exist */ -#define Perl_gv_fullname3(mTHX, sv,gv,prefix) \ - Perl_gv_fullname4(aTHX_ sv,gv,prefix,TRUE) -#define Perl_gv_efullname3(mTHX, sv, gv, prefix) \ - Perl_gv_efullname4(aTHX_ sv,gv,prefix,TRUE) -#define Perl_gv_fetchmethod(mTHX, stash, name) \ - Perl_gv_fetchmethod_autoload(aTHX_ stash, name, TRUE) +#define gv_fullname3(sv,gv,prefix) gv_fullname4(sv,gv,prefix,TRUE) +#define gv_efullname3(sv,gv,prefix) gv_efullname4(sv,gv,prefix,TRUE) +#define gv_fetchmethod(stash, name) gv_fetchmethod_autoload(stash, name, TRUE) /* =for apidoc_defn Am|GV *|gv_fetchsv_nomg|SV *name|I32 flags|const svtype sv_type @@ -346,10 +343,10 @@ Make sure there is a slot of the given type (AV, HV, IO, SV) in the GV C. =cut */ -#define Perl_gv_AVadd(mTHX, gv) Perl_gv_add_by_type(aTHX_ (gv), SVt_PVAV) -#define Perl_gv_HVadd(mTHX, gv) Perl_gv_add_by_type(aTHX_ (gv), SVt_PVHV) -#define Perl_gv_IOadd(mTHX, gv) Perl_gv_add_by_type(aTHX_ (gv), SVt_PVIO) -#define Perl_gv_SVadd(mTHX, gv) Perl_gv_add_by_type(aTHX_ (gv), SVt_NULL) +#define gv_AVadd(gv) gv_add_by_type((gv), SVt_PVAV) +#define gv_HVadd(gv) gv_add_by_type((gv), SVt_PVHV) +#define gv_IOadd(gv) gv_add_by_type((gv), SVt_PVIO) +#define gv_SVadd(gv) gv_add_by_type((gv), SVt_NULL) /* * ex: set ts=8 sts=4 sw=4 et: diff --git a/hv.h b/hv.h index a89896d51e9c..a6319cd60af5 100644 --- a/hv.h +++ b/hv.h @@ -513,9 +513,9 @@ whether it is valid to call C. /* Flags for hv_iternext_flags. */ #define HV_ITERNEXT_WANTPLACEHOLDERS 0x01 /* Don't skip placeholders. */ -#define Perl_hv_iternext(mTHX, hv) Perl_hv_iternext_flags(aTHX_ hv, 0) -#define Perl_hv_magic(mTHX, hv, gv, how) Perl_sv_magic(aTHX_ MUTABLE_SV(hv), MUTABLE_SV(gv), how, NULL, 0) -#define Perl_hv_undef(mTHX, hv) Perl_hv_undef_flags(aTHX_ hv, 0) +#define hv_iternext(hv) hv_iternext_flags(hv, 0) +#define hv_magic(hv, gv, how) sv_magic(MUTABLE_SV(hv), MUTABLE_SV(gv), how, NULL, 0) +#define hv_undef(hv) Perl_hv_undef_flags(aTHX_ hv, 0) #define Perl_sharepvn(pv, len, hash) HEK_KEY(share_hek(pv, len, hash)) #define sharepvn(pv, len, hash) Perl_sharepvn(pv, len, hash) @@ -527,41 +527,41 @@ whether it is valid to call C. ->shared_he_he.he_valu.hent_refcount), \ hek) -#define Perl_hv_store_ent(mTHX, hv, keysv, val, hash) \ - ((HE *) Perl_hv_common(aTHX_ (hv), (keysv), NULL, 0, 0, HV_FETCH_ISSTORE, \ +#define hv_store_ent(hv, keysv, val, hash) \ + ((HE *) hv_common((hv), (keysv), NULL, 0, 0, HV_FETCH_ISSTORE, \ (val), (hash))) -#define Perl_hv_exists_ent(mTHX, hv, keysv, hash) \ - cBOOL(Perl_hv_common(aTHX_ (hv), (keysv), NULL, 0, 0, HV_FETCH_ISEXISTS, 0, (hash))) -#define Perl_hv_fetch_ent(mTHX, hv, keysv, lval, hash) \ - ((HE *) Perl_hv_common(aTHX_ (hv), (keysv), NULL, 0, 0, \ +#define hv_exists_ent(hv, keysv, hash) \ + cBOOL(hv_common((hv), (keysv), NULL, 0, 0, HV_FETCH_ISEXISTS, 0, (hash))) +#define hv_fetch_ent(hv, keysv, lval, hash) \ + ((HE *) hv_common((hv), (keysv), NULL, 0, 0, \ ((lval) ? HV_FETCH_LVALUE : 0), NULL, (hash))) -#define Perl_hv_delete_ent(mTHX, hv, key, flags, hash) \ - (MUTABLE_SV(Perl_hv_common(aTHX_ (hv), (key), NULL, 0, 0, (flags) | HV_DELETE, \ +#define hv_delete_ent(hv, key, flags, hash) \ + (MUTABLE_SV(hv_common((hv), (key), NULL, 0, 0, (flags) | HV_DELETE, \ NULL, (hash)))) -#define Perl_hv_store_flags(mTHX, hv, key, klen, val, hash, flags) \ - ((SV**) Perl_hv_common(aTHX_ (hv), NULL, (key), (klen), (flags), \ +#define hv_store_flags(hv, key, klen, val, hash, flags) \ + ((SV**) hv_common((hv), NULL, (key), (klen), (flags), \ (HV_FETCH_ISSTORE|HV_FETCH_JUST_SV), (val), \ (hash))) -#define Perl_hv_store(mTHX, hv, key, klen, val, hash) \ - ((SV**) Perl_hv_common_key_len(aTHX_ (hv), (key), (klen), \ +#define hv_store(hv, key, klen, val, hash) \ + ((SV**) hv_common_key_len((hv), (key), (klen), \ (HV_FETCH_ISSTORE|HV_FETCH_JUST_SV), \ (val), (hash))) -#define Perl_hv_exists(mTHX, hv, key, klen) \ - cBOOL(Perl_hv_common_key_len(aTHX_ (hv), (key), (klen), HV_FETCH_ISEXISTS, NULL, 0)) +#define hv_exists(hv, key, klen) \ + cBOOL(hv_common_key_len((hv), (key), (klen), HV_FETCH_ISEXISTS, NULL, 0)) -#define Perl_hv_fetch(mTHX, hv, key, klen, lval) \ - ((SV**) Perl_hv_common_key_len(aTHX_ (hv), (key), (klen), (lval) \ +#define hv_fetch(hv, key, klen, lval) \ + ((SV**) hv_common_key_len((hv), (key), (klen), (lval) \ ? (HV_FETCH_JUST_SV | HV_FETCH_LVALUE) \ : HV_FETCH_JUST_SV, NULL, 0)) -#define Perl_hv_delete(mTHX, hv, key, klen, flags) \ - (MUTABLE_SV(Perl_hv_common_key_len(aTHX_ (hv), (key), (klen), \ +#define hv_delete(hv, key, klen, flags) \ + (MUTABLE_SV(hv_common_key_len((hv), (key), (klen), \ (flags) | HV_DELETE, NULL, 0))) /* Provide 's' suffix subs for constant strings (and avoid needing to count @@ -590,8 +590,8 @@ whether it is valid to call C. #define hv_name_sets(hv, name, flags) \ hv_name_set((hv),ASSERT_IS_LITERAL(name),(sizeof(name)-1), flags) -#define Perl_hv_stores(mTHX, hv, key, val) \ - Perl_hv_store(aTHX, (hv), ASSERT_IS_LITERAL(key), (sizeof(key)-1), (val), 0) +#define hv_stores(hv, key, val) \ + hv_store((hv), ASSERT_IS_LITERAL(key), (sizeof(key)-1), (val), 0) #ifdef PERL_CORE # define hv_storehek(hv, hek, val) \ @@ -731,7 +731,7 @@ Creates a new HV. The reference count is set to 1. =cut */ -#define Perl_newHV(mTHX) MUTABLE_HV(Perl_newSV_type(aTHX_ SVt_PVHV)) +#define newHV() MUTABLE_HV(newSV_type(SVt_PVHV)) #include "hv_func.h" diff --git a/inline.h b/inline.h index ac5fdc0b1ec3..44128c624d07 100644 --- a/inline.h +++ b/inline.h @@ -3272,6 +3272,24 @@ Perl_utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen) return 0; } +PERL_STATIC_INLINE U8 * +Perl_uv_to_utf8(pTHX_ U8 *d, UV uv) +{ + return uv_to_utf8_msgs(d, uv, 0, 0); +} + +PERL_STATIC_INLINE U8 * +Perl_uv_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags) +{ + return uv_to_utf8_msgs(d, uv, flags, 0); +} + +PERL_STATIC_INLINE U8 * +Perl_uv_to_utf8_msgs(pTHX_ U8 *d, UV uv, UV flags , HV **msgs) +{ + return uvoffuni_to_utf8_flags_msgs(d, NATIVE_TO_UNI(uv), flags, msgs); +} + /* ------------------------------- perl.h ----------------------------- */ /* diff --git a/mathoms.c b/mathoms.c index 72771459ee47..fc7db080934e 100644 --- a/mathoms.c +++ b/mathoms.c @@ -73,6 +73,293 @@ * without a compiler warning */ GCC_DIAG_IGNORE(-Wdeprecated-declarations) +/* ref() is now a macro using Perl_doref; + * this version provided for binary compatibility only. + */ +OP * +Perl_ref(pTHX_ OP *o, I32 type) +{ + return doref(o, type, TRUE); +} + +void +Perl_sv_unref(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_SV_UNREF; + + sv_unref_flags(sv, 0); +} + +/* +=for apidoc_section $tainting +=for apidoc sv_taint + +Taint an SV. Use C instead. + +=cut +*/ + +void +Perl_sv_taint(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_SV_TAINT; + + sv_magic((sv), NULL, PERL_MAGIC_taint, NULL, 0); +} + +/* sv_2iv() is now a macro using Perl_sv_2iv_flags(); + * this function provided for binary compatibility only + */ + +IV +Perl_sv_2iv(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_SV_2IV; + + return sv_2iv_flags(sv, SV_GMAGIC); +} + +/* sv_2uv() is now a macro using Perl_sv_2uv_flags(); + * this function provided for binary compatibility only + */ + +UV +Perl_sv_2uv(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_SV_2UV; + + return sv_2uv_flags(sv, SV_GMAGIC); +} + +/* sv_2nv() is now a macro using Perl_sv_2nv_flags(); + * this function provided for binary compatibility only + */ + +NV +Perl_sv_2nv(pTHX_ SV *sv) +{ + return sv_2nv_flags(sv, SV_GMAGIC); +} + + +/* sv_2pv() is now a macro using Perl_sv_2pv_flags(); + * this function provided for binary compatibility only + */ + +char * +Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp) +{ + PERL_ARGS_ASSERT_SV_2PV; + + return sv_2pv_flags(sv, lp, SV_GMAGIC); +} + +/* +=for apidoc_section $SV +=for apidoc sv_2pv_nolen + +Like C, but doesn't return the length too. You should usually +use the macro wrapper C instead. + +=cut +*/ + +char * +Perl_sv_2pv_nolen(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_SV_2PV_NOLEN; + return sv_2pv(sv, NULL); +} + +/* +=for apidoc_section $SV +=for apidoc sv_2pvbyte_nolen + +Return a pointer to the byte-encoded representation of the SV. +May cause the SV to be downgraded from UTF-8 as a side-effect. + +Usually accessed via the C macro. + +=cut +*/ + +char * +Perl_sv_2pvbyte_nolen(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_SV_2PVBYTE_NOLEN; + + return sv_2pvbyte(sv, NULL); +} + +/* +=for apidoc_section $SV +=for apidoc sv_2pvutf8_nolen + +Return a pointer to the UTF-8-encoded representation of the SV. +May cause the SV to be upgraded to UTF-8 as a side-effect. + +Usually accessed via the C macro. + +=cut +*/ + +char * +Perl_sv_2pvutf8_nolen(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_SV_2PVUTF8_NOLEN; + + return sv_2pvutf8(sv, NULL); +} + +void +Perl_sv_force_normal(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_SV_FORCE_NORMAL; + + sv_force_normal_flags(sv, 0); +} + +/* sv_setsv() is now a macro using Perl_sv_setsv_flags(); + * this function provided for binary compatibility only + */ + +void +Perl_sv_setsv(pTHX_ SV *dsv, SV *ssv) +{ + PERL_ARGS_ASSERT_SV_SETSV; + + sv_setsv_flags(dsv, ssv, SV_GMAGIC); +} + +/* sv_catpvn() is now a macro using Perl_sv_catpvn_flags(); + * this function provided for binary compatibility only + */ + +void +Perl_sv_catpvn(pTHX_ SV *dsv, const char* sstr, STRLEN slen) +{ + PERL_ARGS_ASSERT_SV_CATPVN; + + sv_catpvn_flags(dsv, sstr, slen, SV_GMAGIC); +} + +void +Perl_sv_catpvn_mg(pTHX_ SV *dsv, const char *sstr, STRLEN len) +{ + PERL_ARGS_ASSERT_SV_CATPVN_MG; + + sv_catpvn_flags(dsv,sstr,len,SV_GMAGIC|SV_SMAGIC); +} + +/* sv_catsv() is now a macro using Perl_sv_catsv_flags(); + * this function provided for binary compatibility only + */ + +void +Perl_sv_catsv(pTHX_ SV *dsv, SV * const sstr) +{ + PERL_ARGS_ASSERT_SV_CATSV; + + sv_catsv_flags(dsv, sstr, SV_GMAGIC); +} + +void +Perl_sv_catsv_mg(pTHX_ SV *dsv, SV * const sstr) +{ + PERL_ARGS_ASSERT_SV_CATSV_MG; + + sv_catsv_flags(dsv,sstr,SV_GMAGIC|SV_SMAGIC); +} + +/* +=for apidoc_section $SV +=for apidoc sv_pv + +Use the C macro instead + +=cut +*/ + +/* sv_pv() is now a macro using SvPV_nolen(); + * this function provided for binary compatibility only + */ + +char * +Perl_sv_pv(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_SV_PV; + + if (SvPOK(sv)) + return SvPVX(sv); + + return sv_2pv(sv, NULL); +} + +/* sv_pvn_force() is now a macro using Perl_sv_pvn_force_flags(); + * this function provided for binary compatibility only + */ + +char * +Perl_sv_pvn_force(pTHX_ SV *sv, STRLEN *lp) +{ + PERL_ARGS_ASSERT_SV_PVN_FORCE; + + return sv_pvn_force_flags(sv, lp, SV_GMAGIC); +} + +/* sv_pvbyte () is now a macro using Perl_sv_2pv_flags(); + * this function provided for binary compatibility only + */ + +char * +Perl_sv_pvbyte(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_SV_PVBYTE; + + (void)sv_utf8_downgrade(sv, FALSE); + return sv_pv(sv); +} + +/* +=for apidoc_section $SV +=for apidoc sv_pvbyte + +Use C instead. + +=cut +*/ + +/* +=for apidoc_section $SV +=for apidoc sv_pvutf8 + +Use the C macro instead + +=cut +*/ + + +char * +Perl_sv_pvutf8(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_SV_PVUTF8; + + sv_utf8_upgrade(sv); + return sv_pv(sv); +} + +/* sv_utf8_upgrade() is now a macro using sv_utf8_upgrade_flags(); + * this function provided for binary compatibility only + */ + +STRLEN +Perl_sv_utf8_upgrade(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_SV_UTF8_UPGRADE; + + return sv_utf8_upgrade_flags(sv, SV_GMAGIC); +} + #if defined(HUGE_VAL) || (defined(USE_LONG_DOUBLE) && defined(HUGE_VALL)) /* * This hack is to force load of "huge" support from libm.a @@ -90,6 +377,66 @@ Perl_huge(void) } #endif +void +Perl_gv_fullname3(pTHX_ SV *sv, const GV *gv, const char *prefix) +{ + PERL_ARGS_ASSERT_GV_FULLNAME3; + + gv_fullname4(sv, gv, prefix, TRUE); +} + +void +Perl_gv_efullname3(pTHX_ SV *sv, const GV *gv, const char *prefix) +{ + PERL_ARGS_ASSERT_GV_EFULLNAME3; + + gv_efullname4(sv, gv, prefix, TRUE); +} + +GV * +Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name) +{ + PERL_ARGS_ASSERT_GV_FETCHMETHOD; + + return gv_fetchmethod_autoload(stash, name, TRUE); +} + +HE * +Perl_hv_iternext(pTHX_ HV *hv) +{ + PERL_ARGS_ASSERT_HV_ITERNEXT; + + return hv_iternext_flags(hv, 0); +} + +void +Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how) +{ + PERL_ARGS_ASSERT_HV_MAGIC; + + sv_magic(MUTABLE_SV(hv), MUTABLE_SV(gv), how, NULL, 0); +} + +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_openn(gv, name, len, as_raw, rawmode, rawperm, + supplied_fp, (SV **) NULL, 0); +} + +#ifndef OS2 +bool +Perl_do_aexec(pTHX_ SV *really, SV **mark, SV **sp) +{ + PERL_ARGS_ASSERT_DO_AEXEC; + + return do_aexec5(really, mark, sp, 0, 0); +} +#endif + /* =for apidoc_section $SV =for apidoc sv_nolocking @@ -135,6 +482,292 @@ Perl_sv_nounlocking(pTHX_ SV *sv) PERL_UNUSED_ARG(sv); } +void +Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len) +{ + PERL_ARGS_ASSERT_SV_USEPVN_MG; + + sv_usepvn_flags(sv,ptr,len, SV_SMAGIC); +} + + +void +Perl_sv_usepvn(pTHX_ SV *sv, char *ptr, STRLEN len) +{ + PERL_ARGS_ASSERT_SV_USEPVN; + + sv_usepvn_flags(sv,ptr,len, 0); +} + +HE * +Perl_hv_store_ent(pTHX_ HV *hv, SV *keysv, SV *val, U32 hash) +{ + return (HE *)hv_common(hv, keysv, NULL, 0, 0, HV_FETCH_ISSTORE, val, hash); +} + +bool +Perl_hv_exists_ent(pTHX_ HV *hv, SV *keysv, U32 hash) +{ + PERL_ARGS_ASSERT_HV_EXISTS_ENT; + + return cBOOL(hv_common(hv, keysv, NULL, 0, 0, HV_FETCH_ISEXISTS, 0, hash)); +} + +HE * +Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, U32 hash) +{ + PERL_ARGS_ASSERT_HV_FETCH_ENT; + + return (HE *)hv_common(hv, keysv, NULL, 0, 0, + (lval ? HV_FETCH_LVALUE : 0), NULL, hash); +} + +SV * +Perl_hv_delete_ent(pTHX_ HV *hv, SV *keysv, I32 flags, U32 hash) +{ + PERL_ARGS_ASSERT_HV_DELETE_ENT; + + return MUTABLE_SV(hv_common(hv, keysv, NULL, 0, 0, flags | HV_DELETE, NULL, + hash)); +} + +SV** +Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash, + int flags) +{ + return (SV**) hv_common(hv, NULL, key, klen, flags, + (HV_FETCH_ISSTORE|HV_FETCH_JUST_SV), val, hash); +} + +SV** +Perl_hv_store(pTHX_ HV *hv, const char *key, I32 klen_i32, SV *val, U32 hash) +{ + STRLEN klen; + int flags; + + if (klen_i32 < 0) { + klen = -klen_i32; + flags = HVhek_UTF8; + } else { + klen = klen_i32; + flags = 0; + } + return (SV **) hv_common(hv, NULL, key, klen, flags, + (HV_FETCH_ISSTORE|HV_FETCH_JUST_SV), val, hash); +} + +bool +Perl_hv_exists(pTHX_ HV *hv, const char *key, I32 klen_i32) +{ + STRLEN klen; + int flags; + + PERL_ARGS_ASSERT_HV_EXISTS; + + if (klen_i32 < 0) { + klen = -klen_i32; + flags = HVhek_UTF8; + } else { + klen = klen_i32; + flags = 0; + } + return cBOOL(hv_common(hv, NULL, key, klen, flags, HV_FETCH_ISEXISTS, 0, 0)); +} + +SV** +Perl_hv_fetch(pTHX_ HV *hv, const char *key, I32 klen_i32, I32 lval) +{ + STRLEN klen; + int flags; + + PERL_ARGS_ASSERT_HV_FETCH; + + if (klen_i32 < 0) { + klen = -klen_i32; + flags = HVhek_UTF8; + } else { + klen = klen_i32; + flags = 0; + } + return (SV **) hv_common(hv, NULL, key, klen, flags, + lval ? (HV_FETCH_JUST_SV | HV_FETCH_LVALUE) + : HV_FETCH_JUST_SV, NULL, 0); +} + +SV * +Perl_hv_delete(pTHX_ HV *hv, const char *key, I32 klen_i32, I32 flags) +{ + STRLEN klen; + int k_flags; + + PERL_ARGS_ASSERT_HV_DELETE; + + if (klen_i32 < 0) { + klen = -klen_i32; + k_flags = HVhek_UTF8; + } else { + klen = klen_i32; + k_flags = 0; + } + return MUTABLE_SV(hv_common(hv, NULL, key, klen, k_flags, flags | HV_DELETE, + NULL, 0)); +} + +AV * +Perl_newAV(pTHX) +{ + return MUTABLE_AV(newSV_type(SVt_PVAV)); + /* sv_upgrade does AvREAL_only(): + AvALLOC(av) = 0; + AvARRAY(av) = NULL; + AvMAX(av) = AvFILLp(av) = -1; */ +} + +HV * +Perl_newHV(pTHX) +{ + HV * const hv = MUTABLE_HV(newSV_type(SVt_PVHV)); + assert(!SvOK(hv)); + + return hv; +} + +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_flags(bigstr, offset, len, little, littlelen, SV_GMAGIC); +} + +void +Perl_save_freesv(pTHX_ SV *sv) +{ + save_freesv(sv); +} + +void +Perl_save_mortalizesv(pTHX_ SV *sv) +{ + PERL_ARGS_ASSERT_SAVE_MORTALIZESV; + + save_mortalizesv(sv); +} + +void +Perl_save_freeop(pTHX_ OP *o) +{ + save_freeop(o); +} + +void +Perl_save_freepv(pTHX_ char *pv) +{ + save_freepv(pv); +} + +void +Perl_save_op(pTHX) +{ + save_op(); +} + +#ifdef PERL_DONT_CREATE_GVSV +GV * +Perl_gv_SVadd(pTHX_ GV *gv) +{ + return gv_SVadd(gv); +} +#endif + +GV * +Perl_gv_AVadd(pTHX_ GV *gv) +{ + return gv_AVadd(gv); +} + +GV * +Perl_gv_HVadd(pTHX_ GV *gv) +{ + return gv_HVadd(gv); +} + +GV * +Perl_gv_IOadd(pTHX_ GV *gv) +{ + return gv_IOadd(gv); +} + +IO * +Perl_newIO(pTHX) +{ + return MUTABLE_IO(newSV_type(SVt_PVIO)); +} + +I32 +Perl_my_stat(pTHX) +{ + return my_stat_flags(SV_GMAGIC); +} + +I32 +Perl_my_lstat(pTHX) +{ + return my_lstat_flags(SV_GMAGIC); +} + +I32 +Perl_sv_eq(pTHX_ SV *sv1, SV *sv2) +{ + return sv_eq_flags(sv1, sv2, SV_GMAGIC); +} + +#ifdef USE_LOCALE_COLLATE +char * +Perl_sv_collxfrm(pTHX_ SV *const sv, STRLEN *const nxp) +{ + PERL_ARGS_ASSERT_SV_COLLXFRM; + return sv_collxfrm_flags(sv, nxp, SV_GMAGIC); +} + +#endif + +bool +Perl_sv_2bool(pTHX_ SV *const sv) +{ + PERL_ARGS_ASSERT_SV_2BOOL; + return sv_2bool_flags(sv, SV_GMAGIC); +} + +CV * +Perl_newSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *block) +{ + return newATTRSUB(floor, o, proto, NULL, block); +} + +SV * +Perl_sv_mortalcopy(pTHX_ SV *const oldsv) +{ + return Perl_sv_mortalcopy_flags(aTHX_ oldsv, SV_GMAGIC); +} + +void +Perl_sv_copypv(pTHX_ SV *const dsv, SV *const ssv) +{ + PERL_ARGS_ASSERT_SV_COPYPV; + + sv_copypv_flags(dsv, ssv, SV_GMAGIC); +} + +STRLEN +Perl_is_utf8_char_buf(const U8 *buf, const U8* buf_end) +{ + + PERL_ARGS_ASSERT_IS_UTF8_CHAR_BUF; + + return isUTF8_CHAR(buf, buf_end); +} + /* =for apidoc_section $unicode =for apidoc utf8_to_uvuni @@ -169,6 +802,36 @@ Perl_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen) return NATIVE_TO_UNI(valid_utf8_to_uvchr(s, retlen)); } +SV * +Perl_newSVsv(pTHX_ SV *const old) +{ + return newSVsv(old); +} + +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); +} + +char * +Perl_sv_2pvutf8(pTHX_ SV *sv, STRLEN *const lp) +{ + PERL_ARGS_ASSERT_SV_2PVUTF8; + + return sv_2pvutf8(sv, lp); +} + +char * +Perl_sv_2pvbyte(pTHX_ SV *sv, STRLEN *const lp) +{ + PERL_ARGS_ASSERT_SV_2PVBYTE; + + return sv_2pvbyte(sv, lp); +} + U8 * Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv) { diff --git a/op.h b/op.h index af89b4acfbe8..a31bae5f51ed 100644 --- a/op.h +++ b/op.h @@ -670,7 +670,7 @@ typedef enum { list of SVs */ #if defined(PERL_IN_PERLY_C) || defined(PERL_IN_OP_C) || defined(PERL_IN_TOKE_C) -#define Perl_ref(mTHX, o, type) Perl_doref(aTHX_ o, type, TRUE) +#define ref(o, type) doref(o, type, TRUE) #endif @@ -1108,10 +1108,8 @@ C is non-null. For a higher-level interface, see C>. # define OP_SIBLING(o) OpSIBLING(o) #endif -#define Perl_newATTRSUB(mTHX, f, o, p, a, b) \ - Perl_newATTRSUB_x(aTHX_ f, o, p, a, b, FALSE) -#define Perl_newSUB(mTHX, f, o, p, b) \ - Perl_newATTRSUB(aTHX, (f), (o), (p), NULL, (b)) +#define newATTRSUB(f, o, p, a, b) Perl_newATTRSUB_x(aTHX_ f, o, p, a, b, FALSE) +#define newSUB(f, o, p, b) newATTRSUB((f), (o), (p), NULL, (b)) #ifdef USE_ITHREADS # define OP_CHECK_MUTEX_INIT MUTEX_INIT(&PL_check_mutex) diff --git a/perl.h b/perl.h index 935954d179bb..5aaeea0cc223 100644 --- a/perl.h +++ b/perl.h @@ -4524,8 +4524,8 @@ struct Perl_OpDumpContext; #include "utf8.h" /* these would be in doio.h if there was such a file */ -#define Perl_my_stat(mTHX_) Perl_my_stat_flags(aTHX_ SV_GMAGIC) -#define Perl_my_lstat(mTHX) Perl_my_lstat_flags(aTHX_ SV_GMAGIC) +#define my_stat() my_stat_flags(SV_GMAGIC) +#define my_lstat() my_lstat_flags(SV_GMAGIC) /* defined in sv.c, but also used in [ach]v.c */ #undef _XPV_HEAD @@ -8397,16 +8397,15 @@ so no C. #pragma message disable (mainparm) /* Perl uses the envp in main(). */ #endif -#define Perl_do_open(mTHX, g, n, l, a, rm, rp, sf) \ - Perl_do_openn(aTHX_ g, n, l, a, rm, rp, sf, (SV **) NULL, 0) +#define do_open(g, n, l, a, rm, rp, sf) \ + do_openn(g, n, l, a, rm, rp, sf, (SV **) NULL, 0) #ifdef PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION # define do_exec(cmd) do_exec3(cmd,0,0) #endif #ifdef OS2 -# define Perl_do_aexec Perl_do_aexec +# define do_aexec Perl_do_aexec #else -# define Perl_do_aexec(mTHX_, really, mark,sp) \ - Perl_do_aexec5(aTHX_ really, mark, sp, 0, 0) +# define do_aexec(really, mark,sp) do_aexec5(really, mark, sp, 0, 0) #endif diff --git a/proto.h b/proto.h index 6ded4aeb247f..cd98a32f285b 100644 --- a/proto.h +++ b/proto.h @@ -844,9 +844,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"); @@ -906,9 +903,6 @@ Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, const OP *o); #define PERL_ARGS_ASSERT_DO_OP_DUMP \ assert(file) -/* PERL_CALLCONV bool -Perl_do_open(pTHX_ GV *gv, const char *name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp); */ - PERL_CALLCONV bool Perl_do_open6(pTHX_ GV *gv, const char *oname, STRLEN len, PerlIO *supplied_fp, SV **svp, U32 num) __attribute__visibility__("hidden"); @@ -1368,15 +1362,6 @@ Perl_grok_oct(pTHX_ const char *start, STRLEN *len_p, I32 *flags, NV *result); #define PERL_ARGS_ASSERT_GROK_OCT \ assert(start); assert(len_p); assert(flags) -/* PERL_CALLCONV GV * -Perl_gv_AVadd(pTHX_ GV *gv); */ - -/* PERL_CALLCONV GV * -Perl_gv_HVadd(pTHX_ GV *gv); */ - -/* PERL_CALLCONV GV * -Perl_gv_IOadd(pTHX_ GV *gv); */ - PERL_CALLCONV GV * Perl_gv_add_by_type(pTHX_ GV *gv, svtype type); #define PERL_ARGS_ASSERT_GV_ADD_BY_TYPE @@ -1414,9 +1399,6 @@ PERL_CALLCONV void Perl_gv_dump(pTHX_ GV *gv); #define PERL_ARGS_ASSERT_GV_DUMP -/* PERL_CALLCONV void -Perl_gv_efullname3(pTHX_ SV *sv, const GV *gv, const char *prefix); */ - PERL_CALLCONV void Perl_gv_efullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain); #define PERL_ARGS_ASSERT_GV_EFULLNAME4 \ @@ -1468,9 +1450,6 @@ Perl_gv_fetchmeth_sv_autoload(pTHX_ HV *stash, SV *namesv, I32 level, U32 flags) #define PERL_ARGS_ASSERT_GV_FETCHMETH_SV_AUTOLOAD \ assert(namesv) -/* PERL_CALLCONV GV * -Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name); */ - PERL_CALLCONV GV * Perl_gv_fetchmethod_autoload(pTHX_ HV *stash, const char *name, I32 autoload); #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_AUTOLOAD \ @@ -1506,9 +1485,6 @@ Perl_gv_fetchsv(pTHX_ SV *name, I32 flags, const svtype sv_type); #define PERL_ARGS_ASSERT_GV_FETCHSV \ assert(name) -/* PERL_CALLCONV void -Perl_gv_fullname3(pTHX_ SV *sv, const GV *gv, const char *prefix); */ - PERL_CALLCONV void Perl_gv_fullname4(pTHX_ SV *sv, const GV *gv, const char *prefix, bool keepmain); #define PERL_ARGS_ASSERT_GV_FULLNAME4 \ @@ -1618,12 +1594,6 @@ PERL_CALLCONV void Perl_hv_delayfree_ent(pTHX_ HV *notused, HE *entry); #define PERL_ARGS_ASSERT_HV_DELAYFREE_ENT -/* PERL_CALLCONV SV * -Perl_hv_delete(pTHX_ HV *hv, const char *key, I32 klen, I32 flags); */ - -/* PERL_CALLCONV SV * -Perl_hv_delete_ent(pTHX_ HV *hv, SV *keysv, I32 flags, U32 hash); */ - PERL_CALLCONV void Perl_hv_dump(pTHX_ HV *hv); #define PERL_ARGS_ASSERT_HV_DUMP @@ -1651,20 +1621,6 @@ Perl_hv_ename_delete(pTHX_ HV *hv, const char *name, U32 len, U32 flags) #define PERL_ARGS_ASSERT_HV_ENAME_DELETE \ assert(hv); assert(name); assert(SvTYPE(hv) == SVt_PVHV) -/* PERL_CALLCONV bool -Perl_hv_exists(pTHX_ HV *hv, const char *key, I32 klen) - __attribute__warn_unused_result__; */ - -/* PERL_CALLCONV bool -Perl_hv_exists_ent(pTHX_ HV *hv, SV *keysv, U32 hash) - __attribute__warn_unused_result__; */ - -/* PERL_CALLCONV SV ** -Perl_hv_fetch(pTHX_ HV *hv, const char *key, I32 klen, I32 lval); */ - -/* PERL_CALLCONV HE * -Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, U32 hash); */ - PERL_CALLCONV STRLEN Perl_hv_fill(pTHX_ HV * const hv); #define PERL_ARGS_ASSERT_HV_FILL \ @@ -1691,9 +1647,6 @@ Perl_hv_iterkeysv(pTHX_ HE *entry) #define PERL_ARGS_ASSERT_HV_ITERKEYSV \ assert(entry) -/* PERL_CALLCONV HE * -Perl_hv_iternext(pTHX_ HV *hv); */ - PERL_CALLCONV HE * Perl_hv_iternext_flags(pTHX_ HV *hv, I32 flags) __attribute__warn_unused_result__; @@ -1717,9 +1670,6 @@ Perl_hv_ksplit(pTHX_ HV *hv, IV newmax); #define PERL_ARGS_ASSERT_HV_KSPLIT \ assert(hv); assert(SvTYPE(hv) == SVt_PVHV) -/* PERL_CALLCONV void -Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how); */ - PERL_CALLCONV void Perl_hv_name_set(pTHX_ HV *hv, const char *name, U32 len, U32 flags); #define PERL_ARGS_ASSERT_HV_NAME_SET \ @@ -1771,19 +1721,10 @@ Perl_hv_scalar(pTHX_ HV *hv) assert(hv); assert(SvTYPE(hv) == SVt_PVHV) /* PERL_CALLCONV SV ** -Perl_hv_store(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash); */ - -/* PERL_CALLCONV HE * -Perl_hv_store_ent(pTHX_ HV *hv, SV *key, SV *val, U32 hash); */ - -/* PERL_CALLCONV SV ** -Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash, int flags); */ - -/* PERL_CALLCONV SV ** -Perl_hv_stores(pTHX_ HV *hv, const char * const key, SV *val); */ +hv_stores(pTHX_ HV *hv, const char * const key, SV *val); */ /* PERL_CALLCONV void -Perl_hv_undef(pTHX_ HV *hv); */ +hv_undef(pTHX_ HV *hv); */ PERL_CALLCONV void Perl_hv_undef_flags(pTHX_ HV *hv, U32 flags); @@ -1909,9 +1850,6 @@ Perl_is_utf8_FF_helper_(const U8 * const s0, const U8 * const e, const bool requ #define PERL_ARGS_ASSERT_IS_UTF8_FF_HELPER_ \ assert(s0); assert(e) -/* PERL_CALLCONV STRLEN -Perl_is_utf8_char_buf(const U8 *buf, const U8 *buf_end); */ - PERL_CALLCONV STRLEN Perl_is_utf8_char_helper_(const U8 * const s, const U8 *e, const U32 flags) __attribute__warn_unused_result__ @@ -2683,7 +2621,7 @@ Perl_my_fork(void); #define PERL_ARGS_ASSERT_MY_FORK /* PERL_CALLCONV I32 -Perl_my_lstat(pTHX); */ +my_lstat(pTHX); */ PERL_CALLCONV I32 Perl_my_lstat_flags(pTHX_ const U32 flags); @@ -2723,7 +2661,7 @@ 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); */ +my_stat(pTHX); */ PERL_CALLCONV I32 Perl_my_stat_flags(pTHX_ const U32 flags); @@ -2787,16 +2725,12 @@ Perl_newASSIGNOP(pTHX_ I32 flags, OP *left, I32 optype, OP *right) #define PERL_ARGS_ASSERT_NEWASSIGNOP /* PERL_CALLCONV CV * -Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block); */ +newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block); */ PERL_CALLCONV CV * Perl_newATTRSUB_x(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block, bool o_is_gv); #define PERL_ARGS_ASSERT_NEWATTRSUB_X -/* PERL_CALLCONV AV * -Perl_newAV(pTHX) - __attribute__warn_unused_result__; */ - PERL_CALLCONV OP * Perl_newAVREF(pTHX_ OP *o) __attribute__warn_unused_result__; @@ -2901,10 +2835,6 @@ Perl_newGVgen_flags(pTHX_ const char *pack, U32 flags) #define PERL_ARGS_ASSERT_NEWGVGEN_FLAGS \ assert(pack) -/* PERL_CALLCONV HV * -Perl_newHV(pTHX) - __attribute__warn_unused_result__; */ - PERL_CALLCONV OP * Perl_newHVREF(pTHX_ OP *o) __attribute__warn_unused_result__; @@ -2916,10 +2846,6 @@ Perl_newHVhv(pTHX_ HV *hv) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEWHVHV -/* PERL_CALLCONV IO * -Perl_newIO(pTHX) - __attribute__warn_unused_result__; */ - PERL_CALLCONV OP * Perl_newLISTOP(pTHX_ I32 type, I32 flags, OP *first, OP *last) __attribute__warn_unused_result__; @@ -3035,9 +2961,6 @@ Perl_newSTUB(pTHX_ GV *gv, bool fake) #define PERL_ARGS_ASSERT_NEWSTUB \ assert(gv) -/* PERL_CALLCONV CV * -Perl_newSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *block); */ - PERL_CALLCONV SV * Perl_newSV(pTHX_ const STRLEN len) __attribute__warn_unused_result__; @@ -3139,10 +3062,6 @@ Perl_newSVrv(pTHX_ SV * const rv, const char * const classname); #define PERL_ARGS_ASSERT_NEWSVRV \ assert(rv) -/* PERL_CALLCONV SV * -Perl_newSVsv(pTHX_ SV * const old) - __attribute__warn_unused_result__; */ - PERL_CALLCONV SV * Perl_newSVsv_flags(pTHX_ SV * const old, I32 flags) __attribute__warn_unused_result__; @@ -4080,20 +3999,11 @@ PERL_CALLCONV void Perl_save_destructor_x(pTHX_ DESTRUCTORFUNC_t f, void *p); #define PERL_ARGS_ASSERT_SAVE_DESTRUCTOR_X -/* PERL_CALLCONV void -Perl_save_freeop(pTHX_ OP *o); */ - -/* PERL_CALLCONV void -Perl_save_freepv(pTHX_ char *pv); */ - PERL_CALLCONV void Perl_save_freercpv(pTHX_ char *rcpv); #define PERL_ARGS_ASSERT_SAVE_FREERCPV \ assert(rcpv) -/* PERL_CALLCONV void -Perl_save_freesv(pTHX_ SV *sv); */ - PERL_CALLCONV void Perl_save_generic_pvref(pTHX_ char **str); #define PERL_ARGS_ASSERT_SAVE_GENERIC_PVREF \ @@ -4151,12 +4061,6 @@ Perl_save_iv(pTHX_ IV *ivp); #define PERL_ARGS_ASSERT_SAVE_IV \ assert(ivp) -/* PERL_CALLCONV void -Perl_save_mortalizesv(pTHX_ SV *sv); */ - -/* PERL_CALLCONV void -Perl_save_op(pTHX); */ - PERL_CALLCONV void Perl_save_padsv_and_mortalize(pTHX_ PADOFFSET off); #define PERL_ARGS_ASSERT_SAVE_PADSV_AND_MORTALIZE @@ -4442,9 +4346,6 @@ Perl_suspend_compcv(pTHX_ struct suspended_compcv *buffer); #define PERL_ARGS_ASSERT_SUSPEND_COMPCV \ assert(buffer) -/* PERL_CALLCONV bool -Perl_sv_2bool(pTHX_ SV * const sv); */ - PERL_CALLCONV bool Perl_sv_2bool_flags(pTHX_ SV *sv, I32 flags); #define PERL_ARGS_ASSERT_SV_2BOOL_FLAGS \ @@ -4460,9 +4361,6 @@ Perl_sv_2io(pTHX_ SV * const sv); #define PERL_ARGS_ASSERT_SV_2IO \ assert(sv) -/* PERL_CALLCONV IV -Perl_sv_2iv(pTHX_ SV * const sv); */ - PERL_CALLCONV IV Perl_sv_2iv_flags(pTHX_ SV * const sv, const I32 flags); #define PERL_ARGS_ASSERT_SV_2IV_FLAGS \ @@ -4478,53 +4376,26 @@ Perl_sv_2num(pTHX_ SV * const sv) #define PERL_ARGS_ASSERT_SV_2NUM \ assert(sv) -/* PERL_CALLCONV NV -Perl_sv_2nv(pTHX_ SV * const sv); */ - PERL_CALLCONV NV Perl_sv_2nv_flags(pTHX_ SV * const sv, const I32 flags); #define PERL_ARGS_ASSERT_SV_2NV_FLAGS \ assert(sv) -/* PERL_CALLCONV char * -Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp); */ - PERL_CALLCONV char * Perl_sv_2pv_flags(pTHX_ SV * const sv, STRLEN * const lp, const U32 flags); #define PERL_ARGS_ASSERT_SV_2PV_FLAGS \ assert(sv) -/* PERL_CALLCONV char * -Perl_sv_2pv_nolen(pTHX_ SV *sv) - __attribute__warn_unused_result__; */ - -/* PERL_CALLCONV char * -Perl_sv_2pvbyte(pTHX_ SV *sv, STRLEN * const lp); */ - PERL_CALLCONV char * Perl_sv_2pvbyte_flags(pTHX_ SV *sv, STRLEN * const lp, const U32 flags); #define PERL_ARGS_ASSERT_SV_2PVBYTE_FLAGS \ assert(sv) -/* PERL_CALLCONV char * -Perl_sv_2pvbyte_nolen(pTHX_ SV *sv) - __attribute__warn_unused_result__; */ - -/* PERL_CALLCONV char * -Perl_sv_2pvutf8(pTHX_ SV *sv, STRLEN * const lp); */ - PERL_CALLCONV char * Perl_sv_2pvutf8_flags(pTHX_ SV *sv, STRLEN * const lp, const U32 flags); #define PERL_ARGS_ASSERT_SV_2PVUTF8_FLAGS \ assert(sv) -/* PERL_CALLCONV char * -Perl_sv_2pvutf8_nolen(pTHX_ SV *sv) - __attribute__warn_unused_result__; */ - -/* PERL_CALLCONV UV -Perl_sv_2uv(pTHX_ SV * const sv); */ - PERL_CALLCONV UV Perl_sv_2uv_flags(pTHX_ SV * const sv, const I32 flags); #define PERL_ARGS_ASSERT_SV_2UV_FLAGS \ @@ -4577,28 +4448,16 @@ Perl_sv_catpvf_mg(pTHX_ SV * const sv, const char * const pat, ...) #define PERL_ARGS_ASSERT_SV_CATPVF_MG \ assert(sv); assert(pat) -/* PERL_CALLCONV void -Perl_sv_catpvn(pTHX_ SV * const dsv, const char *sstr, STRLEN len); */ - PERL_CALLCONV void Perl_sv_catpvn_flags(pTHX_ SV * const dsv, const char *sstr, const STRLEN len, const I32 flags); #define PERL_ARGS_ASSERT_SV_CATPVN_FLAGS \ assert(dsv); assert(sstr) -/* PERL_CALLCONV void -Perl_sv_catpvn_mg(pTHX_ SV * const dsv, const char *sstr, STRLEN len); */ - -/* PERL_CALLCONV void -Perl_sv_catsv(pTHX_ SV * const dsv, SV * const sstr); */ - PERL_CALLCONV void Perl_sv_catsv_flags(pTHX_ SV * const dsv, SV * const sstr, const I32 flags); #define PERL_ARGS_ASSERT_SV_CATSV_FLAGS \ assert(dsv) -/* PERL_CALLCONV void -Perl_sv_catsv_mg(pTHX_ SV * const dsv, SV * const sstr); */ - PERL_CALLCONV void Perl_sv_chop(pTHX_ SV * const sv, const char * const ptr); #define PERL_ARGS_ASSERT_SV_CHOP \ @@ -4635,9 +4494,6 @@ PERL_CALLCONV I32 Perl_sv_cmp_locale_flags(pTHX_ SV * const sv1, SV * const sv2, const U32 flags); #define PERL_ARGS_ASSERT_SV_CMP_LOCALE_FLAGS -/* PERL_CALLCONV void -Perl_sv_copypv(pTHX_ SV * const dsv, SV * const ssv); */ - PERL_CALLCONV void Perl_sv_copypv_flags(pTHX_ SV * const dsv, SV * const ssv, const I32 flags); #define PERL_ARGS_ASSERT_SV_COPYPV_FLAGS \ @@ -4725,16 +4581,10 @@ PERL_CALLCONV void Perl_sv_dump_depth(pTHX_ SV *sv, I32 depth); #define PERL_ARGS_ASSERT_SV_DUMP_DEPTH -/* PERL_CALLCONV I32 -Perl_sv_eq(pTHX_ SV *sv1, SV *sv2); */ - PERL_CALLCONV I32 Perl_sv_eq_flags(pTHX_ SV *sv1, SV *sv2, const U32 flags); #define PERL_ARGS_ASSERT_SV_EQ_FLAGS -/* PERL_CALLCONV void -Perl_sv_force_normal(pTHX_ SV *sv); */ - PERL_CALLCONV void Perl_sv_force_normal_flags(pTHX_ SV * const sv, const U32 flags); #define PERL_ARGS_ASSERT_SV_FORCE_NORMAL_FLAGS \ @@ -4782,9 +4632,6 @@ PERL_CALLCONV void Perl_sv_inc_nomg(pTHX_ SV * const sv); #define PERL_ARGS_ASSERT_SV_INC_NOMG -/* PERL_CALLCONV void -Perl_sv_insert(pTHX_ SV * const bigstr, const STRLEN offset, const STRLEN len, const char * const little, const STRLEN littlelen); */ - PERL_CALLCONV void Perl_sv_insert_flags(pTHX_ SV * const bigstr, const STRLEN offset, const STRLEN len, const char *little, const STRLEN littlelen, const U32 flags); #define PERL_ARGS_ASSERT_SV_INSERT_FLAGS \ @@ -4837,10 +4684,6 @@ Perl_sv_magicext_mglob(pTHX_ SV *sv); #define PERL_ARGS_ASSERT_SV_MAGICEXT_MGLOB \ assert(sv) -/* PERL_CALLCONV SV * -Perl_sv_mortalcopy(pTHX_ SV * const oldsv) - __attribute__warn_unused_result__; */ - PERL_CALLCONV SV * Perl_sv_mortalcopy_flags(pTHX_ SV * const oldsv, U32 flags) __attribute__warn_unused_result__; @@ -4890,31 +4733,16 @@ Perl_sv_pos_u2b_flags(pTHX_ SV * const sv, STRLEN uoffset, STRLEN * const lenp, #define PERL_ARGS_ASSERT_SV_POS_U2B_FLAGS \ assert(sv) -/* PERL_CALLCONV char * -Perl_sv_pv(pTHX_ SV *sv) - __attribute__warn_unused_result__; */ - -/* PERL_CALLCONV char * -Perl_sv_pvbyte(pTHX_ SV *sv) - __attribute__warn_unused_result__; */ - PERL_CALLCONV char * Perl_sv_pvbyten_force(pTHX_ SV * const sv, STRLEN * const lp); #define PERL_ARGS_ASSERT_SV_PVBYTEN_FORCE \ assert(sv) -/* PERL_CALLCONV char * -Perl_sv_pvn_force(pTHX_ SV *sv, STRLEN *lp); */ - PERL_CALLCONV char * Perl_sv_pvn_force_flags(pTHX_ SV * const sv, STRLEN * const lp, const U32 flags); #define PERL_ARGS_ASSERT_SV_PVN_FORCE_FLAGS \ assert(sv) -/* PERL_CALLCONV char * -Perl_sv_pvutf8(pTHX_ SV *sv) - __attribute__warn_unused_result__; */ - PERL_CALLCONV char * Perl_sv_pvutf8n_force(pTHX_ SV * const sv, STRLEN * const lp); #define PERL_ARGS_ASSERT_SV_PVUTF8N_FORCE \ @@ -5113,9 +4941,6 @@ Perl_sv_setrv_noinc_mg(pTHX_ SV * const sv, SV * const ref); #define PERL_ARGS_ASSERT_SV_SETRV_NOINC_MG \ assert(sv); assert(ref) -/* PERL_CALLCONV void -Perl_sv_setsv(pTHX_ SV *dsv, SV *ssv); */ - PERL_CALLCONV void Perl_sv_setsv_flags(pTHX_ SV *dsv, SV *ssv, const I32 flags); #define PERL_ARGS_ASSERT_SV_SETSV_FLAGS \ @@ -5157,9 +4982,6 @@ PERL_CALLCONV SV * Perl_sv_string_from_errnum(pTHX_ int errnum, SV *tgtsv); #define PERL_ARGS_ASSERT_SV_STRING_FROM_ERRNUM -/* PERL_CALLCONV void -Perl_sv_taint(pTHX_ SV *sv); */ - PERL_CALLCONV bool Perl_sv_tainted(pTHX_ SV * const sv) __attribute__warn_unused_result__; @@ -5186,9 +5008,6 @@ Perl_sv_unmagicext(pTHX_ SV * const sv, const int type, const MGVTBL *vtbl); #define PERL_ARGS_ASSERT_SV_UNMAGICEXT \ assert(sv) -/* PERL_CALLCONV void -Perl_sv_unref(pTHX_ SV *sv); */ - PERL_CALLCONV void Perl_sv_unref_flags(pTHX_ SV * const ref, const U32 flags); #define PERL_ARGS_ASSERT_SV_UNREF_FLAGS \ @@ -5204,25 +5023,16 @@ Perl_sv_upgrade(pTHX_ SV * const sv, svtype new_type); #define PERL_ARGS_ASSERT_SV_UPGRADE \ assert(sv) -/* PERL_CALLCONV void -Perl_sv_usepvn(pTHX_ SV *sv, char *ptr, STRLEN len); */ - PERL_CALLCONV void Perl_sv_usepvn_flags(pTHX_ SV * const sv, char *ptr, const STRLEN len, const U32 flags); #define PERL_ARGS_ASSERT_SV_USEPVN_FLAGS \ assert(sv) -/* PERL_CALLCONV void -Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len); */ - PERL_CALLCONV bool Perl_sv_utf8_decode(pTHX_ SV * const sv); #define PERL_ARGS_ASSERT_SV_UTF8_DECODE \ assert(sv) -/* PERL_CALLCONV bool -Perl_sv_utf8_downgrade(pTHX_ SV * const sv, const bool fail_ok); */ - PERL_CALLCONV bool Perl_sv_utf8_downgrade_flags(pTHX_ SV * const sv, const bool fail_ok, const U32 flags); #define PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE_FLAGS \ @@ -5237,10 +5047,7 @@ Perl_sv_utf8_encode(pTHX_ SV * const sv); assert(sv) /* PERL_CALLCONV STRLEN -Perl_sv_utf8_upgrade(pTHX_ SV *sv); */ - -/* PERL_CALLCONV STRLEN -Perl_sv_utf8_upgrade_flags(pTHX_ SV * const sv, const I32 flags); */ +sv_utf8_upgrade_flags(pTHX_ SV * const sv, const I32 flags); */ PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade_flags_grow(pTHX_ SV * const sv, const I32 flags, STRLEN extra); @@ -5456,22 +5263,13 @@ Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *idop, OP *arg) assert(idop) /* PERL_CALLCONV U8 * -Perl_uv_to_utf8(pTHX_ U8 *d, UV uv); */ - -/* PERL_CALLCONV U8 * -Perl_uv_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags); */ - -/* PERL_CALLCONV U8 * -Perl_uv_to_utf8_msgs(pTHX_ U8 *d, UV uv, UV flags, HV **msgs); */ - -/* PERL_CALLCONV U8 * -Perl_uvchr_to_utf8(pTHX_ U8 *d, UV uv); */ +uvchr_to_utf8(pTHX_ U8 *d, UV uv); */ /* PERL_CALLCONV U8 * -Perl_uvchr_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags); */ +uvchr_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags); */ /* PERL_CALLCONV U8 * -Perl_uvchr_to_utf8_flags_msgs(pTHX_ U8 *d, UV uv, UV flags, HV **msgs); */ +uvchr_to_utf8_flags_msgs(pTHX_ U8 *d, UV uv, UV flags, HV **msgs); */ PERL_CALLCONV U8 * Perl_uvoffuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags); @@ -6017,6 +5815,240 @@ Perl_malloced_size(void *p) #endif /* defined(MYMALLOC) */ #if !defined(NO_MATHOMS) +PERL_CALLCONV bool +Perl_do_aexec(pTHX_ SV *really, SV **mark, SV **sp); +# define PERL_ARGS_ASSERT_DO_AEXEC \ + assert(mark); assert(sp) + +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 GV * +Perl_gv_AVadd(pTHX_ GV *gv); +# define PERL_ARGS_ASSERT_GV_AVADD + +PERL_CALLCONV GV * +Perl_gv_HVadd(pTHX_ GV *gv); +# define PERL_ARGS_ASSERT_GV_HVADD + +PERL_CALLCONV GV * +Perl_gv_IOadd(pTHX_ GV *gv); +# define PERL_ARGS_ASSERT_GV_IOADD + +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 GV * +Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name); +# define PERL_ARGS_ASSERT_GV_FETCHMETHOD \ + assert(stash); assert(name) + +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 SV * +Perl_hv_delete(pTHX_ HV *hv, const char *key, I32 klen, I32 flags); +# define PERL_ARGS_ASSERT_HV_DELETE \ + assert(key); assert(!hv || SvTYPE(hv) == SVt_PVHV) + +PERL_CALLCONV SV * +Perl_hv_delete_ent(pTHX_ HV *hv, SV *keysv, I32 flags, U32 hash); +# define PERL_ARGS_ASSERT_HV_DELETE_ENT \ + assert(keysv); assert(!hv || SvTYPE(hv) == SVt_PVHV) + +PERL_CALLCONV bool +Perl_hv_exists(pTHX_ HV *hv, const char *key, I32 klen) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_HV_EXISTS \ + assert(key); assert(!hv || SvTYPE(hv) == SVt_PVHV) + +PERL_CALLCONV bool +Perl_hv_exists_ent(pTHX_ HV *hv, SV *keysv, U32 hash) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_HV_EXISTS_ENT \ + assert(keysv); assert(!hv || SvTYPE(hv) == SVt_PVHV) + +PERL_CALLCONV SV ** +Perl_hv_fetch(pTHX_ HV *hv, const char *key, I32 klen, I32 lval); +# define PERL_ARGS_ASSERT_HV_FETCH \ + assert(key); assert(!hv || SvTYPE(hv) == SVt_PVHV) + +PERL_CALLCONV HE * +Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, U32 hash); +# define PERL_ARGS_ASSERT_HV_FETCH_ENT \ + assert(keysv); assert(!hv || SvTYPE(hv) == SVt_PVHV) + +PERL_CALLCONV HE * +Perl_hv_iternext(pTHX_ HV *hv) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_HV_ITERNEXT \ + assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + +PERL_CALLCONV void +Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how); +# define PERL_ARGS_ASSERT_HV_MAGIC \ + assert(hv); assert(SvTYPE(hv) == SVt_PVHV) + +PERL_CALLCONV SV ** +Perl_hv_store(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash); +# define PERL_ARGS_ASSERT_HV_STORE + +PERL_CALLCONV HE * +Perl_hv_store_ent(pTHX_ HV *hv, SV *key, SV *val, U32 hash); +# define PERL_ARGS_ASSERT_HV_STORE_ENT + +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 + +PERL_CALLCONV STRLEN +Perl_is_utf8_char_buf(const U8 *buf, const U8 *buf_end); +# define PERL_ARGS_ASSERT_IS_UTF8_CHAR_BUF \ + assert(buf); assert(buf_end) + +PERL_CALLCONV AV * +Perl_newAV(pTHX) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_NEWAV + +PERL_CALLCONV HV * +Perl_newHV(pTHX) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_NEWHV + +PERL_CALLCONV IO * +Perl_newIO(pTHX) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_NEWIO + +PERL_CALLCONV CV * +Perl_newSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *block); +# define PERL_ARGS_ASSERT_NEWSUB + +PERL_CALLCONV SV * +Perl_newSVsv(pTHX_ SV * const old) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_NEWSVSV + +PERL_CALLCONV void +Perl_save_freeop(pTHX_ OP *o); +# define PERL_ARGS_ASSERT_SAVE_FREEOP + +PERL_CALLCONV void +Perl_save_freepv(pTHX_ char *pv); +# define PERL_ARGS_ASSERT_SAVE_FREEPV + +PERL_CALLCONV void +Perl_save_freesv(pTHX_ SV *sv); +# define PERL_ARGS_ASSERT_SAVE_FREESV + +PERL_CALLCONV void +Perl_save_mortalizesv(pTHX_ SV *sv); +# define PERL_ARGS_ASSERT_SAVE_MORTALIZESV \ + assert(sv) + +PERL_CALLCONV void +Perl_save_op(pTHX); +# define PERL_ARGS_ASSERT_SAVE_OP + +PERL_CALLCONV bool +Perl_sv_2bool(pTHX_ SV * const sv); +# define PERL_ARGS_ASSERT_SV_2BOOL \ + assert(sv) + +PERL_CALLCONV IV +Perl_sv_2iv(pTHX_ SV *sv); +# define PERL_ARGS_ASSERT_SV_2IV \ + assert(sv) + +PERL_CALLCONV char * +Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp); +# define PERL_ARGS_ASSERT_SV_2PV \ + assert(sv) + +PERL_CALLCONV char * +Perl_sv_2pv_nolen(pTHX_ SV *sv) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_SV_2PV_NOLEN \ + assert(sv) + +PERL_CALLCONV char * +Perl_sv_2pvbyte(pTHX_ SV *sv, STRLEN * const lp); +# define PERL_ARGS_ASSERT_SV_2PVBYTE \ + assert(sv) + +PERL_CALLCONV char * +Perl_sv_2pvbyte_nolen(pTHX_ SV *sv) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_SV_2PVBYTE_NOLEN \ + assert(sv) + +PERL_CALLCONV char * +Perl_sv_2pvutf8(pTHX_ SV *sv, STRLEN * const lp); +# define PERL_ARGS_ASSERT_SV_2PVUTF8 \ + assert(sv) + +PERL_CALLCONV char * +Perl_sv_2pvutf8_nolen(pTHX_ SV *sv) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_SV_2PVUTF8_NOLEN \ + assert(sv) + +PERL_CALLCONV UV +Perl_sv_2uv(pTHX_ SV *sv); +# define PERL_ARGS_ASSERT_SV_2UV \ + assert(sv) + +PERL_CALLCONV void +Perl_sv_catpvn(pTHX_ SV * const dsv, const char *sstr, STRLEN len); +# define PERL_ARGS_ASSERT_SV_CATPVN \ + assert(dsv); assert(sstr) + +PERL_CALLCONV void +Perl_sv_catpvn_mg(pTHX_ SV * const dsv, const char *sstr, STRLEN len); +# define PERL_ARGS_ASSERT_SV_CATPVN_MG \ + assert(dsv); assert(sstr) + +PERL_CALLCONV void +Perl_sv_catsv(pTHX_ SV * const dsv, SV * const sstr); +# define PERL_ARGS_ASSERT_SV_CATSV \ + assert(dsv) + +PERL_CALLCONV void +Perl_sv_catsv_mg(pTHX_ SV * const dsv, SV * const sstr); +# define PERL_ARGS_ASSERT_SV_CATSV_MG \ + assert(dsv) + +PERL_CALLCONV void +Perl_sv_copypv(pTHX_ SV * const dsv, SV * const ssv); +# define PERL_ARGS_ASSERT_SV_COPYPV \ + assert(dsv); assert(ssv) + +PERL_CALLCONV I32 +Perl_sv_eq(pTHX_ SV *sv1, SV *sv2); +# define PERL_ARGS_ASSERT_SV_EQ + +PERL_CALLCONV void +Perl_sv_force_normal(pTHX_ SV *sv); +# define PERL_ARGS_ASSERT_SV_FORCE_NORMAL \ + assert(sv) + +PERL_CALLCONV void +Perl_sv_insert(pTHX_ SV * const bigstr, const STRLEN offset, const STRLEN len, const char * const little, const STRLEN littlelen); +# define PERL_ARGS_ASSERT_SV_INSERT \ + assert(bigstr); assert(little) + +PERL_CALLCONV SV * +Perl_sv_mortalcopy(pTHX_ SV * const oldsv) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_SV_MORTALCOPY + PERL_CALLCONV void Perl_sv_nolocking(pTHX_ SV *sv) __attribute__deprecated__; @@ -6027,6 +6059,64 @@ Perl_sv_nounlocking(pTHX_ SV *sv) __attribute__deprecated__; # define PERL_ARGS_ASSERT_SV_NOUNLOCKING +PERL_CALLCONV char * +Perl_sv_pv(pTHX_ SV *sv) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_SV_PV \ + assert(sv) + +PERL_CALLCONV char * +Perl_sv_pvbyte(pTHX_ SV *sv) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_SV_PVBYTE \ + assert(sv) + +PERL_CALLCONV char * +Perl_sv_pvn_force(pTHX_ SV *sv, STRLEN *lp); +# define PERL_ARGS_ASSERT_SV_PVN_FORCE \ + assert(sv) + +PERL_CALLCONV char * +Perl_sv_pvutf8(pTHX_ SV *sv) + __attribute__warn_unused_result__; +# define PERL_ARGS_ASSERT_SV_PVUTF8 \ + assert(sv) + +PERL_CALLCONV void +Perl_sv_setsv(pTHX_ SV *dsv, SV *ssv); +# define PERL_ARGS_ASSERT_SV_SETSV \ + assert(dsv) + +PERL_CALLCONV void +Perl_sv_taint(pTHX_ SV *sv); +# define PERL_ARGS_ASSERT_SV_TAINT \ + assert(sv) + +PERL_CALLCONV void +Perl_sv_unref(pTHX_ SV *sv); +# define PERL_ARGS_ASSERT_SV_UNREF \ + assert(sv) + +PERL_CALLCONV void +Perl_sv_usepvn(pTHX_ SV *sv, char *ptr, STRLEN len); +# define PERL_ARGS_ASSERT_SV_USEPVN \ + assert(sv) + +PERL_CALLCONV void +Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len); +# define PERL_ARGS_ASSERT_SV_USEPVN_MG \ + assert(sv) + +PERL_CALLCONV bool +Perl_sv_utf8_downgrade(pTHX_ SV * const sv, const bool fail_ok); +# define PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE \ + assert(sv) + +PERL_CALLCONV STRLEN +Perl_sv_utf8_upgrade(pTHX_ SV *sv); +# define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE \ + assert(sv) + PERL_CALLCONV UV Perl_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen) __attribute__deprecated__; @@ -6051,6 +6141,26 @@ Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv) # define PERL_ARGS_ASSERT_UVUNI_TO_UTF8 \ assert(d) +# if defined(PERL_DONT_CREATE_GVSV) +PERL_CALLCONV GV * +Perl_gv_SVadd(pTHX_ GV *gv); +# define PERL_ARGS_ASSERT_GV_SVADD + +# endif +# if defined(PERL_IN_MATHOMS_C) || defined(PERL_IN_OP_C) || \ + defined(PERL_IN_PERLY_C) || defined(PERL_IN_TOKE_C) +PERL_CALLCONV OP * +Perl_ref(pTHX_ OP *o, I32 type); +# define PERL_ARGS_ASSERT_REF + +# endif +# if defined(USE_LOCALE_COLLATE) +PERL_CALLCONV char * +Perl_sv_collxfrm(pTHX_ SV * const sv, STRLEN * const nxp); +# define PERL_ARGS_ASSERT_SV_COLLXFRM \ + assert(sv); assert(nxp) + +# endif #endif /* !defined(NO_MATHOMS) */ #if defined(PERL_ANY_COW) PERL_CALLCONV SV * @@ -6158,11 +6268,6 @@ Perl_do_exec(pTHX_ const char *cmd) # define PERL_ARGS_ASSERT_DO_EXEC \ assert(cmd) -#endif -#if defined(PERL_DONT_CREATE_GVSV) -/* PERL_CALLCONV GV * -Perl_gv_SVadd(pTHX_ GV *gv); */ - #endif #if defined(PERL_IMPLICIT_SYS) PERL_CALLCONV PerlInterpreter * @@ -7273,12 +7378,6 @@ S_adjust_size_and_find_bucket(size_t *nbytes_p); # define PERL_ARGS_ASSERT_ADJUST_SIZE_AND_FIND_BUCKET \ assert(nbytes_p) -#endif -#if defined(PERL_IN_MATHOMS_C) || defined(PERL_IN_OP_C) || \ - defined(PERL_IN_PERLY_C) || defined(PERL_IN_TOKE_C) -/* PERL_CALLCONV OP * -Perl_ref(pTHX_ OP *o, I32 type); */ - #endif #if defined(PERL_IN_MG_C) STATIC void @@ -10180,6 +10279,21 @@ Perl_utf8n_to_uvchr_msgs(const U8 * const s0, STRLEN curlen, STRLEN *retlen, con # define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR_MSGS \ assert(s0) +PERL_STATIC_INLINE U8 * +Perl_uv_to_utf8(pTHX_ U8 *d, UV uv); +# define PERL_ARGS_ASSERT_UV_TO_UTF8 \ + assert(d) + +PERL_STATIC_INLINE U8 * +Perl_uv_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags); +# define PERL_ARGS_ASSERT_UV_TO_UTF8_FLAGS \ + assert(d) + +PERL_STATIC_INLINE 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_STATIC_INLINE UV Perl_valid_utf8_to_uvchr(const U8 *s, STRLEN *retlen) __attribute__warn_unused_result__; @@ -10739,9 +10853,6 @@ Perl_strxfrm(pTHX_ SV *src); # define PERL_ARGS_ASSERT_STRXFRM \ assert(src) -/* PERL_CALLCONV char * -Perl_sv_collxfrm(pTHX_ SV * const sv, STRLEN * const nxp); */ - PERL_CALLCONV char * Perl_sv_collxfrm_flags(pTHX_ SV * const sv, STRLEN * const nxp, I32 const flags); # define PERL_ARGS_ASSERT_SV_COLLXFRM_FLAGS \ diff --git a/scope.h b/scope.h index eccd3aaba2dc..67e1c07feae2 100644 --- a/scope.h +++ b/scope.h @@ -299,20 +299,17 @@ casts it to a pointer of that C. #define SSPTR(off,type) (assert(sizeof(off) >= sizeof(SSize_t)), (type) ((char*)PL_savestack + off)) #define SSPTRt(off,type) (assert(sizeof(off) >= sizeof(SSize_t)), (type*) ((char*)PL_savestack + off)) -#define Perl_save_freesv(mTHX, op) \ - Perl_save_pushptr(aTHX_ (void *)(op), SAVEt_FREESV) -#define Perl_save_mortalizesv(mTHX, op) \ - Perl_save_pushptr(aTHX_ (void *)(op), SAVEt_MORTALIZESV) - -# define Perl_save_freeop(mTHX, op) \ -STMT_START { \ - OP * const _o = (OP *)(op); \ - assert(!_o->op_savefree); \ - _o->op_savefree = 1; \ - Perl_save_pushptr(aTHX_ (void *)(_o), SAVEt_FREEOP); \ +#define save_freesv(op) save_pushptr((void *)(op), SAVEt_FREESV) +#define save_mortalizesv(op) save_pushptr((void *)(op), SAVEt_MORTALIZESV) + +# define save_freeop(op) \ +STMT_START { \ + OP * const _o = (OP *)(op); \ + assert(!_o->op_savefree); \ + _o->op_savefree = 1; \ + save_pushptr((void *)(_o), SAVEt_FREEOP); \ } STMT_END -#define Perl_save_freepv(mTHX, pv) \ - Perl_save_pushptr(aTHX_ (void *)(pv), SAVEt_FREEPV) +#define save_freepv(pv) save_pushptr((void *)(pv), SAVEt_FREEPV) /* =for apidoc_section $callback @@ -323,7 +320,7 @@ Implements C. =cut */ -#define Perl_save_op(mTHX) Perl_save_pushptr(aTHX_ (void *)(PL_op), SAVEt_OP) +#define save_op() save_pushptr((void *)(PL_op), SAVEt_OP) /* * ex: set ts=8 sts=4 sw=4 et: diff --git a/sv.h b/sv.h index 4cf0324d8483..b772ac77944a 100644 --- a/sv.h +++ b/sv.h @@ -1721,14 +1721,10 @@ inputs such as locale settings. C propagates that taintedness to the outputs of an expression in a pessimistic fashion; i.e., without paying attention to precisely which outputs are influenced by which inputs. -=for apidoc sv_taint -Taint an SV. Use C instead. - =cut */ -#define Perl_sv_taint(mTHX, sv) \ - Perl_sv_magic(aTHX_ (sv), NULL, PERL_MAGIC_taint, NULL, 0) +#define sv_taint(sv) sv_magic((sv), NULL, PERL_MAGIC_taint, NULL, 0) #ifdef NO_TAINT_SUPPORT # define SvTAINTED(sv) 0 @@ -2172,12 +2168,10 @@ Returns the hash for C created by C>. #endif -#define Perl_sv_unref(mTHX, sv) Perl_sv_unref_flags(aTHX_ sv, 0) -#define Perl_sv_force_normal(mTHX, sv) Perl_sv_force_normal_flags(aTHX_ sv, 0) -#define Perl_sv_usepvn(mTHX, sv, p, l) \ - Perl_sv_usepvn_flags(aTHX_ sv, p, l, 0) -#define Perl_sv_usepvn_mg(mTHX, sv, p, l) \ - Perl_sv_usepvn_flags(aTHX_ sv, p, l, SV_SMAGIC) +#define sv_unref(sv) sv_unref_flags(sv, 0) +#define sv_force_normal(sv) sv_force_normal_flags(sv, 0) +#define sv_usepvn(sv, p, l) sv_usepvn_flags(sv, p, l, 0) +#define sv_usepvn_mg(sv, p, l) sv_usepvn_flags(sv, p, l, SV_SMAGIC) /* =for apidoc Am|void|SV_CHECK_THINKFIRST_COW_DROP|SV * sv @@ -2228,40 +2222,14 @@ immediately written again. /* all these 'functions' are now just macros */ -/* -=for apidoc sv_pv - -Use the C macro instead - -=cut -*/ -#define Perl_sv_pv(mTHX, sv) Perl_SvPV_nolen(aTHX_ sv) - -/* -=for apidoc sv_pvutf8 - -Use the C macro instead - -=cut -*/ - -#define Perl_sv_pvutf8(mTHX, sv) Perl_SvPVutf8_nolen(aTHX_ sv) - -/* -=for apidoc sv_pvbyte - -Use C instead. - -=cut -*/ -#define Perl sv_pvbyte(mTHX, sv) Perl SvPVbyte_nolen(aTHX_ sv) +#define sv_pv(sv) SvPV_nolen(sv) +#define sv_pvutf8(sv) SvPVutf8_nolen(sv) +#define sv_pvbyte(sv) SvPVbyte_nolen(sv) #define sv_pvn_force_nomg(sv, lp) sv_pvn_force_flags(sv, lp, 0) -#define Perl_sv_utf8_upgrade_flags(mTHX, sv, flags) \ - Perl_sv_utf8_upgrade_flags_grow(aTHX_ sv, flags, 0) +#define sv_utf8_upgrade_flags(sv, flags) sv_utf8_upgrade_flags_grow(sv, flags, 0) #define sv_utf8_upgrade_nomg(sv) sv_utf8_upgrade_flags(sv, 0) -#define Perl_sv_utf8_downgrade(mTHX, sv, fail_ok) \ - Perl_sv_utf8_downgrade_flags(aTHX_ sv, fail_ok, SV_GMAGIC) +#define sv_utf8_downgrade(sv, fail_ok) sv_utf8_downgrade_flags(sv, fail_ok, SV_GMAGIC) #define sv_utf8_downgrade_nomg(sv, fail_ok) sv_utf8_downgrade_flags(sv, fail_ok, 0) /* =for apidoc_defn Am|void|sv_catpvn_nomg|NN SV * const dsv \ @@ -2273,89 +2241,45 @@ Use C instead. */ #define sv_catpvn_nomg(dsv, sstr, slen) sv_catpvn_flags(dsv, sstr, slen, 0) #define sv_catpv_nomg(dsv, sstr) sv_catpv_flags(dsv, sstr, 0) -#define Perl_sv_setsv(mTHX, dsv, ssv) \ - Perl_sv_setsv_flags(aTHX_ dsv, ssv, SV_GMAGIC|SV_DO_COW_SVSETSV) +#define sv_setsv(dsv, ssv) \ + sv_setsv_flags(dsv, ssv, SV_GMAGIC|SV_DO_COW_SVSETSV) /* =for apidoc_defn Am|void|sv_setsv_nomg|SV *dsv|SV *ssv =for apidoc_defn Am|void|sv_catsv_nomg|SV * const dsv|SV * const sstr =cut */ #define sv_setsv_nomg(dsv, ssv) sv_setsv_flags(dsv, ssv, SV_DO_COW_SVSETSV) -#define Perl_sv_catsv(mTHX, dsv, ssv) \ - Perl_sv_catsv_flags(aTHX_ dsv, ssv, SV_GMAGIC) +#define sv_catsv(dsv, ssv) sv_catsv_flags(dsv, ssv, SV_GMAGIC) #define sv_catsv_nomg(dsv, ssv) sv_catsv_flags(dsv, ssv, 0) -#define Perl_sv_catsv_mg(mTHX, dsv, ssv) \ - Perl_sv_catsv_flags(aTHX_ dsv, ssv, SV_GMAGIC|SV_SMAGIC) -#define Perl_sv_catpvn(mTHX, dsv, sstr, slen) \ - Perl_sv_catpvn_flags(aTHX_ dsv, sstr, slen, SV_GMAGIC) -#define Perl_sv_catpvn_mg(mTHX, dsv, sstr, slen) \ - Perl_sv_catpvn_flags(aTHX_ dsv, sstr, slen, SV_GMAGIC|SV_SMAGIC) -#define Perl_sv_copypv(mTHX, dsv, ssv) \ - Perl_sv_copypv_flags(aTHX_ dsv, ssv, SV_GMAGIC) +#define sv_catsv_mg(dsv, ssv) sv_catsv_flags(dsv, ssv, SV_GMAGIC|SV_SMAGIC) +#define sv_catpvn(dsv, sstr, slen) sv_catpvn_flags(dsv, sstr, slen, SV_GMAGIC) +#define sv_catpvn_mg(dsv, sstr, slen) sv_catpvn_flags(dsv, sstr, slen, SV_GMAGIC|SV_SMAGIC); +#define sv_copypv(dsv, ssv) sv_copypv_flags(dsv, ssv, SV_GMAGIC) #define sv_copypv_nomg(dsv, ssv) sv_copypv_flags(dsv, ssv, 0) -#define Perl_sv_2pv(mTHX, sv, lp) Perl_sv_2pv_flags(aTHX_ sv, lp, SV_GMAGIC) - -/* -=for apidoc sv_2pv_nolen - -Like C, but doesn't return the length too. You should usually -use the macro wrapper C instead. - -=cut -*/ -#define Perl_sv_2pv_nolen(mTHX, sv) Perl_sv_2pv(mTHX, sv, 0) -#define Perl_sv_2pvbyte(mTHX, sv, lp) \ - Perl_sv_2pvbyte_flags(aTHX_ sv, lp, SV_GMAGIC) - -/* -=for apidoc sv_2pvbyte_nolen - -Return a pointer to the byte-encoded representation of the SV. -May cause the SV to be downgraded from UTF-8 as a side-effect. - -Usually accessed via the C macro. - -=cut -*/ -#define Perl_sv_2pvbyte_nolen(mTHX, sv) \ - Perl_sv_2pvbyte(aTHX_ sv, 0) - -#define Perl_sv_2pvutf8(mTHX, sv, lp) \ - Perl_sv_2pvutf8_flags(aTHX_ sv, lp, SV_GMAGIC) - -/* -=for apidoc sv_2pvutf8_nolen - -Return a pointer to the UTF-8-encoded representation of the SV. -May cause the SV to be upgraded to UTF-8 as a side-effect. - -Usually accessed via the C macro. - -=cut -*/ -#define Perl_sv_2pvutf8_nolen(mTHX, sv) Perl_sv_2pvutf8(aTHX, sv, 0) - +#define sv_2pv(sv, lp) sv_2pv_flags(sv, lp, SV_GMAGIC) +#define sv_2pv_nolen(sv) sv_2pv(sv, 0) +#define sv_2pvbyte(sv, lp) sv_2pvbyte_flags(sv, lp, SV_GMAGIC) +#define sv_2pvbyte_nolen(sv) sv_2pvbyte(sv, 0) +#define sv_2pvutf8(sv, lp) sv_2pvutf8_flags(sv, lp, SV_GMAGIC) +#define sv_2pvutf8_nolen(sv) sv_2pvutf8(sv, 0) #define sv_2pv_nomg(sv, lp) sv_2pv_flags(sv, lp, 0) -#define Perl_sv_pvn_force(mTHX, sv, lp) \ - Perl_sv_pvn_force_flags(aTHX_ sv, lp, SV_GMAGIC) -#define Perl_sv_utf8_upgrade(mTHX, sv) \ - Perl_sv_utf8_upgrade_flags(aTHX, sv, SV_GMAGIC) -#define Perl_sv_2iv(mTHX, sv) Perl_sv_2iv_flags(aTHX_ sv, SV_GMAGIC) -#define Perl_sv_2uv(mTHX, sv) Perl_sv_2uv_flags(aTHX_ sv, SV_GMAGIC) -#define Perl_sv_2nv(mTHX, sv) Perl_sv_2nv_flags(aTHX_ sv, SV_GMAGIC) -#define Perl_sv_eq(mTHX, sv1, sv2) Perl_sv_eq_flags(aTHX_ sv1, sv2, SV_GMAGIC) +#define sv_pvn_force(sv, lp) sv_pvn_force_flags(sv, lp, SV_GMAGIC) +#define sv_utf8_upgrade(sv) sv_utf8_upgrade_flags(sv, SV_GMAGIC) +#define sv_2iv(sv) sv_2iv_flags(sv, SV_GMAGIC) +#define sv_2uv(sv) sv_2uv_flags(sv, SV_GMAGIC) +#define sv_2nv(sv) sv_2nv_flags(sv, SV_GMAGIC) +#define sv_eq(sv1, sv2) sv_eq_flags(sv1, sv2, SV_GMAGIC) #define sv_cmp(sv1, sv2) sv_cmp_flags(sv1, sv2, SV_GMAGIC) #define sv_cmp_locale(sv1, sv2) sv_cmp_locale_flags(sv1, sv2, SV_GMAGIC) #define sv_numeq(sv1, sv2) sv_numeq_flags(sv1, sv2, SV_GMAGIC) #define sv_streq(sv1, sv2) sv_streq_flags(sv1, sv2, SV_GMAGIC) -#define Perl_sv_collxfrm(mTHX, sv, nxp) \ - Perl_sv_collxfrm_flags(aTHX_ sv, nxp, SV_GMAGIC) -#define Perl_sv_2bool(mTHX, sv) Perl_sv_2bool_flags(aTHX_ sv, SV_GMAGIC) +#define sv_collxfrm(sv, nxp) sv_collxfrm_flags(sv, nxp, SV_GMAGIC) +#define sv_2bool(sv) sv_2bool_flags(sv, SV_GMAGIC) #define sv_2bool_nomg(sv) sv_2bool_flags(sv, 0) -#define Perl_sv_insert(mTHX, bigstr, offset, len, little, littlelen) \ +#define sv_insert(bigstr, offset, len, little, littlelen) \ Perl_sv_insert_flags(aTHX_ (bigstr),(offset), (len), (little), \ (littlelen), SV_GMAGIC) -#define Perl_sv_mortalcopy(mTHX, sv) \ +#define sv_mortalcopy(sv) \ Perl_sv_mortalcopy_flags(aTHX_ sv, SV_GMAGIC|SV_DO_COW_SVSETSV) #define sv_cathek(sv,hek) \ STMT_START { \ @@ -2645,8 +2569,7 @@ struct clone_params { /* SV_NOSTEAL prevents TEMP buffers being, well, stolen, and saves games with SvTEMP_off and SvTEMP_on round a call to sv_setsv. */ -#define Perl_newSVsv(mTHX, sv) \ - Perl_newSVsv_flags(aTHX_ (sv), SV_GMAGIC|SV_NOSTEAL) +#define newSVsv(sv) newSVsv_flags((sv), SV_GMAGIC|SV_NOSTEAL) #define newSVsv_nomg(sv) newSVsv_flags((sv), SV_NOSTEAL) /* @@ -2734,7 +2657,7 @@ Create a new IO, setting the reference count to 1. =cut */ -#define Perl_newIO(mTHX) MUTABLE_IO(Perl_newSV_type(aTHX_ SVt_PVIO)) +#define newIO() MUTABLE_IO(newSV_type(SVt_PVIO)) #if defined(PERL_CORE) || defined(PERL_EXT) diff --git a/utf8.h b/utf8.h index c8cc7c3909bb..7e9fa216a0f4 100644 --- a/utf8.h +++ b/utf8.h @@ -142,12 +142,12 @@ typedef enum { #define uvoffuni_to_utf8_flags(d,uv,flags) \ uvoffuni_to_utf8_flags_msgs(d, uv, flags, 0) -#define Perl_uv_to_utf8(mTHX, d, u) \ - Perl_uv_to_utf8_flags(aTHX, d, u, 0) -#define Perl_uv_to_utf8_flags(mTHX, d, u, f) \ - Perl_uv_to_utf8_msgs(aTHX, d, u, f, 0) -#define Perl_uv_to_utf8_msgs(mTHX, d, u, f , m) \ - Perl_uvoffuni_to_utf8_flags_msgs(aTHX_ d, NATIVE_TO_UNI(u), f, m) +#define uvchr_to_utf8 uv_to_utf8 +#define uvchr_to_utf8_flags uv_to_utf8_flags +#define uvchr_to_utf8_flags_msgs uv_to_utf8_msgs +#define Perl_uvchr_to_utf8 Perl_uv_to_utf8 +#define Perl_uvchr_to_utf8_flags Perl_uv_to_utf8_flags +#define Perl_uvchr_to_utf8_flags_msgs Perl_uv_to_utf8_msgs /* This is needed to cast the parameters for all those calls that had them * improperly as chars */ @@ -173,9 +173,6 @@ typedef enum { #define Perl_c9strict_utf8_to_uv(s, e, cp_p, advance_p) \ Perl_utf8_to_uv_flags( s, e, cp_p, advance_p, \ UTF8_DISALLOW_ILLEGAL_C9_INTERCHANGE) -#define Perl_uvchr_to_utf8 Perl_uv_to_utf8 -#define Perl_uvchr_to_utf8_flags Perl_uv_to_utf8_flags -#define Perl_uvchr_to_utf8_flags_msgs Perl_uv_to_utf8_msgs #define utf16_to_utf8(p, d, bytelen, newlen) \ utf16_to_utf8_base(p, d, bytelen, newlen, 0, 1) @@ -1334,7 +1331,7 @@ point's representation. /* Should be removed; maybe deprecated, but not used in CPAN */ #define SHARP_S_SKIP 2 -#define Perl_is_utf8_char_buf(buf, buf_end) isUTF8_CHAR(buf, buf_end) +#define is_utf8_char_buf(buf, buf_end) isUTF8_CHAR(buf, buf_end) typedef enum { PL_utf8_to_bytes_overwrite = 0,