1431 lines
33 KiB
Lua
1431 lines
33 KiB
Lua
bin={}
|
|
bin.Version={6,0,0}
|
|
bin.stage='stable'
|
|
bin.data=''
|
|
bin.t='bin'
|
|
bin.__index = bin
|
|
bin.__tostring=function(self) return self:getData() end
|
|
bin.__len=function(self) return self:getlength() end
|
|
bin.lastBlockSize=0
|
|
bin.streams={}
|
|
-- Helpers
|
|
function bin.getVersion()
|
|
return bin.Version[1]..'.'..bin.Version[2]..'.'..bin.Version[3]
|
|
end
|
|
function table.print(tbl, indent)
|
|
if not indent then indent = 0 end
|
|
for k, v in pairs(tbl) do
|
|
formatting = string.rep(" ", indent) .. k .. ": "
|
|
if type(v) == "table" then
|
|
print(formatting)
|
|
table.print(v, indent+1)
|
|
elseif type(v) == 'boolean' then
|
|
print(formatting .. tostring(v))
|
|
else
|
|
print(formatting .. tostring(v))
|
|
end
|
|
end
|
|
end
|
|
function table.flip(t)
|
|
local tt={}
|
|
for i,v in pairs(t) do
|
|
tt[v]=i
|
|
end
|
|
return tt
|
|
end
|
|
function toFraction(n)
|
|
local w,p=math.modf(n)
|
|
if p~=0 then
|
|
p=tonumber(tostring(p):sub(3))
|
|
end
|
|
return w,p
|
|
end
|
|
function io.cleanName(name)
|
|
name=name:gsub("\\","")
|
|
name=name:gsub("/","")
|
|
name=name:gsub(":","")
|
|
name=name:gsub("*","")
|
|
name=name:gsub("%?","")
|
|
name=name:gsub("\"","''")
|
|
name=name:gsub("<","")
|
|
name=name:gsub(">","")
|
|
name=name:gsub("|","")
|
|
return name
|
|
end
|
|
function math.numfix(n,x)
|
|
local str=tostring(n)
|
|
if #str<x then
|
|
str=('0'):rep(x-#str)..str
|
|
end
|
|
return str
|
|
end
|
|
function bin.stripFileName(path)
|
|
path=path:gsub("\\","/")
|
|
local npath=path:reverse()
|
|
a=npath:find("/",1,true)
|
|
npath=npath:sub(a)
|
|
npath=npath:reverse()
|
|
return npath
|
|
end
|
|
function bin._trim(str)
|
|
return str:match'^()%s*$' and '' or str:match'^%s*(.*%S)'
|
|
end
|
|
function io.dirExists(strFolderName)
|
|
strFolderName = strFolderName or io.getDir()
|
|
local fileHandle, strError = io.open(strFolderName..'\\*.*','r')
|
|
if fileHandle ~= nil then
|
|
io.close(fileHandle)
|
|
return true
|
|
else
|
|
if string.match(strError,'No such file or directory') then
|
|
return false
|
|
else
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
function bin.fileExists(name)
|
|
local f=io.open(name,"r")
|
|
if f~=nil then io.close(f) return true else return false end
|
|
end
|
|
function bin.randomName(n,ext)
|
|
n=n or math.random(7,15)
|
|
if ext then
|
|
a,b=ext:find('.',1,true)
|
|
if a and b then
|
|
ext=ext:sub(2)
|
|
end
|
|
end
|
|
local str,h = '',0
|
|
strings = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','1','2','3','4','5','6','7','8','9','0','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'}
|
|
for i=1,n do
|
|
h = math.random(1,#strings)
|
|
str = str..''..strings[h]
|
|
end
|
|
return str..'.'..(ext or 'tmp')
|
|
end
|
|
function bin.trimNul(str)
|
|
return str:match("(.-)[%z]*$")
|
|
end
|
|
function io.mkDir(dirname)
|
|
os.execute('mkdir "' .. dirname..'"')
|
|
end
|
|
function string.lines(str)
|
|
local t = {}
|
|
local function helper(line) table.insert(t, line) return '' end
|
|
helper((str:gsub('(.-)\r?\n', helper)))
|
|
return t
|
|
end
|
|
function log(data,name,fmt)
|
|
if name then
|
|
name=io.cleanName(name)
|
|
end
|
|
if not bin.logger then
|
|
bin.logger = bin.stream(name or 'lua.log',false)
|
|
elseif bin.logger and name then
|
|
bin.logger:close()
|
|
bin.logger = bin.stream(name or 'lua.log',false)
|
|
end
|
|
local d=os.date('*t',os.time())
|
|
bin.logger:tackE((fmt or '['..math.numfix(d.month,2)..'-'..math.numfix(d.day,2)..'-'..d.year..'|'..math.numfix(d.hour,2)..':'..math.numfix(d.min,2)..':'..math.numfix(d.sec,2)..']\t')..data..'\r\n')
|
|
end
|
|
function table.max(t)
|
|
if #t == 0 then return end
|
|
local value = t[1]
|
|
for i = 2, #t do
|
|
if (value < t[i]) then
|
|
value = t[i]
|
|
end
|
|
end
|
|
return value
|
|
end
|
|
|
|
local bit
|
|
if jit then
|
|
bit=require("bit")
|
|
elseif bit32 then
|
|
bit=bit32
|
|
else
|
|
bit=require("bin.numbers.no_jit_bit")
|
|
end
|
|
bin.lzw=require("bin.compressors.lzw") -- A WIP
|
|
local bits={}
|
|
bin.bits = bits
|
|
bits.data=''
|
|
bits.t='bits'
|
|
bits.Type='bits'
|
|
bits.__index = bits
|
|
bits.__tostring=function(self) return self.data end
|
|
bits.__len=function(self) return (#self.data)/8 end
|
|
local floor,insert = math.floor, table.insert
|
|
function bits.newBitBuffer(n)
|
|
--
|
|
end
|
|
function bits.newConverter(bitsIn,bitsOut)
|
|
local c={}
|
|
--
|
|
end
|
|
function basen(n,b)
|
|
if not b or b == 10 then return tostring(n) end
|
|
local digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
|
|
local t = {}
|
|
local sign = ""
|
|
if n < 0 then
|
|
sign = "-"
|
|
n = -n
|
|
end
|
|
repeat
|
|
local d = n % b + 1
|
|
n = n / b
|
|
insert(t, 1, digits:sub(d,d))
|
|
until n == 0
|
|
return sign .. table.concat(t,"")
|
|
end
|
|
bits.ref={}
|
|
function bits.newByte(d)
|
|
local c={}
|
|
if type(d)=="string" then
|
|
if #d>1 or #d<1 then
|
|
error("A byte must be one character!")
|
|
else
|
|
c.data=string.byte(d)
|
|
end
|
|
elseif type(d)=="number" then
|
|
if d>255 or d<0 then
|
|
error("A byte must be between 0 and 255!")
|
|
else
|
|
c.data=d
|
|
end
|
|
else
|
|
error("cannot use type "..type(d).." as an argument! Takes only strings or numbers!")
|
|
end
|
|
c.__index=function(self,k)
|
|
if k>=0 and k<9 then
|
|
if self.data==0 then
|
|
return 0
|
|
elseif self.data==255 then
|
|
return 1
|
|
else
|
|
return bits.ref[self.data][k]
|
|
end
|
|
end
|
|
end
|
|
c.__tostring=function(self)
|
|
return bits.ref[tostring(self.data)]
|
|
end
|
|
setmetatable(c,c)
|
|
return c
|
|
end
|
|
function bits.newByteArray(s)
|
|
local c={}
|
|
if type(s)~="string" then
|
|
error("Must be a string type or bin/buffer type")
|
|
elseif type(s)=="table" then
|
|
if s.t=="sink" or s.t=="buffer" or s.t=="bin" then
|
|
local data=s:getData()
|
|
for i=1,#data do
|
|
c[#c+1]=bits.newByte(data:sub(i,i))
|
|
end
|
|
else
|
|
error("Must be a string type or bin/buffer type")
|
|
end
|
|
else
|
|
for i=1,#s do
|
|
c[#c+1]=bits.newByte(s:sub(i,i))
|
|
end
|
|
end
|
|
return c
|
|
end
|
|
function bits.new(n,binary)
|
|
local temp={}
|
|
temp.t="bits"
|
|
temp.Type="bits"
|
|
if type(n)=="string" then
|
|
if binary then
|
|
temp.data=n:match("[10]+")
|
|
else
|
|
local t={}
|
|
for i=#n,1,-1 do
|
|
table.insert(t,bits:conv(string.byte(n,i)))
|
|
end
|
|
temp.data=table.concat(t)
|
|
end
|
|
elseif type(n)=="number" or type(n)=="table" then
|
|
temp.data=basen(n,2)
|
|
end
|
|
if #temp.data%8~=0 then
|
|
temp.data=string.rep('0',8-#temp.data%8)..temp.data
|
|
end
|
|
setmetatable(temp, bits)
|
|
return temp
|
|
end
|
|
for i=0,255 do
|
|
local d=bits.new(i).data
|
|
bits.ref[i]={d:match("(%d)(%d)(%d)(%d)(%d)(%d)(%d)(%d)")}
|
|
bits.ref[tostring(i)]=d
|
|
bits.ref[d]=i
|
|
bits.ref["\255"..string.char(i)]=d
|
|
end
|
|
function bits.numToBytes(n,fit,func)
|
|
local num=string.reverse(bits.new(n):toSbytes())
|
|
local ref={["num"]=num,["fit"]=fit}
|
|
if fit then
|
|
if fit<#num then
|
|
if func then
|
|
print("Warning: attempting to store a number that takes up more space than allotted! Using provided method!")
|
|
func(ref)
|
|
else
|
|
print("Warning: attempting to store a number that takes up more space than allotted!")
|
|
end
|
|
return ref.num:sub(1,ref.fit)
|
|
elseif fit==#num then
|
|
return string.reverse(num)
|
|
else
|
|
return string.reverse(string.rep("\0",fit-#num)..num)
|
|
end
|
|
else
|
|
return string.reverse(num)
|
|
end
|
|
end
|
|
function bits:conv(n)
|
|
local tab={}
|
|
while n>=1 do
|
|
table.insert(tab,n%2)
|
|
n=math.floor(n/2)
|
|
end
|
|
local str=string.reverse(table.concat(tab))
|
|
if #str%8~=0 or #str==0 then
|
|
str=string.rep('0',8-#str%8)..str
|
|
end
|
|
return str
|
|
end
|
|
function bits:tonumber(s,e)
|
|
if s==0 then
|
|
return tonumber(self.data,2)
|
|
end
|
|
s=s or 1
|
|
return tonumber(string.sub(self.data,(8*(s-1))+1,8*s),2) or error('Bounds!')
|
|
end
|
|
function bits:isover()
|
|
return #self.data>8
|
|
end
|
|
function bits:flipbits()
|
|
tab={}
|
|
for i=1,#self.data do
|
|
if string.sub(self.data,i,i)=='1' then
|
|
table.insert(tab,'0')
|
|
else
|
|
table.insert(tab,'1')
|
|
end
|
|
end
|
|
self.data=table.concat(tab)
|
|
end
|
|
function bits:tobytes()
|
|
local tab={}
|
|
for i=self:getbytes(),1,-1 do
|
|
table.insert(tab,string.char(self:tonumber(i)))
|
|
end
|
|
return bin.new(table.concat(tab))
|
|
end
|
|
function bits:toSbytes()
|
|
local tab={}
|
|
for i=self:getbytes(),1,-1 do
|
|
table.insert(tab,string.char(self:tonumber(i)))
|
|
end
|
|
return table.concat(tab)
|
|
end
|
|
function bits:getBin()
|
|
return self.data
|
|
end
|
|
function bits:getbytes()
|
|
return #self.data/8
|
|
end
|
|
local binNum=require("bin.numbers.BigNum")
|
|
local infinabits={}
|
|
bin.infinabits = infinabits
|
|
infinabits.data=''
|
|
infinabits.t='infinabits'
|
|
infinabits.Type='infinabits'
|
|
infinabits.__index = infinabits
|
|
infinabits.__tostring=function(self) return self.data end
|
|
infinabits.__len=function(self) return (#self.data)/8 end
|
|
local floor,insert = math.floor, table.insert
|
|
function basen(n,b)
|
|
n=BigNum.new(n)
|
|
if not b or b == 10 then return tostring(n) end
|
|
local digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
|
|
local t = {}
|
|
local sign = ""
|
|
if n < BigNum.new(0) then
|
|
sign = "-"
|
|
n = -n
|
|
end
|
|
repeat
|
|
local d = tonumber(tostring(n % b)) + 1
|
|
n = n / b
|
|
insert(t, 1, digits:sub(d,d))
|
|
until n == BigNum.new(0)
|
|
return sign .. table.concat(t,"")
|
|
end
|
|
function base2to10(num)
|
|
local n=BigNum.new(0)
|
|
for i = #num-1,0,-1 do
|
|
nn=BigNum.new(num:sub(i+1,i+1))*(BigNum.new(2)^((#num-i)-1))
|
|
n=n+nn
|
|
end
|
|
return n
|
|
end
|
|
function infinabits.newBitBuffer(n)
|
|
-- WIP
|
|
end
|
|
function infinabits.newConverter(bitsIn,bitsOut)
|
|
local c={}
|
|
-- WIP
|
|
end
|
|
infinabits.ref={}
|
|
function infinabits.newByte(d)-- WIP
|
|
local c={}
|
|
if type(d)=="string" then
|
|
if #d>1 or #d<1 then
|
|
error("A byte must be one character!")
|
|
else
|
|
c.data=string.byte(d)
|
|
end
|
|
elseif type(d)=="number" then
|
|
if d>255 or d<0 then
|
|
error("A byte must be between 0 and 255!")
|
|
else
|
|
c.data=d
|
|
end
|
|
else
|
|
error("cannot use type "..type(d).." as an argument! Takes only strings or numbers!")
|
|
end
|
|
c.__index=function(self,k)
|
|
if k>=0 and k<9 then
|
|
if self.data==0 then
|
|
return 0
|
|
elseif self.data==255 then
|
|
return 1
|
|
else
|
|
return infinabits.ref[self.data][k]
|
|
end
|
|
end
|
|
end
|
|
c.__tostring=function(self)
|
|
return infinabits.ref[tostring(self.data)]
|
|
end
|
|
setmetatable(c,c)
|
|
return c
|
|
end
|
|
function infinabits.newByteArray(s)-- WIP
|
|
local c={}
|
|
if type(s)~="string" then
|
|
error("Must be a string type or bin/buffer type")
|
|
elseif type(s)=="table" then
|
|
if s.t=="sink" or s.t=="buffer" or s.t=="bin" then
|
|
local data=s:getData()
|
|
for i=1,#data do
|
|
c[#c+1]=infinabits.newByte(data:sub(i,i))
|
|
end
|
|
else
|
|
error("Must be a string type or bin/buffer type")
|
|
end
|
|
else
|
|
for i=1,#s do
|
|
c[#c+1]=infinabits.newByte(s:sub(i,i))
|
|
end
|
|
end
|
|
return c
|
|
end
|
|
function infinabits.new(n,binary)
|
|
local temp={}
|
|
temp.t="infinabits"
|
|
temp.Type="infinabits"
|
|
if type(n)=="string" then
|
|
if binary then
|
|
temp.data=n:match("[10]+")
|
|
else
|
|
local t={}
|
|
for i=#n,1,-1 do
|
|
table.insert(t,infinabits:conv(string.byte(n,i)))
|
|
end
|
|
temp.data=table.concat(t)
|
|
end
|
|
elseif type(n)=="number" or type(n)=="table" then
|
|
temp.data=basen(tostring(n),2)
|
|
end
|
|
if #temp.data%8~=0 then
|
|
temp.data=string.rep('0',8-#temp.data%8)..temp.data
|
|
end
|
|
setmetatable(temp, infinabits)
|
|
return temp
|
|
end
|
|
for i=0,255 do
|
|
local d=infinabits.new(i).data
|
|
infinabits.ref[i]={d:match("(%d)(%d)(%d)(%d)(%d)(%d)(%d)(%d)")}
|
|
infinabits.ref[tostring(i)]=d
|
|
infinabits.ref[d]=i
|
|
infinabits.ref["\255"..string.char(i)]=d
|
|
end
|
|
function infinabits.numToBytes(n,fit,func)
|
|
local num=string.reverse(infinabits.new(BigNum.new(n)):toSbytes())
|
|
local ref={["num"]=num,["fit"]=fit}
|
|
if fit then
|
|
if fit<#num then
|
|
if func then
|
|
print("Warning: attempting to store a number that takes up more space than allotted! Using provided method!")
|
|
func(ref)
|
|
else
|
|
print("Warning: attempting to store a number that takes up more space than allotted!")
|
|
end
|
|
return ref.num:sub(1,ref.fit)
|
|
elseif fit==#num then
|
|
return string.reverse(num)
|
|
else
|
|
return string.reverse(string.rep("\0",fit-#num)..num)
|
|
end
|
|
else
|
|
return string.reverse(num)
|
|
end
|
|
end
|
|
function infinabits.numToBytes(n,fit,fmt,func)
|
|
if fmt=="%e" then
|
|
local num=string.reverse(infinabits.new(BigNum.new(n)):toSbytes())
|
|
local ref={["num"]=num,["fit"]=fit}
|
|
if fit then
|
|
if fit<#num then
|
|
if func then
|
|
print("Warning: attempting to store a number that takes up more space than allotted! Using provided method!")
|
|
func(ref)
|
|
else
|
|
print("Warning: attempting to store a number that takes up more space than allotted!")
|
|
end
|
|
return ref.num:sub(1,ref.fit)
|
|
elseif fit==#num then
|
|
return num
|
|
else
|
|
return string.rep("\0",fit-#num)..num
|
|
end
|
|
else
|
|
return num
|
|
end
|
|
|
|
else
|
|
local num=string.reverse(infinabits.new(BigNum.new(n)):toSbytes())
|
|
local ref={["num"]=num,["fit"]=fit}
|
|
if fit then
|
|
if fit<#num then
|
|
if func then
|
|
print("Warning: attempting to store a number that takes up more space than allotted! Using provided method!")
|
|
func(ref)
|
|
else
|
|
print("Warning: attempting to store a number that takes up more space than allotted!")
|
|
end
|
|
return ref.num:sub(1,ref.fit)
|
|
elseif fit==#num then
|
|
return string.reverse(num)
|
|
else
|
|
return string.reverse(string.rep("\0",fit-#num)..num)
|
|
end
|
|
else
|
|
return string.reverse(num)
|
|
end
|
|
end
|
|
end
|
|
function infinabits:conv(n)
|
|
local tab={}
|
|
local one=BigNum.new(1)
|
|
local n=BigNum.new(n)
|
|
while n>=one do
|
|
table.insert(tab,tonumber(tostring(n%2)))
|
|
n=n/2
|
|
end
|
|
local str=string.reverse(table.concat(tab))
|
|
if #str%8~=0 or #str==0 then
|
|
str=string.rep('0',8-#str%8)..str
|
|
end
|
|
return str
|
|
end
|
|
function infinabits:tonumber(s)
|
|
if s==0 then
|
|
return tonumber(self.data,2)
|
|
end
|
|
s=s or 1
|
|
return tonumber(tostring(base2to10(string.sub(self.data,(8*(s-1))+1,8*s)))) or error('Bounds!')
|
|
end
|
|
function infinabits:isover()
|
|
return #self.data>8
|
|
end
|
|
function infinabits:flipbits()
|
|
tab={}
|
|
local s=self.data
|
|
s=s:gsub("1","_")
|
|
s=s:gsub("0","1")
|
|
s=s:gsub("_","0")
|
|
self.data=s
|
|
end
|
|
function infinabits:tobytes()
|
|
local tab={}
|
|
for i=self:getbytes(),1,-1 do
|
|
table.insert(tab,string.char(self:tonumber(i)))
|
|
end
|
|
return bin.new(table.concat(tab))
|
|
end
|
|
function infinabits:toSbytes()
|
|
local tab={}
|
|
for i=self:getbytes(),1,-1 do
|
|
table.insert(tab,string.char(self:tonumber(i)))
|
|
end
|
|
return table.concat(tab)
|
|
end
|
|
function infinabits:getBin()
|
|
return self.data
|
|
end
|
|
function infinabits:getbytes()
|
|
return #self.data/8
|
|
end
|
|
local randomGen=require("bin.numbers.random")
|
|
function bin.setBitsInterface(int)
|
|
bin.defualtBit=int or infinabits
|
|
end
|
|
bin.setBitsInterface()
|
|
function bin.normalizeData(data) -- unified function to allow for all types to string
|
|
if type(data)=="string" then return data end
|
|
if type(data)=="table" then
|
|
if data.Type=="bin" or data.Type=="streamable" or data.Type=="buffer" then
|
|
return data:getData()
|
|
elseif data.Type=="bits" or data.Type=="infinabits" then
|
|
return data:toSbytes()
|
|
elseif data.Type=="sink" then
|
|
-- LATER
|
|
else
|
|
return ""
|
|
end
|
|
elseif type(data)=="userdata" then
|
|
if tostring(data):sub(1,4)=="file" then
|
|
local cur=data:seek("cur")
|
|
data:seek("set",0)
|
|
local dat=data:read("*a")
|
|
data:seek("set",cur)
|
|
return dat
|
|
else
|
|
error("File handles are the only userdata that can be used!")
|
|
end
|
|
end
|
|
end
|
|
function bin.resolveType(tab) -- used in getblock for auto object creation. Internal method
|
|
if tab.Type then
|
|
if tab.Type=="bin" then
|
|
return bin.new(tab.data)
|
|
elseif tab.Type=="streamable" then
|
|
if bin.fileExist(tab.file) then return nil,"Cannot load the stream file, source file does not exist!" end
|
|
return bin.stream(tab.file,tab.lock)
|
|
elseif tab.Type=="buffer" then
|
|
local buf=bin.newDataBuffer(tab.size)
|
|
buf[1]=tab:getData()
|
|
return buf
|
|
elseif tab.Type=="bits" then
|
|
local b=bits.new("")
|
|
b.data=tab.data
|
|
return b
|
|
elseif tab.Type=="infinabits" then
|
|
local b=infinabits.new("")
|
|
b.data=tab.data
|
|
return b
|
|
elseif tab.Type=="sink" then
|
|
return bin.newSync(tab.data)
|
|
else -- maybe a type from another library
|
|
return tab
|
|
end
|
|
else return tab end
|
|
end
|
|
function bin.fileExist(path)
|
|
g=io.open(path or '','r')
|
|
if path =='' then
|
|
p='empty path'
|
|
return nil
|
|
end
|
|
if g~=nil and true or false then
|
|
p=(g~=nil and true or false)
|
|
end
|
|
if g~=nil then
|
|
io.close(g)
|
|
else
|
|
return false
|
|
end
|
|
return p
|
|
end
|
|
function bin.toHex(str)
|
|
local str=bin.normalizeData(str)
|
|
return (str:gsub('.', function (c)
|
|
return string.format('%02X', string.byte(c))
|
|
end))
|
|
end
|
|
function bin.fromHex(str)
|
|
return (str:gsub('..', function (cc)
|
|
return string.char(tonumber(cc, 16))
|
|
end))
|
|
end
|
|
|
|
-- Constructors
|
|
function bin.new(data)
|
|
data=bin.normalizeData(data)
|
|
local c = {}
|
|
setmetatable(c, bin)
|
|
c.data=data
|
|
c.Type="bin"
|
|
c.t="bin"
|
|
c.pos=1
|
|
c.stream=false
|
|
return c
|
|
end
|
|
|
|
function bin.newFromHex(data)
|
|
return bin.new(bin.fromHex(data))
|
|
end
|
|
function bin.load(path)
|
|
if type(path) ~= "string" then error("Path must be a string!") end
|
|
local f = io.open(path, 'rb')
|
|
local content = f:read('*a')
|
|
f:close()
|
|
return bin.new(content)
|
|
end
|
|
function bin.stream(file,l)
|
|
if not(l==false) then l=true end
|
|
local c=bin.new()
|
|
c.Type="streamable"
|
|
c.t="streamable"
|
|
if bin.streams[file]~=nil then
|
|
c.file=file
|
|
c.lock = l
|
|
c.workingfile=bin.streams[file][1].workingfile
|
|
bin.streams[file][2]=bin.streams[file][2]+1
|
|
c.stream=true
|
|
return c
|
|
end
|
|
if bin.fileExist(file) then
|
|
c.file=file
|
|
c.lock = l
|
|
c.workingfile=io.open(file,'rb+')
|
|
else
|
|
c.file=file
|
|
c.lock = l
|
|
c.workingfile=io.open(file,'w')
|
|
io.close(c.workingfile)
|
|
c.workingfile=io.open(file,'rb+')
|
|
end
|
|
c.stream=true
|
|
bin.streams[file]={c,1}
|
|
return c
|
|
end
|
|
function bin.newTempFile()
|
|
local c=bin.new()
|
|
c.file=file
|
|
c.lock = false
|
|
c.workingfile=io.tmpfile()
|
|
c.stream=true
|
|
return c
|
|
end
|
|
function bin.freshStream(file)
|
|
bin.new():tofile(file)
|
|
return bin.stream(file,false)
|
|
end
|
|
function bin.newStreamFileObject(file)
|
|
local c=bin.new()
|
|
c.Type="streamable"
|
|
c.t="streamable"
|
|
c.file="FILE_OBJECT"
|
|
c.lock = false
|
|
c.workingfile=file
|
|
c.stream=true
|
|
return c
|
|
end
|
|
-- Core Methods
|
|
function bin:canStreamWrite()
|
|
return (self.stream and not(self.lock))
|
|
end
|
|
function bin:getSeek()
|
|
if self.stream then
|
|
return self.workingfile:seek("cur")+1
|
|
else
|
|
return self.pos
|
|
end
|
|
end
|
|
function bin:setSeek(n)
|
|
if self.stream then
|
|
self.workingfile:seek("set",n-1)
|
|
else
|
|
self.pos=n
|
|
end
|
|
end
|
|
function bin:seek(n)
|
|
if self.stream then
|
|
if not n then return self.workingfile:seek("cur") end
|
|
local cur=self.workingfile:seek("cur")
|
|
self.workingfile:seek("set",cur+n)
|
|
else
|
|
if not n then return self.pos end
|
|
if #self.data-(self.pos-1)<n then
|
|
print(n-((#self.data)-(self.pos-1)))
|
|
self:write(string.rep("\0",n-((#self.data)-(self.pos-1))))
|
|
return
|
|
end
|
|
self.pos=self.pos+n
|
|
end
|
|
end
|
|
function bin:read(n)
|
|
if self.stream then
|
|
return self.workingfile:read(n)
|
|
else
|
|
local data=self.data:sub(self.pos,self.pos+n-1)
|
|
self.pos=self.pos+n
|
|
if data=="" then return end
|
|
return data
|
|
end
|
|
end
|
|
function bin:write(data,size)
|
|
local data=bin.normalizeData(data)
|
|
local dsize=#data
|
|
local size=tonumber(size or dsize)
|
|
if dsize>size then
|
|
data = data:sub(1,size)
|
|
elseif dsize<size then
|
|
data=data..string.rep("\0",size-dsize)
|
|
end
|
|
if self:canStreamWrite() then
|
|
self.workingfile:write(data)
|
|
elseif self.Type=="bin" then
|
|
local tab={}
|
|
if self.pos==1 then
|
|
tab={data,self.data:sub(self.pos+size)}
|
|
else
|
|
tab={self.data:sub(1,self.pos-1),data,self.data:sub(self.pos+size)}
|
|
end
|
|
self.pos=self.pos+size
|
|
self.data=table.concat(tab)
|
|
else
|
|
error("Attempted to write to a locked file!")
|
|
end
|
|
end
|
|
function bin:sub(a,b)
|
|
local data=""
|
|
if self.stream then
|
|
local cur=self.workingfile:seek("cur")
|
|
self.workingfile:seek("set",a-1)
|
|
data=self.workingfile:read(b-(a-1))
|
|
self.workingfile:seek("set",cur)
|
|
else
|
|
data=self.data:sub(a,b)
|
|
end
|
|
return data
|
|
end
|
|
function bin:slide(n)
|
|
local s=self:getSize()
|
|
local buf=bin.newDataBuffer(s)
|
|
buf:fillBuffer(1,self:getData())
|
|
for i=1,s do
|
|
nn=buf[i]+n
|
|
if nn>255 then
|
|
nn=nn%256
|
|
elseif nn<0 then
|
|
nn=256-math.abs(nn)
|
|
end
|
|
buf[i]=nn
|
|
end
|
|
self:setSeek(1)
|
|
self:write(buf:getData())
|
|
end
|
|
function bin:getData(a,b,fmt)
|
|
local data=""
|
|
if a or b then
|
|
data=self:sub(a,b)
|
|
else
|
|
if self.stream then
|
|
local cur=self.workingfile:seek("cur")
|
|
self.workingfile:seek("set",0)
|
|
data=self.workingfile:read("*a")
|
|
self.workingfile:seek("set",cur)
|
|
else
|
|
data=self.data
|
|
end
|
|
end
|
|
if fmt=="%x" or fmt=="hex" then
|
|
return bin.toHex(data):lower()
|
|
elseif fmt=="%X" or fmt=="HEX" then
|
|
return bin.toHex(data)
|
|
elseif fmt=="%b" or fmt=="b64" then
|
|
return bin.toB64(data)
|
|
elseif fmt then
|
|
return bin.new(data):getBlock(fmt,#data)
|
|
end
|
|
return data
|
|
end
|
|
function bin:getSize(fmt)
|
|
local len=0
|
|
if self.stream then
|
|
local cur=self.workingfile:seek("cur")
|
|
len=self.workingfile:seek("end")
|
|
self.workingfile:seek("set",cur)
|
|
else
|
|
len=#self.data
|
|
end
|
|
if fmt=="%b" then
|
|
return bin.toB64()
|
|
elseif fmt then
|
|
return string.format(fmt, len)
|
|
else
|
|
return len
|
|
end
|
|
end
|
|
function bin:tackE(data,size,h)
|
|
local data=bin.normalizeData(data)
|
|
local cur=self:getSize()
|
|
self:setSeek(self:getSize()+1)
|
|
self:write(data,size)
|
|
if h then
|
|
self:setSeek(cur+1)
|
|
end
|
|
end
|
|
function bin:tonumber(a,b)
|
|
local temp={}
|
|
if a then
|
|
temp.data=self:sub(a,b)
|
|
else
|
|
temp=self
|
|
end
|
|
local l,r=0,0
|
|
local g=#temp.data
|
|
for i=1,g do
|
|
r=r+(256^(g-i))*string.byte(string.sub(temp.data,i,i))
|
|
l=l+(256^(i-1))*string.byte(string.sub(temp.data,i,i))
|
|
end
|
|
return r,l
|
|
end
|
|
function bin.endianflop(data)
|
|
return string.reverse(data)
|
|
end
|
|
function bin:tofile(name)
|
|
if self.stream then return end
|
|
if not name then error("Must include a filename to save as!") end
|
|
file = io.open(name, "wb")
|
|
file:write(self.data)
|
|
file:close()
|
|
end
|
|
function bin:close()
|
|
if self.stream then
|
|
if bin.streams[self.file][2]==1 then
|
|
bin.streams[self.file]=nil
|
|
self.workingfile:close()
|
|
else
|
|
bin.streams[self.file][2]=bin.streams[self.file][2]-1
|
|
self.workingfile=io.tmpfile()
|
|
self.workingfile:close()
|
|
end
|
|
end
|
|
end
|
|
function bin:getBlock(t,n)
|
|
local data=""
|
|
if not n then
|
|
if bin.registerBlocks[t] then
|
|
return bin.registerBlocks[t][1](nil,self)
|
|
else
|
|
error("Unknown format! Cannot read from file: "..tostring(t))
|
|
end
|
|
else
|
|
if t=="n" or t=="%e" or t=="%E" then
|
|
data=self:read(n)
|
|
local numB=bin.defualtBit.new(data)
|
|
local numL=bin.defualtBit.new(string.reverse(data))
|
|
local little=numL:tonumber(0)
|
|
local big=numB:tonumber(0)
|
|
if t=="%E" then
|
|
return big
|
|
elseif t=="%X" then
|
|
return bin.toHex(data):upper()
|
|
elseif t=="%x" then
|
|
return bin.toHex(data):lower()
|
|
elseif t=="%b" then
|
|
return bin.toB64(data)
|
|
elseif t=="%e" then
|
|
return little
|
|
end
|
|
return big,little
|
|
elseif t=="s" then
|
|
return self:read(n)
|
|
elseif bin.registerBlocks[t] then
|
|
return bin.registerBlocks[t][1](n,self)
|
|
else
|
|
error("Unknown format! Cannot read from file: "..tostring(t))
|
|
end
|
|
end
|
|
end
|
|
function bin:addBlock(d,fit,fmt)
|
|
if not fmt then fmt=type(d):sub(1,1) end
|
|
if bin.registerBlocks[fmt] then
|
|
self:tackE(bin.registerBlocks[fmt][2](d,fit,fmt,self,bin.registerBlocks[fmt][2]))
|
|
elseif type(d)=="number" then
|
|
local data=bin.defualtBit.numToBytes(d,fit or 4,fmt,function()
|
|
error("Overflow! Space allotted for number is smaller than the number takes up. Increase the fit!")
|
|
end)
|
|
self:tackE(data)
|
|
elseif type(d)=="string" then
|
|
local data=d:sub(1,fit or -1)
|
|
if #data<(fit or #data) then
|
|
data=data..string.rep("\0",fit-#data)
|
|
end
|
|
self:tackE(data)
|
|
end
|
|
end
|
|
bin.registerBlocks={}
|
|
function bin.registerBlock(t,funcG,funcA)
|
|
bin.registerBlocks[t]={funcG,funcA}
|
|
end
|
|
function bin.newDataBuffer(size,fill) -- fills with \0 or nul or with what you enter
|
|
local c={}
|
|
local fill=fill or "\0"
|
|
c.data={self=c}
|
|
c.Type="buffer"
|
|
c.size=size or 0 -- 0 means an infinite buffer, sometimes useful
|
|
for i=1,c.size do
|
|
c.data[i]=fill
|
|
end
|
|
local mt={
|
|
__index=function(t,k)
|
|
if type(k)=="number" then
|
|
local data=t.data[k]
|
|
if data then
|
|
return string.byte(data)
|
|
else
|
|
error("Index out of range!")
|
|
end
|
|
elseif type(k)=="string" then
|
|
local num=tonumber(k)
|
|
if num then
|
|
local data=t.data[num]
|
|
if data then
|
|
return data
|
|
else
|
|
error("Index out of range!")
|
|
end
|
|
else
|
|
error("Only number-strings and numbers can be indexed!")
|
|
end
|
|
else
|
|
error("Only number-strings and numbers can be indexed!")
|
|
end
|
|
end,
|
|
__newindex=function(t,k,v)
|
|
if type(k)~="number" then error("Can only set a buffers data with a numeric index!") end
|
|
local data=""
|
|
if type(v)=="string" then
|
|
data=v
|
|
elseif type(v)=="number" then
|
|
data=string.char(v)
|
|
else
|
|
-- try to normalize the data of type v
|
|
data=bin.normalizeData(v)
|
|
end
|
|
t:fillBuffer(k,data)
|
|
end,
|
|
__tostring=function(t)
|
|
return t:getData()
|
|
end,
|
|
}
|
|
function c:fillBuffer(a,data)
|
|
local len=#data
|
|
if len==1 then
|
|
self.data[a]=data
|
|
else
|
|
local i=a-1
|
|
for d in data:gmatch(".") do
|
|
i=i+1
|
|
if i>c.size then
|
|
return #data-i+a
|
|
end
|
|
self.data[i]=d
|
|
end
|
|
return #data-i+(a-1)
|
|
end
|
|
end
|
|
function c:getData(a,b,fmt) -- LATER
|
|
local dat=bin.new(table.concat(self.data,"",a,b))
|
|
local n=dat:getSize()
|
|
return dat:getBlock(fmt or "s",n)
|
|
end
|
|
function c:getSize()
|
|
return #self:getData()
|
|
end
|
|
setmetatable(c,mt)
|
|
return c
|
|
end
|
|
function bin:newDataBufferFromStream(pos,size,fill) -- fills with \0 or nul or with what you enter IF the nothing exists inside the bin file.
|
|
local s=self:getSize()
|
|
if not self.stream then error("Can only created a streamed buffer on a streamable file!") end
|
|
if s==0 then
|
|
self:write(string.rep("\0",pos+size))
|
|
end
|
|
self:setSeek(1)
|
|
local c=bin.newDataBuffer(size,fill)
|
|
rawset(c,"pos",pos)
|
|
rawset(c,"size",size)
|
|
rawset(c,"fill",fill)
|
|
rawset(c,"bin",self)
|
|
rawset(c,"sync",function(self)
|
|
local cur=self.bin:getSeek()
|
|
self.bin:setSeek(self.pos)
|
|
self.bin:write(self:getData(),size)
|
|
self.bin:setSeek(cur)
|
|
end)
|
|
c:fillBuffer(1,self:sub(pos,pos+size))
|
|
function c:fillBuffer(a,data)
|
|
local len=#data
|
|
if len==1 then
|
|
self.data[a]=data
|
|
self:sync()
|
|
else
|
|
local i=a-1
|
|
for d in data:gmatch(".") do
|
|
i=i+1
|
|
if i>c.size then
|
|
self:sync()
|
|
return #data-i+a
|
|
end
|
|
self.data[i]=d
|
|
end
|
|
self:sync()
|
|
return #data-i+(a-1)
|
|
end
|
|
end
|
|
return c
|
|
end
|
|
function bin:toDataBuffer()
|
|
local s=self:getSize()
|
|
-- if self:canStreamWrite() then
|
|
-- return self:newDataBufferFromStream(0,s)
|
|
-- end
|
|
local buf=bin.newDataBuffer(s)
|
|
local data=self:read(512)
|
|
local i=1
|
|
while data~=nil do
|
|
buf[i]=data
|
|
data=self:read(512)
|
|
i=i+512
|
|
end
|
|
return buf
|
|
end
|
|
function bin:getHash()
|
|
if self:getSize()==0 then
|
|
return "NaN"
|
|
end
|
|
n=32
|
|
local rand = randomGen:newND(1,self:getSize(),self:getSize())
|
|
local h,g={},0
|
|
for i=1,n do
|
|
g=rand:nextInt()
|
|
table.insert(h,bin.toHex(self:sub(g,g)))
|
|
end
|
|
return table.concat(h,'')
|
|
end
|
|
function bin:flipbits()
|
|
if self:canStreamWrite() then
|
|
self:setSeek(1)
|
|
for i=1,self:getSize() do
|
|
self:write(string.char(255-string.byte(self:sub(i,i))))
|
|
end
|
|
else
|
|
local temp={}
|
|
for i=1,#self.data do
|
|
table.insert(temp,string.char(255-string.byte(string.sub(self.data,i,i))))
|
|
end
|
|
self.data=table.concat(temp,'')
|
|
end
|
|
end
|
|
function bin:encrypt()
|
|
self:flipbits()
|
|
end
|
|
function bin:decrypt()
|
|
self:flipbits()
|
|
end
|
|
-- Use with small files!
|
|
function bin:gsub(...)
|
|
local data=self:getData()
|
|
local pos=self:getSeek()
|
|
self:setSeek(1)
|
|
self:write((data:gsub(...)) or data)
|
|
self:setSeek(loc)
|
|
end
|
|
function bin:gmatch(pat)
|
|
return self:getData():gmatch(pat)
|
|
end
|
|
function bin:match(pat)
|
|
return self:getData():match(pat)
|
|
end
|
|
function bin:trim()
|
|
local data=self:getData()
|
|
local pos=self:getSeek()
|
|
self:setSeek(1)
|
|
self:write(data:match'^()%s*$' and '' or data:match'^%s*(.*%S)')
|
|
self:setSeek(loc)
|
|
end
|
|
function bin:lines()
|
|
local t = {}
|
|
local function helper(line) table.insert(t, line) return '' end
|
|
helper((self:getData():gsub('(.-)\r?\n', helper)))
|
|
return t
|
|
end
|
|
function bin._lines(str)
|
|
local t = {}
|
|
local function helper(line) table.insert(t, line) return '' end
|
|
helper((str:gsub('(.-)\r?\n', helper)))
|
|
return t
|
|
end
|
|
function bin:wipe()
|
|
if self:canStreamWrite() then
|
|
self:close()
|
|
local c=bin.freshStream(self.file)
|
|
self.workingfile=c.workingfile
|
|
else
|
|
self.data=""
|
|
end
|
|
self:setSeek(1)
|
|
end
|
|
function bin:fullTrim(empty)
|
|
local t=self:lines()
|
|
for i=#t,1,-1 do
|
|
t[i]=bin._trim(t[i])
|
|
if empty then
|
|
if t[i]=="" then
|
|
table.remove(t,i)
|
|
end
|
|
end
|
|
end
|
|
self:wipe()
|
|
self:write(table.concat(t,"\n"))
|
|
end
|
|
local __CURRENTVERSION=2
|
|
bin.registerBlock("t",function(SIZE_OR_NIL,ref)
|
|
local header=ref:read(3)
|
|
if not header:match("(LT.)") then error("Not a valid table struct!") end
|
|
if bin.defualtBit.new(header:sub(3,3)):tonumber(1)>__CURRENTVERSION then error("Incompatible Version of LuaTable!") end
|
|
local len=ref:getBlock("n",4) -- hehe lets make life easier
|
|
local tab={}
|
|
local ind
|
|
local n=0
|
|
while true do
|
|
local _dat=ref:read(2)
|
|
if _dat==nil then break end
|
|
local it,dt=_dat:match("(.)(.)")
|
|
n=n+2
|
|
if it=="N" then -- get the index stuff out of the way first
|
|
ind=ref:getBlock("n",4)
|
|
n=n+4
|
|
else
|
|
indL=ref:getBlock("n",1)
|
|
n=n+1+indL
|
|
ind=ref:read(indL)
|
|
end
|
|
if dt=="N" then
|
|
tab[ind]=ref:getBlock("d")
|
|
n=n+8
|
|
elseif dt=="I" then
|
|
tab[ind]=math.huge
|
|
ref:getBlock("n",4)
|
|
n=n+4
|
|
elseif dt=="i" then
|
|
tab[ind]=-math.huge
|
|
ref:getBlock("n",4)
|
|
n=n+4
|
|
elseif dt=="S" then
|
|
local nn=ref:getBlock("n",4)
|
|
tab[ind]=ref:read(nn)
|
|
n=n+4+nn
|
|
elseif dt=="B" then
|
|
tab[ind]=({["\255"]=true,["\0"]=false})[ref:read(1)]
|
|
n=n+1
|
|
elseif dt=="F" then
|
|
local nn=ref:getBlock("n",4)
|
|
tab[ind]=loadstring(ref:read(nn))
|
|
n=n+4+nn
|
|
elseif dt=="T" then
|
|
local cur=ref:getSeek()
|
|
local size=ref:getBlock("n",4)
|
|
ref:setSeek(cur)
|
|
ref:read(4)
|
|
if size==7 then
|
|
tab[ind]={}
|
|
ref:read(7)
|
|
n=n+11
|
|
else
|
|
local data=bin.new(ref:read(size))
|
|
local dat=data:getBlock("t")
|
|
if dat.__RECURSIVE then
|
|
tab[ind]=tab
|
|
else
|
|
tab[ind]=dat
|
|
end
|
|
n=n+data:getSize()+4
|
|
end
|
|
end
|
|
if n==len then break end
|
|
end
|
|
return bin.resolveType(tab)
|
|
end,function(d,fit,fmt,self,rec,tabsaw)
|
|
-- INGORE FIT WE ARE CREATING A STRUCT!!!
|
|
-- fmt will apply to all numbers
|
|
local __rem=nil
|
|
if not tabsaw then rem=true end
|
|
local tabsaw=tabsaw or {}
|
|
if rem then
|
|
table.insert(tabsaw,d)
|
|
end
|
|
local bData={}
|
|
for i,v in pairs(d) do -- this is for tables, all but userdata is fine. Depending on where you are using lua functions may or may not work
|
|
local tp=type(v):sub(1,1):upper() -- uppercase of datatype
|
|
if type(i)=="number" then -- Lets handle indexies
|
|
if v==math.huge then
|
|
tp="I"
|
|
v=0
|
|
elseif v==-math.huge then
|
|
tp="i"
|
|
v=0
|
|
end
|
|
table.insert(bData,"N"..tp..bin.defualtBit.numToBytes(i,4)) -- number index?
|
|
elseif type(i)=="string" then
|
|
if #i>255 then error("A string index cannot be larger than 255 bytes!") end
|
|
table.insert(bData,"S"..tp..bin.defualtBit.numToBytes(#i,1)..i) -- string index?
|
|
else
|
|
error("Only numbers and strings can be a table index!") -- throw error?
|
|
end
|
|
if type(v)=="number" then
|
|
-- How do we handle number data
|
|
local temp=bin.new()
|
|
temp:addBlock(v,nil,"d")
|
|
table.insert(bData,temp.data)
|
|
elseif type(v)=="string" then
|
|
-- Lets work on strings
|
|
table.insert(bData,bin.defualtBit.numToBytes(#v,4)) -- add length of string
|
|
table.insert(bData,v) -- add string
|
|
elseif type(v)=="boolean" then -- bools are easy :D
|
|
table.insert(bData,({[true]="\255",[false]="\0"})[v])
|
|
elseif type(v)=="function" then -- should we allow this? why not...
|
|
local dump=string.dump(v)
|
|
table.insert(bData,bin.defualtBit.numToBytes(#dump,4)) -- add length of dumped string
|
|
table.insert(bData,dump) -- add it
|
|
elseif type(v)=="table" then -- tables...
|
|
if tabsaw[1]==v then
|
|
v={__RECURSIVE=i}
|
|
else
|
|
tabsaw[i]=v
|
|
end
|
|
local data=rec(v,nil,"t",self,rec,tabsaw)
|
|
table.insert(bData,bin.defualtBit.numToBytes(#data,4)) -- add length of string
|
|
table.insert(bData,data) -- add string
|
|
end
|
|
end
|
|
local data=table.concat(bData)
|
|
return "LT"..string.char(__CURRENTVERSION)..bin.defualtBit.numToBytes(#data,4)..data
|
|
end)
|
|
bin.registerBlock("b",function(SIZE_OR_NIL,ref)
|
|
return ({["\255"]=true,["\0"]=false})[ref:read(1)]
|
|
end,function(d)
|
|
return ({[true]="\255",[false]="\0"})[d]
|
|
end)
|
|
bin.registerBlock("f",function(SIZE_OR_NIL,ref)
|
|
local nn=ref:getBlock("n",4)
|
|
return loadstring(ref:read(nn))
|
|
end,function(d)
|
|
local dump=string.dump(d)
|
|
return bin.defualtBit.numToBytes(#dump,4)..dump
|
|
end)
|
|
bin.registerBlock("d",function(SIZE_OR_NIL,ref)
|
|
local w,p=ref:getBlock("n",4),ref:getBlock("n",4)
|
|
p=tonumber("0."..tostring(p))
|
|
return w+p
|
|
end,function(d,fit,fmt,self,rec,tabsaw)
|
|
local w,p = toFraction(d)
|
|
local temp=bin.new()
|
|
temp:addBlock(w,4)
|
|
temp:addBlock(p,4)
|
|
return temp.data
|
|
end)
|
|
if love then
|
|
function bin.load(file,s,r)
|
|
content, size = love.filesystem.read(file)
|
|
local temp=bin.new(content)
|
|
temp.filepath=file
|
|
return temp
|
|
end
|
|
function bin.fileExists(name)
|
|
return love.filesystem.getInfo(name)
|
|
end
|
|
function bin:tofile(filename)
|
|
if not(filename) or self.Stream then return nil end
|
|
love.filesystem.write(filename,self.data)
|
|
end
|
|
function bin.loadS(path,s,r)
|
|
local path = love.filesystem.getSaveDirectory( ).."\\"..path
|
|
if type(path) ~= "string" then error("Path must be a string!") end
|
|
local f = io.open(path, 'rb')
|
|
local content = f:read('*a')
|
|
f:close()
|
|
return bin.new(content)
|
|
end
|
|
function bin:tofileS(filename)
|
|
if self.stream then return end
|
|
local filename = love.filesystem.getSaveDirectory( ).."\\"..filename
|
|
print(#self.data,filename)
|
|
if not filename then error("Must include a filename to save as!") end
|
|
file = io.open(filename, "wb")
|
|
file:write(self.data)
|
|
file:close()
|
|
end
|
|
function bin.stream(file)
|
|
return bin.newStreamFileObject(love.filesystem.newFile(file))
|
|
end
|
|
function bin:getSize(fmt)
|
|
local len=0
|
|
if self.stream then
|
|
local len=self.workingfile:getSize()
|
|
else
|
|
len=#self.data
|
|
end
|
|
if fmt=="%b" then
|
|
return bin.toB64()
|
|
elseif fmt then
|
|
return string.format(fmt, len)
|
|
else
|
|
return len
|
|
end
|
|
end
|
|
function bin:getSeek()
|
|
if self.stream then
|
|
return self.workingfile:tell()+1
|
|
else
|
|
return self.pos
|
|
end
|
|
end
|
|
function bin:setSeek(n)
|
|
if self.stream then
|
|
self.workingfile:seek(n-1)
|
|
else
|
|
self.pos=n
|
|
end
|
|
end
|
|
function bin:seek(n)
|
|
if self.stream then
|
|
self.workingfile:seek(n)
|
|
else
|
|
if not n then return self.pos end
|
|
if #self.data-(self.pos-1)<n then
|
|
print(n-((#self.data)-(self.pos-1)))
|
|
self:write(string.rep("\0",n-((#self.data)-(self.pos-1))))
|
|
return
|
|
end
|
|
self.pos=self.pos+n
|
|
end
|
|
end
|
|
function bin:close()
|
|
self.workingfile:close()
|
|
end
|
|
end
|
|
return bin |