3161 lines
96 KiB
Lua
3161 lines
96 KiB
Lua
-- Generated by Haxe 4.3.6
|
|
local _hx_hidden = {__id__=true, hx__closures=true, super=true, prototype=true, __fields__=true, __ifields__=true, __class__=true, __properties__=true, __fields__=true, __name__=true}
|
|
|
|
_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
|
|
}
|
|
|
|
function _hx_is_array(o)
|
|
return type(o) == "table"
|
|
and o.__enum__ == nil
|
|
and getmetatable(o) == _hx_array_mt
|
|
end
|
|
|
|
|
|
|
|
function _hx_tab_array(tab, length)
|
|
tab.length = length
|
|
return setmetatable(tab, _hx_array_mt)
|
|
end
|
|
|
|
|
|
|
|
function _hx_print_class(obj, depth)
|
|
local first = true
|
|
local result = ''
|
|
for k,v in pairs(obj) do
|
|
if _hx_hidden[k] == nil then
|
|
if first then
|
|
first = false
|
|
else
|
|
result = result .. ', '
|
|
end
|
|
if _hx_hidden[k] == nil then
|
|
result = result .. k .. ':' .. _hx_tostring(v, depth+1)
|
|
end
|
|
end
|
|
end
|
|
return '{ ' .. result .. ' }'
|
|
end
|
|
|
|
function _hx_print_enum(o, depth)
|
|
if o.length == 2 then
|
|
return o[0]
|
|
else
|
|
local str = o[0] .. "("
|
|
for i = 2, (o.length-1) do
|
|
if i ~= 2 then
|
|
str = str .. "," .. _hx_tostring(o[i], depth+1)
|
|
else
|
|
str = str .. _hx_tostring(o[i], depth+1)
|
|
end
|
|
end
|
|
return str .. ")"
|
|
end
|
|
end
|
|
|
|
function _hx_tostring(obj, depth)
|
|
if depth == nil then
|
|
depth = 0
|
|
elseif depth > 5 then
|
|
return "<...>"
|
|
end
|
|
|
|
local tstr = _G.type(obj)
|
|
if tstr == "string" then return obj
|
|
elseif tstr == "nil" then return "null"
|
|
elseif tstr == "number" then
|
|
if obj == _G.math.POSITIVE_INFINITY then return "Infinity"
|
|
elseif obj == _G.math.NEGATIVE_INFINITY then return "-Infinity"
|
|
elseif obj == 0 then return "0"
|
|
elseif obj ~= obj then return "NaN"
|
|
else return _G.tostring(obj)
|
|
end
|
|
elseif tstr == "boolean" then return _G.tostring(obj)
|
|
elseif tstr == "userdata" then
|
|
local mt = _G.getmetatable(obj)
|
|
if mt ~= nil and mt.__tostring ~= nil then
|
|
return _G.tostring(obj)
|
|
else
|
|
return "<userdata>"
|
|
end
|
|
elseif tstr == "function" then return "<function>"
|
|
elseif tstr == "thread" then return "<thread>"
|
|
elseif tstr == "table" then
|
|
if obj.__enum__ ~= nil then
|
|
return _hx_print_enum(obj, depth)
|
|
elseif obj.toString ~= nil and not _hx_is_array(obj) then return obj:toString()
|
|
elseif _hx_is_array(obj) then
|
|
if obj.length > 5 then
|
|
return "[...]"
|
|
else
|
|
local str = ""
|
|
for i=0, (obj.length-1) do
|
|
if i == 0 then
|
|
str = str .. _hx_tostring(obj[i], depth+1)
|
|
else
|
|
str = str .. "," .. _hx_tostring(obj[i], depth+1)
|
|
end
|
|
end
|
|
return "[" .. str .. "]"
|
|
end
|
|
elseif obj.__class__ ~= nil then
|
|
return _hx_print_class(obj, depth)
|
|
else
|
|
local buffer = {}
|
|
local ref = obj
|
|
if obj.__fields__ ~= nil then
|
|
ref = obj.__fields__
|
|
end
|
|
for k,v in pairs(ref) do
|
|
if _hx_hidden[k] == nil then
|
|
_G.table.insert(buffer, _hx_tostring(k, depth+1) .. ' : ' .. _hx_tostring(obj[k], depth+1))
|
|
end
|
|
end
|
|
|
|
return "{ " .. table.concat(buffer, ", ") .. " }"
|
|
end
|
|
else
|
|
_G.error("Unknown Lua type", 0)
|
|
return ""
|
|
end
|
|
end
|
|
|
|
local function _hx_obj_newindex(t,k,v)
|
|
t.__fields__[k] = true
|
|
rawset(t,k,v)
|
|
end
|
|
|
|
local _hx_obj_mt = {__newindex=_hx_obj_newindex, __tostring=_hx_tostring}
|
|
|
|
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_obj_mt)
|
|
end
|
|
|
|
local function _hx_e()
|
|
return setmetatable({__fields__ = {}}, _hx_obj_mt)
|
|
end
|
|
|
|
local function _hx_o(obj)
|
|
return setmetatable(obj, _hx_obj_mt)
|
|
end
|
|
|
|
local function _hx_new(prototype)
|
|
return setmetatable({__fields__ = {}}, {__newindex=_hx_obj_newindex, __index=prototype, __tostring=_hx_tostring})
|
|
end
|
|
|
|
function _hx_field_arr(obj)
|
|
local res = {}
|
|
local idx = 0
|
|
if obj.__fields__ ~= nil then
|
|
obj = obj.__fields__
|
|
end
|
|
for k,v in pairs(obj) do
|
|
if _hx_hidden[k] == nil then
|
|
res[idx] = k
|
|
idx = idx + 1
|
|
end
|
|
end
|
|
return _hx_tab_array(res, idx)
|
|
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 _hx_exports = _hx_exports or {}
|
|
_hx_exports["xrfragment"] = _hx_exports["xrfragment"] or _hx_e()
|
|
local Array = _hx_e()
|
|
__lua_lib_lrexlib_Rex = _G.require("rex_pcre2")
|
|
__lua_lib_luautf8_Utf8 = _G.require("lua-utf8")
|
|
local EReg = _hx_e()
|
|
local Math = _hx_e()
|
|
local Reflect = _hx_e()
|
|
local String = _hx_e()
|
|
local Std = _hx_e()
|
|
local StringBuf = _hx_e()
|
|
local StringTools = _hx_e()
|
|
__haxe_IMap = _hx_e()
|
|
__haxe_Exception = _hx_e()
|
|
__haxe_Log = _hx_e()
|
|
__haxe_NativeStackTrace = _hx_e()
|
|
__haxe__Template_TemplateExpr = _hx_e()
|
|
__haxe_iterators_ArrayIterator = _hx_e()
|
|
__haxe_Template = _hx_e()
|
|
__haxe_ValueException = _hx_e()
|
|
__haxe_ds_List = _hx_e()
|
|
__haxe_ds__List_ListNode = _hx_e()
|
|
__haxe_ds_StringMap = _hx_e()
|
|
__haxe_exceptions_PosException = _hx_e()
|
|
__haxe_exceptions_NotImplementedException = _hx_e()
|
|
__haxe_iterators_ArrayKeyValueIterator = _hx_e()
|
|
__lua_Boot = _hx_e()
|
|
__lua_UserData = _hx_e()
|
|
__lua_Lib = _hx_e()
|
|
__lua_Thread = _hx_e()
|
|
__xrfragment_Filter = _hx_e()
|
|
__xrfragment_Parser = _hx_e()
|
|
__xrfragment_URI = _hx_e()
|
|
__xrfragment_XRF = _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.__name__ = true
|
|
Array.prototype = _hx_e();
|
|
Array.prototype.concat = function(self,a)
|
|
local _g = _hx_tab_array({}, 0);
|
|
local _g1 = 0;
|
|
local _g2 = self;
|
|
while (_g1 < _g2.length) do _hx_do_first_1 = false;
|
|
|
|
local i = _g2[_g1];
|
|
_g1 = _g1 + 1;
|
|
_g:push(i);
|
|
end;
|
|
local ret = _g;
|
|
local _g = 0;
|
|
while (_g < a.length) do _hx_do_first_1 = false;
|
|
|
|
local i = a[_g];
|
|
_g = _g + 1;
|
|
ret:push(i);
|
|
end;
|
|
do return ret end
|
|
end
|
|
Array.prototype.join = function(self,sep)
|
|
local tbl = ({});
|
|
local _g_current = 0;
|
|
local _g_array = self;
|
|
while (_g_current < _g_array.length) do _hx_do_first_1 = false;
|
|
|
|
_g_current = _g_current + 1;
|
|
local i = _g_array[_g_current - 1];
|
|
_G.table.insert(tbl, Std.string(i));
|
|
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 _hx_do_first_1 = false;
|
|
|
|
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 _hx_do_first_1 = false;
|
|
|
|
_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 _hx_do_first_1 = false;
|
|
|
|
local swap = false;
|
|
local j = 0;
|
|
local max = (l - i) - 1;
|
|
while (j < max) do _hx_do_first_2 = false;
|
|
|
|
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 _hx_do_first_1 = false;
|
|
|
|
_g = _g + 1;
|
|
local i = _g - 1;
|
|
ret:push(self[i]);
|
|
self[i] = self[i + len];
|
|
end;
|
|
local _g = pos + len;
|
|
local _g1 = self.length;
|
|
while (_g < _g1) do _hx_do_first_1 = false;
|
|
|
|
_g = _g + 1;
|
|
local i = _g - 1;
|
|
self[i] = self[i + 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 _hx_do_first_1 = false;
|
|
|
|
_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 _hx_do_first_1 = false;
|
|
|
|
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 _hx_do_first_1 = false;
|
|
|
|
_g = _g + 1;
|
|
local i = _g - 1;
|
|
if (self[i] == x) then
|
|
local _g = i;
|
|
local _g1 = self.length - 1;
|
|
while (_g < _g1) do _hx_do_first_2 = false;
|
|
|
|
_g = _g + 1;
|
|
local j = _g - 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.contains = function(self,x)
|
|
local _g = 0;
|
|
local _g1 = self.length;
|
|
while (_g < _g1) do _hx_do_first_1 = false;
|
|
|
|
_g = _g + 1;
|
|
local i = _g - 1;
|
|
if (self[i] == x) then
|
|
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 _hx_do_first_1 = false;
|
|
|
|
_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 _hx_do_first_1 = false;
|
|
|
|
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 _hx_do_first_1 = false;
|
|
|
|
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 _hx_do_first_1 = false;
|
|
|
|
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 _hx_do_first_1 = false;
|
|
|
|
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)
|
|
do return __haxe_iterators_ArrayIterator.new(self) end
|
|
end
|
|
Array.prototype.keyValueIterator = function(self)
|
|
do return __haxe_iterators_ArrayKeyValueIterator.new(self) 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 _hx_do_first_1 = false;
|
|
|
|
_g = _g + 1;
|
|
local i = _g - 1;
|
|
self[i] = nil;
|
|
end;
|
|
self.length = len;
|
|
end;
|
|
end;
|
|
end
|
|
|
|
Array.prototype.__class__ = Array
|
|
|
|
EReg.new = function(r,opt)
|
|
local self = _hx_new(EReg.prototype)
|
|
EReg.super(self,r,opt)
|
|
return self
|
|
end
|
|
EReg.super = function(self,r,opt)
|
|
local ropt = 0;
|
|
local _g = 0;
|
|
local _g1 = __lua_lib_luautf8_Utf8.len(opt);
|
|
while (_g < _g1) do _hx_do_first_1 = false;
|
|
|
|
_g = _g + 1;
|
|
local i = _g - 1;
|
|
local _g = __lua_lib_luautf8_Utf8.sub(opt, i + 1, i + 1);
|
|
if (_g) == "g" then
|
|
self.global = true;
|
|
elseif (_g) == "i" then
|
|
ropt = _hx_bit.bor(ropt,EReg.FLAGS.CASELESS);
|
|
elseif (_g) == "m" then
|
|
ropt = _hx_bit.bor(ropt,EReg.FLAGS.MULTILINE);
|
|
elseif (_g) == "s" then
|
|
ropt = _hx_bit.bor(ropt,EReg.FLAGS.DOTALL);else end;
|
|
end;
|
|
ropt = _hx_bit.bor(ropt,EReg.FLAGS.UTF);
|
|
ropt = _hx_bit.bor(ropt,EReg.FLAGS.UCP);
|
|
if (self.global == nil) then
|
|
self.global = false;
|
|
end;
|
|
self.r = __lua_lib_lrexlib_Rex.new(r, ropt);
|
|
end
|
|
EReg.__name__ = true
|
|
EReg.prototype = _hx_e();
|
|
EReg.prototype.match = function(self,s)
|
|
if (s == nil) then
|
|
do return false end;
|
|
else
|
|
self.m = _hx_table.pack(self.r:exec(s, 1));
|
|
self.s = s;
|
|
do return self.m[1] ~= nil end;
|
|
end;
|
|
end
|
|
EReg.prototype.matched = function(self,n)
|
|
if ((self.m[1] == nil) or (n < 0)) then
|
|
_G.error(__haxe_Exception.thrown("EReg::matched"),0);
|
|
else
|
|
if (n == 0) then
|
|
local k = _G.string.sub(self.s, self.m[1], self.m[2]);
|
|
do return k end;
|
|
else
|
|
if (__lua_Boot.__instanceof(self.m[3], _G.table)) then
|
|
local mn = 2 * (n - 1);
|
|
if (__lua_Boot.__instanceof(self.m[3][mn + 1], Bool)) then
|
|
do return nil end;
|
|
end;
|
|
do return _G.string.sub(self.s, self.m[3][mn + 1], self.m[3][mn + 2]) end;
|
|
else
|
|
_G.error(__haxe_Exception.thrown("EReg:matched"),0);
|
|
end;
|
|
end;
|
|
end;
|
|
end
|
|
EReg.prototype.matchedLeft = function(self)
|
|
if (self.m[1] == nil) then
|
|
_G.error(__haxe_Exception.thrown("No string matched"),0);
|
|
end;
|
|
do return _G.string.sub(self.s, 1, self.m[1] - 1) end
|
|
end
|
|
EReg.prototype.matchedRight = function(self)
|
|
if (self.m[1] == nil) then
|
|
_G.error(__haxe_Exception.thrown("No string matched"),0);
|
|
end;
|
|
do return _G.string.sub(self.s, self.m[2] + 1) end
|
|
end
|
|
EReg.prototype.matchedPos = function(self)
|
|
local left = self:matchedLeft();
|
|
local matched = self:matched(0);
|
|
if (self.m[1] == nil) then
|
|
_G.error(__haxe_Exception.thrown("No string matched"),0);
|
|
end;
|
|
do return _hx_o({__fields__={pos=true,len=true},pos=__lua_lib_luautf8_Utf8.len(left),len=__lua_lib_luautf8_Utf8.len(matched)}) end
|
|
end
|
|
EReg.prototype.split = function(self,s)
|
|
if (self.global) then
|
|
do return __lua_Lib.fillArray(_hx_wrap_if_string_field(__lua_lib_lrexlib_Rex,'split')(s, self.r)) end;
|
|
else
|
|
local d = "#__delim__#";
|
|
do return __lua_Lib.fillArray(_hx_wrap_if_string_field(__lua_lib_lrexlib_Rex,'split')(self:replace(s, d), d)) end;
|
|
end;
|
|
end
|
|
EReg.prototype.replace = function(self,s,by)
|
|
local chunks = String.prototype.split(by, "$$");
|
|
local _g = _hx_tab_array({}, 0);
|
|
local _g1 = 0;
|
|
while (_g1 < chunks.length) do _hx_do_first_1 = false;
|
|
|
|
local chunk = chunks[_g1];
|
|
_g1 = _g1 + 1;
|
|
_g:push(__lua_lib_lrexlib_Rex.gsub(chunk, "\\$(\\d)", "%%%1", 1));
|
|
end;
|
|
chunks = _g;
|
|
by = chunks:join("$");
|
|
do return __lua_lib_lrexlib_Rex.gsub(s, self.r, by, (function()
|
|
local _hx_1
|
|
if (self.global) then
|
|
_hx_1 = nil; else
|
|
_hx_1 = 1; end
|
|
return _hx_1
|
|
end )()) end
|
|
end
|
|
|
|
EReg.prototype.__class__ = EReg
|
|
|
|
Math.new = {}
|
|
Math.__name__ = true
|
|
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
|
|
|
|
Reflect.new = {}
|
|
Reflect.__name__ = true
|
|
Reflect.field = function(o,field)
|
|
if (_G.type(o) == "string") then
|
|
if (field == "length") then
|
|
do return _hx_wrap_if_string_field(o,'length') end;
|
|
else
|
|
do return String.prototype[field] end;
|
|
end;
|
|
else
|
|
local _hx_status, _hx_result = pcall(function()
|
|
|
|
do return o[field] end;
|
|
return _hx_pcall_default
|
|
end)
|
|
if not _hx_status and _hx_result == "_hx_pcall_break" then
|
|
elseif not _hx_status then
|
|
local _g = _hx_result;
|
|
do return nil end;
|
|
elseif _hx_result ~= _hx_pcall_default then
|
|
return _hx_result
|
|
end;
|
|
end;
|
|
end
|
|
Reflect.getProperty = function(o,field)
|
|
if (o == nil) then
|
|
do return nil end;
|
|
else
|
|
if ((o.__properties__ ~= nil) and (Reflect.field(o, Std.string("get_") .. Std.string(field)) ~= nil)) then
|
|
do return Reflect.callMethod(o,Reflect.field(o, Std.string("get_") .. Std.string(field)),_hx_tab_array({}, 0)) end;
|
|
else
|
|
do return Reflect.field(o, field) end;
|
|
end;
|
|
end;
|
|
end
|
|
Reflect.callMethod = function(o,func,args)
|
|
if ((args == nil) or (args.length == 0)) then
|
|
do return func(o) end;
|
|
else
|
|
local self_arg = false;
|
|
if ((o ~= nil) and (o.__name__ == nil)) then
|
|
self_arg = true;
|
|
end;
|
|
if (self_arg) then
|
|
do return func(o, _hx_table.unpack(args, 0, args.length - 1)) end;
|
|
else
|
|
do return func(_hx_table.unpack(args, 0, args.length - 1)) end;
|
|
end;
|
|
end;
|
|
end
|
|
Reflect.fields = function(o)
|
|
if (_G.type(o) == "string") then
|
|
do return Reflect.fields(String.prototype) end;
|
|
else
|
|
do return _hx_field_arr(o) end;
|
|
end;
|
|
end
|
|
Reflect.isObject = function(v)
|
|
if (v == nil) then
|
|
do return false end;
|
|
end;
|
|
local t = _G.type(v);
|
|
if (not ((t == "string") or ((t == "table") and (v.__enum__ == nil)))) then
|
|
if (t == "function") then
|
|
do return ((function()
|
|
local _hx_1
|
|
if (_G.type(v) ~= "table") then
|
|
_hx_1 = false; else
|
|
_hx_1 = v.__name__; end
|
|
return _hx_1
|
|
end )() or (function()
|
|
local _hx_2
|
|
if (_G.type(v) ~= "table") then
|
|
_hx_2 = false; else
|
|
_hx_2 = v.__ename__; end
|
|
return _hx_2
|
|
end )()) ~= nil end;
|
|
else
|
|
do return false end;
|
|
end;
|
|
else
|
|
do return true end;
|
|
end;
|
|
end
|
|
Reflect.deleteField = function(o,field)
|
|
if (not ((function()
|
|
local _hx_1
|
|
if ((_G.type(o) == "function") and not ((function()
|
|
local _hx_2
|
|
if (_G.type(o) ~= "table") then
|
|
_hx_2 = false; else
|
|
_hx_2 = o.__name__; end
|
|
return _hx_2
|
|
end )() or (function()
|
|
local _hx_3
|
|
if (_G.type(o) ~= "table") then
|
|
_hx_3 = false; else
|
|
_hx_3 = o.__ename__; end
|
|
return _hx_3
|
|
end )())) then
|
|
_hx_1 = false; elseif ((_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 false end;
|
|
end;
|
|
o[field] = nil;
|
|
o.__fields__[field] = nil;
|
|
do return true end;
|
|
end
|
|
Reflect.copy = function(o)
|
|
if (o == nil) then
|
|
do return nil end;
|
|
end;
|
|
local o2 = _hx_e();
|
|
local _g = 0;
|
|
local _g1 = Reflect.fields(o);
|
|
while (_g < _g1.length) do _hx_do_first_1 = false;
|
|
|
|
local f = _g1[_g];
|
|
_g = _g + 1;
|
|
o2[f] = Reflect.field(o, f);
|
|
end;
|
|
do return o2 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.__name__ = true
|
|
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) == "function") and not ((function()
|
|
local _hx_2
|
|
if (_G.type(o) ~= "table") then
|
|
_hx_2 = false; else
|
|
_hx_2 = o.__name__; end
|
|
return _hx_2
|
|
end )() or (function()
|
|
local _hx_3
|
|
if (_G.type(o) ~= "table") then
|
|
_hx_3 = false; else
|
|
_hx_3 = o.__ename__; end
|
|
return _hx_3
|
|
end )())) then
|
|
_hx_1 = false; elseif ((_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.indexOfEmpty = function(s,startIndex)
|
|
local length = __lua_lib_luautf8_Utf8.len(s);
|
|
if (startIndex < 0) then
|
|
startIndex = length + startIndex;
|
|
if (startIndex < 0) then
|
|
startIndex = 0;
|
|
end;
|
|
end;
|
|
if (startIndex > length) then
|
|
do return length end;
|
|
else
|
|
do return startIndex end;
|
|
end;
|
|
end
|
|
String.fromCharCode = function(code)
|
|
do return __lua_lib_luautf8_Utf8.char(code) end;
|
|
end
|
|
String.prototype = _hx_e();
|
|
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;
|
|
if (str == "") then
|
|
do return String.indexOfEmpty(self, startIndex - 1) end;
|
|
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 ret = -1;
|
|
if (startIndex == nil) then
|
|
startIndex = __lua_lib_luautf8_Utf8.len(self);
|
|
end;
|
|
while (true) do _hx_do_first_1 = false;
|
|
|
|
local p = String.prototype.indexOf(self, str, ret + 1);
|
|
if (((p == -1) or (p > startIndex)) or (p == ret)) 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);
|
|
while (idx ~= nil) do _hx_do_first_1 = false;
|
|
|
|
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
|
|
|
|
String.prototype.__class__ = String
|
|
|
|
Std.new = {}
|
|
Std.__name__ = true
|
|
Std.string = function(s)
|
|
do return _hx_tostring(s, 0) 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
|
|
Std.parseInt = function(x)
|
|
if (x == nil) then
|
|
do return nil end;
|
|
end;
|
|
local sign, numString = _G.string.match(x, "^%s*([%-+]?)0[xX]([%da-fA-F]*)");
|
|
if (numString ~= nil) then
|
|
if (sign == "-") then
|
|
do return -_G.tonumber(numString, 16) end;
|
|
else
|
|
do return _G.tonumber(numString, 16) end;
|
|
end;
|
|
end;
|
|
local intMatch = _G.string.match(x, "^%s*[%-+]?%d*");
|
|
if (intMatch == nil) then
|
|
do return nil end;
|
|
end;
|
|
do return _G.tonumber(intMatch) end;
|
|
end
|
|
Std.parseFloat = function(x)
|
|
if ((x == nil) or (x == "")) then
|
|
do return (0/0) end;
|
|
end;
|
|
local digitMatch = _G.string.match(x, "^%s*[%.%-+]?[0-9]%d*");
|
|
if (digitMatch == nil) then
|
|
do return (0/0) end;
|
|
end;
|
|
x = String.prototype.substr(x, __lua_lib_luautf8_Utf8.len(digitMatch));
|
|
local decimalMatch = _G.string.match(x, "^%.%d*");
|
|
if (decimalMatch == nil) then
|
|
decimalMatch = "";
|
|
end;
|
|
x = String.prototype.substr(x, __lua_lib_luautf8_Utf8.len(decimalMatch));
|
|
local eMatch = _G.string.match(x, "^[eE][+%-]?%d+");
|
|
if (eMatch == nil) then
|
|
eMatch = "";
|
|
end;
|
|
local result = _G.tonumber(Std.string(Std.string(digitMatch) .. Std.string(decimalMatch)) .. Std.string(eMatch));
|
|
if (result ~= nil) then
|
|
do return result end;
|
|
else
|
|
do return (0/0) end;
|
|
end;
|
|
end
|
|
|
|
StringBuf.new = function()
|
|
local self = _hx_new(StringBuf.prototype)
|
|
StringBuf.super(self)
|
|
return self
|
|
end
|
|
StringBuf.super = function(self)
|
|
self.b = ({});
|
|
self.length = 0;
|
|
end
|
|
StringBuf.__name__ = true
|
|
StringBuf.prototype = _hx_e();
|
|
|
|
StringBuf.prototype.__class__ = StringBuf
|
|
|
|
StringTools.new = {}
|
|
StringTools.__name__ = true
|
|
StringTools.urlDecode = function(s)
|
|
s = _G.string.gsub(s, "+", " ");
|
|
s = _G.string.gsub(s, "%%(%x%x)", function(h)
|
|
do return _G.string.char(_G.tonumber(h, 16)) end;
|
|
end);
|
|
s = _G.string.gsub(s, "\r\n", "\n");
|
|
do return s end;
|
|
end
|
|
StringTools.isSpace = function(s,pos)
|
|
if (((__lua_lib_luautf8_Utf8.len(s) == 0) or (pos < 0)) or (pos >= __lua_lib_luautf8_Utf8.len(s))) then
|
|
do return false end;
|
|
end;
|
|
local c = __lua_lib_luautf8_Utf8.byte(s, pos + 1);
|
|
if (not ((c > 8) and (c < 14))) then
|
|
do return c == 32 end;
|
|
else
|
|
do return true end;
|
|
end;
|
|
end
|
|
StringTools.ltrim = function(s)
|
|
local l = __lua_lib_luautf8_Utf8.len(s);
|
|
local r = 0;
|
|
while ((r < l) and StringTools.isSpace(s, r)) do _hx_do_first_1 = false;
|
|
|
|
r = r + 1;
|
|
end;
|
|
if (r > 0) then
|
|
do return String.prototype.substr(s, r, l - r) end;
|
|
else
|
|
do return s end;
|
|
end;
|
|
end
|
|
StringTools.rtrim = function(s)
|
|
local l = __lua_lib_luautf8_Utf8.len(s);
|
|
local r = 0;
|
|
while ((r < l) and StringTools.isSpace(s, (l - r) - 1)) do _hx_do_first_1 = false;
|
|
|
|
r = r + 1;
|
|
end;
|
|
if (r > 0) then
|
|
do return String.prototype.substr(s, 0, l - r) end;
|
|
else
|
|
do return s end;
|
|
end;
|
|
end
|
|
StringTools.trim = function(s)
|
|
do return StringTools.ltrim(StringTools.rtrim(s)) end;
|
|
end
|
|
StringTools.replace = function(s,sub,by)
|
|
do return String.prototype.split(s, sub):join(by) end;
|
|
end
|
|
|
|
__haxe_IMap.new = {}
|
|
__haxe_IMap.__name__ = true
|
|
|
|
__haxe_Exception.new = function(message,previous,native)
|
|
local self = _hx_new(__haxe_Exception.prototype)
|
|
__haxe_Exception.super(self,message,previous,native)
|
|
return self
|
|
end
|
|
__haxe_Exception.super = function(self,message,previous,native)
|
|
self.__skipStack = 0;
|
|
self.__exceptionMessage = message;
|
|
self.__previousException = previous;
|
|
if (native ~= nil) then
|
|
self.__nativeException = native;
|
|
self.__nativeStack = __haxe_NativeStackTrace.exceptionStack();
|
|
else
|
|
self.__nativeException = self;
|
|
self.__nativeStack = __haxe_NativeStackTrace.callStack();
|
|
self.__skipStack = 1;
|
|
end;
|
|
end
|
|
__haxe_Exception.__name__ = true
|
|
__haxe_Exception.caught = function(value)
|
|
if (__lua_Boot.__instanceof(value, __haxe_Exception)) then
|
|
do return value end;
|
|
else
|
|
do return __haxe_ValueException.new(value, nil, value) end;
|
|
end;
|
|
end
|
|
__haxe_Exception.thrown = function(value)
|
|
if (__lua_Boot.__instanceof(value, __haxe_Exception)) then
|
|
do return value:get_native() end;
|
|
else
|
|
local e = __haxe_ValueException.new(value);
|
|
e.__skipStack = e.__skipStack + 1;
|
|
do return e end;
|
|
end;
|
|
end
|
|
__haxe_Exception.prototype = _hx_e();
|
|
__haxe_Exception.prototype.unwrap = function(self)
|
|
do return self.__nativeException end
|
|
end
|
|
__haxe_Exception.prototype.toString = function(self)
|
|
do return self:get_message() end
|
|
end
|
|
__haxe_Exception.prototype.get_message = function(self)
|
|
do return self.__exceptionMessage end
|
|
end
|
|
__haxe_Exception.prototype.get_native = function(self)
|
|
do return self.__nativeException end
|
|
end
|
|
|
|
__haxe_Exception.prototype.__class__ = __haxe_Exception
|
|
|
|
__haxe_Exception.prototype.__properties__ = {get_native="get_native",get_message="get_message"}
|
|
|
|
__haxe_Log.new = {}
|
|
__haxe_Log.__name__ = true
|
|
__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 _hx_do_first_1 = false;
|
|
|
|
local v = _g1[_g];
|
|
_g = _g + 1;
|
|
str = Std.string(str) .. Std.string((Std.string(", ") .. Std.string(Std.string(v))));
|
|
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
|
|
|
|
__haxe_NativeStackTrace.new = {}
|
|
__haxe_NativeStackTrace.__name__ = true
|
|
__haxe_NativeStackTrace.saveStack = function(exception)
|
|
end
|
|
__haxe_NativeStackTrace.callStack = function()
|
|
local _g = debug.traceback();
|
|
if (_g == nil) then
|
|
do return _hx_tab_array({}, 0) end;
|
|
else
|
|
local s = _g;
|
|
do return String.prototype.split(s, "\n"):slice(3) end;
|
|
end;
|
|
end
|
|
__haxe_NativeStackTrace.exceptionStack = function()
|
|
do return _hx_tab_array({}, 0) end;
|
|
end
|
|
_hxClasses["haxe._Template.TemplateExpr"] = { __ename__ = true, __constructs__ = _hx_tab_array({[0]="OpVar","OpExpr","OpIf","OpStr","OpBlock","OpForeach","OpMacro"},7)}
|
|
__haxe__Template_TemplateExpr = _hxClasses["haxe._Template.TemplateExpr"];
|
|
__haxe__Template_TemplateExpr.OpVar = function(v) local _x = _hx_tab_array({[0]="OpVar",0,v,__enum__=__haxe__Template_TemplateExpr}, 3); return _x; end
|
|
__haxe__Template_TemplateExpr.OpExpr = function(expr) local _x = _hx_tab_array({[0]="OpExpr",1,expr,__enum__=__haxe__Template_TemplateExpr}, 3); return _x; end
|
|
__haxe__Template_TemplateExpr.OpIf = function(expr,eif,eelse) local _x = _hx_tab_array({[0]="OpIf",2,expr,eif,eelse,__enum__=__haxe__Template_TemplateExpr}, 5); return _x; end
|
|
__haxe__Template_TemplateExpr.OpStr = function(str) local _x = _hx_tab_array({[0]="OpStr",3,str,__enum__=__haxe__Template_TemplateExpr}, 3); return _x; end
|
|
__haxe__Template_TemplateExpr.OpBlock = function(l) local _x = _hx_tab_array({[0]="OpBlock",4,l,__enum__=__haxe__Template_TemplateExpr}, 3); return _x; end
|
|
__haxe__Template_TemplateExpr.OpForeach = function(expr,loop) local _x = _hx_tab_array({[0]="OpForeach",5,expr,loop,__enum__=__haxe__Template_TemplateExpr}, 4); return _x; end
|
|
__haxe__Template_TemplateExpr.OpMacro = function(name,params) local _x = _hx_tab_array({[0]="OpMacro",6,name,params,__enum__=__haxe__Template_TemplateExpr}, 4); return _x; end
|
|
|
|
__haxe_iterators_ArrayIterator.new = function(array)
|
|
local self = _hx_new(__haxe_iterators_ArrayIterator.prototype)
|
|
__haxe_iterators_ArrayIterator.super(self,array)
|
|
return self
|
|
end
|
|
__haxe_iterators_ArrayIterator.super = function(self,array)
|
|
self.current = 0;
|
|
self.array = array;
|
|
end
|
|
__haxe_iterators_ArrayIterator.__name__ = true
|
|
__haxe_iterators_ArrayIterator.prototype = _hx_e();
|
|
__haxe_iterators_ArrayIterator.prototype.hasNext = function(self)
|
|
do return self.current < self.array.length end
|
|
end
|
|
__haxe_iterators_ArrayIterator.prototype.next = function(self)
|
|
do return self.array[(function()
|
|
local _hx_obj = self;
|
|
local _hx_fld = 'current';
|
|
local _ = _hx_obj[_hx_fld];
|
|
_hx_obj[_hx_fld] = _hx_obj[_hx_fld] + 1;
|
|
return _;
|
|
end)()] end
|
|
end
|
|
|
|
__haxe_iterators_ArrayIterator.prototype.__class__ = __haxe_iterators_ArrayIterator
|
|
|
|
__haxe_Template.new = function(str)
|
|
local self = _hx_new(__haxe_Template.prototype)
|
|
__haxe_Template.super(self,str)
|
|
return self
|
|
end
|
|
__haxe_Template.super = function(self,str)
|
|
local tokens = self:parseTokens(str);
|
|
self.expr = self:parseBlock(tokens);
|
|
if (not tokens:isEmpty()) then
|
|
_G.error(__haxe_Exception.thrown(Std.string(Std.string("Unexpected '") .. Std.string(Std.string(tokens:first().s))) .. Std.string("'")),0);
|
|
end;
|
|
end
|
|
__haxe_Template.__name__ = true
|
|
__haxe_Template.prototype = _hx_e();
|
|
__haxe_Template.prototype.execute = function(self,context,macros)
|
|
self.macros = (function()
|
|
local _hx_1
|
|
if (macros == nil) then
|
|
_hx_1 = _hx_e(); else
|
|
_hx_1 = macros; end
|
|
return _hx_1
|
|
end )();
|
|
self.context = context;
|
|
self.stack = __haxe_ds_List.new();
|
|
self.buf = StringBuf.new();
|
|
self:run(self.expr);
|
|
do return _G.table.concat(self.buf.b) end
|
|
end
|
|
__haxe_Template.prototype.resolve = function(self,v)
|
|
if (v == "__current__") then
|
|
do return self.context end;
|
|
end;
|
|
if (Reflect.isObject(self.context)) then
|
|
local value = Reflect.getProperty(self.context, v);
|
|
local tmp;
|
|
if (value == nil) then
|
|
local o = self.context;
|
|
tmp = (function()
|
|
local _hx_1
|
|
if ((_G.type(o) == "function") and not ((function()
|
|
local _hx_2
|
|
if (_G.type(o) ~= "table") then
|
|
_hx_2 = false; else
|
|
_hx_2 = o.__name__; end
|
|
return _hx_2
|
|
end )() or (function()
|
|
local _hx_3
|
|
if (_G.type(o) ~= "table") then
|
|
_hx_3 = false; else
|
|
_hx_3 = o.__ename__; end
|
|
return _hx_3
|
|
end )())) then
|
|
_hx_1 = false; elseif ((_G.type(o) == "string") and ((String.prototype[v] ~= nil) or (v == "length"))) then
|
|
_hx_1 = true; elseif (o.__fields__ ~= nil) then
|
|
_hx_1 = o.__fields__[v] ~= nil; else
|
|
_hx_1 = o[v] ~= nil; end
|
|
return _hx_1
|
|
end )();
|
|
else
|
|
tmp = true;
|
|
end;
|
|
if (tmp) then
|
|
do return value end;
|
|
end;
|
|
end;
|
|
local _g_head = self.stack.h;
|
|
while (_g_head ~= nil) do _hx_do_first_1 = false;
|
|
|
|
local val = _g_head.item;
|
|
_g_head = _g_head.next;
|
|
local ctx = val;
|
|
local value = Reflect.getProperty(ctx, v);
|
|
local tmp;
|
|
if (value == nil) then
|
|
local o = ctx;
|
|
tmp = (function()
|
|
local _hx_4
|
|
if ((_G.type(o) == "function") and not ((function()
|
|
local _hx_5
|
|
if (_G.type(o) ~= "table") then
|
|
_hx_5 = false; else
|
|
_hx_5 = o.__name__; end
|
|
return _hx_5
|
|
end )() or (function()
|
|
local _hx_6
|
|
if (_G.type(o) ~= "table") then
|
|
_hx_6 = false; else
|
|
_hx_6 = o.__ename__; end
|
|
return _hx_6
|
|
end )())) then
|
|
_hx_4 = false; elseif ((_G.type(o) == "string") and ((String.prototype[v] ~= nil) or (v == "length"))) then
|
|
_hx_4 = true; elseif (o.__fields__ ~= nil) then
|
|
_hx_4 = o.__fields__[v] ~= nil; else
|
|
_hx_4 = o[v] ~= nil; end
|
|
return _hx_4
|
|
end )();
|
|
else
|
|
tmp = true;
|
|
end;
|
|
if (tmp) then
|
|
do return value end;
|
|
end;
|
|
end;
|
|
do return Reflect.field(__haxe_Template.globals, v) end
|
|
end
|
|
__haxe_Template.prototype.parseTokens = function(self,data)
|
|
local tokens = __haxe_ds_List.new();
|
|
local _hx_continue_1 = false;
|
|
while (__haxe_Template.splitter:match(data)) do _hx_do_first_1 = false;
|
|
repeat
|
|
local p = __haxe_Template.splitter:matchedPos();
|
|
if (p.pos > 0) then
|
|
tokens:add(_hx_o({__fields__={p=true,s=true,l=true},p=String.prototype.substr(data, 0, p.pos),s=true,l=nil}));
|
|
end;
|
|
if (__lua_lib_luautf8_Utf8.byte(data, p.pos + 1) == 58) then
|
|
tokens:add(_hx_o({__fields__={p=true,s=true,l=true},p=String.prototype.substr(data, p.pos + 2, p.len - 4),s=false,l=nil}));
|
|
data = __haxe_Template.splitter:matchedRight();
|
|
break;
|
|
end;
|
|
local parp = p.pos + p.len;
|
|
local npar = 1;
|
|
local params = _hx_tab_array({}, 0);
|
|
local part = "";
|
|
while (true) do _hx_do_first_2 = false;
|
|
|
|
local c = __lua_lib_luautf8_Utf8.byte(data, parp + 1);
|
|
parp = parp + 1;
|
|
if (c == 40) then
|
|
npar = npar + 1;
|
|
else
|
|
if (c == 41) then
|
|
npar = npar - 1;
|
|
if (npar <= 0) then
|
|
break;
|
|
end;
|
|
else
|
|
if (c == nil) then
|
|
_G.error(__haxe_Exception.thrown("Unclosed macro parenthesis"),0);
|
|
end;
|
|
end;
|
|
end;
|
|
if ((c == 44) and (npar == 1)) then
|
|
params:push(part);
|
|
part = "";
|
|
else
|
|
part = Std.string(part) .. Std.string(__lua_lib_luautf8_Utf8.char(c));
|
|
end;
|
|
end;
|
|
params:push(part);
|
|
tokens:add(_hx_o({__fields__={p=true,s=true,l=true},p=__haxe_Template.splitter:matched(2),s=false,l=params}));
|
|
data = String.prototype.substr(data, parp, __lua_lib_luautf8_Utf8.len(data) - parp);until true
|
|
if _hx_continue_1 then
|
|
_hx_continue_1 = false;
|
|
break;
|
|
end;
|
|
|
|
end;
|
|
if (__lua_lib_luautf8_Utf8.len(data) > 0) then
|
|
tokens:add(_hx_o({__fields__={p=true,s=true,l=true},p=data,s=true,l=nil}));
|
|
end;
|
|
do return tokens end
|
|
end
|
|
__haxe_Template.prototype.parseBlock = function(self,tokens)
|
|
local l = __haxe_ds_List.new();
|
|
while (true) do _hx_do_first_1 = false;
|
|
|
|
local t = tokens:first();
|
|
if (t == nil) then
|
|
break;
|
|
end;
|
|
if (not t.s and (((t.p == "end") or (t.p == "else")) or (String.prototype.substr(t.p, 0, 7) == "elseif "))) then
|
|
break;
|
|
end;
|
|
l:add(self:parse(tokens));
|
|
end;
|
|
if (l.length == 1) then
|
|
do return l:first() end;
|
|
end;
|
|
do return __haxe__Template_TemplateExpr.OpBlock(l) end
|
|
end
|
|
__haxe_Template.prototype.parse = function(self,tokens)
|
|
local t = tokens:pop();
|
|
local p = t.p;
|
|
if (t.s) then
|
|
do return __haxe__Template_TemplateExpr.OpStr(p) end;
|
|
end;
|
|
if (t.l ~= nil) then
|
|
local pe = __haxe_ds_List.new();
|
|
local _g = 0;
|
|
local _g1 = t.l;
|
|
while (_g < _g1.length) do _hx_do_first_1 = false;
|
|
|
|
local p = _g1[_g];
|
|
_g = _g + 1;
|
|
pe:add(self:parseBlock(self:parseTokens(p)));
|
|
end;
|
|
do return __haxe__Template_TemplateExpr.OpMacro(p, pe) end;
|
|
end;
|
|
local kwdEnd = function(kwd)
|
|
local pos = -1;
|
|
local length = __lua_lib_luautf8_Utf8.len(kwd);
|
|
if (String.prototype.substr(p, 0, length) == kwd) then
|
|
pos = length;
|
|
local s = String.prototype.substr(p, length);
|
|
local _g_codes = __lua_lib_luautf8_Utf8.codes(s);
|
|
local _g_str = s;
|
|
local _hx_1_cp_position, _hx_1_cp_codepoint = _g_codes(_g_str, 0);
|
|
local _g_codepoint = _hx_1_cp_codepoint;
|
|
local _g_position = _hx_1_cp_position;
|
|
while (_g_codepoint ~= nil) do _hx_do_first_1 = false;
|
|
|
|
local ret = _g_codepoint;
|
|
local _hx_2_cp_position, _hx_2_cp_codepoint = _g_codes(_g_str, _g_position);
|
|
_g_codepoint = _hx_2_cp_codepoint;
|
|
_g_position = _hx_2_cp_position;
|
|
local c = ret;
|
|
if (c == 32) then
|
|
pos = pos + 1;
|
|
else
|
|
break;
|
|
end;
|
|
end;
|
|
end;
|
|
do return pos end;
|
|
end;
|
|
local pos = kwdEnd("if");
|
|
if (pos > 0) then
|
|
p = String.prototype.substr(p, pos, __lua_lib_luautf8_Utf8.len(p) - pos);
|
|
local e = self:parseExpr(p);
|
|
local eif = self:parseBlock(tokens);
|
|
local t = tokens:first();
|
|
local eelse;
|
|
if (t == nil) then
|
|
_G.error(__haxe_Exception.thrown("Unclosed 'if'"),0);
|
|
end;
|
|
if (t.p == "end") then
|
|
tokens:pop();
|
|
eelse = nil;
|
|
else
|
|
if (t.p == "else") then
|
|
tokens:pop();
|
|
eelse = self:parseBlock(tokens);
|
|
t = tokens:pop();
|
|
if ((t == nil) or (t.p ~= "end")) then
|
|
_G.error(__haxe_Exception.thrown("Unclosed 'else'"),0);
|
|
end;
|
|
else
|
|
t.p = String.prototype.substr(t.p, 4, __lua_lib_luautf8_Utf8.len(t.p) - 4);
|
|
eelse = self:parse(tokens);
|
|
end;
|
|
end;
|
|
do return __haxe__Template_TemplateExpr.OpIf(e, eif, eelse) end;
|
|
end;
|
|
local pos = kwdEnd("foreach");
|
|
if (pos >= 0) then
|
|
p = String.prototype.substr(p, pos, __lua_lib_luautf8_Utf8.len(p) - pos);
|
|
local e = self:parseExpr(p);
|
|
local efor = self:parseBlock(tokens);
|
|
local t = tokens:pop();
|
|
if ((t == nil) or (t.p ~= "end")) then
|
|
_G.error(__haxe_Exception.thrown("Unclosed 'foreach'"),0);
|
|
end;
|
|
do return __haxe__Template_TemplateExpr.OpForeach(e, efor) end;
|
|
end;
|
|
if (__haxe_Template.expr_splitter:match(p)) then
|
|
do return __haxe__Template_TemplateExpr.OpExpr(self:parseExpr(p)) end;
|
|
end;
|
|
do return __haxe__Template_TemplateExpr.OpVar(p) end
|
|
end
|
|
__haxe_Template.prototype.parseExpr = function(self,data)
|
|
local l = __haxe_ds_List.new();
|
|
local expr = data;
|
|
while (__haxe_Template.expr_splitter:match(data)) do _hx_do_first_1 = false;
|
|
|
|
local p = __haxe_Template.expr_splitter:matchedPos();
|
|
local k = p.pos + p.len;
|
|
if (p.pos ~= 0) then
|
|
l:add(_hx_o({__fields__={p=true,s=true},p=String.prototype.substr(data, 0, p.pos),s=true}));
|
|
end;
|
|
local p = __haxe_Template.expr_splitter:matched(0);
|
|
l:add(_hx_o({__fields__={p=true,s=true},p=p,s=String.prototype.indexOf(p, "\"") >= 0}));
|
|
data = __haxe_Template.expr_splitter:matchedRight();
|
|
end;
|
|
if (__lua_lib_luautf8_Utf8.len(data) ~= 0) then
|
|
local _g_offset = 0;
|
|
local _g_s = data;
|
|
while (_g_offset < __lua_lib_luautf8_Utf8.len(_g_s)) do _hx_do_first_1 = false;
|
|
|
|
local _g_key = _g_offset;
|
|
_g_offset = _g_offset + 1;
|
|
local _g_value = __lua_lib_luautf8_Utf8.byte(_g_s, (_g_offset - 1) + 1);
|
|
local i = _g_key;
|
|
local c = _g_value;
|
|
if (c ~= 32) then
|
|
l:add(_hx_o({__fields__={p=true,s=true},p=String.prototype.substr(data, i),s=true}));
|
|
break;
|
|
end;
|
|
end;
|
|
end;
|
|
local e;
|
|
local _hx_status, _hx_result = pcall(function()
|
|
|
|
e = self:makeExpr(l);
|
|
if (not l:isEmpty()) then
|
|
_G.error(__haxe_Exception.thrown(l:first().p),0);
|
|
end;
|
|
return _hx_pcall_default
|
|
end)
|
|
if not _hx_status and _hx_result == "_hx_pcall_break" then
|
|
elseif not _hx_status then
|
|
local _g = _hx_result;
|
|
local _g1 = __haxe_Exception.caught(_g):unwrap();
|
|
if (__lua_Boot.__instanceof(_g1, String)) then
|
|
local s = _g1;
|
|
_G.error(__haxe_Exception.thrown(Std.string(Std.string(Std.string("Unexpected '") .. Std.string(s)) .. Std.string("' in ")) .. Std.string(expr)),0);
|
|
else
|
|
_G.error(_g,0);
|
|
end;
|
|
elseif _hx_result ~= _hx_pcall_default then
|
|
return _hx_result
|
|
end;
|
|
do return function()
|
|
local _hx_status, _hx_result = pcall(function()
|
|
|
|
do return e() end;
|
|
return _hx_pcall_default
|
|
end)
|
|
if not _hx_status and _hx_result == "_hx_pcall_break" then
|
|
elseif not _hx_status then
|
|
local _g = _hx_result;
|
|
local exc = __haxe_Exception.caught(_g):unwrap();
|
|
_G.error(__haxe_Exception.thrown(Std.string(Std.string(Std.string("Error : ") .. Std.string(Std.string(exc))) .. Std.string(" in ")) .. Std.string(expr)),0);
|
|
elseif _hx_result ~= _hx_pcall_default then
|
|
return _hx_result
|
|
end;
|
|
end end
|
|
end
|
|
__haxe_Template.prototype.makeConst = function(self,v)
|
|
__haxe_Template.expr_trim:match(v);
|
|
v = __haxe_Template.expr_trim:matched(1);
|
|
if (__lua_lib_luautf8_Utf8.byte(v, 1) == 34) then
|
|
local str = String.prototype.substr(v, 1, __lua_lib_luautf8_Utf8.len(v) - 2);
|
|
do return function()
|
|
do return str end;
|
|
end end;
|
|
end;
|
|
if (__haxe_Template.expr_int:match(v)) then
|
|
local i = Std.parseInt(v);
|
|
do return function()
|
|
do return i end;
|
|
end end;
|
|
end;
|
|
if (__haxe_Template.expr_float:match(v)) then
|
|
local f = Std.parseFloat(v);
|
|
do return function()
|
|
do return f end;
|
|
end end;
|
|
end;
|
|
local me = self;
|
|
do return function()
|
|
do return me:resolve(v) end;
|
|
end end
|
|
end
|
|
__haxe_Template.prototype.makePath = function(self,e,l)
|
|
local p = l:first();
|
|
if ((p == nil) or (p.p ~= ".")) then
|
|
do return e end;
|
|
end;
|
|
l:pop();
|
|
local field = l:pop();
|
|
if ((field == nil) or not field.s) then
|
|
_G.error(__haxe_Exception.thrown(field.p),0);
|
|
end;
|
|
local f = field.p;
|
|
__haxe_Template.expr_trim:match(f);
|
|
f = __haxe_Template.expr_trim:matched(1);
|
|
do return self:makePath(function()
|
|
do return Reflect.field(e(), f) end;
|
|
end, l) end
|
|
end
|
|
__haxe_Template.prototype.makeExpr = function(self,l)
|
|
do return self:makePath(self:makeExpr2(l), l) end
|
|
end
|
|
__haxe_Template.prototype.skipSpaces = function(self,l)
|
|
local p = l:first();
|
|
while (p ~= nil) do _hx_do_first_1 = false;
|
|
|
|
local s = p.p;
|
|
local _g_codes = __lua_lib_luautf8_Utf8.codes(s);
|
|
local _g_str = s;
|
|
local _hx_1_cp_position, _hx_1_cp_codepoint = _g_codes(_g_str, 0);
|
|
local _g_codepoint = _hx_1_cp_codepoint;
|
|
local _g_position = _hx_1_cp_position;
|
|
while (_g_codepoint ~= nil) do _hx_do_first_2 = false;
|
|
|
|
local ret = _g_codepoint;
|
|
local _hx_2_cp_position, _hx_2_cp_codepoint = _g_codes(_g_str, _g_position);
|
|
_g_codepoint = _hx_2_cp_codepoint;
|
|
_g_position = _hx_2_cp_position;
|
|
local c = ret;
|
|
if (c ~= 32) then
|
|
do return end;
|
|
end;
|
|
end;
|
|
l:pop();
|
|
p = l:first();
|
|
end;
|
|
end
|
|
__haxe_Template.prototype.makeExpr2 = function(self,l)
|
|
self:skipSpaces(l);
|
|
local p = l:pop();
|
|
self:skipSpaces(l);
|
|
if (p == nil) then
|
|
_G.error(__haxe_Exception.thrown("<eof>"),0);
|
|
end;
|
|
if (p.s) then
|
|
do return self:makeConst(p.p) end;
|
|
end;
|
|
local _g = p.p;
|
|
if (_g) == "!" then
|
|
local e = self:makeExpr(l);
|
|
do return function()
|
|
local v = e();
|
|
if (v ~= nil) then
|
|
do return v == false end;
|
|
else
|
|
do return true end;
|
|
end;
|
|
end end;
|
|
elseif (_g) == "(" then
|
|
self:skipSpaces(l);
|
|
local e1 = self:makeExpr(l);
|
|
self:skipSpaces(l);
|
|
local p = l:pop();
|
|
if ((p == nil) or p.s) then
|
|
_G.error(__haxe_Exception.thrown(p),0);
|
|
end;
|
|
if (p.p == ")") then
|
|
do return e1 end;
|
|
end;
|
|
self:skipSpaces(l);
|
|
local e2 = self:makeExpr(l);
|
|
self:skipSpaces(l);
|
|
local p2 = l:pop();
|
|
self:skipSpaces(l);
|
|
if ((p2 == nil) or (p2.p ~= ")")) then
|
|
_G.error(__haxe_Exception.thrown(p2),0);
|
|
end;
|
|
local _g = p.p;
|
|
if (_g) == "!=" then
|
|
do return function()
|
|
do return e1() ~= e2() end;
|
|
end end;
|
|
elseif (_g) == "&&" then
|
|
do return function()
|
|
do return e1() and e2() end;
|
|
end end;
|
|
elseif (_g) == "*" then
|
|
do return function()
|
|
do return e1() * e2() end;
|
|
end end;
|
|
elseif (_g) == "+" then
|
|
do return function()
|
|
do return _hx_dyn_add(e1(),e2()) end;
|
|
end end;
|
|
elseif (_g) == "-" then
|
|
do return function()
|
|
do return e1() - e2() end;
|
|
end end;
|
|
elseif (_g) == "/" then
|
|
do return function()
|
|
do return e1() / e2() end;
|
|
end end;
|
|
elseif (_g) == "<" then
|
|
do return function()
|
|
do return e1() < e2() end;
|
|
end end;
|
|
elseif (_g) == "<=" then
|
|
do return function()
|
|
do return e1() <= e2() end;
|
|
end end;
|
|
elseif (_g) == "==" then
|
|
do return function()
|
|
do return e1() == e2() end;
|
|
end end;
|
|
elseif (_g) == ">" then
|
|
do return function()
|
|
do return e1() > e2() end;
|
|
end end;
|
|
elseif (_g) == ">=" then
|
|
do return function()
|
|
do return e1() >= e2() end;
|
|
end end;
|
|
elseif (_g) == "||" then
|
|
do return function()
|
|
do return e1() or e2() end;
|
|
end end;else
|
|
_G.error(__haxe_Exception.thrown(Std.string("Unknown operation ") .. Std.string(p.p)),0); end;
|
|
elseif (_g) == "-" then
|
|
local e = self:makeExpr(l);
|
|
do return function()
|
|
do return -e() end;
|
|
end end; end;
|
|
_G.error(__haxe_Exception.thrown(p.p),0);
|
|
end
|
|
__haxe_Template.prototype.run = function(self,e)
|
|
local tmp = e[1];
|
|
if (tmp) == 0 then
|
|
local v = e[2];
|
|
local _this = self.buf;
|
|
local str = Std.string(self:resolve(v));
|
|
_G.table.insert(_this.b, str);
|
|
local _this = _this;
|
|
_this.length = _this.length + __lua_lib_luautf8_Utf8.len(str);
|
|
elseif (tmp) == 1 then
|
|
local e = e[2];
|
|
local _this = self.buf;
|
|
local str = Std.string(e());
|
|
_G.table.insert(_this.b, str);
|
|
local _this = _this;
|
|
_this.length = _this.length + __lua_lib_luautf8_Utf8.len(str);
|
|
elseif (tmp) == 2 then
|
|
local e1 = e[2];
|
|
local eif = e[3];
|
|
local eelse = e[4];
|
|
local v = e1();
|
|
if ((v == nil) or (v == false)) then
|
|
if (eelse ~= nil) then
|
|
self:run(eelse);
|
|
end;
|
|
else
|
|
self:run(eif);
|
|
end;
|
|
elseif (tmp) == 3 then
|
|
local str = e[2];
|
|
local _this = self.buf;
|
|
local str = Std.string(str);
|
|
_G.table.insert(_this.b, str);
|
|
local _this = _this;
|
|
_this.length = _this.length + __lua_lib_luautf8_Utf8.len(str);
|
|
elseif (tmp) == 4 then
|
|
local l = e[2];
|
|
local _g_head = l.h;
|
|
while (_g_head ~= nil) do _hx_do_first_1 = false;
|
|
|
|
local val = _g_head.item;
|
|
_g_head = _g_head.next;
|
|
local e = val;
|
|
self:run(e);
|
|
end;
|
|
elseif (tmp) == 5 then
|
|
local e1 = e[2];
|
|
local loop = e[3];
|
|
local v = e1();
|
|
local _hx_status, _hx_result = pcall(function()
|
|
|
|
local x = v:iterator();
|
|
if (x.hasNext == nil) then
|
|
_G.error(__haxe_Exception.thrown(nil),0);
|
|
end;
|
|
v = x;
|
|
return _hx_pcall_default
|
|
end)
|
|
if not _hx_status and _hx_result == "_hx_pcall_break" then
|
|
elseif not _hx_status then
|
|
local _g = _hx_result;
|
|
local _hx_status, _hx_result = pcall(function()
|
|
|
|
if (v.hasNext == nil) then
|
|
_G.error(__haxe_Exception.thrown(nil),0);
|
|
end;
|
|
return _hx_pcall_default
|
|
end)
|
|
if not _hx_status and _hx_result == "_hx_pcall_break" then
|
|
elseif not _hx_status then
|
|
local _g = _hx_result;
|
|
_G.error(__haxe_Exception.thrown(Std.string("Cannot iter on ") .. Std.string(Std.string(v))),0);
|
|
elseif _hx_result ~= _hx_pcall_default then
|
|
return _hx_result
|
|
end;
|
|
elseif _hx_result ~= _hx_pcall_default then
|
|
return _hx_result
|
|
end;
|
|
self.stack:push(self.context);
|
|
local v = v;
|
|
local ctx = v;
|
|
while (ctx:hasNext()) do _hx_do_first_1 = false;
|
|
|
|
local ctx = ctx:next();
|
|
self.context = ctx;
|
|
self:run(loop);
|
|
end;
|
|
self.context = self.stack:pop();
|
|
elseif (tmp) == 6 then
|
|
local m = e[2];
|
|
local params = e[3];
|
|
local v = Reflect.field(self.macros, m);
|
|
local pl = Array.new();
|
|
local old = self.buf;
|
|
pl:push(_hx_bind(self,self.resolve));
|
|
local _g_head = params.h;
|
|
while (_g_head ~= nil) do _hx_do_first_1 = false;
|
|
|
|
local val = _g_head.item;
|
|
_g_head = _g_head.next;
|
|
local p = val;
|
|
if (p[1] == 0) then
|
|
local v = p[2];
|
|
pl:push(self:resolve(v));
|
|
else
|
|
self.buf = StringBuf.new();
|
|
self:run(p);
|
|
pl:push(_G.table.concat(self.buf.b));
|
|
end;
|
|
end;
|
|
self.buf = old;
|
|
local _hx_status, _hx_result = pcall(function()
|
|
|
|
local _this = self.buf;
|
|
local str = Std.string(Reflect.callMethod(self.macros,v,pl));
|
|
_G.table.insert(_this.b, str);
|
|
local _this = _this;
|
|
_this.length = _this.length + __lua_lib_luautf8_Utf8.len(str);
|
|
return _hx_pcall_default
|
|
end)
|
|
if not _hx_status and _hx_result == "_hx_pcall_break" then
|
|
elseif not _hx_status then
|
|
local _g = _hx_result;
|
|
local e = __haxe_Exception.caught(_g):unwrap();
|
|
local plstr;
|
|
local _hx_status, _hx_result = pcall(function()
|
|
|
|
plstr = pl:join(",");
|
|
return _hx_pcall_default
|
|
end)
|
|
if not _hx_status and _hx_result == "_hx_pcall_break" then
|
|
elseif not _hx_status then
|
|
local _g = _hx_result;
|
|
plstr = "???";
|
|
elseif _hx_result ~= _hx_pcall_default then
|
|
return _hx_result
|
|
end;
|
|
local msg = Std.string(Std.string(Std.string(Std.string(Std.string(Std.string("Macro call ") .. Std.string(m)) .. Std.string("(")) .. Std.string(plstr)) .. Std.string(") failed (")) .. Std.string(Std.string(e))) .. Std.string(")");
|
|
_G.error(__haxe_Exception.thrown(msg),0);
|
|
elseif _hx_result ~= _hx_pcall_default then
|
|
return _hx_result
|
|
end; end;
|
|
end
|
|
|
|
__haxe_Template.prototype.__class__ = __haxe_Template
|
|
|
|
__haxe_ValueException.new = function(value,previous,native)
|
|
local self = _hx_new(__haxe_ValueException.prototype)
|
|
__haxe_ValueException.super(self,value,previous,native)
|
|
return self
|
|
end
|
|
__haxe_ValueException.super = function(self,value,previous,native)
|
|
__haxe_Exception.super(self,(function()
|
|
local _hx_1
|
|
if (value == nil) then
|
|
_hx_1 = "null"; else
|
|
_hx_1 = Std.string(value); end
|
|
return _hx_1
|
|
end )(),previous,native);
|
|
self.value = value;
|
|
end
|
|
__haxe_ValueException.__name__ = true
|
|
__haxe_ValueException.prototype = _hx_e();
|
|
__haxe_ValueException.prototype.unwrap = function(self)
|
|
do return self.value end
|
|
end
|
|
|
|
__haxe_ValueException.prototype.__class__ = __haxe_ValueException
|
|
__haxe_ValueException.__super__ = __haxe_Exception
|
|
setmetatable(__haxe_ValueException.prototype,{__index=__haxe_Exception.prototype})
|
|
setmetatable(__haxe_ValueException.prototype.__properties__,{__index=__haxe_Exception.prototype.__properties__})
|
|
|
|
__haxe_ds_List.new = function()
|
|
local self = _hx_new(__haxe_ds_List.prototype)
|
|
__haxe_ds_List.super(self)
|
|
return self
|
|
end
|
|
__haxe_ds_List.super = function(self)
|
|
self.length = 0;
|
|
end
|
|
__haxe_ds_List.__name__ = true
|
|
__haxe_ds_List.prototype = _hx_e();
|
|
__haxe_ds_List.prototype.add = function(self,item)
|
|
local next = nil;
|
|
local x = __haxe_ds__List_ListNode.new(item, next);
|
|
if (self.h == nil) then
|
|
self.h = x;
|
|
else
|
|
self.q.next = x;
|
|
end;
|
|
self.q = x;
|
|
self.length = self.length + 1;
|
|
end
|
|
__haxe_ds_List.prototype.push = function(self,item)
|
|
local x = __haxe_ds__List_ListNode.new(item, self.h);
|
|
self.h = x;
|
|
if (self.q == nil) then
|
|
self.q = x;
|
|
end;
|
|
self.length = self.length + 1;
|
|
end
|
|
__haxe_ds_List.prototype.first = function(self)
|
|
if (self.h == nil) then
|
|
do return nil end;
|
|
else
|
|
do return self.h.item end;
|
|
end;
|
|
end
|
|
__haxe_ds_List.prototype.pop = function(self)
|
|
if (self.h == nil) then
|
|
do return nil end;
|
|
end;
|
|
local x = self.h.item;
|
|
self.h = self.h.next;
|
|
if (self.h == nil) then
|
|
self.q = nil;
|
|
end;
|
|
self.length = self.length - 1;
|
|
do return x end
|
|
end
|
|
__haxe_ds_List.prototype.isEmpty = function(self)
|
|
do return self.h == nil end
|
|
end
|
|
__haxe_ds_List.prototype.toString = function(self)
|
|
local s_b = ({});
|
|
local s_length = 0;
|
|
local first = true;
|
|
local l = self.h;
|
|
local str = "{";
|
|
_G.table.insert(s_b, str);
|
|
s_length = s_length + __lua_lib_luautf8_Utf8.len(str);
|
|
while (l ~= nil) do _hx_do_first_1 = false;
|
|
|
|
if (first) then
|
|
first = false;
|
|
else
|
|
local str = ", ";
|
|
_G.table.insert(s_b, str);
|
|
s_length = s_length + __lua_lib_luautf8_Utf8.len(str);
|
|
end;
|
|
local str = Std.string(l.item);
|
|
_G.table.insert(s_b, str);
|
|
s_length = s_length + __lua_lib_luautf8_Utf8.len(str);
|
|
l = l.next;
|
|
end;
|
|
local str = "}";
|
|
_G.table.insert(s_b, str);
|
|
s_length = s_length + __lua_lib_luautf8_Utf8.len(str);
|
|
do return _G.table.concat(s_b) end
|
|
end
|
|
|
|
__haxe_ds_List.prototype.__class__ = __haxe_ds_List
|
|
|
|
__haxe_ds__List_ListNode.new = function(item,next)
|
|
local self = _hx_new(__haxe_ds__List_ListNode.prototype)
|
|
__haxe_ds__List_ListNode.super(self,item,next)
|
|
return self
|
|
end
|
|
__haxe_ds__List_ListNode.super = function(self,item,next)
|
|
self.item = item;
|
|
self.next = next;
|
|
end
|
|
__haxe_ds__List_ListNode.__name__ = true
|
|
__haxe_ds__List_ListNode.prototype = _hx_e();
|
|
|
|
__haxe_ds__List_ListNode.prototype.__class__ = __haxe_ds__List_ListNode
|
|
|
|
__haxe_ds_StringMap.new = {}
|
|
__haxe_ds_StringMap.__name__ = true
|
|
__haxe_ds_StringMap.__interfaces__ = {__haxe_IMap}
|
|
|
|
__haxe_exceptions_PosException.new = function(message,previous,pos)
|
|
local self = _hx_new(__haxe_exceptions_PosException.prototype)
|
|
__haxe_exceptions_PosException.super(self,message,previous,pos)
|
|
return self
|
|
end
|
|
__haxe_exceptions_PosException.super = function(self,message,previous,pos)
|
|
__haxe_Exception.super(self,message,previous);
|
|
if (pos == nil) then
|
|
self.posInfos = _hx_o({__fields__={fileName=true,lineNumber=true,className=true,methodName=true},fileName="(unknown)",lineNumber=0,className="(unknown)",methodName="(unknown)"});
|
|
else
|
|
self.posInfos = pos;
|
|
end;
|
|
end
|
|
__haxe_exceptions_PosException.__name__ = true
|
|
__haxe_exceptions_PosException.prototype = _hx_e();
|
|
__haxe_exceptions_PosException.prototype.toString = function(self)
|
|
do return Std.string(Std.string(Std.string(Std.string(Std.string(Std.string(Std.string(Std.string(Std.string("") .. Std.string(__haxe_Exception.prototype.toString(self))) .. Std.string(" in ")) .. Std.string(self.posInfos.className)) .. Std.string(".")) .. Std.string(self.posInfos.methodName)) .. Std.string(" at ")) .. Std.string(self.posInfos.fileName)) .. Std.string(":")) .. Std.string(self.posInfos.lineNumber) end
|
|
end
|
|
|
|
__haxe_exceptions_PosException.prototype.__class__ = __haxe_exceptions_PosException
|
|
__haxe_exceptions_PosException.__super__ = __haxe_Exception
|
|
setmetatable(__haxe_exceptions_PosException.prototype,{__index=__haxe_Exception.prototype})
|
|
setmetatable(__haxe_exceptions_PosException.prototype.__properties__,{__index=__haxe_Exception.prototype.__properties__})
|
|
|
|
__haxe_exceptions_NotImplementedException.new = function(message,previous,pos)
|
|
local self = _hx_new(__haxe_exceptions_NotImplementedException.prototype)
|
|
__haxe_exceptions_NotImplementedException.super(self,message,previous,pos)
|
|
return self
|
|
end
|
|
__haxe_exceptions_NotImplementedException.super = function(self,message,previous,pos)
|
|
if (message == nil) then
|
|
message = "Not implemented";
|
|
end;
|
|
__haxe_exceptions_PosException.super(self,message,previous,pos);
|
|
end
|
|
__haxe_exceptions_NotImplementedException.__name__ = true
|
|
__haxe_exceptions_NotImplementedException.prototype = _hx_e();
|
|
|
|
__haxe_exceptions_NotImplementedException.prototype.__class__ = __haxe_exceptions_NotImplementedException
|
|
__haxe_exceptions_NotImplementedException.__super__ = __haxe_exceptions_PosException
|
|
setmetatable(__haxe_exceptions_NotImplementedException.prototype,{__index=__haxe_exceptions_PosException.prototype})
|
|
setmetatable(__haxe_exceptions_NotImplementedException.prototype.__properties__,{__index=__haxe_exceptions_PosException.prototype.__properties__})
|
|
|
|
__haxe_iterators_ArrayKeyValueIterator.new = function(array)
|
|
local self = _hx_new(__haxe_iterators_ArrayKeyValueIterator.prototype)
|
|
__haxe_iterators_ArrayKeyValueIterator.super(self,array)
|
|
return self
|
|
end
|
|
__haxe_iterators_ArrayKeyValueIterator.super = function(self,array)
|
|
self.array = array;
|
|
end
|
|
__haxe_iterators_ArrayKeyValueIterator.__name__ = true
|
|
__haxe_iterators_ArrayKeyValueIterator.prototype = _hx_e();
|
|
|
|
__haxe_iterators_ArrayKeyValueIterator.prototype.__class__ = __haxe_iterators_ArrayKeyValueIterator
|
|
|
|
__lua_Boot.new = {}
|
|
__lua_Boot.__name__ = true
|
|
__lua_Boot.__instanceof = function(o,cl)
|
|
if (cl == nil) then
|
|
do return false end;
|
|
end;
|
|
local cl1 = cl;
|
|
if (cl1) == Array then
|
|
do return __lua_Boot.isArray(o) end;
|
|
elseif (cl1) == Bool then
|
|
do return _G.type(o) == "boolean" end;
|
|
elseif (cl1) == Dynamic then
|
|
do return o ~= nil end;
|
|
elseif (cl1) == Float then
|
|
do return _G.type(o) == "number" end;
|
|
elseif (cl1) == Int then
|
|
if (_G.type(o) == "number") then
|
|
do return _hx_bit_clamp(o) == o end;
|
|
else
|
|
do return false end;
|
|
end;
|
|
elseif (cl1) == String then
|
|
do return _G.type(o) == "string" end;
|
|
elseif (cl1) == _G.table then
|
|
do return _G.type(o) == "table" end;
|
|
elseif (cl1) == __lua_Thread then
|
|
do return _G.type(o) == "thread" end;
|
|
elseif (cl1) == __lua_UserData then
|
|
do return _G.type(o) == "userdata" end;else
|
|
if (((o ~= nil) and (_G.type(o) == "table")) and (_G.type(cl) == "table")) then
|
|
local tmp;
|
|
if (__lua_Boot.__instanceof(o, Array)) then
|
|
tmp = Array;
|
|
else
|
|
if (__lua_Boot.__instanceof(o, String)) then
|
|
tmp = String;
|
|
else
|
|
local cl = o.__class__;
|
|
tmp = (function()
|
|
local _hx_1
|
|
if (cl ~= nil) then
|
|
_hx_1 = cl; else
|
|
_hx_1 = nil; end
|
|
return _hx_1
|
|
end )();
|
|
end;
|
|
end;
|
|
if (__lua_Boot.extendsOrImplements(tmp, cl)) then
|
|
do return true end;
|
|
end;
|
|
if ((function()
|
|
local _hx_2
|
|
if (cl == Class) then
|
|
_hx_2 = o.__name__ ~= nil; else
|
|
_hx_2 = false; end
|
|
return _hx_2
|
|
end )()) then
|
|
do return true end;
|
|
end;
|
|
if ((function()
|
|
local _hx_3
|
|
if (cl == Enum) then
|
|
_hx_3 = o.__ename__ ~= nil; else
|
|
_hx_3 = false; end
|
|
return _hx_3
|
|
end )()) then
|
|
do return true end;
|
|
end;
|
|
do return o.__enum__ == cl end;
|
|
else
|
|
do return false end;
|
|
end; end;
|
|
end
|
|
__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.extendsOrImplements = function(cl1,cl2)
|
|
if ((cl1 == nil) or (cl2 == nil)) then
|
|
do return false end;
|
|
else
|
|
if (cl1 == cl2) then
|
|
do return true end;
|
|
else
|
|
if (cl1.__interfaces__ ~= nil) then
|
|
local intf = cl1.__interfaces__;
|
|
local _g = 1;
|
|
local _g1 = _hx_table.maxn(intf) + 1;
|
|
while (_g < _g1) do _hx_do_first_1 = false;
|
|
|
|
_g = _g + 1;
|
|
local i = _g - 1;
|
|
if (__lua_Boot.extendsOrImplements(intf[i], cl2)) then
|
|
do return true end;
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
end;
|
|
do return __lua_Boot.extendsOrImplements(cl1.__super__, cl2) end;
|
|
end
|
|
|
|
__lua_UserData.new = {}
|
|
__lua_UserData.__name__ = true
|
|
|
|
__lua_Lib.new = {}
|
|
__lua_Lib.__name__ = true
|
|
__lua_Lib.fillArray = function(itr)
|
|
local i = nil;
|
|
local ret = _hx_tab_array({}, 0);
|
|
while (true) do _hx_do_first_1 = false;
|
|
|
|
i = itr();
|
|
if (not (i ~= nil)) then
|
|
break;
|
|
end;
|
|
ret:push(i);
|
|
end;
|
|
do return ret end;
|
|
end
|
|
|
|
__lua_Thread.new = {}
|
|
__lua_Thread.__name__ = true
|
|
|
|
__xrfragment_Filter.new = function(str)
|
|
local self = _hx_new(__xrfragment_Filter.prototype)
|
|
__xrfragment_Filter.super(self,str)
|
|
return self
|
|
end
|
|
__xrfragment_Filter.super = function(self,str)
|
|
self.q = _hx_e();
|
|
self.str = "";
|
|
if (str ~= nil) then
|
|
self:parse(str);
|
|
end;
|
|
end
|
|
_hx_exports["xrfragment"]["Filter"] = __xrfragment_Filter
|
|
__xrfragment_Filter.__name__ = true
|
|
__xrfragment_Filter.prototype = _hx_e();
|
|
__xrfragment_Filter.prototype.toObject = function(self)
|
|
do return Reflect.copy(self.q) end
|
|
end
|
|
__xrfragment_Filter.prototype.get = function(self)
|
|
do return Reflect.copy(self.q) end
|
|
end
|
|
__xrfragment_Filter.prototype.parse = function(self,str)
|
|
local token = String.prototype.split(str, " ");
|
|
local q = _hx_e();
|
|
local process = function(str,prefix)
|
|
if (prefix == nil) then
|
|
prefix = "";
|
|
end;
|
|
str = StringTools.trim(str);
|
|
local k = String.prototype.split(str, "=")[0];
|
|
local v = String.prototype.split(str, "=")[1];
|
|
local filter = _hx_e();
|
|
if (Reflect.field(q, Std.string(prefix) .. Std.string(k))) then
|
|
filter = Reflect.field(q, Std.string(prefix) .. Std.string(k));
|
|
end;
|
|
if (__xrfragment_XRF.isProp:match(str)) then
|
|
local oper = "";
|
|
if (String.prototype.indexOf(str, ">") ~= -1) then
|
|
oper = ">";
|
|
end;
|
|
if (String.prototype.indexOf(str, "<") ~= -1) then
|
|
oper = "<";
|
|
end;
|
|
if (__xrfragment_XRF.isExclude:match(k)) then
|
|
k = String.prototype.substr(k, 1);
|
|
end;
|
|
v = String.prototype.substr(v, __lua_lib_luautf8_Utf8.len(oper));
|
|
if (__lua_lib_luautf8_Utf8.len(oper) == 0) then
|
|
oper = "=";
|
|
end;
|
|
local rule = _hx_e();
|
|
if (__xrfragment_XRF.isNumber:match(v)) then
|
|
local value = Std.parseFloat(v);
|
|
rule[oper] = value;
|
|
else
|
|
rule[oper] = v;
|
|
end;
|
|
q.expr = rule;
|
|
end;
|
|
local value = (function()
|
|
local _hx_1
|
|
if (__xrfragment_XRF.isDeep:match(str)) then
|
|
_hx_1 = String.prototype.split(k, "*").length - 1; else
|
|
_hx_1 = 0; end
|
|
return _hx_1
|
|
end )();
|
|
q.deep = value;
|
|
local value = (function()
|
|
local _hx_2
|
|
if (__xrfragment_XRF.isExclude:match(str)) then
|
|
_hx_2 = false; else
|
|
_hx_2 = true; end
|
|
return _hx_2
|
|
end )();
|
|
q.show = value;
|
|
local value = __xrfragment_XRF.operators:replace(k, "");
|
|
q.key = value;
|
|
q.value = v;
|
|
end;
|
|
local _g = 0;
|
|
local _g1 = token.length;
|
|
while (_g < _g1) do _hx_do_first_1 = false;
|
|
|
|
_g = _g + 1;
|
|
local i = _g - 1;
|
|
process(token[i]);
|
|
end;
|
|
self.q = q do return self.q end
|
|
end
|
|
__xrfragment_Filter.prototype.test = function(self,obj)
|
|
local qualify = false;
|
|
local _g = 0;
|
|
local _g1 = Reflect.fields(obj);
|
|
while (_g < _g1.length) do _hx_do_first_1 = false;
|
|
|
|
local k = _g1[_g];
|
|
_g = _g + 1;
|
|
local v = Std.string(Reflect.field(obj, k));
|
|
if (self:testProperty(k, v)) then
|
|
qualify = true;
|
|
end;
|
|
end;
|
|
local _g = 0;
|
|
local _g1 = Reflect.fields(obj);
|
|
while (_g < _g1.length) do _hx_do_first_1 = false;
|
|
|
|
local k = _g1[_g];
|
|
_g = _g + 1;
|
|
local v = Std.string(Reflect.field(obj, k));
|
|
if (self:testProperty(k, v, true)) then
|
|
qualify = false;
|
|
end;
|
|
end;
|
|
do return qualify end
|
|
end
|
|
__xrfragment_Filter.prototype.testProperty = function(self,property,value,exclude)
|
|
local conds = 0;
|
|
local fails = 0;
|
|
local qualify = 0;
|
|
local testprop = function(expr)
|
|
conds = conds + 1;
|
|
fails = fails + (function()
|
|
local _hx_1
|
|
if (expr) then
|
|
_hx_1 = 0; else
|
|
_hx_1 = 1; end
|
|
return _hx_1
|
|
end )();
|
|
do return expr end;
|
|
end;
|
|
if (Reflect.field(self.q, value) ~= nil) then
|
|
local v = Reflect.field(self.q, value);
|
|
if (Reflect.field(v, property) ~= nil) then
|
|
do return Reflect.field(v, property) end;
|
|
end;
|
|
end;
|
|
if (Reflect.field(self.q, "expr")) then
|
|
local f = Reflect.field(self.q, "expr");
|
|
if (not Reflect.field(self.q, "show")) then
|
|
if (((Reflect.field(f, "!=") ~= nil) and testprop(Std.string(value) == Std.string(Reflect.field(f, "!=")))) and exclude) then
|
|
qualify = qualify + 1;
|
|
end;
|
|
else
|
|
if ((Reflect.field(f, "*") ~= nil) and testprop(Std.parseFloat(value) ~= nil)) then
|
|
qualify = qualify + 1;
|
|
end;
|
|
if ((Reflect.field(f, ">") ~= nil) and testprop(Std.parseFloat(value) >= Std.parseFloat(Reflect.field(f, ">")))) then
|
|
qualify = qualify + 1;
|
|
end;
|
|
if ((Reflect.field(f, "<") ~= nil) and testprop(Std.parseFloat(value) <= Std.parseFloat(Reflect.field(f, "<")))) then
|
|
qualify = qualify + 1;
|
|
end;
|
|
if ((Reflect.field(f, "=") ~= nil) and (testprop(value == Reflect.field(f, "=")) or testprop(Std.parseFloat(value) == Std.parseFloat(Reflect.field(f, "="))))) then
|
|
qualify = qualify + 1;
|
|
end;
|
|
end;
|
|
end;
|
|
do return qualify > 0 end
|
|
end
|
|
|
|
__xrfragment_Filter.prototype.__class__ = __xrfragment_Filter
|
|
|
|
__xrfragment_Parser.new = {}
|
|
_hx_exports["xrfragment"]["Parser"] = __xrfragment_Parser
|
|
__xrfragment_Parser.__name__ = true
|
|
__xrfragment_Parser.parse = function(key,value,store,index)
|
|
local Frag_h = ({});
|
|
local value1 = _hx_bit.bor(_hx_bit.bor(__xrfragment_XRF.IMMUTABLE,__xrfragment_XRF.T_PREDEFINED_VIEW),__xrfragment_XRF.PV_EXECUTE);
|
|
if (value1 == nil) then
|
|
Frag_h["#"] = __haxe_ds_StringMap.tnull;
|
|
else
|
|
Frag_h["#"] = value1;
|
|
end;
|
|
local value1 = __xrfragment_XRF.T_URL;
|
|
if (value1 == nil) then
|
|
Frag_h.src = __haxe_ds_StringMap.tnull;
|
|
else
|
|
Frag_h.src = value1;
|
|
end;
|
|
local value1 = _hx_bit.bor(__xrfragment_XRF.T_URL,__xrfragment_XRF.T_PREDEFINED_VIEW);
|
|
if (value1 == nil) then
|
|
Frag_h.href = __haxe_ds_StringMap.tnull;
|
|
else
|
|
Frag_h.href = value1;
|
|
end;
|
|
local value1 = _hx_bit.bor(__xrfragment_XRF.IMMUTABLE,__xrfragment_XRF.T_STRING);
|
|
if (value1 == nil) then
|
|
Frag_h.tag = __haxe_ds_StringMap.tnull;
|
|
else
|
|
Frag_h.tag = value1;
|
|
end;
|
|
local value1 = _hx_bit.bor(_hx_bit.bor(_hx_bit.bor(_hx_bit.bor(__xrfragment_XRF.PV_OVERRIDE,__xrfragment_XRF.T_VECTOR3),__xrfragment_XRF.T_STRING),__xrfragment_XRF.METADATA),__xrfragment_XRF.NAVIGATOR);
|
|
if (value1 == nil) then
|
|
Frag_h.pos = __haxe_ds_StringMap.tnull;
|
|
else
|
|
Frag_h.pos = value1;
|
|
end;
|
|
local value1 = _hx_bit.bor(_hx_bit.bor(_hx_bit.bor(_hx_bit.bor(__xrfragment_XRF.QUERY_OPERATOR,__xrfragment_XRF.PV_OVERRIDE),__xrfragment_XRF.T_VECTOR3),__xrfragment_XRF.METADATA),__xrfragment_XRF.NAVIGATOR);
|
|
if (value1 == nil) then
|
|
Frag_h.rot = __haxe_ds_StringMap.tnull;
|
|
else
|
|
Frag_h.rot = value1;
|
|
end;
|
|
local value1 = _hx_bit.bor(_hx_bit.bor(_hx_bit.bor(_hx_bit.bor(__xrfragment_XRF.PV_OVERRIDE,__xrfragment_XRF.T_FLOAT),__xrfragment_XRF.T_VECTOR2),__xrfragment_XRF.NAVIGATOR),__xrfragment_XRF.METADATA);
|
|
if (value1 == nil) then
|
|
Frag_h.t = __haxe_ds_StringMap.tnull;
|
|
else
|
|
Frag_h.t = value1;
|
|
end;
|
|
local value1 = _hx_bit.bor(__xrfragment_XRF.PV_OVERRIDE,__xrfragment_XRF.T_MEDIAFRAG);
|
|
if (value1 == nil) then
|
|
Frag_h.s = __haxe_ds_StringMap.tnull;
|
|
else
|
|
Frag_h.s = value1;
|
|
end;
|
|
local value1 = _hx_bit.bor(__xrfragment_XRF.PV_OVERRIDE,__xrfragment_XRF.T_PREDEFINED_VIEW);
|
|
if (value1 == nil) then
|
|
Frag_h.loop = __haxe_ds_StringMap.tnull;
|
|
else
|
|
Frag_h.loop = value1;
|
|
end;
|
|
local value1 = _hx_bit.bor(__xrfragment_XRF.T_VECTOR2,__xrfragment_XRF.T_MEDIAFRAG);
|
|
if (value1 == nil) then
|
|
Frag_h.uv = __haxe_ds_StringMap.tnull;
|
|
else
|
|
Frag_h.uv = value1;
|
|
end;
|
|
local value1 = _hx_bit.bor(__xrfragment_XRF.IMMUTABLE,__xrfragment_XRF.T_STRING);
|
|
if (value1 == nil) then
|
|
Frag_h.namespace = __haxe_ds_StringMap.tnull;
|
|
else
|
|
Frag_h.namespace = value1;
|
|
end;
|
|
local value1 = _hx_bit.bor(__xrfragment_XRF.IMMUTABLE,__xrfragment_XRF.T_STRING);
|
|
if (value1 == nil) then
|
|
Frag_h.SPDX = __haxe_ds_StringMap.tnull;
|
|
else
|
|
Frag_h.SPDX = value1;
|
|
end;
|
|
local value1 = _hx_bit.bor(__xrfragment_XRF.IMMUTABLE,__xrfragment_XRF.T_STRING);
|
|
if (value1 == nil) then
|
|
Frag_h.unit = __haxe_ds_StringMap.tnull;
|
|
else
|
|
Frag_h.unit = value1;
|
|
end;
|
|
local value1 = _hx_bit.bor(__xrfragment_XRF.IMMUTABLE,__xrfragment_XRF.T_STRING);
|
|
if (value1 == nil) then
|
|
Frag_h.description = __haxe_ds_StringMap.tnull;
|
|
else
|
|
Frag_h.description = value1;
|
|
end;
|
|
local keyStripped = __xrfragment_XRF.operators:replace(key, "");
|
|
local isPVDynamic = (__lua_lib_luautf8_Utf8.len(key) > 0) and (Frag_h[key] == nil);
|
|
if (isPVDynamic) then
|
|
local v = __xrfragment_XRF.new(key, _hx_bit.bor(__xrfragment_XRF.PV_EXECUTE,__xrfragment_XRF.NAVIGATOR), index);
|
|
v:validate(value);
|
|
v.flags = __xrfragment_XRF.set(__xrfragment_XRF.T_DYNAMICKEY, v.flags);
|
|
if (Frag_h[key] == nil) then
|
|
v.flags = __xrfragment_XRF.set(__xrfragment_XRF.CUSTOMFRAG, v.flags);
|
|
end;
|
|
if (__lua_lib_luautf8_Utf8.len(value) == 0) then
|
|
v.flags = __xrfragment_XRF.set(__xrfragment_XRF.T_DYNAMICKEYVALUE, v.flags);
|
|
end;
|
|
store[keyStripped] = v;
|
|
do return true end;
|
|
end;
|
|
local ret = Frag_h[key];
|
|
local v = __xrfragment_XRF.new(key, (function()
|
|
local _hx_1
|
|
if (ret == __haxe_ds_StringMap.tnull) then
|
|
_hx_1 = nil; else
|
|
_hx_1 = ret; end
|
|
return _hx_1
|
|
end )(), index);
|
|
if (Frag_h[key] ~= nil) then
|
|
if (not v:validate(value)) then
|
|
__haxe_Log.trace(Std.string(Std.string(Std.string(Std.string("⚠ fragment '") .. Std.string(key)) .. Std.string("' has incompatible value (")) .. Std.string(value)) .. Std.string(")"), _hx_o({__fields__={fileName=true,lineNumber=true,className=true,methodName=true},fileName="src/xrfragment/Parser.hx",lineNumber=67,className="xrfragment.Parser",methodName="parse"}));
|
|
do return false end;
|
|
end;
|
|
store[keyStripped] = v;
|
|
if (__xrfragment_Parser.debug) then
|
|
__haxe_Log.trace(Std.string(Std.string(Std.string("✔ ") .. Std.string(key)) .. Std.string(": ")) .. Std.string(v.string), _hx_o({__fields__={fileName=true,lineNumber=true,className=true,methodName=true},fileName="src/xrfragment/Parser.hx",lineNumber=71,className="xrfragment.Parser",methodName="parse"}));
|
|
end;
|
|
else
|
|
if (__lua_Boot.__instanceof(value, String)) then
|
|
v:guessType(v, value);
|
|
end;
|
|
v.flags = __xrfragment_XRF.set(__xrfragment_XRF.CUSTOMFRAG, v.flags);
|
|
store[keyStripped] = v;
|
|
end;
|
|
do return true end;
|
|
end
|
|
__xrfragment_Parser.getMetaData = function()
|
|
local meta = _hx_o({__fields__={title=true,description=true,author=true,publisher=true,website=true,license=true},title=_hx_tab_array({[0]="title", "og:title", "dc.title"}, 3),description=_hx_tab_array({[0]="aria-description", "og:description", "dc.description"}, 3),author=_hx_tab_array({[0]="author", "dc.creator"}, 2),publisher=_hx_tab_array({[0]="publisher", "dc.publisher"}, 2),website=_hx_tab_array({[0]="og:site_name", "og:url", "dc.publisher"}, 3),license=_hx_tab_array({[0]="SPDX", "dc.rights"}, 2)});
|
|
do return meta end;
|
|
end
|
|
|
|
__xrfragment_URI.new = function()
|
|
local self = _hx_new(__xrfragment_URI.prototype)
|
|
__xrfragment_URI.super(self)
|
|
return self
|
|
end
|
|
__xrfragment_URI.super = function(self)
|
|
self.XRF = _hx_e();
|
|
self.hash = _hx_e();
|
|
self.fragment = "";
|
|
end
|
|
_hx_exports["xrfragment"]["URI"] = __xrfragment_URI
|
|
__xrfragment_URI.__name__ = true
|
|
__xrfragment_URI.parseFragment = function(url,filter)
|
|
local store = _hx_e();
|
|
if ((url == nil) or (String.prototype.indexOf(url, "#") == -1)) then
|
|
do return store end;
|
|
end;
|
|
local fragment = String.prototype.split(url, "#");
|
|
local splitArray = String.prototype.split(fragment[1], "&");
|
|
local _g = 0;
|
|
local _g1 = splitArray.length;
|
|
while (_g < _g1) do _hx_do_first_1 = false;
|
|
|
|
_g = _g + 1;
|
|
local i = _g - 1;
|
|
local splitByEqual = String.prototype.split(splitArray[i], "=");
|
|
local regexPlus = EReg.new("\\+", "g");
|
|
local key = splitByEqual[0];
|
|
local value = "";
|
|
if (splitByEqual.length > 1) then
|
|
if (__xrfragment_XRF.isVector:match(splitByEqual[1])) then
|
|
value = splitByEqual[1];
|
|
else
|
|
value = StringTools.urlDecode(regexPlus:split(splitByEqual[1]):join(" "));
|
|
end;
|
|
end;
|
|
local ok = __xrfragment_Parser.parse(key, value, store, i);
|
|
end;
|
|
if ((filter ~= nil) and (filter ~= 0)) then
|
|
local _g = 0;
|
|
local _g1 = Reflect.fields(store);
|
|
while (_g < _g1.length) do _hx_do_first_1 = false;
|
|
|
|
local key = _g1[_g];
|
|
_g = _g + 1;
|
|
local xrf = Reflect.field(store, key);
|
|
if (not xrf:is(filter)) then
|
|
Reflect.deleteField(store, key);
|
|
end;
|
|
end;
|
|
end;
|
|
do return store end;
|
|
end
|
|
__xrfragment_URI.template = function(uri,vars)
|
|
local parts = String.prototype.split(uri, "#");
|
|
if (parts.length == 1) then
|
|
do return uri end;
|
|
end;
|
|
local frag = parts[1];
|
|
frag = StringTools.replace(frag, "{", "::");
|
|
frag = StringTools.replace(frag, "}", "::");
|
|
frag = __haxe_Template.new(frag):execute(vars);
|
|
frag = StringTools.replace(frag, "null", "");
|
|
parts[1] = frag;
|
|
do return parts:join("#") end;
|
|
end
|
|
__xrfragment_URI.parse = function(stringUrl,flags)
|
|
local r = EReg.new("^(?:(?![^:@]+:[^:@/]*@)([^:/?#.]+):)?(?://)?((?:(([^:@]*)(?::([^:@]*))?)?@)?([^:/?#]*)(?::(\\d*))?)(((/(?:[^?#](?![^?#/]*\\.[^?#/.]+(?:[?#]|$)))*/?)?([^?#/]*))(?:\\?([^#]*))?(?:#(.*))?)", "");
|
|
if (((String.prototype.indexOf(stringUrl, "://") == -1) and (__lua_lib_luautf8_Utf8.sub(stringUrl, 1, 1) ~= "/")) and (__lua_lib_luautf8_Utf8.sub(stringUrl, 1, 1) ~= "#")) then
|
|
stringUrl = Std.string("/") .. Std.string(stringUrl);
|
|
end;
|
|
r:match(stringUrl);
|
|
local url = __xrfragment_URI.new();
|
|
local _g = 0;
|
|
local _g1 = __xrfragment_URI._parts.length;
|
|
while (_g < _g1) do _hx_do_first_1 = false;
|
|
|
|
_g = _g + 1;
|
|
local i = _g - 1;
|
|
url[__xrfragment_URI._parts[i]] = r:matched(i);
|
|
end;
|
|
if (__xrfragment_URI.isRelative(url) == true) then
|
|
if ((url.directory == nil) and (url.host ~= nil)) then
|
|
url.file = url.host;
|
|
end;
|
|
url.host = "";
|
|
end;
|
|
url.hash = _hx_e();
|
|
if ((url.fragment ~= nil) and (__lua_lib_luautf8_Utf8.len(url.fragment) > 0)) then
|
|
url.XRF = __xrfragment_URI.parseFragment(Std.string("#") .. Std.string(url.fragment), flags);
|
|
local key;
|
|
local _g = 0;
|
|
local _g1 = Reflect.fields(url.XRF);
|
|
while (_g < _g1.length) do _hx_do_first_1 = false;
|
|
|
|
local key = _g1[_g];
|
|
_g = _g + 1;
|
|
local v = Reflect.field(url.XRF, key);
|
|
local this1 = url.hash;
|
|
local value = Reflect.field(v, "string");
|
|
this1[key] = value;
|
|
end;
|
|
end;
|
|
__xrfragment_URI.computeVars(url);
|
|
do return url end;
|
|
end
|
|
__xrfragment_URI.computeVars = function(url)
|
|
local r = EReg.new("//", "g");
|
|
if ((url.directory ~= nil) and (String.prototype.indexOf(url.directory, "//") ~= -1)) then
|
|
url.directory = r:replace(url.directory, "/");
|
|
end;
|
|
if ((url.path ~= nil) and (String.prototype.indexOf(url.path, "//") ~= -1)) then
|
|
url.path = r:replace(url.path, "/");
|
|
end;
|
|
if ((url.file ~= nil) and (String.prototype.indexOf(url.file, "//") ~= -1)) then
|
|
url.file = r:replace(url.file, "/");
|
|
end;
|
|
url.URN = Std.string(Std.string(url.scheme) .. Std.string("://")) .. Std.string(url.host);
|
|
if (url.port ~= nil) then
|
|
local url1 = url;
|
|
url1.URN = Std.string(url1.URN) .. Std.string((Std.string(":") .. Std.string(url.port)));
|
|
end;
|
|
local url1 = url;
|
|
url1.URN = Std.string(url1.URN) .. Std.string(url.directory);
|
|
if (url.file ~= nil) then
|
|
local parts = String.prototype.split(url.file, ".");
|
|
if (parts.length > 1) then
|
|
url.fileExt = parts:pop();
|
|
end;
|
|
end;
|
|
end
|
|
__xrfragment_URI.toString = function(url)
|
|
local result = "";
|
|
if (url.scheme ~= nil) then
|
|
result = Std.string(result) .. Std.string((Std.string(url.scheme) .. Std.string("://")));
|
|
end;
|
|
if (url.user ~= nil) then
|
|
result = Std.string(result) .. Std.string((Std.string(url.user) .. Std.string(":")));
|
|
end;
|
|
if (url.password ~= nil) then
|
|
result = Std.string(result) .. Std.string((Std.string(url.password) .. Std.string("@")));
|
|
end;
|
|
if (url.host ~= nil) then
|
|
result = Std.string(result) .. Std.string(url.host);
|
|
end;
|
|
if (url.port ~= nil) then
|
|
result = Std.string(result) .. Std.string((Std.string(":") .. Std.string(url.port)));
|
|
end;
|
|
if (url.directory ~= nil) then
|
|
result = Std.string(result) .. Std.string(url.directory);
|
|
end;
|
|
if (url.file ~= nil) then
|
|
result = Std.string(result) .. Std.string(url.file);
|
|
end;
|
|
if (url.query ~= nil) then
|
|
result = Std.string(result) .. Std.string((Std.string("?") .. Std.string(url.query)));
|
|
end;
|
|
if (url.fragment ~= nil) then
|
|
result = Std.string(result) .. Std.string((Std.string("#") .. Std.string(url.fragment)));
|
|
end;
|
|
do return result end;
|
|
end
|
|
__xrfragment_URI.appendURI = function(url,appendedURI)
|
|
if (__xrfragment_URI.isRelative(url) == true) then
|
|
do return __xrfragment_URI.appendToRelativeURI(url, appendedURI) end;
|
|
else
|
|
do return __xrfragment_URI.appendToAbsoluteURI(url, appendedURI) end;
|
|
end;
|
|
end
|
|
__xrfragment_URI.isRelative = function(url)
|
|
do return url.scheme == nil end;
|
|
end
|
|
__xrfragment_URI.appendToRelativeURI = function(url,appendedURI)
|
|
if ((url.directory == nil) or (url.host == nil)) then
|
|
do return __xrfragment_URI.cloneURI(appendedURI) end;
|
|
end;
|
|
local resultURI = __xrfragment_URI.new();
|
|
resultURI.host = url.host;
|
|
resultURI.directory = url.directory;
|
|
if (appendedURI.host ~= nil) then
|
|
local resultURI = resultURI;
|
|
resultURI.directory = Std.string(resultURI.directory) .. Std.string(appendedURI.host);
|
|
end;
|
|
if (appendedURI.directory ~= nil) then
|
|
local directory = appendedURI.directory;
|
|
if (appendedURI.host == nil) then
|
|
local resultURI = resultURI;
|
|
resultURI.directory = Std.string(resultURI.directory) .. Std.string(String.prototype.substr(directory, 1));
|
|
else
|
|
local resultURI = resultURI;
|
|
resultURI.directory = Std.string(resultURI.directory) .. Std.string(directory);
|
|
end;
|
|
end;
|
|
if (appendedURI.file ~= nil) then
|
|
resultURI.file = appendedURI.file;
|
|
end;
|
|
resultURI.path = Std.string(resultURI.directory) .. Std.string(resultURI.file);
|
|
if (appendedURI.query ~= nil) then
|
|
resultURI.query = appendedURI.query;
|
|
end;
|
|
if (appendedURI.fragment ~= nil) then
|
|
resultURI.fragment = appendedURI.fragment;
|
|
end;
|
|
do return resultURI end;
|
|
end
|
|
__xrfragment_URI.appendToAbsoluteURI = function(url,appendedURI)
|
|
local resultURI = __xrfragment_URI.new();
|
|
if (url.scheme ~= nil) then
|
|
resultURI.scheme = url.scheme;
|
|
end;
|
|
if (url.host ~= nil) then
|
|
resultURI.host = url.host;
|
|
end;
|
|
local directory = "";
|
|
if (url.directory ~= nil) then
|
|
directory = url.directory;
|
|
end;
|
|
if (appendedURI.host ~= nil) then
|
|
local appendedURI1 = appendedURI;
|
|
appendedURI1.directory = Std.string(appendedURI1.directory) .. Std.string(appendedURI.host);
|
|
end;
|
|
if (appendedURI.directory ~= nil) then
|
|
directory = Std.string(directory) .. Std.string(appendedURI.directory);
|
|
end;
|
|
resultURI.directory = directory;
|
|
if (appendedURI.file ~= nil) then
|
|
resultURI.file = appendedURI.file;
|
|
end;
|
|
resultURI.path = Std.string(resultURI.directory) .. Std.string(resultURI.file);
|
|
if (appendedURI.query ~= nil) then
|
|
resultURI.query = appendedURI.query;
|
|
end;
|
|
if (appendedURI.fragment ~= nil) then
|
|
resultURI.fragment = appendedURI.fragment;
|
|
end;
|
|
do return resultURI end;
|
|
end
|
|
__xrfragment_URI.toAbsolute = function(url,newUrl)
|
|
local newURI = __xrfragment_URI.parse(newUrl, 0);
|
|
local resultURI = __xrfragment_URI.new();
|
|
resultURI.port = url.port;
|
|
resultURI.source = newUrl;
|
|
if (newURI.scheme ~= nil) then
|
|
resultURI.scheme = newURI.scheme;
|
|
else
|
|
resultURI.scheme = url.scheme;
|
|
end;
|
|
if ((newURI.host ~= nil) and (__lua_lib_luautf8_Utf8.len(newURI.host) > 0)) then
|
|
resultURI.host = newURI.host;
|
|
resultURI.port = nil;
|
|
resultURI.fragment = nil;
|
|
resultURI.hash = _hx_e();
|
|
resultURI.XRF = _hx_e();
|
|
if (newURI.port ~= nil) then
|
|
resultURI.port = newURI.port;
|
|
end;
|
|
else
|
|
resultURI.host = url.host;
|
|
end;
|
|
local directory = "";
|
|
if (url.directory ~= nil) then
|
|
directory = url.directory;
|
|
end;
|
|
if (((newURI.directory ~= nil) and (__lua_lib_luautf8_Utf8.sub(newURI.source, 1, 1) ~= "#")) and (__lua_lib_luautf8_Utf8.len(newURI.directory) > 0)) then
|
|
if ((__lua_lib_luautf8_Utf8.sub(newUrl, 1, 1) ~= "/") and (String.prototype.indexOf(newUrl, "://") == -1)) then
|
|
local stripRelative = EReg.new("\\./.*", "");
|
|
directory = stripRelative:replace(directory, "");
|
|
directory = Std.string(directory) .. Std.string(newURI.directory);
|
|
else
|
|
directory = newURI.directory;
|
|
end;
|
|
end;
|
|
resultURI.directory = directory;
|
|
if ((newURI.file ~= nil) and (__lua_lib_luautf8_Utf8.len(newURI.file) > 0)) then
|
|
resultURI.file = newURI.file;
|
|
else
|
|
resultURI.file = url.file;
|
|
end;
|
|
resultURI.path = Std.string(resultURI.directory) .. Std.string(resultURI.file);
|
|
if (newURI.query ~= nil) then
|
|
resultURI.query = newURI.query;
|
|
end;
|
|
if (newURI.fragment ~= nil) then
|
|
resultURI.fragment = newURI.fragment;
|
|
end;
|
|
resultURI.hash = newURI.hash;
|
|
resultURI.XRF = newURI.XRF;
|
|
__xrfragment_URI.computeVars(resultURI);
|
|
do return resultURI end;
|
|
end
|
|
__xrfragment_URI.cloneURI = function(url)
|
|
local clonedURI = __xrfragment_URI.new();
|
|
clonedURI.url = url.url;
|
|
clonedURI.source = url.source;
|
|
clonedURI.scheme = url.scheme;
|
|
clonedURI.authority = url.authority;
|
|
clonedURI.userInfo = url.userInfo;
|
|
clonedURI.password = url.password;
|
|
clonedURI.host = url.host;
|
|
clonedURI.port = url.port;
|
|
clonedURI.relative = url.relative;
|
|
clonedURI.path = url.path;
|
|
clonedURI.directory = url.directory;
|
|
clonedURI.file = url.file;
|
|
clonedURI.query = url.query;
|
|
clonedURI.fragment = url.fragment;
|
|
do return clonedURI end;
|
|
end
|
|
__xrfragment_URI.prototype = _hx_e();
|
|
|
|
__xrfragment_URI.prototype.__class__ = __xrfragment_URI
|
|
|
|
__xrfragment_XRF.new = function(_fragment,_flags,_index)
|
|
local self = _hx_new(__xrfragment_XRF.prototype)
|
|
__xrfragment_XRF.super(self,_fragment,_flags,_index)
|
|
return self
|
|
end
|
|
__xrfragment_XRF.super = function(self,_fragment,_flags,_index)
|
|
self.floats = Array.new();
|
|
self.shift = Array.new();
|
|
self.fragment = _fragment;
|
|
self.flags = _flags;
|
|
self.index = _index;
|
|
end
|
|
_hx_exports["xrfragment"]["XRF"] = __xrfragment_XRF
|
|
__xrfragment_XRF.__name__ = true
|
|
__xrfragment_XRF.set = function(flag,flags)
|
|
do return _hx_bit.bor(flags,flag) end;
|
|
end
|
|
__xrfragment_XRF.unset = function(flag,flags)
|
|
do return _hx_bit.band(flags,_hx_bit.bnot(flag)) end;
|
|
end
|
|
__xrfragment_XRF.prototype = _hx_e();
|
|
__xrfragment_XRF.prototype.is = function(self,flag)
|
|
if (not __lua_Boot.__instanceof(self.flags, Int)) then
|
|
self.flags = 0;
|
|
end;
|
|
do return (_hx_bit.band(self.flags,flag)) ~= 0 end
|
|
end
|
|
__xrfragment_XRF.prototype.validate = function(self,value)
|
|
self:guessType(self, value);
|
|
local ok = true;
|
|
if ((__lua_lib_luautf8_Utf8.len(value) == 0) and not self:is(__xrfragment_XRF.T_PREDEFINED_VIEW)) then
|
|
ok = false;
|
|
end;
|
|
if ((not self:is(__xrfragment_XRF.T_FLOAT) and self:is(__xrfragment_XRF.T_VECTOR2)) and not (__lua_Boot.__instanceof(self.x, Float) and __lua_Boot.__instanceof(self.y, Float))) then
|
|
ok = false;
|
|
end;
|
|
if ((not (self:is(__xrfragment_XRF.T_VECTOR2) or self:is(__xrfragment_XRF.T_STRING)) and self:is(__xrfragment_XRF.T_VECTOR3)) and not ((__lua_Boot.__instanceof(self.x, Float) and __lua_Boot.__instanceof(self.y, Float)) and __lua_Boot.__instanceof(self.z, Float))) then
|
|
ok = false;
|
|
end;
|
|
do return ok end
|
|
end
|
|
__xrfragment_XRF.prototype.guessType = function(self,v,str)
|
|
v.string = str;
|
|
if (__xrfragment_XRF.isReset:match(v.fragment)) then
|
|
v.reset = true;
|
|
end;
|
|
if (v.fragment == "loop") then
|
|
v.loop = true;
|
|
end;
|
|
if (not __lua_Boot.__instanceof(str, String)) then
|
|
do return end;
|
|
end;
|
|
if (__lua_lib_luautf8_Utf8.len(str) > 0) then
|
|
if (__xrfragment_XRF.isXRFScheme:match(str)) then
|
|
v.xrfScheme = true;
|
|
str = __xrfragment_XRF.isXRFScheme:replace(str, "");
|
|
v.string = str;
|
|
end;
|
|
if (String.prototype.split(str, ",").length > 1) then
|
|
local xyzn = String.prototype.split(str, ",");
|
|
if (xyzn.length > 0) then
|
|
v.x = Std.parseFloat(xyzn[0]);
|
|
end;
|
|
if (xyzn.length > 1) then
|
|
v.y = Std.parseFloat(xyzn[1]);
|
|
end;
|
|
if (xyzn.length > 2) then
|
|
v.z = Std.parseFloat(xyzn[2]);
|
|
end;
|
|
local _g = 0;
|
|
local _g1 = xyzn.length;
|
|
while (_g < _g1) do _hx_do_first_1 = false;
|
|
|
|
_g = _g + 1;
|
|
local i = _g - 1;
|
|
v.shift:push(__xrfragment_XRF.isShift:match(xyzn[i]));
|
|
v.floats:push(Std.parseFloat(__xrfragment_XRF.isShift:replace(xyzn[i], "")));
|
|
end;
|
|
end;
|
|
if (__xrfragment_XRF.isColor:match(str)) then
|
|
v.color = str;
|
|
end;
|
|
if (__xrfragment_XRF.isFloat:match(str)) then
|
|
v.x = Std.parseFloat(str);
|
|
v.float = v.x;
|
|
end;
|
|
if (__xrfragment_XRF.isInt:match(str)) then
|
|
v.int = Std.parseInt(str);
|
|
v.x = v.int;
|
|
v.floats:push(v.x);
|
|
end;
|
|
v.filter = __xrfragment_Filter.new(Std.string(Std.string(v.fragment) .. Std.string("=")) .. Std.string(v.string));
|
|
else
|
|
v.filter = __xrfragment_Filter.new(v.fragment);
|
|
end;
|
|
end
|
|
|
|
__xrfragment_XRF.prototype.__class__ = __xrfragment_XRF
|
|
local hasBit32, bit32 = pcall(require, 'bit32')
|
|
if hasBit32 then --if we are on Lua 5.1, bit32 will be the default.
|
|
_hx_bit_raw = 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
|
|
else
|
|
--If we do not have bit32, fallback to 'bit'
|
|
local hasBit, bit = pcall(require, 'bit')
|
|
if not hasBit then
|
|
error("Failed to load bit or bit32")
|
|
end
|
|
_hx_bit_raw = bit
|
|
_hx_bit = setmetatable({}, { __index = _hx_bit_raw })
|
|
end
|
|
|
|
-- see https://github.com/HaxeFoundation/haxe/issues/8849
|
|
_hx_bit.bor = function(...) return _hx_bit_clamp(_hx_bit_raw.bor(...)) end
|
|
_hx_bit.band = function(...) return _hx_bit_clamp(_hx_bit_raw.band(...)) end
|
|
_hx_bit.arshift = function(...) return _hx_bit_clamp(_hx_bit_raw.arshift(...)) end
|
|
|
|
if _hx_bit_raw then
|
|
_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_raw.band(v, 2147483647 ) - math.abs(_hx_bit_raw.band(v, 2147483648))
|
|
end
|
|
else
|
|
_hx_bit_clamp = function(v)
|
|
if v < -2147483648 then
|
|
return -2147483648
|
|
elseif v > 2147483647 then
|
|
return 2147483647
|
|
elseif v > 0 then
|
|
return _G.math.floor(v)
|
|
else
|
|
return _G.math.ceil(v)
|
|
end
|
|
end
|
|
end;
|
|
|
|
|
|
|
|
_hx_array_mt.__index = Array.prototype
|
|
|
|
if package.loaded.luv then
|
|
_hx_luv = _G.require("luv");
|
|
else
|
|
_hx_luv = {
|
|
run=function(mode) return false end,
|
|
loop_alive=function() return false end
|
|
}
|
|
end
|
|
local _hx_static_init = function()
|
|
|
|
if (__lua_lib_lrexlib_Rex == nil) then
|
|
_G.error(__haxe_Exception.thrown("Rex is missing. Please install lrexlib-pcre2."),0);
|
|
end;
|
|
String.__name__ = true;
|
|
Array.__name__ = true;EReg.FLAGS = __lua_lib_lrexlib_Rex.flags();
|
|
|
|
__haxe_Template.splitter = EReg.new("(::[A-Za-z0-9_ ()&|!+=/><*.\"-]+::|\\$\\$([A-Za-z0-9_-]+)\\()", "");
|
|
|
|
__haxe_Template.expr_splitter = EReg.new("(\\(|\\)|[ \r\n\t]*\"[^\"]*\"[ \r\n\t]*|[!+=/><*.&|-]+)", "");
|
|
|
|
__haxe_Template.expr_trim = EReg.new("^[ ]*([^ ]+)[ ]*$", "");
|
|
|
|
__haxe_Template.expr_int = EReg.new("^[0-9]+$", "");
|
|
|
|
__haxe_Template.expr_float = EReg.new("^([+-]?)(?=\\d|,\\d)\\d*(,\\d*)?([Ee]([+-]?\\d+))?$", "");
|
|
|
|
__haxe_Template.globals = _hx_e();
|
|
|
|
__haxe_Template.hxKeepArrayIterator = __haxe_iterators_ArrayIterator.new(_hx_tab_array({}, 0));
|
|
|
|
__haxe_ds_StringMap.tnull = ({});
|
|
|
|
__xrfragment_Parser.error = "";
|
|
|
|
__xrfragment_Parser.debug = false;
|
|
|
|
__xrfragment_URI.__meta__ = _hx_o({__fields__={statics=true},statics=_hx_o({__fields__={template=true},template=_hx_o({__fields__={keep=true},keep=nil})})});
|
|
|
|
__xrfragment_URI._parts = _hx_tab_array({[0]="source", "scheme", "authority", "userInfo", "user", "password", "host", "port", "relative", "path", "directory", "file", "query", "fragment"}, 14);
|
|
|
|
__xrfragment_XRF.IMMUTABLE = 1;
|
|
|
|
__xrfragment_XRF.PROP_BIND = 2;
|
|
|
|
__xrfragment_XRF.QUERY_OPERATOR = 4;
|
|
|
|
__xrfragment_XRF.PROMPT = 8;
|
|
|
|
__xrfragment_XRF.CUSTOMFRAG = 16;
|
|
|
|
__xrfragment_XRF.NAVIGATOR = 32;
|
|
|
|
__xrfragment_XRF.METADATA = 64;
|
|
|
|
__xrfragment_XRF.PV_OVERRIDE = 128;
|
|
|
|
__xrfragment_XRF.PV_EXECUTE = 256;
|
|
|
|
__xrfragment_XRF.T_COLOR = 8192;
|
|
|
|
__xrfragment_XRF.T_INT = 16384;
|
|
|
|
__xrfragment_XRF.T_FLOAT = 32768;
|
|
|
|
__xrfragment_XRF.T_VECTOR2 = 65536;
|
|
|
|
__xrfragment_XRF.T_VECTOR3 = 131072;
|
|
|
|
__xrfragment_XRF.T_URL = 262144;
|
|
|
|
__xrfragment_XRF.T_PREDEFINED_VIEW = 524288;
|
|
|
|
__xrfragment_XRF.T_STRING = 1048576;
|
|
|
|
__xrfragment_XRF.T_MEDIAFRAG = 2097152;
|
|
|
|
__xrfragment_XRF.T_DYNAMICKEY = 4194304;
|
|
|
|
__xrfragment_XRF.T_DYNAMICKEYVALUE = 8388608;
|
|
|
|
__xrfragment_XRF.isColor = EReg.new("^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$", "");
|
|
|
|
__xrfragment_XRF.isInt = EReg.new("^[-0-9]+$", "");
|
|
|
|
__xrfragment_XRF.isFloat = EReg.new("^[-0-9]+\\.[0-9]+$", "");
|
|
|
|
__xrfragment_XRF.isVector = EReg.new("([,]+|\\w)", "");
|
|
|
|
__xrfragment_XRF.isUrl = EReg.new("(://)?\\..*", "");
|
|
|
|
__xrfragment_XRF.isUrlOrPretypedView = EReg.new("(^#|://)?\\..*", "");
|
|
|
|
__xrfragment_XRF.isString = EReg.new(".*", "");
|
|
|
|
__xrfragment_XRF.operators = EReg.new("(^[-]|^[!]|[\\*]$)", "g");
|
|
|
|
__xrfragment_XRF.isProp = EReg.new("^.*=[><=]?", "");
|
|
|
|
__xrfragment_XRF.isExclude = EReg.new("^-", "");
|
|
|
|
__xrfragment_XRF.isDeep = EReg.new("\\*", "");
|
|
|
|
__xrfragment_XRF.isNumber = EReg.new("^[0-9\\.]+$", "");
|
|
|
|
__xrfragment_XRF.isMediaFrag = EReg.new("^([0-9\\.,\\*+-]+)$", "");
|
|
|
|
__xrfragment_XRF.isReset = EReg.new("^!", "");
|
|
|
|
__xrfragment_XRF.isShift = EReg.new("^(\\+|--)", "");
|
|
|
|
__xrfragment_XRF.isXRFScheme = EReg.new("^xrf://", "");
|
|
|
|
|
|
end
|
|
|
|
_hx_bind = function(o,m)
|
|
if m == nil then return nil end;
|
|
local f;
|
|
if o._hx__closures == nil then
|
|
_G.rawset(o, '_hx__closures', {});
|
|
else
|
|
f = o._hx__closures[m];
|
|
end
|
|
if (f == nil) then
|
|
f = function(...) return m(o, ...) end;
|
|
o._hx__closures[m] = f;
|
|
end
|
|
return f;
|
|
end
|
|
|
|
_hx_print = print or (function() end)
|
|
|
|
_hx_table = {}
|
|
_hx_table.pack = _G.table.pack or function(...)
|
|
return {...}
|
|
end
|
|
_hx_table.unpack = _G.table.unpack or _G.unpack
|
|
_hx_table.maxn = _G.table.maxn or function(t)
|
|
local maxn=0;
|
|
for i in pairs(t) do
|
|
maxn=type(i)=='number'and i>maxn and i or maxn
|
|
end
|
|
return maxn
|
|
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_dyn_add = function(a,b)
|
|
if (_G.type(a) == 'string' or _G.type(b) == 'string') then
|
|
return Std.string(a)..Std.string(b)
|
|
else
|
|
return a + b;
|
|
end;
|
|
end;
|
|
|
|
function _hx_handle_error(obj)
|
|
local message = tostring(obj)
|
|
if _G.debug and _G.debug.traceback then
|
|
-- level 2 to skip _hx_handle_error
|
|
message = _G.debug.traceback(message, 2)
|
|
end
|
|
return setmetatable({}, { __tostring = function() return message end })
|
|
end
|
|
|
|
_hx_static_init();
|
|
return _hx_exports
|