File Coverage

xs/XLog.xsi

Criterion	Covered	Total	%
statement	28	28	100.0
branch	38	76	50.0
condition			n/a
subroutine			n/a
pod			n/a
total	66	104	63.4

MODE: INLINE
#include "util.h"
using namespace xs::xlog;

struct PerlObjectFormatter : IFormatter, Backref {
    string format (std::string& msg, const Info& i) const override {
        if (!is_perl_thread()) throw std::logic_error("can't call pure-perl formatting callback: log() called from perl-foreign thread");
        Object o = xs::out(this);
        auto ret = o.call("format", xs::out(msg), xs::out(i.level), xs::out(i.module->name()), xs::out(i.file), xs::out(i.line), xs::out(i.func));
        return xs::in(ret);
    }

    ~PerlObjectFormatter () { Backref::dtor(); }
};

struct PerlObjectLogger : ILogger, Backref {
    void log_format (std::string& msg, const Info& i, const IFormatter& fmt) override {
        if (!is_perl_thread()) throw std::logic_error("can't call pure-perl logging callback: log() called from perl-foreign thread");
        Object o = xs::out(this);
        auto sub = o.method("log_format");
        if (!sub) return ILogger::log_format(msg, i, fmt);
        sub.call(o.ref(), xs::out(msg), xs::out(i.level), xs::out(i.module->name()), xs::out(i.file), xs::out(i.line), xs::out(i.func), xs::out(&fmt));
    }

    void log (const string& msg, const Info& info) override {
        if (!is_perl_thread()) throw std::logic_error("can't call pure-perl logging callback: log() called from perl-foreign thread");
        Object o = xs::out(this);
        o.call("log", xs::out(msg), xs::out(info.level));
    }

    ~PerlObjectLogger () { Backref::dtor(); }
};

namespace xs {
    template  struct Typemap : Typemap {};
    template  struct Typemap : Typemap {};
}

#undef  PANDA_LOG_CODE_POINT
#define PANDA_LOG_CODE_POINT make_code_point()

static inline CV* get_context_sub () {
    int depth = 0;
    auto ctx = caller_cx(depth, nullptr);
    while (ctx) {
        if (CxTYPE(ctx) == CXt_SUB) return ctx->blk_sub.cv;
        ctx = caller_cx(++depth, nullptr);
    }
    return nullptr;
}

static inline CodePoint make_code_point () {
    auto cop = PL_curcop;

    string_view func;
    auto cv = get_context_sub();
    if (cv) {
        GV* gv = CvGV(cv);
        if (gv) func = string_view(GvNAME(gv), GvNAMELEN(gv));
    }

    return CodePoint{CopFILE(cop), CopLINE(cop), func};
}

static inline Sv format_args (SV** args, int items) {
    if (!items) return Simple(default_message);
    if (items == 1) {
        Sv arg(args[0]);
        if (arg.is_simple()) { return arg; }
        else                 { return Simple(SvPV_nolen(args[0]));  }
    }
    STRLEN patlen;
    auto pat = SvPV(args[0], patlen);
    auto ret = Simple::create(patlen * 1.5);
    bool stub = false;
    sv_vcatpvfn(ret, pat, patlen, nullptr, args + 1, items - 1, &stub);
    return ret;
}

static inline void peep_args (SV**& args, I32& items, const Module*& module, Sub& sub) {
    if (items && SvROK(args[0])) {
        auto first = SvRV(args[0]);
        if (has_module(first)) {
            module = xs::in(first);
            ++args;
            --items;
        }
        else if (SvTYPE(first) == SVt_PVCV) {
            if (items > 1) throw exception("no arguments should follow subref when logging");
            sub = first;
        }
    }

    if (!module) module = resolve_module(0); // auto detect module by namespace
}

template
void forward(Log&& log, SV**& args, I32& items, Sub& sub) {
    Simple msg;
    if (sub) {
        Sv ret = sub.call();
        SV* sv = ret;
        msg = format_args(&sv, 1);
    }
    else  {
        msg = format_args(args, items);
    }
    log << msg.as_string();
}

static void xslog (Level level, SV** args, I32 items) {
    const Module* module = nullptr;
    Sub sub;
    peep_args(args, items, module, sub);
    panda_log(level, *module, [&]{ forward(log, args, items, sub); });
}

MODULE = XLog                PACKAGE = XLog
PROTOTYPES: DISABLE

BOOT {
    Stash stash(__PACKAGE__);

    xs::exp::create_constants(stash, {
        {"VERBOSE_DEBUG", (int)Level::VerboseDebug},
        {"DEBUG",         (int)Level::Debug},
        {"INFO",          (int)Level::Info},
        {"NOTICE",        (int)Level::Notice},
        {"WARNING",       (int)Level::Warning},
        {"ERROR",         (int)Level::Error},
        {"CRITICAL",      (int)Level::Critical},
        {"ALERT",         (int)Level::Alert},
        {"EMERGENCY",     (int)Level::Emergency},
    });

    auto root_module = xs::out(&::panda_log_module);
    root_module.readonly(1);
    stash.add_const_sub("default_format", xs::out(default_format));
    stash.add_const_sub("root", root_module);
    stash.store("root_module", root_module);

    xs::at_perl_destroy([]{
        if (dyn_cast(get_logger().get())) set_logger(nullptr);
        if (dyn_cast(get_formatter().get())) set_formatter(nullptr);
    });
}

void set_level (Level level, string_view module = {})

void set_logger (ILoggerSP logger)

void set_formatter (IFormatterSP fmt) : ALIAS(set_format=1) {
    (void)ix;
    set_formatter(fmt);
}

ILoggerSP get_logger ()

IFormatterSP get_formatter ()

Module* get_module (string_view name)

void log (Level level, ...) {
    xslog(level, &ST(1), items-1);
    if (!(PL_op->op_spare & 1)) xlog::optimize();
}

Module* resolve_module(size_t depth = 0) {
    RETVAL = resolve_module(depth);
}

void __logXXX (...) : ALIAS(verbose_debug=0, debug=1, info=2, notice=3, warning=4, error=5, critical=6, alert=7, emergency=8) {
    Level level = Level((int)Level::VerboseDebug + ix);
    xslog(level, &ST(0), items);
    if (!(PL_op->op_spare & 1)) xlog::optimize(level);
}