From 7b805b65bf49a9b3dc1b96f14b1778435853f887 Mon Sep 17 00:00:00 2001 From: Jens Fischer Date: Tue, 10 Mar 2020 12:25:20 +0100 Subject: [PATCH] Add Haxe generated source detection (#4808) --- lib/linguist/generated.rb | 13 +- test/fixtures/Generated/Haxe/Main.cpp | 86 +++ test/fixtures/Generated/Haxe/Main.cs | 37 ++ test/fixtures/Generated/Haxe/Main.h | 58 ++ test/fixtures/Generated/Haxe/Main.java | 41 ++ test/fixtures/Generated/Haxe/Main.php | 31 + test/fixtures/Generated/Haxe/main.js | 8 + test/fixtures/Generated/Haxe/main.lua | 816 +++++++++++++++++++++++++ test/fixtures/Generated/Haxe/main.py | 28 + test/test_generated.rb | 9 + 10 files changed, 1126 insertions(+), 1 deletion(-) create mode 100644 test/fixtures/Generated/Haxe/Main.cpp create mode 100644 test/fixtures/Generated/Haxe/Main.cs create mode 100644 test/fixtures/Generated/Haxe/Main.h create mode 100644 test/fixtures/Generated/Haxe/Main.java create mode 100644 test/fixtures/Generated/Haxe/Main.php create mode 100644 test/fixtures/Generated/Haxe/main.js create mode 100644 test/fixtures/Generated/Haxe/main.lua create mode 100644 test/fixtures/Generated/Haxe/main.py diff --git a/lib/linguist/generated.rb b/lib/linguist/generated.rb index cae93c28cd..74dcc498e0 100644 --- a/lib/linguist/generated.rb +++ b/lib/linguist/generated.rb @@ -94,7 +94,8 @@ def generated? generated_perl_ppport_header? || generated_gamemakerstudio? || generated_gimp? || - generated_visualstudio6? + generated_visualstudio6? || + generated_haxe? end # Internal: Is the blob an Xcode file? @@ -627,6 +628,16 @@ def generated_visualstudio6? lines.first(3).any? { |l| l.include? '# Microsoft Developer Studio Generated Build File' } end + HAXE_EXTENSIONS = ['.js', '.py', '.lua', '.cpp', '.h', '.java', '.cs', '.php'] + + # Internal: Is this a generated Haxe-generated source file? + # + # Return true or false + def generated_haxe? + return false unless HAXE_EXTENSIONS.include?(extname) + return lines.first(3).any? { |l| l.include?("Generated by Haxe") } + end + # Internal: Is this a generated HTML file? # # HTML documents generated by authoring tools often include a diff --git a/test/fixtures/Generated/Haxe/Main.cpp b/test/fixtures/Generated/Haxe/Main.cpp new file mode 100644 index 0000000000..c0414c1a67 --- /dev/null +++ b/test/fixtures/Generated/Haxe/Main.cpp @@ -0,0 +1,86 @@ +// Generated by Haxe 4.0.5 +#include + +#ifndef INCLUDED_Main +#include +#endif +#ifndef INCLUDED_haxe_Log +#include +#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); +} + diff --git a/test/fixtures/Generated/Haxe/Main.cs b/test/fixtures/Generated/Haxe/Main.cs new file mode 100644 index 0000000000..febc7eec4d --- /dev/null +++ b/test/fixtures/Generated/Haxe/Main.cs @@ -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) )})); + } + } + + +} + + diff --git a/test/fixtures/Generated/Haxe/Main.h b/test/fixtures/Generated/Haxe/Main.h new file mode 100644 index 0000000000..c3917d2df2 --- /dev/null +++ b/test/fixtures/Generated/Haxe/Main.h @@ -0,0 +1,58 @@ +// Generated by Haxe 4.0.5 +#ifndef INCLUDED_Main +#define INCLUDED_Main + +#ifndef HXCPP_H +#include +#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 */ diff --git a/test/fixtures/Generated/Haxe/Main.java b/test/fixtures/Generated/Haxe/Main.java new file mode 100644 index 0000000000..2fc931c139 --- /dev/null +++ b/test/fixtures/Generated/Haxe/Main.java @@ -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) )) )})); + } + + +} + + diff --git a/test/fixtures/Generated/Haxe/Main.php b/test/fixtures/Generated/Haxe/Main.php new file mode 100644 index 0000000000..b38f9b8f24 --- /dev/null +++ b/test/fixtures/Generated/Haxe/Main.php @@ -0,0 +1,31 @@ + "source/Main.hx", + "lineNumber" => 3, + "className" => "Main", + "methodName" => "main", + ])); + } + + /** + * @return void + */ + public function __construct () { + } +} + +Boot::registerClass(Main::class, 'Main'); diff --git a/test/fixtures/Generated/Haxe/main.js b/test/fixtures/Generated/Haxe/main.js new file mode 100644 index 0000000000..e4666d260a --- /dev/null +++ b/test/fixtures/Generated/Haxe/main.js @@ -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(); +})({}); diff --git a/test/fixtures/Generated/Haxe/main.lua b/test/fixtures/Generated/Haxe/main.lua new file mode 100644 index 0000000000..d9200b1cf6 --- /dev/null +++ b/test/fixtures/Generated/Haxe/main.lua @@ -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 "" 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 "" 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 "" 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() + \ No newline at end of file diff --git a/test/fixtures/Generated/Haxe/main.py b/test/fixtures/Generated/Haxe/main.py new file mode 100644 index 0000000000..b3c4832468 --- /dev/null +++ b/test/fixtures/Generated/Haxe/main.py @@ -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() diff --git a/test/test_generated.rb b/test/test_generated.rb index 3d2f75d3db..5d94653f1a 100644 --- a/test/test_generated.rb +++ b/test/test_generated.rb @@ -172,5 +172,14 @@ def test_check_generated generated_fixture_loading_data("C/image.c") generated_fixture_loading_data("C/image.h") + # Haxe + generated_fixture_loading_data("Generated/Haxe/main.js") + generated_fixture_loading_data("Generated/Haxe/main.py") + generated_fixture_loading_data("Generated/Haxe/main.lua") + generated_fixture_loading_data("Generated/Haxe/Main.cpp") + generated_fixture_loading_data("Generated/Haxe/Main.h") + generated_fixture_loading_data("Generated/Haxe/Main.java") + generated_fixture_loading_data("Generated/Haxe/Main.cs") + generated_fixture_loading_data("Generated/Haxe/Main.php") end end