ref: beab0276a94c684f938ae5ea3d2c29c3dc331386
dir: /mbld/syssel.myr/
use std use bio use "opts" use "types" pkg bld = type syssel(@a) = struct file : byte[:] line : int targ : byte[:] _match : std.htab(byte[:], (int, int))# _best : std.htab(byte[:], @a)# ;; generic mksyssel : (b : build#, f : byte[:], line : int, targ : byte[:] -> syssel(@a)#) generic sysseladd : (b : build#, syssel : syssel(byte[:])#, file : byte[:] -> void) generic sysseladdlist : (b : build#, syssel : syssel(@a)#, base : byte[:], attrs : byte[:][:], val : @a -> void) generic sysselfin : (b : build#, syssel : syssel(@a)# -> @a[:]) const addsysattrs : (sa : build#, tags : byte[:][:] -> void) ;; generic mksyssel = {b, file, line, targ var syssel syssel = std.mk([ .file = file, .line = line, .targ = targ, ._match = std.mkht(), ._best = std.mkht(), ]) -> syssel } generic sysseladd = {b, syssel, f var basename, attrs var attrlist match std.strfind(f, "+") | `std.Some i: basename = f[:i] match std.strrfind(f[i+1:], ".") | `std.Some j: attrs = f[i+1:][:j] | `std.None: std.fatal("unrecognized type for file {}\n", f) ;; | `std.None: match std.strrfind(f, ".") | `std.None: std.fatal("unrecognized type for file {}\n", f) | `std.Some i: basename = f[:i] attrs = "" ;; ;; attrlist = std.strsplit(attrs, "-") sysseladdlist(b, syssel, basename, attrlist, f) std.slfree(attrlist) } generic sysseladdlist = {b, syssel, base, attrs, val var nmatch, vscore, s nmatch = 0 vscore = 0 for a : attrs s = tagscore(b, a) if s < 0 nmatch = -1 break ;; vscore += s nmatch++ ;; match std.htgetv(syssel._match, base, (-1, -1)) | (curbest, curscore): if curbest < nmatch || (nmatch >= 0 && curbest == nmatch && curscore < vscore) std.htput(syssel._match, base, (nmatch, vscore)) std.htput(syssel._best, base, val) ;; ;; } const tagscore = {b, tag var n, v match std.strfind(tag, ":") | `std.Some i: n = tag[:i] v = parseversion(tag[i+1:]) | `std.None: n = tag v = (-1, -1, -1) ;; match std.htget(b.tags, n) | `std.None: -> -1 | `std.Some cv: -> versionscore(cv, v) ;; } const versionscore = {have, want var s s = 0 match (have, want) | ((a0, a1, a2), (v0, v1, v2)): if a0 == -1 && a1 == -1 && a2 == -1 -> s elif v0 == -1 && v1 == -1 && v2 == -1 -> s else s = 1_000_000 * (a0 - v0) if s == 0 s += 1_000 * (a1 - v1) ;; if s == 0 s += (a2 - v2) ;; if s >= 0 s = 100_000_000 - s ;; -> s ;; ;; } generic sysselfin = {b, syssel var keys, nmatch, ret keys = std.htkeys(syssel._match) ret = [][:] for k : keys (nmatch, _) = std.htgetv(syssel._match, k, (-1, -1)) if nmatch == -1 std.fatal("{}:{}: target {}, no applicable file for '{}'\n", \ syssel.file, syssel.line, syssel.targ, k) ;; std.slpush(&ret, std.get(std.htget(syssel._best, k))) ;; std.htfree(syssel._match) std.htfree(syssel._best) -> ret } const addsysattrs = {b, tags if opt_alltags.len > 0 for t : opt_alltags tag(b, t) ;; else std.htput(b.tags, opt_sys, opt_sysvers) match opt_sys | "freebsd": tag(b, "posixy") | "netbsd": tag(b, "posixy") | "openbsd": tag(b, "posixy") | "osx": tag(b, "posixy") | "linux": tag(b, "posixy") | "plan9": | unknown: std.fatal("unknown system \"{}\"\n", unknown) ;; match opt_arch | "x64": tag(b, "x64") if supports(CpuidSSE2) tag(b, "sse2") ;; if supports(CpuidSSE4) tag(b, "sse4") ;; if supports(CpuidFMA) tag(b, "fma") ;; | unknown: std.fatal("unknown architecture {}\n", unknown) ;; for t : tags tag(b, t) ;; loadtagfile(b, "bld.tags") ;; } const supports = {feat match (opt_sys, opt_cpufeatures & feat) /* The version of gas that's shipped with openbsd is too old. */ | ("openbsd", CpuidSSE4): -> false | ("openbsd", CpuidFMA): -> false | ("freebsd", CpuidSSE4): -> false | ("freebsd", CpuidFMA): -> false | ("netbsd", CpuidSSE4): -> false | ("netbsd", CpuidFMA): -> false | (_, f): -> f == feat ;; } const loadtagfile = {b, tagfile var deptags, tagmap, changed var tf, lnum if !std.fexists(tagfile) -> void ;; match bio.open(tagfile, bio.Rd) | `std.Ok f: tf = f | `std.Err e: std.fatal("could not open tagfile: {}\n", e) ;; lnum = 0 tagmap = std.mkht() /* * Parse the list of tags. Each line is in the form of * * tag list ":" tag list * * The left hand side of the tag list describes the tags * that get added if the tags on the right hand side all * are present. */ for ln : bio.byline(tf) lnum++ match std.strfind(ln, ":") | `std.None: for t : std.bytok(ln) tag(b, t) ;; continue | `std.Some idx: if std.strstrip(ln[:idx]).len == 0 std.fatal("{}:{}: missing tags before ':'\n", tagfile, lnum) ;; deptags = [][:] for d : std.bytok(ln[idx+1:]) std.slpush(&deptags, std.sldup(d)) ;; for t : std.bytok(ln[:idx]) match std.htget(tagmap, t) | `std.Some v: std.slpush(&v, deptags) std.htput(tagmap, t, v) | `std.None: std.htput(tagmap, std.sldup(t), std.sldup([deptags][:])) ;; ;; ;; ;; bio.close(tf) /* * Because tags may depend on other tags, we need to iterate * here until the set of tags reach a fixed point. Each tag * that we insert may potentially free other tags to be inserted, * so either we make progress on the finite set of tags, or we * don't make a change and break out of the loop. */ changed = true while changed changed = false for (k, vss) : std.byhtkeyvals(tagmap) if std.hthas(b.tags, k) continue ;; for vs : vss for v : vs if tagscore(b, v) == -1 goto next ;; ;; tag(b, k) changed = true :next ;; ;; ;; for (k, vss) : std.byhtkeyvals(tagmap) std.slfree(k) for vs : vss for v : vs std.slfree(v) ;; std.slfree(vs) ;; std.slfree(vss) ;; } const tag = {b, t var v match std.strfind(t, ":") | `std.None: std.htput(b.tags, std.sldup(t), (-1, -1, -1)) | `std.Some idx: v = parseversion(t[idx+1:]) std.htput(b.tags, std.sldup(t[:idx]), v) ;; }