--- /dev/null
+--
+-- Yoink Build System
+-- Execute this script with Lua to prepare the project for compiling.
+--
+-- Copyright (c) 2011, Charles McGarvey
+-- Distributable under the terms and conditions of the 2-clause BSD
+-- license; see the file COPYING for a complete text of the license.
+--
+
+
+--local function trace(event, line)
+ --local s = debug.getinfo(2).short_src
+ --print(s .. ":" .. line)
+--end
+--debug.sethook(trace, "l")
+
+
+-- Convert the arguments into standard form. Each argument should be a
+-- string. A table is returned with the arguments' standard form as keys.
+-- If an argument has a value, it will correspond to the appropriate key in
+-- the table. This function supports autoconf-style arguments, including:
+-- 1. -h, --help produce a --help key with a value of true.
+-- 2. --enable-feature=[yes|no|whatever], --disable-feature produce a
+-- --enable-feature key with a value of true, false, or a string.
+-- 3. --with-package=[yes|no|whatever], --without-feature produce a
+-- --with-package key with a value of true, false, or a string.
+-- 4. SYMBOL=VALUE produce a SYMBOL key with VALUE as the string value.
+-- 5. Anything else will appear as a key in the table as-is with a value of
+-- true.
+-- If multiple arguments mapping to the same key are present in the
+-- argument list, the last one is used.
+local function parseArguments(...)
+ local result = {}
+ local filters = {}
+
+ local function setPair(key, value) result[key] = value end
+ local function setTrue(key) result[key] = true end
+ local function addLibrarySearchPath(path)
+ package.path = path .. "/?.lua;" .. package.path
+ package.cpath = path .. "/?.so;" .. package.cpath
+ end
+
+ table.insert(filters, {"^-h$", function() result["--help"] = true end})
+ table.insert(filters, {"^-L(.*)$", addLibrarySearchPath})
+
+ table.insert(filters, {"^(--enable%-[%w_-]+)=?(.*)$", setPair})
+ table.insert(filters, {"^--disable%-([%w_-]+)$", function(feature)
+ setPair("--enable-" .. feature, "no")
+ end})
+
+ table.insert(filters, {"^(--with%-[%w_-]+)=?(.*)$", setPair})
+ table.insert(filters, {"^--without%-([%w_-]+)$", function(package)
+ setPair("--with-" .. package, "no")
+ end})
+
+ table.insert(filters, {"^([%w_-]+)=(.*)$", setPair})
+ table.insert(filters, {"^([%w_-]+)$", setTrue})
+
+ for _,a in ipairs(arg)
+ do
+ for _,filter in pairs(filters)
+ do
+ local matches = {a:match(filter[1])}
+ if matches[1] then filter[2](unpack(matches)) break end
+ end
+ end
+
+ return result
+end
+
+
+local arguments = parseArguments(unpack(arg))
+local interactive = arguments["--interactive"]
+local rules = arguments["--rules"] or "options.lua"
+local configfile = arguments["--configfile"] or "config.mk"
+local printendmsg = arguments["--print-instructions"]
+local exportHeader = arguments["--export-header"]
+local exportTerms = arguments["--export-terms"]
+
+
+local util = require "utility"
+util.logfile = "config.log"
+
+
+local printInfo = util.printer("%s - %s\n")
+local printWarning = util.printer("\a%s - %s\n", "33")
+local printError = util.printer("\a%s - %s\n", "31")
+local function beginProcess(title, caption)
+ print(string.format("%s:\n", title))
+ local updater = util.printer(" [%3d%%] %s\n")
+ updater(0, caption)
+ return function(progress, caption)
+ if progress ~= nil
+ then
+ if 0.0 <= progress and progress <= 1.0 then progress = progress * 100 end
+ return updater(progress, caption)
+ end
+ print()
+ return 0
+ end
+end
+
+local function loadDialog(name, configfile)
+ local dialog
+ local result, err = pcall(function() dialog = require "dialog" end)
+ if not result
+ then
+ printWarning(err)
+ return nil
+ end
+ dialog.title = string.format("%s - %s Configuration", configfile, name)
+ printInfo = dialog.msgbox
+ printWarning = dialog.msgbox
+ printError = dialog.msgbox
+ beginProcess = dialog.gauge
+ return dialog
+end
+
+
+local function topologicalSort(lookup)
+ local dependants = util.copy(lookup, "v", {v = function() return 0 end})
+ for _,option in pairs(lookup)
+ do
+ for _,dep in ipairs(option:getDirectDependants())
+ do
+ dependants[dep] = dependants[dep] + 1
+ end
+ end
+
+ local sorted = {}
+ local queued = {}
+ for symbol,count in pairs(dependants)
+ do
+ if count == 0 then table.insert(queued, symbol) end
+ end
+ while 0 < #queued
+ do
+ local symbol = table.remove(queued)
+ table.insert(sorted, symbol)
+ for _,dep in ipairs(lookup[symbol]:getDirectDependants())
+ do
+ dependants[dep] = dependants[dep] - 1
+ if dependants[dep] == 0 then table.insert(queued, dep) end
+ end
+ end
+
+ local remaining = {}
+ for symbol,count in pairs(dependants)
+ do
+ if 0 < count then table.insert(remaining, symbol) end
+ end
+ if 0 < #remaining
+ then
+ printWarning("Q.A. Notice", "One or more circular dependencies were detected involving these symbols: "
+ .. table.concat(remaining, ", "))
+ for _,symbol in ipairs(remaining) do table.insert(sorted, symbol) end
+ end
+
+ return sorted
+end
+
+local function checkSymbols(symbols)
+ local check = topologicalSort(symbols)
+ local isErr = false
+ local updateTask = function() end
+ if 1 < #check
+ then
+ updateTask = beginProcess("Checking Symbols", "Resolving dependencies...", 6, 65)
+ end
+ for i = 1, #check
+ do
+ local option = symbols[check[i]]
+ if option:validate() == nil then isErr = true end
+ updateTask(i / #check,
+ (option:getSymbol() .. ": " .. option:toExpandedString()):truncate(60))
+ end
+ updateTask()
+ if isErr then return nil end
+ return true
+end
+
+
+---------------------------------------------------------------------------
+local Option = util.class()
+---------------------------------------------------------------------------
+
+function Option:__init(rule, lookup, objects)
+ self.name = rule.name
+ self.caption = rule.caption
+ self.help = rule.help
+ self.value = rule.value
+ self.symbol = rule.symbol
+ self.cmdline = rule.cmdline
+ self.config = rule.config
+ self.export = rule.export
+ self.visible = rule.visible
+ self.check = rule.check
+ self.temp = rule.temp
+ self.before = rule.before
+ self.after = rule.after
+ self.lookup = lookup or {}
+ self.objects = objects or {}
+
+ if type(self.check) == "function" then setfenv(self.check, self.lookup) end
+ if type(self.visible) == "function" then setfenv(self.visible, self.lookup) end
+
+ if self.symbol ~= nil
+ then
+ if self.lookup[self.symbol] ~= nil
+ then
+ printWarning("duplicate symbol defined:", self.symbol)
+ end
+ self.lookup[self.symbol] = self.value
+ self.objects[self.symbol] = self
+ end
+end
+
+-- Get the symbol of the option. The symbol is used as a reference in the
+-- string values of other options. It must be unique.
+function Option:getSymbol()
+ return self.symbol
+end
+
+-- Get the argument of the option.
+function Option:getArg()
+ return self.cmdline
+end
+
+-- Get the value of the option as a string.
+function Option:toString()
+ return tostring(self.lookup[self.symbol])
+end
+
+-- Get the value of the option as an expanded string. For most types of
+-- options, this is the same as Option:toString().
+function Option:toExpandedString()
+ return self:toString()
+end
+
+function Option:getDirectDependants()
+ return self.before or {}
+end
+
+function Option:getUnsortedDependants(dependants)
+ dependants = dependants or {}
+ if dependants[self.symbol] then return dependants end
+ dependants[self.symbol] = self
+ if self.before
+ then
+ for _,dep in ipairs(self.before)
+ do
+ local option = self.objects[dep]
+ if option
+ then
+ dependants = option:getUnsortedDependants(dependants)
+ else
+ printWarning("invalid dependency: " .. dep)
+ end
+ end
+ end
+ return dependants
+end
+
+function Option:addDependant(dependency)
+ self.before = self.before or {}
+ table.insert(self.before, dependency)
+end
+
+function Option:convertDependenciesToDependants()
+ if self.after
+ then
+ local dep = table.remove(self.after)
+ while dep ~= nil
+ do
+ local option = self.objects[dep]
+ if option
+ then
+ option:addDependant(self.symbol)
+ else
+ printWarning("invalid dependency: " .. dep)
+ end
+ dep = table.remove(self.after)
+ end
+ end
+end
+
+function Option:getObjects()
+ return self.objects
+end
+
+-- Check the value of the option for validity.
+-- Returns a valid value based on the given value, or nil (with an error
+-- message) if the value is invalid and could not be converted to a valid
+-- value.
+function Option:validate(value)
+ local err
+ if value == nil then value = self.lookup[self.symbol] end
+ self.problem = nil
+ if type(self.check) == "function"
+ then
+ value, err = self.check(value)
+ if value == nil then self.problem = err return nil, err end
+ end
+ self.lookup[self.symbol] = value
+ return value, err
+end
+
+-- Set the value of the option to the value in a new lookup table.
+function Option:applyTable(lookup)
+end
+
+-- Set the value of the option based on a table of argument flags.
+function Option:applyArguments()
+end
+
+-- Set the value of the option.
+function Option:set(value)
+ self.lookup[self.symbol] = value
+ if checkSymbols(self:getUnsortedDependants())
+ then
+ return self.lookup[self.symbol]
+ end
+end
+
+-- Write the symbol and current value to the config file.
+function Option:writeSymbol(fd)
+ if self.symbol ~= nil and not self.temp
+ then
+ fd:write(util.align(self.symbol, "= " .. tostring(self.lookup[self.symbol]), 16) .. "\n")
+ --fd:write(string.format("%s\t= %s\n", self.symbol, tostring(self.lookup[self.symbol])))
+ end
+end
+
+-- Write the option value to the config header file.
+function Option:writeCppLine(fd)
+end
+
+-- Write the option value as a string replacement to the sed file.
+function Option:writeSedLine(fd)
+ if self.export
+ then
+ local value = self:toExpandedString():gsub("/", "\\/")
+ local function writeLine(key)
+ key = tostring(key):gsub("/", "\\/")
+ fd:write(string.format("s/@%s@/%s/g\n", key, value))
+ end
+ if type(self.export) == "table"
+ then
+ for _,key in ipairs(self.export) do writeLine(key) end
+ else
+ writeLine(self.export)
+ end
+ end
+end
+
+-- Run an interactive menu with the given dialog context. The type of menu
+-- run will depend on the type of option.
+function Option:showMenu(dialog)
+end
+
+-- Get whether or not there is a problem with the current value of the
+-- option.
+function Option:isValid()
+ return type(self.problem) ~= "string"
+end
+
+-- Get a human-readable description of the problem(s) this option faces
+-- before it can be considered valid.
+function Option:getProblem()
+ return self.problem
+end
+
+-- Get the name to be used for this option in the interactive menu.
+function Option:getMenuItem()
+ if not self:isValid() then return self.name .. " <!>" end
+ return self.name
+end
+
+-- Get the label used to represent this option in a menu.
+function Option:getLabel()
+ return ""
+end
+
+-- Get whether or not this option should be visible in a menu of options.
+-- Returns true if option is visible, false otherwise.
+function Option:isVisible()
+ if type(self.visible) == "function" then return self.visible() end
+ return true
+end
+
+-- If the option has an argument flag, print out a line with information
+-- about the purpose of this option.
+function Option:printHelpLine()
+ if self.cmdline ~= nil
+ then
+ print(util.align(" " .. self:getArg(), self.caption, 32))
+ end
+end
+
+function Option:getHelpText()
+ local value = self:toString()
+ local help = self.help or "No help available.\n"
+ local name = self.name or "Unnamed"
+ local symbol = self:getSymbol() or "None"
+ local arg = self:getArg() or "None"
+
+ local problem = self:getProblem()
+ if problem then problem = "\nProblem(s):\n" .. problem
+ else problem = "" end
+
+ return [[
+
+]] .. help .. [[
+
+ Option Name: ]] .. name .. [[
+
+ Symbol: ]] .. symbol .. [[
+
+ Current Value: ]] .. value .. [[
+
+ Argument: ]] .. arg .. [[
+
+]] .. problem
+end
+
+
+---------------------------------------------------------------------------
+local StringOption = util.class(Option)
+---------------------------------------------------------------------------
+
+-- Get the expanded option value. Symbols which begin with dollar signs
+-- will be substituted for their values.
+function StringOption:toExpandedString()
+ local function expand(value)
+ _, value, count = pcall(string.gsub, value, "%$%(([%w_]+)%)", self.lookup)
+ if not count then count = 0 end
+ return value, count
+ end
+ local value = self.lookup[self.symbol]
+ local iterations = 0
+ while iterations < 8
+ do
+ local count = 0
+ value, count = expand(value)
+ if count == 0 then return value end
+ iterations = iterations + 1
+ end
+ return value
+end
+
+function StringOption:applyTable(lookup)
+ local value = lookup[self.symbol]
+ if type(value) == "string" then self.lookup[self.symbol] = tostring(value) end
+end
+
+function StringOption:applyArguments(args)
+ local value = args[self.cmdline]
+ if value ~= nil then self:validate(tostring(value)) end
+end
+
+function StringOption:writeCppLine(fd)
+ if self.config
+ then
+ local value = self:toExpandedString()
+ local function writeLine(key)
+ if type(self.value) == "string"
+ then
+ fd:write(string.format("#define %s %q\n", key, value))
+ else
+ fd:write(string.format("#define %s %s\n", key, value))
+ end
+ end
+ if type(self.config) == "table"
+ then
+ for _,key in ipairs(self.config) do writeLine(key) end
+ else
+ writeLine(self.config)
+ end
+ end
+end
+
+function StringOption:showMenu(dialog)
+ local code, item = dialog.inputbox(self.name, self.caption, self.lookup[self.symbol])
+ if code == 0 and item ~= self.lookup[self.symbol]
+ then
+ return self:set(item)
+ end
+end
+
+function StringOption:getLabel()
+ return self:toExpandedString()
+end
+
+
+---------------------------------------------------------------------------
+local EnumOption = util.class(StringOption)
+---------------------------------------------------------------------------
+
+-- An enumeration option is like a string, but it can only hold certain
+-- pre-determined values. In a rule, it is distinguished by its value key
+-- which refers to an array of the possible (string) values.
+function EnumOption:__init(rule, lookup, objects)
+ Option.__init(self, rule, lookup, objects)
+ self.lookup[self.symbol] = self.value[1]
+end
+
+function EnumOption:getArg()
+ if self.cmdline == nil then return nil end
+ return self.cmdline .. "=[" .. table.concat(self.value, "|") .. "]"
+end
+
+function EnumOption:validate(str)
+ str = str or self.lookup[self.symbol]
+ for _,value in ipairs(self.value)
+ do
+ if value == str then return Option.validate(self, str) end
+ end
+ self.problem = "The assigned value (" .. str .. ") is not a valid option."
+ return nil, self.problem
+end
+
+function EnumOption:applyArguments(args)
+ -- Just like applying arguments for strings, but if the argument is
+ -- false, assume the first value should be assigned.
+ local value = args[self.cmdline]
+ if value == false then self:validate(self.value[1]) return end
+ StringOption.applyArguments(self, args)
+end
+
+function EnumOption:writeCppLine(fd)
+ if self.config
+ then
+ local value = self:toString():upper()
+ local function writeLine(key)
+ key = tostring(key) .. "_" .. value
+ fd:write(string.format("#define %s 1\n", key))
+ end
+ if type(self.config) == "table"
+ then
+ for _,key in ipairs(self.config) do writeLine(key) end
+ else
+ writeLine(self.config)
+ end
+ end
+end
+
+function EnumOption:showMenu(dialog)
+ local menuitems = {}
+ for _,value in ipairs(self.value)
+ do
+ table.insert(menuitems, {value, ""})
+ end
+ local code, item = dialog.menu(
+ self.name,
+ self.caption,
+ menuitems,
+ self.lookup[self.symbol],
+ {["--ok-label"] = "Select"}
+ )
+ if code == 0 and item ~= self.lookup[self.symbol]
+ then
+ return self:set(item)
+ end
+end
+
+function EnumOption:getLabel()
+ return "[" .. StringOption.getLabel(self) .. "]"
+end
+
+
+---------------------------------------------------------------------------
+local BooleanOption = util.class(Option)
+---------------------------------------------------------------------------
+
+function BooleanOption:toString()
+ if self.lookup[self.symbol] then return "Yes" else return "No" end
+end
+
+function BooleanOption:applyTable(lookup)
+ local value = lookup[self.symbol]
+ if type(value) == "boolean" then self.lookup[self.symbol] = value end
+end
+
+function BooleanOption:applyArguments(args)
+ local value = args[self.cmdline]
+ if value == "yes" or value == "" then value = true end
+ if value == "no" then value = false end
+ if type(value) == "boolean" then self:validate(value) end
+end
+
+function BooleanOption:writeCppLine(fd)
+ if self.config
+ then
+ local value = self.lookup[self.symbol]
+ local function writeLine(key)
+ -- Reverse the value if key starts with a bang.
+ local value = value
+ if key:byte(1) == 33 then key = key:sub(2) value = not value end
+ if value
+ then
+ fd:write("#define " .. key .. " 1\n")
+ else
+ fd:write("/* #undef " .. key .. " */\n")
+ end
+ end
+ if type(self.config) == "table"
+ then
+ for _,key in ipairs(self.config) do writeLine(key) end
+ else
+ writeLine(self.config)
+ end
+ end
+end
+
+function BooleanOption:showMenu(dialog)
+ local item = not self.lookup[self.symbol]
+ return self:set(item)
+end
+
+function BooleanOption:getLabel()
+ if self.lookup[self.symbol] then return "[X]" else return "[ ]" end
+end
+
+
+---------------------------------------------------------------------------
+local NullOption = util.class(Option)
+---------------------------------------------------------------------------
+
+-- Null options don't really hold any useful information; they just
+-- translate to a blank line in the menuconfig. Any non-table object in a
+-- rule will become this type of option.
+function NullOption:__init()
+ self.name = ""
+ self.lookup = {}
+end
+
+function NullOption:validate()
+ return true
+end
+function NullOption:isVisible()
+ return true
+end
+
+
+---------------------------------------------------------------------------
+local GroupOption = util.class(Option)
+---------------------------------------------------------------------------
+
+local function optionFactory(rule, lookup, objects)
+ local jump = setmetatable({
+ string = StringOption,
+ number = StringOption,
+ table = EnumOption,
+ boolean = BooleanOption
+ }, {
+ __index = function() return GroupOption end
+ })
+ if type(rule) == "table"
+ then
+ return jump[type(rule.value)](rule, lookup, objects)
+ else
+ -- If the rule is not a table, just insert a placeholder option for
+ -- a blank line.
+ return NullOption()
+ end
+end
+
+-- A GroupOption is not really an option itself, but a group of options.
+function GroupOption:__init(rule, lookup, objects)
+ Option.__init(self, rule, lookup, objects)
+ self.children = {}
+
+ for _,child in ipairs(rule)
+ do
+ table.insert(self.children, optionFactory(child, self.lookup, self.objects))
+ end
+end
+
+function GroupOption:toString()
+ return "n/a"
+end
+
+-- Call the method with an arbitrary number of arguments to each
+-- sub-option.
+function GroupOption:recurse(method, ...)
+ for _,child in ipairs(self.children)
+ do
+ child[method](child, unpack(arg))
+ end
+end
+
+function GroupOption:convertDependenciesToDependants()
+ self:recurse("convertDependenciesToDependants")
+end
+
+-- Validate each sub-option in order. The validation will short-circuit
+-- and return nil (with an error message) upon the first failed validation.
+function GroupOption:validate()
+ for _,child in ipairs(self.children)
+ do
+ local result, err = child:validate()
+ if result == nil then return result, err end
+ end
+ return true
+end
+
+function GroupOption:isValid()
+ for _,child in ipairs(self.children)
+ do
+ if not child:isValid() then return false end
+ end
+ return true
+end
+
+function GroupOption:getProblem()
+ local problems = ""
+ for _,child in ipairs(self.children)
+ do
+ local problem = child:getProblem()
+ if problem
+ then
+ local symbol = child:getSymbol()
+ if symbol
+ then
+ problems = problems .. util.align(symbol .. ":", problem, 16) .. "\n"
+ else
+ problems = problems .. problem .. "\n"
+ end
+ util.align(symbol, problem, 16)
+ end
+ end
+ if problems == "" then return nil end
+ return util.trim(problems)
+end
+
+function GroupOption:applyTable(lookup)
+ self:recurse("applyTable", lookup)
+end
+
+function GroupOption:applyArguments(args)
+ self:recurse("applyArguments", args)
+end
+
+function GroupOption:writeSymbol(fd)
+ if self.name ~= nil then
+ fd:write(string.format("\n# %s\n", self.name))
+ self:recurse("writeSymbol", fd)
+ end
+end
+
+function GroupOption:writeCppLine(fd)
+ self:recurse("writeCppLine", fd)
+end
+
+function GroupOption:writeSedLine(fd)
+ self:recurse("writeSedLine", fd)
+end
+
+
+function GroupOption:showMenu(dialog)
+ local running, dirty, selected = true
+ while running
+ do
+ local menuitems = {}
+ for _,value in ipairs(self.children)
+ do
+ if type(value) ~= "table"
+ then
+ table.insert(menuitems, value)
+ elseif type(value.name) == "string" and value:isVisible()
+ then
+ local name = value:getMenuItem()
+ local label = value:getLabel()
+ local caption = ""
+ if type(value.caption) == "string"
+ then
+ caption = value.caption
+ menuitems["HELP " .. value.caption] = value
+ end
+ menuitems[name] = value
+ table.insert(menuitems, {name, label, caption})
+ end
+ end
+
+ local code, item = dialog.menu(
+ self.name,
+ self.caption,
+ menuitems,
+ selected,
+ {
+ ["--ok-label"] = "Select",
+ ["--cancel-label"] = "Exit",
+ ["--item-help"] = true,
+ ["--help-button"] = true
+ }
+ )
+
+ if code == 0
+ then
+ local value = menuitems[item]
+ if type(value) == "table"
+ then
+ if value:showMenu(dialog) ~= nil then dirty = "changed" end
+ selected = value:getMenuItem()
+ else
+ selected = value
+ end
+ elseif code == 2
+ then
+ local value = menuitems[item]
+ if value
+ then
+ dialog.msgbox(value.name, value:getHelpText(), {["--no-collapse"] = true})
+ selected = value:getMenuItem()
+ else
+ dialog.msgbox("No Help",
+ "Sorry, no help is available for this option.")
+ end
+ else
+ running = false
+ end
+ end
+ return dirty
+end
+
+function GroupOption:getLabel()
+ return "-->"
+end
+
+function GroupOption:printHelpLine()
+ if self:isVisible() and self.name ~= nil then
+ print(string.format("\n%s:", self.name))
+ self:recurse("printHelpLine")
+ end
+end
+
+
+-- Print arguments and usage information for all of the sub-options.
+function GroupOption:printHelp(name)
+ print([[
+
+This script prepares ]] .. name .. [[ for building on your system.
+Usage: ./configure [OPTION]... [VAR=VALUE]...]])
+
+ self:printHelpLine()
+ print()
+end
+
+-- Set values of the sub-options based on a table that is loaded from a
+-- file. The table is formatted as one or more lines with keys and values
+-- separated by an equal sign. The pound sign (#) serves to start a
+-- comment on the line. The first equal sign on a line is used as the
+-- separator, so keys cannot have an equal sign.
+function GroupOption:loadFromFile(filepath)
+ local lookup = {}
+ local fd = io.open(filepath)
+ if fd
+ then
+ for line in fd:lines()
+ do
+ if not line:find("^%s*#")
+ then
+ key, value = line:match("^%s*(%S.-)%s*=%s*(.*)%s*")
+ if value
+ then
+ if value:upper() == "TRUE" then value = true
+ elseif value:upper() == "FALSE" then value = false end
+ end
+ if key then lookup[key] = value end
+ end
+ end
+ fd:close()
+ end
+ self:applyTable(lookup)
+end
+
+-- Save a table with the current values of the sub-options to a file. The
+-- file can be reloaded with GroupOption:loadFromFile.
+function GroupOption:saveToFile(filepath)
+ local fd = io.open(filepath, "w")
+ if fd
+ then
+ fd:write(string.format("\n# Auto-generated: %s", os.date()))
+ self:writeSymbol(fd)
+ fd:write("\n")
+ else
+ printError("couldn't save config file to:", filepath)
+ end
+end
+
+-- Exports the config header file. The key-value pairs of sub-options with
+-- "config" defined will be written to the file.
+function GroupOption:exportHeader(filepath)
+ local fd = io.open(filepath, "w")
+ self:writeCppLine(fd)
+ fd:close()
+end
+
+-- Exports the search 'n replace file. The key-value pairs of sub-options
+-- with "export" defined will be written to the file.
+function GroupOption:exportTerms(filepath)
+ local fd = io.open(filepath, "w")
+ self:writeSedLine(fd)
+ fd:close()
+end
+
+-- Run menuconfig. This is different from showMenu in that this method
+-- tracks changes and returns an action: save, cancel, nochange or error.
+function GroupOption:runMenu()
+ local result, dirty = nil, false
+ while result == nil
+ do
+ if self:showMenu(dialog) ~= nil then dirty = true end
+ if not self:isValid()
+ then
+ local code = dialog.yesno("Oh drat!",
+ "There is at least one problem with the configuration, marked with <!>, and the configuration will not be saved. Do you really want to exit without saving?",
+ {
+ ["--extra-button"] = false,
+ ["--ok-label"] = "Exit",
+ ["--cancel-label"] = "Back"
+ })
+ if code == 0 or code == 255 then result = "error" end
+ elseif dirty
+ then
+ local code = dialog.yesno("Save Changes?",
+ "Your configuration has been altered. Do you want to save the changes?",
+ {
+ ["--ok-label"] = "Save",
+ ["--cancel-label"] = "Back",
+ ["--extra-button"] = true,
+ ["--extra-label"] = "Exit"
+ })
+ if code == 0 then result = "save"
+ elseif code == 3 or code == 255 then result = "cancel" end
+ else
+ result = "nochange"
+ end
+ end
+ return result
+end
+
+
+local loadFn = assert(loadfile(rules))
+local name, rules = loadFn()
+
+local options = optionFactory(rules)
+if arguments["--help"] then options:printHelp(name) os.exit() end
+
+options:loadFromFile(configfile)
+if exportHeader or exportTerms
+then
+ if exportHeader then options:exportHeader(exportHeader) end
+ if exportTerms then options:exportTerms(exportTerms) end
+ os.exit()
+end
+
+print()
+printInfo(name, "Preparing for building and installation on your system.\n")
+options:applyArguments(arguments)
+
+if interactive then loadDialog(name, configfile) end
+
+options:convertDependenciesToDependants()
+checkSymbols(options:getObjects())
+
+if dialog
+then
+ local action = options:runMenu()
+ if action == "exit" or action == "error"
+ then
+ print("configuration aborted by user request")
+ os.exit(1)
+ else
+ options:saveToFile(configfile)
+ print("configuration saved to " .. configfile)
+ end
+elseif options:isValid()
+then
+ options:saveToFile(configfile)
+else
+ printError("Uh oh!", [[
+There is at least one unresolved problem with the configuration.
+]] .. options:getProblem() .. "\n")
+ os.exit(2)
+end
+
+if printendmsg ~= "no"
+then
+ printInfo("Configuration complete!", [[
+To finish the installation, type:
+ make
+ make install
+]])
+end
+
+-- vi:ts=4 sw=4 tw=75
+
projects / chaz / yoink / blobdiff