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

//! Testing utilities.

#![allow(missing_docs)]
#![allow(dead_code)]

use std::vec::Vec;

#[allow(missing_debug_implementations)]
#[derive(Clone, Copy)]
pub enum TtfType {
    Raw(&'static [u8]),
    TrueTypeMagic,
    OpenTypeMagic,
    FontCollectionMagic,
    Int8(i8),
    UInt8(u8),
    Int16(i16),
    UInt16(u16),
    Int32(i32),
    UInt32(u32),
    CFFInt(i32),
}

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

    data
}

pub fn convert_type(value: TtfType, data: &mut Vec<u8>) {
    match value {
        TtfType::Raw(bytes) => {
            data.extend_from_slice(bytes);
        }
        TtfType::TrueTypeMagic => {
            data.extend_from_slice(&[0x00, 0x01, 0x00, 0x00]);
        }
        TtfType::OpenTypeMagic => {
            data.extend_from_slice(&[0x4F, 0x54, 0x54, 0x4F]);
        }
        TtfType::FontCollectionMagic => {
            data.extend_from_slice(&[0x74, 0x74, 0x63, 0x66]);
        }
        TtfType::Int8(n) => {
            data.extend_from_slice(&i8::to_be_bytes(n));
        }
        TtfType::UInt8(n) => {
            data.extend_from_slice(&u8::to_be_bytes(n));
        }
        TtfType::Int16(n) => {
            data.extend_from_slice(&i16::to_be_bytes(n));
        }
        TtfType::UInt16(n) => {
            data.extend_from_slice(&u16::to_be_bytes(n));
        }
        TtfType::Int32(n) => {
            data.extend_from_slice(&i32::to_be_bytes(n));
        }
        TtfType::UInt32(n) => {
            data.extend_from_slice(&u32::to_be_bytes(n));
        }
        TtfType::CFFInt(n) => {
            match n {
                -107..=107 => {
                    data.push((n as i16 + 139) as u8);
                }
                108..=1131 => {
                    let n = n - 108;
                    data.push(((n >> 8) + 247) as u8);
                    data.push((n & 0xFF) as u8);
                }
                -1131..=-108 => {
                    let n = -n - 108;
                    data.push(((n >> 8) + 251) as u8);
                    data.push((n & 0xFF) as u8);
                }
                -32768..=32767 => {
                    data.push(28);
                    data.extend_from_slice(&i16::to_be_bytes(n as i16));
                }
                _ => {
                    data.push(29);
                    data.extend_from_slice(&i32::to_be_bytes(n));
                }
            }
        }
    }
}

#[derive(Debug)]
pub struct Writer {
    pub data: Vec<u8>,
}

impl Writer {
    pub fn new() -> Self {
        Writer { data: Vec::with_capacity(256) }
    }

    pub fn offset(&self) -> usize {
        self.data.len()
    }

    pub fn write(&mut self, value: TtfType) {
        convert_type(value, &mut self.data);
    }
}