rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/loop/serial/FileStream.lua

@@ -0,0 +1,48 @@
+--------------------------------------------------------------------------------
+---------------------- ##       #####    #####   ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##   ## -----------------------
+---------------------- ##      ##   ##  ##   ##  ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##      -----------------------
+---------------------- ######   #####    #####   ##      -----------------------
+----------------------                                   -----------------------
+----------------------- Lua Object-Oriented Programming ------------------------
+--------------------------------------------------------------------------------
+-- Project: LOOP Class Library                                                --
+-- Release: 2.3 beta                                                          --
+-- Title  : Stream that Serializes and Restores Values from Files             --
+-- Author : Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+
+local assert = assert
+local table = require "table"
+local oo = require "loop.simple"
+local Serializer = require "loop.serial.Serializer"
+
+module"loop.serial.FileStream"
+
+oo.class(_M, Serializer)
+
+buffersize = 1024
+
+function write(self, ...)
+	self.file:write(...)
+end
+
+function put(self, ...)
+	self:serialize(...)
+	self.file:write("\0")
+end
+
+function get(self)
+	local lines = {}
+	local line
+	repeat
+		line = self.remains or self.file:read(self.buffersize)
+		self.remains = nil
+		if line and line:find("%z") then
+			line, self.remains = line:match("^([^%z]*)%z(.*)$")
+		end
+		lines[#lines+1] = line
+	until not line or self.remains
+	return assert(self:load("return "..table.concat(lines)))()
+end

data/vendor/lua/lib/lua/loop/serial/Serializer.lua

@@ -0,0 +1,291 @@
+--------------------------------------------------------------------------------
+---------------------- ##       #####    #####   ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##   ## -----------------------
+---------------------- ##      ##   ##  ##   ##  ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##      -----------------------
+---------------------- ######   #####    #####   ##      -----------------------
+----------------------                                   -----------------------
+----------------------- Lua Object-Oriented Programming ------------------------
+--------------------------------------------------------------------------------
+-- Project: LOOP Class Library                                                --
+-- Release: 2.3 beta                                                          --
+-- Title  : Serializer that Serialize Values to Lua Code                      --
+-- Author : Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+
+local _G = _G
+local getmetatable = getmetatable
+local setmetatable = setmetatable
+local getfenv = getfenv
+local setfenv = setfenv
+local package = package
+local assert = assert
+local select = select
+local pairs = pairs
+local pcall = pcall
+local ipairs = ipairs
+local loadstring = loadstring
+local rawget = rawget
+local rawset = rawset
+local require = require
+local tostring = tostring
+local tonumber = tonumber
+local error = error
+local type = type
+
+local debug = debug
+local string = require "string"
+local table = require "loop.table"
+local oo = require "loop.base"
+
+module("loop.serial.Serializer", oo.class)
+
+__mode = "k"
+
+namespace = "serial"
+
+------------------------------------------------------------------------------
+_M.globals = _G
+_M.require = require
+_M.getmetatable = getmetatable
+_M.setmetatable = setmetatable
+_M.getfenv = getfenv
+_M.setfenv = setfenv
+_M.getupvalue = debug and debug.getupvalue
+_M.setupvalue = debug and debug.setupvalue
+_M.package = package and package.loaded
+------------------------------------------------------------------------------
+Environment = oo.class{ __index = _G }
+
+function addmembers(self, pack)
+	if type(pack) == "table" then
+		for field, member in pairs(pack) do
+			local kind = type(member)
+			if
+				self[member] == nil and
+				kind ~= "boolean" and kind ~= "number" and kind ~= "string" and
+				type(field) == "string" and field:match("^[%a_]+[%w_]*$")
+			then
+				self[member] = self[pack].."."..field
+			end
+		end
+	end
+end
+
+function __init(self, object)
+	self = oo.rawnew(self, object)
+	self.environment = self.environment or Environment()
+	self.environment[self.namespace] = self
+	if self.globals then
+		self[self.globals] = self.namespace..".globals"
+		for field, member in pairs(self.globals) do
+			if
+				self[member] == nil and
+				type(field) == "string" and field:match("^[%a_]+[%w_]*$") and
+				type(member) == "function" and not pcall(string.dump, member)
+			then
+				self[member] = self.namespace..".globals."..field
+			end
+		end
+	end
+	if self.package then
+		for name, pack in pairs(self.package) do
+			if self[pack] == nil then
+				self[pack] = self.namespace..'.require("'..name..'")'
+				self:addmembers(pack)
+			end
+		end
+	end
+	return self
+end
+
+------------------------------------------------------------------------------
+local Incomplete = oo.class()
+
+function Incomplete:__load(contents, metatable)
+	table.copy(contents, self)
+	return setmetatable(self, metatable)
+end
+
+function value(self, id, type, ...)
+	local value = self[id]
+	if not value then
+		if type == "function" then
+			value = assert(loadstring((...)))
+		elseif type == "userdata" then
+			value = assert(self[...], "unknown userdata")()
+		elseif type == "table" then
+			local meta
+			value, meta = ...
+			if meta and self.setmetatable then
+				self.setmetatable(value, meta)
+			end
+		else
+			value = Incomplete()
+		end
+		self[id] = value
+	elseif type == "table" and oo.classof(value) == Incomplete then
+		value:__load(...)
+	end
+	return value
+end
+
+function setup(self, value, ...)
+	local type = type(value)
+	if type == "function" then
+		if self.setfenv then self.setfenv(value, ... or self.globals) end
+		local setupvalue = self.setupvalue
+		if setupvalue then
+			local up = 1
+			while setupvalue(value, up, select(up+1, ...) or nil) do
+				up = up + 1
+			end
+		end
+	else
+		local loader = getmetatable(value)
+		if loader then loader = loader.__load end
+		if loader then loader(value, ...) end
+	end
+	return value
+end
+
+function load(self, data)
+	local errmsg
+	data, errmsg = loadstring(data)
+	if data then setfenv(data, self.environment) end
+	return data, errmsg
+end
+------------------------------------------------------------------------------
+function serialstring(self, string)
+	self:write(string.format("%q", string))
+end
+
+function serialtable(self, table, id)
+	self[table] = self.namespace..":value("..id..")"
+	
+	-- serialize contents
+	self:write(self.namespace,":value(",id,",'table',{")
+	for key, val in pairs(table) do
+		self:write("[")
+		self:serialize(key)
+		self:write("]=")
+		self:serialize(val)
+		self:write(",")
+	end
+	self:write("}")
+
+	-- serialize metatable
+	if self.getmetatable then
+		local meta = self.getmetatable(table)
+		if meta then
+			self:write(",")
+			self:serialize(meta)
+		end
+	end
+	
+	self:write(")")
+end
+
+function serialfunction(self, func, id)
+	self[func] = self.namespace..":value("..id..")"
+	self:write(self.namespace,":setup(")
+	
+	-- serialize bytecodes
+	self:write(self.namespace,":value(",id,",'function','")
+	local bytecodes = string.dump(func)
+	for i = 1, #bytecodes do
+		self:write("\\",string.byte(bytecodes, i))
+	end
+	self:write("')")
+
+	-- serialize environment
+	local env
+	if self.getfenv then
+		env = self.getfenv(func)
+		if env == self.globals then env = nil end
+	end
+	self:write(",")
+	self:serialize(env)
+
+	-- serialize upvalues
+	if self.getupvalue then
+		local name, value
+		local up = 1
+		repeat
+			name, value = self.getupvalue(func, up)
+			if name then
+				self:write(",")
+				self:serialize(value)
+			end
+			up = up + 1
+		until not name
+	end
+	
+	self:write(")")
+end
+
+function serialcustom(self, id, name, ...)
+	local state = select("#", ...) > 0
+	if state then
+		self:write(self.namespace,":setup(")
+	end
+	self:write(self.namespace,":value(",id,",'userdata','",name,"')")
+	if state then
+		self:write(",")
+		self:serialize(...)
+		self:write(")")
+	end
+end
+
+function serialuserdata(self, userdata, id)
+	local serializer = getmetatable(userdata)
+	if serializer then
+		serializer = serializer.__serialize
+		if serializer then
+			self[userdata] = self.namespace..":value("..id..")"
+			return self:serialcustom(id, serializer(userdata))
+		end
+	end
+	error("unable to serialize a userdata without custom serialization")
+end
+
+local function getidfor(value)
+	local meta = getmetatable(value)
+	local backup
+	if meta then
+		backup = rawget(meta, "__tostring")
+		if backup ~= nil then rawset(meta, "__tostring", nil) end
+	end
+	local id = string.match(tostring(value), "%l+: (%w+)")
+	if meta then
+		if backup ~= nil then rawset(meta, "__tostring", backup) end
+	end
+	return tonumber(id, 16) or id
+end
+
+function serialize(self, ...)
+	for i=1, select("#", ...) do
+		if i ~= 1 then self:write(",") end
+		local value = select(i, ...)
+		local type = type(value)
+		if type == "nil" or type == "boolean" or type == "number" then
+			self:write(tostring(value))
+		elseif type == "string" then
+			self:serialstring(value)
+		else
+			local id = self[value]
+			if id then
+				self:write(id)
+			elseif self[type] then
+				self[type](self, value, getidfor(value))
+			else
+				error("unable to serialize a "..type)
+			end
+		end
+	end
+end
+
+_M["table"]    = serialtable
+_M["function"] = serialfunction
+_M["userdata"] = serialuserdata
+_M["thread"]   = serialthread

data/vendor/lua/lib/lua/loop/serial/SocketStream.lua

@@ -0,0 +1,51 @@
+--------------------------------------------------------------------------------
+---------------------- ##       #####    #####   ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##   ## -----------------------
+---------------------- ##      ##   ##  ##   ##  ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##      -----------------------
+---------------------- ######   #####    #####   ##      -----------------------
+----------------------                                   -----------------------
+----------------------- Lua Object-Oriented Programming ------------------------
+--------------------------------------------------------------------------------
+-- Project: LOOP Class Library                                                --
+-- Release: 2.3 beta                                                          --
+-- Title  : Stream that Serializes and Restores Values from Sockets           --
+-- Author : Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+
+local assert = assert
+local select = select
+local table = require "table"
+local oo = require "loop.simple"
+local Serializer = require "loop.serial.Serializer"
+
+module"loop.serial.SocketStream"
+
+oo.class(_M, Serializer)
+
+function write(self, ...)
+	for i=1, select("#", ...) do
+		self.buffer[#self.buffer+1] = select(i, ...)
+	end
+end
+
+function put(self, ...)
+	self.buffer = {}
+	self:serialize(...)
+	assert(self.socket:send(table.concat(self.buffer).."\0\n"))
+	self.buffer = nil
+end
+
+function get(self)
+	local lines = {}
+	local line
+	repeat
+		line = assert(self.socket:receive())
+		if line and line:find("%z$") then
+			lines[#lines+1] = line:sub(1, #line-1)
+			break
+		end
+		lines[#lines+1] = line
+	until not line
+	return assert(self:load("return "..table.concat(lines, "\n")))()
+end

data/vendor/lua/lib/lua/loop/serial/StringStream.lua

@@ -0,0 +1,47 @@
+--------------------------------------------------------------------------------
+---------------------- ##       #####    #####   ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##   ## -----------------------
+---------------------- ##      ##   ##  ##   ##  ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##      -----------------------
+---------------------- ######   #####    #####   ##      -----------------------
+----------------------                                   -----------------------
+----------------------- Lua Object-Oriented Programming ------------------------
+--------------------------------------------------------------------------------
+-- Project: LOOP Class Library                                                --
+-- Release: 2.3 beta                                                          --
+-- Title  : Stream that Serializes and Restores Values from Strings           --
+-- Author : Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+
+local assert = assert
+local select = select
+local table = require "table"
+local oo = require "loop.simple"
+local Serializer = require "loop.serial.Serializer"
+
+module"loop.serial.StringStream"
+
+oo.class(_M, Serializer)
+
+pos = 1
+
+__tostring = table.concat
+
+function write(self, ...)
+	for i=1, select("#", ...) do
+		self[#self+1] = select(i, ...)
+	end
+end
+
+function put(self, ...)
+	if #self > 0 then self[#self+1] = "\0" end
+	self:serialize(...)
+end
+
+function get(self)
+	local code = self.data or self:__tostring()
+	local newpos = code:find("%z", self.pos) or #code + 1
+	code = code:sub(self.pos, newpos - 1)
+	self.pos = newpos + 1
+	return assert(self:load("return "..code))()
+end

data/vendor/lua/lib/lua/loop/simple.lua

@@ -0,0 +1,75 @@
+--------------------------------------------------------------------------------
+---------------------- ##       #####    #####   ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##   ## -----------------------
+---------------------- ##      ##   ##  ##   ##  ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##      -----------------------
+---------------------- ######   #####    #####   ##      -----------------------
+----------------------                                   -----------------------
+----------------------- Lua Object-Oriented Programming ------------------------
+--------------------------------------------------------------------------------
+-- Project: LOOP - Lua Object-Oriented Programming                            --
+-- Release: 2.3 beta                                                          --
+-- Title  : Simple Inheritance Class Model                                    --
+-- Author : Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+-- Exported API:                                                              --
+--   class(class, super)                                                      --
+--   new(class, ...)                                                          --
+--   classof(object)                                                          --
+--   isclass(class)                                                           --
+--   instanceof(object, class)                                                --
+--   memberof(class, name)                                                    --
+--   members(class)                                                           --
+--   superclass(class)                                                        --
+--   subclassof(class, super)                                                 --
+--------------------------------------------------------------------------------
+
+local require = require
+local rawget  = rawget
+local pairs   = pairs
+
+local table = require "loop.table"
+
+module "loop.simple"
+--------------------------------------------------------------------------------
+local ObjectCache = require "loop.collection.ObjectCache"
+local base        = require "loop.base"
+--------------------------------------------------------------------------------
+table.copy(base, _M)
+--------------------------------------------------------------------------------
+local DerivedClass = ObjectCache {
+	retrieve = function(self, super)
+		return base.class { __index = super, __call = new }
+	end,
+}
+function class(class, super)
+	if super
+		then return DerivedClass[super](initclass(class))
+		else return base.class(class)
+	end
+end
+--------------------------------------------------------------------------------
+function isclass(class)
+	local metaclass = classof(class)
+	if metaclass then
+		return metaclass == rawget(DerivedClass, metaclass.__index) or
+		       base.isclass(class)
+	end
+end
+--------------------------------------------------------------------------------
+function superclass(class)
+	local metaclass = classof(class)
+	if metaclass then return metaclass.__index end
+end
+--------------------------------------------------------------------------------
+function subclassof(class, super)
+	while class do
+		if class == super then return true end
+		class = superclass(class)
+	end
+	return false
+end
+--------------------------------------------------------------------------------
+function instanceof(object, class)
+	return subclassof(classof(object), class)
+end