mg.c

   1 /*    mg.c
   2  *
   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
   5  *
   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.
   8  *
   9  */
  10
  11 /*
  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."
  14  */
  15
  16 /*
  17 =head1 Magical Functions
  18
  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).
  28
  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
  34 tie.
  35
  36 */
  37
  38 #include "EXTERN.h"
  39 #define PERL_IN_MG_C
  40 #include "perl.h"
  41
  42 #if defined(HAS_GETGROUPS) || defined(HAS_SETGROUPS)
  43 #  ifdef I_GRP
  44 #    include <grp.h>
  45 #  endif
  46 #endif
  47
  48 #if defined(HAS_SETGROUPS)
  49 #  ifndef NGROUPS
  50 #    define NGROUPS 32
  51 #  endif
  52 #endif
  53
  54 #ifdef __hpux
  55 #  include <sys/pstat.h>
  56 #endif
  57
  58 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
  59 Signal_t Perl_csighandler(int sig, siginfo_t *, void *);
  60 #else
  61 Signal_t Perl_csighandler(int sig);
  62 #endif
  63
  64 #ifdef __Lynx__
  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);
  70 #endif
  71
  72 /*
  73  * Use the "DESTRUCTOR" scope cleanup to reinstate magic.
  74  */
  75
  76 struct magic_state {
  77     SV* mgs_sv;
  78     U32 mgs_flags;
  79     I32 mgs_ss_ix;
  80 };
  81 /* MGS is typedef'ed to struct magic_state in perl.h */
  82
  83 STATIC void
  84 S_save_magic(pTHX_ I32 mgs_ix, SV *sv)
  85 {
  86     dVAR;
  87     MGS* mgs;
  88     assert(SvMAGICAL(sv));
  89     /* Turning READONLY off for a copy-on-write scalar (including shared
  90        hash keys) is a bad idea.  */
  91     if (SvIsCOW(sv))
  92       sv_force_normal_flags(sv, 0);
  93
  94     SAVEDESTRUCTOR_X(S_restore_magic, INT2PTR(void*, (IV)mgs_ix));
  95
  96     mgs = SSPTR(mgs_ix, MGS*);
  97     mgs->mgs_sv = sv;
  98     mgs->mgs_flags = SvMAGICAL(sv) | SvREADONLY(sv);
  99     mgs->mgs_ss_ix = PL_savestack_ix;   /* points after the saved destructor */
 100
 101     SvMAGICAL_off(sv);
 102     SvREADONLY_off(sv);
 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;
 106     }
 107 }
 108
 109 /*
 110 =for apidoc mg_magical
 111
 112 Turns on the magical status of an SV.  See C<sv_magic>.
 113
 114 =cut
 115 */
 116
 117 void
 118 Perl_mg_magical(pTHX_ SV *sv)
 119 {
 120     const MAGIC* mg;
 121     PERL_UNUSED_CONTEXT;
 122     for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
 123         const MGVTBL* const vtbl = mg->mg_virtual;
 124         if (vtbl) {
 125             if (vtbl->svt_get && !(mg->mg_flags & MGf_GSKIP))
 126                 SvGMAGICAL_on(sv);
 127             if (vtbl->svt_set)
 128                 SvSMAGICAL_on(sv);
 129             if (!(SvFLAGS(sv) & (SVs_GMG|SVs_SMG)) || vtbl->svt_clear)
 130                 SvRMAGICAL_on(sv);
 131         }
 132     }
 133 }
 134
 135
 136 /* is this container magic (%ENV, $1 etc), or value magic (pos, taint etc)? */
 137
 138 STATIC bool
 139 S_is_container_magic(const MAGIC *mg)
 140 {
 141     switch (mg->mg_type) {
 142     case PERL_MAGIC_bm:
 143     case PERL_MAGIC_fm:
 144     case PERL_MAGIC_regex_global:
 145     case PERL_MAGIC_nkeys:
 146 #ifdef USE_LOCALE_COLLATE
 147     case PERL_MAGIC_collxfrm:
 148 #endif
 149     case PERL_MAGIC_qr:
 150     case PERL_MAGIC_taint:
 151     case PERL_MAGIC_vec:
 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:
 157     case PERL_MAGIC_pos:
 158     case PERL_MAGIC_backref:
 159     case PERL_MAGIC_arylen_p:
 160     case PERL_MAGIC_rhash:
 161     case PERL_MAGIC_symtab:
 162         return 0;
 163     default:
 164         return 1;
 165     }
 166 }
 167
 168 /*
 169 =for apidoc mg_get
 170
 171 Do magic after a value is retrieved from the SV.  See C<sv_magic>.
 172
 173 =cut
 174 */
 175
 176 int
 177 Perl_mg_get(pTHX_ SV *sv)
 178 {
 179     dVAR;
 180     const I32 mgs_ix = SSNEW(sizeof(MGS));
 181     const bool was_temp = (bool)SvTEMP(sv);
 182     int have_new = 0;
 183     MAGIC *newmg, *head, *cur, *mg;
 184     /* guard against sv having being freed midway by holding a private
 185        reference. */
 186
 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).
 189        So restore it.
 190     */
 191     sv_2mortal(SvREFCNT_inc_simple_NN(sv));
 192     if (!was_temp) {
 193         SvTEMP_off(sv);
 194     }
 195
 196     save_magic(mgs_ix, sv);
 197
 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 */
 201
 202     newmg = cur = head = mg = SvMAGIC(sv);
 203     while (mg) {
 204         const MGVTBL * const vtbl = mg->mg_virtual;
 205
 206         if (!(mg->mg_flags & MGf_GSKIP) && vtbl && vtbl->svt_get) {
 207             CALL_FPTR(vtbl->svt_get)(aTHX_ sv, mg);
 208
 209             /* guard against magic having been deleted - eg FETCH calling
 210              * untie */
 211             if (!SvMAGIC(sv))
 212                 break;
 213
 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;
 217         }
 218
 219         mg = mg->mg_moremagic;
 220
 221         if (have_new) {
 222             /* Have we finished with the new entries we saw? Start again
 223                where we left off (unless there are more new entries). */
 224             if (mg == head) {
 225                 have_new = 0;
 226                 mg   = cur;
 227                 head = newmg;
 228             }
 229         }
 230
 231         /* Were any new entries added? */
 232         if (!have_new && (newmg = SvMAGIC(sv)) != head) {
 233             have_new = 1;
 234             cur = mg;
 235             mg  = newmg;
 236         }
 237     }
 238
 239     restore_magic(INT2PTR(void *, (IV)mgs_ix));
 240
 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.  */
 244         SvOK_off(sv);
 245     }
 246     return 0;
 247 }
 248
 249 /*
 250 =for apidoc mg_set
 251
 252 Do magic after a value is assigned to the SV.  See C<sv_magic>.
 253
 254 =cut
 255 */
 256
 257 int
 258 Perl_mg_set(pTHX_ SV *sv)
 259 {
 260     dVAR;
 261     const I32 mgs_ix = SSNEW(sizeof(MGS));
 262     MAGIC* mg;
 263     MAGIC* nextmg;
 264
 265     save_magic(mgs_ix, sv);
 266
 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;
 273         }
 274         if (PL_localizing == 2 && !S_is_container_magic(mg))
 275             continue;
 276         if (vtbl && vtbl->svt_set)
 277             CALL_FPTR(vtbl->svt_set)(aTHX_ sv, mg);
 278     }
 279
 280     restore_magic(INT2PTR(void*, (IV)mgs_ix));
 281     return 0;
 282 }
 283
 284 /*
 285 =for apidoc mg_length
 286
 287 Report on the SV's length.  See C<sv_magic>.
 288
 289 =cut
 290 */
 291
 292 U32
 293 Perl_mg_length(pTHX_ SV *sv)
 294 {
 295     dVAR;
 296     MAGIC* mg;
 297     STRLEN len;
 298
 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));
 307             return len;
 308         }
 309     }
 310
 311     if (DO_UTF8(sv)) {
 312         const U8 *s = (U8*)SvPV_const(sv, len);
 313         len = utf8_length(s, s + len);
 314     }
 315     else
 316         (void)SvPV_const(sv, len);
 317     return len;
 318 }
 319
 320 I32
 321 Perl_mg_size(pTHX_ SV *sv)
 322 {
 323     MAGIC* mg;
 324
 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));
 329             I32 len;
 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));
 334             return len;
 335         }
 336     }
 337
 338     switch(SvTYPE(sv)) {
 339         case SVt_PVAV:
 340             return AvFILLp((AV *) sv); /* Fallback to non-tied array */
 341         case SVt_PVHV:
 342             /* FIXME */
 343         default:
 344             Perl_croak(aTHX_ "Size magic not implemented");
 345             break;
 346     }
 347     return 0;
 348 }
 349
 350 /*
 351 =for apidoc mg_clear
 352
 353 Clear something magical that the SV represents.  See C<sv_magic>.
 354
 355 =cut
 356 */
 357
 358 int
 359 Perl_mg_clear(pTHX_ SV *sv)
 360 {
 361     const I32 mgs_ix = SSNEW(sizeof(MGS));
 362     MAGIC* mg;
 363
 364     save_magic(mgs_ix, sv);
 365
 366     for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
 367         const MGVTBL* const vtbl = mg->mg_virtual;
 368         /* omit GSKIP -- never set here */
 369
 370         if (vtbl && vtbl->svt_clear)
 371             CALL_FPTR(vtbl->svt_clear)(aTHX_ sv, mg);
 372     }
 373
 374     restore_magic(INT2PTR(void*, (IV)mgs_ix));
 375     return 0;
 376 }
 377
 378 /*
 379 =for apidoc mg_find
 380
 381 Finds the magic pointer for type matching the SV.  See C<sv_magic>.
 382
 383 =cut
 384 */
 385
 386 MAGIC*
 387 Perl_mg_find(pTHX_ const SV *sv, int type)
 388 {
 389     PERL_UNUSED_CONTEXT;
 390     if (sv) {
 391         MAGIC *mg;
 392         for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
 393             if (mg->mg_type == type)
 394                 return mg;
 395         }
 396     }
 397     return NULL;
 398 }
 399
 400 /*
 401 =for apidoc mg_copy
 402
 403 Copies the magic from one SV to another.  See C<sv_magic>.
 404
 405 =cut
 406 */
 407
 408 int
 409 Perl_mg_copy(pTHX_ SV *sv, SV *nsv, const char *key, I32 klen)
 410 {
 411     int count = 0;
 412     MAGIC* mg;
 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);
 417         }
 418         else {
 419             const char type = mg->mg_type;
 420             if (isUPPER(type) && type != PERL_MAGIC_uvar) {
 421                 sv_magic(nsv,
 422                      (type == PERL_MAGIC_tied)
 423                         ? SvTIED_obj(sv, mg)
 424                         : (type == PERL_MAGIC_regdata && mg->mg_obj)
 425                             ? sv
 426                             : mg->mg_obj,
 427                      toLOWER(type), key, klen);
 428                 count++;
 429             }
 430         }
 431     }
 432     return count;
 433 }
 434
 435 /*
 436 =for apidoc mg_localize
 437
 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).
 441
 442 =cut
 443 */
 444
 445 void
 446 Perl_mg_localize(pTHX_ SV *sv, SV *nsv)
 447 {
 448     dVAR;
 449     MAGIC *mg;
 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))
 453             continue;
 454
 455         if ((mg->mg_flags & MGf_LOCAL) && vtbl->svt_local)
 456             (void)CALL_FPTR(vtbl->svt_local)(aTHX_ nsv, mg);
 457         else
 458             sv_magicext(nsv, mg->mg_obj, mg->mg_type, vtbl,
 459                             mg->mg_ptr, mg->mg_len);
 460
 461         /* container types should remain read-only across localization */
 462         SvFLAGS(nsv) |= SvREADONLY(sv);
 463     }
 464
 465     if (SvTYPE(nsv) >= SVt_PVMG && SvMAGIC(nsv)) {
 466         SvFLAGS(nsv) |= SvMAGICAL(sv);
 467         PL_localizing = 1;
 468         SvSETMAGIC(nsv);
 469         PL_localizing = 0;
 470     }
 471 }
 472
 473 /*
 474 =for apidoc mg_free
 475
 476 Free any magic storage used by the SV.  See C<sv_magic>.
 477
 478 =cut
 479 */
 480
 481 int
 482 Perl_mg_free(pTHX_ SV *sv)
 483 {
 484     MAGIC* mg;
 485     MAGIC* moremagic;
 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);
 496         }
 497         if (mg->mg_flags & MGf_REFCOUNTED)
 498             SvREFCNT_dec(mg->mg_obj);
 499         Safefree(mg);
 500     }
 501     SvMAGIC_set(sv, NULL);
 502     return 0;
 503 }
 504
 505 #include <signal.h>
 506
 507 U32
 508 Perl_magic_regdata_cnt(pTHX_ SV *sv, MAGIC *mg)
 509 {
 510     dVAR;
 511     PERL_UNUSED_ARG(sv);
 512
 513     if (PL_curpm) {
 514         register const REGEXP * const rx = PM_GETRE(PL_curpm);
 515         if (rx) {
 516             if (mg->mg_obj) {                   /* @+ */
 517                 /* return the number possible */
 518                 return rx->nparens;
 519             } else {                            /* @- */
 520                 I32 paren = rx->lastparen;
 521
 522                 /* return the last filled */
 523                 while ( paren >= 0
 524                         && (rx->offs[paren].start == -1
 525                             || rx->offs[paren].end == -1) )
 526                     paren--;
 527                 return (U32)paren;
 528             }
 529         }
 530     }
 531
 532     return (U32)-1;
 533 }
 534
 535 int
 536 Perl_magic_regdatum_get(pTHX_ SV *sv, MAGIC *mg)
 537 {
 538     dVAR;
 539     if (PL_curpm) {
 540         register const REGEXP * const rx = PM_GETRE(PL_curpm);
 541         if (rx) {
 542             register const I32 paren = mg->mg_len;
 543             register I32 s;
 544             register I32 t;
 545             if (paren < 0)
 546                 return 0;
 547             if (paren <= (I32)rx->nparens &&
 548                 (s = rx->offs[paren].start) != -1 &&
 549                 (t = rx->offs[paren].end) != -1)
 550                 {
 551                     register I32 i;
 552                     if (mg->mg_obj)             /* @+ */
 553                         i = t;
 554                     else                        /* @- */
 555                         i = s;
 556
 557                     if (i > 0 && RX_MATCH_UTF8(rx)) {
 558                         const char * const b = rx->subbeg;
 559                         if (b)
 560                             i = utf8_length((U8*)b, (U8*)(b+i));
 561                     }
 562
 563                     sv_setiv(sv, i);
 564                 }
 565         }
 566     }
 567     return 0;
 568 }
 569
 570 int
 571 Perl_magic_regdatum_set(pTHX_ SV *sv, MAGIC *mg)
 572 {
 573     PERL_UNUSED_ARG(sv);
 574     PERL_UNUSED_ARG(mg);
 575     Perl_croak(aTHX_ PL_no_modify);
 576     NORETURN_FUNCTION_END;
 577 }
 578
 579 U32
 580 Perl_magic_len(pTHX_ SV *sv, MAGIC *mg)
 581 {
 582     dVAR;
 583     register I32 paren;
 584     register I32 i;
 585     register const REGEXP * rx;
 586     const char * const remaining = mg->mg_ptr + 1;
 587
 588     switch (*mg->mg_ptr) {
 589     case '\020':
 590       if (*remaining == '\0') { /* ^P */
 591           break;
 592       } else if (strEQ(remaining, "REMATCH")) { /* $^PREMATCH */
 593           goto do_prematch;
 594       } else if (strEQ(remaining, "OSTMATCH")) { /* $^POSTMATCH */
 595           goto do_postmatch;
 596       }
 597       break;
 598     case '\015': /* $^MATCH */
 599         if (strEQ(remaining, "ATCH")) {
 600         goto do_match;
 601     } else {
 602         break;
 603     }
 604     case '`':
 605       do_prematch:
 606       paren = RX_BUFF_IDX_PREMATCH;
 607       goto maybegetparen;
 608     case '\'':
 609       do_postmatch:
 610       paren = RX_BUFF_IDX_POSTMATCH;
 611       goto maybegetparen;
 612     case '&':
 613       do_match:
 614       paren = RX_BUFF_IDX_FULLMATCH;
 615       goto maybegetparen;
 616     case '1': case '2': case '3': case '4':
 617     case '5': case '6': case '7': case '8': case '9':
 618       paren = atoi(mg->mg_ptr);
 619     maybegetparen:
 620         if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
 621       getparen:
 622         i = CALLREG_NUMBUF_LENGTH((REGEXP * const)rx, sv, paren);
 623
 624                 if (i < 0)
 625                     Perl_croak(aTHX_ "panic: magic_len: %"IVdf, (IV)i);
 626                 return i;
 627         } else {
 628                 if (ckWARN(WARN_UNINITIALIZED))
 629                     report_uninit(sv);
 630                 return 0;
 631         }
 632     case '+':
 633         if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
 634             paren = rx->lastparen;
 635             if (paren)
 636                 goto getparen;
 637         }
 638         return 0;
 639     case '\016': /* ^N */
 640         if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
 641             paren = rx->lastcloseparen;
 642             if (paren)
 643                 goto getparen;
 644         }
 645         return 0;
 646     }
 647     magic_get(sv,mg);
 648     if (!SvPOK(sv) && SvNIOK(sv)) {
 649         sv_2pv(sv, 0);
 650     }
 651     if (SvPOK(sv))
 652         return SvCUR(sv);
 653     return 0;
 654 }
 655
 656 #define SvRTRIM(sv) STMT_START { \
 657     if (SvPOK(sv)) { \
 658         STRLEN len = SvCUR(sv); \
 659         char * const p = SvPVX(sv); \
 660         while (len > 0 && isSPACE(p[len-1])) \
 661            --len; \
 662         SvCUR_set(sv, len); \
 663         p[len] = '\0'; \
 664     } \
 665 } STMT_END
 666
 667 void
 668 Perl_emulate_cop_io(pTHX_ const COP *const c, SV *const sv)
 669 {
 670     if (!(CopHINTS_get(c) & (HINT_LEXICAL_IO_IN|HINT_LEXICAL_IO_OUT)))
 671         sv_setsv(sv, &PL_sv_undef);
 672     else {
 673         sv_setpvs(sv, "");
 674         SvUTF8_off(sv);
 675         if ((CopHINTS_get(c) & HINT_LEXICAL_IO_IN)) {
 676             SV *const value = Perl_refcounted_he_fetch(aTHX_
 677                                                        c->cop_hints_hash,
 678                                                        0, "open<", 5, 0, 0);
 679             assert(value);
 680             sv_catsv(sv, value);
 681         }
 682         sv_catpvs(sv, "\0");
 683         if ((CopHINTS_get(c) & HINT_LEXICAL_IO_OUT)) {
 684             SV *const value = Perl_refcounted_he_fetch(aTHX_
 685                                                        c->cop_hints_hash,
 686                                                        0, "open>", 5, 0, 0);
 687             assert(value);
 688             sv_catsv(sv, value);
 689         }
 690     }
 691 }
 692
 693 int
 694 Perl_magic_get(pTHX_ SV *sv, MAGIC *mg)
 695 {
 696     dVAR;
 697     register I32 paren;
 698     register char *s = NULL;
 699     register REGEXP *rx;
 700     const char * const remaining = mg->mg_ptr + 1;
 701     const char nextchar = *remaining;
 702
 703     switch (*mg->mg_ptr) {
 704     case '\001':                /* ^A */
 705         sv_setsv(sv, PL_bodytarget);
 706         break;
 707     case '\003':                /* ^C, ^CHILD_ERROR_NATIVE */
 708         if (nextchar == '\0') {
 709             sv_setiv(sv, (IV)PL_minus_c);
 710         }
 711         else if (strEQ(remaining, "HILD_ERROR_NATIVE")) {
 712             sv_setiv(sv, (IV)STATUS_NATIVE);
 713         }
 714         break;
 715
 716     case '\004':                /* ^D */
 717         sv_setiv(sv, (IV)(PL_debug & DEBUG_MASK));
 718         break;
 719     case '\005':  /* ^E */
 720          if (nextchar == '\0') {
 721 #if defined(MACOS_TRADITIONAL)
 722              {
 723                   char msg[256];
 724
 725                   sv_setnv(sv,(double)gMacPerl_OSErr);
 726                   sv_setpv(sv, gMacPerl_OSErr ? GetSysErrText(gMacPerl_OSErr, msg) : "");
 727              }
 728 #elif defined(VMS)
 729              {
 730 #                 include <descrip.h>
 731 #                 include <starlet.h>
 732                   char msg[255];
 733                   $DESCRIPTOR(msgdsc,msg);
 734                   sv_setnv(sv,(NV) vaxc$errno);
 735                   if (sys$getmsg(vaxc$errno,&msgdsc.dsc$w_length,&msgdsc,0,0) & 1)
 736                        sv_setpvn(sv,msgdsc.dsc$a_pointer,msgdsc.dsc$w_length);
 737                   else
 738                        sv_setpvn(sv,"",0);
 739              }
 740 #elif defined(OS2)
 741              if (!(_emx_env & 0x200)) { /* Under DOS */
 742                   sv_setnv(sv, (NV)errno);
 743                   sv_setpv(sv, errno ? Strerror(errno) : "");
 744              } else {
 745                   if (errno != errno_isOS2) {
 746                        const int tmp = _syserrno();
 747                        if (tmp) /* 2nd call to _syserrno() makes it 0 */
 748                             Perl_rc = tmp;
 749                   }
 750                   sv_setnv(sv, (NV)Perl_rc);
 751                   sv_setpv(sv, os2error(Perl_rc));
 752              }
 753 #elif defined(WIN32)
 754              {
 755                   const DWORD dwErr = GetLastError();
 756                   sv_setnv(sv, (NV)dwErr);
 757                   if (dwErr) {
 758                        PerlProc_GetOSError(sv, dwErr);
 759                   }
 760                   else
 761                        sv_setpvn(sv, "", 0);
 762                   SetLastError(dwErr);
 763              }
 764 #else
 765              {
 766                  const int saveerrno = errno;
 767                  sv_setnv(sv, (NV)errno);
 768                  sv_setpv(sv, errno ? Strerror(errno) : "");
 769                  errno = saveerrno;
 770              }
 771 #endif
 772              SvRTRIM(sv);
 773              SvNOK_on(sv);      /* what a wonderful hack! */
 774          }
 775          else if (strEQ(remaining, "NCODING"))
 776               sv_setsv(sv, PL_encoding);
 777          break;
 778     case '\006':                /* ^F */
 779         sv_setiv(sv, (IV)PL_maxsysfd);
 780         break;
 781     case '\010':                /* ^H */
 782         sv_setiv(sv, (IV)PL_hints);
 783         break;
 784     case '\011':                /* ^I */ /* NOT \t in EBCDIC */
 785         if (PL_inplace)
 786             sv_setpv(sv, PL_inplace);
 787         else
 788             sv_setsv(sv, &PL_sv_undef);
 789         break;
 790     case '\017':                /* ^O & ^OPEN */
 791         if (nextchar == '\0') {
 792             sv_setpv(sv, PL_osname);
 793             SvTAINTED_off(sv);
 794         }
 795         else if (strEQ(remaining, "PEN")) {
 796             Perl_emulate_cop_io(aTHX_ &PL_compiling, sv);
 797         }
 798         break;
 799     case '\020':
 800         if (nextchar == '\0') {       /* ^P */
 801             sv_setiv(sv, (IV)PL_perldb);
 802         } else if (strEQ(remaining, "REMATCH")) { /* $^PREMATCH */
 803             goto do_prematch_fetch;
 804         } else if (strEQ(remaining, "OSTMATCH")) { /* $^POSTMATCH */
 805             goto do_postmatch_fetch;
 806         }
 807         break;
 808     case '\023':                /* ^S */
 809         if (nextchar == '\0') {
 810             if (PL_parser && PL_parser->lex_state != LEX_NOTPARSING)
 811                 SvOK_off(sv);
 812             else if (PL_in_eval)
 813                 sv_setiv(sv, PL_in_eval & ~(EVAL_INREQUIRE));
 814             else
 815                 sv_setiv(sv, 0);
 816         }
 817         break;
 818     case '\024':                /* ^T */
 819         if (nextchar == '\0') {
 820 #ifdef BIG_TIME
 821             sv_setnv(sv, PL_basetime);
 822 #else
 823             sv_setiv(sv, (IV)PL_basetime);
 824 #endif
 825         }
 826         else if (strEQ(remaining, "AINT"))
 827             sv_setiv(sv, PL_tainting
 828                     ? (PL_taint_warn || PL_unsafe ? -1 : 1)
 829                     : 0);
 830         break;
 831     case '\025':                /* $^UNICODE, $^UTF8LOCALE, $^UTF8CACHE */
 832         if (strEQ(remaining, "NICODE"))
 833             sv_setuv(sv, (UV) PL_unicode);
 834         else if (strEQ(remaining, "TF8LOCALE"))
 835             sv_setuv(sv, (UV) PL_utf8locale);
 836         else if (strEQ(remaining, "TF8CACHE"))
 837             sv_setiv(sv, (IV) PL_utf8cache);
 838         break;
 839     case '\027':                /* ^W  & $^WARNING_BITS */
 840         if (nextchar == '\0')
 841             sv_setiv(sv, (IV)((PL_dowarn & G_WARN_ON) ? TRUE : FALSE));
 842         else if (strEQ(remaining, "ARNING_BITS")) {
 843             if (PL_compiling.cop_warnings == pWARN_NONE) {
 844                 sv_setpvn(sv, WARN_NONEstring, WARNsize) ;
 845             }
 846             else if (PL_compiling.cop_warnings == pWARN_STD) {
 847                 sv_setpvn(
 848                     sv,
 849                     (PL_dowarn & G_WARN_ON) ? WARN_ALLstring : WARN_NONEstring,
 850                     WARNsize
 851                 );
 852             }
 853             else if (PL_compiling.cop_warnings == pWARN_ALL) {
 854                 /* Get the bit mask for $warnings::Bits{all}, because
 855                  * it could have been extended by warnings::register */
 856                 HV * const bits=get_hv("warnings::Bits", FALSE);
 857                 if (bits) {
 858                     SV ** const bits_all = hv_fetchs(bits, "all", FALSE);
 859                     if (bits_all)
 860                         sv_setsv(sv, *bits_all);
 861                 }
 862                 else {
 863                     sv_setpvn(sv, WARN_ALLstring, WARNsize) ;
 864                 }
 865             }
 866             else {
 867                 sv_setpvn(sv, (char *) (PL_compiling.cop_warnings + 1),
 868                           *PL_compiling.cop_warnings);
 869             }
 870             SvPOK_only(sv);
 871         }
 872         break;
 873     case '\015': /* $^MATCH */
 874         if (strEQ(remaining, "ATCH")) {
 875     case '1': case '2': case '3': case '4':
 876     case '5': case '6': case '7': case '8': case '9': case '&':
 877             if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
 878                 /*
 879                  * Pre-threads, this was paren = atoi(GvENAME((GV*)mg->mg_obj));
 880                  * XXX Does the new way break anything?
 881                  */
 882                 paren = atoi(mg->mg_ptr); /* $& is in [0] */
 883                 CALLREG_NUMBUF_FETCH(rx,paren,sv);
 884                 break;
 885             }
 886             sv_setsv(sv,&PL_sv_undef);
 887         }
 888         break;
 889     case '+':
 890         if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
 891             if (rx->lastparen) {
 892                 CALLREG_NUMBUF_FETCH(rx,rx->lastparen,sv);
 893                 break;
 894             }
 895         }
 896         sv_setsv(sv,&PL_sv_undef);
 897         break;
 898     case '\016':                /* ^N */
 899         if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
 900             if (rx->lastcloseparen) {
 901                 CALLREG_NUMBUF_FETCH(rx,rx->lastcloseparen,sv);
 902                 break;
 903             }
 904
 905         }
 906         sv_setsv(sv,&PL_sv_undef);
 907         break;
 908     case '`':
 909       do_prematch_fetch:
 910         if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
 911             CALLREG_NUMBUF_FETCH(rx,-2,sv);
 912             break;
 913         }
 914         sv_setsv(sv,&PL_sv_undef);
 915         break;
 916     case '\'':
 917       do_postmatch_fetch:
 918         if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
 919             CALLREG_NUMBUF_FETCH(rx,-1,sv);
 920             break;
 921         }
 922         sv_setsv(sv,&PL_sv_undef);
 923         break;
 924     case '.':
 925         if (GvIO(PL_last_in_gv)) {
 926             sv_setiv(sv, (IV)IoLINES(GvIOp(PL_last_in_gv)));
 927         }
 928         break;
 929     case '?':
 930         {
 931             sv_setiv(sv, (IV)STATUS_CURRENT);
 932 #ifdef COMPLEX_STATUS
 933             LvTARGOFF(sv) = PL_statusvalue;
 934             LvTARGLEN(sv) = PL_statusvalue_vms;
 935 #endif
 936         }
 937         break;
 938     case '^':
 939         if (GvIOp(PL_defoutgv))
 940             s = IoTOP_NAME(GvIOp(PL_defoutgv));
 941         if (s)
 942             sv_setpv(sv,s);
 943         else {
 944             sv_setpv(sv,GvENAME(PL_defoutgv));
 945             sv_catpv(sv,"_TOP");
 946         }
 947         break;
 948     case '~':
 949         if (GvIOp(PL_defoutgv))
 950             s = IoFMT_NAME(GvIOp(PL_defoutgv));
 951         if (!s)
 952             s = GvENAME(PL_defoutgv);
 953         sv_setpv(sv,s);
 954         break;
 955     case '=':
 956         if (GvIOp(PL_defoutgv))
 957             sv_setiv(sv, (IV)IoPAGE_LEN(GvIOp(PL_defoutgv)));
 958         break;
 959     case '-':
 960         if (GvIOp(PL_defoutgv))
 961             sv_setiv(sv, (IV)IoLINES_LEFT(GvIOp(PL_defoutgv)));
 962         break;
 963     case '%':
 964         if (GvIOp(PL_defoutgv))
 965             sv_setiv(sv, (IV)IoPAGE(GvIOp(PL_defoutgv)));
 966         break;
 967     case ':':
 968         break;
 969     case '/':
 970         break;
 971     case '[':
 972         sv_setiv(sv, (IV)CopARYBASE_get(PL_curcop));
 973         break;
 974     case '|':
 975         if (GvIOp(PL_defoutgv))
 976             sv_setiv(sv, (IV)(IoFLAGS(GvIOp(PL_defoutgv)) & IOf_FLUSH) != 0 );
 977         break;
 978     case ',':
 979         break;
 980     case '\\':
 981         if (PL_ors_sv)
 982             sv_copypv(sv, PL_ors_sv);
 983         break;
 984     case '!':
 985 #ifdef VMS
 986         sv_setnv(sv, (NV)((errno == EVMSERR) ? vaxc$errno : errno));
 987         sv_setpv(sv, errno ? Strerror(errno) : "");
 988 #else
 989         {
 990         const int saveerrno = errno;
 991         sv_setnv(sv, (NV)errno);
 992 #ifdef OS2
 993         if (errno == errno_isOS2 || errno == errno_isOS2_set)
 994             sv_setpv(sv, os2error(Perl_rc));
 995         else
 996 #endif
 997         sv_setpv(sv, errno ? Strerror(errno) : "");
 998         errno = saveerrno;
 999         }
1000 #endif
1001         SvRTRIM(sv);
1002         SvNOK_on(sv);   /* what a wonderful hack! */
1003         break;
1004     case '<':
1005         sv_setiv(sv, (IV)PL_uid);
1006         break;
1007     case '>':
1008         sv_setiv(sv, (IV)PL_euid);
1009         break;
1010     case '(':
1011         sv_setiv(sv, (IV)PL_gid);
1012         goto add_groups;
1013     case ')':
1014         sv_setiv(sv, (IV)PL_egid);
1015       add_groups:
1016 #ifdef HAS_GETGROUPS
1017         {
1018             Groups_t *gary = NULL;
1019             I32 i, num_groups = getgroups(0, gary);
1020             Newx(gary, num_groups, Groups_t);
1021             num_groups = getgroups(num_groups, gary);
1022             for (i = 0; i < num_groups; i++)
1023                 Perl_sv_catpvf(aTHX_ sv, " %"IVdf, (IV)gary[i]);
1024             Safefree(gary);
1025         }
1026         (void)SvIOK_on(sv);     /* what a wonderful hack! */
1027 #endif
1028         break;
1029 #ifndef MACOS_TRADITIONAL
1030     case '0':
1031         break;
1032 #endif
1033     }
1034     return 0;
1035 }
1036
1037 int
1038 Perl_magic_getuvar(pTHX_ SV *sv, MAGIC *mg)
1039 {
1040     struct ufuncs * const uf = (struct ufuncs *)mg->mg_ptr;
1041
1042     if (uf && uf->uf_val)
1043         (*uf->uf_val)(aTHX_ uf->uf_index, sv);
1044     return 0;
1045 }
1046
1047 int
1048 Perl_magic_setenv(pTHX_ SV *sv, MAGIC *mg)
1049 {
1050     dVAR;
1051     STRLEN len = 0, klen;
1052     const char *s = SvOK(sv) ? SvPV_const(sv,len) : "";
1053     const char * const ptr = MgPV_const(mg,klen);
1054     my_setenv(ptr, s);
1055
1056 #ifdef DYNAMIC_ENV_FETCH
1057      /* We just undefd an environment var.  Is a replacement */
1058      /* waiting in the wings? */
1059     if (!len) {
1060         SV ** const valp = hv_fetch(GvHVn(PL_envgv), ptr, klen, FALSE);
1061         if (valp)
1062             s = SvOK(*valp) ? SvPV_const(*valp, len) : "";
1063     }
1064 #endif
1065
1066 #if !defined(OS2) && !defined(AMIGAOS) && !defined(WIN32) && !defined(MSDOS)
1067                             /* And you'll never guess what the dog had */
1068                             /*   in its mouth... */
1069     if (PL_tainting) {
1070         MgTAINTEDDIR_off(mg);
1071 #ifdef VMS
1072         if (s && klen == 8 && strEQ(ptr, "DCL$PATH")) {
1073             char pathbuf[256], eltbuf[256], *cp, *elt;
1074             Stat_t sbuf;
1075             int i = 0, j = 0;
1076
1077             my_strlcpy(eltbuf, s, sizeof(eltbuf));
1078             elt = eltbuf;
1079             do {          /* DCL$PATH may be a search list */
1080                 while (1) {   /* as may dev portion of any element */
1081                     if ( ((cp = strchr(elt,'[')) || (cp = strchr(elt,'<'))) ) {
1082                         if ( *(cp+1) == '.' || *(cp+1) == '-' ||
1083                              cando_by_name(S_IWUSR,0,elt) ) {
1084                             MgTAINTEDDIR_on(mg);
1085                             return 0;
1086                         }
1087                     }
1088                     if ((cp = strchr(elt, ':')) != NULL)
1089                         *cp = '\0';
1090                     if (my_trnlnm(elt, eltbuf, j++))
1091                         elt = eltbuf;
1092                     else
1093                         break;
1094                 }
1095                 j = 0;
1096             } while (my_trnlnm(s, pathbuf, i++) && (elt = pathbuf));
1097         }
1098 #endif /* VMS */
1099         if (s && klen == 4 && strEQ(ptr,"PATH")) {
1100             const char * const strend = s + len;
1101
1102             while (s < strend) {
1103                 char tmpbuf[256];
1104                 Stat_t st;
1105                 I32 i;
1106 #ifdef VMS  /* Hmm.  How do we get $Config{path_sep} from C? */
1107                 const char path_sep = '|';
1108 #else
1109                 const char path_sep = ':';
1110 #endif
1111                 s = delimcpy(tmpbuf, tmpbuf + sizeof tmpbuf,
1112                              s, strend, path_sep, &i);
1113                 s++;
1114                 if (i >= (I32)sizeof tmpbuf   /* too long -- assume the worst */
1115 #ifdef VMS
1116                       || !strchr(tmpbuf, ':') /* no colon thus no device name -- assume relative path */
1117 #else
1118                       || *tmpbuf != '/'       /* no starting slash -- assume relative path */
1119 #endif
1120                       || (PerlLIO_stat(tmpbuf, &st) == 0 && (st.st_mode & 2)) ) {
1121                     MgTAINTEDDIR_on(mg);
1122                     return 0;
1123                 }
1124             }
1125         }
1126     }
1127 #endif /* neither OS2 nor AMIGAOS nor WIN32 nor MSDOS */
1128
1129     return 0;
1130 }
1131
1132 int
1133 Perl_magic_clearenv(pTHX_ SV *sv, MAGIC *mg)
1134 {
1135     PERL_UNUSED_ARG(sv);
1136     my_setenv(MgPV_nolen_const(mg),NULL);
1137     return 0;
1138 }
1139
1140 int
1141 Perl_magic_set_all_env(pTHX_ SV *sv, MAGIC *mg)
1142 {
1143     dVAR;
1144     PERL_UNUSED_ARG(mg);
1145 #if defined(VMS)
1146     Perl_die(aTHX_ "Can't make list assignment to %%ENV on this system");
1147 #else
1148     if (PL_localizing) {
1149         HE* entry;
1150         my_clearenv();
1151         hv_iterinit((HV*)sv);
1152         while ((entry = hv_iternext((HV*)sv))) {
1153             I32 keylen;
1154             my_setenv(hv_iterkey(entry, &keylen),
1155                       SvPV_nolen_const(hv_iterval((HV*)sv, entry)));
1156         }
1157     }
1158 #endif
1159     return 0;
1160 }
1161
1162 int
1163 Perl_magic_clear_all_env(pTHX_ SV *sv, MAGIC *mg)
1164 {
1165     dVAR;
1166     PERL_UNUSED_ARG(sv);
1167     PERL_UNUSED_ARG(mg);
1168 #if defined(VMS)
1169     Perl_die(aTHX_ "Can't make list assignment to %%ENV on this system");
1170 #else
1171     my_clearenv();
1172 #endif
1173     return 0;
1174 }
1175
1176 #ifndef PERL_MICRO
1177 #ifdef HAS_SIGPROCMASK
1178 static void
1179 restore_sigmask(pTHX_ SV *save_sv)
1180 {
1181     const sigset_t * const ossetp = (const sigset_t *) SvPV_nolen_const( save_sv );
1182     (void)sigprocmask(SIG_SETMASK, ossetp, NULL);
1183 }
1184 #endif
1185 int
1186 Perl_magic_getsig(pTHX_ SV *sv, MAGIC *mg)
1187 {
1188     dVAR;
1189     /* Are we fetching a signal entry? */
1190     const I32 i = whichsig(MgPV_nolen_const(mg));
1191     if (i > 0) {
1192         if(PL_psig_ptr[i])
1193             sv_setsv(sv,PL_psig_ptr[i]);
1194         else {
1195             Sighandler_t sigstate = rsignal_state(i);
1196 #ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1197             if (PL_sig_handlers_initted && PL_sig_ignoring[i])
1198                 sigstate = SIG_IGN;
1199 #endif
1200 #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1201             if (PL_sig_handlers_initted && PL_sig_defaulting[i])
1202                 sigstate = SIG_DFL;
1203 #endif
1204             /* cache state so we don't fetch it again */
1205             if(sigstate == (Sighandler_t) SIG_IGN)
1206                 sv_setpvs(sv,"IGNORE");
1207             else
1208                 sv_setsv(sv,&PL_sv_undef);
1209             PL_psig_ptr[i] = SvREFCNT_inc_simple_NN(sv);
1210             SvTEMP_off(sv);
1211         }
1212     }
1213     return 0;
1214 }
1215 int
1216 Perl_magic_clearsig(pTHX_ SV *sv, MAGIC *mg)
1217 {
1218     /* XXX Some of this code was copied from Perl_magic_setsig. A little
1219      * refactoring might be in order.
1220      */
1221     dVAR;
1222     register const char * const s = MgPV_nolen_const(mg);
1223     PERL_UNUSED_ARG(sv);
1224     if (*s == '_') {
1225         SV** svp = NULL;
1226         if (strEQ(s,"__DIE__"))
1227             svp = &PL_diehook;
1228         else if (strEQ(s,"__WARN__") && PL_warnhook != PERL_WARNHOOK_FATAL)
1229             svp = &PL_warnhook;
1230         if (svp && *svp) {
1231             SV *const to_dec = *svp;
1232             *svp = NULL;
1233             SvREFCNT_dec(to_dec);
1234         }
1235     }
1236     else {
1237         /* Are we clearing a signal entry? */
1238         const I32 i = whichsig(s);
1239         if (i > 0) {
1240 #ifdef HAS_SIGPROCMASK
1241             sigset_t set, save;
1242             SV* save_sv;
1243             /* Avoid having the signal arrive at a bad time, if possible. */
1244             sigemptyset(&set);
1245             sigaddset(&set,i);
1246             sigprocmask(SIG_BLOCK, &set, &save);
1247             ENTER;
1248             save_sv = newSVpv((char *)(&save), sizeof(sigset_t));
1249             SAVEFREESV(save_sv);
1250             SAVEDESTRUCTOR_X(restore_sigmask, save_sv);
1251 #endif
1252             PERL_ASYNC_CHECK();
1253 #if defined(FAKE_PERSISTENT_SIGNAL_HANDLERS) || defined(FAKE_DEFAULT_SIGNAL_HANDLERS)
1254             if (!PL_sig_handlers_initted) Perl_csighandler_init();
1255 #endif
1256 #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1257             PL_sig_defaulting[i] = 1;
1258             (void)rsignal(i, PL_csighandlerp);
1259 #else
1260             (void)rsignal(i, (Sighandler_t) SIG_DFL);
1261 #endif
1262             if(PL_psig_name[i]) {
1263                 SvREFCNT_dec(PL_psig_name[i]);
1264                 PL_psig_name[i]=0;
1265             }
1266             if(PL_psig_ptr[i]) {
1267                 SV * const to_dec=PL_psig_ptr[i];
1268                 PL_psig_ptr[i]=0;
1269                 LEAVE;
1270                 SvREFCNT_dec(to_dec);
1271             }
1272             else
1273                 LEAVE;
1274         }
1275     }
1276     return 0;
1277 }
1278
1279 /*
1280  * The signal handling nomenclature has gotten a bit confusing since the advent of
1281  * safe signals.  S_raise_signal only raises signals by analogy with what the
1282  * underlying system's signal mechanism does.  It might be more proper to say that
1283  * it defers signals that have already been raised and caught.
1284  *
1285  * PL_sig_pending and PL_psig_pend likewise do not track signals that are pending
1286  * in the sense of being on the system's signal queue in between raising and delivery.
1287  * They are only pending on Perl's deferral list, i.e., they track deferred signals
1288  * awaiting delivery after the current Perl opcode completes and say nothing about
1289  * signals raised but not yet caught in the underlying signal implementation.
1290  */
1291
1292 #ifndef SIG_PENDING_DIE_COUNT
1293 #  define SIG_PENDING_DIE_COUNT 120
1294 #endif
1295
1296 static void
1297 S_raise_signal(pTHX_ int sig)
1298 {
1299     dVAR;
1300     /* Set a flag to say this signal is pending */
1301     PL_psig_pend[sig]++;
1302     /* And one to say _a_ signal is pending */
1303     if (++PL_sig_pending >= SIG_PENDING_DIE_COUNT)
1304         Perl_croak(aTHX_ "Maximal count of pending signals (%lu) exceeded",
1305                 (unsigned long)SIG_PENDING_DIE_COUNT);
1306 }
1307
1308 Signal_t
1309 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
1310 Perl_csighandler(int sig, siginfo_t *sip PERL_UNUSED_DECL, void *uap PERL_UNUSED_DECL)
1311 #else
1312 Perl_csighandler(int sig)
1313 #endif
1314 {
1315 #ifdef PERL_GET_SIG_CONTEXT
1316     dTHXa(PERL_GET_SIG_CONTEXT);
1317 #else
1318     dTHX;
1319 #endif
1320 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
1321 #endif
1322 #ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1323     (void) rsignal(sig, PL_csighandlerp);
1324     if (PL_sig_ignoring[sig]) return;
1325 #endif
1326 #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1327     if (PL_sig_defaulting[sig])
1328 #ifdef KILL_BY_SIGPRC
1329             exit((Perl_sig_to_vmscondition(sig)&STS$M_COND_ID)|STS$K_SEVERE|STS$M_INHIB_MSG);
1330 #else
1331             exit(1);
1332 #endif
1333 #endif
1334 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
1335 #endif
1336    if (
1337 #ifdef SIGILL
1338            sig == SIGILL ||
1339 #endif
1340 #ifdef SIGBUS
1341            sig == SIGBUS ||
1342 #endif
1343 #ifdef SIGSEGV
1344            sig == SIGSEGV ||
1345 #endif
1346            (PL_signals & PERL_SIGNALS_UNSAFE_FLAG))
1347         /* Call the perl level handler now--
1348          * with risk we may be in malloc() etc. */
1349 #ifdef WIN32
1350         (*PL_sighandlerp)(sig);
1351 #else
1352         (*PL_sighandlerp)(sig, NULL, NULL);
1353 #endif
1354    else
1355         S_raise_signal(aTHX_ sig);
1356 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
1357 #endif
1358 }
1359
1360 #if defined(FAKE_PERSISTENT_SIGNAL_HANDLERS) || defined(FAKE_DEFAULT_SIGNAL_HANDLERS)
1361 void
1362 Perl_csighandler_init(void)
1363 {
1364     int sig;
1365     if (PL_sig_handlers_initted) return;
1366
1367     for (sig = 1; sig < SIG_SIZE; sig++) {
1368 #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1369         dTHX;
1370         PL_sig_defaulting[sig] = 1;
1371         (void) rsignal(sig, PL_csighandlerp);
1372 #endif
1373 #ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1374         PL_sig_ignoring[sig] = 0;
1375 #endif
1376     }
1377     PL_sig_handlers_initted = 1;
1378 }
1379 #endif
1380
1381 void
1382 Perl_despatch_signals(pTHX)
1383 {
1384     dVAR;
1385     int sig;
1386     PL_sig_pending = 0;
1387     for (sig = 1; sig < SIG_SIZE; sig++) {
1388         if (PL_psig_pend[sig]) {
1389             PERL_BLOCKSIG_ADD(set, sig);
1390             PL_psig_pend[sig] = 0;
1391             PERL_BLOCKSIG_BLOCK(set);
1392 #ifdef WIN32
1393             (*PL_sighandlerp)(sig);
1394 #else
1395             (*PL_sighandlerp)(sig, NULL, NULL);
1396 #endif
1397             PERL_BLOCKSIG_UNBLOCK(set);
1398         }
1399     }
1400 }
1401
1402 int
1403 Perl_magic_setsig(pTHX_ SV *sv, MAGIC *mg)
1404 {
1405     dVAR;
1406     I32 i;
1407     SV** svp = NULL;
1408     /* Need to be careful with SvREFCNT_dec(), because that can have side
1409      * effects (due to closures). We must make sure that the new disposition
1410      * is in place before it is called.
1411      */
1412     SV* to_dec = NULL;
1413     STRLEN len;
1414 #ifdef HAS_SIGPROCMASK
1415     sigset_t set, save;
1416     SV* save_sv;
1417 #endif
1418
1419     register const char *s = MgPV_const(mg,len);
1420     if (*s == '_') {
1421         if (strEQ(s,"__DIE__"))
1422             svp = &PL_diehook;
1423         else if (strEQ(s,"__WARN__"))
1424             svp = &PL_warnhook;
1425         else
1426             Perl_croak(aTHX_ "No such hook: %s", s);
1427         i = 0;
1428         if (*svp) {
1429             if (*svp != PERL_WARNHOOK_FATAL)
1430                 to_dec = *svp;
1431             *svp = NULL;
1432         }
1433     }
1434     else {
1435         i = whichsig(s);        /* ...no, a brick */
1436         if (i <= 0) {
1437             if (ckWARN(WARN_SIGNAL))
1438                 Perl_warner(aTHX_ packWARN(WARN_SIGNAL), "No such signal: SIG%s", s);
1439             return 0;
1440         }
1441 #ifdef HAS_SIGPROCMASK
1442         /* Avoid having the signal arrive at a bad time, if possible. */
1443         sigemptyset(&set);
1444         sigaddset(&set,i);
1445         sigprocmask(SIG_BLOCK, &set, &save);
1446         ENTER;
1447         save_sv = newSVpv((char *)(&save), sizeof(sigset_t));
1448         SAVEFREESV(save_sv);
1449         SAVEDESTRUCTOR_X(restore_sigmask, save_sv);
1450 #endif
1451         PERL_ASYNC_CHECK();
1452 #if defined(FAKE_PERSISTENT_SIGNAL_HANDLERS) || defined(FAKE_DEFAULT_SIGNAL_HANDLERS)
1453         if (!PL_sig_handlers_initted) Perl_csighandler_init();
1454 #endif
1455 #ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1456         PL_sig_ignoring[i] = 0;
1457 #endif
1458 #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1459         PL_sig_defaulting[i] = 0;
1460 #endif
1461         SvREFCNT_dec(PL_psig_name[i]);
1462         to_dec = PL_psig_ptr[i];
1463         PL_psig_ptr[i] = SvREFCNT_inc_simple_NN(sv);
1464         SvTEMP_off(sv); /* Make sure it doesn't go away on us */
1465         PL_psig_name[i] = newSVpvn(s, len);
1466         SvREADONLY_on(PL_psig_name[i]);
1467     }
1468     if (SvTYPE(sv) == SVt_PVGV || SvROK(sv)) {
1469         if (i) {
1470             (void)rsignal(i, PL_csighandlerp);
1471 #ifdef HAS_SIGPROCMASK
1472             LEAVE;
1473 #endif
1474         }
1475         else
1476             *svp = SvREFCNT_inc_simple_NN(sv);
1477         if(to_dec)
1478             SvREFCNT_dec(to_dec);
1479         return 0;
1480     }
1481     s = SvOK(sv) ? SvPV_force(sv,len) : "DEFAULT";
1482     if (strEQ(s,"IGNORE")) {
1483         if (i) {
1484 #ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
1485             PL_sig_ignoring[i] = 1;
1486             (void)rsignal(i, PL_csighandlerp);
1487 #else
1488             (void)rsignal(i, (Sighandler_t) SIG_IGN);
1489 #endif
1490         }
1491     }
1492     else if (strEQ(s,"DEFAULT") || !*s) {
1493         if (i)
1494 #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
1495           {
1496             PL_sig_defaulting[i] = 1;
1497             (void)rsignal(i, PL_csighandlerp);
1498           }
1499 #else
1500             (void)rsignal(i, (Sighandler_t) SIG_DFL);
1501 #endif
1502     }
1503     else {
1504         /*
1505          * We should warn if HINT_STRICT_REFS, but without
1506          * access to a known hint bit in a known OP, we can't
1507          * tell whether HINT_STRICT_REFS is in force or not.
1508          */
1509         if (!strchr(s,':') && !strchr(s,'\''))
1510             Perl_sv_insert(aTHX_ sv, 0, 0, STR_WITH_LEN("main::"));
1511         if (i)
1512             (void)rsignal(i, PL_csighandlerp);
1513         else
1514             *svp = SvREFCNT_inc_simple_NN(sv);
1515     }
1516 #ifdef HAS_SIGPROCMASK
1517     if(i)
1518         LEAVE;
1519 #endif
1520     if(to_dec)
1521         SvREFCNT_dec(to_dec);
1522     return 0;
1523 }
1524 #endif /* !PERL_MICRO */
1525
1526 int
1527 Perl_magic_setisa(pTHX_ SV *sv, MAGIC *mg)
1528 {
1529     dVAR;
1530     HV* stash;
1531     PERL_UNUSED_ARG(sv);
1532
1533     /* Bail out if destruction is going on */
1534     if(PL_dirty) return 0;
1535
1536     /* Skip _isaelem because _isa will handle it shortly */
1537     if (PL_delaymagic & DM_ARRAY && mg->mg_type == PERL_MAGIC_isaelem)
1538         return 0;
1539
1540     /* XXX Once it's possible, we need to
1541        detect that our @ISA is aliased in
1542        other stashes, and act on the stashes
1543        of all of the aliases */
1544
1545     /* The first case occurs via setisa,
1546        the second via setisa_elem, which
1547        calls this same magic */
1548     stash = GvSTASH(
1549         SvTYPE(mg->mg_obj) == SVt_PVGV
1550             ? (GV*)mg->mg_obj
1551             : (GV*)SvMAGIC(mg->mg_obj)->mg_obj
1552     );
1553
1554     mro_isa_changed_in(stash);
1555
1556     return 0;
1557 }
1558
1559 int
1560 Perl_magic_setamagic(pTHX_ SV *sv, MAGIC *mg)
1561 {
1562     dVAR;
1563     PERL_UNUSED_ARG(sv);
1564     PERL_UNUSED_ARG(mg);
1565     PL_amagic_generation++;
1566
1567     return 0;
1568 }
1569
1570 int
1571 Perl_magic_getnkeys(pTHX_ SV *sv, MAGIC *mg)
1572 {
1573     HV * const hv = (HV*)LvTARG(sv);
1574     I32 i = 0;
1575     PERL_UNUSED_ARG(mg);
1576
1577     if (hv) {
1578          (void) hv_iterinit(hv);
1579          if (! SvTIED_mg((SV*)hv, PERL_MAGIC_tied))
1580              i = HvKEYS(hv);
1581          else {
1582              while (hv_iternext(hv))
1583                  i++;
1584          }
1585     }
1586
1587     sv_setiv(sv, (IV)i);
1588     return 0;
1589 }
1590
1591 int
1592 Perl_magic_setnkeys(pTHX_ SV *sv, MAGIC *mg)
1593 {
1594     PERL_UNUSED_ARG(mg);
1595     if (LvTARG(sv)) {
1596         hv_ksplit((HV*)LvTARG(sv), SvIV(sv));
1597     }
1598     return 0;
1599 }
1600
1601 /* caller is responsible for stack switching/cleanup */
1602 STATIC int
1603 S_magic_methcall(pTHX_ SV *sv, const MAGIC *mg, const char *meth, I32 flags, int n, SV *val)
1604 {
1605     dVAR;
1606     dSP;
1607
1608     PUSHMARK(SP);
1609     EXTEND(SP, n);
1610     PUSHs(SvTIED_obj(sv, mg));
1611     if (n > 1) {
1612         if (mg->mg_ptr) {
1613             if (mg->mg_len >= 0)
1614                 PUSHs(sv_2mortal(newSVpvn(mg->mg_ptr, mg->mg_len)));
1615             else if (mg->mg_len == HEf_SVKEY)
1616                 PUSHs((SV*)mg->mg_ptr);
1617         }
1618         else if (mg->mg_type == PERL_MAGIC_tiedelem) {
1619             PUSHs(sv_2mortal(newSViv(mg->mg_len)));
1620         }
1621     }
1622     if (n > 2) {
1623         PUSHs(val);
1624     }
1625     PUTBACK;
1626
1627     return call_method(meth, flags);
1628 }
1629
1630 STATIC int
1631 S_magic_methpack(pTHX_ SV *sv, const MAGIC *mg, const char *meth)
1632 {
1633     dVAR; dSP;
1634
1635     ENTER;
1636     SAVETMPS;
1637     PUSHSTACKi(PERLSI_MAGIC);
1638
1639     if (magic_methcall(sv, mg, meth, G_SCALAR, 2, NULL)) {
1640         sv_setsv(sv, *PL_stack_sp--);
1641     }
1642
1643     POPSTACK;
1644     FREETMPS;
1645     LEAVE;
1646     return 0;
1647 }
1648
1649 int
1650 Perl_magic_getpack(pTHX_ SV *sv, MAGIC *mg)
1651 {
1652     if (mg->mg_ptr)
1653         mg->mg_flags |= MGf_GSKIP;
1654     magic_methpack(sv,mg,"FETCH");
1655     return 0;
1656 }
1657
1658 int
1659 Perl_magic_setpack(pTHX_ SV *sv, MAGIC *mg)
1660 {
1661     dVAR; dSP;
1662     ENTER;
1663     PUSHSTACKi(PERLSI_MAGIC);
1664     magic_methcall(sv, mg, "STORE", G_SCALAR|G_DISCARD, 3, sv);
1665     POPSTACK;
1666     LEAVE;
1667     return 0;
1668 }
1669
1670 int
1671 Perl_magic_clearpack(pTHX_ SV *sv, MAGIC *mg)
1672 {
1673     return magic_methpack(sv,mg,"DELETE");
1674 }
1675
1676
1677 U32
1678 Perl_magic_sizepack(pTHX_ SV *sv, MAGIC *mg)
1679 {
1680     dVAR; dSP;
1681     I32 retval = 0;
1682
1683     ENTER;
1684     SAVETMPS;
1685     PUSHSTACKi(PERLSI_MAGIC);
1686     if (magic_methcall(sv, mg, "FETCHSIZE", G_SCALAR, 2, NULL)) {
1687         sv = *PL_stack_sp--;
1688         retval = SvIV(sv)-1;
1689         if (retval < -1)
1690             Perl_croak(aTHX_ "FETCHSIZE returned a negative value");
1691     }
1692     POPSTACK;
1693     FREETMPS;
1694     LEAVE;
1695     return (U32) retval;
1696 }
1697
1698 int
1699 Perl_magic_wipepack(pTHX_ SV *sv, MAGIC *mg)
1700 {
1701     dVAR; dSP;
1702
1703     ENTER;
1704     PUSHSTACKi(PERLSI_MAGIC);
1705     PUSHMARK(SP);
1706     XPUSHs(SvTIED_obj(sv, mg));
1707     PUTBACK;
1708     call_method("CLEAR", G_SCALAR|G_DISCARD);
1709     POPSTACK;
1710     LEAVE;
1711
1712     return 0;
1713 }
1714
1715 int
1716 Perl_magic_nextpack(pTHX_ SV *sv, MAGIC *mg, SV *key)
1717 {
1718     dVAR; dSP;
1719     const char * const meth = SvOK(key) ? "NEXTKEY" : "FIRSTKEY";
1720
1721     ENTER;
1722     SAVETMPS;
1723     PUSHSTACKi(PERLSI_MAGIC);
1724     PUSHMARK(SP);
1725     EXTEND(SP, 2);
1726     PUSHs(SvTIED_obj(sv, mg));
1727     if (SvOK(key))
1728         PUSHs(key);
1729     PUTBACK;
1730
1731     if (call_method(meth, G_SCALAR))
1732         sv_setsv(key, *PL_stack_sp--);
1733
1734     POPSTACK;
1735     FREETMPS;
1736     LEAVE;
1737     return 0;
1738 }
1739
1740 int
1741 Perl_magic_existspack(pTHX_ SV *sv, const MAGIC *mg)
1742 {
1743     return magic_methpack(sv,mg,"EXISTS");
1744 }
1745
1746 SV *
1747 Perl_magic_scalarpack(pTHX_ HV *hv, MAGIC *mg)
1748 {
1749     dVAR; dSP;
1750     SV *retval;
1751     SV * const tied = SvTIED_obj((SV*)hv, mg);
1752     HV * const pkg = SvSTASH((SV*)SvRV(tied));
1753
1754     if (!gv_fetchmethod_autoload(pkg, "SCALAR", FALSE)) {
1755         SV *key;
1756         if (HvEITER_get(hv))
1757             /* we are in an iteration so the hash cannot be empty */
1758             return &PL_sv_yes;
1759         /* no xhv_eiter so now use FIRSTKEY */
1760         key = sv_newmortal();
1761         magic_nextpack((SV*)hv, mg, key);
1762         HvEITER_set(hv, NULL);     /* need to reset iterator */
1763         return SvOK(key) ? &PL_sv_yes : &PL_sv_no;
1764     }
1765
1766     /* there is a SCALAR method that we can call */
1767     ENTER;
1768     PUSHSTACKi(PERLSI_MAGIC);
1769     PUSHMARK(SP);
1770     EXTEND(SP, 1);
1771     PUSHs(tied);
1772     PUTBACK;
1773
1774     if (call_method("SCALAR", G_SCALAR))
1775         retval = *PL_stack_sp--;
1776     else
1777         retval = &PL_sv_undef;
1778     POPSTACK;
1779     LEAVE;
1780     return retval;
1781 }
1782
1783 int
1784 Perl_magic_setdbline(pTHX_ SV *sv, MAGIC *mg)
1785 {
1786     dVAR;
1787     GV * const gv = PL_DBline;
1788     const I32 i = SvTRUE(sv);
1789     SV ** const svp = av_fetch(GvAV(gv),
1790                      atoi(MgPV_nolen_const(mg)), FALSE);
1791     if (svp && SvIOKp(*svp)) {
1792         OP * const o = INT2PTR(OP*,SvIVX(*svp));
1793         if (o) {
1794             /* set or clear breakpoint in the relevant control op */
1795             if (i)
1796                 o->op_flags |= OPf_SPECIAL;
1797             else
1798                 o->op_flags &= ~OPf_SPECIAL;
1799         }
1800     }
1801     return 0;
1802 }
1803
1804 int
1805 Perl_magic_getarylen(pTHX_ SV *sv, const MAGIC *mg)
1806 {
1807     dVAR;
1808     const AV * const obj = (AV*)mg->mg_obj;
1809     if (obj) {
1810         sv_setiv(sv, AvFILL(obj) + CopARYBASE_get(PL_curcop));
1811     } else {
1812         SvOK_off(sv);
1813     }
1814     return 0;
1815 }
1816
1817 int
1818 Perl_magic_setarylen(pTHX_ SV *sv, MAGIC *mg)
1819 {
1820     dVAR;
1821     AV * const obj = (AV*)mg->mg_obj;
1822     if (obj) {
1823         av_fill(obj, SvIV(sv) - CopARYBASE_get(PL_curcop));
1824     } else {
1825         if (ckWARN(WARN_MISC))
1826             Perl_warner(aTHX_ packWARN(WARN_MISC),
1827                         "Attempt to set length of freed array");
1828     }
1829     return 0;
1830 }
1831
1832 int
1833 Perl_magic_freearylen_p(pTHX_ SV *sv, MAGIC *mg)
1834 {
1835     dVAR;
1836     PERL_UNUSED_ARG(sv);
1837     /* during global destruction, mg_obj may already have been freed */
1838     if (PL_in_clean_all)
1839         return 0;
1840
1841     mg = mg_find (mg->mg_obj, PERL_MAGIC_arylen);
1842
1843     if (mg) {
1844         /* arylen scalar holds a pointer back to the array, but doesn't own a
1845            reference. Hence the we (the array) are about to go away with it
1846            still pointing at us. Clear its pointer, else it would be pointing
1847            at free memory. See the comment in sv_magic about reference loops,
1848            and why it can't own a reference to us.  */
1849         mg->mg_obj = 0;
1850     }
1851     return 0;
1852 }
1853
1854 int
1855 Perl_magic_getpos(pTHX_ SV *sv, MAGIC *mg)
1856 {
1857     dVAR;
1858     SV* const lsv = LvTARG(sv);
1859     PERL_UNUSED_ARG(mg);
1860
1861     if (SvTYPE(lsv) >= SVt_PVMG && SvMAGIC(lsv)) {
1862         MAGIC * const found = mg_find(lsv, PERL_MAGIC_regex_global);
1863         if (found && found->mg_len >= 0) {
1864             I32 i = found->mg_len;
1865             if (DO_UTF8(lsv))
1866                 sv_pos_b2u(lsv, &i);
1867             sv_setiv(sv, i + CopARYBASE_get(PL_curcop));
1868             return 0;
1869         }
1870     }
1871     SvOK_off(sv);
1872     return 0;
1873 }
1874
1875 int
1876 Perl_magic_setpos(pTHX_ SV *sv, MAGIC *mg)
1877 {
1878     dVAR;
1879     SV* const lsv = LvTARG(sv);
1880     SSize_t pos;
1881     STRLEN len;
1882     STRLEN ulen = 0;
1883     MAGIC* found;
1884
1885     PERL_UNUSED_ARG(mg);
1886
1887     if (SvTYPE(lsv) >= SVt_PVMG && SvMAGIC(lsv))
1888         found = mg_find(lsv, PERL_MAGIC_regex_global);
1889     else
1890         found = NULL;
1891     if (!found) {
1892         if (!SvOK(sv))
1893             return 0;
1894 #ifdef PERL_OLD_COPY_ON_WRITE
1895     if (SvIsCOW(lsv))
1896         sv_force_normal_flags(lsv, 0);
1897 #endif
1898         found = sv_magicext(lsv, NULL, PERL_MAGIC_regex_global, &PL_vtbl_mglob,
1899                             NULL, 0);
1900     }
1901     else if (!SvOK(sv)) {
1902         found->mg_len = -1;
1903         return 0;
1904     }
1905     len = SvPOK(lsv) ? SvCUR(lsv) : sv_len(lsv);
1906
1907     pos = SvIV(sv) - CopARYBASE_get(PL_curcop);
1908
1909     if (DO_UTF8(lsv)) {
1910         ulen = sv_len_utf8(lsv);
1911         if (ulen)
1912             len = ulen;
1913     }
1914
1915     if (pos < 0) {
1916         pos += len;
1917         if (pos < 0)
1918             pos = 0;
1919     }
1920     else if (pos > (SSize_t)len)
1921         pos = len;
1922
1923     if (ulen) {
1924         I32 p = pos;
1925         sv_pos_u2b(lsv, &p, 0);
1926         pos = p;
1927     }
1928
1929     found->mg_len = pos;
1930     found->mg_flags &= ~MGf_MINMATCH;
1931
1932     return 0;
1933 }
1934
1935 int
1936 Perl_magic_setglob(pTHX_ SV *sv, MAGIC *mg)
1937 {
1938     GV* gv;
1939     PERL_UNUSED_ARG(mg);
1940
1941     Perl_croak(aTHX_ "Perl_magic_setglob is dead code?");
1942
1943     if (!SvOK(sv))
1944         return 0;
1945     if (isGV_with_GP(sv)) {
1946         /* We're actually already a typeglob, so don't need the stuff below.
1947          */
1948         return 0;
1949     }
1950     gv =  gv_fetchsv(sv, GV_ADD, SVt_PVGV);
1951     if (sv == (SV*)gv)
1952         return 0;
1953     if (GvGP(sv))
1954         gp_free((GV*)sv);
1955     GvGP(sv) = gp_ref(GvGP(gv));
1956     return 0;
1957 }
1958
1959 int
1960 Perl_magic_getsubstr(pTHX_ SV *sv, MAGIC *mg)
1961 {
1962     STRLEN len;
1963     SV * const lsv = LvTARG(sv);
1964     const char * const tmps = SvPV_const(lsv,len);
1965     I32 offs = LvTARGOFF(sv);
1966     I32 rem = LvTARGLEN(sv);
1967     PERL_UNUSED_ARG(mg);
1968
1969     if (SvUTF8(lsv))
1970         sv_pos_u2b(lsv, &offs, &rem);
1971     if (offs > (I32)len)
1972         offs = len;
1973     if (rem + offs > (I32)len)
1974         rem = len - offs;
1975     sv_setpvn(sv, tmps + offs, (STRLEN)rem);
1976     if (SvUTF8(lsv))
1977         SvUTF8_on(sv);
1978     return 0;
1979 }
1980
1981 int
1982 Perl_magic_setsubstr(pTHX_ SV *sv, MAGIC *mg)
1983 {
1984     dVAR;
1985     STRLEN len;
1986     const char * const tmps = SvPV_const(sv, len);
1987     SV * const lsv = LvTARG(sv);
1988     I32 lvoff = LvTARGOFF(sv);
1989     I32 lvlen = LvTARGLEN(sv);
1990     PERL_UNUSED_ARG(mg);
1991
1992     if (DO_UTF8(sv)) {
1993         sv_utf8_upgrade(lsv);
1994         sv_pos_u2b(lsv, &lvoff, &lvlen);
1995         sv_insert(lsv, lvoff, lvlen, tmps, len);
1996         LvTARGLEN(sv) = sv_len_utf8(sv);
1997         SvUTF8_on(lsv);
1998     }
1999     else if (lsv && SvUTF8(lsv)) {
2000         const char *utf8;
2001         sv_pos_u2b(lsv, &lvoff, &lvlen);
2002         LvTARGLEN(sv) = len;
2003         utf8 = (char*)bytes_to_utf8((U8*)tmps, &len);
2004         sv_insert(lsv, lvoff, lvlen, utf8, len);
2005         Safefree(utf8);
2006     }
2007     else {
2008         sv_insert(lsv, lvoff, lvlen, tmps, len);
2009         LvTARGLEN(sv) = len;
2010     }
2011
2012
2013     return 0;
2014 }
2015
2016 int
2017 Perl_magic_gettaint(pTHX_ SV *sv, MAGIC *mg)
2018 {
2019     dVAR;
2020     PERL_UNUSED_ARG(sv);
2021     TAINT_IF((PL_localizing != 1) && (mg->mg_len & 1));
2022     return 0;
2023 }
2024
2025 int
2026 Perl_magic_settaint(pTHX_ SV *sv, MAGIC *mg)
2027 {
2028     dVAR;
2029     PERL_UNUSED_ARG(sv);
2030     /* update taint status */
2031     if (PL_tainted)
2032         mg->mg_len |= 1;
2033     else
2034         mg->mg_len &= ~1;
2035     return 0;
2036 }
2037
2038 int
2039 Perl_magic_getvec(pTHX_ SV *sv, MAGIC *mg)
2040 {
2041     SV * const lsv = LvTARG(sv);
2042     PERL_UNUSED_ARG(mg);
2043
2044     if (lsv)
2045         sv_setuv(sv, do_vecget(lsv, LvTARGOFF(sv), LvTARGLEN(sv)));
2046     else
2047         SvOK_off(sv);
2048
2049     return 0;
2050 }
2051
2052 int
2053 Perl_magic_setvec(pTHX_ SV *sv, MAGIC *mg)
2054 {
2055     PERL_UNUSED_ARG(mg);
2056     do_vecset(sv);      /* XXX slurp this routine */
2057     return 0;
2058 }
2059
2060 int
2061 Perl_magic_getdefelem(pTHX_ SV *sv, MAGIC *mg)
2062 {
2063     dVAR;
2064     SV *targ = NULL;
2065     if (LvTARGLEN(sv)) {
2066         if (mg->mg_obj) {
2067             SV * const ahv = LvTARG(sv);
2068             HE * const he = hv_fetch_ent((HV*)ahv, mg->mg_obj, FALSE, 0);
2069             if (he)
2070                 targ = HeVAL(he);
2071         }
2072         else {
2073             AV* const av = (AV*)LvTARG(sv);
2074             if ((I32)LvTARGOFF(sv) <= AvFILL(av))
2075                 targ = AvARRAY(av)[LvTARGOFF(sv)];
2076         }
2077         if (targ && (targ != &PL_sv_undef)) {
2078             /* somebody else defined it for us */
2079             SvREFCNT_dec(LvTARG(sv));
2080             LvTARG(sv) = SvREFCNT_inc_simple_NN(targ);
2081             LvTARGLEN(sv) = 0;
2082             SvREFCNT_dec(mg->mg_obj);
2083             mg->mg_obj = NULL;
2084             mg->mg_flags &= ~MGf_REFCOUNTED;
2085         }
2086     }
2087     else
2088         targ = LvTARG(sv);
2089     sv_setsv(sv, targ ? targ : &PL_sv_undef);
2090     return 0;
2091 }
2092
2093 int
2094 Perl_magic_setdefelem(pTHX_ SV *sv, MAGIC *mg)
2095 {
2096     PERL_UNUSED_ARG(mg);
2097     if (LvTARGLEN(sv))
2098         vivify_defelem(sv);
2099     if (LvTARG(sv)) {
2100         sv_setsv(LvTARG(sv), sv);
2101         SvSETMAGIC(LvTARG(sv));
2102     }
2103     return 0;
2104 }
2105
2106 void
2107 Perl_vivify_defelem(pTHX_ SV *sv)
2108 {
2109     dVAR;
2110     MAGIC *mg;
2111     SV *value = NULL;
2112
2113     if (!LvTARGLEN(sv) || !(mg = mg_find(sv, PERL_MAGIC_defelem)))
2114         return;
2115     if (mg->mg_obj) {
2116         SV * const ahv = LvTARG(sv);
2117         HE * const he = hv_fetch_ent((HV*)ahv, mg->mg_obj, TRUE, 0);
2118         if (he)
2119             value = HeVAL(he);
2120         if (!value || value == &PL_sv_undef)
2121             Perl_croak(aTHX_ PL_no_helem_sv, SVfARG(mg->mg_obj));
2122     }
2123     else {
2124         AV* const av = (AV*)LvTARG(sv);
2125         if ((I32)LvTARGLEN(sv) < 0 && (I32)LvTARGOFF(sv) > AvFILL(av))
2126             LvTARG(sv) = NULL;  /* array can't be extended */
2127         else {
2128             SV* const * const svp = av_fetch(av, LvTARGOFF(sv), TRUE);
2129             if (!svp || (value = *svp) == &PL_sv_undef)
2130                 Perl_croak(aTHX_ PL_no_aelem, (I32)LvTARGOFF(sv));
2131         }
2132     }
2133     SvREFCNT_inc_simple_void(value);
2134     SvREFCNT_dec(LvTARG(sv));
2135     LvTARG(sv) = value;
2136     LvTARGLEN(sv) = 0;
2137     SvREFCNT_dec(mg->mg_obj);
2138     mg->mg_obj = NULL;
2139     mg->mg_flags &= ~MGf_REFCOUNTED;
2140 }
2141
2142 int
2143 Perl_magic_killbackrefs(pTHX_ SV *sv, MAGIC *mg)
2144 {
2145     return Perl_sv_kill_backrefs(aTHX_ sv, (AV*)mg->mg_obj);
2146 }
2147
2148 int
2149 Perl_magic_setmglob(pTHX_ SV *sv, MAGIC *mg)
2150 {
2151     PERL_UNUSED_CONTEXT;
2152     mg->mg_len = -1;
2153     SvSCREAM_off(sv);
2154     return 0;
2155 }
2156
2157 int
2158 Perl_magic_setbm(pTHX_ SV *sv, MAGIC *mg)
2159 {
2160     PERL_UNUSED_ARG(mg);
2161     sv_unmagic(sv, PERL_MAGIC_bm);
2162     SvTAIL_off(sv);
2163     SvVALID_off(sv);
2164     return 0;
2165 }
2166
2167 int
2168 Perl_magic_setfm(pTHX_ SV *sv, MAGIC *mg)
2169 {
2170     PERL_UNUSED_ARG(mg);
2171     sv_unmagic(sv, PERL_MAGIC_fm);
2172     SvCOMPILED_off(sv);
2173     return 0;
2174 }
2175
2176 int
2177 Perl_magic_setuvar(pTHX_ SV *sv, MAGIC *mg)
2178 {
2179     const struct ufuncs * const uf = (struct ufuncs *)mg->mg_ptr;
2180
2181     if (uf && uf->uf_set)
2182         (*uf->uf_set)(aTHX_ uf->uf_index, sv);
2183     return 0;
2184 }
2185
2186 int
2187 Perl_magic_setregexp(pTHX_ SV *sv, MAGIC *mg)
2188 {
2189     PERL_UNUSED_ARG(mg);
2190     sv_unmagic(sv, PERL_MAGIC_qr);
2191     return 0;
2192 }
2193
2194 int
2195 Perl_magic_freeregexp(pTHX_ SV *sv, MAGIC *mg)
2196 {
2197     dVAR;
2198     regexp * const re = (regexp *)mg->mg_obj;
2199     PERL_UNUSED_ARG(sv);
2200
2201     ReREFCNT_dec(re);
2202     return 0;
2203 }
2204
2205 #ifdef USE_LOCALE_COLLATE
2206 int
2207 Perl_magic_setcollxfrm(pTHX_ SV *sv, MAGIC *mg)
2208 {
2209     /*
2210      * RenE<eacute> Descartes said "I think not."
2211      * and vanished with a faint plop.
2212      */
2213     PERL_UNUSED_CONTEXT;
2214     PERL_UNUSED_ARG(sv);
2215     if (mg->mg_ptr) {
2216         Safefree(mg->mg_ptr);
2217         mg->mg_ptr = NULL;
2218         mg->mg_len = -1;
2219     }
2220     return 0;
2221 }
2222 #endif /* USE_LOCALE_COLLATE */
2223
2224 /* Just clear the UTF-8 cache data. */
2225 int
2226 Perl_magic_setutf8(pTHX_ SV *sv, MAGIC *mg)
2227 {
2228     PERL_UNUSED_CONTEXT;
2229     PERL_UNUSED_ARG(sv);
2230     Safefree(mg->mg_ptr);       /* The mg_ptr holds the pos cache. */
2231     mg->mg_ptr = NULL;
2232     mg->mg_len = -1;            /* The mg_len holds the len cache. */
2233     return 0;
2234 }
2235
2236 int
2237 Perl_magic_set(pTHX_ SV *sv, MAGIC *mg)
2238 {
2239     dVAR;
2240     register const char *s;
2241     register I32 paren;
2242     register const REGEXP * rx;
2243     const char * const remaining = mg->mg_ptr + 1;
2244     I32 i;
2245     STRLEN len;
2246
2247     switch (*mg->mg_ptr) {
2248     case '\015': /* $^MATCH */
2249       if (strEQ(remaining, "ATCH"))
2250           goto do_match;
2251     case '`': /* ${^PREMATCH} caught below */
2252       do_prematch:
2253       paren = RX_BUFF_IDX_PREMATCH;
2254       goto setparen;
2255     case '\'': /* ${^POSTMATCH} caught below */
2256       do_postmatch:
2257       paren = RX_BUFF_IDX_POSTMATCH;
2258       goto setparen;
2259     case '&':
2260       do_match:
2261       paren = RX_BUFF_IDX_FULLMATCH;
2262       goto setparen;
2263     case '1': case '2': case '3': case '4':
2264     case '5': case '6': case '7': case '8': case '9':
2265       paren = atoi(mg->mg_ptr);
2266       setparen:
2267         if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
2268             CALLREG_NUMBUF_STORE((REGEXP * const)rx,paren,sv);
2269             break;
2270         } else {
2271             /* Croak with a READONLY error when a numbered match var is
2272              * set without a previous pattern match. Unless it's C<local $1>
2273              */
2274             if (!PL_localizing) {
2275                 Perl_croak(aTHX_ PL_no_modify);
2276             }
2277         }
2278     case '\001':        /* ^A */
2279         sv_setsv(PL_bodytarget, sv);
2280         break;
2281     case '\003':        /* ^C */
2282         PL_minus_c = (bool)SvIV(sv);
2283         break;
2284
2285     case '\004':        /* ^D */
2286 #ifdef DEBUGGING
2287         s = SvPV_nolen_const(sv);
2288         PL_debug = get_debug_opts(&s, 0) | DEBUG_TOP_FLAG;
2289         DEBUG_x(dump_all());
2290 #else
2291         PL_debug = (SvIV(sv)) | DEBUG_TOP_FLAG;
2292 #endif
2293         break;
2294     case '\005':  /* ^E */
2295         if (*(mg->mg_ptr+1) == '\0') {
2296 #ifdef MACOS_TRADITIONAL
2297             gMacPerl_OSErr = SvIV(sv);
2298 #else
2299 #  ifdef VMS
2300             set_vaxc_errno(SvIV(sv));
2301 #  else
2302 #    ifdef WIN32
2303             SetLastError( SvIV(sv) );
2304 #    else
2305 #      ifdef OS2
2306             os2_setsyserrno(SvIV(sv));
2307 #      else
2308             /* will anyone ever use this? */
2309             SETERRNO(SvIV(sv), 4);
2310 #      endif
2311 #    endif
2312 #  endif
2313 #endif
2314         }
2315         else if (strEQ(mg->mg_ptr+1, "NCODING")) {
2316             if (PL_encoding)
2317                 SvREFCNT_dec(PL_encoding);
2318             if (SvOK(sv) || SvGMAGICAL(sv)) {
2319                 PL_encoding = newSVsv(sv);
2320             }
2321             else {
2322                 PL_encoding = NULL;
2323             }
2324         }
2325         break;
2326     case '\006':        /* ^F */
2327         PL_maxsysfd = SvIV(sv);
2328         break;
2329     case '\010':        /* ^H */
2330         PL_hints = SvIV(sv);
2331         break;
2332     case '\011':        /* ^I */ /* NOT \t in EBCDIC */
2333         Safefree(PL_inplace);
2334         PL_inplace = SvOK(sv) ? savesvpv(sv) : NULL;
2335         break;
2336     case '\017':        /* ^O */
2337         if (*(mg->mg_ptr+1) == '\0') {
2338             Safefree(PL_osname);
2339             PL_osname = NULL;
2340             if (SvOK(sv)) {
2341                 TAINT_PROPER("assigning to $^O");
2342                 PL_osname = savesvpv(sv);
2343             }
2344         }
2345         else if (strEQ(mg->mg_ptr, "\017PEN")) {
2346             STRLEN len;
2347             const char *const start = SvPV(sv, len);
2348             const char *out = (const char*)memchr(start, '\0', len);
2349             SV *tmp;
2350             struct refcounted_he *tmp_he;
2351
2352
2353             PL_compiling.cop_hints |= HINT_LEXICAL_IO_IN | HINT_LEXICAL_IO_OUT;
2354             PL_hints
2355                 |= HINT_LOCALIZE_HH | HINT_LEXICAL_IO_IN | HINT_LEXICAL_IO_OUT;
2356
2357             /* Opening for input is more common than opening for output, so
2358                ensure that hints for input are sooner on linked list.  */
2359             tmp = sv_2mortal(out ? newSVpvn(out + 1, start + len - out - 1)
2360                              : newSVpvs(""));
2361             SvFLAGS(tmp) |= SvUTF8(sv);
2362
2363             tmp_he
2364                 = Perl_refcounted_he_new(aTHX_ PL_compiling.cop_hints_hash,
2365                                          sv_2mortal(newSVpvs("open>")), tmp);
2366
2367             /* The UTF-8 setting is carried over  */
2368             sv_setpvn(tmp, start, out ? (STRLEN)(out - start) : len);
2369
2370             PL_compiling.cop_hints_hash
2371                 = Perl_refcounted_he_new(aTHX_ tmp_he,
2372                                          sv_2mortal(newSVpvs("open<")), tmp);
2373         }
2374         break;
2375     case '\020':        /* ^P */
2376       if (*remaining == '\0') { /* ^P */
2377           PL_perldb = SvIV(sv);
2378           if (PL_perldb && !PL_DBsingle)
2379               init_debugger();
2380           break;
2381       } else if (strEQ(remaining, "REMATCH")) { /* $^PREMATCH */
2382           goto do_prematch;
2383       } else if (strEQ(remaining, "OSTMATCH")) { /* $^POSTMATCH */
2384           goto do_postmatch;
2385       }
2386     case '\024':        /* ^T */
2387 #ifdef BIG_TIME
2388         PL_basetime = (Time_t)(SvNOK(sv) ? SvNVX(sv) : sv_2nv(sv));
2389 #else
2390         PL_basetime = (Time_t)SvIV(sv);
2391 #endif
2392         break;
2393     case '\025':        /* ^UTF8CACHE */
2394          if (strEQ(mg->mg_ptr+1, "TF8CACHE")) {
2395              PL_utf8cache = (signed char) sv_2iv(sv);
2396          }
2397          break;
2398     case '\027':        /* ^W & $^WARNING_BITS */
2399         if (*(mg->mg_ptr+1) == '\0') {
2400             if ( ! (PL_dowarn & G_WARN_ALL_MASK)) {
2401                 i = SvIV(sv);
2402                 PL_dowarn = (PL_dowarn & ~G_WARN_ON)
2403                                 | (i ? G_WARN_ON : G_WARN_OFF) ;
2404             }
2405         }
2406         else if (strEQ(mg->mg_ptr+1, "ARNING_BITS")) {
2407             if ( ! (PL_dowarn & G_WARN_ALL_MASK)) {
2408                 if (!SvPOK(sv) && PL_localizing) {
2409                     sv_setpvn(sv, WARN_NONEstring, WARNsize);
2410                     PL_compiling.cop_warnings = pWARN_NONE;
2411                     break;
2412                 }
2413                 {
2414                     STRLEN len, i;
2415                     int accumulate = 0 ;
2416                     int any_fatals = 0 ;
2417                     const char * const ptr = SvPV_const(sv, len) ;
2418                     for (i = 0 ; i < len ; ++i) {
2419                         accumulate |= ptr[i] ;
2420                         any_fatals |= (ptr[i] & 0xAA) ;
2421                     }
2422                     if (!accumulate) {
2423                         if (!specialWARN(PL_compiling.cop_warnings))
2424                             PerlMemShared_free(PL_compiling.cop_warnings);
2425                         PL_compiling.cop_warnings = pWARN_NONE;
2426                     }
2427                     /* Yuck. I can't see how to abstract this:  */
2428                     else if (isWARN_on(((STRLEN *)SvPV_nolen_const(sv)) - 1,
2429                                        WARN_ALL) && !any_fatals) {
2430                         if (!specialWARN(PL_compiling.cop_warnings))
2431                             PerlMemShared_free(PL_compiling.cop_warnings);
2432                         PL_compiling.cop_warnings = pWARN_ALL;
2433                         PL_dowarn |= G_WARN_ONCE ;
2434                     }
2435                     else {
2436                         STRLEN len;
2437                         const char *const p = SvPV_const(sv, len);
2438
2439                         PL_compiling.cop_warnings
2440                             = Perl_new_warnings_bitfield(aTHX_ PL_compiling.cop_warnings,
2441                                                          p, len);
2442
2443                         if (isWARN_on(PL_compiling.cop_warnings, WARN_ONCE))
2444                             PL_dowarn |= G_WARN_ONCE ;
2445                     }
2446
2447                 }
2448             }
2449         }
2450         break;
2451     case '.':
2452         if (PL_localizing) {
2453             if (PL_localizing == 1)
2454                 SAVESPTR(PL_last_in_gv);
2455         }
2456         else if (SvOK(sv) && GvIO(PL_last_in_gv))
2457             IoLINES(GvIOp(PL_last_in_gv)) = SvIV(sv);
2458         break;
2459     case '^':
2460         Safefree(IoTOP_NAME(GvIOp(PL_defoutgv)));
2461         s = IoTOP_NAME(GvIOp(PL_defoutgv)) = savesvpv(sv);
2462         IoTOP_GV(GvIOp(PL_defoutgv)) =  gv_fetchsv(sv, GV_ADD, SVt_PVIO);
2463         break;
2464     case '~':
2465         Safefree(IoFMT_NAME(GvIOp(PL_defoutgv)));
2466         s = IoFMT_NAME(GvIOp(PL_defoutgv)) = savesvpv(sv);
2467         IoFMT_GV(GvIOp(PL_defoutgv)) =  gv_fetchsv(sv, GV_ADD, SVt_PVIO);
2468         break;
2469     case '=':
2470         IoPAGE_LEN(GvIOp(PL_defoutgv)) = (SvIV(sv));
2471         break;
2472     case '-':
2473         IoLINES_LEFT(GvIOp(PL_defoutgv)) = (SvIV(sv));
2474         if (IoLINES_LEFT(GvIOp(PL_defoutgv)) < 0L)
2475             IoLINES_LEFT(GvIOp(PL_defoutgv)) = 0L;
2476         break;
2477     case '%':
2478         IoPAGE(GvIOp(PL_defoutgv)) = (SvIV(sv));
2479         break;
2480     case '|':
2481         {
2482             IO * const io = GvIOp(PL_defoutgv);
2483             if(!io)
2484               break;
2485             if ((SvIV(sv)) == 0)
2486                 IoFLAGS(io) &= ~IOf_FLUSH;
2487             else {
2488                 if (!(IoFLAGS(io) & IOf_FLUSH)) {
2489                     PerlIO *ofp = IoOFP(io);
2490                     if (ofp)
2491                         (void)PerlIO_flush(ofp);
2492                     IoFLAGS(io) |= IOf_FLUSH;
2493                 }
2494             }
2495         }
2496         break;
2497     case '/':
2498         SvREFCNT_dec(PL_rs);
2499         PL_rs = newSVsv(sv);
2500         break;
2501     case '\\':
2502         if (PL_ors_sv)
2503             SvREFCNT_dec(PL_ors_sv);
2504         if (SvOK(sv) || SvGMAGICAL(sv)) {
2505             PL_ors_sv = newSVsv(sv);
2506         }
2507         else {
2508             PL_ors_sv = NULL;
2509         }
2510         break;
2511     case ',':
2512         if (PL_ofs_sv)
2513             SvREFCNT_dec(PL_ofs_sv);
2514         if (SvOK(sv) || SvGMAGICAL(sv)) {
2515             PL_ofs_sv = newSVsv(sv);
2516         }
2517         else {
2518             PL_ofs_sv = NULL;
2519         }
2520         break;
2521     case '[':
2522         CopARYBASE_set(&PL_compiling, SvIV(sv));
2523         break;
2524     case '?':
2525 #ifdef COMPLEX_STATUS
2526         if (PL_localizing == 2) {
2527             PL_statusvalue = LvTARGOFF(sv);
2528             PL_statusvalue_vms = LvTARGLEN(sv);
2529         }
2530         else
2531 #endif
2532 #ifdef VMSISH_STATUS
2533         if (VMSISH_STATUS)
2534             STATUS_NATIVE_CHILD_SET((U32)SvIV(sv));
2535         else
2536 #endif
2537             STATUS_UNIX_EXIT_SET(SvIV(sv));
2538         break;
2539     case '!':
2540         {
2541 #ifdef VMS
2542 #   define PERL_VMS_BANG vaxc$errno
2543 #else
2544 #   define PERL_VMS_BANG 0
2545 #endif
2546         SETERRNO(SvIOK(sv) ? SvIVX(sv) : SvOK(sv) ? sv_2iv(sv) : 0,
2547                  (SvIV(sv) == EVMSERR) ? 4 : PERL_VMS_BANG);
2548         }
2549         break;
2550     case '<':
2551         PL_uid = SvIV(sv);
2552         if (PL_delaymagic) {
2553             PL_delaymagic |= DM_RUID;
2554             break;                              /* don't do magic till later */
2555         }
2556 #ifdef HAS_SETRUID
2557         (void)setruid((Uid_t)PL_uid);
2558 #else
2559 #ifdef HAS_SETREUID
2560         (void)setreuid((Uid_t)PL_uid, (Uid_t)-1);
2561 #else
2562 #ifdef HAS_SETRESUID
2563       (void)setresuid((Uid_t)PL_uid, (Uid_t)-1, (Uid_t)-1);
2564 #else
2565         if (PL_uid == PL_euid) {                /* special case $< = $> */
2566 #ifdef PERL_DARWIN
2567             /* workaround for Darwin's setuid peculiarity, cf [perl #24122] */
2568             if (PL_uid != 0 && PerlProc_getuid() == 0)
2569                 (void)PerlProc_setuid(0);
2570 #endif
2571             (void)PerlProc_setuid(PL_uid);
2572         } else {
2573             PL_uid = PerlProc_getuid();
2574             Perl_croak(aTHX_ "setruid() not implemented");
2575         }
2576 #endif
2577 #endif
2578 #endif
2579         PL_uid = PerlProc_getuid();
2580         PL_tainting |= (PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid));
2581         break;
2582     case '>':
2583         PL_euid = SvIV(sv);
2584         if (PL_delaymagic) {
2585             PL_delaymagic |= DM_EUID;
2586             break;                              /* don't do magic till later */
2587         }
2588 #ifdef HAS_SETEUID
2589         (void)seteuid((Uid_t)PL_euid);
2590 #else
2591 #ifdef HAS_SETREUID
2592         (void)setreuid((Uid_t)-1, (Uid_t)PL_euid);
2593 #else
2594 #ifdef HAS_SETRESUID
2595         (void)setresuid((Uid_t)-1, (Uid_t)PL_euid, (Uid_t)-1);
2596 #else
2597         if (PL_euid == PL_uid)          /* special case $> = $< */
2598             PerlProc_setuid(PL_euid);
2599         else {
2600             PL_euid = PerlProc_geteuid();
2601             Perl_croak(aTHX_ "seteuid() not implemented");
2602         }
2603 #endif
2604 #endif
2605 #endif
2606         PL_euid = PerlProc_geteuid();
2607         PL_tainting |= (PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid));
2608         break;
2609     case '(':
2610         PL_gid = SvIV(sv);
2611         if (PL_delaymagic) {
2612             PL_delaymagic |= DM_RGID;
2613             break;                              /* don't do magic till later */
2614         }
2615 #ifdef HAS_SETRGID
2616         (void)setrgid((Gid_t)PL_gid);
2617 #else
2618 #ifdef HAS_SETREGID
2619         (void)setregid((Gid_t)PL_gid, (Gid_t)-1);
2620 #else
2621 #ifdef HAS_SETRESGID
2622       (void)setresgid((Gid_t)PL_gid, (Gid_t)-1, (Gid_t) 1);
2623 #else
2624         if (PL_gid == PL_egid)                  /* special case $( = $) */
2625             (void)PerlProc_setgid(PL_gid);
2626         else {
2627             PL_gid = PerlProc_getgid();
2628             Perl_croak(aTHX_ "setrgid() not implemented");
2629         }
2630 #endif
2631 #endif
2632 #endif
2633         PL_gid = PerlProc_getgid();
2634         PL_tainting |= (PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid));
2635         break;
2636     case ')':
2637 #ifdef HAS_SETGROUPS
2638         {
2639             const char *p = SvPV_const(sv, len);
2640             Groups_t *gary = NULL;
2641
2642             while (isSPACE(*p))
2643                 ++p;
2644             PL_egid = Atol(p);
2645             for (i = 0; i < NGROUPS; ++i) {
2646                 while (*p && !isSPACE(*p))
2647                     ++p;
2648                 while (isSPACE(*p))
2649                     ++p;
2650                 if (!*p)
2651                     break;
2652                 if(!gary)
2653                     Newx(gary, i + 1, Groups_t);
2654                 else
2655                     Renew(gary, i + 1, Groups_t);
2656                 gary[i] = Atol(p);
2657             }
2658             if (i)
2659                 (void)setgroups(i, gary);
2660             Safefree(gary);
2661         }
2662 #else  /* HAS_SETGROUPS */
2663         PL_egid = SvIV(sv);
2664 #endif /* HAS_SETGROUPS */
2665         if (PL_delaymagic) {
2666             PL_delaymagic |= DM_EGID;
2667             break;                              /* don't do magic till later */
2668         }
2669 #ifdef HAS_SETEGID
2670         (void)setegid((Gid_t)PL_egid);
2671 #else
2672 #ifdef HAS_SETREGID
2673         (void)setregid((Gid_t)-1, (Gid_t)PL_egid);
2674 #else
2675 #ifdef HAS_SETRESGID
2676         (void)setresgid((Gid_t)-1, (Gid_t)PL_egid, (Gid_t)-1);
2677 #else
2678         if (PL_egid == PL_gid)                  /* special case $) = $( */
2679             (void)PerlProc_setgid(PL_egid);
2680         else {
2681             PL_egid = PerlProc_getegid();
2682             Perl_croak(aTHX_ "setegid() not implemented");
2683         }
2684 #endif
2685 #endif
2686 #endif
2687         PL_egid = PerlProc_getegid();
2688         PL_tainting |= (PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid));
2689         break;
2690     case ':':
2691         PL_chopset = SvPV_force(sv,len);
2692         break;
2693 #ifndef MACOS_TRADITIONAL
2694     case '0':
2695         LOCK_DOLLARZERO_MUTEX;
2696 #ifdef HAS_SETPROCTITLE
2697         /* The BSDs don't show the argv[] in ps(1) output, they
2698          * show a string from the process struct and provide
2699          * the setproctitle() routine to manipulate that. */
2700         if (PL_origalen != 1) {
2701             s = SvPV_const(sv, len);
2702 #   if __FreeBSD_version > 410001
2703             /* The leading "-" removes the "perl: " prefix,
2704              * but not the "(perl) suffix from the ps(1)
2705              * output, because that's what ps(1) shows if the
2706              * argv[] is modified. */
2707             setproctitle("-%s", s);
2708 #   else        /* old FreeBSDs, NetBSD, OpenBSD, anyBSD */
2709             /* This doesn't really work if you assume that
2710              * $0 = 'foobar'; will wipe out 'perl' from the $0
2711              * because in ps(1) output the result will be like
2712              * sprintf("perl: %s (perl)", s)
2713              * I guess this is a security feature:
2714              * one (a user process) cannot get rid of the original name.
2715              * --jhi */
2716             setproctitle("%s", s);
2717 #   endif
2718         }
2719 #elif defined(__hpux) && defined(PSTAT_SETCMD)
2720         if (PL_origalen != 1) {
2721              union pstun un;
2722              s = SvPV_const(sv, len);
2723              un.pst_command = (char *)s;
2724              pstat(PSTAT_SETCMD, un, len, 0, 0);
2725         }
2726 #else
2727         if (PL_origalen > 1) {
2728             /* PL_origalen is set in perl_parse(). */
2729             s = SvPV_force(sv,len);
2730             if (len >= (STRLEN)PL_origalen-1) {
2731                 /* Longer than original, will be truncated. We assume that
2732                  * PL_origalen bytes are available. */
2733                 Copy(s, PL_origargv[0], PL_origalen-1, char);
2734             }
2735             else {
2736                 /* Shorter than original, will be padded. */
2737 #ifdef PERL_DARWIN
2738                 /* Special case for Mac OS X: see [perl #38868] */
2739                 const int pad = 0;
2740 #else
2741                 /* Is the space counterintuitive?  Yes.
2742                  * (You were expecting \0?)
2743                  * Does it work?  Seems to.  (In Linux 2.4.20 at least.)
2744                  * --jhi */
2745                 const int pad = ' ';
2746 #endif
2747                 Copy(s, PL_origargv[0], len, char);
2748                 PL_origargv[0][len] = 0;
2749                 memset(PL_origargv[0] + len + 1,
2750                        pad,  PL_origalen - len - 1);
2751             }
2752             PL_origargv[0][PL_origalen-1] = 0;
2753             for (i = 1; i < PL_origargc; i++)
2754                 PL_origargv[i] = 0;
2755         }
2756 #endif
2757         UNLOCK_DOLLARZERO_MUTEX;
2758         break;
2759 #endif
2760     }
2761     return 0;
2762 }
2763
2764 I32
2765 Perl_whichsig(pTHX_ const char *sig)
2766 {
2767     register char* const* sigv;
2768     PERL_UNUSED_CONTEXT;
2769
2770     for (sigv = (char* const*)PL_sig_name; *sigv; sigv++)
2771         if (strEQ(sig,*sigv))
2772             return PL_sig_num[sigv - (char* const*)PL_sig_name];
2773 #ifdef SIGCLD
2774     if (strEQ(sig,"CHLD"))
2775         return SIGCLD;
2776 #endif
2777 #ifdef SIGCHLD
2778     if (strEQ(sig,"CLD"))
2779         return SIGCHLD;
2780 #endif
2781     return -1;
2782 }
2783
2784 Signal_t
2785 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
2786 Perl_sighandler(int sig, siginfo_t *sip, void *uap PERL_UNUSED_DECL)
2787 #else
2788 Perl_sighandler(int sig)
2789 #endif
2790 {
2791 #ifdef PERL_GET_SIG_CONTEXT
2792     dTHXa(PERL_GET_SIG_CONTEXT);
2793 #else
2794     dTHX;
2795 #endif
2796     dSP;
2797     GV *gv = NULL;
2798     SV *sv = NULL;
2799     SV * const tSv = PL_Sv;
2800     CV *cv = NULL;
2801     OP *myop = PL_op;
2802     U32 flags = 0;
2803     XPV * const tXpv = PL_Xpv;
2804
2805     if (PL_savestack_ix + 15 <= PL_savestack_max)
2806         flags |= 1;
2807     if (PL_markstack_ptr < PL_markstack_max - 2)
2808         flags |= 4;
2809     if (PL_scopestack_ix < PL_scopestack_max - 3)
2810         flags |= 16;
2811
2812     if (!PL_psig_ptr[sig]) {
2813                 PerlIO_printf(Perl_error_log, "Signal SIG%s received, but no signal handler set.\n",
2814                                  PL_sig_name[sig]);
2815                 exit(sig);
2816         }
2817
2818     /* Max number of items pushed there is 3*n or 4. We cannot fix
2819        infinity, so we fix 4 (in fact 5): */
2820     if (flags & 1) {
2821         PL_savestack_ix += 5;           /* Protect save in progress. */
2822         SAVEDESTRUCTOR_X(S_unwind_handler_stack, (void*)&flags);
2823     }
2824     if (flags & 4)
2825         PL_markstack_ptr++;             /* Protect mark. */
2826     if (flags & 16)
2827         PL_scopestack_ix += 1;
2828     /* sv_2cv is too complicated, try a simpler variant first: */
2829     if (!SvROK(PL_psig_ptr[sig]) || !(cv = (CV*)SvRV(PL_psig_ptr[sig]))
2830         || SvTYPE(cv) != SVt_PVCV) {
2831         HV *st;
2832         cv = sv_2cv(PL_psig_ptr[sig], &st, &gv, GV_ADD);
2833     }
2834
2835     if (!cv || !CvROOT(cv)) {
2836         if (ckWARN(WARN_SIGNAL))
2837             Perl_warner(aTHX_ packWARN(WARN_SIGNAL), "SIG%s handler \"%s\" not defined.\n",
2838                 PL_sig_name[sig], (gv ? GvENAME(gv)
2839                                 : ((cv && CvGV(cv))
2840                                    ? GvENAME(CvGV(cv))
2841                                    : "__ANON__")));
2842         goto cleanup;
2843     }
2844
2845     if(PL_psig_name[sig]) {
2846         sv = SvREFCNT_inc_NN(PL_psig_name[sig]);
2847         flags |= 64;
2848 #if !defined(PERL_IMPLICIT_CONTEXT)
2849         PL_sig_sv = sv;
2850 #endif
2851     } else {
2852         sv = sv_newmortal();
2853         sv_setpv(sv,PL_sig_name[sig]);
2854     }
2855
2856     PUSHSTACKi(PERLSI_SIGNAL);
2857     PUSHMARK(SP);
2858     PUSHs(sv);
2859 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
2860     {
2861          struct sigaction oact;
2862
2863          if (sigaction(sig, 0, &oact) == 0 && oact.sa_flags & SA_SIGINFO) {
2864               if (sip) {
2865                    HV *sih = newHV();
2866                    SV *rv  = newRV_noinc((SV*)sih);
2867                    /* The siginfo fields signo, code, errno, pid, uid,
2868                     * addr, status, and band are defined by POSIX/SUSv3. */
2869                    (void)hv_stores(sih, "signo", newSViv(sip->si_signo));
2870                    (void)hv_stores(sih, "code", newSViv(sip->si_code));
2871 #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. */
2872                    hv_stores(sih, "errno",      newSViv(sip->si_errno));
2873                    hv_stores(sih, "status",     newSViv(sip->si_status));
2874                    hv_stores(sih, "uid",        newSViv(sip->si_uid));
2875                    hv_stores(sih, "pid",        newSViv(sip->si_pid));
2876                    hv_stores(sih, "addr",       newSVuv(PTR2UV(sip->si_addr)));
2877                    hv_stores(sih, "band",       newSViv(sip->si_band));
2878 #endif
2879                    EXTEND(SP, 2);
2880                    PUSHs((SV*)rv);
2881                    PUSHs(newSVpv((char *)sip, sizeof(*sip)));
2882               }
2883
2884          }
2885     }
2886 #endif
2887     PUTBACK;
2888
2889     call_sv((SV*)cv, G_DISCARD|G_EVAL);
2890
2891     POPSTACK;
2892     if (SvTRUE(ERRSV)) {
2893 #ifndef PERL_MICRO
2894 #ifdef HAS_SIGPROCMASK
2895         /* Handler "died", for example to get out of a restart-able read().
2896          * Before we re-do that on its behalf re-enable the signal which was
2897          * blocked by the system when we entered.
2898          */
2899         sigset_t set;
2900         sigemptyset(&set);
2901         sigaddset(&set,sig);
2902         sigprocmask(SIG_UNBLOCK, &set, NULL);
2903 #else
2904         /* Not clear if this will work */
2905         (void)rsignal(sig, SIG_IGN);
2906         (void)rsignal(sig, PL_csighandlerp);
2907 #endif
2908 #endif /* !PERL_MICRO */
2909         Perl_die(aTHX_ NULL);
2910     }
2911 cleanup:
2912     if (flags & 1)
2913         PL_savestack_ix -= 8; /* Unprotect save in progress. */
2914     if (flags & 4)
2915         PL_markstack_ptr--;
2916     if (flags & 16)
2917         PL_scopestack_ix -= 1;
2918     if (flags & 64)
2919         SvREFCNT_dec(sv);
2920     PL_op = myop;                       /* Apparently not needed... */
2921
2922     PL_Sv = tSv;                        /* Restore global temporaries. */
2923     PL_Xpv = tXpv;
2924     return;
2925 }
2926
2927
2928 static void
2929 S_restore_magic(pTHX_ const void *p)
2930 {
2931     dVAR;
2932     MGS* const mgs = SSPTR(PTR2IV(p), MGS*);
2933     SV* const sv = mgs->mgs_sv;
2934
2935     if (!sv)
2936         return;
2937
2938     if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv))
2939     {
2940 #ifdef PERL_OLD_COPY_ON_WRITE
2941         /* While magic was saved (and off) sv_setsv may well have seen
2942            this SV as a prime candidate for COW.  */
2943         if (SvIsCOW(sv))
2944             sv_force_normal_flags(sv, 0);
2945 #endif
2946
2947         if (mgs->mgs_flags)
2948             SvFLAGS(sv) |= mgs->mgs_flags;
2949         else
2950             mg_magical(sv);
2951         if (SvGMAGICAL(sv)) {
2952             /* downgrade public flags to private,
2953                and discard any other private flags */
2954
2955             const U32 pubflags = SvFLAGS(sv) & (SVf_IOK|SVf_NOK|SVf_POK);
2956             if (pubflags) {
2957                 SvFLAGS(sv) &= ~( pubflags | (SVp_IOK|SVp_NOK|SVp_POK) );
2958                 SvFLAGS(sv) |= ( pubflags << PRIVSHIFT );
2959             }
2960         }
2961     }
2962
2963     mgs->mgs_sv = NULL;  /* mark the MGS structure as restored */
2964
2965     /* If we're still on top of the stack, pop us off.  (That condition
2966      * will be satisfied if restore_magic was called explicitly, but *not*
2967      * if it's being called via leave_scope.)
2968      * The reason for doing this is that otherwise, things like sv_2cv()
2969      * may leave alloc gunk on the savestack, and some code
2970      * (e.g. sighandler) doesn't expect that...
2971      */
2972     if (PL_savestack_ix == mgs->mgs_ss_ix)
2973     {
2974         I32 popval = SSPOPINT;
2975         assert(popval == SAVEt_DESTRUCTOR_X);
2976         PL_savestack_ix -= 2;
2977         popval = SSPOPINT;
2978         assert(popval == SAVEt_ALLOC);
2979         popval = SSPOPINT;
2980         PL_savestack_ix -= popval;
2981     }
2982
2983 }
2984
2985 static void
2986 S_unwind_handler_stack(pTHX_ const void *p)
2987 {
2988     dVAR;
2989     const U32 flags = *(const U32*)p;
2990
2991     if (flags & 1)
2992         PL_savestack_ix -= 5; /* Unprotect save in progress. */
2993 #if !defined(PERL_IMPLICIT_CONTEXT)
2994     if (flags & 64)
2995         SvREFCNT_dec(PL_sig_sv);
2996 #endif
2997 }
2998
2999 /*
3000 =for apidoc magic_sethint
3001
3002 Triggered by a store to %^H, records the key/value pair to
3003 C<PL_compiling.cop_hints_hash>.  It is assumed that hints aren't storing
3004 anything that would need a deep copy.  Maybe we should warn if we find a
3005 reference.
3006
3007 =cut
3008 */
3009 int
3010 Perl_magic_sethint(pTHX_ SV *sv, MAGIC *mg)
3011 {
3012     dVAR;
3013     assert(mg->mg_len == HEf_SVKEY);
3014
3015     /* mg->mg_obj isn't being used.  If needed, it would be possible to store
3016        an alternative leaf in there, with PL_compiling.cop_hints being used if
3017        it's NULL. If needed for threads, the alternative could lock a mutex,
3018        or take other more complex action.  */
3019
3020     /* Something changed in %^H, so it will need to be restored on scope exit.
3021        Doing this here saves a lot of doing it manually in perl code (and
3022        forgetting to do it, and consequent subtle errors.  */
3023     PL_hints |= HINT_LOCALIZE_HH;
3024     PL_compiling.cop_hints_hash
3025         = Perl_refcounted_he_new(aTHX_ PL_compiling.cop_hints_hash,
3026                                  (SV *)mg->mg_ptr, sv);
3027     return 0;
3028 }
3029
3030 /*
3031 =for apidoc magic_sethint
3032
3033 Triggered by a delete from %^H, records the key to
3034 C<PL_compiling.cop_hints_hash>.
3035
3036 =cut
3037 */
3038 int
3039 Perl_magic_clearhint(pTHX_ SV *sv, MAGIC *mg)
3040 {
3041     dVAR;
3042     PERL_UNUSED_ARG(sv);
3043
3044     assert(mg->mg_len == HEf_SVKEY);
3045
3046     PERL_UNUSED_ARG(sv);
3047
3048     PL_hints |= HINT_LOCALIZE_HH;
3049     PL_compiling.cop_hints_hash
3050         = Perl_refcounted_he_new(aTHX_ PL_compiling.cop_hints_hash,
3051                                  (SV *)mg->mg_ptr, &PL_sv_placeholder);
3052     return 0;
3053 }
3054
3055 /*
3056  * Local variables:
3057  * c-indentation-style: bsd
3058  * c-basic-offset: 4
3059  * indent-tabs-mode: t
3060  * End:
3061  *
3062  * ex: set ts=8 sts=4 sw=4 noet:
3063  */