Hojun-Cho
9cceb4ca8d
Promote commit-3's tri-color topo bail into a loud dep_cycle error that names the full import cycle, byte-identical both stages (cmd/ww/main.c + selfhost/cmd/ww/main.ww, deps.ha:243 parity). Add a non-vacuous negative gate (989_sepcycle_dup) proving the pre-existing w6l duplicate-symbol reject fires loud + non-zero on a cross-package collision; no new linker code. #58(b)(c) link-arg parity deferred (system()-string vs procrun()-argv is structurally un-unifiable in this scope); #61 filed for the byte-id-blind w6l_ww dup-message divergence.
1495 lines
49 KiB
C
1495 lines
49 KiB
C
/*
|
|
* ww — the user-facing driver. Plan 9 cc(1) / Hare hare(1) analogue.
|
|
*
|
|
* Pipeline:
|
|
* ww build foo.ww → w6c foo.ww > foo.s ; w6a foo.s > foo.o ;
|
|
* w6l -o foo foo.o <runtime.o>
|
|
* ww run foo.ww → build then exec ./foo
|
|
*
|
|
* Tool paths default to siblings of $0 (so a fresh build runs out of
|
|
* out/bin/), and can be overridden with WW_W6C / WW_W6A / WW_W6L.
|
|
*/
|
|
#include "ww.h"
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <sys/wait.h>
|
|
#include <sys/stat.h>
|
|
#include <dirent.h>
|
|
#include <libgen.h>
|
|
|
|
static const char *usage =
|
|
"usage: ww [-V] <subcommand> [args...]\n"
|
|
" -V print version and exit\n"
|
|
" build [path] compile module to a static binary (path defaults to cwd)\n"
|
|
" run [path] ... build then exec, passing extra args to the program\n"
|
|
" test [path] build and run *_test.ww in the module (path defaults to cwd)\n"
|
|
" fmt <path> reformat ww source\n"
|
|
" version print version and exit\n"
|
|
"\n"
|
|
" path forms:\n"
|
|
" foo.ww literal file\n"
|
|
" foo search cwd, -I dirs, then $WW_LIB for foo.ww or foo/foo.ww\n"
|
|
" lib/foo directory: build lib/foo/foo.ww\n"
|
|
" . build the cwd's <basename>.ww\n";
|
|
|
|
static char *self_dir; /* directory containing this binary */
|
|
|
|
static const char *
|
|
toolpath(const char *envvar, const char *name)
|
|
{
|
|
const char *p = getenv(envvar);
|
|
if (p && p[0]) return p;
|
|
static char buf[1024];
|
|
snprintf(buf, sizeof buf, "%s/%s", self_dir, name);
|
|
return strdup(buf);
|
|
}
|
|
|
|
static int
|
|
run(const char *cmd)
|
|
{
|
|
int rc = system(cmd);
|
|
if (rc == -1) return -1;
|
|
if (WIFEXITED(rc)) return WEXITSTATUS(rc);
|
|
return 1;
|
|
}
|
|
|
|
/* run_test_bin — exec the built test binary with an optional name-filter
|
|
* pattern as argv[1] (lib/test run() reads it via os.args). fork+execv
|
|
* (not system()) so glob metacharacters in the pattern reach the binary
|
|
* verbatim instead of being expanded by the shell. Mirrors the wwstage
|
|
* twin (selfhost/cmd/ww/main.ww runsingletest, which always builds an
|
|
* execargv for procrun). #17 fnmatch filter. */
|
|
static int
|
|
run_test_bin(const char *bin, const char *pattern)
|
|
{
|
|
pid_t pid = fork();
|
|
if (pid < 0) { perror("ww: fork"); return -1; }
|
|
if (pid == 0) {
|
|
char *xargv[3];
|
|
xargv[0] = (char *)bin;
|
|
if (pattern) { xargv[1] = (char *)pattern; xargv[2] = NULL; }
|
|
else { xargv[1] = NULL; }
|
|
execv(bin, xargv);
|
|
perror("ww: exec");
|
|
_exit(127);
|
|
}
|
|
int status = 0;
|
|
waitpid(pid, &status, 0);
|
|
if (WIFEXITED(status)) return WEXITSTATUS(status);
|
|
return 1;
|
|
}
|
|
|
|
/* Set of imported module paths, kept on the heap. Used to break
|
|
* cycles in `use` resolution. Linear because typical imports are
|
|
* a handful per build. */
|
|
struct ImportSet {
|
|
char **paths;
|
|
int n, cap;
|
|
};
|
|
|
|
static int
|
|
import_seen(struct ImportSet *s, const char *path)
|
|
{
|
|
for (int i = 0; i < s->n; i++)
|
|
if (strcmp(s->paths[i], path) == 0) return 1;
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
import_add(struct ImportSet *s, const char *path)
|
|
{
|
|
if (s->n + 1 > s->cap) {
|
|
s->cap = s->cap ? s->cap * 2 : 8;
|
|
s->paths = realloc(s->paths, s->cap * sizeof *s->paths);
|
|
}
|
|
s->paths[s->n++] = strdup(path);
|
|
}
|
|
|
|
/* Translate dots in an `import` name to slashes for path lookup.
|
|
* `encoding.utf8` → `encoding/utf8`. Mirrors Hare hare(1)'s
|
|
* use-path → fs-path mapping (ref/hare/hare/module/srcs.ha:78
|
|
* builds the same shape via path::push per ident part). */
|
|
static void
|
|
import_path_form(const char *name, char *out, size_t outsz)
|
|
{
|
|
size_t i;
|
|
for (i = 0; i + 1 < outsz && name[i] != '\0'; i++)
|
|
out[i] = (name[i] == '.') ? '/' : name[i];
|
|
out[i] = '\0';
|
|
}
|
|
|
|
/* try <dir>/<path>/ as a directory, then <dir>/<path>.ww as a file.
|
|
* Sets *is_dir on hit. Symmetric with wwstage locatein for byte-id
|
|
* driver output (rule 10). The legacy <dir>/<name>/<name>.ww form
|
|
* was dropped in task #22 — directory-as-module enumeration replaces
|
|
* it, mirroring ref/hare/hare/module/srcs.ha (Hare has no fallback
|
|
* matching `foo/foo.ha`; a module IS the directory). */
|
|
static int
|
|
locate_import_in(const char *dir, const char *path_form, char *out,
|
|
size_t outsz, int *is_dir)
|
|
{
|
|
struct stat st;
|
|
snprintf(out, outsz, "%s/%s", dir, path_form);
|
|
if (stat(out, &st) == 0 && S_ISDIR(st.st_mode)) {
|
|
*is_dir = 1;
|
|
return 1;
|
|
}
|
|
snprintf(out, outsz, "%s/%s.ww", dir, path_form);
|
|
if (access(out, 0) == 0) {
|
|
*is_dir = 0;
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Walk a colon-separated dirlist trying to resolve `path_form`. Returns
|
|
* 1 on the first hit and writes the concrete path + dir/file marker. */
|
|
static int
|
|
locate_import(const char *dirs, const char *path_form, char *out,
|
|
size_t outsz, int *is_dir)
|
|
{
|
|
const char *p = dirs;
|
|
while (*p) {
|
|
const char *e = strchr(p, ':');
|
|
size_t n = e ? (size_t)(e - p) : strlen(p);
|
|
if (n > 0 && n < outsz) {
|
|
char dir[1024];
|
|
if (n >= sizeof dir) n = sizeof dir - 1;
|
|
memcpy(dir, p, n);
|
|
dir[n] = '\0';
|
|
if (locate_import_in(dir, path_form, out, outsz,
|
|
is_dir)) return 1;
|
|
}
|
|
if (!e) break;
|
|
p = e + 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* memcmp-based string compare for qsort. Byte-wise total order is
|
|
* locale-independent; rule-10 byte-id requires the two stages sort
|
|
* the same way. (strcmp would work today but Hare-fidelity points
|
|
* at memcmp via ref/hare/sort/cmp/cmp.ha:9.) */
|
|
static int
|
|
strs_cmp(const void *a, const void *b)
|
|
{
|
|
const char *sa = *(const char *const *)a;
|
|
const char *sb = *(const char *const *)b;
|
|
return strcmp(sa, sb);
|
|
}
|
|
|
|
/* enumerate_dir_ww — collect *.ww names in `dirpath` excluding
|
|
* *test.ww, sort byte-wise. Returns count; caller frees entries. */
|
|
static int
|
|
enumerate_dir_ww(const char *dirpath, char ***out_files)
|
|
{
|
|
DIR *d = opendir(dirpath);
|
|
if (d == NULL) { *out_files = NULL; return 0; }
|
|
char **arr = NULL;
|
|
int n = 0, cap = 0;
|
|
struct dirent *ent;
|
|
while ((ent = readdir(d)) != NULL) {
|
|
const char *nm = ent->d_name;
|
|
size_t nl = strlen(nm);
|
|
if (nl <= 3) continue;
|
|
if (strcmp(nm + nl - 3, ".ww") != 0) continue;
|
|
/* skip "*test.ww" (no underscore — bytestest.ww
|
|
* ostest.ww utf8test.ww — Hare convention is _test.ha
|
|
* but ww corpus settled on the un-underscored shape). */
|
|
if (nl >= 7 && strcmp(nm + nl - 7, "test.ww") == 0)
|
|
continue;
|
|
/* skip "*.combined.ww" — driver-generated concat
|
|
* artifacts (the previous build leaves them next to
|
|
* the source). They look like .ww but parse-erroring
|
|
* when re-included. */
|
|
if (nl >= 12 && strcmp(nm + nl - 12, ".combined.ww") == 0)
|
|
continue;
|
|
if (n + 1 > cap) {
|
|
cap = cap ? cap * 2 : 8;
|
|
arr = realloc(arr, cap * sizeof *arr);
|
|
}
|
|
arr[n++] = strdup(nm);
|
|
}
|
|
closedir(d);
|
|
if (n > 1) qsort(arr, n, sizeof *arr, strs_cmp);
|
|
*out_files = arr;
|
|
return n;
|
|
}
|
|
|
|
static void expand(FILE *out, const char *path, struct ImportSet *visited,
|
|
const char *libdir, const char *modpath);
|
|
|
|
/* Scan `path` for its first non-comment-non-blank line; if it starts
|
|
* with `package <name>;` write the name into `out` (NUL-terminated)
|
|
* and return 1, else 0. Strict-same-package enforcement (task #23
|
|
* subset) is bundled here because the failure mode is dir-enum's
|
|
* own — a non-dir-enum compilation unit cannot trigger it. Hare's
|
|
* hare/module/srcs.ha:131 has the same constraint via the README
|
|
* gate; we encode it as same-package across all enumerated files. */
|
|
static int
|
|
peek_package(const char *path, char *out, size_t outsz)
|
|
{
|
|
FILE *in = fopen(path, "rb");
|
|
if (in == NULL) return 0;
|
|
char line[2048];
|
|
int found = 0;
|
|
while (fgets(line, sizeof line, in)) {
|
|
const char *p = line;
|
|
while (*p == ' ' || *p == '\t') p++;
|
|
if (*p == '\n' || *p == '\0') continue;
|
|
if (p[0] == '/' && p[1] == '/') continue;
|
|
if (strncmp(p, "package ", 8) != 0
|
|
&& strncmp(p, "package\t", 8) != 0) break;
|
|
p += 8;
|
|
while (*p == ' ' || *p == '\t') p++;
|
|
size_t i = 0;
|
|
while (i + 1 < outsz && ((p[i] >= 'a' && p[i] <= 'z')
|
|
|| (p[i] >= 'A' && p[i] <= 'Z')
|
|
|| p[i] == '_' || (p[i] >= '0' && p[i] <= '9')))
|
|
out[i] = p[i], i++;
|
|
out[i] = '\0';
|
|
found = (i > 0);
|
|
break;
|
|
}
|
|
fclose(in);
|
|
return found;
|
|
}
|
|
|
|
/* unit_has_package — does `path` declare `package <leaf>;` ANYWHERE?
|
|
* #16 ENFORCE-driver (rob A): distinguishes a genuinely-missing import
|
|
* from one satisfied by an INLINE package in the same unit. Unlike
|
|
* peek_package (stops at the FIRST package decl), this scans every line
|
|
* — single-file multi-package fixtures carry several `package` decls. The
|
|
* comment-skip line scan + name match mirror peek_package, uncapped. The
|
|
* wwstage twin unithaspackage must stay byte-identical (rule 10). */
|
|
static int
|
|
unit_has_package(const char *path, const char *leaf)
|
|
{
|
|
FILE *in = fopen(path, "rb");
|
|
if (in == NULL) return 0;
|
|
char line[2048];
|
|
int found = 0;
|
|
while (fgets(line, sizeof line, in)) {
|
|
const char *p = line;
|
|
while (*p == ' ' || *p == '\t') p++;
|
|
if (p[0] == '/' && p[1] == '/') continue;
|
|
if (strncmp(p, "package ", 8) != 0
|
|
&& strncmp(p, "package\t", 8) != 0) continue;
|
|
p += 8;
|
|
while (*p == ' ' || *p == '\t') p++;
|
|
size_t i = 0;
|
|
while (leaf[i] != '\0' && leaf[i] == p[i]) i++;
|
|
if (leaf[i] == '\0') {
|
|
char c = p[i];
|
|
if (c == ';' || c == ' ' || c == '\t'
|
|
|| c == '\n' || c == '\0') { found = 1; break; }
|
|
}
|
|
}
|
|
fclose(in);
|
|
return found;
|
|
}
|
|
|
|
/* expand_dir — enumerate <dirpath>/*.ww (skip *test.ww), byte-sort,
|
|
* recurse into each. Mirrors ref/hare/hare/module/srcs.ha:183
|
|
* `_findsrcs` minus tag handling. The visited set still keys on
|
|
* concrete file paths so multi-file modules are pulled once.
|
|
* Strict-same-package: all enumerated files must declare the same
|
|
* `package <name>;` (task #23 subset; failure mode native to
|
|
* dir-enum). */
|
|
static void
|
|
expand_dir(FILE *out, const char *dirpath, struct ImportSet *visited,
|
|
const char *libdir, const char *modpath)
|
|
{
|
|
char **files = NULL;
|
|
int n = enumerate_dir_ww(dirpath, &files);
|
|
char dirpkg[128] = {0};
|
|
for (int i = 0; i < n; i++) {
|
|
char fp[1024];
|
|
snprintf(fp, sizeof fp, "%s/%s", dirpath, files[i]);
|
|
char pkg[128];
|
|
if (peek_package(fp, pkg, sizeof pkg)) {
|
|
if (dirpkg[0] == '\0') {
|
|
snprintf(dirpkg, sizeof dirpkg, "%s", pkg);
|
|
} else if (strcmp(dirpkg, pkg) != 0) {
|
|
fprintf(stderr,
|
|
"ww: %s: package %s differs from %s in same module dir %s\n",
|
|
fp, pkg, dirpkg, dirpath);
|
|
exit(1);
|
|
}
|
|
}
|
|
expand(out, fp, visited, libdir, modpath);
|
|
free(files[i]);
|
|
}
|
|
free(files);
|
|
}
|
|
|
|
/* Recursively expand `path`: for each top-level `import IDENT;` we
|
|
* find, resolve the import and expand it first, then append our own
|
|
* bytes. Already-visited paths are skipped. Each source carries its
|
|
* own `package <name>;` declaration (the parser stamps decls from
|
|
* it). */
|
|
static void
|
|
expand(FILE *out, const char *path, struct ImportSet *visited,
|
|
const char *libdir, const char *modpath)
|
|
{
|
|
if (import_seen(visited, path)) return;
|
|
import_add(visited, path);
|
|
|
|
FILE *in = fopen(path, "rb");
|
|
if (in == NULL) {
|
|
fprintf(stderr, "ww: cannot read %s\n", path);
|
|
return;
|
|
}
|
|
char line[2048];
|
|
while (fgets(line, sizeof line, in)) {
|
|
const char *p = line;
|
|
while (*p == ' ' || *p == '\t') p++;
|
|
if (strncmp(p, "import ", 7) != 0 && strncmp(p, "import\t", 7) != 0)
|
|
continue;
|
|
p += 7;
|
|
while (*p == ' ' || *p == '\t') p++;
|
|
char name[256] = {0};
|
|
int j = 0;
|
|
while ((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z')
|
|
|| *p == '_' || *p == '.' || (*p >= '0' && *p <= '9'))
|
|
if (j + 1 < (int)sizeof name) name[j++] = *p++;
|
|
if (j == 0) continue;
|
|
char path_form[256];
|
|
import_path_form(name, path_form, sizeof path_form);
|
|
char ipath[1024];
|
|
int is_dir = 0;
|
|
/* #16 ENFORCE-driver (rob A): an unresolvable import is a hard
|
|
* error, not a silent skip — the old `continue` let a typo'd/
|
|
* missing package drop its symbols and surface later as a
|
|
* confusing downstream failure. BUT a locate-miss is legal when
|
|
* the package is defined INLINE in the same unit (single-file
|
|
* multi-package: `package aa; ... package main; import aa;`) —
|
|
* the bundler can't pull it as a file but the checker binds it.
|
|
* So: miss + inline `package <leaf>` present -> silent skip;
|
|
* miss + not inline -> fatal. */
|
|
if (!locate_import(libdir, path_form, ipath, sizeof ipath,
|
|
&is_dir)) {
|
|
const char *dot = strrchr(name, '.');
|
|
const char *leaf = dot ? dot + 1 : name;
|
|
if (unit_has_package(path, leaf))
|
|
continue; /* inline-satisfied */
|
|
fprintf(stderr, "ww: cannot find package %s\n", name);
|
|
exit(1);
|
|
}
|
|
/* M1 #22 (isdir-gated, rob-ratified): a package IS a directory, so
|
|
* only DIRECTORY imports are package boundaries that path-mangle.
|
|
* A single-file import (`import opcodes;` → opcodes.ww declaring
|
|
* `package w6a`) is an intra-package file-split — it keeps its
|
|
* in-file `package` clause as its module (no directive). */
|
|
if (is_dir) expand_dir(out, ipath, visited, libdir, name);
|
|
else expand(out, ipath, visited, libdir, NULL);
|
|
}
|
|
|
|
/* #16 option-B: a package-less file's decls would otherwise inherit
|
|
* the preceding bundled module's sticky curmod (parser parse.c). Emit
|
|
* a curmod-reset boundary directive so the lexer/parser attribute the
|
|
* file to the primary module ("") — fixes the self-import false-fire
|
|
* and the leaked-prefix bug, codegen-neutral (bare symbols kept; not
|
|
* `package main`, which would main-prefix them). A packaged file's own
|
|
* `package` decl already sets curmod, so it needs nothing — keeping
|
|
* the directive out of every tracked combined.ww. (Task #11.) */
|
|
if (modpath != NULL && modpath[0] != '\0') {
|
|
/* M1 (#22): an import-reached file carries its full dotted
|
|
* import path so codegen mangles symbols on the path, not the
|
|
* leaf `package` clause. The directive's absence is the root
|
|
* marker (#32): root/primary files take the branch below. */
|
|
fprintf(out, "//ww:module %s\n", modpath);
|
|
} else {
|
|
/* Root/primary file: reset the bundle boundary so a preceding
|
|
* imported section's sticky pathmod (M1 #22) is cleared. A
|
|
* package-less file then stays primary ("") as before; a
|
|
* packaged primary's own `package` clause sets curmod fresh
|
|
* (pathmod now NULL → real clause, not an assertion). */
|
|
fputs("//ww:module-reset\n", out);
|
|
}
|
|
rewind(in);
|
|
int ch;
|
|
while ((ch = fgetc(in)) != EOF) fputc(ch, out);
|
|
fputc('\n', out);
|
|
fclose(in);
|
|
}
|
|
|
|
/* objstem (when non-NULL/non-empty) redirects the .s/.o/.combined.ww
|
|
* side files to live beside the build's OUTPUT instead of next to the
|
|
* source (task #15/T3). `ww run` and `ww build -o` pass it so concurrent
|
|
* builds never share the next-to-source fixed paths; the default
|
|
* (objstem == NULL) keeps the old next-to-source layout, load-bearing
|
|
* for make's tracked-combined.ww regen + the #110 freshness gate. */
|
|
static int
|
|
build_one(const char *src, int entry_is_dir, const char *out,
|
|
const char *objstem, const char *extra_includes, const char *extra_libs,
|
|
const char *extra_libdirs, int is_test)
|
|
{
|
|
const char *c6 = toolpath("WW_W6C", "w6c");
|
|
const char *a6 = toolpath("WW_W6A", "w6a");
|
|
const char *l6 = toolpath("WW_W6L", "w6l");
|
|
const char *libdir = getenv("WW_LIB");
|
|
if (libdir == NULL || libdir[0] == 0) {
|
|
static char libbuf[1024];
|
|
snprintf(libbuf, sizeof libbuf, "%s/../lib", self_dir);
|
|
libdir = libbuf;
|
|
}
|
|
const char *srcdir = getenv("WW_SRCLIB");
|
|
static char srcbuf[1024];
|
|
if (srcdir == NULL || srcdir[0] == 0) {
|
|
/* in-tree default: ../../lib relative to bin/ */
|
|
snprintf(srcbuf, sizeof srcbuf, "%s/../../lib", self_dir);
|
|
if (access(srcbuf, 0) == 0) srcdir = srcbuf;
|
|
else if (access("lib", 0) == 0) srcdir = "lib";
|
|
else srcdir = libdir;
|
|
}
|
|
|
|
/* Compose the search path: source-file's directory first, then any
|
|
* -I dirs, then srcdir. The source-dir lead matches Hare's CWD-first
|
|
* convention (its `hare test` is run from the module dir, making CWD
|
|
* == module-dir); our wrappers don't cd, so dirname(src) is the
|
|
* closest analog. Also matches cc -I. — source-dir wins ties over
|
|
* the system path. locate_import walks left-to-right.
|
|
*
|
|
* For a dir entry the source-dir IS src; for a file entry it's
|
|
* the dirname. */
|
|
char srcd[1024];
|
|
if (entry_is_dir) {
|
|
snprintf(srcd, sizeof srcd, "%s", src);
|
|
size_t n = strlen(srcd);
|
|
while (n > 1 && srcd[n-1] == '/') srcd[--n] = '\0';
|
|
} else {
|
|
const char *slash = strrchr(src, '/');
|
|
if (slash) {
|
|
size_t n = (size_t)(slash - src);
|
|
if (n >= sizeof srcd) n = sizeof srcd - 1;
|
|
memcpy(srcd, src, n);
|
|
srcd[n] = '\0';
|
|
} else {
|
|
srcd[0] = '.';
|
|
srcd[1] = '\0';
|
|
}
|
|
}
|
|
static char searchpath[4096];
|
|
if (extra_includes && extra_includes[0])
|
|
snprintf(searchpath, sizeof searchpath, "%s:%s:%s",
|
|
srcd, extra_includes, srcdir);
|
|
else
|
|
snprintf(searchpath, sizeof searchpath, "%s:%s", srcd, srcdir);
|
|
srcdir = searchpath;
|
|
|
|
/* Derive a stem for .s/.o/.combined.ww side files. For a file
|
|
* entry strip the .ww. For a dir entry use <dir>/<basename(dir)>
|
|
* so artifacts land inside the module directory. */
|
|
char stem[1024];
|
|
if (entry_is_dir) {
|
|
const char *b = strrchr(srcd, '/');
|
|
const char *base = b ? b + 1 : srcd;
|
|
snprintf(stem, sizeof stem, "%s/%s", srcd, base);
|
|
} else {
|
|
snprintf(stem, sizeof stem, "%s", src);
|
|
char *dot = strrchr(stem, '.');
|
|
if (dot && strcmp(dot, ".ww") == 0) *dot = '\0';
|
|
}
|
|
|
|
const char *ostem = (objstem && objstem[0]) ? objstem : stem;
|
|
char asmf[1024], obj[1024], combined[1024];
|
|
snprintf(asmf, sizeof asmf, "%s.s", ostem);
|
|
snprintf(obj, sizeof obj, "%s.o", ostem);
|
|
snprintf(combined, sizeof combined, "%s.combined.ww", ostem);
|
|
|
|
/* Resolve imports by concatenating sources into a temp file. The
|
|
* compiler then sees one flat source. Dir entry → enumerate the
|
|
* module dir's *.ww (less *test.ww); file entry → start at the
|
|
* file. */
|
|
{
|
|
FILE *cf = fopen(combined, "wb");
|
|
if (cf == NULL) {
|
|
fprintf(stderr, "ww: cannot open %s\n", combined);
|
|
return 1;
|
|
}
|
|
struct ImportSet visited = {0};
|
|
/* #17 auto-bundle lib/test: the -T synth's main calls lib/test's
|
|
* run(), but @test files don't `import test;`. Pull it like an
|
|
* implicit import through the same filename-keyed expand path
|
|
* (the visited set dedupes if a fixture imports it explicitly).
|
|
* The wwstage twin (selfhost/cmd/ww/main.ww) mirrors this. */
|
|
if (is_test) {
|
|
char tpath[1024];
|
|
int tdir = 0;
|
|
if (locate_import(srcdir, "test", tpath, sizeof tpath, &tdir)) {
|
|
if (tdir) expand_dir(cf, tpath, &visited, srcdir, "test");
|
|
else expand(cf, tpath, &visited, srcdir, NULL);
|
|
}
|
|
}
|
|
if (entry_is_dir) expand_dir(cf, srcd, &visited, srcdir, NULL);
|
|
else expand(cf, src, &visited, srcdir, NULL);
|
|
fclose(cf);
|
|
for (int i = 0; i < visited.n; i++) free(visited.paths[i]);
|
|
free(visited.paths);
|
|
}
|
|
|
|
char cmd[4096];
|
|
snprintf(cmd, sizeof cmd, "%s %s-o %s %s", c6, is_test ? "-T " : "",
|
|
asmf, combined);
|
|
if (run(cmd) != 0) {
|
|
fprintf(stderr, "ww: w6c failed\n");
|
|
return 1;
|
|
}
|
|
snprintf(cmd, sizeof cmd, "%s -o %s %s", a6, obj, asmf);
|
|
if (run(cmd) != 0) {
|
|
fprintf(stderr, "ww: w6a failed\n");
|
|
return 1;
|
|
}
|
|
/* Link runtime: prefer libwwrt.a (selective archive pull) but
|
|
* fall back to start.o + syscall.o in the in-tree obj/ dir if
|
|
* we're running uninstalled. */
|
|
char rtargs[2048] = {0};
|
|
char path[1024];
|
|
snprintf(path, sizeof path, "%s/libwwrt.a", libdir);
|
|
if (access(path, 0) == 0) {
|
|
snprintf(rtargs, sizeof rtargs, "%s", path);
|
|
} else {
|
|
char a1[1024], a2[1024];
|
|
snprintf(a1, sizeof a1, "%s/../obj/rt/start.o", self_dir);
|
|
snprintf(a2, sizeof a2, "%s/../obj/rt/syscall.o", self_dir);
|
|
snprintf(rtargs, sizeof rtargs, "%s %s", a1, a2);
|
|
}
|
|
/* -L<dir> goes before -l<name> so w6l can resolve the latter. */
|
|
const char *libargs = (extra_libs && extra_libs[0]) ? extra_libs : "";
|
|
const char *libdirset = (extra_libdirs && extra_libdirs[0]) ? extra_libdirs : "";
|
|
snprintf(cmd, sizeof cmd, "%s -o %s %s %s%s%s%s%s",
|
|
l6, out, obj, rtargs,
|
|
libdirset[0] ? " " : "", libdirset,
|
|
libargs[0] ? " " : "", libargs);
|
|
if (run(cmd) != 0) {
|
|
fprintf(stderr, "ww: w6l failed\n");
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* ====================================================================
|
|
* ww build --sep — M3-tail separate-compilation driver (task #46/c3).
|
|
* ====================================================================
|
|
* The `--sep` path materializes each imported package's `.wwi`
|
|
* interface and compiles every package on its own (`w6c -c`), then
|
|
* flat-links the `.o` set. combined.ww stays the DEFAULT live path;
|
|
* --sep is purely additive (no existing invocation reaches it).
|
|
*
|
|
* Each w6c pass is BOTH consumer (reads dep `.wwi` as import scope) AND
|
|
* producer (writes this package's `.wwi` for its importers via -I), so
|
|
* a package's interface is materialized as a side effect of compiling
|
|
* it. Reverse-topo order guarantees a package's deps' `.wwi` exist
|
|
* before it compiles.
|
|
*
|
|
* The load-bearing rule (ken #56, rob-resolved): every dep is tagged by
|
|
* its FULL DOTTED import path on prepend (`//ww:module <path>`), so the
|
|
* definer's qualified symbol (#53) equals the consumer's qualified
|
|
* reference (#40) and the sep `.o`s link. A dep is NEVER bare-embedded.
|
|
*
|
|
* The prepend is the TRANSITIVE closure of a package's deps (lead-
|
|
* ratified, superseding rob-c3-spec §1.3 "direct deps"): a dep's public
|
|
* interface can name a transitive dep's type (os exposes time.instant),
|
|
* so the consuming unit needs the whole closure for name RESOLUTION —
|
|
* direct-deps-only does not type-check. This mirrors harec reading the
|
|
* transitive `.td` closure and is consistent with the current flat-unit
|
|
* transitive-namespace model (the visibility tighten is task #45,
|
|
* deferred post-M4).
|
|
*/
|
|
#define SEP_MAXPKG 256
|
|
|
|
struct seppkg {
|
|
char path[256]; /* dotted import path; "" == root/primary */
|
|
char entry[1024]; /* resolved package dir (or file, for a file root) */
|
|
int is_dir;
|
|
int deps[SEP_MAXPKG]; /* direct-dep indices into sepgraph.pkg */
|
|
int ndeps;
|
|
int color; /* tri-color DFS: 0 white, 1 gray, 2 black */
|
|
};
|
|
|
|
struct sepgraph {
|
|
struct seppkg pkg[SEP_MAXPKG];
|
|
int n;
|
|
};
|
|
|
|
/* Find a package by dotted path, or add it. Returns its index, -1 full. */
|
|
static int
|
|
sep_find_or_add(struct sepgraph *g, const char *path, const char *entry,
|
|
int is_dir)
|
|
{
|
|
for (int i = 0; i < g->n; i++)
|
|
if (strcmp(g->pkg[i].path, path) == 0) return i;
|
|
if (g->n >= SEP_MAXPKG) {
|
|
fprintf(stderr, "ww --sep: too many packages (limit %d)\n",
|
|
SEP_MAXPKG);
|
|
return -1;
|
|
}
|
|
struct seppkg *p = &g->pkg[g->n];
|
|
snprintf(p->path, sizeof p->path, "%s", path);
|
|
snprintf(p->entry, sizeof p->entry, "%s", entry);
|
|
p->is_dir = is_dir;
|
|
p->ndeps = 0;
|
|
p->color = 0;
|
|
return g->n++;
|
|
}
|
|
|
|
/* Sanitize a package's dotted path into a scratch-file basename. Dots
|
|
* stay (legal in filenames); the root's empty path becomes "__root". */
|
|
static void
|
|
sep_fname(const struct sepgraph *g, int pi, const char *scratch,
|
|
const char *suffix, char *out, size_t outsz)
|
|
{
|
|
const char *base = g->pkg[pi].path[0] ? g->pkg[pi].path : "__root";
|
|
snprintf(out, outsz, "%s/%s%s", scratch, base, suffix);
|
|
}
|
|
|
|
/* Scan one source file for top-level `import IDENT;`, resolving each. A
|
|
* DIRECTORY import is a package boundary: add it as a direct dep of pkg
|
|
* `pi`. A FILE import is an intra-package split — fold its imports into
|
|
* `pi` (its bytes join pi's body at emit time). Mirrors expand's scan
|
|
* but collects package PATHS instead of concatenating bytes (§1.1). */
|
|
static int
|
|
sep_scan_file(struct sepgraph *g, int pi, const char *file,
|
|
const char *searchpath, struct ImportSet *filevisit)
|
|
{
|
|
if (import_seen(filevisit, file)) return 0;
|
|
import_add(filevisit, file);
|
|
FILE *in = fopen(file, "rb");
|
|
if (in == NULL) {
|
|
fprintf(stderr, "ww --sep: cannot read %s\n", file);
|
|
return -1;
|
|
}
|
|
char line[2048];
|
|
int rc = 0;
|
|
while (fgets(line, sizeof line, in)) {
|
|
const char *p = line;
|
|
while (*p == ' ' || *p == '\t') p++;
|
|
if (strncmp(p, "import ", 7) != 0 && strncmp(p, "import\t", 7) != 0)
|
|
continue;
|
|
p += 7;
|
|
while (*p == ' ' || *p == '\t') p++;
|
|
char name[256] = {0};
|
|
int j = 0;
|
|
while ((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z')
|
|
|| *p == '_' || *p == '.' || (*p >= '0' && *p <= '9'))
|
|
if (j + 1 < (int)sizeof name) name[j++] = *p++;
|
|
if (j == 0) continue;
|
|
char path_form[256];
|
|
import_path_form(name, path_form, sizeof path_form);
|
|
char ipath[1024];
|
|
int is_dir = 0;
|
|
/* a locate-miss is an inline-satisfied (single-file multi-
|
|
* package) import; --sep targets directory packages, so the
|
|
* combined path owns that case. Skip, mirroring expand. */
|
|
if (!locate_import(searchpath, path_form, ipath, sizeof ipath,
|
|
&is_dir))
|
|
continue;
|
|
if (is_dir) {
|
|
int di = sep_find_or_add(g, name, ipath, 1);
|
|
if (di < 0) { rc = -1; break; }
|
|
int seen = 0;
|
|
for (int k = 0; k < g->pkg[pi].ndeps; k++)
|
|
if (g->pkg[pi].deps[k] == di) { seen = 1; break; }
|
|
if (!seen) {
|
|
if (g->pkg[pi].ndeps >= SEP_MAXPKG) { rc = -1; break; }
|
|
g->pkg[pi].deps[g->pkg[pi].ndeps++] = di;
|
|
}
|
|
} else if (sep_scan_file(g, pi, ipath, searchpath, filevisit) < 0) {
|
|
rc = -1; break;
|
|
}
|
|
}
|
|
fclose(in);
|
|
return rc;
|
|
}
|
|
|
|
/* Discover pkg pi's direct deps + recurse. Enumerate the package's own
|
|
* source files (dir → *.ww less *test.ww; file → the file) and scan
|
|
* each. `color` doubles as a scanned-marker here (2 == scanned); it is
|
|
* reset to white before the topo pass. */
|
|
static int
|
|
sep_scan_pkg(struct sepgraph *g, int pi, const char *searchpath)
|
|
{
|
|
if (g->pkg[pi].color == 2) return 0;
|
|
g->pkg[pi].color = 2;
|
|
struct ImportSet fv = {0};
|
|
int rc = 0;
|
|
if (g->pkg[pi].is_dir) {
|
|
char **files = NULL;
|
|
int n = enumerate_dir_ww(g->pkg[pi].entry, &files);
|
|
for (int i = 0; i < n && rc == 0; i++) {
|
|
char fp[1024];
|
|
snprintf(fp, sizeof fp, "%s/%s", g->pkg[pi].entry, files[i]);
|
|
rc = sep_scan_file(g, pi, fp, searchpath, &fv);
|
|
}
|
|
for (int i = 0; i < n; i++) free(files[i]);
|
|
free(files);
|
|
} else {
|
|
rc = sep_scan_file(g, pi, g->pkg[pi].entry, searchpath, &fv);
|
|
}
|
|
for (int i = 0; i < fv.n; i++) free(fv.paths[i]);
|
|
free(fv.paths);
|
|
if (rc < 0) return rc;
|
|
/* recurse into freshly-added deps (sep_find_or_add may have grown
|
|
* g->n during the scan; iterate by index). */
|
|
for (int k = 0; k < g->pkg[pi].ndeps; k++)
|
|
if (sep_scan_pkg(g, g->pkg[pi].deps[k], searchpath) < 0)
|
|
return -1;
|
|
return 0;
|
|
}
|
|
|
|
/* DFS post-order over the dep DAG → reverse-topo (deps before importer),
|
|
* cite Hare gather (deps.ha:123). Tri-color: a gray back-edge is a loud
|
|
* dep-cycle reject naming the chain (Hare deps.ha:243); `stack[0..depth)`
|
|
* is the live DFS path, so the cycle runs from pi's first occurrence on
|
|
* it to the top, closing back on pi. */
|
|
static int
|
|
sep_topo_visit(struct sepgraph *g, int pi, int *order, int *no,
|
|
int *stack, int depth)
|
|
{
|
|
if (g->pkg[pi].color == 2) return 0;
|
|
if (g->pkg[pi].color == 1) {
|
|
int j = 0;
|
|
while (j < depth && stack[j] != pi) j++;
|
|
fprintf(stderr, "ww --sep: dependency cycle: ");
|
|
for (int s = j; s < depth; s++)
|
|
fprintf(stderr, "%s -> ", g->pkg[stack[s]].path[0]
|
|
? g->pkg[stack[s]].path : "(root)");
|
|
fprintf(stderr, "%s\n",
|
|
g->pkg[pi].path[0] ? g->pkg[pi].path : "(root)");
|
|
return -1;
|
|
}
|
|
g->pkg[pi].color = 1;
|
|
stack[depth] = pi;
|
|
for (int k = 0; k < g->pkg[pi].ndeps; k++)
|
|
if (sep_topo_visit(g, g->pkg[pi].deps[k], order, no,
|
|
stack, depth + 1) < 0)
|
|
return -1;
|
|
g->pkg[pi].color = 2;
|
|
order[(*no)++] = pi;
|
|
return 0;
|
|
}
|
|
|
|
/* Mark pi's transitive deps (excluding pi) in inset[]. */
|
|
static void
|
|
sep_mark_deps(struct sepgraph *g, int pi, char *inset)
|
|
{
|
|
for (int k = 0; k < g->pkg[pi].ndeps; k++) {
|
|
int di = g->pkg[pi].deps[k];
|
|
if (!inset[di]) { inset[di] = 1; sep_mark_deps(g, di, inset); }
|
|
}
|
|
}
|
|
|
|
/* Emit one of pi's own source files into the sep-unit under the
|
|
* //ww:module-reset primary boundary (so -c emits its decls, imported
|
|
* ==0). DIRECTORY imports are skipped (provided as `.wwi` ahead of the
|
|
* body); FILE imports fold in (intra-package split). */
|
|
static void
|
|
sep_emit_body(FILE *out, const char *path, struct ImportSet *visited,
|
|
const char *searchpath)
|
|
{
|
|
if (import_seen(visited, path)) return;
|
|
import_add(visited, path);
|
|
FILE *in = fopen(path, "rb");
|
|
if (in == NULL) {
|
|
fprintf(stderr, "ww --sep: cannot read %s\n", path);
|
|
return;
|
|
}
|
|
char line[2048];
|
|
while (fgets(line, sizeof line, in)) {
|
|
const char *p = line;
|
|
while (*p == ' ' || *p == '\t') p++;
|
|
if (strncmp(p, "import ", 7) != 0 && strncmp(p, "import\t", 7) != 0)
|
|
continue;
|
|
p += 7;
|
|
while (*p == ' ' || *p == '\t') p++;
|
|
char name[256] = {0};
|
|
int j = 0;
|
|
while ((*p >= 'a' && *p <= 'z') || (*p >= 'A' && *p <= 'Z')
|
|
|| *p == '_' || *p == '.' || (*p >= '0' && *p <= '9'))
|
|
if (j + 1 < (int)sizeof name) name[j++] = *p++;
|
|
if (j == 0) continue;
|
|
char path_form[256];
|
|
import_path_form(name, path_form, sizeof path_form);
|
|
char ipath[1024];
|
|
int is_dir = 0;
|
|
if (!locate_import(searchpath, path_form, ipath, sizeof ipath,
|
|
&is_dir))
|
|
continue;
|
|
if (!is_dir)
|
|
sep_emit_body(out, ipath, visited, searchpath);
|
|
}
|
|
fputs("//ww:module-reset\n", out);
|
|
rewind(in);
|
|
int ch;
|
|
while ((ch = fgetc(in)) != EOF) fputc(ch, out);
|
|
fputc('\n', out);
|
|
fclose(in);
|
|
}
|
|
|
|
static void
|
|
sep_emit_dir_body(FILE *out, const char *dir, struct ImportSet *visited,
|
|
const char *searchpath)
|
|
{
|
|
char **files = NULL;
|
|
int n = enumerate_dir_ww(dir, &files);
|
|
for (int i = 0; i < n; i++) {
|
|
char fp[1024];
|
|
snprintf(fp, sizeof fp, "%s/%s", dir, files[i]);
|
|
sep_emit_body(out, fp, visited, searchpath);
|
|
free(files[i]);
|
|
}
|
|
free(files);
|
|
}
|
|
|
|
/* Compose pi's sep-unit at `unitf`: the transitive-closure `.wwi`s
|
|
* (reverse-topo order, each tagged by its dotted path), then pi's own
|
|
* body under //ww:module-reset. */
|
|
static int
|
|
sep_compose_unit(struct sepgraph *g, int pi, const char *scratch,
|
|
const int *order, int norder, const char *searchpath, const char *unitf)
|
|
{
|
|
FILE *u = fopen(unitf, "wb");
|
|
if (u == NULL) {
|
|
fprintf(stderr, "ww --sep: cannot open %s\n", unitf);
|
|
return -1;
|
|
}
|
|
char inset[SEP_MAXPKG] = {0};
|
|
sep_mark_deps(g, pi, inset);
|
|
for (int oi = 0; oi < norder; oi++) {
|
|
int dj = order[oi];
|
|
if (dj == pi || !inset[dj]) continue;
|
|
char wwi[1024];
|
|
sep_fname(g, dj, scratch, ".wwi", wwi, sizeof wwi);
|
|
FILE *wf = fopen(wwi, "rb");
|
|
if (wf == NULL) {
|
|
fprintf(stderr, "ww --sep: missing %s\n", wwi);
|
|
fclose(u);
|
|
return -1;
|
|
}
|
|
fprintf(u, "//ww:module %s\n", g->pkg[dj].path);
|
|
int ch;
|
|
while ((ch = fgetc(wf)) != EOF) fputc(ch, u);
|
|
fputc('\n', u);
|
|
fclose(wf);
|
|
}
|
|
struct ImportSet bodyvisit = {0};
|
|
if (g->pkg[pi].is_dir)
|
|
sep_emit_dir_body(u, g->pkg[pi].entry, &bodyvisit, searchpath);
|
|
else
|
|
sep_emit_body(u, g->pkg[pi].entry, &bodyvisit, searchpath);
|
|
for (int i = 0; i < bodyvisit.n; i++) free(bodyvisit.paths[i]);
|
|
free(bodyvisit.paths);
|
|
fclose(u);
|
|
return 0;
|
|
}
|
|
|
|
/* build_one_sep — the --sep orchestration: discover_deps, reverse_topo,
|
|
* the transitive producer loop (one `w6c -c -I` per package, dep-first),
|
|
* then a flat `w6l` of the `.o` set (per-pkg `.a` + multi-archive link
|
|
* is commit 4). Side files land in a cold `<stem>.sepwork` scratch dir
|
|
* (the structured cache is commit 5). */
|
|
static int
|
|
build_one_sep(const char *src, int entry_is_dir, const char *out,
|
|
const char *objstem, const char *extra_includes, const char *extra_libs,
|
|
const char *extra_libdirs)
|
|
{
|
|
const char *c6 = toolpath("WW_W6C", "w6c");
|
|
const char *a6 = toolpath("WW_W6A", "w6a");
|
|
const char *l6 = toolpath("WW_W6L", "w6l");
|
|
const char *libdir = getenv("WW_LIB");
|
|
if (libdir == NULL || libdir[0] == 0) {
|
|
static char libbuf[1024];
|
|
snprintf(libbuf, sizeof libbuf, "%s/../lib", self_dir);
|
|
libdir = libbuf;
|
|
}
|
|
const char *srcdir = getenv("WW_SRCLIB");
|
|
static char srcbuf[1024];
|
|
if (srcdir == NULL || srcdir[0] == 0) {
|
|
snprintf(srcbuf, sizeof srcbuf, "%s/../../lib", self_dir);
|
|
if (access(srcbuf, 0) == 0) srcdir = srcbuf;
|
|
else if (access("lib", 0) == 0) srcdir = "lib";
|
|
else srcdir = libdir;
|
|
}
|
|
/* search path: source-dir, then -I dirs, then srcdir (mirrors
|
|
* build_one). */
|
|
char srcd[1024];
|
|
if (entry_is_dir) {
|
|
snprintf(srcd, sizeof srcd, "%s", src);
|
|
size_t n = strlen(srcd);
|
|
while (n > 1 && srcd[n-1] == '/') srcd[--n] = '\0';
|
|
} else {
|
|
const char *slash = strrchr(src, '/');
|
|
if (slash) {
|
|
size_t n = (size_t)(slash - src);
|
|
if (n >= sizeof srcd) n = sizeof srcd - 1;
|
|
memcpy(srcd, src, n);
|
|
srcd[n] = '\0';
|
|
} else { srcd[0] = '.'; srcd[1] = '\0'; }
|
|
}
|
|
static char searchpath[4096];
|
|
if (extra_includes && extra_includes[0])
|
|
snprintf(searchpath, sizeof searchpath, "%s:%s:%s",
|
|
srcd, extra_includes, srcdir);
|
|
else
|
|
snprintf(searchpath, sizeof searchpath, "%s:%s", srcd, srcdir);
|
|
srcdir = searchpath;
|
|
|
|
char stem[1024];
|
|
if (entry_is_dir) {
|
|
const char *b = strrchr(srcd, '/');
|
|
const char *base = b ? b + 1 : srcd;
|
|
snprintf(stem, sizeof stem, "%s/%s", srcd, base);
|
|
} else {
|
|
snprintf(stem, sizeof stem, "%s", src);
|
|
char *dot = strrchr(stem, '.');
|
|
if (dot && strcmp(dot, ".ww") == 0) *dot = '\0';
|
|
}
|
|
const char *ostem = (objstem && objstem[0]) ? objstem : stem;
|
|
char scratch[1100];
|
|
snprintf(scratch, sizeof scratch, "%s.sepwork", ostem);
|
|
{ char m[1200]; snprintf(m, sizeof m, "rm -rf %s", scratch); run(m); }
|
|
if (mkdir(scratch, 0755) != 0) {
|
|
fprintf(stderr, "ww --sep: cannot create scratch %s\n", scratch);
|
|
return 1;
|
|
}
|
|
|
|
struct sepgraph *g = calloc(1, sizeof *g);
|
|
if (g == NULL) return 1;
|
|
int root = sep_find_or_add(g, "", src, entry_is_dir);
|
|
if (root < 0 || sep_scan_pkg(g, root, srcdir) < 0) { free(g); return 1; }
|
|
for (int i = 0; i < g->n; i++) g->pkg[i].color = 0;
|
|
int *order = calloc((size_t)g->n, sizeof *order);
|
|
int *stack = calloc((size_t)g->n, sizeof *stack);
|
|
int norder = 0;
|
|
if (order == NULL || stack == NULL ||
|
|
sep_topo_visit(g, root, order, &norder, stack, 0) < 0) {
|
|
free(stack); free(order); free(g); return 1;
|
|
}
|
|
free(stack);
|
|
|
|
/* producer loop — dep-first, one `w6c -c -I` pass per package. */
|
|
for (int oi = 0; oi < norder; oi++) {
|
|
int pi = order[oi];
|
|
char unitf[1024], wwi[1024], asmf[1024], obj[1024], cmd[8192];
|
|
sep_fname(g, pi, scratch, ".unit.ww", unitf, sizeof unitf);
|
|
sep_fname(g, pi, scratch, ".wwi", wwi, sizeof wwi);
|
|
sep_fname(g, pi, scratch, ".s", asmf, sizeof asmf);
|
|
sep_fname(g, pi, scratch, ".o", obj, sizeof obj);
|
|
if (sep_compose_unit(g, pi, scratch, order, norder, srcdir,
|
|
unitf) < 0) { free(order); free(g); return 1; }
|
|
snprintf(cmd, sizeof cmd, "%s -c -I %s -o %s %s",
|
|
c6, wwi, asmf, unitf);
|
|
if (run(cmd) != 0) {
|
|
fprintf(stderr, "ww --sep: w6c failed for %s\n",
|
|
g->pkg[pi].path[0] ? g->pkg[pi].path : "(root)");
|
|
free(order); free(g); return 1;
|
|
}
|
|
snprintf(cmd, sizeof cmd, "%s -o %s %s", a6, obj, asmf);
|
|
if (run(cmd) != 0) {
|
|
fprintf(stderr, "ww --sep: w6a failed for %s\n",
|
|
g->pkg[pi].path[0] ? g->pkg[pi].path : "(root)");
|
|
free(order); free(g); return 1;
|
|
}
|
|
}
|
|
|
|
/* flat link: root.o first (order[norder-1]), deps after; runtime
|
|
* archive selectively pulls only undefined runtime symbols (commit 4
|
|
* adds per-pkg `.a` + multi-archive reverse-topo link). */
|
|
char rtargs[2048] = {0};
|
|
char rtpath[1024];
|
|
snprintf(rtpath, sizeof rtpath, "%s/libwwrt.a", libdir);
|
|
if (access(rtpath, 0) == 0) {
|
|
snprintf(rtargs, sizeof rtargs, "%s", rtpath);
|
|
} else {
|
|
char a1[1024], a2[1024];
|
|
snprintf(a1, sizeof a1, "%s/../obj/rt/start.o", self_dir);
|
|
snprintf(a2, sizeof a2, "%s/../obj/rt/syscall.o", self_dir);
|
|
snprintf(rtargs, sizeof rtargs, "%s %s", a1, a2);
|
|
}
|
|
char objs[8192] = {0};
|
|
for (int oi = norder - 1; oi >= 0; oi--) {
|
|
char obj[1024];
|
|
sep_fname(g, order[oi], scratch, ".o", obj, sizeof obj);
|
|
size_t n = strlen(objs);
|
|
snprintf(objs + n, sizeof objs - n, "%s%s", n ? " " : "", obj);
|
|
}
|
|
const char *libargs = (extra_libs && extra_libs[0]) ? extra_libs : "";
|
|
const char *libdirset = (extra_libdirs && extra_libdirs[0]) ? extra_libdirs : "";
|
|
char cmd[16384];
|
|
snprintf(cmd, sizeof cmd, "%s -o %s %s %s%s%s%s%s",
|
|
l6, out, objs, rtargs,
|
|
libdirset[0] ? " " : "", libdirset,
|
|
libargs[0] ? " " : "", libargs);
|
|
int rc = run(cmd);
|
|
free(order); free(g);
|
|
if (rc != 0) { fprintf(stderr, "ww --sep: w6l failed\n"); return 1; }
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
do_version(void)
|
|
{
|
|
printf("ww %s\n", WW_VERSION);
|
|
return 0;
|
|
}
|
|
|
|
/* Compose the standard module search path: cwd : <extra-includes> : $WW_LIB
|
|
* source dir. The `extra` string is colon-separated -I dirs from argv. */
|
|
static const char *
|
|
search_path(const char *extra, char *buf, size_t bufsz)
|
|
{
|
|
const char *libdir = getenv("WW_SRCLIB");
|
|
static char libbuf[1024];
|
|
if (libdir == NULL || libdir[0] == 0) {
|
|
libdir = getenv("WW_LIB");
|
|
}
|
|
if (libdir == NULL || libdir[0] == 0) {
|
|
snprintf(libbuf, sizeof libbuf, "%s/../../lib", self_dir);
|
|
if (access(libbuf, 0) == 0) libdir = libbuf;
|
|
else if (access("lib", 0) == 0) libdir = "lib";
|
|
else {
|
|
snprintf(libbuf, sizeof libbuf, "%s/../lib", self_dir);
|
|
libdir = libbuf;
|
|
}
|
|
}
|
|
if (extra && extra[0])
|
|
snprintf(buf, bufsz, ".:%s:%s", extra, libdir);
|
|
else
|
|
snprintf(buf, bufsz, ".:%s", libdir);
|
|
return buf;
|
|
}
|
|
|
|
/* basename_no_ext: last path segment with any trailing ".ww" stripped. */
|
|
static void
|
|
basename_no_ext(const char *path, char *out, size_t outsz)
|
|
{
|
|
const char *base = strrchr(path, '/');
|
|
base = base ? base + 1 : path;
|
|
snprintf(out, outsz, "%s", base);
|
|
char *dot = strrchr(out, '.');
|
|
if (dot && strcmp(dot, ".ww") == 0) *dot = '\0';
|
|
}
|
|
|
|
/* resolve_module: turn a name into a concrete entry path.
|
|
* foo.ww → use as-is if it exists
|
|
* <existing dir> → returns the dir path (caller dir-enumerates)
|
|
* . → cwd as a directory
|
|
* foo (bare) → walk cwd:incs:WW_LIB; first hit is dir or file.
|
|
* Sets *is_dir on hit. Dir resolution drives directory-as-module
|
|
* enumeration in build_one. */
|
|
static int
|
|
resolve_module(const char *name, const char *incs, char *out, size_t outsz,
|
|
int *is_dir)
|
|
{
|
|
struct stat st;
|
|
if (stat(name, &st) == 0) {
|
|
if (S_ISREG(st.st_mode)) {
|
|
snprintf(out, outsz, "%s", name);
|
|
*is_dir = 0;
|
|
return 1;
|
|
}
|
|
if (S_ISDIR(st.st_mode)) {
|
|
snprintf(out, outsz, "%s", name);
|
|
*is_dir = 1;
|
|
return 1;
|
|
}
|
|
}
|
|
char sp[4096];
|
|
search_path(incs, sp, sizeof sp);
|
|
char path_form[256];
|
|
import_path_form(name, path_form, sizeof path_form);
|
|
return locate_import(sp, path_form, out, outsz, is_dir);
|
|
}
|
|
|
|
/* Append `path` to a heap string-array. Caller frees each entry + the array. */
|
|
static void
|
|
strarr_push(char ***arr, int *n, int *cap, const char *path)
|
|
{
|
|
if (*n + 1 > *cap) {
|
|
*cap = *cap ? *cap * 2 : 8;
|
|
*arr = realloc(*arr, *cap * sizeof **arr);
|
|
}
|
|
(*arr)[(*n)++] = strdup(path);
|
|
}
|
|
|
|
/* collect_tests: enumerate _test.ww files in <dir> (no recursion).
|
|
* Returns 0 on success and writes the file list + count, -1 on failure. */
|
|
static int
|
|
collect_tests(const char *dir, char ***files, int *n)
|
|
{
|
|
DIR *d = opendir(dir);
|
|
if (!d) return -1;
|
|
*files = NULL;
|
|
*n = 0;
|
|
int cap = 0;
|
|
struct dirent *ent;
|
|
while ((ent = readdir(d)) != NULL) {
|
|
const char *nm = ent->d_name;
|
|
size_t nl = strlen(nm);
|
|
const char *suf = "_test.ww";
|
|
size_t sl = strlen(suf);
|
|
if (nl <= sl) continue;
|
|
if (strcmp(nm + nl - sl, suf) != 0) continue;
|
|
char path[1024];
|
|
snprintf(path, sizeof path, "%s/%s", dir, nm);
|
|
strarr_push(files, n, &cap, path);
|
|
}
|
|
closedir(d);
|
|
return 0;
|
|
}
|
|
|
|
/* Parse the standard -I/-L/-l/-o flags into incs/libdirs/libs/outpath. The
|
|
* first non-flag positional becomes *src_out. Returns the index past the last
|
|
* arg consumed for positionals (so callers can pick up trailing args), or -1
|
|
* if a flag is missing its argument (diagnostic already emitted). `cmd` names
|
|
* the subcommand for the diagnostic, byte-identical to the wwstage twin's
|
|
* per-subcommand wording (selfhost/cmd/ww/main.ww dobuild/dorun). */
|
|
static int
|
|
parse_build_flags(const char *cmd, int argc, char **argv,
|
|
char *incs, size_t incsz,
|
|
char *libdirs, size_t libdirsz,
|
|
char *libs, size_t libsz,
|
|
char *outpath, size_t outsz,
|
|
const char **src_out, int *want_sep)
|
|
{
|
|
*src_out = NULL;
|
|
int i = 0;
|
|
for (; i < argc; i++) {
|
|
if (strcmp(argv[i], "--sep") == 0) {
|
|
/* M3-tail c3: separate-compilation path, build-only.
|
|
* `run` has no sep-compile-then-run path (out of #46
|
|
* commit-3 scope), so it LOUD-REJECTS rather than
|
|
* silently swallowing a typed flag — both stages reject
|
|
* identically (rule 10; want_sep==NULL marks the run
|
|
* caller). */
|
|
if (want_sep == NULL) {
|
|
fprintf(stderr,
|
|
"ww %s: --sep is only valid with build\n", cmd);
|
|
return -1;
|
|
}
|
|
*want_sep = 1;
|
|
} else if (strncmp(argv[i], "-l", 2) == 0 && argv[i][2]) {
|
|
size_t n = strlen(libs);
|
|
snprintf(libs + n, libsz - n,
|
|
"%s%s", n ? " " : "", argv[i]);
|
|
} else if (strcmp(argv[i], "-l") == 0) {
|
|
if (i + 1 >= argc) {
|
|
fprintf(stderr,
|
|
"ww %s: -l needs an argument\n", cmd);
|
|
return -1;
|
|
}
|
|
size_t n = strlen(libs);
|
|
snprintf(libs + n, libsz - n,
|
|
"%s-l%s", n ? " " : "", argv[++i]);
|
|
} else if (strcmp(argv[i], "-L") == 0) {
|
|
if (i + 1 >= argc) {
|
|
fprintf(stderr,
|
|
"ww %s: -L needs an argument\n", cmd);
|
|
return -1;
|
|
}
|
|
size_t n = strlen(libdirs);
|
|
snprintf(libdirs + n, libdirsz - n,
|
|
"%s-L%s", n ? " " : "", argv[++i]);
|
|
} else if (strncmp(argv[i], "-L", 2) == 0 && argv[i][2]) {
|
|
size_t n = strlen(libdirs);
|
|
snprintf(libdirs + n, libdirsz - n,
|
|
"%s%s", n ? " " : "", argv[i]);
|
|
} else if (strcmp(argv[i], "-I") == 0) {
|
|
if (i + 1 >= argc) {
|
|
fprintf(stderr,
|
|
"ww %s: -I needs an argument\n", cmd);
|
|
return -1;
|
|
}
|
|
size_t n = strlen(incs);
|
|
snprintf(incs + n, incsz - n,
|
|
"%s%s", n ? ":" : "", argv[++i]);
|
|
} else if (strncmp(argv[i], "-I", 2) == 0 && argv[i][2]) {
|
|
size_t n = strlen(incs);
|
|
snprintf(incs + n, incsz - n,
|
|
"%s%s", n ? ":" : "", argv[i] + 2);
|
|
} else if (strcmp(argv[i], "-o") == 0) {
|
|
if (i + 1 >= argc) {
|
|
fprintf(stderr,
|
|
"ww %s: -o needs an argument\n", cmd);
|
|
return -1;
|
|
}
|
|
snprintf(outpath, outsz, "%s", argv[++i]);
|
|
} else if (strncmp(argv[i], "-o", 2) == 0 && argv[i][2]) {
|
|
snprintf(outpath, outsz, "%s", argv[i] + 2);
|
|
} else if (*src_out == NULL) {
|
|
*src_out = argv[i];
|
|
} else {
|
|
break; /* leave remaining argv to caller (run-args) */
|
|
}
|
|
}
|
|
return i;
|
|
}
|
|
|
|
static int
|
|
do_build(int argc, char **argv)
|
|
{
|
|
const char *src = NULL;
|
|
char libs[2048] = {0};
|
|
char libdirs[2048] = {0};
|
|
char incs[2048] = {0};
|
|
char outflag[1024] = {0};
|
|
int want_sep = 0;
|
|
if (parse_build_flags("build", argc, argv, incs, sizeof incs,
|
|
libdirs, sizeof libdirs, libs, sizeof libs,
|
|
outflag, sizeof outflag, &src, &want_sep) < 0)
|
|
return 2;
|
|
if (src == NULL) src = "."; /* default: build cwd */
|
|
char resolved[1024];
|
|
int is_dir = 0;
|
|
if (!resolve_module(src, incs, resolved, sizeof resolved, &is_dir)) {
|
|
fprintf(stderr, "ww build: cannot find module %s\n", src);
|
|
return 1;
|
|
}
|
|
char out[1024];
|
|
const char *objstem = NULL;
|
|
if (outflag[0]) {
|
|
/* -o sets both the binary path and the intermediate stem so
|
|
* artifacts land beside the requested output (T3). */
|
|
snprintf(out, sizeof out, "%s", outflag);
|
|
objstem = out;
|
|
} else if (is_dir) {
|
|
char tmp[1024];
|
|
snprintf(tmp, sizeof tmp, "%s", resolved);
|
|
size_t n = strlen(tmp);
|
|
while (n > 1 && tmp[n-1] == '/') tmp[--n] = '\0';
|
|
const char *b = strrchr(tmp, '/');
|
|
snprintf(out, sizeof out, "%s", b ? b + 1 : tmp);
|
|
} else {
|
|
basename_no_ext(resolved, out, sizeof out);
|
|
}
|
|
if (want_sep)
|
|
return build_one_sep(resolved, is_dir, out, objstem, incs,
|
|
libs, libdirs);
|
|
return build_one(resolved, is_dir, out, objstem, incs, libs, libdirs, 0);
|
|
}
|
|
|
|
static int
|
|
do_run(int argc, char **argv)
|
|
{
|
|
const char *src = NULL;
|
|
char libs[2048] = {0};
|
|
char libdirs[2048] = {0};
|
|
char incs[2048] = {0};
|
|
char outflag[1024] = {0}; /* -o accepted+ignored: run always uses the temp */
|
|
int next = parse_build_flags("run", argc, argv, incs, sizeof incs,
|
|
libdirs, sizeof libdirs, libs, sizeof libs,
|
|
outflag, sizeof outflag, &src, NULL);
|
|
if (next < 0) return 2;
|
|
if (src == NULL) src = ".";
|
|
char resolved[1024];
|
|
int is_dir = 0;
|
|
if (!resolve_module(src, incs, resolved, sizeof resolved, &is_dir)) {
|
|
fprintf(stderr, "ww run: cannot find module %s\n", src);
|
|
return 1;
|
|
}
|
|
char tmp[1024];
|
|
snprintf(tmp, sizeof tmp, "/tmp/ww_run_%d", getpid());
|
|
/* objstem = tmp → intermediates land at /tmp/ww_run_<pid>.{s,o,
|
|
* combined.ww}, never next to the source (T3). */
|
|
if (build_one(resolved, is_dir, tmp, tmp, incs, libs, libdirs, 0) != 0)
|
|
return 1;
|
|
/* exec the built binary with any trailing argv as its argv. */
|
|
pid_t pid = fork();
|
|
if (pid < 0) { perror("ww: fork"); unlink(tmp); return 1; }
|
|
if (pid == 0) {
|
|
int n_extra = argc - next;
|
|
char **xargv = calloc((size_t)n_extra + 2, sizeof *xargv);
|
|
xargv[0] = tmp;
|
|
for (int i = 0; i < n_extra; i++) xargv[i+1] = argv[next + i];
|
|
xargv[n_extra+1] = NULL;
|
|
execv(tmp, xargv);
|
|
perror("ww: exec");
|
|
_exit(127);
|
|
}
|
|
int status = 0;
|
|
waitpid(pid, &status, 0);
|
|
unlink(tmp);
|
|
if (WIFEXITED(status)) return WEXITSTATUS(status);
|
|
return 1;
|
|
}
|
|
|
|
static int
|
|
do_test(int argc, char **argv)
|
|
{
|
|
const char *src = NULL;
|
|
char incs[2048] = {0};
|
|
/* -c (compile-only, Go's `go test -c`) + -o <stem> build the test
|
|
* binary (and its lib/test-inclusive combined, via build_one's
|
|
* is_test auto-bundle + the T3 objstem redirect) WITHOUT running it —
|
|
* the byte-id gates feed <stem>.combined.ww to raw w6c -T / w6c_ww -T.
|
|
* -T stays internal to w6c; the driver never sees it. -l/-L carry no
|
|
* meaning for a test build, so they (and any unknown flag) are rejected
|
|
* rather than silently swallowed — byte-identical wording to the
|
|
* wwstage twin (selfhost/cmd/ww/main.ww dotest). */
|
|
int compileonly = 0;
|
|
char outstem[1024] = {0};
|
|
/* #17: an optional second positional after the target is a fnmatch
|
|
* name-filter pattern, forwarded to the test binary as argv[1]. Only
|
|
* meaningful for a single test file/module — rejected in dir mode. */
|
|
const char *pattern = NULL;
|
|
for (int i = 0; i < argc; i++) {
|
|
if (argv[i][0] == '-') {
|
|
if (argv[i][1] == 'I') {
|
|
const char *dir;
|
|
if (argv[i][2]) {
|
|
dir = argv[i] + 2;
|
|
} else {
|
|
if (i + 1 >= argc) {
|
|
fprintf(stderr,
|
|
"ww test: -I needs an argument\n");
|
|
return 2;
|
|
}
|
|
dir = argv[++i];
|
|
}
|
|
size_t n = strlen(incs);
|
|
snprintf(incs + n, sizeof incs - n,
|
|
"%s%s", n ? ":" : "", dir);
|
|
} else if (strcmp(argv[i], "-c") == 0) {
|
|
compileonly = 1;
|
|
} else if (strcmp(argv[i], "-o") == 0) {
|
|
if (i + 1 >= argc) {
|
|
fprintf(stderr,
|
|
"ww test: -o needs an argument\n");
|
|
return 2;
|
|
}
|
|
snprintf(outstem, sizeof outstem, "%s", argv[++i]);
|
|
} else if (argv[i][1] == 'o' && argv[i][2]) {
|
|
snprintf(outstem, sizeof outstem, "%s", argv[i] + 2);
|
|
} else {
|
|
fprintf(stderr, "ww test: unknown flag\n");
|
|
return 2;
|
|
}
|
|
} else if (src == NULL) {
|
|
src = argv[i];
|
|
} else if (pattern == NULL) {
|
|
pattern = argv[i];
|
|
}
|
|
}
|
|
const char *target = src ? src : ".";
|
|
struct stat st;
|
|
if (stat(target, &st) != 0) {
|
|
/* not a literal path — try module resolution and run as
|
|
* a single test program. */
|
|
char resolved[1024];
|
|
int is_dir = 0;
|
|
if (!resolve_module(target, incs, resolved, sizeof resolved,
|
|
&is_dir)) {
|
|
fprintf(stderr, "ww test: cannot find %s\n", target);
|
|
return 1;
|
|
}
|
|
char tmp[1024];
|
|
const char *outp;
|
|
if (outstem[0]) outp = outstem;
|
|
else { snprintf(tmp, sizeof tmp, "/tmp/ww_test_%d", getpid()); outp = tmp; }
|
|
if (build_one(resolved, is_dir, outp, outstem[0] ? outstem : NULL,
|
|
incs, "", "", 1) != 0) return 1;
|
|
if (compileonly) return 0;
|
|
int rc = run_test_bin(outp, pattern);
|
|
if (!outstem[0]) unlink(outp);
|
|
return rc;
|
|
}
|
|
if (S_ISREG(st.st_mode)) {
|
|
/* single .ww file — build, then run unless -c (compile-only). */
|
|
char tmp[1024];
|
|
const char *outp;
|
|
if (outstem[0]) outp = outstem;
|
|
else { snprintf(tmp, sizeof tmp, "/tmp/ww_test_%d", getpid()); outp = tmp; }
|
|
if (build_one(target, 0, outp, outstem[0] ? outstem : NULL,
|
|
incs, "", "", 1) != 0) return 1;
|
|
if (compileonly) return 0;
|
|
int rc = run_test_bin(outp, pattern);
|
|
if (!outstem[0]) unlink(outp);
|
|
return rc;
|
|
}
|
|
if (!S_ISDIR(st.st_mode)) {
|
|
fprintf(stderr, "ww test: %s is neither file nor directory\n", target);
|
|
return 1;
|
|
}
|
|
if (compileonly || outstem[0]) {
|
|
fprintf(stderr, "ww test: -c/-o need a single test file\n");
|
|
return 2;
|
|
}
|
|
/* #17: a name-filter pattern is per-binary; directory mode builds one
|
|
* binary per *_test.ww, so a single pattern can't sensibly route. */
|
|
if (pattern) {
|
|
fprintf(stderr, "ww test: pattern needs a single test file\n");
|
|
return 2;
|
|
}
|
|
/* directory — run every *_test.ww inside. */
|
|
char **files = NULL;
|
|
int n = 0;
|
|
if (collect_tests(target, &files, &n) < 0) {
|
|
fprintf(stderr, "ww test: cannot read directory %s\n", target);
|
|
return 1;
|
|
}
|
|
if (n == 0) {
|
|
fprintf(stderr, "ww test: no *_test.ww files in %s\n", target);
|
|
return 1;
|
|
}
|
|
int pass = 0, fail = 0;
|
|
for (int i = 0; i < n; i++) {
|
|
char tmp[1024];
|
|
snprintf(tmp, sizeof tmp, "/tmp/ww_test_%d_%d", getpid(), i);
|
|
const char *label = strrchr(files[i], '/');
|
|
label = label ? label + 1 : files[i];
|
|
int rc = build_one(files[i], 0, tmp, NULL, target, "", "", 1);
|
|
if (rc != 0) {
|
|
fprintf(stderr, "FAIL %s (build)\n", label);
|
|
fail++;
|
|
} else {
|
|
int xrc = run(tmp);
|
|
if (xrc == 0) {
|
|
printf("ok %s\n", label);
|
|
pass++;
|
|
} else {
|
|
printf("FAIL %s (rc=%d)\n", label, xrc);
|
|
fail++;
|
|
}
|
|
}
|
|
unlink(tmp);
|
|
free(files[i]);
|
|
}
|
|
free(files);
|
|
printf("ww test: %d pass, %d fail\n", pass, fail);
|
|
return fail == 0 ? 0 : 1;
|
|
}
|
|
|
|
static int
|
|
do_fmt(int argc, char **argv)
|
|
{
|
|
(void)argc; (void)argv;
|
|
fputs("ww: fmt: not implemented in this phase\n", stderr);
|
|
return 1;
|
|
}
|
|
|
|
int
|
|
main(int argc, char **argv)
|
|
{
|
|
if (argc >= 1) {
|
|
char buf[1024];
|
|
snprintf(buf, sizeof buf, "%s", argv[0]);
|
|
self_dir = strdup(dirname(buf));
|
|
}
|
|
if (argc < 2) { fputs(usage, stderr); return 2; }
|
|
const char *cmd = argv[1];
|
|
if (strcmp(cmd, "-V") == 0 || strcmp(cmd, "version") == 0)
|
|
return do_version();
|
|
if (strcmp(cmd, "-h") == 0 || strcmp(cmd, "--help") == 0) {
|
|
fputs(usage, stdout); return 0;
|
|
}
|
|
if (strcmp(cmd, "build") == 0) return do_build(argc - 2, argv + 2);
|
|
if (strcmp(cmd, "run") == 0) return do_run(argc - 2, argv + 2);
|
|
if (strcmp(cmd, "test") == 0) return do_test(argc - 2, argv + 2);
|
|
if (strcmp(cmd, "fmt") == 0) return do_fmt(argc - 2, argv + 2);
|
|
fprintf(stderr, "ww: unknown subcommand: %s\n", cmd);
|
|
fputs(usage, stderr);
|
|
return 2;
|
|
}
|