diff --git a/Compile.exe b/Compile.exe new file mode 100644 index 0000000..cfcedc2 Binary files /dev/null and b/Compile.exe differ diff --git a/Love2apk.exe b/Love2apk.exe new file mode 100644 index 0000000..9c43069 Binary files /dev/null and b/Love2apk.exe differ diff --git a/apk-signer-1.8.5.jar b/apk-signer-1.8.5.jar new file mode 100644 index 0000000..307a603 Binary files /dev/null and b/apk-signer-1.8.5.jar differ diff --git a/apktool.bat b/apktool.bat new file mode 100644 index 0000000..b0038bc --- /dev/null +++ b/apktool.bat @@ -0,0 +1,5 @@ +@echo off +if "%PATH_BASE%" == "" set PATH_BASE=%PATH% +set PATH=%CD%;%PATH_BASE%; +chcp 65001 2>nul >nul +java -jar -Duser.language=en -Dfile.encoding=UTF8 "%~dp0\apktool.jar" %* \ No newline at end of file diff --git a/apktool.jar b/apktool.jar new file mode 100644 index 0000000..000e599 Binary files /dev/null and b/apktool.jar differ diff --git a/bin/compressors/lzw.lua b/bin/compressors/lzw.lua new file mode 100644 index 0000000..57653b3 --- /dev/null +++ b/bin/compressors/lzw.lua @@ -0,0 +1,73 @@ +--[[ +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 diff --git a/bin/converters/base64.lua b/bin/converters/base64.lua new file mode 100644 index 0000000..d66cc90 --- /dev/null +++ b/bin/converters/base64.lua @@ -0,0 +1,40 @@ +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 diff --git a/bin/converters/base91.lua b/bin/converters/base91.lua new file mode 100644 index 0000000..cb2f447 --- /dev/null +++ b/bin/converters/base91.lua @@ -0,0 +1,82 @@ +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 diff --git a/bin/hashes/md5.lua b/bin/hashes/md5.lua new file mode 100644 index 0000000..c2cc716 --- /dev/null +++ b/bin/hashes/md5.lua @@ -0,0 +1,394 @@ +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 diff --git a/bin/init.lua b/bin/init.lua new file mode 100644 index 0000000..b6ebf52 --- /dev/null +++ b/bin/init.lua @@ -0,0 +1,1431 @@ +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 #str1 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)size then + data = data:sub(1,size) + elseif dsize255 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) 0 then + for i = bnum.len - 2 , 0 , -1 do + for j = 0 , RADIX_LEN - string.len( bnum[i] ) - 1 do + temp = temp .. '0' ; + end + temp = temp .. bnum[i] ; + end + if bnum[bnum.len - 1]==nil then + return "nil" + end + temp = bnum[bnum.len - 1] .. temp ; + if bnum.signal == '-' then + temp = bnum.signal .. temp ; + end + return temp ; + else + return "" ; + end +end + +function BigNum.mt.pow( num1 , num2 ) + local bnum1 = BigNum.new( num1 ) ; + local bnum2 = BigNum.new( num2 ) ; + return BigNum.pow( bnum1 , bnum2 ) ; +end + +function BigNum.mt.eq( num1 , num2 ) + local bnum1 = BigNum.new( num1 ) ; + local bnum2 = BigNum.new( num2 ) ; + return BigNum.eq( bnum1 , bnum2 ) ; +end + +function BigNum.mt.lt( num1 , num2 ) + local bnum1 = BigNum.new( num1 ) ; + local bnum2 = BigNum.new( num2 ) ; + return BigNum.lt( bnum1 , bnum2 ) ; +end + +function BigNum.mt.le( num1 , num2 ) + local bnum1 = BigNum.new( num1 ) ; + local bnum2 = BigNum.new( num2 ) ; + return BigNum.le( bnum1 , bnum2 ) ; +end + +function BigNum.mt.unm( num ) + local ret = BigNum.new( num ) + if ret.signal == '+' then + ret.signal = '-' + else + ret.signal = '+' + end + return ret +end + +BigNum.mt.__metatable = "hidden" +BigNum.mt.__tostring = BigNum.mt.tostring ; +BigNum.mt.__add = BigNum.mt.add ; +BigNum.mt.__sub = BigNum.mt.sub ; +BigNum.mt.__mul = BigNum.mt.mul ; +BigNum.mt.__div = BigNum.mt.div ; +BigNum.mt.__pow = BigNum.mt.pow ; +BigNum.mt.__unm = BigNum.mt.unm ; +BigNum.mt.__mod = BigNum.mt.mod ; +BigNum.mt.__eq = BigNum.mt.eq ; +BigNum.mt.__le = BigNum.mt.le ; +BigNum.mt.__lt = BigNum.mt.lt ; +setmetatable( BigNum.mt, { __index = "inexistent field", __newindex = "not available", __metatable="hidden" } ) ; +function BigNum.add( bnum1 , bnum2 , bnum3 ) + local maxlen = 0 ; + local i = 0 ; + local carry = 0 ; + local signal = '+' ; + local old_len = 0 ; + --Handle the signals + if bnum1 == nil or bnum2 == nil or bnum3 == nil then + error("Function BigNum.add: parameter nil") ; + elseif bnum1.signal == '-' and bnum2.signal == '+' then + bnum1.signal = '+' ; + BigNum.sub( bnum2 , bnum1 , bnum3 ) ; + + if not rawequal(bnum1, bnum3) then + bnum1.signal = '-' ; + end + return 0 ; + elseif bnum1.signal == '+' and bnum2.signal == '-' then + bnum2.signal = '+' ; + BigNum.sub( bnum1 , bnum2 , bnum3 ) ; + if not rawequal(bnum2, bnum3) then + bnum2.signal = '-' ; + end + return 0 ; + elseif bnum1.signal == '-' and bnum2.signal == '-' then + signal = '-' ; + end + -- + old_len = bnum3.len ; + if bnum1.len > bnum2.len then + maxlen = bnum1.len ; + else + maxlen = bnum2.len ; + bnum1 , bnum2 = bnum2 , bnum1 ; + end + --School grade sum + for i = 0 , maxlen - 1 do + if bnum2[i] ~= nil then + bnum3[i] = bnum1[i] + bnum2[i] + carry ; + else + bnum3[i] = bnum1[i] + carry ; + end + if bnum3[i] >= RADIX then + bnum3[i] = bnum3[i] - RADIX ; + carry = 1 ; + else + carry = 0 ; + end + end + --Update the answer's size + if carry == 1 then + bnum3[maxlen] = 1 ; + end + bnum3.len = maxlen + carry ; + bnum3.signal = signal ; + for i = bnum3.len, old_len do + bnum3[i] = nil ; + end + return 0 ; +end + +function BigNum.sub( bnum1 , bnum2 , bnum3 ) + local maxlen = 0 ; + local i = 0 ; + local carry = 0 ; + local old_len = 0 ; + if bnum1 == nil or bnum2 == nil or bnum3 == nil then + error("Function BigNum.sub: parameter nil") ; + elseif bnum1.signal == '-' and bnum2.signal == '+' then + bnum1.signal = '+' ; + BigNum.add( bnum1 , bnum2 , bnum3 ) ; + bnum3.signal = '-' ; + if not rawequal(bnum1, bnum3) then + bnum1.signal = '-' ; + end + return 0 ; + elseif bnum1.signal == '-' and bnum2.signal == '-' then + bnum1.signal = '+' ; + bnum2.signal = '+' ; + BigNum.sub( bnum2, bnum1 , bnum3 ) ; + if not rawequal(bnum1, bnum3) then + bnum1.signal = '-' ; + end + if not rawequal(bnum2, bnum3) then + bnum2.signal = '-' ; + end + return 0 ; + elseif bnum1.signal == '+' and bnum2.signal == '-' then + bnum2.signal = '+' ; + BigNum.add( bnum1 , bnum2 , bnum3 ) ; + if not rawequal(bnum2, bnum3) then + bnum2.signal = '-' ; + end + return 0 ; + end + --Tests if bnum2 > bnum1 + if BigNum.compareAbs( bnum1 , bnum2 ) == 2 then + BigNum.sub( bnum2 , bnum1 , bnum3 ) ; + bnum3.signal = '-' ; + return 0 ; + else + maxlen = bnum1.len ; + end + old_len = bnum3.len ; + bnum3.len = 0 ; + --School grade subtraction + for i = 0 , maxlen - 1 do + if bnum2[i] ~= nil then + bnum3[i] = bnum1[i] - bnum2[i] - carry ; + else + bnum3[i] = bnum1[i] - carry ; + end + if bnum3[i] < 0 then + bnum3[i] = RADIX + bnum3[i] ; + carry = 1 ; + else + carry = 0 ; + end + + if bnum3[i] ~= 0 then + bnum3.len = i + 1 ; + end + end + bnum3.signal = '+' ; + --Check if answer's size if zero + if bnum3.len == 0 then + bnum3.len = 1 ; + bnum3[0] = 0 ; + end + if carry == 1 then + error( "Error in function sub" ) ; + end + for i = bnum3.len , max( old_len , maxlen - 1 ) do + bnum3[i] = nil ; + end + return 0 ; +end + +function BigNum.mul( bnum1 , bnum2 , bnum3 ) + local i = 0 ; j = 0 ; + local temp = BigNum.new( ) ; + local temp2 = 0 ; + local carry = 0 ; + local oldLen = bnum3.len ; + if bnum1 == nil or bnum2 == nil or bnum3 == nil then + error("Function BigNum.mul: parameter nil") ; + --Handle the signals + elseif bnum1.signal ~= bnum2.signal then + BigNum.mul( bnum1 , -bnum2 , bnum3 ) ; + bnum3.signal = '-' ; + return 0 ; + end + bnum3.len = ( bnum1.len ) + ( bnum2.len ) ; + --Fill with zeros + for i = 1 , bnum3.len do + bnum3[i - 1] = 0 ; + end + --Places nil where passes through this + for i = bnum3.len , oldLen do + bnum3[i] = nil ; + end + --School grade multiplication + for i = 0 , bnum1.len - 1 do + for j = 0 , bnum2.len - 1 do + carry = ( bnum1[i] * bnum2[j] + carry ) ; + carry = carry + bnum3[i + j] ; + bnum3[i + j] = ( carry % RADIX ) ; + temp2 = bnum3[i + j] ; + carry = math.floor ( carry / RADIX ) ; + end + if carry ~= 0 then + bnum3[i + bnum2.len] = carry ; + end + carry = 0 ; + end + + --Update the answer's size + for i = bnum3.len - 1 , 1 , -1 do + if bnum3[i] ~= nil and bnum3[i] ~= 0 then + break ; + else + bnum3[i] = nil ; + end + bnum3.len = bnum3.len - 1 ; + end + return 0 ; +end + +function BigNum.div( bnum1 , bnum2 , bnum3 , bnum4 ) + local temp = BigNum.new() ; + local temp2 = BigNum.new() ; + local one = BigNum.new( "1" ) ; + local zero = BigNum.new( "0" ) ; + --Check division by zero + if BigNum.compareAbs( bnum2 , zero ) == 0 then + error( "Function BigNum.div: Division by zero" ) ; + end + --Handle the signals + if bnum1 == nil or bnum2 == nil or bnum3 == nil or bnum4 == nil then + error( "Function BigNum.div: parameter nil" ) ; + elseif bnum1.signal == "+" and bnum2.signal == "-" then + bnum2.signal = "+" ; + BigNum.div( bnum1 , bnum2 , bnum3 , bnum4 ) ; + bnum2.signal = "-" ; + bnum3.signal = "-" ; + return 0 ; + elseif bnum1.signal == "-" and bnum2.signal == "+" then + bnum1.signal = "+" ; + BigNum.div( bnum1 , bnum2 , bnum3 , bnum4 ) ; + bnum1.signal = "-" ; + if bnum4 < zero then --Check if remainder is negative + BigNum.add( bnum3 , one , bnum3 ) ; + BigNum.sub( bnum2 , bnum4 , bnum4 ) ; + end + bnum3.signal = "-" ; + return 0 ; + elseif bnum1.signal == "-" and bnum2.signal == "-" then + bnum1.signal = "+" ; + bnum2.signal = "+" ; + BigNum.div( bnum1 , bnum2 , bnum3 , bnum4 ) ; + bnum1.signal = "-" ; + if bnum4 < zero then --Check if remainder is negative + BigNum.add( bnum3 , one , bnum3 ) ; + BigNum.sub( bnum2 , bnum4 , bnum4 ) ; + end + bnum2.signal = "-" ; + return 0 ; + end + temp.len = bnum1.len - bnum2.len - 1 ; + + --Reset variables + BigNum.change( bnum3 , "0" ) ; + BigNum.change( bnum4 , "0" ) ; + + BigNum.copy( bnum1 , bnum4 ) ; + + --Check if can continue dividing + while( BigNum.compareAbs( bnum4 , bnum2 ) ~= 2 ) do + if bnum4[bnum4.len - 1] >= bnum2[bnum2.len - 1] then + BigNum.put( temp , math.floor( bnum4[bnum4.len - 1] / bnum2[bnum2.len - 1] ) , bnum4.len - bnum2.len ) ; + temp.len = bnum4.len - bnum2.len + 1 ; + else + BigNum.put( temp , math.floor( ( bnum4[bnum4.len - 1] * RADIX + bnum4[bnum4.len - 2] ) / bnum2[bnum2.len -1] ) , bnum4.len - bnum2.len - 1 ) ; + temp.len = bnum4.len - bnum2.len ; + end + + if bnum4.signal ~= bnum2.signal then + temp.signal = "-"; + else + temp.signal = "+"; + end + BigNum.add( temp , bnum3 , bnum3 ) ; + temp = temp * bnum2 ; + BigNum.sub( bnum4 , temp , bnum4 ) ; + end + + --Update if the remainder is negative + if bnum4.signal == '-' then + decr( bnum3 ) ; + BigNum.add( bnum2 , bnum4 , bnum4 ) ; + end + return 0 ; +end + +function BigNum.pow( bnum1 , bnum2 ) + local n = BigNum.new( bnum2 ) ; + local y = BigNum.new( 1 ) ; + local z = BigNum.new( bnum1 ) ; + local zero = BigNum.new( "0" ) ; + if bnum2 < zero then + error( "Function BigNum.exp: domain error" ) ; + elseif bnum2 == zero then + return y ; + end + while 1 do + if ( n[0] % 2 ) == 0 then + n = n / 2 ; + else + n = n / 2 ; + y = z * y ; + if n == zero then + return y ; + end + end + z = z * z ; + end +end +-- Português : +BigNum.exp = BigNum.pow + +function BigNum.gcd( bnum1 , bnum2 ) + local a = {} ; + local b = {} ; + local c = {} ; + local d = {} ; + local zero = {} ; + zero = BigNum.new( "0" ) ; + if bnum1 == zero or bnum2 == zero then + return BigNum.new( "1" ) ; + end + a = BigNum.new( bnum1 ) ; + b = BigNum.new( bnum2 ) ; + a.signal = '+' ; + b.signal = '+' ; + c = BigNum.new() ; + d = BigNum.new() ; + while b > zero do + BigNum.div( a , b , c , d ) ; + a , b , d = b , d , a ; + end + return a ; +end +-- Português: +BigNum.mmc = BigNum.gcd + +function BigNum.eq( bnum1 , bnum2 ) + if BigNum.compare( bnum1 , bnum2 ) == 0 then + return true ; + else + return false ; + end +end + +function BigNum.lt( bnum1 , bnum2 ) + if BigNum.compare( bnum1 , bnum2 ) == 2 then + return true ; + else + return false ; + end +end + +function BigNum.le( bnum1 , bnum2 ) + local temp = -1 ; + temp = BigNum.compare( bnum1 , bnum2 ) + if temp == 0 or temp == 2 then + return true ; + else + return false ; + end +end + +function BigNum.compareAbs( bnum1 , bnum2 ) + if bnum1 == nil or bnum2 == nil then + error("Function compare: parameter nil") ; + elseif bnum1.len > bnum2.len then + return 1 ; + elseif bnum1.len < bnum2.len then + return 2 ; + else + local i ; + for i = bnum1.len - 1 , 0 , -1 do + if bnum1[i] > bnum2[i] then + return 1 ; + elseif bnum1[i] < bnum2[i] then + return 2 ; + end + end + end + return 0 ; +end + +function BigNum.compare( bnum1 , bnum2 ) + local signal = 0 ; + + if bnum1 == nil or bnum2 == nil then + error("Funtion BigNum.compare: parameter nil") ; + elseif bnum1.signal == '+' and bnum2.signal == '-' then + return 1 ; + elseif bnum1.signal == '-' and bnum2.signal == '+' then + return 2 ; + elseif bnum1.signal == '-' and bnum2.signal == '-' then + signal = 1 ; + end + if bnum1.len > bnum2.len then + return 1 + signal ; + elseif bnum1.len < bnum2.len then + return 2 - signal ; + else + local i ; + for i = bnum1.len - 1 , 0 , -1 do + if bnum1[i] > bnum2[i] then + return 1 + signal ; + elseif bnum1[i] < bnum2[i] then + return 2 - signal ; + end + end + end + return 0 ; +end + +function BigNum.copy( bnum1 , bnum2 ) + if bnum1 ~= nil and bnum2 ~= nil then + local i ; + for i = 0 , bnum1.len - 1 do + bnum2[i] = bnum1[i] ; + end + bnum2.len = bnum1.len ; + else + error("Function BigNum.copy: parameter nil") ; + end +end + +function BigNum.change( bnum1 , num ) + local j = 0 ; + local len = 0 ; + local num = num ; + local l ; + local oldLen = 0 ; + if bnum1 == nil then + error( "BigNum.change: parameter nil" ) ; + elseif type( bnum1 ) ~= "table" then + error( "BigNum.change: parameter error, type unexpected" ) ; + elseif num == nil then + bnum1.len = 1 ; + bnum1[0] = 0 ; + bnum1.signal = "+"; + elseif type( num ) == "table" and num.len ~= nil then --check if num is a big number + --copy given table to the new one + for i = 0 , num.len do + bnum1[i] = num[i] ; + end + if num.signal ~= '-' and num.signal ~= '+' then + bnum1.signal = '+' ; + else + bnum1.signal = num.signal ; + end + oldLen = bnum1.len ; + bnum1.len = num.len ; + elseif type( num ) == "string" or type( num ) == "number" then + if string.sub( num , 1 , 1 ) == '+' or string.sub( num , 1 , 1 ) == '-' then + bnum1.signal = string.sub( num , 1 , 1 ) ; + num = string.sub(num, 2) ; + else + bnum1.signal = '+' ; + end + num = string.gsub( num , " " , "" ) ; + local sf = string.find( num , "e" ) ; + --Handles if the number is in exp notation + if sf ~= nil then + num = string.gsub( num , "%." , "" ) ; + local e = string.sub( num , sf + 1 ) ; + e = tonumber(e) ; + if e ~= nil and e > 0 then + e = tonumber(e) ; + else + error( "Function BigNum.change: string is not a valid number" ) ; + end + num = string.sub( num , 1 , sf - 2 ) ; + for i = string.len( num ) , e do + num = num .. "0" ; + end + else + sf = string.find( num , "%." ) ; + if sf ~= nil then + num = string.sub( num , 1 , sf - 1 ) ; + end + end + + l = string.len( num ) ; + oldLen = bnum1.len ; + if (l > RADIX_LEN) then + local mod = l-( math.floor( l / RADIX_LEN ) * RADIX_LEN ) ; + for i = 1 , l-mod, RADIX_LEN do + bnum1[j] = tonumber( string.sub( num, -( i + RADIX_LEN - 1 ) , -i ) ); + --Check if string dosn't represents a number + if bnum1[j] == nil then + error( "Function BigNum.change: string is not a valid number" ) ; + bnum1.len = 0 ; + return 1 ; + end + j = j + 1 ; + len = len + 1 ; + end + if (mod ~= 0) then + bnum1[j] = tonumber( string.sub( num , 1 , mod ) ) ; + bnum1.len = len + 1 ; + else + bnum1.len = len ; + end + --Eliminate trailing zeros + for i = bnum1.len - 1 , 1 , -1 do + if bnum1[i] == 0 then + bnum1[i] = nil ; + bnum1.len = bnum1.len - 1 ; + else + break ; + end + end + + else + -- string.len(num) <= RADIX_LEN + bnum1[j] = tonumber( num ) ; + bnum1.len = 1 ; + end + else + error( "Function BigNum.change: parameter error, type unexpected" ) ; + end + + --eliminates the deprecated higher order 'algarisms' + if oldLen ~= nil then + for i = bnum1.len , oldLen do + bnum1[i] = nil ; + end + end + + return 0 ; +end + +function BigNum.put( bnum , int , pos ) + if bnum == nil then + error("Function BigNum.put: parameter nil") ; + end + local i = 0 ; + for i = 0 , pos - 1 do + bnum[i] = 0 ; + end + bnum[pos] = int ; + for i = pos + 1 , bnum.len do + bnum[i] = nil ; + end + bnum.len = pos ; + return 0 ; +end + +--printraw{{{2 +function printraw( bnum ) + local i = 0 ; + if bnum == nil then + error( "Function printraw: parameter nil" ) ; + end + while 1 == 1 do + if bnum[i] == nil then + io.write( ' len '..bnum.len ) ; + if i ~= bnum.len then + io.write( ' ERRO!!!!!!!!' ) ; + end + io.write( "\n" ) ; + return 0 ; + end + io.write( 'r'..bnum[i] ) ; + i = i + 1 ; + end +end +--max{{{2 +function max( int1 , int2 ) + if int1 > int2 then + return int1 ; + else + return int2 ; + end +end + +--decr{{{2 +function decr( bnum1 ) + local temp = {} ; + temp = BigNum.new( "1" ) ; + BigNum.sub( bnum1 , temp , bnum1 ) ; + return 0 ; +end diff --git a/bin/numbers/BigRat.lua b/bin/numbers/BigRat.lua new file mode 100644 index 0000000..40e9777 --- /dev/null +++ b/bin/numbers/BigRat.lua @@ -0,0 +1,227 @@ +require( "bin.numbers.BigNum" ) ; + +BigRat = {} ; +BigRat.mt = {} ; +function BigRat.new( num1 , num2 ) --{{{2 + local bigrat = {} ; + local f ; + setmetatable(bigrat, BigRat.mt) ; + if type( num1 ) == "table" then + if num1.num ~= nil and num1.den ~= nil then + bigrat.num = BigNum.new( num1.num ) ; + bigrat.den = BigNum.new( num1.den ) ; + else + bigrat.num = BigNum.new( num1 ) ; + bigrat.den = BigNum.new( "1" ) ; + end + elseif num1 ~= nil then + if num2 == nil then + bigrat.den = BigNum.new( "1" ) ; + else + bigrat.den = BigNum.new( num2 ) ; + end + bigrat.num = BigNum.new( num1 ) ; + else + bigrat.den = BigNum.new( ) ; + bigrat.num = BigNum.new( ) ; + end + + --Update the signals + if bigrat.den.signal == "-" then + if bigrat.num.signal == "-" then + bigrat.num.signal = "+" ; + else + bigrat.num.signal = "-" ; + end + bigrat.den.signal = "+" ; + end + + return bigrat ; +end + +function BigRat.mt.sub( num1 , num2 ) + local temp = BigRat.new() ; + local brat1 = BigRat.new( num1 ) ; + local brat2 = BigRat.new( num2 ) ; + BigRat.sub( brat1 , brat2 , temp ) ; + return temp ; +end + +function BigRat.mt.add( num1 , num2 ) + local temp = BigRat.new() ; + local brat1 = BigRat.new( num1 ) ; + local brat2 = BigRat.new( num2 ) ; + BigRat.add( brat1 , brat2 , temp ) ; + return temp ; +end + +function BigRat.mt.mul( num1 , num2 ) + local temp = BigRat.new() ; + local brat1 = BigRat.new( num1 ) ; + local brat2 = BigRat.new( num2 ) ; + BigRat.mul( brat1 , brat2 , temp ) ; + return temp ; +end + +function BigRat.mt.div( num1 , num2 ) + local brat1 = BigRat.new( num1 ) ; + local brat2 = BigRat.new( num2 ) ; + local brat3 = BigRat.new() ; + local brat4 = BigRat.new() ; + BigRat.div( brat1 , brat2 , brat3 , brat4 ) ; + return brat3 , brat4 ; +end + +function BigRat.mt.tostring( brat ) + BigRat.simplify( brat ) ; + return BigNum.mt.tostring( brat.num ) .. " / " .. BigNum.mt.tostring( brat.den ) ; +end + +function BigRat.mt.pow ( num1 , num2 ) + local brat1 = BigRat.new( num1 ) ; + local brat2 = BigRat.new( num2 ) ; + return BigRat.pow( brat1 , brat2 ) +end + +function BigRat.mt.eq ( num1 , num2 ) + return BigRat.eq( num1 , num2 ) +end + +function BigRat.mt.lt ( num1 , num2 ) + return BigRat.lt( num1 , num2 ) +end + +function BigRat.mt.le ( num1 , num2 ) + return BigRat.le( num1 , num2 ) +end + +function BigRat.mt.unm ( num ) + local ret = BigRat.new( num ) + if ret.num.signal == '-' then + ret.num.signal = '+' + else + ret.num.signal = '-' + end + return ret +end + +BigRat.mt.__metatable = "hidden" +BigRat.mt.__tostring = BigRat.mt.tostring +BigRat.mt.__add = BigRat.mt.add +BigRat.mt.__sub = BigRat.mt.sub +BigRat.mt.__mul = BigRat.mt.mul +BigRat.mt.__div = BigRat.mt.div +BigRat.mt.__pow = BigRat.mt.pow +BigRat.mt.__unm = BigRat.mt.unm +BigRat.mt.__eq = BigRat.mt.eq +BigRat.mt.__le = BigRat.mt.le +BigRat.mt.__lt = BigRat.mt.lt +setmetatable( BigRat.mt, { __index = "inexistent field", __newindex = "not available", __metatable="hidden" } ) ; +function BigRat.add( brat1 , brat2 , brat3 ) + brat3.den = brat1.den * brat2.den ; + brat3.num = ( brat1.num * brat2.den ) + ( brat2.num * brat1.den ) ; + return brat3 ; +end +function BigRat.sub( brat1 , brat2 , brat3 ) + brat3.den = brat1.den * brat2.den ; + brat3.num = ( brat1.num * brat2.den ) - ( brat2.num * brat1.den ) ; + return brat3 ; +end + +function BigRat.mul( brat1 , brat2 , brat3 ) + brat3.num = brat1.num * brat2.num ; + brat3.den = brat1.den * brat2.den ; + return 0 ; +end + +function BigRat.div( brat1 , brat2 , brat3 ) + brat3.num = brat1.num * brat2.den ; + brat3.den = brat1.den * brat2.num ; + return brat3 ; +end + +function BigRat.pow( bnum1 , bnum2 ) + if bnum1 == nil or bnum2 == nil then + error( "Function BigRat.pow: parameter nil" ) ; + end + local x = BigRat.new( "8" ) ; + local n = BigRat.new( bnum2.den ) ; + local n2 ; + local y = BigRat.new( ) ; + local i ; + local temp = BigRat.new( ) ; + + BigRat.simplify( bnum2 ) ; + temp.num = BigNum.exp( bnum1.num , bnum2.num ) ; + temp.den = BigNum.exp( bnum1.den , bnum2.num ) ; + n2 = n - 1 ; + + for i = 0 , 4 do + y.num = x.num ^ n2.num ; + y.den = x.den ^ n2.num ; + x = (( temp / y ) + ( n2 * x )) / n ; + end + return x ; +end + +function BigRat.simplify( brat ) + if brat == nil then + error( "Function BigRat.simplify: parameter nil" ) ; + end + local gcd = BigNum.new( ) ; + local temp = BigRat.new( brat ) ; + local devnull = BigNum.new( ) ; + local zero = BigNum.new( "0" ) ; + --Check if numerator is zero + if BigNum.compareAbs( brat.num , zero ) == 0 then + brat.den = BigNum.new( "1" ) ; + return 0 ; + end + gcd = BigNum.gcd( brat.num , brat.den ) ; + BigNum.div( temp.num , gcd , brat.num , devnull ) ; + BigNum.div( temp.den , gcd , brat.den , devnull ) ; + --Update the signal + if brat.num.signal == '-' and brat.den.signal == '-' then + brat.num.signal = '+' ; + brat.den.signal = '+' ; + end + return 0 ; +end + +function BigRat.eq( brat1 , brat2 ) + if BigRat.compare( brat1 , brat2 ) == 0 then + return true ; + else + return false ; + end +end + +function BigRat.lt( brat1 , brat2 ) + if BigRat.compare( brat1 , brat2 ) == 2 then + return true ; + else + return false ; + end +end + +function BigRat.le( brat1 , brat2 ) + local temp = -1 ; + temp = BigRat.compare( brat1 , brat2 ) + if temp == 0 or temp == 2 then + return true ; + else + return false ; + end +end + +function BigRat.compare( bnum1 , bnum2 ) + local temp ; + temp = bnum1 - bnum2 ; + if temp.num[0] == 0 and temp.num.len == 1 then --Check if is zero + return 0 ; + elseif temp.num.signal == "-" then + return 2 ; + else + return 1 ; + end +end diff --git a/bin/numbers/no_jit_bit.lua b/bin/numbers/no_jit_bit.lua new file mode 100644 index 0000000..2cfdc1d --- /dev/null +++ b/bin/numbers/no_jit_bit.lua @@ -0,0 +1,333 @@ +--[[ +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 diff --git a/bin/numbers/random.lua b/bin/numbers/random.lua new file mode 100644 index 0000000..091a7f5 --- /dev/null +++ b/bin/numbers/random.lua @@ -0,0 +1,232 @@ +--[[---------------------------------------- +Random +Not all of this is mine +------------------------------------------]] +--[[------------------------------------ +RandomLua v0.3.1 +Pure Lua Pseudo-Random Numbers Generator +Under the MIT license. +copyright(c) 2011 linux-man +--]]------------------------------------ + +local math_floor = math.floor + +local function normalize(n) + return n % 0x80000000 +end + +local function bit_and(a, b) + local r = 0 + local m = 0 + for m = 0, 31 do + if (a % 2 == 1) and (b % 2 == 1) then r = r + 2^m end + if a % 2 ~= 0 then a = a - 1 end + if b % 2 ~= 0 then b = b - 1 end + a = a / 2 b = b / 2 + end + return normalize(r) +end + +local function bit_or(a, b) + local r = 0 + local m = 0 + for m = 0, 31 do + if (a % 2 == 1) or (b % 2 == 1) then r = r + 2^m end + if a % 2 ~= 0 then a = a - 1 end + if b % 2 ~= 0 then b = b - 1 end + a = a / 2 b = b / 2 + end + return normalize(r) +end + +local function bit_xor(a, b) + local r = 0 + local m = 0 + for m = 0, 31 do + if a % 2 ~= b % 2 then r = r + 2^m end + if a % 2 ~= 0 then a = a - 1 end + if b % 2 ~= 0 then b = b - 1 end + a = a / 2 b = b / 2 + end + return normalize(r) +end + +local function seed() + return normalize(os.time()) +end + +--Mersenne twister +local mersenne_twister = {} +mersenne_twister.__index = mersenne_twister + +function mersenne_twister:randomseed(s) + if not s then s = seed() end + self.mt[0] = normalize(s) + for i = 1, 623 do + self.mt[i] = normalize(0x6c078965 * bit_xor(self.mt[i-1], math_floor(self.mt[i-1] / 0x40000000)) + i) + end +end + +function mersenne_twister:random(a, b) + local y + if self.index == 0 then + for i = 0, 623 do + y = self.mt[(i + 1) % 624] % 0x80000000 + self.mt[i] = bit_xor(self.mt[(i + 397) % 624], math_floor(y / 2)) + if y % 2 ~= 0 then self.mt[i] = bit_xor(self.mt[i], 0x9908b0df) end + end + end + y = self.mt[self.index] + y = bit_xor(y, math_floor(y / 0x800)) + y = bit_xor(y, bit_and(normalize(y * 0x80), 0x9d2c5680)) + y = bit_xor(y, bit_and(normalize(y * 0x8000), 0xefc60000)) + y = bit_xor(y, math_floor(y / 0x40000)) + self.index = (self.index + 1) % 624 + if not a then return y / 0x80000000 + elseif not b then + if a == 0 then return y + else return 1 + (y % a) + end + else + return a + (y % (b - a + 1)) + end +end + +local function twister(s) + local temp = {} + setmetatable(temp, mersenne_twister) + temp.mt = {} + temp.index = 0 + temp:randomseed(s) + return temp +end + +--Linear Congruential Generator +local linear_congruential_generator = {} +linear_congruential_generator.__index = linear_congruential_generator + +function linear_congruential_generator:random(a, b) + local y = (self.a * self.x + self.c) % self.m + self.x = y + if not a then return y / 0x10000 + elseif not b then + if a == 0 then return y + else return 1 + (y % a) end + else + return a + (y % (b - a + 1)) + end +end + +function linear_congruential_generator:randomseed(s) + if not s then s = seed() end + self.x = normalize(s) +end + +local function lcg(s, r) + local temp = {} + setmetatable(temp, linear_congruential_generator) + temp.a, temp.c, temp.m = 1103515245, 12345, 0x10000 --from Ansi C + if r then + if r == 'nr' then temp.a, temp.c, temp.m = 1664525, 1013904223, 0x10000 --from Numerical Recipes. + elseif r == 'mvc' then temp.a, temp.c, temp.m = 214013, 2531011, 0x10000 end--from MVC + end + temp:randomseed(s) + return temp +end + +-- Multiply-with-carry +local multiply_with_carry = {} +multiply_with_carry.__index = multiply_with_carry + +function multiply_with_carry:random(a, b) + local m = self.m + local t = self.a * self.x + self.c + local y = t % m + self.x = y + self.c = math_floor(t / m) + if not a then return y / 0x10000 + elseif not b then + if a == 0 then return y + else return 1 + (y % a) end + else + return a + (y % (b - a + 1)) + end +end + +function multiply_with_carry:randomseed(s) + if not s then s = seed() end + self.c = self.ic + self.x = normalize(s) +end + +local function mwc(s, r) + local temp = {} + setmetatable(temp, multiply_with_carry) + temp.a, temp.c, temp.m = 1103515245, 12345, 0x10000 --from Ansi C + if r then + if r == 'nr' then temp.a, temp.c, temp.m = 1664525, 1013904223, 0x10000 --from Numerical Recipes. + elseif r == 'mvc' then temp.a, temp.c, temp.m = 214013, 2531011, 0x10000 end--from MVC + end + temp.ic = temp.c + temp:randomseed(s) + return temp +end +-- Little bind for the methods: My code starts +local randomGen={} +randomGen.__index=randomGen +function randomGen:new(s) + local temp={} + setmetatable(temp,randomGen) + temp[1]=twister() + temp[2]=lcg() + temp[3]=mwc() + temp.pos=1 + for i=1,3 do + temp[i]:randomseed(s) + end + return temp +end +function randomGen:randomseed(s) + self.pos=1 + self[1]:randomseed(s) + self[2]:randomseed(s) + self[3]:randomseed(s) +end +function randomGen:randomInt(a,b) + local t=self[self.pos]:random(a,b) + self.pos=self.pos+1 + if self.pos>3 then + self.pos=1 + end + return t +end +function randomGen:newND(a,b,s) + if not(a) or not(b) then error('You must include a range!') end + local temp=randomGen:new(s) + temp.a=a + temp.b=b + temp.range=b-a+1 + temp.dups={no=0} + function temp:nextInt() + local t=self:randomInt(self.a,self.b) + if self.dups[t]==nil then + self.dups[t]=true + self.dups.no=self.dups.no+1 + else + return self:nextInt() + end + if self.dups.no==self.range then + function self:nextInt() + return 1,true + end + return t + else + return t + end + end + function temp:nextIInt() + return function() return self:nextInt() end + end + return temp +end +return randomGen diff --git a/bin/support/vfs.lua b/bin/support/vfs.lua new file mode 100644 index 0000000..dae0b43 --- /dev/null +++ b/bin/support/vfs.lua @@ -0,0 +1 @@ +local bin = require("bin") \ No newline at end of file diff --git a/freetype6.dll b/freetype6.dll new file mode 100644 index 0000000..f0f5cf7 Binary files /dev/null and b/freetype6.dll differ diff --git a/game.png b/game.png new file mode 100644 index 0000000..1066eaa Binary files /dev/null and b/game.png differ diff --git a/gd.dll b/gd.dll new file mode 100644 index 0000000..db6add4 Binary files /dev/null and b/gd.dll differ diff --git a/jpeg62.dll b/jpeg62.dll new file mode 100644 index 0000000..21c03d5 Binary files /dev/null and b/jpeg62.dll differ diff --git a/libgd2.dll b/libgd2.dll new file mode 100644 index 0000000..5ef2275 Binary files /dev/null and b/libgd2.dll differ diff --git a/libiconv2.dll b/libiconv2.dll new file mode 100644 index 0000000..747073f Binary files /dev/null and b/libiconv2.dll differ diff --git a/libpng13.dll b/libpng13.dll new file mode 100644 index 0000000..e328d39 Binary files /dev/null and b/libpng13.dll differ diff --git a/loveandroid.apk b/loveandroid.apk new file mode 100644 index 0000000..f5cf3a0 Binary files /dev/null and b/loveandroid.apk differ diff --git a/lua5.1.dll b/lua5.1.dll new file mode 100644 index 0000000..b87f3b6 Binary files /dev/null and b/lua5.1.dll differ diff --git a/lua51.dll b/lua51.dll new file mode 100644 index 0000000..27ab265 Binary files /dev/null and b/lua51.dll differ diff --git a/readme.md b/readme.md new file mode 100644 index 0000000..be39a6a --- /dev/null +++ b/readme.md @@ -0,0 +1,9 @@ +This is a simple tool for turning game.love into .apk + +Note: This is for testing to see if your app works on andriod! The apk is signed using a debug key! You can sign it your self (The non alinged apk) using: apk-signer-1.8.5.jar This will give it a unique key and will not be in debug mode. + +Requirements: java jdk + +Useage: run the Compile.exe file and it will run through the steps. + +If game.png is present it will compile that for you as well \ No newline at end of file diff --git a/src/Compile.lua b/src/Compile.lua new file mode 100644 index 0000000..f55c8f6 --- /dev/null +++ b/src/Compile.lua @@ -0,0 +1,127 @@ +package.path = "./?/init.lua;./?.lua;" +package.cpath = "./?.dll;" +local gd = require("gd") +local bin = require("bin") +function getInput(msg,list) + io.write(msg or "") + local dat = io.read() + if list then + for i=1,#list do + if list[i]==dat then + return dat + end + end + print("Invalid input: "..dat) + return getInput(msg,list) + else + return dat + end +end +io.mkDir("dat") +print("AutoLoveMaker V1.0.0\nEnsure that all your files are in the same directory as the program! game.love, and loveandroid.apk must be present with these filenames for the program to work!") +name = getInput("Game Name: ") +_o={l = "sensorLandscape",p = "portrait"} +if bin.fileExist("dat/"..name..".dat") then + b = getInput("You have compiled a game by this name before! Do you want to use the last build settings? (y/n): ",{"y","n"}) + if b then + local file = bin.load("dat/"..name..".dat") + local dat = file:getBlock("t") + o=dat.o + packageName=dat.packageName + ver=dat.ver + verN=dat.verN + else + print("We are going to manage Settings that affect your apk...") + o = getInput("Svreep Orientation(p - portrait | l - landscape): ",{"o","p"}) + packageName = "game."..name..".org" + ver = getInput("Version Code(number): ") + verN = getInput("Version Name(number.number): ") + os.execute([[apktool d -s -o love_decoded loveandroid.apk]]) + io.mkDir("love_decoded/assets") + bin.load("game.love"):tofile("love_decoded/assets/game.love") + local file = bin.new() + file:addBlock({ + o = o, + packageName = packageName, + ver = ver, + verN = verN, + }) + file:tofile("dat/"..name..".dat") + end +else + print("We are going to manage Settings that affect your apk...") + o = getInput("Svreep Orientation(p - portrait | l - landscape): ",{"o","p"}) + packageName = "game."..name..".org" + ver = getInput("Version Code(number): ") + verN = getInput("Version Name(number.number): ") + os.execute([[apktool d -s -o love_decoded loveandroid.apk]]) + io.mkDir("love_decoded/assets") + bin.load("game.love"):tofile("love_decoded/assets/game.love") + local file = bin.new() + file:addBlock({ + o = o, + packageName = packageName, + ver = ver, + verN = verN, + }) + file:tofile("dat/"..name..".dat") +end +if bin.fileExist("game.png") then + print("building icon") + local icon = gd.createFromPng("game.png") + local i48 = gd.createFromPng("love_decoded/res/drawable-mdpi/love.png") + local i96 = gd.createFromPng("love_decoded/res/drawable-xhdpi/love.png") + local i144 = gd.createFromPng("love_decoded/res/drawable-xxhdpi/love.png") + local i192 = gd.createFromPng("love_decoded/res/drawable-xxxhdpi/love.png") + i48:copyResized(icon, 0, 0, 0, 0, 48, 48, 192, 192) + i96:copyResized(icon, 0, 0, 0, 0, 96, 96, 192, 192) + i144:copyResized(icon, 0, 0, 0, 0, 144, 144, 192, 192) + i192:copyResized(icon, 0, 0, 0, 0, 192, 192, 192, 192) + i48:pngEx("love_decoded/res/drawable-mdpi/love.png",0) + i96:pngEx("love_decoded/res/drawable-xhdpi/love.png",0) + i144:pngEx("love_decoded/res/drawable-xxhdpi/love.png",0) + i192:pngEx("love_decoded/res/drawable-xxxhdpi/love.png",0) +end +bin.new([[ + + + + + + + + + + + + + + + +]]):tofile("love_decoded/AndroidManifest.xml") +temp = bin.load("love_decoded/apktool.yml") +temp.data:gsub("minSdkVersion: '(%d%d)'","minSdkVersion: '16'") +temp.data:gsub("targetSdkVersion: '(%d%d)'","targetSdkVersion: '16'") +temp:tofile("love_decoded/apktool.yml") +print("Building apk...") +os.execute([[apktool b -o ]]..name..[[.apk love_decoded]]) +print("Signing apk...") +os.execute([[java -jar uber-apk-signer.jar -a ]]..name..[[.apk]]) +--minSdkVersion: '16' +--targetSdkVersion: '16' + +--portrait,sensorLandscape diff --git a/uber-apk-signer.jar b/uber-apk-signer.jar new file mode 100644 index 0000000..d98575b Binary files /dev/null and b/uber-apk-signer.jar differ diff --git a/zlib1.dll b/zlib1.dll new file mode 100644 index 0000000..31996cd Binary files /dev/null and b/zlib1.dll differ