rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/oil/kernel/base/Sockets.lua

@@ -0,0 +1,44 @@
+--------------------------------------------------------------------------------
+------------------------------  #####      ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------ ##   ## ##  ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------  #####  ### ###### ------------------------------
+--------------------------------                --------------------------------
+----------------------- An Object Request Broker in Lua ------------------------
+--------------------------------------------------------------------------------
+-- Project: OiL - ORB in Lua: An Object Request Broker in Lua                 --
+-- Release: 0.5                                                               --
+-- Title  : Socket API Wrapper                                                --
+-- Authors: Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+
+local luapcall = pcall
+
+local socket = require "socket.core"
+
+local oo = require "oil.oo"
+
+module("oil.kernel.base.Sockets", oo.class)
+
+pcall = luapcall
+
+function __index(self, field)
+	return _M[field] or socket[field]
+end
+
+function select(self, recvt, sendt, timeout)
+	return socket.select(recvt, sendt, timeout)
+end
+
+function sleep(self, timeout)
+	return socket.sleep(timeout)
+end
+
+function tcp(self)
+	return socket.tcp()
+end
+
+function udp(self)
+	return socket.udp()
+end

data/vendor/lua/lib/lua/oil/kernel/cooperative/Receiver.lua

@@ -0,0 +1,139 @@
+--------------------------------------------------------------------------------
+------------------------------  #####      ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------ ##   ## ##  ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------  #####  ### ###### ------------------------------
+--------------------------------                --------------------------------
+----------------------- An Object Request Broker in Lua ------------------------
+--------------------------------------------------------------------------------
+-- Project: OiL - ORB in Lua: An Object Request Broker in Lua                 --
+-- Release: 0.5                                                               --
+-- Title  : Request Acceptor                                                  --
+-- Authors: Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+-- acceptor:Facet
+-- 	configs:table, [except:table] setupaccess([configs:table])
+-- 	success:boolean, [except:table] hasrequest(configs:table)
+-- 	success:boolean, [except:table] acceptone(configs:table)
+-- 	success:boolean, [except:table] acceptall(configs:table)
+-- 	success:boolean, [except:table] halt(configs:table)
+-- 
+-- listener:Receptacle
+-- 	configs:table default([configs:table])
+-- 	channel:object, [except:table] getchannel(configs:table)
+-- 	success:boolean, [except:table] freeaccess(configs:table)
+-- 	success:boolean, [except:table] freechannel(channel:object)
+-- 	request:table, [except:table] = getrequest(channel:object, [probe:boolean])
+-- 	success:booelan, [except:table] = sendreply(request:table, success:booelan, results...)
+-- 
+-- dispatcher:Receptacle
+-- 	success:boolean, [except:table]|results... dispatch(objectkey:string, operation:string|function, params...)
+-- 
+-- tasks:Receptacle
+-- 	current:thread
+-- 	start(func:function, args...)
+-- 	remove(thread:thread)
+--------------------------------------------------------------------------------
+
+local next  = next
+local pairs = pairs
+
+local oo        = require "oil.oo"
+local Exception = require "oil.Exception"
+local Receiver  = require "oil.kernel.base.Receiver"                            --[[VERBOSE]] local verbose = require "oil.verbose"
+
+module "oil.kernel.cooperative.Receiver"
+
+oo.class(_M, Receiver)
+
+--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
+
+function __init(self, object)
+	self = oo.rawnew(self, object)
+	self.thread = {}
+	self.threads = {}
+	return self
+end
+
+--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
+
+function processrequest(self, request)
+	local result, except = Receiver.processrequest(self, request)
+	if not result and not self.except then
+		self.except = except
+	end
+	return result, except
+end
+
+function getallrequests(self, accesspoint, channel)
+	local listener = self.listener
+	local thread = self.tasks.current
+	local threads = self.threads[accesspoint]
+	threads[thread] = channel
+	local result, except
+	repeat
+		result, except = listener:getrequest(channel)
+		if result then
+			if result == true then
+				break
+			else
+				self.tasks:start(self.processrequest, self, result)
+			end
+		elseif not self.except then
+			self.except = except
+			break
+		end
+	until self.except
+	if (result and result ~= true)
+	or (not result and except.reason ~= "closed") then
+		listener:putchannel(channel)
+	end
+	threads[thread] = nil
+end
+
+--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
+
+function acceptall(self)
+	local accesspoint = self.accesspoint                                          --[[VERBOSE]] verbose:acceptor(true, "accept all requests from channel ",accesspoint)
+	self.thread[accesspoint] = self.tasks.current
+	self.threads[accesspoint] = {}
+	local result, except
+	repeat
+		result, except = self.listener:getchannel(accesspoint)
+		if result then
+			self.tasks:start(self.getallrequests, self, accesspoint, result)
+		end
+	until not result or self.except
+	self.threads[accesspoint] = nil
+	self.thread[accesspoint] = nil                                                --[[VERBOSE]] verbose:acceptor(false)
+	return nil, self.except or except
+end
+
+function halt(self)                                                             --[[VERBOSE]] verbose:acceptor("halt acceptor",accesspoint)
+	local accesspoint = self.accesspoint
+	local tasks = self.tasks
+	local listener = self.listener
+	local result, except = nil, Exception{
+		reason = "halted",
+		message = "orb already halted",
+	}
+	local thread = self.thread[accesspoint]
+	if thread then
+		tasks:remove(thread)
+		result, except = listener:freeaccess(accesspoint)
+		self.thread[accesspoint] = nil
+	end
+	local threads = self.threads[accesspoint]
+	if threads then
+		for thread, channel in pairs(threads) do
+			tasks:remove(thread)
+			result, except = listener:freechannel(channel)
+		end
+		self.threads[accesspoint] = nil
+	end
+	return result, except
+end

data/vendor/lua/lib/lua/oil/kernel/intercepted/Listener.lua

@@ -0,0 +1,47 @@
+
+local unpack = unpack
+
+local Wrapper = require "loop.object.Wrapper"
+
+local oo = require "oil.oo"                                                     --[[VERBOSE]] local verbose = require "oil.verbose"
+
+module("oil.kernel.intercepted.Listener", oo.class)
+
+__init = Wrapper.__init
+__index = Wrapper.__index
+
+function getrequest(self, channel, probe)
+	local result, except = self.__object:getrequest(channel, probe)
+	if result then                                                                --[[VERBOSE]] verbose:interceptors(true, "intercepting request being sent")
+		local request = {
+			target    = result.objectkey,
+			operation = result.operation,
+			n         = result.n,
+			unpack(result, 1, result.n),
+		}
+		local interceptor = self.interceptor
+		if interceptor.getrequest then
+			interceptor:getrequest(request)                                           --[[VERBOSE]] verbose:interceptors(false, "interception ended")
+			if request.success ~= nil then                                            --[[VERBOSE]] verbose:interceptors("interception canceled request")
+				result, except = self.__object:sendreply(request)
+				if result then
+					return self:getrequest(channel, probe)
+				end
+			end
+		end
+		result[self] = request
+	end
+	return result, except
+end
+
+function sendreply(self, reply)
+	local request = reply[self]
+	if request then
+		replt[self] = nil
+		local interceptor = self.interceptor
+		if interceptor.sendreply then                                               --[[VERBOSE]] verbose:interceptors(true, "intercepting received reply")
+			interceptor:sendreply(reply, request)                                     --[[VERBOSE]] verbose:interceptors(false, "interception ended")
+		end
+	end
+	return self.__object:sendreply(reply)
+end

data/vendor/lua/lib/lua/oil/kernel/intercepted/Requester.lua

@@ -0,0 +1,58 @@
+
+local select = select
+local unpack = unpack
+
+local Wrapper = require "loop.object.Wrapper"
+
+local oo = require "oil.oo"                                                     --[[VERBOSE]] local verbose = require "oil.verbose"
+
+module("oil.kernel.intercepted.Requester", oo.class)
+
+__init = Wrapper.__init
+__index = Wrapper.__index
+
+function newrequest(self, reference, operation, ...)
+	local request = {
+		reference = reference,
+		operation = operation,
+		n = select("#", ...),
+		...,
+	}
+	local result, except
+	local interceptor = self.interceptor
+	if interceptor.newrequest then                                                --[[VERBOSE]] verbose:interceptors(true, "intercepting request being sent")
+		interceptor:newrequest(request)                                             --[[VERBOSE]] verbose:interceptors(false, "interception ended")
+		if request.success ~= nil then                                              --[[VERBOSE]] verbose:interceptors("interception canceled request")
+			result, except = request, nil
+		else
+			result, except = self.__object:newrequest(request.reference,
+			                                          request.operation,
+			                                          unpack(request, 1, request.n))
+		end
+	else
+		result, except = self.__object:newrequest(reference, operation, ...)
+	end
+	if not result then
+		request.success = false
+		request.n = 1
+		request[1] = except
+		result, except = request, nil
+	end
+	result[self] = request
+	return result, except
+end
+
+function getreply(self, opreq)
+	local result, except = self.__object:getreply(opreq)
+	if result then
+		local interceptor = self.interceptor
+		local request = opreq[self]
+		if request then
+			opreq[self] = nil
+			if interceptor.getreply then                                              --[[VERBOSE]] verbose:interceptors(true, "intercepting received reply")
+				interceptor:getreply(request, opreq)                                    --[[VERBOSE]] verbose:interceptors(false, "interception ended")
+			end
+		end
+	end
+	return result, except
+end

data/vendor/lua/lib/lua/oil/kernel/lua/Dispatcher.lua

@@ -0,0 +1,76 @@
+--------------------------------------------------------------------------------
+------------------------------  #####      ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------ ##   ## ##  ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------  #####  ### ###### ------------------------------
+--------------------------------                --------------------------------
+----------------------- An Object Request Broker in Lua ------------------------
+--------------------------------------------------------------------------------
+-- Project: OiL - ORB in Lua: An Object Request Broker in Lua                 --
+-- Release: 0.5                                                               --
+-- Title  : Object Request Dispatcher                                         --
+-- Authors: Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+-- dispatcher:Facet
+-- 	success:boolean, [except:table]|results... dispatch(key:string, operation:string|function, params...)
+--------------------------------------------------------------------------------
+
+local unpack       = unpack
+
+local oo          = require "oil.oo"
+local Exception   = require "oil.Exception"
+local Dispatcher  = require "oil.kernel.base.Dispatcher"                        --[[VERBOSE]] local verbose = require "oil.verbose"
+
+module "oil.kernel.lua.Dispatcher"
+
+oo.class(_M, Dispatcher)
+
+--------------------------------------------------------------------------------
+
+local Operations = {
+	tostring = function(self)               return tostring(self) end,
+	unm      = function(self)               return -self end,
+	len      = function(self)               return #self end,
+	add      = function(self, other)        return self + other end,
+	sub      = function(self, other)        return self - other end,
+	mul      = function(self, other)        return self * other end,
+	div      = function(self, other)        return self / other end,
+	mod      = function(self, other)        return self % other end,
+	pow      = function(self, other)        return self ^ other end,
+	lt       = function(self, other)        return self < other end,
+	eq       = function(self, other)        return self == other end,
+	le       = function(self, other)        return self <= other end,
+	concat   = function(self, other)        return self .. other end,
+	call     = function(self, ...)          return self(...) end,
+	index    = function(self, field)        return self[field] end,
+	newindex = function(self, field, value) self[field] = value end,
+}
+
+--------------------------------------------------------------------------------
+
+function dispatch(self, request)
+	local object = self.servants:retrieve(request.objectkey)
+	if object then
+		local method = Operations[request.operation]
+		if method then                                                              --[[VERBOSE]] verbose:dispatcher("dispatching operation ",object,":",request.operation,unpack(request, 1, request.n))
+			self:setresults(request, self.pcall(method, object,
+			                                    unpack(request, 1, request.n)))
+		else
+			self:setresults(request, false, Exception{
+				reason = "noimplement",
+				message = "no implementation for operation of object with key",
+				operation = operation,
+				object = object,
+				key = key,
+			})
+		end
+	else
+		self:setresults(request, false, Exception{
+			reason = "badkey",
+			message = "no object with key",
+			key = key,
+		})
+	end
+	return true
+end

data/vendor/lua/lib/lua/oil/kernel/lua/Proxies.lua

@@ -0,0 +1,69 @@
+--------------------------------------------------------------------------------
+------------------------------  #####      ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------ ##   ## ##  ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------  #####  ### ###### ------------------------------
+--------------------------------                --------------------------------
+----------------------- An Object Request Broker in Lua ------------------------
+--------------------------------------------------------------------------------
+-- Project: OiL - ORB in Lua: An Object Request Broker in Lua                 --
+-- Release: 0.5                                                               --
+-- Title  : Remote Object Proxies                                             --
+-- Authors: Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+-- proxies:Facet
+-- 	proxy:object proxyto(reference:table)
+--
+-- invoker:Receptacle
+-- 	[results:object], [except:table] invoke(reference, operation, args...)
+--------------------------------------------------------------------------------
+
+local ipairs = ipairs
+
+local oo      = require "oil.oo"
+local Proxies = require "oil.kernel.base.Proxies"                               --[[VERBOSE]] local verbose = require "oil.verbose"
+local utils   = require "oil.kernel.base.Proxies.utils"
+
+module "oil.kernel.lua.Proxies"
+
+oo.class(_M, Proxies)
+
+local assertresults = utils.assertresults
+local unpackrequest = utils.unpackrequest
+local callhandler   = utils.callhandler
+
+class = oo.class()
+for _, field in ipairs{
+	"tostring",
+	"unm",
+	"len",
+	"add",
+	"sub",
+	"mul",
+	"div",
+	"mod",
+	"pow",
+	"eq",
+	"lt",
+	"le",
+	"concat",
+	"call",
+	"index",
+	"newindex",
+} do
+	class["__"..field] = function(self, ...)                                      --[[VERBOSE]] verbose:proxies("call to ",field," ", ...)
+		local requester = self.__manager.requester
+		local success, except = requester:newrequest(self.__reference, field, ...)
+		if success then
+			local request = success
+			success, except = requester:getreply(request)
+			if success then
+				return assertresults(self, operation, unpackrequest(request))
+			end
+		end
+		if not success then
+			return callhandler(self, except, operation)
+		end
+	end
+end

data/vendor/lua/lib/lua/oil/kernel/typed/Dispatcher.lua

@@ -0,0 +1,91 @@
+--------------------------------------------------------------------------------
+------------------------------  #####      ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------ ##   ## ##  ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------  #####  ### ###### ------------------------------
+--------------------------------                --------------------------------
+----------------------- An Object Request Broker in Lua ------------------------
+--------------------------------------------------------------------------------
+-- Project: OiL - ORB in Lua: An Object Request Broker in Lua                 --
+-- Release: 0.5                                                               --
+-- Title  : Object Request Dispatcher                                         --
+-- Authors: Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+-- dispatcher:Facet
+-- 	success:boolean, [except:table]|results... dispatch(objectkey:string, operation:string|function, params...)
+-- 
+-- indexer:Receptacle
+-- 	[member:string], [implementation:function] valueof(objectkey:string, operation:string)
+--------------------------------------------------------------------------------
+
+local unpack = unpack
+
+local oo         = require "oil.oo"
+local Exception  = require "oil.Exception"
+local Dispatcher = require "oil.kernel.base.Dispatcher"                         --[[VERBOSE]] local verbose = require "oil.verbose"
+
+module "oil.kernel.typed.Dispatcher"
+
+oo.class(_M, Dispatcher)
+
+context = false
+
+--------------------------------------------------------------------------------
+-- Dispatcher facet
+
+function dispatch(self, request)
+	local context = self.context
+	local servants = context.servants
+	local key = request.object_key
+	local opname = request.operation
+	local opinfo
+	local object, type = servants:retrieve(key)
+	if object == nil then                                                         --[[VERBOSE]] verbose:dispatcher("got illegal object ",key)
+		request:results(false, Exception{
+			reason = "badkey",
+			message = "no object with key",
+			key = key,
+		})
+	else
+		opinfo = context.indexer:valueof(type, opname)
+		if opinfo == nil then                                                         --[[VERBOSE]] verbose:dispatcher("got illegal operation ",opname)
+			request:results(false, Exception{
+				reason = "badoperation",
+				message = "operation is illegal for object with key",
+				operation = opname,
+				object = object,
+				type = type,
+				key = key,
+			})
+		end
+	end
+	key, opname = request:preinvoke(type, opinfo, object)
+	if key == nil then                                                            --[[VERBOSE]] verbose:dispatcher("pre-invocation failed!")
+		return -- cancel dispatch
+	end
+	if key ~= request.objectkey then
+		object = servants:retrieve(key)
+		if object == nil then                                                       --[[VERBOSE]] verbose:dispatcher("got illegal object ",key)
+			request:results(false, Exception{
+				reason = "badkey",
+				message = "no object with key",
+				key = key,
+			})
+			return -- cancel dispatch
+		end
+	end
+	local method = object[opname] or opinfo.implementation
+	if method == nil then                                                         --[[VERBOSE]] verbose:dispatcher("missing implementation of ",opname)
+		return request:results(false, Exception{
+			reason = "noimplement",
+			message = "no implementation for operation of object with key",
+			operationdescription = opinfo,
+			operation = opname,
+			object = object,
+			type = type,
+			key = key,
+		})
+	end                                                                           --[[VERBOSE]] verbose:dispatcher("dispatching operation ",key,":",opname,request:params())
+	request:results(self.pcall(method, object, request:params()))
+end