Merge pull request #336 from burrbull/mngr

oxidize font manager

Author: burrbull

Cargo.lock

@@ -19,7 +19,7 @@ euclid = "0.20"
 indexmap = "1.3.0"
 png = "0.16"
 itoa = "0.4.6"
-once_cell = "1.4.1"
+once_cell = "1.5.2"
 arrayvec = "0.5"
 
 [features]

dpx/Cargo.toml

@@ -43,6 +43,7 @@ enumn = "0.1.2"
 derive_more = "0.99.7"
 md5 = "0.7"
 fontconfig_sys = { package = "yeslogic-fontconfig-sys", version = "2.11.1" }
+once_cell = "1.5.2"
 
 [target.'cfg(target_os = "macos")'.dependencies]
 core-foundation = "0.9.1"

engine/Cargo.toml

@@ -126,11 +126,6 @@ mod core_memory {
         }
         new_mem
     }
-    pub(crate) unsafe fn strdup(s: &str) -> *mut i8 {
-        let new_string = xmalloc((s.len() + 1) as size_t) as *mut i8;
-        let s = std::ffi::CString::new(s).unwrap();
-        libc::strcpy(new_string, s.as_ptr())
-    }
 
     #[inline]
     pub(crate) unsafe fn mfree(ptr: *mut libc::c_void) -> *mut libc::c_void {

engine/src/lib.rs

@@ -2277,8 +2277,8 @@ pub(crate) mod math {
             self.val.chr = c;
             self.typ = MathCell::MathTextChar;
         }*/
-        pub(crate) unsafe fn fetch(&mut self) {
-            crate::xetex_math::fetch(self);
+        pub(crate) unsafe fn fetch(&mut self) -> (usize, char) {
+            crate::xetex_math::fetch(self)
         }
     }
     // ---------------

engine/src/node.rs

@@ -673,7 +673,7 @@ pub(crate) unsafe fn load_native_font(name: &str, s: Scaled) -> Result<usize, Na
     FONT_MAPPING[FONT_PTR] = ptr::null_mut();
     FONT_LETTER_SPACE[FONT_PTR] = loaded_font_letter_space;
     /* "measure the width of the space character and set up font parameters" */
-    let p = new_native_character(FONT_PTR, ' ' as i32);
+    let p = new_native_character(FONT_PTR, ' ');
     let s = p.width() + loaded_font_letter_space;
     p.free();
 

engine/src/tfm.rs

@@ -21,9 +21,8 @@ use crate::xetex_ini::{
     loaded_font_flags, loaded_font_letter_space, FONT_LAYOUT_ENGINE, FONT_LETTER_SPACE,
 };
 use crate::xetex_xetex0::font_feature_warning;
-use libc::{free, strlen};
+use libc::free;
 pub(crate) type Boolean = libc::c_uchar;
-use crate::xetex_output::print_chr;
 
 use crate::xetex_scaledmath::Scaled;
 type Fract = i32;
@@ -103,7 +102,7 @@ pub(crate) unsafe fn do_aat_layout(node: &mut NativeWord, justify: bool) {
     let mut glyph_info: *mut libc::c_void = ptr::null_mut();
     let mut locations: *mut FixedPoint = ptr::null_mut();
     let mut width: CGFloat = 0.;
-    let mut typesetter;
+    let typesetter;
     let mut line;
     let f = node.font() as libc::c_uint;
     if let Font::Native(Aat(attributes)) = &FONT_LAYOUT_ENGINE[f as usize] {
@@ -149,36 +148,38 @@ pub(crate) unsafe fn do_aat_layout(node: &mut NativeWord, justify: bool) {
             width = 0i32 as CGFloat;
             for i in 0..runCount {
                 let run = CFArrayGetValueAtIndex(glyphRuns, i) as CTRunRef;
-                let count = CTRunGetGlyphCount(run);
+                let count = CTRunGetGlyphCount(run) as usize;
                 let runAttributes = CTRunGetAttributes(run);
                 let vertical = CFDictionaryGetValue(
                     runAttributes,
                     kCTVerticalFormsAttributeName as *const libc::c_void,
                 ) as CFBooleanRef;
                 // TODO(jjgod): Avoid unnecessary allocation with CTRunGetFoosPtr().
-                let glyphs =
-                    xmalloc((count as usize).wrapping_mul(::std::mem::size_of::<CGGlyph>()) as _)
-                        as *mut CGGlyph;
-                let positions =
-                    xmalloc((count as usize).wrapping_mul(::std::mem::size_of::<CGPoint>()) as _)
-                        as *mut CGPoint;
-                let advances =
-                    xmalloc((count as usize).wrapping_mul(::std::mem::size_of::<CGSize>()) as _)
-                        as *mut CGSize;
+                let mut glyphs = vec![0 as CGGlyph; count];
+                let mut positions = vec![CGPoint::new(0., 0.); count];
+                let mut advances = vec![CGSize::new(0., 0.); count];
                 let runWidth = CTRunGetTypographicBounds(
                     run,
                     CFRangeMake(0i32 as CFIndex, 0i32 as CFIndex),
                     ptr::null_mut(),
                     ptr::null_mut(),
                     ptr::null_mut(),
                 );
-                CTRunGetGlyphs(run, CFRangeMake(0i32 as CFIndex, 0i32 as CFIndex), glyphs);
+                CTRunGetGlyphs(
+                    run,
+                    CFRangeMake(0i32 as CFIndex, 0i32 as CFIndex),
+                    glyphs.as_mut_ptr(),
+                );
                 CTRunGetPositions(
                     run,
                     CFRangeMake(0i32 as CFIndex, 0i32 as CFIndex),
-                    positions,
+                    positions.as_mut_ptr(),
+                );
+                CTRunGetAdvances(
+                    run,
+                    CFRangeMake(0i32 as CFIndex, 0i32 as CFIndex),
+                    advances.as_mut_ptr(),
                 );
-                CTRunGetAdvances(run, CFRangeMake(0i32 as CFIndex, 0i32 as CFIndex), advances);
                 for j in 0..count {
                     // XXX Core Text has that font cascading thing that will do
                     // font substitution for missing glyphs, which we do not want
@@ -193,28 +194,25 @@ pub(crate) unsafe fn do_aat_layout(node: &mut NativeWord, justify: bool) {
                     {
                         *glyphIDs.offset(totalGlyphCount as isize) = 0i32 as u16
                     } else {
-                        *glyphIDs.offset(totalGlyphCount as isize) = *glyphs.offset(j as isize)
+                        *glyphIDs.offset(totalGlyphCount as isize) = glyphs[j]
                     }
                     // Swap X and Y when doing vertical layout
                     if vertical == kCFBooleanTrue {
                         (*locations.offset(totalGlyphCount as isize)).x =
-                            -FixedPStoTeXPoints((*positions.offset(j as isize)).y);
+                            -FixedPStoTeXPoints(positions[j].y);
                         (*locations.offset(totalGlyphCount as isize)).y =
-                            FixedPStoTeXPoints((*positions.offset(j as isize)).x)
+                            FixedPStoTeXPoints(positions[j].x)
                     } else {
                         (*locations.offset(totalGlyphCount as isize)).x =
-                            FixedPStoTeXPoints((*positions.offset(j as isize)).x);
+                            FixedPStoTeXPoints(positions[j].x);
                         (*locations.offset(totalGlyphCount as isize)).y =
-                            -FixedPStoTeXPoints((*positions.offset(j as isize)).y)
+                            -FixedPStoTeXPoints(positions[j].y)
                     }
                     *glyphAdvances.offset(totalGlyphCount as isize) =
-                        Scaled((*advances.offset(j as isize)).width as i32);
+                        Scaled(advances[j].width as i32);
                     totalGlyphCount += 1;
                 }
                 width += FixedPStoTeXPoints(runWidth).0 as f64;
-                free(glyphs as *mut libc::c_void);
-                free(positions as *mut libc::c_void);
-                free(advances as *mut libc::c_void);
             }
         }
     } else {
@@ -373,32 +371,22 @@ pub(crate) unsafe fn GetGlyphItalCorr_AAT(attributes: CFDictionaryRef, mut gid:
     }
     return 0i32 as f64;
 }
-unsafe fn mapCharToGlyphFromCTFont(font: CTFontRef, mut ch: u32) -> libc::c_int {
+unsafe fn mapCharToGlyphFromCTFont(font: CTFontRef, ch: char) -> libc::c_int {
     let mut glyphs: [CGGlyph; 2] = [0i32 as CGGlyph, 0];
-    let mut txt: [UniChar; 2] = [0; 2];
-    let mut len: libc::c_int = 1i32;
-    if ch > 0xffffi32 as libc::c_uint {
-        ch = (ch as libc::c_uint).wrapping_sub(0x10000i32 as libc::c_uint) as u32;
-        txt[0] = (0xd800i32 as libc::c_uint).wrapping_add(ch.wrapping_div(1024i32 as libc::c_uint))
-            as UniChar;
-        txt[1] = (0xdc00i32 as libc::c_uint).wrapping_add(ch.wrapping_rem(1024i32 as libc::c_uint))
-            as UniChar;
-        len = 2i32
-    } else {
-        txt[0] = ch as UniChar
-    }
+    let mut txt = [0; 2];
+    let result = ch.encode_utf16(&mut txt);
     if CTFontGetGlyphsForCharacters(
         font,
-        txt.as_mut_ptr() as *const UniChar,
+        result.as_mut_ptr() as *const UniChar,
         glyphs.as_mut_ptr(),
-        len as CFIndex,
+        result.len() as CFIndex,
     ) {
         return glyphs[0] as libc::c_int;
     }
     return 0i32;
 }
 
-pub(crate) unsafe fn MapCharToGlyph_AAT(attributes: CFDictionaryRef, ch: u32) -> libc::c_int {
+pub(crate) unsafe fn MapCharToGlyph_AAT(attributes: CFDictionaryRef, ch: char) -> libc::c_int {
     let font = font_from_attributes(attributes);
     mapCharToGlyphFromCTFont(font, ch)
 }
@@ -454,17 +442,21 @@ pub(crate) unsafe fn GetFontCharRange_AAT(
     reqFirst: libc::c_int,
 ) -> libc::c_int {
     if reqFirst != 0 {
-        let mut ch: libc::c_int = 0i32;
-        while MapCharToGlyph_AAT(attributes, ch as u32) == 0i32 && ch < 0x10ffffi32 {
-            ch += 1
+        for ch in 0..=0x10ffff {
+            match std::char::from_u32(ch) {
+                Some(c) if MapCharToGlyph_AAT(attributes, c) != 0 => return ch as i32,
+                _ => {}
+            }
         }
-        return ch;
+        return 0x10ffff;
     } else {
-        let mut ch_0: libc::c_int = 0x10ffffi32;
-        while MapCharToGlyph_AAT(attributes, ch_0 as u32) == 0i32 && ch_0 > 0i32 {
-            ch_0 -= 1
+        for ch in (0..=0x10ffff).rev() {
+            match std::char::from_u32(ch) {
+                Some(c) if MapCharToGlyph_AAT(attributes, c) != 0 => return ch as i32,
+                _ => {}
+            }
         }
-        return ch_0;
+        return 0;
     };
 }
 

engine/src/xetex_aatfont.rs

@@ -915,10 +915,7 @@ pub(crate) unsafe fn find_native_font(uname: &str, mut scaled_size: Scaled) -> O
         let fontRef = findFontByName(&nameString, &mut varString, Fix2D(scaled_size));
         if !fontRef.is_null() {
             /* update name_of_font to the full name of the font, for error messages during font loading */
-            let fullName: *const i8 = getFullName(fontRef);
-            name_of_font = std::ffi::CStr::from_ptr(fullName)
-                .to_string_lossy()
-                .to_string();
+            name_of_font = getFullName(fontRef);
             if scaled_size < Scaled::ZERO {
                 if let Some(font) = createFont(fontRef, scaled_size) {
                     let dsize_0 = D2Fix(getDesignSize(&font));
@@ -985,7 +982,7 @@ pub(crate) unsafe fn ot_get_font_metrics(
     let mut xheight = D2Fix(d as f64);
     /* fallback in case the font does not have OS/2 table */
     if xheight == Scaled::ZERO {
-        let glyphID = engine.map_char_to_glyph('x' as i32 as u32) as i32;
+        let glyphID = engine.map_char_to_glyph('x') as i32;
         if glyphID != 0i32 {
             let (a, _) = engine.get_glyph_height_depth(glyphID as u32);
             xheight = D2Fix(a as f64)
@@ -995,7 +992,7 @@ pub(crate) unsafe fn ot_get_font_metrics(
         }
     }
     if capheight == Scaled::ZERO {
-        let glyphID_0 = engine.map_char_to_glyph('X' as i32 as u32) as i32;
+        let glyphID_0 = engine.map_char_to_glyph('X') as i32;
         if glyphID_0 != 0i32 {
             let (a, _) = engine.get_glyph_height_depth(glyphID_0 as u32);
             capheight = D2Fix(a as f64)
@@ -1292,20 +1289,20 @@ unsafe fn snap_zone(value: &mut Scaled, snap_value: Scaled, fuzz: Scaled) {
         *value = snap_value
     };
 }
-pub(crate) unsafe fn get_native_char_height_depth(font: usize, ch: i32) -> (Scaled, Scaled) {
+pub(crate) unsafe fn get_native_char_height_depth(font: usize, ch: char) -> (Scaled, Scaled) {
     use crate::xetex_consts::{QUAD_CODE, X_HEIGHT_CODE};
     const CAP_HEIGHT: i32 = 8;
     let (ht, dp) = match &FONT_LAYOUT_ENGINE[font] {
         #[cfg(target_os = "macos")]
         Font::Native(Aat(attributes)) => {
             let mut ht: f32 = 0.0f64 as f32;
             let mut dp: f32 = 0.0f64 as f32;
-            let gid: libc::c_int = aat::MapCharToGlyph_AAT(*attributes, ch as u32);
+            let gid: libc::c_int = aat::MapCharToGlyph_AAT(*attributes, ch);
             aat::GetGlyphHeightDepth_AAT(*attributes, gid as u16, &mut ht, &mut dp);
             (ht, dp)
         }
         Font::Native(Otgr(engine)) => {
-            let gid = engine.map_char_to_glyph(ch as u32) as i32;
+            let gid = engine.map_char_to_glyph(ch) as i32;
             engine.get_glyph_height_depth(gid as u32)
         }
         _ => panic!("bad native font flag in `get_native_char_height_depth`"),
@@ -1332,24 +1329,24 @@ pub(crate) unsafe fn get_native_char_height_depth(font: usize, ch: i32) -> (Scal
     );
     (height, depth)
 }
-pub(crate) unsafe fn getnativecharht(f: usize, c: i32) -> Scaled {
+pub(crate) unsafe fn getnativecharht(f: usize, c: char) -> Scaled {
     get_native_char_height_depth(f, c).0
 }
-pub(crate) unsafe fn getnativechardp(f: usize, c: i32) -> Scaled {
+pub(crate) unsafe fn getnativechardp(f: usize, c: char) -> Scaled {
     get_native_char_height_depth(f, c).1
 }
-pub(crate) unsafe fn get_native_char_sidebearings(font: &NativeFont, ch: i32) -> (Scaled, Scaled) {
+pub(crate) unsafe fn get_native_char_sidebearings(font: &NativeFont, ch: char) -> (Scaled, Scaled) {
     let (l, r) = match font {
         #[cfg(target_os = "macos")]
         Aat(attributes) => {
             let mut l: f32 = 0.;
             let mut r: f32 = 0.;
-            let gid = aat::MapCharToGlyph_AAT(*attributes, ch as u32);
+            let gid = aat::MapCharToGlyph_AAT(*attributes, ch);
             aat::GetGlyphSidebearings_AAT(*attributes, gid as u16, &mut l, &mut r);
             (l, r)
         }
         Otgr(engine) => {
-            let gid = engine.map_char_to_glyph(ch as u32) as i32;
+            let gid = engine.map_char_to_glyph(ch) as i32;
             engine.get_glyph_sidebearings(gid as u32)
         }
     };
@@ -1380,7 +1377,7 @@ pub(crate) unsafe fn get_glyph_bounds(font: usize, edge: i32, gid: i32) -> Scale
     };
     D2Fix((if edge <= 2i32 { a } else { b }) as f64)
 }
-pub(crate) unsafe fn getnativecharic(f: &NativeFont, letter_space: Scaled, c: i32) -> Scaled {
+pub(crate) unsafe fn getnativecharic(f: &NativeFont, letter_space: Scaled, c: char) -> Scaled {
     let (_, rsb) = get_native_char_sidebearings(f, c);
     if rsb < Scaled::ZERO {
         letter_space - rsb
@@ -1389,15 +1386,15 @@ pub(crate) unsafe fn getnativecharic(f: &NativeFont, letter_space: Scaled, c: i3
     }
 }
 /* single-purpose metrics accessors */
-pub(crate) unsafe fn getnativecharwd(f: usize, c: i32) -> Scaled {
+pub(crate) unsafe fn getnativecharwd(f: usize, c: char) -> Scaled {
     match &FONT_LAYOUT_ENGINE[f] {
         #[cfg(target_os = "macos")]
         Font::Native(Aat(attributes)) => {
-            let gid = aat::MapCharToGlyph_AAT(*attributes, c as u32);
+            let gid = aat::MapCharToGlyph_AAT(*attributes, c);
             D2Fix(aat::GetGlyphWidth_AAT(*attributes, gid as u16))
         }
         Font::Native(Otgr(engine)) => {
-            let gid = engine.map_char_to_glyph(c as u32) as i32;
+            let gid = engine.map_char_to_glyph(c) as i32;
             D2Fix(engine.get_glyph_width_from_engine(gid as u32) as f64)
         }
         _ => panic!("bad native font flag in `get_native_char_wd`"),
@@ -1431,7 +1428,7 @@ pub(crate) unsafe fn store_justified_native_glyphs(node: &mut NativeWord) {
                 /* apply justification to spaces (or if there are none, distribute it to all glyphs as a last resort) */
                 let glyph_count = node.glyph_count() as usize;
                 let mut spaceCount: i32 = 0i32;
-                let spaceGlyph: i32 = map_char_to_glyph(nf, ' ' as i32);
+                let spaceGlyph: i32 = map_char_to_glyph(nf, ' ');
                 for i in 0..glyph_count {
                     if node.glyph_ids()[i] as i32 == spaceGlyph {
                         spaceCount += 1
@@ -1701,14 +1698,11 @@ pub(crate) unsafe fn measure_native_glyph(node: &mut Glyph, use_glyph_metrics: b
         node.set_depth(Scaled(DEPTH_BASE[f]));
     };
 }
-pub(crate) unsafe fn map_char_to_glyph(font: &NativeFont, ch: i32) -> i32 {
-    if ch > 0x10ffff || ch >= 0xd800 && ch <= 0xdfff {
-        return 0i32;
-    }
+pub(crate) unsafe fn map_char_to_glyph(font: &NativeFont, ch: char) -> i32 {
     match font {
         #[cfg(target_os = "macos")]
-        Aat(engine) => aat::MapCharToGlyph_AAT(*engine, ch as u32),
-        Otgr(engine) => engine.map_char_to_glyph(ch as u32) as i32,
+        Aat(engine) => aat::MapCharToGlyph_AAT(*engine, ch),
+        Otgr(engine) => engine.map_char_to_glyph(ch) as i32,
     }
 }
 pub(crate) unsafe fn map_glyph_to_index(font: &NativeFont, name: &str) -> i32 {