8633b9c0ae
It's marginally useful when touching the bowels of otBase, but even then, looks like it was broken as no code was populating it.
940 lines
26 KiB
Python
940 lines
26 KiB
Python
from __future__ import print_function, division, absolute_import
|
|
from fontTools.misc.py23 import *
|
|
from .DefaultTable import DefaultTable
|
|
import sys
|
|
import array
|
|
import struct
|
|
import logging
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
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 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):
|
|
from . import otTables
|
|
class GlobalState(object):
|
|
def __init__(self, tableType):
|
|
self.tableType = tableType
|
|
globalState = GlobalState(tableType=self.tableTag)
|
|
reader = OTTableReader(data, globalState)
|
|
tableClass = getattr(otTables, self.tableTag)
|
|
self.table = tableClass()
|
|
self.table.decompile(reader, font)
|
|
|
|
def compile(self, font):
|
|
""" Create a top-level OTFWriter 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.
|
|
"""
|
|
class GlobalState(object):
|
|
def __init__(self, tableType):
|
|
self.tableType = tableType
|
|
globalState = GlobalState(tableType=self.tableTag)
|
|
overflowRecord = None
|
|
|
|
while True:
|
|
try:
|
|
writer = OTTableWriter(globalState)
|
|
self.table.compile(writer, font)
|
|
return writer.getAllData()
|
|
|
|
except OTLOffsetOverflowError as e:
|
|
|
|
if overflowRecord == e.value:
|
|
raise # Oh well...
|
|
|
|
overflowRecord = e.value
|
|
log.info("Attempting to fix OTLOffsetOverflowError %s", e)
|
|
lastItem = overflowRecord
|
|
|
|
ok = 0
|
|
if overflowRecord.itemName is None:
|
|
from .otTables import fixLookupOverFlows
|
|
ok = fixLookupOverFlows(font, overflowRecord)
|
|
else:
|
|
from .otTables import fixSubTableOverFlows
|
|
ok = fixSubTableOverFlows(font, overflowRecord)
|
|
if not ok:
|
|
raise
|
|
|
|
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)
|
|
|
|
|
|
class OTTableReader(object):
|
|
|
|
"""Helper class to retrieve data from an OpenType table."""
|
|
|
|
__slots__ = ('data', 'offset', 'pos', 'globalState', 'localState')
|
|
|
|
def __init__(self, data, globalState={}, localState=None, offset=0):
|
|
self.data = data
|
|
self.offset = offset
|
|
self.pos = offset
|
|
self.globalState = globalState
|
|
self.localState = localState
|
|
|
|
def advance(self, count):
|
|
self.pos += count
|
|
|
|
def seek(self, pos):
|
|
self.pos = pos
|
|
|
|
def copy(self):
|
|
other = self.__class__(self.data, self.globalState, self.localState, self.offset)
|
|
other.pos = self.pos
|
|
return other
|
|
|
|
def getSubReader(self, offset):
|
|
offset = self.offset + offset
|
|
return self.__class__(self.data, self.globalState, self.localState, offset)
|
|
|
|
def readUShort(self):
|
|
pos = self.pos
|
|
newpos = pos + 2
|
|
value, = struct.unpack(">H", self.data[pos:newpos])
|
|
self.pos = newpos
|
|
return value
|
|
|
|
def readUShortArray(self, count):
|
|
pos = self.pos
|
|
newpos = pos + count * 2
|
|
value = array.array("H", self.data[pos:newpos])
|
|
if sys.byteorder != "big":
|
|
value.byteswap()
|
|
self.pos = newpos
|
|
return value
|
|
|
|
def readInt8(self):
|
|
pos = self.pos
|
|
newpos = pos + 1
|
|
value, = struct.unpack(">b", self.data[pos:newpos])
|
|
self.pos = newpos
|
|
return value
|
|
|
|
def readShort(self):
|
|
pos = self.pos
|
|
newpos = pos + 2
|
|
value, = struct.unpack(">h", self.data[pos:newpos])
|
|
self.pos = newpos
|
|
return value
|
|
|
|
def readLong(self):
|
|
pos = self.pos
|
|
newpos = pos + 4
|
|
value, = struct.unpack(">l", self.data[pos:newpos])
|
|
self.pos = newpos
|
|
return value
|
|
|
|
def readUInt8(self):
|
|
pos = self.pos
|
|
newpos = pos + 1
|
|
value, = struct.unpack(">B", self.data[pos:newpos])
|
|
self.pos = newpos
|
|
return value
|
|
|
|
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 readULong(self):
|
|
pos = self.pos
|
|
newpos = pos + 4
|
|
value, = struct.unpack(">L", self.data[pos:newpos])
|
|
self.pos = newpos
|
|
return value
|
|
|
|
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 OTTableWriter(object):
|
|
|
|
"""Helper class to gather and assemble data for OpenType tables."""
|
|
|
|
def __init__(self, globalState={}, localState=None):
|
|
self.items = []
|
|
self.pos = None
|
|
self.globalState = globalState
|
|
self.localState = localState
|
|
self.longOffset = False
|
|
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]
|
|
|
|
# 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, "getData") or hasattr(item, "getCountData"):
|
|
if item.longOffset:
|
|
l = l + 4 # sizeof(ULong)
|
|
else:
|
|
l = l + 2 # sizeof(UShort)
|
|
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, "getData"):
|
|
if item.longOffset:
|
|
items[i] = packULong(item.pos - pos)
|
|
else:
|
|
try:
|
|
items[i] = packUShort(item.pos - pos)
|
|
except struct.error:
|
|
# provide data to fix overflow problem.
|
|
overflowErrorRecord = self.getOverflowErrorRecord(item)
|
|
|
|
raise OTLOffsetOverflowError(overflowErrorRecord)
|
|
|
|
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):
|
|
# 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/behdad/fonttools/issues/518
|
|
dontShare = hasattr(self, 'DontShare')
|
|
|
|
if isExtension:
|
|
internedTables = {}
|
|
|
|
items = self.items
|
|
for i in range(len(items)):
|
|
item = items[i]
|
|
if hasattr(item, "getCountData"):
|
|
items[i] = item.getCountData()
|
|
elif hasattr(item, "getData"):
|
|
item._doneWriting(internedTables)
|
|
if not dontShare:
|
|
items[i] = item = internedTables.setdefault(item, item)
|
|
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")
|
|
dontShare = hasattr(self, 'DontShare')
|
|
|
|
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 = 0
|
|
if hasattr(self, "sortCoverageLast"):
|
|
# Find coverage table
|
|
for i in range(numItems):
|
|
item = self.items[i]
|
|
if hasattr(item, "name") and (item.name == "Coverage"):
|
|
sortCoverageLast = 1
|
|
break
|
|
if id(item) not in done:
|
|
item._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, "getData"):
|
|
continue
|
|
|
|
if sortCoverageLast and (i==1) and item.name == 'Coverage':
|
|
# we've already 'gathered' it above
|
|
continue
|
|
|
|
if id(item) not in done:
|
|
item._gatherTables(tables, extTables, done)
|
|
else:
|
|
# Item is already written out by other parent
|
|
pass
|
|
|
|
selfTables.append(self)
|
|
|
|
def getAllData(self):
|
|
"""Assemble all data, including all subtables."""
|
|
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.globalState, self.localState)
|
|
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 writeUShort(self, value):
|
|
assert 0 <= value < 0x10000, value
|
|
self.items.append(struct.pack(">H", value))
|
|
|
|
def writeShort(self, value):
|
|
assert -32768 <= value < 32768, value
|
|
self.items.append(struct.pack(">h", value))
|
|
|
|
def writeUInt8(self, value):
|
|
assert 0 <= value < 256, value
|
|
self.items.append(struct.pack(">B", value))
|
|
|
|
def writeInt8(self, value):
|
|
assert -128 <= value < 128, value
|
|
self.items.append(struct.pack(">b", value))
|
|
|
|
def writeUInt24(self, value):
|
|
assert 0 <= value < 0x1000000, value
|
|
b = struct.pack(">L", value)
|
|
self.items.append(b[1:])
|
|
|
|
def writeLong(self, value):
|
|
self.items.append(struct.pack(">l", value))
|
|
|
|
def writeULong(self, value):
|
|
self.items.append(struct.pack(">L", value))
|
|
|
|
def writeTag(self, tag):
|
|
tag = Tag(tag).tobytes()
|
|
assert len(tag) == 4, tag
|
|
self.items.append(tag)
|
|
|
|
def writeSubTable(self, subWriter):
|
|
self.items.append(subWriter)
|
|
|
|
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.globalState.tableType, 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 getCountData(self):
|
|
assert self.size in (2, 4)
|
|
v = self.table[self.name]
|
|
if v is None: v = 0
|
|
return packUShort(v) if self.size == 2 else packULong(v)
|
|
|
|
|
|
def packUShort(value):
|
|
return struct.pack(">H", value)
|
|
|
|
|
|
def packULong(value):
|
|
assert 0 <= value < 0x100000000, value
|
|
return struct.pack(">L", value)
|
|
|
|
|
|
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):
|
|
reader = self.__dict__.get("reader")
|
|
if reader:
|
|
del self.reader
|
|
font = self.font
|
|
del self.font
|
|
self.decompile(reader, font)
|
|
|
|
@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]
|
|
else:
|
|
return NotImplemented
|
|
totalSize += size * countValue
|
|
return totalSize
|
|
|
|
def getConverters(self):
|
|
return self.converters
|
|
|
|
def getConverterByName(self, name):
|
|
return self.convertersByName[name]
|
|
|
|
def decompile(self, reader, font):
|
|
self.readFormat(reader)
|
|
table = {}
|
|
self.__rawTable = table # for debugging
|
|
converters = self.getConverters()
|
|
for conv in converters:
|
|
if conv.name == "SubTable":
|
|
conv = conv.getConverter(reader.globalState.tableType,
|
|
table["LookupType"])
|
|
if conv.name == "ExtSubTable":
|
|
conv = conv.getConverter(reader.globalState.tableType,
|
|
table["ExtensionLookupType"])
|
|
if conv.name == "FeatureParams":
|
|
conv = conv.getConverter(reader["FeatureTag"])
|
|
if conv.repeat:
|
|
if 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]
|
|
|
|
self.postRead(table, font)
|
|
|
|
del self.__rawTable # succeeded, get rid of debugging info
|
|
|
|
def compile(self, writer, font):
|
|
self.ensureDecompiled()
|
|
table = self.preWrite(font)
|
|
|
|
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 conv.repeat in table:
|
|
CountReference(table, conv.repeat, value=countValue)
|
|
else:
|
|
# conv.repeat is a propagated count
|
|
writer[conv.repeat].setValue(countValue)
|
|
values = value
|
|
for i, value in enumerate(values):
|
|
try:
|
|
conv.write(writer, font, table, value, i)
|
|
except Exception as e:
|
|
name = value.__class__.__name__ if value is not None else conv.name
|
|
e.args = e.args + (name+'['+str(i)+']',)
|
|
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.
|
|
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.
|
|
ref = writer.writeCountReference(table, conv.name, conv.staticSize, table.get(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
|
|
|
|
def readFormat(self, reader):
|
|
pass
|
|
|
|
def writeFormat(self, writer):
|
|
pass
|
|
|
|
def postRead(self, table, font):
|
|
self.__dict__.update(table)
|
|
|
|
def preWrite(self, font):
|
|
return self.__dict__.copy()
|
|
|
|
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)
|
|
try:
|
|
count_conv = self.getConverterByName(conv.repeat)
|
|
setattr(self, conv.repeat, -conv.aux)
|
|
except KeyError:
|
|
# TODO: Count is propagated.
|
|
# We don't have access upstream currently.
|
|
pass
|
|
seq.append(value)
|
|
if hasattr(self, conv.repeat):
|
|
setattr(self, conv.repeat, len(seq)+conv.aux)
|
|
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 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):
|
|
return self.converters[self.Format]
|
|
|
|
def getConverterByName(self, name):
|
|
return self.convertersByName[self.Format][name]
|
|
|
|
def readFormat(self, reader):
|
|
self.Format = reader.readUShort()
|
|
assert self.Format != 0, (self, reader.pos, len(reader.data))
|
|
|
|
def writeFormat(self, writer):
|
|
writer.writeUShort(self.Format)
|
|
|
|
def toXML(self, xmlWriter, font, attrs=None, name=None):
|
|
BaseTable.toXML(self, xmlWriter, font, attrs, name)
|
|
|
|
|
|
#
|
|
# 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)
|
|
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():
|
|
assert hasattr(self, key)
|
|
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 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__
|