rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/oil/ludo/Listener.lua

@@ -0,0 +1,151 @@
+--------------------------------------------------------------------------------
+------------------------------  #####      ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------ ##   ## ##  ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------  #####  ### ###### ------------------------------
+--------------------------------                --------------------------------
+----------------------- An Object Request Broker in Lua ------------------------
+--------------------------------------------------------------------------------
+-- Project: OiL - ORB in Lua                                                  --
+-- Release: 0.5                                                               --
+-- Title  : Server-side LuDO Protocol                                         --
+-- Authors: Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+-- listener:Facet
+-- 	configs:table default([configs:table])
+-- 	channel:object, [except:table] getchannel(configs:table)
+-- 	request:object, [except:table], [requests:table] = getrequest(channel:object, [probe:boolean])
+-- 
+-- channels:Receptacle
+-- 	channel:object retieve(configs:table)
+-- 	configs:table default([configs:table])
+-- 
+-- codec:Receptacle
+-- 	encoder:object encoder()
+-- 	decoder:object decoder(stream:string)
+--------------------------------------------------------------------------------
+
+local select = select
+local tonumber = tonumber
+local unpack = unpack
+
+local oo        = require "oil.oo"
+local Exception = require "oil.Exception"                                       --[[VERBOSE]] local verbose = require "oil.verbose"
+
+module("oil.ludo.Listener", oo.class)
+
+oo.class(_M, Messenger)
+
+--------------------------------------------------------------------------------
+
+function setupaccess(self, configs)
+	return self.channels:default(configs)
+end
+
+function freeaccess(self, accesspoint)                                          --[[VERBOSE]] verbose:listen("closing all channels with configs ",accesspoint)
+	return self.channels:dispose(accesspoint)
+end
+
+--------------------------------------------------------------------------------
+
+function getchannel(self, accesspoint, probe)
+	return self.channels:retrieve(accesspoint, probe)
+end
+
+function putchannel(self, channel)                                              --[[VERBOSE]] verbose:listen "put channel back"
+	return channel:release()
+end
+
+function freechannel(self, channel)                                             --[[VERBOSE]] verbose:listen "close channel"
+	return channel:close()
+end
+
+--------------------------------------------------------------------------------
+
+Request = oo.class{ n = 0 }
+
+function Request:preinvoke()
+	return self.objectkey, self.operation
+end
+
+function Request:params()
+	return unpack(self, 1, self.n)
+end
+
+function Request:results(success, ...)
+	local count = select("#", ...)
+	self.success = success
+	self.n = count
+	for i = 1, count do
+		self[i] = select(i, ...)
+	end
+end
+
+--------------------------------------------------------------------------------
+
+function newrequest(self, requestid, objectkey, operation, ...)                 --[[VERBOSE]] verbose:listen("got request for request ",requestid," to object ",objectkey,":",operation)
+	return Request{
+		requestid = requestid,
+		objectkey = objectkey,
+		operation = operation,
+		n = select("#", ...),
+		...,
+	}
+end
+
+function getrequest(self, channel, probe)
+	local result, except = true
+	if channel:trylock("read", not probe) then
+		if not probe or channel:probe() then
+			result, except = channel:receive()
+			if result then
+				result = tonumber(result)
+				if result then
+					result, except = channel:receive(result)
+					if result then
+						local decoder = self.codec:decoder(result)
+						result = self:newrequest(decoder:get())
+						result.channel = channel
+						channel[result.requestid] = result
+					end
+				else
+					except = "LuDO protocol: invalid message size"
+				end
+			else
+				if except == "closed" then                                              --[[VERBOSE]] verbose:listen("client closed the connection")
+					channel:close()
+					result, except = true, nil
+				else
+					except = "LuDO protocol: socket error "..except
+				end
+			end
+		end
+		channel:freelock("read")
+	end
+	return result, except
+end
+
+--------------------------------------------------------------------------------
+
+local MessageFmt = "%d\n%s"
+
+function sendreply(self, request)                                               --[[VERBOSE]] verbose:listen("got reply for request ",request.requestid," to object ",request.objectkey,":",request.operation)
+	local channel = request.channel
+	local encoder = self.codec:encoder()
+	encoder:put(request.requestid, request.success, unpack(request, 1, request.n))
+	channel[request.requestid] = nil
+	local data = encoder:__tostring()
+	channel:trylock("write", true)
+	local result, except = channel:send(MessageFmt:format(#data, data))
+	channel:freelock("write")
+	if not result then
+		if except == "closed" then                                                  --[[VERBOSE]] verbose:listen("client closed the connection")
+			channel:close()
+			result, except = true, nil
+		else
+			except = "LuDO protocol: socket error "..except
+		end
+	end
+	return result, except
+end

data/vendor/lua/lib/lua/oil/ludo/Referrer.lua

@@ -0,0 +1,72 @@
+--------------------------------------------------------------------------------
+------------------------------  #####      ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------ ##   ## ##  ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------  #####  ### ###### ------------------------------
+--------------------------------                --------------------------------
+----------------------- An Object Request Broker in Lua ------------------------
+--------------------------------------------------------------------------------
+-- Project: OiL - ORB in Lua                                                  --
+-- Release: 0.5                                                               --
+-- Title  : Client-side CORBA GIOP Protocol specific to IIOP                  --
+-- Authors: Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+-- references:Facet
+-- 	reference:table newreference(objectkey:string, accesspointinfo:table...)
+-- 	reference:string encode(reference:table)
+-- 	reference:table decode(reference:string)
+--------------------------------------------------------------------------------
+
+local tonumber = tonumber
+
+local socket = require "socket.core"
+
+local oo = require "oil.oo"                                                     --[[VERBOSE]] local verbose = require "oil.verbose"
+
+module("oil.ludo.Referrer", oo.class)
+
+--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
+
+function newreference(self, access, key)
+	local host = access.host
+	if host == "*" then
+		host = socket.dns.gethostname()
+		host = socket.dns.toip(host) or host
+	end
+	return {
+		host = host,
+		port = access.port,
+		object = key,
+	}
+end
+
+function islocal(self, reference, access)
+	if access.addresses[reference.host] and reference.port == access.port then
+		return reference.object
+	end
+end
+
+function encode(self, reference)
+	local object, host, port = reference.object, reference.host, reference.port
+	if object ~= nil and host ~= nil and port ~= nil then
+		local encoder = self.codec:encoder()
+		encoder:put(object, host, port)
+		return encoder:__tostring()
+	end
+	return nil, "bad LuDO reference"
+end
+
+function decode(self, reference)
+	local decoder = self.codec:decoder(reference)
+	local object, host, port = decoder:get()
+	if object ~= nil and host ~= nil and port ~= nil then
+		return {
+			host = host,
+			port = port,
+			object = object,
+		}
+	end
+	return nil, "invalid LuDO reference"
+end

data/vendor/lua/lib/lua/oil/ludo/Requester.lua

@@ -0,0 +1,107 @@
+--------------------------------------------------------------------------------
+------------------------------  #####      ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------ ##   ## ##  ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------  #####  ### ###### ------------------------------
+--------------------------------                --------------------------------
+----------------------- An Object Request Broker in Lua ------------------------
+--------------------------------------------------------------------------------
+-- Project: OiL - ORB in Lua                                                  --
+-- Release: 0.5                                                               --
+-- Title  : Client-side LuDO Protocol                                         --
+-- Authors: Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+-- requests:Facet
+-- 	reply:object, [except:table], [requests:table] newrequest(reference:table, operation, args...)
+-- 	reply:object, [except:table], [requests:table] getreply(request:object, [probe:boolean])
+-- 
+-- codec:Receptacle
+-- 	encoder:object encoder()
+-- 	decoder:object decoder(stream:string)
+-- 
+-- channels:Receptacle
+-- 	channel:object retieve(configs:table)
+--------------------------------------------------------------------------------
+
+local select  = select
+local tonumber = tonumber
+local unpack = unpack
+
+local oo = require "oil.oo"                                                     --[[VERBOSE]] local verbose = require "oil.verbose"
+
+module "oil.ludo.Requester"
+
+oo.class(_M, Messenger)
+
+--------------------------------------------------------------------------------
+
+local MessageFmt = "%d\n%s"
+
+function newrequest(self, reference, operation, ...)
+	local result, except = self.channels:retrieve(reference)
+	if result then
+		local channel = result
+		local encoder = self.codec:encoder()
+		local requestid = #channel+1
+		encoder:put(requestid, reference.object, operation, ...)
+		local data = encoder:__tostring()
+		channel:trylock("write", true)
+		result, except = channel:send(MessageFmt:format(#data, data))
+		channel:freelock("write")
+		if result then
+			result = { channel = channel }
+			channel[requestid] = result
+		else
+			if except == "closed" then channel:close() end
+		end
+	end
+	return result, except
+end
+
+--------------------------------------------------------------------------------
+
+local function update(channel, requestid, success, ...)
+	local request, except = channel[requestid]
+	if request then
+		channel[requestid] = nil
+		request.channel = nil
+		request.success = success
+		request.n = select("#", ...)
+		for i = 1, request.n do
+			request[i] = select(i, ...)
+		end
+	else
+		except = "LuDO protocol: unexpected reply"
+	end
+	return request, except
+end
+
+function getreply(self, request, probe)
+	local result, except = true, nil
+	if request.success == nil then
+		local channel = request.channel
+		if channel:trylock("read", not probe, request) then
+			local codec = self.codec
+			while result and (result ~= request) and (not probe or channel:probe()) do
+				result, except = channel:receive()
+				if result then
+					result = tonumber(result)
+					if result then
+						result, except = channel:receive(result)
+						if result then
+							result, except = update(channel, codec:decoder(result):get())
+							if result then
+								channel:signal(result)
+							end
+						end
+					else
+						except = "LuDO protocol: invalid message size"
+					end
+				end
+			end
+			channel:freelock("read")
+		end
+	end
+	return result, except
+end

data/vendor/lua/lib/lua/oil/oo.lua

@@ -0,0 +1 @@
+package.loaded["oil.oo"] = require "loop.multiple"

data/vendor/lua/lib/lua/oil/port.lua

@@ -0,0 +1 @@
+package.loaded["oil.port"] = require "loop.component.base"

data/vendor/lua/lib/lua/oil/properties.lua

@@ -0,0 +1,57 @@
+-- $Id$
+--******************************************************************************
+-- Copyright 2002 Noemi Rodriquez & Roberto Ierusalimschy. All rights reserved. 
+--******************************************************************************
+
+--------------------------------------------------------------------------------
+------------------------------  #####      ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------ ##   ## ##  ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------  #####  ### ###### ------------------------------
+--------------------------------                --------------------------------
+----------------------- An Object Request Broker in Lua ------------------------
+--------------------------------------------------------------------------------
+-- Project: OiL - ORB in Lua: An Object Request Broker in Lua                 --
+-- Release: 0.5                                                               --
+-- Title  : Properties management package for OiL                             --
+-- Authors: Leonardo S. A. Maciel <leonardo@maciel.org>                       --
+--------------------------------------------------------------------------------
+-- Interface:                                                                 --
+--------------------------------------------------------------------------------
+-- Notes:                                                                     --
+--------------------------------------------------------------------------------
+
+local require    = require
+local rawget     = rawget
+local rawset     = rawset
+local oo         = require "loop.base"
+
+module("oil.properties", oo.class)                                              --[[VERBOSE]] local verbose = require "oil.verbose"
+
+--------------------------------------------------------------------------------
+-- Key constants ---------------------------------------------------------------
+
+local PARENT = {}
+local DEFAULT = {}
+
+--------------------------------------------------------------------------------
+-- Properties implementation ---------------------------------------------------
+
+function __index(self, key)
+    if key then
+        local parent = rawget(self, PARENT)
+        local default = rawget(self, DEFAULT)
+        local value = parent and parent[key] or default and default[key] or nil
+        rawset(self, key, value)
+        return value
+    else
+        return nil
+    end
+end
+
+function __init(self, parent, default)
+    return oo.rawnew(self, {[PARENT] = parent,
+                            [DEFAULT]= default})
+end
+

data/vendor/lua/lib/lua/oil/verbose.lua

@@ -0,0 +1,133 @@
+--------------------------------------------------------------------------------
+------------------------------  #####      ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------ ##   ## ##  ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------  #####  ### ###### ------------------------------
+--------------------------------                --------------------------------
+----------------------- An Object Request Broker in Lua ------------------------
+--------------------------------------------------------------------------------
+-- Project: OiL - ORB in Lua: An Object Request Broker in Lua                 --
+-- Release: 0.5                                                              --
+-- Title  : Verbose Support                                                   --
+-- Authors: Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+
+local rawget = rawget
+local type   = type
+local unpack = unpack
+
+local math   = require "math"
+local string = require "string"
+local table  = require "table"
+
+local ObjectCache = require "loop.collection.ObjectCache"
+local Viewer      = require "loop.debug.Viewer"
+local Verbose     = require "loop.debug.Verbose"
+local Inspector   = require "loop.debug.Inspector"
+
+module("oil.verbose", Verbose)
+
+viewer = Viewer{
+	maxdepth = 1,
+	labels = ObjectCache(),
+}
+function viewer.labels:retrieve(value)
+  local type = type(value)
+  local id = rawget(self, type) or 0
+  self[type] = id + 1
+  local label = {}
+  repeat
+    label[#label + 1] = string.byte("A") + (id % 26)
+    id = math.floor(id / 26)
+  until id <= 0
+  return string.format("%s:%s", type, string.char(unpack(label)))
+end
+
+function output(self, output)
+	self.viewer.output = output
+end
+
+groups.broker = { "acceptor", "dispatcher", "servants", "proxies" }
+groups.communication = { "mutex", "invoke", "listen", "message", "channels" }
+groups.transport = { "marshal", "unmarshal" }
+groups.idltypes = { "idl", "repository" }
+
+_M:newlevel{ "broker" }
+_M:newlevel{ "invoke", "listen" }
+_M:newlevel{ "mutex" }
+_M:newlevel{ "message" }
+_M:newlevel{ "channels" }
+_M:newlevel{ "transport" }
+_M:newlevel{ "hexastream" }
+_M:newlevel{ "idltypes" }
+
+function _M:hexastream(codec, cursor, prefix)
+	if self.flags.hexastream then
+		local stream = codec:getdata()
+		if prefix then stream = string.rep("\0", prefix)..stream end
+		local last = #stream
+		for count = 1, last do
+			if cursor[count] then
+				for count = last, count, -1 do
+					if cursor[count] == false then
+						last = math.min(last, 16*math.ceil(count/16))
+						break
+					end
+				end
+				local base = codec.previousend
+				local output = self.viewer.output
+				local lines = string.format("%%0%dx:", math.ceil(math.log10((base+last)/16))+1)
+				local text = {}
+				for count = count-(count-1)%16, last do
+					column = math.mod(count-1, 16)
+					-- write line start if necessary
+					if column == 0 then
+						output:write(lines:format(base+count-1))
+					end
+					-- write hexadecimal code
+					local hexa
+					if cursor[count]
+						then hexa = "[%02x]"
+						else hexa = " %02x "
+					end
+					local code = stream:byte(count, count)
+					output:write(hexa:format(code))
+					if code == 0 then
+						text[#text+1] = "."
+					elseif code == 255 then
+						text[#text+1] = "#"
+					elseif stream:match("^[%w%p ]", count) then
+						text[#text+1] = stream:sub(count, count)
+					else
+						text[#text+1] = "?"
+					end
+					-- write blank if reached the end of the stream
+					if count == last or cursor[count+1] == "end" then
+						output:write(string.rep("    ", 15-column))
+						text[#text+1] = string.rep(" ", 15-column)
+						if column < 8 then output:write("  ") end
+						column = 15
+					end
+					-- write ASCII text if last column, or a blank space if middle column
+					if column == 15 then
+						output:write("  |"..table.concat(text).."|\n")
+						text = {}
+					elseif column == 7 then
+						output:write("  ")
+					end
+					if cursor[count+1] == "end" then break end
+				end
+				break
+			end
+		end
+	end
+end
+
+--------------------------------------------------------------------------------
+
+_M:flag("debug", true)
+_M:flag("print", true)
+
+I = Inspector{ viewer = viewer }
+function inspect:debug() self.I:stop(4) end