This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
[perl #122445] use magic on $DB::single etc to avoid overload issues
[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;
a623f893 87 U32 mgs_flags;
150b625d 88 bool mgs_bumped;
c07a80fd 89};
455ece5e 90/* MGS is typedef'ed to struct magic_state in perl.h */
76e3520e
GS
91
92STATIC void
ff44333e 93S_save_magic_flags(pTHX_ I32 mgs_ix, SV *sv, U32 flags)
c07a80fd 94{
455ece5e 95 MGS* mgs;
150b625d 96 bool bumped = FALSE;
7918f24d 97
ff44333e 98 PERL_ARGS_ASSERT_SAVE_MAGIC_FLAGS;
7918f24d 99
4bac9ae4
CS
100 assert(SvMAGICAL(sv));
101
150b625d
DM
102 /* we shouldn't really be called here with RC==0, but it can sometimes
103 * happen via mg_clear() (which also shouldn't be called when RC==0,
104 * but it can happen). Handle this case gracefully(ish) by not RC++
105 * and thus avoiding the resultant double free */
106 if (SvREFCNT(sv) > 0) {
107 /* guard against sv getting freed midway through the mg clearing,
108 * by holding a private reference for the duration. */
109 SvREFCNT_inc_simple_void_NN(sv);
110 bumped = TRUE;
111 }
8985fe98 112
8772537c 113 SAVEDESTRUCTOR_X(S_restore_magic, INT2PTR(void*, (IV)mgs_ix));
455ece5e
AD
114
115 mgs = SSPTR(mgs_ix, MGS*);
c07a80fd 116 mgs->mgs_sv = sv;
a623f893 117 mgs->mgs_flags = SvMAGICAL(sv) | SvREADONLY(sv);
455ece5e 118 mgs->mgs_ss_ix = PL_savestack_ix; /* points after the saved destructor */
150b625d 119 mgs->mgs_bumped = bumped;
c07a80fd 120
ff44333e 121 SvFLAGS(sv) &= ~flags;
3805b5fb 122 SvREADONLY_off(sv);
c07a80fd
PP
123}
124
ff44333e
FC
125#define save_magic(a,b) save_magic_flags(a,b,SVs_GMG|SVs_SMG|SVs_RMG)
126
954c1994
GS
127/*
128=for apidoc mg_magical
129
130Turns on the magical status of an SV. See C<sv_magic>.
131
132=cut
133*/
134
8990e307 135void
ddeaf645 136Perl_mg_magical(SV *sv)
8990e307 137{
e1ec3a88 138 const MAGIC* mg;
7918f24d 139 PERL_ARGS_ASSERT_MG_MAGICAL;
f9c6fee5
CS
140
141 SvMAGICAL_off(sv);
218787bd 142 if ((mg = SvMAGIC(sv))) {
218787bd
VP
143 do {
144 const MGVTBL* const vtbl = mg->mg_virtual;
145 if (vtbl) {
146 if (vtbl->svt_get && !(mg->mg_flags & MGf_GSKIP))
147 SvGMAGICAL_on(sv);
148 if (vtbl->svt_set)
149 SvSMAGICAL_on(sv);
150 if (vtbl->svt_clear)
151 SvRMAGICAL_on(sv);
152 }
153 } while ((mg = mg->mg_moremagic));
154 if (!(SvFLAGS(sv) & (SVs_GMG|SVs_SMG)))
155 SvRMAGICAL_on(sv);
8990e307
LW
156 }
157}
158
954c1994
GS
159/*
160=for apidoc mg_get
161
4b1e7f06 162Do magic before a value is retrieved from the SV. The type of SV must
72d33970 163be >= SVt_PVMG. See C<sv_magic>.
954c1994
GS
164
165=cut
166*/
167
79072805 168int
864dbfa3 169Perl_mg_get(pTHX_ SV *sv)
79072805 170{
35a4481c 171 const I32 mgs_ix = SSNEW(sizeof(MGS));
a9844598 172 bool saved = FALSE;
f9c6fee5 173 bool have_new = 0;
ff76feab 174 MAGIC *newmg, *head, *cur, *mg;
6683b158 175
7918f24d
NC
176 PERL_ARGS_ASSERT_MG_GET;
177
407287f9
FC
178 if (PL_localizing == 1 && sv == DEFSV) return 0;
179
ff76feab
AMS
180 /* We must call svt_get(sv, mg) for each valid entry in the linked
181 list of magic. svt_get() may delete the current entry, add new
182 magic to the head of the list, or upgrade the SV. AMS 20010810 */
183
184 newmg = cur = head = mg = SvMAGIC(sv);
185 while (mg) {
35a4481c 186 const MGVTBL * const vtbl = mg->mg_virtual;
f9c6fee5 187 MAGIC * const nextmg = mg->mg_moremagic; /* it may delete itself */
ff76feab 188
2b260de0 189 if (!(mg->mg_flags & MGf_GSKIP) && vtbl && vtbl->svt_get) {
a9844598
CS
190
191 /* taint's mg get is so dumb it doesn't need flag saving */
192 if (!saved && mg->mg_type != PERL_MAGIC_taint) {
193 save_magic(mgs_ix, sv);
194 saved = TRUE;
195 }
196
16c91539 197 vtbl->svt_get(aTHX_ sv, mg);
b77f7d40 198
58f82c5c
DM
199 /* guard against magic having been deleted - eg FETCH calling
200 * untie */
f9c6fee5 201 if (!SvMAGIC(sv)) {
a623f893
FC
202 /* recalculate flags */
203 (SSPTR(mgs_ix, MGS *))->mgs_flags &= ~(SVs_GMG|SVs_SMG|SVs_RMG);
58f82c5c 204 break;
f9c6fee5 205 }
b77f7d40 206
f9c6fee5 207 /* recalculate flags if this entry was deleted. */
ff76feab 208 if (mg->mg_flags & MGf_GSKIP)
a623f893
FC
209 (SSPTR(mgs_ix, MGS *))->mgs_flags &=
210 ~(SVs_GMG|SVs_SMG|SVs_RMG);
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;
a623f893
FC
234 /* recalculate flags */
235 (SSPTR(mgs_ix, MGS *))->mgs_flags &= ~(SVs_GMG|SVs_SMG|SVs_RMG);
760ac839 236 }
79072805 237 }
463ee0b2 238
a9844598
CS
239 if (saved)
240 restore_magic(INT2PTR(void *, (IV)mgs_ix));
241
79072805
LW
242 return 0;
243}
244
954c1994
GS
245/*
246=for apidoc mg_set
247
248Do magic after a value is assigned to the SV. See C<sv_magic>.
249
250=cut
251*/
252
79072805 253int
864dbfa3 254Perl_mg_set(pTHX_ SV *sv)
79072805 255{
35a4481c 256 const I32 mgs_ix = SSNEW(sizeof(MGS));
79072805 257 MAGIC* mg;
463ee0b2
LW
258 MAGIC* nextmg;
259
7918f24d
NC
260 PERL_ARGS_ASSERT_MG_SET;
261
b5ed8c44
FC
262 if (PL_localizing == 2 && sv == DEFSV) return 0;
263
ff44333e 264 save_magic_flags(mgs_ix, sv, SVs_GMG|SVs_SMG); /* leave SVs_RMG on */
463ee0b2
LW
265
266 for (mg = SvMAGIC(sv); mg; mg = nextmg) {
e1ec3a88 267 const MGVTBL* vtbl = mg->mg_virtual;
463ee0b2 268 nextmg = mg->mg_moremagic; /* it may delete itself */
a0d0e21e
LW
269 if (mg->mg_flags & MGf_GSKIP) {
270 mg->mg_flags &= ~MGf_GSKIP; /* setting requires another read */
a623f893 271 (SSPTR(mgs_ix, MGS*))->mgs_flags &= ~(SVs_GMG|SVs_SMG|SVs_RMG);
a0d0e21e 272 }
e0a73de4 273 if (PL_localizing == 2
b5ed8c44 274 && PERL_MAGIC_TYPE_IS_VALUE_MAGIC(mg->mg_type))
e7cbf6c6 275 continue;
2b260de0 276 if (vtbl && vtbl->svt_set)
16c91539 277 vtbl->svt_set(aTHX_ sv, mg);
79072805 278 }
463ee0b2 279
8772537c 280 restore_magic(INT2PTR(void*, (IV)mgs_ix));
79072805
LW
281 return 0;
282}
283
954c1994
GS
284/*
285=for apidoc mg_length
286
d4e99c76 287Reports on the SV's length in bytes, calling length magic if available,
bd8446cf
FC
288but does not set the UTF8 flag on the sv. It will fall back to 'get'
289magic if there is no 'length' magic, but with no indication as to
290whether it called 'get' magic. It assumes the sv is a PVMG or
291higher. Use sv_len() instead.
954c1994
GS
292
293=cut
294*/
295
79072805 296U32
864dbfa3 297Perl_mg_length(pTHX_ SV *sv)
79072805
LW
298{
299 MAGIC* mg;
463ee0b2 300 STRLEN len;
463ee0b2 301
7918f24d
NC
302 PERL_ARGS_ASSERT_MG_LENGTH;
303
79072805 304 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
35a4481c 305 const MGVTBL * const vtbl = mg->mg_virtual;
2b260de0 306 if (vtbl && vtbl->svt_len) {
35a4481c 307 const I32 mgs_ix = SSNEW(sizeof(MGS));
455ece5e 308 save_magic(mgs_ix, sv);
a0d0e21e 309 /* omit MGf_GSKIP -- not changed here */
16c91539 310 len = vtbl->svt_len(aTHX_ sv, mg);
8772537c 311 restore_magic(INT2PTR(void*, (IV)mgs_ix));
85e6fe83
LW
312 return len;
313 }
314 }
315
bd8446cf 316 (void)SvPV_const(sv, len);
463ee0b2 317 return len;
79072805
LW
318}
319
8fb26106 320I32
864dbfa3 321Perl_mg_size(pTHX_ SV *sv)
93965878
NIS
322{
323 MAGIC* mg;
ac27b0f5 324
7918f24d
NC
325 PERL_ARGS_ASSERT_MG_SIZE;
326
93965878 327 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
35a4481c 328 const MGVTBL* const vtbl = mg->mg_virtual;
2b260de0 329 if (vtbl && vtbl->svt_len) {
35a4481c
AL
330 const I32 mgs_ix = SSNEW(sizeof(MGS));
331 I32 len;
455ece5e 332 save_magic(mgs_ix, sv);
93965878 333 /* omit MGf_GSKIP -- not changed here */
16c91539 334 len = vtbl->svt_len(aTHX_ sv, mg);
8772537c 335 restore_magic(INT2PTR(void*, (IV)mgs_ix));
93965878
NIS
336 return len;
337 }
338 }
339
340 switch(SvTYPE(sv)) {
341 case SVt_PVAV:
502c6561 342 return AvFILLp((const AV *) sv); /* Fallback to non-tied array */
93965878
NIS
343 case SVt_PVHV:
344 /* FIXME */
345 default:
cea2e8a9 346 Perl_croak(aTHX_ "Size magic not implemented");
81d52ecd 347
93965878 348 }
a25b5927 349 NOT_REACHED; /* NOTREACHED */
93965878
NIS
350}
351
954c1994
GS
352/*
353=for apidoc mg_clear
354
355Clear something magical that the SV represents. See C<sv_magic>.
356
357=cut
358*/
359
79072805 360int
864dbfa3 361Perl_mg_clear(pTHX_ SV *sv)
79072805 362{
35a4481c 363 const I32 mgs_ix = SSNEW(sizeof(MGS));
79072805 364 MAGIC* mg;
8ac77ac9 365 MAGIC *nextmg;
463ee0b2 366
7918f24d
NC
367 PERL_ARGS_ASSERT_MG_CLEAR;
368
455ece5e 369 save_magic(mgs_ix, sv);
463ee0b2 370
8ac77ac9 371 for (mg = SvMAGIC(sv); mg; mg = nextmg) {
35a4481c 372 const MGVTBL* const vtbl = mg->mg_virtual;
a0d0e21e 373 /* omit GSKIP -- never set here */
727405f8 374
8ac77ac9
NC
375 nextmg = mg->mg_moremagic; /* it may delete itself */
376
2b260de0 377 if (vtbl && vtbl->svt_clear)
16c91539 378 vtbl->svt_clear(aTHX_ sv, mg);
79072805 379 }
463ee0b2 380
8772537c 381 restore_magic(INT2PTR(void*, (IV)mgs_ix));
79072805
LW
382 return 0;
383}
384
ed624ca8 385static MAGIC*
ddeaf645 386S_mg_findext_flags(const SV *sv, int type, const MGVTBL *vtbl, U32 flags)
39de7f53 387{
39de7f53
FR
388 assert(flags <= 1);
389
390 if (sv) {
391 MAGIC *mg;
392
7db6405c
FC
393 assert(!(SvTYPE(sv) == SVt_PVAV && AvPAD_NAMELIST(sv)));
394
39de7f53
FR
395 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
396 if (mg->mg_type == type && (!flags || mg->mg_virtual == vtbl)) {
397 return mg;
398 }
399 }
400 }
401
402 return NULL;
403}
404
954c1994
GS
405/*
406=for apidoc mg_find
407
408Finds the magic pointer for type matching the SV. See C<sv_magic>.
409
410=cut
411*/
412
93a17b20 413MAGIC*
ddeaf645 414Perl_mg_find(const SV *sv, int type)
93a17b20 415{
ddeaf645 416 return S_mg_findext_flags(sv, type, NULL, 0);
39de7f53
FR
417}
418
419/*
420=for apidoc mg_findext
421
422Finds the magic pointer of C<type> with the given C<vtbl> for the C<SV>. See
423C<sv_magicext>.
424
425=cut
426*/
427
428MAGIC*
ddeaf645 429Perl_mg_findext(const SV *sv, int type, const MGVTBL *vtbl)
39de7f53 430{
ddeaf645 431 return S_mg_findext_flags(sv, type, vtbl, 1);
93a17b20
LW
432}
433
96c2a8ff
FC
434MAGIC *
435Perl_mg_find_mglob(pTHX_ SV *sv)
436{
437 PERL_ARGS_ASSERT_MG_FIND_MGLOB;
438 if (SvTYPE(sv) == SVt_PVLV && LvTYPE(sv) == 'y') {
439 /* This sv is only a delegate. //g magic must be attached to
440 its target. */
441 vivify_defelem(sv);
442 sv = LvTARG(sv);
443 }
444 if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv))
ddeaf645 445 return S_mg_findext_flags(sv, PERL_MAGIC_regex_global, 0, 0);
96c2a8ff
FC
446 return NULL;
447}
448
954c1994
GS
449/*
450=for apidoc mg_copy
451
452Copies the magic from one SV to another. See C<sv_magic>.
453
454=cut
455*/
456
79072805 457int
864dbfa3 458Perl_mg_copy(pTHX_ SV *sv, SV *nsv, const char *key, I32 klen)
79072805 459{
463ee0b2 460 int count = 0;
79072805 461 MAGIC* mg;
7918f24d
NC
462
463 PERL_ARGS_ASSERT_MG_COPY;
464
463ee0b2 465 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
35a4481c 466 const MGVTBL* const vtbl = mg->mg_virtual;
68795e93 467 if ((mg->mg_flags & MGf_COPY) && vtbl->svt_copy){
16c91539 468 count += vtbl->svt_copy(aTHX_ sv, mg, nsv, key, klen);
68795e93 469 }
823a54a3
AL
470 else {
471 const char type = mg->mg_type;
1e73acc8 472 if (isUPPER(type) && type != PERL_MAGIC_uvar) {
823a54a3
AL
473 sv_magic(nsv,
474 (type == PERL_MAGIC_tied)
475 ? SvTIED_obj(sv, mg)
476 : (type == PERL_MAGIC_regdata && mg->mg_obj)
477 ? sv
478 : mg->mg_obj,
479 toLOWER(type), key, klen);
480 count++;
481 }
79072805 482 }
79072805 483 }
463ee0b2 484 return count;
79072805
LW
485}
486
954c1994 487/*
0cbee0a4
DM
488=for apidoc mg_localize
489
9711599e 490Copy some of the magic from an existing SV to new localized version of that
154e47c8
FC
491SV. Container magic (eg %ENV, $1, tie)
492gets copied, value magic doesn't (eg
9711599e
CS
493taint, pos).
494
af7df257 495If setmagic is false then no set magic will be called on the new (empty) SV.
9711599e
CS
496This typically means that assignment will soon follow (e.g. 'local $x = $y'),
497and that will handle the magic.
0cbee0a4
DM
498
499=cut
500*/
501
502void
af7df257 503Perl_mg_localize(pTHX_ SV *sv, SV *nsv, bool setmagic)
0cbee0a4
DM
504{
505 MAGIC *mg;
7918f24d
NC
506
507 PERL_ARGS_ASSERT_MG_LOCALIZE;
508
658a9f31
JD
509 if (nsv == DEFSV)
510 return;
511
0cbee0a4 512 for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
2b1b43ea 513 const MGVTBL* const vtbl = mg->mg_virtual;
e0a73de4 514 if (PERL_MAGIC_TYPE_IS_VALUE_MAGIC(mg->mg_type))
0cbee0a4 515 continue;
0cbee0a4 516
a5063e7c 517 if ((mg->mg_flags & MGf_LOCAL) && vtbl->svt_local)
16c91539 518 (void)vtbl->svt_local(aTHX_ nsv, mg);
a5063e7c 519 else
0cbee0a4
DM
520 sv_magicext(nsv, mg->mg_obj, mg->mg_type, vtbl,
521 mg->mg_ptr, mg->mg_len);
a5063e7c 522
0cbee0a4 523 /* container types should remain read-only across localization */
9ff3e6d8 524 SvFLAGS(nsv) |= SvREADONLY(sv);
0cbee0a4
DM
525 }
526
527 if (SvTYPE(nsv) >= SVt_PVMG && SvMAGIC(nsv)) {
528 SvFLAGS(nsv) |= SvMAGICAL(sv);
af7df257 529 if (setmagic) {
9711599e
CS
530 PL_localizing = 1;
531 SvSETMAGIC(nsv);
532 PL_localizing = 0;
533 }
0cbee0a4
DM
534 }
535}
536
d9088386
Z
537#define mg_free_struct(sv, mg) S_mg_free_struct(aTHX_ sv, mg)
538static void
539S_mg_free_struct(pTHX_ SV *sv, MAGIC *mg)
540{
541 const MGVTBL* const vtbl = mg->mg_virtual;
542 if (vtbl && vtbl->svt_free)
543 vtbl->svt_free(aTHX_ sv, mg);
544 if (mg->mg_ptr && mg->mg_type != PERL_MAGIC_regex_global) {
545 if (mg->mg_len > 0 || mg->mg_type == PERL_MAGIC_utf8)
546 Safefree(mg->mg_ptr);
547 else if (mg->mg_len == HEf_SVKEY)
548 SvREFCNT_dec(MUTABLE_SV(mg->mg_ptr));
549 }
550 if (mg->mg_flags & MGf_REFCOUNTED)
551 SvREFCNT_dec(mg->mg_obj);
552 Safefree(mg);
553}
554
0cbee0a4 555/*
954c1994
GS
556=for apidoc mg_free
557
558Free any magic storage used by the SV. See C<sv_magic>.
559
560=cut
561*/
562
79072805 563int
864dbfa3 564Perl_mg_free(pTHX_ SV *sv)
79072805
LW
565{
566 MAGIC* mg;
567 MAGIC* moremagic;
7918f24d
NC
568
569 PERL_ARGS_ASSERT_MG_FREE;
570
79072805 571 for (mg = SvMAGIC(sv); mg; mg = moremagic) {
79072805 572 moremagic = mg->mg_moremagic;
d9088386 573 mg_free_struct(sv, mg);
c826f41b 574 SvMAGIC_set(sv, moremagic);
79072805 575 }
b162af07 576 SvMAGIC_set(sv, NULL);
68f8932e 577 SvMAGICAL_off(sv);
79072805
LW
578 return 0;
579}
580
d9088386
Z
581/*
582=for apidoc Am|void|mg_free_type|SV *sv|int how
583
584Remove any magic of type I<how> from the SV I<sv>. See L</sv_magic>.
585
586=cut
587*/
588
589void
590Perl_mg_free_type(pTHX_ SV *sv, int how)
591{
592 MAGIC *mg, *prevmg, *moremg;
593 PERL_ARGS_ASSERT_MG_FREE_TYPE;
594 for (prevmg = NULL, mg = SvMAGIC(sv); mg; prevmg = mg, mg = moremg) {
595 MAGIC *newhead;
596 moremg = mg->mg_moremagic;
597 if (mg->mg_type == how) {
598 /* temporarily move to the head of the magic chain, in case
599 custom free code relies on this historical aspect of mg_free */
600 if (prevmg) {
601 prevmg->mg_moremagic = moremg;
602 mg->mg_moremagic = SvMAGIC(sv);
603 SvMAGIC_set(sv, mg);
604 }
605 newhead = mg->mg_moremagic;
606 mg_free_struct(sv, mg);
607 SvMAGIC_set(sv, newhead);
608 mg = prevmg;
609 }
610 }
611 mg_magical(sv);
612}
613
79072805 614#include <signal.h>
79072805 615
942e002e 616U32
864dbfa3 617Perl_magic_regdata_cnt(pTHX_ SV *sv, MAGIC *mg)
6cef1e77 618{
8772537c 619 PERL_UNUSED_ARG(sv);
6cef1e77 620
7918f24d
NC
621 PERL_ARGS_ASSERT_MAGIC_REGDATA_CNT;
622
0bd48802 623 if (PL_curpm) {
eb578fdb 624 const REGEXP * const rx = PM_GETRE(PL_curpm);
0bd48802 625 if (rx) {
a678b0e4
YO
626 if (mg->mg_obj) { /* @+ */
627 /* return the number possible */
07bc277f 628 return RX_NPARENS(rx);
a678b0e4 629 } else { /* @- */
07bc277f 630 I32 paren = RX_LASTPAREN(rx);
a678b0e4
YO
631
632 /* return the last filled */
f46c4081 633 while ( paren >= 0
07bc277f
NC
634 && (RX_OFFS(rx)[paren].start == -1
635 || RX_OFFS(rx)[paren].end == -1) )
f46c4081 636 paren--;
a678b0e4
YO
637 return (U32)paren;
638 }
0bd48802 639 }
8f580fb8 640 }
ac27b0f5 641
942e002e 642 return (U32)-1;
6cef1e77
IZ
643}
644
6502e081
DM
645/* @-, @+ */
646
6cef1e77 647int
864dbfa3 648Perl_magic_regdatum_get(pTHX_ SV *sv, MAGIC *mg)
6cef1e77 649{
7918f24d
NC
650 PERL_ARGS_ASSERT_MAGIC_REGDATUM_GET;
651
0bd48802 652 if (PL_curpm) {
eb578fdb 653 const REGEXP * const rx = PM_GETRE(PL_curpm);
0bd48802 654 if (rx) {
eb578fdb 655 const I32 paren = mg->mg_len;
a10eae29
FC
656 SSize_t s;
657 SSize_t t;
0bd48802
AL
658 if (paren < 0)
659 return 0;
07bc277f
NC
660 if (paren <= (I32)RX_NPARENS(rx) &&
661 (s = RX_OFFS(rx)[paren].start) != -1 &&
662 (t = RX_OFFS(rx)[paren].end) != -1)
0bd48802 663 {
a10eae29 664 SSize_t i;
0bd48802
AL
665 if (mg->mg_obj) /* @+ */
666 i = t;
667 else /* @- */
668 i = s;
669
a10eae29 670 if (RX_MATCH_UTF8(rx)) {
07bc277f 671 const char * const b = RX_SUBBEG(rx);
0bd48802 672 if (b)
6502e081
DM
673 i = RX_SUBCOFFSET(rx) +
674 utf8_length((U8*)b,
675 (U8*)(b-RX_SUBOFFSET(rx)+i));
0bd48802 676 }
727405f8 677
a10eae29 678 sv_setuv(sv, i);
232af1f8 679 return 0;
1aa99e6b 680 }
0bd48802 681 }
6cef1e77 682 }
232af1f8 683 sv_setsv(sv, NULL);
6cef1e77
IZ
684 return 0;
685}
686
6502e081
DM
687/* @-, @+ */
688
e4b89193 689int
a29d06ed
MG
690Perl_magic_regdatum_set(pTHX_ SV *sv, MAGIC *mg)
691{
7918f24d 692 PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET;
dc3bf405 693 PERL_UNUSED_CONTEXT;
d4c19fe8
AL
694 PERL_UNUSED_ARG(sv);
695 PERL_UNUSED_ARG(mg);
cb077ed2 696 Perl_croak_no_modify();
0dbb1585 697 NORETURN_FUNCTION_END;
a29d06ed
MG
698}
699
ad3296c6 700#define SvRTRIM(sv) STMT_START { \
eae92ea0
GA
701 if (SvPOK(sv)) { \
702 STRLEN len = SvCUR(sv); \
703 char * const p = SvPVX(sv); \
8e6b4db6
PC
704 while (len > 0 && isSPACE(p[len-1])) \
705 --len; \
706 SvCUR_set(sv, len); \
707 p[len] = '\0'; \
708 } \
ad3296c6
SH
709} STMT_END
710
8b850bd5
NC
711void
712Perl_emulate_cop_io(pTHX_ const COP *const c, SV *const sv)
713{
7918f24d
NC
714 PERL_ARGS_ASSERT_EMULATE_COP_IO;
715
8b850bd5
NC
716 if (!(CopHINTS_get(c) & (HINT_LEXICAL_IO_IN|HINT_LEXICAL_IO_OUT)))
717 sv_setsv(sv, &PL_sv_undef);
718 else {
719 sv_setpvs(sv, "");
720 SvUTF8_off(sv);
721 if ((CopHINTS_get(c) & HINT_LEXICAL_IO_IN)) {
20439bc7 722 SV *const value = cop_hints_fetch_pvs(c, "open<", 0);
8b850bd5
NC
723 assert(value);
724 sv_catsv(sv, value);
725 }
726 sv_catpvs(sv, "\0");
727 if ((CopHINTS_get(c) & HINT_LEXICAL_IO_OUT)) {
20439bc7 728 SV *const value = cop_hints_fetch_pvs(c, "open>", 0);
8b850bd5
NC
729 assert(value);
730 sv_catsv(sv, value);
731 }
732 }
733}
734
d9fe7d23
KW
735STATIC void
736S_fixup_errno_string(pTHX_ SV* sv)
737{
738 /* Do what is necessary to fixup the non-empty string in 'sv' for return to
739 * Perl space. */
740
741 PERL_ARGS_ASSERT_FIXUP_ERRNO_STRING;
742
743 assert(SvOK(sv));
b35e4f8b
KW
744
745 if(strEQ(SvPVX(sv), "")) {
746 sv_catpv(sv, UNKNOWN_ERRNO_MSG);
747 }
748 else {
d9fe7d23 749
d3c0b317
KW
750 /* In some locales the error string may come back as UTF-8, in which
751 * case we should turn on that flag. This didn't use to happen, and to
5320b60d
KW
752 * avoid as many possible backward compatibility issues as possible, we
753 * don't turn on the flag unless we have to. So the flag stays off for
754 * an entirely ASCII string. We assume that if the string looks like
755 * UTF-8, it really is UTF-8: "text in any other encoding that uses
756 * bytes with the high bit set is extremely unlikely to pass a UTF-8
757 * validity test" (http://en.wikipedia.org/wiki/Charset_detection).
758 * There is a potential that we will get it wrong however, especially
759 * on short error message text. (If it turns out to be necessary, we
760 * could also keep track if the current LC_MESSAGES locale is UTF-8) */
d3c0b317
KW
761 if (! IN_BYTES /* respect 'use bytes' */
762 && ! is_ascii_string((U8*) SvPVX_const(sv), SvCUR(sv))
763 && is_utf8_string((U8*) SvPVX_const(sv), SvCUR(sv)))
764 {
765 SvUTF8_on(sv);
766 }
b35e4f8b 767 }
d9fe7d23
KW
768}
769
25bbd826
CB
770#ifdef VMS
771#include <descrip.h>
772#include <starlet.h>
773#endif
774
79072805 775int
864dbfa3 776Perl_magic_get(pTHX_ SV *sv, MAGIC *mg)
79072805 777{
eb578fdb
KW
778 I32 paren;
779 const char *s = NULL;
780 REGEXP *rx;
823a54a3 781 const char * const remaining = mg->mg_ptr + 1;
e91d8259 782 char nextchar;
79072805 783
7918f24d
NC
784 PERL_ARGS_ASSERT_MAGIC_GET;
785
e91d8259 786 if (!mg->mg_ptr) {
e91d8259 787 paren = mg->mg_len;
e91d8259 788 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
a6d0b1b5 789 do_numbuf_fetch:
e91d8259
NC
790 CALLREG_NUMBUF_FETCH(rx,paren,sv);
791 } else {
792 sv_setsv(sv,&PL_sv_undef);
793 }
794 return 0;
795 }
796
797 nextchar = *remaining;
79072805 798 switch (*mg->mg_ptr) {
748a9306 799 case '\001': /* ^A */
f2da823f
FC
800 if (SvOK(PL_bodytarget)) sv_copypv(sv, PL_bodytarget);
801 else sv_setsv(sv, &PL_sv_undef);
125b9982
NT
802 if (SvTAINTED(PL_bodytarget))
803 SvTAINTED_on(sv);
748a9306 804 break;
e5218da5 805 case '\003': /* ^C, ^CHILD_ERROR_NATIVE */
823a54a3 806 if (nextchar == '\0') {
e5218da5
GA
807 sv_setiv(sv, (IV)PL_minus_c);
808 }
823a54a3 809 else if (strEQ(remaining, "HILD_ERROR_NATIVE")) {
e5218da5
GA
810 sv_setiv(sv, (IV)STATUS_NATIVE);
811 }
49460fe6
NIS
812 break;
813
79072805 814 case '\004': /* ^D */
aea4f609 815 sv_setiv(sv, (IV)(PL_debug & DEBUG_MASK));
79072805 816 break;
28f23441 817 case '\005': /* ^E */
6c6eab55
KW
818 if (nextchar != '\0') {
819 if (strEQ(remaining, "NCODING"))
820 sv_setsv(sv, PL_encoding);
4f4ff3a7 821 break;
6c6eab55 822 }
4f4ff3a7
KW
823
824#if defined(VMS) || defined(OS2) || defined(WIN32)
825# if defined(VMS)
2a99ff86
KW
826 {
827 char msg[255];
828 $DESCRIPTOR(msgdsc,msg);
829 sv_setnv(sv,(NV) vaxc$errno);
830 if (sys$getmsg(vaxc$errno,&msgdsc.dsc$w_length,&msgdsc,0,0) & 1)
831 sv_setpvn(sv,msgdsc.dsc$a_pointer,msgdsc.dsc$w_length);
832 else
833 sv_setpvs(sv,"");
834 }
4b645107 835#elif defined(OS2)
2a99ff86
KW
836 if (!(_emx_env & 0x200)) { /* Under DOS */
837 sv_setnv(sv, (NV)errno);
2c6ee1a7 838 sv_setpv(sv, errno ? my_strerror(errno) : "");
2a99ff86
KW
839 } else {
840 if (errno != errno_isOS2) {
841 const int tmp = _syserrno();
842 if (tmp) /* 2nd call to _syserrno() makes it 0 */
843 Perl_rc = tmp;
844 }
845 sv_setnv(sv, (NV)Perl_rc);
846 sv_setpv(sv, os2error(Perl_rc));
847 }
1534c6f5 848 if (SvOK(sv) && strNE(SvPVX(sv), "")) {
99461a73
KW
849 fixup_errno_string(sv);
850 }
4f4ff3a7 851# elif defined(WIN32)
2a99ff86
KW
852 {
853 const DWORD dwErr = GetLastError();
854 sv_setnv(sv, (NV)dwErr);
855 if (dwErr) {
856 PerlProc_GetOSError(sv, dwErr);
2efab60d 857 fixup_errno_string(sv);
2a99ff86
KW
858 }
859 else
860 sv_setpvs(sv, "");
861 SetLastError(dwErr);
862 }
4f4ff3a7
KW
863# else
864# error Missing code for platform
865# endif
2a99ff86
KW
866 SvRTRIM(sv);
867 SvNOK_on(sv); /* what a wonderful hack! */
868 break;
4f4ff3a7
KW
869#endif /* End of platforms with special handling for $^E; others just fall
870 through to $! */
46f3e16c
KW
871
872 case '!':
873 {
5f1b979d 874 dSAVE_ERRNO;
46f3e16c 875#ifdef VMS
5f1b979d 876 sv_setnv(sv, (NV)((errno == EVMSERR) ? vaxc$errno : errno));
46f3e16c 877#else
5f1b979d 878 sv_setnv(sv, (NV)errno);
46f3e16c
KW
879#endif
880#ifdef OS2
5f1b979d
KW
881 if (errno == errno_isOS2 || errno == errno_isOS2_set)
882 sv_setpv(sv, os2error(Perl_rc));
883 else
46f3e16c 884#endif
5f1b979d
KW
885 if (! errno) {
886 sv_setpvs(sv, "");
46f3e16c 887 }
5f1b979d
KW
888 else {
889
890 /* Strerror can return NULL on some platforms, which will
891 * result in 'sv' not being considered SvOK. The SvNOK_on()
892 * below will cause just the number part to be valid */
2c6ee1a7 893 sv_setpv(sv, my_strerror(errno));
5f1b979d
KW
894 if (SvOK(sv)) {
895 fixup_errno_string(sv);
896 }
897 }
898 RESTORE_ERRNO;
46f3e16c
KW
899 }
900
901 SvRTRIM(sv);
902 SvNOK_on(sv); /* what a wonderful hack! */
903 break;
904
79072805 905 case '\006': /* ^F */
3280af22 906 sv_setiv(sv, (IV)PL_maxsysfd);
79072805 907 break;
9ebf26ad
FR
908 case '\007': /* ^GLOBAL_PHASE */
909 if (strEQ(remaining, "LOBAL_PHASE")) {
910 sv_setpvn(sv, PL_phase_names[PL_phase],
911 strlen(PL_phase_names[PL_phase]));
912 }
913 break;
a0d0e21e 914 case '\010': /* ^H */
3280af22 915 sv_setiv(sv, (IV)PL_hints);
a0d0e21e 916 break;
9d116dd7 917 case '\011': /* ^I */ /* NOT \t in EBCDIC */
120f7abe 918 sv_setpv(sv, PL_inplace); /* Will undefine sv if PL_inplace is NULL */
79072805 919 break;
8561ea1d
FC
920 case '\014': /* ^LAST_FH */
921 if (strEQ(remaining, "AST_FH")) {
922 if (PL_last_in_gv) {
923 assert(isGV_with_GP(PL_last_in_gv));
924 SV_CHECK_THINKFIRST_COW_DROP(sv);
925 prepare_SV_for_RV(sv);
926 SvOK_off(sv);
927 SvRV_set(sv, SvREFCNT_inc_simple_NN(PL_last_in_gv));
928 SvROK_on(sv);
929 sv_rvweaken(sv);
930 }
931 else sv_setsv_nomg(sv, NULL);
932 }
933 break;
ac27b0f5 934 case '\017': /* ^O & ^OPEN */
823a54a3 935 if (nextchar == '\0') {
ac27b0f5 936 sv_setpv(sv, PL_osname);
3511154c
DM
937 SvTAINTED_off(sv);
938 }
823a54a3 939 else if (strEQ(remaining, "PEN")) {
8b850bd5 940 Perl_emulate_cop_io(aTHX_ &PL_compiling, sv);
ac27b0f5 941 }
28f23441 942 break;
9ebf26ad 943 case '\020':
a6d0b1b5 944 sv_setiv(sv, (IV)PL_perldb);
79072805 945 break;
fb73857a 946 case '\023': /* ^S */
a6d0b1b5 947 {
bc177e6b 948 if (PL_parser && PL_parser->lex_state != LEX_NOTPARSING)
0c34ef67 949 SvOK_off(sv);
3280af22 950 else if (PL_in_eval)
6dc8a9e4 951 sv_setiv(sv, PL_in_eval & ~(EVAL_INREQUIRE));
a4268c0a
AMS
952 else
953 sv_setiv(sv, 0);
d58bf5aa 954 }
fb73857a 955 break;
79072805 956 case '\024': /* ^T */
823a54a3 957 if (nextchar == '\0') {
88e89b8a 958#ifdef BIG_TIME
7c36658b 959 sv_setnv(sv, PL_basetime);
88e89b8a 960#else
7c36658b 961 sv_setiv(sv, (IV)PL_basetime);
88e89b8a 962#endif
7c36658b 963 }
823a54a3 964 else if (strEQ(remaining, "AINT"))
284167a5
SM
965 sv_setiv(sv, TAINTING_get
966 ? (TAINT_WARN_get || PL_unsafe ? -1 : 1)
9aa05f58 967 : 0);
7c36658b 968 break;
e07ea26a 969 case '\025': /* $^UNICODE, $^UTF8LOCALE, $^UTF8CACHE */
823a54a3 970 if (strEQ(remaining, "NICODE"))
a05d7ebb 971 sv_setuv(sv, (UV) PL_unicode);
823a54a3 972 else if (strEQ(remaining, "TF8LOCALE"))
7cebcbc0 973 sv_setuv(sv, (UV) PL_utf8locale);
e07ea26a
NC
974 else if (strEQ(remaining, "TF8CACHE"))
975 sv_setiv(sv, (IV) PL_utf8cache);
fde18df1
JH
976 break;
977 case '\027': /* ^W & $^WARNING_BITS */
823a54a3 978 if (nextchar == '\0')
4438c4b7 979 sv_setiv(sv, (IV)((PL_dowarn & G_WARN_ON) ? TRUE : FALSE));
823a54a3 980 else if (strEQ(remaining, "ARNING_BITS")) {
013b78e8 981 if (PL_compiling.cop_warnings == pWARN_NONE) {
4438c4b7 982 sv_setpvn(sv, WARN_NONEstring, WARNsize) ;
013b78e8
RGS
983 }
984 else if (PL_compiling.cop_warnings == pWARN_STD) {
7e4f0450
FC
985 sv_setsv(sv, &PL_sv_undef);
986 break;
013b78e8 987 }
d3a7d8c7 988 else if (PL_compiling.cop_warnings == pWARN_ALL) {
75b6c4ca
RGS
989 /* Get the bit mask for $warnings::Bits{all}, because
990 * it could have been extended by warnings::register */
4bac9ae4
CS
991 HV * const bits = get_hv("warnings::Bits", 0);
992 SV ** const bits_all = bits ? hv_fetchs(bits, "all", FALSE) : NULL;
993 if (bits_all)
994 sv_copypv(sv, *bits_all);
995 else
996 sv_setpvn(sv, WARN_ALLstring, WARNsize);
ac27b0f5 997 }
4438c4b7 998 else {
72dc9ed5
NC
999 sv_setpvn(sv, (char *) (PL_compiling.cop_warnings + 1),
1000 *PL_compiling.cop_warnings);
ac27b0f5 1001 }
4438c4b7 1002 }
79072805 1003 break;
79072805 1004 case '+':
aaa362c4 1005 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
2c7b5d76
DM
1006 paren = RX_LASTPAREN(rx);
1007 if (paren)
1008 goto do_numbuf_fetch;
79072805 1009 }
3280af22 1010 sv_setsv(sv,&PL_sv_undef);
79072805 1011 break;
a01268b5
JH
1012 case '\016': /* ^N */
1013 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
2c7b5d76
DM
1014 paren = RX_LASTCLOSEPAREN(rx);
1015 if (paren)
1016 goto do_numbuf_fetch;
a01268b5
JH
1017 }
1018 sv_setsv(sv,&PL_sv_undef);
1019 break;
79072805 1020 case '.':
3280af22 1021 if (GvIO(PL_last_in_gv)) {
357c8808 1022 sv_setiv(sv, (IV)IoLINES(GvIOp(PL_last_in_gv)));
79072805 1023 }
79072805
LW
1024 break;
1025 case '?':
809a5acc 1026 {
809a5acc 1027 sv_setiv(sv, (IV)STATUS_CURRENT);
ff0cee69 1028#ifdef COMPLEX_STATUS
41cb7b2b 1029 SvUPGRADE(sv, SVt_PVLV);
6b88bc9c
GS
1030 LvTARGOFF(sv) = PL_statusvalue;
1031 LvTARGLEN(sv) = PL_statusvalue_vms;
ff0cee69 1032#endif
809a5acc 1033 }
79072805
LW
1034 break;
1035 case '^':
acbe1b9d 1036 if (GvIOp(PL_defoutgv))
099be4f1 1037 s = IoTOP_NAME(GvIOp(PL_defoutgv));
79072805
LW
1038 if (s)
1039 sv_setpv(sv,s);
1040 else {
3280af22 1041 sv_setpv(sv,GvENAME(PL_defoutgv));
cb421d5e 1042 sv_catpvs(sv,"_TOP");
79072805
LW
1043 }
1044 break;
1045 case '~':
acbe1b9d 1046 if (GvIOp(PL_defoutgv))
0daa599b 1047 s = IoFMT_NAME(GvIOp(PL_defoutgv));
79072805 1048 if (!s)
3280af22 1049 s = GvENAME(PL_defoutgv);
79072805
LW
1050 sv_setpv(sv,s);
1051 break;
79072805 1052 case '=':
099be4f1 1053 if (GvIO(PL_defoutgv))
0daa599b 1054 sv_setiv(sv, (IV)IoPAGE_LEN(GvIOp(PL_defoutgv)));
79072805
LW
1055 break;
1056 case '-':
099be4f1 1057 if (GvIO(PL_defoutgv))
0daa599b 1058 sv_setiv(sv, (IV)IoLINES_LEFT(GvIOp(PL_defoutgv)));
79072805
LW
1059 break;
1060 case '%':
099be4f1 1061 if (GvIO(PL_defoutgv))
0daa599b 1062 sv_setiv(sv, (IV)IoPAGE(GvIOp(PL_defoutgv)));
79072805 1063 break;
79072805
LW
1064 case ':':
1065 break;
1066 case '/':
1067 break;
1068 case '[':
e1dccc0d 1069 sv_setiv(sv, 0);
79072805
LW
1070 break;
1071 case '|':
099be4f1 1072 if (GvIO(PL_defoutgv))
0daa599b 1073 sv_setiv(sv, (IV)(IoFLAGS(GvIOp(PL_defoutgv)) & IOf_FLUSH) != 0 );
79072805 1074 break;
79072805 1075 case '\\':
b2ce0fda 1076 if (PL_ors_sv)
f28098ff 1077 sv_copypv(sv, PL_ors_sv);
4bac9ae4
CS
1078 else
1079 sv_setsv(sv, &PL_sv_undef);
79072805 1080 break;
0e219455 1081 case '$': /* $$ */
9cdac2a2
FC
1082 {
1083 IV const pid = (IV)PerlProc_getpid();
19db9fb7 1084 if (isGV(mg->mg_obj) || SvIV(mg->mg_obj) != pid) {
9cdac2a2
FC
1085 /* never set manually, or at least not since last fork */
1086 sv_setiv(sv, pid);
19db9fb7
Z
1087 /* never unsafe, even if reading in a tainted expression */
1088 SvTAINTED_off(sv);
1089 }
9cdac2a2
FC
1090 /* else a value has been assigned manually, so do nothing */
1091 }
0e219455 1092 break;
79072805 1093 case '<':
dfff4baf 1094 sv_setuid(sv, PerlProc_getuid());
79072805
LW
1095 break;
1096 case '>':
dfff4baf 1097 sv_setuid(sv, PerlProc_geteuid());
79072805
LW
1098 break;
1099 case '(':
dfff4baf 1100 sv_setgid(sv, PerlProc_getgid());
79072805
LW
1101 goto add_groups;
1102 case ')':
dfff4baf 1103 sv_setgid(sv, PerlProc_getegid());
79072805 1104 add_groups:
79072805 1105#ifdef HAS_GETGROUPS
79072805 1106 {
57d7c65e 1107 Groups_t *gary = NULL;
375ed12a
JH
1108 I32 i;
1109 I32 num_groups = getgroups(0, gary);
1110 if (num_groups > 0) {
1111 Newx(gary, num_groups, Groups_t);
1112 num_groups = getgroups(num_groups, gary);
1113 for (i = 0; i < num_groups; i++)
1114 Perl_sv_catpvf(aTHX_ sv, " %"IVdf, (IV)gary[i]);
1115 Safefree(gary);
1116 }
79072805 1117 }
155aba94 1118 (void)SvIOK_on(sv); /* what a wonderful hack! */
cd70abae 1119#endif
79072805 1120 break;
79072805
LW
1121 case '0':
1122 break;
1123 }
a0d0e21e 1124 return 0;
79072805
LW
1125}
1126
1127int
864dbfa3 1128Perl_magic_getuvar(pTHX_ SV *sv, MAGIC *mg)
79072805 1129{
8772537c 1130 struct ufuncs * const uf = (struct ufuncs *)mg->mg_ptr;
79072805 1131
7918f24d
NC
1132 PERL_ARGS_ASSERT_MAGIC_GETUVAR;
1133
79072805 1134 if (uf && uf->uf_val)
24f81a43 1135 (*uf->uf_val)(aTHX_ uf->uf_index, sv);
79072805
LW
1136 return 0;
1137}
1138
1139int
864dbfa3 1140Perl_magic_setenv(pTHX_ SV *sv, MAGIC *mg)
79072805 1141{
9ae3433d 1142 STRLEN len = 0, klen;
12033064 1143 const char * const key = MgPV_const(mg,klen);
888a67f6 1144 const char *s = "";
1e422769 1145
7918f24d
NC
1146 PERL_ARGS_ASSERT_MAGIC_SETENV;
1147
613c63b4 1148 SvGETMAGIC(sv);
12033064 1149 if (SvOK(sv)) {
613c63b4
CS
1150 /* defined environment variables are byte strings; unfortunately
1151 there is no SvPVbyte_force_nomg(), so we must do this piecewise */
1152 (void)SvPV_force_nomg_nolen(sv);
1153 sv_utf8_downgrade(sv, /* fail_ok */ TRUE);
1154 if (SvUTF8(sv)) {
1155 Perl_ck_warner_d(aTHX_ packWARN(WARN_UTF8), "Wide character in %s", "setenv");
1156 SvUTF8_off(sv);
1157 }
1158 s = SvPVX(sv);
1159 len = SvCUR(sv);
12033064
CS
1160 }
1161 my_setenv(key, s); /* does the deed */
1162
a0d0e21e
LW
1163#ifdef DYNAMIC_ENV_FETCH
1164 /* We just undefd an environment var. Is a replacement */
1165 /* waiting in the wings? */
1166 if (!len) {
6bd66ee9 1167 SV ** const valp = hv_fetch(GvHVn(PL_envgv), key, klen, FALSE);
fabdb6c0 1168 if (valp)
4ab59fcc 1169 s = SvOK(*valp) ? SvPV_const(*valp, len) : "";
a0d0e21e
LW
1170 }
1171#endif
1e422769 1172
39e571d4 1173#if !defined(OS2) && !defined(AMIGAOS) && !defined(WIN32) && !defined(MSDOS)
79072805
LW
1174 /* And you'll never guess what the dog had */
1175 /* in its mouth... */
284167a5 1176 if (TAINTING_get) {
1e422769
PP
1177 MgTAINTEDDIR_off(mg);
1178#ifdef VMS
6bd66ee9 1179 if (s && klen == 8 && strEQ(key, "DCL$PATH")) {
b8ffc8df 1180 char pathbuf[256], eltbuf[256], *cp, *elt;
1e422769
PP
1181 int i = 0, j = 0;
1182
6fca0082 1183 my_strlcpy(eltbuf, s, sizeof(eltbuf));
b8ffc8df 1184 elt = eltbuf;
1e422769
PP
1185 do { /* DCL$PATH may be a search list */
1186 while (1) { /* as may dev portion of any element */
1187 if ( ((cp = strchr(elt,'[')) || (cp = strchr(elt,'<'))) ) {
1188 if ( *(cp+1) == '.' || *(cp+1) == '-' ||
1189 cando_by_name(S_IWUSR,0,elt) ) {
1190 MgTAINTEDDIR_on(mg);
1191 return 0;
1192 }
1193 }
bd61b366 1194 if ((cp = strchr(elt, ':')) != NULL)
1e422769
PP
1195 *cp = '\0';
1196 if (my_trnlnm(elt, eltbuf, j++))
1197 elt = eltbuf;
1198 else
1199 break;
1200 }
1201 j = 0;
1202 } while (my_trnlnm(s, pathbuf, i++) && (elt = pathbuf));
1203 }
1204#endif /* VMS */
12033064 1205 if (s && klen == 4 && strEQ(key,"PATH")) {
8772537c 1206 const char * const strend = s + len;
463ee0b2
LW
1207
1208 while (s < strend) {
96827780 1209 char tmpbuf[256];
c623ac67 1210 Stat_t st;
5f74f29c 1211 I32 i;
f5a63d97
AL
1212#ifdef VMS /* Hmm. How do we get $Config{path_sep} from C? */
1213 const char path_sep = '|';
1214#else
1215 const char path_sep = ':';
1216#endif
96827780 1217 s = delimcpy(tmpbuf, tmpbuf + sizeof tmpbuf,
427eaa01 1218 s, strend, path_sep, &i);
463ee0b2 1219 s++;
bb7a0f54 1220 if (i >= (I32)sizeof tmpbuf /* too long -- assume the worst */
326b5008
CB
1221#ifdef VMS
1222 || !strchr(tmpbuf, ':') /* no colon thus no device name -- assume relative path */
1223#else
1224 || *tmpbuf != '/' /* no starting slash -- assume relative path */
1225#endif
c6ed36e1 1226 || (PerlLIO_stat(tmpbuf, &st) == 0 && (st.st_mode & 2)) ) {
8990e307 1227 MgTAINTEDDIR_on(mg);
1e422769
PP
1228 return 0;
1229 }
463ee0b2 1230 }
79072805
LW
1231 }
1232 }
39e571d4 1233#endif /* neither OS2 nor AMIGAOS nor WIN32 nor MSDOS */
1e422769 1234
79072805
LW
1235 return 0;
1236}
1237
1238int
864dbfa3 1239Perl_magic_clearenv(pTHX_ SV *sv, MAGIC *mg)
85e6fe83 1240{
7918f24d 1241 PERL_ARGS_ASSERT_MAGIC_CLEARENV;
8772537c 1242 PERL_UNUSED_ARG(sv);
bd61b366 1243 my_setenv(MgPV_nolen_const(mg),NULL);
85e6fe83
LW
1244 return 0;
1245}
1246
88e89b8a 1247int
864dbfa3 1248Perl_magic_set_all_env(pTHX_ SV *sv, MAGIC *mg)
fb73857a 1249{
7918f24d 1250 PERL_ARGS_ASSERT_MAGIC_SET_ALL_ENV;
65e66c80 1251 PERL_UNUSED_ARG(mg);
b0269e46 1252#if defined(VMS)
cea2e8a9 1253 Perl_die(aTHX_ "Can't make list assignment to %%ENV on this system");
fb73857a 1254#else
3280af22 1255 if (PL_localizing) {
fb73857a 1256 HE* entry;
b0269e46 1257 my_clearenv();
85fbaab2
NC
1258 hv_iterinit(MUTABLE_HV(sv));
1259 while ((entry = hv_iternext(MUTABLE_HV(sv)))) {
fb73857a
PP
1260 I32 keylen;
1261 my_setenv(hv_iterkey(entry, &keylen),
85fbaab2 1262 SvPV_nolen_const(hv_iterval(MUTABLE_HV(sv), entry)));
fb73857a
PP
1263 }
1264 }
1265#endif
1266 return 0;
1267}
1268
1269int
864dbfa3 1270Perl_magic_clear_all_env(pTHX_ SV *sv, MAGIC *mg)
66b1d557 1271{
7918f24d 1272 PERL_ARGS_ASSERT_MAGIC_CLEAR_ALL_ENV;
8772537c
AL
1273 PERL_UNUSED_ARG(sv);
1274 PERL_UNUSED_ARG(mg);
b0269e46
AB
1275#if defined(VMS)
1276 Perl_die(aTHX_ "Can't make list assignment to %%ENV on this system");
1277#else
1278 my_clearenv();
1279#endif
3e3baf6d 1280 return 0;
66b1d557
HM
1281}
1282
64ca3a65 1283#ifndef PERL_MICRO
2d4fcd5e
AJ
1284#ifdef HAS_SIGPROCMASK
1285static void
1286restore_sigmask(pTHX_ SV *save_sv)
1287{
0bd48802 1288 const sigset_t * const ossetp = (const sigset_t *) SvPV_nolen_const( save_sv );
f5a63d97 1289 (void)sigprocmask(SIG_SETMASK, ossetp, NULL);
2d4fcd5e
AJ
1290}
1291#endif
66b1d557 1292int
864dbfa3 1293Perl_magic_getsig(pTHX_ SV *sv, MAGIC *mg)
88e89b8a 1294{
88e89b8a 1295 /* Are we fetching a signal entry? */
708854f2 1296 int i = (I16)mg->mg_private;
7918f24d
NC
1297
1298 PERL_ARGS_ASSERT_MAGIC_GETSIG;
1299
708854f2 1300 if (!i) {
84c7b88c
BF
1301 STRLEN siglen;
1302 const char * sig = MgPV_const(mg, siglen);
1303 mg->mg_private = i = whichsig_pvn(sig, siglen);
708854f2
NC
1304 }
1305
e02bfb16 1306 if (i > 0) {
22c35a8c
GS
1307 if(PL_psig_ptr[i])
1308 sv_setsv(sv,PL_psig_ptr[i]);
88e89b8a 1309 else {
46da273f 1310 Sighandler_t sigstate = rsignal_state(i);
23ada85b 1311#ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
46da273f
AL
1312 if (PL_sig_handlers_initted && PL_sig_ignoring[i])
1313 sigstate = SIG_IGN;
2e34cc90
CL
1314#endif
1315#ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
46da273f
AL
1316 if (PL_sig_handlers_initted && PL_sig_defaulting[i])
1317 sigstate = SIG_DFL;
85b332e2 1318#endif
88e89b8a 1319 /* cache state so we don't fetch it again */
8aad04aa 1320 if(sigstate == (Sighandler_t) SIG_IGN)
6502358f 1321 sv_setpvs(sv,"IGNORE");
88e89b8a 1322 else
3280af22 1323 sv_setsv(sv,&PL_sv_undef);
46da273f 1324 PL_psig_ptr[i] = SvREFCNT_inc_simple_NN(sv);
88e89b8a
PP
1325 SvTEMP_off(sv);
1326 }
1327 }
1328 return 0;
1329}
1330int
864dbfa3 1331Perl_magic_clearsig(pTHX_ SV *sv, MAGIC *mg)
88e89b8a 1332{
7918f24d 1333 PERL_ARGS_ASSERT_MAGIC_CLEARSIG;
179c85a2 1334
38a124f0 1335 magic_setsig(NULL, mg);
179c85a2 1336 return sv_unmagic(sv, mg->mg_type);
88e89b8a 1337}
3d37d572 1338
0a8e0eff 1339Signal_t
8aad04aa 1340#if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
b6455c53 1341Perl_csighandler(int sig, siginfo_t *sip PERL_UNUSED_DECL, void *uap PERL_UNUSED_DECL)
8aad04aa 1342#else
0a8e0eff 1343Perl_csighandler(int sig)
8aad04aa 1344#endif
0a8e0eff 1345{
1018e26f
NIS
1346#ifdef PERL_GET_SIG_CONTEXT
1347 dTHXa(PERL_GET_SIG_CONTEXT);
1348#else
85b332e2
CL
1349 dTHX;
1350#endif
ffb6256b
JH
1351#if defined(__cplusplus) && defined(__GNUC__)
1352 /* g++ doesn't support PERL_UNUSED_DECL, so the sip and uap
1353 * parameters would be warned about. */
1354 PERL_UNUSED_ARG(sip);
1355 PERL_UNUSED_ARG(uap);
1356#endif
23ada85b 1357#ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
5c1546dc 1358 (void) rsignal(sig, PL_csighandlerp);
27da23d5 1359 if (PL_sig_ignoring[sig]) return;
85b332e2 1360#endif
2e34cc90 1361#ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
27da23d5 1362 if (PL_sig_defaulting[sig])
2e34cc90
CL
1363#ifdef KILL_BY_SIGPRC
1364 exit((Perl_sig_to_vmscondition(sig)&STS$M_COND_ID)|STS$K_SEVERE|STS$M_INHIB_MSG);
1365#else
1366 exit(1);
1367#endif
1368#endif
406878dd 1369 if (
853d2c32
RGS
1370#ifdef SIGILL
1371 sig == SIGILL ||
1372#endif
1373#ifdef SIGBUS
1374 sig == SIGBUS ||
1375#endif
1376#ifdef SIGSEGV
1377 sig == SIGSEGV ||
1378#endif
1379 (PL_signals & PERL_SIGNALS_UNSAFE_FLAG))
4ffa73a3 1380 /* Call the perl level handler now--
31c91b43 1381 * with risk we may be in malloc() or being destructed etc. */
6e324d09 1382#if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
80626cf1 1383 (*PL_sighandlerp)(sig, NULL, NULL);
6e324d09
CB
1384#else
1385 (*PL_sighandlerp)(sig);
92807b6d 1386#endif
406878dd 1387 else {
31c91b43 1388 if (!PL_psig_pend) return;
406878dd
GA
1389 /* Set a flag to say this signal is pending, that is awaiting delivery after
1390 * the current Perl opcode completes */
1391 PL_psig_pend[sig]++;
1392
1393#ifndef SIG_PENDING_DIE_COUNT
1394# define SIG_PENDING_DIE_COUNT 120
1395#endif
fe13d51d 1396 /* Add one to say _a_ signal is pending */
406878dd
GA
1397 if (++PL_sig_pending >= SIG_PENDING_DIE_COUNT)
1398 Perl_croak(aTHX_ "Maximal count of pending signals (%lu) exceeded",
1399 (unsigned long)SIG_PENDING_DIE_COUNT);
1400 }
0a8e0eff
NIS
1401}
1402
2e34cc90
CL
1403#if defined(FAKE_PERSISTENT_SIGNAL_HANDLERS) || defined(FAKE_DEFAULT_SIGNAL_HANDLERS)
1404void
1405Perl_csighandler_init(void)
1406{
1407 int sig;
27da23d5 1408 if (PL_sig_handlers_initted) return;
2e34cc90
CL
1409
1410 for (sig = 1; sig < SIG_SIZE; sig++) {
1411#ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
218fdd94 1412 dTHX;
27da23d5 1413 PL_sig_defaulting[sig] = 1;
5c1546dc 1414 (void) rsignal(sig, PL_csighandlerp);
2e34cc90
CL
1415#endif
1416#ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
27da23d5 1417 PL_sig_ignoring[sig] = 0;
2e34cc90
CL
1418#endif
1419 }
27da23d5 1420 PL_sig_handlers_initted = 1;
2e34cc90
CL
1421}
1422#endif
1423
7fe50b8b
LT
1424#if defined HAS_SIGPROCMASK
1425static void
1426unblock_sigmask(pTHX_ void* newset)
1427{
dc3bf405 1428 PERL_UNUSED_CONTEXT;
7fe50b8b
LT
1429 sigprocmask(SIG_UNBLOCK, (sigset_t*)newset, NULL);
1430}
1431#endif
1432
0a8e0eff
NIS
1433void
1434Perl_despatch_signals(pTHX)
1435{
1436 int sig;
1437 PL_sig_pending = 0;
1438 for (sig = 1; sig < SIG_SIZE; sig++) {
1439 if (PL_psig_pend[sig]) {
d0166017 1440 dSAVE_ERRNO;
7fe50b8b 1441#ifdef HAS_SIGPROCMASK
55534442
LT
1442 /* From sigaction(2) (FreeBSD man page):
1443 * | Signal routines normally execute with the signal that
1444 * | caused their invocation blocked, but other signals may
1445 * | yet occur.
1446 * Emulation of this behavior (from within Perl) is enabled
1447 * using sigprocmask
1448 */
1449 int was_blocked;
1450 sigset_t newset, oldset;
1451
1452 sigemptyset(&newset);
1453 sigaddset(&newset, sig);
1454 sigprocmask(SIG_BLOCK, &newset, &oldset);
1455 was_blocked = sigismember(&oldset, sig);
7fe50b8b
LT
1456 if (!was_blocked) {
1457 SV* save_sv = newSVpvn((char *)(&newset), sizeof(sigset_t));
1458 ENTER;
1459 SAVEFREESV(save_sv);
1460 SAVEDESTRUCTOR_X(unblock_sigmask, SvPV_nolen(save_sv));
1461 }
55534442 1462#endif
25da4428 1463 PL_psig_pend[sig] = 0;
6e324d09 1464#if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
80626cf1 1465 (*PL_sighandlerp)(sig, NULL, NULL);
6e324d09
CB
1466#else
1467 (*PL_sighandlerp)(sig);
92807b6d 1468#endif
7fe50b8b 1469#ifdef HAS_SIGPROCMASK
55534442 1470 if (!was_blocked)
7fe50b8b 1471 LEAVE;
55534442 1472#endif
d0166017 1473 RESTORE_ERRNO;
0a8e0eff
NIS
1474 }
1475 }
1476}
1477
38a124f0 1478/* sv of NULL signifies that we're acting as magic_clearsig. */
85e6fe83 1479int
864dbfa3 1480Perl_magic_setsig(pTHX_ SV *sv, MAGIC *mg)
79072805 1481{
27da23d5 1482 dVAR;
79072805 1483 I32 i;
cbbf8932 1484 SV** svp = NULL;
2d4fcd5e
AJ
1485 /* Need to be careful with SvREFCNT_dec(), because that can have side
1486 * effects (due to closures). We must make sure that the new disposition
1487 * is in place before it is called.
1488 */
cbbf8932 1489 SV* to_dec = NULL;
e72dc28c 1490 STRLEN len;
2d4fcd5e
AJ
1491#ifdef HAS_SIGPROCMASK
1492 sigset_t set, save;
1493 SV* save_sv;
1494#endif
eb578fdb 1495 const char *s = MgPV_const(mg,len);
7918f24d
NC
1496
1497 PERL_ARGS_ASSERT_MAGIC_SETSIG;
1498
748a9306 1499 if (*s == '_') {
84c7b88c 1500 if (memEQs(s, len, "__DIE__"))
3280af22 1501 svp = &PL_diehook;
84c7b88c 1502 else if (memEQs(s, len, "__WARN__")
38a124f0
NC
1503 && (sv ? 1 : PL_warnhook != PERL_WARNHOOK_FATAL)) {
1504 /* Merge the existing behaviours, which are as follows:
1505 magic_setsig, we always set svp to &PL_warnhook
1506 (hence we always change the warnings handler)
1507 For magic_clearsig, we don't change the warnings handler if it's
1508 set to the &PL_warnhook. */
3280af22 1509 svp = &PL_warnhook;
84c7b88c
BF
1510 } else if (sv) {
1511 SV *tmp = sv_newmortal();
1512 Perl_croak(aTHX_ "No such hook: %s",
1513 pv_pretty(tmp, s, len, 0, NULL, NULL, 0));
1514 }
748a9306 1515 i = 0;
38a124f0 1516 if (svp && *svp) {
9289f461
RGS
1517 if (*svp != PERL_WARNHOOK_FATAL)
1518 to_dec = *svp;
cbbf8932 1519 *svp = NULL;
4633a7c4 1520 }
748a9306
LW
1521 }
1522 else {
708854f2
NC
1523 i = (I16)mg->mg_private;
1524 if (!i) {
84c7b88c 1525 i = whichsig_pvn(s, len); /* ...no, a brick */
58a26b12 1526 mg->mg_private = (U16)i;
708854f2 1527 }
86d86cad 1528 if (i <= 0) {
84c7b88c
BF
1529 if (sv) {
1530 SV *tmp = sv_newmortal();
1531 Perl_ck_warner(aTHX_ packWARN(WARN_SIGNAL), "No such signal: SIG%s",
1532 pv_pretty(tmp, s, len, 0, NULL, NULL, 0));
1533 }
748a9306
LW
1534 return 0;
1535 }
2d4fcd5e
AJ
1536#ifdef HAS_SIGPROCMASK
1537 /* Avoid having the signal arrive at a bad time, if possible. */
1538 sigemptyset(&set);
1539 sigaddset(&set,i);
1540 sigprocmask(SIG_BLOCK, &set, &save);
1541 ENTER;
9ff8e806 1542 save_sv = newSVpvn((char *)(&save), sizeof(sigset_t));
2d4fcd5e
AJ
1543 SAVEFREESV(save_sv);
1544 SAVEDESTRUCTOR_X(restore_sigmask, save_sv);
1545#endif
1546 PERL_ASYNC_CHECK();
2e34cc90 1547#if defined(FAKE_PERSISTENT_SIGNAL_HANDLERS) || defined(FAKE_DEFAULT_SIGNAL_HANDLERS)
27da23d5 1548 if (!PL_sig_handlers_initted) Perl_csighandler_init();
2e34cc90 1549#endif
23ada85b 1550#ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
27da23d5 1551 PL_sig_ignoring[i] = 0;
85b332e2 1552#endif
2e34cc90 1553#ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
27da23d5 1554 PL_sig_defaulting[i] = 0;
2e34cc90 1555#endif
2d4fcd5e 1556 to_dec = PL_psig_ptr[i];
38a124f0
NC
1557 if (sv) {
1558 PL_psig_ptr[i] = SvREFCNT_inc_simple_NN(sv);
1559 SvTEMP_off(sv); /* Make sure it doesn't go away on us */
79fd3822
NC
1560
1561 /* Signals don't change name during the program's execution, so once
1562 they're cached in the appropriate slot of PL_psig_name, they can
1563 stay there.
1564
1565 Ideally we'd find some way of making SVs at (C) compile time, or
1566 at least, doing most of the work. */
1567 if (!PL_psig_name[i]) {
1568 PL_psig_name[i] = newSVpvn(s, len);
1569 SvREADONLY_on(PL_psig_name[i]);
1570 }
38a124f0 1571 } else {
79fd3822 1572 SvREFCNT_dec(PL_psig_name[i]);
38a124f0
NC
1573 PL_psig_name[i] = NULL;
1574 PL_psig_ptr[i] = NULL;
1575 }
748a9306 1576 }
38a124f0 1577 if (sv && (isGV_with_GP(sv) || SvROK(sv))) {
2d4fcd5e 1578 if (i) {
5c1546dc 1579 (void)rsignal(i, PL_csighandlerp);
2d4fcd5e 1580 }
748a9306 1581 else
b37c2d43 1582 *svp = SvREFCNT_inc_simple_NN(sv);
38a124f0 1583 } else {
9dfa190b
NC
1584 if (sv && SvOK(sv)) {
1585 s = SvPV_force(sv, len);
1586 } else {
1587 sv = NULL;
1588 }
84c7b88c 1589 if (sv && memEQs(s, len,"IGNORE")) {
9dfa190b 1590 if (i) {
23ada85b 1591#ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
9dfa190b
NC
1592 PL_sig_ignoring[i] = 1;
1593 (void)rsignal(i, PL_csighandlerp);
85b332e2 1594#else
9dfa190b 1595 (void)rsignal(i, (Sighandler_t) SIG_IGN);
85b332e2 1596#endif
9dfa190b 1597 }
2d4fcd5e 1598 }
84c7b88c 1599 else if (!sv || memEQs(s, len,"DEFAULT") || !len) {
9dfa190b 1600 if (i) {
2e34cc90 1601#ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
9dfa190b
NC
1602 PL_sig_defaulting[i] = 1;
1603 (void)rsignal(i, PL_csighandlerp);
2e34cc90 1604#else
9dfa190b 1605 (void)rsignal(i, (Sighandler_t) SIG_DFL);
2e34cc90 1606#endif
9dfa190b
NC
1607 }
1608 }
1609 else {
1610 /*
1611 * We should warn if HINT_STRICT_REFS, but without
1612 * access to a known hint bit in a known OP, we can't
1613 * tell whether HINT_STRICT_REFS is in force or not.
1614 */
1615 if (!strchr(s,':') && !strchr(s,'\''))
1616 Perl_sv_insert_flags(aTHX_ sv, 0, 0, STR_WITH_LEN("main::"),
1617 SV_GMAGIC);
1618 if (i)
1619 (void)rsignal(i, PL_csighandlerp);
1620 else
1621 *svp = SvREFCNT_inc_simple_NN(sv);
136e0459 1622 }
748a9306 1623 }
9dfa190b 1624
2d4fcd5e
AJ
1625#ifdef HAS_SIGPROCMASK
1626 if(i)
1627 LEAVE;
1628#endif
ef8d46e8 1629 SvREFCNT_dec(to_dec);
79072805
LW
1630 return 0;
1631}
64ca3a65 1632#endif /* !PERL_MICRO */
79072805
LW
1633
1634int
864dbfa3 1635Perl_magic_setisa(pTHX_ SV *sv, MAGIC *mg)
79072805 1636{
7918f24d 1637 PERL_ARGS_ASSERT_MAGIC_SETISA;
8772537c 1638 PERL_UNUSED_ARG(sv);
e1a479c5 1639
89c14e2e 1640 /* Skip _isaelem because _isa will handle it shortly */
354b0578 1641 if (PL_delaymagic & DM_ARRAY_ISA && mg->mg_type == PERL_MAGIC_isaelem)
89c14e2e
BB
1642 return 0;
1643
0e446081 1644 return magic_clearisa(NULL, mg);
463ee0b2
LW
1645}
1646
0e446081 1647/* sv of NULL signifies that we're acting as magic_setisa. */
463ee0b2 1648int
52b45067
RD
1649Perl_magic_clearisa(pTHX_ SV *sv, MAGIC *mg)
1650{
52b45067 1651 HV* stash;
7918f24d
NC
1652 PERL_ARGS_ASSERT_MAGIC_CLEARISA;
1653
52b45067 1654 /* Bail out if destruction is going on */
627364f1 1655 if(PL_phase == PERL_PHASE_DESTRUCT) return 0;
52b45067 1656
0e446081
NC
1657 if (sv)
1658 av_clear(MUTABLE_AV(sv));
52b45067 1659
6624142a
FC
1660 if (SvTYPE(mg->mg_obj) != SVt_PVGV && SvSMAGICAL(mg->mg_obj))
1661 /* This occurs with setisa_elem magic, which calls this
1662 same function. */
1663 mg = mg_find(mg->mg_obj, PERL_MAGIC_isa);
1664
316ebaf2 1665 assert(mg);
6624142a
FC
1666 if (SvTYPE(mg->mg_obj) == SVt_PVAV) { /* multiple stashes */
1667 SV **svp = AvARRAY((AV *)mg->mg_obj);
1668 I32 items = AvFILLp((AV *)mg->mg_obj) + 1;
1669 while (items--) {
1670 stash = GvSTASH((GV *)*svp++);
1671 if (stash && HvENAME(stash)) mro_isa_changed_in(stash);
1672 }
1673
1674 return 0;
1675 }
1676
52b45067 1677 stash = GvSTASH(
6624142a 1678 (const GV *)mg->mg_obj
52b45067
RD
1679 );
1680
00169e2c
FC
1681 /* The stash may have been detached from the symbol table, so check its
1682 name before doing anything. */
1683 if (stash && HvENAME_get(stash))
5562fa71 1684 mro_isa_changed_in(stash);
52b45067
RD
1685
1686 return 0;
1687}
1688
1689int
864dbfa3 1690Perl_magic_getnkeys(pTHX_ SV *sv, MAGIC *mg)
6ff81951 1691{
85fbaab2 1692 HV * const hv = MUTABLE_HV(LvTARG(sv));
6ff81951 1693 I32 i = 0;
7918f24d
NC
1694
1695 PERL_ARGS_ASSERT_MAGIC_GETNKEYS;
8772537c 1696 PERL_UNUSED_ARG(mg);
7719e241 1697
6ff81951 1698 if (hv) {
497b47a8 1699 (void) hv_iterinit(hv);
ad64d0ec 1700 if (! SvTIED_mg((const SV *)hv, PERL_MAGIC_tied))
1b95d04f 1701 i = HvUSEDKEYS(hv);
497b47a8
JH
1702 else {
1703 while (hv_iternext(hv))
1704 i++;
1705 }
6ff81951
GS
1706 }
1707
1708 sv_setiv(sv, (IV)i);
1709 return 0;
1710}
1711
1712int
864dbfa3 1713Perl_magic_setnkeys(pTHX_ SV *sv, MAGIC *mg)
946ec16e 1714{
7918f24d 1715 PERL_ARGS_ASSERT_MAGIC_SETNKEYS;
8772537c 1716 PERL_UNUSED_ARG(mg);
946ec16e 1717 if (LvTARG(sv)) {
85fbaab2 1718 hv_ksplit(MUTABLE_HV(LvTARG(sv)), SvIV(sv));
946ec16e
PP
1719 }
1720 return 0;
ac27b0f5 1721}
946ec16e 1722
efaf3674
DM
1723/*
1724=for apidoc magic_methcall
1725
1726Invoke a magic method (like FETCH).
1727
2baee27b
FC
1728C<sv> and C<mg> are the tied thingy and the tie magic.
1729
1730C<meth> is the name of the method to call.
1731
1732C<argc> is the number of args (in addition to $self) to pass to the method.
1733
1734The C<flags> can be:
1735
1736 G_DISCARD invoke method with G_DISCARD flag and don't
1737 return a value
1738 G_UNDEF_FILL fill the stack with argc pointers to
1739 PL_sv_undef
1740
1741The arguments themselves are any values following the C<flags> argument.
efaf3674
DM
1742
1743Returns the SV (if any) returned by the method, or NULL on failure.
1744
1745
1746=cut
1747*/
1748
1749SV*
36925d9e 1750Perl_magic_methcall(pTHX_ SV *sv, const MAGIC *mg, SV *meth, U32 flags,
046b0c7d 1751 U32 argc, ...)
a0d0e21e
LW
1752{
1753 dSP;
efaf3674 1754 SV* ret = NULL;
463ee0b2 1755
7918f24d
NC
1756 PERL_ARGS_ASSERT_MAGIC_METHCALL;
1757
efaf3674 1758 ENTER;
d1d7a15d
NC
1759
1760 if (flags & G_WRITING_TO_STDERR) {
1761 SAVETMPS;
1762
d1d7a15d
NC
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
64ff300b 2240 TAINT_IF((PL_localizing != 1) && (mg->mg_len & 1) && IN_PERL_RUNTIME);
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)) {
07c325bb 3128 const HEK * const hek = gv
1d6bb9ae
FC
3129 ? GvENAME_HEK(gv)
3130 : cv && CvNAMED(cv)
3131 ? CvNAME_HEK(cv)
07c325bb
FC
3132 : cv && CvGV(cv) ? GvENAME_HEK(CvGV(cv)) : NULL;
3133 if (hek)
3134 Perl_ck_warner(aTHX_ packWARN(WARN_SIGNAL),
3135 "SIG%s handler \"%"HEKf"\" not defined.\n",
3136 PL_sig_name[sig], hek);
3137 /* diag_listed_as: SIG%s handler "%s" not defined */
3138 else Perl_ck_warner(aTHX_ packWARN(WARN_SIGNAL),
3139 "SIG%s handler \"__ANON__\" not defined.\n",
3140 PL_sig_name[sig]);
00d579c5 3141 goto cleanup;
79072805
LW
3142 }
3143
0c4d3b5e
DM
3144 sv = PL_psig_name[sig]
3145 ? SvREFCNT_inc_NN(PL_psig_name[sig])
3146 : newSVpv(PL_sig_name[sig],0);
72048cfe 3147 flags |= 8;
0c4d3b5e
DM
3148 SAVEFREESV(sv);
3149
a0d63a7b
DM
3150 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG) {
3151 /* make sure our assumption about the size of the SAVEs are correct:
3152 * 3 for SAVEDESTRUCTOR_X, 2 for SAVEFREESV */
3153 assert(old_ss_ix + 2 + ((flags & 1) ? 3+5 : 0) == PL_savestack_ix);
3154 }
e336de0d 3155
e788e7d3 3156 PUSHSTACKi(PERLSI_SIGNAL);
924508f0 3157 PUSHMARK(SP);
79072805 3158 PUSHs(sv);
8aad04aa
JH
3159#if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
3160 {
3161 struct sigaction oact;
3162
3163 if (sigaction(sig, 0, &oact) == 0 && oact.sa_flags & SA_SIGINFO) {
8aad04aa
JH
3164 if (sip) {
3165 HV *sih = newHV();
ad64d0ec 3166 SV *rv = newRV_noinc(MUTABLE_SV(sih));
8aad04aa
JH
3167 /* The siginfo fields signo, code, errno, pid, uid,
3168 * addr, status, and band are defined by POSIX/SUSv3. */
85771703
NC
3169 (void)hv_stores(sih, "signo", newSViv(sip->si_signo));
3170 (void)hv_stores(sih, "code", newSViv(sip->si_code));
79dec0f4 3171#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
3172 hv_stores(sih, "errno", newSViv(sip->si_errno));
3173 hv_stores(sih, "status", newSViv(sip->si_status));
3174 hv_stores(sih, "uid", newSViv(sip->si_uid));
3175 hv_stores(sih, "pid", newSViv(sip->si_pid));
3176 hv_stores(sih, "addr", newSVuv(PTR2UV(sip->si_addr)));
3177 hv_stores(sih, "band", newSViv(sip->si_band));
79dec0f4 3178#endif
8aad04aa 3179 EXTEND(SP, 2);
ad64d0ec 3180 PUSHs(rv);
22f1178f 3181 mPUSHp((char *)sip, sizeof(*sip));
8aad04aa 3182 }
b4552a27 3183
8aad04aa
JH
3184 }
3185 }
3186#endif
79072805 3187 PUTBACK;
a0d0e21e 3188
100c03aa
JL
3189 errsv_save = newSVsv(ERRSV);
3190
ad64d0ec 3191 call_sv(MUTABLE_SV(cv), G_DISCARD|G_EVAL);
79072805 3192
d3acc0f7 3193 POPSTACK;
eed484f9
DD
3194 {
3195 SV * const errsv = ERRSV;
3196 if (SvTRUE_NN(errsv)) {
3197 SvREFCNT_dec(errsv_save);
c22d665b 3198#ifndef PERL_MICRO
1b266415
NIS
3199 /* Handler "died", for example to get out of a restart-able read().
3200 * Before we re-do that on its behalf re-enable the signal which was
3201 * blocked by the system when we entered.
3202 */
c22d665b 3203#ifdef HAS_SIGPROCMASK
d488af49 3204#if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
eed484f9 3205 if (sip || uap)
c22d665b 3206#endif
eed484f9
DD
3207 {
3208 sigset_t set;
3209 sigemptyset(&set);
3210 sigaddset(&set,sig);
3211 sigprocmask(SIG_UNBLOCK, &set, NULL);
3212 }
c22d665b 3213#else
eed484f9
DD
3214 /* Not clear if this will work */
3215 (void)rsignal(sig, SIG_IGN);
3216 (void)rsignal(sig, PL_csighandlerp);
c22d665b
LT
3217#endif
3218#endif /* !PERL_MICRO */
eed484f9
DD
3219 die_sv(errsv);
3220 }
3221 else {
3222 sv_setsv(errsv, errsv_save);
3223 SvREFCNT_dec(errsv_save);
3224 }
100c03aa
JL
3225 }
3226
00d579c5 3227cleanup:
0c4d3b5e
DM
3228 /* pop any of SAVEFREESV, SAVEDESTRUCTOR_X and "save in progress" */
3229 PL_savestack_ix = old_ss_ix;
72048cfe 3230 if (flags & 8)
2357bae7 3231 SvREFCNT_dec_NN(sv);
533c011a 3232 PL_op = myop; /* Apparently not needed... */
ac27b0f5 3233
3280af22
NIS
3234 PL_Sv = tSv; /* Restore global temporaries. */
3235 PL_Xpv = tXpv;
53bb94e2 3236 return;
79072805 3237}
4e35701f
NIS
3238
3239
51371543 3240static void
8772537c 3241S_restore_magic(pTHX_ const void *p)
51371543 3242{
8772537c
AL
3243 MGS* const mgs = SSPTR(PTR2IV(p), MGS*);
3244 SV* const sv = mgs->mgs_sv;
150b625d 3245 bool bumped;
51371543
GS
3246
3247 if (!sv)
3248 return;
3249
4bac9ae4
CS
3250 if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv)) {
3251 SvTEMP_off(sv); /* if it's still magical, this value isn't temporary */
f8c7b90f 3252#ifdef PERL_OLD_COPY_ON_WRITE
f9701176
NC
3253 /* While magic was saved (and off) sv_setsv may well have seen
3254 this SV as a prime candidate for COW. */
3255 if (SvIsCOW(sv))
e424a81e 3256 sv_force_normal_flags(sv, 0);
f9701176 3257#endif
a623f893
FC
3258 if (mgs->mgs_flags)
3259 SvFLAGS(sv) |= mgs->mgs_flags;
51371543
GS
3260 else
3261 mg_magical(sv);
51371543
GS
3262 }
3263
150b625d 3264 bumped = mgs->mgs_bumped;
51371543
GS
3265 mgs->mgs_sv = NULL; /* mark the MGS structure as restored */
3266
3267 /* If we're still on top of the stack, pop us off. (That condition
3268 * will be satisfied if restore_magic was called explicitly, but *not*
3269 * if it's being called via leave_scope.)
3270 * The reason for doing this is that otherwise, things like sv_2cv()
3271 * may leave alloc gunk on the savestack, and some code
3272 * (e.g. sighandler) doesn't expect that...
3273 */
3274 if (PL_savestack_ix == mgs->mgs_ss_ix)
3275 {
1be36ce0
NC
3276 UV popval = SSPOPUV;
3277 assert(popval == SAVEt_DESTRUCTOR_X);
51371543 3278 PL_savestack_ix -= 2;
1be36ce0
NC
3279 popval = SSPOPUV;
3280 assert((popval & SAVE_MASK) == SAVEt_ALLOC);
3281 PL_savestack_ix -= popval >> SAVE_TIGHT_SHIFT;
51371543 3282 }
150b625d
DM
3283 if (bumped) {
3284 if (SvREFCNT(sv) == 1) {
3285 /* We hold the last reference to this SV, which implies that the
3286 SV was deleted as a side effect of the routines we called.
3287 So artificially keep it alive a bit longer.
3288 We avoid turning on the TEMP flag, which can cause the SV's
3289 buffer to get stolen (and maybe other stuff). */
150b625d 3290 sv_2mortal(sv);
4bac9ae4 3291 SvTEMP_off(sv);
8985fe98 3292 }
150b625d 3293 else
2357bae7 3294 SvREFCNT_dec_NN(sv); /* undo the inc in S_save_magic() */
8985fe98 3295 }
51371543
GS
3296}
3297
0c4d3b5e
DM
3298/* clean up the mess created by Perl_sighandler().
3299 * Note that this is only called during an exit in a signal handler;
3300 * a die is trapped by the call_sv() and the SAVEDESTRUCTOR_X manually
9a7f166c 3301 * skipped over. */
0c4d3b5e 3302
51371543 3303static void
8772537c 3304S_unwind_handler_stack(pTHX_ const void *p)
51371543 3305{
0c4d3b5e 3306 PERL_UNUSED_ARG(p);
7918f24d 3307
0c4d3b5e 3308 PL_savestack_ix -= 5; /* Unprotect save in progress. */
51371543 3309}
1018e26f 3310
66610fdd 3311/*
b3ca2e83
NC
3312=for apidoc magic_sethint
3313
3314Triggered by a store to %^H, records the key/value pair to
c28fe1ec
NC
3315C<PL_compiling.cop_hints_hash>. It is assumed that hints aren't storing
3316anything that would need a deep copy. Maybe we should warn if we find a
3317reference.
b3ca2e83
NC
3318
3319=cut
3320*/
3321int
3322Perl_magic_sethint(pTHX_ SV *sv, MAGIC *mg)
3323{
ad64d0ec 3324 SV *key = (mg->mg_len == HEf_SVKEY) ? MUTABLE_SV(mg->mg_ptr)
59cd0e26 3325 : newSVpvn_flags(mg->mg_ptr, mg->mg_len, SVs_TEMP);
b3ca2e83 3326
7918f24d
NC
3327 PERL_ARGS_ASSERT_MAGIC_SETHINT;
3328
e6e3e454
NC
3329 /* mg->mg_obj isn't being used. If needed, it would be possible to store
3330 an alternative leaf in there, with PL_compiling.cop_hints being used if
3331 it's NULL. If needed for threads, the alternative could lock a mutex,
3332 or take other more complex action. */
3333
5b9c0671
NC
3334 /* Something changed in %^H, so it will need to be restored on scope exit.
3335 Doing this here saves a lot of doing it manually in perl code (and
3336 forgetting to do it, and consequent subtle errors. */
3337 PL_hints |= HINT_LOCALIZE_HH;
20439bc7
Z
3338 CopHINTHASH_set(&PL_compiling,
3339 cophh_store_sv(CopHINTHASH_get(&PL_compiling), key, 0, sv, 0));
b3ca2e83
NC
3340 return 0;
3341}
3342
3343/*
f175cff5 3344=for apidoc magic_clearhint
b3ca2e83 3345
c28fe1ec
NC
3346Triggered by a delete from %^H, records the key to
3347C<PL_compiling.cop_hints_hash>.
b3ca2e83
NC
3348
3349=cut
3350*/
3351int
3352Perl_magic_clearhint(pTHX_ SV *sv, MAGIC *mg)
3353{
7918f24d 3354 PERL_ARGS_ASSERT_MAGIC_CLEARHINT;
f5a63d97
AL
3355 PERL_UNUSED_ARG(sv);
3356
5b9c0671 3357 PL_hints |= HINT_LOCALIZE_HH;
20439bc7 3358 CopHINTHASH_set(&PL_compiling,
e3352591
FC
3359 mg->mg_len == HEf_SVKEY
3360 ? cophh_delete_sv(CopHINTHASH_get(&PL_compiling),
3361 MUTABLE_SV(mg->mg_ptr), 0, 0)
3362 : cophh_delete_pvn(CopHINTHASH_get(&PL_compiling),
3363 mg->mg_ptr, mg->mg_len, 0, 0));
b3ca2e83
NC
3364 return 0;
3365}
3366
3367/*
f747ebd6
Z
3368=for apidoc magic_clearhints
3369
3370Triggered by clearing %^H, resets C<PL_compiling.cop_hints_hash>.
3371
3372=cut
3373*/
3374int
3375Perl_magic_clearhints(pTHX_ SV *sv, MAGIC *mg)
3376{
3377 PERL_ARGS_ASSERT_MAGIC_CLEARHINTS;
3378 PERL_UNUSED_ARG(sv);
3379 PERL_UNUSED_ARG(mg);
20439bc7
Z
3380 cophh_free(CopHINTHASH_get(&PL_compiling));
3381 CopHINTHASH_set(&PL_compiling, cophh_new_empty());
f747ebd6
Z
3382 return 0;
3383}
3384
09fb282d
FC
3385int
3386Perl_magic_copycallchecker(pTHX_ SV *sv, MAGIC *mg, SV *nsv,
3387 const char *name, I32 namlen)
3388{
3389 MAGIC *nmg;
3390
3391 PERL_ARGS_ASSERT_MAGIC_COPYCALLCHECKER;
4f8dbb2d 3392 PERL_UNUSED_ARG(sv);
09fb282d
FC
3393 PERL_UNUSED_ARG(name);
3394 PERL_UNUSED_ARG(namlen);
3395
3396 sv_magic(nsv, &PL_sv_undef, mg->mg_type, NULL, 0);
3397 nmg = mg_find(nsv, mg->mg_type);
316ebaf2 3398 assert(nmg);
09fb282d
FC
3399 if (nmg->mg_flags & MGf_REFCOUNTED) SvREFCNT_dec(nmg->mg_obj);
3400 nmg->mg_ptr = mg->mg_ptr;
3401 nmg->mg_obj = SvREFCNT_inc_simple(mg->mg_obj);
3402 nmg->mg_flags |= MGf_REFCOUNTED;
3403 return 1;
3404}
3405
a6d69523
TC
3406int
3407Perl_magic_setdebugvar(pTHX_ SV *sv, MAGIC *mg) {
3408 PERL_ARGS_ASSERT_MAGIC_SETDEBUGVAR;
3409
3410 assert(mg->mg_private >= DBVARMG_SINGLE && mg->mg_private < DBVARMG_COUNT);
3411
3412 PL_DBcontrol[mg->mg_private] = SvIV_nomg(sv);
3413
3414 return 1;
3415}
3416
3417int
3418Perl_magic_getdebugvar(pTHX_ SV *sv, MAGIC *mg) {
3419 PERL_ARGS_ASSERT_MAGIC_GETDEBUGVAR;
3420
3421 assert(mg->mg_private >= DBVARMG_SINGLE && mg->mg_private < DBVARMG_COUNT);
3422 sv_setiv(sv, PL_DBcontrol[mg->mg_private]);
3423
3424 return 0;
3425}
3426
f747ebd6 3427/*
66610fdd
RGS
3428 * Local variables:
3429 * c-indentation-style: bsd
3430 * c-basic-offset: 4
14d04a33 3431 * indent-tabs-mode: nil
66610fdd
RGS
3432 * End:
3433 *
14d04a33 3434 * ex: set ts=8 sts=4 sw=4 et:
37442d52 3435 */