This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Avoid reifing GVs in gv.c:gv_try_downgrade
[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
PP
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
PP
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
SM
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
PP
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
PP
1180 int i = 0, j = 0;
1181
6fca0082 1182 my_strlcpy(eltbuf, s, sizeof(eltbuf));
b8ffc8df 1183 elt = eltbuf;
1e422769
PP
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
PP
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
PP
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
PP
1259 I32 keylen;
1260 my_setenv(hv_iterkey(entry, &keylen),
85fbaab2 1261 SvPV_nolen_const(hv_iterval(MUTABLE_HV(sv), entry)));
fb73857a
PP
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
PP
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
PP
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
d1d7a15d
NC
1762 SAVESPTR(PL_stderrgv);
1763 PL_stderrgv = NULL;
1764 }
1765
efaf3674 1766 PUSHSTACKi(PERLSI_MAGIC);
924508f0 1767 PUSHMARK(SP);
efaf3674 1768
67549bd2
NC
1769 EXTEND(SP, argc+1);
1770 PUSHs(SvTIED_obj(sv, mg));
1771 if (flags & G_UNDEF_FILL) {
1772 while (argc--) {
efaf3674 1773 PUSHs(&PL_sv_undef);
93965878 1774 }
67549bd2 1775 } else if (argc > 0) {
046b0c7d
NC
1776 va_list args;
1777 va_start(args, argc);
1778
1779 do {
1780 SV *const sv = va_arg(args, SV *);
1781 PUSHs(sv);
1782 } while (--argc);
1783
1784 va_end(args);
88e89b8a 1785 }
463ee0b2 1786 PUTBACK;
efaf3674 1787 if (flags & G_DISCARD) {
36925d9e 1788 call_sv(meth, G_SCALAR|G_DISCARD|G_METHOD_NAMED);
efaf3674
DM
1789 }
1790 else {
36925d9e 1791 if (call_sv(meth, G_SCALAR|G_METHOD_NAMED))
efaf3674
DM
1792 ret = *PL_stack_sp--;
1793 }
1794 POPSTACK;
d1d7a15d
NC
1795 if (flags & G_WRITING_TO_STDERR)
1796 FREETMPS;
efaf3674
DM
1797 LEAVE;
1798 return ret;
1799}
1800
efaf3674 1801/* wrapper for magic_methcall that creates the first arg */
463ee0b2 1802
efaf3674 1803STATIC SV*
36925d9e 1804S_magic_methcall1(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags,
efaf3674
DM
1805 int n, SV *val)
1806{
efaf3674
DM
1807 SV* arg1 = NULL;
1808
1809 PERL_ARGS_ASSERT_MAGIC_METHCALL1;
1810
1811 if (mg->mg_ptr) {
1812 if (mg->mg_len >= 0) {
db4b3a1d 1813 arg1 = newSVpvn_flags(mg->mg_ptr, mg->mg_len, SVs_TEMP);
efaf3674
DM
1814 }
1815 else if (mg->mg_len == HEf_SVKEY)
1816 arg1 = MUTABLE_SV(mg->mg_ptr);
1817 }
1818 else if (mg->mg_type == PERL_MAGIC_tiedelem) {
db4b3a1d 1819 arg1 = newSViv((IV)(mg->mg_len));
efaf3674
DM
1820 sv_2mortal(arg1);
1821 }
1822 if (!arg1) {
046b0c7d 1823 return Perl_magic_methcall(aTHX_ sv, mg, meth, flags, n - 1, val);
efaf3674 1824 }
046b0c7d 1825 return Perl_magic_methcall(aTHX_ sv, mg, meth, flags, n, arg1, val);
946ec16e
PP
1826}
1827
76e3520e 1828STATIC int
36925d9e 1829S_magic_methpack(pTHX_ SV *sv, const MAGIC *mg, SV *meth)
a0d0e21e 1830{
efaf3674 1831 SV* ret;
463ee0b2 1832
7918f24d
NC
1833 PERL_ARGS_ASSERT_MAGIC_METHPACK;
1834
efaf3674
DM
1835 ret = magic_methcall1(sv, mg, meth, 0, 1, NULL);
1836 if (ret)
1837 sv_setsv(sv, ret);
a0d0e21e
LW
1838 return 0;
1839}
463ee0b2 1840
a0d0e21e 1841int
864dbfa3 1842Perl_magic_getpack(pTHX_ SV *sv, MAGIC *mg)
a0d0e21e 1843{
7918f24d
NC
1844 PERL_ARGS_ASSERT_MAGIC_GETPACK;
1845
fd69380d 1846 if (mg->mg_type == PERL_MAGIC_tiedelem)
a0d0e21e 1847 mg->mg_flags |= MGf_GSKIP;
36925d9e 1848 magic_methpack(sv,mg,SV_CONST(FETCH));
463ee0b2
LW
1849 return 0;
1850}
1851
1852int
864dbfa3 1853Perl_magic_setpack(pTHX_ SV *sv, MAGIC *mg)
e336de0d 1854{
b112cff9
DM
1855 MAGIC *tmg;
1856 SV *val;
7918f24d
NC
1857
1858 PERL_ARGS_ASSERT_MAGIC_SETPACK;
1859
b112cff9
DM
1860 /* in the code C<$tied{foo} = $val>, the "thing" that gets passed to
1861 * STORE() is not $val, but rather a PVLV (the sv in this call), whose
1862 * public flags indicate its value based on copying from $val. Doing
1863 * mg_set() on the PVLV temporarily does SvMAGICAL_off(), then calls us.
1864 * So STORE()'s $_[2] arg is a temporarily disarmed PVLV. This goes
1865 * wrong if $val happened to be tainted, as sv hasn't got magic
1866 * enabled, even though taint magic is in the chain. In which case,
1867 * fake up a temporary tainted value (this is easier than temporarily
1868 * re-enabling magic on sv). */
1869
284167a5 1870 if (TAINTING_get && (tmg = mg_find(sv, PERL_MAGIC_taint))
b112cff9
DM
1871 && (tmg->mg_len & 1))
1872 {
1873 val = sv_mortalcopy(sv);
1874 SvTAINTED_on(val);
1875 }
1876 else
1877 val = sv;
1878
36925d9e 1879 magic_methcall1(sv, mg, SV_CONST(STORE), G_DISCARD, 2, val);
463ee0b2
LW
1880 return 0;
1881}
1882
1883int
864dbfa3 1884Perl_magic_clearpack(pTHX_ SV *sv, MAGIC *mg)
463ee0b2 1885{
7918f24d
NC
1886 PERL_ARGS_ASSERT_MAGIC_CLEARPACK;
1887
4c13be3f 1888 if (mg->mg_type == PERL_MAGIC_tiedscalar) return 0;
36925d9e 1889 return magic_methpack(sv,mg,SV_CONST(DELETE));
a0d0e21e 1890}
463ee0b2 1891
93965878
NIS
1892
1893U32
864dbfa3 1894Perl_magic_sizepack(pTHX_ SV *sv, MAGIC *mg)
ac27b0f5 1895{
22846ab4 1896 I32 retval = 0;
efaf3674 1897 SV* retsv;
93965878 1898
7918f24d
NC
1899 PERL_ARGS_ASSERT_MAGIC_SIZEPACK;
1900
36925d9e 1901 retsv = magic_methcall1(sv, mg, SV_CONST(FETCHSIZE), 0, 1, NULL);
efaf3674
DM
1902 if (retsv) {
1903 retval = SvIV(retsv)-1;
22846ab4
AB
1904 if (retval < -1)
1905 Perl_croak(aTHX_ "FETCHSIZE returned a negative value");
93965878 1906 }
22846ab4 1907 return (U32) retval;
93965878
NIS
1908}
1909
cea2e8a9
GS
1910int
1911Perl_magic_wipepack(pTHX_ SV *sv, MAGIC *mg)
a0d0e21e 1912{
7918f24d
NC
1913 PERL_ARGS_ASSERT_MAGIC_WIPEPACK;
1914
36925d9e 1915 Perl_magic_methcall(aTHX_ sv, mg, SV_CONST(CLEAR), G_DISCARD, 0);
463ee0b2
LW
1916 return 0;
1917}
1918
1919int
864dbfa3 1920Perl_magic_nextpack(pTHX_ SV *sv, MAGIC *mg, SV *key)
463ee0b2 1921{
efaf3674 1922 SV* ret;
463ee0b2 1923
7918f24d
NC
1924 PERL_ARGS_ASSERT_MAGIC_NEXTPACK;
1925
36925d9e
RZ
1926 ret = SvOK(key) ? Perl_magic_methcall(aTHX_ sv, mg, SV_CONST(NEXTKEY), 0, 1, key)
1927 : Perl_magic_methcall(aTHX_ sv, mg, SV_CONST(FIRSTKEY), 0, 0);
efaf3674
DM
1928 if (ret)
1929 sv_setsv(key,ret);
79072805
LW
1930 return 0;
1931}
1932
1933int
1146e912 1934Perl_magic_existspack(pTHX_ SV *sv, const MAGIC *mg)
a0d0e21e 1935{
7918f24d
NC
1936 PERL_ARGS_ASSERT_MAGIC_EXISTSPACK;
1937
36925d9e 1938 return magic_methpack(sv,mg,SV_CONST(EXISTS));
ac27b0f5 1939}
a0d0e21e 1940
a3bcc51e
TP
1941SV *
1942Perl_magic_scalarpack(pTHX_ HV *hv, MAGIC *mg)
1943{
5fcbf73d 1944 SV *retval;
ad64d0ec
NC
1945 SV * const tied = SvTIED_obj(MUTABLE_SV(hv), mg);
1946 HV * const pkg = SvSTASH((const SV *)SvRV(tied));
a3bcc51e 1947
7918f24d
NC
1948 PERL_ARGS_ASSERT_MAGIC_SCALARPACK;
1949
a3bcc51e
TP
1950 if (!gv_fetchmethod_autoload(pkg, "SCALAR", FALSE)) {
1951 SV *key;
bfcb3514 1952 if (HvEITER_get(hv))
a3bcc51e
TP
1953 /* we are in an iteration so the hash cannot be empty */
1954 return &PL_sv_yes;
1955 /* no xhv_eiter so now use FIRSTKEY */
1956 key = sv_newmortal();
ad64d0ec 1957 magic_nextpack(MUTABLE_SV(hv), mg, key);
bfcb3514 1958 HvEITER_set(hv, NULL); /* need to reset iterator */
a3bcc51e
TP
1959 return SvOK(key) ? &PL_sv_yes : &PL_sv_no;
1960 }
1961
1962 /* there is a SCALAR method that we can call */
36925d9e 1963 retval = Perl_magic_methcall(aTHX_ MUTABLE_SV(hv), mg, SV_CONST(SCALAR), 0, 0);
efaf3674 1964 if (!retval)
5fcbf73d 1965 retval = &PL_sv_undef;
a3bcc51e
TP
1966 return retval;
1967}
1968
a0d0e21e 1969int
864dbfa3 1970Perl_magic_setdbline(pTHX_ SV *sv, MAGIC *mg)
79072805 1971{
089b5c60 1972 SV **svp;
7918f24d
NC
1973
1974 PERL_ARGS_ASSERT_MAGIC_SETDBLINE;
1975
089b5c60
NC
1976 /* The magic ptr/len for the debugger's hash should always be an SV. */
1977 if (UNLIKELY(mg->mg_len != HEf_SVKEY)) {
1978 Perl_croak(aTHX_ "panic: magic_setdbline len=%"IVdf", ptr='%s'",
7b0eb0b8 1979 (IV)mg->mg_len, mg->mg_ptr);
089b5c60
NC
1980 }
1981
1982 /* Use sv_2iv instead of SvIV() as the former generates smaller code, and
1983 setting/clearing debugger breakpoints is not a hot path. */
43e4250a
FC
1984 svp = av_fetch(MUTABLE_AV(mg->mg_obj),
1985 sv_2iv(MUTABLE_SV((mg)->mg_ptr)), FALSE);
089b5c60 1986
8772537c 1987 if (svp && SvIOKp(*svp)) {
88df5f01
FC
1988 OP * const o = INT2PTR(OP*,SvIVX(*svp));
1989 if (o) {
1990#ifdef PERL_DEBUG_READONLY_OPS
1991 Slab_to_rw(OpSLAB(o));
1992#endif
1993 /* set or clear breakpoint in the relevant control op */
089b5c60 1994 if (SvTRUE(sv))
88df5f01 1995 o->op_flags |= OPf_SPECIAL;
8772537c 1996 else
88df5f01
FC
1997 o->op_flags &= ~OPf_SPECIAL;
1998#ifdef PERL_DEBUG_READONLY_OPS
1999 Slab_to_ro(OpSLAB(o));
2000#endif
8772537c 2001 }
5df8de69 2002 }
79072805
LW
2003 return 0;
2004}
2005
2006int
8772537c 2007Perl_magic_getarylen(pTHX_ SV *sv, const MAGIC *mg)
79072805 2008{
502c6561 2009 AV * const obj = MUTABLE_AV(mg->mg_obj);
7918f24d
NC
2010
2011 PERL_ARGS_ASSERT_MAGIC_GETARYLEN;
2012
83bf042f 2013 if (obj) {
e1dccc0d 2014 sv_setiv(sv, AvFILL(obj));
83bf042f 2015 } else {
d4a823b3 2016 sv_setsv(sv, NULL);
83bf042f 2017 }
79072805
LW
2018 return 0;
2019}
2020
2021int
864dbfa3 2022Perl_magic_setarylen(pTHX_ SV *sv, MAGIC *mg)
79072805 2023{
502c6561 2024 AV * const obj = MUTABLE_AV(mg->mg_obj);
7918f24d
NC
2025
2026 PERL_ARGS_ASSERT_MAGIC_SETARYLEN;
2027
83bf042f 2028 if (obj) {
e1dccc0d 2029 av_fill(obj, SvIV(sv));
83bf042f 2030 } else {
a2a5de95
NC
2031 Perl_ck_warner(aTHX_ packWARN(WARN_MISC),
2032 "Attempt to set length of freed array");
83bf042f
NC
2033 }
2034 return 0;
2035}
2036
2037int
83f29afa
VP
2038Perl_magic_cleararylen_p(pTHX_ SV *sv, MAGIC *mg)
2039{
83f29afa
VP
2040 PERL_ARGS_ASSERT_MAGIC_CLEARARYLEN_P;
2041 PERL_UNUSED_ARG(sv);
dc3bf405 2042 PERL_UNUSED_CONTEXT;
83f29afa
VP
2043
2044 /* Reset the iterator when the array is cleared */
3565fbf3
VP
2045#if IVSIZE == I32SIZE
2046 *((IV *) &(mg->mg_len)) = 0;
2047#else
83f29afa
VP
2048 if (mg->mg_ptr)
2049 *((IV *) mg->mg_ptr) = 0;
3565fbf3 2050#endif
83f29afa
VP
2051
2052 return 0;
2053}
2054
2055int
83bf042f
NC
2056Perl_magic_freearylen_p(pTHX_ SV *sv, MAGIC *mg)
2057{
7918f24d 2058 PERL_ARGS_ASSERT_MAGIC_FREEARYLEN_P;
53c1dcc0 2059 PERL_UNUSED_ARG(sv);
7918f24d 2060
94f3782b
DM
2061 /* during global destruction, mg_obj may already have been freed */
2062 if (PL_in_clean_all)
1ea47f64 2063 return 0;
94f3782b 2064
83bf042f
NC
2065 mg = mg_find (mg->mg_obj, PERL_MAGIC_arylen);
2066
2067 if (mg) {
2068 /* arylen scalar holds a pointer back to the array, but doesn't own a
2069 reference. Hence the we (the array) are about to go away with it
2070 still pointing at us. Clear its pointer, else it would be pointing
2071 at free memory. See the comment in sv_magic about reference loops,
2072 and why it can't own a reference to us. */
2073 mg->mg_obj = 0;
2074 }
a0d0e21e
LW
2075 return 0;
2076}
2077
2078int
864dbfa3 2079Perl_magic_getpos(pTHX_ SV *sv, MAGIC *mg)
a0d0e21e 2080{
16eb5365 2081 SV* const lsv = LvTARG(sv);
96c2a8ff 2082 MAGIC * const found = mg_find_mglob(lsv);
7918f24d
NC
2083
2084 PERL_ARGS_ASSERT_MAGIC_GETPOS;
16eb5365 2085 PERL_UNUSED_ARG(mg);
ac27b0f5 2086
6174b39a
FC
2087 if (found && found->mg_len != -1) {
2088 STRLEN i = found->mg_len;
25fdce4a 2089 if (found->mg_flags & MGf_BYTES && DO_UTF8(lsv))
6174b39a
FC
2090 i = sv_pos_b2u_flags(lsv, i, SV_GMAGIC|SV_CONST_RETURN);
2091 sv_setuv(sv, i);
a0d0e21e 2092 return 0;
a0d0e21e 2093 }
35995e5c 2094 sv_setsv(sv,NULL);
a0d0e21e
LW
2095 return 0;
2096}
2097
2098int
864dbfa3 2099Perl_magic_setpos(pTHX_ SV *sv, MAGIC *mg)
a0d0e21e 2100{
16eb5365 2101 SV* const lsv = LvTARG(sv);
a0d0e21e
LW
2102 SSize_t pos;
2103 STRLEN len;
c00206c8 2104 STRLEN ulen = 0;
53d44271 2105 MAGIC* found;
aec43834 2106 const char *s;
a0d0e21e 2107
7918f24d 2108 PERL_ARGS_ASSERT_MAGIC_SETPOS;
16eb5365 2109 PERL_UNUSED_ARG(mg);
ac27b0f5 2110
96c2a8ff 2111 found = mg_find_mglob(lsv);
3881461a 2112 if (!found) {
a0d0e21e
LW
2113 if (!SvOK(sv))
2114 return 0;
96c2a8ff 2115 found = sv_magicext_mglob(lsv);
a0d0e21e
LW
2116 }
2117 else if (!SvOK(sv)) {
3881461a 2118 found->mg_len = -1;
a0d0e21e
LW
2119 return 0;
2120 }
aec43834 2121 s = SvPV_const(lsv, len);
a0d0e21e 2122
e1dccc0d 2123 pos = SvIV(sv);
a0ed51b3 2124
7e2040f0 2125 if (DO_UTF8(lsv)) {
aec43834 2126 ulen = sv_or_pv_len_utf8(lsv, s, len);
a0ed51b3
LW
2127 if (ulen)
2128 len = ulen;
a0ed51b3
LW
2129 }
2130
a0d0e21e
LW
2131 if (pos < 0) {
2132 pos += len;
2133 if (pos < 0)
2134 pos = 0;
2135 }
eb160463 2136 else if (pos > (SSize_t)len)
a0d0e21e 2137 pos = len;
a0ed51b3 2138
3881461a 2139 found->mg_len = pos;
25fdce4a 2140 found->mg_flags &= ~(MGf_MINMATCH|MGf_BYTES);
a0d0e21e 2141
79072805
LW
2142 return 0;
2143}
2144
2145int
864dbfa3 2146Perl_magic_getsubstr(pTHX_ SV *sv, MAGIC *mg)
6ff81951
GS
2147{
2148 STRLEN len;
35a4481c 2149 SV * const lsv = LvTARG(sv);
b83604b4 2150 const char * const tmps = SvPV_const(lsv,len);
777f7c56
EB
2151 STRLEN offs = LvTARGOFF(sv);
2152 STRLEN rem = LvTARGLEN(sv);
83f78d1a
FC
2153 const bool negoff = LvFLAGS(sv) & 1;
2154 const bool negrem = LvFLAGS(sv) & 2;
7918f24d
NC
2155
2156 PERL_ARGS_ASSERT_MAGIC_GETSUBSTR;
8772537c 2157 PERL_UNUSED_ARG(mg);
6ff81951 2158
83f78d1a 2159 if (!translate_substr_offsets(
4ddea69a 2160 SvUTF8(lsv) ? sv_or_pv_len_utf8(lsv, tmps, len) : len,
83f78d1a
FC
2161 negoff ? -(IV)offs : (IV)offs, !negoff,
2162 negrem ? -(IV)rem : (IV)rem, !negrem, &offs, &rem
2163 )) {
2164 Perl_ck_warner(aTHX_ packWARN(WARN_SUBSTR), "substr outside of string");
2165 sv_setsv_nomg(sv, &PL_sv_undef);
2166 return 0;
2167 }
2168
9aa983d2 2169 if (SvUTF8(lsv))
4ddea69a 2170 offs = sv_or_pv_pos_u2b(lsv, tmps, offs, &rem);
1c900557 2171 sv_setpvn(sv, tmps + offs, rem);
9aa983d2 2172 if (SvUTF8(lsv))
2ef4b674 2173 SvUTF8_on(sv);
6ff81951
GS
2174 return 0;
2175}
2176
2177int
864dbfa3 2178Perl_magic_setsubstr(pTHX_ SV *sv, MAGIC *mg)
79072805 2179{
83f78d1a 2180 STRLEN len, lsv_len, oldtarglen, newtarglen;
5fcbf73d 2181 const char * const tmps = SvPV_const(sv, len);
dd374669 2182 SV * const lsv = LvTARG(sv);
777f7c56
EB
2183 STRLEN lvoff = LvTARGOFF(sv);
2184 STRLEN lvlen = LvTARGLEN(sv);
83f78d1a
FC
2185 const bool negoff = LvFLAGS(sv) & 1;
2186 const bool neglen = LvFLAGS(sv) & 2;
7918f24d
NC
2187
2188 PERL_ARGS_ASSERT_MAGIC_SETSUBSTR;
8772537c 2189 PERL_UNUSED_ARG(mg);
075a4a2b 2190
a74fb2cd
FC
2191 SvGETMAGIC(lsv);
2192 if (SvROK(lsv))
2193 Perl_ck_warner(aTHX_ packWARN(WARN_SUBSTR),
2194 "Attempt to use reference as lvalue in substr"
2195 );
fc061ed8
FC
2196 SvPV_force_nomg(lsv,lsv_len);
2197 if (SvUTF8(lsv)) lsv_len = sv_len_utf8_nomg(lsv);
83f78d1a
FC
2198 if (!translate_substr_offsets(
2199 lsv_len,
2200 negoff ? -(IV)lvoff : (IV)lvoff, !negoff,
2201 neglen ? -(IV)lvlen : (IV)lvlen, !neglen, &lvoff, &lvlen
2202 ))
2203 Perl_croak(aTHX_ "substr outside of string");
2204 oldtarglen = lvlen;
1aa99e6b 2205 if (DO_UTF8(sv)) {
73a087f0 2206 sv_utf8_upgrade_nomg(lsv);
d931b1be 2207 lvoff = sv_pos_u2b_flags(lsv, lvoff, &lvlen, SV_CONST_RETURN);
a74fb2cd 2208 sv_insert_flags(lsv, lvoff, lvlen, tmps, len, 0);
7a385470 2209 newtarglen = sv_or_pv_len_utf8(sv, tmps, len);
9aa983d2
JH
2210 SvUTF8_on(lsv);
2211 }
0d336106 2212 else if (SvUTF8(lsv)) {
5fcbf73d 2213 const char *utf8;
d931b1be 2214 lvoff = sv_pos_u2b_flags(lsv, lvoff, &lvlen, SV_CONST_RETURN);
83f78d1a 2215 newtarglen = len;
5fcbf73d 2216 utf8 = (char*)bytes_to_utf8((U8*)tmps, &len);
a74fb2cd 2217 sv_insert_flags(lsv, lvoff, lvlen, utf8, len, 0);
5fcbf73d 2218 Safefree(utf8);
1aa99e6b 2219 }
b76f3ce2 2220 else {
a74fb2cd 2221 sv_insert_flags(lsv, lvoff, lvlen, tmps, len, 0);
83f78d1a 2222 newtarglen = len;
b76f3ce2 2223 }
83f78d1a
FC
2224 if (!neglen) LvTARGLEN(sv) = newtarglen;
2225 if (negoff) LvTARGOFF(sv) += newtarglen - oldtarglen;
b76f3ce2 2226
79072805
LW
2227 return 0;
2228}
2229
2230int
864dbfa3 2231Perl_magic_gettaint(pTHX_ SV *sv, MAGIC *mg)
463ee0b2 2232{
7918f24d 2233 PERL_ARGS_ASSERT_MAGIC_GETTAINT;
8772537c 2234 PERL_UNUSED_ARG(sv);
9a9b5ec9
DM
2235#ifdef NO_TAINT_SUPPORT
2236 PERL_UNUSED_ARG(mg);
2237#endif
7918f24d 2238
64ff300b 2239 TAINT_IF((PL_localizing != 1) && (mg->mg_len & 1) && IN_PERL_RUNTIME);
463ee0b2
LW
2240 return 0;
2241}
2242
2243int
864dbfa3 2244Perl_magic_settaint(pTHX_ SV *sv, MAGIC *mg)
463ee0b2 2245{
7918f24d 2246 PERL_ARGS_ASSERT_MAGIC_SETTAINT;
8772537c 2247 PERL_UNUSED_ARG(sv);
7918f24d 2248
b01e650a 2249 /* update taint status */
284167a5 2250 if (TAINT_get)
b01e650a
DM
2251 mg->mg_len |= 1;
2252 else
2253 mg->mg_len &= ~1;
463ee0b2
LW
2254 return 0;
2255}
2256
2257int
864dbfa3 2258Perl_magic_getvec(pTHX_ SV *sv, MAGIC *mg)
6ff81951 2259{
35a4481c 2260 SV * const lsv = LvTARG(sv);
7918f24d
NC
2261
2262 PERL_ARGS_ASSERT_MAGIC_GETVEC;
8772537c 2263 PERL_UNUSED_ARG(mg);
6ff81951 2264
2e9e14dd 2265 sv_setuv(sv, do_vecget(lsv, LvTARGOFF(sv), LvTARGLEN(sv)));
6ff81951 2266
6ff81951
GS
2267 return 0;
2268}
2269
2270int
864dbfa3 2271Perl_magic_setvec(pTHX_ SV *sv, MAGIC *mg)
79072805 2272{
7918f24d 2273 PERL_ARGS_ASSERT_MAGIC_SETVEC;
8772537c 2274 PERL_UNUSED_ARG(mg);
79072805
LW
2275 do_vecset(sv); /* XXX slurp this routine */
2276 return 0;
2277}
2278
13733cde
FC
2279SV *
2280Perl_defelem_target(pTHX_ SV *sv, MAGIC *mg)
5f05dabc 2281{
a0714e2c 2282 SV *targ = NULL;
13733cde
FC
2283 PERL_ARGS_ASSERT_DEFELEM_TARGET;
2284 if (!mg) mg = mg_find(sv, PERL_MAGIC_defelem);
2285 assert(mg);
5f05dabc 2286 if (LvTARGLEN(sv)) {
68dc0745 2287 if (mg->mg_obj) {
8772537c 2288 SV * const ahv = LvTARG(sv);
85fbaab2 2289 HE * const he = hv_fetch_ent(MUTABLE_HV(ahv), mg->mg_obj, FALSE, 0);
6d822dc4
MS
2290 if (he)
2291 targ = HeVAL(he);
68dc0745 2292 }
bbfdc870 2293 else if (LvSTARGOFF(sv) >= 0) {
502c6561 2294 AV *const av = MUTABLE_AV(LvTARG(sv));
bbfdc870 2295 if (LvSTARGOFF(sv) <= AvFILL(av))
ca58dfd9
FC
2296 {
2297 if (SvRMAGICAL(av)) {
2298 SV * const * const svp = av_fetch(av, LvSTARGOFF(sv), 0);
2299 targ = svp ? *svp : NULL;
2300 }
2301 else
bbfdc870 2302 targ = AvARRAY(av)[LvSTARGOFF(sv)];
ca58dfd9 2303 }
68dc0745 2304 }
46da273f 2305 if (targ && (targ != &PL_sv_undef)) {
68dc0745
PP
2306 /* somebody else defined it for us */
2307 SvREFCNT_dec(LvTARG(sv));
b37c2d43 2308 LvTARG(sv) = SvREFCNT_inc_simple_NN(targ);
68dc0745
PP
2309 LvTARGLEN(sv) = 0;
2310 SvREFCNT_dec(mg->mg_obj);
a0714e2c 2311 mg->mg_obj = NULL;
68dc0745
PP
2312 mg->mg_flags &= ~MGf_REFCOUNTED;
2313 }
13733cde 2314 return targ;
5f05dabc 2315 }
71be2cbc 2316 else
13733cde
FC
2317 return LvTARG(sv);
2318}
2319
2320int
2321Perl_magic_getdefelem(pTHX_ SV *sv, MAGIC *mg)
2322{
2323 PERL_ARGS_ASSERT_MAGIC_GETDEFELEM;
2324
2325 sv_setsv(sv, defelem_target(sv, mg));
71be2cbc
PP
2326 return 0;
2327}
2328
2329int
864dbfa3 2330Perl_magic_setdefelem(pTHX_ SV *sv, MAGIC *mg)
71be2cbc 2331{
7918f24d 2332 PERL_ARGS_ASSERT_MAGIC_SETDEFELEM;
8772537c 2333 PERL_UNUSED_ARG(mg);
71be2cbc 2334 if (LvTARGLEN(sv))
68dc0745
PP
2335 vivify_defelem(sv);
2336 if (LvTARG(sv)) {
5f05dabc 2337 sv_setsv(LvTARG(sv), sv);
68dc0745
PP
2338 SvSETMAGIC(LvTARG(sv));
2339 }
5f05dabc
PP
2340 return 0;
2341}
2342
71be2cbc 2343void
864dbfa3 2344Perl_vivify_defelem(pTHX_ SV *sv)
71be2cbc 2345{
74e13ce4 2346 MAGIC *mg;
a0714e2c 2347 SV *value = NULL;
71be2cbc 2348
7918f24d
NC
2349 PERL_ARGS_ASSERT_VIVIFY_DEFELEM;
2350
14befaf4 2351 if (!LvTARGLEN(sv) || !(mg = mg_find(sv, PERL_MAGIC_defelem)))
71be2cbc 2352 return;
68dc0745 2353 if (mg->mg_obj) {
8772537c 2354 SV * const ahv = LvTARG(sv);
85fbaab2 2355 HE * const he = hv_fetch_ent(MUTABLE_HV(ahv), mg->mg_obj, TRUE, 0);
6d822dc4
MS
2356 if (he)
2357 value = HeVAL(he);
3280af22 2358 if (!value || value == &PL_sv_undef)
be2597df 2359 Perl_croak(aTHX_ PL_no_helem_sv, SVfARG(mg->mg_obj));
71be2cbc 2360 }
bbfdc870
FC
2361 else if (LvSTARGOFF(sv) < 0)
2362 Perl_croak(aTHX_ PL_no_aelem, LvSTARGOFF(sv));
68dc0745 2363 else {
502c6561 2364 AV *const av = MUTABLE_AV(LvTARG(sv));
bbfdc870 2365 if ((I32)LvTARGLEN(sv) < 0 && LvSTARGOFF(sv) > AvFILL(av))
a0714e2c 2366 LvTARG(sv) = NULL; /* array can't be extended */
68dc0745 2367 else {
bbfdc870 2368 SV* const * const svp = av_fetch(av, LvSTARGOFF(sv), TRUE);
031c6d82 2369 if (!svp || !(value = *svp))
bbfdc870 2370 Perl_croak(aTHX_ PL_no_aelem, LvSTARGOFF(sv));
68dc0745
PP
2371 }
2372 }
b37c2d43 2373 SvREFCNT_inc_simple_void(value);
68dc0745
PP
2374 SvREFCNT_dec(LvTARG(sv));
2375 LvTARG(sv) = value;
71be2cbc 2376 LvTARGLEN(sv) = 0;
68dc0745 2377 SvREFCNT_dec(mg->mg_obj);
a0714e2c 2378 mg->mg_obj = NULL;
68dc0745 2379 mg->mg_flags &= ~MGf_REFCOUNTED;
5f05dabc
PP
2380}
2381
2382int
864dbfa3 2383Perl_magic_killbackrefs(pTHX_ SV *sv, MAGIC *mg)
810b8aa5 2384{
7918f24d 2385 PERL_ARGS_ASSERT_MAGIC_KILLBACKREFS;
5648c0ae
DM
2386 Perl_sv_kill_backrefs(aTHX_ sv, MUTABLE_AV(mg->mg_obj));
2387 return 0;
810b8aa5
GS
2388}
2389
2390int
864dbfa3 2391Perl_magic_setmglob(pTHX_ SV *sv, MAGIC *mg)
93a17b20 2392{
7918f24d 2393 PERL_ARGS_ASSERT_MAGIC_SETMGLOB;
96a5add6 2394 PERL_UNUSED_CONTEXT;
0177730e 2395 PERL_UNUSED_ARG(sv);
565764a8 2396 mg->mg_len = -1;
93a17b20
LW
2397 return 0;
2398}
2399
2400int
864dbfa3 2401Perl_magic_setuvar(pTHX_ SV *sv, MAGIC *mg)
79072805 2402{
35a4481c 2403 const struct ufuncs * const uf = (struct ufuncs *)mg->mg_ptr;
79072805 2404
7918f24d
NC
2405 PERL_ARGS_ASSERT_MAGIC_SETUVAR;
2406
79072805 2407 if (uf && uf->uf_set)
24f81a43 2408 (*uf->uf_set)(aTHX_ uf->uf_index, sv);
79072805
LW
2409 return 0;
2410}
2411
c277df42 2412int
faf82a0b
AE
2413Perl_magic_setregexp(pTHX_ SV *sv, MAGIC *mg)
2414{
488344d2 2415 const char type = mg->mg_type;
7918f24d
NC
2416
2417 PERL_ARGS_ASSERT_MAGIC_SETREGEXP;
2418
488344d2
NC
2419 if (type == PERL_MAGIC_qr) {
2420 } else if (type == PERL_MAGIC_bm) {
2421 SvTAIL_off(sv);
2422 SvVALID_off(sv);
2423 } else {
2424 assert(type == PERL_MAGIC_fm);
488344d2
NC
2425 }
2426 return sv_unmagic(sv, type);
faf82a0b
AE
2427}
2428
7a4c00b4 2429#ifdef USE_LOCALE_COLLATE
79072805 2430int
864dbfa3 2431Perl_magic_setcollxfrm(pTHX_ SV *sv, MAGIC *mg)
bbce6d69 2432{
7918f24d
NC
2433 PERL_ARGS_ASSERT_MAGIC_SETCOLLXFRM;
2434
bbce6d69 2435 /*
838b5b74 2436 * RenE<eacute> Descartes said "I think not."
bbce6d69
PP
2437 * and vanished with a faint plop.
2438 */
96a5add6 2439 PERL_UNUSED_CONTEXT;
8772537c 2440 PERL_UNUSED_ARG(sv);
7a4c00b4
PP
2441 if (mg->mg_ptr) {
2442 Safefree(mg->mg_ptr);
2443 mg->mg_ptr = NULL;
565764a8 2444 mg->mg_len = -1;
7a4c00b4 2445 }
bbce6d69
PP
2446 return 0;
2447}
7a4c00b4 2448#endif /* USE_LOCALE_COLLATE */
bbce6d69 2449
7e8c5dac
HS
2450/* Just clear the UTF-8 cache data. */
2451int
2452Perl_magic_setutf8(pTHX_ SV *sv, MAGIC *mg)
2453{
7918f24d 2454 PERL_ARGS_ASSERT_MAGIC_SETUTF8;
96a5add6 2455 PERL_UNUSED_CONTEXT;
8772537c 2456 PERL_UNUSED_ARG(sv);
7e8c5dac 2457 Safefree(mg->mg_ptr); /* The mg_ptr holds the pos cache. */
3881461a 2458 mg->mg_ptr = NULL;
7e8c5dac
HS
2459 mg->mg_len = -1; /* The mg_len holds the len cache. */
2460 return 0;
2461}
2462
bbce6d69 2463int
864dbfa3 2464Perl_magic_set(pTHX_ SV *sv, MAGIC *mg)
79072805 2465{
20b7effb 2466#ifdef USE_ITHREADS
97aff369 2467 dVAR;
20b7effb 2468#endif
eb578fdb
KW
2469 const char *s;
2470 I32 paren;
2471 const REGEXP * rx;
79072805 2472 I32 i;
8990e307 2473 STRLEN len;
125b9982 2474 MAGIC *tmg;
2fdbfb4d 2475
7918f24d
NC
2476 PERL_ARGS_ASSERT_MAGIC_SET;
2477
e91d8259 2478 if (!mg->mg_ptr) {
960b831f 2479 paren = mg->mg_len;
1e05feb3 2480 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
e91d8259 2481 setparen_got_rx:
2fdbfb4d 2482 CALLREG_NUMBUF_STORE((REGEXP * const)rx,paren,sv);
1e05feb3 2483 } else {
2fdbfb4d
AB
2484 /* Croak with a READONLY error when a numbered match var is
2485 * set without a previous pattern match. Unless it's C<local $1>
2486 */
e91d8259 2487 croakparen:
2fdbfb4d 2488 if (!PL_localizing) {
cb077ed2 2489 Perl_croak_no_modify();
2fdbfb4d
AB
2490 }
2491 }
e91d8259
NC
2492 return 0;
2493 }
2494
2495 switch (*mg->mg_ptr) {
748a9306 2496 case '\001': /* ^A */
f2da823f
FC
2497 if (SvOK(sv)) sv_copypv(PL_bodytarget, sv);
2498 else SvOK_off(PL_bodytarget);
64eff8b7
DM
2499 FmLINES(PL_bodytarget) = 0;
2500 if (SvPOK(PL_bodytarget)) {
2501 char *s = SvPVX(PL_bodytarget);
2502 while ( ((s = strchr(s, '\n'))) ) {
2503 FmLINES(PL_bodytarget)++;
2504 s++;
2505 }
2506 }
125b9982 2507 /* mg_set() has temporarily made sv non-magical */
284167a5 2508 if (TAINTING_get) {
125b9982
NT
2509 if ((tmg = mg_find(sv,PERL_MAGIC_taint)) && tmg->mg_len & 1)
2510 SvTAINTED_on(PL_bodytarget);
2511 else
2512 SvTAINTED_off(PL_bodytarget);
2513 }
748a9306 2514 break;
49460fe6 2515 case '\003': /* ^C */
f2338a2e 2516 PL_minus_c = cBOOL(SvIV(sv));
49460fe6
NIS
2517 break;
2518
79072805 2519 case '\004': /* ^D */
b4ab917c 2520#ifdef DEBUGGING
b83604b4 2521 s = SvPV_nolen_const(sv);
ddcf8bc1 2522 PL_debug = get_debug_opts(&s, 0) | DEBUG_TOP_FLAG;
a58fb6f9
CS
2523 if (DEBUG_x_TEST || DEBUG_B_TEST)
2524 dump_all_perl(!DEBUG_B_TEST);
b4ab917c 2525#else
38ab35f8 2526 PL_debug = (SvIV(sv)) | DEBUG_TOP_FLAG;
b4ab917c 2527#endif
79072805 2528 break;
28f23441 2529 case '\005': /* ^E */
d0063567 2530 if (*(mg->mg_ptr+1) == '\0') {
e37778c2 2531#ifdef VMS
38ab35f8 2532 set_vaxc_errno(SvIV(sv));
e37778c2
NC
2533#else
2534# ifdef WIN32
d0063567 2535 SetLastError( SvIV(sv) );
e37778c2
NC
2536# else
2537# ifdef OS2
38ab35f8 2538 os2_setsyserrno(SvIV(sv));
e37778c2 2539# else
d0063567 2540 /* will anyone ever use this? */
38ab35f8 2541 SETERRNO(SvIV(sv), 4);
048c1ddf
IZ
2542# endif
2543# endif
22fae026 2544#endif
d0063567
DK
2545 }
2546 else if (strEQ(mg->mg_ptr+1, "NCODING")) {
ef8d46e8 2547 SvREFCNT_dec(PL_encoding);
d0063567
DK
2548 if (SvOK(sv) || SvGMAGICAL(sv)) {
2549 PL_encoding = newSVsv(sv);
2550 }
2551 else {
a0714e2c 2552 PL_encoding = NULL;
d0063567
DK
2553 }
2554 }
2555 break;
79072805 2556 case '\006': /* ^F */
38ab35f8 2557 PL_maxsysfd = SvIV(sv);
79072805 2558 break;
a0d0e21e 2559 case '\010': /* ^H */
38ab35f8 2560 PL_hints = SvIV(sv);
a0d0e21e 2561 break;
9d116dd7 2562 case '\011': /* ^I */ /* NOT \t in EBCDIC */
43c5f42d 2563 Safefree(PL_inplace);
bd61b366 2564 PL_inplace = SvOK(sv) ? savesvpv(sv) : NULL;
da78da6e 2565 break;
d9bad346
FC
2566 case '\016': /* ^N */
2567 if (PL_curpm && (rx = PM_GETRE(PL_curpm))
2568 && (paren = RX_LASTCLOSEPAREN(rx))) goto setparen_got_rx;
2569 goto croakparen;
28f23441 2570 case '\017': /* ^O */
ac27b0f5 2571 if (*(mg->mg_ptr+1) == '\0') {
43c5f42d 2572 Safefree(PL_osname);
bd61b366 2573 PL_osname = NULL;
3511154c
DM
2574 if (SvOK(sv)) {
2575 TAINT_PROPER("assigning to $^O");
2e0de35c 2576 PL_osname = savesvpv(sv);
3511154c 2577 }
ac27b0f5
NIS
2578 }
2579 else if (strEQ(mg->mg_ptr, "\017PEN")) {
8b850bd5
NC
2580 STRLEN len;
2581 const char *const start = SvPV(sv, len);
b54fc2b6 2582 const char *out = (const char*)memchr(start, '\0', len);
8b850bd5 2583 SV *tmp;
8b850bd5
NC
2584
2585
2586 PL_compiling.cop_hints |= HINT_LEXICAL_IO_IN | HINT_LEXICAL_IO_OUT;
f747ebd6 2587 PL_hints |= HINT_LEXICAL_IO_IN | HINT_LEXICAL_IO_OUT;
8b850bd5
NC
2588
2589 /* Opening for input is more common than opening for output, so
2590 ensure that hints for input are sooner on linked list. */
59cd0e26 2591 tmp = out ? newSVpvn_flags(out + 1, start + len - out - 1,
f747ebd6
Z
2592 SvUTF8(sv))
2593 : newSVpvs_flags("", SvUTF8(sv));
2594 (void)hv_stores(GvHV(PL_hintgv), "open>", tmp);
2595 mg_set(tmp);
8b850bd5 2596
f747ebd6
Z
2597 tmp = newSVpvn_flags(start, out ? (STRLEN)(out - start) : len,
2598 SvUTF8(sv));
2599 (void)hv_stores(GvHV(PL_hintgv), "open<", tmp);
2600 mg_set(tmp);
ac27b0f5 2601 }
28f23441 2602 break;
79072805 2603 case '\020': /* ^P */
2fdbfb4d
AB
2604 PL_perldb = SvIV(sv);
2605 if (PL_perldb && !PL_DBsingle)
2606 init_debugger();
9b9e0be4 2607 break;
79072805 2608 case '\024': /* ^T */
88e89b8a 2609#ifdef BIG_TIME
6b88bc9c 2610 PL_basetime = (Time_t)(SvNOK(sv) ? SvNVX(sv) : sv_2nv(sv));
88e89b8a 2611#else
38ab35f8 2612 PL_basetime = (Time_t)SvIV(sv);
88e89b8a 2613#endif
79072805 2614 break;
e07ea26a
NC
2615 case '\025': /* ^UTF8CACHE */
2616 if (strEQ(mg->mg_ptr+1, "TF8CACHE")) {
2617 PL_utf8cache = (signed char) sv_2iv(sv);
2618 }
2619 break;
fde18df1 2620 case '\027': /* ^W & $^WARNING_BITS */
4438c4b7
JH
2621 if (*(mg->mg_ptr+1) == '\0') {
2622 if ( ! (PL_dowarn & G_WARN_ALL_MASK)) {
38ab35f8 2623 i = SvIV(sv);
ac27b0f5 2624 PL_dowarn = (PL_dowarn & ~G_WARN_ON)
0453d815 2625 | (i ? G_WARN_ON : G_WARN_OFF) ;
4438c4b7 2626 }
599cee73 2627 }
0a378802 2628 else if (strEQ(mg->mg_ptr+1, "ARNING_BITS")) {
4438c4b7 2629 if ( ! (PL_dowarn & G_WARN_ALL_MASK)) {
7e4f0450
FC
2630 if (!SvPOK(sv)) {
2631 PL_compiling.cop_warnings = pWARN_STD;
d775746e
GS
2632 break;
2633 }
f4fc7782 2634 {
b5477537 2635 STRLEN len, i;
d3a7d8c7 2636 int accumulate = 0 ;
f4fc7782 2637 int any_fatals = 0 ;
b83604b4 2638 const char * const ptr = SvPV_const(sv, len) ;
f4fc7782
JH
2639 for (i = 0 ; i < len ; ++i) {
2640 accumulate |= ptr[i] ;
2641 any_fatals |= (ptr[i] & 0xAA) ;
2642 }
4243c432
NC
2643 if (!accumulate) {
2644 if (!specialWARN(PL_compiling.cop_warnings))
2645 PerlMemShared_free(PL_compiling.cop_warnings);
2646 PL_compiling.cop_warnings = pWARN_NONE;
2647 }
72dc9ed5 2648 /* Yuck. I can't see how to abstract this: */
2f3f0b56
KW
2649 else if (isWARN_on(
2650 ((STRLEN *)SvPV_nolen_const(sv)) - 1,
2651 WARN_ALL)
2652 && !any_fatals)
2653 {
4243c432
NC
2654 if (!specialWARN(PL_compiling.cop_warnings))
2655 PerlMemShared_free(PL_compiling.cop_warnings);
f4fc7782
JH
2656 PL_compiling.cop_warnings = pWARN_ALL;
2657 PL_dowarn |= G_WARN_ONCE ;
727405f8 2658 }
d3a7d8c7 2659 else {
72dc9ed5
NC
2660 STRLEN len;
2661 const char *const p = SvPV_const(sv, len);
2662
2663 PL_compiling.cop_warnings
8ee4cf24 2664 = Perl_new_warnings_bitfield(aTHX_ PL_compiling.cop_warnings,
72dc9ed5
NC
2665 p, len);
2666
d3a7d8c7
GS
2667 if (isWARN_on(PL_compiling.cop_warnings, WARN_ONCE))
2668 PL_dowarn |= G_WARN_ONCE ;
2669 }
f4fc7782 2670
d3a7d8c7 2671 }
4438c4b7 2672 }
971a9dd3 2673 }
79072805
LW
2674 break;
2675 case '.':
3280af22
NIS
2676 if (PL_localizing) {
2677 if (PL_localizing == 1)
7766f137 2678 SAVESPTR(PL_last_in_gv);
748a9306 2679 }
3280af22 2680 else if (SvOK(sv) && GvIO(PL_last_in_gv))
632db599 2681 IoLINES(GvIOp(PL_last_in_gv)) = SvIV(sv);
79072805
LW
2682 break;
2683 case '^':
acbe1b9d
FC
2684 Safefree(IoTOP_NAME(GvIOp(PL_defoutgv)));
2685 s = IoTOP_NAME(GvIOp(PL_defoutgv)) = savesvpv(sv);
2686 IoTOP_GV(GvIOp(PL_defoutgv)) = gv_fetchsv(sv, GV_ADD, SVt_PVIO);
79072805
LW
2687 break;
2688 case '~':
acbe1b9d
FC
2689 Safefree(IoFMT_NAME(GvIOp(PL_defoutgv)));
2690 s = IoFMT_NAME(GvIOp(PL_defoutgv)) = savesvpv(sv);
2691 IoFMT_GV(GvIOp(PL_defoutgv)) = gv_fetchsv(sv, GV_ADD, SVt_PVIO);
79072805
LW
2692 break;
2693 case '=':
acbe1b9d 2694 IoPAGE_LEN(GvIOp(PL_defoutgv)) = (SvIV(sv));
79072805
LW
2695 break;
2696 case '-':
acbe1b9d
FC
2697 IoLINES_LEFT(GvIOp(PL_defoutgv)) = (SvIV(sv));
2698 if (IoLINES_LEFT(GvIOp(PL_defoutgv)) < 0L)
099be4f1 2699 IoLINES_LEFT(GvIOp(PL_defoutgv)) = 0L;
79072805
LW
2700 break;
2701 case '%':
acbe1b9d 2702 IoPAGE(GvIOp(PL_defoutgv)) = (SvIV(sv));
79072805
LW
2703 break;
2704 case '|':
4b65379b 2705 {
099be4f1 2706 IO * const io = GvIO(PL_defoutgv);
720f287d
AB
2707 if(!io)
2708 break;
38ab35f8 2709 if ((SvIV(sv)) == 0)
4b65379b
CS
2710 IoFLAGS(io) &= ~IOf_FLUSH;
2711 else {
2712 if (!(IoFLAGS(io) & IOf_FLUSH)) {
2713 PerlIO *ofp = IoOFP(io);
2714 if (ofp)
2715 (void)PerlIO_flush(ofp);
2716 IoFLAGS(io) |= IOf_FLUSH;
2717 }
2718 }
79072805
LW
2719 }
2720 break;
79072805 2721 case '/':
1ab48e3a
YO
2722 {
2723 SV *tmpsv= sv;
2724 if (SvROK(sv)) {
2725 SV *referent= SvRV(sv);
2726 const char *reftype= sv_reftype(referent, 0);
2727 /* XXX: dodgy type check: This leaves me feeling dirty, but the alternative
2728 * is to copy pretty much the entire sv_reftype() into this routine, or to do
2729 * a full string comparison on the return of sv_reftype() both of which
2730 * make me feel worse! NOTE, do not modify this comment without reviewing the
2731 * corresponding comment in sv_reftype(). - Yves */
2732 if (reftype[0] == 'S' || reftype[0] == 'L') {
2733 IV val= SvIV(referent);
2734 if (val <= 0) {
2735 tmpsv= &PL_sv_undef;
2736 Perl_ck_warner(aTHX_ packWARN(WARN_DEPRECATED),
2737 "Setting $/ to a reference to %s as a form of slurp is deprecated, treating as undef",
2738 SvIV(SvRV(sv)) < 0 ? "a negative integer" : "zero"
2739 );
2740 }
2741 } else {
ee0ba734 2742 /* diag_listed_as: Setting $/ to %s reference is forbidden */
a48e4205
FC
2743 Perl_croak(aTHX_ "Setting $/ to a%s %s reference is forbidden",
2744 *reftype == 'A' ? "n" : "", reftype);
1ab48e3a
YO
2745 }
2746 }
b3a2acfa 2747 SvREFCNT_dec(PL_rs);
1ab48e3a 2748 PL_rs = newSVsv(tmpsv);
b3a2acfa 2749 }
79072805
LW
2750 break;
2751 case '\\':
ef8d46e8 2752 SvREFCNT_dec(PL_ors_sv);
6bc2995b 2753 if (SvOK(sv)) {
7889fe52 2754 PL_ors_sv = newSVsv(sv);
009c130f 2755 }
e3c19b7b 2756 else {
a0714e2c 2757 PL_ors_sv = NULL;
e3c19b7b 2758 }
79072805 2759 break;
7d69d4a6
FC
2760 case '[':
2761 if (SvIV(sv) != 0)
2762 Perl_croak(aTHX_ "Assigning non-zero to $[ is no longer possible");
2763 break;
79072805 2764 case '?':
ff0cee69 2765#ifdef COMPLEX_STATUS
6b88bc9c 2766 if (PL_localizing == 2) {
41cb7b2b 2767 SvUPGRADE(sv, SVt_PVLV);
6b88bc9c
GS
2768 PL_statusvalue = LvTARGOFF(sv);
2769 PL_statusvalue_vms = LvTARGLEN(sv);
ff0cee69
PP
2770 }
2771 else
2772#endif
2773#ifdef VMSISH_STATUS
2774 if (VMSISH_STATUS)
fb38d079 2775 STATUS_NATIVE_CHILD_SET((U32)SvIV(sv));
ff0cee69
PP
2776 else
2777#endif
38ab35f8 2778 STATUS_UNIX_EXIT_SET(SvIV(sv));
79072805
LW
2779 break;
2780 case '!':
93189314
JH
2781 {
2782#ifdef VMS
2783# define PERL_VMS_BANG vaxc$errno
2784#else
2785# define PERL_VMS_BANG 0
2786#endif
27329181 2787#if defined(WIN32) && ! defined(UNDER_CE)
c9beaf97
SH
2788 SETERRNO(win32_get_errno(SvIOK(sv) ? SvIVX(sv) : SvOK(sv) ? sv_2iv(sv) : 0),
2789 (SvIV(sv) == EVMSERR) ? 4 : PERL_VMS_BANG);
2790#else
91487cfc 2791 SETERRNO(SvIOK(sv) ? SvIVX(sv) : SvOK(sv) ? sv_2iv(sv) : 0,
93189314 2792 (SvIV(sv) == EVMSERR) ? 4 : PERL_VMS_BANG);
c9beaf97 2793#endif
93189314 2794 }
79072805
LW
2795 break;
2796 case '<':
985213f2 2797 {
b469f1e0 2798 /* XXX $< currently silently ignores failures */
dfff4baf 2799 const Uid_t new_uid = SvUID(sv);
985213f2 2800 PL_delaymagic_uid = new_uid;
3280af22
NIS
2801 if (PL_delaymagic) {
2802 PL_delaymagic |= DM_RUID;
79072805
LW
2803 break; /* don't do magic till later */
2804 }
2805#ifdef HAS_SETRUID
b469f1e0 2806 PERL_UNUSED_RESULT(setruid(new_uid));
79072805
LW
2807#else
2808#ifdef HAS_SETREUID
b469f1e0 2809 PERL_UNUSED_RESULT(setreuid(new_uid, (Uid_t)-1));
748a9306 2810#else
85e6fe83 2811#ifdef HAS_SETRESUID
b469f1e0 2812 PERL_UNUSED_RESULT(setresuid(new_uid, (Uid_t)-1, (Uid_t)-1));
79072805 2813#else
985213f2 2814 if (new_uid == PerlProc_geteuid()) { /* special case $< = $> */
75870ed3 2815#ifdef PERL_DARWIN
2816 /* workaround for Darwin's setuid peculiarity, cf [perl #24122] */
985213f2 2817 if (new_uid != 0 && PerlProc_getuid() == 0)
b469f1e0 2818 PERL_UNUSED_RESULT(PerlProc_setuid(0));
75870ed3 2819#endif
b469f1e0 2820 PERL_UNUSED_RESULT(PerlProc_setuid(new_uid));
75870ed3 2821 } else {
cea2e8a9 2822 Perl_croak(aTHX_ "setruid() not implemented");
a0d0e21e 2823 }
79072805
LW
2824#endif
2825#endif
85e6fe83 2826#endif
79072805 2827 break;
985213f2 2828 }
79072805 2829 case '>':
985213f2 2830 {
b469f1e0 2831 /* XXX $> currently silently ignores failures */
dfff4baf 2832 const Uid_t new_euid = SvUID(sv);
985213f2 2833 PL_delaymagic_euid = new_euid;
3280af22
NIS
2834 if (PL_delaymagic) {
2835 PL_delaymagic |= DM_EUID;
79072805
LW
2836 break; /* don't do magic till later */
2837 }
2838#ifdef HAS_SETEUID
b469f1e0 2839 PERL_UNUSED_RESULT(seteuid(new_euid));
79072805
LW
2840#else
2841#ifdef HAS_SETREUID
b469f1e0 2842 PERL_UNUSED_RESULT(setreuid((Uid_t)-1, new_euid));
85e6fe83
LW
2843#else
2844#ifdef HAS_SETRESUID
b469f1e0 2845 PERL_UNUSED_RESULT(setresuid((Uid_t)-1, new_euid, (Uid_t)-1));
79072805 2846#else
985213f2 2847 if (new_euid == PerlProc_getuid()) /* special case $> = $< */
b469f1e0 2848 PERL_UNUSED_RESULT(PerlProc_setuid(new_euid));
a0d0e21e 2849 else {
cea2e8a9 2850 Perl_croak(aTHX_ "seteuid() not implemented");
a0d0e21e 2851 }
79072805
LW
2852#endif
2853#endif
85e6fe83 2854#endif
79072805 2855 break;
985213f2 2856 }
79072805 2857 case '(':
985213f2 2858 {
b469f1e0 2859 /* XXX $( currently silently ignores failures */
dfff4baf 2860 const Gid_t new_gid = SvGID(sv);
985213f2 2861 PL_delaymagic_gid = new_gid;
3280af22
NIS
2862 if (PL_delaymagic) {
2863 PL_delaymagic |= DM_RGID;
79072805
LW
2864 break; /* don't do magic till later */
2865 }
2866#ifdef HAS_SETRGID
b469f1e0 2867 PERL_UNUSED_RESULT(setrgid(new_gid));
79072805
LW
2868#else
2869#ifdef HAS_SETREGID
b469f1e0 2870 PERL_UNUSED_RESULT(setregid(new_gid, (Gid_t)-1));
85e6fe83
LW
2871#else
2872#ifdef HAS_SETRESGID
b469f1e0 2873 PERL_UNUSED_RESULT(setresgid(new_gid, (Gid_t)-1, (Gid_t) -1));
79072805 2874#else
985213f2 2875 if (new_gid == PerlProc_getegid()) /* special case $( = $) */
b469f1e0 2876 PERL_UNUSED_RESULT(PerlProc_setgid(new_gid));
748a9306 2877 else {
cea2e8a9 2878 Perl_croak(aTHX_ "setrgid() not implemented");
748a9306 2879 }
79072805
LW
2880#endif
2881#endif
85e6fe83 2882#endif
79072805 2883 break;
985213f2 2884 }
79072805 2885 case ')':
985213f2 2886 {
b469f1e0 2887 /* XXX $) currently silently ignores failures */
dfff4baf 2888 Gid_t new_egid;
5cd24f17
PP
2889#ifdef HAS_SETGROUPS
2890 {
b83604b4 2891 const char *p = SvPV_const(sv, len);
757f63d8 2892 Groups_t *gary = NULL;
fdadaf77 2893 const char* endptr;
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;
fdadaf77 2905 new_egid = (Gid_t)grok_atou(p, &endptr);
fb4089e0 2906 for (i = 0; i < maxgrp; ++i) {
fdadaf77
JH
2907 if (endptr == NULL)
2908 break;
2909 p = endptr;
757f63d8
SP
2910 while (isSPACE(*p))
2911 ++p;
2912 if (!*p)
2913 break;
fdadaf77 2914 if (!gary)
757f63d8
SP
2915 Newx(gary, i + 1, Groups_t);
2916 else
2917 Renew(gary, i + 1, Groups_t);
fdadaf77 2918 gary[i] = (Groups_t)grok_atou(p, &endptr);
757f63d8
SP
2919 }
2920 if (i)
b469f1e0 2921 PERL_UNUSED_RESULT(setgroups(i, gary));
f5a63d97 2922 Safefree(gary);
5cd24f17
PP
2923 }
2924#else /* HAS_SETGROUPS */
dfff4baf 2925 new_egid = SvGID(sv);
5cd24f17 2926#endif /* HAS_SETGROUPS */
985213f2 2927 PL_delaymagic_egid = new_egid;
3280af22
NIS
2928 if (PL_delaymagic) {
2929 PL_delaymagic |= DM_EGID;
79072805
LW
2930 break; /* don't do magic till later */
2931 }
2932#ifdef HAS_SETEGID
b469f1e0 2933 PERL_UNUSED_RESULT(setegid(new_egid));
79072805
LW
2934#else
2935#ifdef HAS_SETREGID
b469f1e0 2936 PERL_UNUSED_RESULT(setregid((Gid_t)-1, new_egid));
85e6fe83
LW
2937#else
2938#ifdef HAS_SETRESGID
b469f1e0 2939 PERL_UNUSED_RESULT(setresgid((Gid_t)-1, new_egid, (Gid_t)-1));
79072805 2940#else
985213f2 2941 if (new_egid == PerlProc_getgid()) /* special case $) = $( */
b469f1e0 2942 PERL_UNUSED_RESULT(PerlProc_setgid(new_egid));
748a9306 2943 else {
cea2e8a9 2944 Perl_croak(aTHX_ "setegid() not implemented");
748a9306 2945 }
79072805
LW
2946#endif
2947#endif
85e6fe83 2948#endif
79072805 2949 break;
985213f2 2950 }
79072805 2951 case ':':
2d8e6c8d 2952 PL_chopset = SvPV_force(sv,len);
79072805 2953 break;
9cdac2a2
FC
2954 case '$': /* $$ */
2955 /* Store the pid in mg->mg_obj so we can tell when a fork has
2956 occurred. mg->mg_obj points to *$ by default, so clear it. */
2957 if (isGV(mg->mg_obj)) {
2958 if (mg->mg_flags & MGf_REFCOUNTED) /* probably never true */
2959 SvREFCNT_dec(mg->mg_obj);
2960 mg->mg_flags |= MGf_REFCOUNTED;
2961 mg->mg_obj = newSViv((IV)PerlProc_getpid());
2962 }
2963 else sv_setiv(mg->mg_obj, (IV)PerlProc_getpid());
2964 break;
79072805 2965 case '0':
e2975953 2966 LOCK_DOLLARZERO_MUTEX;
4bc88a62
PS
2967#ifdef HAS_SETPROCTITLE
2968 /* The BSDs don't show the argv[] in ps(1) output, they
2969 * show a string from the process struct and provide
2970 * the setproctitle() routine to manipulate that. */
a2722ac9 2971 if (PL_origalen != 1) {
b83604b4 2972 s = SvPV_const(sv, len);
98b76f99 2973# if __FreeBSD_version > 410001
9aad2c0e 2974 /* The leading "-" removes the "perl: " prefix,
4bc88a62
PS
2975 * but not the "(perl) suffix from the ps(1)
2976 * output, because that's what ps(1) shows if the
2977 * argv[] is modified. */
6f2ad931 2978 setproctitle("-%s", s);
9aad2c0e 2979# else /* old FreeBSDs, NetBSD, OpenBSD, anyBSD */
4bc88a62
PS
2980 /* This doesn't really work if you assume that
2981 * $0 = 'foobar'; will wipe out 'perl' from the $0
2982 * because in ps(1) output the result will be like
2983 * sprintf("perl: %s (perl)", s)
2984 * I guess this is a security feature:
2985 * one (a user process) cannot get rid of the original name.
2986 * --jhi */
2987 setproctitle("%s", s);
2988# endif
2989 }
9d3968b2 2990#elif defined(__hpux) && defined(PSTAT_SETCMD)
a2722ac9 2991 if (PL_origalen != 1) {
17aa7f3d 2992 union pstun un;
b83604b4 2993 s = SvPV_const(sv, len);
6867be6d 2994 un.pst_command = (char *)s;
17aa7f3d
JH
2995 pstat(PSTAT_SETCMD, un, len, 0, 0);
2996 }
9d3968b2 2997#else
2d2af554
GA
2998 if (PL_origalen > 1) {
2999 /* PL_origalen is set in perl_parse(). */
3000 s = SvPV_force(sv,len);
3001 if (len >= (STRLEN)PL_origalen-1) {
3002 /* Longer than original, will be truncated. We assume that
3003 * PL_origalen bytes are available. */
3004 Copy(s, PL_origargv[0], PL_origalen-1, char);
3005 }
3006 else {
3007 /* Shorter than original, will be padded. */
235ac35d 3008#ifdef PERL_DARWIN
60777a0d
JH
3009 /* Special case for Mac OS X: see [perl #38868] */
3010 const int pad = 0;
235ac35d 3011#else
8a89a4f1
MB
3012 /* Is the space counterintuitive? Yes.
3013 * (You were expecting \0?)
3014 * Does it work? Seems to. (In Linux 2.4.20 at least.)
3015 * --jhi */
60777a0d 3016 const int pad = ' ';
235ac35d 3017#endif
60777a0d
JH
3018 Copy(s, PL_origargv[0], len, char);
3019 PL_origargv[0][len] = 0;
3020 memset(PL_origargv[0] + len + 1,
3021 pad, PL_origalen - len - 1);
2d2af554
GA
3022 }
3023 PL_origargv[0][PL_origalen-1] = 0;
3024 for (i = 1; i < PL_origargc; i++)
3025 PL_origargv[i] = 0;
7636ea95
AB
3026#ifdef HAS_PRCTL_SET_NAME
3027 /* Set the legacy process name in addition to the POSIX name on Linux */
3028 if (prctl(PR_SET_NAME, (unsigned long)s, 0, 0, 0) != 0) {
3029 /* diag_listed_as: SKIPME */
3030 Perl_croak(aTHX_ "Can't set $0 with prctl(): %s", Strerror(errno));
3031 }
3032#endif
79072805 3033 }
9d3968b2 3034#endif
e2975953 3035 UNLOCK_DOLLARZERO_MUTEX;
79072805
LW
3036 break;
3037 }
3038 return 0;
3039}
3040
3041I32
84c7b88c
BF
3042Perl_whichsig_sv(pTHX_ SV *sigsv)
3043{
3044 const char *sigpv;
3045 STRLEN siglen;
3046 PERL_ARGS_ASSERT_WHICHSIG_SV;
84c7b88c
BF
3047 sigpv = SvPV_const(sigsv, siglen);
3048 return whichsig_pvn(sigpv, siglen);
3049}
3050
3051I32
3052Perl_whichsig_pv(pTHX_ const char *sig)
3053{
3054 PERL_ARGS_ASSERT_WHICHSIG_PV;
84c7b88c
BF
3055 return whichsig_pvn(sig, strlen(sig));
3056}
3057
3058I32
3059Perl_whichsig_pvn(pTHX_ const char *sig, STRLEN len)
79072805 3060{
eb578fdb 3061 char* const* sigv;
7918f24d 3062
84c7b88c 3063 PERL_ARGS_ASSERT_WHICHSIG_PVN;
96a5add6 3064 PERL_UNUSED_CONTEXT;
79072805 3065
aadb217d 3066 for (sigv = (char* const*)PL_sig_name; *sigv; sigv++)
84c7b88c 3067 if (strlen(*sigv) == len && memEQ(sig,*sigv, len))
aadb217d 3068 return PL_sig_num[sigv - (char* const*)PL_sig_name];
79072805 3069#ifdef SIGCLD
84c7b88c 3070 if (memEQs(sig, len, "CHLD"))
79072805
LW
3071 return SIGCLD;
3072#endif
3073#ifdef SIGCHLD
84c7b88c 3074 if (memEQs(sig, len, "CLD"))
79072805
LW
3075 return SIGCHLD;
3076#endif
7f1236c0 3077 return -1;
79072805
LW
3078}
3079
ecfc5424 3080Signal_t
1e82f5a6 3081#if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
b3dbdd48 3082Perl_sighandler(int sig, siginfo_t *sip, void *uap)
1e82f5a6
SH
3083#else
3084Perl_sighandler(int sig)
3085#endif
79072805 3086{
1018e26f
NIS
3087#ifdef PERL_GET_SIG_CONTEXT
3088 dTHXa(PERL_GET_SIG_CONTEXT);
71d280e3 3089#else
cea2e8a9 3090 dTHX;
71d280e3 3091#endif
79072805 3092 dSP;
a0714e2c
SS
3093 GV *gv = NULL;
3094 SV *sv = NULL;
8772537c 3095 SV * const tSv = PL_Sv;
601f1833 3096 CV *cv = NULL;
533c011a 3097 OP *myop = PL_op;
84902520 3098 U32 flags = 0;
8772537c 3099 XPV * const tXpv = PL_Xpv;
0c4d3b5e 3100 I32 old_ss_ix = PL_savestack_ix;
100c03aa 3101 SV *errsv_save = NULL;
71d280e3 3102
84902520 3103
727405f8 3104 if (!PL_psig_ptr[sig]) {
99ef548b 3105 PerlIO_printf(Perl_error_log, "Signal SIG%s received, but no signal handler set.\n",
727405f8
NIS
3106 PL_sig_name[sig]);
3107 exit(sig);
3108 }
ff0cee69 3109
a0d63a7b
DM
3110 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG) {
3111 /* Max number of items pushed there is 3*n or 4. We cannot fix
3112 infinity, so we fix 4 (in fact 5): */
3113 if (PL_savestack_ix + 15 <= PL_savestack_max) {
3114 flags |= 1;
3115 PL_savestack_ix += 5; /* Protect save in progress. */
3116 SAVEDESTRUCTOR_X(S_unwind_handler_stack, NULL);
3117 }
84902520 3118 }
84902520 3119 /* sv_2cv is too complicated, try a simpler variant first: */
ea726b52 3120 if (!SvROK(PL_psig_ptr[sig]) || !(cv = MUTABLE_CV(SvRV(PL_psig_ptr[sig])))
8772537c
AL
3121 || SvTYPE(cv) != SVt_PVCV) {
3122 HV *st;
f2c0649b 3123 cv = sv_2cv(PL_psig_ptr[sig], &st, &gv, GV_ADD);
8772537c 3124 }
84902520 3125
a0d0e21e 3126 if (!cv || !CvROOT(cv)) {
a2a5de95
NC
3127 Perl_ck_warner(aTHX_ packWARN(WARN_SIGNAL), "SIG%s handler \"%s\" not defined.\n",
3128 PL_sig_name[sig], (gv ? GvENAME(gv)
3129 : ((cv && CvGV(cv))
3130 ? GvENAME(CvGV(cv))
3131 : "__ANON__")));
00d579c5 3132 goto cleanup;
79072805
LW
3133 }
3134
0c4d3b5e
DM
3135 sv = PL_psig_name[sig]
3136 ? SvREFCNT_inc_NN(PL_psig_name[sig])
3137 : newSVpv(PL_sig_name[sig],0);
72048cfe 3138 flags |= 8;
0c4d3b5e
DM
3139 SAVEFREESV(sv);
3140
a0d63a7b
DM
3141 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG) {
3142 /* make sure our assumption about the size of the SAVEs are correct:
3143 * 3 for SAVEDESTRUCTOR_X, 2 for SAVEFREESV */
3144 assert(old_ss_ix + 2 + ((flags & 1) ? 3+5 : 0) == PL_savestack_ix);
3145 }
e336de0d 3146
e788e7d3 3147 PUSHSTACKi(PERLSI_SIGNAL);
924508f0 3148 PUSHMARK(SP);
79072805 3149 PUSHs(sv);
8aad04aa
JH
3150#if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
3151 {
3152 struct sigaction oact;
3153
3154 if (sigaction(sig, 0, &oact) == 0 && oact.sa_flags & SA_SIGINFO) {
8aad04aa
JH
3155 if (sip) {
3156 HV *sih = newHV();
ad64d0ec 3157 SV *rv = newRV_noinc(MUTABLE_SV(sih));
8aad04aa
JH
3158 /* The siginfo fields signo, code, errno, pid, uid,
3159 * addr, status, and band are defined by POSIX/SUSv3. */
85771703
NC
3160 (void)hv_stores(sih, "signo", newSViv(sip->si_signo));
3161 (void)hv_stores(sih, "code", newSViv(sip->si_code));
79dec0f4 3162#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
3163 hv_stores(sih, "errno", newSViv(sip->si_errno));
3164 hv_stores(sih, "status", newSViv(sip->si_status));
3165 hv_stores(sih, "uid", newSViv(sip->si_uid));
3166 hv_stores(sih, "pid", newSViv(sip->si_pid));
3167 hv_stores(sih, "addr", newSVuv(PTR2UV(sip->si_addr)));
3168 hv_stores(sih, "band", newSViv(sip->si_band));
79dec0f4 3169#endif
8aad04aa 3170 EXTEND(SP, 2);
ad64d0ec 3171 PUSHs(rv);
22f1178f 3172 mPUSHp((char *)sip, sizeof(*sip));
8aad04aa 3173 }
b4552a27 3174
8aad04aa
JH
3175 }
3176 }
3177#endif
79072805 3178 PUTBACK;
a0d0e21e 3179
100c03aa
JL
3180 errsv_save = newSVsv(ERRSV);
3181
ad64d0ec 3182 call_sv(MUTABLE_SV(cv), G_DISCARD|G_EVAL);
79072805 3183
d3acc0f7 3184 POPSTACK;
eed484f9
DD
3185 {
3186 SV * const errsv = ERRSV;
3187 if (SvTRUE_NN(errsv)) {
3188 SvREFCNT_dec(errsv_save);
c22d665b 3189#ifndef PERL_MICRO
1b266415
NIS
3190 /* Handler "died", for example to get out of a restart-able read().
3191 * Before we re-do that on its behalf re-enable the signal which was
3192 * blocked by the system when we entered.
3193 */
c22d665b 3194#ifdef HAS_SIGPROCMASK
d488af49 3195#if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
eed484f9 3196 if (sip || uap)
c22d665b 3197#endif
eed484f9
DD
3198 {
3199 sigset_t set;
3200 sigemptyset(&set);
3201 sigaddset(&set,sig);
3202 sigprocmask(SIG_UNBLOCK, &set, NULL);
3203 }
c22d665b 3204#else
eed484f9
DD
3205 /* Not clear if this will work */
3206 (void)rsignal(sig, SIG_IGN);
3207 (void)rsignal(sig, PL_csighandlerp);
c22d665b
LT
3208#endif
3209#endif /* !PERL_MICRO */
eed484f9
DD
3210 die_sv(errsv);
3211 }
3212 else {
3213 sv_setsv(errsv, errsv_save);
3214 SvREFCNT_dec(errsv_save);
3215 }
100c03aa
JL
3216 }
3217
00d579c5 3218cleanup:
0c4d3b5e
DM
3219 /* pop any of SAVEFREESV, SAVEDESTRUCTOR_X and "save in progress" */
3220 PL_savestack_ix = old_ss_ix;
72048cfe 3221 if (flags & 8)
2357bae7 3222 SvREFCNT_dec_NN(sv);
533c011a 3223 PL_op = myop; /* Apparently not needed... */
ac27b0f5 3224
3280af22
NIS
3225 PL_Sv = tSv; /* Restore global temporaries. */
3226 PL_Xpv = tXpv;
53bb94e2 3227 return;
79072805 3228}
4e35701f
NIS
3229
3230
51371543 3231static void
8772537c 3232S_restore_magic(pTHX_ const void *p)
51371543 3233{
8772537c
AL
3234 MGS* const mgs = SSPTR(PTR2IV(p), MGS*);
3235 SV* const sv = mgs->mgs_sv;
150b625d 3236 bool bumped;
51371543
GS
3237
3238 if (!sv)
3239 return;
3240
4bac9ae4
CS
3241 if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv)) {
3242 SvTEMP_off(sv); /* if it's still magical, this value isn't temporary */
f8c7b90f 3243#ifdef PERL_OLD_COPY_ON_WRITE
f9701176
NC
3244 /* While magic was saved (and off) sv_setsv may well have seen
3245 this SV as a prime candidate for COW. */
3246 if (SvIsCOW(sv))
e424a81e 3247 sv_force_normal_flags(sv, 0);
f9701176 3248#endif
f9c6fee5
CS
3249 if (mgs->mgs_readonly)
3250 SvREADONLY_on(sv);
3251 if (mgs->mgs_magical)
3252 SvFLAGS(sv) |= mgs->mgs_magical;
51371543
GS
3253 else
3254 mg_magical(sv);
51371543
GS
3255 }
3256
150b625d 3257 bumped = mgs->mgs_bumped;
51371543
GS
3258 mgs->mgs_sv = NULL; /* mark the MGS structure as restored */
3259
3260 /* If we're still on top of the stack, pop us off. (That condition
3261 * will be satisfied if restore_magic was called explicitly, but *not*
3262 * if it's being called via leave_scope.)
3263 * The reason for doing this is that otherwise, things like sv_2cv()
3264 * may leave alloc gunk on the savestack, and some code
3265 * (e.g. sighandler) doesn't expect that...
3266 */
3267 if (PL_savestack_ix == mgs->mgs_ss_ix)
3268 {
1be36ce0
NC
3269 UV popval = SSPOPUV;
3270 assert(popval == SAVEt_DESTRUCTOR_X);
51371543 3271 PL_savestack_ix -= 2;
1be36ce0
NC
3272 popval = SSPOPUV;
3273 assert((popval & SAVE_MASK) == SAVEt_ALLOC);
3274 PL_savestack_ix -= popval >> SAVE_TIGHT_SHIFT;
51371543 3275 }
150b625d
DM
3276 if (bumped) {
3277 if (SvREFCNT(sv) == 1) {
3278 /* We hold the last reference to this SV, which implies that the
3279 SV was deleted as a side effect of the routines we called.
3280 So artificially keep it alive a bit longer.
3281 We avoid turning on the TEMP flag, which can cause the SV's
3282 buffer to get stolen (and maybe other stuff). */
150b625d 3283 sv_2mortal(sv);
4bac9ae4 3284 SvTEMP_off(sv);
8985fe98 3285 }
150b625d 3286 else
2357bae7 3287 SvREFCNT_dec_NN(sv); /* undo the inc in S_save_magic() */
8985fe98 3288 }
51371543
GS
3289}
3290
0c4d3b5e
DM
3291/* clean up the mess created by Perl_sighandler().
3292 * Note that this is only called during an exit in a signal handler;
3293 * a die is trapped by the call_sv() and the SAVEDESTRUCTOR_X manually
9a7f166c 3294 * skipped over. */
0c4d3b5e 3295
51371543 3296static void
8772537c 3297S_unwind_handler_stack(pTHX_ const void *p)
51371543 3298{
0c4d3b5e 3299 PERL_UNUSED_ARG(p);
7918f24d 3300
0c4d3b5e 3301 PL_savestack_ix -= 5; /* Unprotect save in progress. */
51371543 3302}
1018e26f 3303
66610fdd 3304/*
b3ca2e83
NC
3305=for apidoc magic_sethint
3306
3307Triggered by a store to %^H, records the key/value pair to
c28fe1ec
NC
3308C<PL_compiling.cop_hints_hash>. It is assumed that hints aren't storing
3309anything that would need a deep copy. Maybe we should warn if we find a
3310reference.
b3ca2e83
NC
3311
3312=cut
3313*/
3314int
3315Perl_magic_sethint(pTHX_ SV *sv, MAGIC *mg)
3316{
ad64d0ec 3317 SV *key = (mg->mg_len == HEf_SVKEY) ? MUTABLE_SV(mg->mg_ptr)
59cd0e26 3318 : newSVpvn_flags(mg->mg_ptr, mg->mg_len, SVs_TEMP);
b3ca2e83 3319
7918f24d
NC
3320 PERL_ARGS_ASSERT_MAGIC_SETHINT;
3321
e6e3e454
NC
3322 /* mg->mg_obj isn't being used. If needed, it would be possible to store
3323 an alternative leaf in there, with PL_compiling.cop_hints being used if
3324 it's NULL. If needed for threads, the alternative could lock a mutex,
3325 or take other more complex action. */
3326
5b9c0671
NC
3327 /* Something changed in %^H, so it will need to be restored on scope exit.
3328 Doing this here saves a lot of doing it manually in perl code (and
3329 forgetting to do it, and consequent subtle errors. */
3330 PL_hints |= HINT_LOCALIZE_HH;
20439bc7
Z
3331 CopHINTHASH_set(&PL_compiling,
3332 cophh_store_sv(CopHINTHASH_get(&PL_compiling), key, 0, sv, 0));
b3ca2e83
NC
3333 return 0;
3334}
3335
3336/*
f175cff5 3337=for apidoc magic_clearhint
b3ca2e83 3338
c28fe1ec
NC
3339Triggered by a delete from %^H, records the key to
3340C<PL_compiling.cop_hints_hash>.
b3ca2e83
NC
3341
3342=cut
3343*/
3344int
3345Perl_magic_clearhint(pTHX_ SV *sv, MAGIC *mg)
3346{
7918f24d 3347 PERL_ARGS_ASSERT_MAGIC_CLEARHINT;
f5a63d97
AL
3348 PERL_UNUSED_ARG(sv);
3349
5b9c0671 3350 PL_hints |= HINT_LOCALIZE_HH;
20439bc7 3351 CopHINTHASH_set(&PL_compiling,
e3352591
FC
3352 mg->mg_len == HEf_SVKEY
3353 ? cophh_delete_sv(CopHINTHASH_get(&PL_compiling),
3354 MUTABLE_SV(mg->mg_ptr), 0, 0)
3355 : cophh_delete_pvn(CopHINTHASH_get(&PL_compiling),
3356 mg->mg_ptr, mg->mg_len, 0, 0));
b3ca2e83
NC
3357 return 0;
3358}
3359
3360/*
f747ebd6
Z
3361=for apidoc magic_clearhints
3362
3363Triggered by clearing %^H, resets C<PL_compiling.cop_hints_hash>.
3364
3365=cut
3366*/
3367int
3368Perl_magic_clearhints(pTHX_ SV *sv, MAGIC *mg)
3369{
3370 PERL_ARGS_ASSERT_MAGIC_CLEARHINTS;
3371 PERL_UNUSED_ARG(sv);
3372 PERL_UNUSED_ARG(mg);
20439bc7
Z
3373 cophh_free(CopHINTHASH_get(&PL_compiling));
3374 CopHINTHASH_set(&PL_compiling, cophh_new_empty());
f747ebd6
Z
3375 return 0;
3376}
3377
09fb282d
FC
3378int
3379Perl_magic_copycallchecker(pTHX_ SV *sv, MAGIC *mg, SV *nsv,
3380 const char *name, I32 namlen)
3381{
3382 MAGIC *nmg;
3383
3384 PERL_ARGS_ASSERT_MAGIC_COPYCALLCHECKER;
4f8dbb2d 3385 PERL_UNUSED_ARG(sv);
09fb282d
FC
3386 PERL_UNUSED_ARG(name);
3387 PERL_UNUSED_ARG(namlen);
3388
3389 sv_magic(nsv, &PL_sv_undef, mg->mg_type, NULL, 0);
3390 nmg = mg_find(nsv, mg->mg_type);
316ebaf2 3391 assert(nmg);
09fb282d
FC
3392 if (nmg->mg_flags & MGf_REFCOUNTED) SvREFCNT_dec(nmg->mg_obj);
3393 nmg->mg_ptr = mg->mg_ptr;
3394 nmg->mg_obj = SvREFCNT_inc_simple(mg->mg_obj);
3395 nmg->mg_flags |= MGf_REFCOUNTED;
3396 return 1;
3397}
3398
f747ebd6 3399/*
66610fdd
RGS
3400 * Local variables:
3401 * c-indentation-style: bsd
3402 * c-basic-offset: 4
14d04a33 3403 * indent-tabs-mode: nil
66610fdd
RGS
3404 * End:
3405 *
14d04a33 3406 * ex: set ts=8 sts=4 sw=4 et:
37442d52 3407 */