lualoader: Drop terminating semicolons

This was previously chosen out of convenience, as we had a mixed style and
needed to be consistent. I started learning Lua on Friday, so I switched
everything over. It is not a very lua-nic convention, though, so drop it.

Excessive parenthesizing around conditionals is next on the chopping block.

stand/lua/color.lua

@@ -26,74 +26,74 @@
 -- $FreeBSD$
 --
 
-local core = require("core");
+local core = require("core")
 
-local color = {};
+local color = {}
 
 -- Module exports
-color.BLACK   = 0;
+color.BLACK   = 0
-color.RED     = 1;
+color.RED     = 1
-color.GREEN   = 2;
+color.GREEN   = 2
-color.YELLOW  = 3;
+color.YELLOW  = 3
-color.BLUE    = 4;
+color.BLUE    = 4
-color.MAGENTA = 5;
+color.MAGENTA = 5
-color.CYAN    = 6;
+color.CYAN    = 6
-color.WHITE   = 7;
+color.WHITE   = 7
 
-color.DEFAULT = 0;
+color.DEFAULT = 0
-color.BRIGHT  = 1;
+color.BRIGHT  = 1
-color.DIM     = 2;
+color.DIM     = 2
 
 function color.isEnabled()
-	local c = loader.getenv("loader_color");
+	local c = loader.getenv("loader_color")
 	if (c ~= nil) then
 		if (c:lower() == "no") or (c == "0") then
-			return false;
+			return false
 		end
 	end
-	return (not core.isSerialBoot());
+	return (not core.isSerialBoot())
 end
 
-color.disabled = (not color.isEnabled());
+color.disabled = (not color.isEnabled())
 
 function color.escapef(c)
 	if (color.disabled) then
-		return c;
+		return c
 	end
-	return "\027[3" .. c .. "m";
+	return "\027[3" .. c .. "m"
 end
 
 function color.escapeb(c)
 	if (color.disabled) then
-		return c;
+		return c
 	end
-	return "\027[4" .. c .. "m";
+	return "\027[4" .. c .. "m"
 end
 
 function color.escape(fg, bg, att)
 	if (color.disabled) then
-		return "";
+		return ""
 	end
 	if (not att) then
 		att = ""
 	else
-		att = att .. ";";
+		att = att .. ";"
 	end
-	return "\027[" .. att .. "3" .. fg .. ";4" .. bg .. "m";
+	return "\027[" .. att .. "3" .. fg .. ";4" .. bg .. "m"
 end
 
 function color.default()
 	if (color.disabled) then
-		return "";
+		return ""
 	end
-	return "\027[0;37;40m";
+	return "\027[0;37;40m"
 end
 
 function color.highlight(str)
 	if (color.disabled) then
-		return str;
+		return str
 	end
-	return "\027[1m" .. str .. "\027[0m";
+	return "\027[1m" .. str .. "\027[0m"
 end
 
-return color;
+return color

stand/lua/config.lua

@@ -27,12 +27,12 @@
 -- $FreeBSD$
 --
 
-local config = {};
+local config = {}
 
-local modules = {};
+local modules = {}
 
-local pattern_table;
+local pattern_table
-local carousel_choices = {};
+local carousel_choices = {}
 
 pattern_table = {
 	[1] = {
@@ -44,51 +44,51 @@ pattern_table = {
 		str = "^%s*([%w_]+)_load%s*=%s*\"([%w%s%p]-)\"%s*(.*)",
 		process = function(k, v)
 			if (modules[k] == nil) then
-				modules[k] = {};
+				modules[k] = {}
 			end
-			modules[k].load = v:upper();
+			modules[k].load = v:upper()
 		end
 	},
 	--  module_name="value"
 	[3] = {
 		str = "^%s*([%w_]+)_name%s*=%s*\"([%w%s%p]-)\"%s*(.*)",
 		process = function(k, v)
-			config.setKey(k, "name", v);
+			config.setKey(k, "name", v)
 		end
 	},
 	--  module_type="value"
 	[4] = {
 		str = "^%s*([%w_]+)_type%s*=%s*\"([%w%s%p]-)\"%s*(.*)",
 		process = function(k, v)
-			config.setKey(k, "type", v);
+			config.setKey(k, "type", v)
 		end
 	},
 	--  module_flags="value"
 	[5] = {
 		str = "^%s*([%w_]+)_flags%s*=%s*\"([%w%s%p]-)\"%s*(.*)",
 		process = function(k, v)
-			config.setKey(k, "flags", v);
+			config.setKey(k, "flags", v)
 		end
 	},
 	--  module_before="value"
 	[6] = {
 		str = "^%s*([%w_]+)_before%s*=%s*\"([%w%s%p]-)\"%s*(.*)",
 		process = function(k, v)
-			config.setKey(k, "before", v);
+			config.setKey(k, "before", v)
 		end
 	},
 	--  module_after="value"
 	[7] = {
 		str = "^%s*([%w_]+)_after%s*=%s*\"([%w%s%p]-)\"%s*(.*)",
 		process = function(k, v)
-			config.setKey(k, "after", v);
+			config.setKey(k, "after", v)
 		end
 	},
 	--  module_error="value"
 	[8] = {
 		str = "^%s*([%w_]+)_error%s*=%s*\"([%w%s%p]-)\"%s*(.*)",
 		process = function(k, v)
-			config.setKey(k, "error", v);
+			config.setKey(k, "error", v)
 		end
 	},
 	--  exec="command"
@@ -96,7 +96,7 @@ pattern_table = {
 		str = "^%s*exec%s*=%s*\"([%w%s%p]-)\"%s*(.*)",
 		process = function(k, v)
 			if (loader.perform(k) ~= 0) then
-				print("Failed to exec '" .. k .. "'");
+				print("Failed to exec '" .. k .. "'")
 			end
 		end
 	},
@@ -106,7 +106,7 @@ pattern_table = {
 		process = function(k, v)
 			if (config.setenv(k, v) ~= 0) then
 				print("Failed to set '" .. k ..
-				    "' with value: " .. v .. "");
+				    "' with value: " .. v .. "")
 			end
 		end
 	},
@@ -116,113 +116,113 @@ pattern_table = {
 		process = function(k, v)
 			if (config.setenv(k, v) ~= 0) then
 				print("Failed to set '" .. k ..
-				    "' with value: " .. v .. "");
+				    "' with value: " .. v .. "")
 			end
 		end
 	}
-};
+}
 
 -- Module exports
 -- Which variables we changed
-config.env_changed = {};
+config.env_changed = {}
 -- Values to restore env to (nil to unset)
-config.env_restore = {};
+config.env_restore = {}
 
 -- The first item in every carousel is always the default item.
 function config.getCarouselIndex(id)
-	local val = carousel_choices[id];
+	local val = carousel_choices[id]
 	if (val == nil) then
-		return 1;
+		return 1
 	end
-	return val;
+	return val
 end
 
 function config.setCarouselIndex(id, idx)
-	carousel_choices[id] = idx;
+	carousel_choices[id] = idx
 end
 
 function config.restoreEnv()
 	-- Examine changed environment variables
 	for k, v in pairs(config.env_changed) do
-		local restore_value = config.env_restore[k];
+		local restore_value = config.env_restore[k]
 		if (restore_value == nil) then
 			-- This one doesn't need restored for some reason
-			goto continue;
+			goto continue
 		end
-		local current_value = loader.getenv(k);
+		local current_value = loader.getenv(k)
 		if (current_value ~= v) then
 			-- This was overwritten by some action taken on the menu
 			-- most likely; we'll leave it be.
-			goto continue;
+			goto continue
 		end
-		restore_value = restore_value.value;
+		restore_value = restore_value.value
 		if (restore_value ~= nil) then
-			loader.setenv(k, restore_value);
+			loader.setenv(k, restore_value)
 		else
-			loader.unsetenv(k);
+			loader.unsetenv(k)
 		end
 		::continue::
 	end
 
-	config.env_changed = {};
+	config.env_changed = {}
-	config.env_restore = {};
+	config.env_restore = {}
 end
 
 function config.setenv(k, v)
 	-- Track the original value for this if we haven't already
 	if (config.env_restore[k] == nil) then
-		config.env_restore[k] = {value = loader.getenv(k)};
+		config.env_restore[k] = {value = loader.getenv(k)}
 	end
 
-	config.env_changed[k] = v;
+	config.env_changed[k] = v
 
-	return loader.setenv(k, v);
+	return loader.setenv(k, v)
 end
 
 function config.setKey(k, n, v)
 	if (modules[k] == nil) then
-		modules[k] = {};
+		modules[k] = {}
 	end
-	modules[k][n] = v;
+	modules[k][n] = v
 end
 
 function config.lsModules()
-	print("== Listing modules");
+	print("== Listing modules")
 	for k, v in pairs(modules) do
-		print(k, v.load);
+		print(k, v.load)
 	end
-	print("== List of modules ended");
+	print("== List of modules ended")
 end
 
 
 function config.isValidComment(c)
 	if (c ~= nil) then
-		local s = c:match("^%s*#.*");
+		local s = c:match("^%s*#.*")
 		if (s == nil) then
-			s = c:match("^%s*$");
+			s = c:match("^%s*$")
 		end
 		if (s == nil) then
-			return false;
+			return false
 		end
 	end
-	return true;
+	return true
 end
 
 function config.loadmod(mod, silent)
-	local status = true;
+	local status = true
 	for k, v in pairs(mod) do
 		if (v.load == "YES") then
-			local str = "load ";
+			local str = "load "
 			if (v.flags ~= nil) then
-				str = str .. v.flags .. " ";
+				str = str .. v.flags .. " "
 			end
 			if (v.type ~= nil) then
-				str = str .. "-t " .. v.type .. " ";
+				str = str .. "-t " .. v.type .. " "
 			end
 			if (v.name ~= nil) then
-				str = str .. v.name;
+				str = str .. v.name
 			else
-				str = str .. k;
+				str = str .. k
 			end
 
 			if (v.before ~= nil) then
@@ -231,21 +231,21 @@ function config.loadmod(mod, silent)
 						print("Failed to execute '" ..
 						    v.before ..
 						    "' before loading '" .. k ..
-						    "'");
+						    "'")
 					end
-					status = false;
+					status = false
 				end
 			end
 
 			if (loader.perform(str) ~= 0) then
 				if (not silent) then
 					print("Failed to execute '" .. str ..
-					    "'");
+					    "'")
 				end
 				if (v.error ~= nil) then
-					loader.perform(v.error);
+					loader.perform(v.error)
 				end
-				status = false;
+				status = false
 			end
 
 			if (v.after ~= nil) then
@@ -254,211 +254,211 @@ function config.loadmod(mod, silent)
 						print("Failed to execute '" ..
 						    v.after ..
 						    "' after loading '" .. k ..
-						    "'");
+						    "'")
 					end
-					status = false;
+					status = false
 				end
 			end
 
 		else
 			-- if not silent then
-				-- print("Skiping module '". . k .. "'");
+				-- print("Skiping module '". . k .. "'")
 			-- end
 		end
 	end
 
-	return status;
+	return status
 end
 
 function config.parse(name, silent)
-	local f = io.open(name);
+	local f = io.open(name)
 	if (f == nil) then
 		if (not silent) then
-			print("Failed to open config: '" .. name .. "'");
+			print("Failed to open config: '" .. name .. "'")
 		end
-		return false;
+		return false
 	end
 
-	local text;
+	local text
-	local r;
+	local r
 
-	text, r = io.read(f);
+	text, r = io.read(f)
 
 	if (text == nil) then
 		if (not silent) then
-			print("Failed to read config: '" .. name .. "'");
+			print("Failed to read config: '" .. name .. "'")
 		end
-		return false;
+		return false
 	end
 
-	local n = 1;
+	local n = 1
-	local status = true;
+	local status = true
 
 	for line in text:gmatch("([^\n]+)") do
 		if (line:match("^%s*$") == nil) then
-			local found = false;
+			local found = false
 
 			for i, val in ipairs(pattern_table) do
-				local k, v, c = line:match(val.str);
+				local k, v, c = line:match(val.str)
 				if (k ~= nil) then
-					found = true;
+					found = true
 
 					if (config.isValidComment(c)) then
-						val.process(k, v);
+						val.process(k, v)
 					else
 						print("Malformed line (" .. n ..
-						    "):\n\t'" .. line .. "'");
+						    "):\n\t'" .. line .. "'")
-						status = false;
+						status = false
 					end
 
-					break;
+					break
 				end
 			end
 
 			if (found == false) then
 				print("Malformed line (" .. n .. "):\n\t'" ..
-				    line .. "'");
+				    line .. "'")
-				status = false;
+				status = false
 			end
 		end
-		n = n + 1;
+		n = n + 1
 	end
 
-	return status;
+	return status
 end
 
 -- other_kernel is optionally the name of a kernel to load, if not the default
 -- or autoloaded default from the module_path
 function config.loadkernel(other_kernel)
-	local flags = loader.getenv("kernel_options") or "";
+	local flags = loader.getenv("kernel_options") or ""
-	local kernel = other_kernel or loader.getenv("kernel");
+	local kernel = other_kernel or loader.getenv("kernel")
 
 	local try_load = function (names)
 		for name in names:gmatch("([^;]+)%s*;?") do
-			r = loader.perform("load " .. flags .. " " .. name);
+			r = loader.perform("load " .. flags .. " " .. name)
 			if (r == 0) then
-				return name;
+				return name
 			end
 		end
-		return nil;
+		return nil
 	end
 
 	local load_bootfile = function()
-		local bootfile = loader.getenv("bootfile");
+		local bootfile = loader.getenv("bootfile")
 
 		-- append default kernel name
 		if (bootfile == nil) then
-			bootfile = "kernel";
+			bootfile = "kernel"
 		else
-			bootfile = bootfile .. ";kernel";
+			bootfile = bootfile .. ";kernel"
 		end
 
-		return try_load(bootfile);
+		return try_load(bootfile)
 	end
 
 	-- kernel not set, try load from default module_path
 	if (kernel == nil) then
-		local res = load_bootfile();
+		local res = load_bootfile()
 
 		if (res ~= nil) then
 			-- Default kernel is loaded
-			config.kernel_loaded = nil;
+			config.kernel_loaded = nil
-			return true;
+			return true
 		else
-			print("No kernel set, failed to load from module_path");
+			print("No kernel set, failed to load from module_path")
-			return false;
+			return false
 		end
 	else
 		-- Use our cached module_path, so we don't end up with multiple
 		-- automatically added kernel paths to our final module_path
-		local module_path = config.module_path;
+		local module_path = config.module_path
-		local res = nil;
+		local res = nil
 
 		if (other_kernel ~= nil) then
-			kernel = other_kernel;
+			kernel = other_kernel
 		end
 		-- first try load kernel with module_path = /boot/${kernel}
 		-- then try load with module_path=${kernel}
-		local paths = {"/boot/" .. kernel, kernel};
+		local paths = {"/boot/" .. kernel, kernel}
 
 		for k,v in pairs(paths) do
-			loader.setenv("module_path", v);
+			loader.setenv("module_path", v)
-			res = load_bootfile();
+			res = load_bootfile()
 
 			-- succeeded, add path to module_path
 			if (res ~= nil) then
-				config.kernel_loaded = kernel;
+				config.kernel_loaded = kernel
 				if (module_path ~= nil) then
 					loader.setenv("module_path", v .. ";" ..
-					    module_path);
+					    module_path)
 				end
-				return true;
+				return true
 			end
 		end
 
 		-- failed to load with ${kernel} as a directory
 		-- try as a file
-		res = try_load(kernel);
+		res = try_load(kernel)
 		if (res ~= nil) then
-			config.kernel_loaded = kernel;
+			config.kernel_loaded = kernel
-			return true;
+			return true
 		else
-			print("Failed to load kernel '" .. kernel .. "'");
+			print("Failed to load kernel '" .. kernel .. "'")
-			return false;
+			return false
 		end
 	end
 end
 
 function config.selectkernel(kernel)
-	config.kernel_selected = kernel;
+	config.kernel_selected = kernel
 end
 
 function config.load(file)
 	if (not file) then
-		file = "/boot/defaults/loader.conf";
+		file = "/boot/defaults/loader.conf"
 	end
 
 	if (not config.parse(file)) then
---		print("Failed to parse configuration: '" .. file .. "'");
+--		print("Failed to parse configuration: '" .. file .. "'")
 	end
 
-	local f = loader.getenv("loader_conf_files");
+	local f = loader.getenv("loader_conf_files")
 	if (f ~= nil) then
 		for name in f:gmatch("([%w%p]+)%s*") do
 			if (not config.parse(name)) then
 --				print("Failed to parse configuration: '" ..
---				    name .. "'");
+--				    name .. "'")
 			end
 		end
 	end
 
 	-- Cache the provided module_path at load time for later use
-	config.module_path = loader.getenv("module_path");
+	config.module_path = loader.getenv("module_path")
 end
 
 -- Reload configuration
 function config.reload(file)
-	modules = {};
+	modules = {}
-	config.restoreEnv();
+	config.restoreEnv()
-	config.load(file);
+	config.load(file)
 end
 
 function config.loadelf()
-	local kernel = config.kernel_selected or config.kernel_loaded;
+	local kernel = config.kernel_selected or config.kernel_loaded
-	local loaded = false;
+	local loaded = false
 
-	print("Loading kernel...");
+	print("Loading kernel...")
-	loaded = config.loadkernel(kernel);
+	loaded = config.loadkernel(kernel)
 
 	if (not loaded) then
-		print("Failed to load any kernel");
+		print("Failed to load any kernel")
-		return;
+		return
 	end
 
-	print("Loading configured modules...");
+	print("Loading configured modules...")
 	if (not config.loadmod(modules)) then
-		print("Could not load one or more modules!");
+		print("Could not load one or more modules!")
 	end
 end
 
-return config;
+return config

stand/lua/core.lua

@@ -26,15 +26,15 @@
 -- $FreeBSD$
 --
 
-local config = require('config');
+local config = require('config')
 
-local core = {};
+local core = {}
 
 local compose_loader_cmd = function(cmd_name, argstr)
 	if (argstr ~= nil) then
-		cmd_name = cmd_name .. " " .. argstr;
+		cmd_name = cmd_name .. " " .. argstr
 	end
-	return cmd_name;
+	return cmd_name
 end
 
 -- Internal function
@@ -44,162 +44,162 @@ end
 -- will need to be explicitly overwritten to false
 local parse_boot_args = function(argv, with_kernel)
 	if (#argv == 0) then
-		return nil, "";
+		return nil, ""
 	end
 	if (with_kernel == nil) then
-		with_kernel = true;
+		with_kernel = true
 	end
-	local kernel_name;
+	local kernel_name
-	local argstr = "";
+	local argstr = ""
 
 	for k, v in ipairs(argv) do
 		if (with_kernel) and (v:sub(1,1) ~= "-") then
-			kernel_name = v;
+			kernel_name = v
 		else
-			argstr = argstr .. " " .. v;
+			argstr = argstr .. " " .. v
 		end
 	end
 	if (with_kernel) then
-		return kernel_name, argstr;
+		return kernel_name, argstr
 	else
-		return argstr;
+		return argstr
 	end
 end
 
 -- Globals
 function boot(...)
-	local argv = {...};
+	local argv = {...}
-	local cmd_name = "";
+	local cmd_name = ""
-	cmd_name, argv = core.popFrontTable(argv);
+	cmd_name, argv = core.popFrontTable(argv)
-	local kernel, argstr = parse_boot_args(argv);
+	local kernel, argstr = parse_boot_args(argv)
 	if (kernel ~= nil) then
-		loader.perform("unload");
+		loader.perform("unload")
-		config.selectkernel(kernel);
+		config.selectkernel(kernel)
 	end
-	core.boot(argstr);
+	core.boot(argstr)
 end
 
 function autoboot(...)
 	local argv = {...}
-	local cmd_name = "";
+	local cmd_name = ""
-	cmd_name, argv = core.popFrontTable(argv);
+	cmd_name, argv = core.popFrontTable(argv)
-	local argstr = parse_boot_args(argv, false);
+	local argstr = parse_boot_args(argv, false)
-	core.autoboot(argstr);
+	core.autoboot(argstr)
 end
 
 -- Module exports
 -- Commonly appearing constants
-core.KEY_BACKSPACE	= 8;
+core.KEY_BACKSPACE	= 8
-core.KEY_ENTER		= 13;
+core.KEY_ENTER		= 13
-core.KEY_DELETE		= 127;
+core.KEY_DELETE		= 127
 
-core.KEYSTR_ESCAPE	= "\027";
+core.KEYSTR_ESCAPE	= "\027"
 
-core.MENU_RETURN	= "return";
+core.MENU_RETURN	= "return"
-core.MENU_ENTRY		= "entry";
+core.MENU_ENTRY		= "entry"
-core.MENU_SEPARATOR	= "separator";
+core.MENU_SEPARATOR	= "separator"
-core.MENU_SUBMENU	= "submenu";
+core.MENU_SUBMENU	= "submenu"
-core.MENU_CAROUSEL_ENTRY	= "carousel_entry";
+core.MENU_CAROUSEL_ENTRY	= "carousel_entry"
 
 function core.setVerbose(b)
 	if (b == nil) then
-		b = not core.verbose;
+		b = not core.verbose
 	end
 
 	if (b == true) then
-		loader.setenv("boot_verbose", "YES");
+		loader.setenv("boot_verbose", "YES")
 	else
-		loader.unsetenv("boot_verbose");
+		loader.unsetenv("boot_verbose")
 	end
-	core.verbose = b;
+	core.verbose = b
 end
 
 function core.setSingleUser(b)
 	if (b == nil) then
-		b = not core.su;
+		b = not core.su
 	end
 
 	if (b == true) then
-		loader.setenv("boot_single", "YES");
+		loader.setenv("boot_single", "YES")
 	else
-		loader.unsetenv("boot_single");
+		loader.unsetenv("boot_single")
 	end
-	core.su = b;
+	core.su = b
 end
 
 function core.getACPIPresent(checkingSystemDefaults)
-	local c = loader.getenv("hint.acpi.0.rsdp");
+	local c = loader.getenv("hint.acpi.0.rsdp")
 
 	if (c ~= nil) then
 		if (checkingSystemDefaults == true) then
-			return true;
+			return true
 		end
 		-- Otherwise, respect disabled if it's set
-		c = loader.getenv("hint.acpi.0.disabled");
+		c = loader.getenv("hint.acpi.0.disabled")
-		return (c == nil) or (tonumber(c) ~= 1);
+		return (c == nil) or (tonumber(c) ~= 1)
 	end
-	return false;
+	return false
 end
 
 function core.setACPI(b)
 	if (b == nil) then
-		b = not core.acpi;
+		b = not core.acpi
 	end
 
 	if (b == true) then
-		loader.setenv("acpi_load", "YES");
+		loader.setenv("acpi_load", "YES")
-		loader.setenv("hint.acpi.0.disabled", "0");
+		loader.setenv("hint.acpi.0.disabled", "0")
-		loader.unsetenv("loader.acpi_disabled_by_user");
+		loader.unsetenv("loader.acpi_disabled_by_user")
 	else
-		loader.unsetenv("acpi_load");
+		loader.unsetenv("acpi_load")
-		loader.setenv("hint.acpi.0.disabled", "1");
+		loader.setenv("hint.acpi.0.disabled", "1")
-		loader.setenv("loader.acpi_disabled_by_user", "1");
+		loader.setenv("loader.acpi_disabled_by_user", "1")
 	end
-	core.acpi = b;
+	core.acpi = b
 end
 
 function core.setSafeMode(b)
 	if (b == nil) then
-		b = not core.sm;
+		b = not core.sm
 	end
 	if (b == true) then
-		loader.setenv("kern.smp.disabled", "1");
+		loader.setenv("kern.smp.disabled", "1")
-		loader.setenv("hw.ata.ata_dma", "0");
+		loader.setenv("hw.ata.ata_dma", "0")
-		loader.setenv("hw.ata.atapi_dma", "0");
+		loader.setenv("hw.ata.atapi_dma", "0")
-		loader.setenv("hw.ata.wc", "0");
+		loader.setenv("hw.ata.wc", "0")
-		loader.setenv("hw.eisa_slots", "0");
+		loader.setenv("hw.eisa_slots", "0")
-		loader.setenv("kern.eventtimer.periodic", "1");
+		loader.setenv("kern.eventtimer.periodic", "1")
-		loader.setenv("kern.geom.part.check_integrity", "0");
+		loader.setenv("kern.geom.part.check_integrity", "0")
 	else
-		loader.unsetenv("kern.smp.disabled");
+		loader.unsetenv("kern.smp.disabled")
-		loader.unsetenv("hw.ata.ata_dma");
+		loader.unsetenv("hw.ata.ata_dma")
-		loader.unsetenv("hw.ata.atapi_dma");
+		loader.unsetenv("hw.ata.atapi_dma")
-		loader.unsetenv("hw.ata.wc");
+		loader.unsetenv("hw.ata.wc")
-		loader.unsetenv("hw.eisa_slots");
+		loader.unsetenv("hw.eisa_slots")
-		loader.unsetenv("kern.eventtimer.periodic");
+		loader.unsetenv("kern.eventtimer.periodic")
-		loader.unsetenv("kern.geom.part.check_integrity");
+		loader.unsetenv("kern.geom.part.check_integrity")
 	end
-	core.sm = b;
+	core.sm = b
 end
 
 function core.kernelList()
-	local k = loader.getenv("kernel");
+	local k = loader.getenv("kernel")
-	local v = loader.getenv("kernels") or "";
+	local v = loader.getenv("kernels") or ""
 
-	local kernels = {};
+	local kernels = {}
-	local unique = {};
+	local unique = {}
-	local i = 0;
+	local i = 0
 	if (k ~= nil) then
-		i = i + 1;
+		i = i + 1
-		kernels[i] = k;
+		kernels[i] = k
-		unique[k] = true;
+		unique[k] = true
 	end
 
 	for n in v:gmatch("([^; ]+)[; ]?") do
 		if (unique[n] == nil) then
-			i = i + 1;
+			i = i + 1
-			kernels[i] = n;
+			kernels[i] = n
-			unique[n] = true;
+			unique[n] = true
 		end
 	end
 
@@ -207,89 +207,89 @@ function core.kernelList()
 	-- heuristic.  Any directory in /boot that contains an ordinary file
 	-- named "kernel" is considered eligible.
 	for file in lfs.dir("/boot") do
-		local fname = "/boot/" .. file;
+		local fname = "/boot/" .. file
 
 		if (file == "." or file == "..") then
-			goto continue;
+			goto continue
 		end
 
 		if (lfs.attributes(fname, "mode") ~= "directory") then
-			goto continue;
+			goto continue
 		end
 
 		if (lfs.attributes(fname .. "/kernel", "mode") ~= "file") then
-			goto continue;
+			goto continue
 		end
 
 		if (unique[file] == nil) then
-			i = i + 1;
+			i = i + 1
-			kernels[i] = file;
+			kernels[i] = file
-			unique[file] = true;
+			unique[file] = true
 		end
 
 		::continue::
 	end
-	return kernels;
+	return kernels
 end
 
 function core.setDefaults()
-	core.setACPI(core.getACPIPresent(true));
+	core.setACPI(core.getACPIPresent(true))
-	core.setSafeMode(false);
+	core.setSafeMode(false)
-	core.setSingleUser(false);
+	core.setSingleUser(false)
-	core.setVerbose(false);
+	core.setVerbose(false)
 end
 
 function core.autoboot(argstr)
-	config.loadelf();
+	config.loadelf()
-	loader.perform(compose_loader_cmd("autoboot", argstr));
+	loader.perform(compose_loader_cmd("autoboot", argstr))
 end
 
 function core.boot(argstr)
-	config.loadelf();
+	config.loadelf()
-	loader.perform(compose_loader_cmd("boot", argstr));
+	loader.perform(compose_loader_cmd("boot", argstr))
 end
 
 function core.isSingleUserBoot()
-	local single_user = loader.getenv("boot_single");
+	local single_user = loader.getenv("boot_single")
-	return single_user ~= nil and single_user:lower() == "yes";
+	return single_user ~= nil and single_user:lower() == "yes"
 end
 
 function core.isSerialBoot()
-	local c = loader.getenv("console");
+	local c = loader.getenv("console")
 
 	if (c ~= nil) then
 		if (c:find("comconsole") ~= nil) then
-			return true;
+			return true
 		end
 	end
 
-	local s = loader.getenv("boot_serial");
+	local s = loader.getenv("boot_serial")
 	if (s ~= nil) then
-		return true;
+		return true
 	end
 
-	local m = loader.getenv("boot_multicons");
+	local m = loader.getenv("boot_multicons")
 	if (m ~= nil) then
-		return true;
+		return true
 	end
-	return false;
+	return false
 end
 
 function core.isSystem386()
-	return (loader.machine_arch == "i386");
+	return (loader.machine_arch == "i386")
 end
 
 -- This may be a better candidate for a 'utility' module.
 function core.shallowCopyTable(tbl)
-	local new_tbl = {};
+	local new_tbl = {}
 	for k, v in pairs(tbl) do
 		if (type(v) == "table") then
-			new_tbl[k] = core.shallowCopyTable(v);
+			new_tbl[k] = core.shallowCopyTable(v)
 		else
-			new_tbl[k] = v;
+			new_tbl[k] = v
 		end
 	end
-	return new_tbl;
+	return new_tbl
 end
 
 -- XXX This should go away if we get the table lib into shape for importing.
@@ -298,21 +298,21 @@ end
 function core.popFrontTable(tbl)
 	-- Shouldn't reasonably happen
 	if (#tbl == 0) then
-		return nil, nil;
+		return nil, nil
 	elseif (#tbl == 1) then
-		return tbl[1], {};
+		return tbl[1], {}
 	end
 
-	local first_value = tbl[1];
+	local first_value = tbl[1]
-	local new_tbl = {};
+	local new_tbl = {}
 	-- This is not a cheap operation
 	for k, v in ipairs(tbl) do
 		if (k > 1) then
-			new_tbl[k - 1] = v;
+			new_tbl[k - 1] = v
 		end
 	end
 
-	return first_value, new_tbl;
+	return first_value, new_tbl
 end
 
 -- On i386, hint.acpi.0.rsdp will be set before we're loaded. On !i386, it will
@@ -320,6 +320,6 @@ end
 -- don't really want to) detect/disable ACPI on !i386 reliably. Just set it
 -- enabled if we detect it and leave well enough alone if we don't.
 if (core.isSystem386()) and (core.getACPIPresent(false)) then
-	core.setACPI(true);
+	core.setACPI(true)
 end
-return core;
+return core

stand/lua/drawer.lua

@@ -27,37 +27,37 @@
 -- $FreeBSD$
 --
 
-local color = require("color");
+local color = require("color")
-local config = require("config");
+local config = require("config")
-local core = require("core");
+local core = require("core")
-local screen = require("screen");
+local screen = require("screen")
 
-local drawer = {};
+local drawer = {}
 
-local fbsd_logo;
+local fbsd_logo
-local beastie_color;
+local beastie_color
-local beastie;
+local beastie
-local fbsd_logo_v;
+local fbsd_logo_v
-local orb;
+local orb
-local none;
+local none
-local none_shifted = false;
+local none_shifted = false
 
 local menu_entry_name = function(drawing_menu, entry)
-	local name_handler = drawer.menu_name_handlers[entry.entry_type];
+	local name_handler = drawer.menu_name_handlers[entry.entry_type]
 
 	if (name_handler ~= nil) then
-		return name_handler(drawing_menu, entry);
+		return name_handler(drawing_menu, entry)
 	end
-	return entry.name();
+	return entry.name()
 end
 
 local shift_brand_text = function(shift)
-	drawer.brand_position.x = drawer.brand_position.x + shift.x;
+	drawer.brand_position.x = drawer.brand_position.x + shift.x
-	drawer.brand_position.y = drawer.brand_position.y + shift.y;
+	drawer.brand_position.y = drawer.brand_position.y + shift.y
-	drawer.menu_position.x = drawer.menu_position.x + shift.x;
+	drawer.menu_position.x = drawer.menu_position.x + shift.x
-	drawer.menu_position.y = drawer.menu_position.y + shift.y;
+	drawer.menu_position.y = drawer.menu_position.y + shift.y
-	drawer.box_pos_dim.x = drawer.box_pos_dim.x + shift.x;
+	drawer.box_pos_dim.x = drawer.box_pos_dim.x + shift.x
-	drawer.box_pos_dim.y = drawer.box_pos_dim.y + shift.y;
+	drawer.box_pos_dim.y = drawer.box_pos_dim.y + shift.y
 end
 
 fbsd_logo = {
@@ -68,7 +68,7 @@ fbsd_logo = {
 	" | |   | | |  __/  __/| |_) |____) | |__| |",
 	" | |   | | |    |    ||     |      |      |",
 	" |_|   |_|  \\___|\\___||____/|_____/|_____/ "
-};
+}
 
 beastie_color = {
 	"               \027[31m,        ,",
@@ -90,7 +90,7 @@ beastie_color = {
 	"           \027[36m______\027[31m( (_  / \\______/",
 	"         \027[36m,'  ,-----'   |",
 	"         `--{__________)\027[37m"
-};
+}
 
 beastie = {
 	"               ,        ,",
@@ -112,7 +112,7 @@ beastie = {
 	"           ______( (_  / \\______/",
 	"         ,'  ,-----'   |",
 	"         `--{__________)"
-};
+}
 
 fbsd_logo_v = {
 	"  ______",
@@ -128,7 +128,7 @@ fbsd_logo_v = {
 	" | |_) |____) | |__| |",
 	" |     |      |      |",
 	" |____/|_____/|_____/"
-};
+}
 
 orb_color = {
 	"  \027[31m```                        \027[31;1m`\027[31m",
@@ -146,7 +146,7 @@ orb_color = {
 	"    `:`                  \027[31;1m`:`",
 	"      \027[31;1m.--             `--.",
 	"         .---.....----.\027[37m"
-};
+}
 
 orb = {
 	"  ```                        `",
@@ -164,9 +164,9 @@ orb = {
 	"    `:`                  `:`",
 	"      .--             `--.",
 	"         .---.....----."
-};
+}
 
-none = {""};
+none = {""}
 
 -- Module exports
 drawer.menu_name_handlers = {
@@ -176,21 +176,21 @@ drawer.menu_name_handlers = {
 	-- have their names derived differently. The default action for entry
 	-- types not specified here is to call and use entry.name().
 	[core.MENU_CAROUSEL_ENTRY] = function(drawing_menu, entry)
-		local carid = entry.carousel_id;
+		local carid = entry.carousel_id
-		local caridx = config.getCarouselIndex(carid);
+		local caridx = config.getCarouselIndex(carid)
-		local choices = entry.items();
+		local choices = entry.items()
 
 		if (#choices < caridx) then
-			caridx = 1;
+			caridx = 1
 		end
-		return entry.name(caridx, choices[caridx], choices);
+		return entry.name(caridx, choices[caridx], choices)
 	end,
-};
+}
 
-drawer.brand_position = {x = 2, y = 1};
+drawer.brand_position = {x = 2, y = 1}
-drawer.logo_position = {x = 46, y = 1};
+drawer.logo_position = {x = 46, y = 1}
-drawer.menu_position = {x = 6, y = 11};
+drawer.menu_position = {x = 6, y = 11}
-drawer.box_pos_dim = {x = 3, y = 10, w = 41, h = 11};
+drawer.box_pos_dim = {x = 3, y = 10, w = 41, h = 11}
 
 drawer.branddefs = {
 	-- Indexed by valid values for loader_brand in loader.conf(5). Valid
@@ -201,7 +201,7 @@ drawer.branddefs = {
 	["none"] = {
 		graphic = none,
 	},
-};
+}
 
 drawer.logodefs = {
 	-- Indexed by valid values for loader_logo in loader.conf(5). Valid keys
@@ -237,146 +237,146 @@ drawer.logodefs = {
 		graphic = none,
 		shift = {x = 17, y = 0},
 	},
-};
+}
 
 function drawer.drawscreen(menu_opts)
 	-- drawlogo() must go first.
 	-- it determines the positions of other elements
-	drawer.drawlogo();
+	drawer.drawlogo()
-        drawer.drawbrand();
+        drawer.drawbrand()
-        drawer.drawbox();
+        drawer.drawbox()
-	return drawer.drawmenu(menu_opts);
+	return drawer.drawmenu(menu_opts)
 end
 
 function drawer.drawmenu(m)
-	x = drawer.menu_position.x;
+	x = drawer.menu_position.x
-	y = drawer.menu_position.y;
+	y = drawer.menu_position.y
 
 	-- print the menu and build the alias table
-	local alias_table = {};
+	local alias_table = {}
-	local entry_num = 0;
+	local entry_num = 0
-	local menu_entries = m.entries;
+	local menu_entries = m.entries
 	if (type(menu_entries) == "function") then
-		menu_entries = menu_entries();
+		menu_entries = menu_entries()
 	end
 	for line_num, e in ipairs(menu_entries) do
 		-- Allow menu items to be conditionally visible by specifying
 		-- a visible function.
 		if (e.visible ~= nil) and (not e.visible()) then
-			goto continue;
+			goto continue
 		end
 		if (e.entry_type ~= core.MENU_SEPARATOR) then
-			entry_num = entry_num + 1;
+			entry_num = entry_num + 1
-			screen.setcursor(x, y + line_num);
+			screen.setcursor(x, y + line_num)
 
-			print(entry_num .. ". " .. menu_entry_name(m, e));
+			print(entry_num .. ". " .. menu_entry_name(m, e))
 
 			-- fill the alias table
-			alias_table[tostring(entry_num)] = e;
+			alias_table[tostring(entry_num)] = e
 			if (e.alias ~= nil) then
 				for n, a in ipairs(e.alias) do
-					alias_table[a] = e;
+					alias_table[a] = e
 				end
 			end
 		else
-			screen.setcursor(x, y + line_num);
+			screen.setcursor(x, y + line_num)
-			print(menu_entry_name(m, e));
+			print(menu_entry_name(m, e))
 		end
 		::continue::
 	end
-	return alias_table;
+	return alias_table
 end
 
 
 function drawer.drawbox()
-	x = drawer.box_pos_dim.x;
+	x = drawer.box_pos_dim.x
-	y = drawer.box_pos_dim.y;
+	y = drawer.box_pos_dim.y
-	w = drawer.box_pos_dim.w;
+	w = drawer.box_pos_dim.w
-	h = drawer.box_pos_dim.h;
+	h = drawer.box_pos_dim.h
 
-	local hl = string.char(0xCD);
+	local hl = string.char(0xCD)
-	local vl = string.char(0xBA);
+	local vl = string.char(0xBA)
 
-	local tl = string.char(0xC9);
+	local tl = string.char(0xC9)
-	local bl = string.char(0xC8);
+	local bl = string.char(0xC8)
-	local tr = string.char(0xBB);
+	local tr = string.char(0xBB)
-	local br = string.char(0xBC);
+	local br = string.char(0xBC)
 
-	screen.setcursor(x, y); print(tl);
+	screen.setcursor(x, y); print(tl)
-	screen.setcursor(x, y+h); print(bl);
+	screen.setcursor(x, y+h); print(bl)
-	screen.setcursor(x+w, y); print(tr);
+	screen.setcursor(x+w, y); print(tr)
-	screen.setcursor(x+w, y+h); print(br);
+	screen.setcursor(x+w, y+h); print(br)
 
 	for i = 1, w-1 do
-		screen.setcursor(x+i, y);
+		screen.setcursor(x+i, y)
-		print(hl);
+		print(hl)
-		screen.setcursor(x+i, y+h);
+		screen.setcursor(x+i, y+h)
-		print(hl);
+		print(hl)
 	end
 
 	for i = 1, h-1 do
-		screen.setcursor(x, y+i);
+		screen.setcursor(x, y+i)
-		print(vl);
+		print(vl)
-		screen.setcursor(x+w, y+i);
+		screen.setcursor(x+w, y+i)
-		print(vl);
+		print(vl)
 	end
 
-	screen.setcursor(x+(w/2)-9, y);
+	screen.setcursor(x+(w/2)-9, y)
-	print("Welcome to FreeBSD");
+	print("Welcome to FreeBSD")
 end
 
 function drawer.draw(x, y, logo)
 	for i = 1, #logo do
-		screen.setcursor(x, y + i);
+		screen.setcursor(x, y + i)
-		print(logo[i]);
+		print(logo[i])
 	end
 end
 
 function drawer.drawbrand()
 	local x = tonumber(loader.getenv("loader_brand_x")) or
-	    drawer.brand_position.x;
+	    drawer.brand_position.x
 	local y = tonumber(loader.getenv("loader_brand_y")) or
-	    drawer.brand_position.y;
+	    drawer.brand_position.y
 
-	local graphic = drawer.branddefs[loader.getenv("loader_brand")];
+	local graphic = drawer.branddefs[loader.getenv("loader_brand")]
 	if (graphic == nil) then
-		graphic = fbsd_logo;
+		graphic = fbsd_logo
 	end
-	drawer.draw(x, y, graphic);
+	drawer.draw(x, y, graphic)
 end
 
 function drawer.drawlogo()
 	local x = tonumber(loader.getenv("loader_logo_x")) or
-	    drawer.logo_position.x;
+	    drawer.logo_position.x
 	local y = tonumber(loader.getenv("loader_logo_y")) or
-	    drawer.logo_position.y;
+	    drawer.logo_position.y
 
-	local logo = loader.getenv("loader_logo");
+	local logo = loader.getenv("loader_logo")
-	local colored = color.isEnabled();
+	local colored = color.isEnabled()
 
 	-- Lookup
-	local logodef = drawer.logodefs[logo];
+	local logodef = drawer.logodefs[logo]
 
 	if (logodef ~= nil) and (logodef.graphic == none) then
 		-- centre brand and text if no logo
 		if (not none_shifted) then
-			shift_brand_text(logodef.shift);
+			shift_brand_text(logodef.shift)
-			none_shifted = true;
+			none_shifted = true
 		end
 	elseif (logodef == nil) or (logodef.graphic == nil) or
 	    ((not colored) and logodef.requires_color) then
 		-- Choose a sensible default
 		if (colored) then
-			logodef = drawer.logodefs["orb"];
+			logodef = drawer.logodefs["orb"]
 		else
-			logodef = drawer.logodefs["orbbw"];
+			logodef = drawer.logodefs["orbbw"]
 		end
 	end
 	if (logodef.shift ~= nil) then
-		x = x + logodef.shift.x;
+		x = x + logodef.shift.x
-		y = y + logodef.shift.y;
+		y = y + logodef.shift.y
 	end
-	drawer.draw(x, y, logodef.graphic);
+	drawer.draw(x, y, logodef.graphic)
 end
 
-return drawer;
+return drawer

stand/lua/loader.lua

@@ -27,35 +27,35 @@
 -- $FreeBSD$
 --
 
-local config = require("config");
+local config = require("config")
-local menu = require("menu");
+local menu = require("menu")
-local password = require("password");
+local password = require("password")
 
 -- Declares a global function cli_execute that attempts to dispatch the
 -- arguments passed as a lua function. This gives lua a chance to intercept
 -- builtin CLI commands like "boot"
 function cli_execute(...)
-	local argv = {...};
+	local argv = {...}
 	-- Just in case...
 	if (#argv == 0) then
-		loader.command(...);
+		loader.command(...)
-		return;
+		return
 	end
 
-	local cmd_name = argv[1];
+	local cmd_name = argv[1]
-	local cmd = _G[cmd_name];
+	local cmd = _G[cmd_name]
 	if (cmd ~= nil) and (type(cmd) == "function") then
 		-- Pass argv wholesale into cmd. We could omit argv[0] since the
 		-- traditional reasons for including it don't necessarily apply,
 		-- it may not be totally redundant if we want to have one global
 		-- handling multiple commands
-		cmd(...);
+		cmd(...)
 	else
-		loader.command(...);
+		loader.command(...)
 	end
 
 end
 
-config.load();
+config.load()
-password.check();
+password.check()
-menu.run();
+menu.run()

stand/lua/menu.lua

@@ -28,25 +28,25 @@
 --
 
 
-local core = require("core");
+local core = require("core")
-local color = require("color");
+local color = require("color")
-local config = require("config");
+local config = require("config")
-local screen = require("screen");
+local screen = require("screen")
-local drawer = require("drawer");
+local drawer = require("drawer")
 
-local menu = {};
+local menu = {}
 
-local skip;
+local skip
-local run;
+local run
-local autoboot;
+local autoboot
 
 local OnOff = function(str, b)
 	if (b) then
 		return str .. color.escapef(color.GREEN) .. "On" ..
-		    color.escapef(color.WHITE);
+		    color.escapef(color.WHITE)
 	else
 		return str .. color.escapef(color.RED) .. "off" ..
-		    color.escapef(color.WHITE);
+		    color.escapef(color.WHITE)
 	end
 end
 
@@ -59,32 +59,32 @@ menu.handlers = {
 	-- should just continue after execution.
 	[core.MENU_ENTRY] = function(current_menu, entry)
 		-- run function
-		entry.func();
+		entry.func()
 	end,
 	[core.MENU_CAROUSEL_ENTRY] = function(current_menu, entry)
 		-- carousel (rotating) functionality
-		local carid = entry.carousel_id;
+		local carid = entry.carousel_id
-		local caridx = config.getCarouselIndex(carid);
+		local caridx = config.getCarouselIndex(carid)
-		local choices = entry.items();
+		local choices = entry.items()
 
 		if (#choices > 0) then
-			caridx = (caridx % #choices) + 1;
+			caridx = (caridx % #choices) + 1
-			config.setCarouselIndex(carid, caridx);
+			config.setCarouselIndex(carid, caridx)
-			entry.func(caridx, choices[caridx], choices);
+			entry.func(caridx, choices[caridx], choices)
 		end
 	end,
 	[core.MENU_SUBMENU] = function(current_menu, entry)
 		-- recurse
-		return menu.run(entry.submenu());
+		return menu.run(entry.submenu())
 	end,
 	[core.MENU_RETURN] = function(current_menu, entry)
 		-- allow entry to have a function/side effect
 		if (entry.func ~= nil) then
-			entry.func();
+			entry.func()
 		end
-		return false;
+		return false
 	end,
-};
+}
 -- loader menu tree is rooted at menu.welcome
 
 menu.boot_options = {
@@ -94,7 +94,7 @@ menu.boot_options = {
 			entry_type = core.MENU_RETURN,
 			name = function()
 				return "Back to main menu" ..
-				    color.highlight(" [Backspace]");
+				    color.highlight(" [Backspace]")
 			end
 		},
 
@@ -103,10 +103,10 @@ menu.boot_options = {
 			entry_type = core.MENU_ENTRY,
 			name = function()
 				return "Load System " .. color.highlight("D") ..
-				    "efaults";
+				    "efaults"
 			end,
 			func = function()
-				core.setDefaults();
+				core.setDefaults()
 			end,
 			alias = {"d", "D"}
 		},
@@ -114,14 +114,14 @@ menu.boot_options = {
 		{
 			entry_type = core.MENU_SEPARATOR,
 			name = function()
-				return "";
+				return ""
 			end
 		},
 
 		{
 			entry_type = core.MENU_SEPARATOR,
 			name = function()
-				return "Boot Options:";
+				return "Boot Options:"
 			end
 		},
 
@@ -131,10 +131,10 @@ menu.boot_options = {
 			visible = core.isSystem386,
 			name = function()
 				return OnOff(color.highlight("A") ..
-				    "CPI       :", core.acpi);
+				    "CPI       :", core.acpi)
 			end,
 			func = function()
-				core.setACPI();
+				core.setACPI()
 			end,
 			alias = {"a", "A"}
 		},
@@ -143,10 +143,10 @@ menu.boot_options = {
 			entry_type = core.MENU_ENTRY,
 			name = function()
 				return OnOff("Safe " .. color.highlight("M") ..
-				    "ode  :", core.sm);
+				    "ode  :", core.sm)
 			end,
 			func = function()
-				core.setSafeMode();
+				core.setSafeMode()
 			end,
 			alias = {"m", "M"}
 		},
@@ -155,10 +155,10 @@ menu.boot_options = {
 			entry_type = core.MENU_ENTRY,
 			name = function()
 				return OnOff(color.highlight("S") ..
-				    "ingle user:", core.su);
+				    "ingle user:", core.su)
 			end,
 			func = function()
-				core.setSingleUser();
+				core.setSingleUser()
 			end,
 			alias = {"s", "S"}
 		},
@@ -167,39 +167,39 @@ menu.boot_options = {
 			entry_type = core.MENU_ENTRY,
 			name = function()
 				return OnOff(color.highlight("V") ..
-				    "erbose    :", core.verbose);
+				    "erbose    :", core.verbose)
 			end,
 			func = function()
-				core.setVerbose();
+				core.setVerbose()
 			end,
 			alias = {"v", "V"}
 		},
 	},
-};
+}
 
 menu.welcome = {
 	entries = function()
-		local menu_entries = menu.welcome.all_entries;
+		local menu_entries = menu.welcome.all_entries
 		-- Swap the first two menu items on single user boot
 		if (core.isSingleUserBoot()) then
 			-- We'll cache the swapped menu, for performance
 			if (menu.welcome.swapped_menu ~= nil) then
-				return menu.welcome.swapped_menu;
+				return menu.welcome.swapped_menu
 			end
 			-- Shallow copy the table
-			menu_entries = core.shallowCopyTable(menu_entries);
+			menu_entries = core.shallowCopyTable(menu_entries)
 
 			-- Swap the first two menu entries
 			menu_entries[1], menu_entries[2] =
-			    menu_entries[2], menu_entries[1];
+			    menu_entries[2], menu_entries[1]
 
 			-- Then set their names to their alternate names
 			menu_entries[1].name, menu_entries[2].name =
 			    menu_entries[1].alternate_name,
-			    menu_entries[2].alternate_name;
+			    menu_entries[2].alternate_name
-			menu.welcome.swapped_menu = menu_entries;
+			menu.welcome.swapped_menu = menu_entries
 		end
-		return menu_entries;
+		return menu_entries
 	end,
 	all_entries = {
 		-- boot multi user
@@ -208,16 +208,16 @@ menu.welcome = {
 			name = function()
 				return color.highlight("B") ..
 				    "oot Multi user " ..
-				    color.highlight("[Enter]");
+				    color.highlight("[Enter]")
 			end,
 			-- Not a standard menu entry function!
 			alternate_name = function()
 				return color.highlight("B") ..
-				    "oot Multi user";
+				    "oot Multi user"
 			end,
 			func = function()
-				core.setSingleUser(false);
+				core.setSingleUser(false)
-				core.boot();
+				core.boot()
 			end,
 			alias = {"b", "B"}
 		},
@@ -227,16 +227,16 @@ menu.welcome = {
 			entry_type = core.MENU_ENTRY,
 			name = function()
 				return "Boot " .. color.highlight("S") ..
-				    "ingle user";
+				    "ingle user"
 			end,
 			-- Not a standard menu entry function!
 			alternate_name = function()
 				return "Boot " .. color.highlight("S") ..
-				    "ingle user " .. color.highlight("[Enter]");
+				    "ingle user " .. color.highlight("[Enter]")
 			end,
 			func = function()
-				core.setSingleUser(true);
+				core.setSingleUser(true)
-				core.boot();
+				core.boot()
 			end,
 			alias = {"s", "S"}
 		},
@@ -246,10 +246,10 @@ menu.welcome = {
 			entry_type = core.MENU_RETURN,
 			name = function()
 				return color.highlight("Esc") ..
-				    "ape to loader prompt";
+				    "ape to loader prompt"
 			end,
 			func = function()
-				loader.setenv("autoboot_delay", "NO");
+				loader.setenv("autoboot_delay", "NO")
 			end,
 			alias = {core.KEYSTR_ESCAPE}
 		},
@@ -258,10 +258,10 @@ menu.welcome = {
 		{
 			entry_type = core.MENU_ENTRY,
 			name = function()
-				return color.highlight("R") .. "eboot";
+				return color.highlight("R") .. "eboot"
 			end,
 			func = function()
-				loader.perform("reboot");
+				loader.perform("reboot")
 			end,
 			alias = {"r", "R"}
 		},
@@ -270,14 +270,14 @@ menu.welcome = {
 		{
 			entry_type = core.MENU_SEPARATOR,
 			name = function()
-				return "";
+				return ""
 			end
 		},
 
 		{
 			entry_type = core.MENU_SEPARATOR,
 			name = function()
-				return "Options:";
+				return "Options:"
 			end
 		},
 
@@ -288,26 +288,26 @@ menu.welcome = {
 			items = core.kernelList,
 			name = function(idx, choice, all_choices)
 				if (#all_choices == 0) then
-					return "Kernel: ";
+					return "Kernel: "
 				end
 
-				local is_default = (idx == 1);
+				local is_default = (idx == 1)
-				local kernel_name = "";
+				local kernel_name = ""
-				local name_color;
+				local name_color
 				if (is_default) then
-					name_color = color.escapef(color.GREEN);
+					name_color = color.escapef(color.GREEN)
-					kernel_name = "default/";
+					kernel_name = "default/"
 				else
-					name_color = color.escapef(color.BLUE);
+					name_color = color.escapef(color.BLUE)
 				end
 				kernel_name = kernel_name .. name_color ..
-				    choice .. color.default();
+				    choice .. color.default()
 				return color.highlight("K") .. "ernel: " ..
 				    kernel_name .. " (" .. idx .. " of " ..
-				    #all_choices .. ")";
+				    #all_choices .. ")"
 			end,
 			func = function(idx, choice, all_choices)
-				config.selectkernel(choice);
+				config.selectkernel(choice)
 			end,
 			alias = {"k", "K"}
 		},
@@ -317,144 +317,144 @@ menu.welcome = {
 			entry_type = core.MENU_SUBMENU,
 			name = function()
 				return "Boot " .. color.highlight("O") ..
-				    "ptions";
+				    "ptions"
 			end,
 			submenu = function()
-				return menu.boot_options;
+				return menu.boot_options
 			end,
 			alias = {"o", "O"}
 		},
 	},
-};
+}
 
 function menu.run(m)
 
 	if (menu.skip()) then
-		core.autoboot();
+		core.autoboot()
-		return false;
+		return false
 	end
 
 	if (m == nil) then
-		m = menu.welcome;
+		m = menu.welcome
 	end
 
 	-- redraw screen
-	screen.clear();
+	screen.clear()
-	screen.defcursor();
+	screen.defcursor()
-	local alias_table = drawer.drawscreen(m);
+	local alias_table = drawer.drawscreen(m)
 
-	menu.autoboot();
+	menu.autoboot()
 
-	cont = true;
+	cont = true
 	while (cont) do
-		local key = io.getchar();
+		local key = io.getchar()
 
 		-- Special key behaviors
 		if ((key == core.KEY_BACKSPACE) or (key == core.KEY_DELETE)) and
 		    (m ~= menu.welcome) then
-			break;
+			break
 		elseif (key == core.KEY_ENTER) then
-			core.boot();
+			core.boot()
 			-- Should not return
 		end
 
 		key = string.char(key)
 		-- check to see if key is an alias
-		local sel_entry = nil;
+		local sel_entry = nil
 		for k, v in pairs(alias_table) do
 			if (key == k) then
-				sel_entry = v;
+				sel_entry = v
 			end
 		end
 
 		-- if we have an alias do the assigned action:
 		if (sel_entry ~= nil) then
 			-- Get menu handler
-			local handler = menu.handlers[sel_entry.entry_type];
+			local handler = menu.handlers[sel_entry.entry_type]
 			if (handler ~= nil) then
 				-- The handler's return value indicates whether
 				-- we need to exit this menu. An omitted return
 				-- value means "continue" by default.
-				cont = handler(m, sel_entry);
+				cont = handler(m, sel_entry)
 				if (cont == nil) then
-					cont = true;
+					cont = true
 				end
 			end
 			-- if we got an alias key the screen is out of date:
-			screen.clear();
+			screen.clear()
-			screen.defcursor();
+			screen.defcursor()
-			alias_table = drawer.drawscreen(m);
+			alias_table = drawer.drawscreen(m)
 		end
 	end
 
 	if (m == menu.welcome) then
-		screen.defcursor();
+		screen.defcursor()
-		print("Exiting menu!");
+		print("Exiting menu!")
-		return false;
+		return false
 	end
 
-	return true;
+	return true
 end
 
 function menu.skip()
 	if (core.isSerialBoot()) then
-		return true;
+		return true
 	end
-	local c = string.lower(loader.getenv("console") or "");
+	local c = string.lower(loader.getenv("console") or "")
 	if ((c:match("^efi[ ;]") or c:match("[ ;]efi[ ;]")) ~= nil) then
-		return true;
+		return true
 	end
 
-	c = string.lower(loader.getenv("beastie_disable") or "");
+	c = string.lower(loader.getenv("beastie_disable") or "")
-	print("beastie_disable", c);
+	print("beastie_disable", c)
-	return c == "yes";
+	return c == "yes"
 end
 
 function menu.autoboot()
 	if (menu.already_autoboot == true) then
-		return;
+		return
 	end
-	menu.already_autoboot = true;
+	menu.already_autoboot = true
 
-	local ab = loader.getenv("autoboot_delay");
+	local ab = loader.getenv("autoboot_delay")
 	if (ab ~= nil) and (ab:lower() == "no") then
-		return;
+		return
 	elseif (tonumber(ab) == -1) then
-		core.boot();
+		core.boot()
 	end
-	ab = tonumber(ab) or 10;
+	ab = tonumber(ab) or 10
 
-	local x = loader.getenv("loader_menu_timeout_x") or 5;
+	local x = loader.getenv("loader_menu_timeout_x") or 5
-	local y = loader.getenv("loader_menu_timeout_y") or 22;
+	local y = loader.getenv("loader_menu_timeout_y") or 22
 
-	local endtime = loader.time() + ab;
+	local endtime = loader.time() + ab
-	local time;
+	local time
 
 	repeat
-		time = endtime - loader.time();
+		time = endtime - loader.time()
-		screen.setcursor(x, y);
+		screen.setcursor(x, y)
 		print("Autoboot in " .. time ..
 		    " seconds, hit [Enter] to boot" ..
-		    " or any other key to stop     ");
+		    " or any other key to stop     ")
-		screen.defcursor();
+		screen.defcursor()
 		if (io.ischar()) then
-			local ch = io.getchar();
+			local ch = io.getchar()
 			if (ch == core.KEY_ENTER) then
-				break;
+				break
 			else
 				-- erase autoboot msg
-				screen.setcursor(0, y);
+				screen.setcursor(0, y)
 				print("                                        "
-				    .. "                                        ");
+				    .. "                                        ")
-				screen.defcursor();
+				screen.defcursor()
-				return;
+				return
 			end
 		end
 
-		loader.delay(50000);
+		loader.delay(50000)
-	until time <= 0;
+	until time <= 0
-	core.boot();
+	core.boot()
 
 end
 
-return menu;
+return menu

stand/lua/password.lua

@@ -27,76 +27,76 @@
 -- $FreeBSD$
 --
 
-local core = require("core");
+local core = require("core")
-local screen = require("screen");
+local screen = require("screen")
 
-local password = {};
+local password = {}
 
 -- Module exports
 function password.read()
-	local str = "";
+	local str = ""
-	local n = 0;
+	local n = 0
 
 	repeat
-		ch = io.getchar();
+		ch = io.getchar()
 		if (ch == core.KEY_ENTER) then
-			break;
+			break
 		end
 		-- XXX TODO: Evaluate if we really want this or not, as a
 		-- security consideration of sorts
 		if (ch == core.KEY_BACKSPACE) or (ch == core.KEY_DELETE) then
 			if (n > 0) then
-				n = n - 1;
+				n = n - 1
-				-- loader.printc("\008 \008");
+				-- loader.printc("\008 \008")
-				str = str:sub(1, n);
+				str = str:sub(1, n)
 			end
 		else
-			-- loader.printc("*");
+			-- loader.printc("*")
-			str = str .. string.char(ch);
+			str = str .. string.char(ch)
-			n = n + 1;
+			n = n + 1
 		end
-	until (n == 16);
+	until (n == 16)
-	return str;
+	return str
 end
 
 function password.check()
-	screen.clear();
+	screen.clear()
-	screen.defcursor();
+	screen.defcursor()
 	-- pwd is optionally supplied if we want to check it
 	local function do_prompt(prompt, pwd)
 		while (true) do
-			loader.printc(prompt);
+			loader.printc(prompt)
-			local read_pwd = password.read();
+			local read_pwd = password.read()
 			if (not pwd) or (pwd == read_pwd) then
 				-- Throw an extra newline after password prompt
-				print("");
+				print("")
-				return read_pwd;
+				return read_pwd
 			end
-			print("\n\nloader: incorrect password!\n");
+			print("\n\nloader: incorrect password!\n")
-			loader.delay(3*1000*1000);
+			loader.delay(3*1000*1000)
 		end
 	end
 	local function compare(prompt, pwd)
 		if (pwd == nil) then
-			return;
+			return
 		end
-		do_prompt(prompt, pwd);
+		do_prompt(prompt, pwd)
 	end
 
-	local boot_pwd = loader.getenv("bootlock_password");
+	local boot_pwd = loader.getenv("bootlock_password")
-	compare("Boot password: ", boot_pwd);
+	compare("Boot password: ", boot_pwd)
 
-	local geli_prompt = loader.getenv("geom_eli_passphrase_prompt");
+	local geli_prompt = loader.getenv("geom_eli_passphrase_prompt")
 	if (geli_prompt ~= nil) and (geli_prompt:lower() == "yes") then
-		local passphrase = do_prompt("GELI Passphrase: ");
+		local passphrase = do_prompt("GELI Passphrase: ")
-		loader.setenv("kern.geom.eli.passphrase", passphrase);
+		loader.setenv("kern.geom.eli.passphrase", passphrase)
 	end
 
-	local pwd = loader.getenv("password");
+	local pwd = loader.getenv("password")
 	if (pwd ~= nil) then
-		core.autoboot();
+		core.autoboot()
 	end
-	compare("Password: ", pwd);
+	compare("Password: ", pwd)
 end
 
-return password;
+return password

stand/lua/screen.lua

@@ -26,61 +26,61 @@
 -- $FreeBSD$
 --
 
-local color = require("color");
+local color = require("color")
-local core = require("core");
+local core = require("core")
 
-local screen = {};
+local screen = {}
 
 -- XXX TODO: This should be fixed in the interpreter to not print decimals
 local intstring = function(num)
-	local str = tostring(num);
+	local str = tostring(num)
-	local decimal = str:find("%.");
+	local decimal = str:find("%.")
 
 	if (decimal) then
-		return str:sub(1, decimal - 1);
+		return str:sub(1, decimal - 1)
 	end
-	return str;
+	return str
 end
 
 -- Module exports
 function screen.clear()
 	if (core.isSerialBoot()) then
-		return;
+		return
 	end
-	loader.printc("\027[H\027[J");
+	loader.printc("\027[H\027[J")
 end
 
 function screen.setcursor(x, y)
 	if (core.isSerialBoot()) then
-		return;
+		return
 	end
 
-	loader.printc("\027[" .. intstring(y) .. ";" .. intstring(x) .. "H");
+	loader.printc("\027[" .. intstring(y) .. ";" .. intstring(x) .. "H")
 end
 
 function screen.setforeground(c)
 	if (color.disabled) then
-		return c;
+		return c
 	end
-	loader.printc("\027[3" .. c .. "m");
+	loader.printc("\027[3" .. c .. "m")
 end
 
 function screen.setbackground(c)
 	if (color.disabled) then
-		return c;
+		return c
 	end
-	loader.printc("\027[4" .. c .. "m");
+	loader.printc("\027[4" .. c .. "m")
 end
 
 function screen.defcolor()
-	loader.printc(color.default());
+	loader.printc(color.default())
 end
 
 function screen.defcursor()
 	if (core.isSerialBoot()) then
-		return;
+		return
 	end
-	loader.printc("\027[25;0H");
+	loader.printc("\027[25;0H")
 end
 
-return screen;
+return screen