rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/luadoc/taglet/standard/tags.lua

@@ -0,0 +1,171 @@
+-------------------------------------------------------------------------------
+-- Handlers for several tags
+-- @release $Id: tags.lua,v 1.8 2007/09/05 12:39:09 tomas Exp $
+-------------------------------------------------------------------------------
+
+local luadoc = require "luadoc"
+local util = require "luadoc.util"
+local string = require "string"
+local table = require "table"
+local assert, type, tostring = assert, type, tostring
+
+module "luadoc.taglet.standard.tags"
+
+-------------------------------------------------------------------------------
+
+local function author (tag, block, text)
+	block[tag] = block[tag] or {}
+	if not text then
+		luadoc.logger:warn("author `name' not defined [["..text.."]]: skipping")
+		return
+	end
+	table.insert (block[tag], text)
+end
+
+-------------------------------------------------------------------------------
+-- Set the class of a comment block. Classes can be "module", "function", 
+-- "table". The first two classes are automatic, extracted from the source code
+
+local function class (tag, block, text)
+	block[tag] = text
+end
+
+-------------------------------------------------------------------------------
+
+local function copyright (tag, block, text)
+	block[tag] = text
+end
+
+-------------------------------------------------------------------------------
+
+local function description (tag, block, text)
+	block[tag] = text
+end
+
+-------------------------------------------------------------------------------
+
+local function field (tag, block, text)
+	if block["class"] ~= "table" then
+		luadoc.logger:warn("documenting `field' for block that is not a `table'")
+	end
+	block[tag] = block[tag] or {}
+
+	local _, _, name, desc = string.find(text, "^([_%w%.]+)%s+(.*)")
+	assert(name, "field name not defined")
+	
+	table.insert(block[tag], name)
+	block[tag][name] = desc
+end
+
+-------------------------------------------------------------------------------
+-- Set the name of the comment block. If the block already has a name, issue
+-- an error and do not change the previous value
+
+local function name (tag, block, text)
+	if block[tag] and block[tag] ~= text then
+		luadoc.logger:error(string.format("block name conflict: `%s' -> `%s'", block[tag], text))
+	end
+	
+	block[tag] = text
+end
+
+-------------------------------------------------------------------------------
+-- Processes a parameter documentation.
+-- @param tag String with the name of the tag (it must be "param" always).
+-- @param block Table with previous information about the block.
+-- @param text String with the current line beeing processed.
+
+local function param (tag, block, text)
+	block[tag] = block[tag] or {}
+	-- TODO: make this pattern more flexible, accepting empty descriptions
+	local _, _, name, desc = string.find(text, "^([_%w%.]+)%s+(.*)")
+	if not name then
+		luadoc.logger:warn("parameter `name' not defined [["..text.."]]: skipping")
+		return
+	end
+	local i = table.foreachi(block[tag], function (i, v)
+		if v == name then
+			return i
+		end
+	end)
+	if i == nil then
+		luadoc.logger:warn(string.format("documenting undefined parameter `%s'", name))
+		table.insert(block[tag], name)
+	end
+	block[tag][name] = desc
+end
+
+-------------------------------------------------------------------------------
+
+local function release (tag, block, text)
+	block[tag] = text
+end
+
+-------------------------------------------------------------------------------
+
+local function ret (tag, block, text)
+	tag = "ret"
+	if type(block[tag]) == "string" then
+		block[tag] = { block[tag], text }
+	elseif type(block[tag]) == "table" then
+		table.insert(block[tag], text)
+	else
+		block[tag] = text
+	end
+end
+
+-------------------------------------------------------------------------------
+-- @see ret
+
+local function see (tag, block, text)
+	-- see is always an array
+	block[tag] = block[tag] or {}
+	
+	-- remove trailing "."
+	text = string.gsub(text, "(.*)%.$", "%1")
+	
+	local s = util.split("%s*,%s*", text)			
+	
+	table.foreachi(s, function (_, v)
+		table.insert(block[tag], v)
+	end)
+end
+
+-------------------------------------------------------------------------------
+-- @see ret
+
+local function usage (tag, block, text)
+	if type(block[tag]) == "string" then
+		block[tag] = { block[tag], text }
+	elseif type(block[tag]) == "table" then
+		table.insert(block[tag], text)
+	else
+		block[tag] = text
+	end
+end
+
+-------------------------------------------------------------------------------
+
+local handlers = {}
+handlers["author"] = author
+handlers["class"] = class
+handlers["copyright"] = copyright
+handlers["description"] = description
+handlers["field"] = field
+handlers["name"] = name
+handlers["param"] = param
+handlers["release"] = release
+handlers["return"] = ret
+handlers["see"] = see
+handlers["usage"] = usage
+
+-------------------------------------------------------------------------------
+
+function handle (tag, block, text)
+	if not handlers[tag] then
+		luadoc.logger:error(string.format("undefined handler for tag `%s'", tag))
+		return
+	end
+--	assert(handlers[tag], string.format("undefined handler for tag `%s'", tag))
+	return handlers[tag](tag, block, text)
+end

data/vendor/lua/lib/lua/luadoc/util.lua

@@ -0,0 +1,233 @@
+-------------------------------------------------------------------------------
+-- General utilities.
+-- @release $Id: util.lua,v 1.16 2008/02/17 06:42:51 jasonsantos Exp $
+-------------------------------------------------------------------------------
+
+local lfs = require "lfs"
+local type, table, string, io, assert, tostring, setmetatable, pcall = type, table, string, io, assert, tostring, setmetatable, pcall
+
+-------------------------------------------------------------------------------
+-- Module with several utilities that could not fit in a specific module
+
+module "luadoc.util"
+
+-------------------------------------------------------------------------------
+-- Removes spaces from the begining and end of a given string
+-- @param s string to be trimmed
+-- @return trimmed string
+
+function trim (s)
+	return (string.gsub(s, "^%s*(.-)%s*$", "%1"))
+end
+
+-------------------------------------------------------------------------------
+-- Removes spaces from the begining and end of a given string, considering the
+-- string is inside a lua comment.
+-- @param s string to be trimmed
+-- @return trimmed string
+-- @see trim
+-- @see string.gsub
+
+function trim_comment (s)
+	s = string.gsub(s, "%-%-+(.*)$", "%1")
+	return trim(s)
+end
+
+-------------------------------------------------------------------------------
+-- Checks if a given line is empty
+-- @param line string with a line
+-- @return true if line is empty, false otherwise
+
+function line_empty (line)
+	return (string.len(trim(line)) == 0)
+end
+
+-------------------------------------------------------------------------------
+-- Appends two string, but if the first one is nil, use to second one
+-- @param str1 first string, can be nil
+-- @param str2 second string
+-- @return str1 .. " " .. str2, or str2 if str1 is nil
+
+function concat (str1, str2)
+	if str1 == nil or string.len(str1) == 0 then
+		return str2
+	else
+		return str1 .. " " .. str2
+	end
+end
+
+-------------------------------------------------------------------------------
+-- Split text into a list consisting of the strings in text,
+-- separated by strings matching delim (which may be a pattern).
+-- @param delim if delim is "" then action is the same as %s+ except that
+-- field 1 may be preceeded by leading whitespace
+-- @usage split(",%s*", "Anna, Bob, Charlie,Dolores")
+-- @usage split(""," x y") gives {"x","y"}
+-- @usage split("%s+"," x y") gives {"", "x","y"}
+-- @return array with strings
+-- @see table.concat
+
+function split(delim, text)
+	local list = {}
+	if string.len(text) > 0 then
+		delim = delim or ""
+		local pos = 1
+		-- if delim matches empty string then it would give an endless loop
+		if string.find("", delim, 1) and delim ~= "" then
+			error("delim matches empty string!")
+		end
+		local first, last
+		while 1 do
+			if delim ~= "" then
+				first, last = string.find(text, delim, pos)
+			else
+				first, last = string.find(text, "%s+", pos)
+				if first == 1 then
+					pos = last+1
+					first, last = string.find(text, "%s+", pos)
+				end
+			end
+			if first then -- found?
+				table.insert(list, string.sub(text, pos, first-1))
+				pos = last+1
+			else
+				table.insert(list, string.sub(text, pos))
+				break
+			end
+		end
+	end
+	return list
+end
+
+-------------------------------------------------------------------------------
+-- Comments a paragraph.
+-- @param text text to comment with "--", may contain several lines
+-- @return commented text
+
+function comment (text)
+	text = string.gsub(text, "\n", "\n-- ")
+	return "-- " .. text
+end
+
+-------------------------------------------------------------------------------
+-- Wrap a string into a paragraph.
+-- @param s string to wrap
+-- @param w width to wrap to [80]
+-- @param i1 indent of first line [0]
+-- @param i2 indent of subsequent lines [0]
+-- @return wrapped paragraph
+
+function wrap(s, w, i1, i2)
+	w = w or 80
+	i1 = i1 or 0
+	i2 = i2 or 0
+	assert(i1 < w and i2 < w, "the indents must be less than the line width")
+	s = string.rep(" ", i1) .. s
+	local lstart, len = 1, string.len(s)
+	while len - lstart > w do
+		local i = lstart + w
+		while i > lstart and string.sub(s, i, i) ~= " " do i = i - 1 end
+		local j = i
+		while j > lstart and string.sub(s, j, j) == " " do j = j - 1 end
+		s = string.sub(s, 1, j) .. "\n" .. string.rep(" ", i2) ..
+			string.sub(s, i + 1, -1)
+		local change = i2 + 1 - (i - j)
+		lstart = j + change
+		len = len + change
+	end
+	return s
+end
+
+-------------------------------------------------------------------------------
+-- Opens a file, creating the directories if necessary
+-- @param filename full path of the file to open (or create)
+-- @param mode mode of opening
+-- @return file handle
+
+function lfs.open (filename, mode)
+	local f = io.open(filename, mode)
+	if f == nil then
+		filename = string.gsub(filename, "\\", "/")
+		local dir = ""
+		for d in string.gfind(filename, ".-/") do
+			dir = dir .. d
+			lfs.mkdir(dir)
+		end
+		f = io.open(filename, mode)
+	end
+	return f
+end
+
+
+----------------------------------------------------------------------------------
+-- Creates a Logger with LuaLogging, if present. Otherwise, creates a mock logger.
+-- @param options a table with options for the logging mechanism
+-- @return logger object that will implement log methods
+
+function loadlogengine(options)
+	local logenabled = pcall(function()
+		require "logging"
+		require "logging.console"
+	end)
+
+	local logging = logenabled and logging
+
+	if logenabled then
+		if options.filelog then
+			logger = logging.file("luadoc.log") -- use this to get a file log
+		else
+			logger = logging.console("[%level] %message\n")
+		end
+
+		if options.verbose then
+			logger:setLevel(logging.INFO)
+		else
+			logger:setLevel(logging.WARN)
+		end
+
+	else
+		noop = {__index=function(...)
+			return function(...)
+				-- noop
+			end
+		end}
+
+		logger = {}
+		setmetatable(logger, noop)
+	end
+
+	return logger
+end
+
+-------------------------------------------------------------------------------
+-- Check if the current executing platform is windows
+-- @return true if execution platform is windows
+function iswindows()
+    return string.find(_G.package.config:sub(1,1), "\\")
+end
+
+-------------------------------------------------------------------------------
+-- Removes comment markers from the beginning of a string, leaves spaces alone.
+-- @param s string to be trimmed
+-- @return trimmed string
+-- @see trim_comment
+
+function no_trim_comment (s)
+	s = string.gsub(trim(s), "%-%-+ (.*)$", "%1")
+	return s
+end
+
+-------------------------------------------------------------------------------
+-- Appends two strings using original line-end, but if the first one is nil, use to second one.
+-- to be used when using the text without removal of line ends and indentation
+-- @param str1 first string, can be nil
+-- @param str2 second string
+-- @return str1 .. "\n" .. str2, or str2 if str1 is nil
+
+function no_concat (str1, str2)
+	if str1 == nil or string.len(str1) == 0 then
+		return str2
+	else
+		return str1 .. "\n" .. str2
+	end
+end

data/vendor/lua/lib/lua/luaidl.lua

@@ -0,0 +1,113 @@
+--
+-- Project:  LuaIDL
+-- Author:   Ricardo Cosme <rcosme@tecgraf.puc-rio.br>
+-- Filename: init.lua
+-- 
+local assert  = assert
+local error   = error
+local pcall   = pcall
+local require = require
+local type    = type
+local unpack  = unpack
+
+local io      = require "io"
+local os      = require "os"
+local string  = require "string"
+
+module 'luaidl'
+
+local preprocessor  = require 'luaidl.pre'
+local parser        = require 'luaidl.sin'
+
+VERSION = '1.0.5'
+
+---
+-- Auxiliar functions
+--------------------------------------------------------------------------
+
+local function parseAux(idl, options)
+  local status, output = pcall(parser.parse, idl, options)
+  if status then
+    return unpack(output)
+  else
+    return nil, output
+  end
+end
+--------------------------------------------------------------------------
+
+
+---
+-- API
+--------------------------------------------------------------------------
+
+--- Preprocesses an IDL code. 
+-- 
+-- @param idl String with IDL code.
+-- @param options (optional)Table with preprocessor options, the available keys are:
+-- 'incpath', a table with include paths;
+-- 'filename', the IDL filename.
+-- @return String with the given IDL preprocessed.
+function pre(idl, options)
+  return preprocessor.run(idl, options)
+end
+
+--- Preprocesses an IDL file.
+-- 
+-- @param filename The IDL filename.
+-- @param options (optional)Table with preprocessor options, the available keys are:
+-- 'incpath', a table with include paths.
+-- @return String with the given IDL preprocessed.
+-- @see pre
+function prefile(filename, options)
+  local _type = type(filename)
+  if (_type ~= "string") then
+    error(string.format("bad argument #1 to 'prefile' (filename expected, got %s)", _type), 2)
+  end --if
+  local fh, msg = io.open(filename)
+  if not fh then
+    error(msg, 2)
+  end --if
+  if not options then
+    options = { }
+  end
+  options.filename = filename
+  local str = pre(fh:read('*a'), options)
+  fh:close()
+  return str
+end
+
+--- Parses an IDL code.
+-- 
+-- @param idl String with IDL code.
+-- @param options (optional)Table with parser and preprocessor options, the available keys are:
+-- 'callbacks', a table of callback methods;
+-- 'incpath', a table with include paths;
+-- 'filename',the IDL filename.
+-- @return A graph(lua table),
+-- that represents an IDL definition in Lua, for each IDL definition found.
+function parse(idl, options)
+  idl = pre(idl, options)
+  return parseAux(idl, options)
+end
+
+--- Parses an IDL file.
+-- Calls the method 'prefile' with 
+-- the given arguments, and so it parses the output of 'prefile'
+-- calling the method 'parse'.
+-- @param filename The IDL filename.
+-- @param options (optional)Table with parser and preprocessor options, the available keys are:
+-- 'callbacks', a table of callback methods;
+-- 'incpath', a table with include paths.
+-- @return A graph(lua table),
+-- that represents an IDL definition in Lua, for each IDL definition found.
+-- @see prefile 
+-- @see parse
+function parsefile(filename, options)
+  local _type = type(filename)
+  if (_type ~= "string") then
+    error(string.format("bad argument #1 to 'parsefile' (filename expected, got %s)", _type), 2)
+  end
+  local stridl = prefile(filename, options)
+  return parseAux(stridl, options)
+end
+--------------------------------------------------------------------------