3 * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010,
4 * 2011, 2012 by Larry Wall and others
6 * You may distribute under the terms of either the GNU General Public
7 * License or the Artistic License, as specified in the README file.
12 * Anything that Hobbits had no immediate use for, but were unwilling to
13 * throw away, they called a mathom. Their dwellings were apt to become
14 * rather crowded with mathoms, and many of the presents that passed from
15 * hand to hand were of that sort.
17 * [p.5 of _The Lord of the Rings_: "Prologue"]
23 * This file contains mathoms, various binary artifacts from previous
24 * versions of Perl which we cannot completely remove from the core
25 * code. There are two reasons functions should be here:
27 * 1) A function has been been replaced by a macro within a minor release,
28 * so XS modules compiled against an older release will expect to
29 * still be able to link against the function
30 * 2) A function Perl_foo(...) with #define foo Perl_foo(aTHX_ ...)
31 * has been replaced by a macro, e.g. #define foo(...) foo_flags(...,0)
32 * but XS code may still explicitly use the long form, i.e.
35 * NOTE: ALL FUNCTIONS IN THIS FILE should have an entry with the 'b' flag in
38 * To move a function to this file, simply cut and paste it here, and change
39 * its embed.fnc entry to additionally have the 'b' flag. If, for some reason
40 * a function you'd like to be treated as mathoms can't be moved from its
41 * current place, simply enclose it between
47 * and add the 'b' flag in embed.fnc.
49 * The compilation of this file can be suppressed; see INSTALL
51 * Some blurb for perlapi.pod:
53 =head1 Obsolete backwards compatibility functions
55 Some of these are also deprecated. You can exclude these from
56 your compiled Perl by adding this option to Configure:
57 C<-Accflags='-DNO_MATHOMS'>
65 #define PERL_IN_MATHOMS_C
69 /* ..." warning: ISO C forbids an empty source file"
70 So make sure we have something in here by processing the headers anyway.
74 /* ref() is now a macro using Perl_doref;
75 * this version provided for binary compatibility only.
78 Perl_ref(pTHX_ OP *o, I32 type)
80 return doref(o, type, TRUE);
86 Unsets the RV status of the SV, and decrements the reference count of
87 whatever was being referenced by the RV. This can almost be thought of
88 as a reversal of C<newSVrv>. This is C<sv_unref_flags> with the C<flag>
89 being zero. See C<L</SvROK_off>>.
95 Perl_sv_unref(pTHX_ SV *sv)
97 PERL_ARGS_ASSERT_SV_UNREF;
99 sv_unref_flags(sv, 0);
105 Taint an SV. Use C<SvTAINTED_on> instead.
111 Perl_sv_taint(pTHX_ SV *sv)
113 PERL_ARGS_ASSERT_SV_TAINT;
115 sv_magic((sv), NULL, PERL_MAGIC_taint, NULL, 0);
118 /* sv_2iv() is now a macro using Perl_sv_2iv_flags();
119 * this function provided for binary compatibility only
123 Perl_sv_2iv(pTHX_ SV *sv)
125 PERL_ARGS_ASSERT_SV_2IV;
127 return sv_2iv_flags(sv, SV_GMAGIC);
130 /* sv_2uv() is now a macro using Perl_sv_2uv_flags();
131 * this function provided for binary compatibility only
135 Perl_sv_2uv(pTHX_ SV *sv)
137 PERL_ARGS_ASSERT_SV_2UV;
139 return sv_2uv_flags(sv, SV_GMAGIC);
142 /* sv_2nv() is now a macro using Perl_sv_2nv_flags();
143 * this function provided for binary compatibility only
147 Perl_sv_2nv(pTHX_ SV *sv)
149 return sv_2nv_flags(sv, SV_GMAGIC);
153 /* sv_2pv() is now a macro using Perl_sv_2pv_flags();
154 * this function provided for binary compatibility only
158 Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp)
160 PERL_ARGS_ASSERT_SV_2PV;
162 return sv_2pv_flags(sv, lp, SV_GMAGIC);
166 =for apidoc sv_2pv_nolen
168 Like C<sv_2pv()>, but doesn't return the length too. You should usually
169 use the macro wrapper C<SvPV_nolen(sv)> instead.
175 Perl_sv_2pv_nolen(pTHX_ SV *sv)
177 PERL_ARGS_ASSERT_SV_2PV_NOLEN;
178 return sv_2pv(sv, NULL);
182 =for apidoc sv_2pvbyte_nolen
184 Return a pointer to the byte-encoded representation of the SV.
185 May cause the SV to be downgraded from UTF-8 as a side-effect.
187 Usually accessed via the C<SvPVbyte_nolen> macro.
193 Perl_sv_2pvbyte_nolen(pTHX_ SV *sv)
195 PERL_ARGS_ASSERT_SV_2PVBYTE_NOLEN;
197 return sv_2pvbyte(sv, NULL);
201 =for apidoc sv_2pvutf8_nolen
203 Return a pointer to the UTF-8-encoded representation of the SV.
204 May cause the SV to be upgraded to UTF-8 as a side-effect.
206 Usually accessed via the C<SvPVutf8_nolen> macro.
212 Perl_sv_2pvutf8_nolen(pTHX_ SV *sv)
214 PERL_ARGS_ASSERT_SV_2PVUTF8_NOLEN;
216 return sv_2pvutf8(sv, NULL);
220 =for apidoc sv_force_normal
222 Undo various types of fakery on an SV: if the PV is a shared string, make
223 a private copy; if we're a ref, stop refing; if we're a glob, downgrade to
224 an C<xpvmg>. See also C<L</sv_force_normal_flags>>.
230 Perl_sv_force_normal(pTHX_ SV *sv)
232 PERL_ARGS_ASSERT_SV_FORCE_NORMAL;
234 sv_force_normal_flags(sv, 0);
237 /* sv_setsv() is now a macro using Perl_sv_setsv_flags();
238 * this function provided for binary compatibility only
242 Perl_sv_setsv(pTHX_ SV *dstr, SV *sstr)
244 PERL_ARGS_ASSERT_SV_SETSV;
246 sv_setsv_flags(dstr, sstr, SV_GMAGIC);
249 /* sv_catpvn() is now a macro using Perl_sv_catpvn_flags();
250 * this function provided for binary compatibility only
254 Perl_sv_catpvn(pTHX_ SV *dsv, const char* sstr, STRLEN slen)
256 PERL_ARGS_ASSERT_SV_CATPVN;
258 sv_catpvn_flags(dsv, sstr, slen, SV_GMAGIC);
262 =for apidoc sv_catpvn_mg
264 Like C<sv_catpvn>, but also handles 'set' magic.
270 Perl_sv_catpvn_mg(pTHX_ SV *sv, const char *ptr, STRLEN len)
272 PERL_ARGS_ASSERT_SV_CATPVN_MG;
274 sv_catpvn_flags(sv,ptr,len,SV_GMAGIC|SV_SMAGIC);
277 /* sv_catsv() is now a macro using Perl_sv_catsv_flags();
278 * this function provided for binary compatibility only
282 Perl_sv_catsv(pTHX_ SV *dstr, SV *sstr)
284 PERL_ARGS_ASSERT_SV_CATSV;
286 sv_catsv_flags(dstr, sstr, SV_GMAGIC);
290 =for apidoc sv_catsv_mg
292 Like C<sv_catsv>, but also handles 'set' magic.
298 Perl_sv_catsv_mg(pTHX_ SV *dsv, SV *ssv)
300 PERL_ARGS_ASSERT_SV_CATSV_MG;
302 sv_catsv_flags(dsv,ssv,SV_GMAGIC|SV_SMAGIC);
308 A private implementation of the C<SvIVx> macro for compilers which can't
309 cope with complex macro expressions. Always use the macro instead.
315 Perl_sv_iv(pTHX_ SV *sv)
317 PERL_ARGS_ASSERT_SV_IV;
321 return (IV)SvUVX(sv);
330 A private implementation of the C<SvUVx> macro for compilers which can't
331 cope with complex macro expressions. Always use the macro instead.
337 Perl_sv_uv(pTHX_ SV *sv)
339 PERL_ARGS_ASSERT_SV_UV;
344 return (UV)SvIVX(sv);
352 A private implementation of the C<SvNVx> macro for compilers which can't
353 cope with complex macro expressions. Always use the macro instead.
359 Perl_sv_nv(pTHX_ SV *sv)
361 PERL_ARGS_ASSERT_SV_NV;
371 Use the C<SvPV_nolen> macro instead
375 A private implementation of the C<SvPV> macro for compilers which can't
376 cope with complex macro expressions. Always use the macro instead.
382 Perl_sv_pvn(pTHX_ SV *sv, STRLEN *lp)
384 PERL_ARGS_ASSERT_SV_PVN;
390 return sv_2pv(sv, lp);
395 Perl_sv_pvn_nomg(pTHX_ SV *sv, STRLEN *lp)
397 PERL_ARGS_ASSERT_SV_PVN_NOMG;
403 return sv_2pv_flags(sv, lp, 0);
406 /* sv_pv() is now a macro using SvPV_nolen();
407 * this function provided for binary compatibility only
411 Perl_sv_pv(pTHX_ SV *sv)
413 PERL_ARGS_ASSERT_SV_PV;
418 return sv_2pv(sv, NULL);
421 /* sv_pvn_force() is now a macro using Perl_sv_pvn_force_flags();
422 * this function provided for binary compatibility only
426 Perl_sv_pvn_force(pTHX_ SV *sv, STRLEN *lp)
428 PERL_ARGS_ASSERT_SV_PVN_FORCE;
430 return sv_pvn_force_flags(sv, lp, SV_GMAGIC);
433 /* sv_pvbyte () is now a macro using Perl_sv_2pv_flags();
434 * this function provided for binary compatibility only
438 Perl_sv_pvbyte(pTHX_ SV *sv)
440 PERL_ARGS_ASSERT_SV_PVBYTE;
442 sv_utf8_downgrade(sv, FALSE);
447 =for apidoc sv_pvbyte
449 Use C<SvPVbyte_nolen> instead.
451 =for apidoc sv_pvbyten
453 A private implementation of the C<SvPVbyte> macro for compilers
454 which can't cope with complex macro expressions. Always use the macro
461 Perl_sv_pvbyten(pTHX_ SV *sv, STRLEN *lp)
463 PERL_ARGS_ASSERT_SV_PVBYTEN;
465 sv_utf8_downgrade(sv, FALSE);
466 return sv_pvn(sv,lp);
469 /* sv_pvutf8 () is now a macro using Perl_sv_2pv_flags();
470 * this function provided for binary compatibility only
474 Perl_sv_pvutf8(pTHX_ SV *sv)
476 PERL_ARGS_ASSERT_SV_PVUTF8;
483 =for apidoc sv_pvutf8
485 Use the C<SvPVutf8_nolen> macro instead
487 =for apidoc sv_pvutf8n
489 A private implementation of the C<SvPVutf8> macro for compilers
490 which can't cope with complex macro expressions. Always use the macro
497 Perl_sv_pvutf8n(pTHX_ SV *sv, STRLEN *lp)
499 PERL_ARGS_ASSERT_SV_PVUTF8N;
502 return sv_pvn(sv,lp);
505 /* sv_utf8_upgrade() is now a macro using sv_utf8_upgrade_flags();
506 * this function provided for binary compatibility only
510 Perl_sv_utf8_upgrade(pTHX_ SV *sv)
512 PERL_ARGS_ASSERT_SV_UTF8_UPGRADE;
514 return sv_utf8_upgrade_flags(sv, SV_GMAGIC);
518 Perl_fprintf_nocontext(PerlIO *stream, const char *format, ...)
523 /* Easier to special case this here than in embed.pl. (Look at what it
524 generates for proto.h) */
525 #ifdef PERL_IMPLICIT_CONTEXT
526 PERL_ARGS_ASSERT_FPRINTF_NOCONTEXT;
529 va_start(arglist, format);
530 ret = PerlIO_vprintf(stream, format, arglist);
536 Perl_printf_nocontext(const char *format, ...)
542 #ifdef PERL_IMPLICIT_CONTEXT
543 PERL_ARGS_ASSERT_PRINTF_NOCONTEXT;
546 va_start(arglist, format);
547 ret = PerlIO_vprintf(PerlIO_stdout(), format, arglist);
552 #if defined(HUGE_VAL) || (defined(USE_LONG_DOUBLE) && defined(HUGE_VALL))
554 * This hack is to force load of "huge" support from libm.a
555 * So it is in perl for (say) POSIX to use.
556 * Needed for SunOS with Sun's 'acc' for example.
561 # if defined(USE_LONG_DOUBLE) && defined(HUGE_VALL)
569 /* compatibility with versions <= 5.003. */
571 Perl_gv_fullname(pTHX_ SV *sv, const GV *gv)
573 PERL_ARGS_ASSERT_GV_FULLNAME;
575 gv_fullname3(sv, gv, sv == (const SV*)gv ? "*" : "");
578 /* compatibility with versions <= 5.003. */
580 Perl_gv_efullname(pTHX_ SV *sv, const GV *gv)
582 PERL_ARGS_ASSERT_GV_EFULLNAME;
584 gv_efullname3(sv, gv, sv == (const SV*)gv ? "*" : "");
588 Perl_gv_fullname3(pTHX_ SV *sv, const GV *gv, const char *prefix)
590 PERL_ARGS_ASSERT_GV_FULLNAME3;
592 gv_fullname4(sv, gv, prefix, TRUE);
596 Perl_gv_efullname3(pTHX_ SV *sv, const GV *gv, const char *prefix)
598 PERL_ARGS_ASSERT_GV_EFULLNAME3;
600 gv_efullname4(sv, gv, prefix, TRUE);
604 =for apidoc gv_fetchmethod
606 See L</gv_fetchmethod_autoload>.
612 Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name)
614 PERL_ARGS_ASSERT_GV_FETCHMETHOD;
616 return gv_fetchmethod_autoload(stash, name, TRUE);
620 Perl_hv_iternext(pTHX_ HV *hv)
622 PERL_ARGS_ASSERT_HV_ITERNEXT;
624 return hv_iternext_flags(hv, 0);
628 Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how)
630 PERL_ARGS_ASSERT_HV_MAGIC;
632 sv_magic(MUTABLE_SV(hv), MUTABLE_SV(gv), how, NULL, 0);
636 Perl_do_open(pTHX_ GV *gv, const char *name, I32 len, int as_raw,
637 int rawmode, int rawperm, PerlIO *supplied_fp)
639 PERL_ARGS_ASSERT_DO_OPEN;
641 return do_openn(gv, name, len, as_raw, rawmode, rawperm,
642 supplied_fp, (SV **) NULL, 0);
646 Perl_do_open9(pTHX_ GV *gv, const char *name, I32 len, int
648 int rawmode, int rawperm, PerlIO *supplied_fp, SV *svs,
651 PERL_ARGS_ASSERT_DO_OPEN9;
653 PERL_UNUSED_ARG(num_svs);
654 return do_openn(gv, name, len, as_raw, rawmode, rawperm,
655 supplied_fp, &svs, 1);
659 Perl_do_binmode(pTHX_ PerlIO *fp, int iotype, int mode)
661 /* The old body of this is now in non-LAYER part of perlio.c
662 * This is a stub for any XS code which might have been calling it.
664 const char *name = ":raw";
666 PERL_ARGS_ASSERT_DO_BINMODE;
668 #ifdef PERLIO_USING_CRLF
669 if (!(mode & O_BINARY))
672 return PerlIO_binmode(aTHX_ fp, iotype, mode, name);
677 Perl_do_aexec(pTHX_ SV *really, SV **mark, SV **sp)
679 PERL_ARGS_ASSERT_DO_AEXEC;
681 return do_aexec5(really, mark, sp, 0, 0);
685 /* Backwards compatibility. */
687 Perl_init_i18nl14n(pTHX_ int printwarn)
689 return init_i18nl10n(printwarn);
693 Perl_is_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep)
695 PERL_ARGS_ASSERT_IS_UTF8_STRING_LOC;
697 return is_utf8_string_loclen(s, len, ep, 0);
701 =for apidoc sv_nolocking
703 Dummy routine which "locks" an SV when there is no locking module present.
704 Exists to avoid test for a C<NULL> function pointer and because it could
705 potentially warn under some level of strict-ness.
707 "Superseded" by C<sv_nosharing()>.
713 Perl_sv_nolocking(pTHX_ SV *sv)
721 =for apidoc sv_nounlocking
723 Dummy routine which "unlocks" an SV when there is no locking module present.
724 Exists to avoid test for a C<NULL> function pointer and because it could
725 potentially warn under some level of strict-ness.
727 "Superseded" by C<sv_nosharing()>.
733 Perl_sv_nounlocking(pTHX_ SV *sv)
740 Perl_save_long(pTHX_ long int *longp)
742 PERL_ARGS_ASSERT_SAVE_LONG;
747 SSPUSHUV(SAVEt_LONG);
751 Perl_save_iv(pTHX_ IV *ivp)
753 PERL_ARGS_ASSERT_SAVE_IV;
762 Perl_save_nogv(pTHX_ GV *gv)
764 PERL_ARGS_ASSERT_SAVE_NOGV;
768 SSPUSHUV(SAVEt_NSTAB);
772 Perl_save_list(pTHX_ SV **sarg, I32 maxsarg)
776 PERL_ARGS_ASSERT_SAVE_LIST;
778 for (i = 1; i <= maxsarg; i++) {
782 sv_setsv_nomg(sv,sarg[i]);
784 SSPUSHPTR(sarg[i]); /* remember the pointer */
785 SSPUSHPTR(sv); /* remember the value */
786 SSPUSHUV(SAVEt_ITEM);
791 =for apidoc sv_usepvn_mg
793 Like C<sv_usepvn>, but also handles 'set' magic.
799 Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len)
801 PERL_ARGS_ASSERT_SV_USEPVN_MG;
803 sv_usepvn_flags(sv,ptr,len, SV_SMAGIC);
807 =for apidoc sv_usepvn
809 Tells an SV to use C<ptr> to find its string value. Implemented by
810 calling C<sv_usepvn_flags> with C<flags> of 0, hence does not handle 'set'
811 magic. See C<L</sv_usepvn_flags>>.
817 Perl_sv_usepvn(pTHX_ SV *sv, char *ptr, STRLEN len)
819 PERL_ARGS_ASSERT_SV_USEPVN;
821 sv_usepvn_flags(sv,ptr,len, 0);
825 =for apidoc unpack_str
827 The engine implementing C<unpack()> Perl function. Note: parameters C<strbeg>,
828 C<new_s> and C<ocnt> are not used. This call should not be used, use
829 C<unpackstring> instead.
834 Perl_unpack_str(pTHX_ const char *pat, const char *patend, const char *s,
835 const char *strbeg, const char *strend, char **new_s, I32 ocnt,
838 PERL_ARGS_ASSERT_UNPACK_STR;
840 PERL_UNUSED_ARG(strbeg);
841 PERL_UNUSED_ARG(new_s);
842 PERL_UNUSED_ARG(ocnt);
844 return unpackstring(pat, patend, s, strend, flags);
850 The engine implementing C<pack()> Perl function. Note: parameters
851 C<next_in_list> and C<flags> are not used. This call should not be used; use
858 Perl_pack_cat(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist, SV ***next_in_list, U32 flags)
860 PERL_ARGS_ASSERT_PACK_CAT;
862 PERL_UNUSED_ARG(next_in_list);
863 PERL_UNUSED_ARG(flags);
865 packlist(cat, pat, patend, beglist, endlist);
869 Perl_hv_store_ent(pTHX_ HV *hv, SV *keysv, SV *val, U32 hash)
871 return (HE *)hv_common(hv, keysv, NULL, 0, 0, HV_FETCH_ISSTORE, val, hash);
875 Perl_hv_exists_ent(pTHX_ HV *hv, SV *keysv, U32 hash)
877 PERL_ARGS_ASSERT_HV_EXISTS_ENT;
879 return hv_common(hv, keysv, NULL, 0, 0, HV_FETCH_ISEXISTS, 0, hash)
884 Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, U32 hash)
886 PERL_ARGS_ASSERT_HV_FETCH_ENT;
888 return (HE *)hv_common(hv, keysv, NULL, 0, 0,
889 (lval ? HV_FETCH_LVALUE : 0), NULL, hash);
893 Perl_hv_delete_ent(pTHX_ HV *hv, SV *keysv, I32 flags, U32 hash)
895 PERL_ARGS_ASSERT_HV_DELETE_ENT;
897 return MUTABLE_SV(hv_common(hv, keysv, NULL, 0, 0, flags | HV_DELETE, NULL,
902 Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash,
905 return (SV**) hv_common(hv, NULL, key, klen, flags,
906 (HV_FETCH_ISSTORE|HV_FETCH_JUST_SV), val, hash);
910 Perl_hv_store(pTHX_ HV *hv, const char *key, I32 klen_i32, SV *val, U32 hash)
922 return (SV **) hv_common(hv, NULL, key, klen, flags,
923 (HV_FETCH_ISSTORE|HV_FETCH_JUST_SV), val, hash);
927 Perl_hv_exists(pTHX_ HV *hv, const char *key, I32 klen_i32)
932 PERL_ARGS_ASSERT_HV_EXISTS;
941 return hv_common(hv, NULL, key, klen, flags, HV_FETCH_ISEXISTS, 0, 0)
946 Perl_hv_fetch(pTHX_ HV *hv, const char *key, I32 klen_i32, I32 lval)
951 PERL_ARGS_ASSERT_HV_FETCH;
960 return (SV **) hv_common(hv, NULL, key, klen, flags,
961 lval ? (HV_FETCH_JUST_SV | HV_FETCH_LVALUE)
962 : HV_FETCH_JUST_SV, NULL, 0);
966 Perl_hv_delete(pTHX_ HV *hv, const char *key, I32 klen_i32, I32 flags)
971 PERL_ARGS_ASSERT_HV_DELETE;
975 k_flags = HVhek_UTF8;
980 return MUTABLE_SV(hv_common(hv, NULL, key, klen, k_flags, flags | HV_DELETE,
987 return MUTABLE_AV(newSV_type(SVt_PVAV));
988 /* sv_upgrade does AvREAL_only():
991 AvMAX(av) = AvFILLp(av) = -1; */
997 HV * const hv = MUTABLE_HV(newSV_type(SVt_PVHV));
1004 Perl_sv_insert(pTHX_ SV *const bigstr, const STRLEN offset, const STRLEN len,
1005 const char *const little, const STRLEN littlelen)
1007 PERL_ARGS_ASSERT_SV_INSERT;
1008 sv_insert_flags(bigstr, offset, len, little, littlelen, SV_GMAGIC);
1012 Perl_save_freesv(pTHX_ SV *sv)
1018 Perl_save_mortalizesv(pTHX_ SV *sv)
1020 PERL_ARGS_ASSERT_SAVE_MORTALIZESV;
1022 save_mortalizesv(sv);
1026 Perl_save_freeop(pTHX_ OP *o)
1032 Perl_save_freepv(pTHX_ char *pv)
1043 #ifdef PERL_DONT_CREATE_GVSV
1045 Perl_gv_SVadd(pTHX_ GV *gv)
1047 return gv_SVadd(gv);
1052 Perl_gv_AVadd(pTHX_ GV *gv)
1054 return gv_AVadd(gv);
1058 Perl_gv_HVadd(pTHX_ GV *gv)
1060 return gv_HVadd(gv);
1064 Perl_gv_IOadd(pTHX_ GV *gv)
1066 return gv_IOadd(gv);
1072 return MUTABLE_IO(newSV_type(SVt_PVIO));
1078 return my_stat_flags(SV_GMAGIC);
1084 return my_lstat_flags(SV_GMAGIC);
1088 Perl_sv_eq(pTHX_ SV *sv1, SV *sv2)
1090 return sv_eq_flags(sv1, sv2, SV_GMAGIC);
1093 #ifdef USE_LOCALE_COLLATE
1095 Perl_sv_collxfrm(pTHX_ SV *const sv, STRLEN *const nxp)
1097 return sv_collxfrm_flags(sv, nxp, SV_GMAGIC);
1101 Perl_mem_collxfrm(pTHX_ const char *input_string, STRLEN len, STRLEN *xlen)
1103 /* This function is retained for compatibility in case someone outside core
1104 * is using this (but it is undocumented) */
1106 PERL_ARGS_ASSERT_MEM_COLLXFRM;
1108 return _mem_collxfrm(input_string, len, xlen, FALSE);
1114 Perl_sv_2bool(pTHX_ SV *const sv)
1116 return sv_2bool_flags(sv, SV_GMAGIC);
1121 =for apidoc custom_op_name
1122 Return the name for a given custom op. This was once used by the C<OP_NAME>
1123 macro, but is no longer: it has only been kept for compatibility, and
1126 =for apidoc custom_op_desc
1127 Return the description of a given custom op. This was once used by the
1128 C<OP_DESC> macro, but is no longer: it has only been kept for
1129 compatibility, and should not be used.
1135 Perl_custom_op_name(pTHX_ const OP* o)
1137 PERL_ARGS_ASSERT_CUSTOM_OP_NAME;
1138 return XopENTRYCUSTOM(o, xop_name);
1142 Perl_custom_op_desc(pTHX_ const OP* o)
1144 PERL_ARGS_ASSERT_CUSTOM_OP_DESC;
1145 return XopENTRYCUSTOM(o, xop_desc);
1149 Perl_newSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *block)
1151 return newATTRSUB(floor, o, proto, NULL, block);
1155 Perl_to_utf8_fold(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp)
1157 PERL_ARGS_ASSERT_TO_UTF8_FOLD;
1159 return _to_utf8_fold_flags(p, ustrp, lenp, FOLD_FLAGS_FULL);
1163 Perl_to_utf8_lower(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp)
1165 PERL_ARGS_ASSERT_TO_UTF8_LOWER;
1167 return _to_utf8_lower_flags(p, ustrp, lenp, FALSE);
1171 Perl_to_utf8_title(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp)
1173 PERL_ARGS_ASSERT_TO_UTF8_TITLE;
1175 return _to_utf8_title_flags(p, ustrp, lenp, FALSE);
1179 Perl_to_utf8_upper(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp)
1181 PERL_ARGS_ASSERT_TO_UTF8_UPPER;
1183 return _to_utf8_upper_flags(p, ustrp, lenp, FALSE);
1187 Perl_sv_mortalcopy(pTHX_ SV *const oldstr)
1189 return Perl_sv_mortalcopy_flags(aTHX_ oldstr, SV_GMAGIC);
1193 Perl_sv_copypv(pTHX_ SV *const dsv, SV *const ssv)
1195 PERL_ARGS_ASSERT_SV_COPYPV;
1197 sv_copypv_flags(dsv, ssv, 0);
1200 UV /* Made into a function, so can be deprecated */
1201 NATIVE_TO_NEED(const UV enc, const UV ch)
1203 PERL_UNUSED_ARG(enc);
1207 UV /* Made into a function, so can be deprecated */
1208 ASCII_TO_NEED(const UV enc, const UV ch)
1210 PERL_UNUSED_ARG(enc);
1214 bool /* Made into a function, so can be deprecated */
1215 Perl_isIDFIRST_lazy(pTHX_ const char* p)
1217 PERL_ARGS_ASSERT_ISIDFIRST_LAZY;
1219 return isIDFIRST_lazy_if(p,1);
1222 bool /* Made into a function, so can be deprecated */
1223 Perl_isALNUM_lazy(pTHX_ const char* p)
1225 PERL_ARGS_ASSERT_ISALNUM_LAZY;
1227 return isALNUM_lazy_if(p,1);
1231 Perl_is_uni_alnum(pTHX_ UV c)
1233 return isWORDCHAR_uni(c);
1237 Perl_is_uni_alnumc(pTHX_ UV c)
1239 return isALNUM_uni(c);
1243 Perl_is_uni_alpha(pTHX_ UV c)
1245 return isALPHA_uni(c);
1249 Perl_is_uni_ascii(pTHX_ UV c)
1251 PERL_UNUSED_CONTEXT;
1252 return isASCII_uni(c);
1256 Perl_is_uni_blank(pTHX_ UV c)
1258 PERL_UNUSED_CONTEXT;
1259 return isBLANK_uni(c);
1263 Perl_is_uni_space(pTHX_ UV c)
1265 PERL_UNUSED_CONTEXT;
1266 return isSPACE_uni(c);
1270 Perl_is_uni_digit(pTHX_ UV c)
1272 PERL_UNUSED_CONTEXT;
1273 return isDIGIT_uni(c);
1277 Perl_is_uni_upper(pTHX_ UV c)
1279 PERL_UNUSED_CONTEXT;
1280 return isUPPER_uni(c);
1284 Perl_is_uni_lower(pTHX_ UV c)
1286 PERL_UNUSED_CONTEXT;
1287 return isLOWER_uni(c);
1291 Perl_is_uni_cntrl(pTHX_ UV c)
1293 PERL_UNUSED_CONTEXT;
1294 return isCNTRL_L1(c);
1298 Perl_is_uni_graph(pTHX_ UV c)
1300 PERL_UNUSED_CONTEXT;
1301 return isGRAPH_uni(c);
1305 Perl_is_uni_print(pTHX_ UV c)
1307 PERL_UNUSED_CONTEXT;
1308 return isPRINT_uni(c);
1312 Perl_is_uni_punct(pTHX_ UV c)
1314 PERL_UNUSED_CONTEXT;
1315 return isPUNCT_uni(c);
1319 Perl_is_uni_xdigit(pTHX_ UV c)
1321 PERL_UNUSED_CONTEXT;
1322 return isXDIGIT_uni(c);
1326 Perl_is_uni_alnum_lc(pTHX_ UV c)
1328 PERL_UNUSED_CONTEXT;
1329 return isWORDCHAR_LC_uvchr(c);
1333 Perl_is_uni_alnumc_lc(pTHX_ UV c)
1335 PERL_UNUSED_CONTEXT;
1336 return isALPHANUMERIC_LC_uvchr(c);
1340 Perl_is_uni_idfirst_lc(pTHX_ UV c)
1342 PERL_UNUSED_CONTEXT;
1343 /* XXX Should probably be something that resolves to the old IDFIRST, but
1344 * this function is deprecated, so not bothering */
1345 return isIDFIRST_LC_uvchr(c);
1349 Perl_is_uni_alpha_lc(pTHX_ UV c)
1351 PERL_UNUSED_CONTEXT;
1352 return isALPHA_LC_uvchr(c);
1356 Perl_is_uni_ascii_lc(pTHX_ UV c)
1358 PERL_UNUSED_CONTEXT;
1359 return isASCII_LC_uvchr(c);
1363 Perl_is_uni_blank_lc(pTHX_ UV c)
1365 PERL_UNUSED_CONTEXT;
1366 return isBLANK_LC_uvchr(c);
1370 Perl_is_uni_space_lc(pTHX_ UV c)
1372 PERL_UNUSED_CONTEXT;
1373 return isSPACE_LC_uvchr(c);
1377 Perl_is_uni_digit_lc(pTHX_ UV c)
1379 return isDIGIT_LC_uvchr(c);
1383 Perl_is_uni_idfirst(pTHX_ UV c)
1385 U8 tmpbuf[UTF8_MAXBYTES+1];
1386 uvchr_to_utf8(tmpbuf, c);
1387 return _is_utf8_idstart(tmpbuf);
1391 Perl_is_utf8_idfirst(pTHX_ const U8 *p) /* The naming is historical. */
1393 PERL_ARGS_ASSERT_IS_UTF8_IDFIRST;
1395 return _is_utf8_idstart(p);
1399 Perl_is_utf8_xidfirst(pTHX_ const U8 *p) /* The naming is historical. */
1401 PERL_ARGS_ASSERT_IS_UTF8_XIDFIRST;
1403 return _is_utf8_xidstart(p);
1407 Perl_is_utf8_idcont(pTHX_ const U8 *p)
1409 PERL_ARGS_ASSERT_IS_UTF8_IDCONT;
1411 return _is_utf8_idcont(p);
1415 Perl_is_utf8_xidcont(pTHX_ const U8 *p)
1417 PERL_ARGS_ASSERT_IS_UTF8_XIDCONT;
1419 return _is_utf8_xidcont(p);
1423 Perl_is_uni_upper_lc(pTHX_ UV c)
1425 return isUPPER_LC_uvchr(c);
1429 Perl_is_uni_lower_lc(pTHX_ UV c)
1431 return isLOWER_LC_uvchr(c);
1435 Perl_is_uni_cntrl_lc(pTHX_ UV c)
1437 return isCNTRL_LC_uvchr(c);
1441 Perl_is_uni_graph_lc(pTHX_ UV c)
1443 return isGRAPH_LC_uvchr(c);
1447 Perl_is_uni_print_lc(pTHX_ UV c)
1449 return isPRINT_LC_uvchr(c);
1453 Perl_is_uni_punct_lc(pTHX_ UV c)
1455 return isPUNCT_LC_uvchr(c);
1459 Perl_is_uni_xdigit_lc(pTHX_ UV c)
1461 return isXDIGIT_LC_uvchr(c);
1465 Perl_to_uni_upper_lc(pTHX_ U32 c)
1467 /* XXX returns only the first character -- do not use XXX */
1468 /* XXX no locale support yet */
1470 U8 tmpbuf[UTF8_MAXBYTES_CASE+1];
1471 return (U32)to_uni_upper(c, tmpbuf, &len);
1475 Perl_to_uni_title_lc(pTHX_ U32 c)
1477 /* XXX returns only the first character XXX -- do not use XXX */
1478 /* XXX no locale support yet */
1480 U8 tmpbuf[UTF8_MAXBYTES_CASE+1];
1481 return (U32)to_uni_title(c, tmpbuf, &len);
1485 Perl_to_uni_lower_lc(pTHX_ U32 c)
1487 /* XXX returns only the first character -- do not use XXX */
1488 /* XXX no locale support yet */
1490 U8 tmpbuf[UTF8_MAXBYTES_CASE+1];
1491 return (U32)to_uni_lower(c, tmpbuf, &len);
1495 Perl_is_utf8_alnum(pTHX_ const U8 *p)
1497 PERL_ARGS_ASSERT_IS_UTF8_ALNUM;
1499 /* NOTE: "IsWord", not "IsAlnum", since Alnum is a true
1500 * descendant of isalnum(3), in other words, it doesn't
1501 * contain the '_'. --jhi */
1502 return isWORDCHAR_utf8(p);
1506 Perl_is_utf8_alnumc(pTHX_ const U8 *p)
1508 PERL_ARGS_ASSERT_IS_UTF8_ALNUMC;
1510 return isALPHANUMERIC_utf8(p);
1514 Perl_is_utf8_alpha(pTHX_ const U8 *p)
1516 PERL_ARGS_ASSERT_IS_UTF8_ALPHA;
1518 return isALPHA_utf8(p);
1522 Perl_is_utf8_ascii(pTHX_ const U8 *p)
1524 PERL_ARGS_ASSERT_IS_UTF8_ASCII;
1525 PERL_UNUSED_CONTEXT;
1527 return isASCII_utf8(p);
1531 Perl_is_utf8_blank(pTHX_ const U8 *p)
1533 PERL_ARGS_ASSERT_IS_UTF8_BLANK;
1534 PERL_UNUSED_CONTEXT;
1536 return isBLANK_utf8(p);
1540 Perl_is_utf8_space(pTHX_ const U8 *p)
1542 PERL_ARGS_ASSERT_IS_UTF8_SPACE;
1543 PERL_UNUSED_CONTEXT;
1545 return isSPACE_utf8(p);
1549 Perl_is_utf8_perl_space(pTHX_ const U8 *p)
1551 PERL_ARGS_ASSERT_IS_UTF8_PERL_SPACE;
1552 PERL_UNUSED_CONTEXT;
1554 /* Only true if is an ASCII space-like character, and ASCII is invariant
1555 * under utf8, so can just use the macro */
1556 return isSPACE_A(*p);
1560 Perl_is_utf8_perl_word(pTHX_ const U8 *p)
1562 PERL_ARGS_ASSERT_IS_UTF8_PERL_WORD;
1563 PERL_UNUSED_CONTEXT;
1565 /* Only true if is an ASCII word character, and ASCII is invariant
1566 * under utf8, so can just use the macro */
1567 return isWORDCHAR_A(*p);
1571 Perl_is_utf8_digit(pTHX_ const U8 *p)
1573 PERL_ARGS_ASSERT_IS_UTF8_DIGIT;
1575 return isDIGIT_utf8(p);
1579 Perl_is_utf8_posix_digit(pTHX_ const U8 *p)
1581 PERL_ARGS_ASSERT_IS_UTF8_POSIX_DIGIT;
1582 PERL_UNUSED_CONTEXT;
1584 /* Only true if is an ASCII digit character, and ASCII is invariant
1585 * under utf8, so can just use the macro */
1586 return isDIGIT_A(*p);
1590 Perl_is_utf8_upper(pTHX_ const U8 *p)
1592 PERL_ARGS_ASSERT_IS_UTF8_UPPER;
1594 return isUPPER_utf8(p);
1598 Perl_is_utf8_lower(pTHX_ const U8 *p)
1600 PERL_ARGS_ASSERT_IS_UTF8_LOWER;
1602 return isLOWER_utf8(p);
1606 Perl_is_utf8_cntrl(pTHX_ const U8 *p)
1608 PERL_ARGS_ASSERT_IS_UTF8_CNTRL;
1609 PERL_UNUSED_CONTEXT;
1611 return isCNTRL_utf8(p);
1615 Perl_is_utf8_graph(pTHX_ const U8 *p)
1617 PERL_ARGS_ASSERT_IS_UTF8_GRAPH;
1619 return isGRAPH_utf8(p);
1623 Perl_is_utf8_print(pTHX_ const U8 *p)
1625 PERL_ARGS_ASSERT_IS_UTF8_PRINT;
1627 return isPRINT_utf8(p);
1631 Perl_is_utf8_punct(pTHX_ const U8 *p)
1633 PERL_ARGS_ASSERT_IS_UTF8_PUNCT;
1635 return isPUNCT_utf8(p);
1639 Perl_is_utf8_xdigit(pTHX_ const U8 *p)
1641 PERL_ARGS_ASSERT_IS_UTF8_XDIGIT;
1642 PERL_UNUSED_CONTEXT;
1644 return isXDIGIT_utf8(p);
1648 Perl_is_utf8_mark(pTHX_ const U8 *p)
1650 PERL_ARGS_ASSERT_IS_UTF8_MARK;
1652 return _is_utf8_mark(p);
1656 =for apidoc is_utf8_char
1658 Tests if some arbitrary number of bytes begins in a valid UTF-8
1659 character. Note that an INVARIANT (i.e. ASCII on non-EBCDIC machines)
1660 character is a valid UTF-8 character. The actual number of bytes in the UTF-8
1661 character will be returned if it is valid, otherwise 0.
1663 This function is deprecated due to the possibility that malformed input could
1664 cause reading beyond the end of the input buffer. Use L</isUTF8_CHAR>
1670 Perl_is_utf8_char(const U8 *s)
1672 PERL_ARGS_ASSERT_IS_UTF8_CHAR;
1674 /* Assumes we have enough space, which is why this is deprecated */
1675 return isUTF8_CHAR(s, s + UTF8SKIP(s));
1679 =for apidoc is_utf8_char_buf
1681 This is identical to the macro L</isUTF8_CHAR>.
1686 Perl_is_utf8_char_buf(const U8 *buf, const U8* buf_end)
1689 PERL_ARGS_ASSERT_IS_UTF8_CHAR_BUF;
1691 return isUTF8_CHAR(buf, buf_end);
1695 * Like L</utf8_to_uvuni_buf>(), but should only be called when it is known that
1696 * there are no malformations in the input UTF-8 string C<s>. Surrogates,
1697 * non-character code points, and non-Unicode code points are allowed */
1700 Perl_valid_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen)
1702 PERL_ARGS_ASSERT_VALID_UTF8_TO_UVUNI;
1704 return NATIVE_TO_UNI(valid_utf8_to_uvchr(s, retlen));
1708 =for apidoc utf8_to_uvchr
1710 Returns the native code point of the first character in the string C<s>
1711 which is assumed to be in UTF-8 encoding; C<retlen> will be set to the
1712 length, in bytes, of that character.
1714 Some, but not all, UTF-8 malformations are detected, and in fact, some
1715 malformed input could cause reading beyond the end of the input buffer, which
1716 is why this function is deprecated. Use L</utf8_to_uvchr_buf> instead.
1718 If C<s> points to one of the detected malformations, and UTF8 warnings are
1719 enabled, zero is returned and C<*retlen> is set (if C<retlen> isn't
1720 C<NULL>) to -1. If those warnings are off, the computed value if well-defined (or
1721 the Unicode REPLACEMENT CHARACTER, if not) is silently returned, and C<*retlen>
1722 is set (if C<retlen> isn't NULL) so that (S<C<s> + C<*retlen>>) is the
1723 next possible position in C<s> that could begin a non-malformed character.
1724 See L</utf8n_to_uvchr> for details on when the REPLACEMENT CHARACTER is returned.
1730 Perl_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen)
1732 PERL_ARGS_ASSERT_UTF8_TO_UVCHR;
1734 return utf8_to_uvchr_buf(s, s + UTF8_MAXBYTES, retlen);
1738 =for apidoc utf8_to_uvuni
1740 Returns the Unicode code point of the first character in the string C<s>
1741 which is assumed to be in UTF-8 encoding; C<retlen> will be set to the
1742 length, in bytes, of that character.
1744 Some, but not all, UTF-8 malformations are detected, and in fact, some
1745 malformed input could cause reading beyond the end of the input buffer, which
1746 is one reason why this function is deprecated. The other is that only in
1747 extremely limited circumstances should the Unicode versus native code point be
1748 of any interest to you. See L</utf8_to_uvuni_buf> for alternatives.
1750 If C<s> points to one of the detected malformations, and UTF8 warnings are
1751 enabled, zero is returned and C<*retlen> is set (if C<retlen> doesn't point to
1752 NULL) to -1. If those warnings are off, the computed value if well-defined (or
1753 the Unicode REPLACEMENT CHARACTER, if not) is silently returned, and C<*retlen>
1754 is set (if C<retlen> isn't NULL) so that (S<C<s> + C<*retlen>>) is the
1755 next possible position in C<s> that could begin a non-malformed character.
1756 See L</utf8n_to_uvchr> for details on when the REPLACEMENT CHARACTER is returned.
1762 Perl_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen)
1764 PERL_ARGS_ASSERT_UTF8_TO_UVUNI;
1766 return NATIVE_TO_UNI(valid_utf8_to_uvchr(s, retlen));
1770 =for apidoc Am|HV *|pad_compname_type|PADOFFSET po
1772 Looks up the type of the lexical variable at position C<po> in the
1773 currently-compiling pad. If the variable is typed, the stash of the
1774 class to which it is typed is returned. If not, C<NULL> is returned.
1780 Perl_pad_compname_type(pTHX_ const PADOFFSET po)
1782 return PAD_COMPNAME_TYPE(po);
1785 /* return ptr to little string in big string, NULL if not found */
1786 /* The original version of this routine was donated by Corey Satten. */
1789 Perl_instr(const char *big, const char *little)
1791 PERL_ARGS_ASSERT_INSTR;
1793 return instr((char *) big, (char *) little);
1796 #endif /* NO_MATHOMS */
1799 * ex: set ts=8 sts=4 sw=4 et: