themackabu.com / ant
MIRROR: javascript for 🐜's, a tiny runtime with big ambitions
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

rewrite esm module to be DRY

theMackabu c290402d 98d39afa

+170 -293
+170 -293
src/ant.c
··· 18915 18915 return result; 18916 18916 } 18917 18917 18918 - static bool esm_is_json(const char *path) { 18918 + static bool esm_has_suffix(const char *path, const char *ext) { 18919 18919 size_t len = strlen(path); 18920 - return len > 5 && strcmp(path + len - 5, ".json") == 0; 18920 + size_t elen = strlen(ext); 18921 + return len > elen && strcmp(path + len - elen, ext) == 0; 18922 + } 18923 + 18924 + static bool esm_is_json(const char *path) { 18925 + return esm_has_suffix(path, ".json"); 18921 18926 } 18922 18927 18923 18928 static bool esm_is_text(const char *path) { 18924 - size_t len = strlen(path); 18925 - return (len > 4 && strcmp(path + len - 4, ".txt") == 0) || 18926 - (len > 3 && strcmp(path + len - 3, ".md") == 0) || 18927 - (len > 5 && strcmp(path + len - 5, ".html") == 0) || 18928 - (len > 4 && strcmp(path + len - 4, ".css") == 0); 18929 + return esm_has_suffix(path, ".txt") || 18930 + esm_has_suffix(path, ".md") || 18931 + esm_has_suffix(path, ".html") || 18932 + esm_has_suffix(path, ".css"); 18929 18933 } 18930 18934 18931 18935 static bool esm_is_image(const char *path) { 18932 - size_t len = strlen(path); 18933 - return (len > 4 && strcmp(path + len - 4, ".png") == 0) || 18934 - (len > 4 && strcmp(path + len - 4, ".jpg") == 0) || 18935 - (len > 5 && strcmp(path + len - 5, ".jpeg") == 0) || 18936 - (len > 4 && strcmp(path + len - 4, ".gif") == 0) || 18937 - (len > 4 && strcmp(path + len - 4, ".svg") == 0) || 18938 - (len > 5 && strcmp(path + len - 5, ".webp") == 0); 18936 + return esm_has_suffix(path, ".png") || 18937 + esm_has_suffix(path, ".jpg") || 18938 + esm_has_suffix(path, ".jpeg") || 18939 + esm_has_suffix(path, ".gif") || 18940 + esm_has_suffix(path, ".svg") || 18941 + esm_has_suffix(path, ".webp"); 18939 18942 } 18940 18943 18941 18944 static char *esm_canonicalize_path(const char *path) { ··· 19035 19038 global_module_cache.count = 0; 19036 19039 } 19037 19040 19038 - static jsval_t esm_load_json(struct js *js, const char *path) { 19041 + typedef struct { 19042 + char *data; 19043 + size_t size; 19044 + } esm_file_data_t; 19045 + 19046 + static jsval_t esm_read_file(struct js *js, const char *path, const char *kind, esm_file_data_t *out) { 19039 19047 FILE *fp = fopen(path, "rb"); 19040 - if (!fp) return js_mkerr(js, "Cannot open JSON file: %s", path); 19048 + if (!fp) return js_mkerr(js, "Cannot open %s: %s", kind, path); 19041 19049 19042 19050 fseek(fp, 0, SEEK_END); 19043 - long size = ftell(fp); 19051 + long fsize = ftell(fp); 19044 19052 fseek(fp, 0, SEEK_SET); 19045 19053 19046 - char *content = (char *)malloc(size + 1); 19047 - if (!content) { 19054 + char *buf = (char *)malloc((size_t)fsize + 1); 19055 + if (!buf) { 19048 19056 fclose(fp); 19049 - return js_mkerr(js, "OOM loading JSON"); 19057 + return js_mkerr(js, "OOM loading %s", kind); 19050 19058 } 19051 19059 19052 - fread(content, 1, size, fp); 19060 + fread(buf, 1, (size_t)fsize, fp); 19053 19061 fclose(fp); 19054 - content[size] = '\0'; 19062 + buf[fsize] = '\0'; 19055 19063 19056 - jsval_t json_str = js_mkstr(js, content, size); 19057 - free(content); 19064 + out->data = buf; 19065 + out->size = (size_t)fsize; 19066 + return js_mkundef(); 19067 + } 19068 + 19069 + static jsval_t esm_load_json(struct js *js, const char *path) { 19070 + esm_file_data_t file; 19071 + jsval_t err = esm_read_file(js, path, "JSON file", &file); 19072 + if (is_err(err)) return err; 19058 19073 19074 + jsval_t json_str = js_mkstr(js, file.data, file.size); 19075 + free(file.data); 19059 19076 return js_json_parse(js, &json_str, 1); 19060 19077 } 19061 19078 19062 19079 static jsval_t esm_load_text(struct js *js, const char *path) { 19063 - FILE *fp = fopen(path, "rb"); 19064 - if (!fp) return js_mkerr(js, "Cannot open text file: %s", path); 19065 - 19066 - fseek(fp, 0, SEEK_END); 19067 - long size = ftell(fp); 19068 - fseek(fp, 0, SEEK_SET); 19069 - 19070 - char *content = (char *)malloc(size + 1); 19071 - if (!content) { 19072 - fclose(fp); 19073 - return js_mkerr(js, "OOM loading text"); 19074 - } 19075 - 19076 - fread(content, 1, size, fp); 19077 - fclose(fp); 19078 - content[size] = '\0'; 19079 - 19080 - jsval_t result = js_mkstr(js, content, size); 19081 - free(content); 19080 + esm_file_data_t file; 19081 + jsval_t err = esm_read_file(js, path, "text file", &file); 19082 + if (is_err(err)) return err; 19082 19083 19084 + jsval_t result = js_mkstr(js, file.data, file.size); 19085 + free(file.data); 19083 19086 return result; 19084 19087 } 19085 19088 19086 19089 static jsval_t esm_load_image(struct js *js, const char *path) { 19087 - FILE *fp = fopen(path, "rb"); 19088 - if (!fp) return js_mkerr(js, "Cannot open image file: %s", path); 19089 - 19090 - fseek(fp, 0, SEEK_END); 19091 - long size = ftell(fp); 19092 - fseek(fp, 0, SEEK_SET); 19093 - 19094 - unsigned char *content = (unsigned char *)malloc(size); 19095 - if (!content) { 19096 - fclose(fp); 19097 - return js_mkerr(js, "OOM loading image"); 19098 - } 19090 + esm_file_data_t file; 19091 + jsval_t err = esm_read_file(js, path, "image file", &file); 19092 + if (is_err(err)) return err; 19099 19093 19100 - fread(content, 1, size, fp); 19101 - fclose(fp); 19094 + unsigned char *content = (unsigned char *)file.data; 19095 + size_t size = file.size; 19102 19096 19103 19097 jsval_t obj = mkobj(js, 0); 19104 19098 jsval_t data_arr = mkarr(js); 19105 19099 19106 - for (long i = 0; i < size; i++) { 19100 + for (size_t i = 0; i < size; i++) { 19107 19101 char idx[16]; 19108 - snprintf(idx, sizeof(idx), "%ld", i); 19102 + snprintf(idx, sizeof(idx), "%zu", i); 19109 19103 setprop(js, data_arr, js_mkstr(js, idx, strlen(idx)), tov((double)content[i])); 19110 19104 } 19111 19105 setprop(js, data_arr, js_mkstr(js, "length", 6), tov((double)size)); ··· 19114 19108 setprop(js, obj, js_mkstr(js, "path", 4), js_mkstr(js, path, strlen(path))); 19115 19109 setprop(js, obj, js_mkstr(js, "size", 4), tov((double)size)); 19116 19110 19117 - free(content); 19111 + free(file.data); 19118 19112 return obj; 19119 19113 } 19120 19114 ··· 19186 19180 mod->url_content_len = size; 19187 19181 } 19188 19182 } else { 19189 - FILE *fp = fopen(mod->resolved_path, "rb"); 19190 - if (!fp) { 19191 - mod->is_loading = false; 19192 - return js_mkerr(js, "Cannot open module: %s", mod->resolved_path); 19193 - } 19194 - 19195 - fseek(fp, 0, SEEK_END); 19196 - long fsize = ftell(fp); 19197 - fseek(fp, 0, SEEK_SET); 19198 - size = (size_t)fsize; 19199 - 19200 - content = (char *)malloc(size + 1); 19201 - if (!content) { 19202 - fclose(fp); 19183 + esm_file_data_t file; 19184 + jsval_t err = esm_read_file(js, mod->resolved_path, "module", &file); 19185 + if (is_err(err)) { 19203 19186 mod->is_loading = false; 19204 - return js_mkerr(js, "OOM loading module"); 19187 + return err; 19205 19188 } 19206 - 19207 - fread(content, 1, size, fp); 19208 - fclose(fp); 19189 + content = file.data; 19190 + size = file.size; 19209 19191 } 19210 19192 content[size] = '\0'; 19211 19193 ··· 19264 19246 return esm_load_module(js, mod); 19265 19247 } 19266 19248 19267 - static jsval_t builtin_import(struct js *js, jsval_t *args, int nargs) { 19268 - if (nargs < 1 || vtype(args[0]) != T_STR) { 19269 - return js_mkerr(js, "import() requires a string specifier"); 19270 - } 19249 + typedef struct { 19250 + const char *import_name; 19251 + size_t import_len; 19252 + const char *local_name; 19253 + size_t local_len; 19254 + } esm_import_binding_t; 19255 + 19256 + static char *esm_jsval_to_cstr(struct js *js, jsval_t str, jsoff_t *out_len) { 19257 + jsoff_t len; 19258 + jsoff_t off = vstr(js, str, &len); 19259 + if (out_len) *out_len = len; 19260 + return strndup((char *)&js->mem[off], len); 19261 + } 19262 + 19263 + static jsval_t esm_resolve_and_load(struct js *js, const char *spec_str, jsoff_t spec_len) { 19264 + ant_library_t *lib = find_library(spec_str, spec_len); 19265 + if (lib) return lib->init_fn(js); 19271 19266 19272 - jsoff_t spec_len; 19273 - jsoff_t spec_off = vstr(js, args[0], &spec_len); 19274 - char *specifier = strndup((char *)&js->mem[spec_off], spec_len); 19267 + const char *base_path = js->filename ? js->filename : "."; 19268 + char *resolved_path = esm_resolve(spec_str, base_path, esm_resolve_path); 19269 + if (!resolved_path) return js_mkerr(js, "Cannot resolve module: %s", spec_str); 19275 19270 19276 - ant_library_t *lib = find_library(specifier, spec_len); 19277 - if (lib) { 19278 - free(specifier); 19279 - jsval_t lib_obj = lib->init_fn(js); 19280 - if (is_err(lib_obj)) return builtin_Promise_reject(js, &lib_obj, 1); 19281 - jsval_t promise_args[] = { lib_obj }; 19282 - return builtin_Promise_resolve(js, promise_args, 1); 19271 + jsval_t ns = esm_get_or_load(js, spec_str, resolved_path); 19272 + free(resolved_path); 19273 + return ns; 19274 + } 19275 + 19276 + static jsval_t esm_make_file_url(struct js *js, const char *path) { 19277 + size_t url_len = strlen(path) + 8; 19278 + char *url = malloc(url_len); 19279 + if (!url) return js_mkerr(js, "oom"); 19280 + 19281 + snprintf(url, url_len, "file://%s", path); 19282 + jsval_t val = js_mkstr(js, url, strlen(url)); 19283 + free(url); 19284 + return val; 19285 + } 19286 + 19287 + static int esm_parse_named_imports(struct js *js, esm_import_binding_t *bindings, int max_bindings) { 19288 + int count = 0; 19289 + 19290 + while (next(js) != TOK_RBRACE && count < max_bindings) { 19291 + EXPECT(TOK_IDENTIFIER, (void)0); 19292 + const char *import_name = &js->code[js->toff]; 19293 + size_t import_len = js->tlen; 19294 + js->consumed = 1; 19295 + 19296 + const char *local_name = import_name; 19297 + size_t local_len = import_len; 19298 + 19299 + if (next(js) == TOK_AS) { 19300 + js->consumed = 1; 19301 + EXPECT(TOK_IDENTIFIER, (void)0); 19302 + local_name = &js->code[js->toff]; 19303 + local_len = js->tlen; 19304 + js->consumed = 1; 19305 + } 19306 + 19307 + bindings[count].import_name = import_name; 19308 + bindings[count].import_len = import_len; 19309 + bindings[count].local_name = local_name; 19310 + bindings[count].local_len = local_len; 19311 + count++; 19312 + 19313 + if (next(js) == TOK_COMMA) js->consumed = 1; 19283 19314 } 19284 19315 19285 - const char *base_path = js->filename ? js->filename : "."; 19286 - char *resolved_path = esm_resolve(specifier, base_path, esm_resolve_path); 19287 - if (!resolved_path) { 19288 - jsval_t err = js_mkerr(js, "Cannot resolve module: %s", specifier); 19289 - free(specifier); 19290 - return err; 19316 + EXPECT(TOK_RBRACE, (void)0); 19317 + return count; 19318 + } 19319 + 19320 + static jsval_t builtin_import(struct js *js, jsval_t *args, int nargs) { 19321 + if (nargs < 1 || vtype(args[0]) != T_STR) { 19322 + return js_mkerr(js, "import() requires a string specifier"); 19291 19323 } 19292 19324 19293 - jsval_t ns = esm_get_or_load(js, specifier, resolved_path); 19294 - free(resolved_path); 19325 + jsoff_t spec_len; 19326 + char *specifier = esm_jsval_to_cstr(js, args[0], &spec_len); 19327 + jsval_t ns = esm_resolve_and_load(js, specifier, spec_len); 19295 19328 free(specifier); 19296 19329 19297 19330 if (is_err(ns)) return builtin_Promise_reject(js, &ns, 1); ··· 19305 19338 return js_mkerr(js, "import.meta.resolve() requires a string specifier"); 19306 19339 } 19307 19340 19308 - jsoff_t spec_len; 19309 - jsoff_t spec_off = vstr(js, args[0], &spec_len); 19310 - char *specifier = strndup((char *)&js->mem[spec_off], spec_len); 19341 + char *specifier = esm_jsval_to_cstr(js, args[0], NULL); 19311 19342 19312 19343 const char *base_path = js->filename ? js->filename : "."; 19313 19344 char *resolved_path = esm_resolve(specifier, base_path, esm_resolve_path); ··· 19322 19353 free(resolved_path); return result; 19323 19354 } 19324 19355 19325 - size_t url_len = strlen(resolved_path) + 8; 19326 - char *url = malloc(url_len); 19327 - if (!url) { 19328 - free(resolved_path); 19329 - return js_mkerr(js, "oom"); 19330 - } 19331 - 19332 - snprintf(url, url_len, "file://%s", resolved_path); 19356 + jsval_t result = esm_make_file_url(js, resolved_path); 19333 19357 free(resolved_path); 19334 - 19335 - jsval_t result = js_mkstr(js, url, strlen(url)); 19336 - free(url); 19337 - 19338 19358 return result; 19339 19359 } 19340 19360 ··· 19343 19363 19344 19364 jsval_t import_meta = mkobj(js, 0); 19345 19365 if (is_err(import_meta)) return; 19346 - 19347 19366 bool is_url = esm_is_url(filename); 19348 19367 19349 - if (is_url) { 19350 - jsval_t url_val = js_mkstr(js, filename, strlen(filename)); 19351 - if (!is_err(url_val)) setprop(js, import_meta, js_mkstr(js, "url", 3), url_val); 19352 - } else { 19353 - size_t url_len = strlen(filename) + 8; 19354 - char *url = malloc(url_len); 19355 - if (url) { 19356 - snprintf(url, url_len, "file://%s", filename); 19357 - jsval_t url_val = js_mkstr(js, url, strlen(url)); 19358 - if (!is_err(url_val)) setprop(js, import_meta, js_mkstr(js, "url", 3), url_val); free(url); 19359 - } 19360 - } 19368 + jsval_t url_val = is_url ? js_mkstr(js, filename, strlen(filename)) : esm_make_file_url(js, filename); 19369 + if (!is_err(url_val)) setprop(js, import_meta, js_mkstr(js, "url", 3), url_val); 19361 19370 19362 19371 jsval_t filename_val = js_mkstr(js, filename, strlen(filename)); 19363 19372 if (!is_err(filename_val)) setprop(js, import_meta, js_mkstr(js, "filename", 8), filename_val); ··· 19431 19440 EXPECT(TOK_STRING, ); 19432 19441 19433 19442 jsval_t spec = js_str_literal(js); 19434 - 19435 19443 jsoff_t spec_len; 19436 - jsoff_t spec_off = vstr(js, spec, &spec_len); 19437 - char *spec_str = strndup((char *)&js->mem[spec_off], spec_len); 19438 - jsval_t ns = js_mkundef(); 19439 - ant_library_t *lib = find_library(spec_str, spec_len); 19440 - if (lib) { 19441 - ns = lib->init_fn(js); 19442 - } else { 19443 - const char *base_path = js->filename ? js->filename : "."; 19444 - char *resolved_path = esm_resolve(spec_str, base_path, esm_resolve_path); 19445 - if (!resolved_path) { 19446 - free(spec_str); 19447 - return js_mkerr(js, "Cannot resolve module: %.*s", (int)spec_len, spec_str); 19448 - } 19449 - 19450 - js_parse_state_t saved; 19451 - JS_SAVE_STATE(js, saved); 19452 - ns = esm_get_or_load(js, spec_str, resolved_path); 19453 - JS_RESTORE_STATE(js, saved); 19454 - 19455 - free(resolved_path); 19456 - } 19444 + char *spec_str = esm_jsval_to_cstr(js, spec, &spec_len); 19445 + 19446 + js_parse_state_t saved; 19447 + JS_SAVE_STATE(js, saved); 19448 + jsval_t ns = esm_resolve_and_load(js, spec_str, spec_len); 19449 + JS_RESTORE_STATE(js, saved); 19457 19450 free(spec_str); 19458 19451 19459 19452 js->consumed = 1; next(js); js->consumed = 0; ··· 19468 19461 size_t default_len = js->tlen; 19469 19462 js->consumed = 1; 19470 19463 19471 - typedef struct { 19472 - const char *import_name; 19473 - size_t import_len; 19474 - const char *local_name; 19475 - size_t local_len; 19476 - } import_binding_t; 19477 - 19478 - import_binding_t bindings[64]; 19464 + esm_import_binding_t bindings[64]; 19479 19465 int binding_count = 0; 19480 19466 19481 19467 if (next(js) == TOK_COMMA) { ··· 19483 19469 19484 19470 if (next(js) == TOK_LBRACE) { 19485 19471 js->consumed = 1; 19486 - 19487 - while (next(js) != TOK_RBRACE && binding_count < 64) { 19488 - EXPECT(TOK_IDENTIFIER, ); 19489 - const char *import_name = &js->code[js->toff]; 19490 - size_t import_len = js->tlen; 19491 - js->consumed = 1; 19492 - 19493 - const char *local_name = import_name; 19494 - size_t local_len = import_len; 19495 - 19496 - if (next(js) == TOK_AS) { 19497 - js->consumed = 1; 19498 - EXPECT(TOK_IDENTIFIER, ); 19499 - local_name = &js->code[js->toff]; 19500 - local_len = js->tlen; 19501 - js->consumed = 1; 19502 - } 19503 - 19504 - bindings[binding_count].import_name = import_name; 19505 - bindings[binding_count].import_len = import_len; 19506 - bindings[binding_count].local_name = local_name; 19507 - bindings[binding_count].local_len = local_len; 19508 - binding_count++; 19509 - 19510 - if (next(js) == TOK_COMMA) js->consumed = 1; 19511 - } 19512 - 19513 - EXPECT(TOK_RBRACE, ); 19472 + binding_count = esm_parse_named_imports(js, bindings, 64); 19473 + if (binding_count < 0) return js_mkerr(js, "Failed to parse named imports"); 19514 19474 } else if (next(js) == TOK_MUL) { 19515 19475 js->consumed = 1; 19516 19476 EXPECT(TOK_AS, ); ··· 19530 19490 EXPECT(TOK_STRING, ); 19531 19491 19532 19492 jsval_t spec = js_str_literal(js); 19533 - 19534 19493 jsoff_t spec_len; 19535 - jsoff_t spec_off = vstr(js, spec, &spec_len); 19536 - char *spec_str = strndup((char *)&js->mem[spec_off], spec_len); 19494 + char *spec_str = esm_jsval_to_cstr(js, spec, &spec_len); 19537 19495 19538 - jsval_t ns = js_mkundef(); 19539 - ant_library_t *lib = find_library(spec_str, spec_len); 19540 - if (lib) { 19541 - ns = lib->init_fn(js); 19542 - } else { 19543 - const char *base_path = js->filename ? js->filename : "."; 19544 - char *resolved_path = esm_resolve(spec_str, base_path, esm_resolve_path); 19545 - if (!resolved_path) { 19546 - free(spec_str); 19547 - return js_mkerr(js, "Cannot resolve module: %s", spec_str); 19548 - } 19549 - 19550 - js_parse_state_t saved; 19551 - JS_SAVE_STATE(js, saved); 19552 - ns = esm_get_or_load(js, spec_str, resolved_path); 19553 - JS_RESTORE_STATE(js, saved); 19554 - 19555 - free(resolved_path); 19556 - } 19496 + js_parse_state_t saved; 19497 + JS_SAVE_STATE(js, saved); 19498 + jsval_t ns = esm_resolve_and_load(js, spec_str, spec_len); 19499 + JS_RESTORE_STATE(js, saved); 19557 19500 free(spec_str); 19558 19501 19559 19502 js->consumed = 1; next(js); js->consumed = 0; ··· 19586 19529 if (next(js) == TOK_LBRACE) { 19587 19530 js->consumed = 1; 19588 19531 19589 - typedef struct { 19590 - const char *import_name; 19591 - size_t import_len; 19592 - const char *local_name; 19593 - size_t local_len; 19594 - } import_binding_t; 19595 - 19596 - import_binding_t bindings[64]; 19597 - int binding_count = 0; 19598 - 19599 - while (next(js) != TOK_RBRACE && binding_count < 64) { 19600 - EXPECT(TOK_IDENTIFIER, ); 19601 - const char *import_name = &js->code[js->toff]; 19602 - size_t import_len = js->tlen; 19603 - js->consumed = 1; 19604 - 19605 - const char *local_name = import_name; 19606 - size_t local_len = import_len; 19607 - 19608 - if (next(js) == TOK_AS) { 19609 - js->consumed = 1; 19610 - EXPECT(TOK_IDENTIFIER, ); 19611 - local_name = &js->code[js->toff]; 19612 - local_len = js->tlen; 19613 - js->consumed = 1; 19614 - } 19615 - 19616 - bindings[binding_count].import_name = import_name; 19617 - bindings[binding_count].import_len = import_len; 19618 - bindings[binding_count].local_name = local_name; 19619 - bindings[binding_count].local_len = local_len; 19620 - binding_count++; 19621 - 19622 - if (next(js) == TOK_COMMA) js->consumed = 1; 19623 - } 19532 + esm_import_binding_t bindings[64]; 19533 + int binding_count = esm_parse_named_imports(js, bindings, 64); 19534 + if (binding_count < 0) return js_mkerr(js, "Failed to parse named imports"); 19624 19535 19625 - EXPECT(TOK_RBRACE, ); 19626 19536 EXPECT(TOK_FROM, ); 19627 19537 EXPECT(TOK_STRING, ); 19628 19538 19629 19539 jsval_t spec = js_str_literal(js); 19630 19540 jsoff_t spec_len; 19541 + char *spec_str = esm_jsval_to_cstr(js, spec, &spec_len); 19631 19542 19632 - jsoff_t spec_off = vstr(js, spec, &spec_len); 19633 - char *spec_str = strndup((char *)&js->mem[spec_off], spec_len); 19543 + js_parse_state_t saved; 19544 + JS_SAVE_STATE(js, saved); 19545 + jsoff_t saved_toff = js->toff, saved_tlen = js->tlen; 19546 + jsval_t saved_scope = js->scope; 19547 + 19548 + jsval_t ns = esm_resolve_and_load(js, spec_str, spec_len); 19634 19549 19635 - jsval_t ns = js_mkundef(); 19636 - ant_library_t *lib = find_library(spec_str, spec_len); 19637 - if (lib) { 19638 - ns = lib->init_fn(js); 19639 - } else { 19640 - const char *base_path = js->filename ? js->filename : "."; 19641 - char *resolved_path = esm_resolve(spec_str, base_path, esm_resolve_path); 19642 - if (!resolved_path) { 19643 - free(spec_str); 19644 - return js_mkerr(js, "Cannot resolve module: %s", spec_str); 19645 - } 19646 - 19647 - js_parse_state_t saved; 19648 - JS_SAVE_STATE(js, saved); 19649 - jsoff_t saved_toff = js->toff, saved_tlen = js->tlen; 19650 - jsval_t saved_scope = js->scope; 19651 - 19652 - ns = esm_get_or_load(js, spec_str, resolved_path); 19653 - 19654 - JS_RESTORE_STATE(js, saved); 19655 - js->toff = saved_toff; 19656 - js->tlen = saved_tlen; 19657 - js->scope = saved_scope; 19658 - 19659 - free(resolved_path); 19660 - } 19550 + JS_RESTORE_STATE(js, saved); 19551 + js->toff = saved_toff; 19552 + js->tlen = saved_tlen; 19553 + js->scope = saved_scope; 19661 19554 free(spec_str); 19662 19555 19663 19556 js->consumed = 1; ··· 19775 19668 19776 19669 jsval_t spec = js_str_literal(js); 19777 19670 jsoff_t spec_len; 19778 - jsoff_t spec_off = vstr(js, spec, &spec_len); 19779 - char *spec_str = strndup((char *)&js->mem[spec_off], spec_len); 19671 + char *spec_str = esm_jsval_to_cstr(js, spec, &spec_len); 19780 19672 19781 - jsval_t ns = js_mkundef(); 19782 - ant_library_t *lib = find_library(spec_str, spec_len); 19783 - if (lib) { 19784 - ns = lib->init_fn(js); 19785 - } else { 19786 - const char *base_path = js->filename ? js->filename : "."; 19787 - char *resolved_path = esm_resolve(spec_str, base_path, esm_resolve_path); 19788 - if (!resolved_path) { 19789 - free(spec_str); 19790 - return js_mkerr(js, "Cannot resolve module: %s", spec_str); 19791 - } 19792 - 19793 - js_parse_state_t saved; 19794 - JS_SAVE_STATE(js, saved); 19795 - ns = esm_get_or_load(js, spec_str, resolved_path); 19796 - JS_RESTORE_STATE(js, saved); 19797 - 19798 - free(resolved_path); 19799 - } 19673 + js_parse_state_t saved; 19674 + JS_SAVE_STATE(js, saved); 19675 + jsval_t ns = esm_resolve_and_load(js, spec_str, spec_len); 19676 + JS_RESTORE_STATE(js, saved); 19800 19677 free(spec_str); 19801 19678 19802 19679 js->consumed = 1; next(js); js->consumed = 0;