Making some progress integrating Remglk-rs into Emglken. DispatchRock…

… has to be a union, and because of the WASM ABI, it can't be returned from functions

Cargo.toml

@@ -7,4 +7,12 @@ members = [
 resolver = "2"
 
 [profile.release]
-lto = true
+lto = true
+
+[profile.dev-wasm]
+inherits = "dev"
+panic = "abort"
+
+[profile.release-wasm]
+inherits = "release"
+panic = "abort"

remglk/src/glkapi/mod.rs

@@ -213,13 +213,18 @@ where S: Default + GlkSystem {
  let update = self.update();
  self.system.send_glkote_update(update);
  let event = self.system.get_glkote_event();
- let res = self.handle_event(event)?;
- if let Some(fref) = res.fref {
- let (filename, fref) = match fref {
- FileRefResponse::String(filename) => (filename, None),
- FileRefResponse::Fref(fref) => (fref.filename.clone(), Some(fref)),
- };
- return Ok(Some(self.create_fileref(filename, rock, usage, fref)));
+ if let Some(event) = event {
+ let res = self.handle_event(event)?;
+ if let Some(fref) = res.fref {
+ let (filename, fref) = match fref {
+ FileRefResponse::String(filename) => (filename, None),
+ FileRefResponse::Fref(fref) => (fref.filename.clone(), Some(fref)),
+ };
+ return Ok(Some(self.create_fileref(filename, rock, usage, fref)));
+ }
+ }
+ else {
+ self.glk_exit();
  }
  Ok(None)
  }
@@ -455,7 +460,13 @@ where S: Default + GlkSystem {
  let update = self.update();
  self.system.send_glkote_update(update);
  let event = self.system.get_glkote_event();
- self.handle_event(event)
+ if let Some(event) = event {
+ self.handle_event(event)
+ }
+ else {
+ self.glk_exit();
+ Ok(GlkEvent::default())
+ }
  }
 
  pub fn glk_select_poll(&mut self) -> GlkEvent {
@@ -1019,7 +1030,12 @@ where S: Default + GlkSystem {
 
  pub fn get_glkote_init(&mut self) {
  let event = self.system.get_glkote_event();
- self.handle_event(event).unwrap();
+ if let Some(event) = event {
+ self.handle_event(event).unwrap();
+ }
+ else {
+ self.glk_exit();
+ }
  }
 
  pub fn handle_event(&mut self, mut event: Event) -> GlkResult<GlkEvent> {
@@ -1257,7 +1273,7 @@ where S: Default + GlkSystem {
  Ok(Some(str))
  }
 
- fn create_memory_stream<T>(&mut self, buf: Box<[T]>, fmode: FileMode, rock: u32, disprock: Option<DispatchRockPtr>) -> GlkResult<GlkStream>
+ fn create_memory_stream<T>(&mut self, buf: Box<[T]>, fmode: FileMode, rock: u32, disprock: Option<DispatchRock>) -> GlkResult<GlkStream>
  where Stream: From<ArrayBackedStream<T>> {
  if fmode == FileMode::WriteAppend {
  return Err(IllegalFilemode);
@@ -1545,14 +1561,14 @@ where S: Default + GlkSystem {
  Ok(())
  }
 
- pub fn retain_array(&self, buf: &GlkBuffer) -> DispatchRockPtr {
+ pub fn retain_array(&self, buf: &GlkBuffer) -> DispatchRock {
  match buf {
  GlkBuffer::U8(buf) => (self.retain_array_callbacks_u8.as_ref().unwrap().retain)(buf.as_ptr(), buf.len() as u32, "&+#!Cn".as_ptr()),
  GlkBuffer::U32(buf) => (self.retain_array_callbacks_u32.as_ref().unwrap().retain)(buf.as_ptr(), buf.len() as u32, "&+#!Iu".as_ptr()),
  }
  }
 
- pub fn unretain_array(&self, buf: GlkOwnedBuffer, disprock: DispatchRockPtr) {
+ pub fn unretain_array(&self, buf: GlkOwnedBuffer, disprock: DispatchRock) {
  let len = buf.len() as u32;
  match buf {
  GlkOwnedBuffer::U8(buf) => (self.retain_array_callbacks_u8.as_ref().unwrap().unretain)(Box::leak(buf).as_ptr(), len, "&+#!Cn".as_ptr(), disprock),
@@ -1593,8 +1609,8 @@ pub struct GlkDate {
 }
 
 // Retained array callbacks
-pub type RetainArrayCallback<T> = extern fn(*const T, u32, *const u8) -> DispatchRockPtr;
-pub type UnretainArrayCallback<T> = extern fn(*const T, u32, *const u8, DispatchRockPtr);
+pub type RetainArrayCallback<T> = extern fn(*const T, u32, *const u8) -> DispatchRock;
+pub type UnretainArrayCallback<T> = extern fn(*const T, u32, *const u8, DispatchRock);
 
 pub struct RetainArrayCallbacks<T> {
  pub retain: RetainArrayCallback<T>,
@@ -1708,7 +1724,7 @@ fn glkdate_to_datetime<T: TimeZone>(timezone: T, date: &GlkDate) -> DateTime<T>
  normalised_date = normalised_date.checked_add_months(chrono::Months::new(months as u32)).unwrap();
  }
  if months < 0 {
- normalised_date = normalised_date.checked_sub_months(chrono::Months::new(months as u32)).unwrap();
+ normalised_date = normalised_date.checked_sub_months(chrono::Months::new((-months) as u32)).unwrap();
  }
  let mut normalised_date = NaiveDateTime::from(normalised_date).and_utc();
  let duration = Duration::days(date.day as i64 - 1)

remglk/src/glkapi/objects.rs

@@ -196,8 +196,8 @@ where T: Default + GlkObjectClass, GlkObject<T>: Default + Eq {
 /** Contains the private metadata we keep in each object store */
 #[derive(Default)]
 pub struct GlkObjectMetadata<T> {
- pub array_disprock: Option<DispatchRockPtr>,
- pub disprock: Option<DispatchRockPtr>,
+ pub array_disprock: Option<DispatchRock>,
+ pub disprock: Option<DispatchRock>,
  /** The ID, used in the GlkOte protocol */
  pub id: u32,
  obj: T,
@@ -241,14 +241,20 @@ impl<T> DerefMut for GlkObjectMetadata<T> {
 /** A dispatch rock, which could be anything (*not* the same as a normal Glk rock) */
 // See for explanation https://stackoverflow.com/a/38315613/2854284
 #[repr(C)]
-pub struct DispatchRock {
+pub struct DispatchRockPtr {
  _data: [u8; 0],
  _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
 }
-pub type DispatchRockPtr = *const DispatchRock;
 
-pub type DispatchRegisterCallback<T> = fn(*const Mutex<GlkObjectMetadata<T>>, u32) -> DispatchRockPtr;
-pub type DispatchUnregisterCallback<T> = fn(*const Mutex<GlkObjectMetadata<T>>, u32, DispatchRockPtr);
+#[derive(Clone, Copy)]
+#[repr(C)]
+pub union DispatchRock {
+ num: u32,
+ ptr: *const DispatchRockPtr,
+}
+
+pub type DispatchRegisterCallback<T> = fn(*const Mutex<GlkObjectMetadata<T>>, u32) -> DispatchRock;
+pub type DispatchUnregisterCallback<T> = fn(*const Mutex<GlkObjectMetadata<T>>, u32, DispatchRock);
 
 pub trait GlkObjectClass {
  fn get_object_class_id() -> u32;

remglk/src/lib.rs

@@ -29,5 +29,5 @@ pub trait GlkSystem {
  /** Send an update to GlkOte */
  fn send_glkote_update(&mut self, update: Update);
  /** Get an event from GlkOte */
- fn get_glkote_event(&mut self) -> Event;
+ fn get_glkote_event(&mut self) -> Option<Event>;
 }

remglk_capi/Cargo.toml

@@ -17,12 +17,12 @@ crate-type=["staticlib"]
 
 [dependencies]
 remglk = {path = "../remglk", version = "0.1.0"}
-serde = {version = "1.0"}
+serde = "1.0"
 serde_json = "1.0"
 thiserror = "1.0.40"
 widestring = "1.0.2"
 
-[target.'cfg(emscripten)'.dependencies]
+[target.'cfg(target_os = "emscripten")'.dependencies]
 emscripten_em_js = {path = "../emscripten_em_js", version = "0.1.0"}
 
 [build-dependencies]

remglk_capi/src/dispatch.rs

@@ -19,8 +19,8 @@ use super::*;
 use common::*;
 use glkapi::*;
 
-type RegisterCallbackGeneric = extern fn(*const c_void, u32) -> DispatchRockPtr;
-type UnregisterCallbackGeneric = extern fn(*const c_void, u32, DispatchRockPtr);
+type RegisterCallbackGeneric = extern fn(*const c_void, u32) -> DispatchRock;
+type UnregisterCallbackGeneric = extern fn(*const c_void, u32, DispatchRock);
 
 #[no_mangle]
 pub unsafe extern "C" fn gidispatch_set_object_registry(register_cb: RegisterCallbackGeneric, unregister_cb: UnregisterCallbackGeneric) {
@@ -37,29 +37,30 @@ pub unsafe extern "C" fn gidispatch_set_object_registry(register_cb: RegisterCal
 }
 
 // The C function `gidispatch_get_objrock` takes a generic pointer, which we can't really deal with here in Rust, so support.c will handle calling the appropriate function
+// The WASM ABI means that we can't return a DispatchRock, so it must be set through an out parameter
 #[no_mangle]
-pub extern "C" fn gidispatch_get_objrock_fileref(ptr: FileRefPtr) -> DispatchRockPtr {
+pub extern "C" fn gidispatch_get_objrock_fileref(ptr: FileRefPtr, dispatchrock_ptr: *mut DispatchRock) {
  let obj = from_ptr(ptr);
  let obj = obj.lock().unwrap();
- obj.disprock.unwrap()
+ write_ptr(dispatchrock_ptr, obj.disprock.unwrap());
 }
 
 #[no_mangle]
-pub extern "C" fn gidispatch_get_objrock_stream(ptr: StreamPtr) -> DispatchRockPtr {
+pub extern "C" fn gidispatch_get_objrock_stream(ptr: StreamPtr, dispatchrock_ptr: *mut DispatchRock) {
  let obj = from_ptr(ptr);
  let obj = obj.lock().unwrap();
- obj.disprock.unwrap()
+ write_ptr(dispatchrock_ptr, obj.disprock.unwrap());
 }
 
 #[no_mangle]
-pub extern "C" fn gidispatch_get_objrock_window(ptr: WindowPtr) -> DispatchRockPtr {
+pub extern "C" fn gidispatch_get_objrock_window(ptr: WindowPtr, dispatchrock_ptr: *mut DispatchRock) {
  let obj = from_ptr(ptr);
  let obj = obj.lock().unwrap();
- obj.disprock.unwrap()
+ write_ptr(dispatchrock_ptr, obj.disprock.unwrap());
 }
 
-type RetainArrayCallbackGeneric = extern fn(*const c_void, u32, *const c_char) -> DispatchRockPtr;
-type UnretainArrayCallbackGeneric = extern fn(*const c_void, u32, *const c_char, DispatchRockPtr);
+type RetainArrayCallbackGeneric = extern fn(*const c_void, u32, *const c_char) -> DispatchRock;
+type UnretainArrayCallbackGeneric = extern fn(*const c_void, u32, *const c_char, DispatchRock);
 
 #[no_mangle]
 pub unsafe extern "C" fn gidispatch_set_retained_registry(register_cb: RetainArrayCallbackGeneric, unregister_cb: UnretainArrayCallbackGeneric) {

remglk_capi/src/glk/support.c

@@ -14,13 +14,19 @@ MIT licenced
 #include "support.h"
 
 gidispatch_rock_t gidispatch_get_objrock(void *obj, glui32 objclass) {
+ gidispatch_rock_t rock;
  switch (objclass) {
  case gidisp_Class_Fileref:
- return gidispatch_get_objrock_fileref(obj);
+ gidispatch_get_objrock_fileref(obj, &rock);
+ return rock;
  case gidisp_Class_Stream:
- return gidispatch_get_objrock_stream(obj);
+ gidispatch_get_objrock_stream(obj, &rock);
+ return rock;
  case gidisp_Class_Window:
- return gidispatch_get_objrock_window(obj);
+ gidispatch_get_objrock_window(obj, &rock);
+ return rock;
+ default:
+ __builtin_unreachable();
  }
 }
 

remglk_capi/src/glk/support.h

@@ -4,9 +4,9 @@
 #include "gi_dispa.h"
 #include "glkstart.h"
 
-extern gidispatch_rock_t gidispatch_get_objrock_fileref(void *obj);
-extern gidispatch_rock_t gidispatch_get_objrock_stream(void *obj);
-extern gidispatch_rock_t gidispatch_get_objrock_window(void *obj);
+extern void gidispatch_get_objrock_fileref(void *obj, gidispatch_rock_t *rock_ptr);
+extern void gidispatch_get_objrock_stream(void *obj, gidispatch_rock_t *rock_ptr);
+extern void gidispatch_get_objrock_window(void *obj, gidispatch_rock_t *rock_ptr);
 
 glkunix_argumentlist_t *glkunix_arguments_addr(void);
 

remglk_capi/src/systems/emglken.rs

@@ -10,12 +10,8 @@ https://github.com/curiousdannii/remglk-rs
 */
 
 use std::collections::HashMap;
-use std::env::temp_dir;
-use std::fs;
-use std::io::{self, BufRead};
-use std::path::Path;
 
-use emscripten_em_js::em_js;
+//use emscripten_em_js::em_js;
 
 use super::*;
 use remglk::GlkSystem;
@@ -32,8 +28,7 @@ pub fn glkapi() -> &'static Mutex<GlkApi> {
 
 #[derive(Default)]
 pub struct EmglkenSystem {
- cache: HashMap<String, Box<[u8]>>,
- tempfile_counter: u32,
+ _cache: HashMap<String, Box<[u8]>>,
 }
 
 impl GlkSystem for EmglkenSystem {
@@ -46,35 +41,35 @@ impl GlkSystem for EmglkenSystem {
  }
  }
 
- fn fileref_delete(&mut self, fileref: &SystemFileRef) {
+ fn fileref_delete(&mut self, _fileref: &SystemFileRef) {
  unimplemented!()
  }
 
- fn fileref_exists(&mut self, fileref: &SystemFileRef) -> bool {
+ fn fileref_exists(&mut self, _fileref: &SystemFileRef) -> bool {
  unimplemented!()
  }
 
- fn fileref_read(&mut self, fileref: &SystemFileRef) -> Option<Box<[u8]>> {
+ fn fileref_read(&mut self, _fileref: &SystemFileRef) -> Option<Box<[u8]>> {
  unimplemented!()
  }
 
- fn fileref_temporary(&mut self, filetype: FileType) -> SystemFileRef {
+ fn fileref_temporary(&mut self, _filetype: FileType) -> SystemFileRef {
  unimplemented!()
  }
 
- fn fileref_write_buffer(&mut self, fileref: &SystemFileRef, buf: Box<[u8]>) {
+ fn fileref_write_buffer(&mut self, _fileref: &SystemFileRef, _buf: Box<[u8]>) {
  unimplemented!()
  }
 
  fn flush_writeable_files(&mut self) {
  unimplemented!()
  }
 
- fn get_glkote_event(&mut self) -> Event {
+ fn get_glkote_event(&mut self) -> Option<Event> {
  unimplemented!()
  }
 
- fn send_glkote_update(&mut self, update: Update) {
+ fn send_glkote_update(&mut self, _update: Update) {
  unimplemented!()
  }
 }

remglk_capi/src/systems/standard.rs

@@ -85,7 +85,7 @@ impl GlkSystem for StandardSystem {
  self.cache.shrink_to(4);
  }
 
- fn get_glkote_event(&mut self) -> Event {
+ fn get_glkote_event(&mut self) -> Option<Event> {
  // Read a line from stdin
  let stdin = io::stdin();
  for line in stdin.lock().lines() {
@@ -94,9 +94,9 @@ impl GlkSystem for StandardSystem {
  continue;
  }
  let event: Event = serde_json::from_str(&data).unwrap();
- return event;
+ return Some(event);
  }
- unreachable!()
+ None
  }
 
  fn send_glkote_update(&mut self, update: Update) {