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