Port prepare_mag, geq_word_define, int_error

Author: CraftSpider

crates/engine_xetex/src/c_api/engine.rs

@@ -6,16 +6,21 @@ use std::{ptr, slice};
 
 mod memory;
 
+use crate::c_api::errors::rs_int_error;
 use crate::c_api::is_dir_sep;
 use crate::c_api::output::{
-    rs_print, rs_print_bytes, rs_print_char, rs_print_cs, rs_print_esc_bytes, rs_print_int,
-    rs_print_ln, rs_print_nl, rs_print_nl_bytes, rs_print_raw_char,
+    rs_capture_to_diagnostic, rs_error_here_with_diagnostic, rs_print, rs_print_bytes,
+    rs_print_char, rs_print_cs, rs_print_esc_bytes, rs_print_int, rs_print_ln, rs_print_nl,
+    rs_print_nl_bytes, rs_print_raw_char,
 };
 use crate::c_api::pool::{
     rs_make_string, rs_search_string, rs_slow_make_string, StringPool, EMPTY_STRING, TOO_BIG_CHAR,
 };
 pub use memory::*;
 
+pub const LEVEL_ZERO: u16 = 0;
+pub const LEVEL_ONE: u16 = 1;
+
 pub const NULL_CS: usize = 0x220001;
 pub const PRIM_SIZE: usize = 2100;
 pub const UNDEFINED_CONTROL_SEQUENCE: usize = 0x226603;
@@ -1726,3 +1731,73 @@ pub fn rs_token_show(globals: &mut Globals<'_, '_>, p: usize) {
 pub extern "C" fn token_show(p: i32) {
     Globals::with(|globals| rs_token_show(globals, p as usize))
 }
+
+pub fn rs_geq_word_define(globals: &mut Globals<'_, '_>, p: usize, w: i32) {
+    globals.engine.eqtb[p].b32.s1 = w;
+    globals.engine.set_xeq_level(p, LEVEL_ONE);
+}
+
+#[no_mangle]
+pub extern "C" fn geq_word_define(p: i32, w: i32) {
+    Globals::with(|globals| rs_geq_word_define(globals, p as usize, w))
+}
+
+pub fn rs_prepare_mag(globals: &mut Globals<'_, '_>) -> Option<Box<dyn Fn()>> {
+    if globals.engine.mag_set > 0 && globals.engine.int_par(IntPar::Mag) != globals.engine.mag_set {
+        rs_error_here_with_diagnostic(globals, b"Incompatible magnification (");
+        rs_print_int(globals, globals.engine.int_par(IntPar::Mag));
+        rs_print_bytes(globals, b")");
+        rs_print_nl_bytes(globals, b" the previous value will be retained");
+
+        globals
+            .out
+            .current_diagnostic
+            .as_deref_mut()
+            .unwrap()
+            .append(format!(" {}", globals.engine.mag_set));
+        rs_capture_to_diagnostic(globals, None);
+
+        globals.engine.help_ptr = 2;
+        globals.engine.help_line[1] =
+            c"I can handle only one magnification ratio per job. So I've".as_ptr();
+        globals.engine.help_line[0] =
+            c"reverted to the magnification you used earlier on this run.".as_ptr();
+
+        if let Some(f) = rs_int_error(globals, globals.engine.mag_set) {
+            return Some(f);
+        }
+        rs_geq_word_define(
+            globals,
+            INT_BASE + IntPar::Mag as usize,
+            globals.engine.mag_set,
+        );
+    }
+
+    if globals.engine.int_par(IntPar::Mag) <= 0 || globals.engine.int_par(IntPar::Mag) > 32768 {
+        rs_error_here_with_diagnostic(globals, b"Illegal magnification has been changed to 1000");
+        globals
+            .out
+            .current_diagnostic
+            .as_deref_mut()
+            .unwrap()
+            .append(format!(" {}", globals.engine.int_par(IntPar::Mag)));
+        rs_capture_to_diagnostic(globals, None);
+
+        globals.engine.help_ptr = 1;
+        globals.engine.help_line[0] =
+            c"The magnification ratio must be between 1 and 32768.".as_ptr();
+        if let Some(f) = rs_int_error(globals, globals.engine.int_par(IntPar::Mag)) {
+            return Some(f);
+        }
+        rs_geq_word_define(globals, INT_BASE + IntPar::Mag as usize, 1000);
+    }
+
+    globals.engine.mag_set = globals.engine.int_par(IntPar::Mag);
+    None
+}
+
+#[no_mangle]
+pub extern "C" fn prepare_mag() {
+    let outside_lock = Globals::with(|globals| rs_prepare_mag(globals));
+    outside_lock.map(|f| f());
+}

crates/engine_xetex/src/c_api/errors.rs

@@ -4,7 +4,7 @@ use crate::c_api::engine::{
 use crate::c_api::globals::Globals;
 use crate::c_api::output::{
     rs_capture_to_diagnostic, rs_error_here_with_diagnostic, rs_print_bytes, rs_print_char,
-    rs_print_ln, rs_print_nl_bytes,
+    rs_print_int, rs_print_ln, rs_print_nl_bytes,
 };
 use std::ffi::CStr;
 
@@ -39,7 +39,7 @@ pub fn give_err_help(globals: &mut Globals<'_, '_>) {
     rs_token_show(globals, globals.engine.local(Local::ErrHelp) as usize);
 }
 
-pub fn rs_error(globals: &mut Globals<'_, '_>) -> Box<dyn Fn()> {
+pub fn rs_error(globals: &mut Globals<'_, '_>) -> Option<Box<dyn Fn()>> {
     if globals.engine.history < History::ErrorIssued {
         globals.engine.history = History::ErrorIssued;
     }
@@ -49,10 +49,10 @@ pub fn rs_error(globals: &mut Globals<'_, '_>) -> Box<dyn Fn()> {
     if globals.engine.halt_on_error_p != 0 {
         globals.engine.history = History::FatalError;
         // Execute this outside the globals lock for now
-        return Box::new(|| {
+        return Some(Box::new(|| {
             post_error_message(0);
             panic!("halted on potentially-recoverable error as specified");
-        });
+        }));
     }
 
     /* This used to be where there was a bunch of code if "interaction ==
@@ -63,10 +63,10 @@ pub fn rs_error(globals: &mut Globals<'_, '_>) -> Box<dyn Fn()> {
     if globals.engine.error_count == 100 {
         rs_print_nl_bytes(globals, b"(That makes 100 errors; please try again.)");
         globals.engine.history = History::FatalError;
-        return Box::new(|| {
+        return Some(Box::new(|| {
             post_error_message(0);
             panic!("halted after 100 potentially-recoverable errors");
-        });
+        }));
     }
 
     if globals.engine.interaction != InteractionMode::Batch {
@@ -107,13 +107,13 @@ pub fn rs_error(globals: &mut Globals<'_, '_>) -> Box<dyn Fn()> {
         }
     }
     rs_print_ln(globals);
-    Box::new(|| ())
+    None
 }
 
 #[no_mangle]
 extern "C-unwind" fn error() {
     let out_of_lock = Globals::with(|globals| rs_error(globals));
-    out_of_lock();
+    out_of_lock.map(|f| f());
 }
 
 #[no_mangle]
@@ -128,9 +128,9 @@ extern "C" fn post_error_message(need_to_print_it: i32) {
             return rs_error(globals);
         }
         globals.engine.history = History::FatalError;
-        Box::new(|| ())
+        None
     });
-    out_of_lock();
+    out_of_lock.map(|f| f());
     unsafe { close_files_and_terminate() };
     unsafe { tt_cleanup() };
     Globals::with(|globals| {
@@ -162,6 +162,19 @@ pub extern "C" fn fatal_error(s: *const libc::c_char) {
     });
 }
 
+pub fn rs_int_error(globals: &mut Globals<'_, '_>, n: i32) -> Option<Box<dyn Fn()>> {
+    rs_print_bytes(globals, b" (");
+    rs_print_int(globals, n);
+    rs_print_char(globals, ')' as i32);
+    rs_error(globals)
+}
+
+#[no_mangle]
+pub extern "C" fn int_error(n: i32) {
+    let outside_lock = Globals::with(|globals| rs_int_error(globals, n));
+    outside_lock.map(|f| f());
+}
+
 // TODO: Use the Rust versions directly once they're ported. These just rely indirectly on this
 //       function, making it easier to port piecemeal.
 extern "C" {

crates/engine_xetex/src/c_api/output.rs

@@ -22,7 +22,7 @@ thread_local! {
 }
 
 pub struct OutputCtx {
-    current_diagnostic: Option<Box<Diagnostic>>,
+    pub(crate) current_diagnostic: Option<Box<Diagnostic>>,
     file_line_error_style_p: i32,
     term_offset: i32,
     file_offset: i32,

crates/engine_xetex/xetex/xetex-xetex0.c

@@ -12,16 +12,6 @@
 
 #define IS_LC_HEX(c) (((c) >= '0' && (c) <= '9' ) || ((c) >= 'a' && (c) <= 'f' ))
 
-static void
-int_error(int32_t n)
-{
-    print_cstr(" (");
-    print_int(n);
-    print_char(')');
-    error();
-}
-
-
 int32_t
 badness(scaled_t t, scaled_t s)
 {
@@ -4351,13 +4341,6 @@ void geq_define(int32_t p, uint16_t t, int32_t e)
     eqtb_ptr(p)->b32.s1 = e;
 }
 
-void geq_word_define(int32_t p, int32_t w)
-{
-
-    eqtb_ptr(p)->b32.s1 = w;
-    XEQ_LEVEL(p) = LEVEL_ONE;
-}
-
 void save_for_after(int32_t t)
 {
     if (cur_level > LEVEL_ONE) {
@@ -4446,41 +4429,6 @@ void unsave(void)
         confusion("curlevel");
 }
 
-void prepare_mag(void)
-{
-
-    if (mag_set() > 0 && INTPAR(mag) != mag_set()) {
-        ttbc_diagnostic_t *errmsg = error_here_with_diagnostic("Incompatible magnification (");
-        print_int(INTPAR(mag));
-        print_cstr(");");
-        print_nl_cstr(" the previous value will be retained");
-
-        ttstub_diag_printf(errmsg, " (%d)", mag_set());
-        capture_to_diagnostic(NULL);
-
-        {
-            set_help_ptr(2);
-            set_help_line(1, "I can handle only one magnification ratio per job. So I've");
-            set_help_line(0, "reverted to the magnification you used earlier on this run.");
-        }
-        int_error(mag_set());
-        geq_word_define(INT_BASE + INT_PAR__mag, mag_set());
-    }
-    if ((INTPAR(mag) <= 0) || (INTPAR(mag) > 32768L)) {
-        ttbc_diagnostic_t *errmsg = error_here_with_diagnostic("Illegal magnification has been changed to 1000");
-        ttstub_diag_printf(errmsg, " (%d)", INTPAR(mag));
-        capture_to_diagnostic(NULL);
-
-        {
-            set_help_ptr(1);
-            set_help_line(0, "The magnification ratio must be between 1 and 32768.");
-        }
-        int_error(INTPAR(mag));
-        geq_word_define(INT_BASE + INT_PAR__mag, 1000);
-    }
-    set_mag_set(INTPAR(mag));
-}
-
 void print_meaning(void)
 {
     print_cmd_chr(cur_cmd, cur_chr);

crates/engine_xetex/xetex/xetex_bindings.h

@@ -24,6 +24,10 @@
 
 #define FNT_NUM_0 171
 
+#define LEVEL_ZERO 0
+
+#define LEVEL_ONE 1
+
 #define NULL_CS 2228225
 
 #define PRIM_SIZE 2100