1 /* $RCSfile: sv.c,v $$Revision: 4.1 $$Date: 92/08/07 18:26:45 $
3 * Copyright (c) 1991, Larry Wall
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.
9 * Revision 4.1 92/08/07 18:26:45 lwall
11 * Revision 4.0.1.6 92/06/11 21:14:21 lwall
12 * patch34: quotes containing subscripts containing variables didn't parse right
14 * Revision 4.0.1.5 92/06/08 15:40:43 lwall
15 * patch20: removed implicit int declarations on functions
16 * patch20: Perl now distinguishes overlapped copies from non-overlapped
17 * patch20: paragraph mode now skips extra newlines automatically
18 * patch20: fixed memory leak in doube-quote interpretation
19 * patch20: made /\$$foo/ look for literal '$foo'
20 * patch20: "$var{$foo'bar}" didn't scan subscript correctly
21 * patch20: a splice on non-existent array elements could dump core
22 * patch20: running taintperl explicitly now does checks even if $< == $>
24 * Revision 4.0.1.4 91/11/05 18:40:51 lwall
25 * patch11: $foo .= <BAR> could overrun malloced memory
26 * patch11: \$ didn't always make it through double-quoter to regexp routines
27 * patch11: prepared for ctype implementations that don't define isascii()
29 * Revision 4.0.1.3 91/06/10 01:27:54 lwall
30 * patch10: $) and $| incorrectly handled in run-time patterns
32 * Revision 4.0.1.2 91/06/07 11:58:13 lwall
33 * patch4: new copyright notice
34 * patch4: taint check on undefined string could cause core dump
36 * Revision 4.0.1.1 91/04/12 09:15:30 lwall
37 * patch1: fixed undefined environ problem
38 * patch1: substr($ENV{"PATH"},0,0) = "/foo:" didn't modify environment
39 * patch1: $foo .= <BAR> could cause core dump for certain lengths of $foo
41 * Revision 4.0 91/03/20 01:39:55 lwall
80 sv_free((SV*)SvANY(sv));
85 nv = (double)SvANYI32(sv);
97 nv = (double)SvIV(sv);
117 if (mt == SVt_PV || mt == SVt_PVIV)
140 del_XPVIV(SvANY(sv));
151 del_XPVNV(SvANY(sv));
161 del_XPVMG(SvANY(sv));
164 fatal("Can't upgrade that kind of scalar");
169 fatal("Can't upgrade to undef");
174 SvANY(sv) = new_XIV();
178 SvANY(sv) = new_XNV();
183 SvANY(sv) = new_XPV();
189 SvANY(sv) = new_XPVIV();
199 SvANY(sv) = new_XPVNV();
207 SvANY(sv) = new_XPVMG();
217 SvANY(sv) = new_XPVLV();
231 SvANY(sv) = new_XPVAV();
248 SvANY(sv) = new_XPVHV();
269 SvANY(sv) = new_XPVCV();
288 SvANY(sv) = new_XPVGV();
301 SvANY(sv) = new_XPVBM();
314 SvANY(sv) = new_XPVFM();
341 else if (sv == (SV*)0x55555555 || SvTYPE(sv) == 'U') {
345 else if (SvREFCNT(sv) == 0 && !SvREADONLY(sv)) {
350 switch (SvTYPE(sv)) {
410 sprintf(t,"(%d+\"%0.127s\")",SvIV(sv),SvPV(sv));
412 sprintf(t,"(\"%0.127s\")",SvPV(sv));
415 sprintf(t,"(%g)",SvNV(sv));
417 sprintf(t,"(%ld)",(long)SvIV(sv));
430 SvLEN(sv) += SvIV(sv);
431 SvPV(sv) -= SvIV(sv);
433 Move(s, SvPV(sv), SvCUR(sv)+1, char);
435 SvFLAGS(sv) &= ~SVf_OOK;
444 unsigned long newlen;
450 if (newlen >= 0x10000) {
451 fprintf(stderr, "Allocation too large: %lx\n", newlen);
457 if (SvTYPE(sv) < SVt_PV) {
458 sv_upgrade(sv, SVt_PV);
461 else if (SvOOK(sv)) { /* pv is offset? */
464 if (newlen > SvLEN(sv))
465 newlen += 10 * (newlen - SvCUR(sv)); /* avoid copy each time */
469 if (newlen > SvLEN(sv)) { /* need more room? */
471 Renew(s,newlen,char);
473 New(703,s,newlen,char);
475 SvLEN_set(sv, newlen);
487 if (SvTYPE(sv) < SVt_IV)
488 sv_upgrade(sv, SVt_IV);
489 else if (SvTYPE(sv) == SVt_PV)
490 sv_upgrade(sv, SVt_PVIV);
492 SvIOK_only(sv); /* validate number */
503 if (SvTYPE(sv) < SVt_NV)
504 sv_upgrade(sv, SVt_NV);
505 else if (SvTYPE(sv) < SVt_PVNV)
506 sv_upgrade(sv, SVt_PVNV);
507 else if (SvPOK(sv)) {
511 SvNOK_only(sv); /* validate number */
521 if (SvREADONLY(sv)) {
523 return (I32)SvNV(sv);
524 if (SvPOK(sv) && SvLEN(sv))
525 return atof(SvPV(sv));
527 warn("Use of uninitialized variable");
530 if (SvTYPE(sv) < SVt_IV) {
531 if (SvTYPE(sv) == SVt_REF)
532 return (I32)SvANYI32(sv);
533 sv_upgrade(sv, SVt_IV);
534 DEBUG_c((stderr,"0x%lx num(%g)\n",sv,SvIV(sv)));
537 else if (SvTYPE(sv) == SVt_PV)
538 sv_upgrade(sv, SVt_PVIV);
540 SvIV(sv) = (I32)SvNV(sv);
541 else if (SvPOK(sv) && SvLEN(sv))
542 SvIV(sv) = atol(SvPV(sv));
545 warn("Use of uninitialized variable");
546 SvUPGRADE(sv, SVt_IV);
550 DEBUG_c((stderr,"0x%lx 2iv(%d)\n",sv,SvIV(sv)));
560 if (SvREADONLY(sv)) {
561 if (SvPOK(sv) && SvLEN(sv))
562 return atof(SvPV(sv));
564 warn("Use of uninitialized variable");
567 if (SvTYPE(sv) < SVt_NV) {
568 if (SvTYPE(sv) == SVt_REF)
569 return (double)SvANYI32(sv);
570 sv_upgrade(sv, SVt_NV);
571 DEBUG_c((stderr,"0x%lx num(%g)\n",sv,SvNV(sv)));
574 else if (SvTYPE(sv) < SVt_PVNV)
575 sv_upgrade(sv, SVt_PVNV);
576 if (SvPOK(sv) && SvLEN(sv))
577 SvNV(sv) = atof(SvPV(sv));
579 SvNV(sv) = (double)SvIV(sv);
582 warn("Use of uninitialized variable");
586 DEBUG_c((stderr,"0x%lx 2nv(%g)\n",sv,SvNV(sv)));
599 if (SvTYPE(sv) == SVt_REF) {
602 return "<Empty reference>";
603 switch (SvTYPE(sv)) {
604 case SVt_NULL: s = "an undefined value"; break;
605 case SVt_REF: s = "a reference"; break;
606 case SVt_IV: s = "an integer value"; break;
607 case SVt_NV: s = "a numeric value"; break;
608 case SVt_PV: s = "a string value"; break;
609 case SVt_PVIV: s = "a string+integer value"; break;
610 case SVt_PVNV: s = "a scalar value"; break;
611 case SVt_PVMG: s = "a magic value"; break;
612 case SVt_PVLV: s = "an lvalue"; break;
613 case SVt_PVAV: s = "an array value"; break;
614 case SVt_PVHV: s = "an associative array value"; break;
615 case SVt_PVCV: s = "a code value"; break;
616 case SVt_PVGV: s = "a glob value"; break;
617 case SVt_PVBM: s = "a search string"; break;
618 case SVt_PVFM: s = "a formatline"; break;
619 default: s = "something weird"; break;
621 sprintf(tokenbuf,"<Reference to %s at 0x%lx>", s, (unsigned long)sv);
624 if (SvREADONLY(sv)) {
626 (void)sprintf(tokenbuf,"%ld",SvIV(sv));
630 (void)sprintf(tokenbuf,"%.20g",SvNV(sv));
634 warn("Use of uninitialized variable");
637 if (!SvUPGRADE(sv, SVt_PV))
640 if (SvTYPE(sv) < SVt_PVNV)
641 sv_upgrade(sv, SVt_PVNV);
644 olderrno = errno; /* some Xenix systems wipe out errno here */
645 #if defined(scs) && defined(ns32000)
653 (void)sprintf(s,"%.20g",SvNV(sv));
662 else if (SvIOK(sv)) {
663 if (SvTYPE(sv) < SVt_PVIV)
664 sv_upgrade(sv, SVt_PVIV);
667 olderrno = errno; /* some Xenix systems wipe out errno here */
668 (void)sprintf(s,"%ld",SvIV(sv));
674 warn("Use of uninitialized variable");
679 SvCUR_set(sv, s - SvPV(sv));
681 DEBUG_c((stderr,"0x%lx 2pv(%s)\n",sv,SvPV(sv)));
685 /* Note: sv_setsv() should not be called with a source string that needs
686 * be reused, since it may destroy the source string if it is marked
697 if (SvREADONLY(dstr))
702 if (SvTYPE(dstr) < SvTYPE(sstr))
703 sv_upgrade(dstr, SvTYPE(sstr));
704 else if (SvTYPE(dstr) == SVt_PV && SvTYPE(sstr) <= SVt_NV) {
705 if (SvTYPE(sstr) <= SVt_IV)
706 sv_upgrade(dstr, SVt_PVIV); /* handle discontinuities */
708 sv_upgrade(dstr, SVt_PVNV);
710 else if (SvTYPE(dstr) == SVt_PVIV && SvTYPE(sstr) == SVt_NV)
711 sv_upgrade(dstr, SVt_PVNV);
713 switch (SvTYPE(sstr)) {
715 if (SvTYPE(dstr) == SVt_REF) {
716 sv_free((SV*)SvANY(dstr));
718 SvTYPE(dstr) = SVt_NULL;
725 if (SvTYPE(dstr) == SVt_REF) {
726 SvANY(dstr) = (void*)sv_ref((SV*)SvANY(sstr));
730 fatal("Can't assign a reference to a magical variable");
732 SvTYPE(dstr) = SVt_REF;
733 SvANY(dstr) = (void*)sv_ref((SV*)SvANY(sstr));
740 if (SvTYPE(dstr) == SVt_PVGV) {
747 GvIO(sstr) = newIO();
750 GvGP(dstr) = gp_ref(GvGP(sstr));
763 SvPRIVATE(dstr) = SvPRIVATE(sstr);
764 SvSTORAGE(dstr) = SvSTORAGE(sstr);
771 * Check to see if we can just swipe the string. If so, it's a
772 * possible small lose on short strings, but a big win on long ones.
773 * It might even be a win on short strings if SvPV(dstr)
774 * has to be allocated and SvPV(sstr) has to be freed.
777 if (SvTEMP(sstr)) { /* slated for free anyway? */
780 Safefree(SvPV(dstr));
782 SvPV_set(dstr, SvPV(sstr));
783 SvLEN_set(dstr, SvLEN(sstr));
784 SvCUR_set(dstr, SvCUR(sstr));
785 SvTYPE(dstr) = SvTYPE(sstr);
788 SvPV_set(sstr, Nullch);
790 SvPOK_off(sstr); /* wipe out any weird flags */
791 SvTYPE(sstr) = 0; /* so sstr frees uneventfully */
793 else { /* have to copy actual string */
794 if (SvPV(dstr)) { /* XXX ck type */
797 sv_setpvn(dstr,SvPV(sstr),SvCUR(sstr));
802 SvNV(dstr) = SvNV(sstr);
806 SvIV(dstr) = SvIV(sstr);
809 else if (SvNOK(sstr)) {
811 SvNV(dstr) = SvNV(sstr);
815 SvIV(dstr) = SvIV(sstr);
818 else if (SvIOK(sstr)) {
821 SvIV(dstr) = SvIV(sstr);
831 sv_setpvn(sv,ptr,len)
836 if (!SvUPGRADE(sv, SVt_PV))
840 Move(ptr,SvPV(sv),len,char);
843 SvPOK_only(sv); /* validate pointer */
859 if (!SvUPGRADE(sv, SVt_PV))
862 Move(ptr,SvPV(sv),len+1,char);
864 SvPOK_only(sv); /* validate pointer */
869 sv_chop(sv,ptr) /* like set but assuming ptr is in sv */
873 register STRLEN delta;
875 if (!ptr || !SvPOK(sv))
879 if (SvTYPE(sv) < SVt_PVIV)
880 sv_upgrade(sv,SVt_PVIV);
884 SvFLAGS(sv) |= SVf_OOK;
886 SvFLAGS(sv) &= ~(SVf_IOK|SVf_NOK);
887 delta = ptr - SvPV(sv);
895 sv_catpvn(sv,ptr,len)
904 SvGROW(sv, SvCUR(sv) + len + 1);
905 Move(ptr,SvPV(sv)+SvCUR(sv),len,char);
908 SvPOK_only(sv); /* validate pointer */
920 if (s = SvPVn(sstr)) {
922 sv_catpvn(dstr,s,SvCUR(sstr));
942 SvGROW(sv, SvCUR(sv) + len + 1);
943 Move(ptr,SvPV(sv)+SvCUR(sv),len+1,char);
945 SvPOK_only(sv); /* validate pointer */
950 sv_append_till(sv,from,fromend,delim,keeplist)
953 register char *fromend;
964 len = fromend - from;
965 if (!SvUPGRADE(sv, SVt_PV))
967 SvGROW(sv, SvCUR(sv) + len + 1);
968 SvPOK_only(sv); /* validate pointer */
969 to = SvPV(sv)+SvCUR(sv);
970 for (; from < fromend; from++,to++) {
971 if (*from == '\\' && from+1 < fromend && delim != '\\') {
974 else if (from[1] && index(keeplist,from[1]))
979 else if (*from == delim)
984 SvCUR_set(sv, to - SvPV(sv));
1003 sv_upgrade(sv, SVt_PV);
1004 SvGROW(sv, len + 1);
1010 sv_magic(sv, obj, how, name, namlen)
1021 if (!SvUPGRADE(sv, SVt_PVMG))
1023 Newz(702,mg, 1, MAGIC);
1024 mg->mg_moremagic = SvMAGIC(sv);
1030 mg->mg_ptr = nsavestr(name, namlen);
1031 mg->mg_len = namlen;
1035 mg->mg_virtual = &vtbl_sv;
1038 mg->mg_virtual = &vtbl_bm;
1041 mg->mg_virtual = &vtbl_dbm;
1044 mg->mg_virtual = &vtbl_dbmelem;
1047 mg->mg_virtual = &vtbl_env;
1050 mg->mg_virtual = &vtbl_envelem;
1053 mg->mg_virtual = &vtbl_dbline;
1056 mg->mg_virtual = &vtbl_sig;
1059 mg->mg_virtual = &vtbl_sigelem;
1062 mg->mg_virtual = &vtbl_uvar;
1065 mg->mg_virtual = &vtbl_vec;
1068 mg->mg_virtual = &vtbl_substr;
1071 mg->mg_virtual = &vtbl_glob;
1074 mg->mg_virtual = &vtbl_arylen;
1077 fatal("Don't know how to handle magic of type '%c'", how);
1082 sv_insert(bigstr,offset,len,little,littlelen)
1091 register char *midend;
1092 register char *bigend;
1095 if (SvREADONLY(bigstr))
1099 i = littlelen - len;
1100 if (i > 0) { /* string might grow */
1101 if (!SvUPGRADE(bigstr, SVt_PV))
1103 SvGROW(bigstr, SvCUR(bigstr) + i + 1);
1105 mid = big + offset + len;
1106 midend = bigend = big + SvCUR(bigstr);
1109 while (midend > mid) /* shove everything down */
1110 *--bigend = *--midend;
1111 Move(little,big+offset,littlelen,char);
1117 Move(little,SvPV(bigstr)+offset,len,char);
1125 bigend = big + SvCUR(bigstr);
1127 if (midend > bigend)
1128 fatal("panic: sv_insert");
1130 if (mid - big > bigend - midend) { /* faster to shorten from end */
1132 Move(little, mid, littlelen,char);
1135 i = bigend - midend;
1137 Move(midend, mid, i,char);
1141 SvCUR_set(bigstr, mid - big);
1144 else if (i = mid - big) { /* faster from front */
1145 midend -= littlelen;
1147 sv_chop(bigstr,midend-i);
1152 Move(little, mid, littlelen,char);
1154 else if (littlelen) {
1155 midend -= littlelen;
1156 sv_chop(bigstr,midend);
1157 Move(little,midend,littlelen,char);
1160 sv_chop(bigstr,midend);
1165 /* make sv point to what nstr did */
1172 U32 refcnt = SvREFCNT(sv);
1175 if (SvREFCNT(nsv) != 1)
1176 warn("Reference miscount in sv_replace()");
1179 StructCopy(nsv,sv,SV);
1180 SvREFCNT(sv) = refcnt;
1189 assert(SvREFCNT(sv) == 0);
1191 switch (SvTYPE(sv)) {
1200 op_free(CvSTART(sv));
1203 hv_clear(sv, FALSE);
1227 sv_free((SV*)SvANY(sv));
1233 switch (SvTYPE(sv)) {
1248 del_XPVIV(SvANY(sv));
1251 del_XPVNV(SvANY(sv));
1254 del_XPVMG(SvANY(sv));
1257 del_XPVLV(SvANY(sv));
1260 del_XPVAV(SvANY(sv));
1263 del_XPVHV(SvANY(sv));
1266 del_XPVCV(SvANY(sv));
1269 del_XPVGV(SvANY(sv));
1272 del_XPVBM(SvANY(sv));
1275 del_XPVFM(SvANY(sv));
1278 DEB(SvTYPE(sv) = 0xff;)
1295 if (SvREADONLY(sv)) {
1296 if (sv == &sv_undef || sv == &sv_yes || sv == &sv_no)
1299 if (SvREFCNT(sv) == 0) {
1300 warn("Attempt to free unreferenced scalar");
1303 if (--SvREFCNT(sv) > 0)
1305 if (SvSTORAGE(sv) == 'O') {
1307 BINOP myop; /* fake syntax tree node */
1310 SvSTORAGE(sv) = 0; /* Curse the object. */
1315 curcop = &compiling;
1316 curstash = SvSTASH(sv);
1317 destructor = gv_fetchpv("DESTROY", FALSE);
1319 if (GvCV(destructor)) {
1320 SV* ref = sv_mortalcopy(&sv_undef);
1322 sv_upgrade(ref, SVt_REF);
1323 SvANY(ref) = (void*)sv_ref(sv);
1327 myop.op_last = (OP*)&myop;
1328 myop.op_flags = OPf_STACKED;
1329 myop.op_next = Nullop;
1332 PUSHs((SV*)destructor);
1336 op = pp_entersubr();
1339 LEAVE; /* Will eventually free sv as ordinary item. */
1345 DEB(SvTYPE(sv) = 0xff;)
1361 return mg_len(sv, SvMAGIC(sv));
1389 if (SvMAGICAL(str1))
1403 if (SvMAGICAL(str2))
1417 return !bcmp(pv1, pv2, cur1);
1436 if (SvMAGICAL(str1))
1452 if (SvMAGICAL(str2))
1464 return cur2 ? -1 : 0;
1470 if (retval = memcmp(pv1, pv2, cur1))
1471 return retval < 0 ? -1 : 1;
1476 else if (retval = memcmp(pv1, pv2, cur2))
1477 return retval < 0 ? -1 : 1;
1478 else if (cur1 == cur2)
1485 sv_gets(sv,fp,append)
1490 register char *bp; /* we're going to steal some values */
1491 register I32 cnt; /* from the stdio struct and put EVERYTHING */
1492 register STDCHAR *ptr; /* in the innermost loop into registers */
1493 register I32 newline = rschar;/* (assuming >= 6 registers) */
1500 if (!SvUPGRADE(sv, SVt_PV))
1502 if (rspara) { /* have to do this both before and after */
1503 do { /* to make sure file boundaries work right */
1511 #ifdef STDSTDIO /* Here is some breathtakingly efficient cheating */
1512 cnt = fp->_cnt; /* get count into register */
1513 SvPOK_only(sv); /* validate pointer */
1514 if (SvLEN(sv) - append <= cnt + 1) { /* make sure we have the room */
1515 if (cnt > 80 && SvLEN(sv) > append) {
1516 shortbuffered = cnt - SvLEN(sv) + append + 1;
1517 cnt -= shortbuffered;
1521 SvGROW(sv, append+cnt+2);/* (remembering cnt can be -1) */
1526 bp = SvPV(sv) + append; /* move these two too to registers */
1530 while (--cnt >= 0) { /* this */ /* eat */
1531 if ((*bp++ = *ptr++) == newline) /* really */ /* dust */
1532 goto thats_all_folks; /* screams */ /* sed :-) */
1535 if (shortbuffered) { /* oh well, must extend */
1536 cnt = shortbuffered;
1538 bpx = bp - SvPV(sv); /* prepare for possible relocation */
1540 SvGROW(sv, SvLEN(sv) + append + cnt + 2);
1541 bp = SvPV(sv) + bpx; /* reconstitute our pointer */
1545 fp->_cnt = cnt; /* deregisterize cnt and ptr */
1547 i = _filbuf(fp); /* get more characters */
1549 ptr = fp->_ptr; /* reregisterize cnt and ptr */
1551 bpx = bp - SvPV(sv); /* prepare for possible relocation */
1553 SvGROW(sv, bpx + cnt + 2);
1554 bp = SvPV(sv) + bpx; /* reconstitute our pointer */
1556 if (i == newline) { /* all done for now? */
1558 goto thats_all_folks;
1560 else if (i == EOF) /* all done for ever? */
1561 goto thats_really_all_folks;
1562 *bp++ = i; /* now go back to screaming loop */
1566 if (rslen > 1 && (bp - SvPV(sv) < rslen || bcmp(bp - rslen, rs, rslen)))
1567 goto screamer; /* go back to the fray */
1568 thats_really_all_folks:
1570 cnt += shortbuffered;
1571 fp->_cnt = cnt; /* put these back or we're in trouble */
1574 SvCUR_set(sv, bp - SvPV(sv)); /* set length */
1576 #else /* !STDSTDIO */ /* The big, slow, and stupid way */
1580 register char * bpe = buf + sizeof(buf) - 3;
1584 while ((i = getc(fp)) != EOF && (*bp++ = i) != newline && bp < bpe) ;
1587 sv_catpvn(sv, buf, bp - buf);
1589 sv_setpvn(sv, buf, bp - buf);
1590 if (i != EOF /* joy */
1598 bcmp(SvPV(sv) + SvCUR(sv) - rslen, rs, rslen)
1609 #endif /* STDSTDIO */
1620 return SvCUR(sv) - append ? SvPV(sv) : Nullch;
1645 if (!SvPOK(sv) || !*SvPV(sv)) {
1646 if (!SvUPGRADE(sv, SVt_NV))
1653 while (isALPHA(*d)) d++;
1654 while (isDIGIT(*d)) d++;
1656 sv_setnv(sv,atof(SvPV(sv)) + 1.0); /* punt */
1660 while (d >= SvPV(sv)) {
1670 *(d--) -= 'z' - 'a' + 1;
1673 /* oh,oh, the number grew */
1674 SvGROW(sv, SvCUR(sv) + 2);
1676 for (d = SvPV(sv) + SvCUR(sv); d > SvPV(sv); d--)
1705 if (!SvUPGRADE(sv, SVt_NV))
1711 sv_setnv(sv,atof(SvPV(sv)) - 1.0);
1714 /* Make a string that will exist for the duration of the expression
1715 * evaluation. Actually, it may have to last longer than that, but
1716 * hopefully we won't free it until it has been assigned to a
1717 * permanent location. */
1720 sv_mortalcopy(oldstr)
1723 register SV *sv = NEWSV(78,0);
1725 sv_setsv(sv,oldstr);
1726 if (++tmps_ix > tmps_max) {
1728 if (!(tmps_max & 127)) {
1730 Renew(tmps_stack, tmps_max + 128, SV*);
1732 New(702,tmps_stack, 128, SV*);
1735 tmps_stack[tmps_ix] = sv;
1741 /* same thing without the copying */
1751 if (++tmps_ix > tmps_max) {
1753 if (!(tmps_max & 127)) {
1755 Renew(tmps_stack, tmps_max + 128, SV*);
1757 New(704,tmps_stack, 128, SV*);
1760 tmps_stack[tmps_ix] = sv;
1771 register SV *sv = NEWSV(79,0);
1775 sv_setpvn(sv,s,len);
1783 register SV *sv = NEWSV(80,0);
1793 register SV *sv = NEWSV(80,0);
1799 /* make an exact duplicate of old */
1809 if (SvTYPE(old) == 0xff) {
1810 warn("semi-panic: attempt to dup freed string");
1836 if (!*s) { /* reset ?? searches */
1837 for (pm = HvPMROOT(stash); pm; pm = pm->op_pmnext) {
1838 pm->op_pmflags &= ~PMf_USED;
1843 /* reset variables */
1845 if (!HvARRAY(stash))
1853 for ( ; i <= max; i++) {
1854 for (entry = HvARRAY(stash)[i];
1856 entry = entry->hent_next) {
1857 gv = (GV*)entry->hent_val;
1860 if (SvTYPE(sv) >= SVt_PV) {
1863 if (SvPV(sv) != Nullch)
1870 hv_clear(GvHV(gv), FALSE);
1872 environ[0] = Nullch;
1881 sv_2av(sv, st, gvp, lref)
1889 switch (SvTYPE(sv)) {
1891 *st = sv->sv_u.sv_stash;
1893 return sv->sv_u.sv_av;
1902 gv = gv_fetchpv(SvPVn(sv), lref);
1915 sv_2hv(sv, st, gvp, lref)
1923 switch (SvTYPE(sv)) {
1925 *st = sv->sv_u.sv_stash;
1927 return sv->sv_u.sv_hv;
1936 gv = gv_fetchpv(SvPVn(sv), lref);
1950 sv_2cv(sv, st, gvp, lref)
1961 switch (SvTYPE(sv)) {
1963 cv = (CV*)SvANY(sv);
1964 if (SvTYPE(cv) != SVt_PVCV)
1965 fatal("Not a subroutine reference");
1981 gv = gv_fetchpv(SvPVn(sv), lref);
1999 if ((Xpv = (XPV*)SvANY(sv)) &&
2000 (*Xpv->xpv_pv > '0' ||
2002 (Xpv->xpv_cur && *Xpv->xpv_pv != '0')))
2009 return SvIV(sv) != 0;
2012 return SvNV(sv) != 0.0;
2030 return (double)SvIV(Sv);
2043 return SvPOK(sv) ? SvPV(sv) : sv_2pv(sv);