rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/oil/corba/giop/CodecGen.lua

@@ -0,0 +1,589 @@
+--------------------------------------------------------------------------------
+------------------------------  #####      ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------ ##   ## ##  ##     ------------------------------
+------------------------------ ##   ##  #  ##     ------------------------------
+------------------------------  #####  ### ###### ------------------------------
+--------------------------------                --------------------------------
+----------------------- An Object Request Broker in Lua ------------------------
+--------------------------------------------------------------------------------
+-- Project: OiL - ORB in Lua: An Object Request Broker in Lua                 --
+-- Release: 0.5                                                               --
+-- Title  : Mapping of Lua values into CDR using dynamic generated code       --
+-- Authors: Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+-- codec:Facet
+-- 	encoder:object encoder()
+-- 	decoder:object decoder(stream:string)
+-- 
+-- proxies:Receptacle
+-- 	proxy:object proxyto(ior:table, iface:table|string)
+-- 
+-- objects:Receptacle
+-- 	proxy:object register(implementation:object, iface:table|string)
+--------------------------------------------------------------------------------
+
+local ipairs     = ipairs
+local loadstring = loadstring
+local select     = select
+local unpack     = unpack
+
+local string = require "string"
+local table  = require "table"
+
+local oo     = require "oil.oo"
+local assert = require "oil.assert"
+local idl    = require "oil.corba.idl"
+local Codec  = require "oil.corba.giop.Codec"                                   --[[VERBOSE]] local verbose = require "oil.verbose"
+
+module "oil.corba.giop.CodecGen"
+
+oo.class(_M, Codec)
+
+--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
+
+CodeGenerator = oo.class{
+	stacksize = 0,
+	stacktop = 0,
+	source = table.concat,
+}
+
+local upvaluefmt = "_up%d_"
+local stackposfmt = "_%d_"
+
+function CodeGenerator:__init(...)
+	self = oo.rawnew(self, ...)
+	if self.upvalues == nil then self.upvalues = {n=0} end
+	return self
+end
+
+function CodeGenerator:add(...)
+	for i = 1, select("#", ...) do
+		self[#self+1] = select(i, ...)
+	end
+end
+
+function CodeGenerator:push(...)
+	self.stacktop = self.stacktop + 1
+	if self.stacktop > self.stacksize then
+		self.stacksize = self.stacktop
+	end
+	self:add(self:top(),' = ',...)
+	self:add("\n")
+end
+
+function CodeGenerator:pop()
+	self.stacktop = self.stacktop - 1
+end
+
+function CodeGenerator:top(shift)
+	return stackposfmt:format(self.stacktop+(shift or 0))
+end
+
+function CodeGenerator:upvalue(value)
+	local upvalues = self.upvalues
+	if value == nil then value = upvalues end -- special value to represent 'nil'
+	if upvalues[value] == nil then
+		upvalues.n = upvalues.n + 1
+		upvalues[value] = upvaluefmt:format(upvalues.n)
+		if value ~= upvalues then
+			upvalues[upvalues.n] = value
+		end
+	end
+	return upvalues[value]
+end
+
+function CodeGenerator:compile(idltype)
+	local source = self:source()
+	
+	local positions = {"self"}
+	for i = 1, self.stacksize do
+		positions[i+1] = stackposfmt:format(i)
+	end
+
+	source = string.format([=[
+local assert = require "oil.assert"                                             --[[VERBOSE]] local verbose = require "oil.verbose"
+return function(%s) %s end
+]=], table.concat(positions, ","), source)
+	
+	local upvalues = self.upvalues
+	if upvalues.n > 0 then
+		local names = {}
+		for i = 1, upvalues.n do
+			names[i] = upvaluefmt:format(i)
+		end
+		source = string.format("local %s = ...\n%s", table.concat(names, ","), source)
+	end
+	
+	local codename = string.format("(un)marshaller for %s %s",
+		idltype._type,
+		idltype.repID or idltype.name or "anonymous")
+	return assert.results(loadstring(source, codename))(
+		unpack(upvalues, 1, upvalues.n))
+end
+
+function CodeGenerator:illegal(description, sysex)
+	self:add([[ assert.exception{ ']],(sysex or "illegal value"),[[',
+		reason = 'value',
+		message = 'illegal ]],description,[[',
+		valuename = ']],description,[['
+	}
+	]])
+end
+
+--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
+
+DecoderGenerator = oo.class({}, CodeGenerator)
+
+function DecoderGenerator:__init(...)
+	self = CodeGenerator.__init(self, ...)
+	if #self == 0 then self[1] = "return " end
+	return self
+end
+
+local code = "self.unpack('%s',self.data,nil,nil,self:alignedjump(%d))"
+local function numberunmarshaller(size, format)
+	local code = code:format(format, size)
+	return function(self) self:add(code) end
+end
+DecoderGenerator.null       = function(self) self:add(" nil") end
+DecoderGenerator.void       = DecoderGenerator.null
+DecoderGenerator.short      = numberunmarshaller( 2, "s")
+DecoderGenerator.long       = numberunmarshaller( 4, "l")
+DecoderGenerator.longlong   = numberunmarshaller( 8, "g")
+DecoderGenerator.ushort     = numberunmarshaller( 2, "S")
+DecoderGenerator.ulong      = numberunmarshaller( 4, "L")
+DecoderGenerator.ulonglong  = numberunmarshaller( 8, "G")
+DecoderGenerator.float      = numberunmarshaller( 4, "f")
+DecoderGenerator.double     = numberunmarshaller( 8, "d")
+DecoderGenerator.longdouble = numberunmarshaller(16, "D")
+
+function DecoderGenerator:boolean()
+	self:add "("
+	self:octet()
+	self:add "~=0)"
+end
+
+function DecoderGenerator:char()
+	self:add "self.data:sub(self.cursor,self:jump(1))"
+end
+
+function DecoderGenerator:octet()
+	self:add "self.unpack('B',self.data,nil,nil,self:jump(1))"
+end
+
+function DecoderGenerator:struct(idltype)
+	self:add "setmetatable({\n"
+	for _, field in ipairs(idltype.fields) do
+		self:add(field.name,'=')
+		self:generate(field.type)
+		self:add(',\n')
+	end
+	self:add("},",self:upvalue(idltype),")\n")
+end
+
+function DecoderGenerator:union(idltype)
+	local gen = DecoderGenerator{""}
+	local default = idltype.options[idltype.default+1]
+	gen:add([[
+local switch
+local function default(self)
+	return {
+		_switch = switch,
+]]) if default then gen:add([[
+		_field = ]],default.name,[[,
+		_value = ]]) gen:generate(default.type) gen:add([[,
+]]) end gen:add([[
+	}
+end
+]])
+	
+	gen:add 'return setmetatable({\n'
+	for _, option in ipairs(idltype.options) do
+		--[<option.label>] = function()
+		--	return {
+		--		_switch = <option.label>,
+		--		_field = <option.name>,
+		--		_value = <unmarhsall(option.type)>,
+		--	}
+		--end,
+		local switch = gen:upvalue(option.label)
+		gen:add([[
+	[]],switch,[[] = function(self)
+		return {
+			_switch = ]],switch,[[,
+			_field = ']],option.name,[[',
+			_value = ]]) gen:generate(option.type) gen:add[[,
+		}
+	end,
+]]
+	end
+	gen:add[[
+},{
+	__index=function(_,value)
+		switch=value
+		return default
+	end,
+})
+]]
+	local selector = gen:compile(idltype)
+	-- setmetatable(__selector__[<unmarshal(idltype.switch)>](self), __idltype__)
+	self:add("setmetatable(",self:upvalue(selector()),"[")
+	self:generate(idltype.switch)
+	self:add("](self),",self:upvalue(idltype),")")
+end
+
+function DecoderGenerator:enum(idltype)
+	-- <idltype.enumvalues>[unmarhsal(ulong)+1] or illegal("enumeration value")
+	self:add(self:upvalue(idltype.enumvalues),"[")
+	self:ulong()
+	self:add("+1] or ")
+	self:illegal("enumeration value", "MARSHAL")
+end
+
+function DecoderGenerator:string()
+	self:add "self.data:sub(self:jump("
+	self:ulong()
+	self:add "),self.cursor-2)"
+end
+
+function DecoderGenerator:sequence(idltype)
+	local elementtype = idltype.elementtype
+	while elementtype._type == "typecode" do elementtype = elementtype.type end
+	if elementtype == idl.octet or elementtype == idl.char then
+		self:add "self.data:sub(self:jump("
+		self:ulong()
+		self:add "),self.cursor-1)"
+	else
+		local gen = DecoderGenerator()
+		gen:generate(elementtype)
+		self:add("setmetatable(self:sequenceof(",self:upvalue(gen:compile(elementtype)),",")
+		self:ulong()
+		self:add("),",self:upvalue(idltype),")")
+	end
+end
+
+function DecoderGenerator:array(idltype)
+	local length      = idltype.length
+	local elementtype = idltype.elementtype
+	while elementtype._type == "typecode" do elementtype = elementtype.type end
+	if elementtype == idl.octet or elementtype == idl.char then
+		self:add("self.data:sub(self:jump(",length,"),self.cursor-1)")
+	else
+		self:add "setmetatable({\n"
+		for i = 1, length do
+			self:generate(elementtype)
+			self:add ",\n"
+		end
+		self:add("},",self:upvalue(elementtype),")")
+	end
+end
+
+function DecoderGenerator:typedef(idltype)
+	return self:generate(idltype.type)
+end
+
+function DecoderGenerator:except(idltype)
+	self:add "setmetatable({\n"
+	for _, member in ipairs(idltype.members) do
+		self:add(member.name,"=")
+		self:generate(member.type)
+		self:add(",\n")
+	end
+	self:add("},",self:upvalue(idltype),")")
+end
+
+function DecoderGenerator:generate(idltype)
+	local generator = self[idltype._type]
+	if generator then                                                             --[[VERBOSE]] self:add("verbose:gen_marshal(self,",self:upvalue(idltype),",")
+		generator(self, idltype)                                                    --[[VERBOSE]] self:add(")")
+	else
+		self:add("self:",idltype._type,"(",self:upvalue(idltype),")")
+	end
+end
+
+--------------------------------------------------------------------------------
+
+Decoder = oo.class({}, Decoder)
+
+function Decoder:alignedjump(value)
+	local shift = value - (self.cursor - 2) % value - 1
+	local pos = self.cursor + shift
+	self:jump(shift + value)
+	return pos
+end
+
+function Decoder:sequenceof(decoder, length)
+	local sequence = { n = length }
+	for i = 1, length do
+		sequence[i] = decoder(self)
+	end
+	return sequence
+end
+
+function Decoder:get(idltype)
+	local unmarshall = idltype.unmarshall
+	if unmarshall == nil then
+		local type = idltype._type
+		if DecoderGenerator[type] then
+			local gen = DecoderGenerator()
+			gen:generate(idltype)                                                     --[[VERBOSE]] verbose:marshal("generating new unmarshaller for type ",idltype._type)
+			unmarshall = gen:compile(idltype)
+			idltype.unmarshall = unmarshall
+		else                                                                        --[[VERBOSE]] verbose:marshal("using dynamic unmarshaller for type ",idltype._type)
+			unmarshall = self[type] or
+			             assert.illegal(type, "supported type", "MARSHAL")
+		end                                                                         --[[VERBOSE]] else verbose:marshal("generated unmarshaller found for type ",idltype._type)
+	end
+	return unmarshall(self, idltype)
+end
+
+-- generate string decoder because 'Decoder:string()' does not get an argument.
+local gen = DecoderGenerator()
+gen:generate(idl.string)
+idl.string.unmarshall = gen:compile(idl.string)
+Decoder.string = idl.string.unmarshall
+
+Decoder.struct     = Decoder.get
+Decoder.union      = Decoder.get
+Decoder.enum       = Decoder.get
+Decoder.sequence   = Decoder.get
+Decoder.array      = Decoder.get
+Decoder.typedef    = Decoder.get
+Decoder.except     = Decoder.get
+
+--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
+
+EncoderGenerator = oo.class({
+	stacksize = 1,
+	stacktop = 1,
+}, CodeGenerator)
+
+function EncoderGenerator:__init(...)
+	self = CodeGenerator.__init(self, ...)
+	if #self == 0 then
+		self[1] = [[
+local format = self.format
+local aux
+]]
+	end
+	return self
+end
+
+function EncoderGenerator:rawput(format, size, value)
+	self:add("local index = self.index")
+	self:add("\nformat[index],self[index] = '",format,"',",value or self:top())
+	self:add("\nself.index,self.cursor = index+1,self.cursor+",size,"\n")
+end
+
+local function numbermarshaller(size, format)
+	return function(self)
+		self:add('aux = ',size-1,'-(self.cursor-2)%',size,'\n')
+		self:rawput('"', 'aux', '("\\255"):rep(aux)')
+		self:rawput(format, size)
+	end
+end
+EncoderGenerator.null       = function() end
+EncoderGenerator.void       = DecoderGenerator.null
+EncoderGenerator.short      = numbermarshaller( 2, "s")
+EncoderGenerator.long       = numbermarshaller( 4, "l")
+EncoderGenerator.longlong   = numbermarshaller( 8, "g")
+EncoderGenerator.ushort     = numbermarshaller( 2, "S")
+EncoderGenerator.ulong      = numbermarshaller( 4, "L")
+EncoderGenerator.ulonglong  = numbermarshaller( 8, "G")
+EncoderGenerator.float      = numbermarshaller( 4, "f")
+EncoderGenerator.double     = numbermarshaller( 8, "d")
+EncoderGenerator.longdouble = numbermarshaller(16, "D")
+
+function EncoderGenerator:boolean()
+	self:add(self:top(),' = ',self:top(),' and 1 or 0\n')
+	self:octet()
+end
+
+function EncoderGenerator:char()
+	self:add('if #',self:top(),' ~= 1 then assert.illegal(',self:top(),', "character", "MARSHAL") end\n')
+	self:rawput('"', 1)
+end
+
+function EncoderGenerator:octet()
+	self:rawput("B", 1)
+end
+
+function EncoderGenerator:struct(idltype)
+	for _, field in ipairs(idltype.fields) do
+		self:push(self:top(),".",field.name)
+		self:generate(field.type)
+		self:pop()
+	end
+end
+
+function EncoderGenerator:union(idltype)
+	self:push(self:top(),"._switch")
+	self:add('if ',self:top(),' == nil then\n')
+		self:pop() -- nil
+		self:push(self:upvalue(idltype.selector),'[',self:top(),'._field]')
+		self:add('if ',self:top(),' == nil then\n')
+			for index, option in ipairs(idltype.options) do
+				self:pop() -- nil
+				self:add('if ',self:top(),'.',option.name,' ~= nil then ')
+				self:push(self:upvalue(option.label))
+				self:add('else')
+			end
+			self:add '\n'
+			local default = idltype.options[idltype.default+1]
+			if default then
+				self:pop() -- nil
+				self:push(self:upvalue(default))
+			else
+				self:illegal("union value (no discriminator)", "MARSHAL")
+			end
+	self:add 'end\nend\nend\n'
+	self:generate(idltype.switch)
+	
+	for index, option in ipairs(idltype.options) do
+		self:add('if ',self:top(),' == ',self:upvalue(option.label),' then\n')
+			self:pop() -- switch
+			self:push(self:top(),'._value')
+			self:add('if ',self:top(),' == nil then\n')
+				self:pop() -- nil
+				self:push(self:top(),".",option.name)
+				self:add('if ',self:top(),' == nil then\n')
+					self:illegal("union value (none contents)", "MARSHAL")
+			self:add "end\nend\n"
+			self:generate(option.type)
+		if index == #idltype.options
+			then self:add 'end\n'
+			else self:add 'else'
+		end
+	end
+	self:pop() -- switch or value
+end
+
+function EncoderGenerator:enum(idltype)
+	self:push(self:upvalue(idltype.labelvalue),'[',self:top(),'] or tonumber(',self:top(),')')
+	self:ulong()
+	self:pop()
+end
+
+function EncoderGenerator:string()
+	self:push('#',self:top(),'+1')
+	self:ulong()
+	self:pop()
+	self:rawput('"', self:top(1))
+	self:rawput('"', 0, "'\\0'")
+end
+
+function EncoderGenerator:sequence(idltype)
+	local elementtype = idltype.elementtype
+	while elementtype._type == "typecode" do elementtype = elementtype.type end
+	local dostring = elementtype == idl.octet or elementtype == idl.char
+	if dostring then
+		self:add('if type(',self:top(),') == "string" then\n')
+			self:push('#',self:top())
+			self:ulong()
+			self:pop()
+			self:rawput('"', self:top(1))
+		self:add 'else\n'
+	end
+	self:push(self:top(),'.n or #',self:top())
+	self:ulong()
+	self:pop()
+	self:add('for i = 1, ',self:top(1),' do\n')
+	self:push(self:top(),'[i]')
+	self:generate(elementtype) 
+	self:pop()
+	self:add 'end\n'
+	if dostring then
+		self:add 'end\n'
+	end
+end
+
+function EncoderGenerator:array(idltype)
+	local elementtype = idltype.elementtype
+	while elementtype._type == "typecode" do elementtype = elementtype.type end
+	local dostring = elementtype == idl.octet or elementtype == idl.char
+	if dostring then
+		self:add('if type(',self:top(),') == "string" then\n')
+		self:rawput('"', idltype.length)
+		self:add('else\n')
+	end
+	self:add('for i = 1,',idltype.length,' do\n')
+	self:generate(elementtype) 
+	self:add 'end\n'
+	if dostring then self:add 'end\n' end
+end
+
+function EncoderGenerator:typedef(idltype)
+	return self:generate(idltype.type)
+end
+
+function EncoderGenerator:except(idltype)
+	for _, member in ipairs(idltype.members) do
+		self:push(self:top(),'.',member.name)
+		self:generate(member.type)
+		self:pop()
+	end
+end
+
+function EncoderGenerator:generate(idltype)
+	local generator = self[idltype._type]
+	if generator then                                                             --[[VERBOSE]] self:add('verbose:marshal(true,self,',self:upvalue(idltype),',',self:top(),')\n')
+		generator(self, idltype)                                                    --[[VERBOSE]] self:add('verbose:marshal(false)\n')
+	else
+		self:add('self:',idltype._type,'(',self:top(),',',self:upvalue(idltype),')\n')
+	end
+end
+
+--------------------------------------------------------------------------------
+
+Encoder = oo.class({}, Encoder)
+
+function Encoder:alignedjump(value)
+	local pos = self.cursor - 2
+	self:jump(value - pos % value - 1)
+	return self.cursor
+end
+
+function Encoder:put(value, idltype)
+	local marshall = idltype.marshall
+	if marshall == nil then
+		local type = idltype._type
+		if EncoderGenerator[type] then
+			local gen = EncoderGenerator()
+			gen:generate(idltype)                                                     --[[VERBOSE]] verbose:marshal("generating new marshaller for type ",idltype._type)
+			marshall = gen:compile(idltype)
+			idltype.marshall = marshall
+		else                                                                        --[[VERBOSE]] verbose:marshal("using dynamic marshaller for type ",idltype._type)
+			marshall = self[type] or
+			           assert.illegal(type, "supported type", "MARSHAL")
+		end                                                                         --[[VERBOSE]] else verbose:marshal("generated marshaller found for type ",idltype._type)
+	end
+	return marshall(self, value, idltype)
+end
+
+-- generate string encoder because 'Decoder:string()' does not get an argument.
+local gen = EncoderGenerator()
+gen:generate(idl.string)
+idl.string.marshall = gen:compile(idl.string)
+Encoder.string = idl.string.marshall
+
+Encoder.struct     = Encoder.put
+Encoder.union      = Encoder.put
+Encoder.enum       = Encoder.put
+Encoder.sequence   = Encoder.put
+Encoder.array      = Encoder.put
+Encoder.typedef    = Encoder.put
+Encoder.except     = Encoder.put
+
+--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
+
+--[[VERBOSE]] verbose.codecop[Encoder] = verbose.codecop[Codec.Encoder]
+--[[VERBOSE]] verbose.codecop[Decoder] = verbose.codecop[Codec.Decoder]
+--[[VERBOSE]] function verbose:gen_marshal(codec, type, value)
+--[[VERBOSE]] 	self:marshal(codec, type, value)
+--[[VERBOSE]] 	return value
+--[[VERBOSE]] end