bsc/vendor/gopkg.in/olebedev/go-duktape.v3/duk_logging.c

/*
 *  Logging support
 */

#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include "duktape.h"
#include "duk_logging.h"

/* XXX: uses stderr always for now, configurable? */

#define DUK_LOGGING_FLUSH  /* Duktape 1.x: flush stderr */

/* 3-letter log level strings. */
static const char duk__log_level_strings[] = {
	'T', 'R', 'C', 'D', 'B', 'G', 'I', 'N', 'F',
	'W', 'R', 'N', 'E', 'R', 'R', 'F', 'T', 'L'
};

/* Log method names. */
static const char *duk__log_method_names[] = {
	"trace", "debug", "info", "warn", "error", "fatal"
};

/* Constructor. */
static duk_ret_t duk__logger_constructor(duk_context *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.
		 */

		duk_inspect_callstack_entry(ctx, -2);
		if (duk_is_object(ctx, -1)) {
			if (duk_get_prop_string(ctx, -1, "function")) {
				if (duk_get_prop_string(ctx, -1, "fileName")) {
					if (duk_is_string(ctx, -1)) {
						duk_replace(ctx, 0);
					}
				}
			}
		}
		/* Leave values on stack on purpose, ignored below. */

		/* Stripping the filename might be a good idea
		 * ("/foo/bar/quux.js" -> logger name "quux"),
		 * but now used verbatim.
		 */
	}
	/* 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_string(ctx, 1, "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.
 */
static duk_ret_t duk__logger_prototype_fmt(duk_context *ctx) {
	if (duk_get_prop_string(ctx, 0, "toLogString")) {
		/* [ 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; avoid coercing the buffer to a string to
 * avoid string table traffic.
 */
static duk_ret_t duk__logger_prototype_raw(duk_context *ctx) {
	const char *data;
	duk_size_t data_len;

	data = (const char *) duk_require_buffer(ctx, 0, &data_len);
	fwrite((const void *) data, 1, data_len, stderr);
	fputc((int) '\n', stderr);
#if defined(DUK_LOGGING_FLUSH)
	fflush(stderr);
#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.
 */
static duk_ret_t duk__logger_prototype_log_shared(duk_context *ctx) {
	duk_double_t now;
	duk_time_components comp;
	duk_small_int_t entry_lev;
	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[32];  /* maximum format length is 24+1 (NUL), round up. */
	duk_size_t date_len;
	duk_small_int_t rc;

	/* 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 into a buffer
	 *  allocated directly with the correct size.  If the backend
	 *  function plays nice, it won't coerce the buffer to a string
	 *  (and thus intern it).
	 */

	entry_lev = duk_get_current_magic(ctx);
	if (entry_lev < DUK_LOG_TRACE || entry_lev > DUK_LOG_FATAL) {
		/* Should never happen, check just in case. */
		return 0;
	}
	nargs = duk_get_top(ctx);

	/* [ arg1 ... argN this ] */

	/*
	 *  Log level check
	 */

	duk_push_this(ctx);

	duk_get_prop_string(ctx, -1, "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_get_now(ctx);
	duk_time_to_components(ctx, now, &comp);
	sprintf((char *) date_buf, "%04d-%02d-%02dT%02d:%02d:%02d.%03dZ",
	        (int) comp.year, (int) comp.month + 1, (int) comp.day,
	        (int) comp.hours, (int) comp.minutes, (int) comp.seconds,
	        (int) comp.milliseconds);

	date_len = strlen((const char *) date_buf);

	duk_get_prop_string(ctx, -2, "n");
	duk_to_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_string(ctx, "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: Here it'd be nice if we didn't need to allocate a new fixed
	 * buffer for every write.  This would be possible if raw() took a
	 * buffer and a length.  We could then use a preallocated buffer for
	 * most log writes and request raw() to write a partial buffer.
	 */

	buf = (duk_uint8_t *) duk_push_fixed_buffer(ctx, tot_len);
	p = buf;

	memcpy((void *) p, (const void *) date_buf, (size_t) date_len);
	p += date_len;
	*p++ = (duk_uint8_t) ' ';

	q = (const duk_uint8_t *) duk__log_level_strings + (entry_lev * 3);
	memcpy((void *) p, (const void *) q, (size_t) 3);
	p += 3;

	*p++ = (duk_uint8_t) ' ';

	arg_str = (const duk_uint8_t *) duk_get_lstring(ctx, -2, &arg_len);
	memcpy((void *) p, (const void *) arg_str, (size_t) arg_len);
	p += arg_len;

	*p++ = (duk_uint8_t) ':';

	for (i = 0; i < nargs; i++) {
		*p++ = (duk_uint8_t) ' ';

		arg_str = (const duk_uint8_t *) duk_get_lstring(ctx, i, &arg_len);
		memcpy((void *) p, (const void *) arg_str, (size_t) arg_len);
		p += arg_len;
	}

	/* [ arg1 ... argN this loggerLevel loggerName buffer ] */

	/* 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_string(ctx, "raw");
	duk_dup(ctx, -2);
	/* [ arg1 ... argN this loggerLevel loggerName buffer 'raw' buffer ] */
	duk_call_prop(ctx, -6, 1);  /* this.raw(buffer) */

	return 0;
}

void duk_log_va(duk_context *ctx, duk_int_t level, const char *fmt, va_list ap) {
	if (level < 0) {
		level = 0;
	} else if (level > (int) (sizeof(duk__log_method_names) / sizeof(const char *)) - 1) {
		level = (int) (sizeof(duk__log_method_names) / sizeof(const char *)) - 1;
	}

	duk_push_global_stash(ctx);
	duk_get_prop_string(ctx, -1, "\xff" "logger:constructor");  /* fixed at init time */
	duk_get_prop_string(ctx, -1, "clog");
	duk_get_prop_string(ctx, -1, duk__log_method_names[level]);
	duk_dup(ctx, -2);
	duk_push_vsprintf(ctx, fmt, ap);

	/* [ ... stash Logger clog logfunc clog(=this) msg ] */

	duk_call_method(ctx, 1 /*nargs*/);

	/* [ ... stash Logger clog res ] */

	duk_pop_n(ctx, 4);
}

void duk_log(duk_context *ctx, duk_int_t level, const char *fmt, ...) {
	va_list ap;

	va_start(ap, fmt);
	duk_log_va(ctx, level, fmt, ap);
	va_end(ap);
}

void duk_logging_init(duk_context *ctx, duk_uint_t flags) {
	/* XXX: Add .name property for logger functions (useful for stack traces if they throw). */

	(void) flags;

	duk_eval_string(ctx,
		"(function(cons,prot){"
		"Object.defineProperty(Duktape,'Logger',{value:cons,writable:true,configurable:true});"
		"Object.defineProperty(cons,'prototype',{value:prot});"
		"Object.defineProperty(cons,'clog',{value:new Duktape.Logger('C'),writable:true,configurable:true});"
		"});");

	duk_push_c_function(ctx, duk__logger_constructor, DUK_VARARGS /*nargs*/);  /* Duktape.Logger */
	duk_push_object(ctx);  /* Duktape.Logger.prototype */

	/* [ ... func Duktape.Logger Duktape.Logger.prototype ] */

	duk_push_string(ctx, "name");
	duk_push_string(ctx, "Logger");
	duk_def_prop(ctx, -4, DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_FORCE);

	duk_dup_top(ctx);
	duk_put_prop_string(ctx, -2, "constructor");
	duk_push_int(ctx, 2);
	duk_put_prop_string(ctx, -2, "l");
	duk_push_string(ctx, "anon");
	duk_put_prop_string(ctx, -2, "n");
	duk_push_c_function(ctx, duk__logger_prototype_fmt, 1 /*nargs*/);
	duk_put_prop_string(ctx, -2, "fmt");
	duk_push_c_function(ctx, duk__logger_prototype_raw, 1 /*nargs*/);
	duk_put_prop_string(ctx, -2, "raw");
	duk_push_c_function(ctx, duk__logger_prototype_log_shared, DUK_VARARGS /*nargs*/);
	duk_set_magic(ctx, -1, 0);  /* magic=0: trace */
	duk_put_prop_string(ctx, -2, "trace");
	duk_push_c_function(ctx, duk__logger_prototype_log_shared, DUK_VARARGS /*nargs*/);
	duk_set_magic(ctx, -1, 1);  /* magic=1: debug */
	duk_put_prop_string(ctx, -2, "debug");
	duk_push_c_function(ctx, duk__logger_prototype_log_shared, DUK_VARARGS /*nargs*/);
	duk_set_magic(ctx, -1, 2);  /* magic=2: info */
	duk_put_prop_string(ctx, -2, "info");
	duk_push_c_function(ctx, duk__logger_prototype_log_shared, DUK_VARARGS /*nargs*/);
	duk_set_magic(ctx, -1, 3);  /* magic=3: warn */
	duk_put_prop_string(ctx, -2, "warn");
	duk_push_c_function(ctx, duk__logger_prototype_log_shared, DUK_VARARGS /*nargs*/);
	duk_set_magic(ctx, -1, 4);  /* magic=4: error */
	duk_put_prop_string(ctx, -2, "error");
	duk_push_c_function(ctx, duk__logger_prototype_log_shared, DUK_VARARGS /*nargs*/);
	duk_set_magic(ctx, -1, 5);  /* magic=5: fatal */
	duk_put_prop_string(ctx, -2, "fatal");

	/* [ ... func Duktape.Logger Duktape.Logger.prototype ] */

	/* XXX: when using ROM built-ins, "Duktape" is read-only by default so
	 * setting Duktape.Logger will now fail.
	 */

	/* [ ... func Duktape.Logger Duktape.Logger.prototype ] */

	duk_call(ctx, 2);
	duk_pop(ctx);
}