Port print_native_word, begin converting mem to use node structs instead of raw offsets

Author: CraftSpider

crates/engine_xetex/src/c_api/engine.rs

@@ -33,6 +33,11 @@ pub struct EngineCtx {
     pub(crate) mem: Vec<MemoryWord>,
 }
 
+struct NodeError {
+    ty: u16,
+    subty: u16,
+}
+
 impl EngineCtx {
     fn new() -> EngineCtx {
         EngineCtx {
@@ -49,6 +54,36 @@ impl EngineCtx {
         }
     }
 
+    pub fn try_node<T: ?Sized + Node>(&self, idx: usize) -> Result<&T, NodeError> {
+        let ptr = self.mem.as_ptr().wrapping_add(idx);
+        let base = unsafe { &*NodeBase::from_ptr(ptr) };
+
+        if T::ty() != base.ty() || T::subty() != base.subty() {
+            return Err(NodeError {
+                ty: base.ty(),
+                subty: base.subty(),
+            });
+        }
+
+        let ptr = unsafe { T::from_ptr(ptr) };
+        Ok(unsafe { &*ptr })
+    }
+
+    pub fn node<T: ?Sized + Node>(&self, idx: usize) -> &T {
+        match self.try_node::<T>(idx) {
+            Ok(node) => node,
+            Err(e) => {
+                panic!(
+                    "Invalid node type. expected {}:{}, found {}:{}",
+                    e.ty,
+                    e.subty,
+                    T::ty(),
+                    T::subty(),
+                );
+            }
+        }
+    }
+
     pub fn int_par(&self, par: IntPar) -> i32 {
         unsafe { self.eqtb[INT_BASE + par as usize].b32.s1 }
     }

crates/engine_xetex/src/c_api/engine/memory.rs

@@ -31,6 +31,8 @@
  *
  */
 
+use std::{fmt, ptr};
+
 #[cfg(target_endian = "big")]
 mod data {
     #[derive(Copy, Clone)]
@@ -80,6 +82,40 @@ pub union MemoryWord {
     pub(crate) ptr: *mut (),
 }
 
+impl MemoryWord {
+    pub fn i32_0(&self) -> i32 {
+        unsafe { self.b32.s0 }
+    }
+
+    pub fn i32_1(&self) -> i32 {
+        unsafe { self.b32.s1 }
+    }
+
+    pub fn u16_0(&self) -> u16 {
+        unsafe { self.b16.s0 }
+    }
+
+    pub fn u16_1(&self) -> u16 {
+        unsafe { self.b16.s1 }
+    }
+
+    pub fn u16_2(&self) -> u16 {
+        unsafe { self.b16.s2 }
+    }
+
+    pub fn u16_3(&self) -> u16 {
+        unsafe { self.b16.s3 }
+    }
+
+    pub fn f64(&self) -> f64 {
+        unsafe { self.gr }
+    }
+
+    pub fn ptr(&self) -> *mut () {
+        unsafe { self.ptr }
+    }
+}
+
 /* ## THE ORIGINAL SITUATION (archived for posterity)
  *
  * In XeTeX, a "quarterword" is 16 bits. Who knows why. A "halfword" is,
@@ -172,6 +208,96 @@ pub union MemoryWord {
  *
  */
 
+/* Types of nodes that can occur in general lists. */
+pub const WHATSIT_NODE: u16 = 8;
+
+/* Subtypes for whatsit nodes. */
+pub const NATIVE_WORD_NODE: u16 = 40;
+
+pub trait Node {
+    fn ty() -> u16;
+    fn subty() -> u16;
+
+    unsafe fn from_ptr(ptr: *const MemoryWord) -> *const Self;
+    unsafe fn from_ptr_mut(ptr: *mut MemoryWord) -> *mut Self;
+}
+
+#[repr(C)]
+pub struct NodeBase(B16x4);
+
+impl NodeBase {
+    pub(super) fn from_ptr(ptr: *const MemoryWord) -> *const NodeBase {
+        ptr.cast()
+    }
+
+    pub fn ty(&self) -> u16 {
+        self.0.s1
+    }
+
+    pub fn subty(&self) -> u16 {
+        self.0.s0
+    }
+}
+
+impl fmt::Debug for NodeBase {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("NodeBase")
+            .field("ty", &self.ty())
+            .field("subty", &self.subty())
+            .finish()
+    }
+}
+
+#[repr(C)]
+pub struct NativeWordNode {
+    // p
+    node: NodeBase,
+    // p + 1..p + 3
+    _priv: [MemoryWord; 3],
+    // p + 4 - most data is here
+    data: B16x4,
+    // p + 5 - glyph_info pointer
+    glyph_info: *mut (),
+    // p+6.. - text in this node
+    text: [u16],
+}
+
+impl Node for NativeWordNode {
+    fn ty() -> u16 {
+        WHATSIT_NODE
+    }
+
+    fn subty() -> u16 {
+        NATIVE_WORD_NODE
+    }
+
+    unsafe fn from_ptr(ptr: *const MemoryWord) -> *const Self {
+        let this = ptr::slice_from_raw_parts(ptr, 0) as *const Self;
+        let len = (*this).size();
+        ptr::slice_from_raw_parts(ptr, len) as *const Self
+    }
+
+    unsafe fn from_ptr_mut(ptr: *mut MemoryWord) -> *mut Self {
+        let this = ptr::slice_from_raw_parts_mut(ptr, 0) as *mut Self;
+        let len = (*this).size();
+        ptr::slice_from_raw_parts_mut(ptr, len) as *mut Self
+    }
+}
+
+impl NativeWordNode {
+    pub fn base(&self) -> &NodeBase {
+        &self.node
+    }
+
+    pub fn size(&self) -> usize {
+        self.data.s3 as usize
+    }
+
+    pub fn text(&self) -> &[u16] {
+        &self.text
+    }
+}
+
 pub const EQTB_SIZE: usize = 0x886f92;
 
 pub const ACTIVE_BASE: usize = 0x1;

crates/engine_xetex/src/c_api/output.rs

@@ -1,6 +1,7 @@
 use crate::c_api::engine::{
-    rs_gettexstring, CatCode, IntPar, Selector, ACTIVE_BASE, EQTB_SIZE, FROZEN_NULL_FONT, NULL_CS,
-    PRIM_EQTB_BASE, SCRIPT_SIZE, SINGLE_BASE, TEXT_SIZE, UNDEFINED_CONTROL_SEQUENCE,
+    rs_gettexstring, CatCode, IntPar, NativeWordNode, Selector, ACTIVE_BASE, EQTB_SIZE,
+    FROZEN_NULL_FONT, NULL_CS, PRIM_EQTB_BASE, SCRIPT_SIZE, SINGLE_BASE, TEXT_SIZE,
+    UNDEFINED_CONTROL_SEQUENCE,
 };
 use crate::c_api::globals::Globals;
 use crate::c_api::hash::HASH_BASE;
@@ -802,3 +803,57 @@ pub fn rs_print_size(globals: &mut Globals<'_, '_>, s: i32) {
 pub extern "C" fn print_size(s: i32) {
     Globals::with(|globals| rs_print_size(globals, s))
 }
+
+pub fn rs_print_write_whatsit(globals: &mut Globals<'_, '_>, s: &[u8], p: i32) {
+    rs_print_esc_bytes(globals, s);
+    let p = p as usize;
+
+    let val = globals.engine.mem[p + 1].i32_0();
+    if val < 16 {
+        rs_print_int(globals, val)
+    } else if val == 16 {
+        rs_print_char(globals, '*' as i32);
+    } else {
+        rs_print_char(globals, '-' as i32);
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn print_write_whatsit(s: *const libc::c_char, p: i32) {
+    let s = unsafe { CStr::from_ptr(s) }.to_bytes();
+    Globals::with(|globals| rs_print_write_whatsit(globals, s, p))
+}
+
+pub fn rs_print_native_word(globals: &mut Globals<'_, '_>, p: i32) {
+    let p = p as usize;
+    let size = globals.engine.node::<NativeWordNode>(p).size();
+    let mut skip = false;
+    for i in 0..size {
+        if skip {
+            skip = false;
+            continue;
+        }
+
+        let node = globals.engine.node::<NativeWordNode>(p);
+        let c = node.text()[i];
+        if c >= 0xD800 && c < 0xDC00 {
+            if i < size - 1 {
+                let cc = node.text()[i + 1];
+                if cc >= 0xDC00 && cc < 0xE000 {
+                    let c = 0x10000 + (c as i32 - 0xD800) * 1024 + (cc as i32 - 0xDC00);
+                    rs_print_char(globals, c);
+                    skip = true;
+                }
+            } else {
+                rs_print(globals, '.' as i32);
+            }
+        } else {
+            rs_print_char(globals, c as i32);
+        }
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn print_native_word(p: i32) {
+    Globals::with(|globals| rs_print_native_word(globals, p))
+}

crates/engine_xetex/xetex/xetex-output.c

@@ -9,45 +9,6 @@
 #include "tectonic_bridge_core.h"
 #include "xetex_bindings.h"
 
-void
-print_write_whatsit(const char* s, int32_t p)
-{
-
-    print_esc_cstr(s);
-
-    if (mem(p + 1).b32.s0 < 16)
-        print_int(mem(p + 1).b32.s0);
-    else if (mem(p + 1).b32.s0 == 16)
-        print_char('*');
-    else
-        print_char('-');
-}
-
-
-void
-print_native_word(int32_t p)
-{
-    int32_t i, c, cc;
-    int32_t for_end = mem(p + 4).b16.s1 - 1;
-
-    for (i = 0; i <= for_end; i++) {
-        c = NATIVE_NODE_text(p)[i];
-        if ((c >= 0xD800) && (c < 0xDC00)) {
-            if (i < mem(p + 4).b16.s1 - 1) {
-                cc = NATIVE_NODE_text(p)[i + 1];
-                if ((cc >= 0xDC00) && (cc < 0xE000)) {
-                    c = 0x10000 + (c - 0xD800) * 1024 + (cc - 0xDC00);
-                    print_char(c);
-                    i++;
-                } else
-                    print('.');
-            } else
-                print('.');
-        } else
-            print_char(c);
-    }
-}
-
 
 void
 print_sa_num(int32_t q)

crates/engine_xetex/xetex/xetex_bindings.h

@@ -32,6 +32,8 @@
 
 #define SCRIPT_SCRIPT_SIZE 512
 
+#define NATIVE_NODE_SIZE 6
+
 #define EQTB_SIZE 8941458
 
 #define ACTIVE_BASE 1
@@ -280,6 +282,10 @@ void print_file_name(int32_t n, int32_t a, int32_t e);
 
 void print_size(int32_t s);
 
+void print_write_whatsit(const char *s, int32_t p);
+
+void print_native_word(int32_t p);
+
 void resize_str_pool(uintptr_t size);
 
 void clear_str_pool(void);