389 lines
9.0 KiB
Lua
389 lines
9.0 KiB
Lua
require("Utils.utils")
|
|
|
|
-------------------------------------------------------
|
|
-- globals
|
|
-------------------------------------------------------
|
|
_G["projectsprocessor"] = {}
|
|
_G["projectsblocked"] = {}
|
|
_G["projectsemitted"] = {}
|
|
_G["namespacesemitted"] = {}
|
|
_G["usingClang"] = false
|
|
_G["usingMSVC"] = false
|
|
|
|
-------------------------------------------------------
|
|
-- process command line arguments into global space
|
|
-------------------------------------------------------
|
|
require("Boilerplate.options")
|
|
|
|
-------------------------------------------------------
|
|
-- debug stuff
|
|
-------------------------------------------------------
|
|
function printHeader(key, val)
|
|
print("-------------------------------------------------------")
|
|
print(key, val)
|
|
print("-------------------------------------------------------")
|
|
end
|
|
|
|
function dbgGroup(name)
|
|
printHeader("group", name);
|
|
group(name)
|
|
end
|
|
|
|
-------------------------------------------------------
|
|
-- API
|
|
-------------------------------------------------------
|
|
local jsonProcessor = require("Boilerplate.jsonProcessor")
|
|
|
|
local normalizeSourceRoot = function(path)
|
|
local backup = path
|
|
path = os.realpath(_G.path.join(os.getcwd(), path));
|
|
if (not path) then
|
|
print("path error, not found?", backup)
|
|
return
|
|
end
|
|
return path
|
|
end
|
|
|
|
local extendInfo = function(this)
|
|
local type = this.projectType:lower()
|
|
this.isShared = type == "sharedlib"
|
|
this.isStatic = type == "staticlib"
|
|
this.isExec = type == "consoleapp" or type == 'windowedapp'
|
|
this.isConsole = type == "consoleapp"
|
|
this.isWindowed = type == "windowedapp"
|
|
end
|
|
|
|
local requireAbs = function(path)
|
|
local absRefPath = os.realpath(getroot() .. "/Build_Scripts/")
|
|
local relPath = _G.path.getrelative(absRefPath, path)
|
|
if (os.isfile(relPath)) then
|
|
fatal("Script not found: ", relPath)
|
|
end
|
|
return require(relPath:sub(1, #relPath - 4))
|
|
end
|
|
|
|
function addVisit(ina)
|
|
local args = {
|
|
namespace = ina.namespace,
|
|
name = ina.name, -- OPT: recommended
|
|
path = ina.path,
|
|
type = ina.type,
|
|
out = ina.out,
|
|
translations = ina.translations -- OPT: dictionary of dependency maps
|
|
}
|
|
|
|
local path = normalizeSourceRoot(args.path)
|
|
if (not path) then
|
|
return
|
|
end
|
|
|
|
local info = {
|
|
namespace = args.namespace,
|
|
path = path,
|
|
projectType = args.type,
|
|
out = args.out,
|
|
name = args.name,
|
|
translations = args.translations
|
|
}
|
|
|
|
extendInfo(info)
|
|
|
|
local project = {
|
|
info = info,
|
|
processor = nil,
|
|
deps = {}
|
|
}
|
|
|
|
local cwd = getroot()
|
|
|
|
local remoteLua = path .. "/Aurora.lua"
|
|
local remoteJson = path .. "/Aurora.json"
|
|
local localJson = cwd .. "/Build_UserScripts/" .. args.name .. ".aurora.json"
|
|
local localLua = cwd .. "/Build_UserScripts/" .. args.name .. ".aurora.lua"
|
|
|
|
if (os.isfile(localLua)) then
|
|
project.processor = requireAbs(localLua)(info)
|
|
elseif (os.isfile(localJson)) then
|
|
info.jpath = localJson
|
|
project.processor = jsonProcessor(info)
|
|
elseif (os.isfile(remoteLua)) then
|
|
project.processor = requireAbs(remoteLua)(info)
|
|
elseif (os.isfile(remoteJson)) then
|
|
info.jpath = remoteJson
|
|
project.processor = jsonProcessor(info)
|
|
else
|
|
print("Couldnt find Aurora build script for: ", path)
|
|
return
|
|
end
|
|
|
|
projectsprocessor[info.name] = project
|
|
end
|
|
|
|
function addScript(ina)
|
|
local args = {
|
|
namespace = ina.namespace,
|
|
script = ina.script,
|
|
path = ina.path,
|
|
type = ina.type,
|
|
out = ina.out
|
|
}
|
|
|
|
local path = normalizeSourceRoot(args.path)
|
|
if (not path) then
|
|
return
|
|
end
|
|
|
|
local info = {
|
|
namespace = args.namespace,
|
|
path = path,
|
|
projectType = args.type,
|
|
out = args.out
|
|
}
|
|
|
|
extendInfo(info)
|
|
|
|
local project = {
|
|
info = info,
|
|
processor = nil,
|
|
deps = {}
|
|
}
|
|
|
|
local procesor = userRequire(args.script)
|
|
if (not procesor) then
|
|
processor = requireAbs(args.script)
|
|
if (not procesor) then
|
|
print("missing project script:", args.script, path)
|
|
return
|
|
end
|
|
end
|
|
|
|
project.processor = procesor(info)
|
|
if (not project.processor) then
|
|
print("script error")
|
|
return
|
|
end
|
|
|
|
projectsprocessor[info.name] = project
|
|
end
|
|
|
|
-- private
|
|
local processLocalProject = function(proj)
|
|
processProject(proj.info.name)
|
|
end
|
|
|
|
-- private
|
|
local processInit = function(project)
|
|
if (not project.isInitialized) then
|
|
if (project.processor.init) then
|
|
project.processor:init()
|
|
end
|
|
project.isInitialized = true
|
|
end
|
|
end
|
|
|
|
-- private
|
|
_G["_resolved_dep_res"] = {}
|
|
_G["_resolved_dep"] = {}
|
|
function processDepSearch(proj, resolveProject)
|
|
local name = proj.info.name
|
|
|
|
|
|
_G["_resolved_dep"][name] = name
|
|
|
|
if (not proj.resolvedDeps) then
|
|
if (proj.processor.resolveDependencies) then
|
|
proj.processor:resolveDependencies(function(name, soft)
|
|
|
|
table.insert(proj.deps, name)
|
|
|
|
if (_G["_resolved_dep"][name]) then
|
|
return
|
|
end
|
|
|
|
local depProj = projectsprocessor[name]
|
|
if (not depProj) then
|
|
if (not soft) then
|
|
fatal("missing dependency: ", name)
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
|
|
processDepSearch(depProj, true)
|
|
end)
|
|
end
|
|
proj.resolvedDeps = true
|
|
end
|
|
|
|
processInit(proj)
|
|
end
|
|
|
|
-- private
|
|
local processNS = function(namespace)
|
|
local projs = {}
|
|
local projsIdxs = {}
|
|
|
|
forEach(projectsprocessor, function(proj)
|
|
if (proj.info.namespace ~= namespace) then
|
|
return
|
|
end
|
|
|
|
local name = proj.info.name
|
|
projs[name] = proj
|
|
|
|
table.insert(projsIdxs, name)
|
|
end)
|
|
|
|
table.sort(projsIdxs, function(a, b)
|
|
return a:upper() < b:upper()
|
|
end)
|
|
|
|
forEach(projsIdxs, function(idx)
|
|
processDepSearch(projs[idx], true)
|
|
end)
|
|
|
|
forEach(projsIdxs, function(idx)
|
|
processLocalProject(projs[idx])
|
|
end)
|
|
end
|
|
|
|
function processSolution()
|
|
local hack = {}
|
|
|
|
local hackIdx = {}
|
|
forEach(projectsprocessor, function(proj)
|
|
table.insert(hackIdx, proj.info.namespace)
|
|
end)
|
|
|
|
table.sort(hackIdx, function(a, b)
|
|
return a:upper() < b:upper()
|
|
end)
|
|
|
|
forEach(hackIdx, processNS)
|
|
end
|
|
|
|
function attemptNS(ns)
|
|
local attemptLoad = false
|
|
if (not namespacesemitted[ns]) then
|
|
dbgGroup(ns) -- only print the group once
|
|
|
|
attemptLoad = true
|
|
end
|
|
|
|
-- this seems to be singleshot.
|
|
-- once you switch namespaces, theres no going back, it seems.
|
|
-- we try to preserve namespace-project contiguity as much as possible through sorting and evil recursion
|
|
namespace(ns)
|
|
return attemptLoad
|
|
end
|
|
|
|
resolved = {}
|
|
|
|
function processProject(name, required, noNs)
|
|
local a = projectsprocessor[name]
|
|
if (not a) then
|
|
if (required) then
|
|
fatal("missing project: ", name)
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
|
|
processInit(a)
|
|
|
|
if (projectsblocked[name]) then
|
|
return true
|
|
end
|
|
|
|
projectsblocked[name] = name
|
|
|
|
local ns = a.info.namespace
|
|
local loadOthers = attemptNS(ns)
|
|
|
|
local cwd = os.getcwd()
|
|
local old = _G["current_project"]
|
|
|
|
_G["current_project"] = name
|
|
os.chdir(a.info.path)
|
|
|
|
a.processor:process()
|
|
|
|
os.chdir(cwd)
|
|
_G["current_project"] = old
|
|
|
|
projectsemitted[name] = name
|
|
|
|
if (loadOthers) then
|
|
namespacesemitted[ns] = "";
|
|
processNS(ns)
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
function isWeakCircularReference(depName)
|
|
local curName = getCurrentProjectName()
|
|
|
|
local cur = projectsprocessor[curName]
|
|
if (not cur) then
|
|
return
|
|
end
|
|
|
|
local dep = projectsprocessor[depName]
|
|
if (not dep) then
|
|
return
|
|
end
|
|
|
|
for index, value in ipairs(dep.deps) do
|
|
if value == curName then
|
|
return true
|
|
end
|
|
end
|
|
|
|
return false
|
|
end
|
|
|
|
function isProjectLoaded(name)
|
|
local a = projectsprocessor[name]
|
|
if (not a) then
|
|
return false
|
|
end
|
|
|
|
return a.isInitialized
|
|
end
|
|
|
|
function getProjectInfo(name)
|
|
if (not name) then
|
|
return
|
|
end
|
|
local scre = projectsprocessor[name]
|
|
if (not scre) then
|
|
return
|
|
end
|
|
return scre.info
|
|
end
|
|
|
|
function getCurrentProjectName()
|
|
return current_project
|
|
end
|
|
|
|
-- private
|
|
local buildAction = require("Actions.buildAction")
|
|
-- executes inline under iprocessor::process
|
|
function addBuildAction(...)
|
|
buildAction(...)
|
|
end
|
|
|
|
-- executes inline under iprocessor::process
|
|
function addFeature(feature)
|
|
local script = getroot() .. "/Build_Scripts/Features/" .. feature:lower() .. ".lua"
|
|
|
|
if (not os.isfile(script)) then
|
|
fatal("missing feature", feature, script)
|
|
return
|
|
end
|
|
|
|
requireAbs(script)()
|
|
end
|
|
|
|
require ("Boilerplate.workspace") |