File Coverage

xs/util.cc

Criterion	Covered	Total	%
statement	187	208	89.9
branch	254	1064	23.8
condition			n/a
subroutine			n/a
pod			n/a
total	441	1272	34.6

#include "util.h"
#include
#include

using namespace panda;
using namespace panda::log;
using panda::log::Level;

namespace xs { namespace xlog {

#define OP_NA (OP_max + 1)

using backend_t = std::add_pointer::type;

using Args = std::vector;
using Optimizer = std::function;

static Sv::payload_marker_t module_cache_marker;

bool has_module (SV* ref) {
    if (SvOBJECT(ref)) {
        auto stash = SvSTASH(ref);
        return string_view(HvNAME(stash), HvNAMELEN(stash)) == "XLog::Module";
    }
    return false;
}

Module* get_module_by_namespace (Stash stash) {
    auto module = (Module*)stash.payload(&module_cache_marker).ptr; // try to get module from cache
    if (module) return module;

    Object module_obj;
    auto name = stash.name();

    while (1) {
        auto pkg = Stash(name);
        if (pkg) {
            auto val = pkg.fetch("xlog_module").scalar();
            if (val && val.is_object_ref()) {
                Object o = val;
                if (o.stash().name() == "XLog::Module") {
                    module = xs::in(o);
                    module_obj = o;
                    break;
                }
            }
        }
        if (!name.length()) break; // stop after main::
        auto pos = name.rfind("::");
        if (pos == string_view::npos) { // look in main::
            name = "";
            continue;
        }
        name = name.substr(0, pos);
    }

    if (!module) module = &::panda_log_module;
    stash.payload_attach((void*)module, module_obj, &module_cache_marker);

    return module;
}

Module* resolve_module(size_t depth) {
    Stash stash;
    if (depth == 0) {
        stash = CopSTASH(PL_curcop);
    }
    else {
        const PERL_CONTEXT *dbcx = nullptr;
        const PERL_CONTEXT *cx = caller_cx(depth, &dbcx);
        if (cx) {
            if ((CxTYPE(cx) == CXt_SUB || CxTYPE(cx) == CXt_FORMAT)) {
                #ifdef CvHASGV
                    bool has_gv = CvHASGV(dbcx->blk_sub.cv);
                #else
                    GV * const cvgv = CvGV(dbcx->blk_sub.cv);
                    /* So is ccstack[dbcxix]. */
                    bool has_gv = (cvgv && isGV(cvgv));
                #endif
                if (has_gv) {
                    xs::Sub sub(dbcx->blk_sub.cv);
                    stash = sub.glob().effective_stash();
                }
            }
            else stash =  CopSTASH(cx->blk_oldcop);
        }
    }
    // fallback
    if (!stash) return &::panda_log_module;

    return get_module_by_namespace(stash);
}


template
inline static OP* pp_maybe_skip(SkipPredicate&& p) {
    bool skip = true;
    try {
        skip = p();
    } catch (panda::string& ex) {
        croak_sv(newSVpvn_flags(ex.c_str(), ex.length(), SVf_UTF8 | SVs_TEMP));
    }
    if (skip) {
        OP* cur_op = PL_op;
        while (OpHAS_SIBLING(cur_op))          { cur_op = OpSIBLING(cur_op); }
        while (cur_op->op_type != OP_ENTERSUB) { cur_op = cur_op->op_next; }
        return cur_op->op_next;
    } else {
        return PL_ppaddr[PL_op->op_type](aTHX);
    }
}

static bool final_check(Level level, SV* mod_sv) {
    const Module* module = nullptr;
    if (mod_sv) {
        if (mod_sv && SvROK(mod_sv)) {
            auto ref = SvRV(mod_sv);
            bool ok = has_module(ref);
            if (ok) {
                module = xs::in(ref);
            }
        }
    }
    if (!module) module = resolve_module(0);
    return module->level() > level;
}

namespace access {

SV* constsv(const OP* op)  {
    if (op->op_type == OP_CONST) return cSVOPx_sv(op);
    return nullptr;
}

SV* padsv(const OP* op)  {
    if (op->op_type == OP_PADSV) return PAD_SVl(op->op_targ);
    return nullptr;
}

SV* rv2sv(const OP* op)  {
    if (OP_TYPE_IS_OR_WAS(op, OP_RV2SV)) {
        auto gvop = cUNOPx(op)->op_first;
        if (gvop->op_type == OP_GVSV) {
            auto gv = cGVOPx_gv(gvop);
            if (SvTYPE(gv) == SVt_PVGV) {
                return GvSV(gv);
            }
        }
    }
    return nullptr;
}


}

namespace with_level {

template struct AutoModule {
    static OP* pp(pTHX)  {
        auto check = [&]() { return final_check(level, nullptr); };
        return pp_maybe_skip(check);
    }
};

template struct PADSV {
    static OP* pp(pTHX)  {
        auto check = [&]() {
            auto sv = access::padsv(OpSIBLING(PL_op));
            return final_check(level, sv);
        };
        return pp_maybe_skip(check);
    }
};

template struct RV2SV {
    static OP* pp(pTHX)  {
        auto check = [&]() {
            bool skip = false;
            auto sv = access::rv2sv(OpSIBLING(PL_op));
            if (sv) skip = final_check(level, sv);
            return skip;
        };
        return pp_maybe_skip(check);
    }
};


template