Mac core lib (#1307)

Author: CraftSpider

Cargo.lock

@@ -53,6 +53,7 @@ members = [
     "crates/errors",
     "crates/geturl",
     "crates/io_base",
+    "crates/mac_core",
     "crates/pdf_io",
     "crates/status_base",
     "crates/xdv",

Cargo.toml

@@ -0,0 +1,16 @@
+lints.workspace = true
+
+[package]
+name = "tectonic_mac_core"
+license = "MIT"
+version = "0.0.0-dev.0"
+edition = "2021"
+
+[dependencies]
+libc = "0.2"
+
+[build-dependencies]
+tectonic_cfg_support = { path = "../cfg_support", version = "0.0.0-dev.0" }
+
+[package.metadata.internal_dep_versions]
+tectonic_cfg_support = "thiscommit:aeRoo7oa"

crates/mac_core/Cargo.toml

@@ -0,0 +1,15 @@
+//! Mac core library build script. Links to framework libraries when targeting MacOS.
+
+use tectonic_cfg_support::target_cfg;
+
+fn main() {
+    let is_mac_os = target_cfg!(target_os = "macos");
+
+    if is_mac_os {
+        println!("cargo:rustc-link-lib=framework=Foundation");
+        println!("cargo:rustc-link-lib=framework=CoreFoundation");
+        println!("cargo:rustc-link-lib=framework=CoreGraphics");
+        println!("cargo:rustc-link-lib=framework=CoreText");
+        println!("cargo:rustc-link-lib=framework=AppKit");
+    }
+}

crates/mac_core/build.rs

@@ -0,0 +1,72 @@
+use super::{sys, CoreType};
+use std::marker::PhantomData;
+use std::ops::Index;
+use std::ptr;
+use std::ptr::NonNull;
+
+cfty! {
+    /// A homogeneous array of CFType values, similar to [`Vec`].
+    CFArray<T> : CFArrayGetTypeID
+}
+
+impl<T: CoreType> CFArray<T> {
+    /// Create a new, empty [`CFArray`].
+    pub fn empty() -> CFArray<T> {
+        // SAFETY: Valid to call with all null and zero length + default callbacks
+        let ptr = unsafe {
+            sys::CFArrayCreate(
+                ptr::null_mut(),
+                ptr::null_mut(),
+                0,
+                &sys::kCFTypeArrayCallBacks,
+            )
+        };
+        let ptr = NonNull::new(ptr.cast_mut()).unwrap();
+        // SAFETY: If non-null, pointer from CFArrayCreate is a new, owned CFArray.
+        unsafe { CFArray::new_owned(ptr) }
+    }
+
+    /// Create a new [`CFArray`] that contains the provided values.
+    pub fn new(values: &[T]) -> CFArray<T> {
+        // SAFETY: Length matches provided slice and values are `CoreType` so must be valid
+        //         CFTypeRefs.
+        let ptr = unsafe {
+            sys::CFArrayCreate(
+                ptr::null_mut(),
+                values.as_ptr().cast_mut().cast(),
+                values.len() as sys::CFIndex,
+                &sys::kCFTypeArrayCallBacks,
+            )
+        };
+        let ptr = NonNull::new(ptr.cast_mut()).unwrap();
+        // SAFETY: If non-null, pointer from CFCArrayCreate is a new, owned CFArray.
+        unsafe { CFArray::new_owned(ptr) }
+    }
+
+    /// Get the length of this array
+    pub fn len(&self) -> usize {
+        // SAFETY: Internal pointer is guaranteed valid.
+        unsafe { sys::CFArrayGetCount(self.0.as_ptr()) as usize }
+    }
+
+    /// Check whether this array is empty
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+
+impl<T: CoreType> Index<usize> for CFArray<T> {
+    type Output = T;
+
+    fn index(&self, index: usize) -> &Self::Output {
+        if index >= self.len() {
+            panic!("Index {index} out of bounds for CFArray");
+        }
+        // SAFETY: Internal pointer is guaranteed valid. Index has been verified in-bounds.
+        let ptr =
+            unsafe { sys::CFArrayGetValueAtIndex(self.0.cast().as_ptr(), index as sys::CFIndex) }
+                .cast::<T>();
+        // SAFETY: API contracts ensure all values are of the correct type and live for our lifetime.
+        unsafe { &*ptr }
+    }
+}

crates/mac_core/src/array.rs

@@ -0,0 +1,98 @@
+use super::{sys, CoreType};
+use std::marker::PhantomData;
+use std::mem::MaybeUninit;
+use std::ptr::NonNull;
+use std::{mem, ptr};
+
+pub trait AsPtr {
+    fn as_ptr(&self) -> *const ();
+    #[allow(clippy::len_without_is_empty)]
+    fn len(&self) -> usize;
+}
+
+impl<T> AsPtr for Vec<T> {
+    fn as_ptr(&self) -> *const () {
+        self.as_ptr().cast()
+    }
+
+    fn len(&self) -> usize {
+        self.len()
+    }
+}
+
+impl<T, const N: usize> AsPtr for [T; N] {
+    fn as_ptr(&self) -> *const () {
+        <[T]>::as_ptr(self).cast()
+    }
+
+    fn len(&self) -> usize {
+        N
+    }
+}
+
+pub trait Pairs {
+    type Keys: AsPtr;
+    type Values: AsPtr;
+
+    fn into_pairs(self) -> (Self::Keys, Self::Values);
+}
+
+impl<K, V, const N: usize> Pairs for [(K, V); N] {
+    type Keys = [K; N];
+    type Values = [V; N];
+
+    fn into_pairs(self) -> (Self::Keys, Self::Values) {
+        let mut keys: [MaybeUninit<K>; N] = [const { MaybeUninit::uninit() }; N];
+        let mut values: [MaybeUninit<V>; N] = [const { MaybeUninit::uninit() }; N];
+
+        for (idx, (key, val)) in self.into_iter().enumerate() {
+            keys[idx].write(key);
+            values[idx].write(val);
+        }
+
+        // SAFETY: All values in both arrays have been initialized
+        unsafe {
+            (
+                mem::transmute_copy::<_, [K; N]>(&keys),
+                mem::transmute_copy::<_, [V; N]>(&values),
+            )
+        }
+    }
+}
+
+impl<K, V> Pairs for Vec<(K, V)> {
+    type Keys = Vec<K>;
+    type Values = Vec<V>;
+
+    fn into_pairs(self) -> (Self::Keys, Self::Values) {
+        self.into_iter().unzip()
+    }
+}
+
+cfty! {
+    /// A dictionary / map of CFType keys to values, similar to [`HashMap`](std::collections::HashMap)
+    CFDictionary<K, V> : CFDictionaryGetTypeID
+}
+
+impl<K: CoreType, V: CoreType> CFDictionary<K, V> {
+    /// Create a new [`CFDictionary`] that contains the provided key/value pairs.
+    pub fn new<P: Pairs>(pairs: P) -> CFDictionary<K, V> {
+        let (keys, values) = pairs.into_pairs();
+
+        // SAFETY: Length matches provided slices and values are `CoreType` so must be valid
+        //         CFTypeRefs.
+        let ptr = unsafe {
+            sys::CFDictionaryCreate(
+                ptr::null_mut(),
+                keys.as_ptr().cast_mut().cast(),
+                values.as_ptr().cast_mut().cast(),
+                keys.len() as sys::CFIndex,
+                &sys::kCFTypeDictionaryKeyCallBacks,
+                &sys::kCFTypeDictionaryValueCallBacks,
+            )
+        };
+        let ptr = NonNull::new(ptr.cast_mut()).unwrap();
+        // SAFETY: If non-null, pointer from CFDictionaryCreate is a new, owned CFDictionary.
+        unsafe { CFDictionary::new_owned(ptr) }
+    }
+}

crates/mac_core/src/dict.rs

@@ -0,0 +1,128 @@
+use super::{sys, CFString, CFType, CTFontDescriptor, CoreType};
+use std::ptr;
+use std::ptr::NonNull;
+
+/// An attribute that may be found in a font, such as family name or URL.
+#[derive(Copy, Clone)]
+pub enum FontAttribute {
+    /// Name
+    Name,
+    /// Family Name
+    FamilyName,
+    /// Display Name
+    DisplayName,
+    /// URL
+    URL,
+    /// Cascade List - fallbacks to use if glyph not present in this font.
+    CascadeList,
+}
+
+impl FontAttribute {
+    /// Convert this attribute into its matching [`CFString`].
+    pub fn to_str(self) -> CFString {
+        let ptr = NonNull::new(self.to_raw().cast_mut()).unwrap();
+        // SAFETY: The value returned by `to_raw` is guaranteed to be a valid CFStringRef
+        unsafe { CFString::new_borrowed(ptr) }
+    }
+
+    /// Convert this attribute into a raw pointer to a [`CFString`].
+    pub fn to_raw(self) -> sys::CFStringRef {
+        match self {
+            // SAFETY: Static guaranteed to exist and by a valid CFStringRef
+            FontAttribute::Name => unsafe { sys::kCTFontNameAttribute },
+            // SAFETY: sic
+            FontAttribute::FamilyName => unsafe { sys::kCTFontFamilyNameAttribute },
+            // SAFETY: sic
+            FontAttribute::DisplayName => unsafe { sys::kCTFontDisplayNameAttribute },
+            // SAFETY: sic
+            FontAttribute::URL => unsafe { sys::kCTFontURLAttribute },
+            // SAFETY: sic
+            FontAttribute::CascadeList => unsafe { sys::kCTFontCascadeListAttribute },
+        }
+    }
+}
+
+/// A type of font name that may be available.
+#[derive(Copy, Clone)]
+pub enum FontNameKey {
+    /// Full name
+    Full,
+    /// Family name
+    Family,
+    /// Style name
+    Style,
+    /// PostScript name
+    PostScript,
+}
+
+impl FontNameKey {
+    /// Convert this attribute into its matching [`CFString`].
+    pub fn to_str(self) -> CFString {
+        let ptr = NonNull::new(self.to_raw().cast_mut()).unwrap();
+        // SAFETY: The value returned by `to_raw` is guaranteed to be a valid CFStringRef
+        unsafe { CFString::new_borrowed(ptr) }
+    }
+
+    fn to_raw(self) -> sys::CFStringRef {
+        match self {
+            // SAFETY: Static guaranteed to exist and by a valid CFStringRef
+            FontNameKey::Full => unsafe { sys::kCTFontFullNameKey },
+            // SAFETY: sic
+            FontNameKey::Family => unsafe { sys::kCTFontFamilyNameKey },
+            // SAFETY: sic
+            FontNameKey::Style => unsafe { sys::kCTFontStyleNameKey },
+            // SAFETY: sic
+            FontNameKey::PostScript => unsafe { sys::kCTFontPostScriptNameKey },
+        }
+    }
+}
+
+cfty! {
+    /// A font, combining a descriptor and a size, as well as any other necessary transforms to
+    /// render glyphs.
+    CTFont : CTFontGetTypeID
+}
+
+impl CTFont {
+    /// Create a new font from a [`CTFontDescriptor`] and a size to render at.
+    pub fn new_descriptor(descriptor: &CTFontDescriptor, size: f64) -> CTFont {
+        // SAFETY: Provided descriptor is guaranteed valid. Any size will work. Null matrix is always
+        //         allowed.
+        let ptr = unsafe {
+            sys::CTFontCreateWithFontDescriptor(
+                descriptor.as_type_ref(),
+                size as sys::CGFloat,
+                ptr::null_mut(),
+            )
+        };
+        let ptr = NonNull::new(ptr.cast_mut()).unwrap();
+        // SAFETY: If non-null, pointer from CTFontCreateWithFontDescriptor is a new, owned CTFont.
+        unsafe { CTFont::new_owned(ptr) }
+    }
+
+    /// Get an attribute of this font, if present
+    pub fn attr(&self, attr: FontAttribute) -> Option<CFType> {
+        // SAFETY: Internal pointer and attribute string guaranteed valid.
+        let ptr = unsafe { sys::CTFontCopyAttribute(self.as_type_ref(), attr.to_raw()) };
+        // SAFETY: In non-null, returned name guaranteed valid and owned.
+        NonNull::new(ptr.cast_mut()).map(|ptr| unsafe { CFType::new_owned(ptr) })
+    }
+
+    /// Get a name value of this font, if present
+    pub fn name(&self, name: FontNameKey) -> Option<CFString> {
+        // SAFETY: Internal pointer and name string guaranteed valid.
+        let ptr = unsafe { sys::CTFontCopyName(self.as_type_ref(), name.to_raw()) };
+        // SAFETY: In non-null, returned name guaranteed valid and owned.
+        NonNull::new(ptr.cast_mut()).map(|ptr| unsafe { CFString::new_owned(ptr) })
+    }
+
+    /// Get the name of this font, localized to a specific language
+    pub fn localized_name(&self, name: FontNameKey) -> Option<CFString> {
+        // SAFETY: Internal pointer and name string guaranteed valid.
+        let ptr = unsafe {
+            sys::CTFontCopyLocalizedName(self.as_type_ref(), name.to_raw(), ptr::null_mut())
+        };
+        // SAFETY: In non-null, returned name guaranteed valid and owned.
+        NonNull::new(ptr.cast_mut()).map(|ptr| unsafe { CFString::new_owned(ptr) })
+    }
+}