rufus-lua-win 5.1.5

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

@@ -0,0 +1,54 @@
+-- unsigned ints
+
+local io     = require "vstruct.io"
+local u = {}
+
+function u.unpack(_, buf)
+    local n = 0
+    local e = io("endianness", "get")
+    
+    local sof,eof,step
+    if e == "big" then
+        sof,eof,step = 1,#buf,1
+    else
+        sof,eof,step = #buf,1,-1
+    end
+    
+    for i=sof,eof,step do
+        n = n * 256 + buf:byte(i,i)
+    end
+    
+    return n
+end
+
+function u.unpackbits(bit, width)
+    local n = 0
+    for i=1,width do
+        n = n * 2 + bit()
+    end
+    return n
+end
+
+function u.pack(_, data, width)
+    local s = ""
+    local e = io("endianness", "get")
+    
+    for i=1,width do
+        if e == "big" then
+            s = string.char(data % 256) .. s
+        else
+            s = s .. string.char(data % 256)
+        end
+        data = math.trunc(data/256)
+    end
+    
+    return s
+end
+
+function u.packbits(bit, data, width)
+    for i=width-1,0,-1 do
+        bit(math.floor(data/2^i) % 2)
+    end
+end
+
+return u

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

@@ -0,0 +1,34 @@
+-- skip/pad
+-- unlike the seek controls @+- or the alignment control a, x will never call
+-- seek, and instead uses write '\0' or read-and-ignore - this means it is
+-- safe to use on streams.
+
+local io = require "vstruct.io"
+local x = {}
+
+function x.hasvalue()
+    return false
+end
+
+function x.unpack(fd, buf, width)
+    io("s", "unpack", fd, buf, width)
+    return nil
+end
+
+function x.unpackbits(bit, width)
+    for i=1,width do
+        bit()
+    end
+end
+
+function x.packbits(bit, _, width)
+    for i=1,width do
+        bit(0)
+    end
+end
+
+function x.pack(fd, data, width)
+    return string.rep("\0", width)
+end
+
+return x

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

@@ -0,0 +1,63 @@
+-- null-terminated strings
+
+local io = require "vstruct.io"
+local z = {}
+
+function z.width(width, cwidth)
+    return width
+end
+
+-- null terminated string
+-- w==nil is write string as is + termination
+-- w>0 is write exactly w bytes, truncating/padding and terminating
+
+function z.pack(_, data, width, cwidth)
+    cwidth = cwidth or 1
+	width = width or #data+cwidth
+	
+	assert(width % cwidth == 0, "string length is not a multiple of character size")
+    
+    -- truncate to field width
+	if #data >= width then
+		data = data:sub(1, width-cwidth)
+	end
+	
+    return io("s", "pack", _, data..("\0"):rep(cwidth), width)
+end
+
+-- null-terminated string
+-- if w is omitted, reads up to and including the first nul, and returns everything
+-- except that nul; WARNING: SLOW
+-- otherwise, reads exactly w bytes and returns everything up to the first nul
+function z.unpack(fd, buf, width, cwidth)
+    cwidth = cwidth or 1
+    nul = ("\0"):rep(cwidth)
+    
+    -- read exactly that many characters, then strip the null termination
+    if width then
+        local buf = io("s", "unpack", fd, buf, width)
+        local len = 0
+        
+        -- search the string for the null terminator. If charwidth > 1, just
+        -- finding nul isn't good enough - it needs to be aligned on a character
+        -- boundary.
+        repeat
+            len = buf:find(nul, len+1, true)
+        until len == nil or (len-1) % cwidth == 0
+        
+        return buf:sub(1,(len or 0)-1)
+    end
+    
+    -- this is where it gets ugly: the width wasn't specified, so we need to
+    -- read (cwidth) bytes at a time looking for the null terminator
+    local chars = {}
+    local c = fd:read(cwidth)
+    while c and c ~= nul do
+        chars[#chars+1] = c
+        c = fd:read(cwidth)
+    end
+
+    return table.concat(chars)
+end
+
+return z

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

@@ -0,0 +1,100 @@
+-- Implements the lexer for vstruct format strings.
+-- Returns a function which, given a source string, returns a table of lexer
+-- operations closed over that source.
+
+-- Copyright (c) 2011 Ben "ToxicFrog" Kelly
+
+local lexis = {}
+
+local function lexeme(name)
+	return function(pattern)
+		lexis[#lexis+1] = { name=name, pattern="^"..pattern }
+	end
+end
+
+lexeme (false) 	    "%s+"	-- whitespace
+lexeme (false)      "%-%-[^\n]*" -- comments
+lexeme "key"        "([%a_][%w_.]*):"
+lexeme "name"	    "([-+@<>=])"
+lexeme "name"       "([%a_]+)"
+lexeme "number"     "([%d.,]+)"
+lexeme "{"          "%{"
+lexeme "}"          "%}"
+lexeme "("          "%("
+lexeme ")"          "%)"
+--lexeme ":"          "%:"
+lexeme "*"          "%*"
+lexeme "["          "%["
+lexeme "]"          "%]"
+lexeme "|"          "%|"
+
+return function(source)
+    local orig = source
+    local index = 1
+    local hadwhitespace = false
+           
+    local function where()
+        return ("character %d ('%s')."):format(index, source:sub(1,4))
+    end
+
+    local function find_match()
+        for _,lexeme in ipairs(lexis) do
+            if source:match(lexeme.pattern) then
+                return lexeme,select(2, source:find(lexeme.pattern))
+            end
+        end
+        error (("Lexical error in format string at %s."):format(where()))
+    end
+
+    local function eat_whitespace()
+        local function aux()
+            if #source == 0 then return end
+            local match,size = find_match()
+            
+            if not match.name then
+                hadwhitespace = true
+                source = source:sub(size+1, -1)
+                index = index + size
+                return aux()
+            end
+        end
+        hadwhitespace = false
+        return aux()
+    end
+
+    local function whitespace()
+        return hadwhitespace
+    end
+    
+   local function next()
+       eat_whitespace()
+
+       if #source == 0 then return nil end
+
+       local lexeme,size,text = find_match()
+
+       source = source:sub(size+1, -1)
+       index = index+size
+
+       return { text = text, type = lexeme.name }
+   end
+
+   local function peek()
+       eat_whitespace()
+
+       if #source == 0 then return nil end
+
+       local lexeme,size,text = find_match()
+
+       return { text = text, type = lexeme.name }
+   end
+
+   return {
+       next = next;
+       peek = peek;
+       where = where;
+       whitespace = whitespace;
+       tokens = function() return next end;
+   }
+end
+

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

@@ -0,0 +1,142 @@
+-- Implements the pack operation for vstruct.
+-- This is actually only used by ast.Generator, but is sufficiently complex
+-- that it gets its own file.
+
+-- Copyright (c) 2011 Ben "ToxicFrog" Kelly
+
+local io = require "vstruct.io"
+
+return function(refs)
+    local env = {}
+    
+    local fd,buffer,bufsize,bufpos,data,stack,key,index,istack
+    local bitpack,nextbit
+    
+    local function get()
+        local value
+        if not key then
+            value = data[index]
+            index = index+1
+        else
+            local data = data
+            for name in key:gmatch("([^%.]+)%.") do
+                data = assert(data[name], "malformed table passed to pack")
+            end
+            value = data[key:match("[^%.]+$")]
+            key = nil
+        end
+        return value
+    end
+    
+    local function write(v)
+        if not buffer then
+            fd:write(v)
+        else
+            bufpos = bufpos + #v
+            buffer[#buffer+1] = v
+                
+            if bufpos == bufsize then
+                fd:write(table.concat(buffer))
+                buffer = nil
+            end
+        end
+    end
+    
+    function env.ref(id)
+        return unpack(refs[id])
+    end
+    
+    function env.initialize(_fd, _data)
+        fd = _fd
+        
+        buffer,bufsize,bufpos = nil,0,0
+        
+        data = _data
+        stack = {}
+        
+        index = 1
+        istack = {}
+        
+        key = nil
+        
+        io("endianness", "host")
+    end
+    
+    function env.readahead(n)
+        assert(bufpos == bufsize, "internal consistency failure: overlapping readahead")
+        
+        buffer = {}
+        bufsize = n
+        bufpos = 0
+    end
+    
+    function env.name(name)
+        key = name
+    end
+    
+    function env.push()
+        local t = get()
+
+        stack[#stack+1] = data
+        data = t
+
+        istack[#istack+1] = index
+        index = 1
+    end
+    
+    function env.pop()
+        data = stack[#stack]
+        stack[#stack] = nil
+        
+        index = istack[#istack]
+        istack[#istack] = nil
+    end
+    
+    function env.io(name, hasvalue, width, ...)
+        local v = io(name, "pack", fd, hasvalue and get() or nil, ...)
+        
+        if v then
+            assert((not width) or #v == width, "pack format '"..name.."' lied about its width!")
+            write(v)
+        end
+    end
+    
+    function env.bpio(name, hasvalue, width, ...)
+        return io(name, "packbits", nextbit, hasvalue and get() or nil, ...)
+    end
+    
+    function env.bitpack(width)
+        if width then
+            bitpack = {}
+            for i=1,width do
+                bitpack[i] = 0
+            end
+        
+            local e = io("endianness", "get")
+            
+            local bbit = 7
+            local bbyte = e == "big" and 1 or #bitpack
+            local bdelta = e == "big" and 1 or -1
+            
+            function nextbit(b)
+                bitpack[bbyte] = bitpack[bbyte] + b * 2^bbit
+
+                bbit = (bbit - 1) % 8
+                
+                if bbit == 7 then -- we just wrapped around
+                    bbyte = bbyte + bdelta
+                end
+            end
+        else
+            write(string.char(unpack(bitpack)))
+            bitpack = nil
+        end
+    end
+    
+    function env.finalize()
+        assert(#stack == 0, "mismatched push/pop in execution")
+        return fd
+    end
+    
+    return env
+end

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

@@ -0,0 +1,47 @@
+-- top-level test module for vstruct
+-- run with 'lua test.lua' or, if vstruct is installed, with
+-- 'lua -lvstruct.test -e ""'
+
+-- Runs a "sensible default" set of tests against the vstruct module. Exits
+-- cleanly if all of them passed; if any failed, reports the failed tests
+-- on stdout and then raises an error.
+
+local ok,test = pcall(require, "vstruct.test.common")
+
+-- maybe we aren't installed, and just need to deduce a custom package.path
+-- from the location of this file
+-- if arg is undefined, we were loaded with require and can draw no conclusions
+if ok then
+    -- loaded successfully, no error handling needed
+elseif arg then
+    -- see if we can figure out where we were loaded from
+    local libdir = arg[0]:gsub("[^/\\]+$", "").."../"
+    package.path = package.path..";"..libdir.."?.lua;"..libdir.."?/init.lua"
+    
+    -- clear "failure" entries in package.path
+    package.loaded["vstruct.test.common"] = nil
+    package.loaded["vstruct"] = nil
+    
+    -- retry
+    test = require "vstruct.test.common"
+else
+    error(test)
+end
+
+require "vstruct.test.basic"
+require "vstruct.test.fp-bigendian"
+require "vstruct.test.fp-littleendian"
+
+if arg and #arg > 0 then
+    require "vstruct.test.struct-test-gen"
+else
+    arg = { "NROF_TESTS=2^10", "read" }
+    require "vstruct.test.struct-test-gen"
+    package.loaded["vstruct.test.struct-test-gen"] = nil
+    arg = { "NROF_TESTS=2^10", "write" }
+    require "vstruct.test.struct-test-gen"
+end
+
+if test.report() > 0 then
+    error("Some test cases failed; see preceding output for details.")
+end

data/vendor/lua/lib/lua/vstruct/test/basic.lua

@@ -0,0 +1,73 @@
+-- "basic" test module for vstruct
+-- does not test floating point operations - see test/fp-*endian.lua for those
+-- Copyright (c) 2011 Ben "ToxicFrog" Kelly; see COPYING
+
+-- FIXME - stuff still needing a test case:
+-- * seek past end of file
+-- * input table doesn't match format string
+-- * format string is badly formed
+-- * format string is semantically nonsensical (compile and runtime cases)
+
+local test = require "vstruct.test.common"
+
+local x = test.x
+local T = test.autotest
+
+test.group "basic tests"
+
+T("true",       "> b8",     x"0000 0000 0000 0001", true)
+T("false",      "> b8",     x"0000 0000 0000 0000", false)
+
+T("unsigned",   "< u3",     x"FE FF FF", 2^24-2)
+T("signed",     "< i3",     x"FE FF FF", -2)
+
+T("c str",      "z",        "foobar\0baz", "foobar", "foobar\0")
+T("padded str", "z10",      "foobar\0baz", "foobar", "foobar\0\0\0\0")
+
+T("fixed str",  "s4",       "foobar", "foob", "foob")
+
+T("counted str","< c4",     x"06000000".."foobar", "foobar")
+
+T("bitmask",    "m1",       x"FA", {{ false, true, false, true, true, true, true, true }})
+
+T("skip/pad",   "x4u1",     x"00 00 00 00 02", 2)
+
+T("seek @",     "@2 u1x2",  x"00 00 02 00 00", 2)
+T("seek +",     "+2 u1x2",  x"00 00 02 00 00", 2)
+T("seek -",     "+4-2 u1x2",x"00 00 02 00 00", 2)
+
+T("little-endian", "< u2",  x"00 01", 256)
+T("big-endian", "> u2",     x"00 01", 1)
+
+if test.bigendian() then
+    T("host-endian","= u2", x"01 00", 256)
+    T("endianness leak (1)", "< u2", x"00 01", 256)
+    T("endianness leak (2)", "u2", x"00 01", 1)
+else
+    T("host-endian","= u2", x"01 00", 1)
+    T("endianness leak (1)", "> u2", x"00 01", 1)
+    T("endianness leak (2)", "u2", x"00 01", 256)
+end
+
+T("bitpack [>b]",   "> [2| x15 b1 ]",  x"00 01", true)
+T("bitpack [<b]",   "< [2| x15 b1 ]",  x"01 00", true)
+T("bitpack [>u]",   "> [2| 4*u4 ]",  x"12 34", {1,2,3,4})
+T("bitpack [<u]",   "< [2| 4*u4 ]",  x"12 34", {3,4,1,2})
+T("bitpack [>i]",   "> [2| 4*i4 ]",  x"12 EF", {1,2,-2,-1})
+T("bitpack [<i]",   "< [2| 4*i4 ]",  x"12 EF", {-2,-1,1,2})
+T("bitpack [>m]",   "> [2| m5 m3 x8 ]",  x"12 00", {{false,false,false,true,false},{false,true,false}})
+T("bitpack [<m]",   "< [2| m5 m3 x8 ]",  x"00 12", {{false,false,false,true,false},{false,true,false}})
+
+T("fixed point >",  "> p2,8", x"40 80", 64.5)
+T("fixed point <",  "< p2,8", x"40 80", -127.75)
+
+T("repetition", "> 4*u1", x"01 02 03 04", { 1, 2, 3, 4 })
+T("groups", "> 2*(u1 i1)", x"01 FF 02 FE", { 1, -1, 2, -2 })
+T("tables", "> 2*{ u1 i1 }", x"01 FF 02 FE", { { 1, -1 }, { 2, -2 } })
+T("names", "> coords:{ x:u1 y:u1 } coords.z:u1", x"01 02 03", { coords = { x = 1, y = 2, z = 3 } })
+
+T("UCS-2 z",  "> z,2",  x"0061 0062 0000 FFFF", "\0a\0b", x"0061 0062 0000")
+T("UCS-2 z8", "> z8,2", x"0061 0062 0000 FFFF", "\0a\0b", x"0061 0062 0000 0000")
+
+T("repeated repeat", "2*2*u1", x"01 01 01 01", { 1, 1, 1, 1 })
+