HomePhorge
Diffusion Ant (mir/inline-method) Code

ant/src/errors.c
3fa05edd2fe3mir/inline-method

Last Change
Raw File

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
);
}

Owner Packages

  • No Owners