ww: rename toolchain to w-prefix + hare-style build/run/test driver
Plan 9-style w-prefix on the per-arch tools, disambiguating from the
real Plan 9 6c/6a/6l in ref/plan9front/:
cmd/wwc/ → cmd/wcc/ libwwc.a → libwcc.a
cmd/6{c,a,l} → cmd/w6{c,a,l} binary names too
test/wwc/ → test/wcc/ 6 test files w/ w6 prefix
selfhost/cmd mirror in lockstep
bootstrap/amd64/{w6c,w6a,w6l} snapshot binaries (gitignored)
WW_6{C,A,L} → WW_W6{C,A,L} env-var overrides
Plan 9 source-tree refs ("Plan 9 6c shape", ref/plan9front/, etc.)
preserved. Hare-style driver, both C and ww sides:
ww test [path] discover *_test.ww in a directory module, run
each; single-file mode for `ww test foo.ww`
Module-by-name `ww build foo` resolves to foo.ww or foo/foo.ww
via search path (cwd : -I dirs : $WW_LIB)
Default-to-cwd `ww build` / `ww test` build the cwd module
Run pass-through `ww run path arg1 arg2` reaches the program
lib/os: getcwd (79) and getdents64 (217) syscalls power `.` resolution
and directory enumeration on the ww side.
Makefile: wwstage tool deps now include lib/os/os.ww (+ lib/strconv
for wwdump_ww) so lib/* edits force their rebuild instead of leaving
stale binaries — surfaced when test 995 first failed against a stale
w6c_ww built before the lib/os additions.
Test 993 byte-identical parity gate (C-side ww vs ww-side ww_ww on a
build corpus) stays green; all 19 tests pass.
This commit is contained in:
350
cmd/ww/main.c
350
cmd/ww/main.c
@@ -2,28 +2,36 @@
|
||||
* ww — the user-facing driver. Plan 9 cc(1) / Hare hare(1) analogue.
|
||||
*
|
||||
* Pipeline:
|
||||
* ww build foo.ww → 6c foo.ww > foo.s ; 6a foo.s > foo.o ;
|
||||
* 6l -o foo foo.o <runtime.o>
|
||||
* 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_6C / WW_6A / WW_6L.
|
||||
* 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\n"
|
||||
" run <path> build then exec\n"
|
||||
" test <path> build and run module tests\n"
|
||||
" fmt <path> reformat ww source\n"
|
||||
" version print version and exit\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 */
|
||||
|
||||
@@ -159,9 +167,9 @@ static int
|
||||
build_one(const char *src, const char *out, const char *extra_includes,
|
||||
const char *extra_libs, const char *extra_libdirs)
|
||||
{
|
||||
const char *c6 = toolpath("WW_6C", "6c");
|
||||
const char *a6 = toolpath("WW_6A", "6a");
|
||||
const char *l6 = toolpath("WW_6L", "6l");
|
||||
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];
|
||||
@@ -216,12 +224,12 @@ build_one(const char *src, const char *out, const char *extra_includes,
|
||||
char cmd[4096];
|
||||
snprintf(cmd, sizeof cmd, "%s -o %s %s", c6, asmf, combined);
|
||||
if (run(cmd) != 0) {
|
||||
fprintf(stderr, "ww: 6c failed\n");
|
||||
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: 6a failed\n");
|
||||
fprintf(stderr, "ww: w6a failed\n");
|
||||
return 1;
|
||||
}
|
||||
/* Link runtime: prefer libwwrt.a (selective archive pull) but
|
||||
@@ -238,7 +246,7 @@ build_one(const char *src, const char *out, const char *extra_includes,
|
||||
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 6l can resolve the latter. */
|
||||
/* -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",
|
||||
@@ -246,7 +254,7 @@ build_one(const char *src, const char *out, const char *extra_includes,
|
||||
libdirset[0] ? " " : "", libdirset,
|
||||
libargs[0] ? " " : "", libargs);
|
||||
if (run(cmd) != 0) {
|
||||
fprintf(stderr, "ww: 6l failed\n");
|
||||
fprintf(stderr, "ww: w6l failed\n");
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
@@ -259,70 +267,292 @@ do_version(void)
|
||||
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 .ww file path.
|
||||
* foo.ww → use as-is if it exists
|
||||
* <existing dir> → <dir>/<basename>.ww (Hare module convention)
|
||||
* . → <cwd-basename>.ww in the cwd
|
||||
* foo (bare) → walk cwd:incs:WW_LIB for foo.ww or foo/foo.ww
|
||||
* Returns 1 on success and writes the path to `out`, 0 on failure. */
|
||||
static int
|
||||
resolve_module(const char *name, const char *incs, char *out, size_t outsz)
|
||||
{
|
||||
struct stat st;
|
||||
if (stat(name, &st) == 0) {
|
||||
if (S_ISREG(st.st_mode)) {
|
||||
snprintf(out, outsz, "%s", name);
|
||||
return 1;
|
||||
}
|
||||
if (S_ISDIR(st.st_mode)) {
|
||||
char buf[1024];
|
||||
const char *base;
|
||||
if (strcmp(name, ".") == 0) {
|
||||
if (getcwd(buf, sizeof buf) == NULL) return 0;
|
||||
} else {
|
||||
snprintf(buf, sizeof buf, "%s", name);
|
||||
size_t bl = strlen(buf);
|
||||
while (bl > 1 && buf[bl-1] == '/') buf[--bl] = '\0';
|
||||
}
|
||||
const char *b = strrchr(buf, '/');
|
||||
base = b ? b + 1 : buf;
|
||||
snprintf(out, outsz, "%s/%s.ww", name, base);
|
||||
if (access(out, 0) == 0) return 1;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
char sp[4096];
|
||||
search_path(incs, sp, sizeof sp);
|
||||
if (locate_import(sp, name, out, outsz)) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* 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 flags into incs/libdirs/libs. 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). */
|
||||
static int
|
||||
parse_build_flags(int argc, char **argv,
|
||||
char *incs, size_t incsz,
|
||||
char *libdirs, size_t libdirsz,
|
||||
char *libs, size_t libsz,
|
||||
const char **src_out)
|
||||
{
|
||||
*src_out = NULL;
|
||||
int i = 0;
|
||||
for (; i < argc; i++) {
|
||||
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 && i + 1 < argc) {
|
||||
size_t n = strlen(libs);
|
||||
snprintf(libs + n, libsz - n,
|
||||
"%s-l%s", n ? " " : "", argv[++i]);
|
||||
} else if (strcmp(argv[i], "-L") == 0 && i + 1 < argc) {
|
||||
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 && i + 1 < argc) {
|
||||
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 (*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}; /* -l<name> entries, space-separated */
|
||||
char libdirs[2048] = {0}; /* -L<dir> entries, space-separated */
|
||||
char libs[2048] = {0};
|
||||
char libdirs[2048] = {0};
|
||||
char incs[2048] = {0};
|
||||
for (int i = 0; i < argc; i++) {
|
||||
if (strncmp(argv[i], "-l", 2) == 0 && argv[i][2]) {
|
||||
size_t n = strlen(libs);
|
||||
snprintf(libs + n, sizeof libs - n,
|
||||
"%s%s", n ? " " : "", argv[i]);
|
||||
} else if (strcmp(argv[i], "-l") == 0 && i + 1 < argc) {
|
||||
size_t n = strlen(libs);
|
||||
snprintf(libs + n, sizeof libs - n,
|
||||
"%s-l%s", n ? " " : "", argv[++i]);
|
||||
} else if (strcmp(argv[i], "-L") == 0 && i + 1 < argc) {
|
||||
size_t n = strlen(libdirs);
|
||||
snprintf(libdirs + n, sizeof libdirs - 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, sizeof libdirs - n,
|
||||
"%s%s", n ? " " : "", argv[i]);
|
||||
} else if (strcmp(argv[i], "-I") == 0 && i + 1 < argc) {
|
||||
size_t n = strlen(incs);
|
||||
snprintf(incs + n, sizeof incs - 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, sizeof incs - n,
|
||||
"%s%s", n ? ":" : "", argv[i] + 2);
|
||||
} else if (src == NULL) {
|
||||
src = argv[i];
|
||||
}
|
||||
parse_build_flags(argc, argv, incs, sizeof incs,
|
||||
libdirs, sizeof libdirs, libs, sizeof libs, &src);
|
||||
if (src == NULL) src = "."; /* default: build cwd */
|
||||
char resolved[1024];
|
||||
if (!resolve_module(src, incs, resolved, sizeof resolved)) {
|
||||
fprintf(stderr, "ww build: cannot find module %s\n", src);
|
||||
return 1;
|
||||
}
|
||||
if (src == NULL) { fputs("ww build: missing source\n", stderr); return 2; }
|
||||
char out[1024];
|
||||
const char *base = strrchr(src, '/');
|
||||
base = base ? base + 1 : src;
|
||||
snprintf(out, sizeof out, "%s", base);
|
||||
char *dot = strrchr(out, '.');
|
||||
if (dot && strcmp(dot, ".ww") == 0) *dot = '\0';
|
||||
return build_one(src, out, incs, libs, libdirs);
|
||||
basename_no_ext(resolved, out, sizeof out);
|
||||
return build_one(resolved, out, incs, libs, libdirs);
|
||||
}
|
||||
|
||||
static int
|
||||
do_run(int argc, char **argv)
|
||||
{
|
||||
if (argc < 1) { fputs("ww run: missing source\n", stderr); return 2; }
|
||||
const char *src = NULL;
|
||||
char libs[2048] = {0};
|
||||
char libdirs[2048] = {0};
|
||||
char incs[2048] = {0};
|
||||
int next = parse_build_flags(argc, argv, incs, sizeof incs,
|
||||
libdirs, sizeof libdirs, libs, sizeof libs, &src);
|
||||
if (src == NULL) src = ".";
|
||||
char resolved[1024];
|
||||
if (!resolve_module(src, incs, resolved, sizeof resolved)) {
|
||||
fprintf(stderr, "ww run: cannot find module %s\n", src);
|
||||
return 1;
|
||||
}
|
||||
char tmp[1024];
|
||||
snprintf(tmp, sizeof tmp, "/tmp/ww_run_%d", getpid());
|
||||
if (build_one(argv[0], tmp, "", "", "") != 0) return 1;
|
||||
int rc = run(tmp);
|
||||
if (build_one(resolved, tmp, incs, libs, libdirs) != 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);
|
||||
return rc;
|
||||
if (WIFEXITED(status)) return WEXITSTATUS(status);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int
|
||||
do_test(int argc, char **argv)
|
||||
{
|
||||
(void)argc; (void)argv;
|
||||
fputs("ww: test: not implemented in this phase\n", stderr);
|
||||
return 1;
|
||||
const char *target = (argc > 0) ? argv[0] : ".";
|
||||
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];
|
||||
if (!resolve_module(target, "", resolved, sizeof resolved)) {
|
||||
fprintf(stderr, "ww test: cannot find %s\n", target);
|
||||
return 1;
|
||||
}
|
||||
char tmp[1024];
|
||||
snprintf(tmp, sizeof tmp, "/tmp/ww_test_%d", getpid());
|
||||
if (build_one(resolved, tmp, "", "", "") != 0) return 1;
|
||||
int rc = run(tmp);
|
||||
unlink(tmp);
|
||||
return rc;
|
||||
}
|
||||
if (S_ISREG(st.st_mode)) {
|
||||
/* single .ww file — build+run it. */
|
||||
char tmp[1024];
|
||||
snprintf(tmp, sizeof tmp, "/tmp/ww_test_%d", getpid());
|
||||
if (build_one(target, tmp, "", "", "") != 0) return 1;
|
||||
int rc = run(tmp);
|
||||
unlink(tmp);
|
||||
return rc;
|
||||
}
|
||||
if (!S_ISDIR(st.st_mode)) {
|
||||
fprintf(stderr, "ww test: %s is neither file nor directory\n", target);
|
||||
return 1;
|
||||
}
|
||||
/* 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], tmp, target, "", "");
|
||||
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
|
||||
|
||||
Reference in New Issue
Block a user