rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/pl/sip.lua

@@ -0,0 +1,344 @@
+--- Simple Input Patterns (SIP).
+-- SIP patterns start with '$', then a
+-- one-letter type, and then an optional variable in curly braces.
+--
+--    sip.match('$v=$q','name="dolly"',res)
+--    ==> res=={'name','dolly'}
+--    sip.match('($q{first},$q{second})','("john","smith")',res)
+--    ==> res=={second='smith',first='john'}
+--
+-- ''Type names''
+--
+--    v    identifier
+--    i     integer
+--    f     floating-point
+--    q    quoted string
+--    ([{<  match up to closing bracket
+--
+-- See @{08-additional.md.Simple_Input_Patterns|the Guide}
+--
+-- @module pl.sip
+
+if not rawget(_G,'loadstring') then -- Lua 5.2 full compatibility
+    loadstring = load
+    unpack = table.unpack
+end
+
+local append,concat = table.insert,table.concat
+local concat = table.concat
+local ipairs,loadstring,type,unpack = ipairs,loadstring,type,unpack
+local io,_G = io,_G
+local print,rawget = print,rawget
+
+local patterns = {
+    FLOAT = '[%+%-%d]%d*%.?%d*[eE]?[%+%-]?%d*',
+    INTEGER = '[+%-%d]%d*',
+    IDEN = '[%a_][%w_]*',
+    FILE = '[%a%.\\][:%][%w%._%-\\]*',
+    OPTION = '[%a_][%w_%-]*',
+}
+
+local function assert_arg(idx,val,tp)
+    if type(val) ~= tp then
+        error("argument "..idx.." must be "..tp, 2)
+    end
+end
+
+
+--[[
+module ('pl.sip',utils._module)
+]]
+
+local sip = {}
+
+local brackets = {['<'] = '>', ['('] = ')', ['{'] = '}', ['['] = ']' }
+local stdclasses = {a=1,c=0,d=1,l=1,p=0,u=1,w=1,x=1,s=0}
+
+local _patterns = {}
+
+
+local function group(s)
+    return '('..s..')'
+end
+
+-- escape all magic characters except $, which has special meaning
+-- Also, un-escape any characters after $, so $( passes through as is.
+local function escape (spec)
+    --_G.print('spec',spec)
+    local res = spec:gsub('[%-%.%+%[%]%(%)%^%%%?%*]','%%%1'):gsub('%$%%(%S)','$%1')
+    --_G.print('res',res)
+    return res
+end
+
+local function imcompressible (s)
+    return s:gsub('%s+','\001')
+end
+
+-- [handling of spaces in patterns]
+-- spaces may be 'compressed' (i.e will match zero or more spaces)
+-- unless this occurs within a number or an identifier. So we mark
+-- the four possible imcompressible patterns first and then replace.
+-- The possible alnum patterns are v,f,a,d,x,l and u.
+local function compress_spaces (s)
+    s = s:gsub('%$[vifadxlu]%s+%$[vfadxlu]',imcompressible)
+    s = s:gsub('[%w_]%s+[%w_]',imcompressible)
+    s = s:gsub('[%w_]%s+%$[vfadxlu]',imcompressible)
+    s = s:gsub('%$[vfadxlu]%s+[%w_]',imcompressible)
+    s = s:gsub('%s+','%%s*')
+    s = s:gsub('\001',' ')
+    return s
+end
+
+local pattern_map = {
+  v = group(patterns.IDEN),
+  i = group(patterns.INTEGER),
+  f = group(patterns.FLOAT),
+  o = group(patterns.OPTION),
+  r = '(%S.*)',
+  p = '([%a]?[:]?[\\/%.%w_]+)'
+}
+
+function sip.custom_pattern(flag,patt)
+    pattern_map[flag] = patt
+end
+
+--- convert a SIP pattern into the equivalent Lua string pattern.
+-- @param spec a SIP pattern
+-- @param options a table; only the <code>at_start</code> field is
+-- currently meaningful and esures that the pattern is anchored
+-- at the start of the string.
+-- @return a Lua string pattern.
+function sip.create_pattern (spec,options)
+    assert_arg(1,spec,'string')
+    local fieldnames,fieldtypes = {},{}
+
+    if type(spec) == 'string' then
+        spec = escape(spec)
+    else
+        local res = {}
+        for i,s in ipairs(spec) do
+            res[i] = escape(s)
+        end
+        spec = concat(res,'.-')
+    end
+
+    local kount = 1
+
+    local function addfield (name,type)
+        if not name then name = kount end
+        if fieldnames then append(fieldnames,name) end
+        if fieldtypes then fieldtypes[name] = type end
+        kount = kount + 1
+    end
+
+    local named_vars, pattern
+    named_vars = spec:find('{%a+}')
+    pattern = '%$%S'
+
+    if options and options.at_start then
+        spec = '^'..spec
+    end
+    if spec:sub(-1,-1) == '$' then
+        spec = spec:sub(1,-2)..'$r'
+        if named_vars then spec = spec..'{rest}' end
+    end
+
+
+    local names
+
+    if named_vars then
+        names = {}
+        spec = spec:gsub('{(%a+)}',function(name)
+            append(names,name)
+            return ''
+        end)
+    end
+    spec = compress_spaces(spec)
+
+    local k = 1
+    local err
+    local r = (spec:gsub(pattern,function(s)
+        local type,name
+        type = s:sub(2,2)
+        if names then name = names[k]; k=k+1 end
+        -- this kludge is necessary because %q generates two matches, and
+        -- we want to ignore the first. Not a problem for named captures.
+        if not names and type == 'q' then
+            addfield(nil,'Q')
+        else
+            addfield(name,type)
+        end
+        local res
+        if pattern_map[type] then
+            res = pattern_map[type]
+        elseif type == 'q' then
+            -- some Lua pattern matching voodoo; we want to match '...' as
+            -- well as "...", and can use the fact that %n will match a
+            -- previous capture. Adding the extra field above comes from needing
+            -- to accomodate the extra spurious match (which is either ' or ")
+            addfield(name,type)
+            res = '(["\'])(.-)%'..(kount-2)
+        else
+            local endbracket = brackets[type]
+            if endbracket then
+                res = '(%b'..type..endbracket..')'
+            elseif stdclasses[type] or stdclasses[type:lower()] then
+                res = '(%'..type..'+)'
+            else
+                err = "unknown format type or character class"
+            end
+        end
+        return res
+    end))
+    --print(r,err)
+    if err then
+        return nil,err
+    else
+        return r,fieldnames,fieldtypes
+    end
+end
+
+
+local function tnumber (s)
+    return s == 'd' or s == 'i' or s == 'f'
+end
+
+function sip.create_spec_fun(spec,options)
+    local fieldtypes,fieldnames
+    local ls = {}
+    spec,fieldnames,fieldtypes = sip.create_pattern(spec,options)
+    if not spec then return spec,fieldnames end
+    local named_vars = type(fieldnames[1]) == 'string'
+    for i = 1,#fieldnames do
+        append(ls,'mm'..i)
+    end
+    local fun = ('return (function(s,res)\n\tlocal %s = s:match(%q)\n'):format(concat(ls,','),spec)
+    fun = fun..'\tif not mm1 then return false end\n'
+    local k=1
+    for i,f in ipairs(fieldnames) do
+        if f ~= '_' then
+            local var = 'mm'..i
+            if tnumber(fieldtypes[f]) then
+                var = 'tonumber('..var..')'
+            elseif brackets[fieldtypes[f]] then
+                var = var..':sub(2,-2)'
+            end
+            if named_vars then
+                fun = ('%s\tres.%s = %s\n'):format(fun,f,var)
+            else
+                if fieldtypes[f] ~= 'Q' then -- we skip the string-delim capture
+                    fun = ('%s\tres[%d] = %s\n'):format(fun,k,var)
+                    k = k + 1
+                end
+            end
+        end
+    end
+    return fun..'\treturn true\nend)\n', named_vars
+end
+
+--- convert a SIP pattern into a matching function.
+-- The returned function takes two arguments, the line and an empty table.
+-- If the line matched the pattern, then this function return true
+-- and the table is filled with field-value pairs.
+-- @param spec a SIP pattern
+-- @param options optional table; {anywhere=true} will stop pattern anchoring at start
+-- @return a function if successful, or nil,<error>
+function sip.compile(spec,options)
+    assert_arg(1,spec,'string')
+    local fun,names = sip.create_spec_fun(spec,options)
+    if not fun then return nil,names end
+    if rawget(_G,'_DEBUG') then print(fun) end
+    local chunk,err = loadstring(fun,'tmp')
+    if err then return nil,err end
+    return chunk(),names
+end
+
+local cache = {}
+
+--- match a SIP pattern against a string.
+-- @param spec a SIP pattern
+-- @param line a string
+-- @param res a table to receive values
+-- @param options (optional) option table
+-- @return true or false
+function sip.match (spec,line,res,options)
+    assert_arg(1,spec,'string')
+    assert_arg(2,line,'string')
+    assert_arg(3,res,'table')
+    if not cache[spec] then
+        cache[spec] = sip.compile(spec,options)
+    end
+    return cache[spec](line,res)
+end
+
+--- match a SIP pattern against the start of a string.
+-- @param spec a SIP pattern
+-- @param line a string
+-- @param res a table to receive values
+-- @return true or false
+function sip.match_at_start (spec,line,res)
+    return sip.match(spec,line,res,{at_start=true})
+end
+
+--- given a pattern and a file object, return an iterator over the results
+-- @param spec a SIP pattern
+-- @param f a file - use standard input if not specified.
+function sip.fields (spec,f)
+    assert_arg(1,spec,'string')
+    f = f or io.stdin
+    local fun,err = sip.compile(spec)
+    if not fun then return nil,err end
+    local res = {}
+    return function()
+        while true do
+            local line = f:read()
+            if not line then return end
+            if fun(line,res) then
+                local values = res
+                res = {}
+                return unpack(values)
+            end
+        end
+    end
+end
+
+--- register a match which will be used in the read function.
+-- @param spec a SIP pattern
+-- @param fun a function to be called with the results of the match
+-- @see read
+function sip.pattern (spec,fun)
+    assert_arg(1,spec,'string')
+    local pat,named = sip.compile(spec)
+    append(_patterns,{pat=pat,named=named,callback=fun or false})
+end
+
+--- enter a loop which applies all registered matches to the input file.
+-- @param f a file object; if nil, then io.stdin is assumed.
+function sip.read (f)
+    local owned,err
+    f = f or io.stdin
+    if type(f) == 'string' then
+        f,err = io.open(f)
+        if not f then return nil,err end
+        owned = true
+    end
+    local res = {}
+    for line in f:lines() do
+        for _,item in ipairs(_patterns) do
+            if item.pat(line,res) then
+                if item.callback then
+                    if item.named then
+                        item.callback(res)
+                    else
+                        item.callback(unpack(res))
+                    end
+                end
+                res = {}
+                break
+            end
+        end
+    end
+    if owned then f:close() end
+end
+
+return sip

data/vendor/lua/lib/lua/pl/strict.lua

@@ -0,0 +1,70 @@
+--- Checks uses of undeclared global variables.
+-- All global variables must be 'declared' through a regular assignment
+-- (even assigning nil will do) in a main chunk before being used
+-- anywhere or assigned to inside a function.
+-- @module pl.strict
+
+require 'debug'
+local getinfo, error, rawset, rawget = debug.getinfo, error, rawset, rawget
+local handler,hooked
+
+local mt = getmetatable(_G)
+if mt == nil then
+  mt = {}
+  setmetatable(_G, mt)
+elseif mt.hook then
+    hooked = true
+end
+
+-- predeclaring _PROMPT keeps the Lua Interpreter happy
+mt.__declared = {_PROMPT=true}
+
+local function what ()
+  local d = getinfo(3, "S")
+  return d and d.what or "C"
+end
+
+mt.__newindex = function (t, n, v)
+  if not mt.__declared[n] then
+    local w = what()
+    if w ~= "main" and w ~= "C" then
+      error("assign to undeclared variable '"..n.."'", 2)
+    end
+    mt.__declared[n] = true
+  end
+  rawset(t, n, v)
+end
+
+handler = function(t,n)
+  if not mt.__declared[n] and what() ~= "C" then
+    error("variable '"..n.."' is not declared", 2)
+  end
+  return rawget(t, n)
+end
+
+function package.strict (mod)
+    local mt = getmetatable(mod)
+    if mt == nil then
+      mt = {}
+      setmetatable(mod, mt)
+    end
+    mt.__declared = {}
+    mt.__newindex = function(t, n, v)
+        mt.__declared[n] = true
+        rawset(t, n, v)
+    end
+    mt.__index = function(t,n)
+      if not mt.__declared[n] then
+        error("variable '"..n.."' is not declared", 2)
+      end
+      return rawget(t, n)
+    end
+end
+
+if not hooked then
+    mt.__index = handler
+else
+    mt.hook(handler)
+end
+
+

data/vendor/lua/lib/lua/pl/stringio.lua

@@ -0,0 +1,158 @@
+--- Reading and writing strings using file-like objects. <br>
+--
+--    f = stringio.open(text)
+--    l1 = f:read()  -- read first line
+--    n,m = f:read ('*n','*n') -- read two numbers
+--    for line in f:lines() do print(line) end -- iterate over all lines
+--    f = stringio.create()
+--    f:write('hello')
+--    f:write('dolly')
+--    assert(f:value(),'hellodolly')
+--
+-- See  @{03-strings.md.File_style_I_O_on_Strings|the Guide}.
+-- @module pl.stringio
+
+if not rawget(_G,'loadstring') then -- Lua 5.2 full compatibility
+    unpack = table.unpack
+end
+
+local getmetatable,tostring,unpack,tonumber = getmetatable,tostring,unpack,tonumber
+local concat,append = table.concat,table.insert
+
+local stringio = {}
+
+--- Writer class
+local SW = {}
+SW.__index = SW
+
+local function xwrite(self,...)
+    local args = {...} --arguments may not be nil!
+    for i = 1, #args do
+        append(self.tbl,args[i])
+    end
+end
+
+function SW:write(arg1,arg2,...)
+    if arg2 then
+        xwrite(self,arg1,arg2,...)
+    else
+        append(self.tbl,arg1)
+    end
+end
+
+function SW:writef(fmt,...)
+    self:write(fmt:format(...))
+end
+
+function SW:value()
+    return concat(self.tbl)
+end
+
+function SW:__tostring()
+    return self:value()
+end
+
+function SW:close() -- for compatibility only
+end
+
+function SW:seek()
+end
+
+--- Reader class
+local SR = {}
+SR.__index = SR
+
+function SR:_read(fmt)
+    local i,str = self.i,self.str
+    local sz = #str
+    if i > sz then return nil end
+    local res
+    if fmt == '*l' or fmt == '*L' then
+        local idx = str:find('\n',i) or (sz+1)
+        res = str:sub(i,fmt == '*l' and idx-1 or idx)
+        self.i = idx+1
+    elseif fmt == '*a' then
+        res = str:sub(i)
+        self.i = sz
+    elseif fmt == '*n' then
+        local _,i2,i2,idx
+        _,idx = str:find ('%s*%d+',i)
+        _,i2 = str:find ('^%.%d+',idx+1)
+        if i2 then idx = i2 end
+        _,i2 = str:find ('^[eE][%+%-]*%d+',idx+1)
+        if i2 then idx = i2 end
+        local val = str:sub(i,idx)
+        res = tonumber(val)
+        self.i = idx+1
+    elseif type(fmt) == 'number' then
+        res = str:sub(i,i+fmt-1)
+        self.i = i + fmt
+    else
+        error("bad read format",2)
+    end
+    return res
+end
+
+function SR:read(...)
+    if select('#',...) == 0 then
+        return self:_read('*l')
+    else
+        local res, fmts = {},{...}
+        for i = 1, #fmts do
+            res[i] = self:_read(fmts[i])
+        end
+        return unpack(res)
+    end
+end
+
+function SR:seek(whence,offset)
+    local base
+    whence = whence or 'cur'
+    offset = offset or 0
+    if whence == 'set' then
+        base = 1
+    elseif whence == 'cur' then
+        base = self.i
+    elseif whence == 'end' then
+        base = #self.str
+    end
+    self.i = base + offset
+    return self.i
+end
+
+function SR:lines(...)
+    local n, args = select('#',...)
+    if n > 0 then
+        args = {...}
+    end
+    return function()
+        if n == 0 then
+            return self:_read '*l'
+        else
+            return self:read(unpack(args))
+        end
+    end
+end
+
+function SR:close() -- for compatibility only
+end
+
+--- create a file-like object which can be used to construct a string.
+-- The resulting object has an extra <code>value()</code> method for
+-- retrieving the string value.
+-- @usage f = create(); f:write('hello, dolly\n'); print(f:value())
+function stringio.create()
+    return setmetatable({tbl={}},SW)
+end
+
+--- create a file-like object for reading from a given string.
+-- @param s The input string.
+function stringio.open(s)
+    return setmetatable({str=s,i=1},SR)
+end
+
+function stringio.lines(s,...)
+    return stringio.open(s):lines(...)
+end
+
+return stringio