Coverage for /pythoncovmergedfiles/medio/medio/src/pdfminer.six/pdfminer/pdffont.py: 59%

1import logging 

2import struct 

3from io import BytesIO 

4from typing import ( 

5 TYPE_CHECKING, 

6 Any, 

7 BinaryIO, 

8 Dict, 

9 Iterable, 

10 Iterator, 

11 List, 

12 Mapping, 

13 Optional, 

14 Tuple, 

15 Union, 

16 cast, 

17) 

18 

19from pdfminer import settings 

20from pdfminer.cmapdb import ( 

21 CMap, 

22 CMapBase, 

23 CMapDB, 

24 CMapParser, 

25 FileUnicodeMap, 

26 IdentityUnicodeMap, 

27 UnicodeMap, 

28) 

29from pdfminer.encodingdb import EncodingDB, name2unicode 

30from pdfminer.fontmetrics import FONT_METRICS 

31from pdfminer.pdfexceptions import PDFException, PDFKeyError, PDFValueError 

32from pdfminer.pdftypes import ( 

33 PDFStream, 

34 dict_value, 

35 int_value, 

36 list_value, 

37 num_value, 

38 resolve1, 

39 resolve_all, 

40 stream_value, 

41) 

42from pdfminer.psexceptions import PSEOF 

43from pdfminer.psparser import ( 

44 KWD, 

45 LIT, 

46 PSKeyword, 

47 PSLiteral, 

48 PSStackParser, 

49 literal_name, 

50) 

51from pdfminer.utils import Matrix, Point, Rect, apply_matrix_norm, choplist, nunpack 

52 

53if TYPE_CHECKING: 

54 from pdfminer.pdfinterp import PDFResourceManager 

55 

56log = logging.getLogger(__name__) 

57 

58 

59def get_widths(seq: Iterable[object]) -> Dict[int, float]: 

60 """Build a mapping of character widths for horizontal writing.""" 

61 widths: Dict[int, float] = {} 

62 r: List[float] = [] 

63 for v in seq: 

64 if isinstance(v, list): 

65 if r: 

66 char1 = r[-1] 

67 for i, w in enumerate(v): 

68 widths[cast(int, char1) + i] = w 

69 r = [] 

70 elif isinstance(v, (int, float)): # == utils.isnumber(v) 

71 r.append(v) 

72 if len(r) == 3: 

73 (char1, char2, w) = r 

74 for i in range(cast(int, char1), cast(int, char2) + 1): 

75 widths[i] = w 

76 r = [] 

77 return widths 

78 

79 

80def get_widths2(seq: Iterable[object]) -> Dict[int, Tuple[float, Point]]: 

81 """Build a mapping of character widths for vertical writing.""" 

82 widths: Dict[int, Tuple[float, Point]] = {} 

83 r: List[float] = [] 

84 for v in seq: 

85 if isinstance(v, list): 

86 if r: 

87 char1 = r[-1] 

88 for i, (w, vx, vy) in enumerate(choplist(3, v)): 

89 widths[cast(int, char1) + i] = (w, (vx, vy)) 

90 r = [] 

91 elif isinstance(v, (int, float)): # == utils.isnumber(v) 

92 r.append(v) 

93 if len(r) == 5: 

94 (char1, char2, w, vx, vy) = r 

95 for i in range(cast(int, char1), cast(int, char2) + 1): 

96 widths[i] = (w, (vx, vy)) 

97 r = [] 

98 return widths 

99 

100 

101class FontMetricsDB: 

102 @classmethod 

103 def get_metrics(cls, fontname: str) -> Tuple[Dict[str, object], Dict[str, int]]: 

104 return FONT_METRICS[fontname] 

105 

106 

107# int here means that we're not extending PSStackParser with additional types. 

108class Type1FontHeaderParser(PSStackParser[int]): 

109 KEYWORD_BEGIN = KWD(b"begin") 

110 KEYWORD_END = KWD(b"end") 

111 KEYWORD_DEF = KWD(b"def") 

112 KEYWORD_PUT = KWD(b"put") 

113 KEYWORD_DICT = KWD(b"dict") 

114 KEYWORD_ARRAY = KWD(b"array") 

115 KEYWORD_READONLY = KWD(b"readonly") 

116 KEYWORD_FOR = KWD(b"for") 

117 

118 def __init__(self, data: BinaryIO) -> None: 

119 PSStackParser.__init__(self, data) 

120 self._cid2unicode: Dict[int, str] = {} 

121 

122 def get_encoding(self) -> Dict[int, str]: 

123 """Parse the font encoding. 

124 

125 The Type1 font encoding maps character codes to character names. These 

126 character names could either be standard Adobe glyph names, or 

127 character names associated with custom CharStrings for this font. A 

128 CharString is a sequence of operations that describe how the character 

129 should be drawn. Currently, this function returns '' (empty string) 

130 for character names that are associated with a CharStrings. 

131 

132 Reference: Adobe Systems Incorporated, Adobe Type 1 Font Format 

133 

134 :returns mapping of character identifiers (cid's) to unicode characters 

135 """ 

136 while 1: 

137 try: 

138 (cid, name) = self.nextobject() 

139 except PSEOF: 

140 break 

141 try: 

142 self._cid2unicode[cid] = name2unicode(cast(str, name)) 

143 except KeyError as e: 

144 log.debug(str(e)) 

145 return self._cid2unicode 

146 

147 def do_keyword(self, pos: int, token: PSKeyword) -> None: 

148 if token is self.KEYWORD_PUT: 

149 ((_, key), (_, value)) = self.pop(2) 

150 if isinstance(key, int) and isinstance(value, PSLiteral): 

151 self.add_results((key, literal_name(value))) 

152 

153 

154NIBBLES = ("0", "1", "2", "3", "4", "5", "6", "7", "8", "9", ".", "e", "e-", None, "-") 

155 

156# Mapping of cmap names. Original cmap name is kept if not in the mapping. 

157# (missing reference for why DLIdent is mapped to Identity) 

158IDENTITY_ENCODER = { 

159 "DLIdent-H": "Identity-H", 

160 "DLIdent-V": "Identity-V", 

161} 

162 

163 

164def getdict(data: bytes) -> Dict[int, List[Union[float, int]]]: 

165 d: Dict[int, List[Union[float, int]]] = {} 

166 fp = BytesIO(data) 

167 stack: List[Union[float, int]] = [] 

168 while 1: 

169 c = fp.read(1) 

170 if not c: 

171 break 

172 b0 = ord(c) 

173 if b0 <= 21: 

174 d[b0] = stack 

175 stack = [] 

176 continue 

177 if b0 == 30: 

178 s = "" 

179 loop = True 

180 while loop: 

181 b = ord(fp.read(1)) 

182 for n in (b >> 4, b & 15): 

183 if n == 15: 

184 loop = False 

185 else: 

186 nibble = NIBBLES[n] 

187 assert nibble is not None 

188 s += nibble 

189 value = float(s) 

190 elif b0 >= 32 and b0 <= 246: 

191 value = b0 - 139 

192 else: 

193 b1 = ord(fp.read(1)) 

194 if b0 >= 247 and b0 <= 250: 

195 value = ((b0 - 247) << 8) + b1 + 108 

196 elif b0 >= 251 and b0 <= 254: 

197 value = -((b0 - 251) << 8) - b1 - 108 

198 else: 

199 b2 = ord(fp.read(1)) 

200 if b1 >= 128: 

201 b1 -= 256 

202 if b0 == 28: 

203 value = b1 << 8 | b2 

204 else: 

205 value = b1 << 24 | b2 << 16 | struct.unpack(">H", fp.read(2))[0] 

206 stack.append(value) 

207 return d 

208 

209 

210class CFFFont: 

211 STANDARD_STRINGS = ( 

212 ".notdef", 

213 "space", 

214 "exclam", 

215 "quotedbl", 

216 "numbersign", 

217 "dollar", 

218 "percent", 

219 "ampersand", 

220 "quoteright", 

221 "parenleft", 

222 "parenright", 

223 "asterisk", 

224 "plus", 

225 "comma", 

226 "hyphen", 

227 "period", 

228 "slash", 

229 "zero", 

230 "one", 

231 "two", 

232 "three", 

233 "four", 

234 "five", 

235 "six", 

236 "seven", 

237 "eight", 

238 "nine", 

239 "colon", 

240 "semicolon", 

241 "less", 

242 "equal", 

243 "greater", 

244 "question", 

245 "at", 

246 "A", 

247 "B", 

248 "C", 

249 "D", 

250 "E", 

251 "F", 

252 "G", 

253 "H", 

254 "I", 

255 "J", 

256 "K", 

257 "L", 

258 "M", 

259 "N", 

260 "O", 

261 "P", 

262 "Q", 

263 "R", 

264 "S", 

265 "T", 

266 "U", 

267 "V", 

268 "W", 

269 "X", 

270 "Y", 

271 "Z", 

272 "bracketleft", 

273 "backslash", 

274 "bracketright", 

275 "asciicircum", 

276 "underscore", 

277 "quoteleft", 

278 "a", 

279 "b", 

280 "c", 

281 "d", 

282 "e", 

283 "f", 

284 "g", 

285 "h", 

286 "i", 

287 "j", 

288 "k", 

289 "l", 

290 "m", 

291 "n", 

292 "o", 

293 "p", 

294 "q", 

295 "r", 

296 "s", 

297 "t", 

298 "u", 

299 "v", 

300 "w", 

301 "x", 

302 "y", 

303 "z", 

304 "braceleft", 

305 "bar", 

306 "braceright", 

307 "asciitilde", 

308 "exclamdown", 

309 "cent", 

310 "sterling", 

311 "fraction", 

312 "yen", 

313 "florin", 

314 "section", 

315 "currency", 

316 "quotesingle", 

317 "quotedblleft", 

318 "guillemotleft", 

319 "guilsinglleft", 

320 "guilsinglright", 

321 "fi", 

322 "fl", 

323 "endash", 

324 "dagger", 

325 "daggerdbl", 

326 "periodcentered", 

327 "paragraph", 

328 "bullet", 

329 "quotesinglbase", 

330 "quotedblbase", 

331 "quotedblright", 

332 "guillemotright", 

333 "ellipsis", 

334 "perthousand", 

335 "questiondown", 

336 "grave", 

337 "acute", 

338 "circumflex", 

339 "tilde", 

340 "macron", 

341 "breve", 

342 "dotaccent", 

343 "dieresis", 

344 "ring", 

345 "cedilla", 

346 "hungarumlaut", 

347 "ogonek", 

348 "caron", 

349 "emdash", 

350 "AE", 

351 "ordfeminine", 

352 "Lslash", 

353 "Oslash", 

354 "OE", 

355 "ordmasculine", 

356 "ae", 

357 "dotlessi", 

358 "lslash", 

359 "oslash", 

360 "oe", 

361 "germandbls", 

362 "onesuperior", 

363 "logicalnot", 

364 "mu", 

365 "trademark", 

366 "Eth", 

367 "onehalf", 

368 "plusminus", 

369 "Thorn", 

370 "onequarter", 

371 "divide", 

372 "brokenbar", 

373 "degree", 

374 "thorn", 

375 "threequarters", 

376 "twosuperior", 

377 "registered", 

378 "minus", 

379 "eth", 

380 "multiply", 

381 "threesuperior", 

382 "copyright", 

383 "Aacute", 

384 "Acircumflex", 

385 "Adieresis", 

386 "Agrave", 

387 "Aring", 

388 "Atilde", 

389 "Ccedilla", 

390 "Eacute", 

391 "Ecircumflex", 

392 "Edieresis", 

393 "Egrave", 

394 "Iacute", 

395 "Icircumflex", 

396 "Idieresis", 

397 "Igrave", 

398 "Ntilde", 

399 "Oacute", 

400 "Ocircumflex", 

401 "Odieresis", 

402 "Ograve", 

403 "Otilde", 

404 "Scaron", 

405 "Uacute", 

406 "Ucircumflex", 

407 "Udieresis", 

408 "Ugrave", 

409 "Yacute", 

410 "Ydieresis", 

411 "Zcaron", 

412 "aacute", 

413 "acircumflex", 

414 "adieresis", 

415 "agrave", 

416 "aring", 

417 "atilde", 

418 "ccedilla", 

419 "eacute", 

420 "ecircumflex", 

421 "edieresis", 

422 "egrave", 

423 "iacute", 

424 "icircumflex", 

425 "idieresis", 

426 "igrave", 

427 "ntilde", 

428 "oacute", 

429 "ocircumflex", 

430 "odieresis", 

431 "ograve", 

432 "otilde", 

433 "scaron", 

434 "uacute", 

435 "ucircumflex", 

436 "udieresis", 

437 "ugrave", 

438 "yacute", 

439 "ydieresis", 

440 "zcaron", 

441 "exclamsmall", 

442 "Hungarumlautsmall", 

443 "dollaroldstyle", 

444 "dollarsuperior", 

445 "ampersandsmall", 

446 "Acutesmall", 

447 "parenleftsuperior", 

448 "parenrightsuperior", 

449 "twodotenleader", 

450 "onedotenleader", 

451 "zerooldstyle", 

452 "oneoldstyle", 

453 "twooldstyle", 

454 "threeoldstyle", 

455 "fouroldstyle", 

456 "fiveoldstyle", 

457 "sixoldstyle", 

458 "sevenoldstyle", 

459 "eightoldstyle", 

460 "nineoldstyle", 

461 "commasuperior", 

462 "threequartersemdash", 

463 "periodsuperior", 

464 "questionsmall", 

465 "asuperior", 

466 "bsuperior", 

467 "centsuperior", 

468 "dsuperior", 

469 "esuperior", 

470 "isuperior", 

471 "lsuperior", 

472 "msuperior", 

473 "nsuperior", 

474 "osuperior", 

475 "rsuperior", 

476 "ssuperior", 

477 "tsuperior", 

478 "ff", 

479 "ffi", 

480 "ffl", 

481 "parenleftinferior", 

482 "parenrightinferior", 

483 "Circumflexsmall", 

484 "hyphensuperior", 

485 "Gravesmall", 

486 "Asmall", 

487 "Bsmall", 

488 "Csmall", 

489 "Dsmall", 

490 "Esmall", 

491 "Fsmall", 

492 "Gsmall", 

493 "Hsmall", 

494 "Ismall", 

495 "Jsmall", 

496 "Ksmall", 

497 "Lsmall", 

498 "Msmall", 

499 "Nsmall", 

500 "Osmall", 

501 "Psmall", 

502 "Qsmall", 

503 "Rsmall", 

504 "Ssmall", 

505 "Tsmall", 

506 "Usmall", 

507 "Vsmall", 

508 "Wsmall", 

509 "Xsmall", 

510 "Ysmall", 

511 "Zsmall", 

512 "colonmonetary", 

513 "onefitted", 

514 "rupiah", 

515 "Tildesmall", 

516 "exclamdownsmall", 

517 "centoldstyle", 

518 "Lslashsmall", 

519 "Scaronsmall", 

520 "Zcaronsmall", 

521 "Dieresissmall", 

522 "Brevesmall", 

523 "Caronsmall", 

524 "Dotaccentsmall", 

525 "Macronsmall", 

526 "figuredash", 

527 "hypheninferior", 

528 "Ogoneksmall", 

529 "Ringsmall", 

530 "Cedillasmall", 

531 "questiondownsmall", 

532 "oneeighth", 

533 "threeeighths", 

534 "fiveeighths", 

535 "seveneighths", 

536 "onethird", 

537 "twothirds", 

538 "zerosuperior", 

539 "foursuperior", 

540 "fivesuperior", 

541 "sixsuperior", 

542 "sevensuperior", 

543 "eightsuperior", 

544 "ninesuperior", 

545 "zeroinferior", 

546 "oneinferior", 

547 "twoinferior", 

548 "threeinferior", 

549 "fourinferior", 

550 "fiveinferior", 

551 "sixinferior", 

552 "seveninferior", 

553 "eightinferior", 

554 "nineinferior", 

555 "centinferior", 

556 "dollarinferior", 

557 "periodinferior", 

558 "commainferior", 

559 "Agravesmall", 

560 "Aacutesmall", 

561 "Acircumflexsmall", 

562 "Atildesmall", 

563 "Adieresissmall", 

564 "Aringsmall", 

565 "AEsmall", 

566 "Ccedillasmall", 

567 "Egravesmall", 

568 "Eacutesmall", 

569 "Ecircumflexsmall", 

570 "Edieresissmall", 

571 "Igravesmall", 

572 "Iacutesmall", 

573 "Icircumflexsmall", 

574 "Idieresissmall", 

575 "Ethsmall", 

576 "Ntildesmall", 

577 "Ogravesmall", 

578 "Oacutesmall", 

579 "Ocircumflexsmall", 

580 "Otildesmall", 

581 "Odieresissmall", 

582 "OEsmall", 

583 "Oslashsmall", 

584 "Ugravesmall", 

585 "Uacutesmall", 

586 "Ucircumflexsmall", 

587 "Udieresissmall", 

588 "Yacutesmall", 

589 "Thornsmall", 

590 "Ydieresissmall", 

591 "001.000", 

592 "001.001", 

593 "001.002", 

594 "001.003", 

595 "Black", 

596 "Bold", 

597 "Book", 

598 "Light", 

599 "Medium", 

600 "Regular", 

601 "Roman", 

602 "Semibold", 

603 ) 

604 

605 class INDEX: 

606 def __init__(self, fp: BinaryIO) -> None: 

607 self.fp = fp 

608 self.offsets: List[int] = [] 

609 (count, offsize) = struct.unpack(">HB", self.fp.read(3)) 

610 for i in range(count + 1): 

611 self.offsets.append(nunpack(self.fp.read(offsize))) 

612 self.base = self.fp.tell() - 1 

613 self.fp.seek(self.base + self.offsets[-1]) 

614 

615 def __repr__(self) -> str: 

616 return "<INDEX: size=%d>" % len(self) 

617 

618 def __len__(self) -> int: 

619 return len(self.offsets) - 1 

620 

621 def __getitem__(self, i: int) -> bytes: 

622 self.fp.seek(self.base + self.offsets[i]) 

623 return self.fp.read(self.offsets[i + 1] - self.offsets[i]) 

624 

625 def __iter__(self) -> Iterator[bytes]: 

626 return iter(self[i] for i in range(len(self))) 

627 

628 def __init__(self, name: str, fp: BinaryIO) -> None: 

629 self.name = name 

630 self.fp = fp 

631 # Header 

632 (_major, _minor, hdrsize, offsize) = struct.unpack("BBBB", self.fp.read(4)) 

633 self.fp.read(hdrsize - 4) 

634 # Name INDEX 

635 self.name_index = self.INDEX(self.fp) 

636 # Top DICT INDEX 

637 self.dict_index = self.INDEX(self.fp) 

638 # String INDEX 

639 self.string_index = self.INDEX(self.fp) 

640 # Global Subr INDEX 

641 self.subr_index = self.INDEX(self.fp) 

642 # Top DICT DATA 

643 self.top_dict = getdict(self.dict_index[0]) 

644 (charset_pos,) = self.top_dict.get(15, [0]) 

645 (encoding_pos,) = self.top_dict.get(16, [0]) 

646 (charstring_pos,) = self.top_dict.get(17, [0]) 

647 # CharStrings 

648 self.fp.seek(cast(int, charstring_pos)) 

649 self.charstring = self.INDEX(self.fp) 

650 self.nglyphs = len(self.charstring) 

651 # Encodings 

652 self.code2gid = {} 

653 self.gid2code = {} 

654 self.fp.seek(cast(int, encoding_pos)) 

655 format = self.fp.read(1) 

656 if format == b"\x00": 

657 # Format 0 

658 (n,) = struct.unpack("B", self.fp.read(1)) 

659 for code, gid in enumerate(struct.unpack("B" * n, self.fp.read(n))): 

660 self.code2gid[code] = gid 

661 self.gid2code[gid] = code 

662 elif format == b"\x01": 

663 # Format 1 

664 (n,) = struct.unpack("B", self.fp.read(1)) 

665 code = 0 

666 for i in range(n): 

667 (first, nleft) = struct.unpack("BB", self.fp.read(2)) 

668 for gid in range(first, first + nleft + 1): 

669 self.code2gid[code] = gid 

670 self.gid2code[gid] = code 

671 code += 1 

672 else: 

673 raise PDFValueError("unsupported encoding format: %r" % format) 

674 # Charsets 

675 self.name2gid = {} 

676 self.gid2name = {} 

677 self.fp.seek(cast(int, charset_pos)) 

678 format = self.fp.read(1) 

679 if format == b"\x00": 

680 # Format 0 

681 n = self.nglyphs - 1 

682 for gid, sid in enumerate( 

683 cast( 

684 Tuple[int, ...], struct.unpack(">" + "H" * n, self.fp.read(2 * n)) 

685 ), 

686 ): 

687 gid += 1 

688 sidname = self.getstr(sid) 

689 self.name2gid[sidname] = gid 

690 self.gid2name[gid] = sidname 

691 elif format == b"\x01": 

692 # Format 1 

693 (n,) = struct.unpack("B", self.fp.read(1)) 

694 sid = 0 

695 for i in range(n): 

696 (first, nleft) = struct.unpack("BB", self.fp.read(2)) 

697 for gid in range(first, first + nleft + 1): 

698 sidname = self.getstr(sid) 

699 self.name2gid[sidname] = gid 

700 self.gid2name[gid] = sidname 

701 sid += 1 

702 elif format == b"\x02": 

703 # Format 2 

704 assert False, str(("Unhandled", format)) 

705 else: 

706 raise PDFValueError("unsupported charset format: %r" % format) 

707 

708 def getstr(self, sid: int) -> Union[str, bytes]: 

709 # This returns str for one of the STANDARD_STRINGS but bytes otherwise, 

710 # and appears to be a needless source of type complexity. 

711 if sid < len(self.STANDARD_STRINGS): 

712 return self.STANDARD_STRINGS[sid] 

713 return self.string_index[sid - len(self.STANDARD_STRINGS)] 

714 

715 

716class TrueTypeFont: 

717 class CMapNotFound(PDFException): 

718 pass 

719 

720 def __init__(self, name: str, fp: BinaryIO) -> None: 

721 self.name = name 

722 self.fp = fp 

723 self.tables: Dict[bytes, Tuple[int, int]] = {} 

724 self.fonttype = fp.read(4) 

725 try: 

726 (ntables, _1, _2, _3) = cast( 

727 Tuple[int, int, int, int], 

728 struct.unpack(">HHHH", fp.read(8)), 

729 ) 

730 for _ in range(ntables): 

731 (name_bytes, tsum, offset, length) = cast( 

732 Tuple[bytes, int, int, int], 

733 struct.unpack(">4sLLL", fp.read(16)), 

734 ) 

735 self.tables[name_bytes] = (offset, length) 

736 except struct.error: 

737 # Do not fail if there are not enough bytes to read. Even for 

738 # corrupted PDFs we would like to get as much information as 

739 # possible, so continue. 

740 pass 

741 

742 def create_unicode_map(self) -> FileUnicodeMap: 

743 if b"cmap" not in self.tables: 

744 raise TrueTypeFont.CMapNotFound 

745 (base_offset, length) = self.tables[b"cmap"] 

746 fp = self.fp 

747 fp.seek(base_offset) 

748 (version, nsubtables) = cast(Tuple[int, int], struct.unpack(">HH", fp.read(4))) 

749 subtables: List[Tuple[int, int, int]] = [] 

750 for i in range(nsubtables): 

751 subtables.append( 

752 cast(Tuple[int, int, int], struct.unpack(">HHL", fp.read(8))), 

753 ) 

754 char2gid: Dict[int, int] = {} 

755 # Only supports subtable type 0, 2 and 4. 

756 for platform_id, encoding_id, st_offset in subtables: 

757 # Skip non-Unicode cmaps. 

758 # https://docs.microsoft.com/en-us/typography/opentype/spec/cmap 

759 if not (platform_id == 0 or (platform_id == 3 and encoding_id in [1, 10])): 

760 continue 

761 fp.seek(base_offset + st_offset) 

762 (fmttype, fmtlen, fmtlang) = cast( 

763 Tuple[int, int, int], 

764 struct.unpack(">HHH", fp.read(6)), 

765 ) 

766 if fmttype == 0: 

767 char2gid.update( 

768 enumerate( 

769 cast(Tuple[int, ...], struct.unpack(">256B", fp.read(256))), 

770 ), 

771 ) 

772 elif fmttype == 2: 

773 subheaderkeys = cast( 

774 Tuple[int, ...], 

775 struct.unpack(">256H", fp.read(512)), 

776 ) 

777 firstbytes = [0] * 8192 

778 for i, k in enumerate(subheaderkeys): 

779 firstbytes[k // 8] = i 

780 nhdrs = max(subheaderkeys) // 8 + 1 

781 hdrs: List[Tuple[int, int, int, int, int]] = [] 

782 for i in range(nhdrs): 

783 (firstcode, entcount, delta, offset) = cast( 

784 Tuple[int, int, int, int], 

785 struct.unpack(">HHhH", fp.read(8)), 

786 ) 

787 hdrs.append((i, firstcode, entcount, delta, fp.tell() - 2 + offset)) 

788 for i, firstcode, entcount, delta, pos in hdrs: 

789 if not entcount: 

790 continue 

791 first = firstcode + (firstbytes[i] << 8) 

792 fp.seek(pos) 

793 for c in range(entcount): 

794 gid = cast(Tuple[int], struct.unpack(">H", fp.read(2)))[0] 

795 if gid: 

796 gid += delta 

797 char2gid[first + c] = gid 

798 elif fmttype == 4: 

799 (segcount, _1, _2, _3) = cast( 

800 Tuple[int, int, int, int], 

801 struct.unpack(">HHHH", fp.read(8)), 

802 ) 

803 segcount //= 2 

804 ecs = cast( 

805 Tuple[int, ...], 

806 struct.unpack(">%dH" % segcount, fp.read(2 * segcount)), 

807 ) 

808 fp.read(2) 

809 scs = cast( 

810 Tuple[int, ...], 

811 struct.unpack(">%dH" % segcount, fp.read(2 * segcount)), 

812 ) 

813 idds = cast( 

814 Tuple[int, ...], 

815 struct.unpack(">%dh" % segcount, fp.read(2 * segcount)), 

816 ) 

817 pos = fp.tell() 

818 idrs = cast( 

819 Tuple[int, ...], 

820 struct.unpack(">%dH" % segcount, fp.read(2 * segcount)), 

821 ) 

822 for ec, sc, idd, idr in zip(ecs, scs, idds, idrs): 

823 if idr: 

824 fp.seek(pos + idr) 

825 for c in range(sc, ec + 1): 

826 b = cast(Tuple[int], struct.unpack(">H", fp.read(2)))[0] 

827 char2gid[c] = (b + idd) & 0xFFFF 

828 else: 

829 for c in range(sc, ec + 1): 

830 char2gid[c] = (c + idd) & 0xFFFF 

831 else: 

832 assert False, str(("Unhandled", fmttype))