ref: 3400b0428b9147012553c6f2280147d8dc99bbf1
dir: /mbld/build.myr/
use std use "config.use" use "deps.use" use "opts.use" use "parse.use" use "types.use" use "util.use" pkg bld = const buildall : (b : build# -> bool) const genall : (b : build# -> bool) const buildtarg : (b : build#, target : byte[:] -> bool) const buildbin : (b : build#, bt : myrtarg#, addsrc : bool -> void) const buildlib : (b : build#, lt : myrtarg# -> void) ;; const buildall = {b for tn in b.all if std.hthas(b.built, tn) continue ;; std.htput(b.built, tn, true) match gettarg(b.targs, tn) | `Bin bt: if !bt.istest buildbin(b, bt, false) ;; | `Lib lt: buildlib(b, lt) | `Gen gt: genfiles(b, gt) | `Man mt: /* nothing needed */ | `Cmd ct: /* these are for manual commands or tests */ ;; ;; -> true } const buildtarg = {b, targ var depset depset = std.mkht(std.strhash, std.streq) addeps(b, targ, depset) for tn in b.all if std.hthas(b.built, tn) || !std.hthas(depset, tn) continue ;; if std.sleq(tn, targ) break ;; std.htput(b.built, tn, true) match gettarg(b.targs, tn) | `Bin bt: if !bt.istest buildbin(b, bt, false) ;; | `Lib lt: buildlib(b, lt) | `Gen gt: genfiles(b, gt) | `Man mt: /* nothing needed */ | `Cmd ct: /* these are for manual commands or tests */ ;; ;; build(b, targ) std.htfree(depset) -> true } const addeps = {b, targ, depset if std.hthas(depset, targ) -> ;; std.htput(depset, targ, true) match gettarg(b.targs, targ) | `Bin bt: for (dir, lib, targname) in bt.libdeps addeps(b, targname, depset) ;; | `Lib lt: for (dir, lib, targname) in lt.libdeps addeps(b, targname, depset) ;; | _: ;; } const genall = {b for tn in b.all match gettarg(b.targs, tn) | `Gen gt: runin(b, gt.cmd, gt.dir) | _: /* skip */ ;; ;; /* genfiles will exit if the build fails; always return true */ -> true } const build = {b, targ match std.htget(b.targs, targ) | `std.Some (`Bin bt): buildbin(b, bt, false) | `std.Some (`Lib lt): buildlib(b, lt) | `std.Some (`Gen gt): runin(b, gt.cmd, gt.dir) | `std.Some (`Cmd ct): runin(b, ct.cmd, ct.dir) | `std.Some (`Man mt): /* nothing needed */ | `std.None: std.fatal("invalid target {}\n", targ) ;; -> true } const runin = {b, cmd, dir setdir(b, dir) run(cmd) } const buildbin = {b, targ, addsrc var dg, src setdir(b, targ.dir) addincludes(b, targ) std.put("{}...\n", targ.name) dg = myrdeps(b, targ, false, addsrc) if !std.hthas(dg.deps, targ.name) std.fatal("no input files for {}\n", targ.name) ;; if builddep(b, dg, targ.name, targ.incpath) || !freshlibs(targ, dg.libs) src = std.htkeys(dg.sources) linkbin(dg, targ.name, src, targ.ldscript, targ.runtime, targ.incpath, targ.libdeps) std.slfree(src) ;; } const buildlib = {b, targ var archive var u, l var dg var lib, src setdir(b, targ.dir) addincludes(b, targ) lib = targ.name std.put("lib{}.a...\n", lib) archive = std.fmt("lib{}.a", lib) dg = myrdeps(b, targ, false, false) if !std.hthas(dg.deps, lib) std.fatal("no target declared for {}\n", lib) ;; u = builddep(b, dg, targ.name, targ.incpath) l = builddep(b, dg, archive, targ.incpath) if u || l || !freshlibs(targ, dg.libs) src = std.htkeys(dg.sources) mergeuse(dg, lib, src, targ.incpath) archivelib(dg, lib, src, targ.incpath) std.slfree(src) ;; std.slfree(archive) } const genfiles = {b, gt setdir(b, gt.dir) for out in gt.out if !std.fexists(out) || !allfresh(gt.deps, out) run(gt.cmd) break ;; ;; } const addincludes = {b, targ for (inc, lib, subtarg) in targ.libdeps if !hasinc(targ.incpath, inc) targ.incpath = std.slput(targ.incpath, 0, inc) ;; ;; } const hasinc = {path, t for e in path if std.sleq(e, t) -> true ;; ;; -> false } const builddep = {b, dg, out, incs var stale stale = false /* short circuit walking the dep tree if we've already built this. */ if std.htgetv(dg.updated, out, false) -> false ;; match std.htget(dg.deps, out) | `std.Some deps: for d in deps if builddep(b, dg, d, incs) stale = true ;; match std.htget(b.gensrc, d) | `std.Some gt: if !std.fexists(d) || !allfresh(gt.deps, d) run(gt.cmd) ;; | `std.None: if !std.fexists(d) std.fatal("no input file {}\n", d) ;; ;; if !isfresh(d, out) stale = true ;; ;; | `std.None: ;; match std.htget(dg.input, out) | `std.Some src: if stale compile(dg, src, incs) ;; std.htput(dg.updated, out, true) | `std.None: ;; -> stale } const compile = {dg, src, incs var o var cmd cmd = [][:] if std.hassuffix(src, ".myr") cmd = std.slpush(cmd, opt_mc) for inc in incs cmd = std.slpush(cmd, "-I") cmd = std.slpush(cmd, inc) ;; if opt_genasm cmd = std.slpush(cmd, "-S") ;; cmd = std.slpush(cmd, src) run(cmd) std.slfree(cmd) elif std.hassuffix(src, ".s") o = srcswapsuffix(src, config.Objsuffix) for c in config.Ascmd cmd = std.slpush(cmd, c) ;; cmd = std.slpush(cmd,"-o") cmd = std.slpush(cmd, o) cmd = std.slpush(cmd, src) run(cmd) std.slfree(o) elif std.hassuffix(src, ".glue.c") o = srcswapsuffix(src, config.Objsuffix) cmd = std.slpush(cmd, "cc") cmd = std.slpush(cmd,"-c") cmd = std.slpush(cmd,"-o") cmd = std.slpush(cmd, o) cmd = std.slpush(cmd, src) for flg in std.htgetv(dg.cflags, src, [][:]) cmd = std.slpush(cmd, flg) ;; run(cmd) else std.fatal("Unknown file type for {}\n", src) ;; } const linkbin = {dg, bin, srcfiles, ldscript, rt, incs, extlibs var cmd cmd = [][:] /* ld -o bin */ for c in config.Linkcmd cmd = std.slpush(cmd, std.sldup(c)) ;; cmd = std.slpush(cmd, std.sldup(bin)) /* [-T script] */ if ldscript.len > 0 cmd = std.slpush(cmd, std.sldup("-T")) cmd = std.slpush(cmd, std.sldup(ldscript)) ;; if rt.len != 0 cmd = std.slpush(cmd, std.sldup(rt)) else cmd = std.slpush(cmd, std.sldup(opt_runtime)) ;; /* input.o list.o... */ for f in srcfiles cmd = std.slpush(cmd, srcswapsuffix(f, config.Objsuffix)) ;; /* -L path -l lib... */ cmd = addlibs(cmd, dg.libs, incs) /* add extra libs */ for l in dg.extlibs cmd = std.slpush(cmd, std.fmt("-l{}", l)) ;; /* special for OSX: it warns if we don't add this */ if std.sleq(opt_sys, "osx") cmd = std.slpush(cmd, std.sldup("-macosx_version_min")) cmd = std.slpush(cmd, std.sldup("10.6")) elif std.sleq(opt_sys, "linux") && dg.dynamic cmd = std.slpush(cmd, std.sldup("-dynamic-linker")) cmd = std.slpush(cmd, std.sldup("/lib64/ld-linux-x86-64.so.2")) ;; run(cmd) strlistfree(cmd) } const archivelib = {dg, lib, files, incs var cmd var obj cmd = [][:] for c in config.Arcmd cmd = std.slpush(cmd, std.sldup(c)) ;; cmd = std.slpush(cmd, std.fmt("lib{}.a", lib)) for f in files obj = srcswapsuffix(f, config.Objsuffix) cmd = std.slpush(cmd, obj) ;; run(cmd) strlistfree(cmd) } const mergeuse = {dg, lib, files, incs var cmd cmd = [][:] cmd = std.slpush(cmd, std.sldup(opt_muse)) cmd = std.slpush(cmd, std.sldup("-o")) cmd = std.slpush(cmd, std.sldup(lib)) for f in files if std.hassuffix(f, ".myr") cmd = std.slpush(cmd, srcswapsuffix(f, ".use")) elif !std.hassuffix(f, ".s") && !std.hassuffix(f, ".glue.c") std.fatal("unknown file type for {}\n", f) ;; ;; for l in dg.extlibs cmd = std.slpush(cmd, std.fmt("-l{}", l)) ;; run(cmd) strlistfree(cmd) } const addlibs = {cmd, libgraph, incs var looped : std.htab(byte[:], bool)# var marked : std.htab(byte[:], bool)# var libs var head /* -L incpath... */ if !config.Directlib for inc in incs cmd = std.slpush(cmd, std.fmt("-L{}", inc)) ;; ;; libs = std.htkeys(libgraph) looped = std.mkht(std.strhash, std.streq) marked = std.mkht(std.strhash, std.streq) head = cmd.len for lib in libs cmd = visit(cmd, head, libgraph, lib, looped, marked, incs) ;; -> cmd } const visit = {cmd, head, g, lib, looped, marked, incs if std.hthas(looped, lib) std.fatal("cycle in library graph involving \"{}\"\n", lib) elif std.hthas(marked, lib) -> cmd ;; std.htput(looped, lib, true) for dep in std.htgetv(g, lib, [][:]) cmd = visit(cmd, head, g, dep, looped, marked, incs) ;; std.htdel(looped, lib) std.htput(marked, lib, true) -> putlib(cmd, head, lib, incs) } const putlib = {cmd, head, lib, incs var sep if !config.Directlib -> std.slput(cmd, head, std.fmt("-l{}", lib)) else match findlib(lib, incs) | `std.None: std.put("in path: ") sep = "" for inc in incs std.put("\t{}{}\n", sep, inc) sep = ", " ;; std.fatal("could not find library lib{}.a.\n", lib) | `std.Some p: -> std.slput(cmd, head, p) ;; ;; } const findlib = {lib, incs var buf : byte[512] var sl, p sl = std.bfmt(buf[:], "lib{}.a", lib) for i in incs p = std.pathcat(i, sl) if std.fexists(p) -> `std.Some p ;; std.slfree(p) ;; -> `std.None } const freshlibs = {targ, libgraph var libs libs = std.htkeys(libgraph) for l in libs match findlib(l, targ.incpath) | `std.Some lib: if !isfresh(lib, targ.name) std.slfree(lib) -> false ;; std.slfree(lib) | `std.None: std.fput(1, "{}: could not find library lib{}.a\n", targ.name, l) std.fput(1, "searched:\n") for inc in targ.incpath std.fput(1, "\t{}\n", inc) ;; std.exit(1) ;; ;; std.slfree(libs) -> true } const allfresh = {deps, out for d in deps if !isfresh(d, out) -> false ;; ;; -> true } const isfresh = {src, dst var srcmt, dstmt /* OSX only has single second resolution on modification times. Since most builds happen within one second of each other, if we treat equal times as outdated, we do a lot of spurious rebuilding. So, we treat times where both secs and nsecs are equal as up to date. */ match std.fmtime(src) | `std.Ok mt: srcmt = mt | `std.Fail e: std.fatal("could not stat {}: {}\n", src, e) ;; match std.fmtime(dst) | `std.Ok mt: dstmt = mt | `std.Fail e: -> false ;; -> srcmt <= dstmt }