rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/luarocks/build/builtin.lua

@@ -0,0 +1,253 @@
+
+--- A builtin build system: back-end to provide a portable way of building C-based Lua modules.
+module("luarocks.build.builtin", package.seeall)
+
+local fs = require("luarocks.fs")
+local path = require("luarocks.path")
+local util = require("luarocks.util")
+local cfg = require("luarocks.cfg")
+local dir = require("luarocks.dir")
+
+--- Run a command displaying its execution on standard output.
+-- @return boolean: true if command succeeds (status code 0), false
+-- otherwise.
+local function execute(...)
+   io.stdout:write(table.concat({...}, " ").."\n")
+   return fs.execute(...)
+end
+
+--- Makes an RC file with an embedded Lua script, for building .exes on Windows
+-- @return nil if could open files, error otherwise
+local function make_rc(luafilename, rcfilename)
+   local rcfile = io.open(rcfilename, "w")
+   if not rcfile then
+      error("Could not open "..rcfilename.." for writing.")
+   end
+   rcfile:write("STRINGTABLE\r\nBEGIN\r\n")
+
+   local i = 1
+   for line in io.lines(luafilename) do
+      if not line:match("^#!") then
+         rcfile:write(i .. " \"")
+         line = line:gsub("\\", "\\\\"):gsub('"', '""'):gsub("[\r\n]+", "")
+         rcfile:write(line .. "\\r\\n\"\r\n")
+         i = i + 1
+      end
+   end
+
+   rcfile:write("END\r\n")
+
+   rcfile:close()
+end
+
+--- Driver function for the builtin build back-end.
+-- @param rockspec table: the loaded rockspec.
+-- @return boolean or (nil, string): true if no errors ocurred,
+-- nil and an error message otherwise.
+function run(rockspec)
+   assert(type(rockspec) == "table")
+   local compile_object, compile_library, compile_wrapper_binary
+
+   local build = rockspec.build
+   local variables = rockspec.variables
+
+   local function add_flags(extras, flag, flags)
+      if flags then
+         if type(flags) ~= "table" then
+            flags = { tostring(flags) }
+         end
+         util.variable_substitutions(flags, variables)
+         for _, v in ipairs(flags) do
+            table.insert(extras, flag:format(v))
+         end
+      end
+   end
+
+   -- MinGW basically behaves the same as Unix
+   if cfg.is_platform("mingw32") then
+         compile_object = function(object, source, defines, incdirs)
+         local extras = {}
+         add_flags(extras, "-D%s", defines)
+         add_flags(extras, "-I%s", incdirs)
+         return execute(variables.CC.." "..variables.CFLAGS, "-I"..variables.LUA_INCDIR, "-c", source, "-o", object, unpack(extras))
+      end
+      compile_library = function (library, objects, libraries, libdirs)
+         local extras = { unpack(objects) }
+         add_flags(extras, "-L%s", libdirs)
+         add_flags(extras, "%s.lib", libraries)
+         extras[#extras+1] = dir.path(variables.LUA_LIBDIR, variables.LUALIB)
+         extras[#extras+1] = "-l" .. (variables.MSVCRT or "msvcr80")
+         local ok = execute(variables.LD.." "..variables.LIBFLAG, "-o", library, unpack(extras))
+         return ok
+      end
+      compile_wrapper_binary = function(fullname, name)
+         local fullbasename = fullname:gsub("%.lua$", ""):gsub("/", "\\")
+         local basename = name:gsub("%.lua$", ""):gsub("/", "\\")
+         local rcname = basename..".rc"
+         local resname = basename..".o"
+         local wrapname = basename..".exe"
+         make_rc(fullname, fullbasename..".rc")
+         local ok = execute(variables.RC, "-o", resname, rcname)
+         if not ok then return ok end
+         ok = execute(variables.LD, "-o", wrapname, resname, variables.WRAPPER,
+                      dir.path(variables.LUA_LIBDIR, variables.LUALIB), "-l" .. (variables.MSVCRT or "msvcr80"), "-luser32")
+         return ok, wrapname
+      end
+      compile_wrapper_binary = function(fullname, name) return true, name end
+	-- MSVC specific commands
+	elseif cfg.is_platform("win32") then
+      compile_object = function(object, source, defines, incdirs)
+         local extras = {}
+         add_flags(extras, "-D%s", defines)
+         add_flags(extras, "-I%s", incdirs)
+         return execute(variables.CC.." "..variables.CFLAGS, "-c", "-Fo"..object, "-I"..variables.LUA_INCDIR, source, unpack(extras))
+      end
+      compile_library = function(library, objects, libraries, libdirs, name)
+         local extras = { unpack(objects) }
+         add_flags(extras, "-libpath:%s", libdirs)
+         add_flags(extras, "%s.lib", libraries)
+         local basename = dir.base_name(library):gsub(".[^.]*$", "")
+         local deffile = basename .. ".def"
+         local def = io.open(dir.path(fs.current_dir(), deffile), "w+")
+         def:write("EXPORTS\n")
+         def:write("luaopen_"..name:gsub("%.", "_").."\n")
+         def:close()
+         local ok = execute(variables.LD, "-dll", "-def:"..deffile, "-out:"..library, dir.path(variables.LUA_LIBDIR, variables.LUALIB), unpack(extras))
+         local manifestfile = basename..".dll.manifest"
+         if ok and fs.exists(manifestfile) then
+            ok = execute(variables.MT, "-manifest", manifestfile, "-outputresource:"..basename..".dll;2")
+         end
+         return ok
+      end
+      compile_wrapper_binary = function(fullname, name)
+         local fullbasename = fullname:gsub("%.lua$", ""):gsub("/", "\\")
+         local basename = name:gsub("%.lua$", ""):gsub("/", "\\")
+         local rcname = basename..".rc"
+         local resname = basename..".res"
+         local wrapname = basename..".exe"
+         make_rc(fullname, fullbasename..".rc")
+         local ok = execute(variables.RC, "-r", "-fo"..resname, rcname)
+         if not ok then return ok end
+         ok = execute(variables.LD, "-out:"..wrapname, resname, variables.WRAPPER,
+                      dir.path(variables.LUA_LIBDIR, variables.LUALIB), "user32.lib")
+         local manifestfile = wrapname..".manifest"
+         if ok and fs.exists(manifestfile) then
+            ok = execute(variables.MT, "-manifest", manifestfile, "-outputresource:"..wrapname..";1")
+         end
+         return ok, wrapname
+      end
+   else
+	-- Unix, Linux, Cygwin
+      compile_object = function(object, source, defines, incdirs)
+         local extras = {}
+         add_flags(extras, "-D%s", defines)
+         add_flags(extras, "-I%s", incdirs)
+         return execute(variables.CC.." "..variables.CFLAGS, "-I"..variables.LUA_INCDIR, "-c", source, "-o", object, unpack(extras))
+      end
+      compile_library = function (library, objects, libraries, libdirs)
+         local extras = { unpack(objects) }
+         add_flags(extras, "-L%s", libdirs)
+         add_flags(extras, "-Wl,-rpath,%s:", libdirs)
+         add_flags(extras, "-l%s", libraries)
+		 -- Link to Lua
+         add_flags(extras, "-l%s", variables.LUA_LIB)
+         return execute(variables.LD.." "..variables.LIBFLAG, "-o", library, "-L"..variables.LUA_LIBDIR, unpack(extras))
+      end
+      compile_wrapper_binary = function(fullname, name) return true, name end
+   end
+
+   local ok = true
+   local err = "Build error"
+   local built_modules = {}
+   local luadir = path.lua_dir(rockspec.name, rockspec.version)
+   local libdir = path.lib_dir(rockspec.name, rockspec.version)
+   local docdir = path.doc_dir(rockspec.name, rockspec.version)
+   -- On Windows, compiles an .exe for each Lua file in build.install.bin, and
+   -- replaces the filename with the .exe name. Strips the .lua extension if it exists,
+   -- otherwise just appends .exe to the name
+   if build.install and build.install.bin then
+     for i, name in ipairs(build.install.bin) do
+       local fullname = dir.path(fs.current_dir(), name)
+       local match = name:match("%.lua$")
+       local basename = name:gsub("%.lua$", "")
+       local file
+       if not match then
+          file = io.open(fullname)
+       end
+       if match or (file and file:read():match("#!.*lua.*")) then
+          ok, name = compile_wrapper_binary(fullname, name)
+          if ok then
+             build.install.bin[i] = name
+          else
+             if file then file:close() end
+             return nil, "Build error in wrapper binaries"
+          end
+       end
+       if file then file:close() end
+     end
+   end
+   for name, info in pairs(build.modules) do
+      local moddir = path.module_to_path(name)
+      if type(info) == "string" then
+         local ext = info:match(".([^.]+)$")
+         if ext == "lua" then
+            if info:match("init%.lua$") and not name:match("%.init$") then
+               moddir = path.module_to_path(name..".init")
+            end
+            local dest = dir.path(luadir, moddir)
+            built_modules[info] = dest
+         else
+            info = {info}
+         end
+      end
+      if type(info) == "table" then
+         local objects = {}
+         local sources = info.sources
+         if info[1] then sources = info end
+         if type(sources) == "string" then sources = {sources} end
+         for _, source in ipairs(sources) do
+            local object = source:gsub(".[^.]*$", "."..cfg.obj_extension)
+            if not object then
+               object = source.."."..cfg.obj_extension
+            end
+            ok = compile_object(object, source, info.defines, info.incdirs)
+            if not ok then
+               err = "Failed compiling object "..object
+               break
+            end
+            table.insert(objects, object)
+         end
+         if not ok then break end
+         local module_name = dir.path(moddir, name:match("([^.]*)$").."."..cfg.lib_extension):gsub("//", "/")
+         if moddir ~= "" then
+            fs.make_dir(moddir)
+         end
+         local dest = dir.path(libdir, moddir)
+         built_modules[module_name] = dest
+         ok = compile_library(module_name, objects, info.libraries, info.libdirs, name)
+         if not ok then
+            err = "Failed compiling module "..module_name
+            break
+         end
+      end
+   end
+   for name, dest in pairs(built_modules) do
+      fs.make_dir(dest)
+      ok = fs.copy(name, dest)
+      if not ok then
+         err = "Failed installing "..name.." in "..dest
+         break
+      end
+   end
+   if ok then
+      if fs.is_dir("lua") then
+         ok = fs.copy_contents("lua", luadir)
+         if not ok then err = "Failed copying contents of 'lua' directory." end
+      end
+   end
+   if ok then
+      return true
+   else
+      return nil, err
+   end
+end

data/vendor/lua/lib/lua/luarocks/build/cmake.lua

@@ -0,0 +1,54 @@
+
+--- Build back-end for CMake-based modules.
+module("luarocks.build.cmake", package.seeall)
+
+local fs = require("luarocks.fs")
+local util = require("luarocks.util")
+local cfg = require("luarocks.cfg")
+
+--- Driver function for the "cmake" build back-end.
+-- @param rockspec table: the loaded rockspec.
+-- @return boolean or (nil, string): true if no errors ocurred,
+-- nil and an error message otherwise.
+function run(rockspec)
+   assert(type(rockspec) == "table")
+   local build = rockspec.build
+   local variables = build.variables or {}
+   
+   -- Pass Env variables
+   variables.CMAKE_MODULE_PATH=os.getenv("CMAKE_MODULE_PATH")
+   variables.CMAKE_LIBRARY_PATH=os.getenv("CMAKE_LIBRARY_PATH")
+   variables.CMAKE_INCLUDE_PATH=os.getenv("CMAKE_INCLUDE_PATH")
+
+   util.variable_substitutions(variables, rockspec.variables)
+   
+   -- If inline cmake is present create CMakeLists.txt from it.
+   if type(build.cmake) == "string" then
+      local cmake = assert(io.open(fs.current_dir().."/CMakeLists.txt", "w"))
+      cmake:write(build.cmake)
+      cmake:close()
+   end
+
+
+   -- Execute cmake with variables.
+   local args = ""
+   if cfg.cmake_generator then
+      args = args .. ' -G"'..cfg.cmake_generator.. '"'
+   end
+   for k,v in pairs(variables) do
+      args = args .. ' -D' ..k.. '="' ..v.. '"'
+   end
+
+   if not fs.execute(rockspec.variables.CMAKE.." . " ..args) then
+      return nil, "Failed cmake."
+   end
+   
+   if not fs.execute(rockspec.variables.MAKE.." -fMakefile") then
+      return nil, "Failed building."
+   end
+
+   if not fs.execute(rockspec.variables.MAKE.." -fMakefile install") then
+      return nil, "Failed installing."
+   end
+   return true
+end

data/vendor/lua/lib/lua/luarocks/build/command.lua

@@ -0,0 +1,32 @@
+
+--- Build back-end for raw listing of commands in rockspec files.
+module("luarocks.build.command", package.seeall)
+
+local fs = require("luarocks.fs")
+local util = require("luarocks.util")
+
+--- Driver function for the "command" build back-end.
+-- @param rockspec table: the loaded rockspec.
+-- @return boolean or (nil, string): true if no errors ocurred,
+-- nil and an error message otherwise.
+function run(rockspec)
+   assert(type(rockspec) == "table")
+
+   local build = rockspec.build
+   
+   util.variable_substitutions(build, rockspec.variables)
+   
+   if build.build_command then
+      util.printout(build.build_command)
+      if not fs.execute(build.build_command) then
+         return nil, "Failed building."
+      end
+   end
+   if build.install_command then
+      util.printout(build.install_command)
+      if not fs.execute(build.install_command) then
+         return nil, "Failed installing."
+      end
+   end
+   return true
+end

data/vendor/lua/lib/lua/luarocks/build/make.lua

@@ -0,0 +1,92 @@
+
+--- Build back-end for using Makefile-based packages.
+module("luarocks.build.make", package.seeall)
+
+local fs = require("luarocks.fs")
+local util = require("luarocks.util")
+local cfg = require("luarocks.cfg")
+
+--- Call "make" with given target and variables
+-- @param make_cmd string: the make command to be used (typically
+-- configured through variables.MAKE in the config files, or
+-- the appropriate platform-specific default).
+-- @param pass boolean: If true, run make; if false, do nothing.
+-- @param target string: The make target; an empty string indicates 
+-- the default target.
+-- @param variables table: A table containing string-string key-value
+-- pairs representing variable assignments to be passed to make.
+-- @return boolean: false if any errors occurred, true otherwise.
+local function make_pass(make_cmd, pass, target, variables)
+   assert(type(pass) == "boolean")
+   assert(type(target) == "string")
+   assert(type(variables) == "table")
+
+   local assignments = {}
+   for k,v in pairs(variables) do
+      table.insert(assignments, k.."="..v)
+   end
+   if pass then
+      return fs.execute(make_cmd.." "..target, unpack(assignments))
+   else
+      return true
+   end
+end
+
+--- Driver function for the "make" build back-end.
+-- @param rockspec table: the loaded rockspec.
+-- @return boolean or (nil, string): true if no errors ocurred,
+-- nil and an error message otherwise.
+function run(rockspec)
+   assert(type(rockspec) == "table")
+
+   local build = rockspec.build
+   
+   if build.build_pass == nil then build.build_pass = true end
+   if build.install_pass == nil then build.install_pass = true end
+   build.build_variables = build.build_variables or {}
+   build.install_variables = build.install_variables or {}
+   build.build_target = build.build_target or ""
+   build.install_target = build.install_target or "install"
+   local makefile = build.makefile or cfg.makefile
+   if makefile then
+      -- Assumes all make's accept -f. True for POSIX make, GNU make and Microsoft nmake.
+      build.build_target = "-f "..makefile.." "..build.build_target
+      build.install_target = "-f "..makefile.." "..build.install_target
+   end
+
+   if build.variables then   
+      for var, val in pairs(build.variables) do
+         build.build_variables[var] = val 
+         build.install_variables[var] = val
+      end
+   end
+
+   util.warn_if_not_used(build.build_variables, { CFLAGS=true }, "variable %s was not passed in build_variables")
+
+   util.variable_substitutions(build.build_variables, rockspec.variables)
+   util.variable_substitutions(build.install_variables, rockspec.variables)
+   
+   local auto_variables = { "CC" }
+   
+   for _, variable in pairs(auto_variables) do
+      if not build.build_variables[variable] then
+         build.build_variables[variable] = rockspec.variables[variable]
+      end
+      if not build.install_variables[variable] then
+         build.install_variables[variable] = rockspec.variables[variable]
+      end
+   end
+
+   -- backwards compatibility 
+   local make_cmd = cfg.make or rockspec.variables.MAKE
+
+   local ok = make_pass(make_cmd, build.build_pass, build.build_target, build.build_variables)
+   if not ok then
+      return nil, "Failed building."
+   end
+   ok = make_pass(make_cmd, build.install_pass, build.install_target, build.install_variables)
+   if not ok then
+      return nil, "Failed installing."
+   end
+   return true
+end

data/vendor/lua/lib/lua/luarocks/cache.lua

@@ -0,0 +1,85 @@
+
+--- Module handling the LuaRocks local cache.
+-- Adds a rock or rockspec to a rocks server.
+module("luarocks.cache", package.seeall)
+
+local fs = require("luarocks.fs")
+local cfg = require("luarocks.cfg")
+local dir = require("luarocks.dir")
+local util = require("luarocks.util")
+
+function get_upload_server(server)
+   if not server then server = cfg.upload_server end
+   if not server then
+      return nil, "No server specified and no default configured with upload_server."
+   end
+   return server, cfg.upload_servers and cfg.upload_servers[server]
+end
+
+function get_server_urls(server, upload_server)
+   local download_url = server
+   local login_url = nil
+   if upload_server then
+      if upload_server.rsync then download_url = "rsync://"..upload_server.rsync
+      elseif upload_server.http then download_url = "http://"..upload_server.http
+      elseif upload_server.ftp then download_url = "ftp://"..upload_server.ftp
+      end
+      
+      if upload_server.ftp then login_url = "ftp://"..upload_server.ftp
+      elseif upload_server.sftp then login_url = "sftp://"..upload_server.sftp
+      end
+   end
+   return download_url, login_url
+end
+
+function split_server_url(server, url, user, password)
+   local protocol, server_path = dir.split_url(url)
+   if server_path:match("@") then
+      local credentials
+      credentials, server_path = server_path:match("([^@]*)@(.*)")
+      if credentials:match(":") then
+         user, password = credentials:match("([^:]*):(.*)")
+      else
+         user = credentials
+      end
+   end
+   local local_cache
+   if cfg.local_cache then
+      local_cache = cfg.local_cache .. "/" .. server
+   end
+   return local_cache, protocol, server_path, user, password
+end
+
+function refresh_local_cache(server, url, user, password)
+   local local_cache, protocol, server_path, user, password = split_server_url(server, url, user, password)
+
+   fs.make_dir(cfg.local_cache)
+
+   local tmp_cache = false
+   if not local_cache then
+      local_cache = fs.make_temp_dir("local_cache")
+      tmp_cache = true
+   end
+   local ok = fs.make_dir(local_cache)
+   if not ok then
+      return nil, "Failed creating local cache dir."
+   end
+   fs.change_dir(local_cache)
+   util.printout("Refreshing cache "..local_cache.."...")
+
+   -- TODO abstract away explicit 'wget' call
+   local ok = false
+   if protocol == "rsync" then
+      local srv, path = server_path:match("([^/]+)(/.+)")
+      ok = fs.execute(cfg.variables.RSYNC.." -avz -e ssh "..user.."@"..srv..":"..path.."/ "..local_cache.."/")
+   else 
+      local login_info = ""
+      if user then login_info = " --user="..user end
+      if password then login_info = login_info .. " --password="..password end
+      ok = fs.execute(cfg.variables.WGET.." --no-cache -q -m -np -nd "..protocol.."://"..server_path..login_info)
+   end
+   if not ok then
+      return nil, "Failed downloading cache."
+   end
+   return local_cache, protocol, server_path, user, password
+end