shithub: mc

ref: 3456a5b71887bb64aa8eac957a287a78b8ce9f28
dir: /main.myr/

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 p : bld.parser#
	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")
	;;

	if targname.len != 0
		mt = [
			.name=targname,
			.inputs=optctx.args,
			.runtime=bld.opt_runtime,
			.incpath=bld.opt_incpaths,
			.ldscript=bld.opt_ldscript,
			.libdeps=[][:]
		]
		p = mkparser("cli")
		if bintarg
			bld.buildbin(p, &mt, true)
		else
			bld.buildlib(p, &mt)
		;;
		std.free(p)
	else
		p = loadbuild(bld.opt_bldfile)
		p.cmd = args
		/*bld.configure()*/
		/* default: buildall */
		if optctx.args.len == 0
			bld.buildall(p)
		else
			for cmd in optctx.args
				match cmd
				| "all":	bld.buildall(p)
				| "gen":	bld.genall(p)
				| "clean":	bld.cleanall(p)
				| "install":	bld.install(p)
				| "uninstall":	bld.uninstall(p)
				| "test":	bld.test(p)
				| target:	bld.build(p, target)
				;;
			;;
		;;
	;;
}

const loadbuild =  {path
	var p

	p = mkparser(path)
	match std.slurp(path)
	| `std.Ok d:	p.data = d
	| `std.Fail _:	std.fatal(1, "could not open file 'bldfile'\n")
	;;
	p.rest = p.data
	bld.parse(p)

	-> p
}

const mkparser = {path
	var p

	p = std.zalloc()
	p.line = 1
	p.fname = "cli"
	p.gensrc = std.mkht(std.strhash, std.streq)
	-> p
}

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)
}