bootstrap.ngs

# === Exception ==================================

doc Initialize an Exception.
doc %RET - Exception with .backtrace and .message
doc message - Goes into .message
F init(e:Exception, message:Str) {
	e.message = message
}

doc Initialize an Exception.
doc %RET - Exception with .backtrace and .cause
F init(e:Exception, cause:Exception) {
	e.cause = cause
}

doc Initialize an Exception.
doc %RET - Exception with .backtrace, .message, and .cause
F init(e:Exception, message:Str, cause:Exception) {
	e.message = message
	e.cause = cause
}

{
	type NotImplemented; NotImplemented.inherit(Exception)
	type ReadFail; ReadFail.inherit(Exception)
	type RequireFail; RequireFail.inherit(Exception)
	type MainFail; MainFail.inherit(Exception)

	doc Represents error when converting program execution result to exit code
	type ExitCodeFail; ExitCodeFail.inherit(Exception)

	doc Information about exiting, used by bootstrap and as argument to exit_hook.
	doc exit_code - the code to exit with
	doc exceptions - exceptions that occurred during exit procedure
	type Exit
}

# === bootstrap ==================================

# *** Convert values returned by the program (or -e/-E expression) to exit codes ***
doc %RET - always 0
F ExitCode(x) 0

doc %RET - 0 for true, 1 for false
F ExitCode(b:Bool) if b 0 1

doc %RET - n
F ExitCode(n:Int) n

doc %RET - Always 240
F ExitCode(e:Exception) 240

doc Create MultiMethod with no methods
F MultiMethod() super([])

doc Number of methods in MultiMethod
F len(mm:MultiMethod) mm.Arr().len()

doc Whether MultiMethod has any methods
F Bool(mm:MultiMethod) mm.Arr().Bool()

main = MultiMethod()

# *** Define bootstrap_debug function ***
bootstrap_debug =
	if 'NGS_BOOTSTRAP_DEBUG' in ENV
		F(s) echo(2, "+ [BOOSTRAP DEBUG] $s")
	else
		F(s) {}

bootstrap_ngs_dir_candidates = [
	'/usr/local/etc/ngs'
	'/usr/local/lib/ngs'
	'/etc/ngs'
	'/usr/lib/ngs'
]

doc Internal method. Please do not use.
doc Find which of bootstrap_ngs_dir_candidates directories contains stdlib.ngs . That directory would be the "NGS_DIR".
doc %RET - Str or null
doc %STATUS - internal
F bootstrap_find_ngs_dir() {
	'NGS_DIR' in ENV returns ENV['NGS_DIR']
	l = bootstrap_ngs_dir_candidates.len()
	for(i;l) {
		c_access("${bootstrap_ngs_dir_candidates[i]}/stdlib.ngs", ACCESS['F_OK']) == 0 returns bootstrap_ngs_dir_candidates[i]
	}
	null
}

# *** read - abstraction above low level c io primitives ***
# TODO: Better exceptions
doc Fetches the whole file
doc fname - File name to read
doc %RET - Whole file as a string
F read(fname:Str) {
	try {
		fd = c_open(fname, 'r')
		fd <= 0 throws Exception("read(): failed to open file ${fname}")
		bootstrap_debug("read(): opened file ${fname} as fd ${fd}")
		file_len = c_lseek(fd, 0, "end")
		file_len < 0 throws Exception("read(): failed to get the size of file ${fname}")
		c_lseek(fd, 0, "set")
		bootstrap_debug("read(): file size of ${fname} is ${file_len}")
		data = c_read(fd, file_len)
		c_close(fd)
		data[1]
	} catch(e) {
		throw ReadFail(e)
	}
}



F bootstrap_print_compilation_warnings(program_bytecode, fname) {

	warnings = program_bytecode.attrs()['warnings']
	l = warnings.len()
	for(i;l) {
		w = warnings[i]
		wl = w['location']
		echo(2, "${fname}:${wl['first_line']}:${wl['first_column']} warning: ${w['message']}")
	}
}

doc Runs the given file
doc %RET - Typically whatever the last expression in the file evaluates to
F require(fname:Str) {
	try {
		program_text = read(fname)
		program_bytecode = compile(program_text, fname)
		bootstrap_debug("require(): bytecode for ${fname} has length of ${program_bytecode.len()} bytes")
		bootstrap_print_compilation_warnings(program_bytecode, fname)
		program_func = load(program_bytecode, "require()d file: $fname")
		ret = program_func()
		bootstrap_debug("require(): done requiring ${fname}")
		ret
	} catch(e) {
		throw RequireFail(e)
	}
}

doc Internal method. Please do not use.
doc Main entry point. Executed on NGS boot.
doc %STATUS - internal
F bootstrap() {
	global ARGV0
	global ORIG_ARGV = copy(ARGV)

	do_load_stdlib = true
	code_to_run = null

	bootstrap_debug('bootstrap.ngs begin')
	bootstrap_debug("BOOTSTRAP_FILE=$BOOTSTRAP_FILE")

	# *** Prepare ARGV ***
	# first_item = shift(array, default_value_if_array_is_empty)
	ARGV0 = ARGV.shift(null)

	# *** Parse switches ***
	sw = null
	if ARGV {
		a = ARGV[0]
		if (a == '--version') {
			echo(VERSION)
			return 0
		}
		if (a == '-e' or a == '-E' or a == '-p' or a == '-pj' or a == '-pi' or a == '-pl' or a == '-pil' or a == '-pjl' or a == '-pc' or a == '-pt') {
			sw = ARGV.shift()
			# Newline at the end is for avoiding # commenting out the closing }
			# Newline at the beginning is for symmetry
			default_code = 'F default_argv_code() { fetch() }()'
			code_to_run = "{\n${ARGV.shift(default_code)}\n}"
			bootstrap_debug("Got $sw switch, using command line provided code")
			if sw == '-E' {
				bootstrap_debug('Will skip loading stdlib because of -E flag')
				do_load_stdlib = false
			}
			fname = "<command line ${sw} switch>"
		}
	}

	if 'NGS_SKIP_STDLIB' in ENV {
		bootstrap_debug('Will skip loading stdlib because of set NGS_SKIP_STDLIB environment variable')
		do_load_stdlib = false
	}

	global NGS_DIR = bootstrap_find_ngs_dir()

	NGS_DIR is Null throws Exception("Could not find NGS_DIR")

	if do_load_stdlib {
		bootstrap_debug('Will load stdlib')
		stdlib_file = "${NGS_DIR}/stdlib.ngs"
		bootstrap_debug("Stdlib is at $stdlib_file")
		require(stdlib_file)
	}

	# Note: not() is not defined yet

	if code_to_run is Null {
		bootstrap_debug('No -e or -E switch was passed, will load the program from a file')
		fname = ARGV.shift(null)
		if fname is Null {
			fname = ENV.get('NGS_CLI', "${NGS_DIR}/cli.ngs")
		} else {
			ARGV0 = fname
		}
		code_to_run = read(fname)
	}

	program_bytecode = compile(code_to_run, fname)
	bootstrap_debug("bootstrap(): bytecode for ${fname} has length of ${program_bytecode.len()} bytes")
	bootstrap_print_compilation_warnings(program_bytecode, fname)
	program_func = load(program_bytecode, "bootstrap()ped file: $fname")

	result = program_func()

	# Handle main() - start
	if main.len() > 0 {
		bootstrap_debug("main() defined, using bootstrap_invoke_main()")
		if global_not_found_handler.len() == 0 {
			throw MainFail("Autoloading (usually defined in stdlib) is not present but the main() invoking mechanism requires it")
		}
		result = bootstrap_invoke_main(fname, result)
	}
	# Handle main() - end

	if sw == '-E' {
	} else {

		transformation = {
			'-pl': identity
			'-pil': inspect
			'-pjl': encode_json
		}
		if sw in transformation {
			for r in result {
				transformation[sw](r).echo()
			}
			return 0
		}

		transformation = {
			'-p': identity
			'-pi': inspect
			'-pj': encode_json
			'-pc': code
			'-pt': { Table2::Table(A) }
		}
		if sw in transformation {
			echo(transformation[sw](result))
			return 0
		}
	}
	result.ExitCode()
}

doc Uses built-in dump() to show an exception. Only used if stdlib is not loaded (stdlib defines better method).
F print_exception(e:Exception) {
	dump(exception)
}

doc Prints exceptions. Only used if stdlib is not loaded (stdlib changes exit_hook to a Hook object).
F exit_hook(exit:Exit) {
	for(i; exit.exceptions.len()) {
		echo(2, "[exit_hook] --- Uncaught exception ---")
		print_exception(exit.exceptions[i])
	}
}

doc Internal method. Please do not use.
doc Runs bootstrap() and handles exceptions.
doc %STATUS - internal
F bootstrap_exception_catch_wrapper() {
	exit = Exit()
	exit.exit_code = 0
	exit.exceptions = []
	try {
		exit.exit_code = bootstrap()
	} catch(e:Exception) {
		exit.exceptions.push(e)
		exit.exit_code = 240
		try {
			exit.exit_code = e.ExitCode()
		} catch(e:Exception) {
			exit.exceptions.push(ExitCodeFail("Failed to convert exception to exit code", e))
			exit.exit_code = exit.exit_code + 1
		}
	}

	try {
		exit_hook(exit)
	} catch(e:Exception) {
		exit.exceptions.push(e)
		exit.exit_code = exit.exit_code + 2
		for(i; exit.exceptions.len()) {
			echo(2, "[bootstrap_exception_catch_wrapper] --- Uncaught exception ---")
			dump(exit.exceptions[i])
		}
	}

	c_exit(exit.exit_code)
}

bootstrap_exception_catch_wrapper()