--- /dev/null
+--
+-- Yoink Build System
+-- A pseudo-random collection of useful Lua functions.
+--
+-- 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 M = {
+ logfile = "config.log"
+}
+
+
+-- Sometimes it is useful to iterate over an array with gaps or sections of
+-- nil values, skipping over such empty sections. This function, like the
+-- standard ipairs, creates an iterator, except the iterator will look n
+-- indices past any nil key it finds. The argument n should be given as
+-- the largest possible number of consecutive nils; it defaults to 4. This
+-- function can typically serve as a drop-in replacement for ipairs.
+local function npairs(t, n)
+ n = tonumber(n) or 4
+ return function(t, k)
+ for i = k + 1, k + n
+ do
+ local v = t[i]
+ if v ~= nil then return i, v end
+ end
+ end, t, 0
+end
+M.npairs = npairs
+
+
+-- Makes a copy of an object. For most objects, this just returns the
+-- object that was passed. For tables, a new table will be created and the
+-- contents of the original object will either be assigned or copied over,
+-- depending on the mode. The mode enables deep copies; it is a string
+-- which may be empty or contain any combination of subsets of "k", "v",
+-- and "m" for copying keys, values and metatables, respectively. The
+-- default behavior is to deep copy only the values. The subcopy argument
+-- is the function to be called when making subcopies during a deep copy.
+-- It may also be a table with keys equal to one or more of the copy modes
+-- and values set as the subcopy function to use for the type of object
+-- represented by the copy mode character identifier.
+local function copy(object, mode, subcopy)
+ if type(object) ~= "table" then return object end
+ mode = mode or "v"
+ local copykey = function(object) return object end
+ local copyvalue, copymetatable = copykey, copykey
+ if type(subcopy) == "table"
+ then
+ if mode:find("k") and type(subcopy.k) == "function"
+ then
+ copykey = subcopy.k
+ end
+ if mode:find("v") and type(subcopy.v) == "function"
+ then
+ copyvalue = subcopy.v
+ end
+ if mode:find("m") and type(subcopy.m) == "function"
+ then
+ copymetatable = subcopy.m
+ end
+ else
+ if type(subcopy) ~= "function" then subcopy = copy end
+ if mode:find("k") then copykey = subcopy end
+ if mode:find("v") then copyvalue = subcopy end
+ if mode:find("m") then copymetatable = subcopy end
+ end
+ local new = {}
+ for key,value in pairs(object) do
+ new[copykey(key, mode)] = copyvalue(value, mode)
+ end
+ return setmetatable(new, copymetatable(getmetatable(object), mode))
+end
+M.copy = copy
+
+
+-- Like the standard table.concat function in all respects except values
+-- are transformed by an optional function given; the function defaults to
+-- tostring, so tables with objects for which the concatenate operator
+-- cannot apply do not cause an error to be thrown.
+local function concat(t, s, i, j, f)
+ f = f or tostring
+ return table.concat(copy(t, "v", f), s, i, j)
+end
+M.concat = concat
+
+-- Escape the argument, preparing it for passage through a shell parse.
+local function escape(str)
+ return string.format("%q", tostring(str))
+end
+M.escape = escape
+
+-- Run the test command with the given arguments. If the test passes,
+-- returns true; false if the test fails.
+local function test(...)
+ return os.execute(string.format("test %s", concat(arg, " ", 1, #arg, escape))) == 0
+end
+M.test = test
+
+
+-- Format a string with two pieces of text; the first bit of text is
+-- printed as-is, and the next bit of text is printed left-justified with
+-- an indent. The second bit of text is pushed to the right if the first
+-- bit of text is too big.
+local function align(text1, text2, indent)
+ text1 = text1 or ""
+ text2 = text2 or ""
+ indent = indent or 8
+ local numSpaces = math.max(indent - #text1 - 1, 0)
+ for i = 0, numSpaces do text2 = " " .. text2 end
+ return text1 .. text2
+end
+M.align = align
+
+
+-- Remove the whitespace surrounding a string.
+local function trim(str)
+ return (str:gsub("^%s*(.-)%s*$", "%1"))
+end
+M.trim = trim
+
+-- Trim the string and convert all sequences of whitespace to a single
+-- space.
+local function compact(str)
+ return trim(str:gsub("%s+", " "))
+end
+M.compact = compact
+
+
+-- Execute a command and return its output or nil if the command failed to
+-- run. Use capture to specify which file descriptor to return. The exit
+-- code of the command is also returned.
+local function exec(command, capture)
+ capture = capture or ""
+ local tmpname = os.tmpname()
+ local full = string.format("%s %s>%q", command, tostring(capture), tmpname)
+ local code = os.execute(full)
+ local fd = io.open(tmpname)
+ local output = ""
+ if fd then output = fd:read("*a") fd:close() end
+ os.remove(tmpname)
+ if M.logfile
+ then
+ local fd = io.open(M.logfile, "a")
+ fd:write("\n# ", command, "\n", output, "# exit: ", code, "\n")
+ fd:close()
+ end
+ return trim(output), code
+end
+M.exec = exec
+
+-- Try to execute a command and return true if the command finished
+-- successfully (with an exit code of zero).
+local function try_run(command, dir)
+ if type(dir) == "string" then dir = string.format("cd %q && ", dir) else dir = "" end
+ local output, code= exec(string.format("%s%s", dir, command))
+ return code == 0
+end
+M.try_run = try_run
+
+-- Look for a command from a list that can complete successfully (with exit
+-- code zero) given some arguments. Returns nil and an error string if
+-- none were successful.
+local function find_command(commands, args, dir)
+ if type(commands) ~= "table" then commands = {commands} end
+ if type(args) ~= "string" then args = "" end
+ local paths = os.getenv("PATH")
+ local found = false
+ for _,command in npairs(commands)
+ do
+ if command:byte() == 0x2F
+ then
+ if test("-x", command)
+ then
+ if try_run(command .. " " .. args, dir) then return command end
+ found = true
+ end
+ else
+ for path in paths:gmatch("([^:]*)")
+ do
+ local command = path .. "/" .. command
+ if test("-x", command)
+ then
+ if try_run(command .. " " .. args, dir) then return command end
+ found = true
+ end
+ end
+ end
+ if found then return nil, "command failed" end
+ return nil, "command not found"
+ end
+end
+M.find_command = find_command
+
+
+local function make_tempdir(template)
+ local dir, code = exec(string.format("mktemp -d ${TMPDIR:-/tmp}/%q", template))
+ if code == 0 then return dir end
+end
+M.make_tempdir = make_tempdir
+
+
+local function pkgfind(libs, libdir)
+ local cmd = "pkg-config"
+ if type(libdir) == "string" and libdir ~= ""
+ then
+ cmd = string.format("PKG_CONFIG_PATH=%s/pkgconfig:$PKG_CONFIG_PATH %s", libdir, cmd)
+ end
+ local function invoke(package) return exec(cmd .. " " .. package) end
+ local packages, missing = {}, {}
+ for _,list in ipairs(libs:split("%S+"))
+ do
+ list = list:split("[^|]+")
+ local found = false
+ for _,package in ipairs(list)
+ do
+ local flags,code = invoke(package)
+ if code == 0
+ then
+ table.insert(packages, package)
+ found = true
+ break
+ end
+ end
+ if not found then table.insert(missing, list[1]) end
+ end
+ if #missing == 0 then return concat(packages, " ") end
+ return nil, "One or more required packages are missing: " .. concat(missing, ", ") .. ". Please install them."
+end
+M.pkgfind = pkgfind
+
+-- A wrapper function for a call out to pkg-config. The first argument is
+-- a string signifying what kind of flags to get, either CFLAGS, LIBS, or
+-- LDFLAGS. The second argument is the list of libraries. Finally, the
+-- last argument can be given as a path to libdir; it is used to add a new
+-- path to PKG_CONFIG_PATH when searching for "pc" files.
+local function pkgconfig(what, libs, libdir)
+ local cmd = "pkg-config"
+ if type(libdir) == "string" and libdir ~= ""
+ then
+ cmd = string.format("PKG_CONFIG_PATH=%s/pkgconfig:$PKG_CONFIG_PATH %s", libdir, cmd)
+ end
+ if what == "CFLAGS" or what == "CXXFLAGS"
+ then
+ return exec(cmd .. " --cflags " .. libs)
+ elseif what == "LIBS"
+ then
+ return exec(cmd .. " --libs-only-l " .. libs)
+ elseif what == "LDFLAGS"
+ then
+ local output, code = exec(cmd .. " --libs " .. libs)
+ output = output:gsub("%s%-l%S*", ""):gsub("^%-l%S*%s*", "")
+ return output, code
+ end
+ return exec(cmd .. " " .. libs)
+end
+M.pkgconfig = pkgconfig
+
+
+-- Escape special characters of a pattern string.
+local function escapePattern(str)
+ str = str:gsub("%%", "%%%%")
+ str = str:gsub("%^", "%%^")
+ str = str:gsub("%$", "%%$")
+ str = str:gsub("%(", "%%(")
+ str = str:gsub("%)", "%%)")
+ str = str:gsub("%.", "%%.")
+ str = str:gsub("%[", "%%[")
+ str = str:gsub("%]", "%%[")
+ str = str:gsub("%*", "%%*")
+ str = str:gsub("%+", "%%+")
+ str = str:gsub("%-", "%%-")
+ str = str:gsub("%?", "%%?")
+ return str
+end
+
+-- A basic split function for strings. Give a pattern of a sequence which
+-- should be matched and returns a table of matches.
+function string:split(pattern)
+ local t = {}
+ self:gsub(pattern, function(seq) table.insert(t, seq) end)
+ return t
+end
+
+-- Truncates a string to a certain length, appending an ellipsis if any
+-- part of the string had to be chopped.
+function string:truncate(length)
+ if length < #self then return self:sub(1, length - 3) .. "..." end
+ return self
+end
+
+
+-- Append a word (i.e. flag) to the end of the string.
+function string:appendFlag(...)
+ for _,flag in ipairs(arg)
+ do
+ if self == "" then self = flag
+ else self = string.format("%s %s", self, flag) end
+ end
+ return self
+end
+
+-- Set the flag by appending it to the end of the string unless it already
+-- exists somewhere else in the string. Note: The command line isn't
+-- parsed; a simple search is used to determined if a flag is set.
+function string:setFlag(...)
+ for _,flag in ipairs(arg)
+ do
+ local escaped = escapePattern(flag)
+ if not self:match(escaped) then self = self:appendFlag(flag) end
+ end
+ return self
+end
+
+-- Remove all matching flags from a string. Note: The command line isn't
+-- parsed; a simple search and replace is used to determine where a flag is
+-- set.
+function string:unsetFlag(...)
+ for _,flag in ipairs(arg)
+ do
+ flag = escapePattern(flag)
+ self = self:gsub("^"..flag.."$", "")
+ self = self:gsub("^"..flag.."%s", "")
+ self = self:gsub("%s"..flag.."$", "")
+ self = self:gsub("%s"..flag, "")
+ end
+ return self
+end
+
+-- Replace all matching flags from a string with a new flag. The old flag
+-- is parsed as a pattern, just like a substitution. Each flag matching
+-- the pattern is replaced by the new flag, but if no replacements are
+-- made, the new flag is appended to the string.
+function string:replaceFlag(old, new)
+ local count
+ self, count = self:gsub(old, new)
+ if count < 1 then self = self:appendFlag(new) end
+ return self
+end
+
+
+do
+ local colorCount = exec("tput colors")
+ local isTTY = test("-t", 1)
+
+ -- The logging facility is exported by way of this printer generator.
+ -- Pass a format and attribute string and get a function to print to
+ -- stdout. Attributes will only be used if stdout is a terminal with
+ -- at least eight colors. All arguments are optional; the default
+ -- format mimics the return print function regarding only the first
+ -- argument.
+ local function printer(format, attrib)
+ format = tostring(format or "%s\n")
+ if type(attrib) == "string" and isTTY and 8 <= tonumber(colorCount)
+ then
+ return function(...)
+ io.write(string.format("\e[%sm%s\e[0m", attrib, string.format(format, ...)))
+ end
+ else
+ return function(...)
+ io.write(string.format(format, ...))
+ end
+ end
+ end
+ M.printer = printer
+end
+
+
+-- Symbolize a name; that is, convert a string such that it would make a
+-- good filename. The string is converted to lower case and series of
+-- non-alphanumeric characters are converted to hyphens.
+local function symbolize(name)
+ return name:lower():gsub("%W+", "-")
+end
+M.symbolize = symbolize
+
+-- Take a standard version number with three parts and separate the parts
+-- into major, minor, and revision components.
+local function splitVersion(version)
+ local vmajor, vminor, vrevis = version:match("^(%d*)%.?(%d*)%.?(%d*)")
+ vmajor = tonumber(vmajor) or 0
+ vminor = tonumber(vminor) or 0
+ vrevis = tonumber(vrevis) or 0
+ return vmajor, vminor, vrevis
+end
+M.splitVersion = splitVersion
+
+
+-- Create a new class type. Pass one or more parent classes for
+-- inheritence.
+local function class(...)
+ local c = {__init = function() end}
+ local s = {}
+ for _,super in ipairs(arg)
+ do
+ for key,value in pairs(super) do c[key] = value end
+ table.insert(s, super)
+ end
+ c.__index = c
+ c.__super = s
+ local m = {}
+ function m:__call(...)
+ local o = setmetatable({}, c) o:__init(...) return o
+ end
+ function c:isa(c)
+ local function recurse(a, b)
+ if a == b then return true end
+ for _,super in ipairs(a.__super)
+ do
+ if recurse(super, b) then return true end
+ end
+ return false
+ end
+ return recurse(getmetatable(self), c)
+ end
+ return setmetatable(c, m)
+end
+M.class = class
+
+
+return M
+
projects / chaz / yoink / blobdiff