rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/table_ext.lua

@@ -0,0 +1,117 @@
+-- Extensions to the table module
+module ("table", package.seeall)
+
+--require "list" FIXME: allow require loops
+
+
+local _sort = sort
+--- Make table.sort return its result.
+-- @param t table
+-- @param c comparator function
+-- @return sorted table
+function sort (t, c)
+  _sort (t, c)
+  return t
+end
+
+--- Return whether table is empty.
+-- @param t table
+-- @return <code>true</code> if empty or <code>false</code> otherwise
+function empty (t)
+  return not next (t)
+end
+
+--- Find the number of elements in a table.
+-- @param t table
+-- @return number of elements in t
+function size (t)
+  local n = 0
+  for _ in pairs (t) do
+    n = n + 1
+  end
+  return n
+end
+
+--- Make the list of keys of a table.
+-- @param t table
+-- @return list of keys
+function keys (t)
+  local u = {}
+  for i, v in pairs (t) do
+    insert (u, i)
+  end
+  return u
+end
+
+--- Make the list of values of a table.
+-- @param t table
+-- @return list of values
+function values (t)
+  local u = {}
+  for i, v in pairs (t) do
+    insert (u, v)
+  end
+  return u
+end
+
+--- Invert a table.
+-- @param t table <code>{i=v, ...}</code>
+-- @return inverted table <code>{v=i, ...}</code>
+function invert (t)
+  local u = {}
+  for i, v in pairs (t) do
+    u[v] = i
+  end
+  return u
+end
+
+--- Make a shallow copy of a table, including any metatable (for a
+-- deep copy, use tree.clone).
+-- @param t table
+-- @param nometa if non-nil don't copy metatable
+-- @return copy of table
+function clone (t, nometa)
+  local u = {}
+  if not nometa then
+    setmetatable (u, getmetatable (t))
+  end
+  for i, v in pairs (t) do
+    u[i] = v
+  end
+  return u
+end
+
+--- Clone a table, renaming some keys.
+-- @param map table <code>{old_key=new_key, ...}</code>
+-- @param t table to copy
+-- @return copy of table
+function clone_rename (map, t)
+  local r = clone (t)
+  for i, v in pairs (map) do
+    r[v] = t[i]
+    r[i] = nil
+  end
+  return r
+end
+
+--- Merge one table into another. <code>u</code> is merged into <code>t</code>.
+-- @param t first table
+-- @param u second table
+-- @return first table
+function merge (t, u)
+  for i, v in pairs (u) do
+    t[i] = v
+  end
+  return t
+end
+
+--- Make a table with a default value for unset keys.
+-- @param x default entry value (default: <code>nil</code>)
+-- @param t initial table (default: <code>{}</code>)
+-- @return table whose unset elements are x
+function new (x, t)
+  return setmetatable (t or {},
+                       {__index = function (t, i)
+                                    return x
+                                  end})
+end

data/vendor/lua/lib/lua/tar.lua

@@ -0,0 +1,262 @@
+-----------------------------------------------------------------------------
+-- tar - Lua Tape ARchive module
+--
+-- Code for managing tar files
+--
+-- Version 0.1 (21 AUG 2007)
+--
+-- Author: Judge Maygarden (jmaygarden@computer.org)
+--
+-- Copyright (c) 2007 Judge Maygarden
+-----------------------------------------------------------------------------
+
+local public = {}
+local private = {}
+local TarFile = {}
+local TarInternalFile = {}
+tar = public
+TarFile.__index = TarFile
+TarInternalFile.__index = TarInternalFile
+
+-----------------------------------------------------------------------------
+-- Closes file
+-----------------------------------------------------------------------------
+function TarInternalFile:close()
+end
+
+-----------------------------------------------------------------------------
+-- UNSUPPORTED: Saves any written data to file
+-----------------------------------------------------------------------------
+function TarInternalFile:flush()
+	error('Tar file output flushing is unsupported.')
+end
+
+-----------------------------------------------------------------------------
+-- Returns an iterator function that returns a new line from the file
+-- @return String repressenting a line from the file without the newline
+-----------------------------------------------------------------------------
+function TarInternalFile:lines()
+	return function(s, var)
+		return self:read("*l")
+	end, self, nil
+end
+
+-----------------------------------------------------------------------------
+-- Reads the file according to the given formats as follows:
+-- "*n": reads a number
+-- "*a": reads the whole file
+-- "*l" reads the next line
+-- number: reads a string with up to this number of characters
+-- @param variadic list of formats (default "*l")
+-- @return list of strings (or numbers) or nil if end of file or format error
+-----------------------------------------------------------------------------
+function TarInternalFile:read(...)
+	local eof = self.offset + self.size
+	if self.pointer >= eof then return nil end -- eof
+	local t = {}
+	self.archive.file:seek("set", self.pointer)
+	for i, v in ipairs{...} do
+		local s
+		if "*a" == v then
+			s = self.archive.file:read(eof - self.pointer)
+		elseif "*l" == v or "*n" == v or "number" == type(v) then
+			s = self.archive.file:read(v)
+		else
+			error('bad argument %d to %s (%s)', i
+				'TarInternalFile:read', 'invalid format')
+			return nil
+		end
+		local last = self.pointer
+		self.pointer = self.archive.file:seek()
+		if s and self.pointer < eof then
+			table.insert(t, s)
+		elseif s then
+			table.insert(t, string.sub(s, 1, eof - last - 1))
+			self.pointer = self.offset + self.size
+			break
+		else
+			break
+		end
+	end
+	return unpack(t)
+end
+
+-----------------------------------------------------------------------------
+-- Sets and gets the file position measured from the given base as follows:
+-- "set": base is position 0 (beginning of the file)
+-- "cur": base is current position
+-- "end": base is end of file
+-- @param base position (default "cur")
+-- @param offset in bytes (default 0)
+-- @return final position
+-----------------------------------------------------------------------------
+function TarInternalFile:seek(whence, offset)
+	local whence = whence or "cur"
+	local offset = offset or 0
+	local eof = self.offset + self.size
+	local final
+	local err
+
+	if "cur" == whence then
+		final, err = self.archive.file:seek("set",
+			offset + self.pointer) - self.offset
+
+	elseif "set" == whence then
+		final, err =  self.archive.file:seek("set",
+			offset + self.offset) - self.offset
+
+	elseif "end" == whence then
+		final, err =  self.archive.file:seek("set",
+			offset + eof - 1) - self.offset
+
+	else
+		final, err =  self.archive.file:seek(whence, offset)
+	end
+
+	if not final then
+		return nil, err
+	elseif final < 0 then
+		final = 0
+	elseif final > self.size then
+		final = self.size
+	end
+	self.pointer = final + self.offset
+	
+	return final
+end
+
+-----------------------------------------------------------------------------
+-- UNSUPPORTED: Sets the buffering mode for an output file
+-- @param "no" - no buffering, "full" - full buffering, "line" - line buffering
+-- @param size of the buffer for "full" and "line" modes
+-----------------------------------------------------------------------------
+function TarInternalFile:setvbuf(mode, size)
+	error('Tar file output buffering is unsupported.')
+end
+
+-----------------------------------------------------------------------------
+-- UNSUPPORTED: Writes the value of each of its arguments to the file
+-- @param string or numbers values only
+-----------------------------------------------------------------------------
+function TarInternalFile:write(...)
+	error('Tar file writes are unsupported.')
+end
+
+-----------------------------------------------------------------------------
+-- Opens a file inside the tar file archive
+-- @param pathname of a file inside the tar file
+-- @return file handle or nil if the file is not found
+-----------------------------------------------------------------------------
+function TarFile:open(filename)
+	if not self.list[filename] then return nil end
+	local file = {}
+	file.archive = self
+	file.filename = filename
+	file.offset = self.list[filename].offset
+	file.pointer = file.offset
+	file.size = self.list[filename].size
+	setmetatable(file, TarInternalFile)
+	return file
+end
+
+-----------------------------------------------------------------------------
+-- Returns an iterator over all files in the tar archive
+-- @return interator function, tar file handle
+-----------------------------------------------------------------------------
+function TarFile:files()
+	return next, self.list, nil
+end
+
+-----------------------------------------------------------------------------
+-- Data for parsing tar header fields
+-----------------------------------------------------------------------------
+private.HEADER_DATA = {
+	-- { field, offset, size, octal }
+	{ "name", 0, 100 },
+	{ "mode", 100, 8, true },
+	{ "uid", 108, 8, true },
+	{ "gid", 116, 8, true },
+	{ "size", 124, 12, true },
+	{ "mtime", 136, 12, true },
+	{ "chksum", 148, 8, true },
+	{ "typeflag", 156, 1, true },
+	{ "linkname", 157, 100 },
+	{ "magic", 257, 6 },
+	{ "version", 263, 2 },
+	{ "uname", 265, 32 },
+	{ "gname", 297, 32 },
+	{ "devmajor", 329, 8, true },
+	{ "devminor", 337, 8, true },
+	{ "prefix", 345, 155 },
+}
+
+-----------------------------------------------------------------------------
+-- Converts an octal string into a number
+-- @param string of octal digits
+-- @return number or nil if an invalid string was passed
+-----------------------------------------------------------------------------
+private.octal = function(s)
+	if string.match(s, "[^0-7]") then return nil end
+	local n, m = 0, 0
+	for i = string.len(s), 1, -1 do
+		n = n + (string.byte(s, i) - 48) * 8 ^ m
+		m = m + 1
+	end
+	return n
+end
+
+-----------------------------------------------------------------------------
+-- Decodes a tar file header
+-- @param 512-byte string containing a tar file header block
+-- @return table containg the header fields
+-----------------------------------------------------------------------------
+private.decode = function(header)
+	local t = {}
+	for _, field in ipairs(private.HEADER_DATA) do
+		local s = string.sub(header, field[2] + 1, field[2] + field[3])
+		local s = string.match(s, "[^%z]*")
+		if field[4] then
+			t[field[1]] = private.octal(s)
+		else
+			t[field[1]] = s
+		end
+	end
+	if 0 < string.len(t.prefix) then
+		t.pathname = t.prefix..'/'..t.name
+	else
+		t.pathname = t.name
+	end
+	return t
+end
+
+-----------------------------------------------------------------------------
+-- Opens a tar archive by attaching to the provided Lua file handle.
+-- Ownership of the file handle is transferred to the returned table and
+-- should no longer be referenced by the user.
+-- @param open file handle
+-- @return tar file handle
+-----------------------------------------------------------------------------
+public.open = function(file)
+	assert(file, 'invalid file handle')
+	local archive = {}
+	archive.file = file
+	archive.list = {}
+	local p = file:seek("set")
+	while true do
+		local block = file:read(512)
+		if not block or not string.match(block, "[^%z]") then break end
+		local header = private.decode(block)
+		if 0 == header.typeflag then
+			archive.list[header.pathname] = {
+				["offset"] = file:seek(),
+				["size"] = header.size
+			}
+		end
+		local p = file:seek("cur", 512 * math.ceil(header.size / 512))
+	end
+	setmetatable(archive, TarFile)
+	return archive
+end
+
+return tar
+

data/vendor/lua/lib/lua/tree.lua

@@ -0,0 +1,81 @@
+--- Tables as trees.
+module ("tree", package.seeall)
+
+require "list"
+
+
+local metatable = {}
+--- Make a table into a tree
+-- @param t table
+-- @return tree
+function new (t)
+  return setmetatable (t or {}, metatable)
+end
+
+--- Tree <code>__index</code> metamethod.
+-- @param tr tree
+-- @param i non-table, or list of keys <code>{i<sub>1</sub> ...
+-- i<sub>n</sub>}</code>
+-- @return <code>tr[i]...[i<sub>n</sub>]</code> if i is a table, or
+-- <code>tr[i]</code> otherwise
+function metatable.__index (tr, i)
+  -- FIXME: the following doesn't treat list keys correctly
+  --        e.g. tr[{{1, 2}, {3, 4}}], maybe flatten first?
+  if type (i) == "table" and #i > 0 then
+    return list.foldl (op["[]"], tr, i)
+  else
+    return rawget (tr, i)
+  end
+end
+
+--- Tree <code>__newindex</code> metamethod.
+-- Sets <code>tr[i<sub>1</sub>]...[i<sub>n</sub>] = v</code> if i is a
+-- table, or <code>tr[i] = v</code> otherwise
+-- @param tr tree
+-- @param i non-table, or list of keys <code>{i<sub>1</sub> ...
+-- i<sub>n</sub>}</code>
+-- @param v value
+function metatable.__newindex (tr, i, v)
+  if type (i) == "table" then
+    for n = 1, #i - 1 do
+      if getmetatable (tr[i[n]]) ~= metatable then
+        rawset (tr, i[n], tree.new ())
+      end
+      tr = tr[i[n]]
+    end
+    rawset (tr, i[#i], v)
+  else
+    rawset (tr, i, v)
+  end
+end
+
+--- Make a deep copy of a tree, including any metatables
+-- @param t table
+-- @param nometa if non-nil don't copy metatables
+-- @return copy of table
+function clone (t, nometa)
+  local r = {}
+  if not nometa then
+    setmetatable (r, getmetatable (t))
+  end
+  local d = {[t] = r}
+  local function copy (o, x)
+    for i, v in pairs (x) do
+      if type (v) == "table" then
+        if not d[v] then
+          d[v] = {}
+          if not nometa then
+            setmetatable (d[v], getmetatable (v))
+          end
+          o[i] = copy (d[v], v)
+        else
+          o[i] = d[v]
+        end
+      else
+        o[i] = v
+      end
+    end
+    return o
+  end
+  return copy (r, t)
+end