| from fontTools.config import OPTIONS |
| from fontTools.misc.textTools import Tag, bytesjoin |
| from .DefaultTable import DefaultTable |
| from enum import IntEnum |
| import sys |
| import array |
| import struct |
| import logging |
| from functools import lru_cache |
| from typing import Iterator, NamedTuple, Optional, Tuple |
| |
| log = logging.getLogger(__name__) |
| |
| have_uharfbuzz = False |
| try: |
| import uharfbuzz as hb |
| |
| # repack method added in uharfbuzz >= 0.23; if uharfbuzz *can* be |
| # imported but repack method is missing, behave as if uharfbuzz |
| # is not available (fallback to the slower Python implementation) |
| have_uharfbuzz = callable(getattr(hb, "repack", None)) |
| except ImportError: |
| pass |
| |
| USE_HARFBUZZ_REPACKER = OPTIONS[f"{__name__}:USE_HARFBUZZ_REPACKER"] |
| |
| |
| class OverflowErrorRecord(object): |
| def __init__(self, overflowTuple): |
| self.tableType = overflowTuple[0] |
| self.LookupListIndex = overflowTuple[1] |
| self.SubTableIndex = overflowTuple[2] |
| self.itemName = overflowTuple[3] |
| self.itemIndex = overflowTuple[4] |
| |
| def __repr__(self): |
| return str( |
| ( |
| self.tableType, |
| "LookupIndex:", |
| self.LookupListIndex, |
| "SubTableIndex:", |
| self.SubTableIndex, |
| "ItemName:", |
| self.itemName, |
| "ItemIndex:", |
| self.itemIndex, |
| ) |
| ) |
| |
| |
| class OTLOffsetOverflowError(Exception): |
| def __init__(self, overflowErrorRecord): |
| self.value = overflowErrorRecord |
| |
| def __str__(self): |
| return repr(self.value) |
| |
| |
| class RepackerState(IntEnum): |
| # Repacking control flow is implemnted using a state machine. The state machine table: |
| # |
| # State | Packing Success | Packing Failed | Exception Raised | |
| # ------------+-----------------+----------------+------------------+ |
| # PURE_FT | Return result | PURE_FT | Return failure | |
| # HB_FT | Return result | HB_FT | FT_FALLBACK | |
| # FT_FALLBACK | HB_FT | FT_FALLBACK | Return failure | |
| |
| # Pack only with fontTools, don't allow sharing between extensions. |
| PURE_FT = 1 |
| |
| # Attempt to pack with harfbuzz (allowing sharing between extensions) |
| # use fontTools to attempt overflow resolution. |
| HB_FT = 2 |
| |
| # Fallback if HB/FT packing gets stuck. Pack only with fontTools, don't allow sharing between |
| # extensions. |
| FT_FALLBACK = 3 |
| |
| |
| class BaseTTXConverter(DefaultTable): |
| """Generic base class for TTX table converters. It functions as an |
| adapter between the TTX (ttLib actually) table model and the model |
| we use for OpenType tables, which is necessarily subtly different. |
| """ |
| |
| def decompile(self, data, font): |
| """Create an object from the binary data. Called automatically on access.""" |
| from . import otTables |
| |
| reader = OTTableReader(data, tableTag=self.tableTag) |
| tableClass = getattr(otTables, self.tableTag) |
| self.table = tableClass() |
| self.table.decompile(reader, font) |
| |
| def compile(self, font): |
| """Compiles the table into binary. Called automatically on save.""" |
| |
| # General outline: |
| # Create a top-level OTTableWriter for the GPOS/GSUB table. |
| # Call the compile method for the the table |
| # for each 'converter' record in the table converter list |
| # call converter's write method for each item in the value. |
| # - For simple items, the write method adds a string to the |
| # writer's self.items list. |
| # - For Struct/Table/Subtable items, it add first adds new writer to the |
| # to the writer's self.items, then calls the item's compile method. |
| # This creates a tree of writers, rooted at the GUSB/GPOS writer, with |
| # each writer representing a table, and the writer.items list containing |
| # the child data strings and writers. |
| # call the getAllData method |
| # call _doneWriting, which removes duplicates |
| # call _gatherTables. This traverses the tables, adding unique occurences to a flat list of tables |
| # Traverse the flat list of tables, calling getDataLength on each to update their position |
| # Traverse the flat list of tables again, calling getData each get the data in the table, now that |
| # pos's and offset are known. |
| |
| # If a lookup subtable overflows an offset, we have to start all over. |
| overflowRecord = None |
| # this is 3-state option: default (None) means automatically use hb.repack or |
| # silently fall back if it fails; True, use it and raise error if not possible |
| # or it errors out; False, don't use it, even if you can. |
| use_hb_repack = font.cfg[USE_HARFBUZZ_REPACKER] |
| if self.tableTag in ("GSUB", "GPOS"): |
| if use_hb_repack is False: |
| log.debug( |
| "hb.repack disabled, compiling '%s' with pure-python serializer", |
| self.tableTag, |
| ) |
| elif not have_uharfbuzz: |
| if use_hb_repack is True: |
| raise ImportError("No module named 'uharfbuzz'") |
| else: |
| assert use_hb_repack is None |
| log.debug( |
| "uharfbuzz not found, compiling '%s' with pure-python serializer", |
| self.tableTag, |
| ) |
| |
| if ( |
| use_hb_repack in (None, True) |
| and have_uharfbuzz |
| and self.tableTag in ("GSUB", "GPOS") |
| ): |
| state = RepackerState.HB_FT |
| else: |
| state = RepackerState.PURE_FT |
| |
| hb_first_error_logged = False |
| lastOverflowRecord = None |
| while True: |
| try: |
| writer = OTTableWriter(tableTag=self.tableTag) |
| self.table.compile(writer, font) |
| if state == RepackerState.HB_FT: |
| return self.tryPackingHarfbuzz(writer, hb_first_error_logged) |
| elif state == RepackerState.PURE_FT: |
| return self.tryPackingFontTools(writer) |
| elif state == RepackerState.FT_FALLBACK: |
| # Run packing with FontTools only, but don't return the result as it will |
| # not be optimally packed. Once a successful packing has been found, state is |
| # changed back to harfbuzz packing to produce the final, optimal, packing. |
| self.tryPackingFontTools(writer) |
| log.debug( |
| "Re-enabling sharing between extensions and switching back to " |
| "harfbuzz+fontTools packing." |
| ) |
| state = RepackerState.HB_FT |
| |
| except OTLOffsetOverflowError as e: |
| hb_first_error_logged = True |
| ok = self.tryResolveOverflow(font, e, lastOverflowRecord) |
| lastOverflowRecord = e.value |
| |
| if ok: |
| continue |
| |
| if state is RepackerState.HB_FT: |
| log.debug( |
| "Harfbuzz packing out of resolutions, disabling sharing between extensions and " |
| "switching to fontTools only packing." |
| ) |
| state = RepackerState.FT_FALLBACK |
| else: |
| raise |
| |
| def tryPackingHarfbuzz(self, writer, hb_first_error_logged): |
| try: |
| log.debug("serializing '%s' with hb.repack", self.tableTag) |
| return writer.getAllDataUsingHarfbuzz(self.tableTag) |
| except (ValueError, MemoryError, hb.RepackerError) as e: |
| # Only log hb repacker errors the first time they occur in |
| # the offset-overflow resolution loop, they are just noisy. |
| # Maybe we can revisit this if/when uharfbuzz actually gives |
| # us more info as to why hb.repack failed... |
| if not hb_first_error_logged: |
| error_msg = f"{type(e).__name__}" |
| if str(e) != "": |
| error_msg += f": {e}" |
| log.warning( |
| "hb.repack failed to serialize '%s', attempting fonttools resolutions " |
| "; the error message was: %s", |
| self.tableTag, |
| error_msg, |
| ) |
| hb_first_error_logged = True |
| return writer.getAllData(remove_duplicate=False) |
| |
| def tryPackingFontTools(self, writer): |
| return writer.getAllData() |
| |
| def tryResolveOverflow(self, font, e, lastOverflowRecord): |
| ok = 0 |
| if lastOverflowRecord == e.value: |
| # Oh well... |
| return ok |
| |
| overflowRecord = e.value |
| log.info("Attempting to fix OTLOffsetOverflowError %s", e) |
| |
| if overflowRecord.itemName is None: |
| from .otTables import fixLookupOverFlows |
| |
| ok = fixLookupOverFlows(font, overflowRecord) |
| else: |
| from .otTables import fixSubTableOverFlows |
| |
| ok = fixSubTableOverFlows(font, overflowRecord) |
| |
| if ok: |
| return ok |
| |
| # Try upgrading lookup to Extension and hope |
| # that cross-lookup sharing not happening would |
| # fix overflow... |
| from .otTables import fixLookupOverFlows |
| |
| return fixLookupOverFlows(font, overflowRecord) |
| |
| def toXML(self, writer, font): |
| self.table.toXML2(writer, font) |
| |
| def fromXML(self, name, attrs, content, font): |
| from . import otTables |
| |
| if not hasattr(self, "table"): |
| tableClass = getattr(otTables, self.tableTag) |
| self.table = tableClass() |
| self.table.fromXML(name, attrs, content, font) |
| self.table.populateDefaults() |
| |
| def ensureDecompiled(self, recurse=True): |
| self.table.ensureDecompiled(recurse=recurse) |
| |
| |
| # https://github.com/fonttools/fonttools/pull/2285#issuecomment-834652928 |
| assert len(struct.pack("i", 0)) == 4 |
| assert array.array("i").itemsize == 4, "Oops, file a bug against fonttools." |
| |
| |
| class OTTableReader(object): |
| """Helper class to retrieve data from an OpenType table.""" |
| |
| __slots__ = ("data", "offset", "pos", "localState", "tableTag") |
| |
| def __init__(self, data, localState=None, offset=0, tableTag=None): |
| self.data = data |
| self.offset = offset |
| self.pos = offset |
| self.localState = localState |
| self.tableTag = tableTag |
| |
| def advance(self, count): |
| self.pos += count |
| |
| def seek(self, pos): |
| self.pos = pos |
| |
| def copy(self): |
| other = self.__class__(self.data, self.localState, self.offset, self.tableTag) |
| other.pos = self.pos |
| return other |
| |
| def getSubReader(self, offset): |
| offset = self.offset + offset |
| return self.__class__(self.data, self.localState, offset, self.tableTag) |
| |
| def readValue(self, typecode, staticSize): |
| pos = self.pos |
| newpos = pos + staticSize |
| (value,) = struct.unpack(f">{typecode}", self.data[pos:newpos]) |
| self.pos = newpos |
| return value |
| |
| def readArray(self, typecode, staticSize, count): |
| pos = self.pos |
| newpos = pos + count * staticSize |
| value = array.array(typecode, self.data[pos:newpos]) |
| if sys.byteorder != "big": |
| value.byteswap() |
| self.pos = newpos |
| return value.tolist() |
| |
| def readInt8(self): |
| return self.readValue("b", staticSize=1) |
| |
| def readInt8Array(self, count): |
| return self.readArray("b", staticSize=1, count=count) |
| |
| def readShort(self): |
| return self.readValue("h", staticSize=2) |
| |
| def readShortArray(self, count): |
| return self.readArray("h", staticSize=2, count=count) |
| |
| def readLong(self): |
| return self.readValue("i", staticSize=4) |
| |
| def readLongArray(self, count): |
| return self.readArray("i", staticSize=4, count=count) |
| |
| def readUInt8(self): |
| return self.readValue("B", staticSize=1) |
| |
| def readUInt8Array(self, count): |
| return self.readArray("B", staticSize=1, count=count) |
| |
| def readUShort(self): |
| return self.readValue("H", staticSize=2) |
| |
| def readUShortArray(self, count): |
| return self.readArray("H", staticSize=2, count=count) |
| |
| def readULong(self): |
| return self.readValue("I", staticSize=4) |
| |
| def readULongArray(self, count): |
| return self.readArray("I", staticSize=4, count=count) |
| |
| def readUInt24(self): |
| pos = self.pos |
| newpos = pos + 3 |
| (value,) = struct.unpack(">l", b"\0" + self.data[pos:newpos]) |
| self.pos = newpos |
| return value |
| |
| def readUInt24Array(self, count): |
| return [self.readUInt24() for _ in range(count)] |
| |
| def readTag(self): |
| pos = self.pos |
| newpos = pos + 4 |
| value = Tag(self.data[pos:newpos]) |
| assert len(value) == 4, value |
| self.pos = newpos |
| return value |
| |
| def readData(self, count): |
| pos = self.pos |
| newpos = pos + count |
| value = self.data[pos:newpos] |
| self.pos = newpos |
| return value |
| |
| def __setitem__(self, name, value): |
| state = self.localState.copy() if self.localState else dict() |
| state[name] = value |
| self.localState = state |
| |
| def __getitem__(self, name): |
| return self.localState and self.localState[name] |
| |
| def __contains__(self, name): |
| return self.localState and name in self.localState |
| |
| |
| class OffsetToWriter(object): |
| def __init__(self, subWriter, offsetSize): |
| self.subWriter = subWriter |
| self.offsetSize = offsetSize |
| |
| def __eq__(self, other): |
| if type(self) != type(other): |
| return NotImplemented |
| return self.subWriter == other.subWriter and self.offsetSize == other.offsetSize |
| |
| def __hash__(self): |
| # only works after self._doneWriting() has been called |
| return hash((self.subWriter, self.offsetSize)) |
| |
| |
| class OTTableWriter(object): |
| """Helper class to gather and assemble data for OpenType tables.""" |
| |
| def __init__(self, localState=None, tableTag=None): |
| self.items = [] |
| self.pos = None |
| self.localState = localState |
| self.tableTag = tableTag |
| self.parent = None |
| |
| def __setitem__(self, name, value): |
| state = self.localState.copy() if self.localState else dict() |
| state[name] = value |
| self.localState = state |
| |
| def __getitem__(self, name): |
| return self.localState[name] |
| |
| def __delitem__(self, name): |
| del self.localState[name] |
| |
| # assembler interface |
| |
| def getDataLength(self): |
| """Return the length of this table in bytes, without subtables.""" |
| l = 0 |
| for item in self.items: |
| if hasattr(item, "getCountData"): |
| l += item.size |
| elif hasattr(item, "subWriter"): |
| l += item.offsetSize |
| else: |
| l = l + len(item) |
| return l |
| |
| def getData(self): |
| """Assemble the data for this writer/table, without subtables.""" |
| items = list(self.items) # make a shallow copy |
| pos = self.pos |
| numItems = len(items) |
| for i in range(numItems): |
| item = items[i] |
| |
| if hasattr(item, "subWriter"): |
| if item.offsetSize == 4: |
| items[i] = packULong(item.subWriter.pos - pos) |
| elif item.offsetSize == 2: |
| try: |
| items[i] = packUShort(item.subWriter.pos - pos) |
| except struct.error: |
| # provide data to fix overflow problem. |
| overflowErrorRecord = self.getOverflowErrorRecord( |
| item.subWriter |
| ) |
| |
| raise OTLOffsetOverflowError(overflowErrorRecord) |
| elif item.offsetSize == 3: |
| items[i] = packUInt24(item.subWriter.pos - pos) |
| else: |
| raise ValueError(item.offsetSize) |
| |
| return bytesjoin(items) |
| |
| def getDataForHarfbuzz(self): |
| """Assemble the data for this writer/table with all offset field set to 0""" |
| items = list(self.items) |
| packFuncs = {2: packUShort, 3: packUInt24, 4: packULong} |
| for i, item in enumerate(items): |
| if hasattr(item, "subWriter"): |
| # Offset value is not needed in harfbuzz repacker, so setting offset to 0 to avoid overflow here |
| if item.offsetSize in packFuncs: |
| items[i] = packFuncs[item.offsetSize](0) |
| else: |
| raise ValueError(item.offsetSize) |
| |
| return bytesjoin(items) |
| |
| def __hash__(self): |
| # only works after self._doneWriting() has been called |
| return hash(self.items) |
| |
| def __ne__(self, other): |
| result = self.__eq__(other) |
| return result if result is NotImplemented else not result |
| |
| def __eq__(self, other): |
| if type(self) != type(other): |
| return NotImplemented |
| return self.items == other.items |
| |
| def _doneWriting(self, internedTables, shareExtension=False): |
| # Convert CountData references to data string items |
| # collapse duplicate table references to a unique entry |
| # "tables" are OTTableWriter objects. |
| |
| # For Extension Lookup types, we can |
| # eliminate duplicates only within the tree under the Extension Lookup, |
| # as offsets may exceed 64K even between Extension LookupTable subtables. |
| isExtension = hasattr(self, "Extension") |
| |
| # Certain versions of Uniscribe reject the font if the GSUB/GPOS top-level |
| # arrays (ScriptList, FeatureList, LookupList) point to the same, possibly |
| # empty, array. So, we don't share those. |
| # See: https://github.com/fonttools/fonttools/issues/518 |
| dontShare = hasattr(self, "DontShare") |
| |
| if isExtension and not shareExtension: |
| internedTables = {} |
| |
| items = self.items |
| for i in range(len(items)): |
| item = items[i] |
| if hasattr(item, "getCountData"): |
| items[i] = item.getCountData() |
| elif hasattr(item, "subWriter"): |
| item.subWriter._doneWriting( |
| internedTables, shareExtension=shareExtension |
| ) |
| # At this point, all subwriters are hashable based on their items. |
| # (See hash and comparison magic methods above.) So the ``setdefault`` |
| # call here will return the first writer object we've seen with |
| # equal content, or store it in the dictionary if it's not been |
| # seen yet. We therefore replace the subwriter object with an equivalent |
| # object, which deduplicates the tree. |
| if not dontShare: |
| items[i].subWriter = internedTables.setdefault( |
| item.subWriter, item.subWriter |
| ) |
| self.items = tuple(items) |
| |
| def _gatherTables(self, tables, extTables, done): |
| # Convert table references in self.items tree to a flat |
| # list of tables in depth-first traversal order. |
| # "tables" are OTTableWriter objects. |
| # We do the traversal in reverse order at each level, in order to |
| # resolve duplicate references to be the last reference in the list of tables. |
| # For extension lookups, duplicate references can be merged only within the |
| # writer tree under the extension lookup. |
| |
| done[id(self)] = True |
| |
| numItems = len(self.items) |
| iRange = list(range(numItems)) |
| iRange.reverse() |
| |
| isExtension = hasattr(self, "Extension") |
| |
| selfTables = tables |
| |
| if isExtension: |
| assert ( |
| extTables is not None |
| ), "Program or XML editing error. Extension subtables cannot contain extensions subtables" |
| tables, extTables, done = extTables, None, {} |
| |
| # add Coverage table if it is sorted last. |
| sortCoverageLast = False |
| if hasattr(self, "sortCoverageLast"): |
| # Find coverage table |
| for i in range(numItems): |
| item = self.items[i] |
| if ( |
| hasattr(item, "subWriter") |
| and getattr(item.subWriter, "name", None) == "Coverage" |
| ): |
| sortCoverageLast = True |
| break |
| if id(item.subWriter) not in done: |
| item.subWriter._gatherTables(tables, extTables, done) |
| else: |
| # We're a new parent of item |
| pass |
| |
| for i in iRange: |
| item = self.items[i] |
| if not hasattr(item, "subWriter"): |
| continue |
| |
| if ( |
| sortCoverageLast |
| and (i == 1) |
| and getattr(item.subWriter, "name", None) == "Coverage" |
| ): |
| # we've already 'gathered' it above |
| continue |
| |
| if id(item.subWriter) not in done: |
| item.subWriter._gatherTables(tables, extTables, done) |
| else: |
| # Item is already written out by other parent |
| pass |
| |
| selfTables.append(self) |
| |
| def _gatherGraphForHarfbuzz(self, tables, obj_list, done, objidx, virtual_edges): |
| real_links = [] |
| virtual_links = [] |
| item_idx = objidx |
| |
| # Merge virtual_links from parent |
| for idx in virtual_edges: |
| virtual_links.append((0, 0, idx)) |
| |
| sortCoverageLast = False |
| coverage_idx = 0 |
| if hasattr(self, "sortCoverageLast"): |
| # Find coverage table |
| for i, item in enumerate(self.items): |
| if getattr(item, "name", None) == "Coverage": |
| sortCoverageLast = True |
| if id(item) not in done: |
| coverage_idx = item_idx = item._gatherGraphForHarfbuzz( |
| tables, obj_list, done, item_idx, virtual_edges |
| ) |
| else: |
| coverage_idx = done[id(item)] |
| virtual_edges.append(coverage_idx) |
| break |
| |
| child_idx = 0 |
| offset_pos = 0 |
| for i, item in enumerate(self.items): |
| if hasattr(item, "subWriter"): |
| pos = offset_pos |
| elif hasattr(item, "getCountData"): |
| offset_pos += item.size |
| continue |
| else: |
| offset_pos = offset_pos + len(item) |
| continue |
| |
| if id(item.subWriter) not in done: |
| child_idx = item_idx = item.subWriter._gatherGraphForHarfbuzz( |
| tables, obj_list, done, item_idx, virtual_edges |
| ) |
| else: |
| child_idx = done[id(item.subWriter)] |
| |
| real_edge = (pos, item.offsetSize, child_idx) |
| real_links.append(real_edge) |
| offset_pos += item.offsetSize |
| |
| tables.append(self) |
| obj_list.append((real_links, virtual_links)) |
| item_idx += 1 |
| done[id(self)] = item_idx |
| if sortCoverageLast: |
| virtual_edges.pop() |
| |
| return item_idx |
| |
| def getAllDataUsingHarfbuzz(self, tableTag): |
| """The Whole table is represented as a Graph. |
| Assemble graph data and call Harfbuzz repacker to pack the table. |
| Harfbuzz repacker is faster and retain as much sub-table sharing as possible, see also: |
| https://github.com/harfbuzz/harfbuzz/blob/main/docs/repacker.md |
| The input format for hb.repack() method is explained here: |
| https://github.com/harfbuzz/uharfbuzz/blob/main/src/uharfbuzz/_harfbuzz.pyx#L1149 |
| """ |
| internedTables = {} |
| self._doneWriting(internedTables, shareExtension=True) |
| tables = [] |
| obj_list = [] |
| done = {} |
| objidx = 0 |
| virtual_edges = [] |
| self._gatherGraphForHarfbuzz(tables, obj_list, done, objidx, virtual_edges) |
| # Gather all data in two passes: the absolute positions of all |
| # subtable are needed before the actual data can be assembled. |
| pos = 0 |
| for table in tables: |
| table.pos = pos |
| pos = pos + table.getDataLength() |
| |
| data = [] |
| for table in tables: |
| tableData = table.getDataForHarfbuzz() |
| data.append(tableData) |
| |
| if hasattr(hb, "repack_with_tag"): |
| return hb.repack_with_tag(str(tableTag), data, obj_list) |
| else: |
| return hb.repack(data, obj_list) |
| |
| def getAllData(self, remove_duplicate=True): |
| """Assemble all data, including all subtables.""" |
| if remove_duplicate: |
| internedTables = {} |
| self._doneWriting(internedTables) |
| tables = [] |
| extTables = [] |
| done = {} |
| self._gatherTables(tables, extTables, done) |
| tables.reverse() |
| extTables.reverse() |
| # Gather all data in two passes: the absolute positions of all |
| # subtable are needed before the actual data can be assembled. |
| pos = 0 |
| for table in tables: |
| table.pos = pos |
| pos = pos + table.getDataLength() |
| |
| for table in extTables: |
| table.pos = pos |
| pos = pos + table.getDataLength() |
| |
| data = [] |
| for table in tables: |
| tableData = table.getData() |
| data.append(tableData) |
| |
| for table in extTables: |
| tableData = table.getData() |
| data.append(tableData) |
| |
| return bytesjoin(data) |
| |
| # interface for gathering data, as used by table.compile() |
| |
| def getSubWriter(self): |
| subwriter = self.__class__(self.localState, self.tableTag) |
| subwriter.parent = ( |
| self # because some subtables have idential values, we discard |
| ) |
| # the duplicates under the getAllData method. Hence some |
| # subtable writers can have more than one parent writer. |
| # But we just care about first one right now. |
| return subwriter |
| |
| def writeValue(self, typecode, value): |
| self.items.append(struct.pack(f">{typecode}", value)) |
| |
| def writeArray(self, typecode, values): |
| a = array.array(typecode, values) |
| if sys.byteorder != "big": |
| a.byteswap() |
| self.items.append(a.tobytes()) |
| |
| def writeInt8(self, value): |
| assert -128 <= value < 128, value |
| self.items.append(struct.pack(">b", value)) |
| |
| def writeInt8Array(self, values): |
| self.writeArray("b", values) |
| |
| def writeShort(self, value): |
| assert -32768 <= value < 32768, value |
| self.items.append(struct.pack(">h", value)) |
| |
| def writeShortArray(self, values): |
| self.writeArray("h", values) |
| |
| def writeLong(self, value): |
| self.items.append(struct.pack(">i", value)) |
| |
| def writeLongArray(self, values): |
| self.writeArray("i", values) |
| |
| def writeUInt8(self, value): |
| assert 0 <= value < 256, value |
| self.items.append(struct.pack(">B", value)) |
| |
| def writeUInt8Array(self, values): |
| self.writeArray("B", values) |
| |
| def writeUShort(self, value): |
| assert 0 <= value < 0x10000, value |
| self.items.append(struct.pack(">H", value)) |
| |
| def writeUShortArray(self, values): |
| self.writeArray("H", values) |
| |
| def writeULong(self, value): |
| self.items.append(struct.pack(">I", value)) |
| |
| def writeULongArray(self, values): |
| self.writeArray("I", values) |
| |
| def writeUInt24(self, value): |
| assert 0 <= value < 0x1000000, value |
| b = struct.pack(">L", value) |
| self.items.append(b[1:]) |
| |
| def writeUInt24Array(self, values): |
| for value in values: |
| self.writeUInt24(value) |
| |
| def writeTag(self, tag): |
| tag = Tag(tag).tobytes() |
| assert len(tag) == 4, tag |
| self.items.append(tag) |
| |
| def writeSubTable(self, subWriter, offsetSize): |
| self.items.append(OffsetToWriter(subWriter, offsetSize)) |
| |
| def writeCountReference(self, table, name, size=2, value=None): |
| ref = CountReference(table, name, size=size, value=value) |
| self.items.append(ref) |
| return ref |
| |
| def writeStruct(self, format, values): |
| data = struct.pack(*(format,) + values) |
| self.items.append(data) |
| |
| def writeData(self, data): |
| self.items.append(data) |
| |
| def getOverflowErrorRecord(self, item): |
| LookupListIndex = SubTableIndex = itemName = itemIndex = None |
| if self.name == "LookupList": |
| LookupListIndex = item.repeatIndex |
| elif self.name == "Lookup": |
| LookupListIndex = self.repeatIndex |
| SubTableIndex = item.repeatIndex |
| else: |
| itemName = getattr(item, "name", "<none>") |
| if hasattr(item, "repeatIndex"): |
| itemIndex = item.repeatIndex |
| if self.name == "SubTable": |
| LookupListIndex = self.parent.repeatIndex |
| SubTableIndex = self.repeatIndex |
| elif self.name == "ExtSubTable": |
| LookupListIndex = self.parent.parent.repeatIndex |
| SubTableIndex = self.parent.repeatIndex |
| else: # who knows how far below the SubTable level we are! Climb back up to the nearest subtable. |
| itemName = ".".join([self.name, itemName]) |
| p1 = self.parent |
| while p1 and p1.name not in ["ExtSubTable", "SubTable"]: |
| itemName = ".".join([p1.name, itemName]) |
| p1 = p1.parent |
| if p1: |
| if p1.name == "ExtSubTable": |
| LookupListIndex = p1.parent.parent.repeatIndex |
| SubTableIndex = p1.parent.repeatIndex |
| else: |
| LookupListIndex = p1.parent.repeatIndex |
| SubTableIndex = p1.repeatIndex |
| |
| return OverflowErrorRecord( |
| (self.tableTag, LookupListIndex, SubTableIndex, itemName, itemIndex) |
| ) |
| |
| |
| class CountReference(object): |
| """A reference to a Count value, not a count of references.""" |
| |
| def __init__(self, table, name, size=None, value=None): |
| self.table = table |
| self.name = name |
| self.size = size |
| if value is not None: |
| self.setValue(value) |
| |
| def setValue(self, value): |
| table = self.table |
| name = self.name |
| if table[name] is None: |
| table[name] = value |
| else: |
| assert table[name] == value, (name, table[name], value) |
| |
| def getValue(self): |
| return self.table[self.name] |
| |
| def getCountData(self): |
| v = self.table[self.name] |
| if v is None: |
| v = 0 |
| return {1: packUInt8, 2: packUShort, 4: packULong}[self.size](v) |
| |
| |
| def packUInt8(value): |
| return struct.pack(">B", value) |
| |
| |
| def packUShort(value): |
| return struct.pack(">H", value) |
| |
| |
| def packULong(value): |
| assert 0 <= value < 0x100000000, value |
| return struct.pack(">I", value) |
| |
| |
| def packUInt24(value): |
| assert 0 <= value < 0x1000000, value |
| return struct.pack(">I", value)[1:] |
| |
| |
| class BaseTable(object): |
| """Generic base class for all OpenType (sub)tables.""" |
| |
| def __getattr__(self, attr): |
| reader = self.__dict__.get("reader") |
| if reader: |
| del self.reader |
| font = self.font |
| del self.font |
| self.decompile(reader, font) |
| return getattr(self, attr) |
| |
| raise AttributeError(attr) |
| |
| def ensureDecompiled(self, recurse=False): |
| reader = self.__dict__.get("reader") |
| if reader: |
| del self.reader |
| font = self.font |
| del self.font |
| self.decompile(reader, font) |
| if recurse: |
| for subtable in self.iterSubTables(): |
| subtable.value.ensureDecompiled(recurse) |
| |
| def __getstate__(self): |
| # before copying/pickling 'lazy' objects, make a shallow copy of OTTableReader |
| # https://github.com/fonttools/fonttools/issues/2965 |
| if "reader" in self.__dict__: |
| state = self.__dict__.copy() |
| state["reader"] = self.__dict__["reader"].copy() |
| return state |
| return self.__dict__ |
| |
| @classmethod |
| def getRecordSize(cls, reader): |
| totalSize = 0 |
| for conv in cls.converters: |
| size = conv.getRecordSize(reader) |
| if size is NotImplemented: |
| return NotImplemented |
| countValue = 1 |
| if conv.repeat: |
| if conv.repeat in reader: |
| countValue = reader[conv.repeat] + conv.aux |
| else: |
| return NotImplemented |
| totalSize += size * countValue |
| return totalSize |
| |
| def getConverters(self): |
| return self.converters |
| |
| def getConverterByName(self, name): |
| return self.convertersByName[name] |
| |
| def populateDefaults(self, propagator=None): |
| for conv in self.getConverters(): |
| if conv.repeat: |
| if not hasattr(self, conv.name): |
| setattr(self, conv.name, []) |
| countValue = len(getattr(self, conv.name)) - conv.aux |
| try: |
| count_conv = self.getConverterByName(conv.repeat) |
| setattr(self, conv.repeat, countValue) |
| except KeyError: |
| # conv.repeat is a propagated count |
| if propagator and conv.repeat in propagator: |
| propagator[conv.repeat].setValue(countValue) |
| else: |
| if conv.aux and not eval(conv.aux, None, self.__dict__): |
| continue |
| if hasattr(self, conv.name): |
| continue # Warn if it should NOT be present?! |
| if hasattr(conv, "writeNullOffset"): |
| setattr(self, conv.name, None) # Warn? |
| # elif not conv.isCount: |
| # # Warn? |
| # pass |
| if hasattr(conv, "DEFAULT"): |
| # OptionalValue converters (e.g. VarIndex) |
| setattr(self, conv.name, conv.DEFAULT) |
| |
| def decompile(self, reader, font): |
| self.readFormat(reader) |
| table = {} |
| self.__rawTable = table # for debugging |
| for conv in self.getConverters(): |
| if conv.name == "SubTable": |
| conv = conv.getConverter(reader.tableTag, table["LookupType"]) |
| if conv.name == "ExtSubTable": |
| conv = conv.getConverter(reader.tableTag, table["ExtensionLookupType"]) |
| if conv.name == "FeatureParams": |
| conv = conv.getConverter(reader["FeatureTag"]) |
| if conv.name == "SubStruct": |
| conv = conv.getConverter(reader.tableTag, table["MorphType"]) |
| try: |
| if conv.repeat: |
| if isinstance(conv.repeat, int): |
| countValue = conv.repeat |
| elif conv.repeat in table: |
| countValue = table[conv.repeat] |
| else: |
| # conv.repeat is a propagated count |
| countValue = reader[conv.repeat] |
| countValue += conv.aux |
| table[conv.name] = conv.readArray(reader, font, table, countValue) |
| else: |
| if conv.aux and not eval(conv.aux, None, table): |
| continue |
| table[conv.name] = conv.read(reader, font, table) |
| if conv.isPropagated: |
| reader[conv.name] = table[conv.name] |
| except Exception as e: |
| name = conv.name |
| e.args = e.args + (name,) |
| raise |
| |
| if hasattr(self, "postRead"): |
| self.postRead(table, font) |
| else: |
| self.__dict__.update(table) |
| |
| del self.__rawTable # succeeded, get rid of debugging info |
| |
| def compile(self, writer, font): |
| self.ensureDecompiled() |
| # TODO Following hack to be removed by rewriting how FormatSwitching tables |
| # are handled. |
| # https://github.com/fonttools/fonttools/pull/2238#issuecomment-805192631 |
| if hasattr(self, "preWrite"): |
| deleteFormat = not hasattr(self, "Format") |
| table = self.preWrite(font) |
| deleteFormat = deleteFormat and hasattr(self, "Format") |
| else: |
| deleteFormat = False |
| table = self.__dict__.copy() |
| |
| # some count references may have been initialized in a custom preWrite; we set |
| # these in the writer's state beforehand (instead of sequentially) so they will |
| # be propagated to all nested subtables even if the count appears in the current |
| # table only *after* the offset to the subtable that it is counting. |
| for conv in self.getConverters(): |
| if conv.isCount and conv.isPropagated: |
| value = table.get(conv.name) |
| if isinstance(value, CountReference): |
| writer[conv.name] = value |
| |
| if hasattr(self, "sortCoverageLast"): |
| writer.sortCoverageLast = 1 |
| |
| if hasattr(self, "DontShare"): |
| writer.DontShare = True |
| |
| if hasattr(self.__class__, "LookupType"): |
| writer["LookupType"].setValue(self.__class__.LookupType) |
| |
| self.writeFormat(writer) |
| for conv in self.getConverters(): |
| value = table.get( |
| conv.name |
| ) # TODO Handle defaults instead of defaulting to None! |
| if conv.repeat: |
| if value is None: |
| value = [] |
| countValue = len(value) - conv.aux |
| if isinstance(conv.repeat, int): |
| assert len(value) == conv.repeat, "expected %d values, got %d" % ( |
| conv.repeat, |
| len(value), |
| ) |
| elif conv.repeat in table: |
| CountReference(table, conv.repeat, value=countValue) |
| else: |
| # conv.repeat is a propagated count |
| writer[conv.repeat].setValue(countValue) |
| try: |
| conv.writeArray(writer, font, table, value) |
| except Exception as e: |
| e.args = e.args + (conv.name + "[]",) |
| raise |
| elif conv.isCount: |
| # Special-case Count values. |
| # Assumption: a Count field will *always* precede |
| # the actual array(s). |
| # We need a default value, as it may be set later by a nested |
| # table. We will later store it here. |
| # We add a reference: by the time the data is assembled |
| # the Count value will be filled in. |
| # We ignore the current count value since it will be recomputed, |
| # unless it's a CountReference that was already initialized in a custom preWrite. |
| if isinstance(value, CountReference): |
| ref = value |
| ref.size = conv.staticSize |
| writer.writeData(ref) |
| table[conv.name] = ref.getValue() |
| else: |
| ref = writer.writeCountReference(table, conv.name, conv.staticSize) |
| table[conv.name] = None |
| if conv.isPropagated: |
| writer[conv.name] = ref |
| elif conv.isLookupType: |
| # We make sure that subtables have the same lookup type, |
| # and that the type is the same as the one set on the |
| # Lookup object, if any is set. |
| if conv.name not in table: |
| table[conv.name] = None |
| ref = writer.writeCountReference( |
| table, conv.name, conv.staticSize, table[conv.name] |
| ) |
| writer["LookupType"] = ref |
| else: |
| if conv.aux and not eval(conv.aux, None, table): |
| continue |
| try: |
| conv.write(writer, font, table, value) |
| except Exception as e: |
| name = value.__class__.__name__ if value is not None else conv.name |
| e.args = e.args + (name,) |
| raise |
| if conv.isPropagated: |
| writer[conv.name] = value |
| |
| if deleteFormat: |
| del self.Format |
| |
| def readFormat(self, reader): |
| pass |
| |
| def writeFormat(self, writer): |
| pass |
| |
| def toXML(self, xmlWriter, font, attrs=None, name=None): |
| tableName = name if name else self.__class__.__name__ |
| if attrs is None: |
| attrs = [] |
| if hasattr(self, "Format"): |
| attrs = attrs + [("Format", self.Format)] |
| xmlWriter.begintag(tableName, attrs) |
| xmlWriter.newline() |
| self.toXML2(xmlWriter, font) |
| xmlWriter.endtag(tableName) |
| xmlWriter.newline() |
| |
| def toXML2(self, xmlWriter, font): |
| # Simpler variant of toXML, *only* for the top level tables (like GPOS, GSUB). |
| # This is because in TTX our parent writes our main tag, and in otBase.py we |
| # do it ourselves. I think I'm getting schizophrenic... |
| for conv in self.getConverters(): |
| if conv.repeat: |
| value = getattr(self, conv.name, []) |
| for i in range(len(value)): |
| item = value[i] |
| conv.xmlWrite(xmlWriter, font, item, conv.name, [("index", i)]) |
| else: |
| if conv.aux and not eval(conv.aux, None, vars(self)): |
| continue |
| value = getattr( |
| self, conv.name, None |
| ) # TODO Handle defaults instead of defaulting to None! |
| conv.xmlWrite(xmlWriter, font, value, conv.name, []) |
| |
| def fromXML(self, name, attrs, content, font): |
| try: |
| conv = self.getConverterByName(name) |
| except KeyError: |
| raise # XXX on KeyError, raise nice error |
| value = conv.xmlRead(attrs, content, font) |
| if conv.repeat: |
| seq = getattr(self, conv.name, None) |
| if seq is None: |
| seq = [] |
| setattr(self, conv.name, seq) |
| seq.append(value) |
| else: |
| setattr(self, conv.name, value) |
| |
| def __ne__(self, other): |
| result = self.__eq__(other) |
| return result if result is NotImplemented else not result |
| |
| def __eq__(self, other): |
| if type(self) != type(other): |
| return NotImplemented |
| |
| self.ensureDecompiled() |
| other.ensureDecompiled() |
| |
| return self.__dict__ == other.__dict__ |
| |
| class SubTableEntry(NamedTuple): |
| """See BaseTable.iterSubTables()""" |
| |
| name: str |
| value: "BaseTable" |
| index: Optional[int] = None # index into given array, None for single values |
| |
| def iterSubTables(self) -> Iterator[SubTableEntry]: |
| """Yield (name, value, index) namedtuples for all subtables of current table. |
| |
| A sub-table is an instance of BaseTable (or subclass thereof) that is a child |
| of self, the current parent table. |
| The tuples also contain the attribute name (str) of the of parent table to get |
| a subtable, and optionally, for lists of subtables (i.e. attributes associated |
| with a converter that has a 'repeat'), an index into the list containing the |
| given subtable value. |
| This method can be useful to traverse trees of otTables. |
| """ |
| for conv in self.getConverters(): |
| name = conv.name |
| value = getattr(self, name, None) |
| if value is None: |
| continue |
| if isinstance(value, BaseTable): |
| yield self.SubTableEntry(name, value) |
| elif isinstance(value, list): |
| yield from ( |
| self.SubTableEntry(name, v, index=i) |
| for i, v in enumerate(value) |
| if isinstance(v, BaseTable) |
| ) |
| |
| # instance (not @class)method for consistency with FormatSwitchingBaseTable |
| def getVariableAttrs(self): |
| return getVariableAttrs(self.__class__) |
| |
| |
| class FormatSwitchingBaseTable(BaseTable): |
| """Minor specialization of BaseTable, for tables that have multiple |
| formats, eg. CoverageFormat1 vs. CoverageFormat2.""" |
| |
| @classmethod |
| def getRecordSize(cls, reader): |
| return NotImplemented |
| |
| def getConverters(self): |
| try: |
| fmt = self.Format |
| except AttributeError: |
| # some FormatSwitchingBaseTables (e.g. Coverage) no longer have 'Format' |
| # attribute after fully decompiled, only gain one in preWrite before being |
| # recompiled. In the decompiled state, these hand-coded classes defined in |
| # otTables.py lose their format-specific nature and gain more high-level |
| # attributes that are not tied to converters. |
| return [] |
| return self.converters.get(self.Format, []) |
| |
| def getConverterByName(self, name): |
| return self.convertersByName[self.Format][name] |
| |
| def readFormat(self, reader): |
| self.Format = reader.readUShort() |
| |
| def writeFormat(self, writer): |
| writer.writeUShort(self.Format) |
| |
| def toXML(self, xmlWriter, font, attrs=None, name=None): |
| BaseTable.toXML(self, xmlWriter, font, attrs, name) |
| |
| def getVariableAttrs(self): |
| return getVariableAttrs(self.__class__, self.Format) |
| |
| |
| class UInt8FormatSwitchingBaseTable(FormatSwitchingBaseTable): |
| def readFormat(self, reader): |
| self.Format = reader.readUInt8() |
| |
| def writeFormat(self, writer): |
| writer.writeUInt8(self.Format) |
| |
| |
| formatSwitchingBaseTables = { |
| "uint16": FormatSwitchingBaseTable, |
| "uint8": UInt8FormatSwitchingBaseTable, |
| } |
| |
| |
| def getFormatSwitchingBaseTableClass(formatType): |
| try: |
| return formatSwitchingBaseTables[formatType] |
| except KeyError: |
| raise TypeError(f"Unsupported format type: {formatType!r}") |
| |
| |
| # memoize since these are parsed from otData.py, thus stay constant |
| @lru_cache() |
| def getVariableAttrs(cls: BaseTable, fmt: Optional[int] = None) -> Tuple[str]: |
| """Return sequence of variable table field names (can be empty). |
| |
| Attributes are deemed "variable" when their otData.py's description contain |
| 'VarIndexBase + {offset}', e.g. COLRv1 PaintVar* tables. |
| """ |
| if not issubclass(cls, BaseTable): |
| raise TypeError(cls) |
| if issubclass(cls, FormatSwitchingBaseTable): |
| if fmt is None: |
| raise TypeError(f"'fmt' is required for format-switching {cls.__name__}") |
| converters = cls.convertersByName[fmt] |
| else: |
| converters = cls.convertersByName |
| # assume if no 'VarIndexBase' field is present, table has no variable fields |
| if "VarIndexBase" not in converters: |
| return () |
| varAttrs = {} |
| for name, conv in converters.items(): |
| offset = conv.getVarIndexOffset() |
| if offset is not None: |
| varAttrs[name] = offset |
| return tuple(sorted(varAttrs, key=varAttrs.__getitem__)) |
| |
| |
| # |
| # Support for ValueRecords |
| # |
| # This data type is so different from all other OpenType data types that |
| # it requires quite a bit of code for itself. It even has special support |
| # in OTTableReader and OTTableWriter... |
| # |
| |
| valueRecordFormat = [ |
| # Mask Name isDevice signed |
| (0x0001, "XPlacement", 0, 1), |
| (0x0002, "YPlacement", 0, 1), |
| (0x0004, "XAdvance", 0, 1), |
| (0x0008, "YAdvance", 0, 1), |
| (0x0010, "XPlaDevice", 1, 0), |
| (0x0020, "YPlaDevice", 1, 0), |
| (0x0040, "XAdvDevice", 1, 0), |
| (0x0080, "YAdvDevice", 1, 0), |
| # reserved: |
| (0x0100, "Reserved1", 0, 0), |
| (0x0200, "Reserved2", 0, 0), |
| (0x0400, "Reserved3", 0, 0), |
| (0x0800, "Reserved4", 0, 0), |
| (0x1000, "Reserved5", 0, 0), |
| (0x2000, "Reserved6", 0, 0), |
| (0x4000, "Reserved7", 0, 0), |
| (0x8000, "Reserved8", 0, 0), |
| ] |
| |
| |
| def _buildDict(): |
| d = {} |
| for mask, name, isDevice, signed in valueRecordFormat: |
| d[name] = mask, isDevice, signed |
| return d |
| |
| |
| valueRecordFormatDict = _buildDict() |
| |
| |
| class ValueRecordFactory(object): |
| """Given a format code, this object convert ValueRecords.""" |
| |
| def __init__(self, valueFormat): |
| format = [] |
| for mask, name, isDevice, signed in valueRecordFormat: |
| if valueFormat & mask: |
| format.append((name, isDevice, signed)) |
| self.format = format |
| |
| def __len__(self): |
| return len(self.format) |
| |
| def readValueRecord(self, reader, font): |
| format = self.format |
| if not format: |
| return None |
| valueRecord = ValueRecord() |
| for name, isDevice, signed in format: |
| if signed: |
| value = reader.readShort() |
| else: |
| value = reader.readUShort() |
| if isDevice: |
| if value: |
| from . import otTables |
| |
| subReader = reader.getSubReader(value) |
| value = getattr(otTables, name)() |
| value.decompile(subReader, font) |
| else: |
| value = None |
| setattr(valueRecord, name, value) |
| return valueRecord |
| |
| def writeValueRecord(self, writer, font, valueRecord): |
| for name, isDevice, signed in self.format: |
| value = getattr(valueRecord, name, 0) |
| if isDevice: |
| if value: |
| subWriter = writer.getSubWriter() |
| writer.writeSubTable(subWriter, offsetSize=2) |
| value.compile(subWriter, font) |
| else: |
| writer.writeUShort(0) |
| elif signed: |
| writer.writeShort(value) |
| else: |
| writer.writeUShort(value) |
| |
| |
| class ValueRecord(object): |
| # see ValueRecordFactory |
| |
| def __init__(self, valueFormat=None, src=None): |
| if valueFormat is not None: |
| for mask, name, isDevice, signed in valueRecordFormat: |
| if valueFormat & mask: |
| setattr(self, name, None if isDevice else 0) |
| if src is not None: |
| for key, val in src.__dict__.items(): |
| if not hasattr(self, key): |
| continue |
| setattr(self, key, val) |
| elif src is not None: |
| self.__dict__ = src.__dict__.copy() |
| |
| def getFormat(self): |
| format = 0 |
| for name in self.__dict__.keys(): |
| format = format | valueRecordFormatDict[name][0] |
| return format |
| |
| def getEffectiveFormat(self): |
| format = 0 |
| for name, value in self.__dict__.items(): |
| if value: |
| format = format | valueRecordFormatDict[name][0] |
| return format |
| |
| def toXML(self, xmlWriter, font, valueName, attrs=None): |
| if attrs is None: |
| simpleItems = [] |
| else: |
| simpleItems = list(attrs) |
| for mask, name, isDevice, format in valueRecordFormat[:4]: # "simple" values |
| if hasattr(self, name): |
| simpleItems.append((name, getattr(self, name))) |
| deviceItems = [] |
| for mask, name, isDevice, format in valueRecordFormat[4:8]: # device records |
| if hasattr(self, name): |
| device = getattr(self, name) |
| if device is not None: |
| deviceItems.append((name, device)) |
| if deviceItems: |
| xmlWriter.begintag(valueName, simpleItems) |
| xmlWriter.newline() |
| for name, deviceRecord in deviceItems: |
| if deviceRecord is not None: |
| deviceRecord.toXML(xmlWriter, font, name=name) |
| xmlWriter.endtag(valueName) |
| xmlWriter.newline() |
| else: |
| xmlWriter.simpletag(valueName, simpleItems) |
| xmlWriter.newline() |
| |
| def fromXML(self, name, attrs, content, font): |
| from . import otTables |
| |
| for k, v in attrs.items(): |
| setattr(self, k, int(v)) |
| for element in content: |
| if not isinstance(element, tuple): |
| continue |
| name, attrs, content = element |
| value = getattr(otTables, name)() |
| for elem2 in content: |
| if not isinstance(elem2, tuple): |
| continue |
| name2, attrs2, content2 = elem2 |
| value.fromXML(name2, attrs2, content2, font) |
| setattr(self, name, value) |
| |
| def __ne__(self, other): |
| result = self.__eq__(other) |
| return result if result is NotImplemented else not result |
| |
| def __eq__(self, other): |
| if type(self) != type(other): |
| return NotImplemented |
| return self.__dict__ == other.__dict__ |
