MIRROR: javascript for 🐜's, a tiny runtime with big ambitions
improve error message consistency
+71
-21
+1
libant/meson.build
+1
libant/meson.build
+55
-6
src/cli/cprintf.c
+55
-6
src/cli/cprintf.c
···
131
131
typedef struct {
132
132
char name[MAX_VAR_NAME];
133
133
char value[MAX_VAR_VALUE];
134
-
int nlen; int vlen;
134
+
int nlen; int vlen; int is_fmt;
135
135
} cprintf_var_t;
136
136
137
137
typedef struct {
···
375
375
memcpy(v->value, vstart, vlen);
376
376
377
377
v->value[vlen] = '\0'; v->vlen = vlen;
378
-
p = after;
378
+
v->is_fmt = 0;
379
379
380
+
for (int j = 0; j < vlen; j++) {
381
+
if (vstart[j] == '%' && j + 1 < vlen && vstart[j + 1] != '%')
382
+
{ v->is_fmt = 1; break; }
383
+
}
384
+
385
+
p = after;
380
386
continue;
381
387
}
382
388
···
425
431
return 0;
426
432
}
427
433
434
+
static int match_attr_off(program_t *p, const char *s, int len) {
435
+
for (int i = 0; i < (int)ATTR_COUNT; i++) if (
436
+
len == attrs[i].nlen && memcmp(s, attrs[i].name, len) == 0) {
437
+
emit_op(p, attrs[i].op, 0); return 1;
438
+
}
439
+
return 0;
440
+
}
441
+
442
+
static int match_fg_off(program_t *p, const char *s, int len) {
443
+
for (int i = 0; i < (int)FG_COUNT; i++) if (
444
+
len == fg_colors[i].nlen && memcmp(s, fg_colors[i].name, len) == 0) {
445
+
emit_op(p, OP_SET_FG, COL_NONE); return 1;
446
+
}
447
+
if (len > 0 && s[0] == '#') { emit_op(p, OP_SET_FG, COL_NONE); return 1; }
448
+
return 0;
449
+
}
450
+
451
+
static int match_bg_off(program_t *p, const char *s, int len) {
452
+
for (int i = 0; i < (int)BG_COUNT; i++) if (
453
+
len == bg_colors[i].nlen && memcmp(s, bg_colors[i].name, len) == 0) {
454
+
emit_op(p, OP_SET_BG, COL_NONE); return 1;
455
+
}
456
+
if (tag_prefix(s, len, "bg_#")) { emit_op(p, OP_SET_BG, COL_NONE); return 1; }
457
+
return 0;
458
+
}
459
+
428
460
static int compile_tag(program_t *p, const char *tag, int len, int closing, var_table_t *vars) {
429
461
if (closing) {
430
-
if (tag_eq(tag, len, "pad") || tag_eq(tag, len, "rpad")) emit_op(p, OP_PAD_END, 0);
431
-
else emit_op(p, OP_STYLE_RESET, 0);
462
+
if (tag_eq(tag, len, "pad") || tag_eq(tag, len, "rpad")) {
463
+
emit_op(p, OP_PAD_END, 0); return 1;
464
+
}
465
+
466
+
if (match_attr_off(p, tag, len) || match_fg_off(p, tag, len) || match_bg_off(p, tag, len)) {
467
+
emit_op(p, OP_STYLE_FLUSH, 0); return 1;
468
+
}
469
+
470
+
emit_op(p, OP_STYLE_RESET, 0);
432
471
return 1;
433
472
}
434
473
···
632
671
const char *val = v->value;
633
672
int vlen = v->vlen;
634
673
char buf[MAX_VAR_VALUE];
674
+
635
675
if (lower || upper) {
636
676
transform_case(buf, val, vlen, lower);
637
677
val = buf;
638
678
}
639
-
uint32_t off = add_literal(p, val, vlen);
640
-
emit_op(p, OP_EMIT_LIT, off);
679
+
680
+
if (v->is_fmt) {
681
+
arg_class_t cls = classify_arg(val, vlen);
682
+
uint32_t off = add_literal(p, val, vlen);
683
+
emit_op(p, OP_EMIT_FMT, off | ((uint32_t)cls << 28));
684
+
} else {
685
+
uint32_t off = add_literal(p, val, vlen);
686
+
emit_op(p, OP_EMIT_LIT, off);
687
+
}
688
+
641
689
*lit = end + 1;
642
690
return *lit;
643
691
}
···
1009
1057
1010
1058
static const char *color_name(uint32_t col) {
1011
1059
switch (col) {
1060
+
case COL_NONE: return "none";
1012
1061
case COL_BLACK: return "black";
1013
1062
case COL_RED: return "red";
1014
1063
case COL_GREEN: return "green";
+13
-14
src/main.c
+13
-14
src/main.c
···
87
87
if (strcmp(mode, "hex") == 0 || strcmp(mode, "all") == 0) cprintf_debug_hex = true;
88
88
}
89
89
90
-
else fprintf(stderr, "warning: unknown ANT_DEBUG flag: %s\n", flag);
90
+
else cfprintf(stderr, "<yellow>Warning</yellow>: <bold>Unknown ANT_DEBUG flag: \"%s\"</>\n", flag);
91
91
}
92
92
93
93
static const subcommand_t *find_subcommand(const char *name) {
···
103
103
for (const subcommand_t *cmd = subcommands; cmd->name; cmd++) {
104
104
cprintf(" <pad=18>%s</pad> %s\n", cmd->name, cmd->desc);
105
105
}
106
-
cprintf("\n <pad=18><command> <bold_cyan>--help</></pad> Print help text for command.\n");
106
+
cprintf("\n <pad=18><command> <bold+cyan>--help</></pad> Print help text for command.\n");
107
107
printf("\n");
108
108
}
109
109
···
187
187
buffer = esm_fetch_url(filename, &len, &error);
188
188
189
189
if (!buffer) {
190
-
fprintf(stderr, "Error: Could not fetch '%s': %s\n", filename, error ? error : "unknown error");
191
-
free(error);
192
-
return EXIT_FAILURE;
190
+
cfprintf(stderr, "<red>Error</red>: <bold>Could not fetch \"%s\"</>: %s\n", filename, error ? error : "unknown error");
191
+
free(error); return EXIT_FAILURE;
193
192
}
194
193
195
194
js_set(js, js_glob(js), "__dirname", js_mkundef());
196
195
} else {
197
196
buffer = read_file(filename, &len);
198
197
if (!buffer) {
199
-
fprintf(stderr, "Error: Could not open file '%s'\n", filename);
198
+
cfprintf(stderr, "<red>Error</red>: <bold>Module not found: \"%s\"</>\n", filename);
200
199
return EXIT_FAILURE;
201
200
}
202
201
···
214
213
if (is_typescript_file(filename)) {
215
214
int result = OXC_strip_types(buffer, filename, buffer, len + 1);
216
215
if (result < 0) {
217
-
fprintf(stderr, "TypeScript error: strip failed (%d)\n", result);
216
+
cfprintf(stderr, "<red>Error</red>: <bold>Type stripping failed (%d)</>\n", result);
218
217
free(buffer);
219
218
return EXIT_FAILURE;
220
219
}
···
303
302
304
303
if (help->count > 0) {
305
304
cprintf(
306
-
"{let h=bold, arg=cyan, name='Ant'}"
307
-
"<$h+red>{name}</> is a tiny JavaScript runtime and package manager (%s)<br=2/>"
308
-
"<$h>Usage: {~name} <yellow>[module.js]</yellow> <$arg>[...flags]</><reset/><br/>"
309
-
"<$h><gap=7/>{~name} <<command>><gap=3/><$arg>[...args]</><reset/><br=2/>"
305
+
"{let h=bold, arg=cyan, name='Ant', version='%s'}"
306
+
"<$h+red>{name}</> is a tiny JavaScript runtime and package manager ({version})<br=2/>"
307
+
"<$h>Usage: {~name} <yellow>[module.js]</yellow> <$arg>[...flags]<reset/><br/>"
308
+
"<$h><gap=7/>{~name} <<command>><gap=3/><$arg>[...args]<reset/><br=2/>"
310
309
"If no module file is specified, {name} starts in REPL mode.<br=2/>",
311
310
ANT_VERSION
312
311
);
···
353
352
volatile char stack_base;
354
353
355
354
if (!(js = js_create_dynamic())) {
356
-
cfprintf(stderr, "<bold_red>FATAL</>: Failed to allocate for Ant.\n");
355
+
cfprintf(stderr, "<bold+red>FATAL</bold>: Failed to allocate for Ant.</>\n");
357
356
arg_freetable(argtable, ARGTABLE_COUNT); free(filtered_argv);
358
357
return EXIT_FAILURE;
359
358
}
···
399
398
400
399
jsval_t snapshot_result = ant_load_snapshot(js);
401
400
if (vtype(snapshot_result) == T_ERR) {
402
-
fprintf(stderr, "Warning: Failed to load snapshot: %s\n", js_str(js, snapshot_result));
401
+
cfprintf(stderr, "<yellow>Warning</yellow>: <bold>Failed to load snapshot:</> %s\n", js_str(js, snapshot_result));
403
402
}
404
403
405
404
if (eval->count > 0) {
···
414
413
else if (has_stdin && file->count == 0) {
415
414
size_t len = 0; char *buf = read_stdin(&len);
416
415
if (!buf) {
417
-
fprintf(stderr, "Error: Out of memory\n");
416
+
cfprintf(stderr, "<bold+red>FATAL</bold>: Failed to allocate for Ant.</>\n");
418
417
js_result = EXIT_FAILURE; goto cleanup;
419
418
}
420
419
eval_code(js, buf, len, "[stdin]", print->count > 0); free(buf);
+2
-1
src/utils.c
+2
-1
src/utils.c
···
1
1
#include "utils.h"
2
+
#include "cli/cprintf.h"
2
3
3
4
#include <stdio.h>
4
5
#include <stdbool.h>
···
88
89
void *try_oom(size_t size) {
89
90
void *p = malloc(size);
90
91
if (!p) {
91
-
fputs("Error: out of memory\n", stderr);
92
+
cfprintf(stderr, "<bold+red>FATAL</>: Out of memory\n");
92
93
exit(EXIT_FAILURE);
93
94
} return p;
94
95
}