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