Improve aux code - remove XBuf, make bad states less representable, better ownership handling

Author: CraftSpider

crates/engine_bibtex/src/auxi.rs

@@ -22,60 +22,41 @@ use tectonic_bridge_core::FileFormat;
 
 const AUX_STACK_SIZE: usize = 20;
 
+pub(crate) struct AuxFile {
+    pub(crate) name: StrNumber,
+    pub(crate) file: Box<PeekableInput>,
+    pub(crate) line: i32,
+}
+
 pub(crate) struct AuxData {
-    aux_list: [StrNumber; AUX_STACK_SIZE + 1],
-    aux_file: [Option<Box<PeekableInput>>; AUX_STACK_SIZE + 1],
-    aux_ln_stack: [i32; AUX_STACK_SIZE + 1],
-    aux_ptr: AuxNumber,
+    aux: Vec<AuxFile>,
 }
 
 impl AuxData {
     fn new() -> AuxData {
-        AuxData {
-            aux_list: [0; AUX_STACK_SIZE + 1],
-            aux_file: [(); AUX_STACK_SIZE + 1].map(|_| None),
-            aux_ln_stack: [0; AUX_STACK_SIZE + 1],
-            aux_ptr: 0,
-        }
-    }
-
-    pub fn ptr(&self) -> AuxNumber {
-        self.aux_ptr
-    }
-
-    pub fn set_ptr(&mut self, ptr: AuxNumber) {
-        self.aux_ptr = ptr;
-    }
-
-    pub fn at_ptr(&self) -> StrNumber {
-        self.aux_list[self.aux_ptr]
-    }
-
-    pub fn set_at_ptr(&mut self, num: StrNumber) {
-        self.aux_list[self.aux_ptr] = num;
+        AuxData { aux: Vec::new() }
     }
 
-    pub fn file_at_ptr(&mut self) -> &mut PeekableInput {
-        self.aux_file[self.aux_ptr].as_mut().unwrap()
+    pub fn push_file(&mut self, file: AuxFile) {
+        self.aux.push(file);
     }
 
-    pub fn set_file_at_ptr(&mut self, file: Box<PeekableInput>) {
-        self.aux_file[self.aux_ptr] = Some(file);
+    pub fn pop_file(&mut self) -> (AuxFile, bool) {
+        let out = self.aux.pop().unwrap();
+        let last = self.aux.len() == 0;
+        (out, last)
     }
 
-    pub fn pop_file(&mut self) -> (Box<PeekableInput>, bool) {
-        let out = self.aux_file[self.aux_ptr].take().unwrap();
-        let last = self.aux_ptr == 0;
-        self.aux_ptr = self.aux_ptr.saturating_sub(1);
-        (out, last)
+    pub fn top_file(&self) -> &AuxFile {
+        self.aux.last().unwrap()
     }
 
-    pub fn ln_at_ptr(&self) -> i32 {
-        self.aux_ln_stack[self.aux_ptr]
+    pub fn top_file_mut(&mut self) -> &mut AuxFile {
+        self.aux.last_mut().unwrap()
     }
 
-    pub fn set_ln_at_ptr(&mut self, ln: i32) {
-        self.aux_ln_stack[self.aux_ptr] = ln;
+    pub fn ptr(&self) -> AuxNumber {
+        self.aux.len()
     }
 }
 
@@ -367,7 +348,6 @@ fn aux_input_command(
         return Ok(());
     }
 
-    aux.set_ptr(aux.ptr() + 1);
     if aux.ptr() == AUX_STACK_SIZE {
         print_a_token(buffers);
         write_logs(": ");
@@ -386,42 +366,41 @@ fn aux_input_command(
     if !aux_extension_ok {
         print_a_token(buffers);
         write_logs(" has a wrong extension");
-        aux.set_ptr(aux.ptr() - 1);
         aux_err_print(buffers, aux, pool)?;
         return Ok(());
     }
 
     let file = &buffers.buffer(BufTy::Base)
         [buffers.offset(BufTy::Base, 1)..buffers.offset(BufTy::Base, 2)];
     let res = pool.lookup_str_insert(hash, file, StrIlk::AuxFile)?;
-    aux.set_at_ptr(hash.text(res.loc));
     if res.exists {
         write_logs("Already encountered file ");
-        print_aux_name(aux, pool)?;
-        aux.set_ptr(aux.ptr() - 1);
+        print_aux_name(pool, res.loc)?;
         aux_err_print(buffers, aux, pool)?;
         return Ok(());
     }
 
-    let name = pool.get_str(aux.at_ptr());
+    let name = pool.get_str(hash.text(res.loc));
     let fname = CString::new(name).unwrap();
     let file = PeekableInput::open(ctx, &fname, FileFormat::Tex);
     match file {
         Err(_) => {
             write_logs("I couldn't open auxiliary file ");
-            print_aux_name(aux, pool)?;
-            aux.set_ptr(aux.ptr() - 1);
+            print_aux_name(pool, res.loc)?;
             aux_err_print(buffers, aux, pool)?;
             return Ok(());
         }
         Ok(file) => {
-            aux.set_file_at_ptr(file);
+            aux.push_file(AuxFile {
+                name: hash.text(res.loc),
+                file,
+                line: 0,
+            });
         }
     }
 
-    write_logs(&format!("A level-{} auxiliary file: ", aux.ptr()));
+    write_logs(&format!("A level-{} auxiliary file: ", aux.ptr() - 1));
     log_pr_aux_name(aux, pool)?;
-    aux.set_ln_at_ptr(0);
 
     Ok(())
 }
@@ -484,49 +463,53 @@ pub(crate) fn get_aux_command_and_process(
     Ok(())
 }
 
-pub(crate) fn pop_the_aux_stack(ctx: &mut Bibtex<'_, '_>, aux: &mut AuxData) -> bool {
+pub(crate) fn pop_the_aux_stack(ctx: &mut Bibtex<'_, '_>, aux: &mut AuxData) -> Option<StrNumber> {
     let (file, last) = aux.pop_file();
-    file.close(ctx).unwrap();
-    last
+    file.file.close(ctx).unwrap();
+    if last {
+        Some(file.name)
+    } else {
+        None
+    }
 }
 
 pub(crate) fn last_check_for_aux_errors(
     ctx: &mut Bibtex<'_, '_>,
-    aux: &AuxData,
     pool: &StringPool,
     cites: &mut CiteInfo,
     bibs: &BibData,
+    last_aux: StrNumber,
 ) -> Result<(), BibtexError> {
     cites.set_num_cites(cites.ptr());
     ctx.num_bib_files = bibs.ptr();
     if !ctx.citation_seen {
         aux_end1_err_print();
         write_logs("\\citation commands");
-        aux_end2_err_print(aux, pool)?;
+        aux_end2_err_print(pool, last_aux)?;
     } else if cites.num_cites() == 0 && !ctx.all_entries {
         aux_end1_err_print();
         write_logs("cite keys");
-        aux_end2_err_print(aux, pool)?;
+        aux_end2_err_print(pool, last_aux)?;
     }
 
     if !ctx.bib_seen {
         aux_end1_err_print();
         write_logs("\\bibdata command");
-        aux_end2_err_print(aux, pool)?;
+        aux_end2_err_print(pool, last_aux)?;
     } else if ctx.num_bib_files == 0 {
         aux_end1_err_print();
         write_logs("database files");
-        aux_end2_err_print(aux, pool)?;
+        aux_end2_err_print(pool, last_aux)?;
     }
 
     if !ctx.bst_seen {
         aux_end1_err_print();
         write_logs("\\bibstyle command");
-        aux_end2_err_print(aux, pool)?;
+        aux_end2_err_print(pool, last_aux)?;
     } else if ctx.bst_str == 0 {
         aux_end1_err_print();
         write_logs("style file");
-        aux_end2_err_print(aux, pool)?;
+        aux_end2_err_print(pool, last_aux)?;
     }
 
     Ok(())

crates/engine_bibtex/src/lib.rs

@@ -41,7 +41,7 @@ use tectonic_io_base::{InputHandle, OutputHandle};
 use xbuf::SafelyZero;
 
 use crate::{
-    auxi::{get_aux_command_and_process, last_check_for_aux_errors, pop_the_aux_stack},
+    auxi::{get_aux_command_and_process, last_check_for_aux_errors, pop_the_aux_stack, AuxFile},
     bst::get_bst_command_and_process,
     buffer::BufTy,
     exec::ExecCtx,
@@ -430,25 +430,25 @@ pub(crate) fn inner_bibtex_main(
 
     if ctx.config.verbose {
         write_logs("The top-level auxiliary file: ");
-        print_aux_name(globals.aux, globals.pool)?;
+        print_aux_name(globals.pool, globals.aux.top_file().name)?;
     } else {
         write_log_file("The top-level auxiliary file: ");
         log_pr_aux_name(globals.aux, globals.pool)?;
     }
 
-    loop {
-        globals.aux.set_ln_at_ptr(globals.aux.ln_at_ptr() + 1);
+    let last_aux = loop {
+        globals.aux.top_file_mut().line += 1;
 
-        if !input_ln(Some(globals.aux.file_at_ptr()), globals.buffers) {
-            if pop_the_aux_stack(ctx, globals.aux) {
-                break;
+        if !input_ln(Some(&mut globals.aux.top_file_mut().file), globals.buffers) {
+            if let Some(last) = pop_the_aux_stack(ctx, globals.aux) {
+                break last;
             }
         } else {
             get_aux_command_and_process(ctx, globals)?;
         }
-    }
+    };
 
-    last_check_for_aux_errors(ctx, globals.aux, globals.pool, globals.cites, globals.bibs)?;
+    last_check_for_aux_errors(ctx, globals.pool, globals.cites, globals.bibs, last_aux)?;
 
     if ctx.bst_str == 0 {
         return Err(BibtexError::NoBst);
@@ -491,16 +491,13 @@ pub(crate) fn get_the_top_level_aux_file_name(
         path[range].copy_from_slice(extension);
     };
 
-    aux.set_ptr(0);
-
     let aux_file = match PeekableInput::open(ctx, aux_file_name, FileFormat::Tex) {
         Ok(file) => file,
         Err(_) => {
             sam_wrong_file_name_print(aux_file_name);
             return Ok(1);
         }
     };
-    aux.set_file_at_ptr(aux_file);
 
     set_extension(&mut path, b".blg");
     let log_file = CStr::from_bytes_with_nul(&path).unwrap();
@@ -523,7 +520,12 @@ pub(crate) fn get_the_top_level_aux_file_name(
         Ok(res) => res,
         Err(_) => return Err(BibtexError::Fatal),
     };
-    aux.set_at_ptr(hash.text(lookup.loc));
+
+    aux.push_file(AuxFile {
+        name: hash.text(lookup.loc),
+        file: aux_file,
+        line: 0,
+    });
 
     if lookup.exists {
         write_logs("Already encountered auxiliary file");

crates/engine_bibtex/src/log.rs

@@ -225,15 +225,15 @@ pub fn sam_wrong_file_name_print(file: &CStr) {
     })
 }
 
-pub(crate) fn print_aux_name(aux: &AuxData, pool: &StringPool) -> Result<(), BibtexError> {
-    print_a_pool_str(aux.at_ptr(), pool)?;
+pub(crate) fn print_aux_name(pool: &StringPool, name: StrNumber) -> Result<(), BibtexError> {
+    print_a_pool_str(name, pool)?;
     write_logs("\n");
     Ok(())
 }
 
 pub(crate) fn log_pr_aux_name(aux: &AuxData, pool: &StringPool) -> Result<(), BibtexError> {
     with_log(|log| {
-        out_pool_str(pool, log, aux.at_ptr())?;
+        out_pool_str(pool, log, aux.top_file().name)?;
         writeln!(log).unwrap();
         Ok(())
     })
@@ -244,8 +244,8 @@ pub(crate) fn aux_err_print(
     aux: &AuxData,
     pool: &StringPool,
 ) -> Result<(), BibtexError> {
-    write_logs(&format!("---line {} of file ", aux.ln_at_ptr()));
-    print_aux_name(aux, pool)?;
+    write_logs(&format!("---line {} of file ", aux.top_file().line));
+    print_aux_name(pool, aux.top_file().name)?;
     print_bad_input_line(buffers);
     print_skipping_whatever_remains();
     write_logs("command\n");
@@ -257,7 +257,7 @@ pub(crate) enum AuxTy {
     Style,
 }
 
-pub fn aux_err_illegal_another_print(cmd: AuxTy) -> Result<(), BibtexError> {
+pub(crate) fn aux_err_illegal_another_print(cmd: AuxTy) -> Result<(), BibtexError> {
     write_logs("Illegal, another \\bib");
     match cmd {
         AuxTy::Data => write_logs("data"),
@@ -283,9 +283,9 @@ pub fn aux_end1_err_print() {
     write_logs("I found no ");
 }
 
-pub(crate) fn aux_end2_err_print(aux: &AuxData, pool: &StringPool) -> Result<(), BibtexError> {
+pub(crate) fn aux_end2_err_print(pool: &StringPool, name: StrNumber) -> Result<(), BibtexError> {
     write_logs("---while reading file ");
-    print_aux_name(aux, pool)?;
+    print_aux_name(pool, name)?;
     mark_error();
     Ok(())
 }

crates/engine_bibtex/src/peekable.rs

@@ -126,7 +126,7 @@ pub(crate) unsafe fn peekable_close(
     }
 }
 
-pub fn tectonic_eof(peekable: Option<&mut PeekableInput>) -> bool {
+pub(crate) fn tectonic_eof(peekable: Option<&mut PeekableInput>) -> bool {
     // Check for EOF following Pascal semantics.
     match peekable {
         Some(peek) => peek.eof(),