MIRROR: javascript for 🐜's, a tiny runtime with big ambitions
chore: refactor to use consistent `{type}` syntax
+85
-45
+1
include/cli/cprintf.h
+1
include/cli/cprintf.h
+69
-34
src/cli/cprintf.c
+69
-34
src/cli/cprintf.c
···
139
139
int count;
140
140
} var_table_t;
141
141
142
+
static var_table_t global_vars = {0};
143
+
static const char *scan_var_brace(program_t *p, const char *ptr, const char **lit, var_table_t *vars);
144
+
142
145
struct program_t {
143
146
instruction_t *code;
144
147
size_t code_len;
···
404
407
return 1;
405
408
}
406
409
410
+
void cprintf_var(const char *name, const char *value) {
411
+
if (global_vars.count >= MAX_VARS) return;
412
+
int nlen = (int)strlen(name);
413
+
int vlen = (int)strlen(value);
414
+
if (nlen <= 0 || nlen >= MAX_VAR_NAME || vlen <= 0 || vlen >= MAX_VAR_VALUE) return;
415
+
416
+
for (int i = 0; i < global_vars.count; i++) {
417
+
cprintf_var_t *v = &global_vars.vars[i];
418
+
if (v->nlen == nlen && memcmp(v->name, name, nlen) == 0) {
419
+
memcpy(v->value, value, vlen);
420
+
v->value[vlen] = '\0'; v->vlen = vlen; return;
421
+
}
422
+
}
423
+
424
+
cprintf_var_t *v = &global_vars.vars[global_vars.count++];
425
+
memcpy(v->name, name, nlen);
426
+
v->name[nlen] = '\0'; v->nlen = nlen;
427
+
428
+
memcpy(v->value, value, vlen);
429
+
v->value[vlen] = '\0'; v->vlen = vlen;
430
+
}
431
+
407
432
static int compile_var_ref(program_t *p, var_table_t *vars, const char *tag, int len) {
408
433
const char *name = tag + 1;
409
434
int nlen = len - 1;
···
650
675
);
651
676
}
652
677
678
+
static const char *scan_let_brace(program_t *p, const char *ptr, const char **lit, var_table_t *vars) {
679
+
flush_lit(p, *lit, ptr);
680
+
681
+
const char *body = ptr + 5;
682
+
const char *end = body;
683
+
while (*end && *end != '}') end++;
684
+
685
+
if (*end == '}' && compile_let(vars, body, (int)(end - body))) {
686
+
*lit = end + 1;
687
+
return *lit;
688
+
}
689
+
690
+
uint32_t off = add_literal(p, "{", 1);
691
+
emit_op(p, OP_EMIT_LIT, off);
692
+
*lit = ptr + 1;
693
+
return *lit;
694
+
}
695
+
696
+
static void compile_fragment(program_t *p, const char *fmt, var_table_t *vars) {
697
+
const char *ptr = fmt;
698
+
const char *lit = ptr;
699
+
700
+
while (*ptr) {
701
+
if (*ptr == '<' && ptr[1] == '<') ptr = scan_escape(p, ptr, &lit, "<", 1);
702
+
else if (*ptr == '>' && ptr[1] == '>') ptr = scan_escape(p, ptr, &lit, ">", 1);
703
+
else if (*ptr == '%' && ptr[1] == '%') ptr = scan_escape(p, ptr, &lit, "%%", 2);
704
+
else if (*ptr == '{' && memcmp(ptr, "{let ", 5) == 0) ptr = scan_let_brace(p, ptr, &lit, vars);
705
+
else if (*ptr == '{') ptr = scan_var_brace(p, ptr, &lit, vars);
706
+
else if (*ptr == '<') ptr = scan_tag(p, ptr, &lit, vars);
707
+
else if (*ptr == '%' && ptr[1] && ptr[1] != '%') ptr = scan_fmt(p, ptr, &lit);
708
+
else ptr++;
709
+
}
710
+
711
+
flush_lit(p, lit, ptr);
712
+
}
713
+
653
714
static const char *scan_var_brace(program_t *p, const char *ptr, const char **lit, var_table_t *vars) {
654
715
flush_lit(p, *lit, ptr);
655
716
···
677
738
val = buf;
678
739
}
679
740
680
-
if (v->is_fmt) {
741
+
if (memchr(val, '<', vlen)) {
742
+
char tmp[MAX_VAR_VALUE + 1];
743
+
memcpy(tmp, val, vlen);
744
+
tmp[vlen] = '\0';
745
+
compile_fragment(p, tmp, vars);
746
+
} else if (v->is_fmt) {
681
747
arg_class_t cls = classify_arg(val, vlen);
682
748
uint32_t off = add_literal(p, val, vlen);
683
749
emit_op(p, OP_EMIT_FMT, off | ((uint32_t)cls << 28));
···
697
763
return *lit;
698
764
}
699
765
700
-
static const char *scan_let_brace(program_t *p, const char *ptr, const char **lit, var_table_t *vars) {
701
-
flush_lit(p, *lit, ptr);
702
-
703
-
const char *body = ptr + 5;
704
-
const char *end = body;
705
-
while (*end && *end != '}') end++;
706
-
707
-
if (*end == '}' && compile_let(vars, body, (int)(end - body))) {
708
-
*lit = end + 1;
709
-
return *lit;
710
-
}
711
-
712
-
uint32_t off = add_literal(p, "{", 1);
713
-
emit_op(p, OP_EMIT_LIT, off);
714
-
*lit = ptr + 1;
715
-
return *lit;
716
-
}
717
-
718
766
program_t *cprintf_compile(const char *fmt) {
719
767
program_t *p = program_new();
720
-
var_table_t vars = {0};
721
-
const char *ptr = fmt;
722
-
const char *lit = ptr;
768
+
var_table_t vars = global_vars;
723
769
724
-
while (*ptr) {
725
-
if (*ptr == '<' && ptr[1] == '<') ptr = scan_escape(p, ptr, &lit, "<", 1);
726
-
else if (*ptr == '>' && ptr[1] == '>') ptr = scan_escape(p, ptr, &lit, ">", 1);
727
-
else if (*ptr == '%' && ptr[1] == '%') ptr = scan_escape(p, ptr, &lit, "%%", 2);
728
-
else if (*ptr == '{' && memcmp(ptr, "{let ", 5) == 0) ptr = scan_let_brace(p, ptr, &lit, &vars);
729
-
else if (*ptr == '{') ptr = scan_var_brace(p, ptr, &lit, &vars);
730
-
else if (*ptr == '<') ptr = scan_tag(p, ptr, &lit, &vars);
731
-
else if (*ptr == '%' && ptr[1] && ptr[1] != '%') ptr = scan_fmt(p, ptr, &lit);
732
-
else ptr++;
733
-
}
734
-
735
-
flush_lit(p, lit, ptr);
770
+
compile_fragment(p, fmt, &vars);
736
771
emit_op(p, OP_HALT, 0);
737
772
return p;
738
773
}
+14
-10
src/main.c
+14
-10
src/main.c
···
87
87
if (strcmp(mode, "hex") == 0 || strcmp(mode, "all") == 0) cprintf_debug_hex = true;
88
88
}
89
89
90
-
else cfprintf(stderr, "<yellow>Warning</yellow>: <bold>Unknown ANT_DEBUG flag: \"%s\"</>\n", flag);
90
+
else cfprintf(stderr, "{warn}: <bold>Unknown ANT_DEBUG flag: \"%s\"</>\n", flag);
91
91
}
92
92
93
93
static const subcommand_t *find_subcommand(const char *name) {
···
187
187
buffer = esm_fetch_url(filename, &len, &error);
188
188
189
189
if (!buffer) {
190
-
cfprintf(stderr, "<red>Error</red>: <bold>Could not fetch \"%s\"</>: %s\n", filename, error ? error : "unknown error");
190
+
cfprintf(stderr, "{error}: <bold>Could not fetch \"%s\"</>: %s\n", filename, error ? error : "unknown error");
191
191
free(error); return EXIT_FAILURE;
192
192
}
193
193
···
195
195
} else {
196
196
buffer = read_file(filename, &len);
197
197
if (!buffer) {
198
-
cfprintf(stderr, "<red>Error</red>: <bold>Module not found: \"%s\"</>\n", filename);
198
+
cfprintf(stderr, "{error}: <bold>Module not found: \"%s\"</>\n", filename);
199
199
return EXIT_FAILURE;
200
200
}
201
201
···
213
213
if (is_typescript_file(filename)) {
214
214
int result = OXC_strip_types(buffer, filename, buffer, len + 1);
215
215
if (result < 0) {
216
-
cfprintf(stderr, "<red>Error</red>: <bold>Type stripping failed (%d)</>\n", result);
216
+
cfprintf(stderr, "{error}: <bold>Type stripping failed (%d)</>\n", result);
217
217
free(buffer);
218
218
return EXIT_FAILURE;
219
219
}
···
243
243
const char *binary_name = strrchr(argv[0], '/');
244
244
binary_name = binary_name ? binary_name + 1 : argv[0];
245
245
246
+
cprintf_var("version", ANT_VERSION);
247
+
cprintf_var("fatal", "<bold+red>FATAL</bold>");
248
+
cprintf_var("error", "<red>Error</red>");
249
+
cprintf_var("warn", "<yellow>Warning</yellow>");
250
+
246
251
if (strcmp(binary_name, "antx") == 0) {
247
252
char **exec_argv = try_oom(sizeof(char*) * (argc + 2));
248
253
exec_argv[0] = argv[0]; exec_argv[1] = "x";
···
302
307
303
308
if (help->count > 0) {
304
309
cprintf(
305
-
"{let h=bold, arg=cyan, name='Ant', version='%s'}"
310
+
"{let h=bold, arg=cyan, name='Ant'}"
306
311
"<$h+red>{name}</> is a tiny JavaScript runtime and package manager ({version})<br=2/>"
307
312
"<$h>Usage: {~name} <yellow>[module.js]</yellow> <$arg>[...flags]<reset/><br/>"
308
313
"<$h><gap=7/>{~name} <<command>><gap=3/><$arg>[...args]<reset/><br=2/>"
309
-
"If no module file is specified, {name} starts in REPL mode.<br=2/>",
310
-
ANT_VERSION
314
+
"If no module file is specified, {name} starts in REPL mode.<br=2/>"
311
315
);
312
316
313
317
print_subcommands();
···
352
356
volatile char stack_base;
353
357
354
358
if (!(js = js_create_dynamic())) {
355
-
cfprintf(stderr, "<bold+red>FATAL</bold>: Failed to allocate for Ant.</>\n");
359
+
cfprintf(stderr, "{fatal}: Failed to allocate for Ant.</>\n");
356
360
arg_freetable(argtable, ARGTABLE_COUNT); free(filtered_argv);
357
361
return EXIT_FAILURE;
358
362
}
···
398
402
399
403
jsval_t snapshot_result = ant_load_snapshot(js);
400
404
if (vtype(snapshot_result) == T_ERR) {
401
-
cfprintf(stderr, "<yellow>Warning</yellow>: <bold>Failed to load snapshot:</> %s\n", js_str(js, snapshot_result));
405
+
cfprintf(stderr, "{warn} <bold>Failed to load snapshot:</> %s\n", js_str(js, snapshot_result));
402
406
}
403
407
404
408
if (eval->count > 0) {
···
413
417
else if (has_stdin && file->count == 0) {
414
418
size_t len = 0; char *buf = read_stdin(&len);
415
419
if (!buf) {
416
-
cfprintf(stderr, "<bold+red>FATAL</bold>: Failed to allocate for Ant.</>\n");
420
+
cfprintf(stderr, "{fatal}: Failed to allocate for Ant.</>\n");
417
421
js_result = EXIT_FAILURE; goto cleanup;
418
422
}
419
423
eval_code(js, buf, len, "[stdin]", print->count > 0); free(buf);