Fix missing post table field in opentype definition, PostMetrics and Os2Metrics types

Author: archaephyrryx

doodle-formats/src/format/opentype.rs

@@ -1186,6 +1186,7 @@ pub fn main(module: &mut FormatModule, base: &BaseModule) -> FormatRef {
                     ("version", version16_16(base)),
                     ("italic_angle", fixed32be(base)),
                     ("underline_position", s16be(base)),
+                    ("underline_thickness", s16be(base)),
                     ("is_fixed_pitch", base.u32be()), // nonzero <=> fixed pitch
                     ("min_mem_type42", base.u32be()),
                     ("max_mem_type42", base.u32be()),

generated/api_helper.rs

@@ -604,11 +604,18 @@ pub mod otf_metrics {
         lang_tag: Option<String>,
     }
 
-    // STUB - placeholder for selective field-summary
-    type Os2Metrics = OpentypeOs2;
+    #[derive(Clone, Debug)]
+    struct Os2Metrics {
+        version: u16,
+        // STUB - is anything else relevant?
+    }
 
-    // STUB - placeholder for selective field-summary
-    type PostMetrics = OpentypePost;
+    #[derive(Clone, Debug)]
+    struct PostMetrics {
+        version: u32,
+        is_fixed_pitch: bool,
+        // STUB - is anything else relevant?
+    }
 
     #[derive(Clone, Debug)]
     pub struct RequiredTableMetrics {
@@ -756,27 +763,10 @@ pub mod otf_metrics {
     }
 
     fn utf16be_convert(buf: &[u8]) -> String {
-        // NOTE - taken from the source of nightly-only String::from_utf16be_lossy
-        match (cfg!(target_endian = "big"), unsafe {
-            buf.align_to::<u16>()
-        }) {
-            (true, ([], v, [])) => String::from_utf16_lossy(v),
-            (true, ([], v, [_remainder])) => String::from_utf16_lossy(v) + "\u{FFFD}",
-            _ => {
-                let mut iter = buf.chunks_exact(2);
-                let string = char::decode_utf16(iter.by_ref().map(|hilo| match hilo {
-                    &[hi, lo] => u16::from_be_bytes([hi, lo]),
-                    _ => unreachable!("bad hilo"),
-                }))
-                .map(|r| r.unwrap_or(char::REPLACEMENT_CHARACTER))
-                .collect();
-                if iter.remainder().is_empty() {
-                    string
-                } else {
-                    string + "\u{FFFD}"
-                }
-            }
-        }
+        UTF_16BE
+            .decode(buf, DecoderTrap::Ignore)
+            .unwrap()
+            .to_owned()
     }
 
     pub fn analyze_table_directory(dir: &OpentypeFontDirectory) -> TestResult<SingleFontMetrics> {
@@ -886,13 +876,16 @@ pub mod otf_metrics {
             };
             let os2 = {
                 let os2 = &dir.table_links.os2;
-                // FIXME - implement type for Os2Metrics
-                os2.clone()
+                Os2Metrics {
+                    version: os2.version,
+                }
             };
             let post = {
                 let post = &dir.table_links.post;
-                // FIXME - implement type for PostMetrics
-                post.clone()
+                PostMetrics {
+                    version: post.version,
+                    is_fixed_pitch: post.is_fixed_pitch != 0,
+                }
             };
             RequiredTableMetrics {
                 cmap,
@@ -1233,7 +1226,15 @@ pub mod otf_metrics {
 
     fn show_post_metrics(post: &PostMetrics) {
         // STUB - Metrics is just an alias for the raw type, enrich and refactor if appropriate
-        println!("post: version {}", format_version16dot16(post.version));
+        println!(
+            "post: version {} ({})",
+            format_version16dot16(post.version),
+            if post.is_fixed_pitch {
+                "monospaced"
+            } else {
+                "proportionally spaced"
+            }
+        );
     }
 
     // NOTE - scaffolding to mark the values we currently parse into u16 but which are logically i16, to flag changes to the gencode API as they crop up

generated/sample_codegen.rs

@@ -347,7 +347,7 @@ pub struct deflate_main_codes_reference {
 }
 
 #[derive(Debug, Clone)]
-pub enum deflate_main_codes__dupX1 {
+pub enum deflate_main_codes {
     literal(u8),
     reference(deflate_main_codes_reference),
 }
@@ -364,7 +364,7 @@ pub struct deflate_dynamic_huffman {
     literal_length_alphabet_code_lengths_value: Vec<u8>,
     distance_alphabet_code_lengths_value: Vec<u8>,
     codes: Vec<deflate_dynamic_huffman_codes>,
-    codes_values: Vec<deflate_main_codes__dupX1>,
+    codes_values: Vec<deflate_main_codes>,
 }
 
 #[derive(Debug, Clone)]
@@ -384,7 +384,7 @@ pub struct deflate_fixed_huffman_codes {
 #[derive(Debug, Clone)]
 pub struct deflate_fixed_huffman {
     codes: Vec<deflate_fixed_huffman_codes>,
-    codes_values: Vec<deflate_main_codes__dupX1>,
+    codes_values: Vec<deflate_main_codes>,
 }
 
 #[derive(Debug, Clone)]
@@ -393,11 +393,11 @@ pub struct deflate_uncompressed {
     len: u16,
     nlen: u16,
     bytes: Vec<u8>,
-    codes_values: Vec<deflate_main_codes__dupX1>,
+    codes_values: Vec<deflate_main_codes>,
 }
 
 #[derive(Debug, Clone)]
-pub enum deflate_main_codes {
+pub enum deflate_main_codes__dupX1 {
     dynamic_huffman(deflate_dynamic_huffman),
     fixed_huffman(deflate_fixed_huffman),
     uncompressed(deflate_uncompressed),
@@ -407,13 +407,13 @@ pub enum deflate_main_codes {
 pub struct deflate_block {
     r#final: u8,
     r#type: u8,
-    data: deflate_main_codes,
+    data: deflate_main_codes__dupX1,
 }
 
 #[derive(Debug, Clone)]
 pub struct deflate_main {
     blocks: Vec<deflate_block>,
-    codes: Vec<deflate_main_codes__dupX1>,
+    codes: Vec<deflate_main_codes>,
     inflate: Vec<u8>,
 }
 
@@ -1861,6 +1861,7 @@ pub struct opentype_post_table {
     version: u32,
     italic_angle: opentype_post_table_italic_angle,
     underline_position: u16,
+    underline_thickness: u16,
     is_fixed_pitch: u32,
     min_mem_type42: u32,
     max_mem_type42: u32,
@@ -5947,6 +5948,7 @@ fn Decoder_opentype_post_table<'input>(
         })
     })())?;
     let underline_position = ((|| PResult::Ok((Decoder24(_input))?))())?;
+    let underline_thickness = ((|| PResult::Ok((Decoder24(_input))?))())?;
     let is_fixed_pitch = ((|| PResult::Ok((Decoder21(_input))?))())?;
     let min_mem_type42 = ((|| PResult::Ok((Decoder21(_input))?))())?;
     let max_mem_type42 = ((|| PResult::Ok((Decoder21(_input))?))())?;
@@ -6012,6 +6014,7 @@ fn Decoder_opentype_post_table<'input>(
         version,
         italic_angle,
         underline_position,
+        underline_thickness,
         is_fixed_pitch,
         min_mem_type42,
         max_mem_type42,
@@ -10151,11 +10154,11 @@ fn Decoder_deflate_main<'input>(_input: &mut Parser<'input>) -> Result<deflate_m
         PResult::Ok(
             (try_flat_map_vec(blocks.iter().cloned(), |x: deflate_block| {
                 PResult::Ok(match x.data.clone() {
-                    deflate_main_codes::uncompressed(y) => y.codes_values.clone(),
+                    deflate_main_codes__dupX1::uncompressed(y) => y.codes_values.clone(),
 
-                    deflate_main_codes::fixed_huffman(y) => y.codes_values.clone(),
+                    deflate_main_codes__dupX1::fixed_huffman(y) => y.codes_values.clone(),
 
-                    deflate_main_codes::dynamic_huffman(y) => y.codes_values.clone(),
+                    deflate_main_codes__dupX1::dynamic_huffman(y) => y.codes_values.clone(),
                 })
             }))?,
         )
@@ -10164,12 +10167,12 @@ fn Decoder_deflate_main<'input>(_input: &mut Parser<'input>) -> Result<deflate_m
         PResult::Ok(
             (try_flat_map_append_vec(
                 codes.iter().cloned(),
-                |tuple_var: (&Vec<u8>, deflate_main_codes__dupX1)| {
+                |tuple_var: (&Vec<u8>, deflate_main_codes)| {
                     PResult::Ok(match tuple_var {
                         (buffer, symbol) => match symbol {
-                            deflate_main_codes__dupX1::literal(b) => [b].to_vec(),
+                            deflate_main_codes::literal(b) => [b].to_vec(),
 
-                            deflate_main_codes__dupX1::reference(r) => {
+                            deflate_main_codes::reference(r) => {
                                 let ix =
                                     (try_sub!((buffer.len()) as u32, (r.distance.clone()) as u32))
                                         as usize;
@@ -10208,17 +10211,17 @@ fn Decoder_deflate_block<'input>(_input: &mut Parser<'input>) -> Result<deflate_
         PResult::Ok(match r#type {
             0u8 => {
                 let inner = (Decoder_deflate_uncompressed(_input))?;
-                deflate_main_codes::uncompressed(inner)
+                deflate_main_codes__dupX1::uncompressed(inner)
             }
 
             1u8 => {
                 let inner = (Decoder_deflate_fixed_huffman(_input))?;
-                deflate_main_codes::fixed_huffman(inner)
+                deflate_main_codes__dupX1::fixed_huffman(inner)
             }
 
             2u8 => {
                 let inner = (Decoder_deflate_dynamic_huffman(_input))?;
-                deflate_main_codes::dynamic_huffman(inner)
+                deflate_main_codes__dupX1::dynamic_huffman(inner)
             }
 
             _other => {
@@ -10408,7 +10411,7 @@ fn Decoder_deflate_uncompressed<'input>(
     let codes_values = ((|| {
         PResult::Ok(
             (try_flat_map_vec(bytes.iter().cloned(), |x: u8| {
-                PResult::Ok([deflate_main_codes__dupX1::literal(x)].to_vec())
+                PResult::Ok([deflate_main_codes::literal(x)].to_vec())
             }))?,
         )
     })())?;
@@ -12197,7 +12200,7 @@ fn Decoder_deflate_fixed_huffman<'input>(
                     256u16 => [].to_vec(),
 
                     257u16..=285u16 => match x.extra.clone() {
-                        Some(ref rec) => [deflate_main_codes__dupX1::reference(
+                        Some(ref rec) => [deflate_main_codes::reference(
                             deflate_main_codes_reference {
                                 length: rec.length.clone(),
                                 distance: rec.distance_record.distance.clone(),
@@ -12212,7 +12215,7 @@ fn Decoder_deflate_fixed_huffman<'input>(
 
                     286u16..=287u16 => [].to_vec(),
 
-                    _ => [deflate_main_codes__dupX1::literal((x.code.clone()) as u8)].to_vec(),
+                    _ => [deflate_main_codes::literal((x.code.clone()) as u8)].to_vec(),
                 })
             }))?,
         )
@@ -13721,7 +13724,7 @@ v => {
                     256u16 => [].to_vec(),
 
                     257u16..=285u16 => match x.extra.clone() {
-                        Some(ref rec) => [deflate_main_codes__dupX1::reference(
+                        Some(ref rec) => [deflate_main_codes::reference(
                             deflate_main_codes_reference {
                                 length: rec.length.clone(),
                                 distance: rec.distance_record.distance.clone(),
@@ -13736,7 +13739,7 @@ v => {
 
                     286u16..=287u16 => [].to_vec(),
 
-                    _ => [deflate_main_codes__dupX1::literal((x.code.clone()) as u8)].to_vec(),
+                    _ => [deflate_main_codes::literal((x.code.clone()) as u8)].to_vec(),
                 })
             }))?,
         )