Lines Matching refs:ssv
3188 Perl_sv_copypv_flags(pTHX_ SV *const dsv, SV *const ssv, const I32 flags)
3195 s = SvPV_flags_const(ssv,len,(flags & SV_GMAGIC));
3197 if (SvUTF8(ssv))
3694 These copy the contents of the source SV C<ssv> into the destination SV C<dsv>.
3695 C<ssv> may be destroyed if it is mortal, so don't use these functions if
3702 C<sv_setsv> calls 'get' magic on C<ssv>, but skips 'set' magic on C<dsv>.
3704 C<sv_setsv_mg> calls both 'get' magic on C<ssv> and 'set' magic on C<dsv>.
3725 S_glob_assign_glob(pTHX_ SV *const dsv, SV *const ssv, const int dtype)
3733 const char * const name = GvNAME(ssv);
3734 const STRLEN len = GvNAMELEN(ssv);
3746 GvSTASH(dsv) = GvSTASH(ssv);
3750 GV_ADD | (GvNAMEUTF8(ssv) ? SVf_UTF8 : 0 ));
3754 if(GvGP(MUTABLE_GV(ssv))) {
3756 if(GvCVGEN(ssv)) {
3757 SvREFCNT_dec(GvCV(ssv));
3758 GvCV_set(ssv, NULL);
3759 GvCVGEN(ssv) = 0;
3764 GvCV((const GV *)ssv) && GvSTASH(dsv) && HvHasENAME(GvSTASH(dsv))
3807 /* freeing dsv's GP might free ssv (e.g. *x = $x),
3810 SAVEFREESV(SvREFCNT_inc_simple_NN(ssv));
3813 GvGP_set(dsv, gp_ref(GvGP(ssv)));
3816 if (SvTAINTED(ssv))
3825 if (GvAV((const GV *)ssv)) {
3864 Perl_gv_setref(pTHX_ SV *const dsv, SV *const ssv)
3866 SV * const sref = SvRV(ssv);
4072 if (SvTAINTED(ssv))
4123 Perl_sv_setsv_flags(pTHX_ SV *dsv, SV* ssv, const I32 flags)
4132 if (UNLIKELY( ssv == dsv ))
4135 if (UNLIKELY( !ssv ))
4136 ssv = &PL_sv_undef;
4138 stype = SvTYPE(ssv);
4169 assert(!SvGMAGICAL(ssv));
4172 sflags = SvFLAGS(ssv);
4178 dsv->sv_u.svu_rv = SvREFCNT_inc(SvRV(ssv));
4185 assert( &(ssv->sv_u.svu_iv)
4186 == &(((XPVIV*) SvANY(ssv))->xiv_iv));
4189 dsv->sv_u.svu_iv = ssv->sv_u.svu_iv;
4201 assert( &(ssv->sv_u.svu_nv)
4202 == &(((XPVNV*) SvANY(ssv))->xnv_u.xnv_nv));
4205 dsv->sv_u.svu_nv = ssv->sv_u.svu_nv;
4226 " to a freed scalar %p", SVfARG(ssv), (void *)dsv);
4228 if (SvIS_FREED(ssv)) {
4230 (void*)ssv, (void*)dsv);
4252 if (SvIOK(ssv)) {
4272 SvIV_set(dsv, SvIVX(ssv));
4273 if (SvIsUV(ssv))
4279 assert(!SvTAINTED(ssv));
4282 if (!SvROK(ssv))
4289 if (LIKELY( SvNOK(ssv) )) {
4303 SvNV_set(dsv, SvNVX(ssv));
4309 assert(!SvTAINTED(ssv));
4328 invlist_clone(ssv, dsv);
4332 const char * const type = sv_reftype(ssv,0);
4350 if (SvGMAGICAL(ssv) && (flags & SV_GMAGIC)) {
4351 mg_get(ssv);
4352 if (SvTYPE(ssv) != stype)
4353 stype = SvTYPE(ssv);
4355 if (isGV_with_GP(ssv) && dtype <= SVt_PVLV) {
4356 glob_assign_glob(dsv, ssv, dtype);
4361 if (isREGEXP(ssv)) goto upgregexp;
4371 sflags = SvFLAGS(ssv);
4375 if (SvOK(ssv)) {
4377 const char *const ptr = SvPV_const(ssv, len);
4400 && SvTYPE(SvRV(ssv)) == SVt_PVGV && isGV_with_GP(SvRV(ssv))) {
4401 ssv = SvRV(ssv);
4402 if (ssv == dsv) {
4411 glob_assign_glob(dsv, ssv, dtype);
4417 gv_setref(dsv, ssv);
4427 SvRV_set(dsv, SvREFCNT_inc(SvRV(ssv)));
4440 GV *gv = gv_fetchsv_nomg(ssv, GV_ADD, SVt_PVGV);
4479 && (stype == SVt_REGEXP || isREGEXP(ssv))) {
4480 reg_temp_copy((REGEXP*)dsv, (REGEXP*)ssv);
4483 const STRLEN cur = SvCUR(ssv);
4484 const STRLEN len = SvLEN(ssv);
4505 * slow things down, as SvPVX_const(ssv) would have been freed
4555 SvREFCNT(ssv) == 1 && /* and no other references to it? */
4560 SvPV_set(dsv, SvPVX_mutable(ssv));
4561 SvLEN_set(dsv, SvLEN(ssv));
4562 SvCUR_set(dsv, SvCUR(ssv));
4565 (void)SvOK_off(ssv); /* NOTE: nukes most SvFLAGS on ssv */
4566 SvPV_set(ssv, NULL);
4567 SvLEN_set(ssv, 0);
4568 SvCUR_set(ssv, 0);
4569 SvTEMP_off(ssv);
4574 else if (SvIsCOW_static(ssv)) {
4578 SvPV_set(dsv, SvPVX(ssv));
4591 && CowREFCNT(ssv) != SV_COW_REFCNT_MAX ))
4606 PerlIO_printf(Perl_debug_log, "Copy on write: ssv --> dsv\n");
4607 sv_dump(ssv);
4613 SvIsCOW_on(ssv);
4614 CowREFCNT(ssv) = 0;
4624 sv_buf_to_rw(ssv);
4626 CowREFCNT(ssv)++;
4627 SvPV_set(dsv, SvPVX_mutable(ssv));
4628 sv_buf_to_ro(ssv);
4638 HEK_KEY(share_hek_hek(SvSHARED_HEK_FROM_PV(SvPVX_const(ssv)))));
4647 Move(SvPVX_const(ssv),SvPVX(dsv),cur,char);
4652 SvNV_set(dsv, SvNVX(ssv));
4665 SvIV_set(dsv, SvIVX(ssv));
4677 const MAGIC * const smg = SvVSTRING_mg(ssv);
4690 SvIV_set(dsv, SvIVX(ssv));
4693 SvNV_set(dsv, SvNVX(ssv));
4697 if (isGV_with_GP(ssv)) {
4698 gv_efullname3(dsv, MUTABLE_GV(ssv), "*");
4703 if (SvTAINTED(ssv))
4830 Perl_sv_setsv_mg(pTHX_ SV *const dsv, SV *const ssv)
4834 sv_setsv(dsv,ssv);
4841 Perl_sv_setsv_cow(pTHX_ SV *dsv, SV *ssv)
4843 STRLEN cur = SvCUR(ssv);
4844 STRLEN len = SvLEN(ssv);
4848 const bool already = cBOOL(SvIsCOW(ssv));
4855 (void*)ssv, (void*)dsv);
4856 sv_dump(ssv);
4871 assert (SvPOK(ssv));
4872 assert (SvPOKp(ssv));
4874 if (SvIsCOW(ssv)) {
4875 if (SvIsCOW_shared_hash(ssv)) {
4879 new_pv = HEK_KEY(share_hek_hek(SvSHARED_HEK_FROM_PV(SvPVX_const(ssv))));
4882 else if (SvIsCOW_static(ssv)) {
4884 new_pv = SvPVX(ssv);
4888 assert(SvCUR(ssv)+1 < SvLEN(ssv));
4889 assert(CowREFCNT(ssv) < SV_COW_REFCNT_MAX);
4891 assert ((SvFLAGS(ssv) & CAN_COW_MASK) == CAN_COW_FLAGS);
4892 SvUPGRADE(ssv, SVt_COW);
4893 SvIsCOW_on(ssv);
4895 "Fast copy on write: Converting ssv to COW\n"));
4896 CowREFCNT(ssv) = 0;
4899 if (already) sv_buf_to_rw(ssv);
4901 CowREFCNT(ssv)++;
4902 new_pv = SvPVX_mutable(ssv);
4903 sv_buf_to_ro(ssv);
4908 if (SvUTF8(ssv))
14378 Perl_rvpv_dup(pTHX_ SV *const dsv, const SV *const ssv, CLONE_PARAMS *const param)
14382 assert(!isREGEXP(ssv));
14383 if (SvROK(ssv)) {
14384 if (SvWEAKREF(ssv)) {
14385 SvRV_set(dsv, sv_dup(SvRV_const(ssv), param));
14393 SvRV_set(dsv, sv_dup_inc(SvRV_const(ssv), param));
14395 else if (SvPVX_const(ssv)) {
14397 if (SvLEN(ssv)) {
14399 SvPV_set(dsv, SAVEPVN(SvPVX_const(ssv), SvLEN(ssv)-1));
14400 /* ssv may not be that normal, but actually copy on write.
14406 if (isGV_with_GP(ssv)) {
14409 else if ((SvIsCOW_shared_hash(ssv))) {
14412 HEK_KEY(hek_dup(SvSHARED_HEK_FROM_PV(SvPVX_const(ssv)),
14417 SvPV_set(dsv, (char *) SvPVX_const(ssv));
14443 S_sv_dup_hvaux(pTHX_ const SV *const ssv, SV *dsv, CLONE_PARAMS *const param)
14447 const struct xpvhv_aux * const saux = HvAUX(ssv);
14503 if (HvNAME(ssv))
14506 if (HvSTASH_IS_CLASS(ssv)) {
14524 S_sv_dup_common(pTHX_ const SV *const ssv, CLONE_PARAMS *const param)
14530 if (SvIS_FREED(ssv)) {
14537 dsv = MUTABLE_SV(ptr_table_fetch(PL_ptr_table, ssv));
14544 if (SvTYPE(ssv) == SVt_PVHV) {
14545 const HEK * const hvname = HvNAME_HEK(ssv);
14550 ptr_table_store(PL_ptr_table, ssv, dsv);
14554 else if (SvTYPE(ssv) == SVt_PVGV && !SvFAKE(ssv)) {
14555 HV *stash = GvSTASH(ssv);
14563 stash, GvNAME(ssv),
14564 GvNAMEUTF8(ssv)
14565 ? -GvNAMELEN(ssv)
14566 : GvNAMELEN(ssv),
14570 ptr_table_store(PL_ptr_table, ssv, *svp);
14581 dsv->sv_debug_optype = ssv->sv_debug_optype;
14582 dsv->sv_debug_line = ssv->sv_debug_line;
14583 dsv->sv_debug_inpad = ssv->sv_debug_inpad;
14584 dsv->sv_debug_parent = (SV*)ssv;
14586 dsv->sv_debug_file = savesharedpv(ssv->sv_debug_file);
14589 ptr_table_store(PL_ptr_table, ssv, dsv);
14592 SvFLAGS(dsv) = SvFLAGS(ssv);
14597 if (SvANY(ssv) && PL_watch_pvx && SvPVX_const(ssv) == PL_watch_pvx)
14599 (void*)PL_watch_pvx, SvPVX_const(ssv));
14603 if (SvOBJECT(ssv)
14604 && ! (SvFLAGS(SvSTASH(ssv)) & SVphv_CLONEABLE))
14610 switch (SvTYPE(ssv)) {
14616 if(SvROK(ssv)) {
14617 Perl_rvpv_dup(aTHX_ dsv, ssv, param);
14619 SvIV_set(dsv, SvIVX(ssv));
14628 SvNV_set(dsv, SvNVX(ssv));
14634 const svtype sv_type = SvTYPE(ssv);
14640 Perl_croak(param->proto_perl, "Bizarre SvTYPE [%" IVdf "]", (IV)SvTYPE(ssv));
14645 if (HvHasAUX(ssv)) {
14685 Copy(((char*)SvANY(ssv)) + sv_type_details->offset,
14689 Copy(((char*)SvANY(ssv)),
14698 Perl_rvpv_dup(aTHX_ dsv, ssv, param);
14726 re_dup_guts((REGEXP*) ssv, (REGEXP*) dsv, param);
14736 if (isREGEXP(ssv)) goto duprex;
14740 if(isGV_with_GP(ssv)) {
14751 GvGP_set(dsv, gp_dup(GvGP(ssv), param));
14772 /* IoDIRP(dsv) is already a copy of IoDIRP(ssv) */
14774 IoIFP(dsv) = fp_dup(IoIFP(ssv), IoTYPE(dsv), param);
14776 if (IoOFP(dsv) == IoIFP(ssv))
14786 if (AvARRAY((const AV *)ssv) && AvFILLp((const AV *)ssv) >= 0) {
14788 SSize_t items = AvFILLp((const AV *)ssv) + 1;
14790 src_ary = AvARRAY((const AV *)ssv);
14791 Newx(dst_ary, AvMAX((const AV *)ssv)+1, SV*);
14795 if (AvREAL((const AV *)ssv)) {
14803 items = AvMAX((const AV *)ssv) - AvFILLp((const AV *)ssv);
14816 if (HvARRAY((const HV *)ssv)) {
14819 XPVHV * const sxhv = (XPVHV*)SvANY(ssv);
14825 const HE * const source = HvARRAY(ssv)[i];
14830 if (HvHasAUX(ssv))
14831 sv_dup_hvaux(ssv, dsv, param);
14863 hek_dup(CvNAME_HEK((CV *)ssv), param);
14869 ? gv_dup_inc(CvGV(ssv), param)
14872 : gv_dup(CvGV(ssv), param);
14874 if (!CvISXSUB(ssv)) {
14875 PADLIST * padlist = CvPADLIST(ssv);
14884 CvWEAKOUTSIDE(ssv)
14890 Size_t fieldcount = ObjectMAXFIELD(ssv) + 1;
14895 sv_dup_inc_multiple(ObjectFIELDS(ssv), ObjectFIELDS(dsv), fieldcount, param);
14906 Perl_sv_dup_inc(pTHX_ const SV *const ssv, CLONE_PARAMS *const param)
14909 return ssv ? SvREFCNT_inc(sv_dup_common(ssv, param)) : NULL;
14913 Perl_sv_dup(pTHX_ const SV *const ssv, CLONE_PARAMS *const param)
14915 SV *dsv = ssv ? sv_dup_common(ssv, param) : NULL;
16562 C<encoding> is assumed to be an C<Encode> object, the PV of C<ssv> is
16565 concatenated with the decoded UTF-8 string from C<ssv>. Decoding will terminate
16567 the PV of C<ssv>. The value which C<offset> points will be modified
16568 to the last input position on C<ssv>.
16576 SV *ssv, int *offset, char *tstr, int tlen)
16582 if (SvPOK(ssv) && SvPOK(dsv) && SvROK(encoding)) {
16592 PUSHs(ssv);