HomePhorge
Diffusion Ant (type-hints-typescript) Code

ant/src/utils.c
899dad6b8a9etype-hints-typescript

Last Change
Raw File

utils.c
View Options

#include "utils.h"
#include "messages.h"
#include <oxc.h>
#include <errno.h>
#include <stdio.h>
#include <stdbool.h>
#include <sys/stat.h>
#include <crprintf.h>
#ifdef _WIN32
#include <direct.h>
#define ANT_MKDIR(path) _mkdir(path)
#else
#define ANT_MKDIR(path) mkdir(path, 0755)
#endif
const char *const module_resolve_extensions[] = {
".js", ".mjs", ".cjs",
".ts", ".mts", ".cts",
".json", ".node", NULL
};
typedef struct ant_ts_hints_entry {
char *filename;
char *hints;
struct ant_ts_hints_entry *next;
} ant_ts_hints_entry_t;
static ant_ts_hints_entry_t *ant_ts_hints_head = NULL;
void ant_ts_hints_store(const char *filename, const char *hints) {
if (!filename || !filename[0]) return;
for (ant_ts_hints_entry_t *entry = ant_ts_hints_head; entry; entry = entry->next) {
if (strcmp(entry->filename, filename) != 0) continue;
free(entry->hints);
entry->hints = (hints && hints[0]) ? strdup(hints) : NULL;
return;
}
ant_ts_hints_entry_t *entry = calloc(1, sizeof(*entry));
if (!entry) return;
entry->filename = strdup(filename);
entry->hints = (hints && hints[0]) ? strdup(hints) : NULL;
if (!entry->filename) {
free(entry->hints);
free(entry);
return;
}
entry->next = ant_ts_hints_head;
ant_ts_hints_head = entry;
}
const char *ant_ts_hints_find(const char *filename) {
if (!filename || !filename[0]) return NULL;
for (ant_ts_hints_entry_t *entry = ant_ts_hints_head; entry; entry = entry->next) {
if (strcmp(entry->filename, filename) == 0) return entry->hints;
}
return NULL;
}
static const char *ant_home_dir(void) {
#ifdef _WIN32
const char *home = getenv("USERPROFILE");
if (home && home[0]) return home;
#else
const char *home = getenv("HOME");
if (home && home[0]) return home;
#endif
return NULL;
}
static const char *ant_absolute_env(const char *name) {
#ifdef _WIN32
return NULL;
#else
const char *value = getenv(name);
if (!value || value[0] != '/') return NULL;
return value;
#endif
}
static int ant_join_app_path(
char *out, size_t out_size,
const char *base,
const char *app,
const char *suffix
) {
if (!out || out_size == 0 || !base || !base[0] || !app || !app[0]) return -1;
while (suffix && (*suffix == '/' || *suffix == '\\')) suffix++;
int written = 0;
if (suffix && suffix[0]) written = snprintf(out, out_size, "%s/%s/%s", base, app, suffix);
else written = snprintf(out, out_size, "%s/%s", base, app);
return (written < 0 || (size_t)written >= out_size) ? -1 : 0;
}
static int ant_legacy_home_path(char *out, size_t out_size, const char *suffix) {
const char *home = ant_home_dir();
if (!home) return -1;
return ant_join_app_path(out, out_size, home, ".ant", suffix);
}
static bool ant_legacy_home_exists(void) {
char path[4096];
if (ant_legacy_home_path(path, sizeof(path), NULL) != 0) return false;
struct stat st;
return stat(path, &st) == 0;
}
static int ant_xdg_path(
char *out, size_t out_size,
const char *env_name,
const char *home_suffix,
const char *suffix
) {
#ifdef _WIN32
const char *home = ant_home_dir();
if (!home) return -1;
return ant_join_app_path(out, out_size, home, ".ant", suffix);
#else
if (ant_legacy_home_exists()) {
return ant_legacy_home_path(out, out_size, suffix);
}
const char *base = ant_absolute_env(env_name);
if (base) return ant_join_app_path(out, out_size, base, "ant", suffix);
const char *home = ant_home_dir();
if (!home) return -1;
char fallback[4096];
int written = snprintf(fallback, sizeof(fallback), "%s/%s", home, home_suffix);
if (written < 0 || (size_t)written >= sizeof(fallback)) return -1;
return ant_join_app_path(out, out_size, fallback, "ant", suffix);
#endif
}
int ant_mkdir_p(const char *path) {
if (!path || !path[0]) return -1;
char tmp[4096];
size_t len = strlen(path);
if (len >= sizeof(tmp)) return -1;
memcpy(tmp, path, len + 1);
while (
len > 1 && (tmp[len - 1] == '/' ||
tmp[len - 1] == '\\')
) tmp[--len] = '\0';
for (char *p = tmp + 1; *p; p++) {
if (*p != '/' && *p != '\\') continue;
char sep = *p; *p = '\0';
if (ANT_MKDIR(tmp) != 0 && errno != EEXIST) return -1;
*p = sep;
}
if (ANT_MKDIR(tmp) != 0 && errno != EEXIST) return -1;
return 0;
}
int ant_xdg_cache_path(char *out, size_t out_size, const char *suffix) {
return ant_xdg_path(out, out_size, "XDG_CACHE_HOME", ".cache", suffix);
}
int ant_xdg_data_path(char *out, size_t out_size, const char *suffix) {
return ant_xdg_path(out, out_size, "XDG_DATA_HOME", ".local/share", suffix);
}
int ant_xdg_state_path(char *out, size_t out_size, const char *suffix) {
return ant_xdg_path(out, out_size, "XDG_STATE_HOME", ".local/state", suffix);
}
int ant_user_bin_path(char *out, size_t out_size) {
const char *home = ant_home_dir();
if (!home || !out || out_size == 0) return -1;
#ifdef _WIN32
int written = snprintf(out, out_size, "%s/.ant/bin", home);
#else
if (ant_legacy_home_exists()) {
return ant_legacy_home_path(out, out_size, "bin");
}
int written = snprintf(out, out_size, "%s/.local/bin", home);
#endif
return (written < 0 || (size_t)written >= out_size) ? -1 : 0;
}
int hex_digit(char c) {
static const int8_t lookup[256] = {
['0']=0, ['1']=1, ['2']=2, ['3']=3, ['4']=4, ['5']=5, ['6']=6, ['7']=7, ['8']=8, ['9']=9,
['a']=10, ['b']=11, ['c']=12, ['d']=13, ['e']=14, ['f']=15,
['A']=10, ['B']=11, ['C']=12, ['D']=13, ['E']=14, ['F']=15,
};
int8_t val = lookup[(unsigned char)c];
return val ? val : (c == '0' ? 0 : -1);
}
char hex_char(int v) {
return "0123456789abcdef"[v & 0x0f];
}
uint64_t hash_key(const char *key, size_t len) {
uint64_t hash = 14695981039346656037ULL;
size_t i = 0;
for (; i + 8 <= len; i += 8) {
uint64_t word;
memcpy(&word, key + i, 8);
hash ^= word;
hash *= 1099511628211ULL;
}
for (; i < len; i++) {
hash ^= (uint8_t)key[i];
hash *= 1099511628211ULL;
}
return hash;
}
double half_to_double(uint16_t bits16) {
uint32_t sign = ((uint32_t)bits16 & 0x8000u) << 16;
uint32_t exp = ((uint32_t)bits16 >> 10) & 0x1fu;
uint32_t mant = (uint32_t)bits16 & 0x03ffu;
uint32_t bits32 = 0;
float out = 0.0f;
if (exp == 0) {
if (mant == 0) {
bits32 = sign;
} else {
uint32_t exp32 = 113;
while ((mant & 0x0400u) == 0) {
mant <<= 1;
exp32--;
}
mant &= 0x03ffu;
bits32 = sign | (exp32 << 23) | (mant << 13);
}}
else if (exp == 0x1fu) bits32 = sign | 0x7f800000u | (mant << 13);
else bits32 = sign | ((exp + 112u) << 23) | (mant << 13);
memcpy(&out, &bits32, sizeof(out));
return (double)out;
}
uint16_t double_to_half(double value) {
float input = (float)value;
uint32_t bits32 = 0;
uint32_t sign = 0;
uint32_t exp = 0;
uint32_t mant = 0;
int32_t exp16 = 0;
uint16_t out = 0;
memcpy(&bits32, &input, sizeof(bits32));
sign = (bits32 >> 16) & 0x8000u;
exp = (bits32 >> 23) & 0xffu;
mant = bits32 & 0x007fffffu;
if (exp == 0xffu) {
if (mant != 0) return (uint16_t)(sign | 0x7e00u);
return (uint16_t)(sign | 0x7c00u);
}
exp16 = (int32_t)exp - 127 + 15;
if (exp16 >= 0x1f) return (uint16_t)(sign | 0x7c00u);
if (exp16 <= 0) {
if (exp16 < -10) return (uint16_t)sign;
mant |= 0x00800000u;
uint32_t shift = (uint32_t)(14 - exp16);
uint16_t sub = (uint16_t)(mant >> shift);
if ((mant >> (shift - 1)) & 1u) sub++;
return (uint16_t)(sign | sub);
}
out = (uint16_t)(sign | ((uint32_t)exp16 << 10) | (mant >> 13));
if (mant & 0x00001000u) out++;
return out;
}
int is_typescript_file(const char *filename) {
if (filename == NULL) return 0;
size_t len = strlen(filename);
if (len < 3) return 0;
const char *ext = filename + len;
while (ext > filename && *(ext - 1) != '.' && *(ext - 1) != '/') ext--;
if (ext == filename || *(ext - 1) != '.') return 0;
ext--;
return (strcmp(ext, ".ts") == 0 || strcmp(ext, ".mts") == 0 || strcmp(ext, ".cts") == 0);
}
int strip_typescript_inplace(
char **buffer,
size_t len,
const char *filename,
int is_module,
size_t *out_len,
const char **error_detail
) {
if (out_len) *out_len = len;
if (error_detail) *error_detail = NULL;
if (!is_typescript_file(filename)) return 0;
if (!buffer || !*buffer) {
if (error_detail) *error_detail = "null input/output passed";
return OXC_ERR_NULL_INPUT;
}
char *input = *buffer;
char error_buf[256] = {0};
size_t stripped_len = 0;
char *hints = NULL;
size_t hints_len = 0;
int strip_error = OXC_ERR_TRANSFORM_FAILED;
char *stripped = OXC_strip_types_with_hints_owned(
input, filename, is_module,
&stripped_len, &strip_error,
&hints, &hints_len,
error_buf, sizeof(error_buf)
);
if (!stripped) {
if (error_buf[0] != '\0') {
size_t msg_len = strlen(error_buf);
size_t copy_len = msg_len > len ? len : msg_len;
memcpy(input, error_buf, copy_len);
input[copy_len] = '\0';
} else input[0] = '\0';
if (error_detail) {
*error_detail = input[0] != '\0' ? input : "unknown strip error";
}
return strip_error;
}
char *next = realloc(input, stripped_len + 1);
if (!next) {
free(stripped);
if (error_detail) *error_detail = "out of memory while resizing strip output buffer";
return OXC_ERR_OUTPUT_TOO_LARGE;
}
memcpy(next, stripped, stripped_len + 1);
free(stripped);
ant_ts_hints_store(filename, (hints && hints_len > 0) ? hints : NULL);
free(hints);
*buffer = next;
if (out_len) *out_len = stripped_len;
return 0;
}
static bool is_entrypoint_script_extension(const char *ext) {
return
ext &&
strcmp(ext, ".json") != 0 &&
strcmp(ext, ".node") != 0;
}
static bool has_js_extension(const char *filename) {
const char *slash = strrchr(filename, '/');
const char *base = slash ? slash + 1 : filename;
const char *dot = strrchr(base, '.');
if (!dot) return false;
for (const char *const *ext = module_resolve_extensions; *ext; ext++) {
if (!is_entrypoint_script_extension(*ext)) continue;
if (strcmp(dot, *ext) == 0) return true;
}
return false;
}
char *resolve_js_file(const char *filename) {
extern bool esm_is_url(const char *path);
if (!filename) return NULL;
if (esm_is_url(filename)) return strdup(filename);
struct stat st;
if (stat(filename, &st) == 0) {
if (S_ISREG(st.st_mode)) {
const char *slash = strrchr(filename, '/');
const char *base = slash ? slash + 1 : filename;
const char *dot = strrchr(base, '.');
if (dot && !has_js_extension(filename)) return NULL;
return strdup(filename);
}
if (!S_ISDIR(st.st_mode)) return NULL;
size_t len = strlen(filename);
int has_slash = (len > 0 && filename[len - 1] == '/');
for (const char *const *ext = module_resolve_extensions; *ext; ext++) {
if (!is_entrypoint_script_extension(*ext)) continue;
size_t ext_len = strlen(*ext);
char *index_path = try_oom(len + 7 + ext_len + 1);
sprintf(index_path, "%s%sindex%s", filename, has_slash ? "" : "/", *ext);
if (stat(index_path, &st) == 0 && S_ISREG(st.st_mode)) return index_path;
free(index_path);
}
return NULL;
}
if (has_js_extension(filename)) return NULL;
size_t base_len = strlen(filename);
for (const char *const *ext = module_resolve_extensions; *ext; ext++) {
if (!is_entrypoint_script_extension(*ext)) continue;
size_t ext_len = strlen(*ext);
char *test_path = try_oom(base_len + ext_len + 1);
memcpy(test_path, filename, base_len);
memcpy(test_path + base_len, *ext, ext_len + 1);
if (stat(test_path, &st) == 0 && S_ISREG(st.st_mode)) {
return test_path;
} free(test_path);
}
return NULL;
}
char *resolve_typescript_source_fallback(const char *filename) {
if (!filename) return NULL;
const char *mapped_ext = NULL;
size_t trim_len = 0;
size_t len = strlen(filename);
if (len > 3 && strcmp(filename + len - 3, ".js") == 0) {
mapped_ext = ".ts";
trim_len = 3;
} else if (len > 4 && strcmp(filename + len - 4, ".mjs") == 0) {
mapped_ext = ".mts";
trim_len = 4;
} else if (len > 4 && strcmp(filename + len - 4, ".cjs") == 0) {
mapped_ext = ".cts";
trim_len = 4;
} else return NULL;
size_t mapped_len = strlen(mapped_ext);
char *mapped = try_oom(len - trim_len + mapped_len + 1);
memcpy(mapped, filename, len - trim_len);
memcpy(mapped + len - trim_len, mapped_ext, mapped_len + 1);
return mapped;
}
typedef struct {
const char *repl; size_t repl_len; size_t *ri;
const char *matched; size_t matched_len;
const char *str; size_t str_len; size_t position;
const repl_capture_t *caps; int ncaptures;
char **buf; size_t *buf_len; size_t *buf_cap;
} rt_ctx_t;
static bool rt_append(rt_ctx_t *c, const char *data, size_t dlen) {
if (dlen == 0) return true;
if (*c->buf_len > SIZE_MAX - dlen - 1) return false;
if (*c->buf_len + dlen >= *c->buf_cap) {
size_t needed = *c->buf_len + dlen + 1;
size_t new_cap = needed * 2;
if (new_cap < needed) new_cap = needed;
char *next = realloc(*c->buf, new_cap);
if (!next) return false;
*c->buf = next;
*c->buf_cap = new_cap;
}
memcpy(*c->buf + *c->buf_len, data, dlen);
*c->buf_len += dlen;
return true;
}
static bool rt_dollar(rt_ctx_t *c) {
*c->ri += 2;
return rt_append(c, "$", 1);
}
static bool rt_match(rt_ctx_t *c) {
*c->ri += 2;
return rt_append(c, c->matched, c->matched_len);
}
static bool rt_prefix(rt_ctx_t *c) {
*c->ri += 2;
return rt_append(c, c->str, c->position);
}
static bool rt_suffix(rt_ctx_t *c) {
size_t after = c->position + c->matched_len;
bool ok = true;
if (after < c->str_len)
ok = rt_append(c, c->str + after, c->str_len - after);
*c->ri += 2;
return ok;
}
static bool rt_capture(rt_ctx_t *c) {
char nc = c->repl[*c->ri + 1];
int gn = nc - '0';
*c->ri += 2;
if (*c->ri < c->repl_len && c->repl[*c->ri] >= '0' && c->repl[*c->ri] <= '9') {
int two = gn * 10 + (c->repl[*c->ri] - '0');
if (two <= c->ncaptures) { gn = two; (*c->ri)++; }
}
if (gn > 0 && gn <= c->ncaptures && c->caps[gn - 1].ptr)
return rt_append(c, c->caps[gn - 1].ptr, c->caps[gn - 1].len);
if (gn == 0 || gn > c->ncaptures)
return rt_append(c, "$", 1) && rt_append(c, &nc, 1);
return true;
}
typedef bool (*rt_handler_t)(rt_ctx_t *);
static rt_handler_t rt_dispatch[128];
static bool rt_dispatch_init = false;
static void rt_init_dispatch(void) {
if (rt_dispatch_init) return;
rt_dispatch['$'] = rt_dollar;
rt_dispatch['&'] = rt_match;
rt_dispatch['`'] = rt_prefix;
rt_dispatch['\''] = rt_suffix;
for (int i = '0'; i <= '9'; i++) rt_dispatch[i] = rt_capture;
rt_dispatch_init = true;
}
bool repl_template(
const char *repl, size_t repl_len,
const char *matched, size_t matched_len,
const char *str, size_t str_len, size_t position,
const repl_capture_t *caps, int ncaptures,
char **buf, size_t *buf_len, size_t *buf_cap
) {
rt_init_dispatch();
rt_ctx_t c = {
repl, repl_len, NULL,
matched, matched_len,
str, str_len, position,
caps, ncaptures,
buf, buf_len, buf_cap,
};
for (size_t ri = 0; ri < repl_len; ) {
if (repl[ri] == '$' && ri + 1 < repl_len) {
unsigned char nc = (unsigned char)repl[ri + 1];
c.ri = &ri;
rt_handler_t h = nc < 128 ? rt_dispatch[nc] : NULL;
if (h) { if (!h(&c)) return false; continue; }
}
if (!rt_append(&c, &repl[ri], 1)) return false;
ri++;
}
return true;
}
void *try_oom(size_t size) {
void *p = malloc(size);
if (!p) {
crfprintf(stderr, msg.oom_fatal);
exit(EXIT_FAILURE);
} return p;
}
void cstr_free(cstr_buf_t *buf) {
if (buf->heap) free(buf->heap);
}
char *cstr_init(cstr_buf_t *buf, char *stack, size_t stack_size, const char *src, size_t len) {
if (len < stack_size) {
buf->ptr = stack;
buf->heap = NULL;
} else {
buf->heap = malloc(len + 1);
if (!buf->heap) return NULL;
buf->ptr = buf->heap;
}
memcpy(buf->ptr, src, len);
buf->ptr[len] = '\0';
return buf->ptr;
}

Owner Packages

  • No Owners