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
21 "Magic" is special data attached to SV structures in order to give them
22 "magical" properties. When any Perl code tries to read from, or assign to,
23 an SV marked as magical, it calls the 'get' or 'set' function associated
24 with that SV's magic. A get is called prior to reading an SV, in order to
25 give it a chance to update its internal value (get on $. writes the line
26 number of the last read filehandle into to the SV's IV slot), while
27 set is called after an SV has been written to, in order to allow it to make
28 use of its changed value (set on $/ copies the SV's new value to the
29 PL_rs global variable).
31 Magic is implemented as a linked list of MAGIC structures attached to the
32 SV. Each MAGIC struct holds the type of the magic, a pointer to an array
33 of functions that implement the get(), set(), length() etc functions,
34 plus space for some flags and pointers. For example, a tied variable has
35 a MAGIC structure that contains a pointer to the object associated with the
44 #if defined(HAS_GETGROUPS) || defined(HAS_SETGROUPS)
50 #if defined(HAS_SETGROUPS)
57 # include <sys/pstat.h>
60 #ifdef HAS_PRCTL_SET_NAME
61 # include <sys/prctl.h>
64 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
65 Signal_t Perl_csighandler(int sig, siginfo_t *, void *);
67 Signal_t Perl_csighandler(int sig);
71 /* Missing protos on LynxOS */
72 void setruid(uid_t id);
73 void seteuid(uid_t id);
74 void setrgid(uid_t id);
75 void setegid(uid_t id);
79 * Pre-magic setup and post-magic takedown.
80 * Use the "DESTRUCTOR" scope cleanup to reinstate magic.
90 /* MGS is typedef'ed to struct magic_state in perl.h */
93 S_save_magic(pTHX_ I32 mgs_ix, SV *sv)
99 PERL_ARGS_ASSERT_SAVE_MAGIC;
101 assert(SvMAGICAL(sv));
103 /* we shouldn't really be called here with RC==0, but it can sometimes
104 * happen via mg_clear() (which also shouldn't be called when RC==0,
105 * but it can happen). Handle this case gracefully(ish) by not RC++
106 * and thus avoiding the resultant double free */
107 if (SvREFCNT(sv) > 0) {
108 /* guard against sv getting freed midway through the mg clearing,
109 * by holding a private reference for the duration. */
110 SvREFCNT_inc_simple_void_NN(sv);
114 /* Turning READONLY off for a copy-on-write scalar (including shared
115 hash keys) is a bad idea. */
117 sv_force_normal_flags(sv, 0);
119 SAVEDESTRUCTOR_X(S_restore_magic, INT2PTR(void*, (IV)mgs_ix));
121 mgs = SSPTR(mgs_ix, MGS*);
123 mgs->mgs_magical = SvMAGICAL(sv);
124 mgs->mgs_readonly = SvREADONLY(sv) != 0;
125 mgs->mgs_ss_ix = PL_savestack_ix; /* points after the saved destructor */
126 mgs->mgs_bumped = bumped;
133 =for apidoc mg_magical
135 Turns on the magical status of an SV. See C<sv_magic>.
141 Perl_mg_magical(pTHX_ SV *sv)
144 PERL_ARGS_ASSERT_MG_MAGICAL;
148 if ((mg = SvMAGIC(sv))) {
150 const MGVTBL* const vtbl = mg->mg_virtual;
152 if (vtbl->svt_get && !(mg->mg_flags & MGf_GSKIP))
159 } while ((mg = mg->mg_moremagic));
160 if (!(SvFLAGS(sv) & (SVs_GMG|SVs_SMG)))
168 Do magic after a value is retrieved from the SV. See C<sv_magic>.
174 Perl_mg_get(pTHX_ SV *sv)
177 const I32 mgs_ix = SSNEW(sizeof(MGS));
180 MAGIC *newmg, *head, *cur, *mg;
182 PERL_ARGS_ASSERT_MG_GET;
184 if (PL_localizing == 1 && sv == DEFSV) return 0;
186 /* We must call svt_get(sv, mg) for each valid entry in the linked
187 list of magic. svt_get() may delete the current entry, add new
188 magic to the head of the list, or upgrade the SV. AMS 20010810 */
190 newmg = cur = head = mg = SvMAGIC(sv);
192 const MGVTBL * const vtbl = mg->mg_virtual;
193 MAGIC * const nextmg = mg->mg_moremagic; /* it may delete itself */
195 if (!(mg->mg_flags & MGf_GSKIP) && vtbl && vtbl->svt_get) {
197 /* taint's mg get is so dumb it doesn't need flag saving */
198 if (!saved && mg->mg_type != PERL_MAGIC_taint) {
199 save_magic(mgs_ix, sv);
203 vtbl->svt_get(aTHX_ sv, mg);
205 /* guard against magic having been deleted - eg FETCH calling
208 (SSPTR(mgs_ix, MGS *))->mgs_magical = 0; /* recalculate flags */
212 /* recalculate flags if this entry was deleted. */
213 if (mg->mg_flags & MGf_GSKIP)
214 (SSPTR(mgs_ix, MGS *))->mgs_magical = 0;
216 else if (vtbl == &PL_vtbl_utf8) {
217 /* get-magic can reallocate the PV */
218 magic_setutf8(sv, mg);
224 /* Have we finished with the new entries we saw? Start again
225 where we left off (unless there are more new entries). */
233 /* Were any new entries added? */
234 if (!have_new && (newmg = SvMAGIC(sv)) != head) {
238 (SSPTR(mgs_ix, MGS *))->mgs_magical = 0; /* recalculate flags */
243 restore_magic(INT2PTR(void *, (IV)mgs_ix));
251 Do magic after a value is assigned to the SV. See C<sv_magic>.
257 Perl_mg_set(pTHX_ SV *sv)
260 const I32 mgs_ix = SSNEW(sizeof(MGS));
264 PERL_ARGS_ASSERT_MG_SET;
266 if (PL_localizing == 2 && sv == DEFSV) return 0;
268 save_magic(mgs_ix, sv);
270 for (mg = SvMAGIC(sv); mg; mg = nextmg) {
271 const MGVTBL* vtbl = mg->mg_virtual;
272 nextmg = mg->mg_moremagic; /* it may delete itself */
273 if (mg->mg_flags & MGf_GSKIP) {
274 mg->mg_flags &= ~MGf_GSKIP; /* setting requires another read */
275 (SSPTR(mgs_ix, MGS*))->mgs_magical = 0;
277 if (PL_localizing == 2
278 && PERL_MAGIC_TYPE_IS_VALUE_MAGIC(mg->mg_type))
280 if (vtbl && vtbl->svt_set)
281 vtbl->svt_set(aTHX_ sv, mg);
284 restore_magic(INT2PTR(void*, (IV)mgs_ix));
289 =for apidoc mg_length
291 Report on the SV's length. See C<sv_magic>.
297 Perl_mg_length(pTHX_ SV *sv)
303 PERL_ARGS_ASSERT_MG_LENGTH;
305 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
306 const MGVTBL * const vtbl = mg->mg_virtual;
307 if (vtbl && vtbl->svt_len) {
308 const I32 mgs_ix = SSNEW(sizeof(MGS));
309 save_magic(mgs_ix, sv);
310 /* omit MGf_GSKIP -- not changed here */
311 len = vtbl->svt_len(aTHX_ sv, mg);
312 restore_magic(INT2PTR(void*, (IV)mgs_ix));
318 /* You can't know whether it's UTF-8 until you get the string again...
320 const U8 *s = (U8*)SvPV_const(sv, len);
323 len = utf8_length(s, s + len);
330 Perl_mg_size(pTHX_ SV *sv)
334 PERL_ARGS_ASSERT_MG_SIZE;
336 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
337 const MGVTBL* const vtbl = mg->mg_virtual;
338 if (vtbl && vtbl->svt_len) {
339 const I32 mgs_ix = SSNEW(sizeof(MGS));
341 save_magic(mgs_ix, sv);
342 /* omit MGf_GSKIP -- not changed here */
343 len = vtbl->svt_len(aTHX_ sv, mg);
344 restore_magic(INT2PTR(void*, (IV)mgs_ix));
351 return AvFILLp((const AV *) sv); /* Fallback to non-tied array */
355 Perl_croak(aTHX_ "Size magic not implemented");
364 Clear something magical that the SV represents. See C<sv_magic>.
370 Perl_mg_clear(pTHX_ SV *sv)
372 const I32 mgs_ix = SSNEW(sizeof(MGS));
376 PERL_ARGS_ASSERT_MG_CLEAR;
378 save_magic(mgs_ix, sv);
380 for (mg = SvMAGIC(sv); mg; mg = nextmg) {
381 const MGVTBL* const vtbl = mg->mg_virtual;
382 /* omit GSKIP -- never set here */
384 nextmg = mg->mg_moremagic; /* it may delete itself */
386 if (vtbl && vtbl->svt_clear)
387 vtbl->svt_clear(aTHX_ sv, mg);
390 restore_magic(INT2PTR(void*, (IV)mgs_ix));
395 S_mg_findext_flags(pTHX_ const SV *sv, int type, const MGVTBL *vtbl, U32 flags)
404 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
405 if (mg->mg_type == type && (!flags || mg->mg_virtual == vtbl)) {
417 Finds the magic pointer for type matching the SV. See C<sv_magic>.
423 Perl_mg_find(pTHX_ const SV *sv, int type)
425 return S_mg_findext_flags(aTHX_ sv, type, NULL, 0);
429 =for apidoc mg_findext
431 Finds the magic pointer of C<type> with the given C<vtbl> for the C<SV>. See
438 Perl_mg_findext(pTHX_ const SV *sv, int type, const MGVTBL *vtbl)
440 return S_mg_findext_flags(aTHX_ sv, type, vtbl, 1);
446 Copies the magic from one SV to another. See C<sv_magic>.
452 Perl_mg_copy(pTHX_ SV *sv, SV *nsv, const char *key, I32 klen)
457 PERL_ARGS_ASSERT_MG_COPY;
459 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
460 const MGVTBL* const vtbl = mg->mg_virtual;
461 if ((mg->mg_flags & MGf_COPY) && vtbl->svt_copy){
462 count += vtbl->svt_copy(aTHX_ sv, mg, nsv, key, klen);
465 const char type = mg->mg_type;
466 if (isUPPER(type) && type != PERL_MAGIC_uvar) {
468 (type == PERL_MAGIC_tied)
470 : (type == PERL_MAGIC_regdata && mg->mg_obj)
473 toLOWER(type), key, klen);
482 =for apidoc mg_localize
484 Copy some of the magic from an existing SV to new localized version of that
485 SV. Container magic (eg %ENV, $1, tie) gets copied, value magic doesn't (eg
488 If setmagic is false then no set magic will be called on the new (empty) SV.
489 This typically means that assignment will soon follow (e.g. 'local $x = $y'),
490 and that will handle the magic.
496 Perl_mg_localize(pTHX_ SV *sv, SV *nsv, bool setmagic)
501 PERL_ARGS_ASSERT_MG_LOCALIZE;
506 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
507 const MGVTBL* const vtbl = mg->mg_virtual;
508 if (PERL_MAGIC_TYPE_IS_VALUE_MAGIC(mg->mg_type))
511 if ((mg->mg_flags & MGf_LOCAL) && vtbl->svt_local)
512 (void)vtbl->svt_local(aTHX_ nsv, mg);
514 sv_magicext(nsv, mg->mg_obj, mg->mg_type, vtbl,
515 mg->mg_ptr, mg->mg_len);
517 /* container types should remain read-only across localization */
518 if (!SvIsCOW(sv)) SvFLAGS(nsv) |= SvREADONLY(sv);
521 if (SvTYPE(nsv) >= SVt_PVMG && SvMAGIC(nsv)) {
522 SvFLAGS(nsv) |= SvMAGICAL(sv);
531 #define mg_free_struct(sv, mg) S_mg_free_struct(aTHX_ sv, mg)
533 S_mg_free_struct(pTHX_ SV *sv, MAGIC *mg)
535 const MGVTBL* const vtbl = mg->mg_virtual;
536 if (vtbl && vtbl->svt_free)
537 vtbl->svt_free(aTHX_ sv, mg);
538 if (mg->mg_ptr && mg->mg_type != PERL_MAGIC_regex_global) {
539 if (mg->mg_len > 0 || mg->mg_type == PERL_MAGIC_utf8)
540 Safefree(mg->mg_ptr);
541 else if (mg->mg_len == HEf_SVKEY)
542 SvREFCNT_dec(MUTABLE_SV(mg->mg_ptr));
544 if (mg->mg_flags & MGf_REFCOUNTED)
545 SvREFCNT_dec(mg->mg_obj);
552 Free any magic storage used by the SV. See C<sv_magic>.
558 Perl_mg_free(pTHX_ SV *sv)
563 PERL_ARGS_ASSERT_MG_FREE;
565 for (mg = SvMAGIC(sv); mg; mg = moremagic) {
566 moremagic = mg->mg_moremagic;
567 mg_free_struct(sv, mg);
568 SvMAGIC_set(sv, moremagic);
570 SvMAGIC_set(sv, NULL);
576 =for apidoc Am|void|mg_free_type|SV *sv|int how
578 Remove any magic of type I<how> from the SV I<sv>. See L</sv_magic>.
584 Perl_mg_free_type(pTHX_ SV *sv, int how)
586 MAGIC *mg, *prevmg, *moremg;
587 PERL_ARGS_ASSERT_MG_FREE_TYPE;
588 for (prevmg = NULL, mg = SvMAGIC(sv); mg; prevmg = mg, mg = moremg) {
590 moremg = mg->mg_moremagic;
591 if (mg->mg_type == how) {
592 /* temporarily move to the head of the magic chain, in case
593 custom free code relies on this historical aspect of mg_free */
595 prevmg->mg_moremagic = moremg;
596 mg->mg_moremagic = SvMAGIC(sv);
599 newhead = mg->mg_moremagic;
600 mg_free_struct(sv, mg);
601 SvMAGIC_set(sv, newhead);
611 Perl_magic_regdata_cnt(pTHX_ SV *sv, MAGIC *mg)
616 PERL_ARGS_ASSERT_MAGIC_REGDATA_CNT;
619 const REGEXP * const rx = PM_GETRE(PL_curpm);
621 if (mg->mg_obj) { /* @+ */
622 /* return the number possible */
623 return RX_NPARENS(rx);
625 I32 paren = RX_LASTPAREN(rx);
627 /* return the last filled */
629 && (RX_OFFS(rx)[paren].start == -1
630 || RX_OFFS(rx)[paren].end == -1) )
643 Perl_magic_regdatum_get(pTHX_ SV *sv, MAGIC *mg)
647 PERL_ARGS_ASSERT_MAGIC_REGDATUM_GET;
650 const REGEXP * const rx = PM_GETRE(PL_curpm);
652 const I32 paren = mg->mg_len;
657 if (paren <= (I32)RX_NPARENS(rx) &&
658 (s = RX_OFFS(rx)[paren].start) != -1 &&
659 (t = RX_OFFS(rx)[paren].end) != -1)
662 if (mg->mg_obj) /* @+ */
667 if (i > 0 && RX_MATCH_UTF8(rx)) {
668 const char * const b = RX_SUBBEG(rx);
670 i = RX_SUBCOFFSET(rx) +
672 (U8*)(b-RX_SUBOFFSET(rx)+i));
685 Perl_magic_regdatum_set(pTHX_ SV *sv, MAGIC *mg)
687 PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET;
690 Perl_croak_no_modify(aTHX);
691 NORETURN_FUNCTION_END;
695 Perl_magic_len(pTHX_ SV *sv, MAGIC *mg)
701 const char * const remaining = mg->mg_ptr + 1;
703 PERL_ARGS_ASSERT_MAGIC_LEN;
705 switch (*mg->mg_ptr) {
707 if (*remaining == '\0') { /* ^P */
709 } else if (strEQ(remaining, "REMATCH")) { /* $^PREMATCH */
711 } else if (strEQ(remaining, "OSTMATCH")) { /* $^POSTMATCH */
715 case '\015': /* $^MATCH */
716 if (strEQ(remaining, "ATCH")) {
723 paren = RX_BUFF_IDX_PREMATCH;
727 paren = RX_BUFF_IDX_POSTMATCH;
731 paren = RX_BUFF_IDX_FULLMATCH;
733 case '1': case '2': case '3': case '4':
734 case '5': case '6': case '7': case '8': case '9':
735 paren = atoi(mg->mg_ptr);
737 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
739 i = CALLREG_NUMBUF_LENGTH((REGEXP * const)rx, sv, paren);
742 Perl_croak(aTHX_ "panic: magic_len: %"IVdf, (IV)i);
745 if (ckWARN(WARN_UNINITIALIZED))
750 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
751 paren = RX_LASTPAREN(rx);
756 case '\016': /* ^N */
757 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
758 paren = RX_LASTCLOSEPAREN(rx);
765 if (!SvPOK(sv) && SvNIOK(sv)) {
773 #define SvRTRIM(sv) STMT_START { \
775 STRLEN len = SvCUR(sv); \
776 char * const p = SvPVX(sv); \
777 while (len > 0 && isSPACE(p[len-1])) \
779 SvCUR_set(sv, len); \
785 Perl_emulate_cop_io(pTHX_ const COP *const c, SV *const sv)
787 PERL_ARGS_ASSERT_EMULATE_COP_IO;
789 if (!(CopHINTS_get(c) & (HINT_LEXICAL_IO_IN|HINT_LEXICAL_IO_OUT)))
790 sv_setsv(sv, &PL_sv_undef);
794 if ((CopHINTS_get(c) & HINT_LEXICAL_IO_IN)) {
795 SV *const value = cop_hints_fetch_pvs(c, "open<", 0);
800 if ((CopHINTS_get(c) & HINT_LEXICAL_IO_OUT)) {
801 SV *const value = cop_hints_fetch_pvs(c, "open>", 0);
814 Perl_magic_get(pTHX_ SV *sv, MAGIC *mg)
818 const char *s = NULL;
820 const char * const remaining = mg->mg_ptr + 1;
821 const char nextchar = *remaining;
823 PERL_ARGS_ASSERT_MAGIC_GET;
825 switch (*mg->mg_ptr) {
826 case '\001': /* ^A */
827 if (SvOK(PL_bodytarget)) sv_copypv(sv, PL_bodytarget);
828 else sv_setsv(sv, &PL_sv_undef);
829 if (SvTAINTED(PL_bodytarget))
832 case '\003': /* ^C, ^CHILD_ERROR_NATIVE */
833 if (nextchar == '\0') {
834 sv_setiv(sv, (IV)PL_minus_c);
836 else if (strEQ(remaining, "HILD_ERROR_NATIVE")) {
837 sv_setiv(sv, (IV)STATUS_NATIVE);
841 case '\004': /* ^D */
842 sv_setiv(sv, (IV)(PL_debug & DEBUG_MASK));
844 case '\005': /* ^E */
845 if (nextchar == '\0') {
849 $DESCRIPTOR(msgdsc,msg);
850 sv_setnv(sv,(NV) vaxc$errno);
851 if (sys$getmsg(vaxc$errno,&msgdsc.dsc$w_length,&msgdsc,0,0) & 1)
852 sv_setpvn(sv,msgdsc.dsc$a_pointer,msgdsc.dsc$w_length);
857 if (!(_emx_env & 0x200)) { /* Under DOS */
858 sv_setnv(sv, (NV)errno);
859 sv_setpv(sv, errno ? Strerror(errno) : "");
861 if (errno != errno_isOS2) {
862 const int tmp = _syserrno();
863 if (tmp) /* 2nd call to _syserrno() makes it 0 */
866 sv_setnv(sv, (NV)Perl_rc);
867 sv_setpv(sv, os2error(Perl_rc));
871 const DWORD dwErr = GetLastError();
872 sv_setnv(sv, (NV)dwErr);
874 PerlProc_GetOSError(sv, dwErr);
883 sv_setnv(sv, (NV)errno);
884 sv_setpv(sv, errno ? Strerror(errno) : "");
889 SvNOK_on(sv); /* what a wonderful hack! */
891 else if (strEQ(remaining, "NCODING"))
892 sv_setsv(sv, PL_encoding);
894 case '\006': /* ^F */
895 sv_setiv(sv, (IV)PL_maxsysfd);
897 case '\007': /* ^GLOBAL_PHASE */
898 if (strEQ(remaining, "LOBAL_PHASE")) {
899 sv_setpvn(sv, PL_phase_names[PL_phase],
900 strlen(PL_phase_names[PL_phase]));
903 case '\010': /* ^H */
904 sv_setiv(sv, (IV)PL_hints);
906 case '\011': /* ^I */ /* NOT \t in EBCDIC */
907 sv_setpv(sv, PL_inplace); /* Will undefine sv if PL_inplace is NULL */
909 case '\017': /* ^O & ^OPEN */
910 if (nextchar == '\0') {
911 sv_setpv(sv, PL_osname);
914 else if (strEQ(remaining, "PEN")) {
915 Perl_emulate_cop_io(aTHX_ &PL_compiling, sv);
919 if (nextchar == '\0') { /* ^P */
920 sv_setiv(sv, (IV)PL_perldb);
921 } else if (strEQ(remaining, "REMATCH")) { /* $^PREMATCH */
923 paren = RX_BUFF_IDX_CARET_PREMATCH;
924 goto do_numbuf_fetch;
925 } else if (strEQ(remaining, "OSTMATCH")) { /* $^POSTMATCH */
926 paren = RX_BUFF_IDX_CARET_POSTMATCH;
927 goto do_numbuf_fetch;
930 case '\023': /* ^S */
931 if (nextchar == '\0') {
932 if (PL_parser && PL_parser->lex_state != LEX_NOTPARSING)
935 sv_setiv(sv, PL_in_eval & ~(EVAL_INREQUIRE));
940 case '\024': /* ^T */
941 if (nextchar == '\0') {
943 sv_setnv(sv, PL_basetime);
945 sv_setiv(sv, (IV)PL_basetime);
948 else if (strEQ(remaining, "AINT"))
949 sv_setiv(sv, PL_tainting
950 ? (PL_taint_warn || PL_unsafe ? -1 : 1)
953 case '\025': /* $^UNICODE, $^UTF8LOCALE, $^UTF8CACHE */
954 if (strEQ(remaining, "NICODE"))
955 sv_setuv(sv, (UV) PL_unicode);
956 else if (strEQ(remaining, "TF8LOCALE"))
957 sv_setuv(sv, (UV) PL_utf8locale);
958 else if (strEQ(remaining, "TF8CACHE"))
959 sv_setiv(sv, (IV) PL_utf8cache);
961 case '\027': /* ^W & $^WARNING_BITS */
962 if (nextchar == '\0')
963 sv_setiv(sv, (IV)((PL_dowarn & G_WARN_ON) ? TRUE : FALSE));
964 else if (strEQ(remaining, "ARNING_BITS")) {
965 if (PL_compiling.cop_warnings == pWARN_NONE) {
966 sv_setpvn(sv, WARN_NONEstring, WARNsize) ;
968 else if (PL_compiling.cop_warnings == pWARN_STD) {
969 sv_setsv(sv, &PL_sv_undef);
972 else if (PL_compiling.cop_warnings == pWARN_ALL) {
973 /* Get the bit mask for $warnings::Bits{all}, because
974 * it could have been extended by warnings::register */
975 HV * const bits = get_hv("warnings::Bits", 0);
976 SV ** const bits_all = bits ? hv_fetchs(bits, "all", FALSE) : NULL;
978 sv_copypv(sv, *bits_all);
980 sv_setpvn(sv, WARN_ALLstring, WARNsize);
983 sv_setpvn(sv, (char *) (PL_compiling.cop_warnings + 1),
984 *PL_compiling.cop_warnings);
988 case '\015': /* $^MATCH */
989 if (strEQ(remaining, "ATCH")) {
990 paren = RX_BUFF_IDX_CARET_FULLMATCH;
991 goto do_numbuf_fetch;
994 case '1': case '2': case '3': case '4':
995 case '5': case '6': case '7': case '8': case '9': case '&':
997 * Pre-threads, this was paren = atoi(GvENAME((const GV *)mg->mg_obj));
998 * XXX Does the new way break anything?
1000 paren = atoi(mg->mg_ptr); /* $& is in [0] */
1002 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
1003 CALLREG_NUMBUF_FETCH(rx,paren,sv);
1006 sv_setsv(sv,&PL_sv_undef);
1009 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
1010 paren = RX_LASTPAREN(rx);
1012 goto do_numbuf_fetch;
1014 sv_setsv(sv,&PL_sv_undef);
1016 case '\016': /* ^N */
1017 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
1018 paren = RX_LASTCLOSEPAREN(rx);
1020 goto do_numbuf_fetch;
1022 sv_setsv(sv,&PL_sv_undef);
1025 paren = RX_BUFF_IDX_PREMATCH;
1026 goto do_numbuf_fetch;
1028 paren = RX_BUFF_IDX_POSTMATCH;
1029 goto do_numbuf_fetch;
1031 if (GvIO(PL_last_in_gv)) {
1032 sv_setiv(sv, (IV)IoLINES(GvIOp(PL_last_in_gv)));
1037 sv_setiv(sv, (IV)STATUS_CURRENT);
1038 #ifdef COMPLEX_STATUS
1039 SvUPGRADE(sv, SVt_PVLV);
1040 LvTARGOFF(sv) = PL_statusvalue;
1041 LvTARGLEN(sv) = PL_statusvalue_vms;
1046 if (GvIOp(PL_defoutgv))
1047 s = IoTOP_NAME(GvIOp(PL_defoutgv));
1051 sv_setpv(sv,GvENAME(PL_defoutgv));
1052 sv_catpvs(sv,"_TOP");
1056 if (GvIOp(PL_defoutgv))
1057 s = IoFMT_NAME(GvIOp(PL_defoutgv));
1059 s = GvENAME(PL_defoutgv);
1063 if (GvIO(PL_defoutgv))
1064 sv_setiv(sv, (IV)IoPAGE_LEN(GvIOp(PL_defoutgv)));
1067 if (GvIO(PL_defoutgv))
1068 sv_setiv(sv, (IV)IoLINES_LEFT(GvIOp(PL_defoutgv)));
1071 if (GvIO(PL_defoutgv))
1072 sv_setiv(sv, (IV)IoPAGE(GvIOp(PL_defoutgv)));
1082 if (GvIO(PL_defoutgv))
1083 sv_setiv(sv, (IV)(IoFLAGS(GvIOp(PL_defoutgv)) & IOf_FLUSH) != 0 );
1087 sv_copypv(sv, PL_ors_sv);
1089 sv_setsv(sv, &PL_sv_undef);
1093 IV const pid = (IV)PerlProc_getpid();
1094 if (isGV(mg->mg_obj) || SvIV(mg->mg_obj) != pid) {
1095 /* never set manually, or at least not since last fork */
1097 /* never unsafe, even if reading in a tainted expression */
1100 /* else a value has been assigned manually, so do nothing */
1108 sv_setnv(sv, (NV)((errno == EVMSERR) ? vaxc$errno : errno));
1110 sv_setnv(sv, (NV)errno);
1113 if (errno == errno_isOS2 || errno == errno_isOS2_set)
1114 sv_setpv(sv, os2error(Perl_rc));
1117 sv_setpv(sv, errno ? Strerror(errno) : "");
1122 SvNOK_on(sv); /* what a wonderful hack! */
1125 sv_setiv(sv, (IV)PerlProc_getuid());
1128 sv_setiv(sv, (IV)PerlProc_geteuid());
1131 sv_setiv(sv, (IV)PerlProc_getgid());
1134 sv_setiv(sv, (IV)PerlProc_getegid());
1136 #ifdef HAS_GETGROUPS
1138 Groups_t *gary = NULL;
1139 I32 i, num_groups = getgroups(0, gary);
1140 Newx(gary, num_groups, Groups_t);
1141 num_groups = getgroups(num_groups, gary);
1142 for (i = 0; i < num_groups; i++)
1143 Perl_sv_catpvf(aTHX_ sv, " %"IVdf, (IV)gary[i]);
1146 (void)SvIOK_on(sv); /* what a wonderful hack! */
1156 Perl_magic_getuvar(pTHX_ SV *sv, MAGIC *mg)
1158 struct ufuncs * const uf = (struct ufuncs *)mg->mg_ptr;
1160 PERL_ARGS_ASSERT_MAGIC_GETUVAR;
1162 if (uf && uf->uf_val)
1163 (*uf->uf_val)(aTHX_ uf->uf_index, sv);
1168 Perl_magic_setenv(pTHX_ SV *sv, MAGIC *mg)
1171 STRLEN len = 0, klen;
1172 const char * const key = MgPV_const(mg,klen);
1173 const char *s = NULL;
1175 PERL_ARGS_ASSERT_MAGIC_SETENV;
1179 /* defined environment variables are byte strings; unfortunately
1180 there is no SvPVbyte_force_nomg(), so we must do this piecewise */
1181 (void)SvPV_force_nomg_nolen(sv);
1182 sv_utf8_downgrade(sv, /* fail_ok */ TRUE);
1184 Perl_ck_warner_d(aTHX_ packWARN(WARN_UTF8), "Wide character in %s", "setenv");
1190 my_setenv(key, s); /* does the deed */
1192 #ifdef DYNAMIC_ENV_FETCH
1193 /* We just undefd an environment var. Is a replacement */
1194 /* waiting in the wings? */
1196 SV ** const valp = hv_fetch(GvHVn(PL_envgv), key, klen, FALSE);
1198 s = SvOK(*valp) ? SvPV_const(*valp, len) : "";
1202 #if !defined(OS2) && !defined(AMIGAOS) && !defined(WIN32) && !defined(MSDOS)
1203 /* And you'll never guess what the dog had */
1204 /* in its mouth... */
1206 MgTAINTEDDIR_off(mg);
1208 if (s && klen == 8 && strEQ(key, "DCL$PATH")) {
1209 char pathbuf[256], eltbuf[256], *cp, *elt;
1212 my_strlcpy(eltbuf, s, sizeof(eltbuf));
1214 do { /* DCL$PATH may be a search list */
1215 while (1) { /* as may dev portion of any element */
1216 if ( ((cp = strchr(elt,'[')) || (cp = strchr(elt,'<'))) ) {
1217 if ( *(cp+1) == '.' || *(cp+1) == '-' ||
1218 cando_by_name(S_IWUSR,0,elt) ) {
1219 MgTAINTEDDIR_on(mg);
1223 if ((cp = strchr(elt, ':')) != NULL)
1225 if (my_trnlnm(elt, eltbuf, j++))
1231 } while (my_trnlnm(s, pathbuf, i++) && (elt = pathbuf));
1234 if (s && klen == 4 && strEQ(key,"PATH")) {
1235 const char * const strend = s + len;
1237 while (s < strend) {
1241 #ifdef VMS /* Hmm. How do we get $Config{path_sep} from C? */
1242 const char path_sep = '|';
1244 const char path_sep = ':';
1246 s = delimcpy(tmpbuf, tmpbuf + sizeof tmpbuf,
1247 s, strend, path_sep, &i);
1249 if (i >= (I32)sizeof tmpbuf /* too long -- assume the worst */
1251 || !strchr(tmpbuf, ':') /* no colon thus no device name -- assume relative path */
1253 || *tmpbuf != '/' /* no starting slash -- assume relative path */
1255 || (PerlLIO_stat(tmpbuf, &st) == 0 && (st.st_mode & 2)) ) {
1256 MgTAINTEDDIR_on(mg);
1262 #endif /* neither OS2 nor AMIGAOS nor WIN32 nor MSDOS */
1268 Perl_magic_clearenv(pTHX_ SV *sv, MAGIC *mg)
1270 PERL_ARGS_ASSERT_MAGIC_CLEARENV;
1271 PERL_UNUSED_ARG(sv);
1272 my_setenv(MgPV_nolen_const(mg),NULL);
1277 Perl_magic_set_all_env(pTHX_ SV *sv, MAGIC *mg)
1280 PERL_ARGS_ASSERT_MAGIC_SET_ALL_ENV;
1281 PERL_UNUSED_ARG(mg);
1283 Perl_die(aTHX_ "Can't make list assignment to %%ENV on this system");
1285 if (PL_localizing) {
1288 hv_iterinit(MUTABLE_HV(sv));
1289 while ((entry = hv_iternext(MUTABLE_HV(sv)))) {
1291 my_setenv(hv_iterkey(entry, &keylen),
1292 SvPV_nolen_const(hv_iterval(MUTABLE_HV(sv), entry)));
1300 Perl_magic_clear_all_env(pTHX_ SV *sv, MAGIC *mg)
1303 PERL_ARGS_ASSERT_MAGIC_CLEAR_ALL_ENV;
1304 PERL_UNUSED_ARG(sv);
1305 PERL_UNUSED_ARG(mg);
1307 Perl_die(aTHX_ "Can't make list assignment to %%ENV on this system");
1315 #ifdef HAS_SIGPROCMASK
1317 restore_sigmask(pTHX_ SV *save_sv)
1319 const sigset_t * const ossetp = (const sigset_t *) SvPV_nolen_const( save_sv );
1320 (void)sigprocmask(SIG_SETMASK, ossetp, NULL);
1324 Perl_magic_getsig(pTHX_ SV *sv, MAGIC *mg)
1327 /* Are we fetching a signal entry? */
1328 int i = (I16)mg->mg_private;
1330 PERL_ARGS_ASSERT_MAGIC_GETSIG;
1334 const char * sig = MgPV_const(mg, siglen);
1335 mg->mg_private = i = whichsig_pvn(sig, siglen);
1340 sv_setsv(sv,PL_psig_ptr[i]);
1342 Sighandler_t sigstate = rsignal_state(i);
1343 #ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1344 if (PL_sig_handlers_initted && PL_sig_ignoring[i])
1347 #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1348 if (PL_sig_handlers_initted && PL_sig_defaulting[i])
1351 /* cache state so we don't fetch it again */
1352 if(sigstate == (Sighandler_t) SIG_IGN)
1353 sv_setpvs(sv,"IGNORE");
1355 sv_setsv(sv,&PL_sv_undef);
1356 PL_psig_ptr[i] = SvREFCNT_inc_simple_NN(sv);
1363 Perl_magic_clearsig(pTHX_ SV *sv, MAGIC *mg)
1365 PERL_ARGS_ASSERT_MAGIC_CLEARSIG;
1367 magic_setsig(NULL, mg);
1368 return sv_unmagic(sv, mg->mg_type);
1372 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
1373 Perl_csighandler(int sig, siginfo_t *sip PERL_UNUSED_DECL, void *uap PERL_UNUSED_DECL)
1375 Perl_csighandler(int sig)
1378 #ifdef PERL_GET_SIG_CONTEXT
1379 dTHXa(PERL_GET_SIG_CONTEXT);
1383 #ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1384 (void) rsignal(sig, PL_csighandlerp);
1385 if (PL_sig_ignoring[sig]) return;
1387 #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1388 if (PL_sig_defaulting[sig])
1389 #ifdef KILL_BY_SIGPRC
1390 exit((Perl_sig_to_vmscondition(sig)&STS$M_COND_ID)|STS$K_SEVERE|STS$M_INHIB_MSG);
1405 (PL_signals & PERL_SIGNALS_UNSAFE_FLAG))
1406 /* Call the perl level handler now--
1407 * with risk we may be in malloc() or being destructed etc. */
1408 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
1409 (*PL_sighandlerp)(sig, NULL, NULL);
1411 (*PL_sighandlerp)(sig);
1414 if (!PL_psig_pend) return;
1415 /* Set a flag to say this signal is pending, that is awaiting delivery after
1416 * the current Perl opcode completes */
1417 PL_psig_pend[sig]++;
1419 #ifndef SIG_PENDING_DIE_COUNT
1420 # define SIG_PENDING_DIE_COUNT 120
1422 /* Add one to say _a_ signal is pending */
1423 if (++PL_sig_pending >= SIG_PENDING_DIE_COUNT)
1424 Perl_croak(aTHX_ "Maximal count of pending signals (%lu) exceeded",
1425 (unsigned long)SIG_PENDING_DIE_COUNT);
1429 #if defined(FAKE_PERSISTENT_SIGNAL_HANDLERS) || defined(FAKE_DEFAULT_SIGNAL_HANDLERS)
1431 Perl_csighandler_init(void)
1434 if (PL_sig_handlers_initted) return;
1436 for (sig = 1; sig < SIG_SIZE; sig++) {
1437 #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1439 PL_sig_defaulting[sig] = 1;
1440 (void) rsignal(sig, PL_csighandlerp);
1442 #ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1443 PL_sig_ignoring[sig] = 0;
1446 PL_sig_handlers_initted = 1;
1450 #if defined HAS_SIGPROCMASK
1452 unblock_sigmask(pTHX_ void* newset)
1454 sigprocmask(SIG_UNBLOCK, (sigset_t*)newset, NULL);
1459 Perl_despatch_signals(pTHX)
1464 for (sig = 1; sig < SIG_SIZE; sig++) {
1465 if (PL_psig_pend[sig]) {
1467 #ifdef HAS_SIGPROCMASK
1468 /* From sigaction(2) (FreeBSD man page):
1469 * | Signal routines normally execute with the signal that
1470 * | caused their invocation blocked, but other signals may
1472 * Emulation of this behavior (from within Perl) is enabled
1476 sigset_t newset, oldset;
1478 sigemptyset(&newset);
1479 sigaddset(&newset, sig);
1480 sigprocmask(SIG_BLOCK, &newset, &oldset);
1481 was_blocked = sigismember(&oldset, sig);
1483 SV* save_sv = newSVpvn((char *)(&newset), sizeof(sigset_t));
1485 SAVEFREESV(save_sv);
1486 SAVEDESTRUCTOR_X(unblock_sigmask, SvPV_nolen(save_sv));
1489 PL_psig_pend[sig] = 0;
1490 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
1491 (*PL_sighandlerp)(sig, NULL, NULL);
1493 (*PL_sighandlerp)(sig);
1495 #ifdef HAS_SIGPROCMASK
1504 /* sv of NULL signifies that we're acting as magic_clearsig. */
1506 Perl_magic_setsig(pTHX_ SV *sv, MAGIC *mg)
1511 /* Need to be careful with SvREFCNT_dec(), because that can have side
1512 * effects (due to closures). We must make sure that the new disposition
1513 * is in place before it is called.
1517 #ifdef HAS_SIGPROCMASK
1521 const char *s = MgPV_const(mg,len);
1523 PERL_ARGS_ASSERT_MAGIC_SETSIG;
1526 if (memEQs(s, len, "__DIE__"))
1528 else if (memEQs(s, len, "__WARN__")
1529 && (sv ? 1 : PL_warnhook != PERL_WARNHOOK_FATAL)) {
1530 /* Merge the existing behaviours, which are as follows:
1531 magic_setsig, we always set svp to &PL_warnhook
1532 (hence we always change the warnings handler)
1533 For magic_clearsig, we don't change the warnings handler if it's
1534 set to the &PL_warnhook. */
1537 SV *tmp = sv_newmortal();
1538 Perl_croak(aTHX_ "No such hook: %s",
1539 pv_pretty(tmp, s, len, 0, NULL, NULL, 0));
1543 if (*svp != PERL_WARNHOOK_FATAL)
1549 i = (I16)mg->mg_private;
1551 i = whichsig_pvn(s, len); /* ...no, a brick */
1552 mg->mg_private = (U16)i;
1556 SV *tmp = sv_newmortal();
1557 Perl_ck_warner(aTHX_ packWARN(WARN_SIGNAL), "No such signal: SIG%s",
1558 pv_pretty(tmp, s, len, 0, NULL, NULL, 0));
1562 #ifdef HAS_SIGPROCMASK
1563 /* Avoid having the signal arrive at a bad time, if possible. */
1566 sigprocmask(SIG_BLOCK, &set, &save);
1568 save_sv = newSVpvn((char *)(&save), sizeof(sigset_t));
1569 SAVEFREESV(save_sv);
1570 SAVEDESTRUCTOR_X(restore_sigmask, save_sv);
1573 #if defined(FAKE_PERSISTENT_SIGNAL_HANDLERS) || defined(FAKE_DEFAULT_SIGNAL_HANDLERS)
1574 if (!PL_sig_handlers_initted) Perl_csighandler_init();
1576 #ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1577 PL_sig_ignoring[i] = 0;
1579 #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1580 PL_sig_defaulting[i] = 0;
1582 to_dec = PL_psig_ptr[i];
1584 PL_psig_ptr[i] = SvREFCNT_inc_simple_NN(sv);
1585 SvTEMP_off(sv); /* Make sure it doesn't go away on us */
1587 /* Signals don't change name during the program's execution, so once
1588 they're cached in the appropriate slot of PL_psig_name, they can
1591 Ideally we'd find some way of making SVs at (C) compile time, or
1592 at least, doing most of the work. */
1593 if (!PL_psig_name[i]) {
1594 PL_psig_name[i] = newSVpvn(s, len);
1595 SvREADONLY_on(PL_psig_name[i]);
1598 SvREFCNT_dec(PL_psig_name[i]);
1599 PL_psig_name[i] = NULL;
1600 PL_psig_ptr[i] = NULL;
1603 if (sv && (isGV_with_GP(sv) || SvROK(sv))) {
1605 (void)rsignal(i, PL_csighandlerp);
1608 *svp = SvREFCNT_inc_simple_NN(sv);
1610 if (sv && SvOK(sv)) {
1611 s = SvPV_force(sv, len);
1615 if (sv && memEQs(s, len,"IGNORE")) {
1617 #ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1618 PL_sig_ignoring[i] = 1;
1619 (void)rsignal(i, PL_csighandlerp);
1621 (void)rsignal(i, (Sighandler_t) SIG_IGN);
1625 else if (!sv || memEQs(s, len,"DEFAULT") || !len) {
1627 #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1628 PL_sig_defaulting[i] = 1;
1629 (void)rsignal(i, PL_csighandlerp);
1631 (void)rsignal(i, (Sighandler_t) SIG_DFL);
1637 * We should warn if HINT_STRICT_REFS, but without
1638 * access to a known hint bit in a known OP, we can't
1639 * tell whether HINT_STRICT_REFS is in force or not.
1641 if (!strchr(s,':') && !strchr(s,'\''))
1642 Perl_sv_insert_flags(aTHX_ sv, 0, 0, STR_WITH_LEN("main::"),
1645 (void)rsignal(i, PL_csighandlerp);
1647 *svp = SvREFCNT_inc_simple_NN(sv);
1651 #ifdef HAS_SIGPROCMASK
1655 SvREFCNT_dec(to_dec);
1658 #endif /* !PERL_MICRO */
1661 Perl_magic_setisa(pTHX_ SV *sv, MAGIC *mg)
1664 PERL_ARGS_ASSERT_MAGIC_SETISA;
1665 PERL_UNUSED_ARG(sv);
1667 /* Skip _isaelem because _isa will handle it shortly */
1668 if (PL_delaymagic & DM_ARRAY_ISA && mg->mg_type == PERL_MAGIC_isaelem)
1671 return magic_clearisa(NULL, mg);
1674 /* sv of NULL signifies that we're acting as magic_setisa. */
1676 Perl_magic_clearisa(pTHX_ SV *sv, MAGIC *mg)
1681 PERL_ARGS_ASSERT_MAGIC_CLEARISA;
1683 /* Bail out if destruction is going on */
1684 if(PL_phase == PERL_PHASE_DESTRUCT) return 0;
1687 av_clear(MUTABLE_AV(sv));
1689 if (SvTYPE(mg->mg_obj) != SVt_PVGV && SvSMAGICAL(mg->mg_obj))
1690 /* This occurs with setisa_elem magic, which calls this
1692 mg = mg_find(mg->mg_obj, PERL_MAGIC_isa);
1694 if (SvTYPE(mg->mg_obj) == SVt_PVAV) { /* multiple stashes */
1695 SV **svp = AvARRAY((AV *)mg->mg_obj);
1696 I32 items = AvFILLp((AV *)mg->mg_obj) + 1;
1698 stash = GvSTASH((GV *)*svp++);
1699 if (stash && HvENAME(stash)) mro_isa_changed_in(stash);
1706 (const GV *)mg->mg_obj
1709 /* The stash may have been detached from the symbol table, so check its
1710 name before doing anything. */
1711 if (stash && HvENAME_get(stash))
1712 mro_isa_changed_in(stash);
1718 Perl_magic_getnkeys(pTHX_ SV *sv, MAGIC *mg)
1720 HV * const hv = MUTABLE_HV(LvTARG(sv));
1723 PERL_ARGS_ASSERT_MAGIC_GETNKEYS;
1724 PERL_UNUSED_ARG(mg);
1727 (void) hv_iterinit(hv);
1728 if (! SvTIED_mg((const SV *)hv, PERL_MAGIC_tied))
1731 while (hv_iternext(hv))
1736 sv_setiv(sv, (IV)i);
1741 Perl_magic_setnkeys(pTHX_ SV *sv, MAGIC *mg)
1743 PERL_ARGS_ASSERT_MAGIC_SETNKEYS;
1744 PERL_UNUSED_ARG(mg);
1746 hv_ksplit(MUTABLE_HV(LvTARG(sv)), SvIV(sv));
1752 =for apidoc magic_methcall
1754 Invoke a magic method (like FETCH).
1756 C<sv> and C<mg> are the tied thingy and the tie magic.
1758 C<meth> is the name of the method to call.
1760 C<argc> is the number of args (in addition to $self) to pass to the method.
1762 The C<flags> can be:
1764 G_DISCARD invoke method with G_DISCARD flag and don't
1766 G_UNDEF_FILL fill the stack with argc pointers to
1769 The arguments themselves are any values following the C<flags> argument.
1771 Returns the SV (if any) returned by the method, or NULL on failure.
1778 Perl_magic_methcall(pTHX_ SV *sv, const MAGIC *mg, const char *meth, U32 flags,
1785 PERL_ARGS_ASSERT_MAGIC_METHCALL;
1789 if (flags & G_WRITING_TO_STDERR) {
1793 SAVESPTR(PL_stderrgv);
1797 PUSHSTACKi(PERLSI_MAGIC);
1801 PUSHs(SvTIED_obj(sv, mg));
1802 if (flags & G_UNDEF_FILL) {
1804 PUSHs(&PL_sv_undef);
1806 } else if (argc > 0) {
1808 va_start(args, argc);
1811 SV *const sv = va_arg(args, SV *);
1818 if (flags & G_DISCARD) {
1819 call_method(meth, G_SCALAR|G_DISCARD);
1822 if (call_method(meth, G_SCALAR))
1823 ret = *PL_stack_sp--;
1826 if (flags & G_WRITING_TO_STDERR)
1833 /* wrapper for magic_methcall that creates the first arg */
1836 S_magic_methcall1(pTHX_ SV *sv, const MAGIC *mg, const char *meth, U32 flags,
1842 PERL_ARGS_ASSERT_MAGIC_METHCALL1;
1845 if (mg->mg_len >= 0) {
1846 arg1 = newSVpvn_flags(mg->mg_ptr, mg->mg_len, SVs_TEMP);
1848 else if (mg->mg_len == HEf_SVKEY)
1849 arg1 = MUTABLE_SV(mg->mg_ptr);
1851 else if (mg->mg_type == PERL_MAGIC_tiedelem) {
1852 arg1 = newSViv((IV)(mg->mg_len));
1856 return Perl_magic_methcall(aTHX_ sv, mg, meth, flags, n - 1, val);
1858 return Perl_magic_methcall(aTHX_ sv, mg, meth, flags, n, arg1, val);
1862 S_magic_methpack(pTHX_ SV *sv, const MAGIC *mg, const char *meth)
1867 PERL_ARGS_ASSERT_MAGIC_METHPACK;
1869 ret = magic_methcall1(sv, mg, meth, 0, 1, NULL);
1876 Perl_magic_getpack(pTHX_ SV *sv, MAGIC *mg)
1878 PERL_ARGS_ASSERT_MAGIC_GETPACK;
1880 if (mg->mg_type == PERL_MAGIC_tiedelem)
1881 mg->mg_flags |= MGf_GSKIP;
1882 magic_methpack(sv,mg,"FETCH");
1887 Perl_magic_setpack(pTHX_ SV *sv, MAGIC *mg)
1893 PERL_ARGS_ASSERT_MAGIC_SETPACK;
1895 /* in the code C<$tied{foo} = $val>, the "thing" that gets passed to
1896 * STORE() is not $val, but rather a PVLV (the sv in this call), whose
1897 * public flags indicate its value based on copying from $val. Doing
1898 * mg_set() on the PVLV temporarily does SvMAGICAL_off(), then calls us.
1899 * So STORE()'s $_[2] arg is a temporarily disarmed PVLV. This goes
1900 * wrong if $val happened to be tainted, as sv hasn't got magic
1901 * enabled, even though taint magic is in the chain. In which case,
1902 * fake up a temporary tainted value (this is easier than temporarily
1903 * re-enabling magic on sv). */
1905 if (PL_tainting && (tmg = mg_find(sv, PERL_MAGIC_taint))
1906 && (tmg->mg_len & 1))
1908 val = sv_mortalcopy(sv);
1914 magic_methcall1(sv, mg, "STORE", G_DISCARD, 2, val);
1919 Perl_magic_clearpack(pTHX_ SV *sv, MAGIC *mg)
1921 PERL_ARGS_ASSERT_MAGIC_CLEARPACK;
1923 if (mg->mg_type == PERL_MAGIC_tiedscalar) return 0;
1924 return magic_methpack(sv,mg,"DELETE");
1929 Perl_magic_sizepack(pTHX_ SV *sv, MAGIC *mg)
1935 PERL_ARGS_ASSERT_MAGIC_SIZEPACK;
1937 retsv = magic_methcall1(sv, mg, "FETCHSIZE", 0, 1, NULL);
1939 retval = SvIV(retsv)-1;
1941 Perl_croak(aTHX_ "FETCHSIZE returned a negative value");
1943 return (U32) retval;
1947 Perl_magic_wipepack(pTHX_ SV *sv, MAGIC *mg)
1951 PERL_ARGS_ASSERT_MAGIC_WIPEPACK;
1953 Perl_magic_methcall(aTHX_ sv, mg, "CLEAR", G_DISCARD, 0);
1958 Perl_magic_nextpack(pTHX_ SV *sv, MAGIC *mg, SV *key)
1963 PERL_ARGS_ASSERT_MAGIC_NEXTPACK;
1965 ret = SvOK(key) ? Perl_magic_methcall(aTHX_ sv, mg, "NEXTKEY", 0, 1, key)
1966 : Perl_magic_methcall(aTHX_ sv, mg, "FIRSTKEY", 0, 0);
1973 Perl_magic_existspack(pTHX_ SV *sv, const MAGIC *mg)
1975 PERL_ARGS_ASSERT_MAGIC_EXISTSPACK;
1977 return magic_methpack(sv,mg,"EXISTS");
1981 Perl_magic_scalarpack(pTHX_ HV *hv, MAGIC *mg)
1985 SV * const tied = SvTIED_obj(MUTABLE_SV(hv), mg);
1986 HV * const pkg = SvSTASH((const SV *)SvRV(tied));
1988 PERL_ARGS_ASSERT_MAGIC_SCALARPACK;
1990 if (!gv_fetchmethod_autoload(pkg, "SCALAR", FALSE)) {
1992 if (HvEITER_get(hv))
1993 /* we are in an iteration so the hash cannot be empty */
1995 /* no xhv_eiter so now use FIRSTKEY */
1996 key = sv_newmortal();
1997 magic_nextpack(MUTABLE_SV(hv), mg, key);
1998 HvEITER_set(hv, NULL); /* need to reset iterator */
1999 return SvOK(key) ? &PL_sv_yes : &PL_sv_no;
2002 /* there is a SCALAR method that we can call */
2003 retval = Perl_magic_methcall(aTHX_ MUTABLE_SV(hv), mg, "SCALAR", 0, 0);
2005 retval = &PL_sv_undef;
2010 Perl_magic_setdbline(pTHX_ SV *sv, MAGIC *mg)
2013 GV * const gv = PL_DBline;
2014 const I32 i = SvTRUE(sv);
2015 SV ** const svp = av_fetch(GvAV(gv),
2016 atoi(MgPV_nolen_const(mg)), FALSE);
2018 PERL_ARGS_ASSERT_MAGIC_SETDBLINE;
2020 if (svp && SvIOKp(*svp)) {
2021 OP * const o = INT2PTR(OP*,SvIVX(*svp));
2023 #ifdef PERL_DEBUG_READONLY_OPS
2024 Slab_to_rw(OpSLAB(o));
2026 /* set or clear breakpoint in the relevant control op */
2028 o->op_flags |= OPf_SPECIAL;
2030 o->op_flags &= ~OPf_SPECIAL;
2031 #ifdef PERL_DEBUG_READONLY_OPS
2032 Slab_to_ro(OpSLAB(o));
2040 Perl_magic_getarylen(pTHX_ SV *sv, const MAGIC *mg)
2043 AV * const obj = MUTABLE_AV(mg->mg_obj);
2045 PERL_ARGS_ASSERT_MAGIC_GETARYLEN;
2048 sv_setiv(sv, AvFILL(obj));
2056 Perl_magic_setarylen(pTHX_ SV *sv, MAGIC *mg)
2059 AV * const obj = MUTABLE_AV(mg->mg_obj);
2061 PERL_ARGS_ASSERT_MAGIC_SETARYLEN;
2064 av_fill(obj, SvIV(sv));
2066 Perl_ck_warner(aTHX_ packWARN(WARN_MISC),
2067 "Attempt to set length of freed array");
2073 Perl_magic_cleararylen_p(pTHX_ SV *sv, MAGIC *mg)
2077 PERL_ARGS_ASSERT_MAGIC_CLEARARYLEN_P;
2078 PERL_UNUSED_ARG(sv);
2080 /* Reset the iterator when the array is cleared */
2081 #if IVSIZE == I32SIZE
2082 *((IV *) &(mg->mg_len)) = 0;
2085 *((IV *) mg->mg_ptr) = 0;
2092 Perl_magic_freearylen_p(pTHX_ SV *sv, MAGIC *mg)
2096 PERL_ARGS_ASSERT_MAGIC_FREEARYLEN_P;
2097 PERL_UNUSED_ARG(sv);
2099 /* during global destruction, mg_obj may already have been freed */
2100 if (PL_in_clean_all)
2103 mg = mg_find (mg->mg_obj, PERL_MAGIC_arylen);
2106 /* arylen scalar holds a pointer back to the array, but doesn't own a
2107 reference. Hence the we (the array) are about to go away with it
2108 still pointing at us. Clear its pointer, else it would be pointing
2109 at free memory. See the comment in sv_magic about reference loops,
2110 and why it can't own a reference to us. */
2117 Perl_magic_getpos(pTHX_ SV *sv, MAGIC *mg)
2120 SV* const lsv = LvTARG(sv);
2122 PERL_ARGS_ASSERT_MAGIC_GETPOS;
2123 PERL_UNUSED_ARG(mg);
2125 if (SvTYPE(lsv) >= SVt_PVMG && SvMAGIC(lsv)) {
2126 MAGIC * const found = mg_find(lsv, PERL_MAGIC_regex_global);
2127 if (found && found->mg_len >= 0) {
2128 I32 i = found->mg_len;
2130 sv_pos_b2u(lsv, &i);
2140 Perl_magic_setpos(pTHX_ SV *sv, MAGIC *mg)
2143 SV* const lsv = LvTARG(sv);
2149 PERL_ARGS_ASSERT_MAGIC_SETPOS;
2150 PERL_UNUSED_ARG(mg);
2152 if (SvTYPE(lsv) >= SVt_PVMG && SvMAGIC(lsv))
2153 found = mg_find(lsv, PERL_MAGIC_regex_global);
2159 #ifdef PERL_OLD_COPY_ON_WRITE
2161 sv_force_normal_flags(lsv, 0);
2163 found = sv_magicext(lsv, NULL, PERL_MAGIC_regex_global, &PL_vtbl_mglob,
2166 else if (!SvOK(sv)) {
2170 len = SvPOK_nog(lsv) ? SvCUR(lsv) : sv_len(lsv);
2175 ulen = sv_len_utf8_nomg(lsv);
2185 else if (pos > (SSize_t)len)
2189 pos = sv_pos_u2b_flags(lsv, pos, 0, 0);
2192 found->mg_len = pos;
2193 found->mg_flags &= ~MGf_MINMATCH;
2199 Perl_magic_getsubstr(pTHX_ SV *sv, MAGIC *mg)
2202 SV * const lsv = LvTARG(sv);
2203 const char * const tmps = SvPV_const(lsv,len);
2204 STRLEN offs = LvTARGOFF(sv);
2205 STRLEN rem = LvTARGLEN(sv);
2206 const bool negoff = LvFLAGS(sv) & 1;
2207 const bool negrem = LvFLAGS(sv) & 2;
2209 PERL_ARGS_ASSERT_MAGIC_GETSUBSTR;
2210 PERL_UNUSED_ARG(mg);
2212 if (!translate_substr_offsets(
2213 SvUTF8(lsv) ? sv_len_utf8_nomg(lsv) : len,
2214 negoff ? -(IV)offs : (IV)offs, !negoff,
2215 negrem ? -(IV)rem : (IV)rem, !negrem, &offs, &rem
2217 Perl_ck_warner(aTHX_ packWARN(WARN_SUBSTR), "substr outside of string");
2218 sv_setsv_nomg(sv, &PL_sv_undef);
2223 offs = sv_pos_u2b_flags(lsv, offs, &rem, SV_CONST_RETURN);
2224 sv_setpvn(sv, tmps + offs, rem);
2231 Perl_magic_setsubstr(pTHX_ SV *sv, MAGIC *mg)
2234 STRLEN len, lsv_len, oldtarglen, newtarglen;
2235 const char * const tmps = SvPV_const(sv, len);
2236 SV * const lsv = LvTARG(sv);
2237 STRLEN lvoff = LvTARGOFF(sv);
2238 STRLEN lvlen = LvTARGLEN(sv);
2239 const bool negoff = LvFLAGS(sv) & 1;
2240 const bool neglen = LvFLAGS(sv) & 2;
2242 PERL_ARGS_ASSERT_MAGIC_SETSUBSTR;
2243 PERL_UNUSED_ARG(mg);
2247 Perl_ck_warner(aTHX_ packWARN(WARN_SUBSTR),
2248 "Attempt to use reference as lvalue in substr"
2250 if (SvUTF8(lsv)) lsv_len = sv_len_utf8_nomg(lsv);
2251 else (void)SvPV_nomg(lsv,lsv_len);
2252 if (!translate_substr_offsets(
2254 negoff ? -(IV)lvoff : (IV)lvoff, !negoff,
2255 neglen ? -(IV)lvlen : (IV)lvlen, !neglen, &lvoff, &lvlen
2257 Perl_croak(aTHX_ "substr outside of string");
2260 sv_utf8_upgrade(lsv);
2261 lvoff = sv_pos_u2b_flags(lsv, lvoff, &lvlen, SV_CONST_RETURN);
2262 sv_insert_flags(lsv, lvoff, lvlen, tmps, len, 0);
2263 newtarglen = sv_len_utf8(sv);
2266 else if (lsv && SvUTF8(lsv)) {
2268 lvoff = sv_pos_u2b_flags(lsv, lvoff, &lvlen, SV_CONST_RETURN);
2270 utf8 = (char*)bytes_to_utf8((U8*)tmps, &len);
2271 sv_insert_flags(lsv, lvoff, lvlen, utf8, len, 0);
2275 sv_insert_flags(lsv, lvoff, lvlen, tmps, len, 0);
2278 if (!neglen) LvTARGLEN(sv) = newtarglen;
2279 if (negoff) LvTARGOFF(sv) += newtarglen - oldtarglen;
2285 Perl_magic_gettaint(pTHX_ SV *sv, MAGIC *mg)
2289 PERL_ARGS_ASSERT_MAGIC_GETTAINT;
2290 PERL_UNUSED_ARG(sv);
2292 TAINT_IF((PL_localizing != 1) && (mg->mg_len & 1));
2297 Perl_magic_settaint(pTHX_ SV *sv, MAGIC *mg)
2301 PERL_ARGS_ASSERT_MAGIC_SETTAINT;
2302 PERL_UNUSED_ARG(sv);
2304 /* update taint status */
2313 Perl_magic_getvec(pTHX_ SV *sv, MAGIC *mg)
2315 SV * const lsv = LvTARG(sv);
2317 PERL_ARGS_ASSERT_MAGIC_GETVEC;
2318 PERL_UNUSED_ARG(mg);
2321 sv_setuv(sv, do_vecget(lsv, LvTARGOFF(sv), LvTARGLEN(sv)));
2329 Perl_magic_setvec(pTHX_ SV *sv, MAGIC *mg)
2331 PERL_ARGS_ASSERT_MAGIC_SETVEC;
2332 PERL_UNUSED_ARG(mg);
2333 do_vecset(sv); /* XXX slurp this routine */
2338 Perl_magic_getdefelem(pTHX_ SV *sv, MAGIC *mg)
2343 PERL_ARGS_ASSERT_MAGIC_GETDEFELEM;
2345 if (LvTARGLEN(sv)) {
2347 SV * const ahv = LvTARG(sv);
2348 HE * const he = hv_fetch_ent(MUTABLE_HV(ahv), mg->mg_obj, FALSE, 0);
2353 AV *const av = MUTABLE_AV(LvTARG(sv));
2354 if ((I32)LvTARGOFF(sv) <= AvFILL(av))
2355 targ = AvARRAY(av)[LvTARGOFF(sv)];
2357 if (targ && (targ != &PL_sv_undef)) {
2358 /* somebody else defined it for us */
2359 SvREFCNT_dec(LvTARG(sv));
2360 LvTARG(sv) = SvREFCNT_inc_simple_NN(targ);
2362 SvREFCNT_dec(mg->mg_obj);
2364 mg->mg_flags &= ~MGf_REFCOUNTED;
2369 sv_setsv(sv, targ ? targ : &PL_sv_undef);
2374 Perl_magic_setdefelem(pTHX_ SV *sv, MAGIC *mg)
2376 PERL_ARGS_ASSERT_MAGIC_SETDEFELEM;
2377 PERL_UNUSED_ARG(mg);
2381 sv_setsv(LvTARG(sv), sv);
2382 SvSETMAGIC(LvTARG(sv));
2388 Perl_vivify_defelem(pTHX_ SV *sv)
2394 PERL_ARGS_ASSERT_VIVIFY_DEFELEM;
2396 if (!LvTARGLEN(sv) || !(mg = mg_find(sv, PERL_MAGIC_defelem)))
2399 SV * const ahv = LvTARG(sv);
2400 HE * const he = hv_fetch_ent(MUTABLE_HV(ahv), mg->mg_obj, TRUE, 0);
2403 if (!value || value == &PL_sv_undef)
2404 Perl_croak(aTHX_ PL_no_helem_sv, SVfARG(mg->mg_obj));
2407 AV *const av = MUTABLE_AV(LvTARG(sv));
2408 if ((I32)LvTARGLEN(sv) < 0 && (I32)LvTARGOFF(sv) > AvFILL(av))
2409 LvTARG(sv) = NULL; /* array can't be extended */
2411 SV* const * const svp = av_fetch(av, LvTARGOFF(sv), TRUE);
2412 if (!svp || (value = *svp) == &PL_sv_undef)
2413 Perl_croak(aTHX_ PL_no_aelem, (I32)LvTARGOFF(sv));
2416 SvREFCNT_inc_simple_void(value);
2417 SvREFCNT_dec(LvTARG(sv));
2420 SvREFCNT_dec(mg->mg_obj);
2422 mg->mg_flags &= ~MGf_REFCOUNTED;
2426 Perl_magic_killbackrefs(pTHX_ SV *sv, MAGIC *mg)
2428 PERL_ARGS_ASSERT_MAGIC_KILLBACKREFS;
2429 Perl_sv_kill_backrefs(aTHX_ sv, MUTABLE_AV(mg->mg_obj));
2434 Perl_magic_setmglob(pTHX_ SV *sv, MAGIC *mg)
2436 PERL_ARGS_ASSERT_MAGIC_SETMGLOB;
2437 PERL_UNUSED_CONTEXT;
2438 PERL_UNUSED_ARG(sv);
2444 Perl_magic_setuvar(pTHX_ SV *sv, MAGIC *mg)
2446 const struct ufuncs * const uf = (struct ufuncs *)mg->mg_ptr;
2448 PERL_ARGS_ASSERT_MAGIC_SETUVAR;
2450 if (uf && uf->uf_set)
2451 (*uf->uf_set)(aTHX_ uf->uf_index, sv);
2456 Perl_magic_setregexp(pTHX_ SV *sv, MAGIC *mg)
2458 const char type = mg->mg_type;
2460 PERL_ARGS_ASSERT_MAGIC_SETREGEXP;
2462 if (type == PERL_MAGIC_qr) {
2463 } else if (type == PERL_MAGIC_bm) {
2467 assert(type == PERL_MAGIC_fm);
2469 return sv_unmagic(sv, type);
2472 #ifdef USE_LOCALE_COLLATE
2474 Perl_magic_setcollxfrm(pTHX_ SV *sv, MAGIC *mg)
2476 PERL_ARGS_ASSERT_MAGIC_SETCOLLXFRM;
2479 * RenE<eacute> Descartes said "I think not."
2480 * and vanished with a faint plop.
2482 PERL_UNUSED_CONTEXT;
2483 PERL_UNUSED_ARG(sv);
2485 Safefree(mg->mg_ptr);
2491 #endif /* USE_LOCALE_COLLATE */
2493 /* Just clear the UTF-8 cache data. */
2495 Perl_magic_setutf8(pTHX_ SV *sv, MAGIC *mg)
2497 PERL_ARGS_ASSERT_MAGIC_SETUTF8;
2498 PERL_UNUSED_CONTEXT;
2499 PERL_UNUSED_ARG(sv);
2500 Safefree(mg->mg_ptr); /* The mg_ptr holds the pos cache. */
2502 mg->mg_len = -1; /* The mg_len holds the len cache. */
2507 Perl_magic_set(pTHX_ SV *sv, MAGIC *mg)
2513 const char * const remaining = mg->mg_ptr + 1;
2518 PERL_ARGS_ASSERT_MAGIC_SET;
2520 switch (*mg->mg_ptr) {
2521 case '\015': /* $^MATCH */
2522 if (strEQ(remaining, "ATCH"))
2524 case '`': /* ${^PREMATCH} caught below */
2526 paren = RX_BUFF_IDX_PREMATCH;
2528 case '\'': /* ${^POSTMATCH} caught below */
2530 paren = RX_BUFF_IDX_POSTMATCH;
2534 paren = RX_BUFF_IDX_FULLMATCH;
2536 case '1': case '2': case '3': case '4':
2537 case '5': case '6': case '7': case '8': case '9':
2538 paren = atoi(mg->mg_ptr);
2540 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
2542 CALLREG_NUMBUF_STORE((REGEXP * const)rx,paren,sv);
2544 /* Croak with a READONLY error when a numbered match var is
2545 * set without a previous pattern match. Unless it's C<local $1>
2548 if (!PL_localizing) {
2549 Perl_croak_no_modify(aTHX);
2553 case '\001': /* ^A */
2554 if (SvOK(sv)) sv_copypv(PL_bodytarget, sv);
2555 else SvOK_off(PL_bodytarget);
2556 FmLINES(PL_bodytarget) = 0;
2557 if (SvPOK(PL_bodytarget)) {
2558 char *s = SvPVX(PL_bodytarget);
2559 while ( ((s = strchr(s, '\n'))) ) {
2560 FmLINES(PL_bodytarget)++;
2564 /* mg_set() has temporarily made sv non-magical */
2566 if ((tmg = mg_find(sv,PERL_MAGIC_taint)) && tmg->mg_len & 1)
2567 SvTAINTED_on(PL_bodytarget);
2569 SvTAINTED_off(PL_bodytarget);
2572 case '\003': /* ^C */
2573 PL_minus_c = cBOOL(SvIV(sv));
2576 case '\004': /* ^D */
2578 s = SvPV_nolen_const(sv);
2579 PL_debug = get_debug_opts(&s, 0) | DEBUG_TOP_FLAG;
2580 if (DEBUG_x_TEST || DEBUG_B_TEST)
2581 dump_all_perl(!DEBUG_B_TEST);
2583 PL_debug = (SvIV(sv)) | DEBUG_TOP_FLAG;
2586 case '\005': /* ^E */
2587 if (*(mg->mg_ptr+1) == '\0') {
2589 set_vaxc_errno(SvIV(sv));
2592 SetLastError( SvIV(sv) );
2595 os2_setsyserrno(SvIV(sv));
2597 /* will anyone ever use this? */
2598 SETERRNO(SvIV(sv), 4);
2603 else if (strEQ(mg->mg_ptr+1, "NCODING")) {
2604 SvREFCNT_dec(PL_encoding);
2605 if (SvOK(sv) || SvGMAGICAL(sv)) {
2606 PL_encoding = newSVsv(sv);
2613 case '\006': /* ^F */
2614 PL_maxsysfd = SvIV(sv);
2616 case '\010': /* ^H */
2617 PL_hints = SvIV(sv);
2619 case '\011': /* ^I */ /* NOT \t in EBCDIC */
2620 Safefree(PL_inplace);
2621 PL_inplace = SvOK(sv) ? savesvpv(sv) : NULL;
2623 case '\016': /* ^N */
2624 if (PL_curpm && (rx = PM_GETRE(PL_curpm))
2625 && (paren = RX_LASTCLOSEPAREN(rx))) goto setparen_got_rx;
2627 case '\017': /* ^O */
2628 if (*(mg->mg_ptr+1) == '\0') {
2629 Safefree(PL_osname);
2632 TAINT_PROPER("assigning to $^O");
2633 PL_osname = savesvpv(sv);
2636 else if (strEQ(mg->mg_ptr, "\017PEN")) {
2638 const char *const start = SvPV(sv, len);
2639 const char *out = (const char*)memchr(start, '\0', len);
2643 PL_compiling.cop_hints |= HINT_LEXICAL_IO_IN | HINT_LEXICAL_IO_OUT;
2644 PL_hints |= HINT_LEXICAL_IO_IN | HINT_LEXICAL_IO_OUT;
2646 /* Opening for input is more common than opening for output, so
2647 ensure that hints for input are sooner on linked list. */
2648 tmp = out ? newSVpvn_flags(out + 1, start + len - out - 1,
2650 : newSVpvs_flags("", SvUTF8(sv));
2651 (void)hv_stores(GvHV(PL_hintgv), "open>", tmp);
2654 tmp = newSVpvn_flags(start, out ? (STRLEN)(out - start) : len,
2656 (void)hv_stores(GvHV(PL_hintgv), "open<", tmp);
2660 case '\020': /* ^P */
2661 if (*remaining == '\0') { /* ^P */
2662 PL_perldb = SvIV(sv);
2663 if (PL_perldb && !PL_DBsingle)
2666 } else if (strEQ(remaining, "REMATCH")) { /* $^PREMATCH */
2668 } else if (strEQ(remaining, "OSTMATCH")) { /* $^POSTMATCH */
2672 case '\024': /* ^T */
2674 PL_basetime = (Time_t)(SvNOK(sv) ? SvNVX(sv) : sv_2nv(sv));
2676 PL_basetime = (Time_t)SvIV(sv);
2679 case '\025': /* ^UTF8CACHE */
2680 if (strEQ(mg->mg_ptr+1, "TF8CACHE")) {
2681 PL_utf8cache = (signed char) sv_2iv(sv);
2684 case '\027': /* ^W & $^WARNING_BITS */
2685 if (*(mg->mg_ptr+1) == '\0') {
2686 if ( ! (PL_dowarn & G_WARN_ALL_MASK)) {
2688 PL_dowarn = (PL_dowarn & ~G_WARN_ON)
2689 | (i ? G_WARN_ON : G_WARN_OFF) ;
2692 else if (strEQ(mg->mg_ptr+1, "ARNING_BITS")) {
2693 if ( ! (PL_dowarn & G_WARN_ALL_MASK)) {
2695 PL_compiling.cop_warnings = pWARN_STD;
2700 int accumulate = 0 ;
2701 int any_fatals = 0 ;
2702 const char * const ptr = SvPV_const(sv, len) ;
2703 for (i = 0 ; i < len ; ++i) {
2704 accumulate |= ptr[i] ;
2705 any_fatals |= (ptr[i] & 0xAA) ;
2708 if (!specialWARN(PL_compiling.cop_warnings))
2709 PerlMemShared_free(PL_compiling.cop_warnings);
2710 PL_compiling.cop_warnings = pWARN_NONE;
2712 /* Yuck. I can't see how to abstract this: */
2713 else if (isWARN_on(((STRLEN *)SvPV_nolen_const(sv)) - 1,
2714 WARN_ALL) && !any_fatals) {
2715 if (!specialWARN(PL_compiling.cop_warnings))
2716 PerlMemShared_free(PL_compiling.cop_warnings);
2717 PL_compiling.cop_warnings = pWARN_ALL;
2718 PL_dowarn |= G_WARN_ONCE ;
2722 const char *const p = SvPV_const(sv, len);
2724 PL_compiling.cop_warnings
2725 = Perl_new_warnings_bitfield(aTHX_ PL_compiling.cop_warnings,
2728 if (isWARN_on(PL_compiling.cop_warnings, WARN_ONCE))
2729 PL_dowarn |= G_WARN_ONCE ;
2737 if (PL_localizing) {
2738 if (PL_localizing == 1)
2739 SAVESPTR(PL_last_in_gv);
2741 else if (SvOK(sv) && GvIO(PL_last_in_gv))
2742 IoLINES(GvIOp(PL_last_in_gv)) = SvIV(sv);
2745 Safefree(IoTOP_NAME(GvIOp(PL_defoutgv)));
2746 s = IoTOP_NAME(GvIOp(PL_defoutgv)) = savesvpv(sv);
2747 IoTOP_GV(GvIOp(PL_defoutgv)) = gv_fetchsv(sv, GV_ADD, SVt_PVIO);
2750 Safefree(IoFMT_NAME(GvIOp(PL_defoutgv)));
2751 s = IoFMT_NAME(GvIOp(PL_defoutgv)) = savesvpv(sv);
2752 IoFMT_GV(GvIOp(PL_defoutgv)) = gv_fetchsv(sv, GV_ADD, SVt_PVIO);
2755 IoPAGE_LEN(GvIOp(PL_defoutgv)) = (SvIV(sv));
2758 IoLINES_LEFT(GvIOp(PL_defoutgv)) = (SvIV(sv));
2759 if (IoLINES_LEFT(GvIOp(PL_defoutgv)) < 0L)
2760 IoLINES_LEFT(GvIOp(PL_defoutgv)) = 0L;
2763 IoPAGE(GvIOp(PL_defoutgv)) = (SvIV(sv));
2767 IO * const io = GvIO(PL_defoutgv);
2770 if ((SvIV(sv)) == 0)
2771 IoFLAGS(io) &= ~IOf_FLUSH;
2773 if (!(IoFLAGS(io) & IOf_FLUSH)) {
2774 PerlIO *ofp = IoOFP(io);
2776 (void)PerlIO_flush(ofp);
2777 IoFLAGS(io) |= IOf_FLUSH;
2783 SvREFCNT_dec(PL_rs);
2784 PL_rs = newSVsv(sv);
2787 SvREFCNT_dec(PL_ors_sv);
2789 PL_ors_sv = newSVsv(sv);
2797 Perl_croak(aTHX_ "Assigning non-zero to $[ is no longer possible");
2800 #ifdef COMPLEX_STATUS
2801 if (PL_localizing == 2) {
2802 SvUPGRADE(sv, SVt_PVLV);
2803 PL_statusvalue = LvTARGOFF(sv);
2804 PL_statusvalue_vms = LvTARGLEN(sv);
2808 #ifdef VMSISH_STATUS
2810 STATUS_NATIVE_CHILD_SET((U32)SvIV(sv));
2813 STATUS_UNIX_EXIT_SET(SvIV(sv));
2818 # define PERL_VMS_BANG vaxc$errno
2820 # define PERL_VMS_BANG 0
2822 SETERRNO(SvIOK(sv) ? SvIVX(sv) : SvOK(sv) ? sv_2iv(sv) : 0,
2823 (SvIV(sv) == EVMSERR) ? 4 : PERL_VMS_BANG);
2828 const IV new_uid = SvIV(sv);
2829 PL_delaymagic_uid = new_uid;
2830 if (PL_delaymagic) {
2831 PL_delaymagic |= DM_RUID;
2832 break; /* don't do magic till later */
2835 (void)setruid((Uid_t)new_uid);
2838 (void)setreuid((Uid_t)new_uid, (Uid_t)-1);
2840 #ifdef HAS_SETRESUID
2841 (void)setresuid((Uid_t)new_uid, (Uid_t)-1, (Uid_t)-1);
2843 if (new_uid == PerlProc_geteuid()) { /* special case $< = $> */
2845 /* workaround for Darwin's setuid peculiarity, cf [perl #24122] */
2846 if (new_uid != 0 && PerlProc_getuid() == 0)
2847 (void)PerlProc_setuid(0);
2849 (void)PerlProc_setuid(new_uid);
2851 Perl_croak(aTHX_ "setruid() not implemented");
2860 const UV new_euid = SvIV(sv);
2861 PL_delaymagic_euid = new_euid;
2862 if (PL_delaymagic) {
2863 PL_delaymagic |= DM_EUID;
2864 break; /* don't do magic till later */
2867 (void)seteuid((Uid_t)new_euid);
2870 (void)setreuid((Uid_t)-1, (Uid_t)new_euid);
2872 #ifdef HAS_SETRESUID
2873 (void)setresuid((Uid_t)-1, (Uid_t)new_euid, (Uid_t)-1);
2875 if (new_euid == PerlProc_getuid()) /* special case $> = $< */
2876 PerlProc_setuid(new_euid);
2878 Perl_croak(aTHX_ "seteuid() not implemented");
2887 const UV new_gid = SvIV(sv);
2888 PL_delaymagic_gid = new_gid;
2889 if (PL_delaymagic) {
2890 PL_delaymagic |= DM_RGID;
2891 break; /* don't do magic till later */
2894 (void)setrgid((Gid_t)new_gid);
2897 (void)setregid((Gid_t)new_gid, (Gid_t)-1);
2899 #ifdef HAS_SETRESGID
2900 (void)setresgid((Gid_t)new_gid, (Gid_t)-1, (Gid_t) -1);
2902 if (new_gid == PerlProc_getegid()) /* special case $( = $) */
2903 (void)PerlProc_setgid(new_gid);
2905 Perl_croak(aTHX_ "setrgid() not implemented");
2915 #ifdef HAS_SETGROUPS
2917 const char *p = SvPV_const(sv, len);
2918 Groups_t *gary = NULL;
2919 #ifdef _SC_NGROUPS_MAX
2920 int maxgrp = sysconf(_SC_NGROUPS_MAX);
2925 int maxgrp = NGROUPS;
2931 for (i = 0; i < maxgrp; ++i) {
2932 while (*p && !isSPACE(*p))
2939 Newx(gary, i + 1, Groups_t);
2941 Renew(gary, i + 1, Groups_t);
2945 (void)setgroups(i, gary);
2948 #else /* HAS_SETGROUPS */
2949 new_egid = SvIV(sv);
2950 #endif /* HAS_SETGROUPS */
2951 PL_delaymagic_egid = new_egid;
2952 if (PL_delaymagic) {
2953 PL_delaymagic |= DM_EGID;
2954 break; /* don't do magic till later */
2957 (void)setegid((Gid_t)new_egid);
2960 (void)setregid((Gid_t)-1, (Gid_t)new_egid);
2962 #ifdef HAS_SETRESGID
2963 (void)setresgid((Gid_t)-1, (Gid_t)new_egid, (Gid_t)-1);
2965 if (new_egid == PerlProc_getgid()) /* special case $) = $( */
2966 (void)PerlProc_setgid(new_egid);
2968 Perl_croak(aTHX_ "setegid() not implemented");
2976 PL_chopset = SvPV_force(sv,len);
2979 /* Store the pid in mg->mg_obj so we can tell when a fork has
2980 occurred. mg->mg_obj points to *$ by default, so clear it. */
2981 if (isGV(mg->mg_obj)) {
2982 if (mg->mg_flags & MGf_REFCOUNTED) /* probably never true */
2983 SvREFCNT_dec(mg->mg_obj);
2984 mg->mg_flags |= MGf_REFCOUNTED;
2985 mg->mg_obj = newSViv((IV)PerlProc_getpid());
2987 else sv_setiv(mg->mg_obj, (IV)PerlProc_getpid());
2990 LOCK_DOLLARZERO_MUTEX;
2991 #ifdef HAS_SETPROCTITLE
2992 /* The BSDs don't show the argv[] in ps(1) output, they
2993 * show a string from the process struct and provide
2994 * the setproctitle() routine to manipulate that. */
2995 if (PL_origalen != 1) {
2996 s = SvPV_const(sv, len);
2997 # if __FreeBSD_version > 410001
2998 /* The leading "-" removes the "perl: " prefix,
2999 * but not the "(perl) suffix from the ps(1)
3000 * output, because that's what ps(1) shows if the
3001 * argv[] is modified. */
3002 setproctitle("-%s", s);
3003 # else /* old FreeBSDs, NetBSD, OpenBSD, anyBSD */
3004 /* This doesn't really work if you assume that
3005 * $0 = 'foobar'; will wipe out 'perl' from the $0
3006 * because in ps(1) output the result will be like
3007 * sprintf("perl: %s (perl)", s)
3008 * I guess this is a security feature:
3009 * one (a user process) cannot get rid of the original name.
3011 setproctitle("%s", s);
3014 #elif defined(__hpux) && defined(PSTAT_SETCMD)
3015 if (PL_origalen != 1) {
3017 s = SvPV_const(sv, len);
3018 un.pst_command = (char *)s;
3019 pstat(PSTAT_SETCMD, un, len, 0, 0);
3022 if (PL_origalen > 1) {
3023 /* PL_origalen is set in perl_parse(). */
3024 s = SvPV_force(sv,len);
3025 if (len >= (STRLEN)PL_origalen-1) {
3026 /* Longer than original, will be truncated. We assume that
3027 * PL_origalen bytes are available. */
3028 Copy(s, PL_origargv[0], PL_origalen-1, char);
3031 /* Shorter than original, will be padded. */
3033 /* Special case for Mac OS X: see [perl #38868] */
3036 /* Is the space counterintuitive? Yes.
3037 * (You were expecting \0?)
3038 * Does it work? Seems to. (In Linux 2.4.20 at least.)
3040 const int pad = ' ';
3042 Copy(s, PL_origargv[0], len, char);
3043 PL_origargv[0][len] = 0;
3044 memset(PL_origargv[0] + len + 1,
3045 pad, PL_origalen - len - 1);
3047 PL_origargv[0][PL_origalen-1] = 0;
3048 for (i = 1; i < PL_origargc; i++)
3050 #ifdef HAS_PRCTL_SET_NAME
3051 /* Set the legacy process name in addition to the POSIX name on Linux */
3052 if (prctl(PR_SET_NAME, (unsigned long)s, 0, 0, 0) != 0) {
3053 /* diag_listed_as: SKIPME */
3054 Perl_croak(aTHX_ "Can't set $0 with prctl(): %s", Strerror(errno));
3059 UNLOCK_DOLLARZERO_MUTEX;
3066 Perl_whichsig_sv(pTHX_ SV *sigsv)
3070 PERL_ARGS_ASSERT_WHICHSIG_SV;
3071 PERL_UNUSED_CONTEXT;
3072 sigpv = SvPV_const(sigsv, siglen);
3073 return whichsig_pvn(sigpv, siglen);
3077 Perl_whichsig_pv(pTHX_ const char *sig)
3079 PERL_ARGS_ASSERT_WHICHSIG_PV;
3080 PERL_UNUSED_CONTEXT;
3081 return whichsig_pvn(sig, strlen(sig));
3085 Perl_whichsig_pvn(pTHX_ const char *sig, STRLEN len)
3089 PERL_ARGS_ASSERT_WHICHSIG_PVN;
3090 PERL_UNUSED_CONTEXT;
3092 for (sigv = (char* const*)PL_sig_name; *sigv; sigv++)
3093 if (strlen(*sigv) == len && memEQ(sig,*sigv, len))
3094 return PL_sig_num[sigv - (char* const*)PL_sig_name];
3096 if (memEQs(sig, len, "CHLD"))
3100 if (memEQs(sig, len, "CLD"))
3107 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
3108 Perl_sighandler(int sig, siginfo_t *sip, void *uap)
3110 Perl_sighandler(int sig)
3113 #ifdef PERL_GET_SIG_CONTEXT
3114 dTHXa(PERL_GET_SIG_CONTEXT);
3121 SV * const tSv = PL_Sv;
3125 XPV * const tXpv = PL_Xpv;
3126 I32 old_ss_ix = PL_savestack_ix;
3127 SV *errsv_save = NULL;
3130 if (!PL_psig_ptr[sig]) {
3131 PerlIO_printf(Perl_error_log, "Signal SIG%s received, but no signal handler set.\n",
3136 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG) {
3137 /* Max number of items pushed there is 3*n or 4. We cannot fix
3138 infinity, so we fix 4 (in fact 5): */
3139 if (PL_savestack_ix + 15 <= PL_savestack_max) {
3141 PL_savestack_ix += 5; /* Protect save in progress. */
3142 SAVEDESTRUCTOR_X(S_unwind_handler_stack, NULL);
3145 /* sv_2cv is too complicated, try a simpler variant first: */
3146 if (!SvROK(PL_psig_ptr[sig]) || !(cv = MUTABLE_CV(SvRV(PL_psig_ptr[sig])))
3147 || SvTYPE(cv) != SVt_PVCV) {
3149 cv = sv_2cv(PL_psig_ptr[sig], &st, &gv, GV_ADD);
3152 if (!cv || !CvROOT(cv)) {
3153 Perl_ck_warner(aTHX_ packWARN(WARN_SIGNAL), "SIG%s handler \"%s\" not defined.\n",
3154 PL_sig_name[sig], (gv ? GvENAME(gv)
3161 sv = PL_psig_name[sig]
3162 ? SvREFCNT_inc_NN(PL_psig_name[sig])
3163 : newSVpv(PL_sig_name[sig],0);
3167 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG) {
3168 /* make sure our assumption about the size of the SAVEs are correct:
3169 * 3 for SAVEDESTRUCTOR_X, 2 for SAVEFREESV */
3170 assert(old_ss_ix + 2 + ((flags & 1) ? 3+5 : 0) == PL_savestack_ix);
3173 PUSHSTACKi(PERLSI_SIGNAL);
3176 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
3178 struct sigaction oact;
3180 if (sigaction(sig, 0, &oact) == 0 && oact.sa_flags & SA_SIGINFO) {
3183 SV *rv = newRV_noinc(MUTABLE_SV(sih));
3184 /* The siginfo fields signo, code, errno, pid, uid,
3185 * addr, status, and band are defined by POSIX/SUSv3. */
3186 (void)hv_stores(sih, "signo", newSViv(sip->si_signo));
3187 (void)hv_stores(sih, "code", newSViv(sip->si_code));
3188 #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. */
3189 hv_stores(sih, "errno", newSViv(sip->si_errno));
3190 hv_stores(sih, "status", newSViv(sip->si_status));
3191 hv_stores(sih, "uid", newSViv(sip->si_uid));
3192 hv_stores(sih, "pid", newSViv(sip->si_pid));
3193 hv_stores(sih, "addr", newSVuv(PTR2UV(sip->si_addr)));
3194 hv_stores(sih, "band", newSViv(sip->si_band));
3198 mPUSHp((char *)sip, sizeof(*sip));
3206 errsv_save = newSVsv(ERRSV);
3208 call_sv(MUTABLE_SV(cv), G_DISCARD|G_EVAL);
3211 if (SvTRUE(ERRSV)) {
3212 SvREFCNT_dec(errsv_save);
3214 /* Handler "died", for example to get out of a restart-able read().
3215 * Before we re-do that on its behalf re-enable the signal which was
3216 * blocked by the system when we entered.
3218 #ifdef HAS_SIGPROCMASK
3219 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
3225 sigaddset(&set,sig);
3226 sigprocmask(SIG_UNBLOCK, &set, NULL);
3229 /* Not clear if this will work */
3230 (void)rsignal(sig, SIG_IGN);
3231 (void)rsignal(sig, PL_csighandlerp);
3233 #endif /* !PERL_MICRO */
3237 sv_setsv(ERRSV, errsv_save);
3238 SvREFCNT_dec(errsv_save);
3242 /* pop any of SAVEFREESV, SAVEDESTRUCTOR_X and "save in progress" */
3243 PL_savestack_ix = old_ss_ix;
3246 PL_op = myop; /* Apparently not needed... */
3248 PL_Sv = tSv; /* Restore global temporaries. */
3255 S_restore_magic(pTHX_ const void *p)
3258 MGS* const mgs = SSPTR(PTR2IV(p), MGS*);
3259 SV* const sv = mgs->mgs_sv;
3265 if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv)) {
3266 SvTEMP_off(sv); /* if it's still magical, this value isn't temporary */
3267 #ifdef PERL_OLD_COPY_ON_WRITE
3268 /* While magic was saved (and off) sv_setsv may well have seen
3269 this SV as a prime candidate for COW. */
3271 sv_force_normal_flags(sv, 0);
3273 if (mgs->mgs_readonly)
3275 if (mgs->mgs_magical)
3276 SvFLAGS(sv) |= mgs->mgs_magical;
3281 bumped = mgs->mgs_bumped;
3282 mgs->mgs_sv = NULL; /* mark the MGS structure as restored */
3284 /* If we're still on top of the stack, pop us off. (That condition
3285 * will be satisfied if restore_magic was called explicitly, but *not*
3286 * if it's being called via leave_scope.)
3287 * The reason for doing this is that otherwise, things like sv_2cv()
3288 * may leave alloc gunk on the savestack, and some code
3289 * (e.g. sighandler) doesn't expect that...
3291 if (PL_savestack_ix == mgs->mgs_ss_ix)
3293 UV popval = SSPOPUV;
3294 assert(popval == SAVEt_DESTRUCTOR_X);
3295 PL_savestack_ix -= 2;
3297 assert((popval & SAVE_MASK) == SAVEt_ALLOC);
3298 PL_savestack_ix -= popval >> SAVE_TIGHT_SHIFT;
3301 if (SvREFCNT(sv) == 1) {
3302 /* We hold the last reference to this SV, which implies that the
3303 SV was deleted as a side effect of the routines we called.
3304 So artificially keep it alive a bit longer.
3305 We avoid turning on the TEMP flag, which can cause the SV's
3306 buffer to get stolen (and maybe other stuff). */
3311 SvREFCNT_dec(sv); /* undo the inc in S_save_magic() */
3315 /* clean up the mess created by Perl_sighandler().
3316 * Note that this is only called during an exit in a signal handler;
3317 * a die is trapped by the call_sv() and the SAVEDESTRUCTOR_X manually
3321 S_unwind_handler_stack(pTHX_ const void *p)
3326 PL_savestack_ix -= 5; /* Unprotect save in progress. */
3330 =for apidoc magic_sethint
3332 Triggered by a store to %^H, records the key/value pair to
3333 C<PL_compiling.cop_hints_hash>. It is assumed that hints aren't storing
3334 anything that would need a deep copy. Maybe we should warn if we find a
3340 Perl_magic_sethint(pTHX_ SV *sv, MAGIC *mg)
3343 SV *key = (mg->mg_len == HEf_SVKEY) ? MUTABLE_SV(mg->mg_ptr)
3344 : newSVpvn_flags(mg->mg_ptr, mg->mg_len, SVs_TEMP);
3346 PERL_ARGS_ASSERT_MAGIC_SETHINT;
3348 /* mg->mg_obj isn't being used. If needed, it would be possible to store
3349 an alternative leaf in there, with PL_compiling.cop_hints being used if
3350 it's NULL. If needed for threads, the alternative could lock a mutex,
3351 or take other more complex action. */
3353 /* Something changed in %^H, so it will need to be restored on scope exit.
3354 Doing this here saves a lot of doing it manually in perl code (and
3355 forgetting to do it, and consequent subtle errors. */
3356 PL_hints |= HINT_LOCALIZE_HH;
3357 CopHINTHASH_set(&PL_compiling,
3358 cophh_store_sv(CopHINTHASH_get(&PL_compiling), key, 0, sv, 0));
3363 =for apidoc magic_clearhint
3365 Triggered by a delete from %^H, records the key to
3366 C<PL_compiling.cop_hints_hash>.
3371 Perl_magic_clearhint(pTHX_ SV *sv, MAGIC *mg)
3375 PERL_ARGS_ASSERT_MAGIC_CLEARHINT;
3376 PERL_UNUSED_ARG(sv);
3378 PL_hints |= HINT_LOCALIZE_HH;
3379 CopHINTHASH_set(&PL_compiling,
3380 mg->mg_len == HEf_SVKEY
3381 ? cophh_delete_sv(CopHINTHASH_get(&PL_compiling),
3382 MUTABLE_SV(mg->mg_ptr), 0, 0)
3383 : cophh_delete_pvn(CopHINTHASH_get(&PL_compiling),
3384 mg->mg_ptr, mg->mg_len, 0, 0));
3389 =for apidoc magic_clearhints
3391 Triggered by clearing %^H, resets C<PL_compiling.cop_hints_hash>.
3396 Perl_magic_clearhints(pTHX_ SV *sv, MAGIC *mg)
3398 PERL_ARGS_ASSERT_MAGIC_CLEARHINTS;
3399 PERL_UNUSED_ARG(sv);
3400 PERL_UNUSED_ARG(mg);
3401 cophh_free(CopHINTHASH_get(&PL_compiling));
3402 CopHINTHASH_set(&PL_compiling, cophh_new_empty());
3407 Perl_magic_copycallchecker(pTHX_ SV *sv, MAGIC *mg, SV *nsv,
3408 const char *name, I32 namlen)
3412 PERL_ARGS_ASSERT_MAGIC_COPYCALLCHECKER;
3413 PERL_UNUSED_ARG(sv);
3414 PERL_UNUSED_ARG(name);
3415 PERL_UNUSED_ARG(namlen);
3417 sv_magic(nsv, &PL_sv_undef, mg->mg_type, NULL, 0);
3418 nmg = mg_find(nsv, mg->mg_type);
3419 if (nmg->mg_flags & MGf_REFCOUNTED) SvREFCNT_dec(nmg->mg_obj);
3420 nmg->mg_ptr = mg->mg_ptr;
3421 nmg->mg_obj = SvREFCNT_inc_simple(mg->mg_obj);
3422 nmg->mg_flags |= MGf_REFCOUNTED;
3428 * c-indentation-style: bsd
3430 * indent-tabs-mode: nil
3433 * ex: set ts=8 sts=4 sw=4 et: