rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/loop/collection/MapWithArrayOfKeys.lua

@@ -0,0 +1,64 @@
+--------------------------------------------------------------------------------
+---------------------- ##       #####    #####   ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##   ## -----------------------
+---------------------- ##      ##   ##  ##   ##  ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##      -----------------------
+---------------------- ######   #####    #####   ##      -----------------------
+----------------------                                   -----------------------
+----------------------- Lua Object-Oriented Programming ------------------------
+--------------------------------------------------------------------------------
+-- Project: LOOP Class Library                                                --
+-- Release: 2.3 beta                                                          --
+-- Title  : Map of Objects that Keeps an Array of Key Values                  --
+-- Author : Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+-- Notes:                                                                     --
+--   Can only store non-numeric values.                                       --
+--   Use of key strings equal to the name of one method prevents its usage.   --
+--------------------------------------------------------------------------------
+
+local rawget         = rawget
+local table          = require "table"
+local oo             = require "loop.simple"
+local UnorderedArray = require "loop.collection.UnorderedArray"
+
+module("loop.collection.MapWithArrayOfKeys", oo.class)
+
+keyat = rawget
+
+function value(self, key, value)
+	if value == nil
+		then return self[key]
+		else self[key] = value
+	end
+end
+
+function add(self, key, value)
+	self[#self + 1] = key
+	self[key] = value
+end
+
+function addat(self, index, key, value)
+	table.insert(self, index, key)
+	self[key] = value
+end
+
+function remove(self, key)
+	for i = 1, #self do
+		if self[i] == key then
+			return removeat(self, i)
+		end
+	end
+end
+
+function removeat(self, index)
+	self[ self[index] ] = nil
+	return UnorderedArray.remove(self, index)
+end
+
+function valueat(self, index, value)
+	if value == nil
+		then return self[ self[index] ]
+		else self[ self[index] ] = value
+	end
+end

data/vendor/lua/lib/lua/loop/collection/ObjectCache.lua

@@ -0,0 +1,39 @@
+--------------------------------------------------------------------------------
+---------------------- ##       #####    #####   ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##   ## -----------------------
+---------------------- ##      ##   ##  ##   ##  ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##      -----------------------
+---------------------- ######   #####    #####   ##      -----------------------
+----------------------                                   -----------------------
+----------------------- Lua Object-Oriented Programming ------------------------
+--------------------------------------------------------------------------------
+-- Project: LOOP Class Library                                                --
+-- Release: 2.3 beta                                                          --
+-- Title  : Cache of Objects Created on Demand                                --
+-- Author : Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+-- Notes:                                                                     --
+--   Storage of keys 'retrieve' and 'default' are not allowed.                --
+--------------------------------------------------------------------------------
+
+local rawget = rawget
+local rawset = rawset
+
+local oo   = require "loop.base"
+
+module("loop.collection.ObjectCache", oo.class)
+
+__mode = "k"
+
+function __index(self, key)
+	if key ~= nil then
+		local value = rawget(self, "retrieve")
+		if value then
+			value = value(self, key)
+		else
+			value = rawget(self, "default")
+		end
+		rawset(self, key, value)
+		return value
+	end
+end

data/vendor/lua/lib/lua/loop/collection/OrderedSet.lua

@@ -0,0 +1,164 @@
+--------------------------------------------------------------------------------
+---------------------- ##       #####    #####   ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##   ## -----------------------
+---------------------- ##      ##   ##  ##   ##  ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##      -----------------------
+---------------------- ######   #####    #####   ##      -----------------------
+----------------------                                   -----------------------
+----------------------- Lua Object-Oriented Programming ------------------------
+--------------------------------------------------------------------------------
+-- Project: LOOP Class Library                                                --
+-- Release: 2.3 beta                                                          --
+-- Title  : Ordered Set Optimized for Insertions and Removals                 --
+-- Author : Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+-- Notes:                                                                     --
+--   Storage of strings equal to the name of one method prevents its usage.   --
+--------------------------------------------------------------------------------
+
+local oo = require "loop.base"
+
+--------------------------------------------------------------------------------
+-- key constants ---------------------------------------------------------------
+--------------------------------------------------------------------------------
+
+local FIRST = newproxy()
+local LAST = newproxy()
+
+module("loop.collection.OrderedSet", oo.class)
+
+--------------------------------------------------------------------------------
+-- basic functionality ---------------------------------------------------------
+--------------------------------------------------------------------------------
+
+local function iterator(self, previous)
+	return self[previous], previous
+end
+
+function sequence(self)
+	return iterator, self, FIRST
+end
+
+function contains(self, element)
+	return element ~= nil and (self[element] ~= nil or element == self[LAST])
+end
+
+function first(self)
+	return self[FIRST]
+end
+
+function last(self)
+	return self[LAST]
+end
+
+function empty(self)
+	return self[FIRST] == nil
+end
+
+function insert(self, element, previous)
+	if element ~= nil and not contains(self, element) then
+		if previous == nil then
+			previous = self[LAST]
+			if previous == nil then
+				previous = FIRST
+			end
+		elseif not contains(self, previous) and previous ~= FIRST then
+			return
+		end
+		if self[previous] == nil
+			then self[LAST] = element
+			else self[element] = self[previous]
+		end
+		self[previous] = element
+		return element
+	end
+end
+
+function previous(self, element, start)
+	if contains(self, element) then
+		local previous = (start == nil and FIRST or start)
+		repeat
+			if self[previous] == element then
+				return previous
+			end
+			previous = self[previous]
+		until previous == nil
+	end
+end
+
+function remove(self, element, start)
+	local prev = previous(self, element, start)
+	if prev ~= nil then
+		self[prev] = self[element]
+		if self[LAST] == element
+			then self[LAST] = prev
+			else self[element] = nil
+		end
+		return element, prev
+	end
+end
+
+function replace(self, old, new, start)
+	local prev = previous(self, old, start)
+	if prev ~= nil and new ~= nil and not contains(self, new) then
+		self[prev] = new
+		self[new] = self[old]
+		if old == self[LAST]
+			then self[LAST] = new
+			else self[old] = nil
+		end
+		return old, prev
+	end
+end
+
+function pushfront(self, element)
+	if element ~= nil and not contains(self, element) then
+		if self[FIRST] ~= nil
+			then self[element] = self[FIRST]
+			else self[LAST] = element
+		end
+		self[FIRST] = element
+		return element
+	end
+end
+
+function popfront(self)
+	local element = self[FIRST]
+	self[FIRST] = self[element]
+	if self[FIRST] ~= nil
+		then self[element] = nil
+		else self[LAST] = nil
+	end
+	return element
+end
+
+function pushback(self, element)
+	if element ~= nil and not contains(self, element) then
+		if self[LAST] ~= nil
+			then self[ self[LAST] ] = element
+			else self[FIRST] = element
+		end
+		self[LAST] = element
+		return element
+	end
+end
+
+--------------------------------------------------------------------------------
+-- function aliases ------------------------------------------------------------
+--------------------------------------------------------------------------------
+
+-- set operations
+add = pushback
+
+-- stack operations
+push = pushfront
+pop = popfront
+top = first
+
+-- queue operations
+enqueue = pushback
+dequeue = popfront
+head = first
+tail = last
+
+firstkey = FIRST

data/vendor/lua/lib/lua/loop/collection/PriorityQueue.lua

@@ -0,0 +1,86 @@
+--------------------------------------------------------------------------------
+---------------------- ##       #####    #####   ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##   ## -----------------------
+---------------------- ##      ##   ##  ##   ##  ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##      -----------------------
+---------------------- ######   #####    #####   ##      -----------------------
+----------------------                                   -----------------------
+----------------------- Lua Object-Oriented Programming ------------------------
+--------------------------------------------------------------------------------
+-- Project: LOOP Class Library                                                --
+-- Release: 2.3 beta                                                          --
+-- Title  : Priority Queue Optimized for Insertions and Removals              --
+-- Author : Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+-- Notes:                                                                     --
+--   Storage of strings equal to the name of one method prevents its usage.   --
+--------------------------------------------------------------------------------
+
+local oo         = require "loop.base"
+local OrderedSet = require "loop.collection.OrderedSet"
+
+module("loop.collection.PriorityQueue", oo.class)
+
+--------------------------------------------------------------------------------
+-- internal constants ----------------------------------------------------------
+--------------------------------------------------------------------------------
+
+local PRIORITY = {}
+
+--------------------------------------------------------------------------------
+-- basic functionality ---------------------------------------------------------
+--------------------------------------------------------------------------------
+
+-- internal functions
+local function getpriorities(self)
+	if not self[PRIORITY] then
+		self[PRIORITY] = {}
+	end
+	return self[PRIORITY]
+end
+local function removepriority(self, element)
+	if element then
+		local priorities = getpriorities(self)
+		local priority = priorities[element]
+		priorities[element] = nil
+		return element, priority
+	end
+end
+
+-- borrowed functions
+sequence = OrderedSet.sequence
+contains = OrderedSet.contains
+empty = OrderedSet.empty
+head = OrderedSet.head
+tail = OrderedSet.tail
+
+-- specific functions
+function priority(self, element)
+	return getpriorities(self)[element]
+end
+
+function enqueue(self, element, priority)
+	if not contains(self, element) then
+		local previous
+		if priority then
+			local priorities = getpriorities(self)
+			for elem, prev in sequence(self) do
+				local prio = priorities[elem]
+				if prio and prio > priority then
+					previous = prev
+					break
+				end
+			end
+			priorities[element] = priority
+		end
+		return OrderedSet.insert(self, element, previous)
+	end
+end
+
+function dequeue(self)
+	return removepriority(self, OrderedSet.dequeue(self))
+end
+
+function remove(self, element, previous)
+	return removepriority(self, OrderedSet.remove(self, element, previous))
+end

data/vendor/lua/lib/lua/loop/collection/UnorderedArray.lua

@@ -0,0 +1,32 @@
+--------------------------------------------------------------------------------
+---------------------- ##       #####    #####   ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##   ## -----------------------
+---------------------- ##      ##   ##  ##   ##  ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##      -----------------------
+---------------------- ######   #####    #####   ##      -----------------------
+----------------------                                   -----------------------
+----------------------- Lua Object-Oriented Programming ------------------------
+--------------------------------------------------------------------------------
+-- Project: LOOP Class Library                                                --
+-- Release: 2.3 beta                                                          --
+-- Title  : Array Optimized for Insertion/Removal that Doesn't Garantee Order --
+-- Author : Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+
+local table = require "table"
+local oo    = require "loop.base"
+
+module("loop.collection.UnorderedArray", oo.class)
+
+function add(self, value)
+	self[#self + 1] = value
+end
+
+function remove(self, index)
+	local size = #self
+	if index == size then
+		self[size] = nil
+	elseif (index > 0) and (index < size) then
+		self[index], self[size] = self[size], nil
+	end
+end

data/vendor/lua/lib/lua/loop/collection/UnorderedArraySet.lua

@@ -0,0 +1,56 @@
+--------------------------------------------------------------------------------
+---------------------- ##       #####    #####   ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##   ## -----------------------
+---------------------- ##      ##   ##  ##   ##  ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##      -----------------------
+---------------------- ######   #####    #####   ##      -----------------------
+----------------------                                   -----------------------
+----------------------- Lua Object-Oriented Programming ------------------------
+--------------------------------------------------------------------------------
+-- Project: LOOP Class Library                                                --
+-- Release: 2.3 beta                                                          --
+-- Title  : Unordered Array Optimized for Containment Check                   --
+-- Author : Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+-- Notes:                                                                     --
+--   Can only store non-numeric values.                                       --
+--   Storage of strings equal to the name of one method prevents its usage.   --
+--------------------------------------------------------------------------------
+
+local rawget = rawget
+local oo     = require "loop.base"
+
+module("loop.collection.UnorderedArraySet", oo.class)
+
+valueat = rawget
+indexof = rawget
+
+function contains(self, value)
+	return self[value] ~= nil
+end
+
+function add(self, value)
+	if self[value] == nil then
+		self[#self+1] = value
+		self[value] = #self
+		return value
+	end
+end
+
+function remove(self, value)
+	local index = self[value]
+	if index then
+		local size = #self
+		if index ~= size then
+			local last = self[size]
+			self[index], self[last] = last, index
+		end
+		self[value] = nil
+		self[size] = nil
+		return value
+	end
+end
+
+function removeat(self, index)
+	return self:remove(self[index])
+end

data/vendor/lua/lib/lua/loop/compiler/Arguments.lua

@@ -0,0 +1,108 @@
+--------------------------------------------------------------------------------
+---------------------- ##       #####    #####   ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##   ## -----------------------
+---------------------- ##      ##   ##  ##   ##  ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##      -----------------------
+---------------------- ######   #####    #####   ##      -----------------------
+----------------------                                   -----------------------
+----------------------- Lua Object-Oriented Programming ------------------------
+--------------------------------------------------------------------------------
+-- Project: LOOP Class Library                                                --
+-- Release: 2.3 beta                                                          --
+-- Title  : Command-line Argument Processor                                   --
+-- Author : Renato Maia <maia@inf.puc-rio.br>                                 --
+-- Date   : 2007-07-10                                                        --
+--------------------------------------------------------------------------------
+
+local select   = select
+local tonumber = tonumber
+local type     = type
+
+local oo = require "loop.base"
+
+module("loop.compiler.Arguments", oo.class)
+
+_badnumber = "invalid value for option '%s', number excepted but got '%s'"
+_missing = "no value defined for option '%s'"
+_unknown = "unknown option '%s'"
+_norepeat = "option '%s' was already defined"
+_optpat = "^%-(%w+)(=?)(.-)$"
+_boolean = {
+	["true"] = true,
+	["false"] = false,
+	yes = true,
+	no = false,
+}
+
+function __call(self, ...)
+	local errmsg
+	local defined = self._norepeat and {} or nil
+	local count = select("#", ...)
+	local pos = 1
+	while pos <= count do
+		local opt, set, val = select(pos, ...):match(self._optpat)
+		if not opt then break end
+		
+		-- apply option alias
+		local temp = self._alias
+		temp = temp and temp[opt]
+		opt = temp or opt
+		
+		-- check repeated definitions
+		local kind = type(self[opt])
+		if defined then
+			if not defined[opt] then
+				defined[opt] = true
+			elseif kind ~= "table" and kind ~= "function" then
+				pos, errmsg = nil, self._norepeat:format(opt)
+				break
+			end
+		end
+		
+		-- process option value
+		if kind == "boolean" then
+			if set == "" then -- option value was not set yet, get following argument
+				val = true
+			else
+				temp = self._boolean[val]
+				if temp ~= nil then val = temp end
+			end
+			self[opt] = val
+		elseif kind ~= "nil" or not self._unknown then
+			if set == "" then -- option value was not set yet, get following argument
+				pos = pos + 1
+				if pos <= count then
+					val = select(pos, ...)
+				else
+					pos, errmsg = nil, self._missing:format(opt)
+					break
+				end
+			end
+			
+			if kind == "number" then
+				local number = tonumber(val)
+				if number == nil then
+					pos, errmsg = nil, self._badnumber:format(opt, val)
+					break
+				end
+				self[opt] = number
+			elseif kind == "function" then
+				errmsg = self[opt](self, opt, val)
+				if errmsg then
+					pos = nil
+					break
+				end
+			elseif kind == "table" then
+				local list = self[opt]
+				list[#list+1] = val
+			else
+				self[opt] = val
+			end
+		else
+			pos, errmsg = nil, self._unknown:format(opt)
+			break
+		end
+		pos = pos + 1
+	end
+	return pos, errmsg
+end