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 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
61 Signal_t Perl_csighandler(int sig, siginfo_t *, void *);
63 Signal_t Perl_csighandler(int sig);
67 /* Missing protos on LynxOS */
68 void setruid(uid_t id);
69 void seteuid(uid_t id);
70 void setrgid(uid_t id);
71 void setegid(uid_t id);
75 * Use the "DESTRUCTOR" scope cleanup to reinstate magic.
84 /* MGS is typedef'ed to struct magic_state in perl.h */
87 S_save_magic(pTHX_ I32 mgs_ix, SV *sv)
92 PERL_ARGS_ASSERT_SAVE_MAGIC;
94 assert(SvMAGICAL(sv));
95 /* Turning READONLY off for a copy-on-write scalar (including shared
96 hash keys) is a bad idea. */
98 sv_force_normal_flags(sv, 0);
100 SAVEDESTRUCTOR_X(S_restore_magic, INT2PTR(void*, (IV)mgs_ix));
102 mgs = SSPTR(mgs_ix, MGS*);
104 mgs->mgs_magical = SvMAGICAL(sv);
105 mgs->mgs_readonly = SvREADONLY(sv) != 0;
106 mgs->mgs_ss_ix = PL_savestack_ix; /* points after the saved destructor */
110 if (!(SvFLAGS(sv) & (SVf_IOK|SVf_NOK|SVf_POK))) {
111 /* No public flags are set, so promote any private flags to public. */
112 SvFLAGS(sv) |= (SvFLAGS(sv) & (SVp_IOK|SVp_NOK|SVp_POK)) >> PRIVSHIFT;
117 =for apidoc mg_magical
119 Turns on the magical status of an SV. See C<sv_magic>.
125 Perl_mg_magical(pTHX_ SV *sv)
128 PERL_ARGS_ASSERT_MG_MAGICAL;
132 if ((mg = SvMAGIC(sv))) {
134 const MGVTBL* const vtbl = mg->mg_virtual;
136 if (vtbl->svt_get && !(mg->mg_flags & MGf_GSKIP))
143 } while ((mg = mg->mg_moremagic));
144 if (!(SvFLAGS(sv) & (SVs_GMG|SVs_SMG)))
150 /* is this container magic (%ENV, $1 etc), or value magic (pos, taint etc)? */
153 S_is_container_magic(const MAGIC *mg)
156 switch (mg->mg_type) {
159 case PERL_MAGIC_regex_global:
160 case PERL_MAGIC_nkeys:
161 #ifdef USE_LOCALE_COLLATE
162 case PERL_MAGIC_collxfrm:
165 case PERL_MAGIC_taint:
167 case PERL_MAGIC_vstring:
168 case PERL_MAGIC_utf8:
169 case PERL_MAGIC_substr:
170 case PERL_MAGIC_defelem:
171 case PERL_MAGIC_arylen:
173 case PERL_MAGIC_backref:
174 case PERL_MAGIC_arylen_p:
175 case PERL_MAGIC_rhash:
176 case PERL_MAGIC_symtab:
186 Do magic after a value is retrieved from the SV. See C<sv_magic>.
192 Perl_mg_get(pTHX_ SV *sv)
195 const I32 mgs_ix = SSNEW(sizeof(MGS));
196 const bool was_temp = (bool)SvTEMP(sv);
198 MAGIC *newmg, *head, *cur, *mg;
199 /* guard against sv having being freed midway by holding a private
202 PERL_ARGS_ASSERT_MG_GET;
204 /* sv_2mortal has this side effect of turning on the TEMP flag, which can
205 cause the SV's buffer to get stolen (and maybe other stuff).
208 sv_2mortal(SvREFCNT_inc_simple_NN(sv));
213 save_magic(mgs_ix, sv);
215 /* We must call svt_get(sv, mg) for each valid entry in the linked
216 list of magic. svt_get() may delete the current entry, add new
217 magic to the head of the list, or upgrade the SV. AMS 20010810 */
219 newmg = cur = head = mg = SvMAGIC(sv);
221 const MGVTBL * const vtbl = mg->mg_virtual;
222 MAGIC * const nextmg = mg->mg_moremagic; /* it may delete itself */
224 if (!(mg->mg_flags & MGf_GSKIP) && vtbl && vtbl->svt_get) {
225 CALL_FPTR(vtbl->svt_get)(aTHX_ sv, mg);
227 /* guard against magic having been deleted - eg FETCH calling
230 (SSPTR(mgs_ix, MGS *))->mgs_magical = 0; /* recalculate flags */
234 /* recalculate flags if this entry was deleted. */
235 if (mg->mg_flags & MGf_GSKIP)
236 (SSPTR(mgs_ix, MGS *))->mgs_magical = 0;
242 /* Have we finished with the new entries we saw? Start again
243 where we left off (unless there are more new entries). */
251 /* Were any new entries added? */
252 if (!have_new && (newmg = SvMAGIC(sv)) != head) {
256 (SSPTR(mgs_ix, MGS *))->mgs_magical = 0; /* recalculate flags */
260 restore_magic(INT2PTR(void *, (IV)mgs_ix));
262 if (SvREFCNT(sv) == 1) {
263 /* We hold the last reference to this SV, which implies that the
264 SV was deleted as a side effect of the routines we called. */
273 Do magic after a value is assigned to the SV. See C<sv_magic>.
279 Perl_mg_set(pTHX_ SV *sv)
282 const I32 mgs_ix = SSNEW(sizeof(MGS));
286 PERL_ARGS_ASSERT_MG_SET;
288 save_magic(mgs_ix, sv);
290 for (mg = SvMAGIC(sv); mg; mg = nextmg) {
291 const MGVTBL* vtbl = mg->mg_virtual;
292 nextmg = mg->mg_moremagic; /* it may delete itself */
293 if (mg->mg_flags & MGf_GSKIP) {
294 mg->mg_flags &= ~MGf_GSKIP; /* setting requires another read */
295 (SSPTR(mgs_ix, MGS*))->mgs_magical = 0;
297 if (PL_localizing == 2 && !S_is_container_magic(mg))
299 if (vtbl && vtbl->svt_set)
300 CALL_FPTR(vtbl->svt_set)(aTHX_ sv, mg);
303 restore_magic(INT2PTR(void*, (IV)mgs_ix));
308 =for apidoc mg_length
310 Report on the SV's length. See C<sv_magic>.
316 Perl_mg_length(pTHX_ SV *sv)
322 PERL_ARGS_ASSERT_MG_LENGTH;
324 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
325 const MGVTBL * const vtbl = mg->mg_virtual;
326 if (vtbl && vtbl->svt_len) {
327 const I32 mgs_ix = SSNEW(sizeof(MGS));
328 save_magic(mgs_ix, sv);
329 /* omit MGf_GSKIP -- not changed here */
330 len = CALL_FPTR(vtbl->svt_len)(aTHX_ sv, mg);
331 restore_magic(INT2PTR(void*, (IV)mgs_ix));
337 /* You can't know whether it's UTF-8 until you get the string again...
339 const U8 *s = (U8*)SvPV_const(sv, len);
342 len = utf8_length(s, s + len);
349 Perl_mg_size(pTHX_ SV *sv)
353 PERL_ARGS_ASSERT_MG_SIZE;
355 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
356 const MGVTBL* const vtbl = mg->mg_virtual;
357 if (vtbl && vtbl->svt_len) {
358 const I32 mgs_ix = SSNEW(sizeof(MGS));
360 save_magic(mgs_ix, sv);
361 /* omit MGf_GSKIP -- not changed here */
362 len = CALL_FPTR(vtbl->svt_len)(aTHX_ sv, mg);
363 restore_magic(INT2PTR(void*, (IV)mgs_ix));
370 return AvFILLp((const AV *) sv); /* Fallback to non-tied array */
374 Perl_croak(aTHX_ "Size magic not implemented");
383 Clear something magical that the SV represents. See C<sv_magic>.
389 Perl_mg_clear(pTHX_ SV *sv)
391 const I32 mgs_ix = SSNEW(sizeof(MGS));
395 PERL_ARGS_ASSERT_MG_CLEAR;
397 save_magic(mgs_ix, sv);
399 for (mg = SvMAGIC(sv); mg; mg = nextmg) {
400 const MGVTBL* const vtbl = mg->mg_virtual;
401 /* omit GSKIP -- never set here */
403 nextmg = mg->mg_moremagic; /* it may delete itself */
405 if (vtbl && vtbl->svt_clear)
406 CALL_FPTR(vtbl->svt_clear)(aTHX_ sv, mg);
409 restore_magic(INT2PTR(void*, (IV)mgs_ix));
416 Finds the magic pointer for type matching the SV. See C<sv_magic>.
422 Perl_mg_find(pTHX_ const SV *sv, int type)
427 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
428 if (mg->mg_type == type)
438 Copies the magic from one SV to another. See C<sv_magic>.
444 Perl_mg_copy(pTHX_ SV *sv, SV *nsv, const char *key, I32 klen)
449 PERL_ARGS_ASSERT_MG_COPY;
451 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
452 const MGVTBL* const vtbl = mg->mg_virtual;
453 if ((mg->mg_flags & MGf_COPY) && vtbl->svt_copy){
454 count += CALL_FPTR(vtbl->svt_copy)(aTHX_ sv, mg, nsv, key, klen);
457 const char type = mg->mg_type;
458 if (isUPPER(type) && type != PERL_MAGIC_uvar) {
460 (type == PERL_MAGIC_tied)
462 : (type == PERL_MAGIC_regdata && mg->mg_obj)
465 toLOWER(type), key, klen);
474 =for apidoc mg_localize
476 Copy some of the magic from an existing SV to new localized version of that
477 SV. Container magic (eg %ENV, $1, tie) gets copied, value magic doesn't (eg
480 If setmagic is false then no set magic will be called on the new (empty) SV.
481 This typically means that assignment will soon follow (e.g. 'local $x = $y'),
482 and that will handle the magic.
488 Perl_mg_localize(pTHX_ SV *sv, SV *nsv, bool setmagic)
493 PERL_ARGS_ASSERT_MG_LOCALIZE;
495 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
496 const MGVTBL* const vtbl = mg->mg_virtual;
497 if (!S_is_container_magic(mg))
500 if ((mg->mg_flags & MGf_LOCAL) && vtbl->svt_local)
501 (void)CALL_FPTR(vtbl->svt_local)(aTHX_ nsv, mg);
503 sv_magicext(nsv, mg->mg_obj, mg->mg_type, vtbl,
504 mg->mg_ptr, mg->mg_len);
506 /* container types should remain read-only across localization */
507 SvFLAGS(nsv) |= SvREADONLY(sv);
510 if (SvTYPE(nsv) >= SVt_PVMG && SvMAGIC(nsv)) {
511 SvFLAGS(nsv) |= SvMAGICAL(sv);
523 Free any magic storage used by the SV. See C<sv_magic>.
529 Perl_mg_free(pTHX_ SV *sv)
534 PERL_ARGS_ASSERT_MG_FREE;
536 for (mg = SvMAGIC(sv); mg; mg = moremagic) {
537 const MGVTBL* const vtbl = mg->mg_virtual;
538 moremagic = mg->mg_moremagic;
539 if (vtbl && vtbl->svt_free)
540 CALL_FPTR(vtbl->svt_free)(aTHX_ sv, mg);
541 if (mg->mg_ptr && mg->mg_type != PERL_MAGIC_regex_global) {
542 if (mg->mg_len > 0 || mg->mg_type == PERL_MAGIC_utf8)
543 Safefree(mg->mg_ptr);
544 else if (mg->mg_len == HEf_SVKEY)
545 SvREFCNT_dec(MUTABLE_SV(mg->mg_ptr));
547 if (mg->mg_flags & MGf_REFCOUNTED)
548 SvREFCNT_dec(mg->mg_obj);
550 SvMAGIC_set(sv, moremagic);
552 SvMAGIC_set(sv, NULL);
560 Perl_magic_regdata_cnt(pTHX_ SV *sv, MAGIC *mg)
565 PERL_ARGS_ASSERT_MAGIC_REGDATA_CNT;
568 register const REGEXP * const rx = PM_GETRE(PL_curpm);
570 if (mg->mg_obj) { /* @+ */
571 /* return the number possible */
572 return RX_NPARENS(rx);
574 I32 paren = RX_LASTPAREN(rx);
576 /* return the last filled */
578 && (RX_OFFS(rx)[paren].start == -1
579 || RX_OFFS(rx)[paren].end == -1) )
590 Perl_magic_regdatum_get(pTHX_ SV *sv, MAGIC *mg)
594 PERL_ARGS_ASSERT_MAGIC_REGDATUM_GET;
597 register const REGEXP * const rx = PM_GETRE(PL_curpm);
599 register const I32 paren = mg->mg_len;
604 if (paren <= (I32)RX_NPARENS(rx) &&
605 (s = RX_OFFS(rx)[paren].start) != -1 &&
606 (t = RX_OFFS(rx)[paren].end) != -1)
609 if (mg->mg_obj) /* @+ */
614 if (i > 0 && RX_MATCH_UTF8(rx)) {
615 const char * const b = RX_SUBBEG(rx);
617 i = utf8_length((U8*)b, (U8*)(b+i));
628 Perl_magic_regdatum_set(pTHX_ SV *sv, MAGIC *mg)
630 PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET;
633 Perl_croak(aTHX_ "%s", PL_no_modify);
634 NORETURN_FUNCTION_END;
638 Perl_magic_len(pTHX_ SV *sv, MAGIC *mg)
643 register const REGEXP * rx;
644 const char * const remaining = mg->mg_ptr + 1;
646 PERL_ARGS_ASSERT_MAGIC_LEN;
648 switch (*mg->mg_ptr) {
650 if (*remaining == '\0') { /* ^P */
652 } else if (strEQ(remaining, "REMATCH")) { /* $^PREMATCH */
654 } else if (strEQ(remaining, "OSTMATCH")) { /* $^POSTMATCH */
658 case '\015': /* $^MATCH */
659 if (strEQ(remaining, "ATCH")) {
666 paren = RX_BUFF_IDX_PREMATCH;
670 paren = RX_BUFF_IDX_POSTMATCH;
674 paren = RX_BUFF_IDX_FULLMATCH;
676 case '1': case '2': case '3': case '4':
677 case '5': case '6': case '7': case '8': case '9':
678 paren = atoi(mg->mg_ptr);
680 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
682 i = CALLREG_NUMBUF_LENGTH((REGEXP * const)rx, sv, paren);
685 Perl_croak(aTHX_ "panic: magic_len: %"IVdf, (IV)i);
688 if (ckWARN(WARN_UNINITIALIZED))
693 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
694 paren = RX_LASTPAREN(rx);
699 case '\016': /* ^N */
700 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
701 paren = RX_LASTCLOSEPAREN(rx);
708 if (!SvPOK(sv) && SvNIOK(sv)) {
716 #define SvRTRIM(sv) STMT_START { \
718 STRLEN len = SvCUR(sv); \
719 char * const p = SvPVX(sv); \
720 while (len > 0 && isSPACE(p[len-1])) \
722 SvCUR_set(sv, len); \
728 Perl_emulate_cop_io(pTHX_ const COP *const c, SV *const sv)
730 PERL_ARGS_ASSERT_EMULATE_COP_IO;
732 if (!(CopHINTS_get(c) & (HINT_LEXICAL_IO_IN|HINT_LEXICAL_IO_OUT)))
733 sv_setsv(sv, &PL_sv_undef);
737 if ((CopHINTS_get(c) & HINT_LEXICAL_IO_IN)) {
738 SV *const value = Perl_refcounted_he_fetch(aTHX_
740 0, "open<", 5, 0, 0);
745 if ((CopHINTS_get(c) & HINT_LEXICAL_IO_OUT)) {
746 SV *const value = Perl_refcounted_he_fetch(aTHX_
748 0, "open>", 5, 0, 0);
756 Perl_magic_get(pTHX_ SV *sv, MAGIC *mg)
760 register char *s = NULL;
762 const char * const remaining = mg->mg_ptr + 1;
763 const char nextchar = *remaining;
765 PERL_ARGS_ASSERT_MAGIC_GET;
767 switch (*mg->mg_ptr) {
768 case '\001': /* ^A */
769 sv_setsv(sv, PL_bodytarget);
771 case '\003': /* ^C, ^CHILD_ERROR_NATIVE */
772 if (nextchar == '\0') {
773 sv_setiv(sv, (IV)PL_minus_c);
775 else if (strEQ(remaining, "HILD_ERROR_NATIVE")) {
776 sv_setiv(sv, (IV)STATUS_NATIVE);
780 case '\004': /* ^D */
781 sv_setiv(sv, (IV)(PL_debug & DEBUG_MASK));
783 case '\005': /* ^E */
784 if (nextchar == '\0') {
787 # include <descrip.h>
788 # include <starlet.h>
790 $DESCRIPTOR(msgdsc,msg);
791 sv_setnv(sv,(NV) vaxc$errno);
792 if (sys$getmsg(vaxc$errno,&msgdsc.dsc$w_length,&msgdsc,0,0) & 1)
793 sv_setpvn(sv,msgdsc.dsc$a_pointer,msgdsc.dsc$w_length);
798 if (!(_emx_env & 0x200)) { /* Under DOS */
799 sv_setnv(sv, (NV)errno);
800 sv_setpv(sv, errno ? Strerror(errno) : "");
802 if (errno != errno_isOS2) {
803 const int tmp = _syserrno();
804 if (tmp) /* 2nd call to _syserrno() makes it 0 */
807 sv_setnv(sv, (NV)Perl_rc);
808 sv_setpv(sv, os2error(Perl_rc));
812 const DWORD dwErr = GetLastError();
813 sv_setnv(sv, (NV)dwErr);
815 PerlProc_GetOSError(sv, dwErr);
824 sv_setnv(sv, (NV)errno);
825 sv_setpv(sv, errno ? Strerror(errno) : "");
830 SvNOK_on(sv); /* what a wonderful hack! */
832 else if (strEQ(remaining, "NCODING"))
833 sv_setsv(sv, PL_encoding);
835 case '\006': /* ^F */
836 sv_setiv(sv, (IV)PL_maxsysfd);
838 case '\010': /* ^H */
839 sv_setiv(sv, (IV)PL_hints);
841 case '\011': /* ^I */ /* NOT \t in EBCDIC */
842 sv_setpv(sv, PL_inplace); /* Will undefine sv if PL_inplace is NULL */
844 case '\017': /* ^O & ^OPEN */
845 if (nextchar == '\0') {
846 sv_setpv(sv, PL_osname);
849 else if (strEQ(remaining, "PEN")) {
850 Perl_emulate_cop_io(aTHX_ &PL_compiling, sv);
854 if (nextchar == '\0') { /* ^P */
855 sv_setiv(sv, (IV)PL_perldb);
856 } else if (strEQ(remaining, "REMATCH")) { /* $^PREMATCH */
857 goto do_prematch_fetch;
858 } else if (strEQ(remaining, "OSTMATCH")) { /* $^POSTMATCH */
859 goto do_postmatch_fetch;
862 case '\023': /* ^S */
863 if (nextchar == '\0') {
864 if (PL_parser && PL_parser->lex_state != LEX_NOTPARSING)
867 sv_setiv(sv, PL_in_eval & ~(EVAL_INREQUIRE));
872 case '\024': /* ^T */
873 if (nextchar == '\0') {
875 sv_setnv(sv, PL_basetime);
877 sv_setiv(sv, (IV)PL_basetime);
880 else if (strEQ(remaining, "AINT"))
881 sv_setiv(sv, PL_tainting
882 ? (PL_taint_warn || PL_unsafe ? -1 : 1)
885 case '\025': /* $^UNICODE, $^UTF8LOCALE, $^UTF8CACHE */
886 if (strEQ(remaining, "NICODE"))
887 sv_setuv(sv, (UV) PL_unicode);
888 else if (strEQ(remaining, "TF8LOCALE"))
889 sv_setuv(sv, (UV) PL_utf8locale);
890 else if (strEQ(remaining, "TF8CACHE"))
891 sv_setiv(sv, (IV) PL_utf8cache);
893 case '\027': /* ^W & $^WARNING_BITS */
894 if (nextchar == '\0')
895 sv_setiv(sv, (IV)((PL_dowarn & G_WARN_ON) ? TRUE : FALSE));
896 else if (strEQ(remaining, "ARNING_BITS")) {
897 if (PL_compiling.cop_warnings == pWARN_NONE) {
898 sv_setpvn(sv, WARN_NONEstring, WARNsize) ;
900 else if (PL_compiling.cop_warnings == pWARN_STD) {
903 (PL_dowarn & G_WARN_ON) ? WARN_ALLstring : WARN_NONEstring,
907 else if (PL_compiling.cop_warnings == pWARN_ALL) {
908 /* Get the bit mask for $warnings::Bits{all}, because
909 * it could have been extended by warnings::register */
910 HV * const bits=get_hv("warnings::Bits", 0);
912 SV ** const bits_all = hv_fetchs(bits, "all", FALSE);
914 sv_setsv(sv, *bits_all);
917 sv_setpvn(sv, WARN_ALLstring, WARNsize) ;
921 sv_setpvn(sv, (char *) (PL_compiling.cop_warnings + 1),
922 *PL_compiling.cop_warnings);
927 case '\015': /* $^MATCH */
928 if (strEQ(remaining, "ATCH")) {
929 case '1': case '2': case '3': case '4':
930 case '5': case '6': case '7': case '8': case '9': case '&':
931 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
933 * Pre-threads, this was paren = atoi(GvENAME((const GV *)mg->mg_obj));
934 * XXX Does the new way break anything?
936 paren = atoi(mg->mg_ptr); /* $& is in [0] */
937 CALLREG_NUMBUF_FETCH(rx,paren,sv);
940 sv_setsv(sv,&PL_sv_undef);
944 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
945 if (RX_LASTPAREN(rx)) {
946 CALLREG_NUMBUF_FETCH(rx,RX_LASTPAREN(rx),sv);
950 sv_setsv(sv,&PL_sv_undef);
952 case '\016': /* ^N */
953 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
954 if (RX_LASTCLOSEPAREN(rx)) {
955 CALLREG_NUMBUF_FETCH(rx,RX_LASTCLOSEPAREN(rx),sv);
960 sv_setsv(sv,&PL_sv_undef);
964 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
965 CALLREG_NUMBUF_FETCH(rx,-2,sv);
968 sv_setsv(sv,&PL_sv_undef);
972 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
973 CALLREG_NUMBUF_FETCH(rx,-1,sv);
976 sv_setsv(sv,&PL_sv_undef);
979 if (GvIO(PL_last_in_gv)) {
980 sv_setiv(sv, (IV)IoLINES(GvIOp(PL_last_in_gv)));
985 sv_setiv(sv, (IV)STATUS_CURRENT);
986 #ifdef COMPLEX_STATUS
987 SvUPGRADE(sv, SVt_PVLV);
988 LvTARGOFF(sv) = PL_statusvalue;
989 LvTARGLEN(sv) = PL_statusvalue_vms;
994 if (GvIOp(PL_defoutgv))
995 s = IoTOP_NAME(GvIOp(PL_defoutgv));
999 sv_setpv(sv,GvENAME(PL_defoutgv));
1000 sv_catpvs(sv,"_TOP");
1004 if (GvIOp(PL_defoutgv))
1005 s = IoFMT_NAME(GvIOp(PL_defoutgv));
1007 s = GvENAME(PL_defoutgv);
1011 if (GvIOp(PL_defoutgv))
1012 sv_setiv(sv, (IV)IoPAGE_LEN(GvIOp(PL_defoutgv)));
1015 if (GvIOp(PL_defoutgv))
1016 sv_setiv(sv, (IV)IoLINES_LEFT(GvIOp(PL_defoutgv)));
1019 if (GvIOp(PL_defoutgv))
1020 sv_setiv(sv, (IV)IoPAGE(GvIOp(PL_defoutgv)));
1027 sv_setiv(sv, (IV)CopARYBASE_get(PL_curcop));
1030 if (GvIOp(PL_defoutgv))
1031 sv_setiv(sv, (IV)(IoFLAGS(GvIOp(PL_defoutgv)) & IOf_FLUSH) != 0 );
1035 sv_copypv(sv, PL_ors_sv);
1041 sv_setnv(sv, (NV)((errno == EVMSERR) ? vaxc$errno : errno));
1043 sv_setnv(sv, (NV)errno);
1046 if (errno == errno_isOS2 || errno == errno_isOS2_set)
1047 sv_setpv(sv, os2error(Perl_rc));
1050 sv_setpv(sv, errno ? Strerror(errno) : "");
1052 SvPOK_on(sv); /* may have got removed during taint processing */
1057 SvNOK_on(sv); /* what a wonderful hack! */
1060 sv_setiv(sv, (IV)PL_uid);
1063 sv_setiv(sv, (IV)PL_euid);
1066 sv_setiv(sv, (IV)PL_gid);
1069 sv_setiv(sv, (IV)PL_egid);
1071 #ifdef HAS_GETGROUPS
1073 Groups_t *gary = NULL;
1074 I32 i, num_groups = getgroups(0, gary);
1075 Newx(gary, num_groups, Groups_t);
1076 num_groups = getgroups(num_groups, gary);
1077 for (i = 0; i < num_groups; i++)
1078 Perl_sv_catpvf(aTHX_ sv, " %"IVdf, (IV)gary[i]);
1081 (void)SvIOK_on(sv); /* what a wonderful hack! */
1091 Perl_magic_getuvar(pTHX_ SV *sv, MAGIC *mg)
1093 struct ufuncs * const uf = (struct ufuncs *)mg->mg_ptr;
1095 PERL_ARGS_ASSERT_MAGIC_GETUVAR;
1097 if (uf && uf->uf_val)
1098 (*uf->uf_val)(aTHX_ uf->uf_index, sv);
1103 Perl_magic_setenv(pTHX_ SV *sv, MAGIC *mg)
1106 STRLEN len = 0, klen;
1107 const char *s = SvOK(sv) ? SvPV_const(sv,len) : "";
1108 const char * const ptr = MgPV_const(mg,klen);
1111 PERL_ARGS_ASSERT_MAGIC_SETENV;
1113 #ifdef DYNAMIC_ENV_FETCH
1114 /* We just undefd an environment var. Is a replacement */
1115 /* waiting in the wings? */
1117 SV ** const valp = hv_fetch(GvHVn(PL_envgv), ptr, klen, FALSE);
1119 s = SvOK(*valp) ? SvPV_const(*valp, len) : "";
1123 #if !defined(OS2) && !defined(AMIGAOS) && !defined(WIN32) && !defined(MSDOS)
1124 /* And you'll never guess what the dog had */
1125 /* in its mouth... */
1127 MgTAINTEDDIR_off(mg);
1129 if (s && klen == 8 && strEQ(ptr, "DCL$PATH")) {
1130 char pathbuf[256], eltbuf[256], *cp, *elt;
1134 my_strlcpy(eltbuf, s, sizeof(eltbuf));
1136 do { /* DCL$PATH may be a search list */
1137 while (1) { /* as may dev portion of any element */
1138 if ( ((cp = strchr(elt,'[')) || (cp = strchr(elt,'<'))) ) {
1139 if ( *(cp+1) == '.' || *(cp+1) == '-' ||
1140 cando_by_name(S_IWUSR,0,elt) ) {
1141 MgTAINTEDDIR_on(mg);
1145 if ((cp = strchr(elt, ':')) != NULL)
1147 if (my_trnlnm(elt, eltbuf, j++))
1153 } while (my_trnlnm(s, pathbuf, i++) && (elt = pathbuf));
1156 if (s && klen == 4 && strEQ(ptr,"PATH")) {
1157 const char * const strend = s + len;
1159 while (s < strend) {
1163 #ifdef VMS /* Hmm. How do we get $Config{path_sep} from C? */
1164 const char path_sep = '|';
1166 const char path_sep = ':';
1168 s = delimcpy(tmpbuf, tmpbuf + sizeof tmpbuf,
1169 s, strend, path_sep, &i);
1171 if (i >= (I32)sizeof tmpbuf /* too long -- assume the worst */
1173 || !strchr(tmpbuf, ':') /* no colon thus no device name -- assume relative path */
1175 || *tmpbuf != '/' /* no starting slash -- assume relative path */
1177 || (PerlLIO_stat(tmpbuf, &st) == 0 && (st.st_mode & 2)) ) {
1178 MgTAINTEDDIR_on(mg);
1184 #endif /* neither OS2 nor AMIGAOS nor WIN32 nor MSDOS */
1190 Perl_magic_clearenv(pTHX_ SV *sv, MAGIC *mg)
1192 PERL_ARGS_ASSERT_MAGIC_CLEARENV;
1193 PERL_UNUSED_ARG(sv);
1194 my_setenv(MgPV_nolen_const(mg),NULL);
1199 Perl_magic_set_all_env(pTHX_ SV *sv, MAGIC *mg)
1202 PERL_ARGS_ASSERT_MAGIC_SET_ALL_ENV;
1203 PERL_UNUSED_ARG(mg);
1205 Perl_die(aTHX_ "Can't make list assignment to %%ENV on this system");
1207 if (PL_localizing) {
1210 hv_iterinit(MUTABLE_HV(sv));
1211 while ((entry = hv_iternext(MUTABLE_HV(sv)))) {
1213 my_setenv(hv_iterkey(entry, &keylen),
1214 SvPV_nolen_const(hv_iterval(MUTABLE_HV(sv), entry)));
1222 Perl_magic_clear_all_env(pTHX_ SV *sv, MAGIC *mg)
1225 PERL_ARGS_ASSERT_MAGIC_CLEAR_ALL_ENV;
1226 PERL_UNUSED_ARG(sv);
1227 PERL_UNUSED_ARG(mg);
1229 Perl_die(aTHX_ "Can't make list assignment to %%ENV on this system");
1237 #ifdef HAS_SIGPROCMASK
1239 restore_sigmask(pTHX_ SV *save_sv)
1241 const sigset_t * const ossetp = (const sigset_t *) SvPV_nolen_const( save_sv );
1242 (void)sigprocmask(SIG_SETMASK, ossetp, NULL);
1246 Perl_magic_getsig(pTHX_ SV *sv, MAGIC *mg)
1249 /* Are we fetching a signal entry? */
1250 int i = (I16)mg->mg_private;
1252 PERL_ARGS_ASSERT_MAGIC_GETSIG;
1255 mg->mg_private = i = whichsig(MgPV_nolen_const(mg));
1260 sv_setsv(sv,PL_psig_ptr[i]);
1262 Sighandler_t sigstate = rsignal_state(i);
1263 #ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1264 if (PL_sig_handlers_initted && PL_sig_ignoring[i])
1267 #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1268 if (PL_sig_handlers_initted && PL_sig_defaulting[i])
1271 /* cache state so we don't fetch it again */
1272 if(sigstate == (Sighandler_t) SIG_IGN)
1273 sv_setpvs(sv,"IGNORE");
1275 sv_setsv(sv,&PL_sv_undef);
1276 PL_psig_ptr[i] = SvREFCNT_inc_simple_NN(sv);
1283 Perl_magic_clearsig(pTHX_ SV *sv, MAGIC *mg)
1285 PERL_ARGS_ASSERT_MAGIC_CLEARSIG;
1286 PERL_UNUSED_ARG(sv);
1288 magic_setsig(NULL, mg);
1289 return sv_unmagic(sv, mg->mg_type);
1293 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
1294 Perl_csighandler(int sig, siginfo_t *sip PERL_UNUSED_DECL, void *uap PERL_UNUSED_DECL)
1296 Perl_csighandler(int sig)
1299 #ifdef PERL_GET_SIG_CONTEXT
1300 dTHXa(PERL_GET_SIG_CONTEXT);
1304 #ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1305 (void) rsignal(sig, PL_csighandlerp);
1306 if (PL_sig_ignoring[sig]) return;
1308 #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1309 if (PL_sig_defaulting[sig])
1310 #ifdef KILL_BY_SIGPRC
1311 exit((Perl_sig_to_vmscondition(sig)&STS$M_COND_ID)|STS$K_SEVERE|STS$M_INHIB_MSG);
1326 (PL_signals & PERL_SIGNALS_UNSAFE_FLAG))
1327 /* Call the perl level handler now--
1328 * with risk we may be in malloc() or being destructed etc. */
1329 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
1330 (*PL_sighandlerp)(sig, NULL, NULL);
1332 (*PL_sighandlerp)(sig);
1335 if (!PL_psig_pend) return;
1336 /* Set a flag to say this signal is pending, that is awaiting delivery after
1337 * the current Perl opcode completes */
1338 PL_psig_pend[sig]++;
1340 #ifndef SIG_PENDING_DIE_COUNT
1341 # define SIG_PENDING_DIE_COUNT 120
1343 /* Add one to say _a_ signal is pending */
1344 if (++PL_sig_pending >= SIG_PENDING_DIE_COUNT)
1345 Perl_croak(aTHX_ "Maximal count of pending signals (%lu) exceeded",
1346 (unsigned long)SIG_PENDING_DIE_COUNT);
1350 #if defined(FAKE_PERSISTENT_SIGNAL_HANDLERS) || defined(FAKE_DEFAULT_SIGNAL_HANDLERS)
1352 Perl_csighandler_init(void)
1355 if (PL_sig_handlers_initted) return;
1357 for (sig = 1; sig < SIG_SIZE; sig++) {
1358 #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1360 PL_sig_defaulting[sig] = 1;
1361 (void) rsignal(sig, PL_csighandlerp);
1363 #ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1364 PL_sig_ignoring[sig] = 0;
1367 PL_sig_handlers_initted = 1;
1372 Perl_despatch_signals(pTHX)
1377 for (sig = 1; sig < SIG_SIZE; sig++) {
1378 if (PL_psig_pend[sig]) {
1379 PERL_BLOCKSIG_ADD(set, sig);
1380 PL_psig_pend[sig] = 0;
1381 PERL_BLOCKSIG_BLOCK(set);
1382 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
1383 (*PL_sighandlerp)(sig, NULL, NULL);
1385 (*PL_sighandlerp)(sig);
1387 PERL_BLOCKSIG_UNBLOCK(set);
1392 /* sv of NULL signifies that we're acting as magic_clearsig. */
1394 Perl_magic_setsig(pTHX_ SV *sv, MAGIC *mg)
1399 /* Need to be careful with SvREFCNT_dec(), because that can have side
1400 * effects (due to closures). We must make sure that the new disposition
1401 * is in place before it is called.
1405 #ifdef HAS_SIGPROCMASK
1409 register const char *s = MgPV_const(mg,len);
1411 PERL_ARGS_ASSERT_MAGIC_SETSIG;
1414 if (strEQ(s,"__DIE__"))
1416 else if (strEQ(s,"__WARN__")
1417 && (sv ? 1 : PL_warnhook != PERL_WARNHOOK_FATAL)) {
1418 /* Merge the existing behaviours, which are as follows:
1419 magic_setsig, we always set svp to &PL_warnhook
1420 (hence we always change the warnings handler)
1421 For magic_clearsig, we don't change the warnings handler if it's
1422 set to the &PL_warnhook. */
1425 Perl_croak(aTHX_ "No such hook: %s", s);
1428 if (*svp != PERL_WARNHOOK_FATAL)
1434 i = (I16)mg->mg_private;
1436 i = whichsig(s); /* ...no, a brick */
1437 mg->mg_private = (U16)i;
1441 Perl_ck_warner(aTHX_ packWARN(WARN_SIGNAL), "No such signal: SIG%s", s);
1444 #ifdef HAS_SIGPROCMASK
1445 /* Avoid having the signal arrive at a bad time, if possible. */
1448 sigprocmask(SIG_BLOCK, &set, &save);
1450 save_sv = newSVpvn((char *)(&save), sizeof(sigset_t));
1451 SAVEFREESV(save_sv);
1452 SAVEDESTRUCTOR_X(restore_sigmask, save_sv);
1455 #if defined(FAKE_PERSISTENT_SIGNAL_HANDLERS) || defined(FAKE_DEFAULT_SIGNAL_HANDLERS)
1456 if (!PL_sig_handlers_initted) Perl_csighandler_init();
1458 #ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1459 PL_sig_ignoring[i] = 0;
1461 #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1462 PL_sig_defaulting[i] = 0;
1464 to_dec = PL_psig_ptr[i];
1466 PL_psig_ptr[i] = SvREFCNT_inc_simple_NN(sv);
1467 SvTEMP_off(sv); /* Make sure it doesn't go away on us */
1469 /* Signals don't change name during the program's execution, so once
1470 they're cached in the appropriate slot of PL_psig_name, they can
1473 Ideally we'd find some way of making SVs at (C) compile time, or
1474 at least, doing most of the work. */
1475 if (!PL_psig_name[i]) {
1476 PL_psig_name[i] = newSVpvn(s, len);
1477 SvREADONLY_on(PL_psig_name[i]);
1480 SvREFCNT_dec(PL_psig_name[i]);
1481 PL_psig_name[i] = NULL;
1482 PL_psig_ptr[i] = NULL;
1485 if (sv && (isGV_with_GP(sv) || SvROK(sv))) {
1487 (void)rsignal(i, PL_csighandlerp);
1490 *svp = SvREFCNT_inc_simple_NN(sv);
1492 if (sv && SvOK(sv)) {
1493 s = SvPV_force(sv, len);
1497 if (sv && strEQ(s,"IGNORE")) {
1499 #ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1500 PL_sig_ignoring[i] = 1;
1501 (void)rsignal(i, PL_csighandlerp);
1503 (void)rsignal(i, (Sighandler_t) SIG_IGN);
1507 else if (!sv || strEQ(s,"DEFAULT") || !len) {
1509 #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1510 PL_sig_defaulting[i] = 1;
1511 (void)rsignal(i, PL_csighandlerp);
1513 (void)rsignal(i, (Sighandler_t) SIG_DFL);
1519 * We should warn if HINT_STRICT_REFS, but without
1520 * access to a known hint bit in a known OP, we can't
1521 * tell whether HINT_STRICT_REFS is in force or not.
1523 if (!strchr(s,':') && !strchr(s,'\''))
1524 Perl_sv_insert_flags(aTHX_ sv, 0, 0, STR_WITH_LEN("main::"),
1527 (void)rsignal(i, PL_csighandlerp);
1529 *svp = SvREFCNT_inc_simple_NN(sv);
1533 #ifdef HAS_SIGPROCMASK
1537 SvREFCNT_dec(to_dec);
1540 #endif /* !PERL_MICRO */
1543 Perl_magic_setisa(pTHX_ SV *sv, MAGIC *mg)
1546 PERL_ARGS_ASSERT_MAGIC_SETISA;
1547 PERL_UNUSED_ARG(sv);
1549 /* Skip _isaelem because _isa will handle it shortly */
1550 if (PL_delaymagic & DM_ARRAY && mg->mg_type == PERL_MAGIC_isaelem)
1553 return magic_clearisa(NULL, mg);
1556 /* sv of NULL signifies that we're acting as magic_setisa. */
1558 Perl_magic_clearisa(pTHX_ SV *sv, MAGIC *mg)
1563 PERL_ARGS_ASSERT_MAGIC_CLEARISA;
1565 /* Bail out if destruction is going on */
1566 if(PL_dirty) return 0;
1569 av_clear(MUTABLE_AV(sv));
1571 /* XXX Once it's possible, we need to
1572 detect that our @ISA is aliased in
1573 other stashes, and act on the stashes
1574 of all of the aliases */
1576 /* The first case occurs via setisa,
1577 the second via setisa_elem, which
1578 calls this same magic */
1580 SvTYPE(mg->mg_obj) == SVt_PVGV
1581 ? (const GV *)mg->mg_obj
1582 : (const GV *)mg_find(mg->mg_obj, PERL_MAGIC_isa)->mg_obj
1586 mro_isa_changed_in(stash);
1592 Perl_magic_setamagic(pTHX_ SV *sv, MAGIC *mg)
1595 PERL_ARGS_ASSERT_MAGIC_SETAMAGIC;
1596 PERL_UNUSED_ARG(sv);
1597 PERL_UNUSED_ARG(mg);
1598 PL_amagic_generation++;
1604 Perl_magic_getnkeys(pTHX_ SV *sv, MAGIC *mg)
1606 HV * const hv = MUTABLE_HV(LvTARG(sv));
1609 PERL_ARGS_ASSERT_MAGIC_GETNKEYS;
1610 PERL_UNUSED_ARG(mg);
1613 (void) hv_iterinit(hv);
1614 if (! SvTIED_mg((const SV *)hv, PERL_MAGIC_tied))
1617 while (hv_iternext(hv))
1622 sv_setiv(sv, (IV)i);
1627 Perl_magic_setnkeys(pTHX_ SV *sv, MAGIC *mg)
1629 PERL_ARGS_ASSERT_MAGIC_SETNKEYS;
1630 PERL_UNUSED_ARG(mg);
1632 hv_ksplit(MUTABLE_HV(LvTARG(sv)), SvIV(sv));
1637 /* caller is responsible for stack switching/cleanup */
1639 S_magic_methcall(pTHX_ SV *sv, const MAGIC *mg, const char *meth, I32 flags, int n, SV *val)
1644 PERL_ARGS_ASSERT_MAGIC_METHCALL;
1648 PUSHs(SvTIED_obj(sv, mg));
1651 if (mg->mg_len >= 0)
1652 mPUSHp(mg->mg_ptr, mg->mg_len);
1653 else if (mg->mg_len == HEf_SVKEY)
1654 PUSHs(MUTABLE_SV(mg->mg_ptr));
1656 else if (mg->mg_type == PERL_MAGIC_tiedelem) {
1665 return call_method(meth, flags);
1669 S_magic_methpack(pTHX_ SV *sv, const MAGIC *mg, const char *meth)
1673 PERL_ARGS_ASSERT_MAGIC_METHPACK;
1677 PUSHSTACKi(PERLSI_MAGIC);
1679 if (magic_methcall(sv, mg, meth, G_SCALAR, 2, NULL)) {
1680 sv_setsv(sv, *PL_stack_sp--);
1690 Perl_magic_getpack(pTHX_ SV *sv, MAGIC *mg)
1692 PERL_ARGS_ASSERT_MAGIC_GETPACK;
1695 mg->mg_flags |= MGf_GSKIP;
1696 magic_methpack(sv,mg,"FETCH");
1701 Perl_magic_setpack(pTHX_ SV *sv, MAGIC *mg)
1707 PERL_ARGS_ASSERT_MAGIC_SETPACK;
1709 /* in the code C<$tied{foo} = $val>, the "thing" that gets passed to
1710 * STORE() is not $val, but rather a PVLV (the sv in this call), whose
1711 * public flags indicate its value based on copying from $val. Doing
1712 * mg_set() on the PVLV temporarily does SvMAGICAL_off(), then calls us.
1713 * So STORE()'s $_[2] arg is a temporarily disarmed PVLV. This goes
1714 * wrong if $val happened to be tainted, as sv hasn't got magic
1715 * enabled, even though taint magic is in the chain. In which case,
1716 * fake up a temporary tainted value (this is easier than temporarily
1717 * re-enabling magic on sv). */
1719 if (PL_tainting && (tmg = mg_find(sv, PERL_MAGIC_taint))
1720 && (tmg->mg_len & 1))
1722 val = sv_mortalcopy(sv);
1729 PUSHSTACKi(PERLSI_MAGIC);
1730 magic_methcall(sv, mg, "STORE", G_SCALAR|G_DISCARD, 3, val);
1737 Perl_magic_clearpack(pTHX_ SV *sv, MAGIC *mg)
1739 PERL_ARGS_ASSERT_MAGIC_CLEARPACK;
1741 return magic_methpack(sv,mg,"DELETE");
1746 Perl_magic_sizepack(pTHX_ SV *sv, MAGIC *mg)
1751 PERL_ARGS_ASSERT_MAGIC_SIZEPACK;
1755 PUSHSTACKi(PERLSI_MAGIC);
1756 if (magic_methcall(sv, mg, "FETCHSIZE", G_SCALAR, 2, NULL)) {
1757 sv = *PL_stack_sp--;
1758 retval = SvIV(sv)-1;
1760 Perl_croak(aTHX_ "FETCHSIZE returned a negative value");
1765 return (U32) retval;
1769 Perl_magic_wipepack(pTHX_ SV *sv, MAGIC *mg)
1773 PERL_ARGS_ASSERT_MAGIC_WIPEPACK;
1776 PUSHSTACKi(PERLSI_MAGIC);
1778 XPUSHs(SvTIED_obj(sv, mg));
1780 call_method("CLEAR", G_SCALAR|G_DISCARD);
1788 Perl_magic_nextpack(pTHX_ SV *sv, MAGIC *mg, SV *key)
1791 const char * const meth = SvOK(key) ? "NEXTKEY" : "FIRSTKEY";
1793 PERL_ARGS_ASSERT_MAGIC_NEXTPACK;
1797 PUSHSTACKi(PERLSI_MAGIC);
1800 PUSHs(SvTIED_obj(sv, mg));
1805 if (call_method(meth, G_SCALAR))
1806 sv_setsv(key, *PL_stack_sp--);
1815 Perl_magic_existspack(pTHX_ SV *sv, const MAGIC *mg)
1817 PERL_ARGS_ASSERT_MAGIC_EXISTSPACK;
1819 return magic_methpack(sv,mg,"EXISTS");
1823 Perl_magic_scalarpack(pTHX_ HV *hv, MAGIC *mg)
1827 SV * const tied = SvTIED_obj(MUTABLE_SV(hv), mg);
1828 HV * const pkg = SvSTASH((const SV *)SvRV(tied));
1830 PERL_ARGS_ASSERT_MAGIC_SCALARPACK;
1832 if (!gv_fetchmethod_autoload(pkg, "SCALAR", FALSE)) {
1834 if (HvEITER_get(hv))
1835 /* we are in an iteration so the hash cannot be empty */
1837 /* no xhv_eiter so now use FIRSTKEY */
1838 key = sv_newmortal();
1839 magic_nextpack(MUTABLE_SV(hv), mg, key);
1840 HvEITER_set(hv, NULL); /* need to reset iterator */
1841 return SvOK(key) ? &PL_sv_yes : &PL_sv_no;
1844 /* there is a SCALAR method that we can call */
1846 PUSHSTACKi(PERLSI_MAGIC);
1852 if (call_method("SCALAR", G_SCALAR))
1853 retval = *PL_stack_sp--;
1855 retval = &PL_sv_undef;
1862 Perl_magic_setdbline(pTHX_ SV *sv, MAGIC *mg)
1865 GV * const gv = PL_DBline;
1866 const I32 i = SvTRUE(sv);
1867 SV ** const svp = av_fetch(GvAV(gv),
1868 atoi(MgPV_nolen_const(mg)), FALSE);
1870 PERL_ARGS_ASSERT_MAGIC_SETDBLINE;
1872 if (svp && SvIOKp(*svp)) {
1873 OP * const o = INT2PTR(OP*,SvIVX(*svp));
1875 /* set or clear breakpoint in the relevant control op */
1877 o->op_flags |= OPf_SPECIAL;
1879 o->op_flags &= ~OPf_SPECIAL;
1886 Perl_magic_getarylen(pTHX_ SV *sv, const MAGIC *mg)
1889 AV * const obj = MUTABLE_AV(mg->mg_obj);
1891 PERL_ARGS_ASSERT_MAGIC_GETARYLEN;
1894 sv_setiv(sv, AvFILL(obj) + CopARYBASE_get(PL_curcop));
1902 Perl_magic_setarylen(pTHX_ SV *sv, MAGIC *mg)
1905 AV * const obj = MUTABLE_AV(mg->mg_obj);
1907 PERL_ARGS_ASSERT_MAGIC_SETARYLEN;
1910 av_fill(obj, SvIV(sv) - CopARYBASE_get(PL_curcop));
1912 Perl_ck_warner(aTHX_ packWARN(WARN_MISC),
1913 "Attempt to set length of freed array");
1919 Perl_magic_freearylen_p(pTHX_ SV *sv, MAGIC *mg)
1923 PERL_ARGS_ASSERT_MAGIC_FREEARYLEN_P;
1924 PERL_UNUSED_ARG(sv);
1926 /* during global destruction, mg_obj may already have been freed */
1927 if (PL_in_clean_all)
1930 mg = mg_find (mg->mg_obj, PERL_MAGIC_arylen);
1933 /* arylen scalar holds a pointer back to the array, but doesn't own a
1934 reference. Hence the we (the array) are about to go away with it
1935 still pointing at us. Clear its pointer, else it would be pointing
1936 at free memory. See the comment in sv_magic about reference loops,
1937 and why it can't own a reference to us. */
1944 Perl_magic_getpos(pTHX_ SV *sv, MAGIC *mg)
1947 SV* const lsv = LvTARG(sv);
1949 PERL_ARGS_ASSERT_MAGIC_GETPOS;
1950 PERL_UNUSED_ARG(mg);
1952 if (SvTYPE(lsv) >= SVt_PVMG && SvMAGIC(lsv)) {
1953 MAGIC * const found = mg_find(lsv, PERL_MAGIC_regex_global);
1954 if (found && found->mg_len >= 0) {
1955 I32 i = found->mg_len;
1957 sv_pos_b2u(lsv, &i);
1958 sv_setiv(sv, i + CopARYBASE_get(PL_curcop));
1967 Perl_magic_setpos(pTHX_ SV *sv, MAGIC *mg)
1970 SV* const lsv = LvTARG(sv);
1976 PERL_ARGS_ASSERT_MAGIC_SETPOS;
1977 PERL_UNUSED_ARG(mg);
1979 if (SvTYPE(lsv) >= SVt_PVMG && SvMAGIC(lsv))
1980 found = mg_find(lsv, PERL_MAGIC_regex_global);
1986 #ifdef PERL_OLD_COPY_ON_WRITE
1988 sv_force_normal_flags(lsv, 0);
1990 found = sv_magicext(lsv, NULL, PERL_MAGIC_regex_global, &PL_vtbl_mglob,
1993 else if (!SvOK(sv)) {
1997 len = SvPOK(lsv) ? SvCUR(lsv) : sv_len(lsv);
1999 pos = SvIV(sv) - CopARYBASE_get(PL_curcop);
2002 ulen = sv_len_utf8(lsv);
2012 else if (pos > (SSize_t)len)
2017 sv_pos_u2b(lsv, &p, 0);
2021 found->mg_len = pos;
2022 found->mg_flags &= ~MGf_MINMATCH;
2028 Perl_magic_getsubstr(pTHX_ SV *sv, MAGIC *mg)
2031 SV * const lsv = LvTARG(sv);
2032 const char * const tmps = SvPV_const(lsv,len);
2033 STRLEN offs = LvTARGOFF(sv);
2034 STRLEN rem = LvTARGLEN(sv);
2036 PERL_ARGS_ASSERT_MAGIC_GETSUBSTR;
2037 PERL_UNUSED_ARG(mg);
2040 offs = sv_pos_u2b_flags(lsv, offs, &rem, SV_CONST_RETURN);
2043 if (rem > len - offs)
2045 sv_setpvn(sv, tmps + offs, rem);
2052 Perl_magic_setsubstr(pTHX_ SV *sv, MAGIC *mg)
2056 const char * const tmps = SvPV_const(sv, len);
2057 SV * const lsv = LvTARG(sv);
2058 STRLEN lvoff = LvTARGOFF(sv);
2059 STRLEN lvlen = LvTARGLEN(sv);
2061 PERL_ARGS_ASSERT_MAGIC_SETSUBSTR;
2062 PERL_UNUSED_ARG(mg);
2065 sv_utf8_upgrade(lsv);
2066 lvoff = sv_pos_u2b_flags(lsv, lvoff, &lvlen, SV_CONST_RETURN);
2067 sv_insert(lsv, lvoff, lvlen, tmps, len);
2068 LvTARGLEN(sv) = sv_len_utf8(sv);
2071 else if (lsv && SvUTF8(lsv)) {
2073 lvoff = sv_pos_u2b_flags(lsv, lvoff, &lvlen, SV_CONST_RETURN);
2074 LvTARGLEN(sv) = len;
2075 utf8 = (char*)bytes_to_utf8((U8*)tmps, &len);
2076 sv_insert(lsv, lvoff, lvlen, utf8, len);
2080 sv_insert(lsv, lvoff, lvlen, tmps, len);
2081 LvTARGLEN(sv) = len;
2088 Perl_magic_gettaint(pTHX_ SV *sv, MAGIC *mg)
2092 PERL_ARGS_ASSERT_MAGIC_GETTAINT;
2093 PERL_UNUSED_ARG(sv);
2095 TAINT_IF((PL_localizing != 1) && (mg->mg_len & 1));
2100 Perl_magic_settaint(pTHX_ SV *sv, MAGIC *mg)
2104 PERL_ARGS_ASSERT_MAGIC_SETTAINT;
2105 PERL_UNUSED_ARG(sv);
2107 /* update taint status */
2116 Perl_magic_getvec(pTHX_ SV *sv, MAGIC *mg)
2118 SV * const lsv = LvTARG(sv);
2120 PERL_ARGS_ASSERT_MAGIC_GETVEC;
2121 PERL_UNUSED_ARG(mg);
2124 sv_setuv(sv, do_vecget(lsv, LvTARGOFF(sv), LvTARGLEN(sv)));
2132 Perl_magic_setvec(pTHX_ SV *sv, MAGIC *mg)
2134 PERL_ARGS_ASSERT_MAGIC_SETVEC;
2135 PERL_UNUSED_ARG(mg);
2136 do_vecset(sv); /* XXX slurp this routine */
2141 Perl_magic_getdefelem(pTHX_ SV *sv, MAGIC *mg)
2146 PERL_ARGS_ASSERT_MAGIC_GETDEFELEM;
2148 if (LvTARGLEN(sv)) {
2150 SV * const ahv = LvTARG(sv);
2151 HE * const he = hv_fetch_ent(MUTABLE_HV(ahv), mg->mg_obj, FALSE, 0);
2156 AV *const av = MUTABLE_AV(LvTARG(sv));
2157 if ((I32)LvTARGOFF(sv) <= AvFILL(av))
2158 targ = AvARRAY(av)[LvTARGOFF(sv)];
2160 if (targ && (targ != &PL_sv_undef)) {
2161 /* somebody else defined it for us */
2162 SvREFCNT_dec(LvTARG(sv));
2163 LvTARG(sv) = SvREFCNT_inc_simple_NN(targ);
2165 SvREFCNT_dec(mg->mg_obj);
2167 mg->mg_flags &= ~MGf_REFCOUNTED;
2172 sv_setsv(sv, targ ? targ : &PL_sv_undef);
2177 Perl_magic_setdefelem(pTHX_ SV *sv, MAGIC *mg)
2179 PERL_ARGS_ASSERT_MAGIC_SETDEFELEM;
2180 PERL_UNUSED_ARG(mg);
2184 sv_setsv(LvTARG(sv), sv);
2185 SvSETMAGIC(LvTARG(sv));
2191 Perl_vivify_defelem(pTHX_ SV *sv)
2197 PERL_ARGS_ASSERT_VIVIFY_DEFELEM;
2199 if (!LvTARGLEN(sv) || !(mg = mg_find(sv, PERL_MAGIC_defelem)))
2202 SV * const ahv = LvTARG(sv);
2203 HE * const he = hv_fetch_ent(MUTABLE_HV(ahv), mg->mg_obj, TRUE, 0);
2206 if (!value || value == &PL_sv_undef)
2207 Perl_croak(aTHX_ PL_no_helem_sv, SVfARG(mg->mg_obj));
2210 AV *const av = MUTABLE_AV(LvTARG(sv));
2211 if ((I32)LvTARGLEN(sv) < 0 && (I32)LvTARGOFF(sv) > AvFILL(av))
2212 LvTARG(sv) = NULL; /* array can't be extended */
2214 SV* const * const svp = av_fetch(av, LvTARGOFF(sv), TRUE);
2215 if (!svp || (value = *svp) == &PL_sv_undef)
2216 Perl_croak(aTHX_ PL_no_aelem, (I32)LvTARGOFF(sv));
2219 SvREFCNT_inc_simple_void(value);
2220 SvREFCNT_dec(LvTARG(sv));
2223 SvREFCNT_dec(mg->mg_obj);
2225 mg->mg_flags &= ~MGf_REFCOUNTED;
2229 Perl_magic_killbackrefs(pTHX_ SV *sv, MAGIC *mg)
2231 PERL_ARGS_ASSERT_MAGIC_KILLBACKREFS;
2232 return Perl_sv_kill_backrefs(aTHX_ sv, MUTABLE_AV(mg->mg_obj));
2236 Perl_magic_setmglob(pTHX_ SV *sv, MAGIC *mg)
2238 PERL_ARGS_ASSERT_MAGIC_SETMGLOB;
2239 PERL_UNUSED_CONTEXT;
2241 if (!isGV_with_GP(sv))
2247 Perl_magic_setuvar(pTHX_ SV *sv, MAGIC *mg)
2249 const struct ufuncs * const uf = (struct ufuncs *)mg->mg_ptr;
2251 PERL_ARGS_ASSERT_MAGIC_SETUVAR;
2253 if (uf && uf->uf_set)
2254 (*uf->uf_set)(aTHX_ uf->uf_index, sv);
2259 Perl_magic_setregexp(pTHX_ SV *sv, MAGIC *mg)
2261 const char type = mg->mg_type;
2263 PERL_ARGS_ASSERT_MAGIC_SETREGEXP;
2265 if (type == PERL_MAGIC_qr) {
2266 } else if (type == PERL_MAGIC_bm) {
2270 assert(type == PERL_MAGIC_fm);
2273 return sv_unmagic(sv, type);
2276 #ifdef USE_LOCALE_COLLATE
2278 Perl_magic_setcollxfrm(pTHX_ SV *sv, MAGIC *mg)
2280 PERL_ARGS_ASSERT_MAGIC_SETCOLLXFRM;
2283 * RenE<eacute> Descartes said "I think not."
2284 * and vanished with a faint plop.
2286 PERL_UNUSED_CONTEXT;
2287 PERL_UNUSED_ARG(sv);
2289 Safefree(mg->mg_ptr);
2295 #endif /* USE_LOCALE_COLLATE */
2297 /* Just clear the UTF-8 cache data. */
2299 Perl_magic_setutf8(pTHX_ SV *sv, MAGIC *mg)
2301 PERL_ARGS_ASSERT_MAGIC_SETUTF8;
2302 PERL_UNUSED_CONTEXT;
2303 PERL_UNUSED_ARG(sv);
2304 Safefree(mg->mg_ptr); /* The mg_ptr holds the pos cache. */
2306 mg->mg_len = -1; /* The mg_len holds the len cache. */
2311 Perl_magic_set(pTHX_ SV *sv, MAGIC *mg)
2314 register const char *s;
2316 register const REGEXP * rx;
2317 const char * const remaining = mg->mg_ptr + 1;
2321 PERL_ARGS_ASSERT_MAGIC_SET;
2323 switch (*mg->mg_ptr) {
2324 case '\015': /* $^MATCH */
2325 if (strEQ(remaining, "ATCH"))
2327 case '`': /* ${^PREMATCH} caught below */
2329 paren = RX_BUFF_IDX_PREMATCH;
2331 case '\'': /* ${^POSTMATCH} caught below */
2333 paren = RX_BUFF_IDX_POSTMATCH;
2337 paren = RX_BUFF_IDX_FULLMATCH;
2339 case '1': case '2': case '3': case '4':
2340 case '5': case '6': case '7': case '8': case '9':
2341 paren = atoi(mg->mg_ptr);
2343 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
2344 CALLREG_NUMBUF_STORE((REGEXP * const)rx,paren,sv);
2347 /* Croak with a READONLY error when a numbered match var is
2348 * set without a previous pattern match. Unless it's C<local $1>
2350 if (!PL_localizing) {
2351 Perl_croak(aTHX_ "%s", PL_no_modify);
2354 case '\001': /* ^A */
2355 sv_setsv(PL_bodytarget, sv);
2357 case '\003': /* ^C */
2358 PL_minus_c = (bool)SvIV(sv);
2361 case '\004': /* ^D */
2363 s = SvPV_nolen_const(sv);
2364 PL_debug = get_debug_opts(&s, 0) | DEBUG_TOP_FLAG;
2365 if (DEBUG_x_TEST || DEBUG_B_TEST)
2366 dump_all_perl(!DEBUG_B_TEST);
2368 PL_debug = (SvIV(sv)) | DEBUG_TOP_FLAG;
2371 case '\005': /* ^E */
2372 if (*(mg->mg_ptr+1) == '\0') {
2374 set_vaxc_errno(SvIV(sv));
2377 SetLastError( SvIV(sv) );
2380 os2_setsyserrno(SvIV(sv));
2382 /* will anyone ever use this? */
2383 SETERRNO(SvIV(sv), 4);
2388 else if (strEQ(mg->mg_ptr+1, "NCODING")) {
2389 SvREFCNT_dec(PL_encoding);
2390 if (SvOK(sv) || SvGMAGICAL(sv)) {
2391 PL_encoding = newSVsv(sv);
2398 case '\006': /* ^F */
2399 PL_maxsysfd = SvIV(sv);
2401 case '\010': /* ^H */
2402 PL_hints = SvIV(sv);
2404 case '\011': /* ^I */ /* NOT \t in EBCDIC */
2405 Safefree(PL_inplace);
2406 PL_inplace = SvOK(sv) ? savesvpv(sv) : NULL;
2408 case '\017': /* ^O */
2409 if (*(mg->mg_ptr+1) == '\0') {
2410 Safefree(PL_osname);
2413 TAINT_PROPER("assigning to $^O");
2414 PL_osname = savesvpv(sv);
2417 else if (strEQ(mg->mg_ptr, "\017PEN")) {
2419 const char *const start = SvPV(sv, len);
2420 const char *out = (const char*)memchr(start, '\0', len);
2424 PL_compiling.cop_hints |= HINT_LEXICAL_IO_IN | HINT_LEXICAL_IO_OUT;
2425 PL_hints |= HINT_LEXICAL_IO_IN | HINT_LEXICAL_IO_OUT;
2427 /* Opening for input is more common than opening for output, so
2428 ensure that hints for input are sooner on linked list. */
2429 tmp = out ? newSVpvn_flags(out + 1, start + len - out - 1,
2431 : newSVpvs_flags("", SvUTF8(sv));
2432 (void)hv_stores(GvHV(PL_hintgv), "open>", tmp);
2435 tmp = newSVpvn_flags(start, out ? (STRLEN)(out - start) : len,
2437 (void)hv_stores(GvHV(PL_hintgv), "open<", tmp);
2441 case '\020': /* ^P */
2442 if (*remaining == '\0') { /* ^P */
2443 PL_perldb = SvIV(sv);
2444 if (PL_perldb && !PL_DBsingle)
2447 } else if (strEQ(remaining, "REMATCH")) { /* $^PREMATCH */
2449 } else if (strEQ(remaining, "OSTMATCH")) { /* $^POSTMATCH */
2452 case '\024': /* ^T */
2454 PL_basetime = (Time_t)(SvNOK(sv) ? SvNVX(sv) : sv_2nv(sv));
2456 PL_basetime = (Time_t)SvIV(sv);
2459 case '\025': /* ^UTF8CACHE */
2460 if (strEQ(mg->mg_ptr+1, "TF8CACHE")) {
2461 PL_utf8cache = (signed char) sv_2iv(sv);
2464 case '\027': /* ^W & $^WARNING_BITS */
2465 if (*(mg->mg_ptr+1) == '\0') {
2466 if ( ! (PL_dowarn & G_WARN_ALL_MASK)) {
2468 PL_dowarn = (PL_dowarn & ~G_WARN_ON)
2469 | (i ? G_WARN_ON : G_WARN_OFF) ;
2472 else if (strEQ(mg->mg_ptr+1, "ARNING_BITS")) {
2473 if ( ! (PL_dowarn & G_WARN_ALL_MASK)) {
2474 if (!SvPOK(sv) && PL_localizing) {
2475 sv_setpvn(sv, WARN_NONEstring, WARNsize);
2476 PL_compiling.cop_warnings = pWARN_NONE;
2481 int accumulate = 0 ;
2482 int any_fatals = 0 ;
2483 const char * const ptr = SvPV_const(sv, len) ;
2484 for (i = 0 ; i < len ; ++i) {
2485 accumulate |= ptr[i] ;
2486 any_fatals |= (ptr[i] & 0xAA) ;
2489 if (!specialWARN(PL_compiling.cop_warnings))
2490 PerlMemShared_free(PL_compiling.cop_warnings);
2491 PL_compiling.cop_warnings = pWARN_NONE;
2493 /* Yuck. I can't see how to abstract this: */
2494 else if (isWARN_on(((STRLEN *)SvPV_nolen_const(sv)) - 1,
2495 WARN_ALL) && !any_fatals) {
2496 if (!specialWARN(PL_compiling.cop_warnings))
2497 PerlMemShared_free(PL_compiling.cop_warnings);
2498 PL_compiling.cop_warnings = pWARN_ALL;
2499 PL_dowarn |= G_WARN_ONCE ;
2503 const char *const p = SvPV_const(sv, len);
2505 PL_compiling.cop_warnings
2506 = Perl_new_warnings_bitfield(aTHX_ PL_compiling.cop_warnings,
2509 if (isWARN_on(PL_compiling.cop_warnings, WARN_ONCE))
2510 PL_dowarn |= G_WARN_ONCE ;
2518 if (PL_localizing) {
2519 if (PL_localizing == 1)
2520 SAVESPTR(PL_last_in_gv);
2522 else if (SvOK(sv) && GvIO(PL_last_in_gv))
2523 IoLINES(GvIOp(PL_last_in_gv)) = SvIV(sv);
2526 Safefree(IoTOP_NAME(GvIOp(PL_defoutgv)));
2527 s = IoTOP_NAME(GvIOp(PL_defoutgv)) = savesvpv(sv);
2528 IoTOP_GV(GvIOp(PL_defoutgv)) = gv_fetchsv(sv, GV_ADD, SVt_PVIO);
2531 Safefree(IoFMT_NAME(GvIOp(PL_defoutgv)));
2532 s = IoFMT_NAME(GvIOp(PL_defoutgv)) = savesvpv(sv);
2533 IoFMT_GV(GvIOp(PL_defoutgv)) = gv_fetchsv(sv, GV_ADD, SVt_PVIO);
2536 IoPAGE_LEN(GvIOp(PL_defoutgv)) = (SvIV(sv));
2539 IoLINES_LEFT(GvIOp(PL_defoutgv)) = (SvIV(sv));
2540 if (IoLINES_LEFT(GvIOp(PL_defoutgv)) < 0L)
2541 IoLINES_LEFT(GvIOp(PL_defoutgv)) = 0L;
2544 IoPAGE(GvIOp(PL_defoutgv)) = (SvIV(sv));
2548 IO * const io = GvIOp(PL_defoutgv);
2551 if ((SvIV(sv)) == 0)
2552 IoFLAGS(io) &= ~IOf_FLUSH;
2554 if (!(IoFLAGS(io) & IOf_FLUSH)) {
2555 PerlIO *ofp = IoOFP(io);
2557 (void)PerlIO_flush(ofp);
2558 IoFLAGS(io) |= IOf_FLUSH;
2564 SvREFCNT_dec(PL_rs);
2565 PL_rs = newSVsv(sv);
2568 SvREFCNT_dec(PL_ors_sv);
2569 if (SvOK(sv) || SvGMAGICAL(sv)) {
2570 PL_ors_sv = newSVsv(sv);
2577 CopARYBASE_set(&PL_compiling, SvIV(sv));
2580 #ifdef COMPLEX_STATUS
2581 if (PL_localizing == 2) {
2582 SvUPGRADE(sv, SVt_PVLV);
2583 PL_statusvalue = LvTARGOFF(sv);
2584 PL_statusvalue_vms = LvTARGLEN(sv);
2588 #ifdef VMSISH_STATUS
2590 STATUS_NATIVE_CHILD_SET((U32)SvIV(sv));
2593 STATUS_UNIX_EXIT_SET(SvIV(sv));
2598 # define PERL_VMS_BANG vaxc$errno
2600 # define PERL_VMS_BANG 0
2602 SETERRNO(SvIOK(sv) ? SvIVX(sv) : SvOK(sv) ? sv_2iv(sv) : 0,
2603 (SvIV(sv) == EVMSERR) ? 4 : PERL_VMS_BANG);
2608 if (PL_delaymagic) {
2609 PL_delaymagic |= DM_RUID;
2610 break; /* don't do magic till later */
2613 (void)setruid((Uid_t)PL_uid);
2616 (void)setreuid((Uid_t)PL_uid, (Uid_t)-1);
2618 #ifdef HAS_SETRESUID
2619 (void)setresuid((Uid_t)PL_uid, (Uid_t)-1, (Uid_t)-1);
2621 if (PL_uid == PL_euid) { /* special case $< = $> */
2623 /* workaround for Darwin's setuid peculiarity, cf [perl #24122] */
2624 if (PL_uid != 0 && PerlProc_getuid() == 0)
2625 (void)PerlProc_setuid(0);
2627 (void)PerlProc_setuid(PL_uid);
2629 PL_uid = PerlProc_getuid();
2630 Perl_croak(aTHX_ "setruid() not implemented");
2635 PL_uid = PerlProc_getuid();
2636 PL_tainting |= (PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid));
2640 if (PL_delaymagic) {
2641 PL_delaymagic |= DM_EUID;
2642 break; /* don't do magic till later */
2645 (void)seteuid((Uid_t)PL_euid);
2648 (void)setreuid((Uid_t)-1, (Uid_t)PL_euid);
2650 #ifdef HAS_SETRESUID
2651 (void)setresuid((Uid_t)-1, (Uid_t)PL_euid, (Uid_t)-1);
2653 if (PL_euid == PL_uid) /* special case $> = $< */
2654 PerlProc_setuid(PL_euid);
2656 PL_euid = PerlProc_geteuid();
2657 Perl_croak(aTHX_ "seteuid() not implemented");
2662 PL_euid = PerlProc_geteuid();
2663 PL_tainting |= (PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid));
2667 if (PL_delaymagic) {
2668 PL_delaymagic |= DM_RGID;
2669 break; /* don't do magic till later */
2672 (void)setrgid((Gid_t)PL_gid);
2675 (void)setregid((Gid_t)PL_gid, (Gid_t)-1);
2677 #ifdef HAS_SETRESGID
2678 (void)setresgid((Gid_t)PL_gid, (Gid_t)-1, (Gid_t) 1);
2680 if (PL_gid == PL_egid) /* special case $( = $) */
2681 (void)PerlProc_setgid(PL_gid);
2683 PL_gid = PerlProc_getgid();
2684 Perl_croak(aTHX_ "setrgid() not implemented");
2689 PL_gid = PerlProc_getgid();
2690 PL_tainting |= (PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid));
2693 #ifdef HAS_SETGROUPS
2695 const char *p = SvPV_const(sv, len);
2696 Groups_t *gary = NULL;
2697 #ifdef _SC_NGROUPS_MAX
2698 int maxgrp = sysconf(_SC_NGROUPS_MAX);
2703 int maxgrp = NGROUPS;
2709 for (i = 0; i < maxgrp; ++i) {
2710 while (*p && !isSPACE(*p))
2717 Newx(gary, i + 1, Groups_t);
2719 Renew(gary, i + 1, Groups_t);
2723 (void)setgroups(i, gary);
2726 #else /* HAS_SETGROUPS */
2728 #endif /* HAS_SETGROUPS */
2729 if (PL_delaymagic) {
2730 PL_delaymagic |= DM_EGID;
2731 break; /* don't do magic till later */
2734 (void)setegid((Gid_t)PL_egid);
2737 (void)setregid((Gid_t)-1, (Gid_t)PL_egid);
2739 #ifdef HAS_SETRESGID
2740 (void)setresgid((Gid_t)-1, (Gid_t)PL_egid, (Gid_t)-1);
2742 if (PL_egid == PL_gid) /* special case $) = $( */
2743 (void)PerlProc_setgid(PL_egid);
2745 PL_egid = PerlProc_getegid();
2746 Perl_croak(aTHX_ "setegid() not implemented");
2751 PL_egid = PerlProc_getegid();
2752 PL_tainting |= (PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid));
2755 PL_chopset = SvPV_force(sv,len);
2758 LOCK_DOLLARZERO_MUTEX;
2759 #ifdef HAS_SETPROCTITLE
2760 /* The BSDs don't show the argv[] in ps(1) output, they
2761 * show a string from the process struct and provide
2762 * the setproctitle() routine to manipulate that. */
2763 if (PL_origalen != 1) {
2764 s = SvPV_const(sv, len);
2765 # if __FreeBSD_version > 410001
2766 /* The leading "-" removes the "perl: " prefix,
2767 * but not the "(perl) suffix from the ps(1)
2768 * output, because that's what ps(1) shows if the
2769 * argv[] is modified. */
2770 setproctitle("-%s", s);
2771 # else /* old FreeBSDs, NetBSD, OpenBSD, anyBSD */
2772 /* This doesn't really work if you assume that
2773 * $0 = 'foobar'; will wipe out 'perl' from the $0
2774 * because in ps(1) output the result will be like
2775 * sprintf("perl: %s (perl)", s)
2776 * I guess this is a security feature:
2777 * one (a user process) cannot get rid of the original name.
2779 setproctitle("%s", s);
2782 #elif defined(__hpux) && defined(PSTAT_SETCMD)
2783 if (PL_origalen != 1) {
2785 s = SvPV_const(sv, len);
2786 un.pst_command = (char *)s;
2787 pstat(PSTAT_SETCMD, un, len, 0, 0);
2790 if (PL_origalen > 1) {
2791 /* PL_origalen is set in perl_parse(). */
2792 s = SvPV_force(sv,len);
2793 if (len >= (STRLEN)PL_origalen-1) {
2794 /* Longer than original, will be truncated. We assume that
2795 * PL_origalen bytes are available. */
2796 Copy(s, PL_origargv[0], PL_origalen-1, char);
2799 /* Shorter than original, will be padded. */
2801 /* Special case for Mac OS X: see [perl #38868] */
2804 /* Is the space counterintuitive? Yes.
2805 * (You were expecting \0?)
2806 * Does it work? Seems to. (In Linux 2.4.20 at least.)
2808 const int pad = ' ';
2810 Copy(s, PL_origargv[0], len, char);
2811 PL_origargv[0][len] = 0;
2812 memset(PL_origargv[0] + len + 1,
2813 pad, PL_origalen - len - 1);
2815 PL_origargv[0][PL_origalen-1] = 0;
2816 for (i = 1; i < PL_origargc; i++)
2820 UNLOCK_DOLLARZERO_MUTEX;
2827 Perl_whichsig(pTHX_ const char *sig)
2829 register char* const* sigv;
2831 PERL_ARGS_ASSERT_WHICHSIG;
2832 PERL_UNUSED_CONTEXT;
2834 for (sigv = (char* const*)PL_sig_name; *sigv; sigv++)
2835 if (strEQ(sig,*sigv))
2836 return PL_sig_num[sigv - (char* const*)PL_sig_name];
2838 if (strEQ(sig,"CHLD"))
2842 if (strEQ(sig,"CLD"))
2849 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
2850 Perl_sighandler(int sig, siginfo_t *sip, void *uap PERL_UNUSED_DECL)
2852 Perl_sighandler(int sig)
2855 #ifdef PERL_GET_SIG_CONTEXT
2856 dTHXa(PERL_GET_SIG_CONTEXT);
2863 SV * const tSv = PL_Sv;
2867 XPV * const tXpv = PL_Xpv;
2869 if (PL_savestack_ix + 15 <= PL_savestack_max)
2871 if (PL_markstack_ptr < PL_markstack_max - 2)
2873 if (PL_scopestack_ix < PL_scopestack_max - 3)
2876 if (!PL_psig_ptr[sig]) {
2877 PerlIO_printf(Perl_error_log, "Signal SIG%s received, but no signal handler set.\n",
2882 /* Max number of items pushed there is 3*n or 4. We cannot fix
2883 infinity, so we fix 4 (in fact 5): */
2885 PL_savestack_ix += 5; /* Protect save in progress. */
2886 SAVEDESTRUCTOR_X(S_unwind_handler_stack, (void*)&flags);
2889 PL_markstack_ptr++; /* Protect mark. */
2891 PL_scopestack_ix += 1;
2892 /* sv_2cv is too complicated, try a simpler variant first: */
2893 if (!SvROK(PL_psig_ptr[sig]) || !(cv = MUTABLE_CV(SvRV(PL_psig_ptr[sig])))
2894 || SvTYPE(cv) != SVt_PVCV) {
2896 cv = sv_2cv(PL_psig_ptr[sig], &st, &gv, GV_ADD);
2899 if (!cv || !CvROOT(cv)) {
2900 Perl_ck_warner(aTHX_ packWARN(WARN_SIGNAL), "SIG%s handler \"%s\" not defined.\n",
2901 PL_sig_name[sig], (gv ? GvENAME(gv)
2908 if(PL_psig_name[sig]) {
2909 sv = SvREFCNT_inc_NN(PL_psig_name[sig]);
2911 #if !defined(PERL_IMPLICIT_CONTEXT)
2915 sv = sv_newmortal();
2916 sv_setpv(sv,PL_sig_name[sig]);
2919 PUSHSTACKi(PERLSI_SIGNAL);
2922 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
2924 struct sigaction oact;
2926 if (sigaction(sig, 0, &oact) == 0 && oact.sa_flags & SA_SIGINFO) {
2929 SV *rv = newRV_noinc(MUTABLE_SV(sih));
2930 /* The siginfo fields signo, code, errno, pid, uid,
2931 * addr, status, and band are defined by POSIX/SUSv3. */
2932 (void)hv_stores(sih, "signo", newSViv(sip->si_signo));
2933 (void)hv_stores(sih, "code", newSViv(sip->si_code));
2934 #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. */
2935 hv_stores(sih, "errno", newSViv(sip->si_errno));
2936 hv_stores(sih, "status", newSViv(sip->si_status));
2937 hv_stores(sih, "uid", newSViv(sip->si_uid));
2938 hv_stores(sih, "pid", newSViv(sip->si_pid));
2939 hv_stores(sih, "addr", newSVuv(PTR2UV(sip->si_addr)));
2940 hv_stores(sih, "band", newSViv(sip->si_band));
2944 mPUSHp((char *)sip, sizeof(*sip));
2952 call_sv(MUTABLE_SV(cv), G_DISCARD|G_EVAL);
2955 if (SvTRUE(ERRSV)) {
2957 #ifdef HAS_SIGPROCMASK
2958 /* Handler "died", for example to get out of a restart-able read().
2959 * Before we re-do that on its behalf re-enable the signal which was
2960 * blocked by the system when we entered.
2964 sigaddset(&set,sig);
2965 sigprocmask(SIG_UNBLOCK, &set, NULL);
2967 /* Not clear if this will work */
2968 (void)rsignal(sig, SIG_IGN);
2969 (void)rsignal(sig, PL_csighandlerp);
2971 #endif /* !PERL_MICRO */
2972 Perl_die(aTHX_ NULL);
2976 PL_savestack_ix -= 8; /* Unprotect save in progress. */
2980 PL_scopestack_ix -= 1;
2983 PL_op = myop; /* Apparently not needed... */
2985 PL_Sv = tSv; /* Restore global temporaries. */
2992 S_restore_magic(pTHX_ const void *p)
2995 MGS* const mgs = SSPTR(PTR2IV(p), MGS*);
2996 SV* const sv = mgs->mgs_sv;
3001 if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv))
3003 #ifdef PERL_OLD_COPY_ON_WRITE
3004 /* While magic was saved (and off) sv_setsv may well have seen
3005 this SV as a prime candidate for COW. */
3007 sv_force_normal_flags(sv, 0);
3010 if (mgs->mgs_readonly)
3012 if (mgs->mgs_magical)
3013 SvFLAGS(sv) |= mgs->mgs_magical;
3016 if (SvGMAGICAL(sv)) {
3017 /* downgrade public flags to private,
3018 and discard any other private flags */
3020 const U32 pubflags = SvFLAGS(sv) & (SVf_IOK|SVf_NOK|SVf_POK);
3022 SvFLAGS(sv) &= ~( pubflags | (SVp_IOK|SVp_NOK|SVp_POK) );
3023 SvFLAGS(sv) |= ( pubflags << PRIVSHIFT );
3028 mgs->mgs_sv = NULL; /* mark the MGS structure as restored */
3030 /* If we're still on top of the stack, pop us off. (That condition
3031 * will be satisfied if restore_magic was called explicitly, but *not*
3032 * if it's being called via leave_scope.)
3033 * The reason for doing this is that otherwise, things like sv_2cv()
3034 * may leave alloc gunk on the savestack, and some code
3035 * (e.g. sighandler) doesn't expect that...
3037 if (PL_savestack_ix == mgs->mgs_ss_ix)
3039 I32 popval = SSPOPINT;
3040 assert(popval == SAVEt_DESTRUCTOR_X);
3041 PL_savestack_ix -= 2;
3043 assert(popval == SAVEt_ALLOC);
3045 PL_savestack_ix -= popval;
3051 S_unwind_handler_stack(pTHX_ const void *p)
3054 const U32 flags = *(const U32*)p;
3056 PERL_ARGS_ASSERT_UNWIND_HANDLER_STACK;
3059 PL_savestack_ix -= 5; /* Unprotect save in progress. */
3060 #if !defined(PERL_IMPLICIT_CONTEXT)
3062 SvREFCNT_dec(PL_sig_sv);
3067 =for apidoc magic_sethint
3069 Triggered by a store to %^H, records the key/value pair to
3070 C<PL_compiling.cop_hints_hash>. It is assumed that hints aren't storing
3071 anything that would need a deep copy. Maybe we should warn if we find a
3077 Perl_magic_sethint(pTHX_ SV *sv, MAGIC *mg)
3080 SV *key = (mg->mg_len == HEf_SVKEY) ? MUTABLE_SV(mg->mg_ptr)
3081 : newSVpvn_flags(mg->mg_ptr, mg->mg_len, SVs_TEMP);
3083 PERL_ARGS_ASSERT_MAGIC_SETHINT;
3085 /* mg->mg_obj isn't being used. If needed, it would be possible to store
3086 an alternative leaf in there, with PL_compiling.cop_hints being used if
3087 it's NULL. If needed for threads, the alternative could lock a mutex,
3088 or take other more complex action. */
3090 /* Something changed in %^H, so it will need to be restored on scope exit.
3091 Doing this here saves a lot of doing it manually in perl code (and
3092 forgetting to do it, and consequent subtle errors. */
3093 PL_hints |= HINT_LOCALIZE_HH;
3094 PL_compiling.cop_hints_hash
3095 = Perl_refcounted_he_new(aTHX_ PL_compiling.cop_hints_hash, key, sv);
3100 =for apidoc magic_clearhint
3102 Triggered by a delete from %^H, records the key to
3103 C<PL_compiling.cop_hints_hash>.
3108 Perl_magic_clearhint(pTHX_ SV *sv, MAGIC *mg)
3112 PERL_ARGS_ASSERT_MAGIC_CLEARHINT;
3113 PERL_UNUSED_ARG(sv);
3115 assert(mg->mg_len == HEf_SVKEY);
3117 PERL_UNUSED_ARG(sv);
3119 PL_hints |= HINT_LOCALIZE_HH;
3120 PL_compiling.cop_hints_hash
3121 = Perl_refcounted_he_new(aTHX_ PL_compiling.cop_hints_hash,
3122 MUTABLE_SV(mg->mg_ptr), &PL_sv_placeholder);
3127 =for apidoc magic_clearhints
3129 Triggered by clearing %^H, resets C<PL_compiling.cop_hints_hash>.
3134 Perl_magic_clearhints(pTHX_ SV *sv, MAGIC *mg)
3136 PERL_ARGS_ASSERT_MAGIC_CLEARHINTS;
3137 PERL_UNUSED_ARG(sv);
3138 PERL_UNUSED_ARG(mg);
3139 if (PL_compiling.cop_hints_hash) {
3140 Perl_refcounted_he_free(aTHX_ PL_compiling.cop_hints_hash);
3141 PL_compiling.cop_hints_hash = NULL;
3148 * c-indentation-style: bsd
3150 * indent-tabs-mode: t
3153 * ex: set ts=8 sts=4 sw=4 noet: