388 lines
10 KiB
Lua
388 lines
10 KiB
Lua
--
|
|
-- d/actions/gmake.lua
|
|
-- Define the D makefile action(s).
|
|
-- Copyright (c) 2013-2015 Andrew Gough, Manu Evans, and the Premake project
|
|
--
|
|
|
|
local p = premake
|
|
local m = p.modules.d
|
|
|
|
m.make = {}
|
|
|
|
local dmake = m.make
|
|
|
|
require ("gmake")
|
|
|
|
local make = p.make
|
|
local cpp = p.make.cpp
|
|
local project = p.project
|
|
local config = p.config
|
|
local fileconfig = p.fileconfig
|
|
|
|
-- This check may be unnecessary as we only 'require' this file from d.lua
|
|
-- IFF the action already exists, however this may help if this file is
|
|
-- directly required, rather than d.lua itself.
|
|
local gmake = p.action.get( 'gmake' )
|
|
if gmake == nil then
|
|
error( "Failed to locate prequisite action 'gmake'" )
|
|
end
|
|
|
|
--
|
|
-- Patch the gmake action with the allowed tools...
|
|
--
|
|
gmake.valid_languages = table.join(gmake.valid_languages, { p.D } )
|
|
gmake.valid_tools.dc = { "dmd", "gdc", "ldc" }
|
|
|
|
function m.make.separateCompilation(prj)
|
|
local some = false
|
|
local all = true
|
|
for cfg in project.eachconfig(prj) do
|
|
if cfg.compilationmodel == "File" then
|
|
some = true
|
|
else
|
|
all = false
|
|
end
|
|
end
|
|
return iif(all, "all", iif(some, "some", "none"))
|
|
end
|
|
|
|
|
|
--
|
|
-- Override the GMake action 'onProject' funtion to provide
|
|
-- D knowledge...
|
|
--
|
|
p.override( gmake, "onProject", function(oldfn, prj)
|
|
p.escaper(make.esc)
|
|
if project.isd(prj) then
|
|
local makefile = make.getmakefilename(prj, true)
|
|
p.generate(prj, makefile, m.make.generate)
|
|
return
|
|
end
|
|
oldfn(prj)
|
|
end)
|
|
|
|
p.override( make, "objdir", function(oldfn, cfg)
|
|
if cfg.project.language ~= "D" or cfg.compilationmodel == "File" then
|
|
oldfn(cfg)
|
|
end
|
|
end)
|
|
|
|
p.override( make, "objDirRules", function(oldfn, prj)
|
|
if prj.language ~= "D" or m.make.separateCompilation(prj) ~= "none" then
|
|
oldfn(prj)
|
|
end
|
|
end)
|
|
|
|
|
|
---
|
|
-- Add namespace for element definition lists for p.callarray()
|
|
---
|
|
|
|
m.elements = {}
|
|
|
|
--
|
|
-- Generate a GNU make C++ project makefile, with support for the new platforms API.
|
|
--
|
|
|
|
m.elements.makefile = function(prj)
|
|
return {
|
|
make.header,
|
|
make.phonyRules,
|
|
m.make.configs,
|
|
m.make.objects, -- TODO: This is basically identical to make.cppObjects(), and should ideally be merged/shared
|
|
make.shellType,
|
|
m.make.targetRules,
|
|
make.targetDirRules,
|
|
make.objDirRules,
|
|
make.cppCleanRules, -- D clean code is identical to C/C++
|
|
make.preBuildRules,
|
|
make.preLinkRules,
|
|
m.make.dFileRules,
|
|
}
|
|
end
|
|
|
|
function m.make.generate(prj)
|
|
p.callArray(m.elements.makefile, prj)
|
|
end
|
|
|
|
|
|
function m.make.buildRule(prj)
|
|
_p('$(TARGET): $(SOURCEFILES) $(LDDEPS)')
|
|
_p('\t@echo Building %s', prj.name)
|
|
_p('\t$(SILENT) $(BUILDCMD)')
|
|
_p('\t$(POSTBUILDCMDS)')
|
|
end
|
|
|
|
function m.make.linkRule(prj)
|
|
_p('$(TARGET): $(OBJECTS) $(LDDEPS)')
|
|
_p('\t@echo Linking %s', prj.name)
|
|
_p('\t$(SILENT) $(LINKCMD)')
|
|
_p('\t$(POSTBUILDCMDS)')
|
|
end
|
|
|
|
function m.make.targetRules(prj)
|
|
local separateCompilation = m.make.separateCompilation(prj)
|
|
if separateCompilation == "all" then
|
|
m.make.linkRule(prj)
|
|
elseif separateCompilation == "none" then
|
|
m.make.buildRule(prj)
|
|
else
|
|
for cfg in project.eachconfig(prj) do
|
|
_x('ifeq ($(config),%s)', cfg.shortname)
|
|
if cfg.compilationmodel == "File" then
|
|
m.make.linkRule(prj)
|
|
else
|
|
m.make.buildRule(prj)
|
|
end
|
|
_p('endif')
|
|
end
|
|
end
|
|
_p('')
|
|
end
|
|
|
|
function m.make.dFileRules(prj)
|
|
local separateCompilation = m.make.separateCompilation(prj)
|
|
if separateCompilation ~= "none" then
|
|
make.cppFileRules(prj)
|
|
end
|
|
end
|
|
|
|
--
|
|
-- Override the 'standard' file rule to support D source files
|
|
--
|
|
|
|
p.override(cpp, "standardFileRules", function(oldfn, prj, node)
|
|
-- D file
|
|
if path.isdfile(node.abspath) then
|
|
_p('\t$(SILENT) $(DC) $(ALL_DFLAGS) $(OUTPUTFLAG) -c $<')
|
|
else
|
|
oldfn(prj, node)
|
|
end
|
|
end)
|
|
|
|
--
|
|
-- Let make know it can compile D source files
|
|
--
|
|
|
|
p.override(make, "fileType", function(oldfn, node)
|
|
if path.isdfile(node.abspath) then
|
|
return "objects"
|
|
else
|
|
return oldfn(node)
|
|
end
|
|
end)
|
|
|
|
|
|
--
|
|
-- Write out the settings for a particular configuration.
|
|
--
|
|
|
|
m.elements.makeconfig = function(cfg)
|
|
return {
|
|
m.make.dTools,
|
|
make.target,
|
|
m.make.target,
|
|
make.objdir,
|
|
m.make.versions,
|
|
m.make.debug,
|
|
m.make.imports,
|
|
m.make.stringImports,
|
|
m.make.dFlags,
|
|
make.libs,
|
|
make.ldDeps,
|
|
make.ldFlags,
|
|
m.make.linkCmd,
|
|
make.preBuildCmds,
|
|
make.preLinkCmds,
|
|
make.postBuildCmds,
|
|
m.make.allRules,
|
|
make.settings,
|
|
}
|
|
end
|
|
|
|
function m.make.configs(prj)
|
|
for cfg in project.eachconfig(prj) do
|
|
-- identify the toolset used by this configurations (would be nicer if
|
|
-- this were computed and stored with the configuration up front)
|
|
|
|
local toolset = p.tools[_OPTIONS.dc or cfg.toolset or "dmd"]
|
|
if not toolset then
|
|
error("Invalid toolset '" + (_OPTIONS.dc or cfg.toolset) + "'")
|
|
end
|
|
|
|
_x('ifeq ($(config),%s)', cfg.shortname)
|
|
p.callArray(m.elements.makeconfig, cfg, toolset)
|
|
_p('endif')
|
|
_p('')
|
|
end
|
|
end
|
|
|
|
function m.make.dTools(cfg, toolset)
|
|
local tool = toolset.gettoolname(cfg, "dc")
|
|
if tool then
|
|
_p(' DC = %s', tool)
|
|
end
|
|
end
|
|
|
|
function m.make.target(cfg, toolset)
|
|
if cfg.compilationmodel == "File" then
|
|
_p(' OUTPUTFLAG = %s', toolset.gettarget('"$@"'))
|
|
end
|
|
end
|
|
|
|
function m.make.versions(cfg, toolset)
|
|
_p(' VERSIONS +=%s', make.list(toolset.getversions(cfg.versionconstants, cfg.versionlevel)))
|
|
end
|
|
|
|
function m.make.debug(cfg, toolset)
|
|
_p(' DEBUG +=%s', make.list(toolset.getdebug(cfg.debugconstants, cfg.debuglevel)))
|
|
end
|
|
|
|
function m.make.imports(cfg, toolset)
|
|
local imports = p.esc(toolset.getimportdirs(cfg, cfg.importdirs))
|
|
_p(' IMPORTS +=%s', make.list(imports))
|
|
end
|
|
|
|
function m.make.stringImports(cfg, toolset)
|
|
local stringImports = p.esc(toolset.getstringimportdirs(cfg, cfg.stringimportdirs))
|
|
_p(' STRINGIMPORTS +=%s', make.list(stringImports))
|
|
end
|
|
|
|
function m.make.dFlags(cfg, toolset)
|
|
_p(' ALL_DFLAGS += $(DFLAGS)%s $(VERSIONS) $(DEBUG) $(IMPORTS) $(STRINGIMPORTS) $(ARCH)', make.list(table.join(toolset.getdflags(cfg), cfg.buildoptions)))
|
|
end
|
|
|
|
function m.make.linkCmd(cfg, toolset)
|
|
if cfg.compilationmodel == "File" then
|
|
_p(' LINKCMD = $(DC) ' .. toolset.gettarget("$(TARGET)") .. ' $(ALL_LDFLAGS) $(LIBS) $(OBJECTS)')
|
|
|
|
-- local cc = iif(p.languages.isc(cfg.language), "CC", "CXX")
|
|
-- _p(' LINKCMD = $(%s) -o $(TARGET) $(OBJECTS) $(RESOURCES) $(ARCH) $(ALL_LDFLAGS) $(LIBS)', cc)
|
|
else
|
|
_p(' BUILDCMD = $(DC) ' .. toolset.gettarget("$(TARGET)") .. ' $(ALL_DFLAGS) $(ALL_LDFLAGS) $(LIBS) $(SOURCEFILES)')
|
|
end
|
|
end
|
|
|
|
function m.make.allRules(cfg, toolset)
|
|
-- TODO: The C++ version has some special cases for OSX and Windows... check whether they should be here too?
|
|
if cfg.compilationmodel == "File" then
|
|
_p('all: $(TARGETDIR) $(OBJDIR) prebuild prelink $(TARGET)')
|
|
else
|
|
_p('all: $(TARGETDIR) prebuild prelink $(TARGET)')
|
|
end
|
|
_p('\t@:')
|
|
-- _p('')
|
|
end
|
|
|
|
|
|
--
|
|
-- List the objects file for the project, and each configuration.
|
|
--
|
|
|
|
-- TODO: This is basically identical to make.cppObjects(), and should ideally be merged/shared
|
|
|
|
function m.make.objects(prj)
|
|
-- create lists for intermediate files, at the project level and
|
|
-- for each configuration
|
|
local root = { sourcefiles={}, objects={} }
|
|
local configs = {}
|
|
for cfg in project.eachconfig(prj) do
|
|
configs[cfg] = { sourcefiles={}, objects={} }
|
|
end
|
|
|
|
-- now walk the list of files in the project
|
|
local tr = project.getsourcetree(prj)
|
|
p.tree.traverse(tr, {
|
|
onleaf = function(node, depth)
|
|
-- figure out what configurations contain this file, and
|
|
-- if it uses custom build rules
|
|
local incfg = {}
|
|
local inall = true
|
|
local custom = false
|
|
for cfg in project.eachconfig(prj) do
|
|
local filecfg = fileconfig.getconfig(node, cfg)
|
|
if filecfg and not filecfg.flags.ExcludeFromBuild then
|
|
incfg[cfg] = filecfg
|
|
custom = fileconfig.hasCustomBuildRule(filecfg)
|
|
else
|
|
inall = false
|
|
end
|
|
end
|
|
|
|
if not custom then
|
|
-- skip files that aren't compiled
|
|
if not path.isdfile(node.abspath) then
|
|
return
|
|
end
|
|
|
|
local sourcename = node.relpath
|
|
|
|
-- TODO: assign a unique object file name to avoid collisions
|
|
local objectname = "$(OBJDIR)/" .. node.objname .. ".o"
|
|
|
|
-- if this file exists in all configurations, write it to
|
|
-- the project's list of files, else add to specific cfgs
|
|
if inall then
|
|
table.insert(root.sourcefiles, sourcename)
|
|
table.insert(root.objects, objectname)
|
|
else
|
|
for cfg in project.eachconfig(prj) do
|
|
if incfg[cfg] then
|
|
table.insert(configs[cfg].sourcefiles, sourcename)
|
|
table.insert(configs[cfg].objects, objectname)
|
|
end
|
|
end
|
|
end
|
|
|
|
else
|
|
for cfg in project.eachconfig(prj) do
|
|
local filecfg = incfg[cfg]
|
|
if filecfg then
|
|
-- if the custom build outputs an object file, add it to
|
|
-- the link step automatically to match Visual Studio
|
|
local output = project.getrelative(prj, filecfg.buildoutputs[1])
|
|
if path.isobjectfile(output) then
|
|
table.insert(configs[cfg].objects, output)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
end
|
|
})
|
|
|
|
local separateCompilation = m.make.separateCompilation(prj)
|
|
|
|
-- now I can write out the lists, project level first...
|
|
function listobjects(var, list)
|
|
_p('%s \\', var)
|
|
for _, objectname in ipairs(list) do
|
|
_x('\t%s \\', objectname)
|
|
end
|
|
_p('')
|
|
end
|
|
|
|
if separateCompilation ~= "all" then
|
|
listobjects('SOURCEFILES :=', root.sourcefiles)
|
|
end
|
|
if separateCompilation ~= "none" then
|
|
listobjects('OBJECTS :=', root.objects, 'o')
|
|
end
|
|
|
|
-- ...then individual configurations, as needed
|
|
for cfg in project.eachconfig(prj) do
|
|
local files = configs[cfg]
|
|
if (#files.sourcefiles > 0 and separateCompilation ~= "all") or (#files.objects > 0 and separateCompilation ~= "none") then
|
|
_x('ifeq ($(config),%s)', cfg.shortname)
|
|
if #files.sourcefiles > 0 and separateCompilation ~= "all" then
|
|
listobjects(' SOURCEFILES +=', files.sourcefiles)
|
|
end
|
|
if #files.objects > 0 and separateCompilation ~= "none" then
|
|
listobjects(' OBJECTS +=', files.objects)
|
|
end
|
|
_p('endif')
|
|
end
|
|
end
|
|
_p('')
|
|
end
|