Port engine_xetex to Rust

crates/bridge_core/src/lib.rs

@@ -746,6 +746,12 @@ impl<'a> CoreBridgeState<'a> {
             true
         }
     }
+
+    /// Finish and emit a diagnostic
+    pub fn finish_diagnostic(&mut self, diag: Diagnostic) {
+        self.status
+            .report(diag.kind, format_args!("{}", diag.message), None);
+    }
 }
 
 /// A type for storing settings about potentially insecure engine features.
@@ -1250,23 +1256,45 @@ pub struct Diagnostic {
     kind: MessageKind,
 }
 
+impl Diagnostic {
+    /// Create a new diagnostic that will be reported as an error.
+    pub fn error() -> Diagnostic {
+        Diagnostic {
+            message: String::new(),
+            kind: MessageKind::Error,
+        }
+    }
+
+    /// Create a new diagnostic that will be reported as a warning.
+    pub fn warning() -> Diagnostic {
+        Diagnostic {
+            message: String::new(),
+            kind: MessageKind::Warning,
+        }
+    }
+
+    /// Append text to a diagnostic.
+    pub fn append(&mut self, msg: impl AsRef<str>) {
+        self.message.push_str(msg.as_ref());
+    }
+
+    /// Append a single character to a diagnostic
+    pub fn append_char(&mut self, c: char) {
+        self.message.push(c);
+    }
+}
+
 /// Create a new diagnostic that will be reported as a warning.
 #[no_mangle]
 pub extern "C" fn ttbc_diag_begin_warning() -> *mut Diagnostic {
-    let warning = Box::new(Diagnostic {
-        message: String::new(),
-        kind: MessageKind::Warning,
-    });
+    let warning = Box::new(Diagnostic::error());
     Box::into_raw(warning)
 }
 
 /// Create a new diagnostic that will be reported as an error.
 #[no_mangle]
 pub extern "C" fn ttbc_diag_begin_error() -> *mut Diagnostic {
-    let warning = Box::new(Diagnostic {
-        message: String::new(),
-        kind: MessageKind::Error,
-    });
+    let warning = Box::new(Diagnostic::error());
     Box::into_raw(warning)
 }
 
@@ -1278,7 +1306,7 @@ pub extern "C" fn ttbc_diag_begin_error() -> *mut Diagnostic {
 #[no_mangle]
 pub unsafe extern "C" fn ttbc_diag_append(diag: &mut Diagnostic, text: *const libc::c_char) {
     let rtext = CStr::from_ptr(text);
-    diag.message.push_str(&rtext.to_string_lossy());
+    diag.append(rtext.to_string_lossy());
 }
 
 /// "Finish" a diagnostic: report it to the driver and free the diagnostic object.
@@ -1290,8 +1318,7 @@ pub unsafe extern "C" fn ttbc_diag_append(diag: &mut Diagnostic, text: *const li
 pub unsafe extern "C" fn ttbc_diag_finish(es: &mut CoreBridgeState, diag: *mut Diagnostic) {
     // By creating the box, we will free the diagnostic when this function exits.
     let rdiag = Box::from_raw(diag);
-    es.status
-        .report(rdiag.kind, format_args!("{}", rdiag.message), None);
+    es.finish_diagnostic(*rdiag);
 }
 
 /// Run a shell command

crates/engine_xetex/build.rs

@@ -196,7 +196,6 @@ const C_FILES: &[&str] = &[
     "xetex/xetex-io.c",
     "xetex/xetex-linebreak.c",
     "xetex/xetex-math.c",
-    "xetex/xetex-output.c",
     "xetex/xetex-pagebuilder.c",
     "xetex/xetex-pic.c",
     "xetex/xetex-scaledmath.c",

crates/engine_xetex/cbindgen.toml

@@ -5,6 +5,16 @@ include_guard = "TECTONIC_ENGINE_XETEX_BINDGEN_H"
 
 [export.rename]
 "CoreBridgeState" = "ttbc_state_t"
+"Diagnostic" = "ttbc_diagnostic_t"
+"FileFormat" = "ttbc_file_format"
+"OutputId" = "rust_output_handle_t"
+"InputState" = "input_state_t"
+
+[export]
+exclude = ["Option_OutputId", "Option_InputId"]
+
+[defines]
+"target_endian = big" = "WORDS_BIGENDIAN"
 
 [enum]
 prefix_with_name = true

crates/engine_xetex/src/c_api/dvi.rs

@@ -0,0 +1,104 @@
+use std::cell::RefCell;
+use std::ptr;
+use tectonic_bridge_core::OutputId;
+
+thread_local! {
+    pub static DVI_CTX: RefCell<DviCtx> = const { RefCell::new(DviCtx::new()) }
+}
+
+pub struct DviCtx {
+    file: Option<OutputId>,
+    limit: i32,
+    ptr: i32,
+    offset: i32,
+    gone: i32,
+    buf: Vec<u8>,
+}
+
+impl DviCtx {
+    const fn new() -> DviCtx {
+        DviCtx {
+            file: None,
+            limit: 0,
+            ptr: 0,
+            offset: 0,
+            gone: 0,
+            buf: Vec::new(),
+        }
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn dvi_file() -> OutputId {
+    DVI_CTX.with_borrow(|dvi| dvi.file.unwrap())
+}
+
+#[no_mangle]
+pub extern "C" fn set_dvi_file(file: OutputId) {
+    DVI_CTX.with_borrow_mut(|dvi| dvi.file = Some(file))
+}
+
+#[no_mangle]
+pub extern "C" fn dvi_limit() -> i32 {
+    DVI_CTX.with_borrow(|dvi| dvi.limit)
+}
+
+#[no_mangle]
+pub extern "C" fn set_dvi_limit(val: i32) {
+    DVI_CTX.with_borrow_mut(|dvi| dvi.limit = val)
+}
+
+#[no_mangle]
+pub extern "C" fn dvi_ptr() -> i32 {
+    DVI_CTX.with_borrow(|dvi| dvi.ptr)
+}
+
+#[no_mangle]
+pub extern "C" fn set_dvi_ptr(val: i32) {
+    DVI_CTX.with_borrow_mut(|dvi| dvi.ptr = val)
+}
+
+#[no_mangle]
+pub extern "C" fn dvi_offset() -> i32 {
+    DVI_CTX.with_borrow(|dvi| dvi.offset)
+}
+
+#[no_mangle]
+pub extern "C" fn set_dvi_offset(val: i32) {
+    DVI_CTX.with_borrow_mut(|dvi| dvi.offset = val)
+}
+
+#[no_mangle]
+pub extern "C" fn dvi_gone() -> i32 {
+    DVI_CTX.with_borrow(|dvi| dvi.gone)
+}
+
+#[no_mangle]
+pub extern "C" fn set_dvi_gone(val: i32) {
+    DVI_CTX.with_borrow_mut(|dvi| dvi.gone = val)
+}
+
+#[no_mangle]
+pub extern "C" fn dvi_buf(idx: usize) -> u8 {
+    DVI_CTX.with_borrow(|engine| engine.buf[idx])
+}
+
+#[no_mangle]
+pub extern "C" fn set_dvi_buf(idx: usize, val: u8) {
+    DVI_CTX.with_borrow_mut(|engine| engine.buf[idx] = val)
+}
+
+#[no_mangle]
+pub extern "C" fn dvi_buf_ptr(idx: usize) -> *mut u8 {
+    DVI_CTX.with_borrow_mut(|engine| ptr::from_mut(&mut engine.buf[idx]))
+}
+
+#[no_mangle]
+pub extern "C" fn resize_dvi_buf(len: usize) {
+    DVI_CTX.with_borrow_mut(|engine| engine.buf.resize(len, 0))
+}
+
+#[no_mangle]
+pub extern "C" fn clear_dvi_buf() {
+    DVI_CTX.with_borrow_mut(|engine| engine.buf.clear())
+}