zzy/spl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: zzy:994a35a942f82153763bb187f5e331d6e1045a25
Branches Tags
zzy:main zzy:dev
...
compare: zzy:c81a57dacbddb296e4bc110acce504c97f7873c6
Branches Tags
zzy:dev zzy:main

2 Commits
994a35a942 ... c81a57dacb

Author SHA1 Message Date
zzy
c81a57dacb builder 更改构建方式从python换成nob.h 2026-08-19 21:38:41 +08:00
zzy
b2e6ade484 stage1 继续重构sema 提供更多dbg宏用于日志记录 2026-08-19 21:37:40 +08:00
12 changed files with 4071 additions and 544 deletions
Expand all files Collapse all files

1
.gitignore vendored
View File

@@ -8,5 +8,6 @@ build/
*.o
*.obj
*.old
*.exe
*.out

417
build.py
View File

@@ -1,417 +0,0 @@
#!/usr/bin/env python3
"""SPL build system - .c -> .o -> exe, .spl -> .sir, deps auto-resolved."""
import argparse
import hashlib
import json
import os
import shutil
import subprocess
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parent
BUILD_DIR = ROOT / "build"
CACHE_FILE = BUILD_DIR / ".build_cache.json"
DESC_FILE = ROOT / "project_desc.py"
EXE_EXT = ".exe" if os.name == "nt" else ""
CC = os.environ.get("CC", "gcc")
CFLAGS = os.environ.get("CFLAGS", "-Wall -Wextra -O0 -g").split()
def load_desc():
ns = {"__builtins__": __builtins__}
exec(DESC_FILE.read_text(), ns)
return {
"exe": ns.get("exe", {}),
"spl": ns.get("spl", {}),
"pipeline": ns.get("pipeline", {}),
}
# ── Helpers ─────────────────────────────────────────────────────────────
def obj_key(src):
return src.rsplit(".", 1)[0].replace("/", "_").replace("\\", "_")
def obj_path(src):
return BUILD_DIR / (obj_key(src) + ".o")
def exe_path(name):
return BUILD_DIR / (name + EXE_EXT)
def sir_path(name):
return BUILD_DIR / (name + ".sir")
# ── Cache ───────────────────────────────────────────────────────────────
def load_cache():
if CACHE_FILE.is_file():
try:
return json.loads(CACHE_FILE.read_text())
except (json.JSONDecodeError, OSError):
pass
return {}
def save_cache(cache):
BUILD_DIR.mkdir(parents=True, exist_ok=True)
CACHE_FILE.write_text(json.dumps(cache, indent=2))
def hash_file(p):
h = hashlib.sha256()
with p.open("rb") as f:
while chunk := f.read(65536):
h.update(chunk)
return h.hexdigest()
# ── C compilation ───────────────────────────────────────────────────────
_built_objs = set()
def compile_c(src, cache, force):
key = f"obj:{src}"
dst = obj_path(src)
src_path = ROOT / src
if not src_path.is_file():
print(f" ERR {src} not found"); return False
h = hashlib.sha256()
h.update(hash_file(src_path).encode())
h.update(" ".join(CFLAGS).encode())
ch = h.hexdigest()
cached = cache.get(key)
if not force and cached and cached["h"] == ch and dst.is_file():
_built_objs.add(src); return True
BUILD_DIR.mkdir(parents=True, exist_ok=True)
cmd = [CC] + CFLAGS + ["-c", str(src_path), "-o", str(dst)]
print(f" CC {src}")
if subprocess.run(cmd).returncode: return False
cache[key] = {"h": ch}
_built_objs.add(src)
return True
def link_exe(name, sources, cache, force):
key = f"exe:{name}"
dst = exe_path(name)
# hash = concat of all input obj hashes + name
h = hashlib.sha256(name.encode())
for src in sources:
cached = cache.get(f"obj:{src}", {})
h.update(cached.get("h", "?").encode())
ch = h.hexdigest()
cached = cache.get(key)
if not force and cached and cached["h"] == ch and dst.is_file():
return True
cmd = [CC] + CFLAGS + [str(obj_path(s)) for s in sources] + ["-o", str(dst)]
print(f" LINK {name}")
if subprocess.run(cmd).returncode: return False
cache[key] = {"h": ch}
return True
# ── SPL compilation ─────────────────────────────────────────────────────
def find_imports(src_path):
"""Scan source for @import("path") directives, return resolved paths."""
deps = []
try:
text = src_path.read_text(errors="replace")
except OSError:
return deps
idx = 0
while True:
idx = text.find('@import("', idx)
if idx < 0:
break
start = idx + 9
end = text.find('")', start)
if end < 0:
break
imp_path = text[start:end]
imp_file = (src_path.parent / imp_path).resolve()
if imp_file.is_file():
deps.append(imp_file)
idx = end + 2
return deps
def collect_deps(src_path):
"""Collect all transitive @import dependencies."""
seen = set()
result = []
def walk(p):
p = p.resolve()
if p in seen:
return
seen.add(p)
for dep in find_imports(p):
walk(dep)
result.append(dep)
walk(src_path)
return result
def compile_spl(name, src, compiler, desc, cache, force):
key = f"spl:{name}"
dst = sir_path(name)
src_path = ROOT / src
if not src_path.is_file():
print(f" ERR {src} not found"); return False
h = hashlib.sha256()
h.update(hash_file(src_path).encode())
# Hash @import dependencies (transitive)
for dep in collect_deps(src_path):
h.update(hash_file(dep).encode())
# Determine how to run the compiler
if compiler in desc.get("spl", {}):
# SPL-based compiler: run via VM runner
cinfo = desc["spl"][compiler]
pl = desc.get("pipeline", {}).get(cinfo.get("pipeline", ""), {})
runner = pl.get("runner") or cinfo.get("runner", "spl_cli")
runner_exe = exe_path(runner)
sir = sir_path(compiler)
if runner_exe.is_file():
h.update(hash_file(runner_exe).encode())
if os.path.isfile(sir):
h.update(hash_file(Path(sir)).encode())
ch = h.hexdigest()
cached = cache.get(key)
if not force and cached and cached["h"] == ch and dst.is_file():
return True
BUILD_DIR.mkdir(parents=True, exist_ok=True)
cmd = [str(runner_exe), str(sir), str(src_path), str(dst)]
print(f" SPL {name} ({compiler} via {runner})")
else:
# Native exe compiler
ce = exe_path(compiler)
if ce.is_file():
h.update(hash_file(ce).encode())
ch = h.hexdigest()
cached = cache.get(key)
if not force and cached and cached["h"] == ch and dst.is_file():
return True
BUILD_DIR.mkdir(parents=True, exist_ok=True)
cmd = [str(ce), str(src_path), str(dst)]
print(f" SPL {name} ({compiler})")
if subprocess.run(cmd).returncode: return False
cache[key] = {"h": ch}
return True
# ── Dependency-aware build ──────────────────────────────────────────────
_built = set()
def build(name, desc, cache, force):
"""Build target + all deps (auto-resolved DAG traversal)."""
if name in _built:
return True
if name in desc.get("exe", {}):
sources = desc["exe"][name]
for src in sources:
if not compile_c(src, cache, force):
return False
if not link_exe(name, sources, cache, force):
return False
elif name in desc.get("spl", {}):
info = desc["spl"][name]
pl = desc.get("pipeline", {}).get(info.get("pipeline", ""), {})
compiler = pl.get("compiler") or info.get("compiler")
if not compiler:
print(f" ERR '{name}': no compiler in pipeline '{info.get('pipeline')}'")
return False
if not build(compiler, desc, cache, force):
return False
if not compile_spl(name, info["src"], compiler, desc, cache, force):
return False
else:
print(f" ERR unknown target '{name}'")
return False
_built.add(name)
return True
def build_all(desc, cache, force):
targets = list(desc.get("exe", {})) + list(desc.get("spl", {}))
for t in targets:
if not build(t, desc, cache, force):
return False
return True
# ── Run ─────────────────────────────────────────────────────────────────
def run_target(name, desc, cache, force, extra_args):
if name in desc.get("exe", {}):
if not build(name, desc, cache, force):
return 1
exe = exe_path(name)
print(f" RUN {name}")
return subprocess.run([str(exe)] + extra_args).returncode
if name in desc.get("spl", {}):
info = desc["spl"][name]
pl = desc.get("pipeline", {}).get(info.get("pipeline", ""), {})
runner = pl.get("runner") or info.get("runner", "spl_cli")
if not runner:
print(f" ERR '{name}': no runner"); return 1
if not build(name, desc, cache, force):
return 1
if not build(runner, desc, cache, force):
return 1
print(f" RUN {name} (via {runner})")
return subprocess.run(
[str(exe_path(runner)), str(sir_path(name))] + extra_args
).returncode
if name in desc.get("pipeline", {}):
pl = desc["pipeline"][name]
compiler = pl.get("compiler")
runner = pl.get("runner")
if not compiler or not runner:
print(f" ERR pipeline '{name}' missing compiler or runner"); return 1
if not extra_args:
print(" ERR usage: run <pipeline> <src> [args]"); return 1
src = extra_args[0]
if not build(compiler, desc, cache, force): return 1
if not build(runner, desc, cache, force): return 1
sir_name = "pipeline_" + hashlib.sha256(str(ROOT / src).encode()).hexdigest()[:8]
if not compile_spl(sir_name, src, compiler, desc, cache, force):
return 1
print(f" RUN pipeline {name} ({src})")
return subprocess.run(
[str(exe_path(runner)), str(sir_path(sir_name))] + extra_args[1:]
).returncode
print(f" ERR unknown target '{name}'"); return 1
# ── Clean / List ────────────────────────────────────────────────────────
def clean():
if BUILD_DIR.is_dir():
shutil.rmtree(BUILD_DIR)
print(f" CLEAN {BUILD_DIR}")
def list_targets(desc):
print("Executables (.c -> .o -> exe):")
for name, sources in desc.get("exe", {}).items():
print(f" {name}")
for s in sources:
print(f" {s}")
if desc.get("spl"):
print("\nSPL programs (.spl -> .sir via pipeline):")
for name, info in desc["spl"].items():
pl_name = info.get("pipeline", "-")
print(f" {name} pipeline={pl_name} src={info['src']}")
if desc.get("pipeline"):
print("\nPipelines:")
for name, pl in desc["pipeline"].items():
print(f" {name} compiler={pl['compiler']} runner={pl.get('runner', '-')}")
# ── CLI ─────────────────────────────────────────────────────────────────
def main():
parser = argparse.ArgumentParser(description="SPL build system")
sub = parser.add_subparsers(dest="command")
bp = sub.add_parser("build", help="build targets (default: all)")
bp.add_argument("targets", nargs="*")
bp.add_argument("-f", "--force", action="store_true")
rp = sub.add_parser("run", help="build and run a target, or run pipeline <name> <src> [args]")
rp.add_argument("target")
rp.add_argument("extra", nargs="*")
sub.add_parser("test", help="build and run VM unit tests")
sub.add_parser("clean", help="remove build artifacts")
sub.add_parser("list", help="list all targets")
args = parser.parse_args()
if not DESC_FILE.is_file():
print(f"ERR {DESC_FILE} not found"); return 1
# Default: build all
if args.command is None:
desc = load_desc(); cache = load_cache()
ok = build_all(desc, cache, False)
save_cache(cache)
return 0 if ok else 1
# Build
if args.command == "build":
desc = load_desc(); cache = load_cache()
if args.targets:
ok = all(build(t, desc, cache, args.force) for t in args.targets)
else:
ok = build_all(desc, cache, args.force)
save_cache(cache)
return 0 if ok else 1
# Run
if args.command == "run":
desc = load_desc(); cache = load_cache()
rc = run_target(args.target, desc, cache, False, args.extra)
save_cache(cache)
return rc
# Pipeline: build compiler -> compile .spl -> run via runner
if args.command == "pipeline":
desc = load_desc(); cache = load_cache()
pl = desc.get("pipeline", {}).get(args.name)
if not pl:
print(f" ERR unknown pipeline '{args.name}'"); return 1
compiler = pl.get("compiler")
runner = pl.get("runner")
if not compiler or not runner:
print(f" ERR pipeline '{args.name}' missing compiler or runner"); return 1
src_path = ROOT / args.src
if not src_path.is_file():
print(f" ERR source not found: {args.src}"); return 1
# Build compiler + runner
if not build(compiler, desc, cache, False): return 1
if not build(runner, desc, cache, False): return 1
# Compile .spl -> .sir (temp name = src path hash)
sir_name = "pipeline_" + hashlib.sha256(str(src_path).encode()).hexdigest()[:8]
if not compile_spl(sir_name, args.src, compiler, desc, cache, False):
return 1
# Run .sir via runner
print(f" PIPELINE {args.name} ({args.src})")
rc = subprocess.run(
[str(exe_path(runner)), str(sir_path(sir_name))] + args.extra
).returncode
save_cache(cache)
return rc
# Test
if args.command == "test":
desc = load_desc(); cache = load_cache()
ok = build("test", desc, cache, False)
save_cache(cache)
if not ok: return 1
return subprocess.run([str(exe_path("test"))]).returncode
# Clean / List
if args.command == "clean":
clean(); return 0
if args.command == "list":
list_targets(load_desc()); return 0
return 0
if __name__ == "__main__":
sys.exit(main())

294
nob.c Normal file
View File

@@ -0,0 +1,294 @@
#undef UNICODE
#define NOB_IMPLEMENTATION
// Redefine nob_cc_flags() to carry the project's debug flags. Keep in sync
// with CFLAGS_STR below.
#define SPL_CFLAGS "-Wall", "-Wextra", "-O0", "-g", "-D_CRT_SECURE_NO_WARNINGS"
#define nob_cc_flags(cmd) nob_cmd_append(cmd, SPL_CFLAGS)
#include "nob.h"
#ifdef _WIN32
#include <consoleapi2.h>
#endif
// C-side bootstrap build script. Builds the stage0 VM tools and the splc0
// compiler from their C sources. The SPL self-hosting chain (splc1, ...) is
// out of scope and is driven by a different mechanism.
//
// Usage:
// cc -o nob nob.c # bootstrap once
// ./nob # build all targets
// ./nob build <targets...> # build specific targets
// ./nob run <target> [..] # build and run
// ./nob test # build and run VM unit tests
// ./nob clean # remove build artifacts
// ./nob list # list all targets
// ./nob help # print this help
#define BUILD_FOLDER "build/"
#ifdef _WIN32
#define EXE_SUFFIX ".exe"
#else
#define EXE_SUFFIX ""
#endif
// Content of the .cflags stamp file; must match SPL_CFLAGS above.
#define CFLAGS_STR "-Wall -Wextra -O0 -g"
// Stamp file whose mtime is refreshed whenever the flags change so that all
// object files get rebuilt.
static const char *CFLAGS_STAMP = BUILD_FOLDER ".cflags";
// Target descriptions
#define VM_SRCS "stage0/spl_mcode.c", "stage0/spl_syscall.c", "stage0/spl_vm.c"
#define SPLC0_PART_SRCS \
"stage1/spl_ast.c", "stage1/spl_lexer.c", "stage1/spl_dumptree.c", "stage1/spl_type.c", \
"stage1/spl_sema.c", "stage1/spl_ir.c", "stage1/spl_ast2ir.c"
static const char *spl_cli_srcs[] = {"stage0/spl_cli.c", VM_SRCS};
static const char *splc0_srcs[] = {"stage1/splc0.c", VM_SRCS, SPLC0_PART_SRCS};
static const char *test_srcs[] = {"stage0/test_spl_vm.c", VM_SRCS};
static const char *spl_disasm_srcs[] = {"stage0/spl_disasm.c", VM_SRCS};
typedef struct {
const char *name;
const char **srcs;
size_t srcs_count;
} Exe_Target;
static Exe_Target exe_targets[] = {
{"spl_cli", spl_cli_srcs, NOB_ARRAY_LEN(spl_cli_srcs)},
{"splc0", splc0_srcs, NOB_ARRAY_LEN(splc0_srcs)},
{"test", test_srcs, NOB_ARRAY_LEN(test_srcs)},
{"spl_disasm", spl_disasm_srcs, NOB_ARRAY_LEN(spl_disasm_srcs)},
};
static const Exe_Target *find_exe_target(const char *name) {
for (size_t i = 0; i < NOB_ARRAY_LEN(exe_targets); ++i) {
if (strcmp(exe_targets[i].name, name) == 0) {
return &exe_targets[i];
}
}
return NULL;
}
static const char *obj_path(const char *src) {
// "stage0/spl_vm.c" -> "build/stage0_spl_vm.o"
size_t prefix_len = strlen(BUILD_FOLDER);
char *out = (char *)nob_temp_alloc(prefix_len + strlen(src) + 2 + 1);
char *w = out;
memcpy(w, BUILD_FOLDER, prefix_len);
w += prefix_len;
for (const char *p = src; *p && *p != '.'; ++p) {
*w++ = (*p == '/' || *p == '\\') ? '_' : *p;
}
memcpy(w, ".o", 3);
return out;
}
static const char *exe_path(const char *name) {
return nob_temp_sprintf(BUILD_FOLDER "%s" EXE_SUFFIX, name);
}
static bool sync_cflags_stamp(void) {
Nob_String_View cflags = nob_sv_from_cstr(CFLAGS_STR);
Nob_String_Builder old = {0};
bool changed = true;
if (nob_file_exists(CFLAGS_STAMP) && nob_read_entire_file(CFLAGS_STAMP, &old)) {
changed = !nob_sv_eq(nob_sb_to_sv(old), cflags);
}
nob_sb_free(old);
if (changed) {
if (!nob_write_entire_file(CFLAGS_STAMP, cflags.data, cflags.count)) {
return false;
}
}
return true;
}
static bool prepare_build(void) {
if (!nob_mkdir_if_not_exists(BUILD_FOLDER))
return false;
return sync_cflags_stamp();
}
static bool build_object(const char *src) {
const char *obj = obj_path(src);
if (!nob_file_exists(src)) {
nob_log(NOB_ERROR, "source file `%s` does not exist", src);
return false;
}
const char *inputs[] = {src, CFLAGS_STAMP};
int needs = nob_needs_rebuild(obj, inputs, NOB_ARRAY_LEN(inputs));
if (needs < 0)
return false;
if (needs == 0)
return true;
Nob_Cmd cmd = {0};
nob_cc(&cmd);
nob_cc_flags(&cmd);
nob_cmd_append(&cmd, "-c");
nob_cc_inputs(&cmd, src);
nob_cc_output(&cmd, obj);
return nob_cmd_run(&cmd);
}
static bool link_exe(const Exe_Target *target) {
const char *exe = exe_path(target->name);
const char **objs = (const char **)nob_temp_alloc(sizeof(const char *) * target->srcs_count);
for (size_t i = 0; i < target->srcs_count; ++i) {
objs[i] = obj_path(target->srcs[i]);
}
int needs = nob_needs_rebuild(exe, objs, target->srcs_count);
if (needs < 0)
return false;
if (needs == 0)
return true;
Nob_Cmd cmd = {0};
nob_cc(&cmd);
nob_cc_flags(&cmd);
for (size_t i = 0; i < target->srcs_count; ++i) {
nob_cc_inputs(&cmd, objs[i]);
}
nob_cc_output(&cmd, exe);
return nob_cmd_run(&cmd);
}
static bool build_target(const char *name) {
const Exe_Target *target = find_exe_target(name);
if (target == NULL) {
nob_log(NOB_ERROR, "unknown target `%s`", name);
return false;
}
for (size_t i = 0; i < target->srcs_count; ++i) {
if (!build_object(target->srcs[i])) {
return false;
}
}
return link_exe(target);
}
static bool build_all(void) {
for (size_t i = 0; i < NOB_ARRAY_LEN(exe_targets); ++i) {
if (!build_target(exe_targets[i].name)) {
return false;
}
}
return true;
}
static bool delete_walk_entry(Nob_Walk_Entry entry) { return nob_delete_file(entry.path); }
static bool delete_directory_recursively(const char *dir_path) {
return nob_walk_dir(dir_path, delete_walk_entry, .post_order = true);
}
static void print_help(const char *program_name) {
nob_log(NOB_INFO, "SPL C-side bootstrap build system (nob)");
nob_log(NOB_INFO, "%s", " ");
nob_log(NOB_INFO, "Usage: %s <command> [args...]", program_name);
nob_log(NOB_INFO, "%s", " ");
nob_log(NOB_INFO, "Commands:");
nob_log(NOB_INFO, " build [targets...] build all targets or the given ones");
nob_log(NOB_INFO, " run <target> [args] build and run a target");
nob_log(NOB_INFO, " test build and run VM unit tests");
nob_log(NOB_INFO, " clean remove build artifacts");
nob_log(NOB_INFO, " list list all targets");
nob_log(NOB_INFO, " help/-h/--help print this help message");
nob_log(NOB_INFO, "%s", " ");
nob_log(NOB_INFO, "Targets:");
for (size_t i = 0; i < NOB_ARRAY_LEN(exe_targets); ++i) {
nob_log(NOB_INFO, " %s", exe_targets[i].name);
}
}
int main(int argc, char **argv) {
#ifdef _WIN32
SetConsoleOutputCP(CP_UTF8);
#endif
NOB_GO_REBUILD_URSELF_PLUS(argc, argv, "nob.h");
set_log_handler(nob_cancer_log_handler);
const char *program_name = nob_shift(argv, argc);
const char *command_name = "build";
if (argc > 0) {
command_name = nob_shift(argv, argc);
}
if (strcmp(command_name, "build") == 0) {
if (!prepare_build())
return 1;
if (argc > 0) {
while (argc > 0) {
const char *target_name = nob_shift(argv, argc);
if (!build_target(target_name))
return 1;
}
} else {
if (!build_all())
return 1;
}
return 0;
}
if (strcmp(command_name, "run") == 0) {
if (argc <= 0) {
nob_log(NOB_ERROR, "usage: %s run <target> [args...]", program_name);
return 1;
}
const char *target_name = nob_shift(argv, argc);
if (!prepare_build())
return 1;
if (!build_target(target_name))
return 1;
Nob_Cmd cmd = {0};
nob_cmd_append(&cmd, exe_path(target_name));
while (argc > 0) {
nob_cmd_append(&cmd, nob_shift(argv, argc));
}
return nob_cmd_run(&cmd) ? 0 : 1;
}
if (strcmp(command_name, "test") == 0) {
if (!prepare_build())
return 1;
if (!build_target("test"))
return 1;
Nob_Cmd cmd = {0};
nob_cmd_append(&cmd, exe_path("test"));
return nob_cmd_run(&cmd) ? 0 : 1;
}
if (strcmp(command_name, "clean") == 0) {
if (nob_file_exists(BUILD_FOLDER)) {
if (!delete_directory_recursively(BUILD_FOLDER))
return 1;
}
nob_log(NOB_INFO, "cleaned %s", BUILD_FOLDER);
return 0;
}
if (strcmp(command_name, "list") == 0) {
for (size_t i = 0; i < NOB_ARRAY_LEN(exe_targets); ++i) {
nob_log(NOB_INFO, "%s:", exe_targets[i].name);
for (size_t j = 0; j < exe_targets[i].srcs_count; ++j) {
nob_log(NOB_INFO, " %s", exe_targets[i].srcs[j]);
}
}
return 0;
}
if (strcmp(command_name, "help") == 0 || strcmp(command_name, "-h") == 0 ||
strcmp(command_name, "--help") == 0) {
print_help(program_name);
return 0;
}
nob_log(NOB_ERROR, "unknown command `%s`", command_name);
print_help(program_name);
return 1;
}

3390
nob.h Normal file
View File

File diff suppressed because it is too large Load Diff

52
project_desc.py
View File

@@ -1,52 +0,0 @@
vm = [
"stage0/spl_mcode.c",
"stage0/spl_syscall.c",
"stage0/spl_vm.c",
]
splc0_part = [
"stage1/spl_ast.c",
"stage1/spl_lexer.c",
"stage1/spl_dumptree.c",
"stage1/spl_type.c",
"stage1/spl_sema.c",
"stage1/spl_ir.c",
"stage1/spl_ast2ir.c",
# "stage1/spl_ir2vm.c",
]
exe = {
"spl_cli": ["stage0/spl_cli.c"] + vm,
"splc0": ["stage1/splc0.c"] + vm + splc0_part,
"test": ["stage0/test_spl_vm.c"] + vm,
"spl_disasm": ["stage0/spl_disasm.c"] + vm,
}
pipeline = {
"splc0b": {"compiler": "splc0", "runner": "spl_cli"},
"splc0r": {"compiler": "splc0", "runner": "spl_cli"},
"splc0d": {"compiler": "splc0", "runner": "spl_disasm"},
"splc1b": {"compiler": "splc0", "runner": "spl_cli"},
"splc1r": {"compiler": "splc1", "runner": "spl_cli"},
"splc1d": {"compiler": "splc1", "runner": "spl_disasm"},
"splc2b": {"compiler": "splc1", "runner": "spl_cli"},
"splc2r": {"compiler": "splc2", "runner": "spl_cli"},
"splc2d": {"compiler": "splc2", "runner": "spl_disasm"},
"splc3b": {"compiler": "splc2", "runner": "spl_cli"},
"splc3r": {"compiler": "splc3", "runner": "spl_cli"},
"splc3d": {"compiler": "splc3", "runner": "spl_disasm"},
"splc4b": {"compiler": "splc3", "runner": "spl_cli"},
"splc4r": {"compiler": "splc4", "runner": "spl_cli"},
"splc4d": {"compiler": "splc4", "runner": "spl_disasm"},
}
spl = {
"splc1": {"src": "stage2/splc1.spl", "pipeline": "splc0r"},
"splc2": {"src": "stage2/splc2.spl", "pipeline": "splc1r"},
"splc3": {"src": "stage3/splc3.spl", "pipeline": "splc2r"},
"splc4": {"src": "stage4/splc4.spl", "pipeline": "splc3r"},
}

12
stage1/spl_ast.c
View File

@@ -409,7 +409,7 @@ static spl_ast_node_ref_t parse_type_decl(parser_t *p, spl_ast_node_ref_vec_t at
if (t && (t->type == TOK_COMMA || t->type == TOK_SEMICOLON)) {
advance(p);
} else {
LOG_WARN("need comma or semicolon with member decl");
SPL_WARN(t, "need comma or semicolon with member decl");
}
return ref;
}
@@ -434,7 +434,7 @@ static spl_ast_node_ref_t parse_member_decl(parser_t *p, spl_ast_node_ref_vec_t
if (t && (t->type == TOK_COMMA || t->type == TOK_SEMICOLON)) {
advance(p);
} else {
LOG_WARN("need comma or semicolon with member decl");
SPL_WARN(t, "need comma or semicolon with member decl");
}
return ref;
}
@@ -484,7 +484,7 @@ static spl_ast_node_ref_t parse_var_const_decl(parser_t *p, spl_ast_node_ref_vec
if (t && t->type == TOK_SEMICOLON) {
advance(p);
} else {
LOG_WARN("need semicolon in decl var/const");
SPL_WARN(t, "need semicolon in decl var/const");
}
return ref;
}
@@ -1867,8 +1867,10 @@ static void dump_node(spl_ast_t *ast, spl_ast_node_ref_t node_ref, dump_stack_t
case SPL_AST_FN_DEFINE:
dump_vec(ast, node->fn_decl.attr_list, stack);
dump_vec(ast, node->fn_decl.param_list, stack);
if (node->fn_decl.type_expr)
dump_node(ast, node->fn_decl.type_expr, stack, 1);
if (node->fn_decl.type_expr) {
last = node->kind == SPL_AST_FN_DECL ? 1 : 0;
dump_node(ast, node->fn_decl.type_expr, stack, last);
}
dump_vec(ast, node->fn_decl.block, stack);
break;

5
stage1/spl_ast.h
View File

@@ -139,7 +139,10 @@ struct spl_ast_node {
spl_ast_node_kind_t kind;
spl_dbg_node_t dbg;
usize resolved_def_id;
union {
usize resolved_def_id;
usize resolved_type_id;
};
union {
spl_ast_node_ref_vec_t container_members; /* container_decl */

14
stage1/spl_dbg.h
View File

@@ -10,8 +10,16 @@ typedef struct {
// TODO
} spl_dbg_node_t;
#define SPL_FATAL(tok, fmt, ...) \
LOG_FATAL("fatal at %s:%zd:%zd " fmt, ((tok) && (tok)->fname ? (tok)->fname : "<null>"), \
((tok) ? (tok)->line : 0), ((tok) ? (tok)->col : 0), ##__VA_ARGS__)
#define SPL_FATAL(dbg, fmt, ...) \
LOG_FATAL("fatal at %s:%zd:%zd " fmt, ((dbg) && (dbg)->fname ? (dbg)->fname : "<null>"), \
((dbg) ? (dbg)->line : 0), ((dbg) ? (dbg)->col : 0), ##__VA_ARGS__)
#define SPL_ERROR(dbg, fmt, ...) \
LOG_ERROR("error at %s:%zd:%zd " fmt, ((dbg) && (dbg)->fname ? (dbg)->fname : "<null>"), \
((dbg) ? (dbg)->line : 0), ((dbg) ? (dbg)->col : 0), ##__VA_ARGS__)
#define SPL_WARN(dbg, fmt, ...) \
LOG_ERROR("warn at %s:%zd:%zd " fmt, ((dbg) && (dbg)->fname ? (dbg)->fname : "<null>"), \
((dbg) ? (dbg)->line : 0), ((dbg) ? (dbg)->col : 0), ##__VA_ARGS__)
#endif /* __SPL_DBG_H__ */

2
stage1/spl_ir.h
View File

@@ -222,7 +222,7 @@ typedef struct {
SPL_IR_ATTR_NAKED, /* 不实现 */
SPL_IR_ATTR_NOINLINE, /* 不实现 */
SPL_IR_ATTR_ALWAYSINLINE, /* 不实现 */
};
} kind;
} spl_ir_attr_t;
typedef VEC(spl_ir_attr_t) spl_ir_attr_vec_t;

225
stage1/spl_sema.c
View File

@@ -1,7 +1,5 @@
#include "spl_sema.h"
// Scope part
void spl_scope_init(spl_scope_t *scope) {
vec_init(scope->scopes);
vec_push(scope->scopes, (spl_scope_node_t){0});
@@ -32,7 +30,7 @@ bool spl_scope_insert(spl_scope_t *scope, spl_scope_id_t id, spl_symbol_t symbol
spl_scope_node_t *node = &vec_at(scope->scopes, id);
if (map_get(node->symbols, symbol.name, &old)) {
// spl_type_def(sema->type, old); TODO debug node
LOG_ERROR("find same symbol %s", symbol.name);
SPL_ERROR(&(spl_dbg_node_t){0}, "find same symbol %s", symbol.name);
return false;
}
map_put(node->symbols, symbol.name, symbol);
@@ -43,17 +41,14 @@ bool spl_scope_find(spl_scope_t *scope, const char *name, spl_symbol_t *out) {
if (scope == NULL || name == NULL || out == NULL) {
return false;
}
for (spl_scope_node_t *s = &vec_at(scope->scopes, scope->current_scope); s != 0;
s = &vec_at(scope->scopes, s->parent)) {
if (map_get(s->symbols, name, out) == true) {
for (spl_scope_id_t id = scope->current_scope; id != 0; id = vec_at(scope->scopes, id).parent) {
spl_scope_node_t *s = &vec_at(scope->scopes, id);
if (map_get(s->symbols, name, out)) {
Assert(out->kind != SPL_SYMBOL_KIND_ERROR);
break;
return true;
}
}
if (out->kind == SPL_SYMBOL_KIND_ERROR) {
return false;
}
return true;
return false;
}
// Parse once
@@ -61,7 +56,6 @@ static void sema_collect(spl_sema_t *sema, spl_ast_node_ref_t ref) {
Assert(sema != NULL && ref != 0);
spl_ast_node_t *n = spl_ast_node(sema->ast, ref);
spl_symbol_t symbol = {0};
spl_def_id_t def = 0;
Assert(n != NULL);
switch (n->kind) {
case SPL_AST_CONTAINER_MEMBERS: {
@@ -87,7 +81,7 @@ static void sema_collect(spl_sema_t *sema, spl_ast_node_ref_t ref) {
n->resolved_def_id = symbol.node;
n = spl_ast_node(sema->ast, n->type_decl.type_expr);
if (!n) {
SPL_FATAL(&n->dbg, "type_decl must have type_expr");
SPL_ERROR(&n->dbg, "type_decl must have type_expr");
return;
}
@@ -157,7 +151,6 @@ static void sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
Assert(sema != NULL);
spl_ast_node_t *n = spl_ast_node(sema->ast, ref);
spl_symbol_t symbol = {0};
spl_def_id_t def = 0;
Assert(n != NULL);
switch (n->kind) {
case SPL_AST_NONE:
@@ -181,9 +174,10 @@ static void sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
sema->scope->current_scope = scope_id;
vec_for(n->fn_decl.param_list, i) {
spl_ast_node_ref_t ref = vec_at(n->fn_decl.param_list, i);
// sema_parse(sema, ref);
sema_parse(sema, ref);
def = spl_type_def(sema->type, n->resolved_def_id);
spl_ast_node_t *node = spl_ast_node(sema->ast, ref);
Assert(node->kind = SPL_AST_PARAM_DECL);
Assert(node->kind == SPL_AST_PARAM_DECL);
spl_var_def_t var_def = {0};
var_def.name = node->param_decl.name;
@@ -192,11 +186,15 @@ static void sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
}
vec_for(n->fn_decl.block, i) { sema_parse(sema, vec_at(n->fn_decl.block, i)); }
sema->scope->current_scope = old_id;
// spl_type_def_fn_build(sema->type, n->resolved_def_id, )
} break;
case SPL_AST_TYPE_DECL:
TODO();
break;
case SPL_AST_VAR_DECL: {
case SPL_AST_TYPE_DECL: {
if (n->type_decl.type_expr)
sema_parse(sema, n->type_decl.type_expr);
} break;
case SPL_AST_VAR_DECL:
case SPL_AST_CONST_DECL: {
if (n->resolved_def_id == 0) {
symbol.name = n->var_const_decl.name;
symbol.kind = SPL_SYMBOL_KIND_VAR;
@@ -207,37 +205,106 @@ static void sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
def->kind = SPL_DEF_VAR;
spl_scope_insert(sema->scope, sema->scope->current_scope, symbol);
}
spl_def_node_t *def_node = spl_type_def(sema->type, n->resolved_def_id);
if (n->var_const_decl.type_expr)
sema_parse(sema, n->var_const_decl.type_expr);
if (n->var_const_decl.expr)
sema_parse(sema, n->var_const_decl.expr);
} break;
case SPL_AST_MEMBER_DECL: {
if (n->member_decl.type_expr)
sema_parse(sema, n->member_decl.type_expr);
} break;
case SPL_AST_CONST_DECL:
case SPL_AST_MEMBER_DECL:
TODO();
break;
case SPL_AST__COMPTIME_STMT:
case SPL_AST__DIRECTIVE_BLOCK:
case SPL_AST_PARAM_DECL:
break;
case SPL_AST_PARAM_DECL: {
if (n->resolved_def_id == 0) {
symbol.name = n->param_decl.name;
symbol.kind = SPL_SYMBOL_KIND_VAR;
symbol.node = spl_type_def_alloc(sema->type);
n->resolved_def_id = symbol.node;
spl_def_node_t *def = spl_type_def(sema->type, symbol.node);
def->kind = SPL_DEF_VAR;
spl_scope_insert(sema->scope, sema->scope->current_scope, symbol);
}
if (n->param_decl.type_expr)
sema_parse(sema, n->param_decl.type_expr);
} break;
case SPL_AST_ATTR_ITEM:
case SPL_AST_ARGG_INIT_ITEM:
case SPL_AST_IF_STATEMENT:
case SPL_AST_IFVAR_STATEMENT:
case SPL_AST_WHILE_STATEMENT:
case SPL_AST_LOOP_STATEMENT:
case SPL_AST_FOR_STATEMENT:
case SPL_AST_MATCH_STATEMENT:
TODO();
vec_for(n->attr_item.expr_list, i) { sema_parse(sema, vec_at(n->attr_item.expr_list, i)); }
break;
case SPL_AST_ARGG_INIT_ITEM: {
if (n->aggregate_init_item.expr)
sema_parse(sema, n->aggregate_init_item.expr);
} break;
case SPL_AST_IF_STATEMENT: {
if (n->if_statement.expr)
sema_parse(sema, n->if_statement.expr);
vec_for(n->if_statement.if_block, i) {
sema_parse(sema, vec_at(n->if_statement.if_block, i));
}
vec_for(n->if_statement.else_block, i) {
sema_parse(sema, vec_at(n->if_statement.else_block, i));
}
} break;
case SPL_AST_IFVAR_STATEMENT: {
if (n->ifvar_statement.packed_expr)
sema_parse(sema, n->ifvar_statement.packed_expr);
vec_for(n->ifvar_statement.if_block, i) {
sema_parse(sema, vec_at(n->ifvar_statement.if_block, i));
}
vec_for(n->ifvar_statement.else_block, i) {
sema_parse(sema, vec_at(n->ifvar_statement.else_block, i));
}
} break;
case SPL_AST_WHILE_STATEMENT: {
if (n->while_statement.expr)
sema_parse(sema, n->while_statement.expr);
vec_for(n->while_statement.while_block, i) {
sema_parse(sema, vec_at(n->while_statement.while_block, i));
}
} break;
case SPL_AST_LOOP_STATEMENT: {
vec_for(n->loop_statement.loop_block, i) {
sema_parse(sema, vec_at(n->loop_statement.loop_block, i));
}
} break;
case SPL_AST_FOR_STATEMENT: {
vec_for(n->for_statement.expr_vec, i) {
sema_parse(sema, vec_at(n->for_statement.expr_vec, i));
}
vec_for(n->for_statement.block, i) { sema_parse(sema, vec_at(n->for_statement.block, i)); }
} break;
case SPL_AST_MATCH_STATEMENT: {
if (n->match_statement.expr)
sema_parse(sema, n->match_statement.expr);
vec_for(n->match_statement.paced_exprs, i) {
sema_parse(sema, vec_at(n->match_statement.paced_exprs, i));
}
vec_for(n->match_statement.match_block, i) {
sema_parse(sema, vec_at(n->match_statement.match_block, i));
}
} break;
case SPL_AST_RET_STATEMENT: {
sema_parse(sema, n->ret_statement.expr);
} break;
case SPL_AST_BREAK_STATEMENT:
case SPL_AST_CONTINUE_STATEMENT:
case SPL_AST_DEFER_STATEMENT:
case SPL_AST_DEFER_STATEMENT: {
vec_for(n->defer_statement.block_or_statement, i) {
sema_parse(sema, vec_at(n->defer_statement.block_or_statement, i));
}
} break;
case SPL_AST_TRY_STATEMENT:
case SPL_AST_CATCH_STATEMENT:
case SPL_AST_ERRDEFER_STATEMEMT:
case SPL_AST_EXPR_STATEMENT:
case SPL_AST_PACKED_EXPR:
break;
case SPL_AST_PACKED_EXPR: {
if (n->packed_expr.expr)
sema_parse(sema, n->packed_expr.expr);
} break;
case SPL_AST_ASSIGN_EXPR:
case SPL_AST_ASSIGN_ADD_EXPR:
case SPL_AST_ASSIGN_SUB_EXPR:
@@ -268,17 +335,49 @@ static void sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
case SPL_AST_MUL_EXPR:
case SPL_AST_DIV_EXPR:
case SPL_AST_MOD_EXPR:
if (n->op_expr.left)
sema_parse(sema, n->op_expr.left);
if (n->op_expr.right)
sema_parse(sema, n->op_expr.right);
break;
case SPL_AST_MINUS_EXPR:
case SPL_AST_NOT_EXPR:
case SPL_AST_BIT_NOT_EXPR:
case SPL_AST_ADDRESS_EXPR:
if (n->prefix_expr.postfix_expr)
sema_parse(sema, n->prefix_expr.postfix_expr);
break;
case SPL_AST_CALL_EXPR:
if (n->postfix_expr.primary_expr)
sema_parse(sema, n->postfix_expr.primary_expr);
vec_for(n->postfix_expr.call_expr, i) {
sema_parse(sema, vec_at(n->postfix_expr.call_expr, i));
}
break;
case SPL_AST_FIELD_EXPR:
case SPL_AST_DEREF_EXPR:
if (n->postfix_expr.primary_expr)
sema_parse(sema, n->postfix_expr.primary_expr);
break;
case SPL_AST_INDEX_EXPR:
if (n->postfix_expr.primary_expr)
sema_parse(sema, n->postfix_expr.primary_expr);
if (n->postfix_expr.index_expr)
sema_parse(sema, n->postfix_expr.index_expr);
break;
case SPL_AST_SLICE_EXPR:
if (n->postfix_expr.primary_expr)
sema_parse(sema, n->postfix_expr.primary_expr);
if (n->postfix_expr.slice_expr.begin)
sema_parse(sema, n->postfix_expr.slice_expr.begin);
if (n->postfix_expr.slice_expr.end)
sema_parse(sema, n->postfix_expr.slice_expr.end);
break;
case SPL_AST_AS_EXPR:
TODO();
if (n->postfix_expr.primary_expr)
sema_parse(sema, n->postfix_expr.primary_expr);
if (n->postfix_expr.type_expr)
sema_parse(sema, n->postfix_expr.type_expr);
break;
case SPL_AST_EXPR_INTEGER_LIT:
case SPL_AST_EXPR_FLOAT_LIT:
@@ -291,28 +390,75 @@ static void sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
break;
case SPL_AST_EXPR_IDENT: {
if (!spl_scope_find(sema->scope, n->primary_expr.ident, &symbol)) {
LOG_FATAL("can't find ident `%s`", n->primary_expr.ident);
SPL_ERROR(&n->dbg, "can't find ident `%s`", n->primary_expr.ident);
return;
}
Assert(symbol.node != 0);
n->resolved_def_id = symbol.node;
} break;
case SPL_AST_ARGGREGATE_INIT:
vec_for(n->primary_expr.aggregate_init.expr, i) {
sema_parse(sema, vec_at(n->primary_expr.aggregate_init.expr, i));
}
break;
case SPL_AST_EXPR_EXPR:
if (n->primary_expr.expr)
sema_parse(sema, n->primary_expr.expr);
break;
case SPL_AST_ARRAY_LIT:
if (n->primary_expr.array_lit_expr.type_expr)
sema_parse(sema, n->primary_expr.array_lit_expr.type_expr);
vec_for(n->primary_expr.array_lit_expr.expr_list, i) {
sema_parse(sema, vec_at(n->primary_expr.array_lit_expr.expr_list, i));
}
break;
case SPL_AST_BUILTIN_EXPR:
vec_for(n->primary_expr.builtin_expr.expr_list, i) {
sema_parse(sema, vec_at(n->primary_expr.builtin_expr.expr_list, i));
}
break;
case SPL_AST_BLOCK_EXPR:
vec_for(n->primary_expr.block_expr, i) {
sema_parse(sema, vec_at(n->primary_expr.block_expr, i));
}
break;
case SPL_AST_BASE_TYPE_FN:
vec_for(n->type_expr.attr_list, i) { sema_parse(sema, vec_at(n->type_expr.attr_list, i)); }
vec_for(n->type_expr.fn_type.param_list, i) {
sema_parse(sema, vec_at(n->type_expr.fn_type.param_list, i));
}
if (n->type_expr.fn_type.type_expr)
sema_parse(sema, n->type_expr.fn_type.type_expr);
break;
case SPL_AST_BASE_TYPE_PATH:
TODO();
vec_for(n->type_expr.attr_list, i) { sema_parse(sema, vec_at(n->type_expr.attr_list, i)); }
break;
case SPL_AST_TYPE_POINTER:
vec_for(n->type_expr.attr_list, i) { sema_parse(sema, vec_at(n->type_expr.attr_list, i)); }
if (n->type_expr.pointer_type.pointee)
sema_parse(sema, n->type_expr.pointer_type.pointee);
break;
case SPL_AST_TYPE_ARRAY:
vec_for(n->type_expr.attr_list, i) { sema_parse(sema, vec_at(n->type_expr.attr_list, i)); }
if (n->type_expr.array_type.element)
sema_parse(sema, n->type_expr.array_type.element);
if (n->type_expr.array_type.size)
sema_parse(sema, n->type_expr.array_type.size);
break;
case SPL_AST_TYPE_SLICE:
vec_for(n->type_expr.attr_list, i) { sema_parse(sema, vec_at(n->type_expr.attr_list, i)); }
if (n->type_expr.slice_type.element)
sema_parse(sema, n->type_expr.slice_type.element);
break;
case SPL_AST_TYPE_STRUCT:
case SPL_AST_TYPE_UNION:
case SPL_AST_TYPE_SHAPE:
case SPL_AST_TYPE_ENUM:
vec_for(n->type_expr.attr_list, i) { sema_parse(sema, vec_at(n->type_expr.attr_list, i)); }
vec_for(n->type_expr.aggregate_list, i) {
sema_parse(sema, vec_at(n->type_expr.aggregate_list, i));
}
break;
case SPL_AST_TYPE_VOID:
case SPL_AST_TYPE_BOOL:
case SPL_AST_TYPE_OPAQUE:
@@ -330,7 +476,6 @@ static void sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
case SPL_AST_TYPE__F64:
case SPL_AST_TYPE_ANY:
case SPL_AST_TYPE_IDENT:
TODO();
break;
case SPL_AST_COUNT:
UNREACHABLE();

149
stage1/spl_type.c
View File

@@ -1,6 +1,52 @@
#include "spl_type.h"
static usize spl_type_hash(spl_type_node_t n) { return n.kind; }
static usize spl_type_hash(spl_type_node_t n) {
usize hash = n.kind << 20;
switch (n.kind) {
case SPL_TYPE_ERROR:
case SPL_TYPE_VOID:
case SPL_TYPE_BOOL:
break;
case SPL_TYPE_INT:
hash += n.int_type.bits + n.int_type.is_signed;
break;
case SPL_TYPE_FLOAT:
hash += n.float_type.bits;
break;
case SPL_TYPE_PTR:
hash += n.ptr_pointee;
break;
case SPL_TYPE_SLICE:
hash += n.slice_element;
break;
case SPL_TYPE_RANGE:
hash += n.range_element;
break;
case SPL_TYPE_ARRAY:
hash += n.array_type.element + n.array_type.len;
break;
case SPL_TYPE_STRUCT:
case SPL_TYPE_UNION:
hash += n.layout.mode;
hash += n.layout.fixed_align_bits;
vec_for(n.agg_field_types, i) { hash += vec_at(n.agg_field_types, i); }
break;
case SPL_TYPE_ENUM:
hash += n.layout.mode;
hash += n.layout.fixed_align_bits;
hash += n.adt_type.tag_type;
vec_for(n.adt_type.variants, i) { hash += vec_at(n.adt_type.variants, i); }
break;
case SPL_TYPE_FN:
hash += n.fn_type.ret;
vec_for(n.fn_type.params, i) { hash += vec_at(n.fn_type.params, i); }
break;
default: // TODO
break;
}
return hash;
}
static int spl_type_eq(spl_type_node_t n1, spl_type_node_t n2) {
if (n1.kind != n2.kind)
return 1;
@@ -37,8 +83,42 @@ static int spl_type_eq(spl_type_node_t n1, spl_type_node_t n2) {
if (n1.array_type.len != n2.array_type.len)
return 1;
break;
// TODO
default:
case SPL_TYPE_STRUCT:
case SPL_TYPE_UNION:
if (n1.layout.mode != n2.layout.mode ||
n1.layout.fixed_align_bits != n2.layout.fixed_align_bits)
return 1;
if (vec_size(n1.agg_field_types) != vec_size(n2.agg_field_types))
return 1;
vec_for(n1.agg_field_types, i) {
if (vec_at(n1.agg_field_types, i) != vec_at(n2.agg_field_types, i))
return 1;
}
break;
case SPL_TYPE_ENUM:
if (n1.layout.mode != n2.layout.mode ||
n1.layout.fixed_align_bits != n2.layout.fixed_align_bits)
return 1;
if (n1.adt_type.tag_type != n2.adt_type.tag_type)
return 1;
if (vec_size(n1.adt_type.variants) != vec_size(n2.adt_type.variants))
return 1;
vec_for(n1.adt_type.variants, i) {
if (vec_at(n1.adt_type.variants, i) != vec_at(n2.adt_type.variants, i))
return 1;
}
break;
case SPL_TYPE_FN:
if (n1.fn_type.ret != n2.fn_type.ret)
return 1;
if (vec_size(n1.fn_type.params) != vec_size(n2.fn_type.params))
return 1;
vec_for(n1.fn_type.params, i) {
if (vec_at(n1.fn_type.params, i) != vec_at(n2.fn_type.params, i))
return 1;
}
break;
default: // TODO
return 1;
}
return 0;
@@ -60,6 +140,65 @@ spl_type_id_t spl_type_def_alloc(spl_type_t *type) {
return vec_size(type->def_table) - 1;
}
spl_type_id_t spl_type_def_agg_build(spl_type_t *type, spl_def_id_t def, spl_type_node_kind_t tk,
spl_type_id_t tag_type, spl_type_layout_t layout) {
if (tk != SPL_TYPE_STRUCT && tk != SPL_TYPE_UNION && tk != SPL_TYPE_ENUM) {
return 0;
}
spl_def_node_t *d = spl_type_def(type, def);
if (!d) {
return 0;
}
spl_type_node_t tn = {0};
tn.kind = tk;
tn.layout = layout;
if (tk == SPL_TYPE_ENUM) {
vec_init(tn.adt_type.variants);
tn.adt_type.tag_type = tag_type;
} else {
vec_init(tn.agg_field_types);
}
vec_for(d->agg_def, i) {
if (tk == SPL_TYPE_ENUM) {
vec_push(tn.adt_type.variants, vec_at(d->agg_def, i).type_id);
} else {
vec_push(tn.agg_field_types, vec_at(d->agg_def, i).type_id);
}
}
usize old = vec_size(type->type_table);
spl_type_id_t tid = spl_type_node_push(type, tn);
if (tid < old) {
if (tk == SPL_TYPE_ENUM) {
vec_free(tn.adt_type.variants);
} else {
vec_free(tn.agg_field_types);
}
}
d->type_id = tid;
return tid;
}
spl_type_id_t spl_type_def_fn_build(spl_type_t *type, spl_def_id_t def, spl_type_id_t ret) {
spl_def_node_t *d = spl_type_def(type, def);
if (!d) {
return 0;
}
spl_type_node_t tn = {0};
tn.kind = SPL_TYPE_FN;
vec_init(tn.fn_type.params);
vec_for(d->fn_params_def, i) {
vec_push(tn.fn_type.params, vec_at(d->fn_params_def, i).type_id);
}
tn.fn_type.ret = ret;
usize old = vec_size(type->type_table);
spl_type_id_t tid = spl_type_node_push(type, tn);
if (tid < old) {
vec_free(tn.fn_type.params);
}
d->type_id = tid;
return tid;
}
void spl_type_init(spl_type_t *type) {
vec_init(type->type_table);
vec_push(type->type_table, (spl_type_node_t){0});
@@ -166,7 +305,7 @@ spl_def_node_t *spl_type_def(spl_type_t *type, spl_def_id_t id) {
void spl_type_pure_dump(spl_type_t *type, spl_type_id_t id) {
spl_type_node_t *n = spl_type_node(type, id);
if (!n) {
printf("(err)");
printf("none");
return;
}
switch (n->kind) {
@@ -231,7 +370,7 @@ void spl_type_pure_dump(spl_type_t *type, spl_type_id_t id) {
void spl_type_def_dump(spl_type_t *type, spl_def_id_t id) {
spl_def_node_t *node = spl_type_def(type, id);
if (!node) {
printf("(err)");
printf("none");
return;
}

54
stage1/spl_type.h
View File

@@ -9,27 +9,37 @@ typedef VEC(spl_type_id_t) spl_type_id_vec_t;
typedef usize spl_def_id_t; /* 0 is error */
typedef VEC(spl_def_id_t) spl_def_id_vec_t;
typedef enum {
SPL_TYPE_ERROR,
SPL_TYPE_VOID,
SPL_TYPE_BOOL,
SPL_TYPE_INT,
SPL_TYPE_FLOAT,
SPL_TYPE_PTR,
SPL_TYPE_SLICE, // 未来拥有泛型后删除
SPL_TYPE_RANGE, // 未来拥有泛型后删除
SPL_TYPE_ARRAY,
SPL_TYPE_STRUCT,
SPL_TYPE_UNION,
SPL_TYPE_ENUM,
SPL_TYPE_FN,
SPL_TYPE_ID,
} spl_type_node_kind_t;
typedef enum {
SPL_TYPE_LAYOUT_AUTO,
SPL_TYPE_LAYOUT_EXTERN_C,
SPL_TYPE_LAYOUT_PACKED,
} spl_type_layout_mode_t;
typedef struct {
enum {
SPL_TYPE_ERROR,
SPL_TYPE_VOID,
SPL_TYPE_BOOL,
SPL_TYPE_INT,
SPL_TYPE_FLOAT,
SPL_TYPE_PTR,
SPL_TYPE_SLICE, // 未来拥有泛型后删除
SPL_TYPE_RANGE, // 未来拥有泛型后删除
SPL_TYPE_ARRAY,
SPL_TYPE_STRUCT,
SPL_TYPE_UNION,
SPL_TYPE_ENUM,
SPL_TYPE_FN,
SPL_TYPE_ID,
} kind;
struct {
enum { AUTO, EXTERN_C, PACKED } mode;
usize fixed_align_bits;
} layout;
spl_type_layout_mode_t mode;
usize fixed_align_bits;
} spl_type_layout_t;
typedef struct {
spl_type_node_kind_t kind;
spl_type_layout_t layout;
union {
struct {
usize bits;
@@ -109,4 +119,8 @@ spl_def_node_t *spl_type_def(spl_type_t *type, spl_def_id_t id);
spl_type_id_t spl_type_def_alloc(spl_type_t *type);
spl_type_id_t spl_type_node_push(spl_type_t *type, spl_type_node_t type_node);
spl_type_id_t spl_type_def_agg_build(spl_type_t *type, spl_def_id_t def, spl_type_node_kind_t tk,
spl_type_id_t tag_type, spl_type_layout_t layout);
spl_type_id_t spl_type_def_fn_build(spl_type_t *type, spl_def_id_t def, spl_type_id_t ret);
#endif /* __SPL_TYPE_H__ */