1N/A/*
1N/A * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
1N/A * Use is subject to license terms.
1N/A */
1N/A/* mg.c
1N/A *
1N/A * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
1N/A * 2000, 2001, 2002, 2003, 2004, by Larry Wall and others
1N/A *
1N/A * You may distribute under the terms of either the GNU General Public
1N/A * License or the Artistic License, as specified in the README file.
1N/A *
1N/A */
1N/A
1N/A/*
1N/A * "Sam sat on the ground and put his head in his hands. 'I wish I had never
1N/A * come here, and I don't want to see no more magic,' he said, and fell silent."
1N/A */
1N/A
1N/A/*
1N/A=head1 Magical Functions
1N/A*/
1N/A
1N/A#include "EXTERN.h"
1N/A#define PERL_IN_MG_C
1N/A#include "perl.h"
1N/A
1N/A#if defined(HAS_GETGROUPS) || defined(HAS_SETGROUPS)
1N/A# ifndef NGROUPS
1N/A# define NGROUPS 32
1N/A# endif
1N/A# ifdef I_GRP
1N/A# include <grp.h>
1N/A# endif
1N/A#ifdef __sun
1N/A#include <alloca.h>
1N/A#include <unistd.h>
1N/A#endif
1N/A#endif
1N/A
1N/A#ifdef __hpux
1N/A# include <sys/pstat.h>
1N/A#endif
1N/A
1N/ASignal_t Perl_csighandler(int sig);
1N/A
1N/A/* if you only have signal() and it resets on each signal, FAKE_PERSISTENT_SIGNAL_HANDLERS fixes */
1N/A#if !defined(HAS_SIGACTION) && defined(VMS)
1N/A# define FAKE_PERSISTENT_SIGNAL_HANDLERS
1N/A#endif
1N/A/* if we're doing kill() with sys$sigprc on VMS, FAKE_DEFAULT_SIGNAL_HANDLERS */
1N/A#if defined(KILL_BY_SIGPRC)
1N/A# define FAKE_DEFAULT_SIGNAL_HANDLERS
1N/A#endif
1N/A
1N/Astatic void restore_magic(pTHX_ void *p);
1N/Astatic void unwind_handler_stack(pTHX_ void *p);
1N/A
1N/A#ifdef __Lynx__
1N/A/* Missing protos on LynxOS */
1N/Avoid setruid(uid_t id);
1N/Avoid seteuid(uid_t id);
1N/Avoid setrgid(uid_t id);
1N/Avoid setegid(uid_t id);
1N/A#endif
1N/A
1N/A/*
1N/A * Use the "DESTRUCTOR" scope cleanup to reinstate magic.
1N/A */
1N/A
1N/Astruct magic_state {
1N/A SV* mgs_sv;
1N/A U32 mgs_flags;
1N/A I32 mgs_ss_ix;
1N/A};
1N/A/* MGS is typedef'ed to struct magic_state in perl.h */
1N/A
1N/ASTATIC void
1N/AS_save_magic(pTHX_ I32 mgs_ix, SV *sv)
1N/A{
1N/A MGS* mgs;
1N/A assert(SvMAGICAL(sv));
1N/A
1N/A SAVEDESTRUCTOR_X(restore_magic, INT2PTR(void*, (IV)mgs_ix));
1N/A
1N/A mgs = SSPTR(mgs_ix, MGS*);
1N/A mgs->mgs_sv = sv;
1N/A mgs->mgs_flags = SvMAGICAL(sv) | SvREADONLY(sv);
1N/A mgs->mgs_ss_ix = PL_savestack_ix; /* points after the saved destructor */
1N/A
1N/A SvMAGICAL_off(sv);
1N/A SvREADONLY_off(sv);
1N/A SvFLAGS(sv) |= (SvFLAGS(sv) & (SVp_NOK|SVp_POK)) >> PRIVSHIFT;
1N/A}
1N/A
1N/A/*
1N/A=for apidoc mg_magical
1N/A
1N/ATurns on the magical status of an SV. See C<sv_magic>.
1N/A
1N/A=cut
1N/A*/
1N/A
1N/Avoid
1N/APerl_mg_magical(pTHX_ SV *sv)
1N/A{
1N/A MAGIC* mg;
1N/A for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
1N/A MGVTBL* vtbl = mg->mg_virtual;
1N/A if (vtbl) {
1N/A if (vtbl->svt_get && !(mg->mg_flags & MGf_GSKIP))
1N/A SvGMAGICAL_on(sv);
1N/A if (vtbl->svt_set)
1N/A SvSMAGICAL_on(sv);
1N/A if (!(SvFLAGS(sv) & (SVs_GMG|SVs_SMG)) || vtbl->svt_clear)
1N/A SvRMAGICAL_on(sv);
1N/A }
1N/A }
1N/A}
1N/A
1N/A/*
1N/A=for apidoc mg_get
1N/A
1N/ADo magic after a value is retrieved from the SV. See C<sv_magic>.
1N/A
1N/A=cut
1N/A*/
1N/A
1N/Aint
1N/APerl_mg_get(pTHX_ SV *sv)
1N/A{
1N/A int new = 0;
1N/A MAGIC *newmg, *head, *cur, *mg;
1N/A I32 mgs_ix = SSNEW(sizeof(MGS));
1N/A
1N/A save_magic(mgs_ix, sv);
1N/A
1N/A /* We must call svt_get(sv, mg) for each valid entry in the linked
1N/A list of magic. svt_get() may delete the current entry, add new
1N/A magic to the head of the list, or upgrade the SV. AMS 20010810 */
1N/A
1N/A newmg = cur = head = mg = SvMAGIC(sv);
1N/A while (mg) {
1N/A MGVTBL *vtbl = mg->mg_virtual;
1N/A
1N/A if (!(mg->mg_flags & MGf_GSKIP) && vtbl && vtbl->svt_get) {
1N/A CALL_FPTR(vtbl->svt_get)(aTHX_ sv, mg);
1N/A
1N/A /* guard against sv having been freed */
1N/A if (SvTYPE(sv) == SVTYPEMASK) {
1N/A Perl_croak(aTHX_ "Tied variable freed while still in use");
1N/A }
1N/A /* guard against magic having been deleted - eg FETCH calling
1N/A * untie */
1N/A if (!SvMAGIC(sv))
1N/A break;
1N/A
1N/A /* Don't restore the flags for this entry if it was deleted. */
1N/A if (mg->mg_flags & MGf_GSKIP)
1N/A (SSPTR(mgs_ix, MGS *))->mgs_flags = 0;
1N/A }
1N/A
1N/A mg = mg->mg_moremagic;
1N/A
1N/A if (new) {
1N/A /* Have we finished with the new entries we saw? Start again
1N/A where we left off (unless there are more new entries). */
1N/A if (mg == head) {
1N/A new = 0;
1N/A mg = cur;
1N/A head = newmg;
1N/A }
1N/A }
1N/A
1N/A /* Were any new entries added? */
1N/A if (!new && (newmg = SvMAGIC(sv)) != head) {
1N/A new = 1;
1N/A cur = mg;
1N/A mg = newmg;
1N/A }
1N/A }
1N/A
1N/A restore_magic(aTHX_ INT2PTR(void *, (IV)mgs_ix));
1N/A return 0;
1N/A}
1N/A
1N/A/*
1N/A=for apidoc mg_set
1N/A
1N/ADo magic after a value is assigned to the SV. See C<sv_magic>.
1N/A
1N/A=cut
1N/A*/
1N/A
1N/Aint
1N/APerl_mg_set(pTHX_ SV *sv)
1N/A{
1N/A I32 mgs_ix;
1N/A MAGIC* mg;
1N/A MAGIC* nextmg;
1N/A
1N/A mgs_ix = SSNEW(sizeof(MGS));
1N/A save_magic(mgs_ix, sv);
1N/A
1N/A for (mg = SvMAGIC(sv); mg; mg = nextmg) {
1N/A MGVTBL* vtbl = mg->mg_virtual;
1N/A nextmg = mg->mg_moremagic; /* it may delete itself */
1N/A if (mg->mg_flags & MGf_GSKIP) {
1N/A mg->mg_flags &= ~MGf_GSKIP; /* setting requires another read */
1N/A (SSPTR(mgs_ix, MGS*))->mgs_flags = 0;
1N/A }
1N/A if (vtbl && vtbl->svt_set)
1N/A CALL_FPTR(vtbl->svt_set)(aTHX_ sv, mg);
1N/A }
1N/A
1N/A restore_magic(aTHX_ INT2PTR(void*, (IV)mgs_ix));
1N/A return 0;
1N/A}
1N/A
1N/A/*
1N/A=for apidoc mg_length
1N/A
1N/AReport on the SV's length. See C<sv_magic>.
1N/A
1N/A=cut
1N/A*/
1N/A
1N/AU32
1N/APerl_mg_length(pTHX_ SV *sv)
1N/A{
1N/A MAGIC* mg;
1N/A STRLEN len;
1N/A
1N/A for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
1N/A MGVTBL* vtbl = mg->mg_virtual;
1N/A if (vtbl && vtbl->svt_len) {
1N/A I32 mgs_ix;
1N/A
1N/A mgs_ix = SSNEW(sizeof(MGS));
1N/A save_magic(mgs_ix, sv);
1N/A /* omit MGf_GSKIP -- not changed here */
1N/A len = CALL_FPTR(vtbl->svt_len)(aTHX_ sv, mg);
1N/A restore_magic(aTHX_ INT2PTR(void*, (IV)mgs_ix));
1N/A return len;
1N/A }
1N/A }
1N/A
1N/A if (DO_UTF8(sv))
1N/A {
1N/A U8 *s = (U8*)SvPV(sv, len);
1N/A len = Perl_utf8_length(aTHX_ s, s + len);
1N/A }
1N/A else
1N/A (void)SvPV(sv, len);
1N/A return len;
1N/A}
1N/A
1N/AI32
1N/APerl_mg_size(pTHX_ SV *sv)
1N/A{
1N/A MAGIC* mg;
1N/A I32 len;
1N/A
1N/A for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
1N/A MGVTBL* vtbl = mg->mg_virtual;
1N/A if (vtbl && vtbl->svt_len) {
1N/A I32 mgs_ix;
1N/A
1N/A mgs_ix = SSNEW(sizeof(MGS));
1N/A save_magic(mgs_ix, sv);
1N/A /* omit MGf_GSKIP -- not changed here */
1N/A len = CALL_FPTR(vtbl->svt_len)(aTHX_ sv, mg);
1N/A restore_magic(aTHX_ INT2PTR(void*, (IV)mgs_ix));
1N/A return len;
1N/A }
1N/A }
1N/A
1N/A switch(SvTYPE(sv)) {
1N/A case SVt_PVAV:
1N/A len = AvFILLp((AV *) sv); /* Fallback to non-tied array */
1N/A return len;
1N/A case SVt_PVHV:
1N/A /* FIXME */
1N/A default:
1N/A Perl_croak(aTHX_ "Size magic not implemented");
1N/A break;
1N/A }
1N/A return 0;
1N/A}
1N/A
1N/A/*
1N/A=for apidoc mg_clear
1N/A
1N/AClear something magical that the SV represents. See C<sv_magic>.
1N/A
1N/A=cut
1N/A*/
1N/A
1N/Aint
1N/APerl_mg_clear(pTHX_ SV *sv)
1N/A{
1N/A I32 mgs_ix;
1N/A MAGIC* mg;
1N/A
1N/A mgs_ix = SSNEW(sizeof(MGS));
1N/A save_magic(mgs_ix, sv);
1N/A
1N/A for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
1N/A MGVTBL* vtbl = mg->mg_virtual;
1N/A /* omit GSKIP -- never set here */
1N/A
1N/A if (vtbl && vtbl->svt_clear)
1N/A CALL_FPTR(vtbl->svt_clear)(aTHX_ sv, mg);
1N/A }
1N/A
1N/A restore_magic(aTHX_ INT2PTR(void*, (IV)mgs_ix));
1N/A return 0;
1N/A}
1N/A
1N/A/*
1N/A=for apidoc mg_find
1N/A
1N/AFinds the magic pointer for type matching the SV. See C<sv_magic>.
1N/A
1N/A=cut
1N/A*/
1N/A
1N/AMAGIC*
1N/APerl_mg_find(pTHX_ SV *sv, int type)
1N/A{
1N/A MAGIC* mg;
1N/A if (!sv)
1N/A return 0;
1N/A for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
1N/A if (mg->mg_type == type)
1N/A return mg;
1N/A }
1N/A return 0;
1N/A}
1N/A
1N/A/*
1N/A=for apidoc mg_copy
1N/A
1N/ACopies the magic from one SV to another. See C<sv_magic>.
1N/A
1N/A=cut
1N/A*/
1N/A
1N/Aint
1N/APerl_mg_copy(pTHX_ SV *sv, SV *nsv, const char *key, I32 klen)
1N/A{
1N/A int count = 0;
1N/A MAGIC* mg;
1N/A for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
1N/A MGVTBL* vtbl = mg->mg_virtual;
1N/A if ((mg->mg_flags & MGf_COPY) && vtbl->svt_copy){
1N/A count += CALL_FPTR(vtbl->svt_copy)(aTHX_ sv, mg, nsv, key, klen);
1N/A }
1N/A else if (isUPPER(mg->mg_type)) {
1N/A sv_magic(nsv,
1N/A mg->mg_type == PERL_MAGIC_tied ? SvTIED_obj(sv, mg) :
1N/A (mg->mg_type == PERL_MAGIC_regdata && mg->mg_obj)
1N/A ? sv : mg->mg_obj,
1N/A toLOWER(mg->mg_type), key, klen);
1N/A count++;
1N/A }
1N/A }
1N/A return count;
1N/A}
1N/A
1N/A/*
1N/A=for apidoc mg_free
1N/A
1N/AFree any magic storage used by the SV. See C<sv_magic>.
1N/A
1N/A=cut
1N/A*/
1N/A
1N/Aint
1N/APerl_mg_free(pTHX_ SV *sv)
1N/A{
1N/A MAGIC* mg;
1N/A MAGIC* moremagic;
1N/A for (mg = SvMAGIC(sv); mg; mg = moremagic) {
1N/A MGVTBL* vtbl = mg->mg_virtual;
1N/A moremagic = mg->mg_moremagic;
1N/A if (vtbl && vtbl->svt_free)
1N/A CALL_FPTR(vtbl->svt_free)(aTHX_ sv, mg);
1N/A if (mg->mg_ptr && mg->mg_type != PERL_MAGIC_regex_global) {
1N/A if (mg->mg_len > 0 || mg->mg_type == PERL_MAGIC_utf8)
1N/A Safefree(mg->mg_ptr);
1N/A else if (mg->mg_len == HEf_SVKEY)
1N/A SvREFCNT_dec((SV*)mg->mg_ptr);
1N/A }
1N/A if (mg->mg_flags & MGf_REFCOUNTED)
1N/A SvREFCNT_dec(mg->mg_obj);
1N/A Safefree(mg);
1N/A }
1N/A SvMAGIC(sv) = 0;
1N/A return 0;
1N/A}
1N/A
1N/A#include <signal.h>
1N/A
1N/AU32
1N/APerl_magic_regdata_cnt(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A register REGEXP *rx;
1N/A
1N/A if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
1N/A if (mg->mg_obj) /* @+ */
1N/A return rx->nparens;
1N/A else /* @- */
1N/A return rx->lastparen;
1N/A }
1N/A
1N/A return (U32)-1;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_regdatum_get(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A register I32 paren;
1N/A register I32 s;
1N/A register I32 i;
1N/A register REGEXP *rx;
1N/A I32 t;
1N/A
1N/A if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
1N/A paren = mg->mg_len;
1N/A if (paren < 0)
1N/A return 0;
1N/A if (paren <= (I32)rx->nparens &&
1N/A (s = rx->startp[paren]) != -1 &&
1N/A (t = rx->endp[paren]) != -1)
1N/A {
1N/A if (mg->mg_obj) /* @+ */
1N/A i = t;
1N/A else /* @- */
1N/A i = s;
1N/A
1N/A if (i > 0 && RX_MATCH_UTF8(rx)) {
1N/A char *b = rx->subbeg;
1N/A if (b)
1N/A i = Perl_utf8_length(aTHX_ (U8*)b, (U8*)(b+i));
1N/A }
1N/A
1N/A sv_setiv(sv, i);
1N/A }
1N/A }
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_regdatum_set(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A Perl_croak(aTHX_ PL_no_modify);
1N/A /* NOT REACHED */
1N/A return 0;
1N/A}
1N/A
1N/AU32
1N/APerl_magic_len(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A register I32 paren;
1N/A register I32 i;
1N/A register REGEXP *rx;
1N/A I32 s1, t1;
1N/A
1N/A switch (*mg->mg_ptr) {
1N/A case '1': case '2': case '3': case '4':
1N/A case '5': case '6': case '7': case '8': case '9': case '&':
1N/A if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
1N/A
1N/A paren = atoi(mg->mg_ptr); /* $& is in [0] */
1N/A getparen:
1N/A if (paren <= (I32)rx->nparens &&
1N/A (s1 = rx->startp[paren]) != -1 &&
1N/A (t1 = rx->endp[paren]) != -1)
1N/A {
1N/A i = t1 - s1;
1N/A getlen:
1N/A if (i > 0 && RX_MATCH_UTF8(rx)) {
1N/A char *s = rx->subbeg + s1;
1N/A char *send = rx->subbeg + t1;
1N/A
1N/A i = t1 - s1;
1N/A if (is_utf8_string((U8*)s, i))
1N/A i = Perl_utf8_length(aTHX_ (U8*)s, (U8*)send);
1N/A }
1N/A if (i < 0)
1N/A Perl_croak(aTHX_ "panic: magic_len: %"IVdf, (IV)i);
1N/A return i;
1N/A }
1N/A else {
1N/A if (ckWARN(WARN_UNINITIALIZED))
1N/A report_uninit();
1N/A }
1N/A }
1N/A else {
1N/A if (ckWARN(WARN_UNINITIALIZED))
1N/A report_uninit();
1N/A }
1N/A return 0;
1N/A case '+':
1N/A if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
1N/A paren = rx->lastparen;
1N/A if (paren)
1N/A goto getparen;
1N/A }
1N/A return 0;
1N/A case '\016': /* ^N */
1N/A if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
1N/A paren = rx->lastcloseparen;
1N/A if (paren)
1N/A goto getparen;
1N/A }
1N/A return 0;
1N/A case '`':
1N/A if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
1N/A if (rx->startp[0] != -1) {
1N/A i = rx->startp[0];
1N/A if (i > 0) {
1N/A s1 = 0;
1N/A t1 = i;
1N/A goto getlen;
1N/A }
1N/A }
1N/A }
1N/A return 0;
1N/A case '\'':
1N/A if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
1N/A if (rx->endp[0] != -1) {
1N/A i = rx->sublen - rx->endp[0];
1N/A if (i > 0) {
1N/A s1 = rx->endp[0];
1N/A t1 = rx->sublen;
1N/A goto getlen;
1N/A }
1N/A }
1N/A }
1N/A return 0;
1N/A }
1N/A magic_get(sv,mg);
1N/A if (!SvPOK(sv) && SvNIOK(sv)) {
1N/A STRLEN n_a;
1N/A sv_2pv(sv, &n_a);
1N/A }
1N/A if (SvPOK(sv))
1N/A return SvCUR(sv);
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_get(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A register I32 paren;
1N/A register char *s = NULL;
1N/A register I32 i;
1N/A register REGEXP *rx;
1N/A
1N/A switch (*mg->mg_ptr) {
1N/A case '\001': /* ^A */
1N/A sv_setsv(sv, PL_bodytarget);
1N/A break;
1N/A case '\003': /* ^C */
1N/A sv_setiv(sv, (IV)PL_minus_c);
1N/A break;
1N/A
1N/A case '\004': /* ^D */
1N/A sv_setiv(sv, (IV)(PL_debug & DEBUG_MASK));
1N/A#if defined(YYDEBUG) && defined(DEBUGGING)
1N/A PL_yydebug = DEBUG_p_TEST;
1N/A#endif
1N/A break;
1N/A case '\005': /* ^E */
1N/A if (*(mg->mg_ptr+1) == '\0') {
1N/A#ifdef MACOS_TRADITIONAL
1N/A {
1N/A char msg[256];
1N/A
1N/A sv_setnv(sv,(double)gMacPerl_OSErr);
1N/A sv_setpv(sv, gMacPerl_OSErr ? GetSysErrText(gMacPerl_OSErr, msg) : "");
1N/A }
1N/A#else
1N/A#ifdef VMS
1N/A {
1N/A# include <descrip.h>
1N/A# include <starlet.h>
1N/A char msg[255];
1N/A $DESCRIPTOR(msgdsc,msg);
1N/A sv_setnv(sv,(NV) vaxc$errno);
1N/A if (sys$getmsg(vaxc$errno,&msgdsc.dsc$w_length,&msgdsc,0,0) & 1)
1N/A sv_setpvn(sv,msgdsc.dsc$a_pointer,msgdsc.dsc$w_length);
1N/A else
1N/A sv_setpv(sv,"");
1N/A }
1N/A#else
1N/A#ifdef OS2
1N/A if (!(_emx_env & 0x200)) { /* Under DOS */
1N/A sv_setnv(sv, (NV)errno);
1N/A sv_setpv(sv, errno ? Strerror(errno) : "");
1N/A } else {
1N/A if (errno != errno_isOS2) {
1N/A int tmp = _syserrno();
1N/A if (tmp) /* 2nd call to _syserrno() makes it 0 */
1N/A Perl_rc = tmp;
1N/A }
1N/A sv_setnv(sv, (NV)Perl_rc);
1N/A sv_setpv(sv, os2error(Perl_rc));
1N/A }
1N/A#else
1N/A#ifdef WIN32
1N/A {
1N/A DWORD dwErr = GetLastError();
1N/A sv_setnv(sv, (NV)dwErr);
1N/A if (dwErr)
1N/A {
1N/A PerlProc_GetOSError(sv, dwErr);
1N/A }
1N/A else
1N/A sv_setpv(sv, "");
1N/A SetLastError(dwErr);
1N/A }
1N/A#else
1N/A {
1N/A int saveerrno = errno;
1N/A sv_setnv(sv, (NV)errno);
1N/A sv_setpv(sv, errno ? Strerror(errno) : "");
1N/A errno = saveerrno;
1N/A }
1N/A#endif
1N/A#endif
1N/A#endif
1N/A#endif
1N/A SvNOK_on(sv); /* what a wonderful hack! */
1N/A }
1N/A else if (strEQ(mg->mg_ptr+1, "NCODING"))
1N/A sv_setsv(sv, PL_encoding);
1N/A break;
1N/A case '\006': /* ^F */
1N/A sv_setiv(sv, (IV)PL_maxsysfd);
1N/A break;
1N/A case '\010': /* ^H */
1N/A sv_setiv(sv, (IV)PL_hints);
1N/A break;
1N/A case '\011': /* ^I */ /* NOT \t in EBCDIC */
1N/A if (PL_inplace)
1N/A sv_setpv(sv, PL_inplace);
1N/A else
1N/A sv_setsv(sv, &PL_sv_undef);
1N/A break;
1N/A case '\017': /* ^O & ^OPEN */
1N/A if (*(mg->mg_ptr+1) == '\0') {
1N/A sv_setpv(sv, PL_osname);
1N/A SvTAINTED_off(sv);
1N/A }
1N/A else if (strEQ(mg->mg_ptr, "\017PEN")) {
1N/A if (!PL_compiling.cop_io)
1N/A sv_setsv(sv, &PL_sv_undef);
1N/A else {
1N/A sv_setsv(sv, PL_compiling.cop_io);
1N/A }
1N/A }
1N/A break;
1N/A case '\020': /* ^P */
1N/A sv_setiv(sv, (IV)PL_perldb);
1N/A break;
1N/A case '\023': /* ^S */
1N/A if (*(mg->mg_ptr+1) == '\0') {
1N/A if (PL_lex_state != LEX_NOTPARSING)
1N/A (void)SvOK_off(sv);
1N/A else if (PL_in_eval)
1N/A sv_setiv(sv, PL_in_eval & ~(EVAL_INREQUIRE));
1N/A else
1N/A sv_setiv(sv, 0);
1N/A }
1N/A break;
1N/A case '\024': /* ^T */
1N/A if (*(mg->mg_ptr+1) == '\0') {
1N/A#ifdef BIG_TIME
1N/A sv_setnv(sv, PL_basetime);
1N/A#else
1N/A sv_setiv(sv, (IV)PL_basetime);
1N/A#endif
1N/A }
1N/A else if (strEQ(mg->mg_ptr, "\024AINT"))
1N/A sv_setiv(sv, PL_tainting
1N/A ? (PL_taint_warn || PL_unsafe ? -1 : 1)
1N/A : 0);
1N/A break;
1N/A case '\025': /* $^UNICODE */
1N/A if (strEQ(mg->mg_ptr, "\025NICODE"))
1N/A sv_setuv(sv, (UV) PL_unicode);
1N/A break;
1N/A case '\027': /* ^W & $^WARNING_BITS */
1N/A if (*(mg->mg_ptr+1) == '\0')
1N/A sv_setiv(sv, (IV)((PL_dowarn & G_WARN_ON) ? TRUE : FALSE));
1N/A else if (strEQ(mg->mg_ptr+1, "ARNING_BITS")) {
1N/A if (PL_compiling.cop_warnings == pWARN_NONE ||
1N/A PL_compiling.cop_warnings == pWARN_STD)
1N/A {
1N/A sv_setpvn(sv, WARN_NONEstring, WARNsize) ;
1N/A }
1N/A else if (PL_compiling.cop_warnings == pWARN_ALL) {
1N/A sv_setpvn(sv, WARN_ALLstring, WARNsize) ;
1N/A }
1N/A else {
1N/A sv_setsv(sv, PL_compiling.cop_warnings);
1N/A }
1N/A SvPOK_only(sv);
1N/A }
1N/A break;
1N/A case '1': case '2': case '3': case '4':
1N/A case '5': case '6': case '7': case '8': case '9': case '&':
1N/A if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
1N/A I32 s1, t1;
1N/A
1N/A /*
1N/A * Pre-threads, this was paren = atoi(GvENAME((GV*)mg->mg_obj));
1N/A * XXX Does the new way break anything?
1N/A */
1N/A paren = atoi(mg->mg_ptr); /* $& is in [0] */
1N/A getparen:
1N/A if (paren <= (I32)rx->nparens &&
1N/A (s1 = rx->startp[paren]) != -1 &&
1N/A (t1 = rx->endp[paren]) != -1)
1N/A {
1N/A i = t1 - s1;
1N/A s = rx->subbeg + s1;
1N/A if (!rx->subbeg)
1N/A break;
1N/A
1N/A getrx:
1N/A if (i >= 0) {
1N/A sv_setpvn(sv, s, i);
1N/A if (RX_MATCH_UTF8(rx) && is_utf8_string((U8*)s, i))
1N/A SvUTF8_on(sv);
1N/A else
1N/A SvUTF8_off(sv);
1N/A if (PL_tainting) {
1N/A if (RX_MATCH_TAINTED(rx)) {
1N/A MAGIC* mg = SvMAGIC(sv);
1N/A MAGIC* mgt;
1N/A PL_tainted = 1;
1N/A SvMAGIC(sv) = mg->mg_moremagic;
1N/A SvTAINT(sv);
1N/A if ((mgt = SvMAGIC(sv))) {
1N/A mg->mg_moremagic = mgt;
1N/A SvMAGIC(sv) = mg;
1N/A }
1N/A } else
1N/A SvTAINTED_off(sv);
1N/A }
1N/A break;
1N/A }
1N/A }
1N/A }
1N/A sv_setsv(sv,&PL_sv_undef);
1N/A break;
1N/A case '+':
1N/A if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
1N/A paren = rx->lastparen;
1N/A if (paren)
1N/A goto getparen;
1N/A }
1N/A sv_setsv(sv,&PL_sv_undef);
1N/A break;
1N/A case '\016': /* ^N */
1N/A if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
1N/A paren = rx->lastcloseparen;
1N/A if (paren)
1N/A goto getparen;
1N/A }
1N/A sv_setsv(sv,&PL_sv_undef);
1N/A break;
1N/A case '`':
1N/A if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
1N/A if ((s = rx->subbeg) && rx->startp[0] != -1) {
1N/A i = rx->startp[0];
1N/A goto getrx;
1N/A }
1N/A }
1N/A sv_setsv(sv,&PL_sv_undef);
1N/A break;
1N/A case '\'':
1N/A if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
1N/A if (rx->subbeg && rx->endp[0] != -1) {
1N/A s = rx->subbeg + rx->endp[0];
1N/A i = rx->sublen - rx->endp[0];
1N/A goto getrx;
1N/A }
1N/A }
1N/A sv_setsv(sv,&PL_sv_undef);
1N/A break;
1N/A case '.':
1N/A#ifndef lint
1N/A if (GvIO(PL_last_in_gv)) {
1N/A sv_setiv(sv, (IV)IoLINES(GvIOp(PL_last_in_gv)));
1N/A }
1N/A#endif
1N/A break;
1N/A case '?':
1N/A {
1N/A sv_setiv(sv, (IV)STATUS_CURRENT);
1N/A#ifdef COMPLEX_STATUS
1N/A LvTARGOFF(sv) = PL_statusvalue;
1N/A LvTARGLEN(sv) = PL_statusvalue_vms;
1N/A#endif
1N/A }
1N/A break;
1N/A case '^':
1N/A if (GvIOp(PL_defoutgv))
1N/A s = IoTOP_NAME(GvIOp(PL_defoutgv));
1N/A if (s)
1N/A sv_setpv(sv,s);
1N/A else {
1N/A sv_setpv(sv,GvENAME(PL_defoutgv));
1N/A sv_catpv(sv,"_TOP");
1N/A }
1N/A break;
1N/A case '~':
1N/A if (GvIOp(PL_defoutgv))
1N/A s = IoFMT_NAME(GvIOp(PL_defoutgv));
1N/A if (!s)
1N/A s = GvENAME(PL_defoutgv);
1N/A sv_setpv(sv,s);
1N/A break;
1N/A#ifndef lint
1N/A case '=':
1N/A if (GvIOp(PL_defoutgv))
1N/A sv_setiv(sv, (IV)IoPAGE_LEN(GvIOp(PL_defoutgv)));
1N/A break;
1N/A case '-':
1N/A if (GvIOp(PL_defoutgv))
1N/A sv_setiv(sv, (IV)IoLINES_LEFT(GvIOp(PL_defoutgv)));
1N/A break;
1N/A case '%':
1N/A if (GvIOp(PL_defoutgv))
1N/A sv_setiv(sv, (IV)IoPAGE(GvIOp(PL_defoutgv)));
1N/A break;
1N/A#endif
1N/A case ':':
1N/A break;
1N/A case '/':
1N/A break;
1N/A case '[':
1N/A WITH_THR(sv_setiv(sv, (IV)PL_curcop->cop_arybase));
1N/A break;
1N/A case '|':
1N/A if (GvIOp(PL_defoutgv))
1N/A sv_setiv(sv, (IV)(IoFLAGS(GvIOp(PL_defoutgv)) & IOf_FLUSH) != 0 );
1N/A break;
1N/A case ',':
1N/A break;
1N/A case '\\':
1N/A if (PL_ors_sv)
1N/A sv_copypv(sv, PL_ors_sv);
1N/A break;
1N/A case '#':
1N/A sv_setpv(sv,PL_ofmt);
1N/A break;
1N/A case '!':
1N/A#ifdef VMS
1N/A sv_setnv(sv, (NV)((errno == EVMSERR) ? vaxc$errno : errno));
1N/A sv_setpv(sv, errno ? Strerror(errno) : "");
1N/A#else
1N/A {
1N/A int saveerrno = errno;
1N/A sv_setnv(sv, (NV)errno);
1N/A#ifdef OS2
1N/A if (errno == errno_isOS2 || errno == errno_isOS2_set)
1N/A sv_setpv(sv, os2error(Perl_rc));
1N/A else
1N/A#endif
1N/A sv_setpv(sv, errno ? Strerror(errno) : "");
1N/A errno = saveerrno;
1N/A }
1N/A#endif
1N/A SvNOK_on(sv); /* what a wonderful hack! */
1N/A break;
1N/A case '<':
1N/A sv_setiv(sv, (IV)PL_uid);
1N/A break;
1N/A case '>':
1N/A sv_setiv(sv, (IV)PL_euid);
1N/A break;
1N/A case '(':
1N/A sv_setiv(sv, (IV)PL_gid);
1N/A#ifdef HAS_GETGROUPS
1N/A Perl_sv_setpvf(aTHX_ sv, "%"Gid_t_f, PL_gid);
1N/A#endif
1N/A goto add_groups;
1N/A case ')':
1N/A sv_setiv(sv, (IV)PL_egid);
1N/A#ifdef HAS_GETGROUPS
1N/A Perl_sv_setpvf(aTHX_ sv, "%"Gid_t_f, PL_egid);
1N/A#endif
1N/A add_groups:
1N/A#ifdef HAS_GETGROUPS
1N/A {
1N/A#ifdef __sun
1N/A int maxgrp = getgroups(0, NULL);
1N/A Groups_t *gary = alloca(maxgrp * sizeof (Groups_t));
1N/A i = getgroups(maxgrp,gary);
1N/A#else
1N/A Groups_t gary[NGROUPS];
1N/A i = getgroups(NGROUPS,gary);
1N/A#endif
1N/A while (--i >= 0)
1N/A Perl_sv_catpvf(aTHX_ sv, " %"Gid_t_f, gary[i]);
1N/A }
1N/A#endif
1N/A (void)SvIOK_on(sv); /* what a wonderful hack! */
1N/A break;
1N/A case '*':
1N/A break;
1N/A#ifndef MACOS_TRADITIONAL
1N/A case '0':
1N/A break;
1N/A#endif
1N/A#ifdef USE_5005THREADS
1N/A case '@':
1N/A sv_setsv(sv, thr->errsv);
1N/A break;
1N/A#endif /* USE_5005THREADS */
1N/A }
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_getuvar(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A struct ufuncs *uf = (struct ufuncs *)mg->mg_ptr;
1N/A
1N/A if (uf && uf->uf_val)
1N/A (*uf->uf_val)(aTHX_ uf->uf_index, sv);
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_setenv(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A register char *s;
1N/A char *ptr;
1N/A STRLEN len, klen;
1N/A
1N/A s = SvPV(sv,len);
1N/A ptr = MgPV(mg,klen);
1N/A my_setenv(ptr, s);
1N/A
1N/A#ifdef DYNAMIC_ENV_FETCH
1N/A /* We just undefd an environment var. Is a replacement */
1N/A /* waiting in the wings? */
1N/A if (!len) {
1N/A SV **valp;
1N/A if ((valp = hv_fetch(GvHVn(PL_envgv), ptr, klen, FALSE)))
1N/A s = SvPV(*valp, len);
1N/A }
1N/A#endif
1N/A
1N/A#if !defined(OS2) && !defined(AMIGAOS) && !defined(WIN32) && !defined(MSDOS)
1N/A /* And you'll never guess what the dog had */
1N/A /* in its mouth... */
1N/A if (PL_tainting) {
1N/A MgTAINTEDDIR_off(mg);
1N/A#ifdef VMS
1N/A if (s && klen == 8 && strEQ(ptr, "DCL$PATH")) {
1N/A char pathbuf[256], eltbuf[256], *cp, *elt = s;
1N/A Stat_t sbuf;
1N/A int i = 0, j = 0;
1N/A
1N/A do { /* DCL$PATH may be a search list */
1N/A while (1) { /* as may dev portion of any element */
1N/A if ( ((cp = strchr(elt,'[')) || (cp = strchr(elt,'<'))) ) {
1N/A if ( *(cp+1) == '.' || *(cp+1) == '-' ||
1N/A cando_by_name(S_IWUSR,0,elt) ) {
1N/A MgTAINTEDDIR_on(mg);
1N/A return 0;
1N/A }
1N/A }
1N/A if ((cp = strchr(elt, ':')) != Nullch)
1N/A *cp = '\0';
1N/A if (my_trnlnm(elt, eltbuf, j++))
1N/A elt = eltbuf;
1N/A else
1N/A break;
1N/A }
1N/A j = 0;
1N/A } while (my_trnlnm(s, pathbuf, i++) && (elt = pathbuf));
1N/A }
1N/A#endif /* VMS */
1N/A if (s && klen == 4 && strEQ(ptr,"PATH")) {
1N/A char *strend = s + len;
1N/A
1N/A while (s < strend) {
1N/A char tmpbuf[256];
1N/A Stat_t st;
1N/A I32 i;
1N/A s = delimcpy(tmpbuf, tmpbuf + sizeof tmpbuf,
1N/A s, strend, ':', &i);
1N/A s++;
1N/A if (i >= sizeof tmpbuf /* too long -- assume the worst */
1N/A || *tmpbuf != '/'
1N/A || (PerlLIO_stat(tmpbuf, &st) == 0 && (st.st_mode & 2)) ) {
1N/A MgTAINTEDDIR_on(mg);
1N/A return 0;
1N/A }
1N/A }
1N/A }
1N/A }
1N/A#endif /* neither OS2 nor AMIGAOS nor WIN32 nor MSDOS */
1N/A
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_clearenv(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A STRLEN n_a;
1N/A my_setenv(MgPV(mg,n_a),Nullch);
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_set_all_env(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A#if defined(VMS)
1N/A Perl_die(aTHX_ "Can't make list assignment to %%ENV on this system");
1N/A#else
1N/A if (PL_localizing) {
1N/A HE* entry;
1N/A STRLEN n_a;
1N/A magic_clear_all_env(sv,mg);
1N/A hv_iterinit((HV*)sv);
1N/A while ((entry = hv_iternext((HV*)sv))) {
1N/A I32 keylen;
1N/A my_setenv(hv_iterkey(entry, &keylen),
1N/A SvPV(hv_iterval((HV*)sv, entry), n_a));
1N/A }
1N/A }
1N/A#endif
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_clear_all_env(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A#ifndef PERL_MICRO
1N/A#if defined(VMS) || defined(EPOC)
1N/A Perl_die(aTHX_ "Can't make list assignment to %%ENV on this system");
1N/A#else
1N/A# if defined(PERL_IMPLICIT_SYS) || defined(WIN32)
1N/A PerlEnv_clearenv();
1N/A# else
1N/A# ifdef USE_ENVIRON_ARRAY
1N/A# if defined(USE_ITHREADS)
1N/A /* only the parent thread can clobber the process environment */
1N/A if (PL_curinterp == aTHX)
1N/A# endif
1N/A {
1N/A# ifndef PERL_USE_SAFE_PUTENV
1N/A I32 i;
1N/A
1N/A if (environ == PL_origenviron)
1N/A environ = (char**)safesysmalloc(sizeof(char*));
1N/A else
1N/A for (i = 0; environ[i]; i++)
1N/A safesysfree(environ[i]);
1N/A# endif /* PERL_USE_SAFE_PUTENV */
1N/A
1N/A environ[0] = Nullch;
1N/A }
1N/A# endif /* USE_ENVIRON_ARRAY */
1N/A# endif /* PERL_IMPLICIT_SYS || WIN32 */
1N/A#endif /* VMS || EPOC */
1N/A#endif /* !PERL_MICRO */
1N/A return 0;
1N/A}
1N/A
1N/A#if defined(FAKE_PERSISTENT_SIGNAL_HANDLERS)||defined(FAKE_DEFAULT_SIGNAL_HANDLERS)
1N/Astatic int sig_handlers_initted = 0;
1N/A#endif
1N/A#ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1N/Astatic int sig_ignoring[SIG_SIZE]; /* which signals we are ignoring */
1N/A#endif
1N/A#ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1N/Astatic int sig_defaulting[SIG_SIZE];
1N/A#endif
1N/A
1N/A#ifndef PERL_MICRO
1N/A#ifdef HAS_SIGPROCMASK
1N/Astatic void
1N/Arestore_sigmask(pTHX_ SV *save_sv)
1N/A{
1N/A sigset_t *ossetp = (sigset_t *) SvPV_nolen( save_sv );
1N/A (void)sigprocmask(SIG_SETMASK, ossetp, (sigset_t *)0);
1N/A}
1N/A#endif
1N/Aint
1N/APerl_magic_getsig(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A I32 i;
1N/A STRLEN n_a;
1N/A /* Are we fetching a signal entry? */
1N/A i = whichsig(MgPV(mg,n_a));
1N/A if (i > 0) {
1N/A if(PL_psig_ptr[i])
1N/A sv_setsv(sv,PL_psig_ptr[i]);
1N/A else {
1N/A Sighandler_t sigstate;
1N/A sigstate = rsignal_state(i);
1N/A#ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1N/A if (sig_handlers_initted && sig_ignoring[i]) sigstate = SIG_IGN;
1N/A#endif
1N/A#ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1N/A if (sig_handlers_initted && sig_defaulting[i]) sigstate = SIG_DFL;
1N/A#endif
1N/A /* cache state so we don't fetch it again */
1N/A if(sigstate == SIG_IGN)
1N/A sv_setpv(sv,"IGNORE");
1N/A else
1N/A sv_setsv(sv,&PL_sv_undef);
1N/A PL_psig_ptr[i] = SvREFCNT_inc(sv);
1N/A SvTEMP_off(sv);
1N/A }
1N/A }
1N/A return 0;
1N/A}
1N/Aint
1N/APerl_magic_clearsig(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A /* XXX Some of this code was copied from Perl_magic_setsig. A little
1N/A * refactoring might be in order.
1N/A */
1N/A register char *s;
1N/A STRLEN n_a;
1N/A SV* to_dec;
1N/A s = MgPV(mg,n_a);
1N/A if (*s == '_') {
1N/A SV** svp;
1N/A if (strEQ(s,"__DIE__"))
1N/A svp = &PL_diehook;
1N/A else if (strEQ(s,"__WARN__"))
1N/A svp = &PL_warnhook;
1N/A else
1N/A Perl_croak(aTHX_ "No such hook: %s", s);
1N/A if (*svp) {
1N/A to_dec = *svp;
1N/A *svp = 0;
1N/A SvREFCNT_dec(to_dec);
1N/A }
1N/A }
1N/A else {
1N/A I32 i;
1N/A /* Are we clearing a signal entry? */
1N/A i = whichsig(s);
1N/A if (i > 0) {
1N/A#ifdef HAS_SIGPROCMASK
1N/A sigset_t set, save;
1N/A SV* save_sv;
1N/A /* Avoid having the signal arrive at a bad time, if possible. */
1N/A sigemptyset(&set);
1N/A sigaddset(&set,i);
1N/A sigprocmask(SIG_BLOCK, &set, &save);
1N/A ENTER;
1N/A save_sv = newSVpv((char *)(&save), sizeof(sigset_t));
1N/A SAVEFREESV(save_sv);
1N/A SAVEDESTRUCTOR_X(restore_sigmask, save_sv);
1N/A#endif
1N/A PERL_ASYNC_CHECK();
1N/A#if defined(FAKE_PERSISTENT_SIGNAL_HANDLERS) || defined(FAKE_DEFAULT_SIGNAL_HANDLERS)
1N/A if (!sig_handlers_initted) Perl_csighandler_init();
1N/A#endif
1N/A#ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1N/A sig_defaulting[i] = 1;
1N/A (void)rsignal(i, PL_csighandlerp);
1N/A#else
1N/A (void)rsignal(i, SIG_DFL);
1N/A#endif
1N/A if(PL_psig_name[i]) {
1N/A SvREFCNT_dec(PL_psig_name[i]);
1N/A PL_psig_name[i]=0;
1N/A }
1N/A if(PL_psig_ptr[i]) {
1N/A to_dec=PL_psig_ptr[i];
1N/A PL_psig_ptr[i]=0;
1N/A LEAVE;
1N/A SvREFCNT_dec(to_dec);
1N/A }
1N/A else
1N/A LEAVE;
1N/A }
1N/A }
1N/A return 0;
1N/A}
1N/A
1N/Avoid
1N/APerl_raise_signal(pTHX_ int sig)
1N/A{
1N/A /* Set a flag to say this signal is pending */
1N/A PL_psig_pend[sig]++;
1N/A /* And one to say _a_ signal is pending */
1N/A PL_sig_pending = 1;
1N/A}
1N/A
1N/ASignal_t
1N/APerl_csighandler(int sig)
1N/A{
1N/A#ifdef PERL_GET_SIG_CONTEXT
1N/A dTHXa(PERL_GET_SIG_CONTEXT);
1N/A#else
1N/A dTHX;
1N/A#endif
1N/A#ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1N/A (void) rsignal(sig, PL_csighandlerp);
1N/A if (sig_ignoring[sig]) return;
1N/A#endif
1N/A#ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1N/A if (sig_defaulting[sig])
1N/A#ifdef KILL_BY_SIGPRC
1N/A exit((Perl_sig_to_vmscondition(sig)&STS$M_COND_ID)|STS$K_SEVERE|STS$M_INHIB_MSG);
1N/A#else
1N/A exit(1);
1N/A#endif
1N/A#endif
1N/A if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG)
1N/A /* Call the perl level handler now--
1N/A * with risk we may be in malloc() etc. */
1N/A (*PL_sighandlerp)(sig);
1N/A else
1N/A Perl_raise_signal(aTHX_ sig);
1N/A}
1N/A
1N/A#if defined(FAKE_PERSISTENT_SIGNAL_HANDLERS) || defined(FAKE_DEFAULT_SIGNAL_HANDLERS)
1N/Avoid
1N/APerl_csighandler_init(void)
1N/A{
1N/A int sig;
1N/A if (sig_handlers_initted) return;
1N/A
1N/A for (sig = 1; sig < SIG_SIZE; sig++) {
1N/A#ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1N/A dTHX;
1N/A sig_defaulting[sig] = 1;
1N/A (void) rsignal(sig, PL_csighandlerp);
1N/A#endif
1N/A#ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1N/A sig_ignoring[sig] = 0;
1N/A#endif
1N/A }
1N/A sig_handlers_initted = 1;
1N/A}
1N/A#endif
1N/A
1N/Avoid
1N/APerl_despatch_signals(pTHX)
1N/A{
1N/A int sig;
1N/A PL_sig_pending = 0;
1N/A for (sig = 1; sig < SIG_SIZE; sig++) {
1N/A if (PL_psig_pend[sig]) {
1N/A PERL_BLOCKSIG_ADD(set, sig);
1N/A PL_psig_pend[sig] = 0;
1N/A PERL_BLOCKSIG_BLOCK(set);
1N/A (*PL_sighandlerp)(sig);
1N/A PERL_BLOCKSIG_UNBLOCK(set);
1N/A }
1N/A }
1N/A}
1N/A
1N/Aint
1N/APerl_magic_setsig(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A register char *s;
1N/A I32 i;
1N/A SV** svp = 0;
1N/A /* Need to be careful with SvREFCNT_dec(), because that can have side
1N/A * effects (due to closures). We must make sure that the new disposition
1N/A * is in place before it is called.
1N/A */
1N/A SV* to_dec = 0;
1N/A STRLEN len;
1N/A#ifdef HAS_SIGPROCMASK
1N/A sigset_t set, save;
1N/A SV* save_sv;
1N/A#endif
1N/A
1N/A s = MgPV(mg,len);
1N/A if (*s == '_') {
1N/A if (strEQ(s,"__DIE__"))
1N/A svp = &PL_diehook;
1N/A else if (strEQ(s,"__WARN__"))
1N/A svp = &PL_warnhook;
1N/A else
1N/A Perl_croak(aTHX_ "No such hook: %s", s);
1N/A i = 0;
1N/A if (*svp) {
1N/A to_dec = *svp;
1N/A *svp = 0;
1N/A }
1N/A }
1N/A else {
1N/A i = whichsig(s); /* ...no, a brick */
1N/A if (i < 0) {
1N/A if (ckWARN(WARN_SIGNAL))
1N/A Perl_warner(aTHX_ packWARN(WARN_SIGNAL), "No such signal: SIG%s", s);
1N/A return 0;
1N/A }
1N/A#ifdef HAS_SIGPROCMASK
1N/A /* Avoid having the signal arrive at a bad time, if possible. */
1N/A sigemptyset(&set);
1N/A sigaddset(&set,i);
1N/A sigprocmask(SIG_BLOCK, &set, &save);
1N/A ENTER;
1N/A save_sv = newSVpv((char *)(&save), sizeof(sigset_t));
1N/A SAVEFREESV(save_sv);
1N/A SAVEDESTRUCTOR_X(restore_sigmask, save_sv);
1N/A#endif
1N/A PERL_ASYNC_CHECK();
1N/A#if defined(FAKE_PERSISTENT_SIGNAL_HANDLERS) || defined(FAKE_DEFAULT_SIGNAL_HANDLERS)
1N/A if (!sig_handlers_initted) Perl_csighandler_init();
1N/A#endif
1N/A#ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1N/A sig_ignoring[i] = 0;
1N/A#endif
1N/A#ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1N/A sig_defaulting[i] = 0;
1N/A#endif
1N/A SvREFCNT_dec(PL_psig_name[i]);
1N/A to_dec = PL_psig_ptr[i];
1N/A PL_psig_ptr[i] = SvREFCNT_inc(sv);
1N/A SvTEMP_off(sv); /* Make sure it doesn't go away on us */
1N/A PL_psig_name[i] = newSVpvn(s, len);
1N/A SvREADONLY_on(PL_psig_name[i]);
1N/A }
1N/A if (SvTYPE(sv) == SVt_PVGV || SvROK(sv)) {
1N/A if (i) {
1N/A (void)rsignal(i, PL_csighandlerp);
1N/A#ifdef HAS_SIGPROCMASK
1N/A LEAVE;
1N/A#endif
1N/A }
1N/A else
1N/A *svp = SvREFCNT_inc(sv);
1N/A if(to_dec)
1N/A SvREFCNT_dec(to_dec);
1N/A return 0;
1N/A }
1N/A s = SvPV_force(sv,len);
1N/A if (strEQ(s,"IGNORE")) {
1N/A if (i) {
1N/A#ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1N/A sig_ignoring[i] = 1;
1N/A (void)rsignal(i, PL_csighandlerp);
1N/A#else
1N/A (void)rsignal(i, SIG_IGN);
1N/A#endif
1N/A }
1N/A }
1N/A else if (strEQ(s,"DEFAULT") || !*s) {
1N/A if (i)
1N/A#ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1N/A {
1N/A sig_defaulting[i] = 1;
1N/A (void)rsignal(i, PL_csighandlerp);
1N/A }
1N/A#else
1N/A (void)rsignal(i, SIG_DFL);
1N/A#endif
1N/A }
1N/A else {
1N/A /*
1N/A * We should warn if HINT_STRICT_REFS, but without
1N/A * access to a known hint bit in a known OP, we can't
1N/A * tell whether HINT_STRICT_REFS is in force or not.
1N/A */
1N/A if (!strchr(s,':') && !strchr(s,'\''))
1N/A sv_insert(sv, 0, 0, "main::", 6);
1N/A if (i)
1N/A (void)rsignal(i, PL_csighandlerp);
1N/A else
1N/A *svp = SvREFCNT_inc(sv);
1N/A }
1N/A#ifdef HAS_SIGPROCMASK
1N/A if(i)
1N/A LEAVE;
1N/A#endif
1N/A if(to_dec)
1N/A SvREFCNT_dec(to_dec);
1N/A return 0;
1N/A}
1N/A#endif /* !PERL_MICRO */
1N/A
1N/Aint
1N/APerl_magic_setisa(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A PL_sub_generation++;
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_setamagic(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A /* HV_badAMAGIC_on(Sv_STASH(sv)); */
1N/A PL_amagic_generation++;
1N/A
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_getnkeys(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A HV *hv = (HV*)LvTARG(sv);
1N/A I32 i = 0;
1N/A
1N/A if (hv) {
1N/A (void) hv_iterinit(hv);
1N/A if (! SvTIED_mg((SV*)hv, PERL_MAGIC_tied))
1N/A i = HvKEYS(hv);
1N/A else {
1N/A while (hv_iternext(hv))
1N/A i++;
1N/A }
1N/A }
1N/A
1N/A sv_setiv(sv, (IV)i);
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_setnkeys(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A if (LvTARG(sv)) {
1N/A hv_ksplit((HV*)LvTARG(sv), SvIV(sv));
1N/A }
1N/A return 0;
1N/A}
1N/A
1N/A/* caller is responsible for stack switching/cleanup */
1N/ASTATIC int
1N/AS_magic_methcall(pTHX_ SV *sv, MAGIC *mg, char *meth, I32 flags, int n, SV *val)
1N/A{
1N/A dSP;
1N/A
1N/A PUSHMARK(SP);
1N/A EXTEND(SP, n);
1N/A PUSHs(SvTIED_obj(sv, mg));
1N/A if (n > 1) {
1N/A if (mg->mg_ptr) {
1N/A if (mg->mg_len >= 0)
1N/A PUSHs(sv_2mortal(newSVpvn(mg->mg_ptr, mg->mg_len)));
1N/A else if (mg->mg_len == HEf_SVKEY)
1N/A PUSHs((SV*)mg->mg_ptr);
1N/A }
1N/A else if (mg->mg_type == PERL_MAGIC_tiedelem) {
1N/A PUSHs(sv_2mortal(newSViv(mg->mg_len)));
1N/A }
1N/A }
1N/A if (n > 2) {
1N/A PUSHs(val);
1N/A }
1N/A PUTBACK;
1N/A
1N/A return call_method(meth, flags);
1N/A}
1N/A
1N/ASTATIC int
1N/AS_magic_methpack(pTHX_ SV *sv, MAGIC *mg, char *meth)
1N/A{
1N/A dSP;
1N/A
1N/A ENTER;
1N/A SAVETMPS;
1N/A PUSHSTACKi(PERLSI_MAGIC);
1N/A
1N/A if (magic_methcall(sv, mg, meth, G_SCALAR, 2, NULL)) {
1N/A sv_setsv(sv, *PL_stack_sp--);
1N/A }
1N/A
1N/A POPSTACK;
1N/A FREETMPS;
1N/A LEAVE;
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_getpack(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A if (mg->mg_ptr)
1N/A mg->mg_flags |= MGf_GSKIP;
1N/A magic_methpack(sv,mg,"FETCH");
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_setpack(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A dSP;
1N/A ENTER;
1N/A PUSHSTACKi(PERLSI_MAGIC);
1N/A magic_methcall(sv, mg, "STORE", G_SCALAR|G_DISCARD, 3, sv);
1N/A POPSTACK;
1N/A LEAVE;
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_clearpack(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A return magic_methpack(sv,mg,"DELETE");
1N/A}
1N/A
1N/A
1N/AU32
1N/APerl_magic_sizepack(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A dSP;
1N/A U32 retval = 0;
1N/A
1N/A ENTER;
1N/A SAVETMPS;
1N/A PUSHSTACKi(PERLSI_MAGIC);
1N/A if (magic_methcall(sv, mg, "FETCHSIZE", G_SCALAR, 2, NULL)) {
1N/A sv = *PL_stack_sp--;
1N/A retval = (U32) SvIV(sv)-1;
1N/A }
1N/A POPSTACK;
1N/A FREETMPS;
1N/A LEAVE;
1N/A return retval;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_wipepack(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A dSP;
1N/A
1N/A ENTER;
1N/A PUSHSTACKi(PERLSI_MAGIC);
1N/A PUSHMARK(SP);
1N/A XPUSHs(SvTIED_obj(sv, mg));
1N/A PUTBACK;
1N/A call_method("CLEAR", G_SCALAR|G_DISCARD);
1N/A POPSTACK;
1N/A LEAVE;
1N/A
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_nextpack(pTHX_ SV *sv, MAGIC *mg, SV *key)
1N/A{
1N/A dSP;
1N/A const char *meth = SvOK(key) ? "NEXTKEY" : "FIRSTKEY";
1N/A
1N/A ENTER;
1N/A SAVETMPS;
1N/A PUSHSTACKi(PERLSI_MAGIC);
1N/A PUSHMARK(SP);
1N/A EXTEND(SP, 2);
1N/A PUSHs(SvTIED_obj(sv, mg));
1N/A if (SvOK(key))
1N/A PUSHs(key);
1N/A PUTBACK;
1N/A
1N/A if (call_method(meth, G_SCALAR))
1N/A sv_setsv(key, *PL_stack_sp--);
1N/A
1N/A POPSTACK;
1N/A FREETMPS;
1N/A LEAVE;
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_existspack(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A return magic_methpack(sv,mg,"EXISTS");
1N/A}
1N/A
1N/ASV *
1N/APerl_magic_scalarpack(pTHX_ HV *hv, MAGIC *mg)
1N/A{
1N/A dSP;
1N/A SV *retval = &PL_sv_undef;
1N/A SV *tied = SvTIED_obj((SV*)hv, mg);
1N/A HV *pkg = SvSTASH((SV*)SvRV(tied));
1N/A
1N/A if (!gv_fetchmethod_autoload(pkg, "SCALAR", FALSE)) {
1N/A SV *key;
1N/A if (HvEITER(hv))
1N/A /* we are in an iteration so the hash cannot be empty */
1N/A return &PL_sv_yes;
1N/A /* no xhv_eiter so now use FIRSTKEY */
1N/A key = sv_newmortal();
1N/A magic_nextpack((SV*)hv, mg, key);
1N/A HvEITER(hv) = NULL; /* need to reset iterator */
1N/A return SvOK(key) ? &PL_sv_yes : &PL_sv_no;
1N/A }
1N/A
1N/A /* there is a SCALAR method that we can call */
1N/A ENTER;
1N/A PUSHSTACKi(PERLSI_MAGIC);
1N/A PUSHMARK(SP);
1N/A EXTEND(SP, 1);
1N/A PUSHs(tied);
1N/A PUTBACK;
1N/A
1N/A if (call_method("SCALAR", G_SCALAR))
1N/A retval = *PL_stack_sp--;
1N/A POPSTACK;
1N/A LEAVE;
1N/A return retval;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_setdbline(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A OP *o;
1N/A I32 i;
1N/A GV* gv;
1N/A SV** svp;
1N/A STRLEN n_a;
1N/A
1N/A gv = PL_DBline;
1N/A i = SvTRUE(sv);
1N/A svp = av_fetch(GvAV(gv),
1N/A atoi(MgPV(mg,n_a)), FALSE);
1N/A if (svp && SvIOKp(*svp) && (o = INT2PTR(OP*,SvIVX(*svp)))) {
1N/A /* set or clear breakpoint in the relevant control op */
1N/A if (i)
1N/A o->op_flags |= OPf_SPECIAL;
1N/A else
1N/A o->op_flags &= ~OPf_SPECIAL;
1N/A }
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_getarylen(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A sv_setiv(sv, AvFILL((AV*)mg->mg_obj) + PL_curcop->cop_arybase);
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_setarylen(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A av_fill((AV*)mg->mg_obj, SvIV(sv) - PL_curcop->cop_arybase);
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_getpos(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A SV* lsv = LvTARG(sv);
1N/A
1N/A if (SvTYPE(lsv) >= SVt_PVMG && SvMAGIC(lsv)) {
1N/A mg = mg_find(lsv, PERL_MAGIC_regex_global);
1N/A if (mg && mg->mg_len >= 0) {
1N/A I32 i = mg->mg_len;
1N/A if (DO_UTF8(lsv))
1N/A sv_pos_b2u(lsv, &i);
1N/A sv_setiv(sv, i + PL_curcop->cop_arybase);
1N/A return 0;
1N/A }
1N/A }
1N/A (void)SvOK_off(sv);
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_setpos(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A SV* lsv = LvTARG(sv);
1N/A SSize_t pos;
1N/A STRLEN len;
1N/A STRLEN ulen = 0;
1N/A
1N/A mg = 0;
1N/A
1N/A if (SvTYPE(lsv) >= SVt_PVMG && SvMAGIC(lsv))
1N/A mg = mg_find(lsv, PERL_MAGIC_regex_global);
1N/A if (!mg) {
1N/A if (!SvOK(sv))
1N/A return 0;
1N/A sv_magic(lsv, (SV*)0, PERL_MAGIC_regex_global, Nullch, 0);
1N/A mg = mg_find(lsv, PERL_MAGIC_regex_global);
1N/A }
1N/A else if (!SvOK(sv)) {
1N/A mg->mg_len = -1;
1N/A return 0;
1N/A }
1N/A len = SvPOK(lsv) ? SvCUR(lsv) : sv_len(lsv);
1N/A
1N/A pos = SvIV(sv) - PL_curcop->cop_arybase;
1N/A
1N/A if (DO_UTF8(lsv)) {
1N/A ulen = sv_len_utf8(lsv);
1N/A if (ulen)
1N/A len = ulen;
1N/A }
1N/A
1N/A if (pos < 0) {
1N/A pos += len;
1N/A if (pos < 0)
1N/A pos = 0;
1N/A }
1N/A else if (pos > (SSize_t)len)
1N/A pos = len;
1N/A
1N/A if (ulen) {
1N/A I32 p = pos;
1N/A sv_pos_u2b(lsv, &p, 0);
1N/A pos = p;
1N/A }
1N/A
1N/A mg->mg_len = pos;
1N/A mg->mg_flags &= ~MGf_MINMATCH;
1N/A
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_getglob(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A if (SvFAKE(sv)) { /* FAKE globs can get coerced */
1N/A SvFAKE_off(sv);
1N/A gv_efullname3(sv,((GV*)sv), "*");
1N/A SvFAKE_on(sv);
1N/A }
1N/A else
1N/A gv_efullname3(sv,((GV*)sv), "*"); /* a gv value, be nice */
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_setglob(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A register char *s;
1N/A GV* gv;
1N/A STRLEN n_a;
1N/A
1N/A if (!SvOK(sv))
1N/A return 0;
1N/A s = SvPV(sv, n_a);
1N/A if (*s == '*' && s[1])
1N/A s++;
1N/A gv = gv_fetchpv(s,TRUE, SVt_PVGV);
1N/A if (sv == (SV*)gv)
1N/A return 0;
1N/A if (GvGP(sv))
1N/A gp_free((GV*)sv);
1N/A GvGP(sv) = gp_ref(GvGP(gv));
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_getsubstr(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A STRLEN len;
1N/A SV *lsv = LvTARG(sv);
1N/A char *tmps = SvPV(lsv,len);
1N/A I32 offs = LvTARGOFF(sv);
1N/A I32 rem = LvTARGLEN(sv);
1N/A
1N/A if (SvUTF8(lsv))
1N/A sv_pos_u2b(lsv, &offs, &rem);
1N/A if (offs > (I32)len)
1N/A offs = len;
1N/A if (rem + offs > (I32)len)
1N/A rem = len - offs;
1N/A sv_setpvn(sv, tmps + offs, (STRLEN)rem);
1N/A if (SvUTF8(lsv))
1N/A SvUTF8_on(sv);
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_setsubstr(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A STRLEN len;
1N/A char *tmps = SvPV(sv, len);
1N/A SV *lsv = LvTARG(sv);
1N/A I32 lvoff = LvTARGOFF(sv);
1N/A I32 lvlen = LvTARGLEN(sv);
1N/A
1N/A if (DO_UTF8(sv)) {
1N/A sv_utf8_upgrade(lsv);
1N/A sv_pos_u2b(lsv, &lvoff, &lvlen);
1N/A sv_insert(lsv, lvoff, lvlen, tmps, len);
1N/A SvUTF8_on(lsv);
1N/A }
1N/A else if (lsv && SvUTF8(lsv)) {
1N/A sv_pos_u2b(lsv, &lvoff, &lvlen);
1N/A tmps = (char*)bytes_to_utf8((U8*)tmps, &len);
1N/A sv_insert(lsv, lvoff, lvlen, tmps, len);
1N/A Safefree(tmps);
1N/A }
1N/A else
1N/A sv_insert(lsv, lvoff, lvlen, tmps, len);
1N/A
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_gettaint(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A TAINT_IF((mg->mg_len & 1) ||
1N/A ((mg->mg_len & 2) && mg->mg_obj == sv)); /* kludge */
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_settaint(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A if (PL_localizing) {
1N/A if (PL_localizing == 1)
1N/A mg->mg_len <<= 1;
1N/A else
1N/A mg->mg_len >>= 1;
1N/A }
1N/A else if (PL_tainted)
1N/A mg->mg_len |= 1;
1N/A else
1N/A mg->mg_len &= ~1;
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_getvec(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A SV *lsv = LvTARG(sv);
1N/A
1N/A if (!lsv) {
1N/A (void)SvOK_off(sv);
1N/A return 0;
1N/A }
1N/A
1N/A sv_setuv(sv, do_vecget(lsv, LvTARGOFF(sv), LvTARGLEN(sv)));
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_setvec(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A do_vecset(sv); /* XXX slurp this routine */
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_getdefelem(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A SV *targ = Nullsv;
1N/A if (LvTARGLEN(sv)) {
1N/A if (mg->mg_obj) {
1N/A SV *ahv = LvTARG(sv);
1N/A if (SvTYPE(ahv) == SVt_PVHV) {
1N/A HE *he = hv_fetch_ent((HV*)ahv, mg->mg_obj, FALSE, 0);
1N/A if (he)
1N/A targ = HeVAL(he);
1N/A }
1N/A else {
1N/A SV **svp = avhv_fetch_ent((AV*)ahv, mg->mg_obj, FALSE, 0);
1N/A if (svp)
1N/A targ = *svp;
1N/A }
1N/A }
1N/A else {
1N/A AV* av = (AV*)LvTARG(sv);
1N/A if ((I32)LvTARGOFF(sv) <= AvFILL(av))
1N/A targ = AvARRAY(av)[LvTARGOFF(sv)];
1N/A }
1N/A if (targ && targ != &PL_sv_undef) {
1N/A /* somebody else defined it for us */
1N/A SvREFCNT_dec(LvTARG(sv));
1N/A LvTARG(sv) = SvREFCNT_inc(targ);
1N/A LvTARGLEN(sv) = 0;
1N/A SvREFCNT_dec(mg->mg_obj);
1N/A mg->mg_obj = Nullsv;
1N/A mg->mg_flags &= ~MGf_REFCOUNTED;
1N/A }
1N/A }
1N/A else
1N/A targ = LvTARG(sv);
1N/A sv_setsv(sv, targ ? targ : &PL_sv_undef);
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_setdefelem(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A if (LvTARGLEN(sv))
1N/A vivify_defelem(sv);
1N/A if (LvTARG(sv)) {
1N/A sv_setsv(LvTARG(sv), sv);
1N/A SvSETMAGIC(LvTARG(sv));
1N/A }
1N/A return 0;
1N/A}
1N/A
1N/Avoid
1N/APerl_vivify_defelem(pTHX_ SV *sv)
1N/A{
1N/A MAGIC *mg;
1N/A SV *value = Nullsv;
1N/A
1N/A if (!LvTARGLEN(sv) || !(mg = mg_find(sv, PERL_MAGIC_defelem)))
1N/A return;
1N/A if (mg->mg_obj) {
1N/A SV *ahv = LvTARG(sv);
1N/A STRLEN n_a;
1N/A if (SvTYPE(ahv) == SVt_PVHV) {
1N/A HE *he = hv_fetch_ent((HV*)ahv, mg->mg_obj, TRUE, 0);
1N/A if (he)
1N/A value = HeVAL(he);
1N/A }
1N/A else {
1N/A SV **svp = avhv_fetch_ent((AV*)ahv, mg->mg_obj, TRUE, 0);
1N/A if (svp)
1N/A value = *svp;
1N/A }
1N/A if (!value || value == &PL_sv_undef)
1N/A Perl_croak(aTHX_ PL_no_helem, SvPV(mg->mg_obj, n_a));
1N/A }
1N/A else {
1N/A AV* av = (AV*)LvTARG(sv);
1N/A if ((I32)LvTARGLEN(sv) < 0 && (I32)LvTARGOFF(sv) > AvFILL(av))
1N/A LvTARG(sv) = Nullsv; /* array can't be extended */
1N/A else {
1N/A SV** svp = av_fetch(av, LvTARGOFF(sv), TRUE);
1N/A if (!svp || (value = *svp) == &PL_sv_undef)
1N/A Perl_croak(aTHX_ PL_no_aelem, (I32)LvTARGOFF(sv));
1N/A }
1N/A }
1N/A (void)SvREFCNT_inc(value);
1N/A SvREFCNT_dec(LvTARG(sv));
1N/A LvTARG(sv) = value;
1N/A LvTARGLEN(sv) = 0;
1N/A SvREFCNT_dec(mg->mg_obj);
1N/A mg->mg_obj = Nullsv;
1N/A mg->mg_flags &= ~MGf_REFCOUNTED;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_killbackrefs(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A AV *av = (AV*)mg->mg_obj;
1N/A SV **svp = AvARRAY(av);
1N/A I32 i = AvFILLp(av);
1N/A while (i >= 0) {
1N/A if (svp[i] && svp[i] != &PL_sv_undef) {
1N/A if (!SvWEAKREF(svp[i]))
1N/A Perl_croak(aTHX_ "panic: magic_killbackrefs");
1N/A /* XXX Should we check that it hasn't changed? */
1N/A SvRV(svp[i]) = 0;
1N/A (void)SvOK_off(svp[i]);
1N/A SvWEAKREF_off(svp[i]);
1N/A svp[i] = &PL_sv_undef;
1N/A }
1N/A i--;
1N/A }
1N/A SvREFCNT_dec(av); /* remove extra count added by sv_add_backref() */
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_setmglob(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A mg->mg_len = -1;
1N/A SvSCREAM_off(sv);
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_setbm(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A sv_unmagic(sv, PERL_MAGIC_bm);
1N/A SvVALID_off(sv);
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_setfm(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A sv_unmagic(sv, PERL_MAGIC_fm);
1N/A SvCOMPILED_off(sv);
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_setuvar(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A struct ufuncs *uf = (struct ufuncs *)mg->mg_ptr;
1N/A
1N/A if (uf && uf->uf_set)
1N/A (*uf->uf_set)(aTHX_ uf->uf_index, sv);
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_setregexp(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A sv_unmagic(sv, PERL_MAGIC_qr);
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_freeregexp(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A regexp *re = (regexp *)mg->mg_obj;
1N/A ReREFCNT_dec(re);
1N/A return 0;
1N/A}
1N/A
1N/A#ifdef USE_LOCALE_COLLATE
1N/Aint
1N/APerl_magic_setcollxfrm(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A /*
1N/A * RenE<eacute> Descartes said "I think not."
1N/A * and vanished with a faint plop.
1N/A */
1N/A if (mg->mg_ptr) {
1N/A Safefree(mg->mg_ptr);
1N/A mg->mg_ptr = NULL;
1N/A mg->mg_len = -1;
1N/A }
1N/A return 0;
1N/A}
1N/A#endif /* USE_LOCALE_COLLATE */
1N/A
1N/A/* Just clear the UTF-8 cache data. */
1N/Aint
1N/APerl_magic_setutf8(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A Safefree(mg->mg_ptr); /* The mg_ptr holds the pos cache. */
1N/A mg->mg_ptr = 0;
1N/A mg->mg_len = -1; /* The mg_len holds the len cache. */
1N/A return 0;
1N/A}
1N/A
1N/Aint
1N/APerl_magic_set(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A register char *s;
1N/A I32 i;
1N/A STRLEN len;
1N/A switch (*mg->mg_ptr) {
1N/A case '\001': /* ^A */
1N/A sv_setsv(PL_bodytarget, sv);
1N/A break;
1N/A case '\003': /* ^C */
1N/A PL_minus_c = (bool)(SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv));
1N/A break;
1N/A
1N/A case '\004': /* ^D */
1N/A#ifdef DEBUGGING
1N/A s = SvPV_nolen(sv);
1N/A PL_debug = get_debug_opts(&s) | DEBUG_TOP_FLAG;
1N/A DEBUG_x(dump_all());
1N/A#else
1N/A PL_debug = (SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv)) | DEBUG_TOP_FLAG;
1N/A#endif
1N/A break;
1N/A case '\005': /* ^E */
1N/A if (*(mg->mg_ptr+1) == '\0') {
1N/A#ifdef MACOS_TRADITIONAL
1N/A gMacPerl_OSErr = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv);
1N/A#else
1N/A# ifdef VMS
1N/A set_vaxc_errno(SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv));
1N/A# else
1N/A# ifdef WIN32
1N/A SetLastError( SvIV(sv) );
1N/A# else
1N/A# ifdef OS2
1N/A os2_setsyserrno(SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv));
1N/A# else
1N/A /* will anyone ever use this? */
1N/A SETERRNO(SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv), 4);
1N/A# endif
1N/A# endif
1N/A# endif
1N/A#endif
1N/A }
1N/A else if (strEQ(mg->mg_ptr+1, "NCODING")) {
1N/A if (PL_encoding)
1N/A SvREFCNT_dec(PL_encoding);
1N/A if (SvOK(sv) || SvGMAGICAL(sv)) {
1N/A PL_encoding = newSVsv(sv);
1N/A }
1N/A else {
1N/A PL_encoding = Nullsv;
1N/A }
1N/A }
1N/A break;
1N/A case '\006': /* ^F */
1N/A PL_maxsysfd = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv);
1N/A break;
1N/A case '\010': /* ^H */
1N/A PL_hints = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv);
1N/A break;
1N/A case '\011': /* ^I */ /* NOT \t in EBCDIC */
1N/A if (PL_inplace)
1N/A Safefree(PL_inplace);
1N/A if (SvOK(sv))
1N/A PL_inplace = savepv(SvPV(sv,len));
1N/A else
1N/A PL_inplace = Nullch;
1N/A break;
1N/A case '\017': /* ^O */
1N/A if (*(mg->mg_ptr+1) == '\0') {
1N/A if (PL_osname) {
1N/A Safefree(PL_osname);
1N/A PL_osname = Nullch;
1N/A }
1N/A if (SvOK(sv)) {
1N/A TAINT_PROPER("assigning to $^O");
1N/A PL_osname = savepv(SvPV(sv,len));
1N/A }
1N/A }
1N/A else if (strEQ(mg->mg_ptr, "\017PEN")) {
1N/A if (!PL_compiling.cop_io)
1N/A PL_compiling.cop_io = newSVsv(sv);
1N/A else
1N/A sv_setsv(PL_compiling.cop_io,sv);
1N/A }
1N/A break;
1N/A case '\020': /* ^P */
1N/A PL_perldb = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv);
1N/A if ((PERLDB_SUB || PERLDB_LINE || PERLDB_SUBLINE)
1N/A && !PL_DBsingle)
1N/A init_debugger();
1N/A break;
1N/A case '\024': /* ^T */
1N/A#ifdef BIG_TIME
1N/A PL_basetime = (Time_t)(SvNOK(sv) ? SvNVX(sv) : sv_2nv(sv));
1N/A#else
1N/A PL_basetime = (Time_t)(SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv));
1N/A#endif
1N/A break;
1N/A case '\027': /* ^W & $^WARNING_BITS */
1N/A if (*(mg->mg_ptr+1) == '\0') {
1N/A if ( ! (PL_dowarn & G_WARN_ALL_MASK)) {
1N/A i = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv);
1N/A PL_dowarn = (PL_dowarn & ~G_WARN_ON)
1N/A | (i ? G_WARN_ON : G_WARN_OFF) ;
1N/A }
1N/A }
1N/A else if (strEQ(mg->mg_ptr+1, "ARNING_BITS")) {
1N/A if ( ! (PL_dowarn & G_WARN_ALL_MASK)) {
1N/A if (!SvPOK(sv) && PL_localizing) {
1N/A sv_setpvn(sv, WARN_NONEstring, WARNsize);
1N/A PL_compiling.cop_warnings = pWARN_NONE;
1N/A break;
1N/A }
1N/A {
1N/A STRLEN len, i;
1N/A int accumulate = 0 ;
1N/A int any_fatals = 0 ;
1N/A char * ptr = (char*)SvPV(sv, len) ;
1N/A for (i = 0 ; i < len ; ++i) {
1N/A accumulate |= ptr[i] ;
1N/A any_fatals |= (ptr[i] & 0xAA) ;
1N/A }
1N/A if (!accumulate)
1N/A PL_compiling.cop_warnings = pWARN_NONE;
1N/A else if (isWARN_on(sv, WARN_ALL) && !any_fatals) {
1N/A PL_compiling.cop_warnings = pWARN_ALL;
1N/A PL_dowarn |= G_WARN_ONCE ;
1N/A }
1N/A else {
1N/A if (specialWARN(PL_compiling.cop_warnings))
1N/A PL_compiling.cop_warnings = newSVsv(sv) ;
1N/A else
1N/A sv_setsv(PL_compiling.cop_warnings, sv);
1N/A if (isWARN_on(PL_compiling.cop_warnings, WARN_ONCE))
1N/A PL_dowarn |= G_WARN_ONCE ;
1N/A }
1N/A
1N/A }
1N/A }
1N/A }
1N/A break;
1N/A case '.':
1N/A if (PL_localizing) {
1N/A if (PL_localizing == 1)
1N/A SAVESPTR(PL_last_in_gv);
1N/A }
1N/A else if (SvOK(sv) && GvIO(PL_last_in_gv))
1N/A IoLINES(GvIOp(PL_last_in_gv)) = SvIV(sv);
1N/A break;
1N/A case '^':
1N/A Safefree(IoTOP_NAME(GvIOp(PL_defoutgv)));
1N/A IoTOP_NAME(GvIOp(PL_defoutgv)) = s = savepv(SvPV(sv,len));
1N/A IoTOP_GV(GvIOp(PL_defoutgv)) = gv_fetchpv(s,TRUE, SVt_PVIO);
1N/A break;
1N/A case '~':
1N/A Safefree(IoFMT_NAME(GvIOp(PL_defoutgv)));
1N/A IoFMT_NAME(GvIOp(PL_defoutgv)) = s = savepv(SvPV(sv,len));
1N/A IoFMT_GV(GvIOp(PL_defoutgv)) = gv_fetchpv(s,TRUE, SVt_PVIO);
1N/A break;
1N/A case '=':
1N/A IoPAGE_LEN(GvIOp(PL_defoutgv)) = (SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv));
1N/A break;
1N/A case '-':
1N/A IoLINES_LEFT(GvIOp(PL_defoutgv)) = (SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv));
1N/A if (IoLINES_LEFT(GvIOp(PL_defoutgv)) < 0L)
1N/A IoLINES_LEFT(GvIOp(PL_defoutgv)) = 0L;
1N/A break;
1N/A case '%':
1N/A IoPAGE(GvIOp(PL_defoutgv)) = (SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv));
1N/A break;
1N/A case '|':
1N/A {
1N/A IO *io = GvIOp(PL_defoutgv);
1N/A if(!io)
1N/A break;
1N/A if ((SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv)) == 0)
1N/A IoFLAGS(io) &= ~IOf_FLUSH;
1N/A else {
1N/A if (!(IoFLAGS(io) & IOf_FLUSH)) {
1N/A PerlIO *ofp = IoOFP(io);
1N/A if (ofp)
1N/A (void)PerlIO_flush(ofp);
1N/A IoFLAGS(io) |= IOf_FLUSH;
1N/A }
1N/A }
1N/A }
1N/A break;
1N/A case '*':
1N/A i = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv);
1N/A PL_multiline = (i != 0);
1N/A break;
1N/A case '/':
1N/A SvREFCNT_dec(PL_rs);
1N/A PL_rs = newSVsv(sv);
1N/A break;
1N/A case '\\':
1N/A if (PL_ors_sv)
1N/A SvREFCNT_dec(PL_ors_sv);
1N/A if (SvOK(sv) || SvGMAGICAL(sv)) {
1N/A PL_ors_sv = newSVsv(sv);
1N/A }
1N/A else {
1N/A PL_ors_sv = Nullsv;
1N/A }
1N/A break;
1N/A case ',':
1N/A if (PL_ofs_sv)
1N/A SvREFCNT_dec(PL_ofs_sv);
1N/A if (SvOK(sv) || SvGMAGICAL(sv)) {
1N/A PL_ofs_sv = newSVsv(sv);
1N/A }
1N/A else {
1N/A PL_ofs_sv = Nullsv;
1N/A }
1N/A break;
1N/A case '#':
1N/A if (PL_ofmt)
1N/A Safefree(PL_ofmt);
1N/A PL_ofmt = savepv(SvPV(sv,len));
1N/A break;
1N/A case '[':
1N/A PL_compiling.cop_arybase = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv);
1N/A break;
1N/A case '?':
1N/A#ifdef COMPLEX_STATUS
1N/A if (PL_localizing == 2) {
1N/A PL_statusvalue = LvTARGOFF(sv);
1N/A PL_statusvalue_vms = LvTARGLEN(sv);
1N/A }
1N/A else
1N/A#endif
1N/A#ifdef VMSISH_STATUS
1N/A if (VMSISH_STATUS)
1N/A STATUS_NATIVE_SET((U32)(SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv)));
1N/A else
1N/A#endif
1N/A STATUS_POSIX_SET(SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv));
1N/A break;
1N/A case '!':
1N/A {
1N/A#ifdef VMS
1N/A# define PERL_VMS_BANG vaxc$errno
1N/A#else
1N/A# define PERL_VMS_BANG 0
1N/A#endif
1N/A SETERRNO(SvIOK(sv) ? SvIVX(sv) : SvOK(sv) ? sv_2iv(sv) : 0,
1N/A (SvIV(sv) == EVMSERR) ? 4 : PERL_VMS_BANG);
1N/A }
1N/A break;
1N/A case '<':
1N/A PL_uid = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv);
1N/A if (PL_delaymagic) {
1N/A PL_delaymagic |= DM_RUID;
1N/A break; /* don't do magic till later */
1N/A }
1N/A#ifdef HAS_SETRUID
1N/A (void)setruid((Uid_t)PL_uid);
1N/A#else
1N/A#ifdef HAS_SETREUID
1N/A (void)setreuid((Uid_t)PL_uid, (Uid_t)-1);
1N/A#else
1N/A#ifdef HAS_SETRESUID
1N/A (void)setresuid((Uid_t)PL_uid, (Uid_t)-1, (Uid_t)-1);
1N/A#else
1N/A if (PL_uid == PL_euid) { /* special case $< = $> */
1N/A#ifdef PERL_DARWIN
1N/A /* workaround for Darwin's setuid peculiarity, cf [perl #24122] */
1N/A if (PL_uid != 0 && PerlProc_getuid() == 0)
1N/A (void)PerlProc_setuid(0);
1N/A#endif
1N/A (void)PerlProc_setuid(PL_uid);
1N/A } else {
1N/A PL_uid = PerlProc_getuid();
1N/A Perl_croak(aTHX_ "setruid() not implemented");
1N/A }
1N/A#endif
1N/A#endif
1N/A#endif
1N/A PL_uid = PerlProc_getuid();
1N/A PL_tainting |= (PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid));
1N/A break;
1N/A case '>':
1N/A PL_euid = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv);
1N/A if (PL_delaymagic) {
1N/A PL_delaymagic |= DM_EUID;
1N/A break; /* don't do magic till later */
1N/A }
1N/A#ifdef HAS_SETEUID
1N/A (void)seteuid((Uid_t)PL_euid);
1N/A#else
1N/A#ifdef HAS_SETREUID
1N/A (void)setreuid((Uid_t)-1, (Uid_t)PL_euid);
1N/A#else
1N/A#ifdef HAS_SETRESUID
1N/A (void)setresuid((Uid_t)-1, (Uid_t)PL_euid, (Uid_t)-1);
1N/A#else
1N/A if (PL_euid == PL_uid) /* special case $> = $< */
1N/A PerlProc_setuid(PL_euid);
1N/A else {
1N/A PL_euid = PerlProc_geteuid();
1N/A Perl_croak(aTHX_ "seteuid() not implemented");
1N/A }
1N/A#endif
1N/A#endif
1N/A#endif
1N/A PL_euid = PerlProc_geteuid();
1N/A PL_tainting |= (PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid));
1N/A break;
1N/A case '(':
1N/A PL_gid = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv);
1N/A if (PL_delaymagic) {
1N/A PL_delaymagic |= DM_RGID;
1N/A break; /* don't do magic till later */
1N/A }
1N/A#ifdef HAS_SETRGID
1N/A (void)setrgid((Gid_t)PL_gid);
1N/A#else
1N/A#ifdef HAS_SETREGID
1N/A (void)setregid((Gid_t)PL_gid, (Gid_t)-1);
1N/A#else
1N/A#ifdef HAS_SETRESGID
1N/A (void)setresgid((Gid_t)PL_gid, (Gid_t)-1, (Gid_t) 1);
1N/A#else
1N/A if (PL_gid == PL_egid) /* special case $( = $) */
1N/A (void)PerlProc_setgid(PL_gid);
1N/A else {
1N/A PL_gid = PerlProc_getgid();
1N/A Perl_croak(aTHX_ "setrgid() not implemented");
1N/A }
1N/A#endif
1N/A#endif
1N/A#endif
1N/A PL_gid = PerlProc_getgid();
1N/A PL_tainting |= (PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid));
1N/A break;
1N/A case ')':
1N/A#ifdef HAS_SETGROUPS
1N/A {
1N/A char *p = SvPV(sv, len);
1N/A#ifdef _SC_NGROUPS_MAX
1N/A int maxgrp = sysconf(_SC_NGROUPS_MAX);
1N/A Groups_t *gary = alloca(maxgrp * sizeof (Groups_t));
1N/A#else
1N/A int maxgrp = NGROUPS;
1N/A Groups_t gary[NGROUPS];
1N/A#endif
1N/A
1N/A while (isSPACE(*p))
1N/A ++p;
1N/A PL_egid = Atol(p);
1N/A for (i = 0; i < maxgrp; ++i) {
1N/A while (*p && !isSPACE(*p))
1N/A ++p;
1N/A while (isSPACE(*p))
1N/A ++p;
1N/A if (!*p)
1N/A break;
1N/A gary[i] = Atol(p);
1N/A }
1N/A if (i)
1N/A (void)setgroups(i, gary);
1N/A }
1N/A#else /* HAS_SETGROUPS */
1N/A PL_egid = SvIOK(sv) ? SvIVX(sv) : sv_2iv(sv);
1N/A#endif /* HAS_SETGROUPS */
1N/A if (PL_delaymagic) {
1N/A PL_delaymagic |= DM_EGID;
1N/A break; /* don't do magic till later */
1N/A }
1N/A#ifdef HAS_SETEGID
1N/A (void)setegid((Gid_t)PL_egid);
1N/A#else
1N/A#ifdef HAS_SETREGID
1N/A (void)setregid((Gid_t)-1, (Gid_t)PL_egid);
1N/A#else
1N/A#ifdef HAS_SETRESGID
1N/A (void)setresgid((Gid_t)-1, (Gid_t)PL_egid, (Gid_t)-1);
1N/A#else
1N/A if (PL_egid == PL_gid) /* special case $) = $( */
1N/A (void)PerlProc_setgid(PL_egid);
1N/A else {
1N/A PL_egid = PerlProc_getegid();
1N/A Perl_croak(aTHX_ "setegid() not implemented");
1N/A }
1N/A#endif
1N/A#endif
1N/A#endif
1N/A PL_egid = PerlProc_getegid();
1N/A PL_tainting |= (PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid));
1N/A break;
1N/A case ':':
1N/A PL_chopset = SvPV_force(sv,len);
1N/A break;
1N/A#ifndef MACOS_TRADITIONAL
1N/A case '0':
1N/A LOCK_DOLLARZERO_MUTEX;
1N/A#ifdef HAS_SETPROCTITLE
1N/A /* The BSDs don't show the argv[] in ps(1) output, they
1N/A * show a string from the process struct and provide
1N/A * the setproctitle() routine to manipulate that. */
1N/A {
1N/A s = SvPV(sv, len);
1N/A# if __FreeBSD_version > 410001
1N/A /* The leading "-" removes the "perl: " prefix,
1N/A * but not the "(perl) suffix from the ps(1)
1N/A * output, because that's what ps(1) shows if the
1N/A * argv[] is modified. */
1N/A setproctitle("-%s", s);
1N/A# else /* old FreeBSDs, NetBSD, OpenBSD, anyBSD */
1N/A /* This doesn't really work if you assume that
1N/A * $0 = 'foobar'; will wipe out 'perl' from the $0
1N/A * because in ps(1) output the result will be like
1N/A * sprintf("perl: %s (perl)", s)
1N/A * I guess this is a security feature:
1N/A * one (a user process) cannot get rid of the original name.
1N/A * --jhi */
1N/A setproctitle("%s", s);
1N/A# endif
1N/A }
1N/A#endif
1N/A#if defined(__hpux) && defined(PSTAT_SETCMD)
1N/A {
1N/A union pstun un;
1N/A s = SvPV(sv, len);
1N/A un.pst_command = s;
1N/A pstat(PSTAT_SETCMD, un, len, 0, 0);
1N/A }
1N/A#endif
1N/A /* PL_origalen is set in perl_parse(). */
1N/A s = SvPV_force(sv,len);
1N/A if (len >= (STRLEN)PL_origalen) {
1N/A /* Longer than original, will be truncated. */
1N/A Copy(s, PL_origargv[0], PL_origalen, char);
1N/A PL_origargv[0][PL_origalen - 1] = 0;
1N/A }
1N/A else {
1N/A /* Shorter than original, will be padded. */
1N/A Copy(s, PL_origargv[0], len, char);
1N/A PL_origargv[0][len] = 0;
1N/A memset(PL_origargv[0] + len + 1,
1N/A /* Is the space counterintuitive? Yes.
1N/A * (You were expecting \0?)
1N/A * Does it work? Seems to. (In Linux 2.4.20 at least.)
1N/A * --jhi */
1N/A (int)' ',
1N/A PL_origalen - len - 1);
1N/A for (i = 1; i < PL_origargc; i++)
1N/A PL_origargv[i] = 0;
1N/A }
1N/A UNLOCK_DOLLARZERO_MUTEX;
1N/A break;
1N/A#endif
1N/A#ifdef USE_5005THREADS
1N/A case '@':
1N/A sv_setsv(thr->errsv, sv);
1N/A break;
1N/A#endif /* USE_5005THREADS */
1N/A }
1N/A return 0;
1N/A}
1N/A
1N/A#ifdef USE_5005THREADS
1N/Aint
1N/APerl_magic_mutexfree(pTHX_ SV *sv, MAGIC *mg)
1N/A{
1N/A DEBUG_S(PerlIO_printf(Perl_debug_log,
1N/A "0x%"UVxf": magic_mutexfree 0x%"UVxf"\n",
1N/A PTR2UV(thr), PTR2UV(sv)));
1N/A if (MgOWNER(mg))
1N/A Perl_croak(aTHX_ "panic: magic_mutexfree");
1N/A MUTEX_DESTROY(MgMUTEXP(mg));
1N/A COND_DESTROY(MgCONDP(mg));
1N/A return 0;
1N/A}
1N/A#endif /* USE_5005THREADS */
1N/A
1N/AI32
1N/APerl_whichsig(pTHX_ char *sig)
1N/A{
1N/A register char **sigv;
1N/A
1N/A for (sigv = PL_sig_name; *sigv; sigv++)
1N/A if (strEQ(sig,*sigv))
1N/A return PL_sig_num[sigv - PL_sig_name];
1N/A#ifdef SIGCLD
1N/A if (strEQ(sig,"CHLD"))
1N/A return SIGCLD;
1N/A#endif
1N/A#ifdef SIGCHLD
1N/A if (strEQ(sig,"CLD"))
1N/A return SIGCHLD;
1N/A#endif
1N/A return -1;
1N/A}
1N/A
1N/A#if !defined(PERL_IMPLICIT_CONTEXT)
1N/Astatic SV* sig_sv;
1N/A#endif
1N/A
1N/ASignal_t
1N/APerl_sighandler(int sig)
1N/A{
1N/A#ifdef PERL_GET_SIG_CONTEXT
1N/A dTHXa(PERL_GET_SIG_CONTEXT);
1N/A#else
1N/A dTHX;
1N/A#endif
1N/A dSP;
1N/A GV *gv = Nullgv;
1N/A HV *st;
1N/A SV *sv = Nullsv, *tSv = PL_Sv;
1N/A CV *cv = Nullcv;
1N/A OP *myop = PL_op;
1N/A U32 flags = 0;
1N/A XPV *tXpv = PL_Xpv;
1N/A
1N/A if (PL_savestack_ix + 15 <= PL_savestack_max)
1N/A flags |= 1;
1N/A if (PL_markstack_ptr < PL_markstack_max - 2)
1N/A flags |= 4;
1N/A if (PL_retstack_ix < PL_retstack_max - 2)
1N/A flags |= 8;
1N/A if (PL_scopestack_ix < PL_scopestack_max - 3)
1N/A flags |= 16;
1N/A
1N/A if (!PL_psig_ptr[sig]) {
1N/A PerlIO_printf(Perl_error_log, "Signal SIG%s received, but no signal handler set.\n",
1N/A PL_sig_name[sig]);
1N/A exit(sig);
1N/A }
1N/A
1N/A /* Max number of items pushed there is 3*n or 4. We cannot fix
1N/A infinity, so we fix 4 (in fact 5): */
1N/A if (flags & 1) {
1N/A PL_savestack_ix += 5; /* Protect save in progress. */
1N/A SAVEDESTRUCTOR_X(unwind_handler_stack, (void*)&flags);
1N/A }
1N/A if (flags & 4)
1N/A PL_markstack_ptr++; /* Protect mark. */
1N/A if (flags & 8) {
1N/A PL_retstack_ix++;
1N/A PL_retstack[PL_retstack_ix] = NULL;
1N/A }
1N/A if (flags & 16)
1N/A PL_scopestack_ix += 1;
1N/A /* sv_2cv is too complicated, try a simpler variant first: */
1N/A if (!SvROK(PL_psig_ptr[sig]) || !(cv = (CV*)SvRV(PL_psig_ptr[sig]))
1N/A || SvTYPE(cv) != SVt_PVCV)
1N/A cv = sv_2cv(PL_psig_ptr[sig],&st,&gv,TRUE);
1N/A
1N/A if (!cv || !CvROOT(cv)) {
1N/A if (ckWARN(WARN_SIGNAL))
1N/A Perl_warner(aTHX_ packWARN(WARN_SIGNAL), "SIG%s handler \"%s\" not defined.\n",
1N/A PL_sig_name[sig], (gv ? GvENAME(gv)
1N/A : ((cv && CvGV(cv))
1N/A ? GvENAME(CvGV(cv))
1N/A : "__ANON__")));
1N/A goto cleanup;
1N/A }
1N/A
1N/A if(PL_psig_name[sig]) {
1N/A sv = SvREFCNT_inc(PL_psig_name[sig]);
1N/A flags |= 64;
1N/A#if !defined(PERL_IMPLICIT_CONTEXT)
1N/A sig_sv = sv;
1N/A#endif
1N/A } else {
1N/A sv = sv_newmortal();
1N/A sv_setpv(sv,PL_sig_name[sig]);
1N/A }
1N/A
1N/A PUSHSTACKi(PERLSI_SIGNAL);
1N/A PUSHMARK(SP);
1N/A PUSHs(sv);
1N/A PUTBACK;
1N/A
1N/A call_sv((SV*)cv, G_DISCARD|G_EVAL);
1N/A
1N/A POPSTACK;
1N/A if (SvTRUE(ERRSV)) {
1N/A#ifndef PERL_MICRO
1N/A#ifdef HAS_SIGPROCMASK
1N/A /* Handler "died", for example to get out of a restart-able read().
1N/A * Before we re-do that on its behalf re-enable the signal which was
1N/A * blocked by the system when we entered.
1N/A */
1N/A sigset_t set;
1N/A sigemptyset(&set);
1N/A sigaddset(&set,sig);
1N/A sigprocmask(SIG_UNBLOCK, &set, NULL);
1N/A#else
1N/A /* Not clear if this will work */
1N/A (void)rsignal(sig, SIG_IGN);
1N/A (void)rsignal(sig, PL_csighandlerp);
1N/A#endif
1N/A#endif /* !PERL_MICRO */
1N/A Perl_die(aTHX_ Nullformat);
1N/A }
1N/Acleanup:
1N/A if (flags & 1)
1N/A PL_savestack_ix -= 8; /* Unprotect save in progress. */
1N/A if (flags & 4)
1N/A PL_markstack_ptr--;
1N/A if (flags & 8)
1N/A PL_retstack_ix--;
1N/A if (flags & 16)
1N/A PL_scopestack_ix -= 1;
1N/A if (flags & 64)
1N/A SvREFCNT_dec(sv);
1N/A PL_op = myop; /* Apparently not needed... */
1N/A
1N/A PL_Sv = tSv; /* Restore global temporaries. */
1N/A PL_Xpv = tXpv;
1N/A return;
1N/A}
1N/A
1N/A
1N/Astatic void
1N/Arestore_magic(pTHX_ void *p)
1N/A{
1N/A MGS* mgs = SSPTR(PTR2IV(p), MGS*);
1N/A SV* sv = mgs->mgs_sv;
1N/A
1N/A if (!sv)
1N/A return;
1N/A
1N/A if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv))
1N/A {
1N/A if (mgs->mgs_flags)
1N/A SvFLAGS(sv) |= mgs->mgs_flags;
1N/A else
1N/A mg_magical(sv);
1N/A if (SvGMAGICAL(sv))
1N/A SvFLAGS(sv) &= ~(SVf_IOK|SVf_NOK|SVf_POK);
1N/A }
1N/A
1N/A mgs->mgs_sv = NULL; /* mark the MGS structure as restored */
1N/A
1N/A /* If we're still on top of the stack, pop us off. (That condition
1N/A * will be satisfied if restore_magic was called explicitly, but *not*
1N/A * if it's being called via leave_scope.)
1N/A * The reason for doing this is that otherwise, things like sv_2cv()
1N/A * may leave alloc gunk on the savestack, and some code
1N/A * (e.g. sighandler) doesn't expect that...
1N/A */
1N/A if (PL_savestack_ix == mgs->mgs_ss_ix)
1N/A {
1N/A I32 popval = SSPOPINT;
1N/A assert(popval == SAVEt_DESTRUCTOR_X);
1N/A PL_savestack_ix -= 2;
1N/A popval = SSPOPINT;
1N/A assert(popval == SAVEt_ALLOC);
1N/A popval = SSPOPINT;
1N/A PL_savestack_ix -= popval;
1N/A }
1N/A
1N/A}
1N/A
1N/Astatic void
1N/Aunwind_handler_stack(pTHX_ void *p)
1N/A{
1N/A U32 flags = *(U32*)p;
1N/A
1N/A if (flags & 1)
1N/A PL_savestack_ix -= 5; /* Unprotect save in progress. */
1N/A /* cxstack_ix-- Not needed, die already unwound it. */
1N/A#if !defined(PERL_IMPLICIT_CONTEXT)
1N/A if (flags & 64)
1N/A SvREFCNT_dec(sig_sv);
1N/A#endif
1N/A}
1N/A
1N/A