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

stage2 提供近乎完整的功能但出现严重性能问题 添加stage0的原生性能记录 stage1添加更多内置函数 nob重构代码使其更加健壮

Browse Source
This commit is contained in:
zzy committed 2026-09-19 18:08:43 +08:00
1 parent b5a7a811b3
commit e02b0c633a
35 files changed
+14018 -216
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

nob.c
+230 -176
View File
@@ -1,5 +1,7 @@
#define SPL_CFLAGS "-Wall", "-Wextra", "-O0", "-g", "-D_CRT_SECURE_NO_WARNINGS"
#define COMMON_CFLAGS "-Wall", "-Wextra", "-D_CRT_SECURE_NO_WARNINGS"
#define SPL_CFLAGS COMMON_CFLAGS, "-O0", "-g"
#define SPL_OPTIMIZATION_FLAG COMMON_CFLAGS, "-O2"
#define nob_cc_flags(cmd) nob_cmd_append(cmd, SPL_CFLAGS)
#undef UNICODE
#define NOB_IMPLEMENTATION
@@ -20,7 +22,7 @@ static const char *CFLAGS_STAMP = BUILD_FOLDER ".cflags";
/* clang-format off */
#define VM_SRCS "stage0/spl_mcode.c", "stage0/spl_syscall.c", "stage0/spl_vm.c",
static const char *spl_cli_srcs[] = {"stage0/spl_cli.c", VM_SRCS};
static const char *test_srcs[] = {"stage0/test_spl_vm.c", VM_SRCS};
static const char *vm_test_srcs[] = {"stage0/test_spl_vm.c", VM_SRCS};
static const char *splc0_srcs[] = {
"stage1/splc0.c",
"stage1/spl_diag.c",
@@ -44,27 +46,6 @@ static const char *splc0_srcs[] = {
};
/* clang-format on */
typedef struct {
const char *name;
const char **srcs;
size_t srcs_count;
} target_t;
static target_t exe_targets[] = {
{"spl_cli", spl_cli_srcs, NOB_ARRAY_LEN(spl_cli_srcs)},
{"test", test_srcs, NOB_ARRAY_LEN(test_srcs)},
{"splc0", splc0_srcs, NOB_ARRAY_LEN(splc0_srcs)},
};
static const target_t *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);
@@ -89,6 +70,10 @@ static const char *exe_path(const char *name) {
#endif
}
static const char *sir_path(const char *name) {
return nob_temp_sprintf(BUILD_FOLDER "%s.sir", name);
}
static bool sync_cflags_stamp(void) {
Nob_String_View cflags = nob_sv_from_cstr(CFLAGS_STR);
Nob_String_Builder old = {0};
@@ -106,138 +91,234 @@ static bool sync_cflags_stamp(void) {
return true;
}
// 头文件依赖：收集 stage0/stage1 下的所有 .h，作为每个 object 的输入。
// nob 不解析 #include，这里用“任一头文件变化则重建全部 object”的保守策略，
// 避免头文件改动后各 .o 结构体布局/常量不一致导致的隐蔽错误。
static Nob_Files g_headers = {0};
static bool collect_header_entry(Nob_Walk_Entry entry) {
if (entry.type != NOB_FILE_REGULAR)
return true;
const char *dot = strrchr(entry.path, '.');
if (!dot || strcmp(dot, ".h") != 0)
return true;
if (strstr(entry.path, ".old") != NULL)
return true;
da_append(&g_headers, nob_temp_strdup(entry.path));
return true;
}
static bool collect_headers(void) {
if (g_headers.count > 0)
return true;
if (!nob_walk_dir("stage0", collect_header_entry))
return false;
if (!nob_walk_dir("stage1", collect_header_entry))
return false;
return true;
}
// stage2 的所有 .spl：作为 splc1.sir 的依赖（不解析 @import，保守全量重建）。
static Nob_Files g_spl2 = {0};
static bool collect_spl2_entry(Nob_Walk_Entry entry) {
if (entry.type != NOB_FILE_REGULAR)
return true;
const char *dot = strrchr(entry.path, '.');
if (!dot || strcmp(dot, ".spl") != 0)
return true;
da_append(&g_spl2, nob_temp_strdup(entry.path));
return true;
}
static bool collect_spl2(void) {
if (g_spl2.count > 0)
return true;
return nob_walk_dir("stage2", collect_spl2_entry);
}
static bool prepare_build(void) {
if (!nob_mkdir_if_not_exists(BUILD_FOLDER))
return false;
if (!sync_cflags_stamp())
return false;
if (!collect_headers())
return false;
return collect_spl2();
return true;
}
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;
}
typedef struct build {
const char *name;
enum {
BUILD_EXE,
BUILD_EXE_WITH_OPTIMIZATION,
BUILD_SIR,
} kind;
union {
struct {
const char **srcs;
size_t srcs_count;
const char **headers;
size_t headers_count;
} exe;
struct {
const char *src;
const char *compiler;
} sir;
};
} build_t;
// 依赖：源文件 + 所有头文件 + cflags 戳。
size_t ninputs = g_headers.count + 2;
const char **inputs = (const char **)nob_temp_alloc(sizeof(const char *) * ninputs);
inputs[0] = src;
for (size_t i = 0; i < g_headers.count; ++i) {
inputs[i + 1] = g_headers.items[i];
}
inputs[ninputs - 1] = CFLAGS_STAMP;
typedef struct {
const char **items;
size_t count;
size_t capacity;
} str_da_t;
int needs = nob_needs_rebuild(obj, inputs, ninputs);
if (needs < 0)
return false;
if (needs == 0)
return true;
typedef struct run {
const char *name;
const char *interpreter;
} run_t;
bool run_target(const char *name, Nob_Cmd *args);
const char *build_target(const char *name);
static const char *build_exe(build_t *target) {
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);
}
str_da_t objs = {0};
str_da_t deps = {0};
for (size_t i = 0; i < target->exe.srcs_count; ++i) {
const char *src = target->exe.srcs[i];
const char *obj = obj_path(src);
if (!nob_file_exists(src)) {
nob_log(NOB_ERROR, "source file `%s` does not exist", src);
goto defer;
}
da_append(&objs, obj);
da_append(&deps, src);
da_append(&deps, CFLAGS_STAMP);
for (size_t j = 0; j < target->exe.headers_count; ++j) {
da_append(&deps, target->exe.headers[j]);
}
int needs = nob_needs_rebuild(obj, deps.items, deps.count);
deps.count = 0; // 清空 deps，下一轮循环重新收集
if (needs < 0)
goto defer;
if (needs == 0)
continue;
nob_cc(&cmd);
nob_cc_flags(&cmd);
nob_cmd_append(&cmd, "-c");
nob_cc_inputs(&cmd, src);
nob_cc_output(&cmd, obj);
if (!nob_cmd_run(&cmd)) {
nob_log(NOB_ERROR, "failed to compile `%s`", src);
goto defer;
}
cmd.count = 0; // 清空 cmd，下一轮循环重新构建
}
static bool link_exe(const target_t *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);
int needs = nob_needs_rebuild(exe, objs.items, objs.count);
if (needs < 0)
return false;
goto defer;
if (needs == 0)
return true;
return exe;
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_cmd_append(&cmd, SPL_OPTIMIZATION_FLAG);
for (size_t i = 0; i < objs.count; ++i) {
nob_cc_inputs(&cmd, objs.items[i]);
}
nob_cc_output(&cmd, exe);
return nob_cmd_run(&cmd);
if (!nob_cmd_run(&cmd)) {
goto defer;
}
return exe;
defer:
nob_cmd_free(cmd);
da_free(objs);
da_free(deps);
return NULL;
}
static bool build_target(const char *name) {
const target_t *target = find_exe_target(name);
if (target == NULL) {
nob_log(NOB_ERROR, "unknown target `%s`", name);
static build_t targets[] = {
{
"spl_cli",
BUILD_EXE_WITH_OPTIMIZATION,
.exe = {.srcs = spl_cli_srcs,
.srcs_count = NOB_ARRAY_LEN(spl_cli_srcs),
.headers = NULL,
.headers_count = 0},
},
{
"spl_cli_g",
BUILD_EXE,
.exe = {.srcs = spl_cli_srcs,
.srcs_count = NOB_ARRAY_LEN(spl_cli_srcs),
.headers = NULL,
.headers_count = 0},
},
{
"vm_test",
BUILD_EXE,
.exe = {.srcs = vm_test_srcs,
.srcs_count = NOB_ARRAY_LEN(vm_test_srcs),
.headers = NULL,
.headers_count = 0},
},
{
"splc0",
BUILD_EXE,
.exe = {.srcs = splc0_srcs,
.srcs_count = NOB_ARRAY_LEN(splc0_srcs),
.headers = NULL,
.headers_count = 0},
},
{
"splc1",
BUILD_SIR,
.sir = {.src = "stage2/splc1.spl", .compiler = "splc0"},
},
{
"splc1s",
BUILD_SIR,
.sir = {.src = "stage2/splc1.spl", .compiler = "splc1"},
},
{
"splc1r",
BUILD_SIR,
.sir = {.src = "stage2/splc1.spl", .compiler = "splc1s"},
},
};
const char *build_target(const char *name) {
if (!prepare_build())
return NULL;
for (size_t i = 0; i < NOB_ARRAY_LEN(targets); ++i) {
if (name != NULL && strcmp(targets[i].name, name) != 0) {
continue;
}
build_t *target = &targets[i];
switch (target->kind) {
case BUILD_EXE_WITH_OPTIMIZATION:
case BUILD_EXE: {
return build_exe(target);
}
case BUILD_SIR: {
Nob_Cmd cmd = {0};
const char *target_sir = sir_path(name);
nob_cmd_append(&cmd, target->sir.src, target_sir);
if (!run_target(target->sir.compiler, &cmd)) {
nob_log(NOB_ERROR, "failed to build `%s`", name);
nob_cmd_free(cmd);
return NULL;
}
nob_cmd_free(cmd);
return target_sir;
}
default:
NOB_UNREACHABLE("build_t.kind");
}
}
nob_log(NOB_ERROR, "unknown build target `%s`", name);
return NULL;
}
static run_t runs[] = {
{"spl_cli", NULL}, {"vm_test", NULL}, {"splc0", NULL},
{"splc1", "spl_cli"}, {"splc1r", "spl_cli"}, {"splc1s", "spl_cli"},
};
bool run_target_dry(const char *name, Nob_Cmd *args, Nob_Cmd *result) {
for (size_t i = 0; i < NOB_ARRAY_LEN(runs); ++i) {
if (strcmp(runs[i].name, name) != 0) {
continue;
}
const char *exe = build_target(runs[i].name);
const char *interpreter = runs[i].interpreter;
if (interpreter) {
const char *inter = build_target(interpreter);
if (!exe) {
nob_log(NOB_ERROR, "failed to build interpreter `%s` for `%s`", interpreter, name);
return false;
}
nob_cmd_append(result, inter);
}
nob_cmd_append(result, exe);
nob_cmd_extend(result, args);
return true;
}
nob_log(NOB_ERROR, "unknown run target `%s`", name);
return false;
}
bool run_target(const char *name, Nob_Cmd *args) {
Nob_Cmd result = {0};
if (!run_target_dry(name, args, &result)) {
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;
nob_log(NOB_INFO, "running `%s`", name);
bool ok = nob_cmd_run(&result);
nob_cmd_free(result);
return ok;
}
static void parse_expect(const char *name, Nob_Cmd_Result *expect) {
@@ -341,30 +422,15 @@ static bool test_once_with_dump(const char *fname, void *user_data) {
return nob_cmd_run(&cmd);
}
// 用 splc0 编译 stage2/splc1.spl -> build/splc1.sir（依赖 stage2 全部 .spl）。
static bool build_splc1(void) {
if (!build_target("splc0"))
return false;
const char *src = "stage2/splc1.spl";
const char *sir = BUILD_FOLDER "splc1.sir";
size_t ninputs = g_spl2.count + 2;
const char **inputs = (const char **)nob_temp_alloc(sizeof(const char *) * ninputs);
inputs[0] = src;
for (size_t i = 0; i < g_spl2.count; ++i)
inputs[i + 1] = g_spl2.items[i];
inputs[ninputs - 1] = CFLAGS_STAMP;
int needs = nob_needs_rebuild(sir, inputs, ninputs);
if (needs < 0)
return false;
if (needs == 0)
return true;
Nob_Cmd cmd = {0};
nob_cmd_append(&cmd, exe_path("splc0"), src, sir);
return nob_cmd_run(&cmd);
// 由源路径派生构建产物路径：build/<basename>.sir
static const char *artifact_sir(const char *src) {
const char *base = src;
for (const char *p = src; *p; ++p)
if (*p == '/' || *p == '\\')
base = p + 1;
const char *dot = strrchr(base, '.');
size_t len = dot ? (size_t)(dot - base) : strlen(base);
return nob_temp_sprintf(BUILD_FOLDER "%.*s.sir", (int)len, base);
}
static bool run_capture(Nob_Cmd *cmd, Nob_Cmd_Result *result) {
@@ -388,7 +454,7 @@ static bool test_once_diff(const char *fname, void *user_data) {
return false;
if (!build_target("spl_cli"))
return false;
if (!build_splc1())
if (!build_target("splc1"))
return false;
Nob_Cmd c_cmd = {0};
@@ -519,20 +585,16 @@ static void print_help(const char *program_name) {
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, " test <kind> build and run 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);
SetConsoleCP(CP_UTF8);
#endif
NOB_GO_REBUILD_URSELF_PLUS(argc, argv, "nob.h", "nob_popen.h");
set_log_handler(nob_cancer_log_handler);
@@ -553,7 +615,7 @@ int main(int argc, char **argv) {
return 1;
}
} else {
if (!build_all())
if (!build_target(NULL))
return 1;
}
return 0;
@@ -565,16 +627,11 @@ int main(int argc, char **argv) {
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));
Nob_Cmd runcmd = {0};
while (argc > 0) {
nob_cmd_append(&cmd, nob_shift(argv, argc));
nob_cmd_append(&runcmd, nob_shift(argv, argc));
}
return nob_cmd_run(&cmd) ? 0 : 1;
return !run_target(target_name, &runcmd);
}
if (strcmp(command_name, "test") == 0) {
@@ -629,11 +686,8 @@ int main(int argc, char **argv) {
}
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]);
}
for (size_t i = 0; i < NOB_ARRAY_LEN(targets); ++i) {
nob_log(NOB_INFO, "%s:", targets[i].name);
}
return 0;
}