kc3-lang/SDL/premake/premake4.lua

Branch : - branch - v2.28 - tag -

• Show log

  Commit

• Author : Ryan C. Gordon
  Date : 2013-11-10 00:38:37
  Hash : 92b12812
  Message : Added Ben Henning's GSoC2013 work: premake build system.

• premake/premake4.lua

• -- Copyright (C) 1997-2011 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