perl 5.003_06: pod/perldiag.pod
[perl.git] / sv.c
1 /*    sv.c
2  *
3  *    Copyright (c) 1991-1994, Larry Wall
4  *
5  *    You may distribute under the terms of either the GNU General Public
6  *    License or the Artistic License, as specified in the README file.
7  *
8  */
9
10 /*
11  * "I wonder what the Entish is for 'yes' and 'no'," he thought.
12  */
13
14 #include "EXTERN.h"
15 #include "perl.h"
16
17 #ifdef OVR_DBL_DIG
18 /* Use an overridden DBL_DIG */
19 # ifdef DBL_DIG
20 #  undef DBL_DIG
21 # endif
22 # define DBL_DIG OVR_DBL_DIG
23 #else
24 /* The following is all to get DBL_DIG, in order to pick a nice
25    default value for printing floating point numbers in Gconvert.
26    (see config.h)
27 */
28 #ifdef I_LIMITS
29 #include <limits.h>
30 #endif
31 #ifdef I_FLOAT
32 #include <float.h>
33 #endif
34 #ifndef HAS_DBL_DIG
35 #define DBL_DIG 15   /* A guess that works lots of places */
36 #endif
37 #endif
38
39 #if defined(USE_STDIO_PTR) && defined(STDIO_PTR_LVALUE) && defined(STDIO_CNT_LVALUE) && !defined(__QNX__)
40 #  define FAST_SV_GETS
41 #endif
42
43 static SV *more_sv _((void));
44 static XPVIV *more_xiv _((void));
45 static XPVNV *more_xnv _((void));
46 static XPV *more_xpv _((void));
47 static XRV *more_xrv _((void));
48 static XPVIV *new_xiv _((void));
49 static XPVNV *new_xnv _((void));
50 static XPV *new_xpv _((void));
51 static XRV *new_xrv _((void));
52 static void del_xiv _((XPVIV* p));
53 static void del_xnv _((XPVNV* p));
54 static void del_xpv _((XPV* p));
55 static void del_xrv _((XRV* p));
56 static void sv_mortalgrow _((void));
57 static void sv_unglob _((SV* sv));
58
59 typedef void (*SVFUNC) _((SV*));
60
61 #ifdef PURIFY
62
63 #define new_SV(p)                       \
64     do {                                \
65         (p) = (SV*)safemalloc(sizeof(SV)); \
66         reg_add(p);                     \
67     } while (0)
68
69 #define del_SV(p)                       \
70     do {                                \
71         reg_remove(p);                  \
72         free((char*)(p));               \
73     } while (0)
74
75 static SV **registry;
76 static I32 regsize;
77
78 #define REGHASH(sv,size)  ((((U32)(sv)) >> 2) % (size))
79
80 #define REG_REPLACE(sv,a,b) \
81     do {                                \
82         void* p = sv->sv_any;           \
83         I32 h = REGHASH(sv, regsize);   \
84         I32 i = h;                      \
85         while (registry[i] != (a)) {    \
86             if (++i >= regsize)         \
87                 i = 0;                  \
88             if (i == h)                 \
89                 die("SV registry bug"); \
90         }                               \
91         registry[i] = (b);              \
92     } while (0)
93
94 #define REG_ADD(sv)     REG_REPLACE(sv,Nullsv,sv)
95 #define REG_REMOVE(sv)  REG_REPLACE(sv,sv,Nullsv)
96
97 static void
98 reg_add(sv)
99 SV* sv;
100 {
101     if (sv_count >= (regsize >> 1))
102     {
103         SV **oldreg = registry;
104         I32 oldsize = regsize;
105
106         regsize = regsize ? ((regsize << 2) + 1) : 2037;
107         registry = (SV**)safemalloc(regsize * sizeof(SV*));
108         memzero(registry, regsize * sizeof(SV*));
109
110         if (oldreg) {
111             I32 i;
112
113             for (i = 0; i < oldsize; ++i) {
114                 SV* oldsv = oldreg[i];
115                 if (oldsv)
116                     REG_ADD(oldsv);
117             }
118             Safefree(oldreg);
119         }
120     }
121
122     REG_ADD(sv);
123     ++sv_count;
124 }
125
126 static void
127 reg_remove(sv)
128 SV* sv;
129 {
130     REG_REMOVE(sv);
131     --sv_count;
132 }
133
134 static void
135 visit(f)
136 SVFUNC f;
137 {
138     I32 i;
139
140     for (i = 0; i < regsize; ++i) {
141         SV* sv = registry[i];
142         if (sv)
143             (*f)(sv);
144     }
145 }
146
147 void
148 sv_add_arena(ptr, size, flags)
149 char* ptr;
150 U32 size;
151 U32 flags;
152 {
153     if (!(flags & SVf_FAKE))
154         free(ptr);
155 }
156
157 #else /* ! PURIFY */
158
159 /*
160  * "A time to plant, and a time to uproot what was planted..."
161  */
162
163 #define plant_SV(p)                     \
164     do {                                \
165         SvANY(p) = (void *)sv_root;     \
166         SvFLAGS(p) = SVTYPEMASK;        \
167         sv_root = (p);                  \
168         --sv_count;                     \
169     } while (0)
170
171 #define uproot_SV(p)            \
172     do {                                \
173         (p) = sv_root;                  \
174         sv_root = (SV*)SvANY(p);        \
175         ++sv_count;                     \
176     } while (0)
177
178 #define new_SV(p)                       \
179     if (sv_root)                        \
180         uproot_SV(p);                   \
181     else                                \
182         (p) = more_sv()
183
184 #ifdef DEBUGGING
185
186 #define del_SV(p)                       \
187     if (debug & 32768)                  \
188         del_sv(p);                      \
189     else                                \
190         plant_SV(p)
191
192 static void
193 del_sv(p)
194 SV* p;
195 {
196     if (debug & 32768) {
197         SV* sva;
198         SV* sv;
199         SV* svend;
200         int ok = 0;
201         for (sva = sv_arenaroot; sva; sva = (SV *) SvANY(sva)) {
202             sv = sva + 1;
203             svend = &sva[SvREFCNT(sva)];
204             if (p >= sv && p < svend)
205                 ok = 1;
206         }
207         if (!ok) {
208             warn("Attempt to free non-arena SV: 0x%lx", (unsigned long)p);
209             return;
210         }
211     }
212     plant_SV(p);
213 }
214
215 #else /* ! DEBUGGING */
216
217 #define del_SV(p)   plant_SV(p)
218
219 #endif /* DEBUGGING */
220
221 void
222 sv_add_arena(ptr, size, flags)
223 char* ptr;
224 U32 size;
225 U32 flags;
226 {
227     SV* sva = (SV*)ptr;
228     register SV* sv;
229     register SV* svend;
230     Zero(sva, size, char);
231
232     /* The first SV in an arena isn't an SV. */
233     SvANY(sva) = (void *) sv_arenaroot;         /* ptr to next arena */
234     SvREFCNT(sva) = size / sizeof(SV);          /* number of SV slots */
235     SvFLAGS(sva) = flags;                       /* FAKE if not to be freed */
236
237     sv_arenaroot = sva;
238     sv_root = sva + 1;
239
240     svend = &sva[SvREFCNT(sva) - 1];
241     sv = sva + 1;
242     while (sv < svend) {
243         SvANY(sv) = (void *)(SV*)(sv + 1);
244         SvFLAGS(sv) = SVTYPEMASK;
245         sv++;
246     }
247     SvANY(sv) = 0;
248     SvFLAGS(sv) = SVTYPEMASK;
249 }
250
251 static SV*
252 more_sv()
253 {
254     register SV* sv;
255
256     if (nice_chunk) {
257         sv_add_arena(nice_chunk, nice_chunk_size, 0);
258         nice_chunk = Nullch;
259     }
260     else {
261         char *chunk;                /* must use New here to match call to */
262         New(704,chunk,1008,char);   /* Safefree() in sv_free_arenas()     */
263         sv_add_arena(chunk, 1008, 0);
264     }
265     uproot_SV(sv);
266     return sv;
267 }
268
269 static void
270 visit(f)
271 SVFUNC f;
272 {
273     SV* sva;
274     SV* sv;
275     register SV* svend;
276
277     for (sva = sv_arenaroot; sva; sva = (SV*)SvANY(sva)) {
278         svend = &sva[SvREFCNT(sva)];
279         for (sv = sva + 1; sv < svend; ++sv) {
280             if (SvTYPE(sv) != SVTYPEMASK)
281                 (*f)(sv);
282         }
283     }
284 }
285
286 #endif /* PURIFY */
287
288 static void
289 do_report_used(sv)
290 SV* sv;
291 {
292     if (SvTYPE(sv) != SVTYPEMASK) {
293         /* XXX Perhaps this ought to go to Perl_debug_log, if DEBUGGING. */
294         PerlIO_printf(PerlIO_stderr(), "****\n");
295         sv_dump(sv);
296     }
297 }
298
299 void
300 sv_report_used()
301 {
302     visit(do_report_used);
303 }
304
305 static void
306 do_clean_objs(sv)
307 SV* sv;
308 {
309     SV* rv;
310
311     if (SvROK(sv) && SvOBJECT(rv = SvRV(sv))) {
312         DEBUG_D((PerlIO_printf(Perl_debug_log, "Cleaning object ref:\n "), sv_dump(sv));)
313         SvROK_off(sv);
314         SvRV(sv) = 0;
315         SvREFCNT_dec(rv);
316     }
317
318     /* XXX Might want to check arrays, etc. */
319 }
320
321 #ifndef DISABLE_DESTRUCTOR_KLUDGE
322 static void
323 do_clean_named_objs(sv)
324 SV* sv;
325 {
326     if (SvTYPE(sv) == SVt_PVGV && GvSV(sv))
327         do_clean_objs(GvSV(sv));
328 }
329 #endif
330
331 void
332 sv_clean_objs()
333 {
334 #ifndef DISABLE_DESTRUCTOR_KLUDGE
335     visit(do_clean_named_objs);
336 #endif
337     visit(do_clean_objs);
338 }
339
340 static void
341 do_clean_all(sv)
342 SV* sv;
343 {
344     DEBUG_D((PerlIO_printf(Perl_debug_log, "Cleaning loops:\n "), sv_dump(sv));)
345     SvFLAGS(sv) |= SVf_BREAK;
346     SvREFCNT_dec(sv);
347 }
348
349 static int in_clean_all = 0;
350
351 void
352 sv_clean_all()
353 {
354     in_clean_all = 1;
355     visit(do_clean_all);
356     in_clean_all = 0;
357 }
358
359 void
360 sv_free_arenas()
361 {
362     SV* sva;
363     SV* svanext;
364
365     /* Free arenas here, but be careful about fake ones.  (We assume
366        contiguity of the fake ones with the corresponding real ones.) */
367
368     for (sva = sv_arenaroot; sva; sva = svanext) {
369         svanext = (SV*) SvANY(sva);
370         while (svanext && SvFAKE(svanext))
371             svanext = (SV*) SvANY(svanext);
372
373         if (!SvFAKE(sva))
374             Safefree((void *)sva);
375     }
376 }
377
378 static XPVIV*
379 new_xiv()
380 {
381     IV** xiv;
382     if (xiv_root) {
383         xiv = xiv_root;
384         /*
385          * See comment in more_xiv() -- RAM.
386          */
387         xiv_root = (IV**)*xiv;
388         return (XPVIV*)((char*)xiv - sizeof(XPV));
389     }
390     return more_xiv();
391 }
392
393 static void
394 del_xiv(p)
395 XPVIV* p;
396 {
397     IV** xiv = (IV**)((char*)(p) + sizeof(XPV));
398     *xiv = (IV *)xiv_root;
399     xiv_root = xiv;
400 }
401
402 static XPVIV*
403 more_xiv()
404 {
405     register IV** xiv;
406     register IV** xivend;
407     XPV* ptr = (XPV*)safemalloc(1008);
408     ptr->xpv_pv = (char*)xiv_arenaroot;         /* linked list of xiv arenas */
409     xiv_arenaroot = ptr;                        /* to keep Purify happy */
410
411     xiv = (IV**) ptr;
412     xivend = &xiv[1008 / sizeof(IV *) - 1];
413     xiv += (sizeof(XPV) - 1) / sizeof(IV *) + 1;   /* fudge by size of XPV */
414     xiv_root = xiv;
415     while (xiv < xivend) {
416         *xiv = (IV *)(xiv + 1);
417         xiv++;
418     }
419     *xiv = 0;
420     return new_xiv();
421 }
422
423 static XPVNV*
424 new_xnv()
425 {
426     double* xnv;
427     if (xnv_root) {
428         xnv = xnv_root;
429         xnv_root = *(double**)xnv;
430         return (XPVNV*)((char*)xnv - sizeof(XPVIV));
431     }
432     return more_xnv();
433 }
434
435 static void
436 del_xnv(p)
437 XPVNV* p;
438 {
439     double* xnv = (double*)((char*)(p) + sizeof(XPVIV));
440     *(double**)xnv = xnv_root;
441     xnv_root = xnv;
442 }
443
444 static XPVNV*
445 more_xnv()
446 {
447     register double* xnv;
448     register double* xnvend;
449     xnv = (double*)safemalloc(1008);
450     xnvend = &xnv[1008 / sizeof(double) - 1];
451     xnv += (sizeof(XPVIV) - 1) / sizeof(double) + 1; /* fudge by sizeof XPVIV */
452     xnv_root = xnv;
453     while (xnv < xnvend) {
454         *(double**)xnv = (double*)(xnv + 1);
455         xnv++;
456     }
457     *(double**)xnv = 0;
458     return new_xnv();
459 }
460
461 static XRV*
462 new_xrv()
463 {
464     XRV* xrv;
465     if (xrv_root) {
466         xrv = xrv_root;
467         xrv_root = (XRV*)xrv->xrv_rv;
468         return xrv;
469     }
470     return more_xrv();
471 }
472
473 static void
474 del_xrv(p)
475 XRV* p;
476 {
477     p->xrv_rv = (SV*)xrv_root;
478     xrv_root = p;
479 }
480
481 static XRV*
482 more_xrv()
483 {
484     register XRV* xrv;
485     register XRV* xrvend;
486     xrv_root = (XRV*)safemalloc(1008);
487     xrv = xrv_root;
488     xrvend = &xrv[1008 / sizeof(XRV) - 1];
489     while (xrv < xrvend) {
490         xrv->xrv_rv = (SV*)(xrv + 1);
491         xrv++;
492     }
493     xrv->xrv_rv = 0;
494     return new_xrv();
495 }
496
497 static XPV*
498 new_xpv()
499 {
500     XPV* xpv;
501     if (xpv_root) {
502         xpv = xpv_root;
503         xpv_root = (XPV*)xpv->xpv_pv;
504         return xpv;
505     }
506     return more_xpv();
507 }
508
509 static void
510 del_xpv(p)
511 XPV* p;
512 {
513     p->xpv_pv = (char*)xpv_root;
514     xpv_root = p;
515 }
516
517 static XPV*
518 more_xpv()
519 {
520     register XPV* xpv;
521     register XPV* xpvend;
522     xpv_root = (XPV*)safemalloc(1008);
523     xpv = xpv_root;
524     xpvend = &xpv[1008 / sizeof(XPV) - 1];
525     while (xpv < xpvend) {
526         xpv->xpv_pv = (char*)(xpv + 1);
527         xpv++;
528     }
529     xpv->xpv_pv = 0;
530     return new_xpv();
531 }
532
533 #ifdef PURIFY
534 #define new_XIV() (void*)safemalloc(sizeof(XPVIV))
535 #define del_XIV(p) free((char*)p)
536 #else
537 #define new_XIV() (void*)new_xiv()
538 #define del_XIV(p) del_xiv(p)
539 #endif
540
541 #ifdef PURIFY
542 #define new_XNV() (void*)safemalloc(sizeof(XPVNV))
543 #define del_XNV(p) free((char*)p)
544 #else
545 #define new_XNV() (void*)new_xnv()
546 #define del_XNV(p) del_xnv(p)
547 #endif
548
549 #ifdef PURIFY
550 #define new_XRV() (void*)safemalloc(sizeof(XRV))
551 #define del_XRV(p) free((char*)p)
552 #else
553 #define new_XRV() (void*)new_xrv()
554 #define del_XRV(p) del_xrv(p)
555 #endif
556
557 #ifdef PURIFY
558 #define new_XPV() (void*)safemalloc(sizeof(XPV))
559 #define del_XPV(p) free((char*)p)
560 #else
561 #define new_XPV() (void*)new_xpv()
562 #define del_XPV(p) del_xpv(p)
563 #endif
564
565 #define new_XPVIV() (void*)safemalloc(sizeof(XPVIV))
566 #define del_XPVIV(p) free((char*)p)
567
568 #define new_XPVNV() (void*)safemalloc(sizeof(XPVNV))
569 #define del_XPVNV(p) free((char*)p)
570
571 #define new_XPVMG() (void*)safemalloc(sizeof(XPVMG))
572 #define del_XPVMG(p) free((char*)p)
573
574 #define new_XPVLV() (void*)safemalloc(sizeof(XPVLV))
575 #define del_XPVLV(p) free((char*)p)
576
577 #define new_XPVAV() (void*)safemalloc(sizeof(XPVAV))
578 #define del_XPVAV(p) free((char*)p)
579
580 #define new_XPVHV() (void*)safemalloc(sizeof(XPVHV))
581 #define del_XPVHV(p) free((char*)p)
582
583 #define new_XPVCV() (void*)safemalloc(sizeof(XPVCV))
584 #define del_XPVCV(p) free((char*)p)
585
586 #define new_XPVGV() (void*)safemalloc(sizeof(XPVGV))
587 #define del_XPVGV(p) free((char*)p)
588
589 #define new_XPVBM() (void*)safemalloc(sizeof(XPVBM))
590 #define del_XPVBM(p) free((char*)p)
591
592 #define new_XPVFM() (void*)safemalloc(sizeof(XPVFM))
593 #define del_XPVFM(p) free((char*)p)
594
595 #define new_XPVIO() (void*)safemalloc(sizeof(XPVIO))
596 #define del_XPVIO(p) free((char*)p)
597
598 bool
599 sv_upgrade(sv, mt)
600 register SV* sv;
601 U32 mt;
602 {
603     char*       pv;
604     U32         cur;
605     U32         len;
606     IV          iv;
607     double      nv;
608     MAGIC*      magic;
609     HV*         stash;
610
611     if (SvTYPE(sv) == mt)
612         return TRUE;
613
614     if (mt < SVt_PVIV)
615         (void)SvOOK_off(sv);
616
617     switch (SvTYPE(sv)) {
618     case SVt_NULL:
619         pv      = 0;
620         cur     = 0;
621         len     = 0;
622         iv      = 0;
623         nv      = 0.0;
624         magic   = 0;
625         stash   = 0;
626         break;
627     case SVt_IV:
628         pv      = 0;
629         cur     = 0;
630         len     = 0;
631         iv      = SvIVX(sv);
632         nv      = (double)SvIVX(sv);
633         del_XIV(SvANY(sv));
634         magic   = 0;
635         stash   = 0;
636         if (mt == SVt_NV)
637             mt = SVt_PVNV;
638         else if (mt < SVt_PVIV)
639             mt = SVt_PVIV;
640         break;
641     case SVt_NV:
642         pv      = 0;
643         cur     = 0;
644         len     = 0;
645         nv      = SvNVX(sv);
646         iv      = I_32(nv);
647         magic   = 0;
648         stash   = 0;
649         del_XNV(SvANY(sv));
650         SvANY(sv) = 0;
651         if (mt < SVt_PVNV)
652             mt = SVt_PVNV;
653         break;
654     case SVt_RV:
655         pv      = (char*)SvRV(sv);
656         cur     = 0;
657         len     = 0;
658         iv      = (IV)pv;
659         nv      = (double)(unsigned long)pv;
660         del_XRV(SvANY(sv));
661         magic   = 0;
662         stash   = 0;
663         break;
664     case SVt_PV:
665         pv      = SvPVX(sv);
666         cur     = SvCUR(sv);
667         len     = SvLEN(sv);
668         iv      = 0;
669         nv      = 0.0;
670         magic   = 0;
671         stash   = 0;
672         del_XPV(SvANY(sv));
673         if (mt <= SVt_IV)
674             mt = SVt_PVIV;
675         else if (mt == SVt_NV)
676             mt = SVt_PVNV;
677         break;
678     case SVt_PVIV:
679         pv      = SvPVX(sv);
680         cur     = SvCUR(sv);
681         len     = SvLEN(sv);
682         iv      = SvIVX(sv);
683         nv      = 0.0;
684         magic   = 0;
685         stash   = 0;
686         del_XPVIV(SvANY(sv));
687         break;
688     case SVt_PVNV:
689         pv      = SvPVX(sv);
690         cur     = SvCUR(sv);
691         len     = SvLEN(sv);
692         iv      = SvIVX(sv);
693         nv      = SvNVX(sv);
694         magic   = 0;
695         stash   = 0;
696         del_XPVNV(SvANY(sv));
697         break;
698     case SVt_PVMG:
699         pv      = SvPVX(sv);
700         cur     = SvCUR(sv);
701         len     = SvLEN(sv);
702         iv      = SvIVX(sv);
703         nv      = SvNVX(sv);
704         magic   = SvMAGIC(sv);
705         stash   = SvSTASH(sv);
706         del_XPVMG(SvANY(sv));
707         break;
708     default:
709         croak("Can't upgrade that kind of scalar");
710     }
711
712     switch (mt) {
713     case SVt_NULL:
714         croak("Can't upgrade to undef");
715     case SVt_IV:
716         SvANY(sv) = new_XIV();
717         SvIVX(sv)       = iv;
718         break;
719     case SVt_NV:
720         SvANY(sv) = new_XNV();
721         SvNVX(sv)       = nv;
722         break;
723     case SVt_RV:
724         SvANY(sv) = new_XRV();
725         SvRV(sv) = (SV*)pv;
726         break;
727     case SVt_PV:
728         SvANY(sv) = new_XPV();
729         SvPVX(sv)       = pv;
730         SvCUR(sv)       = cur;
731         SvLEN(sv)       = len;
732         break;
733     case SVt_PVIV:
734         SvANY(sv) = new_XPVIV();
735         SvPVX(sv)       = pv;
736         SvCUR(sv)       = cur;
737         SvLEN(sv)       = len;
738         SvIVX(sv)       = iv;
739         if (SvNIOK(sv))
740             (void)SvIOK_on(sv);
741         SvNOK_off(sv);
742         break;
743     case SVt_PVNV:
744         SvANY(sv) = new_XPVNV();
745         SvPVX(sv)       = pv;
746         SvCUR(sv)       = cur;
747         SvLEN(sv)       = len;
748         SvIVX(sv)       = iv;
749         SvNVX(sv)       = nv;
750         break;
751     case SVt_PVMG:
752         SvANY(sv) = new_XPVMG();
753         SvPVX(sv)       = pv;
754         SvCUR(sv)       = cur;
755         SvLEN(sv)       = len;
756         SvIVX(sv)       = iv;
757         SvNVX(sv)       = nv;
758         SvMAGIC(sv)     = magic;
759         SvSTASH(sv)     = stash;
760         break;
761     case SVt_PVLV:
762         SvANY(sv) = new_XPVLV();
763         SvPVX(sv)       = pv;
764         SvCUR(sv)       = cur;
765         SvLEN(sv)       = len;
766         SvIVX(sv)       = iv;
767         SvNVX(sv)       = nv;
768         SvMAGIC(sv)     = magic;
769         SvSTASH(sv)     = stash;
770         LvTARGOFF(sv)   = 0;
771         LvTARGLEN(sv)   = 0;
772         LvTARG(sv)      = 0;
773         LvTYPE(sv)      = 0;
774         break;
775     case SVt_PVAV:
776         SvANY(sv) = new_XPVAV();
777         if (pv)
778             Safefree(pv);
779         SvPVX(sv)       = 0;
780         AvMAX(sv)       = -1;
781         AvFILL(sv)      = -1;
782         SvIVX(sv)       = 0;
783         SvNVX(sv)       = 0.0;
784         SvMAGIC(sv)     = magic;
785         SvSTASH(sv)     = stash;
786         AvALLOC(sv)     = 0;
787         AvARYLEN(sv)    = 0;
788         AvFLAGS(sv)     = 0;
789         break;
790     case SVt_PVHV:
791         SvANY(sv) = new_XPVHV();
792         if (pv)
793             Safefree(pv);
794         SvPVX(sv)       = 0;
795         HvFILL(sv)      = 0;
796         HvMAX(sv)       = 0;
797         HvKEYS(sv)      = 0;
798         SvNVX(sv)       = 0.0;
799         SvMAGIC(sv)     = magic;
800         SvSTASH(sv)     = stash;
801         HvRITER(sv)     = 0;
802         HvEITER(sv)     = 0;
803         HvPMROOT(sv)    = 0;
804         HvNAME(sv)      = 0;
805         break;
806     case SVt_PVCV:
807         SvANY(sv) = new_XPVCV();
808         Zero(SvANY(sv), 1, XPVCV);
809         SvPVX(sv)       = pv;
810         SvCUR(sv)       = cur;
811         SvLEN(sv)       = len;
812         SvIVX(sv)       = iv;
813         SvNVX(sv)       = nv;
814         SvMAGIC(sv)     = magic;
815         SvSTASH(sv)     = stash;
816         break;
817     case SVt_PVGV:
818         SvANY(sv) = new_XPVGV();
819         SvPVX(sv)       = pv;
820         SvCUR(sv)       = cur;
821         SvLEN(sv)       = len;
822         SvIVX(sv)       = iv;
823         SvNVX(sv)       = nv;
824         SvMAGIC(sv)     = magic;
825         SvSTASH(sv)     = stash;
826         GvGP(sv)        = 0;
827         GvNAME(sv)      = 0;
828         GvNAMELEN(sv)   = 0;
829         GvSTASH(sv)     = 0;
830         GvFLAGS(sv)     = 0;
831         break;
832     case SVt_PVBM:
833         SvANY(sv) = new_XPVBM();
834         SvPVX(sv)       = pv;
835         SvCUR(sv)       = cur;
836         SvLEN(sv)       = len;
837         SvIVX(sv)       = iv;
838         SvNVX(sv)       = nv;
839         SvMAGIC(sv)     = magic;
840         SvSTASH(sv)     = stash;
841         BmRARE(sv)      = 0;
842         BmUSEFUL(sv)    = 0;
843         BmPREVIOUS(sv)  = 0;
844         break;
845     case SVt_PVFM:
846         SvANY(sv) = new_XPVFM();
847         Zero(SvANY(sv), 1, XPVFM);
848         SvPVX(sv)       = pv;
849         SvCUR(sv)       = cur;
850         SvLEN(sv)       = len;
851         SvIVX(sv)       = iv;
852         SvNVX(sv)       = nv;
853         SvMAGIC(sv)     = magic;
854         SvSTASH(sv)     = stash;
855         break;
856     case SVt_PVIO:
857         SvANY(sv) = new_XPVIO();
858         Zero(SvANY(sv), 1, XPVIO);
859         SvPVX(sv)       = pv;
860         SvCUR(sv)       = cur;
861         SvLEN(sv)       = len;
862         SvIVX(sv)       = iv;
863         SvNVX(sv)       = nv;
864         SvMAGIC(sv)     = magic;
865         SvSTASH(sv)     = stash;
866         IoPAGE_LEN(sv)  = 60;
867         break;
868     }
869     SvFLAGS(sv) &= ~SVTYPEMASK;
870     SvFLAGS(sv) |= mt;
871     return TRUE;
872 }
873
874 #ifdef DEBUGGING
875 char *
876 sv_peek(sv)
877 register SV *sv;
878 {
879     char *t = tokenbuf;
880     int unref = 0;
881
882   retry:
883     if (!sv) {
884         strcpy(t, "VOID");
885         goto finish;
886     }
887     else if (sv == (SV*)0x55555555 || SvTYPE(sv) == 'U') {
888         strcpy(t, "WILD");
889         goto finish;
890     }
891     else if (sv == &sv_undef || sv == &sv_no || sv == &sv_yes) {
892         if (sv == &sv_undef) {
893             strcpy(t, "SV_UNDEF");
894             if (!(SvFLAGS(sv) & (SVf_OK|SVf_OOK|SVs_OBJECT|
895                                  SVs_GMG|SVs_SMG|SVs_RMG)) &&
896                 SvREADONLY(sv))
897                 goto finish;
898         }
899         else if (sv == &sv_no) {
900             strcpy(t, "SV_NO");
901             if (!(SvFLAGS(sv) & (SVf_ROK|SVf_OOK|SVs_OBJECT|
902                                  SVs_GMG|SVs_SMG|SVs_RMG)) &&
903                 !(~SvFLAGS(sv) & (SVf_POK|SVf_NOK|SVf_READONLY|
904                                   SVp_POK|SVp_NOK)) &&
905                 SvCUR(sv) == 0 &&
906                 SvNVX(sv) == 0.0)
907                 goto finish;
908         }
909         else {
910             strcpy(t, "SV_YES");
911             if (!(SvFLAGS(sv) & (SVf_ROK|SVf_OOK|SVs_OBJECT|
912                                  SVs_GMG|SVs_SMG|SVs_RMG)) &&
913                 !(~SvFLAGS(sv) & (SVf_POK|SVf_NOK|SVf_READONLY|
914                                   SVp_POK|SVp_NOK)) &&
915                 SvCUR(sv) == 1 &&
916                 SvPVX(sv) && *SvPVX(sv) == '1' &&
917                 SvNVX(sv) == 1.0)
918                 goto finish;
919         }
920         t += strlen(t);
921         *t++ = ':';
922     }
923     else if (SvREFCNT(sv) == 0) {
924         *t++ = '(';
925         unref++;
926     }
927     if (SvROK(sv)) {
928         *t++ = '\\';
929         if (t - tokenbuf + unref > 10) {
930             strcpy(tokenbuf + unref + 3,"...");
931             goto finish;
932         }
933         sv = (SV*)SvRV(sv);
934         goto retry;
935     }
936     switch (SvTYPE(sv)) {
937     default:
938         strcpy(t,"FREED");
939         goto finish;
940
941     case SVt_NULL:
942         strcpy(t,"UNDEF");
943         return tokenbuf;
944     case SVt_IV:
945         strcpy(t,"IV");
946         break;
947     case SVt_NV:
948         strcpy(t,"NV");
949         break;
950     case SVt_RV:
951         strcpy(t,"RV");
952         break;
953     case SVt_PV:
954         strcpy(t,"PV");
955         break;
956     case SVt_PVIV:
957         strcpy(t,"PVIV");
958         break;
959     case SVt_PVNV:
960         strcpy(t,"PVNV");
961         break;
962     case SVt_PVMG:
963         strcpy(t,"PVMG");
964         break;
965     case SVt_PVLV:
966         strcpy(t,"PVLV");
967         break;
968     case SVt_PVAV:
969         strcpy(t,"AV");
970         break;
971     case SVt_PVHV:
972         strcpy(t,"HV");
973         break;
974     case SVt_PVCV:
975         if (CvGV(sv))
976             sprintf(t, "CV(%s)", GvNAME(CvGV(sv)));
977         else
978             strcpy(t, "CV()");
979         goto finish;
980     case SVt_PVGV:
981         strcpy(t,"GV");
982         break;
983     case SVt_PVBM:
984         strcpy(t,"BM");
985         break;
986     case SVt_PVFM:
987         strcpy(t,"FM");
988         break;
989     case SVt_PVIO:
990         strcpy(t,"IO");
991         break;
992     }
993     t += strlen(t);
994
995     if (SvPOKp(sv)) {
996         if (!SvPVX(sv))
997             strcpy(t, "(null)");
998         if (SvOOK(sv))
999             sprintf(t,"(%ld+\"%.127s\")",(long)SvIVX(sv),SvPVX(sv));
1000         else
1001             sprintf(t,"(\"%.127s\")",SvPVX(sv));
1002     }
1003     else if (SvNOKp(sv))
1004         sprintf(t,"(%g)",SvNVX(sv));
1005     else if (SvIOKp(sv))
1006         sprintf(t,"(%ld)",(long)SvIVX(sv));
1007     else
1008         strcpy(t,"()");
1009     
1010   finish:
1011     if (unref) {
1012         t += strlen(t);
1013         while (unref--)
1014             *t++ = ')';
1015         *t = '\0';
1016     }
1017     return tokenbuf;
1018 }
1019 #endif
1020
1021 int
1022 sv_backoff(sv)
1023 register SV *sv;
1024 {
1025     assert(SvOOK(sv));
1026     if (SvIVX(sv)) {
1027         char *s = SvPVX(sv);
1028         SvLEN(sv) += SvIVX(sv);
1029         SvPVX(sv) -= SvIVX(sv);
1030         SvIV_set(sv, 0);
1031         Move(s, SvPVX(sv), SvCUR(sv)+1, char);
1032     }
1033     SvFLAGS(sv) &= ~SVf_OOK;
1034     return 0;
1035 }
1036
1037 char *
1038 sv_grow(sv,newlen)
1039 register SV *sv;
1040 #ifndef DOSISH
1041 register I32 newlen;
1042 #else
1043 unsigned long newlen;
1044 #endif
1045 {
1046     register char *s;
1047
1048 #ifdef MSDOS
1049     if (newlen >= 0x10000) {
1050         PerlIO_printf(Perl_debug_log, "Allocation too large: %lx\n", newlen);
1051         my_exit(1);
1052     }
1053 #endif /* MSDOS */
1054     if (SvROK(sv))
1055         sv_unref(sv);
1056     if (SvTYPE(sv) < SVt_PV) {
1057         sv_upgrade(sv, SVt_PV);
1058         s = SvPVX(sv);
1059     }
1060     else if (SvOOK(sv)) {       /* pv is offset? */
1061         sv_backoff(sv);
1062         s = SvPVX(sv);
1063         if (newlen > SvLEN(sv))
1064             newlen += 10 * (newlen - SvCUR(sv)); /* avoid copy each time */
1065     }
1066     else
1067         s = SvPVX(sv);
1068     if (newlen > SvLEN(sv)) {           /* need more room? */
1069         if (SvLEN(sv) && s)
1070             Renew(s,newlen,char);
1071         else
1072             New(703,s,newlen,char);
1073         SvPV_set(sv, s);
1074         SvLEN_set(sv, newlen);
1075     }
1076     return s;
1077 }
1078
1079 void
1080 sv_setiv(sv,i)
1081 register SV *sv;
1082 IV i;
1083 {
1084     if (SvTHINKFIRST(sv)) {
1085         if (SvREADONLY(sv) && curcop != &compiling)
1086             croak(no_modify);
1087         if (SvROK(sv))
1088             sv_unref(sv);
1089     }
1090     switch (SvTYPE(sv)) {
1091     case SVt_NULL:
1092         sv_upgrade(sv, SVt_IV);
1093         break;
1094     case SVt_NV:
1095         sv_upgrade(sv, SVt_PVNV);
1096         break;
1097     case SVt_RV:
1098     case SVt_PV:
1099         sv_upgrade(sv, SVt_PVIV);
1100         break;
1101
1102     case SVt_PVGV:
1103         if (SvFAKE(sv)) {
1104             sv_unglob(sv);
1105             break;
1106         }
1107         /* FALL THROUGH */
1108     case SVt_PVAV:
1109     case SVt_PVHV:
1110     case SVt_PVCV:
1111     case SVt_PVFM:
1112     case SVt_PVIO:
1113         croak("Can't coerce %s to integer in %s", sv_reftype(sv,0),
1114             op_name[op->op_type]);
1115     }
1116     (void)SvIOK_only(sv);                       /* validate number */
1117     SvIVX(sv) = i;
1118     SvTAINT(sv);
1119 }
1120
1121 void
1122 sv_setnv(sv,num)
1123 register SV *sv;
1124 double num;
1125 {
1126     if (SvTHINKFIRST(sv)) {
1127         if (SvREADONLY(sv) && curcop != &compiling)
1128             croak(no_modify);
1129         if (SvROK(sv))
1130             sv_unref(sv);
1131     }
1132     switch (SvTYPE(sv)) {
1133     case SVt_NULL:
1134     case SVt_IV:
1135         sv_upgrade(sv, SVt_NV);
1136         break;
1137     case SVt_NV:
1138     case SVt_RV:
1139     case SVt_PV:
1140     case SVt_PVIV:
1141         sv_upgrade(sv, SVt_PVNV);
1142         /* FALL THROUGH */
1143     case SVt_PVNV:
1144     case SVt_PVMG:
1145     case SVt_PVBM:
1146     case SVt_PVLV:
1147         if (SvOOK(sv))
1148             (void)SvOOK_off(sv);
1149         break;
1150     case SVt_PVGV:
1151         if (SvFAKE(sv)) {
1152             sv_unglob(sv);
1153             break;
1154         }
1155         /* FALL THROUGH */
1156     case SVt_PVAV:
1157     case SVt_PVHV:
1158     case SVt_PVCV:
1159     case SVt_PVFM:
1160     case SVt_PVIO:
1161         croak("Can't coerce %s to number in %s", sv_reftype(sv,0),
1162             op_name[op->op_type]);
1163     }
1164     SvNVX(sv) = num;
1165     (void)SvNOK_only(sv);                       /* validate number */
1166     SvTAINT(sv);
1167 }
1168
1169 static void
1170 not_a_number(sv)
1171 SV *sv;
1172 {
1173     char tmpbuf[64];
1174     char *d = tmpbuf;
1175     char *s;
1176     int i;
1177
1178     for (s = SvPVX(sv), i = 50; *s && i; s++,i--) {
1179         int ch = *s;
1180         if (ch & 128 && !isprint(ch)) {
1181             *d++ = 'M';
1182             *d++ = '-';
1183             ch &= 127;
1184         }
1185         if (isprint(ch))
1186             *d++ = ch;
1187         else {
1188             *d++ = '^';
1189             *d++ = ch ^ 64;
1190         }
1191     }
1192     if (*s) {
1193         *d++ = '.';
1194         *d++ = '.';
1195         *d++ = '.';
1196     }
1197     *d = '\0';
1198
1199     if (op)
1200         warn("Argument \"%s\" isn't numeric in %s", tmpbuf,
1201                 op_name[op->op_type]);
1202     else
1203         warn("Argument \"%s\" isn't numeric", tmpbuf);
1204 }
1205
1206 IV
1207 sv_2iv(sv)
1208 register SV *sv;
1209 {
1210     if (!sv)
1211         return 0;
1212     if (SvGMAGICAL(sv)) {
1213         mg_get(sv);
1214         if (SvIOKp(sv))
1215             return SvIVX(sv);
1216         if (SvNOKp(sv)) {
1217             if (SvNVX(sv) < 0.0)
1218                 return I_V(SvNVX(sv));
1219             else
1220                 return (IV) U_V(SvNVX(sv));
1221         }
1222         if (SvPOKp(sv) && SvLEN(sv)) {
1223             if (dowarn && !looks_like_number(sv))
1224                 not_a_number(sv);
1225             return (IV)atol(SvPVX(sv));
1226         }
1227         if (!SvROK(sv)) {
1228             return 0;
1229         }
1230     }
1231     if (SvTHINKFIRST(sv)) {
1232         if (SvROK(sv)) {
1233 #ifdef OVERLOAD
1234           SV* tmpstr;
1235           if (SvAMAGIC(sv) && (tmpstr=AMG_CALLun(sv, numer)))
1236             return SvIV(tmpstr);
1237 #endif /* OVERLOAD */
1238           return (IV)SvRV(sv);
1239         }
1240         if (SvREADONLY(sv)) {
1241             if (SvNOKp(sv)) {
1242                 if (SvNVX(sv) < 0.0)
1243                     return I_V(SvNVX(sv));
1244                 else
1245                     return (IV) U_V(SvNVX(sv));
1246             }
1247             if (SvPOKp(sv) && SvLEN(sv)) {
1248                 if (dowarn && !looks_like_number(sv))
1249                     not_a_number(sv);
1250                 return (IV)atol(SvPVX(sv));
1251             }
1252             if (dowarn)
1253                 warn(warn_uninit);
1254             return 0;
1255         }
1256     }
1257     switch (SvTYPE(sv)) {
1258     case SVt_NULL:
1259         sv_upgrade(sv, SVt_IV);
1260         return SvIVX(sv);
1261     case SVt_PV:
1262         sv_upgrade(sv, SVt_PVIV);
1263         break;
1264     case SVt_NV:
1265         sv_upgrade(sv, SVt_PVNV);
1266         break;
1267     }
1268     if (SvNOKp(sv)) {
1269         (void)SvIOK_on(sv);
1270         if (SvNVX(sv) < 0.0)
1271             SvIVX(sv) = I_V(SvNVX(sv));
1272         else
1273             SvIVX(sv) = (IV) U_V(SvNVX(sv));
1274     }
1275     else if (SvPOKp(sv) && SvLEN(sv)) {
1276         if (dowarn && !looks_like_number(sv))
1277             not_a_number(sv);
1278         (void)SvIOK_on(sv);
1279         SvIVX(sv) = (IV)atol(SvPVX(sv));
1280     }
1281     else  {
1282         if (dowarn && !localizing && !(SvFLAGS(sv) & SVs_PADTMP))
1283             warn(warn_uninit);
1284         return 0;
1285     }
1286     (void)SvIOK_on(sv);
1287     DEBUG_c(PerlIO_printf(Perl_debug_log, "0x%lx 2iv(%ld)\n",
1288         (unsigned long)sv,(long)SvIVX(sv)));
1289     return SvIVX(sv);
1290 }
1291
1292 double
1293 sv_2nv(sv)
1294 register SV *sv;
1295 {
1296     if (!sv)
1297         return 0.0;
1298     if (SvGMAGICAL(sv)) {
1299         mg_get(sv);
1300         if (SvNOKp(sv))
1301             return SvNVX(sv);
1302         if (SvPOKp(sv) && SvLEN(sv)) {
1303             if (dowarn && !SvIOKp(sv) && !looks_like_number(sv))
1304                 not_a_number(sv);
1305             return atof(SvPVX(sv));
1306         }
1307         if (SvIOKp(sv))
1308             return (double)SvIVX(sv);
1309         if (!SvROK(sv)) {
1310             return 0;
1311         }
1312     }
1313     if (SvTHINKFIRST(sv)) {
1314         if (SvROK(sv)) {
1315 #ifdef OVERLOAD
1316           SV* tmpstr;
1317           if (SvAMAGIC(sv) && (tmpstr=AMG_CALLun(sv,numer)))
1318             return SvNV(tmpstr);
1319 #endif /* OVERLOAD */
1320           return (double)(unsigned long)SvRV(sv);
1321         }
1322         if (SvREADONLY(sv)) {
1323             if (SvPOKp(sv) && SvLEN(sv)) {
1324                 if (dowarn && !SvIOKp(sv) && !looks_like_number(sv))
1325                     not_a_number(sv);
1326                 return atof(SvPVX(sv));
1327             }
1328             if (SvIOKp(sv))
1329                 return (double)SvIVX(sv);
1330             if (dowarn)
1331                 warn(warn_uninit);
1332             return 0.0;
1333         }
1334     }
1335     if (SvTYPE(sv) < SVt_NV) {
1336         if (SvTYPE(sv) == SVt_IV)
1337             sv_upgrade(sv, SVt_PVNV);
1338         else
1339             sv_upgrade(sv, SVt_NV);
1340         DEBUG_c(PerlIO_printf(Perl_debug_log, "0x%lx num(%g)\n",(unsigned long)sv,SvNVX(sv)));
1341     }
1342     else if (SvTYPE(sv) < SVt_PVNV)
1343         sv_upgrade(sv, SVt_PVNV);
1344     if (SvIOKp(sv) &&
1345             (!SvPOKp(sv) || !strchr(SvPVX(sv),'.') || !looks_like_number(sv)))
1346     {
1347         SvNVX(sv) = (double)SvIVX(sv);
1348     }
1349     else if (SvPOKp(sv) && SvLEN(sv)) {
1350         if (dowarn && !SvIOKp(sv) && !looks_like_number(sv))
1351             not_a_number(sv);
1352         SvNVX(sv) = atof(SvPVX(sv));
1353     }
1354     else  {
1355         if (dowarn && !localizing && !(SvFLAGS(sv) & SVs_PADTMP))
1356             warn(warn_uninit);
1357         return 0.0;
1358     }
1359     SvNOK_on(sv);
1360     DEBUG_c(PerlIO_printf(Perl_debug_log, "0x%lx 2nv(%g)\n",(unsigned long)sv,SvNVX(sv)));
1361     return SvNVX(sv);
1362 }
1363
1364 char *
1365 sv_2pv(sv, lp)
1366 register SV *sv;
1367 STRLEN *lp;
1368 {
1369     register char *s;
1370     int olderrno;
1371
1372     if (!sv) {
1373         *lp = 0;
1374         return "";
1375     }
1376     if (SvGMAGICAL(sv)) {
1377         mg_get(sv);
1378         if (SvPOKp(sv)) {
1379             *lp = SvCUR(sv);
1380             return SvPVX(sv);
1381         }
1382         if (SvIOKp(sv)) {
1383             (void)sprintf(tokenbuf,"%ld",(long)SvIVX(sv));
1384             goto tokensave;
1385         }
1386         if (SvNOKp(sv)) {
1387             Gconvert(SvNVX(sv), DBL_DIG, 0, tokenbuf);
1388             goto tokensave;
1389         }
1390         if (!SvROK(sv)) {
1391             *lp = 0;
1392             return "";
1393         }
1394     }
1395     if (SvTHINKFIRST(sv)) {
1396         if (SvROK(sv)) {
1397 #ifdef OVERLOAD
1398             SV* tmpstr;
1399             if (SvAMAGIC(sv) && (tmpstr=AMG_CALLun(sv,string)))
1400               return SvPV(tmpstr,*lp);
1401 #endif /* OVERLOAD */
1402             sv = (SV*)SvRV(sv);
1403             if (!sv)
1404                 s = "NULLREF";
1405             else {
1406                 switch (SvTYPE(sv)) {
1407                 case SVt_NULL:
1408                 case SVt_IV:
1409                 case SVt_NV:
1410                 case SVt_RV:
1411                 case SVt_PV:
1412                 case SVt_PVIV:
1413                 case SVt_PVNV:
1414                 case SVt_PVBM:
1415                 case SVt_PVMG:  s = "SCALAR";                   break;
1416                 case SVt_PVLV:  s = "LVALUE";                   break;
1417                 case SVt_PVAV:  s = "ARRAY";                    break;
1418                 case SVt_PVHV:  s = "HASH";                     break;
1419                 case SVt_PVCV:  s = "CODE";                     break;
1420                 case SVt_PVGV:  s = "GLOB";                     break;
1421                 case SVt_PVFM:  s = "FORMATLINE";               break;
1422                 case SVt_PVIO:  s = "FILEHANDLE";               break;
1423                 default:        s = "UNKNOWN";                  break;
1424                 }
1425                 if (SvOBJECT(sv))
1426                     sprintf(tokenbuf, "%s=%s(0x%lx)",
1427                                 HvNAME(SvSTASH(sv)), s, (unsigned long)sv);
1428                 else
1429                     sprintf(tokenbuf, "%s(0x%lx)", s, (unsigned long)sv);
1430                 goto tokensaveref;
1431             }
1432             *lp = strlen(s);
1433             return s;
1434         }
1435         if (SvREADONLY(sv)) {
1436             if (SvNOKp(sv)) {
1437                 Gconvert(SvNVX(sv), DBL_DIG, 0, tokenbuf);
1438                 goto tokensave;
1439             }
1440             if (SvIOKp(sv)) {
1441                 (void)sprintf(tokenbuf,"%ld",(long)SvIVX(sv));
1442                 goto tokensave;
1443             }
1444             if (dowarn)
1445                 warn(warn_uninit);
1446             *lp = 0;
1447             return "";
1448         }
1449     }
1450     if (!SvUPGRADE(sv, SVt_PV))
1451         return 0;
1452     if (SvNOKp(sv)) {
1453         if (SvTYPE(sv) < SVt_PVNV)
1454             sv_upgrade(sv, SVt_PVNV);
1455         SvGROW(sv, 28);
1456         s = SvPVX(sv);
1457         olderrno = errno;       /* some Xenix systems wipe out errno here */
1458 #ifdef apollo
1459         if (SvNVX(sv) == 0.0)
1460             (void)strcpy(s,"0");
1461         else
1462 #endif /*apollo*/
1463             Gconvert(SvNVX(sv), DBL_DIG, 0, s);
1464         errno = olderrno;
1465 #ifdef FIXNEGATIVEZERO
1466         if (*s == '-' && s[1] == '0' && !s[2])
1467             strcpy(s,"0");
1468 #endif
1469         while (*s) s++;
1470 #ifdef hcx
1471         if (s[-1] == '.')
1472             s--;
1473 #endif
1474     }
1475     else if (SvIOKp(sv)) {
1476         if (SvTYPE(sv) < SVt_PVIV)
1477             sv_upgrade(sv, SVt_PVIV);
1478         SvGROW(sv, 11);
1479         s = SvPVX(sv);
1480         olderrno = errno;       /* some Xenix systems wipe out errno here */
1481         (void)sprintf(s,"%ld",(long)SvIVX(sv));
1482         errno = olderrno;
1483         while (*s) s++;
1484     }
1485     else {
1486         if (dowarn && !localizing && !(SvFLAGS(sv) & SVs_PADTMP))
1487             warn(warn_uninit);
1488         *lp = 0;
1489         return "";
1490     }
1491     *s = '\0';
1492     *lp = s - SvPVX(sv);
1493     SvCUR_set(sv, *lp);
1494     SvPOK_on(sv);
1495     DEBUG_c(PerlIO_printf(Perl_debug_log, "0x%lx 2pv(%s)\n",(unsigned long)sv,SvPVX(sv)));
1496     return SvPVX(sv);
1497
1498   tokensave:
1499     if (SvROK(sv)) {    /* XXX Skip this when sv_pvn_force calls */
1500         /* Sneaky stuff here */
1501
1502       tokensaveref:
1503         sv = sv_newmortal();
1504         *lp = strlen(tokenbuf);
1505         sv_setpvn(sv, tokenbuf, *lp);
1506         return SvPVX(sv);
1507     }
1508     else {
1509         STRLEN len;
1510         
1511 #ifdef FIXNEGATIVEZERO
1512         if (*tokenbuf == '-' && tokenbuf[1] == '0' && !tokenbuf[2])
1513             strcpy(tokenbuf,"0");
1514 #endif
1515         (void)SvUPGRADE(sv, SVt_PV);
1516         len = *lp = strlen(tokenbuf);
1517         s = SvGROW(sv, len + 1);
1518         SvCUR_set(sv, len);
1519         (void)strcpy(s, tokenbuf);
1520         /* NO SvPOK_on(sv) here! */
1521         return s;
1522     }
1523 }
1524
1525 /* This function is only called on magical items */
1526 bool
1527 sv_2bool(sv)
1528 register SV *sv;
1529 {
1530     if (SvGMAGICAL(sv))
1531         mg_get(sv);
1532
1533     if (!SvOK(sv))
1534         return 0;
1535     if (SvROK(sv)) {
1536 #ifdef OVERLOAD
1537       {
1538         SV* tmpsv;
1539         if (SvAMAGIC(sv) && (tmpsv = AMG_CALLun(sv,bool_)))
1540           return SvTRUE(tmpsv);
1541       }
1542 #endif /* OVERLOAD */
1543       return SvRV(sv) != 0;
1544     }
1545     if (SvPOKp(sv)) {
1546         register XPV* Xpv;
1547         if ((Xpv = (XPV*)SvANY(sv)) &&
1548                 (*Xpv->xpv_pv > '0' ||
1549                 Xpv->xpv_cur > 1 ||
1550                 (Xpv->xpv_cur && *Xpv->xpv_pv != '0')))
1551             return 1;
1552         else
1553             return 0;
1554     }
1555     else {
1556         if (SvIOKp(sv))
1557             return SvIVX(sv) != 0;
1558         else {
1559             if (SvNOKp(sv))
1560                 return SvNVX(sv) != 0.0;
1561             else
1562                 return FALSE;
1563         }
1564     }
1565 }
1566
1567 /* Note: sv_setsv() should not be called with a source string that needs
1568  * to be reused, since it may destroy the source string if it is marked
1569  * as temporary.
1570  */
1571
1572 void
1573 sv_setsv(dstr,sstr)
1574 SV *dstr;
1575 register SV *sstr;
1576 {
1577     register U32 sflags;
1578     register int dtype;
1579     register int stype;
1580
1581     if (sstr == dstr)
1582         return;
1583     if (SvTHINKFIRST(dstr)) {
1584         if (SvREADONLY(dstr) && curcop != &compiling)
1585             croak(no_modify);
1586         if (SvROK(dstr))
1587             sv_unref(dstr);
1588     }
1589     if (!sstr)
1590         sstr = &sv_undef;
1591     stype = SvTYPE(sstr);
1592     dtype = SvTYPE(dstr);
1593
1594     if (dtype == SVt_PVGV && (SvFLAGS(dstr) & SVf_FAKE)) {
1595         sv_unglob(dstr);     /* so fake GLOB won't perpetuate */
1596         sv_setpvn(dstr, "", 0);
1597         (void)SvPOK_only(dstr);
1598         dtype = SvTYPE(dstr);
1599     }
1600
1601 #ifdef OVERLOAD
1602     SvAMAGIC_off(dstr);
1603 #endif /* OVERLOAD */
1604     /* There's a lot of redundancy below but we're going for speed here */
1605
1606     switch (stype) {
1607     case SVt_NULL:
1608         (void)SvOK_off(dstr);
1609         return;
1610     case SVt_IV:
1611         if (dtype <= SVt_PV) {
1612             if (dtype < SVt_IV)
1613                 sv_upgrade(dstr, SVt_IV);
1614             else if (dtype == SVt_NV)
1615                 sv_upgrade(dstr, SVt_PVNV);
1616             else if (dtype <= SVt_PV)
1617                 sv_upgrade(dstr, SVt_PVIV);
1618         }
1619         break;
1620     case SVt_NV:
1621         if (dtype <= SVt_PVIV) {
1622             if (dtype < SVt_NV)
1623                 sv_upgrade(dstr, SVt_NV);
1624             else if (dtype == SVt_PVIV)
1625                 sv_upgrade(dstr, SVt_PVNV);
1626             else if (dtype <= SVt_PV)
1627                 sv_upgrade(dstr, SVt_PVNV);
1628         }
1629         break;
1630     case SVt_RV:
1631         if (dtype < SVt_RV)
1632             sv_upgrade(dstr, SVt_RV);
1633         else if (dtype == SVt_PVGV &&
1634                  SvTYPE(SvRV(sstr)) == SVt_PVGV) {
1635             sstr = SvRV(sstr);
1636             if (sstr == dstr) {
1637                 if (curcop->cop_stash != GvSTASH(dstr))
1638                     GvIMPORTED_on(dstr);
1639                 GvMULTI_on(dstr);
1640                 return;
1641             }
1642             goto glob_assign;
1643         }
1644         break;
1645     case SVt_PV:
1646         if (dtype < SVt_PV)
1647             sv_upgrade(dstr, SVt_PV);
1648         break;
1649     case SVt_PVIV:
1650         if (dtype < SVt_PVIV)
1651             sv_upgrade(dstr, SVt_PVIV);
1652         break;
1653     case SVt_PVNV:
1654         if (dtype < SVt_PVNV)
1655             sv_upgrade(dstr, SVt_PVNV);
1656         break;
1657
1658     case SVt_PVLV:
1659         sv_upgrade(dstr, SVt_PVLV);
1660         break;
1661
1662     case SVt_PVAV:
1663     case SVt_PVHV:
1664     case SVt_PVCV:
1665     case SVt_PVIO:
1666         if (op)
1667             croak("Bizarre copy of %s in %s", sv_reftype(sstr, 0),
1668                 op_name[op->op_type]);
1669         else
1670             croak("Bizarre copy of %s", sv_reftype(sstr, 0));
1671         break;
1672
1673     case SVt_PVGV:
1674         if (dtype <= SVt_PVGV) {
1675   glob_assign:
1676             if (dtype != SVt_PVGV) {
1677                 char *name = GvNAME(sstr);
1678                 STRLEN len = GvNAMELEN(sstr);
1679                 sv_upgrade(dstr, SVt_PVGV);
1680                 sv_magic(dstr, dstr, '*', name, len);
1681                 GvSTASH(dstr) = GvSTASH(sstr);
1682                 GvNAME(dstr) = savepvn(name, len);
1683                 GvNAMELEN(dstr) = len;
1684                 SvFAKE_on(dstr);        /* can coerce to non-glob */
1685             }
1686             (void)SvOK_off(dstr);
1687             GvINTRO_off(dstr);          /* one-shot flag */
1688             gp_free((GV*)dstr);
1689             GvGP(dstr) = gp_ref(GvGP(sstr));
1690             SvTAINT(dstr);
1691             if (curcop->cop_stash != GvSTASH(dstr))
1692                 GvIMPORTED_on(dstr);
1693             GvMULTI_on(dstr);
1694             return;
1695         }
1696         /* FALL THROUGH */
1697
1698     default:
1699         if (dtype < stype)
1700             sv_upgrade(dstr, stype);
1701         if (SvGMAGICAL(sstr))
1702             mg_get(sstr);
1703     }
1704
1705     sflags = SvFLAGS(sstr);
1706
1707     if (sflags & SVf_ROK) {
1708         if (dtype >= SVt_PV) {
1709             if (dtype == SVt_PVGV) {
1710                 SV *sref = SvREFCNT_inc(SvRV(sstr));
1711                 SV *dref = 0;
1712                 int intro = GvINTRO(dstr);
1713
1714                 if (intro) {
1715                     GP *gp;
1716                     GvGP(dstr)->gp_refcnt--;
1717                     GvINTRO_off(dstr);  /* one-shot flag */
1718                     Newz(602,gp, 1, GP);
1719                     GvGP(dstr) = gp;
1720                     GvREFCNT(dstr) = 1;
1721                     GvSV(dstr) = NEWSV(72,0);
1722                     GvLINE(dstr) = curcop->cop_line;
1723                     GvEGV(dstr) = (GV*)dstr;
1724                 }
1725                 GvMULTI_on(dstr);
1726                 switch (SvTYPE(sref)) {
1727                 case SVt_PVAV:
1728                     if (intro)
1729                         SAVESPTR(GvAV(dstr));
1730                     else
1731                         dref = (SV*)GvAV(dstr);
1732                     GvAV(dstr) = (AV*)sref;
1733                     if (curcop->cop_stash != GvSTASH(dstr))
1734                         GvIMPORTED_AV_on(dstr);
1735                     break;
1736                 case SVt_PVHV:
1737                     if (intro)
1738                         SAVESPTR(GvHV(dstr));
1739                     else
1740                         dref = (SV*)GvHV(dstr);
1741                     GvHV(dstr) = (HV*)sref;
1742                     if (curcop->cop_stash != GvSTASH(dstr))
1743                         GvIMPORTED_HV_on(dstr);
1744                     break;
1745                 case SVt_PVCV:
1746                     if (intro)
1747                         SAVESPTR(GvCV(dstr));
1748                     else {
1749                         CV* cv = GvCV(dstr);
1750                         if (cv) {
1751                             dref = (SV*)cv;
1752                             if (dowarn && sref != dref &&
1753                                     !GvCVGEN((GV*)dstr) &&
1754                                     (CvROOT(cv) || CvXSUB(cv)) )
1755                                 warn("Subroutine %s redefined",
1756                                     GvENAME((GV*)dstr));
1757                             SvFAKE_on(cv);
1758                         }
1759                     }
1760                     if (GvCV(dstr) != (CV*)sref) {
1761                         GvCV(dstr) = (CV*)sref;
1762                         GvASSUMECV_on(dstr);
1763                     }
1764                     if (curcop->cop_stash != GvSTASH(dstr))
1765                         GvIMPORTED_CV_on(dstr);
1766                     break;
1767                 case SVt_PVIO:
1768                     if (intro)
1769                         SAVESPTR(GvIOp(dstr));
1770                     else
1771                         dref = (SV*)GvIOp(dstr);
1772                     GvIOp(dstr) = (IO*)sref;
1773                     break;
1774                 default:
1775                     if (intro)
1776                         SAVESPTR(GvSV(dstr));
1777                     else
1778                         dref = (SV*)GvSV(dstr);
1779                     GvSV(dstr) = sref;
1780                     if (curcop->cop_stash != GvSTASH(dstr))
1781                         GvIMPORTED_SV_on(dstr);
1782                     break;
1783                 }
1784                 if (dref)
1785                     SvREFCNT_dec(dref);
1786                 if (intro)
1787                     SAVEFREESV(sref);
1788                 SvTAINT(dstr);
1789                 return;
1790             }
1791             if (SvPVX(dstr)) {
1792                 (void)SvOOK_off(dstr);          /* backoff */
1793                 Safefree(SvPVX(dstr));
1794                 SvLEN(dstr)=SvCUR(dstr)=0;
1795             }
1796         }
1797         (void)SvOK_off(dstr);
1798         SvRV(dstr) = SvREFCNT_inc(SvRV(sstr));
1799         SvROK_on(dstr);
1800         if (sflags & SVp_NOK) {
1801             SvNOK_on(dstr);
1802             SvNVX(dstr) = SvNVX(sstr);
1803         }
1804         if (sflags & SVp_IOK) {
1805             (void)SvIOK_on(dstr);
1806             SvIVX(dstr) = SvIVX(sstr);
1807         }
1808 #ifdef OVERLOAD
1809         if (SvAMAGIC(sstr)) {
1810             SvAMAGIC_on(dstr);
1811         }
1812 #endif /* OVERLOAD */
1813     }
1814     else if (sflags & SVp_POK) {
1815
1816         /*
1817          * Check to see if we can just swipe the string.  If so, it's a
1818          * possible small lose on short strings, but a big win on long ones.
1819          * It might even be a win on short strings if SvPVX(dstr)
1820          * has to be allocated and SvPVX(sstr) has to be freed.
1821          */
1822
1823         if (SvTEMP(sstr) &&             /* slated for free anyway? */
1824             !(sflags & SVf_OOK))        /* and not involved in OOK hack? */
1825         {
1826             if (SvPVX(dstr)) {          /* we know that dtype >= SVt_PV */
1827                 if (SvOOK(dstr)) {
1828                     SvFLAGS(dstr) &= ~SVf_OOK;
1829                     Safefree(SvPVX(dstr) - SvIVX(dstr));
1830                 }
1831                 else
1832                     Safefree(SvPVX(dstr));
1833             }
1834             (void)SvPOK_only(dstr);
1835             SvPV_set(dstr, SvPVX(sstr));
1836             SvLEN_set(dstr, SvLEN(sstr));
1837             SvCUR_set(dstr, SvCUR(sstr));
1838             SvTEMP_off(dstr);
1839             (void)SvOK_off(sstr);
1840             SvPV_set(sstr, Nullch);
1841             SvLEN_set(sstr, 0);
1842             SvCUR_set(sstr, 0);
1843             SvTEMP_off(sstr);
1844         }
1845         else {                                  /* have to copy actual string */
1846             STRLEN len = SvCUR(sstr);
1847
1848             SvGROW(dstr, len + 1);              /* inlined from sv_setpvn */
1849             Move(SvPVX(sstr),SvPVX(dstr),len,char);
1850             SvCUR_set(dstr, len);
1851             *SvEND(dstr) = '\0';
1852             (void)SvPOK_only(dstr);
1853         }
1854         /*SUPPRESS 560*/
1855         if (sflags & SVp_NOK) {
1856             SvNOK_on(dstr);
1857             SvNVX(dstr) = SvNVX(sstr);
1858         }
1859         if (sflags & SVp_IOK) {
1860             (void)SvIOK_on(dstr);
1861             SvIVX(dstr) = SvIVX(sstr);
1862         }
1863     }
1864     else if (sflags & SVp_NOK) {
1865         SvNVX(dstr) = SvNVX(sstr);
1866         (void)SvNOK_only(dstr);
1867         if (SvIOK(sstr)) {
1868             (void)SvIOK_on(dstr);
1869             SvIVX(dstr) = SvIVX(sstr);
1870         }
1871     }
1872     else if (sflags & SVp_IOK) {
1873         (void)SvIOK_only(dstr);
1874         SvIVX(dstr) = SvIVX(sstr);
1875     }
1876     else {
1877         (void)SvOK_off(dstr);
1878     }
1879     SvTAINT(dstr);
1880 }
1881
1882 void
1883 sv_setpvn(sv,ptr,len)
1884 register SV *sv;
1885 register char *ptr;
1886 register STRLEN len;
1887 {
1888     assert(len >= 0);  /* STRLEN is probably unsigned, so this may
1889                           elicit a warning, but it won't hurt. */
1890     if (SvTHINKFIRST(sv)) {
1891         if (SvREADONLY(sv) && curcop != &compiling)
1892             croak(no_modify);
1893         if (SvROK(sv))
1894             sv_unref(sv);
1895     }
1896     if (!ptr) {
1897         (void)SvOK_off(sv);
1898         return;
1899     }
1900     if (SvTYPE(sv) >= SVt_PV) {
1901         if (SvFAKE(sv) && SvTYPE(sv) == SVt_PVGV)
1902             sv_unglob(sv);
1903     }
1904     else if (!sv_upgrade(sv, SVt_PV))
1905         return;
1906     SvGROW(sv, len + 1);
1907     Move(ptr,SvPVX(sv),len,char);
1908     SvCUR_set(sv, len);
1909     *SvEND(sv) = '\0';
1910     (void)SvPOK_only(sv);               /* validate pointer */
1911     SvTAINT(sv);
1912 }
1913
1914 void
1915 sv_setpv(sv,ptr)
1916 register SV *sv;
1917 register char *ptr;
1918 {
1919     register STRLEN len;
1920
1921     if (SvTHINKFIRST(sv)) {
1922         if (SvREADONLY(sv) && curcop != &compiling)
1923             croak(no_modify);
1924         if (SvROK(sv))
1925             sv_unref(sv);
1926     }
1927     if (!ptr) {
1928         (void)SvOK_off(sv);
1929         return;
1930     }
1931     len = strlen(ptr);
1932     if (SvTYPE(sv) >= SVt_PV) {
1933         if (SvFAKE(sv) && SvTYPE(sv) == SVt_PVGV)
1934             sv_unglob(sv);
1935     }
1936     else if (!sv_upgrade(sv, SVt_PV))
1937         return;
1938     SvGROW(sv, len + 1);
1939     Move(ptr,SvPVX(sv),len+1,char);
1940     SvCUR_set(sv, len);
1941     (void)SvPOK_only(sv);               /* validate pointer */
1942     SvTAINT(sv);
1943 }
1944
1945 void
1946 sv_usepvn(sv,ptr,len)
1947 register SV *sv;
1948 register char *ptr;
1949 register STRLEN len;
1950 {
1951     if (SvTHINKFIRST(sv)) {
1952         if (SvREADONLY(sv) && curcop != &compiling)
1953             croak(no_modify);
1954         if (SvROK(sv))
1955             sv_unref(sv);
1956     }
1957     if (!SvUPGRADE(sv, SVt_PV))
1958         return;
1959     if (!ptr) {
1960         (void)SvOK_off(sv);
1961         return;
1962     }
1963     if (SvPVX(sv))
1964         Safefree(SvPVX(sv));
1965     Renew(ptr, len+1, char);
1966     SvPVX(sv) = ptr;
1967     SvCUR_set(sv, len);
1968     SvLEN_set(sv, len+1);
1969     *SvEND(sv) = '\0';
1970     (void)SvPOK_only(sv);               /* validate pointer */
1971     SvTAINT(sv);
1972 }
1973
1974 void
1975 sv_chop(sv,ptr) /* like set but assuming ptr is in sv */
1976 register SV *sv;
1977 register char *ptr;
1978 {
1979     register STRLEN delta;
1980
1981     if (!ptr || !SvPOKp(sv))
1982         return;
1983     if (SvTHINKFIRST(sv)) {
1984         if (SvREADONLY(sv) && curcop != &compiling)
1985             croak(no_modify);
1986         if (SvROK(sv))
1987             sv_unref(sv);
1988     }
1989     if (SvTYPE(sv) < SVt_PVIV)
1990         sv_upgrade(sv,SVt_PVIV);
1991
1992     if (!SvOOK(sv)) {
1993         SvIVX(sv) = 0;
1994         SvFLAGS(sv) |= SVf_OOK;
1995     }
1996     SvFLAGS(sv) &= ~(SVf_IOK|SVf_NOK|SVp_IOK|SVp_NOK);
1997     delta = ptr - SvPVX(sv);
1998     SvLEN(sv) -= delta;
1999     SvCUR(sv) -= delta;
2000     SvPVX(sv) += delta;
2001     SvIVX(sv) += delta;
2002 }
2003
2004 void
2005 sv_catpvn(sv,ptr,len)
2006 register SV *sv;
2007 register char *ptr;
2008 register STRLEN len;
2009 {
2010     STRLEN tlen;
2011     char *junk;
2012
2013     junk = SvPV_force(sv, tlen);
2014     SvGROW(sv, tlen + len + 1);
2015     if (ptr == junk)
2016         ptr = SvPVX(sv);
2017     Move(ptr,SvPVX(sv)+tlen,len,char);
2018     SvCUR(sv) += len;
2019     *SvEND(sv) = '\0';
2020     (void)SvPOK_only(sv);               /* validate pointer */
2021     SvTAINT(sv);
2022 }
2023
2024 void
2025 sv_catsv(dstr,sstr)
2026 SV *dstr;
2027 register SV *sstr;
2028 {
2029     char *s;
2030     STRLEN len;
2031     if (!sstr)
2032         return;
2033     if (s = SvPV(sstr, len))
2034         sv_catpvn(dstr,s,len);
2035 }
2036
2037 void
2038 sv_catpv(sv,ptr)
2039 register SV *sv;
2040 register char *ptr;
2041 {
2042     register STRLEN len;
2043     STRLEN tlen;
2044     char *junk;
2045
2046     if (!ptr)
2047         return;
2048     junk = SvPV_force(sv, tlen);
2049     len = strlen(ptr);
2050     SvGROW(sv, tlen + len + 1);
2051     if (ptr == junk)
2052         ptr = SvPVX(sv);
2053     Move(ptr,SvPVX(sv)+tlen,len+1,char);
2054     SvCUR(sv) += len;
2055     (void)SvPOK_only(sv);               /* validate pointer */
2056     SvTAINT(sv);
2057 }
2058
2059 SV *
2060 #ifdef LEAKTEST
2061 newSV(x,len)
2062 I32 x;
2063 #else
2064 newSV(len)
2065 #endif
2066 STRLEN len;
2067 {
2068     register SV *sv;
2069     
2070     new_SV(sv);
2071     SvANY(sv) = 0;
2072     SvREFCNT(sv) = 1;
2073     SvFLAGS(sv) = 0;
2074     if (len) {
2075         sv_upgrade(sv, SVt_PV);
2076         SvGROW(sv, len + 1);
2077     }
2078     return sv;
2079 }
2080
2081 /* name is assumed to contain an SV* if (name && namelen == HEf_SVKEY) */
2082
2083 void
2084 sv_magic(sv, obj, how, name, namlen)
2085 register SV *sv;
2086 SV *obj;
2087 int how;
2088 char *name;
2089 I32 namlen;
2090 {
2091     MAGIC* mg;
2092     
2093     if (SvREADONLY(sv) && curcop != &compiling && !strchr("gB", how))
2094         croak(no_modify);
2095     if (SvMAGICAL(sv) || (how == 't' && SvTYPE(sv) >= SVt_PVMG)) {
2096         if (SvMAGIC(sv) && (mg = mg_find(sv, how))) {
2097             if (how == 't')
2098                 mg->mg_len |= 1;
2099             return;
2100         }
2101     }
2102     else {
2103         if (!SvUPGRADE(sv, SVt_PVMG))
2104             return;
2105     }
2106     Newz(702,mg, 1, MAGIC);
2107     mg->mg_moremagic = SvMAGIC(sv);
2108
2109     SvMAGIC(sv) = mg;
2110     if (!obj || obj == sv || how == '#')
2111         mg->mg_obj = obj;
2112     else {
2113         mg->mg_obj = SvREFCNT_inc(obj);
2114         mg->mg_flags |= MGf_REFCOUNTED;
2115     }
2116     mg->mg_type = how;
2117     mg->mg_len = namlen;
2118     if (name)
2119         if (namlen >= 0)
2120             mg->mg_ptr = savepvn(name, namlen);
2121         else if (namlen == HEf_SVKEY)
2122             mg->mg_ptr = (char*)SvREFCNT_inc((SV*)name);
2123     
2124     switch (how) {
2125     case 0:
2126         mg->mg_virtual = &vtbl_sv;
2127         break;
2128 #ifdef OVERLOAD
2129     case 'A':
2130         mg->mg_virtual = &vtbl_amagic;
2131         break;
2132     case 'a':
2133         mg->mg_virtual = &vtbl_amagicelem;
2134         break;
2135     case 'c':
2136         mg->mg_virtual = 0;
2137         break;
2138 #endif /* OVERLOAD */
2139     case 'B':
2140         mg->mg_virtual = &vtbl_bm;
2141         break;
2142     case 'E':
2143         mg->mg_virtual = &vtbl_env;
2144         break;
2145     case 'e':
2146         mg->mg_virtual = &vtbl_envelem;
2147         break;
2148     case 'g':
2149         mg->mg_virtual = &vtbl_mglob;
2150         break;
2151     case 'I':
2152         mg->mg_virtual = &vtbl_isa;
2153         break;
2154     case 'i':
2155         mg->mg_virtual = &vtbl_isaelem;
2156         break;
2157     case 'L':
2158         SvRMAGICAL_on(sv);
2159         mg->mg_virtual = 0;
2160         break;
2161     case 'l':
2162         mg->mg_virtual = &vtbl_dbline;
2163         break;
2164     case 'P':
2165         mg->mg_virtual = &vtbl_pack;
2166         break;
2167     case 'p':
2168     case 'q':
2169         mg->mg_virtual = &vtbl_packelem;
2170         break;
2171     case 'S':
2172         mg->mg_virtual = &vtbl_sig;
2173         break;
2174     case 's':
2175         mg->mg_virtual = &vtbl_sigelem;
2176         break;
2177     case 't':
2178         mg->mg_virtual = &vtbl_taint;
2179         mg->mg_len = 1;
2180         break;
2181     case 'U':
2182         mg->mg_virtual = &vtbl_uvar;
2183         break;
2184     case 'v':
2185         mg->mg_virtual = &vtbl_vec;
2186         break;
2187     case 'x':
2188         mg->mg_virtual = &vtbl_substr;
2189         break;
2190     case '*':
2191         mg->mg_virtual = &vtbl_glob;
2192         break;
2193     case '#':
2194         mg->mg_virtual = &vtbl_arylen;
2195         break;
2196     case '.':
2197         mg->mg_virtual = &vtbl_pos;
2198         break;
2199     case '~':   /* Reserved for use by extensions not perl internals.   */
2200         /* Useful for attaching extension internal data to perl vars.   */
2201         /* Note that multiple extensions may clash if magical scalars   */
2202         /* etc holding private data from one are passed to another.     */
2203         SvRMAGICAL_on(sv);
2204         break;
2205     default:
2206         croak("Don't know how to handle magic of type '%c'", how);
2207     }
2208     mg_magical(sv);
2209     if (SvGMAGICAL(sv))
2210         SvFLAGS(sv) &= ~(SVf_IOK|SVf_NOK|SVf_POK);
2211 }
2212
2213 int
2214 sv_unmagic(sv, type)
2215 SV* sv;
2216 int type;
2217 {
2218     MAGIC* mg;
2219     MAGIC** mgp;
2220     if (SvTYPE(sv) < SVt_PVMG || !SvMAGIC(sv))
2221         return 0;
2222     mgp = &SvMAGIC(sv);
2223     for (mg = *mgp; mg; mg = *mgp) {
2224         if (mg->mg_type == type) {
2225             MGVTBL* vtbl = mg->mg_virtual;
2226             *mgp = mg->mg_moremagic;
2227             if (vtbl && vtbl->svt_free)
2228                 (*vtbl->svt_free)(sv, mg);
2229             if (mg->mg_ptr && mg->mg_type != 'g')
2230                 if (mg->mg_len >= 0)
2231                     Safefree(mg->mg_ptr);
2232                 else if (mg->mg_len == HEf_SVKEY)
2233                     SvREFCNT_dec((SV*)mg->mg_ptr);
2234             if (mg->mg_flags & MGf_REFCOUNTED)
2235                 SvREFCNT_dec(mg->mg_obj);
2236             Safefree(mg);
2237         }
2238         else
2239             mgp = &mg->mg_moremagic;
2240     }
2241     if (!SvMAGIC(sv)) {
2242         SvMAGICAL_off(sv);
2243         SvFLAGS(sv) |= (SvFLAGS(sv) & (SVp_IOK|SVp_NOK|SVp_POK)) >> PRIVSHIFT;
2244     }
2245
2246     return 0;
2247 }
2248
2249 void
2250 sv_insert(bigstr,offset,len,little,littlelen)
2251 SV *bigstr;
2252 STRLEN offset;
2253 STRLEN len;
2254 char *little;
2255 STRLEN littlelen;
2256 {
2257     register char *big;
2258     register char *mid;
2259     register char *midend;
2260     register char *bigend;
2261     register I32 i;
2262
2263     if (!bigstr)
2264         croak("Can't modify non-existent substring");
2265     SvPV_force(bigstr, na);
2266
2267     i = littlelen - len;
2268     if (i > 0) {                        /* string might grow */
2269         big = SvGROW(bigstr, SvCUR(bigstr) + i + 1);
2270         mid = big + offset + len;
2271         midend = bigend = big + SvCUR(bigstr);
2272         bigend += i;
2273         *bigend = '\0';
2274         while (midend > mid)            /* shove everything down */
2275             *--bigend = *--midend;
2276         Move(little,big+offset,littlelen,char);
2277         SvCUR(bigstr) += i;
2278         SvSETMAGIC(bigstr);
2279         return;
2280     }
2281     else if (i == 0) {
2282         Move(little,SvPVX(bigstr)+offset,len,char);
2283         SvSETMAGIC(bigstr);
2284         return;
2285     }
2286
2287     big = SvPVX(bigstr);
2288     mid = big + offset;
2289     midend = mid + len;
2290     bigend = big + SvCUR(bigstr);
2291
2292     if (midend > bigend)
2293         croak("panic: sv_insert");
2294
2295     if (mid - big > bigend - midend) {  /* faster to shorten from end */
2296         if (littlelen) {
2297             Move(little, mid, littlelen,char);
2298             mid += littlelen;
2299         }
2300         i = bigend - midend;
2301         if (i > 0) {
2302             Move(midend, mid, i,char);
2303             mid += i;
2304         }
2305         *mid = '\0';
2306         SvCUR_set(bigstr, mid - big);
2307     }
2308     /*SUPPRESS 560*/
2309     else if (i = mid - big) {   /* faster from front */
2310         midend -= littlelen;
2311         mid = midend;
2312         sv_chop(bigstr,midend-i);
2313         big += i;
2314         while (i--)
2315             *--midend = *--big;
2316         if (littlelen)
2317             Move(little, mid, littlelen,char);
2318     }
2319     else if (littlelen) {
2320         midend -= littlelen;
2321         sv_chop(bigstr,midend);
2322         Move(little,midend,littlelen,char);
2323     }
2324     else {
2325         sv_chop(bigstr,midend);
2326     }
2327     SvSETMAGIC(bigstr);
2328 }
2329
2330 /* make sv point to what nstr did */
2331
2332 void
2333 sv_replace(sv,nsv)
2334 register SV *sv;
2335 register SV *nsv;
2336 {
2337     U32 refcnt = SvREFCNT(sv);
2338     if (SvTHINKFIRST(sv)) {
2339         if (SvREADONLY(sv) && curcop != &compiling)
2340             croak(no_modify);
2341         if (SvROK(sv))
2342             sv_unref(sv);
2343     }
2344     if (SvREFCNT(nsv) != 1)
2345         warn("Reference miscount in sv_replace()");
2346     if (SvMAGICAL(sv)) {
2347         if (SvMAGICAL(nsv))
2348             mg_free(nsv);
2349         else
2350             sv_upgrade(nsv, SVt_PVMG);
2351         SvMAGIC(nsv) = SvMAGIC(sv);
2352         SvFLAGS(nsv) |= SvMAGICAL(sv);
2353         SvMAGICAL_off(sv);
2354         SvMAGIC(sv) = 0;
2355     }
2356     SvREFCNT(sv) = 0;
2357     sv_clear(sv);
2358     StructCopy(nsv,sv,SV);
2359     SvREFCNT(sv) = refcnt;
2360     SvFLAGS(nsv) |= SVTYPEMASK;         /* Mark as freed */
2361     del_SV(nsv);
2362 }
2363
2364 void
2365 sv_clear(sv)
2366 register SV *sv;
2367 {
2368     assert(sv);
2369     assert(SvREFCNT(sv) == 0);
2370
2371     if (SvOBJECT(sv)) {
2372         dSP;
2373         GV* destructor;
2374
2375         if (defstash) {         /* Still have a symbol table? */
2376             destructor = gv_fetchmethod(SvSTASH(sv), "DESTROY");
2377
2378             ENTER;
2379             SAVEFREESV(SvSTASH(sv));
2380             if (destructor && GvCV(destructor)) {
2381                 SV ref;
2382
2383                 Zero(&ref, 1, SV);
2384                 sv_upgrade(&ref, SVt_RV);
2385                 SvRV(&ref) = SvREFCNT_inc(sv);
2386                 SvROK_on(&ref);
2387
2388                 EXTEND(SP, 2);
2389                 PUSHMARK(SP);
2390                 PUSHs(&ref);
2391                 PUTBACK;
2392                 perl_call_sv((SV*)destructor, G_DISCARD|G_EVAL|G_KEEPERR);
2393                 del_XRV(SvANY(&ref));
2394                 SvREFCNT(sv)--;
2395             }
2396             LEAVE;
2397         }
2398         else
2399             SvREFCNT_dec(SvSTASH(sv));
2400         if (SvOBJECT(sv)) {
2401             SvOBJECT_off(sv);   /* Curse the object. */
2402             if (SvTYPE(sv) != SVt_PVIO)
2403                 --sv_objcount;  /* XXX Might want something more general */
2404         }
2405         if (SvREFCNT(sv)) {
2406             SV *ret;  
2407             if ( perldb
2408                  && (ret = perl_get_sv("DB::ret", FALSE))
2409                  && SvROK(ret) && SvRV(ret) == sv && SvREFCNT(sv) == 1) {
2410                 /* Debugger is prone to dangling references. */
2411                 SvRV(ret) = 0;
2412                 SvROK_off(ret);
2413                 SvREFCNT(sv) = 0;
2414             } else {
2415                 croak("panic: dangling references in DESTROY");
2416             }
2417         }
2418     }
2419     if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv))
2420         mg_free(sv);
2421     switch (SvTYPE(sv)) {
2422     case SVt_PVIO:
2423         io_close((IO*)sv);
2424         Safefree(IoTOP_NAME(sv));
2425         Safefree(IoFMT_NAME(sv));
2426         Safefree(IoBOTTOM_NAME(sv));
2427         /* FALL THROUGH */
2428     case SVt_PVBM:
2429         goto freescalar;
2430     case SVt_PVCV:
2431     case SVt_PVFM:
2432         cv_undef((CV*)sv);
2433         goto freescalar;
2434     case SVt_PVHV:
2435         hv_undef((HV*)sv);
2436         break;
2437     case SVt_PVAV:
2438         av_undef((AV*)sv);
2439         break;
2440     case SVt_PVGV:
2441         gp_free((GV*)sv);
2442         Safefree(GvNAME(sv));
2443         /* FALL THROUGH */
2444     case SVt_PVLV:
2445     case SVt_PVMG:
2446     case SVt_PVNV:
2447     case SVt_PVIV:
2448       freescalar:
2449         (void)SvOOK_off(sv);
2450         /* FALL THROUGH */
2451     case SVt_PV:
2452     case SVt_RV:
2453         if (SvROK(sv))
2454             SvREFCNT_dec(SvRV(sv));
2455         else if (SvPVX(sv) && SvLEN(sv))
2456             Safefree(SvPVX(sv));
2457         break;
2458 /*
2459     case SVt_NV:
2460     case SVt_IV:
2461     case SVt_NULL:
2462         break;
2463 */
2464     }
2465
2466     switch (SvTYPE(sv)) {
2467     case SVt_NULL:
2468         break;
2469     case SVt_IV:
2470         del_XIV(SvANY(sv));
2471         break;
2472     case SVt_NV:
2473         del_XNV(SvANY(sv));
2474         break;
2475     case SVt_RV:
2476         del_XRV(SvANY(sv));
2477         break;
2478     case SVt_PV:
2479         del_XPV(SvANY(sv));
2480         break;
2481     case SVt_PVIV:
2482         del_XPVIV(SvANY(sv));
2483         break;
2484     case SVt_PVNV:
2485         del_XPVNV(SvANY(sv));
2486         break;
2487     case SVt_PVMG:
2488         del_XPVMG(SvANY(sv));
2489         break;
2490     case SVt_PVLV:
2491         del_XPVLV(SvANY(sv));
2492         break;
2493     case SVt_PVAV:
2494         del_XPVAV(SvANY(sv));
2495         break;
2496     case SVt_PVHV:
2497         del_XPVHV(SvANY(sv));
2498         break;
2499     case SVt_PVCV:
2500         del_XPVCV(SvANY(sv));
2501         break;
2502     case SVt_PVGV:
2503         del_XPVGV(SvANY(sv));
2504         break;
2505     case SVt_PVBM:
2506         del_XPVBM(SvANY(sv));
2507         break;
2508     case SVt_PVFM:
2509         del_XPVFM(SvANY(sv));
2510         break;
2511     case SVt_PVIO:
2512         del_XPVIO(SvANY(sv));
2513         break;
2514     }
2515     SvFLAGS(sv) &= SVf_BREAK;
2516     SvFLAGS(sv) |= SVTYPEMASK;
2517 }
2518
2519 SV *
2520 sv_newref(sv)
2521 SV* sv;
2522 {
2523     if (sv)
2524         SvREFCNT(sv)++;
2525     return sv;
2526 }
2527
2528 void
2529 sv_free(sv)
2530 SV *sv;
2531 {
2532     if (!sv)
2533         return;
2534     if (SvREADONLY(sv)) {
2535         if (sv == &sv_undef || sv == &sv_yes || sv == &sv_no)
2536             return;
2537     }
2538     if (SvREFCNT(sv) == 0) {
2539         if (SvFLAGS(sv) & SVf_BREAK)
2540             return;
2541         if (in_clean_all) /* All is fair */
2542             return;
2543         warn("Attempt to free unreferenced scalar");
2544         return;
2545     }
2546     if (--SvREFCNT(sv) > 0)
2547         return;
2548 #ifdef DEBUGGING
2549     if (SvTEMP(sv)) {
2550         warn("Attempt to free temp prematurely");
2551         return;
2552     }
2553 #endif
2554     sv_clear(sv);
2555     del_SV(sv);
2556 }
2557
2558 STRLEN
2559 sv_len(sv)
2560 register SV *sv;
2561 {
2562     char *junk;
2563     STRLEN len;
2564
2565     if (!sv)
2566         return 0;
2567
2568     if (SvGMAGICAL(sv))
2569         len = mg_len(sv);
2570     else
2571         junk = SvPV(sv, len);
2572     return len;
2573 }
2574
2575 I32
2576 sv_eq(str1,str2)
2577 register SV *str1;
2578 register SV *str2;
2579 {
2580     char *pv1;
2581     STRLEN cur1;
2582     char *pv2;
2583     STRLEN cur2;
2584
2585     if (!str1) {
2586         pv1 = "";
2587         cur1 = 0;
2588     }
2589     else
2590         pv1 = SvPV(str1, cur1);
2591
2592     if (!str2)
2593         return !cur1;
2594     else
2595         pv2 = SvPV(str2, cur2);
2596
2597     if (cur1 != cur2)
2598         return 0;
2599
2600     return !memcmp(pv1, pv2, cur1);
2601 }
2602
2603 I32
2604 sv_cmp(str1,str2)
2605 register SV *str1;
2606 register SV *str2;
2607 {
2608     I32 retval;
2609     char *pv1;
2610     STRLEN cur1;
2611     char *pv2;
2612     STRLEN cur2;
2613
2614     if (!str1) {
2615         pv1 = "";
2616         cur1 = 0;
2617     }
2618     else
2619         pv1 = SvPV(str1, cur1);
2620
2621     if (!str2) {
2622         pv2 = "";
2623         cur2 = 0;
2624     }
2625     else
2626         pv2 = SvPV(str2, cur2);
2627
2628     if (!cur1)
2629         return cur2 ? -1 : 0;
2630     if (!cur2)
2631         return 1;
2632
2633     if (cur1 < cur2) {
2634         /*SUPPRESS 560*/
2635         if (retval = memcmp((void*)pv1, (void*)pv2, cur1))
2636             return retval < 0 ? -1 : 1;
2637         else
2638             return -1;
2639     }
2640     /*SUPPRESS 560*/
2641     else if (retval = memcmp((void*)pv1, (void*)pv2, cur2))
2642         return retval < 0 ? -1 : 1;
2643     else if (cur1 == cur2)
2644         return 0;
2645     else
2646         return 1;
2647 }
2648
2649 char *
2650 sv_gets(sv,fp,append)
2651 register SV *sv;
2652 register PerlIO *fp;
2653 I32 append;
2654 {
2655     char *rsptr;
2656     STRLEN rslen;
2657     register STDCHAR rslast;
2658     register STDCHAR *bp;
2659     register I32 cnt;
2660     I32 i;
2661
2662     if (SvTHINKFIRST(sv)) {
2663         if (SvREADONLY(sv) && curcop != &compiling)
2664             croak(no_modify);
2665         if (SvROK(sv))
2666             sv_unref(sv);
2667     }
2668     if (!SvUPGRADE(sv, SVt_PV))
2669         return 0;
2670
2671     if (RsSNARF(rs)) {
2672         rsptr = NULL;
2673         rslen = 0;
2674     }
2675     else if (RsPARA(rs)) {
2676         rsptr = "\n\n";
2677         rslen = 2;
2678     }
2679     else
2680         rsptr = SvPV(rs, rslen);
2681     rslast = rslen ? rsptr[rslen - 1] : '\0';
2682
2683     if (RsPARA(rs)) {           /* have to do this both before and after */
2684         do {                    /* to make sure file boundaries work right */
2685             if (PerlIO_eof(fp))
2686                 return 0;
2687             i = PerlIO_getc(fp);
2688             if (i != '\n') {
2689                 if (i == -1)
2690                     return 0;
2691                 PerlIO_ungetc(fp,i);
2692                 break;
2693             }
2694         } while (i != EOF);
2695     }
2696
2697     /* See if we know enough about I/O mechanism to cheat it ! */
2698
2699     /* This used to be #ifdef test - it is made run-time test for ease
2700        of abstracting out stdio interface. One call should be cheap 
2701        enough here - and may even be a macro allowing compile
2702        time optimization.
2703      */
2704
2705     if (PerlIO_fast_gets(fp)) {
2706
2707     /*
2708      * We're going to steal some values from the stdio struct
2709      * and put EVERYTHING in the innermost loop into registers.
2710      */
2711     register STDCHAR *ptr;
2712     STRLEN bpx;
2713     I32 shortbuffered;
2714
2715
2716     /* Here is some breathtakingly efficient cheating */
2717
2718     cnt = PerlIO_get_cnt(fp);                   /* get count into register */
2719     (void)SvPOK_only(sv);               /* validate pointer */
2720     if (SvLEN(sv) - append <= cnt + 1) { /* make sure we have the room */
2721         if (cnt > 80 && SvLEN(sv) > append) {
2722             shortbuffered = cnt - SvLEN(sv) + append + 1;
2723             cnt -= shortbuffered;
2724         }
2725         else {
2726             shortbuffered = 0;
2727             SvGROW(sv, append+cnt+2);/* (remembering cnt can be -1) */
2728         }
2729     }
2730     else
2731         shortbuffered = 0;
2732     bp = (STDCHAR*)SvPVX(sv) + append;  /* move these two too to registers */
2733     ptr = (STDCHAR*)PerlIO_get_ptr(fp);
2734     for (;;) {
2735       screamer:
2736         if (cnt > 0) {
2737             if (rslen) {
2738                 while (cnt > 0) {                    /* this     |  eat */
2739                     cnt--;
2740                     if ((*bp++ = *ptr++) == rslast)  /* really   |  dust */
2741                         goto thats_all_folks;        /* screams  |  sed :-) */
2742                 }
2743             }
2744             else {
2745                 memcpy((char*)bp, (char*)ptr, cnt);  /* this     |  eat */    
2746                 bp += cnt;                           /* screams  |  dust */   
2747                 ptr += cnt;                          /* louder   |  sed :-) */
2748                 cnt = 0;
2749             }
2750         }
2751         
2752         if (shortbuffered) {            /* oh well, must extend */
2753             cnt = shortbuffered;
2754             shortbuffered = 0;
2755             bpx = bp - (STDCHAR*)SvPVX(sv); /* box up before relocation */
2756             SvCUR_set(sv, bpx);
2757             SvGROW(sv, SvLEN(sv) + append + cnt + 2);
2758             bp = (STDCHAR*)SvPVX(sv) + bpx; /* unbox after relocation */
2759             continue;
2760         }
2761
2762         PerlIO_set_ptrcnt(fp, ptr, cnt); /* deregisterize cnt and ptr */
2763         /* This used to call 'filbuf' in stdio form, but as that behaves like getc
2764            when cnt <= 0 we use PerlIO_getc here to avoid another abstraction.
2765            This may also avoid issues with different named 'filbuf' equivalents
2766          */
2767         i   = PerlIO_getc(fp);          /* get more characters */
2768         cnt = PerlIO_get_cnt(fp);
2769         ptr = (STDCHAR*)PerlIO_get_ptr(fp);     /* reregisterize cnt and ptr */
2770
2771         if (i == EOF)                   /* all done for ever? */
2772             goto thats_really_all_folks;
2773
2774         bpx = bp - (STDCHAR*)SvPVX(sv); /* box up before relocation */
2775         SvCUR_set(sv, bpx);
2776         SvGROW(sv, bpx + cnt + 2);
2777         bp = (STDCHAR*)SvPVX(sv) + bpx; /* unbox after relocation */
2778
2779         *bp++ = i;                      /* store character from PerlIO_getc */
2780
2781         if (rslen && (STDCHAR)i == rslast)  /* all done for now? */
2782             goto thats_all_folks;
2783     }
2784
2785 thats_all_folks:
2786     if ((rslen > 1 && (bp - (STDCHAR*)SvPVX(sv) < rslen)) ||
2787           memcmp((char*)bp - rslen, rsptr, rslen))
2788         goto screamer;                          /* go back to the fray */
2789 thats_really_all_folks:
2790     if (shortbuffered)
2791         cnt += shortbuffered;
2792     PerlIO_set_ptrcnt(fp, ptr, cnt);    /* put these back or we're in trouble */
2793     *bp = '\0';
2794     SvCUR_set(sv, bp - (STDCHAR*)SvPVX(sv));    /* set length */
2795     }
2796    else
2797     {
2798        /*The big, slow, and stupid way */
2799         STDCHAR buf[8192];
2800
2801 screamer2:
2802         if (rslen) {
2803             register STDCHAR *bpe = buf + sizeof(buf);
2804             bp = buf;
2805             while ((i = PerlIO_getc(fp)) != EOF && (*bp++ = i) != rslast && bp < bpe)
2806                 ; /* keep reading */
2807             cnt = bp - buf;
2808         }
2809         else {
2810             cnt = PerlIO_read(fp,(char*)buf, sizeof(buf));
2811             i = cnt ? (U8)buf[cnt - 1] : EOF;
2812         }
2813
2814         if (append)
2815             sv_catpvn(sv, (char *) buf, cnt);
2816         else
2817             sv_setpvn(sv, (char *) buf, cnt);
2818
2819         if (i != EOF &&                 /* joy */
2820             (!rslen ||
2821              SvCUR(sv) < rslen ||
2822              memcmp(SvPVX(sv) + SvCUR(sv) - rslen, rsptr, rslen)))
2823         {
2824             append = -1;
2825             goto screamer2;
2826         }
2827     }
2828
2829     if (RsPARA(rs)) {           /* have to do this both before and after */  
2830         while (i != EOF) {      /* to make sure file boundaries work right */
2831             i = PerlIO_getc(fp);
2832             if (i != '\n') {
2833                 PerlIO_ungetc(fp,i);
2834                 break;
2835             }
2836         }
2837     }
2838
2839     return (SvCUR(sv) - append) ? SvPVX(sv) : Nullch;
2840 }
2841
2842
2843 void
2844 sv_inc(sv)
2845 register SV *sv;
2846 {
2847     register char *d;
2848     int flags;
2849
2850     if (!sv)
2851         return;
2852     if (SvTHINKFIRST(sv)) {
2853         if (SvREADONLY(sv) && curcop != &compiling)
2854             croak(no_modify);
2855         if (SvROK(sv)) {
2856 #ifdef OVERLOAD
2857           if (SvAMAGIC(sv) && AMG_CALLun(sv,inc)) return;
2858 #endif /* OVERLOAD */
2859           sv_unref(sv);
2860         }
2861     }
2862     if (SvGMAGICAL(sv))
2863         mg_get(sv);
2864     flags = SvFLAGS(sv);
2865     if (flags & SVp_IOK) {
2866         (void)SvIOK_only(sv);
2867         ++SvIVX(sv);
2868         return;
2869     }
2870     if (flags & SVp_NOK) {
2871         SvNVX(sv) += 1.0;
2872         (void)SvNOK_only(sv);
2873         return;
2874     }
2875     if (!(flags & SVp_POK) || !*SvPVX(sv)) {
2876         if ((flags & SVTYPEMASK) < SVt_PVNV)
2877             sv_upgrade(sv, SVt_NV);
2878         SvNVX(sv) = 1.0;
2879         (void)SvNOK_only(sv);
2880         return;
2881     }
2882     d = SvPVX(sv);
2883     while (isALPHA(*d)) d++;
2884     while (isDIGIT(*d)) d++;
2885     if (*d) {
2886         sv_setnv(sv,atof(SvPVX(sv)) + 1.0);  /* punt */
2887         return;
2888     }
2889     d--;
2890     while (d >= SvPVX(sv)) {
2891         if (isDIGIT(*d)) {
2892             if (++*d <= '9')
2893                 return;
2894             *(d--) = '0';
2895         }
2896         else {
2897             ++*d;
2898             if (isALPHA(*d))
2899                 return;
2900             *(d--) -= 'z' - 'a' + 1;
2901         }
2902     }
2903     /* oh,oh, the number grew */
2904     SvGROW(sv, SvCUR(sv) + 2);
2905     SvCUR(sv)++;
2906     for (d = SvPVX(sv) + SvCUR(sv); d > SvPVX(sv); d--)
2907         *d = d[-1];
2908     if (isDIGIT(d[1]))
2909         *d = '1';
2910     else
2911         *d = d[1];
2912 }
2913
2914 void
2915 sv_dec(sv)
2916 register SV *sv;
2917 {
2918     int flags;
2919
2920     if (!sv)
2921         return;
2922     if (SvTHINKFIRST(sv)) {
2923         if (SvREADONLY(sv) && curcop != &compiling)
2924             croak(no_modify);
2925         if (SvROK(sv)) {
2926 #ifdef OVERLOAD
2927           if (SvAMAGIC(sv) && AMG_CALLun(sv,dec)) return;
2928 #endif /* OVERLOAD */
2929           sv_unref(sv);
2930         }
2931     }
2932     if (SvGMAGICAL(sv))
2933         mg_get(sv);
2934     flags = SvFLAGS(sv);
2935     if (flags & SVp_IOK) {
2936         (void)SvIOK_only(sv);
2937         --SvIVX(sv);
2938         return;
2939     }
2940     if (flags & SVp_NOK) {
2941         SvNVX(sv) -= 1.0;
2942         (void)SvNOK_only(sv);
2943         return;
2944     }
2945     if (!(flags & SVp_POK)) {
2946         if ((flags & SVTYPEMASK) < SVt_PVNV)
2947             sv_upgrade(sv, SVt_NV);
2948         SvNVX(sv) = -1.0;
2949         (void)SvNOK_only(sv);
2950         return;
2951     }
2952     sv_setnv(sv,atof(SvPVX(sv)) - 1.0);
2953 }
2954
2955 /* Make a string that will exist for the duration of the expression
2956  * evaluation.  Actually, it may have to last longer than that, but
2957  * hopefully we won't free it until it has been assigned to a
2958  * permanent location. */
2959
2960 static void
2961 sv_mortalgrow()
2962 {
2963     tmps_max += 128;
2964     Renew(tmps_stack, tmps_max, SV*);
2965 }
2966
2967 SV *
2968 sv_mortalcopy(oldstr)
2969 SV *oldstr;
2970 {
2971     register SV *sv;
2972
2973     new_SV(sv);
2974     SvANY(sv) = 0;
2975     SvREFCNT(sv) = 1;
2976     SvFLAGS(sv) = 0;
2977     sv_setsv(sv,oldstr);
2978     if (++tmps_ix >= tmps_max)
2979         sv_mortalgrow();
2980     tmps_stack[tmps_ix] = sv;
2981     SvTEMP_on(sv);
2982     return sv;
2983 }
2984
2985 SV *
2986 sv_newmortal()
2987 {
2988     register SV *sv;
2989
2990     new_SV(sv);
2991     SvANY(sv) = 0;
2992     SvREFCNT(sv) = 1;
2993     SvFLAGS(sv) = SVs_TEMP;
2994     if (++tmps_ix >= tmps_max)
2995         sv_mortalgrow();
2996     tmps_stack[tmps_ix] = sv;
2997     return sv;
2998 }
2999
3000 /* same thing without the copying */
3001
3002 SV *
3003 sv_2mortal(sv)
3004 register SV *sv;
3005 {
3006     if (!sv)
3007         return sv;
3008     if (SvREADONLY(sv) && curcop != &compiling)
3009         croak(no_modify);
3010     if (++tmps_ix >= tmps_max)
3011         sv_mortalgrow();
3012     tmps_stack[tmps_ix] = sv;
3013     SvTEMP_on(sv);
3014     return sv;
3015 }
3016
3017 SV *
3018 newSVpv(s,len)
3019 char *s;
3020 STRLEN len;
3021 {
3022     register SV *sv;
3023
3024     new_SV(sv);
3025     SvANY(sv) = 0;
3026     SvREFCNT(sv) = 1;
3027     SvFLAGS(sv) = 0;
3028     if (!len)
3029         len = strlen(s);
3030     sv_setpvn(sv,s,len);
3031     return sv;
3032 }
3033
3034 SV *
3035 newSVnv(n)
3036 double n;
3037 {
3038     register SV *sv;
3039
3040     new_SV(sv);
3041     SvANY(sv) = 0;
3042     SvREFCNT(sv) = 1;
3043     SvFLAGS(sv) = 0;
3044     sv_setnv(sv,n);
3045     return sv;
3046 }
3047
3048 SV *
3049 newSViv(i)
3050 IV i;
3051 {
3052     register SV *sv;
3053
3054     new_SV(sv);
3055     SvANY(sv) = 0;
3056     SvREFCNT(sv) = 1;
3057     SvFLAGS(sv) = 0;
3058     sv_setiv(sv,i);
3059     return sv;
3060 }
3061
3062 SV *
3063 newRV(ref)
3064 SV *ref;
3065 {
3066     register SV *sv;
3067
3068     new_SV(sv);
3069     SvANY(sv) = 0;
3070     SvREFCNT(sv) = 1;
3071     SvFLAGS(sv) = 0;
3072     sv_upgrade(sv, SVt_RV);
3073     SvTEMP_off(ref);
3074     SvRV(sv) = SvREFCNT_inc(ref);
3075     SvROK_on(sv);
3076     return sv;
3077 }
3078
3079 /* make an exact duplicate of old */
3080
3081 SV *
3082 newSVsv(old)
3083 register SV *old;
3084 {
3085     register SV *sv;
3086
3087     if (!old)
3088         return Nullsv;
3089     if (SvTYPE(old) == SVTYPEMASK) {
3090         warn("semi-panic: attempt to dup freed string");
3091         return Nullsv;
3092     }
3093     new_SV(sv);
3094     SvANY(sv) = 0;
3095     SvREFCNT(sv) = 1;
3096     SvFLAGS(sv) = 0;
3097     if (SvTEMP(old)) {
3098         SvTEMP_off(old);
3099         sv_setsv(sv,old);
3100         SvTEMP_on(old);
3101     }
3102     else
3103         sv_setsv(sv,old);
3104     return sv;
3105 }
3106
3107 void
3108 sv_reset(s,stash)
3109 register char *s;
3110 HV *stash;
3111 {
3112     register HE *entry;
3113     register GV *gv;
3114     register SV *sv;
3115     register I32 i;
3116     register PMOP *pm;
3117     register I32 max;
3118     char todo[256];
3119
3120     if (!*s) {          /* reset ?? searches */
3121         for (pm = HvPMROOT(stash); pm; pm = pm->op_pmnext) {
3122             pm->op_pmflags &= ~PMf_USED;
3123         }
3124         return;
3125     }
3126
3127     /* reset variables */
3128
3129     if (!HvARRAY(stash))
3130         return;
3131
3132     Zero(todo, 256, char);
3133     while (*s) {
3134         i = *s;
3135         if (s[1] == '-') {
3136             s += 2;
3137         }
3138         max = *s++;
3139         for ( ; i <= max; i++) {
3140             todo[i] = 1;
3141         }
3142         for (i = 0; i <= (I32) HvMAX(stash); i++) {
3143             for (entry = HvARRAY(stash)[i];
3144               entry;
3145               entry = HeNEXT(entry)) {
3146                 if (!todo[(U8)*HeKEY(entry)])
3147                     continue;
3148                 gv = (GV*)HeVAL(entry);
3149                 sv = GvSV(gv);
3150                 (void)SvOK_off(sv);
3151                 if (SvTYPE(sv) >= SVt_PV) {
3152                     SvCUR_set(sv, 0);
3153                     SvTAINT(sv);
3154                     if (SvPVX(sv) != Nullch)
3155                         *SvPVX(sv) = '\0';
3156                 }
3157                 if (GvAV(gv)) {
3158                     av_clear(GvAV(gv));
3159                 }
3160                 if (GvHV(gv)) {
3161                     if (HvNAME(GvHV(gv)))
3162                         continue;
3163                     hv_clear(GvHV(gv));
3164 #ifndef VMS  /* VMS has no environ array */
3165                     if (gv == envgv)
3166                         environ[0] = Nullch;
3167 #endif
3168                 }
3169             }
3170         }
3171     }
3172 }
3173
3174 CV *
3175 sv_2cv(sv, st, gvp, lref)
3176 SV *sv;
3177 HV **st;
3178 GV **gvp;
3179 I32 lref;
3180 {
3181     GV *gv;
3182     CV *cv;
3183
3184     if (!sv)
3185         return *gvp = Nullgv, Nullcv;
3186     switch (SvTYPE(sv)) {
3187     case SVt_PVCV:
3188         *st = CvSTASH(sv);
3189         *gvp = Nullgv;
3190         return (CV*)sv;
3191     case SVt_PVHV:
3192     case SVt_PVAV:
3193         *gvp = Nullgv;
3194         return Nullcv;
3195     case SVt_PVGV:
3196         gv = (GV*)sv;
3197         *gvp = gv;
3198         *st = GvESTASH(gv);
3199         goto fix_gv;
3200
3201     default:
3202         if (SvGMAGICAL(sv))
3203             mg_get(sv);
3204         if (SvROK(sv)) {
3205             cv = (CV*)SvRV(sv);
3206             if (SvTYPE(cv) != SVt_PVCV)
3207                 croak("Not a subroutine reference");
3208             *gvp = Nullgv;
3209             *st = CvSTASH(cv);
3210             return cv;
3211         }
3212         if (isGV(sv))
3213             gv = (GV*)sv;
3214         else
3215             gv = gv_fetchpv(SvPV(sv, na), lref, SVt_PVCV);
3216         *gvp = gv;
3217         if (!gv)
3218             return Nullcv;
3219         *st = GvESTASH(gv);
3220     fix_gv:
3221         if (lref && !GvCV(gv)) {
3222             SV *tmpsv;
3223             ENTER;
3224             tmpsv = NEWSV(704,0);
3225             gv_efullname(tmpsv, gv, Nullch);
3226             newSUB(start_subparse(),
3227                    newSVOP(OP_CONST, 0, tmpsv),
3228                    Nullop,
3229                    Nullop);
3230             LEAVE;
3231             if (!GvCV(gv))
3232                 croak("Unable to create sub named \"%s\"", SvPV(sv,na));
3233         }
3234         return GvCV(gv);
3235     }
3236 }
3237
3238 #ifndef SvTRUE
3239 I32
3240 SvTRUE(sv)
3241 register SV *sv;
3242 {
3243     if (!sv)
3244         return 0;
3245     if (SvGMAGICAL(sv))
3246         mg_get(sv);
3247     if (SvPOK(sv)) {
3248         register XPV* Xpv;
3249         if ((Xpv = (XPV*)SvANY(sv)) &&
3250                 (*Xpv->xpv_pv > '0' ||
3251                 Xpv->xpv_cur > 1 ||
3252                 (Xpv->xpv_cur && *Xpv->xpv_pv != '0')))
3253             return 1;
3254         else
3255             return 0;
3256     }
3257     else {
3258         if (SvIOK(sv))
3259             return SvIVX(sv) != 0;
3260         else {
3261             if (SvNOK(sv))
3262                 return SvNVX(sv) != 0.0;
3263             else
3264                 return sv_2bool(sv);
3265         }
3266     }
3267 }
3268 #endif /* SvTRUE */
3269
3270 #ifndef SvIV
3271 IV SvIV(Sv)
3272 register SV *Sv;
3273 {
3274     if (SvIOK(Sv))
3275         return SvIVX(Sv);
3276     return sv_2iv(Sv);
3277 }
3278 #endif /* SvIV */
3279
3280
3281 #ifndef SvNV
3282 double SvNV(Sv)
3283 register SV *Sv;
3284 {
3285     if (SvNOK(Sv))
3286         return SvNVX(Sv);
3287     if (SvIOK(Sv))
3288         return (double)SvIVX(Sv);
3289     return sv_2nv(Sv);
3290 }
3291 #endif /* SvNV */
3292
3293 #ifdef CRIPPLED_CC
3294 char *
3295 sv_pvn(sv, lp)
3296 SV *sv;
3297 STRLEN *lp;
3298 {
3299     if (SvPOK(sv)) {
3300         *lp = SvCUR(sv);
3301         return SvPVX(sv);
3302     }
3303     return sv_2pv(sv, lp);
3304 }
3305 #endif
3306
3307 char *
3308 sv_pvn_force(sv, lp)
3309 SV *sv;
3310 STRLEN *lp;
3311 {
3312     char *s;
3313
3314     if (SvREADONLY(sv) && curcop != &compiling)
3315         croak(no_modify);
3316     
3317     if (SvPOK(sv)) {
3318         *lp = SvCUR(sv);
3319     }
3320     else {
3321         if (SvTYPE(sv) > SVt_PVLV && SvTYPE(sv) != SVt_PVFM) {
3322             if (SvFAKE(sv) && SvTYPE(sv) == SVt_PVGV) {
3323                 sv_unglob(sv);
3324                 s = SvPVX(sv);
3325                 *lp = SvCUR(sv);
3326             }
3327             else
3328                 croak("Can't coerce %s to string in %s", sv_reftype(sv,0),
3329                     op_name[op->op_type]);
3330         }
3331         else
3332             s = sv_2pv(sv, lp);
3333         if (s != SvPVX(sv)) {   /* Almost, but not quite, sv_setpvn() */
3334             STRLEN len = *lp;
3335             
3336             if (SvROK(sv))
3337                 sv_unref(sv);
3338             (void)SvUPGRADE(sv, SVt_PV);                /* Never FALSE */
3339             SvGROW(sv, len + 1);
3340             Move(s,SvPVX(sv),len,char);
3341             SvCUR_set(sv, len);
3342             *SvEND(sv) = '\0';
3343         }
3344         if (!SvPOK(sv)) {
3345             SvPOK_on(sv);               /* validate pointer */
3346             SvTAINT(sv);
3347             DEBUG_c(PerlIO_printf(Perl_debug_log, "0x%lx 2pv(%s)\n",
3348                 (unsigned long)sv,SvPVX(sv)));
3349         }
3350     }
3351     return SvPVX(sv);
3352 }
3353
3354 char *
3355 sv_reftype(sv, ob)
3356 SV* sv;
3357 int ob;
3358 {
3359     if (ob && SvOBJECT(sv))
3360         return HvNAME(SvSTASH(sv));
3361     else {
3362         switch (SvTYPE(sv)) {
3363         case SVt_NULL:
3364         case SVt_IV:
3365         case SVt_NV:
3366         case SVt_RV:
3367         case SVt_PV:
3368         case SVt_PVIV:
3369         case SVt_PVNV:
3370         case SVt_PVMG:
3371         case SVt_PVBM:
3372                                 if (SvROK(sv))
3373                                     return "REF";
3374                                 else
3375                                     return "SCALAR";
3376         case SVt_PVLV:          return "LVALUE";
3377         case SVt_PVAV:          return "ARRAY";
3378         case SVt_PVHV:          return "HASH";
3379         case SVt_PVCV:          return "CODE";
3380         case SVt_PVGV:          return "GLOB";
3381         case SVt_PVFM:          return "FORMLINE";
3382         default:                return "UNKNOWN";
3383         }
3384     }
3385 }
3386
3387 int
3388 sv_isobject(sv)
3389 SV *sv;
3390 {
3391     if (!SvROK(sv))
3392         return 0;
3393     sv = (SV*)SvRV(sv);
3394     if (!SvOBJECT(sv))
3395         return 0;
3396     return 1;
3397 }
3398
3399 int
3400 sv_isa(sv, name)
3401 SV *sv;
3402 char *name;
3403 {
3404     if (!SvROK(sv))
3405         return 0;
3406     sv = (SV*)SvRV(sv);
3407     if (!SvOBJECT(sv))
3408         return 0;
3409
3410     return strEQ(HvNAME(SvSTASH(sv)), name);
3411 }
3412
3413 SV*
3414 newSVrv(rv, classname)
3415 SV *rv;
3416 char *classname;
3417 {
3418     SV *sv;
3419
3420     new_SV(sv);
3421     SvANY(sv) = 0;
3422     SvREFCNT(sv) = 0;
3423     SvFLAGS(sv) = 0;
3424     sv_upgrade(rv, SVt_RV);
3425     SvRV(rv) = SvREFCNT_inc(sv);
3426     SvROK_on(rv);
3427
3428     if (classname) {
3429         HV* stash = gv_stashpv(classname, TRUE);
3430         (void)sv_bless(rv, stash);
3431     }
3432     return sv;
3433 }
3434
3435 SV*
3436 sv_setref_pv(rv, classname, pv)
3437 SV *rv;
3438 char *classname;
3439 void* pv;
3440 {
3441     if (!pv)
3442         sv_setsv(rv, &sv_undef);
3443     else
3444         sv_setiv(newSVrv(rv,classname), (IV)pv);
3445     return rv;
3446 }
3447
3448 SV*
3449 sv_setref_iv(rv, classname, iv)
3450 SV *rv;
3451 char *classname;
3452 IV iv;
3453 {
3454     sv_setiv(newSVrv(rv,classname), iv);
3455     return rv;
3456 }
3457
3458 SV*
3459 sv_setref_nv(rv, classname, nv)
3460 SV *rv;
3461 char *classname;
3462 double nv;
3463 {
3464     sv_setnv(newSVrv(rv,classname), nv);
3465     return rv;
3466 }
3467
3468 SV*
3469 sv_setref_pvn(rv, classname, pv, n)
3470 SV *rv;
3471 char *classname;
3472 char* pv;
3473 I32 n;
3474 {
3475     sv_setpvn(newSVrv(rv,classname), pv, n);
3476     return rv;
3477 }
3478
3479 SV*
3480 sv_bless(sv,stash)
3481 SV* sv;
3482 HV* stash;
3483 {
3484     SV *ref;
3485     if (!SvROK(sv))
3486         croak("Can't bless non-reference value");
3487     ref = SvRV(sv);
3488     if (SvFLAGS(ref) & (SVs_OBJECT|SVf_READONLY)) {
3489         if (SvREADONLY(ref))
3490             croak(no_modify);
3491         if (SvOBJECT(ref) && SvTYPE(ref) != SVt_PVIO)
3492             --sv_objcount;
3493     }
3494     SvOBJECT_on(ref);
3495     ++sv_objcount;
3496     (void)SvUPGRADE(ref, SVt_PVMG);
3497     SvSTASH(ref) = (HV*)SvREFCNT_inc(stash);
3498
3499 #ifdef OVERLOAD
3500     SvAMAGIC_off(sv);
3501     if (Gv_AMG(stash)) {
3502       SvAMAGIC_on(sv);
3503     }
3504 #endif /* OVERLOAD */
3505
3506     return sv;
3507 }
3508
3509 static void
3510 sv_unglob(sv)
3511 SV* sv;
3512 {
3513     assert(SvTYPE(sv) == SVt_PVGV);
3514     SvFAKE_off(sv);
3515     if (GvGP(sv))
3516         gp_free((GV*)sv);
3517     sv_unmagic(sv, '*');
3518     Safefree(GvNAME(sv));
3519     GvMULTI_off(sv);
3520     SvFLAGS(sv) &= ~SVTYPEMASK;
3521     SvFLAGS(sv) |= SVt_PVMG;
3522 }
3523
3524 void
3525 sv_unref(sv)
3526 SV* sv;
3527 {
3528     SV* rv = SvRV(sv);
3529     
3530     SvRV(sv) = 0;
3531     SvROK_off(sv);
3532     if (SvREFCNT(rv) != 1 || SvREADONLY(rv))
3533         SvREFCNT_dec(rv);
3534     else
3535         sv_2mortal(rv);         /* Schedule for freeing later */
3536 }
3537
3538 #ifdef DEBUGGING
3539 void
3540 sv_dump(sv)
3541 SV* sv;
3542 {
3543     char tmpbuf[1024];
3544     char *d = tmpbuf;
3545     U32 flags;
3546     U32 type;
3547
3548     if (!sv) {
3549         PerlIO_printf(Perl_debug_log, "SV = 0\n");
3550         return;
3551     }
3552     
3553     flags = SvFLAGS(sv);
3554     type = SvTYPE(sv);
3555
3556     sprintf(d, "(0x%lx)\n  REFCNT = %ld\n  FLAGS = (",
3557         (unsigned long)SvANY(sv), (long)SvREFCNT(sv));
3558     d += strlen(d);
3559     if (flags & SVs_PADBUSY)    strcat(d, "PADBUSY,");
3560     if (flags & SVs_PADTMP)     strcat(d, "PADTMP,");
3561     if (flags & SVs_PADMY)      strcat(d, "PADMY,");
3562     if (flags & SVs_TEMP)       strcat(d, "TEMP,");
3563     if (flags & SVs_OBJECT)     strcat(d, "OBJECT,");
3564     if (flags & SVs_GMG)        strcat(d, "GMG,");
3565     if (flags & SVs_SMG)        strcat(d, "SMG,");
3566     if (flags & SVs_RMG)        strcat(d, "RMG,");
3567     d += strlen(d);
3568
3569     if (flags & SVf_IOK)        strcat(d, "IOK,");
3570     if (flags & SVf_NOK)        strcat(d, "NOK,");
3571     if (flags & SVf_POK)        strcat(d, "POK,");
3572     if (flags & SVf_ROK)        strcat(d, "ROK,");
3573     if (flags & SVf_OOK)        strcat(d, "OOK,");
3574     if (flags & SVf_FAKE)       strcat(d, "FAKE,");
3575     if (flags & SVf_READONLY)   strcat(d, "READONLY,");
3576     d += strlen(d);
3577
3578 #ifdef OVERLOAD
3579     if (flags & SVf_AMAGIC)     strcat(d, "OVERLOAD,");
3580 #endif /* OVERLOAD */
3581     if (flags & SVp_IOK)        strcat(d, "pIOK,");
3582     if (flags & SVp_NOK)        strcat(d, "pNOK,");
3583     if (flags & SVp_POK)        strcat(d, "pPOK,");
3584     if (flags & SVp_SCREAM)     strcat(d, "SCREAM,");
3585
3586     switch (type) {
3587     case SVt_PVCV:
3588       if (CvANON(sv))   strcat(d, "ANON,");
3589       if (CvCLONE(sv))  strcat(d, "CLONE,");
3590       if (CvCLONED(sv)) strcat(d, "CLONED,");
3591       break;
3592     case SVt_PVGV:
3593       if (GvMULTI(sv))  strcat(d, "MULTI,");
3594 #ifdef OVERLOAD
3595       if (flags & SVpgv_AM)     strcat(d, "withOVERLOAD,");
3596 #endif /* OVERLOAD */
3597     }
3598
3599     d += strlen(d);
3600     if (d[-1] == ',')
3601         d--;
3602     *d++ = ')';
3603     *d = '\0';
3604
3605     PerlIO_printf(Perl_debug_log, "SV = ");
3606     switch (type) {
3607     case SVt_NULL:
3608         PerlIO_printf(Perl_debug_log, "NULL%s\n", tmpbuf);
3609         return;
3610     case SVt_IV:
3611         PerlIO_printf(Perl_debug_log, "IV%s\n", tmpbuf);
3612         break;
3613     case SVt_NV:
3614         PerlIO_printf(Perl_debug_log, "NV%s\n", tmpbuf);
3615         break;
3616     case SVt_RV:
3617         PerlIO_printf(Perl_debug_log, "RV%s\n", tmpbuf);
3618         break;
3619     case SVt_PV:
3620         PerlIO_printf(Perl_debug_log, "PV%s\n", tmpbuf);
3621         break;
3622     case SVt_PVIV:
3623         PerlIO_printf(Perl_debug_log, "PVIV%s\n", tmpbuf);
3624         break;
3625     case SVt_PVNV:
3626         PerlIO_printf(Perl_debug_log, "PVNV%s\n", tmpbuf);
3627         break;
3628     case SVt_PVBM:
3629         PerlIO_printf(Perl_debug_log, "PVBM%s\n", tmpbuf);
3630         break;
3631     case SVt_PVMG:
3632         PerlIO_printf(Perl_debug_log, "PVMG%s\n", tmpbuf);
3633         break;
3634     case SVt_PVLV:
3635         PerlIO_printf(Perl_debug_log, "PVLV%s\n", tmpbuf);
3636         break;
3637     case SVt_PVAV:
3638         PerlIO_printf(Perl_debug_log, "PVAV%s\n", tmpbuf);
3639         break;
3640     case SVt_PVHV:
3641         PerlIO_printf(Perl_debug_log, "PVHV%s\n", tmpbuf);
3642         break;
3643     case SVt_PVCV:
3644         PerlIO_printf(Perl_debug_log, "PVCV%s\n", tmpbuf);
3645         break;
3646     case SVt_PVGV:
3647         PerlIO_printf(Perl_debug_log, "PVGV%s\n", tmpbuf);
3648         break;
3649     case SVt_PVFM:
3650         PerlIO_printf(Perl_debug_log, "PVFM%s\n", tmpbuf);
3651         break;
3652     case SVt_PVIO:
3653         PerlIO_printf(Perl_debug_log, "PVIO%s\n", tmpbuf);
3654         break;
3655     default:
3656         PerlIO_printf(Perl_debug_log, "UNKNOWN%s\n", tmpbuf);
3657         return;
3658     }
3659     if (type >= SVt_PVIV || type == SVt_IV)
3660         PerlIO_printf(Perl_debug_log, "  IV = %ld\n", (long)SvIVX(sv));
3661     if (type >= SVt_PVNV || type == SVt_NV)
3662         PerlIO_printf(Perl_debug_log, "  NV = %.*g\n", DBL_DIG, SvNVX(sv));
3663     if (SvROK(sv)) {
3664         PerlIO_printf(Perl_debug_log, "  RV = 0x%lx\n", (long)SvRV(sv));
3665         sv_dump(SvRV(sv));
3666         return;
3667     }
3668     if (type < SVt_PV)
3669         return;
3670     if (type <= SVt_PVLV) {
3671         if (SvPVX(sv))
3672             PerlIO_printf(Perl_debug_log, "  PV = 0x%lx \"%s\"\n  CUR = %ld\n  LEN = %ld\n",
3673                 (long)SvPVX(sv), SvPVX(sv), (long)SvCUR(sv), (long)SvLEN(sv));
3674         else
3675             PerlIO_printf(Perl_debug_log, "  PV = 0\n");
3676     }
3677     if (type >= SVt_PVMG) {
3678         if (SvMAGIC(sv)) {
3679             PerlIO_printf(Perl_debug_log, "  MAGIC = 0x%lx\n", (long)SvMAGIC(sv));
3680         }
3681         if (SvSTASH(sv))
3682             PerlIO_printf(Perl_debug_log, "  STASH = \"%s\"\n", HvNAME(SvSTASH(sv)));
3683     }
3684     switch (type) {
3685     case SVt_PVLV:
3686         PerlIO_printf(Perl_debug_log, "  TYPE = %c\n", LvTYPE(sv));
3687         PerlIO_printf(Perl_debug_log, "  TARGOFF = %ld\n", (long)LvTARGOFF(sv));
3688         PerlIO_printf(Perl_debug_log, "  TARGLEN = %ld\n", (long)LvTARGLEN(sv));
3689         PerlIO_printf(Perl_debug_log, "  TARG = 0x%lx\n", (long)LvTARG(sv));
3690         sv_dump(LvTARG(sv));
3691         break;
3692     case SVt_PVAV:
3693         PerlIO_printf(Perl_debug_log, "  ARRAY = 0x%lx\n", (long)AvARRAY(sv));
3694         PerlIO_printf(Perl_debug_log, "  ALLOC = 0x%lx\n", (long)AvALLOC(sv));
3695         PerlIO_printf(Perl_debug_log, "  FILL = %ld\n", (long)AvFILL(sv));
3696         PerlIO_printf(Perl_debug_log, "  MAX = %ld\n", (long)AvMAX(sv));
3697         PerlIO_printf(Perl_debug_log, "  ARYLEN = 0x%lx\n", (long)AvARYLEN(sv));
3698         flags = AvFLAGS(sv);
3699         d = tmpbuf;
3700         *d = '\0';
3701         if (flags & AVf_REAL)   strcat(d, "REAL,");
3702         if (flags & AVf_REIFY)  strcat(d, "REIFY,");
3703         if (flags & AVf_REUSED) strcat(d, "REUSED,");
3704         if (*d)
3705             d[strlen(d)-1] = '\0';
3706         PerlIO_printf(Perl_debug_log, "  FLAGS = (%s)\n", d);
3707         break;
3708     case SVt_PVHV:
3709         PerlIO_printf(Perl_debug_log, "  ARRAY = 0x%lx\n",(long)HvARRAY(sv));
3710         PerlIO_printf(Perl_debug_log, "  KEYS = %ld\n", (long)HvKEYS(sv));
3711         PerlIO_printf(Perl_debug_log, "  FILL = %ld\n", (long)HvFILL(sv));
3712         PerlIO_printf(Perl_debug_log, "  MAX = %ld\n", (long)HvMAX(sv));
3713         PerlIO_printf(Perl_debug_log, "  RITER = %ld\n", (long)HvRITER(sv));
3714         PerlIO_printf(Perl_debug_log, "  EITER = 0x%lx\n",(long) HvEITER(sv));
3715         if (HvPMROOT(sv))
3716             PerlIO_printf(Perl_debug_log, "  PMROOT = 0x%lx\n",(long)HvPMROOT(sv));
3717         if (HvNAME(sv))
3718             PerlIO_printf(Perl_debug_log, "  NAME = \"%s\"\n", HvNAME(sv));
3719         break;
3720     case SVt_PVFM:
3721     case SVt_PVCV:
3722         if (SvPOK(sv))
3723             PerlIO_printf(Perl_debug_log, "  PROTOTYPE = \"%s\"\n", SvPV(sv,na));
3724         PerlIO_printf(Perl_debug_log, "  STASH = 0x%lx\n", (long)CvSTASH(sv));
3725         PerlIO_printf(Perl_debug_log, "  START = 0x%lx\n", (long)CvSTART(sv));
3726         PerlIO_printf(Perl_debug_log, "  ROOT = 0x%lx\n", (long)CvROOT(sv));
3727         PerlIO_printf(Perl_debug_log, "  XSUB = 0x%lx\n", (long)CvXSUB(sv));
3728         PerlIO_printf(Perl_debug_log, "  XSUBANY = %ld\n", (long)CvXSUBANY(sv).any_i32);
3729         PerlIO_printf(Perl_debug_log, "  GV = 0x%lx", (long)CvGV(sv));
3730         if (CvGV(sv) && GvNAME(CvGV(sv))) {
3731             PerlIO_printf(Perl_debug_log, "  \"%s\"\n", GvNAME(CvGV(sv)));
3732         } else {
3733             PerlIO_printf(Perl_debug_log, "\n");
3734         }
3735         PerlIO_printf(Perl_debug_log, "  FILEGV = 0x%lx\n", (long)CvFILEGV(sv));
3736         PerlIO_printf(Perl_debug_log, "  DEPTH = %ld\n", (long)CvDEPTH(sv));
3737         PerlIO_printf(Perl_debug_log, "  PADLIST = 0x%lx\n", (long)CvPADLIST(sv));
3738         PerlIO_printf(Perl_debug_log, "  OUTSIDE = 0x%lx\n", (long)CvOUTSIDE(sv));
3739         if (type == SVt_PVFM)
3740             PerlIO_printf(Perl_debug_log, "  LINES = %ld\n", (long)FmLINES(sv));
3741         break;
3742     case SVt_PVGV:
3743         PerlIO_printf(Perl_debug_log, "  NAME = \"%s\"\n", GvNAME(sv));
3744         PerlIO_printf(Perl_debug_log, "  NAMELEN = %ld\n", (long)GvNAMELEN(sv));
3745         PerlIO_printf(Perl_debug_log, "  STASH = \"%s\"\n", HvNAME(GvSTASH(sv)));
3746         PerlIO_printf(Perl_debug_log, "  GP = 0x%lx\n", (long)GvGP(sv));
3747         PerlIO_printf(Perl_debug_log, "    SV = 0x%lx\n", (long)GvSV(sv));
3748         PerlIO_printf(Perl_debug_log, "    REFCNT = %ld\n", (long)GvREFCNT(sv));
3749         PerlIO_printf(Perl_debug_log, "    IO = 0x%lx\n", (long)GvIOp(sv));
3750         PerlIO_printf(Perl_debug_log, "    FORM = 0x%lx\n", (long)GvFORM(sv));
3751         PerlIO_printf(Perl_debug_log, "    AV = 0x%lx\n", (long)GvAV(sv));
3752         PerlIO_printf(Perl_debug_log, "    HV = 0x%lx\n", (long)GvHV(sv));
3753         PerlIO_printf(Perl_debug_log, "    CV = 0x%lx\n", (long)GvCV(sv));
3754         PerlIO_printf(Perl_debug_log, "    CVGEN = 0x%lx\n", (long)GvCVGEN(sv));
3755         PerlIO_printf(Perl_debug_log, "    LASTEXPR = %ld\n", (long)GvLASTEXPR(sv));
3756         PerlIO_printf(Perl_debug_log, "    LINE = %ld\n", (long)GvLINE(sv));
3757         PerlIO_printf(Perl_debug_log, "    FLAGS = 0x%x\n", (int)GvFLAGS(sv));
3758         PerlIO_printf(Perl_debug_log, "    STASH = \"%s\"\n", HvNAME(GvSTASH(sv)));
3759         PerlIO_printf(Perl_debug_log, "    EGV = 0x%lx\n", (long)GvEGV(sv));
3760         break;
3761     case SVt_PVIO:
3762         PerlIO_printf(Perl_debug_log, "  IFP = 0x%lx\n", (long)IoIFP(sv));
3763         PerlIO_printf(Perl_debug_log, "  OFP = 0x%lx\n", (long)IoOFP(sv));
3764         PerlIO_printf(Perl_debug_log, "  DIRP = 0x%lx\n", (long)IoDIRP(sv));
3765         PerlIO_printf(Perl_debug_log, "  LINES = %ld\n", (long)IoLINES(sv));
3766         PerlIO_printf(Perl_debug_log, "  PAGE = %ld\n", (long)IoPAGE(sv));
3767         PerlIO_printf(Perl_debug_log, "  PAGE_LEN = %ld\n", (long)IoPAGE_LEN(sv));
3768         PerlIO_printf(Perl_debug_log, "  LINES_LEFT = %ld\n", (long)IoLINES_LEFT(sv));
3769         PerlIO_printf(Perl_debug_log, "  TOP_NAME = \"%s\"\n", IoTOP_NAME(sv));
3770         PerlIO_printf(Perl_debug_log, "  TOP_GV = 0x%lx\n", (long)IoTOP_GV(sv));
3771         PerlIO_printf(Perl_debug_log, "  FMT_NAME = \"%s\"\n", IoFMT_NAME(sv));
3772         PerlIO_printf(Perl_debug_log, "  FMT_GV = 0x%lx\n", (long)IoFMT_GV(sv));
3773         PerlIO_printf(Perl_debug_log, "  BOTTOM_NAME = \"%s\"\n", IoBOTTOM_NAME(sv));
3774         PerlIO_printf(Perl_debug_log, "  BOTTOM_GV = 0x%lx\n", (long)IoBOTTOM_GV(sv));
3775         PerlIO_printf(Perl_debug_log, "  SUBPROCESS = %ld\n", (long)IoSUBPROCESS(sv));
3776         PerlIO_printf(Perl_debug_log, "  TYPE = %c\n", IoTYPE(sv));
3777         PerlIO_printf(Perl_debug_log, "  FLAGS = 0x%lx\n", (long)IoFLAGS(sv));
3778         break;
3779     }
3780 }
3781 #else
3782 void
3783 sv_dump(sv)
3784 SV* sv;
3785 {
3786 }
3787 #endif
3788
3789 IO*
3790 sv_2io(sv)
3791 SV *sv;
3792 {
3793     IO* io;
3794     GV* gv;
3795
3796     switch (SvTYPE(sv)) {
3797     case SVt_PVIO:
3798         io = (IO*)sv;
3799         break;
3800     case SVt_PVGV:
3801         gv = (GV*)sv;
3802         io = GvIO(gv);
3803         if (!io)
3804             croak("Bad filehandle: %s", GvNAME(gv));
3805         break;
3806     default:
3807         if (!SvOK(sv))
3808             croak(no_usym, "filehandle");
3809         if (SvROK(sv))
3810             return sv_2io(SvRV(sv));
3811         gv = gv_fetchpv(SvPV(sv,na), FALSE, SVt_PVIO);
3812         if (gv)
3813             io = GvIO(gv);
3814         else
3815             io = 0;
3816         if (!io)
3817             croak("Bad filehandle: %s", SvPV(sv,na));
3818         break;
3819     }
3820     return io;
3821 }
3822