This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
https://perl5.git.perl.org / perl5.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
perldelta for refaliasing
[perl5.git] / mg.c
CommitLineData
a0d0e21e 1/* mg.c
79072805 2 *
1129b882
NC		 3 * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 * 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others
79072805
LW		 5 *
6 * You may distribute under the terms of either the GNU General Public
7 * License or the Artistic License, as specified in the README file.
8 *
a0d0e21e
LW		 9 */
10
11/*
4ac71550
TC		 12 * Sam sat on the ground and put his head in his hands. 'I wish I had never
13 * come here, and I don't want to see no more magic,' he said, and fell silent.
14 *
15 * [p.363 of _The Lord of the Rings_, II/vii: "The Mirror of Galadriel"]
79072805
LW		 16 */
17
ccfc67b7
JH		 18/*
19=head1 Magical Functions
166f8a29
DM		 20"Magic" is special data attached to SV structures in order to give them
21"magical" properties. When any Perl code tries to read from, or assign to,
22an SV marked as magical, it calls the 'get' or 'set' function associated
154e47c8 23with that SV's magic. A get is called prior to reading an SV, in order to
ddfa107c 24give it a chance to update its internal value (get on $. writes the line
b53c43bf 25number of the last read filehandle into the SV's IV slot), while
166f8a29 26set is called after an SV has been written to, in order to allow it to make
ddfa107c 27use of its changed value (set on $/ copies the SV's new value to the
166f8a29
DM		 28PL_rs global variable).
29
30Magic is implemented as a linked list of MAGIC structures attached to the
154e47c8 31SV. Each MAGIC struct holds the type of the magic, a pointer to an array
166f8a29 32of functions that implement the get(), set(), length() etc functions,
154e47c8 33plus space for some flags and pointers. For example, a tied variable has
166f8a29
DM		 34a MAGIC structure that contains a pointer to the object associated with the
35tie.
36
7fefc6c1
KW		 37=cut
38
ccfc67b7
JH		 39*/
40
79072805 41#include "EXTERN.h"
864dbfa3 42#define PERL_IN_MG_C
79072805
LW		 43#include "perl.h"
44
5cd24f17 45#if defined(HAS_GETGROUPS) || defined(HAS_SETGROUPS)
b7953727
JH		 46# ifdef I_GRP
47# include <grp.h>
48# endif
188ea221
CS		 49#endif
50
757f63d8
SP		 51#if defined(HAS_SETGROUPS)
52# ifndef NGROUPS
53# define NGROUPS 32
54# endif
55#endif
56
17aa7f3d
JH		 57#ifdef __hpux
58# include <sys/pstat.h>
59#endif
60
7636ea95
AB		 61#ifdef HAS_PRCTL_SET_NAME
62# include <sys/prctl.h>
63#endif
64
8aad04aa 65#if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
b6455c53 66Signal_t Perl_csighandler(int sig, siginfo_t *, void *);
8aad04aa 67#else
e69880a5 68Signal_t Perl_csighandler(int sig);
8aad04aa 69#endif
e69880a5 70
9cffb111
OS		 71#ifdef __Lynx__
72/* Missing protos on LynxOS */
73void setruid(uid_t id);
74void seteuid(uid_t id);
75void setrgid(uid_t id);
76void setegid(uid_t id);
77#endif
78
c07a80fd 79/*
4bac9ae4 80 * Pre-magic setup and post-magic takedown.
c07a80fd 81 * Use the "DESTRUCTOR" scope cleanup to reinstate magic.
82 */
83
84struct magic_state {
85 SV* mgs_sv;
455ece5e 86 I32 mgs_ss_ix;
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 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
S		 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 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 1181 int i = 0, j = 0;
1182
6fca0082 1183 my_strlcpy(eltbuf, s, sizeof(eltbuf));
b8ffc8df 1184 elt = eltbuf;
1e422769 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 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 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 1260 I32 keylen;
1261 my_setenv(hv_iterkey(entry, &keylen),
85fbaab2 1262 SvPV_nolen_const(hv_iterval(MUTABLE_HV(sv), entry)));
fb73857a 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 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 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 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 2307 /* somebody else defined it for us */
2308 SvREFCNT_dec(LvTARG(sv));
b37c2d43 2309 LvTARG(sv) = SvREFCNT_inc_simple_NN(targ);
68dc0745 2310 LvTARGLEN(sv) = 0;
2311 SvREFCNT_dec(mg->mg_obj);
a0714e2c 2312 mg->mg_obj = NULL;
68dc0745 2313 mg->mg_flags &= ~MGf_REFCOUNTED;
2314 }
13733cde 2315 return targ;
5f05dabc 2316 }
71be2cbc 2317 else
13733cde
FC		 2318 return LvTARG(sv);
2319}
2320
2321int
2322Perl_magic_getdefelem(pTHX_ SV *sv, MAGIC *mg)
2323{
2324 PERL_ARGS_ASSERT_MAGIC_GETDEFELEM;
2325
2326 sv_setsv(sv, defelem_target(sv, mg));
71be2cbc 2327 return 0;
2328}
2329
2330int
864dbfa3 2331Perl_magic_setdefelem(pTHX_ SV *sv, MAGIC *mg)
71be2cbc 2332{
7918f24d 2333 PERL_ARGS_ASSERT_MAGIC_SETDEFELEM;
8772537c 2334 PERL_UNUSED_ARG(mg);
71be2cbc 2335 if (LvTARGLEN(sv))
68dc0745 2336 vivify_defelem(sv);
2337 if (LvTARG(sv)) {
5f05dabc 2338 sv_setsv(LvTARG(sv), sv);
68dc0745 2339 SvSETMAGIC(LvTARG(sv));
2340 }
5f05dabc 2341 return 0;
2342}
2343
71be2cbc 2344void
864dbfa3 2345Perl_vivify_defelem(pTHX_ SV *sv)
71be2cbc 2346{
74e13ce4 2347 MAGIC *mg;
a0714e2c 2348 SV *value = NULL;
71be2cbc 2349
7918f24d
NC		 2350 PERL_ARGS_ASSERT_VIVIFY_DEFELEM;
2351
14befaf4 2352 if (!LvTARGLEN(sv) || !(mg = mg_find(sv, PERL_MAGIC_defelem)))
71be2cbc 2353 return;
68dc0745 2354 if (mg->mg_obj) {
8772537c 2355 SV * const ahv = LvTARG(sv);
85fbaab2 2356 HE * const he = hv_fetch_ent(MUTABLE_HV(ahv), mg->mg_obj, TRUE, 0);
6d822dc4
MS		 2357 if (he)
2358 value = HeVAL(he);
3280af22 2359 if (!value || value == &PL_sv_undef)
be2597df 2360 Perl_croak(aTHX_ PL_no_helem_sv, SVfARG(mg->mg_obj));
71be2cbc 2361 }
bbfdc870
FC		 2362 else if (LvSTARGOFF(sv) < 0)
2363 Perl_croak(aTHX_ PL_no_aelem, LvSTARGOFF(sv));
68dc0745 2364 else {
502c6561 2365 AV *const av = MUTABLE_AV(LvTARG(sv));
bbfdc870 2366 if ((I32)LvTARGLEN(sv) < 0 && LvSTARGOFF(sv) > AvFILL(av))
a0714e2c 2367 LvTARG(sv) = NULL; /* array can't be extended */
68dc0745 2368 else {
bbfdc870 2369 SV* const * const svp = av_fetch(av, LvSTARGOFF(sv), TRUE);
031c6d82 2370 if (!svp || !(value = *svp))
bbfdc870 2371 Perl_croak(aTHX_ PL_no_aelem, LvSTARGOFF(sv));
68dc0745 2372 }
2373 }
b37c2d43 2374 SvREFCNT_inc_simple_void(value);
68dc0745 2375 SvREFCNT_dec(LvTARG(sv));
2376 LvTARG(sv) = value;
71be2cbc 2377 LvTARGLEN(sv) = 0;
68dc0745 2378 SvREFCNT_dec(mg->mg_obj);
a0714e2c 2379 mg->mg_obj = NULL;
68dc0745 2380 mg->mg_flags &= ~MGf_REFCOUNTED;
5f05dabc 2381}
2382
2383int
864dbfa3 2384Perl_magic_killbackrefs(pTHX_ SV *sv, MAGIC *mg)
810b8aa5 2385{
7918f24d 2386 PERL_ARGS_ASSERT_MAGIC_KILLBACKREFS;
5648c0ae
DM		 2387 Perl_sv_kill_backrefs(aTHX_ sv, MUTABLE_AV(mg->mg_obj));
2388 return 0;
810b8aa5
GS		 2389}
2390
2391int
864dbfa3 2392Perl_magic_setmglob(pTHX_ SV *sv, MAGIC *mg)
93a17b20 2393{
7918f24d 2394 PERL_ARGS_ASSERT_MAGIC_SETMGLOB;
96a5add6 2395 PERL_UNUSED_CONTEXT;
0177730e 2396 PERL_UNUSED_ARG(sv);
565764a8 2397 mg->mg_len = -1;
93a17b20
LW		 2398 return 0;
2399}
2400
2401int
864dbfa3 2402Perl_magic_setuvar(pTHX_ SV *sv, MAGIC *mg)
79072805 2403{
35a4481c 2404 const struct ufuncs * const uf = (struct ufuncs *)mg->mg_ptr;
79072805 2405
7918f24d
NC		 2406 PERL_ARGS_ASSERT_MAGIC_SETUVAR;
2407
79072805 2408 if (uf && uf->uf_set)
24f81a43 2409 (*uf->uf_set)(aTHX_ uf->uf_index, sv);
79072805
LW		 2410 return 0;
2411}
2412
c277df42 2413int
faf82a0b
AE		 2414Perl_magic_setregexp(pTHX_ SV *sv, MAGIC *mg)
2415{
488344d2 2416 const char type = mg->mg_type;
7918f24d
NC		 2417
2418 PERL_ARGS_ASSERT_MAGIC_SETREGEXP;
2419
488344d2
NC		 2420 if (type == PERL_MAGIC_qr) {
2421 } else if (type == PERL_MAGIC_bm) {
2422 SvTAIL_off(sv);
2423 SvVALID_off(sv);
2424 } else {
2425 assert(type == PERL_MAGIC_fm);
488344d2
NC		 2426 }
2427 return sv_unmagic(sv, type);
faf82a0b
AE		 2428}
2429
7a4c00b4 2430#ifdef USE_LOCALE_COLLATE
79072805 2431int
864dbfa3 2432Perl_magic_setcollxfrm(pTHX_ SV *sv, MAGIC *mg)
bbce6d69 2433{
7918f24d
NC		 2434 PERL_ARGS_ASSERT_MAGIC_SETCOLLXFRM;
2435
bbce6d69 2436 /*
838b5b74 2437 * RenE<eacute> Descartes said "I think not."
bbce6d69 2438 * and vanished with a faint plop.
2439 */
96a5add6 2440 PERL_UNUSED_CONTEXT;
8772537c 2441 PERL_UNUSED_ARG(sv);
7a4c00b4 2442 if (mg->mg_ptr) {
2443 Safefree(mg->mg_ptr);
2444 mg->mg_ptr = NULL;
565764a8 2445 mg->mg_len = -1;
7a4c00b4 2446 }
bbce6d69 2447 return 0;
2448}
7a4c00b4 2449#endif /* USE_LOCALE_COLLATE */
bbce6d69 2450
7e8c5dac
HS		 2451/* Just clear the UTF-8 cache data. */
2452int
2453Perl_magic_setutf8(pTHX_ SV *sv, MAGIC *mg)
2454{
7918f24d 2455 PERL_ARGS_ASSERT_MAGIC_SETUTF8;
96a5add6 2456 PERL_UNUSED_CONTEXT;
8772537c 2457 PERL_UNUSED_ARG(sv);
7e8c5dac 2458 Safefree(mg->mg_ptr); /* The mg_ptr holds the pos cache. */
3881461a 2459 mg->mg_ptr = NULL;
7e8c5dac
HS		 2460 mg->mg_len = -1; /* The mg_len holds the len cache. */
2461 return 0;
2462}
2463
bbce6d69 2464int
9cce4f9a
FC		 2465Perl_magic_setlvref(pTHX_ SV *sv, MAGIC *mg)
2466{
9782ce69 2467 const char *bad = NULL;
9cce4f9a 2468 PERL_ARGS_ASSERT_MAGIC_SETLVREF;
26a50d99 2469 if (!SvROK(sv)) Perl_croak(aTHX_ "Assigned value is not a reference");
9782ce69
FC		 2470 switch (mg->mg_private & OPpLVREF_TYPE) {
2471 case OPpLVREF_SV:
2472 if (SvTYPE(SvRV(sv)) > SVt_PVLV)
2473 bad = " SCALAR";
2474 break;
2475 case OPpLVREF_AV:
2476 if (SvTYPE(SvRV(sv)) != SVt_PVAV)
2477 bad = "n ARRAY";
2478 break;
2479 case OPpLVREF_HV:
2480 if (SvTYPE(SvRV(sv)) != SVt_PVHV)
2481 bad = " HASH";
2482 break;
2483 case OPpLVREF_CV:
2484 if (SvTYPE(SvRV(sv)) != SVt_PVCV)
2485 bad = " CODE";
2486 }
2487 if (bad)
26a50d99 2488 /* diag_listed_as: Assigned value is not %s reference */
9782ce69 2489 Perl_croak(aTHX_ "Assigned value is not a%s reference", bad);
c146a62a
FC		 2490 switch (mg->mg_obj ? SvTYPE(mg->mg_obj) : 0) {
2491 case 0:
2492 {
2493 SV * const old = PAD_SV(mg->mg_len);
2494 PAD_SETSV(mg->mg_len, SvREFCNT_inc_NN(SvRV(sv)));
2495 SvREFCNT_dec(old);
2496 break;
2497 }
2498 case SVt_PVGV:
2499 gv_setref(mg->mg_obj, sv);
2500 SvSETMAGIC(mg->mg_obj);
6102323a
FC		 2501 break;
2502 case SVt_PVAV:
2503 av_store((AV *)mg->mg_obj, SvIV((SV *)mg->mg_ptr),
2504 SvREFCNT_inc_simple_NN(SvRV(sv)));
5f94141d
FC		 2505 break;
2506 case SVt_PVHV:
2507 hv_store_ent((HV *)mg->mg_obj, (SV *)mg->mg_ptr,
2508 SvREFCNT_inc_simple_NN(SvRV(sv)), 0);
c146a62a 2509 }
d39c26a6
FC		 2510 if (mg->mg_flags & MGf_PERSIST)
2511 NOOP; /* This sv is in use as an iterator var and will be reused,
2512 so we must leave the magic. */
2513 else
2514 /* This sv could be returned by the assignment op, so clear the
2515 magic, as lvrefs are an implementation detail that must not be
2516 leaked to the user. */
2517 sv_unmagic(sv, PERL_MAGIC_lvref);
9cce4f9a
FC		 2518 return 0;
2519}
2520
2521int
864dbfa3 2522Perl_magic_set(pTHX_ SV *sv, MAGIC *mg)
79072805 2523{
20b7effb 2524#ifdef USE_ITHREADS
97aff369 2525 dVAR;
20b7effb 2526#endif
eb578fdb
KW		 2527 const char *s;
2528 I32 paren;
2529 const REGEXP * rx;
79072805 2530 I32 i;
8990e307 2531 STRLEN len;
125b9982 2532 MAGIC *tmg;
2fdbfb4d 2533
7918f24d
NC		 2534 PERL_ARGS_ASSERT_MAGIC_SET;
2535
e91d8259 2536 if (!mg->mg_ptr) {
960b831f 2537 paren = mg->mg_len;
1e05feb3 2538 if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
e91d8259 2539 setparen_got_rx:
2fdbfb4d 2540 CALLREG_NUMBUF_STORE((REGEXP * const)rx,paren,sv);
1e05feb3 2541 } else {
2fdbfb4d
AB		 2542 /* Croak with a READONLY error when a numbered match var is
2543 * set without a previous pattern match. Unless it's C<local $1>
2544 */
e91d8259 2545 croakparen:
2fdbfb4d 2546 if (!PL_localizing) {
cb077ed2 2547 Perl_croak_no_modify();
2fdbfb4d
AB		 2548 }
2549 }
e91d8259
NC		 2550 return 0;
2551 }
2552
2553 switch (*mg->mg_ptr) {
748a9306 2554 case '\001': /* ^A */
f2da823f
FC		 2555 if (SvOK(sv)) sv_copypv(PL_bodytarget, sv);
2556 else SvOK_off(PL_bodytarget);
64eff8b7
DM		 2557 FmLINES(PL_bodytarget) = 0;
2558 if (SvPOK(PL_bodytarget)) {
2559 char *s = SvPVX(PL_bodytarget);
2560 while ( ((s = strchr(s, '\n'))) ) {
2561 FmLINES(PL_bodytarget)++;
2562 s++;
2563 }
2564 }
125b9982 2565 /* mg_set() has temporarily made sv non-magical */
284167a5 2566 if (TAINTING_get) {
125b9982
NT		 2567 if ((tmg = mg_find(sv,PERL_MAGIC_taint)) && tmg->mg_len & 1)
2568 SvTAINTED_on(PL_bodytarget);
2569 else
2570 SvTAINTED_off(PL_bodytarget);
2571 }
748a9306 2572 break;
49460fe6 2573 case '\003': /* ^C */
f2338a2e 2574 PL_minus_c = cBOOL(SvIV(sv));
49460fe6
NIS		 2575 break;
2576
79072805 2577 case '\004': /* ^D */
b4ab917c 2578#ifdef DEBUGGING
b83604b4 2579 s = SvPV_nolen_const(sv);
ddcf8bc1 2580 PL_debug = get_debug_opts(&s, 0) | DEBUG_TOP_FLAG;
a58fb6f9
CS		 2581 if (DEBUG_x_TEST || DEBUG_B_TEST)
2582 dump_all_perl(!DEBUG_B_TEST);
b4ab917c 2583#else
38ab35f8 2584 PL_debug = (SvIV(sv)) | DEBUG_TOP_FLAG;
b4ab917c 2585#endif
79072805 2586 break;
28f23441 2587 case '\005': /* ^E */
d0063567 2588 if (*(mg->mg_ptr+1) == '\0') {
e37778c2 2589#ifdef VMS
38ab35f8 2590 set_vaxc_errno(SvIV(sv));
e37778c2
NC		 2591#else
2592# ifdef WIN32
d0063567 2593 SetLastError( SvIV(sv) );
e37778c2
NC		 2594# else
2595# ifdef OS2
38ab35f8 2596 os2_setsyserrno(SvIV(sv));
e37778c2 2597# else
d0063567 2598 /* will anyone ever use this? */
38ab35f8 2599 SETERRNO(SvIV(sv), 4);
048c1ddf
IZ		 2600# endif
2601# endif
22fae026 2602#endif
d0063567
DK		 2603 }
2604 else if (strEQ(mg->mg_ptr+1, "NCODING")) {
ef8d46e8 2605 SvREFCNT_dec(PL_encoding);
d0063567
DK		 2606 if (SvOK(sv) || SvGMAGICAL(sv)) {
2607 PL_encoding = newSVsv(sv);
2608 }
2609 else {
a0714e2c 2610 PL_encoding = NULL;
d0063567
DK		 2611 }
2612 }
2613 break;
79072805 2614 case '\006': /* ^F */
38ab35f8 2615 PL_maxsysfd = SvIV(sv);
79072805 2616 break;
a0d0e21e 2617 case '\010': /* ^H */
38ab35f8 2618 PL_hints = SvIV(sv);
a0d0e21e 2619 break;
9d116dd7 2620 case '\011': /* ^I */ /* NOT \t in EBCDIC */
43c5f42d 2621 Safefree(PL_inplace);
bd61b366 2622 PL_inplace = SvOK(sv) ? savesvpv(sv) : NULL;
da78da6e 2623 break;
d9bad346
FC		 2624 case '\016': /* ^N */
2625 if (PL_curpm && (rx = PM_GETRE(PL_curpm))
2626 && (paren = RX_LASTCLOSEPAREN(rx))) goto setparen_got_rx;
2627 goto croakparen;
28f23441 2628 case '\017': /* ^O */
ac27b0f5 2629 if (*(mg->mg_ptr+1) == '\0') {
43c5f42d 2630 Safefree(PL_osname);
bd61b366 2631 PL_osname = NULL;
3511154c
DM		 2632 if (SvOK(sv)) {
2633 TAINT_PROPER("assigning to $^O");
2e0de35c 2634 PL_osname = savesvpv(sv);
3511154c 2635 }
ac27b0f5
NIS		 2636 }
2637 else if (strEQ(mg->mg_ptr, "\017PEN")) {
8b850bd5
NC		 2638 STRLEN len;
2639 const char *const start = SvPV(sv, len);
b54fc2b6 2640 const char *out = (const char*)memchr(start, '\0', len);
8b850bd5 2641 SV *tmp;
8b850bd5
NC		 2642
2643
2644 PL_compiling.cop_hints |= HINT_LEXICAL_IO_IN | HINT_LEXICAL_IO_OUT;
f747ebd6 2645 PL_hints |= HINT_LEXICAL_IO_IN | HINT_LEXICAL_IO_OUT;
8b850bd5
NC		 2646
2647 /* Opening for input is more common than opening for output, so
2648 ensure that hints for input are sooner on linked list. */
59cd0e26 2649 tmp = out ? newSVpvn_flags(out + 1, start + len - out - 1,
f747ebd6
Z		 2650 SvUTF8(sv))
2651 : newSVpvs_flags("", SvUTF8(sv));
2652 (void)hv_stores(GvHV(PL_hintgv), "open>", tmp);
2653 mg_set(tmp);
8b850bd5 2654
f747ebd6
Z		 2655 tmp = newSVpvn_flags(start, out ? (STRLEN)(out - start) : len,
2656 SvUTF8(sv));
2657 (void)hv_stores(GvHV(PL_hintgv), "open<", tmp);
2658 mg_set(tmp);
ac27b0f5 2659 }
28f23441 2660 break;
79072805 2661 case '\020': /* ^P */
2fdbfb4d
AB		 2662 PL_perldb = SvIV(sv);
2663 if (PL_perldb && !PL_DBsingle)
2664 init_debugger();
9b9e0be4 2665 break;
79072805 2666 case '\024': /* ^T */
88e89b8a 2667#ifdef BIG_TIME
6b88bc9c 2668 PL_basetime = (Time_t)(SvNOK(sv) ? SvNVX(sv) : sv_2nv(sv));
88e89b8a 2669#else
38ab35f8 2670 PL_basetime = (Time_t)SvIV(sv);
88e89b8a 2671#endif
79072805 2672 break;
e07ea26a
NC		 2673 case '\025': /* ^UTF8CACHE */
2674 if (strEQ(mg->mg_ptr+1, "TF8CACHE")) {
2675 PL_utf8cache = (signed char) sv_2iv(sv);
2676 }
2677 break;
fde18df1 2678 case '\027': /* ^W & $^WARNING_BITS */
4438c4b7
JH		 2679 if (*(mg->mg_ptr+1) == '\0') {
2680 if ( ! (PL_dowarn & G_WARN_ALL_MASK)) {
38ab35f8 2681 i = SvIV(sv);
ac27b0f5 2682 PL_dowarn = (PL_dowarn & ~G_WARN_ON)
0453d815 2683 | (i ? G_WARN_ON : G_WARN_OFF) ;
4438c4b7 2684 }
599cee73 2685 }
0a378802 2686 else if (strEQ(mg->mg_ptr+1, "ARNING_BITS")) {
4438c4b7 2687 if ( ! (PL_dowarn & G_WARN_ALL_MASK)) {
7e4f0450
FC		 2688 if (!SvPOK(sv)) {
2689 PL_compiling.cop_warnings = pWARN_STD;
d775746e
GS		 2690 break;
2691 }
f4fc7782 2692 {
b5477537 2693 STRLEN len, i;
d3a7d8c7 2694 int accumulate = 0 ;
f4fc7782 2695 int any_fatals = 0 ;
b83604b4 2696 const char * const ptr = SvPV_const(sv, len) ;
f4fc7782
JH		 2697 for (i = 0 ; i < len ; ++i) {
2698 accumulate |= ptr[i] ;
2699 any_fatals |= (ptr[i] & 0xAA) ;
2700 }
4243c432
NC		 2701 if (!accumulate) {
2702 if (!specialWARN(PL_compiling.cop_warnings))
2703 PerlMemShared_free(PL_compiling.cop_warnings);
2704 PL_compiling.cop_warnings = pWARN_NONE;
2705 }
72dc9ed5 2706 /* Yuck. I can't see how to abstract this: */
2f3f0b56
KW		 2707 else if (isWARN_on(
2708 ((STRLEN *)SvPV_nolen_const(sv)) - 1,
2709 WARN_ALL)
2710 && !any_fatals)
2711 {
4243c432
NC		 2712 if (!specialWARN(PL_compiling.cop_warnings))
2713 PerlMemShared_free(PL_compiling.cop_warnings);
f4fc7782
JH		 2714 PL_compiling.cop_warnings = pWARN_ALL;
2715 PL_dowarn |= G_WARN_ONCE ;
727405f8 2716 }
d3a7d8c7 2717 else {
72dc9ed5
NC		 2718 STRLEN len;
2719 const char *const p = SvPV_const(sv, len);
2720
2721 PL_compiling.cop_warnings
8ee4cf24 2722 = Perl_new_warnings_bitfield(aTHX_ PL_compiling.cop_warnings,
72dc9ed5
NC		 2723 p, len);
2724
d3a7d8c7
GS		 2725 if (isWARN_on(PL_compiling.cop_warnings, WARN_ONCE))
2726 PL_dowarn |= G_WARN_ONCE ;
2727 }
f4fc7782 2728
d3a7d8c7 2729 }
4438c4b7 2730 }
971a9dd3 2731 }
79072805
LW		 2732 break;
2733 case '.':
3280af22
NIS		 2734 if (PL_localizing) {
2735 if (PL_localizing == 1)
7766f137 2736 SAVESPTR(PL_last_in_gv);
748a9306 2737 }
3280af22 2738 else if (SvOK(sv) && GvIO(PL_last_in_gv))
632db599 2739 IoLINES(GvIOp(PL_last_in_gv)) = SvIV(sv);
79072805
LW		 2740 break;
2741 case '^':
acbe1b9d
FC		 2742 Safefree(IoTOP_NAME(GvIOp(PL_defoutgv)));
2743 s = IoTOP_NAME(GvIOp(PL_defoutgv)) = savesvpv(sv);
2744 IoTOP_GV(GvIOp(PL_defoutgv)) = gv_fetchsv(sv, GV_ADD, SVt_PVIO);
79072805
LW		 2745 break;
2746 case '~':
acbe1b9d
FC		 2747 Safefree(IoFMT_NAME(GvIOp(PL_defoutgv)));
2748 s = IoFMT_NAME(GvIOp(PL_defoutgv)) = savesvpv(sv);
2749 IoFMT_GV(GvIOp(PL_defoutgv)) = gv_fetchsv(sv, GV_ADD, SVt_PVIO);
79072805
LW		 2750 break;
2751 case '=':
acbe1b9d 2752 IoPAGE_LEN(GvIOp(PL_defoutgv)) = (SvIV(sv));
79072805
LW		 2753 break;
2754 case '-':
acbe1b9d
FC		 2755 IoLINES_LEFT(GvIOp(PL_defoutgv)) = (SvIV(sv));
2756 if (IoLINES_LEFT(GvIOp(PL_defoutgv)) < 0L)
099be4f1 2757 IoLINES_LEFT(GvIOp(PL_defoutgv)) = 0L;
79072805
LW		 2758 break;
2759 case '%':
acbe1b9d 2760 IoPAGE(GvIOp(PL_defoutgv)) = (SvIV(sv));
79072805
LW		 2761 break;
2762 case '|':
4b65379b 2763 {
099be4f1 2764 IO * const io = GvIO(PL_defoutgv);
720f287d
AB		 2765 if(!io)
2766 break;
38ab35f8 2767 if ((SvIV(sv)) == 0)
4b65379b
CS		 2768 IoFLAGS(io) &= ~IOf_FLUSH;
2769 else {
2770 if (!(IoFLAGS(io) & IOf_FLUSH)) {
2771 PerlIO *ofp = IoOFP(io);
2772 if (ofp)
2773 (void)PerlIO_flush(ofp);
2774 IoFLAGS(io) |= IOf_FLUSH;
2775 }
2776 }
79072805
LW		 2777 }
2778 break;
79072805 2779 case '/':
1ab48e3a
YO		 2780 {
2781 SV *tmpsv= sv;
2782 if (SvROK(sv)) {
2783 SV *referent= SvRV(sv);
2784 const char *reftype= sv_reftype(referent, 0);
2785 /* XXX: dodgy type check: This leaves me feeling dirty, but the alternative
2786 * is to copy pretty much the entire sv_reftype() into this routine, or to do
2787 * a full string comparison on the return of sv_reftype() both of which
2788 * make me feel worse! NOTE, do not modify this comment without reviewing the
2789 * corresponding comment in sv_reftype(). - Yves */
2790 if (reftype[0] == 'S' || reftype[0] == 'L') {
2791 IV val= SvIV(referent);
2792 if (val <= 0) {
2793 tmpsv= &PL_sv_undef;
2794 Perl_ck_warner(aTHX_ packWARN(WARN_DEPRECATED),
2795 "Setting $/ to a reference to %s as a form of slurp is deprecated, treating as undef",
2796 SvIV(SvRV(sv)) < 0 ? "a negative integer" : "zero"
2797 );
2798 }
2799 } else {
ee0ba734 2800 /* diag_listed_as: Setting $/ to %s reference is forbidden */
a48e4205
FC		 2801 Perl_croak(aTHX_ "Setting $/ to a%s %s reference is forbidden",
2802 *reftype == 'A' ? "n" : "", reftype);
1ab48e3a
YO		 2803 }
2804 }
b3a2acfa 2805 SvREFCNT_dec(PL_rs);
1ab48e3a 2806 PL_rs = newSVsv(tmpsv);
b3a2acfa 2807 }
79072805
LW		 2808 break;
2809 case '\\':
ef8d46e8 2810 SvREFCNT_dec(PL_ors_sv);
6bc2995b 2811 if (SvOK(sv)) {
7889fe52 2812 PL_ors_sv = newSVsv(sv);
009c130f 2813 }
e3c19b7b 2814 else {
a0714e2c 2815 PL_ors_sv = NULL;
e3c19b7b 2816 }
79072805 2817 break;
7d69d4a6
FC		 2818 case '[':
2819 if (SvIV(sv) != 0)
2820 Perl_croak(aTHX_ "Assigning non-zero to $[ is no longer possible");
2821 break;
79072805 2822 case '?':
ff0cee69 2823#ifdef COMPLEX_STATUS
6b88bc9c 2824 if (PL_localizing == 2) {
41cb7b2b 2825 SvUPGRADE(sv, SVt_PVLV);
6b88bc9c
GS		 2826 PL_statusvalue = LvTARGOFF(sv);
2827 PL_statusvalue_vms = LvTARGLEN(sv);
ff0cee69 2828 }
2829 else
2830#endif
2831#ifdef VMSISH_STATUS
2832 if (VMSISH_STATUS)
fb38d079 2833 STATUS_NATIVE_CHILD_SET((U32)SvIV(sv));
ff0cee69 2834 else
2835#endif
38ab35f8 2836 STATUS_UNIX_EXIT_SET(SvIV(sv));
79072805
LW		 2837 break;
2838 case '!':
93189314
JH		 2839 {
2840#ifdef VMS
2841# define PERL_VMS_BANG vaxc$errno
2842#else
2843# define PERL_VMS_BANG 0
2844#endif
27329181 2845#if defined(WIN32) && ! defined(UNDER_CE)
c9beaf97
SH		 2846 SETERRNO(win32_get_errno(SvIOK(sv) ? SvIVX(sv) : SvOK(sv) ? sv_2iv(sv) : 0),
2847 (SvIV(sv) == EVMSERR) ? 4 : PERL_VMS_BANG);
2848#else
91487cfc 2849 SETERRNO(SvIOK(sv) ? SvIVX(sv) : SvOK(sv) ? sv_2iv(sv) : 0,
93189314 2850 (SvIV(sv) == EVMSERR) ? 4 : PERL_VMS_BANG);
c9beaf97 2851#endif
93189314 2852 }
79072805
LW		 2853 break;
2854 case '<':
985213f2 2855 {
b469f1e0 2856 /* XXX $< currently silently ignores failures */
dfff4baf 2857 const Uid_t new_uid = SvUID(sv);
985213f2 2858 PL_delaymagic_uid = new_uid;
3280af22
NIS		 2859 if (PL_delaymagic) {
2860 PL_delaymagic |= DM_RUID;
79072805
LW		 2861 break; /* don't do magic till later */
2862 }
2863#ifdef HAS_SETRUID
b469f1e0 2864 PERL_UNUSED_RESULT(setruid(new_uid));
79072805
LW		 2865#else
2866#ifdef HAS_SETREUID
b469f1e0 2867 PERL_UNUSED_RESULT(setreuid(new_uid, (Uid_t)-1));
748a9306 2868#else
85e6fe83 2869#ifdef HAS_SETRESUID
b469f1e0 2870 PERL_UNUSED_RESULT(setresuid(new_uid, (Uid_t)-1, (Uid_t)-1));
79072805 2871#else
985213f2 2872 if (new_uid == PerlProc_geteuid()) { /* special case $< = $> */
75870ed3 2873#ifdef PERL_DARWIN
2874 /* workaround for Darwin's setuid peculiarity, cf [perl #24122] */
985213f2 2875 if (new_uid != 0 && PerlProc_getuid() == 0)
b469f1e0 2876 PERL_UNUSED_RESULT(PerlProc_setuid(0));
75870ed3 2877#endif
b469f1e0 2878 PERL_UNUSED_RESULT(PerlProc_setuid(new_uid));
75870ed3 2879 } else {
cea2e8a9 2880 Perl_croak(aTHX_ "setruid() not implemented");
a0d0e21e 2881 }
79072805
LW		 2882#endif
2883#endif
85e6fe83 2884#endif
79072805 2885 break;
985213f2 2886 }
79072805 2887 case '>':
985213f2 2888 {
b469f1e0 2889 /* XXX $> currently silently ignores failures */
dfff4baf 2890 const Uid_t new_euid = SvUID(sv);
985213f2 2891 PL_delaymagic_euid = new_euid;
3280af22
NIS		 2892 if (PL_delaymagic) {
2893 PL_delaymagic |= DM_EUID;
79072805
LW		 2894 break; /* don't do magic till later */
2895 }
2896#ifdef HAS_SETEUID
b469f1e0 2897 PERL_UNUSED_RESULT(seteuid(new_euid));
79072805
LW		 2898#else
2899#ifdef HAS_SETREUID
b469f1e0 2900 PERL_UNUSED_RESULT(setreuid((Uid_t)-1, new_euid));
85e6fe83
LW		 2901#else
2902#ifdef HAS_SETRESUID
b469f1e0 2903 PERL_UNUSED_RESULT(setresuid((Uid_t)-1, new_euid, (Uid_t)-1));
79072805 2904#else
985213f2 2905 if (new_euid == PerlProc_getuid()) /* special case $> = $< */
b469f1e0 2906 PERL_UNUSED_RESULT(PerlProc_setuid(new_euid));
a0d0e21e 2907 else {
cea2e8a9 2908 Perl_croak(aTHX_ "seteuid() not implemented");
a0d0e21e 2909 }
79072805
LW		 2910#endif
2911#endif
85e6fe83 2912#endif
79072805 2913 break;
985213f2 2914 }
79072805 2915 case '(':
985213f2 2916 {
b469f1e0 2917 /* XXX $( currently silently ignores failures */
dfff4baf 2918 const Gid_t new_gid = SvGID(sv);
985213f2 2919 PL_delaymagic_gid = new_gid;
3280af22
NIS		 2920 if (PL_delaymagic) {
2921 PL_delaymagic |= DM_RGID;
79072805
LW		 2922 break; /* don't do magic till later */
2923 }
2924#ifdef HAS_SETRGID
b469f1e0 2925 PERL_UNUSED_RESULT(setrgid(new_gid));
79072805
LW		 2926#else
2927#ifdef HAS_SETREGID
b469f1e0 2928 PERL_UNUSED_RESULT(setregid(new_gid, (Gid_t)-1));
85e6fe83
LW		 2929#else
2930#ifdef HAS_SETRESGID
b469f1e0 2931 PERL_UNUSED_RESULT(setresgid(new_gid, (Gid_t)-1, (Gid_t) -1));
79072805 2932#else
985213f2 2933 if (new_gid == PerlProc_getegid()) /* special case $( = $) */
b469f1e0 2934 PERL_UNUSED_RESULT(PerlProc_setgid(new_gid));
748a9306 2935 else {
cea2e8a9 2936 Perl_croak(aTHX_ "setrgid() not implemented");
748a9306 2937 }
79072805
LW		 2938#endif
2939#endif
85e6fe83 2940#endif
79072805 2941 break;
985213f2 2942 }
79072805 2943 case ')':
985213f2 2944 {
b469f1e0 2945 /* XXX $) currently silently ignores failures */
dfff4baf 2946 Gid_t new_egid;
5cd24f17 2947#ifdef HAS_SETGROUPS
2948 {
b83604b4 2949 const char *p = SvPV_const(sv, len);
757f63d8 2950 Groups_t *gary = NULL;
fdadaf77 2951 const char* endptr;
fb4089e0 2952#ifdef _SC_NGROUPS_MAX
2953 int maxgrp = sysconf(_SC_NGROUPS_MAX);
2954
2955 if (maxgrp < 0)
2956 maxgrp = NGROUPS;
2957#else
2958 int maxgrp = NGROUPS;
2959#endif
757f63d8
SP		 2960
2961 while (isSPACE(*p))
2962 ++p;
fdadaf77 2963 new_egid = (Gid_t)grok_atou(p, &endptr);
fb4089e0 2964 for (i = 0; i < maxgrp; ++i) {
fdadaf77
JH		 2965 if (endptr == NULL)
2966 break;
2967 p = endptr;
757f63d8
SP		 2968 while (isSPACE(*p))
2969 ++p;
2970 if (!*p)
2971 break;
fdadaf77 2972 if (!gary)
757f63d8
SP		 2973 Newx(gary, i + 1, Groups_t);
2974 else
2975 Renew(gary, i + 1, Groups_t);
fdadaf77 2976 gary[i] = (Groups_t)grok_atou(p, &endptr);
757f63d8
SP		 2977 }
2978 if (i)
b469f1e0 2979 PERL_UNUSED_RESULT(setgroups(i, gary));
f5a63d97 2980 Safefree(gary);
5cd24f17 2981 }
2982#else /* HAS_SETGROUPS */
dfff4baf 2983 new_egid = SvGID(sv);
5cd24f17 2984#endif /* HAS_SETGROUPS */
985213f2 2985 PL_delaymagic_egid = new_egid;
3280af22
NIS		 2986 if (PL_delaymagic) {
2987 PL_delaymagic |= DM_EGID;
79072805
LW		 2988 break; /* don't do magic till later */
2989 }
2990#ifdef HAS_SETEGID
b469f1e0 2991 PERL_UNUSED_RESULT(setegid(new_egid));
79072805
LW		 2992#else
2993#ifdef HAS_SETREGID
b469f1e0 2994 PERL_UNUSED_RESULT(setregid((Gid_t)-1, new_egid));
85e6fe83
LW		 2995#else
2996#ifdef HAS_SETRESGID
b469f1e0 2997 PERL_UNUSED_RESULT(setresgid((Gid_t)-1, new_egid, (Gid_t)-1));
79072805 2998#else
985213f2 2999 if (new_egid == PerlProc_getgid()) /* special case $) = $( */
b469f1e0 3000 PERL_UNUSED_RESULT(PerlProc_setgid(new_egid));
748a9306 3001 else {
cea2e8a9 3002 Perl_croak(aTHX_ "setegid() not implemented");
748a9306 3003 }
79072805
LW		 3004#endif
3005#endif
85e6fe83 3006#endif
79072805 3007 break;
985213f2 3008 }
79072805 3009 case ':':
2d8e6c8d 3010 PL_chopset = SvPV_force(sv,len);
79072805 3011 break;
9cdac2a2
FC		 3012 case '$': /* $$ */
3013 /* Store the pid in mg->mg_obj so we can tell when a fork has
3014 occurred. mg->mg_obj points to *$ by default, so clear it. */
3015 if (isGV(mg->mg_obj)) {
3016 if (mg->mg_flags & MGf_REFCOUNTED) /* probably never true */
3017 SvREFCNT_dec(mg->mg_obj);
3018 mg->mg_flags |= MGf_REFCOUNTED;
3019 mg->mg_obj = newSViv((IV)PerlProc_getpid());
3020 }
3021 else sv_setiv(mg->mg_obj, (IV)PerlProc_getpid());
3022 break;
79072805 3023 case '0':
e2975953 3024 LOCK_DOLLARZERO_MUTEX;
4bc88a62
PS		 3025#ifdef HAS_SETPROCTITLE
3026 /* The BSDs don't show the argv[] in ps(1) output, they
3027 * show a string from the process struct and provide
3028 * the setproctitle() routine to manipulate that. */
a2722ac9 3029 if (PL_origalen != 1) {
b83604b4 3030 s = SvPV_const(sv, len);
98b76f99 3031# if __FreeBSD_version > 410001
9aad2c0e 3032 /* The leading "-" removes the "perl: " prefix,
4bc88a62
PS		 3033 * but not the "(perl) suffix from the ps(1)
3034 * output, because that's what ps(1) shows if the
3035 * argv[] is modified. */
6f2ad931 3036 setproctitle("-%s", s);
9aad2c0e 3037# else /* old FreeBSDs, NetBSD, OpenBSD, anyBSD */
4bc88a62
PS		 3038 /* This doesn't really work if you assume that
3039 * $0 = 'foobar'; will wipe out 'perl' from the $0
3040 * because in ps(1) output the result will be like
3041 * sprintf("perl: %s (perl)", s)
3042 * I guess this is a security feature:
3043 * one (a user process) cannot get rid of the original name.
3044 * --jhi */
3045 setproctitle("%s", s);
3046# endif
3047 }
9d3968b2 3048#elif defined(__hpux) && defined(PSTAT_SETCMD)
a2722ac9 3049 if (PL_origalen != 1) {
17aa7f3d 3050 union pstun un;
b83604b4 3051 s = SvPV_const(sv, len);
6867be6d 3052 un.pst_command = (char *)s;
17aa7f3d
JH		 3053 pstat(PSTAT_SETCMD, un, len, 0, 0);
3054 }
9d3968b2 3055#else
2d2af554
GA		 3056 if (PL_origalen > 1) {
3057 /* PL_origalen is set in perl_parse(). */
3058 s = SvPV_force(sv,len);
3059 if (len >= (STRLEN)PL_origalen-1) {
3060 /* Longer than original, will be truncated. We assume that
3061 * PL_origalen bytes are available. */
3062 Copy(s, PL_origargv[0], PL_origalen-1, char);
3063 }
3064 else {
3065 /* Shorter than original, will be padded. */
235ac35d 3066#ifdef PERL_DARWIN
60777a0d
JH		 3067 /* Special case for Mac OS X: see [perl #38868] */
3068 const int pad = 0;
235ac35d 3069#else
8a89a4f1
MB		 3070 /* Is the space counterintuitive? Yes.
3071 * (You were expecting \0?)
3072 * Does it work? Seems to. (In Linux 2.4.20 at least.)
3073 * --jhi */
60777a0d 3074 const int pad = ' ';
235ac35d 3075#endif
60777a0d
JH		 3076 Copy(s, PL_origargv[0], len, char);
3077 PL_origargv[0][len] = 0;
3078 memset(PL_origargv[0] + len + 1,
3079 pad, PL_origalen - len - 1);
2d2af554
GA		 3080 }
3081 PL_origargv[0][PL_origalen-1] = 0;
3082 for (i = 1; i < PL_origargc; i++)
3083 PL_origargv[i] = 0;
7636ea95
AB		 3084#ifdef HAS_PRCTL_SET_NAME
3085 /* Set the legacy process name in addition to the POSIX name on Linux */
3086 if (prctl(PR_SET_NAME, (unsigned long)s, 0, 0, 0) != 0) {
3087 /* diag_listed_as: SKIPME */
3088 Perl_croak(aTHX_ "Can't set $0 with prctl(): %s", Strerror(errno));
3089 }
3090#endif
79072805 3091 }
9d3968b2 3092#endif
e2975953 3093 UNLOCK_DOLLARZERO_MUTEX;
79072805
LW		 3094 break;
3095 }
3096 return 0;
3097}
3098
3099I32
84c7b88c
BF		 3100Perl_whichsig_sv(pTHX_ SV *sigsv)
3101{
3102 const char *sigpv;
3103 STRLEN siglen;
3104 PERL_ARGS_ASSERT_WHICHSIG_SV;
84c7b88c
BF		 3105 sigpv = SvPV_const(sigsv, siglen);
3106 return whichsig_pvn(sigpv, siglen);
3107}
3108
3109I32
3110Perl_whichsig_pv(pTHX_ const char *sig)
3111{
3112 PERL_ARGS_ASSERT_WHICHSIG_PV;
84c7b88c
BF		 3113 return whichsig_pvn(sig, strlen(sig));
3114}
3115
3116I32
3117Perl_whichsig_pvn(pTHX_ const char *sig, STRLEN len)
79072805 3118{
eb578fdb 3119 char* const* sigv;
7918f24d 3120
84c7b88c 3121 PERL_ARGS_ASSERT_WHICHSIG_PVN;
96a5add6 3122 PERL_UNUSED_CONTEXT;
79072805 3123
aadb217d 3124 for (sigv = (char* const*)PL_sig_name; *sigv; sigv++)
84c7b88c 3125 if (strlen(*sigv) == len && memEQ(sig,*sigv, len))
aadb217d 3126 return PL_sig_num[sigv - (char* const*)PL_sig_name];
79072805 3127#ifdef SIGCLD
84c7b88c 3128 if (memEQs(sig, len, "CHLD"))
79072805
LW		 3129 return SIGCLD;
3130#endif
3131#ifdef SIGCHLD
84c7b88c 3132 if (memEQs(sig, len, "CLD"))
79072805
LW		 3133 return SIGCHLD;
3134#endif
7f1236c0 3135 return -1;
79072805
LW		 3136}
3137
ecfc5424 3138Signal_t
1e82f5a6 3139#if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
b3dbdd48 3140Perl_sighandler(int sig, siginfo_t *sip, void *uap)
1e82f5a6
SH		 3141#else
3142Perl_sighandler(int sig)
3143#endif
79072805 3144{
1018e26f
NIS		 3145#ifdef PERL_GET_SIG_CONTEXT
3146 dTHXa(PERL_GET_SIG_CONTEXT);
71d280e3 3147#else
cea2e8a9 3148 dTHX;
71d280e3 3149#endif
79072805 3150 dSP;
a0714e2c
SS		 3151 GV *gv = NULL;
3152 SV *sv = NULL;
8772537c 3153 SV * const tSv = PL_Sv;
601f1833 3154 CV *cv = NULL;
533c011a 3155 OP *myop = PL_op;
84902520 3156 U32 flags = 0;
8772537c 3157 XPV * const tXpv = PL_Xpv;
0c4d3b5e 3158 I32 old_ss_ix = PL_savestack_ix;
100c03aa 3159 SV *errsv_save = NULL;
71d280e3 3160
84902520 3161
727405f8 3162 if (!PL_psig_ptr[sig]) {
99ef548b 3163 PerlIO_printf(Perl_error_log, "Signal SIG%s received, but no signal handler set.\n",
727405f8
NIS		 3164 PL_sig_name[sig]);
3165 exit(sig);
3166 }
ff0cee69 3167
a0d63a7b
DM		 3168 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG) {
3169 /* Max number of items pushed there is 3*n or 4. We cannot fix
3170 infinity, so we fix 4 (in fact 5): */
3171 if (PL_savestack_ix + 15 <= PL_savestack_max) {
3172 flags |= 1;
3173 PL_savestack_ix += 5; /* Protect save in progress. */
3174 SAVEDESTRUCTOR_X(S_unwind_handler_stack, NULL);
3175 }
84902520 3176 }
84902520 3177 /* sv_2cv is too complicated, try a simpler variant first: */
ea726b52 3178 if (!SvROK(PL_psig_ptr[sig]) || !(cv = MUTABLE_CV(SvRV(PL_psig_ptr[sig])))
8772537c
AL		 3179 || SvTYPE(cv) != SVt_PVCV) {
3180 HV *st;
f2c0649b 3181 cv = sv_2cv(PL_psig_ptr[sig], &st, &gv, GV_ADD);
8772537c 3182 }
84902520 3183
a0d0e21e 3184 if (!cv || !CvROOT(cv)) {
07c325bb 3185 const HEK * const hek = gv
1d6bb9ae
FC		 3186 ? GvENAME_HEK(gv)
3187 : cv && CvNAMED(cv)
3188 ? CvNAME_HEK(cv)
07c325bb
FC		 3189 : cv && CvGV(cv) ? GvENAME_HEK(CvGV(cv)) : NULL;
3190 if (hek)
3191 Perl_ck_warner(aTHX_ packWARN(WARN_SIGNAL),
3192 "SIG%s handler \"%"HEKf"\" not defined.\n",
3193 PL_sig_name[sig], hek);
3194 /* diag_listed_as: SIG%s handler "%s" not defined */
3195 else Perl_ck_warner(aTHX_ packWARN(WARN_SIGNAL),
3196 "SIG%s handler \"__ANON__\" not defined.\n",
3197 PL_sig_name[sig]);
00d579c5 3198 goto cleanup;
79072805
LW		 3199 }
3200
0c4d3b5e
DM		 3201 sv = PL_psig_name[sig]
3202 ? SvREFCNT_inc_NN(PL_psig_name[sig])
3203 : newSVpv(PL_sig_name[sig],0);
72048cfe 3204 flags |= 8;
0c4d3b5e
DM		 3205 SAVEFREESV(sv);
3206
a0d63a7b
DM		 3207 if (PL_signals & PERL_SIGNALS_UNSAFE_FLAG) {
3208 /* make sure our assumption about the size of the SAVEs are correct:
3209 * 3 for SAVEDESTRUCTOR_X, 2 for SAVEFREESV */
3210 assert(old_ss_ix + 2 + ((flags & 1) ? 3+5 : 0) == PL_savestack_ix);
3211 }
e336de0d 3212
e788e7d3 3213 PUSHSTACKi(PERLSI_SIGNAL);
924508f0 3214 PUSHMARK(SP);
79072805 3215 PUSHs(sv);
8aad04aa
JH		 3216#if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
3217 {
3218 struct sigaction oact;
3219
3220 if (sigaction(sig, 0, &oact) == 0 && oact.sa_flags & SA_SIGINFO) {
8aad04aa
JH		 3221 if (sip) {
3222 HV *sih = newHV();
ad64d0ec 3223 SV *rv = newRV_noinc(MUTABLE_SV(sih));
8aad04aa
JH		 3224 /* The siginfo fields signo, code, errno, pid, uid,
3225 * addr, status, and band are defined by POSIX/SUSv3. */
85771703
NC		 3226 (void)hv_stores(sih, "signo", newSViv(sip->si_signo));
3227 (void)hv_stores(sih, "code", newSViv(sip->si_code));
79dec0f4 3228#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		 3229 hv_stores(sih, "errno", newSViv(sip->si_errno));
3230 hv_stores(sih, "status", newSViv(sip->si_status));
3231 hv_stores(sih, "uid", newSViv(sip->si_uid));
3232 hv_stores(sih, "pid", newSViv(sip->si_pid));
3233 hv_stores(sih, "addr", newSVuv(PTR2UV(sip->si_addr)));
3234 hv_stores(sih, "band", newSViv(sip->si_band));
79dec0f4 3235#endif
8aad04aa 3236 EXTEND(SP, 2);
ad64d0ec 3237 PUSHs(rv);
22f1178f 3238 mPUSHp((char *)sip, sizeof(*sip));
8aad04aa 3239 }
b4552a27 3240
8aad04aa
JH		 3241 }
3242 }
3243#endif
79072805 3244 PUTBACK;
a0d0e21e 3245
100c03aa
JL		 3246 errsv_save = newSVsv(ERRSV);
3247
ad64d0ec 3248 call_sv(MUTABLE_SV(cv), G_DISCARD|G_EVAL);
79072805 3249
d3acc0f7 3250 POPSTACK;
eed484f9
DD		 3251 {
3252 SV * const errsv = ERRSV;
3253 if (SvTRUE_NN(errsv)) {
3254 SvREFCNT_dec(errsv_save);
c22d665b 3255#ifndef PERL_MICRO
1b266415
NIS		 3256 /* Handler "died", for example to get out of a restart-able read().
3257 * Before we re-do that on its behalf re-enable the signal which was
3258 * blocked by the system when we entered.
3259 */
c22d665b 3260#ifdef HAS_SIGPROCMASK
d488af49 3261#if defined(HAS_SIGACTION) && defined(SA_SIGINFO)
eed484f9 3262 if (sip || uap)
c22d665b 3263#endif
eed484f9
DD		 3264 {
3265 sigset_t set;
3266 sigemptyset(&set);
3267 sigaddset(&set,sig);
3268 sigprocmask(SIG_UNBLOCK, &set, NULL);
3269 }
c22d665b 3270#else
eed484f9
DD		 3271 /* Not clear if this will work */
3272 (void)rsignal(sig, SIG_IGN);
3273 (void)rsignal(sig, PL_csighandlerp);
c22d665b
LT		 3274#endif
3275#endif /* !PERL_MICRO */
eed484f9
DD		 3276 die_sv(errsv);
3277 }
3278 else {
3279 sv_setsv(errsv, errsv_save);
3280 SvREFCNT_dec(errsv_save);
3281 }
100c03aa
JL		 3282 }
3283
00d579c5 3284cleanup:
0c4d3b5e
DM		 3285 /* pop any of SAVEFREESV, SAVEDESTRUCTOR_X and "save in progress" */
3286 PL_savestack_ix = old_ss_ix;
72048cfe 3287 if (flags & 8)
2357bae7 3288 SvREFCNT_dec_NN(sv);
533c011a 3289 PL_op = myop; /* Apparently not needed... */
ac27b0f5 3290
3280af22
NIS		 3291 PL_Sv = tSv; /* Restore global temporaries. */
3292 PL_Xpv = tXpv;
53bb94e2 3293 return;
79072805 3294}
4e35701f
NIS		 3295
3296
51371543 3297static void
8772537c 3298S_restore_magic(pTHX_ const void *p)
51371543 3299{
8772537c
AL		 3300 MGS* const mgs = SSPTR(PTR2IV(p), MGS*);
3301 SV* const sv = mgs->mgs_sv;
150b625d 3302 bool bumped;
51371543
GS		 3303
3304 if (!sv)
3305 return;
3306
4bac9ae4
CS		 3307 if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv)) {
3308 SvTEMP_off(sv); /* if it's still magical, this value isn't temporary */
f8c7b90f 3309#ifdef PERL_OLD_COPY_ON_WRITE
f9701176
NC		 3310 /* While magic was saved (and off) sv_setsv may well have seen
3311 this SV as a prime candidate for COW. */
3312 if (SvIsCOW(sv))
e424a81e 3313 sv_force_normal_flags(sv, 0);
f9701176 3314#endif
a623f893
FC		 3315 if (mgs->mgs_flags)
3316 SvFLAGS(sv) |= mgs->mgs_flags;
51371543
GS		 3317 else
3318 mg_magical(sv);
51371543
GS		 3319 }
3320
150b625d 3321 bumped = mgs->mgs_bumped;
51371543
GS		 3322 mgs->mgs_sv = NULL; /* mark the MGS structure as restored */
3323
3324 /* If we're still on top of the stack, pop us off. (That condition
3325 * will be satisfied if restore_magic was called explicitly, but *not*
3326 * if it's being called via leave_scope.)
3327 * The reason for doing this is that otherwise, things like sv_2cv()
3328 * may leave alloc gunk on the savestack, and some code
3329 * (e.g. sighandler) doesn't expect that...
3330 */
3331 if (PL_savestack_ix == mgs->mgs_ss_ix)
3332 {
1be36ce0
NC		 3333 UV popval = SSPOPUV;
3334 assert(popval == SAVEt_DESTRUCTOR_X);
51371543 3335 PL_savestack_ix -= 2;
1be36ce0
NC		 3336 popval = SSPOPUV;
3337 assert((popval & SAVE_MASK) == SAVEt_ALLOC);
3338 PL_savestack_ix -= popval >> SAVE_TIGHT_SHIFT;
51371543 3339 }
150b625d
DM		 3340 if (bumped) {
3341 if (SvREFCNT(sv) == 1) {
3342 /* We hold the last reference to this SV, which implies that the
3343 SV was deleted as a side effect of the routines we called.
3344 So artificially keep it alive a bit longer.
3345 We avoid turning on the TEMP flag, which can cause the SV's
3346 buffer to get stolen (and maybe other stuff). */
150b625d 3347 sv_2mortal(sv);
4bac9ae4 3348 SvTEMP_off(sv);
8985fe98 3349 }
150b625d 3350 else
2357bae7 3351 SvREFCNT_dec_NN(sv); /* undo the inc in S_save_magic() */
8985fe98 3352 }
51371543
GS		 3353}
3354
0c4d3b5e
DM		 3355/* clean up the mess created by Perl_sighandler().
3356 * Note that this is only called during an exit in a signal handler;
3357 * a die is trapped by the call_sv() and the SAVEDESTRUCTOR_X manually
9a7f166c 3358 * skipped over. */
0c4d3b5e 3359
51371543 3360static void
8772537c 3361S_unwind_handler_stack(pTHX_ const void *p)
51371543 3362{
0c4d3b5e 3363 PERL_UNUSED_ARG(p);
7918f24d 3364
0c4d3b5e 3365 PL_savestack_ix -= 5; /* Unprotect save in progress. */
51371543 3366}
1018e26f 3367
66610fdd 3368/*
b3ca2e83
NC		 3369=for apidoc magic_sethint
3370
3371Triggered by a store to %^H, records the key/value pair to
c28fe1ec
NC		 3372C<PL_compiling.cop_hints_hash>. It is assumed that hints aren't storing
3373anything that would need a deep copy. Maybe we should warn if we find a
3374reference.
b3ca2e83
NC		 3375
3376=cut
3377*/
3378int
3379Perl_magic_sethint(pTHX_ SV *sv, MAGIC *mg)
3380{
ad64d0ec 3381 SV *key = (mg->mg_len == HEf_SVKEY) ? MUTABLE_SV(mg->mg_ptr)
59cd0e26 3382 : newSVpvn_flags(mg->mg_ptr, mg->mg_len, SVs_TEMP);
b3ca2e83 3383
7918f24d
NC		 3384 PERL_ARGS_ASSERT_MAGIC_SETHINT;
3385
e6e3e454
NC		 3386 /* mg->mg_obj isn't being used. If needed, it would be possible to store
3387 an alternative leaf in there, with PL_compiling.cop_hints being used if
3388 it's NULL. If needed for threads, the alternative could lock a mutex,
3389 or take other more complex action. */
3390
5b9c0671
NC		 3391 /* Something changed in %^H, so it will need to be restored on scope exit.
3392 Doing this here saves a lot of doing it manually in perl code (and
3393 forgetting to do it, and consequent subtle errors. */
3394 PL_hints |= HINT_LOCALIZE_HH;
20439bc7
Z		 3395 CopHINTHASH_set(&PL_compiling,
3396 cophh_store_sv(CopHINTHASH_get(&PL_compiling), key, 0, sv, 0));
b3ca2e83
NC		 3397 return 0;
3398}
3399
3400/*
f175cff5 3401=for apidoc magic_clearhint
b3ca2e83 3402
c28fe1ec
NC		 3403Triggered by a delete from %^H, records the key to
3404C<PL_compiling.cop_hints_hash>.
b3ca2e83
NC		 3405
3406=cut
3407*/
3408int
3409Perl_magic_clearhint(pTHX_ SV *sv, MAGIC *mg)
3410{
7918f24d 3411 PERL_ARGS_ASSERT_MAGIC_CLEARHINT;
f5a63d97
AL		 3412 PERL_UNUSED_ARG(sv);
3413
5b9c0671 3414 PL_hints |= HINT_LOCALIZE_HH;
20439bc7 3415 CopHINTHASH_set(&PL_compiling,
e3352591
FC		 3416 mg->mg_len == HEf_SVKEY
3417 ? cophh_delete_sv(CopHINTHASH_get(&PL_compiling),
3418 MUTABLE_SV(mg->mg_ptr), 0, 0)
3419 : cophh_delete_pvn(CopHINTHASH_get(&PL_compiling),
3420 mg->mg_ptr, mg->mg_len, 0, 0));
b3ca2e83
NC		 3421 return 0;
3422}
3423
3424/*
f747ebd6
Z		 3425=for apidoc magic_clearhints
3426
3427Triggered by clearing %^H, resets C<PL_compiling.cop_hints_hash>.
3428
3429=cut
3430*/
3431int
3432Perl_magic_clearhints(pTHX_ SV *sv, MAGIC *mg)
3433{
3434 PERL_ARGS_ASSERT_MAGIC_CLEARHINTS;
3435 PERL_UNUSED_ARG(sv);
3436 PERL_UNUSED_ARG(mg);
20439bc7
Z		 3437 cophh_free(CopHINTHASH_get(&PL_compiling));
3438 CopHINTHASH_set(&PL_compiling, cophh_new_empty());
f747ebd6
Z		 3439 return 0;
3440}
3441
09fb282d
FC		 3442int
3443Perl_magic_copycallchecker(pTHX_ SV *sv, MAGIC *mg, SV *nsv,
3444 const char *name, I32 namlen)
3445{
3446 MAGIC *nmg;
3447
3448 PERL_ARGS_ASSERT_MAGIC_COPYCALLCHECKER;
4f8dbb2d 3449 PERL_UNUSED_ARG(sv);
09fb282d
FC		 3450 PERL_UNUSED_ARG(name);
3451 PERL_UNUSED_ARG(namlen);
3452
3453 sv_magic(nsv, &PL_sv_undef, mg->mg_type, NULL, 0);
3454 nmg = mg_find(nsv, mg->mg_type);
316ebaf2 3455 assert(nmg);
09fb282d
FC		 3456 if (nmg->mg_flags & MGf_REFCOUNTED) SvREFCNT_dec(nmg->mg_obj);
3457 nmg->mg_ptr = mg->mg_ptr;
3458 nmg->mg_obj = SvREFCNT_inc_simple(mg->mg_obj);
3459 nmg->mg_flags |= MGf_REFCOUNTED;
3460 return 1;
3461}
3462
a6d69523
TC		 3463int
3464Perl_magic_setdebugvar(pTHX_ SV *sv, MAGIC *mg) {
3465 PERL_ARGS_ASSERT_MAGIC_SETDEBUGVAR;
3466
23270f96
DM		 3467#if DBVARMG_SINGLE != 0
3468 assert(mg->mg_private >= DBVARMG_SINGLE);
3469#endif
3470 assert(mg->mg_private < DBVARMG_COUNT);
a6d69523
TC		 3471
3472 PL_DBcontrol[mg->mg_private] = SvIV_nomg(sv);
3473
3474 return 1;
3475}
3476
3477int
3478Perl_magic_getdebugvar(pTHX_ SV *sv, MAGIC *mg) {
3479 PERL_ARGS_ASSERT_MAGIC_GETDEBUGVAR;
3480
23270f96
DM		 3481#if DBVARMG_SINGLE != 0
3482 assert(mg->mg_private >= DBVARMG_SINGLE);
3483#endif
3484 assert(mg->mg_private < DBVARMG_COUNT);
a6d69523
TC		 3485 sv_setiv(sv, PL_DBcontrol[mg->mg_private]);
3486
3487 return 0;
3488}
3489
f747ebd6 3490/*
66610fdd
RGS		 3491 * Local variables:
3492 * c-indentation-style: bsd
3493 * c-basic-offset: 4
14d04a33 3494 * indent-tabs-mode: nil
66610fdd
RGS		 3495 * End:
3496 *
14d04a33 3497 * ex: set ts=8 sts=4 sw=4 et:
37442d52 3498 */
Unnamed repository; edit this file 'description' to name the repository.