--

-- 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)