summaryrefslogtreecommitdiff
path: root/main.myr
blob: efe1f4b2abdbeb1a1e105f05130f6a67c6238b13 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
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 = std.sldup(path)
	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)
}