summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--DEPRECATED5
-rw-r--r--Makefile20
-rw-r--r--bldfile22
-rw-r--r--build.myr412
-rw-r--r--clean.myr89
-rw-r--r--config+plan9-x64.myr11
-rwxr-xr-xconfigure65
-rw-r--r--deps.myr308
-rw-r--r--fsel.myr105
-rw-r--r--install.myr92
-rw-r--r--main.myr115
-rw-r--r--mbld.181
-rw-r--r--mk/myr.mk42
-rw-r--r--opts.myr85
-rw-r--r--parse.myr539
-rw-r--r--subdir.myr23
-rw-r--r--test.myr150
-rw-r--r--types.myr59
-rw-r--r--util.myr123
19 files changed, 5 insertions, 2341 deletions
diff --git a/DEPRECATED b/DEPRECATED
new file mode 100644
index 0000000..837503b
--- /dev/null
+++ b/DEPRECATED
@@ -0,0 +1,5 @@
+This has been merged into mc/.
+
+See http://git.eigenstate.org/git/ori/mc.git
+
+
diff --git a/Makefile b/Makefile
deleted file mode 100644
index 9e1ea95..0000000
--- a/Makefile
+++ /dev/null
@@ -1,20 +0,0 @@
-MYRBIN=mbld
-
-MYRSRC= \
- build.myr \
- clean.myr \
- config.myr \
- deps.myr \
- fsel.myr \
- install.myr \
- main.myr \
- opts.myr \
- parse.myr \
- subdir.myr \
- util.myr \
- test.myr \
- types.myr
-
-include config.mk
-include mk/myr.mk
-
diff --git a/bldfile b/bldfile
deleted file mode 100644
index 45d21bd..0000000
--- a/bldfile
+++ /dev/null
@@ -1,22 +0,0 @@
-# the mbld binary
-bin mbld =
- build.myr
- clean.myr
- config.myr # config, as generated by the ./configure script
- config+plan9-x64.myr # config, as hardcoded for Plan 9
- deps.myr
- fsel.myr
- install.myr
- main.myr
- opts.myr
- parse.myr
- subdir.myr
- test.myr
- types.myr
- util.myr
-;;
-
-gen config.myr {durable} = ./configure ;;
-
-man = mbld.1;;
-
diff --git a/build.myr b/build.myr
deleted file mode 100644
index 74768db..0000000
--- a/build.myr
+++ /dev/null
@@ -1,412 +0,0 @@
-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 build : (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
- match gettarg(b.targs, tn)
- | `Bin bt: buildbin(b, bt, false)
- | `Lib lt: buildlib(b, lt)
- | `Test tt: /* build on 'mbld test' by default */
- | `Gen gt: genfiles(b, gt)
- | `Man m: /* nothing needed */
- ;;
- ;;
- -> true
-}
-
-const genall = {b
- for tn in b.all
- match gettarg(b.targs, tn)
- | `Gen gt: run(gt.cmd)
- | _: /* 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 (`Test tt): buildbin(b, tt, false)
- | `std.Some (`Gen gt): run(gt.cmd)
- | `std.Some (`Man m): /* nothing needed */
- | `std.None: std.fatal(1, "invalid target %s\n", targ)
- ;;
- -> true
-}
-
-const buildbin = {b, targ, addsrc
- var dg, src
-
- if targ.built
- ->
- ;;
- setdir(b, targ.dir)
- addincludes(b, targ)
- buildlibdeps(b, targ)
- std.put("%s...\n", targ.name)
- if !myrdeps(b, targ, false, false, addsrc, &dg)
- std.fatal(1, "Could not load dependencies for %s\n", targ.name)
- ;;
- if !std.hthas(dg.deps, targ.name)
- std.fatal(1, "no input files for %s\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)
- ;;
- targ.built = true
-}
-
-const buildlib = {b, targ
- var archive
- var u, l
- var dg
- var lib, src
-
- if targ.built
- ->
- ;;
- setdir(b, targ.dir)
- addincludes(b, targ)
- buildlibdeps(b, targ)
- lib = targ.name
- std.put("lib%s.a...\n", lib)
- archive = std.fmt("lib%s.a", lib)
- if !myrdeps(b, targ, true, false, false, &dg)
- std.fatal(1, "Could not load dependencies for %s\n", lib)
- ;;
- if !std.hthas(dg.deps, lib)
- std.fatal(1, "no target declared for %s\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)
- targ.built = true
-}
-
-const genfiles = {b, gt
- for f in gt.out
- if !std.fexists(f)
- run(gt.cmd)
- break
- ;;
- ;;
-}
-
-const addincludes = {b, targ
- for (inc, lib, subtarg) in targ.libdeps
- if !hasinc(targ.incpath, inc)
- targ.incpath = std.slpush(targ.incpath, inc)
- ;;
- ;;
-}
-
-const buildlibdeps = {b, targ
- for (inc, lib, subtarg) in targ.libdeps
- build(b, subtarg)
- ;;
-}
-
-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
- ;;
- if !std.fexists(d)
- match std.htget(b.gensrc, d)
- | `std.Some gt: run(gt.cmd)
- | `std.None: std.fatal(1, "no input file %s\n", d)
- ;;
- ;;
- if !isfresh(d, out)
- stale = true
- ;;
- ;;
- | `std.None:
- ;;
-
- match std.htget(dg.input, out)
- | `std.Some src:
- if stale
- compile(src, incs)
- ;;
- std.htput(dg.updated, out, true)
- | `std.None:
- ;;
- -> stale
-}
-
-const compile = {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)
- else
- std.fatal(1, "Unknown file type for %s\n", src)
- ;;
-}
-
-const linkbin = {dg, bin, srcfiles, ldscript, rt, incs, extralibs
- 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)
- for (d, l, t) in extralibs
- cmd = std.slpush(cmd, std.fmt("-l%s", 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"))
- ;;
-
- 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%s.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.fatal(1, "unknown file type for %s\n", f)
- ;;
- ;;
- 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%s", inc))
- ;;
- cmd = std.slpush(cmd, std.fmt("-L%s%s", opt_instroot, "/lib/myr"))
- ;;
-
- 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(1, "cycle in library graph involving \"%s\"\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
- if !config.Directlib
- -> std.slput(cmd, head, std.fmt("-l%s", lib))
- else
- match findlib(lib, incs)
- | `std.None:
- std.fatal(1, "could not find library lib%s.a", 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%s.a", lib)
- for i in incs
- p = std.pathjoin([i, sl][:])
- if std.fexists(p)
- -> `std.Some p
- ;;
- std.slfree(p)
- ;;
- p = std.pathjoin([opt_instroot, "lib/myr", 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.fatal(1, "%s: could not find library lib%s.a", l)
- ;;
- ;;
- std.slfree(libs)
- -> 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.Some mt: srcmt = mt
- | `std.None: std.fatal(1, "could not stat %s\n", src)
- ;;
- match std.fmtime(dst)
- | `std.Some mt: dstmt = mt
- | `std.None: -> false
- ;;
- -> srcmt <= dstmt
-}
-
diff --git a/clean.myr b/clean.myr
deleted file mode 100644
index 89e595b..0000000
--- a/clean.myr
+++ /dev/null
@@ -1,89 +0,0 @@
-use std
-
-use "config.use"
-use "deps.use"
-use "opts.use"
-use "parse.use"
-use "subdir.use"
-use "types.use"
-use "util.use"
-
-pkg bld =
- const cleanall : (b : build# -> bool)
- const clean : (b : build#, targ : byte[:] -> bool)
-;;
-
-const cleanall = {b
- for tn in b.all
- match gettarg(b.targs, tn)
- | `Bin bt:
- cleanup(b, bt, bt.inputs, true)
- | `Lib lt:
- cleanup(b, lt, lt.inputs, true)
- | `Test tt:
- cleanup(b, tt, tt.inputs, true)
- | `Gen gt:
- for f in gt.out
- if !gt.durable && std.remove(f)
- std.put("\tclean %s\n", f)
- ;;
- ;;
- | `Man m:
- ;;
- ;;
- -> true
-}
-
-const clean = {b, targ
- for tn in b.all
- match gettarg(b.targs, tn)
- | `Bin bt:
- if std.sleq(bt.name, targ)
- cleanup(b, bt, bt.inputs, true)
- ;;
- | `Lib lt:
- if std.sleq(lt.name, targ)
- cleanup(b, lt, lt.inputs, true)
- ;;
- | `Test tt:
- if std.sleq(tt.name, targ)
- cleanup(b, tt, tt.inputs, true)
- ;;
- | `Gen gt:
- for f in gt.out
- if !gt.durable && std.remove(f)
- std.put("\tclean %s\n", f)
- ;;
- ;;
- | `Man m:
- ;;
- ;;
- -> true
-}
-
-const cleanup = {b, targ, leaves, islib
- var mchammer_files /* cant touch this */
- var keys
- var dg
-
- /*
- we want to automatically add 'clean' sources since otherwise,
- mbld won't be able to clean code after changing a build file.
- */
- setdir(b, targ.dir)
- if !myrdeps(b, targ, islib, true, true, &dg)
- std.fatal(1, "Could not load dependencies for %s\n", targ.name)
- ;;
- mchammer_files = std.mkht(std.strhash, std.streq)
- for l in leaves
- std.htput(mchammer_files, l, true)
- ;;
-
- keys = std.htkeys(dg.deps)
- for k in keys
- if !std.htgetv(mchammer_files, k, false) && std.remove(k)
- std.put("\tclean %s\n", k)
- ;;
- ;;
-}
-
diff --git a/config+plan9-x64.myr b/config+plan9-x64.myr
deleted file mode 100644
index 75b5081..0000000
--- a/config+plan9-x64.myr
+++ /dev/null
@@ -1,11 +0,0 @@
-pkg config =
- const Instroot = "/amd64"
- const Sys = "Plan9"
- const Objsuffix = ".6"
- const Linkcmd = ["6l", "-lo"]
- const Arcmd = ["ar", "vu"]
- const Ascmd = ["6a"]
- const Directlib = true
- const Runtime = "_myrrt.6"
- const Manpath = "man/"
-;;
diff --git a/configure b/configure
deleted file mode 100755
index d7b2227..0000000
--- a/configure
+++ /dev/null
@@ -1,65 +0,0 @@
-#!/bin/sh
-
-prefix="/usr/local"
-
-for i in `seq 300`; do
- echo "Lots of output to emulate automake... ok"
- echo "Testing for things you'll never use... fail"
- echo "Satisfying the fortran77 lobby... ok"
- echo "Burning CPU time checking for the bloody obvious... ok"
-done
-echo "Automake emulated successfully"
-
-INST_ROOT='/usr/local'
-
-for arg in $*; do
- shift 1
- case $arg in
- "--prefix" | "-p")
- prefix=shift $*
- ;;
- --prefix=*)
- prefix=`echo $arg | sed 's/^--prefix=//g'`
- ;;
- "--help" | "-h")
- echo "Usage:"
- echo " --prefix | -p: The prefix to install to"
- break;
- ;;
- *) echo "Unrecognized argument $arg";;
- esac
-done
-
-OS=`uname`
-
-echo export INST_ROOT=$prefix > config.mk
-
-echo "pkg config = " > config.myr
-echo "const Instroot = \"$prefix\"" >> config.myr
-echo "const Objsuffix = \".o\"" >> config.myr
-echo "const Linkcmd = [\"ld\", \"-o\"]" >> config.myr
-echo "const Arcmd = [\"ar\", \"-rcs\"]" >> config.myr
-echo "const Ascmd = [\"as\", \"-g\"]" >> config.myr
-echo "const Directlib = false" >> config.myr
-echo "const Runtime = \"_myrrt.o\"" >> config.myr
-echo "const Manpath = \"share/man/man\"" >> config.myr
-case $OS in
- *Linux*)
- echo 'export SYS=linux' >> config.mk
- echo 'const Sys = "Linux"' >> config.myr
- ;;
- *Darwin*)
- echo 'export SYS=osx' >> config.mk
- echo 'const Sys = "OSX"' >> config.myr
- ;;
- *)
- echo 'Unknown architecture.'
- ;;
-esac
-echo ";;" >> config.myr
-
-cat << EOF
- Building with:
- prefix=$prefix
-EOF
-
diff --git a/deps.myr b/deps.myr
deleted file mode 100644
index b46a517..0000000
--- a/deps.myr
+++ /dev/null
@@ -1,308 +0,0 @@
-use std
-use regex
-use bio
-
-use "config.use"
-use "opts.use"
-use "types.use"
-use "util.use"
-
-pkg bld =
- const myrdeps : (b : build#, mt : myrtarg#, islib : bool, isclean : bool, addsrc : bool, dg : depgraph# -> bool)
-
- /* a bit ugly: initialized from main() */
- var usepat : regex.regex#
-;;
-
-var usepat : regex.regex#
-
-type dep = union
- `Local byte[:]
- `Lib byte[:]
-;;
-
-const myrdeps = {b, mt, islib, isclean, addsrc, dg
- var objs, uses, srcs, incs
- var out, useout, depstk
- var i
-
- dg.deps = std.mkht(std.strhash, std.streq)
- dg.libs = std.mkht(std.strhash, std.streq)
- dg.input = std.mkht(std.strhash, std.streq)
- dg.sources = std.mkht(std.strhash, std.streq)
- dg.updated = std.mkht(std.strhash, std.streq)
- dg.seen = std.mkht(std.strhash, std.streq)
- dg.done = std.mkht(std.strhash, std.streq)
-
- /* direct dependencies of binary */
- if islib
- out = std.fmt("lib%s.a", mt.name)
- useout = std.sldup(mt.name)
- else
- out = std.sldup(mt.name)
- useout = ""
- ;;
-
- srcs = mt.inputs
- incs = mt.incpath
- objs = swapall(srcs, config.Objsuffix)
- uses = swapall(srcs, ".use")
- for i = 0; i < srcs.len; i++
- std.htput(dg.input, objs[i], srcs[i])
- std.htput(dg.sources, srcs[i], true)
- pushdep(dg, srcs[i], objs[i])
- if std.hassuffix(srcs[i], ".myr")
- std.htput(dg.input, uses[i], srcs[i])
- pushdep(dg, srcs[i], uses[i])
- ;;
- ;;
-
- for i = 0; i < srcs.len; i++
- pushdep(dg, objs[i], out)
- if islib && std.hassuffix(srcs[i], ".myr")
- pushdep(dg, uses[i], useout)
- ;;
- ;;
-
- for i = 0; i < srcs.len; i++
- depstk = [][:]
- srcdeps(b, dg, srcs[i], objs[i], uses[i], incs, &depstk, isclean, addsrc)
- std.slfree(depstk)
- ;;
- dumpgraph(dg)
- -> true
-}
-
-const swapall = {srcs, suff
- var sl
-
- sl = [][:]
- for s in srcs
- sl = std.slpush(sl, srcswapsuffix(s, suff))
- ;;
- -> sl
-}
-
-const dumpgraph = {dg
- var keys
-
- if !opt_debug
- ->
- ;;
- keys = std.htkeys(dg.deps)
- std.put("digraph dg {\n")
- for k in keys
- for v in std.htgetv(dg.deps, k, ["WTFUNKNOWN!"][:])
- std.put("\t\"%s\" -> \"%s\";\n", k, v)
- ;;
- ;;
- std.put("}\n")
-}
-
-const srcdeps = {b, g, path, obj, usefile, incs, depstk, isclean, addsrc
- var deps
-
- if std.hthas(g.done, path)
- ->
- ;;
-
- depstk# = std.slpush(depstk#, path)
- if std.htgetv(g.seen, path, false)
- std.fput(1, "dependency loop involving %s:\n", path)
- for d in depstk#
- std.fput(1, "\t%s\n", d)
- ;;
- std.exit(1)
- ;;
- deps = getdeps(b, path)
- std.htput(g.seen, path, true)
- for d in deps
- match d
- | `Lib lib:
- /*
- If we're cleaning, we don't care about libraries; at best, this does nothing. At
- worst, this will cause failure if the library is a local library that gets cleand.
- */
- if !isclean
- scrapelibs(g, lib, incs)
- ;;
- | `Local l:
- if !std.hassuffix(l, ".use")
- std.fatal(1, "local dependency \"%s\" of \"%s\" should end with .use\n", l, path)
- ;;
- if obj.len != 0
- pushdep(g, l, obj)
- ;;
- if usefile.len != 0
- pushdep(g, l, usefile)
- ;;
- addusedep(b, g, path, l, incs, depstk, isclean, addsrc)
- ;;
- ;;
- depstk# = std.slgrow(depstk#, depstk#.len - 1)
- std.htput(g.seen, path, false)
- std.htput(g.done, path, true)
-}
-
-const addusedep = {b, g, f, usefile, incs, depstk, isclean, addsrc
- var src
-
- if std.hthas(g.done, usefile)
- if opt_debug
- std.put("already loaded deps for %s\n", usefile)
- ;;
- ->
- ;;
- match std.htget(g.input, usefile)
- | `std.Some path:
- src = std.sldup(path)
- | `std.None:
- src = swapsuffix(usefile, ".use", ".myr")
- if addsrc
- std.htput(g.sources, src, true)
- elif !std.hthas(g.input, usefile)
- std.fatal(1, "%s: source file %s not listed in bldfile\n", f, src)
- ;;
- ;;
- pushdep(g, src, usefile)
- std.htput(g.input, usefile, src)
- srcdeps(b, g, src, "", usefile, incs, depstk, isclean, addsrc)
- std.htput(g.done, usefile, true)
-}
-
-const getdeps = {b, path
- var f
- var deps : dep[:]
-
- deps = [][:]
- if !std.fexists(path)
- match std.htget(b.gensrc, path)
- | `std.Some gt: run(gt.cmd)
- | `std.None: std.fatal(1, "no input file %s\n", path)
- ;;
- ;;
- match bio.open(path, bio.Rd)
- | `std.Some fd: f = fd
- | `std.None: std.fatal(1, "could not open %s\n", path)
- ;;
-
- while true
- match bio.readln(f)
- | `std.Some ln:
- deps = depname(deps, ln)
- std.slfree(ln)
- | `std.None:
- bio.close(f)
- -> deps
- ;;
- ;;
-}
-
-const scrapelibs = {dg, lib, incs
- var deps, d
- var f
- var done
-
- if std.hthas(dg.libs, lib)
- ->
- ;;
-
- deps = [][:]
- f = openlib(lib, incs)
- match bio.getc(f)
- | `std.Some 'U': /* nothing */
- | `std.Some _: std.fatal(1, "library %s: corrupt or invalid usefile\n", lib)
- | `std.None: std.fatal(1, "library %s: could not read usefile\n", lib)
- ;;
- match bio.getbe32(f)
- | `std.Some 1: /* nothing: version matches. */
- | `std.Some 0: std.fput(1, "library %s: warning: old usefile version\n", lib)
- | `std.Some _: std.fatal(1, "library %s: usefile version unknown\n", lib)
- | `std.None: std.fatal(1, "library %s: corrutpt or invalid usefile\n", lib)
- ;;
- std.slfree(rdstr(f))
- done = false
- while !done
- match bio.getc(f)
- | `std.Some 'L':
- d = rdstr(f)
- deps = std.slpush(deps, d)
- | `std.Some _: done = true
- | `std.None: done = true
- ;;
- ;;
- bio.close(f)
- std.htput(dg.libs, lib, deps)
- for dep in deps
- scrapelibs(dg, dep, incs)
- ;;
-}
-
-const openlib = {lib, incs
- var path
-
- for p in incs
- path = std.pathjoin([p, lib][:])
- match bio.open(path, bio.Rd)
- | `std.Some file:
- -> file
- | `std.None:
- /* nothing */
- ;;
- ;;
- path = std.pathjoin([opt_instroot, "/lib/myr", lib][:])
- match bio.open(path, bio.Rd)
- | `std.Some file:
- -> file
- | `std.None:
- /* nothing */
- ;;
- std.fatal(1, "could not find library %s.\n", lib)
-}
-
-const depname = {deps, ln
- /*
- the regex pattern does some contortions to either grab
- an unquoted path and put it into uses[4], or a quoted
- path, and put it (minus the quotes) into uses[2]
- */
- match regex.exec(usepat, ln)
- | `std.Some uses:
- if uses[2].len > 0
- deps = std.slpush(deps, `Local std.sldup(uses[2]))
- else
- deps = std.slpush(deps, `Lib std.sldup(uses[4]))
- ;;
- | `std.None:
- /* nothing to do */
- ;;
- -> deps
-}
-
-
-/* pushes a dep into the dependency list */
-const pushdep = {dg, src, dst
- var sl
-
- if opt_debug
- std.put("%s <= %s\n", dst, src)
- ;;
- std.assert(dst.len < 200, "BUG!")
- sl = std.htgetv(dg.deps, dst, [][:])
- sl = std.slpush(sl, src)
- std.htput(dg.deps, dst, sl)
-}
-
-const rdstr = {f
- var len
- var sl
-
- match bio.getbe32(f)
- | `std.Some l:
- len = l
- sl = std.slalloc(len)
- | `std.None: std.die("string length not readable")
- ;;
- bio.read(f, sl)
- -> sl
-}
diff --git a/fsel.myr b/fsel.myr
deleted file mode 100644
index ea45b4f..0000000
--- a/fsel.myr
+++ /dev/null
@@ -1,105 +0,0 @@
-use std
-
-use "opts.use"
-
-pkg bld =
- type fsel = struct
- filematch : std.htab(byte[:], int)#
- filebest : std.htab(byte[:], byte[:])#
- sysattrs : std.htab(byte[:], bool)#
- ;;
-
- const mkfsel : (-> fsel#)
- const fseladd : (fsel : fsel#, file : byte[:] -> void)
- const fselfin : (fsel : fsel# -> byte[:][:])
-;;
-
-const mkfsel = {
- var fsel
-
- fsel = std.alloc()
- fsel.filematch = std.mkht(std.strhash, std.streq)
- fsel.filebest = std.mkht(std.strhash, std.streq)
- fsel.sysattrs = std.mkht(std.strhash, std.streq)
- addsysattrs(fsel.sysattrs)
- -> fsel
-}
-
-const fseladd = {fsel, f
- var basename, attrs
- var nmatch, curbest
- 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(1, "unrecognized type for file %s\n", f)
- ;;
- | `std.None:
- match std.strrfind(f, ".")
- | `std.None: std.fatal(1, "unrecognized type for file %s\n", f)
- | `std.Some i:
- basename = f[:i]
- attrs = ""
- ;;
- ;;
-
- nmatch = 0
- attrlist = std.strsplit(attrs, "-")
- for a in attrlist
- if std.hthas(fsel.sysattrs, a)
- nmatch++
- else
- nmatch = -1
- break
- ;;
- ;;
- std.slfree(attrlist)
- curbest = std.htgetv(fsel.filematch, basename, -1)
- if curbest < nmatch
- std.htput(fsel.filematch, basename, nmatch)
- std.htput(fsel.filebest, basename, f)
- ;;
-}
-
-const fselfin = {fsel
- var keys, nmatch, ret
-
- keys = std.htkeys(fsel.filematch)
- ret = [][:]
- for k in keys
- nmatch = std.htgetv(fsel.filematch, k, -1)
- if nmatch == -1
- std.fatal(1, "no applicable file for '%s'\n", k)
- ;;
- ret = std.slpush(ret, std.htgetv(fsel.filebest, k, ""))
- ;;
- std.htfree(fsel.filematch)
- std.htfree(fsel.filebest)
- std.htfree(fsel.sysattrs)
- -> ret
-}
-
-const addsysattrs = {sa
- var attrs
- match opt_sys
- | "freebsd": attrs = ["freebsd", "posixy"][:]
- | "osx": attrs = ["osx", "posixy"][:]
- | "linux": attrs = ["linux", "posixy"][:]
- | "plan9": attrs = ["plan9"][:]
- | unknown: std.fatal(1, "unknown system \"%s\"\n", unknown)
- ;;
- for a in attrs
- std.htput(sa, a, true)
- ;;
-
- match opt_arch
- | "x64": attrs = ["x64"][:]
- | unknown: std.fatal(1, "unknown arch %s\n", unknown)
- ;;
- for a in attrs
- std.htput(sa, a, true)
- ;;
-}
diff --git a/install.myr b/install.myr
deleted file mode 100644
index a895166..0000000
--- a/install.myr
+++ /dev/null
@@ -1,92 +0,0 @@
-use std
-
-use "config.use"
-use "deps.use"
-use "opts.use"
-use "parse.use"
-use "subdir.use"
-use "types.use"
-use "util.use"
-use "build.use"
-
-pkg bld =
- const install : (p : build# -> bool)
- const uninstall : (p : build# -> bool)
-;;
-
-const install = {b
- buildall(b)
- -> movetargs(b, false)
-}
-
-const uninstall = {b
- -> movetargs(b, true)
-}
-
-const movetargs = {b, delete
- var libarchive
-
- for tn in b.all
- match gettarg(b.targs, tn)
- | `Bin bt:
- movefile(delete, bt.name, opt_instroot, opt_destdir, "bin", 0o755)
- | `Lib lt:
- movefile(delete, lt.name, opt_instroot, opt_destdir, "lib/myr", 0o644)
- libarchive = std.fmt("lib%s.a", lt.name)
- movefile(delete, libarchive, opt_instroot, opt_destdir, "lib/myr", 0o644)
- std.slfree(libarchive)
- | `Gen gt:
- /* nothing to do (?) */
- | `Man mans:
- /* FIXME: figure out man section by number */
- for m in mans
- moveman(delete, m)
- ;;
- | `Test tt: /* nothing */
- ;;
- ;;
- -> true
-}
-
-
-const movefile = {delete, file, instdir, destdir, prefix, perm
- var path
-
- path = std.pathjoin([destdir, instdir, prefix, file][:])
- if delete
- std.put("\tdelete %s\n", path)
- if !std.remove(path)
- std.put("\t\tno such file %s\n", file)
- ;;
- else
- std.put("\t%s => %s\n", file, path)
- std.remove(path)
- match std.slurp(file)
- | `std.Fail m: std.fatal(1, "Could not open %s for reading\n", file)
- | `std.Ok buf:
- if !std.blat(path, buf, perm)
- std.put("Could not write %s\n", file)
- ;;
- std.slfree(buf)
- ;;
- ;;
- std.slfree(path)
-}
-
-const moveman = {delete, man
- var sect, manrel
-
- match std.strrfind(man, ".")
- | `std.None:
- std.fatal(1, "manpage %s has no section\n", man)
- | `std.Some s:
- sect = s + 1
- if s + 1 == man.len
- std.fatal(1, "manpage %s missing suffix\n", man)
- ;;
- ;;
-
- manrel = std.fmt("%s%s", opt_manpath, man[sect:])
- movefile(delete, man, opt_instroot, opt_destdir, manrel, 0o644)
- std.slfree(manrel)
-}
diff --git a/main.myr b/main.myr
deleted file mode 100644
index caab00a..0000000
--- a/main.myr
+++ /dev/null
@@ -1,115 +0,0 @@
-use std
-use regex
-
-use "build.use"
-use "clean.use"
-use "config.use"
-use "deps.use"
-use "install.use"
-use "opts.use"
-use "parse.use"
-use "test.use"
-use "types.use"
-
-const main = {args : byte[:][:]
- var b : bld.build#
- var mt : bld.myrtarg
- var targname
- var bintarg
- var optctx
-
- optctx = std.optinit("hb:l:s:Sr:I:C:A:M:L:R:d", args)
- bld.initopts()
- while !std.optdone(optctx)
- match std.optnext(optctx)
- | ('h', arg): usage(args[0])
- | ('s', arg): bld.opt_ldscript = arg
- | ('f', arg): bld.opt_bldfile = arg
- | ('I', arg): bld.opt_incpaths = std.slpush(bld.opt_incpaths, arg)
- | ('S', _): bld.opt_genasm = true
- | ('R', arg): bld.opt_instroot = arg
- | ('b', arg):
- targname = arg
- bintarg = true
- | ('l', arg):
- targname = arg
- bintarg = false
- | ('r', arg):
- if std.sleq(arg, "none")
- bld.opt_runtime = ""
- else
- bld.opt_runtime = arg
- ;;
- /*
- internal undocumented args; used by compiler suite for
- building with an uninstalled compiler.
- */
- | ('d', arg): bld.opt_debug = true
- | ('C', arg): bld.opt_mc = arg
- | ('M', arg): bld.opt_muse = arg
- | _: std.die("got invalid arg\n")
- ;;
- ;;
-
- match regex.compile("^\\s*use\\s+((\\<\\S+\\>)|(\"(\\S+)\")).*")
- | `std.Ok re: bld.usepat = re
- | `std.Fail f: std.fatal(1, "Failed to compile use pattern regex\n")
- ;;
-
- b = mkbuild()
- if targname.len != 0
- mt = [
- .name=targname,
- .inputs=optctx.args,
- .runtime=bld.opt_runtime,
- .incpath=bld.opt_incpaths,
- .ldscript=bld.opt_ldscript,
- .libdeps=[][:]
- ]
- if bintarg
- bld.buildbin(b, &mt, true)
- else
- bld.buildlib(b, &mt)
- ;;
- else
- bld.load(b, bld.opt_bldfile)
- /*bld.configure()*/
- /* default: buildall */
- if optctx.args.len == 0
- bld.buildall(b)
- else
- for cmd in optctx.args
- match cmd
- | "all": bld.buildall(b)
- | "gen": bld.genall(b)
- | "clean": bld.cleanall(b)
- | "install": bld.install(b)
- | "uninstall": bld.uninstall(b)
- | "test": bld.test(b)
- | target: bld.build(b, target)
- ;;
- ;;
- ;;
- ;;
-}
-
-const mkbuild = {
- var b
-
- b = std.zalloc()
- b.targs = std.mkht(std.strhash, std.streq)
- b.gensrc = std.mkht(std.strhash, std.streq)
- b.basedir = std.getcwd()
- b.curdir = ""
- -> b
-}
-
-const usage = {prog
- std.put("%s [-h] [-I path] [-l lib] [-b bin] inputs...\n", prog)
- std.put("\t-h\tprint this help\n")
- std.put("\t-b bin\tBuild a binary called 'bin'\n")
- std.put("\t-l lib\tBuild a library called 'name'\n")
- std.put("\t-s script\tUse the linker script 'script' when linking\n")
- std.put("\t-I path\tAdd 'path' to use search path\n")
- std.exit(0)
-}
diff --git a/mbld.1 b/mbld.1
deleted file mode 100644
index 52066b3..0000000
--- a/mbld.1
+++ /dev/null
@@ -1,81 +0,0 @@
-.TH MBLD 1
-.SH NAME
-mbld
-.SH SYNOPSIS
-.B mbld
-.I [all | clean | install | uninstall | test]
-.I -[hblIsfrR]
-.I [file...]
-.br
-.SH DESCRIPTION
-.PP
-The 'mbld' tool takes as input a list of Myrddin or assembly sources,
-and compiles them in the correct dependency order into either a library or
-an executable.
-
-.PP
-By default, it reads from an input file called 'bldfile', but if given the
-option '-b' or '-l', it will build a binary or library, respectively, from
-the arguments specified on the command lines.
-
-.PP
-Myrbuild will default to building for the current architecture.
-
-.PP
-The myrbuild options are:
-
-.TP
-.B -h
-Print a summary of the available options.
-
-.TP
-.B -b name
-Compile source into a binary named 'name'. If neither this option nor
-the '-l' option are given, myrbuild will create a binary called 'a.out'.
-
-.TP
-.B -l 'name'
-Compile source given into a library called 'lib<name>.a', and a matching
-usefile called 'name'. Only static libraries are currently supported.
-
-.TP
-.B -s 'script'
-Pass the linker script 'script' to the linker. If this option is not
-provided, no script is passed to the linker.
-
-.TP
-.B -r 'rt'
-Compile a binary using the runtime 'rt'. If the runtime name given
-is 'none', then no runtime will be linked. If this option is not provided,
-then the default runtime in '$INSTALL_ROOT/myr/lib/_myrrt.o' will be
-used.
-
-.TP
-.B -I path
-Add 'path' to the search path for unquoted use statments. This option
-does not affect the search path for local usefiles, which are always
-searched relative to the compiler's current working directory. Without
-any options, the search path defaults to /usr/include/myr.
-
-.SH EXAMPLE
-.EX
- mbld
- mbld -l foo bar.myr baz.myr
-.EE
-
-.SH FILES
-The source for muse is available from
-.B git://git.eigenstate.org/git/ori/mc.git
-and lives in the
-.I myrbuild/
-directory within the source tree.
-
-.SH SEE ALSO
-.IR mc(1)
-.IR muse(1)
-.IR ld(1)
-.IR as(1)
-
-.SH BUGS
-.PP
-None known.
diff --git a/mk/myr.mk b/mk/myr.mk
deleted file mode 100644
index 68e4c41..0000000
--- a/mk/myr.mk
+++ /dev/null
@@ -1,42 +0,0 @@
-ifneq ($(MYRLIB),)
- _LIBNAME=lib$(MYRLIB).a
-endif
-
-all: $(_LIBNAME) $(MYRBIN)
-
-$(_LIBNAME): $(MYRSRC) $(ASMSRC)
- myrbuild -l $(MYRLIB) $^
-
-$(MYRBIN): $(MYRSRC) $(ASMSRC)
- myrbuild -b $(MYRBIN) $^
-
-OBJ=$(MYRSRC:.myr=.o) $(ASMSRC:.s=.o)
-JUNKASM=$(MYRSRC:.myr=.s)
-USE=$(MYRSRC:.myr=.use) $(MYRLIB)
-.PHONY: clean install install-bin install-lib
-clean:
- rm -f $(OBJ)
- rm -f $(USE)
- rm -f $(JUNKASM) $(CLEANEXTRA)
- rm -f $(_LIBNAME) $(MYRBIN)
-
-install: install-bin install-lib
-
-install-bin: $(MYRBIN)
- @if [ ! -z "$(MYRBIN)" ]; then \
- echo install $(MYRBIN) $(INST_ROOT)/bin; \
- mkdir -p $(INST_ROOT)/bin; \
- install $(MYRBIN) $(INST_ROOT)/bin; \
- fi
-
-install-lib: $(_LIBNAME)
- @if [ ! -z "$(_LIBNAME)" ]; then \
- echo install -m 644 $(_LIBNAME) $(INST_ROOT)/lib/myr; \
- echo install -m 644 $(MYRLIB) $(INST_ROOT)/lib/myr; \
- mkdir -p $(INST_ROOT)/lib/myr; \
- install -m 644 $(_LIBNAME) $(INST_ROOT)/lib/myr; \
- install -m 644 $(MYRLIB) $(INST_ROOT)/lib/myr; \
- fi
-
-config.mk:
- ./configure
diff --git a/opts.myr b/opts.myr
deleted file mode 100644
index 1adfab9..0000000
--- a/opts.myr
+++ /dev/null
@@ -1,85 +0,0 @@
-use std
-
-use "config.use"
-
-pkg bld =
- var opt_arch : byte[:]
- var opt_sys : byte[:]
- var opt_runtime : byte[:]
- var opt_genasm : bool
- var opt_ldscript : byte[:]
- var opt_incpaths : byte[:][:]
- var opt_instroot : byte[:]
- var opt_manpath : byte[:]
- var opt_destdir : byte[:]
- var opt_outdir : byte[:]
- var opt_bldfile : byte[:]
- var opt_debug : bool
-
- /* undocumented/unsupported opts */
- var opt_mc : byte[:]
- var opt_muse : byte[:]
-
- var sysarchstr : byte[:]
- var archstr : byte[:]
- var sysstr : byte[:]
-
- const initopts : (-> void)
-;;
-
-var opt_arch = ""
-var opt_sys = ""
-var opt_binname = ""
-var opt_libname = ""
-var opt_runtime = ""
-var opt_ldscript = ""
-var opt_incpaths /* FIXME: taking a constant slice is a nonconstant initializer */
-var opt_instroot = ""
-var opt_manpath = ""
-var opt_destdir = ""
-var opt_debug = false
-var opt_bldfile = "bldfile"
-var opt_mc = "6m"
-var opt_as = "as"
-var opt_muse = "muse"
-var opt_ld = "ld"
-var opt_ar = "ar"
-var opt_genasm = false
-
-/* derived */
-var sysarchstr = ""
-var archstr = ""
-var sysstr = ""
-
-const initopts = {
- var si
-
- std.getsysinfo(&si)
- match si.system
- | "Linux": opt_sys = "linux"
- | "Darwin": opt_sys = "osx"
- | "FreeBSD": opt_sys = "freebsd"
- | "Plan9": opt_sys = "plan9"
- | unknown: std.fatal(1, "unknown system \"%s\"\n", unknown)
- ;;
-
- match si.arch
- | "x86_64": opt_arch = "x64"
- | "amd64": opt_arch = "x64"
- | unknown: std.fatal(1, "unknown architecture \"%s\"\n", unknown)
- ;;
-
- opt_incpaths = [][:]
- opt_instroot = config.Instroot
- opt_manpath = config.Manpath
- opt_destdir = std.getenvv("DESTDIR", "")
- opt_mc = std.getenvv("MYR_MC", "6m")
- opt_muse = std.getenvv("MYR_MUSE", "muse")
-
- sysarchstr = std.fmt("+%s-%s", opt_sys, opt_arch)
- sysstr = std.fmt("+%s", opt_sys)
- archstr = std.fmt("+%s", opt_arch)
-
- opt_runtime = std.pathjoin([opt_instroot, "lib/myr", config.Runtime][:])
-}
-
diff --git a/parse.myr b/parse.myr
deleted file mode 100644
index 75efe3d..0000000
--- a/parse.myr
+++ /dev/null
@@ -1,539 +0,0 @@
-use std
-
-use "types.use"
-use "util.use"
-use "opts.use"
-use "fsel.use"
-
-pkg bld =
- const load : (b : build#, path : byte[:] -> bool)
-;;
-
-type parser = struct
- /* parse input */
- data : byte[:]
- rest : byte[:]
- fname : byte[:]
- fdir : byte[:] /* directory relative to base */
- basedir : byte[:]
- line : int
-
- /* extracted data for further parsing */
- subdirs : byte[:][:]
-;;
-
-const load = {b, path
- -> loadall(b, path, "")
-}
-
-
-const loadall = {b, path, dir
- var p : parser#
- var subpath, subbld, ok
-
- p = mkparser(path, dir, b.basedir)
- ok = bld.parse(b, p, "")
- for s in p.subdirs
- subpath = std.pathcat(p.fdir, s)
- subbld = std.pathcat(subpath, "bldfile")
- loadall(b, subbld, subpath)
- std.slfree(subpath)
- std.slfree(subbld)
- ;;
- freeparser(p)
- -> ok
-}
-
-const mkparser = {path, dir, basedir
- var p
-
- p = std.zalloc()
- p.line = 1
- p.fname = std.sldup(path)
- p.fdir = std.sldup(dir)
- p.basedir = std.sldup(basedir)
- match std.slurp(path)
- | `std.Ok d: p.data = d
- | `std.Fail _: std.fatal(1, "could not open '%s'\n", path)
- ;;
- p.rest = p.data
- -> p
-}
-
-const freeparser = {p
- std.slfree(p.fname)
- std.slfree(p.fdir)
- std.slfree(p.basedir)
- std.slfree(p.subdirs)
- std.slfree(p.data)
- std.free(p)
-}
-
-const failparse = {p, msg, args : ...
- var buf : byte[1024]
- var ap
- var sl
-
- ap = std.vastart(&args)
- sl = std.bfmtv(buf[:], msg, ap)
- std.fput(1, "%s:%i: %s", p.fname, p.line, sl)
- std.exit(1)
-}
-
-const parse = {b, p, path
- while true
- skipspace(p)
- if !target(b, p)
- break
- ;;
- ;;
- skipspace(p)
- if p.rest.len > 0
- failparse(p, "junk in file near %s\n", p.rest[:std.min(p.rest.len, 10)])
- -> false
- ;;
- -> true
-}
-
-const target = {b, p
- match word(p)
- | `std.Some "bin": bintarget(b, p)
- | `std.Some "test": testtarget(b, p)
- | `std.Some "lib": libtarget(b, p)
- | `std.Some "gen": gentarget(b, p)
- | `std.Some "man": mantarget(b, p)
- | `std.Some "sub": subtarget(b, p)
- | `std.Some targtype: failparse(p, "unknown targtype type %s\n", targtype)
- | `std.None: -> false
- ;;
- -> true
-}
-
-/* bintarget: myrtarget */
-const bintarget = {b, p
- var t
- t = myrtarget(p, "bin")
- addtarg(p, b, t.name, `Bin t)
-}
-
-/* libtarget: myrtarget */
-const libtarget = {b, p
- var t
- t = myrtarget(p, "lib")
- addtarg(p, b, t.name, `Lib t)
-}
-
-/* testtarget: myrtarget */
-const testtarget = {b, p
- var t
- t = myrtarget(p, "test")
- addtarg(p, b, t.name, `Test myrtarget(p, "test"))
-}
-
-/* mantarget: anontarget */
-const mantarget = {b, p
- addtarg(p, b, "__man__", `Man anontarget(p, "man"))
-}
-
-/* subtarget : anontarget */
-const subtarget = {b, p
- var subs
-
- subs = anontarget(p, "sub")
- for s in subs
- p.subdirs = std.slpush(p.subdirs, std.pathcat(p.fdir, s))
- ;;
-}
-
-
-/* gentarget: wordlist {attrs} = wordlist ;; */
-const gentarget = {b, p
- var outlist, cmdlist
- var durable
- var attrs
- var gt
-
- match wordlist(p)
- | `std.None: failparse(p, "gen target missing output files\n")
- | `std.Some out:
- outlist = out
- ;;
-
- skipspace(p)
- if matchc(p, '{')
- match attrlist(p)
- | `std.Some al: attrs = al
- | `std.None: failparse(p, "invalid attr list for %s\n", outlist[0])
- ;;
- else
- attrs = [][:]
- ;;
-
- skipspace(p)
- if !matchc(p, '=')
- failparse(p, "expected '=' after '%s %s'\n", cmdlist, outlist[outlist.len-1])
- ;;
-
- match wordlist(p)
- | `std.None: failparse(p, "gen target missing command\n")
- | `std.Some cmd:
- cmdlist = cmd
- ;;
-
- if !matchc(p, ';') || !matchc(p, ';')
- failparse(p, "expected ';;' terminating genfile command, got %c\n", peekc(p))
- ;;
-
- durable = false
- for elt in attrs
- match elt
- | ("durable", ""): durable = true
- | ("durable", val): failparse(p, "durable attr does not take argument\n")
- ;;
- ;;
-
- gt = std.mk([
- .dir=std.sldup(p.fdir),
- .out=outlist,
- .durable=durable,
- .cmd=cmdlist
- ])
- for o in outlist
- std.htput(b.gensrc, o, gt)
- addtarg(p, b, o, `Gen gt)
- ;;
-}
-
-/*
-myrtarget: name '=' inputlist ';;'
- | name attrlist = inputlist ';;'
-*/
-const myrtarget = {p, targ
- var ldscript, runtime, inst, incpath
- var name, inputs, libdeps, attrs
- var fsel
-
- match word(p)
- | `std.Some n: name = n
- | `std.None: failparse(p, "expected target name after '%s'\n", targ)
- ;;
-
- skipspace(p)
- if matchc(p, '{')
- match attrlist(p)
- | `std.Some al: attrs = al
- | `std.None: failparse(p, "invalid attr list for %s %s\n", targ, name)
- ;;
- else
- attrs = [][:]
- ;;
-
- skipspace(p)
- if !matchc(p, '=')
- failparse(p, "expected '=' after '%s %s'\n", targ, name)
- ;;
-
- match inputlist(p)
- | `std.Some (wl, libs):
- fsel = mkfsel()
- libdeps = libs
- for w in wl
- fseladd(fsel, w)
- ;;
- inputs = fselfin(fsel)
- std.slfree(wl)
- | `std.None: failparse(p, "expected list of file names after '%s %s'\n", targ, name)
- ;;
-
- skipspace(p)
- if !matchc(p, ';') || !matchc(p, ';')
- failparse(p, "expected ';;' terminating input list, got %c\n", peekc(p))
- ;;
-
- inst = true
- ldscript = ""
- runtime = ""
- incpath = [][:]
- for elt in attrs
- match elt
- | ("ldscript", lds): ldscript = std.sldup(lds)
- | ("runtime", rt): runtime = std.sldup(rt)
- | ("inc", path): incpath = std.slpush(incpath, std.sldup(path))
- | ("noinst", ""): inst = false
- | ("noinst", val): failparse(p, "noinst attr does not take argument\n")
- | (invalid, _):
- std.fatal(1, "%s: got invalid attr '%s'\n", targ, invalid)
- ;;
- ;;
- -> std.mk([
- /* target */
- .dir=std.sldup(p.fdir),
- .name=name,
- .inputs=inputs,
- .libdeps=libdeps,
- /* attrs */
- .install=inst,
- .ldscript=ldscript,
- .runtime=runtime,
- .incpath=incpath,
- .built=false
- ])
-}
-
-/* anontarget: '=' wordlist ';;' */
-const anontarget = {p, targ
- var inputs
-
- inputs = [][:]
- skipspace(p)
- if !matchc(p, '=')
- failparse(p, "expected '=' after '%s' target\n", targ)
- ;;
-
- match wordlist(p)
- | `std.None: failparse(p, "expected list of file names after '%s' target\n", targ)
- | `std.Some wl: inputs = wl
- ;;
- skipspace(p)
- if !matchc(p, ';') || !matchc(p, ';')
- failparse(p, "expected ';;' terminating input list\n")
- ;;
- -> inputs
-}
-
-/*
-attrlist: attrs '}'
-
-attrs : EMPTY
- | attrs attr
-
-attr : name
- | name '=' name
-*/
-const attrlist = {p
- var al
-
- al = [][:]
- while true
- match word(p)
- | `std.Some k:
- skipspace(p)
- if matchc(p, '=')
- match word(p)
- | `std.Some v:
- al = std.slpush(al, (k, v))
- | `std.None:
- failparse(p, "invalid attr in attribute list\n")
- ;;
- else
- al = std.slpush(al, (k, [][:]))
- ;;
- if !matchc(p, ',')
- break
- ;;
- | `std.None: break
- ;;
- ;;
- if !matchc(p, '}')
- failparse(p, "expected '}' at end of attr list, got '%c'\n", peekc(p))
- ;;
- if al.len == 0
- -> `std.None
- else
- -> `std.Some al
- ;;
-}
-
-/*
-inputlist: EMPTY
- | inputlist input
-
-input : word
- | "lib" word
-*/
-const inputlist = {p
- var dir, lib, targ
- var wl, libs
-
- wl = [][:]
- libs = [][:]
- while true
- match word(p)
- | `std.Some "lib":
- match word(p)
- | `std.Some l:
- (dir, lib, targ) = libpath(p, l)
- libs = std.slpush(libs, (dir, lib, targ))
- | `std.None:
- failparse(p, "expected lib name after 'lib'\n")
- ;;
- | `std.Some w: wl = std.slpush(wl, w)
- | `std.None: break
- ;;
- ;;
- if wl.len == 0
- -> `std.None
- else
- -> `std.Some (wl, libs)
- ;;
-}
-
-/* wordlist: EMPTY | wordlist word */
-const wordlist = {p
- var wl
-
- wl = [][:]
- while true
- match word(p)
- | `std.Some w: wl = std.slpush(wl, w)
- | `std.None: break
- ;;
- ;;
- if wl.len == 0
- -> `std.None
- else
- -> `std.Some wl
- ;;
-}
-
-/* word: /wordchar*/
-const word = {p
- var c, n
- var start
-
- skipspace(p)
-
- c = peekc(p)
- if c == '"'
- n = 0
- getc(p)
- start = p.rest
- while p.rest.len > 0
- c = peekc(p)
- if c == '"'
- getc(p)
- goto done
- elif c == '\\'
- c = getc(p)
- ;;
- getc(p)
- n += std.charlen(c)
- ;;
- failparse(p, "input ended within quoted word\n")
- else
- n = 0
- start = p.rest
- while p.rest.len > 0
- c = peekc(p)
- if wordchar(c)
- getc(p)
- n += std.charlen(c)
- else
- break
- ;;
- ;;
- ;;
-:done
- if n > 0
- -> `std.Some std.sldup(start[:n])
- else
- -> `std.None
- ;;
-}
-
-const wordchar = {c
- -> std.isalnum(c) || \
- c == '.' || c == '_' || c == '$' || c == '-' || \
- c == '/' || c == ':' || c == '!' || c == '~' || \
- c == '+'
-}
-
-const skipspace = {p
- var c, r
-
- r = p.rest
- while r.len > 0
- c = peekc(p)
- match c
- | ' ': getc(p)
- | '\t': getc(p)
- | '\n':
- getc(p)
- p.line++
- | '#':
- while p.rest.len > 0 && peekc(p) != '\n'
- getc(p)
- ;;
- | _:
- break
- ;;
- ;;
-}
-
-const matchc = {p, c
- var chr, s
-
- if p.rest.len == 0
- -> false
- ;;
- (chr, s) = std.striter(p.rest)
- if c == chr
- p.rest = s
- -> true
- else
- -> false
- ;;
-}
-
-const peekc = {p
- -> std.decode(p.rest)
-}
-
-const getc = {p
- var c, s
-
- (c, s) = std.striter(p.rest)
- p.rest = s
- -> c
-}
-
-const addtarg = {p, b, name, targ
- var tn
-
- tn = std.fmt("%s:%s", p.fdir, name)
- if std.hthas(b.targs, tn)
- failparse(p, "duplicate target %s\n", tn)
- ;;
- b.all = std.slpush(b.all, tn)
- std.htput(b.targs, tn, targ)
-}
-
-const libpath = {p, libpath
- var dir, lib, targ
-
- match(std.strrfind(libpath, ":"))
- | `std.None:
- dir = std.sldup(".")
- lib = std.sldup(libpath)
- targ = std.fmt("%s:%s", p.fdir, lib)
- | `std.Some idx:
- if idx == libpath.len
- std.fatal(1, "libdep %s missing library after ':'\n")
- ;;
- /* absolute path */
- if std.hasprefix(libpath, "@/") || std.hasprefix(libpath, "@:")
- dir = std.pathcat(p.basedir, libpath[2:idx])
- lib = std.sldup(libpath[idx+1:])
- targ = std.sldup(libpath[2:])
- /* relative path */
- else
- dir = std.sldup(libpath[:idx])
- lib = std.sldup(libpath[idx+1:])
- targ = std.pathcat(p.fdir, libpath)
- if std.hasprefix(targ, "../")
- std.fatal(1, "library %s outside of project\n", libpath)
- ;;
- ;;
- ;;
- -> (dir, lib, targ)
-}
diff --git a/subdir.myr b/subdir.myr
deleted file mode 100644
index 0efd958..0000000
--- a/subdir.myr
+++ /dev/null
@@ -1,23 +0,0 @@
-use std
-
-use "types.use"
-use "util.use"
-
-pkg bld =
- const subdirs : (p : build#, subs : byte[:][:], targ : std.option(byte[:]) -> void)
-;;
-
-const subdirs = {p, subs, targ
- for s in subs
- std.put("Entering directory '%s'\n", s)
- if !std.chdir(s)
- std.fatal(1, "unable to enter directory %s\n", s)
- ;;
- run(p.cmd)
- std.put("Leaving directory '%s'\n", s)
- if !std.chdir("..")
- std.fatal(1, "unable to leave directory %s\n", s)
- ;;
- ;;
-}
-
diff --git a/test.myr b/test.myr
deleted file mode 100644
index 77c6c25..0000000
--- a/test.myr
+++ /dev/null
@@ -1,150 +0,0 @@
-use std
-
-use "build.use"
-use "clean.use"
-use "deps.use"
-use "opts.use"
-use "parse.use"
-use "types.use"
-use "util.use"
-use "subdir.use"
-
-use "config.use"
-
-pkg bld =
- const test : (b : build# -> void)
-;;
-
-const test = {b
- var ok/*, bin */
-
- /* no implicit tests to run */
- ok = true
- if std.fexists("test")
- for tn in b.all
- match gettarg(b.targs, tn)
- | `Bin bt:
- if !dotest(b, bt, ok)
- ok = false
- ;;
- | `Lib lt:
- if !dotest(b, lt, ok)
- ok = false
- ;;
- | _: /* ignore */
- ;;
- ;;
- ;;
- /*
- FIXME: reenable test binaries
- for `Test t in targs
- for s in t.incpath
- if std.sleq(".", s)
- goto founddot
- ;;
- ;;
- t.incpath = std.slpush(t.incpath, std.sldup("."))
-
-:founddot
- buildbin(b, t, false)
- bin = std.strcat("./", t.name)
- if !runtest(bin)
- ok = false
- ;;
- std.slfree(bin)
- ;;
- */
- if ok
- std.put("TESTS PASSED\n")
- else
- std.put("TESTS FAILED\n")
- std.exit(1)
- ;;
-}
-
-const dotest = {b, targ, ok
- var tt, bin ,path, tests
-
- tests = [][:]
- setdir(b, targ.dir)
- for s in targ.inputs
- path = std.pathcat("./test", s)
- if std.fexists(path)
- bin = srcswapsuffix(path, "")
- tt = [
- .name = bin,
- .dir = targ.dir,
- .inputs = [path, s][:],
- .install = false,
- .libdeps = targ.libdeps,
- .incpath = targ.incpath,
- .built = false,
- ]
-
- cleantest(b, path)
- buildbin(b, &tt, true)
- tests = std.slpush(tests, bin)
- ;;
- std.slfree(path)
- ;;
-
- ok = true
- for t in tests
- if !runtest(t)
- ok = false
- ;;
- std.slfree(t)
- ;;
- std.slfree(tests)
- -> ok
-}
-
-const cleantest = {b, src
- var obj, bin, log, usef
-
- obj = srcswapsuffix(src, config.Objsuffix)
- log = srcswapsuffix(src, ".log")
- usef = srcswapsuffix(src, ".use")
- bin = srcswapsuffix(src, "")
-
- std.remove(obj)
- std.remove(usef)
- std.remove(log)
- std.remove(bin)
-
- std.slfree(obj)
- std.slfree(usef)
- std.slfree(log)
- std.slfree(bin)
-}
-
-const runtest = {bin
- var r, log
-
- std.put("run %s:\t", bin)
- log = std.strcat(bin, ".log")
- match std.spork([bin][:])
- | `std.Fail m:
- std.fatal(1, "unable to run test: %s\n", m)
- | `std.Ok (pid, infd, outfd):
- match std.fslurp(outfd)
- | `std.Ok "": /* empty output; nothing to log */
- | `std.Ok buf:
- std.blat(log, buf, 0o644)
- | `std.Fail m:
- ;;
- std.slfree(log)
-
- r = false
- match std.wait(pid)
- | `std.Wfailure: std.put("FAIL\n")
- | `std.Wsignalled: std.put("CRASH\n")
- | `std.Wsuccess:
- std.put("PASS\n")
- r = true
- | _: std.put("???\n")
- ;;
- ;;
- -> r
-}
-
diff --git a/types.myr b/types.myr
deleted file mode 100644
index 90d1d0c..0000000
--- a/types.myr
+++ /dev/null
@@ -1,59 +0,0 @@
-use std
-
-pkg bld =
- type build = struct
- cmd : byte[:][:] /* command that we ran */
- /* build state */
- basedir : byte[:]
- curdir : byte[:]
- /* build params */
- all : byte[:][:]
- targs : std.htab(byte[:], targ)# /* dir => target mapping */
- tdeps : std.htab(byte[:], byte[:][:]) /* targname => depname[:] mapping */
- gensrc : std.htab(byte[:], gentarg#)# /* generated src => generating target mapping */
- prefix : byte[:]
- system : byte[:]
- arch : byte[:]
- ;;
-
-
- type depgraph = struct
- roots : byte[:][:]
- deps : std.htab(byte[:], byte[:][:])#
- libs : std.htab(byte[:], byte[:][:])#
- input : std.htab(byte[:], byte[:])#
- sources : std.htab(byte[:], bool)#
- updated : std.htab(byte[:], bool)#
- seen : std.htab(byte[:], bool)#
- done : std.htab(byte[:], bool)#
- ;;
-
- type myrtarg = struct
- dir : byte[:]
- name : byte[:]
- inputs : byte[:][:]
- libdeps : (byte[:], byte[:], byte[:])[:] /* dir, lib pairs */
- built : bool
- install : bool
- runtime : byte[:]
- incpath : byte[:][:]
- ldscript : byte[:]
- ;;
-
- type gentarg = struct
- dir : byte[:]
- out : byte[:][:]
- cmd : byte[:][:]
- durable : bool
- /* we can have multiple outputs, but we only want to run once for each */
- done : bool
- ;;
-
- type targ = union
- `Bin myrtarg#
- `Lib myrtarg#
- `Test myrtarg#
- `Gen gentarg#
- `Man byte[:][:]
- ;;
-;;
diff --git a/util.myr b/util.myr
deleted file mode 100644
index 57872b1..0000000
--- a/util.myr
+++ /dev/null
@@ -1,123 +0,0 @@
-use std
-
-use "opts.use"
-use "types.use"
-
-pkg bld =
- const run : (cmd : byte[:][:] -> void)
- const printcmd
- const srcsplit : (src : byte[:] -> (byte[:], byte[:], byte[:]))
- const swapsuffix : (f : byte[:], suff : byte[:], newsuff : byte[:] -> byte[:])
- const srcswapsuffix : (f : byte[:], newsuff : byte[:] -> byte[:])
- const strlistfree : (sl : byte[:][:] -> void)
- const gettarg : (tab : std.htab(byte[:], targ)#, n : byte[:] -> targ)
- const setdir : (b : build#, dir : byte[:] -> void)
-;;
-
-const run = {cmd
- var pid
-
- printcmd(cmd)
- pid = std.fork()
- if pid == -1
- std.fatal(1, "could not fork command\n")
- elif pid == 0
- if std.execvp(cmd[0], cmd) < 0
- std.fatal(1, "failed to exec %s\n", cmd[0])
- ;;
- else
- match std.wait(pid)
- | `std.Wsuccess: /* nothing */
- | `std.Wfailure: std.fatal(1, "FAIL: \"%s\"\n", std.strjoin(cmd, " "))
- | `std.Wsignalled: std.fatal(1, "CRASH: \"%s\"\n", std.strjoin(cmd, " "))
- | `std.Waiterror: std.fatal(1, "WAT: \"%s\"\n", std.strjoin(cmd, " "))
- ;;
- ;;
-}
-
-const printcmd = {lst
- if lst.len > 0
- std.put("\t")
- std.put("%s\t", lst[0])
- for l in lst[1:]
- std.put("%s ", l)
- ;;
- ;;
- std.put("\n")
-}
-
-const srcsplit = {src
- var platf, suff
-
- platf = ""
- suff = ""
- match std.strrfind(src, ".")
- | `std.Some i:
- suff = src[i:]
- src = src[:i]
- | `std.None:
- /* no suffix to trim */
- ;;
-
- match std.strrfind(src, "+")
- | `std.Some i:
- platf = src[i:]
- src = src[:i]
- | `std.None:
- /* no platform to trim */
- ;;
- -> (src, platf, suff)
-}
-
-const swapsuffix = {f, suff, newsuff
- if std.hassuffix(f, suff)
- f = f[:f.len - suff.len]
- ;;
- -> std.fmt("%s%s", f, newsuff)
-}
-
-const srcswapsuffix = {src, new
- var base, platf, suff
-
- (base, platf, suff) = srcsplit(src)
- if std.sleq(suff, ".myr")
- -> std.strcat(base, new)
- elif std.sleq(suff, ".s")
- -> std.strcat(base, new)
- else
- std.fatal(1, "unrecognized source %s\n", src)
- ;;
-}
-
-const strlistfree = {sl
- for s in sl
- std.slfree(s)
- ;;
- std.slfree(sl)
-}
-
-const gettarg = {tab, n
- match std.htget(tab, n)
- | `std.None: std.fatal(1, "internal: nonexistent %s\n", n)
- | `std.Some t: -> t
- ;;
-}
-
-const setdir = {b, dir
- var p
-
- if !std.sleq(b.curdir, dir)
- p = std.pathcat(b.basedir, dir)
- if b.curdir.len != 0
- std.put("Leaving directory %s\n", b.curdir)
- ;;
-
- std.put("Entering directory '%s'\n", dir)
- if !std.chdir(p)
- std.fatal(1, "could not cd into %s\n")
- ;;
- b.curdir = dir
- std.slfree(p)
- ;;
-}
-