Use font-kit to implement XeTeXFontInst

bridge/Cargo.toml

@@ -9,3 +9,4 @@ cc = "^1.0"
 
 [dependencies]
 libc = "0.2"
+anyhow = "1.0.19"

bridge/src/lib.rs

@@ -9,7 +9,7 @@
     unused_mut
 )]
 
-use std::io::{prelude::*, Result};
+use std::io::{self, prelude::*, Result, ErrorKind};
 use std::io::SeekFrom;
 use std::ptr::NonNull;
 
@@ -52,12 +52,29 @@ impl Write for OutputHandleWrapper {
 }
 
 #[derive(Clone, PartialEq)]
+#[repr(transparent)]
 pub struct InputHandleWrapper(pub NonNull<libc::c_void>);
 
 impl Read for InputHandleWrapper {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
         unsafe {
-            Ok(ttstub_input_read(self.0.as_ptr(), buf.as_mut_ptr() as *mut i8, buf.len() as u64) as usize)
+            let read_isize = ttstub_input_read(self.0.as_ptr(), buf.as_mut_ptr() as *mut i8, buf.len() as u64);
+            if read_isize < 0 {
+                Err(io::Error::new(ErrorKind::Other, anyhow::anyhow!("Unknown -1 error code from across the bridge while reading input handle")))
+            } else {
+                Ok(read_isize as usize)
+            }
+        }
+    }
+
+    fn read_exact(&mut self, buf: &mut [u8]) -> Result<()> {
+        unsafe {
+            let read_isize = ttstub_input_read_exact(self.0.as_ptr(), buf.as_mut_ptr() as *mut i8, buf.len() as u64);
+            if read_isize < 0 {
+                Err(io::Error::new(ErrorKind::Other, anyhow::anyhow!("Unknown -1 error code from across the bridge while reading input handle (with read_exact)")))
+            } else {
+                Ok(())
+            }
         }
     }
 }
@@ -71,7 +88,8 @@ impl Seek for InputHandleWrapper {
             SeekFrom::End(o) => (o as ssize_t, SEEK_END),
         };
         unsafe {
-            Ok(ttstub_input_seek(self.0.as_ptr(), offset, whence) as u64)
+            let sought = ttstub_input_seek(self.0.as_ptr(), offset, whence);
+            Ok(sought as u64)
         }
     }
 }
@@ -86,46 +104,46 @@ impl InputHandleWrapper {
 #[repr(C)]
 pub struct tt_bridge_api_t {
     pub context: *mut libc::c_void,
-    pub issue_warning: Option<unsafe extern "C" fn(_: *mut libc::c_void, _: *const i8) -> ()>,
-    pub issue_error: Option<unsafe extern "C" fn(_: *mut libc::c_void, _: *const i8) -> ()>,
+    pub issue_warning: Option<unsafe fn(_: *mut libc::c_void, _: *const i8) -> ()>,
+    pub issue_error: Option<unsafe fn(_: *mut libc::c_void, _: *const i8) -> ()>,
     pub get_file_md5:
-        Option<unsafe extern "C" fn(_: *mut libc::c_void, _: *const i8, _: *mut i8) -> i32>,
+        Option<unsafe fn(_: *mut libc::c_void, _: *const i8, _: *mut i8) -> i32>,
     pub get_data_md5: Option<
-        unsafe extern "C" fn(_: *mut libc::c_void, _: *const i8, _: size_t, _: *mut i8) -> i32,
+        unsafe fn(_: *mut libc::c_void, _: *const i8, _: size_t, _: *mut i8) -> i32,
     >,
     pub output_open: Option<
-        unsafe extern "C" fn(_: *mut libc::c_void, _: *const i8, _: i32) -> rust_output_handle_t,
+        unsafe fn(_: *mut libc::c_void, _: *const i8, _: i32) -> rust_output_handle_t,
     >,
     pub output_open_stdout:
-        Option<unsafe extern "C" fn(_: *mut libc::c_void) -> rust_output_handle_t>,
+        Option<unsafe fn(_: *mut libc::c_void) -> rust_output_handle_t>,
     pub output_putc:
-        Option<unsafe extern "C" fn(_: *mut libc::c_void, _: rust_output_handle_t, _: i32) -> i32>,
+        Option<unsafe fn(_: *mut libc::c_void, _: rust_output_handle_t, _: i32) -> i32>,
     pub output_write: Option<
-        unsafe extern "C" fn(
+        unsafe fn(
             _: *mut libc::c_void,
             _: rust_output_handle_t,
             _: *const i8,
             _: size_t,
         ) -> size_t,
     >,
     pub output_flush:
-        Option<unsafe extern "C" fn(_: *mut libc::c_void, _: rust_output_handle_t) -> i32>,
+        Option<unsafe fn(_: *mut libc::c_void, _: rust_output_handle_t) -> i32>,
     pub output_close:
-        Option<unsafe extern "C" fn(_: *mut libc::c_void, _: rust_output_handle_t) -> i32>,
+        Option<unsafe fn(_: *mut libc::c_void, _: rust_output_handle_t) -> i32>,
     pub input_open: Option<
-        unsafe extern "C" fn(
+        unsafe fn(
             _: *mut libc::c_void,
             _: *const i8,
             _: TTInputFormat,
             _: i32,
         ) -> rust_input_handle_t,
     >,
     pub input_open_primary:
-        Option<unsafe extern "C" fn(_: *mut libc::c_void) -> rust_input_handle_t>,
+        Option<unsafe fn(_: *mut libc::c_void) -> rust_input_handle_t>,
     pub input_get_size:
-        Option<unsafe extern "C" fn(_: *mut libc::c_void, _: rust_input_handle_t) -> size_t>,
+        Option<unsafe fn(_: *mut libc::c_void, _: rust_input_handle_t) -> size_t>,
     pub input_seek: Option<
-        unsafe extern "C" fn(
+        unsafe fn(
             _: *mut libc::c_void,
             _: rust_input_handle_t,
             _: ssize_t,
@@ -134,19 +152,27 @@ pub struct tt_bridge_api_t {
         ) -> size_t,
     >,
     pub input_read: Option<
-        unsafe extern "C" fn(
+        unsafe fn(
+            _: *mut libc::c_void,
+            _: rust_input_handle_t,
+            _: *mut i8,
+            _: size_t,
+        ) -> ssize_t,
+    >,
+    pub input_read_exact: Option<
+        unsafe fn(
             _: *mut libc::c_void,
             _: rust_input_handle_t,
             _: *mut i8,
             _: size_t,
         ) -> ssize_t,
     >,
     pub input_getc:
-        Option<unsafe extern "C" fn(_: *mut libc::c_void, _: rust_input_handle_t) -> i32>,
+        Option<unsafe fn(_: *mut libc::c_void, _: rust_input_handle_t) -> i32>,
     pub input_ungetc:
-        Option<unsafe extern "C" fn(_: *mut libc::c_void, _: rust_input_handle_t, _: i32) -> i32>,
+        Option<unsafe fn(_: *mut libc::c_void, _: rust_input_handle_t, _: i32) -> i32>,
     pub input_close:
-        Option<unsafe extern "C" fn(_: *mut libc::c_void, _: rust_input_handle_t) -> i32>,
+        Option<unsafe fn(_: *mut libc::c_void, _: rust_input_handle_t) -> i32>,
 }
 
 #[repr(C)]
@@ -161,8 +187,11 @@ pub enum TTHistory {
 #[repr(C)]
 #[derive(Clone, Copy, PartialEq)]
 pub enum TTInputFormat {
+    /// TeX Font Metric
     TFM = 3,
+    /// Adobe Font Metric
     AFM = 4,
+    /// BibTeX
     BIB = 6,
     BST = 7,
     CNF = 8,
@@ -371,6 +400,7 @@ pub unsafe extern "C" fn ttstub_input_seek(
     }
     rv
 }
+
 #[no_mangle]
 pub unsafe extern "C" fn ttstub_input_read(
     mut handle: rust_input_handle_t,
@@ -383,18 +413,34 @@ pub unsafe extern "C" fn ttstub_input_read(
         (*tectonic_global_bridge).context, handle, data, len
     )
 }
+
+#[no_mangle]
+pub unsafe extern "C" fn ttstub_input_read_exact(
+    mut handle: rust_input_handle_t,
+    mut data: *mut i8,
+    mut len: size_t,
+) -> ssize_t {
+    (*tectonic_global_bridge)
+        .input_read_exact
+        .expect("non-null function pointer")(
+        (*tectonic_global_bridge).context, handle, data, len
+    )
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn ttstub_input_getc(handle: &mut InputHandleWrapper) -> i32 {
     (*tectonic_global_bridge)
         .input_getc
         .expect("non-null function pointer")((*tectonic_global_bridge).context, handle.0.as_ptr())
 }
+
 #[no_mangle]
 pub unsafe extern "C" fn ttstub_input_ungetc(handle: &mut InputHandleWrapper, mut ch: i32) -> i32 {
     (*tectonic_global_bridge)
         .input_ungetc
         .expect("non-null function pointer")((*tectonic_global_bridge).context, handle.0.as_ptr(), ch)
 }
+
 #[no_mangle]
 pub unsafe extern "C" fn ttstub_input_close(mut handle: InputHandleWrapper) -> i32 {
     if (*tectonic_global_bridge)

dpx/src/dpx_bmpimage.rs

@@ -36,7 +36,7 @@ use crate::dpx_pdfobj::{
     pdf_stream_set_predictor, STREAM_COMPRESS,
 };
 use crate::warn;
-use crate::{ttstub_input_read};
+use crate::{ttstub_input_read_exact};
 use libc::{free, memset};
 
 use std::io::{Seek, SeekFrom};
@@ -63,7 +63,7 @@ pub struct hdr_info {
 pub unsafe extern "C" fn check_for_bmp(handle: &mut InputHandleWrapper) -> i32 {
     let mut sigbytes: [u8; 2] = [0; 2];
     handle.seek(SeekFrom::Start(0)).unwrap();
-    if ttstub_input_read(
+    if ttstub_input_read_exact(
         handle.0.as_ptr(),
         sigbytes.as_mut_ptr() as *mut i8,
         ::std::mem::size_of::<[u8; 2]>() as u64,
@@ -192,7 +192,7 @@ pub unsafe extern "C" fn bmp_include_image(
         let palette = new(((num_palette * 3i32 + 1i32) as u32 as u64)
             .wrapping_mul(::std::mem::size_of::<u8>() as u64) as u32) as *mut u8;
         for i in 0..num_palette {
-            if ttstub_input_read(handle.0.as_ptr(), bgrq.as_mut_ptr() as *mut i8, hdr.psize as size_t)
+            if ttstub_input_read_exact(handle.0.as_ptr(), bgrq.as_mut_ptr() as *mut i8, hdr.psize as size_t)
                 != hdr.psize as i64
             {
                 warn!("Reading file failed...");
@@ -235,7 +235,7 @@ pub unsafe extern "C" fn bmp_include_image(
         let mut n = 0i32;
         while n < info.height {
             let p = stream_data_ptr.offset((n * rowbytes) as isize);
-            if ttstub_input_read(handle.0.as_ptr(), p as *mut i8, dib_rowbytes as size_t)
+            if ttstub_input_read_exact(handle.0.as_ptr(), p as *mut i8, dib_rowbytes as size_t)
                 != dib_rowbytes as i64
             {
                 warn!("Reading BMP raster data failed...");
@@ -316,7 +316,7 @@ use crate::FromLEByteSlice;
 unsafe fn read_header(handle: &mut InputHandleWrapper, hdr: &mut hdr_info) -> i32 {
     let mut buf: [u8; 142] = [0; 142];
     let p = &mut buf;
-    if ttstub_input_read(handle.0.as_ptr(), p.as_mut_ptr() as *mut i8, (14i32 + 4i32) as size_t)
+    if ttstub_input_read_exact(handle.0.as_ptr(), p.as_mut_ptr() as *mut i8, (14i32 + 4i32) as size_t)
         != (14i32 + 4i32) as i64
     {
         warn!("Could not read BMP file header...");
@@ -339,7 +339,7 @@ unsafe fn read_header(handle: &mut InputHandleWrapper, hdr: &mut hdr_info) -> i3
     /* info header */
     hdr.hsize = u32::from_le_byte_slice(&p[..4]); /* undefined. FIXME */
     let p = &mut p[4..]; /* undefined. FIXME */
-    if ttstub_input_read(
+    if ttstub_input_read_exact(
         handle.0.as_ptr(),
         p.as_mut_ptr() as *mut i8,
         hdr.hsize.wrapping_sub(4_u32) as size_t,
@@ -439,7 +439,7 @@ unsafe fn read_raster_rle8(
                             warn!("RLE decode failed...");
                             return -1i32;
                         }
-                        if ttstub_input_read(handle.0.as_ptr(), p as *mut i8, b1 as size_t) != b1 as i64 {
+                        if ttstub_input_read_exact(handle.0.as_ptr(), p as *mut i8, b1 as size_t) != b1 as i64 {
                             return -1i32;
                         }
                         count += b1 as i32;
@@ -534,7 +534,7 @@ unsafe fn read_raster_rle4(
                                 *fresh0 = (*fresh0 as i32 | b as i32 >> 4i32 & 0xfi32) as u8;
                                 *p = ((b as i32) << 4i32 & 0xf0i32) as u8;
                             }
-                        } else if ttstub_input_read(handle.0.as_ptr(), p as *mut i8, nbytes as size_t)
+                        } else if ttstub_input_read_exact(handle.0.as_ptr(), p as *mut i8, nbytes as size_t)
                             != nbytes as i64
                         {
                             return -1i32;

dpx/src/dpx_cff.rs

@@ -33,7 +33,7 @@ use crate::warn;
 use super::dpx_cff_dict::{cff_dict_get, cff_dict_known, cff_dict_unpack, cff_release_dict};
 use super::dpx_mem::{new, renew};
 use super::dpx_numbers::{tt_get_unsigned_byte, tt_get_unsigned_pair};
-use crate::{ttstub_input_read};
+use crate::{ttstub_input_read_exact};
 use libc::{free, memcmp, memcpy, memmove, memset, strlen};
 
 use std::io::{Seek, SeekFrom};
@@ -1041,7 +1041,7 @@ pub unsafe extern "C" fn cff_get_index(cff: &mut cff_font) -> *mut cff_index {
                 as *mut u8;
         let mut offset = 0;
         while length > 0i32 {
-            let nb_read = ttstub_input_read(
+            let nb_read = ttstub_input_read_exact(
                 handle.0.as_ptr(),
                 ((*idx).data as *mut i8).offset(offset as isize),
                 length as size_t,
@@ -2277,7 +2277,7 @@ pub unsafe extern "C" fn cff_read_private(cff: &mut cff_font) -> i32 {
                 let data = new(
                     (size as u32 as u64).wrapping_mul(::std::mem::size_of::<u8>() as u64) as u32,
                 ) as *mut u8;
-                if ttstub_input_read(handle.0.as_ptr(), data as *mut i8, size as size_t) != size as i64 {
+                if ttstub_input_read_exact(handle.0.as_ptr(), data as *mut i8, size as size_t) != size as i64 {
                     panic!("reading file failed");
                 }
                 let ref mut fresh53 = *cff.private.offset(i as isize);
@@ -2305,7 +2305,7 @@ pub unsafe extern "C" fn cff_read_private(cff: &mut cff_font) -> i32 {
             let data =
                 new((size as u32 as u64).wrapping_mul(::std::mem::size_of::<u8>() as u64) as u32)
                     as *mut u8;
-            if ttstub_input_read(handle.0.as_ptr(), data as *mut i8, size as size_t) != size as i64 {
+            if ttstub_input_read_exact(handle.0.as_ptr(), data as *mut i8, size as size_t) != size as i64 {
                 panic!("reading file failed");
             }
             let ref mut fresh55 = *cff.private.offset(0);

dpx/src/dpx_cidtype0.rs

@@ -85,7 +85,7 @@ use crate::dpx_pdfobj::{
 };
 use crate::dpx_truetype::sfnt_table_info;
 use crate::shims::sprintf;
-use crate::{ttstub_input_read};
+use crate::{ttstub_input_read_exact};
 use libc::{free, memmove, memset, strcat, strcmp, strcpy, strlen, strstr};
 
 use std::io::{Seek, SeekFrom};
@@ -849,7 +849,7 @@ pub unsafe extern "C" fn CIDFont_type0_dofont(mut font: *mut CIDFont) {
             *(*charstrings).offset.offset(gid as isize) = (charstring_len + 1i32) as l_offset;
             let handle = cffont.handle.as_mut().unwrap();
             handle.seek(SeekFrom::Start(offset as u64 + *(*idx).offset.offset(gid_org as isize) as u64 - 1)).unwrap();
-            ttstub_input_read(handle.0.as_ptr(), data as *mut i8, size as size_t);
+            ttstub_input_read_exact(handle.0.as_ptr(), data as *mut i8, size as size_t);
             let fd = cff_fdselect_lookup(cffont, gid_org) as i32;
             charstring_len += cs_copy_charstring(
                 (*charstrings).data.offset(charstring_len as isize),
@@ -1395,7 +1395,7 @@ pub unsafe extern "C" fn CIDFont_type0_t1cdofont(mut font: *mut CIDFont) {
             *(*charstrings).offset.offset(gid as isize) = (charstring_len + 1i32) as l_offset;
             let handle = cffont.handle.as_mut().unwrap();
             handle.seek(SeekFrom::Start(offset as u64 + *(*idx).offset.offset(cid as isize) as u64 - 1 )).unwrap();
-            ttstub_input_read(handle.0.as_ptr(), data as *mut i8, size as size_t);
+            ttstub_input_read_exact(handle.0.as_ptr(), data as *mut i8, size as size_t);
             charstring_len += cs_copy_charstring(
                 (*charstrings).data.offset(charstring_len as isize),
                 max_len - charstring_len,

dpx/src/dpx_cmap_read.rs

@@ -45,7 +45,7 @@ use super::dpx_pst_obj::pst_obj;
 use super::dpx_pst_obj::{
     pst_data_ptr, pst_getIV, pst_getSV, pst_length_of, pst_release_obj, pst_type_of,
 };
-use crate::{ttstub_input_get_size, ttstub_input_read};
+use crate::{ttstub_input_get_size, ttstub_input_read_exact};
 use libc::{free, memcmp, memcpy, memmove, strcmp, strlen, strstr};
 
 pub type __ssize_t = i64;
@@ -122,7 +122,7 @@ unsafe fn ifreader_read(mut reader: *mut ifreader, mut size: size_t) -> size_t {
         );
         (*reader).cursor = (*reader).buf;
         (*reader).endptr = (*reader).buf.offset(bytesrem as isize);
-        if ttstub_input_read((*reader).handle.0.as_ptr(), (*reader).endptr as *mut i8, bytesread) as u64
+        if ttstub_input_read_exact((*reader).handle.0.as_ptr(), (*reader).endptr as *mut i8, bytesread) as u64
             != bytesread
         {
             panic!("Reading file failed.");
@@ -680,7 +680,7 @@ pub unsafe extern "C" fn CMap_parse_check_sig(handle: Option<&mut InputHandleWra
     }
     let mut handle = handle.unwrap();
     handle.seek(SeekFrom::Start(0)).unwrap();
-    if ttstub_input_read(handle.0.as_ptr(), sig.as_mut_ptr(), 64i32 as size_t) != 64i32 as i64 {
+    if ttstub_input_read_exact(handle.0.as_ptr(), sig.as_mut_ptr(), 64i32 as size_t) != 64i32 as i64 {
         result = -1i32
     } else {
         sig[64] = 0_i8;

dpx/src/dpx_dvi.rs

@@ -86,7 +86,7 @@ use crate::specials::{
 };
 use crate::{
     ttstub_input_close, ttstub_input_get_size, ttstub_input_getc, ttstub_input_open,
-    ttstub_input_read, ttstub_input_ungetc,
+    ttstub_input_read_exact, ttstub_input_ungetc,
 };
 use crate::dpx_dvicodes::*;
 
@@ -537,14 +537,14 @@ unsafe fn read_font_record(mut tex_id: u32) {
     let directory = new(
         ((dir_length + 1i32) as u32 as u64).wrapping_mul(::std::mem::size_of::<i8>() as u64) as u32
     ) as *mut i8;
-    if ttstub_input_read(handle.0.as_ptr(), directory, dir_length as size_t) != dir_length as i64 {
+    if ttstub_input_read_exact(handle.0.as_ptr(), directory, dir_length as size_t) != dir_length as i64 {
         panic!(invalid_signature);
     }
     *directory.offset(dir_length as isize) = '\u{0}' as i32 as i8;
     free(directory as *mut libc::c_void);
     let font_name = new(((name_length + 1i32) as u32 as u64)
         .wrapping_mul(::std::mem::size_of::<i8>() as u64) as u32) as *mut i8;
-    if ttstub_input_read(handle.0.as_ptr(), font_name, name_length as size_t) != name_length as i64 {
+    if ttstub_input_read_exact(handle.0.as_ptr(), font_name, name_length as size_t) != name_length as i64 {
         panic!(invalid_signature);
     }
     *font_name.offset(name_length as isize) = '\u{0}' as i32 as i8;
@@ -582,7 +582,7 @@ unsafe fn read_native_font_record(mut tex_id: u32) {
     let font_name =
         new(((len + 1i32) as u32 as u64).wrapping_mul(::std::mem::size_of::<i8>() as u64) as u32)
             as *mut i8;
-    if ttstub_input_read(handle.0.as_ptr(), font_name, len as size_t) != len as i64 {
+    if ttstub_input_read_exact(handle.0.as_ptr(), font_name, len as size_t) != len as i64 {
         panic!(invalid_signature);
     }
     *font_name.offset(len as isize) = '\u{0}' as i32 as i8;