3 * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 * 2000, 2001, 2002, 2003, 2004, 2005, by Larry Wall and others
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.
9 * "I wonder what the Entish is for 'yes' and 'no'," he thought.
12 * This file contains the code that creates, manipulates and destroys
13 * scalar values (SVs). The other types (AV, HV, GV, etc.) reuse the
14 * structure of an SV, so their creation and destruction is handled
15 * here; higher-level functions are in av.c, hv.c, and so on. Opcode
16 * level functions (eg. substr, split, join) for each of the types are
28 /* Missing proto on LynxOS */
29 char *gconvert(double, int, int, char *);
32 #ifdef PERL_UTF8_CACHE_ASSERT
33 /* The cache element 0 is the Unicode offset;
34 * the cache element 1 is the byte offset of the element 0;
35 * the cache element 2 is the Unicode length of the substring;
36 * the cache element 3 is the byte length of the substring;
37 * The checking of the substring side would be good
38 * but substr() has enough code paths to make my head spin;
39 * if adding more checks watch out for the following tests:
40 * t/op/index.t t/op/length.t t/op/pat.t t/op/substr.t
41 * lib/utf8.t lib/Unicode/Collate/t/index.t
44 #define ASSERT_UTF8_CACHE(cache) \
45 STMT_START { if (cache) { assert((cache)[0] <= (cache)[1]); } } STMT_END
47 #define ASSERT_UTF8_CACHE(cache) NOOP
50 #ifdef PERL_OLD_COPY_ON_WRITE
51 #define SV_COW_NEXT_SV(sv) INT2PTR(SV *,SvUVX(sv))
52 #define SV_COW_NEXT_SV_SET(current,next) SvUV_set(current, PTR2UV(next))
53 /* This is a pessimistic view. Scalar must be purely a read-write PV to copy-
57 /* ============================================================================
59 =head1 Allocation and deallocation of SVs.
61 An SV (or AV, HV, etc.) is allocated in two parts: the head (struct sv,
62 av, hv...) contains type and reference count information, as well as a
63 pointer to the body (struct xrv, xpv, xpviv...), which contains fields
64 specific to each type.
66 Normally, this allocation is done using arenas, which by default are
67 approximately 4K chunks of memory parcelled up into N heads or bodies. The
68 first slot in each arena is reserved, and is used to hold a link to the next
69 arena. In the case of heads, the unused first slot also contains some flags
70 and a note of the number of slots. Snaked through each arena chain is a
71 linked list of free items; when this becomes empty, an extra arena is
72 allocated and divided up into N items which are threaded into the free list.
74 The following global variables are associated with arenas:
76 PL_sv_arenaroot pointer to list of SV arenas
77 PL_sv_root pointer to list of free SV structures
79 PL_foo_arenaroot pointer to list of foo arenas,
80 PL_foo_root pointer to list of free foo bodies
81 ... for foo in xiv, xnv, xrv, xpv etc.
83 Note that some of the larger and more rarely used body types (eg xpvio)
84 are not allocated using arenas, but are instead just malloc()/free()ed as
85 required. Also, if PURIFY is defined, arenas are abandoned altogether,
86 with all items individually malloc()ed. In addition, a few SV heads are
87 not allocated from an arena, but are instead directly created as static
88 or auto variables, eg PL_sv_undef. The size of arenas can be changed from
89 the default by setting PERL_ARENA_SIZE appropriately at compile time.
91 The SV arena serves the secondary purpose of allowing still-live SVs
92 to be located and destroyed during final cleanup.
94 At the lowest level, the macros new_SV() and del_SV() grab and free
95 an SV head. (If debugging with -DD, del_SV() calls the function S_del_sv()
96 to return the SV to the free list with error checking.) new_SV() calls
97 more_sv() / sv_add_arena() to add an extra arena if the free list is empty.
98 SVs in the free list have their SvTYPE field set to all ones.
100 Similarly, there are macros new_XIV()/del_XIV(), new_XNV()/del_XNV() etc
101 that allocate and return individual body types. Normally these are mapped
102 to the arena-manipulating functions new_xiv()/del_xiv() etc, but may be
103 instead mapped directly to malloc()/free() if PURIFY is defined. The
104 new/del functions remove from, or add to, the appropriate PL_foo_root
105 list, and call more_xiv() etc to add a new arena if the list is empty.
107 At the time of very final cleanup, sv_free_arenas() is called from
108 perl_destruct() to physically free all the arenas allocated since the
109 start of the interpreter. Note that this also clears PL_he_arenaroot,
110 which is otherwise dealt with in hv.c.
112 Manipulation of any of the PL_*root pointers is protected by enclosing
113 LOCK_SV_MUTEX; ... UNLOCK_SV_MUTEX calls which should Do the Right Thing
114 if threads are enabled.
116 The function visit() scans the SV arenas list, and calls a specified
117 function for each SV it finds which is still live - ie which has an SvTYPE
118 other than all 1's, and a non-zero SvREFCNT. visit() is used by the
119 following functions (specified as [function that calls visit()] / [function
120 called by visit() for each SV]):
122 sv_report_used() / do_report_used()
123 dump all remaining SVs (debugging aid)
125 sv_clean_objs() / do_clean_objs(),do_clean_named_objs()
126 Attempt to free all objects pointed to by RVs,
127 and, unless DISABLE_DESTRUCTOR_KLUDGE is defined,
128 try to do the same for all objects indirectly
129 referenced by typeglobs too. Called once from
130 perl_destruct(), prior to calling sv_clean_all()
133 sv_clean_all() / do_clean_all()
134 SvREFCNT_dec(sv) each remaining SV, possibly
135 triggering an sv_free(). It also sets the
136 SVf_BREAK flag on the SV to indicate that the
137 refcnt has been artificially lowered, and thus
138 stopping sv_free() from giving spurious warnings
139 about SVs which unexpectedly have a refcnt
140 of zero. called repeatedly from perl_destruct()
141 until there are no SVs left.
145 Private API to rest of sv.c
149 new_XIV(), del_XIV(),
150 new_XNV(), del_XNV(),
155 sv_report_used(), sv_clean_objs(), sv_clean_all(), sv_free_arenas()
160 ============================================================================ */
165 * "A time to plant, and a time to uproot what was planted..."
169 * nice_chunk and nice_chunk size need to be set
170 * and queried under the protection of sv_mutex
173 Perl_offer_nice_chunk(pTHX_ void *chunk, U32 chunk_size)
178 new_chunk = (void *)(chunk);
179 new_chunk_size = (chunk_size);
180 if (new_chunk_size > PL_nice_chunk_size) {
181 Safefree(PL_nice_chunk);
182 PL_nice_chunk = (char *) new_chunk;
183 PL_nice_chunk_size = new_chunk_size;
190 #ifdef DEBUG_LEAKING_SCALARS
192 # define FREE_SV_DEBUG_FILE(sv) PerlMemfree((sv)->sv_debug_file)
194 # define FREE_SV_DEBUG_FILE(sv) PerlMemShared_free((sv)->sv_debug_file)
197 # define FREE_SV_DEBUG_FILE(sv)
200 #define plant_SV(p) \
202 FREE_SV_DEBUG_FILE(p); \
203 SvANY(p) = (void *)PL_sv_root; \
204 SvFLAGS(p) = SVTYPEMASK; \
209 /* sv_mutex must be held while calling uproot_SV() */
210 #define uproot_SV(p) \
213 PL_sv_root = (SV*)SvANY(p); \
218 /* make some more SVs by adding another arena */
220 /* sv_mutex must be held while calling more_sv() */
227 sv_add_arena(PL_nice_chunk, PL_nice_chunk_size, 0);
228 PL_nice_chunk = Nullch;
229 PL_nice_chunk_size = 0;
232 char *chunk; /* must use New here to match call to */
233 Newx(chunk,PERL_ARENA_SIZE,char); /* Safefree() in sv_free_arenas() */
234 sv_add_arena(chunk, PERL_ARENA_SIZE, 0);
240 /* new_SV(): return a new, empty SV head */
242 #ifdef DEBUG_LEAKING_SCALARS
243 /* provide a real function for a debugger to play with */
253 sv = S_more_sv(aTHX);
258 sv->sv_debug_optype = PL_op ? PL_op->op_type : 0;
259 sv->sv_debug_line = (U16) ((PL_copline == NOLINE) ?
260 (PL_curcop ? CopLINE(PL_curcop) : 0) : PL_copline);
261 sv->sv_debug_inpad = 0;
262 sv->sv_debug_cloned = 0;
264 sv->sv_debug_file = PL_curcop ? savepv(CopFILE(PL_curcop)): NULL;
266 sv->sv_debug_file = PL_curcop ? savesharedpv(CopFILE(PL_curcop)): NULL;
271 # define new_SV(p) (p)=S_new_SV(aTHX)
280 (p) = S_more_sv(aTHX); \
289 /* del_SV(): return an empty SV head to the free list */
304 S_del_sv(pTHX_ SV *p)
309 for (sva = PL_sv_arenaroot; sva; sva = (SV *) SvANY(sva)) {
310 const SV * const sv = sva + 1;
311 const SV * const svend = &sva[SvREFCNT(sva)];
312 if (p >= sv && p < svend) {
318 if (ckWARN_d(WARN_INTERNAL))
319 Perl_warner(aTHX_ packWARN(WARN_INTERNAL),
320 "Attempt to free non-arena SV: 0x%"UVxf
321 pTHX__FORMAT, PTR2UV(p) pTHX__VALUE);
328 #else /* ! DEBUGGING */
330 #define del_SV(p) plant_SV(p)
332 #endif /* DEBUGGING */
336 =head1 SV Manipulation Functions
338 =for apidoc sv_add_arena
340 Given a chunk of memory, link it to the head of the list of arenas,
341 and split it into a list of free SVs.
347 Perl_sv_add_arena(pTHX_ char *ptr, U32 size, U32 flags)
353 /* The first SV in an arena isn't an SV. */
354 SvANY(sva) = (void *) PL_sv_arenaroot; /* ptr to next arena */
355 SvREFCNT(sva) = size / sizeof(SV); /* number of SV slots */
356 SvFLAGS(sva) = flags; /* FAKE if not to be freed */
358 PL_sv_arenaroot = sva;
359 PL_sv_root = sva + 1;
361 svend = &sva[SvREFCNT(sva) - 1];
364 SvANY(sv) = (void *)(SV*)(sv + 1);
368 /* Must always set typemask because it's awlays checked in on cleanup
369 when the arenas are walked looking for objects. */
370 SvFLAGS(sv) = SVTYPEMASK;
377 SvFLAGS(sv) = SVTYPEMASK;
380 /* visit(): call the named function for each non-free SV in the arenas
381 * whose flags field matches the flags/mask args. */
384 S_visit(pTHX_ SVFUNC_t f, U32 flags, U32 mask)
389 for (sva = PL_sv_arenaroot; sva; sva = (SV*)SvANY(sva)) {
390 register const SV * const svend = &sva[SvREFCNT(sva)];
392 for (sv = sva + 1; sv < svend; ++sv) {
393 if (SvTYPE(sv) != SVTYPEMASK
394 && (sv->sv_flags & mask) == flags
407 /* called by sv_report_used() for each live SV */
410 do_report_used(pTHX_ SV *sv)
412 if (SvTYPE(sv) != SVTYPEMASK) {
413 PerlIO_printf(Perl_debug_log, "****\n");
420 =for apidoc sv_report_used
422 Dump the contents of all SVs not yet freed. (Debugging aid).
428 Perl_sv_report_used(pTHX)
431 visit(do_report_used, 0, 0);
435 /* called by sv_clean_objs() for each live SV */
438 do_clean_objs(pTHX_ SV *ref)
442 if (SvROK(ref) && SvOBJECT(target = SvRV(ref))) {
443 DEBUG_D((PerlIO_printf(Perl_debug_log, "Cleaning object ref:\n "), sv_dump(ref)));
444 if (SvWEAKREF(ref)) {
445 sv_del_backref(target, ref);
451 SvREFCNT_dec(target);
455 /* XXX Might want to check arrays, etc. */
458 /* called by sv_clean_objs() for each live SV */
460 #ifndef DISABLE_DESTRUCTOR_KLUDGE
462 do_clean_named_objs(pTHX_ SV *sv)
464 if (SvTYPE(sv) == SVt_PVGV && GvGP(sv)) {
466 #ifdef PERL_DONT_CREATE_GVSV
469 SvOBJECT(GvSV(sv))) ||
470 (GvAV(sv) && SvOBJECT(GvAV(sv))) ||
471 (GvHV(sv) && SvOBJECT(GvHV(sv))) ||
472 (GvIO(sv) && SvOBJECT(GvIO(sv))) ||
473 (GvCV(sv) && SvOBJECT(GvCV(sv))) )
475 DEBUG_D((PerlIO_printf(Perl_debug_log, "Cleaning named glob object:\n "), sv_dump(sv)));
476 SvFLAGS(sv) |= SVf_BREAK;
484 =for apidoc sv_clean_objs
486 Attempt to destroy all objects not yet freed
492 Perl_sv_clean_objs(pTHX)
494 PL_in_clean_objs = TRUE;
495 visit(do_clean_objs, SVf_ROK, SVf_ROK);
496 #ifndef DISABLE_DESTRUCTOR_KLUDGE
497 /* some barnacles may yet remain, clinging to typeglobs */
498 visit(do_clean_named_objs, SVt_PVGV, SVTYPEMASK);
500 PL_in_clean_objs = FALSE;
503 /* called by sv_clean_all() for each live SV */
506 do_clean_all(pTHX_ SV *sv)
508 DEBUG_D((PerlIO_printf(Perl_debug_log, "Cleaning loops: SV at 0x%"UVxf"\n", PTR2UV(sv)) ));
509 SvFLAGS(sv) |= SVf_BREAK;
510 if (PL_comppad == (AV*)sv) {
512 PL_curpad = Null(SV**);
518 =for apidoc sv_clean_all
520 Decrement the refcnt of each remaining SV, possibly triggering a
521 cleanup. This function may have to be called multiple times to free
522 SVs which are in complex self-referential hierarchies.
528 Perl_sv_clean_all(pTHX)
531 PL_in_clean_all = TRUE;
532 cleaned = visit(do_clean_all, 0,0);
533 PL_in_clean_all = FALSE;
538 S_free_arena(pTHX_ void **root) {
540 void ** const next = *(void **)root;
547 =for apidoc sv_free_arenas
549 Deallocate the memory used by all arenas. Note that all the individual SV
550 heads and bodies within the arenas must already have been freed.
555 #define free_arena(name) \
557 S_free_arena(aTHX_ (void**) PL_ ## name ## _arenaroot); \
558 PL_ ## name ## _arenaroot = 0; \
559 PL_ ## name ## _root = 0; \
563 Perl_sv_free_arenas(pTHX)
568 /* Free arenas here, but be careful about fake ones. (We assume
569 contiguity of the fake ones with the corresponding real ones.) */
571 for (sva = PL_sv_arenaroot; sva; sva = svanext) {
572 svanext = (SV*) SvANY(sva);
573 while (svanext && SvFAKE(svanext))
574 svanext = (SV*) SvANY(svanext);
592 #if defined(USE_ITHREADS)
596 Safefree(PL_nice_chunk);
597 PL_nice_chunk = Nullch;
598 PL_nice_chunk_size = 0;
603 /* ---------------------------------------------------------------------
605 * support functions for report_uninit()
608 /* the maxiumum size of array or hash where we will scan looking
609 * for the undefined element that triggered the warning */
611 #define FUV_MAX_SEARCH_SIZE 1000
613 /* Look for an entry in the hash whose value has the same SV as val;
614 * If so, return a mortal copy of the key. */
617 S_find_hash_subscript(pTHX_ HV *hv, SV* val)
623 if (!hv || SvMAGICAL(hv) || !HvARRAY(hv) ||
624 (HvTOTALKEYS(hv) > FUV_MAX_SEARCH_SIZE))
629 for (i=HvMAX(hv); i>0; i--) {
631 for (entry = array[i]; entry; entry = HeNEXT(entry)) {
632 if (HeVAL(entry) != val)
634 if ( HeVAL(entry) == &PL_sv_undef ||
635 HeVAL(entry) == &PL_sv_placeholder)
639 if (HeKLEN(entry) == HEf_SVKEY)
640 return sv_mortalcopy(HeKEY_sv(entry));
641 return sv_2mortal(newSVpvn(HeKEY(entry), HeKLEN(entry)));
647 /* Look for an entry in the array whose value has the same SV as val;
648 * If so, return the index, otherwise return -1. */
651 S_find_array_subscript(pTHX_ AV *av, SV* val)
655 if (!av || SvMAGICAL(av) || !AvARRAY(av) ||
656 (AvFILLp(av) > FUV_MAX_SEARCH_SIZE))
660 for (i=AvFILLp(av); i>=0; i--) {
661 if (svp[i] == val && svp[i] != &PL_sv_undef)
667 /* S_varname(): return the name of a variable, optionally with a subscript.
668 * If gv is non-zero, use the name of that global, along with gvtype (one
669 * of "$", "@", "%"); otherwise use the name of the lexical at pad offset
670 * targ. Depending on the value of the subscript_type flag, return:
673 #define FUV_SUBSCRIPT_NONE 1 /* "@foo" */
674 #define FUV_SUBSCRIPT_ARRAY 2 /* "$foo[aindex]" */
675 #define FUV_SUBSCRIPT_HASH 3 /* "$foo{keyname}" */
676 #define FUV_SUBSCRIPT_WITHIN 4 /* "within @foo" */
679 S_varname(pTHX_ GV *gv, const char gvtype, PADOFFSET targ,
680 SV* keyname, I32 aindex, int subscript_type)
683 SV * const name = sv_newmortal();
686 /* simulate gv_fullname4(), but add literal '^' for $^FOO names
687 * XXX get rid of all this if gv_fullnameX() ever supports this
691 HV * const hv = GvSTASH(gv);
694 else if (!(p=HvNAME_get(hv)))
696 if (strEQ(p, "main"))
697 sv_setpvn(name, &gvtype, 1);
699 Perl_sv_setpvf(aTHX_ name, "%c%s::", gvtype, p);
701 if (GvNAMELEN(gv)>= 1 &&
702 ((unsigned int)*GvNAME(gv)) <= 26)
704 Perl_sv_catpvf(aTHX_ name,"^%c", *GvNAME(gv) + 'A' - 1);
705 sv_catpvn(name,GvNAME(gv)+1,GvNAMELEN(gv)-1);
708 sv_catpvn(name,GvNAME(gv),GvNAMELEN(gv));
712 CV * const cv = find_runcv(&unused);
716 if (!cv || !CvPADLIST(cv))
718 av = (AV*)(*av_fetch(CvPADLIST(cv), 0, FALSE));
719 sv = *av_fetch(av, targ, FALSE);
720 /* SvLEN in a pad name is not to be trusted */
721 sv_setpv(name, SvPV_nolen_const(sv));
724 if (subscript_type == FUV_SUBSCRIPT_HASH) {
725 SV * const sv = NEWSV(0,0);
727 Perl_sv_catpvf(aTHX_ name, "{%s}",
728 pv_display(sv,SvPVX_const(keyname), SvCUR(keyname), 0, 32));
731 else if (subscript_type == FUV_SUBSCRIPT_ARRAY) {
733 Perl_sv_catpvf(aTHX_ name, "[%"IVdf"]", (IV)aindex);
735 else if (subscript_type == FUV_SUBSCRIPT_WITHIN)
736 sv_insert(name, 0, 0, "within ", 7);
743 =for apidoc find_uninit_var
745 Find the name of the undefined variable (if any) that caused the operator o
746 to issue a "Use of uninitialized value" warning.
747 If match is true, only return a name if it's value matches uninit_sv.
748 So roughly speaking, if a unary operator (such as OP_COS) generates a
749 warning, then following the direct child of the op may yield an
750 OP_PADSV or OP_GV that gives the name of the undefined variable. On the
751 other hand, with OP_ADD there are two branches to follow, so we only print
752 the variable name if we get an exact match.
754 The name is returned as a mortal SV.
756 Assumes that PL_op is the op that originally triggered the error, and that
757 PL_comppad/PL_curpad points to the currently executing pad.
763 S_find_uninit_var(pTHX_ OP* obase, SV* uninit_sv, bool match)
771 if (!obase || (match && (!uninit_sv || uninit_sv == &PL_sv_undef ||
772 uninit_sv == &PL_sv_placeholder)))
775 switch (obase->op_type) {
782 const bool pad = (obase->op_type == OP_PADAV || obase->op_type == OP_PADHV);
783 const bool hash = (obase->op_type == OP_PADHV || obase->op_type == OP_RV2HV);
786 int subscript_type = FUV_SUBSCRIPT_WITHIN;
788 if (pad) { /* @lex, %lex */
789 sv = PAD_SVl(obase->op_targ);
793 if (cUNOPx(obase)->op_first->op_type == OP_GV) {
794 /* @global, %global */
795 gv = cGVOPx_gv(cUNOPx(obase)->op_first);
798 sv = hash ? (SV*)GvHV(gv): (SV*)GvAV(gv);
800 else /* @{expr}, %{expr} */
801 return find_uninit_var(cUNOPx(obase)->op_first,
805 /* attempt to find a match within the aggregate */
807 keysv = S_find_hash_subscript(aTHX_ (HV*)sv, uninit_sv);
809 subscript_type = FUV_SUBSCRIPT_HASH;
812 index = S_find_array_subscript(aTHX_ (AV*)sv, uninit_sv);
814 subscript_type = FUV_SUBSCRIPT_ARRAY;
817 if (match && subscript_type == FUV_SUBSCRIPT_WITHIN)
820 return varname(gv, hash ? '%' : '@', obase->op_targ,
821 keysv, index, subscript_type);
825 if (match && PAD_SVl(obase->op_targ) != uninit_sv)
827 return varname(Nullgv, '$', obase->op_targ,
828 Nullsv, 0, FUV_SUBSCRIPT_NONE);
831 gv = cGVOPx_gv(obase);
832 if (!gv || (match && GvSV(gv) != uninit_sv))
834 return varname(gv, '$', 0, Nullsv, 0, FUV_SUBSCRIPT_NONE);
837 if (obase->op_flags & OPf_SPECIAL) { /* lexical array */
840 av = (AV*)PAD_SV(obase->op_targ);
841 if (!av || SvRMAGICAL(av))
843 svp = av_fetch(av, (I32)obase->op_private, FALSE);
844 if (!svp || *svp != uninit_sv)
847 return varname(Nullgv, '$', obase->op_targ,
848 Nullsv, (I32)obase->op_private, FUV_SUBSCRIPT_ARRAY);
851 gv = cGVOPx_gv(obase);
857 if (!av || SvRMAGICAL(av))
859 svp = av_fetch(av, (I32)obase->op_private, FALSE);
860 if (!svp || *svp != uninit_sv)
863 return varname(gv, '$', 0,
864 Nullsv, (I32)obase->op_private, FUV_SUBSCRIPT_ARRAY);
869 o = cUNOPx(obase)->op_first;
870 if (!o || o->op_type != OP_NULL ||
871 ! (o->op_targ == OP_AELEM || o->op_targ == OP_HELEM))
873 return find_uninit_var(cBINOPo->op_last, uninit_sv, match);
878 /* $a[uninit_expr] or $h{uninit_expr} */
879 return find_uninit_var(cBINOPx(obase)->op_last, uninit_sv, match);
882 o = cBINOPx(obase)->op_first;
883 kid = cBINOPx(obase)->op_last;
885 /* get the av or hv, and optionally the gv */
887 if (o->op_type == OP_PADAV || o->op_type == OP_PADHV) {
888 sv = PAD_SV(o->op_targ);
890 else if ((o->op_type == OP_RV2AV || o->op_type == OP_RV2HV)
891 && cUNOPo->op_first->op_type == OP_GV)
893 gv = cGVOPx_gv(cUNOPo->op_first);
896 sv = o->op_type == OP_RV2HV ? (SV*)GvHV(gv) : (SV*)GvAV(gv);
901 if (kid && kid->op_type == OP_CONST && SvOK(cSVOPx_sv(kid))) {
902 /* index is constant */
906 if (obase->op_type == OP_HELEM) {
907 HE* he = hv_fetch_ent((HV*)sv, cSVOPx_sv(kid), 0, 0);
908 if (!he || HeVAL(he) != uninit_sv)
912 SV ** const svp = av_fetch((AV*)sv, SvIV(cSVOPx_sv(kid)), FALSE);
913 if (!svp || *svp != uninit_sv)
917 if (obase->op_type == OP_HELEM)
918 return varname(gv, '%', o->op_targ,
919 cSVOPx_sv(kid), 0, FUV_SUBSCRIPT_HASH);
921 return varname(gv, '@', o->op_targ, Nullsv,
922 SvIV(cSVOPx_sv(kid)), FUV_SUBSCRIPT_ARRAY);
926 /* index is an expression;
927 * attempt to find a match within the aggregate */
928 if (obase->op_type == OP_HELEM) {
929 SV * const keysv = S_find_hash_subscript(aTHX_ (HV*)sv, uninit_sv);
931 return varname(gv, '%', o->op_targ,
932 keysv, 0, FUV_SUBSCRIPT_HASH);
935 const I32 index = S_find_array_subscript(aTHX_ (AV*)sv, uninit_sv);
937 return varname(gv, '@', o->op_targ,
938 Nullsv, index, FUV_SUBSCRIPT_ARRAY);
943 (o->op_type == OP_PADAV || o->op_type == OP_RV2AV)
945 o->op_targ, Nullsv, 0, FUV_SUBSCRIPT_WITHIN);
951 /* only examine RHS */
952 return find_uninit_var(cBINOPx(obase)->op_first, uninit_sv, match);
955 o = cUNOPx(obase)->op_first;
956 if (o->op_type == OP_PUSHMARK)
959 if (!o->op_sibling) {
960 /* one-arg version of open is highly magical */
962 if (o->op_type == OP_GV) { /* open FOO; */
964 if (match && GvSV(gv) != uninit_sv)
966 return varname(gv, '$', 0,
967 Nullsv, 0, FUV_SUBSCRIPT_NONE);
969 /* other possibilities not handled are:
970 * open $x; or open my $x; should return '${*$x}'
971 * open expr; should return '$'.expr ideally
977 /* ops where $_ may be an implicit arg */
981 if ( !(obase->op_flags & OPf_STACKED)) {
982 if (uninit_sv == ((obase->op_private & OPpTARGET_MY)
983 ? PAD_SVl(obase->op_targ)
987 sv_setpvn(sv, "$_", 2);
995 /* skip filehandle as it can't produce 'undef' warning */
996 o = cUNOPx(obase)->op_first;
997 if ((obase->op_flags & OPf_STACKED) && o->op_type == OP_PUSHMARK)
998 o = o->op_sibling->op_sibling;
1005 match = 1; /* XS or custom code could trigger random warnings */
1010 if (SvROK(PL_rs) && uninit_sv == SvRV(PL_rs))
1011 return sv_2mortal(newSVpvn("${$/}", 5));
1016 if (!(obase->op_flags & OPf_KIDS))
1018 o = cUNOPx(obase)->op_first;
1024 /* if all except one arg are constant, or have no side-effects,
1025 * or are optimized away, then it's unambiguous */
1027 for (kid=o; kid; kid = kid->op_sibling) {
1029 ( (kid->op_type == OP_CONST && SvOK(cSVOPx_sv(kid)))
1030 || (kid->op_type == OP_NULL && ! (kid->op_flags & OPf_KIDS))
1031 || (kid->op_type == OP_PUSHMARK)
1035 if (o2) { /* more than one found */
1042 return find_uninit_var(o2, uninit_sv, match);
1046 sv = find_uninit_var(o, uninit_sv, 1);
1058 =for apidoc report_uninit
1060 Print appropriate "Use of uninitialized variable" warning
1066 Perl_report_uninit(pTHX_ SV* uninit_sv)
1069 SV* varname = Nullsv;
1071 varname = find_uninit_var(PL_op, uninit_sv,0);
1073 sv_insert(varname, 0, 0, " ", 1);
1075 Perl_warner(aTHX_ packWARN(WARN_UNINITIALIZED), PL_warn_uninit,
1076 varname ? SvPV_nolen_const(varname) : "",
1077 " in ", OP_DESC(PL_op));
1080 Perl_warner(aTHX_ packWARN(WARN_UNINITIALIZED), PL_warn_uninit,
1085 S_more_bodies (pTHX_ void **arena_root, void **root, size_t size)
1089 const size_t count = PERL_ARENA_SIZE/size;
1090 Newx(start, count*size, char);
1091 *((void **) start) = *arena_root;
1092 *arena_root = (void *)start;
1094 end = start + (count-1) * size;
1096 /* The initial slot is used to link the arenas together, so it isn't to be
1097 linked into the list of ready-to-use bodies. */
1101 *root = (void *)start;
1103 while (start < end) {
1104 char * const next = start + size;
1105 *(void**) start = (void *)next;
1108 *(void **)start = 0;
1113 /* grab a new thing from the free list, allocating more if necessary */
1115 /* 1st, the inline version */
1117 #define new_body_inline(xpv, arena_root, root, size) \
1120 xpv = *((void **)(root)) \
1121 ? *((void **)(root)) : S_more_bodies(aTHX_ arena_root, root, size); \
1122 *(root) = *(void**)(xpv); \
1126 /* now use the inline version in the proper function */
1129 S_new_body(pTHX_ void **arena_root, void **root, size_t size)
1132 new_body_inline(xpv, arena_root, root, size);
1136 /* return a thing to the free list */
1138 #define del_body(thing, root) \
1140 void **thing_copy = (void **)thing; \
1142 *thing_copy = *root; \
1143 *root = (void*)thing_copy; \
1147 /* Conventionally we simply malloc() a big block of memory, then divide it
1148 up into lots of the thing that we're allocating.
1150 This macro will expand to call to S_new_body. So for XPVBM (with ithreads),
1153 S_new_body(my_perl, (void**)&(my_perl->Ixpvbm_arenaroot),
1154 (void**)&(my_perl->Ixpvbm_root), sizeof(XPVBM), 0)
1157 #define new_body_type(TYPE,lctype) \
1158 S_new_body(aTHX_ (void**)&PL_ ## lctype ## _arenaroot, \
1159 (void**)&PL_ ## lctype ## _root, \
1162 #define del_body_type(p,TYPE,lctype) \
1163 del_body((void*)p, (void**)&PL_ ## lctype ## _root)
1165 /* But for some types, we cheat. The type starts with some members that are
1166 never accessed. So we allocate the substructure, starting at the first used
1167 member, then adjust the pointer back in memory by the size of the bit not
1168 allocated, so it's as if we allocated the full structure.
1169 (But things will all go boom if you write to the part that is "not there",
1170 because you'll be overwriting the last members of the preceding structure
1173 We calculate the correction using the STRUCT_OFFSET macro. For example, if
1174 xpv_allocated is the same structure as XPV then the two OFFSETs sum to zero,
1175 and the pointer is unchanged. If the allocated structure is smaller (no
1176 initial NV actually allocated) then the net effect is to subtract the size
1177 of the NV from the pointer, to return a new pointer as if an initial NV were
1180 This is the same trick as was used for NV and IV bodies. Ironically it
1181 doesn't need to be used for NV bodies any more, because NV is now at the
1182 start of the structure. IV bodies don't need it either, because they are
1183 no longer allocated. */
1185 #define new_body_allocated(TYPE,lctype,member) \
1186 (void*)((char*)S_new_body(aTHX_ (void**)&PL_ ## lctype ## _arenaroot, \
1187 (void**)&PL_ ## lctype ## _root, \
1188 sizeof(lctype ## _allocated)) - \
1189 STRUCT_OFFSET(TYPE, member) \
1190 + STRUCT_OFFSET(lctype ## _allocated, member))
1193 #define del_body_allocated(p,TYPE,lctype,member) \
1194 del_body((void*)((char*)p + STRUCT_OFFSET(TYPE, member) \
1195 - STRUCT_OFFSET(lctype ## _allocated, member)), \
1196 (void**)&PL_ ## lctype ## _root)
1198 #define my_safemalloc(s) (void*)safemalloc(s)
1199 #define my_safefree(p) safefree((char*)p)
1203 #define new_XNV() my_safemalloc(sizeof(XPVNV))
1204 #define del_XNV(p) my_safefree(p)
1206 #define new_XPV() my_safemalloc(sizeof(XPV))
1207 #define del_XPV(p) my_safefree(p)
1209 #define new_XPVIV() my_safemalloc(sizeof(XPVIV))
1210 #define del_XPVIV(p) my_safefree(p)
1212 #define new_XPVNV() my_safemalloc(sizeof(XPVNV))
1213 #define del_XPVNV(p) my_safefree(p)
1215 #define new_XPVCV() my_safemalloc(sizeof(XPVCV))
1216 #define del_XPVCV(p) my_safefree(p)
1218 #define new_XPVAV() my_safemalloc(sizeof(XPVAV))
1219 #define del_XPVAV(p) my_safefree(p)
1221 #define new_XPVHV() my_safemalloc(sizeof(XPVHV))
1222 #define del_XPVHV(p) my_safefree(p)
1224 #define new_XPVMG() my_safemalloc(sizeof(XPVMG))
1225 #define del_XPVMG(p) my_safefree(p)
1227 #define new_XPVGV() my_safemalloc(sizeof(XPVGV))
1228 #define del_XPVGV(p) my_safefree(p)
1230 #define new_XPVLV() my_safemalloc(sizeof(XPVLV))
1231 #define del_XPVLV(p) my_safefree(p)
1233 #define new_XPVBM() my_safemalloc(sizeof(XPVBM))
1234 #define del_XPVBM(p) my_safefree(p)
1238 #define new_XNV() new_body_type(NV, xnv)
1239 #define del_XNV(p) del_body_type(p, NV, xnv)
1241 #define new_XPV() new_body_allocated(XPV, xpv, xpv_cur)
1242 #define del_XPV(p) del_body_allocated(p, XPV, xpv, xpv_cur)
1244 #define new_XPVIV() new_body_allocated(XPVIV, xpviv, xpv_cur)
1245 #define del_XPVIV(p) del_body_allocated(p, XPVIV, xpviv, xpv_cur)
1247 #define new_XPVNV() new_body_type(XPVNV, xpvnv)
1248 #define del_XPVNV(p) del_body_type(p, XPVNV, xpvnv)
1250 #define new_XPVCV() new_body_type(XPVCV, xpvcv)
1251 #define del_XPVCV(p) del_body_type(p, XPVCV, xpvcv)
1253 #define new_XPVAV() new_body_allocated(XPVAV, xpvav, xav_fill)
1254 #define del_XPVAV(p) del_body_allocated(p, XPVAV, xpvav, xav_fill)
1256 #define new_XPVHV() new_body_allocated(XPVHV, xpvhv, xhv_fill)
1257 #define del_XPVHV(p) del_body_allocated(p, XPVHV, xpvhv, xhv_fill)
1259 #define new_XPVMG() new_body_type(XPVMG, xpvmg)
1260 #define del_XPVMG(p) del_body_type(p, XPVMG, xpvmg)
1262 #define new_XPVGV() new_body_type(XPVGV, xpvgv)
1263 #define del_XPVGV(p) del_body_type(p, XPVGV, xpvgv)
1265 #define new_XPVLV() new_body_type(XPVLV, xpvlv)
1266 #define del_XPVLV(p) del_body_type(p, XPVLV, xpvlv)
1268 #define new_XPVBM() new_body_type(XPVBM, xpvbm)
1269 #define del_XPVBM(p) del_body_type(p, XPVBM, xpvbm)
1273 #define new_XPVFM() my_safemalloc(sizeof(XPVFM))
1274 #define del_XPVFM(p) my_safefree(p)
1276 #define new_XPVIO() my_safemalloc(sizeof(XPVIO))
1277 #define del_XPVIO(p) my_safefree(p)
1280 =for apidoc sv_upgrade
1282 Upgrade an SV to a more complex form. Generally adds a new body type to the
1283 SV, then copies across as much information as possible from the old body.
1284 You generally want to use the C<SvUPGRADE> macro wrapper. See also C<svtype>.
1290 Perl_sv_upgrade(pTHX_ register SV *sv, U32 mt)
1292 void** old_body_arena;
1293 size_t old_body_offset;
1294 size_t old_body_length; /* Well, the length to copy. */
1296 #ifndef NV_ZERO_IS_ALLBITS_ZERO
1297 /* If NV 0.0 is store as all bits 0 then Zero() already creates a correct
1299 bool zero_nv = TRUE;
1302 size_t new_body_length;
1303 size_t new_body_offset;
1304 void** new_body_arena;
1305 void** new_body_arenaroot;
1306 const U32 old_type = SvTYPE(sv);
1308 if (mt != SVt_PV && SvIsCOW(sv)) {
1309 sv_force_normal_flags(sv, 0);
1312 if (SvTYPE(sv) == mt)
1315 if (SvTYPE(sv) > mt)
1316 Perl_croak(aTHX_ "sv_upgrade from type %d down to type %d",
1317 (int)SvTYPE(sv), (int)mt);
1320 old_body = SvANY(sv);
1322 old_body_offset = 0;
1323 old_body_length = 0;
1324 new_body_offset = 0;
1325 new_body_length = ~0;
1327 /* Copying structures onto other structures that have been neatly zeroed
1328 has a subtle gotcha. Consider XPVMG
1330 +------+------+------+------+------+-------+-------+
1331 | NV | CUR | LEN | IV | MAGIC | STASH |
1332 +------+------+------+------+------+-------+-------+
1333 0 4 8 12 16 20 24 28
1335 where NVs are aligned to 8 bytes, so that sizeof that structure is
1336 actually 32 bytes long, with 4 bytes of padding at the end:
1338 +------+------+------+------+------+-------+-------+------+
1339 | NV | CUR | LEN | IV | MAGIC | STASH | ??? |
1340 +------+------+------+------+------+-------+-------+------+
1341 0 4 8 12 16 20 24 28 32
1343 so what happens if you allocate memory for this structure:
1345 +------+------+------+------+------+-------+-------+------+------+...
1346 | NV | CUR | LEN | IV | MAGIC | STASH | GP | NAME |
1347 +------+------+------+------+------+-------+-------+------+------+...
1348 0 4 8 12 16 20 24 28 32 36
1350 zero it, then copy sizeof(XPVMG) bytes on top of it? Not quite what you
1351 expect, because you copy the area marked ??? onto GP. Now, ??? may have
1352 started out as zero once, but it's quite possible that it isn't. So now,
1353 rather than a nicely zeroed GP, you have it pointing somewhere random.
1356 (In fact, GP ends up pointing at a previous GP structure, because the
1357 principle cause of the padding in XPVMG getting garbage is a copy of
1358 sizeof(XPVMG) bytes from a XPVGV structure in sv_unglob)
1360 So we are careful and work out the size of used parts of all the
1363 switch (SvTYPE(sv)) {
1369 else if (mt < SVt_PVIV)
1371 old_body_offset = STRUCT_OFFSET(XPVIV, xiv_iv);
1372 old_body_length = sizeof(IV);
1375 old_body_arena = (void **) &PL_xnv_root;
1376 old_body_length = sizeof(NV);
1377 #ifndef NV_ZERO_IS_ALLBITS_ZERO
1386 old_body_arena = (void **) &PL_xpv_root;
1387 old_body_offset = STRUCT_OFFSET(XPV, xpv_cur)
1388 - STRUCT_OFFSET(xpv_allocated, xpv_cur);
1389 old_body_length = STRUCT_OFFSET(XPV, xpv_len)
1390 + sizeof (((XPV*)SvANY(sv))->xpv_len)
1394 else if (mt == SVt_NV)
1398 old_body_arena = (void **) &PL_xpviv_root;
1399 old_body_offset = STRUCT_OFFSET(XPVIV, xpv_cur)
1400 - STRUCT_OFFSET(xpviv_allocated, xpv_cur);
1401 old_body_length = STRUCT_OFFSET(XPVIV, xiv_u)
1402 + sizeof (((XPVIV*)SvANY(sv))->xiv_u)
1406 old_body_arena = (void **) &PL_xpvnv_root;
1407 old_body_length = STRUCT_OFFSET(XPVNV, xiv_u)
1408 + sizeof (((XPVNV*)SvANY(sv))->xiv_u);
1409 #ifndef NV_ZERO_IS_ALLBITS_ZERO
1414 /* Because the XPVMG of PL_mess_sv isn't allocated from the arena,
1415 there's no way that it can be safely upgraded, because perl.c
1416 expects to Safefree(SvANY(PL_mess_sv)) */
1417 assert(sv != PL_mess_sv);
1418 /* This flag bit is used to mean other things in other scalar types.
1419 Given that it only has meaning inside the pad, it shouldn't be set
1420 on anything that can get upgraded. */
1421 assert((SvFLAGS(sv) & SVpad_TYPED) == 0);
1422 old_body_arena = (void **) &PL_xpvmg_root;
1423 old_body_length = STRUCT_OFFSET(XPVMG, xmg_stash)
1424 + sizeof (((XPVMG*)SvANY(sv))->xmg_stash);
1425 #ifndef NV_ZERO_IS_ALLBITS_ZERO
1430 Perl_croak(aTHX_ "Can't upgrade that kind of scalar");
1433 SvFLAGS(sv) &= ~SVTYPEMASK;
1438 Perl_croak(aTHX_ "Can't upgrade to undef");
1440 assert(old_type == SVt_NULL);
1441 SvANY(sv) = (XPVIV*)((char*)&(sv->sv_u.svu_iv) - STRUCT_OFFSET(XPVIV, xiv_iv));
1445 assert(old_type == SVt_NULL);
1446 SvANY(sv) = new_XNV();
1450 assert(old_type == SVt_NULL);
1451 SvANY(sv) = &sv->sv_u.svu_rv;
1455 SvANY(sv) = new_XPVHV();
1458 HvTOTALKEYS(sv) = 0;
1463 SvANY(sv) = new_XPVAV();
1470 /* SVt_NULL isn't the only thing upgraded to AV or HV.
1471 The target created by newSVrv also is, and it can have magic.
1472 However, it never has SvPVX set.
1474 if (old_type >= SVt_RV) {
1475 assert(SvPVX_const(sv) == 0);
1478 /* Could put this in the else clause below, as PVMG must have SvPVX
1479 0 already (the assertion above) */
1480 SvPV_set(sv, (char*)0);
1482 if (old_type >= SVt_PVMG) {
1483 SvMAGIC_set(sv, ((XPVMG*)old_body)->xmg_magic);
1484 SvSTASH_set(sv, ((XPVMG*)old_body)->xmg_stash);
1492 new_body = new_XPVIO();
1493 new_body_length = sizeof(XPVIO);
1496 new_body = new_XPVFM();
1497 new_body_length = sizeof(XPVFM);
1501 new_body_length = sizeof(XPVBM);
1502 new_body_arena = (void **) &PL_xpvbm_root;
1503 new_body_arenaroot = (void **) &PL_xpvbm_arenaroot;
1506 new_body_length = sizeof(XPVGV);
1507 new_body_arena = (void **) &PL_xpvgv_root;
1508 new_body_arenaroot = (void **) &PL_xpvgv_arenaroot;
1511 new_body_length = sizeof(XPVCV);
1512 new_body_arena = (void **) &PL_xpvcv_root;
1513 new_body_arenaroot = (void **) &PL_xpvcv_arenaroot;
1516 new_body_length = sizeof(XPVLV);
1517 new_body_arena = (void **) &PL_xpvlv_root;
1518 new_body_arenaroot = (void **) &PL_xpvlv_arenaroot;
1521 new_body_length = sizeof(XPVMG);
1522 new_body_arena = (void **) &PL_xpvmg_root;
1523 new_body_arenaroot = (void **) &PL_xpvmg_arenaroot;
1526 new_body_length = sizeof(XPVNV);
1527 new_body_arena = (void **) &PL_xpvnv_root;
1528 new_body_arenaroot = (void **) &PL_xpvnv_arenaroot;
1531 new_body_offset = STRUCT_OFFSET(XPVIV, xpv_cur)
1532 - STRUCT_OFFSET(xpviv_allocated, xpv_cur);
1533 new_body_length = sizeof(XPVIV) - new_body_offset;
1534 new_body_arena = (void **) &PL_xpviv_root;
1535 new_body_arenaroot = (void **) &PL_xpviv_arenaroot;
1536 /* XXX Is this still needed? Was it ever needed? Surely as there is
1537 no route from NV to PVIV, NOK can never be true */
1541 goto new_body_no_NV;
1543 new_body_offset = STRUCT_OFFSET(XPV, xpv_cur)
1544 - STRUCT_OFFSET(xpv_allocated, xpv_cur);
1545 new_body_length = sizeof(XPV) - new_body_offset;
1546 new_body_arena = (void **) &PL_xpv_root;
1547 new_body_arenaroot = (void **) &PL_xpv_arenaroot;
1549 /* PV and PVIV don't have an NV slot. */
1550 #ifndef NV_ZERO_IS_ALLBITS_ZERO
1555 assert(new_body_length);
1557 /* This points to the start of the allocated area. */
1558 new_body_inline(new_body, new_body_arenaroot, new_body_arena,
1561 /* We always allocated the full length item with PURIFY */
1562 new_body_length += new_body_offset;
1563 new_body_offset = 0;
1564 new_body = my_safemalloc(new_body_length);
1568 Zero(new_body, new_body_length, char);
1569 new_body = ((char *)new_body) - new_body_offset;
1570 SvANY(sv) = new_body;
1572 if (old_body_length) {
1573 Copy((char *)old_body + old_body_offset,
1574 (char *)new_body + old_body_offset,
1575 old_body_length, char);
1578 #ifndef NV_ZERO_IS_ALLBITS_ZERO
1584 IoPAGE_LEN(sv) = 60;
1585 if (old_type < SVt_RV)
1589 Perl_croak(aTHX_ "panic: sv_upgrade to unknown type %lu", mt);
1593 if (old_body_arena) {
1595 my_safefree(old_body);
1597 del_body((void*)((char*)old_body + old_body_offset),
1604 =for apidoc sv_backoff
1606 Remove any string offset. You should normally use the C<SvOOK_off> macro
1613 Perl_sv_backoff(pTHX_ register SV *sv)
1616 assert(SvTYPE(sv) != SVt_PVHV);
1617 assert(SvTYPE(sv) != SVt_PVAV);
1619 const char * const s = SvPVX_const(sv);
1620 SvLEN_set(sv, SvLEN(sv) + SvIVX(sv));
1621 SvPV_set(sv, SvPVX(sv) - SvIVX(sv));
1623 Move(s, SvPVX(sv), SvCUR(sv)+1, char);
1625 SvFLAGS(sv) &= ~SVf_OOK;
1632 Expands the character buffer in the SV. If necessary, uses C<sv_unref> and
1633 upgrades the SV to C<SVt_PV>. Returns a pointer to the character buffer.
1634 Use the C<SvGROW> wrapper instead.
1640 Perl_sv_grow(pTHX_ register SV *sv, register STRLEN newlen)
1644 #ifdef HAS_64K_LIMIT
1645 if (newlen >= 0x10000) {
1646 PerlIO_printf(Perl_debug_log,
1647 "Allocation too large: %"UVxf"\n", (UV)newlen);
1650 #endif /* HAS_64K_LIMIT */
1653 if (SvTYPE(sv) < SVt_PV) {
1654 sv_upgrade(sv, SVt_PV);
1655 s = SvPVX_mutable(sv);
1657 else if (SvOOK(sv)) { /* pv is offset? */
1659 s = SvPVX_mutable(sv);
1660 if (newlen > SvLEN(sv))
1661 newlen += 10 * (newlen - SvCUR(sv)); /* avoid copy each time */
1662 #ifdef HAS_64K_LIMIT
1663 if (newlen >= 0x10000)
1668 s = SvPVX_mutable(sv);
1670 if (newlen > SvLEN(sv)) { /* need more room? */
1671 newlen = PERL_STRLEN_ROUNDUP(newlen);
1672 if (SvLEN(sv) && s) {
1674 const STRLEN l = malloced_size((void*)SvPVX_const(sv));
1680 s = saferealloc(s, newlen);
1683 s = safemalloc(newlen);
1684 if (SvPVX_const(sv) && SvCUR(sv)) {
1685 Move(SvPVX_const(sv), s, (newlen < SvCUR(sv)) ? newlen : SvCUR(sv), char);
1689 SvLEN_set(sv, newlen);
1695 =for apidoc sv_setiv
1697 Copies an integer into the given SV, upgrading first if necessary.
1698 Does not handle 'set' magic. See also C<sv_setiv_mg>.
1704 Perl_sv_setiv(pTHX_ register SV *sv, IV i)
1706 SV_CHECK_THINKFIRST_COW_DROP(sv);
1707 switch (SvTYPE(sv)) {
1709 sv_upgrade(sv, SVt_IV);
1712 sv_upgrade(sv, SVt_PVNV);
1716 sv_upgrade(sv, SVt_PVIV);
1725 Perl_croak(aTHX_ "Can't coerce %s to integer in %s", sv_reftype(sv,0),
1728 (void)SvIOK_only(sv); /* validate number */
1734 =for apidoc sv_setiv_mg
1736 Like C<sv_setiv>, but also handles 'set' magic.
1742 Perl_sv_setiv_mg(pTHX_ register SV *sv, IV i)
1749 =for apidoc sv_setuv
1751 Copies an unsigned integer into the given SV, upgrading first if necessary.
1752 Does not handle 'set' magic. See also C<sv_setuv_mg>.
1758 Perl_sv_setuv(pTHX_ register SV *sv, UV u)
1760 /* With these two if statements:
1761 u=1.49 s=0.52 cu=72.49 cs=10.64 scripts=270 tests=20865
1764 u=1.35 s=0.47 cu=73.45 cs=11.43 scripts=270 tests=20865
1766 If you wish to remove them, please benchmark to see what the effect is
1768 if (u <= (UV)IV_MAX) {
1769 sv_setiv(sv, (IV)u);
1778 =for apidoc sv_setuv_mg
1780 Like C<sv_setuv>, but also handles 'set' magic.
1786 Perl_sv_setuv_mg(pTHX_ register SV *sv, UV u)
1795 =for apidoc sv_setnv
1797 Copies a double into the given SV, upgrading first if necessary.
1798 Does not handle 'set' magic. See also C<sv_setnv_mg>.
1804 Perl_sv_setnv(pTHX_ register SV *sv, NV num)
1806 SV_CHECK_THINKFIRST_COW_DROP(sv);
1807 switch (SvTYPE(sv)) {
1810 sv_upgrade(sv, SVt_NV);
1815 sv_upgrade(sv, SVt_PVNV);
1824 Perl_croak(aTHX_ "Can't coerce %s to number in %s", sv_reftype(sv,0),
1828 (void)SvNOK_only(sv); /* validate number */
1833 =for apidoc sv_setnv_mg
1835 Like C<sv_setnv>, but also handles 'set' magic.
1841 Perl_sv_setnv_mg(pTHX_ register SV *sv, NV num)
1847 /* Print an "isn't numeric" warning, using a cleaned-up,
1848 * printable version of the offending string
1852 S_not_a_number(pTHX_ SV *sv)
1859 dsv = sv_2mortal(newSVpvn("", 0));
1860 pv = sv_uni_display(dsv, sv, 10, 0);
1863 char *limit = tmpbuf + sizeof(tmpbuf) - 8;
1864 /* each *s can expand to 4 chars + "...\0",
1865 i.e. need room for 8 chars */
1867 const char *s, *end;
1868 for (s = SvPVX_const(sv), end = s + SvCUR(sv); s < end && d < limit;
1871 if (ch & 128 && !isPRINT_LC(ch)) {
1880 else if (ch == '\r') {
1884 else if (ch == '\f') {
1888 else if (ch == '\\') {
1892 else if (ch == '\0') {
1896 else if (isPRINT_LC(ch))
1913 Perl_warner(aTHX_ packWARN(WARN_NUMERIC),
1914 "Argument \"%s\" isn't numeric in %s", pv,
1917 Perl_warner(aTHX_ packWARN(WARN_NUMERIC),
1918 "Argument \"%s\" isn't numeric", pv);
1922 =for apidoc looks_like_number
1924 Test if the content of an SV looks like a number (or is a number).
1925 C<Inf> and C<Infinity> are treated as numbers (so will not issue a
1926 non-numeric warning), even if your atof() doesn't grok them.
1932 Perl_looks_like_number(pTHX_ SV *sv)
1934 register const char *sbegin;
1938 sbegin = SvPVX_const(sv);
1941 else if (SvPOKp(sv))
1942 sbegin = SvPV_const(sv, len);
1944 return SvFLAGS(sv) & (SVf_NOK|SVp_NOK|SVf_IOK|SVp_IOK);
1945 return grok_number(sbegin, len, NULL);
1948 /* Actually, ISO C leaves conversion of UV to IV undefined, but
1949 until proven guilty, assume that things are not that bad... */
1954 As 64 bit platforms often have an NV that doesn't preserve all bits of
1955 an IV (an assumption perl has been based on to date) it becomes necessary
1956 to remove the assumption that the NV always carries enough precision to
1957 recreate the IV whenever needed, and that the NV is the canonical form.
1958 Instead, IV/UV and NV need to be given equal rights. So as to not lose
1959 precision as a side effect of conversion (which would lead to insanity
1960 and the dragon(s) in t/op/numconvert.t getting very angry) the intent is
1961 1) to distinguish between IV/UV/NV slots that have cached a valid
1962 conversion where precision was lost and IV/UV/NV slots that have a
1963 valid conversion which has lost no precision
1964 2) to ensure that if a numeric conversion to one form is requested that
1965 would lose precision, the precise conversion (or differently
1966 imprecise conversion) is also performed and cached, to prevent
1967 requests for different numeric formats on the same SV causing
1968 lossy conversion chains. (lossless conversion chains are perfectly
1973 SvIOKp is true if the IV slot contains a valid value
1974 SvIOK is true only if the IV value is accurate (UV if SvIOK_UV true)
1975 SvNOKp is true if the NV slot contains a valid value
1976 SvNOK is true only if the NV value is accurate
1979 while converting from PV to NV, check to see if converting that NV to an
1980 IV(or UV) would lose accuracy over a direct conversion from PV to
1981 IV(or UV). If it would, cache both conversions, return NV, but mark
1982 SV as IOK NOKp (ie not NOK).
1984 While converting from PV to IV, check to see if converting that IV to an
1985 NV would lose accuracy over a direct conversion from PV to NV. If it
1986 would, cache both conversions, flag similarly.
1988 Before, the SV value "3.2" could become NV=3.2 IV=3 NOK, IOK quite
1989 correctly because if IV & NV were set NV *always* overruled.
1990 Now, "3.2" will become NV=3.2 IV=3 NOK, IOKp, because the flag's meaning
1991 changes - now IV and NV together means that the two are interchangeable:
1992 SvIVX == (IV) SvNVX && SvNVX == (NV) SvIVX;
1994 The benefit of this is that operations such as pp_add know that if
1995 SvIOK is true for both left and right operands, then integer addition
1996 can be used instead of floating point (for cases where the result won't
1997 overflow). Before, floating point was always used, which could lead to
1998 loss of precision compared with integer addition.
2000 * making IV and NV equal status should make maths accurate on 64 bit
2002 * may speed up maths somewhat if pp_add and friends start to use
2003 integers when possible instead of fp. (Hopefully the overhead in
2004 looking for SvIOK and checking for overflow will not outweigh the
2005 fp to integer speedup)
2006 * will slow down integer operations (callers of SvIV) on "inaccurate"
2007 values, as the change from SvIOK to SvIOKp will cause a call into
2008 sv_2iv each time rather than a macro access direct to the IV slot
2009 * should speed up number->string conversion on integers as IV is
2010 favoured when IV and NV are equally accurate
2012 ####################################################################
2013 You had better be using SvIOK_notUV if you want an IV for arithmetic:
2014 SvIOK is true if (IV or UV), so you might be getting (IV)SvUV.
2015 On the other hand, SvUOK is true iff UV.
2016 ####################################################################
2018 Your mileage will vary depending your CPU's relative fp to integer
2022 #ifndef NV_PRESERVES_UV
2023 # define IS_NUMBER_UNDERFLOW_IV 1
2024 # define IS_NUMBER_UNDERFLOW_UV 2
2025 # define IS_NUMBER_IV_AND_UV 2
2026 # define IS_NUMBER_OVERFLOW_IV 4
2027 # define IS_NUMBER_OVERFLOW_UV 5
2029 /* sv_2iuv_non_preserve(): private routine for use by sv_2iv() and sv_2uv() */
2031 /* For sv_2nv these three cases are "SvNOK and don't bother casting" */
2033 S_sv_2iuv_non_preserve(pTHX_ register SV *sv, I32 numtype)
2035 DEBUG_c(PerlIO_printf(Perl_debug_log,"sv_2iuv_non '%s', IV=0x%"UVxf" NV=%"NVgf" inttype=%"UVXf"\n", SvPVX_const(sv), SvIVX(sv), SvNVX(sv), (UV)numtype));
2036 if (SvNVX(sv) < (NV)IV_MIN) {
2037 (void)SvIOKp_on(sv);
2039 SvIV_set(sv, IV_MIN);
2040 return IS_NUMBER_UNDERFLOW_IV;
2042 if (SvNVX(sv) > (NV)UV_MAX) {
2043 (void)SvIOKp_on(sv);
2046 SvUV_set(sv, UV_MAX);
2047 return IS_NUMBER_OVERFLOW_UV;
2049 (void)SvIOKp_on(sv);
2051 /* Can't use strtol etc to convert this string. (See truth table in
2053 if (SvNVX(sv) <= (UV)IV_MAX) {
2054 SvIV_set(sv, I_V(SvNVX(sv)));
2055 if ((NV)(SvIVX(sv)) == SvNVX(sv)) {
2056 SvIOK_on(sv); /* Integer is precise. NOK, IOK */
2058 /* Integer is imprecise. NOK, IOKp */
2060 return SvNVX(sv) < 0 ? IS_NUMBER_UNDERFLOW_UV : IS_NUMBER_IV_AND_UV;
2063 SvUV_set(sv, U_V(SvNVX(sv)));
2064 if ((NV)(SvUVX(sv)) == SvNVX(sv)) {
2065 if (SvUVX(sv) == UV_MAX) {
2066 /* As we know that NVs don't preserve UVs, UV_MAX cannot
2067 possibly be preserved by NV. Hence, it must be overflow.
2069 return IS_NUMBER_OVERFLOW_UV;
2071 SvIOK_on(sv); /* Integer is precise. NOK, UOK */
2073 /* Integer is imprecise. NOK, IOKp */
2075 return IS_NUMBER_OVERFLOW_IV;
2077 #endif /* !NV_PRESERVES_UV*/
2079 /* sv_2iv() is now a macro using Perl_sv_2iv_flags();
2080 * this function provided for binary compatibility only
2084 Perl_sv_2iv(pTHX_ register SV *sv)
2086 return sv_2iv_flags(sv, SV_GMAGIC);
2090 =for apidoc sv_2iv_flags
2092 Return the integer value of an SV, doing any necessary string
2093 conversion. If flags includes SV_GMAGIC, does an mg_get() first.
2094 Normally used via the C<SvIV(sv)> and C<SvIVx(sv)> macros.
2100 Perl_sv_2iv_flags(pTHX_ register SV *sv, I32 flags)
2104 if (SvGMAGICAL(sv)) {
2105 if (flags & SV_GMAGIC)
2110 return I_V(SvNVX(sv));
2112 if (SvPOKp(sv) && SvLEN(sv))
2115 if (!(SvFLAGS(sv) & SVs_PADTMP)) {
2116 if (!PL_localizing && ckWARN(WARN_UNINITIALIZED))
2122 if (SvTHINKFIRST(sv)) {
2125 if (SvAMAGIC(sv) && (tmpstr=AMG_CALLun(sv,numer)) &&
2126 (!SvROK(tmpstr) || (SvRV(tmpstr) != SvRV(sv))))
2127 return SvIV(tmpstr);
2128 return PTR2IV(SvRV(sv));
2131 sv_force_normal_flags(sv, 0);
2133 if (SvREADONLY(sv) && !SvOK(sv)) {
2134 if (ckWARN(WARN_UNINITIALIZED))
2141 return (IV)(SvUVX(sv));
2148 /* erm. not sure. *should* never get NOKp (without NOK) from sv_2nv
2149 * without also getting a cached IV/UV from it at the same time
2150 * (ie PV->NV conversion should detect loss of accuracy and cache
2151 * IV or UV at same time to avoid this. NWC */
2153 if (SvTYPE(sv) == SVt_NV)
2154 sv_upgrade(sv, SVt_PVNV);
2156 (void)SvIOKp_on(sv); /* Must do this first, to clear any SvOOK */
2157 /* < not <= as for NV doesn't preserve UV, ((NV)IV_MAX+1) will almost
2158 certainly cast into the IV range at IV_MAX, whereas the correct
2159 answer is the UV IV_MAX +1. Hence < ensures that dodgy boundary
2161 if (SvNVX(sv) < (NV)IV_MAX + 0.5) {
2162 SvIV_set(sv, I_V(SvNVX(sv)));
2163 if (SvNVX(sv) == (NV) SvIVX(sv)
2164 #ifndef NV_PRESERVES_UV
2165 && (((UV)1 << NV_PRESERVES_UV_BITS) >
2166 (UV)(SvIVX(sv) > 0 ? SvIVX(sv) : -SvIVX(sv)))
2167 /* Don't flag it as "accurately an integer" if the number
2168 came from a (by definition imprecise) NV operation, and
2169 we're outside the range of NV integer precision */
2172 SvIOK_on(sv); /* Can this go wrong with rounding? NWC */
2173 DEBUG_c(PerlIO_printf(Perl_debug_log,
2174 "0x%"UVxf" iv(%"NVgf" => %"IVdf") (precise)\n",
2180 /* IV not precise. No need to convert from PV, as NV
2181 conversion would already have cached IV if it detected
2182 that PV->IV would be better than PV->NV->IV
2183 flags already correct - don't set public IOK. */
2184 DEBUG_c(PerlIO_printf(Perl_debug_log,
2185 "0x%"UVxf" iv(%"NVgf" => %"IVdf") (imprecise)\n",
2190 /* Can the above go wrong if SvIVX == IV_MIN and SvNVX < IV_MIN,
2191 but the cast (NV)IV_MIN rounds to a the value less (more
2192 negative) than IV_MIN which happens to be equal to SvNVX ??
2193 Analogous to 0xFFFFFFFFFFFFFFFF rounding up to NV (2**64) and
2194 NV rounding back to 0xFFFFFFFFFFFFFFFF, so UVX == UV(NVX) and
2195 (NV)UVX == NVX are both true, but the values differ. :-(
2196 Hopefully for 2s complement IV_MIN is something like
2197 0x8000000000000000 which will be exact. NWC */
2200 SvUV_set(sv, U_V(SvNVX(sv)));
2202 (SvNVX(sv) == (NV) SvUVX(sv))
2203 #ifndef NV_PRESERVES_UV
2204 /* Make sure it's not 0xFFFFFFFFFFFFFFFF */
2205 /*&& (SvUVX(sv) != UV_MAX) irrelevant with code below */
2206 && (((UV)1 << NV_PRESERVES_UV_BITS) > SvUVX(sv))
2207 /* Don't flag it as "accurately an integer" if the number
2208 came from a (by definition imprecise) NV operation, and
2209 we're outside the range of NV integer precision */
2215 DEBUG_c(PerlIO_printf(Perl_debug_log,
2216 "0x%"UVxf" 2iv(%"UVuf" => %"IVdf") (as unsigned)\n",
2220 return (IV)SvUVX(sv);
2223 else if (SvPOKp(sv) && SvLEN(sv)) {
2225 const int numtype = grok_number(SvPVX_const(sv), SvCUR(sv), &value);
2226 /* We want to avoid a possible problem when we cache an IV which
2227 may be later translated to an NV, and the resulting NV is not
2228 the same as the direct translation of the initial string
2229 (eg 123.456 can shortcut to the IV 123 with atol(), but we must
2230 be careful to ensure that the value with the .456 is around if the
2231 NV value is requested in the future).
2233 This means that if we cache such an IV, we need to cache the
2234 NV as well. Moreover, we trade speed for space, and do not
2235 cache the NV if we are sure it's not needed.
2238 /* SVt_PVNV is one higher than SVt_PVIV, hence this order */
2239 if ((numtype & (IS_NUMBER_IN_UV | IS_NUMBER_NOT_INT))
2240 == IS_NUMBER_IN_UV) {
2241 /* It's definitely an integer, only upgrade to PVIV */
2242 if (SvTYPE(sv) < SVt_PVIV)
2243 sv_upgrade(sv, SVt_PVIV);
2245 } else if (SvTYPE(sv) < SVt_PVNV)
2246 sv_upgrade(sv, SVt_PVNV);
2248 /* If NV preserves UV then we only use the UV value if we know that
2249 we aren't going to call atof() below. If NVs don't preserve UVs
2250 then the value returned may have more precision than atof() will
2251 return, even though value isn't perfectly accurate. */
2252 if ((numtype & (IS_NUMBER_IN_UV
2253 #ifdef NV_PRESERVES_UV
2256 )) == IS_NUMBER_IN_UV) {
2257 /* This won't turn off the public IOK flag if it was set above */
2258 (void)SvIOKp_on(sv);
2260 if (!(numtype & IS_NUMBER_NEG)) {
2262 if (value <= (UV)IV_MAX) {
2263 SvIV_set(sv, (IV)value);
2265 SvUV_set(sv, value);
2269 /* 2s complement assumption */
2270 if (value <= (UV)IV_MIN) {
2271 SvIV_set(sv, -(IV)value);
2273 /* Too negative for an IV. This is a double upgrade, but
2274 I'm assuming it will be rare. */
2275 if (SvTYPE(sv) < SVt_PVNV)
2276 sv_upgrade(sv, SVt_PVNV);
2280 SvNV_set(sv, -(NV)value);
2281 SvIV_set(sv, IV_MIN);
2285 /* For !NV_PRESERVES_UV and IS_NUMBER_IN_UV and IS_NUMBER_NOT_INT we
2286 will be in the previous block to set the IV slot, and the next
2287 block to set the NV slot. So no else here. */
2289 if ((numtype & (IS_NUMBER_IN_UV | IS_NUMBER_NOT_INT))
2290 != IS_NUMBER_IN_UV) {
2291 /* It wasn't an (integer that doesn't overflow the UV). */
2292 SvNV_set(sv, Atof(SvPVX_const(sv)));
2294 if (! numtype && ckWARN(WARN_NUMERIC))
2297 #if defined(USE_LONG_DOUBLE)
2298 DEBUG_c(PerlIO_printf(Perl_debug_log, "0x%"UVxf" 2iv(%" PERL_PRIgldbl ")\n",
2299 PTR2UV(sv), SvNVX(sv)));
2301 DEBUG_c(PerlIO_printf(Perl_debug_log, "0x%"UVxf" 2iv(%"NVgf")\n",
2302 PTR2UV(sv), SvNVX(sv)));
2306 #ifdef NV_PRESERVES_UV
2307 (void)SvIOKp_on(sv);
2309 if (SvNVX(sv) < (NV)IV_MAX + 0.5) {
2310 SvIV_set(sv, I_V(SvNVX(sv)));
2311 if ((NV)(SvIVX(sv)) == SvNVX(sv)) {
2314 /* Integer is imprecise. NOK, IOKp */
2316 /* UV will not work better than IV */
2318 if (SvNVX(sv) > (NV)UV_MAX) {
2320 /* Integer is inaccurate. NOK, IOKp, is UV */
2321 SvUV_set(sv, UV_MAX);
2324 SvUV_set(sv, U_V(SvNVX(sv)));
2325 /* 0xFFFFFFFFFFFFFFFF not an issue in here */
2326 if ((NV)(SvUVX(sv)) == SvNVX(sv)) {
2330 /* Integer is imprecise. NOK, IOKp, is UV */
2336 #else /* NV_PRESERVES_UV */
2337 if ((numtype & (IS_NUMBER_IN_UV | IS_NUMBER_NOT_INT))
2338 == (IS_NUMBER_IN_UV | IS_NUMBER_NOT_INT)) {
2339 /* The IV slot will have been set from value returned by
2340 grok_number above. The NV slot has just been set using
2343 assert (SvIOKp(sv));
2345 if (((UV)1 << NV_PRESERVES_UV_BITS) >
2346 U_V(SvNVX(sv) > 0 ? SvNVX(sv) : -SvNVX(sv))) {
2347 /* Small enough to preserve all bits. */
2348 (void)SvIOKp_on(sv);
2350 SvIV_set(sv, I_V(SvNVX(sv)));
2351 if ((NV)(SvIVX(sv)) == SvNVX(sv))
2353 /* Assumption: first non-preserved integer is < IV_MAX,
2354 this NV is in the preserved range, therefore: */
2355 if (!(U_V(SvNVX(sv) > 0 ? SvNVX(sv) : -SvNVX(sv))
2357 Perl_croak(aTHX_ "sv_2iv assumed (U_V(fabs((double)SvNVX(sv))) < (UV)IV_MAX) but SvNVX(sv)=%"NVgf" U_V is 0x%"UVxf", IV_MAX is 0x%"UVxf"\n", SvNVX(sv), U_V(SvNVX(sv)), (UV)IV_MAX);
2361 0 0 already failed to read UV.
2362 0 1 already failed to read UV.
2363 1 0 you won't get here in this case. IV/UV
2364 slot set, public IOK, Atof() unneeded.
2365 1 1 already read UV.
2366 so there's no point in sv_2iuv_non_preserve() attempting
2367 to use atol, strtol, strtoul etc. */
2368 if (sv_2iuv_non_preserve (sv, numtype)
2369 >= IS_NUMBER_OVERFLOW_IV)
2373 #endif /* NV_PRESERVES_UV */
2376 if (!PL_localizing && !(SvFLAGS(sv) & SVs_PADTMP) && ckWARN(WARN_UNINITIALIZED))
2378 if (SvTYPE(sv) < SVt_IV)
2379 /* Typically the caller expects that sv_any is not NULL now. */
2380 sv_upgrade(sv, SVt_IV);
2383 DEBUG_c(PerlIO_printf(Perl_debug_log, "0x%"UVxf" 2iv(%"IVdf")\n",
2384 PTR2UV(sv),SvIVX(sv)));
2385 return SvIsUV(sv) ? (IV)SvUVX(sv) : SvIVX(sv);
2388 /* sv_2uv() is now a macro using Perl_sv_2uv_flags();
2389 * this function provided for binary compatibility only
2393 Perl_sv_2uv(pTHX_ register SV *sv)
2395 return sv_2uv_flags(sv, SV_GMAGIC);
2399 =for apidoc sv_2uv_flags
2401 Return the unsigned integer value of an SV, doing any necessary string
2402 conversion. If flags includes SV_GMAGIC, does an mg_get() first.
2403 Normally used via the C<SvUV(sv)> and C<SvUVx(sv)> macros.
2409 Perl_sv_2uv_flags(pTHX_ register SV *sv, I32 flags)
2413 if (SvGMAGICAL(sv)) {
2414 if (flags & SV_GMAGIC)
2419 return U_V(SvNVX(sv));
2420 if (SvPOKp(sv) && SvLEN(sv))
2423 if (!(SvFLAGS(sv) & SVs_PADTMP)) {
2424 if (!PL_localizing && ckWARN(WARN_UNINITIALIZED))
2430 if (SvTHINKFIRST(sv)) {
2433 if (SvAMAGIC(sv) && (tmpstr=AMG_CALLun(sv,numer)) &&
2434 (!SvROK(tmpstr) || (SvRV(tmpstr) != SvRV(sv))))
2435 return SvUV(tmpstr);
2436 return PTR2UV(SvRV(sv));
2439 sv_force_normal_flags(sv, 0);
2441 if (SvREADONLY(sv) && !SvOK(sv)) {
2442 if (ckWARN(WARN_UNINITIALIZED))
2452 return (UV)SvIVX(sv);
2456 /* erm. not sure. *should* never get NOKp (without NOK) from sv_2nv
2457 * without also getting a cached IV/UV from it at the same time
2458 * (ie PV->NV conversion should detect loss of accuracy and cache
2459 * IV or UV at same time to avoid this. */
2460 /* IV-over-UV optimisation - choose to cache IV if possible */
2462 if (SvTYPE(sv) == SVt_NV)
2463 sv_upgrade(sv, SVt_PVNV);
2465 (void)SvIOKp_on(sv); /* Must do this first, to clear any SvOOK */
2466 if (SvNVX(sv) < (NV)IV_MAX + 0.5) {
2467 SvIV_set(sv, I_V(SvNVX(sv)));
2468 if (SvNVX(sv) == (NV) SvIVX(sv)
2469 #ifndef NV_PRESERVES_UV
2470 && (((UV)1 << NV_PRESERVES_UV_BITS) >
2471 (UV)(SvIVX(sv) > 0 ? SvIVX(sv) : -SvIVX(sv)))
2472 /* Don't flag it as "accurately an integer" if the number
2473 came from a (by definition imprecise) NV operation, and
2474 we're outside the range of NV integer precision */
2477 SvIOK_on(sv); /* Can this go wrong with rounding? NWC */
2478 DEBUG_c(PerlIO_printf(Perl_debug_log,
2479 "0x%"UVxf" uv(%"NVgf" => %"IVdf") (precise)\n",
2485 /* IV not precise. No need to convert from PV, as NV
2486 conversion would already have cached IV if it detected
2487 that PV->IV would be better than PV->NV->IV
2488 flags already correct - don't set public IOK. */
2489 DEBUG_c(PerlIO_printf(Perl_debug_log,
2490 "0x%"UVxf" uv(%"NVgf" => %"IVdf") (imprecise)\n",
2495 /* Can the above go wrong if SvIVX == IV_MIN and SvNVX < IV_MIN,
2496 but the cast (NV)IV_MIN rounds to a the value less (more
2497 negative) than IV_MIN which happens to be equal to SvNVX ??
2498 Analogous to 0xFFFFFFFFFFFFFFFF rounding up to NV (2**64) and
2499 NV rounding back to 0xFFFFFFFFFFFFFFFF, so UVX == UV(NVX) and
2500 (NV)UVX == NVX are both true, but the values differ. :-(
2501 Hopefully for 2s complement IV_MIN is something like
2502 0x8000000000000000 which will be exact. NWC */
2505 SvUV_set(sv, U_V(SvNVX(sv)));
2507 (SvNVX(sv) == (NV) SvUVX(sv))
2508 #ifndef NV_PRESERVES_UV
2509 /* Make sure it's not 0xFFFFFFFFFFFFFFFF */
2510 /*&& (SvUVX(sv) != UV_MAX) irrelevant with code below */
2511 && (((UV)1 << NV_PRESERVES_UV_BITS) > SvUVX(sv))
2512 /* Don't flag it as "accurately an integer" if the number
2513 came from a (by definition imprecise) NV operation, and
2514 we're outside the range of NV integer precision */
2519 DEBUG_c(PerlIO_printf(Perl_debug_log,
2520 "0x%"UVxf" 2uv(%"UVuf" => %"IVdf") (as unsigned)\n",
2526 else if (SvPOKp(sv) && SvLEN(sv)) {
2528 const int numtype = grok_number(SvPVX_const(sv), SvCUR(sv), &value);
2530 /* We want to avoid a possible problem when we cache a UV which
2531 may be later translated to an NV, and the resulting NV is not
2532 the translation of the initial data.
2534 This means that if we cache such a UV, we need to cache the
2535 NV as well. Moreover, we trade speed for space, and do not
2536 cache the NV if not needed.
2539 /* SVt_PVNV is one higher than SVt_PVIV, hence this order */
2540 if ((numtype & (IS_NUMBER_IN_UV | IS_NUMBER_NOT_INT))
2541 == IS_NUMBER_IN_UV) {
2542 /* It's definitely an integer, only upgrade to PVIV */
2543 if (SvTYPE(sv) < SVt_PVIV)
2544 sv_upgrade(sv, SVt_PVIV);
2546 } else if (SvTYPE(sv) < SVt_PVNV)
2547 sv_upgrade(sv, SVt_PVNV);
2549 /* If NV preserves UV then we only use the UV value if we know that
2550 we aren't going to call atof() below. If NVs don't preserve UVs
2551 then the value returned may have more precision than atof() will
2552 return, even though it isn't accurate. */
2553 if ((numtype & (IS_NUMBER_IN_UV
2554 #ifdef NV_PRESERVES_UV
2557 )) == IS_NUMBER_IN_UV) {
2558 /* This won't turn off the public IOK flag if it was set above */
2559 (void)SvIOKp_on(sv);
2561 if (!(numtype & IS_NUMBER_NEG)) {
2563 if (value <= (UV)IV_MAX) {
2564 SvIV_set(sv, (IV)value);
2566 /* it didn't overflow, and it was positive. */
2567 SvUV_set(sv, value);
2571 /* 2s complement assumption */
2572 if (value <= (UV)IV_MIN) {
2573 SvIV_set(sv, -(IV)value);
2575 /* Too negative for an IV. This is a double upgrade, but
2576 I'm assuming it will be rare. */
2577 if (SvTYPE(sv) < SVt_PVNV)
2578 sv_upgrade(sv, SVt_PVNV);
2582 SvNV_set(sv, -(NV)value);
2583 SvIV_set(sv, IV_MIN);
2588 if ((numtype & (IS_NUMBER_IN_UV | IS_NUMBER_NOT_INT))
2589 != IS_NUMBER_IN_UV) {
2590 /* It wasn't an integer, or it overflowed the UV. */
2591 SvNV_set(sv, Atof(SvPVX_const(sv)));
2593 if (! numtype && ckWARN(WARN_NUMERIC))
2596 #if defined(USE_LONG_DOUBLE)
2597 DEBUG_c(PerlIO_printf(Perl_debug_log, "0x%"UVxf" 2uv(%" PERL_PRIgldbl ")\n",
2598 PTR2UV(sv), SvNVX(sv)));
2600 DEBUG_c(PerlIO_printf(Perl_debug_log, "0x%"UVxf" 2uv(%"NVgf")\n",
2601 PTR2UV(sv), SvNVX(sv)));
2604 #ifdef NV_PRESERVES_UV
2605 (void)SvIOKp_on(sv);
2607 if (SvNVX(sv) < (NV)IV_MAX + 0.5) {
2608 SvIV_set(sv, I_V(SvNVX(sv)));
2609 if ((NV)(SvIVX(sv)) == SvNVX(sv)) {
2612 /* Integer is imprecise. NOK, IOKp */
2614 /* UV will not work better than IV */
2616 if (SvNVX(sv) > (NV)UV_MAX) {
2618 /* Integer is inaccurate. NOK, IOKp, is UV */
2619 SvUV_set(sv, UV_MAX);
2622 SvUV_set(sv, U_V(SvNVX(sv)));
2623 /* 0xFFFFFFFFFFFFFFFF not an issue in here, NVs
2624 NV preservse UV so can do correct comparison. */
2625 if ((NV)(SvUVX(sv)) == SvNVX(sv)) {
2629 /* Integer is imprecise. NOK, IOKp, is UV */
2634 #else /* NV_PRESERVES_UV */
2635 if ((numtype & (IS_NUMBER_IN_UV | IS_NUMBER_NOT_INT))
2636 == (IS_NUMBER_IN_UV | IS_NUMBER_NOT_INT)) {
2637 /* The UV slot will have been set from value returned by
2638 grok_number above. The NV slot has just been set using
2641 assert (SvIOKp(sv));
2643 if (((UV)1 << NV_PRESERVES_UV_BITS) >
2644 U_V(SvNVX(sv) > 0 ? SvNVX(sv) : -SvNVX(sv))) {
2645 /* Small enough to preserve all bits. */
2646 (void)SvIOKp_on(sv);
2648 SvIV_set(sv, I_V(SvNVX(sv)));
2649 if ((NV)(SvIVX(sv)) == SvNVX(sv))
2651 /* Assumption: first non-preserved integer is < IV_MAX,
2652 this NV is in the preserved range, therefore: */
2653 if (!(U_V(SvNVX(sv) > 0 ? SvNVX(sv) : -SvNVX(sv))
2655 Perl_croak(aTHX_ "sv_2uv assumed (U_V(fabs((double)SvNVX(sv))) < (UV)IV_MAX) but SvNVX(sv)=%"NVgf" U_V is 0x%"UVxf", IV_MAX is 0x%"UVxf"\n", SvNVX(sv), U_V(SvNVX(sv)), (UV)IV_MAX);
2658 sv_2iuv_non_preserve (sv, numtype);
2660 #endif /* NV_PRESERVES_UV */
2664 if (!(SvFLAGS(sv) & SVs_PADTMP)) {
2665 if (!PL_localizing && ckWARN(WARN_UNINITIALIZED))
2668 if (SvTYPE(sv) < SVt_IV)
2669 /* Typically the caller expects that sv_any is not NULL now. */
2670 sv_upgrade(sv, SVt_IV);
2674 DEBUG_c(PerlIO_printf(Perl_debug_log, "0x%"UVxf" 2uv(%"UVuf")\n",
2675 PTR2UV(sv),SvUVX(sv)));
2676 return SvIsUV(sv) ? SvUVX(sv) : (UV)SvIVX(sv);
2682 Return the num value of an SV, doing any necessary string or integer
2683 conversion, magic etc. Normally used via the C<SvNV(sv)> and C<SvNVx(sv)>
2690 Perl_sv_2nv(pTHX_ register SV *sv)
2694 if (SvGMAGICAL(sv)) {
2698 if (SvPOKp(sv) && SvLEN(sv)) {
2699 if (!SvIOKp(sv) && ckWARN(WARN_NUMERIC) &&
2700 !grok_number(SvPVX_const(sv), SvCUR(sv), NULL))
2702 return Atof(SvPVX_const(sv));
2706 return (NV)SvUVX(sv);
2708 return (NV)SvIVX(sv);
2711 if (!(SvFLAGS(sv) & SVs_PADTMP)) {
2712 if (!PL_localizing && ckWARN(WARN_UNINITIALIZED))
2718 if (SvTHINKFIRST(sv)) {
2721 if (SvAMAGIC(sv) && (tmpstr=AMG_CALLun(sv,numer)) &&
2722 (!SvROK(tmpstr) || (SvRV(tmpstr) != SvRV(sv))))
2723 return SvNV(tmpstr);
2724 return PTR2NV(SvRV(sv));
2727 sv_force_normal_flags(sv, 0);
2729 if (SvREADONLY(sv) && !SvOK(sv)) {
2730 if (ckWARN(WARN_UNINITIALIZED))
2735 if (SvTYPE(sv) < SVt_NV) {
2736 if (SvTYPE(sv) == SVt_IV)
2737 sv_upgrade(sv, SVt_PVNV);
2739 sv_upgrade(sv, SVt_NV);
2740 #ifdef USE_LONG_DOUBLE
2742 STORE_NUMERIC_LOCAL_SET_STANDARD();
2743 PerlIO_printf(Perl_debug_log,
2744 "0x%"UVxf" num(%" PERL_PRIgldbl ")\n",
2745 PTR2UV(sv), SvNVX(sv));
2746 RESTORE_NUMERIC_LOCAL();
2750 STORE_NUMERIC_LOCAL_SET_STANDARD();
2751 PerlIO_printf(Perl_debug_log, "0x%"UVxf" num(%"NVgf")\n",
2752 PTR2UV(sv), SvNVX(sv));
2753 RESTORE_NUMERIC_LOCAL();
2757 else if (SvTYPE(sv) < SVt_PVNV)
2758 sv_upgrade(sv, SVt_PVNV);
2763 SvNV_set(sv, SvIsUV(sv) ? (NV)SvUVX(sv) : (NV)SvIVX(sv));
2764 #ifdef NV_PRESERVES_UV
2767 /* Only set the public NV OK flag if this NV preserves the IV */
2768 /* Check it's not 0xFFFFFFFFFFFFFFFF */
2769 if (SvIsUV(sv) ? ((SvUVX(sv) != UV_MAX)&&(SvUVX(sv) == U_V(SvNVX(sv))))
2770 : (SvIVX(sv) == I_V(SvNVX(sv))))
2776 else if (SvPOKp(sv) && SvLEN(sv)) {
2778 const int numtype = grok_number(SvPVX_const(sv), SvCUR(sv), &value);
2779 if (!SvIOKp(sv) && !numtype && ckWARN(WARN_NUMERIC))
2781 #ifdef NV_PRESERVES_UV
2782 if ((numtype & (IS_NUMBER_IN_UV | IS_NUMBER_NOT_INT))
2783 == IS_NUMBER_IN_UV) {
2784 /* It's definitely an integer */
2785 SvNV_set(sv, (numtype & IS_NUMBER_NEG) ? -(NV)value : (NV)value);
2787 SvNV_set(sv, Atof(SvPVX_const(sv)));
2790 SvNV_set(sv, Atof(SvPVX_const(sv)));
2791 /* Only set the public NV OK flag if this NV preserves the value in
2792 the PV at least as well as an IV/UV would.
2793 Not sure how to do this 100% reliably. */
2794 /* if that shift count is out of range then Configure's test is
2795 wonky. We shouldn't be in here with NV_PRESERVES_UV_BITS ==
2797 if (((UV)1 << NV_PRESERVES_UV_BITS) >
2798 U_V(SvNVX(sv) > 0 ? SvNVX(sv) : -SvNVX(sv))) {
2799 SvNOK_on(sv); /* Definitely small enough to preserve all bits */
2800 } else if (!(numtype & IS_NUMBER_IN_UV)) {
2801 /* Can't use strtol etc to convert this string, so don't try.
2802 sv_2iv and sv_2uv will use the NV to convert, not the PV. */
2805 /* value has been set. It may not be precise. */
2806 if ((numtype & IS_NUMBER_NEG) && (value > (UV)IV_MIN)) {
2807 /* 2s complement assumption for (UV)IV_MIN */
2808 SvNOK_on(sv); /* Integer is too negative. */
2813 if (numtype & IS_NUMBER_NEG) {
2814 SvIV_set(sv, -(IV)value);
2815 } else if (value <= (UV)IV_MAX) {
2816 SvIV_set(sv, (IV)value);
2818 SvUV_set(sv, value);
2822 if (numtype & IS_NUMBER_NOT_INT) {
2823 /* I believe that even if the original PV had decimals,
2824 they are lost beyond the limit of the FP precision.
2825 However, neither is canonical, so both only get p
2826 flags. NWC, 2000/11/25 */
2827 /* Both already have p flags, so do nothing */
2829 const NV nv = SvNVX(sv);
2830 if (SvNVX(sv) < (NV)IV_MAX + 0.5) {
2831 if (SvIVX(sv) == I_V(nv)) {
2836 /* It had no "." so it must be integer. */
2839 /* between IV_MAX and NV(UV_MAX).
2840 Could be slightly > UV_MAX */
2842 if (numtype & IS_NUMBER_NOT_INT) {
2843 /* UV and NV both imprecise. */
2845 const UV nv_as_uv = U_V(nv);
2847 if (value == nv_as_uv && SvUVX(sv) != UV_MAX) {
2858 #endif /* NV_PRESERVES_UV */
2861 if (!PL_localizing && !(SvFLAGS(sv) & SVs_PADTMP) && ckWARN(WARN_UNINITIALIZED))
2863 if (SvTYPE(sv) < SVt_NV)
2864 /* Typically the caller expects that sv_any is not NULL now. */
2865 /* XXX Ilya implies that this is a bug in callers that assume this
2866 and ideally should be fixed. */
2867 sv_upgrade(sv, SVt_NV);
2870 #if defined(USE_LONG_DOUBLE)
2872 STORE_NUMERIC_LOCAL_SET_STANDARD();
2873 PerlIO_printf(Perl_debug_log, "0x%"UVxf" 2nv(%" PERL_PRIgldbl ")\n",
2874 PTR2UV(sv), SvNVX(sv));
2875 RESTORE_NUMERIC_LOCAL();
2879 STORE_NUMERIC_LOCAL_SET_STANDARD();
2880 PerlIO_printf(Perl_debug_log, "0x%"UVxf" 1nv(%"NVgf")\n",
2881 PTR2UV(sv), SvNVX(sv));
2882 RESTORE_NUMERIC_LOCAL();
2888 /* asIV(): extract an integer from the string value of an SV.
2889 * Caller must validate PVX */
2892 S_asIV(pTHX_ SV *sv)
2895 const int numtype = grok_number(SvPVX_const(sv), SvCUR(sv), &value);
2897 if ((numtype & (IS_NUMBER_IN_UV | IS_NUMBER_NOT_INT))
2898 == IS_NUMBER_IN_UV) {
2899 /* It's definitely an integer */
2900 if (numtype & IS_NUMBER_NEG) {
2901 if (value < (UV)IV_MIN)
2904 if (value < (UV)IV_MAX)
2909 if (ckWARN(WARN_NUMERIC))
2912 return I_V(Atof(SvPVX_const(sv)));
2915 /* asUV(): extract an unsigned integer from the string value of an SV
2916 * Caller must validate PVX */
2919 S_asUV(pTHX_ SV *sv)
2922 const int numtype = grok_number(SvPVX_const(sv), SvCUR(sv), &value);
2924 if ((numtype & (IS_NUMBER_IN_UV | IS_NUMBER_NOT_INT))
2925 == IS_NUMBER_IN_UV) {
2926 /* It's definitely an integer */
2927 if (!(numtype & IS_NUMBER_NEG))
2931 if (ckWARN(WARN_NUMERIC))
2934 return U_V(Atof(SvPVX_const(sv)));
2938 =for apidoc sv_2pv_nolen
2940 Like C<sv_2pv()>, but doesn't return the length too. You should usually
2941 use the macro wrapper C<SvPV_nolen(sv)> instead.
2946 Perl_sv_2pv_nolen(pTHX_ register SV *sv)
2948 return sv_2pv(sv, 0);
2951 /* uiv_2buf(): private routine for use by sv_2pv_flags(): print an IV or
2952 * UV as a string towards the end of buf, and return pointers to start and
2955 * We assume that buf is at least TYPE_CHARS(UV) long.
2959 S_uiv_2buf(char *buf, IV iv, UV uv, int is_uv, char **peob)
2961 char *ptr = buf + TYPE_CHARS(UV);
2975 *--ptr = '0' + (char)(uv % 10);
2983 /* sv_2pv() is now a macro using Perl_sv_2pv_flags();
2984 * this function provided for binary compatibility only
2988 Perl_sv_2pv(pTHX_ register SV *sv, STRLEN *lp)
2990 return sv_2pv_flags(sv, lp, SV_GMAGIC);
2994 =for apidoc sv_2pv_flags
2996 Returns a pointer to the string value of an SV, and sets *lp to its length.
2997 If flags includes SV_GMAGIC, does an mg_get() first. Coerces sv to a string
2999 Normally invoked via the C<SvPV_flags> macro. C<sv_2pv()> and C<sv_2pv_nomg>
3000 usually end up here too.
3006 Perl_sv_2pv_flags(pTHX_ register SV *sv, STRLEN *lp, I32 flags)
3011 char tbuf[64]; /* Must fit sprintf/Gconvert of longest IV/NV */
3012 char *tmpbuf = tbuf;
3019 if (SvGMAGICAL(sv)) {
3020 if (flags & SV_GMAGIC)
3025 if (flags & SV_MUTABLE_RETURN)
3026 return SvPVX_mutable(sv);
3027 if (flags & SV_CONST_RETURN)
3028 return (char *)SvPVX_const(sv);
3033 (void)sprintf(tmpbuf,"%"UVuf, (UV)SvUVX(sv));
3035 (void)sprintf(tmpbuf,"%"IVdf, (IV)SvIVX(sv));
3040 Gconvert(SvNVX(sv), NV_DIG, 0, tmpbuf);
3045 if (!(SvFLAGS(sv) & SVs_PADTMP)) {
3046 if (!PL_localizing && ckWARN(WARN_UNINITIALIZED))
3054 if (SvTHINKFIRST(sv)) {
3057 register const char *typestr;
3058 if (SvAMAGIC(sv) && (tmpstr=AMG_CALLun(sv,string)) &&
3059 (!SvROK(tmpstr) || (SvRV(tmpstr) != SvRV(sv)))) {
3061 /* char *pv = lp ? SvPV(tmpstr, *lp) : SvPV_nolen(tmpstr); */
3064 if ((SvFLAGS(tmpstr) & (SVf_POK)) == SVf_POK) {
3065 if (flags & SV_CONST_RETURN) {
3066 pv = (char *) SvPVX_const(tmpstr);
3068 pv = (flags & SV_MUTABLE_RETURN)
3069 ? SvPVX_mutable(tmpstr) : SvPVX(tmpstr);
3072 *lp = SvCUR(tmpstr);
3074 pv = sv_2pv_flags(tmpstr, lp, flags);
3085 typestr = "NULLREF";
3089 switch (SvTYPE(sv)) {
3091 if ( ((SvFLAGS(sv) &
3092 (SVs_OBJECT|SVf_OK|SVs_GMG|SVs_SMG|SVs_RMG))
3093 == (SVs_OBJECT|SVs_SMG))
3094 && (mg = mg_find(sv, PERL_MAGIC_qr))) {
3095 const regexp *re = (regexp *)mg->mg_obj;
3098 const char *fptr = "msix";
3103 char need_newline = 0;
3104 U16 reganch = (U16)((re->reganch & PMf_COMPILETIME) >> 12);
3106 while((ch = *fptr++)) {
3108 reflags[left++] = ch;
3111 reflags[right--] = ch;
3116 reflags[left] = '-';
3120 mg->mg_len = re->prelen + 4 + left;
3122 * If /x was used, we have to worry about a regex
3123 * ending with a comment later being embedded
3124 * within another regex. If so, we don't want this
3125 * regex's "commentization" to leak out to the
3126 * right part of the enclosing regex, we must cap
3127 * it with a newline.
3129 * So, if /x was used, we scan backwards from the
3130 * end of the regex. If we find a '#' before we
3131 * find a newline, we need to add a newline
3132 * ourself. If we find a '\n' first (or if we
3133 * don't find '#' or '\n'), we don't need to add
3134 * anything. -jfriedl
3136 if (PMf_EXTENDED & re->reganch)
3138 const char *endptr = re->precomp + re->prelen;
3139 while (endptr >= re->precomp)
3141 const char c = *(endptr--);
3143 break; /* don't need another */
3145 /* we end while in a comment, so we
3147 mg->mg_len++; /* save space for it */
3148 need_newline = 1; /* note to add it */
3154 Newx(mg->mg_ptr, mg->mg_len + 1 + left, char);
3155 Copy("(?", mg->mg_ptr, 2, char);
3156 Copy(reflags, mg->mg_ptr+2, left, char);
3157 Copy(":", mg->mg_ptr+left+2, 1, char);
3158 Copy(re->precomp, mg->mg_ptr+3+left, re->prelen, char);
3160 mg->mg_ptr[mg->mg_len - 2] = '\n';
3161 mg->mg_ptr[mg->mg_len - 1] = ')';
3162 mg->mg_ptr[mg->mg_len] = 0;
3164 PL_reginterp_cnt += re->program[0].next_off;
3166 if (re->reganch & ROPT_UTF8)
3182 case SVt_PVBM: typestr = SvROK(sv) ? "REF" : "SCALAR"; break;
3183 case SVt_PVLV: typestr = SvROK(sv) ? "REF"
3184 /* tied lvalues should appear to be
3185 * scalars for backwards compatitbility */
3186 : (LvTYPE(sv) == 't' || LvTYPE(sv) == 'T')
3187 ? "SCALAR" : "LVALUE"; break;
3188 case SVt_PVAV: typestr = "ARRAY"; break;
3189 case SVt_PVHV: typestr = "HASH"; break;
3190 case SVt_PVCV: typestr = "CODE"; break;
3191 case SVt_PVGV: typestr = "GLOB"; break;
3192 case SVt_PVFM: typestr = "FORMAT"; break;
3193 case SVt_PVIO: typestr = "IO"; break;
3194 default: typestr = "UNKNOWN"; break;
3198 const char *name = HvNAME_get(SvSTASH(sv));
3199 Perl_sv_setpvf(aTHX_ tsv, "%s=%s(0x%"UVxf")",
3200 name ? name : "__ANON__" , typestr, PTR2UV(sv));
3203 Perl_sv_setpvf(aTHX_ tsv, "%s(0x%"UVxf")", typestr, PTR2UV(sv));
3207 *lp = strlen(typestr);
3208 return (char *)typestr;
3210 if (SvREADONLY(sv) && !SvOK(sv)) {
3211 if (ckWARN(WARN_UNINITIALIZED))
3218 if (SvIOK(sv) || ((SvIOKp(sv) && !SvNOKp(sv)))) {
3219 /* I'm assuming that if both IV and NV are equally valid then
3220 converting the IV is going to be more efficient */
3221 const U32 isIOK = SvIOK(sv);
3222 const U32 isUIOK = SvIsUV(sv);
3223 char buf[TYPE_CHARS(UV)];
3226 if (SvTYPE(sv) < SVt_PVIV)
3227 sv_upgrade(sv, SVt_PVIV);
3229 ptr = uiv_2buf(buf, 0, SvUVX(sv), 1, &ebuf);
3231 ptr = uiv_2buf(buf, SvIVX(sv), 0, 0, &ebuf);
3232 /* inlined from sv_setpvn */
3233 SvGROW_mutable(sv, (STRLEN)(ebuf - ptr + 1));
3234 Move(ptr,SvPVX_mutable(sv),ebuf - ptr,char);
3235 SvCUR_set(sv, ebuf - ptr);
3245 else if (SvNOKp(sv)) {
3246 if (SvTYPE(sv) < SVt_PVNV)
3247 sv_upgrade(sv, SVt_PVNV);
3248 /* The +20 is pure guesswork. Configure test needed. --jhi */
3249 s = SvGROW_mutable(sv, NV_DIG + 20);
3250 olderrno = errno; /* some Xenix systems wipe out errno here */
3252 if (SvNVX(sv) == 0.0)
3253 (void)strcpy(s,"0");
3257 Gconvert(SvNVX(sv), NV_DIG, 0, s);
3260 #ifdef FIXNEGATIVEZERO
3261 if (*s == '-' && s[1] == '0' && !s[2])
3271 if (!PL_localizing && !(SvFLAGS(sv) & SVs_PADTMP) && ckWARN(WARN_UNINITIALIZED))
3275 if (SvTYPE(sv) < SVt_PV)
3276 /* Typically the caller expects that sv_any is not NULL now. */
3277 sv_upgrade(sv, SVt_PV);
3281 STRLEN len = s - SvPVX_const(sv);
3287 DEBUG_c(PerlIO_printf(Perl_debug_log, "0x%"UVxf" 2pv(%s)\n",
3288 PTR2UV(sv),SvPVX_const(sv)));
3289 if (flags & SV_CONST_RETURN)
3290 return (char *)SvPVX_const(sv);
3291 if (flags & SV_MUTABLE_RETURN)
3292 return SvPVX_mutable(sv);
3296 if (SvROK(sv)) { /* XXX Skip this when sv_pvn_force calls */
3297 /* Sneaky stuff here */
3301 tsv = newSVpv(tmpbuf, 0);
3314 t = SvPVX_const(tsv);
3319 len = strlen(tmpbuf);
3321 #ifdef FIXNEGATIVEZERO
3322 if (len == 2 && t[0] == '-' && t[1] == '0') {
3327 SvUPGRADE(sv, SVt_PV);
3330 s = SvGROW_mutable(sv, len + 1);
3333 return memcpy(s, t, len + 1);
3338 =for apidoc sv_copypv
3340 Copies a stringified representation of the source SV into the
3341 destination SV. Automatically performs any necessary mg_get and
3342 coercion of numeric values into strings. Guaranteed to preserve
3343 UTF-8 flag even from overloaded objects. Similar in nature to
3344 sv_2pv[_flags] but operates directly on an SV instead of just the
3345 string. Mostly uses sv_2pv_flags to do its work, except when that
3346 would lose the UTF-8'ness of the PV.
3352 Perl_sv_copypv(pTHX_ SV *dsv, register SV *ssv)
3355 const char * const s = SvPV_const(ssv,len);
3356 sv_setpvn(dsv,s,len);
3364 =for apidoc sv_2pvbyte_nolen
3366 Return a pointer to the byte-encoded representation of the SV.
3367 May cause the SV to be downgraded from UTF-8 as a side-effect.
3369 Usually accessed via the C<SvPVbyte_nolen> macro.
3375 Perl_sv_2pvbyte_nolen(pTHX_ register SV *sv)
3377 return sv_2pvbyte(sv, 0);
3381 =for apidoc sv_2pvbyte
3383 Return a pointer to the byte-encoded representation of the SV, and set *lp
3384 to its length. May cause the SV to be downgraded from UTF-8 as a
3387 Usually accessed via the C<SvPVbyte> macro.
3393 Perl_sv_2pvbyte(pTHX_ register SV *sv, STRLEN *lp)
3395 sv_utf8_downgrade(sv,0);
3396 return lp ? SvPV(sv,*lp) : SvPV_nolen(sv);
3400 =for apidoc sv_2pvutf8_nolen
3402 Return a pointer to the UTF-8-encoded representation of the SV.
3403 May cause the SV to be upgraded to UTF-8 as a side-effect.
3405 Usually accessed via the C<SvPVutf8_nolen> macro.
3411 Perl_sv_2pvutf8_nolen(pTHX_ register SV *sv)
3413 return sv_2pvutf8(sv, 0);
3417 =for apidoc sv_2pvutf8
3419 Return a pointer to the UTF-8-encoded representation of the SV, and set *lp
3420 to its length. May cause the SV to be upgraded to UTF-8 as a side-effect.
3422 Usually accessed via the C<SvPVutf8> macro.
3428 Perl_sv_2pvutf8(pTHX_ register SV *sv, STRLEN *lp)
3430 sv_utf8_upgrade(sv);
3431 return SvPV(sv,*lp);
3435 =for apidoc sv_2bool
3437 This function is only called on magical items, and is only used by
3438 sv_true() or its macro equivalent.
3444 Perl_sv_2bool(pTHX_ register SV *sv)
3452 if (SvAMAGIC(sv) && (tmpsv=AMG_CALLun(sv,bool_)) &&
3453 (!SvROK(tmpsv) || (SvRV(tmpsv) != SvRV(sv))))
3454 return (bool)SvTRUE(tmpsv);
3455 return SvRV(sv) != 0;
3458 register XPV* const Xpvtmp = (XPV*)SvANY(sv);
3460 (*sv->sv_u.svu_pv > '0' ||
3461 Xpvtmp->xpv_cur > 1 ||
3462 (Xpvtmp->xpv_cur && *sv->sv_u.svu_pv != '0')))
3469 return SvIVX(sv) != 0;
3472 return SvNVX(sv) != 0.0;
3479 /* sv_utf8_upgrade() is now a macro using sv_utf8_upgrade_flags();
3480 * this function provided for binary compatibility only
3485 Perl_sv_utf8_upgrade(pTHX_ register SV *sv)
3487 return sv_utf8_upgrade_flags(sv, SV_GMAGIC);
3491 =for apidoc sv_utf8_upgrade
3493 Converts the PV of an SV to its UTF-8-encoded form.
3494 Forces the SV to string form if it is not already.
3495 Always sets the SvUTF8 flag to avoid future validity checks even
3496 if all the bytes have hibit clear.
3498 This is not as a general purpose byte encoding to Unicode interface:
3499 use the Encode extension for that.
3501 =for apidoc sv_utf8_upgrade_flags
3503 Converts the PV of an SV to its UTF-8-encoded form.
3504 Forces the SV to string form if it is not already.
3505 Always sets the SvUTF8 flag to avoid future validity checks even
3506 if all the bytes have hibit clear. If C<flags> has C<SV_GMAGIC> bit set,
3507 will C<mg_get> on C<sv> if appropriate, else not. C<sv_utf8_upgrade> and
3508 C<sv_utf8_upgrade_nomg> are implemented in terms of this function.
3510 This is not as a general purpose byte encoding to Unicode interface:
3511 use the Encode extension for that.
3517 Perl_sv_utf8_upgrade_flags(pTHX_ register SV *sv, I32 flags)
3519 if (sv == &PL_sv_undef)
3523 if (SvREADONLY(sv) && (SvPOKp(sv) || SvIOKp(sv) || SvNOKp(sv))) {
3524 (void) sv_2pv_flags(sv,&len, flags);
3528 (void) SvPV_force(sv,len);
3537 sv_force_normal_flags(sv, 0);
3540 if (PL_encoding && !(flags & SV_UTF8_NO_ENCODING))
3541 sv_recode_to_utf8(sv, PL_encoding);
3542 else { /* Assume Latin-1/EBCDIC */
3543 /* This function could be much more efficient if we
3544 * had a FLAG in SVs to signal if there are any hibit
3545 * chars in the PV. Given that there isn't such a flag
3546 * make the loop as fast as possible. */
3547 const U8 *s = (U8 *) SvPVX_const(sv);
3548 const U8 *e = (U8 *) SvEND(sv);
3554 if ((hibit = !NATIVE_IS_INVARIANT(ch)))
3558 STRLEN len = SvCUR(sv) + 1; /* Plus the \0 */
3559 U8 * const recoded = bytes_to_utf8((U8*)s, &len);
3561 SvPV_free(sv); /* No longer using what was there before. */
3563 SvPV_set(sv, (char*)recoded);
3564 SvCUR_set(sv, len - 1);
3565 SvLEN_set(sv, len); /* No longer know the real size. */
3567 /* Mark as UTF-8 even if no hibit - saves scanning loop */
3574 =for apidoc sv_utf8_downgrade
3576 Attempts to convert the PV of an SV from characters to bytes.
3577 If the PV contains a character beyond byte, this conversion will fail;
3578 in this case, either returns false or, if C<fail_ok> is not
3581 This is not as a general purpose Unicode to byte encoding interface:
3582 use the Encode extension for that.
3588 Perl_sv_utf8_downgrade(pTHX_ register SV* sv, bool fail_ok)
3590 if (SvPOKp(sv) && SvUTF8(sv)) {
3596 sv_force_normal_flags(sv, 0);
3598 s = (U8 *) SvPV(sv, len);
3599 if (!utf8_to_bytes(s, &len)) {
3604 Perl_croak(aTHX_ "Wide character in %s",
3607 Perl_croak(aTHX_ "Wide character");
3618 =for apidoc sv_utf8_encode
3620 Converts the PV of an SV to UTF-8, but then turns the C<SvUTF8>
3621 flag off so that it looks like octets again.
3627 Perl_sv_utf8_encode(pTHX_ register SV *sv)
3629 (void) sv_utf8_upgrade(sv);
3631 sv_force_normal_flags(sv, 0);
3633 if (SvREADONLY(sv)) {
3634 Perl_croak(aTHX_ PL_no_modify);
3640 =for apidoc sv_utf8_decode
3642 If the PV of the SV is an octet sequence in UTF-8
3643 and contains a multiple-byte character, the C<SvUTF8> flag is turned on
3644 so that it looks like a character. If the PV contains only single-byte
3645 characters, the C<SvUTF8> flag stays being off.
3646 Scans PV for validity and returns false if the PV is invalid UTF-8.
3652 Perl_sv_utf8_decode(pTHX_ register SV *sv)
3658 /* The octets may have got themselves encoded - get them back as
3661 if (!sv_utf8_downgrade(sv, TRUE))
3664 /* it is actually just a matter of turning the utf8 flag on, but
3665 * we want to make sure everything inside is valid utf8 first.
3667 c = (const U8 *) SvPVX_const(sv);
3668 if (!is_utf8_string(c, SvCUR(sv)+1))
3670 e = (const U8 *) SvEND(sv);
3673 if (!UTF8_IS_INVARIANT(ch)) {
3682 /* sv_setsv() is now a macro using Perl_sv_setsv_flags();
3683 * this function provided for binary compatibility only
3687 Perl_sv_setsv(pTHX_ SV *dstr, register SV *sstr)
3689 sv_setsv_flags(dstr, sstr, SV_GMAGIC);
3693 =for apidoc sv_setsv
3695 Copies the contents of the source SV C<ssv> into the destination SV
3696 C<dsv>. The source SV may be destroyed if it is mortal, so don't use this
3697 function if the source SV needs to be reused. Does not handle 'set' magic.
3698 Loosely speaking, it performs a copy-by-value, obliterating any previous
3699 content of the destination.
3701 You probably want to use one of the assortment of wrappers, such as
3702 C<SvSetSV>, C<SvSetSV_nosteal>, C<SvSetMagicSV> and
3703 C<SvSetMagicSV_nosteal>.
3705 =for apidoc sv_setsv_flags
3707 Copies the contents of the source SV C<ssv> into the destination SV
3708 C<dsv>. The source SV may be destroyed if it is mortal, so don't use this
3709 function if the source SV needs to be reused. Does not handle 'set' magic.
3710 Loosely speaking, it performs a copy-by-value, obliterating any previous
3711 content of the destination.
3712 If the C<flags> parameter has the C<SV_GMAGIC> bit set, will C<mg_get> on
3713 C<ssv> if appropriate, else not. If the C<flags> parameter has the
3714 C<NOSTEAL> bit set then the buffers of temps will not be stolen. <sv_setsv>
3715 and C<sv_setsv_nomg> are implemented in terms of this function.
3717 You probably want to use one of the assortment of wrappers, such as
3718 C<SvSetSV>, C<SvSetSV_nosteal>, C<SvSetMagicSV> and
3719 C<SvSetMagicSV_nosteal>.
3721 This is the primary function for copying scalars, and most other
3722 copy-ish functions and macros use this underneath.
3728 Perl_sv_setsv_flags(pTHX_ SV *dstr, register SV *sstr, I32 flags)
3730 register U32 sflags;
3736 SV_CHECK_THINKFIRST_COW_DROP(dstr);
3738 sstr = &PL_sv_undef;
3739 stype = SvTYPE(sstr);
3740 dtype = SvTYPE(dstr);
3745 /* need to nuke the magic */
3747 SvRMAGICAL_off(dstr);
3750 /* There's a lot of redundancy below but we're going for speed here */
3755 if (dtype != SVt_PVGV) {
3756 (void)SvOK_off(dstr);
3764 sv_upgrade(dstr, SVt_IV);
3767 sv_upgrade(dstr, SVt_PVNV);
3771 sv_upgrade(dstr, SVt_PVIV);
3774 (void)SvIOK_only(dstr);
3775 SvIV_set(dstr, SvIVX(sstr));
3778 if (SvTAINTED(sstr))
3789 sv_upgrade(dstr, SVt_NV);
3794 sv_upgrade(dstr, SVt_PVNV);
3797 SvNV_set(dstr, SvNVX(sstr));
3798 (void)SvNOK_only(dstr);
3799 if (SvTAINTED(sstr))
3807 sv_upgrade(dstr, SVt_RV);
3808 else if (dtype == SVt_PVGV &&
3809 SvROK(sstr) && SvTYPE(SvRV(sstr)) == SVt_PVGV) {
3812 if (GvIMPORTED(dstr) != GVf_IMPORTED
3813 && CopSTASH_ne(PL_curcop, GvSTASH(dstr)))
3815 GvIMPORTED_on(dstr);
3824 #ifdef PERL_OLD_COPY_ON_WRITE
3825 if ((SvFLAGS(sstr) & CAN_COW_MASK) == CAN_COW_FLAGS) {
3826 if (dtype < SVt_PVIV)
3827 sv_upgrade(dstr, SVt_PVIV);
3834 sv_upgrade(dstr, SVt_PV);
3837 if (dtype < SVt_PVIV)
3838 sv_upgrade(dstr, SVt_PVIV);
3841 if (dtype < SVt_PVNV)
3842 sv_upgrade(dstr, SVt_PVNV);
3849 const char * const type = sv_reftype(sstr,0);
3851 Perl_croak(aTHX_ "Bizarre copy of %s in %s", type, OP_NAME(PL_op));
3853 Perl_croak(aTHX_ "Bizarre copy of %s", type);
3858 if (dtype <= SVt_PVGV) {
3860 if (dtype != SVt_PVGV) {
3861 const char * const name = GvNAME(sstr);
3862 const STRLEN len = GvNAMELEN(sstr);
3863 /* don't upgrade SVt_PVLV: it can hold a glob */
3864 if (dtype != SVt_PVLV)
3865 sv_upgrade(dstr, SVt_PVGV);
3866 sv_magic(dstr, dstr, PERL_MAGIC_glob, Nullch, 0);
3867 GvSTASH(dstr) = GvSTASH(sstr);
3869 Perl_sv_add_backref(aTHX_ (SV*)GvSTASH(dstr), dstr);
3870 GvNAME(dstr) = savepvn(name, len);
3871 GvNAMELEN(dstr) = len;
3872 SvFAKE_on(dstr); /* can coerce to non-glob */
3874 /* ahem, death to those who redefine active sort subs */
3875 else if (PL_curstackinfo->si_type == PERLSI_SORT
3876 && GvCV(dstr) && PL_sortcop == CvSTART(GvCV(dstr)))
3877 Perl_croak(aTHX_ "Can't redefine active sort subroutine %s",
3880 #ifdef GV_UNIQUE_CHECK
3881 if (GvUNIQUE((GV*)dstr)) {
3882 Perl_croak(aTHX_ PL_no_modify);
3886 (void)SvOK_off(dstr);
3887 GvINTRO_off(dstr); /* one-shot flag */
3889 GvGP(dstr) = gp_ref(GvGP(sstr));
3890 if (SvTAINTED(sstr))
3892 if (GvIMPORTED(dstr) != GVf_IMPORTED
3893 && CopSTASH_ne(PL_curcop, GvSTASH(dstr)))
3895 GvIMPORTED_on(dstr);
3903 if (SvGMAGICAL(sstr) && (flags & SV_GMAGIC)) {
3905 if ((int)SvTYPE(sstr) != stype) {
3906 stype = SvTYPE(sstr);
3907 if (stype == SVt_PVGV && dtype <= SVt_PVGV)
3911 if (stype == SVt_PVLV)
3912 SvUPGRADE(dstr, SVt_PVNV);
3914 SvUPGRADE(dstr, (U32)stype);
3917 sflags = SvFLAGS(sstr);
3919 if (sflags & SVf_ROK) {
3920 if (dtype >= SVt_PV) {
3921 if (dtype == SVt_PVGV) {
3922 SV *sref = SvREFCNT_inc(SvRV(sstr));
3924 const int intro = GvINTRO(dstr);
3926 #ifdef GV_UNIQUE_CHECK
3927 if (GvUNIQUE((GV*)dstr)) {
3928 Perl_croak(aTHX_ PL_no_modify);
3933 GvINTRO_off(dstr); /* one-shot flag */
3934 GvLINE(dstr) = CopLINE(PL_curcop);
3935 GvEGV(dstr) = (GV*)dstr;
3938 switch (SvTYPE(sref)) {
3941 SAVEGENERICSV(GvAV(dstr));
3943 dref = (SV*)GvAV(dstr);
3944 GvAV(dstr) = (AV*)sref;
3945 if (!GvIMPORTED_AV(dstr)
3946 && CopSTASH_ne(PL_curcop, GvSTASH(dstr)))
3948 GvIMPORTED_AV_on(dstr);
3953 SAVEGENERICSV(GvHV(dstr));
3955 dref = (SV*)GvHV(dstr);
3956 GvHV(dstr) = (HV*)sref;
3957 if (!GvIMPORTED_HV(dstr)
3958 && CopSTASH_ne(PL_curcop, GvSTASH(dstr)))
3960 GvIMPORTED_HV_on(dstr);
3965 if (GvCVGEN(dstr) && GvCV(dstr) != (CV*)sref) {
3966 SvREFCNT_dec(GvCV(dstr));
3967 GvCV(dstr) = Nullcv;
3968 GvCVGEN(dstr) = 0; /* Switch off cacheness. */
3969 PL_sub_generation++;
3971 SAVEGENERICSV(GvCV(dstr));
3974 dref = (SV*)GvCV(dstr);
3975 if (GvCV(dstr) != (CV*)sref) {
3976 CV* cv = GvCV(dstr);
3978 if (!GvCVGEN((GV*)dstr) &&
3979 (CvROOT(cv) || CvXSUB(cv)))
3981 /* ahem, death to those who redefine
3982 * active sort subs */
3983 if (PL_curstackinfo->si_type == PERLSI_SORT &&
3984 PL_sortcop == CvSTART(cv))
3986 "Can't redefine active sort subroutine %s",
3987 GvENAME((GV*)dstr));
3988 /* Redefining a sub - warning is mandatory if
3989 it was a const and its value changed. */
3990 if (ckWARN(WARN_REDEFINE)
3992 && (!CvCONST((CV*)sref)
3993 || sv_cmp(cv_const_sv(cv),
3994 cv_const_sv((CV*)sref)))))
3996 Perl_warner(aTHX_ packWARN(WARN_REDEFINE),
3998 ? "Constant subroutine %s::%s redefined"
3999 : "Subroutine %s::%s redefined",
4000 HvNAME_get(GvSTASH((GV*)dstr)),
4001 GvENAME((GV*)dstr));
4005 cv_ckproto(cv, (GV*)dstr,
4007 ? SvPVX_const(sref) : Nullch);
4009 GvCV(dstr) = (CV*)sref;
4010 GvCVGEN(dstr) = 0; /* Switch off cacheness. */
4011 GvASSUMECV_on(dstr);
4012 PL_sub_generation++;
4014 if (!GvIMPORTED_CV(dstr)
4015 && CopSTASH_ne(PL_curcop, GvSTASH(dstr)))
4017 GvIMPORTED_CV_on(dstr);
4022 SAVEGENERICSV(GvIOp(dstr));
4024 dref = (SV*)GvIOp(dstr);
4025 GvIOp(dstr) = (IO*)sref;
4029 SAVEGENERICSV(GvFORM(dstr));
4031 dref = (SV*)GvFORM(dstr);
4032 GvFORM(dstr) = (CV*)sref;
4036 SAVEGENERICSV(GvSV(dstr));
4038 dref = (SV*)GvSV(dstr);
4040 if (!GvIMPORTED_SV(dstr)
4041 && CopSTASH_ne(PL_curcop, GvSTASH(dstr)))
4043 GvIMPORTED_SV_on(dstr);
4049 if (SvTAINTED(sstr))
4053 if (SvPVX_const(dstr)) {
4059 (void)SvOK_off(dstr);
4060 SvRV_set(dstr, SvREFCNT_inc(SvRV(sstr)));
4062 if (sflags & SVp_NOK) {
4064 /* Only set the public OK flag if the source has public OK. */
4065 if (sflags & SVf_NOK)
4066 SvFLAGS(dstr) |= SVf_NOK;
4067 SvNV_set(dstr, SvNVX(sstr));
4069 if (sflags & SVp_IOK) {
4070 (void)SvIOKp_on(dstr);
4071 if (sflags & SVf_IOK)
4072 SvFLAGS(dstr) |= SVf_IOK;
4073 if (sflags & SVf_IVisUV)
4075 SvIV_set(dstr, SvIVX(sstr));
4077 if (SvAMAGIC(sstr)) {
4081 else if (sflags & SVp_POK) {
4085 * Check to see if we can just swipe the string. If so, it's a
4086 * possible small lose on short strings, but a big win on long ones.
4087 * It might even be a win on short strings if SvPVX_const(dstr)
4088 * has to be allocated and SvPVX_const(sstr) has to be freed.
4091 /* Whichever path we take through the next code, we want this true,
4092 and doing it now facilitates the COW check. */
4093 (void)SvPOK_only(dstr);
4096 /* We're not already COW */
4097 ((sflags & (SVf_FAKE | SVf_READONLY)) != (SVf_FAKE | SVf_READONLY)
4098 #ifndef PERL_OLD_COPY_ON_WRITE
4099 /* or we are, but dstr isn't a suitable target. */
4100 || (SvFLAGS(dstr) & CAN_COW_MASK) != CAN_COW_FLAGS
4105 (sflags & SVs_TEMP) && /* slated for free anyway? */
4106 !(sflags & SVf_OOK) && /* and not involved in OOK hack? */
4107 (!(flags & SV_NOSTEAL)) &&
4108 /* and we're allowed to steal temps */
4109 SvREFCNT(sstr) == 1 && /* and no other references to it? */
4110 SvLEN(sstr) && /* and really is a string */
4111 /* and won't be needed again, potentially */
4112 !(PL_op && PL_op->op_type == OP_AASSIGN))
4113 #ifdef PERL_OLD_COPY_ON_WRITE
4114 && !((sflags & CAN_COW_MASK) == CAN_COW_FLAGS
4115 && (SvFLAGS(dstr) & CAN_COW_MASK) == CAN_COW_FLAGS
4116 && SvTYPE(sstr) >= SVt_PVIV)
4119 /* Failed the swipe test, and it's not a shared hash key either.
4120 Have to copy the string. */
4121 STRLEN len = SvCUR(sstr);
4122 SvGROW(dstr, len + 1); /* inlined from sv_setpvn */
4123 Move(SvPVX_const(sstr),SvPVX(dstr),len,char);
4124 SvCUR_set(dstr, len);
4125 *SvEND(dstr) = '\0';
4127 /* If PERL_OLD_COPY_ON_WRITE is not defined, then isSwipe will always
4129 /* Either it's a shared hash key, or it's suitable for
4130 copy-on-write or we can swipe the string. */
4132 PerlIO_printf(Perl_debug_log, "Copy on write: sstr --> dstr\n");
4136 #ifdef PERL_OLD_COPY_ON_WRITE
4138 /* I believe I should acquire a global SV mutex if
4139 it's a COW sv (not a shared hash key) to stop
4140 it going un copy-on-write.
4141 If the source SV has gone un copy on write between up there
4142 and down here, then (assert() that) it is of the correct
4143 form to make it copy on write again */
4144 if ((sflags & (SVf_FAKE | SVf_READONLY))
4145 != (SVf_FAKE | SVf_READONLY)) {
4146 SvREADONLY_on(sstr);
4148 /* Make the source SV into a loop of 1.
4149 (about to become 2) */
4150 SV_COW_NEXT_SV_SET(sstr, sstr);
4154 /* Initial code is common. */
4155 if (SvPVX_const(dstr)) { /* we know that dtype >= SVt_PV */
4160 /* making another shared SV. */
4161 STRLEN cur = SvCUR(sstr);
4162 STRLEN len = SvLEN(sstr);
4163 #ifdef PERL_OLD_COPY_ON_WRITE
4165 assert (SvTYPE(dstr) >= SVt_PVIV);
4166 /* SvIsCOW_normal */
4167 /* splice us in between source and next-after-source. */
4168 SV_COW_NEXT_SV_SET(dstr, SV_COW_NEXT_SV(sstr));
4169 SV_COW_NEXT_SV_SET(sstr, dstr);
4170 SvPV_set(dstr, SvPVX_mutable(sstr));
4174 /* SvIsCOW_shared_hash */
4175 DEBUG_C(PerlIO_printf(Perl_debug_log,
4176 "Copy on write: Sharing hash\n"));
4178 assert (SvTYPE(dstr) >= SVt_PV);
4180 HEK_KEY(share_hek_hek(SvSHARED_HEK_FROM_PV(SvPVX_const(sstr)))));
4182 SvLEN_set(dstr, len);
4183 SvCUR_set(dstr, cur);
4184 SvREADONLY_on(dstr);
4186 /* Relesase a global SV mutex. */
4189 { /* Passes the swipe test. */
4190 SvPV_set(dstr, SvPVX_mutable(sstr));
4191 SvLEN_set(dstr, SvLEN(sstr));
4192 SvCUR_set(dstr, SvCUR(sstr));
4195 (void)SvOK_off(sstr); /* NOTE: nukes most SvFLAGS on sstr */
4196 SvPV_set(sstr, Nullch);
4202 if (sflags & SVf_UTF8)
4204 if (sflags & SVp_NOK) {
4206 if (sflags & SVf_NOK)
4207 SvFLAGS(dstr) |= SVf_NOK;
4208 SvNV_set(dstr, SvNVX(sstr));
4210 if (sflags & SVp_IOK) {
4211 (void)SvIOKp_on(dstr);
4212 if (sflags & SVf_IOK)
4213 SvFLAGS(dstr) |= SVf_IOK;
4214 if (sflags & SVf_IVisUV)
4216 SvIV_set(dstr, SvIVX(sstr));
4219 MAGIC *smg = mg_find(sstr,PERL_MAGIC_vstring);
4220 sv_magic(dstr, NULL, PERL_MAGIC_vstring,
4221 smg->mg_ptr, smg->mg_len);
4222 SvRMAGICAL_on(dstr);
4225 else if (sflags & SVp_IOK) {
4226 if (sflags & SVf_IOK)
4227 (void)SvIOK_only(dstr);
4229 (void)SvOK_off(dstr);
4230 (void)SvIOKp_on(dstr);
4232 /* XXXX Do we want to set IsUV for IV(ROK)? Be extra safe... */
4233 if (sflags & SVf_IVisUV)
4235 SvIV_set(dstr, SvIVX(sstr));
4236 if (sflags & SVp_NOK) {
4237 if (sflags & SVf_NOK)
4238 (void)SvNOK_on(dstr);
4240 (void)SvNOKp_on(dstr);
4241 SvNV_set(dstr, SvNVX(sstr));
4244 else if (sflags & SVp_NOK) {
4245 if (sflags & SVf_NOK)
4246 (void)SvNOK_only(dstr);
4248 (void)SvOK_off(dstr);
4251 SvNV_set(dstr, SvNVX(sstr));
4254 if (dtype == SVt_PVGV) {
4255 if (ckWARN(WARN_MISC))
4256 Perl_warner(aTHX_ packWARN(WARN_MISC), "Undefined value assigned to typeglob");
4259 (void)SvOK_off(dstr);
4261 if (SvTAINTED(sstr))
4266 =for apidoc sv_setsv_mg
4268 Like C<sv_setsv>, but also handles 'set' magic.
4274 Perl_sv_setsv_mg(pTHX_ SV *dstr, register SV *sstr)
4276 sv_setsv(dstr,sstr);
4280 #ifdef PERL_OLD_COPY_ON_WRITE
4282 Perl_sv_setsv_cow(pTHX_ SV *dstr, SV *sstr)
4284 STRLEN cur = SvCUR(sstr);
4285 STRLEN len = SvLEN(sstr);
4286 register char *new_pv;
4289 PerlIO_printf(Perl_debug_log, "Fast copy on write: %p -> %p\n",
4297 if (SvTHINKFIRST(dstr))
4298 sv_force_normal_flags(dstr, SV_COW_DROP_PV);
4299 else if (SvPVX_const(dstr))
4300 Safefree(SvPVX_const(dstr));
4304 SvUPGRADE(dstr, SVt_PVIV);
4306 assert (SvPOK(sstr));
4307 assert (SvPOKp(sstr));
4308 assert (!SvIOK(sstr));
4309 assert (!SvIOKp(sstr));
4310 assert (!SvNOK(sstr));
4311 assert (!SvNOKp(sstr));
4313 if (SvIsCOW(sstr)) {
4315 if (SvLEN(sstr) == 0) {
4316 /* source is a COW shared hash key. */
4317 DEBUG_C(PerlIO_printf(Perl_debug_log,
4318 "Fast copy on write: Sharing hash\n"));
4319 new_pv = HEK_KEY(share_hek_hek(SvSHARED_HEK_FROM_PV(SvPVX_const(sstr))));
4322 SV_COW_NEXT_SV_SET(dstr, SV_COW_NEXT_SV(sstr));
4324 assert ((SvFLAGS(sstr) & CAN_COW_MASK) == CAN_COW_FLAGS);
4325 SvUPGRADE(sstr, SVt_PVIV);
4326 SvREADONLY_on(sstr);
4328 DEBUG_C(PerlIO_printf(Perl_debug_log,
4329 "Fast copy on write: Converting sstr to COW\n"));
4330 SV_COW_NEXT_SV_SET(dstr, sstr);
4332 SV_COW_NEXT_SV_SET(sstr, dstr);
4333 new_pv = SvPVX_mutable(sstr);
4336 SvPV_set(dstr, new_pv);
4337 SvFLAGS(dstr) = (SVt_PVIV|SVf_POK|SVp_POK|SVf_FAKE|SVf_READONLY);
4340 SvLEN_set(dstr, len);
4341 SvCUR_set(dstr, cur);
4350 =for apidoc sv_setpvn
4352 Copies a string into an SV. The C<len> parameter indicates the number of
4353 bytes to be copied. If the C<ptr> argument is NULL the SV will become
4354 undefined. Does not handle 'set' magic. See C<sv_setpvn_mg>.
4360 Perl_sv_setpvn(pTHX_ register SV *sv, register const char *ptr, register STRLEN len)
4362 register char *dptr;
4364 SV_CHECK_THINKFIRST_COW_DROP(sv);
4370 /* len is STRLEN which is unsigned, need to copy to signed */
4373 Perl_croak(aTHX_ "panic: sv_setpvn called with negative strlen");
4375 SvUPGRADE(sv, SVt_PV);
4377 dptr = SvGROW(sv, len + 1);
4378 Move(ptr,dptr,len,char);
4381 (void)SvPOK_only_UTF8(sv); /* validate pointer */
4386 =for apidoc sv_setpvn_mg
4388 Like C<sv_setpvn>, but also handles 'set' magic.
4394 Perl_sv_setpvn_mg(pTHX_ register SV *sv, register const char *ptr, register STRLEN len)
4396 sv_setpvn(sv,ptr,len);
4401 =for apidoc sv_setpv
4403 Copies a string into an SV. The string must be null-terminated. Does not
4404 handle 'set' magic. See C<sv_setpv_mg>.
4410 Perl_sv_setpv(pTHX_ register SV *sv, register const char *ptr)
4412 register STRLEN len;
4414 SV_CHECK_THINKFIRST_COW_DROP(sv);
4420 SvUPGRADE(sv, SVt_PV);
4422 SvGROW(sv, len + 1);
4423 Move(ptr,SvPVX(sv),len+1,char);
4425 (void)SvPOK_only_UTF8(sv); /* validate pointer */
4430 =for apidoc sv_setpv_mg
4432 Like C<sv_setpv>, but also handles 'set' magic.
4438 Perl_sv_setpv_mg(pTHX_ register SV *sv, register const char *ptr)
4445 =for apidoc sv_usepvn
4447 Tells an SV to use C<ptr> to find its string value. Normally the string is
4448 stored inside the SV but sv_usepvn allows the SV to use an outside string.
4449 The C<ptr> should point to memory that was allocated by C<malloc>. The
4450 string length, C<len>, must be supplied. This function will realloc the
4451 memory pointed to by C<ptr>, so that pointer should not be freed or used by
4452 the programmer after giving it to sv_usepvn. Does not handle 'set' magic.
4453 See C<sv_usepvn_mg>.
4459 Perl_sv_usepvn(pTHX_ register SV *sv, register char *ptr, register STRLEN len)
4462 SV_CHECK_THINKFIRST_COW_DROP(sv);
4463 SvUPGRADE(sv, SVt_PV);
4468 if (SvPVX_const(sv))
4471 allocate = PERL_STRLEN_ROUNDUP(len + 1);
4472 ptr = saferealloc (ptr, allocate);
4475 SvLEN_set(sv, allocate);
4477 (void)SvPOK_only_UTF8(sv); /* validate pointer */
4482 =for apidoc sv_usepvn_mg
4484 Like C<sv_usepvn>, but also handles 'set' magic.
4490 Perl_sv_usepvn_mg(pTHX_ register SV *sv, register char *ptr, register STRLEN len)
4492 sv_usepvn(sv,ptr,len);
4496 #ifdef PERL_OLD_COPY_ON_WRITE
4497 /* Need to do this *after* making the SV normal, as we need the buffer
4498 pointer to remain valid until after we've copied it. If we let go too early,
4499 another thread could invalidate it by unsharing last of the same hash key
4500 (which it can do by means other than releasing copy-on-write Svs)
4501 or by changing the other copy-on-write SVs in the loop. */
4503 S_sv_release_COW(pTHX_ register SV *sv, const char *pvx, STRLEN len, SV *after)
4505 if (len) { /* this SV was SvIsCOW_normal(sv) */
4506 /* we need to find the SV pointing to us. */
4507 SV * const current = SV_COW_NEXT_SV(after);
4509 if (current == sv) {
4510 /* The SV we point to points back to us (there were only two of us
4512 Hence other SV is no longer copy on write either. */
4514 SvREADONLY_off(after);
4516 /* We need to follow the pointers around the loop. */
4518 while ((next = SV_COW_NEXT_SV(current)) != sv) {
4521 /* don't loop forever if the structure is bust, and we have
4522 a pointer into a closed loop. */
4523 assert (current != after);
4524 assert (SvPVX_const(current) == pvx);
4526 /* Make the SV before us point to the SV after us. */
4527 SV_COW_NEXT_SV_SET(current, after);
4530 unshare_hek(SvSHARED_HEK_FROM_PV(pvx));
4535 Perl_sv_release_IVX(pTHX_ register SV *sv)
4538 sv_force_normal_flags(sv, 0);
4544 =for apidoc sv_force_normal_flags
4546 Undo various types of fakery on an SV: if the PV is a shared string, make
4547 a private copy; if we're a ref, stop refing; if we're a glob, downgrade to
4548 an xpvmg; if we're a copy-on-write scalar, this is the on-write time when
4549 we do the copy, and is also used locally. If C<SV_COW_DROP_PV> is set
4550 then a copy-on-write scalar drops its PV buffer (if any) and becomes
4551 SvPOK_off rather than making a copy. (Used where this scalar is about to be
4552 set to some other value.) In addition, the C<flags> parameter gets passed to
4553 C<sv_unref_flags()> when unrefing. C<sv_force_normal> calls this function
4554 with flags set to 0.
4560 Perl_sv_force_normal_flags(pTHX_ register SV *sv, U32 flags)
4562 #ifdef PERL_OLD_COPY_ON_WRITE
4563 if (SvREADONLY(sv)) {
4564 /* At this point I believe I should acquire a global SV mutex. */
4566 const char * const pvx = SvPVX_const(sv);
4567 const STRLEN len = SvLEN(sv);
4568 const STRLEN cur = SvCUR(sv);
4569 SV * const next = SV_COW_NEXT_SV(sv); /* next COW sv in the loop. */
4571 PerlIO_printf(Perl_debug_log,
4572 "Copy on write: Force normal %ld\n",
4578 /* This SV doesn't own the buffer, so need to Newx() a new one: */
4579 SvPV_set(sv, (char*)0);
4581 if (flags & SV_COW_DROP_PV) {
4582 /* OK, so we don't need to copy our buffer. */
4585 SvGROW(sv, cur + 1);
4586 Move(pvx,SvPVX(sv),cur,char);
4590 sv_release_COW(sv, pvx, len, next);
4595 else if (IN_PERL_RUNTIME)
4596 Perl_croak(aTHX_ PL_no_modify);
4597 /* At this point I believe that I can drop the global SV mutex. */
4600 if (SvREADONLY(sv)) {
4602 const char * const pvx = SvPVX_const(sv);
4603 const STRLEN len = SvCUR(sv);
4606 SvPV_set(sv, Nullch);
4608 SvGROW(sv, len + 1);
4609 Move(pvx,SvPVX_const(sv),len,char);
4611 unshare_hek(SvSHARED_HEK_FROM_PV(pvx));
4613 else if (IN_PERL_RUNTIME)
4614 Perl_croak(aTHX_ PL_no_modify);
4618 sv_unref_flags(sv, flags);
4619 else if (SvFAKE(sv) && SvTYPE(sv) == SVt_PVGV)
4624 =for apidoc sv_force_normal
4626 Undo various types of fakery on an SV: if the PV is a shared string, make
4627 a private copy; if we're a ref, stop refing; if we're a glob, downgrade to
4628 an xpvmg. See also C<sv_force_normal_flags>.
4634 Perl_sv_force_normal(pTHX_ register SV *sv)
4636 sv_force_normal_flags(sv, 0);
4642 Efficient removal of characters from the beginning of the string buffer.
4643 SvPOK(sv) must be true and the C<ptr> must be a pointer to somewhere inside
4644 the string buffer. The C<ptr> becomes the first character of the adjusted
4645 string. Uses the "OOK hack".
4646 Beware: after this function returns, C<ptr> and SvPVX_const(sv) may no longer