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. For binary or source compatibility reasons, though,
25 * we cannot completely remove them from the core code.
29 * The compilation of this file can be suppressed; see INSTALL
34 #define PERL_IN_MATHOMS_C
38 /* ..." warning: ISO C forbids an empty source file"
39 So make sure we have something in here by processing the headers anyway.
43 /* Not all of these have prototypes elsewhere, so do this to get
48 PERL_CALLCONV OP * Perl_ref(pTHX_ OP *o, I32 type);
49 PERL_CALLCONV void Perl_sv_unref(pTHX_ SV *sv);
50 PERL_CALLCONV void Perl_sv_taint(pTHX_ SV *sv);
51 PERL_CALLCONV IV Perl_sv_2iv(pTHX_ SV *sv);
52 PERL_CALLCONV UV Perl_sv_2uv(pTHX_ SV *sv);
53 PERL_CALLCONV NV Perl_sv_2nv(pTHX_ SV *sv);
54 PERL_CALLCONV char * Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp);
55 PERL_CALLCONV char * Perl_sv_2pv_nolen(pTHX_ SV *sv);
56 PERL_CALLCONV char * Perl_sv_2pvbyte_nolen(pTHX_ SV *sv);
57 PERL_CALLCONV char * Perl_sv_2pvutf8_nolen(pTHX_ SV *sv);
58 PERL_CALLCONV void Perl_sv_force_normal(pTHX_ SV *sv);
59 PERL_CALLCONV void Perl_sv_setsv(pTHX_ SV *dstr, SV *sstr);
60 PERL_CALLCONV void Perl_sv_catpvn(pTHX_ SV *dsv, const char* sstr, STRLEN slen);
61 PERL_CALLCONV void Perl_sv_catpvn_mg(pTHX_ SV *sv, const char *ptr, STRLEN len);
62 PERL_CALLCONV void Perl_sv_catsv(pTHX_ SV *dstr, SV *sstr);
63 PERL_CALLCONV void Perl_sv_catsv_mg(pTHX_ SV *dsv, SV *ssv);
64 PERL_CALLCONV char * Perl_sv_pv(pTHX_ SV *sv);
65 PERL_CALLCONV char * Perl_sv_pvn_force(pTHX_ SV *sv, STRLEN *lp);
66 PERL_CALLCONV char * Perl_sv_pvbyte(pTHX_ SV *sv);
67 PERL_CALLCONV char * Perl_sv_pvutf8(pTHX_ SV *sv);
68 PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade(pTHX_ SV *sv);
69 PERL_CALLCONV NV Perl_huge(void);
70 PERL_CALLCONV void Perl_gv_fullname3(pTHX_ SV *sv, const GV *gv, const char *prefix);
71 PERL_CALLCONV void Perl_gv_efullname3(pTHX_ SV *sv, const GV *gv, const char *prefix);
72 PERL_CALLCONV GV * Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name);
73 PERL_CALLCONV HE * Perl_hv_iternext(pTHX_ HV *hv);
74 PERL_CALLCONV void Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how);
75 PERL_CALLCONV bool Perl_do_open(pTHX_ GV *gv, const char *name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp);
76 PERL_CALLCONV bool Perl_do_aexec(pTHX_ SV *really, SV **mark, SV **sp);
77 PERL_CALLCONV U8 * Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv);
78 PERL_CALLCONV bool Perl_is_utf8_string_loc(pTHX_ const U8 *s, STRLEN len, const U8 **ep);
79 PERL_CALLCONV void Perl_sv_nolocking(pTHX_ SV *sv);
80 PERL_CALLCONV void Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len);
81 PERL_CALLCONV void Perl_sv_usepvn(pTHX_ SV *sv, char *ptr, STRLEN len);
82 PERL_CALLCONV int Perl_fprintf_nocontext(PerlIO *stream, const char *format, ...);
83 PERL_CALLCONV int Perl_printf_nocontext(const char *format, ...);
84 PERL_CALLCONV int Perl_magic_setglob(pTHX_ SV* sv, MAGIC* mg);
85 PERL_CALLCONV AV * Perl_newAV(pTHX);
86 PERL_CALLCONV HV * Perl_newHV(pTHX);
87 PERL_CALLCONV IO * Perl_newIO(pTHX);
88 PERL_CALLCONV I32 Perl_my_stat(pTHX);
89 PERL_CALLCONV I32 Perl_my_lstat(pTHX);
90 PERL_CALLCONV I32 Perl_sv_eq(pTHX_ SV *sv1, SV *sv2);
91 PERL_CALLCONV char * Perl_sv_collxfrm(pTHX_ SV *const sv, STRLEN *const nxp);
92 PERL_CALLCONV bool Perl_sv_2bool(pTHX_ SV *const sv);
93 PERL_CALLCONV CV * Perl_newSUB(pTHX_ I32 floor, OP* o, OP* proto, OP* block);
94 PERL_CALLCONV UV Perl_to_utf8_lower(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp);
95 PERL_CALLCONV UV Perl_to_utf8_title(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp);
96 PERL_CALLCONV UV Perl_to_utf8_upper(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp);
97 PERL_CALLCONV UV Perl_to_utf8_fold(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp);
98 PERL_CALLCONV SV *Perl_sv_mortalcopy(pTHX_ SV *const oldstr);
100 /* ref() is now a macro using Perl_doref;
101 * this version provided for binary compatibility only.
104 Perl_ref(pTHX_ OP *o, I32 type)
106 return doref(o, type, TRUE);
112 Unsets the RV status of the SV, and decrements the reference count of
113 whatever was being referenced by the RV. This can almost be thought of
114 as a reversal of C<newSVrv>. This is C<sv_unref_flags> with the C<flag>
115 being zero. See C<SvROK_off>.
121 Perl_sv_unref(pTHX_ SV *sv)
123 PERL_ARGS_ASSERT_SV_UNREF;
125 sv_unref_flags(sv, 0);
131 Taint an SV. Use C<SvTAINTED_on> instead.
137 Perl_sv_taint(pTHX_ SV *sv)
139 PERL_ARGS_ASSERT_SV_TAINT;
141 sv_magic((sv), NULL, PERL_MAGIC_taint, NULL, 0);
144 /* sv_2iv() is now a macro using Perl_sv_2iv_flags();
145 * this function provided for binary compatibility only
149 Perl_sv_2iv(pTHX_ SV *sv)
151 PERL_ARGS_ASSERT_SV_2IV;
153 return sv_2iv_flags(sv, SV_GMAGIC);
156 /* sv_2uv() is now a macro using Perl_sv_2uv_flags();
157 * this function provided for binary compatibility only
161 Perl_sv_2uv(pTHX_ SV *sv)
163 PERL_ARGS_ASSERT_SV_2UV;
165 return sv_2uv_flags(sv, SV_GMAGIC);
168 /* sv_2nv() is now a macro using Perl_sv_2nv_flags();
169 * this function provided for binary compatibility only
173 Perl_sv_2nv(pTHX_ SV *sv)
175 return sv_2nv_flags(sv, SV_GMAGIC);
179 /* sv_2pv() is now a macro using Perl_sv_2pv_flags();
180 * this function provided for binary compatibility only
184 Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp)
186 PERL_ARGS_ASSERT_SV_2PV;
188 return sv_2pv_flags(sv, lp, SV_GMAGIC);
192 =for apidoc sv_2pv_nolen
194 Like C<sv_2pv()>, but doesn't return the length too. You should usually
195 use the macro wrapper C<SvPV_nolen(sv)> instead.
201 Perl_sv_2pv_nolen(pTHX_ SV *sv)
203 PERL_ARGS_ASSERT_SV_2PV_NOLEN;
204 return sv_2pv(sv, NULL);
208 =for apidoc sv_2pvbyte_nolen
210 Return a pointer to the byte-encoded representation of the SV.
211 May cause the SV to be downgraded from UTF-8 as a side-effect.
213 Usually accessed via the C<SvPVbyte_nolen> macro.
219 Perl_sv_2pvbyte_nolen(pTHX_ SV *sv)
221 PERL_ARGS_ASSERT_SV_2PVBYTE_NOLEN;
223 return sv_2pvbyte(sv, NULL);
227 =for apidoc sv_2pvutf8_nolen
229 Return a pointer to the UTF-8-encoded representation of the SV.
230 May cause the SV to be upgraded to UTF-8 as a side-effect.
232 Usually accessed via the C<SvPVutf8_nolen> macro.
238 Perl_sv_2pvutf8_nolen(pTHX_ SV *sv)
240 PERL_ARGS_ASSERT_SV_2PVUTF8_NOLEN;
242 return sv_2pvutf8(sv, NULL);
246 =for apidoc sv_force_normal
248 Undo various types of fakery on an SV: if the PV is a shared string, make
249 a private copy; if we're a ref, stop refing; if we're a glob, downgrade to
250 an xpvmg. See also C<sv_force_normal_flags>.
256 Perl_sv_force_normal(pTHX_ SV *sv)
258 PERL_ARGS_ASSERT_SV_FORCE_NORMAL;
260 sv_force_normal_flags(sv, 0);
263 /* sv_setsv() is now a macro using Perl_sv_setsv_flags();
264 * this function provided for binary compatibility only
268 Perl_sv_setsv(pTHX_ SV *dstr, SV *sstr)
270 PERL_ARGS_ASSERT_SV_SETSV;
272 sv_setsv_flags(dstr, sstr, SV_GMAGIC);
275 /* sv_catpvn() is now a macro using Perl_sv_catpvn_flags();
276 * this function provided for binary compatibility only
280 Perl_sv_catpvn(pTHX_ SV *dsv, const char* sstr, STRLEN slen)
282 PERL_ARGS_ASSERT_SV_CATPVN;
284 sv_catpvn_flags(dsv, sstr, slen, SV_GMAGIC);
288 =for apidoc sv_catpvn_mg
290 Like C<sv_catpvn>, but also handles 'set' magic.
296 Perl_sv_catpvn_mg(pTHX_ SV *sv, const char *ptr, STRLEN len)
298 PERL_ARGS_ASSERT_SV_CATPVN_MG;
300 sv_catpvn_flags(sv,ptr,len,SV_GMAGIC|SV_SMAGIC);
303 /* sv_catsv() is now a macro using Perl_sv_catsv_flags();
304 * this function provided for binary compatibility only
308 Perl_sv_catsv(pTHX_ SV *dstr, SV *sstr)
310 PERL_ARGS_ASSERT_SV_CATSV;
312 sv_catsv_flags(dstr, sstr, SV_GMAGIC);
316 =for apidoc sv_catsv_mg
318 Like C<sv_catsv>, but also handles 'set' magic.
324 Perl_sv_catsv_mg(pTHX_ SV *dsv, SV *ssv)
326 PERL_ARGS_ASSERT_SV_CATSV_MG;
328 sv_catsv_flags(dsv,ssv,SV_GMAGIC|SV_SMAGIC);
334 A private implementation of the C<SvIVx> macro for compilers which can't
335 cope with complex macro expressions. Always use the macro instead.
341 Perl_sv_iv(pTHX_ SV *sv)
343 PERL_ARGS_ASSERT_SV_IV;
347 return (IV)SvUVX(sv);
356 A private implementation of the C<SvUVx> macro for compilers which can't
357 cope with complex macro expressions. Always use the macro instead.
363 Perl_sv_uv(pTHX_ SV *sv)
365 PERL_ARGS_ASSERT_SV_UV;
370 return (UV)SvIVX(sv);
378 A private implementation of the C<SvNVx> macro for compilers which can't
379 cope with complex macro expressions. Always use the macro instead.
385 Perl_sv_nv(pTHX_ SV *sv)
387 PERL_ARGS_ASSERT_SV_NV;
397 Use the C<SvPV_nolen> macro instead
401 A private implementation of the C<SvPV> macro for compilers which can't
402 cope with complex macro expressions. Always use the macro instead.
408 Perl_sv_pvn(pTHX_ SV *sv, STRLEN *lp)
410 PERL_ARGS_ASSERT_SV_PVN;
416 return sv_2pv(sv, lp);
421 Perl_sv_pvn_nomg(pTHX_ SV *sv, STRLEN *lp)
423 PERL_ARGS_ASSERT_SV_PVN_NOMG;
429 return sv_2pv_flags(sv, lp, 0);
432 /* sv_pv() is now a macro using SvPV_nolen();
433 * this function provided for binary compatibility only
437 Perl_sv_pv(pTHX_ SV *sv)
439 PERL_ARGS_ASSERT_SV_PV;
444 return sv_2pv(sv, NULL);
447 /* sv_pvn_force() is now a macro using Perl_sv_pvn_force_flags();
448 * this function provided for binary compatibility only
452 Perl_sv_pvn_force(pTHX_ SV *sv, STRLEN *lp)
454 PERL_ARGS_ASSERT_SV_PVN_FORCE;
456 return sv_pvn_force_flags(sv, lp, SV_GMAGIC);
459 /* sv_pvbyte () is now a macro using Perl_sv_2pv_flags();
460 * this function provided for binary compatibility only
464 Perl_sv_pvbyte(pTHX_ SV *sv)
466 PERL_ARGS_ASSERT_SV_PVBYTE;
468 sv_utf8_downgrade(sv, FALSE);
473 =for apidoc sv_pvbyte
475 Use C<SvPVbyte_nolen> instead.
477 =for apidoc sv_pvbyten
479 A private implementation of the C<SvPVbyte> macro for compilers
480 which can't cope with complex macro expressions. Always use the macro
487 Perl_sv_pvbyten(pTHX_ SV *sv, STRLEN *lp)
489 PERL_ARGS_ASSERT_SV_PVBYTEN;
491 sv_utf8_downgrade(sv, FALSE);
492 return sv_pvn(sv,lp);
495 /* sv_pvutf8 () is now a macro using Perl_sv_2pv_flags();
496 * this function provided for binary compatibility only
500 Perl_sv_pvutf8(pTHX_ SV *sv)
502 PERL_ARGS_ASSERT_SV_PVUTF8;
509 =for apidoc sv_pvutf8
511 Use the C<SvPVutf8_nolen> macro instead
513 =for apidoc sv_pvutf8n
515 A private implementation of the C<SvPVutf8> macro for compilers
516 which can't cope with complex macro expressions. Always use the macro
523 Perl_sv_pvutf8n(pTHX_ SV *sv, STRLEN *lp)
525 PERL_ARGS_ASSERT_SV_PVUTF8N;
528 return sv_pvn(sv,lp);
531 /* sv_utf8_upgrade() is now a macro using sv_utf8_upgrade_flags();
532 * this function provided for binary compatibility only
536 Perl_sv_utf8_upgrade(pTHX_ SV *sv)
538 PERL_ARGS_ASSERT_SV_UTF8_UPGRADE;
540 return sv_utf8_upgrade_flags(sv, SV_GMAGIC);
544 Perl_fprintf_nocontext(PerlIO *stream, const char *format, ...)
550 /* Easier to special case this here than in embed.pl. (Look at what it
551 generates for proto.h) */
552 #ifdef PERL_IMPLICIT_CONTEXT
553 PERL_ARGS_ASSERT_FPRINTF_NOCONTEXT;
556 va_start(arglist, format);
557 ret = PerlIO_vprintf(stream, format, arglist);
563 Perl_printf_nocontext(const char *format, ...)
569 #ifdef PERL_IMPLICIT_CONTEXT
570 PERL_ARGS_ASSERT_PRINTF_NOCONTEXT;
573 va_start(arglist, format);
574 ret = PerlIO_vprintf(PerlIO_stdout(), format, arglist);
579 #if defined(HUGE_VAL) || (defined(USE_LONG_DOUBLE) && defined(HUGE_VALL))
581 * This hack is to force load of "huge" support from libm.a
582 * So it is in perl for (say) POSIX to use.
583 * Needed for SunOS with Sun's 'acc' for example.
588 # if defined(USE_LONG_DOUBLE) && defined(HUGE_VALL)
596 /* compatibility with versions <= 5.003. */
598 Perl_gv_fullname(pTHX_ SV *sv, const GV *gv)
600 PERL_ARGS_ASSERT_GV_FULLNAME;
602 gv_fullname3(sv, gv, sv == (const SV*)gv ? "*" : "");
605 /* compatibility with versions <= 5.003. */
607 Perl_gv_efullname(pTHX_ SV *sv, const GV *gv)
609 PERL_ARGS_ASSERT_GV_EFULLNAME;
611 gv_efullname3(sv, gv, sv == (const SV*)gv ? "*" : "");
615 Perl_gv_fullname3(pTHX_ SV *sv, const GV *gv, const char *prefix)
617 PERL_ARGS_ASSERT_GV_FULLNAME3;
619 gv_fullname4(sv, gv, prefix, TRUE);
623 Perl_gv_efullname3(pTHX_ SV *sv, const GV *gv, const char *prefix)
625 PERL_ARGS_ASSERT_GV_EFULLNAME3;
627 gv_efullname4(sv, gv, prefix, TRUE);
631 =for apidoc gv_fetchmethod
633 See L</gv_fetchmethod_autoload>.
639 Perl_gv_fetchmethod(pTHX_ HV *stash, const char *name)
641 PERL_ARGS_ASSERT_GV_FETCHMETHOD;
643 return gv_fetchmethod_autoload(stash, name, TRUE);
647 Perl_hv_iternext(pTHX_ HV *hv)
649 PERL_ARGS_ASSERT_HV_ITERNEXT;
651 return hv_iternext_flags(hv, 0);
655 Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how)
657 PERL_ARGS_ASSERT_HV_MAGIC;
659 sv_magic(MUTABLE_SV(hv), MUTABLE_SV(gv), how, NULL, 0);
663 Perl_do_open(pTHX_ GV *gv, const char *name, I32 len, int as_raw,
664 int rawmode, int rawperm, PerlIO *supplied_fp)
666 PERL_ARGS_ASSERT_DO_OPEN;
668 return do_openn(gv, name, len, as_raw, rawmode, rawperm,
669 supplied_fp, (SV **) NULL, 0);
673 Perl_do_open9(pTHX_ GV *gv, const char *name, I32 len, int
675 int rawmode, int rawperm, PerlIO *supplied_fp, SV *svs,
678 PERL_ARGS_ASSERT_DO_OPEN9;
680 PERL_UNUSED_ARG(num_svs);
681 return do_openn(gv, name, len, as_raw, rawmode, rawperm,
682 supplied_fp, &svs, 1);
686 Perl_do_binmode(pTHX_ PerlIO *fp, int iotype, int mode)
688 /* The old body of this is now in non-LAYER part of perlio.c
689 * This is a stub for any XS code which might have been calling it.
691 const char *name = ":raw";
693 PERL_ARGS_ASSERT_DO_BINMODE;
695 #ifdef PERLIO_USING_CRLF
696 if (!(mode & O_BINARY))
699 return PerlIO_binmode(aTHX_ fp, iotype, mode, name);
704 Perl_do_aexec(pTHX_ SV *really, SV **mark, SV **sp)
706 PERL_ARGS_ASSERT_DO_AEXEC;
708 return do_aexec5(really, mark, sp, 0, 0);
712 /* Backwards compatibility. */
714 Perl_init_i18nl14n(pTHX_ int printwarn)
716 return init_i18nl10n(printwarn);
720 Perl_is_utf8_string_loc(pTHX_ const U8 *s, STRLEN len, const U8 **ep)
722 PERL_ARGS_ASSERT_IS_UTF8_STRING_LOC;
724 return is_utf8_string_loclen(s, len, ep, 0);
728 =for apidoc sv_nolocking
730 Dummy routine which "locks" an SV when there is no locking module present.
731 Exists to avoid test for a NULL function pointer and because it could
732 potentially warn under some level of strict-ness.
734 "Superseded" by sv_nosharing().
740 Perl_sv_nolocking(pTHX_ SV *sv)
748 =for apidoc sv_nounlocking
750 Dummy routine which "unlocks" an SV when there is no locking module present.
751 Exists to avoid test for a NULL function pointer and because it could
752 potentially warn under some level of strict-ness.
754 "Superseded" by sv_nosharing().
760 Perl_sv_nounlocking(pTHX_ SV *sv)
767 Perl_save_long(pTHX_ long int *longp)
771 PERL_ARGS_ASSERT_SAVE_LONG;
776 SSPUSHUV(SAVEt_LONG);
780 Perl_save_iv(pTHX_ IV *ivp)
784 PERL_ARGS_ASSERT_SAVE_IV;
793 Perl_save_nogv(pTHX_ GV *gv)
797 PERL_ARGS_ASSERT_SAVE_NOGV;
801 SSPUSHUV(SAVEt_NSTAB);
805 Perl_save_list(pTHX_ SV **sarg, I32 maxsarg)
810 PERL_ARGS_ASSERT_SAVE_LIST;
812 for (i = 1; i <= maxsarg; i++) {
816 sv_setsv_nomg(sv,sarg[i]);
818 SSPUSHPTR(sarg[i]); /* remember the pointer */
819 SSPUSHPTR(sv); /* remember the value */
820 SSPUSHUV(SAVEt_ITEM);
825 =for apidoc sv_usepvn_mg
827 Like C<sv_usepvn>, but also handles 'set' magic.
833 Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len)
835 PERL_ARGS_ASSERT_SV_USEPVN_MG;
837 sv_usepvn_flags(sv,ptr,len, SV_SMAGIC);
841 =for apidoc sv_usepvn
843 Tells an SV to use C<ptr> to find its string value. Implemented by
844 calling C<sv_usepvn_flags> with C<flags> of 0, hence does not handle 'set'
845 magic. See C<sv_usepvn_flags>.
851 Perl_sv_usepvn(pTHX_ SV *sv, char *ptr, STRLEN len)
853 PERL_ARGS_ASSERT_SV_USEPVN;
855 sv_usepvn_flags(sv,ptr,len, 0);
859 =for apidoc unpack_str
861 The engine implementing unpack() Perl function. Note: parameters strbeg,
862 new_s and ocnt are not used. This call should not be used, use
863 unpackstring instead.
868 Perl_unpack_str(pTHX_ const char *pat, const char *patend, const char *s,
869 const char *strbeg, const char *strend, char **new_s, I32 ocnt,
872 PERL_ARGS_ASSERT_UNPACK_STR;
874 PERL_UNUSED_ARG(strbeg);
875 PERL_UNUSED_ARG(new_s);
876 PERL_UNUSED_ARG(ocnt);
878 return unpackstring(pat, patend, s, strend, flags);
884 The engine implementing pack() Perl function. Note: parameters
885 next_in_list and flags are not used. This call should not be used; use
892 Perl_pack_cat(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist, SV ***next_in_list, U32 flags)
894 PERL_ARGS_ASSERT_PACK_CAT;
896 PERL_UNUSED_ARG(next_in_list);
897 PERL_UNUSED_ARG(flags);
899 packlist(cat, pat, patend, beglist, endlist);
903 Perl_hv_store_ent(pTHX_ HV *hv, SV *keysv, SV *val, U32 hash)
905 return (HE *)hv_common(hv, keysv, NULL, 0, 0, HV_FETCH_ISSTORE, val, hash);
909 Perl_hv_exists_ent(pTHX_ HV *hv, SV *keysv, U32 hash)
911 PERL_ARGS_ASSERT_HV_EXISTS_ENT;
913 return hv_common(hv, keysv, NULL, 0, 0, HV_FETCH_ISEXISTS, 0, hash)
918 Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, U32 hash)
920 PERL_ARGS_ASSERT_HV_FETCH_ENT;
922 return (HE *)hv_common(hv, keysv, NULL, 0, 0,
923 (lval ? HV_FETCH_LVALUE : 0), NULL, hash);
927 Perl_hv_delete_ent(pTHX_ HV *hv, SV *keysv, I32 flags, U32 hash)
929 PERL_ARGS_ASSERT_HV_DELETE_ENT;
931 return MUTABLE_SV(hv_common(hv, keysv, NULL, 0, 0, flags | HV_DELETE, NULL,
936 Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash,
939 return (SV**) hv_common(hv, NULL, key, klen, flags,
940 (HV_FETCH_ISSTORE|HV_FETCH_JUST_SV), val, hash);
944 Perl_hv_store(pTHX_ HV *hv, const char *key, I32 klen_i32, SV *val, U32 hash)
956 return (SV **) hv_common(hv, NULL, key, klen, flags,
957 (HV_FETCH_ISSTORE|HV_FETCH_JUST_SV), val, hash);
961 Perl_hv_exists(pTHX_ HV *hv, const char *key, I32 klen_i32)
966 PERL_ARGS_ASSERT_HV_EXISTS;
975 return hv_common(hv, NULL, key, klen, flags, HV_FETCH_ISEXISTS, 0, 0)
980 Perl_hv_fetch(pTHX_ HV *hv, const char *key, I32 klen_i32, I32 lval)
985 PERL_ARGS_ASSERT_HV_FETCH;
994 return (SV **) hv_common(hv, NULL, key, klen, flags,
995 lval ? (HV_FETCH_JUST_SV | HV_FETCH_LVALUE)
996 : HV_FETCH_JUST_SV, NULL, 0);
1000 Perl_hv_delete(pTHX_ HV *hv, const char *key, I32 klen_i32, I32 flags)
1005 PERL_ARGS_ASSERT_HV_DELETE;
1009 k_flags = HVhek_UTF8;
1014 return MUTABLE_SV(hv_common(hv, NULL, key, klen, k_flags, flags | HV_DELETE,
1018 /* Functions after here were made mathoms post 5.10.0 but pre 5.8.9 */
1023 return MUTABLE_AV(newSV_type(SVt_PVAV));
1024 /* sv_upgrade does AvREAL_only():
1027 AvMAX(av) = AvFILLp(av) = -1; */
1033 HV * const hv = MUTABLE_HV(newSV_type(SVt_PVHV));
1040 Perl_sv_insert(pTHX_ SV *const bigstr, const STRLEN offset, const STRLEN len,
1041 const char *const little, const STRLEN littlelen)
1043 PERL_ARGS_ASSERT_SV_INSERT;
1044 sv_insert_flags(bigstr, offset, len, little, littlelen, SV_GMAGIC);
1048 Perl_save_freesv(pTHX_ SV *sv)
1055 Perl_save_mortalizesv(pTHX_ SV *sv)
1059 PERL_ARGS_ASSERT_SAVE_MORTALIZESV;
1061 save_mortalizesv(sv);
1065 Perl_save_freeop(pTHX_ OP *o)
1072 Perl_save_freepv(pTHX_ char *pv)
1085 #ifdef PERL_DONT_CREATE_GVSV
1087 Perl_gv_SVadd(pTHX_ GV *gv)
1089 return gv_SVadd(gv);
1094 Perl_gv_AVadd(pTHX_ GV *gv)
1096 return gv_AVadd(gv);
1100 Perl_gv_HVadd(pTHX_ GV *gv)
1102 return gv_HVadd(gv);
1106 Perl_gv_IOadd(pTHX_ GV *gv)
1108 return gv_IOadd(gv);
1114 return MUTABLE_IO(newSV_type(SVt_PVIO));
1120 return my_stat_flags(SV_GMAGIC);
1126 return my_lstat_flags(SV_GMAGIC);
1130 Perl_sv_eq(pTHX_ SV *sv1, SV *sv2)
1132 return sv_eq_flags(sv1, sv2, SV_GMAGIC);
1135 #ifdef USE_LOCALE_COLLATE
1137 Perl_sv_collxfrm(pTHX_ SV *const sv, STRLEN *const nxp)
1139 return sv_collxfrm_flags(sv, nxp, SV_GMAGIC);
1144 Perl_sv_2bool(pTHX_ SV *const sv)
1146 return sv_2bool_flags(sv, SV_GMAGIC);
1151 =for apidoc custom_op_name
1152 Return the name for a given custom op. This was once used by the OP_NAME
1153 macro, but is no longer: it has only been kept for compatibility, and
1156 =for apidoc custom_op_desc
1157 Return the description of a given custom op. This was once used by the
1158 OP_DESC macro, but is no longer: it has only been kept for
1159 compatibility, and should not be used.
1165 Perl_custom_op_name(pTHX_ const OP* o)
1167 PERL_ARGS_ASSERT_CUSTOM_OP_NAME;
1168 return XopENTRYCUSTOM(o, xop_name);
1172 Perl_custom_op_desc(pTHX_ const OP* o)
1174 PERL_ARGS_ASSERT_CUSTOM_OP_DESC;
1175 return XopENTRYCUSTOM(o, xop_desc);
1179 Perl_newSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *block)
1181 return newATTRSUB(floor, o, proto, NULL, block);
1185 Perl_to_utf8_fold(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp)
1187 PERL_ARGS_ASSERT_TO_UTF8_FOLD;
1189 return _to_utf8_fold_flags(p, ustrp, lenp, FOLD_FLAGS_FULL);
1193 Perl_to_utf8_lower(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp)
1195 PERL_ARGS_ASSERT_TO_UTF8_LOWER;
1197 return _to_utf8_lower_flags(p, ustrp, lenp, FALSE);
1201 Perl_to_utf8_title(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp)
1203 PERL_ARGS_ASSERT_TO_UTF8_TITLE;
1205 return _to_utf8_title_flags(p, ustrp, lenp, FALSE);
1209 Perl_to_utf8_upper(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp)
1211 PERL_ARGS_ASSERT_TO_UTF8_UPPER;
1213 return _to_utf8_upper_flags(p, ustrp, lenp, FALSE);
1217 Perl_sv_mortalcopy(pTHX_ SV *const oldstr)
1219 return Perl_sv_mortalcopy_flags(aTHX_ oldstr, SV_GMAGIC);
1222 UV /* Made into a function, so can be deprecated */
1223 NATIVE_TO_NEED(const UV enc, const UV ch)
1225 PERL_UNUSED_ARG(enc);
1229 UV /* Made into a function, so can be deprecated */
1230 ASCII_TO_NEED(const UV enc, const UV ch)
1232 PERL_UNUSED_ARG(enc);
1236 bool /* Made into a function, so can be deprecated */
1237 Perl_isIDFIRST_lazy(pTHX_ const char* p)
1239 PERL_ARGS_ASSERT_ISIDFIRST_LAZY;
1241 return isIDFIRST_lazy_if(p,1);
1244 bool /* Made into a function, so can be deprecated */
1245 Perl_isALNUM_lazy(pTHX_ const char* p)
1247 PERL_ARGS_ASSERT_ISALNUM_LAZY;
1249 return isALNUM_lazy_if(p,1);
1253 Perl_is_uni_alnum(pTHX_ UV c)
1255 return isWORDCHAR_uni(c);
1259 Perl_is_uni_alnumc(pTHX_ UV c)
1261 return isALNUM_uni(c);
1265 Perl_is_uni_alpha(pTHX_ UV c)
1267 return isALPHA_uni(c);
1271 Perl_is_uni_ascii(pTHX_ UV c)
1273 return isASCII_uni(c);
1277 Perl_is_uni_blank(pTHX_ UV c)
1279 return isBLANK_uni(c);
1283 Perl_is_uni_space(pTHX_ UV c)
1285 return isSPACE_uni(c);
1289 Perl_is_uni_digit(pTHX_ UV c)
1291 return isDIGIT_uni(c);
1295 Perl_is_uni_upper(pTHX_ UV c)
1297 return isUPPER_uni(c);
1301 Perl_is_uni_lower(pTHX_ UV c)
1303 return isLOWER_uni(c);
1307 Perl_is_uni_cntrl(pTHX_ UV c)
1309 return isCNTRL_L1(c);
1313 Perl_is_uni_graph(pTHX_ UV c)
1315 return isGRAPH_uni(c);
1319 Perl_is_uni_print(pTHX_ UV c)
1321 return isPRINT_uni(c);
1325 Perl_is_uni_punct(pTHX_ UV c)
1327 return isPUNCT_uni(c);
1331 Perl_is_uni_xdigit(pTHX_ UV c)
1333 return isXDIGIT_uni(c);
1337 Perl_is_uni_alnum_lc(pTHX_ UV c)
1339 return isWORDCHAR_LC_uvchr(c);
1343 Perl_is_uni_alnumc_lc(pTHX_ UV c)
1345 return isALPHANUMERIC_LC_uvchr(c);
1349 Perl_is_uni_idfirst_lc(pTHX_ UV c)
1351 /* XXX Should probably be something that resolves to the old IDFIRST, but
1352 * this function is deprecated, so not bothering */
1353 return isIDFIRST_LC_uvchr(c);
1357 Perl_is_uni_alpha_lc(pTHX_ UV c)
1359 return isALPHA_LC_uvchr(c);
1363 Perl_is_uni_ascii_lc(pTHX_ UV c)
1365 return isASCII_LC_uvchr(c);
1369 Perl_is_uni_blank_lc(pTHX_ UV c)
1371 return isBLANK_LC_uvchr(c);
1375 Perl_is_uni_space_lc(pTHX_ UV c)
1377 return isSPACE_LC_uvchr(c);
1381 Perl_is_uni_digit_lc(pTHX_ UV c)
1383 return isDIGIT_LC_uvchr(c);
1387 Perl_is_uni_idfirst(pTHX_ UV c)
1389 U8 tmpbuf[UTF8_MAXBYTES+1];
1390 uvchr_to_utf8(tmpbuf, c);
1391 return _is_utf8_idstart(tmpbuf);
1395 Perl_is_utf8_idfirst(pTHX_ const U8 *p) /* The naming is historical. */
1399 PERL_ARGS_ASSERT_IS_UTF8_IDFIRST;
1401 return _is_utf8_idstart(p);
1405 Perl_is_utf8_xidfirst(pTHX_ const U8 *p) /* The naming is historical. */
1409 PERL_ARGS_ASSERT_IS_UTF8_XIDFIRST;
1411 return _is_utf8_xidstart(p);
1415 Perl_is_utf8_idcont(pTHX_ const U8 *p)
1419 PERL_ARGS_ASSERT_IS_UTF8_IDCONT;
1421 return _is_utf8_idcont(p);
1425 Perl_is_utf8_xidcont(pTHX_ const U8 *p)
1429 PERL_ARGS_ASSERT_IS_UTF8_XIDCONT;
1431 return _is_utf8_xidcont(p);
1435 Perl_is_uni_upper_lc(pTHX_ UV c)
1437 return isUPPER_LC_uvchr(c);
1441 Perl_is_uni_lower_lc(pTHX_ UV c)
1443 return isLOWER_LC_uvchr(c);
1447 Perl_is_uni_cntrl_lc(pTHX_ UV c)
1449 return isCNTRL_LC_uvchr(c);
1453 Perl_is_uni_graph_lc(pTHX_ UV c)
1455 return isGRAPH_LC_uvchr(c);
1459 Perl_is_uni_print_lc(pTHX_ UV c)
1461 return isPRINT_LC_uvchr(c);
1465 Perl_is_uni_punct_lc(pTHX_ UV c)
1467 return isPUNCT_LC_uvchr(c);
1471 Perl_is_uni_xdigit_lc(pTHX_ UV c)
1473 return isXDIGIT_LC_uvchr(c);
1477 Perl_to_uni_upper_lc(pTHX_ U32 c)
1479 /* XXX returns only the first character -- do not use XXX */
1480 /* XXX no locale support yet */
1482 U8 tmpbuf[UTF8_MAXBYTES_CASE+1];
1483 return (U32)to_uni_upper(c, tmpbuf, &len);
1487 Perl_to_uni_title_lc(pTHX_ U32 c)
1489 /* XXX returns only the first character XXX -- do not use XXX */
1490 /* XXX no locale support yet */
1492 U8 tmpbuf[UTF8_MAXBYTES_CASE+1];
1493 return (U32)to_uni_title(c, tmpbuf, &len);
1497 Perl_to_uni_lower_lc(pTHX_ U32 c)
1499 /* XXX returns only the first character -- do not use XXX */
1500 /* XXX no locale support yet */
1502 U8 tmpbuf[UTF8_MAXBYTES_CASE+1];
1503 return (U32)to_uni_lower(c, tmpbuf, &len);
1507 Perl_is_utf8_alnum(pTHX_ const U8 *p)
1511 PERL_ARGS_ASSERT_IS_UTF8_ALNUM;
1513 /* NOTE: "IsWord", not "IsAlnum", since Alnum is a true
1514 * descendant of isalnum(3), in other words, it doesn't
1515 * contain the '_'. --jhi */
1516 return isWORDCHAR_utf8(p);
1520 Perl_is_utf8_alnumc(pTHX_ const U8 *p)
1524 PERL_ARGS_ASSERT_IS_UTF8_ALNUMC;
1526 return isALPHANUMERIC_utf8(p);
1530 Perl_is_utf8_alpha(pTHX_ const U8 *p)
1534 PERL_ARGS_ASSERT_IS_UTF8_ALPHA;
1536 return isALPHA_utf8(p);
1540 Perl_is_utf8_ascii(pTHX_ const U8 *p)
1544 PERL_ARGS_ASSERT_IS_UTF8_ASCII;
1546 return isASCII_utf8(p);
1550 Perl_is_utf8_blank(pTHX_ const U8 *p)
1554 PERL_ARGS_ASSERT_IS_UTF8_BLANK;
1556 return isBLANK_utf8(p);
1560 Perl_is_utf8_space(pTHX_ const U8 *p)
1564 PERL_ARGS_ASSERT_IS_UTF8_SPACE;
1566 return isSPACE_utf8(p);
1570 Perl_is_utf8_perl_space(pTHX_ const U8 *p)
1574 PERL_ARGS_ASSERT_IS_UTF8_PERL_SPACE;
1576 /* Only true if is an ASCII space-like character, and ASCII is invariant
1577 * under utf8, so can just use the macro */
1578 return isSPACE_A(*p);
1582 Perl_is_utf8_perl_word(pTHX_ const U8 *p)
1586 PERL_ARGS_ASSERT_IS_UTF8_PERL_WORD;
1588 /* Only true if is an ASCII word character, and ASCII is invariant
1589 * under utf8, so can just use the macro */
1590 return isWORDCHAR_A(*p);
1594 Perl_is_utf8_digit(pTHX_ const U8 *p)
1598 PERL_ARGS_ASSERT_IS_UTF8_DIGIT;
1600 return isDIGIT_utf8(p);
1604 Perl_is_utf8_posix_digit(pTHX_ const U8 *p)
1608 PERL_ARGS_ASSERT_IS_UTF8_POSIX_DIGIT;
1610 /* Only true if is an ASCII digit character, and ASCII is invariant
1611 * under utf8, so can just use the macro */
1612 return isDIGIT_A(*p);
1616 Perl_is_utf8_upper(pTHX_ const U8 *p)
1620 PERL_ARGS_ASSERT_IS_UTF8_UPPER;
1622 return isUPPER_utf8(p);
1626 Perl_is_utf8_lower(pTHX_ const U8 *p)
1630 PERL_ARGS_ASSERT_IS_UTF8_LOWER;
1632 return isLOWER_utf8(p);
1636 Perl_is_utf8_cntrl(pTHX_ const U8 *p)
1640 PERL_ARGS_ASSERT_IS_UTF8_CNTRL;
1642 return isCNTRL_utf8(p);
1646 Perl_is_utf8_graph(pTHX_ const U8 *p)
1650 PERL_ARGS_ASSERT_IS_UTF8_GRAPH;
1652 return isGRAPH_utf8(p);
1656 Perl_is_utf8_print(pTHX_ const U8 *p)
1660 PERL_ARGS_ASSERT_IS_UTF8_PRINT;
1662 return isPRINT_utf8(p);
1666 Perl_is_utf8_punct(pTHX_ const U8 *p)
1670 PERL_ARGS_ASSERT_IS_UTF8_PUNCT;
1672 return isPUNCT_utf8(p);
1676 Perl_is_utf8_xdigit(pTHX_ const U8 *p)
1680 PERL_ARGS_ASSERT_IS_UTF8_XDIGIT;
1682 return isXDIGIT_utf8(p);
1686 Perl_is_utf8_mark(pTHX_ const U8 *p)
1690 PERL_ARGS_ASSERT_IS_UTF8_MARK;
1692 return _is_utf8_mark(p);
1696 =for apidoc is_utf8_char
1698 Tests if some arbitrary number of bytes begins in a valid UTF-8
1699 character. Note that an INVARIANT (i.e. ASCII on non-EBCDIC machines)
1700 character is a valid UTF-8 character. The actual number of bytes in the UTF-8
1701 character will be returned if it is valid, otherwise 0.
1703 This function is deprecated due to the possibility that malformed input could
1704 cause reading beyond the end of the input buffer. Use L</isUTF8_CHAR>
1710 Perl_is_utf8_char(const U8 *s)
1712 PERL_ARGS_ASSERT_IS_UTF8_CHAR;
1714 /* Assumes we have enough space, which is why this is deprecated */
1715 return isUTF8_CHAR(s, s + UTF8SKIP(s));
1719 * Like L</utf8_to_uvuni_buf>(), but should only be called when it is known that
1720 * there are no malformations in the input UTF-8 string C<s>. Surrogates,
1721 * non-character code points, and non-Unicode code points are allowed */
1724 Perl_valid_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen)
1726 PERL_ARGS_ASSERT_VALID_UTF8_TO_UVUNI;
1728 return NATIVE_TO_UNI(valid_utf8_to_uvchr(s, retlen));
1732 =for apidoc utf8_to_uvchr
1734 Returns the native code point of the first character in the string C<s>
1735 which is assumed to be in UTF-8 encoding; C<retlen> will be set to the
1736 length, in bytes, of that character.
1738 Some, but not all, UTF-8 malformations are detected, and in fact, some
1739 malformed input could cause reading beyond the end of the input buffer, which
1740 is why this function is deprecated. Use L</utf8_to_uvchr_buf> instead.
1742 If C<s> points to one of the detected malformations, and UTF8 warnings are
1743 enabled, zero is returned and C<*retlen> is set (if C<retlen> isn't
1744 NULL) to -1. If those warnings are off, the computed value if well-defined (or
1745 the Unicode REPLACEMENT CHARACTER, if not) is silently returned, and C<*retlen>
1746 is set (if C<retlen> isn't NULL) so that (S<C<s> + C<*retlen>>) is the
1747 next possible position in C<s> that could begin a non-malformed character.
1748 See L</utf8n_to_uvchr> for details on when the REPLACEMENT CHARACTER is returned.
1754 Perl_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen)
1756 PERL_ARGS_ASSERT_UTF8_TO_UVCHR;
1758 return utf8_to_uvchr_buf(s, s + UTF8_MAXBYTES, retlen);
1762 =for apidoc utf8_to_uvuni
1764 Returns the Unicode code point of the first character in the string C<s>
1765 which is assumed to be in UTF-8 encoding; C<retlen> will be set to the
1766 length, in bytes, of that character.
1768 Some, but not all, UTF-8 malformations are detected, and in fact, some
1769 malformed input could cause reading beyond the end of the input buffer, which
1770 is one reason why this function is deprecated. The other is that only in
1771 extremely limited circumstances should the Unicode versus native code point be
1772 of any interest to you. See L</utf8_to_uvuni_buf> for alternatives.
1774 If C<s> points to one of the detected malformations, and UTF8 warnings are
1775 enabled, zero is returned and C<*retlen> is set (if C<retlen> doesn't point to
1776 NULL) to -1. If those warnings are off, the computed value if well-defined (or
1777 the Unicode REPLACEMENT CHARACTER, if not) is silently returned, and C<*retlen>
1778 is set (if C<retlen> isn't NULL) so that (S<C<s> + C<*retlen>>) is the
1779 next possible position in C<s> that could begin a non-malformed character.
1780 See L</utf8n_to_uvchr> for details on when the REPLACEMENT CHARACTER is returned.
1786 Perl_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen)
1788 PERL_ARGS_ASSERT_UTF8_TO_UVUNI;
1790 return NATIVE_TO_UNI(valid_utf8_to_uvchr(s, retlen));
1795 #endif /* NO_MATHOMS */
1799 * c-indentation-style: bsd
1801 * indent-tabs-mode: nil
1804 * ex: set ts=8 sts=4 sw=4 et: