Home /Modules/compiler/sleela_langc.c

sleela_langc.c

lib/compiler/src/sleela_langc.c · 237 line(s) · c

/*
 * lib/compiler/src/sleela_langc.c
 * SLeeLa Compiler — multi-language front-end C ABI implementation.
 * Max Rupplin - MEARVK LLC - 2026.
 *
 * Stable C implementation of the modular compiler framework boundary. It holds
 * the language-module registry and answers phase/target/plan questions. It is
 * deliberately allocation-free and side-effect-free beyond the registry: it
 * never opens, parses, links, loads, or executes an input program. All of that
 * belongs to the SLeeLa front ends above and the VM/OS boundary below.
 */

#include "../include/sleela_langc.h"

#include <string.h>
#include <ctype.h>

static sleela_lang_module_t g_registry[SLEELA_LANG_REGISTRY_MAX];
static size_t g_registry_count = 0u;

/* ---- small helpers ------------------------------------------------------ */

static int sl_ieq(const char *a, const char *b) {
    if (!a || !b) return 0;
    while (*a && *b) {
        if (tolower((unsigned char)*a) != tolower((unsigned char)*b)) return 0;
        ++a; ++b;
    }
    return *a == '\0' && *b == '\0';
}

/* Does the comma-separated extension list `list` contain `ext`? Both sides are
 * matched case-insensitively; a missing leading dot on either side is tolerated. */
static int sl_ext_list_has(const char *list, const char *ext) {
    if (!list || !ext) return 0;
    if (*ext == '.') ++ext;              /* normalize query to no-dot */
    size_t extlen = strlen(ext);
    if (extlen == 0u) return 0;

    const char *p = list;
    while (*p) {
        /* skip separators / leading whitespace */
        while (*p == ',' || *p == ' ' || *p == '\t') ++p;
        const char *start = p;
        while (*p && *p != ',') ++p;
        const char *end = p;             /* [start,end) is one token */
        /* trim trailing whitespace */
        while (end > start && (end[-1] == ' ' || end[-1] == '\t')) --end;
        const char *tok = start;
        if (tok < end && *tok == '.') ++tok;   /* normalize token to no-dot */
        size_t toklen = (size_t)(end - tok);
        if (toklen == extlen) {
            size_t i;
            int same = 1;
            for (i = 0; i < toklen; ++i) {
                if (tolower((unsigned char)tok[i]) != tolower((unsigned char)ext[i])) {
                    same = 0;
                    break;
                }
            }
            if (same) return 1;
        }
    }
    return 0;
}

static int sl_phase_in_range(uint32_t phase_code) {
    return phase_code >= SLEELA_LANG_PHASE_SOURCE && phase_code <= SLEELA_LANG_PHASE_LAST;
}

static int sl_valid_module(const sleela_lang_module_t *m) {
    if (!m || !m->language_name || m->language_name[0] == '\0') return 0;
    if (m->default_target < SLEELA_LANG_TARGET_SLVM ||
        m->default_target > SLEELA_LANG_TARGET_NATIVE) return 0;
    return 1;
}

/* ---- registry ----------------------------------------------------------- */

void sleela_lang_registry_reset(void) {
    g_registry_count = 0u;
    memset(g_registry, 0, sizeof(g_registry));
}

int sleela_lang_register(const sleela_lang_module_t *module) {
    size_t i;
    if (!sl_valid_module(module)) return SLEELA_LANG_INVALID;

    /* replace in place when a module with the same name already exists */
    for (i = 0; i < g_registry_count; ++i) {
        if (sl_ieq(g_registry[i].language_name, module->language_name)) {
            g_registry[i] = *module;
            return SLEELA_LANG_OK;
        }
    }
    if (g_registry_count >= SLEELA_LANG_REGISTRY_MAX) return SLEELA_LANG_BLOCKED;
    g_registry[g_registry_count++] = *module;
    return SLEELA_LANG_OK;
}

size_t sleela_lang_registry_count(void) {
    return g_registry_count;
}

const sleela_lang_module_t *sleela_lang_find(const char *language_name) {
    size_t i;
    if (!language_name) return NULL;
    for (i = 0; i < g_registry_count; ++i) {
        if (sl_ieq(g_registry[i].language_name, language_name)) return &g_registry[i];
    }
    return NULL;
}

const sleela_lang_module_t *sleela_lang_find_by_extension(const char *ext) {
    size_t i;
    if (!ext) return NULL;
    for (i = 0; i < g_registry_count; ++i) {
        if (sl_ext_list_has(g_registry[i].source_extensions, ext)) return &g_registry[i];
    }
    return NULL;
}

/* ---- phase model -------------------------------------------------------- */

int sleela_lang_provides(const sleela_lang_module_t *m, uint32_t phase_code) {
    if (!m || !sl_phase_in_range(phase_code)) return 0;
    return (m->phase_mask & (1u << (phase_code - 1u))) != 0u;
}

uint32_t sleela_lang_required_phases(uint32_t target) {
    /* phases 1..6 (source..IR) are the common minimum for any produced model. */
    uint32_t base = 0u;
    uint32_t p;
    for (p = SLEELA_LANG_PHASE_SOURCE; p <= SLEELA_LANG_PHASE_IR; ++p)
        base |= (1u << (p - 1u));
    switch (target) {
        case SLEELA_LANG_TARGET_SLIR:
            return base;                                  /* stop at IR */
        case SLEELA_LANG_TARGET_SLVM:
        case SLEELA_LANG_TARGET_SLJVM:
        case SLEELA_LANG_TARGET_NATIVE:
            return base
                 | (1u << (SLEELA_LANG_PHASE_LOWER   - 1u))
                 | (1u << (SLEELA_LANG_PHASE_CODEGEN - 1u));
        default:
            return 0u;
    }
}

int sleela_lang_phase_status(const sleela_lang_module_t *m, uint32_t phase_code) {
    if (!m || !sl_phase_in_range(phase_code)) return SLEELA_LANG_INVALID;
    return sleela_lang_provides(m, phase_code) ? SLEELA_LANG_OK : SLEELA_LANG_ABSENT;
}

const char *sleela_lang_phase_name(uint32_t phase_code) {
    switch (phase_code) {
        case SLEELA_LANG_PHASE_SOURCE:   return "source";
        case SLEELA_LANG_PHASE_LEX:      return "lex";
        case SLEELA_LANG_PHASE_PARSE:    return "parse";
        case SLEELA_LANG_PHASE_RESOLVE:  return "resolve";
        case SLEELA_LANG_PHASE_SEMANTIC: return "semantic";
        case SLEELA_LANG_PHASE_IR:       return "ir";
        case SLEELA_LANG_PHASE_LOWER:    return "lower";
        case SLEELA_LANG_PHASE_CODEGEN:  return "codegen";
        default:                         return "unknown";
    }
}

const char *sleela_lang_target_name(uint32_t target_code) {
    switch (target_code) {
        case SLEELA_LANG_TARGET_SLVM:   return "SLVM";
        case SLEELA_LANG_TARGET_SLJVM:  return "SLJVM";
        case SLEELA_LANG_TARGET_SLIR:   return "SLIR";
        case SLEELA_LANG_TARGET_NATIVE: return "NATIVE";
        default:                        return "UNKNOWN";
    }
}

/* ---- planning ----------------------------------------------------------- */

int sleela_lang_plan(const sleela_lang_request_t *req, sleela_lang_plan_t *out) {
    const sleela_lang_module_t *m;
    uint32_t target, required, p, missing;

    if (!req || !out) return SLEELA_LANG_INVALID;
    memset(out, 0, sizeof(*out));

    m = sleela_lang_find(req->module_name);
    if (!m) return SLEELA_LANG_ABSENT;

    target = req->requested_target ? req->requested_target : m->default_target;
    required = sleela_lang_required_phases(target);
    if (required == 0u) return SLEELA_LANG_INVALID;

    /* a reference-only module may plan up to IR but must not be asked to emit. */
    if (m->reference_only &&
        (target == SLEELA_LANG_TARGET_SLVM ||
         target == SLEELA_LANG_TARGET_SLJVM ||
         target == SLEELA_LANG_TARGET_NATIVE)) {
        out->covered_phase_mask  = m->phase_mask;
        out->required_phase_mask = required;
        out->target              = target;
        out->first_missing_phase = SLEELA_LANG_PHASE_CODEGEN;
        out->vm_ready            = 0u;
        return SLEELA_LANG_BLOCKED;
    }

    out->covered_phase_mask  = m->phase_mask;
    out->required_phase_mask = required;
    out->target              = target;

    missing = 0u;
    for (p = SLEELA_LANG_PHASE_SOURCE; p <= SLEELA_LANG_PHASE_LAST; ++p) {
        uint32_t bit = (1u << (p - 1u));
        if ((required & bit) && !(m->phase_mask & bit)) {
            missing = p;
            break;
        }
    }
    out->first_missing_phase = missing;
    out->vm_ready = (missing == 0u) ? 1u : 0u;

    /* strict requests fail closed: no plan unless fully covered. */
    if (req->strict && !out->vm_ready) return SLEELA_LANG_BLOCKED;
    return SLEELA_LANG_OK;
}

const char *sleela_lang_status_name(int status_code) {
    switch (status_code) {
        case SLEELA_LANG_OK:      return "OK";
        case SLEELA_LANG_ABSENT:  return "ABSENT";
        case SLEELA_LANG_INVALID: return "INVALID";
        case SLEELA_LANG_BLOCKED: return "BLOCKED";
        default:                  return "UNKNOWN";
    }
}