mirror of https://github.com/svaarala/duktape.git
Sami Vaarala
9 years ago
8 changed files with 2 additions and 554 deletions
@ -1,52 +0,0 @@ |
|||||
/*
|
|
||||
* Logging |
|
||||
* |
|
||||
* Current logging primitive is a sprintf-style log which is convenient |
|
||||
* for most C code. Another useful primitive would be to log N arguments |
|
||||
* from value stack (like the Ecmascript binding does). |
|
||||
*/ |
|
||||
|
|
||||
#include "duk_internal.h" |
|
||||
|
|
||||
DUK_EXTERNAL void duk_log_va(duk_context *ctx, duk_int_t level, const char *fmt, va_list ap) { |
|
||||
/* stridx_logfunc[] must be static to allow initializer with old compilers like BCC */ |
|
||||
static const duk_uint16_t stridx_logfunc[6] = { |
|
||||
DUK_STRIDX_LC_TRACE, DUK_STRIDX_LC_DEBUG, DUK_STRIDX_LC_INFO, |
|
||||
DUK_STRIDX_LC_WARN, DUK_STRIDX_LC_ERROR, DUK_STRIDX_LC_FATAL |
|
||||
}; |
|
||||
|
|
||||
DUK_ASSERT_CTX_VALID(ctx); |
|
||||
|
|
||||
if (level < 0) { |
|
||||
level = 0; |
|
||||
} else if (level > (int) (sizeof(stridx_logfunc) / sizeof(duk_uint16_t)) - 1) { |
|
||||
level = (int) (sizeof(stridx_logfunc) / sizeof(duk_uint16_t)) - 1; |
|
||||
} |
|
||||
|
|
||||
duk_push_hobject_bidx(ctx, DUK_BIDX_LOGGER_CONSTRUCTOR); |
|
||||
duk_get_prop_stridx(ctx, -1, DUK_STRIDX_CLOG); |
|
||||
duk_get_prop_stridx(ctx, -1, stridx_logfunc[level]); |
|
||||
duk_dup(ctx, -2); |
|
||||
|
|
||||
/* [ ... Logger clog logfunc clog ] */ |
|
||||
|
|
||||
duk_push_vsprintf(ctx, fmt, ap); |
|
||||
|
|
||||
/* [ ... Logger clog logfunc clog(=this) msg ] */ |
|
||||
|
|
||||
duk_call_method(ctx, 1 /*nargs*/); |
|
||||
|
|
||||
/* [ ... Logger clog res ] */ |
|
||||
|
|
||||
duk_pop_3(ctx); |
|
||||
} |
|
||||
|
|
||||
DUK_EXTERNAL void duk_log(duk_context *ctx, duk_int_t level, const char *fmt, ...) { |
|
||||
va_list ap; |
|
||||
|
|
||||
DUK_ASSERT_CTX_VALID(ctx); |
|
||||
|
|
||||
va_start(ap, fmt); |
|
||||
duk_log_va(ctx, level, fmt, ap); |
|
||||
va_end(ap); |
|
||||
} |
|
||||
@ -1,300 +0,0 @@ |
|||||
/*
|
|
||||
* Logging support |
|
||||
*/ |
|
||||
|
|
||||
#include "duk_internal.h" |
|
||||
|
|
||||
/* 3-letter log level strings */ |
|
||||
DUK_LOCAL const duk_uint8_t duk__log_level_strings[] = { |
|
||||
(duk_uint8_t) DUK_ASC_UC_T, (duk_uint8_t) DUK_ASC_UC_R, (duk_uint8_t) DUK_ASC_UC_C, |
|
||||
(duk_uint8_t) DUK_ASC_UC_D, (duk_uint8_t) DUK_ASC_UC_B, (duk_uint8_t) DUK_ASC_UC_G, |
|
||||
(duk_uint8_t) DUK_ASC_UC_I, (duk_uint8_t) DUK_ASC_UC_N, (duk_uint8_t) DUK_ASC_UC_F, |
|
||||
(duk_uint8_t) DUK_ASC_UC_W, (duk_uint8_t) DUK_ASC_UC_R, (duk_uint8_t) DUK_ASC_UC_N, |
|
||||
(duk_uint8_t) DUK_ASC_UC_E, (duk_uint8_t) DUK_ASC_UC_R, (duk_uint8_t) DUK_ASC_UC_R, |
|
||||
(duk_uint8_t) DUK_ASC_UC_F, (duk_uint8_t) DUK_ASC_UC_T, (duk_uint8_t) DUK_ASC_UC_L |
|
||||
}; |
|
||||
|
|
||||
/* Constructor */ |
|
||||
DUK_INTERNAL duk_ret_t duk_bi_logger_constructor(duk_context *ctx) { |
|
||||
duk_hthread *thr = (duk_hthread *) ctx; |
|
||||
duk_idx_t nargs; |
|
||||
|
|
||||
/* Calling as a non-constructor is not meaningful. */ |
|
||||
if (!duk_is_constructor_call(ctx)) { |
|
||||
return DUK_RET_TYPE_ERROR; |
|
||||
} |
|
||||
|
|
||||
nargs = duk_get_top(ctx); |
|
||||
duk_set_top(ctx, 1); |
|
||||
|
|
||||
duk_push_this(ctx); |
|
||||
|
|
||||
/* [ name this ] */ |
|
||||
|
|
||||
if (nargs == 0) { |
|
||||
/* Automatic defaulting of logger name from caller. This would
|
|
||||
* work poorly with tail calls, but constructor calls are currently |
|
||||
* never tail calls, so tail calls are not an issue now. |
|
||||
*/ |
|
||||
|
|
||||
if (thr->callstack_top >= 2) { |
|
||||
duk_activation *act_caller = thr->callstack + thr->callstack_top - 2; |
|
||||
duk_hobject *func_caller; |
|
||||
|
|
||||
func_caller = DUK_ACT_GET_FUNC(act_caller); |
|
||||
if (func_caller) { |
|
||||
/* Stripping the filename might be a good idea
|
|
||||
* ("/foo/bar/quux.js" -> logger name "quux"), |
|
||||
* but now used verbatim. |
|
||||
*/ |
|
||||
duk_push_hobject(ctx, func_caller); |
|
||||
duk_get_prop_stridx(ctx, -1, DUK_STRIDX_FILE_NAME); |
|
||||
duk_replace(ctx, 0); |
|
||||
} |
|
||||
} |
|
||||
} |
|
||||
/* the stack is unbalanced here on purpose; we only rely on the
|
|
||||
* initial two values: [ name this ]. |
|
||||
*/ |
|
||||
|
|
||||
if (duk_is_string(ctx, 0)) { |
|
||||
duk_dup(ctx, 0); |
|
||||
duk_put_prop_stridx(ctx, 1, DUK_STRIDX_LC_N); |
|
||||
} else { |
|
||||
/* don't set 'n' at all, inherited value is used as name */ |
|
||||
} |
|
||||
|
|
||||
duk_compact(ctx, 1); |
|
||||
|
|
||||
return 0; /* keep default instance */ |
|
||||
} |
|
||||
|
|
||||
/* Default function to format objects. Tries to use toLogString() but falls
|
|
||||
* back to toString(). Any errors are propagated out without catching. |
|
||||
*/ |
|
||||
DUK_INTERNAL duk_ret_t duk_bi_logger_prototype_fmt(duk_context *ctx) { |
|
||||
if (duk_get_prop_stridx(ctx, 0, DUK_STRIDX_TO_LOG_STRING)) { |
|
||||
/* [ arg toLogString ] */ |
|
||||
|
|
||||
duk_dup(ctx, 0); |
|
||||
duk_call_method(ctx, 0); |
|
||||
|
|
||||
/* [ arg result ] */ |
|
||||
return 1; |
|
||||
} |
|
||||
|
|
||||
/* [ arg undefined ] */ |
|
||||
duk_pop(ctx); |
|
||||
duk_to_string(ctx, 0); |
|
||||
return 1; |
|
||||
} |
|
||||
|
|
||||
/* Default function to write a formatted log line. Writes to stderr,
|
|
||||
* appending a newline to the log line. |
|
||||
* |
|
||||
* The argument is a buffer whose visible size contains the log message. |
|
||||
* This function should avoid coercing the buffer to a string to avoid |
|
||||
* string table traffic. |
|
||||
*/ |
|
||||
DUK_INTERNAL duk_ret_t duk_bi_logger_prototype_raw(duk_context *ctx) { |
|
||||
const char *data; |
|
||||
duk_size_t data_len; |
|
||||
|
|
||||
DUK_UNREF(ctx); |
|
||||
DUK_UNREF(data); |
|
||||
DUK_UNREF(data_len); |
|
||||
|
|
||||
#ifdef DUK_USE_FILE_IO |
|
||||
data = (const char *) duk_require_buffer(ctx, 0, &data_len); |
|
||||
DUK_FWRITE((const void *) data, 1, data_len, DUK_STDERR); |
|
||||
DUK_FPUTC((int) '\n', DUK_STDERR); |
|
||||
DUK_FFLUSH(DUK_STDERR); |
|
||||
#else |
|
||||
/* nop */ |
|
||||
#endif |
|
||||
return 0; |
|
||||
} |
|
||||
|
|
||||
/* Log frontend shared helper, magic value indicates log level. Provides
|
|
||||
* frontend functions: trace(), debug(), info(), warn(), error(), fatal(). |
|
||||
* This needs to have small footprint, reasonable performance, minimal |
|
||||
* memory churn, etc. |
|
||||
*/ |
|
||||
DUK_INTERNAL duk_ret_t duk_bi_logger_prototype_log_shared(duk_context *ctx) { |
|
||||
duk_hthread *thr = (duk_hthread *) ctx; |
|
||||
duk_double_t now; |
|
||||
duk_small_int_t entry_lev = duk_get_current_magic(ctx); |
|
||||
duk_small_int_t logger_lev; |
|
||||
duk_int_t nargs; |
|
||||
duk_int_t i; |
|
||||
duk_size_t tot_len; |
|
||||
const duk_uint8_t *arg_str; |
|
||||
duk_size_t arg_len; |
|
||||
duk_uint8_t *buf, *p; |
|
||||
const duk_uint8_t *q; |
|
||||
duk_uint8_t date_buf[DUK_BI_DATE_ISO8601_BUFSIZE]; |
|
||||
duk_size_t date_len; |
|
||||
duk_small_int_t rc; |
|
||||
|
|
||||
DUK_ASSERT(entry_lev >= 0 && entry_lev <= 5); |
|
||||
DUK_UNREF(thr); |
|
||||
|
|
||||
/* XXX: sanitize to printable (and maybe ASCII) */ |
|
||||
/* XXX: better multiline */ |
|
||||
|
|
||||
/*
|
|
||||
* Logger arguments are: |
|
||||
* |
|
||||
* magic: log level (0-5) |
|
||||
* this: logger |
|
||||
* stack: plain log args |
|
||||
* |
|
||||
* We want to minimize memory churn so a two-pass approach |
|
||||
* is used: first pass formats arguments and computes final |
|
||||
* string length, second pass copies strings either into a |
|
||||
* pre-allocated and reused buffer (short messages) or into a |
|
||||
* newly allocated fixed buffer. If the backend function plays |
|
||||
* nice, it won't coerce the buffer to a string (and thus |
|
||||
* intern it). |
|
||||
*/ |
|
||||
|
|
||||
nargs = duk_get_top(ctx); |
|
||||
|
|
||||
/* [ arg1 ... argN this ] */ |
|
||||
|
|
||||
/*
|
|
||||
* Log level check |
|
||||
*/ |
|
||||
|
|
||||
duk_push_this(ctx); |
|
||||
|
|
||||
duk_get_prop_stridx(ctx, -1, DUK_STRIDX_LC_L); |
|
||||
logger_lev = (duk_small_int_t) duk_get_int(ctx, -1); |
|
||||
if (entry_lev < logger_lev) { |
|
||||
return 0; |
|
||||
} |
|
||||
/* log level could be popped but that's not necessary */ |
|
||||
|
|
||||
now = DUK_USE_DATE_GET_NOW(ctx); |
|
||||
duk_bi_date_format_timeval(now, date_buf); |
|
||||
date_len = DUK_STRLEN((const char *) date_buf); |
|
||||
|
|
||||
duk_get_prop_stridx(ctx, -2, DUK_STRIDX_LC_N); |
|
||||
duk_to_string(ctx, -1); |
|
||||
DUK_ASSERT(duk_is_string(ctx, -1)); |
|
||||
|
|
||||
/* [ arg1 ... argN this loggerLevel loggerName ] */ |
|
||||
|
|
||||
/*
|
|
||||
* Pass 1 |
|
||||
*/ |
|
||||
|
|
||||
/* Line format: <time> <entryLev> <loggerName>: <msg> */ |
|
||||
|
|
||||
tot_len = 0; |
|
||||
tot_len += 3 + /* separators: space, space, colon */ |
|
||||
3 + /* level string */ |
|
||||
date_len + /* time */ |
|
||||
duk_get_length(ctx, -1); /* loggerName */ |
|
||||
|
|
||||
for (i = 0; i < nargs; i++) { |
|
||||
/* When formatting an argument to a string, errors may happen from multiple
|
|
||||
* causes. In general we want to catch obvious errors like a toLogString() |
|
||||
* throwing an error, but we don't currently try to catch every possible |
|
||||
* error. In particular, internal errors (like out of memory or stack) are |
|
||||
* not caught. Also, we expect Error toString() to not throw an error. |
|
||||
*/ |
|
||||
if (duk_is_object(ctx, i)) { |
|
||||
/* duk_pcall_prop() may itself throw an error, but we're content
|
|
||||
* in catching the obvious errors (like toLogString() throwing an |
|
||||
* error). |
|
||||
*/ |
|
||||
duk_push_hstring_stridx(ctx, DUK_STRIDX_FMT); |
|
||||
duk_dup(ctx, i); |
|
||||
/* [ arg1 ... argN this loggerLevel loggerName 'fmt' arg ] */ |
|
||||
/* call: this.fmt(arg) */ |
|
||||
rc = duk_pcall_prop(ctx, -5 /*obj_index*/, 1 /*nargs*/); |
|
||||
if (rc) { |
|
||||
/* Keep the error as the result (coercing it might fail below,
|
|
||||
* but we don't catch that now). |
|
||||
*/ |
|
||||
; |
|
||||
} |
|
||||
duk_replace(ctx, i); |
|
||||
} |
|
||||
(void) duk_to_lstring(ctx, i, &arg_len); |
|
||||
tot_len++; /* sep (even before first one) */ |
|
||||
tot_len += arg_len; |
|
||||
} |
|
||||
|
|
||||
/*
|
|
||||
* Pass 2 |
|
||||
*/ |
|
||||
|
|
||||
/* XXX: There used to be a shared log buffer here, but it was removed
|
|
||||
* when dynamic buffer spare was removed. The problem with using |
|
||||
* bufwriter is that, without the spare, the buffer gets passed on |
|
||||
* as an argument to the raw() call so it'd need to be resized |
|
||||
* (reallocated) anyway. If raw() call convention is changed, this |
|
||||
* could be made more efficient. |
|
||||
*/ |
|
||||
|
|
||||
buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, tot_len); |
|
||||
DUK_ASSERT(buf != NULL); |
|
||||
p = buf; |
|
||||
|
|
||||
DUK_MEMCPY((void *) p, (const void *) date_buf, (size_t) date_len); |
|
||||
p += date_len; |
|
||||
*p++ = (duk_uint8_t) DUK_ASC_SPACE; |
|
||||
|
|
||||
q = duk__log_level_strings + (entry_lev * 3); |
|
||||
DUK_MEMCPY((void *) p, (const void *) q, (size_t) 3); |
|
||||
p += 3; |
|
||||
|
|
||||
*p++ = (duk_uint8_t) DUK_ASC_SPACE; |
|
||||
|
|
||||
arg_str = (const duk_uint8_t *) duk_get_lstring(ctx, -2, &arg_len); |
|
||||
DUK_MEMCPY((void *) p, (const void *) arg_str, (size_t) arg_len); |
|
||||
p += arg_len; |
|
||||
|
|
||||
*p++ = (duk_uint8_t) DUK_ASC_COLON; |
|
||||
|
|
||||
for (i = 0; i < nargs; i++) { |
|
||||
*p++ = (duk_uint8_t) DUK_ASC_SPACE; |
|
||||
|
|
||||
arg_str = (const duk_uint8_t *) duk_get_lstring(ctx, i, &arg_len); |
|
||||
DUK_ASSERT(arg_str != NULL); |
|
||||
DUK_MEMCPY((void *) p, (const void *) arg_str, (size_t) arg_len); |
|
||||
p += arg_len; |
|
||||
} |
|
||||
DUK_ASSERT(buf + tot_len == p); |
|
||||
|
|
||||
/* [ arg1 ... argN this loggerLevel loggerName buffer ] */ |
|
||||
|
|
||||
#if defined(DUK_USE_DEBUGGER_SUPPORT) && defined(DUK_USE_DEBUGGER_FWD_LOGGING) |
|
||||
/* Do debugger forwarding before raw() because the raw() function
|
|
||||
* doesn't get the log level right now. |
|
||||
*/ |
|
||||
if (DUK_HEAP_IS_DEBUGGER_ATTACHED(thr->heap)) { |
|
||||
const char *log_buf; |
|
||||
duk_size_t sz_buf; |
|
||||
log_buf = (const char *) duk_get_buffer(ctx, -1, &sz_buf); |
|
||||
DUK_ASSERT(log_buf != NULL); |
|
||||
duk_debug_write_notify(thr, DUK_DBG_CMD_LOG); |
|
||||
duk_debug_write_int(thr, (duk_int32_t) entry_lev); |
|
||||
duk_debug_write_string(thr, (const char *) log_buf, sz_buf); |
|
||||
duk_debug_write_eom(thr); |
|
||||
} |
|
||||
#endif |
|
||||
|
|
||||
/* Call this.raw(msg); look up through the instance allows user to override
|
|
||||
* the raw() function in the instance or in the prototype for maximum |
|
||||
* flexibility. |
|
||||
*/ |
|
||||
duk_push_hstring_stridx(ctx, DUK_STRIDX_RAW); |
|
||||
duk_dup(ctx, -2); |
|
||||
/* [ arg1 ... argN this loggerLevel loggerName buffer 'raw' buffer ] */ |
|
||||
duk_call_prop(ctx, -6, 1); /* this.raw(buffer) */ |
|
||||
|
|
||||
return 0; |
|
||||
} |
|
||||
Loading…
Reference in new issue