shithub: mc

ref: 285be77897e18d68efede25a98f423bddd4f2cb9
dir: /mbld/opts.myr/

use std
use thread

use "config"

pkg bld =
	var opt_arch 		: byte[:]
	var opt_sys		: byte[:]
	var opt_sysvers		: (int, int, int)
	var opt_cpufeatures	: uint64
	var opt_runtime		: byte[:]
	var opt_genasm		: bool
	var opt_incpaths	: byte[:][:]
	var opt_alltags		: byte[:][:]
	var opt_mcflags		: byte[:][:]
	var opt_museflags	: byte[:][:]
	var opt_ldflags		: byte[:][:]
	var opt_instbase	: byte[:]
	var opt_destdir		: byte[:]
	var opt_objdir		: byte[:]
	var opt_maxproc 	: std.size
	var opt_debug		: bool
	var opt_verbosity	: int

	/* undocumented/unsupported opts */
	var opt_mc	: byte[:]
	var opt_muse	: byte[:]

	var sysarchstr	: byte[:]
	var archstr	: byte[:]
	var sysstr	: byte[:]

	const initopts	: (-> void)
	const parseversion	: (v : byte[:] -> (int, int, int))

	/* not exactly portable, but good enough for now */
	const CpuidSSE2 : uint64= 0x400000000000000
	const CpuidSSE4 : uint64= 0x180000

	/*
	   Intel manuals (vol 1, 14.5.3) say AVX, OSXSAVE also
	   needed. For full portability, XGETBV also needs to be
	   checked, though it isn't right now.
	 */
	const CpuidFMA  : uint64= 0x18001000
	extern const cpufeatures : (-> uint64)
;;

var opt_arch 		= ""
var opt_sys		= ""
var opt_binname		= ""
var opt_cpufeatures	= 0ul
var opt_libname		= ""
var opt_runtime		= ""
var opt_incpaths	= [][:]
var opt_instbase	= ""
var opt_destdir		= ""
var opt_sysvers
var opt_debug		= false
var opt_mc		= "6m"
var opt_as		= "as"
var opt_muse		= "muse"
var opt_mcflags		= [][:]
var opt_museflags	= [][:]
var opt_ldflags		= [][:]
var opt_alltags		= [][:]
var opt_objdir		= "obj"
var opt_genasm  	= false
var opt_verbosity	= 0
var opt_maxproc 	= 1

const initopts = {
	var si

	std.getsysinfo(&si)
	match si.system
	| "Linux":	opt_sys = "linux"
	| "Darwin":	opt_sys = "osx"
	| "FreeBSD":	opt_sys = "freebsd"
	| "NetBSD":	opt_sys = "netbsd"
	| "OpenBSD":	opt_sys = "openbsd"
	| "Plan9":	opt_sys = "plan9"
	| unknown:	std.fatal("unknown system \"{}\"\n", unknown)
	;;

	opt_sysvers = parseversion(si.release)

	match si.arch
	| "x86_64":	opt_arch = "x64"
	| "amd64":	opt_arch = "x64"
	| unknown:	std.fatal("unknown architecture \"{}\"\n", unknown)
	;;

	/* from cpuid with EAX=1; EDX at top, ECX at bottom */
	opt_cpufeatures = cpufeatures()

	opt_maxproc = 2*(thread.ncpu() : std.size)
	opt_instbase = config.Instroot
	opt_destdir = std.getenvv("DESTDIR", "")
	opt_mc = std.getenvv("MYR_MC", "6m")
	opt_muse = std.getenvv("MYR_MUSE", "muse")
	opt_runtime = std.getenvv("MYR_RT", "")
	match std.getenv("MYR_MCFLAGS")
	| `std.Some s:	opt_mcflags = std.strtok(s)
	| `std.None:	/* ok */
	;;
	match std.getenv("MYR_MUSEFLAGS")
	| `std.Some s:	opt_mcflags = std.strtok(s)
	| `std.None:	/* ok */
	;;
	match std.getenv("MYR_LDFLAGS")
	| `std.Some s:	opt_ldflags = std.strtok(s)
	| `std.None:	/* ok */
	;;
	if opt_runtime.len == 0
		opt_runtime = std.pathjoin([opt_instbase, config.Libpath, config.Runtime][:]) 
	;;
}

const parseversion = {v
	var a
	var i

	i = 0
	a = [0, 0, 0]
	for e : std.bysplit(v, ".")
		match std.intparse(e)
		| `std.Some n:	a[i++] = n
		| `std.None:	continue
		;;
		if i == 3
			break
		;;
	;;
	-> (a[0], a[1], a[2])
}