diff options
Diffstat (limited to 'src/tomo.c')
| -rw-r--r-- | src/tomo.c | 726 |
1 files changed, 726 insertions, 0 deletions
diff --git a/src/tomo.c b/src/tomo.c new file mode 100644 index 00000000..e99f42d9 --- /dev/null +++ b/src/tomo.c @@ -0,0 +1,726 @@ +// The main program that runs compilation +#include <ctype.h> +#include <errno.h> +#include <gc.h> +#include <gc/cord.h> +#include <libgen.h> +#include <printf.h> +#include <spawn.h> +#include <stdio.h> +#include <stdlib.h> +#include <sys/stat.h> +#include <sys/wait.h> + +#include "ast.h" +#include "compile.h" +#include "cordhelpers.h" +#include "parse.h" +#include "repl.h" +#include "stdlib/arrays.h" +#include "stdlib/bools.h" +#include "stdlib/bytes.h" +#include "stdlib/datatypes.h" +#include "stdlib/integers.h" +#include "stdlib/optionals.h" +#include "stdlib/patterns.h" +#include "stdlib/paths.h" +#include "stdlib/text.h" +#include "typecheck.h" +#include "types.h" + +#define run_cmd(...) ({ const char *_cmd = heap_strf(__VA_ARGS__); if (verbose) printf("\033[34;1m%s\033[m\n", _cmd); popen(_cmd, "w"); }) +#define array_str(arr) Text$as_c_string(Text$join(Text(" "), arr)) + +static struct stat compiler_stat; + +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, + uninstall = NONE_ARRAY, + libraries = NONE_ARRAY; +static OptionalBool_t verbose = false, + quiet = false, + stop_at_transpile = false, + stop_at_obj_compilation = false, + compile_exe = false, + should_install = false, + run_repl = false, + clean_build = false; + +static OptionalText_t + show_codegen = NONE_TEXT, + cflags = Text("-Werror -fdollars-in-identifiers -std=gnu11 -Wno-trigraphs -fsanitize=signed-integer-overflow -fno-sanitize-recover" + " -fno-signed-zeros -fno-finite-math-only -fno-signaling-nans -fno-trapping-math" + " -D_XOPEN_SOURCE=700 -D_POSIX_C_SOURCE=200809L -D_DEFAULT_SOURCE -fPIC -ggdb" + " -DGC_THREADS" + " -I$HOME/.local/share/tomo/installed"), + 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("gcc"); + +static void transpile_header(env_t *base_env, Path_t path); +static void transpile_code(env_t *base_env, Path_t path); +static void compile_object_file(Path_t path); +static Path_t compile_executable(env_t *base_env, Path_t path, Path_t exe_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, Array_t *object_files, Array_t *ldlibs); +static bool is_stale(Path_t path, Path_t relative_to); + +typedef struct { + bool h:1, c:1, o:1; +} staleness_t; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstack-protector" +int main(int argc, char *argv[]) +{ + // Get the file modification time of the compiler, so we + // can recompile files after changing the compiler: + if (stat(argv[0], &compiler_stat) != 0) + err(1, "Could not find age of compiler"); + + if (register_printf_specifier('T', printf_type, printf_pointer_size)) + errx(1, "Couldn't set printf specifier"); + if (register_printf_specifier('W', printf_ast, printf_pointer_size)) + errx(1, "Couldn't set printf specifier"); + if (register_printf_specifier('k', printf_text, printf_text_size)) + errx(1, "Couldn't set printf specifier"); + + // Run a tool: + if ((streq(argv[1], "-r") || streq(argv[1], "--run")) && argc >= 3) { + if (strcspn(argv[2], "/;$") == strlen(argv[2])) { + const char *program = heap_strf("%s/.local/share/tomo/installed/%s/%s", getenv("HOME"), argv[2], argv[2]); + execv(program, &argv[2]); + } + errx(1, "This is not an installed tomo program: \033[31;1m%s\033[m", argv[2]); + } + + Text_t usage = Text("\x1b[33;4;1mUsage:\x1b[m\n" + "\x1b[1mRun a program:\x1b[m tomo file.tm [-- args...]\n" + "\x1b[1mTranspile files:\x1b[m tomo -t file.tm...\n" + "\x1b[1mCompile object files:\x1b[m tomo -c file.tm...\n" + "\x1b[1mCompile executables:\x1b[m tomo -e file.tm...\n" + "\x1b[1mBuild libraries:\x1b[m tomo -L lib...\n" + "\x1b[1mUninstall libraries:\x1b[m tomo -u lib...\n" + "\x1b[1mOther flags:\x1b[m\n" + " --verbose|-v: verbose output\n" + " --quiet|-q: quiet output\n" + " --install|-I: install the executable or library\n" + " --c-compiler <compiler>: the C compiler to use (default: cc)\n" + " --optimization|-O <level>: set optimization level\n" + " --run|-r: run a program from ~/.local/share/tomo/installed\n" + ); + 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(&Path$info), &files}, + {"args", true, Array$info(&Text$info), &args}, + {"verbose", false, &Bool$info, &verbose}, + {"v", false, &Bool$info, &verbose}, + {"quiet", false, &Bool$info, &quiet}, + {"q", false, &Bool$info, &quiet}, + {"transpile", false, &Bool$info, &stop_at_transpile}, + {"t", false, &Bool$info, &stop_at_transpile}, + {"compile-obj", false, &Bool$info, &stop_at_obj_compilation}, + {"c", false, &Bool$info, &stop_at_obj_compilation}, + {"compile-exe", false, &Bool$info, &compile_exe}, + {"e", false, &Bool$info, &compile_exe}, + {"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}, + {"force-rebuild", false, &Bool$info, &clean_build}, + {"f", false, &Bool$info, &clean_build}, + ); + + 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"); + + 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 < 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); + } + + // TODO: REPL + if (run_repl) { + repl(); + return 0; + } + + if (files.length <= 0 && (uninstall.length > 0 || libraries.length > 0)) { + return 0; + } + + // Convert `foo` to `foo/foo.tm` + for (int64_t i = 0; i < files.length; i++) { + Path_t *path = (Path_t*)(files.data + i*files.stride); + if (Path$is_directory(*path, true)) + *path = Path$with_component(*path, Texts(Path$base_name(*path), Text(".tm"))); + } + + if (files.length < 1) + errx(1, "No file specified!"); + else if (files.length != 1) + errx(1, "Too many files specified!"); + + quiet = !verbose; + + for (int64_t i = 0; i < files.length; i++) { + Path_t path = *(Path_t*)(files.data + i*files.stride); + Path_t exe_path = compile_exe ? Path$with_extension(path, Text(""), true) + : Path$write_unique_bytes(Path("/tmp/tomo-exe-XXXXXX"), (Array_t){}); + + pid_t child = fork(); + if (child == 0) { + env_t *env = global_env(); + Array_t object_files = {}, + extra_ldlibs = {}; + compile_files(env, files, &object_files, &extra_ldlibs); + compile_executable(env, path, exe_path, object_files, extra_ldlibs); + + if (compile_exe) + _exit(0); + + char *prog_args[1 + args.length + 1]; + prog_args[0] = (char*)Path$as_c_string(exe_path); + for (int64_t j = 0; j < args.length; j++) + prog_args[j + 1] = Text$as_c_string(*(Text_t*)(args.data + j*args.stride)); + prog_args[1 + args.length] = NULL; + execv(prog_args[0], prog_args); + err(1, "Could not execute program: %s", prog_args[0]); + } + + int status; + while (waitpid(child, &status, 0) < 0 && errno == EINTR) { + if (WIFEXITED(status) || WIFSIGNALED(status)) + break; + else if (WIFSTOPPED(status)) + kill(child, SIGCONT); + } + + if (!compile_exe) + Path$remove(exe_path, true); + + if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) { + _exit(WIFEXITED(status) ? WEXITSTATUS(status) : EXIT_FAILURE); + } + } + + if (compile_exe && should_install) { + for (int64_t i = 0; i < files.length; i++) { + Path_t path = *(Path_t*)(files.data + i*files.stride); + Path_t exe = Path$with_extension(path, Text(""), true); + system(heap_strf("cp -v '%s' ~/.local/bin/", Path$as_c_string(exe))); + } + } + return 0; +} +#pragma GCC diagnostic pop + +Text_t escape_lib_name(Text_t lib_name) +{ + return Text$replace(lib_name, Pattern("{1+ !alphanumeric}"), Text("_"), Pattern(""), false); +} + +static Path_t build_file(Path_t path, const char *extension) +{ + Path_t build_dir = Path$with_component(Path$parent(path), Text(".build")); + if (mkdir(Path$as_c_string(build_dir), 0777) != 0) { + if (errno != EEXIST) + err(1, "Could not make .build directory"); + } + return Path$with_component(build_dir, Texts(Path$base_name(path), Text$from_str(extension))); +} + +typedef struct { + env_t *env; + Table_t *used_imports; + FILE *output; +} libheader_info_t; + +static void _compile_statement_header_for_library(libheader_info_t *info, ast_t *ast) +{ + if (ast->tag == Declare && Match(ast, Declare)->value->tag == Use) + ast = Match(ast, Declare)->value; + + if (ast->tag == Use) { + auto use = Match(ast, Use); + if (use->what == USE_LOCAL) + return; + + Path_t path = Path$from_str(use->path); + if (!Table$get(*info->used_imports, &path, Table$info(&Path$info, &Path$info))) { + Table$set(info->used_imports, &path, ((Bool_t[1]){1}), Table$info(&Text$info, &Bool$info)); + CORD_put(compile_statement_type_header(info->env, ast), info->output); + CORD_put(compile_statement_namespace_header(info->env, ast), info->output); + } + } else { + CORD_put(compile_statement_type_header(info->env, ast), info->output); + CORD_put(compile_statement_namespace_header(info->env, ast), info->output); + } +} + +static void _make_typedefs_for_library(libheader_info_t *info, ast_t *ast) +{ + if (ast->tag == StructDef) { + auto def = Match(ast, StructDef); + CORD full_name = CORD_cat(namespace_prefix(info->env, info->env->namespace), def->name); + CORD_put(CORD_all("typedef struct ", full_name, "$$struct ", full_name, "$$type;\n"), info->output); + } else if (ast->tag == EnumDef) { + auto def = Match(ast, EnumDef); + CORD full_name = CORD_cat(namespace_prefix(info->env, info->env->namespace), def->name); + CORD_put(CORD_all("typedef struct ", full_name, "$$struct ", full_name, "$$type;\n"), info->output); + + for (tag_ast_t *tag = def->tags; tag; tag = tag->next) { + if (!tag->fields) continue; + CORD_put(CORD_all("typedef struct ", full_name, "$", tag->name, "$$struct ", full_name, "$", tag->name, "$$type;\n"), info->output); + } + } else if (ast->tag == LangDef) { + auto def = Match(ast, LangDef); + CORD_put(CORD_all("typedef Text_t ", namespace_prefix(info->env, info->env->namespace), def->name, "$$type;\n"), info->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, &path, Table$info(&Path$info, &Bool$info))) + return; + + Table$set(visited_files, &path, ((Bool_t[1]){1}), Table$info(&Path$info, &Bool$info)); + + 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 = { + .env=module_env, + .used_imports=used_imports, + .output=output, + }; + + // Visit files in topological order: + for (ast_list_t *stmt = Match(file_ast, Block)->statements; stmt; stmt = stmt->next) { + ast_t *ast = stmt->ast; + if (ast->tag == Declare) + ast = Match(ast, Declare)->value; + if (ast->tag != Use) continue; + + auto use = Match(ast, Use); + if (use->what == USE_LOCAL) { + Path_t resolved = Path$resolved(Path$from_str(use->path), Path("./")); + _compile_file_header_for_library(env, resolved, visited_files, used_imports, output); + } + } + + visit_topologically( + Match(file_ast, Block)->statements, (Closure_t){.fn=(void*)_make_typedefs_for_library, &info}); + visit_topologically( + Match(file_ast, Block)->statements, (Closure_t){.fn=(void*)_compile_statement_header_for_library, &info}); + + CORD_fprintf(output, "void %r$initialize(void);\n", namespace_prefix(module_env, module_env->namespace)); +} + +void build_library(Text_t lib_dir_name) +{ + Array_t tm_files = Path$glob(Path("./[!._0-9]*.tm")); + env_t *env = fresh_scope(global_env()); + Array_t object_files = {}, + extra_ldlibs = {}; + compile_files(env, tm_files, &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 + env->libname = Text$as_c_string(escape_lib_name(lib_dir_name)); + + // Build a "whatever.h" header that loads all the headers: + FILE *header = fopen(heap_strf("%k.h", &lib_dir_name), "w"); + fputs("#pragma once\n", header); + fputs("#include <tomo/tomo.h>\n", header); + Table_t visited_files = {}; + Table_t used_imports = {}; + 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) + errx(1, "Failed to write header file: %k.h", &lib_dir_name); + + // Build up a list of symbol renamings: + unlink(".build/symbol_renames.txt"); + FILE *prog; + 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' | sed -n 's/_\\$\\(.*\\)/\\0 _$%s$\\1/p' >>.build/symbol_renames.txt", + Path$as_c_string(build_file(f, ".o")), CORD_to_const_char_star(env->libname)); + if (!prog) errx(1, "Could not find symbols!"); + int status = pclose(prog); + if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) + errx(WEXITSTATUS(status), "Failed to create symbol rename table with `nm` and `sed`"); + } + + 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, + paths_str(object_files), &lib_dir_name); + if (!prog) + errx(1, "Failed to run C compiler: %k", &cc); + int status = pclose(prog); + if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) + exit(EXIT_FAILURE); + + if (!quiet) + printf("Compiled library:\tlib%k.so\n", &lib_dir_name); + + prog = run_cmd("objcopy --redefine-syms=.build/symbol_renames.txt 'lib%k.so'", &lib_dir_name); + status = pclose(prog); + if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) + errx(WEXITSTATUS(status), "Failed to run `objcopy` to add library prefix to symbols"); + + prog = run_cmd("patchelf --rename-dynamic-symbols .build/symbol_renames.txt 'lib%k.so'", &lib_dir_name); + status = pclose(prog); + if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) + errx(WEXITSTATUS(status), "Failed to run `patchelf` to rename dynamic symbols with library prefix"); + + if (verbose) + CORD_printf("Successfully renamed symbols with library prefix!\n"); + + // unlink(".build/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 -rf '%s'", dest)); + system(heap_strf("mkdir -p '%s'", dest)); + system(heap_strf("cp -r * '%s/'", dest)); + } + system("mkdir -p ~/.local/share/tomo/lib/"); + system(heap_strf("ln -f -s ../installed/'%k'/lib'%k'.so ~/.local/share/tomo/lib/lib'%k'.so", + &lib_dir_name, &lib_dir_name, &lib_dir_name)); + printf("Installed \033[1m%k\033[m to ~/.local/share/tomo/installed\n", &lib_dir_name); + free(library_directory); + } +} + +void compile_files(env_t *env, Array_t to_compile, Array_t *object_files, Array_t *extra_ldlibs) +{ + Table_t to_link = {}; + 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); + 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: %s", Path$as_c_string(resolved)); + build_file_dependency_graph(resolved, &dependency_files, &to_link); + } + + int status; + // (Re)compile header files, eagerly for explicitly passed in files, lazily + // for downstream dependencies: + for (int64_t i = 0; i < dependency_files.entries.length; i++) { + struct { + Path_t filename; + staleness_t staleness; + } *entry = (dependency_files.entries.data + i*dependency_files.entries.stride); + if (entry->staleness.h) { + transpile_header(env, entry->filename); + entry->staleness.o = true; + } + } + + env->imports = new(Table_t); + + struct child_s { + struct child_s *next; + pid_t pid; + } *child_processes = NULL; + + // (Re)transpile and compile object files, eagerly for files explicitly + // specified and lazily for downstream dependencies: + for (int64_t i = 0; i < dependency_files.entries.length; i++) { + struct { + Path_t filename; + staleness_t staleness; + } *entry = (dependency_files.entries.data + i*dependency_files.entries.stride); + if (!clean_build && !entry->staleness.c && !entry->staleness.h) + continue; + + pid_t pid = fork(); + if (pid == 0) { + transpile_code(env, entry->filename); + if (!stop_at_transpile) + compile_object_file(entry->filename); + _exit(EXIT_SUCCESS); + } + child_processes = new(struct child_s, .next=child_processes, .pid=pid); + } + + for (; child_processes; child_processes = child_processes->next) { + waitpid(child_processes->pid, &status, 0); + if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) + exit(EXIT_FAILURE); + else if (WIFSTOPPED(status)) + kill(child_processes->pid, SIGCONT); + } + + if (object_files) { + for (int64_t i = 0; i < dependency_files.entries.length; i++) { + Path_t path = *(Path_t*)(dependency_files.entries.data + i*dependency_files.entries.stride); + path = build_file(path, ".o"); + Array$insert(object_files, &path, I(0), sizeof(Path_t)); + } + } + if (extra_ldlibs) { + for (int64_t i = 0; i < to_link.entries.length; i++) { + Text_t lib = *(Text_t*)(to_link.entries.data + i*to_link.entries.stride); + Array$insert(extra_ldlibs, &lib, I(0), sizeof(Text_t)); + } + } +} + +void build_file_dependency_graph(Path_t path, Table_t *to_compile, Table_t *to_link) +{ + if (Table$get(*to_compile, &path, Table$info(&Path$info, &Byte$info))) + return; + + staleness_t staleness = { + .h=is_stale(build_file(path, ".h"), path), + .c=is_stale(build_file(path, ".c"), path), + }; + staleness.o = staleness.c || staleness.h + || is_stale(build_file(path, ".o"), build_file(path, ".c")) + || is_stale(build_file(path, ".o"), build_file(path, ".h")); + Table$set(to_compile, &path, &staleness, Table$info(&Path$info, &Byte$info)); + + assert(Text$equal_values(Path$extension(path, true), Text("tm"))); + + ast_t *ast = parse_file(Path$as_c_string(path), NULL); + if (!ast) + 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; + if (stmt_ast->tag == Declare) + stmt_ast = Match(stmt_ast, Declare)->value; + + if (stmt_ast->tag != Use) continue; + auto use = Match(stmt_ast, Use); + + switch (use->what) { + case USE_LOCAL: { + Path_t dep_tm = Path$resolved(Path$from_str(use->path), Path$parent(path)); + if (is_stale(build_file(path, ".h"), dep_tm)) + staleness.h = true; + if (is_stale(build_file(path, ".c"), dep_tm)) + staleness.c = true; + if (staleness.c || staleness.h) + staleness.o = true; + Table$set(to_compile, &path, &staleness, Table$info(&Path$info, &Byte$info)); + build_file_dependency_graph(dep_tm, to_compile, to_link); + break; + } + case USE_MODULE: { + Text_t lib = Text$format("'%s/.local/share/tomo/installed/%s/lib%s.so'", getenv("HOME"), use->path, use->path); + Table$set(to_link, &lib, ((Bool_t[1]){1}), Table$info(&Text$info, &Bool$info)); + + Array_t children = Path$glob(Path$from_str(heap_strf("%s/.local/share/tomo/installed/%s/*.tm", getenv("HOME"), use->path))); + for (int64_t i = 0; i < children.length; i++) { + Path_t *child = (Path_t*)(children.data + i*children.stride); + Table_t discarded = {.fallback=to_compile}; + build_file_dependency_graph(*child, &discarded, to_link); + } + break; + } + case USE_SHARED_OBJECT: { + Text_t lib = Text$format("-l:%s", use->path); + Table$set(to_link, &lib, ((Bool_t[1]){1}), Table$info(&Text$info, &Bool$info)); + break; + } + case USE_ASM: { + Text_t linker_text = Path$as_text(&use->path, false, &Path$info); + Table$set(to_link, &linker_text, ((Bool_t[1]){1}), Table$info(&Text$info, &Bool$info)); + break; + } + default: case USE_HEADER: break; + } + } +} + +bool is_stale(Path_t path, Path_t relative_to) +{ + struct stat target_stat; + if (stat(Path$as_c_string(path), &target_stat) != 0) + return true; + + // Any file older than the compiler is stale: + if (target_stat.st_mtime < compiler_stat.st_mtime) + return true; + + struct stat relative_to_stat; + 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, Path_t path) +{ + Path_t h_filename = build_file(path, ".h"); + ast_t *ast = parse_file(Path$as_c_string(path), NULL); + if (!ast) + 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(Path$as_c_string(h_filename), "w"); + if (!header) + errx(1, "Failed to open header file: %s", Path$as_c_string(h_filename)); + CORD_put(h_code, header); + if (fclose(header) == -1) + errx(1, "Failed to write header file: %s", Path$as_c_string(h_filename)); + + if (!quiet) + printf("Transpiled header:\t%s\n", Path$as_c_string(h_filename)); + + if (show_codegen.length > 0) + system(heap_strf("<%s %k", Path$as_c_string(h_filename), &show_codegen)); +} + +void transpile_code(env_t *base_env, Path_t path) +{ + Path_t c_filename = build_file(path, ".c"); + ast_t *ast = parse_file(Path$as_c_string(path), NULL); + if (!ast) + 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(Path$as_c_string(c_filename), "w"); + if (!c_file) + errx(1, "Failed to write C file: %s", Path$as_c_string(c_filename)); + + CORD_put(c_code, c_file); + + binding_t *main_binding = get_binding(module_env, "main"); + if (main_binding && main_binding->type->tag == FunctionType) { + type_t *ret = Match(main_binding->type, FunctionType)->ret; + if (ret->tag != VoidType && ret->tag != AbortType) + compiler_err(ast->file, ast->start, ast->end, "The main() function in this file has a return type of %T, but it should not have any return value!", ret); + + CORD_put(CORD_all( + "int ", main_binding->code, "$parse_and_run(int argc, char *argv[]) {\n" + "#line 1\n" + "tomo_init();\n", + "_$", module_env->namespace->name, "$$initialize();\n" + "\n", + compile_cli_arg_call(module_env, main_binding->code, main_binding->type), + "return 0;\n" + "}\n"), c_file); + } + + if (fclose(c_file) == -1) + errx(1, "Failed to output C code to %s", Path$as_c_string(c_filename)); + + if (!quiet) + printf("Transpiled code:\t%s\n", Path$as_c_string(c_filename)); + + if (show_codegen.length > 0) + system(heap_strf("<%s %k", Path$as_c_string(c_filename), &show_codegen)); +} + +void compile_object_file(Path_t path) +{ + Path_t obj_file = build_file(path, ".o"); + Path_t c_file = build_file(path, ".c"); + + 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); + if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) + exit(EXIT_FAILURE); + + if (!quiet) + printf("Compiled object:\t%s\n", Path$as_c_string(obj_file)); +} + +Path_t compile_executable(env_t *base_env, Path_t path, Path_t exe_path, Array_t object_files, Array_t extra_ldlibs) +{ + ast_t *ast = parse_file(Path$as_c_string(path), NULL); + if (!ast) + 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 %s, so it can't be run!", Path$as_c_string(path)); + + 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), paths_str(object_files), Path$as_c_string(exe_path)); + CORD program = CORD_all( + "extern int ", main_binding->code, "$parse_and_run(int argc, char *argv[]);\n" + "int main(int argc, char *argv[]) {\n" + "\treturn ", main_binding->code, "$parse_and_run(argc, argv);\n" + "}\n" + ); + + if (show_codegen.length > 0) { + FILE *out = run_cmd("%k", &show_codegen); + CORD_put(program, out); + pclose(out); + } + + CORD_put(program, runner); + int status = pclose(runner); + if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) + exit(EXIT_FAILURE); + + if (!quiet) + printf("Compiled executable:\t%s\n", Path$as_c_string(exe_path)); + return exe_path; +} + +// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0 |