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();
302 SvANY(sv) = new_XPVBM();
315 SvANY(sv) = new_XPVFM();
342 else if (sv == (SV*)0x55555555 || SvTYPE(sv) == 'U') {
346 else if (SvREFCNT(sv) == 0 && !SvREADONLY(sv)) {
351 switch (SvTYPE(sv)) {
362 if (t - tokenbuf > 10) {
363 strcpy(tokenbuf + 3,"...");
415 sprintf(t,"(%d+\"%0.127s\")",SvIV(sv),SvPV(sv));
417 sprintf(t,"(\"%0.127s\")",SvPV(sv));
420 sprintf(t,"(%g)",SvNV(sv));
422 sprintf(t,"(%ld)",(long)SvIV(sv));
435 SvLEN(sv) += SvIV(sv);
436 SvPV(sv) -= SvIV(sv);
438 Move(s, SvPV(sv), SvCUR(sv)+1, char);
440 SvFLAGS(sv) &= ~SVf_OOK;
449 unsigned long newlen;
455 if (newlen >= 0x10000) {
456 fprintf(stderr, "Allocation too large: %lx\n", newlen);
462 if (SvTYPE(sv) < SVt_PV) {
463 sv_upgrade(sv, SVt_PV);
466 else if (SvOOK(sv)) { /* pv is offset? */
469 if (newlen > SvLEN(sv))
470 newlen += 10 * (newlen - SvCUR(sv)); /* avoid copy each time */
474 if (newlen > SvLEN(sv)) { /* need more room? */
476 Renew(s,newlen,char);
478 New(703,s,newlen,char);
480 SvLEN_set(sv, newlen);
492 if (SvTYPE(sv) < SVt_IV)
493 sv_upgrade(sv, SVt_IV);
494 else if (SvTYPE(sv) == SVt_PV)
495 sv_upgrade(sv, SVt_PVIV);
497 SvIOK_only(sv); /* validate number */
508 if (SvTYPE(sv) < SVt_NV)
509 sv_upgrade(sv, SVt_NV);
510 else if (SvTYPE(sv) < SVt_PVNV)
511 sv_upgrade(sv, SVt_PVNV);
512 else if (SvPOK(sv)) {
516 SvNOK_only(sv); /* validate number */
526 if (SvREADONLY(sv)) {
528 return (I32)SvNV(sv);
529 if (SvPOK(sv) && SvLEN(sv))
530 return atof(SvPV(sv));
532 warn("Use of uninitialized variable");
535 if (SvTYPE(sv) < SVt_IV) {
536 if (SvTYPE(sv) == SVt_REF)
537 return (I32)SvANYI32(sv);
538 sv_upgrade(sv, SVt_IV);
539 DEBUG_c((stderr,"0x%lx num(%g)\n",sv,SvIV(sv)));
542 else if (SvTYPE(sv) == SVt_PV)
543 sv_upgrade(sv, SVt_PVIV);
545 SvIV(sv) = (I32)SvNV(sv);
546 else if (SvPOK(sv) && SvLEN(sv)) {
547 if (dowarn && !looks_like_number(sv)) {
549 warn("Argument wasn't numeric for \"%s\"",op_name[op->op_type]);
551 warn("Argument wasn't numeric");
553 SvIV(sv) = atol(SvPV(sv));
557 warn("Use of uninitialized variable");
558 SvUPGRADE(sv, SVt_IV);
562 DEBUG_c((stderr,"0x%lx 2iv(%d)\n",sv,SvIV(sv)));
572 if (SvREADONLY(sv)) {
573 if (SvPOK(sv) && SvLEN(sv))
574 return atof(SvPV(sv));
576 warn("Use of uninitialized variable");
579 if (SvTYPE(sv) < SVt_NV) {
580 if (SvTYPE(sv) == SVt_REF)
581 return (double)SvANYI32(sv);
582 sv_upgrade(sv, SVt_NV);
583 DEBUG_c((stderr,"0x%lx num(%g)\n",sv,SvNV(sv)));
586 else if (SvTYPE(sv) < SVt_PVNV)
587 sv_upgrade(sv, SVt_PVNV);
589 (!SvPOK(sv) || !strchr(SvPV(sv),'.') || !looks_like_number(sv)))
591 SvNV(sv) = (double)SvIV(sv);
593 else if (SvPOK(sv) && SvLEN(sv)) {
594 if (dowarn && !SvIOK(sv) && !looks_like_number(sv)) {
596 warn("Argument wasn't numeric for \"%s\"",op_name[op->op_type]);
598 warn("Argument wasn't numeric");
600 SvNV(sv) = atof(SvPV(sv));
604 warn("Use of uninitialized variable");
608 DEBUG_c((stderr,"0x%lx 2nv(%g)\n",sv,SvNV(sv)));
621 if (SvTYPE(sv) == SVt_REF) {
624 return "<Empty reference>";
625 switch (SvTYPE(sv)) {
626 case SVt_NULL: s = "an undefined value"; break;
627 case SVt_REF: s = "a reference"; break;
628 case SVt_IV: s = "an integer value"; break;
629 case SVt_NV: s = "a numeric value"; break;
630 case SVt_PV: s = "a string value"; break;
631 case SVt_PVIV: s = "a string+integer value"; break;
632 case SVt_PVNV: s = "a scalar value"; break;
633 case SVt_PVMG: s = "a magic value"; break;
634 case SVt_PVLV: s = "an lvalue"; break;
635 case SVt_PVAV: s = "an array value"; break;
636 case SVt_PVHV: s = "an associative array value"; break;
637 case SVt_PVCV: s = "a code value"; break;
638 case SVt_PVGV: s = "a glob value"; break;
639 case SVt_PVBM: s = "a search string"; break;
640 case SVt_PVFM: s = "a formatline"; break;
641 default: s = "something weird"; break;
643 sprintf(tokenbuf,"<Reference to %s at 0x%lx>", s, (unsigned long)sv);
646 if (SvREADONLY(sv)) {
648 (void)sprintf(tokenbuf,"%ld",SvIV(sv));
652 (void)sprintf(tokenbuf,"%.20g",SvNV(sv));
656 warn("Use of uninitialized variable");
659 if (!SvUPGRADE(sv, SVt_PV))
662 if (SvTYPE(sv) < SVt_PVNV)
663 sv_upgrade(sv, SVt_PVNV);
666 olderrno = errno; /* some Xenix systems wipe out errno here */
667 #if defined(scs) && defined(ns32000)
675 (void)sprintf(s,"%.20g",SvNV(sv));
684 else if (SvIOK(sv)) {
685 if (SvTYPE(sv) < SVt_PVIV)
686 sv_upgrade(sv, SVt_PVIV);
689 olderrno = errno; /* some Xenix systems wipe out errno here */
690 (void)sprintf(s,"%ld",SvIV(sv));
696 warn("Use of uninitialized variable");
701 SvCUR_set(sv, s - SvPV(sv));
703 DEBUG_c((stderr,"0x%lx 2pv(%s)\n",sv,SvPV(sv)));
707 /* Note: sv_setsv() should not be called with a source string that needs
708 * be reused, since it may destroy the source string if it is marked
719 if (SvREADONLY(dstr))
724 if (SvTYPE(dstr) < SvTYPE(sstr))
725 sv_upgrade(dstr, SvTYPE(sstr));
726 else if (SvTYPE(dstr) == SVt_PV && SvTYPE(sstr) <= SVt_NV) {
727 if (SvTYPE(sstr) <= SVt_IV)
728 sv_upgrade(dstr, SVt_PVIV); /* handle discontinuities */
730 sv_upgrade(dstr, SVt_PVNV);
732 else if (SvTYPE(dstr) == SVt_PVIV && SvTYPE(sstr) == SVt_NV)
733 sv_upgrade(dstr, SVt_PVNV);
735 switch (SvTYPE(sstr)) {
737 if (SvTYPE(dstr) == SVt_REF) {
738 sv_free((SV*)SvANY(dstr));
740 SvTYPE(dstr) = SVt_NULL;
747 if (SvTYPE(dstr) == SVt_REF) {
748 SvANY(dstr) = (void*)sv_ref((SV*)SvANY(sstr));
752 fatal("Can't assign a reference to a magical variable");
754 SvTYPE(dstr) = SVt_REF;
755 SvANY(dstr) = (void*)sv_ref((SV*)SvANY(sstr));
762 if (SvTYPE(dstr) == SVt_PVGV) {
769 GvIO(sstr) = newIO();
772 GvGP(dstr) = gp_ref(GvGP(sstr));
785 SvPRIVATE(dstr) = SvPRIVATE(sstr);
786 SvSTORAGE(dstr) = SvSTORAGE(sstr);
793 * Check to see if we can just swipe the string. If so, it's a
794 * possible small lose on short strings, but a big win on long ones.
795 * It might even be a win on short strings if SvPV(dstr)
796 * has to be allocated and SvPV(sstr) has to be freed.
799 if (SvTEMP(sstr)) { /* slated for free anyway? */
802 Safefree(SvPV(dstr));
804 SvPV_set(dstr, SvPV(sstr));
805 SvLEN_set(dstr, SvLEN(sstr));
806 SvCUR_set(dstr, SvCUR(sstr));
807 SvTYPE(dstr) = SvTYPE(sstr);
810 SvPV_set(sstr, Nullch);
812 SvPOK_off(sstr); /* wipe out any weird flags */
813 SvTYPE(sstr) = 0; /* so sstr frees uneventfully */
815 else { /* have to copy actual string */
816 if (SvPV(dstr)) { /* XXX ck type */
819 sv_setpvn(dstr,SvPV(sstr),SvCUR(sstr));
824 SvNV(dstr) = SvNV(sstr);
828 SvIV(dstr) = SvIV(sstr);
831 else if (SvNOK(sstr)) {
833 SvNV(dstr) = SvNV(sstr);
837 SvIV(dstr) = SvIV(sstr);
840 else if (SvIOK(sstr)) {
843 SvIV(dstr) = SvIV(sstr);
853 sv_setpvn(sv,ptr,len)
858 if (!SvUPGRADE(sv, SVt_PV))
862 Move(ptr,SvPV(sv),len,char);
865 SvPOK_only(sv); /* validate pointer */
881 if (!SvUPGRADE(sv, SVt_PV))
884 Move(ptr,SvPV(sv),len+1,char);
886 SvPOK_only(sv); /* validate pointer */
891 sv_chop(sv,ptr) /* like set but assuming ptr is in sv */
895 register STRLEN delta;
897 if (!ptr || !SvPOK(sv))
901 if (SvTYPE(sv) < SVt_PVIV)
902 sv_upgrade(sv,SVt_PVIV);
906 SvFLAGS(sv) |= SVf_OOK;
908 SvFLAGS(sv) &= ~(SVf_IOK|SVf_NOK);
909 delta = ptr - SvPV(sv);
917 sv_catpvn(sv,ptr,len)
926 SvGROW(sv, SvCUR(sv) + len + 1);
927 Move(ptr,SvPV(sv)+SvCUR(sv),len,char);
930 SvPOK_only(sv); /* validate pointer */
942 if (s = SvPVn(sstr)) {
944 sv_catpvn(dstr,s,SvCUR(sstr));
964 SvGROW(sv, SvCUR(sv) + len + 1);
965 Move(ptr,SvPV(sv)+SvCUR(sv),len+1,char);
967 SvPOK_only(sv); /* validate pointer */
986 sv_upgrade(sv, SVt_PV);
993 sv_magic(sv, obj, how, name, namlen)
1004 if (!SvUPGRADE(sv, SVt_PVMG))
1006 Newz(702,mg, 1, MAGIC);
1007 mg->mg_moremagic = SvMAGIC(sv);
1013 mg->mg_ptr = nsavestr(name, namlen);
1014 mg->mg_len = namlen;
1018 mg->mg_virtual = &vtbl_sv;
1021 mg->mg_virtual = &vtbl_bm;
1024 mg->mg_virtual = &vtbl_dbm;
1027 mg->mg_virtual = &vtbl_dbmelem;
1030 mg->mg_virtual = &vtbl_env;
1033 mg->mg_virtual = &vtbl_envelem;
1036 mg->mg_virtual = &vtbl_mglob;
1042 mg->mg_virtual = &vtbl_dbline;
1045 mg->mg_virtual = &vtbl_sig;
1048 mg->mg_virtual = &vtbl_sigelem;
1051 mg->mg_virtual = &vtbl_uvar;
1054 mg->mg_virtual = &vtbl_vec;
1057 mg->mg_virtual = &vtbl_substr;
1060 mg->mg_virtual = &vtbl_glob;
1063 mg->mg_virtual = &vtbl_arylen;
1066 fatal("Don't know how to handle magic of type '%c'", how);
1071 sv_insert(bigstr,offset,len,little,littlelen)
1080 register char *midend;
1081 register char *bigend;
1084 if (SvREADONLY(bigstr))
1088 i = littlelen - len;
1089 if (i > 0) { /* string might grow */
1090 if (!SvUPGRADE(bigstr, SVt_PV))
1092 SvGROW(bigstr, SvCUR(bigstr) + i + 1);
1094 mid = big + offset + len;
1095 midend = bigend = big + SvCUR(bigstr);
1098 while (midend > mid) /* shove everything down */
1099 *--bigend = *--midend;
1100 Move(little,big+offset,littlelen,char);
1106 Move(little,SvPV(bigstr)+offset,len,char);
1114 bigend = big + SvCUR(bigstr);
1116 if (midend > bigend)
1117 fatal("panic: sv_insert");
1119 if (mid - big > bigend - midend) { /* faster to shorten from end */
1121 Move(little, mid, littlelen,char);
1124 i = bigend - midend;
1126 Move(midend, mid, i,char);
1130 SvCUR_set(bigstr, mid - big);
1133 else if (i = mid - big) { /* faster from front */
1134 midend -= littlelen;
1136 sv_chop(bigstr,midend-i);
1141 Move(little, mid, littlelen,char);
1143 else if (littlelen) {
1144 midend -= littlelen;
1145 sv_chop(bigstr,midend);
1146 Move(little,midend,littlelen,char);
1149 sv_chop(bigstr,midend);
1154 /* make sv point to what nstr did */
1161 U32 refcnt = SvREFCNT(sv);
1164 if (SvREFCNT(nsv) != 1)
1165 warn("Reference miscount in sv_replace()");
1166 if (SvMAGICAL(sv)) {
1167 SvUPGRADE(nsv, SVt_PVMG);
1168 SvMAGIC(nsv) = SvMAGIC(sv);
1175 StructCopy(nsv,sv,SV);
1176 SvREFCNT(sv) = refcnt;
1185 assert(SvREFCNT(sv) == 0);
1187 switch (SvTYPE(sv)) {
1196 op_free(CvSTART(sv));
1199 hv_clear(sv, FALSE);
1223 sv_free((SV*)SvANY(sv));
1229 switch (SvTYPE(sv)) {
1244 del_XPVIV(SvANY(sv));
1247 del_XPVNV(SvANY(sv));
1250 del_XPVMG(SvANY(sv));
1253 del_XPVLV(SvANY(sv));
1256 del_XPVAV(SvANY(sv));
1259 del_XPVHV(SvANY(sv));
1262 del_XPVCV(SvANY(sv));
1265 del_XPVGV(SvANY(sv));
1268 del_XPVBM(SvANY(sv));
1271 del_XPVFM(SvANY(sv));
1274 DEB(SvTYPE(sv) = 0xff;)
1291 if (SvREADONLY(sv)) {
1292 if (sv == &sv_undef || sv == &sv_yes || sv == &sv_no)
1295 if (SvREFCNT(sv) == 0) {
1296 warn("Attempt to free unreferenced scalar");
1299 if (--SvREFCNT(sv) > 0)
1301 if (SvSTORAGE(sv) == 'O') {
1303 BINOP myop; /* fake syntax tree node */
1306 SvSTORAGE(sv) = 0; /* Curse the object. */
1311 curcop = &compiling;
1312 curstash = SvSTASH(sv);
1313 destructor = gv_fetchpv("DESTROY", FALSE);
1315 if (GvCV(destructor)) {
1316 SV* ref = sv_mortalcopy(&sv_undef);
1318 sv_upgrade(ref, SVt_REF);
1319 SvANY(ref) = (void*)sv_ref(sv);
1323 myop.op_last = (OP*)&myop;
1324 myop.op_flags = OPf_STACKED;
1325 myop.op_next = Nullop;
1328 PUSHs((SV*)destructor);
1332 op = pp_entersubr();
1335 LEAVE; /* Will eventually free sv as ordinary item. */
1341 DEB(SvTYPE(sv) = 0xff;)
1385 if (SvMAGICAL(str1))
1399 if (SvMAGICAL(str2))
1413 return !bcmp(pv1, pv2, cur1);
1432 if (SvMAGICAL(str1))
1448 if (SvMAGICAL(str2))
1460 return cur2 ? -1 : 0;
1466 if (retval = memcmp(pv1, pv2, cur1))
1467 return retval < 0 ? -1 : 1;
1472 else if (retval = memcmp(pv1, pv2, cur2))
1473 return retval < 0 ? -1 : 1;
1474 else if (cur1 == cur2)
1481 sv_gets(sv,fp,append)
1486 register char *bp; /* we're going to steal some values */
1487 register I32 cnt; /* from the stdio struct and put EVERYTHING */
1488 register STDCHAR *ptr; /* in the innermost loop into registers */
1489 register I32 newline = rschar;/* (assuming >= 6 registers) */
1496 if (!SvUPGRADE(sv, SVt_PV))
1498 if (rspara) { /* have to do this both before and after */
1499 do { /* to make sure file boundaries work right */
1507 #ifdef STDSTDIO /* Here is some breathtakingly efficient cheating */
1508 cnt = fp->_cnt; /* get count into register */
1509 SvPOK_only(sv); /* validate pointer */
1510 if (SvLEN(sv) - append <= cnt + 1) { /* make sure we have the room */
1511 if (cnt > 80 && SvLEN(sv) > append) {
1512 shortbuffered = cnt - SvLEN(sv) + append + 1;
1513 cnt -= shortbuffered;
1517 SvGROW(sv, append+cnt+2);/* (remembering cnt can be -1) */
1522 bp = SvPV(sv) + append; /* move these two too to registers */
1527 while (--cnt >= 0) { /* this */ /* eat */
1528 if ((*bp++ = *ptr++) == newline) /* really */ /* dust */
1529 goto thats_all_folks; /* screams */ /* sed :-) */
1533 if (shortbuffered) { /* oh well, must extend */
1534 cnt = shortbuffered;
1536 bpx = bp - SvPV(sv); /* prepare for possible relocation */
1538 SvGROW(sv, SvLEN(sv) + append + cnt + 2);
1539 bp = SvPV(sv) + bpx; /* reconstitute our pointer */
1543 fp->_cnt = cnt; /* deregisterize cnt and ptr */
1545 i = _filbuf(fp); /* get more characters */
1547 ptr = fp->_ptr; /* reregisterize cnt and ptr */
1549 bpx = bp - SvPV(sv); /* prepare for possible relocation */
1551 SvGROW(sv, bpx + cnt + 2);
1552 bp = SvPV(sv) + bpx; /* reconstitute our pointer */
1554 if (i == newline) { /* all done for now? */
1556 goto thats_all_folks;
1558 else if (i == EOF) /* all done for ever? */
1559 goto thats_really_all_folks;
1560 *bp++ = i; /* now go back to screaming loop */
1564 if (rslen > 1 && (bp - SvPV(sv) < rslen || bcmp(bp - rslen, rs, rslen)))
1565 goto screamer; /* go back to the fray */
1566 thats_really_all_folks:
1568 cnt += shortbuffered;
1569 fp->_cnt = cnt; /* put these back or we're in trouble */
1572 SvCUR_set(sv, bp - SvPV(sv)); /* set length */
1574 #else /* !STDSTDIO */ /* The big, slow, and stupid way */
1578 register char * bpe = buf + sizeof(buf) - 3;
1582 while ((i = getc(fp)) != EOF && (*bp++ = i) != newline && bp < bpe) ;
1585 sv_catpvn(sv, buf, bp - buf);
1587 sv_setpvn(sv, buf, bp - buf);
1588 if (i != EOF /* joy */
1596 bcmp(SvPV(sv) + SvCUR(sv) - rslen, rs, rslen)
1607 #endif /* STDSTDIO */
1618 return SvCUR(sv) - append ? SvPV(sv) : Nullch;
1643 if (!SvPOK(sv) || !*SvPV(sv)) {
1644 if (!SvUPGRADE(sv, SVt_NV))
1651 while (isALPHA(*d)) d++;
1652 while (isDIGIT(*d)) d++;
1654 sv_setnv(sv,atof(SvPV(sv)) + 1.0); /* punt */
1658 while (d >= SvPV(sv)) {
1668 *(d--) -= 'z' - 'a' + 1;
1671 /* oh,oh, the number grew */
1672 SvGROW(sv, SvCUR(sv) + 2);
1674 for (d = SvPV(sv) + SvCUR(sv); d > SvPV(sv); d--)
1703 if (!SvUPGRADE(sv, SVt_NV))
1709 sv_setnv(sv,atof(SvPV(sv)) - 1.0);
1712 /* Make a string that will exist for the duration of the expression
1713 * evaluation. Actually, it may have to last longer than that, but
1714 * hopefully we won't free it until it has been assigned to a
1715 * permanent location. */
1718 sv_mortalcopy(oldstr)
1721 register SV *sv = NEWSV(78,0);
1723 sv_setsv(sv,oldstr);
1724 if (++tmps_ix > tmps_max) {
1726 if (!(tmps_max & 127)) {
1728 Renew(tmps_stack, tmps_max + 128, SV*);
1730 New(702,tmps_stack, 128, SV*);
1733 tmps_stack[tmps_ix] = sv;
1739 /* same thing without the copying */
1749 if (++tmps_ix > tmps_max) {
1751 if (!(tmps_max & 127)) {
1753 Renew(tmps_stack, tmps_max + 128, SV*);
1755 New(704,tmps_stack, 128, SV*);
1758 tmps_stack[tmps_ix] = sv;
1769 register SV *sv = NEWSV(79,0);
1773 sv_setpvn(sv,s,len);
1781 register SV *sv = NEWSV(80,0);
1791 register SV *sv = NEWSV(80,0);
1797 /* make an exact duplicate of old */
1807 if (SvTYPE(old) == 0xff) {
1808 warn("semi-panic: attempt to dup freed string");
1834 if (!*s) { /* reset ?? searches */
1835 for (pm = HvPMROOT(stash); pm; pm = pm->op_pmnext) {
1836 pm->op_pmflags &= ~PMf_USED;
1841 /* reset variables */
1843 if (!HvARRAY(stash))
1851 for ( ; i <= max; i++) {
1852 for (entry = HvARRAY(stash)[i];
1854 entry = entry->hent_next) {
1855 gv = (GV*)entry->hent_val;
1858 if (SvTYPE(sv) >= SVt_PV) {
1861 if (SvPV(sv) != Nullch)
1868 hv_clear(GvHV(gv), FALSE);
1870 environ[0] = Nullch;
1879 sv_2av(sv, st, gvp, lref)
1887 switch (SvTYPE(sv)) {
1889 *st = sv->sv_u.sv_stash;
1891 return sv->sv_u.sv_av;
1900 gv = gv_fetchpv(SvPVn(sv), lref);
1913 sv_2hv(sv, st, gvp, lref)
1921 switch (SvTYPE(sv)) {
1923 *st = sv->sv_u.sv_stash;
1925 return sv->sv_u.sv_hv;
1934 gv = gv_fetchpv(SvPVn(sv), lref);
1948 sv_2cv(sv, st, gvp, lref)
1958 return *gvp = Nullgv, Nullcv;
1959 switch (SvTYPE(sv)) {
1961 cv = (CV*)SvANY(sv);
1962 if (SvTYPE(cv) != SVt_PVCV)
1963 fatal("Not a subroutine reference");
1979 gv = gv_fetchpv(SvPVn(sv), lref);
1997 if ((Xpv = (XPV*)SvANY(sv)) &&
1998 (*Xpv->xpv_pv > '0' ||
2000 (Xpv->xpv_cur && *Xpv->xpv_pv != '0')))
2007 return SvIV(sv) != 0;
2010 return SvNV(sv) != 0.0;
2028 return (double)SvIV(Sv);
2041 return SvPOK(sv) ? SvPV(sv) : sv_2pv(sv);