Catch the engine(s) up to TeXLive 2020.0

Cargo.toml

@@ -79,6 +79,7 @@ profile = []
 # libz-sys = "^1.0"
 
 [dev-dependencies]
+filetime = "^0.2"
 futures = "0.1"
 headers = "0.2"
 hyper = "0.12"
@@ -87,7 +88,7 @@ tokio = "0.1.22"
 
 [package.metadata.vcpkg]
 git = "https://github.com/microsoft/vcpkg"
-rev = "76a7e9248fb3c57350b559966dcaa2d52a5e4458"
+rev = "527c0e04332db88a7906e469dca1d9f0a35726fc"
 
 [package.metadata.vcpkg.target]
 x86_64-apple-darwin = { install = ["freetype","harfbuzz[icu,graphite2]"] }

build.rs

@@ -318,6 +318,7 @@ fn main() {
  .file("tectonic/dpx-mem.c")
  .file("tectonic/dpx-mfileio.c")
  .file("tectonic/dpx-mpost.c")
+ .file("tectonic/dpx-mt19937ar.c")
  .file("tectonic/dpx-numbers.c")
  .file("tectonic/dpx-otl_conf.c")
  .file("tectonic/dpx-otl_opt.c")

dist/azure-ci-cd.yml

@@ -80,12 +80,15 @@ parameters:
  TARGET: x86_64-apple-darwin
  TOOLCHAIN: stable
 
- - name: windows
- vmImage: windows-2019
- params: {}
- vars:
- TARGET: x86_64-pc-windows-msvc
- TOOLCHAIN: stable-x86_64-pc-windows-msvc
+ # Temporarily disabled due to vcpkg brokenness that looks like it
+ # will take a little while to resolve. Tracking issue:
+ # https://github.com/tectonic-typesetting/tectonic/issues/668
+ # - name: windows
+ # vmImage: windows-2019
+ # params: {}
+ # vars:
+ # TARGET: x86_64-pc-windows-msvc
+ # TOOLCHAIN: stable-x86_64-pc-windows-msvc
 
 - name: crossBuilds
  type: object

src/bin/tectonic.rs

@@ -195,7 +195,7 @@ fn inner(args: CliOptions, config: PersistentConfig, status: &mut dyn StatusBack
  engine
  );
 
- status.dump_error_logs(&output);
+ status.dump_error_logs(&output.data);
  }
  }
  }

src/driver.rs

@@ -18,18 +18,25 @@ use std::fs::File;
 use std::io::Write;
 use std::path::{Path, PathBuf};
 use std::rc::Rc;
+use std::result::Result as StdResult;
 use std::str::FromStr;
 use std::time::SystemTime;
 
-use crate::digest::DigestData;
-use crate::engines::IoEventBackend;
-use crate::errors::{ErrorKind, Result, ResultExt};
-use crate::io::{Bundle, InputOrigin, IoProvider, IoSetup, IoSetupBuilder, OpenResult};
-use crate::status::StatusBackend;
-use crate::unstable_opts::UnstableOptions;
-use crate::{ctry, errmsg, tt_error, tt_note, tt_warning};
-use crate::{BibtexEngine, Spx2HtmlEngine, TexEngine, TexResult, XdvipdfmxEngine};
-use std::result::Result as StdResult;
+use crate::{
+ ctry,
+ digest::DigestData,
+ engines::IoEventBackend,
+ errmsg,
+ errors::{ErrorKind, Result, ResultExt},
+ io::{
+ memory::MemoryFileCollection, Bundle, InputOrigin, IoProvider, IoSetup, IoSetupBuilder,
+ OpenResult,
+ },
+ status::StatusBackend,
+ tt_error, tt_note, tt_warning,
+ unstable_opts::UnstableOptions,
+ BibtexEngine, Spx2HtmlEngine, TexEngine, TexResult, XdvipdfmxEngine,
+};
 
 /// Different patterns with which files may have been accessed by the
 /// underlying engines. Once a file is marked as ReadThenWritten or
@@ -845,7 +852,7 @@ impl ProcessingSession {
 
  let mut n_skipped_intermediates = 0;
 
- for (name, contents) in &*self.io.mem.files.borrow() {
+ for (name, file) in &*self.io.mem.files.borrow() {
  if name == self.io.mem.stdout_key() {
  continue;
  }
@@ -882,7 +889,7 @@ impl ProcessingSession {
  continue;
  }
 
- if contents.is_empty() {
+ if file.data.is_empty() {
  status.note_highlighted(
  "Not writing ",
  &format!("`{}`", sname),
@@ -892,15 +899,15 @@ impl ProcessingSession {
  }
 
  let real_path = root.join(name);
- let byte_len = Byte::from_bytes(contents.len() as u128);
+ let byte_len = Byte::from_bytes(file.data.len() as u128);
  status.note_highlighted(
  "Writing ",
  &format!("`{}`", real_path.to_string_lossy()),
  &format!(" ({})", byte_len.get_appropriate_unit(true).to_string()),
  );
 
  let mut f = File::create(&real_path)?;
- f.write_all(contents)?;
+ f.write_all(&file.data)?;
  summ.got_written_to_disk = true;
 
  if let Some(ref mut mf_dest) = mf_dest_maybe {
@@ -1009,10 +1016,10 @@ impl ProcessingSession {
  .files
  .borrow()
  .get(&self.tex_aux_path)
- .map(|data| {
+ .map(|file| {
  // We used to use aho-corasick crate here, but it was removed to reduce the code
  // size.
- data.windows(BIBDATA.len()).any(|s| s == BIBDATA)
+ file.data.windows(BIBDATA.len()).any(|s| s == BIBDATA)
  })
  .unwrap_or(false)
  }
@@ -1081,7 +1088,7 @@ impl ProcessingSession {
 
  let format_cache = &mut *self.io.format_cache.as_mut().unwrap();
 
- for (name, contents) in &*self.io.mem.files.borrow() {
+ for (name, file) in &*self.io.mem.files.borrow() {
  if name == self.io.mem.stdout_key() {
  continue;
  }
@@ -1093,7 +1100,7 @@ impl ProcessingSession {
  }
 
  // Note that we intentionally pass 'stem', not 'name'.
- ctry!(format_cache.write_format(stem, contents, status); "cannot write format file {}", sname);
+ ctry!(format_cache.write_format(stem, &file.data, status); "cannot write format file {}", sname);
  }
 
  // All done. Clear the memory layer since this was a special preparatory step.
@@ -1229,7 +1236,7 @@ impl ProcessingSession {
  /// This will panic if you there are multiple strong references to the
  /// `files` map. This should only happen if you create and keep a clone of
  /// the `Rc<>` wrapping it before calling this function.
- pub fn into_file_data(self) -> HashMap<OsString, Vec<u8>> {
+ pub fn into_file_data(self) -> MemoryFileCollection {
  Rc::try_unwrap(self.io.mem.files)
  .expect("multiple strong refs to MemoryIo files")
  .into_inner()

src/engines/mod.rs

@@ -418,6 +418,23 @@ impl<'a> ExecutionState<'a> {
  }
  }
 
+ fn input_get_mtime(&mut self, handle: *mut InputHandle) -> libc::time_t {
+ let rhandle: &mut InputHandle = unsafe { &mut *handle };
+ let maybe_time = match rhandle.get_unix_mtime() {
+ Ok(t) => t,
+ Err(e) => {
+ tt_warning!(self.status, "failed to get the modification time of an input"; e);
+ Some(0)
+ }
+ };
+
+ if let Some(t) = maybe_time {
+ t as libc::time_t
+ } else {
+ 1 // Intentionally make this distinguishable from the error value 0
+ }
+ }
+
  fn input_seek(&mut self, handle: *mut InputHandle, pos: SeekFrom) -> Result<u64> {
  let rhandle: &mut InputHandle = unsafe { &mut *handle };
  rhandle.try_seek(pos)
@@ -697,6 +714,14 @@ pub extern "C" fn input_get_size(
  es.input_get_size(handle)
 }
 
+#[no_mangle]
+pub extern "C" fn input_get_mtime(
+ es: &mut ExecutionState,
+ handle: *mut InputHandle,
+) -> libc::time_t {
+ es.input_get_mtime(handle)
+}
+
 #[no_mangle]
 pub extern "C" fn input_seek(
  es: &mut ExecutionState,

src/engines/tex.rs

@@ -126,10 +126,16 @@ impl TexEngine {
  unsafe {
  super::tt_xetex_set_int_variable(b"shell_escape_enabled\0".as_ptr() as _, v);
  }
- let v = if self.halt_on_error { 1 } else { 0 };
+
+ let mut halt_on_error = self.halt_on_error;
+ if unstables.continue_on_errors {
+ halt_on_error = false; // command-line override
+ }
+ let v = if halt_on_error { 1 } else { 0 };
  unsafe {
  super::tt_xetex_set_int_variable(b"halt_on_error_p\0".as_ptr() as _, v);
  }
+
  let v = if self.initex_mode { 1 } else { 0 };
  unsafe {
  super::tt_xetex_set_int_variable(b"in_initex_mode\0".as_ptr() as _, v);

src/errors.rs

@@ -63,6 +63,7 @@ error_chain! {
  Reqwest(reqwest::Error);
  ConfigRead(ReadError);
  ConfigWrite(WriteError);
+ Time(std::time::SystemTimeError);
  Utf8(str::Utf8Error);
  Xdv(tectonic_xdv::XdvError);
  Zip(ZipError);

src/io/filesystem.rs

@@ -161,6 +161,15 @@ impl InputFeatures for File {
  Ok(self.metadata()?.len() as usize)
  }
 
+ fn get_unix_mtime(&mut self) -> Result<Option<i64>> {
+ let sys_time = self.metadata()?.modified()?;
+
+ // No cleaner way to convert a SystemTime to time_t, as far as I can
+ // tell.
+ let dur = sys_time.duration_since(std::time::SystemTime::UNIX_EPOCH)?;
+ Ok(Some(dur.as_secs() as i64))
+ }
+
  fn try_seek(&mut self, pos: SeekFrom) -> Result<u64> {
  Ok(self.seek(pos)?)
  }
@@ -171,6 +180,12 @@ impl InputFeatures for BufReader<File> {
  Ok(self.get_mut().metadata()?.len() as usize)
  }
 
+ fn get_unix_mtime(&mut self) -> Result<Option<i64>> {
+ let sys_time = self.get_mut().metadata()?.modified()?;
+ let dur = sys_time.duration_since(std::time::SystemTime::UNIX_EPOCH)?;
+ Ok(Some(dur.as_secs() as i64))
+ }
+
  fn try_seek(&mut self, pos: SeekFrom) -> Result<u64> {
  Ok(self.seek(pos)?)
  }