417 lines
7.5 KiB
Lua
417 lines
7.5 KiB
Lua
definerule("normalrule",
|
|
{
|
|
ins = { type="targets" },
|
|
outleaves = { type="strings" },
|
|
label = { type="string", optional=true },
|
|
commands = { type="strings" },
|
|
vars = { type="table", default={} },
|
|
},
|
|
function (e)
|
|
local objpath = "$(OBJDIR)/"..e.name
|
|
local realouts = {}
|
|
for k, v in pairs(e.outleaves) do
|
|
realouts[k] = concatpath(objpath, v)
|
|
end
|
|
|
|
local vars = inherit(e.vars, {
|
|
dir = objpath
|
|
})
|
|
|
|
local result = simplerule {
|
|
name = e.name,
|
|
ins = e.ins,
|
|
outs = realouts,
|
|
label = e.label,
|
|
commands = e.commands,
|
|
vars = vars,
|
|
}
|
|
result.dir = objpath
|
|
return result
|
|
end
|
|
)
|
|
|
|
definerule("cfile",
|
|
{
|
|
srcs = { type="targets" },
|
|
deps = { type="targets", default={} },
|
|
commands = {
|
|
type="strings",
|
|
default={
|
|
"$(CC) -c -o %{outs[1]} %{ins[1]} %{hdrpaths}"
|
|
},
|
|
}
|
|
},
|
|
function (e)
|
|
local csrcs = filenamesof(e.srcs, "%.c$")
|
|
if (#csrcs ~= 1) then
|
|
error("you must have exactly one .c file")
|
|
end
|
|
|
|
local hsrcs = filenamesof(e.srcs, "%.h$")
|
|
local hdeps = selectof(e.deps, "%.h$")
|
|
local hdrpaths = {}
|
|
for _, t in pairs(hdeps) do
|
|
hdrpaths[#hdrpaths+1] = "-I"..t.dir
|
|
end
|
|
hdrpaths = uniquify(hdrpaths)
|
|
|
|
for _, f in pairs(filenamesof(hdeps)) do
|
|
hsrcs[#hsrcs+1] = f
|
|
end
|
|
|
|
local outleaf = basename(csrcs[1]):gsub("%.c$", ".o")
|
|
|
|
return normalrule {
|
|
name = e.name,
|
|
ins = {csrcs[1], unpack(hsrcs)},
|
|
outleaves = {outleaf},
|
|
label = e.label,
|
|
commands = e.commands,
|
|
vars = {
|
|
hdrpaths = hdrpaths
|
|
}
|
|
}
|
|
end
|
|
)
|
|
|
|
definerule("bundle",
|
|
{
|
|
srcs = { type="targets" },
|
|
commands = {
|
|
type="strings",
|
|
default={
|
|
"tar cf - %{ins} | (cd %{dir} && tar xf -)"
|
|
}
|
|
}
|
|
},
|
|
function (e)
|
|
local outleaves = {}
|
|
local commands = {}
|
|
for _, f in pairs(filenamesof(e.srcs)) do
|
|
local localf = basename(f)
|
|
outleaves[#outleaves+1] = localf
|
|
commands[#commands+1] = "cp "..f.." %{dir}/"..localf
|
|
end
|
|
|
|
return normalrule {
|
|
name = e.name,
|
|
ins = e.srcs,
|
|
outleaves = outleaves,
|
|
label = e.label,
|
|
commands = commands
|
|
}
|
|
end
|
|
)
|
|
|
|
definerule("clibrary",
|
|
{
|
|
srcs = { type="targets" },
|
|
deps = { type="targets", default={} },
|
|
commands = {
|
|
type="strings",
|
|
default={
|
|
"rm -f %{outs}",
|
|
"$(AR) qs %{outs} %{ins}"
|
|
},
|
|
}
|
|
},
|
|
function (e)
|
|
local csrcs = filenamesof(e.srcs, "%.c$")
|
|
if (#csrcs < 1) then
|
|
error("you must supply at least one C source file")
|
|
end
|
|
|
|
local hsrcs = filenamesof(e.srcs, "%.h$")
|
|
|
|
local ins = {}
|
|
for _, csrc in pairs(csrcs) do
|
|
local n = basename(csrc):gsub("%.%w*$", "")
|
|
ins[#ins+1] = cfile {
|
|
name = e.name.."/"..n,
|
|
srcs = {csrc, unpack(hsrcs)},
|
|
deps = e.deps,
|
|
}
|
|
end
|
|
|
|
return normalrule {
|
|
name = e.name,
|
|
ins = ins,
|
|
outleaves = { e.name..".a" },
|
|
label = e.label,
|
|
commands = e.commands
|
|
}
|
|
end
|
|
)
|
|
|
|
clibrary {
|
|
name = "mylib",
|
|
srcs = {
|
|
"modules/src/string/*.c",
|
|
},
|
|
deps = {
|
|
"modules:headers"
|
|
}
|
|
}
|
|
|
|
--[[
|
|
--
|
|
-- Targets:
|
|
--
|
|
-- {
|
|
-- dir = target's build directory
|
|
-- outs = target's object files
|
|
-- is = { set of rule types which made the target }
|
|
-- }
|
|
function M.subenv(p)
|
|
local e = p[1]
|
|
setmetable(p, {__index = e})
|
|
return p
|
|
end
|
|
|
|
local function check_filename(fn)
|
|
if type(fn) == "table" then
|
|
for _, f in ipairs(fn) do
|
|
check_filename(f)
|
|
end
|
|
else
|
|
if fn:find("%s") then
|
|
error("Filename '"+fn+"' contains spaces. This will make the build system sad.")
|
|
end
|
|
end
|
|
end
|
|
|
|
function M.basename(fn)
|
|
if type(fn) == "table" then
|
|
local nfn = {}
|
|
for _, f in ipairs(fn) do
|
|
nfn[#nfn+1] = M.basename(f)
|
|
end
|
|
return nfn
|
|
else
|
|
local _, _, base = fn:find("([^/]*)$")
|
|
return base
|
|
end
|
|
end
|
|
|
|
function M.flatten(t)
|
|
if t == nil then
|
|
return {}
|
|
end
|
|
|
|
local tt = {}
|
|
for _, subt in ipairs(t) do
|
|
if type(subt) == "table" then
|
|
for _, subt in ipairs(M.flatten(subt)) do
|
|
tt[#tt+1] = subt
|
|
end
|
|
else
|
|
tt[#tt+1] = subt
|
|
end
|
|
end
|
|
return tt
|
|
end
|
|
|
|
local function append(...)
|
|
local ts = {}
|
|
for _, t in ipairs({...}) do
|
|
for _, v in ipairs(t) do
|
|
ts[#ts+1] = v
|
|
end
|
|
end
|
|
return ts
|
|
end
|
|
|
|
local function settotable(s)
|
|
local t = {}
|
|
for k in pairs(s) do
|
|
t[#t+1] = k
|
|
end
|
|
return t
|
|
end
|
|
|
|
local function asstring(t)
|
|
return table.concat(M.flatten(t), " ")
|
|
end
|
|
|
|
local function emit(...)
|
|
for _, s in ipairs({...}) do
|
|
io.stdout:write(s)
|
|
end
|
|
end
|
|
|
|
function M.rawtarget(p)
|
|
local description = p.description or error("no description supplied")
|
|
local ins = M.flatten(p.ins)
|
|
local outs = M.flatten(p.outs)
|
|
|
|
local cmd = p.command
|
|
if type(cmd) ~= "table" then
|
|
cmd = {cmd}
|
|
end
|
|
|
|
for _, s in ipairs(ins) do
|
|
check_filename(s)
|
|
end
|
|
for _, s in ipairs(outs) do
|
|
check_filename(s)
|
|
end
|
|
|
|
emit(outs[1], ":")
|
|
for _, s in ipairs(ins) do
|
|
emit(" ", s)
|
|
end
|
|
emit("\n")
|
|
|
|
emit("\t@echo ", p.description, "\n")
|
|
|
|
emit("\t$(hide) ", table.concat(cmd, " && "), "\n")
|
|
|
|
for i = 2, #outs do
|
|
emit(outs[i], ": ", outs[1], "\n")
|
|
end
|
|
|
|
emit("\n")
|
|
end
|
|
|
|
function M.export(p)
|
|
local e = p[1]
|
|
local dest = p.dest or error("no export destination provided")
|
|
local deps = p.deps or error("nothing to export")
|
|
|
|
local fdeps = M.flatten(deps)
|
|
|
|
if #fdeps ~= 1 then
|
|
error("you can only export one thing at a time")
|
|
end
|
|
|
|
return M.rawtarget {e,
|
|
ins=deps,
|
|
outs={dest},
|
|
command="cp "..fdeps[1].." "..dest,
|
|
description="EXPORT "..dest
|
|
}
|
|
end
|
|
|
|
function M.hermetic(p)
|
|
local e = p[1]
|
|
local ins = M.flatten(p.ins)
|
|
local deps = M.flatten(p.deps)
|
|
local baseouts = p.baseouts or error("you must specify some baseouts")
|
|
local description = p.description
|
|
|
|
local absouts = {}
|
|
local path = e.PATH .. "/" .. p.baseouts[1] .. ".env"
|
|
|
|
for _, s in ipairs(M.flatten(p.baseouts)) do
|
|
absouts[#absouts+1] = path .. "/" .. s
|
|
end
|
|
|
|
local dirset = {}
|
|
for _, s in ipairs(absouts) do
|
|
local d = s:gsub("^(.*/).*$", "%1")
|
|
if d then
|
|
dirset[d] = true
|
|
end
|
|
end
|
|
|
|
local newcmd = {
|
|
"rm -rf "..path,
|
|
"mkdir -p "..asstring(settotable(dirset)),
|
|
"ln -srf "..asstring(append(ins, deps)).." "..path,
|
|
"cd "..path
|
|
}
|
|
for _, s in ipairs(p.command) do
|
|
newcmd[#newcmd+1] = "(" .. s .. ")"
|
|
end
|
|
|
|
M.rawtarget {e,
|
|
ins={ins, unpack(deps)},
|
|
outs=absouts,
|
|
command=newcmd,
|
|
description=description
|
|
}
|
|
|
|
return absouts
|
|
end
|
|
|
|
function M.cfile(p)
|
|
local e = p[1]
|
|
local src = p.src
|
|
local deps = p.deps or {}
|
|
|
|
local outfile = p.src:gsub("%.c$", ".o")
|
|
local basesrc = M.basename(p.src)
|
|
|
|
return M.hermetic {e,
|
|
ins={src},
|
|
deps=deps,
|
|
baseouts={outfile},
|
|
command={e.CC.." "..e.CFLAGS.." -c -o "..outfile.." "..basesrc},
|
|
description="CC "..src
|
|
}
|
|
end
|
|
|
|
function M.cprogram(p)
|
|
local e = p[1]
|
|
local name = p.name or error("cprogram must have a name specified")
|
|
local deps = p.deps or {}
|
|
local libs = p.libraries or {}
|
|
local headers = p.headers or {}
|
|
|
|
if p.srcs then
|
|
local mainlib = M.clibrary {e,
|
|
name=name..".a",
|
|
deps=deps,
|
|
srcs=p.srcs,
|
|
headers=headers
|
|
}
|
|
|
|
deps = append(deps, {mainlib})
|
|
end
|
|
|
|
local libflags = {}
|
|
for _, s in ipairs(libs) do
|
|
libflags[#libflags+1] = "-l"..s
|
|
end
|
|
|
|
return M.hermetic {e,
|
|
ins=deps,
|
|
baseouts={name},
|
|
command={e.CC.." "..e.CFLAGS.." -o "..name.." "..asstring(M.basename(deps)).." "..asstring(libflags)},
|
|
description="CLINK "..name
|
|
}
|
|
end
|
|
|
|
function M.clibrary(p)
|
|
local e = p[1]
|
|
local name = p.name or error("clibrary must have a name specified")
|
|
local deps = M.flatten(p.deps)
|
|
local srcs = M.flatten(p.srcs)
|
|
local headers = M.flatten(p.headers)
|
|
|
|
local baseouts = {name}
|
|
|
|
local objs = deps
|
|
for _, f in ipairs(srcs) do
|
|
objs[#objs+1] = M.cfile {e,
|
|
src=f,
|
|
deps=headers
|
|
}
|
|
end
|
|
|
|
return M.hermetic {e,
|
|
ins=append(objs, headers),
|
|
baseouts=baseouts,
|
|
command={
|
|
e.AR.." q "..name.." "..asstring(M.basename(objs)),
|
|
e.RANLIB.." "..name,
|
|
},
|
|
description="CLIBRARY "..name
|
|
}
|
|
end
|
|
|
|
emit("hide = @\n")
|
|
|
|
return M
|
|
--]]
|