Don't pass go pointers to C

For go 1.6. Fixes #31.

Author: ry

Makefile

@@ -1,17 +1,16 @@
 version?=4.3.59
 target?=native # available: x64.debug, ia32.debug, ia32.release, x64.release
 
+test: v8worker.test
+	./v8worker.test
+
 v8.pc: v8
 	target=$(target) ./build.sh
 
 v8:
 	fetch --nohooks v8
 	cd v8 && git checkout $(version) && gclient sync
 
-test: v8worker.test
-	./v8worker.test
-
-
 v8worker.test: v8.pc *.go *.cc *.h
 	go test -c
 

binding.cc

@@ -11,7 +11,7 @@ using namespace v8;
 
 struct worker_s {
   int x;
-  void* data;
+  int table_index;
   worker_recv_cb cb;
   worker_recv_sync_cb sync_cb;
   Isolate* isolate;
@@ -100,12 +100,12 @@ std::string ExceptionString(Isolate* isolate, TryCatch* try_catch) {
 extern "C" {
 #include "_cgo_export.h"
 
-void go_recv_cb(const char* msg, void* data) {
-  recvCb((char*)msg, data);
+void go_recv_cb(const char* msg, int table_index) {
+  recvCb((char*)msg, table_index);
 }
 
-const char* go_recv_sync_cb(const char* msg, void* data) {
-  return recvSyncCb((char*)msg, data);
+const char* go_recv_sync_cb(const char* msg, int table_index) {
+  return recvSyncCb((char*)msg, table_index);
 }
 
 const char* worker_version() {
@@ -225,7 +225,7 @@ void Send(const FunctionCallbackInfo<Value>& args) {
   }
 
   // XXX should we use Unlocker?
-  w->cb(msg.c_str(), w->data);
+  w->cb(msg.c_str(), w->table_index);
 }
 
 // Called from javascript using $request.
@@ -250,7 +250,7 @@ void SendSync(const FunctionCallbackInfo<Value>& args) {
     String::Utf8Value str(v);
     msg = ToCString(str);
   }
-  const char* returnMsg = w->sync_cb(msg.c_str(), w->data);
+  const char* returnMsg = w->sync_cb(msg.c_str(), w->table_index);
   Local<String> returnV = String::NewFromUtf8(w->isolate, returnMsg);
   args.GetReturnValue().Set(returnV);
 }
@@ -329,7 +329,7 @@ void v8_init() {
   V8::SetArrayBufferAllocator(&array_buffer_allocator);
 }
 
-worker* worker_new(worker_recv_cb cb, worker_recv_sync_cb sync_cb, void* data) {
+worker* worker_new(worker_recv_cb cb, worker_recv_sync_cb sync_cb, int table_index) {
   Isolate* isolate = Isolate::New();
   Locker locker(isolate);
   Isolate::Scope isolate_scope(isolate);
@@ -339,7 +339,7 @@ worker* worker_new(worker_recv_cb cb, worker_recv_sync_cb sync_cb, void* data) {
   w->isolate = isolate;
   w->isolate->SetCaptureStackTraceForUncaughtExceptions(true);
   w->isolate->SetData(0, w);
-  w->data = data;
+  w->table_index = table_index;
   w->cb = cb;
   w->sync_cb = sync_cb;
 

binding.h

@@ -3,19 +3,19 @@ extern "C" {
 #endif
 
 
-void go_recv_cb(const char* msg, void* data);
-const char* go_recv_sync_cb(const char* msg, void* data);
+void go_recv_cb(const char* msg, int table_index);
+const char* go_recv_sync_cb(const char* msg, int table_index);
 
 struct worker_s;
 typedef struct worker_s worker;
-typedef void (*worker_recv_cb)(const char* msg, void* data);
-typedef const char* (*worker_recv_sync_cb)(const char* msg, void* data);
+typedef void (*worker_recv_cb)(const char* msg, int table_index);
+typedef const char* (*worker_recv_sync_cb)(const char* msg, int table_index);
 
 const char* worker_version();
 
 void v8_init();
 
-worker* worker_new(worker_recv_cb cb, worker_recv_sync_cb sync_cb, void* data);
+worker* worker_new(worker_recv_cb cb, worker_recv_sync_cb sync_cb, int table_index);
 
 // returns nonzero on error
 // get error from worker_last_exception

worker.go

@@ -13,6 +13,17 @@ import "unsafe"
 import "sync"
 import "runtime"
 
+type workerTableIndex int
+
+var workerTableLock sync.Mutex
+
+// This table will store all pointers to all active workers. Because we can't safely
+// pass pointers to Go objects to C, we instead pass a key to this table.
+var workerTable = make(map[workerTableIndex]*Worker)
+
+// Keeps track of the last used table index. Incremeneted when a worker is created.
+var workerTableNextAvailable workerTableIndex = 0
+
 // To receive messages from javascript...
 type ReceiveMessageCallback func(msg string)
 
@@ -27,49 +38,65 @@ var initV8Once sync.Once
 
 // This is a golang wrapper around a single V8 Isolate.
 type Worker struct {
-	cWorker *C.worker
-	cb      ReceiveMessageCallback
-	sync_cb ReceiveSyncMessageCallback
+	cWorker    *C.worker
+	cb         ReceiveMessageCallback
+	sync_cb    ReceiveSyncMessageCallback
+	tableIndex workerTableIndex
 }
 
 // Return the V8 version E.G. "4.3.59"
 func Version() string {
 	return C.GoString(C.worker_version())
 }
 
+func workerTableLookup(index workerTableIndex) *Worker {
+	workerTableLock.Lock()
+	defer workerTableLock.Unlock()
+	return workerTable[index]
+}
+
 //export recvCb
-func recvCb(msg_s *C.char, ptr unsafe.Pointer) {
+func recvCb(msg_s *C.char, index workerTableIndex) {
 	msg := C.GoString(msg_s)
-	worker := (*Worker)(ptr)
+	worker := workerTableLookup(index)
 	worker.cb(msg)
 }
 
 //export recvSyncCb
-func recvSyncCb(msg_s *C.char, ptr unsafe.Pointer) *C.char {
+func recvSyncCb(msg_s *C.char, index workerTableIndex) *C.char {
 	msg := C.GoString(msg_s)
-	worker := (*Worker)(ptr)
+	worker := workerTableLookup(index)
 	return_s := C.CString(worker.sync_cb(msg))
 	return return_s
 }
 
 // Creates a new worker, which corresponds to a V8 isolate. A single threaded
 // standalone execution context.
 func New(cb ReceiveMessageCallback, sync_cb ReceiveSyncMessageCallback) *Worker {
+	workerTableLock.Lock()
 	worker := &Worker{
-		cb:      cb,
-		sync_cb: sync_cb,
+		cb:         cb,
+		sync_cb:    sync_cb,
+		tableIndex: workerTableNextAvailable,
 	}
 
+	workerTableNextAvailable++
+	workerTable[worker.tableIndex] = worker
+	workerTableLock.Unlock()
+
 	initV8Once.Do(func() {
 		C.v8_init()
 	})
 
 	callback := C.worker_recv_cb(C.go_recv_cb)
 	receiveSync_callback := C.worker_recv_sync_cb(C.go_recv_sync_cb)
 
-	worker.cWorker = C.worker_new(callback, receiveSync_callback, unsafe.Pointer(worker))
+	worker.cWorker = C.worker_new(callback, receiveSync_callback, C.int(worker.tableIndex))
 	runtime.SetFinalizer(worker, func(final_worker *Worker) {
-		C.worker_dispose(final_worker.cWorker) // Delete this worker on finalize (GC)
+		workerTableLock.Lock()
+		delete(workerTable, final_worker.tableIndex)
+		workerTableLock.Unlock()
+		C.worker_dispose(final_worker.cWorker)
 	})
 	return worker
 }