This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
https://perl5.git.perl.org / perl5.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Update which stable release series are now "officially" supported
[perl5.git] / mg.c
CommitLineData
a0d0e21e 1/* mg.c
79072805 2 *
1129b882
NC		 3 * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 * 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others
79072805
LW		 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 *
a0d0e21e
LW		 9 */
10
11/*
4ac71550
TC		 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 * [p.363 of _The Lord of the Rings_, II/vii: "The Mirror of Galadriel"]
79072805
LW		 16 */
17
ccfc67b7
JH		 18/*
19=head1 Magical Functions
166f8a29
DM		 20"Magic" is special data attached to SV structures in order to give them
21"magical" properties. When any Perl code tries to read from, or assign to,
22an SV marked as magical, it calls the 'get' or 'set' function associated
154e47c8 23with that SV's magic. A get is called prior to reading an SV, in order to
ddfa107c 24give it a chance to update its internal value (get on $. writes the line
b53c43bf 25number of the last read filehandle into the SV's IV slot), while
166f8a29 26set is called after an SV has been written to, in order to allow it to make
ddfa107c 27use of its changed value (set on $/ copies the SV's new value to the
166f8a29
DM		 28PL_rs global variable).
29
30Magic is implemented as a linked list of MAGIC structures attached to the
154e47c8 31SV. Each MAGIC struct holds the type of the magic, a pointer to an array
166f8a29 32of functions that implement the get(), set(), length() etc functions,
154e47c8 33plus space for some flags and pointers. For example, a tied variable has
166f8a29
DM		 34a MAGIC structure that contains a pointer to the object associated with the
35tie.
36
7fefc6c1
KW		 37=cut
38
ccfc67b7
JH		 39*/
40
79072805 41#include "EXTERN.h"
864dbfa3 42#define PERL_IN_MG_C
79072805
LW		 43#include "perl.h"
44
5cd24f17 45#if defined(HAS_GETGROUPS) || defined(HAS_SETGROUPS)
b7953727
JH		 46# ifdef I_GRP
47# include <grp.h>
48# endif
188ea221
CS		 49#endif
50
757f63d8
SP		 51#if defined(HAS_SETGROUPS)
52# ifndef NGROUPS
53# define NGROUPS 32
54# endif
55#endif
56
17aa7f3d
JH		 57#ifdef __hpux
58# include <sys/pstat.h>
59#endif
60
7636ea95
AB		 61#ifdef HAS_PRCTL_SET_NAME
62# include <sys/prctl.h>
63#endif
64
8aad04aa 65#if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
b6455c53 66Signal_t Perl_csighandler(int sig, siginfo_t *, void *);
8aad04aa 67#else
e69880a5 68Signal_t Perl_csighandler(int sig);
8aad04aa 69#endif
e69880a5 70
9cffb111
OS		 71#ifdef __Lynx__
72/* Missing protos on LynxOS */
73void setruid(uid_t id);
74void seteuid(uid_t id);
75void setrgid(uid_t id);
76void setegid(uid_t id);
77#endif
78
c07a80fd 79/*
4bac9ae4 80 * Pre-magic setup and post-magic takedown.
c07a80fd 81 * Use the "DESTRUCTOR" scope cleanup to reinstate magic.
82 */
83
84struct magic_state {
85 SV* mgs_sv;
455ece5e 86 I32 mgs_ss_ix;
f9c6fee5
CS		 87 U32 mgs_magical;
88 bool mgs_readonly;
150b625d 89 bool mgs_bumped;
c07a80fd 90};
455ece5e 91/* MGS is typedef'ed to struct magic_state in perl.h */
76e3520e
GS		 92
93STATIC void
ff44333e 94S_save_magic_flags(pTHX_ I32 mgs_ix, SV *sv, U32 flags)
c07a80fd 95{
455ece5e 96 MGS* mgs;
150b625d 97 bool bumped = FALSE;
7918f24d 98
ff44333e 99 PERL_ARGS_ASSERT_SAVE_MAGIC_FLAGS;
7918f24d 100
4bac9ae4
CS		 101 assert(SvMAGICAL(sv));
102
150b625d
DM		 103 /* we shouldn't really be called here with RC==0, but it can sometimes
104 * happen via mg_clear() (which also shouldn't be called when RC==0,
105 * but it can happen). Handle this case gracefully(ish) by not RC++
106 * and thus avoiding the resultant double free */
107 if (SvREFCNT(sv) > 0) {
108 /* guard against sv getting freed midway through the mg clearing,
109 * by holding a private reference for the duration. */
110 SvREFCNT_inc_simple_void_NN(sv);
111 bumped = TRUE;
112 }
8985fe98 113
8772537c 114 SAVEDESTRUCTOR_X(S_restore_magic, INT2PTR(void*, (IV)mgs_ix));
455ece5e
AD		 115
116 mgs = SSPTR(mgs_ix, MGS*);
c07a80fd 117 mgs->mgs_sv = sv;
f9c6fee5 118 mgs->mgs_magical = SvMAGICAL(sv);
46959f1c 119 mgs->mgs_readonly = SvREADONLY(sv) != 0;
455ece5e 120 mgs->mgs_ss_ix = PL_savestack_ix; /* points after the saved destructor */
150b625d 121 mgs->mgs_bumped = bumped;
c07a80fd 122
ff44333e 123 SvFLAGS(sv) &= ~flags;
3805b5fb 124 SvREADONLY_off(sv);
c07a80fd 125}
126
ff44333e
FC		 127#define save_magic(a,b) save_magic_flags(a,b,SVs_GMG|SVs_SMG|SVs_RMG)
128
954c1994
GS		 129/*
130=for apidoc mg_magical
131
132Turns on the magical status of an SV. See C<sv_magic>.
133
134=cut
135*/
136
8990e307 137void
ddeaf645 138Perl_mg_magical(SV *sv)
8990e307 139{
e1ec3a88 140 const MAGIC* mg;
7918f24d 141 PERL_ARGS_ASSERT_MG_MAGICAL;
f9c6fee5
CS		 142
143 SvMAGICAL_off(sv);
218787bd 144 if ((mg = SvMAGIC(sv))) {
218787bd
VP		 145 do {
146 const MGVTBL* const vtbl = mg->mg_virtual;
147 if (vtbl) {
148 if (vtbl->svt_get && !(mg->mg_flags & MGf_GSKIP))
149 SvGMAGICAL_on(sv);
150 if (vtbl->svt_set)
151 SvSMAGICAL_on(sv);
152 if (vtbl->svt_clear)
153 SvRMAGICAL_on(sv);
154 }
155 } while ((mg = mg->mg_moremagic));
156 if (!(SvFLAGS(sv) & (SVs_GMG|SVs_SMG)))
157 SvRMAGICAL_on(sv);
8990e307
LW		 158 }
159}
160
954c1994
GS		 161/*
162=for apidoc mg_get
163
4b1e7f06 164Do magic before a value is retrieved from the SV. The type of SV must
72d33970 165be >= SVt_PVMG. See C<sv_magic>.
954c1994
GS		 166
167=cut
168*/
169
79072805 170int
864dbfa3 171Perl_mg_get(pTHX_ SV *sv)
79072805 172{
35a4481c 173 const I32 mgs_ix = SSNEW(sizeof(MGS));
a9844598 174 bool saved = FALSE;
f9c6fee5 175 bool have_new = 0;
ff76feab 176 MAGIC *newmg, *head, *cur, *mg;
6683b158 177
7918f24d
NC		 178 PERL_ARGS_ASSERT_MG_GET;
179
407287f9
FC		 180 if (PL_localizing == 1 && sv == DEFSV) return 0;
181
ff76feab
AMS		 182 /* We must call svt_get(sv, mg) for each valid entry in the linked
183 list of magic. svt_get() may delete the current entry, add new
184 magic to the head of the list, or upgrade the SV. AMS 20010810 */
185
186 newmg = cur = head = mg = SvMAGIC(sv);
187 while (mg) {
35a4481c 188 const MGVTBL * const vtbl = mg->mg_virtual;
f9c6fee5 189 MAGIC * const nextmg = mg->mg_moremagic; /* it may delete itself */
ff76feab 190
2b260de0 191 if (!(mg->mg_flags & MGf_GSKIP) && vtbl && vtbl->svt_get) {
a9844598
CS		 192
193 /* taint's mg get is so dumb it doesn't need flag saving */
194 if (!saved && mg->mg_type != PERL_MAGIC_taint) {
195 save_magic(mgs_ix, sv);
196 saved = TRUE;
197 }
198
16c91539 199 vtbl->svt_get(aTHX_ sv, mg);
b77f7d40 200
58f82c5c
DM		 201 /* guard against magic having been deleted - eg FETCH calling
202 * untie */
f9c6fee5
CS		 203 if (!SvMAGIC(sv)) {
204 (SSPTR(mgs_ix, MGS *))->mgs_magical = 0; /* recalculate flags */
58f82c5c 205 break;
f9c6fee5 206 }
b77f7d40 207
f9c6fee5 208 /* recalculate flags if this entry was deleted. */
ff76feab 209 if (mg->mg_flags & MGf_GSKIP)
f9c6fee5 210 (SSPTR(mgs_ix, MGS *))->mgs_magical = 0;
a0d0e21e 211 }
7d1328bb
FC		 212 else if (vtbl == &PL_vtbl_utf8) {
213 /* get-magic can reallocate the PV */
214 magic_setutf8(sv, mg);
215 }
ff76feab 216
f9c6fee5 217 mg = nextmg;
ff76feab 218
0723351e 219 if (have_new) {
ff76feab
AMS		 220 /* Have we finished with the new entries we saw? Start again
221 where we left off (unless there are more new entries). */
222 if (mg == head) {
0723351e 223 have_new = 0;
ff76feab
AMS		 224 mg = cur;
225 head = newmg;
226 }
227 }
228
229 /* Were any new entries added? */
0723351e
NC		 230 if (!have_new && (newmg = SvMAGIC(sv)) != head) {
231 have_new = 1;
ff76feab
AMS		 232 cur = mg;
233 mg = newmg;
f9c6fee5 234 (SSPTR(mgs_ix, MGS *))->mgs_magical = 0; /* recalculate flags */
760ac839 235 }
79072805 236 }
463ee0b2 237
a9844598
CS		 238 if (saved)
239 restore_magic(INT2PTR(void *, (IV)mgs_ix));
240
79072805
LW		 241 return 0;
242}
243
954c1994
GS		 244/*
245=for apidoc mg_set
246
247Do magic after a value is assigned to the SV. See C<sv_magic>.
248
249=cut
250*/
251
79072805 252int
864dbfa3 253Perl_mg_set(pTHX_ SV *sv)
79072805 254{
35a4481c 255 const I32 mgs_ix = SSNEW(sizeof(MGS));
79072805 256 MAGIC* mg;
463ee0b2
LW		 257 MAGIC* nextmg;
258
7918f24d
NC		 259 PERL_ARGS_ASSERT_MG_SET;
260
b5ed8c44
FC		 261 if (PL_localizing == 2 && sv == DEFSV) return 0;
262
ff44333e 263 save_magic_flags(mgs_ix, sv, SVs_GMG|SVs_SMG); /* leave SVs_RMG on */
463ee0b2
LW		 264
265 for (mg = SvMAGIC(sv); mg; mg = nextmg) {
e1ec3a88 266 const MGVTBL* vtbl = mg->mg_virtual;
463ee0b2 267 nextmg = mg->mg_moremagic; /* it may delete itself */
a0d0e21e
LW		 268 if (mg->mg_flags & MGf_GSKIP) {
269 mg->mg_flags &= ~MGf_GSKIP; /* setting requires another read */
f9c6fee5 270 (SSPTR(mgs_ix, MGS*))->mgs_magical = 0;
a0d0e21e 271 }
e0a73de4 272 if (PL_localizing == 2
b5ed8c44 273 && PERL_MAGIC_TYPE_IS_VALUE_MAGIC(mg->mg_type))
e7cbf6c6 274 continue;
2b260de0 275 if (vtbl && vtbl->svt_set)
16c91539 276 vtbl->svt_set(aTHX_ sv, mg);
79072805 277 }
463ee0b2 278
8772537c 279 restore_magic(INT2PTR(void*, (IV)mgs_ix));
79072805
LW		 280 return 0;
281}
282
954c1994
GS		 283/*
284=for apidoc mg_length
285
d4e99c76 286Reports on the SV's length in bytes, calling length magic if available,
bd8446cf
FC		 287but does not set the UTF8 flag on the sv. It will fall back to 'get'
288magic if there is no 'length' magic, but with no indication as to
289whether it called 'get' magic. It assumes the sv is a PVMG or
290higher. Use sv_len() instead.
954c1994
GS		 291
292=cut
293*/
294
79072805 295U32
864dbfa3 296Perl_mg_length(pTHX_ SV *sv)
79072805
LW		 297{
298 MAGIC* mg;
463ee0b2 299 STRLEN len;
463ee0b2 300
7918f24d
NC		 301 PERL_ARGS_ASSERT_MG_LENGTH;
302
79072805 303 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
35a4481c 304 const MGVTBL * const vtbl = mg->mg_virtual;
2b260de0 305 if (vtbl && vtbl->svt_len) {
35a4481c 306 const I32 mgs_ix = SSNEW(sizeof(MGS));
455ece5e 307 save_magic(mgs_ix, sv);
a0d0e21e 308 /* omit MGf_GSKIP -- not changed here */
16c91539 309 len = vtbl->svt_len(aTHX_ sv, mg);
8772537c 310 restore_magic(INT2PTR(void*, (IV)mgs_ix));
85e6fe83
LW		 311 return len;
312 }
313 }
314
bd8446cf 315 (void)SvPV_const(sv, len);
463ee0b2 316 return len;
79072805
LW		 317}
318
8fb26106 319I32
864dbfa3 320Perl_mg_size(pTHX_ SV *sv)
93965878
NIS		 321{
322 MAGIC* mg;
ac27b0f5 323
7918f24d
NC		 324 PERL_ARGS_ASSERT_MG_SIZE;
325
93965878 326 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
35a4481c 327 const MGVTBL* const vtbl = mg->mg_virtual;
2b260de0 328 if (vtbl && vtbl->svt_len) {
35a4481c
AL		 329 const I32 mgs_ix = SSNEW(sizeof(MGS));
330 I32 len;
455ece5e 331 save_magic(mgs_ix, sv);
93965878 332 /* omit MGf_GSKIP -- not changed here */
16c91539 333 len = vtbl->svt_len(aTHX_ sv, mg);
8772537c 334 restore_magic(INT2PTR(void*, (IV)mgs_ix));
93965878
NIS		 335 return len;
336 }
337 }
338
339 switch(SvTYPE(sv)) {
340 case SVt_PVAV:
502c6561 341 return AvFILLp((const AV *) sv); /* Fallback to non-tied array */
93965878
NIS		 342 case SVt_PVHV:
343 /* FIXME */
344 default:
cea2e8a9 345 Perl_croak(aTHX_ "Size magic not implemented");
81d52ecd 346
93965878 347 }
a25b5927 348 NOT_REACHED; /* NOTREACHED */
93965878
NIS		 349}
350
954c1994
GS		 351/*
352=for apidoc mg_clear
353
354Clear something magical that the SV represents. See C<sv_magic>.
355
356=cut
357*/
358
79072805 359int
864dbfa3 360Perl_mg_clear(pTHX_ SV *sv)
79072805 361{
35a4481c 362 const I32 mgs_ix = SSNEW(sizeof(MGS));
79072805 363 MAGIC* mg;
8ac77ac9 364 MAGIC *nextmg;
463ee0b2 365
7918f24d
NC		 366 PERL_ARGS_ASSERT_MG_CLEAR;
367
455ece5e 368 save_magic(mgs_ix, sv);
463ee0b2 369
8ac77ac9 370 for (mg = SvMAGIC(sv); mg; mg = nextmg) {
35a4481c 371 const MGVTBL* const vtbl = mg->mg_virtual;
a0d0e21e 372 /* omit GSKIP -- never set here */
727405f8 373
8ac77ac9
NC		 374 nextmg = mg->mg_moremagic; /* it may delete itself */
375
2b260de0 376 if (vtbl && vtbl->svt_clear)
16c91539 377 vtbl->svt_clear(aTHX_ sv, mg);
79072805 378 }
463ee0b2 379
8772537c 380 restore_magic(INT2PTR(void*, (IV)mgs_ix));
79072805
LW		 381 return 0;
382}
383
ed624ca8 384static MAGIC*
ddeaf645 385S_mg_findext_flags(const SV *sv, int type, const MGVTBL *vtbl, U32 flags)
39de7f53 386{
39de7f53
FR		 387 assert(flags <= 1);
388
389 if (sv) {
390 MAGIC *mg;
391
7db6405c
FC		 392 assert(!(SvTYPE(sv) == SVt_PVAV && AvPAD_NAMELIST(sv)));
393
39de7f53
FR		 394 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
395 if (mg->mg_type == type && (!flags || mg->mg_virtual == vtbl)) {
396 return mg;
397 }
398 }
399 }
400
401 return NULL;
402}
403
954c1994
GS		 404/*
405=for apidoc mg_find
406
407Finds the magic pointer for type matching the SV. See C<sv_magic>.
408
409=cut
410*/
411
93a17b20 412MAGIC*
ddeaf645 413Perl_mg_find(const SV *sv, int type)
93a17b20 414{
ddeaf645 415 return S_mg_findext_flags(sv, type, NULL, 0);
39de7f53
FR		 416}
417
418/*
419=for apidoc mg_findext
420
421Finds the magic pointer of C<type> with the given C<vtbl> for the C<SV>. See
422C<sv_magicext>.
423
424=cut
425*/
426
427MAGIC*
ddeaf645 428Perl_mg_findext(const SV *sv, int type, const MGVTBL *vtbl)
39de7f53 429{
ddeaf645 430 return S_mg_findext_flags(sv, type, vtbl, 1);
93a17b20
LW		 431}
432
96c2a8ff
FC		 433MAGIC *
434Perl_mg_find_mglob(pTHX_ SV *sv)
435{
436 PERL_ARGS_ASSERT_MG_FIND_MGLOB;
437 if (SvTYPE(sv) == SVt_PVLV && LvTYPE(sv) == 'y') {
438 /* This sv is only a delegate. //g magic must be attached to
439 its target. */
440 vivify_defelem(sv);
441 sv = LvTARG(sv);
442 }
443 if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv))
ddeaf645 444 return S_mg_findext_flags(sv, PERL_MAGIC_regex_global, 0, 0);
96c2a8ff
FC		 445 return NULL;
446}
447
954c1994
GS		 448/*
449=for apidoc mg_copy
450
451Copies the magic from one SV to another. See C<sv_magic>.
452
453=cut
454*/
455
79072805 456int
864dbfa3 457Perl_mg_copy(pTHX_ SV *sv, SV *nsv, const char *key, I32 klen)
79072805 458{
463ee0b2 459 int count = 0;
79072805 460 MAGIC* mg;
7918f24d
NC		 461
462 PERL_ARGS_ASSERT_MG_COPY;
463
463ee0b2 464 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
35a4481c 465 const MGVTBL* const vtbl = mg->mg_virtual;
68795e93 466 if ((mg->mg_flags & MGf_COPY) && vtbl->svt_copy){
16c91539 467 count += vtbl->svt_copy(aTHX_ sv, mg, nsv, key, klen);
68795e93 468 }
823a54a3
AL		 469 else {
470 const char type = mg->mg_type;
1e73acc8 471 if (isUPPER(type) && type != PERL_MAGIC_uvar) {
823a54a3
AL		 472 sv_magic(nsv,
473 (type == PERL_MAGIC_tied)
474 ? SvTIED_obj(sv, mg)
475 : (type == PERL_MAGIC_regdata && mg->mg_obj)
476 ? sv
477 : mg->mg_obj,
478 toLOWER(type), key, klen);
479 count++;
480 }
79072805 481 }
79072805 482 }
463ee0b2 483 return count;
79072805
LW		 484}
485
954c1994 486/*
0cbee0a4
DM		 487=for apidoc mg_localize
488
9711599e 489Copy some of the magic from an existing SV to new localized version of that
154e47c8
FC		 490SV. Container magic (eg %ENV, $1, tie)
491gets copied, value magic doesn't (eg
9711599e
CS		 492taint, pos).
493
af7df257 494If setmagic is false then no set magic will be called on the new (empty) SV.
9711599e
CS		 495This typically means that assignment will soon follow (e.g. 'local $x = $y'),
496and that will handle the magic.
0cbee0a4
DM		 497
498=cut
499*/
500
501void
af7df257 502Perl_mg_localize(pTHX_ SV *sv, SV *nsv, bool setmagic)
0cbee0a4
DM		 503{
504 MAGIC *mg;
7918f24d
NC		 505
506 PERL_ARGS_ASSERT_MG_LOCALIZE;
507
658a9f31
JD		 508 if (nsv == DEFSV)
509 return;
510
0cbee0a4 511 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
2b1b43ea 512 const MGVTBL* const vtbl = mg->mg_virtual;
e0a73de4 513 if (PERL_MAGIC_TYPE_IS_VALUE_MAGIC(mg->mg_type))
0cbee0a4 514 continue;
0cbee0a4 515
a5063e7c 516 if ((mg->mg_flags & MGf_LOCAL) && vtbl->svt_local)
16c91539 517 (void)vtbl->svt_local(aTHX_ nsv, mg);
a5063e7c 518 else
0cbee0a4
DM		 519 sv_magicext(nsv, mg->mg_obj, mg->mg_type, vtbl,
520 mg->mg_ptr, mg->mg_len);
a5063e7c 521
0cbee0a4 522 /* container types should remain read-only across localization */
9ff3e6d8 523 SvFLAGS(nsv) |= SvREADONLY(sv);
0cbee0a4
DM		 524 }
525
526 if (SvTYPE(nsv) >= SVt_PVMG && SvMAGIC(nsv)) {
527 SvFLAGS(nsv) |= SvMAGICAL(sv);
af7df257 528 if (setmagic) {
9711599e
CS		 529 PL_localizing = 1;
530 SvSETMAGIC(nsv);
531 PL_localizing = 0;
532 }
0cbee0a4
DM		 533 }
534}
535
d9088386
Z		 536#define mg_free_struct(sv, mg) S_mg_free_struct(aTHX_ sv, mg)
537static void
538S_mg_free_struct(pTHX_ SV *sv, MAGIC *mg)
539{
540 const MGVTBL* const vtbl = mg->mg_virtual;
541 if (vtbl && vtbl->svt_free)
542 vtbl->svt_free(aTHX_ sv, mg);
543 if (mg->mg_ptr && mg->mg_type != PERL_MAGIC_regex_global) {
544 if (mg->mg_len > 0 || mg->mg_type == PERL_MAGIC_utf8)
545 Safefree(mg->mg_ptr);
546 else if (mg->mg_len == HEf_SVKEY)
547 SvREFCNT_dec(MUTABLE_SV(mg->mg_ptr));
548 }
549 if (mg->mg_flags & MGf_REFCOUNTED)
550 SvREFCNT_dec(mg->mg_obj);
551 Safefree(mg);
552}
553
0cbee0a4 554/*
954c1994
GS		 555=for apidoc mg_free
556
557Free any magic storage used by the SV. See C<sv_magic>.
558
559=cut
560*/
561
79072805 562int
864dbfa3 563Perl_mg_free(pTHX_ SV *sv)
79072805
LW		 564{
565 MAGIC* mg;
566 MAGIC* moremagic;
7918f24d
NC		 567
568 PERL_ARGS_ASSERT_MG_FREE;
569
79072805 570 for (mg = SvMAGIC(sv); mg; mg = moremagic) {
79072805 571 moremagic = mg->mg_moremagic;
d9088386 572 mg_free_struct(sv, mg);
c826f41b 573 SvMAGIC_set(sv, moremagic);
79072805 574 }
b162af07 575 SvMAGIC_set(sv, NULL);
68f8932e 576 SvMAGICAL_off(sv);
79072805
LW		 577 return 0;
578}
579
d9088386
Z		 580/*
581=for apidoc Am|void|mg_free_type|SV *sv|int how
582
583Remove any magic of type I<how> from the SV I<sv>. See L</sv_magic>.
584
585=cut
586*/
587
588void
589Perl_mg_free_type(pTHX_ SV *sv, int how)
590{
591 MAGIC *mg, *prevmg, *moremg;
592 PERL_ARGS_ASSERT_MG_FREE_TYPE;
593 for (prevmg = NULL, mg = SvMAGIC(sv); mg; prevmg = mg, mg = moremg) {
594 MAGIC *newhead;
595 moremg = mg->mg_moremagic;
596 if (mg->mg_type == how) {
597 /* temporarily move to the head of the magic chain, in case
598 custom free code relies on this historical aspect of mg_free */
599 if (prevmg) {
600 prevmg->mg_moremagic = moremg;
601 mg->mg_moremagic = SvMAGIC(sv);
602 SvMAGIC_set(sv, mg);
603 }
604 newhead = mg->mg_moremagic;
605 mg_free_struct(sv, mg);
606 SvMAGIC_set(sv, newhead);
607 mg = prevmg;
608 }
609 }
610 mg_magical(sv);
611}
612
79072805 613#include <signal.h>
79072805 614
942e002e 615U32
864dbfa3 616Perl_magic_regdata_cnt(pTHX_ SV *sv, MAGIC *mg)
6cef1e77 617{
8772537c 618 PERL_UNUSED_ARG(sv);
6cef1e77 619
7918f24d
NC		 620 PERL_ARGS_ASSERT_MAGIC_REGDATA_CNT;
621
0bd48802 622 if (PL_curpm) {
eb578fdb 623 const REGEXP * const rx = PM_GETRE(PL_curpm);
0bd48802 624 if (rx) {
a678b0e4
YO		 625 if (mg->mg_obj) { /* @+ */
626 /* return the number possible */
07bc277f 627 return RX_NPARENS(rx);
a678b0e4 628 } else { /* @- */
07bc277f 629 I32 paren = RX_LASTPAREN(rx);
a678b0e4
YO		 630
631 /* return the last filled */
f46c4081 632 while ( paren >= 0
07bc277f
NC		 633 && (RX_OFFS(rx)[paren].start == -1
634 || RX_OFFS(rx)[paren].end == -1) )
f46c4081 635 paren--;
a678b0e4
YO		 636 return (U32)paren;
637 }
0bd48802 638 }
8f580fb8 639 }
ac27b0f5 640
942e002e 641 return (U32)-1;
6cef1e77
IZ		 642}
643
6502e081
DM		 644/* @-, @+ */
645
6cef1e77 646int
864dbfa3 647Perl_magic_regdatum_get(pTHX_ SV *sv, MAGIC *mg)
6cef1e77 648{
7918f24d
NC		 649 PERL_ARGS_ASSERT_MAGIC_REGDATUM_GET;
650
0bd48802 651 if (PL_curpm) {
eb578fdb 652 const REGEXP * const rx = PM_GETRE(PL_curpm);
0bd48802 653 if (rx) {
eb578fdb 654 const I32 paren = mg->mg_len;
a10eae29
FC		 655 SSize_t s;
656 SSize_t t;
0bd48802
AL		 657 if (paren < 0)
658 return 0;
07bc277f
NC		 659 if (paren <= (I32)RX_NPARENS(rx) &&
660 (s = RX_OFFS(rx)[paren].start) != -1 &&
661 (t = RX_OFFS(rx)[paren].end) != -1)
0bd48802 662 {
a10eae29 663 SSize_t i;
0bd48802
AL		 664 if (mg->mg_obj) /* @+ */
665 i = t;
666 else /* @- */
667 i = s;
668
a10eae29 669 if (RX_MATCH_UTF8(rx)) {
07bc277f 670 const char * const b = RX_SUBBEG(rx);
0bd48802 671 if (b)
6502e081
DM		 672 i = RX_SUBCOFFSET(rx) +
673 utf8_length((U8*)b,
674 (U8*)(b-RX_SUBOFFSET(rx)+i));
0bd48802 675 }
727405f8 676
a10eae29 677 sv_setuv(sv, i);
232af1f8 678 return 0;
1aa99e6b 679 }
0bd48802 680 }
6cef1e77 681 }
232af1f8 682 sv_setsv(sv, NULL);
6cef1e77
IZ		 683 return 0;
684}
685
6502e081
DM		 686/* @-, @+ */
687
e4b89193 688int
a29d06ed
MG		 689Perl_magic_regdatum_set(pTHX_ SV *sv, MAGIC *mg)
690{
7918f24d 691 PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET;
dc3bf405 692 PERL_UNUSED_CONTEXT;
d4c19fe8
AL		 693 PERL_UNUSED_ARG(sv);
694 PERL_UNUSED_ARG(mg);
cb077ed2 695 Perl_croak_no_modify();
0dbb1585 696 NORETURN_FUNCTION_END;
a29d06ed
MG		 697}
698
ad3296c6 699#define SvRTRIM(sv) STMT_START { \
eae92ea0
GA		 700 if (SvPOK(sv)) { \
701 STRLEN len = SvCUR(sv); \
702 char * const p = SvPVX(sv); \
8e6b4db6
PC		 703 while (len > 0 && isSPACE(p[len-1])) \
704 --len; \
705 SvCUR_set(sv, len); \
706 p[len] = '\0'; \
707 } \
ad3296c6
SH		 708} STMT_END
709
8b850bd5
NC		 710void
711Perl_emulate_cop_io(pTHX_ const COP *const c, SV *const sv)
712{
7918f24d
NC		 713 PERL_ARGS_ASSERT_EMULATE_COP_IO;
714
8b850bd5
NC		 715 if (!(CopHINTS_get(c) & (HINT_LEXICAL_IO_IN|HINT_LEXICAL_IO_OUT)))
716 sv_setsv(sv, &PL_sv_undef);
717 else {
718 sv_setpvs(sv, "");
719 SvUTF8_off(sv);
720 if ((CopHINTS_get(c) & HINT_LEXICAL_IO_IN)) {
20439bc7 721 SV *const value = cop_hints_fetch_pvs(c, "open<", 0);
8b850bd5
NC		 722 assert(value);
723 sv_catsv(sv, value);
724 }
725 sv_catpvs(sv, "\0");
726 if ((CopHINTS_get(c) & HINT_LEXICAL_IO_OUT)) {
20439bc7 727 SV *const value = cop_hints_fetch_pvs(c, "open>", 0);
8b850bd5
NC		 728 assert(value);
729 sv_catsv(sv, value);
730 }
731 }
732}
733
d9fe7d23
KW		 734STATIC void
735S_fixup_errno_string(pTHX_ SV* sv)
736{
737 /* Do what is necessary to fixup the non-empty string in 'sv' for return to
738 * Perl space. */
739
740 PERL_ARGS_ASSERT_FIXUP_ERRNO_STRING;
741
742 assert(SvOK(sv));
b35e4f8b
KW		 743
744 if(strEQ(SvPVX(sv), "")) {
745 sv_catpv(sv, UNKNOWN_ERRNO_MSG);
746 }
747 else {
d9fe7d23 748
d3c0b317
KW		 749 /* In some locales the error string may come back as UTF-8, in which
750 * case we should turn on that flag. This didn't use to happen, and to
5320b60d
KW		 751 * avoid as many possible backward compatibility issues as possible, we
752 * don't turn on the flag unless we have to. So the flag stays off for
753 * an entirely ASCII string. We assume that if the string looks like
754 * UTF-8, it really is UTF-8: "text in any other encoding that uses
755 * bytes with the high bit set is extremely unlikely to pass a UTF-8
756 * validity test" (http://en.wikipedia.org/wiki/Charset_detection).
757 * There is a potential that we will get it wrong however, especially
758 * on short error message text. (If it turns out to be necessary, we
759 * could also keep track if the current LC_MESSAGES locale is UTF-8) */
d3c0b317
KW		 760 if (! IN_BYTES /* respect 'use bytes' */
761 && ! is_ascii_string((U8*) SvPVX_const(sv), SvCUR(sv))
762 && is_utf8_string((U8*) SvPVX_const(sv), SvCUR(sv)))
763 {
764 SvUTF8_on(sv);
765 }
b35e4f8b 766 }
d9fe7d23
KW		 767}
768
25bbd826
CB		 769#ifdef VMS
770#include <descrip.h>
771#include <starlet.h>
772#endif
773
79072805 774int
864dbfa3 775Perl_magic_get(pTHX_ SV *sv, MAGIC *mg)
79072805 776{
eb578fdb
KW		 777 I32 paren;
778 const char *s = NULL;
779 REGEXP *rx;
823a54a3 780 const char * const remaining = mg->mg_ptr + 1;
e91d8259 781 char nextchar;
79072805 782
7918f24d
NC		 783 PERL_ARGS_ASSERT_MAGIC_GET;
784
e91d8259 785 if (!mg->mg_ptr) {
e91d8259 786 paren = mg->mg_len;
e91d8259 787 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
a6d0b1b5 788 do_numbuf_fetch:
e91d8259
NC		 789 CALLREG_NUMBUF_FETCH(rx,paren,sv);
790 } else {
791 sv_setsv(sv,&PL_sv_undef);
792 }
793 return 0;
794 }
795
796 nextchar = *remaining;
79072805 797 switch (*mg->mg_ptr) {
748a9306 798 case '\001': /* ^A */
f2da823f
FC		 799 if (SvOK(PL_bodytarget)) sv_copypv(sv, PL_bodytarget);
800 else sv_setsv(sv, &PL_sv_undef);
125b9982
NT		 801 if (SvTAINTED(PL_bodytarget))
802 SvTAINTED_on(sv);
748a9306 803 break;
e5218da5 804 case '\003': /* ^C, ^CHILD_ERROR_NATIVE */
823a54a3 805 if (nextchar == '\0') {
e5218da5
GA		 806 sv_setiv(sv, (IV)PL_minus_c);
807 }
823a54a3 808 else if (strEQ(remaining, "HILD_ERROR_NATIVE")) {
e5218da5
GA		 809 sv_setiv(sv, (IV)STATUS_NATIVE);
810 }
49460fe6
NIS		 811 break;
812
79072805 813 case '\004': /* ^D */
aea4f609 814 sv_setiv(sv, (IV)(PL_debug & DEBUG_MASK));
79072805 815 break;
28f23441 816 case '\005': /* ^E */
6c6eab55
KW		 817 if (nextchar != '\0') {
818 if (strEQ(remaining, "NCODING"))
819 sv_setsv(sv, PL_encoding);
4f4ff3a7 820 break;
6c6eab55 821 }
4f4ff3a7
KW		 822
823#if defined(VMS) || defined(OS2) || defined(WIN32)
824# if defined(VMS)
2a99ff86
KW		 825 {
826 char msg[255];
827 $DESCRIPTOR(msgdsc,msg);
828 sv_setnv(sv,(NV) vaxc$errno);
829 if (sys$getmsg(vaxc$errno,&msgdsc.dsc$w_length,&msgdsc,0,0) & 1)
830 sv_setpvn(sv,msgdsc.dsc$a_pointer,msgdsc.dsc$w_length);
831 else
832 sv_setpvs(sv,"");
833 }
4b645107 834#elif defined(OS2)
2a99ff86
KW		 835 if (!(_emx_env & 0x200)) { /* Under DOS */
836 sv_setnv(sv, (NV)errno);
2c6ee1a7 837 sv_setpv(sv, errno ? my_strerror(errno) : "");
2a99ff86
KW		 838 } else {
839 if (errno != errno_isOS2) {
840 const int tmp = _syserrno();
841 if (tmp) /* 2nd call to _syserrno() makes it 0 */
842 Perl_rc = tmp;
843 }
844 sv_setnv(sv, (NV)Perl_rc);
845 sv_setpv(sv, os2error(Perl_rc));
846 }
1534c6f5 847 if (SvOK(sv) && strNE(SvPVX(sv), "")) {
99461a73
KW		 848 fixup_errno_string(sv);
849 }
4f4ff3a7 850# elif defined(WIN32)
2a99ff86
KW		 851 {
852 const DWORD dwErr = GetLastError();
853 sv_setnv(sv, (NV)dwErr);
854 if (dwErr) {
855 PerlProc_GetOSError(sv, dwErr);
2efab60d 856 fixup_errno_string(sv);
2a99ff86
KW		 857 }
858 else
859 sv_setpvs(sv, "");
860 SetLastError(dwErr);
861 }
4f4ff3a7
KW		 862# else
863# error Missing code for platform
864# endif
2a99ff86
KW		 865 SvRTRIM(sv);
866 SvNOK_on(sv); /* what a wonderful hack! */
867 break;
4f4ff3a7
KW		 868#endif /* End of platforms with special handling for $^E; others just fall
869 through to $! */
46f3e16c
KW		 870
871 case '!':
872 {
5f1b979d 873 dSAVE_ERRNO;
46f3e16c 874#ifdef VMS
5f1b979d 875 sv_setnv(sv, (NV)((errno == EVMSERR) ? vaxc$errno : errno));
46f3e16c 876#else
5f1b979d 877 sv_setnv(sv, (NV)errno);
46f3e16c
KW		 878#endif
879#ifdef OS2
5f1b979d
KW		 880 if (errno == errno_isOS2 || errno == errno_isOS2_set)
881 sv_setpv(sv, os2error(Perl_rc));
882 else
46f3e16c 883#endif
5f1b979d
KW		 884 if (! errno) {
885 sv_setpvs(sv, "");
46f3e16c 886 }
5f1b979d
KW		 887 else {
888
889 /* Strerror can return NULL on some platforms, which will
890 * result in 'sv' not being considered SvOK. The SvNOK_on()
891 * below will cause just the number part to be valid */
2c6ee1a7 892 sv_setpv(sv, my_strerror(errno));
5f1b979d
KW		 893 if (SvOK(sv)) {
894 fixup_errno_string(sv);
895 }
896 }
897 RESTORE_ERRNO;
46f3e16c
KW		 898 }
899
900 SvRTRIM(sv);
901 SvNOK_on(sv); /* what a wonderful hack! */
902 break;
903
79072805 904 case '\006': /* ^F */
3280af22 905 sv_setiv(sv, (IV)PL_maxsysfd);
79072805 906 break;
9ebf26ad
FR		 907 case '\007': /* ^GLOBAL_PHASE */
908 if (strEQ(remaining, "LOBAL_PHASE")) {
909 sv_setpvn(sv, PL_phase_names[PL_phase],
910 strlen(PL_phase_names[PL_phase]));
911 }
912 break;
a0d0e21e 913 case '\010': /* ^H */
3280af22 914 sv_setiv(sv, (IV)PL_hints);
a0d0e21e 915 break;
9d116dd7 916 case '\011': /* ^I */ /* NOT \t in EBCDIC */
120f7abe 917 sv_setpv(sv, PL_inplace); /* Will undefine sv if PL_inplace is NULL */
79072805 918 break;
8561ea1d
FC		 919 case '\014': /* ^LAST_FH */
920 if (strEQ(remaining, "AST_FH")) {
921 if (PL_last_in_gv) {
922 assert(isGV_with_GP(PL_last_in_gv));
923 SV_CHECK_THINKFIRST_COW_DROP(sv);
924 prepare_SV_for_RV(sv);
925 SvOK_off(sv);
926 SvRV_set(sv, SvREFCNT_inc_simple_NN(PL_last_in_gv));
927 SvROK_on(sv);
928 sv_rvweaken(sv);
929 }
930 else sv_setsv_nomg(sv, NULL);
931 }
932 break;
ac27b0f5 933 case '\017': /* ^O & ^OPEN */
823a54a3 934 if (nextchar == '\0') {
ac27b0f5 935 sv_setpv(sv, PL_osname);
3511154c
DM		 936 SvTAINTED_off(sv);
937 }
823a54a3 938 else if (strEQ(remaining, "PEN")) {
8b850bd5 939 Perl_emulate_cop_io(aTHX_ &PL_compiling, sv);
ac27b0f5 940 }
28f23441 941 break;
9ebf26ad 942 case '\020':
a6d0b1b5 943 sv_setiv(sv, (IV)PL_perldb);
79072805 944 break;
fb73857a 945 case '\023': /* ^S */
a6d0b1b5 946 {
bc177e6b 947 if (PL_parser && PL_parser->lex_state != LEX_NOTPARSING)
0c34ef67 948 SvOK_off(sv);
3280af22 949 else if (PL_in_eval)
6dc8a9e4 950 sv_setiv(sv, PL_in_eval & ~(EVAL_INREQUIRE));
a4268c0a
AMS		 951 else
952 sv_setiv(sv, 0);
d58bf5aa 953 }
fb73857a 954 break;
79072805 955 case '\024': /* ^T */
823a54a3 956 if (nextchar == '\0') {
88e89b8a 957#ifdef BIG_TIME
7c36658b 958 sv_setnv(sv, PL_basetime);
88e89b8a 959#else
7c36658b 960 sv_setiv(sv, (IV)PL_basetime);
88e89b8a 961#endif
7c36658b 962 }
823a54a3 963 else if (strEQ(remaining, "AINT"))
284167a5
S		 964 sv_setiv(sv, TAINTING_get
965 ? (TAINT_WARN_get || PL_unsafe ? -1 : 1)
9aa05f58 966 : 0);
7c36658b 967 break;
e07ea26a 968 case '\025': /* $^UNICODE, $^UTF8LOCALE, $^UTF8CACHE */
823a54a3 969 if (strEQ(remaining, "NICODE"))
a05d7ebb 970 sv_setuv(sv, (UV) PL_unicode);
823a54a3 971 else if (strEQ(remaining, "TF8LOCALE"))
7cebcbc0 972 sv_setuv(sv, (UV) PL_utf8locale);
e07ea26a
NC		 973 else if (strEQ(remaining, "TF8CACHE"))
974 sv_setiv(sv, (IV) PL_utf8cache);
fde18df1
JH		 975 break;
976 case '\027': /* ^W & $^WARNING_BITS */
823a54a3 977 if (nextchar == '\0')
4438c4b7 978 sv_setiv(sv, (IV)((PL_dowarn & G_WARN_ON) ? TRUE : FALSE));
823a54a3 979 else if (strEQ(remaining, "ARNING_BITS")) {
013b78e8 980 if (PL_compiling.cop_warnings == pWARN_NONE) {
4438c4b7 981 sv_setpvn(sv, WARN_NONEstring, WARNsize) ;
013b78e8
RGS		 982 }
983 else if (PL_compiling.cop_warnings == pWARN_STD) {
7e4f0450
FC		 984 sv_setsv(sv, &PL_sv_undef);
985 break;
013b78e8 986 }
d3a7d8c7 987 else if (PL_compiling.cop_warnings == pWARN_ALL) {
75b6c4ca
RGS		 988 /* Get the bit mask for $warnings::Bits{all}, because
989 * it could have been extended by warnings::register */
4bac9ae4
CS		 990 HV * const bits = get_hv("warnings::Bits", 0);
991 SV ** const bits_all = bits ? hv_fetchs(bits, "all", FALSE) : NULL;
992 if (bits_all)
993 sv_copypv(sv, *bits_all);
994 else
995 sv_setpvn(sv, WARN_ALLstring, WARNsize);
ac27b0f5 996 }
4438c4b7 997 else {
72dc9ed5
NC		 998 sv_setpvn(sv, (char *) (PL_compiling.cop_warnings + 1),
999 *PL_compiling.cop_warnings);
ac27b0f5 1000 }
4438c4b7 1001 }
79072805 1002 break;
79072805 1003 case '+':
aaa362c4 1004 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
2c7b5d76
DM		 1005 paren = RX_LASTPAREN(rx);
1006 if (paren)
1007 goto do_numbuf_fetch;
79072805 1008 }
3280af22 1009 sv_setsv(sv,&PL_sv_undef);
79072805 1010 break;
a01268b5
JH		 1011 case '\016': /* ^N */
1012 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
2c7b5d76
DM		 1013 paren = RX_LASTCLOSEPAREN(rx);
1014 if (paren)
1015 goto do_numbuf_fetch;
a01268b5
JH		 1016 }
1017 sv_setsv(sv,&PL_sv_undef);
1018 break;
79072805 1019 case '.':
3280af22 1020 if (GvIO(PL_last_in_gv)) {
357c8808 1021 sv_setiv(sv, (IV)IoLINES(GvIOp(PL_last_in_gv)));
79072805 1022 }
79072805
LW		 1023 break;
1024 case '?':
809a5acc 1025 {
809a5acc 1026 sv_setiv(sv, (IV)STATUS_CURRENT);
ff0cee69 1027#ifdef COMPLEX_STATUS
41cb7b2b 1028 SvUPGRADE(sv, SVt_PVLV);
6b88bc9c
GS		 1029 LvTARGOFF(sv) = PL_statusvalue;
1030 LvTARGLEN(sv) = PL_statusvalue_vms;
ff0cee69 1031#endif
809a5acc 1032 }
79072805
LW		 1033 break;
1034 case '^':
acbe1b9d 1035 if (GvIOp(PL_defoutgv))
099be4f1 1036 s = IoTOP_NAME(GvIOp(PL_defoutgv));
79072805
LW		 1037 if (s)
1038 sv_setpv(sv,s);
1039 else {
3280af22 1040 sv_setpv(sv,GvENAME(PL_defoutgv));
cb421d5e 1041 sv_catpvs(sv,"_TOP");
79072805
LW		 1042 }
1043 break;
1044 case '~':
acbe1b9d 1045 if (GvIOp(PL_defoutgv))
0daa599b 1046 s = IoFMT_NAME(GvIOp(PL_defoutgv));
79072805 1047 if (!s)
3280af22 1048 s = GvENAME(PL_defoutgv);
79072805
LW		 1049 sv_setpv(sv,s);
1050 break;
79072805 1051 case '=':
099be4f1 1052 if (GvIO(PL_defoutgv))
0daa599b 1053 sv_setiv(sv, (IV)IoPAGE_LEN(GvIOp(PL_defoutgv)));
79072805
LW		 1054 break;
1055 case '-':
099be4f1 1056 if (GvIO(PL_defoutgv))
0daa599b 1057 sv_setiv(sv, (IV)IoLINES_LEFT(GvIOp(PL_defoutgv)));
79072805
LW		 1058 break;
1059 case '%':
099be4f1 1060 if (GvIO(PL_defoutgv))
0daa599b 1061 sv_setiv(sv, (IV)IoPAGE(GvIOp(PL_defoutgv)));
79072805 1062 break;
79072805
LW		 1063 case ':':
1064 break;
1065 case '/':
1066 break;
1067 case '[':
e1dccc0d 1068 sv_setiv(sv, 0);
79072805
LW		 1069 break;
1070 case '|':
099be4f1 1071 if (GvIO(PL_defoutgv))
0daa599b 1072 sv_setiv(sv, (IV)(IoFLAGS(GvIOp(PL_defoutgv)) & IOf_FLUSH) != 0 );
79072805 1073 break;
79072805 1074 case '\\':
b2ce0fda 1075 if (PL_ors_sv)
f28098ff 1076 sv_copypv(sv, PL_ors_sv);
4bac9ae4
CS		 1077 else
1078 sv_setsv(sv, &PL_sv_undef);
79072805 1079 break;
0e219455 1080 case '$': /* $$ */
9cdac2a2
FC		 1081 {
1082 IV const pid = (IV)PerlProc_getpid();
19db9fb7 1083 if (isGV(mg->mg_obj) || SvIV(mg->mg_obj) != pid) {
9cdac2a2
FC		 1084 /* never set manually, or at least not since last fork */
1085 sv_setiv(sv, pid);
19db9fb7
Z		 1086 /* never unsafe, even if reading in a tainted expression */
1087 SvTAINTED_off(sv);
1088 }
9cdac2a2
FC		 1089 /* else a value has been assigned manually, so do nothing */
1090 }
0e219455 1091 break;
79072805 1092 case '<':
dfff4baf 1093 sv_setuid(sv, PerlProc_getuid());
79072805
LW		 1094 break;
1095 case '>':
dfff4baf 1096 sv_setuid(sv, PerlProc_geteuid());
79072805
LW		 1097 break;
1098 case '(':
dfff4baf 1099 sv_setgid(sv, PerlProc_getgid());
79072805
LW		 1100 goto add_groups;
1101 case ')':
dfff4baf 1102 sv_setgid(sv, PerlProc_getegid());
79072805 1103 add_groups:
79072805 1104#ifdef HAS_GETGROUPS
79072805 1105 {
57d7c65e 1106 Groups_t *gary = NULL;
375ed12a
JH		 1107 I32 i;
1108 I32 num_groups = getgroups(0, gary);
1109 if (num_groups > 0) {
1110 Newx(gary, num_groups, Groups_t);
1111 num_groups = getgroups(num_groups, gary);
1112 for (i = 0; i < num_groups; i++)
1113 Perl_sv_catpvf(aTHX_ sv, " %"IVdf, (IV)gary[i]);
1114 Safefree(gary);
1115 }
79072805 1116 }
155aba94 1117 (void)SvIOK_on(sv); /* what a wonderful hack! */
cd70abae 1118#endif
79072805 1119 break;
79072805
LW		 1120 case '0':
1121 break;
1122 }
a0d0e21e 1123 return 0;
79072805
LW		 1124}
1125
1126int
864dbfa3 1127Perl_magic_getuvar(pTHX_ SV *sv, MAGIC *mg)
79072805 1128{
8772537c 1129 struct ufuncs * const uf = (struct ufuncs *)mg->mg_ptr;
79072805 1130
7918f24d
NC		 1131 PERL_ARGS_ASSERT_MAGIC_GETUVAR;
1132
79072805 1133 if (uf && uf->uf_val)
24f81a43 1134 (*uf->uf_val)(aTHX_ uf->uf_index, sv);
79072805
LW		 1135 return 0;
1136}
1137
1138int
864dbfa3 1139Perl_magic_setenv(pTHX_ SV *sv, MAGIC *mg)
79072805 1140{
9ae3433d 1141 STRLEN len = 0, klen;
12033064 1142 const char * const key = MgPV_const(mg,klen);
888a67f6 1143 const char *s = "";
1e422769 1144
7918f24d
NC		 1145 PERL_ARGS_ASSERT_MAGIC_SETENV;
1146
613c63b4 1147 SvGETMAGIC(sv);
12033064 1148 if (SvOK(sv)) {
613c63b4
CS		 1149 /* defined environment variables are byte strings; unfortunately
1150 there is no SvPVbyte_force_nomg(), so we must do this piecewise */
1151 (void)SvPV_force_nomg_nolen(sv);
1152 sv_utf8_downgrade(sv, /* fail_ok */ TRUE);
1153 if (SvUTF8(sv)) {
1154 Perl_ck_warner_d(aTHX_ packWARN(WARN_UTF8), "Wide character in %s", "setenv");
1155 SvUTF8_off(sv);
1156 }
1157 s = SvPVX(sv);
1158 len = SvCUR(sv);
12033064
CS		 1159 }
1160 my_setenv(key, s); /* does the deed */
1161
a0d0e21e
LW		 1162#ifdef DYNAMIC_ENV_FETCH
1163 /* We just undefd an environment var. Is a replacement */
1164 /* waiting in the wings? */
1165 if (!len) {
6bd66ee9 1166 SV ** const valp = hv_fetch(GvHVn(PL_envgv), key, klen, FALSE);
fabdb6c0 1167 if (valp)
4ab59fcc 1168 s = SvOK(*valp) ? SvPV_const(*valp, len) : "";
a0d0e21e
LW		 1169 }
1170#endif
1e422769 1171
39e571d4 1172#if !defined(OS2) && !defined(AMIGAOS) && !defined(WIN32) && !defined(MSDOS)
79072805
LW		 1173 /* And you'll never guess what the dog had */
1174 /* in its mouth... */
284167a5 1175 if (TAINTING_get) {
1e422769 1176 MgTAINTEDDIR_off(mg);
1177#ifdef VMS
6bd66ee9 1178 if (s && klen == 8 && strEQ(key, "DCL$PATH")) {
b8ffc8df 1179 char pathbuf[256], eltbuf[256], *cp, *elt;
1e422769 1180 int i = 0, j = 0;
1181
6fca0082 1182 my_strlcpy(eltbuf, s, sizeof(eltbuf));
b8ffc8df 1183 elt = eltbuf;
1e422769 1184 do { /* DCL$PATH may be a search list */
1185 while (1) { /* as may dev portion of any element */
1186 if ( ((cp = strchr(elt,'[')) || (cp = strchr(elt,'<'))) ) {
1187 if ( *(cp+1) == '.' || *(cp+1) == '-' ||
1188 cando_by_name(S_IWUSR,0,elt) ) {
1189 MgTAINTEDDIR_on(mg);
1190 return 0;
1191 }
1192 }
bd61b366 1193 if ((cp = strchr(elt, ':')) != NULL)
1e422769 1194 *cp = '\0';
1195 if (my_trnlnm(elt, eltbuf, j++))
1196 elt = eltbuf;
1197 else
1198 break;
1199 }
1200 j = 0;
1201 } while (my_trnlnm(s, pathbuf, i++) && (elt = pathbuf));
1202 }
1203#endif /* VMS */
12033064 1204 if (s && klen == 4 && strEQ(key,"PATH")) {
8772537c 1205 const char * const strend = s + len;
463ee0b2
LW		 1206
1207 while (s < strend) {
96827780 1208 char tmpbuf[256];
c623ac67 1209 Stat_t st;
5f74f29c 1210 I32 i;
f5a63d97
AL		 1211#ifdef VMS /* Hmm. How do we get $Config{path_sep} from C? */
1212 const char path_sep = '|';
1213#else
1214 const char path_sep = ':';
1215#endif
96827780 1216 s = delimcpy(tmpbuf, tmpbuf + sizeof tmpbuf,
427eaa01 1217 s, strend, path_sep, &i);
463ee0b2 1218 s++;
bb7a0f54 1219 if (i >= (I32)sizeof tmpbuf /* too long -- assume the worst */
326b5008
CB		 1220#ifdef VMS
1221 || !strchr(tmpbuf, ':') /* no colon thus no device name -- assume relative path */
1222#else
1223 || *tmpbuf != '/' /* no starting slash -- assume relative path */
1224#endif
c6ed36e1 1225 || (PerlLIO_stat(tmpbuf, &st) == 0 && (st.st_mode & 2)) ) {
8990e307 1226 MgTAINTEDDIR_on(mg);
1e422769 1227 return 0;
1228 }
463ee0b2 1229 }
79072805
LW		 1230 }
1231 }
39e571d4 1232#endif /* neither OS2 nor AMIGAOS nor WIN32 nor MSDOS */
1e422769 1233
79072805
LW		 1234 return 0;
1235}
1236
1237int
864dbfa3 1238Perl_magic_clearenv(pTHX_ SV *sv, MAGIC *mg)
85e6fe83 1239{
7918f24d 1240 PERL_ARGS_ASSERT_MAGIC_CLEARENV;
8772537c 1241 PERL_UNUSED_ARG(sv);
bd61b366 1242 my_setenv(MgPV_nolen_const(mg),NULL);
85e6fe83
LW		 1243 return 0;
1244}
1245
88e89b8a 1246int
864dbfa3 1247Perl_magic_set_all_env(pTHX_ SV *sv, MAGIC *mg)
fb73857a 1248{
7918f24d 1249 PERL_ARGS_ASSERT_MAGIC_SET_ALL_ENV;
65e66c80 1250 PERL_UNUSED_ARG(mg);
b0269e46 1251#if defined(VMS)
cea2e8a9 1252 Perl_die(aTHX_ "Can't make list assignment to %%ENV on this system");
fb73857a 1253#else
3280af22 1254 if (PL_localizing) {
fb73857a 1255 HE* entry;
b0269e46 1256 my_clearenv();
85fbaab2
NC		 1257 hv_iterinit(MUTABLE_HV(sv));
1258 while ((entry = hv_iternext(MUTABLE_HV(sv)))) {
fb73857a 1259 I32 keylen;
1260 my_setenv(hv_iterkey(entry, &keylen),
85fbaab2 1261 SvPV_nolen_const(hv_iterval(MUTABLE_HV(sv), entry)));
fb73857a 1262 }
1263 }
1264#endif
1265 return 0;
1266}
1267
1268int
864dbfa3 1269Perl_magic_clear_all_env(pTHX_ SV *sv, MAGIC *mg)
66b1d557 1270{
7918f24d 1271 PERL_ARGS_ASSERT_MAGIC_CLEAR_ALL_ENV;
8772537c
AL		 1272 PERL_UNUSED_ARG(sv);
1273 PERL_UNUSED_ARG(mg);
b0269e46
AB		 1274#if defined(VMS)
1275 Perl_die(aTHX_ "Can't make list assignment to %%ENV on this system");
1276#else
1277 my_clearenv();
1278#endif
3e3baf6d 1279 return 0;
66b1d557
HM		 1280}
1281
64ca3a65 1282#ifndef PERL_MICRO
2d4fcd5e
AJ		 1283#ifdef HAS_SIGPROCMASK
1284static void
1285restore_sigmask(pTHX_ SV *save_sv)
1286{
0bd48802 1287 const sigset_t * const ossetp = (const sigset_t *) SvPV_nolen_const( save_sv );
f5a63d97 1288 (void)sigprocmask(SIG_SETMASK, ossetp, NULL);
2d4fcd5e
AJ		 1289}
1290#endif
66b1d557 1291int
864dbfa3 1292Perl_magic_getsig(pTHX_ SV *sv, MAGIC *mg)
88e89b8a 1293{
88e89b8a 1294 /* Are we fetching a signal entry? */
708854f2 1295 int i = (I16)mg->mg_private;
7918f24d
NC		 1296
1297 PERL_ARGS_ASSERT_MAGIC_GETSIG;
1298
708854f2 1299 if (!i) {
84c7b88c
BF		 1300 STRLEN siglen;
1301 const char * sig = MgPV_const(mg, siglen);
1302 mg->mg_private = i = whichsig_pvn(sig, siglen);
708854f2
NC		 1303 }
1304
e02bfb16 1305 if (i > 0) {
22c35a8c
GS		 1306 if(PL_psig_ptr[i])
1307 sv_setsv(sv,PL_psig_ptr[i]);
88e89b8a 1308 else {
46da273f 1309 Sighandler_t sigstate = rsignal_state(i);
23ada85b 1310#ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
46da273f
AL		 1311 if (PL_sig_handlers_initted && PL_sig_ignoring[i])
1312 sigstate = SIG_IGN;
2e34cc90
CL		 1313#endif
1314#ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
46da273f
AL		 1315 if (PL_sig_handlers_initted && PL_sig_defaulting[i])
1316 sigstate = SIG_DFL;
85b332e2 1317#endif
88e89b8a 1318 /* cache state so we don't fetch it again */
8aad04aa 1319 if(sigstate == (Sighandler_t) SIG_IGN)
6502358f 1320 sv_setpvs(sv,"IGNORE");
88e89b8a 1321 else
3280af22 1322 sv_setsv(sv,&PL_sv_undef);
46da273f 1323 PL_psig_ptr[i] = SvREFCNT_inc_simple_NN(sv);
88e89b8a 1324 SvTEMP_off(sv);
1325 }
1326 }
1327 return 0;
1328}
1329int
864dbfa3 1330Perl_magic_clearsig(pTHX_ SV *sv, MAGIC *mg)
88e89b8a 1331{
7918f24d 1332 PERL_ARGS_ASSERT_MAGIC_CLEARSIG;
179c85a2 1333
38a124f0 1334 magic_setsig(NULL, mg);
179c85a2 1335 return sv_unmagic(sv, mg->mg_type);
88e89b8a 1336}
3d37d572 1337
0a8e0eff 1338Signal_t
8aad04aa 1339#if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
b6455c53 1340Perl_csighandler(int sig, siginfo_t *sip PERL_UNUSED_DECL, void *uap PERL_UNUSED_DECL)
8aad04aa 1341#else
0a8e0eff 1342Perl_csighandler(int sig)
8aad04aa 1343#endif
0a8e0eff 1344{
1018e26f
NIS		 1345#ifdef PERL_GET_SIG_CONTEXT
1346 dTHXa(PERL_GET_SIG_CONTEXT);
1347#else
85b332e2
CL		 1348 dTHX;
1349#endif
ffb6256b
JH		 1350#if defined(__cplusplus) && defined(__GNUC__)
1351 /* g++ doesn't support PERL_UNUSED_DECL, so the sip and uap
1352 * parameters would be warned about. */
1353 PERL_UNUSED_ARG(sip);
1354 PERL_UNUSED_ARG(uap);
1355#endif
23ada85b 1356#ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
5c1546dc 1357 (void) rsignal(sig, PL_csighandlerp);
27da23d5 1358 if (PL_sig_ignoring[sig]) return;
85b332e2 1359#endif
2e34cc90 1360#ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
27da23d5 1361 if (PL_sig_defaulting[sig])
2e34cc90
CL		 1362#ifdef KILL_BY_SIGPRC
1363 exit((Perl_sig_to_vmscondition(sig)&STS$M_COND_ID)|STS$K_SEVERE|STS$M_INHIB_MSG);
1364#else
1365 exit(1);
1366#endif
1367#endif
406878dd 1368 if (
853d2c32
RGS		 1369#ifdef SIGILL
1370 sig == SIGILL ||
1371#endif
1372#ifdef SIGBUS
1373 sig == SIGBUS ||
1374#endif
1375#ifdef SIGSEGV
1376 sig == SIGSEGV ||
1377#endif
1378 (PL_signals & PERL_SIGNALS_UNSAFE_FLAG))
4ffa73a3 1379 /* Call the perl level handler now--
31c91b43 1380 * with risk we may be in malloc() or being destructed etc. */
6e324d09 1381#if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
80626cf1 1382 (*PL_sighandlerp)(sig, NULL, NULL);
6e324d09
CB		 1383#else
1384 (*PL_sighandlerp)(sig);
92807b6d 1385#endif
406878dd 1386 else {
31c91b43 1387 if (!PL_psig_pend) return;
406878dd
GA		 1388 /* Set a flag to say this signal is pending, that is awaiting delivery after
1389 * the current Perl opcode completes */
1390 PL_psig_pend[sig]++;
1391
1392#ifndef SIG_PENDING_DIE_COUNT
1393# define SIG_PENDING_DIE_COUNT 120
1394#endif
fe13d51d 1395 /* Add one to say _a_ signal is pending */
406878dd
GA		 1396 if (++PL_sig_pending >= SIG_PENDING_DIE_COUNT)
1397 Perl_croak(aTHX_ "Maximal count of pending signals (%lu) exceeded",
1398 (unsigned long)SIG_PENDING_DIE_COUNT);
1399 }
0a8e0eff
NIS		 1400}
1401
2e34cc90
CL		 1402#if defined(FAKE_PERSISTENT_SIGNAL_HANDLERS) || defined(FAKE_DEFAULT_SIGNAL_HANDLERS)
1403void
1404Perl_csighandler_init(void)
1405{
1406 int sig;
27da23d5 1407 if (PL_sig_handlers_initted) return;
2e34cc90
CL		 1408
1409 for (sig = 1; sig < SIG_SIZE; sig++) {
1410#ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
218fdd94 1411 dTHX;
27da23d5 1412 PL_sig_defaulting[sig] = 1;
5c1546dc 1413 (void) rsignal(sig, PL_csighandlerp);
2e34cc90
CL		 1414#endif
1415#ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
27da23d5 1416 PL_sig_ignoring[sig] = 0;
2e34cc90
CL		 1417#endif
1418 }
27da23d5 1419 PL_sig_handlers_initted = 1;
2e34cc90
CL		 1420}
1421#endif
1422
7fe50b8b
LT		 1423#if defined HAS_SIGPROCMASK
1424static void
1425unblock_sigmask(pTHX_ void* newset)
1426{
dc3bf405 1427 PERL_UNUSED_CONTEXT;
7fe50b8b
LT		 1428 sigprocmask(SIG_UNBLOCK, (sigset_t*)newset, NULL);
1429}
1430#endif
1431
0a8e0eff
NIS		 1432void
1433Perl_despatch_signals(pTHX)
1434{
1435 int sig;
1436 PL_sig_pending = 0;
1437 for (sig = 1; sig < SIG_SIZE; sig++) {
1438 if (PL_psig_pend[sig]) {
d0166017 1439 dSAVE_ERRNO;
7fe50b8b 1440#ifdef HAS_SIGPROCMASK
55534442
LT		 1441 /* From sigaction(2) (FreeBSD man page):
1442 * | Signal routines normally execute with the signal that
1443 * | caused their invocation blocked, but other signals may
1444 * | yet occur.
1445 * Emulation of this behavior (from within Perl) is enabled
1446 * using sigprocmask
1447 */
1448 int was_blocked;
1449 sigset_t newset, oldset;
1450
1451 sigemptyset(&newset);
1452 sigaddset(&newset, sig);
1453 sigprocmask(SIG_BLOCK, &newset, &oldset);
1454 was_blocked = sigismember(&oldset, sig);
7fe50b8b
LT		 1455 if (!was_blocked) {
1456 SV* save_sv = newSVpvn((char *)(&newset), sizeof(sigset_t));
1457 ENTER;
1458 SAVEFREESV(save_sv);
1459 SAVEDESTRUCTOR_X(unblock_sigmask, SvPV_nolen(save_sv));
1460 }
55534442 1461#endif
25da4428 1462 PL_psig_pend[sig] = 0;
6e324d09 1463#if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
80626cf1 1464 (*PL_sighandlerp)(sig, NULL, NULL);
6e324d09
CB		 1465#else
1466 (*PL_sighandlerp)(sig);
92807b6d 1467#endif
7fe50b8b 1468#ifdef HAS_SIGPROCMASK
55534442 1469 if (!was_blocked)
7fe50b8b 1470 LEAVE;
55534442 1471#endif
d0166017 1472 RESTORE_ERRNO;
0a8e0eff
NIS		 1473 }
1474 }
1475}
1476
38a124f0 1477/* sv of NULL signifies that we're acting as magic_clearsig. */
85e6fe83 1478int
864dbfa3 1479Perl_magic_setsig(pTHX_ SV *sv, MAGIC *mg)
79072805 1480{
27da23d5 1481 dVAR;
79072805 1482 I32 i;
cbbf8932 1483 SV** svp = NULL;
2d4fcd5e
AJ		 1484 /* Need to be careful with SvREFCNT_dec(), because that can have side
1485 * effects (due to closures). We must make sure that the new disposition
1486 * is in place before it is called.
1487 */
cbbf8932 1488 SV* to_dec = NULL;
e72dc28c 1489 STRLEN len;
2d4fcd5e
AJ		 1490#ifdef HAS_SIGPROCMASK
1491 sigset_t set, save;
1492 SV* save_sv;
1493#endif
eb578fdb 1494 const char *s = MgPV_const(mg,len);
7918f24d
NC		 1495
1496 PERL_ARGS_ASSERT_MAGIC_SETSIG;
1497
748a9306 1498 if (*s == '_') {
84c7b88c 1499 if (memEQs(s, len, "__DIE__"))
3280af22 1500 svp = &PL_diehook;
84c7b88c 1501 else if (memEQs(s, len, "__WARN__")
38a124f0
NC		 1502 && (sv ? 1 : PL_warnhook != PERL_WARNHOOK_FATAL)) {
1503 /* Merge the existing behaviours, which are as follows:
1504 magic_setsig, we always set svp to &PL_warnhook
1505 (hence we always change the warnings handler)
1506 For magic_clearsig, we don't change the warnings handler if it's
1507 set to the &PL_warnhook. */
3280af22 1508 svp = &PL_warnhook;
84c7b88c
BF		 1509 } else if (sv) {
1510 SV *tmp = sv_newmortal();
1511 Perl_croak(aTHX_ "No such hook: %s",
1512 pv_pretty(tmp, s, len, 0, NULL, NULL, 0));
1513 }
748a9306 1514 i = 0;
38a124f0 1515 if (svp && *svp) {
9289f461
RGS		 1516 if (*svp != PERL_WARNHOOK_FATAL)
1517 to_dec = *svp;
cbbf8932 1518 *svp = NULL;
4633a7c4 1519 }
748a9306
LW		 1520 }
1521 else {
708854f2
NC		 1522 i = (I16)mg->mg_private;
1523 if (!i) {
84c7b88c 1524 i = whichsig_pvn(s, len); /* ...no, a brick */
58a26b12 1525 mg->mg_private = (U16)i;
708854f2 1526 }
86d86cad 1527 if (i <= 0) {
84c7b88c
BF		 1528 if (sv) {
1529 SV *tmp = sv_newmortal();
1530 Perl_ck_warner(aTHX_ packWARN(WARN_SIGNAL), "No such signal: SIG%s",
1531 pv_pretty(tmp, s, len, 0, NULL, NULL, 0));
1532 }
748a9306
LW		 1533 return 0;
1534 }
2d4fcd5e
AJ		 1535#ifdef HAS_SIGPROCMASK
1536 /* Avoid having the signal arrive at a bad time, if possible. */
1537 sigemptyset(&set);
1538 sigaddset(&set,i);
1539 sigprocmask(SIG_BLOCK, &set, &save);
1540 ENTER;
9ff8e806 1541 save_sv = newSVpvn((char *)(&save), sizeof(sigset_t));
2d4fcd5e
AJ		 1542 SAVEFREESV(save_sv);
1543 SAVEDESTRUCTOR_X(restore_sigmask, save_sv);
1544#endif
1545 PERL_ASYNC_CHECK();
2e34cc90 1546#if defined(FAKE_PERSISTENT_SIGNAL_HANDLERS) || defined(FAKE_DEFAULT_SIGNAL_HANDLERS)
27da23d5 1547 if (!PL_sig_handlers_initted) Perl_csighandler_init();
2e34cc90 1548#endif
23ada85b 1549#ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
27da23d5 1550 PL_sig_ignoring[i] = 0;
85b332e2 1551#endif
2e34cc90 1552#ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
27da23d5 1553 PL_sig_defaulting[i] = 0;
2e34cc90 1554#endif
2d4fcd5e 1555 to_dec = PL_psig_ptr[i];
38a124f0
NC		 1556 if (sv) {
1557 PL_psig_ptr[i] = SvREFCNT_inc_simple_NN(sv);
1558 SvTEMP_off(sv); /* Make sure it doesn't go away on us */
79fd3822
NC		 1559
1560 /* Signals don't change name during the program's execution, so once
1561 they're cached in the appropriate slot of PL_psig_name, they can
1562 stay there.
1563
1564 Ideally we'd find some way of making SVs at (C) compile time, or
1565 at least, doing most of the work. */
1566 if (!PL_psig_name[i]) {
1567 PL_psig_name[i] = newSVpvn(s, len);
1568 SvREADONLY_on(PL_psig_name[i]);
1569 }
38a124f0 1570 } else {
79fd3822 1571 SvREFCNT_dec(PL_psig_name[i]);
38a124f0
NC		 1572 PL_psig_name[i] = NULL;
1573 PL_psig_ptr[i] = NULL;
1574 }
748a9306 1575 }
38a124f0 1576 if (sv && (isGV_with_GP(sv) || SvROK(sv))) {
2d4fcd5e 1577 if (i) {
5c1546dc 1578 (void)rsignal(i, PL_csighandlerp);
2d4fcd5e 1579 }
748a9306 1580 else
b37c2d43 1581 *svp = SvREFCNT_inc_simple_NN(sv);
38a124f0 1582 } else {
9dfa190b
NC		 1583 if (sv && SvOK(sv)) {
1584 s = SvPV_force(sv, len);
1585 } else {
1586 sv = NULL;
1587 }
84c7b88c 1588 if (sv && memEQs(s, len,"IGNORE")) {
9dfa190b 1589 if (i) {
23ada85b 1590#ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
9dfa190b
NC		 1591 PL_sig_ignoring[i] = 1;
1592 (void)rsignal(i, PL_csighandlerp);
85b332e2 1593#else
9dfa190b 1594 (void)rsignal(i, (Sighandler_t) SIG_IGN);
85b332e2 1595#endif
9dfa190b 1596 }
2d4fcd5e 1597 }
84c7b88c 1598 else if (!sv || memEQs(s, len,"DEFAULT") || !len) {
9dfa190b 1599 if (i) {
2e34cc90 1600#ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
9dfa190b
NC		 1601 PL_sig_defaulting[i] = 1;
1602 (void)rsignal(i, PL_csighandlerp);
2e34cc90 1603#else
9dfa190b 1604 (void)rsignal(i, (Sighandler_t) SIG_DFL);
2e34cc90 1605#endif
9dfa190b
NC		 1606 }
1607 }
1608 else {
1609 /*
1610 * We should warn if HINT_STRICT_REFS, but without
1611 * access to a known hint bit in a known OP, we can't
1612 * tell whether HINT_STRICT_REFS is in force or not.
1613 */
1614 if (!strchr(s,':') && !strchr(s,'\''))
1615 Perl_sv_insert_flags(aTHX_ sv, 0, 0, STR_WITH_LEN("main::"),
1616 SV_GMAGIC);
1617 if (i)
1618 (void)rsignal(i, PL_csighandlerp);
1619 else
1620 *svp = SvREFCNT_inc_simple_NN(sv);
136e0459 1621 }
748a9306 1622 }
9dfa190b 1623
2d4fcd5e
AJ		 1624#ifdef HAS_SIGPROCMASK
1625 if(i)
1626 LEAVE;
1627#endif
ef8d46e8 1628 SvREFCNT_dec(to_dec);
79072805
LW		 1629 return 0;
1630}
64ca3a65 1631#endif /* !PERL_MICRO */
79072805
LW		 1632
1633int
864dbfa3 1634Perl_magic_setisa(pTHX_ SV *sv, MAGIC *mg)
79072805 1635{
7918f24d 1636 PERL_ARGS_ASSERT_MAGIC_SETISA;
8772537c 1637 PERL_UNUSED_ARG(sv);
e1a479c5 1638
89c14e2e 1639 /* Skip _isaelem because _isa will handle it shortly */
354b0578 1640 if (PL_delaymagic & DM_ARRAY_ISA && mg->mg_type == PERL_MAGIC_isaelem)
89c14e2e
BB		 1641 return 0;
1642
0e446081 1643 return magic_clearisa(NULL, mg);
463ee0b2
LW		 1644}
1645
0e446081 1646/* sv of NULL signifies that we're acting as magic_setisa. */
463ee0b2 1647int
52b45067
RD		 1648Perl_magic_clearisa(pTHX_ SV *sv, MAGIC *mg)
1649{
52b45067 1650 HV* stash;
7918f24d
NC		 1651 PERL_ARGS_ASSERT_MAGIC_CLEARISA;
1652
52b45067 1653 /* Bail out if destruction is going on */
627364f1 1654 if(PL_phase == PERL_PHASE_DESTRUCT) return 0;
52b45067 1655
0e446081
NC		 1656 if (sv)
1657 av_clear(MUTABLE_AV(sv));
52b45067 1658
6624142a
FC		 1659 if (SvTYPE(mg->mg_obj) != SVt_PVGV && SvSMAGICAL(mg->mg_obj))
1660 /* This occurs with setisa_elem magic, which calls this
1661 same function. */
1662 mg = mg_find(mg->mg_obj, PERL_MAGIC_isa);
1663
316ebaf2 1664 assert(mg);
6624142a
FC		 1665 if (SvTYPE(mg->mg_obj) == SVt_PVAV) { /* multiple stashes */
1666 SV **svp = AvARRAY((AV *)mg->mg_obj);
1667 I32 items = AvFILLp((AV *)mg->mg_obj) + 1;
1668 while (items--) {
1669 stash = GvSTASH((GV *)*svp++);
1670 if (stash && HvENAME(stash)) mro_isa_changed_in(stash);
1671 }
1672
1673 return 0;
1674 }
1675
52b45067 1676 stash = GvSTASH(
6624142a 1677 (const GV *)mg->mg_obj
52b45067
RD		 1678 );
1679
00169e2c
FC		 1680 /* The stash may have been detached from the symbol table, so check its
1681 name before doing anything. */
1682 if (stash && HvENAME_get(stash))
5562fa71 1683 mro_isa_changed_in(stash);
52b45067
RD		 1684
1685 return 0;
1686}
1687
1688int
864dbfa3 1689Perl_magic_getnkeys(pTHX_ SV *sv, MAGIC *mg)
6ff81951 1690{
85fbaab2 1691 HV * const hv = MUTABLE_HV(LvTARG(sv));
6ff81951 1692 I32 i = 0;
7918f24d
NC		 1693
1694 PERL_ARGS_ASSERT_MAGIC_GETNKEYS;
8772537c 1695 PERL_UNUSED_ARG(mg);
7719e241 1696
6ff81951 1697 if (hv) {
497b47a8 1698 (void) hv_iterinit(hv);
ad64d0ec 1699 if (! SvTIED_mg((const SV *)hv, PERL_MAGIC_tied))
1b95d04f 1700 i = HvUSEDKEYS(hv);
497b47a8
JH		 1701 else {
1702 while (hv_iternext(hv))
1703 i++;
1704 }
6ff81951
GS		 1705 }
1706
1707 sv_setiv(sv, (IV)i);
1708 return 0;
1709}
1710
1711int
864dbfa3 1712Perl_magic_setnkeys(pTHX_ SV *sv, MAGIC *mg)
946ec16e 1713{
7918f24d 1714 PERL_ARGS_ASSERT_MAGIC_SETNKEYS;
8772537c 1715 PERL_UNUSED_ARG(mg);
946ec16e 1716 if (LvTARG(sv)) {
85fbaab2 1717 hv_ksplit(MUTABLE_HV(LvTARG(sv)), SvIV(sv));
946ec16e 1718 }
1719 return 0;
ac27b0f5 1720}
946ec16e 1721
efaf3674
DM		 1722/*
1723=for apidoc magic_methcall
1724
1725Invoke a magic method (like FETCH).
1726
2baee27b
FC		 1727C<sv> and C<mg> are the tied thingy and the tie magic.
1728
1729C<meth> is the name of the method to call.
1730
1731C<argc> is the number of args (in addition to $self) to pass to the method.
1732
1733The C<flags> can be:
1734
1735 G_DISCARD invoke method with G_DISCARD flag and don't
1736 return a value
1737 G_UNDEF_FILL fill the stack with argc pointers to
1738 PL_sv_undef
1739
1740The arguments themselves are any values following the C<flags> argument.
efaf3674
DM		 1741
1742Returns the SV (if any) returned by the method, or NULL on failure.
1743
1744
1745=cut
1746*/
1747
1748SV*
36925d9e 1749Perl_magic_methcall(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags,
046b0c7d 1750 U32 argc, ...)
a0d0e21e
LW		 1751{
1752 dSP;
efaf3674 1753 SV* ret = NULL;
463ee0b2 1754
7918f24d
NC		 1755 PERL_ARGS_ASSERT_MAGIC_METHCALL;
1756
efaf3674 1757 ENTER;
d1d7a15d
NC		 1758
1759 if (flags & G_WRITING_TO_STDERR) {
1760 SAVETMPS;
1761
1762 save_re_context();
1763 SAVESPTR(PL_stderrgv);
1764 PL_stderrgv = NULL;
1765 }
1766
efaf3674 1767 PUSHSTACKi(PERLSI_MAGIC);
924508f0 1768 PUSHMARK(SP);
efaf3674 1769
67549bd2
NC		 1770 EXTEND(SP, argc+1);
1771 PUSHs(SvTIED_obj(sv, mg));
1772 if (flags & G_UNDEF_FILL) {
1773 while (argc--) {
efaf3674 1774 PUSHs(&PL_sv_undef);
93965878 1775 }
67549bd2 1776 } else if (argc > 0) {
046b0c7d
NC		 1777 va_list args;
1778 va_start(args, argc);
1779
1780 do {
1781 SV *const sv = va_arg(args, SV *);
1782 PUSHs(sv);
1783 } while (--argc);
1784
1785 va_end(args);
88e89b8a 1786 }
463ee0b2 1787 PUTBACK;
efaf3674 1788 if (flags & G_DISCARD) {
36925d9e 1789 call_sv(meth, G_SCALAR|G_DISCARD|G_METHOD_NAMED);
efaf3674
DM		 1790 }
1791 else {
36925d9e 1792 if (call_sv(meth, G_SCALAR|G_METHOD_NAMED))
efaf3674
DM		 1793 ret = *PL_stack_sp--;
1794 }
1795 POPSTACK;
d1d7a15d
NC		 1796 if (flags & G_WRITING_TO_STDERR)
1797 FREETMPS;
efaf3674
DM		 1798 LEAVE;
1799 return ret;
1800}
1801
efaf3674 1802/* wrapper for magic_methcall that creates the first arg */
463ee0b2 1803
efaf3674 1804STATIC SV*
36925d9e 1805S_magic_methcall1(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags,
efaf3674
DM		 1806 int n, SV *val)
1807{
efaf3674
DM		 1808 SV* arg1 = NULL;
1809
1810 PERL_ARGS_ASSERT_MAGIC_METHCALL1;
1811
1812 if (mg->mg_ptr) {
1813 if (mg->mg_len >= 0) {
db4b3a1d 1814 arg1 = newSVpvn_flags(mg->mg_ptr, mg->mg_len, SVs_TEMP);
efaf3674
DM		 1815 }
1816 else if (mg->mg_len == HEf_SVKEY)
1817 arg1 = MUTABLE_SV(mg->mg_ptr);
1818 }
1819 else if (mg->mg_type == PERL_MAGIC_tiedelem) {
db4b3a1d 1820 arg1 = newSViv((IV)(mg->mg_len));
efaf3674
DM		 1821 sv_2mortal(arg1);
1822 }
1823 if (!arg1) {
046b0c7d 1824 return Perl_magic_methcall(aTHX_ sv, mg, meth, flags, n - 1, val);
efaf3674 1825 }
046b0c7d 1826 return Perl_magic_methcall(aTHX_ sv, mg, meth, flags, n, arg1, val);
946ec16e 1827}
1828
76e3520e 1829STATIC int
36925d9e 1830S_magic_methpack(pTHX_ SV *sv, const MAGIC *mg, SV *meth)
a0d0e21e 1831{
efaf3674 1832 SV* ret;
463ee0b2 1833
7918f24d
NC		 1834 PERL_ARGS_ASSERT_MAGIC_METHPACK;
1835
efaf3674
DM		 1836 ret = magic_methcall1(sv, mg, meth, 0, 1, NULL);
1837 if (ret)
1838 sv_setsv(sv, ret);
a0d0e21e
LW		 1839 return 0;
1840}
463ee0b2 1841
a0d0e21e 1842int
864dbfa3 1843Perl_magic_getpack(pTHX_ SV *sv, MAGIC *mg)
a0d0e21e 1844{
7918f24d
NC		 1845 PERL_ARGS_ASSERT_MAGIC_GETPACK;
1846
fd69380d 1847 if (mg->mg_type == PERL_MAGIC_tiedelem)
a0d0e21e 1848 mg->mg_flags |= MGf_GSKIP;
36925d9e 1849 magic_methpack(sv,mg,SV_CONST(FETCH));
463ee0b2
LW		 1850 return 0;
1851}
1852
1853int
864dbfa3 1854Perl_magic_setpack(pTHX_ SV *sv, MAGIC *mg)
e336de0d 1855{
b112cff9
DM		 1856 MAGIC *tmg;
1857 SV *val;
7918f24d
NC		 1858
1859 PERL_ARGS_ASSERT_MAGIC_SETPACK;
1860
b112cff9
DM		 1861 /* in the code C<$tied{foo} = $val>, the "thing" that gets passed to
1862 * STORE() is not $val, but rather a PVLV (the sv in this call), whose
1863 * public flags indicate its value based on copying from $val. Doing
1864 * mg_set() on the PVLV temporarily does SvMAGICAL_off(), then calls us.
1865 * So STORE()'s $_[2] arg is a temporarily disarmed PVLV. This goes
1866 * wrong if $val happened to be tainted, as sv hasn't got magic
1867 * enabled, even though taint magic is in the chain. In which case,
1868 * fake up a temporary tainted value (this is easier than temporarily
1869 * re-enabling magic on sv). */
1870
284167a5 1871 if (TAINTING_get && (tmg = mg_find(sv, PERL_MAGIC_taint))
b112cff9
DM		 1872 && (tmg->mg_len & 1))
1873 {
1874 val = sv_mortalcopy(sv);
1875 SvTAINTED_on(val);
1876 }
1877 else
1878 val = sv;
1879
36925d9e 1880 magic_methcall1(sv, mg, SV_CONST(STORE), G_DISCARD, 2, val);
463ee0b2
LW		 1881 return 0;
1882}
1883
1884int
864dbfa3 1885Perl_magic_clearpack(pTHX_ SV *sv, MAGIC *mg)
463ee0b2 1886{
7918f24d
NC		 1887 PERL_ARGS_ASSERT_MAGIC_CLEARPACK;
1888
4c13be3f 1889 if (mg->mg_type == PERL_MAGIC_tiedscalar) return 0;
36925d9e 1890 return magic_methpack(sv,mg,SV_CONST(DELETE));
a0d0e21e 1891}
463ee0b2 1892
93965878
NIS		 1893
1894U32
864dbfa3 1895Perl_magic_sizepack(pTHX_ SV *sv, MAGIC *mg)
ac27b0f5 1896{
22846ab4 1897 I32 retval = 0;
efaf3674 1898 SV* retsv;
93965878 1899
7918f24d
NC		 1900 PERL_ARGS_ASSERT_MAGIC_SIZEPACK;
1901
36925d9e 1902 retsv = magic_methcall1(sv, mg, SV_CONST(FETCHSIZE), 0, 1, NULL);
efaf3674
DM		 1903 if (retsv) {
1904 retval = SvIV(retsv)-1;
22846ab4
AB		 1905 if (retval < -1)
1906 Perl_croak(aTHX_ "FETCHSIZE returned a negative value");
93965878 1907 }
22846ab4 1908 return (U32) retval;
93965878
NIS		 1909}
1910
cea2e8a9
GS		 1911int
1912Perl_magic_wipepack(pTHX_ SV *sv, MAGIC *mg)
a0d0e21e 1913{
7918f24d
NC		 1914 PERL_ARGS_ASSERT_MAGIC_WIPEPACK;
1915
36925d9e 1916 Perl_magic_methcall(aTHX_ sv, mg, SV_CONST(CLEAR), G_DISCARD, 0);
463ee0b2
LW		 1917 return 0;
1918}
1919
1920int
864dbfa3 1921Perl_magic_nextpack(pTHX_ SV *sv, MAGIC *mg, SV *key)
463ee0b2 1922{
efaf3674 1923 SV* ret;
463ee0b2 1924
7918f24d
NC		 1925 PERL_ARGS_ASSERT_MAGIC_NEXTPACK;
1926
36925d9e
RZ		 1927 ret = SvOK(key) ? Perl_magic_methcall(aTHX_ sv, mg, SV_CONST(NEXTKEY), 0, 1, key)
1928 : Perl_magic_methcall(aTHX_ sv, mg, SV_CONST(FIRSTKEY), 0, 0);
efaf3674
DM		 1929 if (ret)
1930 sv_setsv(key,ret);
79072805
LW		 1931 return 0;
1932}
1933
1934int
1146e912 1935Perl_magic_existspack(pTHX_ SV *sv, const MAGIC *mg)
a0d0e21e 1936{
7918f24d
NC		 1937 PERL_ARGS_ASSERT_MAGIC_EXISTSPACK;
1938
36925d9e 1939 return magic_methpack(sv,mg,SV_CONST(EXISTS));
ac27b0f5 1940}
a0d0e21e 1941
a3bcc51e
TP		 1942SV *
1943Perl_magic_scalarpack(pTHX_ HV *hv, MAGIC *mg)
1944{
5fcbf73d 1945 SV *retval;
ad64d0ec
NC		 1946 SV * const tied = SvTIED_obj(MUTABLE_SV(hv), mg);
1947 HV * const pkg = SvSTASH((const SV *)SvRV(tied));
a3bcc51e 1948
7918f24d
NC		 1949 PERL_ARGS_ASSERT_MAGIC_SCALARPACK;
1950
a3bcc51e
TP		 1951 if (!gv_fetchmethod_autoload(pkg, "SCALAR", FALSE)) {
1952 SV *key;
bfcb3514 1953 if (HvEITER_get(hv))
a3bcc51e
TP		 1954 /* we are in an iteration so the hash cannot be empty */
1955 return &PL_sv_yes;
1956 /* no xhv_eiter so now use FIRSTKEY */
1957 key = sv_newmortal();
ad64d0ec 1958 magic_nextpack(MUTABLE_SV(hv), mg, key);
bfcb3514 1959 HvEITER_set(hv, NULL); /* need to reset iterator */
a3bcc51e
TP		 1960 return SvOK(key) ? &PL_sv_yes : &PL_sv_no;
1961 }
1962
1963 /* there is a SCALAR method that we can call */
36925d9e 1964 retval = Perl_magic_methcall(aTHX_ MUTABLE_SV(hv), mg, SV_CONST(SCALAR), 0, 0);
efaf3674 1965 if (!retval)
5fcbf73d 1966 retval = &PL_sv_undef;
a3bcc51e
TP		 1967 return retval;
1968}
1969
a0d0e21e 1970int
864dbfa3 1971Perl_magic_setdbline(pTHX_ SV *sv, MAGIC *mg)
79072805 1972{
089b5c60 1973 SV **svp;
7918f24d
NC		 1974
1975 PERL_ARGS_ASSERT_MAGIC_SETDBLINE;
1976
089b5c60
NC		 1977 /* The magic ptr/len for the debugger's hash should always be an SV. */
1978 if (UNLIKELY(mg->mg_len != HEf_SVKEY)) {
1979 Perl_croak(aTHX_ "panic: magic_setdbline len=%"IVdf", ptr='%s'",
7b0eb0b8 1980 (IV)mg->mg_len, mg->mg_ptr);
089b5c60
NC		 1981 }
1982
1983 /* Use sv_2iv instead of SvIV() as the former generates smaller code, and
1984 setting/clearing debugger breakpoints is not a hot path. */
43e4250a
FC		 1985 svp = av_fetch(MUTABLE_AV(mg->mg_obj),
1986 sv_2iv(MUTABLE_SV((mg)->mg_ptr)), FALSE);
089b5c60 1987
8772537c 1988 if (svp && SvIOKp(*svp)) {
88df5f01
FC		 1989 OP * const o = INT2PTR(OP*,SvIVX(*svp));
1990 if (o) {
1991#ifdef PERL_DEBUG_READONLY_OPS
1992 Slab_to_rw(OpSLAB(o));
1993#endif
1994 /* set or clear breakpoint in the relevant control op */
089b5c60 1995 if (SvTRUE(sv))
88df5f01 1996 o->op_flags |= OPf_SPECIAL;
8772537c 1997 else
88df5f01
FC		 1998 o->op_flags &= ~OPf_SPECIAL;
1999#ifdef PERL_DEBUG_READONLY_OPS
2000 Slab_to_ro(OpSLAB(o));
2001#endif
8772537c 2002 }
5df8de69 2003 }
79072805
LW		 2004 return 0;
2005}
2006
2007int
8772537c 2008Perl_magic_getarylen(pTHX_ SV *sv, const MAGIC *mg)
79072805 2009{
502c6561 2010 AV * const obj = MUTABLE_AV(mg->mg_obj);
7918f24d
NC		 2011
2012 PERL_ARGS_ASSERT_MAGIC_GETARYLEN;
2013
83bf042f 2014 if (obj) {
e1dccc0d 2015 sv_setiv(sv, AvFILL(obj));
83bf042f 2016 } else {
d4a823b3 2017 sv_setsv(sv, NULL);
83bf042f 2018 }
79072805
LW		 2019 return 0;
2020}
2021
2022int
864dbfa3 2023Perl_magic_setarylen(pTHX_ SV *sv, MAGIC *mg)
79072805 2024{
502c6561 2025 AV * const obj = MUTABLE_AV(mg->mg_obj);
7918f24d
NC		 2026
2027 PERL_ARGS_ASSERT_MAGIC_SETARYLEN;
2028
83bf042f 2029 if (obj) {
e1dccc0d 2030 av_fill(obj, SvIV(sv));
83bf042f 2031 } else {
a2a5de95
NC		 2032 Perl_ck_warner(aTHX_ packWARN(WARN_MISC),
2033 "Attempt to set length of freed array");
83bf042f
NC		 2034 }
2035 return 0;
2036}
2037
2038int
83f29afa
VP		 2039Perl_magic_cleararylen_p(pTHX_ SV *sv, MAGIC *mg)
2040{
83f29afa
VP		 2041 PERL_ARGS_ASSERT_MAGIC_CLEARARYLEN_P;
2042 PERL_UNUSED_ARG(sv);
dc3bf405 2043 PERL_UNUSED_CONTEXT;
83f29afa
VP		 2044
2045 /* Reset the iterator when the array is cleared */
3565fbf3
VP		 2046#if IVSIZE == I32SIZE
2047 *((IV *) &(mg->mg_len)) = 0;
2048#else
83f29afa
VP		 2049 if (mg->mg_ptr)
2050 *((IV *) mg->mg_ptr) = 0;
3565fbf3 2051#endif
83f29afa
VP		 2052
2053 return 0;
2054}
2055
2056int
83bf042f
NC		 2057Perl_magic_freearylen_p(pTHX_ SV *sv, MAGIC *mg)
2058{
7918f24d 2059 PERL_ARGS_ASSERT_MAGIC_FREEARYLEN_P;
53c1dcc0 2060 PERL_UNUSED_ARG(sv);
7918f24d 2061
94f3782b
DM		 2062 /* during global destruction, mg_obj may already have been freed */
2063 if (PL_in_clean_all)
1ea47f64 2064 return 0;
94f3782b 2065
83bf042f
NC		 2066 mg = mg_find (mg->mg_obj, PERL_MAGIC_arylen);
2067
2068 if (mg) {
2069 /* arylen scalar holds a pointer back to the array, but doesn't own a
2070 reference. Hence the we (the array) are about to go away with it
2071 still pointing at us. Clear its pointer, else it would be pointing
2072 at free memory. See the comment in sv_magic about reference loops,
2073 and why it can't own a reference to us. */
2074 mg->mg_obj = 0;
2075 }
a0d0e21e
LW		 2076 return 0;
2077}
2078
2079int
864dbfa3 2080Perl_magic_getpos(pTHX_ SV *sv, MAGIC *mg)
a0d0e21e 2081{
16eb5365 2082 SV* const lsv = LvTARG(sv);
96c2a8ff 2083 MAGIC * const found = mg_find_mglob(lsv);
7918f24d
NC		 2084
2085 PERL_ARGS_ASSERT_MAGIC_GETPOS;
16eb5365 2086 PERL_UNUSED_ARG(mg);
ac27b0f5 2087
6174b39a
FC		 2088 if (found && found->mg_len != -1) {
2089 STRLEN i = found->mg_len;
25fdce4a 2090 if (found->mg_flags & MGf_BYTES && DO_UTF8(lsv))
6174b39a
FC		 2091 i = sv_pos_b2u_flags(lsv, i, SV_GMAGIC|SV_CONST_RETURN);
2092 sv_setuv(sv, i);
a0d0e21e 2093 return 0;
a0d0e21e 2094 }
35995e5c 2095 sv_setsv(sv,NULL);
a0d0e21e
LW		 2096 return 0;
2097}
2098
2099int
864dbfa3 2100Perl_magic_setpos(pTHX_ SV *sv, MAGIC *mg)
a0d0e21e 2101{
16eb5365 2102 SV* const lsv = LvTARG(sv);
a0d0e21e
LW		 2103 SSize_t pos;
2104 STRLEN len;
c00206c8 2105 STRLEN ulen = 0;
53d44271 2106 MAGIC* found;
aec43834 2107 const char *s;
a0d0e21e 2108
7918f24d 2109 PERL_ARGS_ASSERT_MAGIC_SETPOS;
16eb5365 2110 PERL_UNUSED_ARG(mg);
ac27b0f5 2111
96c2a8ff 2112 found = mg_find_mglob(lsv);
3881461a 2113 if (!found) {
a0d0e21e
LW		 2114 if (!SvOK(sv))
2115 return 0;
96c2a8ff 2116 found = sv_magicext_mglob(lsv);
a0d0e21e
LW		 2117 }
2118 else if (!SvOK(sv)) {
3881461a 2119 found->mg_len = -1;
a0d0e21e
LW		 2120 return 0;
2121 }
aec43834 2122 s = SvPV_const(lsv, len);
a0d0e21e 2123
e1dccc0d 2124 pos = SvIV(sv);
a0ed51b3 2125
7e2040f0 2126 if (DO_UTF8(lsv)) {
aec43834 2127 ulen = sv_or_pv_len_utf8(lsv, s, len);
a0ed51b3
LW		 2128 if (ulen)
2129 len = ulen;
a0ed51b3
LW		 2130 }
2131
a0d0e21e
LW		 2132 if (pos < 0) {
2133 pos += len;
2134 if (pos < 0)
2135 pos = 0;
2136 }
eb160463 2137 else if (pos > (SSize_t)len)
a0d0e21e 2138 pos = len;
a0ed51b3 2139
3881461a 2140 found->mg_len = pos;
25fdce4a 2141 found->mg_flags &= ~(MGf_MINMATCH|MGf_BYTES);
a0d0e21e 2142
79072805
LW		 2143 return 0;
2144}
2145
2146int
864dbfa3 2147Perl_magic_getsubstr(pTHX_ SV *sv, MAGIC *mg)
6ff81951
GS		 2148{
2149 STRLEN len;
35a4481c 2150 SV * const lsv = LvTARG(sv);
b83604b4 2151 const char * const tmps = SvPV_const(lsv,len);
777f7c56
EB		 2152 STRLEN offs = LvTARGOFF(sv);
2153 STRLEN rem = LvTARGLEN(sv);
83f78d1a
FC		 2154 const bool negoff = LvFLAGS(sv) & 1;
2155 const bool negrem = LvFLAGS(sv) & 2;
7918f24d
NC		 2156
2157 PERL_ARGS_ASSERT_MAGIC_GETSUBSTR;
8772537c 2158 PERL_UNUSED_ARG(mg);
6ff81951 2159
83f78d1a 2160 if (!translate_substr_offsets(
4ddea69a 2161 SvUTF8(lsv) ? sv_or_pv_len_utf8(lsv, tmps, len) : len,
83f78d1a
FC		 2162 negoff ? -(IV)offs : (IV)offs, !negoff,
2163 negrem ? -(IV)rem : (IV)rem, !negrem, &offs, &rem
2164 )) {
2165 Perl_ck_warner(aTHX_ packWARN(WARN_SUBSTR), "substr outside of string");
2166 sv_setsv_nomg(sv, &PL_sv_undef);
2167 return 0;
2168 }
2169
9aa983d2 2170 if (SvUTF8(lsv))
4ddea69a 2171 offs = sv_or_pv_pos_u2b(lsv, tmps, offs, &rem);
1c900557 2172 sv_setpvn(sv, tmps + offs, rem);
9aa983d2 2173 if (SvUTF8(lsv))
2ef4b674 2174 SvUTF8_on(sv);
6ff81951
GS		 2175 return 0;
2176}
2177
2178int
864dbfa3 2179Perl_magic_setsubstr(pTHX_ SV *sv, MAGIC *mg)
79072805 2180{
83f78d1a 2181 STRLEN len, lsv_len, oldtarglen, newtarglen;
5fcbf73d 2182 const char * const tmps = SvPV_const(sv, len);
dd374669 2183 SV * const lsv = LvTARG(sv);
777f7c56
EB		 2184 STRLEN lvoff = LvTARGOFF(sv);
2185 STRLEN lvlen = LvTARGLEN(sv);
83f78d1a
FC		 2186 const bool negoff = LvFLAGS(sv) & 1;
2187 const bool neglen = LvFLAGS(sv) & 2;
7918f24d
NC		 2188
2189 PERL_ARGS_ASSERT_MAGIC_SETSUBSTR;
8772537c 2190 PERL_UNUSED_ARG(mg);
075a4a2b 2191
a74fb2cd
FC		 2192 SvGETMAGIC(lsv);
2193 if (SvROK(lsv))
2194 Perl_ck_warner(aTHX_ packWARN(WARN_SUBSTR),
2195 "Attempt to use reference as lvalue in substr"
2196 );
fc061ed8
FC		 2197 SvPV_force_nomg(lsv,lsv_len);
2198 if (SvUTF8(lsv)) lsv_len = sv_len_utf8_nomg(lsv);
83f78d1a
FC		 2199 if (!translate_substr_offsets(
2200 lsv_len,
2201 negoff ? -(IV)lvoff : (IV)lvoff, !negoff,
2202 neglen ? -(IV)lvlen : (IV)lvlen, !neglen, &lvoff, &lvlen
2203 ))
2204 Perl_croak(aTHX_ "substr outside of string");
2205 oldtarglen = lvlen;
1aa99e6b 2206 if (DO_UTF8(sv)) {
73a087f0 2207 sv_utf8_upgrade_nomg(lsv);
d931b1be 2208 lvoff = sv_pos_u2b_flags(lsv, lvoff, &lvlen, SV_CONST_RETURN);
a74fb2cd 2209 sv_insert_flags(lsv, lvoff, lvlen, tmps, len, 0);
7a385470 2210 newtarglen = sv_or_pv_len_utf8(sv, tmps, len);
9aa983d2
JH		 2211 SvUTF8_on(lsv);
2212 }
0d336106 2213 else if (SvUTF8(lsv)) {
5fcbf73d 2214 const char *utf8;
d931b1be 2215 lvoff = sv_pos_u2b_flags(lsv, lvoff, &lvlen, SV_CONST_RETURN);
83f78d1a 2216 newtarglen = len;
5fcbf73d 2217 utf8 = (char*)bytes_to_utf8((U8*)tmps, &len);
a74fb2cd 2218 sv_insert_flags(lsv, lvoff, lvlen, utf8, len, 0);
5fcbf73d 2219 Safefree(utf8);
1aa99e6b 2220 }
b76f3ce2 2221 else {
a74fb2cd 2222 sv_insert_flags(lsv, lvoff, lvlen, tmps, len, 0);
83f78d1a 2223 newtarglen = len;
b76f3ce2 2224 }
83f78d1a
FC		 2225 if (!neglen) LvTARGLEN(sv) = newtarglen;
2226 if (negoff) LvTARGOFF(sv) += newtarglen - oldtarglen;
b76f3ce2 2227
79072805
LW		 2228 return 0;
2229}
2230
2231int
864dbfa3 2232Perl_magic_gettaint(pTHX_ SV *sv, MAGIC *mg)
463ee0b2 2233{
7918f24d 2234 PERL_ARGS_ASSERT_MAGIC_GETTAINT;
8772537c 2235 PERL_UNUSED_ARG(sv);
9a9b5ec9
DM		 2236#ifdef NO_TAINT_SUPPORT
2237 PERL_UNUSED_ARG(mg);
2238#endif
7918f24d 2239
27cc343c 2240 TAINT_IF((PL_localizing != 1) && (mg->mg_len & 1));
463ee0b2
LW		 2241 return 0;
2242}
2243
2244int
864dbfa3 2245Perl_magic_settaint(pTHX_ SV *sv, MAGIC *mg)
463ee0b2 2246{
7918f24d 2247 PERL_ARGS_ASSERT_MAGIC_SETTAINT;
8772537c 2248 PERL_UNUSED_ARG(sv);
7918f24d 2249
b01e650a 2250 /* update taint status */
284167a5 2251 if (TAINT_get)
b01e650a
DM		 2252 mg->mg_len |= 1;
2253 else
2254 mg->mg_len &= ~1;
463ee0b2
LW		 2255 return 0;
2256}
2257
2258int
864dbfa3 2259Perl_magic_getvec(pTHX_ SV *sv, MAGIC *mg)
6ff81951 2260{
35a4481c 2261 SV * const lsv = LvTARG(sv);
7918f24d
NC		 2262
2263 PERL_ARGS_ASSERT_MAGIC_GETVEC;
8772537c 2264 PERL_UNUSED_ARG(mg);
6ff81951 2265
2e9e14dd 2266 sv_setuv(sv, do_vecget(lsv, LvTARGOFF(sv), LvTARGLEN(sv)));
6ff81951 2267
6ff81951
GS		 2268 return 0;
2269}
2270
2271int
864dbfa3 2272Perl_magic_setvec(pTHX_ SV *sv, MAGIC *mg)
79072805 2273{
7918f24d 2274 PERL_ARGS_ASSERT_MAGIC_SETVEC;
8772537c 2275 PERL_UNUSED_ARG(mg);
79072805
LW		 2276 do_vecset(sv); /* XXX slurp this routine */
2277 return 0;
2278}
2279
13733cde
FC		 2280SV *
2281Perl_defelem_target(pTHX_ SV *sv, MAGIC *mg)
5f05dabc 2282{
a0714e2c 2283 SV *targ = NULL;
13733cde
FC		 2284 PERL_ARGS_ASSERT_DEFELEM_TARGET;
2285 if (!mg) mg = mg_find(sv, PERL_MAGIC_defelem);
2286 assert(mg);
5f05dabc 2287 if (LvTARGLEN(sv)) {
68dc0745 2288 if (mg->mg_obj) {
8772537c 2289 SV * const ahv = LvTARG(sv);
85fbaab2 2290 HE * const he = hv_fetch_ent(MUTABLE_HV(ahv), mg->mg_obj, FALSE, 0);
6d822dc4
MS		 2291 if (he)
2292 targ = HeVAL(he);
68dc0745 2293 }
bbfdc870 2294 else if (LvSTARGOFF(sv) >= 0) {
502c6561 2295 AV *const av = MUTABLE_AV(LvTARG(sv));
bbfdc870 2296 if (LvSTARGOFF(sv) <= AvFILL(av))
ca58dfd9
FC		 2297 {
2298 if (SvRMAGICAL(av)) {
2299 SV * const * const svp = av_fetch(av, LvSTARGOFF(sv), 0);
2300 targ = svp ? *svp : NULL;
2301 }
2302 else
bbfdc870 2303 targ = AvARRAY(av)[LvSTARGOFF(sv)];
ca58dfd9 2304 }
68dc0745 2305 }
46da273f 2306 if (targ && (targ != &PL_sv_undef)) {
68dc0745 2307 /* somebody else defined it for us */
2308 SvREFCNT_dec(LvTARG(sv));
b37c2d43 2309 LvTARG(sv) = SvREFCNT_inc_simple_NN(targ);
68dc0745 2310 LvTARGLEN(sv) = 0;
2311 SvREFCNT_dec(mg->mg_obj);
a0714e2c 2312 mg->mg_obj = NULL;
68dc0745 2313 mg->mg_flags &= ~MGf_REFCOUNTED;
2314 }
13733cde 2315 return targ;
5f05dabc 2316 }
71be2cbc 2317 else
13733cde
FC		 2318 return LvTARG(sv);
2319}
2320
2321int
2322Perl_magic_getdefelem(pTHX_ SV *sv, MAGIC *mg)
2323{
2324 PERL_ARGS_ASSERT_MAGIC_GETDEFELEM;
2325
2326 sv_setsv(sv, defelem_target(sv, mg));
71be2cbc 2327 return 0;
2328}
2329
2330int
864dbfa3 2331Perl_magic_setdefelem(pTHX_ SV *sv, MAGIC *mg)
71be2cbc 2332{
7918f24d 2333 PERL_ARGS_ASSERT_MAGIC_SETDEFELEM;
8772537c 2334 PERL_UNUSED_ARG(mg);
71be2cbc 2335 if (LvTARGLEN(sv))
68dc0745 2336 vivify_defelem(sv);
2337 if (LvTARG(sv)) {
5f05dabc 2338 sv_setsv(LvTARG(sv), sv);
68dc0745 2339 SvSETMAGIC(LvTARG(sv));
2340 }
5f05dabc 2341 return 0;
2342}
2343
71be2cbc 2344void
864dbfa3 2345Perl_vivify_defelem(pTHX_ SV *sv)
71be2cbc 2346{
74e13ce4 2347 MAGIC *mg;
a0714e2c 2348 SV *value = NULL;
71be2cbc 2349
7918f24d
NC		 2350 PERL_ARGS_ASSERT_VIVIFY_DEFELEM;
2351
14befaf4 2352 if (!LvTARGLEN(sv) || !(mg = mg_find(sv, PERL_MAGIC_defelem)))
71be2cbc 2353 return;
68dc0745 2354 if (mg->mg_obj) {
8772537c 2355 SV * const ahv = LvTARG(sv);
85fbaab2 2356 HE * const he = hv_fetch_ent(MUTABLE_HV(ahv), mg->mg_obj, TRUE, 0);
6d822dc4
MS		 2357 if (he)
2358 value = HeVAL(he);
3280af22 2359 if (!value || value == &PL_sv_undef)
be2597df 2360 Perl_croak(aTHX_ PL_no_helem_sv, SVfARG(mg->mg_obj));
71be2cbc 2361 }
bbfdc870
FC		 2362 else if (LvSTARGOFF(sv) < 0)
2363 Perl_croak(aTHX_ PL_no_aelem, LvSTARGOFF(sv));
68dc0745 2364 else {
502c6561 2365 AV *const av = MUTABLE_AV(LvTARG(sv));
bbfdc870 2366 if ((I32)LvTARGLEN(sv) < 0 && LvSTARGOFF(sv) > AvFILL(av))
a0714e2c 2367 LvTARG(sv) = NULL; /* array can't be extended */
68dc0745 2368 else {
bbfdc870 2369 SV* const * const svp = av_fetch(av, LvSTARGOFF(sv), TRUE);
031c6d82 2370 if (!svp || !(value = *svp))
bbfdc870 2371 Perl_croak(aTHX_ PL_no_aelem, LvSTARGOFF(sv));
68dc0745 2372 }
2373 }
b37c2d43 2374 SvREFCNT_inc_simple_void(value);
68dc0745 2375 SvREFCNT_dec(LvTARG(sv));
2376 LvTARG(sv) = value;
71be2cbc 2377 LvTARGLEN(sv) = 0;
68dc0745 2378 SvREFCNT_dec(mg->mg_obj);
a0714e2c 2379 mg->mg_obj = NULL;
68dc0745 2380 mg->mg_flags &= ~MGf_REFCOUNTED;
5f05dabc 2381}
2382
2383int
864dbfa3 2384Perl_magic_killbackrefs(pTHX_ SV *sv, MAGIC *mg)
810b8aa5 2385{
7918f24d 2386 PERL_ARGS_ASSERT_MAGIC_KILLBACKREFS;
5648c0ae
DM		 2387 Perl_sv_kill_backrefs(aTHX_ sv, MUTABLE_AV(mg->mg_obj));
2388 return 0;
810b8aa5
GS		 2389}
2390
2391int
864dbfa3 2392Perl_magic_setmglob(pTHX_ SV *sv, MAGIC *mg)
93a17b20 2393{
7918f24d 2394 PERL_ARGS_ASSERT_MAGIC_SETMGLOB;
96a5add6 2395 PERL_UNUSED_CONTEXT;
0177730e 2396 PERL_UNUSED_ARG(sv);
565764a8 2397 mg->mg_len = -1;
93a17b20
LW		 2398 return 0;
2399}
2400
2401int
864dbfa3 2402Perl_magic_setuvar(pTHX_ SV *sv, MAGIC *mg)
79072805 2403{
35a4481c 2404 const struct ufuncs * const uf = (struct ufuncs *)mg->mg_ptr;
79072805 2405
7918f24d
NC		 2406 PERL_ARGS_ASSERT_MAGIC_SETUVAR;
2407
79072805 2408 if (uf && uf->uf_set)
24f81a43 2409 (*uf->uf_set)(aTHX_ uf->uf_index, sv);
79072805
LW		 2410 return 0;
2411}
2412
c277df42 2413int
faf82a0b
AE		 2414Perl_magic_setregexp(pTHX_ SV *sv, MAGIC *mg)
2415{
488344d2 2416 const char type = mg->mg_type;
7918f24d
NC		 2417
2418 PERL_ARGS_ASSERT_MAGIC_SETREGEXP;
2419
488344d2
NC		 2420 if (type == PERL_MAGIC_qr) {
2421 } else if (type == PERL_MAGIC_bm) {
2422 SvTAIL_off(sv);
2423 SvVALID_off(sv);
2424 } else {
2425 assert(type == PERL_MAGIC_fm);
488344d2
NC		 2426 }
2427 return sv_unmagic(sv, type);
faf82a0b
AE		 2428}
2429
7a4c00b4 2430#ifdef USE_LOCALE_COLLATE
79072805 2431int
864dbfa3 2432Perl_magic_setcollxfrm(pTHX_ SV *sv, MAGIC *mg)
bbce6d69 2433{
7918f24d
NC		 2434 PERL_ARGS_ASSERT_MAGIC_SETCOLLXFRM;
2435
bbce6d69 2436 /*
838b5b74 2437 * RenE<eacute> Descartes said "I think not."
bbce6d69 2438 * and vanished with a faint plop.
2439 */
96a5add6 2440 PERL_UNUSED_CONTEXT;
8772537c 2441 PERL_UNUSED_ARG(sv);
7a4c00b4 2442 if (mg->mg_ptr) {
2443 Safefree(mg->mg_ptr);
2444 mg->mg_ptr = NULL;
565764a8 2445 mg->mg_len = -1;
7a4c00b4 2446 }
bbce6d69 2447 return 0;
2448}
7a4c00b4 2449#endif /* USE_LOCALE_COLLATE */
bbce6d69 2450
7e8c5dac
HS		 2451/* Just clear the UTF-8 cache data. */
2452int
2453Perl_magic_setutf8(pTHX_ SV *sv, MAGIC *mg)
2454{
7918f24d 2455 PERL_ARGS_ASSERT_MAGIC_SETUTF8;
96a5add6 2456 PERL_UNUSED_CONTEXT;
8772537c 2457 PERL_UNUSED_ARG(sv);
7e8c5dac 2458 Safefree(mg->mg_ptr); /* The mg_ptr holds the pos cache. */
3881461a 2459 mg->mg_ptr = NULL;
7e8c5dac
HS		 2460 mg->mg_len = -1; /* The mg_len holds the len cache. */
2461 return 0;
2462}
2463
bbce6d69 2464int
864dbfa3 2465Perl_magic_set(pTHX_ SV *sv, MAGIC *mg)
79072805 2466{
20b7effb 2467#ifdef USE_ITHREADS
97aff369 2468 dVAR;
20b7effb 2469#endif
eb578fdb
KW		 2470 const char *s;
2471 I32 paren;
2472 const REGEXP * rx;
79072805 2473 I32 i;
8990e307 2474 STRLEN len;
125b9982 2475 MAGIC *tmg;
2fdbfb4d 2476
7918f24d
NC		 2477 PERL_ARGS_ASSERT_MAGIC_SET;
2478
e91d8259 2479 if (!mg->mg_ptr) {
960b831f 2480 paren = mg->mg_len;
1e05feb3 2481 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
e91d8259 2482 setparen_got_rx:
2fdbfb4d 2483 CALLREG_NUMBUF_STORE((REGEXP * const)rx,paren,sv);
1e05feb3 2484 } else {
2fdbfb4d
AB		 2485 /* Croak with a READONLY error when a numbered match var is
2486 * set without a previous pattern match. Unless it's C<local $1>
2487 */
e91d8259 2488 croakparen:
2fdbfb4d 2489 if (!PL_localizing) {
cb077ed2 2490 Perl_croak_no_modify();
2fdbfb4d
AB		 2491 }
2492 }
e91d8259
NC		 2493 return 0;
2494 }
2495
2496 switch (*mg->mg_ptr) {
748a9306 2497 case '\001': /* ^A */
f2da823f
FC		 2498 if (SvOK(sv)) sv_copypv(PL_bodytarget, sv);
2499 else SvOK_off(PL_bodytarget);
64eff8b7
DM		 2500 FmLINES(PL_bodytarget) = 0;
2501 if (SvPOK(PL_bodytarget)) {
2502 char *s = SvPVX(PL_bodytarget);
2503 while ( ((s = strchr(s, '\n'))) ) {
2504 FmLINES(PL_bodytarget)++;
2505 s++;
2506 }
2507 }
125b9982 2508 /* mg_set() has temporarily made sv non-magical */
284167a5 2509 if (TAINTING_get) {
125b9982
NT		 2510 if ((tmg = mg_find(sv,PERL_MAGIC_taint)) && tmg->mg_len & 1)
2511 SvTAINTED_on(PL_bodytarget);
2512 else
2513 SvTAINTED_off(PL_bodytarget);
2514 }
748a9306 2515 break;
49460fe6 2516 case '\003': /* ^C */
f2338a2e 2517 PL_minus_c = cBOOL(SvIV(sv));
49460fe6
NIS		 2518 break;
2519
79072805 2520 case '\004': /* ^D */
b4ab917c 2521#ifdef DEBUGGING
b83604b4 2522 s = SvPV_nolen_const(sv);
ddcf8bc1 2523 PL_debug = get_debug_opts(&s, 0) | DEBUG_TOP_FLAG;
a58fb6f9
CS		 2524 if (DEBUG_x_TEST || DEBUG_B_TEST)
2525 dump_all_perl(!DEBUG_B_TEST);
b4ab917c 2526#else
38ab35f8 2527 PL_debug = (SvIV(sv)) | DEBUG_TOP_FLAG;
b4ab917c 2528#endif
79072805 2529 break;
28f23441 2530 case '\005': /* ^E */
d0063567 2531 if (*(mg->mg_ptr+1) == '\0') {
e37778c2 2532#ifdef VMS
38ab35f8 2533 set_vaxc_errno(SvIV(sv));
e37778c2
NC		 2534#else
2535# ifdef WIN32
d0063567 2536 SetLastError( SvIV(sv) );
e37778c2
NC		 2537# else
2538# ifdef OS2
38ab35f8 2539 os2_setsyserrno(SvIV(sv));
e37778c2 2540# else
d0063567 2541 /* will anyone ever use this? */
38ab35f8 2542 SETERRNO(SvIV(sv), 4);
048c1ddf
IZ		 2543# endif
2544# endif
22fae026 2545#endif
d0063567
DK		 2546 }
2547 else if (strEQ(mg->mg_ptr+1, "NCODING")) {
ef8d46e8 2548 SvREFCNT_dec(PL_encoding);
d0063567
DK		 2549 if (SvOK(sv) || SvGMAGICAL(sv)) {
2550 PL_encoding = newSVsv(sv);
2551 }
2552 else {
a0714e2c 2553 PL_encoding = NULL;
d0063567
DK		 2554 }
2555 }
2556 break;
79072805 2557 case '\006': /* ^F */
38ab35f8 2558 PL_maxsysfd = SvIV(sv);
79072805 2559 break;
a0d0e21e 2560 case '\010': /* ^H */
38ab35f8 2561 PL_hints = SvIV(sv);
a0d0e21e 2562 break;
9d116dd7 2563 case '\011': /* ^I */ /* NOT \t in EBCDIC */
43c5f42d 2564 Safefree(PL_inplace);
bd61b366 2565 PL_inplace = SvOK(sv) ? savesvpv(sv) : NULL;
da78da6e 2566 break;
d9bad346
FC		 2567 case '\016': /* ^N */
2568 if (PL_curpm && (rx = PM_GETRE(PL_curpm))
2569 && (paren = RX_LASTCLOSEPAREN(rx))) goto setparen_got_rx;
2570 goto croakparen;
28f23441 2571 case '\017': /* ^O */
ac27b0f5 2572 if (*(mg->mg_ptr+1) == '\0') {
43c5f42d 2573 Safefree(PL_osname);
bd61b366 2574 PL_osname = NULL;
3511154c
DM		 2575 if (SvOK(sv)) {
2576 TAINT_PROPER("assigning to $^O");
2e0de35c 2577 PL_osname = savesvpv(sv);
3511154c 2578 }
ac27b0f5
NIS		 2579 }
2580 else if (strEQ(mg->mg_ptr, "\017PEN")) {
8b850bd5
NC		 2581 STRLEN len;
2582 const char *const start = SvPV(sv, len);
b54fc2b6 2583 const char *out = (const char*)memchr(start, '\0', len);
8b850bd5 2584 SV *tmp;
8b850bd5
NC		 2585
2586
2587 PL_compiling.cop_hints |= HINT_LEXICAL_IO_IN | HINT_LEXICAL_IO_OUT;
f747ebd6 2588 PL_hints |= HINT_LEXICAL_IO_IN | HINT_LEXICAL_IO_OUT;
8b850bd5
NC		 2589
2590 /* Opening for input is more common than opening for output, so
2591 ensure that hints for input are sooner on linked list. */
59cd0e26 2592 tmp = out ? newSVpvn_flags(out + 1, start + len - out - 1,
f747ebd6
Z		 2593 SvUTF8(sv))
2594 : newSVpvs_flags("", SvUTF8(sv));
2595 (void)hv_stores(GvHV(PL_hintgv), "open>", tmp);
2596 mg_set(tmp);
8b850bd5 2597
f747ebd6
Z		 2598 tmp = newSVpvn_flags(start, out ? (STRLEN)(out - start) : len,
2599 SvUTF8(sv));
2600 (void)hv_stores(GvHV(PL_hintgv), "open<", tmp);
2601 mg_set(tmp);
ac27b0f5 2602 }
28f23441 2603 break;
79072805 2604 case '\020': /* ^P */
2fdbfb4d
AB		 2605 PL_perldb = SvIV(sv);
2606 if (PL_perldb && !PL_DBsingle)
2607 init_debugger();
9b9e0be4 2608 break;
79072805 2609 case '\024': /* ^T */
88e89b8a 2610#ifdef BIG_TIME
6b88bc9c 2611 PL_basetime = (Time_t)(SvNOK(sv) ? SvNVX(sv) : sv_2nv(sv));
88e89b8a 2612#else
38ab35f8 2613 PL_basetime = (Time_t)SvIV(sv);
88e89b8a 2614#endif
79072805 2615 break;
e07ea26a
NC		 2616 case '\025': /* ^UTF8CACHE */
2617 if (strEQ(mg->mg_ptr+1, "TF8CACHE")) {
2618 PL_utf8cache = (signed char) sv_2iv(sv);
2619 }
2620 break;
fde18df1 2621 case '\027': /* ^W & $^WARNING_BITS */
4438c4b7
JH		 2622 if (*(mg->mg_ptr+1) == '\0') {
2623 if ( ! (PL_dowarn & G_WARN_ALL_MASK)) {
38ab35f8 2624 i = SvIV(sv);
ac27b0f5 2625 PL_dowarn = (PL_dowarn & ~G_WARN_ON)
0453d815 2626 | (i ? G_WARN_ON : G_WARN_OFF) ;
4438c4b7 2627 }
599cee73 2628 }
0a378802 2629 else if (strEQ(mg->mg_ptr+1, "ARNING_BITS")) {
4438c4b7 2630 if ( ! (PL_dowarn & G_WARN_ALL_MASK)) {
7e4f0450
FC		 2631 if (!SvPOK(sv)) {
2632 PL_compiling.cop_warnings = pWARN_STD;
d775746e
GS		 2633 break;
2634 }
f4fc7782 2635 {
b5477537 2636 STRLEN len, i;
d3a7d8c7 2637 int accumulate = 0 ;
f4fc7782 2638 int any_fatals = 0 ;
b83604b4 2639 const char * const ptr = SvPV_const(sv, len) ;
f4fc7782
JH		 2640 for (i = 0 ; i < len ; ++i) {
2641 accumulate |= ptr[i] ;
2642 any_fatals |= (ptr[i] & 0xAA) ;
2643 }
4243c432
NC		 2644 if (!accumulate) {
2645 if (!specialWARN(PL_compiling.cop_warnings))
2646 PerlMemShared_free(PL_compiling.cop_warnings);
2647 PL_compiling.cop_warnings = pWARN_NONE;
2648 }
72dc9ed5 2649 /* Yuck. I can't see how to abstract this: */
2f3f0b56
KW		 2650 else if (isWARN_on(
2651 ((STRLEN *)SvPV_nolen_const(sv)) - 1,
2652 WARN_ALL)
2653 && !any_fatals)
2654 {
4243c432
NC		 2655 if (!specialWARN(PL_compiling.cop_warnings))
2656 PerlMemShared_free(PL_compiling.cop_warnings);
f4fc7782
JH		 2657 PL_compiling.cop_warnings = pWARN_ALL;
2658 PL_dowarn |= G_WARN_ONCE ;
727405f8 2659 }
d3a7d8c7 2660 else {
72dc9ed5
NC		 2661 STRLEN len;
2662 const char *const p = SvPV_const(sv, len);
2663
2664 PL_compiling.cop_warnings
8ee4cf24 2665 = Perl_new_warnings_bitfield(aTHX_ PL_compiling.cop_warnings,
72dc9ed5
NC		 2666 p, len);
2667
d3a7d8c7
GS		 2668 if (isWARN_on(PL_compiling.cop_warnings, WARN_ONCE))
2669 PL_dowarn |= G_WARN_ONCE ;
2670 }
f4fc7782 2671
d3a7d8c7 2672 }
4438c4b7 2673 }
971a9dd3 2674 }
79072805
LW		 2675 break;
2676 case '.':
3280af22
NIS		 2677 if (PL_localizing) {
2678 if (PL_localizing == 1)
7766f137 2679 SAVESPTR(PL_last_in_gv);
748a9306 2680 }
3280af22 2681 else if (SvOK(sv) && GvIO(PL_last_in_gv))
632db599 2682 IoLINES(GvIOp(PL_last_in_gv)) = SvIV(sv);
79072805
LW		 2683 break;
2684 case '^':
acbe1b9d
FC		 2685 Safefree(IoTOP_NAME(GvIOp(PL_defoutgv)));
2686 s = IoTOP_NAME(GvIOp(PL_defoutgv)) = savesvpv(sv);
2687 IoTOP_GV(GvIOp(PL_defoutgv)) = gv_fetchsv(sv, GV_ADD, SVt_PVIO);
79072805
LW		 2688 break;
2689 case '~':
acbe1b9d
FC		 2690 Safefree(IoFMT_NAME(GvIOp(PL_defoutgv)));
2691 s = IoFMT_NAME(GvIOp(PL_defoutgv)) = savesvpv(sv);
2692 IoFMT_GV(GvIOp(PL_defoutgv)) = gv_fetchsv(sv, GV_ADD, SVt_PVIO);
79072805
LW		 2693 break;
2694 case '=':
acbe1b9d 2695 IoPAGE_LEN(GvIOp(PL_defoutgv)) = (SvIV(sv));
79072805
LW		 2696 break;
2697 case '-':
acbe1b9d
FC		 2698 IoLINES_LEFT(GvIOp(PL_defoutgv)) = (SvIV(sv));
2699 if (IoLINES_LEFT(GvIOp(PL_defoutgv)) < 0L)
099be4f1 2700 IoLINES_LEFT(GvIOp(PL_defoutgv)) = 0L;
79072805
LW		 2701 break;
2702 case '%':
acbe1b9d 2703 IoPAGE(GvIOp(PL_defoutgv)) = (SvIV(sv));
79072805
LW		 2704 break;
2705 case '|':
4b65379b 2706 {
099be4f1 2707 IO * const io = GvIO(PL_defoutgv);
720f287d
AB		 2708 if(!io)
2709 break;
38ab35f8 2710 if ((SvIV(sv)) == 0)
4b65379b
CS		 2711 IoFLAGS(io) &= ~IOf_FLUSH;
2712 else {
2713 if (!(IoFLAGS(io) & IOf_FLUSH)) {
2714 PerlIO *ofp = IoOFP(io);
2715 if (ofp)
2716 (void)PerlIO_flush(ofp);
2717 IoFLAGS(io) |= IOf_FLUSH;
2718 }
2719 }
79072805
LW		 2720 }
2721 break;
79072805 2722 case '/':
1ab48e3a
YO		 2723 {
2724 SV *tmpsv= sv;
2725 if (SvROK(sv)) {
2726 SV *referent= SvRV(sv);
2727 const char *reftype= sv_reftype(referent, 0);
2728 /* XXX: dodgy type check: This leaves me feeling dirty, but the alternative
2729 * is to copy pretty much the entire sv_reftype() into this routine, or to do
2730 * a full string comparison on the return of sv_reftype() both of which
2731 * make me feel worse! NOTE, do not modify this comment without reviewing the
2732 * corresponding comment in sv_reftype(). - Yves */
2733 if (reftype[0] == 'S' || reftype[0] == 'L') {
2734 IV val= SvIV(referent);
2735 if (val <= 0) {
2736 tmpsv= &PL_sv_undef;
2737 Perl_ck_warner(aTHX_ packWARN(WARN_DEPRECATED),
2738 "Setting $/ to a reference to %s as a form of slurp is deprecated, treating as undef",
2739 SvIV(SvRV(sv)) < 0 ? "a negative integer" : "zero"
2740 );
2741 }
2742 } else {
ee0ba734 2743 /* diag_listed_as: Setting $/ to %s reference is forbidden */
a48e4205
FC		 2744 Perl_croak(aTHX_ "Setting $/ to a%s %s reference is forbidden",
2745 *reftype == 'A' ? "n" : "", reftype);
1ab48e3a
YO		 2746 }
2747 }
b3a2acfa 2748 SvREFCNT_dec(PL_rs);
1ab48e3a 2749 PL_rs = newSVsv(tmpsv);
b3a2acfa 2750 }
79072805
LW		 2751 break;
2752 case '\\':
ef8d46e8 2753 SvREFCNT_dec(PL_ors_sv);
6bc2995b 2754 if (SvOK(sv)) {
7889fe52 2755 PL_ors_sv = newSVsv(sv);
009c130f 2756 }
e3c19b7b 2757 else {
a0714e2c 2758 PL_ors_sv = NULL;
e3c19b7b 2759 }
79072805 2760 break;
7d69d4a6
FC		 2761 case '[':
2762 if (SvIV(sv) != 0)
2763 Perl_croak(aTHX_ "Assigning non-zero to $[ is no longer possible");
2764 break;
79072805 2765 case '?':
ff0cee69 2766#ifdef COMPLEX_STATUS
6b88bc9c 2767 if (PL_localizing == 2) {
41cb7b2b 2768 SvUPGRADE(sv, SVt_PVLV);
6b88bc9c
GS		 2769 PL_statusvalue = LvTARGOFF(sv);
2770 PL_statusvalue_vms = LvTARGLEN(sv);
ff0cee69 2771 }
2772 else
2773#endif
2774#ifdef VMSISH_STATUS
2775 if (VMSISH_STATUS)
fb38d079 2776 STATUS_NATIVE_CHILD_SET((U32)SvIV(sv));
ff0cee69 2777 else
2778#endif
38ab35f8 2779 STATUS_UNIX_EXIT_SET(SvIV(sv));
79072805
LW		 2780 break;
2781 case '!':
93189314
JH		 2782 {
2783#ifdef VMS
2784# define PERL_VMS_BANG vaxc$errno
2785#else
2786# define PERL_VMS_BANG 0
2787#endif
27329181 2788#if defined(WIN32) && ! defined(UNDER_CE)
c9beaf97
SH		 2789 SETERRNO(win32_get_errno(SvIOK(sv) ? SvIVX(sv) : SvOK(sv) ? sv_2iv(sv) : 0),
2790 (SvIV(sv) == EVMSERR) ? 4 : PERL_VMS_BANG);
2791#else
91487cfc 2792 SETERRNO(SvIOK(sv) ? SvIVX(sv) : SvOK(sv) ? sv_2iv(sv) : 0,
93189314 2793 (SvIV(sv) == EVMSERR) ? 4 : PERL_VMS_BANG);
c9beaf97 2794#endif
93189314 2795 }
79072805
LW		 2796 break;
2797 case '<':
985213f2 2798 {
b469f1e0 2799 /* XXX $< currently silently ignores failures */
dfff4baf 2800 const Uid_t new_uid = SvUID(sv);
985213f2 2801 PL_delaymagic_uid = new_uid;
3280af22
NIS		 2802 if (PL_delaymagic) {
2803 PL_delaymagic |= DM_RUID;
79072805
LW		 2804 break; /* don't do magic till later */
2805 }
2806#ifdef HAS_SETRUID
b469f1e0 2807 PERL_UNUSED_RESULT(setruid(new_uid));
79072805
LW		 2808#else
2809#ifdef HAS_SETREUID
b469f1e0 2810 PERL_UNUSED_RESULT(setreuid(new_uid, (Uid_t)-1));
748a9306 2811#else
85e6fe83 2812#ifdef HAS_SETRESUID
b469f1e0 2813 PERL_UNUSED_RESULT(setresuid(new_uid, (Uid_t)-1, (Uid_t)-1));
79072805 2814#else
985213f2 2815 if (new_uid == PerlProc_geteuid()) { /* special case $< = $> */
75870ed3 2816#ifdef PERL_DARWIN
2817 /* workaround for Darwin's setuid peculiarity, cf [perl #24122] */
985213f2 2818 if (new_uid != 0 && PerlProc_getuid() == 0)
b469f1e0 2819 PERL_UNUSED_RESULT(PerlProc_setuid(0));
75870ed3 2820#endif
b469f1e0 2821 PERL_UNUSED_RESULT(PerlProc_setuid(new_uid));
75870ed3 2822 } else {
cea2e8a9 2823 Perl_croak(aTHX_ "setruid() not implemented");
a0d0e21e 2824 }
79072805
LW		 2825#endif
2826#endif
85e6fe83 2827#endif
79072805 2828 break;
985213f2 2829 }
79072805 2830 case '>':
985213f2 2831 {
b469f1e0 2832 /* XXX $> currently silently ignores failures */
dfff4baf 2833 const Uid_t new_euid = SvUID(sv);
985213f2 2834 PL_delaymagic_euid = new_euid;
3280af22
NIS		 2835 if (PL_delaymagic) {
2836 PL_delaymagic |= DM_EUID;
79072805
LW		 2837 break; /* don't do magic till later */
2838 }
2839#ifdef HAS_SETEUID
b469f1e0 2840 PERL_UNUSED_RESULT(seteuid(new_euid));
79072805
LW		 2841#else
2842#ifdef HAS_SETREUID
b469f1e0 2843 PERL_UNUSED_RESULT(setreuid((Uid_t)-1, new_euid));
85e6fe83
LW		 2844#else
2845#ifdef HAS_SETRESUID
b469f1e0 2846 PERL_UNUSED_RESULT(setresuid((Uid_t)-1, new_euid, (Uid_t)-1));
79072805 2847#else
985213f2 2848 if (new_euid == PerlProc_getuid()) /* special case $> = $< */
b469f1e0 2849 PERL_UNUSED_RESULT(PerlProc_setuid(new_euid));
a0d0e21e 2850 else {
cea2e8a9 2851 Perl_croak(aTHX_ "seteuid() not implemented");
a0d0e21e 2852 }
79072805
LW		 2853#endif
2854#endif
85e6fe83 2855#endif
79072805 2856 break;
985213f2 2857 }
79072805 2858 case '(':
985213f2 2859 {
b469f1e0 2860 /* XXX $( currently silently ignores failures */
dfff4baf 2861 const Gid_t new_gid = SvGID(sv);
985213f2 2862 PL_delaymagic_gid = new_gid;
3280af22
NIS		 2863 if (PL_delaymagic) {
2864 PL_delaymagic |= DM_RGID;
79072805
LW		 2865 break; /* don't do magic till later */
2866 }
2867#ifdef HAS_SETRGID
b469f1e0 2868 PERL_UNUSED_RESULT(setrgid(new_gid));
79072805
LW		 2869#else
2870#ifdef HAS_SETREGID
b469f1e0 2871 PERL_UNUSED_RESULT(setregid(new_gid, (Gid_t)-1));
85e6fe83
LW		 2872#else
2873#ifdef HAS_SETRESGID
b469f1e0 2874 PERL_UNUSED_RESULT(setresgid(new_gid, (Gid_t)-1, (Gid_t) -1));
79072805 2875#else
985213f2 2876 if (new_gid == PerlProc_getegid()) /* special case $( = $) */
b469f1e0 2877 PERL_UNUSED_RESULT(PerlProc_setgid(new_gid));
748a9306 2878 else {
cea2e8a9 2879 Perl_croak(aTHX_ "setrgid() not implemented");
748a9306 2880 }
79072805
LW		 2881#endif
2882#endif
85e6fe83 2883#endif
79072805 2884 break;
985213f2 2885 }
79072805 2886 case ')':
985213f2 2887 {
b469f1e0 2888 /* XXX $) currently silently ignores failures */
dfff4baf 2889 Gid_t new_egid;
5cd24f17 2890#ifdef HAS_SETGROUPS
2891 {
b83604b4 2892 const char *p = SvPV_const(sv, len);
757f63d8 2893 Groups_t *gary = NULL;
fb4089e0 2894#ifdef _SC_NGROUPS_MAX
2895 int maxgrp = sysconf(_SC_NGROUPS_MAX);
2896
2897 if (maxgrp < 0)
2898 maxgrp = NGROUPS;
2899#else
2900 int maxgrp = NGROUPS;
2901#endif
757f63d8
SP		 2902
2903 while (isSPACE(*p))
2904 ++p;
dfff4baf 2905 new_egid = (Gid_t)Atol(p);
fb4089e0 2906 for (i = 0; i < maxgrp; ++i) {
757f63d8
SP		 2907 while (*p && !isSPACE(*p))
2908 ++p;
2909 while (isSPACE(*p))
2910 ++p;
2911 if (!*p)
2912 break;
2913 if(!gary)
2914 Newx(gary, i + 1, Groups_t);
2915 else
2916 Renew(gary, i + 1, Groups_t);
dfff4baf 2917 gary[i] = (Groups_t)Atol(p);
757f63d8
SP		 2918 }
2919 if (i)
b469f1e0 2920 PERL_UNUSED_RESULT(setgroups(i, gary));
f5a63d97 2921 Safefree(gary);
5cd24f17 2922 }
2923#else /* HAS_SETGROUPS */
dfff4baf 2924 new_egid = SvGID(sv);
5cd24f17 2925#endif /* HAS_SETGROUPS */
985213f2 2926 PL_delaymagic_egid = new_egid;
3280af22
NIS		 2927 if (PL_delaymagic) {
2928 PL_delaymagic |= DM_EGID;
79072805
LW		 2929 break; /* don't do magic till later */
2930 }
2931#ifdef HAS_SETEGID
b469f1e0 2932 PERL_UNUSED_RESULT(setegid(new_egid));
79072805
LW		 2933#else
2934#ifdef HAS_SETREGID
b469f1e0 2935 PERL_UNUSED_RESULT(setregid((Gid_t)-1, new_egid));
85e6fe83
LW		 2936#else
2937#ifdef HAS_SETRESGID
b469f1e0 2938 PERL_UNUSED_RESULT(setresgid((Gid_t)-1, new_egid, (Gid_t)-1));
79072805 2939#else
985213f2 2940 if (new_egid == PerlProc_getgid()) /* special case $) = $( */
b469f1e0 2941 PERL_UNUSED_RESULT(PerlProc_setgid(new_egid));
748a9306 2942 else {
cea2e8a9 2943 Perl_croak(aTHX_ "setegid() not implemented");
748a9306 2944 }
79072805
LW		 2945#endif
2946#endif
85e6fe83 2947#endif
79072805 2948 break;
985213f2 2949 }
79072805 2950 case ':':
2d8e6c8d 2951 PL_chopset = SvPV_force(sv,len);
79072805 2952 break;
9cdac2a2
FC		 2953 case '$': /* $$ */
2954 /* Store the pid in mg->mg_obj so we can tell when a fork has
2955 occurred. mg->mg_obj points to *$ by default, so clear it. */
2956 if (isGV(mg->mg_obj)) {
2957 if (mg->mg_flags & MGf_REFCOUNTED) /* probably never true */
2958 SvREFCNT_dec(mg->mg_obj);
2959 mg->mg_flags |= MGf_REFCOUNTED;
2960 mg->mg_obj = newSViv((IV)PerlProc_getpid());
2961 }
2962 else sv_setiv(mg->mg_obj, (IV)PerlProc_getpid());
2963 break;
79072805 2964 case '0':
e2975953 2965 LOCK_DOLLARZERO_MUTEX;
4bc88a62
PS		 2966#ifdef HAS_SETPROCTITLE
2967 /* The BSDs don't show the argv[] in ps(1) output, they
2968 * show a string from the process struct and provide
2969 * the setproctitle() routine to manipulate that. */
a2722ac9 2970 if (PL_origalen != 1) {
b83604b4 2971 s = SvPV_const(sv, len);
98b76f99 2972# if __FreeBSD_version > 410001
9aad2c0e 2973 /* The leading "-" removes the "perl: " prefix,
4bc88a62
PS		 2974 * but not the "(perl) suffix from the ps(1)
2975 * output, because that's what ps(1) shows if the
2976 * argv[] is modified. */
6f2ad931 2977 setproctitle("-%s", s);
9aad2c0e 2978# else /* old FreeBSDs, NetBSD, OpenBSD, anyBSD */
4bc88a62
PS		 2979 /* This doesn't really work if you assume that
2980 * $0 = 'foobar'; will wipe out 'perl' from the $0
2981 * because in ps(1) output the result will be like
2982 * sprintf("perl: %s (perl)", s)
2983 * I guess this is a security feature:
2984 * one (a user process) cannot get rid of the original name.
2985 * --jhi */
2986 setproctitle("%s", s);
2987# endif
2988 }
9d3968b2 2989#elif defined(__hpux) && defined(PSTAT_SETCMD)
a2722ac9 2990 if (PL_origalen != 1) {
17aa7f3d 2991 union pstun un;
b83604b4 2992 s = SvPV_const(sv, len);
6867be6d 2993 un.pst_command = (char *)s;
17aa7f3d
JH		 2994 pstat(PSTAT_SETCMD, un, len, 0, 0);
2995 }
9d3968b2 2996#else
2d2af554
GA		 2997 if (PL_origalen > 1) {
2998 /* PL_origalen is set in perl_parse(). */
2999 s = SvPV_force(sv,len);
3000 if (len >= (STRLEN)PL_origalen-1) {
3001 /* Longer than original, will be truncated. We assume that
3002 * PL_origalen bytes are available. */
3003 Copy(s, PL_origargv[0], PL_origalen-1, char);
3004 }
3005 else {
3006 /* Shorter than original, will be padded. */
235ac35d 3007#ifdef PERL_DARWIN
60777a0d
JH		 3008 /* Special case for Mac OS X: see [perl #38868] */
3009 const int pad = 0;
235ac35d 3010#else
8a89a4f1
MB		 3011 /* Is the space counterintuitive? Yes.
3012 * (You were expecting \0?)
3013 * Does it work? Seems to. (In Linux 2.4.20 at least.)
3014 * --jhi */
60777a0d 3015 const int pad = ' ';
235ac35d 3016#endif
60777a0d
JH		 3017 Copy(s, PL_origargv[0], len, char);
3018 PL_origargv[0][len] = 0;
3019 memset(PL_origargv[0] + len + 1,
3020 pad, PL_origalen - len - 1);
2d2af554
GA		 3021 }
3022 PL_origargv[0][PL_origalen-1] = 0;
3023 for (i = 1; i < PL_origargc; i++)
3024 PL_origargv[i] = 0;
7636ea95
AB		 3025#ifdef HAS_PRCTL_SET_NAME
3026 /* Set the legacy process name in addition to the POSIX name on Linux */
3027 if (prctl(PR_SET_NAME, (unsigned long)s, 0, 0, 0) != 0) {
3028 /* diag_listed_as: SKIPME */
3029 Perl_croak(aTHX_ "Can't set $0 with prctl(): %s", Strerror(errno));
3030 }
3031#endif
79072805 3032 }
9d3968b2 3033#endif
e2975953 3034 UNLOCK_DOLLARZERO_MUTEX;
79072805
LW		 3035 break;
3036 }
3037 return 0;
3038}
3039
3040I32
84c7b88c
BF		 3041Perl_whichsig_sv(pTHX_ SV *sigsv)
3042{
3043 const char *sigpv;
3044 STRLEN siglen;
3045 PERL_ARGS_ASSERT_WHICHSIG_SV;
84c7b88c
BF		 3046 sigpv = SvPV_const(sigsv, siglen);
3047 return whichsig_pvn(sigpv, siglen);
3048}
3049
3050I32
3051Perl_whichsig_pv(pTHX_ const char *sig)
3052{
3053 PERL_ARGS_ASSERT_WHICHSIG_PV;
84c7b88c
BF		 3054 return whichsig_pvn(sig, strlen(sig));
3055}
3056
3057I32
3058Perl_whichsig_pvn(pTHX_ const char *sig, STRLEN len)
79072805 3059{
eb578fdb 3060 char* const* sigv;
7918f24d 3061
84c7b88c 3062 PERL_ARGS_ASSERT_WHICHSIG_PVN;
96a5add6 3063 PERL_UNUSED_CONTEXT;
79072805 3064
aadb217d 3065 for (sigv = (char* const*)PL_sig_name; *sigv; sigv++)
84c7b88c 3066 if (strlen(*sigv) == len && memEQ(sig,*sigv, len))
aadb217d 3067 return PL_sig_num[sigv - (char* const*)PL_sig_name];
79072805 3068#ifdef SIGCLD
84c7b88c 3069 if (memEQs(sig, len, "CHLD"))
79072805
LW		 3070 return SIGCLD;
3071#endif
3072#ifdef SIGCHLD
84c7b88c 3073 if (memEQs(sig, len, "CLD"))
79072805
LW		 3074 return SIGCHLD;
3075#endif
7f1236c0 3076 return -1;
79072805
LW		 3077}
3078
ecfc5424 3079Signal_t
1e82f5a6 3080#if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
b3dbdd48 3081Perl_sighandler(int sig, siginfo_t *sip, void *uap)
1e82f5a6
SH		 3082#else
3083Perl_sighandler(int sig)
3084#endif
79072805 3085{
1018e26f
NIS		 3086#ifdef PERL_GET_SIG_CONTEXT
3087 dTHXa(PERL_GET_SIG_CONTEXT);
71d280e3 3088#else
cea2e8a9 3089 dTHX;
71d280e3 3090#endif
79072805 3091 dSP;
a0714e2c
SS		 3092 GV *gv = NULL;
3093 SV *sv = NULL;
8772537c 3094 SV * const tSv = PL_Sv;
601f1833 3095 CV *cv = NULL;
533c011a 3096 OP *myop = PL_op;
84902520 3097 U32 flags = 0;
8772537c 3098 XPV * const tXpv = PL_Xpv;
0c4d3b5e 3099 I32 old_ss_ix = PL_savestack_ix;
100c03aa 3100 SV *errsv_save = NULL;
71d280e3 3101
84902520 3102
727405f8 3103 if (!PL_psig_ptr[sig]) {
99ef548b 3104 PerlIO_printf(Perl_error_log, "Signal SIG%s received, but no signal handler set.\n",
727405f8
NIS		 3105 PL_sig_name[sig]);
3106 exit(sig);
3107 }
ff0cee69 3108
a0d63a7b
DM		 3109 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG) {
3110 /* Max number of items pushed there is 3*n or 4. We cannot fix
3111 infinity, so we fix 4 (in fact 5): */
3112 if (PL_savestack_ix + 15 <= PL_savestack_max) {
3113 flags |= 1;
3114 PL_savestack_ix += 5; /* Protect save in progress. */
3115 SAVEDESTRUCTOR_X(S_unwind_handler_stack, NULL);
3116 }
84902520 3117 }
84902520 3118 /* sv_2cv is too complicated, try a simpler variant first: */
ea726b52 3119 if (!SvROK(PL_psig_ptr[sig]) || !(cv = MUTABLE_CV(SvRV(PL_psig_ptr[sig])))
8772537c
AL		 3120 || SvTYPE(cv) != SVt_PVCV) {
3121 HV *st;
f2c0649b 3122 cv = sv_2cv(PL_psig_ptr[sig], &st, &gv, GV_ADD);
8772537c 3123 }
84902520 3124
a0d0e21e 3125 if (!cv || !CvROOT(cv)) {
a2a5de95
NC		 3126 Perl_ck_warner(aTHX_ packWARN(WARN_SIGNAL), "SIG%s handler \"%s\" not defined.\n",
3127 PL_sig_name[sig], (gv ? GvENAME(gv)
3128 : ((cv && CvGV(cv))
3129 ? GvENAME(CvGV(cv))
3130 : "__ANON__")));
00d579c5 3131 goto cleanup;
79072805
LW		 3132 }
3133
0c4d3b5e
DM		 3134 sv = PL_psig_name[sig]
3135 ? SvREFCNT_inc_NN(PL_psig_name[sig])
3136 : newSVpv(PL_sig_name[sig],0);
72048cfe 3137 flags |= 8;
0c4d3b5e
DM		 3138 SAVEFREESV(sv);
3139
a0d63a7b
DM		 3140 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG) {
3141 /* make sure our assumption about the size of the SAVEs are correct:
3142 * 3 for SAVEDESTRUCTOR_X, 2 for SAVEFREESV */
3143 assert(old_ss_ix + 2 + ((flags & 1) ? 3+5 : 0) == PL_savestack_ix);
3144 }
e336de0d 3145
e788e7d3 3146 PUSHSTACKi(PERLSI_SIGNAL);
924508f0 3147 PUSHMARK(SP);
79072805 3148 PUSHs(sv);
8aad04aa
JH		 3149#if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
3150 {
3151 struct sigaction oact;
3152
3153 if (sigaction(sig, 0, &oact) == 0 && oact.sa_flags & SA_SIGINFO) {
8aad04aa
JH		 3154 if (sip) {
3155 HV *sih = newHV();
ad64d0ec 3156 SV *rv = newRV_noinc(MUTABLE_SV(sih));
8aad04aa
JH		 3157 /* The siginfo fields signo, code, errno, pid, uid,
3158 * addr, status, and band are defined by POSIX/SUSv3. */
85771703
NC		 3159 (void)hv_stores(sih, "signo", newSViv(sip->si_signo));
3160 (void)hv_stores(sih, "code", newSViv(sip->si_code));
79dec0f4 3161#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. */
85771703
NC		 3162 hv_stores(sih, "errno", newSViv(sip->si_errno));
3163 hv_stores(sih, "status", newSViv(sip->si_status));
3164 hv_stores(sih, "uid", newSViv(sip->si_uid));
3165 hv_stores(sih, "pid", newSViv(sip->si_pid));
3166 hv_stores(sih, "addr", newSVuv(PTR2UV(sip->si_addr)));
3167 hv_stores(sih, "band", newSViv(sip->si_band));
79dec0f4 3168#endif
8aad04aa 3169 EXTEND(SP, 2);
ad64d0ec 3170 PUSHs(rv);
22f1178f 3171 mPUSHp((char *)sip, sizeof(*sip));
8aad04aa 3172 }
b4552a27 3173
8aad04aa
JH		 3174 }
3175 }
3176#endif
79072805 3177 PUTBACK;
a0d0e21e 3178
100c03aa
JL		 3179 errsv_save = newSVsv(ERRSV);
3180
ad64d0ec 3181 call_sv(MUTABLE_SV(cv), G_DISCARD|G_EVAL);
79072805 3182
d3acc0f7 3183 POPSTACK;
eed484f9
DD		 3184 {
3185 SV * const errsv = ERRSV;
3186 if (SvTRUE_NN(errsv)) {
3187 SvREFCNT_dec(errsv_save);
c22d665b 3188#ifndef PERL_MICRO
1b266415
NIS		 3189 /* Handler "died", for example to get out of a restart-able read().
3190 * Before we re-do that on its behalf re-enable the signal which was
3191 * blocked by the system when we entered.
3192 */
c22d665b 3193#ifdef HAS_SIGPROCMASK
d488af49 3194#if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
eed484f9 3195 if (sip || uap)
c22d665b 3196#endif
eed484f9
DD		 3197 {
3198 sigset_t set;
3199 sigemptyset(&set);
3200 sigaddset(&set,sig);
3201 sigprocmask(SIG_UNBLOCK, &set, NULL);
3202 }
c22d665b 3203#else
eed484f9
DD		 3204 /* Not clear if this will work */
3205 (void)rsignal(sig, SIG_IGN);
3206 (void)rsignal(sig, PL_csighandlerp);
c22d665b
LT		 3207#endif
3208#endif /* !PERL_MICRO */
eed484f9
DD		 3209 die_sv(errsv);
3210 }
3211 else {
3212 sv_setsv(errsv, errsv_save);
3213 SvREFCNT_dec(errsv_save);
3214 }
100c03aa
JL		 3215 }
3216
00d579c5 3217cleanup:
0c4d3b5e
DM		 3218 /* pop any of SAVEFREESV, SAVEDESTRUCTOR_X and "save in progress" */
3219 PL_savestack_ix = old_ss_ix;
72048cfe 3220 if (flags & 8)
2357bae7 3221 SvREFCNT_dec_NN(sv);
533c011a 3222 PL_op = myop; /* Apparently not needed... */
ac27b0f5 3223
3280af22
NIS		 3224 PL_Sv = tSv; /* Restore global temporaries. */
3225 PL_Xpv = tXpv;
53bb94e2 3226 return;
79072805 3227}
4e35701f
NIS		 3228
3229
51371543 3230static void
8772537c 3231S_restore_magic(pTHX_ const void *p)
51371543 3232{
8772537c
AL		 3233 MGS* const mgs = SSPTR(PTR2IV(p), MGS*);
3234 SV* const sv = mgs->mgs_sv;
150b625d 3235 bool bumped;
51371543
GS		 3236
3237 if (!sv)
3238 return;
3239
4bac9ae4
CS		 3240 if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv)) {
3241 SvTEMP_off(sv); /* if it's still magical, this value isn't temporary */
f8c7b90f 3242#ifdef PERL_OLD_COPY_ON_WRITE
f9701176
NC		 3243 /* While magic was saved (and off) sv_setsv may well have seen
3244 this SV as a prime candidate for COW. */
3245 if (SvIsCOW(sv))
e424a81e 3246 sv_force_normal_flags(sv, 0);
f9701176 3247#endif
f9c6fee5
CS		 3248 if (mgs->mgs_readonly)
3249 SvREADONLY_on(sv);
3250 if (mgs->mgs_magical)
3251 SvFLAGS(sv) |= mgs->mgs_magical;
51371543
GS		 3252 else
3253 mg_magical(sv);
51371543
GS		 3254 }
3255
150b625d 3256 bumped = mgs->mgs_bumped;
51371543
GS		 3257 mgs->mgs_sv = NULL; /* mark the MGS structure as restored */
3258
3259 /* If we're still on top of the stack, pop us off. (That condition
3260 * will be satisfied if restore_magic was called explicitly, but *not*
3261 * if it's being called via leave_scope.)
3262 * The reason for doing this is that otherwise, things like sv_2cv()
3263 * may leave alloc gunk on the savestack, and some code
3264 * (e.g. sighandler) doesn't expect that...
3265 */
3266 if (PL_savestack_ix == mgs->mgs_ss_ix)
3267 {
1be36ce0
NC		 3268 UV popval = SSPOPUV;
3269 assert(popval == SAVEt_DESTRUCTOR_X);
51371543 3270 PL_savestack_ix -= 2;
1be36ce0
NC		 3271 popval = SSPOPUV;
3272 assert((popval & SAVE_MASK) == SAVEt_ALLOC);
3273 PL_savestack_ix -= popval >> SAVE_TIGHT_SHIFT;
51371543 3274 }
150b625d
DM		 3275 if (bumped) {
3276 if (SvREFCNT(sv) == 1) {
3277 /* We hold the last reference to this SV, which implies that the
3278 SV was deleted as a side effect of the routines we called.
3279 So artificially keep it alive a bit longer.
3280 We avoid turning on the TEMP flag, which can cause the SV's
3281 buffer to get stolen (and maybe other stuff). */
150b625d 3282 sv_2mortal(sv);
4bac9ae4 3283 SvTEMP_off(sv);
8985fe98 3284 }
150b625d 3285 else
2357bae7 3286 SvREFCNT_dec_NN(sv); /* undo the inc in S_save_magic() */
8985fe98 3287 }
51371543
GS		 3288}
3289
0c4d3b5e
DM		 3290/* clean up the mess created by Perl_sighandler().
3291 * Note that this is only called during an exit in a signal handler;
3292 * a die is trapped by the call_sv() and the SAVEDESTRUCTOR_X manually
9a7f166c 3293 * skipped over. */
0c4d3b5e 3294
51371543 3295static void
8772537c 3296S_unwind_handler_stack(pTHX_ const void *p)
51371543 3297{
0c4d3b5e 3298 PERL_UNUSED_ARG(p);
7918f24d 3299
0c4d3b5e 3300 PL_savestack_ix -= 5; /* Unprotect save in progress. */
51371543 3301}
1018e26f 3302
66610fdd 3303/*
b3ca2e83
NC		 3304=for apidoc magic_sethint
3305
3306Triggered by a store to %^H, records the key/value pair to
c28fe1ec
NC		 3307C<PL_compiling.cop_hints_hash>. It is assumed that hints aren't storing
3308anything that would need a deep copy. Maybe we should warn if we find a
3309reference.
b3ca2e83
NC		 3310
3311=cut
3312*/
3313int
3314Perl_magic_sethint(pTHX_ SV *sv, MAGIC *mg)
3315{
ad64d0ec 3316 SV *key = (mg->mg_len == HEf_SVKEY) ? MUTABLE_SV(mg->mg_ptr)
59cd0e26 3317 : newSVpvn_flags(mg->mg_ptr, mg->mg_len, SVs_TEMP);
b3ca2e83 3318
7918f24d
NC		 3319 PERL_ARGS_ASSERT_MAGIC_SETHINT;
3320
e6e3e454
NC		 3321 /* mg->mg_obj isn't being used. If needed, it would be possible to store
3322 an alternative leaf in there, with PL_compiling.cop_hints being used if
3323 it's NULL. If needed for threads, the alternative could lock a mutex,
3324 or take other more complex action. */
3325
5b9c0671
NC		 3326 /* Something changed in %^H, so it will need to be restored on scope exit.
3327 Doing this here saves a lot of doing it manually in perl code (and
3328 forgetting to do it, and consequent subtle errors. */
3329 PL_hints |= HINT_LOCALIZE_HH;
20439bc7
Z		 3330 CopHINTHASH_set(&PL_compiling,
3331 cophh_store_sv(CopHINTHASH_get(&PL_compiling), key, 0, sv, 0));
b3ca2e83
NC		 3332 return 0;
3333}
3334
3335/*
f175cff5 3336=for apidoc magic_clearhint
b3ca2e83 3337
c28fe1ec
NC		 3338Triggered by a delete from %^H, records the key to
3339C<PL_compiling.cop_hints_hash>.
b3ca2e83
NC		 3340
3341=cut
3342*/
3343int
3344Perl_magic_clearhint(pTHX_ SV *sv, MAGIC *mg)
3345{
7918f24d 3346 PERL_ARGS_ASSERT_MAGIC_CLEARHINT;
f5a63d97
AL		 3347 PERL_UNUSED_ARG(sv);
3348
5b9c0671 3349 PL_hints |= HINT_LOCALIZE_HH;
20439bc7 3350 CopHINTHASH_set(&PL_compiling,
e3352591
FC		 3351 mg->mg_len == HEf_SVKEY
3352 ? cophh_delete_sv(CopHINTHASH_get(&PL_compiling),
3353 MUTABLE_SV(mg->mg_ptr), 0, 0)
3354 : cophh_delete_pvn(CopHINTHASH_get(&PL_compiling),
3355 mg->mg_ptr, mg->mg_len, 0, 0));
b3ca2e83
NC		 3356 return 0;
3357}
3358
3359/*
f747ebd6
Z		 3360=for apidoc magic_clearhints
3361
3362Triggered by clearing %^H, resets C<PL_compiling.cop_hints_hash>.
3363
3364=cut
3365*/
3366int
3367Perl_magic_clearhints(pTHX_ SV *sv, MAGIC *mg)
3368{
3369 PERL_ARGS_ASSERT_MAGIC_CLEARHINTS;
3370 PERL_UNUSED_ARG(sv);
3371 PERL_UNUSED_ARG(mg);
20439bc7
Z		 3372 cophh_free(CopHINTHASH_get(&PL_compiling));
3373 CopHINTHASH_set(&PL_compiling, cophh_new_empty());
f747ebd6
Z		 3374 return 0;
3375}
3376
09fb282d
FC		 3377int
3378Perl_magic_copycallchecker(pTHX_ SV *sv, MAGIC *mg, SV *nsv,
3379 const char *name, I32 namlen)
3380{
3381 MAGIC *nmg;
3382
3383 PERL_ARGS_ASSERT_MAGIC_COPYCALLCHECKER;
4f8dbb2d 3384 PERL_UNUSED_ARG(sv);
09fb282d
FC		 3385 PERL_UNUSED_ARG(name);
3386 PERL_UNUSED_ARG(namlen);
3387
3388 sv_magic(nsv, &PL_sv_undef, mg->mg_type, NULL, 0);
3389 nmg = mg_find(nsv, mg->mg_type);
316ebaf2 3390 assert(nmg);
09fb282d
FC		 3391 if (nmg->mg_flags & MGf_REFCOUNTED) SvREFCNT_dec(nmg->mg_obj);
3392 nmg->mg_ptr = mg->mg_ptr;
3393 nmg->mg_obj = SvREFCNT_inc_simple(mg->mg_obj);
3394 nmg->mg_flags |= MGf_REFCOUNTED;
3395 return 1;
3396}
3397
f747ebd6 3398/*
66610fdd
RGS		 3399 * Local variables:
3400 * c-indentation-style: bsd
3401 * c-basic-offset: 4
14d04a33 3402 * indent-tabs-mode: nil
66610fdd
RGS		 3403 * End:
3404 *
14d04a33 3405 * ex: set ts=8 sts=4 sw=4 et:
37442d52 3406 */
Unnamed repository; edit this file 'description' to name the repository.