view release on metacpan or  search on metacpan

Cover.xs  view on Meta::CPAN

    for (;;) {
        PDEB(D(L, "running func %p from %p (%s)\n",
               PL_op->op_ppaddr, PL_op, OP_NAME(PL_op)));

        if (!(PL_op = PL_op->op_ppaddr(aTHX)))
            break;

        PERL_ASYNC_CHECK();
    }

    PDEB(D(L, "exiting runops_trace\n"));

    TAINT_NOT;
    return 0;
}
#endif

static char *svclassnames[] = {
    "B::NULL",
    "B::IV",
    "B::NV",
    "B::RV",
    "B::PV",
    "B::PVIV",
    "B::PVNV",
    "B::PVMG",
    "B::BM",
    "B::GV",
    "B::PVLV",
    "B::AV",
    "B::HV",
    "B::CV",
    "B::FM",
    "B::IO",
};

static SV *make_sv_object(pTHX_ SV *arg, SV *sv) {
    IV    iv;
    char *type;

    iv = PTR2IV(sv);
    type = svclassnames[SvTYPE(sv)];
    sv_setiv(newSVrv(arg, type), iv);
    return arg;
}


typedef OP *B__OP;
typedef AV *B__AV;


MODULE = Devel::Cover PACKAGE = Devel::Cover

PROTOTYPES: ENABLE

void
set_criteria(flag)
        unsigned flag
    PREINIT:
        dMY_CXT;
    PPCODE:
        MY_CXT.covering = flag;
        /* fprintf(stderr, "Cover set to %d\n", flag); */
        if (MY_CXT.replace_ops) return;
        PL_runops = MY_CXT.covering ? runops_cover : runops_orig;

void
add_criteria(flag)
        unsigned flag
    PREINIT:
        dMY_CXT;
    PPCODE:
        MY_CXT.covering |= flag;
        if (MY_CXT.replace_ops) return;
        PL_runops = MY_CXT.covering ? runops_cover : runops_orig;

void
remove_criteria(flag)
        unsigned flag
    PREINIT:
        dMY_CXT;
    PPCODE:
        MY_CXT.covering &= ~flag;
        if (MY_CXT.replace_ops) return;
        PL_runops = MY_CXT.covering ? runops_cover : runops_orig;

unsigned
get_criteria()
    PREINIT:
        dMY_CXT;
    CODE:
        RETVAL = MY_CXT.covering;
    OUTPUT:
        RETVAL

unsigned
coverage_none()
    CODE:
        RETVAL = None;
    OUTPUT:
        RETVAL

unsigned
coverage_statement()
    CODE:
        RETVAL = Statement;
    OUTPUT:
        RETVAL

unsigned
coverage_branch()
    CODE:
        RETVAL = Branch;
    OUTPUT:
        RETVAL

unsigned
coverage_condition()
    CODE:
        RETVAL = Condition;
    OUTPUT:
        RETVAL

unsigned
coverage_subroutine()
    CODE:
        RETVAL = Subroutine;
    OUTPUT:
        RETVAL

unsigned
coverage_path()
    CODE:
        RETVAL = Path;
    OUTPUT:
        RETVAL

unsigned
coverage_pod()
    CODE:
        RETVAL = Pod;
    OUTPUT:
        RETVAL

unsigned
coverage_time()
    CODE:
        RETVAL = Time;
    OUTPUT:
        RETVAL

unsigned
coverage_all()
    CODE:
        RETVAL = All;
    OUTPUT:
        RETVAL

double
get_elapsed()
    CODE:
#ifdef HAS_GETTIMEOFDAY
        RETVAL = get_elapsed();
#else
        RETVAL = 0;
#endif
    OUTPUT:
        RETVAL

SV *
coverage(final)
        unsigned final
    PREINIT:
        dMY_CXT;
    CODE:
        NDEB(D(L, "Getting coverage %d\n", final));
        if (final) finalise_conditions(aTHX);
        if (MY_CXT.cover)
            RETVAL = newRV_inc((SV*) MY_CXT.cover);
        else
            RETVAL = &PL_sv_undef;
    OUTPUT:
        RETVAL

SV *
get_key(o)
        B::OP o
    CODE:
        RETVAL = newSV(KEY_SZ + 1);
        sv_setpvn(RETVAL, get_key(o), KEY_SZ);
    OUTPUT:
        RETVAL

void
set_first_init_and_end()
    PPCODE:
        set_firsts_if_needed(aTHX);

void
collect_inits()
    PREINIT:
        dMY_CXT;
    PPCODE:
        int i;
        if (!MY_CXT.ends) MY_CXT.ends = newAV();
        NDEB(svdump(MY_CXT.ends));
        if (PL_initav)
            for (i = 0; i <= av_len(PL_initav); i++) {
                SV **cv = av_fetch(PL_initav, i, 0);
                SvREFCNT_inc(*cv);
                av_push(MY_CXT.ends, *cv);
            }

void
set_last_end()
    PREINIT:
        dMY_CXT;
    PPCODE:
        int i;
        SV *end = (SV *)get_cv("last_end", 0);
        av_push(PL_endav, end);
        NDEB(svdump(end));
        if (!MY_CXT.ends) MY_CXT.ends = newAV();
        if (PL_endav)
            for (i = 0; i <= av_len(PL_endav); i++) {
                SV **cv = av_fetch(PL_endav, i, 0);
                SvREFCNT_inc(*cv);
                av_push(MY_CXT.ends, *cv);
            }

B::AV
get_ends()
    PREINIT:
        dMY_CXT;
    CODE:
        if (!MY_CXT.ends) MY_CXT.ends = newAV();  /* TODO: how? */
            RETVAL = MY_CXT.ends;
    OUTPUT:
        RETVAL

BOOT:
    {
        MY_CXT_INIT;
#ifdef USE_ITHREADS
        MUTEX_INIT(&DC_mutex);
#endif
        initialise(aTHX);
        if (MY_CXT.replace_ops) {
            replace_ops(aTHX);
#if defined HAS_GETTIMEOFDAY
            elapsed();
#elif defined HAS_TIMES
            cpu();
#endif
#if defined DO_RUNOPS_TRACE
            PL_runops = runops_trace;
#endif
        } else {
            PL_runops = runops_cover;
        }
        PL_savebegin = TRUE;
    }