ralsina/tartrazine
1
0
Fork 0
mirror of https://github.com/ralsina/tartrazine.git synced 2025-06-27 06:42:04 -03:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Merge commit 'f955c625aded244864e83a872b396868a490dbc5' as 'go-enry'

Browse Source
This commit is contained in:
Roberto Alsina
2024-09-04 16:33:41 -03:00
parent 6a38f2f5fb f955c625ad
commit e44f64a7df
192 changed files with 528500 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

86
go-enry/_testdata/Generated/Haxe/Main.cpp Normal file
View File

@ -0,0 +1,86 @@
// Generated by Haxe 4.0.5
#include <hxcpp.h>
#ifndef INCLUDED_Main
#include <Main.h>
#endif
#ifndef INCLUDED_haxe_Log
#include <haxe/Log.h>
#endif
HX_LOCAL_STACK_FRAME(_hx_pos_e47a9afac0942eb9_3_main,"Main","main",0xed0e206e,"Main.main","Main.hx",3,0x087e5c05)
void Main_obj::__construct() { }
Dynamic Main_obj::__CreateEmpty() { return new Main_obj; }
void *Main_obj::_hx_vtable = 0;
Dynamic Main_obj::__Create(hx::DynamicArray inArgs)
{
hx::ObjectPtr< Main_obj > _hx_result = new Main_obj();
_hx_result->__construct();
return _hx_result;
}
bool Main_obj::_hx_isInstanceOf(int inClassId) {
return inClassId==(int)0x00000001 || inClassId==(int)0x332f6459;
}
void Main_obj::main(){
HX_STACKFRAME(&_hx_pos_e47a9afac0942eb9_3_main)
HXDLIN( 3) ::haxe::Log_obj::trace(HX_("Hello World",84,f6,db,6f),hx::SourceInfo(HX_("source/Main.hx",91,d3,a7,40),3,HX_("Main",59,64,2f,33),HX_("main",39,38,56,48)));
}
STATIC_HX_DEFINE_DYNAMIC_FUNC0(Main_obj,main,(void))
Main_obj::Main_obj()
{
}
bool Main_obj::__GetStatic(const ::String &inName, Dynamic &outValue, hx::PropertyAccess inCallProp)
{
switch(inName.length) {
case 4:
if (HX_FIELD_EQ(inName,"main") ) { outValue = main_dyn(); return true; }
}
return false;
}
#ifdef HXCPP_SCRIPTABLE
static hx::StorageInfo *Main_obj_sMemberStorageInfo = 0;
static hx::StaticInfo *Main_obj_sStaticStorageInfo = 0;
#endif
hx::Class Main_obj::__mClass;
static ::String Main_obj_sStaticFields[] = {
HX_("main",39,38,56,48),
::String(null())
};
void Main_obj::__register()
{
Main_obj _hx_dummy;
Main_obj::_hx_vtable = *(void **)&_hx_dummy;
hx::Static(__mClass) = new hx::Class_obj();
__mClass->mName = HX_("Main",59,64,2f,33);
__mClass->mSuper = &super::__SGetClass();
__mClass->mConstructEmpty = &__CreateEmpty;
__mClass->mConstructArgs = &__Create;
__mClass->mGetStaticField = &Main_obj::__GetStatic;
__mClass->mSetStaticField = &hx::Class_obj::SetNoStaticField;
__mClass->mStatics = hx::Class_obj::dupFunctions(Main_obj_sStaticFields);
__mClass->mMembers = hx::Class_obj::dupFunctions(0 /* sMemberFields */);
__mClass->mCanCast = hx::TCanCast< Main_obj >;
#ifdef HXCPP_SCRIPTABLE
__mClass->mMemberStorageInfo = Main_obj_sMemberStorageInfo;
#endif
#ifdef HXCPP_SCRIPTABLE
__mClass->mStaticStorageInfo = Main_obj_sStaticStorageInfo;
#endif
hx::_hx_RegisterClass(__mClass->mName, __mClass);
}

37
go-enry/_testdata/Generated/Haxe/Main.cs Normal file
View File

@ -0,0 +1,37 @@
// Generated by Haxe 4.0.5
#pragma warning disable 109, 114, 219, 429, 168, 162
public class EntryPoint__Main {
public static void Main() {
global::cs.Boot.init();
{
global::Main.main();
}
}
}
public class Main : global::haxe.lang.HxObject {
public Main(global::haxe.lang.EmptyObject empty) {
}
public Main() {
global::Main.__hx_ctor__Main(this);
}
protected static void __hx_ctor__Main(global::Main __hx_this) {
}
public static void main() {
unchecked {
global::haxe.Log.trace.__hx_invoke2_o(default(double), "Hello World", default(double), new global::haxe.lang.DynamicObject(new int[]{302979532, 1547539107, 1648581351}, new object[]{"main", "Main", "source/Main.hx"}, new int[]{1981972957}, new double[]{((double) (3) )}));
}
}
}

58
go-enry/_testdata/Generated/Haxe/Main.h Normal file
View File

@ -0,0 +1,58 @@
// Generated by Haxe 4.0.5
#ifndef INCLUDED_Main
#define INCLUDED_Main
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
HX_DECLARE_CLASS0(Main)
class HXCPP_CLASS_ATTRIBUTES Main_obj : public hx::Object
{
public:
typedef hx::Object super;
typedef Main_obj OBJ_;
Main_obj();
public:
enum { _hx_ClassId = 0x332f6459 };
void __construct();
inline void *operator new(size_t inSize, bool inContainer=false,const char *inName="Main")
{ return hx::Object::operator new(inSize,inContainer,inName); }
inline void *operator new(size_t inSize, int extra)
{ return hx::Object::operator new(inSize+extra,false,"Main"); }
inline static hx::ObjectPtr< Main_obj > __new() {
hx::ObjectPtr< Main_obj > __this = new Main_obj();
__this->__construct();
return __this;
}
inline static hx::ObjectPtr< Main_obj > __alloc(hx::Ctx *_hx_ctx) {
Main_obj *__this = (Main_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(Main_obj), false, "Main"));
*(void **)__this = Main_obj::_hx_vtable;
return __this;
}
static void * _hx_vtable;
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~Main_obj();
HX_DO_RTTI_ALL;
static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
static void __register();
bool _hx_isInstanceOf(int inClassId);
::String __ToString() const { return HX_("Main",59,64,2f,33); }
static void main();
static ::Dynamic main_dyn();
};
#endif /* INCLUDED_Main */

41
go-enry/_testdata/Generated/Haxe/Main.java Normal file
View File

@ -0,0 +1,41 @@
// Generated by Haxe 4.0.5
package haxe.root;
import haxe.root.*;
@SuppressWarnings(value={"rawtypes", "unchecked"})
public class Main extends haxe.lang.HxObject
{
public static void main(String[] args)
{
haxe.java.Init.init();
{
haxe.root.Main.main();
}
}
public Main(haxe.lang.EmptyObject empty)
{
}
public Main()
{
haxe.root.Main.__hx_ctor__Main(this);
}
protected static void __hx_ctor__Main(haxe.root.Main __hx_this)
{
}
public static void main()
{
haxe.Log.trace.__hx_invoke2_o(0.0, "Hello World", 0.0, new haxe.lang.DynamicObject(new java.lang.String[]{"className", "fileName", "methodName"}, new java.lang.Object[]{"Main", "source/Main.hx", "main"}, new java.lang.String[]{"lineNumber"}, new double[]{((double) (((double) (3) )) )}));
}
}

31
go-enry/_testdata/Generated/Haxe/Main.php Normal file
View File

@ -0,0 +1,31 @@
<?php
/**
* Generated by Haxe 4.0.5
*/
use \php\_Boot\HxAnon;
use \php\Boot;
use \haxe\Log;
class Main {
/**
* @return void
*/
public static function main () {
#source/Main.hx:3: characters 3-8
(Log::$trace)("Hello World", new HxAnon([
"fileName" => "source/Main.hx",
"lineNumber" => 3,
"className" => "Main",
"methodName" => "main",
]));
}
/**
* @return void
*/
public function __construct () {
}
}
Boot::registerClass(Main::class, 'Main');

8
go-enry/_testdata/Generated/Haxe/main.js Normal file
View File

@ -0,0 +1,8 @@
// Generated by Haxe 4.0.5
(function ($global) { "use strict";
var Main = function() { };
Main.main = function() {
console.log("source/Main.hx:3:","Hello World");
};
Main.main();
})({});

816
go-enry/_testdata/Generated/Haxe/main.lua Normal file
View File

@ -0,0 +1,816 @@
-- Generated by Haxe 4.0.5
local _hx_array_mt = {
__newindex = function(t,k,v)
local len = t.length
t.length = k >= len and (k + 1) or len
rawset(t,k,v)
end
}
local function _hx_tab_array(tab,length)
tab.length = length
return setmetatable(tab, _hx_array_mt)
end
local function _hx_anon_newindex(t,k,v) t.__fields__[k] = true; rawset(t,k,v); end
local _hx_anon_mt = {__newindex=_hx_anon_newindex}
local function _hx_a(...)
local __fields__ = {};
local ret = {__fields__ = __fields__};
local max = select('#',...);
local tab = {...};
local cur = 1;
while cur < max do
local v = tab[cur];
__fields__[v] = true;
ret[v] = tab[cur+1];
cur = cur + 2
end
return setmetatable(ret, _hx_anon_mt)
end
local function _hx_e()
return setmetatable({__fields__ = {}}, _hx_anon_mt)
end
local function _hx_o(obj)
return setmetatable(obj, _hx_anon_mt)
end
local function _hx_new(prototype)
return setmetatable({__fields__ = {}}, {__newindex=_hx_anon_newindex, __index=prototype})
end
local _hxClasses = {}
local Int = _hx_e();
local Dynamic = _hx_e();
local Float = _hx_e();
local Bool = _hx_e();
local Class = _hx_e();
local Enum = _hx_e();
local Array = _hx_e()
__lua_lib_luautf8_Utf8 = _G.require("lua-utf8")
local Main = _hx_e()
local Math = _hx_e()
local String = _hx_e()
local Std = _hx_e()
__haxe_Log = _hx_e()
__lua_Boot = _hx_e()
local _hx_bind, _hx_bit, _hx_staticToInstance, _hx_funcToField, _hx_maxn, _hx_print, _hx_apply_self, _hx_box_mr, _hx_bit_clamp, _hx_table, _hx_bit_raw
local _hx_pcall_default = {};
local _hx_pcall_break = {};
Array.new = function()
local self = _hx_new(Array.prototype)
Array.super(self)
return self
end
Array.super = function(self)
_hx_tab_array(self, 0);
end
Array.prototype = _hx_a();
Array.prototype.concat = function(self,a)
local _g = _hx_tab_array({}, 0);
local _g1 = 0;
local _g2 = self;
while (_g1 < _g2.length) do
local i = _g2[_g1];
_g1 = _g1 + 1;
_g:push(i);
end;
local ret = _g;
local _g3 = 0;
while (_g3 < a.length) do
local i1 = a[_g3];
_g3 = _g3 + 1;
ret:push(i1);
end;
do return ret end
end
Array.prototype.join = function(self,sep)
local tbl = ({});
local _gthis = self;
local cur_length = 0;
local i = _hx_o({__fields__={hasNext=true,next=true},hasNext=function(self)
do return cur_length < _gthis.length end;
end,next=function(self)
cur_length = cur_length + 1;
do return _gthis[cur_length - 1] end;
end});
while (i:hasNext()) do
local i1 = i:next();
_G.table.insert(tbl, Std.string(i1));
end;
do return _G.table.concat(tbl, sep) end
end
Array.prototype.pop = function(self)
if (self.length == 0) then
do return nil end;
end;
local ret = self[self.length - 1];
self[self.length - 1] = nil;
self.length = self.length - 1;
do return ret end
end
Array.prototype.push = function(self,x)
self[self.length] = x;
do return self.length end
end
Array.prototype.reverse = function(self)
local tmp;
local i = 0;
while (i < Std.int(self.length / 2)) do
tmp = self[i];
self[i] = self[(self.length - i) - 1];
self[(self.length - i) - 1] = tmp;
i = i + 1;
end;
end
Array.prototype.shift = function(self)
if (self.length == 0) then
do return nil end;
end;
local ret = self[0];
if (self.length == 1) then
self[0] = nil;
else
if (self.length > 1) then
self[0] = self[1];
_G.table.remove(self, 1);
end;
end;
local tmp = self;
tmp.length = tmp.length - 1;
do return ret end
end
Array.prototype.slice = function(self,pos,_end)
if ((_end == nil) or (_end > self.length)) then
_end = self.length;
else
if (_end < 0) then
_end = _G.math.fmod((self.length - (_G.math.fmod(-_end, self.length))), self.length);
end;
end;
if (pos < 0) then
pos = _G.math.fmod((self.length - (_G.math.fmod(-pos, self.length))), self.length);
end;
if ((pos > _end) or (pos > self.length)) then
do return _hx_tab_array({}, 0) end;
end;
local ret = _hx_tab_array({}, 0);
local _g = pos;
local _g1 = _end;
while (_g < _g1) do
_g = _g + 1;
local i = _g - 1;
ret:push(self[i]);
end;
do return ret end
end
Array.prototype.sort = function(self,f)
local i = 0;
local l = self.length;
while (i < l) do
local swap = false;
local j = 0;
local max = (l - i) - 1;
while (j < max) do
if (f(self[j], self[j + 1]) > 0) then
local tmp = self[j + 1];
self[j + 1] = self[j];
self[j] = tmp;
swap = true;
end;
j = j + 1;
end;
if (not swap) then
break;
end;
i = i + 1;
end;
end
Array.prototype.splice = function(self,pos,len)
if ((len < 0) or (pos > self.length)) then
do return _hx_tab_array({}, 0) end;
else
if (pos < 0) then
pos = self.length - (_G.math.fmod(-pos, self.length));
end;
end;
len = Math.min(len, self.length - pos);
local ret = _hx_tab_array({}, 0);
local _g = pos;
local _g1 = pos + len;
while (_g < _g1) do
_g = _g + 1;
local i = _g - 1;
ret:push(self[i]);
self[i] = self[i + len];
end;
local _g2 = pos + len;
local _g3 = self.length;
while (_g2 < _g3) do
_g2 = _g2 + 1;
local i1 = _g2 - 1;
self[i1] = self[i1 + len];
end;
local tmp = self;
tmp.length = tmp.length - len;
do return ret end
end
Array.prototype.toString = function(self)
local tbl = ({});
_G.table.insert(tbl, "[");
_G.table.insert(tbl, self:join(","));
_G.table.insert(tbl, "]");
do return _G.table.concat(tbl, "") end
end
Array.prototype.unshift = function(self,x)
local len = self.length;
local _g = 0;
local _g1 = len;
while (_g < _g1) do
_g = _g + 1;
local i = _g - 1;
self[len - i] = self[(len - i) - 1];
end;
self[0] = x;
end
Array.prototype.insert = function(self,pos,x)
if (pos > self.length) then
pos = self.length;
end;
if (pos < 0) then
pos = self.length + pos;
if (pos < 0) then
pos = 0;
end;
end;
local cur_len = self.length;
while (cur_len > pos) do
self[cur_len] = self[cur_len - 1];
cur_len = cur_len - 1;
end;
self[pos] = x;
end
Array.prototype.remove = function(self,x)
local _g = 0;
local _g1 = self.length;
while (_g < _g1) do
_g = _g + 1;
local i = _g - 1;
if (self[i] == x) then
local _g2 = i;
local _g11 = self.length - 1;
while (_g2 < _g11) do
_g2 = _g2 + 1;
local j = _g2 - 1;
self[j] = self[j + 1];
end;
self[self.length - 1] = nil;
self.length = self.length - 1;
do return true end;
end;
end;
do return false end
end
Array.prototype.indexOf = function(self,x,fromIndex)
local _end = self.length;
if (fromIndex == nil) then
fromIndex = 0;
else
if (fromIndex < 0) then
fromIndex = self.length + fromIndex;
if (fromIndex < 0) then
fromIndex = 0;
end;
end;
end;
local _g = fromIndex;
local _g1 = _end;
while (_g < _g1) do
_g = _g + 1;
local i = _g - 1;
if (x == self[i]) then
do return i end;
end;
end;
do return -1 end
end
Array.prototype.lastIndexOf = function(self,x,fromIndex)
if ((fromIndex == nil) or (fromIndex >= self.length)) then
fromIndex = self.length - 1;
else
if (fromIndex < 0) then
fromIndex = self.length + fromIndex;
if (fromIndex < 0) then
do return -1 end;
end;
end;
end;
local i = fromIndex;
while (i >= 0) do
if (self[i] == x) then
do return i end;
else
i = i - 1;
end;
end;
do return -1 end
end
Array.prototype.copy = function(self)
local _g = _hx_tab_array({}, 0);
local _g1 = 0;
local _g2 = self;
while (_g1 < _g2.length) do
local i = _g2[_g1];
_g1 = _g1 + 1;
_g:push(i);
end;
do return _g end
end
Array.prototype.map = function(self,f)
local _g = _hx_tab_array({}, 0);
local _g1 = 0;
local _g2 = self;
while (_g1 < _g2.length) do
local i = _g2[_g1];
_g1 = _g1 + 1;
_g:push(f(i));
end;
do return _g end
end
Array.prototype.filter = function(self,f)
local _g = _hx_tab_array({}, 0);
local _g1 = 0;
local _g2 = self;
while (_g1 < _g2.length) do
local i = _g2[_g1];
_g1 = _g1 + 1;
if (f(i)) then
_g:push(i);
end;
end;
do return _g end
end
Array.prototype.iterator = function(self)
local _gthis = self;
local cur_length = 0;
do return _hx_o({__fields__={hasNext=true,next=true},hasNext=function(self)
do return cur_length < _gthis.length end;
end,next=function(self)
cur_length = cur_length + 1;
do return _gthis[cur_length - 1] end;
end}) end
end
Array.prototype.resize = function(self,len)
if (self.length < len) then
self.length = len;
else
if (self.length > len) then
local _g = len;
local _g1 = self.length;
while (_g < _g1) do
_g = _g + 1;
local i = _g - 1;
self[i] = nil;
end;
self.length = len;
end;
end;
end
Main.new = {}
Main.main = function()
__haxe_Log.trace("Hello World", _hx_o({__fields__={fileName=true,lineNumber=true,className=true,methodName=true},fileName="source/Main.hx",lineNumber=3,className="Main",methodName="main"}));
end
Math.new = {}
Math.isNaN = function(f)
do return f ~= f end;
end
Math.isFinite = function(f)
if (f > -_G.math.huge) then
do return f < _G.math.huge end;
else
do return false end;
end;
end
Math.min = function(a,b)
if (Math.isNaN(a) or Math.isNaN(b)) then
do return (0/0) end;
else
do return _G.math.min(a, b) end;
end;
end
String.new = function(string)
local self = _hx_new(String.prototype)
String.super(self,string)
self = string
return self
end
String.super = function(self,string)
end
String.__index = function(s,k)
if (k == "length") then
do return __lua_lib_luautf8_Utf8.len(s) end;
else
local o = String.prototype;
local field = k;
if ((function()
local _hx_1
if ((_G.type(o) == "string") and ((String.prototype[field] ~= nil) or (field == "length"))) then
_hx_1 = true; elseif (o.__fields__ ~= nil) then
_hx_1 = o.__fields__[field] ~= nil; else
_hx_1 = o[field] ~= nil; end
return _hx_1
end )()) then
do return String.prototype[k] end;
else
if (String.__oldindex ~= nil) then
if (_G.type(String.__oldindex) == "function") then
do return String.__oldindex(s, k) end;
else
if (_G.type(String.__oldindex) == "table") then
do return String.__oldindex[k] end;
end;
end;
do return nil end;
else
do return nil end;
end;
end;
end;
end
String.fromCharCode = function(code)
do return __lua_lib_luautf8_Utf8.char(code) end;
end
String.prototype = _hx_a();
String.prototype.toUpperCase = function(self)
do return __lua_lib_luautf8_Utf8.upper(self) end
end
String.prototype.toLowerCase = function(self)
do return __lua_lib_luautf8_Utf8.lower(self) end
end
String.prototype.indexOf = function(self,str,startIndex)
if (startIndex == nil) then
startIndex = 1;
else
startIndex = startIndex + 1;
end;
local r = __lua_lib_luautf8_Utf8.find(self, str, startIndex, true);
if ((r ~= nil) and (r > 0)) then
do return r - 1 end;
else
do return -1 end;
end;
end
String.prototype.lastIndexOf = function(self,str,startIndex)
local i = 0;
local ret = -1;
if (startIndex == nil) then
startIndex = __lua_lib_luautf8_Utf8.len(self);
end;
while (true) do
local startIndex1 = ret + 1;
if (startIndex1 == nil) then
startIndex1 = 1;
else
startIndex1 = startIndex1 + 1;
end;
local r = __lua_lib_luautf8_Utf8.find(self, str, startIndex1, true);
local p = (function()
local _hx_1
if ((r ~= nil) and (r > 0)) then
_hx_1 = r - 1; else
_hx_1 = -1; end
return _hx_1
end )();
if ((p == -1) or (p > startIndex)) then
break;
end;
ret = p;
end;
do return ret end
end
String.prototype.split = function(self,delimiter)
local idx = 1;
local ret = _hx_tab_array({}, 0);
local delim_offset = (function()
local _hx_1
if (__lua_lib_luautf8_Utf8.len(delimiter) > 0) then
_hx_1 = __lua_lib_luautf8_Utf8.len(delimiter); else
_hx_1 = 1; end
return _hx_1
end )();
while (idx ~= nil) do
local newidx = 0;
if (__lua_lib_luautf8_Utf8.len(delimiter) > 0) then
newidx = __lua_lib_luautf8_Utf8.find(self, delimiter, idx, true);
else
if (idx >= __lua_lib_luautf8_Utf8.len(self)) then
newidx = nil;
else
newidx = idx + 1;
end;
end;
if (newidx ~= nil) then
local match = __lua_lib_luautf8_Utf8.sub(self, idx, newidx - 1);
ret:push(match);
idx = newidx + __lua_lib_luautf8_Utf8.len(delimiter);
else
ret:push(__lua_lib_luautf8_Utf8.sub(self, idx, __lua_lib_luautf8_Utf8.len(self)));
idx = nil;
end;
end;
do return ret end
end
String.prototype.toString = function(self)
do return self end
end
String.prototype.substring = function(self,startIndex,endIndex)
if (endIndex == nil) then
endIndex = __lua_lib_luautf8_Utf8.len(self);
end;
if (endIndex < 0) then
endIndex = 0;
end;
if (startIndex < 0) then
startIndex = 0;
end;
if (endIndex < startIndex) then
do return __lua_lib_luautf8_Utf8.sub(self, endIndex + 1, startIndex) end;
else
do return __lua_lib_luautf8_Utf8.sub(self, startIndex + 1, endIndex) end;
end;
end
String.prototype.charAt = function(self,index)
do return __lua_lib_luautf8_Utf8.sub(self, index + 1, index + 1) end
end
String.prototype.charCodeAt = function(self,index)
do return __lua_lib_luautf8_Utf8.byte(self, index + 1) end
end
String.prototype.substr = function(self,pos,len)
if ((len == nil) or (len > (pos + __lua_lib_luautf8_Utf8.len(self)))) then
len = __lua_lib_luautf8_Utf8.len(self);
else
if (len < 0) then
len = __lua_lib_luautf8_Utf8.len(self) + len;
end;
end;
if (pos < 0) then
pos = __lua_lib_luautf8_Utf8.len(self) + pos;
end;
if (pos < 0) then
pos = 0;
end;
do return __lua_lib_luautf8_Utf8.sub(self, pos + 1, pos + len) end
end
Std.new = {}
Std.string = function(s)
do return __lua_Boot.__string_rec(s) end;
end
Std.int = function(x)
if (not Math.isFinite(x) or Math.isNaN(x)) then
do return 0 end;
else
do return _hx_bit_clamp(x) end;
end;
end
__haxe_Log.new = {}
__haxe_Log.formatOutput = function(v,infos)
local str = Std.string(v);
if (infos == nil) then
do return str end;
end;
local pstr = Std.string(Std.string(infos.fileName) .. Std.string(":")) .. Std.string(infos.lineNumber);
if (infos.customParams ~= nil) then
local _g = 0;
local _g1 = infos.customParams;
while (_g < _g1.length) do
local v1 = _g1[_g];
_g = _g + 1;
str = Std.string(str) .. Std.string((Std.string(", ") .. Std.string(Std.string(v1))));
end;
end;
do return Std.string(Std.string(pstr) .. Std.string(": ")) .. Std.string(str) end;
end
__haxe_Log.trace = function(v,infos)
local str = __haxe_Log.formatOutput(v, infos);
_hx_print(str);
end
__lua_Boot.new = {}
__lua_Boot.isArray = function(o)
if (_G.type(o) == "table") then
if ((o.__enum__ == nil) and (_G.getmetatable(o) ~= nil)) then
do return _G.getmetatable(o).__index == Array.prototype end;
else
do return false end;
end;
else
do return false end;
end;
end
__lua_Boot.printEnum = function(o,s)
if (o.length == 2) then
do return o[0] end;
else
local str = Std.string(Std.string(o[0])) .. Std.string("(");
s = Std.string(s) .. Std.string("\t");
local _g = 2;
local _g1 = o.length;
while (_g < _g1) do
_g = _g + 1;
local i = _g - 1;
if (i ~= 2) then
str = Std.string(str) .. Std.string((Std.string(",") .. Std.string(__lua_Boot.__string_rec(o[i], s))));
else
str = Std.string(str) .. Std.string(__lua_Boot.__string_rec(o[i], s));
end;
end;
do return Std.string(str) .. Std.string(")") end;
end;
end
__lua_Boot.printClassRec = function(c,result,s)
if (result == nil) then
result = "";
end;
local f = __lua_Boot.__string_rec;
for k,v in pairs(c) do if result ~= '' then result = result .. ', ' end result = result .. k .. ':' .. f(v, s.. ' ') end;
do return result end;
end
__lua_Boot.__string_rec = function(o,s)
if (s == nil) then
s = "";
end;
if (__lua_lib_luautf8_Utf8.len(s) >= 5) then
do return "<...>" end;
end;
local _g = type(o);
if (_g) == "boolean" then
do return tostring(o) end;
elseif (_g) == "function" then
do return "<function>" end;
elseif (_g) == "nil" then
do return "null" end;
elseif (_g) == "number" then
if (o == _G.math.huge) then
do return "Infinity" end;
else
if (o == -_G.math.huge) then
do return "-Infinity" end;
else
if (o == 0) then
do return "0" end;
else
if (o ~= o) then
do return "NaN" end;
else
do return tostring(o) end;
end;
end;
end;
end;
elseif (_g) == "string" then
do return o end;
elseif (_g) == "table" then
if (o.__enum__ ~= nil) then
do return __lua_Boot.printEnum(o, s) end;
else
if ((_hx_wrap_if_string_field(o,'toString') ~= nil) and not __lua_Boot.isArray(o)) then
do return _hx_wrap_if_string_field(o,'toString')(o) end;
else
if (__lua_Boot.isArray(o)) then
local o2 = o;
if (__lua_lib_luautf8_Utf8.len(s) > 5) then
do return "[...]" end;
else
local _g1 = _hx_tab_array({}, 0);
local _g11 = 0;
while (_g11 < o2.length) do
local i = o2[_g11];
_g11 = _g11 + 1;
_g1:push(__lua_Boot.__string_rec(i, Std.string(s) .. Std.string(1)));
end;
do return Std.string(Std.string("[") .. Std.string(_g1:join(","))) .. Std.string("]") end;
end;
else
if (o.__class__ ~= nil) then
do return Std.string(Std.string("{") .. Std.string(__lua_Boot.printClassRec(o, "", Std.string(s) .. Std.string("\t")))) .. Std.string("}") end;
else
local fields = __lua_Boot.fieldIterator(o);
local buffer = ({});
local first = true;
_G.table.insert(buffer, "{ ");
local f = fields;
while (f:hasNext()) do
local f1 = f:next();
if (first) then
first = false;
else
_G.table.insert(buffer, ", ");
end;
_G.table.insert(buffer, Std.string(Std.string(Std.string("") .. Std.string(Std.string(f1))) .. Std.string(" : ")) .. Std.string(__lua_Boot.__string_rec(o[f1], Std.string(s) .. Std.string("\t"))));
end;
_G.table.insert(buffer, " }");
do return _G.table.concat(buffer, "") end;
end;
end;
end;
end;
elseif (_g) == "thread" then
do return "<thread>" end;
elseif (_g) == "userdata" then
local mt = _G.getmetatable(o);
if ((mt ~= nil) and (mt.__tostring ~= nil)) then
do return _G.tostring(o) end;
else
do return "<userdata>" end;
end;else
_G.error("Unknown Lua type",0); end;
end
__lua_Boot.fieldIterator = function(o)
if (_G.type(o) ~= "table") then
do return _hx_o({__fields__={next=true,hasNext=true},next=function(self)
do return nil end;
end,hasNext=function(self)
do return false end;
end}) end;
end;
local tbl = (function()
local _hx_1
if (o.__fields__ ~= nil) then
_hx_1 = o.__fields__; else
_hx_1 = o; end
return _hx_1
end )();
local cur = _G.pairs(tbl);
local next_valid = function(tbl1,val)
while (__lua_Boot.hiddenFields[val] ~= nil) do
val = cur(tbl1, val);
end;
do return val end;
end;
local cur_val = next_valid(tbl, cur(tbl, nil));
do return _hx_o({__fields__={next=true,hasNext=true},next=function(self)
local ret = cur_val;
cur_val = next_valid(tbl, cur(tbl, cur_val));
do return ret end;
end,hasNext=function(self)
do return cur_val ~= nil end;
end}) end;
end
_hx_bit_clamp = function(v)
if v <= 2147483647 and v >= -2147483648 then
if v > 0 then return _G.math.floor(v)
else return _G.math.ceil(v)
end
end
if v > 2251798999999999 then v = v*2 end;
if (v ~= v or math.abs(v) == _G.math.huge) then return nil end
return _hx_bit.band(v, 2147483647 ) - math.abs(_hx_bit.band(v, 2147483648))
end
-- require this for lua 5.1
pcall(require, 'bit')
if bit then
_hx_bit = bit
else
local _hx_bit_raw = _G.require('bit32')
_hx_bit = setmetatable({}, { __index = _hx_bit_raw });
-- lua 5.2 weirdness
_hx_bit.bnot = function(...) return _hx_bit_clamp(_hx_bit_raw.bnot(...)) end;
_hx_bit.bxor = function(...) return _hx_bit_clamp(_hx_bit_raw.bxor(...)) end;
end
_hx_array_mt.__index = Array.prototype
local _hx_static_init = function()
__lua_Boot.hiddenFields = {__id__=true, hx__closures=true, super=true, prototype=true, __fields__=true, __ifields__=true, __class__=true, __properties__=true}
end
_hx_print = print or (function() end)
_hx_wrap_if_string_field = function(o, fld)
if _G.type(o) == 'string' then
if fld == 'length' then
return _G.string.len(o)
else
return String.prototype[fld]
end
else
return o[fld]
end
end
_hx_static_init();
Main.main()

28
go-enry/_testdata/Generated/Haxe/main.py Normal file
View File

@ -0,0 +1,28 @@
# Generated by Haxe 4.0.5
# coding: utf-8
import sys
class Main:
__slots__ = ()
@staticmethod
def main():
print("Hello World")
class python_internal_MethodClosure:
__slots__ = ("obj", "func")
def __init__(self,obj,func):
self.obj = obj
self.func = func
def __call__(self,*args):
return self.func(self.obj,*args)
Main.main()