args.myr

/*
	Command line flag handling library, respects -- to end flags

	Styled after the Inferno arg.m as per http://man.cat-v.org/inferno/2/arg
*/

use std


pkg args =
	const init		: (args : byte[:][:] -> void)		// Must be called first
	const setusage	: (str : byte[:] -> void)
	const usage		: (-> void)
	const opt		: (-> char)
	const earg		: (-> byte[:])
	const progname	: (-> byte[:])
	const argv		: (-> byte[:][:])
;;


var initialized	= false				// Has the lib been init()'d ?
var done		= false				// Are we done parsing ?
var usagestr						// String to print after usage:
var argv0		: byte[:]			// The argv[0] program name
var argen		: byte[:][:]		// The arguments argv[1:]
var i			= 0					// Position in argv


// Initializes the argument library
const init = {args : byte[:][:]
	if initialized
		-> void
	;;

	initialized = true

	/* Ingest arguments */
	if ! (args.len > 0)
		-> void
	;;

	argv0 = args[0]

	if ! (args.len > 1)
		-> void
	;;

	argen = args[1:]
}

// Sets the library usage string
const setusage = {str : byte[:]
	initcheck()

	usagestr = std.fmt("usage: {}\n", str)
}

// Emits and exits for usage
const usage = {
	initcheck()

	std.fatal(usagestr)
}

// Emits the next flag character in the flag chain
const opt = {
	initcheck()

	// If we hit --, stop parsing
	match argen[i]
	| "--":
		done = true
	| _:
		;
	;;

	// Conditions for not yielding a character
	if done || i >= argen.len || argen[i].len < 2 || argen[i][0] != ('-' : byte)
		-> (0 : char)
	;;

	-> (argen[i++][1] : char)
}

// Returns the current argument which must not be nil
const earg = {
	initcheck()

	// If we hit --, stop parsing
	match argen[i]
	| "--":
		done = true
	| _:
		;
	;;

	if done || argen[i].len < 1 || i >= argen.len
		usage()
	;;

	// So we avoid parsing out a flag, use -- to avoid this?
	if argen[i][0] == ('-' : byte)
		usage()
	;;

	-> argen[i++]
}

// Returns the argv0 of the input, our program name
const progname = {
	initcheck()

	-> argv0
}

// Print remaining arguments
const argv = {
	-> argen[i:]
}

// Verifies if init() has been called
const initcheck = {
	if !initialized
		std.fatal("err: must call args.init() first\n")
	;;
}