rufus-lua-win 5.1.5

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

@@ -0,0 +1,50 @@
+--------------------------------------------------------------------------------
+---------------------- ##       #####    #####   ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##   ## -----------------------
+---------------------- ##      ##   ##  ##   ##  ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##      -----------------------
+---------------------- ######   #####    #####   ##      -----------------------
+----------------------                                   -----------------------
+----------------------- Lua Object-Oriented Programming ------------------------
+--------------------------------------------------------------------------------
+-- Project: LOOP Class Library                                                --
+-- Release: 2.3 beta                                                          --
+-- Title  : Conditional Compiler for Code Generation                          --
+-- Author : Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+
+local type       = type
+local assert     = assert
+local ipairs     = ipairs
+local setfenv    = setfenv
+local loadstring = loadstring
+
+local table = require "table"
+local oo    = require "loop.base"
+
+module("loop.compiler.Conditional", oo.class)
+
+function source(self, includes)
+	local func = {}
+	for line, strip in ipairs(self) do
+		local cond = strip[2]
+		if cond then
+			cond = assert(loadstring("return "..cond,
+				"compiler condition "..line..":"))
+			setfenv(cond, includes)
+			cond = cond()
+		else
+			cond = true
+		end
+		if cond then
+			assert(type(strip[1]) == "string",
+				"code string is not a string")
+			func[#func+1] = strip[1]
+		end
+	end
+	return table.concat(func, "\n")
+end
+
+function execute(self, includes, ...)
+	return assert(loadstring(self:source(includes), self.name))(...)
+end

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

@@ -0,0 +1,215 @@
+--------------------------------------------------------------------------------
+---------------------- ##       #####    #####   ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##   ## -----------------------
+---------------------- ##      ##   ##  ##   ##  ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##      -----------------------
+---------------------- ######   #####    #####   ##      -----------------------
+----------------------                                   -----------------------
+----------------------- Lua Object-Oriented Programming ------------------------
+--------------------------------------------------------------------------------
+-- Project: LOOP Class Library                                                --
+-- Release: 2.3 beta                                                          --
+-- Title  : Simple Expression Parser                                          --
+-- Author : Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+
+local luaerror = error
+local pairs = pairs
+local ipairs = ipairs
+local unpack = unpack
+local select = select
+
+require "string"
+local oo = require "loop.base"
+
+--[[VERBOSE]] local verbose = require("loop.debug.Verbose"){
+--[[VERBOSE]] 	groups = { expression = {"operator","value","parse"} }
+--[[VERBOSE]] }
+--[[VERBOSE]] verbose:flag("expression", false)
+
+module("loop.compiler.Expression", oo.class)
+
+pos = 1
+count = 0
+precedence = {}
+
+local pattern = "^ *%s"
+function __init(self, object)
+	self = oo.rawnew(self, object)
+
+	if not self.operands and self.values then
+		local operands = {}
+		for kind, spec in pairs(self.values) do
+			operands[kind] = pattern:format(spec)
+		end
+		self.operands = operands
+	end
+	
+	if not self.format and self.operators then
+		local opformat = {}
+		for name, spec in pairs(self.operators) do
+			local format = {}
+			local pos = 1
+			while pos <= #spec do
+				if spec:find("^ ", pos) then
+					format[#format+1] = true
+					pos = pos + 1
+				else
+					local keyword = spec:match("^[^ ]+", pos)
+					format[#format+1] = keyword
+					pos = pos + #keyword
+				end
+			end
+			opformat[name] = format
+		end
+		self.format = opformat
+	end
+
+	self.values = self.values or {}
+	
+	return self
+end
+
+function push(self, kind, value)
+	self[#self+1] = kind
+	if kind == true then
+		self.count = self.count + 1
+		self.values[self.count] = value
+	end
+end
+
+function pop(self)
+	local kind = self[#self]
+	self[#self] = nil
+	local value
+	if kind == true then
+		value = self.values[self.count]
+		self.count = self.count - 1
+	end
+	return kind, value
+end
+
+function get(self, count)
+	local nvals = 0
+	for _=1, count do
+		if self[#self] == true then
+			nvals = nvals + 1
+		end
+		self[#self] = nil
+	end
+	self.count = self.count - nvals
+	return unpack(self.values, self.count + 1, self.count + nvals)
+end
+
+local errmsg = "%s at position %d"
+function error(self, msg)
+	return luaerror(errmsg:format(msg, self.pos))
+end
+
+function done(self)
+	return (self.text:match("^%s*$", self.pos))
+end
+
+function token(self, token)
+	local pos = select(2, self.text:find("^%s*[^%s]", self.pos))
+	if pos and (self.text:find(token, pos, true) == pos) then
+		self.pos = pos + #token
+		return true
+	end
+end
+
+function match(self, pattern)
+	local first, last, value = self.text:find(pattern, self.pos)
+	if first then
+		self.pos = last + 1
+		return value
+	end
+end
+
+function operator(self, name, level, start)
+	local format = self.format[name]
+	for index, kind in ipairs(format) do
+		local parsed = self[start + index]
+		if parsed then
+			if parsed ~= kind then                                                    --[[VERBOSE]] verbose:operator("parsed value mismatch, got '",parsed,"' ('",kind,"' expected)")
+				return false                                                            --[[VERBOSE]] else verbose:operator("parsed value matched, got '",parsed,"'")
+			end
+		else
+			if kind == true then                                                      --[[VERBOSE]] verbose:operator(true, "operand expected, parsing...")
+				if not self:parse(level + 1, #self) then                                --[[VERBOSE]] verbose:operator(false, "operand parsing failed")
+					return false
+				end                                                                     --[[VERBOSE]] verbose:operator(false, "operand parsed successfully")
+			else                                                                      --[[VERBOSE]] verbose:operator("token ",kind," expected")
+				if self:token(kind) then                                                --[[VERBOSE]] verbose:operator("token found successfully")
+					self:push(kind)
+				else                                                                    --[[VERBOSE]] verbose:operator("token not found")
+					return false
+				end
+			end
+		end
+	end                                                                           --[[VERBOSE]] verbose:operator(true, "operator ",name," matched")
+	self:push(true, self[name](self, self:get(#format)))                          --[[VERBOSE]] verbose:operator(false, "operator ",name," callback called")
+	return true
+end
+
+function value(self)
+	if self:token("(") then                                                       --[[VERBOSE]] verbose:value(true, "'(' found at ",self.pos)
+		local start = #self
+		if not self:parse(1, start) then                                            --[[VERBOSE]] verbose:value(false, "error in enclosed expression")
+			self:error("value expected")
+		elseif #self ~= start + 1 or self[#self] ~= true then                       --[[VERBOSE]] verbose:value(false, "enclosed expression incomplete (too many parsed values left)")
+			self:error("incomplete expression")
+		elseif not self:token(")") then                                             --[[VERBOSE]] verbose:value(false, "')' not found")
+			self:error("')' expected")
+		end                                                                         --[[VERBOSE]] verbose:value(false, "matching ')' found")
+		return true
+	else                                                                          --[[VERBOSE]] verbose:value(true, "parsing value at ",self.pos)
+		for kind, pattern in pairs(self.operands) do                                --[[VERBOSE]] verbose:value("attempt to match value as ",kind)
+			local value = self:match(pattern)
+			if value then                                                             --[[VERBOSE]] verbose:value(true, "value found as ",kind)
+				self:push(true, self[kind](self, value))                                --[[VERBOSE]] verbose:value(false, "value evaluated to ",self.values[self.count])
+				return true                                                             --[[VERBOSE]],verbose:value(false)
+			end
+		end                                                                         --[[VERBOSE]] verbose:value(false, "no value found at ",self.pos)
+		return false
+	end
+end
+
+function parse(self, level, start)
+	if not self:done() then
+		local ops = self.precedence[level]
+		if ops then                                                                 --[[VERBOSE]] verbose:parse(true, "parsing operators of level ",level)
+			local i = 1
+			while ops[i] do
+				local op = ops[i]                                                       --[[VERBOSE]] verbose:parse(true, "attempt to match operator ",op)
+				if self:operator(ops[i], level, start) then                             --[[VERBOSE]] verbose:parse(false, "operator ",op," successfully matched")
+					i = 1
+				else                                                                    --[[VERBOSE]] verbose:parse(false, "operator ",op," not matched")
+					i = i + 1
+				end
+			end
+			if #self == start then                                                    --[[VERBOSE]] verbose:parse(false, "no value evaluated by operators of level ",level)
+				return self:parse(level + 1, start)
+			elseif self[start + 1] == true then                                       --[[VERBOSE]] verbose:parse(false, "values evaluated by operators of level ",level)
+				return true
+			end
+		else                                                                        --[[VERBOSE]] verbose:parse(true, "parsing value")
+			return self:value()                                                       --[[VERBOSE]] ,verbose:parse(false)
+		end
+	end
+end
+
+function evaluate(self, text, pos)
+	if text then
+		self.text = text
+		self.pos = pos
+	end
+	if not self:parse(1, 0) then
+		self:error("parsing failed")
+	elseif not self:done() then
+		self:error("malformed expression")
+	elseif #self ~= 1 or self[1] ~= true then
+		self:error("incomplete expression")
+	end
+	return self:get(1)
+end

data/vendor/lua/lib/lua/loop/component/base.lua

@@ -0,0 +1,221 @@
+--------------------------------------------------------------------------------
+---------------------- ##       #####    #####   ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##   ## -----------------------
+---------------------- ##      ##   ##  ##   ##  ######  -----------------------
+---------------------- ##      ##   ##  ##   ##  ##      -----------------------
+---------------------- ######   #####    #####   ##      -----------------------
+----------------------                                   -----------------------
+----------------------- Lua Object-Oriented Programming ------------------------
+--------------------------------------------------------------------------------
+-- Project: LOOP - Lua Object-Oriented Programming                            --
+-- Release: 2.3 beta                                                          --
+-- Title  : Base Component Model                                              --
+-- Author : Renato Maia <maia@inf.puc-rio.br>                                 --
+--------------------------------------------------------------------------------
+-- Exported API:                                                              --
+--   Template                                                                 --
+--   Facet                                                                    --
+--   Receptacle                                                               --
+--   ListReceptacle                                                           --
+--   HashReceptacle                                                           --
+--   SetReceptacle                                                            --
+--   factoryof(component)                                                     --
+--   templateof(factory|component)                                            --
+--   ports(template)                                                          --
+--   segmentof(portname, component)                                           --
+--------------------------------------------------------------------------------
+
+local next   = next
+local pairs  = pairs
+local pcall  = pcall
+local rawget = rawget
+local rawset = rawset
+local select = select
+local type   = type
+
+local oo = require "loop.cached"
+
+module "loop.component.base"
+
+--------------------------------------------------------------------------------
+
+BaseTemplate = oo.class()
+
+function BaseTemplate:__call(...)
+	return self:__build(self:__new(...))
+end
+
+function BaseTemplate:__new(...)
+	local comp = self.__component or self[1]
+	if comp then
+		comp = comp(...)
+		comp.__component = comp
+	else
+		comp = ... or {}
+	end
+	comp.__factory = self
+	for port, class in pairs(self) do
+		if type(port) == "string" and port:match("^%a[%w_]*$") then
+			comp[port] = class(comp[port], comp)
+		end
+	end
+	return comp
+end
+
+local function tryindex(segment) return segment.context end
+function BaseTemplate:__setcontext(segment, context)
+	local success, setcontext = pcall(tryindex, segment)
+	if success and setcontext ~= nil then
+		if type(setcontext) == "function"
+			then setcontext(segment, context)
+			else segment.context = context
+		end
+	end
+end
+
+function BaseTemplate:__build(segments)
+	for port, class in oo.allmembers(oo.classof(self)) do
+		if port:match("^%a[%w_]*$") then
+			class(segments, port, segments)
+		end
+	end
+	segments.__reference = segments
+	for port in pairs(self) do
+		if port == 1
+			then self:__setcontext(segments.__component, segments)
+			else self:__setcontext(segments[port], segments)
+		end
+	end
+	return segments
+end
+
+function Template(template, ...)
+	if select("#", ...) > 0
+		then return oo.class(template, ...)
+		else return oo.class(template, BaseTemplate)
+	end
+end
+
+--------------------------------------------------------------------------------
+
+function factoryof(component)
+	return component.__factory
+end
+
+function templateof(object)
+	return oo.classof(factoryof(object) or object)
+end
+
+local nextmember
+local function portiterator(state, name)
+	local port
+	repeat
+		name, port = nextmember(state, name)
+		if name == nil then return end
+	until name:find("^%a")
+	return name, port
+end
+function ports(template)
+	if not oo.subclassof(template, BaseTemplate) then
+		template = templateof(template)
+	end
+	local state, var
+	nextmember, state, var = oo.allmembers(template)
+	return portiterator, state, var
+end
+
+function segmentof(comp, port)
+	return comp[port]
+end
+
+--------------------------------------------------------------------------------
+
+function addport(comp, name, port, class)
+	if class then
+		comp[name] = class(comp[name], comp)
+	end
+	port(comp, name, comp)
+	comp.__factory:__setcontext(comp[name], context)
+end
+
+function removeport(comp, name)
+	comp[name] = nil
+end
+
+--------------------------------------------------------------------------------
+
+function Facet(segments, name)
+	segments[name] = segments[name] or
+	                 segments.__component[name] or
+	                 segments.__component
+	return false
+end
+
+--------------------------------------------------------------------------------
+
+function Receptacle()
+	return false
+end
+
+--------------------------------------------------------------------------------
+
+MultipleReceptacle = oo.class{
+	__all = pairs,
+	__hasany = next,
+	__get = rawget,
+}
+
+function MultipleReceptacle:__init(segments, name)
+	local receptacle = oo.rawnew(self, segments[name])
+	segments[name] = receptacle
+	return receptacle
+end
+
+function MultipleReceptacle:__newindex(key, value)
+	if value == nil
+		then self:__unbind(key)
+		else self:__bind(value, key)
+	end
+end
+
+function MultipleReceptacle:__unbind(key)
+	local port = rawget(self, key)
+	rawset(self, key, nil)
+	return port
+end
+
+--------------------------------------------------------------------------------
+
+ListReceptacle = oo.class({}, MultipleReceptacle)
+
+function ListReceptacle:__bind(port)
+	local index = #self + 1
+	rawset(self, index, port)
+	return index
+end
+
+--------------------------------------------------------------------------------
+
+HashReceptacle = oo.class({}, MultipleReceptacle)
+
+function HashReceptacle:__bind(port, key)
+	rawset(self, key, port)
+	return key
+end
+
+--------------------------------------------------------------------------------
+
+SetReceptacle = oo.class({}, MultipleReceptacle)
+
+function SetReceptacle:__bind(port)
+	rawset(self, port, port)
+	return port
+end
+
+--------------------------------------------------------------------------------
+
+_M[Facet         ] = "Facet"
+_M[Receptacle    ] = "Receptacle"
+_M[ListReceptacle] = "ListReceptacle"
+_M[HashReceptacle] = "HashReceptacle"
+_M[SetReceptacle ] = "SetReceptacle"