Lines Matching defs:cv
2783 * optimiser on it), then attach it to cv (if cv is non-null)
2787 S_process_optree(pTHX_ CV *cv, OP *optree, OP* start)
2795 if (cv)
2796 startp = &CvSTART(cv);
2808 if (cv) {
2811 : CvCLONE(cv) ? padtidy_SUBCLONE : padtidy_SUB);
2838 CV *cv = PL_compcv;
2841 cv = CvOUTSIDE(cv);
2842 /* RT #127786: cv can be NULL due to an eval within the DB package
2847 if (!cv)
2849 assert(CvPADLIST(cv));
2851 PadlistNAMESARRAY(CvPADLIST(cv))[PARENT_PAD_INDEX(pn)];
3114 CV *cv;
3145 cv = isGV(gv)
3150 if (!cv)
3152 if (CvLVALUE(cv))
3157 namesv = cv_name(cv, NULL, 0);
3921 C<len> arguments to the subroutine identified by the C<cv> argument which
3935 Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv,
3963 newRV(MUTABLE_SV(cv))),
4754 CV * const cv = get_cvs("DB::postponed", 0);
4755 if (cv) {
4762 call_sv(MUTABLE_SV(cv), G_DISCARD);
7547 CV *cv;
7557 cv = newATTRSUB(floor, 0, NULL, NULL, qr);
7558 ReANY(re)->qr_anoncv = cv;
7562 (void)pad_add_anon(cv, o->op_type);
7563 SvREFCNT_inc_simple_void(cv);
9973 Perl_cv_ckproto_len_flags(pTHX_ const CV *cv, const GV *gv, const char *p,
9977 const char * cvp = SvROK(cv)
9978 ? SvTYPE(SvRV_const(cv)) == SVt_PVCV
9979 ? (cv = (const CV *)SvRV_const(cv), CvPROTO(cv))
9981 : CvPROTO(cv);
9982 STRLEN clen = CvPROTOLEN(cv), plen = len;
9995 if ((flags & SVf_UTF8) == SvUTF8(cv)) {
10035 UTF8fARG(SvUTF8(cv),clen,cvp)
10047 static void const_sv_xsub(pTHX_ CV* cv);
10048 static void const_av_xsub(pTHX_ CV* cv);
10056 If C<cv> is a constant sub eligible for inlining, returns the constant
10065 Perl_cv_const_sv(const CV *const cv)
10068 if (!cv)
10070 if (!(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM))
10072 sv = CvCONST(cv) ? MUTABLE_SV(CvXSUBANY(cv).any_ptr) : NULL;
10078 Perl_cv_const_sv_or_av(const CV * const cv)
10080 if (!cv)
10082 if (SvROK(cv)) return SvRV((SV *)cv);
10083 assert (SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM);
10084 return CvCONST(cv) ? MUTABLE_SV(CvXSUBANY(cv).any_ptr) : NULL;
10093 * allow_lex && !CvCONST(cv);
10102 S_op_const_sv(pTHX_ const OP *o, CV *cv, bool allow_lex)
10108 assert(cv);
10143 CvCONST_on(cv);
10150 S_already_defined(pTHX_ CV *const cv, OP * const block, OP * const o,
10153 assert (cv);
10159 const bool pureperl = !CvISXSUB(cv) && CvROOT(cv);
10160 if (CvLVALUE(PL_compcv) && ! CvLVALUE(cv) && pureperl
10168 CvFLAGS(cv) |=
10176 if (CvCONST(cv) || ckWARN(WARN_REDEFINE)) {
10189 report_redefined_cv(namesv, cv, const_svp);
10193 SAVEFREESV(cv);
10216 CV *cv = NULL;
10278 cv = *spot;
10282 cv = *spot;
10299 cv = PadnamePROTOCV(name);
10312 || (cv && CvLVALUE(cv) && !CvROOT(cv) && !CvXSUB(cv))
10326 if (cv) {
10327 const bool exists = CvROOT(cv) || CvXSUB(cv);
10333 if (exists || SvPOK(cv))
10334 cv_ckproto_len_flags(cv, (GV *)PadnameSV(name), ps, ps_len,
10338 S_already_defined(aTHX_ cv, block, NULL, name, &const_sv);
10340 cv = NULL;
10350 cv = NULL;
10358 if (cv) {
10359 assert(!CvROOT(cv) && !CvCONST(cv));
10360 cv_forget_slab(cv);
10363 cv = MUTABLE_CV(newSV_type(SVt_PVCV));
10364 CvFILE_set_from_cop(cv, PL_curcop);
10365 CvSTASH_set(cv, PL_curstash);
10366 *spot = cv;
10368 SvPVCLEAR(MUTABLE_SV(cv)); /* prototype is "" */
10369 CvXSUBANY(cv).any_ptr = const_sv;
10370 CvXSUB(cv) = const_sv_xsub;
10371 CvCONST_on(cv);
10372 CvISXSUB_on(cv);
10373 PoisonPADLIST(cv);
10374 CvFLAGS(cv) |= CvNOWARN_AMBIGUOUS(compcv);
10394 if (cv) { /* must reuse cv in case stub is referenced elsewhere */
10395 /* transfer PL_compcv to cv */
10397 bool free_file = CvFILE(cv) && CvDYNFILE(cv);
10399 CvFLAGS(cv) & (CVf_BUILTIN_ATTRS|CVf_NAMED);
10400 PADLIST *const temp_padl = CvPADLIST(cv);
10401 CV *const temp_cv = CvOUTSIDE(cv);
10403 CvFLAGS(cv) & (CVf_SLABBED|CVf_WEAKOUTSIDE);
10404 OP * const cvstart = CvSTART(cv);
10406 SvPOK_off(cv);
10407 CvFLAGS(cv) =
10409 CvOUTSIDE(cv) = CvOUTSIDE(compcv);
10410 CvOUTSIDE_SEQ(cv) = CvOUTSIDE_SEQ(compcv);
10411 CvPADLIST_set(cv, CvPADLIST(compcv));
10414 CvSTART(cv) = CvSTART(compcv);
10420 Safefree(CvFILE(cv));
10421 CvFILE(cv) = NULL;
10425 pad_fixup_inner_anons(CvPADLIST(cv), compcv, cv);
10431 CvFLAGS(cv) |= (CvFLAGS(compcv) & CVf_BUILTIN_ATTRS);
10435 PL_compcv = compcv = cv;
10438 cv = compcv;
10439 *spot = cv;
10443 CvLEXICAL_on(cv);
10444 if (!CvNAME_HEK(cv)) {
10453 CvNAME_HEK_set(cv, hek);
10459 if (CvFILE(cv) && CvDYNFILE(cv))
10460 Safefree(CvFILE(cv));
10461 CvFILE_set_from_cop(cv, PL_curcop);
10462 CvSTASH_set(cv, PL_curstash);
10465 sv_setpvn(MUTABLE_SV(cv), ps, ps_len);
10467 SvUTF8_on(MUTABLE_SV(cv));
10477 CvROOT(cv) = block;
10478 /* The cv no longer needs to hold a refcount on the slab, as CvROOT
10480 CvSLABBED_off(cv);
10481 OpslabREFCNT_dec_padok((OPSLAB *)CvSTART(cv));
10483 slab = (OPSLAB *)CvSTART(cv);
10485 S_process_optree(aTHX_ cv, block, start);
10490 /* Need to do a C<use attributes $stash_of_cv,\&cv,@attrs>. */
10491 apply_attrs(PL_curstash, MUTABLE_SV(cv), attrs);
10538 cv = *spot;
10547 *svspot = SvREFCNT_inc_simple_NN(cv);
10561 return cv;
10672 CV *cv = NULL; /* the previous CV with this name, if any */
10703 contains a package name, then GvSTASH(CvGV(cv)) may differ from
10787 cv = PL_compcv;
10832 cv = PL_compcv = NULL;
10837 cv = (!name || (isGV(gv) && GvCVGEN(gv)))
10857 || (cv && CvLVALUE(cv) && !CvROOT(cv) && !CvXSUB(cv)
10909 if (cv) {
10910 const bool exists = CvROOT(cv) || CvXSUB(cv);
10916 if (exists || SvPOK(cv))
10917 cv_ckproto_len_flags(cv, gv, ps, ps_len, ps_utf8);
10920 S_already_defined(aTHX_ cv, block, o, NULL, &const_sv);
10922 cv = NULL;
10936 if (cv) {
10937 assert(!CvROOT(cv) && !CvCONST(cv));
10938 cv_forget_slab(cv);
10939 SvPVCLEAR(MUTABLE_SV(cv)); /* prototype is "" */
10940 CvXSUBANY(cv).any_ptr = const_sv;
10941 CvXSUB(cv) = const_sv_xsub;
10942 CvCONST_on(cv);
10943 CvISXSUB_on(cv);
10944 PoisonPADLIST(cv);
10945 CvFLAGS(cv) |= CvNOWARN_AMBIGUOUS(PL_compcv);
10951 cv = newCONSTSUB_flags(
10955 assert(cv);
10956 assert(SvREFCNT((SV*)cv) != 0);
10957 CvFLAGS(cv) |= CvNOWARN_AMBIGUOUS(PL_compcv);
10976 if (name && cv && *name == 'B' && strEQ(name, "BEGIN"))
10977 cv = NULL;
10979 if (cv) { /* must reuse cv if autoloaded */
10980 /* transfer PL_compcv to cv */
10982 bool free_file = CvFILE(cv) && CvDYNFILE(cv);
10983 cv_flags_t existing_builtin_attrs = CvFLAGS(cv) & CVf_BUILTIN_ATTRS;
10984 PADLIST *const temp_av = CvPADLIST(cv);
10985 CV *const temp_cv = CvOUTSIDE(cv);
10987 CvFLAGS(cv) & (CVf_SLABBED|CVf_WEAKOUTSIDE);
10988 OP * const cvstart = CvSTART(cv);
10991 CvGV_set(cv,gv);
10992 assert(!CvCVGV_RC(cv));
10993 assert(CvGV(cv) == gv);
10998 CvNAME_HEK_set(cv,
11006 SvPOK_off(cv);
11007 CvFLAGS(cv) = CvFLAGS(PL_compcv) | existing_builtin_attrs
11008 | CvNAMED(cv);
11009 CvOUTSIDE(cv) = CvOUTSIDE(PL_compcv);
11010 CvOUTSIDE_SEQ(cv) = CvOUTSIDE_SEQ(PL_compcv);
11011 CvPADLIST_set(cv,CvPADLIST(PL_compcv));
11014 CvSTART(cv) = CvSTART(PL_compcv);
11020 Safefree(CvFILE(cv));
11022 CvFILE_set_from_cop(cv, PL_curcop);
11023 CvSTASH_set(cv, PL_curstash);
11026 pad_fixup_inner_anons(CvPADLIST(cv), PL_compcv, cv);
11032 CvFLAGS(cv) |= (CvFLAGS(PL_compcv) & CVf_BUILTIN_ATTRS);
11036 PL_compcv = cv;
11039 cv = PL_compcv;
11041 GvCV_set(gv, cv);
11054 SvRV_set(gv, (SV *)cv);
11059 assert(cv);
11060 assert(SvREFCNT((SV*)cv) != 0);
11062 if (!CvHASGV(cv)) {
11064 CvGV_set(cv, gv);
11068 CvNAME_HEK_set(cv, share_hek(name,
11074 CvFILE_set_from_cop(cv, PL_curcop);
11075 CvSTASH_set(cv, PL_curstash);
11079 sv_setpvn(MUTABLE_SV(cv), ps, ps_len);
11081 SvUTF8_on(MUTABLE_SV(cv));
11091 CvROOT(cv) = block;
11092 /* The cv no longer needs to hold a refcount on the slab, as CvROOT
11094 CvSLABBED_off(cv);
11095 OpslabREFCNT_dec_padok((OPSLAB *)CvSTART(cv));
11097 slab = (OPSLAB *)CvSTART(cv);
11099 S_process_optree(aTHX_ cv, block, start);
11104 /* Need to do a C<use attributes $stash_of_cv,\&cv,@attrs>. */
11105 HV *stash = name && !CvNAMED(cv) && GvSTASH(CvGV(cv))
11106 ? GvSTASH(CvGV(cv))
11109 SAVEFREESV(cv);
11110 apply_attrs(stash, MUTABLE_SV(cv), attrs);
11112 SvREFCNT_inc_simple_void_NN(cv);
11117 SV * const tmpstr = cv_name(cv,NULL,0);
11142 clear_special_blocks(name, gv, cv);
11145 process_special_blocks(floor, name, gv, cv);
11148 assert(cv);
11151 assert(!cv || evanescent || SvREFCNT((SV*)cv) != 0);
11156 assert(!cv || evanescent || SvREFCNT((SV*)cv) != 0);
11162 if (cv && name && block && CvOUTSIDE(cv) && !CvEVAL(CvOUTSIDE(cv)))
11163 pad_add_weakref(cv);
11165 return cv;
11170 GV *const gv, CV *const cv) {
11185 (void)CvGV(cv);
11189 SvREFCNT_dec_NN(MUTABLE_SV(cv));
11197 CV *const cv)
11212 (void)CvGV(cv);
11306 Perl_av_create_and_push(aTHX_ &PL_beginav, MUTABLE_SV(cv));
11307 GvCV_set(gv,0); /* cv has been hijacked */
11320 Perl_av_create_and_unshift_one(aTHX_ &PL_endav, MUTABLE_SV(cv));
11326 Perl_av_create_and_unshift_one(aTHX_ &PL_unitcheckav, MUTABLE_SV(cv));
11336 Perl_av_create_and_unshift_one(aTHX_ &PL_checkav, MUTABLE_SV(cv));
11344 HV *hv = CvSTASH(cv);
11368 Perl_av_create_and_push(aTHX_ &PL_initav, MUTABLE_SV(cv));
11375 (void)CvGV(cv);
11376 GvCV_set(gv,0); /* cv has been hijacked */
11468 CV* cv;
11500 cv = newXS_len_flags(name, len,
11506 assert(cv);
11507 assert(SvREFCNT((SV*)cv) != 0);
11508 CvXSUBANY(cv).any_ptr = SvREFCNT_inc_simple(sv);
11509 CvCONST_on(cv);
11513 return cv;
11632 CV *cv;
11645 if ((cv = (name ? GvCV(gv) : NULL))) {
11648 SvREFCNT_dec(cv);
11649 cv = NULL;
11651 else if (CvROOT(cv) || CvXSUB(cv) || GvASSUMECV(gv)) {
11655 if (CvCONST(cv) || ckWARN(WARN_REDEFINE)) {
11659 cv, const_svp);
11663 SAVEFREESV(cv);
11664 cv = NULL;
11668 if (cv) /* must reuse cv if autoloaded */
11669 cv_undef(cv);
11671 cv = MUTABLE_CV(newSV_type(SVt_PVCV));
11673 GvCV_set(gv,cv);
11679 assert(cv);
11680 assert(SvREFCNT((SV*)cv) != 0);
11682 CvGV_set(cv, gv);
11687 assert(!CvDYNFILE(cv)); /* cv_undef should have turned it off */
11689 CvDYNFILE_on(cv);
11690 CvFILE(cv) = savepv(filename);
11693 CvFILE(cv) = (char *)filename;
11697 CvFILE(cv) = (char*)PL_xsubfilename;
11699 CvISXSUB_on(cv);
11700 CvXSUB(cv) = subaddr;
11702 CvHSCXT(cv) = &PL_stack_sp;
11704 PoisonPADLIST(cv);
11708 evanescent = process_special_blocks(0, name, gv, cv);
11710 CvANON_on(cv);
11713 assert(cv);
11714 assert(evanescent || SvREFCNT((SV*)cv) != 0);
11716 if (!evanescent) sv_setpv(MUTABLE_SV(cv), proto);
11718 assert(evanescent || SvREFCNT((SV*)cv) != 0);
11719 return cv;
11729 CV *cv = MUTABLE_CV(newSV_type(SVt_PVCV));
11733 GvCV_set(gv, cv);
11742 CvGV_set(cv, cvgv);
11743 CvFILE_set_from_cop(cv, PL_curcop);
11744 CvSTASH_set(cv, PL_curstash);
11746 return cv;
11752 CV *cv;
11767 if ((cv = GvFORM(gv))) {
11782 SvREFCNT_dec(cv);
11784 cv = PL_compcv;
11785 GvFORM(gv) = (CV *)SvREFCNT_inc_simple_NN(cv);
11786 CvGV_set(cv, gv);
11787 CvFILE_set_from_cop(cv, PL_curcop);
11791 CvROOT(cv) = root;
11794 S_process_optree(aTHX_ cv, root, start);
11795 cv_forget_slab(cv);
11873 SV * const cv = MUTABLE_SV(newATTRSUB(floor, 0, proto, attrs, block));
11875 bool is_const = CvANONCONST(cv);
11879 cv);
13541 CV *const cv = (CV*)SvRV(sv);
13542 SV *name_sv = newSVhek_mortal(CvNAME_HEK(cv));
13543 (void)gv_init_sv((GV*)sv, CvSTASH(cv), name_sv, 0);
14185 CV *cv;
14202 cv = MUTABLE_CV(SvRV(gv));
14210 cv = GvCVu(gv);
14211 if (!cv) {
14221 cv = (CV*)SvRV(rv);
14225 cv = find_lexical_cv(rvop->op_targ);
14232 if (SvTYPE((SV*)cv) != SVt_PVCV)
14235 if ((!CvANON(cv) && !CvLEXICAL(cv)) || !gv)
14236 gv = CvGV(cv);
14240 if (CvLEXICAL(cv) || CvNAMED(cv))
14242 if (!CvANON(cv) || !gv)
14243 gv = CvGV(cv);
14247 return cv;
14691 Retrieves the function that will be used to fix up a call to C<cv>.
14694 at compile time as C<cv>.
14717 the SV parameter is C<cv> itself, and the C<CALL_CHECKER_REQUIRE_GV>
14747 Perl_cv_get_call_checker_flags(pTHX_ CV *cv, U32 gflags,
14753 callmg = SvMAGICAL((SV*)cv) ? mg_find((SV*)cv, PERL_MAGIC_checkcall) : NULL;
14760 *ckobj_p = (SV*)cv;
14766 Perl_cv_get_call_checker(pTHX_ CV *cv, Perl_call_checker *ckfun_p, SV **ckobj_p)
14771 cv_get_call_checker_flags(cv, CALL_CHECKER_REQUIRE_GV, ckfun_p, ckobj_p,
14778 Sets the function that will be used to fix up a call to C<cv>.
14781 at compile time as C<cv>.
14823 Perl_cv_set_call_checker(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj)
14826 cv_set_call_checker_flags(cv, ckfun, ckobj, CALL_CHECKER_REQUIRE_GV);
14830 Perl_cv_set_call_checker_flags(pTHX_ CV *cv, Perl_call_checker ckfun,
14834 if (ckfun == Perl_ck_entersub_args_proto_or_list && ckobj == (SV*)cv) {
14835 if (SvMAGICAL((SV*)cv))
14836 mg_free_type((SV*)cv, PERL_MAGIC_checkcall);
14839 sv_magic((SV*)cv, &PL_sv_undef, PERL_MAGIC_checkcall, NULL, 0);
14840 callmg = mg_find((SV*)cv, PERL_MAGIC_checkcall);
14848 if (ckobj != (SV*)cv) {
14868 CV *cv;
14880 cv = rv2cv_op_cv(cvop, RV2CVOPCV_MARK_EARLY);
14881 namegv = cv ? (GV*)rv2cv_op_cv(cvop, RV2CVOPCV_MAYBE_NAME_GV) : NULL;
14938 if (!cv) {
14945 cv_get_call_checker_flags(cv, 0, &ckfun, &ckobj, &ckflags);
14946 if (CvISXSUB(cv) || !CvROOT(cv))
14956 if (!CvANON(cv) && (!CvNAMED(cv) || CvNAME_HEK(cv)))
14957 namegv = CvGV(cv);
14959 else namegv = MUTABLE_GV(cv);
14960 /* After a syntax error in a lexical sub, the cv that
15795 const_sv_xsub(pTHX_ CV* cv)
15809 const_av_xsub(pTHX_ CV* cv)