errors.c
No OneTemporary
Actions

Size

30 KB

Referenced Files

None

Subscribers

None

errors.c
View Options

	#include "errors.h"
	#include "internal.h"
	#include "descriptors.h"
	#include "silver/engine.h"
	#include "modules/io.h"
	#include "highlight.h"

	#include <stdlib.h>
	#include <string.h>
	#include <stdarg.h>
	#include <limits.h>
	#include <crprintf.h>

	#ifdef _WIN32
	#define WIN32_LEAN_AND_MEAN
	#include <windows.h>
	#else
	#include <unistd.h>
	#include <sys/ioctl.h>
	#endif

	typedef struct { char *buf; size_t size; } errbuf_t;

	static void print_error_value(ant_t js, ant_value_t value, ant_value_t fallback_stack, const char prefix) {
	ant_value_t obj = is_err(value) ? js_as_obj(value) : value;
	const char *stack = NULL; bool no_stack = false;

	if (vtype(obj) == T_OBJ) {
	ant_value_t err_type = js_get_slot(obj, SLOT_ERR_TYPE);
	no_stack = vtype(err_type) == T_NUM && ((int)js_getnum(err_type) & JS_ERR_NO_STACK);
	if (!no_stack) stack = get_str_prop(js, obj, "stack", 5, NULL);
	}

	if (!no_stack && !stack && vtype(fallback_stack) == T_STR) {
	ant_offset_t slen;
	ant_offset_t soff = vstr(js, fallback_stack, &slen);
	stack = (const char *)(uintptr_t)(soff);
	}

	if (prefix) fputs(prefix, stderr);

	if (stack) {
	fputs(stack, stderr);
	size_t n = strlen(stack);
	if (n == 0 \|\| stack[n - 1] != '\n') fputc('\n', stderr);
	} else if (vtype(obj) == T_OBJ) {
	const char *name = get_str_prop(js, obj, "name", 4, NULL);
	const char *msg = get_str_prop(js, obj, "message", 7, NULL);

	if (name && msg) fprintf(stderr, "%s%s%s: %s%s%s\n", C_RED, name, C_RESET, C_BOLD, msg, C_RESET);
	else if (name) fprintf(stderr, "%s%s%s\n", C_RED, name, C_RESET);
	else fprintf(stderr, "[object Error]\n");
	}

	else fprintf(stderr, "%s\n", js_str(js, value));
	}

	bool print_uncaught_throw(ant_t *js) {
	if (!js->thrown_exists) return false;
	print_error_value(js, js->thrown_value, js->thrown_stack, NULL);

	js->thrown_exists = false;
	js->thrown_value = js_mkundef();
	js->thrown_stack = js_mkundef();

	return true;
	}

	bool print_unhandled_promise_rejection(ant_t *js, ant_value_t value) {
	print_error_value(js, value, js_mkundef(), "Uncaught (in promise) ");
	return true;
	}

	bool js_mark_errorlike_no_stack(ant_t *js, ant_value_t value) {
	if (vtype(value) != T_OBJ) return false;
	if (js_get_slot(value, SLOT_ERROR_BRAND) == js_true) return false;

	const char *name = get_str_prop(js, value, "name", 4, NULL);
	const char *message = get_str_prop(js, value, "message", 7, NULL);
	if ((!name \|\| !name) && (!message \|\| !message)) return false;

	ant_value_t err_type = js_get_slot(value, SLOT_ERR_TYPE);
	int base_type = vtype(err_type) == T_NUM ? (int)js_getnum(err_type) : JS_ERR_GENERIC;

	js_set(js, value, "stack", js_mkundef());
	js_set_slot(value, SLOT_ERR_TYPE, js_mknum((double)(base_type \| JS_ERR_NO_STACK)));

	return true;
	}

	static const char *get_error_type_name(js_err_type_t err_type) {
	static const char *names[] = {
	[JS_ERR_GENERIC] = "Error",
	[JS_ERR_TYPE] = "TypeError",
	[JS_ERR_SYNTAX] = "SyntaxError",
	[JS_ERR_REFERENCE] = "ReferenceError",
	[JS_ERR_RANGE] = "RangeError",
	[JS_ERR_EVAL] = "EvalError",
	[JS_ERR_URI] = "URIError",
	[JS_ERR_INTERNAL] = "InternalError",
	[JS_ERR_AGGREGATE] = "AggregateError",
	};

	return names[err_type] ?: "Error";
	}

	static bool ensure_errbuf_capacity(errbuf_t *eb, size_t needed) {
	if (needed <= eb->size) return true;

	size_t new_size = eb->size;
	while (new_size < needed) {
	size_t next = new_size * 2;
	if (next < new_size) return false;
	new_size = next;
	}

	char next_buf = (char )realloc(eb->buf, new_size);
	if (!next_buf) return false;
	eb->buf = next_buf;
	eb->size = new_size;
	return true;
	}

	__attribute__((format(printf, 3, 4)))
	static size_t append_errbuf_fmt(errbuf_t eb, size_t used, const char fmt, ...) {
	int max_attempts = 3;
	int attempt = 0;

	for (;;) {
	if (!ensure_errbuf_capacity(eb, used + 1)) {
	return eb->size ? eb->size - 1 : used;
	}

	size_t remaining = eb->size - used;
	va_list ap;
	va_start(ap, fmt);
	int written = vsnprintf(eb->buf + used, remaining, fmt, ap);
	va_end(ap);

	if (written < 0) return used;
	if ((size_t)written < remaining) return used + (size_t)written;

	if (!ensure_errbuf_capacity(eb, used + (size_t)written + 1)) {
	if (++attempt >= max_attempts) return eb->size ? eb->size - 1 : used;
	}
	}
	}

	static inline size_t remaining_capacity(size_t used, size_t total) {
	return used >= total ? 0 : total - used;
	}

	static size_t append_error_header(errbuf_t eb, ant_t js, size_t used, int line, int col) {
	const char *file = (js->errsite.valid && js->errsite.filename) ? js->errsite.filename : js->filename;
	if (file) return append_errbuf_fmt(eb, used, "%s:%d:%d\n", file, line, col);
	return append_errbuf_fmt(eb, used, "<eval>:%d:%d\n", line, col);
	}

	static void get_line_col(const char code, ant_offset_t code_len, ant_offset_t pos, int out_line, int *out_col) {
	if (!out_line \|\| !out_col) return;

	*out_line = 1;
	*out_col = 1;

	if (!code \|\| code_len <= 0 \|\| pos <= 0) return;
	if (pos > code_len) pos = code_len;

	for (ant_offset_t i = 0; i < pos; i++) {
	char ch = code[i];
	if (ch == '\0') break;
	if (ch == '\n') {
	*out_line += 1;
	*out_col = 1;
	} else *out_col += 1;
	}
	}

	static void get_error_line(
	const char code, ant_offset_t clen, ant_offset_t pos, char buf, size_t bufsize,
	int line_start_col, ant_offset_t out_line_start, ant_offset_t *out_line_end
	) {
	if (!code \|\| bufsize == 0) {
	if (bufsize > 0) buf[0] = '\0';
	if (line_start_col) *line_start_col = 1;
	if (out_line_start) *out_line_start = 0;
	if (out_line_end) *out_line_end = 0;
	return;
	}

	if (pos > clen) pos = clen;

	if (clen == 0) {
	buf[0] = '\0';
	if (line_start_col) *line_start_col = 1;
	if (out_line_start) *out_line_start = 0;
	if (out_line_end) *out_line_end = 0;
	return;
	}

	ant_offset_t line_start = pos;
	while (line_start > 0 && code[line_start - 1] != '\n') {
	line_start--;
	}

	ant_offset_t line_end = pos;
	while (line_end < clen && code[line_end] != '\n' && code[line_end] != '\0') {
	line_end++;
	}

	ant_offset_t line_len = line_end - line_start;
	if (line_len >= bufsize) line_len = (ant_offset_t)(bufsize - 1);

	memcpy(buf, &code[line_start], line_len);
	buf[line_len] = '\0';

	if (line_start_col) *line_start_col = (int)(pos - line_start) + 1;
	if (out_line_start) *out_line_start = line_start;
	if (out_line_end) *out_line_end = line_end;
	}

	static size_t append_error_value(errbuf_t eb, ant_t js, size_t used, ant_value_t value) {
	const char *name = "Error";
	const char *msg = NULL;

	ant_offset_t name_len = 5;
	ant_offset_t msg_len = 0;

	static const void *type_dispatch[] = {
	[T_STR] = &&l_type_str,
	[T_OBJ] = &&l_type_obj,
	[T_FUNC] = &&l_type_default,
	[T_ARR] = &&l_type_default,
	[T_PROMISE] = &&l_type_default,
	[T_GENERATOR] = &&l_type_default,
	[T_BIGINT] = &&l_type_default,
	[T_NUM] = &&l_type_default,
	[T_BOOL] = &&l_type_default,
	[T_SYMBOL] = &&l_type_default,
	[T_CFUNC] = &&l_type_default,
	[T_TYPEDARRAY] = &&l_type_default,
	[T_ERR] = &&l_type_default,
	[T_UNDEF] = &&l_type_default,
	[T_NULL] = &&l_type_default,
	};

	uint8_t t = vtype(value);
	if (t < sizeof(type_dispatch) / sizeof(type_dispatch[0]) && type_dispatch[t]) {
	goto *type_dispatch[t];
	}
	goto l_type_default;

	l_type_str:
	msg = (const char *)(uintptr_t)(vstr(js, value, &msg_len));
	goto l_type_done;

	l_type_obj:
	name = get_str_prop(js, value, "name", 4, &name_len);
	if (!name) {
	name = "Error";
	name_len = 5;
	}
	msg = get_str_prop(js, value, "message", 7, &msg_len);
	goto l_type_done;

	l_type_default:
	msg = js_str(js, value);
	msg_len = msg ? (ant_offset_t)strlen(msg) : 0;
	goto l_type_done;

	l_type_done:

	static const void *dispatch[] = { &&l_with_msg, &&l_name_only };
	int key = msg ? 0 : 1;
	goto *dispatch[key];

	l_with_msg:
	return append_errbuf_fmt(eb, used,
	ERR_FMT,
	(int)name_len, name, (int)msg_len, msg
	);

	l_name_only:
	return append_errbuf_fmt(eb, used,
	ERR_NAME_ONLY,
	(int)name_len, name
	);
	}

	static int count_digits_int(int v) {
	int n = 1;
	while (v >= 10) { v /= 10; n++; }
	return n;
	}

	static void append_error_caret(errbuf_t eb, size_t n, int error_col, int span_cols) {
	if (span_cols < 1) span_cols = 1;
	if (!ensure_errbuf_capacity(eb, *n + (size_t)error_col + (size_t)span_cols + 2)) return;
	if (*n >= eb->size - 1) return;

	size_t remaining = eb->size - *n;
	for (int i = 1; i < error_col && remaining > 1; i++) {
	eb->buf[(*n)++] = ' ';
	remaining--;
	}

	for (int i = 0; i < span_cols && remaining > 1; i++) {
	eb->buf[(*n)++] = '^';
	remaining--;
	}

	eb->buf[*n] = '\0';
	}

	static int error_span_cols_for_line(ant_offset_t src_pos, ant_offset_t span_len, ant_offset_t line_start, ant_offset_t line_end) {
	if (line_end < line_start) return 1;
	if (src_pos < line_start) src_pos = line_start;
	if (src_pos > line_end) src_pos = line_end;
	if (span_len <= 0) return 1;

	ant_offset_t span_end = src_pos + span_len;
	if (span_end < src_pos) span_end = src_pos;
	if (span_end > line_end) span_end = line_end;

	ant_offset_t width = span_end - src_pos;
	if (width <= 0) width = 1;
	if (width > INT_MAX) width = INT_MAX;
	return (int)width;
	}

	static int error_terminal_columns(void) {
	#ifdef _WIN32
	HANDLE h = GetStdHandle(STD_ERROR_HANDLE);
	if (h == NULL \|\| h == INVALID_HANDLE_VALUE) h = GetStdHandle(STD_OUTPUT_HANDLE);
	if (h && h != INVALID_HANDLE_VALUE) {
	CONSOLE_SCREEN_BUFFER_INFO csbi;
	if (GetConsoleScreenBufferInfo(h, &csbi)) {
	int cols = (int)(csbi.srWindow.Right - csbi.srWindow.Left + 1);
	if (cols > 0) return cols;
	}
	}
	#else
	struct winsize ws;
	if (ioctl(STDERR_FILENO, TIOCGWINSZ, &ws) == 0 && ws.ws_col > 0) {
	return (int)ws.ws_col;
	}
	if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == 0 && ws.ws_col > 0) {
	return (int)ws.ws_col;
	}
	#endif

	const char *cols_env = getenv("COLUMNS");
	if (cols_env && *cols_env) {
	char *end = NULL;
	long cols = strtol(cols_env, &end, 10);
	if (end != cols_env && cols > 0 && cols <= INT_MAX) return (int)cols;
	}
	return 120;
	}

	static int error_context_src_cols_limit(int gutter_w) {
	int cols = error_terminal_columns();
	int half = cols / 2;
	if (half < 40) half = 40;
	int budget = half - (gutter_w + 3);
	if (budget < 20) budget = 20;
	return budget;
	}

	static const char error_frame_name(ant_t js, sv_frame_t frame, sv_func_t func) {
	if (func && func->name && func->name[0]) return func->name;
	if (js && frame && vtype(frame->callee) == T_FUNC) {
	ant_offset_t name_len = 0;
	const char *name = get_str_prop(js, js_func_obj(frame->callee), "name", 4, &name_len);
	if (name && name_len > 0) return name;
	}
	return "<anonymous>";
	}

	typedef struct {
	const char *name;
	const char *file;
	int line;
	int col;
	int index;
	int depth;
	} js_vm_frame_view_t;

	typedef bool
	(*js_vm_frame_visitor_fn)
	(ant_t js, const js_vm_frame_view_t view, void *ctx);

	static bool error_skip_bottom_wrapper_frame(const js_vm_frame_view_t *view) {
	return
	view &&
	view->index == 0 &&
	view->depth > 0 &&
	strcmp(view->name, "<anonymous>") == 0 &&
	view->line == 1 &&
	view->col == 1;
	}

	static bool error_fill_vm_frame_view(
	ant_t js, sv_vm_t vm, int depth, int i,
	const char fallback_file, js_vm_frame_view_t out
	) {
	if (!js \|\| !vm \|\| i < 0 \|\| i > depth \|\| !out) return false;

	sv_frame_t *frame = &vm->frames[i];
	sv_func_t *func = frame->func;

	out->name = error_frame_name(js, frame, func);
	out->file = (func && func->filename) ? func->filename : fallback_file;
	out->line = (func && func->source_line > 0) ? func->source_line : 1;
	out->col = 1;
	out->index = i;
	out->depth = depth;

	if (func && func->srcpos && frame->ip) {
	uint32_t l, c;
	if (sv_lookup_srcpos(func, (int)(frame->ip - func->code), &l, &c)) {
	out->line = (int)l; out->col = (int)c;
	}
	}

	return true;
	}

	static void error_visit_vm_stack_frames(
	ant_t js, const char fallback_file, js_vm_frame_visitor_fn visitor, void *ctx
	) {
	if (!js \|\| !visitor) return;
	sv_vm_t *vm = sv_vm_get_active(js);
	if (!vm) return;

	int depth = vm->fp;
	for (int i = depth; i >= 0; i--) {
	js_vm_frame_view_t view;
	if (!error_fill_vm_frame_view(js, vm, depth, i, fallback_file, &view)) continue;
	if (error_skip_bottom_wrapper_frame(&view)) continue;
	if (!visitor(js, &view, ctx)) break;
	}
	}

	typedef struct {
	errbuf_t *eb;
	size_t *n;
	size_t remaining;
	const char *dim;
	const char *reset;
	} error_frame_errbuf_ctx_t;

	static bool error_visit_frame_append_errbuf(ant_t js, const js_vm_frame_view_t view, void *ctx) {
	error_frame_errbuf_ctx_t c = (error_frame_errbuf_ctx_t )ctx;
	*c->n = append_errbuf_fmt(
	c->eb, *c->n,
	"\n at %s %s(%s:%d:%d)%s",
	view->name, c->dim, view->file, view->line, view->col, c->reset
	);
	c->remaining = remaining_capacity(*c->n, c->eb->size);
	return c->remaining > 20;
	}

	ant_value_t js_capture_raw_stack(ant_t *js) {
	errbuf_t eb = { malloc(4096), 4096 };
	if (!eb.buf) return js_mkundef();
	eb.buf[0] = '\0';

	size_t n = 0;
	const char *file = (js->errsite.valid && js->errsite.filename)
	? js->errsite.filename
	: (js->filename ? js->filename : "<eval>");

	sv_vm_t *vm = sv_vm_get_active(js);
	if (vm && vm->fp >= 0) {
	error_frame_errbuf_ctx_t ctx = { &eb, &n, remaining_capacity(n, eb.size), "", "" };
	error_visit_vm_stack_frames(js, file, error_visit_frame_append_errbuf, &ctx);
	}

	ant_value_t stack_str = js_mkstr(js, eb.buf, n);
	free(eb.buf);
	return stack_str;
	}

	static bool error_visit_frame_print_file(ant_t js, const js_vm_frame_view_t view, void *ctx) {
	FILE out = (FILE )ctx;
	fprintf(
	out, " at %s (%s%s:%d:%d%s)\n",
	view->name, C_GRAY, view->file, view->line, view->col, C_RESET
	);
	return true;
	}

	static bool append_error_context(
	errbuf_t eb, size_t n,
	const char *src, ant_offset_t src_len,
	ant_offset_t src_pos,
	int error_line_no, int error_col, int error_span_cols
	) {
	if (!src \|\| src_len <= 0 \|\| !n) return false;
	if (src_pos < 0) src_pos = 0;
	if (src_pos > src_len) src_pos = src_len;

	ant_offset_t err_line_start = src_pos;
	while (err_line_start > 0 && src[err_line_start - 1] != '\n') err_line_start--;

	ant_offset_t err_line_end = src_pos;
	while (err_line_end < src_len && src[err_line_end] != '\n' && src[err_line_end] != '\0') err_line_end++;

	ant_offset_t ctx_start = err_line_start;
	int first_line_no = error_line_no;
	for (int i = 0; i < 5 && ctx_start > 0; i++) {
	ant_offset_t prev = ctx_start - 1;
	if (src[prev] == '\n') prev--;
	while (prev >= 0 && src[prev] != '\n') prev--;

	ctx_start = prev + 1;
	first_line_no--;
	if (first_line_no < 1) { first_line_no = 1; break; }
	}

	int gutter_w = count_digits_int(error_line_no);
	int src_cols_limit = error_context_src_cols_limit(gutter_w);

	char tagged[4096]; char rendered[8192];
	highlight_state hl_state = HL_STATE_INIT;

	ant_offset_t cur = ctx_start;
	int line_no = first_line_no;

	while (cur <= err_line_end && cur < src_len) {
	ant_offset_t ls = cur, le = cur;
	while (le < src_len && src[le] != '\n' && src[le] != '\0') le++;

	int line_len = (int)(le - ls);
	bool was_clipped = (src_cols_limit > 0 && line_len > src_cols_limit);

	if (!io_no_color) {
	highlight_js_line_clipped(
	src + ls, (size_t)line_len, (size_t)src_cols_limit,
	tagged, sizeof(tagged), &hl_state
	);
	crsprintf_stateful(rendered, sizeof(rendered), NULL, tagged);
	n = append_errbuf_fmt(eb, n, "\n%*d \| %s", gutter_w, line_no, rendered);
	} else {
	int shown = was_clipped ? src_cols_limit : line_len;
	n = append_errbuf_fmt(eb, n, "\n%d \| %.s", gutter_w, line_no, shown, src + ls);
	}

	if (was_clipped) n = append_errbuf_fmt(eb, n, "...");
	if (ls == err_line_start) {
	n = append_errbuf_fmt(eb, n, "\n%*s ", gutter_w, "");
	int caret_col = error_col;
	int caret_span = error_span_cols;
	if (was_clipped) {
	int max_col = src_cols_limit > 0 ? src_cols_limit : 1;
	if (caret_col > max_col) caret_col = max_col;
	if (caret_span > max_col - caret_col + 1) caret_span = max_col - caret_col + 1;
	if (caret_span < 1) caret_span = 1;
	}
	append_error_caret(eb, n, caret_col, caret_span);
	}

	if (le >= src_len \|\| src[le] == '\0') break;
	cur = le + 1; line_no++;
	}

	return true;
	}

	static void format_error_stack(errbuf_t eb, ant_t js, size_t n, int line, int col, bool include_source_line, const char error_line, int error_col, int error_span_cols) {
	if (!ensure_errbuf_capacity(eb, *n + 1)) return;

	const char *dim = C_GRAY;
	const char *reset = C_RESET;

	if (include_source_line && error_line && error_line[0] && *n < eb->size) {
	n = append_errbuf_fmt(eb, n, "\n%s\n", error_line);
	append_error_caret(eb, n, error_col, error_span_cols);
	}

	size_t remaining = remaining_capacity(*n, eb->size);
	if (remaining > 20) {
	const char *file = (js->errsite.valid && js->errsite.filename)
	? js->errsite.filename
	: (js->filename ? js->filename : "<eval>");

	sv_vm_t *vm = sv_vm_get_active(js);
	int depth = vm ? vm->fp : -1;

	if (depth >= 0) {
	error_frame_errbuf_ctx_t ctx = { eb, n, remaining, dim, reset };
	error_visit_vm_stack_frames(js, file, error_visit_frame_append_errbuf, &ctx);
	remaining = ctx.remaining;
	}

	if (depth <= 0 && remaining > 20) {
	n = append_errbuf_fmt(eb, n,
	"\n at %s%s:%d:%d%s",
	dim, file, line, col, reset
	);
	remaining = remaining_capacity(*n, eb->size);
	}

	if (remaining > 60 && js->filename && strcmp(js->filename, "[eval]") != 0) {
	n = append_errbuf_fmt(eb, n,
	"\n at silver.sv_execute_frame %s(ant:internal/silver/engine:323:5)%s",
	dim, reset
	);
	remaining = remaining_capacity(*n, eb->size);
	}

	if (remaining > 40 && js->filename && strcmp(js->filename, "[eval]") != 0) {
	n = append_errbuf_fmt(eb, n, "\n at %sant:internal/call:13635:14%s", dim, reset);
	}
	}

	eb->buf[eb->size - 1] = '\0';
	}

	void js_set_error_site(ant_t js, const char src, ant_offset_t src_len, const char *filename, ant_offset_t off, ant_offset_t span_len) {
	if (!js) return;

	js->errsite.src = src;
	js->errsite.src_len = src_len;
	js->errsite.filename = filename;
	js->errsite.off = off < 0 ? 0 : off;
	js->errsite.span_len = span_len < 0 ? 0 : span_len;
	js->errsite.valid = (src != NULL && src_len >= 0);
	}

	void js_get_call_location(ant_t js, const char out_filename, int out_line, int *out_col) {
	if (!js) return;
	if (!js->errsite.valid) js_set_error_site_from_vm_top(js);

	if (out_filename) *out_filename = (js->errsite.valid && js->errsite.filename) ? js->errsite.filename : js->filename;
	if (out_line) *out_line = 1;
	if (out_col) *out_col = 1;

	if (js->errsite.valid && js->errsite.src) get_line_col(
	js->errsite.src, js->errsite.src_len,
	js->errsite.off, out_line, out_col
	);
	}

	void js_clear_error_site(ant_t *js) {
	if (!js) return;
	memset(&js->errsite, 0, sizeof(js->errsite));
	}

	static void resolve_error_site(
	ant_t js, const char out_src, ant_offset_t out_src_len,
	ant_offset_t out_src_pos, ant_offset_t out_span_len
	) {
	if (js && !js->errsite.valid) js_set_error_site_from_vm_top(js);

	const char *src = NULL;
	ant_offset_t src_len = 0;
	ant_offset_t src_pos = 0;
	ant_offset_t span_len = 0;

	if (js->errsite.valid) {
	src = js->errsite.src;
	src_len = js->errsite.src_len;
	src_pos = js->errsite.off;
	span_len = js->errsite.span_len;
	}

	if (out_src) *out_src = src;
	if (out_src_len) *out_src_len = src_len;
	if (out_src_pos) *out_src_pos = src_pos;
	if (out_span_len) *out_span_len = span_len;
	}

	typedef struct {
	const char *src;
	ant_offset_t src_len;
	ant_offset_t src_pos;
	int error_col;
	int error_span_cols;
	int line;
	int col;
	char error_line[256];
	} js_error_render_site_t;

	static void js_prepare_error_render_site(ant_t js, js_error_render_site_t site) {
	if (!site) return;
	memset(site, 0, sizeof(*site));
	site->line = 1;
	site->col = 1;
	site->error_col = 1;
	site->error_span_cols = 1;

	ant_offset_t src_span_len = 0;
	ant_offset_t line_start = 0, line_end = 0;
	resolve_error_site(js, &site->src, &site->src_len, &site->src_pos, &src_span_len);

	get_line_col(site->src, site->src_len, site->src_pos, &site->line, &site->col);
	get_error_line(
	site->src, site->src_len, site->src_pos,
	site->error_line, sizeof(site->error_line),
	&site->error_col, &line_start, &line_end
	);
	site->error_span_cols = error_span_cols_for_line(site->src_pos, src_span_len, line_start, line_end);
	}

	typedef enum {
	JS_STACK_TEXT_FROM_ERROR_OBJECT = 0,
	JS_STACK_TEXT_FROM_THROW_VALUE = 1,
	} js_stack_text_kind_t;

	static ant_value_t js_build_stack_text(ant_t *js, js_stack_text_kind_t kind, ant_value_t value) {
	js_error_render_site_t site;
	js_prepare_error_render_site(js, &site);

	errbuf_t eb = { malloc(4096), 4096 };
	if (!eb.buf) return js_mkundef();
	eb.buf[0] = '\0';

	size_t n = 0;
	n = append_error_header(&eb, js, 0, site.line, site.col);

	if (n > 0 && eb.buf[n - 1] == '\n') {
	n--;
	eb.buf[n] = '\0';
	}

	bool rendered_context = append_error_context(
	&eb, &n, site.src, site.src_len, site.src_pos,
	site.line, site.error_col, site.error_span_cols
	);

	if (!rendered_context && site.error_line[0]) {
	n = append_errbuf_fmt(&eb, n, "\n%s\n", site.error_line);
	append_error_caret(&eb, &n, site.error_col, site.error_span_cols);
	}

	n = append_errbuf_fmt(&eb, n, "\n");

	if (kind == JS_STACK_TEXT_FROM_ERROR_OBJECT) {
	const char *err_name = "Error";
	const char *err_msg = NULL;

	ant_offset_t name_len = 5, msg_len = 0;
	const char *n_str = get_str_prop(js, value, "name", 4, &name_len);

	if (n_str) err_name = n_str;
	err_msg = get_str_prop(js, value, "message", 7, &msg_len);

	if (err_msg) {
	n = append_errbuf_fmt(&eb, n,
	"%s%.s%s: %s%.s%s",
	C_RED, (int)name_len, err_name, C_RESET,
	C_BOLD, (int)msg_len, err_msg, C_RESET);
	} else {
	n = append_errbuf_fmt(&eb, n,
	"%s%.*s%s",
	C_RED, (int)name_len, err_name, C_RESET);
	}
	} else n = append_error_value(&eb, js, n, value);

	format_error_stack(
	&eb, js, &n, site.line, site.col, false,
	site.error_line, site.error_col, site.error_span_cols
	);

	ant_value_t stack_str = js_mkstr(js, eb.buf, n);
	free(eb.buf);
	return stack_str;
	}

	void js_capture_stack(ant_t *js, ant_value_t err_obj) {
	ant_value_t stack_str = js_build_stack_text(js, JS_STACK_TEXT_FROM_ERROR_OBJECT, err_obj);
	if (vtype(stack_str) != T_STR) return;

	js_set(js, err_obj, "stack", stack_str);
	js_set_descriptor(js, js_as_obj(err_obj), "stack", 5, JS_DESC_W \| JS_DESC_C);
	js_clear_error_site(js);
	}

	js_err_type_t get_error_type(ant_t *js) {
	if (!js->thrown_exists) return JS_ERR_GENERIC;
	ant_value_t err_type = js_get_slot(js->thrown_value, SLOT_ERR_TYPE);
	if (vtype(err_type) != T_NUM) return JS_ERR_GENERIC;
	return (js_err_type_t)((int)js_getnum(err_type) & ~JS_ERR_NO_STACK);
	}

	__attribute__((format(printf, 4, 5)))
	ant_value_t js_create_error(ant_t js, js_err_type_t err_type, ant_value_t props, const char xx, ...) {
	va_list ap;
	char error_msg[256] = {0};

	bool no_stack = (err_type & JS_ERR_NO_STACK) != 0;
	js_err_type_t base_type = (js_err_type_t)(err_type & ~JS_ERR_NO_STACK);

	va_start(ap, xx);
	vsnprintf(error_msg, sizeof(error_msg), xx, ap);
	va_end(ap);

	const char *err_name = get_error_type_name(base_type);
	size_t err_name_len = strlen(err_name);
	size_t msg_len = strlen(error_msg);

	ant_value_t err_obj = js_mkobj(js);
	js_set(js, err_obj, "name", js_mkstr(js, err_name, err_name_len));
	js_set(js, err_obj, "message", js_mkstr(js, error_msg, msg_len));
	js_set_slot(err_obj, SLOT_ERR_TYPE, js_mknum((double)err_type));

	int props_type = vtype(props);
	if ((JS_TPFLG(props_type) & T_SPECIAL_OBJECT_MASK) != 0) {
	js_merge_obj(js, err_obj, props);
	}
	ant_value_t proto = js_get_ctor_proto(js, err_name, err_name_len);
	int proto_type = vtype(proto);
	if ((JS_TPFLG(proto_type) & T_SPECIAL_OBJECT_MASK) != 0) {
	js_set_proto_init(err_obj, proto);
	}

	js->thrown_exists = true;
	js->thrown_value = err_obj;

	if (!no_stack) {
	js_capture_stack(js, err_obj);
	}

	js_clear_error_site(js);
	return mkval(T_ERR, vdata(err_obj));
	}

	ant_value_t js_make_error_silent(ant_t js, js_err_type_t err_type, const char message) {
	bool had_throw = js->thrown_exists;

	ant_value_t saved_value = had_throw ? js->thrown_value : js_mkundef();
	ant_value_t saved_stack = had_throw ? js->thrown_stack : js_mkundef();

	js_create_error(js, err_type, js_mkundef(), "%s", message);
	ant_value_t err = js->thrown_value;

	js->thrown_exists = had_throw;
	js->thrown_value = saved_value;
	js->thrown_stack = saved_stack;

	return err;
	}

	ant_value_t js_throw(ant_t *js, ant_value_t value) {
	if (vtype(value) == T_OBJ) {
	ant_value_t existing = js_get(js, value, "stack");
	if (vtype(existing) == T_STR) {
	js->thrown_exists = true;
	js->thrown_value = value;
	js_clear_error_site(js);
	return mkval(T_ERR, vdata(value));
	}
	ant_value_t slot = js_get_slot(value, SLOT_ERR_TYPE);
	if (vtype(slot) == T_NUM && ((int)js_getnum(slot) & JS_ERR_NO_STACK)) {
	js->thrown_exists = true;
	js->thrown_value = value;
	js_clear_error_site(js);
	return mkval(T_ERR, vdata(value));
	}
	}

	ant_value_t stack_str = js_build_stack_text(js, JS_STACK_TEXT_FROM_THROW_VALUE, value);
	if (vtype(stack_str) != T_STR) {
	js->thrown_exists = true;
	js->thrown_value = value;
	js_clear_error_site(js);
	return mkval(T_ERR, 0);
	}

	if (vtype(value) == T_OBJ) {
	js_set(js, value, "stack", stack_str);
	js_set_descriptor(js, js_as_obj(value), "stack", 5, JS_DESC_W \| JS_DESC_C);
	}

	js->thrown_exists = true;
	js->thrown_value = value;
	js->thrown_stack = stack_str;
	js_clear_error_site(js);

	return mkval(T_ERR, 0);
	}

	enum {
	CS_FILE = 0,
	CS_LINE,
	CS_COL,
	CS_NAME
	};

	static ant_value_t callsite_field(ant_t *js, int field) {
	ant_value_t data = js_get_slot(js->this_val, SLOT_DATA);
	if (vtype(data) != T_ARR) return js_mkundef();
	return js_arr_get(js, data, field);
	}

	static ant_value_t callsite_getFileName(ant_t js, ant_value_t args, int nargs) { return callsite_field(js, CS_FILE); }
	static ant_value_t callsite_getLineNumber(ant_t js, ant_value_t args, int nargs) { return callsite_field(js, CS_LINE); }
	static ant_value_t callsite_getColumnNumber(ant_t js, ant_value_t args, int nargs) { return callsite_field(js, CS_COL); }
	static ant_value_t callsite_getFunctionName(ant_t js, ant_value_t args, int nargs) { return callsite_field(js, CS_NAME); }

	static ant_value_t callsite_getTypeName(ant_t js, ant_value_t args, int nargs) { return js_mknull(); }
	static ant_value_t callsite_getMethodName(ant_t js, ant_value_t args, int nargs) { return callsite_field(js, CS_NAME); }

	static ant_value_t callsite_isNative(ant_t js, ant_value_t args, int nargs) { return js_false; }
	static ant_value_t callsite_isToplevel(ant_t js, ant_value_t args, int nargs) { return js_false; }
	static ant_value_t callsite_isEval(ant_t js, ant_value_t args, int nargs) { return js_false; }
	static ant_value_t callsite_isConstructor(ant_t js, ant_value_t args, int nargs) { return js_false; }
	static ant_value_t callsite_getEvalOrigin(ant_t js, ant_value_t args, int nargs) { return js_mkundef(); }
	static ant_value_t callsite_getThis(ant_t js, ant_value_t args, int nargs) { return js_mkundef(); }

	static ant_value_t callsite_toString(ant_t js, ant_value_t args, int nargs) {
	ant_value_t name = callsite_field(js, CS_NAME);
	ant_value_t file = callsite_field(js, CS_FILE);
	ant_value_t line = callsite_field(js, CS_LINE);
	ant_value_t col = callsite_field(js, CS_COL);

	const char *n = js_str(js, name);
	const char *f = js_str(js, file);
	int l = vtype(line) == T_NUM ? (int)js_getnum(line) : 0;
	int c = vtype(col) == T_NUM ? (int)js_getnum(col) : 0;

	char buf[512];
	int len = snprintf(buf, sizeof(buf), "%s (%s:%d:%d)", n, f, l, c);
	if (len < 0) len = 0;
	return js_mkstr(js, buf, (size_t)len);
	}

	typedef struct {
	ant_t *js;
	ant_value_t arr;
	ant_value_t proto;
	} callsite_build_ctx_t;

	static bool callsite_visit_frame(ant_t js, const js_vm_frame_view_t view, void *ctx) {
	callsite_build_ctx_t c = (callsite_build_ctx_t )ctx;

	ant_value_t data = js_mkarr(js);
	js_arr_push(js, data, js_mkstr(js, view->file, strlen(view->file)));
	js_arr_push(js, data, js_mknum((double)view->line));
	js_arr_push(js, data, js_mknum((double)view->col));
	js_arr_push(js, data, js_mkstr(js, view->name, strlen(view->name)));

	ant_value_t site = js_mkobj(js);
	js_set_proto_init(site, c->proto);
	js_set_slot(site, SLOT_DATA, data);

	js_arr_push(js, c->arr, site);
	return true;
	}

	ant_value_t js_build_callsite_array(ant_t *js) {
	ant_value_t proto = js_mkobj(js);

	js_set(js, proto, "getFileName", js_mkfun(callsite_getFileName));
	js_set(js, proto, "getLineNumber", js_mkfun(callsite_getLineNumber));
	js_set(js, proto, "getColumnNumber", js_mkfun(callsite_getColumnNumber));
	js_set(js, proto, "getFunctionName", js_mkfun(callsite_getFunctionName));
	js_set(js, proto, "getTypeName", js_mkfun(callsite_getTypeName));
	js_set(js, proto, "getMethodName", js_mkfun(callsite_getMethodName));
	js_set(js, proto, "isNative", js_mkfun(callsite_isNative));
	js_set(js, proto, "isToplevel", js_mkfun(callsite_isToplevel));
	js_set(js, proto, "isEval", js_mkfun(callsite_isEval));
	js_set(js, proto, "isConstructor", js_mkfun(callsite_isConstructor));
	js_set(js, proto, "getEvalOrigin", js_mkfun(callsite_getEvalOrigin));
	js_set(js, proto, "getThis", js_mkfun(callsite_getThis));
	js_set(js, proto, "toString", js_mkfun(callsite_toString));

	ant_value_t arr = js_mkarr(js);
	callsite_build_ctx_t ctx = { js, arr, proto };

	const char *file = (js->errsite.valid && js->errsite.filename)
	? js->errsite.filename
	: (js->filename ? js->filename : "<eval>");

	error_visit_vm_stack_frames(js, file, callsite_visit_frame, &ctx);
	return arr;
	}

	void js_print_stack_trace_vm(ant_t js, FILE stream) {
	const char *fallback_file = js->filename ? js->filename : "<unknown>";
	if (!stream) return;

	error_visit_vm_stack_frames(
	js, fallback_file,
	error_visit_frame_print_file, stream
	);
	}

File Metadata

Mime Type: text/x-c
Expires: Sat, May 2, 4:58 AM (1 d, 19 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 541451
Default Alt Text: errors.c (30 KB)

errors.cNo OneTemporaryActions

errors.cView Options

File Metadata

Event Timeline

errors.c
No OneTemporary
Actions

errors.c
View Options