From f51acef40e8297d7bd41b774413aa8331ca946ed Mon Sep 17 00:00:00 2001 From: Bruce Hill Date: Sat, 15 Mar 2025 14:22:11 -0400 Subject: [PATCH] Overhaul of Path so it uses root and array of components instead of stringly typed --- ast.c | 1 + ast.h | 4 + compile.c | 27 +- environment.c | 31 +- environment.h | 1 + examples/ini/ini.tm | 2 +- examples/tomo-install/tomo-install.tm | 2 +- examples/tomodeps/tomodeps.tm | 6 +- examples/wrap/wrap.tm | 2 +- parse.c | 86 ++--- stdlib/datatypes.h | 6 + stdlib/moments.h | 1 + stdlib/optionals.h | 1 + stdlib/paths.c | 469 +++++++++++++++++--------- stdlib/paths.h | 32 +- stdlib/stdlib.c | 15 +- test/paths.tm | 55 ++- tomo.c | 267 ++++++++------- typecheck.c | 3 +- types.c | 2 + 20 files changed, 582 insertions(+), 431 deletions(-) diff --git a/ast.c b/ast.c index 367b118..982ef7d 100644 --- a/ast.c +++ b/ast.c @@ -108,6 +108,7 @@ CORD ast_to_xml(ast_t *ast) T(Num, "%g", data.n) T(TextLiteral, "%r", xml_escape(data.cord)) T(TextJoin, "%r", data.lang ? CORD_all(" lang=\"", data.lang, "\"") : CORD_EMPTY, ast_list_to_xml(data.children)) + T(Path, "%s", data.path) T(Declare, "%r", ast_to_xml(data.var), ast_to_xml(data.value)) T(Assign, "%r%r", ast_list_to_xml(data.targets), ast_list_to_xml(data.values)) T(BinaryOp, "%r %r", xml_escape(OP_NAMES[data.op]), ast_to_xml(data.lhs), ast_to_xml(data.rhs)) diff --git a/ast.h b/ast.h index 76485a2..0b8e786 100644 --- a/ast.h +++ b/ast.h @@ -124,6 +124,7 @@ typedef enum { None, Bool, Var, Int, Num, TextLiteral, TextJoin, PrintStatement, + Path, Declare, Assign, BinaryOp, UpdateAssign, Not, Negative, HeapAllocate, StackReference, Mutexed, Holding, @@ -175,6 +176,9 @@ struct ast_s { const char *lang; ast_list_t *children; } TextJoin; + struct { + const char *path; + } Path; struct { ast_list_t *to_print; } PrintStatement; diff --git a/compile.c b/compile.c index 8943dd9..c753fc6 100644 --- a/compile.c +++ b/compile.c @@ -38,7 +38,7 @@ static CORD compile_string_literal(CORD literal); CORD promote_to_optional(type_t *t, CORD code) { - if (t == THREAD_TYPE) { + if (t == THREAD_TYPE || t == PATH_TYPE || t->tag == MomentType) { return code; } else if (t->tag == IntType) { switch (Match(t, IntType)->bits) { @@ -502,6 +502,7 @@ CORD compile_type(type_t *t) if (t == THREAD_TYPE) return "Thread_t"; else if (t == RNG_TYPE) return "RNG_t"; else if (t == MATCH_TYPE) return "Match_t"; + else if (t == PATH_TYPE) return "Path_t"; switch (t->tag) { case ReturnType: errx(1, "Shouldn't be compiling ReturnType to a type"); @@ -522,8 +523,6 @@ CORD compile_type(type_t *t) return "Text_t"; else if (streq(text->lang, "Pattern")) return "Pattern_t"; - else if (streq(text->lang, "Path")) - return "Path_t"; else if (streq(text->lang, "Shell")) return "Shell_t"; else @@ -570,6 +569,8 @@ CORD compile_type(type_t *t) return "Thread_t"; if (nonnull == MATCH_TYPE) return "OptionalMatch_t"; + if (nonnull == PATH_TYPE) + return "OptionalPath_t"; auto s = Match(nonnull, StructType); return CORD_all(namespace_prefix(s->env, s->env->namespace->parent), "$Optional", s->name, "$$type"); } @@ -682,7 +683,7 @@ CORD optional_into_nonnone(type_t *t, CORD value) case IntType: return CORD_all(value, ".i"); case StructType: - if (t == THREAD_TYPE || t == MATCH_TYPE) + if (t == THREAD_TYPE || t == MATCH_TYPE || t == PATH_TYPE) return value; return CORD_all(value, ".value"); default: @@ -698,6 +699,8 @@ CORD check_none(type_t *t, CORD value) return CORD_all("(", value, " == NULL)"); else if (t == MATCH_TYPE) return CORD_all("((", value, ").index.small == 0)"); + else if (t == PATH_TYPE) + return CORD_all("((", value, ").root == PATH_NONE)"); else if (t->tag == BigIntType) return CORD_all("((", value, ").small == 0)"); else if (t->tag == ClosureType) @@ -2191,6 +2194,7 @@ CORD compile_none(type_t *t) t = Match(t, OptionalType)->type; if (t == THREAD_TYPE) return "NULL"; + else if (t == PATH_TYPE) return "NONE_PATH"; switch (t->tag) { case BigIntType: return "NONE_INT"; @@ -2621,11 +2625,10 @@ CORD compile(env_t *env, ast_t *ast) code_err(ast, "The 'xor' operator isn't supported between %T and %T values", lhs_t, rhs_t); } case BINOP_CONCAT: { + if (operand_t == PATH_TYPE) + return CORD_all("Path$concat(", lhs, ", ", rhs, ")"); switch (operand_t->tag) { case TextType: { - const char *lang = Match(operand_t, TextType)->lang; - if (streq(lang, "Path")) - return CORD_all("Path$concat(", lhs, ", ", rhs, ")"); return CORD_all("Text$concat(", lhs, ", ", rhs, ")"); } case ArrayType: { @@ -2660,7 +2663,7 @@ CORD compile(env_t *env, ast_t *ast) CORD lang_constructor; if (!lang || streq(lang, "Text")) lang_constructor = "Text"; - else if (streq(lang, "Pattern") || streq(lang, "Path") || streq(lang, "Shell")) + else if (streq(lang, "Pattern") || streq(lang, "Shell")) lang_constructor = lang; else lang_constructor = CORD_all(namespace_prefix(Match(text_t, TextType)->env, Match(text_t, TextType)->env->namespace->parent), lang); @@ -2704,6 +2707,9 @@ CORD compile(env_t *env, ast_t *ast) return code; } } + case Path: { + return CORD_all("Path(", compile_string_literal(Match(ast, Path)->path), ")"); + } case Block: { ast_list_t *stmts = Match(ast, Block)->statements; if (stmts && !stmts->next) @@ -3836,8 +3842,9 @@ CORD compile(env_t *env, ast_t *ast) CORD compile_type_info(type_t *t) { if (t == THREAD_TYPE) return "&Thread$info"; - else if (t == MATCH_TYPE) return "&Match$info"; else if (t == RNG_TYPE) return "&RNG$info"; + else if (t == MATCH_TYPE) return "&Match$info"; + else if (t == PATH_TYPE) return "&Path$info"; switch (t->tag) { case BoolType: case ByteType: case IntType: case BigIntType: case NumType: case CStringType: case MomentType: @@ -3850,8 +3857,6 @@ CORD compile_type_info(type_t *t) return "&Pattern$info"; else if (streq(text->lang, "Shell")) return "&Shell$info"; - else if (streq(text->lang, "Path")) - return "&Path$info"; return CORD_all("(&", namespace_prefix(text->env, text->env->namespace->parent), text->lang, "$$info)"); } case StructType: { diff --git a/environment.c b/environment.c index 476cd69..5358fb5 100644 --- a/environment.c +++ b/environment.c @@ -14,6 +14,7 @@ type_t *TEXT_TYPE = NULL; type_t *MATCH_TYPE = NULL; type_t *RNG_TYPE = NULL; +public type_t *PATH_TYPE = NULL; public type_t *THREAD_TYPE = NULL; env_t *new_compilation_unit(CORD libname) @@ -79,6 +80,14 @@ env_t *new_compilation_unit(CORD libname) .next=new(arg_t, .name="captures", .type=Type(ArrayType, .item_type=TEXT_TYPE))))); } + { + env_t *path_env = namespace_env(env, "Path"); + PATH_TYPE = Type( + StructType, .name="Path", .env=path_env, + .fields=new(arg_t, .name="root", .type=Type(IntType, .bits=TYPE_IBITS32), + .next=new(arg_t, .name="components", .type=Type(ArrayType, .item_type=TEXT_TYPE)))); + } + { env_t *thread_env = namespace_env(env, "Thread"); THREAD_TYPE = Type(StructType, .name="Thread", .env=thread_env, .opaque=true); @@ -324,12 +333,15 @@ env_t *new_compilation_unit(CORD libname) {"unix_timestamp", "Moment$unix_timestamp", "func(moment:Moment -> Int64)"}, {"year", "Moment$year", "func(moment:Moment,timezone=none:Text -> Int)"}, )}, - {"Path", Type(TextType, .lang="Path", .env=namespace_env(env, "Path")), "Text_t", "Text$info", TypedArray(ns_entry_t, + {"Path", PATH_TYPE, "Path_t", "Path$info", TypedArray(ns_entry_t, {"append", "Path$append", "func(path:Path, text:Text, permissions=Int32(0o644))"}, {"append_bytes", "Path$append_bytes", "func(path:Path, bytes:[Byte], permissions=Int32(0o644))"}, {"base_name", "Path$base_name", "func(path:Path -> Text)"}, {"by_line", "Path$by_line", "func(path:Path -> func(->Text?)?)"}, + {"child", "Path$with_component", "func(path:Path, child:Text -> Path)"}, {"children", "Path$children", "func(path:Path, include_hidden=no -> [Path])"}, + {"components", "Path$components", "func(path:Path -> [Text])"}, + {"concatenated_with", "Path$concat", "func(a,b:Path -> Path)"}, {"create_directory", "Path$create_directory", "func(path:Path, permissions=Int32(0o755))"}, {"escape_int", "Int$value_as_text", "func(i:Int -> Path)"}, {"escape_path", "Path$escape_path", "func(path:Path -> Path)"}, @@ -337,6 +349,7 @@ env_t *new_compilation_unit(CORD libname) {"exists", "Path$exists", "func(path:Path -> Bool)"}, {"extension", "Path$extension", "func(path:Path, full=yes -> Text)"}, {"files", "Path$children", "func(path:Path, include_hidden=no -> [Path])"}, + {"from_components", "Path$from_components", "func(components:[Text] -> Path)"}, {"glob", "Path$glob", "func(path:Path -> [Path])"}, {"is_directory", "Path$is_directory", "func(path:Path, follow_symlinks=yes -> Bool)"}, {"is_file", "Path$is_file", "func(path:Path, follow_symlinks=yes -> Bool)"}, @@ -347,6 +360,7 @@ env_t *new_compilation_unit(CORD libname) {"read", "Path$read", "func(path:Path -> Text?)"}, {"read_bytes", "Path$read_bytes", "func(path:Path, limit=none:Int -> [Byte]?)"}, {"relative", "Path$relative", "func(path:Path, relative_to=(./) -> Path)"}, + {"relative_to", "Path$relative_to", "func(path:Path, relative_to:Path -> Path)"}, {"remove", "Path$remove", "func(path:Path, ignore_missing=no)"}, {"resolved", "Path$resolved", "func(path:Path, relative_to=(./) -> Path)"}, {"subdirectories", "Path$children", "func(path:Path, include_hidden=no -> [Path])"}, @@ -359,14 +373,6 @@ env_t *new_compilation_unit(CORD libname) {"modified", "Path$modified", "func(path:Path, follow_symlinks=yes -> Moment?)"}, {"accessed", "Path$accessed", "func(path:Path, follow_symlinks=yes -> Moment?)"}, {"changed", "Path$changed", "func(path:Path, follow_symlinks=yes -> Moment?)"}, - - // Text methods: - {"ends_with", "Text$ends_with", "func(path:Path, suffix:Text -> Bool)"}, - {"has", "Text$has", "func(path:Path, pattern:Pattern -> Bool)"}, - {"matches", "Text$matches", "func(path:Path, pattern:Pattern -> [Text]?)"}, - {"replace", "Text$replace", "func(path:Path, pattern:Pattern, replacement:Text, backref=$/\\/, recursive=yes -> Path)"}, - {"replace_all", "Text$replace_all", "func(path:Path, replacements:{Pattern,Text}, backref=$/\\/, recursive=yes -> Path)"}, - {"starts_with", "Text$starts_with", "func(path:Path, prefix:Text -> Bool)"}, )}, // RNG must come after Path so we can read bytes from /dev/urandom {"RNG", RNG_TYPE, "RNG_t", "RNG", TypedArray(ns_entry_t, @@ -411,7 +417,7 @@ env_t *new_compilation_unit(CORD libname) {"from_c_string", "Text$from_str", "func(str:CString -> Text?)"}, {"from_codepoint_names", "Text$from_codepoint_names", "func(codepoint_names:[Text] -> Text?)"}, {"from_codepoints", "Text$from_codepoints", "func(codepoints:[Int32] -> Text)"}, - {"from_text", "Path$cleanup", "func(text:Text -> Path)"}, + {"from_text", "Path$from_text", "func(text:Text -> Path)"}, {"has", "Text$has", "func(text:Text, pattern:Pattern -> Bool)"}, {"join", "Text$join", "func(glue:Text, pieces:[Text] -> Text)"}, {"left_pad", "Text$left_pad", "func(text:Text, count:Int, pad=\" \" -> Text)"}, @@ -595,9 +601,8 @@ env_t *new_compilation_unit(CORD libname) set_binding(namespace_env(env, "Path"), "from_text", Type(FunctionType, .args=new(arg_t, .name="text", .type=TEXT_TYPE), - .ret=Type(TextType, .lang="Path", .env=namespace_env(env, "Path"))), - "Path$cleanup"); - + .ret=PATH_TYPE), + "Path$from_text"); set_binding(namespace_env(env, "Pattern"), "from_text", Type(FunctionType, .args=new(arg_t, .name="text", .type=TEXT_TYPE), diff --git a/environment.h b/environment.h index a6fabc8..b86fba2 100644 --- a/environment.h +++ b/environment.h @@ -75,6 +75,7 @@ binding_t *get_namespace_binding(env_t *env, ast_t *self, const char *name); extern type_t *TEXT_TYPE; extern type_t *MATCH_TYPE; extern type_t *RNG_TYPE; +extern type_t *PATH_TYPE; extern type_t *THREAD_TYPE; // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/examples/ini/ini.tm b/examples/ini/ini.tm index 9b27e8c..1c50ac3 100644 --- a/examples/ini/ini.tm +++ b/examples/ini/ini.tm @@ -7,7 +7,7 @@ _HELP := " " func parse_ini(path:Path -> {Text,{Text,Text}}): - text := path:read() or exit("Could not read INI file: $\[31;1]$(path.text)$\[]") + text := path:read() or exit("Could not read INI file: $\[31;1]$(path)$\[]") sections := @{:Text,@{Text,Text}} current_section := @{:Text,Text} diff --git a/examples/tomo-install/tomo-install.tm b/examples/tomo-install/tomo-install.tm index f769204..43e2302 100644 --- a/examples/tomo-install/tomo-install.tm +++ b/examples/tomo-install/tomo-install.tm @@ -13,7 +13,7 @@ func find_urls(path:Path -> [Text]): if path:is_directory(): for f in path:children(): urls:insert_all(find_urls(f)) - else if path:is_file() and path:ends_with(".tm"): + else if path:is_file() and path:extension() == ".tm": for line in path:by_line()!: if m := line:matches($/use{space}{url}/) or line:matches($/{id}{space}:={space}use{space}{url}/): urls:insert(m[-1]) diff --git a/examples/tomodeps/tomodeps.tm b/examples/tomodeps/tomodeps.tm index 93e3eb4..279e505 100644 --- a/examples/tomodeps/tomodeps.tm +++ b/examples/tomodeps/tomodeps.tm @@ -36,7 +36,7 @@ func _build_dependency_graph(dep:Dependency, dependencies:@{Dependency,{Dependen dir := (~/.local/share/tomo/installed/$module) module_deps := @{:Dependency} visited := @{:Path} - unvisited := @{f:resolved() for f in dir:files() if f:ends_with(".tm")} + unvisited := @{f:resolved() for f in dir:files() if f:extension() == ".tm"} while unvisited.length > 0: file := unvisited.items[-1] unvisited:remove(file) @@ -66,9 +66,9 @@ func _printable_name(dep:Dependency -> Text): is File(f): f = f:relative() if f:exists(): - return "$(f.text)" + return Text(f) else: - return "$(\x1b)[31;1m$(f.text) (not found)$(\x1b)[m" + return "$(\x1b)[31;1m$(f) (not found)$(\x1b)[m" func _draw_tree(dep:Dependency, dependencies:{Dependency,{Dependency}}, already_printed:@{Dependency}, prefix="", is_last=yes): if already_printed:has(dep): diff --git a/examples/wrap/wrap.tm b/examples/wrap/wrap.tm index 94d752b..c90713a 100644 --- a/examples/wrap/wrap.tm +++ b/examples/wrap/wrap.tm @@ -82,7 +82,7 @@ func main(files:[Path], width=80, inplace=no, min_split=3, rewrap=yes, hyphen=UN files = [(/dev/stdin)] for file in files: - text := file:read() or exit("Could not read file: $(file.text)") + text := file:read() or exit("Could not read file: $file") if rewrap: text = unwrap(text) diff --git a/parse.c b/parse.c index 81b239a..bbe8a70 100644 --- a/parse.c +++ b/parse.c @@ -1423,73 +1423,43 @@ PARSER(parse_path) { // "(" ("~/" / "./" / "../" / "/") ... ")" const char *start = pos; - if (!(match(&pos, "(~/") - || match(&pos, "(./") - || match(&pos, "(../") - || match(&pos, "(/"))) + if (!match(&pos, "(")) return NULL; - const char *chunk_start = start + 1; - ast_list_t *chunks = NULL; - CORD chunk_text = CORD_EMPTY; + if (!(*pos == '~' || *pos == '.' || *pos == '/')) + return NULL; + + const char *path_start = pos; + size_t len = 1; int paren_depth = 1; - while (pos < ctx->file->text + ctx->file->len) { - switch (*pos) { - case '\\': { - ++pos; - chunk_text = CORD_asprintf("%r%.*s%c", chunk_text, (size_t)(pos - chunk_start), chunk_start, *pos); - ++pos; - chunk_start = pos; + while (pos + len < ctx->file->text + ctx->file->len - 1) { + if (pos[len] == '\\') { + len += 2; continue; - } - case '$': { - const char *interp_start = pos; - - if (pos > chunk_start) - chunk_text = CORD_asprintf("%r%.*s", chunk_text, (size_t)(pos - chunk_start), chunk_start); - - if (chunk_text) { - ast_t *literal = NewAST(ctx->file, chunk_start, pos, TextLiteral, .cord=chunk_text); - chunks = new(ast_list_t, .ast=literal, .next=chunks); - chunk_text = CORD_EMPTY; - } - ++pos; - if (*pos == ' ' || *pos == '\t') - parser_err(ctx, pos, pos+1, "Whitespace is not allowed before an interpolation here"); - ast_t *interp = expect(ctx, interp_start, &pos, parse_term_no_suffix, "I expected an interpolation term here"); - chunks = new(ast_list_t, .ast=interp, .next=chunks); - chunk_start = pos; - continue; - } - case '(': { + } else if (pos[len] == '(') { paren_depth += 1; - ++pos; - continue; - } - case ')': { + } else if (pos[len] == ')') { paren_depth -= 1; - if (paren_depth == 0) - goto end_of_path; - ++pos; - continue; + if (paren_depth <= 0) break; + } else if (pos[len] == '\r' || pos[len] == '\n') { + parser_err(ctx, path_start, &pos[len-1], "This path was not closed"); } - default: ++pos; continue; + len += 1; + } + pos += len + 1; + char *path = heap_strf("%.*s", (int)len, path_start); + for (char *src = path, *dest = path; ; ) { + if (src[0] == '\\') { + *(dest++) = src[1]; + src += 2; + } else if (*src) { + *(dest++) = *(src++); + } else { + *(dest++) = '\0'; + break; } } - end_of_path:; - - if (pos > chunk_start) - chunk_text = CORD_asprintf("%r%.*s", chunk_text, (size_t)(pos - chunk_start), chunk_start); - - if (chunk_text != CORD_EMPTY) { - ast_t *literal = NewAST(ctx->file, chunk_start, pos, TextLiteral, .cord=chunk_text); - chunks = new(ast_list_t, .ast=literal, .next=chunks); - } - - expect_closing(ctx, &pos, ")", "I was expecting a ')' to finish this path"); - - REVERSE_LIST(chunks); - return NewAST(ctx->file, start, pos, TextJoin, .lang="Path", .children=chunks); + return NewAST(ctx->file, start, pos, Path, .path=path); } PARSER(parse_pass) { diff --git a/stdlib/datatypes.h b/stdlib/datatypes.h index e131239..8ddcbc8 100644 --- a/stdlib/datatypes.h +++ b/stdlib/datatypes.h @@ -96,6 +96,12 @@ typedef struct Text_s { #define Pattern_t Text_t #define OptionalPattern_t Text_t +typedef struct { + enum { PATH_NONE, PATH_RELATIVE, PATH_ROOT, PATH_HOME } root; + Array_t components; +} Path_t; +#define OptionalPath_t Path_t + typedef struct timeval Moment_t; #define OptionalMoment_t Moment_t diff --git a/stdlib/moments.h b/stdlib/moments.h index 1ae3326..ff6d411 100644 --- a/stdlib/moments.h +++ b/stdlib/moments.h @@ -12,6 +12,7 @@ Text_t Moment$as_text(const void *moment, bool colorize, const TypeInfo_t *type); PUREFUNC int32_t Moment$compare(const void *a, const void *b, const TypeInfo_t *type); +CONSTFUNC public bool Moment$is_none(const void *m, const TypeInfo_t*); Moment_t Moment$now(void); Moment_t Moment$new(Int_t year, Int_t month, Int_t day, Int_t hour, Int_t minute, double second, OptionalText_t timezone); Moment_t Moment$after(Moment_t moment, double seconds, double minutes, double hours, Int_t days, Int_t weeks, Int_t months, Int_t years, OptionalText_t timezone); diff --git a/stdlib/optionals.h b/stdlib/optionals.h index 4e6bf7e..4b368b1 100644 --- a/stdlib/optionals.h +++ b/stdlib/optionals.h @@ -23,6 +23,7 @@ #define NONE_CLOSURE ((OptionalClosure_t){.fn=NULL}) #define NONE_TEXT ((OptionalText_t){.length=-1}) #define NONE_MOMENT ((OptionalMoment_t){.tv_usec=-1}) +#define NONE_PATH ((Path_t){.root=PATH_NONE}) PUREFUNC bool is_null(const void *obj, const TypeInfo_t *non_optional_type); PUREFUNC uint64_t Optional$hash(const void *obj, const TypeInfo_t *type); diff --git a/stdlib/paths.c b/stdlib/paths.c index a42dc5a..fc82390 100644 --- a/stdlib/paths.c +++ b/stdlib/paths.c @@ -8,6 +8,7 @@ #include #include #include +#include #include #include #include @@ -23,145 +24,154 @@ #include "types.h" #include "util.h" -PUREFUNC public Path_t Path$escape_text(Text_t text) +// Use inline version of the siphash code for performance: +#include "siphash.h" +#include "siphash-internals.h" + +static const Path_t HOME_PATH = {.root=PATH_HOME}, ROOT_PATH = {.root=PATH_ROOT}, CURDIR_PATH = {.root=PATH_RELATIVE}; + +static void clean_components(Array_t *components) { - if (Text$has(text, Pattern("/"))) - fail("Path interpolations cannot contain slashes: %k", &text); - else if (Text$has(text, Pattern(";"))) - fail("Path interpolations cannot contain semicolons: %k", &text); - else if (Text$equal_values(text, Path(".")) || Text$equal_values(text, Path(".."))) - fail("Path interpolation is \"%k\" which is disallowed to prevent security vulnerabilities", &text); - return (Path_t)text; -} - -PUREFUNC public Path_t Path$escape_path(Path_t path) -{ - if (Text$starts_with(path, Path("~/")) || Text$starts_with(path, Path("/"))) - fail("Invalid path component: %k", &path); - return path; -} - -public Path_t Path$cleanup(Path_t path) -{ - if (!Text$starts_with(path, Path("/")) && !Text$starts_with(path, Path("./")) - && !Text$starts_with(path, Path("../")) && !Text$starts_with(path, Path("~/"))) - path = Text$concat(Text("./"), path); - - // Not fully resolved, but at least get rid of some of the cruft like "/./" - // and "/foo/../" and "//" - bool trailing_slash = Text$ends_with(path, Path("/")); - Array_t components = Text$split(path, Pattern("/")); - if (components.length == 0) return Path("/"); - Path_t root = *(Path_t*)components.data; - Array$remove_at(&components, I(1), I(1), sizeof(Path_t)); - - for (int64_t i = 0; i < components.length; ) { - Path_t component = *(Path_t*)(components.data + i*components.stride); - if (component.length == 0 || Text$equal_values(component, Path("."))) { // Skip (//) and (/./) - Array$remove_at(&components, I(i+1), I(1), sizeof(Path_t)); - } else if (Text$equal_values(component, Path(".."))) { - if (i == 0) { - if (root.length == 0) { // (/..) -> (/) - Array$remove_at(&components, I(i+1), I(1), sizeof(Path_t)); - i += 1; - } else if (Text$equal_values(root, Path("."))) { // (./..) -> (..) - root = Path(".."); - Array$remove_at(&components, I(i+1), I(1), sizeof(Path_t)); - i += 1; - } else if (Text$equal_values(root, Path("~"))) { - root = Path(""); // Convert $HOME to absolute path: - - Array$remove_at(&components, I(i+1), I(1), sizeof(Path_t)); - // `i` is pointing to where the `..` lived - - const char *home = getenv("HOME"); - if (!home) fail("Could not get $HOME directory!"); - - // Insert all but the last component: - for (const char *p = home + 1; *p; ) { - const char *next_slash = strchr(p, '/'); - if (!next_slash) break; // Skip last component - Path_t home_component = Text$format("%.*s", (int)(next_slash - p), p); - Array$insert(&components, &home_component, I(i+1), sizeof(Path_t)); - i += 1; - p = next_slash + 1; - } - } else { // (../..) -> (../..) - i += 1; - } - } else if (Text$equal(&component, (Path_t*)(components.data + (i-1)*components.stride), &Text$info)) { // (___/../..) -> (____/../..) - i += 1; - } else { // (___/foo/..) -> (___) - Array$remove_at(&components, I(i), I(2), sizeof(Path_t)); + for (int64_t i = 0; i < components->length; ) { + Text_t *component = (Text_t*)(components->data + i*components->stride); + if (component->length == 0 || Text$equal_values(*component, Text("."))) { + Array$remove_at(components, I(i+1), I(1), sizeof(Text_t)); + } else if (i > 0 && Text$equal_values(*component, Text(".."))) { + Text_t *prev = (Text_t*)(components->data + (i-1)*components->stride); + if (!Text$equal_values(*prev, Text(".."))) { + Array$remove_at(components, I(i), I(2), sizeof(Text_t)); i -= 1; + } else { + i += 1; } - } else { // (___/foo/baz) -> (___/foo/baz) - i++; + } else { + i += 1; } } +} - Text_t cleaned_up = Text$concat(root, Text("/"), Text$join(Text("/"), components)); - if (trailing_slash && !Text$ends_with(cleaned_up, Text("/"))) - cleaned_up = Text$concat(cleaned_up, Text("/")); - return cleaned_up; +public Path_t Path$from_str(const char *str) +{ + if (!str || str[0] == '\0' || streq(str, "/")) return ROOT_PATH; + else if (streq(str, "~")) return HOME_PATH; + else if (streq(str, ".")) return CURDIR_PATH; + + Path_t result = {.components={}}; + if (str[0] == '/') { + result.root = PATH_ROOT; + str += 1; + } else if (str[0] == '~' && str[1] == '/') { + result.root = PATH_HOME; + str += 2; + } else if (str[0] == '.' && str[1] == '/') { + result.root = PATH_RELATIVE; + str += 2; + } else { + result.root = PATH_RELATIVE; + } + + while (str && *str) { + size_t component_len = strcspn(str, "/"); + if (component_len > 0) { + if (component_len == 1 && str[0] == '.') { + // ignore /./ + } else if (component_len == 2 && strncmp(str, "..", 2) == 0 + && result.components.length > 1 + && !Text$equal_values(Text(".."), *(Text_t*)(result.components.data + result.components.stride*(result.components.length-1)))) { + // Pop off /foo/baz/.. -> /foo + Array$remove_at(&result.components, I(result.components.length), I(1), sizeof(Text_t)); + } else { + Text_t component = Text$from_strn(str, component_len); + Array$insert_value(&result.components, component, I(0), sizeof(Text_t)); + } + str += component_len; + } + str += strspn(str, "/"); + } + return result; +} + +public Path_t Path$from_text(Text_t text) +{ + return Path$from_str(Text$as_c_string(text)); } static INLINE Path_t Path$_expand_home(Path_t path) { - if (Text$starts_with(path, Path("~/"))) { - Path_t after_tilde = Text$slice(path, I(2), I(-1)); - return Text$format("%s%k", getenv("HOME"), &after_tilde); - } else { - return path; + if (path.root == PATH_HOME) { + Path_t pwd = Path$from_str(getenv("HOME")); + Array_t components = Array$concat(path.components, pwd.components, sizeof(Text_t)); + clean_components(&components); + path = (Path_t){.root=PATH_ROOT, .components=components}; } + return path; } public Path_t Path$_concat(int n, Path_t items[n]) { - Path_t cleaned_up = Path$cleanup(Text$_concat(n, items)); - if (cleaned_up.length > PATH_MAX) - fail("Path exceeds the maximum path length: %k", &cleaned_up); - return cleaned_up; -} - -public Text_t Path$resolved(Path_t path, Path_t relative_to) -{ - path = Path$cleanup(path); - - const char *path_str = Text$as_c_string(path); - const char *relative_to_str = Text$as_c_string(relative_to); - const char *resolved_path = resolve_path(path_str, relative_to_str, relative_to_str); - if (resolved_path) { - return (Path_t)(Text$from_str(resolved_path)); - } else if (path_str[0] == '/') { - return path; - } else if (path_str[0] == '~' && path_str[1] == '/') { - return (Path_t)Text$format("%s%s", getenv("HOME"), path_str + 1); - } else { - return Text$concat(Path$resolved(relative_to, Path(".")), Path("/"), path); + assert(n > 0); + Path_t result = items[0]; + ARRAY_INCREF(result.components); + for (int i = 1; i < n; i++) { + if (items[i].root != PATH_RELATIVE) + fail("Cannot concatenate an absolute or home-based path onto another path: (%s)\n", + Path$as_c_string(items[i])); + Array$insert_all(&result.components, items[i].components, I(0), sizeof(Text_t)); } + clean_components(&result.components); + return result; } -public Text_t Path$relative(Path_t path, Path_t relative_to) +public Path_t Path$resolved(Path_t path, Path_t relative_to) { - path = Path$resolved(path, relative_to); - relative_to = Path$resolved(relative_to, Path(".")); - if (Text$starts_with(path, Text$concat(relative_to, Text("/")))) - return Text$slice(path, I(relative_to.length + 2), I(-1)); + if (path.root == PATH_RELATIVE && !(relative_to.root == PATH_RELATIVE && relative_to.components.length == 0)) { + Path_t result = {.root=relative_to.root}; + result.components = relative_to.components; + ARRAY_INCREF(result.components); + Array$insert_all(&result.components, path.components, I(0), sizeof(Text_t)); + clean_components(&result.components); + return result; + } return path; } +public Path_t Path$relative_to(Path_t path, Path_t relative_to) +{ + if (path.root != relative_to.root) + fail("Cannot create a path relative to a different path with a mismatching root: (%k) relative to (%k)", + (Text_t[1]){Path$as_text(&path, false, &Path$info)}, (Text_t[1]){Path$as_text(&relative_to, false, &Path$info)}); + + Path_t result = {.root=PATH_RELATIVE}; + int64_t shared = 0; + for (; shared < path.components.length && shared < relative_to.components.length; shared++) { + Text_t *p = (Text_t*)(path.components.data + shared*path.components.stride); + Text_t *r = (Text_t*)(relative_to.components.data + shared*relative_to.components.stride); + if (!Text$equal_values(*p, *r)) + break; + } + + for (int64_t i = shared; i < relative_to.components.length; shared++) + Array$insert_value(&result.components, Text(".."), I(1), sizeof(Text_t)); + + for (int64_t i = shared; i < path.components.length; shared++) { + Text_t *p = (Text_t*)(path.components.data + i*path.components.stride); + Array$insert(&result.components, p, I(0), sizeof(Text_t)); + } + //clean_components(&result.components); + return result; +} + public bool Path$exists(Path_t path) { path = Path$_expand_home(path); struct stat sb; - return (stat(Text$as_c_string(path), &sb) == 0); + return (stat(Path$as_c_string(path), &sb) == 0); } static INLINE int path_stat(Path_t path, bool follow_symlinks, struct stat *sb) { path = Path$_expand_home(path); - const char *path_str = Text$as_c_string(path); + const char *path_str = Path$as_c_string(path); return follow_symlinks ? stat(path_str, sb) : lstat(path_str, sb); } @@ -232,7 +242,7 @@ public OptionalMoment_t Path$changed(Path_t path, bool follow_symlinks) static void _write(Path_t path, Array_t bytes, int mode, int permissions) { path = Path$_expand_home(path); - const char *path_str = Text$as_c_string(path); + const char *path_str = Path$as_c_string(path); int fd = open(path_str, mode, permissions); if (fd == -1) fail("Could not write to file: %s\n%s", path_str, strerror(errno)); @@ -269,7 +279,7 @@ public void Path$append_bytes(Path_t path, Array_t bytes, int permissions) public OptionalArray_t Path$read_bytes(Path_t path, OptionalInt_t count) { path = Path$_expand_home(path); - int fd = open(Text$as_c_string(path), O_RDONLY); + int fd = open(Path$as_c_string(path), O_RDONLY); if (fd == -1) return NONE_ARRAY; @@ -333,7 +343,7 @@ public OptionalText_t Path$read(Path_t path) public void Path$remove(Path_t path, bool ignore_missing) { path = Path$_expand_home(path); - const char *path_str = Text$as_c_string(path); + const char *path_str = Path$as_c_string(path); struct stat sb; if (lstat(path_str, &sb) != 0) { if (!ignore_missing) @@ -354,27 +364,10 @@ public void Path$remove(Path_t path, bool ignore_missing) public void Path$create_directory(Path_t path, int permissions) { path = Path$_expand_home(path); - char *c_path = Text$as_c_string(path); - char *end = c_path + strlen(c_path); - if (*end == '/' && end > c_path) { - *end = '\0'; - --end; - } - char *end_of_component = strchrnul(c_path + 1, '/'); - for (;;) { - if (end_of_component < end) - *end_of_component = '\0'; - - int status = mkdir(c_path, (mode_t)permissions); - if (status != 0 && errno != EEXIST) - fail("Could not create directory: %s (%s)", c_path, strerror(errno)); - - if (end_of_component >= end) - break; - - *end_of_component = '/'; - end_of_component = strchrnul(end_of_component + 1, '/'); - } + const char *c_path = Path$as_c_string(path); + int status = mkdir(c_path, (mode_t)permissions); + if (status != 0 && errno != EEXIST) + fail("Could not create directory: %s (%s)", c_path, strerror(errno)); } static Array_t _filtered_children(Path_t path, bool include_hidden, mode_t filter) @@ -382,7 +375,7 @@ static Array_t _filtered_children(Path_t path, bool include_hidden, mode_t filte path = Path$_expand_home(path); struct dirent *dir; Array_t children = {}; - const char *path_str = Text$as_c_string(path); + const char *path_str = Path$as_c_string(path); size_t path_len = strlen(path_str); DIR *d = opendir(path_str); if (!d) @@ -404,7 +397,7 @@ static Array_t _filtered_children(Path_t path, bool include_hidden, mode_t filte if (!((sb.st_mode & S_IFMT) & filter)) continue; - Path_t child = Text$format("%s%s", child_str, ((sb.st_mode & S_IFMT) == S_IFDIR) ? "/" : ""); // Trailing slash for dirs + Path_t child = Path$from_str(child_str); Array$insert(&children, &child, I(0), sizeof(Path_t)); } closedir(d); @@ -429,7 +422,7 @@ public Array_t Path$subdirectories(Path_t path, bool include_hidden) public Path_t Path$unique_directory(Path_t path) { path = Path$_expand_home(path); - const char *path_str = Text$as_c_string(path); + const char *path_str = Path$as_c_string(path); size_t len = strlen(path_str); if (len >= PATH_MAX) fail("Path is too long: %s", path_str); char buf[PATH_MAX] = {}; @@ -438,13 +431,13 @@ public Path_t Path$unique_directory(Path_t path) buf[--len] = '\0'; char *created = mkdtemp(buf); if (!created) fail("Failed to create temporary directory: %s (%s)", path_str, strerror(errno)); - return Text$format("%s/", created); + return Path$from_str(created); } -public Text_t Path$write_unique_bytes(Path_t path, Array_t bytes) +public Path_t Path$write_unique_bytes(Path_t path, Array_t bytes) { path = Path$_expand_home(path); - const char *path_str = Text$as_c_string(path); + const char *path_str = Path$as_c_string(path); size_t len = strlen(path_str); if (len >= PATH_MAX) fail("Path is too long: %s", path_str); char buf[PATH_MAX] = {}; @@ -466,26 +459,39 @@ public Text_t Path$write_unique_bytes(Path_t path, Array_t bytes) ssize_t written = write(fd, bytes.data, (size_t)bytes.length); if (written != (ssize_t)bytes.length) fail("Could not write to file: %s\n%s", buf, strerror(errno)); - return Text$format("%s", buf); + return Path$from_str(buf); } -public Text_t Path$write_unique(Path_t path, Text_t text) +public Path_t Path$write_unique(Path_t path, Text_t text) { return Path$write_unique_bytes(path, Text$utf8_bytes(text)); } public Path_t Path$parent(Path_t path) { - return Path$cleanup(Text$concat(path, Path("/../"))); + if (path.root == PATH_ROOT && path.components.length == 0) { + return path; + } else if (path.components.length > 0 && !Text$equal_values(*(Text_t*)(path.components.data + path.components.stride*(path.components.length-1)), + Text(".."))) { + return (Path_t){.root=path.root, .components=Array$slice(path.components, I(1), I(-2))}; + } else { + Path_t result = {.root=path.root, .components=path.components}; + ARRAY_INCREF(result.components); + Array$insert_value(&result.components, Text(".."), I(0), sizeof(Text_t)); + return result; + } } -public Text_t Path$base_name(Path_t path) +public PUREFUNC Text_t Path$base_name(Path_t path) { - path = Path$cleanup(path); - if (Text$ends_with(path, Path("/"))) - return Text$replace(path, Pattern("{0+..}/{!/}/{end}"), Text("@2"), Text("@"), false); + if (path.components.length >= 1) + return *(Text_t*)(path.components.data + path.components.stride*(path.components.length-1)); + else if (path.root == PATH_HOME) + return Text("~"); + else if (path.root == PATH_RELATIVE) + return Text("."); else - return Text$replace(path, Pattern("{0+..}/{!/}{end}"), Text("@2"), Text("@"), false); + return EMPTY_TEXT; } public Text_t Path$extension(Path_t path, bool full) @@ -501,6 +507,41 @@ public Text_t Path$extension(Path_t path, bool full) return Text(""); } +public Path_t Path$with_component(Path_t path, Text_t component) +{ + Path_t result = { + .root=path.root, + .components=path.components, + }; + ARRAY_INCREF(result.components); + Array$insert(&result.components, &component, I(0), sizeof(Text_t)); + return result; +} + +public Path_t Path$with_extension(Path_t path, Text_t extension, bool replace) +{ + if (path.components.length == 0) + fail("A path with no components can't have an extension!"); + + Path_t result = { + .root=path.root, + .components=path.components, + }; + ARRAY_INCREF(result.components); + Text_t last = *(Text_t*)(path.components.data + path.components.stride*(path.components.length-1)); + Array$remove_at(&result.components, I(-1), I(1), sizeof(Text_t)); + if (replace) { + if (Text$starts_with(last, Text("."))) + last = Text$replace(last, Pattern(".{!.}.{..}"), Text(".@1"), Pattern("@"), false); + else + last = Text$replace(last, Pattern("{!.}.{..}"), Text("@1"), Pattern("@"), false); + } + + last = Text$concat(last, extension); + Array$insert(&result.components, &last, I(0), sizeof(Text_t)); + return result; +} + static void _line_reader_cleanup(FILE **f) { if (f && *f) { @@ -536,7 +577,7 @@ public OptionalClosure_t Path$by_line(Path_t path) { path = Path$_expand_home(path); - FILE *f = fopen(Text$as_c_string(path), "r"); + FILE *f = fopen(Path$as_c_string(path), "r"); if (f == NULL) return NONE_CLOSURE; @@ -549,7 +590,7 @@ public OptionalClosure_t Path$by_line(Path_t path) public Array_t Path$glob(Path_t path) { glob_t glob_result; - int status = glob(Text$as_c_string(path), GLOB_BRACE | GLOB_TILDE | GLOB_TILDE_CHECK, NULL, &glob_result); + int status = glob(Path$as_c_string(path), GLOB_BRACE | GLOB_TILDE | GLOB_TILDE_CHECK, NULL, &glob_result); if (status != 0 && status != GLOB_NOMATCH) fail("Failed to perform globbing"); @@ -559,17 +600,141 @@ public Array_t Path$glob(Path_t path) if ((len >= 2 && glob_result.gl_pathv[i][len-1] == '.' && glob_result.gl_pathv[i][len-2] == '/') || (len >= 2 && glob_result.gl_pathv[i][len-1] == '.' && glob_result.gl_pathv[i][len-2] == '.' && glob_result.gl_pathv[i][len-3] == '/')) continue; - Array$insert(&glob_files, (Text_t[1]){Text$from_str(glob_result.gl_pathv[i])}, I(0), sizeof(Text_t)); + Path_t p = Path$from_str(glob_result.gl_pathv[i]); + Array$insert(&glob_files, &p, I(0), sizeof(Path_t)); } return glob_files; } +public PUREFUNC uint64_t Path$hash(const void *obj, const TypeInfo_t *type) +{ + (void)type; + Path_t *path = (Path_t*)obj; + siphash sh; + siphashinit(&sh, (uint64_t)path->root); + for (int64_t i = 0; i < path->components.length; i++) { + uint64_t item_hash = Text$hash(path->components.data + i*path->components.stride, &Text$info); + siphashadd64bits(&sh, item_hash); + } + return siphashfinish_last_part(&sh, (uint64_t)path->components.length); +} + +public PUREFUNC int32_t Path$compare(const void *va, const void *vb, const TypeInfo_t *type) +{ + (void)type; + Path_t *a = (Path_t*)va, *b = (Path_t*)vb; + int diff = ((int)a->root - (int)b->root); + if (diff != 0) return diff; + return Array$compare(&a->components, &b->components, Array$info(&Text$info)); +} + +public PUREFUNC bool Path$equal(const void *va, const void *vb, const TypeInfo_t *type) +{ + (void)type; + Path_t *a = (Path_t*)va, *b = (Path_t*)vb; + if (a->root != b->root) return false; + return Array$equal(&a->components, &b->components, Array$info(&Text$info)); +} + +public PUREFUNC bool Path$equal_values(Path_t a, Path_t b) +{ + if (a.root != b.root) return false; + return Array$equal(&a.components, &b.components, Array$info(&Text$info)); +} + +public const char *Path$as_c_string(Path_t path) +{ + if (path.components.length == 0) { + if (path.root == PATH_ROOT) return "/"; + else if (path.root == PATH_RELATIVE) return "."; + else if (path.root == PATH_HOME) return "~"; + } + + size_t len = 0, capacity = 16; + char *buf = GC_MALLOC_ATOMIC(capacity); + if (path.root == PATH_ROOT) { + buf[len++] = '/'; + } else if (path.root == PATH_HOME) { + buf[len++] = '~'; + buf[len++] = '/'; + } else if (path.root == PATH_RELATIVE) { + if (!Text$equal_values(*(Text_t*)path.components.data, Text(".."))) { + buf[len++] = '.'; + buf[len++] = '/'; + } + } + + for (int64_t i = 0; i < path.components.length; i++) { + Text_t *comp = (Text_t*)(path.components.data + i*path.components.stride); + const char *comp_str = Text$as_c_string(*comp); + size_t comp_len = strlen(comp_str); + if (len + comp_len + 1 > capacity) { + buf = GC_REALLOC(buf, (capacity += MIN(comp_len + 2, 16))); + } + memcpy(&buf[len], comp_str, comp_len); + len += comp_len; + if (i + 1 < path.components.length) + buf[len++] = '/'; + } + buf[len++] = '\0'; + return buf; +} + +public Text_t Path$as_text(const void *obj, bool color, const TypeInfo_t *type) +{ + (void)type; + if (!obj) return Text("Path"); + Path_t *path = (Path_t*)obj; + Text_t text = Text$join(Text("/"), path->components); + if (path->root == PATH_HOME) + text = Text$concat(path->components.length > 0 ? Text("~/") : Text("~"), text); + else if (path->root == PATH_ROOT) + text = Text$concat(Text("/"), text); + else if (path->root == PATH_RELATIVE && path->components.length > 0 && !Text$equal_values(*(Text_t*)(path->components.data), Text(".."))) + text = Text$concat(path->components.length > 0 ? Text("./") : Text("."), text); + + if (color) + text = Texts(Text("\033[32;1m"), text, Text("\033[m")); + + return text; +} + +public CONSTFUNC bool Path$is_none(const void *obj, const TypeInfo_t *type) +{ + (void)type; + return ((Path_t*)obj)->root == PATH_NONE; +} + +public void Path$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type) +{ + (void)type; + Path_t *path = (Path_t*)obj; + fputc((int)path->root, out); + Array$serialize(&path->components, out, pointers, Array$info(&Text$info)); +} + +public void Path$deserialize(FILE *in, void *obj, Array_t *pointers, const TypeInfo_t *type) +{ + (void)type; + Path_t path = {}; + path.root = fgetc(in); + Array$deserialize(in, &path.components, pointers, Array$info(&Text$info)); + *(Path_t*)obj = path; +} + public const TypeInfo_t Path$info = { .size=sizeof(Path_t), .align=__alignof__(Path_t), - .tag=TextInfo, - .TextInfo={.lang="Path"}, - .metamethods=Text$metamethods, + .tag=OpaqueInfo, + .metamethods={ + .as_text=Path$as_text, + .hash=Path$hash, + .compare=Path$compare, + .equal=Path$equal, + .is_none=Path$is_none, + .serialize=Path$serialize, + .deserialize=Path$deserialize, + } }; // vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 diff --git a/stdlib/paths.h b/stdlib/paths.h index bc26395..3efe10d 100644 --- a/stdlib/paths.h +++ b/stdlib/paths.h @@ -9,18 +9,15 @@ #include "datatypes.h" #include "optionals.h" -#define Path_t Text_t -#define OptionalPath_t Text_t -#define Path(text) ((Path_t)Text(text)) -#define Paths(...) Path$_concat(sizeof((Path_t[]){__VA_ARGS__})/sizeof(Path_t), (Path_t[]){__VA_ARGS__}) - -Path_t Path$cleanup(Path_t path); +Path_t Path$from_str(const char *str); +Path_t Path$from_text(Text_t text); +const char *Path$as_c_string(Path_t path); +#define Path(str) Path$from_str(str) Path_t Path$_concat(int n, Path_t items[n]); -#define Path$concat(a, b) Paths(a, Path("/"), b) -PUREFUNC Path_t Path$escape_text(Text_t text); -PUREFUNC Path_t Path$escape_path(Text_t path); +#define Path$concat(...) Path$_concat((int)sizeof((Path_t[]){__VA_ARGS__})/sizeof(Path_t), ((Path_t[]){__VA_ARGS__})) Path_t Path$resolved(Path_t path, Path_t relative_to); Path_t Path$relative(Path_t path, Path_t relative_to); +Path_t Path$relative_to(Path_t path, Path_t relative_to); bool Path$exists(Path_t path); bool Path$is_file(Path_t path, bool follow_symlinks); bool Path$is_directory(Path_t path, bool follow_symlinks); @@ -42,17 +39,24 @@ Array_t Path$children(Path_t path, bool include_hidden); Array_t Path$files(Path_t path, bool include_hidden); Array_t Path$subdirectories(Path_t path, bool include_hidden); Path_t Path$unique_directory(Path_t path); -Text_t Path$write_unique(Path_t path, Text_t text); -Text_t Path$write_unique_bytes(Path_t path, Array_t bytes); +Path_t Path$write_unique(Path_t path, Text_t text); +Path_t Path$write_unique_bytes(Path_t path, Array_t bytes); Path_t Path$parent(Path_t path); Text_t Path$base_name(Path_t path); Text_t Path$extension(Path_t path, bool full); +Path_t Path$with_component(Path_t path, Text_t component); +Path_t Path$with_extension(Path_t path, Text_t extension, bool replace); Closure_t Path$by_line(Path_t path); Array_t Path$glob(Path_t path); -#define Path$hash Text$hash -#define Path$compare Text$compare -#define Path$equal Text$equal +uint64_t Path$hash(const void *obj, const TypeInfo_t*); +int32_t Path$compare(const void *a, const void *b, const TypeInfo_t *type); +bool Path$equal(const void *a, const void *b, const TypeInfo_t *type); +bool Path$equal_values(Path_t a, Path_t b); +Text_t Path$as_text(const void *obj, bool color, const TypeInfo_t *type); +bool Path$is_none(const void *obj, const TypeInfo_t *type); +void Path$serialize(const void *obj, FILE *out, Table_t *pointers, const TypeInfo_t *type); +void Path$deserialize(FILE *in, void *obj, Array_t *pointers, const TypeInfo_t *type); extern const TypeInfo_t Path$info; diff --git a/stdlib/stdlib.c b/stdlib/stdlib.c index 7d13fcb..9b117a2 100644 --- a/stdlib/stdlib.c +++ b/stdlib/stdlib.c @@ -118,20 +118,7 @@ static bool parse_single_arg(const TypeInfo_t *info, char *arg, void *dest) *(OptionalNum32_t*)dest = parsed; return !isnan(parsed); } else if (info == &Path$info) { - Path_t path = Text$from_str(arg); - if (Text$equal_values(path, Path("~"))) { - path = Path("~/"); - } else if (Text$equal_values(path, Path("."))) { - path = Path("./"); - } else if (Text$equal_values(path, Path(".."))) { - path = Path("../"); - } else if (!Text$starts_with(path, Text("./")) - && !Text$starts_with(path, Text("../")) - && !Text$starts_with(path, Text("/")) - && !Text$starts_with(path, Text("~/"))) { - path = Text$concat(Text("./"), path); - } - *(OptionalText_t*)dest = path; + *(OptionalPath_t*)dest = Path$from_str(arg); return true; } else if (info->tag == TextInfo) { *(OptionalText_t*)dest = Text$from_str(arg); diff --git a/test/paths.tm b/test/paths.tm index 1a8da4c..1302f7a 100644 --- a/test/paths.tm +++ b/test/paths.tm @@ -6,14 +6,14 @@ func main(): = yes >> (~/Downloads/file(1).txt) - = (~/Downloads/file(1).txt) + = ~/Downloads/file(1).txt >> (/half\)paren) - = (/half\)paren) + = /half)paren >> filename := "example.txt" - >> (~/$filename) - = (~/example.txt) + >> (~):child(filename) + = ~/example.txt >> tmpdir := (/tmp/tomo-test-path-XXXXXX):unique_directory() >> (/tmp):subdirectories():has(tmpdir) @@ -55,7 +55,7 @@ func main(): >> p:base_name() = "qux.tar.gz" >> p:parent() - = (/foo/baz.x/) + = /foo/baz.x >> p:extension() = "tar.gz" >> p:extension(full=no) @@ -69,69 +69,62 @@ func main(): = "baz.qux" >> (/):parent() - = (/) + = / >> (~/x/.):parent() - = (~/) + = ~ >> (~/x):parent() - = (~/) - >> (./):parent() - = (../) - >> (../):parent() - = (../../) + = ~ + >> (.):parent() + = .. + >> (..):parent() + = ../.. >> (../foo):parent() - = (../) - - >> (./foo.txt):ends_with(".txt") - = yes - >> (./foo.txt):matches($|{..}/foo{..}|) - = [".", ".txt"] : [Text]? - >> (./foo.txt):replace($/.txt/, ".md") - = (./foo.md) + = .. # Concatenation tests: !! Basic relative path concatenation: >> (/foo) ++ (./baz) - = (/foo/baz) + = /foo/baz !! Concatenation with a current directory (`.`): >> (/foo/bar) ++ (./.) - = (/foo/bar) + = /foo/bar !! Trailing slash in the first path: >> (/foo/) ++ (./baz) - = (/foo/baz) + = /foo/baz !! Trailing slash in the second path: >> (/foo/bar) ++ (./baz/) - = (/foo/bar/baz/) + = /foo/bar/baz !! Removing redundant current directory (`.`): >> (/foo/bar) ++ (./baz/./qux) - = (/foo/bar/baz/qux) + = /foo/bar/baz/qux !! Removing redundant parent directory (`..`): >> (/foo/bar) ++ (./baz/qux/../quux) - = (/foo/bar/baz/quux) + = /foo/bar/baz/quux !! Collapsing `..` to navigate up: >> (/foo/bar/baz) ++ (../qux) - = (/foo/bar/qux) + = /foo/bar/qux !! Current directory and parent directory mixed: >> (/foo/bar) ++ (././../baz) - = (/foo/baz) + = /foo/baz !! Path begins with a `.`: >> (/foo) ++ (./baz/../qux) - = (/foo/qux) + = /foo/qux !! Multiple slashes: >> (/foo) ++ (./baz//qux) - = (/foo/baz/qux) + = /foo/baz/qux !! Complex path with multiple `.` and `..`: >> (/foo/bar/baz) ++ (./.././qux/./../quux) - = (/foo/bar/quux) + = /foo/bar/quux !! Globbing: >> (./*.tm):glob() diff --git a/tomo.c b/tomo.c index e65c51f..4cb024e 100644 --- a/tomo.c +++ b/tomo.c @@ -2,7 +2,6 @@ #include #include #include -#include #include #include #include @@ -30,15 +29,25 @@ #define run_cmd(...) ({ const char *_cmd = heap_strf(__VA_ARGS__); if (verbose) puts(_cmd); popen(_cmd, "w"); }) #define array_str(arr) Text$as_c_string(Text$join(Text(" "), arr)) +static const char *paths_str(Array_t paths) { + Text_t result = EMPTY_TEXT; + for (int64_t i = 0; i < paths.length; i++) { + if (i > 0) result = Texts(result, Text(" ")); + result = Texts(result, Path$as_text((Path_t*)(paths.data + i*paths.stride), false, &Path$info)); + } + return Text$as_c_string(result); +} + static OptionalArray_t files = NONE_ARRAY, - args = NONE_ARRAY; + args = NONE_ARRAY, + uninstall = NONE_ARRAY, + libraries = NONE_ARRAY; static OptionalBool_t verbose = false, stop_at_transpile = false, stop_at_obj_compilation = false, stop_at_exe_compilation = false, should_install = false, - library_mode = false, - uninstall = false; + run_repl = false; static OptionalText_t show_codegen = NONE_TEXT, @@ -50,17 +59,17 @@ static OptionalText_t ldlibs = Text("-lgc -lgmp -lm -ltomo"), ldflags = Text("-Wl,-rpath='$ORIGIN',-rpath=$HOME/.local/share/tomo/lib -L. -L$HOME/.local/share/tomo/lib"), optimization = Text("2"), - cc = Text("cc"); + cc = Text("gcc"); -static void transpile_header(env_t *base_env, Text_t filename, bool force_retranspile); -static void transpile_code(env_t *base_env, Text_t filename, bool force_retranspile); -static void compile_object_file(Text_t filename, bool force_recompile); -static Text_t compile_executable(env_t *base_env, Text_t filename, Array_t object_files, Array_t extra_ldlibs); -static void build_file_dependency_graph(Text_t filename, Table_t *to_compile, Table_t *to_link); +static void transpile_header(env_t *base_env, Path_t path, bool force_retranspile); +static void transpile_code(env_t *base_env, Path_t path, bool force_retranspile); +static void compile_object_file(Path_t path, bool force_recompile); +static Path_t compile_executable(env_t *base_env, Path_t path, Array_t object_files, Array_t extra_ldlibs); +static void build_file_dependency_graph(Path_t path, Table_t *to_compile, Table_t *to_link); static Text_t escape_lib_name(Text_t lib_name); static void build_library(Text_t lib_dir_name); static void compile_files(env_t *env, Array_t files, bool only_compile_arguments, Array_t *object_files, Array_t *ldlibs); -static bool is_stale(Path_t filename, Path_t relative_to); +static bool is_stale(Path_t path, Path_t relative_to); #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wstack-protector" @@ -99,7 +108,7 @@ int main(int argc, char *argv[]) Text_t help = Texts(Text("\x1b[1mtomo\x1b[m: a compiler for the Tomo programming language"), Text("\n\n"), usage); tomo_parse_args( argc, argv, usage, help, - {"files", true, Array$info(&Text$info), &files}, + {"files", true, Array$info(&Path$info), &files}, {"args", true, Array$info(&Text$info), &args}, {"verbose", false, &Bool$info, &verbose}, {"v", false, &Bool$info, &verbose}, @@ -109,67 +118,69 @@ int main(int argc, char *argv[]) {"c", false, &Bool$info, &stop_at_obj_compilation}, {"compile-exe", false, &Bool$info, &stop_at_exe_compilation}, {"e", false, &Bool$info, &stop_at_exe_compilation}, - {"uninstall", false, &Bool$info, &uninstall}, - {"u", false, &Bool$info, &uninstall}, - {"library", false, &Bool$info, &library_mode}, - {"L", false, &Bool$info, &library_mode}, + {"uninstall", false, Array$info(&Text$info), &uninstall}, + {"u", false, Array$info(&Text$info), &uninstall}, + {"library", false, Array$info(&Path$info), &libraries}, + {"L", false, Array$info(&Path$info), &libraries}, {"show-codegen", false, &Text$info, &show_codegen}, {"C", false, &Text$info, &show_codegen}, + {"repl", false, &Bool$info, &run_repl}, + {"R", false, &Bool$info, &run_repl}, {"install", false, &Bool$info, &should_install}, {"I", false, &Bool$info, &should_install}, {"c-compiler", false, &Text$info, &cc}, {"optimization", false, &Text$info, &optimization}, {"O", false, &Text$info, &optimization}, ); - + if (show_codegen.length > 0 && Text$equal_values(show_codegen, Text("pretty"))) show_codegen = Text("sed '/^#line/d;/^$/d' | indent -o /dev/stdout | bat -l c -P"); - if (uninstall) { - for (int64_t i = 0; i < files.length; i++) { - Text_t arg = *(Text_t*)(files.data + i*files.stride); - system(heap_strf("rm -rvf ~/.local/share/tomo/installed/%k ~/.local/share/tomo/lib/lib%k.so", - &arg, &arg)); - } - return 0; - } else if (library_mode) { - char *cwd = get_current_dir_name(); - if (files.length == 0) - files = (Array_t){.length=1, .stride=sizeof(Text_t), .data=(Text_t[]){Text(".")}}; + for (int64_t i = 0; i < uninstall.length; i++) { + Text_t *u = (Text_t*)(uninstall.data + i*uninstall.stride); + system(heap_strf("rm -rvf ~/.local/share/tomo/installed/%k ~/.local/share/tomo/lib/lib%k.so", u, u)); + printf("Uninstalled %k\n", u); + } - for (int64_t i = 0; i < files.length; i++) { - Text_t arg = *(Text_t*)(files.data + i*files.stride); - if (chdir(Text$as_c_string(arg)) != 0) - errx(1, "Could not enter directory: %k", &arg); - char *libdir = get_current_dir_name(); - char *libdirname = basename(libdir); - build_library(Text$from_str(libdirname)); - free(libdir); - chdir(cwd); - } + for (int64_t i = 0; i < libraries.length; i++) { + Path_t *lib = (Path_t*)(libraries.data + i*libraries.stride); + const char *lib_str = Path$as_c_string(*lib); + char *cwd = get_current_dir_name(); + if (chdir(lib_str) != 0) + errx(1, "Could not enter directory: %s", lib_str); + + char *libdir = get_current_dir_name(); + char *libdirname = basename(libdir); + build_library(Text$from_str(libdirname)); + free(libdir); + chdir(cwd); free(cwd); - return 0; - } else if (files.length == 0) { - if (show_codegen.length >= 0) - errx(1, "You specified to show codegen with the tool `%k` but didn't give any files", &show_codegen); + } + + // TODO: REPL + if (run_repl) { repl(); return 0; } + if (files.length <= 0 && (uninstall.length > 0 || libraries.length > 0)) { + return 0; + } + // Run file directly: if (!stop_at_transpile && !stop_at_obj_compilation && !stop_at_exe_compilation) { if (files.length < 1) errx(1, "No file specified!"); else if (files.length != 1) errx(1, "Too many files specified!"); - Text_t filename = *(Text_t*)files.data; + Path_t path = *(Path_t*)files.data; env_t *env = new_compilation_unit(NULL); Array_t object_files = {}, extra_ldlibs = {}; compile_files(env, files, false, &object_files, &extra_ldlibs); - Text_t exe_name = compile_executable(env, filename, object_files, extra_ldlibs); + Path_t exe_name = compile_executable(env, path, object_files, extra_ldlibs); char *prog_args[1 + args.length + 1]; - prog_args[0] = Text$as_c_string(exe_name); + prog_args[0] = (char*)Path$as_c_string(exe_name); for (int64_t i = 0; i < args.length; i++) prog_args[i + 1] = Text$as_c_string(*(Text_t*)(args.data + i*args.stride)); prog_args[1 + args.length] = NULL; @@ -184,10 +195,10 @@ int main(int argc, char *argv[]) return 0; for (int64_t i = 0; i < files.length; i++) { - Text_t filename = *(Text_t*)(files.data + i*files.stride); - Text_t bin_name = compile_executable(env, filename, object_files, extra_ldlibs); + Path_t path = *(Path_t*)(files.data + i*files.stride); + Path_t bin_name = compile_executable(env, path, object_files, extra_ldlibs); if (should_install) - system(heap_strf("cp -v '%k' ~/.local/bin/", &bin_name)); + system(heap_strf("cp -v '%s' ~/.local/bin/", Path$as_c_string(bin_name))); } return 0; } @@ -248,15 +259,15 @@ static void _make_typedefs_for_library(libheader_info_t *info, ast_t *ast) } } -static void _compile_file_header_for_library(env_t *env, Text_t filename, Table_t *visited_files, Table_t *used_imports, FILE *output) +static void _compile_file_header_for_library(env_t *env, Path_t path, Table_t *visited_files, Table_t *used_imports, FILE *output) { - if (Table$get(*visited_files, &filename, Table$info(&Text$info, &Bool$info))) + if (Table$get(*visited_files, &path, Table$info(&Path$info, &Bool$info))) return; - Table$set(visited_files, &filename, ((Bool_t[1]){1}), Table$info(&Text$info, &Bool$info)); + Table$set(visited_files, &path, ((Bool_t[1]){1}), Table$info(&Path$info, &Bool$info)); - ast_t *file_ast = parse_file(Text$as_c_string(filename), NULL); - if (!file_ast) errx(1, "Could not parse file %k", &filename); + ast_t *file_ast = parse_file(Path$as_c_string(path), NULL); + if (!file_ast) errx(1, "Could not parse file %s", Path$as_c_string(path)); env_t *module_env = load_module_env(env, file_ast); libheader_info_t info = { @@ -274,7 +285,7 @@ static void _compile_file_header_for_library(env_t *env, Text_t filename, Table_ auto use = Match(ast, Use); if (use->what == USE_LOCAL) { - Path_t resolved = Path$resolved(Text$from_str(use->path), Path("./")); + Path_t resolved = Path$resolved(Path$from_str(use->path), Path("./")); _compile_file_header_for_library(env, resolved, visited_files, used_imports, output); } } @@ -289,19 +300,11 @@ static void _compile_file_header_for_library(env_t *env, Text_t filename, Table_ void build_library(Text_t lib_dir_name) { - glob_t tm_files; - char *library_directory = get_current_dir_name(); - if (glob("[!._0-9]*.tm", 0, NULL, &tm_files) != 0) - errx(1, "Couldn't get .tm files in directory: %s", library_directory); - - Array_t glob_files = {}; - for (size_t i = 0; i < tm_files.gl_pathc; i++) - Array$insert(&glob_files, (Text_t[1]){Text$from_str(tm_files.gl_pathv[i])}, I(0), sizeof(Text_t)); - + Array_t tm_files = Path$glob(Path("./[!._0-9]*.tm")); env_t *env = new_compilation_unit(NULL); Array_t object_files = {}, extra_ldlibs = {}; - compile_files(env, glob_files, false, &object_files, &extra_ldlibs); + compile_files(env, tm_files, false, &object_files, &extra_ldlibs); // Library name replaces all stretchs of non-alphanumeric chars with an underscore // So e.g. https://github.com/foo/baz --> https_github_com_foo_baz @@ -313,9 +316,9 @@ void build_library(Text_t lib_dir_name) fputs("#include \n", header); Table_t visited_files = {}; Table_t used_imports = {}; - for (size_t i = 0; i < tm_files.gl_pathc; i++) { - const char *filename = tm_files.gl_pathv[i]; - Path_t resolved = Path$resolved(Text$from_str(filename), Path(".")); + for (int64_t i = 0; i < tm_files.length; i++) { + Path_t f = *(Path_t*)(tm_files.data + i*tm_files.stride); + Path_t resolved = Path$resolved(f, Path(".")); _compile_file_header_for_library(env, resolved, &visited_files, &used_imports, header); } if (fclose(header) == -1) @@ -324,20 +327,18 @@ void build_library(Text_t lib_dir_name) // Build up a list of symbol renamings: unlink("symbol_renames.txt"); FILE *prog; - for (size_t i = 0; i < tm_files.gl_pathc; i++) { - const char *filename = tm_files.gl_pathv[i]; + for (int64_t i = 0; i < tm_files.length; i++) { + Path_t f = *(Path_t*)(tm_files.data + i*tm_files.stride); prog = run_cmd("nm -Ug -fjust-symbols '%s.o' | sed 's/_\\$\\(.*\\)/\\0 _$%s$\\1/' >>symbol_renames.txt", - filename, CORD_to_const_char_star(env->libname)); + Path$as_c_string(f), CORD_to_const_char_star(env->libname)); int status = pclose(prog); if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) errx(WEXITSTATUS(status), "Failed to create symbol rename table with `nm` and `sed`"); } - globfree(&tm_files); - prog = run_cmd("%k -O%k %k %k %k %s -Wl,-soname='lib%k.so' -shared %s -o 'lib%k.so'", &cc, &optimization, &cflags, &ldflags, &ldlibs, array_str(extra_ldlibs), &lib_dir_name, - array_str(object_files), &lib_dir_name); + paths_str(object_files), &lib_dir_name); if (!prog) errx(1, "Failed to run C compiler: %k", &cc); int status = pclose(prog); @@ -363,6 +364,7 @@ void build_library(Text_t lib_dir_name) unlink("symbol_renames.txt"); if (should_install) { + char *library_directory = get_current_dir_name(); const char *dest = heap_strf("%s/.local/share/tomo/installed/%k", getenv("HOME"), &lib_dir_name); if (!streq(library_directory, dest)) { system(heap_strf("rm -rvf '%s'", dest)); @@ -372,9 +374,8 @@ void build_library(Text_t lib_dir_name) system("mkdir -p ~/.local/share/tomo/lib/"); system(heap_strf("ln -fv -s ../installed/'%k'/lib'%k'.so ~/.local/share/tomo/lib/lib'%k'.so", &lib_dir_name, &lib_dir_name, &lib_dir_name)); + free(library_directory); } - - free(library_directory); } void compile_files(env_t *env, Array_t to_compile, bool only_compile_arguments, Array_t *object_files, Array_t *extra_ldlibs) @@ -385,11 +386,12 @@ void compile_files(env_t *env, Array_t to_compile, bool only_compile_arguments, Table_t dependency_files = {}; for (int64_t i = 0; i < to_compile.length; i++) { Path_t filename = *(Path_t*)(to_compile.data + i*to_compile.stride); - if (!Text$ends_with(filename, Text(".tm"))) - errx(1, "Not a valid .tm file: \x1b[31;1m%k\x1b[m", &filename); + Text_t extension = Path$extension(filename, true); + if (!Text$equal_values(extension, Text("tm"))) + errx(1, "Not a valid .tm file: \x1b[31;1m%s\x1b[m", Path$as_c_string(filename)); Path_t resolved = Path$resolved(filename, Path("./")); if (!Path$is_file(resolved, true)) - errx(1, "Couldn't find file: %k", &resolved); + errx(1, "Couldn't find file: %s", Path$as_c_string(resolved)); Table$set(&argument_files, &resolved, &filename, path_table_info); build_file_dependency_graph(resolved, &dependency_files, &to_link); } @@ -438,10 +440,9 @@ void compile_files(env_t *env, Array_t to_compile, bool only_compile_arguments, if (object_files) { for (int64_t i = 0; i < dependency_files.entries.length; i++) { - Path_t filename = Text$concat( - *(Path_t*)(dependency_files.entries.data + i*dependency_files.entries.stride), - Text(".o")); - Array$insert(object_files, &filename, I(0), sizeof(Path_t)); + Path_t path = *(Path_t*)(dependency_files.entries.data + i*dependency_files.entries.stride); + path = Path$with_extension(path, Text(".o"), false); + Array$insert(object_files, &path, I(0), sizeof(Path_t)); } } if (extra_ldlibs) { @@ -452,19 +453,19 @@ void compile_files(env_t *env, Array_t to_compile, bool only_compile_arguments, } } -void build_file_dependency_graph(Text_t filename, Table_t *to_compile, Table_t *to_link) +void build_file_dependency_graph(Path_t path, Table_t *to_compile, Table_t *to_link) { - if (Table$get(*to_compile, &filename, Table$info(&Text$info, &Bool$info))) + if (Table$get(*to_compile, &path, Table$info(&Path$info, &Bool$info))) return; - bool stale = is_stale(Paths(filename, Path(".o")), filename); - Table$set(to_compile, &filename, &stale, Table$info(&Text$info, &Bool$info)); + bool stale = is_stale(Path$with_extension(path, Text(".o"), false), path); + Table$set(to_compile, &path, &stale, Table$info(&Path$info, &Bool$info)); - assert(Text$ends_with(filename, Text(".tm"))); + assert(Text$equal_values(Path$extension(path, true), Text("tm"))); - ast_t *ast = parse_file(Text$as_c_string(filename), NULL); + ast_t *ast = parse_file(Path$as_c_string(path), NULL); if (!ast) - errx(1, "Could not parse file %k", &filename); + errx(1, "Could not parse file %s", Path$as_c_string(path)); for (ast_list_t *stmt = Match(ast, Block)->statements; stmt; stmt = stmt->next) { ast_t *stmt_ast = stmt->ast; @@ -476,10 +477,10 @@ void build_file_dependency_graph(Text_t filename, Table_t *to_compile, Table_t * switch (use->what) { case USE_LOCAL: { - Text_t resolved = Path$resolved(Text$from_str(use->path), filename); - if (!stale && is_stale(Texts(filename, Text(".o")), resolved)) { + Path_t resolved = Path$resolved(Path$from_str(use->path), Path$parent(path)); + if (!stale && is_stale(Path$with_extension(path, Text(".o"), false), resolved)) { stale = true; - Table$set(to_compile, &filename, &stale, Table$info(&Text$info, &Bool$info)); + Table$set(to_compile, &path, &stale, Table$info(&Path$info, &Bool$info)); } if (Table$get(*to_compile, &resolved, Table$info(&Path$info, &Path$info))) continue; @@ -506,60 +507,60 @@ void build_file_dependency_graph(Text_t filename, Table_t *to_compile, Table_t * } } -bool is_stale(Path_t filename, Path_t relative_to) +bool is_stale(Path_t path, Path_t relative_to) { struct stat target_stat; - if (stat(Text$as_c_string(filename), &target_stat) != 0) + if (stat(Path$as_c_string(path), &target_stat) != 0) return true; struct stat relative_to_stat; - if (stat(Text$as_c_string(relative_to), &relative_to_stat) != 0) - errx(1, "File doesn't exist: %k", &relative_to); + if (stat(Path$as_c_string(relative_to), &relative_to_stat) != 0) + errx(1, "File doesn't exist: %s", Path$as_c_string(relative_to)); return target_stat.st_mtime < relative_to_stat.st_mtime; } -void transpile_header(env_t *base_env, Text_t filename, bool force_retranspile) +void transpile_header(env_t *base_env, Path_t path, bool force_retranspile) { - Text_t h_filename = Text$concat(filename, Text(".h")); - if (!force_retranspile && !is_stale(h_filename, filename)) + Path_t h_filename = Path$with_extension(path, Text(".h"), false); + if (!force_retranspile && !is_stale(h_filename, path)) return; - ast_t *ast = parse_file(Text$as_c_string(filename), NULL); + ast_t *ast = parse_file(Path$as_c_string(path), NULL); if (!ast) - errx(1, "Could not parse file %k", &filename); + errx(1, "Could not parse file %s", Path$as_c_string(path)); env_t *module_env = load_module_env(base_env, ast); CORD h_code = compile_file_header(module_env, ast); - FILE *header = fopen(Text$as_c_string(h_filename), "w"); + FILE *header = fopen(Path$as_c_string(h_filename), "w"); CORD_put(h_code, header); if (fclose(header) == -1) - errx(1, "Failed to write header file: %k", &h_filename); + errx(1, "Failed to write header file: %s", Path$as_c_string(h_filename)); if (verbose) - printf("\x1b[2mTranspiled to %k\x1b[m\n", &h_filename); + printf("\x1b[2mTranspiled to %s\x1b[m\n", Path$as_c_string(h_filename)); if (show_codegen.length > 0) - system(heap_strf("<%k %k", &h_filename, &show_codegen)); + system(heap_strf("<%s %k", Path$as_c_string(h_filename), &show_codegen)); } -void transpile_code(env_t *base_env, Text_t filename, bool force_retranspile) +void transpile_code(env_t *base_env, Path_t path, bool force_retranspile) { - Text_t c_filename = Text$concat(filename, Text(".c")); - if (!force_retranspile && !is_stale(c_filename, filename)) + Path_t c_filename = Path$with_extension(path, Text(".c"), false); + if (!force_retranspile && !is_stale(c_filename, path)) return; - ast_t *ast = parse_file(Text$as_c_string(filename), NULL); + ast_t *ast = parse_file(Path$as_c_string(path), NULL); if (!ast) - errx(1, "Could not parse file %k", &filename); + errx(1, "Could not parse file %s", Path$as_c_string(path)); env_t *module_env = load_module_env(base_env, ast); CORD c_code = compile_file(module_env, ast); - FILE *c_file = fopen(Text$as_c_string(c_filename), "w"); + FILE *c_file = fopen(Path$as_c_string(c_filename), "w"); if (!c_file) - errx(1, "Failed to write C file: %k", &c_filename); + errx(1, "Failed to write C file: %s", Path$as_c_string(c_filename)); CORD_put(c_code, c_file); @@ -581,28 +582,28 @@ void transpile_code(env_t *base_env, Text_t filename, bool force_retranspile) } if (fclose(c_file) == -1) - errx(1, "Failed to output C code to %k", &c_filename); + errx(1, "Failed to output C code to %s", Path$as_c_string(c_filename)); if (verbose) - printf("\x1b[2mTranspiled to %k\x1b[m\n", &c_filename); + printf("\x1b[2mTranspiled to %s\x1b[m\n", Path$as_c_string(c_filename)); if (show_codegen.length > 0) - system(heap_strf("<%k %k", &c_filename, &show_codegen)); + system(heap_strf("<%s %k", Path$as_c_string(c_filename), &show_codegen)); } -void compile_object_file(Text_t filename, bool force_recompile) +void compile_object_file(Path_t path, bool force_recompile) { - Text_t obj_file = Text$concat(filename, Text(".o")); - Text_t c_file = Text$concat(filename, Text(".c")); - Text_t h_file = Text$concat(filename, Text(".h")); - if (!force_recompile && !is_stale(obj_file, filename) + Path_t obj_file = Path$with_extension(path, Text(".o"), false); + Path_t c_file = Path$with_extension(path, Text(".c"), false); + Path_t h_file = Path$with_extension(path, Text(".h"), false); + if (!force_recompile && !is_stale(obj_file, path) && !is_stale(obj_file, c_file) && !is_stale(obj_file, h_file)) { return; } - FILE *prog = run_cmd("%k %k -O%k -c %k -o %k", - &cc, &cflags, &optimization, &c_file, &obj_file); + FILE *prog = run_cmd("%k %k -O%k -c %s -o %s", + &cc, &cflags, &optimization, Path$as_c_string(c_file), Path$as_c_string(obj_file)); if (!prog) errx(1, "Failed to run C compiler: %k", &cc); int status = pclose(prog); @@ -610,23 +611,23 @@ void compile_object_file(Text_t filename, bool force_recompile) exit(EXIT_FAILURE); if (verbose) - printf("\x1b[2mCompiled to %k\x1b[m\n", &obj_file); + printf("\x1b[2mCompiled to %s\x1b[m\n", Path$as_c_string(obj_file)); } -Text_t compile_executable(env_t *base_env, Text_t filename, Array_t object_files, Array_t extra_ldlibs) +Path_t compile_executable(env_t *base_env, Path_t path, Array_t object_files, Array_t extra_ldlibs) { - ast_t *ast = parse_file(Text$as_c_string(filename), NULL); + ast_t *ast = parse_file(Path$as_c_string(path), NULL); if (!ast) - errx(1, "Could not parse file %k", &filename); + errx(1, "Could not parse file %s", Path$as_c_string(path)); env_t *env = load_module_env(base_env, ast); binding_t *main_binding = get_binding(env, "main"); if (!main_binding || main_binding->type->tag != FunctionType) - errx(1, "No main() function has been defined for %k, so it can't be run!", &filename); + errx(1, "No main() function has been defined for %s, so it can't be run!", Path$as_c_string(path)); - Text_t bin_name = Text$trim(filename, Text(".tm"), false, true); - FILE *runner = run_cmd("%k %k -O%k %k %k %s %s -x c - -o %k", + Path_t bin_name = Path$with_extension(path, Text(""), true); + FILE *runner = run_cmd("%k %k -O%k %k %k %s %s -x c - -o %s", &cc, &cflags, &optimization, &ldflags, &ldlibs, - array_str(extra_ldlibs), array_str(object_files), &bin_name); + array_str(extra_ldlibs), paths_str(object_files), Path$as_c_string(bin_name)); CORD program = CORD_all( "extern int ", main_binding->code, "$parse_and_run(int argc, char *argv[]);\n" "int main(int argc, char *argv[]) {\n" @@ -634,6 +635,10 @@ Text_t compile_executable(env_t *base_env, Text_t filename, Array_t object_files "}\n" ); + FILE *xxx = fopen("runner.c", "w"); + CORD_put(program, xxx); + fclose(xxx); + if (show_codegen.length > 0) { FILE *out = run_cmd("%k", &show_codegen); CORD_put(program, out); @@ -646,7 +651,7 @@ Text_t compile_executable(env_t *base_env, Text_t filename, Array_t object_files exit(EXIT_FAILURE); if (verbose) - printf("\x1b[2mCompiled executable: %k\x1b[m\n", &bin_name); + printf("\x1b[2mCompiled executable: %s\x1b[m\n", Path$as_c_string(bin_name)); return bin_name; } diff --git a/typecheck.c b/typecheck.c index c5ca64c..11b2d6d 100644 --- a/typecheck.c +++ b/typecheck.c @@ -638,6 +638,7 @@ type_t *get_type(env_t *env, ast_t *ast) return Match(t, OptionalType)->type; } case TextLiteral: return TEXT_TYPE; + case Path: return PATH_TYPE; case TextJoin: { const char *lang = Match(ast, TextJoin)->lang; if (lang) { @@ -1050,7 +1051,7 @@ type_t *get_type(env_t *env, ast_t *ast) return lhs_t; break; } - case BINOP_PLUS: case BINOP_MINUS: case BINOP_AND: case BINOP_OR: case BINOP_XOR: { + case BINOP_PLUS: case BINOP_MINUS: case BINOP_AND: case BINOP_OR: case BINOP_XOR: case BINOP_CONCAT: { if (type_eq(lhs_t, rhs_t) && binding_works(binop_method_names[binop->op], binop->lhs, lhs_t, rhs_t, lhs_t)) return lhs_t; break; diff --git a/types.c b/types.c index 358a729..eaecad2 100644 --- a/types.c +++ b/types.c @@ -494,6 +494,7 @@ PUREFUNC size_t unpadded_struct_size(type_t *t) PUREFUNC size_t type_size(type_t *t) { if (t == THREAD_TYPE) return sizeof(pthread_t*); + if (t == PATH_TYPE) return sizeof(Path_t); #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wswitch-default" switch (t->tag) { @@ -579,6 +580,7 @@ PUREFUNC size_t type_size(type_t *t) PUREFUNC size_t type_align(type_t *t) { if (t == THREAD_TYPE) return __alignof__(pthread_t*); + if (t == PATH_TYPE) return __alignof__(Path_t); #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wswitch-default" switch (t->tag) {