premake/premake4.lua
author Ryan C. Gordon <icculus@icculus.org>
Fri, 12 Aug 2016 19:59:00 -0400
changeset 10266 c09f06c4e8c8
parent 9998 f67cf37e9cd4
permissions -rwxr-xr-x
emscripten: send fake mouse events for touches, like other targets do. (This really should be handled at the higher level and not in the individual targets, but this fixes the immediate bug.)

-- Copyright (C) 1997-2016 Sam Lantinga <slouken@libsdl.org>
--
-- This software is provided 'as-is', without any express or implied
-- warranty.  In no event will the authors be held liable for any damages
-- arising from the use of this software.
--
-- Permission is granted to anyone to use this software for any purpose,
-- including commercial applications, and to alter it and redistribute it
-- freely.
--
-- Meta-build system using premake created and maintained by
-- Benjamin Henning <b.henning@digipen.edu>

--[[
premake4.lua

	This script sets up the entire premake system. It's responsible for executing
	all of the definition scripts for the SDL2 library and the entire test suite,
	or demos for the iOS platform. It handles each specific platform and uses the
	setup state to generate both the configuration header file needed to build
	SDL2 and the premake lua script to generate the target project files.
]]

-- string utility functions
dofile "util/sdl_string.lua"
-- utility file wrapper for some useful functions
dofile "util/sdl_file.lua"
-- system for defining SDL projects
dofile "util/sdl_projects.lua"
-- offers a utility function for finding dependencies specifically on windows
dofile "util/sdl_depends.lua"
-- system for generating a *config.h file used to build the SDL2 library
dofile "util/sdl_gen_config.lua"
-- functions to handle complicated dependency checks using CMake-esque functions
dofile "util/sdl_check_compile.lua"
-- a list of dependency functions for the SDL2 project and any other projects
dofile "util/sdl_dependency_checkers.lua"

-- the following are various options for configuring the meta-build system
newoption {
	trigger = "to",
	value   = "path",
	description = "Set the base output directory for the generated and executed lua file."
}

newoption {
	trigger = "mingw",
	description = "Runs the premake generation script targeted to MinGW."
}

newoption {
	trigger = "cygwin",
	description = "Runs the premake generation script targeted to Cygwin."
}

newoption {
	trigger = "ios",
	description = "Runs the premake generation script targeted to iOS."
}

-- determine the localized destination path
local baseLoc = "./"
if _OPTIONS["to"] then
	baseLoc = _OPTIONS["to"]:gsub("\\", "/")
end

local deps = SDL_getDependencies()
for _,v in ipairs(deps) do
	newoption {
		trigger = v:lower(),
		description = "Force on the dependency: " .. v
	}
end

-- clean action
if _ACTION == "clean" then
	-- this is kept the way it is because premake's default method of cleaning the
	-- build tree is not very good standalone, whereas the following correctly
	-- cleans every build option
	print("Cleaning the build environment...")
	os.rmdir(baseLoc .. "/SDL2")
	os.rmdir(baseLoc .. "/SDL2main")
	os.rmdir(baseLoc .. "/SDL2test")
	os.rmdir(baseLoc .. "/tests")
	os.rmdir(baseLoc .. "/Demos")
	os.rmdir(baseLoc .. "/ipch") -- sometimes shows up
	os.remove(baseLoc .. "/SDL.sln")
	os.remove(baseLoc .. "/SDL.suo")
	os.remove(baseLoc .. "/SDL.v11.suo")
	os.remove(baseLoc .. "/SDL.sdf")
	os.remove(baseLoc .. "/SDL.ncb")
	os.remove(baseLoc .. "/SDL-gen.lua")
	os.remove(baseLoc .. "/SDL_config_premake.h")
	os.remove(baseLoc .. "/Makefile")
	os.rmdir(baseLoc .. "/SDL.xcworkspace")
	os.exit()
end

-- only run through standard execution if not in help mode
if _OPTIONS["help"] == nil then
	-- load all of the project definitions
	local results = os.matchfiles("projects/**.lua")
	for _,dir in ipairs(results) do
		dofile(dir)
	end

	-- figure out which configuration template to use
	local premakeConfigHeader = baseLoc .. "/SDL_config_premake.h"
	-- minimal configuration is the default
	local premakeTemplateHeader = "./config/SDL_config_minimal.template.h"
	if SDL_getos() == "windows" or SDL_getos() == "mingw" then
		premakeTemplateHeader = "./config/SDL_config_windows.template.h"
	elseif SDL_getos() == "macosx" then
		premakeTemplateHeader = "./config/SDL_config_macosx.template.h"
	elseif SDL_getos() == "ios" then
		premakeTemplateHeader = "./config/SDL_config_iphoneos.template.h"
	elseif os.get() == "linux" then
		premakeTemplateHeader = "./config/SDL_config_linux.template.h"
	elseif SDL_getos() == "cygwin" then
		premakeTemplateHeader = "./config/SDL_config_cygwin.template.h"
	end

	local genFile = baseLoc .. "/SDL-gen.lua"
	local file = fileopen(genFile, "wt")
	print("Generating " .. genFile .. "...")
	-- begin generating the config header file
	startGeneration(premakeConfigHeader, premakeTemplateHeader)

	-- begin generating the actual premake script
	file:print(0, "-- Premake script generated by Simple DirectMedia Layer meta-build script")
	file:print(1, 'solution "SDL"')
	local platforms = { }
	local platformsIndexed = { }
		for n,p in pairs(projects) do
			if p.platforms and #p.platforms ~= 0 then
				for k,v in pairs(p.platforms) do
					platforms[v] = true
				end
			end
		end
		for n,v in pairs(platforms) do
			platformsIndexed[#platformsIndexed + 1] = n
		end
		file:print(2, implode(platformsIndexed, 'platforms {', '"', '"', ', ', '}'))
		file:print(2, 'configurations { "Debug", "Release" }')
		for n,p in pairs(projects) do
			if p.compat then
				local proj = {}
				if p.projectLocation ~= nil then
					proj.location = p.projectLocation .. "/" .. p.name
				else
					proj.location = p.name .. "/"
				end
				proj.includedirs = { path.getrelative(baseLoc,
					path.getdirectory(premakeConfigHeader)),
					path.getrelative(baseLoc, "../include") }
				proj.libdirs = { }
				proj.files = { }
				local links = { }
				local dbgCopyTable = { }
				local relCopyTable = { }
				-- custom links that shouldn't exist...
				-- (these should always happen before dependencies)
				if p.customLinks ~= nil then
					for k,lnk in pairs(p.customLinks) do
						table.insert(links, lnk)
					end
				end
				-- setup project dependencies
				local dependencyLocs = { }
				if p.projectDependencies ~= nil and #p.projectDependencies ~= 0 then
					for k,projname in pairs(p.projectDependencies) do
						local depproj = projects[projname]
						-- validation that it exists and can be linked to
						if depproj ~= nil and (depproj.kind == "SharedLib" or depproj.kind == "StaticLib") then
							if depproj.kind == "SharedLib" then
								local deplocation = nil
								if depproj.projectLocation ~= nil then
									deplocation = depproj.projectLocation .. "/" .. p.name
								else
									deplocation = depproj.name .. "/"
								end
								table.insert(dependencyLocs, { location = deplocation, name = projname })
							else -- static lib
								-- we are now dependent on everything the static lib is dependent on
								if depproj.customLinks ~= nil then
									for k,lnk in pairs(depproj.customLinks) do
										table.insert(links, lnk)
									end
								end
								-- also include links from dependencies
								for i,d in pairs(depproj.dependencyTree) do
									if d.links then
										for k,v in pairs(d.links) do
											local propPath = v:gsub("\\", "/")
											table.insert(links, propPath)
										end
									end
								end
							end
							-- finally, depend on the project itself
							table.insert(links, projname)
						elseif depproj == nil then
							print("Warning: Missing external dependency for project: ".. p.name ..
								". Be sure you setup project dependencies in a logical order.")
						else
							print("Warning: Cannot link " .. p.name .. " to second project " ..
								projname .. " because the second project is not a library.")
						end
					end
				end
				-- iterate across all root directories, matching source directories
				local dirs = createDirTable(p.sourcedir)
				-- but first, handle any files specifically set in the project, rather than
				-- its dependencies
				-- register c and h files in this directory
				if (p.files ~= nil and #p.files ~= 0) or (p.paths ~= nil and #p.paths ~= 0) then
					-- handle all lists of files
					if p.files ~= nil and #p.files ~= 0 then
						for k,filepat in pairs(p.files) do
							for k,f in pairs(os.matchfiles(p.sourcedir .. filepat)) do
								table.insert(proj.files, path.getrelative(baseLoc, f))
							end
						end
					end -- end props files if
					-- add all .c/.h files from each path
					-- handle all related paths
					if p.paths ~= nil and #p.paths ~= 0 then
						for j,filepat in ipairs(p.paths) do
							for k,f in pairs(os.matchfiles(p.sourcedir .. filepat .. "*.c")) do
								table.insert(proj.files, path.getrelative(baseLoc, f))
							end
							for k,f in pairs(os.matchfiles(p.sourcedir .. filepat .. "*.h")) do
								table.insert(proj.files, path.getrelative(baseLoc, f))
							end
							-- mac osx
							for k,f in pairs(os.matchfiles(p.sourcedir .. filepat .. "*.m")) do
								table.insert(proj.files, path.getrelative(baseLoc, f))
							end
						end
					end -- end of props paths if
				end -- end of check for files/paths in main project
				-- if this project has any configuration flags, add them to the current file
				if p.config then
					addConfig(p.config)
				end
				-- now, handle files and paths for dependencies
				for i,props in ipairs(p.dependencyTree) do
					if props.compat then
						-- register c and h files in this directory
						-- handle all lists of files
						if props.files ~= nil and #props.files ~= 0 then
							for k,filepat in pairs(props.files) do
								for k,f in pairs(os.matchfiles(p.sourcedir .. filepat)) do
									table.insert(proj.files, path.getrelative(baseLoc, f))
								end
							end
						end -- end props files if
						-- add all .c/.h files from each path
						-- handle all related paths
						if props.paths ~= nil and #props.paths ~= 0 then
							for j,filepat in ipairs(props.paths) do
								for k,f in pairs(os.matchfiles(p.sourcedir .. filepat .. "*.c")) do
									table.insert(proj.files, path.getrelative(baseLoc, f))
								end
								for k,f in pairs(os.matchfiles(p.sourcedir .. filepat .. "*.h")) do
									table.insert(proj.files, path.getrelative(baseLoc, f))
								end
								-- mac osx
								for k,f in pairs(os.matchfiles(p.sourcedir .. filepat .. "*.m")) do
									table.insert(proj.files, path.getrelative(baseLoc, f))
								end
							end
						end -- end of props paths if
						-- if this dependency has any special configuration flags, add 'em
						if props.config then
							addConfig(props.config)
						end -- end of props config if check
					end -- end check for compatibility
				end -- end of props loop
				--local debugConfig = configuration("Debug")
				local debugConfig = {}
				local releaseConfig = {}
				debugConfig.defines = { "USING_PREMAKE_CONFIG_H", "_DEBUG" }
				releaseConfig.defines = { "USING_PREMAKE_CONFIG_H", "NDEBUG" }
				-- setup per-project defines
				if p.defines ~= nil then
					for k,def in pairs(p.defines) do
						table.insert(debugConfig.defines, def)
						table.insert(releaseConfig.defines, def)
					end
				end
				debugConfig.buildoptions = { }
				if SDL_getos() == "windows" then
					table.insert(debugConfig.buildoptions, "/MDd")
				end
				debugConfig.linkoptions = { }
				releaseConfig.buildoptions = {}
				releaseConfig.linkoptions = {}
				local baseBuildDir = "/Build"
				if os.get() == "windows" then
					baseBuildDir = "/Win32"
				end
				debugConfig.flags = { "Symbols" }
				debugConfig.targetdir = proj.location .. baseBuildDir .. "/Debug"
				releaseConfig.flags = { "OptimizeSpeed" }
				releaseConfig.targetdir = proj.location .. baseBuildDir .. "/Release"
				-- setup postbuild options
				local dbgPostbuildcommands = { }
				local relPostbuildcommands = { }
				-- handle copying depended shared libraries to correct folders
				if os.get() == "windows" then
					for k,deploc in pairs(dependencyLocs) do
						table.insert(dbgCopyTable, { src = deploc.location .. baseBuildDir .. "/Debug/" .. deploc.name .. ".dll",
							dst = debugConfig.targetdir .. "/" .. deploc.name .. ".dll" })
						table.insert(relCopyTable, { src = deploc.location .. baseBuildDir .. "/Release/" .. deploc.name .. ".dll",
							dst = releaseConfig.targetdir .. "/" .. deploc.name .. ".dll" })
					end
				end
				if p.copy ~= nil then
					for k,file in pairs(p.copy) do
						-- the following builds relative paths native to the current system for copying, other
						-- than the copy command itself, this is essentially cross-platform for paths
					
						-- all custom copies should be relative to the current working directory
						table.insert(dbgCopyTable, { src = path.getrelative(baseLoc, p.sourcedir .. "/" .. file), dst = debugConfig.targetdir .. "/" .. file })
						table.insert(relCopyTable, { src = path.getrelative(baseLoc, p.sourcedir .. "/" .. file), dst = releaseConfig.targetdir .. "/" .. file })
					end
				end
				for k,file in pairs(dbgCopyTable) do
					-- all copies should be relative to project location, based on platform
					local relLocation = "./"
					--if os.get() == "windows" then
						relLocation = proj.location
					--end
					local fromPath = "./" .. path.getrelative(relLocation, file.src)
					local toPath = "./" .. path.getrelative(relLocation, file.dst)
					local toPathParent = path.getdirectory(toPath)
					local copyCommand = "cp"
					local destCheck = "if [ ! -d \\\"" .. toPathParent .. "\\\" ]; then mkdir -p \\\"" .. toPathParent .. "\\\"; fi"
					if SDL_getos() ~= "windows" and fromPath:find("*") ~= nil then
						-- to path must be a directory for * copies
						toPath = path.getdirectory(toPath)
					end
					if SDL_getos() == "windows" then
						fromPath = path.translate(fromPath, "/"):gsub("/", "\\\\")
						toPath = path.translate(toPath, "/"):gsub("/", "\\\\")
						toPathParent = path.translate(toPathParent, "/"):gsub("/", "\\\\")
						copyCommand = "copy"
						destCheck = "if not exist \\\"" .. toPathParent .. "\\\" ( mkdir \\\"" .. toPathParent .. "\\\" )"
					else
						fromPath = path.translate(fromPath, nil):gsub("\\", "/")
						toPath = path.translate(toPath, nil):gsub("\\", "/")
					end
					-- command will check for destination directory to exist and, if it doesn't,
					-- it will make the directory and then copy over any assets
					local quotedFromPath = fromPath
					if SDL_getos() == "windows" or fromPath:find("*") == nil then
						quotedFromPath = '\\"' .. quotedFromPath .. '\\"'
					end
					table.insert(dbgPostbuildcommands, destCheck)
					table.insert(dbgPostbuildcommands,
						copyCommand .. " " ..
						quotedFromPath .. " \\\"" ..
						toPath .. "\\\"")
				end
				for k,file in pairs(relCopyTable) do
					-- all copies should be relative to project location, based on platform
					local relLocation = "./"
					relLocation = proj.location
					local fromPath = "./" .. path.getrelative(relLocation, file.src)
					local toPath = "./" .. path.getrelative(relLocation, file.dst)
					local toPathParent = path.getdirectory(toPath)
					local copyCommand = "cp"
					local destCheck = "if [ ! -d \\\"" .. toPathParent .. "\\\" ]; then mkdir -p \\\"" .. toPathParent .. "\\\"; fi"
					if SDL_getos() ~= "windows" and fromPath:find("*") ~= nil then
						-- to path must be a directory for * copies
						toPath = path.getdirectory(toPath)
					end
					if SDL_getos() == "windows" then
						fromPath = path.translate(fromPath, "/"):gsub("/", "\\\\")
						toPath = path.translate(toPath, "/"):gsub("/", "\\\\")
						toPathParent = path.translate(toPathParent, "/"):gsub("/", "\\\\")
						copyCommand = "copy"
						destCheck = "if not exist \\\"" .. toPathParent .. "\\\" ( mkdir \\\"" .. toPathParent .. "\\\" )"
					else
						fromPath = path.translate(fromPath, nil):gsub("\\", "/")
						toPath = path.translate(toPath, nil):gsub("\\", "/")
					end
					-- command will check for destination directory to exist and, if it doesn't,
					-- it will make the directory and then copy over any assets
					local quotedFromPath = fromPath
					if SDL_getos() == "windows" or fromPath:find("*") == nil then
						quotedFromPath = '\\"' .. quotedFromPath .. '\\"'
					end
					table.insert(relPostbuildcommands, destCheck)
					table.insert(relPostbuildcommands,
						copyCommand .. " " ..
						quotedFromPath .. " \\\"" ..
						toPath .. "\\\"")
				end
				debugConfig.postbuildcommands = dbgPostbuildcommands
				debugConfig.links = links
				releaseConfig.postbuildcommands = relPostbuildcommands
				releaseConfig.links = links -- release links?
				for i,d in pairs(p.dependencyTree) do
					if d.includes then
						for k,v in pairs(d.includes) do
							local propPath = v:gsub("\\", "/")
							proj.includedirs[propPath] = propPath
						end
					end
					if d.libs then
						for k,v in pairs(d.libs) do
							local propPath = v:gsub("\\", "/")
							proj.libdirs[propPath] = propPath
						end
					end
					if d.links then
						for k,v in pairs(d.links) do
							local propPath = v:gsub("\\", "/")
							debugConfig.links[#debugConfig.links + 1] = propPath
						end
					end
				end
				if #proj.files > 0 then
					file:print(1, 'project "' .. p.name .. '"')
					file:print(2, 'targetname "' .. p.name .. '"')
					-- note: commented out because I think this hack is unnecessary
					--if iOSMode and p.kind == "ConsoleApp" then
						-- hack for iOS where we cannot build "tools"/ConsoleApps in
						-- Xcode for iOS, so we convert them over to WindowedApps
					--	p.kind = "WindowedApp"
					--end
					file:print(2, 'kind "' .. p.kind .. '"')
					file:print(2, 'language "' .. p.language .. '"')
					file:print(2, 'location "' .. proj.location .. '"')
					file:print(2, 'flags { "NoExceptions" }') -- NoRTTI
					file:print(2, 'buildoptions { }')--"/GS-" }')
					file:print(2, implode(proj.includedirs, 'includedirs {', '"', '"', ', ', '}'))
					file:print(2, implode(proj.libdirs, 'libdirs {', '"', '"', ', ', '}'))
					file:print(2, implode(proj.files, 'files {', '"', '"', ', ', '}'))
					-- debug configuration
					file:print(2, 'configuration "Debug"')
					file:print(3, 'targetdir "' .. debugConfig.targetdir .. '"')
					-- debug dir is relative to the solution's location
					file:print(3, 'debugdir "' .. debugConfig.targetdir .. '"')
					file:print(3, implode(debugConfig.defines, 'defines {', '"', '"', ', ', '}'))
					file:print(3, implode(debugConfig.links, "links {", '"', '"', ', ', "}"))
					if SDL_getos() == "mingw" then
						-- static runtime
						file:print(3, 'linkoptions { "-lmingw32 -static-libgcc" }')
					end
					if SDL_getos() == "cygwin" then
						file:print(3, 'linkoptions { "-static-libgcc" }')
					end
					file:print(3, implode(debugConfig.flags, "flags {", '"', '"', ', ', "}"))
					file:print(3, implode(debugConfig.postbuildcommands, "postbuildcommands {", '"', '"', ', ', "}"))
					-- release configuration
					file:print(2, 'configuration "Release"')
					file:print(3, 'targetdir "' .. releaseConfig.targetdir .. '"')
					-- debug dir is relative to the solution's location
					file:print(3, 'debugdir "' .. releaseConfig.targetdir .. '"')
					file:print(3, implode(releaseConfig.defines, 'defines {', '"', '"', ', ', '}'))
					file:print(3, implode(releaseConfig.links, "links {", '"', '"', ', ', "}"))
					if SDL_getos() == "mingw" then
						-- static runtime
						file:print(3, 'linkoptions { "-lmingw32 -static-libgcc" }')
					end
					file:print(3, implode(releaseConfig.flags, "flags {", '"', '"', ', ', "}"))
					file:print(3, implode(releaseConfig.postbuildcommands, "postbuildcommands {", '"', '"', ', ', "}"))
				end -- end check for valid project (files to build)
			end -- end compatibility check for projects
		end -- end for loop for projects

	endGeneration() -- finish generating the config header file
	file:close()

	-- generation is over, now execute the generated file, setup the premake
	-- solution, and let premake execute the action and generate the project files
	dofile(genFile)
end -- end check for not being in help mode