Merge pull request #2 from ricochet1k/safer

Safer

Author: neclepsio

bridge.go

@@ -23,12 +23,12 @@ import (
 )
 
 var (
-	guiFunc      = make(chan func())
-	guiDone      = make(chan struct{})
-	guiLock      = 0
-	guiMainRef   uintptr
-	guiPaintRef  uintptr
-	guiIdleRun   int32
+	guiFunc     = make(chan func())
+	guiDone     = make(chan struct{})
+	guiLock     = 0
+	guiMainRef  uintptr
+	guiPaintRef uintptr
+	guiIdleRun  int32
 
 	initialized int32
 )
@@ -187,6 +187,7 @@ func hookIdleTimer() {
 				return
 			}
 		}
+		// fmt.Fprintf(os.Stderr, "hookIdleTimer: %v\n", runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name())
 		f()
 		guiDone <- struct{}{}
 		atomic.AddInt32(&guiIdleRun, -1)
@@ -230,10 +231,17 @@ func wrapGoValue(engine *Engine, gvalue interface{}, owner valueOwner) (cvalue u
 
 	painting := cdata.Ref() == atomic.LoadUintptr(&guiPaintRef)
 
+	hashableGvalue := gvalue
+	if gvaluev.Kind() == reflect.Slice {
+		hashableGvalue = *(*reflect.SliceHeader)(unsafe.Pointer(gvaluev.Pointer()))
+	} else if !hashable(gvalue) {
+		panic(fmt.Sprintf("gvalue not hashable: %v %v", gvaluev.Type(), gvaluev.Kind()))
+	}
+
 	// Cannot reuse a jsOwner because the QML runtime may choose to destroy
 	// the value _after_ we hand it a new reference to the same value.
 	// See issue #68 for details.
-	prev, ok := engine.values[gvalue]
+	prev, ok := engine.values[hashableGvalue]
 	if ok && (prev.owner == cppOwner || painting) {
 		return prev.cvalue
 	}
@@ -257,7 +265,7 @@ func wrapGoValue(engine *Engine, gvalue interface{}, owner valueOwner) (cvalue u
 		fold.next = prev
 		prev.prev = fold
 	}
-	engine.values[gvalue] = fold
+	engine.values[hashableGvalue] = fold
 
 	//fmt.Printf("[DEBUG] value alive (wrapped): cvalue=%x gvalue=%x/%#v\n", fold.cvalue, addrOf(fold.gvalue), fold.gvalue)
 	stats.valuesAlive(+1)
@@ -356,7 +364,6 @@ func deref(value reflect.Value) reflect.Value {
 		}
 		return value
 	}
-	panic("cannot happen")
 }
 
 //export hookGoValueReadField
@@ -367,7 +374,18 @@ func hookGoValueReadField(enginep, foldp unsafe.Pointer, reflectIndex, getIndex,
 	if getIndex >= 0 {
 		field = reflect.ValueOf(fold.gvalue).Method(int(getIndex)).Call(nil)[0]
 	} else {
-		field = deref(reflect.ValueOf(fold.gvalue)).Field(int(reflectIndex))
+		val := deref(reflect.ValueOf(fold.gvalue))
+		// defer func() {
+		// 	if r := recover(); r != nil {
+		// 		fmt.Fprintf(os.Stderr, "panic in hookGoValueReadField %v %v\n", val, reflectIndex)
+		// 	}
+		// }()
+		if !val.IsValid() {
+			// panic(fmt.Sprintf("invalid value in hookGoValueReadField %#v\n", fold))
+			resultdv.dataType = C.DTInvalid
+			return
+		}
+		field = val.Field(int(reflectIndex))
 	}
 	field = deref(field)
 
@@ -503,7 +521,11 @@ func hookGoValueCallMethod(enginep, foldp unsafe.Pointer, reflectIndex C.int, ar
 	for i := 0; i < numIn; i++ {
 		paramdv := (*C.DataValue)(unsafe.Pointer(uintptr(unsafe.Pointer(args)) + (uintptr(i)+1)*dataValueSize))
 		param := reflect.ValueOf(unpackDataValue(paramdv, fold.engine))
-		if argt := methodt.In(i); param.Type() != argt {
+		argt := methodt.In(i)
+		if !param.IsValid() {
+			fmt.Printf("Warning: %s called with zero parameter\n", methodName)
+			param = reflect.Zero(argt)
+		} else if param.Type() != argt {
 			param, err = convertParam(methodName, i, param, argt)
 			if err != nil {
 				panic(err.Error())
@@ -562,7 +584,7 @@ func hookGoValuePaint(enginep, foldp unsafe.Pointer, reflectIndex C.intptr_t) {
 		return
 	}
 
-	painter := &Painter{engine: fold.engine, obj: &Common{fold.cvalue, fold.engine}}
+	painter := &Painter{engine: fold.engine, obj: CommonOf(fold.cvalue, fold.engine)}
 	v := reflect.ValueOf(fold.gvalue)
 	method := v.Method(int(reflectIndex))
 	method.Call([]reflect.Value{reflect.ValueOf(painter)})
@@ -617,7 +639,7 @@ func _initGoType(fold *valueFold, schedulePaint bool) {
 		return
 	}
 	// TODO Would be good to preserve identity on the Go side. See unpackDataValue as well.
-	obj := &Common{engine: fold.engine, addr: fold.cvalue}
+	obj := CommonOf(fold.cvalue, fold.engine)
 	fold.init.Call([]reflect.Value{reflect.ValueOf(fold.gvalue), reflect.ValueOf(obj)})
 	fold.init = reflect.Value{}
 	if schedulePaint {

cpp/capi.cpp

@@ -113,6 +113,58 @@ void engineSetOwnershipJS(QQmlEngine_ *engine, QObject_ *object)
     qengine->setObjectOwnership(qobject, QQmlEngine::JavaScriptOwnership);
 }
 
+void engineClearImportPaths(QQmlEngine_ *engine)
+{
+    QQmlEngine *qengine = reinterpret_cast<QQmlEngine *>(engine);
+
+    QStringList empty;
+
+    qengine->setImportPathList(empty);
+}
+
+void engineAddImportPath(QQmlEngine_ *engine, const char *path, int pathLen)
+{
+    QQmlEngine *qengine = reinterpret_cast<QQmlEngine *>(engine);
+
+    QByteArray qimportPath(path, pathLen);
+    QString qsimportPath = QString::fromUtf8(qimportPath);
+
+    qengine->addImportPath(qsimportPath);
+}
+
+void engineClearPluginPaths(QQmlEngine_ *engine)
+{
+    QQmlEngine *qengine = reinterpret_cast<QQmlEngine *>(engine);
+
+    QStringList empty;
+
+    qengine->setPluginPathList(empty);
+}
+
+void engineAddPluginPath(QQmlEngine_ *engine, const char *path, int pathLen)
+{
+    QQmlEngine *qengine = reinterpret_cast<QQmlEngine *>(engine);
+
+    QByteArray qpluginPath(path, pathLen);
+    QString qspluginPath = QString::fromUtf8(qpluginPath);
+
+    qengine->addPluginPath(qspluginPath);
+}
+
+void engineClearComponentCache(QQmlEngine_ *engine)
+{
+    QQmlEngine *qengine = reinterpret_cast<QQmlEngine *>(engine);
+    qengine->clearComponentCache();
+}
+
+void coreAddLibraryPath(const char *path, int pathLen)
+{
+    QByteArray qlibraryPath(path, pathLen);
+    QString qslibraryPath = QString::fromUtf8(qlibraryPath);
+
+    QCoreApplication::addLibraryPath(qslibraryPath);
+}
+
 QQmlComponent_ *newComponent(QQmlEngine_ *engine, QObject_ *parent)
 {
     QQmlEngine *qengine = reinterpret_cast<QQmlEngine *>(engine);
@@ -362,7 +414,7 @@ const char *objectTypeName(QObject_ *object)
 int objectGetProperty(QObject_ *object, const char *name, DataValue *result)
 {
     QObject *qobject = reinterpret_cast<QObject *>(object);
-    
+
     QVariant var = qobject->property(name);
     packDataValue(&var, result);
 
@@ -437,6 +489,10 @@ error *objectInvoke(QObject_ *object, const char *method, int methodLen, DataVal
         panicf("fix the parameter dispatching");
     }
 
+    if (qobject == 0) {
+      return errorf("method called on null object: %s", method);
+    }
+
     const QMetaObject *metaObject = qobject->metaObject();
     // Walk backwards so descendants have priority.
     for (int i = metaObject->methodCount()-1; i >= 0; i--) {
@@ -452,7 +508,7 @@ error *objectInvoke(QObject_ *object, const char *method, int methodLen, DataVal
 
                 bool ok;
                 if (metaMethod.returnType() == QMetaType::Void) {
-                    ok = metaMethod.invoke(qobject, Qt::DirectConnection, 
+                    ok = metaMethod.invoke(qobject, Qt::DirectConnection,
                         arg[0], arg[1], arg[2], arg[3], arg[4], arg[5], arg[6], arg[7], arg[8], arg[9]);
                 } else {
                     ok = metaMethod.invoke(qobject, Qt::DirectConnection, Q_RETURN_ARG(QVariant, result),
@@ -475,7 +531,7 @@ void objectFindChild(QObject_ *object, QString_ *name, DataValue *resultdv)
 {
     QObject *qobject = reinterpret_cast<QObject *>(object);
     QString *qname = reinterpret_cast<QString *>(name);
-    
+
     QVariant var;
     QObject *result = qobject->findChild<QObject *>(*qname);
     if (result) {
@@ -743,6 +799,15 @@ void packDataValue(QVariant_ *var, DataValue *value)
             *(DataValue**)(value->data) = dvlist;
         }
         break;
+    case QMetaType::User:
+        {
+            static const int qjstype = QVariant::fromValue(QJSValue()).userType();
+            if (qvar->userType() == qjstype) {
+                auto var = qvar->value<QJSValue>().toVariant();
+                packDataValue(&var, value);
+            }
+        }
+        break;
     default:
         if (qvar->type() == (int)QMetaType::QObjectStar || qvar->canConvert<QObject *>()) {
             QObject *qobject = qvar->value<QObject *>();

cpp/capi.h

@@ -122,6 +122,12 @@ void engineSetOwnershipCPP(QQmlEngine_ *engine, QObject_ *object);
 void engineSetOwnershipJS(QQmlEngine_ *engine, QObject_ *object);
 void engineSetContextForObject(QQmlEngine_ *engine, QObject_ *object);
 void engineAddImageProvider(QQmlEngine_ *engine, QString_ *providerId, void *imageFunc);
+void engineClearImportPaths(QQmlEngine_ *engine);
+void engineAddImportPath(QQmlEngine_ *engine, const char *path, int pathLen);
+void engineClearPluginPaths(QQmlEngine_ *engine);
+void engineAddPluginPath(QQmlEngine_ *engine, const char *path, int pathLen);
+void engineClearComponentCache(QQmlEngine_ *engine);
+void coreAddLibraryPath(const char *path, int pathLen);
 
 void contextGetProperty(QQmlContext_ *context, QString_ *name, DataValue *value);
 void contextSetProperty(QQmlContext_ *context, QString_ *name, DataValue *value);

datatype.go

@@ -162,10 +162,7 @@ func unpackDataValue(dvalue *C.DataValue, engine *Engine) interface{} {
 		return nil
 	case C.DTObject:
 		// TODO Would be good to preserve identity on the Go side. See initGoType as well.
-		obj := &Common{
-			engine: engine,
-			addr:   *(*unsafe.Pointer)(datap),
-		}
+		obj := CommonOf(*(*unsafe.Pointer)(datap), engine)
 		if len(converters) > 0 {
 			// TODO Embed the type name in DataValue to drop these calls.
 			typeName := obj.TypeName()