3 * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 * 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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 * Sam sat on the ground and put his head in his hands. 'I wish I had never
13 * come here, and I don't want to see no more magic,' he said, and fell silent.
15 * [p.363 of _The Lord of the Rings_, II/vii: "The Mirror of Galadriel"]
19 =head1 Magical Functions
20 "Magic" is special data attached to SV structures in order to give them
21 "magical" properties. When any Perl code tries to read from, or assign to,
22 an SV marked as magical, it calls the 'get' or 'set' function associated
23 with that SV's magic. A get is called prior to reading an SV, in order to
24 give it a chance to update its internal value (get on $. writes the line
25 number of the last read filehandle into the SV's IV slot), while
26 set is called after an SV has been written to, in order to allow it to make
27 use of its changed value (set on $/ copies the SV's new value to the
28 PL_rs global variable).
30 Magic is implemented as a linked list of MAGIC structures attached to the
31 SV. Each MAGIC struct holds the type of the magic, a pointer to an array
32 of functions that implement the get(), set(), length() etc functions,
33 plus space for some flags and pointers. For example, a tied variable has
34 a MAGIC structure that contains a pointer to the object associated with the
45 #if defined(HAS_GETGROUPS) || defined(HAS_SETGROUPS)
51 #if defined(HAS_SETGROUPS)
58 # include <sys/pstat.h>
61 #ifdef HAS_PRCTL_SET_NAME
62 # include <sys/prctl.h>
65 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
66 Signal_t Perl_csighandler(int sig, siginfo_t *, void *);
68 Signal_t Perl_csighandler(int sig);
72 /* Missing protos on LynxOS */
73 void setruid(uid_t id);
74 void seteuid(uid_t id);
75 void setrgid(uid_t id);
76 void setegid(uid_t id);
80 * Pre-magic setup and post-magic takedown.
81 * Use the "DESTRUCTOR" scope cleanup to reinstate magic.
91 /* MGS is typedef'ed to struct magic_state in perl.h */
94 S_save_magic_flags(pTHX_ I32 mgs_ix, SV *sv, U32 flags)
100 PERL_ARGS_ASSERT_SAVE_MAGIC_FLAGS;
102 assert(SvMAGICAL(sv));
104 /* we shouldn't really be called here with RC==0, but it can sometimes
105 * happen via mg_clear() (which also shouldn't be called when RC==0,
106 * but it can happen). Handle this case gracefully(ish) by not RC++
107 * and thus avoiding the resultant double free */
108 if (SvREFCNT(sv) > 0) {
109 /* guard against sv getting freed midway through the mg clearing,
110 * by holding a private reference for the duration. */
111 SvREFCNT_inc_simple_void_NN(sv);
115 SAVEDESTRUCTOR_X(S_restore_magic, INT2PTR(void*, (IV)mgs_ix));
117 mgs = SSPTR(mgs_ix, MGS*);
119 mgs->mgs_magical = SvMAGICAL(sv);
120 mgs->mgs_readonly = SvREADONLY(sv) != 0;
121 mgs->mgs_ss_ix = PL_savestack_ix; /* points after the saved destructor */
122 mgs->mgs_bumped = bumped;
124 SvFLAGS(sv) &= ~flags;
128 #define save_magic(a,b) save_magic_flags(a,b,SVs_GMG|SVs_SMG|SVs_RMG)
131 =for apidoc mg_magical
133 Turns on the magical status of an SV. See C<sv_magic>.
139 Perl_mg_magical(pTHX_ SV *sv)
142 PERL_ARGS_ASSERT_MG_MAGICAL;
146 if ((mg = SvMAGIC(sv))) {
148 const MGVTBL* const vtbl = mg->mg_virtual;
150 if (vtbl->svt_get && !(mg->mg_flags & MGf_GSKIP))
157 } while ((mg = mg->mg_moremagic));
158 if (!(SvFLAGS(sv) & (SVs_GMG|SVs_SMG)))
166 Do magic before a value is retrieved from the SV. The type of SV must
167 be >= SVt_PVMG. See C<sv_magic>.
173 Perl_mg_get(pTHX_ SV *sv)
176 const I32 mgs_ix = SSNEW(sizeof(MGS));
179 MAGIC *newmg, *head, *cur, *mg;
181 PERL_ARGS_ASSERT_MG_GET;
183 if (PL_localizing == 1 && sv == DEFSV) return 0;
185 /* We must call svt_get(sv, mg) for each valid entry in the linked
186 list of magic. svt_get() may delete the current entry, add new
187 magic to the head of the list, or upgrade the SV. AMS 20010810 */
189 newmg = cur = head = mg = SvMAGIC(sv);
191 const MGVTBL * const vtbl = mg->mg_virtual;
192 MAGIC * const nextmg = mg->mg_moremagic; /* it may delete itself */
194 if (!(mg->mg_flags & MGf_GSKIP) && vtbl && vtbl->svt_get) {
196 /* taint's mg get is so dumb it doesn't need flag saving */
197 if (!saved && mg->mg_type != PERL_MAGIC_taint) {
198 save_magic(mgs_ix, sv);
202 vtbl->svt_get(aTHX_ sv, mg);
204 /* guard against magic having been deleted - eg FETCH calling
207 (SSPTR(mgs_ix, MGS *))->mgs_magical = 0; /* recalculate flags */
211 /* recalculate flags if this entry was deleted. */
212 if (mg->mg_flags & MGf_GSKIP)
213 (SSPTR(mgs_ix, MGS *))->mgs_magical = 0;
215 else if (vtbl == &PL_vtbl_utf8) {
216 /* get-magic can reallocate the PV */
217 magic_setutf8(sv, mg);
223 /* Have we finished with the new entries we saw? Start again
224 where we left off (unless there are more new entries). */
232 /* Were any new entries added? */
233 if (!have_new && (newmg = SvMAGIC(sv)) != head) {
237 (SSPTR(mgs_ix, MGS *))->mgs_magical = 0; /* recalculate flags */
242 restore_magic(INT2PTR(void *, (IV)mgs_ix));
250 Do magic after a value is assigned to the SV. See C<sv_magic>.
256 Perl_mg_set(pTHX_ SV *sv)
259 const I32 mgs_ix = SSNEW(sizeof(MGS));
263 PERL_ARGS_ASSERT_MG_SET;
265 if (PL_localizing == 2 && sv == DEFSV) return 0;
267 save_magic_flags(mgs_ix, sv, SVs_GMG|SVs_SMG); /* leave SVs_RMG on */
269 for (mg = SvMAGIC(sv); mg; mg = nextmg) {
270 const MGVTBL* vtbl = mg->mg_virtual;
271 nextmg = mg->mg_moremagic; /* it may delete itself */
272 if (mg->mg_flags & MGf_GSKIP) {
273 mg->mg_flags &= ~MGf_GSKIP; /* setting requires another read */
274 (SSPTR(mgs_ix, MGS*))->mgs_magical = 0;
276 if (PL_localizing == 2
277 && PERL_MAGIC_TYPE_IS_VALUE_MAGIC(mg->mg_type))
279 if (vtbl && vtbl->svt_set)
280 vtbl->svt_set(aTHX_ sv, mg);
283 restore_magic(INT2PTR(void*, (IV)mgs_ix));
288 =for apidoc mg_length
290 Reports on the SV's length in bytes, calling length magic if available,
291 but does not set the UTF8 flag on the sv. It will fall back to 'get'
292 magic if there is no 'length' magic, but with no indication as to
293 whether it called 'get' magic. It assumes the sv is a PVMG or
294 higher. Use sv_len() instead.
300 Perl_mg_length(pTHX_ SV *sv)
306 PERL_ARGS_ASSERT_MG_LENGTH;
308 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
309 const MGVTBL * const vtbl = mg->mg_virtual;
310 if (vtbl && vtbl->svt_len) {
311 const I32 mgs_ix = SSNEW(sizeof(MGS));
312 save_magic(mgs_ix, sv);
313 /* omit MGf_GSKIP -- not changed here */
314 len = vtbl->svt_len(aTHX_ sv, mg);
315 restore_magic(INT2PTR(void*, (IV)mgs_ix));
320 (void)SvPV_const(sv, len);
325 Perl_mg_size(pTHX_ SV *sv)
329 PERL_ARGS_ASSERT_MG_SIZE;
331 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
332 const MGVTBL* const vtbl = mg->mg_virtual;
333 if (vtbl && vtbl->svt_len) {
334 const I32 mgs_ix = SSNEW(sizeof(MGS));
336 save_magic(mgs_ix, sv);
337 /* omit MGf_GSKIP -- not changed here */
338 len = vtbl->svt_len(aTHX_ sv, mg);
339 restore_magic(INT2PTR(void*, (IV)mgs_ix));
346 return AvFILLp((const AV *) sv); /* Fallback to non-tied array */
350 Perl_croak(aTHX_ "Size magic not implemented");
353 NOT_REACHED; /* NOTREACHED */
359 Clear something magical that the SV represents. See C<sv_magic>.
365 Perl_mg_clear(pTHX_ SV *sv)
367 const I32 mgs_ix = SSNEW(sizeof(MGS));
371 PERL_ARGS_ASSERT_MG_CLEAR;
373 save_magic(mgs_ix, sv);
375 for (mg = SvMAGIC(sv); mg; mg = nextmg) {
376 const MGVTBL* const vtbl = mg->mg_virtual;
377 /* omit GSKIP -- never set here */
379 nextmg = mg->mg_moremagic; /* it may delete itself */
381 if (vtbl && vtbl->svt_clear)
382 vtbl->svt_clear(aTHX_ sv, mg);
385 restore_magic(INT2PTR(void*, (IV)mgs_ix));
390 S_mg_findext_flags(pTHX_ const SV *sv, int type, const MGVTBL *vtbl, U32 flags)
399 assert(!(SvTYPE(sv) == SVt_PVAV && AvPAD_NAMELIST(sv)));
401 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
402 if (mg->mg_type == type && (!flags || mg->mg_virtual == vtbl)) {
414 Finds the magic pointer for type matching the SV. See C<sv_magic>.
420 Perl_mg_find(pTHX_ const SV *sv, int type)
422 return S_mg_findext_flags(aTHX_ sv, type, NULL, 0);
426 =for apidoc mg_findext
428 Finds the magic pointer of C<type> with the given C<vtbl> for the C<SV>. See
435 Perl_mg_findext(pTHX_ const SV *sv, int type, const MGVTBL *vtbl)
437 return S_mg_findext_flags(aTHX_ sv, type, vtbl, 1);
441 Perl_mg_find_mglob(pTHX_ SV *sv)
443 PERL_ARGS_ASSERT_MG_FIND_MGLOB;
444 if (SvTYPE(sv) == SVt_PVLV && LvTYPE(sv) == 'y') {
445 /* This sv is only a delegate. //g magic must be attached to
450 if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv))
451 return S_mg_findext_flags(aTHX_ sv, PERL_MAGIC_regex_global, 0, 0);
458 Copies the magic from one SV to another. See C<sv_magic>.
464 Perl_mg_copy(pTHX_ SV *sv, SV *nsv, const char *key, I32 klen)
469 PERL_ARGS_ASSERT_MG_COPY;
471 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
472 const MGVTBL* const vtbl = mg->mg_virtual;
473 if ((mg->mg_flags & MGf_COPY) && vtbl->svt_copy){
474 count += vtbl->svt_copy(aTHX_ sv, mg, nsv, key, klen);
477 const char type = mg->mg_type;
478 if (isUPPER(type) && type != PERL_MAGIC_uvar) {
480 (type == PERL_MAGIC_tied)
482 : (type == PERL_MAGIC_regdata && mg->mg_obj)
485 toLOWER(type), key, klen);
494 =for apidoc mg_localize
496 Copy some of the magic from an existing SV to new localized version of that
497 SV. Container magic (eg %ENV, $1, tie)
498 gets copied, value magic doesn't (eg
501 If setmagic is false then no set magic will be called on the new (empty) SV.
502 This typically means that assignment will soon follow (e.g. 'local $x = $y'),
503 and that will handle the magic.
509 Perl_mg_localize(pTHX_ SV *sv, SV *nsv, bool setmagic)
514 PERL_ARGS_ASSERT_MG_LOCALIZE;
519 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
520 const MGVTBL* const vtbl = mg->mg_virtual;
521 if (PERL_MAGIC_TYPE_IS_VALUE_MAGIC(mg->mg_type))
524 if ((mg->mg_flags & MGf_LOCAL) && vtbl->svt_local)
525 (void)vtbl->svt_local(aTHX_ nsv, mg);
527 sv_magicext(nsv, mg->mg_obj, mg->mg_type, vtbl,
528 mg->mg_ptr, mg->mg_len);
530 /* container types should remain read-only across localization */
531 SvFLAGS(nsv) |= SvREADONLY(sv);
534 if (SvTYPE(nsv) >= SVt_PVMG && SvMAGIC(nsv)) {
535 SvFLAGS(nsv) |= SvMAGICAL(sv);
544 #define mg_free_struct(sv, mg) S_mg_free_struct(aTHX_ sv, mg)
546 S_mg_free_struct(pTHX_ SV *sv, MAGIC *mg)
548 const MGVTBL* const vtbl = mg->mg_virtual;
549 if (vtbl && vtbl->svt_free)
550 vtbl->svt_free(aTHX_ sv, mg);
551 if (mg->mg_ptr && mg->mg_type != PERL_MAGIC_regex_global) {
552 if (mg->mg_len > 0 || mg->mg_type == PERL_MAGIC_utf8)
553 Safefree(mg->mg_ptr);
554 else if (mg->mg_len == HEf_SVKEY)
555 SvREFCNT_dec(MUTABLE_SV(mg->mg_ptr));
557 if (mg->mg_flags & MGf_REFCOUNTED)
558 SvREFCNT_dec(mg->mg_obj);
565 Free any magic storage used by the SV. See C<sv_magic>.
571 Perl_mg_free(pTHX_ SV *sv)
576 PERL_ARGS_ASSERT_MG_FREE;
578 for (mg = SvMAGIC(sv); mg; mg = moremagic) {
579 moremagic = mg->mg_moremagic;
580 mg_free_struct(sv, mg);
581 SvMAGIC_set(sv, moremagic);
583 SvMAGIC_set(sv, NULL);
589 =for apidoc Am|void|mg_free_type|SV *sv|int how
591 Remove any magic of type I<how> from the SV I<sv>. See L</sv_magic>.
597 Perl_mg_free_type(pTHX_ SV *sv, int how)
599 MAGIC *mg, *prevmg, *moremg;
600 PERL_ARGS_ASSERT_MG_FREE_TYPE;
601 for (prevmg = NULL, mg = SvMAGIC(sv); mg; prevmg = mg, mg = moremg) {
603 moremg = mg->mg_moremagic;
604 if (mg->mg_type == how) {
605 /* temporarily move to the head of the magic chain, in case
606 custom free code relies on this historical aspect of mg_free */
608 prevmg->mg_moremagic = moremg;
609 mg->mg_moremagic = SvMAGIC(sv);
612 newhead = mg->mg_moremagic;
613 mg_free_struct(sv, mg);
614 SvMAGIC_set(sv, newhead);
624 Perl_magic_regdata_cnt(pTHX_ SV *sv, MAGIC *mg)
629 PERL_ARGS_ASSERT_MAGIC_REGDATA_CNT;
632 const REGEXP * const rx = PM_GETRE(PL_curpm);
634 if (mg->mg_obj) { /* @+ */
635 /* return the number possible */
636 return RX_NPARENS(rx);
638 I32 paren = RX_LASTPAREN(rx);
640 /* return the last filled */
642 && (RX_OFFS(rx)[paren].start == -1
643 || RX_OFFS(rx)[paren].end == -1) )
656 Perl_magic_regdatum_get(pTHX_ SV *sv, MAGIC *mg)
660 PERL_ARGS_ASSERT_MAGIC_REGDATUM_GET;
663 const REGEXP * const rx = PM_GETRE(PL_curpm);
665 const I32 paren = mg->mg_len;
670 if (paren <= (I32)RX_NPARENS(rx) &&
671 (s = RX_OFFS(rx)[paren].start) != -1 &&
672 (t = RX_OFFS(rx)[paren].end) != -1)
675 if (mg->mg_obj) /* @+ */
680 if (RX_MATCH_UTF8(rx)) {
681 const char * const b = RX_SUBBEG(rx);
683 i = RX_SUBCOFFSET(rx) +
685 (U8*)(b-RX_SUBOFFSET(rx)+i));
700 Perl_magic_regdatum_set(pTHX_ SV *sv, MAGIC *mg)
702 PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET;
706 Perl_croak_no_modify();
707 NORETURN_FUNCTION_END;
710 #define SvRTRIM(sv) STMT_START { \
712 STRLEN len = SvCUR(sv); \
713 char * const p = SvPVX(sv); \
714 while (len > 0 && isSPACE(p[len-1])) \
716 SvCUR_set(sv, len); \
722 Perl_emulate_cop_io(pTHX_ const COP *const c, SV *const sv)
724 PERL_ARGS_ASSERT_EMULATE_COP_IO;
726 if (!(CopHINTS_get(c) & (HINT_LEXICAL_IO_IN|HINT_LEXICAL_IO_OUT)))
727 sv_setsv(sv, &PL_sv_undef);
731 if ((CopHINTS_get(c) & HINT_LEXICAL_IO_IN)) {
732 SV *const value = cop_hints_fetch_pvs(c, "open<", 0);
737 if ((CopHINTS_get(c) & HINT_LEXICAL_IO_OUT)) {
738 SV *const value = cop_hints_fetch_pvs(c, "open>", 0);
746 S_fixup_errno_string(pTHX_ SV* sv)
748 /* Do what is necessary to fixup the non-empty string in 'sv' for return to
751 PERL_ARGS_ASSERT_FIXUP_ERRNO_STRING;
755 if(strEQ(SvPVX(sv), "")) {
756 sv_catpv(sv, UNKNOWN_ERRNO_MSG);
760 /* In some locales the error string may come back as UTF-8, in which
761 * case we should turn on that flag. This didn't use to happen, and to
762 * avoid as many possible backward compatibility issues as possible, we
763 * don't turn on the flag unless we have to. So the flag stays off for
764 * an entirely ASCII string. We assume that if the string looks like
765 * UTF-8, it really is UTF-8: "text in any other encoding that uses
766 * bytes with the high bit set is extremely unlikely to pass a UTF-8
767 * validity test" (http://en.wikipedia.org/wiki/Charset_detection).
768 * There is a potential that we will get it wrong however, especially
769 * on short error message text. (If it turns out to be necessary, we
770 * could also keep track if the current LC_MESSAGES locale is UTF-8) */
771 if (! IN_BYTES /* respect 'use bytes' */
772 && ! is_ascii_string((U8*) SvPVX_const(sv), SvCUR(sv))
773 && is_utf8_string((U8*) SvPVX_const(sv), SvCUR(sv)))
786 Perl_magic_get(pTHX_ SV *sv, MAGIC *mg)
790 const char *s = NULL;
792 const char * const remaining = mg->mg_ptr + 1;
795 PERL_ARGS_ASSERT_MAGIC_GET;
799 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
801 CALLREG_NUMBUF_FETCH(rx,paren,sv);
803 sv_setsv(sv,&PL_sv_undef);
808 nextchar = *remaining;
809 switch (*mg->mg_ptr) {
810 case '\001': /* ^A */
811 if (SvOK(PL_bodytarget)) sv_copypv(sv, PL_bodytarget);
812 else sv_setsv(sv, &PL_sv_undef);
813 if (SvTAINTED(PL_bodytarget))
816 case '\003': /* ^C, ^CHILD_ERROR_NATIVE */
817 if (nextchar == '\0') {
818 sv_setiv(sv, (IV)PL_minus_c);
820 else if (strEQ(remaining, "HILD_ERROR_NATIVE")) {
821 sv_setiv(sv, (IV)STATUS_NATIVE);
825 case '\004': /* ^D */
826 sv_setiv(sv, (IV)(PL_debug & DEBUG_MASK));
828 case '\005': /* ^E */
829 if (nextchar != '\0') {
830 if (strEQ(remaining, "NCODING"))
831 sv_setsv(sv, PL_encoding);
835 #if defined(VMS) || defined(OS2) || defined(WIN32)
839 $DESCRIPTOR(msgdsc,msg);
840 sv_setnv(sv,(NV) vaxc$errno);
841 if (sys$getmsg(vaxc$errno,&msgdsc.dsc$w_length,&msgdsc,0,0) & 1)
842 sv_setpvn(sv,msgdsc.dsc$a_pointer,msgdsc.dsc$w_length);
847 if (!(_emx_env & 0x200)) { /* Under DOS */
848 sv_setnv(sv, (NV)errno);
849 sv_setpv(sv, errno ? my_strerror(errno) : "");
851 if (errno != errno_isOS2) {
852 const int tmp = _syserrno();
853 if (tmp) /* 2nd call to _syserrno() makes it 0 */
856 sv_setnv(sv, (NV)Perl_rc);
857 sv_setpv(sv, os2error(Perl_rc));
859 if (SvOK(sv) && strNE(SvPVX(sv), "")) {
860 fixup_errno_string(sv);
862 # elif defined(WIN32)
864 const DWORD dwErr = GetLastError();
865 sv_setnv(sv, (NV)dwErr);
867 PerlProc_GetOSError(sv, dwErr);
868 fixup_errno_string(sv);
875 # error Missing code for platform
878 SvNOK_on(sv); /* what a wonderful hack! */
880 #endif /* End of platforms with special handling for $^E; others just fall
887 sv_setnv(sv, (NV)((errno == EVMSERR) ? vaxc$errno : errno));
889 sv_setnv(sv, (NV)errno);
892 if (errno == errno_isOS2 || errno == errno_isOS2_set)
893 sv_setpv(sv, os2error(Perl_rc));
901 /* Strerror can return NULL on some platforms, which will
902 * result in 'sv' not being considered SvOK. The SvNOK_on()
903 * below will cause just the number part to be valid */
904 sv_setpv(sv, my_strerror(errno));
906 fixup_errno_string(sv);
913 SvNOK_on(sv); /* what a wonderful hack! */
916 case '\006': /* ^F */
917 sv_setiv(sv, (IV)PL_maxsysfd);
919 case '\007': /* ^GLOBAL_PHASE */
920 if (strEQ(remaining, "LOBAL_PHASE")) {
921 sv_setpvn(sv, PL_phase_names[PL_phase],
922 strlen(PL_phase_names[PL_phase]));
925 case '\010': /* ^H */
926 sv_setiv(sv, (IV)PL_hints);
928 case '\011': /* ^I */ /* NOT \t in EBCDIC */
929 sv_setpv(sv, PL_inplace); /* Will undefine sv if PL_inplace is NULL */
931 case '\014': /* ^LAST_FH */
932 if (strEQ(remaining, "AST_FH")) {
934 assert(isGV_with_GP(PL_last_in_gv));
935 SV_CHECK_THINKFIRST_COW_DROP(sv);
936 prepare_SV_for_RV(sv);
938 SvRV_set(sv, SvREFCNT_inc_simple_NN(PL_last_in_gv));
942 else sv_setsv_nomg(sv, NULL);
945 case '\017': /* ^O & ^OPEN */
946 if (nextchar == '\0') {
947 sv_setpv(sv, PL_osname);
950 else if (strEQ(remaining, "PEN")) {
951 Perl_emulate_cop_io(aTHX_ &PL_compiling, sv);
955 sv_setiv(sv, (IV)PL_perldb);
957 case '\023': /* ^S */
959 if (PL_parser && PL_parser->lex_state != LEX_NOTPARSING)
962 sv_setiv(sv, PL_in_eval & ~(EVAL_INREQUIRE));
967 case '\024': /* ^T */
968 if (nextchar == '\0') {
970 sv_setnv(sv, PL_basetime);
972 sv_setiv(sv, (IV)PL_basetime);
975 else if (strEQ(remaining, "AINT"))
976 sv_setiv(sv, TAINTING_get
977 ? (TAINT_WARN_get || PL_unsafe ? -1 : 1)
980 case '\025': /* $^UNICODE, $^UTF8LOCALE, $^UTF8CACHE */
981 if (strEQ(remaining, "NICODE"))
982 sv_setuv(sv, (UV) PL_unicode);
983 else if (strEQ(remaining, "TF8LOCALE"))
984 sv_setuv(sv, (UV) PL_utf8locale);
985 else if (strEQ(remaining, "TF8CACHE"))
986 sv_setiv(sv, (IV) PL_utf8cache);
988 case '\027': /* ^W & $^WARNING_BITS */
989 if (nextchar == '\0')
990 sv_setiv(sv, (IV)((PL_dowarn & G_WARN_ON) ? TRUE : FALSE));
991 else if (strEQ(remaining, "ARNING_BITS")) {
992 if (PL_compiling.cop_warnings == pWARN_NONE) {
993 sv_setpvn(sv, WARN_NONEstring, WARNsize) ;
995 else if (PL_compiling.cop_warnings == pWARN_STD) {
996 sv_setsv(sv, &PL_sv_undef);
999 else if (PL_compiling.cop_warnings == pWARN_ALL) {
1000 /* Get the bit mask for $warnings::Bits{all}, because
1001 * it could have been extended by warnings::register */
1002 HV * const bits = get_hv("warnings::Bits", 0);
1003 SV ** const bits_all = bits ? hv_fetchs(bits, "all", FALSE) : NULL;
1005 sv_copypv(sv, *bits_all);
1007 sv_setpvn(sv, WARN_ALLstring, WARNsize);
1010 sv_setpvn(sv, (char *) (PL_compiling.cop_warnings + 1),
1011 *PL_compiling.cop_warnings);
1016 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
1017 paren = RX_LASTPAREN(rx);
1019 goto do_numbuf_fetch;
1021 sv_setsv(sv,&PL_sv_undef);
1023 case '\016': /* ^N */
1024 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
1025 paren = RX_LASTCLOSEPAREN(rx);
1027 goto do_numbuf_fetch;
1029 sv_setsv(sv,&PL_sv_undef);
1032 if (GvIO(PL_last_in_gv)) {
1033 sv_setiv(sv, (IV)IoLINES(GvIOp(PL_last_in_gv)));
1038 sv_setiv(sv, (IV)STATUS_CURRENT);
1039 #ifdef COMPLEX_STATUS
1040 SvUPGRADE(sv, SVt_PVLV);
1041 LvTARGOFF(sv) = PL_statusvalue;
1042 LvTARGLEN(sv) = PL_statusvalue_vms;
1047 if (GvIOp(PL_defoutgv))
1048 s = IoTOP_NAME(GvIOp(PL_defoutgv));
1052 sv_setpv(sv,GvENAME(PL_defoutgv));
1053 sv_catpvs(sv,"_TOP");
1057 if (GvIOp(PL_defoutgv))
1058 s = IoFMT_NAME(GvIOp(PL_defoutgv));
1060 s = GvENAME(PL_defoutgv);
1064 if (GvIO(PL_defoutgv))
1065 sv_setiv(sv, (IV)IoPAGE_LEN(GvIOp(PL_defoutgv)));
1068 if (GvIO(PL_defoutgv))
1069 sv_setiv(sv, (IV)IoLINES_LEFT(GvIOp(PL_defoutgv)));
1072 if (GvIO(PL_defoutgv))
1073 sv_setiv(sv, (IV)IoPAGE(GvIOp(PL_defoutgv)));
1083 if (GvIO(PL_defoutgv))
1084 sv_setiv(sv, (IV)(IoFLAGS(GvIOp(PL_defoutgv)) & IOf_FLUSH) != 0 );
1088 sv_copypv(sv, PL_ors_sv);
1090 sv_setsv(sv, &PL_sv_undef);
1094 IV const pid = (IV)PerlProc_getpid();
1095 if (isGV(mg->mg_obj) || SvIV(mg->mg_obj) != pid) {
1096 /* never set manually, or at least not since last fork */
1098 /* never unsafe, even if reading in a tainted expression */
1101 /* else a value has been assigned manually, so do nothing */
1105 sv_setuid(sv, PerlProc_getuid());
1108 sv_setuid(sv, PerlProc_geteuid());
1111 sv_setgid(sv, PerlProc_getgid());
1114 sv_setgid(sv, PerlProc_getegid());
1116 #ifdef HAS_GETGROUPS
1118 Groups_t *gary = NULL;
1120 I32 num_groups = getgroups(0, gary);
1121 if (num_groups > 0) {
1122 Newx(gary, num_groups, Groups_t);
1123 num_groups = getgroups(num_groups, gary);
1124 for (i = 0; i < num_groups; i++)
1125 Perl_sv_catpvf(aTHX_ sv, " %"IVdf, (IV)gary[i]);
1129 (void)SvIOK_on(sv); /* what a wonderful hack! */
1139 Perl_magic_getuvar(pTHX_ SV *sv, MAGIC *mg)
1141 struct ufuncs * const uf = (struct ufuncs *)mg->mg_ptr;
1143 PERL_ARGS_ASSERT_MAGIC_GETUVAR;
1145 if (uf && uf->uf_val)
1146 (*uf->uf_val)(aTHX_ uf->uf_index, sv);
1151 Perl_magic_setenv(pTHX_ SV *sv, MAGIC *mg)
1154 STRLEN len = 0, klen;
1155 const char * const key = MgPV_const(mg,klen);
1158 PERL_ARGS_ASSERT_MAGIC_SETENV;
1162 /* defined environment variables are byte strings; unfortunately
1163 there is no SvPVbyte_force_nomg(), so we must do this piecewise */
1164 (void)SvPV_force_nomg_nolen(sv);
1165 sv_utf8_downgrade(sv, /* fail_ok */ TRUE);
1167 Perl_ck_warner_d(aTHX_ packWARN(WARN_UTF8), "Wide character in %s", "setenv");
1173 my_setenv(key, s); /* does the deed */
1175 #ifdef DYNAMIC_ENV_FETCH
1176 /* We just undefd an environment var. Is a replacement */
1177 /* waiting in the wings? */
1179 SV ** const valp = hv_fetch(GvHVn(PL_envgv), key, klen, FALSE);
1181 s = SvOK(*valp) ? SvPV_const(*valp, len) : "";
1185 #if !defined(OS2) && !defined(AMIGAOS) && !defined(WIN32) && !defined(MSDOS)
1186 /* And you'll never guess what the dog had */
1187 /* in its mouth... */
1189 MgTAINTEDDIR_off(mg);
1191 if (s && klen == 8 && strEQ(key, "DCL$PATH")) {
1192 char pathbuf[256], eltbuf[256], *cp, *elt;
1195 my_strlcpy(eltbuf, s, sizeof(eltbuf));
1197 do { /* DCL$PATH may be a search list */
1198 while (1) { /* as may dev portion of any element */
1199 if ( ((cp = strchr(elt,'[')) || (cp = strchr(elt,'<'))) ) {
1200 if ( *(cp+1) == '.' || *(cp+1) == '-' ||
1201 cando_by_name(S_IWUSR,0,elt) ) {
1202 MgTAINTEDDIR_on(mg);
1206 if ((cp = strchr(elt, ':')) != NULL)
1208 if (my_trnlnm(elt, eltbuf, j++))
1214 } while (my_trnlnm(s, pathbuf, i++) && (elt = pathbuf));
1217 if (s && klen == 4 && strEQ(key,"PATH")) {
1218 const char * const strend = s + len;
1220 while (s < strend) {
1224 #ifdef VMS /* Hmm. How do we get $Config{path_sep} from C? */
1225 const char path_sep = '|';
1227 const char path_sep = ':';
1229 s = delimcpy(tmpbuf, tmpbuf + sizeof tmpbuf,
1230 s, strend, path_sep, &i);
1232 if (i >= (I32)sizeof tmpbuf /* too long -- assume the worst */
1234 || !strchr(tmpbuf, ':') /* no colon thus no device name -- assume relative path */
1236 || *tmpbuf != '/' /* no starting slash -- assume relative path */
1238 || (PerlLIO_stat(tmpbuf, &st) == 0 && (st.st_mode & 2)) ) {
1239 MgTAINTEDDIR_on(mg);
1245 #endif /* neither OS2 nor AMIGAOS nor WIN32 nor MSDOS */
1251 Perl_magic_clearenv(pTHX_ SV *sv, MAGIC *mg)
1253 PERL_ARGS_ASSERT_MAGIC_CLEARENV;
1254 PERL_UNUSED_ARG(sv);
1255 my_setenv(MgPV_nolen_const(mg),NULL);
1260 Perl_magic_set_all_env(pTHX_ SV *sv, MAGIC *mg)
1263 PERL_ARGS_ASSERT_MAGIC_SET_ALL_ENV;
1264 PERL_UNUSED_ARG(mg);
1266 Perl_die(aTHX_ "Can't make list assignment to %%ENV on this system");
1268 if (PL_localizing) {
1271 hv_iterinit(MUTABLE_HV(sv));
1272 while ((entry = hv_iternext(MUTABLE_HV(sv)))) {
1274 my_setenv(hv_iterkey(entry, &keylen),
1275 SvPV_nolen_const(hv_iterval(MUTABLE_HV(sv), entry)));
1283 Perl_magic_clear_all_env(pTHX_ SV *sv, MAGIC *mg)
1286 PERL_ARGS_ASSERT_MAGIC_CLEAR_ALL_ENV;
1287 PERL_UNUSED_ARG(sv);
1288 PERL_UNUSED_ARG(mg);
1290 Perl_die(aTHX_ "Can't make list assignment to %%ENV on this system");
1298 #ifdef HAS_SIGPROCMASK
1300 restore_sigmask(pTHX_ SV *save_sv)
1302 const sigset_t * const ossetp = (const sigset_t *) SvPV_nolen_const( save_sv );
1303 (void)sigprocmask(SIG_SETMASK, ossetp, NULL);
1307 Perl_magic_getsig(pTHX_ SV *sv, MAGIC *mg)
1310 /* Are we fetching a signal entry? */
1311 int i = (I16)mg->mg_private;
1313 PERL_ARGS_ASSERT_MAGIC_GETSIG;
1317 const char * sig = MgPV_const(mg, siglen);
1318 mg->mg_private = i = whichsig_pvn(sig, siglen);
1323 sv_setsv(sv,PL_psig_ptr[i]);
1325 Sighandler_t sigstate = rsignal_state(i);
1326 #ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1327 if (PL_sig_handlers_initted && PL_sig_ignoring[i])
1330 #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1331 if (PL_sig_handlers_initted && PL_sig_defaulting[i])
1334 /* cache state so we don't fetch it again */
1335 if(sigstate == (Sighandler_t) SIG_IGN)
1336 sv_setpvs(sv,"IGNORE");
1338 sv_setsv(sv,&PL_sv_undef);
1339 PL_psig_ptr[i] = SvREFCNT_inc_simple_NN(sv);
1346 Perl_magic_clearsig(pTHX_ SV *sv, MAGIC *mg)
1348 PERL_ARGS_ASSERT_MAGIC_CLEARSIG;
1350 magic_setsig(NULL, mg);
1351 return sv_unmagic(sv, mg->mg_type);
1355 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
1356 Perl_csighandler(int sig, siginfo_t *sip PERL_UNUSED_DECL, void *uap PERL_UNUSED_DECL)
1358 Perl_csighandler(int sig)
1361 #ifdef PERL_GET_SIG_CONTEXT
1362 dTHXa(PERL_GET_SIG_CONTEXT);
1366 #ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1367 (void) rsignal(sig, PL_csighandlerp);
1368 if (PL_sig_ignoring[sig]) return;
1370 #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1371 if (PL_sig_defaulting[sig])
1372 #ifdef KILL_BY_SIGPRC
1373 exit((Perl_sig_to_vmscondition(sig)&STS$M_COND_ID)|STS$K_SEVERE|STS$M_INHIB_MSG);
1388 (PL_signals & PERL_SIGNALS_UNSAFE_FLAG))
1389 /* Call the perl level handler now--
1390 * with risk we may be in malloc() or being destructed etc. */
1391 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
1392 (*PL_sighandlerp)(sig, NULL, NULL);
1394 (*PL_sighandlerp)(sig);
1397 if (!PL_psig_pend) return;
1398 /* Set a flag to say this signal is pending, that is awaiting delivery after
1399 * the current Perl opcode completes */
1400 PL_psig_pend[sig]++;
1402 #ifndef SIG_PENDING_DIE_COUNT
1403 # define SIG_PENDING_DIE_COUNT 120
1405 /* Add one to say _a_ signal is pending */
1406 if (++PL_sig_pending >= SIG_PENDING_DIE_COUNT)
1407 Perl_croak(aTHX_ "Maximal count of pending signals (%lu) exceeded",
1408 (unsigned long)SIG_PENDING_DIE_COUNT);
1412 #if defined(FAKE_PERSISTENT_SIGNAL_HANDLERS) || defined(FAKE_DEFAULT_SIGNAL_HANDLERS)
1414 Perl_csighandler_init(void)
1417 if (PL_sig_handlers_initted) return;
1419 for (sig = 1; sig < SIG_SIZE; sig++) {
1420 #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1422 PL_sig_defaulting[sig] = 1;
1423 (void) rsignal(sig, PL_csighandlerp);
1425 #ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1426 PL_sig_ignoring[sig] = 0;
1429 PL_sig_handlers_initted = 1;
1433 #if defined HAS_SIGPROCMASK
1435 unblock_sigmask(pTHX_ void* newset)
1437 PERL_UNUSED_CONTEXT;
1438 sigprocmask(SIG_UNBLOCK, (sigset_t*)newset, NULL);
1443 Perl_despatch_signals(pTHX)
1448 for (sig = 1; sig < SIG_SIZE; sig++) {
1449 if (PL_psig_pend[sig]) {
1451 #ifdef HAS_SIGPROCMASK
1452 /* From sigaction(2) (FreeBSD man page):
1453 * | Signal routines normally execute with the signal that
1454 * | caused their invocation blocked, but other signals may
1456 * Emulation of this behavior (from within Perl) is enabled
1460 sigset_t newset, oldset;
1462 sigemptyset(&newset);
1463 sigaddset(&newset, sig);
1464 sigprocmask(SIG_BLOCK, &newset, &oldset);
1465 was_blocked = sigismember(&oldset, sig);
1467 SV* save_sv = newSVpvn((char *)(&newset), sizeof(sigset_t));
1469 SAVEFREESV(save_sv);
1470 SAVEDESTRUCTOR_X(unblock_sigmask, SvPV_nolen(save_sv));
1473 PL_psig_pend[sig] = 0;
1474 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
1475 (*PL_sighandlerp)(sig, NULL, NULL);
1477 (*PL_sighandlerp)(sig);
1479 #ifdef HAS_SIGPROCMASK
1488 /* sv of NULL signifies that we're acting as magic_clearsig. */
1490 Perl_magic_setsig(pTHX_ SV *sv, MAGIC *mg)
1495 /* Need to be careful with SvREFCNT_dec(), because that can have side
1496 * effects (due to closures). We must make sure that the new disposition
1497 * is in place before it is called.
1501 #ifdef HAS_SIGPROCMASK
1505 const char *s = MgPV_const(mg,len);
1507 PERL_ARGS_ASSERT_MAGIC_SETSIG;
1510 if (memEQs(s, len, "__DIE__"))
1512 else if (memEQs(s, len, "__WARN__")
1513 && (sv ? 1 : PL_warnhook != PERL_WARNHOOK_FATAL)) {
1514 /* Merge the existing behaviours, which are as follows:
1515 magic_setsig, we always set svp to &PL_warnhook
1516 (hence we always change the warnings handler)
1517 For magic_clearsig, we don't change the warnings handler if it's
1518 set to the &PL_warnhook. */
1521 SV *tmp = sv_newmortal();
1522 Perl_croak(aTHX_ "No such hook: %s",
1523 pv_pretty(tmp, s, len, 0, NULL, NULL, 0));
1527 if (*svp != PERL_WARNHOOK_FATAL)
1533 i = (I16)mg->mg_private;
1535 i = whichsig_pvn(s, len); /* ...no, a brick */
1536 mg->mg_private = (U16)i;
1540 SV *tmp = sv_newmortal();
1541 Perl_ck_warner(aTHX_ packWARN(WARN_SIGNAL), "No such signal: SIG%s",
1542 pv_pretty(tmp, s, len, 0, NULL, NULL, 0));
1546 #ifdef HAS_SIGPROCMASK
1547 /* Avoid having the signal arrive at a bad time, if possible. */
1550 sigprocmask(SIG_BLOCK, &set, &save);
1552 save_sv = newSVpvn((char *)(&save), sizeof(sigset_t));
1553 SAVEFREESV(save_sv);
1554 SAVEDESTRUCTOR_X(restore_sigmask, save_sv);
1557 #if defined(FAKE_PERSISTENT_SIGNAL_HANDLERS) || defined(FAKE_DEFAULT_SIGNAL_HANDLERS)
1558 if (!PL_sig_handlers_initted) Perl_csighandler_init();
1560 #ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1561 PL_sig_ignoring[i] = 0;
1563 #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1564 PL_sig_defaulting[i] = 0;
1566 to_dec = PL_psig_ptr[i];
1568 PL_psig_ptr[i] = SvREFCNT_inc_simple_NN(sv);
1569 SvTEMP_off(sv); /* Make sure it doesn't go away on us */
1571 /* Signals don't change name during the program's execution, so once
1572 they're cached in the appropriate slot of PL_psig_name, they can
1575 Ideally we'd find some way of making SVs at (C) compile time, or
1576 at least, doing most of the work. */
1577 if (!PL_psig_name[i]) {
1578 PL_psig_name[i] = newSVpvn(s, len);
1579 SvREADONLY_on(PL_psig_name[i]);
1582 SvREFCNT_dec(PL_psig_name[i]);
1583 PL_psig_name[i] = NULL;
1584 PL_psig_ptr[i] = NULL;
1587 if (sv && (isGV_with_GP(sv) || SvROK(sv))) {
1589 (void)rsignal(i, PL_csighandlerp);
1592 *svp = SvREFCNT_inc_simple_NN(sv);
1594 if (sv && SvOK(sv)) {
1595 s = SvPV_force(sv, len);
1599 if (sv && memEQs(s, len,"IGNORE")) {
1601 #ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1602 PL_sig_ignoring[i] = 1;
1603 (void)rsignal(i, PL_csighandlerp);
1605 (void)rsignal(i, (Sighandler_t) SIG_IGN);
1609 else if (!sv || memEQs(s, len,"DEFAULT") || !len) {
1611 #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1612 PL_sig_defaulting[i] = 1;
1613 (void)rsignal(i, PL_csighandlerp);
1615 (void)rsignal(i, (Sighandler_t) SIG_DFL);
1621 * We should warn if HINT_STRICT_REFS, but without
1622 * access to a known hint bit in a known OP, we can't
1623 * tell whether HINT_STRICT_REFS is in force or not.
1625 if (!strchr(s,':') && !strchr(s,'\''))
1626 Perl_sv_insert_flags(aTHX_ sv, 0, 0, STR_WITH_LEN("main::"),
1629 (void)rsignal(i, PL_csighandlerp);
1631 *svp = SvREFCNT_inc_simple_NN(sv);
1635 #ifdef HAS_SIGPROCMASK
1639 SvREFCNT_dec(to_dec);
1642 #endif /* !PERL_MICRO */
1645 Perl_magic_setisa(pTHX_ SV *sv, MAGIC *mg)
1648 PERL_ARGS_ASSERT_MAGIC_SETISA;
1649 PERL_UNUSED_ARG(sv);
1651 /* Skip _isaelem because _isa will handle it shortly */
1652 if (PL_delaymagic & DM_ARRAY_ISA && mg->mg_type == PERL_MAGIC_isaelem)
1655 return magic_clearisa(NULL, mg);
1658 /* sv of NULL signifies that we're acting as magic_setisa. */
1660 Perl_magic_clearisa(pTHX_ SV *sv, MAGIC *mg)
1665 PERL_ARGS_ASSERT_MAGIC_CLEARISA;
1667 /* Bail out if destruction is going on */
1668 if(PL_phase == PERL_PHASE_DESTRUCT) return 0;
1671 av_clear(MUTABLE_AV(sv));
1673 if (SvTYPE(mg->mg_obj) != SVt_PVGV && SvSMAGICAL(mg->mg_obj))
1674 /* This occurs with setisa_elem magic, which calls this
1676 mg = mg_find(mg->mg_obj, PERL_MAGIC_isa);
1679 if (SvTYPE(mg->mg_obj) == SVt_PVAV) { /* multiple stashes */
1680 SV **svp = AvARRAY((AV *)mg->mg_obj);
1681 I32 items = AvFILLp((AV *)mg->mg_obj) + 1;
1683 stash = GvSTASH((GV *)*svp++);
1684 if (stash && HvENAME(stash)) mro_isa_changed_in(stash);
1691 (const GV *)mg->mg_obj
1694 /* The stash may have been detached from the symbol table, so check its
1695 name before doing anything. */
1696 if (stash && HvENAME_get(stash))
1697 mro_isa_changed_in(stash);
1703 Perl_magic_getnkeys(pTHX_ SV *sv, MAGIC *mg)
1705 HV * const hv = MUTABLE_HV(LvTARG(sv));
1708 PERL_ARGS_ASSERT_MAGIC_GETNKEYS;
1709 PERL_UNUSED_ARG(mg);
1712 (void) hv_iterinit(hv);
1713 if (! SvTIED_mg((const SV *)hv, PERL_MAGIC_tied))
1716 while (hv_iternext(hv))
1721 sv_setiv(sv, (IV)i);
1726 Perl_magic_setnkeys(pTHX_ SV *sv, MAGIC *mg)
1728 PERL_ARGS_ASSERT_MAGIC_SETNKEYS;
1729 PERL_UNUSED_ARG(mg);
1731 hv_ksplit(MUTABLE_HV(LvTARG(sv)), SvIV(sv));
1737 =for apidoc magic_methcall
1739 Invoke a magic method (like FETCH).
1741 C<sv> and C<mg> are the tied thingy and the tie magic.
1743 C<meth> is the name of the method to call.
1745 C<argc> is the number of args (in addition to $self) to pass to the method.
1747 The C<flags> can be:
1749 G_DISCARD invoke method with G_DISCARD flag and don't
1751 G_UNDEF_FILL fill the stack with argc pointers to
1754 The arguments themselves are any values following the C<flags> argument.
1756 Returns the SV (if any) returned by the method, or NULL on failure.
1763 Perl_magic_methcall(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags,
1770 PERL_ARGS_ASSERT_MAGIC_METHCALL;
1774 if (flags & G_WRITING_TO_STDERR) {
1778 SAVESPTR(PL_stderrgv);
1782 PUSHSTACKi(PERLSI_MAGIC);
1786 PUSHs(SvTIED_obj(sv, mg));
1787 if (flags & G_UNDEF_FILL) {
1789 PUSHs(&PL_sv_undef);
1791 } else if (argc > 0) {
1793 va_start(args, argc);
1796 SV *const sv = va_arg(args, SV *);
1803 if (flags & G_DISCARD) {
1804 call_sv(meth, G_SCALAR|G_DISCARD|G_METHOD_NAMED);
1807 if (call_sv(meth, G_SCALAR|G_METHOD_NAMED))
1808 ret = *PL_stack_sp--;
1811 if (flags & G_WRITING_TO_STDERR)
1817 /* wrapper for magic_methcall that creates the first arg */
1820 S_magic_methcall1(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags,
1826 PERL_ARGS_ASSERT_MAGIC_METHCALL1;
1829 if (mg->mg_len >= 0) {
1830 arg1 = newSVpvn_flags(mg->mg_ptr, mg->mg_len, SVs_TEMP);
1832 else if (mg->mg_len == HEf_SVKEY)
1833 arg1 = MUTABLE_SV(mg->mg_ptr);
1835 else if (mg->mg_type == PERL_MAGIC_tiedelem) {
1836 arg1 = newSViv((IV)(mg->mg_len));
1840 return Perl_magic_methcall(aTHX_ sv, mg, meth, flags, n - 1, val);
1842 return Perl_magic_methcall(aTHX_ sv, mg, meth, flags, n, arg1, val);
1846 S_magic_methpack(pTHX_ SV *sv, const MAGIC *mg, SV *meth)
1851 PERL_ARGS_ASSERT_MAGIC_METHPACK;
1853 ret = magic_methcall1(sv, mg, meth, 0, 1, NULL);
1860 Perl_magic_getpack(pTHX_ SV *sv, MAGIC *mg)
1862 PERL_ARGS_ASSERT_MAGIC_GETPACK;
1864 if (mg->mg_type == PERL_MAGIC_tiedelem)
1865 mg->mg_flags |= MGf_GSKIP;
1866 magic_methpack(sv,mg,SV_CONST(FETCH));
1871 Perl_magic_setpack(pTHX_ SV *sv, MAGIC *mg)
1877 PERL_ARGS_ASSERT_MAGIC_SETPACK;
1879 /* in the code C<$tied{foo} = $val>, the "thing" that gets passed to
1880 * STORE() is not $val, but rather a PVLV (the sv in this call), whose
1881 * public flags indicate its value based on copying from $val. Doing
1882 * mg_set() on the PVLV temporarily does SvMAGICAL_off(), then calls us.
1883 * So STORE()'s $_[2] arg is a temporarily disarmed PVLV. This goes
1884 * wrong if $val happened to be tainted, as sv hasn't got magic
1885 * enabled, even though taint magic is in the chain. In which case,
1886 * fake up a temporary tainted value (this is easier than temporarily
1887 * re-enabling magic on sv). */
1889 if (TAINTING_get && (tmg = mg_find(sv, PERL_MAGIC_taint))
1890 && (tmg->mg_len & 1))
1892 val = sv_mortalcopy(sv);
1898 magic_methcall1(sv, mg, SV_CONST(STORE), G_DISCARD, 2, val);
1903 Perl_magic_clearpack(pTHX_ SV *sv, MAGIC *mg)
1905 PERL_ARGS_ASSERT_MAGIC_CLEARPACK;
1907 if (mg->mg_type == PERL_MAGIC_tiedscalar) return 0;
1908 return magic_methpack(sv,mg,SV_CONST(DELETE));
1913 Perl_magic_sizepack(pTHX_ SV *sv, MAGIC *mg)
1919 PERL_ARGS_ASSERT_MAGIC_SIZEPACK;
1921 retsv = magic_methcall1(sv, mg, SV_CONST(FETCHSIZE), 0, 1, NULL);
1923 retval = SvIV(retsv)-1;
1925 Perl_croak(aTHX_ "FETCHSIZE returned a negative value");
1927 return (U32) retval;
1931 Perl_magic_wipepack(pTHX_ SV *sv, MAGIC *mg)
1935 PERL_ARGS_ASSERT_MAGIC_WIPEPACK;
1937 Perl_magic_methcall(aTHX_ sv, mg, SV_CONST(CLEAR), G_DISCARD, 0);
1942 Perl_magic_nextpack(pTHX_ SV *sv, MAGIC *mg, SV *key)
1947 PERL_ARGS_ASSERT_MAGIC_NEXTPACK;
1949 ret = SvOK(key) ? Perl_magic_methcall(aTHX_ sv, mg, SV_CONST(NEXTKEY), 0, 1, key)
1950 : Perl_magic_methcall(aTHX_ sv, mg, SV_CONST(FIRSTKEY), 0, 0);
1957 Perl_magic_existspack(pTHX_ SV *sv, const MAGIC *mg)
1959 PERL_ARGS_ASSERT_MAGIC_EXISTSPACK;
1961 return magic_methpack(sv,mg,SV_CONST(EXISTS));
1965 Perl_magic_scalarpack(pTHX_ HV *hv, MAGIC *mg)
1969 SV * const tied = SvTIED_obj(MUTABLE_SV(hv), mg);
1970 HV * const pkg = SvSTASH((const SV *)SvRV(tied));
1972 PERL_ARGS_ASSERT_MAGIC_SCALARPACK;
1974 if (!gv_fetchmethod_autoload(pkg, "SCALAR", FALSE)) {
1976 if (HvEITER_get(hv))
1977 /* we are in an iteration so the hash cannot be empty */
1979 /* no xhv_eiter so now use FIRSTKEY */
1980 key = sv_newmortal();
1981 magic_nextpack(MUTABLE_SV(hv), mg, key);
1982 HvEITER_set(hv, NULL); /* need to reset iterator */
1983 return SvOK(key) ? &PL_sv_yes : &PL_sv_no;
1986 /* there is a SCALAR method that we can call */
1987 retval = Perl_magic_methcall(aTHX_ MUTABLE_SV(hv), mg, SV_CONST(SCALAR), 0, 0);
1989 retval = &PL_sv_undef;
1994 Perl_magic_setdbline(pTHX_ SV *sv, MAGIC *mg)
1999 PERL_ARGS_ASSERT_MAGIC_SETDBLINE;
2001 /* The magic ptr/len for the debugger's hash should always be an SV. */
2002 if (UNLIKELY(mg->mg_len != HEf_SVKEY)) {
2003 Perl_croak(aTHX_ "panic: magic_setdbline len=%"IVdf", ptr='%s'",
2004 (IV)mg->mg_len, mg->mg_ptr);
2007 /* Use sv_2iv instead of SvIV() as the former generates smaller code, and
2008 setting/clearing debugger breakpoints is not a hot path. */
2009 svp = av_fetch(MUTABLE_AV(mg->mg_obj),
2010 sv_2iv(MUTABLE_SV((mg)->mg_ptr)), FALSE);
2012 if (svp && SvIOKp(*svp)) {
2013 OP * const o = INT2PTR(OP*,SvIVX(*svp));
2015 #ifdef PERL_DEBUG_READONLY_OPS
2016 Slab_to_rw(OpSLAB(o));
2018 /* set or clear breakpoint in the relevant control op */
2020 o->op_flags |= OPf_SPECIAL;
2022 o->op_flags &= ~OPf_SPECIAL;
2023 #ifdef PERL_DEBUG_READONLY_OPS
2024 Slab_to_ro(OpSLAB(o));
2032 Perl_magic_getarylen(pTHX_ SV *sv, const MAGIC *mg)
2035 AV * const obj = MUTABLE_AV(mg->mg_obj);
2037 PERL_ARGS_ASSERT_MAGIC_GETARYLEN;
2040 sv_setiv(sv, AvFILL(obj));
2048 Perl_magic_setarylen(pTHX_ SV *sv, MAGIC *mg)
2051 AV * const obj = MUTABLE_AV(mg->mg_obj);
2053 PERL_ARGS_ASSERT_MAGIC_SETARYLEN;
2056 av_fill(obj, SvIV(sv));
2058 Perl_ck_warner(aTHX_ packWARN(WARN_MISC),
2059 "Attempt to set length of freed array");
2065 Perl_magic_cleararylen_p(pTHX_ SV *sv, MAGIC *mg)
2069 PERL_ARGS_ASSERT_MAGIC_CLEARARYLEN_P;
2070 PERL_UNUSED_ARG(sv);
2071 PERL_UNUSED_CONTEXT;
2073 /* Reset the iterator when the array is cleared */
2074 #if IVSIZE == I32SIZE
2075 *((IV *) &(mg->mg_len)) = 0;
2078 *((IV *) mg->mg_ptr) = 0;
2085 Perl_magic_freearylen_p(pTHX_ SV *sv, MAGIC *mg)
2089 PERL_ARGS_ASSERT_MAGIC_FREEARYLEN_P;
2090 PERL_UNUSED_ARG(sv);
2092 /* during global destruction, mg_obj may already have been freed */
2093 if (PL_in_clean_all)
2096 mg = mg_find (mg->mg_obj, PERL_MAGIC_arylen);
2099 /* arylen scalar holds a pointer back to the array, but doesn't own a
2100 reference. Hence the we (the array) are about to go away with it
2101 still pointing at us. Clear its pointer, else it would be pointing
2102 at free memory. See the comment in sv_magic about reference loops,
2103 and why it can't own a reference to us. */
2110 Perl_magic_getpos(pTHX_ SV *sv, MAGIC *mg)
2113 SV* const lsv = LvTARG(sv);
2114 MAGIC * const found = mg_find_mglob(lsv);
2116 PERL_ARGS_ASSERT_MAGIC_GETPOS;
2117 PERL_UNUSED_ARG(mg);
2119 if (found && found->mg_len != -1) {
2120 STRLEN i = found->mg_len;
2121 if (found->mg_flags & MGf_BYTES && DO_UTF8(lsv))
2122 i = sv_pos_b2u_flags(lsv, i, SV_GMAGIC|SV_CONST_RETURN);
2131 Perl_magic_setpos(pTHX_ SV *sv, MAGIC *mg)
2134 SV* const lsv = LvTARG(sv);
2141 PERL_ARGS_ASSERT_MAGIC_SETPOS;
2142 PERL_UNUSED_ARG(mg);
2144 found = mg_find_mglob(lsv);
2148 found = sv_magicext_mglob(lsv);
2150 else if (!SvOK(sv)) {
2154 s = SvPV_const(lsv, len);
2159 ulen = sv_or_pv_len_utf8(lsv, s, len);
2169 else if (pos > (SSize_t)len)
2172 found->mg_len = pos;
2173 found->mg_flags &= ~(MGf_MINMATCH|MGf_BYTES);
2179 Perl_magic_getsubstr(pTHX_ SV *sv, MAGIC *mg)
2182 SV * const lsv = LvTARG(sv);
2183 const char * const tmps = SvPV_const(lsv,len);
2184 STRLEN offs = LvTARGOFF(sv);
2185 STRLEN rem = LvTARGLEN(sv);
2186 const bool negoff = LvFLAGS(sv) & 1;
2187 const bool negrem = LvFLAGS(sv) & 2;
2189 PERL_ARGS_ASSERT_MAGIC_GETSUBSTR;
2190 PERL_UNUSED_ARG(mg);
2192 if (!translate_substr_offsets(
2193 SvUTF8(lsv) ? sv_or_pv_len_utf8(lsv, tmps, len) : len,
2194 negoff ? -(IV)offs : (IV)offs, !negoff,
2195 negrem ? -(IV)rem : (IV)rem, !negrem, &offs, &rem
2197 Perl_ck_warner(aTHX_ packWARN(WARN_SUBSTR), "substr outside of string");
2198 sv_setsv_nomg(sv, &PL_sv_undef);
2203 offs = sv_or_pv_pos_u2b(lsv, tmps, offs, &rem);
2204 sv_setpvn(sv, tmps + offs, rem);
2211 Perl_magic_setsubstr(pTHX_ SV *sv, MAGIC *mg)
2214 STRLEN len, lsv_len, oldtarglen, newtarglen;
2215 const char * const tmps = SvPV_const(sv, len);
2216 SV * const lsv = LvTARG(sv);
2217 STRLEN lvoff = LvTARGOFF(sv);
2218 STRLEN lvlen = LvTARGLEN(sv);
2219 const bool negoff = LvFLAGS(sv) & 1;
2220 const bool neglen = LvFLAGS(sv) & 2;
2222 PERL_ARGS_ASSERT_MAGIC_SETSUBSTR;
2223 PERL_UNUSED_ARG(mg);
2227 Perl_ck_warner(aTHX_ packWARN(WARN_SUBSTR),
2228 "Attempt to use reference as lvalue in substr"
2230 SvPV_force_nomg(lsv,lsv_len);
2231 if (SvUTF8(lsv)) lsv_len = sv_len_utf8_nomg(lsv);
2232 if (!translate_substr_offsets(
2234 negoff ? -(IV)lvoff : (IV)lvoff, !negoff,
2235 neglen ? -(IV)lvlen : (IV)lvlen, !neglen, &lvoff, &lvlen
2237 Perl_croak(aTHX_ "substr outside of string");
2240 sv_utf8_upgrade_nomg(lsv);
2241 lvoff = sv_pos_u2b_flags(lsv, lvoff, &lvlen, SV_CONST_RETURN);
2242 sv_insert_flags(lsv, lvoff, lvlen, tmps, len, 0);
2243 newtarglen = sv_or_pv_len_utf8(sv, tmps, len);
2246 else if (SvUTF8(lsv)) {
2248 lvoff = sv_pos_u2b_flags(lsv, lvoff, &lvlen, SV_CONST_RETURN);
2250 utf8 = (char*)bytes_to_utf8((U8*)tmps, &len);
2251 sv_insert_flags(lsv, lvoff, lvlen, utf8, len, 0);
2255 sv_insert_flags(lsv, lvoff, lvlen, tmps, len, 0);
2258 if (!neglen) LvTARGLEN(sv) = newtarglen;
2259 if (negoff) LvTARGOFF(sv) += newtarglen - oldtarglen;
2265 Perl_magic_gettaint(pTHX_ SV *sv, MAGIC *mg)
2269 PERL_ARGS_ASSERT_MAGIC_GETTAINT;
2270 PERL_UNUSED_ARG(sv);
2271 #ifdef NO_TAINT_SUPPORT
2272 PERL_UNUSED_ARG(mg);
2275 TAINT_IF((PL_localizing != 1) && (mg->mg_len & 1));
2280 Perl_magic_settaint(pTHX_ SV *sv, MAGIC *mg)
2284 PERL_ARGS_ASSERT_MAGIC_SETTAINT;
2285 PERL_UNUSED_ARG(sv);
2287 /* update taint status */
2296 Perl_magic_getvec(pTHX_ SV *sv, MAGIC *mg)
2298 SV * const lsv = LvTARG(sv);
2300 PERL_ARGS_ASSERT_MAGIC_GETVEC;
2301 PERL_UNUSED_ARG(mg);
2303 sv_setuv(sv, do_vecget(lsv, LvTARGOFF(sv), LvTARGLEN(sv)));
2309 Perl_magic_setvec(pTHX_ SV *sv, MAGIC *mg)
2311 PERL_ARGS_ASSERT_MAGIC_SETVEC;
2312 PERL_UNUSED_ARG(mg);
2313 do_vecset(sv); /* XXX slurp this routine */
2318 Perl_defelem_target(pTHX_ SV *sv, MAGIC *mg)
2322 PERL_ARGS_ASSERT_DEFELEM_TARGET;
2323 if (!mg) mg = mg_find(sv, PERL_MAGIC_defelem);
2325 if (LvTARGLEN(sv)) {
2327 SV * const ahv = LvTARG(sv);
2328 HE * const he = hv_fetch_ent(MUTABLE_HV(ahv), mg->mg_obj, FALSE, 0);
2332 else if (LvSTARGOFF(sv) >= 0) {
2333 AV *const av = MUTABLE_AV(LvTARG(sv));
2334 if (LvSTARGOFF(sv) <= AvFILL(av))
2336 if (SvRMAGICAL(av)) {
2337 SV * const * const svp = av_fetch(av, LvSTARGOFF(sv), 0);
2338 targ = svp ? *svp : NULL;
2341 targ = AvARRAY(av)[LvSTARGOFF(sv)];
2344 if (targ && (targ != &PL_sv_undef)) {
2345 /* somebody else defined it for us */
2346 SvREFCNT_dec(LvTARG(sv));
2347 LvTARG(sv) = SvREFCNT_inc_simple_NN(targ);
2349 SvREFCNT_dec(mg->mg_obj);
2351 mg->mg_flags &= ~MGf_REFCOUNTED;
2360 Perl_magic_getdefelem(pTHX_ SV *sv, MAGIC *mg)
2362 PERL_ARGS_ASSERT_MAGIC_GETDEFELEM;
2364 sv_setsv(sv, defelem_target(sv, mg));
2369 Perl_magic_setdefelem(pTHX_ SV *sv, MAGIC *mg)
2371 PERL_ARGS_ASSERT_MAGIC_SETDEFELEM;
2372 PERL_UNUSED_ARG(mg);
2376 sv_setsv(LvTARG(sv), sv);
2377 SvSETMAGIC(LvTARG(sv));
2383 Perl_vivify_defelem(pTHX_ SV *sv)
2389 PERL_ARGS_ASSERT_VIVIFY_DEFELEM;
2391 if (!LvTARGLEN(sv) || !(mg = mg_find(sv, PERL_MAGIC_defelem)))
2394 SV * const ahv = LvTARG(sv);
2395 HE * const he = hv_fetch_ent(MUTABLE_HV(ahv), mg->mg_obj, TRUE, 0);
2398 if (!value || value == &PL_sv_undef)
2399 Perl_croak(aTHX_ PL_no_helem_sv, SVfARG(mg->mg_obj));
2401 else if (LvSTARGOFF(sv) < 0)
2402 Perl_croak(aTHX_ PL_no_aelem, LvSTARGOFF(sv));
2404 AV *const av = MUTABLE_AV(LvTARG(sv));
2405 if ((I32)LvTARGLEN(sv) < 0 && LvSTARGOFF(sv) > AvFILL(av))
2406 LvTARG(sv) = NULL; /* array can't be extended */
2408 SV* const * const svp = av_fetch(av, LvSTARGOFF(sv), TRUE);
2409 if (!svp || !(value = *svp))
2410 Perl_croak(aTHX_ PL_no_aelem, LvSTARGOFF(sv));
2413 SvREFCNT_inc_simple_void(value);
2414 SvREFCNT_dec(LvTARG(sv));
2417 SvREFCNT_dec(mg->mg_obj);
2419 mg->mg_flags &= ~MGf_REFCOUNTED;
2423 Perl_magic_killbackrefs(pTHX_ SV *sv, MAGIC *mg)
2425 PERL_ARGS_ASSERT_MAGIC_KILLBACKREFS;
2426 Perl_sv_kill_backrefs(aTHX_ sv, MUTABLE_AV(mg->mg_obj));
2431 Perl_magic_setmglob(pTHX_ SV *sv, MAGIC *mg)
2433 PERL_ARGS_ASSERT_MAGIC_SETMGLOB;
2434 PERL_UNUSED_CONTEXT;
2435 PERL_UNUSED_ARG(sv);
2441 Perl_magic_setuvar(pTHX_ SV *sv, MAGIC *mg)
2443 const struct ufuncs * const uf = (struct ufuncs *)mg->mg_ptr;
2445 PERL_ARGS_ASSERT_MAGIC_SETUVAR;
2447 if (uf && uf->uf_set)
2448 (*uf->uf_set)(aTHX_ uf->uf_index, sv);
2453 Perl_magic_setregexp(pTHX_ SV *sv, MAGIC *mg)
2455 const char type = mg->mg_type;
2457 PERL_ARGS_ASSERT_MAGIC_SETREGEXP;
2459 if (type == PERL_MAGIC_qr) {
2460 } else if (type == PERL_MAGIC_bm) {
2464 assert(type == PERL_MAGIC_fm);
2466 return sv_unmagic(sv, type);
2469 #ifdef USE_LOCALE_COLLATE
2471 Perl_magic_setcollxfrm(pTHX_ SV *sv, MAGIC *mg)
2473 PERL_ARGS_ASSERT_MAGIC_SETCOLLXFRM;
2476 * RenE<eacute> Descartes said "I think not."
2477 * and vanished with a faint plop.
2479 PERL_UNUSED_CONTEXT;
2480 PERL_UNUSED_ARG(sv);
2482 Safefree(mg->mg_ptr);
2488 #endif /* USE_LOCALE_COLLATE */
2490 /* Just clear the UTF-8 cache data. */
2492 Perl_magic_setutf8(pTHX_ SV *sv, MAGIC *mg)
2494 PERL_ARGS_ASSERT_MAGIC_SETUTF8;
2495 PERL_UNUSED_CONTEXT;
2496 PERL_UNUSED_ARG(sv);
2497 Safefree(mg->mg_ptr); /* The mg_ptr holds the pos cache. */
2499 mg->mg_len = -1; /* The mg_len holds the len cache. */
2504 Perl_magic_set(pTHX_ SV *sv, MAGIC *mg)
2514 PERL_ARGS_ASSERT_MAGIC_SET;
2518 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
2520 CALLREG_NUMBUF_STORE((REGEXP * const)rx,paren,sv);
2522 /* Croak with a READONLY error when a numbered match var is
2523 * set without a previous pattern match. Unless it's C<local $1>
2526 if (!PL_localizing) {
2527 Perl_croak_no_modify();
2533 switch (*mg->mg_ptr) {
2534 case '\001': /* ^A */
2535 if (SvOK(sv)) sv_copypv(PL_bodytarget, sv);
2536 else SvOK_off(PL_bodytarget);
2537 FmLINES(PL_bodytarget) = 0;
2538 if (SvPOK(PL_bodytarget)) {
2539 char *s = SvPVX(PL_bodytarget);
2540 while ( ((s = strchr(s, '\n'))) ) {
2541 FmLINES(PL_bodytarget)++;
2545 /* mg_set() has temporarily made sv non-magical */
2547 if ((tmg = mg_find(sv,PERL_MAGIC_taint)) && tmg->mg_len & 1)
2548 SvTAINTED_on(PL_bodytarget);
2550 SvTAINTED_off(PL_bodytarget);
2553 case '\003': /* ^C */
2554 PL_minus_c = cBOOL(SvIV(sv));
2557 case '\004': /* ^D */
2559 s = SvPV_nolen_const(sv);
2560 PL_debug = get_debug_opts(&s, 0) | DEBUG_TOP_FLAG;
2561 if (DEBUG_x_TEST || DEBUG_B_TEST)
2562 dump_all_perl(!DEBUG_B_TEST);
2564 PL_debug = (SvIV(sv)) | DEBUG_TOP_FLAG;
2567 case '\005': /* ^E */
2568 if (*(mg->mg_ptr+1) == '\0') {
2570 set_vaxc_errno(SvIV(sv));
2573 SetLastError( SvIV(sv) );
2576 os2_setsyserrno(SvIV(sv));
2578 /* will anyone ever use this? */
2579 SETERRNO(SvIV(sv), 4);
2584 else if (strEQ(mg->mg_ptr+1, "NCODING")) {
2585 SvREFCNT_dec(PL_encoding);
2586 if (SvOK(sv) || SvGMAGICAL(sv)) {
2587 PL_encoding = newSVsv(sv);
2594 case '\006': /* ^F */
2595 PL_maxsysfd = SvIV(sv);
2597 case '\010': /* ^H */
2598 PL_hints = SvIV(sv);
2600 case '\011': /* ^I */ /* NOT \t in EBCDIC */
2601 Safefree(PL_inplace);
2602 PL_inplace = SvOK(sv) ? savesvpv(sv) : NULL;
2604 case '\016': /* ^N */
2605 if (PL_curpm && (rx = PM_GETRE(PL_curpm))
2606 && (paren = RX_LASTCLOSEPAREN(rx))) goto setparen_got_rx;
2608 case '\017': /* ^O */
2609 if (*(mg->mg_ptr+1) == '\0') {
2610 Safefree(PL_osname);
2613 TAINT_PROPER("assigning to $^O");
2614 PL_osname = savesvpv(sv);
2617 else if (strEQ(mg->mg_ptr, "\017PEN")) {
2619 const char *const start = SvPV(sv, len);
2620 const char *out = (const char*)memchr(start, '\0', len);
2624 PL_compiling.cop_hints |= HINT_LEXICAL_IO_IN | HINT_LEXICAL_IO_OUT;
2625 PL_hints |= HINT_LEXICAL_IO_IN | HINT_LEXICAL_IO_OUT;
2627 /* Opening for input is more common than opening for output, so
2628 ensure that hints for input are sooner on linked list. */
2629 tmp = out ? newSVpvn_flags(out + 1, start + len - out - 1,
2631 : newSVpvs_flags("", SvUTF8(sv));
2632 (void)hv_stores(GvHV(PL_hintgv), "open>", tmp);
2635 tmp = newSVpvn_flags(start, out ? (STRLEN)(out - start) : len,
2637 (void)hv_stores(GvHV(PL_hintgv), "open<", tmp);
2641 case '\020': /* ^P */
2642 PL_perldb = SvIV(sv);
2643 if (PL_perldb && !PL_DBsingle)
2646 case '\024': /* ^T */
2648 PL_basetime = (Time_t)(SvNOK(sv) ? SvNVX(sv) : sv_2nv(sv));
2650 PL_basetime = (Time_t)SvIV(sv);
2653 case '\025': /* ^UTF8CACHE */
2654 if (strEQ(mg->mg_ptr+1, "TF8CACHE")) {
2655 PL_utf8cache = (signed char) sv_2iv(sv);
2658 case '\027': /* ^W & $^WARNING_BITS */
2659 if (*(mg->mg_ptr+1) == '\0') {
2660 if ( ! (PL_dowarn & G_WARN_ALL_MASK)) {
2662 PL_dowarn = (PL_dowarn & ~G_WARN_ON)
2663 | (i ? G_WARN_ON : G_WARN_OFF) ;
2666 else if (strEQ(mg->mg_ptr+1, "ARNING_BITS")) {
2667 if ( ! (PL_dowarn & G_WARN_ALL_MASK)) {
2669 PL_compiling.cop_warnings = pWARN_STD;
2674 int accumulate = 0 ;
2675 int any_fatals = 0 ;
2676 const char * const ptr = SvPV_const(sv, len) ;
2677 for (i = 0 ; i < len ; ++i) {
2678 accumulate |= ptr[i] ;
2679 any_fatals |= (ptr[i] & 0xAA) ;
2682 if (!specialWARN(PL_compiling.cop_warnings))
2683 PerlMemShared_free(PL_compiling.cop_warnings);
2684 PL_compiling.cop_warnings = pWARN_NONE;
2686 /* Yuck. I can't see how to abstract this: */
2688 ((STRLEN *)SvPV_nolen_const(sv)) - 1,
2692 if (!specialWARN(PL_compiling.cop_warnings))
2693 PerlMemShared_free(PL_compiling.cop_warnings);
2694 PL_compiling.cop_warnings = pWARN_ALL;
2695 PL_dowarn |= G_WARN_ONCE ;
2699 const char *const p = SvPV_const(sv, len);
2701 PL_compiling.cop_warnings
2702 = Perl_new_warnings_bitfield(aTHX_ PL_compiling.cop_warnings,
2705 if (isWARN_on(PL_compiling.cop_warnings, WARN_ONCE))
2706 PL_dowarn |= G_WARN_ONCE ;
2714 if (PL_localizing) {
2715 if (PL_localizing == 1)
2716 SAVESPTR(PL_last_in_gv);
2718 else if (SvOK(sv) && GvIO(PL_last_in_gv))
2719 IoLINES(GvIOp(PL_last_in_gv)) = SvIV(sv);
2722 Safefree(IoTOP_NAME(GvIOp(PL_defoutgv)));
2723 s = IoTOP_NAME(GvIOp(PL_defoutgv)) = savesvpv(sv);
2724 IoTOP_GV(GvIOp(PL_defoutgv)) = gv_fetchsv(sv, GV_ADD, SVt_PVIO);
2727 Safefree(IoFMT_NAME(GvIOp(PL_defoutgv)));
2728 s = IoFMT_NAME(GvIOp(PL_defoutgv)) = savesvpv(sv);
2729 IoFMT_GV(GvIOp(PL_defoutgv)) = gv_fetchsv(sv, GV_ADD, SVt_PVIO);
2732 IoPAGE_LEN(GvIOp(PL_defoutgv)) = (SvIV(sv));
2735 IoLINES_LEFT(GvIOp(PL_defoutgv)) = (SvIV(sv));
2736 if (IoLINES_LEFT(GvIOp(PL_defoutgv)) < 0L)
2737 IoLINES_LEFT(GvIOp(PL_defoutgv)) = 0L;
2740 IoPAGE(GvIOp(PL_defoutgv)) = (SvIV(sv));
2744 IO * const io = GvIO(PL_defoutgv);
2747 if ((SvIV(sv)) == 0)
2748 IoFLAGS(io) &= ~IOf_FLUSH;
2750 if (!(IoFLAGS(io) & IOf_FLUSH)) {
2751 PerlIO *ofp = IoOFP(io);
2753 (void)PerlIO_flush(ofp);
2754 IoFLAGS(io) |= IOf_FLUSH;
2763 SV *referent= SvRV(sv);
2764 const char *reftype= sv_reftype(referent, 0);
2765 /* XXX: dodgy type check: This leaves me feeling dirty, but the alternative
2766 * is to copy pretty much the entire sv_reftype() into this routine, or to do
2767 * a full string comparison on the return of sv_reftype() both of which
2768 * make me feel worse! NOTE, do not modify this comment without reviewing the
2769 * corresponding comment in sv_reftype(). - Yves */
2770 if (reftype[0] == 'S' || reftype[0] == 'L') {
2771 IV val= SvIV(referent);
2773 tmpsv= &PL_sv_undef;
2774 Perl_ck_warner(aTHX_ packWARN(WARN_DEPRECATED),
2775 "Setting $/ to a reference to %s as a form of slurp is deprecated, treating as undef",
2776 SvIV(SvRV(sv)) < 0 ? "a negative integer" : "zero"
2780 /* diag_listed_as: Setting $/ to %s reference is forbidden */
2781 Perl_croak(aTHX_ "Setting $/ to a%s %s reference is forbidden",
2782 *reftype == 'A' ? "n" : "", reftype);
2785 SvREFCNT_dec(PL_rs);
2786 PL_rs = newSVsv(tmpsv);
2790 SvREFCNT_dec(PL_ors_sv);
2792 PL_ors_sv = newSVsv(sv);
2800 Perl_croak(aTHX_ "Assigning non-zero to $[ is no longer possible");
2803 #ifdef COMPLEX_STATUS
2804 if (PL_localizing == 2) {
2805 SvUPGRADE(sv, SVt_PVLV);
2806 PL_statusvalue = LvTARGOFF(sv);
2807 PL_statusvalue_vms = LvTARGLEN(sv);
2811 #ifdef VMSISH_STATUS
2813 STATUS_NATIVE_CHILD_SET((U32)SvIV(sv));
2816 STATUS_UNIX_EXIT_SET(SvIV(sv));
2821 # define PERL_VMS_BANG vaxc$errno
2823 # define PERL_VMS_BANG 0
2825 #if defined(WIN32) && ! defined(UNDER_CE)
2826 SETERRNO(win32_get_errno(SvIOK(sv) ? SvIVX(sv) : SvOK(sv) ? sv_2iv(sv) : 0),
2827 (SvIV(sv) == EVMSERR) ? 4 : PERL_VMS_BANG);
2829 SETERRNO(SvIOK(sv) ? SvIVX(sv) : SvOK(sv) ? sv_2iv(sv) : 0,
2830 (SvIV(sv) == EVMSERR) ? 4 : PERL_VMS_BANG);
2836 /* XXX $< currently silently ignores failures */
2837 const Uid_t new_uid = SvUID(sv);
2838 PL_delaymagic_uid = new_uid;
2839 if (PL_delaymagic) {
2840 PL_delaymagic |= DM_RUID;
2841 break; /* don't do magic till later */
2844 PERL_UNUSED_RESULT(setruid(new_uid));
2847 PERL_UNUSED_RESULT(setreuid(new_uid, (Uid_t)-1));
2849 #ifdef HAS_SETRESUID
2850 PERL_UNUSED_RESULT(setresuid(new_uid, (Uid_t)-1, (Uid_t)-1));
2852 if (new_uid == PerlProc_geteuid()) { /* special case $< = $> */
2854 /* workaround for Darwin's setuid peculiarity, cf [perl #24122] */
2855 if (new_uid != 0 && PerlProc_getuid() == 0)
2856 PERL_UNUSED_RESULT(PerlProc_setuid(0));
2858 PERL_UNUSED_RESULT(PerlProc_setuid(new_uid));
2860 Perl_croak(aTHX_ "setruid() not implemented");
2869 /* XXX $> currently silently ignores failures */
2870 const Uid_t new_euid = SvUID(sv);
2871 PL_delaymagic_euid = new_euid;
2872 if (PL_delaymagic) {
2873 PL_delaymagic |= DM_EUID;
2874 break; /* don't do magic till later */
2877 PERL_UNUSED_RESULT(seteuid(new_euid));
2880 PERL_UNUSED_RESULT(setreuid((Uid_t)-1, new_euid));
2882 #ifdef HAS_SETRESUID
2883 PERL_UNUSED_RESULT(setresuid((Uid_t)-1, new_euid, (Uid_t)-1));
2885 if (new_euid == PerlProc_getuid()) /* special case $> = $< */
2886 PERL_UNUSED_RESULT(PerlProc_setuid(new_euid));
2888 Perl_croak(aTHX_ "seteuid() not implemented");
2897 /* XXX $( currently silently ignores failures */
2898 const Gid_t new_gid = SvGID(sv);
2899 PL_delaymagic_gid = new_gid;
2900 if (PL_delaymagic) {
2901 PL_delaymagic |= DM_RGID;
2902 break; /* don't do magic till later */
2905 PERL_UNUSED_RESULT(setrgid(new_gid));
2908 PERL_UNUSED_RESULT(setregid(new_gid, (Gid_t)-1));
2910 #ifdef HAS_SETRESGID
2911 PERL_UNUSED_RESULT(setresgid(new_gid, (Gid_t)-1, (Gid_t) -1));
2913 if (new_gid == PerlProc_getegid()) /* special case $( = $) */
2914 PERL_UNUSED_RESULT(PerlProc_setgid(new_gid));
2916 Perl_croak(aTHX_ "setrgid() not implemented");
2925 /* XXX $) currently silently ignores failures */
2927 #ifdef HAS_SETGROUPS
2929 const char *p = SvPV_const(sv, len);
2930 Groups_t *gary = NULL;
2931 #ifdef _SC_NGROUPS_MAX
2932 int maxgrp = sysconf(_SC_NGROUPS_MAX);
2937 int maxgrp = NGROUPS;
2942 new_egid = (Gid_t)Atol(p);
2943 for (i = 0; i < maxgrp; ++i) {
2944 while (*p && !isSPACE(*p))
2951 Newx(gary, i + 1, Groups_t);
2953 Renew(gary, i + 1, Groups_t);
2954 gary[i] = (Groups_t)Atol(p);
2957 PERL_UNUSED_RESULT(setgroups(i, gary));
2960 #else /* HAS_SETGROUPS */
2961 new_egid = SvGID(sv);
2962 #endif /* HAS_SETGROUPS */
2963 PL_delaymagic_egid = new_egid;
2964 if (PL_delaymagic) {
2965 PL_delaymagic |= DM_EGID;
2966 break; /* don't do magic till later */
2969 PERL_UNUSED_RESULT(setegid(new_egid));
2972 PERL_UNUSED_RESULT(setregid((Gid_t)-1, new_egid));
2974 #ifdef HAS_SETRESGID
2975 PERL_UNUSED_RESULT(setresgid((Gid_t)-1, new_egid, (Gid_t)-1));
2977 if (new_egid == PerlProc_getgid()) /* special case $) = $( */
2978 PERL_UNUSED_RESULT(PerlProc_setgid(new_egid));
2980 Perl_croak(aTHX_ "setegid() not implemented");
2988 PL_chopset = SvPV_force(sv,len);
2991 /* Store the pid in mg->mg_obj so we can tell when a fork has
2992 occurred. mg->mg_obj points to *$ by default, so clear it. */
2993 if (isGV(mg->mg_obj)) {
2994 if (mg->mg_flags & MGf_REFCOUNTED) /* probably never true */
2995 SvREFCNT_dec(mg->mg_obj);
2996 mg->mg_flags |= MGf_REFCOUNTED;
2997 mg->mg_obj = newSViv((IV)PerlProc_getpid());
2999 else sv_setiv(mg->mg_obj, (IV)PerlProc_getpid());
3002 LOCK_DOLLARZERO_MUTEX;
3003 #ifdef HAS_SETPROCTITLE
3004 /* The BSDs don't show the argv[] in ps(1) output, they
3005 * show a string from the process struct and provide
3006 * the setproctitle() routine to manipulate that. */
3007 if (PL_origalen != 1) {
3008 s = SvPV_const(sv, len);
3009 # if __FreeBSD_version > 410001
3010 /* The leading "-" removes the "perl: " prefix,
3011 * but not the "(perl) suffix from the ps(1)
3012 * output, because that's what ps(1) shows if the
3013 * argv[] is modified. */
3014 setproctitle("-%s", s);
3015 # else /* old FreeBSDs, NetBSD, OpenBSD, anyBSD */
3016 /* This doesn't really work if you assume that
3017 * $0 = 'foobar'; will wipe out 'perl' from the $0
3018 * because in ps(1) output the result will be like
3019 * sprintf("perl: %s (perl)", s)
3020 * I guess this is a security feature:
3021 * one (a user process) cannot get rid of the original name.
3023 setproctitle("%s", s);
3026 #elif defined(__hpux) && defined(PSTAT_SETCMD)
3027 if (PL_origalen != 1) {
3029 s = SvPV_const(sv, len);
3030 un.pst_command = (char *)s;
3031 pstat(PSTAT_SETCMD, un, len, 0, 0);
3034 if (PL_origalen > 1) {
3035 /* PL_origalen is set in perl_parse(). */
3036 s = SvPV_force(sv,len);
3037 if (len >= (STRLEN)PL_origalen-1) {
3038 /* Longer than original, will be truncated. We assume that
3039 * PL_origalen bytes are available. */
3040 Copy(s, PL_origargv[0], PL_origalen-1, char);
3043 /* Shorter than original, will be padded. */
3045 /* Special case for Mac OS X: see [perl #38868] */
3048 /* Is the space counterintuitive? Yes.
3049 * (You were expecting \0?)
3050 * Does it work? Seems to. (In Linux 2.4.20 at least.)
3052 const int pad = ' ';
3054 Copy(s, PL_origargv[0], len, char);
3055 PL_origargv[0][len] = 0;
3056 memset(PL_origargv[0] + len + 1,
3057 pad, PL_origalen - len - 1);
3059 PL_origargv[0][PL_origalen-1] = 0;
3060 for (i = 1; i < PL_origargc; i++)
3062 #ifdef HAS_PRCTL_SET_NAME
3063 /* Set the legacy process name in addition to the POSIX name on Linux */
3064 if (prctl(PR_SET_NAME, (unsigned long)s, 0, 0, 0) != 0) {
3065 /* diag_listed_as: SKIPME */
3066 Perl_croak(aTHX_ "Can't set $0 with prctl(): %s", Strerror(errno));
3071 UNLOCK_DOLLARZERO_MUTEX;
3078 Perl_whichsig_sv(pTHX_ SV *sigsv)
3082 PERL_ARGS_ASSERT_WHICHSIG_SV;
3083 PERL_UNUSED_CONTEXT;
3084 sigpv = SvPV_const(sigsv, siglen);
3085 return whichsig_pvn(sigpv, siglen);
3089 Perl_whichsig_pv(pTHX_ const char *sig)
3091 PERL_ARGS_ASSERT_WHICHSIG_PV;
3092 PERL_UNUSED_CONTEXT;
3093 return whichsig_pvn(sig, strlen(sig));
3097 Perl_whichsig_pvn(pTHX_ const char *sig, STRLEN len)
3101 PERL_ARGS_ASSERT_WHICHSIG_PVN;
3102 PERL_UNUSED_CONTEXT;
3104 for (sigv = (char* const*)PL_sig_name; *sigv; sigv++)
3105 if (strlen(*sigv) == len && memEQ(sig,*sigv, len))
3106 return PL_sig_num[sigv - (char* const*)PL_sig_name];
3108 if (memEQs(sig, len, "CHLD"))
3112 if (memEQs(sig, len, "CLD"))
3119 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
3120 Perl_sighandler(int sig, siginfo_t *sip, void *uap)
3122 Perl_sighandler(int sig)
3125 #ifdef PERL_GET_SIG_CONTEXT
3126 dTHXa(PERL_GET_SIG_CONTEXT);
3133 SV * const tSv = PL_Sv;
3137 XPV * const tXpv = PL_Xpv;
3138 I32 old_ss_ix = PL_savestack_ix;
3139 SV *errsv_save = NULL;
3142 if (!PL_psig_ptr[sig]) {
3143 PerlIO_printf(Perl_error_log, "Signal SIG%s received, but no signal handler set.\n",
3148 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG) {
3149 /* Max number of items pushed there is 3*n or 4. We cannot fix
3150 infinity, so we fix 4 (in fact 5): */
3151 if (PL_savestack_ix + 15 <= PL_savestack_max) {
3153 PL_savestack_ix += 5; /* Protect save in progress. */
3154 SAVEDESTRUCTOR_X(S_unwind_handler_stack, NULL);
3157 /* sv_2cv is too complicated, try a simpler variant first: */
3158 if (!SvROK(PL_psig_ptr[sig]) || !(cv = MUTABLE_CV(SvRV(PL_psig_ptr[sig])))
3159 || SvTYPE(cv) != SVt_PVCV) {
3161 cv = sv_2cv(PL_psig_ptr[sig], &st, &gv, GV_ADD);
3164 if (!cv || !CvROOT(cv)) {
3165 Perl_ck_warner(aTHX_ packWARN(WARN_SIGNAL), "SIG%s handler \"%s\" not defined.\n",
3166 PL_sig_name[sig], (gv ? GvENAME(gv)
3173 sv = PL_psig_name[sig]
3174 ? SvREFCNT_inc_NN(PL_psig_name[sig])
3175 : newSVpv(PL_sig_name[sig],0);
3179 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG) {
3180 /* make sure our assumption about the size of the SAVEs are correct:
3181 * 3 for SAVEDESTRUCTOR_X, 2 for SAVEFREESV */
3182 assert(old_ss_ix + 2 + ((flags & 1) ? 3+5 : 0) == PL_savestack_ix);
3185 PUSHSTACKi(PERLSI_SIGNAL);
3188 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
3190 struct sigaction oact;
3192 if (sigaction(sig, 0, &oact) == 0 && oact.sa_flags & SA_SIGINFO) {
3195 SV *rv = newRV_noinc(MUTABLE_SV(sih));
3196 /* The siginfo fields signo, code, errno, pid, uid,
3197 * addr, status, and band are defined by POSIX/SUSv3. */
3198 (void)hv_stores(sih, "signo", newSViv(sip->si_signo));
3199 (void)hv_stores(sih, "code", newSViv(sip->si_code));
3200 #if 0 /* XXX TODO: Configure scan for the existence of these, but even that does not help if the SA_SIGINFO is not implemented according to the spec. */
3201 hv_stores(sih, "errno", newSViv(sip->si_errno));
3202 hv_stores(sih, "status", newSViv(sip->si_status));
3203 hv_stores(sih, "uid", newSViv(sip->si_uid));
3204 hv_stores(sih, "pid", newSViv(sip->si_pid));
3205 hv_stores(sih, "addr", newSVuv(PTR2UV(sip->si_addr)));
3206 hv_stores(sih, "band", newSViv(sip->si_band));
3210 mPUSHp((char *)sip, sizeof(*sip));
3218 errsv_save = newSVsv(ERRSV);
3220 call_sv(MUTABLE_SV(cv), G_DISCARD|G_EVAL);
3224 SV * const errsv = ERRSV;
3225 if (SvTRUE_NN(errsv)) {
3226 SvREFCNT_dec(errsv_save);
3228 /* Handler "died", for example to get out of a restart-able read().
3229 * Before we re-do that on its behalf re-enable the signal which was
3230 * blocked by the system when we entered.
3232 #ifdef HAS_SIGPROCMASK
3233 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
3239 sigaddset(&set,sig);
3240 sigprocmask(SIG_UNBLOCK, &set, NULL);
3243 /* Not clear if this will work */
3244 (void)rsignal(sig, SIG_IGN);
3245 (void)rsignal(sig, PL_csighandlerp);
3247 #endif /* !PERL_MICRO */
3251 sv_setsv(errsv, errsv_save);
3252 SvREFCNT_dec(errsv_save);
3257 /* pop any of SAVEFREESV, SAVEDESTRUCTOR_X and "save in progress" */
3258 PL_savestack_ix = old_ss_ix;
3260 SvREFCNT_dec_NN(sv);
3261 PL_op = myop; /* Apparently not needed... */
3263 PL_Sv = tSv; /* Restore global temporaries. */
3270 S_restore_magic(pTHX_ const void *p)
3273 MGS* const mgs = SSPTR(PTR2IV(p), MGS*);
3274 SV* const sv = mgs->mgs_sv;
3280 if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv)) {
3281 SvTEMP_off(sv); /* if it's still magical, this value isn't temporary */
3282 #ifdef PERL_OLD_COPY_ON_WRITE
3283 /* While magic was saved (and off) sv_setsv may well have seen
3284 this SV as a prime candidate for COW. */
3286 sv_force_normal_flags(sv, 0);
3288 if (mgs->mgs_readonly)
3290 if (mgs->mgs_magical)
3291 SvFLAGS(sv) |= mgs->mgs_magical;
3296 bumped = mgs->mgs_bumped;
3297 mgs->mgs_sv = NULL; /* mark the MGS structure as restored */
3299 /* If we're still on top of the stack, pop us off. (That condition
3300 * will be satisfied if restore_magic was called explicitly, but *not*
3301 * if it's being called via leave_scope.)
3302 * The reason for doing this is that otherwise, things like sv_2cv()
3303 * may leave alloc gunk on the savestack, and some code
3304 * (e.g. sighandler) doesn't expect that...
3306 if (PL_savestack_ix == mgs->mgs_ss_ix)
3308 UV popval = SSPOPUV;
3309 assert(popval == SAVEt_DESTRUCTOR_X);
3310 PL_savestack_ix -= 2;
3312 assert((popval & SAVE_MASK) == SAVEt_ALLOC);
3313 PL_savestack_ix -= popval >> SAVE_TIGHT_SHIFT;
3316 if (SvREFCNT(sv) == 1) {
3317 /* We hold the last reference to this SV, which implies that the
3318 SV was deleted as a side effect of the routines we called.
3319 So artificially keep it alive a bit longer.
3320 We avoid turning on the TEMP flag, which can cause the SV's
3321 buffer to get stolen (and maybe other stuff). */
3326 SvREFCNT_dec_NN(sv); /* undo the inc in S_save_magic() */
3330 /* clean up the mess created by Perl_sighandler().
3331 * Note that this is only called during an exit in a signal handler;
3332 * a die is trapped by the call_sv() and the SAVEDESTRUCTOR_X manually
3336 S_unwind_handler_stack(pTHX_ const void *p)
3341 PL_savestack_ix -= 5; /* Unprotect save in progress. */
3345 =for apidoc magic_sethint
3347 Triggered by a store to %^H, records the key/value pair to
3348 C<PL_compiling.cop_hints_hash>. It is assumed that hints aren't storing
3349 anything that would need a deep copy. Maybe we should warn if we find a
3355 Perl_magic_sethint(pTHX_ SV *sv, MAGIC *mg)
3358 SV *key = (mg->mg_len == HEf_SVKEY) ? MUTABLE_SV(mg->mg_ptr)
3359 : newSVpvn_flags(mg->mg_ptr, mg->mg_len, SVs_TEMP);
3361 PERL_ARGS_ASSERT_MAGIC_SETHINT;
3363 /* mg->mg_obj isn't being used. If needed, it would be possible to store
3364 an alternative leaf in there, with PL_compiling.cop_hints being used if
3365 it's NULL. If needed for threads, the alternative could lock a mutex,
3366 or take other more complex action. */
3368 /* Something changed in %^H, so it will need to be restored on scope exit.
3369 Doing this here saves a lot of doing it manually in perl code (and
3370 forgetting to do it, and consequent subtle errors. */
3371 PL_hints |= HINT_LOCALIZE_HH;
3372 CopHINTHASH_set(&PL_compiling,
3373 cophh_store_sv(CopHINTHASH_get(&PL_compiling), key, 0, sv, 0));
3378 =for apidoc magic_clearhint
3380 Triggered by a delete from %^H, records the key to
3381 C<PL_compiling.cop_hints_hash>.
3386 Perl_magic_clearhint(pTHX_ SV *sv, MAGIC *mg)
3390 PERL_ARGS_ASSERT_MAGIC_CLEARHINT;
3391 PERL_UNUSED_ARG(sv);
3393 PL_hints |= HINT_LOCALIZE_HH;
3394 CopHINTHASH_set(&PL_compiling,
3395 mg->mg_len == HEf_SVKEY
3396 ? cophh_delete_sv(CopHINTHASH_get(&PL_compiling),
3397 MUTABLE_SV(mg->mg_ptr), 0, 0)
3398 : cophh_delete_pvn(CopHINTHASH_get(&PL_compiling),
3399 mg->mg_ptr, mg->mg_len, 0, 0));
3404 =for apidoc magic_clearhints
3406 Triggered by clearing %^H, resets C<PL_compiling.cop_hints_hash>.
3411 Perl_magic_clearhints(pTHX_ SV *sv, MAGIC *mg)
3413 PERL_ARGS_ASSERT_MAGIC_CLEARHINTS;
3414 PERL_UNUSED_ARG(sv);
3415 PERL_UNUSED_ARG(mg);
3416 cophh_free(CopHINTHASH_get(&PL_compiling));
3417 CopHINTHASH_set(&PL_compiling, cophh_new_empty());
3422 Perl_magic_copycallchecker(pTHX_ SV *sv, MAGIC *mg, SV *nsv,
3423 const char *name, I32 namlen)
3427 PERL_ARGS_ASSERT_MAGIC_COPYCALLCHECKER;
3428 PERL_UNUSED_ARG(sv);
3429 PERL_UNUSED_ARG(name);
3430 PERL_UNUSED_ARG(namlen);
3432 sv_magic(nsv, &PL_sv_undef, mg->mg_type, NULL, 0);
3433 nmg = mg_find(nsv, mg->mg_type);
3435 if (nmg->mg_flags & MGf_REFCOUNTED) SvREFCNT_dec(nmg->mg_obj);
3436 nmg->mg_ptr = mg->mg_ptr;
3437 nmg->mg_obj = SvREFCNT_inc_simple(mg->mg_obj);
3438 nmg->mg_flags |= MGf_REFCOUNTED;
3444 * c-indentation-style: bsd
3446 * indent-tabs-mode: nil
3449 * ex: set ts=8 sts=4 sw=4 et: