3 * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 * 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 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."
17 =head1 Magical Functions
19 "Magic" is special data attached to SV structures in order to give them
20 "magical" properties. When any Perl code tries to read from, or assign to,
21 an SV marked as magical, it calls the 'get' or 'set' function associated
22 with that SV's magic. A get is called prior to reading an SV, in order to
23 give it a chance to update its internal value (get on $. writes the line
24 number of the last read filehandle into to the SV's IV slot), while
25 set is called after an SV has been written to, in order to allow it to make
26 use of its changed value (set on $/ copies the SV's new value to the
27 PL_rs global variable).
29 Magic is implemented as a linked list of MAGIC structures attached to the
30 SV. Each MAGIC struct holds the type of the magic, a pointer to an array
31 of functions that implement the get(), set(), length() etc functions,
32 plus space for some flags and pointers. For example, a tied variable has
33 a MAGIC structure that contains a pointer to the object associated with the
42 #if defined(HAS_GETGROUPS) || defined(HAS_SETGROUPS)
48 #if defined(HAS_SETGROUPS)
55 # include <sys/pstat.h>
58 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
59 Signal_t Perl_csighandler(int sig, siginfo_t *, void *);
61 Signal_t Perl_csighandler(int sig);
65 /* Missing protos on LynxOS */
66 void setruid(uid_t id);
67 void seteuid(uid_t id);
68 void setrgid(uid_t id);
69 void setegid(uid_t id);
73 * Use the "DESTRUCTOR" scope cleanup to reinstate magic.
81 /* MGS is typedef'ed to struct magic_state in perl.h */
84 S_save_magic(pTHX_ I32 mgs_ix, SV *sv)
88 assert(SvMAGICAL(sv));
89 /* Turning READONLY off for a copy-on-write scalar (including shared
90 hash keys) is a bad idea. */
92 sv_force_normal_flags(sv, 0);
94 SAVEDESTRUCTOR_X(S_restore_magic, INT2PTR(void*, (IV)mgs_ix));
96 mgs = SSPTR(mgs_ix, MGS*);
98 mgs->mgs_flags = SvMAGICAL(sv) | SvREADONLY(sv);
99 mgs->mgs_ss_ix = PL_savestack_ix; /* points after the saved destructor */
103 if (!(SvFLAGS(sv) & (SVf_IOK|SVf_NOK|SVf_POK))) {
104 /* No public flags are set, so promote any private flags to public. */
105 SvFLAGS(sv) |= (SvFLAGS(sv) & (SVp_IOK|SVp_NOK|SVp_POK)) >> PRIVSHIFT;
110 =for apidoc mg_magical
112 Turns on the magical status of an SV. See C<sv_magic>.
118 Perl_mg_magical(pTHX_ SV *sv)
122 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
123 const MGVTBL* const vtbl = mg->mg_virtual;
125 if (vtbl->svt_get && !(mg->mg_flags & MGf_GSKIP))
129 if (!(SvFLAGS(sv) & (SVs_GMG|SVs_SMG)) || vtbl->svt_clear)
136 /* is this container magic (%ENV, $1 etc), or value magic (pos, taint etc)? */
139 S_is_container_magic(const MAGIC *mg)
141 switch (mg->mg_type) {
144 case PERL_MAGIC_regex_global:
145 case PERL_MAGIC_nkeys:
146 #ifdef USE_LOCALE_COLLATE
147 case PERL_MAGIC_collxfrm:
150 case PERL_MAGIC_taint:
152 case PERL_MAGIC_vstring:
153 case PERL_MAGIC_utf8:
154 case PERL_MAGIC_substr:
155 case PERL_MAGIC_defelem:
156 case PERL_MAGIC_arylen:
158 case PERL_MAGIC_backref:
159 case PERL_MAGIC_arylen_p:
160 case PERL_MAGIC_rhash:
161 case PERL_MAGIC_symtab:
171 Do magic after a value is retrieved from the SV. See C<sv_magic>.
177 Perl_mg_get(pTHX_ SV *sv)
180 const I32 mgs_ix = SSNEW(sizeof(MGS));
181 const bool was_temp = (bool)SvTEMP(sv);
183 MAGIC *newmg, *head, *cur, *mg;
184 /* guard against sv having being freed midway by holding a private
187 /* sv_2mortal has this side effect of turning on the TEMP flag, which can
188 cause the SV's buffer to get stolen (and maybe other stuff).
191 sv_2mortal(SvREFCNT_inc_simple_NN(sv));
196 save_magic(mgs_ix, sv);
198 /* We must call svt_get(sv, mg) for each valid entry in the linked
199 list of magic. svt_get() may delete the current entry, add new
200 magic to the head of the list, or upgrade the SV. AMS 20010810 */
202 newmg = cur = head = mg = SvMAGIC(sv);
204 const MGVTBL * const vtbl = mg->mg_virtual;
206 if (!(mg->mg_flags & MGf_GSKIP) && vtbl && vtbl->svt_get) {
207 CALL_FPTR(vtbl->svt_get)(aTHX_ sv, mg);
209 /* guard against magic having been deleted - eg FETCH calling
214 /* Don't restore the flags for this entry if it was deleted. */
215 if (mg->mg_flags & MGf_GSKIP)
216 (SSPTR(mgs_ix, MGS *))->mgs_flags = 0;
219 mg = mg->mg_moremagic;
222 /* Have we finished with the new entries we saw? Start again
223 where we left off (unless there are more new entries). */
231 /* Were any new entries added? */
232 if (!have_new && (newmg = SvMAGIC(sv)) != head) {
239 restore_magic(INT2PTR(void *, (IV)mgs_ix));
241 if (SvREFCNT(sv) == 1) {
242 /* We hold the last reference to this SV, which implies that the
243 SV was deleted as a side effect of the routines we called. */
252 Do magic after a value is assigned to the SV. See C<sv_magic>.
258 Perl_mg_set(pTHX_ SV *sv)
261 const I32 mgs_ix = SSNEW(sizeof(MGS));
265 save_magic(mgs_ix, sv);
267 for (mg = SvMAGIC(sv); mg; mg = nextmg) {
268 const MGVTBL* vtbl = mg->mg_virtual;
269 nextmg = mg->mg_moremagic; /* it may delete itself */
270 if (mg->mg_flags & MGf_GSKIP) {
271 mg->mg_flags &= ~MGf_GSKIP; /* setting requires another read */
272 (SSPTR(mgs_ix, MGS*))->mgs_flags = 0;
274 if (PL_localizing == 2 && !S_is_container_magic(mg))
276 if (vtbl && vtbl->svt_set)
277 CALL_FPTR(vtbl->svt_set)(aTHX_ sv, mg);
280 restore_magic(INT2PTR(void*, (IV)mgs_ix));
285 =for apidoc mg_length
287 Report on the SV's length. See C<sv_magic>.
293 Perl_mg_length(pTHX_ SV *sv)
299 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
300 const MGVTBL * const vtbl = mg->mg_virtual;
301 if (vtbl && vtbl->svt_len) {
302 const I32 mgs_ix = SSNEW(sizeof(MGS));
303 save_magic(mgs_ix, sv);
304 /* omit MGf_GSKIP -- not changed here */
305 len = CALL_FPTR(vtbl->svt_len)(aTHX_ sv, mg);
306 restore_magic(INT2PTR(void*, (IV)mgs_ix));
312 const U8 *s = (U8*)SvPV_const(sv, len);
313 len = utf8_length(s, s + len);
316 (void)SvPV_const(sv, len);
321 Perl_mg_size(pTHX_ SV *sv)
325 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
326 const MGVTBL* const vtbl = mg->mg_virtual;
327 if (vtbl && vtbl->svt_len) {
328 const I32 mgs_ix = SSNEW(sizeof(MGS));
330 save_magic(mgs_ix, sv);
331 /* omit MGf_GSKIP -- not changed here */
332 len = CALL_FPTR(vtbl->svt_len)(aTHX_ sv, mg);
333 restore_magic(INT2PTR(void*, (IV)mgs_ix));
340 return AvFILLp((AV *) sv); /* Fallback to non-tied array */
344 Perl_croak(aTHX_ "Size magic not implemented");
353 Clear something magical that the SV represents. See C<sv_magic>.
359 Perl_mg_clear(pTHX_ SV *sv)
361 const I32 mgs_ix = SSNEW(sizeof(MGS));
364 save_magic(mgs_ix, sv);
366 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
367 const MGVTBL* const vtbl = mg->mg_virtual;
368 /* omit GSKIP -- never set here */
370 if (vtbl && vtbl->svt_clear)
371 CALL_FPTR(vtbl->svt_clear)(aTHX_ sv, mg);
374 restore_magic(INT2PTR(void*, (IV)mgs_ix));
381 Finds the magic pointer for type matching the SV. See C<sv_magic>.
387 Perl_mg_find(pTHX_ const SV *sv, int type)
392 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
393 if (mg->mg_type == type)
403 Copies the magic from one SV to another. See C<sv_magic>.
409 Perl_mg_copy(pTHX_ SV *sv, SV *nsv, const char *key, I32 klen)
413 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
414 const MGVTBL* const vtbl = mg->mg_virtual;
415 if ((mg->mg_flags & MGf_COPY) && vtbl->svt_copy){
416 count += CALL_FPTR(vtbl->svt_copy)(aTHX_ sv, mg, nsv, key, klen);
419 const char type = mg->mg_type;
420 if (isUPPER(type) && type != PERL_MAGIC_uvar) {
422 (type == PERL_MAGIC_tied)
424 : (type == PERL_MAGIC_regdata && mg->mg_obj)
427 toLOWER(type), key, klen);
436 =for apidoc mg_localize
438 Copy some of the magic from an existing SV to new localized version of
439 that SV. Container magic (eg %ENV, $1, tie) gets copied, value magic
440 doesn't (eg taint, pos).
446 Perl_mg_localize(pTHX_ SV *sv, SV *nsv)
450 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
451 const MGVTBL* const vtbl = mg->mg_virtual;
452 if (!S_is_container_magic(mg))
455 if ((mg->mg_flags & MGf_LOCAL) && vtbl->svt_local)
456 (void)CALL_FPTR(vtbl->svt_local)(aTHX_ nsv, mg);
458 sv_magicext(nsv, mg->mg_obj, mg->mg_type, vtbl,
459 mg->mg_ptr, mg->mg_len);
461 /* container types should remain read-only across localization */
462 SvFLAGS(nsv) |= SvREADONLY(sv);
465 if (SvTYPE(nsv) >= SVt_PVMG && SvMAGIC(nsv)) {
466 SvFLAGS(nsv) |= SvMAGICAL(sv);
476 Free any magic storage used by the SV. See C<sv_magic>.
482 Perl_mg_free(pTHX_ SV *sv)
486 for (mg = SvMAGIC(sv); mg; mg = moremagic) {
487 const MGVTBL* const vtbl = mg->mg_virtual;
488 moremagic = mg->mg_moremagic;
489 if (vtbl && vtbl->svt_free)
490 CALL_FPTR(vtbl->svt_free)(aTHX_ sv, mg);
491 if (mg->mg_ptr && mg->mg_type != PERL_MAGIC_regex_global) {
492 if (mg->mg_len > 0 || mg->mg_type == PERL_MAGIC_utf8)
493 Safefree(mg->mg_ptr);
494 else if (mg->mg_len == HEf_SVKEY)
495 SvREFCNT_dec((SV*)mg->mg_ptr);
497 if (mg->mg_flags & MGf_REFCOUNTED)
498 SvREFCNT_dec(mg->mg_obj);
500 SvMAGIC_set(sv, moremagic);
502 SvMAGIC_set(sv, NULL);
509 Perl_magic_regdata_cnt(pTHX_ SV *sv, MAGIC *mg)
515 register const REGEXP * const rx = PM_GETRE(PL_curpm);
517 if (mg->mg_obj) { /* @+ */
518 /* return the number possible */
519 return RX_NPARENS(rx);
521 I32 paren = RX_LASTPAREN(rx);
523 /* return the last filled */
525 && (RX_OFFS(rx)[paren].start == -1
526 || RX_OFFS(rx)[paren].end == -1) )
537 Perl_magic_regdatum_get(pTHX_ SV *sv, MAGIC *mg)
541 register const REGEXP * const rx = PM_GETRE(PL_curpm);
543 register const I32 paren = mg->mg_len;
548 if (paren <= (I32)RX_NPARENS(rx) &&
549 (s = RX_OFFS(rx)[paren].start) != -1 &&
550 (t = RX_OFFS(rx)[paren].end) != -1)
553 if (mg->mg_obj) /* @+ */
558 if (i > 0 && RX_MATCH_UTF8(rx)) {
559 const char * const b = RX_SUBBEG(rx);
561 i = utf8_length((U8*)b, (U8*)(b+i));
572 Perl_magic_regdatum_set(pTHX_ SV *sv, MAGIC *mg)
576 Perl_croak(aTHX_ PL_no_modify);
577 NORETURN_FUNCTION_END;
581 Perl_magic_len(pTHX_ SV *sv, MAGIC *mg)
586 register const REGEXP * rx;
587 const char * const remaining = mg->mg_ptr + 1;
589 switch (*mg->mg_ptr) {
591 if (*remaining == '\0') { /* ^P */
593 } else if (strEQ(remaining, "REMATCH")) { /* $^PREMATCH */
595 } else if (strEQ(remaining, "OSTMATCH")) { /* $^POSTMATCH */
599 case '\015': /* $^MATCH */
600 if (strEQ(remaining, "ATCH")) {
607 paren = RX_BUFF_IDX_PREMATCH;
611 paren = RX_BUFF_IDX_POSTMATCH;
615 paren = RX_BUFF_IDX_FULLMATCH;
617 case '1': case '2': case '3': case '4':
618 case '5': case '6': case '7': case '8': case '9':
619 paren = atoi(mg->mg_ptr);
621 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
623 i = CALLREG_NUMBUF_LENGTH((REGEXP * const)rx, sv, paren);
626 Perl_croak(aTHX_ "panic: magic_len: %"IVdf, (IV)i);
629 if (ckWARN(WARN_UNINITIALIZED))
634 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
635 paren = RX_LASTPAREN(rx);
640 case '\016': /* ^N */
641 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
642 paren = RX_LASTCLOSEPAREN(rx);
649 if (!SvPOK(sv) && SvNIOK(sv)) {
657 #define SvRTRIM(sv) STMT_START { \
659 STRLEN len = SvCUR(sv); \
660 char * const p = SvPVX(sv); \
661 while (len > 0 && isSPACE(p[len-1])) \
663 SvCUR_set(sv, len); \
669 Perl_emulate_cop_io(pTHX_ const COP *const c, SV *const sv)
671 if (!(CopHINTS_get(c) & (HINT_LEXICAL_IO_IN|HINT_LEXICAL_IO_OUT)))
672 sv_setsv(sv, &PL_sv_undef);
676 if ((CopHINTS_get(c) & HINT_LEXICAL_IO_IN)) {
677 SV *const value = Perl_refcounted_he_fetch(aTHX_
679 0, "open<", 5, 0, 0);
684 if ((CopHINTS_get(c) & HINT_LEXICAL_IO_OUT)) {
685 SV *const value = Perl_refcounted_he_fetch(aTHX_
687 0, "open>", 5, 0, 0);
695 Perl_magic_get(pTHX_ SV *sv, MAGIC *mg)
699 register char *s = NULL;
701 const char * const remaining = mg->mg_ptr + 1;
702 const char nextchar = *remaining;
704 switch (*mg->mg_ptr) {
705 case '\001': /* ^A */
706 sv_setsv(sv, PL_bodytarget);
708 case '\003': /* ^C, ^CHILD_ERROR_NATIVE */
709 if (nextchar == '\0') {
710 sv_setiv(sv, (IV)PL_minus_c);
712 else if (strEQ(remaining, "HILD_ERROR_NATIVE")) {
713 sv_setiv(sv, (IV)STATUS_NATIVE);
717 case '\004': /* ^D */
718 sv_setiv(sv, (IV)(PL_debug & DEBUG_MASK));
720 case '\005': /* ^E */
721 if (nextchar == '\0') {
722 #if defined(MACOS_TRADITIONAL)
726 sv_setnv(sv,(double)gMacPerl_OSErr);
727 sv_setpv(sv, gMacPerl_OSErr ? GetSysErrText(gMacPerl_OSErr, msg) : "");
731 # include <descrip.h>
732 # include <starlet.h>
734 $DESCRIPTOR(msgdsc,msg);
735 sv_setnv(sv,(NV) vaxc$errno);
736 if (sys$getmsg(vaxc$errno,&msgdsc.dsc$w_length,&msgdsc,0,0) & 1)
737 sv_setpvn(sv,msgdsc.dsc$a_pointer,msgdsc.dsc$w_length);
742 if (!(_emx_env & 0x200)) { /* Under DOS */
743 sv_setnv(sv, (NV)errno);
744 sv_setpv(sv, errno ? Strerror(errno) : "");
746 if (errno != errno_isOS2) {
747 const int tmp = _syserrno();
748 if (tmp) /* 2nd call to _syserrno() makes it 0 */
751 sv_setnv(sv, (NV)Perl_rc);
752 sv_setpv(sv, os2error(Perl_rc));
756 const DWORD dwErr = GetLastError();
757 sv_setnv(sv, (NV)dwErr);
759 PerlProc_GetOSError(sv, dwErr);
762 sv_setpvn(sv, "", 0);
767 const int saveerrno = errno;
768 sv_setnv(sv, (NV)errno);
769 sv_setpv(sv, errno ? Strerror(errno) : "");
774 SvNOK_on(sv); /* what a wonderful hack! */
776 else if (strEQ(remaining, "NCODING"))
777 sv_setsv(sv, PL_encoding);
779 case '\006': /* ^F */
780 sv_setiv(sv, (IV)PL_maxsysfd);
782 case '\010': /* ^H */
783 sv_setiv(sv, (IV)PL_hints);
785 case '\011': /* ^I */ /* NOT \t in EBCDIC */
786 sv_setpv(sv, PL_inplace); /* Will undefine sv if PL_inplace is NULL */
788 case '\017': /* ^O & ^OPEN */
789 if (nextchar == '\0') {
790 sv_setpv(sv, PL_osname);
793 else if (strEQ(remaining, "PEN")) {
794 Perl_emulate_cop_io(aTHX_ &PL_compiling, sv);
798 if (nextchar == '\0') { /* ^P */
799 sv_setiv(sv, (IV)PL_perldb);
800 } else if (strEQ(remaining, "REMATCH")) { /* $^PREMATCH */
801 goto do_prematch_fetch;
802 } else if (strEQ(remaining, "OSTMATCH")) { /* $^POSTMATCH */
803 goto do_postmatch_fetch;
806 case '\023': /* ^S */
807 if (nextchar == '\0') {
808 if (PL_parser && PL_parser->lex_state != LEX_NOTPARSING)
811 sv_setiv(sv, PL_in_eval & ~(EVAL_INREQUIRE));
816 case '\024': /* ^T */
817 if (nextchar == '\0') {
819 sv_setnv(sv, PL_basetime);
821 sv_setiv(sv, (IV)PL_basetime);
824 else if (strEQ(remaining, "AINT"))
825 sv_setiv(sv, PL_tainting
826 ? (PL_taint_warn || PL_unsafe ? -1 : 1)
829 case '\025': /* $^UNICODE, $^UTF8LOCALE, $^UTF8CACHE */
830 if (strEQ(remaining, "NICODE"))
831 sv_setuv(sv, (UV) PL_unicode);
832 else if (strEQ(remaining, "TF8LOCALE"))
833 sv_setuv(sv, (UV) PL_utf8locale);
834 else if (strEQ(remaining, "TF8CACHE"))
835 sv_setiv(sv, (IV) PL_utf8cache);
837 case '\027': /* ^W & $^WARNING_BITS */
838 if (nextchar == '\0')
839 sv_setiv(sv, (IV)((PL_dowarn & G_WARN_ON) ? TRUE : FALSE));
840 else if (strEQ(remaining, "ARNING_BITS")) {
841 if (PL_compiling.cop_warnings == pWARN_NONE) {
842 sv_setpvn(sv, WARN_NONEstring, WARNsize) ;
844 else if (PL_compiling.cop_warnings == pWARN_STD) {
847 (PL_dowarn & G_WARN_ON) ? WARN_ALLstring : WARN_NONEstring,
851 else if (PL_compiling.cop_warnings == pWARN_ALL) {
852 /* Get the bit mask for $warnings::Bits{all}, because
853 * it could have been extended by warnings::register */
854 HV * const bits=get_hv("warnings::Bits", FALSE);
856 SV ** const bits_all = hv_fetchs(bits, "all", FALSE);
858 sv_setsv(sv, *bits_all);
861 sv_setpvn(sv, WARN_ALLstring, WARNsize) ;
865 sv_setpvn(sv, (char *) (PL_compiling.cop_warnings + 1),
866 *PL_compiling.cop_warnings);
871 case '\015': /* $^MATCH */
872 if (strEQ(remaining, "ATCH")) {
873 case '1': case '2': case '3': case '4':
874 case '5': case '6': case '7': case '8': case '9': case '&':
875 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
877 * Pre-threads, this was paren = atoi(GvENAME((GV*)mg->mg_obj));
878 * XXX Does the new way break anything?
880 paren = atoi(mg->mg_ptr); /* $& is in [0] */
881 CALLREG_NUMBUF_FETCH(rx,paren,sv);
884 sv_setsv(sv,&PL_sv_undef);
888 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
889 if (RX_LASTPAREN(rx)) {
890 CALLREG_NUMBUF_FETCH(rx,RX_LASTPAREN(rx),sv);
894 sv_setsv(sv,&PL_sv_undef);
896 case '\016': /* ^N */
897 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
898 if (RX_LASTCLOSEPAREN(rx)) {
899 CALLREG_NUMBUF_FETCH(rx,RX_LASTCLOSEPAREN(rx),sv);
904 sv_setsv(sv,&PL_sv_undef);
908 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
909 CALLREG_NUMBUF_FETCH(rx,-2,sv);
912 sv_setsv(sv,&PL_sv_undef);
916 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
917 CALLREG_NUMBUF_FETCH(rx,-1,sv);
920 sv_setsv(sv,&PL_sv_undef);
923 if (GvIO(PL_last_in_gv)) {
924 sv_setiv(sv, (IV)IoLINES(GvIOp(PL_last_in_gv)));
929 sv_setiv(sv, (IV)STATUS_CURRENT);
930 #ifdef COMPLEX_STATUS
931 LvTARGOFF(sv) = PL_statusvalue;
932 LvTARGLEN(sv) = PL_statusvalue_vms;
937 if (GvIOp(PL_defoutgv))
938 s = IoTOP_NAME(GvIOp(PL_defoutgv));
942 sv_setpv(sv,GvENAME(PL_defoutgv));
943 sv_catpvs(sv,"_TOP");
947 if (GvIOp(PL_defoutgv))
948 s = IoFMT_NAME(GvIOp(PL_defoutgv));
950 s = GvENAME(PL_defoutgv);
954 if (GvIOp(PL_defoutgv))
955 sv_setiv(sv, (IV)IoPAGE_LEN(GvIOp(PL_defoutgv)));
958 if (GvIOp(PL_defoutgv))
959 sv_setiv(sv, (IV)IoLINES_LEFT(GvIOp(PL_defoutgv)));
962 if (GvIOp(PL_defoutgv))
963 sv_setiv(sv, (IV)IoPAGE(GvIOp(PL_defoutgv)));
970 sv_setiv(sv, (IV)CopARYBASE_get(PL_curcop));
973 if (GvIOp(PL_defoutgv))
974 sv_setiv(sv, (IV)(IoFLAGS(GvIOp(PL_defoutgv)) & IOf_FLUSH) != 0 );
980 sv_copypv(sv, PL_ors_sv);
984 sv_setnv(sv, (NV)((errno == EVMSERR) ? vaxc$errno : errno));
985 sv_setpv(sv, errno ? Strerror(errno) : "");
988 const int saveerrno = errno;
989 sv_setnv(sv, (NV)errno);
991 if (errno == errno_isOS2 || errno == errno_isOS2_set)
992 sv_setpv(sv, os2error(Perl_rc));
995 sv_setpv(sv, errno ? Strerror(errno) : "");
1000 SvNOK_on(sv); /* what a wonderful hack! */
1003 sv_setiv(sv, (IV)PL_uid);
1006 sv_setiv(sv, (IV)PL_euid);
1009 sv_setiv(sv, (IV)PL_gid);
1012 sv_setiv(sv, (IV)PL_egid);
1014 #ifdef HAS_GETGROUPS
1016 Groups_t *gary = NULL;
1017 I32 i, num_groups = getgroups(0, gary);
1018 Newx(gary, num_groups, Groups_t);
1019 num_groups = getgroups(num_groups, gary);
1020 for (i = 0; i < num_groups; i++)
1021 Perl_sv_catpvf(aTHX_ sv, " %"IVdf, (IV)gary[i]);
1024 (void)SvIOK_on(sv); /* what a wonderful hack! */
1027 #ifndef MACOS_TRADITIONAL
1036 Perl_magic_getuvar(pTHX_ SV *sv, MAGIC *mg)
1038 struct ufuncs * const uf = (struct ufuncs *)mg->mg_ptr;
1040 if (uf && uf->uf_val)
1041 (*uf->uf_val)(aTHX_ uf->uf_index, sv);
1046 Perl_magic_setenv(pTHX_ SV *sv, MAGIC *mg)
1049 STRLEN len = 0, klen;
1050 const char *s = SvOK(sv) ? SvPV_const(sv,len) : "";
1051 const char * const ptr = MgPV_const(mg,klen);
1054 #ifdef DYNAMIC_ENV_FETCH
1055 /* We just undefd an environment var. Is a replacement */
1056 /* waiting in the wings? */
1058 SV ** const valp = hv_fetch(GvHVn(PL_envgv), ptr, klen, FALSE);
1060 s = SvOK(*valp) ? SvPV_const(*valp, len) : "";
1064 #if !defined(OS2) && !defined(AMIGAOS) && !defined(WIN32) && !defined(MSDOS)
1065 /* And you'll never guess what the dog had */
1066 /* in its mouth... */
1068 MgTAINTEDDIR_off(mg);
1070 if (s && klen == 8 && strEQ(ptr, "DCL$PATH")) {
1071 char pathbuf[256], eltbuf[256], *cp, *elt;
1075 my_strlcpy(eltbuf, s, sizeof(eltbuf));
1077 do { /* DCL$PATH may be a search list */
1078 while (1) { /* as may dev portion of any element */
1079 if ( ((cp = strchr(elt,'[')) || (cp = strchr(elt,'<'))) ) {
1080 if ( *(cp+1) == '.' || *(cp+1) == '-' ||
1081 cando_by_name(S_IWUSR,0,elt) ) {
1082 MgTAINTEDDIR_on(mg);
1086 if ((cp = strchr(elt, ':')) != NULL)
1088 if (my_trnlnm(elt, eltbuf, j++))
1094 } while (my_trnlnm(s, pathbuf, i++) && (elt = pathbuf));
1097 if (s && klen == 4 && strEQ(ptr,"PATH")) {
1098 const char * const strend = s + len;
1100 while (s < strend) {
1104 #ifdef VMS /* Hmm. How do we get $Config{path_sep} from C? */
1105 const char path_sep = '|';
1107 const char path_sep = ':';
1109 s = delimcpy(tmpbuf, tmpbuf + sizeof tmpbuf,
1110 s, strend, path_sep, &i);
1112 if (i >= (I32)sizeof tmpbuf /* too long -- assume the worst */
1114 || !strchr(tmpbuf, ':') /* no colon thus no device name -- assume relative path */
1116 || *tmpbuf != '/' /* no starting slash -- assume relative path */
1118 || (PerlLIO_stat(tmpbuf, &st) == 0 && (st.st_mode & 2)) ) {
1119 MgTAINTEDDIR_on(mg);
1125 #endif /* neither OS2 nor AMIGAOS nor WIN32 nor MSDOS */
1131 Perl_magic_clearenv(pTHX_ SV *sv, MAGIC *mg)
1133 PERL_UNUSED_ARG(sv);
1134 my_setenv(MgPV_nolen_const(mg),NULL);
1139 Perl_magic_set_all_env(pTHX_ SV *sv, MAGIC *mg)
1142 PERL_UNUSED_ARG(mg);
1144 Perl_die(aTHX_ "Can't make list assignment to %%ENV on this system");
1146 if (PL_localizing) {
1149 hv_iterinit((HV*)sv);
1150 while ((entry = hv_iternext((HV*)sv))) {
1152 my_setenv(hv_iterkey(entry, &keylen),
1153 SvPV_nolen_const(hv_iterval((HV*)sv, entry)));
1161 Perl_magic_clear_all_env(pTHX_ SV *sv, MAGIC *mg)
1164 PERL_UNUSED_ARG(sv);
1165 PERL_UNUSED_ARG(mg);
1167 Perl_die(aTHX_ "Can't make list assignment to %%ENV on this system");
1175 #ifdef HAS_SIGPROCMASK
1177 restore_sigmask(pTHX_ SV *save_sv)
1179 const sigset_t * const ossetp = (const sigset_t *) SvPV_nolen_const( save_sv );
1180 (void)sigprocmask(SIG_SETMASK, ossetp, NULL);
1184 Perl_magic_getsig(pTHX_ SV *sv, MAGIC *mg)
1187 /* Are we fetching a signal entry? */
1188 const I32 i = whichsig(MgPV_nolen_const(mg));
1191 sv_setsv(sv,PL_psig_ptr[i]);
1193 Sighandler_t sigstate = rsignal_state(i);
1194 #ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1195 if (PL_sig_handlers_initted && PL_sig_ignoring[i])
1198 #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1199 if (PL_sig_handlers_initted && PL_sig_defaulting[i])
1202 /* cache state so we don't fetch it again */
1203 if(sigstate == (Sighandler_t) SIG_IGN)
1204 sv_setpvs(sv,"IGNORE");
1206 sv_setsv(sv,&PL_sv_undef);
1207 PL_psig_ptr[i] = SvREFCNT_inc_simple_NN(sv);
1214 Perl_magic_clearsig(pTHX_ SV *sv, MAGIC *mg)
1216 /* XXX Some of this code was copied from Perl_magic_setsig. A little
1217 * refactoring might be in order.
1220 register const char * const s = MgPV_nolen_const(mg);
1221 PERL_UNUSED_ARG(sv);
1224 if (strEQ(s,"__DIE__"))
1226 else if (strEQ(s,"__WARN__") && PL_warnhook != PERL_WARNHOOK_FATAL)
1229 SV *const to_dec = *svp;
1231 SvREFCNT_dec(to_dec);
1235 /* Are we clearing a signal entry? */
1236 const I32 i = whichsig(s);
1238 #ifdef HAS_SIGPROCMASK
1241 /* Avoid having the signal arrive at a bad time, if possible. */
1244 sigprocmask(SIG_BLOCK, &set, &save);
1246 save_sv = newSVpvn((char *)(&save), sizeof(sigset_t));
1247 SAVEFREESV(save_sv);
1248 SAVEDESTRUCTOR_X(restore_sigmask, save_sv);
1251 #if defined(FAKE_PERSISTENT_SIGNAL_HANDLERS) || defined(FAKE_DEFAULT_SIGNAL_HANDLERS)
1252 if (!PL_sig_handlers_initted) Perl_csighandler_init();
1254 #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1255 PL_sig_defaulting[i] = 1;
1256 (void)rsignal(i, PL_csighandlerp);
1258 (void)rsignal(i, (Sighandler_t) SIG_DFL);
1260 if(PL_psig_name[i]) {
1261 SvREFCNT_dec(PL_psig_name[i]);
1264 if(PL_psig_ptr[i]) {
1265 SV * const to_dec=PL_psig_ptr[i];
1268 SvREFCNT_dec(to_dec);
1278 * The signal handling nomenclature has gotten a bit confusing since the advent of
1279 * safe signals. S_raise_signal only raises signals by analogy with what the
1280 * underlying system's signal mechanism does. It might be more proper to say that
1281 * it defers signals that have already been raised and caught.
1283 * PL_sig_pending and PL_psig_pend likewise do not track signals that are pending
1284 * in the sense of being on the system's signal queue in between raising and delivery.
1285 * They are only pending on Perl's deferral list, i.e., they track deferred signals
1286 * awaiting delivery after the current Perl opcode completes and say nothing about
1287 * signals raised but not yet caught in the underlying signal implementation.
1290 #ifndef SIG_PENDING_DIE_COUNT
1291 # define SIG_PENDING_DIE_COUNT 120
1295 S_raise_signal(pTHX_ int sig)
1298 /* Set a flag to say this signal is pending */
1299 PL_psig_pend[sig]++;
1300 /* And one to say _a_ signal is pending */
1301 if (++PL_sig_pending >= SIG_PENDING_DIE_COUNT)
1302 Perl_croak(aTHX_ "Maximal count of pending signals (%lu) exceeded",
1303 (unsigned long)SIG_PENDING_DIE_COUNT);
1307 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
1308 Perl_csighandler(int sig, siginfo_t *sip PERL_UNUSED_DECL, void *uap PERL_UNUSED_DECL)
1310 Perl_csighandler(int sig)
1313 #ifdef PERL_GET_SIG_CONTEXT
1314 dTHXa(PERL_GET_SIG_CONTEXT);
1318 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
1320 #ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1321 (void) rsignal(sig, PL_csighandlerp);
1322 if (PL_sig_ignoring[sig]) return;
1324 #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1325 if (PL_sig_defaulting[sig])
1326 #ifdef KILL_BY_SIGPRC
1327 exit((Perl_sig_to_vmscondition(sig)&STS$M_COND_ID)|STS$K_SEVERE|STS$M_INHIB_MSG);
1332 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
1344 (PL_signals & PERL_SIGNALS_UNSAFE_FLAG))
1345 /* Call the perl level handler now--
1346 * with risk we may be in malloc() etc. */
1347 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
1348 (*PL_sighandlerp)(sig, NULL, NULL);
1350 (*PL_sighandlerp)(sig);
1353 S_raise_signal(aTHX_ sig);
1356 #if defined(FAKE_PERSISTENT_SIGNAL_HANDLERS) || defined(FAKE_DEFAULT_SIGNAL_HANDLERS)
1358 Perl_csighandler_init(void)
1361 if (PL_sig_handlers_initted) return;
1363 for (sig = 1; sig < SIG_SIZE; sig++) {
1364 #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1366 PL_sig_defaulting[sig] = 1;
1367 (void) rsignal(sig, PL_csighandlerp);
1369 #ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1370 PL_sig_ignoring[sig] = 0;
1373 PL_sig_handlers_initted = 1;
1378 Perl_despatch_signals(pTHX)
1383 for (sig = 1; sig < SIG_SIZE; sig++) {
1384 if (PL_psig_pend[sig]) {
1385 PERL_BLOCKSIG_ADD(set, sig);
1386 PL_psig_pend[sig] = 0;
1387 PERL_BLOCKSIG_BLOCK(set);
1388 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
1389 (*PL_sighandlerp)(sig, NULL, NULL);
1391 (*PL_sighandlerp)(sig);
1393 PERL_BLOCKSIG_UNBLOCK(set);
1399 Perl_magic_setsig(pTHX_ SV *sv, MAGIC *mg)
1404 /* Need to be careful with SvREFCNT_dec(), because that can have side
1405 * effects (due to closures). We must make sure that the new disposition
1406 * is in place before it is called.
1410 #ifdef HAS_SIGPROCMASK
1415 register const char *s = MgPV_const(mg,len);
1417 if (strEQ(s,"__DIE__"))
1419 else if (strEQ(s,"__WARN__"))
1422 Perl_croak(aTHX_ "No such hook: %s", s);
1425 if (*svp != PERL_WARNHOOK_FATAL)
1431 i = whichsig(s); /* ...no, a brick */
1433 if (ckWARN(WARN_SIGNAL))
1434 Perl_warner(aTHX_ packWARN(WARN_SIGNAL), "No such signal: SIG%s", s);
1437 #ifdef HAS_SIGPROCMASK
1438 /* Avoid having the signal arrive at a bad time, if possible. */
1441 sigprocmask(SIG_BLOCK, &set, &save);
1443 save_sv = newSVpvn((char *)(&save), sizeof(sigset_t));
1444 SAVEFREESV(save_sv);
1445 SAVEDESTRUCTOR_X(restore_sigmask, save_sv);
1448 #if defined(FAKE_PERSISTENT_SIGNAL_HANDLERS) || defined(FAKE_DEFAULT_SIGNAL_HANDLERS)
1449 if (!PL_sig_handlers_initted) Perl_csighandler_init();
1451 #ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1452 PL_sig_ignoring[i] = 0;
1454 #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1455 PL_sig_defaulting[i] = 0;
1457 SvREFCNT_dec(PL_psig_name[i]);
1458 to_dec = PL_psig_ptr[i];
1459 PL_psig_ptr[i] = SvREFCNT_inc_simple_NN(sv);
1460 SvTEMP_off(sv); /* Make sure it doesn't go away on us */
1461 PL_psig_name[i] = newSVpvn(s, len);
1462 SvREADONLY_on(PL_psig_name[i]);
1464 if (SvTYPE(sv) == SVt_PVGV || SvROK(sv)) {
1466 (void)rsignal(i, PL_csighandlerp);
1467 #ifdef HAS_SIGPROCMASK
1472 *svp = SvREFCNT_inc_simple_NN(sv);
1474 SvREFCNT_dec(to_dec);
1477 s = SvOK(sv) ? SvPV_force(sv,len) : "DEFAULT";
1478 if (strEQ(s,"IGNORE")) {
1480 #ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1481 PL_sig_ignoring[i] = 1;
1482 (void)rsignal(i, PL_csighandlerp);
1484 (void)rsignal(i, (Sighandler_t) SIG_IGN);
1488 else if (strEQ(s,"DEFAULT") || !*s) {
1490 #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1492 PL_sig_defaulting[i] = 1;
1493 (void)rsignal(i, PL_csighandlerp);
1496 (void)rsignal(i, (Sighandler_t) SIG_DFL);
1501 * We should warn if HINT_STRICT_REFS, but without
1502 * access to a known hint bit in a known OP, we can't
1503 * tell whether HINT_STRICT_REFS is in force or not.
1505 if (!strchr(s,':') && !strchr(s,'\''))
1506 Perl_sv_insert(aTHX_ sv, 0, 0, STR_WITH_LEN("main::"));
1508 (void)rsignal(i, PL_csighandlerp);
1510 *svp = SvREFCNT_inc_simple_NN(sv);
1512 #ifdef HAS_SIGPROCMASK
1517 SvREFCNT_dec(to_dec);
1520 #endif /* !PERL_MICRO */
1523 Perl_magic_setisa(pTHX_ SV *sv, MAGIC *mg)
1527 PERL_UNUSED_ARG(sv);
1529 /* Bail out if destruction is going on */
1530 if(PL_dirty) return 0;
1532 /* Skip _isaelem because _isa will handle it shortly */
1533 if (PL_delaymagic & DM_ARRAY && mg->mg_type == PERL_MAGIC_isaelem)
1536 /* XXX Once it's possible, we need to
1537 detect that our @ISA is aliased in
1538 other stashes, and act on the stashes
1539 of all of the aliases */
1541 /* The first case occurs via setisa,
1542 the second via setisa_elem, which
1543 calls this same magic */
1545 SvTYPE(mg->mg_obj) == SVt_PVGV
1547 : (GV*)SvMAGIC(mg->mg_obj)->mg_obj
1550 mro_isa_changed_in(stash);
1556 Perl_magic_clearisa(pTHX_ SV *sv, MAGIC *mg)
1561 /* Bail out if destruction is going on */
1562 if(PL_dirty) return 0;
1566 /* XXX see comments in magic_setisa */
1568 SvTYPE(mg->mg_obj) == SVt_PVGV
1570 : (GV*)SvMAGIC(mg->mg_obj)->mg_obj
1573 mro_isa_changed_in(stash);
1579 Perl_magic_setamagic(pTHX_ SV *sv, MAGIC *mg)
1582 PERL_UNUSED_ARG(sv);
1583 PERL_UNUSED_ARG(mg);
1584 PL_amagic_generation++;
1590 Perl_magic_getnkeys(pTHX_ SV *sv, MAGIC *mg)
1592 HV * const hv = (HV*)LvTARG(sv);
1594 PERL_UNUSED_ARG(mg);
1597 (void) hv_iterinit(hv);
1598 if (! SvTIED_mg((SV*)hv, PERL_MAGIC_tied))
1601 while (hv_iternext(hv))
1606 sv_setiv(sv, (IV)i);
1611 Perl_magic_setnkeys(pTHX_ SV *sv, MAGIC *mg)
1613 PERL_UNUSED_ARG(mg);
1615 hv_ksplit((HV*)LvTARG(sv), SvIV(sv));
1620 /* caller is responsible for stack switching/cleanup */
1622 S_magic_methcall(pTHX_ SV *sv, const MAGIC *mg, const char *meth, I32 flags, int n, SV *val)
1629 PUSHs(SvTIED_obj(sv, mg));
1632 if (mg->mg_len >= 0)
1633 mPUSHp(mg->mg_ptr, mg->mg_len);
1634 else if (mg->mg_len == HEf_SVKEY)
1635 PUSHs((SV*)mg->mg_ptr);
1637 else if (mg->mg_type == PERL_MAGIC_tiedelem) {
1646 return call_method(meth, flags);
1650 S_magic_methpack(pTHX_ SV *sv, const MAGIC *mg, const char *meth)
1656 PUSHSTACKi(PERLSI_MAGIC);
1658 if (magic_methcall(sv, mg, meth, G_SCALAR, 2, NULL)) {
1659 sv_setsv(sv, *PL_stack_sp--);
1669 Perl_magic_getpack(pTHX_ SV *sv, MAGIC *mg)
1672 mg->mg_flags |= MGf_GSKIP;
1673 magic_methpack(sv,mg,"FETCH");
1678 Perl_magic_setpack(pTHX_ SV *sv, MAGIC *mg)
1682 PUSHSTACKi(PERLSI_MAGIC);
1683 magic_methcall(sv, mg, "STORE", G_SCALAR|G_DISCARD, 3, sv);
1690 Perl_magic_clearpack(pTHX_ SV *sv, MAGIC *mg)
1692 return magic_methpack(sv,mg,"DELETE");
1697 Perl_magic_sizepack(pTHX_ SV *sv, MAGIC *mg)
1704 PUSHSTACKi(PERLSI_MAGIC);
1705 if (magic_methcall(sv, mg, "FETCHSIZE", G_SCALAR, 2, NULL)) {
1706 sv = *PL_stack_sp--;
1707 retval = SvIV(sv)-1;
1709 Perl_croak(aTHX_ "FETCHSIZE returned a negative value");
1714 return (U32) retval;
1718 Perl_magic_wipepack(pTHX_ SV *sv, MAGIC *mg)
1723 PUSHSTACKi(PERLSI_MAGIC);
1725 XPUSHs(SvTIED_obj(sv, mg));
1727 call_method("CLEAR", G_SCALAR|G_DISCARD);
1735 Perl_magic_nextpack(pTHX_ SV *sv, MAGIC *mg, SV *key)
1738 const char * const meth = SvOK(key) ? "NEXTKEY" : "FIRSTKEY";
1742 PUSHSTACKi(PERLSI_MAGIC);
1745 PUSHs(SvTIED_obj(sv, mg));
1750 if (call_method(meth, G_SCALAR))
1751 sv_setsv(key, *PL_stack_sp--);
1760 Perl_magic_existspack(pTHX_ SV *sv, const MAGIC *mg)
1762 return magic_methpack(sv,mg,"EXISTS");
1766 Perl_magic_scalarpack(pTHX_ HV *hv, MAGIC *mg)
1770 SV * const tied = SvTIED_obj((SV*)hv, mg);
1771 HV * const pkg = SvSTASH((SV*)SvRV(tied));
1773 if (!gv_fetchmethod_autoload(pkg, "SCALAR", FALSE)) {
1775 if (HvEITER_get(hv))
1776 /* we are in an iteration so the hash cannot be empty */
1778 /* no xhv_eiter so now use FIRSTKEY */
1779 key = sv_newmortal();
1780 magic_nextpack((SV*)hv, mg, key);
1781 HvEITER_set(hv, NULL); /* need to reset iterator */
1782 return SvOK(key) ? &PL_sv_yes : &PL_sv_no;
1785 /* there is a SCALAR method that we can call */
1787 PUSHSTACKi(PERLSI_MAGIC);
1793 if (call_method("SCALAR", G_SCALAR))
1794 retval = *PL_stack_sp--;
1796 retval = &PL_sv_undef;
1803 Perl_magic_setdbline(pTHX_ SV *sv, MAGIC *mg)
1806 GV * const gv = PL_DBline;
1807 const I32 i = SvTRUE(sv);
1808 SV ** const svp = av_fetch(GvAV(gv),
1809 atoi(MgPV_nolen_const(mg)), FALSE);
1810 if (svp && SvIOKp(*svp)) {
1811 OP * const o = INT2PTR(OP*,SvIVX(*svp));
1813 /* set or clear breakpoint in the relevant control op */
1815 o->op_flags |= OPf_SPECIAL;
1817 o->op_flags &= ~OPf_SPECIAL;
1824 Perl_magic_getarylen(pTHX_ SV *sv, const MAGIC *mg)
1827 const AV * const obj = (AV*)mg->mg_obj;
1829 sv_setiv(sv, AvFILL(obj) + CopARYBASE_get(PL_curcop));
1837 Perl_magic_setarylen(pTHX_ SV *sv, MAGIC *mg)
1840 AV * const obj = (AV*)mg->mg_obj;
1842 av_fill(obj, SvIV(sv) - CopARYBASE_get(PL_curcop));
1844 if (ckWARN(WARN_MISC))
1845 Perl_warner(aTHX_ packWARN(WARN_MISC),
1846 "Attempt to set length of freed array");
1852 Perl_magic_freearylen_p(pTHX_ SV *sv, MAGIC *mg)
1855 PERL_UNUSED_ARG(sv);
1856 /* during global destruction, mg_obj may already have been freed */
1857 if (PL_in_clean_all)
1860 mg = mg_find (mg->mg_obj, PERL_MAGIC_arylen);
1863 /* arylen scalar holds a pointer back to the array, but doesn't own a
1864 reference. Hence the we (the array) are about to go away with it
1865 still pointing at us. Clear its pointer, else it would be pointing
1866 at free memory. See the comment in sv_magic about reference loops,
1867 and why it can't own a reference to us. */
1874 Perl_magic_getpos(pTHX_ SV *sv, MAGIC *mg)
1877 SV* const lsv = LvTARG(sv);
1878 PERL_UNUSED_ARG(mg);
1880 if (SvTYPE(lsv) >= SVt_PVMG && SvMAGIC(lsv)) {
1881 MAGIC * const found = mg_find(lsv, PERL_MAGIC_regex_global);
1882 if (found && found->mg_len >= 0) {
1883 I32 i = found->mg_len;
1885 sv_pos_b2u(lsv, &i);
1886 sv_setiv(sv, i + CopARYBASE_get(PL_curcop));
1895 Perl_magic_setpos(pTHX_ SV *sv, MAGIC *mg)
1898 SV* const lsv = LvTARG(sv);
1904 PERL_UNUSED_ARG(mg);
1906 if (SvTYPE(lsv) >= SVt_PVMG && SvMAGIC(lsv))
1907 found = mg_find(lsv, PERL_MAGIC_regex_global);
1913 #ifdef PERL_OLD_COPY_ON_WRITE
1915 sv_force_normal_flags(lsv, 0);
1917 found = sv_magicext(lsv, NULL, PERL_MAGIC_regex_global, &PL_vtbl_mglob,
1920 else if (!SvOK(sv)) {
1924 len = SvPOK(lsv) ? SvCUR(lsv) : sv_len(lsv);
1926 pos = SvIV(sv) - CopARYBASE_get(PL_curcop);
1929 ulen = sv_len_utf8(lsv);
1939 else if (pos > (SSize_t)len)
1944 sv_pos_u2b(lsv, &p, 0);
1948 found->mg_len = pos;
1949 found->mg_flags &= ~MGf_MINMATCH;
1955 Perl_magic_getsubstr(pTHX_ SV *sv, MAGIC *mg)
1958 SV * const lsv = LvTARG(sv);
1959 const char * const tmps = SvPV_const(lsv,len);
1960 I32 offs = LvTARGOFF(sv);
1961 I32 rem = LvTARGLEN(sv);
1962 PERL_UNUSED_ARG(mg);
1965 sv_pos_u2b(lsv, &offs, &rem);
1966 if (offs > (I32)len)
1968 if (rem + offs > (I32)len)
1970 sv_setpvn(sv, tmps + offs, (STRLEN)rem);
1977 Perl_magic_setsubstr(pTHX_ SV *sv, MAGIC *mg)
1981 const char * const tmps = SvPV_const(sv, len);
1982 SV * const lsv = LvTARG(sv);
1983 I32 lvoff = LvTARGOFF(sv);
1984 I32 lvlen = LvTARGLEN(sv);
1985 PERL_UNUSED_ARG(mg);
1988 sv_utf8_upgrade(lsv);
1989 sv_pos_u2b(lsv, &lvoff, &lvlen);
1990 sv_insert(lsv, lvoff, lvlen, tmps, len);
1991 LvTARGLEN(sv) = sv_len_utf8(sv);
1994 else if (lsv && SvUTF8(lsv)) {
1996 sv_pos_u2b(lsv, &lvoff, &lvlen);
1997 LvTARGLEN(sv) = len;
1998 utf8 = (char*)bytes_to_utf8((U8*)tmps, &len);
1999 sv_insert(lsv, lvoff, lvlen, utf8, len);
2003 sv_insert(lsv, lvoff, lvlen, tmps, len);
2004 LvTARGLEN(sv) = len;
2012 Perl_magic_gettaint(pTHX_ SV *sv, MAGIC *mg)
2015 PERL_UNUSED_ARG(sv);
2016 TAINT_IF((PL_localizing != 1) && (mg->mg_len & 1));
2021 Perl_magic_settaint(pTHX_ SV *sv, MAGIC *mg)
2024 PERL_UNUSED_ARG(sv);
2025 /* update taint status */
2034 Perl_magic_getvec(pTHX_ SV *sv, MAGIC *mg)
2036 SV * const lsv = LvTARG(sv);
2037 PERL_UNUSED_ARG(mg);
2040 sv_setuv(sv, do_vecget(lsv, LvTARGOFF(sv), LvTARGLEN(sv)));
2048 Perl_magic_setvec(pTHX_ SV *sv, MAGIC *mg)
2050 PERL_UNUSED_ARG(mg);
2051 do_vecset(sv); /* XXX slurp this routine */
2056 Perl_magic_getdefelem(pTHX_ SV *sv, MAGIC *mg)
2060 if (LvTARGLEN(sv)) {
2062 SV * const ahv = LvTARG(sv);
2063 HE * const he = hv_fetch_ent((HV*)ahv, mg->mg_obj, FALSE, 0);
2068 AV* const av = (AV*)LvTARG(sv);
2069 if ((I32)LvTARGOFF(sv) <= AvFILL(av))
2070 targ = AvARRAY(av)[LvTARGOFF(sv)];
2072 if (targ && (targ != &PL_sv_undef)) {
2073 /* somebody else defined it for us */
2074 SvREFCNT_dec(LvTARG(sv));
2075 LvTARG(sv) = SvREFCNT_inc_simple_NN(targ);
2077 SvREFCNT_dec(mg->mg_obj);
2079 mg->mg_flags &= ~MGf_REFCOUNTED;
2084 sv_setsv(sv, targ ? targ : &PL_sv_undef);
2089 Perl_magic_setdefelem(pTHX_ SV *sv, MAGIC *mg)
2091 PERL_UNUSED_ARG(mg);
2095 sv_setsv(LvTARG(sv), sv);
2096 SvSETMAGIC(LvTARG(sv));
2102 Perl_vivify_defelem(pTHX_ SV *sv)
2108 if (!LvTARGLEN(sv) || !(mg = mg_find(sv, PERL_MAGIC_defelem)))
2111 SV * const ahv = LvTARG(sv);
2112 HE * const he = hv_fetch_ent((HV*)ahv, mg->mg_obj, TRUE, 0);
2115 if (!value || value == &PL_sv_undef)
2116 Perl_croak(aTHX_ PL_no_helem_sv, SVfARG(mg->mg_obj));
2119 AV* const av = (AV*)LvTARG(sv);
2120 if ((I32)LvTARGLEN(sv) < 0 && (I32)LvTARGOFF(sv) > AvFILL(av))
2121 LvTARG(sv) = NULL; /* array can't be extended */
2123 SV* const * const svp = av_fetch(av, LvTARGOFF(sv), TRUE);
2124 if (!svp || (value = *svp) == &PL_sv_undef)
2125 Perl_croak(aTHX_ PL_no_aelem, (I32)LvTARGOFF(sv));
2128 SvREFCNT_inc_simple_void(value);
2129 SvREFCNT_dec(LvTARG(sv));
2132 SvREFCNT_dec(mg->mg_obj);
2134 mg->mg_flags &= ~MGf_REFCOUNTED;
2138 Perl_magic_killbackrefs(pTHX_ SV *sv, MAGIC *mg)
2140 return Perl_sv_kill_backrefs(aTHX_ sv, (AV*)mg->mg_obj);
2144 Perl_magic_setmglob(pTHX_ SV *sv, MAGIC *mg)
2146 PERL_UNUSED_CONTEXT;
2153 Perl_magic_setuvar(pTHX_ SV *sv, MAGIC *mg)
2155 const struct ufuncs * const uf = (struct ufuncs *)mg->mg_ptr;
2157 if (uf && uf->uf_set)
2158 (*uf->uf_set)(aTHX_ uf->uf_index, sv);
2163 Perl_magic_setregexp(pTHX_ SV *sv, MAGIC *mg)
2165 const char type = mg->mg_type;
2166 if (type == PERL_MAGIC_qr) {
2167 } else if (type == PERL_MAGIC_bm) {
2171 assert(type == PERL_MAGIC_fm);
2174 return sv_unmagic(sv, type);
2177 #ifdef USE_LOCALE_COLLATE
2179 Perl_magic_setcollxfrm(pTHX_ SV *sv, MAGIC *mg)
2182 * RenE<eacute> Descartes said "I think not."
2183 * and vanished with a faint plop.
2185 PERL_UNUSED_CONTEXT;
2186 PERL_UNUSED_ARG(sv);
2188 Safefree(mg->mg_ptr);
2194 #endif /* USE_LOCALE_COLLATE */
2196 /* Just clear the UTF-8 cache data. */
2198 Perl_magic_setutf8(pTHX_ SV *sv, MAGIC *mg)
2200 PERL_UNUSED_CONTEXT;
2201 PERL_UNUSED_ARG(sv);
2202 Safefree(mg->mg_ptr); /* The mg_ptr holds the pos cache. */
2204 mg->mg_len = -1; /* The mg_len holds the len cache. */
2209 Perl_magic_set(pTHX_ SV *sv, MAGIC *mg)
2212 register const char *s;
2214 register const REGEXP * rx;
2215 const char * const remaining = mg->mg_ptr + 1;
2219 switch (*mg->mg_ptr) {
2220 case '\015': /* $^MATCH */
2221 if (strEQ(remaining, "ATCH"))
2223 case '`': /* ${^PREMATCH} caught below */
2225 paren = RX_BUFF_IDX_PREMATCH;
2227 case '\'': /* ${^POSTMATCH} caught below */
2229 paren = RX_BUFF_IDX_POSTMATCH;
2233 paren = RX_BUFF_IDX_FULLMATCH;
2235 case '1': case '2': case '3': case '4':
2236 case '5': case '6': case '7': case '8': case '9':
2237 paren = atoi(mg->mg_ptr);
2239 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
2240 CALLREG_NUMBUF_STORE((REGEXP * const)rx,paren,sv);
2243 /* Croak with a READONLY error when a numbered match var is
2244 * set without a previous pattern match. Unless it's C<local $1>
2246 if (!PL_localizing) {
2247 Perl_croak(aTHX_ PL_no_modify);
2250 case '\001': /* ^A */
2251 sv_setsv(PL_bodytarget, sv);
2253 case '\003': /* ^C */
2254 PL_minus_c = (bool)SvIV(sv);
2257 case '\004': /* ^D */
2259 s = SvPV_nolen_const(sv);
2260 PL_debug = get_debug_opts(&s, 0) | DEBUG_TOP_FLAG;
2261 DEBUG_x(dump_all());
2263 PL_debug = (SvIV(sv)) | DEBUG_TOP_FLAG;
2266 case '\005': /* ^E */
2267 if (*(mg->mg_ptr+1) == '\0') {
2268 #ifdef MACOS_TRADITIONAL
2269 gMacPerl_OSErr = SvIV(sv);
2272 set_vaxc_errno(SvIV(sv));
2275 SetLastError( SvIV(sv) );
2278 os2_setsyserrno(SvIV(sv));
2280 /* will anyone ever use this? */
2281 SETERRNO(SvIV(sv), 4);
2287 else if (strEQ(mg->mg_ptr+1, "NCODING")) {
2289 SvREFCNT_dec(PL_encoding);
2290 if (SvOK(sv) || SvGMAGICAL(sv)) {
2291 PL_encoding = newSVsv(sv);
2298 case '\006': /* ^F */
2299 PL_maxsysfd = SvIV(sv);
2301 case '\010': /* ^H */
2302 PL_hints = SvIV(sv);
2304 case '\011': /* ^I */ /* NOT \t in EBCDIC */
2305 Safefree(PL_inplace);
2306 PL_inplace = SvOK(sv) ? savesvpv(sv) : NULL;
2308 case '\017': /* ^O */
2309 if (*(mg->mg_ptr+1) == '\0') {
2310 Safefree(PL_osname);
2313 TAINT_PROPER("assigning to $^O");
2314 PL_osname = savesvpv(sv);
2317 else if (strEQ(mg->mg_ptr, "\017PEN")) {
2319 const char *const start = SvPV(sv, len);
2320 const char *out = (const char*)memchr(start, '\0', len);
2322 struct refcounted_he *tmp_he;
2325 PL_compiling.cop_hints |= HINT_LEXICAL_IO_IN | HINT_LEXICAL_IO_OUT;
2327 |= HINT_LOCALIZE_HH | HINT_LEXICAL_IO_IN | HINT_LEXICAL_IO_OUT;
2329 /* Opening for input is more common than opening for output, so
2330 ensure that hints for input are sooner on linked list. */
2331 tmp = out ? newSVpvn_flags(out + 1, start + len - out - 1,
2332 SVs_TEMP | SvUTF8(sv))
2333 : newSVpvn_flags("", 0, SVs_TEMP | SvUTF8(sv));
2336 = Perl_refcounted_he_new(aTHX_ PL_compiling.cop_hints_hash,
2337 newSVpvs_flags("open>", SVs_TEMP),
2340 /* The UTF-8 setting is carried over */
2341 sv_setpvn(tmp, start, out ? (STRLEN)(out - start) : len);
2343 PL_compiling.cop_hints_hash
2344 = Perl_refcounted_he_new(aTHX_ tmp_he,
2345 newSVpvs_flags("open<", SVs_TEMP),
2349 case '\020': /* ^P */
2350 if (*remaining == '\0') { /* ^P */
2351 PL_perldb = SvIV(sv);
2352 if (PL_perldb && !PL_DBsingle)
2355 } else if (strEQ(remaining, "REMATCH")) { /* $^PREMATCH */
2357 } else if (strEQ(remaining, "OSTMATCH")) { /* $^POSTMATCH */
2360 case '\024': /* ^T */
2362 PL_basetime = (Time_t)(SvNOK(sv) ? SvNVX(sv) : sv_2nv(sv));
2364 PL_basetime = (Time_t)SvIV(sv);
2367 case '\025': /* ^UTF8CACHE */
2368 if (strEQ(mg->mg_ptr+1, "TF8CACHE")) {
2369 PL_utf8cache = (signed char) sv_2iv(sv);
2372 case '\027': /* ^W & $^WARNING_BITS */
2373 if (*(mg->mg_ptr+1) == '\0') {
2374 if ( ! (PL_dowarn & G_WARN_ALL_MASK)) {
2376 PL_dowarn = (PL_dowarn & ~G_WARN_ON)
2377 | (i ? G_WARN_ON : G_WARN_OFF) ;
2380 else if (strEQ(mg->mg_ptr+1, "ARNING_BITS")) {
2381 if ( ! (PL_dowarn & G_WARN_ALL_MASK)) {
2382 if (!SvPOK(sv) && PL_localizing) {
2383 sv_setpvn(sv, WARN_NONEstring, WARNsize);
2384 PL_compiling.cop_warnings = pWARN_NONE;
2389 int accumulate = 0 ;
2390 int any_fatals = 0 ;
2391 const char * const ptr = SvPV_const(sv, len) ;
2392 for (i = 0 ; i < len ; ++i) {
2393 accumulate |= ptr[i] ;
2394 any_fatals |= (ptr[i] & 0xAA) ;
2397 if (!specialWARN(PL_compiling.cop_warnings))
2398 PerlMemShared_free(PL_compiling.cop_warnings);
2399 PL_compiling.cop_warnings = pWARN_NONE;
2401 /* Yuck. I can't see how to abstract this: */
2402 else if (isWARN_on(((STRLEN *)SvPV_nolen_const(sv)) - 1,
2403 WARN_ALL) && !any_fatals) {
2404 if (!specialWARN(PL_compiling.cop_warnings))
2405 PerlMemShared_free(PL_compiling.cop_warnings);
2406 PL_compiling.cop_warnings = pWARN_ALL;
2407 PL_dowarn |= G_WARN_ONCE ;
2411 const char *const p = SvPV_const(sv, len);
2413 PL_compiling.cop_warnings
2414 = Perl_new_warnings_bitfield(aTHX_ PL_compiling.cop_warnings,
2417 if (isWARN_on(PL_compiling.cop_warnings, WARN_ONCE))
2418 PL_dowarn |= G_WARN_ONCE ;
2426 if (PL_localizing) {
2427 if (PL_localizing == 1)
2428 SAVESPTR(PL_last_in_gv);
2430 else if (SvOK(sv) && GvIO(PL_last_in_gv))
2431 IoLINES(GvIOp(PL_last_in_gv)) = SvIV(sv);
2434 Safefree(IoTOP_NAME(GvIOp(PL_defoutgv)));
2435 s = IoTOP_NAME(GvIOp(PL_defoutgv)) = savesvpv(sv);
2436 IoTOP_GV(GvIOp(PL_defoutgv)) = gv_fetchsv(sv, GV_ADD, SVt_PVIO);
2439 Safefree(IoFMT_NAME(GvIOp(PL_defoutgv)));
2440 s = IoFMT_NAME(GvIOp(PL_defoutgv)) = savesvpv(sv);
2441 IoFMT_GV(GvIOp(PL_defoutgv)) = gv_fetchsv(sv, GV_ADD, SVt_PVIO);
2444 IoPAGE_LEN(GvIOp(PL_defoutgv)) = (SvIV(sv));
2447 IoLINES_LEFT(GvIOp(PL_defoutgv)) = (SvIV(sv));
2448 if (IoLINES_LEFT(GvIOp(PL_defoutgv)) < 0L)
2449 IoLINES_LEFT(GvIOp(PL_defoutgv)) = 0L;
2452 IoPAGE(GvIOp(PL_defoutgv)) = (SvIV(sv));
2456 IO * const io = GvIOp(PL_defoutgv);
2459 if ((SvIV(sv)) == 0)
2460 IoFLAGS(io) &= ~IOf_FLUSH;
2462 if (!(IoFLAGS(io) & IOf_FLUSH)) {
2463 PerlIO *ofp = IoOFP(io);
2465 (void)PerlIO_flush(ofp);
2466 IoFLAGS(io) |= IOf_FLUSH;
2472 SvREFCNT_dec(PL_rs);
2473 PL_rs = newSVsv(sv);
2477 SvREFCNT_dec(PL_ors_sv);
2478 if (SvOK(sv) || SvGMAGICAL(sv)) {
2479 PL_ors_sv = newSVsv(sv);
2487 SvREFCNT_dec(PL_ofs_sv);
2488 if (SvOK(sv) || SvGMAGICAL(sv)) {
2489 PL_ofs_sv = newSVsv(sv);
2496 CopARYBASE_set(&PL_compiling, SvIV(sv));
2499 #ifdef COMPLEX_STATUS
2500 if (PL_localizing == 2) {
2501 PL_statusvalue = LvTARGOFF(sv);
2502 PL_statusvalue_vms = LvTARGLEN(sv);
2506 #ifdef VMSISH_STATUS
2508 STATUS_NATIVE_CHILD_SET((U32)SvIV(sv));
2511 STATUS_UNIX_EXIT_SET(SvIV(sv));
2516 # define PERL_VMS_BANG vaxc$errno
2518 # define PERL_VMS_BANG 0
2520 SETERRNO(SvIOK(sv) ? SvIVX(sv) : SvOK(sv) ? sv_2iv(sv) : 0,
2521 (SvIV(sv) == EVMSERR) ? 4 : PERL_VMS_BANG);
2526 if (PL_delaymagic) {
2527 PL_delaymagic |= DM_RUID;
2528 break; /* don't do magic till later */
2531 (void)setruid((Uid_t)PL_uid);
2534 (void)setreuid((Uid_t)PL_uid, (Uid_t)-1);
2536 #ifdef HAS_SETRESUID
2537 (void)setresuid((Uid_t)PL_uid, (Uid_t)-1, (Uid_t)-1);
2539 if (PL_uid == PL_euid) { /* special case $< = $> */
2541 /* workaround for Darwin's setuid peculiarity, cf [perl #24122] */
2542 if (PL_uid != 0 && PerlProc_getuid() == 0)
2543 (void)PerlProc_setuid(0);
2545 (void)PerlProc_setuid(PL_uid);
2547 PL_uid = PerlProc_getuid();
2548 Perl_croak(aTHX_ "setruid() not implemented");
2553 PL_uid = PerlProc_getuid();
2554 PL_tainting |= (PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid));
2558 if (PL_delaymagic) {
2559 PL_delaymagic |= DM_EUID;
2560 break; /* don't do magic till later */
2563 (void)seteuid((Uid_t)PL_euid);
2566 (void)setreuid((Uid_t)-1, (Uid_t)PL_euid);
2568 #ifdef HAS_SETRESUID
2569 (void)setresuid((Uid_t)-1, (Uid_t)PL_euid, (Uid_t)-1);
2571 if (PL_euid == PL_uid) /* special case $> = $< */
2572 PerlProc_setuid(PL_euid);
2574 PL_euid = PerlProc_geteuid();
2575 Perl_croak(aTHX_ "seteuid() not implemented");
2580 PL_euid = PerlProc_geteuid();
2581 PL_tainting |= (PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid));
2585 if (PL_delaymagic) {
2586 PL_delaymagic |= DM_RGID;
2587 break; /* don't do magic till later */
2590 (void)setrgid((Gid_t)PL_gid);
2593 (void)setregid((Gid_t)PL_gid, (Gid_t)-1);
2595 #ifdef HAS_SETRESGID
2596 (void)setresgid((Gid_t)PL_gid, (Gid_t)-1, (Gid_t) 1);
2598 if (PL_gid == PL_egid) /* special case $( = $) */
2599 (void)PerlProc_setgid(PL_gid);
2601 PL_gid = PerlProc_getgid();
2602 Perl_croak(aTHX_ "setrgid() not implemented");
2607 PL_gid = PerlProc_getgid();
2608 PL_tainting |= (PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid));
2611 #ifdef HAS_SETGROUPS
2613 const char *p = SvPV_const(sv, len);
2614 Groups_t *gary = NULL;
2619 for (i = 0; i < NGROUPS; ++i) {
2620 while (*p && !isSPACE(*p))
2627 Newx(gary, i + 1, Groups_t);
2629 Renew(gary, i + 1, Groups_t);
2633 (void)setgroups(i, gary);
2636 #else /* HAS_SETGROUPS */
2638 #endif /* HAS_SETGROUPS */
2639 if (PL_delaymagic) {
2640 PL_delaymagic |= DM_EGID;
2641 break; /* don't do magic till later */
2644 (void)setegid((Gid_t)PL_egid);
2647 (void)setregid((Gid_t)-1, (Gid_t)PL_egid);
2649 #ifdef HAS_SETRESGID
2650 (void)setresgid((Gid_t)-1, (Gid_t)PL_egid, (Gid_t)-1);
2652 if (PL_egid == PL_gid) /* special case $) = $( */
2653 (void)PerlProc_setgid(PL_egid);
2655 PL_egid = PerlProc_getegid();
2656 Perl_croak(aTHX_ "setegid() not implemented");
2661 PL_egid = PerlProc_getegid();
2662 PL_tainting |= (PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid));
2665 PL_chopset = SvPV_force(sv,len);
2667 #ifndef MACOS_TRADITIONAL
2669 LOCK_DOLLARZERO_MUTEX;
2670 #ifdef HAS_SETPROCTITLE
2671 /* The BSDs don't show the argv[] in ps(1) output, they
2672 * show a string from the process struct and provide
2673 * the setproctitle() routine to manipulate that. */
2674 if (PL_origalen != 1) {
2675 s = SvPV_const(sv, len);
2676 # if __FreeBSD_version > 410001
2677 /* The leading "-" removes the "perl: " prefix,
2678 * but not the "(perl) suffix from the ps(1)
2679 * output, because that's what ps(1) shows if the
2680 * argv[] is modified. */
2681 setproctitle("-%s", s);
2682 # else /* old FreeBSDs, NetBSD, OpenBSD, anyBSD */
2683 /* This doesn't really work if you assume that
2684 * $0 = 'foobar'; will wipe out 'perl' from the $0
2685 * because in ps(1) output the result will be like
2686 * sprintf("perl: %s (perl)", s)
2687 * I guess this is a security feature:
2688 * one (a user process) cannot get rid of the original name.
2690 setproctitle("%s", s);
2693 #elif defined(__hpux) && defined(PSTAT_SETCMD)
2694 if (PL_origalen != 1) {
2696 s = SvPV_const(sv, len);
2697 un.pst_command = (char *)s;
2698 pstat(PSTAT_SETCMD, un, len, 0, 0);
2701 if (PL_origalen > 1) {
2702 /* PL_origalen is set in perl_parse(). */
2703 s = SvPV_force(sv,len);
2704 if (len >= (STRLEN)PL_origalen-1) {
2705 /* Longer than original, will be truncated. We assume that
2706 * PL_origalen bytes are available. */
2707 Copy(s, PL_origargv[0], PL_origalen-1, char);
2710 /* Shorter than original, will be padded. */
2712 /* Special case for Mac OS X: see [perl #38868] */
2715 /* Is the space counterintuitive? Yes.
2716 * (You were expecting \0?)
2717 * Does it work? Seems to. (In Linux 2.4.20 at least.)
2719 const int pad = ' ';
2721 Copy(s, PL_origargv[0], len, char);
2722 PL_origargv[0][len] = 0;
2723 memset(PL_origargv[0] + len + 1,
2724 pad, PL_origalen - len - 1);
2726 PL_origargv[0][PL_origalen-1] = 0;
2727 for (i = 1; i < PL_origargc; i++)
2731 UNLOCK_DOLLARZERO_MUTEX;
2739 Perl_whichsig(pTHX_ const char *sig)
2741 register char* const* sigv;
2742 PERL_UNUSED_CONTEXT;
2744 for (sigv = (char* const*)PL_sig_name; *sigv; sigv++)
2745 if (strEQ(sig,*sigv))
2746 return PL_sig_num[sigv - (char* const*)PL_sig_name];
2748 if (strEQ(sig,"CHLD"))
2752 if (strEQ(sig,"CLD"))
2759 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
2760 Perl_sighandler(int sig, siginfo_t *sip, void *uap PERL_UNUSED_DECL)
2762 Perl_sighandler(int sig)
2765 #ifdef PERL_GET_SIG_CONTEXT
2766 dTHXa(PERL_GET_SIG_CONTEXT);
2773 SV * const tSv = PL_Sv;
2777 XPV * const tXpv = PL_Xpv;
2779 if (PL_savestack_ix + 15 <= PL_savestack_max)
2781 if (PL_markstack_ptr < PL_markstack_max - 2)
2783 if (PL_scopestack_ix < PL_scopestack_max - 3)
2786 if (!PL_psig_ptr[sig]) {
2787 PerlIO_printf(Perl_error_log, "Signal SIG%s received, but no signal handler set.\n",
2792 /* Max number of items pushed there is 3*n or 4. We cannot fix
2793 infinity, so we fix 4 (in fact 5): */
2795 PL_savestack_ix += 5; /* Protect save in progress. */
2796 SAVEDESTRUCTOR_X(S_unwind_handler_stack, (void*)&flags);
2799 PL_markstack_ptr++; /* Protect mark. */
2801 PL_scopestack_ix += 1;
2802 /* sv_2cv is too complicated, try a simpler variant first: */
2803 if (!SvROK(PL_psig_ptr[sig]) || !(cv = (CV*)SvRV(PL_psig_ptr[sig]))
2804 || SvTYPE(cv) != SVt_PVCV) {
2806 cv = sv_2cv(PL_psig_ptr[sig], &st, &gv, GV_ADD);
2809 if (!cv || !CvROOT(cv)) {
2810 if (ckWARN(WARN_SIGNAL))
2811 Perl_warner(aTHX_ packWARN(WARN_SIGNAL), "SIG%s handler \"%s\" not defined.\n",
2812 PL_sig_name[sig], (gv ? GvENAME(gv)
2819 if(PL_psig_name[sig]) {
2820 sv = SvREFCNT_inc_NN(PL_psig_name[sig]);
2822 #if !defined(PERL_IMPLICIT_CONTEXT)
2826 sv = sv_newmortal();
2827 sv_setpv(sv,PL_sig_name[sig]);
2830 PUSHSTACKi(PERLSI_SIGNAL);
2833 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
2835 struct sigaction oact;
2837 if (sigaction(sig, 0, &oact) == 0 && oact.sa_flags & SA_SIGINFO) {
2840 SV *rv = newRV_noinc((SV*)sih);
2841 /* The siginfo fields signo, code, errno, pid, uid,
2842 * addr, status, and band are defined by POSIX/SUSv3. */
2843 (void)hv_stores(sih, "signo", newSViv(sip->si_signo));
2844 (void)hv_stores(sih, "code", newSViv(sip->si_code));
2845 #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. */
2846 hv_stores(sih, "errno", newSViv(sip->si_errno));
2847 hv_stores(sih, "status", newSViv(sip->si_status));
2848 hv_stores(sih, "uid", newSViv(sip->si_uid));
2849 hv_stores(sih, "pid", newSViv(sip->si_pid));
2850 hv_stores(sih, "addr", newSVuv(PTR2UV(sip->si_addr)));
2851 hv_stores(sih, "band", newSViv(sip->si_band));
2855 mPUSHp((char *)sip, sizeof(*sip));
2863 call_sv((SV*)cv, G_DISCARD|G_EVAL);
2866 if (SvTRUE(ERRSV)) {
2868 #ifdef HAS_SIGPROCMASK
2869 /* Handler "died", for example to get out of a restart-able read().
2870 * Before we re-do that on its behalf re-enable the signal which was
2871 * blocked by the system when we entered.
2875 sigaddset(&set,sig);
2876 sigprocmask(SIG_UNBLOCK, &set, NULL);
2878 /* Not clear if this will work */
2879 (void)rsignal(sig, SIG_IGN);
2880 (void)rsignal(sig, PL_csighandlerp);
2882 #endif /* !PERL_MICRO */
2883 Perl_die(aTHX_ NULL);
2887 PL_savestack_ix -= 8; /* Unprotect save in progress. */
2891 PL_scopestack_ix -= 1;
2894 PL_op = myop; /* Apparently not needed... */
2896 PL_Sv = tSv; /* Restore global temporaries. */
2903 S_restore_magic(pTHX_ const void *p)
2906 MGS* const mgs = SSPTR(PTR2IV(p), MGS*);
2907 SV* const sv = mgs->mgs_sv;
2912 if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv))
2914 #ifdef PERL_OLD_COPY_ON_WRITE
2915 /* While magic was saved (and off) sv_setsv may well have seen
2916 this SV as a prime candidate for COW. */
2918 sv_force_normal_flags(sv, 0);
2922 SvFLAGS(sv) |= mgs->mgs_flags;
2925 if (SvGMAGICAL(sv)) {
2926 /* downgrade public flags to private,
2927 and discard any other private flags */
2929 const U32 pubflags = SvFLAGS(sv) & (SVf_IOK|SVf_NOK|SVf_POK);
2931 SvFLAGS(sv) &= ~( pubflags | (SVp_IOK|SVp_NOK|SVp_POK) );
2932 SvFLAGS(sv) |= ( pubflags << PRIVSHIFT );
2937 mgs->mgs_sv = NULL; /* mark the MGS structure as restored */
2939 /* If we're still on top of the stack, pop us off. (That condition
2940 * will be satisfied if restore_magic was called explicitly, but *not*
2941 * if it's being called via leave_scope.)
2942 * The reason for doing this is that otherwise, things like sv_2cv()
2943 * may leave alloc gunk on the savestack, and some code
2944 * (e.g. sighandler) doesn't expect that...
2946 if (PL_savestack_ix == mgs->mgs_ss_ix)
2948 I32 popval = SSPOPINT;
2949 assert(popval == SAVEt_DESTRUCTOR_X);
2950 PL_savestack_ix -= 2;
2952 assert(popval == SAVEt_ALLOC);
2954 PL_savestack_ix -= popval;
2960 S_unwind_handler_stack(pTHX_ const void *p)
2963 const U32 flags = *(const U32*)p;
2966 PL_savestack_ix -= 5; /* Unprotect save in progress. */
2967 #if !defined(PERL_IMPLICIT_CONTEXT)
2969 SvREFCNT_dec(PL_sig_sv);
2974 =for apidoc magic_sethint
2976 Triggered by a store to %^H, records the key/value pair to
2977 C<PL_compiling.cop_hints_hash>. It is assumed that hints aren't storing
2978 anything that would need a deep copy. Maybe we should warn if we find a
2984 Perl_magic_sethint(pTHX_ SV *sv, MAGIC *mg)
2987 SV *key = (mg->mg_len == HEf_SVKEY) ? (SV *)mg->mg_ptr
2988 : newSVpvn_flags(mg->mg_ptr, mg->mg_len, SVs_TEMP);
2990 /* mg->mg_obj isn't being used. If needed, it would be possible to store
2991 an alternative leaf in there, with PL_compiling.cop_hints being used if
2992 it's NULL. If needed for threads, the alternative could lock a mutex,
2993 or take other more complex action. */
2995 /* Something changed in %^H, so it will need to be restored on scope exit.
2996 Doing this here saves a lot of doing it manually in perl code (and
2997 forgetting to do it, and consequent subtle errors. */
2998 PL_hints |= HINT_LOCALIZE_HH;
2999 PL_compiling.cop_hints_hash
3000 = Perl_refcounted_he_new(aTHX_ PL_compiling.cop_hints_hash, key, sv);
3005 =for apidoc magic_sethint
3007 Triggered by a delete from %^H, records the key to
3008 C<PL_compiling.cop_hints_hash>.
3013 Perl_magic_clearhint(pTHX_ SV *sv, MAGIC *mg)
3016 PERL_UNUSED_ARG(sv);
3018 assert(mg->mg_len == HEf_SVKEY);
3020 PERL_UNUSED_ARG(sv);
3022 PL_hints |= HINT_LOCALIZE_HH;
3023 PL_compiling.cop_hints_hash
3024 = Perl_refcounted_he_new(aTHX_ PL_compiling.cop_hints_hash,
3025 (SV *)mg->mg_ptr, &PL_sv_placeholder);
3031 * c-indentation-style: bsd
3033 * indent-tabs-mode: t
3036 * ex: set ts=8 sts=4 sw=4 noet: