1889 lines
60 KiB
C
1889 lines
60 KiB
C
/*
|
|
* ww — the user-facing driver. Plan 9 cc(1) / Hare hare(1) analogue.
|
|
*
|
|
* 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 <errno.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 [-S] [-w DIR] [-o FILE] [path] compile module; -S stops after package asm\n"
|
|
" run [path] ... build then exec, passing extra args to the program\n"
|
|
" test [-S -o STEM] [-w DIR] [options] [path] build/run tests; -S emits package asm\n"
|
|
" version print version and exit\n"
|
|
"\n"
|
|
" path forms:\n"
|
|
" foo.ww literal file\n"
|
|
" foo search cwd, -I dirs, then the source library for foo.ww or foo/\n"
|
|
" lib/foo directory: build its package sources\n"
|
|
" lib/... every package under lib, recursively (test only)\n"
|
|
" . build the cwd's <basename>.ww\n";
|
|
|
|
static char *self_dir;
|
|
|
|
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 passes the same
|
|
* argv to os.exec.runstdio). #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;
|
|
/* the do_run twin's EINTR discipline: an interrupted wait left
|
|
* status==0, so WIFEXITED(0)/WEXITSTATUS(0) reported a false
|
|
* test PASS. */
|
|
pid_t got;
|
|
do { got = waitpid(pid, &status, 0); } while (got < 0 && errno == EINTR);
|
|
if (got < 0) { perror("ww: waitpid"); return -1; }
|
|
if (WIFEXITED(status)) return WEXITSTATUS(status);
|
|
return 1;
|
|
}
|
|
|
|
/* Delegate package/directory testing to the native WW coordinator. Keep the
|
|
* old single-file path in this driver: wwtest itself builds each generated
|
|
* package root through `ww test -c ... package.ww`, so that file boundary also
|
|
* prevents delegation recursion. */
|
|
static int
|
|
exec_package_tests(int argc, char **argv, const char *target,
|
|
const char *resolved, int add_dot)
|
|
{
|
|
const char *override = getenv("WW_WWTEST");
|
|
char fallback[1024];
|
|
const char *prog = override && override[0] ? override : fallback;
|
|
if (prog == fallback)
|
|
snprintf(fallback, sizeof fallback, "%s/wwtest", self_dir);
|
|
char builder[1024];
|
|
snprintf(builder, sizeof builder, "%s/ww", self_dir);
|
|
|
|
char **xargv = calloc((size_t)argc + 6, sizeof *xargv);
|
|
if (xargv == NULL) {
|
|
fputs("ww test: cannot allocate package coordinator arguments\n",
|
|
stderr);
|
|
return 1;
|
|
}
|
|
int n = 0, dotted = 0;
|
|
xargv[n++] = (char *)prog;
|
|
xargv[n++] = "package";
|
|
xargv[n++] = "--ww-driver";
|
|
xargv[n++] = builder;
|
|
for (int i = 0; i < argc; i++) {
|
|
if (add_dot && !dotted && strcmp(argv[i], "--") == 0) {
|
|
xargv[n++] = ".";
|
|
dotted = 1;
|
|
}
|
|
xargv[n++] = (resolved && argv[i] == target)
|
|
? (char *)resolved : argv[i];
|
|
}
|
|
if (add_dot && !dotted) xargv[n++] = ".";
|
|
xargv[n] = NULL;
|
|
execv(prog, xargv); /* inherit the caller's environment */
|
|
fputs("ww test: cannot exec package test coordinator\n", stderr);
|
|
free(xargv);
|
|
return 1;
|
|
}
|
|
|
|
/* Breaks 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);
|
|
}
|
|
|
|
/* `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';
|
|
}
|
|
|
|
/* 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, int want_dir)
|
|
{
|
|
struct stat st;
|
|
if (want_dir) {
|
|
snprintf(out, outsz, "%s/%s", dir, path_form);
|
|
if (stat(out, &st) == 0 && S_ISDIR(st.st_mode)) {
|
|
*is_dir = 1;
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
snprintf(out, outsz, "%s/%s.ww", dir, path_form);
|
|
if (access(out, 0) == 0) {
|
|
*is_dir = 0;
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* #98: "a module IS the directory" — a directory-package on ANY entry
|
|
* wins over a same-named sibling FILE on an EARLIER entry. The driver
|
|
* builds the searchpath srcd-first; a co-located `lib/<mod>/<x>_test.ww`
|
|
* entry makes srcd = lib/<mod>, so a self-named `import <mod>` would
|
|
* else file-hit the sibling lib/<mod>/<mod>.ww and fold it
|
|
* inline under the wrong module-reset → "package <mod> does not match
|
|
* import path <importer>". Two passes — directories first, files only
|
|
* if no directory matches anywhere — let lib/<mod>/ resolve as the dir
|
|
* while a genuine leaf package with no directory (e.g. lib/encoding/hex
|
|
* imported bare as `hex`, reachable only via its file in srcd) still
|
|
* resolves in the file pass. Latent: a dir-package now beats an
|
|
* earlier-entry same-named sibling FILE — loud-failing, none in the
|
|
* corpus; tracked as #101. */
|
|
static int
|
|
locate_import(const char *dirs, const char *path_form, char *out,
|
|
size_t outsz, int *is_dir)
|
|
{
|
|
for (int want_dir = 1; want_dir >= 0; want_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, want_dir)) return 1;
|
|
}
|
|
if (!e) break;
|
|
p = e + 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Byte-wise total order is locale-independent; rule-10 byte-id requires
|
|
* the two stages sort the same way. strcmp diverges from Hare's memcmp
|
|
* (ref/hare/sort/cmp/cmp.ha:9); the order is identical for NUL-free
|
|
* filenames. */
|
|
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);
|
|
}
|
|
|
|
/* Go's contract: only *_test.ww is a test source. A line-leading @test
|
|
* declaration anywhere else would be silently dropped by a non-T build
|
|
* (#6, the Hare model), so directory enumeration rejects it loudly. */
|
|
static int
|
|
file_has_line_test(const char *path)
|
|
{
|
|
char line[4096];
|
|
FILE *f = fopen(path, "rb");
|
|
if (f == NULL) return 0;
|
|
int found = 0;
|
|
while (fgets(line, sizeof line, f) != NULL) {
|
|
char *p = line;
|
|
while (*p == ' ' || *p == '\t' || *p == '\r') p++;
|
|
if (strncmp(p, "@test", 5) == 0
|
|
&& (p[5] == ' ' || p[5] == '\t')) {
|
|
found = 1;
|
|
break;
|
|
}
|
|
}
|
|
fclose(f);
|
|
return found;
|
|
}
|
|
|
|
/* A line-leading @test in a production source is diagnosed here and
|
|
* returns -2. This is the sole directory-membership discovery path; the
|
|
* owning seppkg retains the returned list. */
|
|
static int
|
|
enumerate_dir_ww(const char *dirpath, char ***out_files)
|
|
{
|
|
DIR *d = opendir(dirpath);
|
|
if (d == NULL) { *out_files = NULL; return -1; }
|
|
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;
|
|
char path[2048];
|
|
snprintf(path, sizeof path, "%s/%s", dirpath, nm);
|
|
if (nl >= 8 && strcmp(nm + nl - 8, "_test.ww") == 0)
|
|
continue;
|
|
if (file_has_line_test(path)) {
|
|
fprintf(stderr,
|
|
"ww: %s: @test declaration outside *_test.ww\n",
|
|
path);
|
|
for (int i = 0; i < n; i++) free(arr[i]);
|
|
free(arr);
|
|
closedir(d);
|
|
*out_files = NULL;
|
|
return -2;
|
|
}
|
|
if (n + 1 > cap) {
|
|
cap = cap ? cap * 2 : 8;
|
|
arr = realloc(arr, cap * sizeof *arr);
|
|
}
|
|
arr[n++] = strdup(path);
|
|
}
|
|
closedir(d);
|
|
if (n > 1) qsort(arr, n, sizeof *arr, strs_cmp);
|
|
*out_files = arr;
|
|
return n;
|
|
}
|
|
|
|
/* ww build — separate-compilation driver (task #46/c3).
|
|
*
|
|
* This is the SOLE build path (E3-C1 flip, task #87): the legacy
|
|
* single-file amalgamator is gone. Each imported
|
|
* package's `.wwi` interface is materialized and every package is
|
|
* compiled on its own (`w6c -c`), then the `.o` set is flat-linked.
|
|
*
|
|
* 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) */
|
|
char name[256]; /* validated declared name; directory packages only */
|
|
char **sources; /* owned, byte-sorted production paths; dirs only */
|
|
int nsources;
|
|
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;
|
|
};
|
|
|
|
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: 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->name[0] = '\0';
|
|
p->sources = NULL;
|
|
p->nsources = 0;
|
|
p->ndeps = 0;
|
|
p->color = 0;
|
|
return g->n++;
|
|
}
|
|
|
|
/* Release the one package-owned directory-membership list. Every graph exit
|
|
* funnels through this function; regular-file nodes own no source list. */
|
|
static void
|
|
sep_graph_free(struct sepgraph *g)
|
|
{
|
|
if (g == NULL) return;
|
|
for (int i = 0; i < g->n; i++) {
|
|
for (int j = 0; j < g->pkg[i].nsources; j++)
|
|
free(g->pkg[i].sources[j]);
|
|
free(g->pkg[i].sources);
|
|
}
|
|
free(g);
|
|
}
|
|
|
|
/* 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);
|
|
}
|
|
|
|
/* 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 a
|
|
* first-package-decl scan, this checks every line — single-file
|
|
* multi-package fixtures carry several `package` decls. The
|
|
* comment-skip line scan + name match are 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;
|
|
}
|
|
|
|
static int
|
|
sep_ident_start(int c)
|
|
{
|
|
return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_';
|
|
}
|
|
|
|
static int
|
|
sep_ident_continue(int c)
|
|
{
|
|
return sep_ident_start(c) || (c >= '0' && c <= '9');
|
|
}
|
|
|
|
/* Deliberately only the loader's small header grammar for the leading
|
|
* package clause, not a second compiler lexer. */
|
|
static int
|
|
sep_skip_space(const char *src, size_t n, size_t *off)
|
|
{
|
|
size_t i = *off;
|
|
for (;;) {
|
|
while (i < n && (src[i] == ' ' || src[i] == '\t'
|
|
|| src[i] == '\r' || src[i] == '\n'))
|
|
i++;
|
|
if (i + 1 < n && src[i] == '/' && src[i + 1] == '/') {
|
|
i += 2;
|
|
while (i < n && src[i] != '\n') i++;
|
|
continue;
|
|
}
|
|
if (i + 1 < n && src[i] == '/' && src[i + 1] == '*') {
|
|
i += 2;
|
|
while (i + 1 < n && !(src[i] == '*' && src[i + 1] == '/'))
|
|
i++;
|
|
if (i + 1 >= n) return -1;
|
|
i += 2;
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
*off = i;
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
sep_package_clause(const char *src, size_t n, char *name, size_t namesz)
|
|
{
|
|
static const char kw[] = "package";
|
|
size_t i = 0;
|
|
if (sep_skip_space(src, n, &i) < 0
|
|
|| i + sizeof kw - 1 >= n
|
|
|| memcmp(src + i, kw, sizeof kw - 1) != 0)
|
|
return -1;
|
|
i += sizeof kw - 1;
|
|
if (i >= n || (src[i] != ' ' && src[i] != '\t'
|
|
&& src[i] != '\r' && src[i] != '\n'))
|
|
return -1;
|
|
if (sep_skip_space(src, n, &i) < 0 || i >= n
|
|
|| !sep_ident_start((unsigned char)src[i]))
|
|
return -1;
|
|
size_t begin = i++;
|
|
while (i < n && sep_ident_continue((unsigned char)src[i])) i++;
|
|
size_t len = i - begin;
|
|
if (len + 1 > namesz || sep_skip_space(src, n, &i) < 0
|
|
|| i >= n || src[i] != ';')
|
|
return -1;
|
|
memcpy(name, src + begin, len);
|
|
name[len] = '\0';
|
|
return 0;
|
|
}
|
|
|
|
/* 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). Collects package PATHS
|
|
* rather than concatenating bytes the way the legacy amalgamator did
|
|
* (§1.1). */
|
|
static int
|
|
sep_scan_file(struct sepgraph *g, int pi, const char *file,
|
|
const char *searchpath, struct ImportSet *filevisit, int owned_source)
|
|
{
|
|
if (import_seen(filevisit, file)) return 0;
|
|
import_add(filevisit, file);
|
|
FILE *in = fopen(file, "rb");
|
|
if (in == NULL) {
|
|
fprintf(stderr, "ww: cannot read %s\n", file);
|
|
return -1;
|
|
}
|
|
if (fseek(in, 0, SEEK_END) != 0) { fclose(in); return -1; }
|
|
long flen = ftell(in);
|
|
if (flen < 0 || fseek(in, 0, SEEK_SET) != 0) {
|
|
fclose(in);
|
|
return -1;
|
|
}
|
|
char *buf = malloc((size_t)flen + 1);
|
|
if (buf == NULL) { fclose(in); return -1; }
|
|
if (fread(buf, 1, (size_t)flen, in) != (size_t)flen) {
|
|
free(buf);
|
|
fclose(in);
|
|
return -1;
|
|
}
|
|
buf[flen] = '\0';
|
|
fclose(in);
|
|
|
|
if (owned_source) {
|
|
char declared[256];
|
|
if (sep_package_clause(buf, (size_t)flen, declared,
|
|
sizeof declared) < 0) {
|
|
fprintf(stderr, "ww: %s: invalid or missing package clause\n",
|
|
file);
|
|
free(buf);
|
|
return -1;
|
|
}
|
|
struct seppkg *pkg = &g->pkg[pi];
|
|
if (pkg->name[0] == '\0')
|
|
snprintf(pkg->name, sizeof pkg->name, "%s", declared);
|
|
else if (strcmp(pkg->name, declared) != 0) {
|
|
fprintf(stderr,
|
|
"ww: %s: conflicting package names %s and %s\n",
|
|
pkg->entry, pkg->name, declared);
|
|
free(buf);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
int rc = 0;
|
|
for (size_t off = 0; off < (size_t)flen && rc == 0;) {
|
|
size_t end = off;
|
|
while (end < (size_t)flen && buf[end] != '\n') end++;
|
|
const char *p = buf + off;
|
|
const char *lineend = buf + end;
|
|
while (p < lineend && (*p == ' ' || *p == '\t')) p++;
|
|
if ((size_t)(lineend - p) < 7
|
|
|| (memcmp(p, "import ", 7) != 0
|
|
&& memcmp(p, "import\t", 7) != 0)) {
|
|
off = end < (size_t)flen ? end + 1 : end;
|
|
continue;
|
|
}
|
|
p += 7;
|
|
while (p < lineend && (*p == ' ' || *p == '\t')) p++;
|
|
char name[256] = {0};
|
|
int j = 0;
|
|
while (p < lineend && ((*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) {
|
|
off = end < (size_t)flen ? end + 1 : end;
|
|
continue;
|
|
}
|
|
char path_form[256];
|
|
import_path_form(name, path_form, sizeof path_form);
|
|
char ipath[1024];
|
|
int is_dir = 0;
|
|
/* #16 ENFORCE-driver: an unresolvable import is a hard error,
|
|
* not a silent skip — EXCEPT when the package is defined INLINE
|
|
* in the same unit (single-file multi-package; leaf = the last
|
|
* dotted component). E3-C1 (#87): the legacy amalgamator that
|
|
* used to own the genuine-missing case is gone, so the sep
|
|
* producer enforces it here (INV-2, by construction). */
|
|
if (!locate_import(searchpath, path_form, ipath, sizeof ipath,
|
|
&is_dir)) {
|
|
const char *dot = strrchr(name, '.');
|
|
const char *leaf = dot ? dot + 1 : name;
|
|
if (unit_has_package(file, leaf))
|
|
goto next_line; /* inline-satisfied */
|
|
fprintf(stderr, "ww: cannot find package %s\n", name);
|
|
rc = -1;
|
|
goto next_line;
|
|
}
|
|
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) < 0) {
|
|
rc = -1; break;
|
|
}
|
|
next_line:
|
|
off = end < (size_t)flen ? end + 1 : end;
|
|
}
|
|
free(buf);
|
|
return rc;
|
|
}
|
|
|
|
/* Load package pi once: a directory node takes ownership of its sorted
|
|
* production paths, then the same stored list supplies package-name
|
|
* validation and dependency scanning. Recurse over the resulting edges.
|
|
* `color` doubles as a loaded marker here (2 == loaded); it is reset to
|
|
* white before the topo pass. */
|
|
static int
|
|
sep_load_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) {
|
|
g->pkg[pi].nsources = enumerate_dir_ww(g->pkg[pi].entry,
|
|
&g->pkg[pi].sources);
|
|
if (g->pkg[pi].nsources == -2) {
|
|
rc = -1; /* diagnosed in enumerate_dir_ww */
|
|
} else if (g->pkg[pi].nsources < 0) {
|
|
fprintf(stderr, "ww: cannot read directory %s\n",
|
|
g->pkg[pi].entry);
|
|
rc = -1;
|
|
} else if (g->pkg[pi].nsources == 0) {
|
|
fprintf(stderr,
|
|
"ww: %s: directory contains no WW package sources\n",
|
|
g->pkg[pi].entry);
|
|
rc = -1;
|
|
}
|
|
for (int i = 0; i < g->pkg[pi].nsources && rc == 0; i++)
|
|
rc = sep_scan_file(g, pi, g->pkg[pi].sources[i],
|
|
searchpath, &fv, 1);
|
|
if (rc == 0 && g->pkg[pi].path[0] != '\0') {
|
|
const char *dot = strrchr(g->pkg[pi].path, '.');
|
|
const char *leaf = dot ? dot + 1 : g->pkg[pi].path;
|
|
if (strcmp(g->pkg[pi].name, leaf) != 0) {
|
|
fprintf(stderr,
|
|
"ww: package %s does not match import path %s\n",
|
|
g->pkg[pi].name, g->pkg[pi].path);
|
|
rc = -1;
|
|
}
|
|
}
|
|
} else {
|
|
rc = sep_scan_file(g, pi, g->pkg[pi].entry, searchpath, &fv, 0);
|
|
}
|
|
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_load_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: 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;
|
|
}
|
|
|
|
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, 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;
|
|
if (!locate_import(searchpath, path_form, ipath, sizeof ipath,
|
|
&is_dir))
|
|
continue;
|
|
if (!is_dir)
|
|
sep_emit_body(out, ipath, visited, searchpath, modpath);
|
|
}
|
|
/* #57: tag the primary body by its full dotted import path so the
|
|
* definer mangles == the importer reference; a root build (path "")
|
|
* stays a bare reset (keeps bare main). */
|
|
if (modpath != NULL && modpath[0] != '\0')
|
|
fprintf(out, "//ww:module-reset %s\n", modpath);
|
|
else
|
|
fputs("//ww:module-reset\n", out);
|
|
rewind(in);
|
|
int ch;
|
|
while ((ch = fgetc(in)) != EOF) fputc(ch, out);
|
|
fputc('\n', out);
|
|
fclose(in);
|
|
}
|
|
|
|
/* 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. Directory membership comes only from the
|
|
* package node loaded before planning. */
|
|
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: 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: 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) {
|
|
for (int i = 0; i < g->pkg[pi].nsources; i++)
|
|
sep_emit_body(u, g->pkg[pi].sources[i], &bodyvisit,
|
|
searchpath, g->pkg[pi].path);
|
|
} else {
|
|
sep_emit_body(u, g->pkg[pi].entry, &bodyvisit, searchpath,
|
|
g->pkg[pi].path);
|
|
}
|
|
for (int i = 0; i < bodyvisit.n; i++) free(bodyvisit.paths[i]);
|
|
free(bodyvisit.paths);
|
|
fclose(u);
|
|
return 0;
|
|
}
|
|
|
|
/* archive_o — write a deterministic single-member SysV ar archive at
|
|
* `apath` wrapping the object at `objpath`. No armap / long-name table:
|
|
* w6l reads each member's ELF .symtab directly (obj.c elf_globals) and
|
|
* skips '/'-named members, so a package `.a` needs only the global magic,
|
|
* one 60-byte member header, and the `.o` bytes (newline-padded to even).
|
|
* Zeroed mtime/uid/gid + fixed mode + a fixed member name make the bytes
|
|
* a pure function of the `.o` content → cstage `.a` == wwstage `.a`
|
|
* (rule 10). The wwstage twin is archiveo (selfhost/cmd/ww/main.ww). */
|
|
static int
|
|
archive_o(const char *objpath, const char *apath)
|
|
{
|
|
FILE *in = fopen(objpath, "rb");
|
|
if (in == NULL) {
|
|
fprintf(stderr, "ww: cannot read %s\n", objpath);
|
|
return -1;
|
|
}
|
|
fseek(in, 0, SEEK_END);
|
|
long n = ftell(in);
|
|
fseek(in, 0, SEEK_SET);
|
|
if (n < 0) { fclose(in); return -1; }
|
|
unsigned char *buf = malloc((size_t)n);
|
|
if (buf == NULL) { fclose(in); return -1; }
|
|
if (fread(buf, 1, (size_t)n, in) != (size_t)n) {
|
|
free(buf); fclose(in); return -1;
|
|
}
|
|
fclose(in);
|
|
|
|
FILE *out = fopen(apath, "wb");
|
|
if (out == NULL) {
|
|
fprintf(stderr, "ww: cannot open %s\n", apath);
|
|
free(buf);
|
|
return -1;
|
|
}
|
|
fwrite("!<arch>\n", 1, 8, out);
|
|
/* ar(5) fixes each member header at 60 bytes; the offsets below
|
|
* address fields in that serialized header. */
|
|
char hdr[60];
|
|
memset(hdr, ' ', sizeof hdr);
|
|
memcpy(hdr + 0, "pkg.o/", 6); /* GNU short-name '/' terminator */
|
|
hdr[16] = '0'; /* mtime (zeroed → determinism) */
|
|
hdr[28] = '0'; /* uid (zeroed) */
|
|
hdr[34] = '0'; /* gid (zeroed) */
|
|
memcpy(hdr + 40, "100644", 6); /* mode (fixed octal) */
|
|
char sz[12];
|
|
int szn = snprintf(sz, sizeof sz, "%lu", (unsigned long)n);
|
|
memcpy(hdr + 48, sz, (size_t)szn);
|
|
hdr[58] = 0x60; /* member-header magic byte */
|
|
hdr[59] = 0x0a;
|
|
fwrite(hdr, 1, sizeof hdr, out);
|
|
fwrite(buf, 1, (size_t)n, out);
|
|
if (n & 1) fputc('\n', out); /* members are 2-byte aligned */
|
|
fclose(out);
|
|
free(buf);
|
|
return 0;
|
|
}
|
|
|
|
/* -w workdir freshness: a `-w DIR` workdir is a caller-owned persistent
|
|
* package-artifact tree that replaces the fresh `.sepwork` scratch.
|
|
* Staleness is pure content
|
|
* identity, never mtime: a package is reused only when its freshly
|
|
* composed unit byte-equals the committed unit AND the tool copies
|
|
* recorded in the dir byte-equal the live tools — every decision is
|
|
* reproducible by hand with cmp(1) against plain files. Artifacts commit
|
|
* via temp + rename with the unit renamed last, so a killed build can
|
|
* never leave a committed unit vouching for uncommitted artifacts. The
|
|
* caller serializes invocations per workdir (Make target = one workdir)
|
|
* and `make clean` reclaims the state; the wwstage twin is the
|
|
* fileequal/copyfileatomic/workdirstamp group in selfhost/cmd/ww/main.ww. */
|
|
|
|
/* `.s`/`.wwi` may be legitimately empty (an FFI-only package like rt
|
|
* emits no text), so committed presence is their freshness test; the
|
|
* rename-commit protocol owns integrity. `.o`/`.a` are never empty
|
|
* (ELF/ar headers), so a zero size there is always a torn write. */
|
|
static int
|
|
file_is_reg(const char *path)
|
|
{
|
|
struct stat st;
|
|
return stat(path, &st) == 0 && S_ISREG(st.st_mode);
|
|
}
|
|
|
|
static int
|
|
file_size_nonzero(const char *path)
|
|
{
|
|
struct stat st;
|
|
return stat(path, &st) == 0 && S_ISREG(st.st_mode) && st.st_size > 0;
|
|
}
|
|
|
|
/* Byte equality of two files; absence or IO error is inequality. */
|
|
static int
|
|
file_equal(const char *a, const char *b)
|
|
{
|
|
FILE *fa = fopen(a, "rb");
|
|
if (fa == NULL) return 0;
|
|
FILE *fb = fopen(b, "rb");
|
|
if (fb == NULL) { fclose(fa); return 0; }
|
|
static char ba[65536], bb[65536];
|
|
int eq = 1;
|
|
for (;;) {
|
|
size_t na = fread(ba, 1, sizeof ba, fa);
|
|
size_t nb = fread(bb, 1, sizeof bb, fb);
|
|
if (na != nb || memcmp(ba, bb, na) != 0) { eq = 0; break; }
|
|
if (na < sizeof ba) {
|
|
if (ferror(fa) || ferror(fb)) eq = 0;
|
|
break;
|
|
}
|
|
}
|
|
fclose(fa); fclose(fb);
|
|
return eq;
|
|
}
|
|
|
|
/* Replace dst with src's bytes via temp + rename, so a torn write can
|
|
* never masquerade as a committed tool copy. */
|
|
static int
|
|
copy_file_atomic(const char *src, const char *dst)
|
|
{
|
|
char tmp[1100];
|
|
snprintf(tmp, sizeof tmp, "%s.new", dst);
|
|
FILE *in = fopen(src, "rb");
|
|
if (in == NULL) return -1;
|
|
FILE *out = fopen(tmp, "wb");
|
|
if (out == NULL) { fclose(in); return -1; }
|
|
static char buf[65536];
|
|
size_t n;
|
|
while ((n = fread(buf, 1, sizeof buf, in)) > 0)
|
|
if (fwrite(buf, 1, n, out) != n) {
|
|
fclose(in); fclose(out); return -1;
|
|
}
|
|
int bad = ferror(in);
|
|
fclose(in);
|
|
if (fclose(out) != 0 || bad) return -1;
|
|
return rename(tmp, dst);
|
|
}
|
|
|
|
/* The stamp pins the non-content build inputs a unit compare cannot see:
|
|
* the -T/-S shape of the producer pass and the artifact protocol
|
|
* revision (bump "fmt" when the unit/archive/commit format changes). */
|
|
static void
|
|
workdir_stamp_text(char *buf, size_t bufsz, int is_test, int emit_asm)
|
|
{
|
|
snprintf(buf, bufsz, "ww workdir fmt 1 mode %s asm %d\n",
|
|
is_test ? "test" : "build", emit_asm);
|
|
}
|
|
|
|
/* build_one_sep — discover_deps, reverse_topo,
|
|
* the transitive producer loop (one `w6c -c -I` per package, dep-first,
|
|
* each DEP `.o` wrapped in its own deterministic `.a`), then a
|
|
* reverse-topo `w6l` of the root `.o` + dep `.a` set + libwwrt.a. Side
|
|
* files land in a cold `<stem>.sepwork` dir, or under the persistent
|
|
* `-w` workdir with content-identity package reuse. */
|
|
static int
|
|
build_one_sep_impl(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, int emit_asm, const char *workdir,
|
|
char *scratchout, size_t scratchoutsz, struct sepgraph **graphout)
|
|
{
|
|
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;
|
|
}
|
|
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;
|
|
int warm = workdir != NULL && workdir[0] != 0;
|
|
char scratch[1100];
|
|
if (warm) {
|
|
struct stat wst;
|
|
if (stat(workdir, &wst) != 0 || !S_ISDIR(wst.st_mode)) {
|
|
fprintf(stderr, "ww: workdir %s is not a directory\n",
|
|
workdir);
|
|
return 1;
|
|
}
|
|
/* The workdir is caller-owned and persistent: no acquisition,
|
|
* no refusal, and scratchout stays empty so the wrapper never
|
|
* cleans it. */
|
|
snprintf(scratch, sizeof scratch, "%s", workdir);
|
|
} else {
|
|
snprintf(scratch, sizeof scratch, "%s.sepwork", ostem);
|
|
if (mkdir(scratch, 0755) != 0) {
|
|
fprintf(stderr, "ww: cannot create scratch %s\n", scratch);
|
|
return 1;
|
|
}
|
|
/* Hand the scratch path back only after mkdir succeeds. The
|
|
* wrapper therefore never removes a pre-existing path that this
|
|
* build failed to acquire. */
|
|
if (scratchout) snprintf(scratchout, scratchoutsz, "%s", scratch);
|
|
}
|
|
int stale_all = 0, stampok = 0;
|
|
char toolc[1200] = {0}, toola[1200] = {0}, stampf[1200] = {0};
|
|
char stampwant[128];
|
|
if (warm) {
|
|
snprintf(toolc, sizeof toolc, "%s/.wwtool.w6c", scratch);
|
|
snprintf(toola, sizeof toola, "%s/.wwtool.w6a", scratch);
|
|
snprintf(stampf, sizeof stampf, "%s/.wwtool.stamp", scratch);
|
|
workdir_stamp_text(stampwant, sizeof stampwant, is_test, emit_asm);
|
|
char got[128] = {0};
|
|
FILE *sf = fopen(stampf, "rb");
|
|
if (sf) {
|
|
size_t rn = fread(got, 1, sizeof got - 1, sf);
|
|
got[rn] = 0;
|
|
fclose(sf);
|
|
}
|
|
stampok = strcmp(stampwant, got) == 0;
|
|
if (!stampok || !file_equal(toolc, c6)
|
|
|| (!emit_asm && !file_equal(toola, a6)))
|
|
stale_all = 1;
|
|
}
|
|
|
|
struct sepgraph *g = calloc(1, sizeof *g);
|
|
if (g == NULL) return 1;
|
|
if (graphout) *graphout = g;
|
|
int root = sep_find_or_add(g, "", src, entry_is_dir);
|
|
if (root < 0) return 1;
|
|
/* #79 (-T): lib/test is the synth main's `test.run` callee but @test
|
|
* files never `import test;`. Inject it as a direct dep of the root so
|
|
* sep_load_pkg pulls test + its transitive deps; the producer adds -T
|
|
* to the root and `test.run` links against test's `.a` — via the
|
|
* sep_scan_file dedup-guarded dep append. */
|
|
if (is_test) {
|
|
char tpath[1024];
|
|
int tdir = 0;
|
|
if (locate_import(srcdir, "test", tpath, sizeof tpath, &tdir)) {
|
|
int ti = sep_find_or_add(g, "test", tpath, tdir);
|
|
if (ti < 0) return 1;
|
|
int seen = 0;
|
|
for (int k = 0; k < g->pkg[root].ndeps; k++)
|
|
if (g->pkg[root].deps[k] == ti) { seen = 1; break; }
|
|
if (!seen && g->pkg[root].ndeps < SEP_MAXPKG)
|
|
g->pkg[root].deps[g->pkg[root].ndeps++] = ti;
|
|
}
|
|
}
|
|
if (sep_load_pkg(g, root, srcdir) < 0) 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); return 1;
|
|
}
|
|
free(stack);
|
|
|
|
for (int oi = 0; oi < norder; oi++) {
|
|
int pi = order[oi];
|
|
char unitf[1024], wwi[1024], asmf[1024], obj[1024], apath[1024];
|
|
char unitnew[1024], wwinew[1024], asmnew[1024], objnew[1024];
|
|
char anew[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);
|
|
sep_fname(g, pi, scratch, ".a", apath, sizeof apath);
|
|
sep_fname(g, pi, scratch, ".unit.new", unitnew, sizeof unitnew);
|
|
sep_fname(g, pi, scratch, ".wwi.new", wwinew, sizeof wwinew);
|
|
sep_fname(g, pi, scratch, ".s.new", asmnew, sizeof asmnew);
|
|
sep_fname(g, pi, scratch, ".o.new", objnew, sizeof objnew);
|
|
sep_fname(g, pi, scratch, ".a.new", anew, sizeof anew);
|
|
/* Warm mode compiles from staged `.new` paths and commits by
|
|
* rename; classic mode keeps its exact in-place paths. */
|
|
const char *cu = warm ? unitnew : unitf;
|
|
const char *cw = warm ? wwinew : wwi;
|
|
const char *cs = warm ? asmnew : asmf;
|
|
const char *co = warm ? objnew : obj;
|
|
const char *ca = warm ? anew : apath;
|
|
if (sep_compose_unit(g, pi, scratch, order, norder, srcdir,
|
|
cu) < 0) { free(order); return 1; }
|
|
if (warm && !stale_all && file_equal(unitnew, unitf)
|
|
&& file_is_reg(asmf)
|
|
&& (pi == root || file_is_reg(wwi))
|
|
&& (emit_asm || (file_size_nonzero(obj)
|
|
&& (pi == root || file_size_nonzero(apath))))) {
|
|
if (unlink(unitnew) != 0) {
|
|
fprintf(stderr, "ww: cannot remove %s\n",
|
|
unitnew);
|
|
free(order); return 1;
|
|
}
|
|
continue;
|
|
}
|
|
/* BUG-1 (#69): -I <wwi> is purely the root's UNUSED
|
|
* `.wwi` output path, but it triggers wwi_emit →
|
|
* check_exported_type on the root. A terminal binary's
|
|
* root legitimately has `export fn` over an unexported
|
|
* LOCAL type (the root is never imported), which the
|
|
* export-check rejects. Skip -I for the root; its `.wwi`
|
|
* is never consumed. */
|
|
if (pi == root)
|
|
/* #79: the root carries -T under `ww test`
|
|
* so w6c synthesizes the test main. Deps never
|
|
* get -T. */
|
|
snprintf(cmd, sizeof cmd, "%s %s-c -o %s %s",
|
|
c6, is_test ? "-T " : "", cs, cu);
|
|
else
|
|
snprintf(cmd, sizeof cmd, "%s -c -I %s -o %s %s",
|
|
c6, cw, cs, cu);
|
|
if (run(cmd) != 0) {
|
|
fprintf(stderr, "ww: w6c failed for %s\n",
|
|
g->pkg[pi].path[0] ? g->pkg[pi].path : "(root)");
|
|
free(order); return 1;
|
|
}
|
|
if (!emit_asm) {
|
|
snprintf(cmd, sizeof cmd, "%s -o %s %s", a6, co, cs);
|
|
if (run(cmd) != 0) {
|
|
fprintf(stderr, "ww: w6a failed for %s\n",
|
|
g->pkg[pi].path[0] ? g->pkg[pi].path : "(root)");
|
|
free(order); return 1;
|
|
}
|
|
}
|
|
/* wrap each DEP package's `.o` in its own deterministic `.a`
|
|
* (5a). The ROOT stays a positional `.o` (force-loaded — it's
|
|
* the build target, always fully linked), so `main` is defined
|
|
* before any archive is processed. The link consumes `.o`/`.a`,
|
|
* never `.wwi`. */
|
|
if (!emit_asm && pi != root) {
|
|
if (archive_o(co, ca) != 0) {
|
|
fprintf(stderr, "ww: archive failed for %s\n",
|
|
g->pkg[pi].path[0] ? g->pkg[pi].path : "(root)");
|
|
free(order); return 1;
|
|
}
|
|
}
|
|
/* Commit order: artifacts before the unit that vouches for
|
|
* them, unit strictly last. */
|
|
if (warm) {
|
|
if ((pi != root && rename(wwinew, wwi) != 0)
|
|
|| rename(asmnew, asmf) != 0
|
|
|| (!emit_asm && rename(objnew, obj) != 0)
|
|
|| (!emit_asm && pi != root
|
|
&& rename(anew, apath) != 0)
|
|
|| rename(unitnew, unitf) != 0) {
|
|
fprintf(stderr, "ww: cannot commit %s\n",
|
|
g->pkg[pi].path[0] ? g->pkg[pi].path : "(root)");
|
|
free(order); return 1;
|
|
}
|
|
}
|
|
}
|
|
/* Tool identity commits only after every package artifact it vouches
|
|
* for is itself committed; a killed pass leaves the old identity and
|
|
* forces a full recompile, never a false reuse. */
|
|
if (warm) {
|
|
if (!file_equal(toolc, c6)
|
|
&& copy_file_atomic(c6, toolc) != 0) {
|
|
fprintf(stderr, "ww: cannot record %s\n", toolc);
|
|
free(order); return 1;
|
|
}
|
|
if (!emit_asm && !file_equal(toola, a6)
|
|
&& copy_file_atomic(a6, toola) != 0) {
|
|
fprintf(stderr, "ww: cannot record %s\n", toola);
|
|
free(order); return 1;
|
|
}
|
|
if (!stampok) {
|
|
char stampnew[1300];
|
|
snprintf(stampnew, sizeof stampnew, "%s.new", stampf);
|
|
FILE *sf = fopen(stampnew, "wb");
|
|
int bad = sf == NULL || fputs(stampwant, sf) == EOF;
|
|
if (sf != NULL && fclose(sf) != 0) bad = 1;
|
|
if (bad || rename(stampnew, stampf) != 0) {
|
|
fprintf(stderr, "ww: cannot record %s\n",
|
|
stampf);
|
|
free(order); return 1;
|
|
}
|
|
}
|
|
}
|
|
if (emit_asm) { free(order); return 0; }
|
|
|
|
/* reverse-topo link: root `.o` first (order[norder-1], force-loaded),
|
|
* then transitive dep `.a` in reverse-topo order, then libwwrt.a —
|
|
* each archive selectively pulls only members satisfying a live
|
|
* undef. */
|
|
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 path[1024];
|
|
sep_fname(g, order[oi], scratch,
|
|
order[oi] == root ? ".o" : ".a", path, sizeof path);
|
|
size_t n = strlen(objs);
|
|
snprintf(objs + n, sizeof objs - n, "%s%s", n ? " " : "", path);
|
|
}
|
|
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);
|
|
if (rc != 0) { fprintf(stderr, "ww: w6l failed\n"); return 1; }
|
|
return 0;
|
|
}
|
|
|
|
/* build_one_sep — thin wrapper over build_one_sep_impl. `ww build` and an
|
|
* explicit `ww test -o` retain caller-visible `.sepwork` artifacts; their
|
|
* caller owns that exact tree. `ww run` and a no-output single-file test use
|
|
* internal scratch and remove it on success and failure. One cleanup site
|
|
* covers every internal-scratch impl return. The path is nonempty only after
|
|
* this invocation successfully created the exact `.sepwork` tree. */
|
|
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, int is_test, int emit_asm, int keepscratch,
|
|
const char *workdir)
|
|
{
|
|
char scratch[1100] = {0};
|
|
struct sepgraph *g = NULL;
|
|
int r = build_one_sep_impl(src, entry_is_dir, out, objstem,
|
|
extra_includes, extra_libs, extra_libdirs, is_test, emit_asm,
|
|
workdir, scratch, sizeof scratch, &g);
|
|
sep_graph_free(g);
|
|
if (!keepscratch && scratch[0]) {
|
|
size_t sl = strlen(scratch);
|
|
if (sl > 8 && strcmp(scratch + sl - 8, ".sepwork") == 0) {
|
|
int cleanrc = 1;
|
|
pid_t pid = fork();
|
|
if (pid == 0) {
|
|
execl("/bin/rm", "rm", "-rf", "--", scratch,
|
|
(char *)NULL);
|
|
_exit(127);
|
|
}
|
|
if (pid > 0) {
|
|
int status = 0;
|
|
if (waitpid(pid, &status, 0) == pid &&
|
|
WIFEXITED(status))
|
|
cleanrc = WEXITSTATUS(status);
|
|
}
|
|
if (cleanrc != 0) {
|
|
fprintf(stderr, "ww: cannot remove scratch %s\n", scratch);
|
|
if (r == 0) r = 1;
|
|
}
|
|
}
|
|
}
|
|
return r;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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';
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
/* 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,
|
|
char *workdir, size_t workdirsz,
|
|
const char **src_out, int *emit_asm_out)
|
|
{
|
|
*src_out = NULL;
|
|
if (emit_asm_out) *emit_asm_out = 0;
|
|
int i = 0;
|
|
for (; i < argc; i++) {
|
|
if (strcmp(argv[i], "-S") == 0) {
|
|
if (emit_asm_out == NULL) {
|
|
fprintf(stderr, "ww %s: unknown flag\n", cmd);
|
|
return -1;
|
|
}
|
|
*emit_asm_out = 1;
|
|
} else if (strcmp(argv[i], "-w") == 0) {
|
|
if (workdir == NULL) {
|
|
fprintf(stderr, "ww %s: unknown flag\n", cmd);
|
|
return -1;
|
|
}
|
|
if (i + 1 >= argc) {
|
|
fprintf(stderr,
|
|
"ww %s: -w needs an argument\n", cmd);
|
|
return -1;
|
|
}
|
|
snprintf(workdir, workdirsz, "%s", argv[++i]);
|
|
} else if (strncmp(argv[i], "-w", 2) == 0 && argv[i][2]) {
|
|
if (workdir == NULL) {
|
|
fprintf(stderr, "ww %s: unknown flag\n", cmd);
|
|
return -1;
|
|
}
|
|
snprintf(workdir, workdirsz, "%s", argv[i] + 2);
|
|
} 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 (argv[i][0] == '-') {
|
|
fprintf(stderr, "ww %s: unknown flag\n", cmd);
|
|
return -1;
|
|
} 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};
|
|
char workdir[1024] = {0};
|
|
int emit_asm = 0;
|
|
if (parse_build_flags("build", argc, argv, incs, sizeof incs,
|
|
libdirs, sizeof libdirs, libs, sizeof libs,
|
|
outflag, sizeof outflag, workdir, sizeof workdir,
|
|
&src, &emit_asm) < 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 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);
|
|
}
|
|
return build_one_sep(resolved, is_dir, out, objstem, incs, libs,
|
|
libdirs, 0, emit_asm, 1, workdir);
|
|
}
|
|
|
|
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, NULL, 0, &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 tmpdir[1024], tmp[1024];
|
|
snprintf(tmpdir, sizeof tmpdir, "/tmp/ww_run_%d", getpid());
|
|
if (mkdir(tmpdir, 0700) != 0) {
|
|
fprintf(stderr, "ww: cannot create temporary directory %s\n", tmpdir);
|
|
return 1;
|
|
}
|
|
snprintf(tmp, sizeof tmp, "%s/main", tmpdir);
|
|
/* The freshly acquired directory owns both the executable and the
|
|
* adjacent main.sepwork tree. Nothing outside it is adopted or removed. */
|
|
if (build_one_sep(resolved, is_dir, tmp, tmp, incs, libs, libdirs, 0, 0,
|
|
0, NULL) != 0) {
|
|
if (unlink(tmp) != 0 && errno != ENOENT)
|
|
fputs("ww: cannot remove temporary output\n", stderr);
|
|
if (rmdir(tmpdir) != 0)
|
|
fputs("ww: cannot remove temporary directory\n", stderr);
|
|
return 1;
|
|
}
|
|
pid_t pid = fork();
|
|
if (pid < 0) {
|
|
perror("ww: fork");
|
|
if (unlink(tmp) != 0 && errno != ENOENT)
|
|
fputs("ww: cannot remove temporary output\n", stderr);
|
|
if (rmdir(tmpdir) != 0)
|
|
fputs("ww: cannot remove temporary directory\n", stderr);
|
|
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;
|
|
pid_t got;
|
|
do { got = waitpid(pid, &status, 0); } while (got < 0 && errno == EINTR);
|
|
int rc = got == pid && WIFEXITED(status) ? WEXITSTATUS(status) : 1;
|
|
if (got != pid) perror("ww: waitpid");
|
|
if (unlink(tmp) != 0 && errno != ENOENT) {
|
|
fputs("ww: cannot remove temporary output\n", stderr);
|
|
if (rc == 0) rc = 1;
|
|
}
|
|
if (rmdir(tmpdir) != 0) {
|
|
fputs("ww: cannot remove temporary directory\n", stderr);
|
|
if (rc == 0) rc = 1;
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
static int
|
|
do_test(int argc, char **argv)
|
|
{
|
|
const char *src = NULL;
|
|
char incs[2048] = {0};
|
|
/* -c (Go's `go test -c`) builds the test binary without running it.
|
|
* -S + -o <stem> stops after the lib/test-inclusive package `.s`
|
|
* outputs are emitted. Both routes use build_one_sep's is_test bundle
|
|
* and T3 objstem redirect.
|
|
* -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;
|
|
int emit_asm = 0;
|
|
char outstem[1024] = {0};
|
|
char workdir[1024] = {0};
|
|
int packageopts = 0;
|
|
int afterdash = 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 (afterdash) continue;
|
|
if (argv[i][0] == '-') {
|
|
if (strcmp(argv[i], "--") == 0) {
|
|
packageopts = 1;
|
|
afterdash = 1;
|
|
continue;
|
|
}
|
|
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], "-S") == 0) {
|
|
emit_asm = 1;
|
|
} else if (strcmp(argv[i], "-list") == 0) {
|
|
packageopts = 1;
|
|
} else if (strcmp(argv[i], "-j") == 0 ||
|
|
strcmp(argv[i], "-run") == 0 ||
|
|
strcmp(argv[i], "-filter") == 0) {
|
|
if (i + 1 >= argc) {
|
|
fprintf(stderr, "ww test: %s needs an argument\n",
|
|
argv[i]);
|
|
return 2;
|
|
}
|
|
packageopts = 1;
|
|
i++;
|
|
} else if (strncmp(argv[i], "-timeout-ms=", 12) == 0 &&
|
|
argv[i][12] != '\0') {
|
|
packageopts = 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 if (strcmp(argv[i], "-w") == 0) {
|
|
if (i + 1 >= argc) {
|
|
fprintf(stderr,
|
|
"ww test: -w needs an argument\n");
|
|
return 2;
|
|
}
|
|
snprintf(workdir, sizeof workdir, "%s", argv[++i]);
|
|
} else if (argv[i][1] == 'w' && argv[i][2]) {
|
|
snprintf(workdir, sizeof workdir, "%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 : ".";
|
|
if (emit_asm && !outstem[0]) {
|
|
fprintf(stderr, "ww test: -S needs -o\n");
|
|
return 2;
|
|
}
|
|
/* Go's ./... form: a trailing "..." element is a package-tree
|
|
* request for the coordinator, never a literal path — recognized
|
|
* before stat, with the directory-mode rejects. */
|
|
size_t tlen = strlen(target);
|
|
if (strcmp(target, "...") == 0 ||
|
|
(tlen >= 4 && strcmp(target + tlen - 4, "/...") == 0)) {
|
|
if (emit_asm) {
|
|
fprintf(stderr,
|
|
"ww test: -S needs a single test file\n");
|
|
return 2;
|
|
}
|
|
/* -c -o forwards: the coordinator names the single
|
|
* package's artifact and rejects a multi-package fan-out. */
|
|
if (outstem[0] && !compileonly) {
|
|
fprintf(stderr,
|
|
"ww test: -o needs -c for a package target\n");
|
|
return 2;
|
|
}
|
|
if (pattern) {
|
|
fprintf(stderr,
|
|
"ww test: pattern needs a single test file\n");
|
|
return 2;
|
|
}
|
|
/* -w forwards: the coordinator keys one persistent driver
|
|
* workdir per package group under the given root. */
|
|
return exec_package_tests(argc, argv, src, NULL, 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];
|
|
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;
|
|
}
|
|
if (is_dir) {
|
|
if (emit_asm) {
|
|
fprintf(stderr,
|
|
"ww test: -S needs a single test file\n");
|
|
return 2;
|
|
}
|
|
if (outstem[0] && !compileonly) {
|
|
fprintf(stderr,
|
|
"ww test: -o needs -c for a package target\n");
|
|
return 2;
|
|
}
|
|
if (pattern) {
|
|
fprintf(stderr,
|
|
"ww test: pattern needs a single test file\n");
|
|
return 2;
|
|
}
|
|
return exec_package_tests(argc, argv, src, resolved, 0);
|
|
}
|
|
if (packageopts) {
|
|
fprintf(stderr,
|
|
"ww test: package options need a directory\n");
|
|
return 2;
|
|
}
|
|
char tmpdir[1024] = {0}, tmp[1024];
|
|
const char *outp;
|
|
int owntmp = !outstem[0] && !workdir[0];
|
|
if (outstem[0]) outp = outstem;
|
|
else if (workdir[0]) {
|
|
/* The workdir owns the persistent test binary the same
|
|
* way it owns the package artifacts. */
|
|
snprintf(tmp, sizeof tmp, "%s/main", workdir);
|
|
outp = tmp;
|
|
} else {
|
|
snprintf(tmpdir, sizeof tmpdir, "/tmp/ww_test_%d", getpid());
|
|
if (mkdir(tmpdir, 0700) != 0) {
|
|
fprintf(stderr, "ww: cannot create temporary directory %s\n",
|
|
tmpdir);
|
|
return 1;
|
|
}
|
|
snprintf(tmp, sizeof tmp, "%s/main", tmpdir);
|
|
outp = tmp;
|
|
}
|
|
/* No-o redirects internal scratch to /tmp rather than beside the
|
|
* source. An explicit -o names the caller-owned artifact stem. */
|
|
int br = build_one_sep(resolved, is_dir, outp,
|
|
outstem[0] ? outstem : tmp, incs, "", "", 1,
|
|
emit_asm, outstem[0] ? 1 : 0, workdir);
|
|
if (br != 0) {
|
|
if (owntmp && unlink(outp) != 0 && errno != ENOENT)
|
|
fputs("ww: cannot remove temporary output\n", stderr);
|
|
if (owntmp && rmdir(tmpdir) != 0)
|
|
fputs("ww: cannot remove temporary directory\n", stderr);
|
|
return 1;
|
|
}
|
|
if (compileonly || emit_asm) {
|
|
int cleanfail = 0;
|
|
if (owntmp && unlink(outp) != 0 && errno != ENOENT) {
|
|
fputs("ww: cannot remove temporary output\n", stderr);
|
|
cleanfail = 1;
|
|
}
|
|
if (owntmp && rmdir(tmpdir) != 0) {
|
|
fputs("ww: cannot remove temporary directory\n", stderr);
|
|
cleanfail = 1;
|
|
}
|
|
return cleanfail ? 1 : 0;
|
|
}
|
|
int rc = run_test_bin(outp, pattern);
|
|
if (owntmp && unlink(outp) != 0 && errno != ENOENT) {
|
|
fputs("ww: cannot remove temporary output\n", stderr);
|
|
if (rc == 0) rc = 1;
|
|
}
|
|
if (owntmp && rmdir(tmpdir) != 0) {
|
|
fputs("ww: cannot remove temporary directory\n", stderr);
|
|
if (rc == 0) rc = 1;
|
|
}
|
|
return rc;
|
|
}
|
|
if (S_ISREG(st.st_mode)) {
|
|
if (packageopts) {
|
|
fprintf(stderr,
|
|
"ww test: package options need a directory\n");
|
|
return 2;
|
|
}
|
|
char tmpdir[1024] = {0}, tmp[1024];
|
|
const char *outp;
|
|
int owntmp = !outstem[0] && !workdir[0];
|
|
if (outstem[0]) outp = outstem;
|
|
else if (workdir[0]) {
|
|
snprintf(tmp, sizeof tmp, "%s/main", workdir);
|
|
outp = tmp;
|
|
} else {
|
|
snprintf(tmpdir, sizeof tmpdir, "/tmp/ww_test_%d", getpid());
|
|
if (mkdir(tmpdir, 0700) != 0) {
|
|
fprintf(stderr, "ww: cannot create temporary directory %s\n",
|
|
tmpdir);
|
|
return 1;
|
|
}
|
|
snprintf(tmp, sizeof tmp, "%s/main", tmpdir);
|
|
outp = tmp;
|
|
}
|
|
/* See module-mode note: no-o scratch is redirected to /tmp. */
|
|
int br = build_one_sep(target, 0, outp, outstem[0] ? outstem : tmp,
|
|
incs, "", "", 1, emit_asm, outstem[0] ? 1 : 0, workdir);
|
|
if (br != 0) {
|
|
if (owntmp && unlink(outp) != 0 && errno != ENOENT)
|
|
fputs("ww: cannot remove temporary output\n", stderr);
|
|
if (owntmp && rmdir(tmpdir) != 0)
|
|
fputs("ww: cannot remove temporary directory\n", stderr);
|
|
return 1;
|
|
}
|
|
if (compileonly || emit_asm) {
|
|
int cleanfail = 0;
|
|
if (owntmp && unlink(outp) != 0 && errno != ENOENT) {
|
|
fputs("ww: cannot remove temporary output\n", stderr);
|
|
cleanfail = 1;
|
|
}
|
|
if (owntmp && rmdir(tmpdir) != 0) {
|
|
fputs("ww: cannot remove temporary directory\n", stderr);
|
|
cleanfail = 1;
|
|
}
|
|
return cleanfail ? 1 : 0;
|
|
}
|
|
int rc = run_test_bin(outp, pattern);
|
|
if (owntmp && unlink(outp) != 0 && errno != ENOENT) {
|
|
fputs("ww: cannot remove temporary output\n", stderr);
|
|
if (rc == 0) rc = 1;
|
|
}
|
|
if (owntmp && rmdir(tmpdir) != 0) {
|
|
fputs("ww: cannot remove temporary directory\n", stderr);
|
|
if (rc == 0) rc = 1;
|
|
}
|
|
return rc;
|
|
}
|
|
if (!S_ISDIR(st.st_mode)) {
|
|
fprintf(stderr, "ww test: %s is neither file nor directory\n", target);
|
|
return 1;
|
|
}
|
|
if (emit_asm) {
|
|
fprintf(stderr, "ww test: -S needs a single test file\n");
|
|
return 2;
|
|
}
|
|
if (outstem[0] && !compileonly) {
|
|
fprintf(stderr, "ww test: -o needs -c for a package target\n");
|
|
return 2;
|
|
}
|
|
/* The second bare positional remains the legacy single-file filter form;
|
|
* package filtering uses explicit -run/-filter options. */
|
|
if (pattern) {
|
|
fprintf(stderr, "ww test: pattern needs a single test file\n");
|
|
return 2;
|
|
}
|
|
return exec_package_tests(argc, argv, src, NULL, src == NULL);
|
|
}
|
|
|
|
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);
|
|
fprintf(stderr, "ww: unknown subcommand: %s\n", cmd);
|
|
fputs(usage, stderr);
|
|
return 2;
|
|
}
|