path: root/bootstrap/main.c

/*
 * Main entry point of the bootstrap compiler.
 *
 * Copyright © 2025-2026 Samuel Lidén Borell <samuel@kodafritt.se>
 *
 * SPDX-License-Identifier: EUPL-1.2+ OR LGPL-2.1-or-later
 */
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "compiler.h"
#include "token.h"

#if defined(_WIN32) || defined(_WIN64)
    #define DIRSEP '\\'
#else
    #define DIRSEP '/'
#endif

#define PATH_LIMIT 512

static size_t ifacedir_len = 0;
static const char *ifacedir = NULL;

static size_t rootdir_len = 0;
static const char *rootdir;
static FILE *f = NULL;

static const char *output_c_filename = NULL;
const char *current_filename = NULL;
static char *last_alloced_filename = NULL;
unsigned current_line = 0;

NORETURN void error(const char *s)
{
    error_len(s, NULL, 0);
}

NORETURN void error_str(const char *s, const char *arg)
{
    error_len(s, arg, arg ? strlen(arg) : 0);
}

NORETURN void error_len(const char *s, const char *arg, size_t arglen)
{
    assert(arglen <= INT_MAX);
    fprintf(stderr, "%s:%u: %s%s%.*s\n", current_filename, current_line,
            s,
            arg ? ": " : "",
            (int)arglen, arg ? arg : "");
    if (output_c_filename) {
        remove(output_c_filename);
    }
    exit(EXIT_FAILURE);
}

NORETURN void error_token(const char *s, const struct LexemeInfo *li)
{
    error_len(s, li->string, li->len);
}

NORETURN void error_ident(const char *s, const struct Ident *ident)
{
    error_len(s, ident->node.name, ident->node.length);
}

void set_srcloc(const struct SourceLocation *srcloc)
{
    assert(srcloc->filename != NULL);
    current_filename = srcloc->filename;
    current_line = srcloc->line;
}

NORETURN void error_at_ident(const char *s, const struct Ident *ident)
{
    set_srcloc(&ident->srcloc);
    error_len(s, ident->node.name, ident->node.length);
}

NORETURN void error_var(const char *s, const struct Var *var)
{
    error_ident(s, &var->ident);
}

void warning(const char *s)
{
    fprintf(stderr, "%s:%u: warning: %s\n",
            current_filename, current_line, s);
}

static void open_file(const char *dir, size_t dirlen, const char *filename)
{
    size_t filename_len, total_len;
    char *fullpath;

    filename_len = strlen(filename);
    total_len = dirlen + 1 + filename_len + 1;
    if (total_len > PATH_LIMIT) {
        FAIL("filename too long");
    }
    fullpath = malloc(total_len);
    NO_NULL(fullpath);
    /* Root dir */
    memcpy(fullpath, dir, dirlen);
    fullpath[dirlen] = DIRSEP;
    /* Source file */
    memcpy(fullpath+dirlen+1, filename, filename_len);
    replacechar(fullpath+dirlen+1, '/', DIRSEP, filename_len);
    fullpath[dirlen+1+filename_len] = '\0';

    f = fopen(fullpath, "rb");
    if (!f) {
        perror(fullpath);
        exit(EXIT_FAILURE);
    }
    last_alloced_filename = fullpath;
    current_filename = fullpath;
    current_line = 0;
}

static void close_file(void)
{
    assert(f != NULL);
    NO_NEG(fclose(f));
    f = NULL;
    current_filename = NULL;
    current_line = 0;
}

static void free_last_filename(void)
{
    free(last_alloced_filename);
    last_alloced_filename = NULL;
}

static void completed_one_module(void)
{
    if (unbound_types_list) {
        error_at_ident("Undefined type",
                       &unbound_types_list->ident);
    }
    if (unbound_funcs_list) {
        error_at_ident("Undefined function",
                       &unbound_funcs_list->ident);
    }

    /* TODO compute API-hashes etc. */
    mod_declared_versions = NULL;
    mod_declared_versions_list = NULL;

    current_module_id++;
}

static void parse_core_interface(void)
{
    /* TODO rename core_wip.slul to core.slul once it's API-stable */
    open_file(ifacedir, ifacedir_len, "core_wip.slul");
    /* TODO forbid Uppercase initial letter in interfaces?
            or at least don't create an implicit class. */
    parse_file(f, "core_wip.slul");
    builtins_bind();
    close_file();
    completed_one_module();
}

static void parse_dependency_interfaces(void)
{
    char filename[50+5+1]; /* "<modulename>.slul\0" */
    const struct DependencyInfo *dep;

    for (dep = dependencies_list; dep; dep = dep->next) {
        size_t namelen = dep->node.length;
        assert(namelen <= 50);
        memcpy(filename, dep->node.name, namelen);
        memcpy(filename+namelen, ".slul", 5+1);

        open_file(ifacedir, ifacedir_len, filename);
        parse_file(f, filename);
        close_file();
        compute_api_hashes();
        completed_one_module();
    }
}

static void parse_exported_interface(void)
{
    assert(is_library);
    in_exported_interface = true;
    open_file(rootdir, rootdir_len, "interface.slul");
    parse_file(f, "interface.slul");
    close_file();
    compute_api_hashes();
    completed_one_module();
    in_exported_interface = false;
}

static void parse(void)
{
    const struct SourceFile *sourcefile;

    ast_init();

    /* TODO Decide on a file name here. In particular,
            check that "sources.index" is not used for anything else.
                - Go uses extensions: go.mod, go.sum, etc.
                  How about:
                    slul.sources
                    slul.list
                    slul.index
                  And then, for the other types of files:
                    slul.deps
                    slul.exports
                    slul.known (known hashes / pubkeys)
                  (Also, how about renaming slul?)
            */
    open_file(rootdir, rootdir_len, "sources.index");
    parse_source_index(f);
    close_file();
    free_last_filename();

    open_file(rootdir, rootdir_len, "deps.index");
    parse_dependencies_list(f);
    close_file();
    free_last_filename();

    parse_core_interface();
    parse_dependency_interfaces();
    if (is_library) {
        parse_exported_interface();
    }
    interfaces_done = true;

    for (sourcefile = sources; sourcefile; sourcefile = sourcefile->next) {
        const char *filename = sourcefile->filename;
        open_file(rootdir, rootdir_len, filename);
        parse_file(f, path_basename(filename));
        close_file();
    }
    completed_one_module();
}

static void set_rootdir(const char *rootdir_arg)
{
    rootdir_len = strlen(rootdir_arg);
    if (rootdir_len+2 >= PATH_LIMIT) FAIL("source path too long");
    rootdir = rootdir_arg;
}

int main(int argc, char **argv)
{
    enum {
        IFACEDIR_ARG = 1,
        SOURCE_DIR_ARG = 2,
        C_OUTPUT_ARG = 3
    };

    if (argc != 4) {
        fprintf(stderr, "usage: "
            "stage1 <interface-dir> <source-dir> <output.c>\n");
        return EXIT_FAILURE;
    }

    /* TODO allow the interface files to be read directly from the modules? */
    ifacedir = argv[IFACEDIR_ARG];
    ifacedir_len = strlen(ifacedir);

    set_rootdir(argv[SOURCE_DIR_ARG]);
    parse();

    output_c_filename = argv[C_OUTPUT_ARG];
    emit_c_code(output_c_filename);
    return EXIT_SUCCESS;
}