rufus-lua-win 5.1.5

data/vendor/lua/lib/lua/verbose_require.lua

@@ -0,0 +1,11 @@
+do
+   local xrequire, n, ind = require, 0, "| "
+   function require (x)
+      print(ind:rep(n).."/ require: "..x)
+      n=n+1
+      local y = xrequire(x) 
+      n=n-1
+      print(ind:rep(n).."\\_"); 
+      return y
+   end
+end

data/vendor/lua/lib/lua/vstruct.lua

@@ -0,0 +1,86 @@
+-- vstruct, the versatile struct library
+
+-- Copyright (C) 2011 Ben "ToxicFrog" Kelly; see COPYING
+
+local table,math,type,require,assert,_unpack = table,math,type,require,assert,unpack
+local debug = debug
+local print = print
+
+module "vstruct"
+
+_VERSION = "1.1"
+
+cursor = require "vstruct.cursor"
+
+local ast    = require "vstruct.ast"
+
+-- cache control for the parser
+-- true: cache is read/write (new formats will be cached, old ones retrieved)
+-- false: cache is read-only
+-- nil: cache is disabled
+cache = true
+
+-- this is needed by some IO formats as well as init itself
+-- FIXME: should it perhaps be a vstruct internal function rather than
+-- installing it in math?
+if not math.trunc then
+	function math.trunc(n)
+		if n < 0 then
+			return math.ceil(n)
+		else
+			return math.floor(n)
+		end
+	end
+end
+
+-- turn an int into a list of booleans
+-- the length of the list will be the smallest number of bits needed to
+-- represent the int
+function explode(int, size)
+    assert(int, "vstruct.explode: missing argument")
+    size = size or 0
+    
+    local mask = {}
+    while int ~= 0 or #mask < size do
+        table.insert(mask, int % 2 ~= 0)
+        int = math.trunc(int/2)
+    end
+    return mask
+end
+
+-- turn a list of booleans into an int
+-- the converse of explode
+function implode(mask, size)
+    size = size or #mask
+    
+    local int = 0
+    for i=size,1,-1 do
+        int = int*2 + ((mask[i] and 1) or 0)
+    end
+    return int
+end
+
+-- Given a format string, a buffer or file, and an optional third argument,
+-- unpack data from the buffer or file according to the format string
+function unpack(fmt, ...)
+    assert(type(fmt) == "string", "invalid first argument to vstruct.unpack")
+    
+    local t = ast.parse(fmt)
+    return t.unpack(...)
+end
+
+-- Given a format string, an optional file-like, and a table of data,
+-- pack data into the file-like (or create and return a string of packed data)
+-- according to the format string
+function pack(fmt, ...)
+    local t = ast.parse(fmt)
+    return t.pack(...)
+end
+
+-- Given a format string, compile it and return a table containing the original
+-- source and the pack/unpack functions derived from it.
+function compile(fmt)
+	return ast.parse(fmt)
+end
+
+return _M

data/vendor/lua/lib/lua/vstruct/ast.lua

@@ -0,0 +1,192 @@
+-- Abstract Syntax Tree module for vstruct
+-- This module implements the parser for vstruct format definitions. It is a
+-- fairly simple recursive-descent parser that constructs an AST using Lua
+-- tables, and then generates lua source from it.
+
+-- See ast/*.lua for the implementations of various node types in the AST,
+-- and see lexer.lua for the implementation of the lexer.
+
+-- Copyright (c) 2011 Ben "ToxicFrog" Kelly
+
+local struct = require "vstruct"
+local lexer  = require "vstruct.lexer"
+
+local ast = {}
+local cache = {}
+
+-- load the implementations of the various AST node types
+for _,node in ipairs { "IO", "List", "Name", "Table", "Repeat", "Generator", "Root", "Bitpack" } do
+    ast[node] = require ((...).."."..node)
+end
+
+-- given a source string, compile it
+-- returns a table containing pack and unpack functions and the original
+-- source - see README#vstruct.compile for a description.
+--
+-- if (struct.cache) is non-nil, will return the cached version, if present
+-- if (struct.cache) is true, will create a new cache entry, if needed
+function ast.parse(source)
+    if struct.cache ~= nil and cache[source] then
+        return cache[source]
+    end
+
+    local lex = lexer(source)
+    local root = ast.Root(ast.List())
+    
+    for node in (function() return ast.next(lex) end) do
+        root:append(node)
+    end
+    
+    root = root:gen(ast.Generator())
+    
+    if struct.cache == true then
+        cache[source] = root
+    end
+    
+    return root
+end
+
+-- used by the rest of the parser to report syntax errors
+function ast.error(lex, expected)
+    error("vstruct: parsing format string at "..lex.where()..": expected "..expected..", got "..lex.peek().type)
+end
+
+-- Everything below this line is internal to the recursive descent parser
+
+function ast.name(lex)
+    local name = lex.next().text
+    local next = lex.peek()
+    
+    if next and next.type == "number" and not lex.whitespace() then
+        return ast.IO(name, lex.next().text)
+    else
+        return ast.IO(name, nil)
+    end
+end
+
+function ast.key(lex)
+    local name = lex.next().text
+    local next = lex.peek()
+    
+    next = ast.next(lex)
+    if next.tag == "io" or next.tag == "table" then
+        return ast.Name(name, next)
+    else
+        ast.error(lex, "value (field or table)")
+    end
+end
+
+function ast.next(lex)
+    local tok = lex.peek()
+    
+    if not tok then
+        return nil
+    end
+    
+    if tok.type == '(' then
+        return ast.group(lex)
+    
+    elseif tok.type == '{' then
+        return ast.table(lex)
+    
+    elseif tok.type == '[' then
+        return ast.bitpack(lex)
+        
+    elseif tok.type == "name" then
+        return ast.name(lex)
+    
+    elseif tok.type == "key" then
+        return ast.key(lex)
+        
+    elseif tok.type == "number" then
+        return ast.repetition(lex)
+        
+    elseif tok.type == "control" then
+        return ast.control(lex)
+        
+    else
+        ast.error(lex, "'(', '{', '[', name, number, control, or io specifier")
+    end
+end
+
+function ast.repetition(lex)
+    local count = tonumber(lex.next().text)
+    ast.require(lex, "*");
+
+    return ast.Repeat(count, ast.next(lex))
+end
+
+function ast.group(lex)
+    ast.require(lex, '(')
+    
+    local group = ast.List()
+    group.tag = "group"
+    
+    while lex.peek().type ~= ')' do
+        group:append(ast.next(lex))
+    end
+    
+    ast.require(lex, ')')
+    return group
+end
+
+function ast.table(lex)
+    ast.require(lex, '{')
+    
+    local group = ast.Table()
+    
+    while lex.peek().type ~= '}' do
+        group:append(ast.next(lex))
+    end
+    
+    ast.require(lex, '}')
+    return group
+end
+
+function ast.bitpack(lex)
+    ast.require(lex, "[")
+    
+    local bitpack = ast.Bitpack(tonumber(ast.require(lex, "number").text))
+    
+    ast.require(lex, "|")
+    
+    while lex.peek().type ~= "]" do
+        bitpack:append(ast.next(lex))
+    end
+    
+    ast.require(lex, "]")
+    bitpack:finalize()
+    return bitpack
+end
+
+function ast.require(lex, type)
+    local t = lex.next()
+    
+    if t.type ~= type then
+        ast.error(lex, type)
+    end
+    
+    return t
+end
+
+return ast
+
+--[[
+
+format -> commands
+
+command -> repeat | bitpack | group | named | value | control 
+
+repeat -> NUMBER '*' command | command '*' NUMBER
+bitpack -> NUMBER '|' commands '|'
+group -> '(' commands ')'
+
+named -> NAME ':' value
+value -> table | primitive
+table -> '{' commands '}'
+
+primitive -> ATOM NUMBERS
+
+control -> SEEK NUMBER | ENDIANNESS
+
+--]]

data/vendor/lua/lib/lua/vstruct/ast/Bitpack.lua

@@ -0,0 +1,33 @@
+local List = require "vstruct.ast.List"
+
+return function(size)
+    local Bitpack = {
+        tag = "bitpack";
+        width = size;
+    }
+    
+    local children = List();
+    
+    function Bitpack:show()
+        print("bitpack", size)
+        children:show()
+    end
+    
+    function Bitpack:append(node)
+        children:append(node)
+        assert(children.width, "bitpacks cannot contain variable-width fields")
+        assert(children.width <= size*8, "bitpack contents are larger than containing bitpack")
+    end
+    
+    function Bitpack:finalize()
+        assert(children.width == size*8, "bitpack contents are smaller than containing bitpack")
+    end
+    
+    function Bitpack:gen(generator)
+        generator:bitpack(size)
+        children:gen(generator)
+        generator:bitpack()
+    end
+    
+    return Bitpack
+end

data/vendor/lua/lib/lua/vstruct/ast/Generator.lua

@@ -0,0 +1,174 @@
+local unpackenv = require "vstruct.unpack"
+local packenv   = require "vstruct.pack"
+local cursor    = require "vstruct.cursor"
+
+return function()
+    local Generator = {}
+    
+    local source = {}
+    local data = {}
+    local readahead = nil
+    local ra_left = nil
+    local indent = 0
+    local bitpack = false
+    local loopmul = 1
+    
+    local function append(...)
+        source[#source+1] = string.rep(" ", indent)..string.format(...)
+    end
+    
+    local function ref(v)
+        data[#data+1] = v
+        return #data
+    end
+    
+    function Generator:init()
+        append('initialize(...)')
+        append('')
+    end
+    
+    function Generator:finalize()
+        append('')
+        append('return finalize()')
+        
+        local s = table.concat(source, "\n")
+        local f,err = loadstring(s)
+        
+        if not f then
+            error(err.."\n--- internal error in code generator ---\n--- report this as a bug in vstruct ---\n"..s.."\n--- internal error in code generator ---\n")
+        end
+        
+        local u_env = unpackenv(data)
+        local p_env = packenv(data)
+        
+        local _unpack = unpack
+        
+        local function unpack(fd, data)
+            -- autobox strings
+            if type(fd) == "string" then
+                fd = cursor(fd)
+            end
+            
+            -- fd must have file duck type
+            assert(fd.read, "invalid fd argument to vstruct.unpack: must be a string or file-like object")
+            
+            -- data must be true ('return unpacked results')
+            -- or false/absent ('create new table')
+            -- or a table to fill in
+            assert(data == nil or type(data) == "boolean" or type(data) == "table"
+                , "invalid data argument to vstruct.unpack: if present, must be table or boolean") 
+            
+            setfenv(f, u_env)
+            
+            if data == true then
+                return _unpack(f(fd, {}))
+            else
+                return f(fd, data or {})
+            end
+        end
+        
+        local function pack(fd, data)
+            if fd and not data then
+                data,fd = fd,nil
+            end
+            
+            assert(type(data) == "table", "invalid data argument to vstruct.pack: must be a table")
+            
+            local realfd
+            
+            if not fd or type(fd) == "string" then
+                realfd = cursor(fd or "")
+            else
+                realfd = fd
+            end
+            
+            setfenv(f, p_env)
+            local result = f(realfd, data)
+            if realfd == fd then
+                return result
+            else
+                return result.str
+            end
+        end
+        
+        return { pack=pack, unpack=unpack, source=s }
+    end
+
+    function Generator:io(name, hasvalue, width, args)
+        append('%sio(%q, %s, %s%s%s)'
+            , bitpack and "bp" or ""
+            , name
+            , tostring(hasvalue)
+            , tostring(width)
+            , args and ", " or ""
+            , args or "")
+
+        if readahead then
+            ra_left = ra_left - width * loopmul
+            assert(ra_left >= 0
+                , string.format("code generation consistency failure: readahead=%d, left=%f"
+                    , readahead
+                    , ra_left))
+            if ra_left == 0 then
+                readahead = nil
+                ra_left = nil
+                append('-- end readahead')
+            end
+        end
+    end
+    
+    function Generator:readahead(n)
+        if n and n > 0 and not readahead then
+            readahead = n
+            ra_left = n * loopmul
+            append('readahead(%d)', n)
+        end
+    end
+    
+    function Generator:startloop(n)
+        append('for _=1,%d do', n)
+        indent = indent + 2
+        loopmul = loopmul * n
+    end
+    
+    function Generator:endloop(n)
+        loopmul = loopmul / n
+        indent = indent - 2
+        append('end')
+    end
+    
+    function Generator:starttable()
+        append('push()')
+        indent = indent + 2
+    end
+    
+    function Generator:endtable()
+        indent = indent - 2
+        append('pop()')
+    end
+    
+    function Generator:name(name)
+        append('name %q', name)
+    end
+    
+    function Generator:bitpack(size)
+        if size then
+            if bitpack then
+                error("nested bitpacks are not permitted")
+            end
+            append('bitpack(%d)', size)
+            bitpack = size
+            if readahead then
+                ra_left = ra_left * 8
+            end
+        else
+            append('bitpack(nil)')
+            bitpack = false
+            if readahead then
+                ra_left = ra_left / 8
+            end
+        end
+    end
+    
+    return Generator
+end