Working on bin library, need to fix and make consistant
This commit is contained in:
parent
1b0fe31002
commit
4eb7d84e5e
85
base91.lua
85
base91.lua
@ -1,85 +0,0 @@
|
|||||||
-- Part of the massive rewrite I am making for the bin library. this library will sport hex, base32, base64, and base91 when it is done
|
|
||||||
-- For now feel free to take a look at this code and use it for your own needs
|
|
||||||
bit=require("bit")
|
|
||||||
function table.flip(t)
|
|
||||||
local tt={}
|
|
||||||
for i,v in pairs(t) do
|
|
||||||
tt[v]=i
|
|
||||||
end
|
|
||||||
return tt
|
|
||||||
end
|
|
||||||
b91enc={
|
|
||||||
'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',
|
|
||||||
'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',
|
|
||||||
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '!', '#', '$',
|
|
||||||
'%', '&', '(', ')', '*', '+', ',', '.', '/', ':', ';', '<', '=',
|
|
||||||
'>', '?', '@', '[', ']', '^', '_', '`', '{', '|', '}', '~', '"'
|
|
||||||
}
|
|
||||||
b91enc[0]='A' -- algorithm expects a 0 as the first index, lua starts at 1... easy fix :)
|
|
||||||
b91dec=table.flip(b91enc)
|
|
||||||
function decode(d)
|
|
||||||
local l,v,o,b,n = #d,-1,"",0,0
|
|
||||||
for i in d:gmatch(".") do
|
|
||||||
local c=b91dec[i]
|
|
||||||
if not(c) then
|
|
||||||
-- Continue
|
|
||||||
else
|
|
||||||
if v < 0 then
|
|
||||||
v = c
|
|
||||||
else
|
|
||||||
v = v+c*91
|
|
||||||
b = bit.bor(b, bit.lshift(v,n))
|
|
||||||
if bit.band(v,8191) then
|
|
||||||
n = n + 13
|
|
||||||
else
|
|
||||||
n = n + 14
|
|
||||||
end
|
|
||||||
while true do
|
|
||||||
o=o..string.char(bit.band(b,255))
|
|
||||||
b=bit.rshift(b,8)
|
|
||||||
n=n-8
|
|
||||||
if not (n>7) then
|
|
||||||
break
|
|
||||||
end
|
|
||||||
end
|
|
||||||
v=-1
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
if v + 1>0 then
|
|
||||||
o=o..string.char(bit.band(bit.bor(b,bit.lshift(v,n)),255))
|
|
||||||
end
|
|
||||||
return o
|
|
||||||
end
|
|
||||||
function encode(d)
|
|
||||||
local b,n,o,l=0,0,"",#d
|
|
||||||
for i in d:gmatch(".") do
|
|
||||||
b=bit.bor(b,bit.lshift(string.byte(i),n))
|
|
||||||
n=n+8
|
|
||||||
if n>13 then
|
|
||||||
v=bit.band(b,8191)
|
|
||||||
if v>88 then
|
|
||||||
b=bit.rshift(b,13)
|
|
||||||
n=n-13
|
|
||||||
else
|
|
||||||
v=bit.band(b,16383)
|
|
||||||
b=bit.rshift(b,14)
|
|
||||||
n=n-14
|
|
||||||
end
|
|
||||||
o=o..b91enc[v % 91] .. b91enc[math.floor(v / 91)]
|
|
||||||
end
|
|
||||||
end
|
|
||||||
if n>0 then
|
|
||||||
o=o..b91enc[b % 91]
|
|
||||||
if n>7 or b>90 then
|
|
||||||
o=o .. b91enc[math.floor(b / 91)]
|
|
||||||
end
|
|
||||||
end
|
|
||||||
return o
|
|
||||||
end
|
|
||||||
enc=encode("Hungry for Apples!")
|
|
||||||
print(enc)
|
|
||||||
dec=decode(enc)
|
|
||||||
print(dec)
|
|
||||||
@ -1,73 +0,0 @@
|
|||||||
--[[
|
|
||||||
LZW String Compression demo for Gideros
|
|
||||||
This code is MIT licensed, see http://www.opensource.org/licenses/mit-license.php
|
|
||||||
(C) 2013 - Guava7
|
|
||||||
]]
|
|
||||||
CLZWCompression = {}
|
|
||||||
function CLZWCompression:InitDictionary(isEncode)
|
|
||||||
self.mDictionary = {}
|
|
||||||
-- local s = " !#$%&'\"()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
|
|
||||||
local s={}
|
|
||||||
for i=1,255 do
|
|
||||||
s[#s+1]=string.char(i)
|
|
||||||
end
|
|
||||||
s=table.concat(s)
|
|
||||||
local len = #s
|
|
||||||
for i = 1, len do
|
|
||||||
if isEncode then
|
|
||||||
self.mDictionary[s:sub(i, i)] = i
|
|
||||||
else
|
|
||||||
self.mDictionary[i] = s:sub(i, i)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
self.mDictionaryLen = len
|
|
||||||
end
|
|
||||||
function CLZWCompression:Encode(sInput)
|
|
||||||
self:InitDictionary(true)
|
|
||||||
local s = ""
|
|
||||||
local ch
|
|
||||||
local len = #sInput
|
|
||||||
local result = {}
|
|
||||||
local dic = self.mDictionary
|
|
||||||
local temp
|
|
||||||
for i = 1, len do
|
|
||||||
ch = sInput:sub(i, i)
|
|
||||||
temp = s..ch
|
|
||||||
if dic[temp] then
|
|
||||||
s = temp
|
|
||||||
else
|
|
||||||
result[#result + 1] = dic[s]
|
|
||||||
self.mDictionaryLen = self.mDictionaryLen + 1
|
|
||||||
dic[temp] = self.mDictionaryLen
|
|
||||||
s = ch
|
|
||||||
end
|
|
||||||
end
|
|
||||||
result[#result + 1] = dic[s]
|
|
||||||
return result
|
|
||||||
end
|
|
||||||
function CLZWCompression:Decode(data)
|
|
||||||
self:InitDictionary(false)
|
|
||||||
local dic = self.mDictionary
|
|
||||||
local entry
|
|
||||||
local ch
|
|
||||||
local prevCode, currCode
|
|
||||||
local result = {}
|
|
||||||
prevCode = data[1]
|
|
||||||
result[#result + 1] = dic[prevCode]
|
|
||||||
for i = 2, #data do
|
|
||||||
currCode = data[i]
|
|
||||||
entry = dic[currCode]
|
|
||||||
if entry then
|
|
||||||
ch = entry:sub(1, 1)
|
|
||||||
result[#result + 1] = entry
|
|
||||||
else
|
|
||||||
ch = dic[prevCode]:sub(1, 1)
|
|
||||||
result[#result + 1] = dic[prevCode]..ch
|
|
||||||
end
|
|
||||||
dic[#dic + 1] = dic[prevCode]..ch
|
|
||||||
prevCode = currCode
|
|
||||||
end
|
|
||||||
return table.concat(result)
|
|
||||||
end
|
|
||||||
|
|
||||||
return CLZWCompression
|
|
||||||
@ -1,40 +0,0 @@
|
|||||||
local bin = require("bin")
|
|
||||||
local base64={}
|
|
||||||
local bs = { [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','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','0','1','2','3','4','5','6','7','8','9','+','/',
|
|
||||||
}
|
|
||||||
local bsd=table.flip(bs)
|
|
||||||
local char=string.char
|
|
||||||
function base64.encode(s)
|
|
||||||
local byte, rep, pad = string.byte, string.rep, 2 - ((#s-1) % 3)
|
|
||||||
s = (s..rep('\0', pad)):gsub("...", function(cs)
|
|
||||||
local a, b, c = byte(cs, 1, 3)
|
|
||||||
return bs[bit.rshift(a,2)] .. bs[bit.bor(bit.lshift(bit.band(a,3),4),bit.rshift(b,4))] .. bs[bit.bor(bit.lshift(bit.band(b,15),2),bit.rshift(c,6))] .. bs[bit.band(c,63)]
|
|
||||||
end)
|
|
||||||
return s:sub(1, #s-pad) .. rep('=', pad)
|
|
||||||
end
|
|
||||||
function base64.decode(s)
|
|
||||||
local s=s:match("["..s.."=]+")
|
|
||||||
local p,cc=s:gsub("=","A")
|
|
||||||
local r=""
|
|
||||||
local n=0
|
|
||||||
s=s:sub(1,#s-#p)..p
|
|
||||||
for c = 1,#s,4 do
|
|
||||||
n = bit.lshift(bsd[s:sub(c, c)], 18) + bit.lshift(bsd[s:sub(c+1, c+1)], 12) + bit.lshift(bsd[s:sub(c + 2, c + 2)], 6) + bsd[s:sub(c + 3, c + 3)]
|
|
||||||
r = r .. char(bit.band(bit.arshift(n, 16), 0xFF)) .. char(bit.band(bit.arshift(n, 8), 0xFF)) .. char(bit.band(n, 0xFF))
|
|
||||||
end
|
|
||||||
return r:sub(1,-(cc+1))
|
|
||||||
end
|
|
||||||
function bin.newFromBase91(data)
|
|
||||||
return bin.new(bin.fromBase91(data))
|
|
||||||
end
|
|
||||||
function bin.toBase91(s)
|
|
||||||
return base91.encode(s)
|
|
||||||
end
|
|
||||||
function bin.fromBase91(s)
|
|
||||||
return base91.decode(s)
|
|
||||||
end
|
|
||||||
return base64
|
|
||||||
@ -1,82 +0,0 @@
|
|||||||
local bin = require("bin")
|
|
||||||
local base91={}
|
|
||||||
local b91enc={[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',
|
|
||||||
'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',
|
|
||||||
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '!', '#', '$',
|
|
||||||
'%', '&', '(', ')', '*', '+', ',', '.', '/', ':', ';', '<', '=',
|
|
||||||
'>', '?', '@', '[', ']', '^', '_', '`', '{', '|', '}', '~', '"'
|
|
||||||
}
|
|
||||||
local b91dec=table.flip(b91enc)
|
|
||||||
function base91.decode(d)
|
|
||||||
local l,v,o,b,n = #d,-1,"",0,0
|
|
||||||
for i in d:gmatch(".") do
|
|
||||||
local c=b91dec[i]
|
|
||||||
if not(c) then
|
|
||||||
-- Continue
|
|
||||||
else
|
|
||||||
if v < 0 then
|
|
||||||
v = c
|
|
||||||
else
|
|
||||||
v = v+c*91
|
|
||||||
b = bit.bor(b, bit.lshift(v,n))
|
|
||||||
if bit.band(v,8191) then
|
|
||||||
n = n + 13
|
|
||||||
else
|
|
||||||
n = n + 14
|
|
||||||
end
|
|
||||||
while true do
|
|
||||||
o=o..string.char(bit.band(b,255))
|
|
||||||
b=bit.rshift(b,8)
|
|
||||||
n=n-8
|
|
||||||
if not (n>7) then
|
|
||||||
break
|
|
||||||
end
|
|
||||||
end
|
|
||||||
v=-1
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
if v + 1>0 then
|
|
||||||
o=o..string.char(bit.band(bit.bor(b,bit.lshift(v,n)),255))
|
|
||||||
end
|
|
||||||
return o
|
|
||||||
end
|
|
||||||
function base91.encode(d)
|
|
||||||
local b,n,o,l=0,0,"",#d
|
|
||||||
for i in d:gmatch(".") do
|
|
||||||
b=bit.bor(b,bit.lshift(string.byte(i),n))
|
|
||||||
n=n+8
|
|
||||||
if n>13 then
|
|
||||||
v=bit.band(b,8191)
|
|
||||||
if v>88 then
|
|
||||||
b=bit.rshift(b,13)
|
|
||||||
n=n-13
|
|
||||||
else
|
|
||||||
v=bit.band(b,16383)
|
|
||||||
b=bit.rshift(b,14)
|
|
||||||
n=n-14
|
|
||||||
end
|
|
||||||
o=o..b91enc[v % 91] .. b91enc[math.floor(v / 91)]
|
|
||||||
end
|
|
||||||
end
|
|
||||||
if n>0 then
|
|
||||||
o=o..b91enc[b % 91]
|
|
||||||
if n>7 or b>90 then
|
|
||||||
o=o .. b91enc[math.floor(b / 91)]
|
|
||||||
end
|
|
||||||
end
|
|
||||||
return o
|
|
||||||
end
|
|
||||||
function bin.newFromBase64(data)
|
|
||||||
return bin.new(bin.fromBase64(data))
|
|
||||||
end
|
|
||||||
function bin.toBase64(s)
|
|
||||||
return base64.encode(s)
|
|
||||||
end
|
|
||||||
function bin.fromBase64(s)
|
|
||||||
return base64.decode(s)
|
|
||||||
end
|
|
||||||
return base91
|
|
||||||
@ -1,394 +0,0 @@
|
|||||||
local bin = require("bin")
|
|
||||||
local md5 = {
|
|
||||||
_VERSION = "md5.lua 1.1.0",
|
|
||||||
_DESCRIPTION = "MD5 computation in Lua (5.1-3, LuaJIT)",
|
|
||||||
_URL = "https://github.com/kikito/md5.lua",
|
|
||||||
_LICENSE = [[
|
|
||||||
MIT LICENSE
|
|
||||||
|
|
||||||
Copyright (c) 2013 Enrique García Cota + Adam Baldwin + hanzao + Equi 4 Software
|
|
||||||
]]
|
|
||||||
}
|
|
||||||
|
|
||||||
-- bit lib implementions
|
|
||||||
|
|
||||||
local char, byte, format, rep, sub =
|
|
||||||
string.char, string.byte, string.format, string.rep, string.sub
|
|
||||||
local bit_or, bit_and, bit_not, bit_xor, bit_rshift, bit_lshift
|
|
||||||
|
|
||||||
local ok, bit = pcall(require, 'bit')
|
|
||||||
if ok then
|
|
||||||
bit_or, bit_and, bit_not, bit_xor, bit_rshift, bit_lshift = bit.bor, bit.band, bit.bnot, bit.bxor, bit.rshift, bit.lshift
|
|
||||||
else
|
|
||||||
ok, bit = pcall(require, 'bit32')
|
|
||||||
|
|
||||||
if ok then
|
|
||||||
|
|
||||||
bit_not = bit.bnot
|
|
||||||
|
|
||||||
local tobit = function(n)
|
|
||||||
return n <= 0x7fffffff and n or -(bit_not(n) + 1)
|
|
||||||
end
|
|
||||||
|
|
||||||
local normalize = function(f)
|
|
||||||
return function(a,b) return tobit(f(tobit(a), tobit(b))) end
|
|
||||||
end
|
|
||||||
|
|
||||||
bit_or, bit_and, bit_xor = normalize(bit.bor), normalize(bit.band), normalize(bit.bxor)
|
|
||||||
bit_rshift, bit_lshift = normalize(bit.rshift), normalize(bit.lshift)
|
|
||||||
|
|
||||||
else
|
|
||||||
|
|
||||||
local function tbl2number(tbl)
|
|
||||||
local result = 0
|
|
||||||
local power = 1
|
|
||||||
for i = 1, #tbl do
|
|
||||||
result = result + tbl[i] * power
|
|
||||||
power = power * 2
|
|
||||||
end
|
|
||||||
return result
|
|
||||||
end
|
|
||||||
|
|
||||||
local function expand(t1, t2)
|
|
||||||
local big, small = t1, t2
|
|
||||||
if(#big < #small) then
|
|
||||||
big, small = small, big
|
|
||||||
end
|
|
||||||
-- expand small
|
|
||||||
for i = #small + 1, #big do
|
|
||||||
small[i] = 0
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
local to_bits -- needs to be declared before bit_not
|
|
||||||
|
|
||||||
bit_not = function(n)
|
|
||||||
local tbl = to_bits(n)
|
|
||||||
local size = math.max(#tbl, 32)
|
|
||||||
for i = 1, size do
|
|
||||||
if(tbl[i] == 1) then
|
|
||||||
tbl[i] = 0
|
|
||||||
else
|
|
||||||
tbl[i] = 1
|
|
||||||
end
|
|
||||||
end
|
|
||||||
return tbl2number(tbl)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- defined as local above
|
|
||||||
to_bits = function (n)
|
|
||||||
if(n < 0) then
|
|
||||||
-- negative
|
|
||||||
return to_bits(bit_not(math.abs(n)) + 1)
|
|
||||||
end
|
|
||||||
-- to bits table
|
|
||||||
local tbl = {}
|
|
||||||
local cnt = 1
|
|
||||||
local last
|
|
||||||
while n > 0 do
|
|
||||||
last = n % 2
|
|
||||||
tbl[cnt] = last
|
|
||||||
n = (n-last)/2
|
|
||||||
cnt = cnt + 1
|
|
||||||
end
|
|
||||||
|
|
||||||
return tbl
|
|
||||||
end
|
|
||||||
|
|
||||||
bit_or = function(m, n)
|
|
||||||
local tbl_m = to_bits(m)
|
|
||||||
local tbl_n = to_bits(n)
|
|
||||||
expand(tbl_m, tbl_n)
|
|
||||||
|
|
||||||
local tbl = {}
|
|
||||||
for i = 1, #tbl_m do
|
|
||||||
if(tbl_m[i]== 0 and tbl_n[i] == 0) then
|
|
||||||
tbl[i] = 0
|
|
||||||
else
|
|
||||||
tbl[i] = 1
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
return tbl2number(tbl)
|
|
||||||
end
|
|
||||||
|
|
||||||
bit_and = function(m, n)
|
|
||||||
local tbl_m = to_bits(m)
|
|
||||||
local tbl_n = to_bits(n)
|
|
||||||
expand(tbl_m, tbl_n)
|
|
||||||
|
|
||||||
local tbl = {}
|
|
||||||
for i = 1, #tbl_m do
|
|
||||||
if(tbl_m[i]== 0 or tbl_n[i] == 0) then
|
|
||||||
tbl[i] = 0
|
|
||||||
else
|
|
||||||
tbl[i] = 1
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
return tbl2number(tbl)
|
|
||||||
end
|
|
||||||
|
|
||||||
bit_xor = function(m, n)
|
|
||||||
local tbl_m = to_bits(m)
|
|
||||||
local tbl_n = to_bits(n)
|
|
||||||
expand(tbl_m, tbl_n)
|
|
||||||
|
|
||||||
local tbl = {}
|
|
||||||
for i = 1, #tbl_m do
|
|
||||||
if(tbl_m[i] ~= tbl_n[i]) then
|
|
||||||
tbl[i] = 1
|
|
||||||
else
|
|
||||||
tbl[i] = 0
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
return tbl2number(tbl)
|
|
||||||
end
|
|
||||||
|
|
||||||
bit_rshift = function(n, bits)
|
|
||||||
local high_bit = 0
|
|
||||||
if(n < 0) then
|
|
||||||
-- negative
|
|
||||||
n = bit_not(math.abs(n)) + 1
|
|
||||||
high_bit = 0x80000000
|
|
||||||
end
|
|
||||||
|
|
||||||
local floor = math.floor
|
|
||||||
|
|
||||||
for i=1, bits do
|
|
||||||
n = n/2
|
|
||||||
n = bit_or(floor(n), high_bit)
|
|
||||||
end
|
|
||||||
return floor(n)
|
|
||||||
end
|
|
||||||
|
|
||||||
bit_lshift = function(n, bits)
|
|
||||||
if(n < 0) then
|
|
||||||
-- negative
|
|
||||||
n = bit_not(math.abs(n)) + 1
|
|
||||||
end
|
|
||||||
|
|
||||||
for i=1, bits do
|
|
||||||
n = n*2
|
|
||||||
end
|
|
||||||
return bit_and(n, 0xFFFFFFFF)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
-- convert little-endian 32-bit int to a 4-char string
|
|
||||||
local function lei2str(i)
|
|
||||||
local f=function (s) return char( bit_and( bit_rshift(i, s), 255)) end
|
|
||||||
return f(0)..f(8)..f(16)..f(24)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- convert raw string to big-endian int
|
|
||||||
local function str2bei(s)
|
|
||||||
local v=0
|
|
||||||
for i=1, #s do
|
|
||||||
v = v * 256 + byte(s, i)
|
|
||||||
end
|
|
||||||
return v
|
|
||||||
end
|
|
||||||
|
|
||||||
-- convert raw string to little-endian int
|
|
||||||
local function str2lei(s)
|
|
||||||
local v=0
|
|
||||||
for i = #s,1,-1 do
|
|
||||||
v = v*256 + byte(s, i)
|
|
||||||
end
|
|
||||||
return v
|
|
||||||
end
|
|
||||||
|
|
||||||
-- cut up a string in little-endian ints of given size
|
|
||||||
local function cut_le_str(s,...)
|
|
||||||
local o, r = 1, {}
|
|
||||||
local args = {...}
|
|
||||||
for i=1, #args do
|
|
||||||
table.insert(r, str2lei(sub(s, o, o + args[i] - 1)))
|
|
||||||
o = o + args[i]
|
|
||||||
end
|
|
||||||
return r
|
|
||||||
end
|
|
||||||
|
|
||||||
local swap = function (w) return str2bei(lei2str(w)) end
|
|
||||||
|
|
||||||
-- An MD5 mplementation in Lua, requires bitlib (hacked to use LuaBit from above, ugh)
|
|
||||||
-- 10/02/2001 jcw@equi4.com
|
|
||||||
|
|
||||||
local CONSTS = {
|
|
||||||
0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
|
|
||||||
0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
|
|
||||||
0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
|
|
||||||
0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
|
|
||||||
0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
|
|
||||||
0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
|
|
||||||
0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
|
|
||||||
0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
|
|
||||||
0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
|
|
||||||
0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
|
|
||||||
0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05,
|
|
||||||
0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
|
|
||||||
0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
|
|
||||||
0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
|
|
||||||
0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
|
|
||||||
0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391,
|
|
||||||
0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476
|
|
||||||
}
|
|
||||||
|
|
||||||
local f=function (x,y,z) return bit_or(bit_and(x,y),bit_and(-x-1,z)) end
|
|
||||||
local g=function (x,y,z) return bit_or(bit_and(x,z),bit_and(y,-z-1)) end
|
|
||||||
local h=function (x,y,z) return bit_xor(x,bit_xor(y,z)) end
|
|
||||||
local i=function (x,y,z) return bit_xor(y,bit_or(x,-z-1)) end
|
|
||||||
local z=function (ff,a,b,c,d,x,s,ac)
|
|
||||||
a=bit_and(a+ff(b,c,d)+x+ac,0xFFFFFFFF)
|
|
||||||
-- be *very* careful that left shift does not cause rounding!
|
|
||||||
return bit_or(bit_lshift(bit_and(a,bit_rshift(0xFFFFFFFF,s)),s),bit_rshift(a,32-s))+b
|
|
||||||
end
|
|
||||||
|
|
||||||
local function transform(A,B,C,D,X)
|
|
||||||
local a,b,c,d=A,B,C,D
|
|
||||||
local t=CONSTS
|
|
||||||
|
|
||||||
a=z(f,a,b,c,d,X[ 0], 7,t[ 1])
|
|
||||||
d=z(f,d,a,b,c,X[ 1],12,t[ 2])
|
|
||||||
c=z(f,c,d,a,b,X[ 2],17,t[ 3])
|
|
||||||
b=z(f,b,c,d,a,X[ 3],22,t[ 4])
|
|
||||||
a=z(f,a,b,c,d,X[ 4], 7,t[ 5])
|
|
||||||
d=z(f,d,a,b,c,X[ 5],12,t[ 6])
|
|
||||||
c=z(f,c,d,a,b,X[ 6],17,t[ 7])
|
|
||||||
b=z(f,b,c,d,a,X[ 7],22,t[ 8])
|
|
||||||
a=z(f,a,b,c,d,X[ 8], 7,t[ 9])
|
|
||||||
d=z(f,d,a,b,c,X[ 9],12,t[10])
|
|
||||||
c=z(f,c,d,a,b,X[10],17,t[11])
|
|
||||||
b=z(f,b,c,d,a,X[11],22,t[12])
|
|
||||||
a=z(f,a,b,c,d,X[12], 7,t[13])
|
|
||||||
d=z(f,d,a,b,c,X[13],12,t[14])
|
|
||||||
c=z(f,c,d,a,b,X[14],17,t[15])
|
|
||||||
b=z(f,b,c,d,a,X[15],22,t[16])
|
|
||||||
|
|
||||||
a=z(g,a,b,c,d,X[ 1], 5,t[17])
|
|
||||||
d=z(g,d,a,b,c,X[ 6], 9,t[18])
|
|
||||||
c=z(g,c,d,a,b,X[11],14,t[19])
|
|
||||||
b=z(g,b,c,d,a,X[ 0],20,t[20])
|
|
||||||
a=z(g,a,b,c,d,X[ 5], 5,t[21])
|
|
||||||
d=z(g,d,a,b,c,X[10], 9,t[22])
|
|
||||||
c=z(g,c,d,a,b,X[15],14,t[23])
|
|
||||||
b=z(g,b,c,d,a,X[ 4],20,t[24])
|
|
||||||
a=z(g,a,b,c,d,X[ 9], 5,t[25])
|
|
||||||
d=z(g,d,a,b,c,X[14], 9,t[26])
|
|
||||||
c=z(g,c,d,a,b,X[ 3],14,t[27])
|
|
||||||
b=z(g,b,c,d,a,X[ 8],20,t[28])
|
|
||||||
a=z(g,a,b,c,d,X[13], 5,t[29])
|
|
||||||
d=z(g,d,a,b,c,X[ 2], 9,t[30])
|
|
||||||
c=z(g,c,d,a,b,X[ 7],14,t[31])
|
|
||||||
b=z(g,b,c,d,a,X[12],20,t[32])
|
|
||||||
|
|
||||||
a=z(h,a,b,c,d,X[ 5], 4,t[33])
|
|
||||||
d=z(h,d,a,b,c,X[ 8],11,t[34])
|
|
||||||
c=z(h,c,d,a,b,X[11],16,t[35])
|
|
||||||
b=z(h,b,c,d,a,X[14],23,t[36])
|
|
||||||
a=z(h,a,b,c,d,X[ 1], 4,t[37])
|
|
||||||
d=z(h,d,a,b,c,X[ 4],11,t[38])
|
|
||||||
c=z(h,c,d,a,b,X[ 7],16,t[39])
|
|
||||||
b=z(h,b,c,d,a,X[10],23,t[40])
|
|
||||||
a=z(h,a,b,c,d,X[13], 4,t[41])
|
|
||||||
d=z(h,d,a,b,c,X[ 0],11,t[42])
|
|
||||||
c=z(h,c,d,a,b,X[ 3],16,t[43])
|
|
||||||
b=z(h,b,c,d,a,X[ 6],23,t[44])
|
|
||||||
a=z(h,a,b,c,d,X[ 9], 4,t[45])
|
|
||||||
d=z(h,d,a,b,c,X[12],11,t[46])
|
|
||||||
c=z(h,c,d,a,b,X[15],16,t[47])
|
|
||||||
b=z(h,b,c,d,a,X[ 2],23,t[48])
|
|
||||||
|
|
||||||
a=z(i,a,b,c,d,X[ 0], 6,t[49])
|
|
||||||
d=z(i,d,a,b,c,X[ 7],10,t[50])
|
|
||||||
c=z(i,c,d,a,b,X[14],15,t[51])
|
|
||||||
b=z(i,b,c,d,a,X[ 5],21,t[52])
|
|
||||||
a=z(i,a,b,c,d,X[12], 6,t[53])
|
|
||||||
d=z(i,d,a,b,c,X[ 3],10,t[54])
|
|
||||||
c=z(i,c,d,a,b,X[10],15,t[55])
|
|
||||||
b=z(i,b,c,d,a,X[ 1],21,t[56])
|
|
||||||
a=z(i,a,b,c,d,X[ 8], 6,t[57])
|
|
||||||
d=z(i,d,a,b,c,X[15],10,t[58])
|
|
||||||
c=z(i,c,d,a,b,X[ 6],15,t[59])
|
|
||||||
b=z(i,b,c,d,a,X[13],21,t[60])
|
|
||||||
a=z(i,a,b,c,d,X[ 4], 6,t[61])
|
|
||||||
d=z(i,d,a,b,c,X[11],10,t[62])
|
|
||||||
c=z(i,c,d,a,b,X[ 2],15,t[63])
|
|
||||||
b=z(i,b,c,d,a,X[ 9],21,t[64])
|
|
||||||
|
|
||||||
return bit_and(A+a,0xFFFFFFFF),bit_and(B+b,0xFFFFFFFF),
|
|
||||||
bit_and(C+c,0xFFFFFFFF),bit_and(D+d,0xFFFFFFFF)
|
|
||||||
end
|
|
||||||
|
|
||||||
----------------------------------------------------------------
|
|
||||||
|
|
||||||
local function md5_update(self, s)
|
|
||||||
self.pos = self.pos + #s
|
|
||||||
s = self.buf .. s
|
|
||||||
for ii = 1, #s - 63, 64 do
|
|
||||||
local X = cut_le_str(sub(s,ii,ii+63),4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4)
|
|
||||||
assert(#X == 16)
|
|
||||||
X[0] = table.remove(X,1) -- zero based!
|
|
||||||
self.a,self.b,self.c,self.d = transform(self.a,self.b,self.c,self.d,X)
|
|
||||||
end
|
|
||||||
self.buf = sub(s, math.floor(#s/64)*64 + 1, #s)
|
|
||||||
return self
|
|
||||||
end
|
|
||||||
|
|
||||||
local function md5_finish(self)
|
|
||||||
local msgLen = self.pos
|
|
||||||
local padLen = 56 - msgLen % 64
|
|
||||||
|
|
||||||
if msgLen % 64 > 56 then padLen = padLen + 64 end
|
|
||||||
|
|
||||||
if padLen == 0 then padLen = 64 end
|
|
||||||
|
|
||||||
local s = char(128) .. rep(char(0),padLen-1) .. lei2str(bit_and(8*msgLen, 0xFFFFFFFF)) .. lei2str(math.floor(msgLen/0x20000000))
|
|
||||||
md5_update(self, s)
|
|
||||||
|
|
||||||
assert(self.pos % 64 == 0)
|
|
||||||
return lei2str(self.a) .. lei2str(self.b) .. lei2str(self.c) .. lei2str(self.d)
|
|
||||||
end
|
|
||||||
|
|
||||||
----------------------------------------------------------------
|
|
||||||
|
|
||||||
function md5.new()
|
|
||||||
return { a = CONSTS[65], b = CONSTS[66], c = CONSTS[67], d = CONSTS[68],
|
|
||||||
pos = 0,
|
|
||||||
buf = '',
|
|
||||||
update = md5_update,
|
|
||||||
finish = md5_finish }
|
|
||||||
end
|
|
||||||
|
|
||||||
function md5.tohex(s)
|
|
||||||
return format("%08x%08x%08x%08x", str2bei(sub(s, 1, 4)), str2bei(sub(s, 5, 8)), str2bei(sub(s, 9, 12)), str2bei(sub(s, 13, 16)))
|
|
||||||
end
|
|
||||||
|
|
||||||
function md5.sum(s)
|
|
||||||
return md5.new():update(s):finish()
|
|
||||||
end
|
|
||||||
|
|
||||||
function md5.sumhexa(s)
|
|
||||||
return md5.tohex(md5.sum(s))
|
|
||||||
end
|
|
||||||
bin.md5 = md5
|
|
||||||
function bin:getMD5Hash()
|
|
||||||
self:setSeek(1)
|
|
||||||
local len=self:getSize()
|
|
||||||
local md5=bin.md5.new()
|
|
||||||
local SIZE=2048
|
|
||||||
if len>SIZE then
|
|
||||||
local dat=self:read(SIZE)
|
|
||||||
while dat~=nil do
|
|
||||||
md5:update(dat)
|
|
||||||
dat=self:read(SIZE)
|
|
||||||
end
|
|
||||||
return bin.md5.tohex(md5:finish()):upper()
|
|
||||||
else
|
|
||||||
return bin.md5.sumhexa(self:getData()):upper()
|
|
||||||
end
|
|
||||||
end
|
|
||||||
return md5
|
|
||||||
@ -1,333 +0,0 @@
|
|||||||
--[[
|
|
||||||
LICENSE
|
|
||||||
|
|
||||||
(c) 2008-2011 David Manura. Licensed under the same terms as Lua (MIT).
|
|
||||||
--]]
|
|
||||||
|
|
||||||
local M = {_TYPE='module', _NAME='bit.numberlua', _VERSION='0.3.1.20120131'}
|
|
||||||
|
|
||||||
local floor = math.floor
|
|
||||||
|
|
||||||
local MOD = 2^32
|
|
||||||
local MODM = MOD-1
|
|
||||||
|
|
||||||
local function memoize(f)
|
|
||||||
local mt = {}
|
|
||||||
local t = setmetatable({}, mt)
|
|
||||||
function mt:__index(k)
|
|
||||||
local v = f(k); t[k] = v
|
|
||||||
return v
|
|
||||||
end
|
|
||||||
return t
|
|
||||||
end
|
|
||||||
|
|
||||||
local function make_bitop_uncached(t, m)
|
|
||||||
local function bitop(a, b)
|
|
||||||
local res,p = 0,1
|
|
||||||
while a ~= 0 and b ~= 0 do
|
|
||||||
local am, bm = a%m, b%m
|
|
||||||
res = res + t[am][bm]*p
|
|
||||||
a = (a - am) / m
|
|
||||||
b = (b - bm) / m
|
|
||||||
p = p*m
|
|
||||||
end
|
|
||||||
res = res + (a+b)*p
|
|
||||||
return res
|
|
||||||
end
|
|
||||||
return bitop
|
|
||||||
end
|
|
||||||
|
|
||||||
local function make_bitop(t)
|
|
||||||
local op1 = make_bitop_uncached(t,2^1)
|
|
||||||
local op2 = memoize(function(a)
|
|
||||||
return memoize(function(b)
|
|
||||||
return op1(a, b)
|
|
||||||
end)
|
|
||||||
end)
|
|
||||||
return make_bitop_uncached(op2, 2^(t.n or 1))
|
|
||||||
end
|
|
||||||
|
|
||||||
-- ok? probably not if running on a 32-bit int Lua number type platform
|
|
||||||
function M.tobit(x)
|
|
||||||
return x % 2^32
|
|
||||||
end
|
|
||||||
|
|
||||||
M.bxor = make_bitop {[0]={[0]=0,[1]=1},[1]={[0]=1,[1]=0}, n=4}
|
|
||||||
local bxor = M.bxor
|
|
||||||
|
|
||||||
function M.bnot(a) return MODM - a end
|
|
||||||
local bnot = M.bnot
|
|
||||||
|
|
||||||
function M.band(a,b) return ((a+b) - bxor(a,b))/2 end
|
|
||||||
local band = M.band
|
|
||||||
|
|
||||||
function M.bor(a,b) return MODM - band(MODM - a, MODM - b) end
|
|
||||||
local bor = M.bor
|
|
||||||
|
|
||||||
local lshift, rshift -- forward declare
|
|
||||||
|
|
||||||
function M.rshift(a,disp) -- Lua5.2 insipred
|
|
||||||
if disp < 0 then return lshift(a,-disp) end
|
|
||||||
return floor(a % 2^32 / 2^disp)
|
|
||||||
end
|
|
||||||
rshift = M.rshift
|
|
||||||
|
|
||||||
function M.lshift(a,disp) -- Lua5.2 inspired
|
|
||||||
if disp < 0 then return rshift(a,-disp) end
|
|
||||||
return (a * 2^disp) % 2^32
|
|
||||||
end
|
|
||||||
lshift = M.lshift
|
|
||||||
|
|
||||||
function M.tohex(x, n) -- BitOp style
|
|
||||||
n = n or 8
|
|
||||||
local up
|
|
||||||
if n <= 0 then
|
|
||||||
if n == 0 then return '' end
|
|
||||||
up = true
|
|
||||||
n = - n
|
|
||||||
end
|
|
||||||
x = band(x, 16^n-1)
|
|
||||||
return ('%0'..n..(up and 'X' or 'x')):format(x)
|
|
||||||
end
|
|
||||||
local tohex = M.tohex
|
|
||||||
|
|
||||||
function M.extract(n, field, width) -- Lua5.2 inspired
|
|
||||||
width = width or 1
|
|
||||||
return band(rshift(n, field), 2^width-1)
|
|
||||||
end
|
|
||||||
local extract = M.extract
|
|
||||||
|
|
||||||
function M.replace(n, v, field, width) -- Lua5.2 inspired
|
|
||||||
width = width or 1
|
|
||||||
local mask1 = 2^width-1
|
|
||||||
v = band(v, mask1) -- required by spec?
|
|
||||||
local mask = bnot(lshift(mask1, field))
|
|
||||||
return band(n, mask) + lshift(v, field)
|
|
||||||
end
|
|
||||||
local replace = M.replace
|
|
||||||
|
|
||||||
function M.bswap(x) -- BitOp style
|
|
||||||
local a = band(x, 0xff); x = rshift(x, 8)
|
|
||||||
local b = band(x, 0xff); x = rshift(x, 8)
|
|
||||||
local c = band(x, 0xff); x = rshift(x, 8)
|
|
||||||
local d = band(x, 0xff)
|
|
||||||
return lshift(lshift(lshift(a, 8) + b, 8) + c, 8) + d
|
|
||||||
end
|
|
||||||
local bswap = M.bswap
|
|
||||||
|
|
||||||
function M.rrotate(x, disp) -- Lua5.2 inspired
|
|
||||||
disp = disp % 32
|
|
||||||
local low = band(x, 2^disp-1)
|
|
||||||
return rshift(x, disp) + lshift(low, 32-disp)
|
|
||||||
end
|
|
||||||
local rrotate = M.rrotate
|
|
||||||
|
|
||||||
function M.lrotate(x, disp) -- Lua5.2 inspired
|
|
||||||
return rrotate(x, -disp)
|
|
||||||
end
|
|
||||||
local lrotate = M.lrotate
|
|
||||||
|
|
||||||
M.rol = M.lrotate -- LuaOp inspired
|
|
||||||
M.ror = M.rrotate -- LuaOp insipred
|
|
||||||
|
|
||||||
|
|
||||||
function M.arshift(x, disp) -- Lua5.2 inspired
|
|
||||||
local z = rshift(x, disp)
|
|
||||||
if x >= 0x80000000 then z = z + lshift(2^disp-1, 32-disp) end
|
|
||||||
return z
|
|
||||||
end
|
|
||||||
local arshift = M.arshift
|
|
||||||
|
|
||||||
function M.btest(x, y) -- Lua5.2 inspired
|
|
||||||
return band(x, y) ~= 0
|
|
||||||
end
|
|
||||||
|
|
||||||
M.bit32 = {} -- Lua 5.2 'bit32' compatibility
|
|
||||||
|
|
||||||
|
|
||||||
local function bit32_bnot(x)
|
|
||||||
return (-1 - x) % MOD
|
|
||||||
end
|
|
||||||
M.bit32.bnot = bit32_bnot
|
|
||||||
|
|
||||||
local function bit32_bxor(a, b, c, ...)
|
|
||||||
local z
|
|
||||||
if b then
|
|
||||||
a = a % MOD
|
|
||||||
b = b % MOD
|
|
||||||
z = bxor(a, b)
|
|
||||||
if c then
|
|
||||||
z = bit32_bxor(z, c, ...)
|
|
||||||
end
|
|
||||||
return z
|
|
||||||
elseif a then
|
|
||||||
return a % MOD
|
|
||||||
else
|
|
||||||
return 0
|
|
||||||
end
|
|
||||||
end
|
|
||||||
M.bit32.bxor = bit32_bxor
|
|
||||||
|
|
||||||
local function bit32_band(a, b, c, ...)
|
|
||||||
local z
|
|
||||||
if b then
|
|
||||||
a = a % MOD
|
|
||||||
b = b % MOD
|
|
||||||
z = ((a+b) - bxor(a,b)) / 2
|
|
||||||
if c then
|
|
||||||
z = bit32_band(z, c, ...)
|
|
||||||
end
|
|
||||||
return z
|
|
||||||
elseif a then
|
|
||||||
return a % MOD
|
|
||||||
else
|
|
||||||
return MODM
|
|
||||||
end
|
|
||||||
end
|
|
||||||
M.bit32.band = bit32_band
|
|
||||||
|
|
||||||
local function bit32_bor(a, b, c, ...)
|
|
||||||
local z
|
|
||||||
if b then
|
|
||||||
a = a % MOD
|
|
||||||
b = b % MOD
|
|
||||||
z = MODM - band(MODM - a, MODM - b)
|
|
||||||
if c then
|
|
||||||
z = bit32_bor(z, c, ...)
|
|
||||||
end
|
|
||||||
return z
|
|
||||||
elseif a then
|
|
||||||
return a % MOD
|
|
||||||
else
|
|
||||||
return 0
|
|
||||||
end
|
|
||||||
end
|
|
||||||
M.bit32.bor = bit32_bor
|
|
||||||
|
|
||||||
function M.bit32.btest(...)
|
|
||||||
return bit32_band(...) ~= 0
|
|
||||||
end
|
|
||||||
|
|
||||||
function M.bit32.lrotate(x, disp)
|
|
||||||
return lrotate(x % MOD, disp)
|
|
||||||
end
|
|
||||||
|
|
||||||
function M.bit32.rrotate(x, disp)
|
|
||||||
return rrotate(x % MOD, disp)
|
|
||||||
end
|
|
||||||
|
|
||||||
function M.bit32.lshift(x,disp)
|
|
||||||
if disp > 31 or disp < -31 then return 0 end
|
|
||||||
return lshift(x % MOD, disp)
|
|
||||||
end
|
|
||||||
|
|
||||||
function M.bit32.rshift(x,disp)
|
|
||||||
if disp > 31 or disp < -31 then return 0 end
|
|
||||||
return rshift(x % MOD, disp)
|
|
||||||
end
|
|
||||||
|
|
||||||
function M.bit32.arshift(x,disp)
|
|
||||||
x = x % MOD
|
|
||||||
if disp >= 0 then
|
|
||||||
if disp > 31 then
|
|
||||||
return (x >= 0x80000000) and MODM or 0
|
|
||||||
else
|
|
||||||
local z = rshift(x, disp)
|
|
||||||
if x >= 0x80000000 then z = z + lshift(2^disp-1, 32-disp) end
|
|
||||||
return z
|
|
||||||
end
|
|
||||||
else
|
|
||||||
return lshift(x, -disp)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
function M.bit32.extract(x, field, ...)
|
|
||||||
local width = ... or 1
|
|
||||||
if field < 0 or field > 31 or width < 0 or field+width > 32 then error 'out of range' end
|
|
||||||
x = x % MOD
|
|
||||||
return extract(x, field, ...)
|
|
||||||
end
|
|
||||||
|
|
||||||
function M.bit32.replace(x, v, field, ...)
|
|
||||||
local width = ... or 1
|
|
||||||
if field < 0 or field > 31 or width < 0 or field+width > 32 then error 'out of range' end
|
|
||||||
x = x % MOD
|
|
||||||
v = v % MOD
|
|
||||||
return replace(x, v, field, ...)
|
|
||||||
end
|
|
||||||
|
|
||||||
M.bit = {} -- LuaBitOp "bit" compatibility
|
|
||||||
|
|
||||||
function M.bit.tobit(x)
|
|
||||||
x = x % MOD
|
|
||||||
if x >= 0x80000000 then x = x - MOD end
|
|
||||||
return x
|
|
||||||
end
|
|
||||||
local bit_tobit = M.bit.tobit
|
|
||||||
|
|
||||||
function M.bit.tohex(x, ...)
|
|
||||||
return tohex(x % MOD, ...)
|
|
||||||
end
|
|
||||||
|
|
||||||
function M.bit.bnot(x)
|
|
||||||
return bit_tobit(bnot(x % MOD))
|
|
||||||
end
|
|
||||||
|
|
||||||
local function bit_bor(a, b, c, ...)
|
|
||||||
if c then
|
|
||||||
return bit_bor(bit_bor(a, b), c, ...)
|
|
||||||
elseif b then
|
|
||||||
return bit_tobit(bor(a % MOD, b % MOD))
|
|
||||||
else
|
|
||||||
return bit_tobit(a)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
M.bit.bor = bit_bor
|
|
||||||
|
|
||||||
local function bit_band(a, b, c, ...)
|
|
||||||
if c then
|
|
||||||
return bit_band(bit_band(a, b), c, ...)
|
|
||||||
elseif b then
|
|
||||||
return bit_tobit(band(a % MOD, b % MOD))
|
|
||||||
else
|
|
||||||
return bit_tobit(a)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
M.bit.band = bit_band
|
|
||||||
|
|
||||||
local function bit_bxor(a, b, c, ...)
|
|
||||||
if c then
|
|
||||||
return bit_bxor(bit_bxor(a, b), c, ...)
|
|
||||||
elseif b then
|
|
||||||
return bit_tobit(bxor(a % MOD, b % MOD))
|
|
||||||
else
|
|
||||||
return bit_tobit(a)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
M.bit.bxor = bit_bxor
|
|
||||||
|
|
||||||
function M.bit.lshift(x, n)
|
|
||||||
return bit_tobit(lshift(x % MOD, n % 32))
|
|
||||||
end
|
|
||||||
|
|
||||||
function M.bit.rshift(x, n)
|
|
||||||
return bit_tobit(rshift(x % MOD, n % 32))
|
|
||||||
end
|
|
||||||
|
|
||||||
function M.bit.arshift(x, n)
|
|
||||||
return bit_tobit(arshift(x % MOD, n % 32))
|
|
||||||
end
|
|
||||||
|
|
||||||
function M.bit.rol(x, n)
|
|
||||||
return bit_tobit(lrotate(x % MOD, n % 32))
|
|
||||||
end
|
|
||||||
|
|
||||||
function M.bit.ror(x, n)
|
|
||||||
return bit_tobit(rrotate(x % MOD, n % 32))
|
|
||||||
end
|
|
||||||
|
|
||||||
function M.bit.bswap(x)
|
|
||||||
return bit_tobit(bswap(x % MOD))
|
|
||||||
end
|
|
||||||
|
|
||||||
return M
|
|
||||||
@ -1 +0,0 @@
|
|||||||
local bin = require("bin")
|
|
||||||
@ -1,6 +0,0 @@
|
|||||||
package.path="?/init.lua;"..package.path
|
|
||||||
require("bin")
|
|
||||||
local bits = bin.bits
|
|
||||||
for i=0,255 do
|
|
||||||
print(bits.new(i))
|
|
||||||
end
|
|
||||||
@ -140,15 +140,7 @@ function table.max(t)
|
|||||||
return value
|
return value
|
||||||
end
|
end
|
||||||
|
|
||||||
local bit
|
local bit=require("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={}
|
local bits={}
|
||||||
bin.bits = bits
|
bin.bits = bits
|
||||||
bits.data=''
|
bits.data=''
|
||||||
@ -300,11 +292,7 @@ function bits:conv(n)
|
|||||||
return str
|
return str
|
||||||
end
|
end
|
||||||
function bits:tonumber(s,e)
|
function bits:tonumber(s,e)
|
||||||
if s==0 then
|
return tonumber(self.data,2)
|
||||||
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
|
end
|
||||||
function bits:isover()
|
function bits:isover()
|
||||||
return #self.data>8
|
return #self.data>8
|
||||||
@ -350,15 +338,14 @@ infinabits.__index = infinabits
|
|||||||
infinabits.__tostring=function(self) return self.data end
|
infinabits.__tostring=function(self) return self.data end
|
||||||
infinabits.__len=function(self) return (#self.data)/8 end
|
infinabits.__len=function(self) return (#self.data)/8 end
|
||||||
local floor,insert = math.floor, table.insert
|
local floor,insert = math.floor, table.insert
|
||||||
function basen(n,b)
|
function basen_b(n,b)
|
||||||
n=BigNum.new(n)
|
n = BigNum.new(n)
|
||||||
if not b or b == 10 then return tostring(n) end
|
|
||||||
local digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
|
local digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
|
||||||
local t = {}
|
local t = {}
|
||||||
local sign = ""
|
local sign = ""
|
||||||
if n < BigNum.new(0) then
|
if n < BigNum.new(0) then
|
||||||
sign = "-"
|
sign = "-"
|
||||||
n = -n
|
n = -n
|
||||||
end
|
end
|
||||||
repeat
|
repeat
|
||||||
local d = tonumber(tostring(n % b)) + 1
|
local d = tonumber(tostring(n % b)) + 1
|
||||||
@ -452,7 +439,7 @@ function infinabits.new(n,binary)
|
|||||||
temp.data=table.concat(t)
|
temp.data=table.concat(t)
|
||||||
end
|
end
|
||||||
elseif type(n)=="number" or type(n)=="table" then
|
elseif type(n)=="number" or type(n)=="table" then
|
||||||
temp.data=basen(tostring(n),2)
|
temp.data=basen_b(tostring(n),2)
|
||||||
end
|
end
|
||||||
if #temp.data%8~=0 then
|
if #temp.data%8~=0 then
|
||||||
temp.data=string.rep('0',8-#temp.data%8)..temp.data
|
temp.data=string.rep('0',8-#temp.data%8)..temp.data
|
||||||
@ -547,11 +534,7 @@ function infinabits:conv(n)
|
|||||||
return str
|
return str
|
||||||
end
|
end
|
||||||
function infinabits:tonumber(s)
|
function infinabits:tonumber(s)
|
||||||
if s==0 then
|
return base2to10(self.data)
|
||||||
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
|
end
|
||||||
function infinabits:isover()
|
function infinabits:isover()
|
||||||
return #self.data>8
|
return #self.data>8
|
||||||
31
rockspecs/bin-6.0-0.rockspec
Normal file
31
rockspecs/bin-6.0-0.rockspec
Normal file
@ -0,0 +1,31 @@
|
|||||||
|
package = "bin"
|
||||||
|
version = "6.0-0"
|
||||||
|
source = {
|
||||||
|
url = "git://github.com/rayaman/bin.git",
|
||||||
|
tag = "v6.0.0",
|
||||||
|
}
|
||||||
|
description = {
|
||||||
|
summary = "Lua Binary ManIpulatioN library",
|
||||||
|
detailed = [[
|
||||||
|
This library contains many methods for working with files at the binary level. It can handle sterilization of all lua objects except userdata. It can even handle self recursion in talbes. It provides a bit, bits, infinabits, base64/91, lzw, md5 hashing, bignum, random, and a virtual file system(Soon, check out oldbin.lua for that) module.
|
||||||
|
The bit library is the same that comes with luajit. the bits/infinabits library deals with 1's and 0's used for numbers. bits is faster than infinabits, but is limited to 32/64 bits based on which version of lua you are working on. Base64/91 is provided, but since it is done in pure lua it is slower. Check out the github for more info.
|
||||||
|
]],
|
||||||
|
homepage = "https://github.com/rayaman/bin",
|
||||||
|
license = "MIT"
|
||||||
|
}
|
||||||
|
dependencies = {
|
||||||
|
"lua >= 5.1",
|
||||||
|
"luabitop"
|
||||||
|
}
|
||||||
|
build = {
|
||||||
|
type = "builtin",
|
||||||
|
modules = {
|
||||||
|
-- Note the required Lua syntax when listing submodules as keys
|
||||||
|
["bin.init"] = "bin/init.lua",
|
||||||
|
["bin.compressors.lzw"] = "bin/compressors/lzw.lua",
|
||||||
|
["bin.hashes.md5"] = "bin/hashes/md5.lua",
|
||||||
|
["bin.numbers.no_jit_bit"] = "bin/numbers/no_jit_bit.lua",
|
||||||
|
["bin.numbers.random"] = "bin/numbers/random.lua",
|
||||||
|
["bin.support.vfs"] = "bin/support/vfs.lua",
|
||||||
|
}
|
||||||
|
}
|
||||||
Loading…
x
Reference in New Issue
Block a user