mirror of
https://github.com/ralsina/tartrazine.git
synced 2024-11-14 15:32:24 +00:00
8ff885a3a8
Closes #17 Implements the IsGenerated helper function to filter out generated files using the rules and matchers in: - https://github.com/github/linguist/blob/master/lib/linguist/generated.rb Since the vast majority of matchers have very different logic, it cannot be autogenerated directly from linguist like other logics in enry, so it's translated by hand. There are three different types of matchers in this implementation: - By extension, which mark as generated based only in the extension. These are the fastest matchers, so they're done first. - By file name, which matches patterns against the filename. These are performed in second place. Unlike linguist, we try to use string functions instead of regexps as much as possible. - Finally, the rest of the matchers, which go into the content and try to identify if they're generated or not based on the content. Unlike linguist, we try to only read the content we need and not split it all unless it's necessary and use byte functions instead of regexps as much as possible. Signed-off-by: Miguel Molina <miguel@erizocosmi.co>
816 lines
20 KiB
Lua
816 lines
20 KiB
Lua
-- Generated by Haxe 4.0.5
|
|
local _hx_array_mt = {
|
|
__newindex = function(t,k,v)
|
|
local len = t.length
|
|
t.length = k >= len and (k + 1) or len
|
|
rawset(t,k,v)
|
|
end
|
|
}
|
|
|
|
local function _hx_tab_array(tab,length)
|
|
tab.length = length
|
|
return setmetatable(tab, _hx_array_mt)
|
|
end
|
|
|
|
local function _hx_anon_newindex(t,k,v) t.__fields__[k] = true; rawset(t,k,v); end
|
|
local _hx_anon_mt = {__newindex=_hx_anon_newindex}
|
|
local function _hx_a(...)
|
|
local __fields__ = {};
|
|
local ret = {__fields__ = __fields__};
|
|
local max = select('#',...);
|
|
local tab = {...};
|
|
local cur = 1;
|
|
while cur < max do
|
|
local v = tab[cur];
|
|
__fields__[v] = true;
|
|
ret[v] = tab[cur+1];
|
|
cur = cur + 2
|
|
end
|
|
return setmetatable(ret, _hx_anon_mt)
|
|
end
|
|
|
|
local function _hx_e()
|
|
return setmetatable({__fields__ = {}}, _hx_anon_mt)
|
|
end
|
|
|
|
local function _hx_o(obj)
|
|
return setmetatable(obj, _hx_anon_mt)
|
|
end
|
|
|
|
local function _hx_new(prototype)
|
|
return setmetatable({__fields__ = {}}, {__newindex=_hx_anon_newindex, __index=prototype})
|
|
end
|
|
|
|
local _hxClasses = {}
|
|
local Int = _hx_e();
|
|
local Dynamic = _hx_e();
|
|
local Float = _hx_e();
|
|
local Bool = _hx_e();
|
|
local Class = _hx_e();
|
|
local Enum = _hx_e();
|
|
|
|
local Array = _hx_e()
|
|
__lua_lib_luautf8_Utf8 = _G.require("lua-utf8")
|
|
local Main = _hx_e()
|
|
local Math = _hx_e()
|
|
local String = _hx_e()
|
|
local Std = _hx_e()
|
|
__haxe_Log = _hx_e()
|
|
__lua_Boot = _hx_e()
|
|
|
|
local _hx_bind, _hx_bit, _hx_staticToInstance, _hx_funcToField, _hx_maxn, _hx_print, _hx_apply_self, _hx_box_mr, _hx_bit_clamp, _hx_table, _hx_bit_raw
|
|
local _hx_pcall_default = {};
|
|
local _hx_pcall_break = {};
|
|
|
|
Array.new = function()
|
|
local self = _hx_new(Array.prototype)
|
|
Array.super(self)
|
|
return self
|
|
end
|
|
Array.super = function(self)
|
|
_hx_tab_array(self, 0);
|
|
end
|
|
Array.prototype = _hx_a();
|
|
Array.prototype.concat = function(self,a)
|
|
local _g = _hx_tab_array({}, 0);
|
|
local _g1 = 0;
|
|
local _g2 = self;
|
|
while (_g1 < _g2.length) do
|
|
local i = _g2[_g1];
|
|
_g1 = _g1 + 1;
|
|
_g:push(i);
|
|
end;
|
|
local ret = _g;
|
|
local _g3 = 0;
|
|
while (_g3 < a.length) do
|
|
local i1 = a[_g3];
|
|
_g3 = _g3 + 1;
|
|
ret:push(i1);
|
|
end;
|
|
do return ret end
|
|
end
|
|
Array.prototype.join = function(self,sep)
|
|
local tbl = ({});
|
|
local _gthis = self;
|
|
local cur_length = 0;
|
|
local i = _hx_o({__fields__={hasNext=true,next=true},hasNext=function(self)
|
|
do return cur_length < _gthis.length end;
|
|
end,next=function(self)
|
|
cur_length = cur_length + 1;
|
|
do return _gthis[cur_length - 1] end;
|
|
end});
|
|
while (i:hasNext()) do
|
|
local i1 = i:next();
|
|
_G.table.insert(tbl, Std.string(i1));
|
|
end;
|
|
do return _G.table.concat(tbl, sep) end
|
|
end
|
|
Array.prototype.pop = function(self)
|
|
if (self.length == 0) then
|
|
do return nil end;
|
|
end;
|
|
local ret = self[self.length - 1];
|
|
self[self.length - 1] = nil;
|
|
self.length = self.length - 1;
|
|
do return ret end
|
|
end
|
|
Array.prototype.push = function(self,x)
|
|
self[self.length] = x;
|
|
do return self.length end
|
|
end
|
|
Array.prototype.reverse = function(self)
|
|
local tmp;
|
|
local i = 0;
|
|
while (i < Std.int(self.length / 2)) do
|
|
tmp = self[i];
|
|
self[i] = self[(self.length - i) - 1];
|
|
self[(self.length - i) - 1] = tmp;
|
|
i = i + 1;
|
|
end;
|
|
end
|
|
Array.prototype.shift = function(self)
|
|
if (self.length == 0) then
|
|
do return nil end;
|
|
end;
|
|
local ret = self[0];
|
|
if (self.length == 1) then
|
|
self[0] = nil;
|
|
else
|
|
if (self.length > 1) then
|
|
self[0] = self[1];
|
|
_G.table.remove(self, 1);
|
|
end;
|
|
end;
|
|
local tmp = self;
|
|
tmp.length = tmp.length - 1;
|
|
do return ret end
|
|
end
|
|
Array.prototype.slice = function(self,pos,_end)
|
|
if ((_end == nil) or (_end > self.length)) then
|
|
_end = self.length;
|
|
else
|
|
if (_end < 0) then
|
|
_end = _G.math.fmod((self.length - (_G.math.fmod(-_end, self.length))), self.length);
|
|
end;
|
|
end;
|
|
if (pos < 0) then
|
|
pos = _G.math.fmod((self.length - (_G.math.fmod(-pos, self.length))), self.length);
|
|
end;
|
|
if ((pos > _end) or (pos > self.length)) then
|
|
do return _hx_tab_array({}, 0) end;
|
|
end;
|
|
local ret = _hx_tab_array({}, 0);
|
|
local _g = pos;
|
|
local _g1 = _end;
|
|
while (_g < _g1) do
|
|
_g = _g + 1;
|
|
local i = _g - 1;
|
|
ret:push(self[i]);
|
|
end;
|
|
do return ret end
|
|
end
|
|
Array.prototype.sort = function(self,f)
|
|
local i = 0;
|
|
local l = self.length;
|
|
while (i < l) do
|
|
local swap = false;
|
|
local j = 0;
|
|
local max = (l - i) - 1;
|
|
while (j < max) do
|
|
if (f(self[j], self[j + 1]) > 0) then
|
|
local tmp = self[j + 1];
|
|
self[j + 1] = self[j];
|
|
self[j] = tmp;
|
|
swap = true;
|
|
end;
|
|
j = j + 1;
|
|
end;
|
|
if (not swap) then
|
|
break;
|
|
end;
|
|
i = i + 1;
|
|
end;
|
|
end
|
|
Array.prototype.splice = function(self,pos,len)
|
|
if ((len < 0) or (pos > self.length)) then
|
|
do return _hx_tab_array({}, 0) end;
|
|
else
|
|
if (pos < 0) then
|
|
pos = self.length - (_G.math.fmod(-pos, self.length));
|
|
end;
|
|
end;
|
|
len = Math.min(len, self.length - pos);
|
|
local ret = _hx_tab_array({}, 0);
|
|
local _g = pos;
|
|
local _g1 = pos + len;
|
|
while (_g < _g1) do
|
|
_g = _g + 1;
|
|
local i = _g - 1;
|
|
ret:push(self[i]);
|
|
self[i] = self[i + len];
|
|
end;
|
|
local _g2 = pos + len;
|
|
local _g3 = self.length;
|
|
while (_g2 < _g3) do
|
|
_g2 = _g2 + 1;
|
|
local i1 = _g2 - 1;
|
|
self[i1] = self[i1 + len];
|
|
end;
|
|
local tmp = self;
|
|
tmp.length = tmp.length - len;
|
|
do return ret end
|
|
end
|
|
Array.prototype.toString = function(self)
|
|
local tbl = ({});
|
|
_G.table.insert(tbl, "[");
|
|
_G.table.insert(tbl, self:join(","));
|
|
_G.table.insert(tbl, "]");
|
|
do return _G.table.concat(tbl, "") end
|
|
end
|
|
Array.prototype.unshift = function(self,x)
|
|
local len = self.length;
|
|
local _g = 0;
|
|
local _g1 = len;
|
|
while (_g < _g1) do
|
|
_g = _g + 1;
|
|
local i = _g - 1;
|
|
self[len - i] = self[(len - i) - 1];
|
|
end;
|
|
self[0] = x;
|
|
end
|
|
Array.prototype.insert = function(self,pos,x)
|
|
if (pos > self.length) then
|
|
pos = self.length;
|
|
end;
|
|
if (pos < 0) then
|
|
pos = self.length + pos;
|
|
if (pos < 0) then
|
|
pos = 0;
|
|
end;
|
|
end;
|
|
local cur_len = self.length;
|
|
while (cur_len > pos) do
|
|
self[cur_len] = self[cur_len - 1];
|
|
cur_len = cur_len - 1;
|
|
end;
|
|
self[pos] = x;
|
|
end
|
|
Array.prototype.remove = function(self,x)
|
|
local _g = 0;
|
|
local _g1 = self.length;
|
|
while (_g < _g1) do
|
|
_g = _g + 1;
|
|
local i = _g - 1;
|
|
if (self[i] == x) then
|
|
local _g2 = i;
|
|
local _g11 = self.length - 1;
|
|
while (_g2 < _g11) do
|
|
_g2 = _g2 + 1;
|
|
local j = _g2 - 1;
|
|
self[j] = self[j + 1];
|
|
end;
|
|
self[self.length - 1] = nil;
|
|
self.length = self.length - 1;
|
|
do return true end;
|
|
end;
|
|
end;
|
|
do return false end
|
|
end
|
|
Array.prototype.indexOf = function(self,x,fromIndex)
|
|
local _end = self.length;
|
|
if (fromIndex == nil) then
|
|
fromIndex = 0;
|
|
else
|
|
if (fromIndex < 0) then
|
|
fromIndex = self.length + fromIndex;
|
|
if (fromIndex < 0) then
|
|
fromIndex = 0;
|
|
end;
|
|
end;
|
|
end;
|
|
local _g = fromIndex;
|
|
local _g1 = _end;
|
|
while (_g < _g1) do
|
|
_g = _g + 1;
|
|
local i = _g - 1;
|
|
if (x == self[i]) then
|
|
do return i end;
|
|
end;
|
|
end;
|
|
do return -1 end
|
|
end
|
|
Array.prototype.lastIndexOf = function(self,x,fromIndex)
|
|
if ((fromIndex == nil) or (fromIndex >= self.length)) then
|
|
fromIndex = self.length - 1;
|
|
else
|
|
if (fromIndex < 0) then
|
|
fromIndex = self.length + fromIndex;
|
|
if (fromIndex < 0) then
|
|
do return -1 end;
|
|
end;
|
|
end;
|
|
end;
|
|
local i = fromIndex;
|
|
while (i >= 0) do
|
|
if (self[i] == x) then
|
|
do return i end;
|
|
else
|
|
i = i - 1;
|
|
end;
|
|
end;
|
|
do return -1 end
|
|
end
|
|
Array.prototype.copy = function(self)
|
|
local _g = _hx_tab_array({}, 0);
|
|
local _g1 = 0;
|
|
local _g2 = self;
|
|
while (_g1 < _g2.length) do
|
|
local i = _g2[_g1];
|
|
_g1 = _g1 + 1;
|
|
_g:push(i);
|
|
end;
|
|
do return _g end
|
|
end
|
|
Array.prototype.map = function(self,f)
|
|
local _g = _hx_tab_array({}, 0);
|
|
local _g1 = 0;
|
|
local _g2 = self;
|
|
while (_g1 < _g2.length) do
|
|
local i = _g2[_g1];
|
|
_g1 = _g1 + 1;
|
|
_g:push(f(i));
|
|
end;
|
|
do return _g end
|
|
end
|
|
Array.prototype.filter = function(self,f)
|
|
local _g = _hx_tab_array({}, 0);
|
|
local _g1 = 0;
|
|
local _g2 = self;
|
|
while (_g1 < _g2.length) do
|
|
local i = _g2[_g1];
|
|
_g1 = _g1 + 1;
|
|
if (f(i)) then
|
|
_g:push(i);
|
|
end;
|
|
end;
|
|
do return _g end
|
|
end
|
|
Array.prototype.iterator = function(self)
|
|
local _gthis = self;
|
|
local cur_length = 0;
|
|
do return _hx_o({__fields__={hasNext=true,next=true},hasNext=function(self)
|
|
do return cur_length < _gthis.length end;
|
|
end,next=function(self)
|
|
cur_length = cur_length + 1;
|
|
do return _gthis[cur_length - 1] end;
|
|
end}) end
|
|
end
|
|
Array.prototype.resize = function(self,len)
|
|
if (self.length < len) then
|
|
self.length = len;
|
|
else
|
|
if (self.length > len) then
|
|
local _g = len;
|
|
local _g1 = self.length;
|
|
while (_g < _g1) do
|
|
_g = _g + 1;
|
|
local i = _g - 1;
|
|
self[i] = nil;
|
|
end;
|
|
self.length = len;
|
|
end;
|
|
end;
|
|
end
|
|
|
|
Main.new = {}
|
|
Main.main = function()
|
|
__haxe_Log.trace("Hello World", _hx_o({__fields__={fileName=true,lineNumber=true,className=true,methodName=true},fileName="source/Main.hx",lineNumber=3,className="Main",methodName="main"}));
|
|
end
|
|
|
|
Math.new = {}
|
|
Math.isNaN = function(f)
|
|
do return f ~= f end;
|
|
end
|
|
Math.isFinite = function(f)
|
|
if (f > -_G.math.huge) then
|
|
do return f < _G.math.huge end;
|
|
else
|
|
do return false end;
|
|
end;
|
|
end
|
|
Math.min = function(a,b)
|
|
if (Math.isNaN(a) or Math.isNaN(b)) then
|
|
do return (0/0) end;
|
|
else
|
|
do return _G.math.min(a, b) end;
|
|
end;
|
|
end
|
|
|
|
String.new = function(string)
|
|
local self = _hx_new(String.prototype)
|
|
String.super(self,string)
|
|
self = string
|
|
return self
|
|
end
|
|
String.super = function(self,string)
|
|
end
|
|
String.__index = function(s,k)
|
|
if (k == "length") then
|
|
do return __lua_lib_luautf8_Utf8.len(s) end;
|
|
else
|
|
local o = String.prototype;
|
|
local field = k;
|
|
if ((function()
|
|
local _hx_1
|
|
if ((_G.type(o) == "string") and ((String.prototype[field] ~= nil) or (field == "length"))) then
|
|
_hx_1 = true; elseif (o.__fields__ ~= nil) then
|
|
_hx_1 = o.__fields__[field] ~= nil; else
|
|
_hx_1 = o[field] ~= nil; end
|
|
return _hx_1
|
|
end )()) then
|
|
do return String.prototype[k] end;
|
|
else
|
|
if (String.__oldindex ~= nil) then
|
|
if (_G.type(String.__oldindex) == "function") then
|
|
do return String.__oldindex(s, k) end;
|
|
else
|
|
if (_G.type(String.__oldindex) == "table") then
|
|
do return String.__oldindex[k] end;
|
|
end;
|
|
end;
|
|
do return nil end;
|
|
else
|
|
do return nil end;
|
|
end;
|
|
end;
|
|
end;
|
|
end
|
|
String.fromCharCode = function(code)
|
|
do return __lua_lib_luautf8_Utf8.char(code) end;
|
|
end
|
|
String.prototype = _hx_a();
|
|
String.prototype.toUpperCase = function(self)
|
|
do return __lua_lib_luautf8_Utf8.upper(self) end
|
|
end
|
|
String.prototype.toLowerCase = function(self)
|
|
do return __lua_lib_luautf8_Utf8.lower(self) end
|
|
end
|
|
String.prototype.indexOf = function(self,str,startIndex)
|
|
if (startIndex == nil) then
|
|
startIndex = 1;
|
|
else
|
|
startIndex = startIndex + 1;
|
|
end;
|
|
local r = __lua_lib_luautf8_Utf8.find(self, str, startIndex, true);
|
|
if ((r ~= nil) and (r > 0)) then
|
|
do return r - 1 end;
|
|
else
|
|
do return -1 end;
|
|
end;
|
|
end
|
|
String.prototype.lastIndexOf = function(self,str,startIndex)
|
|
local i = 0;
|
|
local ret = -1;
|
|
if (startIndex == nil) then
|
|
startIndex = __lua_lib_luautf8_Utf8.len(self);
|
|
end;
|
|
while (true) do
|
|
local startIndex1 = ret + 1;
|
|
if (startIndex1 == nil) then
|
|
startIndex1 = 1;
|
|
else
|
|
startIndex1 = startIndex1 + 1;
|
|
end;
|
|
local r = __lua_lib_luautf8_Utf8.find(self, str, startIndex1, true);
|
|
local p = (function()
|
|
local _hx_1
|
|
if ((r ~= nil) and (r > 0)) then
|
|
_hx_1 = r - 1; else
|
|
_hx_1 = -1; end
|
|
return _hx_1
|
|
end )();
|
|
if ((p == -1) or (p > startIndex)) then
|
|
break;
|
|
end;
|
|
ret = p;
|
|
end;
|
|
do return ret end
|
|
end
|
|
String.prototype.split = function(self,delimiter)
|
|
local idx = 1;
|
|
local ret = _hx_tab_array({}, 0);
|
|
local delim_offset = (function()
|
|
local _hx_1
|
|
if (__lua_lib_luautf8_Utf8.len(delimiter) > 0) then
|
|
_hx_1 = __lua_lib_luautf8_Utf8.len(delimiter); else
|
|
_hx_1 = 1; end
|
|
return _hx_1
|
|
end )();
|
|
while (idx ~= nil) do
|
|
local newidx = 0;
|
|
if (__lua_lib_luautf8_Utf8.len(delimiter) > 0) then
|
|
newidx = __lua_lib_luautf8_Utf8.find(self, delimiter, idx, true);
|
|
else
|
|
if (idx >= __lua_lib_luautf8_Utf8.len(self)) then
|
|
newidx = nil;
|
|
else
|
|
newidx = idx + 1;
|
|
end;
|
|
end;
|
|
if (newidx ~= nil) then
|
|
local match = __lua_lib_luautf8_Utf8.sub(self, idx, newidx - 1);
|
|
ret:push(match);
|
|
idx = newidx + __lua_lib_luautf8_Utf8.len(delimiter);
|
|
else
|
|
ret:push(__lua_lib_luautf8_Utf8.sub(self, idx, __lua_lib_luautf8_Utf8.len(self)));
|
|
idx = nil;
|
|
end;
|
|
end;
|
|
do return ret end
|
|
end
|
|
String.prototype.toString = function(self)
|
|
do return self end
|
|
end
|
|
String.prototype.substring = function(self,startIndex,endIndex)
|
|
if (endIndex == nil) then
|
|
endIndex = __lua_lib_luautf8_Utf8.len(self);
|
|
end;
|
|
if (endIndex < 0) then
|
|
endIndex = 0;
|
|
end;
|
|
if (startIndex < 0) then
|
|
startIndex = 0;
|
|
end;
|
|
if (endIndex < startIndex) then
|
|
do return __lua_lib_luautf8_Utf8.sub(self, endIndex + 1, startIndex) end;
|
|
else
|
|
do return __lua_lib_luautf8_Utf8.sub(self, startIndex + 1, endIndex) end;
|
|
end;
|
|
end
|
|
String.prototype.charAt = function(self,index)
|
|
do return __lua_lib_luautf8_Utf8.sub(self, index + 1, index + 1) end
|
|
end
|
|
String.prototype.charCodeAt = function(self,index)
|
|
do return __lua_lib_luautf8_Utf8.byte(self, index + 1) end
|
|
end
|
|
String.prototype.substr = function(self,pos,len)
|
|
if ((len == nil) or (len > (pos + __lua_lib_luautf8_Utf8.len(self)))) then
|
|
len = __lua_lib_luautf8_Utf8.len(self);
|
|
else
|
|
if (len < 0) then
|
|
len = __lua_lib_luautf8_Utf8.len(self) + len;
|
|
end;
|
|
end;
|
|
if (pos < 0) then
|
|
pos = __lua_lib_luautf8_Utf8.len(self) + pos;
|
|
end;
|
|
if (pos < 0) then
|
|
pos = 0;
|
|
end;
|
|
do return __lua_lib_luautf8_Utf8.sub(self, pos + 1, pos + len) end
|
|
end
|
|
|
|
Std.new = {}
|
|
Std.string = function(s)
|
|
do return __lua_Boot.__string_rec(s) end;
|
|
end
|
|
Std.int = function(x)
|
|
if (not Math.isFinite(x) or Math.isNaN(x)) then
|
|
do return 0 end;
|
|
else
|
|
do return _hx_bit_clamp(x) end;
|
|
end;
|
|
end
|
|
|
|
__haxe_Log.new = {}
|
|
__haxe_Log.formatOutput = function(v,infos)
|
|
local str = Std.string(v);
|
|
if (infos == nil) then
|
|
do return str end;
|
|
end;
|
|
local pstr = Std.string(Std.string(infos.fileName) .. Std.string(":")) .. Std.string(infos.lineNumber);
|
|
if (infos.customParams ~= nil) then
|
|
local _g = 0;
|
|
local _g1 = infos.customParams;
|
|
while (_g < _g1.length) do
|
|
local v1 = _g1[_g];
|
|
_g = _g + 1;
|
|
str = Std.string(str) .. Std.string((Std.string(", ") .. Std.string(Std.string(v1))));
|
|
end;
|
|
end;
|
|
do return Std.string(Std.string(pstr) .. Std.string(": ")) .. Std.string(str) end;
|
|
end
|
|
__haxe_Log.trace = function(v,infos)
|
|
local str = __haxe_Log.formatOutput(v, infos);
|
|
_hx_print(str);
|
|
end
|
|
|
|
__lua_Boot.new = {}
|
|
__lua_Boot.isArray = function(o)
|
|
if (_G.type(o) == "table") then
|
|
if ((o.__enum__ == nil) and (_G.getmetatable(o) ~= nil)) then
|
|
do return _G.getmetatable(o).__index == Array.prototype end;
|
|
else
|
|
do return false end;
|
|
end;
|
|
else
|
|
do return false end;
|
|
end;
|
|
end
|
|
__lua_Boot.printEnum = function(o,s)
|
|
if (o.length == 2) then
|
|
do return o[0] end;
|
|
else
|
|
local str = Std.string(Std.string(o[0])) .. Std.string("(");
|
|
s = Std.string(s) .. Std.string("\t");
|
|
local _g = 2;
|
|
local _g1 = o.length;
|
|
while (_g < _g1) do
|
|
_g = _g + 1;
|
|
local i = _g - 1;
|
|
if (i ~= 2) then
|
|
str = Std.string(str) .. Std.string((Std.string(",") .. Std.string(__lua_Boot.__string_rec(o[i], s))));
|
|
else
|
|
str = Std.string(str) .. Std.string(__lua_Boot.__string_rec(o[i], s));
|
|
end;
|
|
end;
|
|
do return Std.string(str) .. Std.string(")") end;
|
|
end;
|
|
end
|
|
__lua_Boot.printClassRec = function(c,result,s)
|
|
if (result == nil) then
|
|
result = "";
|
|
end;
|
|
local f = __lua_Boot.__string_rec;
|
|
for k,v in pairs(c) do if result ~= '' then result = result .. ', ' end result = result .. k .. ':' .. f(v, s.. ' ') end;
|
|
do return result end;
|
|
end
|
|
__lua_Boot.__string_rec = function(o,s)
|
|
if (s == nil) then
|
|
s = "";
|
|
end;
|
|
if (__lua_lib_luautf8_Utf8.len(s) >= 5) then
|
|
do return "<...>" end;
|
|
end;
|
|
local _g = type(o);
|
|
if (_g) == "boolean" then
|
|
do return tostring(o) end;
|
|
elseif (_g) == "function" then
|
|
do return "<function>" end;
|
|
elseif (_g) == "nil" then
|
|
do return "null" end;
|
|
elseif (_g) == "number" then
|
|
if (o == _G.math.huge) then
|
|
do return "Infinity" end;
|
|
else
|
|
if (o == -_G.math.huge) then
|
|
do return "-Infinity" end;
|
|
else
|
|
if (o == 0) then
|
|
do return "0" end;
|
|
else
|
|
if (o ~= o) then
|
|
do return "NaN" end;
|
|
else
|
|
do return tostring(o) end;
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
elseif (_g) == "string" then
|
|
do return o end;
|
|
elseif (_g) == "table" then
|
|
if (o.__enum__ ~= nil) then
|
|
do return __lua_Boot.printEnum(o, s) end;
|
|
else
|
|
if ((_hx_wrap_if_string_field(o,'toString') ~= nil) and not __lua_Boot.isArray(o)) then
|
|
do return _hx_wrap_if_string_field(o,'toString')(o) end;
|
|
else
|
|
if (__lua_Boot.isArray(o)) then
|
|
local o2 = o;
|
|
if (__lua_lib_luautf8_Utf8.len(s) > 5) then
|
|
do return "[...]" end;
|
|
else
|
|
local _g1 = _hx_tab_array({}, 0);
|
|
local _g11 = 0;
|
|
while (_g11 < o2.length) do
|
|
local i = o2[_g11];
|
|
_g11 = _g11 + 1;
|
|
_g1:push(__lua_Boot.__string_rec(i, Std.string(s) .. Std.string(1)));
|
|
end;
|
|
do return Std.string(Std.string("[") .. Std.string(_g1:join(","))) .. Std.string("]") end;
|
|
end;
|
|
else
|
|
if (o.__class__ ~= nil) then
|
|
do return Std.string(Std.string("{") .. Std.string(__lua_Boot.printClassRec(o, "", Std.string(s) .. Std.string("\t")))) .. Std.string("}") end;
|
|
else
|
|
local fields = __lua_Boot.fieldIterator(o);
|
|
local buffer = ({});
|
|
local first = true;
|
|
_G.table.insert(buffer, "{ ");
|
|
local f = fields;
|
|
while (f:hasNext()) do
|
|
local f1 = f:next();
|
|
if (first) then
|
|
first = false;
|
|
else
|
|
_G.table.insert(buffer, ", ");
|
|
end;
|
|
_G.table.insert(buffer, Std.string(Std.string(Std.string("") .. Std.string(Std.string(f1))) .. Std.string(" : ")) .. Std.string(__lua_Boot.__string_rec(o[f1], Std.string(s) .. Std.string("\t"))));
|
|
end;
|
|
_G.table.insert(buffer, " }");
|
|
do return _G.table.concat(buffer, "") end;
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
elseif (_g) == "thread" then
|
|
do return "<thread>" end;
|
|
elseif (_g) == "userdata" then
|
|
local mt = _G.getmetatable(o);
|
|
if ((mt ~= nil) and (mt.__tostring ~= nil)) then
|
|
do return _G.tostring(o) end;
|
|
else
|
|
do return "<userdata>" end;
|
|
end;else
|
|
_G.error("Unknown Lua type",0); end;
|
|
end
|
|
__lua_Boot.fieldIterator = function(o)
|
|
if (_G.type(o) ~= "table") then
|
|
do return _hx_o({__fields__={next=true,hasNext=true},next=function(self)
|
|
do return nil end;
|
|
end,hasNext=function(self)
|
|
do return false end;
|
|
end}) end;
|
|
end;
|
|
local tbl = (function()
|
|
local _hx_1
|
|
if (o.__fields__ ~= nil) then
|
|
_hx_1 = o.__fields__; else
|
|
_hx_1 = o; end
|
|
return _hx_1
|
|
end )();
|
|
local cur = _G.pairs(tbl);
|
|
local next_valid = function(tbl1,val)
|
|
while (__lua_Boot.hiddenFields[val] ~= nil) do
|
|
val = cur(tbl1, val);
|
|
end;
|
|
do return val end;
|
|
end;
|
|
local cur_val = next_valid(tbl, cur(tbl, nil));
|
|
do return _hx_o({__fields__={next=true,hasNext=true},next=function(self)
|
|
local ret = cur_val;
|
|
cur_val = next_valid(tbl, cur(tbl, cur_val));
|
|
do return ret end;
|
|
end,hasNext=function(self)
|
|
do return cur_val ~= nil end;
|
|
end}) end;
|
|
end
|
|
_hx_bit_clamp = function(v)
|
|
if v <= 2147483647 and v >= -2147483648 then
|
|
if v > 0 then return _G.math.floor(v)
|
|
else return _G.math.ceil(v)
|
|
end
|
|
end
|
|
if v > 2251798999999999 then v = v*2 end;
|
|
if (v ~= v or math.abs(v) == _G.math.huge) then return nil end
|
|
return _hx_bit.band(v, 2147483647 ) - math.abs(_hx_bit.band(v, 2147483648))
|
|
end
|
|
|
|
-- require this for lua 5.1
|
|
pcall(require, 'bit')
|
|
if bit then
|
|
_hx_bit = bit
|
|
else
|
|
local _hx_bit_raw = _G.require('bit32')
|
|
_hx_bit = setmetatable({}, { __index = _hx_bit_raw });
|
|
-- lua 5.2 weirdness
|
|
_hx_bit.bnot = function(...) return _hx_bit_clamp(_hx_bit_raw.bnot(...)) end;
|
|
_hx_bit.bxor = function(...) return _hx_bit_clamp(_hx_bit_raw.bxor(...)) end;
|
|
end
|
|
|
|
_hx_array_mt.__index = Array.prototype
|
|
|
|
local _hx_static_init = function()
|
|
__lua_Boot.hiddenFields = {__id__=true, hx__closures=true, super=true, prototype=true, __fields__=true, __ifields__=true, __class__=true, __properties__=true}
|
|
|
|
|
|
end
|
|
|
|
_hx_print = print or (function() end)
|
|
|
|
_hx_wrap_if_string_field = function(o, fld)
|
|
if _G.type(o) == 'string' then
|
|
if fld == 'length' then
|
|
return _G.string.len(o)
|
|
else
|
|
return String.prototype[fld]
|
|
end
|
|
else
|
|
return o[fld]
|
|
end
|
|
end
|
|
|
|
_hx_static_init();
|
|
Main.main()
|
|
|