ttf-parser 0.15.2

A high-level, safe, zero-allocation TrueType font parser.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

mod aat;
mod ankr;
mod cff1;
mod cmap;
mod feat;
mod glyf;
mod hmtx;
mod maxp;
mod sbix;
mod trak;

use ttf_parser::{Face, FaceParsingError, fonts_in_collection};

#[allow(dead_code)]
#[derive(Clone, Copy)]
pub enum Unit {
    Raw(&'static [u8]),
    Int8(i8),
    UInt8(u8),
    Int16(i16),
    UInt16(u16),
    Int32(i32),
    UInt32(u32),
    Fixed(f32),
}

pub fn convert(units: &[Unit]) -> Vec<u8> {
    let mut data = Vec::with_capacity(256);
    for v in units {
        convert_unit(*v, &mut data);
    }

    data
}

fn convert_unit(unit: Unit, data: &mut Vec<u8>) {
    match unit {
        Unit::Raw(bytes) => {
            data.extend_from_slice(bytes);
        }
        Unit::Int8(n) => {
            data.extend_from_slice(&i8::to_be_bytes(n));
        }
        Unit::UInt8(n) => {
            data.extend_from_slice(&u8::to_be_bytes(n));
        }
        Unit::Int16(n) => {
            data.extend_from_slice(&i16::to_be_bytes(n));
        }
        Unit::UInt16(n) => {
            data.extend_from_slice(&u16::to_be_bytes(n));
        }
        Unit::Int32(n) => {
            data.extend_from_slice(&i32::to_be_bytes(n));
        }
        Unit::UInt32(n) => {
            data.extend_from_slice(&u32::to_be_bytes(n));
        }
        Unit::Fixed(n) => {
            data.extend_from_slice(&i32::to_be_bytes((n * 65536.0) as i32));
        }
    }
}


#[test]
fn empty_font() {
    assert_eq!(Face::from_slice(&[], 0).unwrap_err(),
               FaceParsingError::UnknownMagic);
}

#[test]
fn zero_tables() {
    use Unit::*;
    let data = convert(&[
        Raw(&[0x00, 0x01, 0x00, 0x00]), // magic
        UInt16(0), // numTables
        UInt16(0), // searchRange
        UInt16(0), // entrySelector
        UInt16(0), // rangeShift
    ]);

    assert_eq!(Face::from_slice(&data, 0).unwrap_err(),
               FaceParsingError::NoHeadTable);
}

#[test]
fn tables_count_overflow() {
    use Unit::*;
    let data = convert(&[
        Raw(&[0x00, 0x01, 0x00, 0x00]), // magic
        UInt16(std::u16::MAX), // numTables
        UInt16(0), // searchRange
        UInt16(0), // entrySelector
        UInt16(0), // rangeShift
    ]);

    assert_eq!(Face::from_slice(&data, 0).unwrap_err(),
               FaceParsingError::MalformedFont);
}

#[test]
fn empty_font_collection() {
    use Unit::*;
    let data = convert(&[
        Raw(&[0x74, 0x74, 0x63, 0x66]), // magic
        UInt16(0), // majorVersion
        UInt16(0), // minorVersion
        UInt32(0), // numFonts
    ]);

    assert_eq!(fonts_in_collection(&data), Some(0));
    assert_eq!(Face::from_slice(&data, 0).unwrap_err(),
               FaceParsingError::FaceIndexOutOfBounds);
}

#[test]
fn font_collection_num_fonts_overflow() {
    use Unit::*;
    let data = convert(&[
        Raw(&[0x74, 0x74, 0x63, 0x66]), // magic
        UInt16(0), // majorVersion
        UInt16(0), // minorVersion
        UInt32(std::u32::MAX), // numFonts
    ]);

    assert_eq!(fonts_in_collection(&data), Some(std::u32::MAX));
    assert_eq!(Face::from_slice(&data, 0).unwrap_err(),
               FaceParsingError::MalformedFont);
}

#[test]
fn font_index_overflow() {
    use Unit::*;
    let data = convert(&[
        Raw(&[0x74, 0x74, 0x63, 0x66]), // magic
        UInt16(0), // majorVersion
        UInt16(0), // minorVersion
        UInt32(1), // numFonts
        UInt32(12), // offset [0]
    ]);

    assert_eq!(fonts_in_collection(&data), Some(1));
    assert_eq!(Face::from_slice(&data, std::u32::MAX).unwrap_err(),
               FaceParsingError::FaceIndexOutOfBounds);
}