add support for haxe and swift + fix interop stack overflow issue

* fix unsafe pointer arithmetic issues
therecipe · Jul 1, 2020 · 7f61353 · 7f61353
1 parent 66b6100
commit 7f61353
Show file tree

Hide file tree

Showing 43 changed files with 2,183 additions and 857 deletions.
diff --git a/.gitignore b/.gitignore
@@ -16,6 +16,9 @@ Mfile*
 */cgo_*
 */minimal_*
 */*.d.ts
+*/*.dart
+*/*.hx
+*/*.swift
 
 interop/moc*
 
@@ -25,4 +28,6 @@ interop/moc*
 /internal/examples/**/deploy
 /internal/examples/**/moc*
 /internal/examples/**/rcc*
-/internal/examples/**/uic*
+/internal/examples/**/uic*
+
+flutter/*lutter*
diff --git a/core/core.cpp b/core/core.cpp
@@ -14092,14 +14092,14 @@ char QMetaType_QMetaType_Compare(void* lhs, void* rhs, int typeId, int result)
 	return QMetaType::compare(lhs, rhs, typeId, &result);
 }
 
-void* QMetaType_QMetaType_Construct2(int ty, void* where, void* copy)
+void* QMetaType_QMetaType_Construct2(int ty, void* whe, void* copy)
 {
-	return QMetaType::construct(ty, where, copy);
+	return QMetaType::construct(ty, whe, copy);
 }
 
-void* QMetaType_Construct3(void* ptr, void* where, void* copy)
+void* QMetaType_Construct3(void* ptr, void* whe, void* copy)
 {
-	return static_cast<QMetaType*>(ptr)->construct(where, copy);
+	return static_cast<QMetaType*>(ptr)->construct(whe, copy);
 }
 
 char QMetaType_QMetaType_Convert(void* from, int fromTypeId, void* to, int toTypeId)
@@ -14132,9 +14132,9 @@ void QMetaType_Destroy2(void* ptr, void* data)
 	static_cast<QMetaType*>(ptr)->destroy(data);
 }
 
-void QMetaType_QMetaType_Destruct(int ty, void* where)
+void QMetaType_QMetaType_Destruct(int ty, void* whe)
 {
-	QMetaType::destruct(ty, where);
+	QMetaType::destruct(ty, whe);
 }
 
 void QMetaType_Destruct2(void* ptr, void* data)

diff --git a/core/core.go b/core/core.go
@@ -32066,17 +32066,17 @@ func (ptr *QMetaType) Compare(lhs unsafe.Pointer, rhs unsafe.Pointer, typeId int
 	return int8(C.QMetaType_QMetaType_Compare(lhs, rhs, C.int(int32(typeId)), C.int(int32(result)))) != 0
 }
 
-func QMetaType_Construct2(ty int, where unsafe.Pointer, copy unsafe.Pointer) unsafe.Pointer {
-	return C.QMetaType_QMetaType_Construct2(C.int(int32(ty)), where, copy)
+func QMetaType_Construct2(ty int, whe unsafe.Pointer, copy unsafe.Pointer) unsafe.Pointer {
+	return C.QMetaType_QMetaType_Construct2(C.int(int32(ty)), whe, copy)
 }
 
-func (ptr *QMetaType) Construct2(ty int, where unsafe.Pointer, copy unsafe.Pointer) unsafe.Pointer {
-	return C.QMetaType_QMetaType_Construct2(C.int(int32(ty)), where, copy)
+func (ptr *QMetaType) Construct2(ty int, whe unsafe.Pointer, copy unsafe.Pointer) unsafe.Pointer {
+	return C.QMetaType_QMetaType_Construct2(C.int(int32(ty)), whe, copy)
 }
 
-func (ptr *QMetaType) Construct3(where unsafe.Pointer, copy unsafe.Pointer) unsafe.Pointer {
+func (ptr *QMetaType) Construct3(whe unsafe.Pointer, copy unsafe.Pointer) unsafe.Pointer {
 	if ptr.Pointer() != nil {
-		return C.QMetaType_Construct3(ptr.Pointer(), where, copy)
+		return C.QMetaType_Construct3(ptr.Pointer(), whe, copy)
 	}
 	return nil
 }
@@ -32126,12 +32126,12 @@ func (ptr *QMetaType) Destroy2(data unsafe.Pointer) {
 	}
 }
 
-func QMetaType_Destruct(ty int, where unsafe.Pointer) {
-	C.QMetaType_QMetaType_Destruct(C.int(int32(ty)), where)
+func QMetaType_Destruct(ty int, whe unsafe.Pointer) {
+	C.QMetaType_QMetaType_Destruct(C.int(int32(ty)), whe)
 }
 
-func (ptr *QMetaType) Destruct(ty int, where unsafe.Pointer) {
-	C.QMetaType_QMetaType_Destruct(C.int(int32(ty)), where)
+func (ptr *QMetaType) Destruct(ty int, whe unsafe.Pointer) {
+	C.QMetaType_QMetaType_Destruct(C.int(int32(ty)), whe)
 }
 
 func (ptr *QMetaType) Destruct2(data unsafe.Pointer) {

diff --git a/core/core.h b/core/core.h
@@ -2178,15 +2178,15 @@ char QMetaProperty_Write(void* ptr, void* object, void* value);
 char QMetaProperty_WriteOnGadget(void* ptr, void* gadget, void* value);
 void* QMetaType_NewQMetaType(int typeId);
 char QMetaType_QMetaType_Compare(void* lhs, void* rhs, int typeId, int result);
-void* QMetaType_QMetaType_Construct2(int ty, void* where, void* copy);
-void* QMetaType_Construct3(void* ptr, void* where, void* copy);
+void* QMetaType_QMetaType_Construct2(int ty, void* whe, void* copy);
+void* QMetaType_Construct3(void* ptr, void* whe, void* copy);
 char QMetaType_QMetaType_Convert(void* from, int fromTypeId, void* to, int toTypeId);
 void* QMetaType_QMetaType_Create(int ty, void* copy);
 void* QMetaType_Create2(void* ptr, void* copy);
 char QMetaType_QMetaType_DebugStream(void* dbg, void* rhs, int typeId);
 void QMetaType_QMetaType_Destroy(int ty, void* data);
 void QMetaType_Destroy2(void* ptr, void* data);
-void QMetaType_QMetaType_Destruct(int ty, void* where);
+void QMetaType_QMetaType_Destruct(int ty, void* whe);
 void QMetaType_Destruct2(void* ptr, void* data);
 char QMetaType_QMetaType_Equals(void* lhs, void* rhs, int typeId, int result);
 long long QMetaType_Flags(void* ptr);

diff --git a/dbus/dbus.cpp b/dbus/dbus.cpp
@@ -1627,7 +1627,7 @@ class MyQDBusPendingCallWatcher: public QDBusPendingCallWatcher
 {
 public:
 	MyQDBusPendingCallWatcher(const QDBusPendingCall &call, QObject *parent = Q_NULLPTR) : QDBusPendingCallWatcher(call, parent) {QDBusPendingCallWatcher_QDBusPendingCallWatcher_QRegisterMetaType();};
-	void Signal_Finished(QDBusPendingCallWatcher * self) { callbackQDBusPendingCallWatcher_Finished(this, self); };
+	void Signal_Finished(QDBusPendingCallWatcher * se) { callbackQDBusPendingCallWatcher_Finished(this, se); };
 	 ~MyQDBusPendingCallWatcher() { callbackQDBusPendingCallWatcher_DestroyQDBusPendingCallWatcher(this); };
 	void childEvent(QChildEvent * event) { callbackQDBusPendingCallWatcher_ChildEvent(this, event); };
 	void connectNotify(const QMetaMethod & sign) { callbackQDBusPendingCallWatcher_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
@@ -1662,9 +1662,9 @@ void QDBusPendingCallWatcher_DisconnectFinished(void* ptr)
 	QObject::disconnect(static_cast<QDBusPendingCallWatcher*>(ptr), static_cast<void (QDBusPendingCallWatcher::*)(QDBusPendingCallWatcher *)>(&QDBusPendingCallWatcher::finished), static_cast<MyQDBusPendingCallWatcher*>(ptr), static_cast<void (MyQDBusPendingCallWatcher::*)(QDBusPendingCallWatcher *)>(&MyQDBusPendingCallWatcher::Signal_Finished));
 }
 
-void QDBusPendingCallWatcher_Finished(void* ptr, void* self)
+void QDBusPendingCallWatcher_Finished(void* ptr, void* se)
 {
-		static_cast<QDBusPendingCallWatcher*>(ptr)->finished(static_cast<QDBusPendingCallWatcher*>(self));
+		static_cast<QDBusPendingCallWatcher*>(ptr)->finished(static_cast<QDBusPendingCallWatcher*>(se));
 }
 
 char QDBusPendingCallWatcher_IsFinished(void* ptr)

diff --git a/dbus/dbus.go b/dbus/dbus.go
@@ -3494,24 +3494,24 @@ func NewQDBusPendingCallWatcher(call QDBusPendingCall_ITF, parent core.QObject_I
 }
 
 //export callbackQDBusPendingCallWatcher_Finished
-func callbackQDBusPendingCallWatcher_Finished(ptr unsafe.Pointer, self unsafe.Pointer) {
+func callbackQDBusPendingCallWatcher_Finished(ptr unsafe.Pointer, se unsafe.Pointer) {
 	if signal := qt.GetSignal(ptr, "finished"); signal != nil {
-		(*(*func(*QDBusPendingCallWatcher))(signal))(NewQDBusPendingCallWatcherFromPointer(self))
+		(*(*func(*QDBusPendingCallWatcher))(signal))(NewQDBusPendingCallWatcherFromPointer(se))
 	}
 
 }
 
-func (ptr *QDBusPendingCallWatcher) ConnectFinished(f func(self *QDBusPendingCallWatcher)) {
+func (ptr *QDBusPendingCallWatcher) ConnectFinished(f func(se *QDBusPendingCallWatcher)) {
 	if ptr.Pointer() != nil {
 
 		if !qt.ExistsSignal(ptr.Pointer(), "finished") {
 			C.QDBusPendingCallWatcher_ConnectFinished(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "finished")))
 		}
 
 		if signal := qt.LendSignal(ptr.Pointer(), "finished"); signal != nil {
-			f := func(self *QDBusPendingCallWatcher) {
-				(*(*func(*QDBusPendingCallWatcher))(signal))(self)
-				f(self)
+			f := func(se *QDBusPendingCallWatcher) {
+				(*(*func(*QDBusPendingCallWatcher))(signal))(se)
+				f(se)
 			}
 			qt.ConnectSignal(ptr.Pointer(), "finished", unsafe.Pointer(&f))
 		} else {
@@ -3527,9 +3527,9 @@ func (ptr *QDBusPendingCallWatcher) DisconnectFinished() {
 	}
 }
 
-func (ptr *QDBusPendingCallWatcher) Finished(self QDBusPendingCallWatcher_ITF) {
+func (ptr *QDBusPendingCallWatcher) Finished(se QDBusPendingCallWatcher_ITF) {
 	if ptr.Pointer() != nil {
-		C.QDBusPendingCallWatcher_Finished(ptr.Pointer(), PointerFromQDBusPendingCallWatcher(self))
+		C.QDBusPendingCallWatcher_Finished(ptr.Pointer(), PointerFromQDBusPendingCallWatcher(se))
 	}
 }
 

diff --git a/dbus/dbus.h b/dbus/dbus.h
@@ -260,7 +260,7 @@ void QDBusPendingCall_DestroyQDBusPendingCall(void* ptr);
 void* QDBusPendingCallWatcher_NewQDBusPendingCallWatcher(void* call, void* parent);
 void QDBusPendingCallWatcher_ConnectFinished(void* ptr, long long t);
 void QDBusPendingCallWatcher_DisconnectFinished(void* ptr);
-void QDBusPendingCallWatcher_Finished(void* ptr, void* self);
+void QDBusPendingCallWatcher_Finished(void* ptr, void* se);
 char QDBusPendingCallWatcher_IsFinished(void* ptr);
 void QDBusPendingCallWatcher_WaitForFinished(void* ptr);
 void QDBusPendingCallWatcher_DestroyQDBusPendingCallWatcher(void* ptr);

diff --git a/flutter/widget.go b/flutter/widget.go
@@ -277,7 +277,7 @@ func RunOnMainBlocking(f func()) {
 	}
 
 	done := make(chan bool, 0)
-	interop.Helper.RunOnMainThread(func() { f(); done <- true })
+	interop.MainThreadHelper.RunOnMainThread(func() { f(); done <- true })
 	<-done
 }
 

diff --git a/gui/gui.cpp b/gui/gui.cpp
@@ -12149,9 +12149,9 @@ void* QOpenGLContext_QOpenGLContext_GlobalShareContext()
 	return QOpenGLContext::globalShareContext();
 }
 
-char QOpenGLContext_HasExtension(void* ptr, void* extension)
+char QOpenGLContext_HasExtension(void* ptr, void* extensi)
 {
-	return static_cast<QOpenGLContext*>(ptr)->hasExtension(*static_cast<QByteArray*>(extension));
+	return static_cast<QOpenGLContext*>(ptr)->hasExtension(*static_cast<QByteArray*>(extensi));
 }
 
 char QOpenGLContext_IsOpenGLES(void* ptr)

diff --git a/gui/gui.go b/gui/gui.go
@@ -26175,9 +26175,9 @@ func (ptr *QOpenGLContext) GlobalShareContext() *QOpenGLContext {
 	return tmpValue
 }
 
-func (ptr *QOpenGLContext) HasExtension(extension core.QByteArray_ITF) bool {
+func (ptr *QOpenGLContext) HasExtension(extensi core.QByteArray_ITF) bool {
 	if ptr.Pointer() != nil {
-		return int8(C.QOpenGLContext_HasExtension(ptr.Pointer(), core.PointerFromQByteArray(extension))) != 0
+		return int8(C.QOpenGLContext_HasExtension(ptr.Pointer(), core.PointerFromQByteArray(extensi))) != 0
 	}
 	return false
 }

diff --git a/gui/gui.h b/gui/gui.h
@@ -1955,7 +1955,7 @@ void* QOpenGLContext_Functions(void* ptr);
 void* QOpenGLContext_GetProcAddress(void* ptr, void* procName);
 void* QOpenGLContext_GetProcAddress2(void* ptr, char* procName);
 void* QOpenGLContext_QOpenGLContext_GlobalShareContext();
-char QOpenGLContext_HasExtension(void* ptr, void* extension);
+char QOpenGLContext_HasExtension(void* ptr, void* extensi);
 char QOpenGLContext_IsOpenGLES(void* ptr);
 char QOpenGLContext_IsValid(void* ptr);
 char QOpenGLContext_MakeCurrent(void* ptr, void* surface);

diff --git a/internal/binding/converter/body_input_go.go b/internal/binding/converter/body_input_go.go
@@ -18,13 +18,7 @@ func GoInputParametersForC(function *parser.Function) string {
 	if function.SignalMode == "" {
 		for _, parameter := range function.Parameters {
 			if parameter.PureGoType != "" && !(parameter.Value == "QMap<QString, QVariant>" || parameter.Value == "QList<QVariant>") && !parser.IsBlackListedPureGoType(parameter.PureGoType) {
-				input = append(input, GoInput(fmt.Sprintf("uintptr(unsafe.Pointer(%v%v))",
-					func() string {
-						if !strings.HasPrefix(parameter.PureGoType, "*") {
-							return "&"
-						}
-						return ""
-					}(), parser.CleanName(parameter.Name, parameter.Value)), parameter.Value, function, parameter.PureGoType))
+				input = append(input, GoInput(fmt.Sprintf("%vTID", parser.CleanName(parameter.Name, parameter.Value)), parameter.Value, function, parameter.PureGoType))
 			} else {
 				var alloc = GoInput(parameter.Name, parameter.Value, function, parameter.PureGoType)
 				if strings.Contains(alloc, "C.CString") || strings.Contains(alloc, "qt.GoBoolToInt(*") || strings.Contains(alloc, "*C.char") || strings.Contains(alloc, "C.long(int32(*") {
@@ -72,17 +66,13 @@ func GoInputParametersForJS(function *parser.Function) string {
 		for _, parameter := range function.Parameters {
 			if parameter.PureGoType != "" && !(parameter.Value == "QMap<QString, QVariant>" || parameter.Value == "QList<QVariant>") && !parser.IsBlackListedPureGoType(parameter.PureGoType) {
 				if parser.UseWasm() {
-					if parameter.PureGoType != "" && !(parameter.Value == "QMap<QString, QVariant>" || parameter.Value == "QList<QVariant>") && !parser.IsBlackListedPureGoType(parameter.PureGoType) {
-						input = append(input, GoInput(fmt.Sprintf("unsafe.Pointer(%v%v)",
-							func() string {
-								if !strings.HasPrefix(parameter.PureGoType, "*") {
-									return "&"
-								}
-								return ""
-							}(), parser.CleanName(parameter.Name, parameter.Value)), parameter.Value, function, parameter.PureGoType))
-					} else {
-						input = append(input, GoInputJS(parser.CleanName(parameter.Name, parameter.Value), parameter.Value, function, parameter.PureGoType))
-					}
+					input = append(input, GoInput(fmt.Sprintf("unsafe.Pointer(%v%v)",
+						func() string {
+							if !strings.HasPrefix(parameter.PureGoType, "*") {
+								return "&"
+							}
+							return ""
+						}(), parser.CleanName(parameter.Name, parameter.Value)), parameter.Value, function, parameter.PureGoType))
 				} else {
 					input = append(input, GoInputJS(fmt.Sprintf("%vTID", parser.CleanName(parameter.Name, parameter.Value)), parameter.Value, function, parameter.PureGoType))
 				}

diff --git a/internal/binding/files/utils-qml.go b/internal/binding/files/utils-qml.go
@@ -1,9 +1,11 @@
 package qml
 
 import (
+	"encoding/json"
 	"math"
 	"reflect"
 	"runtime"
+	"strconv"
 	"strings"
 	"sync"
 	"unsafe"
@@ -17,6 +19,18 @@ var (
 
 	finalizerMap      = make(map[unsafe.Pointer][]*core.QObject)
 	finalizerMapMutex sync.Mutex
+
+	//needed only for interop  --->
+	ReturnPointersAsStrings bool
+
+	syncCallIntoRemoteChan       = make(chan string, 0)
+	syncCallIntoRemoteReturnChan = make(chan string, 0)
+
+	fromJsToRefReturnsOnChan bool
+	fromJsToRefReturnChan    = make(chan []reflect.Value, 0)
+
+	Z_wrapperFunctionReturnChan = make(chan *QJSValue, 0)
+	//needed only for interop  <---
 )
 
 type ptr_itf interface {
@@ -203,6 +217,31 @@ func Z_wrapperFunction(jsvals *QJSValue) *QJSValue {
 		}
 
 		ret := m.Call(input)
+
+		//needed only for interop  --->
+		if fromJsToRefReturnsOnChan {
+			fromJsToRefReturnsOnChan = false
+			go func() {
+				ret = <-fromJsToRefReturnChan
+
+				if len(ret) == 0 {
+					Z_wrapperFunctionReturnChan <- NewQJSValue(QJSValue__UndefinedValue)
+					return
+				}
+
+				rret := engine.NewGoType(ret[0].Interface())
+				if reflect.TypeOf(ret[0].Interface()).Implements(reflect.TypeOf((*core.QObject_ITF)(nil)).Elem()) { //TODO: check for destroyed signal instead, or simply override the destructor instead ?
+					if qt.ExistsSignal(ret[0].Interface().(ptr_itf).Pointer(), "destroyed") {
+						engine.GlobalObject().Property("___connectDestroyed").Call([]*QJSValue{rret}) //TODO: connect destroyed/destructor from go instead ?
+					}
+				}
+
+				Z_wrapperFunctionReturnChan <- rret
+			}()
+			return NewQJSValue(QJSValue__UndefinedValue)
+		}
+		//needed only for interop  <---
+
 		if len(ret) == 0 {
 			return NewQJSValue(QJSValue__UndefinedValue)
 		}
@@ -256,10 +295,35 @@ func (ptr *QJSEngine) fromJsToRef(tofi reflect.Type, jsval *QJSValue) reflect.Va
 			for i, arg := range args {
 				input[i] = ptr.NewGoType(arg.Interface())
 			}
-			if ret := jsval.Call(input); tofi.NumOut() != 0 {
-				return []reflect.Value{ptr.fromJsToRef(tofi.Out(0), ret)}
+			ret := jsval.Call(input)
+
+			//the default path to return on this function
+			if !(ret.IsObject() && ret.Property("___earlyReturn").ToString() == "true") {
+				if tofi.NumOut() != 0 {
+					return []reflect.Value{ptr.fromJsToRef(tofi.Out(0), ret)}
+				}
+				return nil
+			}
+
+			//needed only for interop  --->
+			fromJsToRefReturnsOnChan = true
+
+			syncCallIntoRemoteChan <- string(ret.Property("___data").ToString())
+			go func() {
+				var o interface{}
+				json.Unmarshal([]byte(<-syncCallIntoRemoteReturnChan), &o)
+				if tofi.NumOut() != 0 {
+					fromJsToRefReturnChan <- []reflect.Value{ptr.fromJsToRef(tofi.Out(0), ptr.ToScriptValue(core.NewQVariant1(o)))}
+				} else {
+					fromJsToRefReturnChan <- nil
+				}
+			}()
+
+			if tofi.NumOut() != 0 {
+				return []reflect.Value{reflect.ValueOf("___earlyReturn")}
 			}
 			return nil
+			//needed only for interop  <---
 		})
 
 		//TODO: merge into (*core.QVariant).ToGoType ? >>>
@@ -586,7 +650,11 @@ func (ptr *QJSEngine) makeFuncWrapper(fn string) *QJSValue {
 }
 
 func (ptr *QJSEngine) makeObjectWrapper(in interface{}, jsv *QJSValue) {
-	jsv.SetProperty("___pointer", ptr.ToScriptValue(core.NewQVariant1(uint64(uintptr(in.(ptr_itf).Pointer()))))) //TODO: can be shortened once NewQVariant1 supports unsafe.Pointer
+	if ReturnPointersAsStrings {
+		jsv.SetProperty("___pointer", ptr.ToScriptValue(core.NewQVariant1(strconv.FormatUint(uint64(uintptr(in.(ptr_itf).Pointer())), 10)))) //TODO: can be shortened once NewQVariant1 supports unsafe.Pointer
+	} else {
+		jsv.SetProperty("___pointer", ptr.ToScriptValue(core.NewQVariant1(uint64(uintptr(in.(ptr_itf).Pointer()))))) //TODO: can be shortened once NewQVariant1 supports unsafe.Pointer
+	}
 
 	rv := reflect.ValueOf(in)
 

diff --git a/internal/binding/parser/helper.go b/internal/binding/parser/helper.go
@@ -155,7 +155,12 @@ func CleanName(name, value string) string {
 		"time",
 		"hex",
 		"script",
-		"final":
+		"final",
+		"where",
+		"extension",
+		"protocol",
+		"self",
+		"repeat":
 		{
 			return name[:len(name)-2]
 		}