rufus-lua-win 5.1.5

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

@@ -0,0 +1,24 @@
+-- default implementations for some of the IO sub-operations - if a format
+-- doesn't provide its own, these will be used
+
+local defaults = {}
+
+-- verifies the width given, returns the number of bytes that will actually
+-- be read or written. Default assumes that width is mandatory and exactly
+-- equals the amount that will be RWd.
+-- If the format doesn't do any, should return 0. If the amount cannot be
+-- determined ahead of time (for example, format c) should return nil.
+function defaults.width(n)
+    assert(tonumber(n), "format requires a width")
+    return tonumber(n)
+end
+
+function defaults.validate()
+    return true
+end
+
+function defaults.hasvalue()
+    return true
+end
+
+return defaults

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

@@ -0,0 +1,41 @@
+-- the actual endianness controls. These should not be used directly, but
+-- are instead invoked by the <=> formats (bigendian, littleendian, and
+-- hostendian) to do the actual work.
+
+-- FIXME: endianness flag should be operation-local rather than VM-local; at
+-- present packunpack operations are atomic, but if in the future they are
+-- not - for example, if an io is implemented that uses coroutines - the current
+-- implementation will fuck us right up.
+
+local e = {}
+
+local endianness;
+
+function e.hasvalue()
+    return false
+end
+
+function e.big()
+    endianness = "big"
+end
+
+function e.little()
+    endianness = "little"
+end
+
+-- determine if the host system is big-endian or not, by dumping an empty
+-- function and looking at the endianness flag
+-- HACK HACK HACK
+function e.host()
+    if string.byte(string.dump(function() end)) == 0x00 then
+        e.big()
+    else
+        e.little()
+    end
+end
+
+function e.get()
+    return endianness
+end
+
+return e

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

@@ -0,0 +1,129 @@
+-- IEEE floating point floats, doubles and quads
+
+local struct = require "vstruct"
+local io     = require "vstruct.io"
+
+local sizes = {
+	[4] = {1,  8, 23};
+	[8] = {1, 11, 52};
+    [16] = {1, 15, 112};
+}
+
+local function reader(data, size_exp, size_fraction)
+	local fraction, exponent, sign
+	local endian = io("endianness", "get") == "big" and ">" or "<"
+	
+	-- Split the unsigned integer into the 3 IEEE fields
+	local bits = struct.unpack(endian.." m"..#data, data)[1]
+	local fraction = struct.implode({unpack(bits, 1, size_fraction)}, size_fraction)
+	local exponent = struct.implode({unpack(bits, size_fraction+1, size_fraction+size_exp)}, size_exp)
+	local sign = bits[#bits] and -1 or 1
+    
+	-- special case: exponent is all 1s
+	if exponent == 2^size_exp-1 then
+		-- significand is 0? +- infinity
+		if fraction == 0 then
+			return sign * math.huge
+		
+		-- otherwise it's NaN
+		else
+			return 0/0
+		end
+	end
+			
+	-- restore the MSB of the significand, unless it's a subnormal number
+	if exponent ~= 0 then
+		fraction = fraction + (2 ^ size_fraction)
+	else
+        exponent = 1
+    end
+	
+	-- remove the exponent bias
+	exponent = exponent - 2 ^ (size_exp - 1) + 1
+
+	-- Decrease the size of the exponent rather than make the fraction (0.5, 1]
+	exponent = exponent - size_fraction
+    
+	return sign * math.ldexp(fraction, exponent)
+end
+
+local function writer(value, size_exp, size_fraction)
+	local fraction, exponent, sign
+	local width = (size_exp + size_fraction + 1)/8
+	local endian = io("endianness", "get") == "big" and ">" or "<"
+    local bias = 2^(size_exp-1)-1
+	
+	if value < 0 
+    or 1/value == -math.huge then -- handle the case of -0
+		sign = true
+		value = -value
+	else
+		sign = false
+	end
+
+	-- special case: value is infinite
+	if value == math.huge then
+		exponent = bias+1
+		fraction = 0
+	
+	-- special case: value is NaN
+	elseif value ~= value then
+		exponent = bias+1
+		fraction = 2^(size_fraction-1)
+
+    --special case: value is 0
+    elseif value == 0 then
+        exponent = -bias
+        fraction = 0
+        
+	else
+		fraction,exponent = math.frexp(value)
+        
+        -- subnormal number
+        if exponent+bias <= 1 then
+            fraction = fraction * 2^(size_fraction+(exponent+bias)-1)
+            exponent = -bias
+
+        else
+            -- remove the most significant bit from the fraction and adjust exponent
+            fraction = fraction - 0.5
+            exponent = exponent - 1
+            
+            -- turn the fraction into an integer
+            fraction = fraction * 2^(size_fraction+1)
+        end
+	end
+	
+    
+    -- add the exponent bias
+    exponent = exponent + bias
+
+	local bits = struct.explode(fraction)
+	local bits_exp = struct.explode(exponent)
+	for i=1,size_exp do
+		bits[size_fraction+i] = bits_exp[i]
+	end
+	bits[size_fraction+size_exp+1] = sign
+    
+	return struct.pack(endian.."m"..width, {bits})
+end
+
+local f = {}
+
+function f.width(n)
+    n = tonumber(n)
+    assert(n == 4 or n == 8 or n == 16
+        , "format 'f' only supports widths 4 (float), 8 (double) and 16 (quad)")
+    
+    return n
+end
+
+function f.unpack(_, buf, width)
+    return reader(buf, unpack(sizes[width], 2))
+end
+
+function f.pack(_, data, width)
+    return writer(data, unpack(sizes[width], 2))
+end
+
+return f

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

@@ -0,0 +1,21 @@
+-- = set endianness to same as host system
+
+local io = require "vstruct.io"
+local he = {}
+
+function he.hasvalue()
+    return false
+end
+
+function he.width(n)
+    assert(n == nil, "'=' is an endianness control, and does not have width")
+    return 0
+end
+
+function he.unpack()
+    io("endianness", "host")
+end
+
+he.pack = he.unpack
+
+return he

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

@@ -0,0 +1,42 @@
+-- signed integers
+
+local io = require "vstruct.io"
+local i = {}
+
+function i.unpack(fd, buf, width)
+    local n = io("u", "unpack", fd, buf, width)
+
+    if n >= 2^(width*8-1) then
+        return n - 2^(width*8)
+    end
+    
+    return n
+end
+
+function i.unpackbits(bit, width)
+    local n = io("u", "unpackbits", bit, width)
+    
+    if n >= 2^(width-1) then
+        return n - 2^width
+    end
+    
+    return n
+end
+
+function i.pack(_, data, width)
+    if data < 0 then
+        data = data + 2^(width*8)
+    end
+    
+    return io("u", "pack", _, data, width)
+end
+
+function i.packbits(bit, data, width)
+    if data < 0 then
+        data = data + 2^width
+    end
+    
+    return io("u", "packbits", bit, data, width)
+end
+
+return i

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

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

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

@@ -0,0 +1,62 @@
+-- bitmasks
+
+local struct = require "vstruct"
+local io     = require "vstruct.io"
+local m = {}
+
+function m.unpack(_, buf, width)
+    local mask = {}
+    local e = io("endianness", "get")
+    
+    local sof,eof,step
+    if e == "big" then
+        sof,eof,step = #buf,1,-1
+    else
+        sof,eof,step = 1,#buf,1
+    end
+    
+	for i=sof,eof,step do
+		local byte = buf:byte(i)
+        for i=1,8 do
+            mask[#mask+1] = (byte % 2 == 1) and true or false
+            byte = math.floor(byte/2)
+        end
+	end
+    
+    return mask
+end
+
+function m.unpackbits(bit, width)
+    local mask = {}
+    for i=1,width do
+        mask[i] = bit() == 1 and true or false
+    end
+    return mask
+end
+
+-- bitmask
+-- we use a string here because using an unsigned will lose data on bitmasks
+-- wider than lua's native number format
+function m.pack(fd, data, width)
+	local buf = ""
+    local e = io("endianness", "get")
+	
+	for i=1,width*8,8 do
+		local bits = { unpack(data, i, i+7) }
+		local byte = string.char(struct.implode(bits, 8))
+		if e == "big" then
+			buf = byte..buf
+		else
+			buf = buf..byte
+		end
+	end
+	return io("s", "pack", fd, buf, width)
+end
+
+function m.packbits(bit, data, width)
+    for i=1,width do
+        bit(data[i] and 1 or 0)
+    end
+end
+
+return m

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

@@ -0,0 +1,23 @@
+-- fixed point
+-- format is pINTEGER_WIDTH,FRACTIONAL_WIDTH
+-- widths are in *bits* even when operating in byte mode!
+-- FIXME: this should support bitpacks
+
+local io = require "vstruct.io"
+local p = {}
+
+function p.width(width, frac)
+    assert(width*8 >= frac, "fixed point number has more fractional bits than total bits")
+    
+    return width
+end
+
+function p.unpack(fd, buf, width, frac)
+    return io("i", "unpack", fd, buf, width)/(2^frac)
+end
+
+function p.pack(fd, data, width, frac)
+    return io("i", "pack", fd, data * 2^frac, width)
+end
+
+return p

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

@@ -0,0 +1,27 @@
+-- fixed length strings
+
+local io = require "vstruct.io"
+local s = {}
+
+function s.width(w)
+    return tonumber(w)
+end
+
+function s.unpack(fd, buf, width)
+    if width then
+        assert(#buf == width, "sanity failure: length of buffer does not match length of string format")
+        return buf
+    end
+    
+    return fd:read('*a')
+end
+
+function s.pack(_, data, width)
+    width = width or #data
+    if width > #data then
+        data = data..string.rep("\0", width - #data)
+    end
+    return data:sub(1,width)
+end
+
+return s

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

@@ -0,0 +1,18 @@
+-- - seek backward a constant amount
+
+local seek = {}
+
+function seek.hasvalue()
+    return false
+end
+
+function seek.width()
+    return nil
+end
+
+function seek.unpack(fd, _, offset)
+    fd:seek("cur", -offset)
+end
+seek.pack = seek.unpack
+
+return seek

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

@@ -0,0 +1,18 @@
+-- + seek forward a constant amount
+
+local seek = {}
+
+function seek.hasvalue()
+    return false
+end
+
+function seek.width()
+    return nil
+end
+
+function seek.unpack(fd, _, offset)
+    fd:seek("cur", offset)
+end
+seek.pack = seek.unpack
+
+return seek

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

@@ -0,0 +1,18 @@
+-- @ seek to a constant offset
+
+local seek = {}
+
+function seek.hasvalue()
+    return false
+end
+
+function seek.width()
+    return nil
+end
+
+function seek.unpack(fd, _, offset)
+    fd:seek("set", offset)
+end
+seek.pack = seek.unpack
+
+return seek