rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/gzip.lua

@@ -0,0 +1,81 @@
+
+--[===================================================================[
+TODO:
+	- add a nice header with license and stuff..
+	- detect plain text files
+	- proper testing
+	- improve implementation?
+	- check gzopen flags for consistency (ex: strategy flag)
+--]===================================================================]
+
+local io = require 'io'
+local zlib = require 'zlib'
+
+local error, assert, setmetatable, tostring = error, assert, setmetatable, tostring
+
+module('gzip')
+
+function open(filename, mode)
+	mode = mode or 'r'
+	local r = mode:find('r', 1, true) and true
+	local w = mode:find('w', 1, true) and true
+	local level = -1
+
+	local lstart, lend = mode:find('%d')
+	if (lstart and lend) then
+		level = mode:sub(lstart, lend)
+	end
+
+	if (not (r or w)) then
+		error('file open mode must specify read or write operation')
+	end
+
+	local f, z
+
+	local mt = {
+		__index = {
+			read = function(self, ...)
+				return z:read(...)
+			end,
+			write = function(self, ...)
+				return z:write(...)
+			end,
+			seek = function(self, ...)
+				error 'seek not supported on gzip files'
+			end,
+			lines = function(self, ...)
+				return z:lines(...)
+			end,
+			flush = function(self, ...)
+				return z:flush(...) and f:flush()
+			end,
+			close = function(self, ...)
+				return z:close() and f:close()
+			end,
+		},
+		__tostring = function(self)
+			return 'gzip object (' .. mode .. ') [' .. tostring(z) .. '] [' .. tostring(f) .. ']'
+		end,
+	}
+
+	if r then
+		f = assert(io.open(filename, 'rb'))
+		z = assert(zlib.inflate(f))
+	else
+		f = assert(io.open(filename, 'wb'))
+		z = assert(zlib.deflate(f, level, nil, 15 + 16))
+	end
+
+	return setmetatable({}, mt)
+end
+
+function lines(filename)
+	local gz = open(filename, 'r')
+	return function()
+		local line = gz and gz:read()
+		if line == nil then
+			gz:close()
+		end
+		return line
+	end
+end

data/vendor/lua/lib/lua/io_ext.lua

@@ -0,0 +1,115 @@
+--- Additions to the io module
+module ("io", package.seeall)
+
+require "base"
+require "package_ext"
+
+
+-- Get file handle metatable
+local file_metatable = getmetatable (io.stdin)
+
+
+-- Get an input file handle.
+-- @param h file handle or name (default: <code>io.input ()</code>)
+-- @return file handle, or nil on error
+local function input_handle (h)
+  if h == nil then
+    h = input ()
+  elseif _G.type (h) == "string" then
+    h = io.open (h)
+  end
+  return h
+end
+
+--- Slurp a file handle.
+-- @param h file handle or name (default: <code>io.input ()</code>)
+-- @return contents of file or handle, or nil if error
+function slurp (h)
+  h = input_handle (h)
+  if h then
+    local s = h:read ("*a")
+    h:close ()
+    return s
+  end
+end
+
+--- Read a file or file handle into a list of lines.
+-- @param h file handle or name (default: <code>io.input ()</code>);
+-- if h is a handle, the file is closed after reading
+-- @return list of lines
+function readlines (h)
+  h = input_handle (h)
+  local l = {}
+  for line in h:lines () do
+    table.insert (l, line)
+  end
+  h:close ()
+  return l
+end
+file_metatable.readlines = readlines
+
+--- Write values adding a newline after each.
+-- @param h file handle (default: <code>io.output ()</code>
+-- @param ... values to write (as for write)
+function writelines (h, ...)
+  if io.type (h) ~= "file" then
+    io.write (h, "\n")
+    h = io.output ()
+  end
+  for v in ileaves ({...}) do
+    h:write (v, "\n")
+  end
+end
+file_metatable.writelines = writelines
+
+--- Split a directory path into components.
+-- Empty components are retained: the root directory becomes <code>{"", ""}</code>.
+-- @param path path
+-- @return list of path components
+function splitdir (path)
+  return string.split (path, package.dirsep)
+end
+
+--- Concatenate one or more directories and a filename into a path.
+-- @param ... path components
+-- @return path
+function catfile (...)
+  return table.concat ({...}, package.dirsep)
+end
+
+--- Concatenate two or more directories into a path, removing the trailing slash.
+-- @param ... path components
+-- @return path
+function catdir (...)
+  return (string.gsub (catfile (...), "^$", package.dirsep))
+end
+
+--- Perform a shell command and return its output.
+-- @param c command
+-- @return output, or nil if error
+function shell (c)
+  return io.slurp (io.popen (c))
+end
+
+--- Process files specified on the command-line.
+-- If no files given, process <code>io.stdin</code>; in list of files,
+-- <code>-</code> means <code>io.stdin</code>.
+-- <br>FIXME: Make the file list an argument to the function.
+-- @param f function to process files with, which is passed
+-- <code>(name, arg_no)</code>
+function processFiles (f)
+  -- N.B. "arg" below refers to the global array of command-line args
+  if #arg == 0 then
+    table.insert (arg, "-")
+  end
+  for i, v in ipairs (arg) do
+    if v == "-" then
+      io.input (io.stdin)
+    else
+      io.input (v)
+    end
+    prog.file = v
+    f (v, i)
+  end
+  prog.file = nil
+end

data/vendor/lua/lib/lua/lanes-keeper.lua

@@ -0,0 +1,302 @@
+--
+-- KEEPER.LUA
+--
+-- Keeper state logic
+--
+-- This code is read in for each "keeper state", which are the hidden, inter-
+-- mediate data stores used by Lanes inter-state communication objects.
+--
+-- Author: Asko Kauppi <akauppi@gmail.com>
+--
+--[[
+===============================================================================
+
+Copyright (C) 2008-10 Asko Kauppi <akauppi@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+===============================================================================
+]]--
+
+-- We only need to have base and table libraries (and io for debugging)
+--
+local table_concat = assert( table.concat)
+local table_insert = assert( table.insert)
+local table_remove = assert( table.remove)
+local select, unpack = assert( select), assert( unpack)
+
+--[[
+local function WR(...)
+    if io then
+        io.stderr:write( table_concat({...},'\t').."\n" )
+    end
+end
+
+local function DEBUG(title,ud,key)
+    assert( title and ud and key )
+
+    local data,_= tables(ud)
+
+    local s= tostring(data[key])
+    for _,v in ipairs( data[key] or {} ) do
+        s= s..", "..tostring(v)
+    end
+    WR( "*** "..title.." ("..tostring(key).."): ", s )
+end
+--]]
+
+-----
+-- FIFO for a key
+--
+
+local fifo_new = function()
+    return { first = 1, count = 0}
+end
+
+local fifo_push = function( fifo, ...)
+    local first, count, added = fifo.first, fifo.count, select( '#', ...)
+    local start = first + count - 1
+    for i = 1, added do
+        fifo[start + i] = select( i, ...)
+    end
+    fifo.count = count + added
+end
+
+local fifo_peek = function( fifo, count)
+    if count <= fifo.count then
+			local first = fifo.first
+			local last = first + count - 1
+			return unpack( fifo, first, last)
+    end
+end
+
+local fifo_pop = function( fifo, count)
+    local first = fifo.first
+    local last = first + count - 1
+    local out = { unpack( fifo, first, last)}
+    for i = first, last do
+        fifo[i] = nil
+    end
+    fifo.first = first + count
+    fifo.count = fifo.count - count
+    return unpack( out)
+end
+
+
+-----
+-- Actual data store
+--
+-- { [linda_deep_ud]= { key= { val [, ... ] } [, ...] }
+--      ...
+-- }
+--
+local _data= {}
+
+-----
+-- Length limits (if any) for queues
+--
+-- 0:   don't queue values at all; ':send()' waits if the slot is not vacant
+-- N:   allow N values to be queued (slot itself + N-1); wait if full
+-- nil: no limits, '_data' may grow endlessly
+--
+local _limits= {}
+
+-----
+-- data_tbl, limits_tbl = tables( linda_deep_ud )
+--
+-- Gives appropriate tables for a certain Linda (creates them if needed)
+--
+local function tables( ud )
+    -- tables are created either all or nothing
+    --
+    if not _data[ud] then
+        _data[ud]= {}
+        _limits[ud]= {}
+    end
+    return _data[ud], _limits[ud]
+end
+
+-----
+-- bool= send( linda_deep_ud, key, ...)
+--
+-- Send new data (1..N) to 'key' slot. This send is atomic; all the values
+-- end up one after each other (this is why having possibility for sending
+-- multiple values in one call is deemed important).
+--
+-- If the queue has a limit, values are sent only if all of them fit in.
+--
+-- Returns: 'true' if all the values were placed
+--          'false' if sending would exceed the queue limit (wait & retry)
+--
+function send( ud, key, ...)
+
+    local data, limits = tables( ud)
+
+    local n = select( '#', ...)
+
+    -- Initialize queue for all keys that have been used with ':send()'
+    --
+    if data[key] == nil then
+        data[key] = fifo_new()
+    end
+    local fifo = data[key]
+
+    local len = fifo.count
+    local m = limits[key]
+
+    if m and len+n > m then
+        return false    -- would exceed the limit; try again later
+    end
+
+    fifo_push( fifo, ...)
+    return true
+end
+
+
+-----
+-- [val, key]= receive( linda_deep_ud, key [, ...] )
+--
+-- Read any of the given keys, consuming the data found. Keys are read in
+-- order.
+--
+function receive( ud, ...)
+
+    local data = tables( ud)
+
+    for i = 1, select( '#', ...) do
+        local key = select( i, ...)
+        local fifo = data[key]
+        if fifo and fifo.count > 0 then
+            local val = fifo_pop( fifo, 1)
+            if val ~= nil then
+                return val, key
+            end
+        end
+    end
+end
+
+
+-----
+-- [val1, ... valCOUNT]= receive_batched( linda_deep_ud, key , min_COUNT, max_COUNT)
+--
+-- Read a single key, consuming the data found.
+--
+receive_batched = function( ud, key, min_count, max_count)
+    if min_count > 0 then
+        local fifo = tables( ud)[key]
+        if fifo then
+            local fifo_count = fifo.count
+            if fifo_count >= min_count then
+                max_count = max_count or min_count
+                max_count = (max_count > fifo_count) and fifo_count or max_count
+                return fifo_pop( fifo, max_count)
+            end
+        end
+    end
+end
+
+
+-----
+-- = limit( linda_deep_ud, key, uint )
+--
+function limit( ud, key, n)
+
+    local _, limits = tables( ud)
+
+    limits[key] = n
+end
+
+
+-----
+-- void= set( linda_deep_ud, key, [val] )
+--
+function set( ud, key, val)
+
+    local data, _ = tables( ud)
+
+    -- Setting a key to 'nil' really clears it; only queing uses sentinels.
+    --
+    if val ~= nil then
+        local fifo = fifo_new()
+        fifo_push( fifo, val)
+        data[key] = fifo
+    else
+        data[key] = nil
+    end
+end
+
+
+-----
+-- [val]= get( linda_deep_ud, key )
+--
+function get( ud, key)
+    local data, _ = tables( ud)
+    local fifo = data[key]
+    return fifo and fifo_peek( fifo, 1)
+end
+
+
+-----
+-- [val]= count( linda_deep_ud, ...)
+--
+-- 3 modes of operation
+-- linda:count() -> returns a table of key/count pairs
+-- linda:count(key) returns the number of items waiting in the key
+-- linda:count(key,...) -> returns a table telling, for each key, the number of items
+function count( ud, ...)
+    local data, _ = tables( ud)
+    local n = select( '#', ...)
+    if n == 0 then
+        local out
+        for key, _ in pairs( data) do
+			local fifo = data[key]
+			local count = fifo and fifo.count or 0
+			out = out or {}
+            out[key] = count
+            found = true
+        end
+        return out
+    elseif n == 1 then
+        local key = ...
+        local fifo = data[key]
+		return fifo and fifo.count or nil
+    else -- more than 1 key
+        local out
+        for i = 1, n do
+            local key = select( i, ...)
+			local fifo = data[key]
+			local count = fifo and fifo.count or nil
+			out = out or {}
+            out[key] = count
+		end
+        return out
+    end
+end
+
+
+-----
+-- void= clear( linda_deep_ud)
+--
+-- Clear the data structures used for a Linda (at its destructor)
+--
+function clear( ud)
+
+    _data[ud]= nil
+    _limits[ud]= nil
+end