mirror of
https://github.com/FlightControl-Master/MOOSE.git
synced 2025-10-29 16:58:06 +00:00
3b69cf992e
* Installs luarocks WITH it's executable (easy to install other rocks if necessary) * Use Lua supplied with luarocks * Create Utils/luadocumentor.bat, which works with RELATIVE PATH ! -> Everybody can generate the doc * Updated launch files accordingly
761 lines
24 KiB
Lua
761 lines
24 KiB
Lua
--- Configuration for LuaRocks.
|
|
-- Tries to load the user's configuration file and
|
|
-- defines defaults for unset values. See the
|
|
-- <a href="http://luarocks.org/en/Config_file_format">config
|
|
-- file format documentation</a> for details.
|
|
--
|
|
-- End-users shouldn't edit this file. They can override any defaults
|
|
-- set in this file using their system-wide or user-specific configuration
|
|
-- files. Run `luarocks` with no arguments to see the locations of
|
|
-- these files in your platform.
|
|
|
|
local rawset, next, table, pairs, require, io, os, setmetatable, pcall, ipairs, package, tonumber, type, assert, _VERSION =
|
|
rawset, next, table, pairs, require, io, os, setmetatable, pcall, ipairs, package, tonumber, type, assert, _VERSION
|
|
|
|
--module("luarocks.cfg")
|
|
local cfg = {}
|
|
package.loaded["luarocks.cfg"] = cfg
|
|
|
|
local util = require("luarocks.util")
|
|
|
|
cfg.lua_version = _VERSION:match(" (5%.[123])$") or "5.1"
|
|
local version_suffix = cfg.lua_version:gsub("%.", "_")
|
|
|
|
-- Load site-local global configurations
|
|
local ok, site_config = pcall(require, "luarocks.site_config_"..version_suffix)
|
|
if not ok then
|
|
ok, site_config = pcall(require, "luarocks.site_config")
|
|
end
|
|
if not ok then
|
|
io.stderr:write("Site-local luarocks/site_config.lua file not found. Incomplete installation?\n")
|
|
site_config = {}
|
|
end
|
|
|
|
cfg.program_version = "2.4.2"
|
|
cfg.program_series = "2.4"
|
|
cfg.major_version = (cfg.program_version:match("([^.]%.[^.])")) or cfg.program_series
|
|
cfg.variables = {}
|
|
cfg.rocks_trees = {}
|
|
cfg.platforms = {}
|
|
|
|
local persist = require("luarocks.persist")
|
|
|
|
cfg.errorcodes = setmetatable({
|
|
OK = 0,
|
|
UNSPECIFIED = 1,
|
|
PERMISSIONDENIED = 2,
|
|
CONFIGFILE = 3,
|
|
CRASH = 99
|
|
},{
|
|
__index = function(t, key)
|
|
local val = rawget(t, key)
|
|
if not val then
|
|
error("'"..tostring(key).."' is not a valid errorcode", 2)
|
|
end
|
|
return val
|
|
end
|
|
})
|
|
|
|
|
|
local popen_ok, popen_result = pcall(io.popen, "")
|
|
if popen_ok then
|
|
if popen_result then
|
|
popen_result:close()
|
|
end
|
|
else
|
|
io.stderr:write("Your version of Lua does not support io.popen,\n")
|
|
io.stderr:write("which is required by LuaRocks. Please check your Lua installation.\n")
|
|
os.exit(cfg.errorcodes.UNSPECIFIED)
|
|
end
|
|
|
|
-- System detection:
|
|
|
|
-- A proper installation of LuaRocks will hardcode the system
|
|
-- and proc values with site_config.LUAROCKS_UNAME_S and site_config.LUAROCKS_UNAME_M,
|
|
-- so that this detection does not run every time. When it is
|
|
-- performed, we use the Unix way to identify the system,
|
|
-- even on Windows (assuming UnxUtils or Cygwin).
|
|
local system = site_config.LUAROCKS_UNAME_S or io.popen("uname -s"):read("*l")
|
|
local proc = site_config.LUAROCKS_UNAME_M or io.popen("uname -m"):read("*l")
|
|
if proc:match("i[%d]86") then
|
|
cfg.target_cpu = "x86"
|
|
elseif proc:match("amd64") or proc:match("x86_64") then
|
|
cfg.target_cpu = "x86_64"
|
|
elseif proc:match("Power Macintosh") then
|
|
cfg.target_cpu = "powerpc"
|
|
else
|
|
cfg.target_cpu = proc
|
|
end
|
|
|
|
if system == "FreeBSD" then
|
|
cfg.platforms.unix = true
|
|
cfg.platforms.freebsd = true
|
|
cfg.platforms.bsd = true
|
|
elseif system == "OpenBSD" then
|
|
cfg.platforms.unix = true
|
|
cfg.platforms.openbsd = true
|
|
cfg.platforms.bsd = true
|
|
elseif system == "NetBSD" then
|
|
cfg.platforms.unix = true
|
|
cfg.platforms.netbsd = true
|
|
cfg.platforms.bsd = true
|
|
elseif system == "Darwin" then
|
|
cfg.platforms.unix = true
|
|
cfg.platforms.macosx = true
|
|
cfg.platforms.bsd = true
|
|
elseif system == "Linux" then
|
|
cfg.platforms.unix = true
|
|
cfg.platforms.linux = true
|
|
elseif system == "SunOS" then
|
|
cfg.platforms.unix = true
|
|
cfg.platforms.solaris = true
|
|
elseif system and system:match("^CYGWIN") then
|
|
cfg.platforms.unix = true
|
|
cfg.platforms.cygwin = true
|
|
elseif system and system:match("^MSYS") then
|
|
cfg.platforms.unix = true
|
|
cfg.platforms.msys = true
|
|
cfg.platforms.cygwin = true
|
|
elseif system and system:match("^Windows") then
|
|
cfg.platforms.windows = true
|
|
cfg.platforms.win32 = true
|
|
elseif system and system:match("^MINGW") then
|
|
cfg.platforms.windows = true
|
|
cfg.platforms.mingw32 = true
|
|
cfg.platforms.win32 = true
|
|
elseif system == "Haiku" then
|
|
cfg.platforms.unix = true
|
|
cfg.platforms.haiku = true
|
|
else
|
|
cfg.platforms.unix = true
|
|
-- Fall back to Unix in unknown systems.
|
|
end
|
|
|
|
-- Set order for platform overrides.
|
|
-- More general platform identifiers should be listed first,
|
|
-- more specific ones later.
|
|
local platform_order = {
|
|
-- Unixes
|
|
"unix",
|
|
"bsd",
|
|
"solaris",
|
|
"netbsd",
|
|
"openbsd",
|
|
"freebsd",
|
|
"linux",
|
|
"macosx",
|
|
"cygwin",
|
|
"msys",
|
|
"haiku",
|
|
-- Windows
|
|
"win32",
|
|
"mingw32",
|
|
"windows",
|
|
}
|
|
|
|
-- Path configuration:
|
|
local sys_config_file, home_config_file
|
|
local sys_config_file_default, home_config_file_default
|
|
local sys_config_dir, home_config_dir
|
|
local sys_config_ok, home_config_ok = false, false
|
|
local extra_luarocks_module_dir
|
|
sys_config_dir = site_config.LUAROCKS_SYSCONFDIR or site_config.LUAROCKS_PREFIX
|
|
if cfg.platforms.windows then
|
|
cfg.home = os.getenv("APPDATA") or "c:"
|
|
sys_config_dir = sys_config_dir or "c:/luarocks"
|
|
home_config_dir = cfg.home.."/luarocks"
|
|
cfg.home_tree = cfg.home.."/luarocks/"
|
|
else
|
|
cfg.home = os.getenv("HOME") or ""
|
|
sys_config_dir = sys_config_dir or "/etc/luarocks"
|
|
home_config_dir = cfg.home.."/.luarocks"
|
|
cfg.home_tree = (os.getenv("USER") ~= "root") and cfg.home.."/.luarocks/"
|
|
end
|
|
|
|
-- Create global environment for the config files;
|
|
local env_for_config_file = function()
|
|
local e
|
|
e = {
|
|
home = cfg.home,
|
|
lua_version = cfg.lua_version,
|
|
platforms = util.make_shallow_copy(cfg.platforms),
|
|
processor = cfg.target_cpu, -- remains for compat reasons
|
|
target_cpu = cfg.target_cpu, -- replaces `processor`
|
|
os_getenv = os.getenv,
|
|
dump_env = function()
|
|
-- debug function, calling it from a config file will show all
|
|
-- available globals to that config file
|
|
print(util.show_table(e, "global environment"))
|
|
end,
|
|
}
|
|
return e
|
|
end
|
|
|
|
-- Merge values from config files read into the `cfg` table
|
|
local merge_overrides = function(overrides)
|
|
-- remove some stuff we do not want to integrate
|
|
overrides.os_getenv = nil
|
|
overrides.dump_env = nil
|
|
-- remove tables to be copied verbatim instead of deeply merged
|
|
if overrides.rocks_trees then cfg.rocks_trees = nil end
|
|
if overrides.rocks_servers then cfg.rocks_servers = nil end
|
|
-- perform actual merge
|
|
util.deep_merge(cfg, overrides)
|
|
end
|
|
|
|
-- load config file from a list until first succesful one. Info is
|
|
-- added to `cfg` module table, returns filepath of succesfully loaded
|
|
-- file or nil if it failed
|
|
local load_config_file = function(list)
|
|
for _, filepath in ipairs(list) do
|
|
local result, err, errcode = persist.load_into_table(filepath, env_for_config_file())
|
|
if (not result) and errcode ~= "open" then
|
|
-- errcode is either "load" or "run"; bad config file, so error out
|
|
io.stderr:write(err.."\n")
|
|
os.exit(cfg.errorcodes.CONFIGFILE)
|
|
end
|
|
if result then
|
|
-- succes in loading and running, merge contents and exit
|
|
merge_overrides(result)
|
|
return filepath
|
|
end
|
|
end
|
|
return nil -- nothing was loaded
|
|
end
|
|
|
|
|
|
-- Load system configuration file
|
|
do
|
|
sys_config_file_default = sys_config_dir.."/config-"..cfg.lua_version..".lua"
|
|
sys_config_file = load_config_file({
|
|
site_config.LUAROCKS_SYSCONFIG or sys_config_file_default,
|
|
sys_config_dir.."/config.lua",
|
|
})
|
|
sys_config_ok = (sys_config_file ~= nil)
|
|
end
|
|
|
|
-- Load user configuration file (if allowed)
|
|
if not site_config.LUAROCKS_FORCE_CONFIG then
|
|
|
|
home_config_file_default = home_config_dir.."/config-"..cfg.lua_version..".lua"
|
|
|
|
local config_env_var = "LUAROCKS_CONFIG_" .. version_suffix
|
|
local config_env_value = os.getenv(config_env_var)
|
|
if not config_env_value then
|
|
config_env_var = "LUAROCKS_CONFIG"
|
|
config_env_value = os.getenv(config_env_var)
|
|
end
|
|
|
|
-- first try environment provided file, so we can explicitly warn when it is missing
|
|
if config_env_value then
|
|
local list = { config_env_value }
|
|
home_config_file = load_config_file(list)
|
|
home_config_ok = (home_config_file ~= nil)
|
|
if not home_config_ok then
|
|
io.stderr:write("Warning: could not load configuration file `"..config_env_value.."` given in environment variable "..config_env_var.."\n")
|
|
end
|
|
end
|
|
|
|
-- try the alternative defaults if there was no environment specified file or it didn't work
|
|
if not home_config_ok then
|
|
local list = {
|
|
home_config_file_default,
|
|
home_config_dir.."/config.lua",
|
|
}
|
|
home_config_file = load_config_file(list)
|
|
home_config_ok = (home_config_file ~= nil)
|
|
end
|
|
end
|
|
|
|
|
|
if not next(cfg.rocks_trees) then
|
|
if cfg.home_tree then
|
|
table.insert(cfg.rocks_trees, { name = "user", root = cfg.home_tree } )
|
|
end
|
|
if site_config.LUAROCKS_ROCKS_TREE then
|
|
table.insert(cfg.rocks_trees, { name = "system", root = site_config.LUAROCKS_ROCKS_TREE } )
|
|
end
|
|
end
|
|
|
|
-- update platforms list; keyed -> array
|
|
do
|
|
-- if explicitly given by user,
|
|
if cfg.platforms[1] then
|
|
local is_windows = cfg.platforms.windows
|
|
-- Clear auto-detected values
|
|
for k, _ in pairs(cfg.platforms) do
|
|
if type(k) == "string" then
|
|
cfg.platforms[k] = nil
|
|
end
|
|
end
|
|
-- and set the ones given by the user.
|
|
for _, plat in ipairs(cfg.platforms) do
|
|
cfg.platforms[plat] = true
|
|
end
|
|
-- If no major platform family was set by the user,
|
|
if not (cfg.platforms.unix or cfg.platforms.windows) then
|
|
-- set some fallback defaults in case the user provides an incomplete configuration.
|
|
-- LuaRocks expects a set of defaults to be available.
|
|
-- This is used for setting defaults here only; the platform overrides
|
|
-- will use only the user's list.
|
|
if is_windows then
|
|
cfg.platforms.windows = true
|
|
table.insert(cfg.platforms, "windows")
|
|
else
|
|
cfg.platforms.unix = true
|
|
table.insert(cfg.platforms, "unix")
|
|
end
|
|
end
|
|
else
|
|
-- Sort detected platform defaults
|
|
local order = {}
|
|
for i, v in ipairs(platform_order) do
|
|
order[v] = i
|
|
end
|
|
local entries = {}
|
|
for k, v in pairs(cfg.platforms) do
|
|
if type(k) == "string" and v == true then
|
|
table.insert(entries, k)
|
|
end
|
|
end
|
|
table.sort(entries, function(a, b) return order[a] < order[b] end)
|
|
util.deep_merge(cfg.platforms, entries)
|
|
end
|
|
end
|
|
|
|
-- Configure defaults:
|
|
local defaults = {
|
|
|
|
local_by_default = false,
|
|
accept_unknown_fields = false,
|
|
fs_use_modules = true,
|
|
hooks_enabled = true,
|
|
deps_mode = "one",
|
|
check_certificates = false,
|
|
perm_read = "0644",
|
|
perm_exec = "0755",
|
|
|
|
lua_modules_path = "/share/lua/"..cfg.lua_version,
|
|
lib_modules_path = "/lib/lua/"..cfg.lua_version,
|
|
rocks_subdir = site_config.LUAROCKS_ROCKS_SUBDIR or "/lib/luarocks/rocks",
|
|
|
|
arch = "unknown",
|
|
lib_extension = "unknown",
|
|
obj_extension = "unknown",
|
|
link_lua_explicitly = false,
|
|
|
|
rocks_servers = {
|
|
{
|
|
"https://luarocks.org",
|
|
"https://raw.githubusercontent.com/rocks-moonscript-org/moonrocks-mirror/master/",
|
|
"http://luafr.org/moonrocks/",
|
|
"http://luarocks.logiceditor.com/rocks",
|
|
}
|
|
},
|
|
disabled_servers = {},
|
|
|
|
upload = {
|
|
server = "https://luarocks.org",
|
|
tool_version = "1.0.0",
|
|
api_version = "1",
|
|
},
|
|
|
|
lua_extension = "lua",
|
|
lua_interpreter = site_config.LUA_INTERPRETER or "lua",
|
|
downloader = site_config.LUAROCKS_DOWNLOADER or "wget",
|
|
md5checker = site_config.LUAROCKS_MD5CHECKER or "md5sum",
|
|
connection_timeout = 30, -- 0 = no timeout
|
|
|
|
variables = {
|
|
MAKE = "make",
|
|
CC = "cc",
|
|
LD = "ld",
|
|
|
|
CVS = "cvs",
|
|
GIT = "git",
|
|
SSCM = "sscm",
|
|
SVN = "svn",
|
|
HG = "hg",
|
|
|
|
RSYNC = "rsync",
|
|
WGET = "wget",
|
|
SCP = "scp",
|
|
CURL = "curl",
|
|
|
|
PWD = "pwd",
|
|
MKDIR = "mkdir",
|
|
RMDIR = "rmdir",
|
|
CP = "cp",
|
|
LS = "ls",
|
|
RM = "rm",
|
|
FIND = "find",
|
|
TEST = "test",
|
|
CHMOD = "chmod",
|
|
MKTEMP = "mktemp",
|
|
|
|
ZIP = "zip",
|
|
UNZIP = "unzip -n",
|
|
GUNZIP = "gunzip",
|
|
BUNZIP2 = "bunzip2",
|
|
TAR = "tar",
|
|
|
|
MD5SUM = "md5sum",
|
|
OPENSSL = "openssl",
|
|
MD5 = "md5",
|
|
STAT = "stat",
|
|
TOUCH = "touch",
|
|
|
|
CMAKE = "cmake",
|
|
SEVENZ = "7z",
|
|
|
|
RSYNCFLAGS = "--exclude=.git -Oavz",
|
|
STATFLAG = "-c '%a'",
|
|
CURLNOCERTFLAG = "",
|
|
WGETNOCERTFLAG = "",
|
|
},
|
|
|
|
external_deps_subdirs = site_config.LUAROCKS_EXTERNAL_DEPS_SUBDIRS or {
|
|
bin = "bin",
|
|
lib = "lib",
|
|
include = "include"
|
|
},
|
|
runtime_external_deps_subdirs = site_config.LUAROCKS_RUNTIME_EXTERNAL_DEPS_SUBDIRS or {
|
|
bin = "bin",
|
|
lib = "lib",
|
|
include = "include"
|
|
},
|
|
|
|
rocks_provided = {}
|
|
}
|
|
|
|
if cfg.platforms.windows then
|
|
local full_prefix = (site_config.LUAROCKS_PREFIX or (os.getenv("PROGRAMFILES")..[[\LuaRocks]]))
|
|
extra_luarocks_module_dir = full_prefix.."/lua/?.lua"
|
|
|
|
home_config_file = home_config_file and home_config_file:gsub("\\","/")
|
|
defaults.fs_use_modules = false
|
|
defaults.arch = "win32-"..cfg.target_cpu
|
|
defaults.lib_extension = "dll"
|
|
defaults.external_lib_extension = "dll"
|
|
defaults.obj_extension = "obj"
|
|
defaults.external_deps_dirs = { "c:/external/" }
|
|
defaults.variables.LUA_BINDIR = site_config.LUA_BINDIR and site_config.LUA_BINDIR:gsub("\\", "/") or "c:/lua"..cfg.lua_version.."/bin"
|
|
defaults.variables.LUA_INCDIR = site_config.LUA_INCDIR and site_config.LUA_INCDIR:gsub("\\", "/") or "c:/lua"..cfg.lua_version.."/include"
|
|
defaults.variables.LUA_LIBDIR = site_config.LUA_LIBDIR and site_config.LUA_LIBDIR:gsub("\\", "/") or "c:/lua"..cfg.lua_version.."/lib"
|
|
|
|
defaults.makefile = "Makefile.win"
|
|
defaults.variables.MAKE = "nmake"
|
|
defaults.variables.CC = "cl"
|
|
defaults.variables.RC = "rc"
|
|
defaults.variables.WRAPPER = full_prefix.."\\rclauncher.c"
|
|
defaults.variables.LD = "link"
|
|
defaults.variables.MT = "mt"
|
|
defaults.variables.LUALIB = "lua"..cfg.lua_version..".lib"
|
|
defaults.variables.CFLAGS = "/nologo /MD /O2"
|
|
defaults.variables.LIBFLAG = "/nologo /dll"
|
|
|
|
local bins = { "SEVENZ", "CP", "FIND", "LS", "MD5SUM",
|
|
"MKDIR", "MV", "PWD", "RMDIR", "TEST", "UNAME", "WGET" }
|
|
for _, var in ipairs(bins) do
|
|
if defaults.variables[var] then
|
|
defaults.variables[var] = full_prefix.."\\tools\\"..defaults.variables[var]
|
|
end
|
|
end
|
|
|
|
defaults.external_deps_patterns = {
|
|
bin = { "?.exe", "?.bat" },
|
|
lib = { "?.lib", "?.dll", "lib?.dll" },
|
|
include = { "?.h" }
|
|
}
|
|
defaults.runtime_external_deps_patterns = {
|
|
bin = { "?.exe", "?.bat" },
|
|
lib = { "?.dll", "lib?.dll" },
|
|
include = { "?.h" }
|
|
}
|
|
defaults.export_path = "SET PATH=%s"
|
|
defaults.export_path_separator = ";"
|
|
defaults.export_lua_path = "SET LUA_PATH=%s"
|
|
defaults.export_lua_cpath = "SET LUA_CPATH=%s"
|
|
defaults.wrapper_suffix = ".bat"
|
|
|
|
local localappdata = os.getenv("LOCALAPPDATA")
|
|
if not localappdata then
|
|
-- for Windows versions below Vista
|
|
localappdata = os.getenv("USERPROFILE").."/Local Settings/Application Data"
|
|
end
|
|
defaults.local_cache = localappdata.."/LuaRocks/Cache"
|
|
defaults.web_browser = "start"
|
|
end
|
|
|
|
if cfg.platforms.mingw32 then
|
|
defaults.obj_extension = "o"
|
|
defaults.cmake_generator = "MinGW Makefiles"
|
|
defaults.variables.MAKE = "mingw32-make"
|
|
defaults.variables.CC = "mingw32-gcc"
|
|
defaults.variables.RC = "windres"
|
|
defaults.variables.LD = "mingw32-gcc"
|
|
defaults.variables.CFLAGS = "-O2"
|
|
defaults.variables.LIBFLAG = "-shared"
|
|
defaults.makefile = "Makefile"
|
|
defaults.external_deps_patterns = {
|
|
bin = { "?.exe", "?.bat" },
|
|
-- mingw lookup list from http://stackoverflow.com/a/15853231/1793220
|
|
-- ...should we keep ?.lib at the end? It's not in the above list.
|
|
lib = { "lib?.dll.a", "?.dll.a", "lib?.a", "cyg?.dll", "lib?.dll", "?.dll", "?.lib" },
|
|
include = { "?.h" }
|
|
}
|
|
defaults.runtime_external_deps_patterns = {
|
|
bin = { "?.exe", "?.bat" },
|
|
lib = { "cyg?.dll", "?.dll", "lib?.dll" },
|
|
include = { "?.h" }
|
|
}
|
|
|
|
end
|
|
|
|
if cfg.platforms.unix then
|
|
defaults.lib_extension = "so"
|
|
defaults.external_lib_extension = "so"
|
|
defaults.obj_extension = "o"
|
|
defaults.external_deps_dirs = { "/usr/local", "/usr" }
|
|
defaults.variables.LUA_BINDIR = site_config.LUA_BINDIR or "/usr/local/bin"
|
|
defaults.variables.LUA_INCDIR = site_config.LUA_INCDIR or "/usr/local/include"
|
|
defaults.variables.LUA_LIBDIR = site_config.LUA_LIBDIR or "/usr/local/lib"
|
|
defaults.variables.CFLAGS = "-O2"
|
|
defaults.cmake_generator = "Unix Makefiles"
|
|
defaults.variables.CC = "gcc"
|
|
defaults.variables.LD = "gcc"
|
|
defaults.gcc_rpath = true
|
|
defaults.variables.LIBFLAG = "-shared"
|
|
defaults.external_deps_patterns = {
|
|
bin = { "?" },
|
|
lib = { "lib?.a", "lib?.so", "lib?.so.*" },
|
|
include = { "?.h" }
|
|
}
|
|
defaults.runtime_external_deps_patterns = {
|
|
bin = { "?" },
|
|
lib = { "lib?.so", "lib?.so.*" },
|
|
include = { "?.h" }
|
|
}
|
|
defaults.export_path = "export PATH='%s'"
|
|
defaults.export_path_separator = ":"
|
|
defaults.export_lua_path = "export LUA_PATH='%s'"
|
|
defaults.export_lua_cpath = "export LUA_CPATH='%s'"
|
|
defaults.wrapper_suffix = ""
|
|
defaults.local_cache = cfg.home.."/.cache/luarocks"
|
|
if not defaults.variables.CFLAGS:match("-fPIC") then
|
|
defaults.variables.CFLAGS = defaults.variables.CFLAGS.." -fPIC"
|
|
end
|
|
defaults.web_browser = "xdg-open"
|
|
end
|
|
|
|
if cfg.platforms.cygwin then
|
|
defaults.lib_extension = "so" -- can be overridden in the config file for mingw builds
|
|
defaults.arch = "cygwin-"..cfg.target_cpu
|
|
defaults.cmake_generator = "Unix Makefiles"
|
|
defaults.variables.CC = "echo -llua | xargs gcc"
|
|
defaults.variables.LD = "echo -llua | xargs gcc"
|
|
defaults.variables.LIBFLAG = "-shared"
|
|
defaults.link_lua_explicitly = true
|
|
end
|
|
|
|
if cfg.platforms.msys then
|
|
-- msys is basically cygwin made out of mingw, meaning the subsytem is unixish
|
|
-- enough, yet we can freely mix with native win32
|
|
defaults.external_deps_patterns = {
|
|
bin = { "?.exe", "?.bat", "?" },
|
|
lib = { "lib?.so", "lib?.so.*", "lib?.dll.a", "?.dll.a",
|
|
"lib?.a", "lib?.dll", "?.dll", "?.lib" },
|
|
include = { "?.h" }
|
|
}
|
|
defaults.runtime_external_deps_patterns = {
|
|
bin = { "?.exe", "?.bat" },
|
|
lib = { "lib?.so", "?.dll", "lib?.dll" },
|
|
include = { "?.h" }
|
|
}
|
|
end
|
|
|
|
|
|
if cfg.platforms.bsd then
|
|
defaults.variables.MAKE = "gmake"
|
|
defaults.variables.STATFLAG = "-f '%OLp'"
|
|
end
|
|
|
|
if cfg.platforms.macosx then
|
|
defaults.variables.MAKE = "make"
|
|
defaults.external_lib_extension = "dylib"
|
|
defaults.arch = "macosx-"..cfg.target_cpu
|
|
defaults.variables.LIBFLAG = "-bundle -undefined dynamic_lookup -all_load"
|
|
defaults.variables.STAT = "/usr/bin/stat"
|
|
defaults.variables.STATFLAG = "-f '%A'"
|
|
local version = io.popen("sw_vers -productVersion"):read("*l")
|
|
version = tonumber(version and version:match("^[^.]+%.([^.]+)")) or 3
|
|
if version >= 10 then
|
|
version = 8
|
|
elseif version >= 5 then
|
|
version = 5
|
|
else
|
|
defaults.gcc_rpath = false
|
|
end
|
|
defaults.variables.CC = "env MACOSX_DEPLOYMENT_TARGET=10."..version.." gcc"
|
|
defaults.variables.LD = "env MACOSX_DEPLOYMENT_TARGET=10."..version.." gcc"
|
|
defaults.web_browser = "open"
|
|
end
|
|
|
|
if cfg.platforms.linux then
|
|
defaults.arch = "linux-"..cfg.target_cpu
|
|
end
|
|
|
|
if cfg.platforms.freebsd then
|
|
defaults.arch = "freebsd-"..cfg.target_cpu
|
|
defaults.gcc_rpath = false
|
|
defaults.variables.CC = "cc"
|
|
defaults.variables.LD = "cc"
|
|
end
|
|
|
|
if cfg.platforms.openbsd then
|
|
defaults.arch = "openbsd-"..cfg.target_cpu
|
|
end
|
|
|
|
if cfg.platforms.netbsd then
|
|
defaults.arch = "netbsd-"..cfg.target_cpu
|
|
end
|
|
|
|
if cfg.platforms.solaris then
|
|
defaults.arch = "solaris-"..cfg.target_cpu
|
|
--defaults.platforms = {"unix", "solaris"}
|
|
defaults.variables.MAKE = "gmake"
|
|
end
|
|
|
|
-- Expose some more values detected by LuaRocks for use by rockspec authors.
|
|
defaults.variables.LIB_EXTENSION = defaults.lib_extension
|
|
defaults.variables.OBJ_EXTENSION = defaults.obj_extension
|
|
defaults.variables.LUAROCKS_PREFIX = site_config.LUAROCKS_PREFIX
|
|
defaults.variables.LUA = site_config.LUA_DIR_SET and (defaults.variables.LUA_BINDIR.."/"..defaults.lua_interpreter) or defaults.lua_interpreter
|
|
|
|
-- Add built-in modules to rocks_provided
|
|
defaults.rocks_provided["lua"] = cfg.lua_version.."-1"
|
|
|
|
if bit32 then -- Lua 5.2+
|
|
defaults.rocks_provided["bit32"] = cfg.lua_version.."-1"
|
|
end
|
|
|
|
if utf8 then -- Lua 5.3+
|
|
defaults.rocks_provided["utf8"] = cfg.lua_version.."-1"
|
|
end
|
|
|
|
if package.loaded.jit then
|
|
-- LuaJIT
|
|
local lj_version = package.loaded.jit.version:match("LuaJIT (.*)"):gsub("%-","")
|
|
--defaults.rocks_provided["luajit"] = lj_version.."-1"
|
|
defaults.rocks_provided["luabitop"] = lj_version.."-1"
|
|
end
|
|
|
|
-- Use defaults:
|
|
|
|
-- Populate some arrays with values from their 'defaults' counterparts
|
|
-- if they were not already set by user.
|
|
for _, entry in ipairs({"variables", "rocks_provided"}) do
|
|
if not cfg[entry] then
|
|
cfg[entry] = {}
|
|
end
|
|
for k,v in pairs(defaults[entry]) do
|
|
if not cfg[entry][k] then
|
|
cfg[entry][k] = v
|
|
end
|
|
end
|
|
end
|
|
|
|
-- For values not set in the config file, use values from the 'defaults' table.
|
|
local cfg_mt = {
|
|
__index = function(t, k)
|
|
local default = defaults[k]
|
|
if default then
|
|
rawset(t, k, default)
|
|
end
|
|
return default
|
|
end
|
|
}
|
|
setmetatable(cfg, cfg_mt)
|
|
|
|
if not cfg.check_certificates then
|
|
cfg.variables.CURLNOCERTFLAG = "-k"
|
|
cfg.variables.WGETNOCERTFLAG = "--no-check-certificate"
|
|
end
|
|
|
|
function cfg.make_paths_from_tree(tree)
|
|
local lua_path, lib_path, bin_path
|
|
if type(tree) == "string" then
|
|
lua_path = tree..cfg.lua_modules_path
|
|
lib_path = tree..cfg.lib_modules_path
|
|
bin_path = tree.."/bin"
|
|
else
|
|
lua_path = tree.lua_dir or tree.root..cfg.lua_modules_path
|
|
lib_path = tree.lib_dir or tree.root..cfg.lib_modules_path
|
|
bin_path = tree.bin_dir or tree.root.."/bin"
|
|
end
|
|
return lua_path, lib_path, bin_path
|
|
end
|
|
|
|
function cfg.package_paths(current)
|
|
local new_path, new_cpath, new_bin = {}, {}, {}
|
|
local function add_tree_to_paths(tree)
|
|
local lua_path, lib_path, bin_path = cfg.make_paths_from_tree(tree)
|
|
table.insert(new_path, lua_path.."/?.lua")
|
|
table.insert(new_path, lua_path.."/?/init.lua")
|
|
table.insert(new_cpath, lib_path.."/?."..cfg.lib_extension)
|
|
table.insert(new_bin, bin_path)
|
|
end
|
|
if current then
|
|
add_tree_to_paths(current)
|
|
end
|
|
for _,tree in ipairs(cfg.rocks_trees) do
|
|
add_tree_to_paths(tree)
|
|
end
|
|
if extra_luarocks_module_dir then
|
|
table.insert(new_path, extra_luarocks_module_dir)
|
|
end
|
|
return table.concat(new_path, ";"), table.concat(new_cpath, ";"), table.concat(new_bin, cfg.export_path_separator)
|
|
end
|
|
|
|
function cfg.init_package_paths()
|
|
local lr_path, lr_cpath, lr_bin = cfg.package_paths()
|
|
package.path = util.remove_path_dupes(package.path .. ";" .. lr_path, ";")
|
|
package.cpath = util.remove_path_dupes(package.cpath .. ";" .. lr_cpath, ";")
|
|
end
|
|
|
|
function cfg.which_config()
|
|
local ret = {
|
|
system = {
|
|
file = sys_config_file or sys_config_file_default,
|
|
ok = sys_config_ok,
|
|
},
|
|
user = {
|
|
file = home_config_file or home_config_file_default,
|
|
ok = home_config_ok,
|
|
}
|
|
}
|
|
ret.nearest = (ret.user.ok and ret.user.file) or ret.system.file
|
|
return ret
|
|
end
|
|
|
|
cfg.user_agent = "LuaRocks/"..cfg.program_version.." "..cfg.arch
|
|
|
|
cfg.http_proxy = os.getenv("http_proxy")
|
|
cfg.https_proxy = os.getenv("https_proxy")
|
|
cfg.no_proxy = os.getenv("no_proxy")
|
|
|
|
--- Check if platform was detected
|
|
-- @param query string: The platform name to check.
|
|
-- @return boolean: true if LuaRocks is currently running on queried platform.
|
|
function cfg.is_platform(query)
|
|
assert(type(query) == "string")
|
|
|
|
for _, platform in ipairs(cfg.platforms) do
|
|
if platform == query then
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
|
|
return cfg
|