HomePhorge
Diffusion Ant (mir/inline-method) Code

ant/src/modules/path.c
3fa05edd2fe3mir/inline-method

Last Change
Raw File

path.c
View Options

#include <compat.h> // IWYU pragma: keep
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "ant.h"
#include "errors.h"
#include "internal.h"
#include "modules/symbol.h"
#ifndef PATH_MAX
#define PATH_MAX 4096
#endif
#ifdef _WIN32
#define PATH_SEP '\\'
#define PATH_SEP_STR "\\"
#define PATH_DELIMITER ';'
#else
#define PATH_SEP '/'
#define PATH_SEP_STR "/"
#define PATH_DELIMITER ':'
#endif
typedef enum {
PATH_STYLE_POSIX = 1,
PATH_STYLE_WIN32 = 2,
} path_style_t;
static path_style_t path_host_style(void) {
#ifdef _WIN32
return PATH_STYLE_WIN32;
#else
return PATH_STYLE_POSIX;
#endif
}
static path_style_t path_current_style(ant_t *js) {
ant_value_t data = js_get_slot(js->current_func, SLOT_DATA);
if (vtype(data) == T_NUM) {
int style = (int)js_getnum(data);
if (style == PATH_STYLE_WIN32) return PATH_STYLE_WIN32;
if (style == PATH_STYLE_POSIX) return PATH_STYLE_POSIX;
}
return path_host_style();
}
static bool path_style_is_windows(path_style_t style) {
return style == PATH_STYLE_WIN32;
}
static bool path_is_sep(path_style_t style, char ch) {
if (style == PATH_STYLE_WIN32) return ch == '\\' || ch == '/';
return ch == '/';
}
static char path_sep_char(path_style_t style) {
return style == PATH_STYLE_WIN32 ? '\\' : '/';
}
static const char *path_sep_str(path_style_t style) {
return style == PATH_STYLE_WIN32 ? "\\" : "/";
}
static const char *path_delimiter_str(path_style_t style) {
return style == PATH_STYLE_WIN32 ? ";" : ":";
}
static bool path_has_drive_letter(const char *path, size_t len) {
return len >= 2 && isalpha((unsigned char)path[0]) && path[1] == ':';
}
static bool path_is_absolute_style(path_style_t style, const char *path, size_t len) {
if (!path || len == 0) return false;
if (style == PATH_STYLE_WIN32) {
if (path_is_sep(style, path[0])) return true;
return len >= 3 && path_has_drive_letter(path, len) && path_is_sep(style, path[2]);
}
return path[0] == '/';
}
static char *path_normalize_separators(path_style_t style, const char *path, size_t len) {
char *result = malloc(len + 1);
if (!result) return NULL;
for (size_t i = 0; i < len; i++) {
if (style == PATH_STYLE_WIN32 && (path[i] == '\\' || path[i] == '/'))
result[i] = '\\';
else result[i] = path[i];
}
result[len] = '\0';
return result;
}
static size_t path_root_length(path_style_t style, const char *path, size_t len) {
if (!path || len == 0) return 0;
if (style != PATH_STYLE_WIN32) return path[0] == '/' ? 1 : 0;
if (len >= 2 && path_is_sep(style, path[0]) && path_is_sep(style, path[1])) {
size_t i = 2;
int parts = 0;
while (i < len) {
while (i < len && path_is_sep(style, path[i])) i++;
size_t start = i;
while (i < len && !path_is_sep(style, path[i])) i++;
if (i == start) continue;
parts++;
if (parts == 2) {
while (i < len && path_is_sep(style, path[i])) i++;
return i;
}}
return 2;
}
if (path_has_drive_letter(path, len))
return (len >= 3 && path_is_sep(style, path[2])) ? 3 : 2;
return path_is_sep(style, path[0]) ? 1 : 0;
}
static bool path_is_drive_relative(path_style_t style, const char *path, size_t len) {
return style == PATH_STYLE_WIN32 && path_has_drive_letter(path, len) && !(len >= 3 && path_is_sep(style, path[2]));
}
typedef struct {
char *from_norm;
char *to_norm;
char **from_segs;
char **to_segs;
size_t *from_lens;
size_t *to_lens;
int from_count;
int to_count;
size_t from_root_len;
size_t to_root_len;
int common;
char *result;
size_t result_cap;
size_t pos;
} path_relative_ctx_t;
static size_t path_trimmed_end(path_style_t style, const char *path, size_t len) {
size_t root_len = path_root_length(style, path, len);
while (len > root_len && path_is_sep(style, path[len - 1])) len--;
return len;
}
static size_t path_basename_start(path_style_t style, const char *path, size_t len) {
size_t root_len = path_root_length(style, path, len);
size_t end = path_trimmed_end(style, path, len);
size_t start = end;
while (start > root_len && !path_is_sep(style, path[start - 1])) start--;
return start;
}
static ant_value_t path_make_string(ant_t *js, const char *src, size_t len) {
return js_mkstr(js, src, len);
}
static ant_value_t builtin_path_basename(ant_t *js, ant_value_t *args, int nargs) {
path_style_t style = path_current_style(js);
if (nargs < 1) return js_mkerr(js, "basename() requires a path argument");
if (vtype(args[0]) != T_STR) return js_mkerr(js, "basename() path must be a string");
size_t path_len;
char *path = js_getstr(js, args[0], &path_len);
if (!path || path_len == 0) return js_mkstr(js, "", 0);
size_t end = path_trimmed_end(style, path, path_len);
size_t start = path_basename_start(style, path, path_len);
const char *base = path + start;
size_t base_len = end > start ? end - start : 0;
if (nargs >= 2 && vtype(args[1]) == T_STR) {
size_t ext_len;
char *ext = js_getstr(js, args[1], &ext_len);
if (ext && ext_len > 0 && base_len >= ext_len) {
if (memcmp(base + base_len - ext_len, ext, ext_len) == 0) base_len -= ext_len;
}
}
return path_make_string(js, base, base_len);
}
// path.dirname(path)
static ant_value_t builtin_path_dirname(ant_t *js, ant_value_t *args, int nargs) {
path_style_t style = path_current_style(js);
if (nargs < 1) return js_mkerr(js, "dirname() requires a path argument");
if (vtype(args[0]) != T_STR) return js_mkerr(js, "dirname() path must be a string");
size_t path_len;
char *path = js_getstr(js, args[0], &path_len);
if (!path || path_len == 0) return js_mkstr(js, ".", 1);
char *normalized = path_normalize_separators(style, path, path_len);
size_t root_len = 0;
size_t end = 0;
size_t cut = 0;
if (!normalized) return js_mkerr(js, "Out of memory");
root_len = path_root_length(style, normalized, path_len);
end = path_trimmed_end(style, normalized, path_len);
cut = end;
while (cut > root_len && !path_is_sep(style, normalized[cut - 1])) cut--;
while (cut > root_len && path_is_sep(style, normalized[cut - 1])) cut--;
if (cut == 0) {
free(normalized);
return js_mkstr(js, ".", 1);
}
if (cut < root_len) cut = root_len;
ant_value_t result = path_make_string(js, normalized, cut);
free(normalized);
return result;
}
// path.extname(path)
static ant_value_t builtin_path_extname(ant_t *js, ant_value_t *args, int nargs) {
path_style_t style = path_current_style(js);
if (nargs < 1) return js_mkerr(js, "extname() requires a path argument");
if (vtype(args[0]) != T_STR) return js_mkerr(js, "extname() path must be a string");
size_t path_len;
char *path = js_getstr(js, args[0], &path_len);
if (!path || path_len == 0) return js_mkstr(js, "", 0);
size_t start = path_basename_start(style, path, path_len);
size_t end = path_trimmed_end(style, path, path_len);
const char *base = path + start;
size_t base_len = end > start ? end - start : 0;
for (size_t i = base_len; i > 0; i--) {
if (base[i - 1] != '.') continue;
if (i - 1 == 0) break;
return path_make_string(js, base + i - 1, base_len - (i - 1));
}
return js_mkstr(js, "", 0);
}
static int is_dotdot(const char *seg, size_t len) {
return len == 2 && seg[0] == '.' && seg[1] == '.';
}
static char* normalize_path_full(path_style_t style, const char *path, size_t path_len) {
char *normalized = NULL;
char **segments = NULL;
size_t *seg_lens = NULL;
char *result = NULL;
char sep = path_sep_char(style);
size_t root_len = 0;
bool drive_relative = false;
if (path_len == 0) return strdup(".");
normalized = path_normalize_separators(style, path, path_len);
if (!normalized) goto fail;
segments = malloc(path_len * sizeof(char*));
seg_lens = malloc(path_len * sizeof(size_t));
if (!segments || !seg_lens) goto fail;
root_len = path_root_length(style, normalized, path_len);
drive_relative = path_is_drive_relative(style, normalized, path_len);
int seg_count = 0;
char *start = normalized + root_len;
char *seg_start = start;
for (char *p = start; ; p++) {
if (!path_is_sep(style, *p) && *p != '\0') continue;
size_t len = p - seg_start;
if (len == 0 || (len == 1 && seg_start[0] == '.')) goto next;
if (is_dotdot(seg_start, len)) {
if (seg_count > 0 && !is_dotdot(segments[seg_count - 1], seg_lens[seg_count - 1])) seg_count--;
else if (root_len == 0 || drive_relative) goto add_segment;
goto next;
}
add_segment:
segments[seg_count] = seg_start;
seg_lens[seg_count] = len;
seg_count++;
next:
if (*p == '\0') break;
seg_start = p + 1;
}
size_t result_len = root_len;
for (int i = 0; i < seg_count; i++) {
result_len += seg_lens[i];
if (i < seg_count - 1) result_len++;
}
if (result_len == 0) result_len = 1;
result = malloc(result_len + 1);
if (!result) goto fail;
size_t pos = 0;
if (root_len > 0) {
memcpy(result + pos, normalized, root_len);
pos += root_len;
}
for (int i = 0; i < seg_count; i++) {
if (pos > 0 && result[pos - 1] != sep && !(drive_relative && pos == root_len))
result[pos++] = sep;
memcpy(result + pos, segments[i], seg_lens[i]);
pos += seg_lens[i];
}
if (pos == 0) result[pos++] = '.';
if (path_len > root_len && path_is_sep(style, path[path_len - 1])
&& pos > 0 && !path_is_sep(style, result[pos - 1])) {
result = realloc(result, pos + 2);
if (!result) goto fail;
result[pos++] = sep;
}
result[pos] = '\0';
free(segments);
free(seg_lens);
free(normalized);
return result;
fail:
free(segments);
free(seg_lens);
free(normalized);
return NULL;
}
// path.normalize(path)
static ant_value_t builtin_path_normalize(ant_t *js, ant_value_t *args, int nargs) {
path_style_t style = path_current_style(js);
if (nargs < 1) return js_mkerr(js, "normalize() requires a path argument");
if (vtype(args[0]) != T_STR) return js_mkerr(js, "normalize() path must be a string");
size_t path_len;
char *path = js_getstr(js, args[0], &path_len);
if (!path || path_len == 0) return js_mkstr(js, ".", 1);
char *result = normalize_path_full(style, path, path_len);
if (!result) return js_mkerr(js, "Out of memory");
ant_value_t ret = js_mkstr(js, result, strlen(result));
free(result);
return ret;
}
// path.join(...paths)
static ant_value_t builtin_path_join(ant_t *js, ant_value_t *args, int nargs) {
path_style_t style = path_current_style(js);
char sep = path_sep_char(style);
if (nargs < 1) return js_mkstr(js, ".", 1);
size_t total_len = 0;
char **segments = malloc(nargs * sizeof(char*));
size_t *lengths = malloc(nargs * sizeof(size_t));
if (!segments || !lengths) {
free(segments);
free(lengths);
return js_mkerr(js, "Out of memory");
}
int valid_segments = 0;
for (int i = 0; i < nargs; i++) {
if (vtype(args[i]) == T_STR) {
segments[valid_segments] = js_getstr(js, args[i], &lengths[valid_segments]);
if (segments[valid_segments] && lengths[valid_segments] > 0) {
total_len += lengths[valid_segments] + 1; // +1 for separator
valid_segments++;
}}}
if (valid_segments == 0) {
free(segments);
free(lengths);
return js_mkstr(js, ".", 1);
}
char *result = malloc(total_len + 1);
if (!result) {
free(segments);
free(lengths);
return js_mkerr(js, "Out of memory");
}
size_t pos = 0;
for (int i = 0; i < valid_segments; i++) {
if (i > 0 && pos > 0 && result[pos - 1] != sep) {
result[pos++] = sep;
}
size_t start = 0;
if (i > 0 && path_is_sep(style, segments[i][0])) start = 1;
size_t seg_len = lengths[i];
while (seg_len > start + 1 && path_is_sep(style, segments[i][seg_len - 1])) seg_len--;
if (seg_len > start) {
memcpy(result + pos, segments[i] + start, seg_len - start);
pos += seg_len - start;
}
}
if (
valid_segments > 0 && lengths[valid_segments - 1] > 0
&& path_is_sep(style, segments[valid_segments - 1][lengths[valid_segments - 1] - 1])
&& pos > 0 && !path_is_sep(style, result[pos - 1])
) result[pos++] = sep;
result[pos] = '\0';
char *normalized = normalize_path_full(style, result, pos);
free(result);
free(segments);
free(lengths);
if (!normalized) return js_mkerr(js, "Out of memory");
ant_value_t ret = js_mkstr(js, normalized, strlen(normalized));
free(normalized);
return ret;
}
// path.resolve(...paths)
static ant_value_t builtin_path_resolve(ant_t *js, ant_value_t *args, int nargs) {
path_style_t style = path_current_style(js);
char cwd[PATH_MAX];
char *cwd_norm = NULL;
char *joined = NULL;
char *normalized = NULL;
char drive_prefix[3] = {0};
bool saw_absolute = false;
char sep = path_sep_char(style);
if (getcwd(cwd, sizeof(cwd)) == NULL)
return js_mkerr(js, "Failed to get current working directory");
cwd_norm = path_normalize_separators(style, cwd, strlen(cwd));
if (!cwd_norm) return js_mkerr(js, "Out of memory");
for (int i = nargs - 1; i >= 0; i--) {
char *next = NULL;
size_t seg_len = 0;
size_t joined_len = 0;
size_t next_len = 0;
char *segment = NULL;
size_t prefix_len = 0;
if (vtype(args[i]) != T_STR) continue;
segment = js_getstr(js, args[i], &seg_len);
if (!segment || seg_len == 0) continue;
if (style == PATH_STYLE_WIN32 && path_is_drive_relative(style, segment, seg_len)) {
if (drive_prefix[0] == '\0') {
drive_prefix[0] = segment[0];
drive_prefix[1] = ':';
drive_prefix[2] = '\0';
}
prefix_len = 2;
}
if (!joined) {
joined = strndup(segment + prefix_len, seg_len - prefix_len);
if (!joined) {
free(cwd_norm);
return js_mkerr(js, "Out of memory");
}
} else {
joined_len = strlen(joined);
next_len = (seg_len - prefix_len) + 1 + joined_len + 1;
next = malloc(next_len);
if (!next) {
free(cwd_norm);
free(joined);
return js_mkerr(js, "Out of memory");
}
snprintf(next, next_len, "%.*s%c%s", (int)(seg_len - prefix_len), segment + prefix_len, sep, joined);
free(joined);
joined = next;
}
if (path_is_absolute_style(style, segment, seg_len)) {
saw_absolute = true;
break;
}
}
if (!joined) {
if (style == PATH_STYLE_WIN32 && drive_prefix[0] != '\0') {
size_t cwd_len = strlen(cwd_norm);
joined = malloc(2 + cwd_len + 1);
if (!joined) {
free(cwd_norm);
return js_mkerr(js, "Out of memory");
}
snprintf(joined, 2 + cwd_len + 1, "%s%s", drive_prefix, cwd_norm);
} else {
joined = strdup(cwd_norm);
if (!joined) {
free(cwd_norm);
return js_mkerr(js, "Out of memory");
}
}
} else if (!saw_absolute) {
size_t cwd_len = strlen(cwd_norm);
size_t joined_len = strlen(joined);
size_t prefix_len = (style == PATH_STYLE_WIN32 && drive_prefix[0] != '\0') ? 2 : 0;
char *next = malloc(prefix_len + cwd_len + 1 + joined_len + 1);
if (!next) {
free(cwd_norm);
free(joined);
return js_mkerr(js, "Out of memory");
}
if (prefix_len > 0)
snprintf(next, prefix_len + cwd_len + 1 + joined_len + 1, "%s%s%c%s", drive_prefix, cwd_norm, sep, joined);
else snprintf(next, prefix_len + cwd_len + 1 + joined_len + 1, "%s%c%s", cwd_norm, sep, joined);
free(joined);
joined = next;
}
normalized = normalize_path_full(style, joined, strlen(joined));
free(cwd_norm);
free(joined);
if (!normalized) return js_mkerr(js, "Out of memory");
ant_value_t ret = js_mkstr(js, normalized, strlen(normalized));
free(normalized);
return ret;
}
// path.relative(from, to)
static ant_value_t builtin_path_relative(ant_t *js, ant_value_t *args, int nargs) {
path_style_t style = path_current_style(js);
path_relative_ctx_t rel = {0};
char sep = path_sep_char(style);
if (nargs < 2) return js_mkerr(js, "relative() requires from and to arguments");
if (vtype(args[0]) != T_STR) return js_mkerr(js, "relative() from must be a string");
if (vtype(args[1]) != T_STR) return js_mkerr(js, "relative() to must be a string");
size_t from_len, to_len;
char *from = js_getstr(js, args[0], &from_len);
char *to = js_getstr(js, args[1], &to_len);
if (!from || !to) return js_mkerr(js, "Failed to get arguments");
if (from_len == to_len && strncmp(from, to, from_len) == 0) return js_mkstr(js, "", 0);
rel.from_norm = normalize_path_full(style, from, from_len);
rel.to_norm = normalize_path_full(style, to, to_len);
if (!rel.from_norm || !rel.to_norm) goto relative_fail;
rel.from_root_len = path_root_length(style, rel.from_norm, strlen(rel.from_norm));
rel.to_root_len = path_root_length(style, rel.to_norm, strlen(rel.to_norm));
if (style == PATH_STYLE_WIN32) {
if (rel.from_root_len != rel.to_root_len || strncasecmp(rel.from_norm, rel.to_norm, rel.from_root_len) != 0) {
ant_value_t out = js_mkstr(js, rel.to_norm, strlen(rel.to_norm));
free(rel.from_norm);
free(rel.to_norm);
return out;
}
} else if (rel.from_root_len != rel.to_root_len || strncmp(rel.from_norm, rel.to_norm, rel.from_root_len) != 0) {
ant_value_t out = js_mkstr(js, rel.to_norm, strlen(rel.to_norm));
free(rel.from_norm);
free(rel.to_norm);
return out;
}
rel.from_segs = malloc(strlen(rel.from_norm) * sizeof(char *));
rel.to_segs = malloc(strlen(rel.to_norm) * sizeof(char *));
rel.from_lens = malloc(strlen(rel.from_norm) * sizeof(size_t));
rel.to_lens = malloc(strlen(rel.to_norm) * sizeof(size_t));
if (!rel.from_segs || !rel.to_segs || !rel.from_lens || !rel.to_lens) goto relative_fail;
for (size_t i = rel.from_root_len, start = rel.from_root_len;; i++) {
if (rel.from_norm[i] != '\0' && !path_is_sep(style, rel.from_norm[i])) continue;
if (i > start) {
rel.from_segs[rel.from_count] = rel.from_norm + start;
rel.from_lens[rel.from_count++] = i - start;
}
if (rel.from_norm[i] == '\0') break;
start = i + 1;
}
for (size_t i = rel.to_root_len, start = rel.to_root_len;; i++) {
if (rel.to_norm[i] != '\0' && !path_is_sep(style, rel.to_norm[i])) continue;
if (i > start) {
rel.to_segs[rel.to_count] = rel.to_norm + start;
rel.to_lens[rel.to_count++] = i - start;
}
if (rel.to_norm[i] == '\0') break;
start = i + 1;
}
while (rel.common < rel.from_count && rel.common < rel.to_count) {
bool equal = false;
if (rel.from_lens[rel.common] == rel.to_lens[rel.common]) {
equal = style == PATH_STYLE_WIN32
? strncasecmp(rel.from_segs[rel.common], rel.to_segs[rel.common], rel.from_lens[rel.common]) == 0
: strncmp(rel.from_segs[rel.common], rel.to_segs[rel.common], rel.from_lens[rel.common]) == 0;
}
if (!equal) break;
rel.common++;
}
rel.result_cap = strlen(rel.to_norm) + (size_t)(rel.from_count - rel.common) * 3 + 2;
rel.result = malloc(rel.result_cap);
if (!rel.result) goto relative_fail;
for (int i = rel.common; i < rel.from_count; i++) {
if (rel.pos > 0) rel.result[rel.pos++] = sep;
rel.result[rel.pos++] = '.';
rel.result[rel.pos++] = '.';
}
for (int i = rel.common; i < rel.to_count; i++) {
if (rel.pos > 0) rel.result[rel.pos++] = sep;
memcpy(rel.result + rel.pos, rel.to_segs[i], rel.to_lens[i]);
rel.pos += rel.to_lens[i];
}
if (rel.pos == 0) rel.result[rel.pos++] = '.';
rel.result[rel.pos] = '\0';
ant_value_t out = js_mkstr(js, rel.result, rel.pos);
free(rel.result);
free(rel.from_norm);
free(rel.to_norm);
free(rel.from_segs);
free(rel.to_segs);
free(rel.from_lens);
free(rel.to_lens);
return out;
relative_fail:
free(rel.result);
free(rel.from_norm);
free(rel.to_norm);
free(rel.from_segs);
free(rel.to_segs);
free(rel.from_lens);
free(rel.to_lens);
return js_mkerr(js, "Out of memory");
}
// path.isAbsolute(path)
static ant_value_t builtin_path_isAbsolute(ant_t *js, ant_value_t *args, int nargs) {
path_style_t style = path_current_style(js);
if (nargs < 1) return js_mkerr(js, "isAbsolute() requires a path argument");
if (vtype(args[0]) != T_STR) return js_mkerr(js, "isAbsolute() path must be a string");
size_t path_len;
char *path = js_getstr(js, args[0], &path_len);
if (!path || path_len == 0) return js_false;
return js_bool(path_is_absolute_style(style, path, path_len));
}
// path.parse(path)
static ant_value_t builtin_path_parse(ant_t *js, ant_value_t *args, int nargs) {
path_style_t style = path_current_style(js);
if (nargs < 1) return js_mkerr(js, "parse() requires a path argument");
if (vtype(args[0]) != T_STR) return js_mkerr(js, "parse() path must be a string");
size_t path_len;
char *path = js_getstr(js, args[0], &path_len);
if (!path) return js_mkerr(js, "Failed to get path string");
ant_value_t result = js_mkobj(js);
char *normalized = path_normalize_separators(style, path, path_len);
size_t root_len = 0;
size_t start = 0;
size_t end = 0;
const char *base = NULL;
size_t base_len = 0;
if (!normalized) return js_mkerr(js, "Out of memory");
root_len = path_root_length(style, normalized, path_len);
js_set(js, result, "root", path_make_string(js, normalized, root_len));
end = path_trimmed_end(style, normalized, path_len);
start = path_basename_start(style, normalized, path_len);
base = normalized + start;
base_len = end > start ? end - start : 0;
if (start == 0) js_set(js, result, "dir", js_mkstr(js, ".", 1));
else {
size_t dir_len = start;
while (dir_len > root_len && path_is_sep(style, normalized[dir_len - 1])) dir_len--;
js_set(js, result, "dir", path_make_string(js, normalized, dir_len));
}
js_set(js, result, "base", path_make_string(js, base, base_len));
for (size_t i = base_len; i > 0; i--) {
if (base[i - 1] != '.') continue;
if (i - 1 == 0) break;
js_set(js, result, "ext", path_make_string(js, base + i - 1, base_len - (i - 1)));
js_set(js, result, "name", path_make_string(js, base, i - 1));
free(normalized);
return result;
}
js_set(js, result, "ext", js_mkstr(js, "", 0));
js_set(js, result, "name", path_make_string(js, base, base_len));
free(normalized);
return result;
}
// path.format(pathObject)
static ant_value_t builtin_path_format(ant_t *js, ant_value_t *args, int nargs) {
path_style_t style = path_current_style(js);
char sep = path_sep_char(style);
if (nargs < 1) return js_mkerr(js, "format() requires a path object argument");
if (!is_special_object(args[0])) return js_mkerr(js, "format() argument must be an object");
ant_value_t obj = args[0];
ant_value_t dir_val = js_get(js, obj, "dir");
ant_value_t root_val = js_get(js, obj, "root");
ant_value_t base_val = js_get(js, obj, "base");
ant_value_t name_val = js_get(js, obj, "name");
ant_value_t ext_val = js_get(js, obj, "ext");
char result[PATH_MAX] = {0};
size_t pos = 0;
if (vtype(dir_val) == T_STR) {
size_t len;
char *str = js_getstr(js, dir_val, &len);
if (str && len > 0 && pos + len < PATH_MAX) {
memcpy(result + pos, str, len);
pos += len;
if (result[pos - 1] != sep && pos < PATH_MAX - 1) {
result[pos++] = sep;
}
}
} else if (vtype(root_val) == T_STR) {
size_t len;
char *str = js_getstr(js, root_val, &len);
if (str && len > 0 && pos + len < PATH_MAX) {
memcpy(result + pos, str, len);
pos += len;
}
}
if (vtype(base_val) == T_STR) {
size_t len;
char *str = js_getstr(js, base_val, &len);
if (str && len > 0 && pos + len < PATH_MAX) {
memcpy(result + pos, str, len);
pos += len;
}
} else {
if (vtype(name_val) == T_STR) {
size_t len;
char *str = js_getstr(js, name_val, &len);
if (str && len > 0 && pos + len < PATH_MAX) {
memcpy(result + pos, str, len);
pos += len;
}
}
if (vtype(ext_val) == T_STR) {
size_t len;
char *str = js_getstr(js, ext_val, &len);
if (str && len > 0 && pos + len < PATH_MAX) {
memcpy(result + pos, str, len);
pos += len;
}
}
}
return js_mkstr(js, result, pos);
}
typedef struct {
ant_value_t basename;
ant_value_t dirname;
ant_value_t extname;
ant_value_t join;
ant_value_t normalize;
ant_value_t resolve;
ant_value_t relative;
ant_value_t isAbsolute;
ant_value_t parse;
ant_value_t format;
} path_api_t;
static path_api_t path_build_api_for_style(ant_t *js, path_style_t style) {
ant_value_t style_value = js_mknum((double)style);
return (path_api_t){
.basename = js_heavy_mkfun(js, builtin_path_basename, style_value),
.dirname = js_heavy_mkfun(js, builtin_path_dirname, style_value),
.extname = js_heavy_mkfun(js, builtin_path_extname, style_value),
.join = js_heavy_mkfun(js, builtin_path_join, style_value),
.normalize = js_heavy_mkfun(js, builtin_path_normalize, style_value),
.resolve = js_heavy_mkfun(js, builtin_path_resolve, style_value),
.relative = js_heavy_mkfun(js, builtin_path_relative, style_value),
.isAbsolute = js_heavy_mkfun(js, builtin_path_isAbsolute, style_value),
.parse = js_heavy_mkfun(js, builtin_path_parse, style_value),
.format = js_heavy_mkfun(js, builtin_path_format, style_value)
};}
static void path_apply_api(ant_t *js, ant_value_t target, const path_api_t *api) {
js_set(js, target, "basename", api->basename);
js_set(js, target, "dirname", api->dirname);
js_set(js, target, "extname", api->extname);
js_set(js, target, "join", api->join);
js_set(js, target, "normalize", api->normalize);
js_set(js, target, "resolve", api->resolve);
js_set(js, target, "relative", api->relative);
js_set(js, target, "isAbsolute", api->isAbsolute);
js_set(js, target, "parse", api->parse);
js_set(js, target, "format", api->format);
}
static ant_value_t path_make_variant(ant_t *js, const path_api_t *api, path_style_t style) {
ant_value_t variant = js_mkobj(js);
path_apply_api(js, variant, api);
js_set(js, variant, "sep", js_mkstr(js, path_sep_str(style), 1));
js_set(js, variant, "delimiter", js_mkstr(js, path_delimiter_str(style), 1));
js_set(js, variant, "default", variant);
return variant;
}
ant_value_t path_library(ant_t *js) {
path_api_t api = path_build_api_for_style(js, path_host_style());
path_api_t posix_api = path_build_api_for_style(js, PATH_STYLE_POSIX);
path_api_t win32_api = path_build_api_for_style(js, PATH_STYLE_WIN32);
ant_value_t lib = path_make_variant(js, &api, path_host_style());
ant_value_t posix = path_make_variant(js, &posix_api, PATH_STYLE_POSIX);
ant_value_t win32 = path_make_variant(js, &win32_api, PATH_STYLE_WIN32);
js_set(js, lib, "posix", posix);
js_set(js, lib, "win32", win32);
js_set_sym(js, lib, get_toStringTag_sym(), js_mkstr(js, "path", 4));
js_set(js, lib, "default", lib);
return lib;
}
ant_value_t path_posix_library(ant_t *js) {
path_api_t api = path_build_api_for_style(js, PATH_STYLE_POSIX);
ant_value_t lib = path_make_variant(js, &api, PATH_STYLE_POSIX);
js_set_sym(js, lib, get_toStringTag_sym(), js_mkstr(js, "path", 4));
return lib;
}
ant_value_t path_win32_library(ant_t *js) {
path_api_t api = path_build_api_for_style(js, PATH_STYLE_WIN32);
ant_value_t lib = path_make_variant(js, &api, PATH_STYLE_WIN32);
js_set_sym(js, lib, get_toStringTag_sym(), js_mkstr(js, "path", 4));
return lib;
}

Owner Packages

  • No Owners