From 766f9ed028c757561b99e4ed5aa487d381fe80a3 Mon Sep 17 00:00:00 2001
From: Pietro Gagliardi <pietro10@mac.com>
Date: Sun, 26 Aug 2018 10:19:10 -0400
Subject: [PATCH] Migrated util.go and main.go to the new pkgui convention and
 C file. Also replaced C.CBytes() with C.malloc() (this bumps our minimum
 version requirement to 1.8, but it's better than keeping a massive slice
 around at all times).

---
 BBB_GOFILES/util.go            | 45 ----------------------------------
 BBB_GOFILES/main.go => main.go | 25 ++++++++-----------
 pkgui.c                        | 23 +++++++++++++++++
 pkgui.h                        |  9 +++++++
 util.go                        | 31 +++++++++++++++++++++++
 util.h                         |  3 ---
 6 files changed, 73 insertions(+), 63 deletions(-)
 delete mode 100644 BBB_GOFILES/util.go
 rename BBB_GOFILES/main.go => main.go (85%)
 create mode 100644 pkgui.c
 create mode 100644 pkgui.h
 create mode 100644 util.go
 delete mode 100644 util.h

diff --git a/BBB_GOFILES/util.go b/BBB_GOFILES/util.go
deleted file mode 100644
index bcd4d33..0000000
--- a/BBB_GOFILES/util.go
+++ /dev/null
@@ -1,45 +0,0 @@
-// 12 december 2015
-
-package ui
-
-import (
-	"unsafe"
-)
-
-// #include <stdlib.h>
-// #include "util.h"
-import "C"
-
-// We want Go itself to complain when we're out of memory.
-// The allocators in cgo *should* do this, but there isn't a
-// C.CMalloc(). There *is* a C.CBytes(), however, for transferring
-// binary blobs from Go to C. If we pass this an arbitrary slice
-// of the desired length, we get our C.CMalloc(). Using a slice
-// that's always initialized to zero gives us the memset(0)
-// (or ZeroMemory()) for free.
-var allocBytes = make([]byte, 1024)		// 1024 bytes first
-
-//export pkguiAlloc
-func pkguiAlloc(n C.size_t) unsafe.Pointer {
-	if n > C.size_t(len(allocBytes)) {
-		// TODO round n up to a multiple of a power of 2?
-		// for instance 0x1234 bytes -> 0x1800 bytes
-		allocBytes = make([]byte, n)
-	}
-	return C.CBytes(allocBytes[:n])
-}
-
-func freestr(str *C.char) {
-	C.free(unsafe.Pointer(str))
-}
-
-func tobool(b C.int) bool {
-	return b != 0
-}
-
-func frombool(b bool) C.int {
-	if b {
-		return 1
-	}
-	return 0
-}
diff --git a/BBB_GOFILES/main.go b/main.go
similarity index 85%
rename from BBB_GOFILES/main.go
rename to main.go
index 6500345..356e0e8 100644
--- a/BBB_GOFILES/main.go
+++ b/main.go
@@ -9,12 +9,7 @@ import (
 	"unsafe"
 )
 
-// #include "ui.h"
-// extern void doQueueMain(void *);
-// extern int doOnShouldQuit(void *);
-// // see golang/go#19835
-// typedef void (*queueMainCallback)(void *);
-// typedef int (*onShouldQuitCallback)(void *);
+// #include "pkgui.h"
 import "C"
 
 // make sure main() runs on the first thread created by the OS
@@ -33,15 +28,15 @@ func init() {
 // nil. If package ui fails to initialize, Main returns an appropriate
 // error.
 func Main(f func()) error {
-	// TODO HEAP SAFETY
-	opts := C.uiInitOptions{}
-	estr := C.uiInit(&opts)
+	opts := C.pkguiAllocInitOptions()
+	estr := C.uiInit(opts)
+	C.pkguiFreeInitOptions(opts)
 	if estr != nil {
 		err := errors.New(C.GoString(estr))
 		C.uiFreeInitError(estr)
 		return err
 	}
-	C.uiOnShouldQuit(C.onShouldQuitCallback(C.doOnShouldQuit), nil)
+	C.pkguiOnShouldQuit()
 	QueueMain(f)
 	C.uiMain()
 	return nil
@@ -90,11 +85,11 @@ func QueueMain(f func()) {
 		}
 	}
 	qmmap[n] = f
-	C.uiQueueMain(C.queueMainCallback(C.doQueueMain), unsafe.Pointer(n))
+	C.pkguiQueueMain(C.uintptr_t(n))
 }
 
-//export doQueueMain
-func doQueueMain(nn unsafe.Pointer) {
+//export pkguiDoQueueMain
+func pkguiDoQueueMain(nn unsafe.Pointer) {
 	qmlock.Lock()
 
 	n := uintptr(nn)
@@ -121,8 +116,8 @@ func OnShouldQuit(f func() bool) {
 	shouldQuitFunc = f
 }
 
-//export doOnShouldQuit
-func doOnShouldQuit(unused unsafe.Pointer) C.int {
+//export pkguiDoOnShouldQuit
+func pkguiDoOnShouldQuit(unused unsafe.Pointer) C.int {
 	if shouldQuitFunc == nil {
 		return 0
 	}
diff --git a/pkgui.c b/pkgui.c
new file mode 100644
index 0000000..7caab2c
--- /dev/null
+++ b/pkgui.c
@@ -0,0 +1,23 @@
+// 26 august 2018
+#include "pkgui.h"
+#include "xxxxx"
+
+uiInitOptions *pkguiAllocInitOptions(void)
+{
+	return (uiInitOptions *) pkguiAlloc(sizeof (uiInitOptions));
+}
+
+void pkguiFreeInitOptions(uiInitOptions *o)
+{
+	free(o);
+}
+
+void pkguiQueueMain(uintptr_t n)
+{
+	uiQueueMain(pkguiDoQueueMain, (void *) n);
+}
+
+void pkguiOnShouldQuit(void)
+{
+	uiOnShouldQuit(pkguiDoOnShouldQuit, NULL);
+}
diff --git a/pkgui.h b/pkgui.h
new file mode 100644
index 0000000..2af5f2b
--- /dev/null
+++ b/pkgui.h
@@ -0,0 +1,9 @@
+// 12 august 2018
+#include <stdio.h>
+#include "ui.h"
+
+// main.go
+extern uiInitOptions *pkguiAllocInitOptions(void);
+extern void pkguiFreeInitOptions(uiInitOptions *o);
+extern void pkguiQueueMain(uintptr_t n);
+extern void pkguiOnShouldQuit(void);
diff --git a/util.go b/util.go
new file mode 100644
index 0000000..667f679
--- /dev/null
+++ b/util.go
@@ -0,0 +1,31 @@
+// 12 december 2015
+
+package ui
+
+import (
+	"unsafe"
+)
+
+// #include "pkgui.h"
+import "C"
+
+//export pkguiAlloc
+func pkguiAlloc(n C.size_t) unsafe.Pointer {
+	// cgo turns C.malloc() into a panic-on-OOM version; use it
+	return C.malloc(n)
+}
+
+func freestr(str *C.char) {
+	C.free(unsafe.Pointer(str))
+}
+
+func tobool(b C.int) bool {
+	return b != 0
+}
+
+func frombool(b bool) C.int {
+	if b {
+		return 1
+	}
+	return 0
+}
diff --git a/util.h b/util.h
deleted file mode 100644
index 3354234..0000000
--- a/util.h
+++ /dev/null
@@ -1,3 +0,0 @@
-// 12 august 2018
-
-extern void *pkguiAlloc(size_t);