Grcov report - cff.rs

1

//! CFF font handling.

2

//!

3

//! Refer to [Technical Note #5176](http://wwwimages.adobe.com/content/dam/Adobe/en/devnet/font/pdfs/5176.CFF.pdf)

4

//! for more information.

5

6

pub mod cff2;

7

pub mod charstring;

8

pub mod outline;

9

mod subset;

10

11

use std::io::Write;

12

use std::iter;

13

use std::marker::PhantomData;

14

use std::sync::OnceLock;

15

16

use tinyvec::{array_vec, tiny_vec, TinyVec};

17

18

use crate::binary::read::{

19

    ReadArray, ReadArrayCow, ReadBinary, ReadBinaryDep, ReadCtxt, ReadFrom, ReadScope,

20

    ReadUnchecked,

21

};

22

use crate::binary::write::{WriteBinary, WriteBinaryDep, WriteBuffer, WriteContext, WriteCounter};

23

use crate::binary::{I16Be, I32Be, U16Be, U24Be, U32Be, U8};

24

use crate::error::{ParseError, WriteError};

25

use crate::tables::variable_fonts::{ItemVariationStore, OwnedTuple};

26

use crate::variations::VariationError;

27

use crate::GlyphId;

28

use crate::TryNumFrom;

29

use cff2::BlendOperand;

30

use charstring::ArgumentsStack;

31

pub use subset::SubsetCFF;

32

33

/// Maximum number of operands in Top DICT, Font DICTs, Private DICTs and CharStrings.

34

///

35

/// > An operator may be preceded by up to a maximum of 48 operands.

36

pub const MAX_OPERANDS: usize = 48;

37

const END_OF_FLOAT_FLAG: u8 = 0xf;

38

39

const OPERAND_ZERO: [Operand; 1] = [Operand::Integer(0)];

40

const OFFSET_ZERO: [Operand; 1] = [Operand::Offset(0)];

41

const DEFAULT_UNDERLINE_POSITION: [Operand; 1] = [Operand::Integer(-100)];

42

const DEFAULT_UNDERLINE_THICKNESS: [Operand; 1] = [Operand::Integer(50)];

43

const DEFAULT_CHARSTRING_TYPE: [Operand; 1] = [Operand::Integer(2)];

44

const DEFAULT_BBOX: [Operand; 4] = [

45

    Operand::Integer(0),

46

    Operand::Integer(0),

47

    Operand::Integer(0),

48

    Operand::Integer(0),

49

];

50

const DEFAULT_CID_COUNT: [Operand; 1] = [Operand::Integer(8720)];

51

const DEFAULT_BLUE_SHIFT: [Operand; 1] = [Operand::Integer(7)];

52

const DEFAULT_BLUE_FUZZ: [Operand; 1] = [Operand::Integer(1)];

53

54

// Operands containing `Real` values can't be const because `Real` wraps a

55

// `TinyVec`, whose construction isn't const. They are computed once on first

56

// access via `OnceLock` and reused thereafter.

57

58

pub(crate) fn default_font_matrix() -> &'static [Operand; 6] {

59

    static V: OnceLock<[Operand; 6]> = OnceLock::new();

60

    V.get_or_init(|| {

61

        let real_0_001 = Operand::Real(Real(tiny_vec![0x0a, 0x00, 0x1f])); // 0.001

62

63

            real_0_001.clone(),

64

            Operand::Integer(0),

65

            Operand::Integer(0),

66

            real_0_001,

67

            Operand::Integer(0),

68

            Operand::Integer(0),

69

70

})

71

72

73

pub(crate) fn default_blue_scale() -> &'static [Operand; 1] {

74

    static V: OnceLock<[Operand; 1]> = OnceLock::new();

75

    V.get_or_init(|| [Operand::Real(Real(tiny_vec![0x0a, 0x03, 0x96, 0x25, 0xff]))]) // 0.039625

76

77

78

pub(crate) fn default_expansion_factor() -> &'static [Operand; 1] {

79

    static V: OnceLock<[Operand; 1]> = OnceLock::new();

80

    V.get_or_init(|| [Operand::Real(Real(tiny_vec![0x0a, 0x06, 0xff]))]) // 0.06

81

82

83

const ISO_ADOBE_LAST_SID: u16 = 228;

84

const ADOBE: &[u8] = b"Adobe";

85

const IDENTITY: &[u8] = b"Identity";

86

87

/// Top level representation of a CFF font file, typically read from a CFF OpenType table.

88

///

89

/// Refer to Technical Note #5176

90

#[derive(Clone)]

91

pub struct CFF<'a> {

92

    pub header: Header,

93

    pub name_index: MaybeOwnedIndex<'a>,

94

    pub string_index: MaybeOwnedIndex<'a>,

95

    pub global_subr_index: MaybeOwnedIndex<'a>,

96

    pub fonts: Vec<Font<'a>>,

97

98

99

/// CFF Font Header described in Section 6 of Technical Note #5176

100

#[derive(Clone, Debug, PartialEq)]

101

pub struct Header {

102

    pub major: u8,

103

    pub minor: u8,

104

    pub hdr_size: u8,

105

    pub off_size: u8,

106

107

108

/// Utility type for reading an INDEX with 16-bit offsets

109

pub struct IndexU16;

110

111

/// Utility type for reading an INDEX with 32-bit offsets

112

pub struct IndexU32;

113

114

/// A CFF INDEX described in Section 5 of Technical Note #5176

115

#[derive(Clone)]

116

pub struct Index<'a> {

117

    pub count: usize,

118

    off_size: u8,

119

    offset_array: &'a [u8],

120

    data_array: &'a [u8],

121

122

123

/// A single font within a CFF file

124

#[derive(Clone)]

125

pub struct Font<'a> {

126

    pub top_dict: TopDict,

127

    pub char_strings_index: MaybeOwnedIndex<'a>,

128

    pub charset: Charset<'a>,

129

    pub data: CFFVariant<'a>,

130

131

132

/// A borrowed reference to a [cff::Font](Font) or [cff2::Font].

133

#[derive(Copy, Clone)]

134

pub enum CFFFont<'a, 'data> {

135

    CFF(&'a Font<'data>),

136

    CFF2(&'a cff2::Font<'data>),

137

138

139

/// A CFF INDEX that can hold borrowed or owned data.

140

#[derive(Clone)]

141

pub enum MaybeOwnedIndex<'a> {

142

    Borrowed(Index<'a>),

143

    Owned(owned::Index),

144

145

146

/// Iterator for the entries in a `MaybeOwnedIndex`.

147

pub struct MaybeOwnedIndexIterator<'a> {

148

    data: &'a MaybeOwnedIndex<'a>,

149

    index: usize,

150

151

152

/// A list of errors that can occur when interpreting CFF CharStrings.

153

#[derive(Clone, Eq, PartialEq, Debug)]

154

pub enum CFFError {

155

    ParseError(ParseError),

156

    InvalidOperator,

157

    // Operand was out of range or otherwise unsuitable for the intended use

158

    InvalidOperand,

159

    UnsupportedOperator,

160

    MissingEndChar,

161

    DataAfterEndChar,

162

    NestingLimitReached,

163

    ArgumentsStackLimitReached,

164

    InvalidArgumentsStackLength,

165

    BboxOverflow,

166

    MissingMoveTo,

167

    DuplicateVsIndex,

168

    InvalidSubroutineIndex,

169

    InvalidFontIndex,

170

    NoLocalSubroutines,

171

    InvalidSeacCode,

172

    VsIndexAfterBlend,

173

    MissingVariationStore,

174

175

176

mod owned {

177

    use super::{U16Be, U32Be, WriteBinary, WriteContext, WriteError, U8};

178

179

    pub(super) struct IndexU16;

180

    pub(super) struct IndexU32;

181

182

    #[derive(Clone)]

183

    pub struct Index {

184

        pub(super) data: Vec<Vec<u8>>,

185

186

187

    impl WriteBinary<&Index> for IndexU16 {

188

        type Output = ();

189

190

        fn write<C: WriteContext>(ctxt: &mut C, index: &Index) -> Result<(), WriteError> {

191

            let count = u16::try_from(index.data.len())?;

192

            U16Be::write(ctxt, count)?;

193

            write_index_body(ctxt, index)

194

195

196

197

    impl WriteBinary<&Index> for IndexU32 {

198

        type Output = ();

199

200

        fn write<C: WriteContext>(ctxt: &mut C, index: &Index) -> Result<(), WriteError> {

201

            let count = u32::try_from(index.data.len())?;

202

            U32Be::write(ctxt, count)?;

203

            write_index_body(ctxt, index)

204

205

206

207

    fn write_index_body<C: WriteContext>(ctxt: &mut C, index: &Index) -> Result<(), WriteError> {

208

        if index.data.is_empty() {

209

            return Ok(());

210

211

212

        let mut offset = 1; // INDEX offsets start at 1

213

        let mut offsets = Vec::with_capacity(index.data.len() + 1);

214

        for data in &index.data {

215

            offsets.push(offset);

216

            offset += data.len();

217

218

        offsets.push(offset);

219

        let (off_size, offset_array) = super::serialise_offset_array(offsets)?;

220

        U8::write(ctxt, off_size)?;

221

        ctxt.write_bytes(&offset_array)?;

222

        for data in &index.data {

223

            ctxt.write_bytes(data)?;

224

225

226

        Ok(())

227

228

229

    impl Index {

230

        pub(super) fn read_object(&self, index: usize) -> Option<&[u8]> {

231

            self.data.get(index).map(|data| data.as_slice())

232

233

234

235

236

#[derive(Clone)]

237

pub enum CFFVariant<'a> {

238

    CID(CIDData<'a>),

239

    Type1(Type1Data<'a>),

240

241

242

#[derive(Clone)]

243

pub struct CIDData<'a> {

244

    pub font_dict_index: MaybeOwnedIndex<'a>,

245

    pub private_dicts: Vec<PrivateDict>,

246

    /// An optional local subroutine index per Private DICT.

247

    pub local_subr_indices: Vec<Option<MaybeOwnedIndex<'a>>>,

248

    pub fd_select: FDSelect<'a>,

249

250

251

pub struct CIDDataOffsets {

252

    pub font_dict_index: usize,

253

    pub fd_select: usize,

254

255

256

#[derive(Clone)]

257

pub struct Type1Data<'a> {

258

    pub encoding: Encoding<'a>,

259

    pub private_dict: PrivateDict,

260

    pub local_subr_index: Option<MaybeOwnedIndex<'a>>,

261

262

263

pub struct Type1DataOffsets {

264

    pub custom_encoding: Option<usize>,

265

    pub private_dict: usize,

266

    pub private_dict_len: usize,

267

268

269

// Encoding data is located via the offset operand to the Encoding operator in the Top DICT. Only

270

// one Encoding operator can be specified per font except for CIDFonts which specify no encoding.

271

#[derive(Clone)]

272

pub enum Encoding<'a> {

273

    Standard,

274

    Expert,

275

    Custom(CustomEncoding<'a>),

276

277

278

#[derive(Clone)]

279

pub enum Charset<'a> {

280

    ISOAdobe,

281

    Expert,

282

    ExpertSubset,

283

    Custom(CustomCharset<'a>),

284

285

286

#[derive(Clone)]

287

pub enum CustomEncoding<'a> {

288

    Format0 {

289

        codes: ReadArray<'a, U8>,

290

},

291

    Format1 {

292

        ranges: ReadArray<'a, Range<u8, u8>>,

293

},

294

295

296

// A string id in the font

297

type SID = u16;

298

299

#[derive(Clone)]

300

pub enum CustomCharset<'a> {

301

    Format0 {

302

        glyphs: ReadArrayCow<'a, U16Be>,

303

},

304

    Format1 {

305

        ranges: ReadArrayCow<'a, Range<SID, u8>>,

306

},

307

    Format2 {

308

        ranges: ReadArrayCow<'a, Range<SID, u16>>,

309

},

310

311

312

/// A Range from `first` to `first + n_left`

313

#[derive(Copy, Clone, Debug, PartialEq)]

314

pub struct Range<F, N> {

315

    pub first: F,

316

    pub n_left: N,

317

318

319

/// A CFF DICT described in Section 4 of Technical Note #5176

320

#[derive(Debug, PartialEq, Clone)]

321

pub struct Dict<T>

322

where

323

    T: DictDefault,

324

325

    dict: Vec<(Operator, Vec<Operand>)>,

326

    default: PhantomData<T>,

327

328

329

/// The default values of a DICT

330

pub trait DictDefault {

331

    /// Returns the default operand(s) if any for the supplied `op`.

332

    fn default(op: Operator) -> Option<&'static [Operand]>;

333

334

335

#[derive(Debug, PartialEq, Clone)]

336

pub struct TopDictDefault;

337

338

#[derive(Debug, PartialEq, Clone)]

339

pub struct FontDictDefault;

340

341

#[derive(Debug, PartialEq, Clone)]

342

pub struct PrivateDictDefault;

343

344

pub type TopDict = Dict<TopDictDefault>;

345

346

pub type FontDict = Dict<FontDictDefault>;

347

348

pub type PrivateDict = Dict<PrivateDictDefault>;

349

350

/// A collection of offset changes to a `Dict`

351

///

352

/// `DictDelta` only accepts Operators with offsets as operands.

353

#[derive(Debug, PartialEq, Clone)]

354

pub struct DictDelta {

355

    // Most entries will have operands of a single offset, so the tiny vec is set to that

356

    dict: Vec<(Operator, TinyVec<[Operand; 1]>)>,

357

358

359

/// Font DICT select as described in Section 19 of Technical Note #5176

360

#[derive(Clone, Debug)]

361

pub enum FDSelect<'a> {

362

    Format0 {

363

        glyph_font_dict_indices: ReadArrayCow<'a, U8>,

364

},

365

    // Formats 1 and 2 are not defined

366

    Format3 {

367

        ranges: ReadArrayCow<'a, Range<u16, u8>>,

368

        sentinel: u16,

369

},

370

    // Format 4 is not yet implemented

371

372

373

/// CFF DICT operator

374

#[derive(Debug, PartialEq)]

375

enum Op {

376

    Operator(Operator),

377

    Operand(Operand),

378

379

380

/// CFF operand to an operator

381

#[derive(Debug, PartialEq, Clone)]

382

pub enum Operand {

383

    Integer(i32),

384

    Offset(i32),

385

    Real(Real),

386

387

388

// On a corpus of 23945 CFF fonts real values were encountered as follows:

389

//     572 2 bytes

390

//     776 3 bytes

391

//    1602 4 bytes

392

//   14037 5 bytes

393

//    3491 6 bytes

394

//      36 7 bytes

395

// Using 7 bytes for the tiny vec covers all these, fits in a register on 64-bit systems,

396

// allows Operand to be 8 bytes on 64-bit systems, and is considerably smaller than the 24 bytes

397

// used by Vec (which Real contained in the past).

398

399

/// A real number

400

///

401

/// To parse the value into `f64` use the `TryFrom`/`TryInto` impl.

402

#[derive(Debug, PartialEq, Clone)]

403

pub struct Real(TinyVec<[u8; 7]>);

404

405

#[repr(u16)]

406

#[derive(Debug, PartialEq, Copy, Clone)]

407

pub enum Operator {

408

    Version = 0,

409

    Notice = 1,

410

    FullName = 2,

411

    FamilyName = 3,

412

    Weight = 4,

413

    FontBBox = 5,

414

    BlueValues = 6,

415

    OtherBlues = 7,

416

    FamilyBlues = 8,

417

    FamilyOtherBlues = 9,

418

    StdHW = 10,

419

    StdVW = 11,

420

    UniqueID = 13,

421

    XUID = 14,

422

    Charset = 15,

423

    Encoding = 16,

424

    CharStrings = 17,

425

    Private = 18,

426

    Subrs = 19,

427

    DefaultWidthX = 20,

428

    NominalWidthX = 21,

429

    // CFF2

430

    VSIndex = 22,

431

    Blend = 23,

432

    VStore = 24,

433

434

    Copyright = op2(0),

435

    IsFixedPitch = op2(1),

436

    ItalicAngle = op2(2),

437

    UnderlinePosition = op2(3),

438

    UnderlineThickness = op2(4),

439

    PaintType = op2(5),

440

    CharstringType = op2(6),

441

    FontMatrix = op2(7),

442

    StrokeWidth = op2(8),

443

    BlueScale = op2(9),

444

    BlueShift = op2(10),

445

    BlueFuzz = op2(11),

446

    StemSnapH = op2(12),

447

    StemSnapV = op2(13),

448

    ForceBold = op2(14),

449

    LanguageGroup = op2(17),

450

    ExpansionFactor = op2(18),

451

    InitialRandomSeed = op2(19),

452

    SyntheticBase = op2(20),

453

    PostScript = op2(21),

454

    BaseFontName = op2(22),

455

    BaseFontBlend = op2(23),

456

    ROS = op2(30),

457

    CIDFontVersion = op2(31),

458

    CIDFontRevision = op2(32),

459

    CIDFontType = op2(33),

460

    CIDCount = op2(34),

461

    UIDBase = op2(35),

462

    FDArray = op2(36),

463

    FDSelect = op2(37),

464

    FontName = op2(38),

465

466

467

const fn op2(value: u8) -> u16 {

468

    (12 << 8) | (value as u16)

469

470

471

impl ReadBinary for CFF<'_> {

472

    type HostType<'a> = CFF<'a>;

473

474

    fn read<'a>(ctxt: &mut ReadCtxt<'a>) -> Result<Self::HostType<'a>, ParseError> {

475

        // Get a scope that starts at the beginning of the CFF data. This is needed for reading

476

        // data that is specified as an offset from the start of the data later.

477

        let scope = ctxt.scope();

478

479

        let header = ctxt.read::<Header>()?;

480

        let name_index = ctxt.read::<IndexU16>()?;

481

        let top_dict_index = ctxt.read::<IndexU16>()?;

482

        let string_index = ctxt.read::<IndexU16>()?;

483

        let global_subr_index = ctxt.read::<IndexU16>().map(MaybeOwnedIndex::Borrowed)?;

484

485

        let mut fonts = Vec::with_capacity(name_index.count);

486

        for font_index in 0..name_index.count {

487

            let top_dict = top_dict_index.read::<TopDict>(font_index, MAX_OPERANDS)?;

488

489

            // CharStrings index

490

            let offset = top_dict

491

                .get_i32(Operator::CharStrings)

492

                .unwrap_or(Err(ParseError::MissingValue))?;

493

            let char_strings_index = scope.offset(usize::try_from(offset)?).read::<IndexU16>()?;

494

495

            // The Top DICT begins with the SyntheticBase and ROS operators

496

            // for synthetic and CIDFonts, respectively. Regular Type 1 fonts

497

            // begin with some other operator.

498

            let data = match top_dict.first_operator() {

499

                Some(Operator::ROS) => {

500

                    let cid_data = read_cid_data(&scope, &top_dict, char_strings_index.count)?;

501

                    CFFVariant::CID(cid_data)

502

503

                Some(Operator::SyntheticBase) => {

504

                    return Err(ParseError::NotImplemented);

505

506

                Some(_) => {

507

                    let (private_dict, private_dict_offset) =

508

                        top_dict.read_private_dict::<PrivateDict>(&scope, MAX_OPERANDS)?;

509

                    let local_subr_index = read_local_subr_index::<_, IndexU16>(

510

                        &scope,

511

                        &private_dict,

512

                        private_dict_offset,

513

)?

514

                    .map(MaybeOwnedIndex::Borrowed);

515

                    let encoding = read_encoding(&scope, &top_dict)?;

516

517

                    CFFVariant::Type1(Type1Data {

518

                        encoding,

519

                        private_dict,

520

                        local_subr_index,

521

})

522

523

                None => return Err(ParseError::MissingValue),

524

};

525

526

            let charset = read_charset(&scope, &top_dict, char_strings_index.count)?;

527

528

            fonts.push(Font {

529

                top_dict,

530

                char_strings_index: MaybeOwnedIndex::Borrowed(char_strings_index),

531

                charset,

532

                data,

533

});

534

535

536

        Ok(CFF {

537

            header,

538

            name_index: MaybeOwnedIndex::Borrowed(name_index),

539

            string_index: MaybeOwnedIndex::Borrowed(string_index),

540

            global_subr_index,

541

            fonts,

542

})

543

544

545

546

impl<'a> WriteBinary<&Self> for CFF<'a> {

547

    type Output = ();

548

549

    fn write<C: WriteContext>(ctxt: &mut C, cff: &CFF<'a>) -> Result<(), WriteError> {

550

        Header::write(ctxt, &cff.header)?;

551

        MaybeOwnedIndex::write16(ctxt, &cff.name_index)?;

552

        let top_dicts = cff.fonts.iter().map(|font| &font.top_dict).collect::<Vec<_>>();

553

        let top_dict_index_length =

554

            Index::calculate_size::<TopDict, _>(top_dicts.as_slice(), DictDelta::new())?;

555

        let top_dict_index_placeholder = ctxt.reserve::<IndexU16, _>(top_dict_index_length)?;

556

        MaybeOwnedIndex::write16(ctxt, &cff.string_index)?;

557

        MaybeOwnedIndex::write16(ctxt, &cff.global_subr_index)?;

558

559

        // Collect Top DICT deltas now that we know the offsets to other items in the DICT

560

        let mut top_dict_deltas = vec![DictDelta::new(); cff.fonts.len()];

561

        for (font, top_dict_delta) in cff.fonts.iter().zip(top_dict_deltas.iter_mut()) {

562

            top_dict_delta.push_offset(Operator::CharStrings, i32::try_from(ctxt.bytes_written())?);

563

            MaybeOwnedIndex::write16(ctxt, &font.char_strings_index)?;

564

565

            match &font.charset {

566

                Charset::ISOAdobe => top_dict_delta.push_offset(Operator::Charset, 0),

567

                Charset::Expert => top_dict_delta.push_offset(Operator::Charset, 1),

568

                Charset::ExpertSubset => top_dict_delta.push_offset(Operator::Charset, 2),

569

                Charset::Custom(custom) => {

570

                    top_dict_delta

571

                        .push_offset(Operator::Charset, i32::try_from(ctxt.bytes_written())?);

572

                    CustomCharset::write(ctxt, custom)?;

573

574

575

            write_cff_variant(ctxt, &font.data, top_dict_delta)?;

576

577

578

        // Write out the Top DICTs with the updated offsets

579

        let mut top_dict_data = WriteBuffer::new();

580

        let mut offsets = Vec::with_capacity(cff.fonts.len());

581

        for (font, top_dict_delta) in cff.fonts.iter().zip(top_dict_deltas.into_iter()) {

582

            offsets.push(top_dict_data.bytes_written() + 1); // +1 because INDEX offsets start at 1

583

            TopDict::write_dep(&mut top_dict_data, &font.top_dict, top_dict_delta)?;

584

585

        offsets.push(top_dict_data.bytes_written() + 1); // Add the extra offset at the end

586

        let (off_size, offset_array) = serialise_offset_array(offsets)?;

587

588

        // Fill in the Top DICT INDEX placeholder

589

        let top_dict_index = Index {

590

            count: cff.fonts.len(),

591

            off_size,

592

            offset_array: &offset_array,

593

            data_array: top_dict_data.bytes(),

594

};

595

        ctxt.write_placeholder(top_dict_index_placeholder, &top_dict_index)?;

596

597

        Ok(())

598

599

600

601

impl CFF<'_> {

602

    /// Read a string with the given SID from the String INDEX

603

    pub fn read_string(&self, sid: SID) -> Result<&str, ParseError> {

604

        read_string_index_string(&self.string_index, sid)

605

606

607

608

/// Read a string with the given SID from the String INDEX

609

fn read_string_index_string<'idx>(

610

    string_index: &'idx MaybeOwnedIndex<'_>,

611

    sid: SID,

612

) -> Result<&'idx str, ParseError> {

613

    let sid = usize::from(sid);

614

    // When the client needs to determine the string that corresponds to a particular SID it

615

    // performs the following: test if SID is in standard range then fetch from internal table,

616

    // otherwise, fetch string from the String INDEX using a value of (SID – nStdStrings) as

617

    // the index

618

    if let Some(string) = STANDARD_STRINGS.get(sid) {

619

        Ok(string)

620

    } else {

621

        let bytes = string_index

622

            .read_object(sid - STANDARD_STRINGS.len())

623

            .ok_or(ParseError::BadIndex)?;

624

625

        std::str::from_utf8(bytes).map_err(|_utf8_err| ParseError::BadValue)

626

627

628

629

impl ReadBinary for Header {

630

    type HostType<'b> = Self;

631

632

    fn read(ctxt: &mut ReadCtxt<'_>) -> Result<Self, ParseError> {

633

        // From section 6 of Technical Note #5176:

634

        // Implementations reading font set files must include code to check version numbers so

635

        // that if and when the format and therefore the version number changes, older

636

        // implementations will reject newer versions gracefully. If the major version number is

637

        // understood by an implementation it can safely proceed with reading the font. The minor

638

        // version number indicates extensions to the format that are undetectable by

639

        // implementations that do not support them although they will be unable to take advantage

640

        // of these extensions.

641

        let major = ctxt.read_u8()?;

642

        ctxt.check(major == 1)?;

643

        let minor = ctxt.read_u8()?;

644

        let hdr_size = ctxt.read_u8()?;

645

        let off_size = ctxt.read_u8()?;

646

647

        if hdr_size < 4 {

648

            return Err(ParseError::BadValue);

649

650

651

        if off_size < 1 || off_size > 4 {

652

            return Err(ParseError::BadValue);

653

654

655

        let _unknown = ctxt.read_slice((hdr_size - 4) as usize)?;

656

657

        Ok(Header {

658

            major,

659

            minor,

660

            hdr_size,

661

            off_size,

662

})

663

664

665

666

impl WriteBinary<&Self> for Header {

667

    type Output = ();

668

669

    fn write<C: WriteContext>(ctxt: &mut C, header: &Header) -> Result<(), WriteError> {

670

        U8::write(ctxt, header.major)?;

671

        U8::write(ctxt, header.minor)?;

672

        // Any data between the header and the Name INDEX will have been discarded.

673

        // So the size will always be 4 bytes.

674

        U8::write(ctxt, 4)?; // hdr_size

675

        U8::write(ctxt, header.off_size)?;

676

677

        Ok(())

678

679

680

681

impl ReadBinary for IndexU16 {

682

    type HostType<'a> = Index<'a>;

683

684

    fn read<'a>(ctxt: &mut ReadCtxt<'a>) -> Result<Self::HostType<'a>, ParseError> {

685

        let count = usize::from(ctxt.read_u16be()?);

686

        read_index(ctxt, count)

687

688

689

690

fn read_index<'a>(ctxt: &mut ReadCtxt<'a>, count: usize) -> Result<Index<'a>, ParseError> {

691

    if count > 0 {

692

        let off_size = ctxt.read_u8()?;

693

        if off_size < 1 || off_size > 4 {

694

            return Err(ParseError::BadValue);

695

696

697

        let offset_array_size = (count + 1) * usize::from(off_size);

698

        let offset_array = ctxt.read_slice(offset_array_size)?;

699

700

        let last_offset_index = lookup_offset_index(off_size, offset_array, count);

701

        if last_offset_index < 1 {

702

            return Err(ParseError::BadValue);

703

704

705

        let data_array_size = last_offset_index - 1;

706

        let data_array = ctxt.read_slice(data_array_size)?;

707

708

        Ok(Index {

709

            count,

710

            off_size,

711

            offset_array,

712

            data_array,

713

})

714

    } else {

715

        // count == 0

716

        Ok(Index {

717

            count,

718

            off_size: 1,

719

            offset_array: &[],

720

            data_array: &[],

721

})

722

723

724

725

impl<'a> WriteBinary<&Index<'a>> for IndexU16 {

726

    type Output = ();

727

728

    fn write<C: WriteContext>(ctxt: &mut C, index: &Index<'a>) -> Result<(), WriteError> {

729

        U16Be::write(ctxt, u16::try_from(index.count)?)?;

730

        write_index_body(ctxt, index)

731

732

733

734

fn write_index_body<C: WriteContext>(ctxt: &mut C, index: &Index<'_>) -> Result<(), WriteError> {

735

    if index.count == 0 {

736

        return Ok(());

737

738

739

    U8::write(ctxt, index.off_size)?;

740

    ctxt.write_bytes(index.offset_array)?;

741

    ctxt.write_bytes(index.data_array)?;

742

743

    Ok(())

744

745

746

impl<T> ReadBinaryDep for Dict<T>

747

where

748

    T: DictDefault,

749

750

    type Args<'a> = usize;

751

    type HostType<'b> = Self;

752

753

    fn read_dep<'a>(

754

        ctxt: &mut ReadCtxt<'a>,

755

        max_operands: usize,

756

    ) -> Result<Self::HostType<'a>, ParseError> {

757

        let mut dict = Vec::new();

758

        let mut operands = Vec::new();

759

760

        while ctxt.bytes_available() {

761

            match Op::read(ctxt)? {

762

                Op::Operator(operator) => {

763

                    integer_to_offset(operator, &mut operands);

764

                    dict.push((operator, operands.clone()));

765

                    operands.clear();

766

767

                Op::Operand(operand) => {

768

                    operands.push(operand);

769

                    if operands.len() > max_operands {

770

                        return Err(ParseError::LimitExceeded);

771

772

773

774

775

776

        Ok(Dict {

777

            dict,

778

            default: PhantomData,

779

})

780

781

782

783

fn offset_size(value: usize) -> Option<u8> {

784

    match value {

785

        0..=0xFF => Some(1),

786

        0x100..=0xFFFF => Some(2),

787

        0x1_0000..=0xFF_FFFF => Some(3),

788

        0x100_0000..=0xFFFF_FFFF => Some(4),

789

        _ => None,

790

791

792

793

// Special case handling for operands that are offsets. This function swaps them from an

794

// Integer to an Offset. This is later used when writing operands.

795

fn integer_to_offset(operator: Operator, operands: &mut [Operand]) {

796

    match (operator, &operands) {

797

        // Encodings 0..=1 indicate predefined encodings and are not offsets

798

        (Operator::Encoding, [Operand::Integer(offset)]) if *offset > 1 => {

799

            operands[0] = Operand::Offset(*offset);

800

801

        (Operator::Charset, [Operand::Integer(offset)])

802

        | (Operator::CharStrings, [Operand::Integer(offset)])

803

        | (Operator::Subrs, [Operand::Integer(offset)])

804

        | (Operator::FDArray, [Operand::Integer(offset)])

805

        | (Operator::FDSelect, [Operand::Integer(offset)])

806

        | (Operator::VStore, [Operand::Integer(offset)]) => {

807

            operands[0] = Operand::Offset(*offset);

808

809

        (Operator::Private, [Operand::Integer(length), Operand::Integer(offset)]) => {

810

            let offset = *offset; // This is a work around an ownership issue

811

            operands[0] = Operand::Offset(*length);

812

            operands[1] = Operand::Offset(offset);

813

814

        _ => {}

815

816

817

818

impl<T> WriteBinaryDep<&Self> for Dict<T>

819

where

820

    T: DictDefault,

821

822

    type Args = DictDelta;

823

    type Output = usize; // The length of the written Dict

824

825

    fn write_dep<C: WriteContext>(

826

        ctxt: &mut C,

827

        dict: &Dict<T>,

828

        delta: DictDelta,

829

    ) -> Result<Self::Output, WriteError> {

830

        let offset = ctxt.bytes_written();

831

832

        for (operator, operands) in dict.iter() {

833

            let mut operands = operands.as_slice();

834

835

            // Replace operands with delta operands if present otherwise skip if operands match

836

            // default. We never skip operands pulled from the delta DICT as these are offsets and

837

            // always need to be written in order to make the size of the DICT predictable.

838

            if let Some(delta_operands) = delta.get(*operator) {

839

                operands = delta_operands;

840

            } else if T::default(*operator)

841

                .map(|defaults| defaults == operands)

842

                .unwrap_or(false)

843

844

                continue;

845

846

847

            for operand in operands {

848

                Operand::write(ctxt, operand)?;

849

850

            Operator::write(ctxt, *operator)?;

851

852

853

        Ok(ctxt.bytes_written() - offset)

854

855

856

857

impl ReadBinary for Op {

858

    type HostType<'b> = Self;

859

860

    fn read(ctxt: &mut ReadCtxt<'_>) -> Result<Self, ParseError> {

861

        let b0 = ctxt.read_u8()?;

862

863

        match b0 {

864

            0..=11 | 13..=21 => ok_operator(u16::from(b0).try_into().unwrap()), // NOTE(unwrap): Safe due to pattern

865

            // CFF2

866

            22..=24 => ok_operator(u16::from(b0).try_into().unwrap()), // NOTE(unwrap): Safe due to pattern

867

            12 => ok_operator(op2(ctxt.read_u8()?).try_into()?),

868

            28 => {

869

                let num = ctxt.read_i16be()?;

870

                Ok(Op::Operand(Operand::Integer(i32::from(num))))

871

872

            29 => ok_int(ctxt.read_i32be()?),

873

            30 => ok_real(ctxt.read_until_nibble(END_OF_FLOAT_FLAG)?),

874

            32..=246 => ok_int(i32::from(b0) - 139),

875

            247..=250 => {

876

                let b1 = ctxt.read_u8()?;

877

                ok_int((i32::from(b0) - 247) * 256 + i32::from(b1) + 108)

878

879

            251..=254 => {

880

                let b1 = ctxt.read_u8()?;

881

                ok_int(-(i32::from(b0) - 251) * 256 - i32::from(b1) - 108)

882

883

            // reserved

884

            25..=27 | 31 | 255 => Err(ParseError::BadValue),

885

886

887

888

889

impl WriteBinary<Self> for Operator {

890

    type Output = ();

891

892

    fn write<C: WriteContext>(ctxt: &mut C, op: Operator) -> Result<(), WriteError> {

893

        let value = op as u16;

894

        if value > 0xFF {

895

            U16Be::write(ctxt, value)?;

896

        } else {

897

            U8::write(ctxt, value as u8)?;

898

899

900

        Ok(())

901

902

903

904

impl WriteBinary<&Self> for Operand {

905

    type Output = ();

906

907

    // Refer to Table 3 Operand Encoding in section 4 of Technical Note #5176 for details on the

908

    // integer encoding scheme.

909

    fn write<C: WriteContext>(ctxt: &mut C, op: &Operand) -> Result<(), WriteError> {

910

        match op {

911

            Operand::Integer(val) => match *val {

912

                // NOTE: Casts are safe due to patterns limiting range

913

                -107..=107 => {

914

                    U8::write(ctxt, (val + 139) as u8)?;

915

916

                108..=1131 => {

917

                    let val = *val - 108;

918

                    U8::write(ctxt, ((val >> 8) + 247) as u8)?;

919

                    U8::write(ctxt, val as u8)?;

920

921

                -1131..=-108 => {

922

                    let val = -*val - 108;

923

                    U8::write(ctxt, ((val >> 8) + 251) as u8)?;

924

                    U8::write(ctxt, val as u8)?;

925

926

                -32768..=32767 => {

927

                    U8::write(ctxt, 28)?;

928

                    I16Be::write(ctxt, *val as i16)?

929

930

                _ => {

931

                    U8::write(ctxt, 29)?;

932

                    I32Be::write(ctxt, *val)?

933

934

},

935

            Operand::Offset(val) => {

936

                U8::write(ctxt, 29)?;

937

                // Offsets are always encoded using the i32 representation to make their size

938

                // predictable.

939

                I32Be::write(ctxt, *val)?;

940

941

            Operand::Real(Real(val)) => {

942

                U8::write(ctxt, 30)?;

943

                ctxt.write_bytes(val)?;

944

945

946

947

        Ok(())

948

949

950

951

fn ok_operator(op: Operator) -> Result<Op, ParseError> {

952

    Ok(Op::Operator(op))

953

954

955

fn ok_int(num: i32) -> Result<Op, ParseError> {

956

    Ok(Op::Operand(Operand::Integer(num)))

957

958

959

fn ok_real(slice: &[u8]) -> Result<Op, ParseError> {

960

    Ok(Op::Operand(Operand::Real(Real(TinyVec::from(slice)))))

961

962

963

const FLOAT_BUF_LEN: usize = 64;

964

965

// Portions of this try_from impl derived from ttf-parser, licenced under Apache-2.0.

966

// https://github.com/RazrFalcon/ttf-parser/blob/ba2d9c8b9a207951b7b07e9481bc74688762bd21/src/tables/cff/dict.rs#L188

967

impl TryFrom<&Real> for f64 {

968

    type Error = ParseError;

969

970

    /// Try to parse this `Real` into an `f64`.

971

    fn try_from(real: &Real) -> Result<Self, Self::Error> {

972

        let mut buf = [0u8; FLOAT_BUF_LEN];

973

        let mut used = 0;

974

975

        for byte in real.0.iter().copied() {

976

            let nibble1 = byte >> 4;

977

            let nibble2 = byte & 0xF;

978

979

            if nibble1 == END_OF_FLOAT_FLAG {

980

                break;

981

982

            parse_float_nibble(nibble1, &mut used, &mut buf)?;

983

            if nibble2 == END_OF_FLOAT_FLAG {

984

                break;

985

986

            parse_float_nibble(nibble2, &mut used, &mut buf)?;

987

988

989

        // NOTE(unwrap): Safe as we have constructed the string from only ASCII characters in

990

        // parse_float_nibble.

991

        let s = core::str::from_utf8(&buf[..used]).unwrap();

992

        s.parse().map_err(|_| ParseError::BadValue)

993

994

995

996

// Adobe Technical Note #5176, Table 5 Nibble Definitions

997

fn parse_float_nibble(nibble: u8, idx: &mut usize, data: &mut [u8]) -> Result<(), ParseError> {

998

    if *idx == FLOAT_BUF_LEN {

999

        return Err(ParseError::LimitExceeded);

1000

1001

1002

    match nibble {

1003

        0..=9 => {

1004

            data[*idx] = b'0' + nibble;

1005

1006

        10 => {

1007

            data[*idx] = b'.';

1008

1009

        11 => {

1010

            data[*idx] = b'E';

1011

1012

        12 => {

1013

            if *idx + 1 == FLOAT_BUF_LEN {

1014

                return Err(ParseError::LimitExceeded);

1015

1016

1017

            data[*idx] = b'E';

1018

            *idx += 1;

1019

            data[*idx] = b'-';

1020

1021

        13 => return Err(ParseError::BadValue),

1022

        14 => {

1023

            data[*idx] = b'-';

1024

1025

        _ => return Err(ParseError::BadValue),

1026

1027

1028

    *idx += 1;

1029

    Ok(())

1030

1031

1032

impl ReadFrom for Range<u8, u8> {

1033

    type ReadType = (U8, U8);

1034

    fn read_from((first, n_left): (u8, u8)) -> Self {

1035

        Range { first, n_left }

1036

1037

1038

1039

impl WriteBinary for Range<u8, u8> {

1040

    type Output = ();

1041

1042

    fn write<C: WriteContext>(ctxt: &mut C, range: Self) -> Result<(), WriteError> {

1043

        U8::write(ctxt, range.first)?;

1044

        U8::write(ctxt, range.n_left)?;

1045

1046

        Ok(())

1047

1048

1049

1050

impl ReadFrom for Range<SID, u8> {

1051

    type ReadType = (U16Be, U8);

1052

    fn read_from((first, n_left): (SID, u8)) -> Self {

1053

        Range { first, n_left }

1054

1055

1056

1057

impl WriteBinary for Range<SID, u8> {

1058

    type Output = ();

1059

1060

    fn write<C: WriteContext>(ctxt: &mut C, range: Self) -> Result<(), WriteError> {

1061

        U16Be::write(ctxt, range.first)?;

1062

        U8::write(ctxt, range.n_left)?;

1063

1064

        Ok(())

1065

1066

1067

1068

impl ReadFrom for Range<SID, u16> {

1069

    type ReadType = (U16Be, U16Be);

1070

    fn read_from((first, n_left): (SID, u16)) -> Self {

1071

        Range { first, n_left }

1072

1073

1074

1075

impl WriteBinary for Range<SID, u16> {

1076

    type Output = ();

1077

1078

    fn write<C: WriteContext>(ctxt: &mut C, range: Self) -> Result<(), WriteError> {

1079

        U16Be::write(ctxt, range.first)?;

1080

        U16Be::write(ctxt, range.n_left)?;

1081

1082

        Ok(())

1083

1084

1085

1086

impl<F, N> Range<F, N>

1087

where

1088

    N: Copy,

1089

    usize: From<N>,

1090

1091

    pub fn len(&self) -> usize {

1092

        usize::from(self.n_left) + 1

1093

1094

1095

1096

// TODO: Make these generic. Requires Rust stabilisation of the Step trait or its replacement.

1097

// https://doc.rust-lang.org/core/iter/trait.Step.html

1098

impl Range<SID, u8> {

1099

    pub fn iter(&self) -> impl Iterator<Item = SID> {

1100

        let last = self.first + SID::from(self.n_left);

1101

        self.first..=last

1102

1103

1104

1105

impl Range<SID, u16> {

1106

    pub fn iter(&self) -> impl Iterator<Item = SID> {

1107

        let last = self.first + self.n_left;

1108

        self.first..=last

1109

1110

1111

1112

impl ReadBinary for CustomEncoding<'_> {

1113

    type HostType<'a> = CustomEncoding<'a>;

1114

1115

    fn read<'a>(ctxt: &mut ReadCtxt<'a>) -> Result<Self::HostType<'a>, ParseError> {

1116

        // First byte indicates the format of the encoding data

1117

        match ctxt.read::<U8>()? {

1118

            0 => {

1119

                let ncodes = ctxt.read::<U8>()?;

1120

                let codes = ctxt.read_array::<U8>(usize::from(ncodes))?;

1121

                Ok(CustomEncoding::Format0 { codes })

1122

1123

            1 => {

1124

                let nranges = ctxt.read::<U8>()?;

1125

                let ranges = ctxt.read_array::<Range<u8, u8>>(usize::from(nranges))?;

1126

                Ok(CustomEncoding::Format1 { ranges })

1127

1128

            // The CFF spec notes:

1129

            // A few fonts have multiply-encoded glyphs which are not supported directly by any of

1130

            // the above formats. This situation is indicated by setting the high-order bit in the

1131

            // format byte and supplementing the encoding.

1132

//

1133

            // This is not handed as it is not expected that these will be encountered in CFF in

1134

            // OTF files.

1135

            format if format & 0x80 == 0x80 => Err(ParseError::NotImplemented),

1136

            _ => Err(ParseError::BadValue),

1137

1138

1139

1140

1141

impl WriteBinary<&Self> for CustomEncoding<'_> {

1142

    type Output = ();

1143

1144

    fn write<C: WriteContext>(ctxt: &mut C, encoding: &Self) -> Result<(), WriteError> {

1145

        match encoding {

1146

            CustomEncoding::Format0 { codes } => {

1147

                U8::write(ctxt, 0)?; // format

1148

                U8::write(ctxt, u8::try_from(codes.len())?)?;

1149

                <&ReadArray<'_, _>>::write(ctxt, codes)?;

1150

1151

            CustomEncoding::Format1 { ranges } => {

1152

                U8::write(ctxt, 1)?; // format

1153

                U8::write(ctxt, u8::try_from(ranges.len())?)?;

1154

                <&ReadArray<'_, _>>::write(ctxt, ranges)?;

1155

1156

1157

1158

        Ok(())

1159

1160

1161

1162

impl Charset<'_> {

1163

    /// Returns the id of the SID (Type 1 font) or CID (CID keyed font) of the name of the supplied glyph

1164

    pub fn id_for_glyph(&self, glyph_id: u16) -> Option<u16> {

1165

        match self {

1166

            // In ISOAdobe glyph ID maps to SID

1167

            Charset::ISOAdobe => {

1168

                if glyph_id <= ISO_ADOBE_LAST_SID {

1169

                    Some(glyph_id)

1170

                } else {

1171

                    None

1172

1173

1174

            Charset::Expert => EXPERT_CHARSET.get(usize::from(glyph_id)).copied(),

1175

            Charset::ExpertSubset => EXPERT_SUBSET_CHARSET.get(usize::from(glyph_id)).copied(),

1176

            Charset::Custom(custom) => custom.id_for_glyph(glyph_id),

1177

1178

1179

1180

    /// Returns the glyph id of the supplied string id.

1181

    pub fn sid_to_gid(&self, sid: SID) -> Option<u16> {

1182

        if sid == 0 {

1183

            return Some(0);

1184

1185

1186

        match self {

1187

            Charset::ISOAdobe | Charset::Expert | Charset::ExpertSubset => None,

1188

            Charset::Custom(custom) => custom.sid_to_gid(sid),

1189

1190

1191

1192

1193

impl ReadBinaryDep for CustomCharset<'_> {

1194

    type Args<'a> = usize;

1195

    type HostType<'a> = CustomCharset<'a>;

1196

1197

    fn read_dep<'a>(

1198

        ctxt: &mut ReadCtxt<'a>,

1199

        n_glyphs: usize,

1200

    ) -> Result<Self::HostType<'a>, ParseError> {

1201

        // (There is one less element in the charset than nGlyphs because the .notdef glyph name is omitted.)

1202

        let n_glyphs = n_glyphs.checked_sub(1).ok_or(ParseError::BadValue)?;

1203

        match ctxt.read::<U8>()? {

1204

            0 => {

1205

                // The number of glyphs (nGlyphs) is the value of the count field in the

1206

                // CharStrings INDEX.

1207

                let glyphs = ctxt.read_array::<U16Be>(n_glyphs)?;

1208

                Ok(CustomCharset::Format0 {

1209

                    glyphs: ReadArrayCow::Borrowed(glyphs),

1210

})

1211

1212

            1 => {

1213

                let ranges = read_range_array(ctxt, n_glyphs)?;

1214

                Ok(CustomCharset::Format1 {

1215

                    ranges: ReadArrayCow::Borrowed(ranges),

1216

})

1217

1218

            2 => {

1219

                let ranges = read_range_array(ctxt, n_glyphs)?;

1220

                Ok(CustomCharset::Format2 {

1221

                    ranges: ReadArrayCow::Borrowed(ranges),

1222

})

1223

1224

            _ => Err(ParseError::BadValue),

1225

1226

1227

1228

1229

impl WriteBinary<&Self> for CustomCharset<'_> {

1230

    type Output = ();

1231

1232

    fn write<C: WriteContext>(ctxt: &mut C, charset: &Self) -> Result<(), WriteError> {

1233

        match charset {

1234

            CustomCharset::Format0 { glyphs } => {

1235

                U8::write(ctxt, 0)?; // format

1236

                ReadArrayCow::write(ctxt, glyphs)?;

1237

1238

            CustomCharset::Format1 { ranges } => {

1239

                U8::write(ctxt, 1)?; // format

1240

                ReadArrayCow::write(ctxt, ranges)?;

1241

1242

            CustomCharset::Format2 { ranges } => {

1243

                U8::write(ctxt, 2)?; // format

1244

                ReadArrayCow::write(ctxt, ranges)?;

1245

1246

1247

1248

        Ok(())

1249

1250

1251

1252

impl<'a> CustomCharset<'a> {

1253

    pub fn iter(&'a self) -> Box<dyn Iterator<Item = u16> + 'a> {

1254

        let notdef = iter::once(0);

1255

        match &self {

1256

            CustomCharset::Format0 { glyphs } => Box::new(notdef.chain(glyphs.iter())),

1257

            CustomCharset::Format1 { ranges } => {

1258

                Box::new(notdef.chain(ranges.iter().flat_map(|range| range.iter())))

1259

1260

            CustomCharset::Format2 { ranges } => {

1261

                Box::new(notdef.chain(ranges.iter().flat_map(|range| range.iter())))

1262

1263

1264

1265

1266

    /// Returns the SID (Type 1 font) or CID (CID keyed font) of the name of the supplied glyph

1267

    pub fn id_for_glyph(&self, glyph_id: u16) -> Option<u16> {

1268

        // Section 11 of Technical Note #5176:

1269

        // By definition the first glyph (GID 0) is “.notdef” and must be present in all fonts.

1270

        // Since this is always the case, it is not necessary to represent either the encoding

1271

        // (unencoded) or name (.notdef) for GID 0. Consequently, taking advantage of this

1272

        // optimization, the encoding and charset arrays always begin with GID 1.

1273

        if glyph_id == 0 {

1274

            return Some(0);

1275

1276

1277

        match self {

1278

            CustomCharset::Format0 { glyphs } => {

1279

                let index = usize::from(glyph_id - 1);

1280

                glyphs.get_item(index)

1281

1282

            CustomCharset::Format1 { ranges } => Self::id_for_glyph_in_ranges(ranges, glyph_id),

1283

            CustomCharset::Format2 { ranges } => Self::id_for_glyph_in_ranges(ranges, glyph_id),

1284

1285

1286

1287

    pub fn sid_to_gid(&self, sid: SID) -> Option<u16> {

1288

        match self {

1289

            CustomCharset::Format0 { glyphs: array } => {

1290

                // First glyph is omitted, so we have to add 1.

1291

                array

1292

                    .into_iter()

1293

                    .position(|n| n == sid)

1294

                    .and_then(|n| u16::try_from(n + 1).ok())

1295

1296

            CustomCharset::Format1 { ranges } => Self::glyph_id_for_sid_in_ranges(ranges, sid),

1297

            CustomCharset::Format2 { ranges } => Self::glyph_id_for_sid_in_ranges(ranges, sid),

1298

1299

1300

1301

    fn glyph_id_for_sid_in_ranges<F, N>(

1302

        ranges: &ReadArrayCow<'a, Range<F, N>>,

1303

        sid: SID,

1304

    ) -> Option<u16>

1305

    where

1306

        F: Copy,

1307

        N: Copy,

1308

        u32: From<N> + From<F>,

1309

        u16: From<N> + From<F>,

1310

        Range<F, N>: ReadFrom,

1311

1312

        let mut glyph_id = 1;

1313

        for range in ranges.iter() {

1314

            let last = u32::from(range.first) + u32::from(range.n_left);

1315

            if u16::from(range.first) <= sid && u32::from(sid) <= last {

1316

                glyph_id += sid - u16::from(range.first);

1317

                return Some(glyph_id);

1318

1319

1320

            glyph_id += u16::from(range.n_left) + 1;

1321

1322

1323

        None

1324

1325

1326

    fn id_for_glyph_in_ranges<F, N>(

1327

        ranges: &ReadArrayCow<'a, Range<F, N>>,

1328

        glyph_id: u16,

1329

    ) -> Option<u16>

1330

    where

1331

        F: Copy,

1332

        N: Copy,

1333

        usize: From<N> + From<F>,

1334

        Range<F, N>: ReadFrom,

1335

        <Range<F, N> as ReadUnchecked>::HostType: Copy,

1336

1337

        let glyph_id = usize::from(glyph_id);

1338

1339

        ranges

1340

            .iter()

1341

            .scan(0usize, |glyphs_covered, range| {

1342

                *glyphs_covered += range.len();

1343

                Some((*glyphs_covered, range))

1344

})

1345

            .find(|(glyphs_covered, _range)| glyph_id <= *glyphs_covered)

1346

            .and_then(|(glyphs_covered, range)| {

1347

                (usize::from(range.first) + (glyph_id - (glyphs_covered - range.len()) - 1))

1348

                    .try_into()

1349

                    .ok()

1350

})

1351

1352

1353

1354

impl ReadBinaryDep for FDSelect<'_> {

1355

    type Args<'a> = usize;

1356

    type HostType<'a> = FDSelect<'a>;

1357

1358

    fn read_dep<'a>(

1359

        ctxt: &mut ReadCtxt<'a>,

1360

        n_glyphs: usize,

1361

    ) -> Result<Self::HostType<'a>, ParseError> {

1362

        match ctxt.read::<U8>()? {

1363

            0 => {

1364

                let glyph_font_dict_indices = ctxt.read_array::<U8>(n_glyphs)?;

1365

                Ok(FDSelect::Format0 {

1366

                    glyph_font_dict_indices: ReadArrayCow::Borrowed(glyph_font_dict_indices),

1367

})

1368

1369

            3 => {

1370

                let nranges = usize::from(ctxt.read::<U16Be>()?);

1371

                let ranges = ctxt.read_array(nranges)?;

1372

                let sentinel = ctxt.read::<U16Be>()?;

1373

                Ok(FDSelect::Format3 {

1374

                    ranges: ReadArrayCow::Borrowed(ranges),

1375

                    sentinel,

1376

})

1377

1378

            // Format4 was added in CFF2, it allows GIDs greater than u16::MAX but the

1379

            // rest of the OpenType format does not accommodate this yet, so it's not

1380

            // implemented.

1381

            4 => Err(ParseError::NotImplemented),

1382

            _ => Err(ParseError::BadValue),

1383

1384

1385

1386

1387

impl WriteBinary<&Self> for FDSelect<'_> {

1388

    type Output = ();

1389

1390

    fn write<C: WriteContext>(ctxt: &mut C, fd_select: &Self) -> Result<(), WriteError> {

1391

        match fd_select {

1392

            FDSelect::Format0 {

1393

                glyph_font_dict_indices,

1394

            } => {

1395

                U8::write(ctxt, 0)?; // format

1396

                ReadArrayCow::write(ctxt, glyph_font_dict_indices)?;

1397

1398

            FDSelect::Format3 { ranges, sentinel } => {

1399

                U8::write(ctxt, 3)?; // format

1400

                U16Be::write(ctxt, u16::try_from(ranges.len())?)?;

1401

                ReadArrayCow::write(ctxt, ranges)?;

1402

                U16Be::write(ctxt, *sentinel)?;

1403

1404

1405

1406

        Ok(())

1407

1408

1409

1410

impl PartialEq for FDSelect<'_> {

1411

    fn eq(&self, other: &Self) -> bool {

1412

        match (self, other) {

1413

1414

                FDSelect::Format0 {

1415

                    glyph_font_dict_indices: self_glyph_font_dict_indices,

1416

},

1417

                FDSelect::Format0 {

1418

                    glyph_font_dict_indices: other_glyph_font_dict_indices,

1419

},

1420

            ) => {

1421

                self_glyph_font_dict_indices.len() == other_glyph_font_dict_indices.len()

1422

                    && self_glyph_font_dict_indices

1423

                        .iter()

1424

                        .zip(other_glyph_font_dict_indices.iter())

1425

                        .all(|(left, right)| left == right)

1426

1427

1428

                FDSelect::Format3 {

1429

                    ranges: self_ranges,

1430

                    sentinel: self_sentinel,

1431

},

1432

                FDSelect::Format3 {

1433

                    ranges: other_ranges,

1434

                    sentinel: other_sentinel,

1435

},

1436

            ) => {

1437

                self_ranges.len() == other_ranges.len()

1438

                    && self_sentinel == other_sentinel

1439

                    && self_ranges

1440

                        .iter()

1441

                        .zip(other_ranges.iter())

1442

                        .all(|(left, right)| left == right)

1443

1444

            _ => false,

1445

1446

1447

1448

1449

impl FDSelect<'_> {

1450

    /// Returns the index of the Font DICT for the supplied `glyph_id`

1451

    pub fn font_dict_index(&self, glyph_id: u16) -> Option<u8> {

1452

        let index = usize::from(glyph_id);

1453

        match self {

1454

            FDSelect::Format0 {

1455

                glyph_font_dict_indices,

1456

            } => glyph_font_dict_indices.get_item(index),

1457

            FDSelect::Format3 { ranges, sentinel } => {

1458

                let mut iter = ranges

1459

                    .iter()

1460

                    .map(|Range { first, n_left }| (first, Some(n_left)))

1461

                    .chain(iter::once((*sentinel, None)))

1462

                    .peekable();

1463

1464

                while let Some((first, fd_index)) = iter.next() {

1465

                    let &(last, _) = match iter.peek() {

1466

                        Some(next) => next,

1467

                        None => break,

1468

};

1469

                    if glyph_id >= first && glyph_id < last {

1470

                        return fd_index;

1471

1472

1473

1474

                None

1475

1476

1477

1478

1479

1480

impl<'a> Index<'a> {

1481

    fn read_object(&self, index: usize) -> Option<&[u8]> {

1482

        if index < self.count {

1483

            let start_index = lookup_offset_index(self.off_size, self.offset_array, index) - 1;

1484

            let end_index = lookup_offset_index(self.off_size, self.offset_array, index + 1) - 1;

1485

            Some(&self.data_array[start_index..end_index])

1486

        } else {

1487

            None

1488

1489

1490

1491

    pub fn read<T: ReadBinaryDep>(

1492

        &'a self,

1493

        index: usize,

1494

        args: T::Args<'a>,

1495

    ) -> Result<T::HostType<'a>, ParseError> {

1496

        let data = self.read_object(index).ok_or(ParseError::BadIndex)?;

1497

        ReadScope::new(data).read_dep::<T>(args)

1498

1499

1500

    pub fn iter(&self) -> impl Iterator<Item = &[u8]> {

1501

        // NOTE(unwrap): Safe since we're iterating over valid indices

1502

        (0..self.count).map(move |i| self.read_object(i).unwrap())

1503

1504

1505

    /// Returns the length required to write `objects`.

1506

    pub fn calculate_size<'b, T, HostType>(

1507

        objects: &'b [&HostType],

1508

        args: T::Args,

1509

    ) -> Result<usize, WriteError>

1510

    where

1511

        T: WriteBinaryDep<&'b HostType>,

1512

        T::Args: Clone,

1513

1514

        let mut counter = WriteCounter::new();

1515

1516

        U16Be::write(&mut counter, u16::try_from(objects.len())?)?;

1517

        let off_size = if !objects.is_empty() {

1518

            let start = counter.bytes_written();

1519

            for obj in objects {

1520

                T::write_dep(&mut counter, obj, args.clone())?;

1521

1522

            let last_offset = counter.bytes_written() - start + 1; // +1 because index offsets start at 1

1523

            let off_size = offset_size(last_offset).ok_or(WriteError::BadValue)?;

1524

            U8::write(&mut counter, off_size)?;

1525

            off_size

1526

        } else {

1527

1528

};

1529

1530

        let offset_array_size = usize::from(off_size) * (objects.len() + 1);

1531

        Ok(counter.bytes_written() + offset_array_size)

1532

1533

1534

    /// Returns the size of the data held by this INDEX.

1535

    pub fn data_len(&self) -> usize {

1536

        self.data_array.len()

1537

1538

1539

1540

impl<'a> MaybeOwnedIndex<'a> {

1541

    pub fn iter(&'a self) -> MaybeOwnedIndexIterator<'a> {

1542

        MaybeOwnedIndexIterator {

1543

            data: self,

1544

            index: 0,

1545

1546

1547

1548

    pub fn read_object(&self, index: usize) -> Option<&[u8]> {

1549

        match self {

1550

            MaybeOwnedIndex::Borrowed(idx) => idx.read_object(index),

1551

            MaybeOwnedIndex::Owned(idx) => idx.read_object(index),

1552

1553

1554

1555

    /// Returns the number of items in self.

1556

    pub fn len(&self) -> usize {

1557

        match self {

1558

            MaybeOwnedIndex::Borrowed(index) => index.count,

1559

            MaybeOwnedIndex::Owned(index) => index.data.len(),

1560

1561

1562

1563

    /// Returns the index of `object` in self if found.

1564

    fn index(&self, object: &[u8]) -> Option<usize> {

1565

        self.iter().position(|obj| obj == object)

1566

1567

1568

    /// Push an object onto this `MaybeOwnedIndex`. Returns the index of the object in self.

1569

///

1570

    /// If self is `Borrowed` then it is converted to the `Owned` variant first.

1571

    fn push(&mut self, object: Vec<u8>) -> usize {

1572

        match self {

1573

            MaybeOwnedIndex::Borrowed(_) => {

1574

                self.to_owned();

1575

                self.push(object);

1576

1577

            MaybeOwnedIndex::Owned(index) => {

1578

                index.data.push(object);

1579

1580

1581

1582

        self.len() - 1

1583

1584

1585

    /// Replace the object at `idx` with `object`.

1586

///

1587

    /// If self is `Borrowed` then it is converted to the `Owned` variant first.

1588

///

1589

    /// **Panics**

1590

///

1591

    /// Panics if `idx` is out of bounds.

1592

    pub fn replace(&mut self, idx: usize, object: Vec<u8>) {

1593

        match self {

1594

            MaybeOwnedIndex::Borrowed(_) => {

1595

                self.to_owned();

1596

                self.replace(idx, object);

1597

1598

            MaybeOwnedIndex::Owned(index) => index.data[idx] = object,

1599

1600

1601

1602

    /// If self is the `Borrowed` variant, convert to the `Owned` variant.

1603

    fn to_owned(&mut self) {

1604

        match self {

1605

            MaybeOwnedIndex::Borrowed(data) => {

1606

                let data = data.iter().map(|obj| obj.to_owned()).collect();

1607

                *self = MaybeOwnedIndex::Owned(owned::Index { data })

1608

1609

            MaybeOwnedIndex::Owned(_) => {}

1610

1611

1612

1613

    pub fn data_len(&self) -> usize {

1614

        match self {

1615

            MaybeOwnedIndex::Borrowed(index) => index.data_len(),

1616

            MaybeOwnedIndex::Owned(index) => index.data.iter().map(|data| data.len()).sum(),

1617

1618

1619

1620

    pub(crate) fn write32<C: WriteContext>(

1621

        ctxt: &mut C,

1622

        index: &MaybeOwnedIndex<'_>,

1623

    ) -> Result<(), WriteError> {

1624

        match index {

1625

            MaybeOwnedIndex::Borrowed(index) => IndexU32::write(ctxt, index),

1626

            MaybeOwnedIndex::Owned(index) => owned::IndexU32::write(ctxt, index),

1627

1628

1629

1630

    pub(crate) fn write16<C: WriteContext>(

1631

        ctxt: &mut C,

1632

        index: &MaybeOwnedIndex<'_>,

1633

    ) -> Result<(), WriteError> {

1634

        match index {

1635

            MaybeOwnedIndex::Borrowed(index) => IndexU16::write(ctxt, index),

1636

            MaybeOwnedIndex::Owned(index) => owned::IndexU16::write(ctxt, index),

1637

1638

1639

1640

1641

impl<'a> Iterator for MaybeOwnedIndexIterator<'a> {

1642

    type Item = &'a [u8];

1643

1644

    fn next(&mut self) -> Option<Self::Item> {

1645

        if self.index < self.data.len() {

1646

            let index = self.index;

1647

            self.index += 1;

1648

            self.data.read_object(index)

1649

        } else {

1650

            None

1651

1652

1653

1654

    fn size_hint(&self) -> (usize, Option<usize>) {

1655

        let len = self.data.len();

1656

        (len, Some(len))

1657

1658

1659

1660

impl DictDefault for TopDictDefault {

1661

    fn default(op: Operator) -> Option<&'static [Operand]> {

1662

        match op {

1663

            Operator::IsFixedPitch => Some(&OPERAND_ZERO),

1664

            Operator::ItalicAngle => Some(&OPERAND_ZERO),

1665

            Operator::UnderlinePosition => Some(&DEFAULT_UNDERLINE_POSITION),

1666

            Operator::UnderlineThickness => Some(&DEFAULT_UNDERLINE_THICKNESS),

1667

            Operator::PaintType => Some(&OPERAND_ZERO),

1668

            Operator::CharstringType => Some(&DEFAULT_CHARSTRING_TYPE),

1669

            Operator::FontMatrix => Some(default_font_matrix().as_ref()),

1670

            Operator::FontBBox => Some(&DEFAULT_BBOX),

1671

            Operator::StrokeWidth => Some(&OPERAND_ZERO),

1672

            Operator::Charset => Some(&OFFSET_ZERO),

1673

            Operator::Encoding => Some(&OFFSET_ZERO),

1674

            Operator::CIDFontVersion => Some(&OPERAND_ZERO),

1675

            Operator::CIDFontRevision => Some(&OPERAND_ZERO),

1676

            Operator::CIDFontType => Some(&OPERAND_ZERO),

1677

            Operator::CIDCount => Some(&DEFAULT_CID_COUNT),

1678

            _ => None,

1679

1680

1681

1682

1683

impl DictDefault for FontDictDefault {

1684

    fn default(_op: Operator) -> Option<&'static [Operand]> {

1685

        None

1686

1687

1688

1689

impl DictDefault for PrivateDictDefault {

1690

    fn default(op: Operator) -> Option<&'static [Operand]> {

1691

        match op {

1692

            Operator::BlueScale => Some(default_blue_scale().as_ref()),

1693

            Operator::BlueShift => Some(&DEFAULT_BLUE_SHIFT),

1694

            Operator::BlueFuzz => Some(&DEFAULT_BLUE_FUZZ),

1695

            Operator::ForceBold => Some(&OPERAND_ZERO),

1696

            Operator::LanguageGroup => Some(&OPERAND_ZERO),

1697

            Operator::ExpansionFactor => Some(default_expansion_factor().as_ref()),

1698

            Operator::InitialRandomSeed => Some(&OPERAND_ZERO),

1699

            Operator::StrokeWidth => Some(&OPERAND_ZERO),

1700

            Operator::DefaultWidthX => Some(&OPERAND_ZERO),

1701

            Operator::NominalWidthX => Some(&OPERAND_ZERO),

1702

            _ => None,

1703

1704

1705

1706

1707

impl<'a, T> Dict<T>

1708

where

1709

    T: DictDefault,

1710

1711

    pub fn new() -> Self {

1712

        Dict {

1713

            dict: Vec::new(),

1714

            default: PhantomData,

1715

1716

1717

1718

    pub fn get_with_default(&self, key: Operator) -> Option<&[Operand]> {

1719

        self.get(key).or_else(|| T::default(key))

1720

1721

1722

    pub fn get(&self, key: Operator) -> Option<&[Operand]> {

1723

        self.dict.iter().find_map(|(op, args)| {

1724

            if *op == key {

1725

                Some(args.as_slice())

1726

            } else {

1727

                None

1728

1729

})

1730

1731

1732

    /// Returns the i32 value of this operator if the operands hold a single Integer.

1733

    pub fn get_i32(&self, key: Operator) -> Option<Result<i32, ParseError>> {

1734

        self.get_with_default(key).map(|operands| match operands {

1735

            [Operand::Integer(number)] => Ok(*number),

1736

            [Operand::Offset(number)] => Ok(*number),

1737

            _ => Err(ParseError::BadValue),

1738

})

1739

1740

1741

    pub fn iter(&self) -> impl Iterator<Item = &(Operator, Vec<Operand>)> {

1742

        self.dict.iter()

1743

1744

1745

    /// Returns the first operator of this DICT or `None` if the DICT is empty.

1746

    pub fn first_operator(&self) -> Option<Operator> {

1747

        self.iter().next().map(|(operator, _)| *operator)

1748

1749

1750

    /// Read a PrivateDict from this Dict returning it and its offset within `scope` on success.

1751

///

1752

    /// A Private DICT is required, but may be specified as having a length of 0 if there are no

1753

    /// non-default values to be stored.

1754

    pub fn read_private_dict<D: ReadBinaryDep<Args<'a> = usize>>(

1755

        &self,

1756

        scope: &ReadScope<'a>,

1757

        max_operands: usize,

1758

    ) -> Result<(D::HostType<'a>, usize), ParseError> {

1759

        let (private_dict_offset, private_dict_length) =

1760

            match self.get_with_default(Operator::Private) {

1761

                Some([Operand::Offset(length), Operand::Offset(offset)]) => {

1762

                    Ok((usize::try_from(*offset)?, usize::try_from(*length)?))

1763

1764

                Some(_) => Err(ParseError::BadValue),

1765

                None => Err(ParseError::MissingValue),

1766

}?;

1767

        scope

1768

            .offset_length(private_dict_offset, private_dict_length)?

1769

            .read_dep::<D>(max_operands)

1770

            .map(|dict| (dict, private_dict_offset))

1771

1772

1773

    pub fn len(&self) -> usize {

1774

        self.dict.len()

1775

1776

1777

    fn inner_mut(&mut self) -> &mut Vec<(Operator, Vec<Operand>)> {

1778

        &mut self.dict

1779

1780

1781

    fn remove(&mut self, operator: Operator) {

1782

        if let Some(index) = self.dict.iter().position(|(op, _)| *op == operator) {

1783

            self.dict.remove(index);

1784

1785

1786

1787

    /// Replace the entry in the DICT for `operator` with `operands`.

1788

///

1789

    /// If `operator` is not found then append it to the DICT.

1790

    fn replace(&mut self, operator: Operator, operands: Vec<Operand>) {

1791

        match self.dict.iter().position(|(op, _)| *op == operator) {

1792

            Some(index) => self.dict[index] = (operator, operands),

1793

            None => self.dict.push((operator, operands)),

1794

1795

1796

1797

    /// Apply variation data to this Dict according to `instance` to produce a new Dict.

1798

///

1799

    /// The new Dict is no longer variable and does not contain any vsindex or blend operators.

1800

    fn instance(

1801

        &self,

1802

        instance: &OwnedTuple,

1803

        vstore: &ItemVariationStore<'_>,

1804

    ) -> Result<Self, VariationError> {

1805

        let mut dict = Vec::new();

1806

        let mut vsindex = 0;

1807

        let mut stack = ArgumentsStack {

1808

            data: &mut [0.0; cff2::MAX_OPERANDS],

1809

            len: 0,

1810

            max_len: cff2::MAX_OPERANDS,

1811

};

1812

1813

        for (op, operands) in self.iter() {

1814

            match op {

1815

                Operator::VSIndex => match operands.as_slice() {

1816

                    [Operand::Integer(variation_index)] => vsindex = *variation_index,

1817

                    _ => return Err(ParseError::BadValue.into()),

1818

},

1819

                Operator::Blend => {

1820

                    // do the blend, generating new operands for the following op to inherit

1821

                    operands

1822

                        .iter()

1823

                        .try_for_each(|operand| stack.push(f32::try_from(operand)?))?;

1824

1825

                    let scalars = cff2::scalars(

1826

                        u16::try_from(vsindex).map_err(ParseError::from)?,

1827

                        vstore,

1828

                        instance,

1829

)?;

1830

1831

                    cff2::blend(&scalars, &mut stack)?;

1832

1833

                _ if !stack.is_empty() => {

1834

                    // The operator needs to operate on any blended operands on the stack in

1835

                    // addition to any that were supplied to it. All operators except `blend` clear

1836

                    // the stack:

1837

//

1838

                    // "In well-formed CFF2 data, the number of operands preceding a DICT key

1839

                    // operator must be exactly the number required for that operator; hence, the

1840

                    // stack will be empty after the operator is processed."

1841

1842

                    // Take all the operands, clearing out the stack at the same time

1843

                    let mut new_operands = stack

1844

                        .pop_all()

1845

                        .iter()

1846

                        .copied()

1847

                        .map(Operand::from)

1848

                        .collect::<Vec<_>>();

1849

                    new_operands.extend(operands.iter().cloned());

1850

                    dict.push((*op, new_operands));

1851

1852

                _ => dict.push((*op, operands.clone())),

1853

1854

1855

1856

        Ok(Dict {

1857

            dict,

1858

            default: PhantomData,

1859

})

1860

1861

1862

1863

impl BlendOperand for f32 {

1864

    fn try_as_i32(self) -> Option<i32> {

1865

        i32::try_num_from(self)

1866

1867

1868

    fn try_as_u16(self) -> Option<u16> {

1869

        if self.fract() == 0.0 {

1870

            u16::try_from(self as i32).ok()

1871

        } else {

1872

            None

1873

1874

1875

1876

    fn try_as_u8(self) -> Option<u8> {

1877

        u8::try_num_from(self)

1878

1879

1880

1881

impl DictDelta {

1882

    pub fn new() -> Self {

1883

        DictDelta { dict: Vec::new() }

1884

1885

1886

    pub fn get(&self, key: Operator) -> Option<&[Operand]> {

1887

        self.dict

1888

            .iter()

1889

            .filter_map(|(op, args)| {

1890

                if *op == key {

1891

                    Some(args.as_slice())

1892

                } else {

1893

                    None

1894

1895

})

1896

            .next()

1897

1898

1899

    /// Push `operator` on this Dict as an Offset Operand

1900

    pub fn push_offset(&mut self, operator: Operator, offset: i32) {

1901

        self.dict

1902

            .push((operator, tiny_vec!([Operand; 1] => Operand::Offset(offset))))

1903

1904

1905

    /// Push `operands` onto this Dict

1906

///

1907

    /// Panics if all `operands` are not `Operand::Offsets`

1908

    pub fn push(&mut self, operator: Operator, operands: TinyVec<[Operand; 1]>) {

1909

        assert!(operands.iter().all(Operand::is_offset));

1910

        self.dict.push((operator, operands))

1911

1912

1913

1914

impl CIDData<'_> {

1915

    pub fn font_dict(&self, index: usize) -> Result<FontDict, ParseError> {

1916

        let data = self

1917

            .font_dict_index

1918

            .read_object(index)

1919

            .ok_or(ParseError::BadIndex)?;

1920

        ReadScope::new(data).read_dep::<FontDict>(MAX_OPERANDS)

1921

1922

1923

1924

impl TryFrom<u16> for Operator {

1925

    type Error = ParseError;

1926

1927

    fn try_from(value: u16) -> Result<Self, Self::Error> {

1928

        if (value & 0xFF00) == (12 << 8) {

1929

            match value as u8 {

1930

                0 => Ok(Operator::Copyright),

1931

                1 => Ok(Operator::IsFixedPitch),

1932

                2 => Ok(Operator::ItalicAngle),

1933

                3 => Ok(Operator::UnderlinePosition),

1934

                4 => Ok(Operator::UnderlineThickness),

1935

                5 => Ok(Operator::PaintType),

1936

                6 => Ok(Operator::CharstringType),

1937

                7 => Ok(Operator::FontMatrix),

1938

                8 => Ok(Operator::StrokeWidth),

1939

                9 => Ok(Operator::BlueScale),

1940

                10 => Ok(Operator::BlueShift),

1941

                11 => Ok(Operator::BlueFuzz),

1942

                12 => Ok(Operator::StemSnapH),

1943

                13 => Ok(Operator::StemSnapV),

1944

                14 => Ok(Operator::ForceBold),

1945

                17 => Ok(Operator::LanguageGroup),

1946

                18 => Ok(Operator::ExpansionFactor),

1947

                19 => Ok(Operator::InitialRandomSeed),

1948

                20 => Ok(Operator::SyntheticBase),

1949

                21 => Ok(Operator::PostScript),

1950

                22 => Ok(Operator::BaseFontName),

1951

                23 => Ok(Operator::BaseFontBlend),

1952

                30 => Ok(Operator::ROS),

1953

                31 => Ok(Operator::CIDFontVersion),

1954

                32 => Ok(Operator::CIDFontRevision),

1955

                33 => Ok(Operator::CIDFontType),

1956

                34 => Ok(Operator::CIDCount),

1957

                35 => Ok(Operator::UIDBase),

1958

                36 => Ok(Operator::FDArray),

1959

                37 => Ok(Operator::FDSelect),

1960

                38 => Ok(Operator::FontName),

1961

                _ => Err(ParseError::BadValue),

1962

1963

        } else {

1964

            match value {

1965

                0 => Ok(Operator::Version),

1966

                1 => Ok(Operator::Notice),

1967

                2 => Ok(Operator::FullName),

1968

                3 => Ok(Operator::FamilyName),

1969

                4 => Ok(Operator::Weight),

1970

                5 => Ok(Operator::FontBBox),

1971

                6 => Ok(Operator::BlueValues),

1972

                7 => Ok(Operator::OtherBlues),

1973

                8 => Ok(Operator::FamilyBlues),

1974

                9 => Ok(Operator::FamilyOtherBlues),

1975

                10 => Ok(Operator::StdHW),

1976

                11 => Ok(Operator::StdVW),

1977

                13 => Ok(Operator::UniqueID),

1978

                14 => Ok(Operator::XUID),

1979

                15 => Ok(Operator::Charset),

1980

                16 => Ok(Operator::Encoding),

1981

                17 => Ok(Operator::CharStrings),

1982

                18 => Ok(Operator::Private),

1983

                19 => Ok(Operator::Subrs),

1984

                20 => Ok(Operator::DefaultWidthX),

1985

                21 => Ok(Operator::NominalWidthX),

1986

                // CFF2

1987

                22 => Ok(Operator::VSIndex),

1988

                23 => Ok(Operator::Blend),

1989

                24 => Ok(Operator::VStore),

1990

                _ => Err(ParseError::BadValue),

1991

1992

1993

1994

1995

1996

impl Operand {

1997

    pub fn is_offset(&self) -> bool {

1998

        matches!(self, Operand::Offset(_))

1999

2000

2001

    fn bcd_encode(buf: &mut TinyVec<[u8; 32]>, val: f32) -> Operand {

2002

        if val == 0.0 {

2003

            Operand::Integer(0)

2004

        } else if val.fract() == 0.0 {

2005

            Operand::Integer(val as i32)

2006

        } else {

2007

            // encode Real

2008

            // https://learn.microsoft.com/en-us/typography/opentype/otspec191alpha/cff2#binary-coded-decimal

2009

            buf.clear();

2010

            // NOTE(unwrap): write into string won't return an error

2011

            write!(buf, "{:E}", val).unwrap();

2012

            // The formatter will always include an exponent. Drop it if it's "E0"

2013

            if buf.ends_with(b"E0") {

2014

                buf.truncate(buf.len() - 2);

2015

2016

2017

            let mut chars = buf.iter().peekable();

2018

            let mut bcd = tiny_vec!([u8; 7]);

2019

            let mut pair = array_vec!([u8; 2]);

2020

2021

            while let Some(c) = chars.next() {

2022

                let nibble = match c {

2023

                    b'0'..=b'9' => c - b'0',

2024

                    b'.' => 0xA,

2025

                    b'E' if chars.peek() == Some(&&b'-') => {

2026

                        let _ = chars.next(); // discard '-'

2027

0xC

2028

2029

                    b'E' => 0xB,

2030

                    b'-' => 0xE,

2031

                    _ => unreachable!(),

2032

};

2033

                pair.push(nibble);

2034

                if let [high, low] = pair.as_slice() {

2035

                    bcd.push((high << 4) | low);

2036

                    pair.clear();

2037

2038

2039

2040

            // Add the end of number sentinel

2041

            match pair.as_slice() {

2042

                // "If the terminating 0xf nibble is the first nibble of a byte, then an additional

2043

                // 0xf nibble must be appended (hence, the byte is 0xff) so that the encoded

2044

                // representation is always a whole number of bytes."

2045

                [] => bcd.push(0xFF),

2046

                [high] => bcd.push((high << 4) | 0xF),

2047

                _ => unreachable!(),

2048

2049

            Operand::Real(Real(bcd))

2050

2051

2052

2053

2054

impl TryFrom<&Operand> for f32 {

2055

    type Error = ParseError;

2056

2057

    fn try_from(operand: &Operand) -> Result<f32, Self::Error> {

2058

        const MAX: i32 = 1 << f32::MANTISSA_DIGITS;

2059

        const MIN: i32 = -MAX;

2060

2061

        match operand {

2062

            Operand::Integer(int) | Operand::Offset(int) => (MIN..=MAX)

2063

                .contains(int)

2064

                .then_some(*int as f32)

2065

                .ok_or(ParseError::LimitExceeded),

2066

            Operand::Real(r) => f64::try_from(r).and_then(|val| {

2067

                (f32::MIN as f64..=f32::MAX as f64)

2068

                    .contains(&val)

2069

                    .then_some(val as f32)

2070

                    .ok_or(ParseError::LimitExceeded)

2071

}),

2072

2073

2074

2075

2076

impl From<f32> for Operand {

2077

    fn from(val: f32) -> Self {

2078

        let mut buf = tiny_vec!([u8; 32]);

2079

        Operand::bcd_encode(&mut buf, val)

2080

2081

2082

2083

// This exists so that Operand can be used in a TinyVec

2084

impl Default for Operand {

2085

    fn default() -> Self {

2086

        Operand::Offset(0)

2087

2088

2089

2090

impl Font<'_> {

2091

    pub fn is_cid_keyed(&self) -> bool {

2092

        match self.data {

2093

            CFFVariant::CID(_) => true,

2094

            CFFVariant::Type1(_) => false,

2095

2096

2097

2098

    // seac = standard encoding accented character, makes an accented character from two other

2099

    // characters.

2100

    pub(crate) fn seac_code_to_glyph_id(&self, code: u8) -> Option<GlyphId> {

2101

        let sid = STANDARD_ENCODING[usize::from(code)];

2102

2103

        match self.charset {

2104

            Charset::ISOAdobe => {

2105

                // ISO Adobe charset only defines string ids up to 228 (zcaron)

2106

                if code <= 228 {

2107

                    Some(u16::from(sid))

2108

                } else {

2109

                    None

2110

2111

2112

            Charset::Expert | Charset::ExpertSubset => None,

2113

            Charset::Custom(_) => self.charset.sid_to_gid(u16::from(sid)),

2114

2115

2116

2117

2118

fn lookup_offset_index(off_size: u8, offset_array: &[u8], index: usize) -> usize {

2119

    let buf = &offset_array[index * usize::from(off_size)..];

2120

    match off_size {

2121

        1 => buf[0] as usize,

2122

        2 => u16::from_be_bytes([buf[0], buf[1]]) as usize,

2123

        3 => u32::from_be_bytes([0, buf[0], buf[1], buf[2]]) as usize,

2124

        4 => u32::from_be_bytes([buf[0], buf[1], buf[2], buf[3]]) as usize,

2125

        _ => panic!("unexpected off_size"),

2126

2127

2128

2129

fn read_range_array<'a, F, N>(

2130

    ctxt: &mut ReadCtxt<'a>,

2131

    n_glyphs: usize,

2132

) -> Result<ReadArray<'a, Range<F, N>>, ParseError>

2133

where

2134

    Range<F, N>: ReadFrom,

2135

    usize: From<N>,

2136

    N: Copy,

2137

2138

    let mut peek = ctxt.scope().ctxt();

2139

    let mut range_count = 0;

2140

    let mut glyphs_covered = 0;

2141

    while glyphs_covered < n_glyphs {

2142

        let range = peek.read::<Range<F, N>>()?;

2143

        range_count += 1;

2144

        glyphs_covered += range.len();

2145

2146

2147

    ctxt.read_array::<Range<F, N>>(range_count)

2148

2149

2150

fn write_cff_variant<C: WriteContext>(

2151

    ctxt: &mut C,

2152

    variant: &CFFVariant<'_>,

2153

    top_dict_delta: &mut DictDelta,

2154

) -> Result<(), WriteError> {

2155

    match variant {

2156

        CFFVariant::CID(cid_data) => {

2157

            let offsets = CIDData::write(ctxt, cid_data)?;

2158

            top_dict_delta.push_offset(Operator::FDArray, i32::try_from(offsets.font_dict_index)?);

2159

            top_dict_delta.push_offset(Operator::FDSelect, i32::try_from(offsets.fd_select)?);

2160

2161

        CFFVariant::Type1(type1_data) => {

2162

            let offsets = Type1Data::write(ctxt, type1_data)?;

2163

            if let Some(custom_encoding_offset) = offsets.custom_encoding {

2164

                top_dict_delta

2165

                    .push_offset(Operator::Encoding, i32::try_from(custom_encoding_offset)?);

2166

2167

            top_dict_delta.push(

2168

                Operator::Private,

2169

                tiny_vec!([Operand; 1] =>

2170

                    Operand::Offset(i32::try_from(offsets.private_dict_len)?),

2171

                    Operand::Offset(i32::try_from(offsets.private_dict)?)),

2172

);

2173

2174

2175

2176

    Ok(())

2177

2178

2179

// NOTE: Ideally the following read_* functions would ReadBinary or ReadBinaryDep impls.

2180

// However we need to be able to indicate that the borrowed TopDict has a different lifetime

2181

// to the other aspects, which is not currently possible.

2182

// This post sums up the issue fairly well:

2183

// https://lukaskalbertodt.github.io/2018/08/03/solving-the-generalized-streaming-iterator-problem-without-gats.html

2184

// Rust tracking issue: https://github.com/rust-lang/rust/issues/44265

2185

2186

fn read_cid_data<'a>(

2187

    scope: &ReadScope<'a>,

2188

    top_dict: &TopDict,

2189

    n_glyphs: usize,

2190

) -> Result<CIDData<'a>, ParseError> {

2191

    // The Top DICT begins with ROS operator

2192

    // which specifies the Registry-Ordering-Supplement for the font.

2193

    // This will indicate to a CFF parser that special CID processing

2194

    // should be applied to this font. Specifically:

2195

//

2196

    // • The FDArray operator is expected to be present, with a single

2197

    //   argument specifying an offset to the Font DICT INDEX. Each

2198

    //   Font DICT in this array specifies information unique to a

2199

    //   particular group of glyphs in the font.

2200

    let offset = top_dict

2201

        .get_i32(Operator::FDArray)

2202

        .ok_or(ParseError::MissingValue)??;

2203

    let font_dict_index = scope.offset(usize::try_from(offset)?).read::<IndexU16>()?;

2204

2205

    let offset = top_dict

2206

        .get_i32(Operator::FDSelect)

2207

        .ok_or(ParseError::MissingValue)??;

2208

    let fd_select = scope

2209

        .offset(usize::try_from(offset)?)

2210

        .read_dep::<FDSelect<'a>>(n_glyphs)?;

2211

2212

    let mut private_dicts = Vec::with_capacity(font_dict_index.count);

2213

    let mut local_subr_indices = Vec::with_capacity(font_dict_index.count);

2214

    for object in font_dict_index.iter() {

2215

        let font_dict = ReadScope::new(object).read_dep::<FontDict>(MAX_OPERANDS)?;

2216

        let (private_dict, private_dict_offset) =

2217

            font_dict.read_private_dict::<PrivateDict>(scope, MAX_OPERANDS)?;

2218

        let local_subr_index =

2219

            read_local_subr_index::<_, IndexU16>(scope, &private_dict, private_dict_offset)?

2220

                .map(MaybeOwnedIndex::Borrowed);

2221

2222

        private_dicts.push(private_dict);

2223

        local_subr_indices.push(local_subr_index);

2224

2225

2226

    Ok(CIDData {

2227

        font_dict_index: MaybeOwnedIndex::Borrowed(font_dict_index),

2228

        private_dicts,

2229

        local_subr_indices,

2230

        fd_select,

2231

})

2232

2233

2234

impl WriteBinary<&Self> for CIDData<'_> {

2235

    type Output = CIDDataOffsets;

2236

2237

    fn write<C: WriteContext>(ctxt: &mut C, data: &Self) -> Result<Self::Output, WriteError> {

2238

        // Private DICTs and Local subroutines

2239

        let mut private_dict_offset_lengths = Vec::with_capacity(data.private_dicts.len());

2240

        for (private_dict, local_subr_index) in data

2241

            .private_dicts

2242

            .iter()

2243

            .zip(data.local_subr_indices.iter())

2244

2245

            let offset = ctxt.bytes_written();

2246

            let written_length =

2247

                write_private_dict_and_local_subr_index(ctxt, private_dict, local_subr_index)?;

2248

            private_dict_offset_lengths.push((offset, written_length));

2249

2250

2251

        // Font DICT INDEX

2252

        let mut font_dict_data = WriteBuffer::new();

2253

        let mut font_dict_offsets = Vec::with_capacity(data.font_dict_index.len());

2254

        for (object, (offset, length)) in data

2255

            .font_dict_index

2256

            .iter()

2257

            .zip(private_dict_offset_lengths.into_iter())

2258

2259

            let font_dict = ReadScope::new(object)

2260

                .read_dep::<FontDict>(MAX_OPERANDS)

2261

                .map_err(|_err| WriteError::BadValue)?;

2262

            let mut font_dict_delta = DictDelta::new();

2263

            font_dict_delta.push(

2264

                Operator::Private,

2265

                tiny_vec!([Operand; 1] =>

2266

                    Operand::Offset(i32::try_from(length)?),

2267

                    Operand::Offset(i32::try_from(offset)?)),

2268

);

2269

2270

            font_dict_offsets.push(font_dict_data.bytes_written() + 1); // +1 INDEXes start at offset 1

2271

            FontDict::write_dep(&mut font_dict_data, &font_dict, font_dict_delta)?;

2272

2273

        let last_font_dict_offset = font_dict_data.bytes_written() + 1;

2274

        font_dict_offsets.push(last_font_dict_offset);

2275

2276

        let (off_size, offset_array) = serialise_offset_array(font_dict_offsets)?;

2277

        let font_dict_index = Index {

2278

            count: data.font_dict_index.len(),

2279

            off_size,

2280

            offset_array: &offset_array,

2281

            data_array: font_dict_data.bytes(),

2282

};

2283

        let font_dict_index_offset = ctxt.bytes_written();

2284

        IndexU16::write(ctxt, &font_dict_index)?;

2285

2286

        let fd_select_offset = ctxt.bytes_written();

2287

        FDSelect::write(ctxt, &data.fd_select)?;

2288

2289

        Ok(CIDDataOffsets {

2290

            font_dict_index: font_dict_index_offset,

2291

            fd_select: fd_select_offset,

2292

})

2293

2294

2295

2296

impl WriteBinary<&Self> for Type1Data<'_> {

2297

    type Output = Type1DataOffsets;

2298

2299

    fn write<C: WriteContext>(ctxt: &mut C, data: &Self) -> Result<Self::Output, WriteError> {

2300

        let mut offsets = Type1DataOffsets {

2301

            custom_encoding: None,

2302

            private_dict: ctxt.bytes_written(),

2303

            private_dict_len: 0,

2304

};

2305

2306

        offsets.private_dict_len = write_private_dict_and_local_subr_index(

2307

            ctxt,

2308

            &data.private_dict,

2309

            &data.local_subr_index,

2310

)?;

2311

2312

        if let Type1Data {

2313

            encoding: Encoding::Custom(ref custom_encoding),

2314

..

2315

        } = data

2316

2317

            offsets.custom_encoding = Some(ctxt.bytes_written());

2318

            CustomEncoding::write(ctxt, custom_encoding)?;

2319

2320

2321

        Ok(offsets)

2322

2323

2324

2325

/// Write the Private DICT and local subrs if present, returns the length of the Private DICT

2326

fn write_private_dict_and_local_subr_index<C: WriteContext>(

2327

    ctxt: &mut C,

2328

    private_dict: &PrivateDict,

2329

    local_subr_index: &Option<MaybeOwnedIndex<'_>>,

2330

) -> Result<usize, WriteError> {

2331

    // Determine how big the Private DICT will be

2332

    let private_dict_length =

2333

        PrivateDict::write_dep(&mut WriteCounter::new(), private_dict, DictDelta::new())?;

2334

2335

    // Write Private DICT with updated offset to Local subroutines if present

2336

    let mut private_dict_delta = DictDelta::new();

2337

    if local_subr_index.is_some() {

2338

        // This offset is relative to the start of the Private DICT

2339

        private_dict_delta.push_offset(Operator::Subrs, i32::try_from(private_dict_length)?);

2340

2341

    let written_length = PrivateDict::write_dep(ctxt, private_dict, private_dict_delta)?;

2342

    assert_eq!(written_length, private_dict_length);

2343

2344

    if let Some(local_subr_index) = local_subr_index {

2345

        MaybeOwnedIndex::write16(ctxt, local_subr_index)?;

2346

2347

2348

    Ok(written_length)

2349

2350

2351

fn read_encoding<'a>(

2352

    scope: &ReadScope<'a>,

2353

    top_dict: &TopDict,

2354

) -> Result<Encoding<'a>, ParseError> {

2355

    let offset = top_dict

2356

        .get_i32(Operator::Encoding)

2357

        .ok_or(ParseError::MissingValue)??;

2358

    let encoding = match offset {

2359

        0 => Encoding::Standard,

2360

        1 => Encoding::Expert,

2361

        _ => Encoding::Custom(

2362

            scope

2363

                .offset(usize::try_from(offset)?)

2364

                .read::<CustomEncoding<'_>>()?,

2365

),

2366

};

2367

2368

    Ok(encoding)

2369

2370

2371

fn read_charset<'a>(

2372

    scope: &ReadScope<'a>,

2373

    top_dict: &TopDict,

2374

    char_strings_count: usize,

2375

) -> Result<Charset<'a>, ParseError> {

2376

    let offset = top_dict

2377

        .get_i32(Operator::Charset)

2378

        .ok_or(ParseError::MissingValue)??;

2379

    let charset = match offset {

2380

        0 => Charset::ISOAdobe,

2381

        1 => Charset::Expert,

2382

        2 => Charset::ExpertSubset,

2383

        _ => Charset::Custom(

2384

            scope

2385

                .offset(usize::try_from(offset)?)

2386

                .read_dep::<CustomCharset<'_>>(char_strings_count)?,

2387

),

2388

};

2389

2390

    Ok(charset)

2391

2392

2393

fn read_local_subr_index<'a, T, Idx>(

2394

    scope: &ReadScope<'a>,

2395

    private_dict: &Dict<T>,

2396

    private_dict_offset: usize,

2397

) -> Result<Option<Index<'a>>, ParseError>

2398

where

2399

    T: DictDefault,

2400

    Idx: ReadBinary<HostType<'a> = Index<'a>>,

2401

2402

    // Local subrs are stored in an INDEX structure which is located via the offset operand

2403

    // of the Subrs operator in the Private DICT. A font without local subrs has no Subrs

2404

    // operator in the Private DICT. The local subrs offset is relative to the beginning of

2405

    // the Private DICT data.

2406

    private_dict

2407

        .get_i32(Operator::Subrs)

2408

        .transpose()?

2409

        .map(|offset| {

2410

            let offset = usize::try_from(offset)?;

2411

            scope.offset(private_dict_offset + offset).read::<Idx>()

2412

})

2413

        .transpose()

2414

2415

2416

/// Serialise the offsets using an optimal `off_size`, returning that and the serialised data.

2417

fn serialise_offset_array(offsets: Vec<usize>) -> Result<(u8, Vec<u8>), WriteError> {

2418

    if offsets.is_empty() {

2419

        return Ok((1, Vec::new()));

2420

2421

2422

    // NOTE(unwrap): Safe due to is_empty check

2423

    let off_size = offset_size(*offsets.last().unwrap()).ok_or(WriteError::BadValue)?;

2424

    let mut offset_array = WriteBuffer::new();

2425

    match off_size {

2426

        1 => offset_array.write_iter::<U8, _>(offsets.into_iter().map(|offset| offset as u8))?,

2427

2428

        2 => {

2429

            offset_array.write_iter::<U16Be, _>(offsets.into_iter().map(|offset| offset as u16))?

2430

2431

2432

        3 => {

2433

            offset_array.write_iter::<U24Be, _>(offsets.into_iter().map(|offset| offset as u32))?

2434

2435

2436

        4 => {

2437

            offset_array.write_iter::<U32Be, _>(offsets.into_iter().map(|offset| offset as u32))?

2438

2439

2440

        _ => unreachable!(), // offset_size only returns 1..=4

2441

2442

2443

    Ok((off_size, offset_array.into_inner()))

2444

2445

2446

impl CFFFont<'_, '_> {

2447

    pub fn is_cff(&self) -> bool {

2448

        matches!(self, CFFFont::CFF(_))

2449

2450

2451

    pub fn is_cff2(&self) -> bool {

2452

        matches!(self, CFFFont::CFF2(_))

2453

2454

2455

2456

const STANDARD_STRINGS: [&str; 391] = [

2457

    ".notdef",

2458

    "space",

2459

    "exclam",

2460

    "quotedbl",

2461

    "numbersign",

2462

    "dollar",

2463

    "percent",

2464

    "ampersand",

2465

    "quoteright",

2466

    "parenleft",

2467

    "parenright",

2468

    "asterisk",

2469

    "plus",

2470

    "comma",

2471

    "hyphen",

2472

    "period",

2473

    "slash",

2474

    "zero",

2475

    "one",

2476

    "two",

2477

    "three",

2478

    "four",

2479

    "five",

2480

    "six",

2481

    "seven",

2482

    "eight",

2483

    "nine",

2484

    "colon",

2485

    "semicolon",

2486

    "less",

2487

    "equal",

2488

    "greater",

2489

    "question",

2490

    "at",

2491

    "A",

2492

    "B",

2493

    "C",

2494

    "D",

2495

    "E",

2496

    "F",

2497

    "G",

2498

    "H",

2499

    "I",

2500

    "J",

2501

    "K",

2502

    "L",

2503

    "M",

2504

    "N",

2505

    "O",

2506

    "P",

2507

    "Q",

2508

    "R",

2509

    "S",

2510

    "T",

2511

    "U",

2512

    "V",

2513

    "W",

2514

    "X",

2515

    "Y",

2516

    "Z",

2517

    "bracketleft",

2518

    "backslash",

2519

    "bracketright",

2520

    "asciicircum",

2521

    "underscore",

2522

    "quoteleft",

2523

    "a",

2524

    "b",

2525

    "c",

2526

    "d",

2527

    "e",

2528

    "f",

2529

    "g",

2530

    "h",

2531

    "i",

2532

    "j",

2533

    "k",

2534

    "l",

2535

    "m",

2536

    "n",

2537

    "o",

2538

    "p",

2539

    "q",

2540

    "r",

2541

    "s",

2542

    "t",

2543

    "u",

2544

    "v",

2545

    "w",

2546

    "x",

2547

    "y",

2548

    "z",

2549

    "braceleft",

2550

    "bar",

2551

    "braceright",

2552

    "asciitilde",

2553

    "exclamdown",

2554

    "cent",

2555

    "sterling",

2556

    "fraction",

2557

    "yen",

2558

    "florin",

2559

    "section",

2560

    "currency",

2561

    "quotesingle",

2562

    "quotedblleft",

2563

    "guillemotleft",

2564

    "guilsinglleft",

2565

    "guilsinglright",

2566

    "fi",

2567

    "fl",

2568

    "endash",

2569

    "dagger",

2570

    "daggerdbl",

2571

    "periodcentered",

2572

    "paragraph",

2573

    "bullet",

2574

    "quotesinglbase",

2575

    "quotedblbase",

2576

    "quotedblright",

2577

    "guillemotright",

2578

    "ellipsis",

2579

    "perthousand",

2580

    "questiondown",

2581

    "grave",

2582

    "acute",

2583

    "circumflex",

2584

    "tilde",

2585

    "macron",

2586

    "breve",

2587

    "dotaccent",

2588

    "dieresis",

2589

    "ring",

2590

    "cedilla",

2591

    "hungarumlaut",

2592

    "ogonek",

2593

    "caron",

2594

    "emdash",

2595

    "AE",

2596

    "ordfeminine",

2597

    "Lslash",

2598

    "Oslash",

2599

    "OE",

2600

    "ordmasculine",

2601

    "ae",

2602

    "dotlessi",

2603

    "lslash",

2604

    "oslash",

2605

    "oe",

2606

    "germandbls",

2607

    "onesuperior",

2608

    "logicalnot",

2609

    "mu",

2610

    "trademark",

2611

    "Eth",

2612

    "onehalf",

2613

    "plusminus",

2614

    "Thorn",

2615

    "onequarter",

2616

    "divide",

2617

    "brokenbar",

2618

    "degree",

2619

    "thorn",

2620

    "threequarters",

2621

    "twosuperior",

2622

    "registered",

2623

    "minus",

2624

    "eth",

2625

    "multiply",

2626

    "threesuperior",

2627

    "copyright",

2628

    "Aacute",

2629

    "Acircumflex",

2630

    "Adieresis",

2631

    "Agrave",

2632

    "Aring",

2633

    "Atilde",

2634

    "Ccedilla",

2635

    "Eacute",

2636

    "Ecircumflex",

2637

    "Edieresis",

2638

    "Egrave",

2639

    "Iacute",

2640

    "Icircumflex",

2641

    "Idieresis",

2642

    "Igrave",

2643

    "Ntilde",

2644

    "Oacute",

2645

    "Ocircumflex",

2646

    "Odieresis",

2647

    "Ograve",

2648

    "Otilde",

2649

    "Scaron",

2650

    "Uacute",

2651

    "Ucircumflex",

2652

    "Udieresis",

2653

    "Ugrave",

2654

    "Yacute",

2655

    "Ydieresis",

2656

    "Zcaron",

2657

    "aacute",

2658

    "acircumflex",

2659

    "adieresis",

2660

    "agrave",

2661

    "aring",

2662

    "atilde",

2663

    "ccedilla",

2664

    "eacute",

2665

    "ecircumflex",

2666

    "edieresis",

2667

    "egrave",

2668

    "iacute",

2669

    "icircumflex",

2670

    "idieresis",

2671

    "igrave",

2672

    "ntilde",

2673

    "oacute",

2674

    "ocircumflex",

2675

    "odieresis",

2676

    "ograve",

2677

    "otilde",

2678

    "scaron",

2679

    "uacute",

2680

    "ucircumflex",

2681

    "udieresis",

2682

    "ugrave",

2683

    "yacute",

2684

    "ydieresis",

2685

    "zcaron",

2686

    "exclamsmall",

2687

    "Hungarumlautsmall",

2688

    "dollaroldstyle",

2689

    "dollarsuperior",

2690

    "ampersandsmall",

2691

    "Acutesmall",

2692

    "parenleftsuperior",

2693

    "parenrightsuperior",

2694

    "twodotenleader",

2695

    "onedotenleader",

2696

    "zerooldstyle",

2697

    "oneoldstyle",

2698

    "twooldstyle",

2699

    "threeoldstyle",

2700

    "fouroldstyle",

2701

    "fiveoldstyle",

2702

    "sixoldstyle",

2703

    "sevenoldstyle",

2704

    "eightoldstyle",

2705

    "nineoldstyle",

2706

    "commasuperior",

2707

    "threequartersemdash",

2708

    "periodsuperior",

2709

    "questionsmall",

2710

    "asuperior",

2711

    "bsuperior",

2712

    "centsuperior",

2713

    "dsuperior",

2714

    "esuperior",

2715

    "isuperior",

2716

    "lsuperior",

2717

    "msuperior",

2718

    "nsuperior",

2719

    "osuperior",

2720

    "rsuperior",

2721

    "ssuperior",

2722

    "tsuperior",

2723

    "ff",

2724

    "ffi",

2725

    "ffl",

2726

    "parenleftinferior",

2727

    "parenrightinferior",

2728

    "Circumflexsmall",

2729

    "hyphensuperior",

2730

    "Gravesmall",

2731

    "Asmall",

2732

    "Bsmall",

2733

    "Csmall",

2734

    "Dsmall",

2735

    "Esmall",

2736

    "Fsmall",

2737

    "Gsmall",

2738

    "Hsmall",

2739

    "Ismall",

2740

    "Jsmall",

2741

    "Ksmall",

2742

    "Lsmall",

2743

    "Msmall",

2744

    "Nsmall",

2745

    "Osmall",

2746

    "Psmall",

2747

    "Qsmall",

2748

    "Rsmall",

2749

    "Ssmall",

2750

    "Tsmall",

2751

    "Usmall",

2752

    "Vsmall",

2753

    "Wsmall",

2754

    "Xsmall",

2755

    "Ysmall",

2756

    "Zsmall",

2757

    "colonmonetary",

2758

    "onefitted",

2759

    "rupiah",

2760

    "Tildesmall",

2761

    "exclamdownsmall",

2762

    "centoldstyle",

2763

    "Lslashsmall",

2764

    "Scaronsmall",

2765

    "Zcaronsmall",

2766

    "Dieresissmall",

2767

    "Brevesmall",

2768

    "Caronsmall",

2769

    "Dotaccentsmall",

2770

    "Macronsmall",

2771

    "figuredash",

2772

    "hypheninferior",

2773

    "Ogoneksmall",

2774

    "Ringsmall",

2775

    "Cedillasmall",

2776

    "questiondownsmall",

2777

    "oneeighth",

2778

    "threeeighths",

2779

    "fiveeighths",

2780

    "seveneighths",

2781

    "onethird",

2782

    "twothirds",

2783

    "zerosuperior",

2784

    "foursuperior",

2785

    "fivesuperior",

2786

    "sixsuperior",

2787

    "sevensuperior",

2788

    "eightsuperior",

2789

    "ninesuperior",

2790

    "zeroinferior",

2791

    "oneinferior",

2792

    "twoinferior",

2793

    "threeinferior",

2794

    "fourinferior",

2795

    "fiveinferior",

2796

    "sixinferior",

2797

    "seveninferior",

2798

    "eightinferior",

2799

    "nineinferior",

2800

    "centinferior",

2801

    "dollarinferior",

2802

    "periodinferior",

2803

    "commainferior",

2804

    "Agravesmall",

2805

    "Aacutesmall",

2806

    "Acircumflexsmall",

2807

    "Atildesmall",

2808

    "Adieresissmall",

2809

    "Aringsmall",

2810

    "AEsmall",

2811

    "Ccedillasmall",

2812

    "Egravesmall",

2813

    "Eacutesmall",

2814

    "Ecircumflexsmall",

2815

    "Edieresissmall",

2816

    "Igravesmall",

2817

    "Iacutesmall",

2818

    "Icircumflexsmall",

2819

    "Idieresissmall",

2820

    "Ethsmall",

2821

    "Ntildesmall",

2822

    "Ogravesmall",

2823

    "Oacutesmall",

2824

    "Ocircumflexsmall",

2825

    "Otildesmall",

2826

    "Odieresissmall",

2827

    "OEsmall",

2828

    "Oslashsmall",

2829

    "Ugravesmall",

2830

    "Uacutesmall",

2831

    "Ucircumflexsmall",

2832

    "Udieresissmall",

2833

    "Yacutesmall",

2834

    "Thornsmall",

2835

    "Ydieresissmall",

2836

    "001.000",

2837

    "001.001",

2838

    "001.002",

2839

    "001.003",

2840

    "Black",

2841

    "Bold",

2842

    "Book",

2843

    "Light",

2844

    "Medium",

2845

    "Regular",

2846

    "Roman",

2847

    "Semibold",

2848

];

2849

2850

#[allow(dead_code)]

2851

const STANDARD_ENCODING: [u8; 256] = [

2852

    0,   // .notdef

2853

    0,   // .notdef

2854

    0,   // .notdef

2855

    0,   // .notdef

2856

    0,   // .notdef

2857

    0,   // .notdef

2858

    0,   // .notdef

2859

    0,   // .notdef

2860

    0,   // .notdef

2861

    0,   // .notdef

2862

    0,   // .notdef

2863

    0,   // .notdef

2864

    0,   // .notdef

2865

    0,   // .notdef

2866

    0,   // .notdef

2867

    0,   // .notdef

2868

    0,   // .notdef

2869

    0,   // .notdef

2870

    0,   // .notdef

2871

    0,   // .notdef

2872

    0,   // .notdef

2873

    0,   // .notdef

2874

    0,   // .notdef

2875

    0,   // .notdef

2876

    0,   // .notdef

2877

    0,   // .notdef

2878

    0,   // .notdef

2879

    0,   // .notdef

2880

    0,   // .notdef

2881

    0,   // .notdef

2882

    0,   // .notdef

2883

    0,   // .notdef

2884

    1,   // space

2885

    2,   // exclam

2886

    3,   // quotedbl

2887

    4,   // numbersign

2888

    5,   // dollar

2889

    6,   // percent

2890

    7,   // ampersand

2891

    8,   // quoteright

2892

    9,   // parenleft

2893

    10,  // parenright

2894

    11,  // asterisk

2895

    12,  // plus

2896

    13,  // comma

2897

    14,  // hyphen

2898

    15,  // period

2899

    16,  // slash

2900

    17,  // zero

2901

    18,  // one

2902

    19,  // two

2903

    20,  // three

2904

    21,  // four

2905

    22,  // five

2906

    23,  // six

2907

    24,  // seven

2908

    25,  // eight

2909

    26,  // nine

2910

    27,  // colon

2911

    28,  // semicolon

2912

    29,  // less

2913

    30,  // equal

2914

    31,  // greater

2915

    32,  // question

2916

    33,  // at

2917

    34,  // A

2918

    35,  // B

2919

    36,  // C

2920

    37,  // D

2921

    38,  // E

2922

    39,  // F

2923

    40,  // G

2924

    41,  // H

2925

    42,  // I

2926

    43,  // J

2927

    44,  // K

2928

    45,  // L

2929

    46,  // M

2930

    47,  // N

2931

    48,  // O

2932

    49,  // P

2933

    50,  // Q

2934

    51,  // R

2935

    52,  // S

2936

    53,  // T

2937

    54,  // U

2938

    55,  // V

2939

    56,  // W

2940

    57,  // X

2941

    58,  // Y

2942

    59,  // Z

2943

    60,  // bracketleft

2944

    61,  // backslash

2945

    62,  // bracketright

2946

    63,  // asciicircum

2947

    64,  // underscore

2948

    65,  // quoteleft

2949

    66,  // a

2950

    67,  // b

2951

    68,  // c

2952

    69,  // d

2953

    70,  // e

2954

    71,  // f

2955

    72,  // g

2956

    73,  // h

2957

    74,  // i

2958

    75,  // j

2959

    76,  // k

2960

    77,  // l

2961

    78,  // m

2962

    79,  // n

2963

    80,  // o

2964

    81,  // p

2965

    82,  // q

2966

    83,  // r

2967

    84,  // s

2968

    85,  // t

2969

    86,  // u

2970

    87,  // v

2971

    88,  // w

2972

    89,  // x

2973

    90,  // y

2974

    91,  // z

2975

    92,  // braceleft

2976

    93,  // bar

2977

    94,  // braceright

2978

    95,  // asciitilde

2979

    0,   // .notdef

2980

    0,   // .notdef

2981

    0,   // .notdef

2982

    0,   // .notdef

2983

    0,   // .notdef

2984

    0,   // .notdef

2985

    0,   // .notdef

2986

    0,   // .notdef

2987

    0,   // .notdef

2988

    0,   // .notdef

2989

    0,   // .notdef

2990

    0,   // .notdef

2991

    0,   // .notdef

2992

    0,   // .notdef

2993

    0,   // .notdef

2994

    0,   // .notdef

2995

    0,   // .notdef

2996

    0,   // .notdef

2997

    0,   // .notdef

2998

    0,   // .notdef

2999

    0,   // .notdef

3000

    0,   // .notdef

3001

    0,   // .notdef

3002

    0,   // .notdef

3003

    0,   // .notdef

3004

    0,   // .notdef

3005

    0,   // .notdef

3006

    0,   // .notdef

3007

    0,   // .notdef

3008

    0,   // .notdef

3009

    0,   // .notdef

3010

    0,   // .notdef

3011

    0,   // .notdef

3012

    0,   // .notdef

3013

    96,  // exclamdown

3014

    97,  // cent

3015

    98,  // sterling

3016

    99,  // fraction

3017

    100, // yen

3018

    101, // florin

3019

    102, // section

3020

    103, // currency

3021

    104, // quotesingle

3022

    105, // quotedblleft

3023

    106, // guillemotleft

3024

    107, // guilsinglleft

3025

    108, // guilsinglright

3026

    109, // fi

3027

    110, // fl

3028

    0,   // .notdef

3029

    111, // endash

3030

    112, // dagger

3031

    113, // daggerdbl

3032

    114, // periodcentered

3033

    0,   // .notdef

3034

    115, // paragraph

3035

    116, // bullet

3036

    117, // quotesinglbase

3037

    118, // quotedblbase

3038

    119, // quotedblright

3039

    120, // guillemotright

3040

    121, // ellipsis

3041

    122, // perthousand

3042

    0,   // .notdef

3043

    123, // questiondown

3044

    0,   // .notdef

3045

    124, // grave

3046

    125, // acute

3047

    126, // circumflex

3048

    127, // tilde

3049

    128, // macron

3050

    129, // breve

3051

    130, // dotaccent

3052

    131, // dieresis

3053

    0,   // .notdef

3054

    132, // ring

3055

    133, // cedilla

3056

    0,   // .notdef

3057

    134, // hungarumlaut

3058

    135, // ogonek

3059

    136, // caron

3060

    137, // emdash

3061

    0,   // .notdef

3062

    0,   // .notdef

3063

    0,   // .notdef

3064

    0,   // .notdef

3065

    0,   // .notdef

3066

    0,   // .notdef

3067

    0,   // .notdef

3068

    0,   // .notdef

3069

    0,   // .notdef

3070

    0,   // .notdef

3071

    0,   // .notdef

3072

    0,   // .notdef

3073

    0,   // .notdef

3074

    0,   // .notdef

3075

    0,   // .notdef

3076

    0,   // .notdef

3077

    138, // AE

3078

    0,   // .notdef

3079

    139, // ordfeminine

3080

    0,   // .notdef

3081

    0,   // .notdef

3082

    0,   // .notdef

3083

    0,   // .notdef

3084

    140, // Lslash

3085

    141, // Oslash

3086

    142, // OE

3087

    143, // ordmasculine

3088

    0,   // .notdef

3089

    0,   // .notdef

3090

    0,   // .notdef

3091

    0,   // .notdef

3092

    0,   // .notdef

3093

    144, // ae

3094

    0,   // .notdef

3095

    0,   // .notdef

3096

    0,   // .notdef

3097

    145, // dotlessi

3098

    0,   // .notdef

3099

    0,   // .notdef

3100

    146, // lslash

3101

    147, // oslash

3102

    148, // oe

3103

    149, // germandbls

3104

    0,   // .notdef

3105

    0,   // .notdef

3106

    0,   // .notdef

3107

    0,   // .notdef

3108

];

3109

3110

const EXPERT_CHARSET: [u16; 166] = [

3111

    0,   // .notdef

3112

    1,   // space

3113

    229, // exclamsmall

3114

    230, // Hungarumlautsmall

3115

    231, // dollaroldstyle

3116

    232, // dollarsuperior

3117

    233, // ampersandsmall

3118

    234, // Acutesmall

3119

    235, // parenleftsuperior

3120

    236, // parenrightsuperior

3121

    237, // twodotenleader

3122

    238, // onedotenleader

3123

    13,  // comma

3124

    14,  // hyphen

3125

    15,  // period

3126

    99,  // fraction

3127

    239, // zerooldstyle

3128

    240, // oneoldstyle

3129

    241, // twooldstyle

3130

    242, // threeoldstyle

3131

    243, // fouroldstyle

3132

    244, // fiveoldstyle

3133

    245, // sixoldstyle

3134

    246, // sevenoldstyle

3135

    247, // eightoldstyle

3136

    248, // nineoldstyle

3137

    27,  // colon

3138

    28,  // semicolon

3139

    249, // commasuperior

3140

    250, // threequartersemdash

3141

    251, // periodsuperior

3142

    252, // questionsmall

3143

    253, // asuperior

3144

    254, // bsuperior

3145

    255, // centsuperior

3146

    256, // dsuperior

3147

    257, // esuperior

3148

    258, // isuperior

3149

    259, // lsuperior

3150

    260, // msuperior

3151

    261, // nsuperior

3152

    262, // osuperior

3153

    263, // rsuperior

3154

    264, // ssuperior

3155

    265, // tsuperior

3156

    266, // ff

3157

    109, // fi

3158

    110, // fl

3159

    267, // ffi

3160

    268, // ffl

3161

    269, // parenleftinferior

3162

    270, // parenrightinferior

3163

    271, // Circumflexsmall

3164

    272, // hyphensuperior

3165

    273, // Gravesmall

3166

    274, // Asmall

3167

    275, // Bsmall

3168

    276, // Csmall

3169

    277, // Dsmall

3170

    278, // Esmall

3171

    279, // Fsmall

3172

    280, // Gsmall

3173

    281, // Hsmall

3174

    282, // Ismall

3175

    283, // Jsmall

3176

    284, // Ksmall

3177

    285, // Lsmall

3178

    286, // Msmall

3179

    287, // Nsmall

3180

    288, // Osmall

3181

    289, // Psmall

3182

    290, // Qsmall

3183

    291, // Rsmall

3184

    292, // Ssmall

3185

    293, // Tsmall

3186

    294, // Usmall

3187

    295, // Vsmall

3188

    296, // Wsmall

3189

    297, // Xsmall

3190

    298, // Ysmall

3191

    299, // Zsmall

3192

    300, // colonmonetary

3193

    301, // onefitted

3194

    302, // rupiah

3195

    303, // Tildesmall

3196

    304, // exclamdownsmall

3197

    305, // centoldstyle

3198

    306, // Lslashsmall

3199

    307, // Scaronsmall

3200

    308, // Zcaronsmall

3201

    309, // Dieresissmall

3202

    310, // Brevesmall

3203

    311, // Caronsmall

3204

    312, // Dotaccentsmall

3205

    313, // Macronsmall

3206

    314, // figuredash

3207

    315, // hypheninferior

3208

    316, // Ogoneksmall

3209

    317, // Ringsmall

3210

    318, // Cedillasmall

3211

    158, // onequarter

3212

    155, // onehalf

3213

    163, // threequarters

3214

    319, // questiondownsmall

3215

    320, // oneeighth

3216

    321, // threeeighths

3217

    322, // fiveeighths

3218

    323, // seveneighths

3219

    324, // onethird

3220

    325, // twothirds

3221

    326, // zerosuperior

3222

    150, // onesuperior

3223

    164, // twosuperior

3224

    169, // threesuperior

3225

    327, // foursuperior

3226

    328, // fivesuperior

3227

    329, // sixsuperior

3228

    330, // sevensuperior

3229

    331, // eightsuperior

3230

    332, // ninesuperior

3231

    333, // zeroinferior

3232

    334, // oneinferior

3233

    335, // twoinferior

3234

    336, // threeinferior

3235

    337, // fourinferior

3236

    338, // fiveinferior

3237

    339, // sixinferior

3238

    340, // seveninferior

3239

    341, // eightinferior

3240

    342, // nineinferior

3241

    343, // centinferior

3242

    344, // dollarinferior

3243

    345, // periodinferior

3244

    346, // commainferior

3245

    347, // Agravesmall

3246

    348, // Aacutesmall

3247

    349, // Acircumflexsmall

3248

    350, // Atildesmall

3249

    351, // Adieresissmall

3250

    352, // Aringsmall

3251

    353, // AEsmall

3252

    354, // Ccedillasmall

3253

    355, // Egravesmall

3254

    356, // Eacutesmall

3255

    357, // Ecircumflexsmall

3256

    358, // Edieresissmall

3257

    359, // Igravesmall

3258

    360, // Iacutesmall

3259

    361, // Icircumflexsmall

3260

    362, // Idieresissmall

3261

    363, // Ethsmall

3262

    364, // Ntildesmall

3263

    365, // Ogravesmall

3264

    366, // Oacutesmall

3265

    367, // Ocircumflexsmall

3266

    368, // Otildesmall

3267

    369, // Odieresissmall

3268

    370, // OEsmall

3269

    371, // Oslashsmall

3270

    372, // Ugravesmall

3271

    373, // Uacutesmall

3272

    374, // Ucircumflexsmall

3273

    375, // Udieresissmall

3274

    376, // Yacutesmall

3275

    377, // Thornsmall

3276

    378, // Ydieresissmall

3277

];

3278

3279

const EXPERT_SUBSET_CHARSET: [u16; 87] = [

3280

    0,   // .notdef

3281

    1,   // space

3282

    231, // dollaroldstyle

3283

    232, // dollarsuperior

3284

    235, // parenleftsuperior

3285

    236, // parenrightsuperior

3286

    237, // twodotenleader

3287

    238, // onedotenleader

3288

    13,  // comma

3289

    14,  // hyphen

3290

    15,  // period

3291

    99,  // fraction

3292

    239, // zerooldstyle

3293

    240, // oneoldstyle

3294

    241, // twooldstyle

3295

    242, // threeoldstyle

3296

    243, // fouroldstyle

3297

    244, // fiveoldstyle

3298

    245, // sixoldstyle

3299

    246, // sevenoldstyle

3300

    247, // eightoldstyle

3301

    248, // nineoldstyle

3302

    27,  // colon

3303

    28,  // semicolon

3304

    249, // commasuperior

3305

    250, // threequartersemdash

3306

    251, // periodsuperior

3307

    253, // asuperior

3308

    254, // bsuperior

3309

    255, // centsuperior

3310

    256, // dsuperior

3311

    257, // esuperior

3312

    258, // isuperior

3313

    259, // lsuperior

3314

    260, // msuperior

3315

    261, // nsuperior

3316

    262, // osuperior

3317

    263, // rsuperior

3318

    264, // ssuperior

3319

    265, // tsuperior

3320

    266, // ff

3321

    109, // fi

3322

    110, // fl

3323

    267, // ffi

3324

    268, // ffl

3325

    269, // parenleftinferior

3326

    270, // parenrightinferior

3327

    272, // hyphensuperior

3328

    300, // colonmonetary

3329

    301, // onefitted

3330

    302, // rupiah

3331

    305, // centoldstyle

3332

    314, // figuredash

3333

    315, // hypheninferior

3334

    158, // onequarter

3335

    155, // onehalf

3336

    163, // threequarters

3337

    320, // oneeighth

3338

    321, // threeeighths

3339

    322, // fiveeighths

3340

    323, // seveneighths

3341

    324, // onethird

3342

    325, // twothirds

3343

    326, // zerosuperior

3344

    150, // onesuperior

3345

    164, // twosuperior

3346

    169, // threesuperior

3347

    327, // foursuperior

3348

    328, // fivesuperior

3349

    329, // sixsuperior

3350

    330, // sevensuperior

3351

    331, // eightsuperior

3352

    332, // ninesuperior

3353

    333, // zeroinferior

3354

    334, // oneinferior

3355

    335, // twoinferior

3356

    336, // threeinferior

3357

    337, // fourinferior

3358

    338, // fiveinferior

3359

    339, // sixinferior

3360

    340, // seveninferior

3361

    341, // eightinferior

3362

    342, // nineinferior

3363

    343, // centinferior

3364

    344, // dollarinferior

3365

    345, // periodinferior

3366

    346, // commainferior

3367

];

3368

3369

#[cfg(test)]

3370

mod tests {

3371

    use super::*;

3372

    use crate::binary::read::ReadScope;

3373

3374

    fn assert_close(actual: f64, expected: f64) {

3375

        assert!(

3376

            (actual - expected).abs() < f64::EPSILON,

3377

            "{:?} != {:?} ± {}",

3378

            actual,

3379

            expected,

3380

            f64::EPSILON

3381

);

3382

3383

3384

    #[test]

3385

    fn test_iter_index() {

3386

        let offset_array = [1, 2, 3];

3387

        let data_array = [4, 5];

3388

        let index = Index {

3389

            count: 2,

3390

            off_size: 1,

3391

            offset_array: &offset_array,

3392

            data_array: &data_array,

3393

};

3394

3395

        assert_eq!(index.iter().collect::<Vec<_>>(), vec![[4], [5]]);

3396

3397

3398

    #[test]

3399

    fn test_read_op1() {

3400

        let mut ctxt = ReadScope::new(&[0, 0]).ctxt();

3401

        assert_eq!(

3402

            Op::read(&mut ctxt).unwrap(),

3403

            Op::Operator(Operator::Version)

3404

);

3405

3406

3407

    #[test]

3408

    fn test_fail_op1() {

3409

        let mut ctxt = ReadScope::new(&[]).ctxt();

3410

        assert!(Op::read(&mut ctxt).is_err());

3411

3412

3413

    #[test]

3414

    fn test_read_op2() {

3415

        let mut ctxt = ReadScope::new(&[12, 1]).ctxt();

3416

        assert_eq!(

3417

            Op::read(&mut ctxt).unwrap(),

3418

            Op::Operator(Operator::IsFixedPitch)

3419

);

3420

3421

3422

    #[test]

3423

    fn test_fail_op2() {

3424

        let mut ctxt = ReadScope::new(&[12]).ctxt();

3425

        assert!(Op::read(&mut ctxt).is_err());

3426

3427

3428

    #[test]

3429

    fn test_read_i8() {

3430

        let mut ctxt = ReadScope::new(&[0x8b]).ctxt();

3431

        assert_eq!(

3432

            Op::read(&mut ctxt).unwrap(),

3433

            Op::Operand(Operand::Integer(0))

3434

);

3435

3436

3437

    #[test]

3438

    fn test_read_i16() {

3439

        //                             _____-10000______  ______10000_____  100   -100

3440

        let mut ctxt = ReadScope::new(&[0x1c, 0xd8, 0xf0, 0x1c, 0x27, 0x10, 0xef, 0x27]).ctxt();

3441

        assert_eq!(

3442

            Op::read(&mut ctxt).unwrap(),

3443

            Op::Operand(Operand::Integer(-10000))

3444

);

3445

        assert_eq!(

3446

            Op::read(&mut ctxt).unwrap(),

3447

            Op::Operand(Operand::Integer(10000))

3448

);

3449

        assert_eq!(

3450

            Op::read(&mut ctxt).unwrap(),

3451

            Op::Operand(Operand::Integer(100))

3452

);

3453

        assert_eq!(

3454

            Op::read(&mut ctxt).unwrap(),

3455

            Op::Operand(Operand::Integer(-100))

3456

);

3457

3458

3459

    #[test]

3460

    fn test_read_i32() {

3461

        //                   __________-100000___________  ____________100000__________

3462

        let mut ctxt =

3463

            ReadScope::new(&[0x1d, 0xff, 0xfe, 0x79, 0x60, 0x1d, 0x00, 0x01, 0x86, 0xa0]).ctxt();

3464

        assert_eq!(

3465

            Op::read(&mut ctxt).unwrap(),

3466

            Op::Operand(Operand::Integer(-100000))

3467

);

3468

        assert_eq!(

3469

            Op::read(&mut ctxt).unwrap(),

3470

            Op::Operand(Operand::Integer(100000))

3471

);

3472

3473

3474

    #[test]

3475

    fn test_read_real() {

3476

        // From the spec:

3477

        // Thus, the value –2.25 is encoded by the byte sequence (1e e2 a2 5f) and the value

3478

        // 0.140541E–3 by the sequence (1e 0a 14 05 41 c3 ff).

3479

        let mut ctxt = ReadScope::new(&[

3480

            // ______-2.25________  _______________0.140541E–3______________

3481

            0x1e, 0xe2, 0xa2, 0x5f, 0x1e, 0x0a, 0x14, 0x05, 0x41, 0xc3, 0xff,

3482

])

3483

        .ctxt();

3484

        let op = Op::read(&mut ctxt).unwrap();

3485

        assert_eq!(

3486

op,

3487

            Op::Operand(Operand::Real(Real(tiny_vec![0xe2, 0xa2, 0x5f])))

3488

);

3489

        let Op::Operand(Operand::Real(real)) = op else {

3490

            panic!("op didn't match Real")

3491

};

3492

        assert_close(f64::try_from(&real).unwrap(), -2.25);

3493

        let op = Op::read(&mut ctxt).unwrap();

3494

        assert_eq!(

3495

op,

3496

            Op::Operand(Operand::Real(Real(tiny_vec![

3497

                0x0a, 0x14, 0x05, 0x41, 0xc3, 0xff

3498

            ])))

3499

);

3500

        let Op::Operand(Operand::Real(real)) = op else {

3501

            panic!("op didn't match Real")

3502

};

3503

        assert_close(f64::try_from(&real).unwrap(), 0.000140541);

3504

3505

3506

    #[test]

3507

    fn test_read_top_dict() {

3508

        let expected = TopDict {

3509

            dict: vec![

3510

                (Operator::IsFixedPitch, vec![Operand::Integer(1)]),

3511

                (Operator::Notice, vec![Operand::Integer(123)]),

3512

],

3513

            default: PhantomData,

3514

};

3515

        // IsFixedPitch (12 1) is true (1)

3516

        // Notice (1) SID is 123

3517

        //                              _1__         __123__

3518

        let mut ctxt = ReadScope::new(&[0x8c, 12, 1, 247, 15, 1]).ctxt();

3519

        assert_eq!(

3520

            TopDict::read_dep(&mut ctxt, MAX_OPERANDS).unwrap(),

3521

            expected

3522

);

3523

3524

3525

    #[test]

3526

    fn test_write_top_dict() {

3527

        let dict = TopDict {

3528

            dict: vec![

3529

                (Operator::IsFixedPitch, vec![Operand::Integer(1)]),

3530

                (Operator::Notice, vec![Operand::Integer(123)]),

3531

                // This one is omitted in the output because it is the default for this operator

3532

                (Operator::PaintType, vec![Operand::Integer(0)]),

3533

],

3534

            default: PhantomData,

3535

};

3536

        // IsFixedPitch Op2(1) is true (1)

3537

        // Notice Op1(1) SID is 123

3538

        //              _1__  Op2(1) __123__  Op1(1)

3539

        let expected = [0x8c, 12, 1, 247, 15, 1];

3540

        let mut ctxt = WriteBuffer::new();

3541

        TopDict::write_dep(&mut ctxt, &dict, DictDelta::new()).unwrap();

3542

3543

        assert_eq!(ctxt.bytes(), &expected);

3544

3545

3546

    #[test]

3547

    fn test_write_top_dict_delta() {

3548

        let dict = TopDict {

3549

            dict: vec![(Operator::CharStrings, vec![Operand::Offset(123)])],

3550

            default: PhantomData,

3551

};

3552

        let mut delta = DictDelta::new();

3553

        delta.push(

3554

            Operator::CharStrings,

3555

            tiny_vec!([Operand; 1] => Operand::Offset(1000)),

3556

);

3557

3558

        // CharStrings is operator 17 and takes an offset (number as operand)

3559

        // Offsets are always written out using the 5 byte representation

3560

        //              _______1000_________

3561

        let expected = [29, 0, 0, 0x03, 0xE8, 17];

3562

        let mut ctxt = WriteBuffer::new();

3563

        TopDict::write_dep(&mut ctxt, &dict, delta).unwrap();

3564

3565

        // It's expected that the delta value is used instead of the dict value

3566

        assert_eq!(ctxt.bytes(), &expected);

3567

3568

3569

    #[test]

3570

    fn test_write_top_dict_size() {

3571

        let dict = TopDict {

3572

            dict: vec![

3573

                (Operator::IsFixedPitch, vec![Operand::Integer(1)]),

3574

                (Operator::Notice, vec![Operand::Integer(123)]),

3575

                // This one is omitted in the output because it is the default for this operator

3576

                (Operator::PaintType, vec![Operand::Integer(0)]),

3577

],

3578

            default: PhantomData,

3579

};

3580

        let mut counter = WriteCounter::new();

3581

        TopDict::write_dep(&mut counter, &dict, DictDelta::new()).unwrap();

3582

3583

        assert_eq!(counter.bytes_written(), 6);

3584

3585

3586

    #[test]

3587

    fn test_read_top_dict_operand_limit() {

3588

        let mut ctxt = ReadScope::new(&[0x8c; 2]).ctxt();

3589

        match TopDict::read_dep(&mut ctxt, 1) {

3590

            Err(ParseError::LimitExceeded) => {}

3591

            _ => panic!("expected Err(ParseError::LimitExceeded) got something else"),

3592

3593

3594

3595

    #[test]

3596

    fn test_read_empty_private_dict() {

3597

        // A Private DICT is required, but may be specified as having a length of 0 if there are

3598

        // no non-default values to be stored.

3599

        let dict = ReadScope::new(&[]).read_dep::<PrivateDict>(MAX_OPERANDS);

3600

        assert!(dict.is_ok());

3601

3602

3603

    #[test]

3604

    fn test_read_custom_encoding_format0() {

3605

        let data_format0 = [0, 3, 4, 5, 6];

3606

        let mut ctxt = ReadScope::new(&data_format0).ctxt();

3607

        let format0_encoding = ctxt.read::<CustomEncoding<'_>>().unwrap();

3608

        match format0_encoding {

3609

            CustomEncoding::Format0 { codes } => {

3610

                assert_eq!(codes.iter().collect::<Vec<_>>(), vec![4, 5, 6])

3611

3612

            _ => panic!("expected CustomEncoding::Format0 got something else"),

3613

3614

3615

3616

    #[test]

3617

    fn test_read_custom_encoding_format1() {

3618

        let data_format1 = [1, 2, 4, 5, 6, 7];

3619

        let mut ctxt = ReadScope::new(&data_format1).ctxt();

3620

        let format1_encoding = ctxt.read::<CustomEncoding<'_>>().unwrap();

3621

        match format1_encoding {

3622

            CustomEncoding::Format1 { ranges } => assert_eq!(

3623

                ranges.iter().collect::<Vec<_>>(),

3624

                vec![

3625

                    Range {

3626

                        first: 4,

3627

                        n_left: 5

3628

},

3629

                    Range {

3630

                        first: 6,

3631

                        n_left: 7

3632

3633

3634

),

3635

            _ => panic!("expected CustomEncoding::Format1 got something else"),

3636

3637

3638

3639

    #[test]

3640

    fn test_read_custom_charset_format0() {

3641

        let n_glyphs = 2;

3642

        let data_format0 = [0, 0xAA, 0xBB];

3643

        let mut ctxt = ReadScope::new(&data_format0).ctxt();

3644

        let format0_charset = ctxt.read_dep::<CustomCharset<'_>>(n_glyphs).unwrap();

3645

        match format0_charset {

3646

            CustomCharset::Format0 { glyphs } => {

3647

                assert_eq!(glyphs.iter().collect::<Vec<_>>(), vec![0xAABB])

3648

3649

            _ => panic!("expected CustomCharset::Format0 got something else"),

3650

3651

3652

3653

    #[test]

3654

    fn test_read_custom_charset_format1() {

3655

        let n_glyphs = 5;

3656

        let data_format1 = [1, 0, 1, 3];

3657

        let mut ctxt = ReadScope::new(&data_format1).ctxt();

3658

        let format1_charset = ctxt.read_dep::<CustomCharset<'_>>(n_glyphs).unwrap();

3659

        match format1_charset {

3660

            CustomCharset::Format1 { ranges } => assert_eq!(

3661

                ranges.iter().collect::<Vec<_>>(),

3662

                vec![Range {

3663

                    first: 1,

3664

                    n_left: 3

3665

},]

3666

),

3667

            _ => panic!("expected CustomCharset::Format1 got something else"),

3668

3669

3670

3671

    #[test]

3672

    fn test_read_custom_charset_format2() {

3673

        let n_glyphs = 5;

3674

        let data_format2 = [2, 0, 1, 0, 3];

3675

        let mut ctxt = ReadScope::new(&data_format2).ctxt();

3676

        let format2_charset = ctxt.read_dep::<CustomCharset<'_>>(n_glyphs).unwrap();

3677

        match format2_charset {

3678

            CustomCharset::Format2 { ranges } => assert_eq!(

3679

                ranges.iter().collect::<Vec<_>>(),

3680

                vec![Range {

3681

                    first: 1,

3682

                    n_left: 3

3683

},]

3684

),

3685

            _ => panic!("expected CustomCharset::Format2 got something else"),

3686

3687

3688

3689

    #[test]

3690

    fn test_read_write_index() {

3691

        let mut count = vec![0, 1];

3692

        let off_size = 3;

3693

        let mut offset0 = vec![0, 0, 1];

3694

        let mut offset1 = vec![0, 0, 2];

3695

        let object = 5;

3696

3697

        // The data is built up like so it's easier to see what each value represents

3698

        let mut data = Vec::new();

3699

        data.append(&mut count);

3700

        data.push(off_size);

3701

        data.append(&mut offset0);

3702

        data.append(&mut offset1);

3703

        data.push(object);

3704

3705

        // Read

3706

        let mut ctxt = ReadScope::new(&data).ctxt();

3707

        let index = ctxt.read::<IndexU16>().unwrap();

3708

3709

        let actual: Vec<_> = index.iter().collect();

3710

        assert_eq!(actual, &[&[5]]);

3711

3712

        // Write

3713

        let mut ctxt = WriteBuffer::new();

3714

        IndexU16::write(&mut ctxt, &index).unwrap();

3715

3716

        assert_eq!(ctxt.bytes(), &[0, 1, 3, 0, 0, 1, 0, 0, 2, 5]);

3717

3718

3719

    #[test]

3720

    fn test_write_int_operand() {

3721

        assert_eq!(write_int_operand(0), &[0x8b]);

3722

        assert_eq!(write_int_operand(100), &[0xef]);

3723

        assert_eq!(write_int_operand(-100), &[0x27]);

3724

        assert_eq!(write_int_operand(1000), &[0xfa, 0x7c]);

3725

        assert_eq!(write_int_operand(-1000), &[0xfe, 0x7c]);

3726

        assert_eq!(write_int_operand(10000), &[0x1c, 0x27, 0x10]);

3727

        assert_eq!(write_int_operand(-10000), &[0x1c, 0xd8, 0xf0]);

3728

        assert_eq!(write_int_operand(100000), &[0x1d, 0x00, 0x01, 0x86, 0xa0]);

3729

        assert_eq!(write_int_operand(-100000), &[0x1d, 0xff, 0xfe, 0x79, 0x60]);

3730

3731

3732

    #[test]

3733

    fn test_write_int_operand_round_trip() {

3734

        int_operand_round_trip(0);

3735

        int_operand_round_trip(100);

3736

        int_operand_round_trip(540);

3737

        int_operand_round_trip(-100);

3738

        int_operand_round_trip(-267);

3739

        int_operand_round_trip(1000);

3740

        int_operand_round_trip(-1000);

3741

        int_operand_round_trip(10000);

3742

        int_operand_round_trip(-10000);

3743

        int_operand_round_trip(100000);

3744

        int_operand_round_trip(-100000);

3745

3746

3747

    fn int_operand_round_trip(val: i32) {

3748

        let int = write_int_operand(val);

3749

        match ReadScope::new(&int).read::<Op>().unwrap() {

3750

            Op::Operand(Operand::Integer(actual)) => assert_eq!(actual, val),

3751

            _ => unreachable!(),

3752

3753

3754

3755

    fn write_int_operand(val: i32) -> Vec<u8> {

3756

        let mut ctxt = WriteBuffer::new();

3757

        Operand::write(&mut ctxt, &Operand::Integer(val)).unwrap();

3758

        ctxt.into_inner()

3759

3760

3761

    #[test]

3762

    fn test_fd_select_font_dict_index_format0() {

3763

        let glyph_font_dict_indices = ReadArrayCow::Owned(vec![1, 2, 3]);

3764

        let fd_select = FDSelect::Format0 {

3765

            glyph_font_dict_indices,

3766

};

3767

3768

        assert_eq!(fd_select.font_dict_index(2), Some(3));

3769

        assert_eq!(fd_select.font_dict_index(3), None);

3770

3771

3772

    #[test]

3773

    fn test_fd_select_font_dict_index_format3() {

3774

        // Set up 3 ranges:

3775

        //  0..10 -> Font DICT index 2

3776

        // 10..17 -> Font DICT index 1

3777

        // 17..33 -> Font DICT index 0

3778

        let ranges: Vec<Range<u16, u8>> = vec![

3779

            Range {

3780

                first: 0,

3781

                n_left: 2,

3782

},

3783

            Range {

3784

                first: 10,

3785

                n_left: 1,

3786

},

3787

            Range {

3788

                first: 17,

3789

                n_left: 0,

3790

},

3791

];

3792

        let fd_select = FDSelect::Format3 {

3793

            ranges: ReadArrayCow::Owned(ranges),

3794

            sentinel: 33,

3795

};

3796

3797

        assert_eq!(fd_select.font_dict_index(2), Some(2));

3798

        assert_eq!(fd_select.font_dict_index(10), Some(1));

3799

        assert_eq!(fd_select.font_dict_index(32), Some(0));

3800

        assert_eq!(fd_select.font_dict_index(33), None);

3801

3802

3803

    #[test]

3804

    fn test_charset_id_for_glyph_pre_defined_charsets() {

3805

        assert_eq!(Charset::ISOAdobe.id_for_glyph(2), Some(2));

3806

        assert_eq!(Charset::ISOAdobe.id_for_glyph(300), None);

3807

        assert_eq!(Charset::Expert.id_for_glyph(2), Some(229));

3808

        assert_eq!(Charset::Expert.id_for_glyph(300), None);

3809

        assert_eq!(Charset::ExpertSubset.id_for_glyph(2), Some(231));

3810

        assert_eq!(Charset::ExpertSubset.id_for_glyph(300), None);

3811

3812

3813

    #[test]

3814

    fn test_custom_charset_id_for_glyph_format0() {

3815

        let glyph_sids = ReadArrayCow::Owned(vec![1, 2, 3]);

3816

        let charset = CustomCharset::Format0 { glyphs: glyph_sids };

3817

3818

        // glyph id 0 is .notdef and is implicitly encoded

3819

        assert_eq!(charset.id_for_glyph(0), Some(0));

3820

        assert_eq!(charset.id_for_glyph(1), Some(1));

3821

        assert_eq!(charset.id_for_glyph(4), None);

3822

3823

3824

    #[test]

3825

    fn test_custom_charset_id_for_glyph_format1() {

3826

        let ranges = ReadArrayCow::Owned(vec![Range {

3827

            first: 34,

3828

            n_left: 5,

3829

        }]);

3830

        let charset = CustomCharset::Format1 { ranges };

3831

3832

        // glyph id 0 is .notdef and is implicitly encoded

3833

        assert_eq!(charset.id_for_glyph(0), Some(0));

3834

        assert_eq!(charset.id_for_glyph(1), Some(34));

3835

        assert_eq!(charset.id_for_glyph(6), Some(39));

3836

        assert_eq!(charset.id_for_glyph(7), None);

3837

3838

3839

    #[test]

3840

    fn test_custom_charset_id_for_glyph_format2() {

3841

        let ranges = ReadArrayCow::Owned(vec![Range {

3842

            first: 34,

3843

            n_left: 5,

3844

        }]);

3845

        let charset = CustomCharset::Format2 { ranges };

3846

3847

        // glyph id 0 is .notdef and is implicitly encoded

3848

        assert_eq!(charset.id_for_glyph(0), Some(0));

3849

        assert_eq!(charset.id_for_glyph(1), Some(34));

3850

        assert_eq!(charset.id_for_glyph(6), Some(39));

3851

        assert_eq!(charset.id_for_glyph(7), None);

3852

3853

3854

    #[test]

3855

    fn test_arno_custom_charset_ranges() {

3856

        // These ranges are from the ArnoPro-Regular font and are in the same order they are in the

3857

        // font.

3858

        #[rustfmt::skip]

3859

        let ranges = ReadArrayCow::Owned(vec![

3860

            Range { first: 1, n_left: 107, },

3861

            Range { first: 111, n_left: 38, },

3862

            Range { first: 151, n_left: 12, },

3863

            Range { first: 165, n_left: 3, },

3864

            Range { first: 170, n_left: 58, },

3865

            Range { first: 237, n_left: 1, },

3866

            Range { first: 391, n_left: 0, },

3867

            Range { first: 393, n_left: 0, },

3868

            Range { first: 300, n_left: 0, },

3869

            Range { first: 392, n_left: 0, },

3870

            Range { first: 314, n_left: 0, },

3871

            Range { first: 324, n_left: 1, },

3872

            Range { first: 320, n_left: 3, },

3873

            Range { first: 394, n_left: 2577, },

3874

            Range { first: 109, n_left: 1, },

3875

            Range { first: 2972, n_left: 28, },

3876

            Range { first: 2846, n_left: 768, },

3877

]);

3878

        let charset = CustomCharset::Format2 { ranges };

3879

3880

        // glyph id 0 is .notdef and is implicitly encoded

3881

        assert_eq!(charset.id_for_glyph(134), Some(136));

3882

        assert_eq!(charset.id_for_glyph(265), Some(422));

3883

        assert_eq!(charset.id_for_glyph(279), Some(436));

3884

3885

3886

    #[test]

3887

    fn test_custom_charset_iter() {

3888

        // These ranges are from the ArnoPro-Regular font and are in the same order they are in the

3889

        // font.

3890

        #[rustfmt::skip]

3891

            let ranges = ReadArrayCow::Owned(vec![

3892

            Range { first: 111, n_left: 4, },

3893

            Range { first: 1, n_left: 3, },

3894

            Range { first: 2972, n_left: 2, },

3895

]);

3896

        let charset = CustomCharset::Format2 { ranges };

3897

        let actual = charset.iter().collect::<Vec<_>>();

3898

        let expected = vec![0, 111, 112, 113, 114, 115, 1, 2, 3, 4, 2972, 2973, 2974];

3899

3900

        assert_eq!(actual, expected);

3901

3902

3903

    #[test]

3904

    fn test_read_standard_string() {

3905

        let data = b"Ferris";

3906

        let offsets = [1, (data.len() + 1) as u8];

3907

        let string_index = MaybeOwnedIndex::Borrowed(Index {

3908

            count: 1,

3909

            off_size: 1,

3910

            offset_array: &offsets,

3911

            data_array: data,

3912

});

3913

3914

        assert_eq!(

3915

            read_string_index_string(&string_index, 7).unwrap(),

3916

            "ampersand"

3917

);

3918

        assert_eq!(

3919

            read_string_index_string(&string_index, 390).unwrap(),

3920

            "Semibold"

3921

);

3922

3923

3924

    #[test]

3925

    fn test_read_custom_string() {

3926

        let data = b"Ferris";

3927

        let offsets = [1, (data.len() + 1) as u8];

3928

        let string_index = MaybeOwnedIndex::Borrowed(Index {

3929

            count: 1,

3930

            off_size: 1,

3931

            offset_array: &offsets,

3932

            data_array: data,

3933

});

3934

3935

        assert_eq!(

3936

            read_string_index_string(&string_index, 391).unwrap(),

3937

            "Ferris"

3938

);

3939

        assert!(read_string_index_string(&string_index, 392).is_err());

3940

3941

3942

    #[test]

3943

    fn bcd_encode() {

3944

        let mut buf = tiny_vec!([u8; 32]);

3945

        assert_eq!(Operand::bcd_encode(&mut buf, 0.0), Operand::Integer(0));

3946

        assert_eq!(Operand::bcd_encode(&mut buf, 1.0), Operand::Integer(1));

3947

        assert_eq!(Operand::bcd_encode(&mut buf, -1.0), Operand::Integer(-1));

3948

        assert_eq!(

3949

            Operand::bcd_encode(&mut buf, -2.25),

3950

            Operand::Real(Real(tiny_vec![0xe2, 0xa2, 0x5f]))

3951

);

3952

        assert_eq!(

3953

            Operand::bcd_encode(&mut buf, 1.140541E-3),

3954

            Operand::Real(Real(tiny_vec![0x1a, 0x14, 0x05, 0x41, 0xc3, 0xff]))

3955

);

3956

3957