rufus-lua-win 5.1.5

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

@@ -0,0 +1,45 @@
+local io = require "vstruct.io"
+
+local function argv2str(argv)
+    local args = {}
+    
+    for i=1,argv.n do
+        args[i] = tostring(argv[i])
+    end
+    
+    return table.concat(args, ", ")
+end
+
+return function(name, args)
+    local argv = { n = 0 }
+    
+    if args then
+        local args = args..","
+        local n = 1
+        
+        for arg in args:gmatch("([^,]*),") do
+            if #arg == 0 then arg = nil
+            elseif tonumber(arg) then arg = tonumber(arg)
+            end
+            argv.n = argv.n +1
+            argv[argv.n] = arg
+        end
+    end
+    
+    local width = io(name, "width", unpack(argv, 1, argv.n))
+    
+    local IO = {
+        tag = "io";
+        width = width;
+    }
+    
+    function IO:show()
+        print("io", name, width)
+    end
+    
+    function IO:gen(generator)
+        generator:io(name, io(name, "hasvalue"), width, argv.n > 0 and argv2str(argv))
+    end
+    
+    return IO
+end

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

@@ -0,0 +1,56 @@
+return function()
+    local List = {
+        tag = "list";
+        width = 0;
+    }
+    local child
+    
+    function List:append(node)
+        if node.width then
+            if not child then
+                child = {
+                    tag = "sublist";
+                    width = 0;
+                    show = self.show;
+                    unpack = self.unpack;
+                    pack = self.pack;
+                    gen = self.gen;
+                }
+                self[#self+1] = child
+            end
+            
+            if self.width then
+                self.width = self.width + node.width
+            end
+            
+            child[#child+1] = node
+            child.width = child.width + node.width
+        else
+            child = nil
+            self.width = nil
+            self[#self+1] = node
+        end
+    end
+    
+    function List:show(data)
+        for i,node in ipairs(self) do
+            if node.show then
+                node:show()
+            end
+        end
+    end
+    
+    function List:gen(generator)
+        if self.width then
+            generator:readahead(self.width)
+        end
+        for i,v in ipairs(self) do
+            v:gen(generator)
+        end
+        if self.width then
+            generator:readahead(nil)
+        end
+    end
+    
+    return List
+end

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

@@ -0,0 +1,20 @@
+return function(key, value)
+    local Name = {
+        tag = "name";
+        width = value.width;
+        key = key;
+        value = value;
+    }
+    
+    function Name:show()
+        io.write("name\t"..key.."\t")
+        value:show()
+    end
+    
+    function Name:gen(generator)
+        generator:name(key)
+        value:gen(generator)
+    end
+    
+    return Name
+end

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

@@ -0,0 +1,23 @@
+return function(count, value)
+    local Repeat = {
+        tag = "repeat";
+        width = (value.width and count * value.width) or nil;
+        count = count;
+        value = value;
+    }
+    
+    function Repeat:show()
+        io.write("repeat\t"..tostring(count).."\t")
+        value:show()
+    end
+    
+    function Repeat:gen(generator)
+        if count > 0 then
+            generator:startloop(count)
+            value:gen(generator)
+            generator:endloop(count)
+        end
+    end
+    
+    return Repeat
+end

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

@@ -0,0 +1,19 @@
+return function(child)
+    local Root = {}
+    
+    function Root:gen(generator)
+        generator:init()
+        child:gen(generator)
+        return generator:finalize()
+    end
+    
+    function Root:append(...)
+        return child:append(...)
+    end
+    
+    function Root:show()
+        return child:show()
+    end
+    
+    return Root
+end

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

@@ -0,0 +1,65 @@
+local List = require "vstruct.ast.List"
+
+local WRAPPER = {}
+
+return function()
+    local Table = {
+        tag = "table";
+        list = List();
+    }
+    
+    setmetatable(Table, { __index = Table.list })
+    
+    function Table:append(...)
+        return Table.list:append(...)
+    end
+    
+    function Table:show()
+        print("table", Table.width, #Table.list)
+        self.list:show()
+    end
+    
+    function Table:unpack(fd, buf, data)
+        local value = {}
+        self.list:unpack(fd, buf, value)
+        return value
+    end
+    
+    function Table:pack(fd, data, key)
+        local function wrapdata(t)
+            local key = nil
+            local n = 1
+            
+            local function next()
+                local v
+                if key ~= nil then
+                    v,key = t[key],nil
+                else
+                    v,n = t[n],n+1
+                end
+                return v
+            end
+            
+            local function setkey(self, newkey)
+                key = newkey
+            end
+            
+            return setmetatable({ next=next, key=setkey }, WRAPPER)
+        end
+        
+        if getmetatable(data) == WRAPPER then
+            return self.list:pack(fd, wrapdata(data:next()), key)
+        else
+            return self.list:pack(fd, wrapdata(data), key)
+        end
+    end
+    
+    function Table:gen(generator)
+        generator:starttable()
+        self.list:gen(generator)
+        generator:endtable()
+    end
+    
+    return Table
+end
+

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

@@ -0,0 +1,81 @@
+-- cursor - a wrapper for strings that makes them look like files
+-- exports: seek read write
+-- read only supports numeric amounts
+
+-- Copyright (c) 2011 Ben "ToxicFrog" Kelly; see COPYING
+
+local cursor = {}
+
+-- like fseek
+-- seeking past the end of the string is permitted
+-- reads will return EOF, writes will fill in the intermediate space with nuls
+-- seeking past the start of the string is a soft error
+function cursor:seek(whence, offset)
+	whence = whence or "cur"
+	offset = offset or 0
+	
+	if whence == "set" then
+		self.pos = offset
+	elseif whence == "cur" then
+		self.pos = self.pos + offset
+	elseif whence == "end" then
+		self.pos = #self.str + offset
+	else
+		error "bad argument #1 to seek"
+	end
+	
+	if self.pos < 0 then
+		self.pos = 0
+		return nil,"attempt to seek prior to start of file"
+	end
+	
+	return self.pos
+end
+
+-- read n bytes from the current position
+-- reads longer than the string can satisfy return as much as it can
+-- reads while the position is at the end return nil,"eof"
+function cursor:read(n)
+	if self.pos >= #self.str then
+		return nil,"eof"
+	end
+	
+    if n == "*a" then
+        n = #self.str
+    end
+    
+	local buf = self.str:sub(self.pos+1, self.pos + n)
+	self.pos = math.min(self.pos + n, #self.str)
+	
+	return buf
+end
+
+-- write the contents of the buffer at the current position, overwriting
+-- any data already present
+-- if the write pointer is past the end of the string, also fill in the
+-- intermediate space with nuls
+function cursor:write(buf)
+	if self.pos > #self.str then
+		self.str = self.str .. string.char(0):rep(self.pos - #self.str)
+	end
+
+	self.str = self.str:sub(1, self.pos)
+		.. buf
+		.. self.str:sub(self.pos + #buf + 1, -1)
+	self.pos = self.pos + #buf
+
+	return self
+end	
+
+cursor.__index = cursor
+
+setmetatable(cursor, {
+    __call = function(self, source)
+    	assert(type(source) == "string", "invalid first argument to cursor()")
+        return setmetatable(
+	    	{ str = source, pos = 0 },
+            cursor)
+    end;
+})
+
+return cursor

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

@@ -0,0 +1,45 @@
+-- The loader for individual IO formats for vstruct.
+-- Returns the "io function", which is called with:
+-- * an IO type, such as 'x' or 'c'
+-- * an IO operation, such as 'pack' or 'width'
+-- * some (type x operation) specific other arguments
+-- upon which it will attempt to load the handler for that operation from the
+-- module vstruct.io.<type> and call it.
+
+-- Copyright (c) 2011 Ben "ToxicFrog" Kelly
+
+local defaults = require "vstruct.io.defaults"
+
+local formats = {}
+
+local function iorequire(format)
+    local r,v = pcall(require, "vstruct.io."..format)
+
+    if not r then
+        error("vstruct: no support for format '"..format.."':\n"..tostring(v))
+    end
+    
+    return v                   
+end
+
+local controlnames = {
+    seekf   = "+";
+    seekb   = "-";
+    seekto  = "@";
+    bigendian   = ">";
+    littleendian= "<";
+    hostendian  = "=";
+}
+
+for name,symbol in pairs(controlnames) do
+    package.preload["vstruct.io."..symbol] = function() return iorequire(name) end
+end
+
+return function(format, method, ...)
+    local fmt = formats[format]
+        or setmetatable(iorequire(format), { __index = defaults })
+    
+    assert(fmt[method], "No support for method '"..tostring(method).."' in IO module '"..format.."'")
+    
+    return fmt[method](...)
+end

data/vendor/lua/lib/lua/vstruct/io/a.lua

@@ -0,0 +1,24 @@
+-- align-to
+
+local io = require "vstruct.io"
+local a = {}
+
+function a.hasvalue()
+    return false
+end
+
+function a.width()
+    return nil
+end
+
+function a.unpack(fd, _, align)
+    local cur = fd:seek()
+    
+    if cur % align ~= 0 then
+        fd:seek("cur", align - (cur % align))
+    end
+end
+
+a.pack = a.unpack
+
+return a

data/vendor/lua/lib/lua/vstruct/io/b.lua

@@ -0,0 +1,28 @@
+-- boolean
+
+local io = require "vstruct.io"
+local b = {}
+
+function b.unpack(_, buf)
+    return (buf:match("%Z") and true) or false
+end
+
+function b.unpackbits(bit, width)
+    local n = 0
+    for i=1,width do
+        n = n + bit()
+    end
+    return n > 0
+end
+
+function b.pack(_, data, width)
+    return io("u", "pack", nil, data and 1 or 0, width)
+end
+
+function b.packbits(bit, data, width)
+    for i=1,width do
+        bit(data and 1 or 0)
+    end
+end
+
+return b

data/vendor/lua/lib/lua/vstruct/io/bigendian.lua

@@ -0,0 +1,21 @@
+-- > set endianness: big
+
+local io = require "vstruct.io"
+local be = {}
+
+function be.hasvalue()
+    return false
+end
+
+function be.width(n)
+    assert(n == nil, "'>' is an endianness control, and does not have width")
+    return 0
+end
+
+function be.unpack()
+    io("endianness", "big")
+end
+
+be.pack = be.unpack
+
+return be

data/vendor/lua/lib/lua/vstruct/io/c.lua

@@ -0,0 +1,25 @@
+-- counted strings
+
+local io = require "vstruct.io"
+local c = {}
+
+function c.width(n)
+    return nil
+end
+
+function c.unpack(fd, _, width)
+    assert(width)
+    local buf = fd:read(width)
+    local len = io("u", "unpack", nil, buf, width)
+    if len == 0 then
+        return ""
+    end
+    return fd:read(len)
+end
+
+function c.pack(fd, data, width)
+    return io("u", "pack", nil, #data, width)
+        .. io("s", "pack", nil, data)
+end
+
+return c