Remove C code from engine_bibtex

Author: CraftSpider

Cargo.lock

@@ -16,17 +16,13 @@ repository = "https://github.com/tectonic-typesetting/tectonic/"
 readme = "README.md"
 license = "MIT"
 edition = "2018"
-links = "tectonic_engine_bibtex"
 
 [dependencies]
 libc = "^0.2"
 tectonic_io_base = { path = "../io_base", version = '0.0.0-dev.0' }
 tectonic_bridge_core = { path = "../bridge_core", version = "0.0.0-dev.0" }
 tectonic_errors = { path = "../errors", version = "0.0.0-dev.0" }
 
-[build-dependencies]
-cc = "^1.0.66"
-
 [package.metadata.internal_dep_versions]
 tectonic_bridge_core = "thiscommit:2021-01-17:fohCh1sh"
 tectonic_errors = "5c9ba661edf5ef669f24f9904f99cca369d999e7"

crates/engine_bibtex/Cargo.toml

@@ -146,7 +146,7 @@ fn aux_bib_data_command(
 
         let name = pool.get_str(bibs.cur_bib());
         let fname = CString::new(name).unwrap();
-        let bib_in = peekable_open(&fname, FileFormat::Bib);
+        let bib_in = peekable_open(ctx, &fname, FileFormat::Bib);
         if bib_in.is_null() {
             write_logs("I couldn't open database file ");
             print_bib_name(pool, bibs)?;
@@ -210,7 +210,7 @@ fn aux_bib_style_command(
 
     let name = pool.get_str(ctx.bst_str);
     let fname = CString::new(name).unwrap();
-    let ptr = peekable_open(&fname, FileFormat::Bst);
+    let ptr = peekable_open(ctx, &fname, FileFormat::Bst);
     if ptr.is_null() {
         write_logs("I couldn't open style file ");
         print_bst_name(ctx, pool)?;
@@ -334,7 +334,7 @@ fn aux_citation_command(
 }
 
 fn aux_input_command(
-    ctx: &Bibtex,
+    ctx: &mut Bibtex,
     buffers: &mut GlobalBuffer,
     aux: &mut AuxData,
     pool: &mut StringPool,
@@ -401,7 +401,7 @@ fn aux_input_command(
 
     let name = pool.get_str(aux.at_ptr());
     let fname = CString::new(name).unwrap();
-    let ptr = peekable_open(&fname, FileFormat::Tex);
+    let ptr = peekable_open(ctx, &fname, FileFormat::Tex);
     if ptr.is_null() {
         write_logs("I couldn't open auxiliary file ");
         print_aux_name(aux, pool)?;
@@ -476,9 +476,9 @@ pub(crate) fn get_aux_command_and_process(
     Ok(())
 }
 
-pub(crate) fn pop_the_aux_stack(aux: &mut AuxData) -> bool {
+pub(crate) fn pop_the_aux_stack(ctx: &mut Bibtex<'_, '_>, aux: &mut AuxData) -> bool {
     // SAFETY: Aux file at pointer guaranteed valid at this point
-    unsafe { peekable_close(NonNull::new(aux.file_at_ptr())) };
+    unsafe { peekable_close(ctx, NonNull::new(aux.file_at_ptr())) };
     aux.set_file_at_ptr(ptr::null_mut());
     if aux.ptr() == 0 {
         true

crates/engine_bibtex/bibtex/bibtex.c

@@ -579,7 +579,7 @@ fn bst_read_command(ctx: &mut ExecCtx, globals: &mut GlobalItems<'_>) -> Result<
             )?;
         }
         // SAFETY: take_cur_bib_file returns reference to which we're the last owner
-        unsafe { peekable_close(globals.bibs.take_cur_bib_file().map(NonNull::from)) };
+        unsafe { peekable_close(ctx.glbl_ctx_mut(), globals.bibs.take_cur_bib_file().map(NonNull::from)) };
         globals.bibs.set_ptr(globals.bibs.ptr() + 1);
     }
 

crates/engine_bibtex/bibtex/bibtex_bindings.h

@@ -61,9 +61,8 @@ impl ExecVal {
 // SAFETY: We require our zero discriminant to be an integer, which is valid for any bit pattern, including 0
 unsafe impl SafelyZero for ExecVal {}
 
-#[repr(C)]
-pub struct ExecCtx {
-    pub glbl_ctx: *mut Bibtex,
+pub(crate) struct ExecCtx<'a, 'bib, 'cbs> {
+    pub glbl_ctx: &'a mut Bibtex<'bib, 'cbs>,
     pub _default: HashPointer,
     pub(crate) lit_stack: Box<XBuf<ExecVal>>,
     pub lit_stk_ptr: usize,
@@ -72,8 +71,8 @@ pub struct ExecCtx {
     pub bib_str_ptr: StrNumber,
 }
 
-impl ExecCtx {
-    pub(crate) fn new(glbl_ctx: &mut Bibtex) -> ExecCtx {
+impl<'a, 'bib, 'cbs> ExecCtx<'a, 'bib, 'cbs> {
+    pub(crate) fn new(glbl_ctx: &'a mut Bibtex<'bib, 'cbs>) -> ExecCtx<'a, 'bib, 'cbs> {
         ExecCtx {
             glbl_ctx,
             _default: 0,
@@ -125,14 +124,12 @@ impl ExecCtx {
         self.lit_stack.grow(LIT_STK_SIZE);
     }
 
-    pub(crate) fn glbl_ctx(&self) -> &Bibtex {
-        // SAFETY: Contained pointer is always valid
-        unsafe { &*self.glbl_ctx }
+    pub(crate) fn glbl_ctx(&self) -> &Bibtex<'bib, 'cbs> {
+        &*self.glbl_ctx
     }
 
-    pub(crate) fn glbl_ctx_mut(&mut self) -> &mut Bibtex {
-        // SAFETY: Contained pointer is always valid
-        unsafe { &mut *self.glbl_ctx }
+    pub(crate) fn glbl_ctx_mut(&mut self) -> &mut Bibtex<'bib, 'cbs> {
+        &mut *self.glbl_ctx
     }
 }
 

crates/engine_bibtex/build.rs

@@ -12,7 +12,7 @@ use crate::{
         peekable::input_ln,
         pool::StringPool,
         scan::{Scan, ScanRes},
-        ttstub_output_close, ttstub_output_open, ttstub_output_open_stdout, ASCIICode, Bibtex,
+        ttbc_output_close, ttbc_output_open, ttbc_output_open_stdout, ASCIICode, Bibtex,
         CiteNumber, FieldLoc, HashPointer, StrNumber,
     },
     BibtexError,
@@ -79,12 +79,12 @@ pub(crate) fn write_log_file<B: ?Sized + AsBytes>(str: &B) {
     with_log(|log| log.write_all(str.as_bytes())).unwrap();
 }
 
-pub(crate) fn init_log_file(file: &CStr) -> bool {
+pub(crate) fn init_log_file(ctx: &mut Bibtex<'_, '_>, file: &CStr) -> bool {
     LOG_FILE.with(|log| {
         let ptr = log.replace(None);
         if ptr.is_none() {
             // SAFETY: Our CStr is valid for the length of the call, so this can't access bad memory
-            let new = unsafe { ttstub_output_open(file.as_ptr(), 0) };
+            let new = unsafe { ttbc_output_open(ctx.engine, file.as_ptr(), 0) };
             // SAFETY: Return of ttstub_output_open should be valid if non-null
             log.set(unsafe { new.as_mut() });
             !new.is_null()
@@ -95,12 +95,12 @@ pub(crate) fn init_log_file(file: &CStr) -> bool {
     })
 }
 
-pub fn init_standard_output() -> bool {
+pub(crate) fn init_standard_output(ctx: &mut Bibtex<'_, '_>) -> bool {
     STANDARD_OUTPUT.with(|out| {
         let ptr = out.replace(None);
         if ptr.is_none() {
             // SAFETY: This is actually fine to call, just extern
-            let stdout = unsafe { ttstub_output_open_stdout() };
+            let stdout = unsafe { ttbc_output_open_stdout(ctx.engine) };
             // SAFETY: Pointer from ttstub_output_open_stdout is valid if non-null
             out.set(unsafe { stdout.as_mut() });
             !stdout.is_null()
@@ -111,12 +111,12 @@ pub fn init_standard_output() -> bool {
     })
 }
 
-pub fn bib_close_log() {
+pub(crate) fn bib_close_log(ctx: &mut Bibtex<'_, '_>) {
     LOG_FILE.with(|log| {
         let log = log.replace(None);
         if let Some(log) = log {
             // SAFETY: Log is valid due to being a mut ref
-            unsafe { ttstub_output_close(log) };
+            unsafe { ttbc_output_close(ctx.engine, log) };
         }
     })
 }