3 * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 * 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 by Larry Wall
7 * You may distribute under the terms of either the GNU General Public
8 * License or the Artistic License, as specified in the README file.
13 * 'I wonder what the Entish is for "yes" and "no",' he thought.
16 * [p.480 of _The Lord of the Rings_, III/iv: "Treebeard"]
22 * This file contains the code that creates, manipulates and destroys
23 * scalar values (SVs). The other types (AV, HV, GV, etc.) reuse the
24 * structure of an SV, so their creation and destruction is handled
25 * here; higher-level functions are in av.c, hv.c, and so on. Opcode
26 * level functions (eg. substr, split, join) for each of the types are
38 /* Missing proto on LynxOS */
39 char *gconvert(double, int, int, char *);
42 #ifdef PERL_UTF8_CACHE_ASSERT
43 /* if adding more checks watch out for the following tests:
44 * t/op/index.t t/op/length.t t/op/pat.t t/op/substr.t
45 * lib/utf8.t lib/Unicode/Collate/t/index.t
48 # define ASSERT_UTF8_CACHE(cache) \
49 STMT_START { if (cache) { assert((cache)[0] <= (cache)[1]); \
50 assert((cache)[2] <= (cache)[3]); \
51 assert((cache)[3] <= (cache)[1]);} \
54 # define ASSERT_UTF8_CACHE(cache) NOOP
57 #ifdef PERL_OLD_COPY_ON_WRITE
58 #define SV_COW_NEXT_SV(sv) INT2PTR(SV *,SvUVX(sv))
59 #define SV_COW_NEXT_SV_SET(current,next) SvUV_set(current, PTR2UV(next))
60 /* This is a pessimistic view. Scalar must be purely a read-write PV to copy-
64 /* ============================================================================
66 =head1 Allocation and deallocation of SVs.
68 An SV (or AV, HV, etc.) is allocated in two parts: the head (struct
69 sv, av, hv...) contains type and reference count information, and for
70 many types, a pointer to the body (struct xrv, xpv, xpviv...), which
71 contains fields specific to each type. Some types store all they need
72 in the head, so don't have a body.
74 In all but the most memory-paranoid configuations (ex: PURIFY), heads
75 and bodies are allocated out of arenas, which by default are
76 approximately 4K chunks of memory parcelled up into N heads or bodies.
77 Sv-bodies are allocated by their sv-type, guaranteeing size
78 consistency needed to allocate safely from arrays.
80 For SV-heads, the first slot in each arena is reserved, and holds a
81 link to the next arena, some flags, and a note of the number of slots.
82 Snaked through each arena chain is a linked list of free items; when
83 this becomes empty, an extra arena is allocated and divided up into N
84 items which are threaded into the free list.
86 SV-bodies are similar, but they use arena-sets by default, which
87 separate the link and info from the arena itself, and reclaim the 1st
88 slot in the arena. SV-bodies are further described later.
90 The following global variables are associated with arenas:
92 PL_sv_arenaroot pointer to list of SV arenas
93 PL_sv_root pointer to list of free SV structures
95 PL_body_arenas head of linked-list of body arenas
96 PL_body_roots[] array of pointers to list of free bodies of svtype
97 arrays are indexed by the svtype needed
99 A few special SV heads are not allocated from an arena, but are
100 instead directly created in the interpreter structure, eg PL_sv_undef.
101 The size of arenas can be changed from the default by setting
102 PERL_ARENA_SIZE appropriately at compile time.
104 The SV arena serves the secondary purpose of allowing still-live SVs
105 to be located and destroyed during final cleanup.
107 At the lowest level, the macros new_SV() and del_SV() grab and free
108 an SV head. (If debugging with -DD, del_SV() calls the function S_del_sv()
109 to return the SV to the free list with error checking.) new_SV() calls
110 more_sv() / sv_add_arena() to add an extra arena if the free list is empty.
111 SVs in the free list have their SvTYPE field set to all ones.
113 At the time of very final cleanup, sv_free_arenas() is called from
114 perl_destruct() to physically free all the arenas allocated since the
115 start of the interpreter.
117 The function visit() scans the SV arenas list, and calls a specified
118 function for each SV it finds which is still live - ie which has an SvTYPE
119 other than all 1's, and a non-zero SvREFCNT. visit() is used by the
120 following functions (specified as [function that calls visit()] / [function
121 called by visit() for each SV]):
123 sv_report_used() / do_report_used()
124 dump all remaining SVs (debugging aid)
126 sv_clean_objs() / do_clean_objs(),do_clean_named_objs()
127 Attempt to free all objects pointed to by RVs,
128 and, unless DISABLE_DESTRUCTOR_KLUDGE is defined,
129 try to do the same for all objects indirectly
130 referenced by typeglobs too. Called once from
131 perl_destruct(), prior to calling sv_clean_all()
134 sv_clean_all() / do_clean_all()
135 SvREFCNT_dec(sv) each remaining SV, possibly
136 triggering an sv_free(). It also sets the
137 SVf_BREAK flag on the SV to indicate that the
138 refcnt has been artificially lowered, and thus
139 stopping sv_free() from giving spurious warnings
140 about SVs which unexpectedly have a refcnt
141 of zero. called repeatedly from perl_destruct()
142 until there are no SVs left.
144 =head2 Arena allocator API Summary
146 Private API to rest of sv.c
150 new_XIV(), del_XIV(),
151 new_XNV(), del_XNV(),
156 sv_report_used(), sv_clean_objs(), sv_clean_all(), sv_free_arenas()
160 * ========================================================================= */
163 * "A time to plant, and a time to uproot what was planted..."
167 Perl_offer_nice_chunk(pTHX_ void *const chunk, const U32 chunk_size)
173 PERL_ARGS_ASSERT_OFFER_NICE_CHUNK;
175 new_chunk = (void *)(chunk);
176 new_chunk_size = (chunk_size);
177 if (new_chunk_size > PL_nice_chunk_size) {
178 Safefree(PL_nice_chunk);
179 PL_nice_chunk = (char *) new_chunk;
180 PL_nice_chunk_size = new_chunk_size;
187 # define MEM_LOG_NEW_SV(sv, file, line, func) \
188 Perl_mem_log_new_sv(sv, file, line, func)
189 # define MEM_LOG_DEL_SV(sv, file, line, func) \
190 Perl_mem_log_del_sv(sv, file, line, func)
192 # define MEM_LOG_NEW_SV(sv, file, line, func) NOOP
193 # define MEM_LOG_DEL_SV(sv, file, line, func) NOOP
196 #ifdef DEBUG_LEAKING_SCALARS
197 # define FREE_SV_DEBUG_FILE(sv) Safefree((sv)->sv_debug_file)
198 # define DEBUG_SV_SERIAL(sv) \
199 DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) del_SV\n", \
200 PTR2UV(sv), (long)(sv)->sv_debug_serial))
202 # define FREE_SV_DEBUG_FILE(sv)
203 # define DEBUG_SV_SERIAL(sv) NOOP
207 # define SvARENA_CHAIN(sv) ((sv)->sv_u.svu_rv)
208 # define SvARENA_CHAIN_SET(sv,val) (sv)->sv_u.svu_rv = MUTABLE_SV((val))
209 /* Whilst I'd love to do this, it seems that things like to check on
211 # define POSION_SV_HEAD(sv) PoisonNew(sv, 1, struct STRUCT_SV)
213 # define POSION_SV_HEAD(sv) PoisonNew(&SvANY(sv), 1, void *), \
214 PoisonNew(&SvREFCNT(sv), 1, U32)
216 # define SvARENA_CHAIN(sv) SvANY(sv)
217 # define SvARENA_CHAIN_SET(sv,val) SvANY(sv) = (void *)(val)
218 # define POSION_SV_HEAD(sv)
221 /* Mark an SV head as unused, and add to free list.
223 * If SVf_BREAK is set, skip adding it to the free list, as this SV had
224 * its refcount artificially decremented during global destruction, so
225 * there may be dangling pointers to it. The last thing we want in that
226 * case is for it to be reused. */
228 #define plant_SV(p) \
230 const U32 old_flags = SvFLAGS(p); \
231 MEM_LOG_DEL_SV(p, __FILE__, __LINE__, FUNCTION__); \
232 DEBUG_SV_SERIAL(p); \
233 FREE_SV_DEBUG_FILE(p); \
235 SvFLAGS(p) = SVTYPEMASK; \
236 if (!(old_flags & SVf_BREAK)) { \
237 SvARENA_CHAIN_SET(p, PL_sv_root); \
243 #define uproot_SV(p) \
246 PL_sv_root = MUTABLE_SV(SvARENA_CHAIN(p)); \
251 /* make some more SVs by adding another arena */
260 sv_add_arena(PL_nice_chunk, PL_nice_chunk_size, 0);
261 PL_nice_chunk = NULL;
262 PL_nice_chunk_size = 0;
265 char *chunk; /* must use New here to match call to */
266 Newx(chunk,PERL_ARENA_SIZE,char); /* Safefree() in sv_free_arenas() */
267 sv_add_arena(chunk, PERL_ARENA_SIZE, 0);
273 /* new_SV(): return a new, empty SV head */
275 #ifdef DEBUG_LEAKING_SCALARS
276 /* provide a real function for a debugger to play with */
278 S_new_SV(pTHX_ const char *file, int line, const char *func)
285 sv = S_more_sv(aTHX);
289 sv->sv_debug_optype = PL_op ? PL_op->op_type : 0;
290 sv->sv_debug_line = (U16) (PL_parser && PL_parser->copline != NOLINE
296 sv->sv_debug_inpad = 0;
297 sv->sv_debug_cloned = 0;
298 sv->sv_debug_file = PL_curcop ? savepv(CopFILE(PL_curcop)): NULL;
300 sv->sv_debug_serial = PL_sv_serial++;
302 MEM_LOG_NEW_SV(sv, file, line, func);
303 DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%"UVxf": (%05ld) new_SV (from %s:%d [%s])\n",
304 PTR2UV(sv), (long)sv->sv_debug_serial, file, line, func));
308 # define new_SV(p) (p)=S_new_SV(aTHX_ __FILE__, __LINE__, FUNCTION__)
316 (p) = S_more_sv(aTHX); \
320 MEM_LOG_NEW_SV(p, __FILE__, __LINE__, FUNCTION__); \
325 /* del_SV(): return an empty SV head to the free list */
338 S_del_sv(pTHX_ SV *p)
342 PERL_ARGS_ASSERT_DEL_SV;
347 for (sva = PL_sv_arenaroot; sva; sva = MUTABLE_SV(SvANY(sva))) {
348 const SV * const sv = sva + 1;
349 const SV * const svend = &sva[SvREFCNT(sva)];
350 if (p >= sv && p < svend) {
356 if (ckWARN_d(WARN_INTERNAL))
357 Perl_warner(aTHX_ packWARN(WARN_INTERNAL),
358 "Attempt to free non-arena SV: 0x%"UVxf
359 pTHX__FORMAT, PTR2UV(p) pTHX__VALUE);
366 #else /* ! DEBUGGING */
368 #define del_SV(p) plant_SV(p)
370 #endif /* DEBUGGING */
374 =head1 SV Manipulation Functions
376 =for apidoc sv_add_arena
378 Given a chunk of memory, link it to the head of the list of arenas,
379 and split it into a list of free SVs.
385 S_sv_add_arena(pTHX_ char *const ptr, const U32 size, const U32 flags)
388 SV *const sva = MUTABLE_SV(ptr);
392 PERL_ARGS_ASSERT_SV_ADD_ARENA;
394 /* The first SV in an arena isn't an SV. */
395 SvANY(sva) = (void *) PL_sv_arenaroot; /* ptr to next arena */
396 SvREFCNT(sva) = size / sizeof(SV); /* number of SV slots */
397 SvFLAGS(sva) = flags; /* FAKE if not to be freed */
399 PL_sv_arenaroot = sva;
400 PL_sv_root = sva + 1;
402 svend = &sva[SvREFCNT(sva) - 1];
405 SvARENA_CHAIN_SET(sv, (sv + 1));
409 /* Must always set typemask because it's always checked in on cleanup
410 when the arenas are walked looking for objects. */
411 SvFLAGS(sv) = SVTYPEMASK;
414 SvARENA_CHAIN_SET(sv, 0);
418 SvFLAGS(sv) = SVTYPEMASK;
421 /* visit(): call the named function for each non-free SV in the arenas
422 * whose flags field matches the flags/mask args. */
425 S_visit(pTHX_ SVFUNC_t f, const U32 flags, const U32 mask)
431 PERL_ARGS_ASSERT_VISIT;
433 for (sva = PL_sv_arenaroot; sva; sva = MUTABLE_SV(SvANY(sva))) {
434 register const SV * const svend = &sva[SvREFCNT(sva)];
436 for (sv = sva + 1; sv < svend; ++sv) {
437 if (SvTYPE(sv) != SVTYPEMASK
438 && (sv->sv_flags & mask) == flags
451 /* called by sv_report_used() for each live SV */
454 do_report_used(pTHX_ SV *const sv)
456 if (SvTYPE(sv) != SVTYPEMASK) {
457 PerlIO_printf(Perl_debug_log, "****\n");
464 =for apidoc sv_report_used
466 Dump the contents of all SVs not yet freed. (Debugging aid).
472 Perl_sv_report_used(pTHX)
475 visit(do_report_used, 0, 0);
481 /* called by sv_clean_objs() for each live SV */
484 do_clean_objs(pTHX_ SV *const ref)
489 SV * const target = SvRV(ref);
490 if (SvOBJECT(target)) {
491 DEBUG_D((PerlIO_printf(Perl_debug_log, "Cleaning object ref:\n "), sv_dump(ref)));
492 if (SvWEAKREF(ref)) {
493 sv_del_backref(target, ref);
499 SvREFCNT_dec(target);
504 /* XXX Might want to check arrays, etc. */
507 /* called by sv_clean_objs() for each live SV */
509 #ifndef DISABLE_DESTRUCTOR_KLUDGE
511 do_clean_named_objs(pTHX_ SV *const sv)
514 assert(SvTYPE(sv) == SVt_PVGV);
515 assert(isGV_with_GP(sv));
518 #ifdef PERL_DONT_CREATE_GVSV
521 SvOBJECT(GvSV(sv))) ||
522 (GvAV(sv) && SvOBJECT(GvAV(sv))) ||
523 (GvHV(sv) && SvOBJECT(GvHV(sv))) ||
524 /* In certain rare cases GvIOp(sv) can be NULL, which would make SvOBJECT(GvIO(sv)) dereference NULL. */
525 (GvIO(sv) ? (SvFLAGS(GvIOp(sv)) & SVs_OBJECT) : 0) ||
526 (GvCV(sv) && SvOBJECT(GvCV(sv))) )
528 DEBUG_D((PerlIO_printf(Perl_debug_log, "Cleaning named glob object:\n "), sv_dump(sv)));
529 SvFLAGS(sv) |= SVf_BREAK;
537 =for apidoc sv_clean_objs
539 Attempt to destroy all objects not yet freed
545 Perl_sv_clean_objs(pTHX)
548 PL_in_clean_objs = TRUE;
549 visit(do_clean_objs, SVf_ROK, SVf_ROK);
550 #ifndef DISABLE_DESTRUCTOR_KLUDGE
551 /* some barnacles may yet remain, clinging to typeglobs */
552 visit(do_clean_named_objs, SVt_PVGV|SVpgv_GP, SVTYPEMASK|SVp_POK|SVpgv_GP);
554 PL_in_clean_objs = FALSE;
557 /* called by sv_clean_all() for each live SV */
560 do_clean_all(pTHX_ SV *const sv)
563 if (sv == (const SV *) PL_fdpid || sv == (const SV *)PL_strtab) {
564 /* don't clean pid table and strtab */
567 DEBUG_D((PerlIO_printf(Perl_debug_log, "Cleaning loops: SV at 0x%"UVxf"\n", PTR2UV(sv)) ));
568 SvFLAGS(sv) |= SVf_BREAK;
573 =for apidoc sv_clean_all
575 Decrement the refcnt of each remaining SV, possibly triggering a
576 cleanup. This function may have to be called multiple times to free
577 SVs which are in complex self-referential hierarchies.
583 Perl_sv_clean_all(pTHX)
587 PL_in_clean_all = TRUE;
588 cleaned = visit(do_clean_all, 0,0);
589 PL_in_clean_all = FALSE;
594 ARENASETS: a meta-arena implementation which separates arena-info
595 into struct arena_set, which contains an array of struct
596 arena_descs, each holding info for a single arena. By separating
597 the meta-info from the arena, we recover the 1st slot, formerly
598 borrowed for list management. The arena_set is about the size of an
599 arena, avoiding the needless malloc overhead of a naive linked-list.
601 The cost is 1 arena-set malloc per ~320 arena-mallocs, + the unused
602 memory in the last arena-set (1/2 on average). In trade, we get
603 back the 1st slot in each arena (ie 1.7% of a CV-arena, less for
604 smaller types). The recovery of the wasted space allows use of
605 small arenas for large, rare body types, by changing array* fields
606 in body_details_by_type[] below.
609 char *arena; /* the raw storage, allocated aligned */
610 size_t size; /* its size ~4k typ */
611 U32 misc; /* type, and in future other things. */
616 /* Get the maximum number of elements in set[] such that struct arena_set
617 will fit within PERL_ARENA_SIZE, which is probably just under 4K, and
618 therefore likely to be 1 aligned memory page. */
620 #define ARENAS_PER_SET ((PERL_ARENA_SIZE - sizeof(struct arena_set*) \
621 - 2 * sizeof(int)) / sizeof (struct arena_desc))
624 struct arena_set* next;
625 unsigned int set_size; /* ie ARENAS_PER_SET */
626 unsigned int curr; /* index of next available arena-desc */
627 struct arena_desc set[ARENAS_PER_SET];
631 =for apidoc sv_free_arenas
633 Deallocate the memory used by all arenas. Note that all the individual SV
634 heads and bodies within the arenas must already have been freed.
639 Perl_sv_free_arenas(pTHX)
646 /* Free arenas here, but be careful about fake ones. (We assume
647 contiguity of the fake ones with the corresponding real ones.) */
649 for (sva = PL_sv_arenaroot; sva; sva = svanext) {
650 svanext = MUTABLE_SV(SvANY(sva));
651 while (svanext && SvFAKE(svanext))
652 svanext = MUTABLE_SV(SvANY(svanext));
659 struct arena_set *aroot = (struct arena_set*) PL_body_arenas;
662 struct arena_set *current = aroot;
665 assert(aroot->set[i].arena);
666 Safefree(aroot->set[i].arena);
674 i = PERL_ARENA_ROOTS_SIZE;
676 PL_body_roots[i] = 0;
678 Safefree(PL_nice_chunk);
679 PL_nice_chunk = NULL;
680 PL_nice_chunk_size = 0;
686 Here are mid-level routines that manage the allocation of bodies out
687 of the various arenas. There are 5 kinds of arenas:
689 1. SV-head arenas, which are discussed and handled above
690 2. regular body arenas
691 3. arenas for reduced-size bodies
693 5. pte arenas (thread related)
695 Arena types 2 & 3 are chained by body-type off an array of
696 arena-root pointers, which is indexed by svtype. Some of the
697 larger/less used body types are malloced singly, since a large
698 unused block of them is wasteful. Also, several svtypes dont have
699 bodies; the data fits into the sv-head itself. The arena-root
700 pointer thus has a few unused root-pointers (which may be hijacked
701 later for arena types 4,5)
703 3 differs from 2 as an optimization; some body types have several
704 unused fields in the front of the structure (which are kept in-place
705 for consistency). These bodies can be allocated in smaller chunks,
706 because the leading fields arent accessed. Pointers to such bodies
707 are decremented to point at the unused 'ghost' memory, knowing that
708 the pointers are used with offsets to the real memory.
710 HE, HEK arenas are managed separately, with separate code, but may
711 be merge-able later..
713 PTE arenas are not sv-bodies, but they share these mid-level
714 mechanics, so are considered here. The new mid-level mechanics rely
715 on the sv_type of the body being allocated, so we just reserve one
716 of the unused body-slots for PTEs, then use it in those (2) PTE
717 contexts below (line ~10k)
720 /* get_arena(size): this creates custom-sized arenas
721 TBD: export properly for hv.c: S_more_he().
724 Perl_get_arena(pTHX_ const size_t arena_size, const U32 misc)
727 struct arena_desc* adesc;
728 struct arena_set *aroot = (struct arena_set*) PL_body_arenas;
731 /* shouldnt need this
732 if (!arena_size) arena_size = PERL_ARENA_SIZE;
735 /* may need new arena-set to hold new arena */
736 if (!aroot || aroot->curr >= aroot->set_size) {
737 struct arena_set *newroot;
738 Newxz(newroot, 1, struct arena_set);
739 newroot->set_size = ARENAS_PER_SET;
740 newroot->next = aroot;
742 PL_body_arenas = (void *) newroot;
743 DEBUG_m(PerlIO_printf(Perl_debug_log, "new arenaset %p\n", (void*)aroot));
746 /* ok, now have arena-set with at least 1 empty/available arena-desc */
747 curr = aroot->curr++;
748 adesc = &(aroot->set[curr]);
749 assert(!adesc->arena);
751 Newx(adesc->arena, arena_size, char);
752 adesc->size = arena_size;
754 DEBUG_m(PerlIO_printf(Perl_debug_log, "arena %d added: %p size %"UVuf"\n",
755 curr, (void*)adesc->arena, (UV)arena_size));
761 /* return a thing to the free list */
763 #define del_body(thing, root) \
765 void ** const thing_copy = (void **)thing;\
766 *thing_copy = *root; \
767 *root = (void*)thing_copy; \
772 =head1 SV-Body Allocation
774 Allocation of SV-bodies is similar to SV-heads, differing as follows;
775 the allocation mechanism is used for many body types, so is somewhat
776 more complicated, it uses arena-sets, and has no need for still-live
779 At the outermost level, (new|del)_X*V macros return bodies of the
780 appropriate type. These macros call either (new|del)_body_type or
781 (new|del)_body_allocated macro pairs, depending on specifics of the
782 type. Most body types use the former pair, the latter pair is used to
783 allocate body types with "ghost fields".
785 "ghost fields" are fields that are unused in certain types, and
786 consequently don't need to actually exist. They are declared because
787 they're part of a "base type", which allows use of functions as
788 methods. The simplest examples are AVs and HVs, 2 aggregate types
789 which don't use the fields which support SCALAR semantics.
791 For these types, the arenas are carved up into appropriately sized
792 chunks, we thus avoid wasted memory for those unaccessed members.
793 When bodies are allocated, we adjust the pointer back in memory by the
794 size of the part not allocated, so it's as if we allocated the full
795 structure. (But things will all go boom if you write to the part that
796 is "not there", because you'll be overwriting the last members of the
797 preceding structure in memory.)
799 We calculate the correction using the STRUCT_OFFSET macro on the first
800 member present. If the allocated structure is smaller (no initial NV
801 actually allocated) then the net effect is to subtract the size of the NV
802 from the pointer, to return a new pointer as if an initial NV were actually
803 allocated. (We were using structures named *_allocated for this, but
804 this turned out to be a subtle bug, because a structure without an NV
805 could have a lower alignment constraint, but the compiler is allowed to
806 optimised accesses based on the alignment constraint of the actual pointer
807 to the full structure, for example, using a single 64 bit load instruction
808 because it "knows" that two adjacent 32 bit members will be 8-byte aligned.)
810 This is the same trick as was used for NV and IV bodies. Ironically it
811 doesn't need to be used for NV bodies any more, because NV is now at
812 the start of the structure. IV bodies don't need it either, because
813 they are no longer allocated.
815 In turn, the new_body_* allocators call S_new_body(), which invokes
816 new_body_inline macro, which takes a lock, and takes a body off the
817 linked list at PL_body_roots[sv_type], calling S_more_bodies() if
818 necessary to refresh an empty list. Then the lock is released, and
819 the body is returned.
821 S_more_bodies calls get_arena(), and carves it up into an array of N
822 bodies, which it strings into a linked list. It looks up arena-size
823 and body-size from the body_details table described below, thus
824 supporting the multiple body-types.
826 If PURIFY is defined, or PERL_ARENA_SIZE=0, arenas are not used, and
827 the (new|del)_X*V macros are mapped directly to malloc/free.
833 For each sv-type, struct body_details bodies_by_type[] carries
834 parameters which control these aspects of SV handling:
836 Arena_size determines whether arenas are used for this body type, and if
837 so, how big they are. PURIFY or PERL_ARENA_SIZE=0 set this field to
838 zero, forcing individual mallocs and frees.
840 Body_size determines how big a body is, and therefore how many fit into
841 each arena. Offset carries the body-pointer adjustment needed for
842 "ghost fields", and is used in *_allocated macros.
844 But its main purpose is to parameterize info needed in
845 Perl_sv_upgrade(). The info here dramatically simplifies the function
846 vs the implementation in 5.8.8, making it table-driven. All fields
847 are used for this, except for arena_size.
849 For the sv-types that have no bodies, arenas are not used, so those
850 PL_body_roots[sv_type] are unused, and can be overloaded. In
851 something of a special case, SVt_NULL is borrowed for HE arenas;
852 PL_body_roots[HE_SVSLOT=SVt_NULL] is filled by S_more_he, but the
853 bodies_by_type[SVt_NULL] slot is not used, as the table is not
856 PTEs also use arenas, but are never seen in Perl_sv_upgrade. Nonetheless,
857 they get their own slot in bodies_by_type[PTE_SVSLOT =SVt_IV], so they can
858 just use the same allocation semantics. At first, PTEs were also
859 overloaded to a non-body sv-type, but this yielded hard-to-find malloc
860 bugs, so was simplified by claiming a new slot. This choice has no
861 consequence at this time.
865 struct body_details {
866 U8 body_size; /* Size to allocate */
867 U8 copy; /* Size of structure to copy (may be shorter) */
869 unsigned int type : 4; /* We have space for a sanity check. */
870 unsigned int cant_upgrade : 1; /* Cannot upgrade this type */
871 unsigned int zero_nv : 1; /* zero the NV when upgrading from this */
872 unsigned int arena : 1; /* Allocated from an arena */
873 size_t arena_size; /* Size of arena to allocate */
881 /* With -DPURFIY we allocate everything directly, and don't use arenas.
882 This seems a rather elegant way to simplify some of the code below. */
883 #define HASARENA FALSE
885 #define HASARENA TRUE
887 #define NOARENA FALSE
889 /* Size the arenas to exactly fit a given number of bodies. A count
890 of 0 fits the max number bodies into a PERL_ARENA_SIZE.block,
891 simplifying the default. If count > 0, the arena is sized to fit
892 only that many bodies, allowing arenas to be used for large, rare
893 bodies (XPVFM, XPVIO) without undue waste. The arena size is
894 limited by PERL_ARENA_SIZE, so we can safely oversize the
897 #define FIT_ARENA0(body_size) \
898 ((size_t)(PERL_ARENA_SIZE / body_size) * body_size)
899 #define FIT_ARENAn(count,body_size) \
900 ( count * body_size <= PERL_ARENA_SIZE) \
901 ? count * body_size \
902 : FIT_ARENA0 (body_size)
903 #define FIT_ARENA(count,body_size) \
905 ? FIT_ARENAn (count, body_size) \
906 : FIT_ARENA0 (body_size)
908 /* Calculate the length to copy. Specifically work out the length less any
909 final padding the compiler needed to add. See the comment in sv_upgrade
910 for why copying the padding proved to be a bug. */
912 #define copy_length(type, last_member) \
913 STRUCT_OFFSET(type, last_member) \
914 + sizeof (((type*)SvANY((const SV *)0))->last_member)
916 static const struct body_details bodies_by_type[] = {
917 { sizeof(HE), 0, 0, SVt_NULL,
918 FALSE, NONV, NOARENA, FIT_ARENA(0, sizeof(HE)) },
920 /* The bind placeholder pretends to be an RV for now.
921 Also it's marked as "can't upgrade" to stop anyone using it before it's
923 { 0, 0, 0, SVt_BIND, TRUE, NONV, NOARENA, 0 },
925 /* IVs are in the head, so the allocation size is 0.
926 However, the slot is overloaded for PTEs. */
927 { sizeof(struct ptr_tbl_ent), /* This is used for PTEs. */
928 sizeof(IV), /* This is used to copy out the IV body. */
929 STRUCT_OFFSET(XPVIV, xiv_iv), SVt_IV, FALSE, NONV,
930 NOARENA /* IVS don't need an arena */,
931 /* But PTEs need to know the size of their arena */
932 FIT_ARENA(0, sizeof(struct ptr_tbl_ent))
935 /* 8 bytes on most ILP32 with IEEE doubles */
936 { sizeof(NV), sizeof(NV), 0, SVt_NV, FALSE, HADNV, HASARENA,
937 FIT_ARENA(0, sizeof(NV)) },
939 /* 8 bytes on most ILP32 with IEEE doubles */
940 { sizeof(XPV) - STRUCT_OFFSET(XPV, xpv_cur),
941 copy_length(XPV, xpv_len) - STRUCT_OFFSET(XPV, xpv_cur),
942 + STRUCT_OFFSET(XPV, xpv_cur),
943 SVt_PV, FALSE, NONV, HASARENA,
944 FIT_ARENA(0, sizeof(XPV) - STRUCT_OFFSET(XPV, xpv_cur)) },
947 { sizeof(XPVIV) - STRUCT_OFFSET(XPV, xpv_cur),
948 copy_length(XPVIV, xiv_u) - STRUCT_OFFSET(XPV, xpv_cur),
949 + STRUCT_OFFSET(XPVIV, xpv_cur),
950 SVt_PVIV, FALSE, NONV, HASARENA,
951 FIT_ARENA(0, sizeof(XPV) - STRUCT_OFFSET(XPV, xpv_cur)) },
954 { sizeof(XPVNV), copy_length(XPVNV, xiv_u), 0, SVt_PVNV, FALSE, HADNV,
955 HASARENA, FIT_ARENA(0, sizeof(XPVNV)) },
958 { sizeof(XPVMG), copy_length(XPVMG, xmg_stash), 0, SVt_PVMG, FALSE, HADNV,
959 HASARENA, FIT_ARENA(0, sizeof(XPVMG)) },
962 { sizeof(regexp) - STRUCT_OFFSET(regexp, xpv_cur),
963 sizeof(regexp) - STRUCT_OFFSET(regexp, xpv_cur),
964 + STRUCT_OFFSET(regexp, xpv_cur),
965 SVt_REGEXP, FALSE, NONV, HASARENA,
966 FIT_ARENA(0, sizeof(regexp) - STRUCT_OFFSET(regexp, xpv_cur))
970 { sizeof(XPVGV), sizeof(XPVGV), 0, SVt_PVGV, TRUE, HADNV,
971 HASARENA, FIT_ARENA(0, sizeof(XPVGV)) },
974 { sizeof(XPVLV), sizeof(XPVLV), 0, SVt_PVLV, TRUE, HADNV,
975 HASARENA, FIT_ARENA(0, sizeof(XPVLV)) },
977 { sizeof(XPVAV) - STRUCT_OFFSET(XPVAV, xav_fill),
978 copy_length(XPVAV, xmg_stash) - STRUCT_OFFSET(XPVAV, xav_fill),
979 + STRUCT_OFFSET(XPVAV, xav_fill),
980 SVt_PVAV, TRUE, NONV, HASARENA,
981 FIT_ARENA(0, sizeof(XPVAV) - STRUCT_OFFSET(XPVAV, xav_fill)) },
983 { sizeof(XPVHV) - STRUCT_OFFSET(XPVHV, xhv_fill),
984 copy_length(XPVHV, xmg_stash) - STRUCT_OFFSET(XPVHV, xhv_fill),
985 + STRUCT_OFFSET(XPVHV, xhv_fill),
986 SVt_PVHV, TRUE, NONV, HASARENA,
987 FIT_ARENA(0, sizeof(XPVHV) - STRUCT_OFFSET(XPVHV, xhv_fill)) },
990 { sizeof(XPVCV) - STRUCT_OFFSET(XPVCV, xpv_cur),
991 sizeof(XPVCV) - STRUCT_OFFSET(XPVCV, xpv_cur),
992 + STRUCT_OFFSET(XPVCV, xpv_cur),
993 SVt_PVCV, TRUE, NONV, HASARENA,
994 FIT_ARENA(0, sizeof(XPVCV) - STRUCT_OFFSET(XPVCV, xpv_cur)) },
996 { sizeof(XPVFM) - STRUCT_OFFSET(XPVFM, xpv_cur),
997 sizeof(XPVFM) - STRUCT_OFFSET(XPVFM, xpv_cur),
998 + STRUCT_OFFSET(XPVFM, xpv_cur),
999 SVt_PVFM, TRUE, NONV, NOARENA,
1000 FIT_ARENA(20, sizeof(XPVFM) - STRUCT_OFFSET(XPVFM, xpv_cur)) },
1002 /* XPVIO is 84 bytes, fits 48x */
1003 { sizeof(XPVIO) - STRUCT_OFFSET(XPVIO, xpv_cur),
1004 sizeof(XPVIO) - STRUCT_OFFSET(XPVIO, xpv_cur),
1005 + STRUCT_OFFSET(XPVIO, xpv_cur),
1006 SVt_PVIO, TRUE, NONV, HASARENA,
1007 FIT_ARENA(24, sizeof(XPVIO) - STRUCT_OFFSET(XPVIO, xpv_cur)) },
1010 #define new_body_type(sv_type) \
1011 (void *)((char *)S_new_body(aTHX_ sv_type))
1013 #define del_body_type(p, sv_type) \
1014 del_body(p, &PL_body_roots[sv_type])
1017 #define new_body_allocated(sv_type) \
1018 (void *)((char *)S_new_body(aTHX_ sv_type) \
1019 - bodies_by_type[sv_type].offset)
1021 #define del_body_allocated(p, sv_type) \
1022 del_body(p + bodies_by_type[sv_type].offset, &PL_body_roots[sv_type])
1025 #define my_safemalloc(s) (void*)safemalloc(s)
1026 #define my_safecalloc(s) (void*)safecalloc(s, 1)
1027 #define my_safefree(p) safefree((char*)p)
1031 #define new_XNV() my_safemalloc(sizeof(XPVNV))
1032 #define del_XNV(p) my_safefree(p)
1034 #define new_XPVNV() my_safemalloc(sizeof(XPVNV))
1035 #define del_XPVNV(p) my_safefree(p)
1037 #define new_XPVAV() my_safemalloc(sizeof(XPVAV))
1038 #define del_XPVAV(p) my_safefree(p)
1040 #define new_XPVHV() my_safemalloc(sizeof(XPVHV))
1041 #define del_XPVHV(p) my_safefree(p)
1043 #define new_XPVMG() my_safemalloc(sizeof(XPVMG))
1044 #define del_XPVMG(p) my_safefree(p)
1046 #define new_XPVGV() my_safemalloc(sizeof(XPVGV))
1047 #define del_XPVGV(p) my_safefree(p)
1051 #define new_XNV() new_body_type(SVt_NV)
1052 #define del_XNV(p) del_body_type(p, SVt_NV)
1054 #define new_XPVNV() new_body_type(SVt_PVNV)
1055 #define del_XPVNV(p) del_body_type(p, SVt_PVNV)
1057 #define new_XPVAV() new_body_allocated(SVt_PVAV)
1058 #define del_XPVAV(p) del_body_allocated(p, SVt_PVAV)
1060 #define new_XPVHV() new_body_allocated(SVt_PVHV)
1061 #define del_XPVHV(p) del_body_allocated(p, SVt_PVHV)
1063 #define new_XPVMG() new_body_type(SVt_PVMG)
1064 #define del_XPVMG(p) del_body_type(p, SVt_PVMG)
1066 #define new_XPVGV() new_body_type(SVt_PVGV)
1067 #define del_XPVGV(p) del_body_type(p, SVt_PVGV)
1071 /* no arena for you! */
1073 #define new_NOARENA(details) \
1074 my_safemalloc((details)->body_size + (details)->offset)
1075 #define new_NOARENAZ(details) \
1076 my_safecalloc((details)->body_size + (details)->offset)
1079 S_more_bodies (pTHX_ const svtype sv_type)
1082 void ** const root = &PL_body_roots[sv_type];
1083 const struct body_details * const bdp = &bodies_by_type[sv_type];
1084 const size_t body_size = bdp->body_size;
1087 const size_t arena_size = Perl_malloc_good_size(bdp->arena_size);
1088 #if defined(DEBUGGING) && !defined(PERL_GLOBAL_STRUCT_PRIVATE)
1089 static bool done_sanity_check;
1091 /* PERL_GLOBAL_STRUCT_PRIVATE cannot coexist with global
1092 * variables like done_sanity_check. */
1093 if (!done_sanity_check) {
1094 unsigned int i = SVt_LAST;
1096 done_sanity_check = TRUE;
1099 assert (bodies_by_type[i].type == i);
1103 assert(bdp->arena_size);
1105 start = (char*) Perl_get_arena(aTHX_ arena_size, sv_type);
1107 end = start + arena_size - 2 * body_size;
1109 /* computed count doesnt reflect the 1st slot reservation */
1110 #if defined(MYMALLOC) || defined(HAS_MALLOC_GOOD_SIZE)
1111 DEBUG_m(PerlIO_printf(Perl_debug_log,
1112 "arena %p end %p arena-size %d (from %d) type %d "
1114 (void*)start, (void*)end, (int)arena_size,
1115 (int)bdp->arena_size, sv_type, (int)body_size,
1116 (int)arena_size / (int)body_size));
1118 DEBUG_m(PerlIO_printf(Perl_debug_log,
1119 "arena %p end %p arena-size %d type %d size %d ct %d\n",
1120 (void*)start, (void*)end,
1121 (int)bdp->arena_size, sv_type, (int)body_size,
1122 (int)bdp->arena_size / (int)body_size));
1124 *root = (void *)start;
1126 while (start <= end) {
1127 char * const next = start + body_size;
1128 *(void**) start = (void *)next;
1131 *(void **)start = 0;
1136 /* grab a new thing from the free list, allocating more if necessary.
1137 The inline version is used for speed in hot routines, and the
1138 function using it serves the rest (unless PURIFY).
1140 #define new_body_inline(xpv, sv_type) \
1142 void ** const r3wt = &PL_body_roots[sv_type]; \
1143 xpv = (PTR_TBL_ENT_t*) (*((void **)(r3wt)) \
1144 ? *((void **)(r3wt)) : more_bodies(sv_type)); \
1145 *(r3wt) = *(void**)(xpv); \
1151 S_new_body(pTHX_ const svtype sv_type)
1155 new_body_inline(xpv, sv_type);
1161 static const struct body_details fake_rv =
1162 { 0, 0, 0, SVt_IV, FALSE, NONV, NOARENA, 0 };
1165 =for apidoc sv_upgrade
1167 Upgrade an SV to a more complex form. Generally adds a new body type to the
1168 SV, then copies across as much information as possible from the old body.
1169 You generally want to use the C<SvUPGRADE> macro wrapper. See also C<svtype>.
1175 Perl_sv_upgrade(pTHX_ register SV *const sv, svtype new_type)
1180 const svtype old_type = SvTYPE(sv);
1181 const struct body_details *new_type_details;
1182 const struct body_details *old_type_details
1183 = bodies_by_type + old_type;
1184 SV *referant = NULL;
1186 PERL_ARGS_ASSERT_SV_UPGRADE;
1188 if (new_type != SVt_PV && SvIsCOW(sv)) {
1189 sv_force_normal_flags(sv, 0);
1192 if (old_type == new_type)
1195 old_body = SvANY(sv);
1197 /* Copying structures onto other structures that have been neatly zeroed
1198 has a subtle gotcha. Consider XPVMG
1200 +------+------+------+------+------+-------+-------+
1201 | NV | CUR | LEN | IV | MAGIC | STASH |
1202 +------+------+------+------+------+-------+-------+
1203 0 4 8 12 16 20 24 28
1205 where NVs are aligned to 8 bytes, so that sizeof that structure is
1206 actually 32 bytes long, with 4 bytes of padding at the end:
1208 +------+------+------+------+------+-------+-------+------+
1209 | NV | CUR | LEN | IV | MAGIC | STASH | ??? |
1210 +------+------+------+------+------+-------+-------+------+
1211 0 4 8 12 16 20 24 28 32
1213 so what happens if you allocate memory for this structure:
1215 +------+------+------+------+------+-------+-------+------+------+...
1216 | NV | CUR | LEN | IV | MAGIC | STASH | GP | NAME |
1217 +------+------+------+------+------+-------+-------+------+------+...
1218 0 4 8 12 16 20 24 28 32 36
1220 zero it, then copy sizeof(XPVMG) bytes on top of it? Not quite what you
1221 expect, because you copy the area marked ??? onto GP. Now, ??? may have
1222 started out as zero once, but it's quite possible that it isn't. So now,
1223 rather than a nicely zeroed GP, you have it pointing somewhere random.
1226 (In fact, GP ends up pointing at a previous GP structure, because the
1227 principle cause of the padding in XPVMG getting garbage is a copy of
1228 sizeof(XPVMG) bytes from a XPVGV structure in sv_unglob. Right now
1229 this happens to be moot because XPVGV has been re-ordered, with GP
1230 no longer after STASH)
1232 So we are careful and work out the size of used parts of all the
1240 referant = SvRV(sv);
1241 old_type_details = &fake_rv;
1242 if (new_type == SVt_NV)
1243 new_type = SVt_PVNV;
1245 if (new_type < SVt_PVIV) {
1246 new_type = (new_type == SVt_NV)
1247 ? SVt_PVNV : SVt_PVIV;
1252 if (new_type < SVt_PVNV) {
1253 new_type = SVt_PVNV;
1257 assert(new_type > SVt_PV);
1258 assert(SVt_IV < SVt_PV);
1259 assert(SVt_NV < SVt_PV);
1266 /* Because the XPVMG of PL_mess_sv isn't allocated from the arena,
1267 there's no way that it can be safely upgraded, because perl.c
1268 expects to Safefree(SvANY(PL_mess_sv)) */
1269 assert(sv != PL_mess_sv);
1270 /* This flag bit is used to mean other things in other scalar types.
1271 Given that it only has meaning inside the pad, it shouldn't be set
1272 on anything that can get upgraded. */
1273 assert(!SvPAD_TYPED(sv));
1276 if (old_type_details->cant_upgrade)
1277 Perl_croak(aTHX_ "Can't upgrade %s (%" UVuf ") to %" UVuf,
1278 sv_reftype(sv, 0), (UV) old_type, (UV) new_type);
1281 if (old_type > new_type)
1282 Perl_croak(aTHX_ "sv_upgrade from type %d down to type %d",
1283 (int)old_type, (int)new_type);
1285 new_type_details = bodies_by_type + new_type;
1287 SvFLAGS(sv) &= ~SVTYPEMASK;
1288 SvFLAGS(sv) |= new_type;
1290 /* This can't happen, as SVt_NULL is <= all values of new_type, so one of
1291 the return statements above will have triggered. */
1292 assert (new_type != SVt_NULL);
1295 assert(old_type == SVt_NULL);
1296 SvANY(sv) = (XPVIV*)((char*)&(sv->sv_u.svu_iv) - STRUCT_OFFSET(XPVIV, xiv_iv));
1300 assert(old_type == SVt_NULL);
1301 SvANY(sv) = new_XNV();
1306 assert(new_type_details->body_size);
1309 assert(new_type_details->arena);
1310 assert(new_type_details->arena_size);
1311 /* This points to the start of the allocated area. */
1312 new_body_inline(new_body, new_type);
1313 Zero(new_body, new_type_details->body_size, char);
1314 new_body = ((char *)new_body) - new_type_details->offset;
1316 /* We always allocated the full length item with PURIFY. To do this
1317 we fake things so that arena is false for all 16 types.. */
1318 new_body = new_NOARENAZ(new_type_details);
1320 SvANY(sv) = new_body;
1321 if (new_type == SVt_PVAV) {
1325 if (old_type_details->body_size) {
1328 /* It will have been zeroed when the new body was allocated.
1329 Lets not write to it, in case it confuses a write-back
1335 #ifndef NODEFAULT_SHAREKEYS
1336 HvSHAREKEYS_on(sv); /* key-sharing on by default */
1338 HvMAX(sv) = 7; /* (start with 8 buckets) */
1339 if (old_type_details->body_size) {
1342 /* It will have been zeroed when the new body was allocated.
1343 Lets not write to it, in case it confuses a write-back
1348 /* SVt_NULL isn't the only thing upgraded to AV or HV.
1349 The target created by newSVrv also is, and it can have magic.
1350 However, it never has SvPVX set.
1352 if (old_type == SVt_IV) {
1354 } else if (old_type >= SVt_PV) {
1355 assert(SvPVX_const(sv) == 0);
1358 if (old_type >= SVt_PVMG) {
1359 SvMAGIC_set(sv, ((XPVMG*)old_body)->xmg_u.xmg_magic);
1360 SvSTASH_set(sv, ((XPVMG*)old_body)->xmg_stash);
1362 sv->sv_u.svu_array = NULL; /* or svu_hash */
1368 /* XXX Is this still needed? Was it ever needed? Surely as there is
1369 no route from NV to PVIV, NOK can never be true */
1370 assert(!SvNOKp(sv));
1382 assert(new_type_details->body_size);
1383 /* We always allocated the full length item with PURIFY. To do this
1384 we fake things so that arena is false for all 16 types.. */
1385 if(new_type_details->arena) {
1386 /* This points to the start of the allocated area. */
1387 new_body_inline(new_body, new_type);
1388 Zero(new_body, new_type_details->body_size, char);
1389 new_body = ((char *)new_body) - new_type_details->offset;
1391 new_body = new_NOARENAZ(new_type_details);
1393 SvANY(sv) = new_body;
1395 if (old_type_details->copy) {
1396 /* There is now the potential for an upgrade from something without
1397 an offset (PVNV or PVMG) to something with one (PVCV, PVFM) */
1398 int offset = old_type_details->offset;
1399 int length = old_type_details->copy;
1401 if (new_type_details->offset > old_type_details->offset) {
1402 const int difference
1403 = new_type_details->offset - old_type_details->offset;
1404 offset += difference;
1405 length -= difference;
1407 assert (length >= 0);
1409 Copy((char *)old_body + offset, (char *)new_body + offset, length,
1413 #ifndef NV_ZERO_IS_ALLBITS_ZERO
1414 /* If NV 0.0 is stores as all bits 0 then Zero() already creates a
1415 * correct 0.0 for us. Otherwise, if the old body didn't have an
1416 * NV slot, but the new one does, then we need to initialise the
1417 * freshly created NV slot with whatever the correct bit pattern is
1419 if (old_type_details->zero_nv && !new_type_details->zero_nv
1420 && !isGV_with_GP(sv))
1424 if (new_type == SVt_PVIO)
1425 IoPAGE_LEN(sv) = 60;
1426 if (old_type < SVt_PV) {
1427 /* referant will be NULL unless the old type was SVt_IV emulating
1429 sv->sv_u.svu_rv = referant;
1433 Perl_croak(aTHX_ "panic: sv_upgrade to unknown type %lu",
1434 (unsigned long)new_type);
1437 if (old_type_details->arena) {
1438 /* If there was an old body, then we need to free it.
1439 Note that there is an assumption that all bodies of types that
1440 can be upgraded came from arenas. Only the more complex non-
1441 upgradable types are allowed to be directly malloc()ed. */
1443 my_safefree(old_body);
1445 del_body((void*)((char*)old_body + old_type_details->offset),
1446 &PL_body_roots[old_type]);
1452 =for apidoc sv_backoff
1454 Remove any string offset. You should normally use the C<SvOOK_off> macro
1461 Perl_sv_backoff(pTHX_ register SV *const sv)
1464 const char * const s = SvPVX_const(sv);
1466 PERL_ARGS_ASSERT_SV_BACKOFF;
1467 PERL_UNUSED_CONTEXT;
1470 assert(SvTYPE(sv) != SVt_PVHV);
1471 assert(SvTYPE(sv) != SVt_PVAV);
1473 SvOOK_offset(sv, delta);
1475 SvLEN_set(sv, SvLEN(sv) + delta);
1476 SvPV_set(sv, SvPVX(sv) - delta);
1477 Move(s, SvPVX(sv), SvCUR(sv)+1, char);
1478 SvFLAGS(sv) &= ~SVf_OOK;
1485 Expands the character buffer in the SV. If necessary, uses C<sv_unref> and
1486 upgrades the SV to C<SVt_PV>. Returns a pointer to the character buffer.
1487 Use the C<SvGROW> wrapper instead.
1493 Perl_sv_grow(pTHX_ register SV *const sv, register STRLEN newlen)
1497 PERL_ARGS_ASSERT_SV_GROW;
1499 if (PL_madskills && newlen >= 0x100000) {
1500 PerlIO_printf(Perl_debug_log,
1501 "Allocation too large: %"UVxf"\n", (UV)newlen);
1503 #ifdef HAS_64K_LIMIT
1504 if (newlen >= 0x10000) {
1505 PerlIO_printf(Perl_debug_log,
1506 "Allocation too large: %"UVxf"\n", (UV)newlen);
1509 #endif /* HAS_64K_LIMIT */
1512 if (SvTYPE(sv) < SVt_PV) {
1513 sv_upgrade(sv, SVt_PV);
1514 s = SvPVX_mutable(sv);
1516 else if (SvOOK(sv)) { /* pv is offset? */
1518 s = SvPVX_mutable(sv);
1519 if (newlen > SvLEN(sv))
1520 newlen += 10 * (newlen - SvCUR(sv)); /* avoid copy each time */
1521 #ifdef HAS_64K_LIMIT
1522 if (newlen >= 0x10000)
1527 s = SvPVX_mutable(sv);
1529 if (newlen > SvLEN(sv)) { /* need more room? */
1530 #ifndef Perl_safesysmalloc_size
1531 newlen = PERL_STRLEN_ROUNDUP(newlen);
1533 if (SvLEN(sv) && s) {
1534 s = (char*)saferealloc(s, newlen);
1537 s = (char*)safemalloc(newlen);
1538 if (SvPVX_const(sv) && SvCUR(sv)) {
1539 Move(SvPVX_const(sv), s, (newlen < SvCUR(sv)) ? newlen : SvCUR(sv), char);
1543 #ifdef Perl_safesysmalloc_size
1544 /* Do this here, do it once, do it right, and then we will never get
1545 called back into sv_grow() unless there really is some growing
1547 SvLEN_set(sv, Perl_safesysmalloc_size(s));
1549 SvLEN_set(sv, newlen);
1556 =for apidoc sv_setiv
1558 Copies an integer into the given SV, upgrading first if necessary.
1559 Does not handle 'set' magic. See also C<sv_setiv_mg>.
1565 Perl_sv_setiv(pTHX_ register SV *const sv, const IV i)
1569 PERL_ARGS_ASSERT_SV_SETIV;
1571 SV_CHECK_THINKFIRST_COW_DROP(sv);
1572 switch (SvTYPE(sv)) {
1575 sv_upgrade(sv, SVt_IV);
1578 sv_upgrade(sv, SVt_PVIV);
1582 if (!isGV_with_GP(sv))
1589 Perl_croak(aTHX_ "Can't coerce %s to integer in %s", sv_reftype(sv,0),
1593 (void)SvIOK_only(sv); /* validate number */
1599 =for apidoc sv_setiv_mg
1601 Like C<sv_setiv>, but also handles 'set' magic.
1607 Perl_sv_setiv_mg(pTHX_ register SV *const sv, const IV i)
1609 PERL_ARGS_ASSERT_SV_SETIV_MG;
1616 =for apidoc sv_setuv
1618 Copies an unsigned integer into the given SV, upgrading first if necessary.
1619 Does not handle 'set' magic. See also C<sv_setuv_mg>.
1625 Perl_sv_setuv(pTHX_ register SV *const sv, const UV u)
1627 PERL_ARGS_ASSERT_SV_SETUV;
1629 /* With these two if statements:
1630 u=1.49 s=0.52 cu=72.49 cs=10.64 scripts=270 tests=20865
1633 u=1.35 s=0.47 cu=73.45 cs=11.43 scripts=270 tests=20865
1635 If you wish to remove them, please benchmark to see what the effect is
1637 if (u <= (UV)IV_MAX) {
1638 sv_setiv(sv, (IV)u);
1647 =for apidoc sv_setuv_mg
1649 Like C<sv_setuv>, but also handles 'set' magic.
1655 Perl_sv_setuv_mg(pTHX_ register SV *const sv, const UV u)
1657 PERL_ARGS_ASSERT_SV_SETUV_MG;
1664 =for apidoc sv_setnv
1666 Copies a double into the given SV, upgrading first if necessary.
1667 Does not handle 'set' magic. See also C<sv_setnv_mg>.
1673 Perl_sv_setnv(pTHX_ register SV *const sv, const NV num)
1677 PERL_ARGS_ASSERT_SV_SETNV;
1679 SV_CHECK_THINKFIRST_COW_DROP(sv);
1680 switch (SvTYPE(sv)) {
1683 sv_upgrade(sv, SVt_NV);
1687 sv_upgrade(sv, SVt_PVNV);
1691 if (!isGV_with_GP(sv))
1698 Perl_croak(aTHX_ "Can't coerce %s to number in %s", sv_reftype(sv,0),
1703 (void)SvNOK_only(sv); /* validate number */
1708 =for apidoc sv_setnv_mg
1710 Like C<sv_setnv>, but also handles 'set' magic.
1716 Perl_sv_setnv_mg(pTHX_ register SV *const sv, const NV num)
1718 PERL_ARGS_ASSERT_SV_SETNV_MG;
1724 /* Print an "isn't numeric" warning, using a cleaned-up,
1725 * printable version of the offending string
1729 S_not_a_number(pTHX_ SV *const sv)
1736 PERL_ARGS_ASSERT_NOT_A_NUMBER;
1739 dsv = newSVpvs_flags("", SVs_TEMP);
1740 pv = sv_uni_display(dsv, sv, 10, 0);
1743 const char * const limit = tmpbuf + sizeof(tmpbuf) - 8;
1744 /* each *s can expand to 4 chars + "...\0",
1745 i.e. need room for 8 chars */
1747 const char *s = SvPVX_const(sv);
1748 const char * const end = s + SvCUR(sv);
1749 for ( ; s < end && d < limit; s++ ) {
1751 if (ch & 128 && !isPRINT_LC(ch)) {
1760 else if (ch == '\r') {
1764 else if (ch == '\f') {
1768 else if (ch == '\\') {
1772 else if (ch == '\0') {
1776 else if (isPRINT_LC(ch))
1793 Perl_warner(aTHX_ packWARN(WARN_NUMERIC),
1794 "Argument \"%s\" isn't numeric in %s", pv,
1797 Perl_warner(aTHX_ packWARN(WARN_NUMERIC),
1798 "Argument \"%s\" isn't numeric", pv);
1802 =for apidoc looks_like_number
1804 Test if the content of an SV looks like a number (or is a number).
1805 C<Inf> and C<Infinity> are treated as numbers (so will not issue a
1806 non-numeric warning), even if your atof() doesn't grok them.
1812 Perl_looks_like_number(pTHX_ SV *const sv)
1814 register const char *sbegin;
1817 PERL_ARGS_ASSERT_LOOKS_LIKE_NUMBER;
1820 sbegin = SvPVX_const(sv);
1823 else if (SvPOKp(sv))
1824 sbegin = SvPV_const(sv, len);
1826 return SvFLAGS(sv) & (SVf_NOK|SVp_NOK|SVf_IOK|SVp_IOK);
1827 return grok_number(sbegin, len, NULL);
1831 S_glob_2number(pTHX_ GV * const gv)
1833 const U32 wasfake = SvFLAGS(gv) & SVf_FAKE;
1834 SV *const buffer = sv_newmortal();
1836 PERL_ARGS_ASSERT_GLOB_2NUMBER;
1838 /* FAKE globs can get coerced, so need to turn this off temporarily if it
1841 gv_efullname3(buffer, gv, "*");
1842 SvFLAGS(gv) |= wasfake;
1844 /* We know that all GVs stringify to something that is not-a-number,
1845 so no need to test that. */
1846 if (ckWARN(WARN_NUMERIC))
1847 not_a_number(buffer);
1848 /* We just want something true to return, so that S_sv_2iuv_common
1849 can tail call us and return true. */
1853 /* Actually, ISO C leaves conversion of UV to IV undefined, but
1854 until proven guilty, assume that things are not that bad... */
1859 As 64 bit platforms often have an NV that doesn't preserve all bits of
1860 an IV (an assumption perl has been based on to date) it becomes necessary
1861 to remove the assumption that the NV always carries enough precision to
1862 recreate the IV whenever needed, and that the NV is the canonical form.
1863 Instead, IV/UV and NV need to be given equal rights. So as to not lose
1864 precision as a side effect of conversion (which would lead to insanity
1865 and the dragon(s) in t/op/numconvert.t getting very angry) the intent is
1866 1) to distinguish between IV/UV/NV slots that have cached a valid
1867 conversion where precision was lost and IV/UV/NV slots that have a
1868 valid conversion which has lost no precision
1869 2) to ensure that if a numeric conversion to one form is requested that
1870 would lose precision, the precise conversion (or differently
1871 imprecise conversion) is also performed and cached, to prevent
1872 requests for different numeric formats on the same SV causing
1873 lossy conversion chains. (lossless conversion chains are perfectly
1878 SvIOKp is true if the IV slot contains a valid value
1879 SvIOK is true only if the IV value is accurate (UV if SvIOK_UV true)
1880 SvNOKp is true if the NV slot contains a valid value
1881 SvNOK is true only if the NV value is accurate
1884 while converting from PV to NV, check to see if converting that NV to an
1885 IV(or UV) would lose accuracy over a direct conversion from PV to
1886 IV(or UV). If it would, cache both conversions, return NV, but mark
1887 SV as IOK NOKp (ie not NOK).
1889 While converting from PV to IV, check to see if converting that IV to an
1890 NV would lose accuracy over a direct conversion from PV to NV. If it
1891 would, cache both conversions, flag similarly.
1893 Before, the SV value "3.2" could become NV=3.2 IV=3 NOK, IOK quite
1894 correctly because if IV & NV were set NV *always* overruled.
1895 Now, "3.2" will become NV=3.2 IV=3 NOK, IOKp, because the flag's meaning
1896 changes - now IV and NV together means that the two are interchangeable:
1897 SvIVX == (IV) SvNVX && SvNVX == (NV) SvIVX;
1899 The benefit of this is that operations such as pp_add know that if
1900 SvIOK is true for both left and right operands, then integer addition
1901 can be used instead of floating point (for cases where the result won't
1902 overflow). Before, floating point was always used, which could lead to
1903 loss of precision compared with integer addition.
1905 * making IV and NV equal status should make maths accurate on 64 bit
1907 * may speed up maths somewhat if pp_add and friends start to use
1908 integers when possible instead of fp. (Hopefully the overhead in
1909 looking for SvIOK and checking for overflow will not outweigh the
1910 fp to integer speedup)
1911 * will slow down integer operations (callers of SvIV) on "inaccurate"
1912 values, as the change from SvIOK to SvIOKp will cause a call into
1913 sv_2iv each time rather than a macro access direct to the IV slot
1914 * should speed up number->string conversion on integers as IV is
1915 favoured when IV and NV are equally accurate
1917 ####################################################################
1918 You had better be using SvIOK_notUV if you want an IV for arithmetic:
1919 SvIOK is true if (IV or UV), so you might be getting (IV)SvUV.
1920 On the other hand, SvUOK is true iff UV.
1921 ####################################################################
1923 Your mileage will vary depending your CPU's relative fp to integer
1927 #ifndef NV_PRESERVES_UV
1928 # define IS_NUMBER_UNDERFLOW_IV 1
1929 # define IS_NUMBER_UNDERFLOW_UV 2
1930 # define IS_NUMBER_IV_AND_UV 2
1931 # define IS_NUMBER_OVERFLOW_IV 4
1932 # define IS_NUMBER_OVERFLOW_UV 5
1934 /* sv_2iuv_non_preserve(): private routine for use by sv_2iv() and sv_2uv() */
1936 /* For sv_2nv these three cases are "SvNOK and don't bother casting" */
1938 S_sv_2iuv_non_preserve(pTHX_ register SV *const sv
1946 PERL_ARGS_ASSERT_SV_2IUV_NON_PRESERVE;
1948 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));
1949 if (SvNVX(sv) < (NV)IV_MIN) {
1950 (void)SvIOKp_on(sv);
1952 SvIV_set(sv, IV_MIN);
1953 return IS_NUMBER_UNDERFLOW_IV;
1955 if (SvNVX(sv) > (NV)UV_MAX) {
1956 (void)SvIOKp_on(sv);
1959 SvUV_set(sv, UV_MAX);
1960 return IS_NUMBER_OVERFLOW_UV;
1962 (void)SvIOKp_on(sv);
1964 /* Can't use strtol etc to convert this string. (See truth table in
1966 if (SvNVX(sv) <= (UV)IV_MAX) {
1967 SvIV_set(sv, I_V(SvNVX(sv)));
1968 if ((NV)(SvIVX(sv)) == SvNVX(sv)) {
1969 SvIOK_on(sv); /* Integer is precise. NOK, IOK */
1971 /* Integer is imprecise. NOK, IOKp */
1973 return SvNVX(sv) < 0 ? IS_NUMBER_UNDERFLOW_UV : IS_NUMBER_IV_AND_UV;
1976 SvUV_set(sv, U_V(SvNVX(sv)));
1977 if ((NV)(SvUVX(sv)) == SvNVX(sv)) {
1978 if (SvUVX(sv) == UV_MAX) {
1979 /* As we know that NVs don't preserve UVs, UV_MAX cannot
1980 possibly be preserved by NV. Hence, it must be overflow.
1982 return IS_NUMBER_OVERFLOW_UV;
1984 SvIOK_on(sv); /* Integer is precise. NOK, UOK */
1986 /* Integer is imprecise. NOK, IOKp */
1988 return IS_NUMBER_OVERFLOW_IV;
1990 #endif /* !NV_PRESERVES_UV*/
1993 S_sv_2iuv_common(pTHX_ SV *const sv)
1997 PERL_ARGS_ASSERT_SV_2IUV_COMMON;
2000 /* erm. not sure. *should* never get NOKp (without NOK) from sv_2nv
2001 * without also getting a cached IV/UV from it at the same time
2002 * (ie PV->NV conversion should detect loss of accuracy and cache
2003 * IV or UV at same time to avoid this. */
2004 /* IV-over-UV optimisation - choose to cache IV if possible */
2006 if (SvTYPE(sv) == SVt_NV)
2007 sv_upgrade(sv, SVt_PVNV);
2009 (void)SvIOKp_on(sv); /* Must do this first, to clear any SvOOK */
2010 /* < not <= as for NV doesn't preserve UV, ((NV)IV_MAX+1) will almost
2011 certainly cast into the IV range at IV_MAX, whereas the correct
2012 answer is the UV IV_MAX +1. Hence < ensures that dodgy boundary
2014 #if defined(NAN_COMPARE_BROKEN) && defined(Perl_isnan)
2015 if (Perl_isnan(SvNVX(sv))) {
2021 if (SvNVX(sv) < (NV)IV_MAX + 0.5) {
2022 SvIV_set(sv, I_V(SvNVX(sv)));
2023 if (SvNVX(sv) == (NV) SvIVX(sv)
2024 #ifndef NV_PRESERVES_UV
2025 && (((UV)1 << NV_PRESERVES_UV_BITS) >
2026 (UV)(SvIVX(sv) > 0 ? SvIVX(sv) : -SvIVX(sv)))
2027 /* Don't flag it as "accurately an integer" if the number
2028 came from a (by definition imprecise) NV operation, and
2029 we're outside the range of NV integer precision */
2033 SvIOK_on(sv); /* Can this go wrong with rounding? NWC */
2035 /* scalar has trailing garbage, eg "42a" */
2037 DEBUG_c(PerlIO_printf(Perl_debug_log,
2038 "0x%"UVxf" iv(%"NVgf" => %"IVdf") (precise)\n",
2044 /* IV not precise. No need to convert from PV, as NV
2045 conversion would already have cached IV if it detected
2046 that PV->IV would be better than PV->NV->IV
2047 flags already correct - don't set public IOK. */
2048 DEBUG_c(PerlIO_printf(Perl_debug_log,
2049 "0x%"UVxf" iv(%"NVgf" => %"IVdf") (imprecise)\n",
2054 /* Can the above go wrong if SvIVX == IV_MIN and SvNVX < IV_MIN,
2055 but the cast (NV)IV_MIN rounds to a the value less (more
2056 negative) than IV_MIN which happens to be equal to SvNVX ??
2057 Analogous to 0xFFFFFFFFFFFFFFFF rounding up to NV (2**64) and
2058 NV rounding back to 0xFFFFFFFFFFFFFFFF, so UVX == UV(NVX) and
2059 (NV)UVX == NVX are both true, but the values differ. :-(
2060 Hopefully for 2s complement IV_MIN is something like
2061 0x8000000000000000 which will be exact. NWC */
2064 SvUV_set(sv, U_V(SvNVX(sv)));
2066 (SvNVX(sv) == (NV) SvUVX(sv))
2067 #ifndef NV_PRESERVES_UV
2068 /* Make sure it's not 0xFFFFFFFFFFFFFFFF */
2069 /*&& (SvUVX(sv) != UV_MAX) irrelevant with code below */
2070 && (((UV)1 << NV_PRESERVES_UV_BITS) > SvUVX(sv))
2071 /* Don't flag it as "accurately an integer" if the number
2072 came from a (by definition imprecise) NV operation, and
2073 we're outside the range of NV integer precision */
2079 DEBUG_c(PerlIO_printf(Perl_debug_log,
2080 "0x%"UVxf" 2iv(%"UVuf" => %"IVdf") (as unsigned)\n",
2086 else if (SvPOKp(sv) && SvLEN(sv)) {
2088 const int numtype = grok_number(SvPVX_const(sv), SvCUR(sv), &value);
2089 /* We want to avoid a possible problem when we cache an IV/ a UV which
2090 may be later translated to an NV, and the resulting NV is not
2091 the same as the direct translation of the initial string
2092 (eg 123.456 can shortcut to the IV 123 with atol(), but we must
2093 be careful to ensure that the value with the .456 is around if the
2094 NV value is requested in the future).
2096 This means that if we cache such an IV/a UV, we need to cache the
2097 NV as well. Moreover, we trade speed for space, and do not
2098 cache the NV if we are sure it's not needed.
2101 /* SVt_PVNV is one higher than SVt_PVIV, hence this order */
2102 if ((numtype & (IS_NUMBER_IN_UV | IS_NUMBER_NOT_INT))
2103 == IS_NUMBER_IN_UV) {
2104 /* It's definitely an integer, only upgrade to PVIV */
2105 if (SvTYPE(sv) < SVt_PVIV)
2106 sv_upgrade(sv, SVt_PVIV);
2108 } else if (SvTYPE(sv) < SVt_PVNV)
2109 sv_upgrade(sv, SVt_PVNV);
2111 /* If NVs preserve UVs then we only use the UV value if we know that
2112 we aren't going to call atof() below. If NVs don't preserve UVs
2113 then the value returned may have more precision than atof() will
2114 return, even though value isn't perfectly accurate. */
2115 if ((numtype & (IS_NUMBER_IN_UV
2116 #ifdef NV_PRESERVES_UV
2119 )) == IS_NUMBER_IN_UV) {
2120 /* This won't turn off the public IOK flag if it was set above */
2121 (void)SvIOKp_on(sv);
2123 if (!(numtype & IS_NUMBER_NEG)) {
2125 if (value <= (UV)IV_MAX) {
2126 SvIV_set(sv, (IV)value);
2128 /* it didn't overflow, and it was positive. */
2129 SvUV_set(sv, value);
2133 /* 2s complement assumption */
2134 if (value <= (UV)IV_MIN) {
2135 SvIV_set(sv, -(IV)value);
2137 /* Too negative for an IV. This is a double upgrade, but
2138 I'm assuming it will be rare. */
2139 if (SvTYPE(sv) < SVt_PVNV)
2140 sv_upgrade(sv, SVt_PVNV);
2144 SvNV_set(sv, -(NV)value);
2145 SvIV_set(sv, IV_MIN);
2149 /* For !NV_PRESERVES_UV and IS_NUMBER_IN_UV and IS_NUMBER_NOT_INT we
2150 will be in the previous block to set the IV slot, and the next
2151 block to set the NV slot. So no else here. */
2153 if ((numtype & (IS_NUMBER_IN_UV | IS_NUMBER_NOT_INT))
2154 != IS_NUMBER_IN_UV) {
2155 /* It wasn't an (integer that doesn't overflow the UV). */
2156 SvNV_set(sv, Atof(SvPVX_const(sv)));
2158 if (! numtype && ckWARN(WARN_NUMERIC))
2161 #if defined(USE_LONG_DOUBLE)
2162 DEBUG_c(PerlIO_printf(Perl_debug_log, "0x%"UVxf" 2iv(%" PERL_PRIgldbl ")\n",
2163 PTR2UV(sv), SvNVX(sv)));
2165 DEBUG_c(PerlIO_printf(Perl_debug_log, "0x%"UVxf" 2iv(%"NVgf")\n",
2166 PTR2UV(sv), SvNVX(sv)));
2169 #ifdef NV_PRESERVES_UV
2170 (void)SvIOKp_on(sv);
2172 if (SvNVX(sv) < (NV)IV_MAX + 0.5) {
2173 SvIV_set(sv, I_V(SvNVX(sv)));
2174 if ((NV)(SvIVX(sv)) == SvNVX(sv)) {
2177 NOOP; /* Integer is imprecise. NOK, IOKp */
2179 /* UV will not work better than IV */
2181 if (SvNVX(sv) > (NV)UV_MAX) {
2183 /* Integer is inaccurate. NOK, IOKp, is UV */
2184 SvUV_set(sv, UV_MAX);
2186 SvUV_set(sv, U_V(SvNVX(sv)));
2187 /* 0xFFFFFFFFFFFFFFFF not an issue in here, NVs
2188 NV preservse UV so can do correct comparison. */
2189 if ((NV)(SvUVX(sv)) == SvNVX(sv)) {
2192 NOOP; /* Integer is imprecise. NOK, IOKp, is UV */
2197 #else /* NV_PRESERVES_UV */
2198 if ((numtype & (IS_NUMBER_IN_UV | IS_NUMBER_NOT_INT))
2199 == (IS_NUMBER_IN_UV | IS_NUMBER_NOT_INT)) {
2200 /* The IV/UV slot will have been set from value returned by
2201 grok_number above. The NV slot has just been set using
2204 assert (SvIOKp(sv));
2206 if (((UV)1 << NV_PRESERVES_UV_BITS) >
2207 U_V(SvNVX(sv) > 0 ? SvNVX(sv) : -SvNVX(sv))) {
2208 /* Small enough to preserve all bits. */
2209 (void)SvIOKp_on(sv);
2211 SvIV_set(sv, I_V(SvNVX(sv)));
2212 if ((NV)(SvIVX(sv)) == SvNVX(sv))
2214 /* Assumption: first non-preserved integer is < IV_MAX,
2215 this NV is in the preserved range, therefore: */
2216 if (!(U_V(SvNVX(sv) > 0 ? SvNVX(sv) : -SvNVX(sv))
2218 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);
2222 0 0 already failed to read UV.
2223 0 1 already failed to read UV.
2224 1 0 you won't get here in this case. IV/UV
2225 slot set, public IOK, Atof() unneeded.
2226 1 1 already read UV.
2227 so there's no point in sv_2iuv_non_preserve() attempting
2228 to use atol, strtol, strtoul etc. */
2230 sv_2iuv_non_preserve (sv, numtype);
2232 sv_2iuv_non_preserve (sv);
2236 #endif /* NV_PRESERVES_UV */
2237 /* It might be more code efficient to go through the entire logic above
2238 and conditionally set with SvIOKp_on() rather than SvIOK(), but it
2239 gets complex and potentially buggy, so more programmer efficient
2240 to do it this way, by turning off the public flags: */
2242 SvFLAGS(sv) &= ~(SVf_IOK|SVf_NOK);
2246 if (isGV_with_GP(sv))
2247 return glob_2number(MUTABLE_GV(sv));
2249 if (!(SvFLAGS(sv) & SVs_PADTMP)) {
2250 if (!PL_localizing && ckWARN(WARN_UNINITIALIZED))
2253 if (SvTYPE(sv) < SVt_IV)
2254 /* Typically the caller expects that sv_any is not NULL now. */
2255 sv_upgrade(sv, SVt_IV);
2256 /* Return 0 from the caller. */
2263 =for apidoc sv_2iv_flags
2265 Return the integer value of an SV, doing any necessary string
2266 conversion. If flags includes SV_GMAGIC, does an mg_get() first.
2267 Normally used via the C<SvIV(sv)> and C<SvIVx(sv)> macros.
2273 Perl_sv_2iv_flags(pTHX_ register SV *const sv, const I32 flags)
2278 if (SvGMAGICAL(sv) || (SvTYPE(sv) == SVt_PVGV && SvVALID(sv))) {
2279 /* FBMs use the same flag bit as SVf_IVisUV, so must let them
2280 cache IVs just in case. In practice it seems that they never
2281 actually anywhere accessible by user Perl code, let alone get used
2282 in anything other than a string context. */
2283 if (flags & SV_GMAGIC)
2288 return I_V(SvNVX(sv));
2290 if (SvPOKp(sv) && SvLEN(sv)) {
2293 = grok_number(SvPVX_const(sv), SvCUR(sv), &value);
2295 if ((numtype & (IS_NUMBER_IN_UV | IS_NUMBER_NOT_INT))
2296 == IS_NUMBER_IN_UV) {
2297 /* It's definitely an integer */
2298 if (numtype & IS_NUMBER_NEG) {
2299 if (value < (UV)IV_MIN)
2302 if (value < (UV)IV_MAX)
2307 if (ckWARN(WARN_NUMERIC))
2310 return I_V(Atof(SvPVX_const(sv)));
2315 assert(SvTYPE(sv) >= SVt_PVMG);
2316 /* This falls through to the report_uninit inside S_sv_2iuv_common. */
2317 } else if (SvTHINKFIRST(sv)) {
2321 SV * const tmpstr=AMG_CALLun(sv,numer);
2322 if (tmpstr && (!SvROK(tmpstr) || (SvRV(tmpstr) != SvRV(sv)))) {
2323 return SvIV(tmpstr);
2326 return PTR2IV(SvRV(sv));
2329 sv_force_normal_flags(sv, 0);
2331 if (SvREADONLY(sv) && !SvOK(sv)) {
2332 if (ckWARN(WARN_UNINITIALIZED))
2338 if (S_sv_2iuv_common(aTHX_ sv))
2341 DEBUG_c(PerlIO_printf(Perl_debug_log, "0x%"UVxf" 2iv(%"IVdf")\n",
2342 PTR2UV(sv),SvIVX(sv)));
2343 return SvIsUV(sv) ? (IV)SvUVX(sv) : SvIVX(sv);
2347 =for apidoc sv_2uv_flags
2349 Return the unsigned integer value of an SV, doing any necessary string
2350 conversion. If flags includes SV_GMAGIC, does an mg_get() first.
2351 Normally used via the C<SvUV(sv)> and C<SvUVx(sv)> macros.
2357 Perl_sv_2uv_flags(pTHX_ register SV *const sv, const I32 flags)
2362 if (SvGMAGICAL(sv) || (SvTYPE(sv) == SVt_PVGV && SvVALID(sv))) {
2363 /* FBMs use the same flag bit as SVf_IVisUV, so must let them
2364 cache IVs just in case. */
2365 if (flags & SV_GMAGIC)
2370 return U_V(SvNVX(sv));
2371 if (SvPOKp(sv) && SvLEN(sv)) {
2374 = grok_number(SvPVX_const(sv), SvCUR(sv), &value);
2376 if ((numtype & (IS_NUMBER_IN_UV | IS_NUMBER_NOT_INT))
2377 == IS_NUMBER_IN_UV) {
2378 /* It's definitely an integer */
2379 if (!(numtype & IS_NUMBER_NEG))
2383 if (ckWARN(WARN_NUMERIC))
2386 return U_V(Atof(SvPVX_const(sv)));
2391 assert(SvTYPE(sv) >= SVt_PVMG);
2392 /* This falls through to the report_uninit inside S_sv_2iuv_common. */
2393 } else if (SvTHINKFIRST(sv)) {
2397 SV *const tmpstr = AMG_CALLun(sv,numer);
2398 if (tmpstr && (!SvROK(tmpstr) || (SvRV(tmpstr) != SvRV(sv)))) {
2399 return SvUV(tmpstr);
2402 return PTR2UV(SvRV(sv));
2405 sv_force_normal_flags(sv, 0);
2407 if (SvREADONLY(sv) && !SvOK(sv)) {
2408 if (ckWARN(WARN_UNINITIALIZED))
2414 if (S_sv_2iuv_common(aTHX_ sv))
2418 DEBUG_c(PerlIO_printf(Perl_debug_log, "0x%"UVxf" 2uv(%"UVuf")\n",
2419 PTR2UV(sv),SvUVX(sv)));
2420 return SvIsUV(sv) ? SvUVX(sv) : (UV)SvIVX(sv);
2426 Return the num value of an SV, doing any necessary string or integer
2427 conversion, magic etc. Normally used via the C<SvNV(sv)> and C<SvNVx(sv)>
2434 Perl_sv_2nv(pTHX_ register SV *const sv)
2439 if (SvGMAGICAL(sv) || (SvTYPE(sv) == SVt_PVGV && SvVALID(sv))) {
2440 /* FBMs use the same flag bit as SVf_IVisUV, so must let them
2441 cache IVs just in case. */
2445 if ((SvPOKp(sv) && SvLEN(sv)) && !SvIOKp(sv)) {
2446 if (!SvIOKp(sv) && ckWARN(WARN_NUMERIC) &&
2447 !grok_number(SvPVX_const(sv), SvCUR(sv), NULL))
2449 return Atof(SvPVX_const(sv));
2453 return (NV)SvUVX(sv);
2455 return (NV)SvIVX(sv);
2460 assert(SvTYPE(sv) >= SVt_PVMG);
2461 /* This falls through to the report_uninit near the end of the
2463 } else if (SvTHINKFIRST(sv)) {
2467 SV *const tmpstr = AMG_CALLun(sv,numer);
2468 if (tmpstr && (!SvROK(tmpstr) || (SvRV(tmpstr) != SvRV(sv)))) {
2469 return SvNV(tmpstr);
2472 return PTR2NV(SvRV(sv));
2475 sv_force_normal_flags(sv, 0);
2477 if (SvREADONLY(sv) && !SvOK(sv)) {
2478 if (ckWARN(WARN_UNINITIALIZED))
2483 if (SvTYPE(sv) < SVt_NV) {
2484 /* The logic to use SVt_PVNV if necessary is in sv_upgrade. */
2485 sv_upgrade(sv, SVt_NV);
2486 #ifdef USE_LONG_DOUBLE
2488 STORE_NUMERIC_LOCAL_SET_STANDARD();
2489 PerlIO_printf(Perl_debug_log,
2490 "0x%"UVxf" num(%" PERL_PRIgldbl ")\n",
2491 PTR2UV(sv), SvNVX(sv));
2492 RESTORE_NUMERIC_LOCAL();
2496 STORE_NUMERIC_LOCAL_SET_STANDARD();
2497 PerlIO_printf(Perl_debug_log, "0x%"UVxf" num(%"NVgf")\n",
2498 PTR2UV(sv), SvNVX(sv));
2499 RESTORE_NUMERIC_LOCAL();
2503 else if (SvTYPE(sv) < SVt_PVNV)
2504 sv_upgrade(sv, SVt_PVNV);
2509 SvNV_set(sv, SvIsUV(sv) ? (NV)SvUVX(sv) : (NV)SvIVX(sv));
2510 #ifdef NV_PRESERVES_UV
2516 /* Only set the public NV OK flag if this NV preserves the IV */
2517 /* Check it's not 0xFFFFFFFFFFFFFFFF */
2519 SvIsUV(sv) ? ((SvUVX(sv) != UV_MAX)&&(SvUVX(sv) == U_V(SvNVX(sv))))
2520 : (SvIVX(sv) == I_V(SvNVX(sv))))
2526 else if (SvPOKp(sv) && SvLEN(sv)) {
2528 const int numtype = grok_number(SvPVX_const(sv), SvCUR(sv), &value);
2529 if (!SvIOKp(sv) && !numtype && ckWARN(WARN_NUMERIC))
2531 #ifdef NV_PRESERVES_UV
2532 if ((numtype & (IS_NUMBER_IN_UV | IS_NUMBER_NOT_INT))
2533 == IS_NUMBER_IN_UV) {
2534 /* It's definitely an integer */
2535 SvNV_set(sv, (numtype & IS_NUMBER_NEG) ? -(NV)value : (NV)value);
2537 SvNV_set(sv, Atof(SvPVX_const(sv)));
2543 SvNV_set(sv, Atof(SvPVX_const(sv)));
2544 /* Only set the public NV OK flag if this NV preserves the value in
2545 the PV at least as well as an IV/UV would.
2546 Not sure how to do this 100% reliably. */
2547 /* if that shift count is out of range then Configure's test is
2548 wonky. We shouldn't be in here with NV_PRESERVES_UV_BITS ==
2550 if (((UV)1 << NV_PRESERVES_UV_BITS) >
2551 U_V(SvNVX(sv) > 0 ? SvNVX(sv) : -SvNVX(sv))) {
2552 SvNOK_on(sv); /* Definitely small enough to preserve all bits */
2553 } else if (!(numtype & IS_NUMBER_IN_UV)) {
2554 /* Can't use strtol etc to convert this string, so don't try.
2555 sv_2iv and sv_2uv will use the NV to convert, not the PV. */
2558 /* value has been set. It may not be precise. */
2559 if ((numtype & IS_NUMBER_NEG) && (value > (UV)IV_MIN)) {
2560 /* 2s complement assumption for (UV)IV_MIN */
2561 SvNOK_on(sv); /* Integer is too negative. */
2566 if (numtype & IS_NUMBER_NEG) {
2567 SvIV_set(sv, -(IV)value);
2568 } else if (value <= (UV)IV_MAX) {
2569 SvIV_set(sv, (IV)value);
2571 SvUV_set(sv, value);
2575 if (numtype & IS_NUMBER_NOT_INT) {
2576 /* I believe that even if the original PV had decimals,
2577 they are lost beyond the limit of the FP precision.
2578 However, neither is canonical, so both only get p
2579 flags. NWC, 2000/11/25 */
2580 /* Both already have p flags, so do nothing */
2582 const NV nv = SvNVX(sv);
2583 if (SvNVX(sv) < (NV)IV_MAX + 0.5) {
2584 if (SvIVX(sv) == I_V(nv)) {
2587 /* It had no "." so it must be integer. */
2591 /* between IV_MAX and NV(UV_MAX).
2592 Could be slightly > UV_MAX */
2594 if (numtype & IS_NUMBER_NOT_INT) {
2595 /* UV and NV both imprecise. */
2597 const UV nv_as_uv = U_V(nv);
2599 if (value == nv_as_uv && SvUVX(sv) != UV_MAX) {
2608 /* It might be more code efficient to go through the entire logic above
2609 and conditionally set with SvNOKp_on() rather than SvNOK(), but it
2610 gets complex and potentially buggy, so more programmer efficient
2611 to do it this way, by turning off the public flags: */
2613 SvFLAGS(sv) &= ~(SVf_IOK|SVf_NOK);
2614 #endif /* NV_PRESERVES_UV */
2617 if (isGV_with_GP(sv)) {
2618 glob_2number(MUTABLE_GV(sv));
2622 if (!PL_localizing && !(SvFLAGS(sv) & SVs_PADTMP) && ckWARN(WARN_UNINITIALIZED))
2624 assert (SvTYPE(sv) >= SVt_NV);
2625 /* Typically the caller expects that sv_any is not NULL now. */
2626 /* XXX Ilya implies that this is a bug in callers that assume this
2627 and ideally should be fixed. */
2630 #if defined(USE_LONG_DOUBLE)
2632 STORE_NUMERIC_LOCAL_SET_STANDARD();
2633 PerlIO_printf(Perl_debug_log, "0x%"UVxf" 2nv(%" PERL_PRIgldbl ")\n",
2634 PTR2UV(sv), SvNVX(sv));
2635 RESTORE_NUMERIC_LOCAL();
2639 STORE_NUMERIC_LOCAL_SET_STANDARD();
2640 PerlIO_printf(Perl_debug_log, "0x%"UVxf" 1nv(%"NVgf")\n",
2641 PTR2UV(sv), SvNVX(sv));
2642 RESTORE_NUMERIC_LOCAL();
2651 Return an SV with the numeric value of the source SV, doing any necessary
2652 reference or overload conversion. You must use the C<SvNUM(sv)> macro to
2653 access this function.
2659 Perl_sv_2num(pTHX_ register SV *const sv)
2661 PERL_ARGS_ASSERT_SV_2NUM;
2666 SV * const tmpsv = AMG_CALLun(sv,numer);
2667 if (tmpsv && (!SvROK(tmpsv) || (SvRV(tmpsv) != SvRV(sv))))
2668 return sv_2num(tmpsv);
2670 return sv_2mortal(newSVuv(PTR2UV(SvRV(sv))));
2673 /* uiv_2buf(): private routine for use by sv_2pv_flags(): print an IV or
2674 * UV as a string towards the end of buf, and return pointers to start and
2677 * We assume that buf is at least TYPE_CHARS(UV) long.
2681 S_uiv_2buf(char *const buf, const IV iv, UV uv, const int is_uv, char **const peob)
2683 char *ptr = buf + TYPE_CHARS(UV);
2684 char * const ebuf = ptr;
2687 PERL_ARGS_ASSERT_UIV_2BUF;
2699 *--ptr = '0' + (char)(uv % 10);
2708 =for apidoc sv_2pv_flags
2710 Returns a pointer to the string value of an SV, and sets *lp to its length.
2711 If flags includes SV_GMAGIC, does an mg_get() first. Coerces sv to a string
2713 Normally invoked via the C<SvPV_flags> macro. C<sv_2pv()> and C<sv_2pv_nomg>
2714 usually end up here too.
2720 Perl_sv_2pv_flags(pTHX_ register SV *const sv, STRLEN *const lp, const I32 flags)
2730 if (SvGMAGICAL(sv)) {
2731 if (flags & SV_GMAGIC)
2736 if (flags & SV_MUTABLE_RETURN)
2737 return SvPVX_mutable(sv);
2738 if (flags & SV_CONST_RETURN)
2739 return (char *)SvPVX_const(sv);
2742 if (SvIOKp(sv) || SvNOKp(sv)) {
2743 char tbuf[64]; /* Must fit sprintf/Gconvert of longest IV/NV */
2748 ? my_snprintf(tbuf, sizeof(tbuf), "%"UVuf, (UV)SvUVX(sv))
2749 : my_snprintf(tbuf, sizeof(tbuf), "%"IVdf, (IV)SvIVX(sv));
2751 Gconvert(SvNVX(sv), NV_DIG, 0, tbuf);
2758 #ifdef FIXNEGATIVEZERO
2759 if (len == 2 && tbuf[0] == '-' && tbuf[1] == '0') {
2765 SvUPGRADE(sv, SVt_PV);
2768 s = SvGROW_mutable(sv, len + 1);
2771 return (char*)memcpy(s, tbuf, len + 1);
2777 assert(SvTYPE(sv) >= SVt_PVMG);
2778 /* This falls through to the report_uninit near the end of the
2780 } else if (SvTHINKFIRST(sv)) {
2784 SV *const tmpstr = AMG_CALLun(sv,string);
2785 if (tmpstr && (!SvROK(tmpstr) || (SvRV(tmpstr) != SvRV(sv)))) {
2787 /* char *pv = lp ? SvPV(tmpstr, *lp) : SvPV_nolen(tmpstr);
2791 if ((SvFLAGS(tmpstr) & (SVf_POK)) == SVf_POK) {
2792 if (flags & SV_CONST_RETURN) {
2793 pv = (char *) SvPVX_const(tmpstr);
2795 pv = (flags & SV_MUTABLE_RETURN)
2796 ? SvPVX_mutable(tmpstr) : SvPVX(tmpstr);
2799 *lp = SvCUR(tmpstr);
2801 pv = sv_2pv_flags(tmpstr, lp, flags);
2814 SV *const referent = SvRV(sv);
2818 retval = buffer = savepvn("NULLREF", len);
2819 } else if (SvTYPE(referent) == SVt_REGEXP) {
2820 REGEXP * const re = (REGEXP *)MUTABLE_PTR(referent);
2825 /* If the regex is UTF-8 we want the containing scalar to
2826 have an UTF-8 flag too */
2832 if ((seen_evals = RX_SEEN_EVALS(re)))
2833 PL_reginterp_cnt += seen_evals;
2836 *lp = RX_WRAPLEN(re);
2838 return RX_WRAPPED(re);
2840 const char *const typestr = sv_reftype(referent, 0);
2841 const STRLEN typelen = strlen(typestr);
2842 UV addr = PTR2UV(referent);
2843 const char *stashname = NULL;
2844 STRLEN stashnamelen = 0; /* hush, gcc */
2845 const char *buffer_end;
2847 if (SvOBJECT(referent)) {
2848 const HEK *const name = HvNAME_HEK(SvSTASH(referent));
2851 stashname = HEK_KEY(name);
2852 stashnamelen = HEK_LEN(name);
2854 if (HEK_UTF8(name)) {
2860 stashname = "__ANON__";
2863 len = stashnamelen + 1 /* = */ + typelen + 3 /* (0x */
2864 + 2 * sizeof(UV) + 2 /* )\0 */;
2866 len = typelen + 3 /* (0x */
2867 + 2 * sizeof(UV) + 2 /* )\0 */;
2870 Newx(buffer, len, char);
2871 buffer_end = retval = buffer + len;
2873 /* Working backwards */
2877 *--retval = PL_hexdigit[addr & 15];
2878 } while (addr >>= 4);
2884 memcpy(retval, typestr, typelen);
2888 retval -= stashnamelen;
2889 memcpy(retval, stashname, stashnamelen);
2891 /* retval may not neccesarily have reached the start of the
2893 assert (retval >= buffer);
2895 len = buffer_end - retval - 1; /* -1 for that \0 */
2903 if (SvREADONLY(sv) && !SvOK(sv)) {
2906 if (flags & SV_UNDEF_RETURNS_NULL)
2908 if (ckWARN(WARN_UNINITIALIZED))
2913 if (SvIOK(sv) || ((SvIOKp(sv) && !SvNOKp(sv)))) {
2914 /* I'm assuming that if both IV and NV are equally valid then
2915 converting the IV is going to be more efficient */
2916 const U32 isUIOK = SvIsUV(sv);
2917 char buf[TYPE_CHARS(UV)];
2921 if (SvTYPE(sv) < SVt_PVIV)
2922 sv_upgrade(sv, SVt_PVIV);
2923 ptr = uiv_2buf(buf, SvIVX(sv), SvUVX(sv), isUIOK, &ebuf);
2925 /* inlined from sv_setpvn */
2926 s = SvGROW_mutable(sv, len + 1);
2927 Move(ptr, s, len, char);
2931 else if (SvNOKp(sv)) {
2933 if (SvTYPE(sv) < SVt_PVNV)
2934 sv_upgrade(sv, SVt_PVNV);
2935 /* The +20 is pure guesswork. Configure test needed. --jhi */
2936 s = SvGROW_mutable(sv, NV_DIG + 20);
2937 /* some Xenix systems wipe out errno here */
2939 if (SvNVX(sv) == 0.0)
2940 my_strlcpy(s, "0", SvLEN(sv));
2944 Gconvert(SvNVX(sv), NV_DIG, 0, s);
2947 #ifdef FIXNEGATIVEZERO
2948 if (*s == '-' && s[1] == '0' && !s[2]) {
2960 if (isGV_with_GP(sv)) {
2961 GV *const gv = MUTABLE_GV(sv);
2962 const U32 wasfake = SvFLAGS(gv) & SVf_FAKE;
2963 SV *const buffer = sv_newmortal();
2965 /* FAKE globs can get coerced, so need to turn this off temporarily
2968 gv_efullname3(buffer, gv, "*");
2969 SvFLAGS(gv) |= wasfake;
2971 assert(SvPOK(buffer));
2973 *lp = SvCUR(buffer);
2975 return SvPVX(buffer);
2980 if (flags & SV_UNDEF_RETURNS_NULL)
2982 if (!PL_localizing && !(SvFLAGS(sv) & SVs_PADTMP) && ckWARN(WARN_UNINITIALIZED))
2984 if (SvTYPE(sv) < SVt_PV)
2985 /* Typically the caller expects that sv_any is not NULL now. */
2986 sv_upgrade(sv, SVt_PV);
2990 const STRLEN len = s - SvPVX_const(sv);
2996 DEBUG_c(PerlIO_printf(Perl_debug_log, "0x%"UVxf" 2pv(%s)\n",
2997 PTR2UV(sv),SvPVX_const(sv)));
2998 if (flags & SV_CONST_RETURN)
2999 return (char *)SvPVX_const(sv);
3000 if (flags & SV_MUTABLE_RETURN)
3001 return SvPVX_mutable(sv);
3006 =for apidoc sv_copypv
3008 Copies a stringified representation of the source SV into the
3009 destination SV. Automatically performs any necessary mg_get and
3010 coercion of numeric values into strings. Guaranteed to preserve
3011 UTF8 flag even from overloaded objects. Similar in nature to
3012 sv_2pv[_flags] but operates directly on an SV instead of just the
3013 string. Mostly uses sv_2pv_flags to do its work, except when that
3014 would lose the UTF-8'ness of the PV.
3020 Perl_sv_copypv(pTHX_ SV *const dsv, register SV *const ssv)
3023 const char * const s = SvPV_const(ssv,len);
3025 PERL_ARGS_ASSERT_SV_COPYPV;
3027 sv_setpvn(dsv,s,len);
3035 =for apidoc sv_2pvbyte
3037 Return a pointer to the byte-encoded representation of the SV, and set *lp
3038 to its length. May cause the SV to be downgraded from UTF-8 as a
3041 Usually accessed via the C<SvPVbyte> macro.
3047 Perl_sv_2pvbyte(pTHX_ register SV *const sv, STRLEN *const lp)
3049 PERL_ARGS_ASSERT_SV_2PVBYTE;
3051 sv_utf8_downgrade(sv,0);
3052 return lp ? SvPV(sv,*lp) : SvPV_nolen(sv);
3056 =for apidoc sv_2pvutf8
3058 Return a pointer to the UTF-8-encoded representation of the SV, and set *lp
3059 to its length. May cause the SV to be upgraded to UTF-8 as a side-effect.
3061 Usually accessed via the C<SvPVutf8> macro.
3067 Perl_sv_2pvutf8(pTHX_ register SV *const sv, STRLEN *const lp)
3069 PERL_ARGS_ASSERT_SV_2PVUTF8;
3071 sv_utf8_upgrade(sv);
3072 return lp ? SvPV(sv,*lp) : SvPV_nolen(sv);
3077 =for apidoc sv_2bool
3079 This function is only called on magical items, and is only used by
3080 sv_true() or its macro equivalent.
3086 Perl_sv_2bool(pTHX_ register SV *const sv)
3090 PERL_ARGS_ASSERT_SV_2BOOL;
3098 SV * const tmpsv = AMG_CALLun(sv,bool_);
3099 if (tmpsv && (!SvROK(tmpsv) || (SvRV(tmpsv) != SvRV(sv))))
3100 return (bool)SvTRUE(tmpsv);
3102 return SvRV(sv) != 0;
3105 register XPV* const Xpvtmp = (XPV*)SvANY(sv);
3107 (*sv->sv_u.svu_pv > '0' ||
3108 Xpvtmp->xpv_cur > 1 ||
3109 (Xpvtmp->xpv_cur && *sv->sv_u.svu_pv != '0')))
3116 return SvIVX(sv) != 0;
3119 return SvNVX(sv) != 0.0;
3121 if (isGV_with_GP(sv))
3131 =for apidoc sv_utf8_upgrade
3133 Converts the PV of an SV to its UTF-8-encoded form.
3134 Forces the SV to string form if it is not already.
3135 Will C<mg_get> on C<sv> if appropriate.
3136 Always sets the SvUTF8 flag to avoid future validity checks even
3137 if the whole string is the same in UTF-8 as not.
3138 Returns the number of bytes in the converted string
3140 This is not as a general purpose byte encoding to Unicode interface:
3141 use the Encode extension for that.
3143 =for apidoc sv_utf8_upgrade_nomg
3145 Like sv_utf8_upgrade, but doesn't do magic on C<sv>
3147 =for apidoc sv_utf8_upgrade_flags
3149 Converts the PV of an SV to its UTF-8-encoded form.
3150 Forces the SV to string form if it is not already.
3151 Always sets the SvUTF8 flag to avoid future validity checks even
3152 if all the bytes are invariant in UTF-8. If C<flags> has C<SV_GMAGIC> bit set,
3153 will C<mg_get> on C<sv> if appropriate, else not.
3154 Returns the number of bytes in the converted string
3155 C<sv_utf8_upgrade> and
3156 C<sv_utf8_upgrade_nomg> are implemented in terms of this function.
3158 This is not as a general purpose byte encoding to Unicode interface:
3159 use the Encode extension for that.
3163 The grow version is currently not externally documented. It adds a parameter,
3164 extra, which is the number of unused bytes the string of 'sv' is guaranteed to
3165 have free after it upon return. This allows the caller to reserve extra space
3166 that it intends to fill, to avoid extra grows.
3168 Also externally undocumented for the moment is the flag SV_FORCE_UTF8_UPGRADE,
3169 which can be used to tell this function to not first check to see if there are
3170 any characters that are different in UTF-8 (variant characters) which would
3171 force it to allocate a new string to sv, but to assume there are. Typically
3172 this flag is used by a routine that has already parsed the string to find that
3173 there are such characters, and passes this information on so that the work
3174 doesn't have to be repeated.
3176 (One might think that the calling routine could pass in the position of the
3177 first such variant, so it wouldn't have to be found again. But that is not the
3178 case, because typically when the caller is likely to use this flag, it won't be
3179 calling this routine unless it finds something that won't fit into a byte.
3180 Otherwise it tries to not upgrade and just use bytes. But some things that
3181 do fit into a byte are variants in utf8, and the caller may not have been
3182 keeping track of these.)
3184 If the routine itself changes the string, it adds a trailing NUL. Such a NUL
3185 isn't guaranteed due to having other routines do the work in some input cases,
3186 or if the input is already flagged as being in utf8.
3188 The speed of this could perhaps be improved for many cases if someone wanted to
3189 write a fast function that counts the number of variant characters in a string,
3190 especially if it could return the position of the first one.
3195 Perl_sv_utf8_upgrade_flags_grow(pTHX_ register SV *const sv, const I32 flags, STRLEN extra)
3199 PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_FLAGS_GROW;
3201 if (sv == &PL_sv_undef)
3205 if (SvREADONLY(sv) && (SvPOKp(sv) || SvIOKp(sv) || SvNOKp(sv))) {
3206 (void) sv_2pv_flags(sv,&len, flags);
3208 if (extra) SvGROW(sv, SvCUR(sv) + extra);
3212 (void) SvPV_force(sv,len);
3217 if (extra) SvGROW(sv, SvCUR(sv) + extra);
3222 sv_force_normal_flags(sv, 0);
3225 if (PL_encoding && !(flags & SV_UTF8_NO_ENCODING)) {
3226 sv_recode_to_utf8(sv, PL_encoding);
3227 if (extra) SvGROW(sv, SvCUR(sv) + extra);
3231 if (SvCUR(sv) > 0) { /* Assume Latin-1/EBCDIC */
3232 /* This function could be much more efficient if we
3233 * had a FLAG in SVs to signal if there are any variant
3234 * chars in the PV. Given that there isn't such a flag
3235 * make the loop as fast as possible (although there are certainly ways
3236 * to speed this up, eg. through vectorization) */
3237 U8 * s = (U8 *) SvPVX_const(sv);
3238 U8 * e = (U8 *) SvEND(sv);
3240 STRLEN two_byte_count = 0;
3242 if (flags & SV_FORCE_UTF8_UPGRADE) goto must_be_utf8;
3244 /* See if really will need to convert to utf8. We mustn't rely on our
3245 * incoming SV being well formed and having a trailing '\0', as certain
3246 * code in pp_formline can send us partially built SVs. */
3250 if (NATIVE_IS_INVARIANT(ch)) continue;
3252 t--; /* t already incremented; re-point to first variant */
3257 /* utf8 conversion not needed because all are invariants. Mark as
3258 * UTF-8 even if no variant - saves scanning loop */
3264 /* Here, the string should be converted to utf8, either because of an
3265 * input flag (two_byte_count = 0), or because a character that
3266 * requires 2 bytes was found (two_byte_count = 1). t points either to
3267 * the beginning of the string (if we didn't examine anything), or to
3268 * the first variant. In either case, everything from s to t - 1 will
3269 * occupy only 1 byte each on output.
3271 * There are two main ways to convert. One is to create a new string
3272 * and go through the input starting from the beginning, appending each
3273 * converted value onto the new string as we go along. It's probably
3274 * best to allocate enough space in the string for the worst possible
3275 * case rather than possibly running out of space and having to
3276 * reallocate and then copy what we've done so far. Since everything
3277 * from s to t - 1 is invariant, the destination can be initialized
3278 * with these using a fast memory copy
3280 * The other way is to figure out exactly how big the string should be
3281 * by parsing the entire input. Then you don't have to make it big
3282 * enough to handle the worst possible case, and more importantly, if
3283 * the string you already have is large enough, you don't have to
3284 * allocate a new string, you can copy the last character in the input
3285 * string to the final position(s) that will be occupied by the
3286 * converted string and go backwards, stopping at t, since everything
3287 * before that is invariant.
3289 * There are advantages and disadvantages to each method.
3291 * In the first method, we can allocate a new string, do the memory
3292 * copy from the s to t - 1, and then proceed through the rest of the
3293 * string byte-by-byte.
3295 * In the second method, we proceed through the rest of the input
3296 * string just calculating how big the converted string will be. Then
3297 * there are two cases:
3298 * 1) if the string has enough extra space to handle the converted
3299 * value. We go backwards through the string, converting until we
3300 * get to the position we are at now, and then stop. If this
3301 * position is far enough along in the string, this method is
3302 * faster than the other method. If the memory copy were the same
3303 * speed as the byte-by-byte loop, that position would be about
3304 * half-way, as at the half-way mark, parsing to the end and back
3305 * is one complete string's parse, the same amount as starting
3306 * over and going all the way through. Actually, it would be
3307 * somewhat less than half-way, as it's faster to just count bytes
3308 * than to also copy, and we don't have the overhead of allocating
3309 * a new string, changing the scalar to use it, and freeing the
3310 * existing one. But if the memory copy is fast, the break-even
3311 * point is somewhere after half way. The counting loop could be
3312 * sped up by vectorization, etc, to move the break-even point
3313 * further towards the beginning.
3314 * 2) if the string doesn't have enough space to handle the converted
3315 * value. A new string will have to be allocated, and one might
3316 * as well, given that, start from the beginning doing the first
3317 * method. We've spent extra time parsing the string and in
3318 * exchange all we've gotten is that we know precisely how big to
3319 * make the new one. Perl is more optimized for time than space,
3320 * so this case is a loser.
3321 * So what I've decided to do is not use the 2nd method unless it is
3322 * guaranteed that a new string won't have to be allocated, assuming
3323 * the worst case. I also decided not to put any more conditions on it
3324 * than this, for now. It seems likely that, since the worst case is
3325 * twice as big as the unknown portion of the string (plus 1), we won't
3326 * be guaranteed enough space, causing us to go to the first method,
3327 * unless the string is short, or the first variant character is near
3328 * the end of it. In either of these cases, it seems best to use the
3329 * 2nd method. The only circumstance I can think of where this would
3330 * be really slower is if the string had once had much more data in it
3331 * than it does now, but there is still a substantial amount in it */
3334 STRLEN invariant_head = t - s;
3335 STRLEN size = invariant_head + (e - t) * 2 + 1 + extra;
3336 if (SvLEN(sv) < size) {
3338 /* Here, have decided to allocate a new string */
3343 Newx(dst, size, U8);
3345 /* If no known invariants at the beginning of the input string,
3346 * set so starts from there. Otherwise, can use memory copy to
3347 * get up to where we are now, and then start from here */
3349 if (invariant_head <= 0) {
3352 Copy(s, dst, invariant_head, char);
3353 d = dst + invariant_head;
3357 const UV uv = NATIVE8_TO_UNI(*t++);
3358 if (UNI_IS_INVARIANT(uv))
3359 *d++ = (U8)UNI_TO_NATIVE(uv);
3361 *d++ = (U8)UTF8_EIGHT_BIT_HI(uv);
3362 *d++ = (U8)UTF8_EIGHT_BIT_LO(uv);
3366 SvPV_free(sv); /* No longer using pre-existing string */
3367 SvPV_set(sv, (char*)dst);
3368 SvCUR_set(sv, d - dst);
3369 SvLEN_set(sv, size);
3372 /* Here, have decided to get the exact size of the string.
3373 * Currently this happens only when we know that there is
3374 * guaranteed enough space to fit the converted string, so
3375 * don't have to worry about growing. If two_byte_count is 0,
3376 * then t points to the first byte of the string which hasn't
3377 * been examined yet. Otherwise two_byte_count is 1, and t
3378 * points to the first byte in the string that will expand to
3379 * two. Depending on this, start examining at t or 1 after t.
3382 U8 *d = t + two_byte_count;
3385 /* Count up the remaining bytes that expand to two */
3388 const U8 chr = *d++;
3389 if (! NATIVE_IS_INVARIANT(chr)) two_byte_count++;
3392 /* The string will expand by just the number of bytes that
3393 * occupy two positions. But we are one afterwards because of
3394 * the increment just above. This is the place to put the
3395 * trailing NUL, and to set the length before we decrement */
3397 d += two_byte_count;
3398 SvCUR_set(sv, d - s);
3402 /* Having decremented d, it points to the position to put the
3403 * very last byte of the expanded string. Go backwards through
3404 * the string, copying and expanding as we go, stopping when we
3405 * get to the part that is invariant the rest of the way down */
3409 const U8 ch = NATIVE8_TO_UNI(*e--);
3410 if (UNI_IS_INVARIANT(ch)) {
3411 *d-- = UNI_TO_NATIVE(ch);
3413 *d-- = (U8)UTF8_EIGHT_BIT_LO(ch);
3414 *d-- = (U8)UTF8_EIGHT_BIT_HI(ch);
3421 /* Mark as UTF-8 even if no variant - saves scanning loop */
3427 =for apidoc sv_utf8_downgrade
3429 Attempts to convert the PV of an SV from characters to bytes.
3430 If the PV contains a character that cannot fit
3431 in a byte, this conversion will fail;
3432 in this case, either returns false or, if C<fail_ok> is not
3435 This is not as a general purpose Unicode to byte encoding interface:
3436 use the Encode extension for that.
3442 Perl_sv_utf8_downgrade(pTHX_ register SV *const sv, const bool fail_ok)
3446 PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE;
3448 if (SvPOKp(sv) && SvUTF8(sv)) {
3454 sv_force_normal_flags(sv, 0);
3456 s = (U8 *) SvPV(sv, len);
3457 if (!utf8_to_bytes(s, &len)) {
3462 Perl_croak(aTHX_ "Wide character in %s",
3465 Perl_croak(aTHX_ "Wide character");
3476 =for apidoc sv_utf8_encode
3478 Converts the PV of an SV to UTF-8, but then turns the C<SvUTF8>
3479 flag off so that it looks like octets again.
3485 Perl_sv_utf8_encode(pTHX_ register SV *const sv)
3487 PERL_ARGS_ASSERT_SV_UTF8_ENCODE;
3490 sv_force_normal_flags(sv, 0);
3492 if (SvREADONLY(sv)) {
3493 Perl_croak(aTHX_ "%s", PL_no_modify);
3495 (void) sv_utf8_upgrade(sv);
3500 =for apidoc sv_utf8_decode
3502 If the PV of the SV is an octet sequence in UTF-8
3503 and contains a multiple-byte character, the C<SvUTF8> flag is turned on
3504 so that it looks like a character. If the PV contains only single-byte
3505 characters, the C<SvUTF8> flag stays being off.
3506 Scans PV for validity and returns false if the PV is invalid UTF-8.
3512 Perl_sv_utf8_decode(pTHX_ register SV *const sv)
3514 PERL_ARGS_ASSERT_SV_UTF8_DECODE;
3520 /* The octets may have got themselves encoded - get them back as
3523 if (!sv_utf8_downgrade(sv, TRUE))
3526 /* it is actually just a matter of turning the utf8 flag on, but
3527 * we want to make sure everything inside is valid utf8 first.
3529 c = (const U8 *) SvPVX_const(sv);
3530 if (!is_utf8_string(c, SvCUR(sv)+1))
3532 e = (const U8 *) SvEND(sv);
3535 if (!UTF8_IS_INVARIANT(ch)) {
3545 =for apidoc sv_setsv
3547 Copies the contents of the source SV C<ssv> into the destination SV
3548 C<dsv>. The source SV may be destroyed if it is mortal, so don't use this
3549 function if the source SV needs to be reused. Does not handle 'set' magic.
3550 Loosely speaking, it performs a copy-by-value, obliterating any previous
3551 content of the destination.
3553 You probably want to use one of the assortment of wrappers, such as
3554 C<SvSetSV>, C<SvSetSV_nosteal>, C<SvSetMagicSV> and
3555 C<SvSetMagicSV_nosteal>.
3557 =for apidoc sv_setsv_flags
3559 Copies the contents of the source SV C<ssv> into the destination SV
3560 C<dsv>. The source SV may be destroyed if it is mortal, so don't use this
3561 function if the source SV needs to be reused. Does not handle 'set' magic.
3562 Loosely speaking, it performs a copy-by-value, obliterating any previous
3563 content of the destination.
3564 If the C<flags> parameter has the C<SV_GMAGIC> bit set, will C<mg_get> on
3565 C<ssv> if appropriate, else not. If the C<flags> parameter has the
3566 C<NOSTEAL> bit set then the buffers of temps will not be stolen. <sv_setsv>
3567 and C<sv_setsv_nomg> are implemented in terms of this function.
3569 You probably want to use one of the assortment of wrappers, such as
3570 C<SvSetSV>, C<SvSetSV_nosteal>, C<SvSetMagicSV> and
3571 C<SvSetMagicSV_nosteal>.
3573 This is the primary function for copying scalars, and most other
3574 copy-ish functions and macros use this underneath.
3580 S_glob_assign_glob(pTHX_ SV *const dstr, SV *const sstr, const int dtype)
3582 I32 mro_changes = 0; /* 1 = method, 2 = isa */
3584 PERL_ARGS_ASSERT_GLOB_ASSIGN_GLOB;
3586 if (dtype != SVt_PVGV) {
3587 const char * const name = GvNAME(sstr);
3588 const STRLEN len = GvNAMELEN(sstr);
3590 if (dtype >= SVt_PV) {
3596 SvUPGRADE(dstr, SVt_PVGV);
3597 (void)SvOK_off(dstr);
3598 /* FIXME - why are we doing this, then turning it off and on again
3600 isGV_with_GP_on(dstr);
3602 GvSTASH(dstr) = GvSTASH(sstr);
3604 Perl_sv_add_backref(aTHX_ MUTABLE_SV(GvSTASH(dstr)), dstr);
3605 gv_name_set(MUTABLE_GV(dstr), name, len, GV_ADD);
3606 SvFAKE_on(dstr); /* can coerce to non-glob */
3609 if(GvGP(MUTABLE_GV(sstr))) {
3610 /* If source has method cache entry, clear it */
3612 SvREFCNT_dec(GvCV(sstr));
3616 /* If source has a real method, then a method is
3618 else if(GvCV((const GV *)sstr)) {
3623 /* If dest already had a real method, that's a change as well */
3624 if(!mro_changes && GvGP(MUTABLE_GV(dstr)) && GvCVu((const GV *)dstr)) {
3628 if(strEQ(GvNAME((const GV *)dstr),"ISA"))
3631 gp_free(MUTABLE_GV(dstr));
3632 isGV_with_GP_off(dstr);
3633 (void)SvOK_off(dstr);
3634 isGV_with_GP_on(dstr);
3635 GvINTRO_off(dstr); /* one-shot flag */
3636 GvGP(dstr) = gp_ref(GvGP(sstr));
3637 if (SvTAINTED(sstr))
3639 if (GvIMPORTED(dstr) != GVf_IMPORTED
3640 && CopSTASH_ne(PL_curcop, GvSTASH(dstr)))
3642 GvIMPORTED_on(dstr);
3645 if(mro_changes == 2) mro_isa_changed_in(GvSTASH(dstr));
3646 else if(mro_changes) mro_method_changed_in(GvSTASH(dstr));
3651 S_glob_assign_ref(pTHX_ SV *const dstr, SV *const sstr)
3653 SV * const sref = SvREFCNT_inc(SvRV(sstr));
3655 const int intro = GvINTRO(dstr);
3658 const U32 stype = SvTYPE(sref);
3659 bool mro_changes = FALSE;
3661 PERL_ARGS_ASSERT_GLOB_ASSIGN_REF;
3664 GvINTRO_off(dstr); /* one-shot flag */
3665 GvLINE(dstr) = CopLINE(PL_curcop);
3666 GvEGV(dstr) = MUTABLE_GV(dstr);
3671 location = (SV **) &GvCV(dstr);
3672 import_flag = GVf_IMPORTED_CV;
3675 location = (SV **) &GvHV(dstr);
3676 import_flag = GVf_IMPORTED_HV;
3679 location = (SV **) &GvAV(dstr);
3680 if (strEQ(GvNAME((GV*)dstr), "ISA"))
3682 import_flag = GVf_IMPORTED_AV;
3685 location = (SV **) &GvIOp(dstr);
3688 location = (SV **) &GvFORM(dstr);
3691 location = &GvSV(dstr);
3692 import_flag = GVf_IMPORTED_SV;
3695 if (stype == SVt_PVCV) {
3696 /*if (GvCVGEN(dstr) && (GvCV(dstr) != (const CV *)sref || GvCVGEN(dstr))) {*/
3697 if (GvCVGEN(dstr)) {
3698 SvREFCNT_dec(GvCV(dstr));
3700 GvCVGEN(dstr) = 0; /* Switch off cacheness. */
3703 SAVEGENERICSV(*location);
3707 if (stype == SVt_PVCV && (*location != sref || GvCVGEN(dstr))) {
3708 CV* const cv = MUTABLE_CV(*location);
3710 if (!GvCVGEN((const GV *)dstr) &&
3711 (CvROOT(cv) || CvXSUB(cv)))
3713 /* Redefining a sub - warning is mandatory if
3714 it was a const and its value changed. */
3715 if (CvCONST(cv) && CvCONST((const CV *)sref)
3717 == cv_const_sv((const CV *)sref)) {
3719 /* They are 2 constant subroutines generated from
3720 the same constant. This probably means that
3721 they are really the "same" proxy subroutine
3722 instantiated in 2 places. Most likely this is
3723 when a constant is exported twice. Don't warn.
3726 else if (ckWARN(WARN_REDEFINE)
3728 && (!CvCONST((const CV *)sref)
3729 || sv_cmp(cv_const_sv(cv),
3730 cv_const_sv((const CV *)
3732 Perl_warner(aTHX_ packWARN(WARN_REDEFINE),
3735 ? "Constant subroutine %s::%s redefined"
3736 : "Subroutine %s::%s redefined"),
3737 HvNAME_get(GvSTASH((const GV *)dstr)),
3738 GvENAME(MUTABLE_GV(dstr)));
3742 cv_ckproto_len(cv, (const GV *)dstr,
3743 SvPOK(sref) ? SvPVX_const(sref) : NULL,
3744 SvPOK(sref) ? SvCUR(sref) : 0);
3746 GvCVGEN(dstr) = 0; /* Switch off cacheness. */
3747 GvASSUMECV_on(dstr);
3748 if(GvSTASH(dstr)) mro_method_changed_in(GvSTASH(dstr)); /* sub foo { 1 } sub bar { 2 } *bar = \&foo */
3751 if (import_flag && !(GvFLAGS(dstr) & import_flag)
3752 && CopSTASH_ne(PL_curcop, GvSTASH(dstr))) {
3753 GvFLAGS(dstr) |= import_flag;
3758 if (SvTAINTED(sstr))
3760 if (mro_changes) mro_isa_changed_in(GvSTASH(dstr));
3765 Perl_sv_setsv_flags(pTHX_ SV *dstr, register SV* sstr, const I32 flags)
3768 register U32 sflags;
3770 register svtype stype;
3772 PERL_ARGS_ASSERT_SV_SETSV_FLAGS;
3777 if (SvIS_FREED(dstr)) {
3778 Perl_croak(aTHX_ "panic: attempt to copy value %" SVf
3779 " to a freed scalar %p", SVfARG(sstr), (void *)dstr);
3781 SV_CHECK_THINKFIRST_COW_DROP(dstr);
3783 sstr = &PL_sv_undef;
3784 if (SvIS_FREED(sstr)) {
3785 Perl_croak(aTHX_ "panic: attempt to copy freed scalar %p to %p",
3786 (void*)sstr, (void*)dstr);
3788 stype = SvTYPE(sstr);
3789 dtype = SvTYPE(dstr);
3791 (void)SvAMAGIC_off(dstr);
3794 /* need to nuke the magic */
3798 /* There's a lot of redundancy below but we're going for speed here */
3803 if (dtype != SVt_PVGV) {
3804 (void)SvOK_off(dstr);
3812 sv_upgrade(dstr, SVt_IV);
3816 sv_upgrade(dstr, SVt_PVIV);
3819 goto end_of_first_switch;
3821 (void)SvIOK_only(dstr);
3822 SvIV_set(dstr, SvIVX(sstr));
3825 /* SvTAINTED can only be true if the SV has taint magic, which in
3826 turn means that the SV type is PVMG (or greater). This is the
3827 case statement for SVt_IV, so this cannot be true (whatever gcov
3829 assert(!SvTAINTED(sstr));
3834 if (dtype < SVt_PV && dtype != SVt_IV)
3835 sv_upgrade(dstr, SVt_IV);
3843 sv_upgrade(dstr, SVt_NV);
3847 sv_upgrade(dstr, SVt_PVNV);
3850 goto end_of_first_switch;
3852 SvNV_set(dstr, SvNVX(sstr));
3853 (void)SvNOK_only(dstr);
3854 /* SvTAINTED can only be true if the SV has taint magic, which in
3855 turn means that the SV type is PVMG (or greater). This is the
3856 case statement for SVt_NV, so this cannot be true (whatever gcov
3858 assert(!SvTAINTED(sstr));
3864 #ifdef PERL_OLD_COPY_ON_WRITE
3865 if ((SvFLAGS(sstr) & CAN_COW_MASK) == CAN_COW_FLAGS) {
3866 if (dtype < SVt_PVIV)
3867 sv_upgrade(dstr, SVt_PVIV);
3875 sv_upgrade(dstr, SVt_PV);
3878 if (dtype < SVt_PVIV)
3879 sv_upgrade(dstr, SVt_PVIV);
3882 if (dtype < SVt_PVNV)
3883 sv_upgrade(dstr, SVt_PVNV);
3887 const char * const type = sv_reftype(sstr,0);
3889 Perl_croak(aTHX_ "Bizarre copy of %s in %s", type, OP_NAME(PL_op));
3891 Perl_croak(aTHX_ "Bizarre copy of %s", type);
3895 /* case SVt_BIND: */
3898 if (isGV_with_GP(sstr) && dtype <= SVt_PVGV) {
3899 glob_assign_glob(dstr, sstr, dtype);
3902 /* SvVALID means that this PVGV is playing at being an FBM. */
3906 if (SvGMAGICAL(sstr) && (flags & SV_GMAGIC)) {
3908 if (SvTYPE(sstr) != stype) {
3909 stype = SvTYPE(sstr);
3910 if (isGV_with_GP(sstr) && stype == SVt_PVGV && dtype <= SVt_PVGV) {
3911 glob_assign_glob(dstr, sstr, dtype);
3916 if (stype == SVt_PVLV)
3917 SvUPGRADE(dstr, SVt_PVNV);
3919 SvUPGRADE(dstr, (svtype)stype);
3921 end_of_first_switch:
3923 /* dstr may have been upgraded. */
3924 dtype = SvTYPE(dstr);
3925 sflags = SvFLAGS(sstr);
3927 if (dtype == SVt_PVCV || dtype == SVt_PVFM) {
3928 /* Assigning to a subroutine sets the prototype. */
3931 const char *const ptr = SvPV_const(sstr, len);
3933 SvGROW(dstr, len + 1);
3934 Copy(ptr, SvPVX(dstr), len + 1, char);
3935 SvCUR_set(dstr, len);
3937 SvFLAGS(dstr) |= sflags & SVf_UTF8;
3941 } else if (dtype == SVt_PVAV || dtype == SVt_PVHV) {
3942 const char * const type = sv_reftype(dstr,0);
3944 Perl_croak(aTHX_ "Cannot copy to %s in %s", type, OP_NAME(PL_op));
3946 Perl_croak(aTHX_ "Cannot copy to %s", type);
3947 } else if (sflags & SVf_ROK) {
3948 if (isGV_with_GP(dstr) && dtype == SVt_PVGV
3949 && SvTYPE(SvRV(sstr)) == SVt_PVGV && isGV_with_GP(SvRV(sstr))) {
3952 if (GvIMPORTED(dstr) != GVf_IMPORTED
3953 && CopSTASH_ne(PL_curcop, GvSTASH(dstr)))
3955 GvIMPORTED_on(dstr);
3960 glob_assign_glob(dstr, sstr, dtype);
3964 if (dtype >= SVt_PV) {
3965 if (dtype == SVt_PVGV && isGV_with_GP(dstr)) {
3966 glob_assign_ref(dstr, sstr);
3969 if (SvPVX_const(dstr)) {
3975 (void)SvOK_off(dstr);
3976 SvRV_set(dstr, SvREFCNT_inc(SvRV(sstr)));
3977 SvFLAGS(dstr) |= sflags & SVf_ROK;
3978 assert(!(sflags & SVp_NOK));
3979 assert(!(sflags & SVp_IOK));
3980 assert(!(sflags & SVf_NOK));
3981 assert(!(sflags & SVf_IOK));
3983 else if (dtype == SVt_PVGV && isGV_with_GP(dstr)) {
3984 if (!(sflags & SVf_OK)) {
3985 if (ckWARN(WARN_MISC))
3986 Perl_warner(aTHX_ packWARN(WARN_MISC),
3987 "Undefined value assigned to typeglob");
3990 GV *gv = gv_fetchsv(sstr, GV_ADD, SVt_PVGV);
3991 if (dstr != (const SV *)gv) {
3993 gp_free(MUTABLE_GV(dstr));
3994 GvGP(dstr) = gp_ref(GvGP(gv));
3998 else if (sflags & SVp_POK) {
4002 * Check to see if we can just swipe the string. If so, it's a
4003 * possible small lose on short strings, but a big win on long ones.
4004 * It might even be a win on short strings if SvPVX_const(dstr)
4005 * has to be allocated and SvPVX_const(sstr) has to be freed.
4006 * Likewise if we can set up COW rather than doing an actual copy, we
4007 * drop to the else clause, as the swipe code and the COW setup code
4008 * have much in common.
4011 /* Whichever path we take through the next code, we want this true,
4012 and doing it now facilitates the COW check. */
4013 (void)SvPOK_only(dstr);
4016 /* If we're already COW then this clause is not true, and if COW
4017 is allowed then we drop down to the else and make dest COW
4018 with us. If caller hasn't said that we're allowed to COW
4019 shared hash keys then we don't do the COW setup, even if the
4020 source scalar is a shared hash key scalar. */
4021 (((flags & SV_COW_SHARED_HASH_KEYS)
4022 ? (sflags & (SVf_FAKE|SVf_READONLY)) != (SVf_FAKE|SVf_READONLY)
4023 : 1 /* If making a COW copy is forbidden then the behaviour we
4024 desire is as if the source SV isn't actually already
4025 COW, even if it is. So we act as if the source flags
4026 are not COW, rather than actually testing them. */
4028 #ifndef PERL_OLD_COPY_ON_WRITE
4029 /* The change that added SV_COW_SHARED_HASH_KEYS makes the logic
4030 when PERL_OLD_COPY_ON_WRITE is defined a little wrong.
4031 Conceptually PERL_OLD_COPY_ON_WRITE being defined should
4032 override SV_COW_SHARED_HASH_KEYS, because it means "always COW"
4033 but in turn, it's somewhat dead code, never expected to go
4034 live, but more kept as a placeholder on how to do it better
4035 in a newer implementation. */
4036 /* If we are COW and dstr is a suitable target then we drop down
4037 into the else and make dest a COW of us. */
4038 || (SvFLAGS(dstr) & CAN_COW_MASK) != CAN_COW_FLAGS
4043 (sflags & SVs_TEMP) && /* slated for free anyway? */
4044 !(sflags & SVf_OOK) && /* and not involved in OOK hack? */
4045 (!(flags & SV_NOSTEAL)) &&
4046 /* and we're allowed to steal temps */
4047 SvREFCNT(sstr) == 1 && /* and no other references to it? */
4048 SvLEN(sstr) && /* and really is a string */
4049 /* and won't be needed again, potentially */
4050 !(PL_op && PL_op->op_type == OP_AASSIGN))
4051 #ifdef PERL_OLD_COPY_ON_WRITE
4052 && ((flags & SV_COW_SHARED_HASH_KEYS)
4053 ? (!((sflags & CAN_COW_MASK) == CAN_COW_FLAGS
4054 && (SvFLAGS(dstr) & CAN_COW_MASK) == CAN_COW_FLAGS
4055 && SvTYPE(sstr) >= SVt_PVIV && SvTYPE(sstr) != SVt_PVFM))
4059 /* Failed the swipe test, and it's not a shared hash key either.
4060 Have to copy the string. */
4061 STRLEN len = SvCUR(sstr);
4062 SvGROW(dstr, len + 1); /* inlined from sv_setpvn */
4063 Move(SvPVX_const(sstr),SvPVX(dstr),len,char);
4064 SvCUR_set(dstr, len);
4065 *SvEND(dstr) = '\0';
4067 /* If PERL_OLD_COPY_ON_WRITE is not defined, then isSwipe will always
4069 /* Either it's a shared hash key, or it's suitable for
4070 copy-on-write or we can swipe the string. */
4072 PerlIO_printf(Perl_debug_log, "Copy on write: sstr --> dstr\n");
4076 #ifdef PERL_OLD_COPY_ON_WRITE
4078 if ((sflags & (SVf_FAKE | SVf_READONLY))
4079 != (SVf_FAKE | SVf_READONLY)) {
4080 SvREADONLY_on(sstr);
4082 /* Make the source SV into a loop of 1.
4083 (about to become 2) */
4084 SV_COW_NEXT_SV_SET(sstr, sstr);
4088 /* Initial code is common. */
4089 if (SvPVX_const(dstr)) { /* we know that dtype >= SVt_PV */
4094 /* making another shared SV. */
4095 STRLEN cur = SvCUR(sstr);
4096 STRLEN len = SvLEN(sstr);
4097 #ifdef PERL_OLD_COPY_ON_WRITE
4099 assert (SvTYPE(dstr) >= SVt_PVIV);
4100 /* SvIsCOW_normal */
4101 /* splice us in between source and next-after-source. */
4102 SV_COW_NEXT_SV_SET(dstr, SV_COW_NEXT_SV(sstr));
4103 SV_COW_NEXT_SV_SET(sstr, dstr);
4104 SvPV_set(dstr, SvPVX_mutable(sstr));
4108 /* SvIsCOW_shared_hash */
4109 DEBUG_C(PerlIO_printf(Perl_debug_log,
4110 "Copy on write: Sharing hash\n"));
4112 assert (SvTYPE(dstr) >= SVt_PV);
4114 HEK_KEY(share_hek_hek(SvSHARED_HEK_FROM_PV(SvPVX_const(sstr)))));
4116 SvLEN_set(dstr, len);
4117 SvCUR_set(dstr, cur);
4118 SvREADONLY_on(dstr);
4122 { /* Passes the swipe test. */
4123 SvPV_set(dstr, SvPVX_mutable(sstr));
4124 SvLEN_set(dstr, SvLEN(sstr));
4125 SvCUR_set(dstr, SvCUR(sstr));
4128 (void)SvOK_off(sstr); /* NOTE: nukes most SvFLAGS on sstr */
4129 SvPV_set(sstr, NULL);
4135 if (sflags & SVp_NOK) {
4136 SvNV_set(dstr, SvNVX(sstr));
4138 if (sflags & SVp_IOK) {
4139 SvIV_set(dstr, SvIVX(sstr));
4140 /* Must do this otherwise some other overloaded use of 0x80000000
4141 gets confused. I guess SVpbm_VALID */
4142 if (sflags & SVf_IVisUV)
4145 SvFLAGS(dstr) |= sflags & (SVf_IOK|SVp_IOK|SVf_NOK|SVp_NOK|SVf_UTF8);
4147 const MAGIC * const smg = SvVSTRING_mg(sstr);
4149 sv_magic(dstr, NULL, PERL_MAGIC_vstring,
4150 smg->mg_ptr, smg->mg_len);
4151 SvRMAGICAL_on(dstr);
4155 else if (sflags & (SVp_IOK|SVp_NOK)) {
4156 (void)SvOK_off(dstr);
4157 SvFLAGS(dstr) |= sflags & (SVf_IOK|SVp_IOK|SVf_IVisUV|SVf_NOK|SVp_NOK);
4158 if (sflags & SVp_IOK) {
4159 /* XXXX Do we want to set IsUV for IV(ROK)? Be extra safe... */
4160 SvIV_set(dstr, SvIVX(sstr));
4162 if (sflags & SVp_NOK) {
4163 SvNV_set(dstr, SvNVX(sstr));
4167 if (isGV_with_GP(sstr)) {
4168 /* This stringification rule for globs is spread in 3 places.
4169 This feels bad. FIXME. */
4170 const U32 wasfake = sflags & SVf_FAKE;
4172 /* FAKE globs can get coerced, so need to turn this off
4173 temporarily if it is on. */
4175 gv_efullname3(dstr, MUTABLE_GV(sstr), "*");
4176 SvFLAGS(sstr) |= wasfake;
4179 (void)SvOK_off(dstr);
4181 if (SvTAINTED(sstr))
4186 =for apidoc sv_setsv_mg
4188 Like C<sv_setsv>, but also handles 'set' magic.
4194 Perl_sv_setsv_mg(pTHX_ SV *const dstr, register SV *const sstr)
4196 PERL_ARGS_ASSERT_SV_SETSV_MG;
4198 sv_setsv(dstr,sstr);
4202 #ifdef PERL_OLD_COPY_ON_WRITE
4204 Perl_sv_setsv_cow(pTHX_ SV *dstr, SV *sstr)
4206 STRLEN cur = SvCUR(sstr);
4207 STRLEN len = SvLEN(sstr);
4208 register char *new_pv;
4210 PERL_ARGS_ASSERT_SV_SETSV_COW;
4213 PerlIO_printf(Perl_debug_log, "Fast copy on write: %p -> %p\n",
4214 (void*)sstr, (void*)dstr);
4221 if (SvTHINKFIRST(dstr))
4222 sv_force_normal_flags(dstr, SV_COW_DROP_PV);
4223 else if (SvPVX_const(dstr))
4224 Safefree(SvPVX_const(dstr));
4228 SvUPGRADE(dstr, SVt_PVIV);
4230 assert (SvPOK(sstr));
4231 assert (SvPOKp(sstr));
4232 assert (!SvIOK(sstr));
4233 assert (!SvIOKp(sstr));
4234 assert (!SvNOK(sstr));
4235 assert (!SvNOKp(sstr));
4237 if (SvIsCOW(sstr)) {
4239 if (SvLEN(sstr) == 0) {
4240 /* source is a COW shared hash key. */
4241 DEBUG_C(PerlIO_printf(Perl_debug_log,
4242 "Fast copy on write: Sharing hash\n"));
4243 new_pv = HEK_KEY(share_hek_hek(SvSHARED_HEK_FROM_PV(SvPVX_const(sstr))));
4246 SV_COW_NEXT_SV_SET(dstr, SV_COW_NEXT_SV(sstr));
4248 assert ((SvFLAGS(sstr) & CAN_COW_MASK) == CAN_COW_FLAGS);
4249 SvUPGRADE(sstr, SVt_PVIV);
4250 SvREADONLY_on(sstr);
4252 DEBUG_C(PerlIO_printf(Perl_debug_log,
4253 "Fast copy on write: Converting sstr to COW\n"));
4254 SV_COW_NEXT_SV_SET(dstr, sstr);
4256 SV_COW_NEXT_SV_SET(sstr, dstr);
4257 new_pv = SvPVX_mutable(sstr);
4260 SvPV_set(dstr, new_pv);
4261 SvFLAGS(dstr) = (SVt_PVIV|SVf_POK|SVp_POK|SVf_FAKE|SVf_READONLY);
4264 SvLEN_set(dstr, len);
4265 SvCUR_set(dstr, cur);
4274 =for apidoc sv_setpvn
4276 Copies a string into an SV. The C<len> parameter indicates the number of
4277 bytes to be copied. If the C<ptr> argument is NULL the SV will become
4278 undefined. Does not handle 'set' magic. See C<sv_setpvn_mg>.
4284 Perl_sv_setpvn(pTHX_ register SV *const sv, register const char *const ptr, register const STRLEN len)
4287 register char *dptr;
4289 PERL_ARGS_ASSERT_SV_SETPVN;
4291 SV_CHECK_THINKFIRST_COW_DROP(sv);
4297 /* len is STRLEN which is unsigned, need to copy to signed */
4300 Perl_croak(aTHX_ "panic: sv_setpvn called with negative strlen");
4302 SvUPGRADE(sv, SVt_PV);
4304 dptr = SvGROW(sv, len + 1);
4305 Move(ptr,dptr,len,char);
4308 (void)SvPOK_only_UTF8(sv); /* validate pointer */
4313 =for apidoc sv_setpvn_mg
4315 Like C<sv_setpvn>, but also handles 'set' magic.
4321 Perl_sv_setpvn_mg(pTHX_ register SV *const sv, register const char *const ptr, register const STRLEN len)
4323 PERL_ARGS_ASSERT_SV_SETPVN_MG;
4325 sv_setpvn(sv,ptr,len);
4330 =for apidoc sv_setpv
4332 Copies a string into an SV. The string must be null-terminated. Does not
4333 handle 'set' magic. See C<sv_setpv_mg>.
4339 Perl_sv_setpv(pTHX_ register SV *const sv, register const char *const ptr)
4342 register STRLEN len;
4344 PERL_ARGS_ASSERT_SV_SETPV;
4346 SV_CHECK_THINKFIRST_COW_DROP(sv);
4352 SvUPGRADE(sv, SVt_PV);
4354 SvGROW(sv, len + 1);
4355 Move(ptr,SvPVX(sv),len+1,char);
4357 (void)SvPOK_only_UTF8(sv); /* validate pointer */
4362 =for apidoc sv_setpv_mg
4364 Like C<sv_setpv>, but also handles 'set' magic.
4370 Perl_sv_setpv_mg(pTHX_ register SV *const sv, register const char *const ptr)
4372 PERL_ARGS_ASSERT_SV_SETPV_MG;
4379 =for apidoc sv_usepvn_flags
4381 Tells an SV to use C<ptr> to find its string value. Normally the
4382 string is stored inside the SV but sv_usepvn allows the SV to use an
4383 outside string. The C<ptr> should point to memory that was allocated
4384 by C<malloc>. The string length, C<len>, must be supplied. By default
4385 this function will realloc (i.e. move) the memory pointed to by C<ptr>,
4386 so that pointer should not be freed or used by the programmer after
4387 giving it to sv_usepvn, and neither should any pointers from "behind"
4388 that pointer (e.g. ptr + 1) be used.
4390 If C<flags> & SV_SMAGIC is true, will call SvSETMAGIC. If C<flags> &
4391 SV_HAS_TRAILING_NUL is true, then C<ptr[len]> must be NUL, and the realloc
4392 will be skipped. (i.e. the buffer is actually at least 1 byte longer than
4393 C<len>, and already meets the requirements for storing in C<SvPVX>)
4399 Perl_sv_usepvn_flags(pTHX_ SV *const sv, char *ptr, const STRLEN len, const U32 flags)
4404 PERL_ARGS_ASSERT_SV_USEPVN_FLAGS;
4406 SV_CHECK_THINKFIRST_COW_DROP(sv);
4407 SvUPGRADE(sv, SVt_PV);
4410 if (flags & SV_SMAGIC)
4414 if (SvPVX_const(sv))
4418 if (flags & SV_HAS_TRAILING_NUL)
4419 assert(ptr[len] == '\0');
4422 allocate = (flags & SV_HAS_TRAILING_NUL)
4424 #ifdef Perl_safesysmalloc_size
4427 PERL_STRLEN_ROUNDUP(len + 1);
4429 if (flags & SV_HAS_TRAILING_NUL) {
4430 /* It's long enough - do nothing.
4431 Specfically Perl_newCONSTSUB is relying on this. */
4434 /* Force a move to shake out bugs in callers. */
4435 char *new_ptr = (char*)safemalloc(allocate);
4436 Copy(ptr, new_ptr, len, char);
4437 PoisonFree(ptr,len,char);
4441 ptr = (char*) saferealloc (ptr, allocate);
4444 #ifdef Perl_safesysmalloc_size
4445 SvLEN_set(sv, Perl_safesysmalloc_size(ptr));
4447 SvLEN_set(sv, allocate);
4451 if (!(flags & SV_HAS_TRAILING_NUL)) {
4454 (void)SvPOK_only_UTF8(sv); /* validate pointer */
4456 if (flags & SV_SMAGIC)
4460 #ifdef PERL_OLD_COPY_ON_WRITE
4461 /* Need to do this *after* making the SV normal, as we need the buffer
4462 pointer to remain valid until after we've copied it. If we let go too early,
4463 another thread could invalidate it by unsharing last of the same hash key
4464 (which it can do by means other than releasing copy-on-write Svs)
4465 or by changing the other copy-on-write SVs in the loop. */
4467 S_sv_release_COW(pTHX_ register SV *sv, const char *pvx, SV *after)
4469 PERL_ARGS_ASSERT_SV_RELEASE_COW;
4471 { /* this SV was SvIsCOW_normal(sv) */
4472 /* we need to find the SV pointing to us. */
4473 SV *current = SV_COW_NEXT_SV(after);
4475 if (current == sv) {
4476 /* The SV we point to points back to us (there were only two of us
4478 Hence other SV is no longer copy on write either. */
4480 SvREADONLY_off(after);
4482 /* We need to follow the pointers around the loop. */
4484 while ((next = SV_COW_NEXT_SV(current)) != sv) {
4487 /* don't loop forever if the structure is bust, and we have
4488 a pointer into a closed loop. */
4489 assert (current != after);
4490 assert (SvPVX_const(current) == pvx);
4492 /* Make the SV before us point to the SV after us. */
4493 SV_COW_NEXT_SV_SET(current, after);
4499 =for apidoc sv_force_normal_flags
4501 Undo various types of fakery on an SV: if the PV is a shared string, make
4502 a private copy; if we're a ref, stop refing; if we're a glob, downgrade to
4503 an xpvmg; if we're a copy-on-write scalar, this is the on-write time when
4504 we do the copy, and is also used locally. If C<SV_COW_DROP_PV> is set
4505 then a copy-on-write scalar drops its PV buffer (if any) and becomes
4506 SvPOK_off rather than making a copy. (Used where this scalar is about to be
4507 set to some other value.) In addition, the C<flags> parameter gets passed to
4508 C<sv_unref_flags()> when unrefing. C<sv_force_normal> calls this function
4509 with flags set to 0.
4515 Perl_sv_force_normal_flags(pTHX_ register SV *const sv, const U32 flags)
4519 PERL_ARGS_ASSERT_SV_FORCE_NORMAL_FLAGS;
4521 #ifdef PERL_OLD_COPY_ON_WRITE
4522 if (SvREADONLY(sv)) {
4524 const char * const pvx = SvPVX_const(sv);
4525 const STRLEN len = SvLEN(sv);
4526 const STRLEN cur = SvCUR(sv);
4527 /* next COW sv in the loop. If len is 0 then this is a shared-hash
4528 key scalar, so we mustn't attempt to call SV_COW_NEXT_SV(), as
4529 we'll fail an assertion. */
4530 SV * const next = len ? SV_COW_NEXT_SV(sv) : 0;
4533 PerlIO_printf(Perl_debug_log,
4534 "Copy on write: Force normal %ld\n",
4540 /* This SV doesn't own the buffer, so need to Newx() a new one: */
4543 if (flags & SV_COW_DROP_PV) {
4544 /* OK, so we don't need to copy our buffer. */
4547 SvGROW(sv, cur + 1);
4548 Move(pvx,SvPVX(sv),cur,char);
4553 sv_release_COW(sv, pvx, next);
4555 unshare_hek(SvSHARED_HEK_FROM_PV(pvx));
4561 else if (IN_PERL_RUNTIME)
4562 Perl_croak(aTHX_ "%s", PL_no_modify);
4565 if (SvREADONLY(sv)) {
4567 const char * const pvx = SvPVX_const(sv);
4568 const STRLEN len = SvCUR(sv);
4573 SvGROW(sv, len + 1);
4574 Move(pvx,SvPVX(sv),len,char);
4576 unshare_hek(SvSHARED_HEK_FROM_PV(pvx));
4578 else if (IN_PERL_RUNTIME)
4579 Perl_croak(aTHX_ "%s", PL_no_modify);
4583 sv_unref_flags(sv, flags);
4584 else if (SvFAKE(sv) && SvTYPE(sv) == SVt_PVGV)
4591 Efficient removal of characters from the beginning of the string buffer.
4592 SvPOK(sv) must be true and the C<ptr> must be a pointer to somewhere inside
4593 the string buffer. The C<ptr> becomes the first character of the adjusted
4594 string. Uses the "OOK hack".
4595 Beware: after this function returns, C<ptr> and SvPVX_const(sv) may no longer
4596 refer to the same chunk of data.
4602 Perl_sv_chop(pTHX_ register SV *const sv, register const char *const ptr)
4608 const U8 *real_start;
4612 PERL_ARGS_ASSERT_SV_CHOP;
4614 if (!ptr || !SvPOKp(sv))
4616 delta = ptr - SvPVX_const(sv);
4618 /* Nothing to do. */
4621 /* SvPVX(sv) may move in SV_CHECK_THINKFIRST(sv), but after this line,
4622 nothing uses the value of ptr any more. */
4623 max_delta = SvLEN(sv) ? SvLEN(sv) : SvCUR(sv);
4624 if (ptr <= SvPVX_const(sv))
4625 Perl_croak(aTHX_ "panic: sv_chop ptr=%p, start=%p, end=%p",
4626 ptr, SvPVX_const(sv), SvPVX_const(sv) + max_delta);
4627 SV_CHECK_THINKFIRST(sv);
4628 if (delta > max_delta)
4629 Perl_croak(aTHX_ "panic: sv_chop ptr=%p (was %p), start=%p, end=%p",
4630 SvPVX_const(sv) + delta, ptr, SvPVX_const(sv),
4631 SvPVX_const(sv) + max_delta);
4634 if (!SvLEN(sv)) { /* make copy of shared string */
4635 const char *pvx = SvPVX_const(sv);
4636 const STRLEN len = SvCUR(sv);
4637 SvGROW(sv, len + 1);
4638 Move(pvx,SvPVX(sv),len,char);
4641 SvFLAGS(sv) |= SVf_OOK;
4644 SvOOK_offset(sv, old_delta);
4646 SvLEN_set(sv, SvLEN(sv) - delta);
4647 SvCUR_set(sv, SvCUR(sv) - delta);
4648 SvPV_set(sv, SvPVX(sv) + delta);
4650 p = (U8 *)SvPVX_const(sv);
4655 real_start = p - delta;
4659 if (delta < 0x100) {
4663 p -= sizeof(STRLEN);
4664 Copy((U8*)&delta, p, sizeof(STRLEN), U8);
4668 /* Fill the preceding buffer with sentinals to verify that no-one is
4670 while (p > real_start) {
4678 =for apidoc sv_catpvn
4680 Concatenates the string onto the end of the string which is in the SV. The
4681 C<len> indicates number of bytes to copy. If the SV has the UTF-8
4682 status set, then the bytes appended should be valid UTF-8.
4683 Handles 'get' magic, but not 'set' magic. See C<sv_catpvn_mg>.
4685 =for apidoc sv_catpvn_flags
4687 Concatenates the string onto the end of the string which is in the SV. The
4688 C<len> indicates number of bytes to copy. If the SV has the UTF-8
4689 status set, then the bytes appended should be valid UTF-8.
4690 If C<flags> has C<SV_GMAGIC> bit set, will C<mg_get> on C<dsv> if
4691 appropriate, else not. C<sv_catpvn> and C<sv_catpvn_nomg> are implemented
4692 in terms of this function.
4698 Perl_sv_catpvn_flags(pTHX_ register SV *const dsv, register const char *sstr, register const STRLEN slen, const I32 flags)
4702 const char * const dstr = SvPV_force_flags(dsv, dlen, flags);
4704 PERL_ARGS_ASSERT_SV_CATPVN_FLAGS;
4706 SvGROW(dsv, dlen + slen + 1);
4708 sstr = SvPVX_const(dsv);
4709 Move(sstr, SvPVX(dsv) + dlen, slen, char);
4710 SvCUR_set(dsv, SvCUR(dsv) + slen);
4712 (void)SvPOK_only_UTF8(dsv); /* validate pointer */
4714 if (flags & SV_SMAGIC)
4719 =for apidoc sv_catsv
4721 Concatenates the string from SV C<ssv> onto the end of the string in
4722 SV C<dsv>. Modifies C<dsv> but not C<ssv>. Handles 'get' magic, but
4723 not 'set' magic. See C<sv_catsv_mg>.
4725 =for apidoc sv_catsv_flags
4727 Concatenates the string from SV C<ssv> onto the end of the string in
4728 SV C<dsv>. Modifies C<dsv> but not C<ssv>. If C<flags> has C<SV_GMAGIC>
4729 bit set, will C<mg_get> on the SVs if appropriate, else not. C<sv_catsv>
4730 and C<sv_catsv_nomg> are implemented in terms of this function.
4735 Perl_sv_catsv_flags(pTHX_ SV *const dsv, register SV *const ssv, const I32 flags)
4739 PERL_ARGS_ASSERT_SV_CATSV_FLAGS;
4743 const char *spv = SvPV_const(ssv, slen);
4745 /* sutf8 and dutf8 were type bool, but under USE_ITHREADS,
4746 gcc version 2.95.2 20000220 (Debian GNU/Linux) for
4747 Linux xxx 2.2.17 on sparc64 with gcc -O2, we erroneously
4748 get dutf8 = 0x20000000, (i.e. SVf_UTF8) even though
4749 dsv->sv_flags doesn't have that bit set.
4750 Andy Dougherty 12 Oct 2001
4752 const I32 sutf8 = DO_UTF8(ssv);
4755 if (SvGMAGICAL(dsv) && (flags & SV_GMAGIC))
4757 dutf8 = DO_UTF8(dsv);
4759 if (dutf8 != sutf8) {
4761 /* Not modifying source SV, so taking a temporary copy. */
4762 SV* const csv = newSVpvn_flags(spv, slen, SVs_TEMP);
4764 sv_utf8_upgrade(csv);
4765 spv = SvPV_const(csv, slen);
4768 /* Leave enough space for the cat that's about to happen */
4769 sv_utf8_upgrade_flags_grow(dsv, 0, slen);
4771 sv_catpvn_nomg(dsv, spv, slen);
4774 if (flags & SV_SMAGIC)
4779 =for apidoc sv_catpv
4781 Concatenates the string onto the end of the string which is in the SV.
4782 If the SV has the UTF-8 status set, then the bytes appended should be
4783 valid UTF-8. Handles 'get' magic, but not 'set' magic. See C<sv_catpv_mg>.
4788 Perl_sv_catpv(pTHX_ register SV *const sv, register const char *ptr)
4791 register STRLEN len;
4795 PERL_ARGS_ASSERT_SV_CATPV;
4799 junk = SvPV_force(sv, tlen);
4801 SvGROW(sv, tlen + len + 1);
4803 ptr = SvPVX_const(sv);
4804 Move(ptr,SvPVX(sv)+tlen,len+1,char);
4805 SvCUR_set(sv, SvCUR(sv) + len);
4806 (void)SvPOK_only_UTF8(sv); /* validate pointer */
4811 =for apidoc sv_catpv_mg
4813 Like C<sv_catpv>, but also handles 'set' magic.
4819 Perl_sv_catpv_mg(pTHX_ register SV *const sv, register const char *const ptr)
4821 PERL_ARGS_ASSERT_SV_CATPV_MG;
4830 Creates a new SV. A non-zero C<len> parameter indicates the number of
4831 bytes of preallocated string space the SV should have. An extra byte for a
4832 trailing NUL is also reserved. (SvPOK is not set for the SV even if string
4833 space is allocated.) The reference count for the new SV is set to 1.
4835 In 5.9.3, newSV() replaces the older NEWSV() API, and drops the first
4836 parameter, I<x>, a debug aid which allowed callers to identify themselves.
4837 This aid has been superseded by a new build option, PERL_MEM_LOG (see
4838 L<perlhack/PERL_MEM_LOG>). The older API is still there for use in XS
4839 modules supporting older perls.
4845 Perl_newSV(pTHX_ const STRLEN len)
4852 sv_upgrade(sv, SVt_PV);
4853 SvGROW(sv, len + 1);
4858 =for apidoc sv_magicext
4860 Adds magic to an SV, upgrading it if necessary. Applies the
4861 supplied vtable and returns a pointer to the magic added.
4863 Note that C<sv_magicext> will allow things that C<sv_magic> will not.
4864 In particular, you can add magic to SvREADONLY SVs, and add more than
4865 one instance of the same 'how'.
4867 If C<namlen> is greater than zero then a C<savepvn> I<copy> of C<name> is
4868 stored, if C<namlen> is zero then C<name> is stored as-is and - as another
4869 special case - if C<(name && namlen == HEf_SVKEY)> then C<name> is assumed
4870 to contain an C<SV*> and is stored as-is with its REFCNT incremented.
4872 (This is now used as a subroutine by C<sv_magic>.)
4877 Perl_sv_magicext(pTHX_ SV *const sv, SV *const obj, const int how,
4878 const MGVTBL *const vtable, const char *const name, const I32 namlen)
4883 PERL_ARGS_ASSERT_SV_MAGICEXT;
4885 SvUPGRADE(sv, SVt_PVMG);
4886 Newxz(mg, 1, MAGIC);
4887 mg->mg_moremagic = SvMAGIC(sv);
4888 SvMAGIC_set(sv, mg);
4890 /* Sometimes a magic contains a reference loop, where the sv and
4891 object refer to each other. To prevent a reference loop that
4892 would prevent such objects being freed, we look for such loops
4893 and if we find one we avoid incrementing the object refcount.
4895 Note we cannot do this to avoid self-tie loops as intervening RV must
4896 have its REFCNT incremented to keep it in existence.
4899 if (!obj || obj == sv ||
4900 how == PERL_MAGIC_arylen ||
4901 how == PERL_MAGIC_symtab ||
4902 (SvTYPE(obj) == SVt_PVGV &&
4903 (GvSV(obj) == sv || GvHV(obj) == (const HV *)sv
4904 || GvAV(obj) == (const AV *)sv || GvCV(obj) == (const CV *)sv
4905 || GvIOp(obj) == (const IO *)sv || GvFORM(obj) == (const CV *)sv)))
4910 mg->mg_obj = SvREFCNT_inc_simple(obj);
4911 mg->mg_flags |= MGf_REFCOUNTED;
4914 /* Normal self-ties simply pass a null object, and instead of
4915 using mg_obj directly, use the SvTIED_obj macro to produce a
4916 new RV as needed. For glob "self-ties", we are tieing the PVIO
4917 with an RV obj pointing to the glob containing the PVIO. In
4918 this case, to avoid a reference loop, we need to weaken the
4922 if (how == PERL_MAGIC_tiedscalar && SvTYPE(sv) == SVt_PVIO &&
4923 obj && SvROK(obj) && GvIO(SvRV(obj)) == (const IO *)sv)
4929 mg->mg_len = namlen;
4932 mg->mg_ptr = savepvn(name, namlen);
4933 else if (namlen == HEf_SVKEY) {
4934 /* Yes, this is casting away const. This is only for the case of
4935 HEf_SVKEY. I think we need to document this abberation of the
4936 constness of the API, rather than making name non-const, as
4937 that change propagating outwards a long way. */
4938 mg->mg_ptr = (char*)SvREFCNT_inc_simple_NN((SV *)name);
4940 mg->mg_ptr = (char *) name;
4942 mg->mg_virtual = (MGVTBL *) vtable;
4946 SvFLAGS(sv) &= ~(SVf_IOK|SVf_NOK|SVf_POK);
4951 =for apidoc sv_magic
4953 Adds magic to an SV. First upgrades C<sv> to type C<SVt_PVMG> if necessary,
4954 then adds a new magic item of type C<how> to the head of the magic list.
4956 See C<sv_magicext> (which C<sv_magic> now calls) for a description of the
4957 handling of the C<name> and C<namlen> arguments.
4959 You need to use C<sv_magicext> to add magic to SvREADONLY SVs and also
4960 to add more than one instance of the same 'how'.
4966 Perl_sv_magic(pTHX_ register SV *const sv, SV *const obj, const int how,
4967 const char *const name, const I32 namlen)
4970 const MGVTBL *vtable;
4973 PERL_ARGS_ASSERT_SV_MAGIC;
4975 #ifdef PERL_OLD_COPY_ON_WRITE
4977 sv_force_normal_flags(sv, 0);
4979 if (SvREADONLY(sv)) {
4981 /* its okay to attach magic to shared strings; the subsequent
4982 * upgrade to PVMG will unshare the string */
4983 !(SvFAKE(sv) && SvTYPE(sv) < SVt_PVMG)
4986 && how != PERL_MAGIC_regex_global
4987 && how != PERL_MAGIC_bm
4988 && how != PERL_MAGIC_fm
4989 && how != PERL_MAGIC_sv
4990 && how != PERL_MAGIC_backref
4993 Perl_croak(aTHX_ "%s", PL_no_modify);
4996 if (SvMAGICAL(sv) || (how == PERL_MAGIC_taint && SvTYPE(sv) >= SVt_PVMG)) {
4997 if (SvMAGIC(sv) && (mg = mg_find(sv, how))) {
4998 /* sv_magic() refuses to add a magic of the same 'how' as an
5001 if (how == PERL_MAGIC_taint) {
5003 /* Any scalar which already had taint magic on which someone
5004 (erroneously?) did SvIOK_on() or similar will now be
5005 incorrectly sporting public "OK" flags. */
5006 SvFLAGS(sv) &= ~(SVf_IOK|SVf_NOK|SVf_POK);
5014 vtable = &PL_vtbl_sv;
5016 case PERL_MAGIC_overload:
5017 vtable = &PL_vtbl_amagic;
5019 case PERL_MAGIC_overload_elem:
5020 vtable = &PL_vtbl_amagicelem;
5022 case PERL_MAGIC_overload_table:
5023 vtable = &PL_vtbl_ovrld;
5026 vtable = &PL_vtbl_bm;
5028 case PERL_MAGIC_regdata:
5029 vtable = &PL_vtbl_regdata;
5031 case PERL_MAGIC_regdatum:
5032 vtable = &PL_vtbl_regdatum;
5034 case PERL_MAGIC_env:
5035 vtable = &PL_vtbl_env;
5038 vtable = &PL_vtbl_fm;
5040 case PERL_MAGIC_envelem:
5041 vtable = &PL_vtbl_envelem;
5043 case PERL_MAGIC_regex_global:
5044 vtable = &PL_vtbl_mglob;
5046 case PERL_MAGIC_isa:
5047 vtable = &PL_vtbl_isa;
5049 case PERL_MAGIC_isaelem:
5050 vtable = &PL_vtbl_isaelem;
5052 case PERL_MAGIC_nkeys:
5053 vtable = &PL_vtbl_nkeys;
5055 case PERL_MAGIC_dbfile:
5058 case PERL_MAGIC_dbline:
5059 vtable = &PL_vtbl_dbline;
5061 #ifdef USE_LOCALE_COLLATE
5062 case PERL_MAGIC_collxfrm:
5063 vtable = &PL_vtbl_collxfrm;
5065 #endif /* USE_LOCALE_COLLATE */
5066 case PERL_MAGIC_tied:
5067 vtable = &PL_vtbl_pack;
5069 case PERL_MAGIC_tiedelem:
5070 case PERL_MAGIC_tiedscalar:
5071 vtable = &PL_vtbl_packelem;
5074 vtable = &PL_vtbl_regexp;
5076 case PERL_MAGIC_hints:
5077 /* As this vtable is all NULL, we can reuse it. */
5078 case PERL_MAGIC_sig:
5079 vtable = &PL_vtbl_sig;
5081 case PERL_MAGIC_sigelem:
5082 vtable = &PL_vtbl_sigelem;
5084 case PERL_MAGIC_taint:
5085 vtable = &PL_vtbl_taint;
5087 case PERL_MAGIC_uvar:
5088 vtable = &PL_vtbl_uvar;
5090 case PERL_MAGIC_vec:
5091 vtable = &PL_vtbl_vec;
5093 case PERL_MAGIC_arylen_p:
5094 case PERL_MAGIC_rhash:
5095 case PERL_MAGIC_symtab:
5096 case PERL_MAGIC_vstring:
5099 case PERL_MAGIC_utf8:
5100 vtable = &PL_vtbl_utf8;
5102 case PERL_MAGIC_substr:
5103 vtable = &PL_vtbl_substr;
5105 case PERL_MAGIC_defelem:
5106 vtable = &PL_vtbl_defelem;
5108 case PERL_MAGIC_arylen:
5109 vtable = &PL_vtbl_arylen;
5111 case PERL_MAGIC_pos:
5112 vtable = &PL_vtbl_pos;
5114 case PERL_MAGIC_backref:
5115 vtable = &PL_vtbl_backref;
5117 case PERL_MAGIC_hintselem:
5118 vtable = &PL_vtbl_hintselem;
5120 case PERL_MAGIC_ext:
5121 /* Reserved for use by extensions not perl internals. */
5122 /* Useful for attaching extension internal data to perl vars. */
5123 /* Note that multiple extensions may clash if magical scalars */
5124 /* etc holding private data from one are passed to another. */
5128 Perl_croak(aTHX_ "Don't know how to handle magic of type \\%o", how);
5131 /* Rest of work is done else where */
5132 mg = sv_magicext(sv,obj,how,vtable,name,namlen);
5135 case PERL_MAGIC_taint:
5138 case PERL_MAGIC_ext:
5139 case PERL_MAGIC_dbfile:
5146 =for apidoc sv_unmagic
5148 Removes all magic of type C<type> from an SV.
5154 Perl_sv_unmagic(pTHX_ SV *const sv, const int type)
5159 PERL_ARGS_ASSERT_SV_UNMAGIC;
5161 if (SvTYPE(sv) < SVt_PVMG || !SvMAGIC(sv))
5163 mgp = &(((XPVMG*) SvANY(sv))->xmg_u.xmg_magic);
5164 for (mg = *mgp; mg; mg = *mgp) {
5165 if (mg->mg_type == type) {
5166 const MGVTBL* const vtbl = mg->mg_virtual;
5167 *mgp = mg->mg_moremagic;
5168 if (vtbl && vtbl->svt_free)
5169 CALL_FPTR(vtbl->svt_free)(aTHX_ sv, mg);
5170 if (mg->mg_ptr && mg->mg_type != PERL_MAGIC_regex_global) {
5172 Safefree(mg->mg_ptr);
5173 else if (mg->mg_len == HEf_SVKEY)
5174 SvREFCNT_dec(MUTABLE_SV(mg->mg_ptr));
5175 else if (mg->mg_type == PERL_MAGIC_utf8)
5176 Safefree(mg->mg_ptr);
5178 if (mg->mg_flags & MGf_REFCOUNTED)
5179 SvREFCNT_dec(mg->mg_obj);
5183 mgp = &mg->mg_moremagic;
5187 SvFLAGS(sv) |= (SvFLAGS(sv) & (SVp_IOK|SVp_NOK|SVp_POK)) >> PRIVSHIFT;
5188 SvMAGIC_set(sv, NULL);
5195 =for apidoc sv_rvweaken
5197 Weaken a reference: set the C<SvWEAKREF> flag on this RV; give the
5198 referred-to SV C<PERL_MAGIC_backref> magic if it hasn't already; and
5199 push a back-reference to this RV onto the array of backreferences
5200 associated with that magic. If the RV is magical, set magic will be
5201 called after the RV is cleared.
5207 Perl_sv_rvweaken(pTHX_ SV *const sv)
5211 PERL_ARGS_ASSERT_SV_RVWEAKEN;
5213 if (!SvOK(sv)) /* let undefs pass */
5216 Perl_croak(aTHX_ "Can't weaken a nonreference");
5217 else if (SvWEAKREF(sv)) {
5218 if (ckWARN(WARN_MISC))
5219 Perl_warner(aTHX_ packWARN(WARN_MISC), "Reference is already weak");
5223 Perl_sv_add_backref(aTHX_ tsv, sv);
5229 /* Give tsv backref magic if it hasn't already got it, then push a
5230 * back-reference to sv onto the array associated with the backref magic.
5233 /* A discussion about the backreferences array and its refcount:
5235 * The AV holding the backreferences is pointed to either as the mg_obj of
5236 * PERL_MAGIC_backref, or in the specific case of a HV that has the hv_aux
5237 * structure, from the xhv_backreferences field. (A HV without hv_aux will
5238 * have the standard magic instead.) The array is created with a refcount
5239 * of 2. This means that if during global destruction the array gets
5240 * picked on first to have its refcount decremented by the random zapper,
5241 * it won't actually be freed, meaning it's still theere for when its
5242 * parent gets freed.
5243 * When the parent SV is freed, in the case of magic, the magic is freed,
5244 * Perl_magic_killbackrefs is called which decrements one refcount, then
5245 * mg_obj is freed which kills the second count.
5246 * In the vase of a HV being freed, one ref is removed by
5247 * Perl_hv_kill_backrefs, the other by Perl_sv_kill_backrefs, which it
5252 Perl_sv_add_backref(pTHX_ SV *const tsv, SV *const sv)
5257 PERL_ARGS_ASSERT_SV_ADD_BACKREF;
5259 if (SvTYPE(tsv) == SVt_PVHV) {
5260 AV **const avp = Perl_hv_backreferences_p(aTHX_ MUTABLE_HV(tsv));
5264 /* There is no AV in the offical place - try a fixup. */
5265 MAGIC *const mg = mg_find(tsv, PERL_MAGIC_backref);
5268 /* Aha. They've got it stowed in magic. Bring it back. */
5269 av = MUTABLE_AV(mg->mg_obj);
5270 /* Stop mg_free decreasing the refernce count. */
5272 /* Stop mg_free even calling the destructor, given that
5273 there's no AV to free up. */
5275 sv_unmagic(tsv, PERL_MAGIC_backref);
5279 SvREFCNT_inc_simple_void(av); /* see discussion above */
5284 const MAGIC *const mg
5285 = SvMAGICAL(tsv) ? mg_find(tsv, PERL_MAGIC_backref) : NULL;
5287 av = MUTABLE_AV(mg->mg_obj);
5291 sv_magic(tsv, MUTABLE_SV(av), PERL_MAGIC_backref, NULL, 0);
5292 /* av now has a refcnt of 2; see discussion above */
5295 if (AvFILLp(av) >= AvMAX(av)) {
5296 av_extend(av, AvFILLp(av)+1);
5298 AvARRAY(av)[++AvFILLp(av)] = sv; /* av_push() */
5301 /* delete a back-reference to ourselves from the backref magic associated
5302 * with the SV we point to.
5306 S_sv_del_backref(pTHX_ SV *const tsv, SV *const sv)
5313 PERL_ARGS_ASSERT_SV_DEL_BACKREF;
5315 if (SvTYPE(tsv) == SVt_PVHV && SvOOK(tsv)) {
5316 av = *Perl_hv_backreferences_p(aTHX_ MUTABLE_HV(tsv));
5317 /* We mustn't attempt to "fix up" the hash here by moving the
5318 backreference array back to the hv_aux structure, as that is stored
5319 in the main HvARRAY(), and hfreentries assumes that no-one
5320 reallocates HvARRAY() while it is running. */
5323 const MAGIC *const mg
5324 = SvMAGICAL(tsv) ? mg_find(tsv, PERL_MAGIC_backref) : NULL;
5326 av = MUTABLE_AV(mg->mg_obj);
5330 Perl_croak(aTHX_ "panic: del_backref");
5332 assert(!SvIS_FREED(av));
5335 /* We shouldn't be in here more than once, but for paranoia reasons lets
5337 for (i = AvFILLp(av); i >= 0; i--) {
5339 const SSize_t fill = AvFILLp(av);
5341 /* We weren't the last entry.
5342 An unordered list has this property that you can take the
5343 last element off the end to fill the hole, and it's still
5344 an unordered list :-)
5349 AvFILLp(av) = fill - 1;
5355 Perl_sv_kill_backrefs(pTHX_ SV *const sv, AV *const av)
5357 SV **svp = AvARRAY(av);
5359 PERL_ARGS_ASSERT_SV_KILL_BACKREFS;
5360 PERL_UNUSED_ARG(sv);
5362 assert(!svp || !SvIS_FREED(av));
5364 SV *const *const last = svp + AvFILLp(av);
5366 while (svp <= last) {
5368 SV *const referrer = *svp;
5369 if (SvWEAKREF(referrer)) {
5370 /* XXX Should we check that it hasn't changed? */
5371 SvRV_set(referrer, 0);
5373 SvWEAKREF_off(referrer);
5374 SvSETMAGIC(referrer);
5375 } else if (SvTYPE(referrer) == SVt_PVGV ||
5376 SvTYPE(referrer) == SVt_PVLV) {
5377 /* You lookin' at me? */
5378 assert(GvSTASH(referrer));
5379 assert(GvSTASH(referrer) == (const HV *)sv);
5380 GvSTASH(referrer) = 0;
5383 "panic: magic_killbackrefs (flags=%"UVxf")",
5384 (UV)SvFLAGS(referrer));
5392 SvREFCNT_dec(av); /* remove extra count added by sv_add_backref() */
5397 =for apidoc sv_insert
5399 Inserts a string at the specified offset/length within the SV. Similar to
5400 the Perl substr() function. Handles get magic.
5402 =for apidoc sv_insert_flags
5404 Same as C<sv_insert>, but the extra C<flags> are passed the C<SvPV_force_flags> that applies to C<bigstr>.
5410 Perl_sv_insert_flags(pTHX_ SV *const bigstr, const STRLEN offset, const STRLEN len, const char *const little, const STRLEN littlelen, const U32 flags)
5415 register char *midend;
5416 register char *bigend;
5420 PERL_ARGS_ASSERT_SV_INSERT_FLAGS;
5423 Perl_croak(aTHX_ "Can't modify non-existent substring");
5424 SvPV_force_flags(bigstr, curlen, flags);
5425 (void)SvPOK_only_UTF8(bigstr);
5426 if (offset + len > curlen) {
5427 SvGROW(bigstr, offset+len+1);
5428 Zero(SvPVX(bigstr)+curlen, offset+len-curlen, char);
5429 SvCUR_set(bigstr, offset+len);
5433 i = littlelen - len;
5434 if (i > 0) { /* string might grow */
5435 big = SvGROW(bigstr, SvCUR(bigstr) + i + 1);
5436 mid = big + offset + len;
5437 midend = bigend = big + SvCUR(bigstr);
5440 while (midend > mid) /* shove everything down */
5441 *--bigend = *--midend;
5442 Move(little,big+offset,littlelen,char);
5443 SvCUR_set(bigstr, SvCUR(bigstr) + i);
5448 Move(little,SvPVX(bigstr)+offset,len,char);
5453 big = SvPVX(bigstr);
5456 bigend = big + SvCUR(bigstr);
5458 if (midend > bigend)
5459 Perl_croak(aTHX_ "panic: sv_insert");
5461 if (mid - big > bigend - midend) { /* faster to shorten from end */
5463 Move(little, mid, littlelen,char);
5466 i = bigend - midend;
5468 Move(midend, mid, i,char);
5472 SvCUR_set(bigstr, mid - big);
5474 else if ((i = mid - big)) { /* faster from front */
5475 midend -= littlelen;
5477 Move(big, midend - i, i, char);
5478 sv_chop(bigstr,midend-i);
5480 Move(little, mid, littlelen,char);
5482 else if (littlelen) {
5483 midend -= littlelen;
5484 sv_chop(bigstr,midend);
5485 Move(little,midend,littlelen,char);
5488 sv_chop(bigstr,midend);
5494 =for apidoc sv_replace
5496 Make the first argument a copy of the second, then delete the original.
5497 The target SV physically takes over ownership of the body of the source SV
5498 and inherits its flags; however, the target keeps any magic it owns,
5499 and any magic in the source is discarded.
5500 Note that this is a rather specialist SV copying operation; most of the
5501 time you'll want to use C<sv_setsv> or one of its many macro front-ends.
5507 Perl_sv_replace(pTHX_ register SV *const sv, register SV *const nsv)
5510 const U32 refcnt = SvREFCNT(sv);
5512 PERL_ARGS_ASSERT_SV_REPLACE;
5514 SV_CHECK_THINKFIRST_COW_DROP(sv);
5515 if (SvREFCNT(nsv) != 1) {
5516 Perl_croak(aTHX_ "panic: reference miscount on nsv in sv_replace()"
5517 " (%" UVuf " != 1)", (UV) SvREFCNT(nsv));
5519 if (SvMAGICAL(sv)) {
5523 sv_upgrade(nsv, SVt_PVMG);
5524 SvMAGIC_set(nsv, SvMAGIC(sv));
5525 SvFLAGS(nsv) |= SvMAGICAL(sv);
5527 SvMAGIC_set(sv, NULL);
5531 assert(!SvREFCNT(sv));
5532 #ifdef DEBUG_LEAKING_SCALARS
5533 sv->sv_flags = nsv->sv_flags;
5534 sv->sv_any = nsv->sv_any;
5535 sv->sv_refcnt = nsv->sv_refcnt;
5536 sv->sv_u = nsv->sv_u;
5538 StructCopy(nsv,sv,SV);
5540 if(SvTYPE(sv) == SVt_IV) {
5542 = (XPVIV*)((char*)&(sv->sv_u.svu_iv) - STRUCT_OFFSET(XPVIV, xiv_iv));
5546 #ifdef PERL_OLD_COPY_ON_WRITE
5547 if (SvIsCOW_normal(nsv)) {
5548 /* We need to follow the pointers around the loop to make the
5549 previous SV point to sv, rather than nsv. */
5552 while ((next = SV_COW_NEXT_SV(current)) != nsv) {
5555 assert(SvPVX_const(current) == SvPVX_const(nsv));
5557 /* Make the SV before us point to the SV after us. */
5559 PerlIO_printf(Perl_debug_log, "previous is\n");
5561 PerlIO_printf(Perl_debug_log,
5562 "move it from 0x%"UVxf" to 0x%"UVxf"\n",
5563 (UV) SV_COW_NEXT_SV(current), (UV) sv);
5565 SV_COW_NEXT_SV_SET(current, sv);
5568 SvREFCNT(sv) = refcnt;
5569 SvFLAGS(nsv) |= SVTYPEMASK; /* Mark as freed */
5575 =for apidoc sv_clear
5577 Clear an SV: call any destructors, free up any memory used by the body,
5578 and free the body itself. The SV's head is I<not> freed, although
5579 its type is set to all 1's so that it won't inadvertently be assumed
5580 to be live during global destruction etc.
5581 This function should only be called when REFCNT is zero. Most of the time
5582 you'll want to call C<sv_free()> (or its macro wrapper C<SvREFCNT_dec>)
5589 Perl_sv_clear(pTHX_ register SV *const sv)
5592 const U32 type = SvTYPE(sv);
5593 const struct body_details *const sv_type_details
5594 = bodies_by_type + type;
5597 PERL_ARGS_ASSERT_SV_CLEAR;
5598 assert(SvREFCNT(sv) == 0);
5599 assert(SvTYPE(sv) != SVTYPEMASK);
5601 if (type <= SVt_IV) {
5602 /* See the comment in sv.h about the collusion between this early
5603 return and the overloading of the NULL and IV slots in the size
5606 SV * const target = SvRV(sv);
5608 sv_del_backref(target, sv);
5610 SvREFCNT_dec(target);
5612 SvFLAGS(sv) &= SVf_BREAK;
5613 SvFLAGS(sv) |= SVTYPEMASK;
5618 if (PL_defstash && /* Still have a symbol table? */
5625 stash = SvSTASH(sv);
5626 destructor = StashHANDLER(stash,DESTROY);
5628 /* A constant subroutine can have no side effects, so
5629 don't bother calling it. */
5630 && !CvCONST(destructor)
5631 /* Don't bother calling an empty destructor */
5632 && (CvISXSUB(destructor)
5633 || CvSTART(destructor)->op_next->op_type != OP_LEAVESUB))
5635 SV* const tmpref = newRV(sv);
5636 SvREADONLY_on(tmpref); /* DESTROY() could be naughty */
5638 PUSHSTACKi(PERLSI_DESTROY);
5643 call_sv(MUTABLE_SV(destructor), G_DISCARD|G_EVAL|G_KEEPERR|G_VOID);
5649 if(SvREFCNT(tmpref) < 2) {
5650 /* tmpref is not kept alive! */
5652 SvRV_set(tmpref, NULL);
5655 SvREFCNT_dec(tmpref);
5657 } while (SvOBJECT(sv) && SvSTASH(sv) != stash);
5661 if (PL_in_clean_objs)
5662 Perl_croak(aTHX_ "DESTROY created new reference to dead object '%s'",
5664 /* DESTROY gave object new lease on life */
5670 SvREFCNT_dec(SvSTASH(sv)); /* possibly of changed persuasion */
5671 SvOBJECT_off(sv); /* Curse the object. */
5672 if (type != SVt_PVIO)
5673 --PL_sv_objcount; /* XXX Might want something more general */
5676 if (type >= SVt_PVMG) {
5677 if (type == SVt_PVMG && SvPAD_OUR(sv)) {
5678 SvREFCNT_dec(SvOURSTASH(sv));
5679 } else if (SvMAGIC(sv))
5681 if (type == SVt_PVMG && SvPAD_TYPED(sv))
5682 SvREFCNT_dec(SvSTASH(sv));
5685 /* case SVt_BIND: */
5688 IoIFP(sv) != PerlIO_stdin() &&
5689 IoIFP(sv) != PerlIO_stdout() &&
5690 IoIFP(sv) != PerlIO_stderr())
5692 io_close(MUTABLE_IO(sv), FALSE);
5694 if (IoDIRP(sv) && !(IoFLAGS(sv) & IOf_FAKE_DIRP))
5695 PerlDir_close(IoDIRP(sv));
5696 IoDIRP(sv) = (DIR*)NULL;
5697 Safefree(IoTOP_NAME(sv));
5698 Safefree(IoFMT_NAME(sv));
5699 Safefree(IoBOTTOM_NAME(sv));
5702 /* FIXME for plugins */
5703 pregfree2((REGEXP*) sv);
5707 cv_undef(MUTABLE_CV(sv));
5710 if (PL_last_swash_hv == (const HV *)sv) {
5711 PL_last_swash_hv = NULL;
5713 Perl_hv_kill_backrefs(aTHX_ MUTABLE_HV(sv));
5714 hv_undef(MUTABLE_HV(sv));
5717 if (PL_comppad == MUTABLE_AV(sv)) {
5721 av_undef(MUTABLE_AV(sv));
5724 if (LvTYPE(sv) == 'T') { /* for tie: return HE to pool */
5725 SvREFCNT_dec(HeKEY_sv((HE*)LvTARG(sv)));
5726 HeNEXT((HE*)LvTARG(sv)) = PL_hv_fetch_ent_mh;
5727 PL_hv_fetch_ent_mh = (HE*)LvTARG(sv);
5729 else if (LvTYPE(sv) != 't') /* unless tie: unrefcnted fake SV** */
5730 SvREFCNT_dec(LvTARG(sv));
5732 if (isGV_with_GP(sv)) {
5733 if(GvCVu((const GV *)sv) && (stash = GvSTASH(MUTABLE_GV(sv)))
5734 && HvNAME_get(stash))
5735 mro_method_changed_in(stash);
5736 gp_free(MUTABLE_GV(sv));
5738 unshare_hek(GvNAME_HEK(sv));
5739 /* If we're in a stash, we don't own a reference to it. However it does
5740 have a back reference to us, which needs to be cleared. */
5741 if (!SvVALID(sv) && (stash = GvSTASH(sv)))
5742 sv_del_backref(MUTABLE_SV(stash), sv);
5744 /* FIXME. There are probably more unreferenced pointers to SVs in the
5745 interpreter struct that we should check and tidy in a similar
5747 if ((const GV *)sv == PL_last_in_gv)
5748 PL_last_in_gv = NULL;
5754 /* Don't bother with SvOOK_off(sv); as we're only going to free it. */
5757 SvOOK_offset(sv, offset);
5758 SvPV_set(sv, SvPVX_mutable(sv) - offset);
5759 /* Don't even bother with turning off the OOK flag. */
5762 SV * const target = SvRV(sv);
5764 sv_del_backref(target, sv);
5766 SvREFCNT_dec(target);
5768 #ifdef PERL_OLD_COPY_ON_WRITE
5769 else if (SvPVX_const(sv)) {
5772 PerlIO_printf(Perl_debug_log, "Copy on write: clear\n");
5776 sv_release_COW(sv, SvPVX_const(sv), SV_COW_NEXT_SV(sv));
5778 unshare_hek(SvSHARED_HEK_FROM_PV(SvPVX_const(sv)));
5782 } else if (SvLEN(sv)) {
5783 Safefree(SvPVX_const(sv));
5787 else if (SvPVX_const(sv) && SvLEN(sv))
5788 Safefree(SvPVX_mutable(sv));
5789 else if (SvPVX_const(sv) && SvREADONLY(sv) && SvFAKE(sv)) {
5790 unshare_hek(SvSHARED_HEK_FROM_PV(SvPVX_const(sv)));
5799 SvFLAGS(sv) &= SVf_BREAK;
5800 SvFLAGS(sv) |= SVTYPEMASK;
5802 if (sv_type_details->arena) {
5803 del_body(((char *)SvANY(sv) + sv_type_details->offset),
5804 &PL_body_roots[type]);
5806 else if (sv_type_details->body_size) {
5807 my_safefree(SvANY(sv));
5812 =for apidoc sv_newref
5814 Increment an SV's reference count. Use the C<SvREFCNT_inc()> wrapper
5821 Perl_sv_newref(pTHX_ SV *const sv)
5823 PERL_UNUSED_CONTEXT;
5832 Decrement an SV's reference count, and if it drops to zero, call
5833 C<sv_clear> to invoke destructors and free up any memory used by
5834 the body; finally, deallocate the SV's head itself.
5835 Normally called via a wrapper macro C<SvREFCNT_dec>.
5841 Perl_sv_free(pTHX_ SV *const sv)
5846 if (SvREFCNT(sv) == 0) {
5847 if (SvFLAGS(sv) & SVf_BREAK)
5848 /* this SV's refcnt has been artificially decremented to
5849 * trigger cleanup */
5851 if (PL_in_clean_all) /* All is fair */
5853 if (SvREADONLY(sv) && SvIMMORTAL(sv)) {
5854 /* make sure SvREFCNT(sv)==0 happens very seldom */
5855 SvREFCNT(sv) = (~(U32)0)/2;
5858 if (ckWARN_d(WARN_INTERNAL)) {
5859 #ifdef DEBUG_LEAKING_SCALARS_FORK_DUMP
5860 Perl_dump_sv_child(aTHX_ sv);
5862 #ifdef DEBUG_LEAKING_SCALARS
5865 #ifdef DEBUG_LEAKING_SCALARS_ABORT
5866 if (PL_warnhook == PERL_WARNHOOK_FATAL
5867 || ckDEAD(packWARN(WARN_INTERNAL))) {
5868 /* Don't let Perl_warner cause us to escape our fate: */
5872 /* This may not return: */
5873 Perl_warner(aTHX_ packWARN(WARN_INTERNAL),
5874 "Attempt to free unreferenced scalar: SV 0x%"UVxf
5875 pTHX__FORMAT, PTR2UV(sv) pTHX__VALUE);
5878 #ifdef DEBUG_LEAKING_SCALARS_ABORT
5883 if (--(SvREFCNT(sv)) > 0)
5885 Perl_sv_free2(aTHX_ sv);
5889 Perl_sv_free2(pTHX_ SV *const sv)
5893 PERL_ARGS_ASSERT_SV_FREE2;
5897 if (ckWARN_d(WARN_DEBUGGING))
5898 Perl_warner(aTHX_ packWARN(WARN_DEBUGGING),
5899 "Attempt to free temp prematurely: SV 0x%"UVxf
5900 pTHX__FORMAT, PTR2UV(sv) pTHX__VALUE);
5904 if (SvREADONLY(sv) && SvIMMORTAL(sv)) {
5905 /* make sure SvREFCNT(sv)==0 happens very seldom */
5906 SvREFCNT(sv) = (~(U32)0)/2;
5917 Returns the length of the string in the SV. Handles magic and type
5918 coercion. See also C<SvCUR>, which gives raw access to the xpv_cur slot.
5924 Perl_sv_len(pTHX_ register SV *const sv)
5932 len = mg_length(sv);
5934 (void)SvPV_const(sv, len);
5939 =for apidoc sv_len_utf8
5941 Returns the number of characters in the string in an SV, counting wide
5942 UTF-8 bytes as a single character. Handles magic and type coercion.
5948 * The length is cached in PERL_MAGIC_utf8, in the mg_len field. Also the
5949 * mg_ptr is used, by sv_pos_u2b() and sv_pos_b2u() - see the comments below.
5950 * (Note that the mg_len is not the length of the mg_ptr field.
5951 * This allows the cache to store the character length of the string without
5952 * needing to malloc() extra storage to attach to the mg_ptr.)
5957 Perl_sv_len_utf8(pTHX_ register SV *const sv)
5963 return mg_length(sv);
5967 const U8 *s = (U8*)SvPV_const(sv, len);
5971 MAGIC *mg = SvMAGICAL(sv) ? mg_find(sv, PERL_MAGIC_utf8) : NULL;
5973 if (mg && mg->mg_len != -1) {
5975 if (PL_utf8cache < 0) {
5976 const STRLEN real = Perl_utf8_length(aTHX_ s, s + len);
5978 /* Need to turn the assertions off otherwise we may
5979 recurse infinitely while printing error messages.
5981 SAVEI8(PL_utf8cache);
5983 Perl_croak(aTHX_ "panic: sv_len_utf8 cache %"UVuf
5984 " real %"UVuf" for %"SVf,
5985 (UV) ulen, (UV) real, SVfARG(sv));
5990 ulen = Perl_utf8_length(aTHX_ s, s + len);
5991 if (!SvREADONLY(sv)) {
5993 mg = sv_magicext(sv, 0, PERL_MAGIC_utf8,
5994 &PL_vtbl_utf8, 0, 0);
6002 return Perl_utf8_length(aTHX_ s, s + len);
6006 /* Walk forwards to find the byte corresponding to the passed in UTF-8
6009 S_sv_pos_u2b_forwards(const U8 *const start, const U8 *const send,
6012 const U8 *s = start;
6014 PERL_ARGS_ASSERT_SV_POS_U2B_FORWARDS;
6016 while (s < send && uoffset--)
6019 /* This is the existing behaviour. Possibly it should be a croak, as
6020 it's actually a bounds error */
6026 /* Given the length of the string in both bytes and UTF-8 characters, decide
6027 whether to walk forwards or backwards to find the byte corresponding to
6028 the passed in UTF-8 offset. */
6030 S_sv_pos_u2b_midway(const U8 *const start, const U8 *send,
6031 const STRLEN uoffset, const STRLEN uend)
6033 STRLEN backw = uend - uoffset;
6035 PERL_ARGS_ASSERT_SV_POS_U2B_MIDWAY;
6037 if (uoffset < 2 * backw) {
6038 /* The assumption is that going forwards is twice the speed of going
6039 forward (that's where the 2 * backw comes from).
6040 (The real figure of course depends on the UTF-8 data.) */
6041 return sv_pos_u2b_forwards(start, send, uoffset);
6046 while (UTF8_IS_CONTINUATION(*send))
6049 return send - start;
6052 /* For the string representation of the given scalar, find the byte
6053 corresponding to the passed in UTF-8 offset. uoffset0 and boffset0
6054 give another position in the string, *before* the sought offset, which
6055 (which is always true, as 0, 0 is a valid pair of positions), which should
6056 help reduce the amount of linear searching.
6057 If *mgp is non-NULL, it should point to the UTF-8 cache magic, which
6058 will be used to reduce the amount of linear searching. The cache will be
6059 created if necessary, and the found value offered to it for update. */
6061 S_sv_pos_u2b_cached(pTHX_ SV *const sv, MAGIC **const mgp, const U8 *const start,
6062 const U8 *const send, const STRLEN uoffset,
6063 STRLEN uoffset0, STRLEN boffset0)
6065 STRLEN boffset = 0; /* Actually always set, but let's keep gcc happy. */
6068 PERL_ARGS_ASSERT_SV_POS_U2B_CACHED;
6070 assert (uoffset >= uoffset0);
6072 if (SvMAGICAL(sv) && !SvREADONLY(sv) && PL_utf8cache
6073 && (*mgp || (*mgp = mg_find(sv, PERL_MAGIC_utf8)))) {
6074 if ((*mgp)->mg_ptr) {
6075 STRLEN *cache = (STRLEN *) (*mgp)->mg_ptr;
6076 if (cache[0] == uoffset) {
6077 /* An exact match. */
6080 if (cache[2] == uoffset) {
6081 /* An exact match. */
6085 if (cache[0] < uoffset) {
6086 /* The cache already knows part of the way. */
6087 if (cache[0] > uoffset0) {
6088 /* The cache knows more than the passed in pair */
6089 uoffset0 = cache[0];
6090 boffset0 = cache[1];
6092 if ((*mgp)->mg_len != -1) {
6093 /* And we know the end too. */
6095 + sv_pos_u2b_midway(start + boffset0, send,
6097 (*mgp)->mg_len - uoffset0);
6100 + sv_pos_u2b_forwards(start + boffset0,
6101 send, uoffset - uoffset0);
6104 else if (cache[2] < uoffset) {
6105 /* We're between the two cache entries. */
6106 if (cache[2] > uoffset0) {
6107 /* and the cache knows more than the passed in pair */
6108 uoffset0 = cache[2];
6109 boffset0 = cache[3];
6113 + sv_pos_u2b_midway(start + boffset0,
6116 cache[0] - uoffset0);
6119 + sv_pos_u2b_midway(start + boffset0,
6122 cache[2] - uoffset0);
6126 else if ((*mgp)->mg_len != -1) {
6127 /* If we can take advantage of a passed in offset, do so. */
6128 /* In fact, offset0 is either 0, or less than offset, so don't
6129 need to worry about the other possibility. */
6131 + sv_pos_u2b_midway(start + boffset0, send,
6133 (*mgp)->mg_len - uoffset0);
6138 if (!found || PL_utf8cache < 0) {
6139 const STRLEN real_boffset
6140 = boffset0 + sv_pos_u2b_forwards(start + boffset0,
6141 send, uoffset - uoffset0);
6143 if (found && PL_utf8cache < 0) {
6144 if (real_boffset != boffset) {
6145 /* Need to turn the assertions off otherwise we may recurse
6146 infinitely while printing error messages. */
6147 SAVEI8(PL_utf8cache);
6149 Perl_croak(aTHX_ "panic: sv_pos_u2b_cache cache %"UVuf
6150 " real %"UVuf" for %"SVf,
6151 (UV) boffset, (UV) real_boffset, SVfARG(sv));
6154 boffset = real_boffset;
6158 utf8_mg_pos_cache_update(sv, mgp, boffset, uoffset, send - start);
6164 =for apidoc sv_pos_u2b
6166 Converts the value pointed to by offsetp from a count of UTF-8 chars from
6167 the start of the string, to a count of the equivalent number of bytes; if
6168 lenp is non-zero, it does the same to lenp, but this time starting from
6169 the offset, rather than from the start of the string. Handles magic and
6176 * sv_pos_u2b() uses, like sv_pos_b2u(), the mg_ptr of the potential
6177 * PERL_MAGIC_utf8 of the sv to store the mapping between UTF-8 and
6178 * byte offsets. See also the comments of S_utf8_mg_pos_cache_update().
6183 Perl_sv_pos_u2b(pTHX_ register SV *const sv, I32 *const offsetp, I32 *const lenp)
6188 PERL_ARGS_ASSERT_SV_POS_U2B;
6193 start = (U8*)SvPV_const(sv, len);
6195 STRLEN uoffset = (STRLEN) *offsetp;
6196 const U8 * const send = start + len;
6198 const STRLEN boffset = sv_pos_u2b_cached(sv, &mg, start, send,
6201 *offsetp = (I32) boffset;
6204 /* Convert the relative offset to absolute. */
6205 const STRLEN uoffset2 = uoffset + (STRLEN) *lenp;
6206 const STRLEN boffset2
6207 = sv_pos_u2b_cached(sv, &mg, start, send, uoffset2,
6208 uoffset, boffset) - boffset;
6222 /* Create and update the UTF8 magic offset cache, with the proffered utf8/
6223 byte length pairing. The (byte) length of the total SV is passed in too,
6224 as blen, because for some (more esoteric) SVs, the call to SvPV_const()
6225 may not have updated SvCUR, so we can't rely on reading it directly.
6227 The proffered utf8/byte length pairing isn't used if the cache already has
6228 two pairs, and swapping either for the proffered pair would increase the
6229 RMS of the intervals between known byte offsets.
6231 The cache itself consists of 4 STRLEN values
6232 0: larger UTF-8 offset
6233 1: corresponding byte offset
6234 2: smaller UTF-8 offset
6235 3: corresponding byte offset
6237 Unused cache pairs have the value 0, 0.
6238 Keeping the cache "backwards" means that the invariant of
6239 cache[0] >= cache[2] is maintained even with empty slots, which means that
6240 the code that uses it doesn't need to worry if only 1 entry has actually
6241 been set to non-zero. It also makes the "position beyond the end of the
6242 cache" logic much simpler, as the first slot is always the one to start
6246 S_utf8_mg_pos_cache_update(pTHX_ SV *const sv, MAGIC **const mgp, const STRLEN byte,
6247 const STRLEN utf8, const STRLEN blen)
6251 PERL_ARGS_ASSERT_UTF8_MG_POS_CACHE_UPDATE;
6257 *mgp = sv_magicext(sv, 0, PERL_MAGIC_utf8, (MGVTBL*)&PL_vtbl_utf8, 0,
6259 (*mgp)->mg_len = -1;
6263 if (!(cache = (STRLEN *)(*mgp)->mg_ptr)) {
6264 Newxz(cache, PERL_MAGIC_UTF8_CACHESIZE * 2, STRLEN);
6265 (*mgp)->mg_ptr = (char *) cache;
6269 if (PL_utf8cache < 0) {
6270 const U8 *start = (const U8 *) SvPVX_const(sv);
6271 const STRLEN realutf8 = utf8_length(start, start + byte);
6273 if (realutf8 != utf8) {
6274 /* Need to turn the assertions off otherwise we may recurse
6275 infinitely while printing error messages. */
6276 SAVEI8(PL_utf8cache);
6278 Perl_croak(aTHX_ "panic: utf8_mg_pos_cache_update cache %"UVuf
6279 " real %"UVuf" for %"SVf, (UV) utf8, (UV) realutf8, SVfARG(sv));
6283 /* Cache is held with the later position first, to simplify the code
6284 that deals with unbounded ends. */
6286 ASSERT_UTF8_CACHE(cache);
6287 if (cache[1] == 0) {
6288 /* Cache is totally empty */
6291 } else if (cache[3] == 0) {
6292 if (byte > cache[1]) {
6293 /* New one is larger, so goes first. */
6294 cache[2] = cache[0];
6295 cache[3] = cache[1];
6303 #define THREEWAY_SQUARE(a,b,c,d) \
6304 ((float)((d) - (c))) * ((float)((d) - (c))) \
6305 + ((float)((c) - (b))) * ((float)((c) - (b))) \
6306 + ((float)((b) - (a))) * ((float)((b) - (a)))
6308 /* Cache has 2 slots in use, and we know three potential pairs.
6309 Keep the two that give the lowest RMS distance. Do the
6310 calcualation in bytes simply because we always know the byte
6311 length. squareroot has the same ordering as the positive value,
6312 so don't bother with the actual square root. */
6313 const float existing = THREEWAY_SQUARE(0, cache[3], cache[1], blen);
6314 if (byte > cache[1]) {
6315 /* New position is after the existing pair of pairs. */
6316 const float keep_earlier
6317 = THREEWAY_SQUARE(0, cache[3], byte, blen);
6318 const float keep_later
6319 = THREEWAY_SQUARE(0, cache[1], byte, blen);
6321 if (keep_later < keep_earlier) {
6322 if (keep_later < existing) {
6323 cache[2] = cache[0];
6324 cache[3] = cache[1];
6330 if (keep_earlier < existing) {
6336 else if (byte > cache[3]) {
6337 /* New position is between the existing pair of pairs. */
6338 const float keep_earlier
6339 = THREEWAY_SQUARE(0, cache[3], byte, blen);
6340 const float keep_later
6341 = THREEWAY_SQUARE(0, byte, cache[1], blen);
6343 if (keep_later < keep_earlier) {
6344 if (keep_later < existing) {
6350 if (keep_earlier < existing) {
6357 /* New position is before the existing pair of pairs. */
6358 const float keep_earlier
6359 = THREEWAY_SQUARE(0, byte, cache[3], blen);
6360 const float keep_later
6361 = THREEWAY_SQUARE(0, byte, cache[1], blen);
6363 if (keep_later < keep_earlier) {
6364 if (keep_later < existing) {
6370 if (keep_earlier < existing) {
6371 cache[0] = cache[2];
6372 cache[1] = cache[3];
6379 ASSERT_UTF8_CACHE(cache);
6382 /* We already know all of the way, now we may be able to walk back. The same
6383 assumption is made as in S_sv_pos_u2b_midway(), namely that walking
6384 backward is half the speed of walking forward. */
6386 S_sv_pos_b2u_midway(pTHX_ const U8 *const s, const U8 *const target,
6387 const U8 *end, STRLEN endu)
6389 const STRLEN forw = target - s;
6390 STRLEN backw = end - target;
6392 PERL_ARGS_ASSERT_SV_POS_B2U_MIDWAY;
6394 if (forw < 2 * backw) {
6395 return utf8_length(s, target);
6398 while (end > target) {
6400 while (UTF8_IS_CONTINUATION(*end)) {
6409 =for apidoc sv_pos_b2u
6411 Converts the value pointed to by offsetp from a count of bytes from the
6412 start of the string, to a count of the equivalent number of UTF-8 chars.
6413 Handles magic and type coercion.
6419 * sv_pos_b2u() uses, like sv_pos_u2b(), the mg_ptr of the potential
6420 * PERL_MAGIC_utf8 of the sv to store the mapping between UTF-8 and
6425 Perl_sv_pos_b2u(pTHX_ register SV *const sv, I32 *const offsetp)
6428 const STRLEN byte = *offsetp;
6429 STRLEN len = 0; /* Actually always set, but let's keep gcc happy. */
6435 PERL_ARGS_ASSERT_SV_POS_B2U;
6440 s = (const U8*)SvPV_const(sv, blen);
6443 Perl_croak(aTHX_ "panic: sv_pos_b2u: bad byte offset");
6447 if (SvMAGICAL(sv) && !SvREADONLY(sv) && PL_utf8cache
6448 && (mg = mg_find(sv, PERL_MAGIC_utf8))) {
6450 STRLEN * const cache = (STRLEN *) mg->mg_ptr;
6451 if (cache[1] == byte) {
6452 /* An exact match. */
6453 *offsetp = cache[0];
6456 if (cache[3] == byte) {
6457 /* An exact match. */
6458 *offsetp = cache[2];
6462 if (cache[1] < byte) {
6463 /* We already know part of the way. */
6464 if (mg->mg_len != -1) {
6465 /* Actually, we know the end too. */
6467 + S_sv_pos_b2u_midway(aTHX_ s + cache[1], send,
6468 s + blen, mg->mg_len - cache[0]);
6470 len = cache[0] + utf8_length(s + cache[1], send);
6473 else if (cache[3] < byte) {
6474 /* We're between the two cached pairs, so we do the calculation
6475 offset by the byte/utf-8 positions for the earlier pair,
6476 then add the utf-8 characters from the string start to
6478 len = S_sv_pos_b2u_midway(aTHX_ s + cache[3], send,
6479 s + cache[1], cache[0] - cache[2])
6483 else { /* cache[3] > byte */
6484 len = S_sv_pos_b2u_midway(aTHX_ s, send, s + cache[3],
6488 ASSERT_UTF8_CACHE(cache);
6490 } else if (mg->mg_len != -1) {
6491 len = S_sv_pos_b2u_midway(aTHX_ s, send, s + blen, mg->mg_len);
6495 if (!found || PL_utf8cache < 0) {
6496 const STRLEN real_len = utf8_length(s, send);
6498 if (found && PL_utf8cache < 0) {
6499 if (len != real_len) {
6500 /* Need to turn the assertions off otherwise we may recurse
6501 infinitely while printing error messages. */
6502 SAVEI8(PL_utf8cache);
6504 Perl_croak(aTHX_ "panic: sv_pos_b2u cache %"UVuf
6505 " real %"UVuf" for %"SVf,
6506 (UV) len, (UV) real_len, SVfARG(sv));
6514 utf8_mg_pos_cache_update(sv, &mg, byte, len, blen);
6520 Returns a boolean indicating whether the strings in the two SVs are
6521 identical. Is UTF-8 and 'use bytes' aware, handles get magic, and will
6522 coerce its args to strings if necessary.
6528 Perl_sv_eq(pTHX_ register SV *sv1, register SV *sv2)
6537 SV* svrecode = NULL;
6544 /* if pv1 and pv2 are the same, second SvPV_const call may
6545 * invalidate pv1, so we may need to make a copy */
6546 if (sv1 == sv2 && (SvTHINKFIRST(sv1) || SvGMAGICAL(sv1))) {
6547 pv1 = SvPV_const(sv1, cur1);
6548 sv1 = newSVpvn_flags(pv1, cur1, SVs_TEMP | SvUTF8(sv2));
6550 pv1 = SvPV_const(sv1, cur1);
6558 pv2 = SvPV_const(sv2, cur2);
6560 if (cur1 && cur2 && SvUTF8(sv1) != SvUTF8(sv2) && !IN_BYTES) {
6561 /* Differing utf8ness.
6562 * Do not UTF8size the comparands as a side-effect. */
6565 svrecode = newSVpvn(pv2, cur2);
6566 sv_recode_to_utf8(svrecode, PL_encoding);
6567 pv2 = SvPV_const(svrecode, cur2);
6570 svrecode = newSVpvn(pv1, cur1);
6571 sv_recode_to_utf8(svrecode, PL_encoding);
6572 pv1 = SvPV_const(svrecode, cur1);
6574 /* Now both are in UTF-8. */
6576 SvREFCNT_dec(svrecode);
6581 bool is_utf8 = TRUE;
6584 /* sv1 is the UTF-8 one,
6585 * if is equal it must be downgrade-able */
6586 char * const pv = (char*)bytes_from_utf8((const U8*)pv1,
6592 /* sv2 is the UTF-8 one,
6593 * if is equal it must be downgrade-able */
6594 char * const pv = (char *)bytes_from_utf8((const U8*)pv2,
6600 /* Downgrade not possible - cannot be eq */
6608 eq = (pv1 == pv2) || memEQ(pv1, pv2, cur1);
6610 SvREFCNT_dec(svrecode);
6620 Compares the strings in two SVs. Returns -1, 0, or 1 indicating whether the
6621 string in C<sv1> is less than, equal to, or greater than the string in
6622 C<sv2>. Is UTF-8 and 'use bytes' aware, handles get magic, and will
6623 coerce its args to strings if necessary. See also C<sv_cmp_locale>.
6629 Perl_sv_cmp(pTHX_ register SV *const sv1, register SV *const sv2)
6633 const char *pv1, *pv2;
6636 SV *svrecode = NULL;
6643 pv1 = SvPV_const(sv1, cur1);
6650 pv2 = SvPV_const(sv2, cur2);
6652 if (cur1 && cur2 && SvUTF8(sv1) != SvUTF8(sv2) && !IN_BYTES) {
6653 /* Differing utf8ness.
6654 * Do not UTF8size the comparands as a side-effect. */
6657 svrecode = newSVpvn(pv2, cur2);
6658 sv_recode_to_utf8(svrecode, PL_encoding);
6659 pv2 = SvPV_const(svrecode, cur2);
6662 pv2 = tpv = (char*)bytes_to_utf8((const U8*)pv2, &cur2);
6667 svrecode = newSVpvn(pv1, cur1);
6668 sv_recode_to_utf8(svrecode, PL_encoding);
6669 pv1 = SvPV_const(svrecode, cur1);
6672 pv1 = tpv = (char*)bytes_to_utf8((const U8*)pv1, &cur1);
6678 cmp = cur2 ? -1 : 0;
6682 const I32 retval = memcmp((const void*)pv1, (const void*)pv2, cur1 < cur2 ? cur1 : cur2);
6685 cmp = retval < 0 ? -1 : 1;
6686 } else if (cur1 == cur2) {
6689 cmp = cur1 < cur2 ? -1 : 1;
6693 SvREFCNT_dec(svrecode);
6701 =for apidoc sv_cmp_locale
6703 Compares the strings in two SVs in a locale-aware manner. Is UTF-8 and
6704 'use bytes' aware, handles get magic, and will coerce its args to strings
6705 if necessary. See also C<sv_cmp>.
6711 Perl_sv_cmp_locale(pTHX_ register SV *const sv1, register SV *const sv2)
6714 #ifdef USE_LOCALE_COLLATE
6720 if (PL_collation_standard)
6724 pv1 = sv1 ? sv_collxfrm(sv1, &len1) : (char *) NULL;
6726 pv2 = sv2 ? sv_collxfrm(sv2, &len2) : (char *) NULL;
6728 if (!pv1 || !len1) {
6739 retval = memcmp((void*)pv1, (void*)pv2, len1 < len2 ? len1 : len2);
6742 return retval < 0 ? -1 : 1;
6745 * When the result of collation is equality, that doesn't mean
6746 * that there are no differences -- some locales exclude some
6747 * characters from consideration. So to avoid false equalities,
6748 * we use the raw string as a tiebreaker.
6754 #endif /* USE_LOCALE_COLLATE */
6756 return sv_cmp(sv1, sv2);
6760 #ifdef USE_LOCALE_COLLATE
6763 =for apidoc sv_collxfrm
6765 Add Collate Transform magic to an SV if it doesn't already have it.
6767 Any scalar variable may carry PERL_MAGIC_collxfrm magic that contains the
6768 scalar data of the variable, but transformed to such a format that a normal
6769 memory comparison can be used to compare the data according to the locale
6776 Perl_sv_collxfrm(pTHX_ SV *const sv, STRLEN *const nxp)
6781 PERL_ARGS_ASSERT_SV_COLLXFRM;
6783 mg = SvMAGICAL(sv) ? mg_find(sv, PERL_MAGIC_collxfrm) : (MAGIC *) NULL;
6784 if (!mg || !mg->mg_ptr || *(U32*)mg->mg_ptr != PL_collation_ix) {
6790 Safefree(mg->mg_ptr);
6791 s = SvPV_const(sv, len);
6792 if ((xf = mem_collxfrm(s, len, &xlen))) {
6794 #ifdef PERL_OLD_COPY_ON_WRITE
6796 sv_force_normal_flags(sv, 0);
6798 mg = sv_magicext(sv, 0, PERL_MAGIC_collxfrm, &PL_vtbl_collxfrm,
6812 if (mg && mg->mg_ptr) {
6814 return mg->mg_ptr + sizeof(PL_collation_ix);
6822 #endif /* USE_LOCALE_COLLATE */
6827 Get a line from the filehandle and store it into the SV, optionally
6828 appending to the currently-stored string.
6834 Perl_sv_gets(pTHX_ register SV *const sv, register PerlIO *const fp, I32 append)
6839 register STDCHAR rslast;
6840 register STDCHAR *bp;
6845 PERL_ARGS_ASSERT_SV_GETS;
6847 if (SvTHINKFIRST(sv))
6848 sv_force_normal_flags(sv, append ? 0 : SV_COW_DROP_PV);
6849 /* XXX. If you make this PVIV, then copy on write can copy scalars read
6851 However, perlbench says it's slower, because the existing swipe code
6852 is faster than copy on write.
6853 Swings and roundabouts. */
6854 SvUPGRADE(sv, SVt_PV);
6859 if (PerlIO_isutf8(fp)) {
6861 sv_utf8_upgrade_nomg(sv);
6862 sv_pos_u2b(sv,&append,0);
6864 } else if (SvUTF8(sv)) {
6865 SV * const tsv = newSV(0);
6866 sv_gets(tsv, fp, 0);
6867 sv_utf8_upgrade_nomg(tsv);
6868 SvCUR_set(sv,append);
6871 goto return_string_or_null;
6876 if (PerlIO_isutf8(fp))
6879 if (IN_PERL_COMPILETIME) {
6880 /* we always read code in line mode */
6884 else if (RsSNARF(PL_rs)) {
6885 /* If it is a regular disk file use size from stat() as estimate
6886 of amount we are going to read -- may result in mallocing
6887 more memory than we really need if the layers below reduce
6888 the size we read (e.g. CRLF or a gzip layer).
6891 if (!PerlLIO_fstat(PerlIO_fileno(fp), &st) && S_ISREG(st.st_mode)) {
6892 const Off_t offset = PerlIO_tell(fp);
6893 if (offset != (Off_t) -1 && st.st_size + append > offset) {
6894 (void) SvGROW(sv, (STRLEN)((st.st_size - offset) + append + 1));
6900 else if (RsRECORD(PL_rs)) {
6908 /* Grab the size of the record we're getting */
6909 recsize = SvUV(SvRV(PL_rs)); /* RsRECORD() guarantees > 0. */
6910 buffer = SvGROW(sv, (STRLEN)(recsize + append + 1)) + append;
6913 /* VMS wants read instead of fread, because fread doesn't respect */
6914 /* RMS record boundaries. This is not necessarily a good thing to be */
6915 /* doing, but we've got no other real choice - except avoid stdio
6916 as implementation - perhaps write a :vms layer ?
6918 fd = PerlIO_fileno(fp);
6919 if (fd == -1) { /* in-memory file from PerlIO::Scalar */
6920 bytesread = PerlIO_read(fp, buffer, recsize);
6923 bytesread = PerlLIO_read(fd, buffer, recsize);
6926 bytesread = PerlIO_read(fp, buffer, recsize);
6930 SvCUR_set(sv, bytesread + append);
6931 buffer[bytesread] = '\0';
6932 goto return_string_or_null;
6934 else if (RsPARA(PL_rs)) {
6940 /* Get $/ i.e. PL_rs into same encoding as stream wants */
6941 if (PerlIO_isutf8(fp)) {
6942 rsptr = SvPVutf8(PL_rs, rslen);
6945 if (SvUTF8(PL_rs)) {
6946 if (!sv_utf8_downgrade(PL_rs, TRUE)) {
6947 Perl_croak(aTHX_ "Wide character in $/");
6950 rsptr = SvPV_const(PL_rs, rslen);
6954 rslast = rslen ? rsptr[rslen - 1] : '\0';
6956 if (rspara) { /* have to do this both before and after */
6957 do { /* to make sure file boundaries work right */
6960 i = PerlIO_getc(fp);
6964 PerlIO_ungetc(fp,i);
6970 /* See if we know enough about I/O mechanism to cheat it ! */
6972 /* This used to be #ifdef test - it is made run-time test for ease
6973 of abstracting out stdio interface. One call should be cheap
6974 enough here - and may even be a macro allowing compile
6978 if (PerlIO_fast_gets(fp)) {
6981 * We're going to steal some values from the stdio struct
6982 * and put EVERYTHING in the innermost loop into registers.
6984 register STDCHAR *ptr;
6988 #if defined(VMS) && defined(PERLIO_IS_STDIO)
6989 /* An ungetc()d char is handled separately from the regular
6990 * buffer, so we getc() it back out and stuff it in the buffer.
6992 i = PerlIO_getc(fp);
6993 if (i == EOF) return 0;
6994 *(--((*fp)->_ptr)) = (unsigned char) i;
6998 /* Here is some breathtakingly efficient cheating */
7000 cnt = PerlIO_get_cnt(fp); /* get count into register */
7001 /* make sure we have the room */
7002 if ((I32)(SvLEN(sv) - append) <= cnt + 1) {
7003 /* Not room for all of it
7004 if we are looking for a separator and room for some
7006 if (rslen && cnt > 80 && (I32)SvLEN(sv) > append) {
7007 /* just process what we have room for */
7008 shortbuffered = cnt - SvLEN(sv) + append + 1;
7009 cnt -= shortbuffered;
7013 /* remember that cnt can be negative */
7014 SvGROW(sv, (STRLEN)(append + (cnt <= 0 ? 2 : (cnt + 1))));
7019 bp = (STDCHAR*)SvPVX_const(sv) + append; /* move these two too to registers */
7020 ptr = (STDCHAR*)PerlIO_get_ptr(fp);
7021 DEBUG_P(PerlIO_printf(Perl_debug_log,
7022 "Screamer: entering, ptr=%"UVuf", cnt=%ld\n",PTR2UV(ptr),(long)cnt));
7023 DEBUG_P(PerlIO_printf(Perl_debug_log,
7024 "Screamer: entering: PerlIO * thinks ptr=%"UVuf", cnt=%ld, base=%"UVuf"\n",
7025 PTR2UV(PerlIO_get_ptr(fp)), (long)PerlIO_get_cnt(fp),
7026 PTR2UV(PerlIO_has_base(fp) ? PerlIO_get_base(fp) : 0)));
7031 while (cnt > 0) { /* this | eat */
7033 if ((*bp++ = *ptr++) == rslast) /* really | dust */
7034 goto thats_all_folks; /* screams | sed :-) */
7038 Copy(ptr, bp, cnt, char); /* this | eat */
7039 bp += cnt; /* screams | dust */
7040 ptr += cnt; /* louder | sed :-) */
7045 if (shortbuffered) { /* oh well, must extend */
7046 cnt = shortbuffered;
7048 bpx = bp - (STDCHAR*)SvPVX_const(sv); /* box up before relocation */
7050 SvGROW(sv, SvLEN(sv) + append + cnt + 2);
7051 bp = (STDCHAR*)SvPVX_const(sv) + bpx; /* unbox after relocation */
7055 DEBUG_P(PerlIO_printf(Perl_debug_log,
7056 "Screamer: going to getc, ptr=%"UVuf", cnt=%ld\n",
7057 PTR2UV(ptr),(long)cnt));
7058 PerlIO_set_ptrcnt(fp, (STDCHAR*)ptr, cnt); /* deregisterize cnt and ptr */
7060 DEBUG_P(PerlIO_printf(Perl_debug_log,
7061 "Screamer: pre: FILE * thinks ptr=%"UVuf", cnt=%ld, base=%"UVuf"\n",
7062 PTR2UV(PerlIO_get_ptr(fp)), (long)PerlIO_get_cnt(fp),
7063 PTR2UV(PerlIO_has_base (fp) ? PerlIO_get_base(fp) : 0)));
7065 /* This used to call 'filbuf' in stdio form, but as that behaves like
7066 getc when cnt <= 0 we use PerlIO_getc here to avoid introducing
7067 another abstraction. */
7068 i = PerlIO_getc(fp); /* get more characters */
7070 DEBUG_P(PerlIO_printf(Perl_debug_log,
7071 "Screamer: post: FILE * thinks ptr=%"UVuf", cnt=%ld, base=%"UVuf"\n",
7072 PTR2UV(PerlIO_get_ptr(fp)), (long)PerlIO_get_cnt(fp),
7073 PTR2UV(PerlIO_has_base (fp) ? PerlIO_get_base(fp) : 0)));
7075 cnt = PerlIO_get_cnt(fp);
7076 ptr = (STDCHAR*)PerlIO_get_ptr(fp); /* reregisterize cnt and ptr */
7077 DEBUG_P(PerlIO_printf(Perl_debug_log,
7078 "Screamer: after getc, ptr=%"UVuf", cnt=%ld\n",PTR2UV(ptr),(long)cnt));
7080 if (i == EOF) /* all done for ever? */
7081 goto thats_really_all_folks;
7083 bpx = bp - (STDCHAR*)SvPVX_const(sv); /* box up before relocation */
7085 SvGROW(sv, bpx + cnt + 2);
7086 bp = (STDCHAR*)SvPVX_const(sv) + bpx; /* unbox after relocation */
7088 *bp++ = (STDCHAR)i; /* store character from PerlIO_getc */
7090 if (rslen && (STDCHAR)i == rslast) /* all done for now? */
7091 goto thats_all_folks;
7095 if ((rslen > 1 && (STRLEN)(bp - (STDCHAR*)SvPVX_const(sv)) < rslen) ||
7096 memNE((char*)bp - rslen, rsptr, rslen))
7097 goto screamer; /* go back to the fray */
7098 thats_really_all_folks:
7100 cnt += shortbuffered;
7101 DEBUG_P(PerlIO_printf(Perl_debug_log,
7102 "Screamer: quitting, ptr=%"UVuf", cnt=%ld\n",PTR2UV(ptr),(long)cnt));
7103 PerlIO_set_ptrcnt(fp, (STDCHAR*)ptr, cnt); /* put these back or we're in trouble */
7104 DEBUG_P(PerlIO_printf(Perl_debug_log,
7105 "Screamer: end: FILE * thinks ptr=%"UVuf", cnt=%ld, base=%"UVuf"\n",
7106 PTR2UV(PerlIO_get_ptr(fp)), (long)PerlIO_get_cnt(fp),
7107 PTR2UV(PerlIO_has_base (fp) ? PerlIO_get_base(fp) : 0)));
7109 SvCUR_set(sv, bp - (STDCHAR*)SvPVX_const(sv)); /* set length */
7110 DEBUG_P(PerlIO_printf(Perl_debug_log,
7111 "Screamer: done, len=%ld, string=|%.*s|\n",
7112 (long)SvCUR(sv),(int)SvCUR(sv),SvPVX_const(sv)));
7116 /*The big, slow, and stupid way. */
7117 #ifdef USE_HEAP_INSTEAD_OF_STACK /* Even slower way. */
7118 STDCHAR *buf = NULL;
7119 Newx(buf, 8192, STDCHAR);
7127 register const STDCHAR * const bpe = buf + sizeof(buf);
7129 while ((i = PerlIO_getc(fp)) != EOF && (*bp++ = (STDCHAR)i) != rslast && bp < bpe)
7130 ; /* keep reading */
7134 cnt = PerlIO_read(fp,(char*)buf, sizeof(buf));
7135 /* Accomodate broken VAXC compiler, which applies U8 cast to
7136 * both args of ?: operator, causing EOF to change into 255
7139 i = (U8)buf[cnt - 1];
7145 cnt = 0; /* we do need to re-set the sv even when cnt <= 0 */
7147 sv_catpvn(sv, (char *) buf, cnt);
7149 sv_setpvn(sv, (char *) buf, cnt);
7151 if (i != EOF && /* joy */
7153 SvCUR(sv) < rslen ||
7154 memNE(SvPVX_const(sv) + SvCUR(sv) - rslen, rsptr, rslen)))
7158 * If we're reading from a TTY and we get a short read,
7159 * indicating that the user hit his EOF character, we need
7160 * to notice it now, because if we try to read from the TTY
7161 * again, the EOF condition will disappear.
7163 * The comparison of cnt to sizeof(buf) is an optimization
7164 * that prevents unnecessary calls to feof().
7168 if (!(cnt < (I32)sizeof(buf) && PerlIO_eof(fp)))
7172 #ifdef USE_HEAP_INSTEAD_OF_STACK
7177 if (rspara) { /* have to do this both before and after */
7178 while (i != EOF) { /* to make sure file boundaries work right */
7179 i = PerlIO_getc(fp);
7181 PerlIO_ungetc(fp,i);
7187 return_string_or_null:
7188 return (SvCUR(sv) - append) ? SvPVX(sv) : NULL;
7194 Auto-increment of the value in the SV, doing string to numeric conversion
7195 if necessary. Handles 'get' magic.
7201 Perl_sv_inc(pTHX_ register SV *const sv)
7210 if (SvTHINKFIRST(sv)) {
7212 sv_force_normal_flags(sv, 0);
7213 if (SvREADONLY(sv)) {
7214 if (IN_PERL_RUNTIME)
7215 Perl_croak(aTHX_ "%s", PL_no_modify);
7219 if (SvAMAGIC(sv) && AMG_CALLun(sv,inc))
7221 i = PTR2IV(SvRV(sv));
7226 flags = SvFLAGS(sv);
7227 if ((flags & (SVp_NOK|SVp_IOK)) == SVp_NOK) {
7228 /* It's (privately or publicly) a float, but not tested as an
7229 integer, so test it to see. */
7231 flags = SvFLAGS(sv);
7233 if ((flags & SVf_IOK) || ((flags & (SVp_IOK | SVp_NOK)) == SVp_IOK)) {
7234 /* It's publicly an integer, or privately an integer-not-float */
7235 #ifdef PERL_PRESERVE_IVUV
7239 if (SvUVX(sv) == UV_MAX)
7240 sv_setnv(sv, UV_MAX_P1);
7242 (void)SvIOK_only_UV(sv);
7243 SvUV_set(sv, SvUVX(sv) + 1);
7245 if (SvIVX(sv) == IV_MAX)
7246 sv_setuv(sv, (UV)IV_MAX + 1);
7248 (void)SvIOK_only(sv);
7249 SvIV_set(sv, SvIVX(sv) + 1);
7254 if (flags & SVp_NOK) {
7255 const NV was = SvNVX(sv);
7256 if (NV_OVERFLOWS_INTEGERS_AT &&
7257 was >= NV_OVERFLOWS_INTEGERS_AT && ckWARN(WARN_IMPRECISION)) {
7258 Perl_warner(aTHX_ packWARN(WARN_IMPRECISION),
7259 "Lost precision when incrementing %" NVff " by 1",
7262 (void)SvNOK_only(sv);
7263 SvNV_set(sv, was + 1.0);
7267 if (!(flags & SVp_POK) || !*SvPVX_const(sv)) {
7268 if ((flags & SVTYPEMASK) < SVt_PVIV)
7269 sv_upgrade(sv, ((flags & SVTYPEMASK) > SVt_IV ? SVt_PVIV : SVt_IV));
7270 (void)SvIOK_only(sv);
7275 while (isALPHA(*d)) d++;
7276 while (isDIGIT(*d)) d++;
7278 #ifdef PERL_PRESERVE_IVUV
7279 /* Got to punt this as an integer if needs be, but we don't issue
7280 warnings. Probably ought to make the sv_iv_please() that does
7281 the conversion if possible, and silently. */
7282 const int numtype = grok_number(SvPVX_const(sv), SvCUR(sv), NULL);
7283 if (numtype && !(numtype & IS_NUMBER_INFINITY)) {
7284 /* Need to try really hard to see if it's an integer.
7285 9.22337203685478e+18 is an integer.
7286 but "9.22337203685478e+18" + 0 is UV=9223372036854779904
7287 so $a="9.22337203685478e+18"; $a+0; $a++
7288 needs to be the same as $a="9.22337203685478e+18"; $a++
7295 /* sv_2iv *should* have made this an NV */
7296 if (flags & SVp_NOK) {
7297 (void)SvNOK_only(sv);
7298 SvNV_set(sv, SvNVX(sv) + 1.0);
7301 /* I don't think we can get here. Maybe I should assert this
7302 And if we do get here I suspect that sv_setnv will croak. NWC
7304 #if defined(USE_LONG_DOUBLE)
7305 DEBUG_c(PerlIO_printf(Perl_debug_log,"sv_inc punt failed to convert '%s' to IOK or NOKp, UV=0x%"UVxf" NV=%"PERL_PRIgldbl"\n",
7306 SvPVX_const(sv), SvIVX(sv), SvNVX(sv)));
7308 DEBUG_c(PerlIO_printf(Perl_debug_log,"sv_inc punt failed to convert '%s' to IOK or NOKp, UV=0x%"UVxf" NV=%"NVgf"\n",
7309 SvPVX_const(sv), SvIVX(sv), SvNVX(sv)));
7312 #endif /* PERL_PRESERVE_IVUV */
7313 sv_setnv(sv,Atof(SvPVX_const(sv)) + 1.0);
7317 while (d >= SvPVX_const(sv)) {
7325 /* MKS: The original code here died if letters weren't consecutive.
7326 * at least it didn't have to worry about non-C locales. The
7327 * new code assumes that ('z'-'a')==('Z'-'A'), letters are
7328 * arranged in order (although not consecutively) and that only
7329 * [A-Za-z] are accepted by isALPHA in the C locale.
7331 if (*d != 'z' && *d != 'Z') {
7332 do { ++*d; } while (!isALPHA(*d));
7335 *(d--) -= 'z' - 'a';
7340 *(d--) -= 'z' - 'a' + 1;
7344 /* oh,oh, the number grew */
7345 SvGROW(sv, SvCUR(sv) + 2);
7346 SvCUR_set(sv, SvCUR(sv) + 1);
7347 for (d = SvPVX(sv) + SvCUR(sv); d > SvPVX_const(sv); d--)
7358 Auto-decrement of the value in the SV, doing string to numeric conversion
7359 if necessary. Handles 'get' magic.
7365 Perl_sv_dec(pTHX_ register SV *const sv)
7373 if (SvTHINKFIRST(sv)) {
7375 sv_force_normal_flags(sv, 0);
7376 if (SvREADONLY(sv)) {
7377 if (IN_PERL_RUNTIME)
7378 Perl_croak(aTHX_ "%s", PL_no_modify);
7382 if (SvAMAGIC(sv) && AMG_CALLun(sv,dec))
7384 i = PTR2IV(SvRV(sv));
7389 /* Unlike sv_inc we don't have to worry about string-never-numbers
7390 and keeping them magic. But we mustn't warn on punting */
7391 flags = SvFLAGS(sv);
7392 if ((flags & SVf_IOK) || ((flags & (SVp_IOK | SVp_NOK)) == SVp_IOK)) {
7393 /* It's publicly an integer, or privately an integer-not-float */
7394 #ifdef PERL_PRESERVE_IVUV
7398 if (SvUVX(sv) == 0) {
7399 (void)SvIOK_only(sv);
7403 (void)SvIOK_only_UV(sv);
7404 SvUV_set(sv, SvUVX(sv) - 1);
7407 if (SvIVX(sv) == IV_MIN) {
7408 sv_setnv(sv, (NV)IV_MIN);
7412 (void)SvIOK_only(sv);
7413 SvIV_set(sv, SvIVX(sv) - 1);
7418 if (flags & SVp_NOK) {
7421 const NV was = SvNVX(sv);
7422 if (NV_OVERFLOWS_INTEGERS_AT &&
7423 was <= -NV_OVERFLOWS_INTEGERS_AT && ckWARN(WARN_IMPRECISION)) {
7424 Perl_warner(aTHX_ packWARN(WARN_IMPRECISION),
7425 "Lost precision when decrementing %" NVff " by 1",
7428 (void)SvNOK_only(sv);
7429 SvNV_set(sv, was - 1.0);
7433 if (!(flags & SVp_POK)) {
7434 if ((flags & SVTYPEMASK) < SVt_PVIV)
7435 sv_upgrade(sv, ((flags & SVTYPEMASK) > SVt_IV) ? SVt_PVIV : SVt_IV);
7437 (void)SvIOK_only(sv);
7440 #ifdef PERL_PRESERVE_IVUV
7442 const int numtype = grok_number(SvPVX_const(sv), SvCUR(sv), NULL);
7443 if (numtype && !(numtype & IS_NUMBER_INFINITY)) {
7444 /* Need to try really hard to see if it's an integer.
7445 9.22337203685478e+18 is an integer.
7446 but "9.22337203685478e+18" + 0 is UV=9223372036854779904
7447 so $a="9.22337203685478e+18"; $a+0; $a--
7448 needs to be the same as $a="9.22337203685478e+18"; $a--
7455 /* sv_2iv *should* have made this an NV */
7456 if (flags & SVp_NOK) {
7457 (void)SvNOK_only(sv);
7458 SvNV_set(sv, SvNVX(sv) - 1.0);
7461 /* I don't think we can get here. Maybe I should assert this
7462 And if we do get here I suspect that sv_setnv will croak. NWC
7464 #if defined(USE_LONG_DOUBLE)
7465 DEBUG_c(PerlIO_printf(Perl_debug_log,"sv_dec punt failed to convert '%s' to IOK or NOKp, UV=0x%"UVxf" NV=%"PERL_PRIgldbl"\n",
7466 SvPVX_const(sv), SvIVX(sv), SvNVX(sv)));
7468 DEBUG_c(PerlIO_printf(Perl_debug_log,"sv_dec punt failed to convert '%s' to IOK or NOKp, UV=0x%"UVxf" NV=%"NVgf"\n",
7469 SvPVX_const(sv), SvIVX(sv), SvNVX(sv)));
7473 #endif /* PERL_PRESERVE_IVUV */
7474 sv_setnv(sv,Atof(SvPVX_const(sv)) - 1.0); /* punt */
7478 =for apidoc sv_mortalcopy
7480 Creates a new SV which is a copy of the original SV (using C<sv_setsv>).
7481 The new SV is marked as mortal. It will be destroyed "soon", either by an
7482 explicit call to FREETMPS, or by an implicit call at places such as
7483 statement boundaries. See also C<sv_newmortal> and C<sv_2mortal>.
7488 /* Make a string that will exist for the duration of the expression
7489 * evaluation. Actually, it may have to last longer than that, but
7490 * hopefully we won't free it until it has been assigned to a
7491 * permanent location. */
7494 Perl_sv_mortalcopy(pTHX_ SV *const oldstr)
7500 sv_setsv(sv,oldstr);
7502 PL_tmps_stack[++PL_tmps_ix] = sv;
7508 =for apidoc sv_newmortal
7510 Creates a new null SV which is mortal. The reference count of the SV is
7511 set to 1. It will be destroyed "soon", either by an explicit call to
7512 FREETMPS, or by an implicit call at places such as statement boundaries.
7513 See also C<sv_mortalcopy> and C<sv_2mortal>.
7519 Perl_sv_newmortal(pTHX)
7525 SvFLAGS(sv) = SVs_TEMP;
7527 PL_tmps_stack[++PL_tmps_ix] = sv;
7533 =for apidoc newSVpvn_flags
7535 Creates a new SV and copies a string into it. The reference count for the
7536 SV is set to 1. Note that if C<len> is zero, Perl will create a zero length
7537 string. You are responsible for ensuring that the source string is at least
7538 C<len> bytes long. If the C<s> argument is NULL the new SV will be undefined.
7539 Currently the only flag bits accepted are C<SVf_UTF8> and C<SVs_TEMP>.
7540 If C<SVs_TEMP> is set, then C<sv2mortal()> is called on the result before
7541 returning. If C<SVf_UTF8> is set, then it will be set on the new SV.
7542 C<newSVpvn_utf8()> is a convenience wrapper for this function, defined as
7544 #define newSVpvn_utf8(s, len, u) \
7545 newSVpvn_flags((s), (len), (u) ? SVf_UTF8 : 0)
7551 Perl_newSVpvn_flags(pTHX_ const char *const s, const STRLEN len, const U32 flags)
7556 /* All the flags we don't support must be zero.
7557 And we're new code so I'm going to assert this from the start. */
7558 assert(!(flags & ~(SVf_UTF8|SVs_TEMP)));
7560 sv_setpvn(sv,s,len);
7561 SvFLAGS(sv) |= (flags & SVf_UTF8);
7562 return (flags & SVs_TEMP) ? sv_2mortal(sv) : sv;
7566 =for apidoc sv_2mortal
7568 Marks an existing SV as mortal. The SV will be destroyed "soon", either
7569 by an explicit call to FREETMPS, or by an implicit call at places such as
7570 statement boundaries. SvTEMP() is turned on which means that the SV's
7571 string buffer can be "stolen" if this SV is copied. See also C<sv_newmortal>
7572 and C<sv_mortalcopy>.
7578 Perl_sv_2mortal(pTHX_ register SV *const sv)
7583 if (SvREADONLY(sv) && SvIMMORTAL(sv))
7586 PL_tmps_stack[++PL_tmps_ix] = sv;
7594 Creates a new SV and copies a string into it. The reference count for the
7595 SV is set to 1. If C<len> is zero, Perl will compute the length using
7596 strlen(). For efficiency, consider using C<newSVpvn> instead.
7602 Perl_newSVpv(pTHX_ const char *const s, const STRLEN len)
7608 sv_setpvn(sv, s, len || s == NULL ? len : strlen(s));
7613 =for apidoc newSVpvn
7615 Creates a new SV and copies a string into it. The reference count for the
7616 SV is set to 1. Note that if C<len> is zero, Perl will create a zero length
7617 string. You are responsible for ensuring that the source string is at least
7618 C<len> bytes long. If the C<s> argument is NULL the new SV will be undefined.
7624 Perl_newSVpvn(pTHX_ const char *const s, const STRLEN len)
7630 sv_setpvn(sv,s,len);
7635 =for apidoc newSVhek
7637 Creates a new SV from the hash key structure. It will generate scalars that
7638 point to the shared string table where possible. Returns a new (undefined)
7639 SV if the hek is NULL.
7645 Perl_newSVhek(pTHX_ const HEK *const hek)
7655 if (HEK_LEN(hek) == HEf_SVKEY) {
7656 return newSVsv(*(SV**)HEK_KEY(hek));
7658 const int flags = HEK_FLAGS(hek);
7659 if (flags & HVhek_WASUTF8) {
7661 Andreas would like keys he put in as utf8 to come back as utf8
7663 STRLEN utf8_len = HEK_LEN(hek);
7664 const U8 *as_utf8 = bytes_to_utf8 ((U8*)HEK_KEY(hek), &utf8_len);
7665 SV * const sv = newSVpvn ((const char*)as_utf8, utf8_len);
7668 Safefree (as_utf8); /* bytes_to_utf8() allocates a new string */
7670 } else if (flags & (HVhek_REHASH|HVhek_UNSHARED)) {
7671 /* We don't have a pointer to the hv, so we have to replicate the
7672 flag into every HEK. This hv is using custom a hasing
7673 algorithm. Hence we can't return a shared string scalar, as
7674 that would contain the (wrong) hash value, and might get passed
7675 into an hv routine with a regular hash.
7676 Similarly, a hash that isn't using shared hash keys has to have
7677 the flag in every key so that we know not to try to call
7678 share_hek_kek on it. */
7680 SV * const sv = newSVpvn (HEK_KEY(hek), HEK_LEN(hek));
7685 /* This will be overwhelminly the most common case. */
7687 /* Inline most of newSVpvn_share(), because share_hek_hek() is far
7688 more efficient than sharepvn(). */
7692 sv_upgrade(sv, SVt_PV);
7693 SvPV_set(sv, (char *)HEK_KEY(share_hek_hek(hek)));
7694 SvCUR_set(sv, HEK_LEN(hek));
7707 =for apidoc newSVpvn_share
7709 Creates a new SV with its SvPVX_const pointing to a shared string in the string
7710 table. If the string does not already exist in the table, it is created
7711 first. Turns on READONLY and FAKE. If the C<hash> parameter is non-zero, that
7712 value is used; otherwise the hash is computed. The string's hash can be later
7713 be retrieved from the SV with the C<SvSHARED_HASH()> macro. The idea here is
7714 that as the string table is used for shared hash keys these strings will have
7715 SvPVX_const == HeKEY and hash lookup will avoid string compare.
7721 Perl_newSVpvn_share(pTHX_ const char *src, I32 len, U32 hash)
7725 bool is_utf8 = FALSE;
7726 const char *const orig_src = src;
7729 STRLEN tmplen = -len;
7731 /* See the note in hv.c:hv_fetch() --jhi */
7732 src = (char*)bytes_from_utf8((const U8*)src, &tmplen, &is_utf8);
7736 PERL_HASH(hash, src, len);
7738 /* The logic for this is inlined in S_mro_get_linear_isa_dfs(), so if it
7739 changes here, update it there too. */
7740 sv_upgrade(sv, SVt_PV);
7741 SvPV_set(sv, sharepvn(src, is_utf8?-len:len, hash));
7749 if (src != orig_src)
7755 #if defined(PERL_IMPLICIT_CONTEXT)
7757 /* pTHX_ magic can't cope with varargs, so this is a no-context
7758 * version of the main function, (which may itself be aliased to us).
7759 * Don't access this version directly.
7763 Perl_newSVpvf_nocontext(const char *const pat, ...)
7769 PERL_ARGS_ASSERT_NEWSVPVF_NOCONTEXT;
7771 va_start(args, pat);
7772 sv = vnewSVpvf(pat, &args);
7779 =for apidoc newSVpvf
7781 Creates a new SV and initializes it with the string formatted like
7788 Perl_newSVpvf(pTHX_ const char *const pat, ...)
7793 PERL_ARGS_ASSERT_NEWSVPVF;
7795 va_start(args, pat);
7796 sv = vnewSVpvf(pat, &args);
7801 /* backend for newSVpvf() and newSVpvf_nocontext() */
7804 Perl_vnewSVpvf(pTHX_ const char *const pat, va_list *const args)
7809 PERL_ARGS_ASSERT_VNEWSVPVF;
7812 sv_vsetpvfn(sv, pat, strlen(pat), args, NULL, 0, NULL);
7819 Creates a new SV and copies a floating point value into it.
7820 The reference count for the SV is set to 1.
7826 Perl_newSVnv(pTHX_ const NV n)
7839 Creates a new SV and copies an integer into it. The reference count for the
7846 Perl_newSViv(pTHX_ const IV i)
7859 Creates a new SV and copies an unsigned integer into it.
7860 The reference count for the SV is set to 1.
7866 Perl_newSVuv(pTHX_ const UV u)
7877 =for apidoc newSV_type
7879 Creates a new SV, of the type specified. The reference count for the new SV
7886 Perl_newSV_type(pTHX_ const svtype type)
7891 sv_upgrade(sv, type);
7896 =for apidoc newRV_noinc
7898 Creates an RV wrapper for an SV. The reference count for the original
7899 SV is B<not> incremented.
7905 Perl_newRV_noinc(pTHX_ SV *const tmpRef)
7908 register SV *sv = newSV_type(SVt_IV);
7910 PERL_ARGS_ASSERT_NEWRV_NOINC;
7913 SvRV_set(sv, tmpRef);
7918 /* newRV_inc is the official function name to use now.
7919 * newRV_inc is in fact #defined to newRV in sv.h
7923 Perl_newRV(pTHX_ SV *const sv)
7927 PERL_ARGS_ASSERT_NEWRV;
7929 return newRV_noinc(SvREFCNT_inc_simple_NN(sv));
7935 Creates a new SV which is an exact duplicate of the original SV.
7942 Perl_newSVsv(pTHX_ register SV *const old)
7949 if (SvTYPE(old) == SVTYPEMASK) {
7950 if (ckWARN_d(WARN_INTERNAL))
7951 Perl_warner(aTHX_ packWARN(WARN_INTERNAL), "semi-panic: attempt to dup freed string");
7955 /* SV_GMAGIC is the default for sv_setv()
7956 SV_NOSTEAL prevents TEMP buffers being, well, stolen, and saves games
7957 with SvTEMP_off and SvTEMP_on round a call to sv_setsv. */
7958 sv_setsv_flags(sv, old, SV_GMAGIC | SV_NOSTEAL);
7963 =for apidoc sv_reset
7965 Underlying implementation for the C<reset> Perl function.
7966 Note that the perl-level function is vaguely deprecated.
7972 Perl_sv_reset(pTHX_ register const char *s, HV *const stash)
7975 char todo[PERL_UCHAR_MAX+1];
7977 PERL_ARGS_ASSERT_SV_RESET;
7982 if (!*s) { /* reset ?? searches */
7983 MAGIC * const mg = mg_find((const SV *)stash, PERL_MAGIC_symtab);
7985 const U32 count = mg->mg_len / sizeof(PMOP**);
7986 PMOP **pmp = (PMOP**) mg->mg_ptr;
7987 PMOP *const *const end = pmp + count;
7991 SvREADONLY_off(PL_regex_pad[(*pmp)->op_pmoffset]);
7993 (*pmp)->op_pmflags &= ~PMf_USED;
8001 /* reset variables */
8003 if (!HvARRAY(stash))
8006 Zero(todo, 256, char);
8009 I32 i = (unsigned char)*s;
8013 max = (unsigned char)*s++;
8014 for ( ; i <= max; i++) {
8017 for (i = 0; i <= (I32) HvMAX(stash); i++) {
8019 for (entry = HvARRAY(stash)[i];
8021 entry = HeNEXT(entry))
8026 if (!todo[(U8)*HeKEY(entry)])
8028 gv = MUTABLE_GV(HeVAL(entry));
8031 if (SvTHINKFIRST(sv)) {
8032 if (!SvREADONLY(sv) && SvROK(sv))
8034 /* XXX Is this continue a bug? Why should THINKFIRST
8035 exempt us from resetting arrays and hashes? */
8039 if (SvTYPE(sv) >= SVt_PV) {
8041 if (SvPVX_const(sv) != NULL)
8049 if (GvHV(gv) && !HvNAME_get(GvHV(gv))) {
8051 Perl_die(aTHX_ "Can't reset %%ENV on this system");
8054 # if defined(USE_ENVIRON_ARRAY)
8057 # endif /* USE_ENVIRON_ARRAY */
8068 Using various gambits, try to get an IO from an SV: the IO slot if its a
8069 GV; or the recursive result if we're an RV; or the IO slot of the symbol
8070 named after the PV if we're a string.
8076 Perl_sv_2io(pTHX_ SV *const sv)
8081 PERL_ARGS_ASSERT_SV_2IO;
8083 switch (SvTYPE(sv)) {
8085 io = MUTABLE_IO(sv);
8088 if (isGV_with_GP(sv)) {
8089 gv = MUTABLE_GV(sv);
8092 Perl_croak(aTHX_ "Bad filehandle: %s", GvNAME(gv));
8098 Perl_croak(aTHX_ PL_no_usym, "filehandle");
8100 return sv_2io(SvRV(sv));
8101 gv = gv_fetchsv(sv, 0, SVt_PVIO);
8107 Perl_croak(aTHX_ "Bad filehandle: %"SVf, SVfARG(sv));
8116 Using various gambits, try to get a CV from an SV; in addition, try if
8117 possible to set C<*st> and C<*gvp> to the stash and GV associated with it.
8118 The flags in C<lref> are passed to sv_fetchsv.
8124 Perl_sv_2cv(pTHX_ SV *sv, HV **const st, GV **const gvp, const I32 lref)
8130 PERL_ARGS_ASSERT_SV_2CV;
8137 switch (SvTYPE(sv)) {
8141 return MUTABLE_CV(sv);
8148 if (isGV_with_GP(sv)) {
8149 gv = MUTABLE_GV(sv);
8158 SV * const *sp = &sv; /* Used in tryAMAGICunDEREF macro. */
8160 tryAMAGICunDEREF(to_cv);
8163 if (SvTYPE(sv) == SVt_PVCV) {
8164 cv = MUTABLE_CV(sv);
8169 else if(isGV_with_GP(sv))
8170 gv = MUTABLE_GV(sv);
8172 Perl_croak(aTHX_ "Not a subroutine reference");
8174 else if (isGV_with_GP(sv)) {
8176 gv = MUTABLE_GV(sv);
8179 gv = gv_fetchsv(sv, lref, SVt_PVCV); /* Calls get magic */
8185 /* Some flags to gv_fetchsv mean don't really create the GV */
8186 if (!isGV_with_GP(gv)) {
8192 if (lref && !GvCVu(gv)) {
8196 gv_efullname3(tmpsv, gv, NULL);
8197 /* XXX this is probably not what they think they're getting.
8198 * It has the same effect as "sub name;", i.e. just a forward
8200 newSUB(start_subparse(FALSE, 0),
8201 newSVOP(OP_CONST, 0, tmpsv),
8205 Perl_croak(aTHX_ "Unable to create sub named \"%"SVf"\"",
8206 SVfARG(SvOK(sv) ? sv : &PL_sv_no));
8215 Returns true if the SV has a true value by Perl's rules.
8216 Use the C<SvTRUE> macro instead, which may call C<sv_true()> or may
8217 instead use an in-line version.
8223 Perl_sv_true(pTHX_ register SV *const sv)
8228 register const XPV* const tXpv = (XPV*)SvANY(sv);
8230 (tXpv->xpv_cur > 1 ||
8231 (tXpv->xpv_cur && *sv->sv_u.svu_pv != '0')))
8238 return SvIVX(sv) != 0;
8241 return SvNVX(sv) != 0.0;
8243 return sv_2bool(sv);
8249 =for apidoc sv_pvn_force
8251 Get a sensible string out of the SV somehow.
8252 A private implementation of the C<SvPV_force> macro for compilers which
8253 can't cope with complex macro expressions. Always use the macro instead.
8255 =for apidoc sv_pvn_force_flags
8257 Get a sensible string out of the SV somehow.
8258 If C<flags> has C<SV_GMAGIC> bit set, will C<mg_get> on C<sv> if
8259 appropriate, else not. C<sv_pvn_force> and C<sv_pvn_force_nomg> are
8260 implemented in terms of this function.
8261 You normally want to use the various wrapper macros instead: see
8262 C<SvPV_force> and C<SvPV_force_nomg>
8268 Perl_sv_pvn_force_flags(pTHX_ SV *const sv, STRLEN *const lp, const I32 flags)
8272 PERL_ARGS_ASSERT_SV_PVN_FORCE_FLAGS;
8274 if (SvTHINKFIRST(sv) && !SvROK(sv))
8275 sv_force_normal_flags(sv, 0);
8285 if (SvREADONLY(sv) && !(flags & SV_MUTABLE_RETURN)) {
8286 const char * const ref = sv_reftype(sv,0);
8288 Perl_croak(aTHX_ "Can't coerce readonly %s to string in %s",
8289 ref, OP_NAME(PL_op));
8291 Perl_croak(aTHX_ "Can't coerce readonly %s to string", ref);
8293 if ((SvTYPE(sv) > SVt_PVLV && SvTYPE(sv) != SVt_PVFM)
8294 || isGV_with_GP(sv))
8295 Perl_croak(aTHX_ "Can't coerce %s to string in %s", sv_reftype(sv,0),
8297 s = sv_2pv_flags(sv, &len, flags);
8301 if (s != SvPVX_const(sv)) { /* Almost, but not quite, sv_setpvn() */
8304 SvUPGRADE(sv, SVt_PV); /* Never FALSE */
8305 SvGROW(sv, len + 1);
8306 Move(s,SvPVX(sv),len,char);
8308 SvPVX(sv)[len] = '\0';
8311 SvPOK_on(sv); /* validate pointer */
8313 DEBUG_c(PerlIO_printf(Perl_debug_log, "0x%"UVxf" 2pv(%s)\n",
8314 PTR2UV(sv),SvPVX_const(sv)));
8317 return SvPVX_mutable(sv);
8321 =for apidoc sv_pvbyten_force
8323 The backend for the C<SvPVbytex_force> macro. Always use the macro instead.
8329 Perl_sv_pvbyten_force(pTHX_ SV *const sv, STRLEN *const lp)
8331 PERL_ARGS_ASSERT_SV_PVBYTEN_FORCE;
8333 sv_pvn_force(sv,lp);
8334 sv_utf8_downgrade(sv,0);
8340 =for apidoc sv_pvutf8n_force
8342 The backend for the C<SvPVutf8x_force> macro. Always use the macro instead.
8348 Perl_sv_pvutf8n_force(pTHX_ SV *const sv, STRLEN *const lp)
8350 PERL_ARGS_ASSERT_SV_PVUTF8N_FORCE;
8352 sv_pvn_force(sv,lp);
8353 sv_utf8_upgrade(sv);
8359 =for apidoc sv_reftype
8361 Returns a string describing what the SV is a reference to.
8367 Perl_sv_reftype(pTHX_ const SV *const sv, const int ob)
8369 PERL_ARGS_ASSERT_SV_REFTYPE;
8371 /* The fact that I don't need to downcast to char * everywhere, only in ?:
8372 inside return suggests a const propagation bug in g++. */
8373 if (ob && SvOBJECT(sv)) {
8374 char * const name = HvNAME_get(SvSTASH(sv));
8375 return name ? name : (char *) "__ANON__";
8378 switch (SvTYPE(sv)) {
8393 case SVt_PVLV: return (char *) (SvROK(sv) ? "REF"
8394 /* tied lvalues should appear to be
8395 * scalars for backwards compatitbility */
8396 : (LvTYPE(sv) == 't' || LvTYPE(sv) == 'T')
8397 ? "SCALAR" : "LVALUE");
8398 case SVt_PVAV: return "ARRAY";
8399 case SVt_PVHV: return "HASH";
8400 case SVt_PVCV: return "CODE";
8401 case SVt_PVGV: return (char *) (isGV_with_GP(sv)
8402 ? "GLOB" : "SCALAR");
8403 case SVt_PVFM: return "FORMAT";
8404 case SVt_PVIO: return "IO";
8405 case SVt_BIND: return "BIND";
8406 case SVt_REGEXP: return "REGEXP";
8407 default: return "UNKNOWN";
8413 =for apidoc sv_isobject
8415 Returns a boolean indicating whether the SV is an RV pointing to a blessed
8416 object. If the SV is not an RV, or if the object is not blessed, then this
8423 Perl_sv_isobject(pTHX_ SV *sv)
8439 Returns a boolean indicating whether the SV is blessed into the specified
8440 class. This does not check for subtypes; use C<sv_derived_from> to verify
8441 an inheritance relationship.
8447 Perl_sv_isa(pTHX_ SV *sv, const char *const name)
8451 PERL_ARGS_ASSERT_SV_ISA;
8461 hvname = HvNAME_get(SvSTASH(sv));
8465 return strEQ(hvname, name);
8471 Creates a new SV for the RV, C<rv>, to point to. If C<rv> is not an RV then
8472 it will be upgraded to one. If C<classname> is non-null then the new SV will
8473 be blessed in the specified package. The new SV is returned and its
8474 reference count is 1.
8480 Perl_newSVrv(pTHX_ SV *const rv, const char *const classname)
8485 PERL_ARGS_ASSERT_NEWSVRV;
8489 SV_CHECK_THINKFIRST_COW_DROP(rv);
8490 (void)SvAMAGIC_off(rv);
8492 if (SvTYPE(rv) >= SVt_PVMG) {
8493 const U32 refcnt = SvREFCNT(rv);
8497 SvREFCNT(rv) = refcnt;
8499 sv_upgrade(rv, SVt_IV);
8500 } else if (SvROK(rv)) {
8501 SvREFCNT_dec(SvRV(rv));
8503 prepare_SV_for_RV(rv);
8511 HV* const stash = gv_stashpv(classname, GV_ADD);
8512 (void)sv_bless(rv, stash);
8518 =for apidoc sv_setref_pv
8520 Copies a pointer into a new SV, optionally blessing the SV. The C<rv>
8521 argument will be upgraded to an RV. That RV will be modified to point to
8522 the new SV. If the C<pv> argument is NULL then C<PL_sv_undef> will be placed
8523 into the SV. The C<classname> argument indicates the package for the
8524 blessing. Set C<classname> to C<NULL> to avoid the blessing. The new SV
8525 will have a reference count of 1, and the RV will be returned.
8527 Do not use with other Perl types such as HV, AV, SV, CV, because those
8528 objects will become corrupted by the pointer copy process.
8530 Note that C<sv_setref_pvn> copies the string while this copies the pointer.
8536 Perl_sv_setref_pv(pTHX_ SV *const rv, const char *const classname, void *const pv)
8540 PERL_ARGS_ASSERT_SV_SETREF_PV;
8543 sv_setsv(rv, &PL_sv_undef);
8547 sv_setiv(newSVrv(rv,classname), PTR2IV(pv));
8552 =for apidoc sv_setref_iv
8554 Copies an integer into a new SV, optionally blessing the SV. The C<rv>
8555 argument will be upgraded to an RV. That RV will be modified to point to
8556 the new SV. The C<classname> argument indicates the package for the
8557 blessing. Set C<classname> to C<NULL> to avoid the blessing. The new SV
8558 will have a reference count of 1, and the RV will be returned.
8564 Perl_sv_setref_iv(pTHX_ SV *const rv, const char *const classname, const IV iv)
8566 PERL_ARGS_ASSERT_SV_SETREF_IV;
8568 sv_setiv(newSVrv(rv,classname), iv);
8573 =for apidoc sv_setref_uv
8575 Copies an unsigned integer into a new SV, optionally blessing the SV. The C<rv>
8576 argument will be upgraded to an RV. That RV will be modified to point to
8577 the new SV. The C<classname> argument indicates the package for the
8578 blessing. Set C<classname> to C<NULL> to avoid the blessing. The new SV
8579 will have a reference count of 1, and the RV will be returned.
8585 Perl_sv_setref_uv(pTHX_ SV *const rv, const char *const classname, const UV uv)
8587 PERL_ARGS_ASSERT_SV_SETREF_UV;
8589 sv_setuv(newSVrv(rv,classname), uv);
8594 =for apidoc sv_setref_nv
8596 Copies a double into a new SV, optionally blessing the SV. The C<rv>
8597 argument will be upgraded to an RV. That RV will be modified to point to
8598 the new SV. The C<classname> argument indicates the package for the
8599 blessing. Set C<classname> to C<NULL> to avoid the blessing. The new SV
8600 will have a reference count of 1, and the RV will be returned.
8606 Perl_sv_setref_nv(pTHX_ SV *const rv, const char *const classname, const NV nv)
8608 PERL_ARGS_ASSERT_SV_SETREF_NV;
8610 sv_setnv(newSVrv(rv,classname), nv);
8615 =for apidoc sv_setref_pvn
8617 Copies a string into a new SV, optionally blessing the SV. The length of the
8618 string must be specified with C<n>. The C<rv> argument will be upgraded to
8619 an RV. That RV will be modified to point to the new SV. The C<classname>
8620 argument indicates the package for the blessing. Set C<classname> to
8621 C<NULL> to avoid the blessing. The new SV will have a reference count
8622 of 1, and the RV will be returned.
8624 Note that C<sv_setref_pv> copies the pointer while this copies the string.
8630 Perl_sv_setref_pvn(pTHX_ SV *const rv, const char *const classname,
8631 const char *const pv, const STRLEN n)
8633 PERL_ARGS_ASSERT_SV_SETREF_PVN;
8635 sv_setpvn(newSVrv(rv,classname), pv, n);
8640 =for apidoc sv_bless
8642 Blesses an SV into a specified package. The SV must be an RV. The package
8643 must be designated by its stash (see C<gv_stashpv()>). The reference count
8644 of the SV is unaffected.
8650 Perl_sv_bless(pTHX_ SV *const sv, HV *const stash)
8655 PERL_ARGS_ASSERT_SV_BLESS;
8658 Perl_croak(aTHX_ "Can't bless non-reference value");
8660 if (SvFLAGS(tmpRef) & (SVs_OBJECT|SVf_READONLY)) {
8661 if (SvIsCOW(tmpRef))
8662 sv_force_normal_flags(tmpRef, 0);
8663 if (SvREADONLY(tmpRef))
8664 Perl_croak(aTHX_ "%s", PL_no_modify);
8665 if (SvOBJECT(tmpRef)) {
8666 if (SvTYPE(tmpRef) != SVt_PVIO)
8668 SvREFCNT_dec(SvSTASH(tmpRef));
8671 SvOBJECT_on(tmpRef);
8672 if (SvTYPE(tmpRef) != SVt_PVIO)
8674 SvUPGRADE(tmpRef, SVt_PVMG);
8675 SvSTASH_set(tmpRef, MUTABLE_HV(SvREFCNT_inc_simple(stash)));
8680 (void)SvAMAGIC_off(sv);
8682 if(SvSMAGICAL(tmpRef))
8683 if(mg_find(tmpRef, PERL_MAGIC_ext) || mg_find(tmpRef, PERL_MAGIC_uvar))
8691 /* Downgrades a PVGV to a PVMG.
8695 S_sv_unglob(pTHX_ SV *const sv)
8700 SV * const temp = sv_newmortal();
8702 PERL_ARGS_ASSERT_SV_UNGLOB;
8704 assert(SvTYPE(sv) == SVt_PVGV);
8706 gv_efullname3(temp, MUTABLE_GV(sv), "*");
8709 if(GvCVu((const GV *)sv) && (stash = GvSTASH(MUTABLE_GV(sv)))
8710 && HvNAME_get(stash))
8711 mro_method_changed_in(stash);
8712 gp_free(MUTABLE_GV(sv));
8715 sv_del_backref(MUTABLE_SV(GvSTASH(sv)), sv);
8719 if (GvNAME_HEK(sv)) {
8720 unshare_hek(GvNAME_HEK(sv));
8722 isGV_with_GP_off(sv);
8724 /* need to keep SvANY(sv) in the right arena */
8725 xpvmg = new_XPVMG();
8726 StructCopy(SvANY(sv), xpvmg, XPVMG);
8727 del_XPVGV(SvANY(sv));
8730 SvFLAGS(sv) &= ~SVTYPEMASK;
8731 SvFLAGS(sv) |= SVt_PVMG;
8733 /* Intentionally not calling any local SET magic, as this isn't so much a
8734 set operation as merely an internal storage change. */
8735 sv_setsv_flags(sv, temp, 0);
8739 =for apidoc sv_unref_flags
8741 Unsets the RV status of the SV, and decrements the reference count of
8742 whatever was being referenced by the RV. This can almost be thought of
8743 as a reversal of C<newSVrv>. The C<cflags> argument can contain
8744 C<SV_IMMEDIATE_UNREF> to force the reference count to be decremented
8745 (otherwise the decrementing is conditional on the reference count being
8746 different from one or the reference being a readonly SV).
8753 Perl_sv_unref_flags(pTHX_ SV *const ref, const U32 flags)
8755 SV* const target = SvRV(ref);
8757 PERL_ARGS_ASSERT_SV_UNREF_FLAGS;
8759 if (SvWEAKREF(ref)) {
8760 sv_del_backref(target, ref);
8762 SvRV_set(ref, NULL);
8765 SvRV_set(ref, NULL);
8767 /* You can't have a || SvREADONLY(target) here, as $a = $$a, where $a was
8768 assigned to as BEGIN {$a = \"Foo"} will fail. */
8769 if (SvREFCNT(target) != 1 || (flags & SV_IMMEDIATE_UNREF))
8770 SvREFCNT_dec(target);
8771 else /* XXX Hack, but hard to make $a=$a->[1] work otherwise */
8772 sv_2mortal(target); /* Schedule for freeing later */
8776 =for apidoc sv_untaint
8778 Untaint an SV. Use C<SvTAINTED_off> instead.
8783 Perl_sv_untaint(pTHX_ SV *const sv)
8785 PERL_ARGS_ASSERT_SV_UNTAINT;
8787 if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv)) {
8788 MAGIC * const mg = mg_find(sv, PERL_MAGIC_taint);
8795 =for apidoc sv_tainted
8797 Test an SV for taintedness. Use C<SvTAINTED> instead.
8802 Perl_sv_tainted(pTHX_ SV *const sv)
8804 PERL_ARGS_ASSERT_SV_TAINTED;
8806 if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv)) {
8807 const MAGIC * const mg = mg_find(sv, PERL_MAGIC_taint);
8808 if (mg && (mg->mg_len & 1) )
8815 =for apidoc sv_setpviv
8817 Copies an integer into the given SV, also updating its string value.
8818 Does not handle 'set' magic. See C<sv_setpviv_mg>.
8824 Perl_sv_setpviv(pTHX_ SV *const sv, const IV iv)
8826 char buf[TYPE_CHARS(UV)];
8828 char * const ptr = uiv_2buf(buf, iv, 0, 0, &ebuf);
8830 PERL_ARGS_ASSERT_SV_SETPVIV;
8832 sv_setpvn(sv, ptr, ebuf - ptr);
8836 =for apidoc sv_setpviv_mg
8838 Like C<sv_setpviv>, but also handles 'set' magic.
8844 Perl_sv_setpviv_mg(pTHX_ SV *const sv, const IV iv)
8846 PERL_ARGS_ASSERT_SV_SETPVIV_MG;
8852 #if defined(PERL_IMPLICIT_CONTEXT)
8854 /* pTHX_ magic can't cope with varargs, so this is a no-context
8855 * version of the main function, (which may itself be aliased to us).
8856 * Don't access this version directly.
8860 Perl_sv_setpvf_nocontext(SV *const sv, const char *const pat, ...)
8865 PERL_ARGS_ASSERT_SV_SETPVF_NOCONTEXT;
8867 va_start(args, pat);
8868 sv_vsetpvf(sv, pat, &args);
8872 /* pTHX_ magic can't cope with varargs, so this is a no-context
8873 * version of the main function, (which may itself be aliased to us).
8874 * Don't access this version directly.
8878 Perl_sv_setpvf_mg_nocontext(SV *const sv, const char *const pat, ...)
8883 PERL_ARGS_ASSERT_SV_SETPVF_MG_NOCONTEXT;
8885 va_start(args, pat);
8886 sv_vsetpvf_mg(sv, pat, &args);
8892 =for apidoc sv_setpvf
8894 Works like C<sv_catpvf> but copies the text into the SV instead of
8895 appending it. Does not handle 'set' magic. See C<sv_setpvf_mg>.
8901 Perl_sv_setpvf(pTHX_ SV *const sv, const char *const pat, ...)
8905 PERL_ARGS_ASSERT_SV_SETPVF;
8907 va_start(args, pat);
8908 sv_vsetpvf(sv, pat, &args);
8913 =for apidoc sv_vsetpvf
8915 Works like C<sv_vcatpvf> but copies the text into the SV instead of
8916 appending it. Does not handle 'set' magic. See C<sv_vsetpvf_mg>.
8918 Usually used via its frontend C<sv_setpvf>.
8924 Perl_sv_vsetpvf(pTHX_ SV *const sv, const char *const pat, va_list *const args)
8926 PERL_ARGS_ASSERT_SV_VSETPVF;
8928 sv_vsetpvfn(sv, pat, strlen(pat), args, NULL, 0, NULL);
8932 =for apidoc sv_setpvf_mg
8934 Like C<sv_setpvf>, but also handles 'set' magic.
8940 Perl_sv_setpvf_mg(pTHX_ SV *const sv, const char *const pat, ...)
8944 PERL_ARGS_ASSERT_SV_SETPVF_MG;
8946 va_start(args, pat);
8947 sv_vsetpvf_mg(sv, pat, &args);
8952 =for apidoc sv_vsetpvf_mg
8954 Like C<sv_vsetpvf>, but also handles 'set' magic.
8956 Usually used via its frontend C<sv_setpvf_mg>.
8962 Perl_sv_vsetpvf_mg(pTHX_ SV *const sv, const char *const pat, va_list *const args)
8964 PERL_ARGS_ASSERT_SV_VSETPVF_MG;
8966 sv_vsetpvfn(sv, pat, strlen(pat), args, NULL, 0, NULL);
8970 #if defined(PERL_IMPLICIT_CONTEXT)
8972 /* pTHX_ magic can't cope with varargs, so this is a no-context
8973 * version of the main function, (which may itself be aliased to us).
8974 * Don't access this version directly.
8978 Perl_sv_catpvf_nocontext(SV *const sv, const char *const pat, ...)
8983 PERL_ARGS_ASSERT_SV_CATPVF_NOCONTEXT;
8985 va_start(args, pat);
8986 sv_vcatpvf(sv, pat, &args);
8990 /* pTHX_ magic can't cope with varargs, so this is a no-context
8991 * version of the main function, (which may itself be aliased to us).
8992 * Don't access this version directly.
8996 Perl_sv_catpvf_mg_nocontext(SV *const sv, const char *const pat, ...)
9001 PERL_ARGS_ASSERT_SV_CATPVF_MG_NOCONTEXT;
9003 va_start(args, pat);
9004 sv_vcatpvf_mg(sv, pat, &args);
9010 =for apidoc sv_catpvf
9012 Processes its arguments like C<sprintf> and appends the formatted
9013 output to an SV. If the appended data contains "wide" characters
9014 (including, but not limited to, SVs with a UTF-8 PV formatted with %s,
9015 and characters >255 formatted with %c), the original SV might get
9016 upgraded to UTF-8. Handles 'get' magic, but not 'set' magic. See
9017 C<sv_catpvf_mg>. If the original SV was UTF-8, the pattern should be
9018 valid UTF-8; if the original SV was bytes, the pattern should be too.
9023 Perl_sv_catpvf(pTHX_ SV *const sv, const char *const pat, ...)
9027 PERL_ARGS_ASSERT_SV_CATPVF;
9029 va_start(args, pat);
9030 sv_vcatpvf(sv, pat, &args);
9035 =for apidoc sv_vcatpvf
9037 Processes its arguments like C<vsprintf> and appends the formatted output
9038 to an SV. Does not handle 'set' magic. See C<sv_vcatpvf_mg>.
9040 Usually used via its frontend C<sv_catpvf>.
9046 Perl_sv_vcatpvf(pTHX_ SV *const sv, const char *const pat, va_list *const args)
9048 PERL_ARGS_ASSERT_SV_VCATPVF;
9050 sv_vcatpvfn(sv, pat, strlen(pat), args, NULL, 0, NULL);
9054 =for apidoc sv_catpvf_mg
9056 Like C<sv_catpvf>, but also handles 'set' magic.
9062 Perl_sv_catpvf_mg(pTHX_ SV *const sv, const char *const pat, ...)
9066 PERL_ARGS_ASSERT_SV_CATPVF_MG;
9068 va_start(args, pat);
9069 sv_vcatpvf_mg(sv, pat, &args);
9074 =for apidoc sv_vcatpvf_mg
9076 Like C<sv_vcatpvf>, but also handles 'set' magic.
9078 Usually used via its frontend C<sv_catpvf_mg>.
9084 Perl_sv_vcatpvf_mg(pTHX_ SV *const sv, const char *const pat, va_list *const args)
9086 PERL_ARGS_ASSERT_SV_VCATPVF_MG;
9088 sv_vcatpvfn(sv, pat, strlen(pat), args, NULL, 0, NULL);
9093 =for apidoc sv_vsetpvfn
9095 Works like C<sv_vcatpvfn> but copies the text into the SV instead of
9098 Usually used via one of its frontends C<sv_vsetpvf> and C<sv_vsetpvf_mg>.
9104 Perl_sv_vsetpvfn(pTHX_ SV *const sv, const char *const pat, const STRLEN patlen,
9105 va_list *const args, SV **const svargs, const I32 svmax, bool *const maybe_tainted)
9107 PERL_ARGS_ASSERT_SV_VSETPVFN;
9110 sv_vcatpvfn(sv, pat, patlen, args, svargs, svmax, maybe_tainted);
9114 S_expect_number(pTHX_ char **const pattern)
9119 PERL_ARGS_ASSERT_EXPECT_NUMBER;
9121 switch (**pattern) {
9122 case '1': case '2': case '3':
9123 case '4': case '5': case '6':
9124 case '7': case '8': case '9':
9125 var = *(*pattern)++ - '0';
9126 while (isDIGIT(**pattern)) {
9127 const I32 tmp = var * 10 + (*(*pattern)++ - '0');
9129 Perl_croak(aTHX_ "Integer overflow in format string for %s", (PL_op ? OP_NAME(PL_op) : "sv_vcatpvfn"));
9137 S_F0convert(NV nv, char *const endbuf, STRLEN *const len)
9139 const int neg = nv < 0;
9142 PERL_ARGS_ASSERT_F0CONVERT;
9150 if (uv & 1 && uv == nv)
9151 uv--; /* Round to even */
9153 const unsigned dig = uv % 10;
9166 =for apidoc sv_vcatpvfn
9168 Processes its arguments like C<vsprintf> and appends the formatted output
9169 to an SV. Uses an array of SVs if the C style variable argument list is
9170 missing (NULL). When running with taint checks enabled, indicates via
9171 C<maybe_tainted> if results are untrustworthy (often due to the use of
9174 Usually used via one of its frontends C<sv_vcatpvf> and C<sv_vcatpvf_mg>.
9180 #define VECTORIZE_ARGS vecsv = va_arg(*args, SV*);\
9181 vecstr = (U8*)SvPV_const(vecsv,veclen);\
9182 vec_utf8 = DO_UTF8(vecsv);
9184 /* XXX maybe_tainted is never assigned to, so the doc above is lying. */
9187 Perl_sv_vcatpvfn(pTHX_ SV *const sv, const char *const pat, const STRLEN patlen,
9188 va_list *const args, SV **const svargs, const I32 svmax, bool *const maybe_tainted)
9196 static const char nullstr[] = "(null)";
9198 bool has_utf8 = DO_UTF8(sv); /* has the result utf8? */
9199 const bool pat_utf8 = has_utf8; /* the pattern is in utf8? */
9201 /* Times 4: a decimal digit takes more than 3 binary digits.
9202 * NV_DIG: mantissa takes than many decimal digits.
9203 * Plus 32: Playing safe. */
9204 char ebuf[IV_DIG * 4 + NV_DIG + 32];
9205 /* large enough for "%#.#f" --chip */
9206 /* what about long double NVs? --jhi */
9208 PERL_ARGS_ASSERT_SV_VCATPVFN;
9209 PERL_UNUSED_ARG(maybe_tainted);
9211 /* no matter what, this is a string now */
9212 (void)SvPV_force(sv, origlen);
9214 /* special-case "", "%s", and "%-p" (SVf - see below) */
9217 if (patlen == 2 && pat[0] == '%' && pat[1] == 's') {
9219 const char * const s = va_arg(*args, char*);
9220 sv_catpv(sv, s ? s : nullstr);
9222 else if (svix < svmax) {
9223 sv_catsv(sv, *svargs);
9227 if (args && patlen == 3 && pat[0] == '%' &&
9228 pat[1] == '-' && pat[2] == 'p') {
9229 argsv = MUTABLE_SV(va_arg(*args, void*));
9230 sv_catsv(sv, argsv);
9234 #ifndef USE_LONG_DOUBLE
9235 /* special-case "%.<number>[gf]" */
9236 if ( !args && patlen <= 5 && pat[0] == '%' && pat[1] == '.'
9237 && (pat[patlen-1] == 'g' || pat[patlen-1] == 'f') ) {
9238 unsigned digits = 0;
9242 while (*pp >= '0' && *pp <= '9')
9243 digits = 10 * digits + (*pp++ - '0');
9244 if (pp - pat == (int)patlen - 1) {
9252 /* Add check for digits != 0 because it seems that some
9253 gconverts are buggy in this case, and we don't yet have
9254 a Configure test for this. */
9255 if (digits && digits < sizeof(ebuf) - NV_DIG - 10) {
9256 /* 0, point, slack */
9257 Gconvert(nv, (int)digits, 0, ebuf);
9259 if (*ebuf) /* May return an empty string for digits==0 */
9262 } else if (!digits) {
9265 if ((p = F0convert(nv, ebuf + sizeof ebuf, &l))) {
9266 sv_catpvn(sv, p, l);
9272 #endif /* !USE_LONG_DOUBLE */
9274 if (!args && svix < svmax && DO_UTF8(*svargs))
9277 patend = (char*)pat + patlen;
9278 for (p = (char*)pat; p < patend; p = q) {
9281 bool vectorize = FALSE;
9282 bool vectorarg = FALSE;
9283 bool vec_utf8 = FALSE;
9289 bool has_precis = FALSE;
9291 const I32 osvix = svix;
9292 bool is_utf8 = FALSE; /* is this item utf8? */
9293 #ifdef HAS_LDBL_SPRINTF_BUG
9294 /* This is to try to fix a bug with irix/nonstop-ux/powerux and
9295 with sfio - Allen <allens@cpan.org> */
9296 bool fix_ldbl_sprintf_bug = FALSE;
9300 U8 utf8buf[UTF8_MAXBYTES+1];
9301 STRLEN esignlen = 0;
9303 const char *eptr = NULL;
9304 const char *fmtstart;
9307 const U8 *vecstr = NULL;
9314 /* we need a long double target in case HAS_LONG_DOUBLE but
9317 #if defined(HAS_LONG_DOUBLE) && LONG_DOUBLESIZE > DOUBLESIZE
9325 const char *dotstr = ".";
9326 STRLEN dotstrlen = 1;
9327 I32 efix = 0; /* explicit format parameter index */
9328 I32 ewix = 0; /* explicit width index */
9329 I32 epix = 0; /* explicit precision index */
9330 I32 evix = 0; /* explicit vector index */
9331 bool asterisk = FALSE;
9333 /* echo everything up to the next format specification */
9334 for (q = p; q < patend && *q != '%'; ++q) ;
9336 if (has_utf8 && !pat_utf8)
9337 sv_catpvn_utf8_upgrade(sv, p, q - p, nsv);
9339 sv_catpvn(sv, p, q - p);
9348 We allow format specification elements in this order:
9349 \d+\$ explicit format parameter index
9351 v|\*(\d+\$)?v vector with optional (optionally specified) arg
9352 0 flag (as above): repeated to allow "v02"
9353 \d+|\*(\d+\$)? width using optional (optionally specified) arg
9354 \.(\d*|\*(\d+\$)?) precision using optional (optionally specified) arg
9356 [%bcdefginopsuxDFOUX] format (mandatory)
9361 As of perl5.9.3, printf format checking is on by default.
9362 Internally, perl uses %p formats to provide an escape to
9363 some extended formatting. This block deals with those
9364 extensions: if it does not match, (char*)q is reset and
9365 the normal format processing code is used.
9367 Currently defined extensions are:
9368 %p include pointer address (standard)
9369 %-p (SVf) include an SV (previously %_)
9370 %-<num>p include an SV with precision <num>
9371 %<num>p reserved for future extensions
9373 Robin Barker 2005-07-14
9375 %1p (VDf) removed. RMB 2007-10-19
9382 n = expect_number(&q);
9389 argsv = MUTABLE_SV(va_arg(*args, void*));
9390 eptr = SvPV_const(argsv, elen);
9396 if (ckWARN_d(WARN_INTERNAL))
9397 Perl_warner(aTHX_ packWARN(WARN_INTERNAL),
9398 "internal %%<num>p might conflict with future printf extensions");
9404 if ( (width = expect_number(&q)) ) {
9419 if (plus == '+' && *q == ' ') /* '+' over ' ' */
9448 if ( (ewix = expect_number(&q)) )
9457 if ((vectorarg = asterisk)) {
9470 width = expect_number(&q);
9476 vecsv = va_arg(*args, SV*);
9478 vecsv = (evix > 0 && evix <= svmax)
9479 ? svargs[evix-1] : &PL_sv_undef;
9481 vecsv = svix < svmax ? svargs[svix++] : &PL_sv_undef;
9483 dotstr = SvPV_const(vecsv, dotstrlen);
9484 /* Keep the DO_UTF8 test *after* the SvPV call, else things go
9485 bad with tied or overloaded values that return UTF8. */
9488 else if (has_utf8) {
9489 vecsv = sv_mortalcopy(vecsv);
9490 sv_utf8_upgrade(vecsv);
9491 dotstr = SvPV_const(vecsv, dotstrlen);
9498 else if (efix ? (efix > 0 && efix <= svmax) : svix < svmax) {
9499 vecsv = svargs[efix ? efix-1 : svix++];
9500 vecstr = (U8*)SvPV_const(vecsv,veclen);
9501 vec_utf8 = DO_UTF8(vecsv);
9503 /* if this is a version object, we need to convert
9504 * back into v-string notation and then let the
9505 * vectorize happen normally
9507 if (sv_derived_from(vecsv, "version")) {
9508 char *version = savesvpv(vecsv);
9509 if ( hv_exists(MUTABLE_HV(SvRV(vecsv)), "alpha", 5 ) ) {
9510 Perl_warner(aTHX_ packWARN(WARN_INTERNAL),
9511 "vector argument not supported with alpha versions");
9514 vecsv = sv_newmortal();
9515 scan_vstring(version, version + veclen, vecsv);
9516 vecstr = (U8*)SvPV_const(vecsv, veclen);
9517 vec_utf8 = DO_UTF8(vecsv);
9529 i = va_arg(*args, int);
9531 i = (ewix ? ewix <= svmax : svix < svmax) ?
9532 SvIVx(svargs[ewix ? ewix-1 : svix++]) : 0;
9534 width = (i < 0) ? -i : i;
9544 if ( ((epix = expect_number(&q))) && (*q++ != '$') )
9546 /* XXX: todo, support specified precision parameter */
9550 i = va_arg(*args, int);
9552 i = (ewix ? ewix <= svmax : svix < svmax)
9553 ? SvIVx(svargs[ewix ? ewix-1 : svix++]) : 0;
9555 has_precis = !(i < 0);
9560 precis = precis * 10 + (*q++ - '0');
9569 case 'I': /* Ix, I32x, and I64x */
9571 if (q[1] == '6' && q[2] == '4') {
9577 if (q[1] == '3' && q[2] == '2') {
9587 #if defined(HAS_QUAD) || defined(HAS_LONG_DOUBLE)
9598 #if defined(HAS_QUAD) || defined(HAS_LONG_DOUBLE)
9599 if (*(q + 1) == 'l') { /* lld, llf */
9625 if (!vectorize && !args) {
9627 const I32 i = efix-1;
9628 argsv = (i >= 0 && i < svmax) ? svargs[i] : &PL_sv_undef;
9630 argsv = (svix >= 0 && svix < svmax)
9631 ? svargs[svix++] : &PL_sv_undef;
9642 uv = (args) ? va_arg(*args, int) : SvIV(argsv);
9644 (!UNI_IS_INVARIANT(uv) && SvUTF8(sv)))
9646 eptr = (char*)utf8buf;
9647 elen = uvchr_to_utf8((U8*)eptr, uv) - utf8buf;
9661 eptr = va_arg(*args, char*);
9663 elen = strlen(eptr);
9665 eptr = (char *)nullstr;
9666 elen = sizeof nullstr - 1;
9670 eptr = SvPV_const(argsv, elen);
9671 if (DO_UTF8(argsv)) {
9672 STRLEN old_precis = precis;
9673 if (has_precis && precis < elen) {
9674 STRLEN ulen = sv_len_utf8(argsv);
9675 I32 p = precis > ulen ? ulen : precis;
9676 sv_pos_u2b(argsv, &p, 0); /* sticks at end */
9679 if (width) { /* fudge width (can't fudge elen) */
9680 if (has_precis && precis < elen)
9681 width += precis - old_precis;
9683 width += elen - sv_len_utf8(argsv);
9690 if (has_precis && precis < elen)
9697 if (alt || vectorize)
9699 uv = PTR2UV(args ? va_arg(*args, void*) : argsv);
9720 uv = utf8n_to_uvchr(vecstr, veclen, &ulen,
9729 esignbuf[esignlen++] = plus;
9733 case 'h': iv = (short)va_arg(*args, int); break;
9734 case 'l': iv = va_arg(*args, long); break;
9735 case 'V': iv = va_arg(*args, IV); break;
9736 default: iv = va_arg(*args, int); break;
9739 iv = va_arg(*args, Quad_t); break;
9746 IV tiv = SvIV(argsv); /* work around GCC bug #13488 */
9748 case 'h': iv = (short)tiv; break;
9749 case 'l': iv = (long)tiv; break;
9751 default: iv = tiv; break;
9754 iv = (Quad_t)tiv; break;
9760 if ( !vectorize ) /* we already set uv above */
9765 esignbuf[esignlen++] = plus;
9769 esignbuf[esignlen++] = '-';
9813 uv = utf8n_to_uvchr(vecstr, veclen, &ulen,
9824 case 'h': uv = (unsigned short)va_arg(*args, unsigned); break;
9825 case 'l': uv = va_arg(*args, unsigned long); break;
9826 case 'V': uv = va_arg(*args, UV); break;
9827 default: uv = va_arg(*args, unsigned); break;
9830 uv = va_arg(*args, Uquad_t); break;
9837 UV tuv = SvUV(argsv); /* work around GCC bug #13488 */
9839 case 'h': uv = (unsigned short)tuv; break;
9840 case 'l': uv = (unsigned long)tuv; break;
9842 default: uv = tuv; break;
9845 uv = (Uquad_t)tuv; break;
9854 char *ptr = ebuf + sizeof ebuf;
9855 bool tempalt = uv ? alt : FALSE; /* Vectors can't change alt */
9861 p = (char *)((c == 'X') ? PL_hexdigit + 16 : PL_hexdigit);
9867 esignbuf[esignlen++] = '0';
9868 esignbuf[esignlen++] = c; /* 'x' or 'X' */
9876 if (alt && *ptr != '0')
9885 esignbuf[esignlen++] = '0';
9886 esignbuf[esignlen++] = c;
9889 default: /* it had better be ten or less */
9893 } while (uv /= base);
9896 elen = (ebuf + sizeof ebuf) - ptr;
9900 zeros = precis - elen;
9901 else if (precis == 0 && elen == 1 && *eptr == '0'
9902 && !(base == 8 && alt)) /* "%#.0o" prints "0" */
9905 /* a precision nullifies the 0 flag. */
9912 /* FLOATING POINT */
9915 c = 'f'; /* maybe %F isn't supported here */
9923 /* This is evil, but floating point is even more evil */
9925 /* for SV-style calling, we can only get NV
9926 for C-style calling, we assume %f is double;
9927 for simplicity we allow any of %Lf, %llf, %qf for long double
9931 #if defined(USE_LONG_DOUBLE)
9935 /* [perl #20339] - we should accept and ignore %lf rather than die */
9939 #if defined(USE_LONG_DOUBLE)
9940 intsize = args ? 0 : 'q';
9944 #if defined(HAS_LONG_DOUBLE)
9953 /* now we need (long double) if intsize == 'q', else (double) */
9955 #if LONG_DOUBLESIZE > DOUBLESIZE
9957 va_arg(*args, long double) :
9958 va_arg(*args, double)
9960 va_arg(*args, double)
9965 /* nv * 0 will be NaN for NaN, +Inf and -Inf, and 0 for anything
9966 else. frexp() has some unspecified behaviour for those three */
9967 if (c != 'e' && c != 'E' && (nv * 0) == 0) {
9969 /* FIXME: if HAS_LONG_DOUBLE but not USE_LONG_DOUBLE this
9970 will cast our (long double) to (double) */
9971 (void)Perl_frexp(nv, &i);
9972 if (i == PERL_INT_MIN)
9973 Perl_die(aTHX_ "panic: frexp");
9975 need = BIT_DIGITS(i);
9977 need += has_precis ? precis : 6; /* known default */
9982 #ifdef HAS_LDBL_SPRINTF_BUG
9983 /* This is to try to fix a bug with irix/nonstop-ux/powerux and
9984 with sfio - Allen <allens@cpan.org> */
9987 # define MY_DBL_MAX DBL_MAX
9988 # else /* XXX guessing! HUGE_VAL may be defined as infinity, so not using */
9989 # if DOUBLESIZE >= 8
9990 # define MY_DBL_MAX 1.7976931348623157E+308L
9992 # define MY_DBL_MAX 3.40282347E+38L
9996 # ifdef HAS_LDBL_SPRINTF_BUG_LESS1 /* only between -1L & 1L - Allen */
9997 # define MY_DBL_MAX_BUG 1L
9999 # define MY_DBL_MAX_BUG MY_DBL_MAX
10003 # define MY_DBL_MIN DBL_MIN
10004 # else /* XXX guessing! -Allen */
10005 # if DOUBLESIZE >= 8
10006 # define MY_DBL_MIN 2.2250738585072014E-308L
10008 # define MY_DBL_MIN 1.17549435E-38L
10012 if ((intsize == 'q') && (c == 'f') &&
10013 ((nv < MY_DBL_MAX_BUG) && (nv > -MY_DBL_MAX_BUG)) &&
10014 (need < DBL_DIG)) {
10015 /* it's going to be short enough that
10016 * long double precision is not needed */
10018 if ((nv <= 0L) && (nv >= -0L))
10019 fix_ldbl_sprintf_bug = TRUE; /* 0 is 0 - easiest */
10021 /* would use Perl_fp_class as a double-check but not
10022 * functional on IRIX - see perl.h comments */
10024 if ((nv >= MY_DBL_MIN) || (nv <= -MY_DBL_MIN)) {
10025 /* It's within the range that a double can represent */
10026 #if defined(DBL_MAX) && !defined(DBL_MIN)
10027 if ((nv >= ((long double)1/DBL_MAX)) ||
10028 (nv <= (-(long double)1/DBL_MAX)))
10030 fix_ldbl_sprintf_bug = TRUE;
10033 if (fix_ldbl_sprintf_bug == TRUE) {
10043 # undef MY_DBL_MAX_BUG
10046 #endif /* HAS_LDBL_SPRINTF_BUG */
10048 need += 20; /* fudge factor */
10049 if (PL_efloatsize < need) {
10050 Safefree(PL_efloatbuf);
10051 PL_efloatsize = need + 20; /* more fudge */
10052 Newx(PL_efloatbuf, PL_efloatsize, char);
10053 PL_efloatbuf[0] = '\0';
10056 if ( !(width || left || plus || alt) && fill != '0'
10057 && has_precis && intsize != 'q' ) { /* Shortcuts */
10058 /* See earlier comment about buggy Gconvert when digits,
10060 if ( c == 'g' && precis) {
10061 Gconvert((NV)nv, (int)precis, 0, PL_efloatbuf);
10062 /* May return an empty string for digits==0 */
10063 if (*PL_efloatbuf) {
10064 elen = strlen(PL_efloatbuf);
10065 goto float_converted;
10067 } else if ( c == 'f' && !precis) {
10068 if ((eptr = F0convert(nv, ebuf + sizeof ebuf, &elen)))
10073 char *ptr = ebuf + sizeof ebuf;
10076 /* FIXME: what to do if HAS_LONG_DOUBLE but not PERL_PRIfldbl? */
10077 #if defined(HAS_LONG_DOUBLE) && defined(PERL_PRIfldbl)
10078 if (intsize == 'q') {
10079 /* Copy the one or more characters in a long double
10080 * format before the 'base' ([efgEFG]) character to
10081 * the format string. */
10082 static char const prifldbl[] = PERL_PRIfldbl;
10083 char const *p = prifldbl + sizeof(prifldbl) - 3;
10084 while (p >= prifldbl) { *--ptr = *p--; }
10089 do { *--ptr = '0' + (base % 10); } while (base /= 10);
10094 do { *--ptr = '0' + (base % 10); } while (base /= 10);
10106 /* No taint. Otherwise we are in the strange situation
10107 * where printf() taints but print($float) doesn't.
10109 #if defined(HAS_LONG_DOUBLE)
10110 elen = ((intsize == 'q')
10111 ? my_snprintf(PL_efloatbuf, PL_efloatsize, ptr, nv)
10112 : my_snprintf(PL_efloatbuf, PL_efloatsize, ptr, (double)nv));
10114 elen = my_sprintf(PL_efloatbuf, ptr, nv);
10118 eptr = PL_efloatbuf;
10126 i = SvCUR(sv) - origlen;
10129 case 'h': *(va_arg(*args, short*)) = i; break;
10130 default: *(va_arg(*args, int*)) = i; break;
10131 case 'l': *(va_arg(*args, long*)) = i; break;
10132 case 'V': *(va_arg(*args, IV*)) = i; break;
10135 *(va_arg(*args, Quad_t*)) = i; break;
10142 sv_setuv_mg(argsv, (UV)i);
10143 continue; /* not "break" */
10150 && (PL_op->op_type == OP_PRTF || PL_op->op_type == OP_SPRINTF)
10151 && ckWARN(WARN_PRINTF))
10153 SV * const msg = sv_newmortal();
10154 Perl_sv_setpvf(aTHX_ msg, "Invalid conversion in %sprintf: ",
10155 (PL_op->op_type == OP_PRTF) ? "" : "s");
10156 if (fmtstart < patend) {
10157 const char * const fmtend = q < patend ? q : patend;
10159 sv_catpvs(msg, "\"%");
10160 for (f = fmtstart; f < fmtend; f++) {
10162 sv_catpvn(msg, f, 1);
10164 Perl_sv_catpvf(aTHX_ msg,
10165 "\\%03"UVof, (UV)*f & 0xFF);
10168 sv_catpvs(msg, "\"");
10170 sv_catpvs(msg, "end of string");
10172 Perl_warner(aTHX_ packWARN(WARN_PRINTF), "%"SVf, SVfARG(msg)); /* yes, this is reentrant */
10175 /* output mangled stuff ... */
10181 /* ... right here, because formatting flags should not apply */
10182 SvGROW(sv, SvCUR(sv) + elen + 1);
10184 Copy(eptr, p, elen, char);
10187 SvCUR_set(sv, p - SvPVX_const(sv));
10189 continue; /* not "break" */
10192 if (is_utf8 != has_utf8) {
10195 sv_utf8_upgrade(sv);
10198 const STRLEN old_elen = elen;
10199 SV * const nsv = newSVpvn_flags(eptr, elen, SVs_TEMP);
10200 sv_utf8_upgrade(nsv);
10201 eptr = SvPVX_const(nsv);
10204 if (width) { /* fudge width (can't fudge elen) */
10205 width += elen - old_elen;
10211 have = esignlen + zeros + elen;
10213 Perl_croak_nocontext("%s", PL_memory_wrap);
10215 need = (have > width ? have : width);
10218 if (need >= (((STRLEN)~0) - SvCUR(sv) - dotstrlen - 1))
10219 Perl_croak_nocontext("%s", PL_memory_wrap);
10220 SvGROW(sv, SvCUR(sv) + need + dotstrlen + 1);
10222 if (esignlen && fill == '0') {
10224 for (i = 0; i < (int)esignlen; i++)
10225 *p++ = esignbuf[i];
10227 if (gap && !left) {
10228 memset(p, fill, gap);
10231 if (esignlen && fill != '0') {
10233 for (i = 0; i < (int)esignlen; i++)
10234 *p++ = esignbuf[i];
10238 for (i = zeros; i; i--)
10242 Copy(eptr, p, elen, char);
10246 memset(p, ' ', gap);
10251 Copy(dotstr, p, dotstrlen, char);
10255 vectorize = FALSE; /* done iterating over vecstr */
10262 SvCUR_set(sv, p - SvPVX_const(sv));
10270 /* =========================================================================
10272 =head1 Cloning an interpreter
10274 All the macros and functions in this section are for the private use of
10275 the main function, perl_clone().
10277 The foo_dup() functions make an exact copy of an existing foo thingy.
10278 During the course of a cloning, a hash table is used to map old addresses
10279 to new addresses. The table is created and manipulated with the
10280 ptr_table_* functions.
10284 * =========================================================================*/
10287 #if defined(USE_ITHREADS)
10289 /* XXX Remove this so it doesn't have to go thru the macro and return for nothing */
10290 #ifndef GpREFCNT_inc
10291 # define GpREFCNT_inc(gp) ((gp) ? (++(gp)->gp_refcnt, (gp)) : (GP*)NULL)
10295 /* Certain cases in Perl_ss_dup have been merged, by relying on the fact
10296 that currently av_dup, gv_dup and hv_dup are the same as sv_dup.
10297 If this changes, please unmerge ss_dup.
10298 Likewise, sv_dup_inc_multiple() relies on this fact. */
10299 #define sv_dup_inc(s,t) SvREFCNT_inc(sv_dup(s,t))
10300 #define sv_dup_inc_NN(s,t) SvREFCNT_inc_NN(sv_dup(s,t))
10301 #define av_dup(s,t) MUTABLE_AV(sv_dup((const SV *)s,t))
10302 #define av_dup_inc(s,t) MUTABLE_AV(SvREFCNT_inc(sv_dup((const SV *)s,t)))
10303 #define hv_dup(s,t) MUTABLE_HV(sv_dup((const SV *)s,t))
10304 #define hv_dup_inc(s,t) MUTABLE_HV(SvREFCNT_inc(sv_dup((const SV *)s,t)))
10305 #define cv_dup(s,t) MUTABLE_CV(sv_dup((const SV *)s,t))
10306 #define cv_dup_inc(s,t) MUTABLE_CV(SvREFCNT_inc(sv_dup((const SV *)s,t)))
10307 #define io_dup(s,t) MUTABLE_IO(sv_dup((const SV *)s,t))
10308 #define io_dup_inc(s,t) MUTABLE_IO(SvREFCNT_inc(sv_dup((const SV *)s,t)))
10309 #define gv_dup(s,t) MUTABLE_GV(sv_dup((const SV *)s,t))
10310 #define gv_dup_inc(s,t) MUTABLE_GV(SvREFCNT_inc(sv_dup((const SV *)s,t)))
10311 #define SAVEPV(p) ((p) ? savepv(p) : NULL)
10312 #define SAVEPVN(p,n) ((p) ? savepvn(p,n) : NULL)
10314 /* clone a parser */
10317 Perl_parser_dup(pTHX_ const yy_parser *const proto, CLONE_PARAMS *const param)
10321 PERL_ARGS_ASSERT_PARSER_DUP;
10326 /* look for it in the table first */
10327 parser = (yy_parser *)ptr_table_fetch(PL_ptr_table, proto);
10331 /* create anew and remember what it is */
10332 Newxz(parser, 1, yy_parser);
10333 ptr_table_store(PL_ptr_table, proto, parser);
10335 parser->yyerrstatus = 0;
10336 parser->yychar = YYEMPTY; /* Cause a token to be read. */
10338 /* XXX these not yet duped */
10339 parser->old_parser = NULL;
10340 parser->stack = NULL;
10342 parser->stack_size = 0;
10343 /* XXX parser->stack->state = 0; */
10345 /* XXX eventually, just Copy() most of the parser struct ? */
10347 parser->lex_brackets = proto->lex_brackets;
10348 parser->lex_casemods = proto->lex_casemods;
10349 parser->lex_brackstack = savepvn(proto->lex_brackstack,
10350 (proto->lex_brackets < 120 ? 120 : proto->lex_brackets));
10351 parser->lex_casestack = savepvn(proto->lex_casestack,
10352 (proto->lex_casemods < 12 ? 12 : proto->lex_casemods));
10353 parser->lex_defer = proto->lex_defer;
10354 parser->lex_dojoin = proto->lex_dojoin;
10355 parser->lex_expect = proto->lex_expect;
10356 parser->lex_formbrack = proto->lex_formbrack;
10357 parser->lex_inpat = proto->lex_inpat;
10358 parser->lex_inwhat = proto->lex_inwhat;
10359 parser->lex_op = proto->lex_op;
10360 parser->lex_repl = sv_dup_inc(proto->lex_repl, param);
10361 parser->lex_starts = proto->lex_starts;
10362 parser->lex_stuff = sv_dup_inc(proto->lex_stuff, param);
10363 parser->multi_close = proto->multi_close;
10364 parser->multi_open = proto->multi_open;
10365 parser->multi_start = proto->multi_start;
10366 parser->multi_end = proto->multi_end;
10367 parser->pending_ident = proto->pending_ident;
10368 parser->preambled = proto->preambled;
10369 parser->sublex_info = proto->sublex_info; /* XXX not quite right */
10370 parser->linestr = sv_dup_inc(proto->linestr, param);
10371 parser->expect = proto->expect;
10372 parser->copline = proto->copline;
10373 parser->last_lop_op = proto->last_lop_op;
10374 parser->lex_state = proto->lex_state;
10375 parser->rsfp = fp_dup(proto->rsfp, '<', param);
10376 /* rsfp_filters entries have fake IoDIRP() */
10377 parser->rsfp_filters= av_dup_inc(proto->rsfp_filters, param);
10378 parser->in_my = proto->in_my;
10379 parser->in_my_stash = hv_dup(proto->in_my_stash, param);
10380 parser->error_count = proto->error_count;
10383 parser->linestr = sv_dup_inc(proto->linestr, param);
10386 char * const ols = SvPVX(proto->linestr);
10387 char * const ls = SvPVX(parser->linestr);
10389 parser->bufptr = ls + (proto->bufptr >= ols ?
10390 proto->bufptr - ols : 0);
10391 parser->oldbufptr = ls + (proto->oldbufptr >= ols ?
10392 proto->oldbufptr - ols : 0);
10393 parser->oldoldbufptr= ls + (proto->oldoldbufptr >= ols ?
10394 proto->oldoldbufptr - ols : 0);
10395 parser->linestart = ls + (proto->linestart >= ols ?
10396 proto->linestart - ols : 0);
10397 parser->last_uni = ls + (proto->last_uni >= ols ?
10398 proto->last_uni - ols : 0);
10399 parser->last_lop = ls + (proto->last_lop >= ols ?
10400 proto->last_lop - ols : 0);
10402 parser->bufend = ls + SvCUR(parser->linestr);
10405 Copy(proto->tokenbuf, parser->tokenbuf, 256, char);
10409 parser->endwhite = proto->endwhite;
10410 parser->faketokens = proto->faketokens;
10411 parser->lasttoke = proto->lasttoke;
10412 parser->nextwhite = proto->nextwhite;
10413 parser->realtokenstart = proto->realtokenstart;
10414 parser->skipwhite = proto->skipwhite;
10415 parser->thisclose = proto->thisclose;
10416 parser->thismad = proto->thismad;
10417 parser->thisopen = proto->thisopen;
10418 parser->thisstuff = proto->thisstuff;
10419 parser->thistoken = proto->thistoken;
10420 parser->thiswhite = proto->thiswhite;
10422 Copy(proto->nexttoke, parser->nexttoke, 5, NEXTTOKE);
10423 parser->curforce = proto->curforce;
10425 Copy(proto->nextval, parser->nextval, 5, YYSTYPE);
10426 Copy(proto->nexttype, parser->nexttype, 5, I32);
10427 parser->nexttoke = proto->nexttoke;
10433 /* duplicate a file handle */
10436 Perl_fp_dup(pTHX_ PerlIO *const fp, const char type, CLONE_PARAMS *const param)
10440 PERL_ARGS_ASSERT_FP_DUP;
10441 PERL_UNUSED_ARG(type);
10444 return (PerlIO*)NULL;
10446 /* look for it in the table first */
10447 ret = (PerlIO*)ptr_table_fetch(PL_ptr_table, fp);
10451 /* create anew and remember what it is */
10452 ret = PerlIO_fdupopen(aTHX_ fp, param, PERLIO_DUP_CLONE);
10453 ptr_table_store(PL_ptr_table, fp, ret);
10457 /* duplicate a directory handle */
10460 Perl_dirp_dup(pTHX_ DIR *const dp)
10462 PERL_UNUSED_CONTEXT;
10469 /* duplicate a typeglob */
10472 Perl_gp_dup(pTHX_ GP *const gp, CLONE_PARAMS *const param)
10476 PERL_ARGS_ASSERT_GP_DUP;
10480 /* look for it in the table first */
10481 ret = (GP*)ptr_table_fetch(PL_ptr_table, gp);
10485 /* create anew and remember what it is */
10487 ptr_table_store(PL_ptr_table, gp, ret);
10490 /* ret->gp_refcnt must be 0 before any other dups are called. We're relying
10491 on Newxz() to do this for us. */
10492 ret->gp_sv = sv_dup_inc(gp->gp_sv, param);
10493 ret->gp_io = io_dup_inc(gp->gp_io, param);
10494 ret->gp_form = cv_dup_inc(gp->gp_form, param);
10495 ret->gp_av = av_dup_inc(gp->gp_av, param);
10496 ret->gp_hv = hv_dup_inc(gp->gp_hv, param);
10497 ret->gp_egv = gv_dup(gp->gp_egv, param);/* GvEGV is not refcounted */
10498 ret->gp_cv = cv_dup_inc(gp->gp_cv, param);
10499 ret->gp_cvgen = gp->gp_cvgen;
10500 ret->gp_line = gp->gp_line;
10501 ret->gp_file_hek = hek_dup(gp->gp_file_hek, param);
10505 /* duplicate a chain of magic */
10508 Perl_mg_dup(pTHX_ MAGIC *mg, CLONE_PARAMS *const param)
10510 MAGIC *mgret = NULL;
10511 MAGIC **mgprev_p = &mgret;
10513 PERL_ARGS_ASSERT_MG_DUP;
10515 for (; mg; mg = mg->mg_moremagic) {
10517 Newx(nmg, 1, MAGIC);
10519 mgprev_p = &(nmg->mg_moremagic);
10521 /* There was a comment "XXX copy dynamic vtable?" but as we don't have
10522 dynamic vtables, I'm not sure why Sarathy wrote it. The comment dates
10523 from the original commit adding Perl_mg_dup() - revision 4538.
10524 Similarly there is the annotation "XXX random ptr?" next to the
10525 assignment to nmg->mg_ptr. */
10528 /* FIXME for plugins
10529 if (nmg->mg_type == PERL_MAGIC_qr) {
10530 nmg->mg_obj = MUTABLE_SV(CALLREGDUPE((REGEXP*)nmg->mg_obj, param));
10534 if(nmg->mg_type == PERL_MAGIC_backref) {
10535 /* The backref AV has its reference count deliberately bumped by
10538 = SvREFCNT_inc(av_dup_inc((const AV *) nmg->mg_obj, param));
10541 nmg->mg_obj = (nmg->mg_flags & MGf_REFCOUNTED)
10542 ? sv_dup_inc(nmg->mg_obj, param)
10543 : sv_dup(nmg->mg_obj, param);
10546 if (nmg->mg_ptr && nmg->mg_type != PERL_MAGIC_regex_global) {
10547 if (nmg->mg_len > 0) {
10548 nmg->mg_ptr = SAVEPVN(nmg->mg_ptr, nmg->mg_len);
10549 if (nmg->mg_type == PERL_MAGIC_overload_table &&
10550 AMT_AMAGIC((AMT*)nmg->mg_ptr))
10552 AMT * const namtp = (AMT*)nmg->mg_ptr;
10553 sv_dup_inc_multiple((SV**)(namtp->table),
10554 (SV**)(namtp->table), NofAMmeth, param);
10557 else if (nmg->mg_len == HEf_SVKEY)
10558 nmg->mg_ptr = (char*)sv_dup_inc((const SV *)nmg->mg_ptr, param);
10560 if ((nmg->mg_flags & MGf_DUP) && nmg->mg_virtual && nmg->mg_virtual->svt_dup) {
10561 CALL_FPTR(nmg->mg_virtual->svt_dup)(aTHX_ nmg, param);
10567 #endif /* USE_ITHREADS */
10569 /* create a new pointer-mapping table */
10572 Perl_ptr_table_new(pTHX)
10575 PERL_UNUSED_CONTEXT;
10577 Newx(tbl, 1, PTR_TBL_t);
10578 tbl->tbl_max = 511;
10579 tbl->tbl_items = 0;
10580 Newxz(tbl->tbl_ary, tbl->tbl_max + 1, PTR_TBL_ENT_t*);
10584 #define PTR_TABLE_HASH(ptr) \
10585 ((PTR2UV(ptr) >> 3) ^ (PTR2UV(ptr) >> (3 + 7)) ^ (PTR2UV(ptr) >> (3 + 17)))
10588 we use the PTE_SVSLOT 'reservation' made above, both here (in the
10589 following define) and at call to new_body_inline made below in
10590 Perl_ptr_table_store()
10593 #define del_pte(p) del_body_type(p, PTE_SVSLOT)
10595 /* map an existing pointer using a table */
10597 STATIC PTR_TBL_ENT_t *
10598 S_ptr_table_find(PTR_TBL_t *const tbl, const void *const sv)
10600 PTR_TBL_ENT_t *tblent;
10601 const UV hash = PTR_TABLE_HASH(sv);
10603 PERL_ARGS_ASSERT_PTR_TABLE_FIND;
10605 tblent = tbl->tbl_ary[hash & tbl->tbl_max];
10606 for (; tblent; tblent = tblent->next) {
10607 if (tblent->oldval == sv)
10614 Perl_ptr_table_fetch(pTHX_ PTR_TBL_t *const tbl, const void *const sv)
10616 PTR_TBL_ENT_t const *const tblent = ptr_table_find(tbl, sv);
10618 PERL_ARGS_ASSERT_PTR_TABLE_FETCH;
10619 PERL_UNUSED_CONTEXT;
10621 return tblent ? tblent->newval : NULL;
10624 /* add a new entry to a pointer-mapping table */
10627 Perl_ptr_table_store(pTHX_ PTR_TBL_t *const tbl, const void *const oldsv, void *const newsv)
10629 PTR_TBL_ENT_t *tblent = ptr_table_find(tbl, oldsv);
10631 PERL_ARGS_ASSERT_PTR_TABLE_STORE;
10632 PERL_UNUSED_CONTEXT;
10635 tblent->newval = newsv;
10637 const UV entry = PTR_TABLE_HASH(oldsv) & tbl->tbl_max;
10639 new_body_inline(tblent, PTE_SVSLOT);
10641 tblent->oldval = oldsv;
10642 tblent->newval = newsv;
10643 tblent->next = tbl->tbl_ary[entry];
10644 tbl->tbl_ary[entry] = tblent;
10646 if (tblent->next && tbl->tbl_items > tbl->tbl_max)
10647 ptr_table_split(tbl);
10651 /* double the hash bucket size of an existing ptr table */
10654 Perl_ptr_table_split(pTHX_ PTR_TBL_t *const tbl)
10656 PTR_TBL_ENT_t **ary = tbl->tbl_ary;
10657 const UV oldsize = tbl->tbl_max + 1;
10658 UV newsize = oldsize * 2;
10661 PERL_ARGS_ASSERT_PTR_TABLE_SPLIT;
10662 PERL_UNUSED_CONTEXT;
10664 Renew(ary, newsize, PTR_TBL_ENT_t*);
10665 Zero(&ary[oldsize], newsize-oldsize, PTR_TBL_ENT_t*);
10666 tbl->tbl_max = --newsize;
10667 tbl->tbl_ary = ary;
10668 for (i=0; i < oldsize; i++, ary++) {
10669 PTR_TBL_ENT_t **curentp, **entp, *ent;
10672 curentp = ary + oldsize;
10673 for (entp = ary, ent = *ary; ent; ent = *entp) {
10674 if ((newsize & PTR_TABLE_HASH(ent->oldval)) != i) {
10676 ent->next = *curentp;
10686 /* remove all the entries from a ptr table */
10689 Perl_ptr_table_clear(pTHX_ PTR_TBL_t *const tbl)
10691 if (tbl && tbl->tbl_items) {
10692 register PTR_TBL_ENT_t * const * const array = tbl->tbl_ary;
10693 UV riter = tbl->tbl_max;
10696 PTR_TBL_ENT_t *entry = array[riter];
10699 PTR_TBL_ENT_t * const oentry = entry;
10700 entry = entry->next;
10705 tbl->tbl_items = 0;
10709 /* clear and free a ptr table */
10712 Perl_ptr_table_free(pTHX_ PTR_TBL_t *const tbl)
10717 ptr_table_clear(tbl);
10718 Safefree(tbl->tbl_ary);
10722 #if defined(USE_ITHREADS)
10725 Perl_rvpv_dup(pTHX_ SV *const dstr, const SV *const sstr, CLONE_PARAMS *const param)
10727 PERL_ARGS_ASSERT_RVPV_DUP;
10730 SvRV_set(dstr, SvWEAKREF(sstr)
10731 ? sv_dup(SvRV_const(sstr), param)
10732 : sv_dup_inc(SvRV_const(sstr), param));
10735 else if (SvPVX_const(sstr)) {
10736 /* Has something there */
10738 /* Normal PV - clone whole allocated space */
10739 SvPV_set(dstr, SAVEPVN(SvPVX_const(sstr), SvLEN(sstr)-1));
10740 if (SvREADONLY(sstr) && SvFAKE(sstr)) {
10741 /* Not that normal - actually sstr is copy on write.
10742 But we are a true, independant SV, so: */
10743 SvREADONLY_off(dstr);
10748 /* Special case - not normally malloced for some reason */
10749 if (isGV_with_GP(sstr)) {
10750 /* Don't need to do anything here. */
10752 else if ((SvREADONLY(sstr) && SvFAKE(sstr))) {
10753 /* A "shared" PV - clone it as "shared" PV */
10755 HEK_KEY(hek_dup(SvSHARED_HEK_FROM_PV(SvPVX_const(sstr)),
10759 /* Some other special case - random pointer */
10760 SvPV_set(dstr, (char *) SvPVX_const(sstr));
10765 /* Copy the NULL */
10766 SvPV_set(dstr, NULL);
10770 /* duplicate a list of SVs. source and dest may point to the same memory. */
10772 S_sv_dup_inc_multiple(pTHX_ SV *const *source, SV **dest,
10773 SSize_t items, CLONE_PARAMS *const param)
10775 PERL_ARGS_ASSERT_SV_DUP_INC_MULTIPLE;
10777 while (items-- > 0) {
10778 *dest++ = sv_dup_inc(*source++, param);
10784 /* duplicate an SV of any type (including AV, HV etc) */
10787 Perl_sv_dup(pTHX_ const SV *const sstr, CLONE_PARAMS *const param)
10792 PERL_ARGS_ASSERT_SV_DUP;
10796 if (SvTYPE(sstr) == SVTYPEMASK) {
10797 #ifdef DEBUG_LEAKING_SCALARS_ABORT
10802 /* look for it in the table first */
10803 dstr = MUTABLE_SV(ptr_table_fetch(PL_ptr_table, sstr));
10807 if(param->flags & CLONEf_JOIN_IN) {
10808 /** We are joining here so we don't want do clone
10809 something that is bad **/
10810 if (SvTYPE(sstr) == SVt_PVHV) {
10811 const HEK * const hvname = HvNAME_HEK(sstr);
10813 /** don't clone stashes if they already exist **/
10814 return MUTABLE_SV(gv_stashpvn(HEK_KEY(hvname), HEK_LEN(hvname), 0));
10818 /* create anew and remember what it is */
10821 #ifdef DEBUG_LEAKING_SCALARS
10822 dstr->sv_debug_optype = sstr->sv_debug_optype;
10823 dstr->sv_debug_line = sstr->sv_debug_line;
10824 dstr->sv_debug_inpad = sstr->sv_debug_inpad;
10825 dstr->sv_debug_cloned = 1;
10826 dstr->sv_debug_file = savepv(sstr->sv_debug_file);
10829 ptr_table_store(PL_ptr_table, sstr, dstr);
10832 SvFLAGS(dstr) = SvFLAGS(sstr);
10833 SvFLAGS(dstr) &= ~SVf_OOK; /* don't propagate OOK hack */
10834 SvREFCNT(dstr) = 0; /* must be before any other dups! */
10837 if (SvANY(sstr) && PL_watch_pvx && SvPVX_const(sstr) == PL_watch_pvx)
10838 PerlIO_printf(Perl_debug_log, "watch at %p hit, found string \"%s\"\n",
10839 (void*)PL_watch_pvx, SvPVX_const(sstr));
10842 /* don't clone objects whose class has asked us not to */
10843 if (SvOBJECT(sstr) && ! (SvFLAGS(SvSTASH(sstr)) & SVphv_CLONEABLE)) {
10848 switch (SvTYPE(sstr)) {
10850 SvANY(dstr) = NULL;
10853 SvANY(dstr) = (XPVIV*)((char*)&(dstr->sv_u.svu_iv) - STRUCT_OFFSET(XPVIV, xiv_iv));
10855 Perl_rvpv_dup(aTHX_ dstr, sstr, param);
10857 SvIV_set(dstr, SvIVX(sstr));
10861 SvANY(dstr) = new_XNV();
10862 SvNV_set(dstr, SvNVX(sstr));
10864 /* case SVt_BIND: */
10867 /* These are all the types that need complex bodies allocating. */
10869 const svtype sv_type = SvTYPE(sstr);
10870 const struct body_details *const sv_type_details
10871 = bodies_by_type + sv_type;
10875 Perl_croak(aTHX_ "Bizarre SvTYPE [%" IVdf "]", (IV)SvTYPE(sstr));
10890 assert(sv_type_details->body_size);
10891 if (sv_type_details->arena) {
10892 new_body_inline(new_body, sv_type);
10894 = (void*)((char*)new_body - sv_type_details->offset);
10896 new_body = new_NOARENA(sv_type_details);
10900 SvANY(dstr) = new_body;
10903 Copy(((char*)SvANY(sstr)) + sv_type_details->offset,
10904 ((char*)SvANY(dstr)) + sv_type_details->offset,
10905 sv_type_details->copy, char);
10907 Copy(((char*)SvANY(sstr)),
10908 ((char*)SvANY(dstr)),
10909 sv_type_details->body_size + sv_type_details->offset, char);
10912 if (sv_type != SVt_PVAV && sv_type != SVt_PVHV
10913 && !isGV_with_GP(dstr))
10914 Perl_rvpv_dup(aTHX_ dstr, sstr, param);
10916 /* The Copy above means that all the source (unduplicated) pointers
10917 are now in the destination. We can check the flags and the
10918 pointers in either, but it's possible that there's less cache
10919 missing by always going for the destination.
10920 FIXME - instrument and check that assumption */
10921 if (sv_type >= SVt_PVMG) {
10922 if ((sv_type == SVt_PVMG) && SvPAD_OUR(dstr)) {
10923 SvOURSTASH_set(dstr, hv_dup_inc(SvOURSTASH(dstr), param));
10924 } else if (SvMAGIC(dstr))
10925 SvMAGIC_set(dstr, mg_dup(SvMAGIC(dstr), param));
10927 SvSTASH_set(dstr, hv_dup_inc(SvSTASH(dstr), param));
10930 /* The cast silences a GCC warning about unhandled types. */
10931 switch ((int)sv_type) {
10941 /* FIXME for plugins */
10942 re_dup_guts((REGEXP*) sstr, (REGEXP*) dstr, param);
10945 /* XXX LvTARGOFF sometimes holds PMOP* when DEBUGGING */
10946 if (LvTYPE(dstr) == 't') /* for tie: unrefcnted fake (SV**) */
10947 LvTARG(dstr) = dstr;
10948 else if (LvTYPE(dstr) == 'T') /* for tie: fake HE */
10949 LvTARG(dstr) = MUTABLE_SV(he_dup((HE*)LvTARG(dstr), 0, param));
10951 LvTARG(dstr) = sv_dup_inc(LvTARG(dstr), param);
10953 if(isGV_with_GP(sstr)) {
10954 GvNAME_HEK(dstr) = hek_dup(GvNAME_HEK(dstr), param);
10955 /* Don't call sv_add_backref here as it's going to be
10956 created as part of the magic cloning of the symbol
10958 /* Danger Will Robinson - GvGP(dstr) isn't initialised
10959 at the point of this comment. */
10960 GvSTASH(dstr) = hv_dup(GvSTASH(dstr), param);
10961 GvGP(dstr) = gp_dup(GvGP(sstr), param);
10962 (void)GpREFCNT_inc(GvGP(dstr));
10964 Perl_rvpv_dup(aTHX_ dstr, sstr, param);
10967 IoIFP(dstr) = fp_dup(IoIFP(dstr), IoTYPE(dstr), param);
10968 if (IoOFP(dstr) == IoIFP(sstr))
10969 IoOFP(dstr) = IoIFP(dstr);
10971 IoOFP(dstr) = fp_dup(IoOFP(dstr), IoTYPE(dstr), param);
10972 /* PL_parser->rsfp_filters entries have fake IoDIRP() */
10973 if(IoFLAGS(dstr) & IOf_FAKE_DIRP) {
10974 /* I have no idea why fake dirp (rsfps)
10975 should be treated differently but otherwise
10976 we end up with leaks -- sky*/
10977 IoTOP_GV(dstr) = gv_dup_inc(IoTOP_GV(dstr), param);
10978 IoFMT_GV(dstr) = gv_dup_inc(IoFMT_GV(dstr), param);
10979 IoBOTTOM_GV(dstr) = gv_dup_inc(IoBOTTOM_GV(dstr), param);
10981 IoTOP_GV(dstr) = gv_dup(IoTOP_GV(dstr), param);
10982 IoFMT_GV(dstr) = gv_dup(IoFMT_GV(dstr), param);
10983 IoBOTTOM_GV(dstr) = gv_dup(IoBOTTOM_GV(dstr), param);
10984 if (IoDIRP(dstr)) {
10985 IoDIRP(dstr) = dirp_dup(IoDIRP(dstr));
10988 /* IoDIRP(dstr) is already a copy of IoDIRP(sstr) */
10991 IoTOP_NAME(dstr) = SAVEPV(IoTOP_NAME(dstr));
10992 IoFMT_NAME(dstr) = SAVEPV(IoFMT_NAME(dstr));
10993 IoBOTTOM_NAME(dstr) = SAVEPV(IoBOTTOM_NAME(dstr));
10996 /* avoid cloning an empty array */
10997 if (AvARRAY((const AV *)sstr) && AvFILLp((const AV *)sstr) >= 0) {
10998 SV **dst_ary, **src_ary;
10999 SSize_t items = AvFILLp((const AV *)sstr) + 1;
11001 src_ary = AvARRAY((const AV *)sstr);
11002 Newxz(dst_ary, AvMAX((const AV *)sstr)+1, SV*);
11003 ptr_table_store(PL_ptr_table, src_ary, dst_ary);
11004 AvARRAY(MUTABLE_AV(dstr)) = dst_ary;
11005 AvALLOC((const AV *)dstr) = dst_ary;
11006 if (AvREAL((const AV *)sstr)) {
11007 dst_ary = sv_dup_inc_multiple(src_ary, dst_ary, items,
11011 while (items-- > 0)
11012 *dst_ary++ = sv_dup(*src_ary++, param);
11014 items = AvMAX((const AV *)sstr) - AvFILLp((const AV *)sstr);
11015 while (items-- > 0) {
11016 *dst_ary++ = &PL_sv_undef;
11020 AvARRAY(MUTABLE_AV(dstr)) = NULL;
11021 AvALLOC((const AV *)dstr) = (SV**)NULL;
11022 AvMAX( (const AV *)dstr) = -1;
11023 AvFILLp((const AV *)dstr) = -1;
11027 if (HvARRAY((const HV *)sstr)) {
11029 const bool sharekeys = !!HvSHAREKEYS(sstr);
11030 XPVHV * const dxhv = (XPVHV*)SvANY(dstr);
11031 XPVHV * const sxhv = (XPVHV*)SvANY(sstr);
11033 Newx(darray, PERL_HV_ARRAY_ALLOC_BYTES(dxhv->xhv_max+1)
11034 + (SvOOK(sstr) ? sizeof(struct xpvhv_aux) : 0),
11036 HvARRAY(dstr) = (HE**)darray;
11037 while (i <= sxhv->xhv_max) {
11038 const HE * const source = HvARRAY(sstr)[i];
11039 HvARRAY(dstr)[i] = source
11040 ? he_dup(source, sharekeys, param) : 0;
11045 const struct xpvhv_aux * const saux = HvAUX(sstr);
11046 struct xpvhv_aux * const daux = HvAUX(dstr);
11047 /* This flag isn't copied. */
11048 /* SvOOK_on(hv) attacks the IV flags. */
11049 SvFLAGS(dstr) |= SVf_OOK;
11051 hvname = saux->xhv_name;
11052 daux->xhv_name = hek_dup(hvname, param);
11054 daux->xhv_riter = saux->xhv_riter;
11055 daux->xhv_eiter = saux->xhv_eiter
11056 ? he_dup(saux->xhv_eiter,
11057 (bool)!!HvSHAREKEYS(sstr), param) : 0;
11058 /* backref array needs refcnt=2; see sv_add_backref */
11059 daux->xhv_backreferences =
11060 saux->xhv_backreferences
11061 ? MUTABLE_AV(SvREFCNT_inc(
11062 sv_dup_inc((const SV *)saux->xhv_backreferences, param)))
11065 daux->xhv_mro_meta = saux->xhv_mro_meta
11066 ? mro_meta_dup(saux->xhv_mro_meta, param)
11069 /* Record stashes for possible cloning in Perl_clone(). */
11071 av_push(param->stashes, dstr);
11075 HvARRAY(MUTABLE_HV(dstr)) = NULL;
11078 if (!(param->flags & CLONEf_COPY_STACKS)) {
11082 /* NOTE: not refcounted */
11083 CvSTASH(dstr) = hv_dup(CvSTASH(dstr), param);
11085 if (!CvISXSUB(dstr))
11086 CvROOT(dstr) = OpREFCNT_inc(CvROOT(dstr));
11088 if (CvCONST(dstr) && CvISXSUB(dstr)) {
11089 CvXSUBANY(dstr).any_ptr =
11090 sv_dup_inc((const SV *)CvXSUBANY(dstr).any_ptr, param);
11092 /* don't dup if copying back - CvGV isn't refcounted, so the
11093 * duped GV may never be freed. A bit of a hack! DAPM */
11094 CvGV(dstr) = (param->flags & CLONEf_JOIN_IN) ?
11095 NULL : gv_dup(CvGV(dstr), param) ;
11096 PAD_DUP(CvPADLIST(dstr), CvPADLIST(sstr), param);
11098 CvWEAKOUTSIDE(sstr)
11099 ? cv_dup( CvOUTSIDE(dstr), param)
11100 : cv_dup_inc(CvOUTSIDE(dstr), param);
11101 if (!CvISXSUB(dstr))
11102 CvFILE(dstr) = SAVEPV(CvFILE(dstr));
11108 if (SvOBJECT(dstr) && SvTYPE(dstr) != SVt_PVIO)
11114 /* duplicate a context */
11117 Perl_cx_dup(pTHX_ PERL_CONTEXT *cxs, I32 ix, I32 max, CLONE_PARAMS* param)
11119 PERL_CONTEXT *ncxs;
11121 PERL_ARGS_ASSERT_CX_DUP;
11124 return (PERL_CONTEXT*)NULL;
11126 /* look for it in the table first */
11127 ncxs = (PERL_CONTEXT*)ptr_table_fetch(PL_ptr_table, cxs);
11131 /* create anew and remember what it is */
11132 Newx(ncxs, max + 1, PERL_CONTEXT);
11133 ptr_table_store(PL_ptr_table, cxs, ncxs);
11134 Copy(cxs, ncxs, max + 1, PERL_CONTEXT);
11137 PERL_CONTEXT * const ncx = &ncxs[ix];
11138 if (CxTYPE(ncx) == CXt_SUBST) {
11139 Perl_croak(aTHX_ "Cloning substitution context is unimplemented");
11142 switch (CxTYPE(ncx)) {
11144 ncx->blk_sub.cv = (ncx->blk_sub.olddepth == 0
11145 ? cv_dup_inc(ncx->blk_sub.cv, param)
11146 : cv_dup(ncx->blk_sub.cv,param));
11147 ncx->blk_sub.argarray = (CxHASARGS(ncx)
11148 ? av_dup_inc(ncx->blk_sub.argarray,
11151 ncx->blk_sub.savearray = av_dup_inc(ncx->blk_sub.savearray,
11153 ncx->blk_sub.oldcomppad = (PAD*)ptr_table_fetch(PL_ptr_table,
11154 ncx->blk_sub.oldcomppad);
11157 ncx->blk_eval.old_namesv = sv_dup_inc(ncx->blk_eval.old_namesv,
11159 ncx->blk_eval.cur_text = sv_dup(ncx->blk_eval.cur_text, param);
11161 case CXt_LOOP_LAZYSV:
11162 ncx->blk_loop.state_u.lazysv.end
11163 = sv_dup_inc(ncx->blk_loop.state_u.lazysv.end, param);
11164 /* We are taking advantage of av_dup_inc and sv_dup_inc
11165 actually being the same function, and order equivalance of
11167 We can assert the later [but only at run time :-(] */
11168 assert ((void *) &ncx->blk_loop.state_u.ary.ary ==
11169 (void *) &ncx->blk_loop.state_u.lazysv.cur);
11171 ncx->blk_loop.state_u.ary.ary
11172 = av_dup_inc(ncx->blk_loop.state_u.ary.ary, param);
11173 case CXt_LOOP_LAZYIV:
11174 case CXt_LOOP_PLAIN:
11175 if (CxPADLOOP(ncx)) {
11176 ncx->blk_loop.oldcomppad
11177 = (PAD*)ptr_table_fetch(PL_ptr_table,
11178 ncx->blk_loop.oldcomppad);
11180 ncx->blk_loop.oldcomppad
11181 = (PAD*)gv_dup((const GV *)ncx->blk_loop.oldcomppad,
11186 ncx->blk_format.cv = cv_dup(ncx->blk_format.cv, param);
11187 ncx->blk_format.gv = gv_dup(ncx->blk_format.gv, param);
11188 ncx->blk_format.dfoutgv = gv_dup_inc(ncx->blk_format.dfoutgv,
11201 /* duplicate a stack info structure */
11204 Perl_si_dup(pTHX_ PERL_SI *si, CLONE_PARAMS* param)
11208 PERL_ARGS_ASSERT_SI_DUP;
11211 return (PERL_SI*)NULL;
11213 /* look for it in the table first */
11214 nsi = (PERL_SI*)ptr_table_fetch(PL_ptr_table, si);
11218 /* create anew and remember what it is */
11219 Newxz(nsi, 1, PERL_SI);
11220 ptr_table_store(PL_ptr_table, si, nsi);
11222 nsi->si_stack = av_dup_inc(si->si_stack, param);
11223 nsi->si_cxix = si->si_cxix;
11224 nsi->si_cxmax = si->si_cxmax;
11225 nsi->si_cxstack = cx_dup(si->si_cxstack, si->si_cxix, si->si_cxmax, param);
11226 nsi->si_type = si->si_type;
11227 nsi->si_prev = si_dup(si->si_prev, param);
11228 nsi->si_next = si_dup(si->si_next, param);
11229 nsi->si_markoff = si->si_markoff;
11234 #define POPINT(ss,ix) ((ss)[--(ix)].any_i32)
11235 #define TOPINT(ss,ix) ((ss)[ix].any_i32)
11236 #define POPLONG(ss,ix) ((ss)[--(ix)].any_long)
11237 #define TOPLONG(ss,ix) ((ss)[ix].any_long)
11238 #define POPIV(ss,ix) ((ss)[--(ix)].any_iv)
11239 #define TOPIV(ss,ix) ((ss)[ix].any_iv)
11240 #define POPBOOL(ss,ix) ((ss)[--(ix)].any_bool)
11241 #define TOPBOOL(ss,ix) ((ss)[ix].any_bool)
11242 #define POPPTR(ss,ix) ((ss)[--(ix)].any_ptr)
11243 #define TOPPTR(ss,ix) ((ss)[ix].any_ptr)
11244 #define POPDPTR(ss,ix) ((ss)[--(ix)].any_dptr)
11245 #define TOPDPTR(ss,ix) ((ss)[ix].any_dptr)
11246 #define POPDXPTR(ss,ix) ((ss)[--(ix)].any_dxptr)
11247 #define TOPDXPTR(ss,ix) ((ss)[ix].any_dxptr)
11250 #define pv_dup_inc(p) SAVEPV(p)
11251 #define pv_dup(p) SAVEPV(p)
11252 #define svp_dup_inc(p,pp) any_dup(p,pp)
11254 /* map any object to the new equivent - either something in the
11255 * ptr table, or something in the interpreter structure
11259 Perl_any_dup(pTHX_ void *v, const PerlInterpreter *proto_perl)
11263 PERL_ARGS_ASSERT_ANY_DUP;
11266 return (void*)NULL;
11268 /* look for it in the table first */
11269 ret = ptr_table_fetch(PL_ptr_table, v);
11273 /* see if it is part of the interpreter structure */
11274 if (v >= (void*)proto_perl && v < (void*)(proto_perl+1))
11275 ret = (void*)(((char*)aTHX) + (((char*)v) - (char*)proto_perl));
11283 /* duplicate the save stack */
11286 Perl_ss_dup(pTHX_ PerlInterpreter *proto_perl, CLONE_PARAMS* param)
11289 ANY * const ss = proto_perl->Isavestack;
11290 const I32 max = proto_perl->Isavestack_max;
11291 I32 ix = proto_perl->Isavestack_ix;
11304 void (*dptr) (void*);
11305 void (*dxptr) (pTHX_ void*);
11307 PERL_ARGS_ASSERT_SS_DUP;
11309 Newxz(nss, max, ANY);
11312 const I32 type = POPINT(ss,ix);
11313 TOPINT(nss,ix) = type;
11315 case SAVEt_HELEM: /* hash element */
11316 sv = (const SV *)POPPTR(ss,ix);
11317 TOPPTR(nss,ix) = sv_dup_inc(sv, param);
11319 case SAVEt_ITEM: /* normal string */
11320 case SAVEt_SV: /* scalar reference */
11321 sv = (const SV *)POPPTR(ss,ix);
11322 TOPPTR(nss,ix) = sv_dup_inc(sv, param);
11325 case SAVEt_MORTALIZESV:
11326 sv = (const SV *)POPPTR(ss,ix);
11327 TOPPTR(nss,ix) = sv_dup_inc(sv, param);
11329 case SAVEt_SHARED_PVREF: /* char* in shared space */
11330 c = (char*)POPPTR(ss,ix);
11331 TOPPTR(nss,ix) = savesharedpv(c);
11332 ptr = POPPTR(ss,ix);
11333 TOPPTR(nss,ix) = any_dup(ptr, proto_perl);
11335 case SAVEt_GENERIC_SVREF: /* generic sv */
11336 case SAVEt_SVREF: /* scalar reference */
11337 sv = (const SV *)POPPTR(ss,ix);
11338 TOPPTR(nss,ix) = sv_dup_inc(sv, param);
11339 ptr = POPPTR(ss,ix);
11340 TOPPTR(nss,ix) = svp_dup_inc((SV**)ptr, proto_perl);/* XXXXX */
11342 case SAVEt_HV: /* hash reference */
11343 case SAVEt_AV: /* array reference */
11344 sv = (const SV *) POPPTR(ss,ix);
11345 TOPPTR(nss,ix) = sv_dup_inc(sv, param);
11347 case SAVEt_COMPPAD:
11349 sv = (const SV *) POPPTR(ss,ix);
11350 TOPPTR(nss,ix) = sv_dup(sv, param);
11352 case SAVEt_INT: /* int reference */
11353 ptr = POPPTR(ss,ix);
11354 TOPPTR(nss,ix) = any_dup(ptr, proto_perl);
11355 intval = (int)POPINT(ss,ix);
11356 TOPINT(nss,ix) = intval;
11358 case SAVEt_LONG: /* long reference */
11359 ptr = POPPTR(ss,ix);
11360 TOPPTR(nss,ix) = any_dup(ptr, proto_perl);
11362 case SAVEt_CLEARSV:
11363 longval = (long)POPLONG(ss,ix);
11364 TOPLONG(nss,ix) = longval;
11366 case SAVEt_I32: /* I32 reference */
11367 case SAVEt_I16: /* I16 reference */
11368 case SAVEt_I8: /* I8 reference */
11369 case SAVEt_COP_ARYBASE: /* call CopARYBASE_set */
11370 ptr = POPPTR(ss,ix);
11371 TOPPTR(nss,ix) = any_dup(ptr, proto_perl);
11373 TOPINT(nss,ix) = i;
11375 case SAVEt_IV: /* IV reference */
11376 ptr = POPPTR(ss,ix);
11377 TOPPTR(nss,ix) = any_dup(ptr, proto_perl);
11379 TOPIV(nss,ix) = iv;
11381 case SAVEt_HPTR: /* HV* reference */
11382 case SAVEt_APTR: /* AV* reference */
11383 case SAVEt_SPTR: /* SV* reference */
11384 ptr = POPPTR(ss,ix);
11385 TOPPTR(nss,ix) = any_dup(ptr, proto_perl);
11386 sv = (const SV *)POPPTR(ss,ix);
11387 TOPPTR(nss,ix) = sv_dup(sv, param);
11389 case SAVEt_VPTR: /* random* reference */
11390 ptr = POPPTR(ss,ix);
11391 TOPPTR(nss,ix) = any_dup(ptr, proto_perl);
11392 ptr = POPPTR(ss,ix);
11393 TOPPTR(nss,ix) = any_dup(ptr, proto_perl);
11395 case SAVEt_GENERIC_PVREF: /* generic char* */
11396 case SAVEt_PPTR: /* char* reference */
11397 ptr = POPPTR(ss,ix);
11398 TOPPTR(nss,ix) = any_dup(ptr, proto_perl);
11399 c = (char*)POPPTR(ss,ix);
11400 TOPPTR(nss,ix) = pv_dup(c);
11402 case SAVEt_GP: /* scalar reference */
11403 gp = (GP*)POPPTR(ss,ix);
11404 TOPPTR(nss,ix) = gp = gp_dup(gp, param);
11405 (void)GpREFCNT_inc(gp);
11406 gv = (const GV *)POPPTR(ss,ix);
11407 TOPPTR(nss,ix) = gv_dup_inc(gv, param);
11410 ptr = POPPTR(ss,ix);
11411 if (ptr && (((OP*)ptr)->op_private & OPpREFCOUNTED)) {
11412 /* these are assumed to be refcounted properly */
11414 switch (((OP*)ptr)->op_type) {
11416 case OP_LEAVESUBLV:
11420 case OP_LEAVEWRITE:
11421 TOPPTR(nss,ix) = ptr;
11424 (void) OpREFCNT_inc(o);
11428 TOPPTR(nss,ix) = NULL;
11433 TOPPTR(nss,ix) = NULL;
11436 hv = (const HV *)POPPTR(ss,ix);
11437 TOPPTR(nss,ix) = hv_dup_inc(hv, param);
11439 TOPINT(nss,ix) = i;
11442 c = (char*)POPPTR(ss,ix);
11443 TOPPTR(nss,ix) = pv_dup_inc(c);
11445 case SAVEt_STACK_POS: /* Position on Perl stack */
11447 TOPINT(nss,ix) = i;
11449 case SAVEt_DESTRUCTOR:
11450 ptr = POPPTR(ss,ix);
11451 TOPPTR(nss,ix) = any_dup(ptr, proto_perl); /* XXX quite arbitrary */
11452 dptr = POPDPTR(ss,ix);
11453 TOPDPTR(nss,ix) = DPTR2FPTR(void (*)(void*),
11454 any_dup(FPTR2DPTR(void *, dptr),
11457 case SAVEt_DESTRUCTOR_X:
11458 ptr = POPPTR(ss,ix);
11459 TOPPTR(nss,ix) = any_dup(ptr, proto_perl); /* XXX quite arbitrary */
11460 dxptr = POPDXPTR(ss,ix);
11461 TOPDXPTR(nss,ix) = DPTR2FPTR(void (*)(pTHX_ void*),
11462 any_dup(FPTR2DPTR(void *, dxptr),
11465 case SAVEt_REGCONTEXT:
11468 TOPINT(nss,ix) = i;
11471 case SAVEt_AELEM: /* array element */
11472 sv = (const SV *)POPPTR(ss,ix);
11473 TOPPTR(nss,ix) = sv_dup_inc(sv, param);
11475 TOPINT(nss,ix) = i;
11476 av = (const AV *)POPPTR(ss,ix);
11477 TOPPTR(nss,ix) = av_dup_inc(av, param);
11480 ptr = POPPTR(ss,ix);
11481 TOPPTR(nss,ix) = ptr;
11484 ptr = POPPTR(ss,ix);
11487 ((struct refcounted_he *)ptr)->refcounted_he_refcnt++;
11488 HINTS_REFCNT_UNLOCK;
11490 TOPPTR(nss,ix) = ptr;
11492 TOPINT(nss,ix) = i;
11493 if (i & HINT_LOCALIZE_HH) {
11494 hv = (const HV *)POPPTR(ss,ix);
11495 TOPPTR(nss,ix) = hv_dup_inc(hv, param);
11498 case SAVEt_PADSV_AND_MORTALIZE:
11499 longval = (long)POPLONG(ss,ix);
11500 TOPLONG(nss,ix) = longval;
11501 ptr = POPPTR(ss,ix);
11502 TOPPTR(nss,ix) = any_dup(ptr, proto_perl);
11503 sv = (const SV *)POPPTR(ss,ix);
11504 TOPPTR(nss,ix) = sv_dup_inc(sv, param);
11507 ptr = POPPTR(ss,ix);
11508 TOPPTR(nss,ix) = any_dup(ptr, proto_perl);
11509 longval = (long)POPBOOL(ss,ix);
11510 TOPBOOL(nss,ix) = (bool)longval;
11512 case SAVEt_SET_SVFLAGS:
11514 TOPINT(nss,ix) = i;
11516 TOPINT(nss,ix) = i;
11517 sv = (const SV *)POPPTR(ss,ix);
11518 TOPPTR(nss,ix) = sv_dup(sv, param);
11520 case SAVEt_RE_STATE:
11522 const struct re_save_state *const old_state
11523 = (struct re_save_state *)
11524 (ss + ix - SAVESTACK_ALLOC_FOR_RE_SAVE_STATE);
11525 struct re_save_state *const new_state
11526 = (struct re_save_state *)
11527 (nss + ix - SAVESTACK_ALLOC_FOR_RE_SAVE_STATE);
11529 Copy(old_state, new_state, 1, struct re_save_state);
11530 ix -= SAVESTACK_ALLOC_FOR_RE_SAVE_STATE;
11532 new_state->re_state_bostr
11533 = pv_dup(old_state->re_state_bostr);
11534 new_state->re_state_reginput
11535 = pv_dup(old_state->re_state_reginput);
11536 new_state->re_state_regeol
11537 = pv_dup(old_state->re_state_regeol);
11538 new_state->re_state_regoffs
11539 = (regexp_paren_pair*)
11540 any_dup(old_state->re_state_regoffs, proto_perl);
11541 new_state->re_state_reglastparen
11542 = (U32*) any_dup(old_state->re_state_reglastparen,
11544 new_state->re_state_reglastcloseparen
11545 = (U32*)any_dup(old_state->re_state_reglastcloseparen,
11547 /* XXX This just has to be broken. The old save_re_context
11548 code did SAVEGENERICPV(PL_reg_start_tmp);
11549 PL_reg_start_tmp is char **.
11550 Look above to what the dup code does for
11551 SAVEt_GENERIC_PVREF
11552 It can never have worked.
11553 So this is merely a faithful copy of the exiting bug: */
11554 new_state->re_state_reg_start_tmp
11555 = (char **) pv_dup((char *)
11556 old_state->re_state_reg_start_tmp);
11557 /* I assume that it only ever "worked" because no-one called
11558 (pseudo)fork while the regexp engine had re-entered itself.
11560 #ifdef PERL_OLD_COPY_ON_WRITE
11561 new_state->re_state_nrs
11562 = sv_dup(old_state->re_state_nrs, param);
11564 new_state->re_state_reg_magic
11565 = (MAGIC*) any_dup(old_state->re_state_reg_magic,
11567 new_state->re_state_reg_oldcurpm
11568 = (PMOP*) any_dup(old_state->re_state_reg_oldcurpm,
11570 new_state->re_state_reg_curpm
11571 = (PMOP*) any_dup(old_state->re_state_reg_curpm,
11573 new_state->re_state_reg_oldsaved
11574 = pv_dup(old_state->re_state_reg_oldsaved);
11575 new_state->re_state_reg_poscache
11576 = pv_dup(old_state->re_state_reg_poscache);
11577 new_state->re_state_reg_starttry
11578 = pv_dup(old_state->re_state_reg_starttry);
11581 case SAVEt_COMPILE_WARNINGS:
11582 ptr = POPPTR(ss,ix);
11583 TOPPTR(nss,ix) = DUP_WARNINGS((STRLEN*)ptr);
11586 ptr = POPPTR(ss,ix);
11587 TOPPTR(nss,ix) = parser_dup((const yy_parser*)ptr, param);
11591 "panic: ss_dup inconsistency (%"IVdf")", (IV) type);
11599 /* if sv is a stash, call $class->CLONE_SKIP(), and set the SVphv_CLONEABLE
11600 * flag to the result. This is done for each stash before cloning starts,
11601 * so we know which stashes want their objects cloned */
11604 do_mark_cloneable_stash(pTHX_ SV *const sv)
11606 const HEK * const hvname = HvNAME_HEK((const HV *)sv);
11608 GV* const cloner = gv_fetchmethod_autoload(MUTABLE_HV(sv), "CLONE_SKIP", 0);
11609 SvFLAGS(sv) |= SVphv_CLONEABLE; /* clone objects by default */
11610 if (cloner && GvCV(cloner)) {
11617 mXPUSHs(newSVhek(hvname));
11619 call_sv(MUTABLE_SV(GvCV(cloner)), G_SCALAR);
11626 SvFLAGS(sv) &= ~SVphv_CLONEABLE;
11634 =for apidoc perl_clone
11636 Create and return a new interpreter by cloning the current one.
11638 perl_clone takes these flags as parameters:
11640 CLONEf_COPY_STACKS - is used to, well, copy the stacks also,
11641 without it we only clone the data and zero the stacks,
11642 with it we copy the stacks and the new perl interpreter is
11643 ready to run at the exact same point as the previous one.
11644 The pseudo-fork code uses COPY_STACKS while the
11645 threads->create doesn't.
11647 CLONEf_KEEP_PTR_TABLE
11648 perl_clone keeps a ptr_table with the pointer of the old
11649 variable as a key and the new variable as a value,
11650 this allows it to check if something has been cloned and not
11651 clone it again but rather just use the value and increase the
11652 refcount. If KEEP_PTR_TABLE is not set then perl_clone will kill
11653 the ptr_table using the function
11654 C<ptr_table_free(PL_ptr_table); PL_ptr_table = NULL;>,
11655 reason to keep it around is if you want to dup some of your own
11656 variable who are outside the graph perl scans, example of this
11657 code is in threads.xs create
11660 This is a win32 thing, it is ignored on unix, it tells perls
11661 win32host code (which is c++) to clone itself, this is needed on
11662 win32 if you want to run two threads at the same time,
11663 if you just want to do some stuff in a separate perl interpreter
11664 and then throw it away and return to the original one,
11665 you don't need to do anything.
11670 /* XXX the above needs expanding by someone who actually understands it ! */
11671 EXTERN_C PerlInterpreter *
11672 perl_clone_host(PerlInterpreter* proto_perl, UV flags);
11675 perl_clone(PerlInterpreter *proto_perl, UV flags)
11678 #ifdef PERL_IMPLICIT_SYS
11680 PERL_ARGS_ASSERT_PERL_CLONE;
11682 /* perlhost.h so we need to call into it
11683 to clone the host, CPerlHost should have a c interface, sky */
11685 if (flags & CLONEf_CLONE_HOST) {
11686 return perl_clone_host(proto_perl,flags);
11688 return perl_clone_using(proto_perl, flags,
11690 proto_perl->IMemShared,
11691 proto_perl->IMemParse,
11693 proto_perl->IStdIO,
11697 proto_perl->IProc);
11701 perl_clone_using(PerlInterpreter *proto_perl, UV flags,
11702 struct IPerlMem* ipM, struct IPerlMem* ipMS,
11703 struct IPerlMem* ipMP, struct IPerlEnv* ipE,
11704 struct IPerlStdIO* ipStd, struct IPerlLIO* ipLIO,
11705 struct IPerlDir* ipD, struct IPerlSock* ipS,
11706 struct IPerlProc* ipP)
11708 /* XXX many of the string copies here can be optimized if they're
11709 * constants; they need to be allocated as common memory and just
11710 * their pointers copied. */
11713 CLONE_PARAMS clone_params;
11714 CLONE_PARAMS* const param = &clone_params;
11716 PerlInterpreter * const my_perl = (PerlInterpreter*)(*ipM->pMalloc)(ipM, sizeof(PerlInterpreter));
11718 PERL_ARGS_ASSERT_PERL_CLONE_USING;
11720 /* for each stash, determine whether its objects should be cloned */
11721 S_visit(proto_perl, do_mark_cloneable_stash, SVt_PVHV, SVTYPEMASK);
11722 PERL_SET_THX(my_perl);
11725 PoisonNew(my_perl, 1, PerlInterpreter);
11731 PL_savestack_ix = 0;
11732 PL_savestack_max = -1;
11733 PL_sig_pending = 0;
11735 Zero(&PL_debug_pad, 1, struct perl_debug_pad);
11736 # else /* !DEBUGGING */
11737 Zero(my_perl, 1, PerlInterpreter);
11738 # endif /* DEBUGGING */
11740 /* host pointers */
11742 PL_MemShared = ipMS;
11743 PL_MemParse = ipMP;
11750 #else /* !PERL_IMPLICIT_SYS */
11752 CLONE_PARAMS clone_params;
11753 CLONE_PARAMS* param = &clone_params;
11754 PerlInterpreter * const my_perl = (PerlInterpreter*)PerlMem_malloc(sizeof(PerlInterpreter));
11756 PERL_ARGS_ASSERT_PERL_CLONE;
11758 /* for each stash, determine whether its objects should be cloned */
11759 S_visit(proto_perl, do_mark_cloneable_stash, SVt_PVHV, SVTYPEMASK);
11760 PERL_SET_THX(my_perl);
11763 PoisonNew(my_perl, 1, PerlInterpreter);
11769 PL_savestack_ix = 0;
11770 PL_savestack_max = -1;
11771 PL_sig_pending = 0;
11773 Zero(&PL_debug_pad, 1, struct perl_debug_pad);
11774 # else /* !DEBUGGING */
11775 Zero(my_perl, 1, PerlInterpreter);
11776 # endif /* DEBUGGING */
11777 #endif /* PERL_IMPLICIT_SYS */
11778 param->flags = flags;
11779 param->proto_perl = proto_perl;
11781 INIT_TRACK_MEMPOOL(my_perl->Imemory_debug_header, my_perl);
11783 PL_body_arenas = NULL;
11784 Zero(&PL_body_roots, 1, PL_body_roots);
11786 PL_nice_chunk = NULL;
11787 PL_nice_chunk_size = 0;
11789 PL_sv_objcount = 0;
11791 PL_sv_arenaroot = NULL;
11793 PL_debug = proto_perl->Idebug;
11795 PL_hash_seed = proto_perl->Ihash_seed;
11796 PL_rehash_seed = proto_perl->Irehash_seed;
11798 #ifdef USE_REENTRANT_API
11799 /* XXX: things like -Dm will segfault here in perlio, but doing
11800 * PERL_SET_CONTEXT(proto_perl);
11801 * breaks too many other things
11803 Perl_reentrant_init(aTHX);
11806 /* create SV map for pointer relocation */
11807 PL_ptr_table = ptr_table_new();
11809 /* initialize these special pointers as early as possible */
11810 SvANY(&PL_sv_undef) = NULL;
11811 SvREFCNT(&PL_sv_undef) = (~(U32)0)/2;
11812 SvFLAGS(&PL_sv_undef) = SVf_READONLY|SVt_NULL;
11813 ptr_table_store(PL_ptr_table, &proto_perl->Isv_undef, &PL_sv_undef);
11815 SvANY(&PL_sv_no) = new_XPVNV();
11816 SvREFCNT(&PL_sv_no) = (~(U32)0)/2;
11817 SvFLAGS(&PL_sv_no) = SVp_IOK|SVf_IOK|SVp_NOK|SVf_NOK
11818 |SVp_POK|SVf_POK|SVf_READONLY|SVt_PVNV;
11819 SvPV_set(&PL_sv_no, savepvn(PL_No, 0));
11820 SvCUR_set(&PL_sv_no, 0);
11821 SvLEN_set(&PL_sv_no, 1);
11822 SvIV_set(&PL_sv_no, 0);
11823 SvNV_set(&PL_sv_no, 0);
11824 ptr_table_store(PL_ptr_table, &proto_perl->Isv_no, &PL_sv_no);
11826 SvANY(&PL_sv_yes) = new_XPVNV();
11827 SvREFCNT(&PL_sv_yes) = (~(U32)0)/2;
11828 SvFLAGS(&PL_sv_yes) = SVp_IOK|SVf_IOK|SVp_NOK|SVf_NOK
11829 |SVp_POK|SVf_POK|SVf_READONLY|SVt_PVNV;
11830 SvPV_set(&PL_sv_yes, savepvn(PL_Yes, 1));
11831 SvCUR_set(&PL_sv_yes, 1);
11832 SvLEN_set(&PL_sv_yes, 2);
11833 SvIV_set(&PL_sv_yes, 1);
11834 SvNV_set(&PL_sv_yes, 1);
11835 ptr_table_store(PL_ptr_table, &proto_perl->Isv_yes, &PL_sv_yes);
11837 /* create (a non-shared!) shared string table */
11838 PL_strtab = newHV();
11839 HvSHAREKEYS_off(PL_strtab);
11840 hv_ksplit(PL_strtab, HvTOTALKEYS(proto_perl->Istrtab));
11841 ptr_table_store(PL_ptr_table, proto_perl->Istrtab, PL_strtab);
11843 PL_compiling = proto_perl->Icompiling;
11845 /* These two PVs will be free'd special way so must set them same way op.c does */
11846 PL_compiling.cop_stashpv = savesharedpv(PL_compiling.cop_stashpv);
11847 ptr_table_store(PL_ptr_table, proto_perl->Icompiling.cop_stashpv, PL_compiling.cop_stashpv);
11849 PL_compiling.cop_file = savesharedpv(PL_compiling.cop_file);
11850 ptr_table_store(PL_ptr_table, proto_perl->Icompiling.cop_file, PL_compiling.cop_file);
11852 ptr_table_store(PL_ptr_table, &proto_perl->Icompiling, &PL_compiling);
11853 PL_compiling.cop_warnings = DUP_WARNINGS(PL_compiling.cop_warnings);
11854 if (PL_compiling.cop_hints_hash) {
11856 PL_compiling.cop_hints_hash->refcounted_he_refcnt++;
11857 HINTS_REFCNT_UNLOCK;
11859 PL_curcop = (COP*)any_dup(proto_perl->Icurcop, proto_perl);
11860 #ifdef PERL_DEBUG_READONLY_OPS
11865 /* pseudo environmental stuff */
11866 PL_origargc = proto_perl->Iorigargc;
11867 PL_origargv = proto_perl->Iorigargv;
11869 param->stashes = newAV(); /* Setup array of objects to call clone on */
11871 /* Set tainting stuff before PerlIO_debug can possibly get called */
11872 PL_tainting = proto_perl->Itainting;
11873 PL_taint_warn = proto_perl->Itaint_warn;
11875 #ifdef PERLIO_LAYERS
11876 /* Clone PerlIO tables as soon as we can handle general xx_dup() */
11877 PerlIO_clone(aTHX_ proto_perl, param);
11880 PL_envgv = gv_dup(proto_perl->Ienvgv, param);
11881 PL_incgv = gv_dup(proto_perl->Iincgv, param);
11882 PL_hintgv = gv_dup(proto_perl->Ihintgv, param);
11883 PL_origfilename = SAVEPV(proto_perl->Iorigfilename);
11884 PL_diehook = sv_dup_inc(proto_perl->Idiehook, param);
11885 PL_warnhook = sv_dup_inc(proto_perl->Iwarnhook, param);
11888 PL_minus_c = proto_perl->Iminus_c;
11889 PL_patchlevel = sv_dup_inc(proto_perl->Ipatchlevel, param);
11890 PL_localpatches = proto_perl->Ilocalpatches;
11891 PL_splitstr = proto_perl->Isplitstr;
11892 PL_minus_n = proto_perl->Iminus_n;
11893 PL_minus_p = proto_perl->Iminus_p;
11894 PL_minus_l = proto_perl->Iminus_l;
11895 PL_minus_a = proto_perl->Iminus_a;
11896 PL_minus_E = proto_perl->Iminus_E;
11897 PL_minus_F = proto_perl->Iminus_F;
11898 PL_doswitches = proto_perl->Idoswitches;
11899 PL_dowarn = proto_perl->Idowarn;
11900 PL_doextract = proto_perl->Idoextract;
11901 PL_sawampersand = proto_perl->Isawampersand;
11902 PL_unsafe = proto_perl->Iunsafe;
11903 PL_inplace = SAVEPV(proto_perl->Iinplace);
11904 PL_e_script = sv_dup_inc(proto_perl->Ie_script, param);
11905 PL_perldb = proto_perl->Iperldb;
11906 PL_perl_destruct_level = proto_perl->Iperl_destruct_level;
11907 PL_exit_flags = proto_perl->Iexit_flags;
11909 /* magical thingies */
11910 /* XXX time(&PL_basetime) when asked for? */
11911 PL_basetime = proto_perl->Ibasetime;
11912 PL_formfeed = sv_dup(proto_perl->Iformfeed, param);
11914 PL_maxsysfd = proto_perl->Imaxsysfd;
11915 PL_statusvalue = proto_perl->Istatusvalue;
11917 PL_statusvalue_vms = proto_perl->Istatusvalue_vms;
11919 PL_statusvalue_posix = proto_perl->Istatusvalue_posix;
11921 PL_encoding = sv_dup(proto_perl->Iencoding, param);
11923 sv_setpvs(PERL_DEBUG_PAD(0), ""); /* For regex debugging. */
11924 sv_setpvs(PERL_DEBUG_PAD(1), ""); /* ext/re needs these */
11925 sv_setpvs(PERL_DEBUG_PAD(2), ""); /* even without DEBUGGING. */
11928 /* RE engine related */
11929 Zero(&PL_reg_state, 1, struct re_save_state);
11930 PL_reginterp_cnt = 0;
11931 PL_regmatch_slab = NULL;
11933 /* Clone the regex array */
11934 /* ORANGE FIXME for plugins, probably in the SV dup code.
11935 newSViv(PTR2IV(CALLREGDUPE(
11936 INT2PTR(REGEXP *, SvIVX(regex)), param))))
11938 PL_regex_padav = av_dup_inc(proto_perl->Iregex_padav, param);
11939 PL_regex_pad = AvARRAY(PL_regex_padav);
11941 /* shortcuts to various I/O objects */
11942 PL_ofsgv = gv_dup(proto_perl->Iofsgv, param);
11943 PL_stdingv = gv_dup(proto_perl->Istdingv, param);
11944 PL_stderrgv = gv_dup(proto_perl->Istderrgv, param);
11945 PL_defgv = gv_dup(proto_perl->Idefgv, param);
11946 PL_argvgv = gv_dup(proto_perl->Iargvgv, param);
11947 PL_argvoutgv = gv_dup(proto_perl->Iargvoutgv, param);
11948 PL_argvout_stack = av_dup_inc(proto_perl->Iargvout_stack, param);
11950 /* shortcuts to regexp stuff */
11951 PL_replgv = gv_dup(proto_perl->Ireplgv, param);
11953 /* shortcuts to misc objects */
11954 PL_errgv = gv_dup(proto_perl->Ierrgv, param);
11956 /* shortcuts to debugging objects */
11957 PL_DBgv = gv_dup(proto_perl->IDBgv, param);
11958 PL_DBline = gv_dup(proto_perl->IDBline, param);
11959 PL_DBsub = gv_dup(proto_perl->IDBsub, param);
11960 PL_DBsingle = sv_dup(proto_perl->IDBsingle, param);
11961 PL_DBtrace = sv_dup(proto_perl->IDBtrace, param);
11962 PL_DBsignal = sv_dup(proto_perl->IDBsignal, param);
11963 PL_dbargs = av_dup(proto_perl->Idbargs, param);
11965 /* symbol tables */
11966 PL_defstash = hv_dup_inc(proto_perl->Idefstash, param);
11967 PL_curstash = hv_dup(proto_perl->Icurstash, param);
11968 PL_debstash = hv_dup(proto_perl->Idebstash, param);
11969 PL_globalstash = hv_dup(proto_perl->Iglobalstash, param);
11970 PL_curstname = sv_dup_inc(proto_perl->Icurstname, param);
11972 PL_beginav = av_dup_inc(proto_perl->Ibeginav, param);
11973 PL_beginav_save = av_dup_inc(proto_perl->Ibeginav_save, param);
11974 PL_checkav_save = av_dup_inc(proto_perl->Icheckav_save, param);
11975 PL_unitcheckav = av_dup_inc(proto_perl->Iunitcheckav, param);
11976 PL_unitcheckav_save = av_dup_inc(proto_perl->Iunitcheckav_save, param);
11977 PL_endav = av_dup_inc(proto_perl->Iendav, param);
11978 PL_checkav = av_dup_inc(proto_perl->Icheckav, param);
11979 PL_initav = av_dup_inc(proto_perl->Iinitav, param);
11981 PL_sub_generation = proto_perl->Isub_generation;
11982 PL_isarev = hv_dup_inc(proto_perl->Iisarev, param);
11984 /* funky return mechanisms */
11985 PL_forkprocess = proto_perl->Iforkprocess;
11987 /* subprocess state */
11988 PL_fdpid = av_dup_inc(proto_perl->Ifdpid, param);
11990 /* internal state */
11991 PL_maxo = proto_perl->Imaxo;
11992 if (proto_perl->Iop_mask)
11993 PL_op_mask = SAVEPVN(proto_perl->Iop_mask, PL_maxo);
11996 /* PL_asserting = proto_perl->Iasserting; */
11998 /* current interpreter roots */
11999 PL_main_cv = cv_dup_inc(proto_perl->Imain_cv, param);
12001 PL_main_root = OpREFCNT_inc(proto_perl->Imain_root);
12003 PL_main_start = proto_perl->Imain_start;
12004 PL_eval_root = proto_perl->Ieval_root;
12005 PL_eval_start = proto_perl->Ieval_start;
12007 /* runtime control stuff */
12008 PL_curcopdb = (COP*)any_dup(proto_perl->Icurcopdb, proto_perl);
12010 PL_filemode = proto_perl->Ifilemode;
12011 PL_lastfd = proto_perl->Ilastfd;
12012 PL_oldname = proto_perl->Ioldname; /* XXX not quite right */
12015 PL_gensym = proto_perl->Igensym;
12016 PL_preambleav = av_dup_inc(proto_perl->Ipreambleav, param);
12017 PL_laststatval = proto_perl->Ilaststatval;
12018 PL_laststype = proto_perl->Ilaststype;
12021 PL_ors_sv = sv_dup_inc(proto_perl->Iors_sv, param);
12023 /* interpreter atexit processing */
12024 PL_exitlistlen = proto_perl->Iexitlistlen;
12025 if (PL_exitlistlen) {
12026 Newx(PL_exitlist, PL_exitlistlen, PerlExitListEntry);
12027 Copy(proto_perl->Iexitlist, PL_exitlist, PL_exitlistlen, PerlExitListEntry);
12030 PL_exitlist = (PerlExitListEntry*)NULL;
12032 PL_my_cxt_size = proto_perl->Imy_cxt_size;
12033 if (PL_my_cxt_size) {
12034 Newx(PL_my_cxt_list, PL_my_cxt_size, void *);
12035 Copy(proto_perl->Imy_cxt_list, PL_my_cxt_list, PL_my_cxt_size, void *);
12036 #ifdef PERL_GLOBAL_STRUCT_PRIVATE
12037 Newx(PL_my_cxt_keys, PL_my_cxt_size, const char *);
12038 Copy(proto_perl->Imy_cxt_keys, PL_my_cxt_keys, PL_my_cxt_size, char *);
12042 PL_my_cxt_list = (void**)NULL;
12043 #ifdef PERL_GLOBAL_STRUCT_PRIVATE
12044 PL_my_cxt_keys = (const char**)NULL;
12047 PL_modglobal = hv_dup_inc(proto_perl->Imodglobal, param);
12048 PL_custom_op_names = hv_dup_inc(proto_perl->Icustom_op_names,param);
12049 PL_custom_op_descs = hv_dup_inc(proto_perl->Icustom_op_descs,param);
12051 PL_profiledata = NULL;
12053 PL_compcv = cv_dup(proto_perl->Icompcv, param);
12055 PAD_CLONE_VARS(proto_perl, param);
12057 #ifdef HAVE_INTERP_INTERN
12058 sys_intern_dup(&proto_perl->Isys_intern, &PL_sys_intern);
12061 /* more statics moved here */
12062 PL_generation = proto_perl->Igeneration;
12063 PL_DBcv = cv_dup(proto_perl->IDBcv, param);
12065 PL_in_clean_objs = proto_perl->Iin_clean_objs;
12066 PL_in_clean_all = proto_perl->Iin_clean_all;
12068 PL_uid = proto_perl->Iuid;
12069 PL_euid = proto_perl->Ieuid;
12070 PL_gid = proto_perl->Igid;
12071 PL_egid = proto_perl->Iegid;
12072 PL_nomemok = proto_perl->Inomemok;
12073 PL_an = proto_perl->Ian;
12074 PL_evalseq = proto_perl->Ievalseq;
12075 PL_origenviron = proto_perl->Iorigenviron; /* XXX not quite right */
12076 PL_origalen = proto_perl->Iorigalen;
12077 #ifdef PERL_USES_PL_PIDSTATUS
12078 PL_pidstatus = newHV(); /* XXX flag for cloning? */
12080 PL_osname = SAVEPV(proto_perl->Iosname);
12081 PL_sighandlerp = proto_perl->Isighandlerp;
12083 PL_runops = proto_perl->Irunops;
12085 PL_parser = parser_dup(proto_perl->Iparser, param);
12087 PL_subline = proto_perl->Isubline;
12088 PL_subname = sv_dup_inc(proto_perl->Isubname, param);
12091 PL_cryptseen = proto_perl->Icryptseen;
12094 PL_hints = proto_perl->Ihints;
12096 PL_amagic_generation = proto_perl->Iamagic_generation;
12098 #ifdef USE_LOCALE_COLLATE
12099 PL_collation_ix = proto_perl->Icollation_ix;
12100 PL_collation_name = SAVEPV(proto_perl->Icollation_name);
12101 PL_collation_standard = proto_perl->Icollation_standard;
12102 PL_collxfrm_base = proto_perl->Icollxfrm_base;
12103 PL_collxfrm_mult = proto_perl->Icollxfrm_mult;
12104 #endif /* USE_LOCALE_COLLATE */
12106 #ifdef USE_LOCALE_NUMERIC
12107 PL_numeric_name = SAVEPV(proto_perl->Inumeric_name);
12108 PL_numeric_standard = proto_perl->Inumeric_standard;
12109 PL_numeric_local = proto_perl->Inumeric_local;
12110 PL_numeric_radix_sv = sv_dup_inc(proto_perl->Inumeric_radix_sv, param);
12111 #endif /* !USE_LOCALE_NUMERIC */
12113 /* utf8 character classes */
12114 PL_utf8_alnum = sv_dup_inc(proto_perl->Iutf8_alnum, param);
12115 PL_utf8_alnumc = sv_dup_inc(proto_perl->Iutf8_alnumc, param);
12116 PL_utf8_ascii = sv_dup_inc(proto_perl->Iutf8_ascii, param);
12117 PL_utf8_alpha = sv_dup_inc(proto_perl->Iutf8_alpha, param);
12118 PL_utf8_space = sv_dup_inc(proto_perl->Iutf8_space, param);
12119 PL_utf8_cntrl = sv_dup_inc(proto_perl->Iutf8_cntrl, param);
12120 PL_utf8_graph = sv_dup_inc(proto_perl->Iutf8_graph, param);
12121 PL_utf8_digit = sv_dup_inc(proto_perl->Iutf8_digit, param);
12122 PL_utf8_upper = sv_dup_inc(proto_perl->Iutf8_upper, param);
12123 PL_utf8_lower = sv_dup_inc(proto_perl->Iutf8_lower, param);
12124 PL_utf8_print = sv_dup_inc(proto_perl->Iutf8_print, param);
12125 PL_utf8_punct = sv_dup_inc(proto_perl->Iutf8_punct, param);
12126 PL_utf8_xdigit = sv_dup_inc(proto_perl->Iutf8_xdigit, param);
12127 PL_utf8_mark = sv_dup_inc(proto_perl->Iutf8_mark, param);
12128 PL_utf8_toupper = sv_dup_inc(proto_perl->Iutf8_toupper, param);
12129 PL_utf8_totitle = sv_dup_inc(proto_perl->Iutf8_totitle, param);
12130 PL_utf8_tolower = sv_dup_inc(proto_perl->Iutf8_tolower, param);
12131 PL_utf8_tofold = sv_dup_inc(proto_perl->Iutf8_tofold, param);
12132 PL_utf8_idstart = sv_dup_inc(proto_perl->Iutf8_idstart, param);
12133 PL_utf8_idcont = sv_dup_inc(proto_perl->Iutf8_idcont, param);
12135 /* Did the locale setup indicate UTF-8? */
12136 PL_utf8locale = proto_perl->Iutf8locale;
12137 /* Unicode features (see perlrun/-C) */
12138 PL_unicode = proto_perl->Iunicode;
12140 /* Pre-5.8 signals control */
12141 PL_signals = proto_perl->Isignals;
12143 /* times() ticks per second */
12144 PL_clocktick = proto_perl->Iclocktick;
12146 /* Recursion stopper for PerlIO_find_layer */
12147 PL_in_load_module = proto_perl->Iin_load_module;
12149 /* sort() routine */
12150 PL_sort_RealCmp = proto_perl->Isort_RealCmp;
12152 /* Not really needed/useful since the reenrant_retint is "volatile",
12153 * but do it for consistency's sake. */
12154 PL_reentrant_retint = proto_perl->Ireentrant_retint;
12156 /* Hooks to shared SVs and locks. */
12157 PL_sharehook = proto_perl->Isharehook;
12158 PL_lockhook = proto_perl->Ilockhook;
12159 PL_unlockhook = proto_perl->Iunlockhook;
12160 PL_threadhook = proto_perl->Ithreadhook;
12161 PL_destroyhook = proto_perl->Idestroyhook;
12163 #ifdef THREADS_HAVE_PIDS
12164 PL_ppid = proto_perl->Ippid;
12168 PL_last_swash_hv = NULL; /* reinits on demand */
12169 PL_last_swash_klen = 0;
12170 PL_last_swash_key[0]= '\0';
12171 PL_last_swash_tmps = (U8*)NULL;
12172 PL_last_swash_slen = 0;
12174 PL_glob_index = proto_perl->Iglob_index;
12175 PL_srand_called = proto_perl->Isrand_called;
12177 if (proto_perl->Ipsig_pend) {
12178 Newxz(PL_psig_pend, SIG_SIZE, int);
12181 PL_psig_pend = (int*)NULL;
12184 if (proto_perl->Ipsig_name) {
12185 Newx(PL_psig_name, 2 * SIG_SIZE, SV*);
12186 sv_dup_inc_multiple(proto_perl->Ipsig_name, PL_psig_name, 2 * SIG_SIZE,
12188 PL_psig_ptr = PL_psig_name + SIG_SIZE;
12191 PL_psig_ptr = (SV**)NULL;
12192 PL_psig_name = (SV**)NULL;
12195 /* intrpvar.h stuff */
12197 if (flags & CLONEf_COPY_STACKS) {
12198 /* next allocation will be PL_tmps_stack[PL_tmps_ix+1] */
12199 PL_tmps_ix = proto_perl->Itmps_ix;
12200 PL_tmps_max = proto_perl->Itmps_max;
12201 PL_tmps_floor = proto_perl->Itmps_floor;
12202 Newx(PL_tmps_stack, PL_tmps_max, SV*);
12203 sv_dup_inc_multiple(proto_perl->Itmps_stack, PL_tmps_stack, PL_tmps_ix,
12206 /* next PUSHMARK() sets *(PL_markstack_ptr+1) */
12207 i = proto_perl->Imarkstack_max - proto_perl->Imarkstack;
12208 Newxz(PL_markstack, i, I32);
12209 PL_markstack_max = PL_markstack + (proto_perl->Imarkstack_max
12210 - proto_perl->Imarkstack);
12211 PL_markstack_ptr = PL_markstack + (proto_perl->Imarkstack_ptr
12212 - proto_perl->Imarkstack);
12213 Copy(proto_perl->Imarkstack, PL_markstack,
12214 PL_markstack_ptr - PL_markstack + 1, I32);
12216 /* next push_scope()/ENTER sets PL_scopestack[PL_scopestack_ix]
12217 * NOTE: unlike the others! */
12218 PL_scopestack_ix = proto_perl->Iscopestack_ix;
12219 PL_scopestack_max = proto_perl->Iscopestack_max;
12220 Newxz(PL_scopestack, PL_scopestack_max, I32);
12221 Copy(proto_perl->Iscopestack, PL_scopestack, PL_scopestack_ix, I32);
12223 /* NOTE: si_dup() looks at PL_markstack */
12224 PL_curstackinfo = si_dup(proto_perl->Icurstackinfo, param);
12226 /* PL_curstack = PL_curstackinfo->si_stack; */
12227 PL_curstack = av_dup(proto_perl->Icurstack, param);
12228 PL_mainstack = av_dup(proto_perl->Imainstack, param);
12230 /* next PUSHs() etc. set *(PL_stack_sp+1) */
12231 PL_stack_base = AvARRAY(PL_curstack);
12232 PL_stack_sp = PL_stack_base + (proto_perl->Istack_sp
12233 - proto_perl->Istack_base);
12234 PL_stack_max = PL_stack_base + AvMAX(PL_curstack);
12236 /* next SSPUSHFOO() sets PL_savestack[PL_savestack_ix]
12237 * NOTE: unlike the others! */
12238 PL_savestack_ix = proto_perl->Isavestack_ix;
12239 PL_savestack_max = proto_perl->Isavestack_max;
12240 /*Newxz(PL_savestack, PL_savestack_max, ANY);*/
12241 PL_savestack = ss_dup(proto_perl, param);
12245 ENTER; /* perl_destruct() wants to LEAVE; */
12247 /* although we're not duplicating the tmps stack, we should still
12248 * add entries for any SVs on the tmps stack that got cloned by a
12249 * non-refcount means (eg a temp in @_); otherwise they will be
12252 for (i = 0; i<= proto_perl->Itmps_ix; i++) {
12253 SV * const nsv = MUTABLE_SV(ptr_table_fetch(PL_ptr_table,
12254 proto_perl->Itmps_stack[i]));
12255 if (nsv && !SvREFCNT(nsv)) {
12257 PL_tmps_stack[++PL_tmps_ix] = SvREFCNT_inc_simple(nsv);
12262 PL_start_env = proto_perl->Istart_env; /* XXXXXX */
12263 PL_top_env = &PL_start_env;
12265 PL_op = proto_perl->Iop;
12268 PL_Xpv = (XPV*)NULL;
12269 my_perl->Ina = proto_perl->Ina;
12271 PL_statbuf = proto_perl->Istatbuf;
12272 PL_statcache = proto_perl->Istatcache;
12273 PL_statgv = gv_dup(proto_perl->Istatgv, param);
12274 PL_statname = sv_dup_inc(proto_perl->Istatname, param);
12276 PL_timesbuf = proto_perl->Itimesbuf;
12279 PL_tainted = proto_perl->Itainted;
12280 PL_curpm = proto_perl->Icurpm; /* XXX No PMOP ref count */
12281 PL_rs = sv_dup_inc(proto_perl->Irs, param);
12282 PL_last_in_gv = gv_dup(proto_perl->Ilast_in_gv, param);
12283 PL_defoutgv = gv_dup_inc(proto_perl->Idefoutgv, param);
12284 PL_chopset = proto_perl->Ichopset; /* XXX never deallocated */
12285 PL_toptarget = sv_dup_inc(proto_perl->Itoptarget, param);
12286 PL_bodytarget = sv_dup_inc(proto_perl->Ibodytarget, param);
12287 PL_formtarget = sv_dup(proto_perl->Iformtarget, param);
12289 PL_restartop = proto_perl->Irestartop;
12290 PL_in_eval = proto_perl->Iin_eval;
12291 PL_delaymagic = proto_perl->Idelaymagic;
12292 PL_dirty = proto_perl->Idirty;
12293 PL_localizing = proto_perl->Ilocalizing;
12295 PL_errors = sv_dup_inc(proto_perl->Ierrors, param);
12296 PL_hv_fetch_ent_mh = NULL;
12297 PL_modcount = proto_perl->Imodcount;
12298 PL_lastgotoprobe = NULL;
12299 PL_dumpindent = proto_perl->Idumpindent;
12301 PL_sortcop = (OP*)any_dup(proto_perl->Isortcop, proto_perl);
12302 PL_sortstash = hv_dup(proto_perl->Isortstash, param);
12303 PL_firstgv = gv_dup(proto_perl->Ifirstgv, param);
12304 PL_secondgv = gv_dup(proto_perl->Isecondgv, param);
12305 PL_efloatbuf = NULL; /* reinits on demand */
12306 PL_efloatsize = 0; /* reinits on demand */
12310 PL_screamfirst = NULL;
12311 PL_screamnext = NULL;
12312 PL_maxscream = -1; /* reinits on demand */
12313 PL_lastscream = NULL;
12316 PL_regdummy = proto_perl->Iregdummy;
12317 PL_colorset = 0; /* reinits PL_colors[] */
12318 /*PL_colors[6] = {0,0,0,0,0,0};*/
12322 /* Pluggable optimizer */
12323 PL_peepp = proto_perl->Ipeepp;
12324 /* op_free() hook */
12325 PL_opfreehook = proto_perl->Iopfreehook;
12327 PL_stashcache = newHV();
12329 PL_watchaddr = (char **) ptr_table_fetch(PL_ptr_table,
12330 proto_perl->Iwatchaddr);
12331 PL_watchok = PL_watchaddr ? * PL_watchaddr : NULL;
12332 if (PL_debug && PL_watchaddr) {
12333 PerlIO_printf(Perl_debug_log,
12334 "WATCHING: %"UVxf" cloned as %"UVxf" with value %"UVxf"\n",
12335 PTR2UV(proto_perl->Iwatchaddr), PTR2UV(PL_watchaddr),
12336 PTR2UV(PL_watchok));
12339 PL_registered_mros = hv_dup_inc(proto_perl->Iregistered_mros, param);
12341 if (!(flags & CLONEf_KEEP_PTR_TABLE)) {
12342 ptr_table_free(PL_ptr_table);
12343 PL_ptr_table = NULL;
12346 /* Call the ->CLONE method, if it exists, for each of the stashes
12347 identified by sv_dup() above.
12349 while(av_len(param->stashes) != -1) {
12350 HV* const stash = MUTABLE_HV(av_shift(param->stashes));
12351 GV* const cloner = gv_fetchmethod_autoload(stash, "CLONE", 0);
12352 if (cloner && GvCV(cloner)) {
12357 mXPUSHs(newSVhek(HvNAME_HEK(stash)));
12359 call_sv(MUTABLE_SV(GvCV(cloner)), G_DISCARD);
12365 SvREFCNT_dec(param->stashes);
12367 /* orphaned? eg threads->new inside BEGIN or use */
12368 if (PL_compcv && ! SvREFCNT(PL_compcv)) {
12369 SvREFCNT_inc_simple_void(PL_compcv);
12370 SAVEFREESV(PL_compcv);
12376 #endif /* USE_ITHREADS */
12379 =head1 Unicode Support
12381 =for apidoc sv_recode_to_utf8
12383 The encoding is assumed to be an Encode object, on entry the PV
12384 of the sv is assumed to be octets in that encoding, and the sv
12385 will be converted into Unicode (and UTF-8).
12387 If the sv already is UTF-8 (or if it is not POK), or if the encoding
12388 is not a reference, nothing is done to the sv. If the encoding is not
12389 an C<Encode::XS> Encoding object, bad things will happen.
12390 (See F<lib/encoding.pm> and L<Encode>).
12392 The PV of the sv is returned.
12397 Perl_sv_recode_to_utf8(pTHX_ SV *sv, SV *encoding)
12401 PERL_ARGS_ASSERT_SV_RECODE_TO_UTF8;
12403 if (SvPOK(sv) && !SvUTF8(sv) && !IN_BYTES && SvROK(encoding)) {
12417 Passing sv_yes is wrong - it needs to be or'ed set of constants
12418 for Encode::XS, while UTf-8 decode (currently) assumes a true value means
12419 remove converted chars from source.
12421 Both will default the value - let them.
12423 XPUSHs(&PL_sv_yes);
12426 call_method("decode", G_SCALAR);
12430 s = SvPV_const(uni, len);
12431 if (s != SvPVX_const(sv)) {
12432 SvGROW(sv, len + 1);
12433 Move(s, SvPVX(sv), len + 1, char);
12434 SvCUR_set(sv, len);
12441 return SvPOKp(sv) ? SvPVX(sv) : NULL;
12445 =for apidoc sv_cat_decode
12447 The encoding is assumed to be an Encode object, the PV of the ssv is
12448 assumed to be octets in that encoding and decoding the input starts
12449 from the position which (PV + *offset) pointed to. The dsv will be
12450 concatenated the decoded UTF-8 string from ssv. Decoding will terminate
12451 when the string tstr appears in decoding output or the input ends on
12452 the PV of the ssv. The value which the offset points will be modified
12453 to the last input position on the ssv.
12455 Returns TRUE if the terminator was found, else returns FALSE.
12460 Perl_sv_cat_decode(pTHX_ SV *dsv, SV *encoding,
12461 SV *ssv, int *offset, char *tstr, int tlen)
12466 PERL_ARGS_ASSERT_SV_CAT_DECODE;
12468 if (SvPOK(ssv) && SvPOK(dsv) && SvROK(encoding) && offset) {
12479 offsv = newSViv(*offset);
12481 mXPUSHp(tstr, tlen);
12483 call_method("cat_decode", G_SCALAR);
12485 ret = SvTRUE(TOPs);
12486 *offset = SvIV(offsv);
12492 Perl_croak(aTHX_ "Invalid argument to sv_cat_decode");
12497 /* ---------------------------------------------------------------------
12499 * support functions for report_uninit()
12502 /* the maxiumum size of array or hash where we will scan looking
12503 * for the undefined element that triggered the warning */
12505 #define FUV_MAX_SEARCH_SIZE 1000
12507 /* Look for an entry in the hash whose value has the same SV as val;
12508 * If so, return a mortal copy of the key. */
12511 S_find_hash_subscript(pTHX_ const HV *const hv, const SV *const val)
12514 register HE **array;
12517 PERL_ARGS_ASSERT_FIND_HASH_SUBSCRIPT;
12519 if (!hv || SvMAGICAL(hv) || !HvARRAY(hv) ||
12520 (HvTOTALKEYS(hv) > FUV_MAX_SEARCH_SIZE))
12523 array = HvARRAY(hv);
12525 for (i=HvMAX(hv); i>0; i--) {
12526 register HE *entry;
12527 for (entry = array[i]; entry; entry = HeNEXT(entry)) {
12528 if (HeVAL(entry) != val)
12530 if ( HeVAL(entry) == &PL_sv_undef ||
12531 HeVAL(entry) == &PL_sv_placeholder)
12535 if (HeKLEN(entry) == HEf_SVKEY)
12536 return sv_mortalcopy(HeKEY_sv(entry));
12537 return sv_2mortal(newSVhek(HeKEY_hek(entry)));
12543 /* Look for an entry in the array whose value has the same SV as val;
12544 * If so, return the index, otherwise return -1. */
12547 S_find_array_subscript(pTHX_ const AV *const av, const SV *const val)
12551 PERL_ARGS_ASSERT_FIND_ARRAY_SUBSCRIPT;
12553 if (!av || SvMAGICAL(av) || !AvARRAY(av) ||
12554 (AvFILLp(av) > FUV_MAX_SEARCH_SIZE))
12557 if (val != &PL_sv_undef) {
12558 SV ** const svp = AvARRAY(av);
12561 for (i=AvFILLp(av); i>=0; i--)
12568 /* S_varname(): return the name of a variable, optionally with a subscript.
12569 * If gv is non-zero, use the name of that global, along with gvtype (one
12570 * of "$", "@", "%"); otherwise use the name of the lexical at pad offset
12571 * targ. Depending on the value of the subscript_type flag, return:
12574 #define FUV_SUBSCRIPT_NONE 1 /* "@foo" */
12575 #define FUV_SUBSCRIPT_ARRAY 2 /* "$foo[aindex]" */
12576 #define FUV_SUBSCRIPT_HASH 3 /* "$foo{keyname}" */
12577 #define FUV_SUBSCRIPT_WITHIN 4 /* "within @foo" */
12580 S_varname(pTHX_ const GV *const gv, const char gvtype, PADOFFSET targ,
12581 const SV *const keyname, I32 aindex, int subscript_type)
12584 SV * const name = sv_newmortal();
12587 buffer[0] = gvtype;
12590 /* as gv_fullname4(), but add literal '^' for $^FOO names */
12592 gv_fullname4(name, gv, buffer, 0);
12594 if ((unsigned int)SvPVX(name)[1] <= 26) {
12596 buffer[1] = SvPVX(name)[1] + 'A' - 1;
12598 /* Swap the 1 unprintable control character for the 2 byte pretty
12599 version - ie substr($name, 1, 1) = $buffer; */
12600 sv_insert(name, 1, 1, buffer, 2);
12604 CV * const cv = find_runcv(NULL);
12608 if (!cv || !CvPADLIST(cv))
12610 av = MUTABLE_AV((*av_fetch(CvPADLIST(cv), 0, FALSE)));
12611 sv = *av_fetch(av, targ, FALSE);
12612 sv_setpvn(name, SvPV_nolen_const(sv), SvCUR(sv));
12615 if (subscript_type == FUV_SUBSCRIPT_HASH) {
12616 SV * const sv = newSV(0);
12617 *SvPVX(name) = '$';
12618 Perl_sv_catpvf(aTHX_ name, "{%s}",
12619 pv_display(sv,SvPVX_const(keyname), SvCUR(keyname), 0, 32));
12622 else if (subscript_type == FUV_SUBSCRIPT_ARRAY) {
12623 *SvPVX(name) = '$';
12624 Perl_sv_catpvf(aTHX_ name, "[%"IVdf"]", (IV)aindex);
12626 else if (subscript_type == FUV_SUBSCRIPT_WITHIN) {
12627 /* We know that name has no magic, so can use 0 instead of SV_GMAGIC */
12628 Perl_sv_insert_flags(aTHX_ name, 0, 0, STR_WITH_LEN("within "), 0);
12636 =for apidoc find_uninit_var
12638 Find the name of the undefined variable (if any) that caused the operator o
12639 to issue a "Use of uninitialized value" warning.
12640 If match is true, only return a name if it's value matches uninit_sv.
12641 So roughly speaking, if a unary operator (such as OP_COS) generates a
12642 warning, then following the direct child of the op may yield an
12643 OP_PADSV or OP_GV that gives the name of the undefined variable. On the
12644 other hand, with OP_ADD there are two branches to follow, so we only print
12645 the variable name if we get an exact match.
12647 The name is returned as a mortal SV.
12649 Assumes that PL_op is the op that originally triggered the error, and that
12650 PL_comppad/PL_curpad points to the currently executing pad.
12656 S_find_uninit_var(pTHX_ const OP *const obase, const SV *const uninit_sv,
12662 const OP *o, *o2, *kid;
12664 if (!obase || (match && (!uninit_sv || uninit_sv == &PL_sv_undef ||
12665 uninit_sv == &PL_sv_placeholder)))
12668 switch (obase->op_type) {
12675 const bool pad = (obase->op_type == OP_PADAV || obase->op_type == OP_PADHV);
12676 const bool hash = (obase->op_type == OP_PADHV || obase->op_type == OP_RV2HV);
12679 int subscript_type = FUV_SUBSCRIPT_WITHIN;
12681 if (pad) { /* @lex, %lex */
12682 sv = PAD_SVl(obase->op_targ);
12686 if (cUNOPx(obase)->op_first->op_type == OP_GV) {
12687 /* @global, %global */
12688 gv = cGVOPx_gv(cUNOPx(obase)->op_first);
12691 sv = hash ? MUTABLE_SV(GvHV(gv)): MUTABLE_SV(GvAV(gv));
12693 else /* @{expr}, %{expr} */
12694 return find_uninit_var(cUNOPx(obase)->op_first,
12698 /* attempt to find a match within the aggregate */
12700 keysv = find_hash_subscript((const HV*)sv, uninit_sv);
12702 subscript_type = FUV_SUBSCRIPT_HASH;
12705 index = find_array_subscript((const AV *)sv, uninit_sv);
12707 subscript_type = FUV_SUBSCRIPT_ARRAY;
12710 if (match && subscript_type == FUV_SUBSCRIPT_WITHIN)
12713 return varname(gv, hash ? '%' : '@', obase->op_targ,
12714 keysv, index, subscript_type);
12718 if (match && PAD_SVl(obase->op_targ) != uninit_sv)
12720 return varname(NULL, '$', obase->op_targ,
12721 NULL, 0, FUV_SUBSCRIPT_NONE);
12724 gv = cGVOPx_gv(obase);
12725 if (!gv || (match && GvSV(gv) != uninit_sv))
12727 return varname(gv, '$', 0, NULL, 0, FUV_SUBSCRIPT_NONE);
12730 if (obase->op_flags & OPf_SPECIAL) { /* lexical array */
12733 AV *av = MUTABLE_AV(PAD_SV(obase->op_targ));
12734 if (!av || SvRMAGICAL(av))
12736 svp = av_fetch(av, (I32)obase->op_private, FALSE);
12737 if (!svp || *svp != uninit_sv)
12740 return varname(NULL, '$', obase->op_targ,
12741 NULL, (I32)obase->op_private, FUV_SUBSCRIPT_ARRAY);
12744 gv = cGVOPx_gv(obase);
12749 AV *const av = GvAV(gv);
12750 if (!av || SvRMAGICAL(av))
12752 svp = av_fetch(av, (I32)obase->op_private, FALSE);
12753 if (!svp || *svp != uninit_sv)
12756 return varname(gv, '$', 0,
12757 NULL, (I32)obase->op_private, FUV_SUBSCRIPT_ARRAY);
12762 o = cUNOPx(obase)->op_first;
12763 if (!o || o->op_type != OP_NULL ||
12764 ! (o->op_targ == OP_AELEM || o->op_targ == OP_HELEM))
12766 return find_uninit_var(cBINOPo->op_last, uninit_sv, match);
12770 if (PL_op == obase)
12771 /* $a[uninit_expr] or $h{uninit_expr} */
12772 return find_uninit_var(cBINOPx(obase)->op_last, uninit_sv, match);
12775 o = cBINOPx(obase)->op_first;
12776 kid = cBINOPx(obase)->op_last;
12778 /* get the av or hv, and optionally the gv */
12780 if (o->op_type == OP_PADAV || o->op_type == OP_PADHV) {
12781 sv = PAD_SV(o->op_targ);
12783 else if ((o->op_type == OP_RV2AV || o->op_type == OP_RV2HV)
12784 && cUNOPo->op_first->op_type == OP_GV)
12786 gv = cGVOPx_gv(cUNOPo->op_first);
12790 == OP_RV2HV ? MUTABLE_SV(GvHV(gv)) : MUTABLE_SV(GvAV(gv));
12795 if (kid && kid->op_type == OP_CONST && SvOK(cSVOPx_sv(kid))) {
12796 /* index is constant */
12800 if (obase->op_type == OP_HELEM) {
12801 HE* he = hv_fetch_ent(MUTABLE_HV(sv), cSVOPx_sv(kid), 0, 0);
12802 if (!he || HeVAL(he) != uninit_sv)
12806 SV * const * const svp = av_fetch(MUTABLE_AV(sv), SvIV(cSVOPx_sv(kid)), FALSE);
12807 if (!svp || *svp != uninit_sv)
12811 if (obase->op_type == OP_HELEM)
12812 return varname(gv, '%', o->op_targ,
12813 cSVOPx_sv(kid), 0, FUV_SUBSCRIPT_HASH);
12815 return varname(gv, '@', o->op_targ, NULL,
12816 SvIV(cSVOPx_sv(kid)), FUV_SUBSCRIPT_ARRAY);
12819 /* index is an expression;
12820 * attempt to find a match within the aggregate */
12821 if (obase->op_type == OP_HELEM) {
12822 SV * const keysv = find_hash_subscript((const HV*)sv, uninit_sv);
12824 return varname(gv, '%', o->op_targ,
12825 keysv, 0, FUV_SUBSCRIPT_HASH);
12829 = find_array_subscript((const AV *)sv, uninit_sv);
12831 return varname(gv, '@', o->op_targ,
12832 NULL, index, FUV_SUBSCRIPT_ARRAY);
12837 (o->op_type == OP_PADAV || o->op_type == OP_RV2AV)
12839 o->op_targ, NULL, 0, FUV_SUBSCRIPT_WITHIN);
12844 /* only examine RHS */
12845 return find_uninit_var(cBINOPx(obase)->op_first, uninit_sv, match);
12848 o = cUNOPx(obase)->op_first;
12849 if (o->op_type == OP_PUSHMARK)
12852 if (!o->op_sibling) {
12853 /* one-arg version of open is highly magical */
12855 if (o->op_type == OP_GV) { /* open FOO; */
12857 if (match && GvSV(gv) != uninit_sv)
12859 return varname(gv, '$', 0,
12860 NULL, 0, FUV_SUBSCRIPT_NONE);
12862 /* other possibilities not handled are:
12863 * open $x; or open my $x; should return '${*$x}'
12864 * open expr; should return '$'.expr ideally
12870 /* ops where $_ may be an implicit arg */
12874 if ( !(obase->op_flags & OPf_STACKED)) {
12875 if (uninit_sv == ((obase->op_private & OPpTARGET_MY)
12876 ? PAD_SVl(obase->op_targ)
12879 sv = sv_newmortal();
12880 sv_setpvs(sv, "$_");
12889 match = 1; /* print etc can return undef on defined args */
12890 /* skip filehandle as it can't produce 'undef' warning */
12891 o = cUNOPx(obase)->op_first;
12892 if ((obase->op_flags & OPf_STACKED) && o->op_type == OP_PUSHMARK)
12893 o = o->op_sibling->op_sibling;
12897 case OP_ENTEREVAL: /* could be eval $undef or $x='$undef'; eval $x */
12899 case OP_CUSTOM: /* XS or custom code could trigger random warnings */
12901 /* the following ops are capable of returning PL_sv_undef even for
12902 * defined arg(s) */
12921 case OP_GETPEERNAME:
12969 case OP_SMARTMATCH:
12978 /* XXX tmp hack: these two may call an XS sub, and currently
12979 XS subs don't have a SUB entry on the context stack, so CV and
12980 pad determination goes wrong, and BAD things happen. So, just
12981 don't try to determine the value under those circumstances.
12982 Need a better fix at dome point. DAPM 11/2007 */
12988 GV * const gv = gv_fetchpvs(".", GV_NOTQUAL, SVt_PV);
12989 if (gv && GvSV(gv) == uninit_sv)
12990 return newSVpvs_flags("$.", SVs_TEMP);
12995 /* def-ness of rval pos() is independent of the def-ness of its arg */
12996 if ( !(obase->op_flags & OPf_MOD))
13001 if (SvROK(PL_rs) && uninit_sv == SvRV(PL_rs))
13002 return newSVpvs_flags("${$/}", SVs_TEMP);
13007 if (!(obase->op_flags & OPf_KIDS))
13009 o = cUNOPx(obase)->op_first;
13015 /* if all except one arg are constant, or have no side-effects,
13016 * or are optimized away, then it's unambiguous */
13018 for (kid=o; kid; kid = kid->op_sibling) {
13020 const OPCODE type = kid->op_type;
13021 if ( (type == OP_CONST && SvOK(cSVOPx_sv(kid)))
13022 || (type == OP_NULL && ! (kid->op_flags & OPf_KIDS))
13023 || (type == OP_PUSHMARK)
13027 if (o2) { /* more than one found */
13034 return find_uninit_var(o2, uninit_sv, match);
13036 /* scan all args */
13038 sv = find_uninit_var(o, uninit_sv, 1);
13050 =for apidoc report_uninit
13052 Print appropriate "Use of uninitialized variable" warning
13058 Perl_report_uninit(pTHX_ const SV *uninit_sv)
13062 SV* varname = NULL;
13064 varname = find_uninit_var(PL_op, uninit_sv,0);
13066 sv_insert(varname, 0, 0, " ", 1);
13068 Perl_warner(aTHX_ packWARN(WARN_UNINITIALIZED), PL_warn_uninit,
13069 varname ? SvPV_nolen_const(varname) : "",
13070 " in ", OP_DESC(PL_op));
13073 Perl_warner(aTHX_ packWARN(WARN_UNINITIALIZED), PL_warn_uninit,
13079 * c-indentation-style: bsd
13080 * c-basic-offset: 4
13081 * indent-tabs-mode: t
13084 * ex: set ts=8 sts=4 sw=4 noet: