Lines Matching refs:sv
0 /* sv.c
49 An SV (or AV, HV, etc.) is allocated in two parts: the head (struct sv,
122 SvREFCNT_dec(sv) each remaining SV, possibly
133 Private API to rest of sv.c
180 SV* sv;
184 uproot_SV(sv);
186 sv = more_sv();
188 SvANY(sv) = 0;
189 SvREFCNT(sv) = 1;
190 SvFLAGS(sv) = 0;
191 return sv;
230 SV* sv;
234 sv = sva + 1;
236 if (p >= sv && p < svend)
272 register SV* sv;
285 sv = sva + 1;
286 while (sv < svend) {
287 SvANY(sv) = (void *)(SV*)(sv + 1);
288 SvFLAGS(sv) = SVTYPEMASK;
289 sv++;
291 SvANY(sv) = 0;
292 SvFLAGS(sv) = SVTYPEMASK;
301 register SV* sv;
313 uproot_SV(sv);
314 return sv;
323 SV* sv;
329 for (sv = sva + 1; sv < svend; ++sv) {
330 if (SvTYPE(sv) != SVTYPEMASK && SvREFCNT(sv)) {
331 (FCALL)(aTHX_ sv);
344 do_report_used(pTHX_ SV *sv)
346 if (SvTYPE(sv) != SVTYPEMASK) {
348 sv_dump(sv);
372 do_clean_objs(pTHX_ SV *sv)
376 if (SvROK(sv) && SvOBJECT(rv = SvRV(sv))) {
377 DEBUG_D((PerlIO_printf(Perl_debug_log, "Cleaning object ref:\n "), sv_dump(sv)));
378 if (SvWEAKREF(sv)) {
379 sv_del_backref(sv);
380 SvWEAKREF_off(sv);
381 SvRV(sv) = 0;
383 SvROK_off(sv);
384 SvRV(sv) = 0;
396 do_clean_named_objs(pTHX_ SV *sv)
398 if (SvTYPE(sv) == SVt_PVGV && GvGP(sv)) {
399 if ( SvOBJECT(GvSV(sv)) ||
400 (GvAV(sv) && SvOBJECT(GvAV(sv))) ||
401 (GvHV(sv) && SvOBJECT(GvHV(sv))) ||
402 (GvIO(sv) && SvOBJECT(GvIO(sv))) ||
403 (GvCV(sv) && SvOBJECT(GvCV(sv))) )
405 DEBUG_D((PerlIO_printf(Perl_debug_log, "Cleaning named glob object:\n "), sv_dump(sv)));
406 SvFLAGS(sv) |= SVf_BREAK;
407 SvREFCNT_dec(sv);
436 do_clean_all(pTHX_ SV *sv)
438 DEBUG_D((PerlIO_printf(Perl_debug_log, "Cleaning loops: SV at 0x%"UVxf"\n", PTR2UV(sv)) ));
439 SvFLAGS(sv) |= SVf_BREAK;
440 SvREFCNT_dec(sv);
1275 Perl_sv_upgrade(pTHX_ register SV *sv, U32 mt)
1286 if (mt != SVt_PV && SvREADONLY(sv) && SvFAKE(sv)) {
1287 sv_force_normal(sv);
1290 if (SvTYPE(sv) == mt)
1294 (void)SvOOK_off(sv);
1296 switch (SvTYPE(sv)) {
1310 iv = SvIVX(sv);
1311 nv = (NV)SvIVX(sv);
1312 del_XIV(SvANY(sv));
1324 nv = SvNVX(sv);
1328 del_XNV(SvANY(sv));
1329 SvANY(sv) = 0;
1334 pv = (char*)SvRV(sv);
1339 del_XRV(SvANY(sv));
1344 pv = SvPVX(sv);
1345 cur = SvCUR(sv);
1346 len = SvLEN(sv);
1351 del_XPV(SvANY(sv));
1358 pv = SvPVX(sv);
1359 cur = SvCUR(sv);
1360 len = SvLEN(sv);
1361 iv = SvIVX(sv);
1365 del_XPVIV(SvANY(sv));
1368 pv = SvPVX(sv);
1369 cur = SvCUR(sv);
1370 len = SvLEN(sv);
1371 iv = SvIVX(sv);
1372 nv = SvNVX(sv);
1375 del_XPVNV(SvANY(sv));
1378 pv = SvPVX(sv);
1379 cur = SvCUR(sv);
1380 len = SvLEN(sv);
1381 iv = SvIVX(sv);
1382 nv = SvNVX(sv);
1383 magic = SvMAGIC(sv);
1384 stash = SvSTASH(sv);
1385 del_XPVMG(SvANY(sv));
1395 SvANY(sv) = new_XIV();
1396 SvIVX(sv) = iv;
1399 SvANY(sv) = new_XNV();
1400 SvNVX(sv) = nv;
1403 SvANY(sv) = new_XRV();
1404 SvRV(sv) = (SV*)pv;
1407 SvANY(sv) = new_XPV();
1408 SvPVX(sv) = pv;
1409 SvCUR(sv) = cur;
1410 SvLEN(sv) = len;
1413 SvANY(sv) = new_XPVIV();
1414 SvPVX(sv) = pv;
1415 SvCUR(sv) = cur;
1416 SvLEN(sv) = len;
1417 SvIVX(sv) = iv;
1418 if (SvNIOK(sv))
1419 (void)SvIOK_on(sv);
1420 SvNOK_off(sv);
1423 SvANY(sv) = new_XPVNV();
1424 SvPVX(sv) = pv;
1425 SvCUR(sv) = cur;
1426 SvLEN(sv) = len;
1427 SvIVX(sv) = iv;
1428 SvNVX(sv) = nv;
1431 SvANY(sv) = new_XPVMG();
1432 SvPVX(sv) = pv;
1433 SvCUR(sv) = cur;
1434 SvLEN(sv) = len;
1435 SvIVX(sv) = iv;
1436 SvNVX(sv) = nv;
1437 SvMAGIC(sv) = magic;
1438 SvSTASH(sv) = stash;
1441 SvANY(sv) = new_XPVLV();
1442 SvPVX(sv) = pv;
1443 SvCUR(sv) = cur;
1444 SvLEN(sv) = len;
1445 SvIVX(sv) = iv;
1446 SvNVX(sv) = nv;
1447 SvMAGIC(sv) = magic;
1448 SvSTASH(sv) = stash;
1449 LvTARGOFF(sv) = 0;
1450 LvTARGLEN(sv) = 0;
1451 LvTARG(sv) = 0;
1452 LvTYPE(sv) = 0;
1455 SvANY(sv) = new_XPVAV();
1458 SvPVX(sv) = 0;
1459 AvMAX(sv) = -1;
1460 AvFILLp(sv) = -1;
1461 SvIVX(sv) = 0;
1462 SvNVX(sv) = 0.0;
1463 SvMAGIC(sv) = magic;
1464 SvSTASH(sv) = stash;
1465 AvALLOC(sv) = 0;
1466 AvARYLEN(sv) = 0;
1467 AvFLAGS(sv) = AVf_REAL;
1470 SvANY(sv) = new_XPVHV();
1473 SvPVX(sv) = 0;
1474 HvFILL(sv) = 0;
1475 HvMAX(sv) = 0;
1476 HvTOTALKEYS(sv) = 0;
1477 HvPLACEHOLDERS(sv) = 0;
1478 SvMAGIC(sv) = magic;
1479 SvSTASH(sv) = stash;
1480 HvRITER(sv) = 0;
1481 HvEITER(sv) = 0;
1482 HvPMROOT(sv) = 0;
1483 HvNAME(sv) = 0;
1486 SvANY(sv) = new_XPVCV();
1487 Zero(SvANY(sv), 1, XPVCV);
1488 SvPVX(sv) = pv;
1489 SvCUR(sv) = cur;
1490 SvLEN(sv) = len;
1491 SvIVX(sv) = iv;
1492 SvNVX(sv) = nv;
1493 SvMAGIC(sv) = magic;
1494 SvSTASH(sv) = stash;
1497 SvANY(sv) = new_XPVGV();
1498 SvPVX(sv) = pv;
1499 SvCUR(sv) = cur;
1500 SvLEN(sv) = len;
1501 SvIVX(sv) = iv;
1502 SvNVX(sv) = nv;
1503 SvMAGIC(sv) = magic;
1504 SvSTASH(sv) = stash;
1505 GvGP(sv) = 0;
1506 GvNAME(sv) = 0;
1507 GvNAMELEN(sv) = 0;
1508 GvSTASH(sv) = 0;
1509 GvFLAGS(sv) = 0;
1512 SvANY(sv) = new_XPVBM();
1513 SvPVX(sv) = pv;
1514 SvCUR(sv) = cur;
1515 SvLEN(sv) = len;
1516 SvIVX(sv) = iv;
1517 SvNVX(sv) = nv;
1518 SvMAGIC(sv) = magic;
1519 SvSTASH(sv) = stash;
1520 BmRARE(sv) = 0;
1521 BmUSEFUL(sv) = 0;
1522 BmPREVIOUS(sv) = 0;
1525 SvANY(sv) = new_XPVFM();
1526 Zero(SvANY(sv), 1, XPVFM);
1527 SvPVX(sv) = pv;
1528 SvCUR(sv) = cur;
1529 SvLEN(sv) = len;
1530 SvIVX(sv) = iv;
1531 SvNVX(sv) = nv;
1532 SvMAGIC(sv) = magic;
1533 SvSTASH(sv) = stash;
1536 SvANY(sv) = new_XPVIO();
1537 Zero(SvANY(sv), 1, XPVIO);
1538 SvPVX(sv) = pv;
1539 SvCUR(sv) = cur;
1540 SvLEN(sv) = len;
1541 SvIVX(sv) = iv;
1542 SvNVX(sv) = nv;
1543 SvMAGIC(sv) = magic;
1544 SvSTASH(sv) = stash;
1545 IoPAGE_LEN(sv) = 60;
1548 SvFLAGS(sv) &= ~SVTYPEMASK;
1549 SvFLAGS(sv) |= mt;
1563 Perl_sv_backoff(pTHX_ register SV *sv)
1565 assert(SvOOK(sv));
1566 if (SvIVX(sv)) {
1567 char *s = SvPVX(sv);
1568 SvLEN(sv) += SvIVX(sv);
1569 SvPVX(sv) -= SvIVX(sv);
1570 SvIV_set(sv, 0);
1571 Move(s, SvPVX(sv), SvCUR(sv)+1, char);
1573 SvFLAGS(sv) &= ~SVf_OOK;
1588 Perl_sv_grow(pTHX_ register SV *sv, register STRLEN newlen)
1601 if (SvROK(sv))
1602 sv_unref(sv);
1603 if (SvTYPE(sv) < SVt_PV) {
1604 sv_upgrade(sv, SVt_PV);
1605 s = SvPVX(sv);
1607 else if (SvOOK(sv)) { /* pv is offset? */
1608 sv_backoff(sv);
1609 s = SvPVX(sv);
1610 if (newlen > SvLEN(sv))
1611 newlen += 10 * (newlen - SvCUR(sv)); /* avoid copy each time */
1618 s = SvPVX(sv);
1620 if (newlen > SvLEN(sv)) { /* need more room? */
1621 if (SvLEN(sv) && s) {
1623 STRLEN l = malloced_size((void*)SvPVX(sv));
1625 SvLEN_set(sv, l);
1634 if (SvREADONLY(sv) && SvFAKE(sv)) {
1635 SvFAKE_off(sv);
1636 SvREADONLY_off(sv);
1639 if (SvPVX(sv) && SvCUR(sv)) {
1640 Move(SvPVX(sv), s, (newlen < SvCUR(sv)) ? newlen : SvCUR(sv), char);
1643 SvPV_set(sv, s);
1644 SvLEN_set(sv, newlen);
1659 Perl_sv_setiv(pTHX_ register SV *sv, IV i)
1661 SV_CHECK_THINKFIRST(sv);
1662 switch (SvTYPE(sv)) {
1664 sv_upgrade(sv, SVt_IV);
1667 sv_upgrade(sv, SVt_PVNV);
1671 sv_upgrade(sv, SVt_PVIV);
1680 Perl_croak(aTHX_ "Can't coerce %s to integer in %s", sv_reftype(sv,0),
1683 (void)SvIOK_only(sv); /* validate number */
1684 SvIVX(sv) = i;
1685 SvTAINT(sv);
1697 Perl_sv_setiv_mg(pTHX_ register SV *sv, IV i)
1699 sv_setiv(sv,i);
1700 SvSETMAGIC(sv);
1713 Perl_sv_setuv(pTHX_ register SV *sv, UV u)
1724 sv_setiv(sv, (IV)u);
1727 sv_setiv(sv, 0);
1728 SvIsUV_on(sv);
1729 SvUVX(sv) = u;
1741 Perl_sv_setuv_mg(pTHX_ register SV *sv, UV u)
1752 sv_setiv(sv, (IV)u);
1754 sv_setiv(sv, 0);
1755 SvIsUV_on(sv);
1756 sv_setuv(sv,u);
1758 SvSETMAGIC(sv);
1771 Perl_sv_setnv(pTHX_ register SV *sv, NV num)
1773 SV_CHECK_THINKFIRST(sv);
1774 switch (SvTYPE(sv)) {
1777 sv_upgrade(sv, SVt_NV);
1782 sv_upgrade(sv, SVt_PVNV);
1791 Perl_croak(aTHX_ "Can't coerce %s to number in %s", sv_reftype(sv,0),
1794 SvNVX(sv) = num;
1795 (void)SvNOK_only(sv); /* validate number */
1796 SvTAINT(sv);
1808 Perl_sv_setnv_mg(pTHX_ register SV *sv, NV num)
1810 sv_setnv(sv,num);
1811 SvSETMAGIC(sv);
1819 S_not_a_number(pTHX_ SV *sv)
1825 if (DO_UTF8(sv)) {
1827 pv = sv_uni_display(dsv, sv, 10, 0);
1835 for (s = SvPVX(sv), end = s + SvCUR(sv); s < end && d < limit; s++) {
1898 Perl_looks_like_number(pTHX_ SV *sv)
1903 if (SvPOK(sv)) {
1904 sbegin = SvPVX(sv);
1905 len = SvCUR(sv);
1907 else if (SvPOKp(sv))
1908 sbegin = SvPV(sv, len);
1999 S_sv_2iuv_non_preserve(pTHX_ register SV *sv, I32 numtype)
2001 DEBUG_c(PerlIO_printf(Perl_debug_log,"sv_2iuv_non '%s', IV=0x%"UVxf" NV=%"NVgf" inttype=%"UVXf"\n", SvPVX(sv), SvIVX(sv), SvNVX(sv), (UV)numtype));
2002 if (SvNVX(sv) < (NV)IV_MIN) {
2003 (void)SvIOKp_on(sv);
2004 (void)SvNOK_on(sv);
2005 SvIVX(sv) = IV_MIN;
2008 if (SvNVX(sv) > (NV)UV_MAX) {
2009 (void)SvIOKp_on(sv);
2010 (void)SvNOK_on(sv);
2011 SvIsUV_on(sv);
2012 SvUVX(sv) = UV_MAX;
2015 (void)SvIOKp_on(sv);
2016 (void)SvNOK_on(sv);
2019 if (SvNVX(sv) <= (UV)IV_MAX) {
2020 SvIVX(sv) = I_V(SvNVX(sv));
2021 if ((NV)(SvIVX(sv)) == SvNVX(sv)) {
2022 SvIOK_on(sv); /* Integer is precise. NOK, IOK */
2026 return SvNVX(sv) < 0 ? IS_NUMBER_UNDERFLOW_UV : IS_NUMBER_IV_AND_UV;
2028 SvIsUV_on(sv);
2029 SvUVX(sv) = U_V(SvNVX(sv));
2030 if ((NV)(SvUVX(sv)) == SvNVX(sv)) {
2031 if (SvUVX(sv) == UV_MAX) {
2037 SvIOK_on(sv); /* Integer is precise. NOK, UOK */
2049 magic etc. Normally used via the C<SvIV(sv)> and C<SvIVx(sv)> macros.
2055 Perl_sv_2iv(pTHX_ register SV *sv)
2057 if (!sv)
2059 if (SvGMAGICAL(sv)) {
2060 mg_get(sv);
2061 if (SvIOKp(sv))
2062 return SvIVX(sv);
2063 if (SvNOKp(sv)) {
2064 return I_V(SvNVX(sv));
2066 if (SvPOKp(sv) && SvLEN(sv))
2067 return asIV(sv);
2068 if (!SvROK(sv)) {
2069 if (!(SvFLAGS(sv) & SVs_PADTMP)) {
2076 if (SvTHINKFIRST(sv)) {
2077 if (SvROK(sv)) {
2079 if (SvAMAGIC(sv) && (tmpstr=AMG_CALLun(sv,numer)) &&
2080 (!SvROK(tmpstr) || (SvRV(tmpstr) != SvRV(sv))))
2082 return PTR2IV(SvRV(sv));
2084 if (SvREADONLY(sv) && SvFAKE(sv)) {
2085 sv_force_normal(sv);
2087 if (SvREADONLY(sv) && !SvOK(sv)) {
2093 if (SvIOKp(sv)) {
2094 if (SvIsUV(sv)) {
2095 return (IV)(SvUVX(sv));
2098 return SvIVX(sv);
2101 if (SvNOKp(sv)) {
2107 if (SvTYPE(sv) == SVt_NV)
2108 sv_upgrade(sv, SVt_PVNV);
2110 (void)SvIOKp_on(sv); /* Must do this first, to clear any SvOOK */
2115 if (SvNVX(sv) < (NV)IV_MAX + 0.5) {
2116 SvIVX(sv) = I_V(SvNVX(sv));
2117 if (SvNVX(sv) == (NV) SvIVX(sv)
2120 (UV)(SvIVX(sv) > 0 ? SvIVX(sv) : -SvIVX(sv)))
2126 SvIOK_on(sv); /* Can this go wrong with rounding? NWC */
2129 PTR2UV(sv),
2130 SvNVX(sv),
2131 SvIVX(sv)));
2140 PTR2UV(sv),
2141 SvNVX(sv),
2142 SvIVX(sv)));
2154 SvUVX(sv) = U_V(SvNVX(sv));
2156 (SvNVX(sv) == (NV) SvUVX(sv))
2159 /*&& (SvUVX(sv) != UV_MAX) irrelevant with code below */
2160 && (((UV)1 << NV_PRESERVES_UV_BITS) > SvUVX(sv))
2166 SvIOK_on(sv);
2167 SvIsUV_on(sv);
2171 PTR2UV(sv),
2172 SvUVX(sv),
2173 SvUVX(sv)));
2174 return (IV)SvUVX(sv);
2177 else if (SvPOKp(sv) && SvLEN(sv)) {
2179 int numtype = grok_number(SvPVX(sv), SvCUR(sv), &value);
2196 if (SvTYPE(sv) < SVt_PVIV)
2197 sv_upgrade(sv, SVt_PVIV);
2198 (void)SvIOK_on(sv);
2199 } else if (SvTYPE(sv) < SVt_PVNV)
2200 sv_upgrade(sv, SVt_PVNV);
2212 (void)SvIOKp_on(sv);
2217 SvIVX(sv) = (IV)value;
2219 SvUVX(sv) = value;
2220 SvIsUV_on(sv);
2225 SvIVX(sv) = -(IV)value;
2229 if (SvTYPE(sv) < SVt_PVNV)
2230 sv_upgrade(sv, SVt_PVNV);
2231 SvNOK_on(sv);
2232 SvIOK_off(sv);
2233 SvIOKp_on(sv);
2234 SvNVX(sv) = -(NV)value;
2235 SvIVX(sv) = IV_MIN;
2246 SvNVX(sv) = Atof(SvPVX(sv));
2249 not_a_number(sv);
2253 PTR2UV(sv), SvNVX(sv)));
2256 PTR2UV(sv), SvNVX(sv)));
2261 (void)SvIOKp_on(sv);
2262 (void)SvNOK_on(sv);
2263 if (SvNVX(sv) < (NV)IV_MAX + 0.5) {
2264 SvIVX(sv) = I_V(SvNVX(sv));
2265 if ((NV)(SvIVX(sv)) == SvNVX(sv)) {
2266 SvIOK_on(sv);
2272 if (SvNVX(sv) > (NV)UV_MAX) {
2273 SvIsUV_on(sv);
2275 SvUVX(sv) = UV_MAX;
2276 SvIsUV_on(sv);
2278 SvUVX(sv) = U_V(SvNVX(sv));
2280 if ((NV)(SvUVX(sv)) == SvNVX(sv)) {
2281 SvIOK_on(sv);
2282 SvIsUV_on(sv);
2285 SvIsUV_on(sv);
2296 SvNOK_on(sv);
2297 assert (SvIOKp(sv));
2300 U_V(SvNVX(sv) > 0 ? SvNVX(sv) : -SvNVX(sv))) {
2302 (void)SvIOKp_on(sv);
2303 SvNOK_on(sv);
2304 SvIVX(sv) = I_V(SvNVX(sv));
2305 if ((NV)(SvIVX(sv)) == SvNVX(sv))
2306 SvIOK_on(sv);
2309 if (!(U_V(SvNVX(sv) > 0 ? SvNVX(sv) : -SvNVX(sv))
2311 Perl_croak(aTHX_ "sv_2iv assumed (U_V(fabs((double)SvNVX(sv))) < (UV)IV_MAX) but SvNVX(sv)=%"NVgf" U_V is 0x%"UVxf", IV_MAX is 0x%"UVxf"\n", SvNVX(sv), U_V(SvNVX(sv)), (UV)IV_MAX);
2322 if (sv_2iuv_non_preserve (sv, numtype)
2330 if (ckWARN(WARN_UNINITIALIZED) && !PL_localizing && !(SvFLAGS(sv) & SVs_PADTMP))
2332 if (SvTYPE(sv) < SVt_IV)
2334 sv_upgrade(sv, SVt_IV);
2338 PTR2UV(sv),SvIVX(sv)));
2339 return SvIsUV(sv) ? (IV)SvUVX(sv) : SvIVX(sv);
2346 conversion, magic etc. Normally used via the C<SvUV(sv)> and C<SvUVx(sv)>
2353 Perl_sv_2uv(pTHX_ register SV *sv)
2355 if (!sv)
2357 if (SvGMAGICAL(sv)) {
2358 mg_get(sv);
2359 if (SvIOKp(sv))
2360 return SvUVX(sv);
2361 if (SvNOKp(sv))
2362 return U_V(SvNVX(sv));
2363 if (SvPOKp(sv) && SvLEN(sv))
2364 return asUV(sv);
2365 if (!SvROK(sv)) {
2366 if (!(SvFLAGS(sv) & SVs_PADTMP)) {
2373 if (SvTHINKFIRST(sv)) {
2374 if (SvROK(sv)) {
2376 if (SvAMAGIC(sv) && (tmpstr=AMG_CALLun(sv,numer)) &&
2377 (!SvROK(tmpstr) || (SvRV(tmpstr) != SvRV(sv))))
2379 return PTR2UV(SvRV(sv));
2381 if (SvREADONLY(sv) && SvFAKE(sv)) {
2382 sv_force_normal(sv);
2384 if (SvREADONLY(sv) && !SvOK(sv)) {
2390 if (SvIOKp(sv)) {
2391 if (SvIsUV(sv)) {
2392 return SvUVX(sv);
2395 return (UV)SvIVX(sv);
2398 if (SvNOKp(sv)) {
2405 if (SvTYPE(sv) == SVt_NV)
2406 sv_upgrade(sv, SVt_PVNV);
2408 (void)SvIOKp_on(sv); /* Must do this first, to clear any SvOOK */
2409 if (SvNVX(sv) < (NV)IV_MAX + 0.5) {
2410 SvIVX(sv) = I_V(SvNVX(sv));
2411 if (SvNVX(sv) == (NV) SvIVX(sv)
2414 (UV)(SvIVX(sv) > 0 ? SvIVX(sv) : -SvIVX(sv)))
2420 SvIOK_on(sv); /* Can this go wrong with rounding? NWC */
2423 PTR2UV(sv),
2424 SvNVX(sv),
2425 SvIVX(sv)));
2434 PTR2UV(sv),
2435 SvNVX(sv),
2436 SvIVX(sv)));
2448 SvUVX(sv) = U_V(SvNVX(sv));
2450 (SvNVX(sv) == (NV) SvUVX(sv))
2453 /*&& (SvUVX(sv) != UV_MAX) irrelevant with code below */
2454 && (((UV)1 << NV_PRESERVES_UV_BITS) > SvUVX(sv))
2460 SvIOK_on(sv);
2461 SvIsUV_on(sv);
2464 PTR2UV(sv),
2465 SvUVX(sv),
2466 SvUVX(sv)));
2469 else if (SvPOKp(sv) && SvLEN(sv)) {
2471 int numtype = grok_number(SvPVX(sv), SvCUR(sv), &value);
2486 if (SvTYPE(sv) < SVt_PVIV)
2487 sv_upgrade(sv, SVt_PVIV);
2488 (void)SvIOK_on(sv);
2489 } else if (SvTYPE(sv) < SVt_PVNV)
2490 sv_upgrade(sv, SVt_PVNV);
2502 (void)SvIOKp_on(sv);
2507 SvIVX(sv) = (IV)value;
2510 SvUVX(sv) = value;
2511 SvIsUV_on(sv);
2516 SvIVX(sv) = -(IV)value;
2520 if (SvTYPE(sv) < SVt_PVNV)
2521 sv_upgrade(sv, SVt_PVNV);
2522 SvNOK_on(sv);
2523 SvIOK_off(sv);
2524 SvIOKp_on(sv);
2525 SvNVX(sv) = -(NV)value;
2526 SvIVX(sv) = IV_MIN;
2534 SvNVX(sv) = Atof(SvPVX(sv));
2537 not_a_number(sv);
2541 PTR2UV(sv), SvNVX(sv)));
2544 PTR2UV(sv), SvNVX(sv)));
2548 (void)SvIOKp_on(sv);
2549 (void)SvNOK_on(sv);
2550 if (SvNVX(sv) < (NV)IV_MAX + 0.5) {
2551 SvIVX(sv) = I_V(SvNVX(sv));
2552 if ((NV)(SvIVX(sv)) == SvNVX(sv)) {
2553 SvIOK_on(sv);
2559 if (SvNVX(sv) > (NV)UV_MAX) {
2560 SvIsUV_on(sv);
2562 SvUVX(sv) = UV_MAX;
2563 SvIsUV_on(sv);
2565 SvUVX(sv) = U_V(SvNVX(sv));
2568 if ((NV)(SvUVX(sv)) == SvNVX(sv)) {
2569 SvIOK_on(sv);
2570 SvIsUV_on(sv);
2573 SvIsUV_on(sv);
2583 SvNOK_on(sv);
2584 assert (SvIOKp(sv));
2587 U_V(SvNVX(sv) > 0 ? SvNVX(sv) : -SvNVX(sv))) {
2589 (void)SvIOKp_on(sv);
2590 SvNOK_on(sv);
2591 SvIVX(sv) = I_V(SvNVX(sv));
2592 if ((NV)(SvIVX(sv)) == SvNVX(sv))
2593 SvIOK_on(sv);
2596 if (!(U_V(SvNVX(sv) > 0 ? SvNVX(sv) : -SvNVX(sv))
2598 Perl_croak(aTHX_ "sv_2uv assumed (U_V(fabs((double)SvNVX(sv))) < (UV)IV_MAX) but SvNVX(sv)=%"NVgf" U_V is 0x%"UVxf", IV_MAX is 0x%"UVxf"\n", SvNVX(sv), U_V(SvNVX(sv)), (UV)IV_MAX);
2601 sv_2iuv_non_preserve (sv, numtype);
2607 if (!(SvFLAGS(sv) & SVs_PADTMP)) {
2611 if (SvTYPE(sv) < SVt_IV)
2613 sv_upgrade(sv, SVt_IV);
2618 PTR2UV(sv),SvUVX(sv)));
2619 return SvIsUV(sv) ? SvUVX(sv) : (UV)SvIVX(sv);
2626 conversion, magic etc. Normally used via the C<SvNV(sv)> and C<SvNVx(sv)>
2633 Perl_sv_2nv(pTHX_ register SV *sv)
2635 if (!sv)
2637 if (SvGMAGICAL(sv)) {
2638 mg_get(sv);
2639 if (SvNOKp(sv))
2640 return SvNVX(sv);
2641 if (SvPOKp(sv) && SvLEN(sv)) {
2642 if (ckWARN(WARN_NUMERIC) && !SvIOKp(sv) &&
2643 !grok_number(SvPVX(sv), SvCUR(sv), NULL))
2644 not_a_number(sv);
2645 return Atof(SvPVX(sv));
2647 if (SvIOKp(sv)) {
2648 if (SvIsUV(sv))
2649 return (NV)SvUVX(sv);
2651 return (NV)SvIVX(sv);
2653 if (!SvROK(sv)) {
2654 if (!(SvFLAGS(sv) & SVs_PADTMP)) {
2661 if (SvTHINKFIRST(sv)) {
2662 if (SvROK(sv)) {
2664 if (SvAMAGIC(sv) && (tmpstr=AMG_CALLun(sv,numer)) &&
2665 (!SvROK(tmpstr) || (SvRV(tmpstr) != SvRV(sv))))
2667 return PTR2NV(SvRV(sv));
2669 if (SvREADONLY(sv) && SvFAKE(sv)) {
2670 sv_force_normal(sv);
2672 if (SvREADONLY(sv) && !SvOK(sv)) {
2678 if (SvTYPE(sv) < SVt_NV) {
2679 if (SvTYPE(sv) == SVt_IV)
2680 sv_upgrade(sv, SVt_PVNV);
2682 sv_upgrade(sv, SVt_NV);
2688 PTR2UV(sv), SvNVX(sv));
2695 PTR2UV(sv), SvNVX(sv));
2700 else if (SvTYPE(sv) < SVt_PVNV)
2701 sv_upgrade(sv, SVt_PVNV);
2702 if (SvNOKp(sv)) {
2703 return SvNVX(sv);
2705 if (SvIOKp(sv)) {
2706 SvNVX(sv) = SvIsUV(sv) ? (NV)SvUVX(sv) : (NV)SvIVX(sv);
2708 SvNOK_on(sv);
2712 if (SvIsUV(sv) ? ((SvUVX(sv) != UV_MAX)&&(SvUVX(sv) == U_V(SvNVX(sv))))
2713 : (SvIVX(sv) == I_V(SvNVX(sv))))
2714 SvNOK_on(sv);
2716 SvNOKp_on(sv);
2719 else if (SvPOKp(sv) && SvLEN(sv)) {
2721 int numtype = grok_number(SvPVX(sv), SvCUR(sv), &value);
2722 if (ckWARN(WARN_NUMERIC) && !SvIOKp(sv) && !numtype)
2723 not_a_number(sv);
2728 SvNVX(sv) = (numtype & IS_NUMBER_NEG) ? -(NV)value : (NV)value;
2730 SvNVX(sv) = Atof(SvPVX(sv));
2731 SvNOK_on(sv);
2733 SvNVX(sv) = Atof(SvPVX(sv));
2741 U_V(SvNVX(sv) > 0 ? SvNVX(sv) : -SvNVX(sv))) {
2742 SvNOK_on(sv); /* Definitely small enough to preserve all bits */
2746 SvNOK_on(sv);
2751 SvNOK_on(sv); /* Integer is too negative. */
2753 SvNOKp_on(sv);
2754 SvIOKp_on(sv);
2757 SvIVX(sv) = -(IV)value;
2759 SvIVX(sv) = (IV)value;
2761 SvUVX(sv) = value;
2762 SvIsUV_on(sv);
2772 NV nv = SvNVX(sv);
2773 if (SvNVX(sv) < (NV)IV_MAX + 0.5) {
2774 if (SvIVX(sv) == I_V(nv)) {
2775 SvNOK_on(sv);
2776 SvIOK_on(sv);
2778 SvIOK_on(sv);
2790 if (value == nv_as_uv && SvUVX(sv) != UV_MAX) {
2791 SvNOK_on(sv);
2792 SvIOK_on(sv);
2794 SvIOK_on(sv);
2804 if (ckWARN(WARN_UNINITIALIZED) && !PL_localizing && !(SvFLAGS(sv) & SVs_PADTMP))
2806 if (SvTYPE(sv) < SVt_NV)
2810 sv_upgrade(sv, SVt_NV);
2817 PTR2UV(sv), SvNVX(sv));
2824 PTR2UV(sv), SvNVX(sv));
2828 return SvNVX(sv);
2835 S_asIV(pTHX_ SV *sv)
2838 int numtype = grok_number(SvPVX(sv), SvCUR(sv), &value);
2853 not_a_number(sv);
2855 return I_V(Atof(SvPVX(sv)));
2862 S_asUV(pTHX_ SV *sv)
2865 int numtype = grok_number(SvPVX(sv), SvCUR(sv), &value);
2875 not_a_number(sv);
2877 return U_V(Atof(SvPVX(sv)));
2884 use the macro wrapper C<SvPV_nolen(sv)> instead.
2889 Perl_sv_2pv_nolen(pTHX_ register SV *sv)
2892 return sv_2pv(sv, &n_a);
2932 Perl_sv_2pv(pTHX_ register SV *sv, STRLEN *lp)
2934 return sv_2pv_flags(sv, lp, SV_GMAGIC);
2941 If flags includes SV_GMAGIC, does an mg_get() first. Coerces sv to a string
2950 Perl_sv_2pv_flags(pTHX_ register SV *sv, STRLEN *lp, I32 flags)
2958 if (!sv) {
2962 if (SvGMAGICAL(sv)) {
2964 mg_get(sv);
2965 if (SvPOKp(sv)) {
2966 *lp = SvCUR(sv);
2967 return SvPVX(sv);
2969 if (SvIOKp(sv)) {
2970 if (SvIsUV(sv))
2971 (void)sprintf(tmpbuf,"%"UVuf, (UV)SvUVX(sv));
2973 (void)sprintf(tmpbuf,"%"IVdf, (IV)SvIVX(sv));
2977 if (SvNOKp(sv)) {
2978 Gconvert(SvNVX(sv), NV_DIG, 0, tmpbuf);
2982 if (!SvROK(sv)) {
2983 if (!(SvFLAGS(sv) & SVs_PADTMP)) {
2991 if (SvTHINKFIRST(sv)) {
2992 if (SvROK(sv)) {
2994 if (SvAMAGIC(sv) && (tmpstr=AMG_CALLun(sv,string)) &&
2995 (!SvROK(tmpstr) || (SvRV(tmpstr) != SvRV(sv)))) {
2998 SvUTF8_on(sv);
3000 SvUTF8_off(sv);
3003 origsv = sv;
3004 sv = (SV*)SvRV(sv);
3005 if (!sv)
3010 switch (SvTYPE(sv)) {
3012 if ( ((SvFLAGS(sv) &
3015 && (mg = mg_find(sv, PERL_MAGIC_qr))) {
3102 case SVt_PVBM: if (SvROK(sv))
3106 case SVt_PVLV: s = SvROK(sv) ? "REF"
3109 : (LvTYPE(sv) == 't' || LvTYPE(sv) == 'T')
3120 if (SvOBJECT(sv)) {
3121 HV *svs = SvSTASH(sv);
3131 Perl_sv_catpvf(aTHX_ tsv, "(0x%"UVxf")", PTR2UV(sv));
3137 if (SvREADONLY(sv) && !SvOK(sv)) {
3144 if (SvIOK(sv) || ((SvIOKp(sv) && !SvNOKp(sv)))) {
3147 U32 isIOK = SvIOK(sv);
3148 U32 isUIOK = SvIsUV(sv);
3152 if (SvTYPE(sv) < SVt_PVIV)
3153 sv_upgrade(sv, SVt_PVIV);
3155 ptr = uiv_2buf(buf, 0, SvUVX(sv), 1, &ebuf);
3157 ptr = uiv_2buf(buf, SvIVX(sv), 0, 0, &ebuf);
3158 SvGROW(sv, (STRLEN)(ebuf - ptr + 1)); /* inlined from sv_setpvn */
3159 Move(ptr,SvPVX(sv),ebuf - ptr,char);
3160 SvCUR_set(sv, ebuf - ptr);
3161 s = SvEND(sv);
3164 SvIOK_on(sv);
3166 SvIOKp_on(sv);
3168 SvIsUV_on(sv);
3170 else if (SvNOKp(sv)) {
3171 if (SvTYPE(sv) < SVt_PVNV)
3172 sv_upgrade(sv, SVt_PVNV);
3174 SvGROW(sv, NV_DIG + 20);
3175 s = SvPVX(sv);
3178 if (SvNVX(sv) == 0.0)
3183 Gconvert(SvNVX(sv), NV_DIG, 0, s);
3198 && !PL_localizing && !(SvFLAGS(sv) & SVs_PADTMP))
3201 if (SvTYPE(sv) < SVt_PV)
3203 sv_upgrade(sv, SVt_PV);
3206 *lp = s - SvPVX(sv);
3207 SvCUR_set(sv, *lp);
3208 SvPOK_on(sv);
3210 PTR2UV(sv),SvPVX(sv)));
3211 return SvPVX(sv);
3214 if (SvROK(sv)) { /* XXX Skip this when sv_pvn_force calls */
3243 (void)SvUPGRADE(sv, SVt_PV);
3245 s = SvGROW(sv, len + 1);
3246 SvCUR_set(sv, len);
3248 SvPOKp_on(sv);
3292 Perl_sv_2pvbyte_nolen(pTHX_ register SV *sv)
3295 return sv_2pvbyte(sv, &n_a);
3311 Perl_sv_2pvbyte(pTHX_ register SV *sv, STRLEN *lp)
3313 sv_utf8_downgrade(sv,0);
3314 return SvPV(sv,*lp);
3329 Perl_sv_2pvutf8_nolen(pTHX_ register SV *sv)
3332 return sv_2pvutf8(sv, &n_a);
3347 Perl_sv_2pvutf8(pTHX_ register SV *sv, STRLEN *lp)
3349 sv_utf8_upgrade(sv);
3350 return SvPV(sv,*lp);
3363 Perl_sv_2bool(pTHX_ register SV *sv)
3365 if (SvGMAGICAL(sv))
3366 mg_get(sv);
3368 if (!SvOK(sv))
3370 if (SvROK(sv)) {
3372 if (SvAMAGIC(sv) && (tmpsv=AMG_CALLun(sv,bool_)) &&
3373 (!SvROK(tmpsv) || (SvRV(tmpsv) != SvRV(sv))))
3375 return SvRV(sv) != 0;
3377 if (SvPOKp(sv)) {
3379 if ((Xpvtmp = (XPV*)SvANY(sv)) &&
3388 if (SvIOKp(sv))
3389 return SvIVX(sv) != 0;
3391 if (SvNOKp(sv))
3392 return SvNVX(sv) != 0.0;
3405 Perl_sv_utf8_upgrade(pTHX_ register SV *sv)
3407 return sv_utf8_upgrade_flags(sv, SV_GMAGIC);
3427 will C<mg_get> on C<sv> if appropriate, else not. C<sv_utf8_upgrade> and
3437 Perl_sv_utf8_upgrade_flags(pTHX_ register SV *sv, I32 flags)
3442 if (!sv)
3445 if (!SvPOK(sv)) {
3447 (void) sv_2pv_flags(sv,&len, flags);
3448 if (!SvPOK(sv))
3452 if (SvUTF8(sv))
3453 return SvCUR(sv);
3455 if (SvREADONLY(sv) && SvFAKE(sv)) {
3456 sv_force_normal(sv);
3460 sv_recode_to_utf8(sv, PL_encoding);
3466 s = (U8 *) SvPVX(sv);
3467 e = (U8 *) SvEND(sv);
3476 (void)SvOOK_off(sv);
3477 s = (U8*)SvPVX(sv);
3478 len = SvCUR(sv) + 1; /* Plus the \0 */
3479 SvPVX(sv) = (char*)bytes_to_utf8((U8*)s, &len);
3480 SvCUR(sv) = len - 1;
3481 if (SvLEN(sv) != 0)
3483 SvLEN(sv) = len; /* No longer know the real size. */
3486 SvUTF8_on(sv);
3488 return SvCUR(sv);
3506 Perl_sv_utf8_downgrade(pTHX_ register SV* sv, bool fail_ok)
3508 if (SvPOK(sv) && SvUTF8(sv)) {
3509 if (SvCUR(sv)) {
3513 if (SvREADONLY(sv) && SvFAKE(sv))
3514 sv_force_normal(sv);
3515 s = (U8 *) SvPV(sv, len);
3527 SvCUR(sv) = len;
3530 SvUTF8_off(sv);
3545 Perl_sv_utf8_encode(pTHX_ register SV *sv)
3547 (void) sv_utf8_upgrade(sv);
3548 if (SvIsCOW(sv)) {
3549 sv_force_normal_flags(sv, 0);
3551 if (SvREADONLY(sv)) {
3554 SvUTF8_off(sv);
3568 Perl_sv_utf8_decode(pTHX_ register SV *sv)
3570 if (SvPOK(sv)) {
3577 if (!sv_utf8_downgrade(sv, TRUE))
3583 c = (U8 *) SvPVX(sv);
3584 if (!is_utf8_string(c, SvCUR(sv)+1))
3586 e = (U8 *) SvEND(sv);
3590 SvUTF8_on(sv);
4115 Perl_sv_setpvn(pTHX_ register SV *sv, register const char *ptr, register STRLEN len)
4119 SV_CHECK_THINKFIRST(sv);
4121 (void)SvOK_off(sv);
4130 (void)SvUPGRADE(sv, SVt_PV);
4132 SvGROW(sv, len + 1);
4133 dptr = SvPVX(sv);
4136 SvCUR_set(sv, len);
4137 (void)SvPOK_only_UTF8(sv); /* validate pointer */
4138 SvTAINT(sv);
4150 Perl_sv_setpvn_mg(pTHX_ register SV *sv, register const char *ptr, register STRLEN len)
4152 sv_setpvn(sv,ptr,len);
4153 SvSETMAGIC(sv);
4166 Perl_sv_setpv(pTHX_ register SV *sv, register const char *ptr)
4170 SV_CHECK_THINKFIRST(sv);
4172 (void)SvOK_off(sv);
4176 (void)SvUPGRADE(sv, SVt_PV);
4178 SvGROW(sv, len + 1);
4179 Move(ptr,SvPVX(sv),len+1,char);
4180 SvCUR_set(sv, len);
4181 (void)SvPOK_only_UTF8(sv); /* validate pointer */
4182 SvTAINT(sv);
4194 Perl_sv_setpv_mg(pTHX_ register SV *sv, register const char *ptr)
4196 sv_setpv(sv,ptr);
4197 SvSETMAGIC(sv);
4215 Perl_sv_usepvn(pTHX_ register SV *sv, register char *ptr, register STRLEN len)
4217 SV_CHECK_THINKFIRST(sv);
4218 (void)SvUPGRADE(sv, SVt_PV);
4220 (void)SvOK_off(sv);
4223 (void)SvOOK_off(sv);
4224 if (SvPVX(sv) && SvLEN(sv))
4225 Safefree(SvPVX(sv));
4227 SvPVX(sv) = ptr;
4228 SvCUR_set(sv, len);
4229 SvLEN_set(sv, len+1);
4230 *SvEND(sv) = '\0';
4231 (void)SvPOK_only_UTF8(sv); /* validate pointer */
4232 SvTAINT(sv);
4244 Perl_sv_usepvn_mg(pTHX_ register SV *sv, register char *ptr, register STRLEN len)
4246 sv_usepvn(sv,ptr,len);
4247 SvSETMAGIC(sv);
4262 Perl_sv_force_normal_flags(pTHX_ register SV *sv, U32 flags)
4264 if (SvREADONLY(sv)) {
4265 if (SvFAKE(sv)) {
4266 char *pvx = SvPVX(sv);
4267 STRLEN len = SvCUR(sv);
4268 U32 hash = SvUVX(sv);
4269 SvFAKE_off(sv);
4270 SvREADONLY_off(sv);
4271 SvGROW(sv, len + 1);
4272 Move(pvx,SvPVX(sv),len,char);
4273 *SvEND(sv) = '\0';
4274 unsharepvn(pvx, SvUTF8(sv) ? -(I32)len : len, hash);
4279 if (SvROK(sv))
4280 sv_unref_flags(sv, flags);
4281 else if (SvFAKE(sv) && SvTYPE(sv) == SVt_PVGV)
4282 sv_unglob(sv);
4296 Perl_sv_force_normal(pTHX_ register SV *sv)
4298 sv_force_normal_flags(sv, 0);
4305 SvPOK(sv) must be true and the C<ptr> must be a pointer to somewhere inside
4308 Beware: after this function returns, C<ptr> and SvPVX(sv) may no longer
4315 Perl_sv_chop(pTHX_ register SV *sv, register char *ptr)
4318 if (!ptr || !SvPOKp(sv))
4320 delta = ptr - SvPVX(sv);
4321 SV_CHECK_THINKFIRST(sv);
4322 if (SvTYPE(sv) < SVt_PVIV)
4323 sv_upgrade(sv,SVt_PVIV);
4325 if (!SvOOK(sv)) {
4326 if (!SvLEN(sv)) { /* make copy of shared string */
4327 char *pvx = SvPVX(sv);
4328 STRLEN len = SvCUR(sv);
4329 SvGROW(sv, len + 1);
4330 Move(pvx,SvPVX(sv),len,char);
4331 *SvEND(sv) = '\0';
4333 SvIVX(sv) = 0;
4337 SvFLAGS(sv) |= SVf_OOK;
4339 SvNIOK_off(sv);
4340 SvLEN(sv) -= delta;
4341 SvCUR(sv) -= delta;
4342 SvPVX(sv) += delta;
4343 SvIVX(sv) += delta;
4402 Perl_sv_catpvn_mg(pTHX_ register SV *sv, register const char *ptr, register STRLEN len)
4404 sv_catpvn(sv,ptr,len);
4405 SvSETMAGIC(sv);
4496 Perl_sv_catpv(pTHX_ register SV *sv, register const char *ptr)
4504 junk = SvPV_force(sv, tlen);
4506 SvGROW(sv, tlen + len + 1);
4508 ptr = SvPVX(sv);
4509 Move(ptr,SvPVX(sv)+tlen,len+1,char);
4510 SvCUR(sv) += len;
4511 (void)SvPOK_only_UTF8(sv); /* validate pointer */
4512 SvTAINT(sv);
4524 Perl_sv_catpv_mg(pTHX_ register SV *sv, register const char *ptr)
4526 sv_catpv(sv,ptr);
4527 SvSETMAGIC(sv);
4543 register SV *sv;
4545 new_SV(sv);
4547 sv_upgrade(sv, SVt_PV);
4548 SvGROW(sv, len + 1);
4550 return sv;
4572 Perl_sv_magicext(pTHX_ SV* sv, SV* obj, int how, MGVTBL *vtable,
4577 if (SvTYPE(sv) < SVt_PVMG) {
4578 (void)SvUPGRADE(sv, SVt_PVMG);
4581 mg->mg_moremagic = SvMAGIC(sv);
4582 SvMAGIC(sv) = mg;
4584 /* Some magic sontains a reference loop, where the sv and object refer to
4593 if (!obj || obj == sv ||
4597 (GvSV(obj) == sv || GvHV(obj) == (HV*)sv || GvAV(obj) == (AV*)sv ||
4598 GvCV(obj) == (CV*)sv || GvIOp(obj) == (IO*)sv ||
4599 GvFORM(obj) == (CV*)sv)))
4616 if (how == PERL_MAGIC_tiedscalar && SvTYPE(sv) == SVt_PVIO &&
4617 obj && SvROK(obj) && GvIO(SvRV(obj)) == (IO*)sv)
4634 mg_magical(sv);
4635 if (SvGMAGICAL(sv))
4636 SvFLAGS(sv) &= ~(SVf_IOK|SVf_NOK|SVf_POK);
4643 Adds magic to an SV. First upgrades C<sv> to type C<SVt_PVMG> if necessary,
4650 Perl_sv_magic(pTHX_ register SV *sv, SV *obj, int how, const char *name, I32 namlen)
4655 if (SvREADONLY(sv)) {
4667 if (SvMAGICAL(sv) || (how == PERL_MAGIC_taint && SvTYPE(sv) >= SVt_PVMG)) {
4668 if (SvMAGIC(sv) && (mg = mg_find(sv, how))) {
4797 mg = sv_magicext(sv,obj,how,vtable,name,namlen);
4805 SvRMAGICAL_on(sv);
4819 Perl_sv_unmagic(pTHX_ SV *sv, int type)
4823 if (SvTYPE(sv) < SVt_PVMG || !SvMAGIC(sv))
4825 mgp = &SvMAGIC(sv);
4831 CALL_FPTR(vtbl->svt_free)(aTHX_ sv, mg);
4847 if (!SvMAGIC(sv)) {
4848 SvMAGICAL_off(sv);
4849 SvFLAGS(sv) |= (SvFLAGS(sv) & (SVp_NOK|SVp_POK)) >> PRIVSHIFT;
4867 Perl_sv_rvweaken(pTHX_ SV *sv)
4870 if (!SvOK(sv)) /* let undefs pass */
4871 return sv;
4872 if (!SvROK(sv))
4874 else if (SvWEAKREF(sv)) {
4877 return sv;
4879 tsv = SvRV(sv);
4880 sv_add_backref(tsv, sv);
4881 SvWEAKREF_on(sv);
4883 return sv;
4887 * back-reference to sv onto the array associated with the backref magic.
4891 S_sv_add_backref(pTHX_ SV *tsv, SV *sv)
4909 svp[i] = sv; /* reuse the slot */
4916 AvARRAY(av)[++AvFILLp(av)] = sv; /* av_push() */
4924 S_sv_del_backref(pTHX_ SV *sv)
4929 SV *tsv = SvRV(sv);
4937 if (svp[i] == sv) {
5052 Perl_sv_replace(pTHX_ register SV *sv, register SV *nsv)
5054 U32 refcnt = SvREFCNT(sv);
5055 SV_CHECK_THINKFIRST(sv);
5058 if (SvMAGICAL(sv)) {
5063 SvMAGIC(nsv) = SvMAGIC(sv);
5064 SvFLAGS(nsv) |= SvMAGICAL(sv);
5065 SvMAGICAL_off(sv);
5066 SvMAGIC(sv) = 0;
5068 SvREFCNT(sv) = 0;
5069 sv_clear(sv);
5070 assert(!SvREFCNT(sv));
5071 StructCopy(nsv,sv,SV);
5072 SvREFCNT(sv) = refcnt;
5093 Perl_sv_clear(pTHX_ register SV *sv)
5096 assert(sv);
5097 assert(SvREFCNT(sv) == 0);
5099 if (SvOBJECT(sv)) {
5107 stash = SvSTASH(sv);
5110 SV* tmpref = newRV(sv);
5126 SvREFCNT(sv)--;
5132 } while (SvOBJECT(sv) && SvSTASH(sv) != stash);
5135 if (SvREFCNT(sv)) {
5144 if (SvOBJECT(sv)) {
5145 SvREFCNT_dec(SvSTASH(sv)); /* possibly of changed persuasion */
5146 SvOBJECT_off(sv); /* Curse the object. */
5147 if (SvTYPE(sv) != SVt_PVIO)
5151 if (SvTYPE(sv) >= SVt_PVMG) {
5152 if (SvMAGIC(sv))
5153 mg_free(sv);
5154 if (SvFLAGS(sv) & SVpad_TYPED)
5155 SvREFCNT_dec(SvSTASH(sv));
5158 switch (SvTYPE(sv)) {
5160 if (IoIFP(sv) &&
5161 IoIFP(sv) != PerlIO_stdin() &&
5162 IoIFP(sv) != PerlIO_stdout() &&
5163 IoIFP(sv) != PerlIO_stderr())
5165 io_close((IO*)sv, FALSE);
5167 if (IoDIRP(sv) && !(IoFLAGS(sv) & IOf_FAKE_DIRP))
5168 PerlDir_close(IoDIRP(sv));
5169 IoDIRP(sv) = (DIR*)NULL;
5170 Safefree(IoTOP_NAME(sv));
5171 Safefree(IoFMT_NAME(sv));
5172 Safefree(IoBOTTOM_NAME(sv));
5178 cv_undef((CV*)sv);
5181 hv_undef((HV*)sv);
5184 av_undef((AV*)sv);
5187 if (LvTYPE(sv) == 'T') { /* for tie: return HE to pool */
5188 SvREFCNT_dec(HeKEY_sv((HE*)LvTARG(sv)));
5189 HeNEXT((HE*)LvTARG(sv)) = PL_hv_fetch_ent_mh;
5190 PL_hv_fetch_ent_mh = (HE*)LvTARG(sv);
5192 else if (LvTYPE(sv) != 't') /* unless tie: unrefcnted fake SV** */
5193 SvREFCNT_dec(LvTARG(sv));
5196 gp_free((GV*)sv);
5197 Safefree(GvNAME(sv));
5200 of stash until current sv is completely gone.
5202 stash = GvSTASH(sv);
5208 (void)SvOOK_off(sv);
5212 if (SvROK(sv)) {
5213 if (SvWEAKREF(sv))
5214 sv_del_backref(sv);
5216 SvREFCNT_dec(SvRV(sv));
5218 else if (SvPVX(sv) && SvLEN(sv))
5219 Safefree(SvPVX(sv));
5220 else if (SvPVX(sv) && SvREADONLY(sv) && SvFAKE(sv)) {
5221 unsharepvn(SvPVX(sv),
5222 SvUTF8(sv) ? -(I32)SvCUR(sv) : SvCUR(sv),
5223 SvUVX(sv));
5224 SvFAKE_off(sv);
5235 switch (SvTYPE(sv)) {
5239 del_XIV(SvANY(sv));
5242 del_XNV(SvANY(sv));
5245 del_XRV(SvANY(sv));
5248 del_XPV(SvANY(sv));
5251 del_XPVIV(SvANY(sv));
5254 del_XPVNV(SvANY(sv));
5257 del_XPVMG(SvANY(sv));
5260 del_XPVLV(SvANY(sv));
5263 del_XPVAV(SvANY(sv));
5266 del_XPVHV(SvANY(sv));
5269 del_XPVCV(SvANY(sv));
5272 del_XPVGV(SvANY(sv));
5274 SvFLAGS(sv) &= SVf_BREAK;
5275 SvFLAGS(sv) |= SVTYPEMASK;
5281 del_XPVBM(SvANY(sv));
5284 del_XPVFM(SvANY(sv));
5287 del_XPVIO(SvANY(sv));
5290 SvFLAGS(sv) &= SVf_BREAK;
5291 SvFLAGS(sv) |= SVTYPEMASK;
5304 Perl_sv_newref(pTHX_ SV *sv)
5306 if (sv)
5307 ATOMIC_INC(SvREFCNT(sv));
5308 return sv;
5323 Perl_sv_free(pTHX_ SV *sv)
5327 if (!sv)
5329 if (SvREFCNT(sv) == 0) {
5330 if (SvFLAGS(sv) & SVf_BREAK)
5336 if (SvREADONLY(sv) && SvIMMORTAL(sv)) {
5337 /* make sure SvREFCNT(sv)==0 happens very seldom */
5338 SvREFCNT(sv) = (~(U32)0)/2;
5344 PTR2UV(sv));
5347 ATOMIC_DEC_AND_TEST(refcount_is_zero, SvREFCNT(sv));
5351 if (SvTEMP(sv)) {
5355 PTR2UV(sv));
5359 if (SvREADONLY(sv) && SvIMMORTAL(sv)) {
5360 /* make sure SvREFCNT(sv)==0 happens very seldom */
5361 SvREFCNT(sv) = (~(U32)0)/2;
5364 sv_clear(sv);
5365 if (! SvREFCNT(sv))
5366 del_SV(sv);
5379 Perl_sv_len(pTHX_ register SV *sv)
5383 if (!sv)
5386 if (SvGMAGICAL(sv))
5387 len = mg_length(sv);
5389 (void)SvPV(sv, len);
5410 Perl_sv_len_utf8(pTHX_ register SV *sv)
5412 if (!sv)
5415 if (SvGMAGICAL(sv))
5416 return mg_length(sv);
5420 U8 *s = (U8*)SvPV(sv, len);
5421 MAGIC *mg = SvMAGICAL(sv) ? mg_find(sv, PERL_MAGIC_utf8) : 0;
5431 if (!mg && !SvREADONLY(sv)) {
5432 sv_magic(sv, 0, PERL_MAGIC_utf8, 0, 0);
5433 mg = mg_find(sv, PERL_MAGIC_utf8);
5454 S_utf8_mg_pos_init(pTHX_ SV *sv, MAGIC **mgp, STRLEN **cachep, I32 i, I32 *offsetp, U8 *s, U8 *start)
5458 if (SvMAGICAL(sv) && !SvREADONLY(sv)) {
5460 *mgp = sv_magicext(sv, 0, PERL_MAGIC_utf8, &PL_vtbl_utf8, 0, 0);
5487 S_utf8_mg_pos(pTHX_ SV *sv, MAGIC **mgp, STRLEN **cachep, I32 i, I32 *offsetp, I32 uoff, U8 **sp, U8 *start, U8 *send)
5491 if (SvMAGICAL(sv) && !SvREADONLY(sv)) {
5493 *mgp = mg_find(sv, PERL_MAGIC_utf8);
5521 STRLEN ulen = sv_len_utf8(sv);
5611 * PERL_UTF8_magic of the sv to store the mapping between UTF-8 and
5617 Perl_sv_pos_u2b(pTHX_ register SV *sv, I32* offsetp, I32* lenp)
5625 if (!sv)
5628 start = s = (U8*)SvPV(sv, len);
5635 if (utf8_mg_pos(sv, &mg, &cache, 0, offsetp, *offsetp, &s, start, send))
5642 if (utf8_mg_pos_init(sv, &mg, &cache, 0, offsetp, s, start))
5649 if (utf8_mg_pos(sv, &mg, &cache, 2, lenp, *lenp + *offsetp, &s, start, send)) {
5660 utf8_mg_pos_init(sv, &mg, &cache, 2, lenp, s, start);
5687 * PERL_UTF8_magic of the sv to store the mapping between UTF-8 and
5693 Perl_sv_pos_b2u(pTHX_ register SV* sv, I32* offsetp)
5698 if (!sv)
5701 s = (U8*)SvPV(sv, len);
5711 if (SvMAGICAL(sv) && !SvREADONLY(sv)) {
5712 mg = mg_find(sv, PERL_MAGIC_utf8);
5780 if (!SvREADONLY(sv)) {
5782 sv_magic(sv, 0, PERL_MAGIC_utf8, 0, 0);
5783 mg = mg_find(sv, PERL_MAGIC_utf8);
6057 Perl_sv_collxfrm(pTHX_ SV *sv, STRLEN *nxp)
6061 mg = SvMAGICAL(sv) ? mg_find(sv, PERL_MAGIC_collxfrm) : (MAGIC *) NULL;
6068 s = SvPV(sv, len);
6070 if (SvREADONLY(sv)) {
6076 sv_magic(sv, 0, PERL_MAGIC_collxfrm, 0, 0);
6077 mg = mg_find(sv, PERL_MAGIC_collxfrm);
6112 Perl_sv_gets(pTHX_ register SV *sv, register PerlIO *fp, I32 append)
6123 if (SvTHINKFIRST(sv))
6124 sv_force_normal_flags(sv, append ? 0 : SV_COW_DROP_PV);
6130 (void)SvUPGRADE(sv, SVt_PV);
6132 SvSCREAM_off(sv);
6136 if (!SvUTF8(sv)) {
6137 sv_utf8_upgrade_nomg(sv);
6138 sv_pos_u2b(sv,&append,0);
6140 } else if (SvUTF8(sv)) {
6144 SvCUR_set(sv,append);
6145 sv_catsv(sv,tsv);
6151 SvPOK_only(sv);
6153 SvUTF8_on(sv);
6170 (void) SvGROW(sv, (STRLEN)((st.st_size - offset) + append + 1));
6182 buffer = SvGROW(sv, (STRLEN)(recsize + append + 1)) + append;
6196 SvCUR_set(sv, bytesread += append);
6268 if ((I32)(SvLEN(sv) - append) <= cnt + 1) {
6272 if (rslen && cnt > 80 && (I32)SvLEN(sv) > append) {
6274 shortbuffered = cnt - SvLEN(sv) + append + 1;
6280 SvGROW(sv, (STRLEN)(append + (cnt <= 0 ? 2 : (cnt + 1))));
6285 bp = (STDCHAR*)SvPVX(sv) + append; /* move these two too to registers */
6314 bpx = bp - (STDCHAR*)SvPVX(sv); /* box up before relocation */
6315 SvCUR_set(sv, bpx);
6316 SvGROW(sv, SvLEN(sv) + append + cnt + 2);
6317 bp = (STDCHAR*)SvPVX(sv) + bpx; /* unbox after relocation */
6349 bpx = bp - (STDCHAR*)SvPVX(sv); /* box up before relocation */
6350 SvCUR_set(sv, bpx);
6351 SvGROW(sv, bpx + cnt + 2);
6352 bp = (STDCHAR*)SvPVX(sv) + bpx; /* unbox after relocation */
6361 if ((rslen > 1 && (STRLEN)(bp - (STDCHAR*)SvPVX(sv)) < rslen) ||
6375 SvCUR_set(sv, bp - (STDCHAR*)SvPVX(sv)); /* set length */
6378 (long)SvCUR(sv),(int)SvCUR(sv),SvPVX(sv)));
6421 cnt = 0; /* we do need to re-set the sv even when cnt <= 0 */
6423 sv_catpvn(sv, (char *) buf, cnt);
6425 sv_setpvn(sv, (char *) buf, cnt);
6429 SvCUR(sv) < rslen ||
6430 memNE(SvPVX(sv) + SvCUR(sv) - rslen, rsptr, rslen)))
6464 return (SvCUR(sv) - append) ? SvPVX(sv) : Nullch;
6477 Perl_sv_inc(pTHX_ register SV *sv)
6482 if (!sv)
6484 if (SvGMAGICAL(sv))
6485 mg_get(sv);
6486 if (SvTHINKFIRST(sv)) {
6487 if (SvREADONLY(sv) && SvFAKE(sv))
6488 sv_force_normal(sv);
6489 if (SvREADONLY(sv)) {
6493 if (SvROK(sv)) {
6495 if (SvAMAGIC(sv) && AMG_CALLun(sv,inc))
6497 i = PTR2IV(SvRV(sv));
6498 sv_unref(sv);
6499 sv_setiv(sv, i);
6502 flags = SvFLAGS(sv);
6506 (void) SvIV(sv);
6507 flags = SvFLAGS(sv);
6514 if (SvIsUV(sv)) {
6515 if (SvUVX(sv) == UV_MAX)
6516 sv_setnv(sv, UV_MAX_P1);
6518 (void)SvIOK_only_UV(sv);
6519 ++SvUVX(sv);
6521 if (SvIVX(sv) == IV_MAX)
6522 sv_setuv(sv, (UV)IV_MAX + 1);
6524 (void)SvIOK_only(sv);
6525 ++SvIVX(sv);
6531 (void)SvNOK_only(sv);
6532 SvNVX(sv) += 1.0;
6536 if (!(flags & SVp_POK) || !*SvPVX(sv)) {
6538 sv_upgrade(sv, SVt_IV);
6539 (void)SvIOK_only(sv);
6540 SvIVX(sv) = 1;
6543 d = SvPVX(sv);
6551 int numtype = grok_number(SvPVX(sv), SvCUR(sv), NULL);
6560 (void) sv_2iv(sv);
6561 if (SvIOK(sv))
6566 (void)SvNOK_only(sv);
6567 SvNVX(sv) += 1.0;
6575 SvPVX(sv), SvIVX(sv), SvNVX(sv)));
6578 SvPVX(sv), SvIVX(sv), SvNVX(sv)));
6582 sv_setnv(sv,Atof(SvPVX(sv)) + 1.0);
6586 while (d >= SvPVX(sv)) {
6614 SvGROW(sv, SvCUR(sv) + 2);
6615 SvCUR(sv)++;
6616 for (d = SvPVX(sv) + SvCUR(sv); d > SvPVX(sv); d--)
6634 Perl_sv_dec(pTHX_ register SV *sv)
6638 if (!sv)
6640 if (SvGMAGICAL(sv))
6641 mg_get(sv);
6642 if (SvTHINKFIRST(sv)) {
6643 if (SvREADONLY(sv) && SvFAKE(sv))
6644 sv_force_normal(sv);
6645 if (SvREADONLY(sv)) {
6649 if (SvROK(sv)) {
6651 if (SvAMAGIC(sv) && AMG_CALLun(sv,dec))
6653 i = PTR2IV(SvRV(sv));
6654 sv_unref(sv);
6655 sv_setiv(sv, i);
6660 flags = SvFLAGS(sv);
6666 if (SvIsUV(sv)) {
6667 if (SvUVX(sv) == 0) {
6668 (void)SvIOK_only(sv);
6669 SvIVX(sv) = -1;
6672 (void)SvIOK_only_UV(sv);
6673 --SvUVX(sv);
6676 if (SvIVX(sv) == IV_MIN)
6677 sv_setnv(sv, (NV)IV_MIN - 1.0);
6679 (void)SvIOK_only(sv);
6680 --SvIVX(sv);
6686 SvNVX(sv) -= 1.0;
6687 (void)SvNOK_only(sv);
6692 sv_upgrade(sv, SVt_NV);
6693 SvNVX(sv) = -1.0;
6694 (void)SvNOK_only(sv);
6699 int numtype = grok_number(SvPVX(sv), SvCUR(sv), NULL);
6708 (void) sv_2iv(sv);
6709 if (SvIOK(sv))
6714 (void)SvNOK_only(sv);
6715 SvNVX(sv) -= 1.0;
6723 SvPVX(sv), SvIVX(sv), SvNVX(sv)));
6726 SvPVX(sv), SvIVX(sv), SvNVX(sv)));
6731 sv_setnv(sv,Atof(SvPVX(sv)) - 1.0); /* punt */
6753 register SV *sv;
6755 new_SV(sv);
6756 sv_setsv(sv,oldstr);
6758 PL_tmps_stack[++PL_tmps_ix] = sv;
6759 SvTEMP_on(sv);
6760 return sv;
6777 register SV *sv;
6779 new_SV(sv);
6780 SvFLAGS(sv) = SVs_TEMP;
6782 PL_tmps_stack[++PL_tmps_ix] = sv;
6783 return sv;
6797 Perl_sv_2mortal(pTHX_ register SV *sv)
6799 if (!sv)
6800 return sv;
6801 if (SvREADONLY(sv) && SvIMMORTAL(sv))
6802 return sv;
6804 PL_tmps_stack[++PL_tmps_ix] = sv;
6805 SvTEMP_on(sv);
6806 return sv;
6822 register SV *sv;
6824 new_SV(sv);
6827 sv_setpvn(sv,s,len);
6828 return sv;
6845 register SV *sv;
6847 new_SV(sv);
6848 sv_setpvn(sv,s,len);
6849 return sv;
6869 register SV *sv;
6880 new_SV(sv);
6881 sv_upgrade(sv, SVt_PVIV);
6882 SvPVX(sv) = sharepvn(src, is_utf8?-len:len, hash);
6883 SvCUR(sv) = len;
6884 SvUVX(sv) = hash;
6885 SvLEN(sv) = 0;
6886 SvREADONLY_on(sv);
6887 SvFAKE_on(sv);
6888 SvPOK_on(sv);
6890 SvUTF8_on(sv);
6891 return sv;
6906 register SV *sv;
6909 sv = vnewSVpvf(pat, &args);
6911 return sv;
6927 register SV *sv;
6930 sv = vnewSVpvf(pat, &args);
6932 return sv;
6940 register SV *sv;
6941 new_SV(sv);
6942 sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));
6943 return sv;
6958 register SV *sv;
6960 new_SV(sv);
6961 sv_setnv(sv,n);
6962 return sv;
6977 register SV *sv;
6979 new_SV(sv);
6980 sv_setiv(sv,i);
6981 return sv;
6996 register SV *sv;
6998 new_SV(sv);
6999 sv_setuv(sv,u);
7000 return sv;
7015 register SV *sv;
7017 new_SV(sv);
7018 sv_upgrade(sv, SVt_RV);
7020 SvRV(sv) = tmpRef;
7021 SvROK_on(sv);
7022 return sv;
7026 * newRV_inc is in fact #defined to newRV in sv.h
7047 register SV *sv;
7056 new_SV(sv);
7059 sv_setsv(sv,old);
7063 sv_setsv(sv,old);
7064 return sv;
7081 register SV *sv;
7120 sv = GvSV(gv);
7121 if (SvTHINKFIRST(sv)) {
7122 if (!SvREADONLY(sv) && SvROK(sv))
7123 sv_unref(sv);
7126 (void)SvOK_off(sv);
7127 if (SvTYPE(sv) >= SVt_PV) {
7128 SvCUR_set(sv, 0);
7129 if (SvPVX(sv) != Nullch)
7130 *SvPVX(sv) = '\0';
7131 SvTAINT(sv);
7167 Perl_sv_2io(pTHX_ SV *sv)
7173 switch (SvTYPE(sv)) {
7175 io = (IO*)sv;
7178 gv = (GV*)sv;
7184 if (!SvOK(sv))
7186 if (SvROK(sv))
7187 return sv_2io(SvRV(sv));
7188 gv = gv_fetchpv(SvPV(sv,n_a), FALSE, SVt_PVIO);
7194 Perl_croak(aTHX_ "Bad filehandle: %"SVf, sv);
7210 Perl_sv_2cv(pTHX_ SV *sv, HV **st, GV **gvp, I32 lref)
7216 if (!sv)
7218 switch (SvTYPE(sv)) {
7220 *st = CvSTASH(sv);
7222 return (CV*)sv;
7228 gv = (GV*)sv;
7234 if (SvGMAGICAL(sv))
7235 mg_get(sv);
7236 if (SvROK(sv)) {
7237 SV **sp = &sv; /* Used in tryAMAGICunDEREF macro. */
7240 sv = SvRV(sv);
7241 if (SvTYPE(sv) == SVt_PVCV) {
7242 cv = (CV*)sv;
7247 else if(isGV(sv))
7248 gv = (GV*)sv;
7252 else if (isGV(sv))
7253 gv = (GV*)sv;
7255 gv = gv_fetchpv(SvPV(sv, n_a), lref, SVt_PVCV);
7276 sv);
7293 Perl_sv_true(pTHX_ register SV *sv)
7295 if (!sv)
7297 if (SvPOK(sv)) {
7299 if ((tXpv = (XPV*)SvANY(sv)) &&
7307 if (SvIOK(sv))
7308 return SvIVX(sv) != 0;
7310 if (SvNOK(sv))
7311 return SvNVX(sv) != 0.0;
7313 return sv_2bool(sv);
7328 Perl_sv_iv(pTHX_ register SV *sv)
7330 if (SvIOK(sv)) {
7331 if (SvIsUV(sv))
7332 return (IV)SvUVX(sv);
7333 return SvIVX(sv);
7335 return sv_2iv(sv);
7348 Perl_sv_uv(pTHX_ register SV *sv)
7350 if (SvIOK(sv)) {
7351 if (SvIsUV(sv))
7352 return SvUVX(sv);
7353 return (UV)SvIVX(sv);
7355 return sv_2uv(sv);
7368 Perl_sv_nv(pTHX_ register SV *sv)
7370 if (SvNOK(sv))
7371 return SvNVX(sv);
7372 return sv_2nv(sv);
7380 Perl_sv_pv(pTHX_ SV *sv)
7384 if (SvPOK(sv))
7385 return SvPVX(sv);
7387 return sv_2pv(sv, &n_a);
7404 Perl_sv_pvn(pTHX_ SV *sv, STRLEN *lp)
7406 if (SvPOK(sv)) {
7407 *lp = SvCUR(sv);
7408 return SvPVX(sv);
7410 return sv_2pv(sv, lp);
7415 Perl_sv_pvn_nomg(pTHX_ register SV *sv, STRLEN *lp)
7417 if (SvPOK(sv)) {
7418 *lp = SvCUR(sv);
7419 return SvPVX(sv);
7421 return sv_2pv_flags(sv, lp, 0);
7429 Perl_sv_pvn_force(pTHX_ SV *sv, STRLEN *lp)
7431 return sv_pvn_force_flags(sv, lp, SV_GMAGIC);
7444 If C<flags> has C<SV_GMAGIC> bit set, will C<mg_get> on C<sv> if
7454 Perl_sv_pvn_force_flags(pTHX_ SV *sv, STRLEN *lp, I32 flags)
7458 if (SvTHINKFIRST(sv) && !SvROK(sv))
7459 sv_force_normal(sv);
7461 if (SvPOK(sv)) {
7462 *lp = SvCUR(sv);
7465 if (SvTYPE(sv) > SVt_PVLV && SvTYPE(sv) != SVt_PVFM) {
7466 Perl_croak(aTHX_ "Can't coerce %s to string in %s", sv_reftype(sv,0),
7470 s = sv_2pv_flags(sv, lp, flags);
7471 if (s != SvPVX(sv)) { /* Almost, but not quite, sv_setpvn() */
7474 if (SvROK(sv))
7475 sv_unref(sv);
7476 (void)SvUPGRADE(sv, SVt_PV); /* Never FALSE */
7477 SvGROW(sv, len + 1);
7478 Move(s,SvPVX(sv),len,char);
7479 SvCUR_set(sv, len);
7480 *SvEND(sv) = '\0';
7482 if (!SvPOK(sv)) {
7483 SvPOK_on(sv); /* validate pointer */
7484 SvTAINT(sv);
7486 PTR2UV(sv),SvPVX(sv)));
7489 return SvPVX(sv);
7497 Perl_sv_pvbyte(pTHX_ SV *sv)
7499 sv_utf8_downgrade(sv,0);
7500 return sv_pv(sv);
7518 Perl_sv_pvbyten(pTHX_ SV *sv, STRLEN *lp)
7520 sv_utf8_downgrade(sv,0);
7521 return sv_pvn(sv,lp);
7535 Perl_sv_pvbyten_force(pTHX_ SV *sv, STRLEN *lp)
7537 sv_utf8_downgrade(sv,0);
7538 return sv_pvn_force(sv,lp);
7546 Perl_sv_pvutf8(pTHX_ SV *sv)
7548 sv_utf8_upgrade(sv);
7549 return sv_pv(sv);
7567 Perl_sv_pvutf8n(pTHX_ SV *sv, STRLEN *lp)
7569 sv_utf8_upgrade(sv);
7570 return sv_pvn(sv,lp);
7584 Perl_sv_pvutf8n_force(pTHX_ SV *sv, STRLEN *lp)
7586 sv_utf8_upgrade(sv);
7587 return sv_pvn_force(sv,lp);
7599 Perl_sv_reftype(pTHX_ SV *sv, int ob)
7601 if (ob && SvOBJECT(sv)) {
7602 HV *svs = SvSTASH(sv);
7608 switch (SvTYPE(sv)) {
7618 if (SvROK(sv))
7623 case SVt_PVLV: return SvROK(sv) ? "REF"
7626 : (LvTYPE(sv) == 't' || LvTYPE(sv) == 'T')
7650 Perl_sv_isobject(pTHX_ SV *sv)
7652 if (!sv)
7654 if (SvGMAGICAL(sv))
7655 mg_get(sv);
7656 if (!SvROK(sv))
7658 sv = (SV*)SvRV(sv);
7659 if (!SvOBJECT(sv))
7675 Perl_sv_isa(pTHX_ SV *sv, const char *name)
7677 if (!sv)
7679 if (SvGMAGICAL(sv))
7680 mg_get(sv);
7681 if (!SvROK(sv))
7683 sv = (SV*)SvRV(sv);
7684 if (!SvOBJECT(sv))
7687 return strEQ(HvNAME(SvSTASH(sv)), name);
7704 SV *sv;
7706 new_SV(sv);
7730 SvRV(rv) = sv;
7737 return sv;
7860 Perl_sv_bless(pTHX_ SV *sv, HV *stash)
7863 if (!SvROK(sv))
7865 tmpRef = SvRV(sv);
7882 SvAMAGIC_on(sv);
7884 SvAMAGIC_off(sv);
7892 return sv;
7899 S_sv_unglob(pTHX_ SV *sv)
7903 assert(SvTYPE(sv) == SVt_PVGV);
7904 SvFAKE_off(sv);
7905 if (GvGP(sv))
7906 gp_free((GV*)sv);
7907 if (GvSTASH(sv)) {
7908 SvREFCNT_dec(GvSTASH(sv));
7909 GvSTASH(sv) = Nullhv;
7911 sv_unmagic(sv, PERL_MAGIC_glob);
7912 Safefree(GvNAME(sv));
7913 GvMULTI_off(sv);
7915 /* need to keep SvANY(sv) in the right arena */
7917 StructCopy(SvANY(sv), xpvmg, XPVMG);
7918 del_XPVGV(SvANY(sv));
7919 SvANY(sv) = xpvmg;
7921 SvFLAGS(sv) &= ~SVTYPEMASK;
7922 SvFLAGS(sv) |= SVt_PVMG;
7940 Perl_sv_unref_flags(pTHX_ SV *sv, U32 flags)
7942 SV* rv = SvRV(sv);
7944 if (SvWEAKREF(sv)) {
7945 sv_del_backref(sv);
7946 SvWEAKREF_off(sv);
7947 SvRV(sv) = 0;
7950 SvRV(sv) = 0;
7951 SvROK_off(sv);
7972 Perl_sv_unref(pTHX_ SV *sv)
7974 sv_unref_flags(sv, 0);
7985 Perl_sv_taint(pTHX_ SV *sv)
7987 sv_magic((sv), Nullsv, PERL_MAGIC_taint, Nullch, 0);
7998 Perl_sv_untaint(pTHX_ SV *sv)
8000 if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv)) {
8001 MAGIC *mg = mg_find(sv, PERL_MAGIC_taint);
8015 Perl_sv_tainted(pTHX_ SV *sv)
8017 if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv)) {
8018 MAGIC *mg = mg_find(sv, PERL_MAGIC_taint);
8019 if (mg && ((mg->mg_len & 1) || ((mg->mg_len & 2) && mg->mg_obj == sv)))
8035 Perl_sv_setpviv(pTHX_ SV *sv, IV iv)
8041 sv_setpvn(sv, ptr, ebuf - ptr);
8053 Perl_sv_setpviv_mg(pTHX_ SV *sv, IV iv)
8059 sv_setpvn(sv, ptr, ebuf - ptr);
8060 SvSETMAGIC(sv);
8071 Perl_sv_setpvf_nocontext(SV *sv, const char* pat, ...)
8076 sv_vsetpvf(sv, pat, &args);
8086 Perl_sv_setpvf_mg_nocontext(SV *sv, const char* pat, ...)
8091 sv_vsetpvf_mg(sv, pat, &args);
8106 Perl_sv_setpvf(pTHX_ SV *sv, const char* pat, ...)
8110 sv_vsetpvf(sv, pat, &args);
8117 Perl_sv_vsetpvf(pTHX_ SV *sv, const char* pat, va_list* args)
8119 sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));
8131 Perl_sv_setpvf_mg(pTHX_ SV *sv, const char* pat, ...)
8135 sv_vsetpvf_mg(sv, pat, &args);
8142 Perl_sv_vsetpvf_mg(pTHX_ SV *sv, const char* pat, va_list* args)
8144 sv_vsetpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));
8145 SvSETMAGIC(sv);
8156 Perl_sv_catpvf_nocontext(SV *sv, const char* pat, ...)
8161 sv_vcatpvf(sv, pat, &args);
8171 Perl_sv_catpvf_mg_nocontext(SV *sv, const char* pat, ...)
8176 sv_vcatpvf_mg(sv, pat, &args);
8195 Perl_sv_catpvf(pTHX_ SV *sv, const char* pat, ...)
8199 sv_vcatpvf(sv, pat, &args);
8206 Perl_sv_vcatpvf(pTHX_ SV *sv, const char* pat, va_list* args)
8208 sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));
8220 Perl_sv_catpvf_mg(pTHX_ SV *sv, const char* pat, ...)
8224 sv_vcatpvf_mg(sv, pat, &args);
8231 Perl_sv_vcatpvf_mg(pTHX_ SV *sv, const char* pat, va_list* args)
8233 sv_vcatpvfn(sv, pat, strlen(pat), args, Null(SV**), 0, Null(bool*));
8234 SvSETMAGIC(sv);
8249 Perl_sv_vsetpvfn(pTHX_ SV *sv, const char *pat, STRLEN patlen, va_list *args, SV **svargs, I32 svmax, bool *maybe_tainted)
8251 sv_setpvn(sv, "", 0);
8252 sv_vcatpvfn(sv, pat, patlen, args, svargs, svmax, maybe_tainted);
8314 Perl_sv_vcatpvfn(pTHX_ SV *sv, const char *pat, STRLEN patlen, va_list *args, SV **svargs, I32 svmax, bool *maybe_tainted)
8333 has_utf8 = pat_utf8 = DO_UTF8(sv);
8336 (void)SvPV_force(sv, origlen);
8346 sv_catpv(sv, s ? s : nullstr);
8349 sv_catsv(sv, *svargs);
8351 SvUTF8_on(sv);
8357 sv_catsv(sv, argsv);
8359 SvUTF8_on(sv);
8393 sv_catpv(sv, ebuf);
8401 sv_catpvn(sv, p, l);
8471 sv_catpvn_utf8_upgrade(sv, p, q - p, nsv);
8473 sv_catpvn(sv, p, q - p);
8697 (!UNI_IS_INVARIANT(uv) && SvUTF8(sv)))
8945 char *s = SvPV(sv,n);
9176 i = SvCUR(sv) - origlen;
9222 SvGROW(sv, SvCUR(sv) + elen + 1);
9223 p = SvEND(sv);
9227 SvCUR(sv) = p - SvPVX(sv);
9239 if (SvCUR(sv))
9240 sv_utf8_upgrade(sv);
9248 SvGROW(sv, SvCUR(sv) + elen + 1);
9249 p = SvEND(sv);
9263 if (need >= (((STRLEN)~0) - SvCUR(sv) - dotstrlen - 1))
9265 SvGROW(sv, SvCUR(sv) + need + dotstrlen + 1);
9266 p = SvEND(sv);
9302 SvUTF8_on(sv);
9304 SvCUR(sv) = p - SvPVX(sv);
9613 Perl_ptr_table_fetch(pTHX_ PTR_TBL_t *tbl, void *sv)
9616 UV hash = PTR_TABLE_HASH(sv);
9620 if (tblent->oldval == sv)
9747 SV *sv = ¶m->proto_perl->Isv_no; /* just need SvREADONLY-ness */
9753 GvCV(gv) = (CV*)sv;
9775 GvSV(gv) = sv;
9782 GvAV(gv) = (AV*)sv;
9789 GvHV(gv) = (HV*)sv;
10334 SV *sv;
10356 sv = (SV*)POPPTR(ss,ix);
10357 TOPPTR(nss,ix) = sv_dup_inc(sv, param);
10358 sv = (SV*)POPPTR(ss,ix);
10359 TOPPTR(nss,ix) = sv_dup_inc(sv, param);
10362 sv = (SV*)POPPTR(ss,ix);
10363 TOPPTR(nss,ix) = sv_dup_inc(sv, param);
10379 case SAVEt_GENERIC_SVREF: /* generic sv */
10381 sv = (SV*)POPPTR(ss,ix);
10382 TOPPTR(nss,ix) = sv_dup_inc(sv, param);
10427 sv = (SV*)POPPTR(ss,ix);
10428 TOPPTR(nss,ix) = sv_dup(sv, param);
10473 sv = (SV*)POPPTR(ss,ix);
10474 TOPPTR(nss,ix) = sv_dup_inc(sv, param);
10538 sv = (SV*)POPPTR(ss,ix);
10539 TOPPTR(nss,ix) = sv_dup_inc(sv, param);
10546 sv = (SV*)POPPTR(ss,ix);
10547 TOPPTR(nss,ix) = sv_dup_inc(sv, param);
10548 sv = (SV*)POPPTR(ss,ix);
10549 TOPPTR(nss,ix) = sv_dup_inc(sv, param);
10570 sv = (SV*)POPPTR(ss,ix);
10571 TOPPTR(nss,ix) = sv_dup(sv, param);
11453 of the sv is assumed to be octets in that encoding, and the sv
11456 If the sv already is UTF-8 (or if it is not POK), or if the encoding
11457 is not a reference, nothing is done to the sv. If the encoding is not
11461 The PV of the sv is returned.
11466 Perl_sv_recode_to_utf8(pTHX_ SV *sv, SV *encoding)
11468 if (SvPOK(sv) && !SvUTF8(sv) && !IN_BYTES && SvROK(encoding)) {
11479 XPUSHs(sv);
11496 if (s != SvPVX(sv)) {
11497 SvGROW(sv, len + 1);
11498 Move(s, SvPVX(sv), len, char);
11499 SvCUR_set(sv, len);
11500 SvPVX(sv)[len] = 0;
11504 SvUTF8_on(sv);
11506 return SvPVX(sv);