rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/metalua/mlc_xcall.lua

@@ -0,0 +1,119 @@
+--------------------------------------------------------------------------------
+-- Execute an `mlc.ast_of_*()' in a separate lua process.
+-- Communication between processes goes through temporary files,
+-- for the sake of portability.
+--------------------------------------------------------------------------------
+
+mlc_xcall = { }
+
+--------------------------------------------------------------------------------
+-- Number of lines to remove at the end of a traceback, should it be
+-- dumped due to a compilation error in metabugs mode.
+--------------------------------------------------------------------------------
+local STACK_LINES_TO_CUT = 7
+
+--------------------------------------------------------------------------------
+-- (Not intended to be called directly by users)
+--
+-- This is the back-end function, called in a separate lua process
+-- by `mlc_xcall.client_*()' through `os.execute()'.
+--  * inputs:
+--     * the name of a lua source file to compile in a separate process
+--     * the name of a writable file where the resulting ast is dumped
+--       with `serialize()'.
+--     * metabugs: if true and an error occurs during compilation,
+--       the compiler's stacktrace is printed, allowing meta-programs
+--       debugging.
+--  * results:
+--     * an exit status of 0 or -1, depending on whethet compilation
+--       succeeded;
+--     * the ast file filled will either the serialized ast, or the
+--       error message.
+--------------------------------------------------------------------------------
+function mlc_xcall.server (luafilename, astfilename, metabugs)
+
+   -- We don't want these to be loaded when people only do client-side business
+   require 'metalua.compiler'
+   require 'serialize'
+
+   mlc.metabugs = metabugs
+
+   -- compile the content of luafile name in an AST, serialized in astfilename
+   --local status, ast = pcall (mlc.luafile_to_ast, luafilename)
+   local status, ast
+   local function compile() return mlc.luafile_to_ast (luafilename) end
+   if mlc.metabugs then 
+      print 'mlc_xcall.server/metabugs'
+      --status, ast = xpcall (compile, debug.traceback)
+      --status, ast = xpcall (compile, debug.traceback)
+      local function tb(msg)
+         local r = debug.traceback(msg)
+
+         -- Cut superfluous end lines
+         local line_re = '\n[^\n]*'
+         local re =  "^(.-)" .. (line_re) :rep (STACK_LINES_TO_CUT) .. "$"
+         return r :strmatch (re) or r
+      end
+      --status, ast = xpcall (compile, debug.traceback)
+      status, ast = xpcall (compile, tb)
+   else status, ast = pcall (compile) end
+   local out = io.open (astfilename, 'w')
+   if status then -- success
+      out:write (serialize (ast))
+      out:close ()
+      os.exit (0)
+   else -- failure, `ast' is actually the error message
+      out:write (ast)
+      out:close ()
+      os.exit (-1)
+   end      
+end
+
+--------------------------------------------------------------------------------
+-- Compile the file whose name is passed as argument, in a separate process,
+-- communicating through a temporary file.
+-- returns:
+--  * true or false, indicating whether the compilation succeeded
+--  * the ast, or the error message.
+--------------------------------------------------------------------------------
+function mlc_xcall.client_file (luafile)
+
+   -- printf("\n\nmlc_xcall.client_file(%q)\n\n", luafile)
+
+   local tmpfilename = os.tmpname()
+   local cmd = string.format (
+      [=[%s -l metalua.mlc_xcall -e "mlc_xcall.server([[%s]], [[%s]], %s)"]=], 
+      (_PROGDIR and _PROGDIR.."/lua" or "lua"), luafile, tmpfilename, mlc.metabugs and "true" or "false")
+
+   -- printf("os.execute [[%s]]\n\n", cmd)
+
+   local status = (0 == os.execute (cmd))
+   local result -- ast or error msg
+   if status then 
+      result = (lua_loadfile or loadfile) (tmpfilename) ()
+   else
+      local f = io.open (tmpfilename)
+      result = f :read '*a'
+      f :close()
+   end
+   os.remove(tmpfilename)
+   return status, result
+end
+
+--------------------------------------------------------------------------------
+-- Compile a source string into an ast, by dumping it in a tmp
+-- file then calling `mlc_xcall.client_file()'.
+-- returns: the same as `mlc_xcall.client_file()'.
+--------------------------------------------------------------------------------
+function mlc_xcall.client_literal (luasrc)
+   local srcfilename = os.tmpname()
+   local srcfile, msg = io.open (srcfilename, 'w')
+   if not srcfile then print(msg) end
+   srcfile :write (luasrc)
+   srcfile :close ()
+   local status, ast = mlc_xcall.client_file (srcfilename)
+   os.remove(srcfilename)
+   return status, ast
+end
+
+return mlc_xcall

data/vendor/lua/lib/lua/metalua/package2.lua

@@ -0,0 +1,101 @@
+local package = package
+
+require 'metalua.mlc'
+
+package.metalua_extension_prefix = 'metalua.extension.'
+
+package.mpath = os.getenv 'LUA_MPATH' or string.gsub( package.path or "./?.mlua", "%.lua", "%.mlua")
+
+----------------------------------------------------------------------
+-- resc(k) returns "%"..k if it's a special regular expression char,
+-- or just k if it's normal.
+----------------------------------------------------------------------
+local regexp_magic = table.transpose{
+   "^", "$", "(", ")", "%", ".", "[", "]", "*", "+", "-", "?" }
+local function resc(k)
+   return regexp_magic[k] and '%'..k or k
+end
+
+----------------------------------------------------------------------
+-- Take a Lua module name, return the open file and its name,
+-- or <false> and an error message.
+----------------------------------------------------------------------
+function package.findfile(name, path_string)
+   local config_regexp = ("([^\n])\n"):rep(5):sub(1, -2)
+   local dir_sep, path_sep, path_mark, execdir, igmark =
+      package.config:strmatch (config_regexp)
+   name = name:gsub ('%.', dir_sep)
+   local errors = { }
+   local path_pattern = string.format('[^%s]+', resc(path_sep))
+   for path in path_string:gmatch (path_pattern) do
+      --printf('path = %s, rpath_mark=%s, name=%s', path, resc(path_mark), name)
+      local filename = path:gsub (resc (path_mark), name)
+      --printf('filename = %s', filename)
+      local file = io.open (filename, 'r')
+      if file then return file, filename end
+      table.insert(errors, string.format("\tno lua file %q", filename))
+   end
+   return false, table.concat(errors, "\n")..'\n'
+end
+
+----------------------------------------------------------------------
+-- Execute a metalua module sources compilation in a separate process
+-- Sending back the bytecode directly is difficult, as some shells
+-- (at least MS-Windows') interpret some characters. So rather than
+-- base64-encoding the bytecode, AST is returned from the child
+-- process, and converted to bytecode then function in the calling
+-- process.
+----------------------------------------------------------------------
+local function spring_load(filename)
+   -- FIXME: handle compilation errors
+   local pattern = 
+      [=[%s -l metalua.compiler -l serialize -e ]=]..
+      [=["print(serialize(mlc.ast_of_luafile [[%s]]))"]=]
+   local cmd = string.format (pattern, (_PROGDIR and _PROGDIR.."/lua" or "lua"), filename)
+   --print ("running command: ``" .. cmd .. "''")
+   local fd = io.popen (cmd)
+   local ast_src = fd:read '*a'
+   fd:close()
+   local ast = lua_loadstring (ast_src) () -- much faster than loadstring()
+   return mlc.function_of_ast (ast, filename)
+end
+
+----------------------------------------------------------------------
+-- Load a metalua source file.
+----------------------------------------------------------------------
+function package.metalua_loader (name)
+   local file, filename_or_msg = package.findfile (name, package.mpath)
+   if not file then return filename_or_msg end
+   if package.metalua_nopopen then
+      local luastring = file:read '*a'
+      file:close()
+      return mlc.function_of_luastring (luastring, name)
+   else      
+      file:close()
+      require 'metalua.mlc_xcall'
+      local status, ast = mlc_xcall.client_file (filename_or_msg)
+      return mlc.function_of_ast(ast)
+   end
+end
+
+----------------------------------------------------------------------
+-- Placed after lua/luac loader, so precompiled files have
+-- higher precedence.
+----------------------------------------------------------------------
+table.insert(package.loaders, package.metalua_loader)
+
+----------------------------------------------------------------------
+-- Load an extension.
+----------------------------------------------------------------------
+function extension (name, noruntime)
+   local complete_name = package.metalua_extension_prefix..name
+   local x = require (complete_name)
+   if x==true then return
+   elseif type(x) ~= 'table' then
+      error ("extension returned %s instead of an AST", type(x))
+   else
+      return x
+   end
+end
+
+return package

data/vendor/lua/lib/lua/metalua/runtime.lua

@@ -0,0 +1,3 @@
+require 'metalua.base'
+require 'metalua.table2'
+require 'metalua.string2'

data/vendor/lua/lib/lua/metalua/string2.lua

@@ -0,0 +1,44 @@
+
+----------------------------------------------------------------------
+----------------------------------------------------------------------
+--
+-- String module extension
+--
+----------------------------------------------------------------------
+----------------------------------------------------------------------
+
+-- Courtesy of lua-users.org
+function string.split(str, pat)
+   local t = {} 
+   local fpat = "(.-)" .. pat
+   local last_end = 1
+   local s, e, cap = string.find(str, fpat, 1)
+   while s do
+      if s ~= 1 or cap ~= "" then
+          table.insert(t,cap)
+       end
+      last_end = e+1
+      s, e, cap = string.find(str, fpat, last_end)
+   end
+   if last_end <= string.len(str) then
+      cap = string.sub(str, last_end)
+      table.insert(t, cap)
+   end
+   return t
+end
+
+-- "match" is regularly used as a keyword for pattern matching, 
+-- so here is an always available substitute.
+string.strmatch = string["match"]
+
+-- change a compiled string into a function
+function string.undump(str)
+   if str:strmatch '^\027LuaQ' or str:strmatch '^#![^\n]+\n\027LuaQ' then
+      local f = (lua_loadstring or loadstring)(str)
+      return f
+   else
+      error "Not a chunk dump"
+   end
+end
+
+return string

data/vendor/lua/lib/lua/metalua/table2.lua

@@ -0,0 +1,372 @@
+---------------------------------------------------------------------
+----------------------------------------------------------------------
+--
+-- Table module extension
+--
+----------------------------------------------------------------------
+----------------------------------------------------------------------
+
+-- todo: table.scan (scan1?) fold1? flip?
+
+function table.transpose(t)
+   local tt = { }
+   for a, b in pairs(t) do tt[b] = a end
+   return tt
+end
+
+function table.iforeach(f, ...)
+   -- assert (type (f) == "function") [wouldn't allow metamethod __call]
+   local nargs = select("#", ...)
+   if nargs==1 then -- Quick iforeach (most common case), just one table arg
+      local t = ...
+      assert (type (t) == "table")
+      for i = 1, #t do 
+         local result = f (t[i])
+         -- If the function returns non-false, stop iteration
+         if result then return result end
+      end
+   else -- advanced case: boundaries and/or multiple tables
+      -- 1 - find boundaries if any
+      local  args, fargs, first, last, arg1 = {...}, { }
+      if     type(args[1]) ~= "number" then first, arg1 = 1, 1
+      elseif type(args[2]) ~= "number" then first, last, arg1 = 1, args[1], 2
+      else   first,  last, i = args[1], args[2], 3 end
+      assert (nargs > arg1)
+      -- 2 - determine upper boundary if not given
+      if not last then for i = arg1, nargs do 
+            assert (type (args[i]) == "table")
+            last = max (#args[i], last) 
+      end end
+      -- 3 - perform the iteration
+      for i = first, last do
+         for j = arg1, nargs do fargs[j] = args[j][i] end -- build args list
+         local result = f (unpack (fargs)) -- here is the call
+         -- If the function returns non-false, stop iteration
+         if result then return result end
+      end
+   end
+end
+
+function table.imap (f, ...)
+   local result, idx = { }, 1
+   local function g(...) result[idx] = f(...);  idx=idx+1 end
+   table.iforeach(g, ...)
+   return result
+end
+
+function table.ifold (f, acc, ...)
+   local function g(...) acc = f (acc,...) end
+   table.iforeach (g, ...)
+   return acc
+end
+
+-- function table.ifold1 (f, ...)
+--    return table.ifold (f, acc, 2, false, ...)
+-- end
+
+function table.izip(...)
+   local function g(...) return {...} end
+   return table.imap(g, ...)
+end
+
+function table.ifilter(f, t)
+   local yes, no = { }, { }
+   for i=1,#t do table.insert (f(t[i]) and yes or no, t[i]) end
+   return yes, no
+end
+
+function table.icat(...)
+   local result = { }
+   for t in values {...} do
+      for x in values (t) do
+         table.insert (result, x)
+      end
+   end
+   return result
+end
+
+function table.iflatten (x) return table.icat (unpack (x)) end
+
+function table.irev (t)
+   local result, nt = { }, #t
+   for i=0, nt-1 do result[nt-i] = t[i+1] end
+   return result
+end
+
+function table.isub (t, ...)
+   local ti, u = table.insert, { }
+   local args, nargs = {...}, select("#", ...)
+   for i=1, nargs/2 do
+      local a, b = args[2*i-1], args[2*i]
+      for i=a, b, a<=b and 1 or -1 do ti(u, t[i]) end
+   end
+   return u
+end
+
+function table.iall (f, ...)
+   local result = true
+   local function g(...) return not f(...) end
+   return not table.iforeach(g, ...)
+   --return result
+end
+
+function table.iany (f, ...)
+   local function g(...) return not f(...) end
+   return not table.iall(g, ...)
+end
+
+function table.shallow_copy(x)
+   local y={ }
+   for k, v in pairs(x) do y[k]=v end
+   return y
+end
+
+-- Warning, this is implementation dependent: it relies on
+-- the fact the [next()] enumerates the array-part before the hash-part.
+function table.cat(...)
+   local y={ }
+   for x in values{...} do
+      -- cat array-part
+      for _, v in ipairs(x) do table.insert(y,v) end
+      -- cat hash-part
+      local lx, k = #x
+      if lx>0 then k=next(x,lx) else k=next(x) end
+      while k do y[k]=x[k]; k=next(x,k) end
+   end
+   return y
+end
+
+function table.deep_copy(x) 
+   local tracker = { }
+   local function aux (x)
+      if type(x) == "table" then
+         local y=tracker[x]
+         if y then return y end
+         y = { }; tracker[x] = y
+         setmetatable (y, getmetatable (x))
+         for k,v in pairs(x) do y[aux(k)] = aux(v) end
+         return y
+      else return x end
+   end
+   return aux(x)
+end
+
+function table.override(dst, src)
+   for k, v in pairs(src) do dst[k] = v end
+   for i = #src+1, #dst   do dst[i] = nil end
+   return dst
+end
+
+
+function table.range(a,b,c)
+   if not b then assert(not(c)); b=a; a=1
+   elseif not c then c = (b>=a) and 1 or -1 end
+   local result = { }
+   for i=a, b, c do table.insert(result, i) end
+   return result
+end
+
+-- FIXME: new_indent seems to be always nil?!
+-- FIXME: accumulator function should be configurable,
+-- so that print() doesn't need to bufferize the whole string
+-- before starting to print.
+function table.tostring(t, ...)
+   local PRINT_HASH, HANDLE_TAG, FIX_INDENT, LINE_MAX, INITIAL_INDENT = true, true
+   for _, x in ipairs {...} do
+      if type(x) == "number" then
+         if not LINE_MAX then LINE_MAX = x
+         else INITIAL_INDENT = x end
+      elseif x=="nohash" then PRINT_HASH = false
+      elseif x=="notag"  then HANDLE_TAG = false
+      else
+         local n = string['match'](x, "^indent%s*(%d*)$")
+         if n then FIX_INDENT = tonumber(n) or 3 end
+      end
+   end
+   LINE_MAX       = LINE_MAX or math.huge
+   INITIAL_INDENT = INITIAL_INDENT or 1
+   
+   local current_offset =  0  -- indentation level
+   local xlen_cache     = { } -- cached results for xlen()
+   local acc_list       = { } -- Generated bits of string
+   local function acc(...)    -- Accumulate a bit of string
+      local x = table.concat{...}
+      current_offset = current_offset + #x
+      table.insert(acc_list, x) 
+   end
+   local function valid_id(x)
+      -- FIXME: we should also reject keywords; but the list of
+      -- current keywords is not fixed in metalua...
+      return type(x) == "string" 
+         and string['match'](x, "^[a-zA-Z_][a-zA-Z0-9_]*$")
+   end
+   
+   -- Compute the number of chars it would require to display the table
+   -- on a single line. Helps to decide whether some carriage returns are
+   -- required. Since the size of each sub-table is required many times,
+   -- it's cached in [xlen_cache].
+   local xlen_type = { }
+   local function xlen(x, nested)
+      nested = nested or { }
+      if x==nil then return #"nil" end
+      --if nested[x] then return #tostring(x) end -- already done in table
+      local len = xlen_cache[x]
+      if len then return len end
+      local f = xlen_type[type(x)]
+      if not f then return #tostring(x) end
+      len = f (x, nested) 
+      xlen_cache[x] = len
+      return len
+   end
+
+   -- optim: no need to compute lengths if I'm not going to use them
+   -- anyway.
+   if LINE_MAX == math.huge then xlen = function() return 0 end end
+
+   xlen_type["nil"] = function () return 3 end
+   function xlen_type.number  (x) return #tostring(x) end
+   function xlen_type.boolean (x) return x and 4 or 5 end
+   function xlen_type.string  (x) return #string.format("%q",x) end
+   function xlen_type.table   (adt, nested)
+
+      -- Circular references detection
+      if nested [adt] then return #tostring(adt) end
+      nested [adt] = true
+
+      local has_tag  = HANDLE_TAG and valid_id(adt.tag)
+      local alen     = #adt
+      local has_arr  = alen>0
+      local has_hash = false
+      local x = 0
+      
+      if PRINT_HASH then
+         -- first pass: count hash-part
+         for k, v in pairs(adt) do
+            if k=="tag" and has_tag then 
+               -- this is the tag -> do nothing!
+            elseif type(k)=="number" and k<=alen and math.fmod(k,1)==0 then 
+               -- array-part pair -> do nothing!
+            else
+               has_hash = true
+               if valid_id(k) then x=x+#k
+               else x = x + xlen (k, nested) + 2 end -- count surrounding brackets
+               x = x + xlen (v, nested) + 5          -- count " = " and ", "
+            end
+         end
+      end
+
+      for i = 1, alen do x = x + xlen (adt[i], nested) + 2 end -- count ", "
+      
+      nested[adt] = false -- No more nested calls
+
+      if not (has_tag or has_arr or has_hash) then return 3 end
+      if has_tag then x=x+#adt.tag+1 end
+      if not (has_arr or has_hash) then return x end
+      if not has_hash and alen==1 and type(adt[1])~="table" then
+         return x-2 -- substract extraneous ", "
+      end
+      return x+2 -- count "{ " and " }", substract extraneous ", "
+   end
+   
+   -- Recursively print a (sub) table at given indentation level.
+   -- [newline] indicates whether newlines should be inserted.
+   local function rec (adt, nested, indent)
+      if not FIX_INDENT then indent = current_offset end
+      local function acc_newline()
+         acc ("\n"); acc (string.rep (" ", indent)) 
+         current_offset = indent
+      end
+      local x = { }
+      x["nil"] = function() acc "nil" end
+      function x.number()   acc (tostring (adt)) end
+      --function x.string()   acc (string.format ("%q", adt)) end
+      function x.string()   acc ((string.format ("%q", adt):gsub("\\\n", "\\n"))) end
+      function x.boolean()  acc (adt and "true" or "false") end
+      function x.table()
+         if nested[adt] then acc(tostring(adt)); return end
+         nested[adt]  = true
+
+
+         local has_tag  = HANDLE_TAG and valid_id(adt.tag)
+         local alen     = #adt
+         local has_arr  = alen>0
+         local has_hash = false
+
+         if has_tag then acc("`"); acc(adt.tag) end
+
+         -- First pass: handle hash-part
+         if PRINT_HASH then
+            for k, v in pairs(adt) do
+               -- pass if the key belongs to the array-part or is the "tag" field
+               if not (k=="tag" and HANDLE_TAG) and 
+                  not (type(k)=="number" and k<=alen and math.fmod(k,1)==0) then
+
+                  -- Is it the first time we parse a hash pair?
+                  if not has_hash then 
+                     acc "{ "
+                     if not FIX_INDENT then indent = current_offset end
+                  else acc ", " end
+
+                  -- Determine whether a newline is required
+                  local is_id, expected_len = valid_id(k)
+                  if is_id then expected_len = #k + xlen (v, nested) + #" = , "
+                  else expected_len = xlen (k, nested) + 
+                                      xlen (v, nested) + #"[] = , " end
+                  if has_hash and expected_len + current_offset > LINE_MAX
+                  then acc_newline() end
+                  
+                  -- Print the key
+                  if is_id then acc(k); acc " = " 
+                  else  acc "["; rec (k, nested, indent+(FIX_INDENT or 0)); acc "] = " end
+
+                  -- Print the value
+                  rec (v, nested, indent+(FIX_INDENT or 0))
+                  has_hash = true
+               end
+            end
+         end
+
+         -- Now we know whether there's a hash-part, an array-part, and a tag.
+         -- Tag and hash-part are already printed if they're present.
+         if not has_tag and not has_hash and not has_arr then acc "{ }"; 
+         elseif has_tag and not has_hash and not has_arr then -- nothing, tag already in acc
+         else 
+            assert (has_hash or has_arr)
+            local no_brace = false
+            if has_hash and has_arr then acc ", " 
+            elseif has_tag and not has_hash and alen==1 and type(adt[1])~="table" then
+               -- No brace required; don't print "{", remember not to print "}"
+               acc (" "); rec (adt[1], nested, indent+(FIX_INDENT or 0))
+               no_brace = true
+            elseif not has_hash then
+               -- Braces required, but not opened by hash-part handler yet
+               acc "{ "
+               if not FIX_INDENT then indent = current_offset end
+            end
+
+            -- 2nd pass: array-part
+            if not no_brace and has_arr then 
+               rec (adt[1], nested, indent+(FIX_INDENT or 0))
+               for i=2, alen do 
+                  acc ", ";                   
+                  if   current_offset + xlen (adt[i], { }) > LINE_MAX
+                  then acc_newline() end
+                  rec (adt[i], nested, indent+(FIX_INDENT or 0)) 
+               end
+            end
+            if not no_brace then acc " }" end
+         end
+         nested[adt] = false -- No more nested calls
+      end
+      local y = x[type(adt)]
+      if y then y() else acc(tostring(adt)) end
+   end
+   --printf("INITIAL_INDENT = %i", INITIAL_INDENT)
+   current_offset = INITIAL_INDENT or 0
+   rec(t, { }, 0)
+   return table.concat (acc_list)
+end
+
+function table.print(...) return print(table.tostring(...)) end
+
+return table