Behdad Esfahbod | 32c10ee | 2013-11-27 17:46:17 -0500 | [diff] [blame] | 1 | from __future__ import print_function, division |
Behdad Esfahbod | 30e691e | 2013-11-27 17:27:45 -0500 | [diff] [blame] | 2 | from fontTools.misc.py23 import * |
Behdad Esfahbod | 2b06aaa | 2013-11-27 02:34:11 -0500 | [diff] [blame] | 3 | from .DefaultTable import DefaultTable |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 4 | import struct |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 5 | |
Behdad Esfahbod | e388db5 | 2013-11-28 14:26:58 -0500 | [diff] [blame] | 6 | class OverflowErrorRecord(object): |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 7 | def __init__(self, overflowTuple): |
| 8 | self.tableType = overflowTuple[0] |
| 9 | self.LookupListIndex = overflowTuple[1] |
| 10 | self.SubTableIndex = overflowTuple[2] |
| 11 | self.itemName = overflowTuple[3] |
| 12 | self.itemIndex = overflowTuple[4] |
| 13 | |
| 14 | def __repr__(self): |
| 15 | return str((self.tableType, "LookupIndex:", self.LookupListIndex, "SubTableIndex:", self.SubTableIndex, "ItemName:", self.itemName, "ItemIndex:", self.itemIndex)) |
| 16 | |
| 17 | class OTLOffsetOverflowError(Exception): |
| 18 | def __init__(self, overflowErrorRecord): |
| 19 | self.value = overflowErrorRecord |
| 20 | |
| 21 | def __str__(self): |
| 22 | return repr(self.value) |
| 23 | |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 24 | |
| 25 | class BaseTTXConverter(DefaultTable): |
| 26 | |
jvr | 3a6aa23 | 2003-09-02 19:23:13 +0000 | [diff] [blame] | 27 | """Generic base class for TTX table converters. It functions as an |
| 28 | adapter between the TTX (ttLib actually) table model and the model |
| 29 | we use for OpenType tables, which is necessarily subtly different. |
| 30 | """ |
jvr | 64b5c80 | 2002-05-11 10:21:36 +0000 | [diff] [blame] | 31 | |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 32 | def decompile(self, data, font): |
Behdad Esfahbod | 2b06aaa | 2013-11-27 02:34:11 -0500 | [diff] [blame] | 33 | from . import otTables |
Behdad Esfahbod | 0585b64 | 2013-11-22 16:20:59 -0500 | [diff] [blame] | 34 | cachingStats = None if True else {} |
Behdad Esfahbod | e388db5 | 2013-11-28 14:26:58 -0500 | [diff] [blame] | 35 | class GlobalState(object): |
Behdad Esfahbod | 79f7344 | 2013-11-26 17:07:37 -0500 | [diff] [blame] | 36 | def __init__(self, tableType, cachingStats): |
| 37 | self.tableType = tableType |
| 38 | self.cachingStats = cachingStats |
| 39 | globalState = GlobalState(tableType=self.tableTag, |
| 40 | cachingStats=cachingStats) |
| 41 | reader = OTTableReader(data, globalState) |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 42 | tableClass = getattr(otTables, self.tableTag) |
| 43 | self.table = tableClass() |
| 44 | self.table.decompile(reader, font) |
Behdad Esfahbod | 0585b64 | 2013-11-22 16:20:59 -0500 | [diff] [blame] | 45 | if cachingStats: |
Behdad Esfahbod | ac1b435 | 2013-11-27 04:15:34 -0500 | [diff] [blame] | 46 | stats = sorted([(v, k) for k, v in cachingStats.items()]) |
jvr | cfadfd0 | 2002-07-22 22:13:57 +0000 | [diff] [blame] | 47 | stats.reverse() |
Behdad Esfahbod | 3ec6a25 | 2013-11-27 04:57:33 -0500 | [diff] [blame] | 48 | print("cachingsstats for ", self.tableTag) |
jvr | cfadfd0 | 2002-07-22 22:13:57 +0000 | [diff] [blame] | 49 | for v, k in stats: |
| 50 | if v < 2: |
| 51 | break |
Behdad Esfahbod | 3ec6a25 | 2013-11-27 04:57:33 -0500 | [diff] [blame] | 52 | print(v, k) |
| 53 | print("---", len(stats)) |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 54 | |
| 55 | def compile(self, font): |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 56 | """ Create a top-level OTFWriter for the GPOS/GSUB table. |
| 57 | Call the compile method for the the table |
jvr | 1c73452 | 2008-03-09 20:13:16 +0000 | [diff] [blame] | 58 | for each 'converter' record in the table converter list |
| 59 | call converter's write method for each item in the value. |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 60 | - For simple items, the write method adds a string to the |
| 61 | writer's self.items list. |
jvr | 1c73452 | 2008-03-09 20:13:16 +0000 | [diff] [blame] | 62 | - For Struct/Table/Subtable items, it add first adds new writer to the |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 63 | to the writer's self.items, then calls the item's compile method. |
| 64 | This creates a tree of writers, rooted at the GUSB/GPOS writer, with |
| 65 | each writer representing a table, and the writer.items list containing |
| 66 | the child data strings and writers. |
jvr | 1c73452 | 2008-03-09 20:13:16 +0000 | [diff] [blame] | 67 | call the getAllData method |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 68 | call _doneWriting, which removes duplicates |
jvr | 1c73452 | 2008-03-09 20:13:16 +0000 | [diff] [blame] | 69 | call _gatherTables. This traverses the tables, adding unique occurences to a flat list of tables |
| 70 | Traverse the flat list of tables, calling getDataLength on each to update their position |
| 71 | Traverse the flat list of tables again, calling getData each get the data in the table, now that |
| 72 | pos's and offset are known. |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 73 | |
| 74 | If a lookup subtable overflows an offset, we have to start all over. |
| 75 | """ |
Behdad Esfahbod | e388db5 | 2013-11-28 14:26:58 -0500 | [diff] [blame] | 76 | class GlobalState(object): |
Behdad Esfahbod | 79f7344 | 2013-11-26 17:07:37 -0500 | [diff] [blame] | 77 | def __init__(self, tableType): |
| 78 | self.tableType = tableType |
| 79 | globalState = GlobalState(tableType=self.tableTag) |
| 80 | writer = OTTableWriter(globalState) |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 81 | writer.parent = None |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 82 | self.table.compile(writer, font) |
jvr | cfadfd0 | 2002-07-22 22:13:57 +0000 | [diff] [blame] | 83 | return writer.getAllData() |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 84 | |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 85 | def toXML(self, writer, font): |
| 86 | self.table.toXML2(writer, font) |
| 87 | |
Behdad Esfahbod | 3a9fd30 | 2013-11-27 03:19:32 -0500 | [diff] [blame] | 88 | def fromXML(self, name, attrs, content, font): |
Behdad Esfahbod | 2b06aaa | 2013-11-27 02:34:11 -0500 | [diff] [blame] | 89 | from . import otTables |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 90 | if not hasattr(self, "table"): |
| 91 | tableClass = getattr(otTables, self.tableTag) |
| 92 | self.table = tableClass() |
Behdad Esfahbod | 3a9fd30 | 2013-11-27 03:19:32 -0500 | [diff] [blame] | 93 | self.table.fromXML(name, attrs, content, font) |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 94 | |
| 95 | |
Behdad Esfahbod | 3879cf9 | 2013-11-22 19:23:35 -0500 | [diff] [blame] | 96 | class OTTableReader(object): |
Behdad Esfahbod | 7981704 | 2013-11-24 16:59:42 -0500 | [diff] [blame] | 97 | |
jvr | 64b5c80 | 2002-05-11 10:21:36 +0000 | [diff] [blame] | 98 | """Helper class to retrieve data from an OpenType table.""" |
Behdad Esfahbod | 3879cf9 | 2013-11-22 19:23:35 -0500 | [diff] [blame] | 99 | |
Behdad Esfahbod | 79f7344 | 2013-11-26 17:07:37 -0500 | [diff] [blame] | 100 | __slots__ = ('data', 'offset', 'pos', 'globalState', 'localState') |
Behdad Esfahbod | 7981704 | 2013-11-24 16:59:42 -0500 | [diff] [blame] | 101 | |
Behdad Esfahbod | 79f7344 | 2013-11-26 17:07:37 -0500 | [diff] [blame] | 102 | def __init__(self, data, globalState={}, localState=None, offset=0): |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 103 | self.data = data |
| 104 | self.offset = offset |
| 105 | self.pos = offset |
Behdad Esfahbod | 79f7344 | 2013-11-26 17:07:37 -0500 | [diff] [blame] | 106 | self.globalState = globalState |
| 107 | self.localState = localState |
Behdad Esfahbod | 7981704 | 2013-11-24 16:59:42 -0500 | [diff] [blame] | 108 | |
Behdad Esfahbod | 0fac7fe | 2013-11-24 18:04:29 -0500 | [diff] [blame] | 109 | def getSubReader(self, offset): |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 110 | offset = self.offset + offset |
Behdad Esfahbod | 79f7344 | 2013-11-26 17:07:37 -0500 | [diff] [blame] | 111 | cachingStats = self.globalState.cachingStats |
| 112 | if cachingStats is not None: |
| 113 | cachingStats[offset] = cachingStats.get(offset, 0) + 1 |
| 114 | return self.__class__(self.data, self.globalState, self.localState, offset) |
Behdad Esfahbod | 7981704 | 2013-11-24 16:59:42 -0500 | [diff] [blame] | 115 | |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 116 | def readUShort(self): |
| 117 | pos = self.pos |
| 118 | newpos = pos + 2 |
jvr | e69caf8 | 2002-05-13 18:08:19 +0000 | [diff] [blame] | 119 | value, = struct.unpack(">H", self.data[pos:newpos]) |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 120 | self.pos = newpos |
| 121 | return value |
Behdad Esfahbod | 7981704 | 2013-11-24 16:59:42 -0500 | [diff] [blame] | 122 | |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 123 | def readShort(self): |
| 124 | pos = self.pos |
| 125 | newpos = pos + 2 |
jvr | e69caf8 | 2002-05-13 18:08:19 +0000 | [diff] [blame] | 126 | value, = struct.unpack(">h", self.data[pos:newpos]) |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 127 | self.pos = newpos |
| 128 | return value |
Behdad Esfahbod | 7981704 | 2013-11-24 16:59:42 -0500 | [diff] [blame] | 129 | |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 130 | def readLong(self): |
| 131 | pos = self.pos |
| 132 | newpos = pos + 4 |
jvr | e69caf8 | 2002-05-13 18:08:19 +0000 | [diff] [blame] | 133 | value, = struct.unpack(">l", self.data[pos:newpos]) |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 134 | self.pos = newpos |
| 135 | return value |
Behdad Esfahbod | 7981704 | 2013-11-24 16:59:42 -0500 | [diff] [blame] | 136 | |
Behdad Esfahbod | 9e1bd2d | 2013-11-26 19:23:08 -0500 | [diff] [blame] | 137 | def readUInt24(self): |
| 138 | pos = self.pos |
| 139 | newpos = pos + 3 |
Behdad Esfahbod | c0a9d69 | 2013-11-28 06:38:07 -0500 | [diff] [blame] | 140 | value, = struct.unpack(">l", b'\0'+self.data[pos:newpos]) |
Behdad Esfahbod | 9e1bd2d | 2013-11-26 19:23:08 -0500 | [diff] [blame] | 141 | self.pos = newpos |
| 142 | return value |
| 143 | |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 144 | def readULong(self): |
| 145 | pos = self.pos |
| 146 | newpos = pos + 4 |
| 147 | value, = struct.unpack(">L", self.data[pos:newpos]) |
| 148 | self.pos = newpos |
| 149 | return value |
| 150 | |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 151 | def readTag(self): |
| 152 | pos = self.pos |
| 153 | newpos = pos + 4 |
Behdad Esfahbod | 960280b | 2013-11-27 18:16:43 -0500 | [diff] [blame] | 154 | value = Tag(self.data[pos:newpos]) |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 155 | assert len(value) == 4 |
| 156 | self.pos = newpos |
| 157 | return value |
Behdad Esfahbod | 7981704 | 2013-11-24 16:59:42 -0500 | [diff] [blame] | 158 | |
Behdad Esfahbod | 79f7344 | 2013-11-26 17:07:37 -0500 | [diff] [blame] | 159 | def __setitem__(self, name, value): |
| 160 | state = self.localState.copy() if self.localState else dict() |
| 161 | state[name] = value |
| 162 | self.localState = state |
Behdad Esfahbod | 7981704 | 2013-11-24 16:59:42 -0500 | [diff] [blame] | 163 | |
Behdad Esfahbod | 79f7344 | 2013-11-26 17:07:37 -0500 | [diff] [blame] | 164 | def __getitem__(self, name): |
| 165 | return self.localState[name] |
Behdad Esfahbod | 7981704 | 2013-11-24 16:59:42 -0500 | [diff] [blame] | 166 | |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 167 | |
Behdad Esfahbod | 3879cf9 | 2013-11-22 19:23:35 -0500 | [diff] [blame] | 168 | class OTTableWriter(object): |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 169 | |
jvr | 64b5c80 | 2002-05-11 10:21:36 +0000 | [diff] [blame] | 170 | """Helper class to gather and assemble data for OpenType tables.""" |
| 171 | |
Behdad Esfahbod | 79f7344 | 2013-11-26 17:07:37 -0500 | [diff] [blame] | 172 | def __init__(self, globalState, localState=None): |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 173 | self.items = [] |
jvr | cfadfd0 | 2002-07-22 22:13:57 +0000 | [diff] [blame] | 174 | self.pos = None |
Behdad Esfahbod | 79f7344 | 2013-11-26 17:07:37 -0500 | [diff] [blame] | 175 | self.globalState = globalState |
| 176 | self.localState = localState |
Behdad Esfahbod | 7981704 | 2013-11-24 16:59:42 -0500 | [diff] [blame] | 177 | |
Behdad Esfahbod | 79f7344 | 2013-11-26 17:07:37 -0500 | [diff] [blame] | 178 | def __setitem__(self, name, value): |
| 179 | state = self.localState.copy() if self.localState else dict() |
| 180 | state[name] = value |
| 181 | self.localState = state |
Behdad Esfahbod | 7981704 | 2013-11-24 16:59:42 -0500 | [diff] [blame] | 182 | |
Behdad Esfahbod | 79f7344 | 2013-11-26 17:07:37 -0500 | [diff] [blame] | 183 | def __getitem__(self, name): |
| 184 | return self.localState[name] |
Behdad Esfahbod | 7981704 | 2013-11-24 16:59:42 -0500 | [diff] [blame] | 185 | |
jvr | 4105ca0 | 2002-07-23 08:43:03 +0000 | [diff] [blame] | 186 | # assembler interface |
| 187 | |
| 188 | def getAllData(self): |
| 189 | """Assemble all data, including all subtables.""" |
| 190 | self._doneWriting() |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 191 | tables, extTables = self._gatherTables() |
jvr | 4105ca0 | 2002-07-23 08:43:03 +0000 | [diff] [blame] | 192 | tables.reverse() |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 193 | extTables.reverse() |
jvr | 4105ca0 | 2002-07-23 08:43:03 +0000 | [diff] [blame] | 194 | # Gather all data in two passes: the absolute positions of all |
| 195 | # subtable are needed before the actual data can be assembled. |
| 196 | pos = 0 |
| 197 | for table in tables: |
| 198 | table.pos = pos |
| 199 | pos = pos + table.getDataLength() |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 200 | |
| 201 | for table in extTables: |
| 202 | table.pos = pos |
| 203 | pos = pos + table.getDataLength() |
| 204 | |
| 205 | |
jvr | 4105ca0 | 2002-07-23 08:43:03 +0000 | [diff] [blame] | 206 | data = [] |
| 207 | for table in tables: |
| 208 | tableData = table.getData() |
| 209 | data.append(tableData) |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 210 | |
| 211 | for table in extTables: |
| 212 | tableData = table.getData() |
| 213 | data.append(tableData) |
| 214 | |
Behdad Esfahbod | 821572c | 2013-11-27 21:09:03 -0500 | [diff] [blame] | 215 | return bytesjoin(data) |
jvr | 4105ca0 | 2002-07-23 08:43:03 +0000 | [diff] [blame] | 216 | |
| 217 | def getDataLength(self): |
| 218 | """Return the length of this table in bytes, without subtables.""" |
| 219 | l = 0 |
| 220 | for item in self.items: |
| 221 | if hasattr(item, "getData") or hasattr(item, "getCountData"): |
Behdad Esfahbod | e0c2e8e | 2013-11-25 05:32:17 -0500 | [diff] [blame] | 222 | if item.longOffset: |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 223 | l = l + 4 # sizeof(ULong) |
| 224 | else: |
| 225 | l = l + 2 # sizeof(UShort) |
jvr | 4105ca0 | 2002-07-23 08:43:03 +0000 | [diff] [blame] | 226 | else: |
| 227 | l = l + len(item) |
| 228 | return l |
| 229 | |
| 230 | def getData(self): |
| 231 | """Assemble the data for this writer/table, without subtables.""" |
| 232 | items = list(self.items) # make a shallow copy |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 233 | pos = self.pos |
| 234 | numItems = len(items) |
| 235 | for i in range(numItems): |
jvr | 4105ca0 | 2002-07-23 08:43:03 +0000 | [diff] [blame] | 236 | item = items[i] |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 237 | |
jvr | 4105ca0 | 2002-07-23 08:43:03 +0000 | [diff] [blame] | 238 | if hasattr(item, "getData"): |
Behdad Esfahbod | e0c2e8e | 2013-11-25 05:32:17 -0500 | [diff] [blame] | 239 | if item.longOffset: |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 240 | items[i] = packULong(item.pos - pos) |
| 241 | else: |
| 242 | try: |
| 243 | items[i] = packUShort(item.pos - pos) |
Behdad Esfahbod | 9e48233 | 2013-12-17 05:46:51 -0500 | [diff] [blame] | 244 | except struct.error: |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 245 | # provide data to fix overflow problem. |
Behdad Esfahbod | 58acba2 | 2013-11-24 20:08:05 -0500 | [diff] [blame] | 246 | # If the overflow is to a lookup, or from a lookup to a subtable, |
Behdad Esfahbod | ab0ca1b | 2013-12-17 06:19:15 -0500 | [diff] [blame] | 247 | # just report the current item. Otherwise... |
| 248 | if self.name not in [ 'LookupList', 'Lookup']: |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 249 | # overflow is within a subTable. Life is more complicated. |
| 250 | # If we split the sub-table just before the current item, we may still suffer overflow. |
| 251 | # This is because duplicate table merging is done only within an Extension subTable tree; |
| 252 | # when we split the subtable in two, some items may no longer be duplicates. |
| 253 | # Get worst case by adding up all the item lengths, depth first traversal. |
| 254 | # and then report the first item that overflows a short. |
| 255 | def getDeepItemLength(table): |
| 256 | if hasattr(table, "getDataLength"): |
| 257 | length = 0 |
| 258 | for item in table.items: |
| 259 | length = length + getDeepItemLength(item) |
| 260 | else: |
| 261 | length = len(table) |
| 262 | return length |
| 263 | |
| 264 | length = self.getDataLength() |
| 265 | if hasattr(self, "sortCoverageLast") and item.name == "Coverage": |
| 266 | # Coverage is first in the item list, but last in the table list, |
| 267 | # The original overflow is really in the item list. Skip the Coverage |
| 268 | # table in the following test. |
| 269 | items = items[i+1:] |
| 270 | |
| 271 | for j in range(len(items)): |
| 272 | item = items[j] |
| 273 | length = length + getDeepItemLength(item) |
| 274 | if length > 65535: |
| 275 | break |
| 276 | overflowErrorRecord = self.getOverflowErrorRecord(item) |
| 277 | |
| 278 | |
Behdad Esfahbod | cd5aad9 | 2013-11-27 02:42:28 -0500 | [diff] [blame] | 279 | raise OTLOffsetOverflowError(overflowErrorRecord) |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 280 | |
Behdad Esfahbod | 821572c | 2013-11-27 21:09:03 -0500 | [diff] [blame] | 281 | return bytesjoin(items) |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 282 | |
jvr | cfadfd0 | 2002-07-22 22:13:57 +0000 | [diff] [blame] | 283 | def __hash__(self): |
| 284 | # only works after self._doneWriting() has been called |
| 285 | return hash(self.items) |
| 286 | |
Behdad Esfahbod | 8ea6439 | 2013-12-06 22:25:48 -0500 | [diff] [blame] | 287 | def __ne__(self, other): |
| 288 | return not self.__eq__(other) |
Behdad Esfahbod | b7fd2e1 | 2013-11-27 18:58:45 -0500 | [diff] [blame] | 289 | def __eq__(self, other): |
| 290 | if type(self) != type(other): |
Behdad Esfahbod | 273a900 | 2013-12-07 03:40:44 -0500 | [diff] [blame] | 291 | return NotImplemented |
Behdad Esfahbod | b7fd2e1 | 2013-11-27 18:58:45 -0500 | [diff] [blame] | 292 | return self.items == other.items |
jvr | cfadfd0 | 2002-07-22 22:13:57 +0000 | [diff] [blame] | 293 | |
jvr | cfadfd0 | 2002-07-22 22:13:57 +0000 | [diff] [blame] | 294 | def _doneWriting(self, internedTables=None): |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 295 | # Convert CountData references to data string items |
| 296 | # collapse duplicate table references to a unique entry |
| 297 | # "tables" are OTTableWriter objects. |
| 298 | |
| 299 | # For Extension Lookup types, we can |
| 300 | # eliminate duplicates only within the tree under the Extension Lookup, |
| 301 | # as offsets may exceed 64K even between Extension LookupTable subtables. |
jvr | cfadfd0 | 2002-07-22 22:13:57 +0000 | [diff] [blame] | 302 | if internedTables is None: |
| 303 | internedTables = {} |
| 304 | items = self.items |
Behdad Esfahbod | 97dea0a | 2013-11-27 03:34:48 -0500 | [diff] [blame] | 305 | iRange = list(range(len(items))) |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 306 | |
| 307 | if hasattr(self, "Extension"): |
| 308 | newTree = 1 |
| 309 | else: |
| 310 | newTree = 0 |
| 311 | for i in iRange: |
jvr | cfadfd0 | 2002-07-22 22:13:57 +0000 | [diff] [blame] | 312 | item = items[i] |
| 313 | if hasattr(item, "getCountData"): |
| 314 | items[i] = item.getCountData() |
| 315 | elif hasattr(item, "getData"): |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 316 | if newTree: |
| 317 | item._doneWriting() |
jvr | cfadfd0 | 2002-07-22 22:13:57 +0000 | [diff] [blame] | 318 | else: |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 319 | item._doneWriting(internedTables) |
Behdad Esfahbod | dea08f2 | 2013-12-17 06:04:28 -0500 | [diff] [blame] | 320 | internedItem = internedTables.get(item) |
| 321 | if internedItem: |
| 322 | items[i] = item = internedItem |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 323 | else: |
| 324 | internedTables[item] = item |
jvr | cfadfd0 | 2002-07-22 22:13:57 +0000 | [diff] [blame] | 325 | self.items = tuple(items) |
| 326 | |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 327 | def _gatherTables(self, tables=None, extTables=None, done=None): |
| 328 | # Convert table references in self.items tree to a flat |
| 329 | # list of tables in depth-first traversal order. |
| 330 | # "tables" are OTTableWriter objects. |
| 331 | # We do the traversal in reverse order at each level, in order to |
| 332 | # resolve duplicate references to be the last reference in the list of tables. |
| 333 | # For extension lookups, duplicate references can be merged only within the |
| 334 | # writer tree under the extension lookup. |
| 335 | if tables is None: # init call for first time. |
jvr | cfadfd0 | 2002-07-22 22:13:57 +0000 | [diff] [blame] | 336 | tables = [] |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 337 | extTables = [] |
jvr | cfadfd0 | 2002-07-22 22:13:57 +0000 | [diff] [blame] | 338 | done = {} |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 339 | |
| 340 | done[self] = 1 |
| 341 | |
| 342 | numItems = len(self.items) |
Behdad Esfahbod | 97dea0a | 2013-11-27 03:34:48 -0500 | [diff] [blame] | 343 | iRange = list(range(numItems)) |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 344 | iRange.reverse() |
| 345 | |
| 346 | if hasattr(self, "Extension"): |
| 347 | appendExtensions = 1 |
| 348 | else: |
| 349 | appendExtensions = 0 |
| 350 | |
| 351 | # add Coverage table if it is sorted last. |
| 352 | sortCoverageLast = 0 |
| 353 | if hasattr(self, "sortCoverageLast"): |
| 354 | # Find coverage table |
| 355 | for i in range(numItems): |
| 356 | item = self.items[i] |
| 357 | if hasattr(item, "name") and (item.name == "Coverage"): |
| 358 | sortCoverageLast = 1 |
| 359 | break |
Behdad Esfahbod | bc5e1cb | 2013-11-27 02:33:03 -0500 | [diff] [blame] | 360 | if item not in done: |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 361 | item._gatherTables(tables, extTables, done) |
| 362 | else: |
Behdad Esfahbod | ee6340f | 2013-12-17 06:31:37 -0500 | [diff] [blame] | 363 | # We're a new parent of item |
| 364 | pass |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 365 | |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 366 | for i in iRange: |
| 367 | item = self.items[i] |
jvr | cfadfd0 | 2002-07-22 22:13:57 +0000 | [diff] [blame] | 368 | if not hasattr(item, "getData"): |
| 369 | continue |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 370 | |
| 371 | if sortCoverageLast and (i==1) and item.name == 'Coverage': |
| 372 | # we've already 'gathered' it above |
| 373 | continue |
| 374 | |
| 375 | if appendExtensions: |
Behdad Esfahbod | 9e6ef94 | 2013-12-04 16:31:44 -0500 | [diff] [blame] | 376 | assert extTables is not None, "Program or XML editing error. Extension subtables cannot contain extensions subtables" |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 377 | newDone = {} |
| 378 | item._gatherTables(extTables, None, newDone) |
| 379 | |
Behdad Esfahbod | bc5e1cb | 2013-11-27 02:33:03 -0500 | [diff] [blame] | 380 | elif item not in done: |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 381 | item._gatherTables(tables, extTables, done) |
| 382 | else: |
Behdad Esfahbod | ee6340f | 2013-12-17 06:31:37 -0500 | [diff] [blame] | 383 | # We're a new parent of item |
| 384 | pass |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 385 | |
| 386 | |
jvr | cfadfd0 | 2002-07-22 22:13:57 +0000 | [diff] [blame] | 387 | tables.append(self) |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 388 | return tables, extTables |
jvr | cfadfd0 | 2002-07-22 22:13:57 +0000 | [diff] [blame] | 389 | |
jvr | 4105ca0 | 2002-07-23 08:43:03 +0000 | [diff] [blame] | 390 | # interface for gathering data, as used by table.compile() |
jvr | cfadfd0 | 2002-07-22 22:13:57 +0000 | [diff] [blame] | 391 | |
jvr | 4105ca0 | 2002-07-23 08:43:03 +0000 | [diff] [blame] | 392 | def getSubWriter(self): |
Behdad Esfahbod | 79f7344 | 2013-11-26 17:07:37 -0500 | [diff] [blame] | 393 | subwriter = self.__class__(self.globalState, self.localState) |
Behdad Esfahbod | ee6340f | 2013-12-17 06:31:37 -0500 | [diff] [blame] | 394 | subwriter.parent = self # because some subtables have idential values, we discard |
| 395 | # the duplicates under the getAllData method. Hence some |
| 396 | # subtable writers can have more than one parent writer. |
| 397 | # But we just care about first one right now. |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 398 | return subwriter |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 399 | |
| 400 | def writeUShort(self, value): |
| 401 | assert 0 <= value < 0x10000 |
| 402 | self.items.append(struct.pack(">H", value)) |
| 403 | |
| 404 | def writeShort(self, value): |
| 405 | self.items.append(struct.pack(">h", value)) |
Behdad Esfahbod | 9e1bd2d | 2013-11-26 19:23:08 -0500 | [diff] [blame] | 406 | |
| 407 | def writeUInt24(self, value): |
| 408 | assert 0 <= value < 0x1000000 |
Behdad Esfahbod | c0a9d69 | 2013-11-28 06:38:07 -0500 | [diff] [blame] | 409 | b = struct.pack(">L", value) |
| 410 | self.items.append(b[1:]) |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 411 | |
| 412 | def writeLong(self, value): |
| 413 | self.items.append(struct.pack(">l", value)) |
| 414 | |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 415 | def writeULong(self, value): |
| 416 | self.items.append(struct.pack(">L", value)) |
| 417 | |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 418 | def writeTag(self, tag): |
Behdad Esfahbod | 960280b | 2013-11-27 18:16:43 -0500 | [diff] [blame] | 419 | tag = Tag(tag).tobytes() |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 420 | assert len(tag) == 4 |
| 421 | self.items.append(tag) |
| 422 | |
| 423 | def writeSubTable(self, subWriter): |
| 424 | self.items.append(subWriter) |
| 425 | |
| 426 | def writeCountReference(self, table, name): |
Behdad Esfahbod | 7981704 | 2013-11-24 16:59:42 -0500 | [diff] [blame] | 427 | ref = CountReference(table, name) |
| 428 | self.items.append(ref) |
Behdad Esfahbod | ee27eb8 | 2013-11-24 17:34:43 -0500 | [diff] [blame] | 429 | return ref |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 430 | |
| 431 | def writeStruct(self, format, values): |
Behdad Esfahbod | 66214cb | 2013-11-27 02:18:18 -0500 | [diff] [blame] | 432 | data = struct.pack(*(format,) + values) |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 433 | self.items.append(data) |
| 434 | |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 435 | def writeData(self, data): |
| 436 | self.items.append(data) |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 437 | |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 438 | def getOverflowErrorRecord(self, item): |
| 439 | LookupListIndex = SubTableIndex = itemName = itemIndex = None |
| 440 | if self.name == 'LookupList': |
| 441 | LookupListIndex = item.repeatIndex |
| 442 | elif self.name == 'Lookup': |
| 443 | LookupListIndex = self.repeatIndex |
| 444 | SubTableIndex = item.repeatIndex |
| 445 | else: |
| 446 | itemName = item.name |
| 447 | if hasattr(item, 'repeatIndex'): |
| 448 | itemIndex = item.repeatIndex |
| 449 | if self.name == 'SubTable': |
Behdad Esfahbod | ee6340f | 2013-12-17 06:31:37 -0500 | [diff] [blame] | 450 | LookupListIndex = self.parent.repeatIndex |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 451 | SubTableIndex = self.repeatIndex |
| 452 | elif self.name == 'ExtSubTable': |
Behdad Esfahbod | ee6340f | 2013-12-17 06:31:37 -0500 | [diff] [blame] | 453 | LookupListIndex = self.parent.parent.repeatIndex |
| 454 | SubTableIndex = self.parent.repeatIndex |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 455 | else: # who knows how far below the SubTable level we are! Climb back up to the nearest subtable. |
Behdad Esfahbod | 9e48233 | 2013-12-17 05:46:51 -0500 | [diff] [blame] | 456 | itemName = ".".join([self.name, item.name]) |
Behdad Esfahbod | ee6340f | 2013-12-17 06:31:37 -0500 | [diff] [blame] | 457 | p1 = self.parent |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 458 | while p1 and p1.name not in ['ExtSubTable', 'SubTable']: |
Behdad Esfahbod | 9e48233 | 2013-12-17 05:46:51 -0500 | [diff] [blame] | 459 | itemName = ".".join([p1.name, item.name]) |
Behdad Esfahbod | ee6340f | 2013-12-17 06:31:37 -0500 | [diff] [blame] | 460 | p1 = p1.parent |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 461 | if p1: |
| 462 | if p1.name == 'ExtSubTable': |
Behdad Esfahbod | ee6340f | 2013-12-17 06:31:37 -0500 | [diff] [blame] | 463 | LookupListIndex = p1.parent.parent.repeatIndex |
| 464 | SubTableIndex = p1.parent.repeatIndex |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 465 | else: |
Behdad Esfahbod | ee6340f | 2013-12-17 06:31:37 -0500 | [diff] [blame] | 466 | LookupListIndex = p1.parent.repeatIndex |
Behdad Esfahbod | 9e48233 | 2013-12-17 05:46:51 -0500 | [diff] [blame] | 467 | SubTableIndex = p1.repeatIndex |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 468 | |
Behdad Esfahbod | 79f7344 | 2013-11-26 17:07:37 -0500 | [diff] [blame] | 469 | return OverflowErrorRecord( (self.globalState.tableType, LookupListIndex, SubTableIndex, itemName, itemIndex) ) |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 470 | |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 471 | |
Behdad Esfahbod | e388db5 | 2013-11-28 14:26:58 -0500 | [diff] [blame] | 472 | class CountReference(object): |
jvr | cfadfd0 | 2002-07-22 22:13:57 +0000 | [diff] [blame] | 473 | """A reference to a Count value, not a count of references.""" |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 474 | def __init__(self, table, name): |
| 475 | self.table = table |
| 476 | self.name = name |
Behdad Esfahbod | 7981704 | 2013-11-24 16:59:42 -0500 | [diff] [blame] | 477 | def setValue(self, value): |
| 478 | table = self.table |
| 479 | name = self.name |
| 480 | if table[name] is None: |
| 481 | table[name] = value |
| 482 | else: |
Behdad Esfahbod | 1f0eed8 | 2013-11-26 18:41:53 -0500 | [diff] [blame] | 483 | assert table[name] == value, (name, table[name], value) |
jvr | cfadfd0 | 2002-07-22 22:13:57 +0000 | [diff] [blame] | 484 | def getCountData(self): |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 485 | return packUShort(self.table[self.name]) |
| 486 | |
| 487 | |
jvr | 64b5c80 | 2002-05-11 10:21:36 +0000 | [diff] [blame] | 488 | def packUShort(value): |
jvr | 64b5c80 | 2002-05-11 10:21:36 +0000 | [diff] [blame] | 489 | return struct.pack(">H", value) |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 490 | |
| 491 | |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 492 | def packULong(value): |
jvr | ce47e0d | 2008-03-09 20:48:45 +0000 | [diff] [blame] | 493 | assert 0 <= value < 0x100000000, value |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 494 | return struct.pack(">L", value) |
| 495 | |
| 496 | |
Behdad Esfahbod | 5988cc3 | 2013-11-19 17:20:54 -0500 | [diff] [blame] | 497 | class BaseTable(object): |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 498 | |
Behdad Esfahbod | 398770d | 2013-12-19 15:30:24 -0500 | [diff] [blame^] | 499 | def __hash__(self): |
| 500 | return id(self) |
| 501 | |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 502 | def __getattr__(self, attr): |
Behdad Esfahbod | f650263 | 2013-12-17 05:59:05 -0500 | [diff] [blame] | 503 | reader = self.__dict__.get("reader") |
Behdad Esfahbod | dafdb29 | 2013-12-17 00:58:02 -0500 | [diff] [blame] | 504 | if reader: |
| 505 | del self.reader |
| 506 | font = self.font |
| 507 | del self.font |
| 508 | self.decompile(reader, font) |
| 509 | return getattr(self, attr) |
| 510 | |
| 511 | raise AttributeError(attr) |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 512 | |
jvr | 64b5c80 | 2002-05-11 10:21:36 +0000 | [diff] [blame] | 513 | """Generic base class for all OpenType (sub)tables.""" |
| 514 | |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 515 | def getConverters(self): |
| 516 | return self.converters |
| 517 | |
| 518 | def getConverterByName(self, name): |
| 519 | return self.convertersByName[name] |
| 520 | |
Behdad Esfahbod | 078b363 | 2013-11-24 17:08:06 -0500 | [diff] [blame] | 521 | def decompile(self, reader, font): |
jvr | f7ef96c | 2002-09-10 19:26:38 +0000 | [diff] [blame] | 522 | self.readFormat(reader) |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 523 | table = {} |
| 524 | self.__rawTable = table # for debugging |
Behdad Esfahbod | 41caf2d | 2013-11-22 19:12:14 -0500 | [diff] [blame] | 525 | converters = self.getConverters() |
| 526 | for conv in converters: |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 527 | if conv.name == "SubTable": |
Behdad Esfahbod | 79f7344 | 2013-11-26 17:07:37 -0500 | [diff] [blame] | 528 | conv = conv.getConverter(reader.globalState.tableType, |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 529 | table["LookupType"]) |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 530 | if conv.name == "ExtSubTable": |
Behdad Esfahbod | 79f7344 | 2013-11-26 17:07:37 -0500 | [diff] [blame] | 531 | conv = conv.getConverter(reader.globalState.tableType, |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 532 | table["ExtensionLookupType"]) |
Behdad Esfahbod | 9e1bd2d | 2013-11-26 19:23:08 -0500 | [diff] [blame] | 533 | if conv.name == "FeatureParams": |
| 534 | conv = conv.getConverter(reader["FeatureTag"]) |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 535 | if conv.repeat: |
| 536 | l = [] |
Behdad Esfahbod | ee27eb8 | 2013-11-24 17:34:43 -0500 | [diff] [blame] | 537 | if conv.repeat in table: |
| 538 | countValue = table[conv.repeat] |
| 539 | else: |
| 540 | # conv.repeat is a propagated count |
Behdad Esfahbod | 79f7344 | 2013-11-26 17:07:37 -0500 | [diff] [blame] | 541 | countValue = reader[conv.repeat] |
Behdad Esfahbod | 6b6e9fa | 2013-11-24 22:11:41 -0500 | [diff] [blame] | 542 | for i in range(countValue + conv.aux): |
Behdad Esfahbod | 078b363 | 2013-11-24 17:08:06 -0500 | [diff] [blame] | 543 | l.append(conv.read(reader, font, table)) |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 544 | table[conv.name] = l |
| 545 | else: |
Behdad Esfahbod | 5b9cabc | 2013-11-25 04:01:56 -0500 | [diff] [blame] | 546 | if conv.aux and not eval(conv.aux, None, table): |
| 547 | continue |
Behdad Esfahbod | 078b363 | 2013-11-24 17:08:06 -0500 | [diff] [blame] | 548 | table[conv.name] = conv.read(reader, font, table) |
Behdad Esfahbod | 9e1bd2d | 2013-11-26 19:23:08 -0500 | [diff] [blame] | 549 | if conv.isPropagated: |
Behdad Esfahbod | 79f7344 | 2013-11-26 17:07:37 -0500 | [diff] [blame] | 550 | reader[conv.name] = table[conv.name] |
Behdad Esfahbod | 41caf2d | 2013-11-22 19:12:14 -0500 | [diff] [blame] | 551 | |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 552 | self.postRead(table, font) |
Behdad Esfahbod | 41caf2d | 2013-11-22 19:12:14 -0500 | [diff] [blame] | 553 | |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 554 | del self.__rawTable # succeeded, get rid of debugging info |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 555 | |
Behdad Esfahbod | f50d0df | 2013-11-20 18:38:46 -0500 | [diff] [blame] | 556 | def ensureDecompiled(self): |
Behdad Esfahbod | f650263 | 2013-12-17 05:59:05 -0500 | [diff] [blame] | 557 | reader = self.__dict__.get("reader") |
Behdad Esfahbod | dafdb29 | 2013-12-17 00:58:02 -0500 | [diff] [blame] | 558 | if reader: |
| 559 | del self.reader |
| 560 | font = self.font |
| 561 | del self.font |
| 562 | self.decompile(reader, font) |
Behdad Esfahbod | f50d0df | 2013-11-20 18:38:46 -0500 | [diff] [blame] | 563 | |
Behdad Esfahbod | 078b363 | 2013-11-24 17:08:06 -0500 | [diff] [blame] | 564 | def compile(self, writer, font): |
Behdad Esfahbod | 3ac9e63 | 2013-11-26 19:42:55 -0500 | [diff] [blame] | 565 | self.ensureDecompiled() |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 566 | table = self.preWrite(font) |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 567 | |
| 568 | if hasattr(self, 'sortCoverageLast'): |
| 569 | writer.sortCoverageLast = 1 |
| 570 | |
Behdad Esfahbod | 5fec22b | 2013-12-17 02:42:18 -0500 | [diff] [blame] | 571 | if hasattr(self.__class__, 'LookupType'): |
| 572 | writer['LookupType'].setValue(self.__class__.LookupType) |
| 573 | |
jvr | f7ef96c | 2002-09-10 19:26:38 +0000 | [diff] [blame] | 574 | self.writeFormat(writer) |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 575 | for conv in self.getConverters(): |
| 576 | value = table.get(conv.name) |
| 577 | if conv.repeat: |
| 578 | if value is None: |
jvr | 64b5c80 | 2002-05-11 10:21:36 +0000 | [diff] [blame] | 579 | value = [] |
Behdad Esfahbod | 6b6e9fa | 2013-11-24 22:11:41 -0500 | [diff] [blame] | 580 | countValue = len(value) - conv.aux |
Behdad Esfahbod | ee27eb8 | 2013-11-24 17:34:43 -0500 | [diff] [blame] | 581 | if conv.repeat in table: |
Behdad Esfahbod | 6bfee2c | 2013-12-09 00:28:58 -0500 | [diff] [blame] | 582 | CountReference(table, conv.repeat).setValue(countValue) |
Behdad Esfahbod | ee27eb8 | 2013-11-24 17:34:43 -0500 | [diff] [blame] | 583 | else: |
| 584 | # conv.repeat is a propagated count |
Behdad Esfahbod | 79f7344 | 2013-11-26 17:07:37 -0500 | [diff] [blame] | 585 | writer[conv.repeat].setValue(countValue) |
jvr | 823f8cd | 2006-10-21 14:12:38 +0000 | [diff] [blame] | 586 | for i in range(len(value)): |
Behdad Esfahbod | 078b363 | 2013-11-24 17:08:06 -0500 | [diff] [blame] | 587 | conv.write(writer, font, table, value[i], i) |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 588 | elif conv.isCount: |
| 589 | # Special-case Count values. |
| 590 | # Assumption: a Count field will *always* precede |
Behdad Esfahbod | ee27eb8 | 2013-11-24 17:34:43 -0500 | [diff] [blame] | 591 | # the actual array(s). |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 592 | # We need a default value, as it may be set later by a nested |
Behdad Esfahbod | 41caf2d | 2013-11-22 19:12:14 -0500 | [diff] [blame] | 593 | # table. We will later store it here. |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 594 | # We add a reference: by the time the data is assembled |
| 595 | # the Count value will be filled in. |
Behdad Esfahbod | ee27eb8 | 2013-11-24 17:34:43 -0500 | [diff] [blame] | 596 | ref = writer.writeCountReference(table, conv.name) |
Behdad Esfahbod | 6bfee2c | 2013-12-09 00:28:58 -0500 | [diff] [blame] | 597 | table[conv.name] = None |
Behdad Esfahbod | 9e1bd2d | 2013-11-26 19:23:08 -0500 | [diff] [blame] | 598 | if conv.isPropagated: |
Behdad Esfahbod | 79f7344 | 2013-11-26 17:07:37 -0500 | [diff] [blame] | 599 | writer[conv.name] = ref |
Behdad Esfahbod | 5fec22b | 2013-12-17 02:42:18 -0500 | [diff] [blame] | 600 | elif conv.isLookupType: |
| 601 | ref = writer.writeCountReference(table, conv.name) |
| 602 | table[conv.name] = None |
| 603 | writer['LookupType'] = ref |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 604 | else: |
Behdad Esfahbod | 5b9cabc | 2013-11-25 04:01:56 -0500 | [diff] [blame] | 605 | if conv.aux and not eval(conv.aux, None, table): |
| 606 | continue |
Behdad Esfahbod | 078b363 | 2013-11-24 17:08:06 -0500 | [diff] [blame] | 607 | conv.write(writer, font, table, value) |
Behdad Esfahbod | 9e1bd2d | 2013-11-26 19:23:08 -0500 | [diff] [blame] | 608 | if conv.isPropagated: |
| 609 | writer[conv.name] = value |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 610 | |
jvr | f7ef96c | 2002-09-10 19:26:38 +0000 | [diff] [blame] | 611 | def readFormat(self, reader): |
| 612 | pass |
| 613 | |
| 614 | def writeFormat(self, writer): |
| 615 | pass |
| 616 | |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 617 | def postRead(self, table, font): |
| 618 | self.__dict__.update(table) |
| 619 | |
| 620 | def preWrite(self, font): |
| 621 | return self.__dict__.copy() |
| 622 | |
Behdad Esfahbod | d76fa68 | 2013-12-09 00:39:25 -0500 | [diff] [blame] | 623 | def toXML(self, xmlWriter, font, attrs=None, name=None): |
| 624 | tableName = name if name else self.__class__.__name__ |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 625 | if attrs is None: |
| 626 | attrs = [] |
| 627 | if hasattr(self, "Format"): |
jvr | 64b5c80 | 2002-05-11 10:21:36 +0000 | [diff] [blame] | 628 | attrs = attrs + [("Format", self.Format)] |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 629 | xmlWriter.begintag(tableName, attrs) |
| 630 | xmlWriter.newline() |
| 631 | self.toXML2(xmlWriter, font) |
| 632 | xmlWriter.endtag(tableName) |
| 633 | xmlWriter.newline() |
| 634 | |
| 635 | def toXML2(self, xmlWriter, font): |
| 636 | # Simpler variant of toXML, *only* for the top level tables (like GPOS, GSUB). |
| 637 | # This is because in TTX our parent writes our main tag, and in otBase.py we |
| 638 | # do it ourselves. I think I'm getting schizophrenic... |
| 639 | for conv in self.getConverters(): |
jvr | 64b5c80 | 2002-05-11 10:21:36 +0000 | [diff] [blame] | 640 | if conv.repeat: |
Behdad Esfahbod | 5b9cabc | 2013-11-25 04:01:56 -0500 | [diff] [blame] | 641 | value = getattr(self, conv.name) |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 642 | for i in range(len(value)): |
| 643 | item = value[i] |
jvr | 64b5c80 | 2002-05-11 10:21:36 +0000 | [diff] [blame] | 644 | conv.xmlWrite(xmlWriter, font, item, conv.name, |
| 645 | [("index", i)]) |
| 646 | else: |
Behdad Esfahbod | 5b9cabc | 2013-11-25 04:01:56 -0500 | [diff] [blame] | 647 | if conv.aux and not eval(conv.aux, None, vars(self)): |
| 648 | continue |
| 649 | value = getattr(self, conv.name) |
jvr | 64b5c80 | 2002-05-11 10:21:36 +0000 | [diff] [blame] | 650 | conv.xmlWrite(xmlWriter, font, value, conv.name, []) |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 651 | |
Behdad Esfahbod | 3a9fd30 | 2013-11-27 03:19:32 -0500 | [diff] [blame] | 652 | def fromXML(self, name, attrs, content, font): |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 653 | try: |
| 654 | conv = self.getConverterByName(name) |
| 655 | except KeyError: |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 656 | raise # XXX on KeyError, raise nice error |
| 657 | value = conv.xmlRead(attrs, content, font) |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 658 | if conv.repeat: |
jvr | 52966bb | 2002-09-12 16:45:48 +0000 | [diff] [blame] | 659 | seq = getattr(self, conv.name, None) |
| 660 | if seq is None: |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 661 | seq = [] |
jvr | 64b5c80 | 2002-05-11 10:21:36 +0000 | [diff] [blame] | 662 | setattr(self, conv.name, seq) |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 663 | seq.append(value) |
| 664 | else: |
jvr | 64b5c80 | 2002-05-11 10:21:36 +0000 | [diff] [blame] | 665 | setattr(self, conv.name, value) |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 666 | |
Behdad Esfahbod | 8ea6439 | 2013-12-06 22:25:48 -0500 | [diff] [blame] | 667 | def __ne__(self, other): |
| 668 | return not self.__eq__(other) |
Behdad Esfahbod | b7fd2e1 | 2013-11-27 18:58:45 -0500 | [diff] [blame] | 669 | def __eq__(self, other): |
| 670 | if type(self) != type(other): |
Behdad Esfahbod | 273a900 | 2013-12-07 03:40:44 -0500 | [diff] [blame] | 671 | return NotImplemented |
Behdad Esfahbod | 96b321c | 2013-08-17 11:11:22 -0400 | [diff] [blame] | 672 | |
Behdad Esfahbod | f50d0df | 2013-11-20 18:38:46 -0500 | [diff] [blame] | 673 | self.ensureDecompiled() |
Behdad Esfahbod | b7fd2e1 | 2013-11-27 18:58:45 -0500 | [diff] [blame] | 674 | other.ensureDecompiled() |
Behdad Esfahbod | f50d0df | 2013-11-20 18:38:46 -0500 | [diff] [blame] | 675 | |
Behdad Esfahbod | b7fd2e1 | 2013-11-27 18:58:45 -0500 | [diff] [blame] | 676 | return self.__dict__ == other.__dict__ |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 677 | |
| 678 | |
| 679 | class FormatSwitchingBaseTable(BaseTable): |
| 680 | |
jvr | cfadfd0 | 2002-07-22 22:13:57 +0000 | [diff] [blame] | 681 | """Minor specialization of BaseTable, for tables that have multiple |
jvr | 64b5c80 | 2002-05-11 10:21:36 +0000 | [diff] [blame] | 682 | formats, eg. CoverageFormat1 vs. CoverageFormat2.""" |
| 683 | |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 684 | def getConverters(self): |
| 685 | return self.converters[self.Format] |
| 686 | |
| 687 | def getConverterByName(self, name): |
| 688 | return self.convertersByName[self.Format][name] |
| 689 | |
jvr | f7ef96c | 2002-09-10 19:26:38 +0000 | [diff] [blame] | 690 | def readFormat(self, reader): |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 691 | self.Format = reader.readUShort() |
Behdad Esfahbod | 180ace6 | 2013-11-27 02:40:30 -0500 | [diff] [blame] | 692 | assert self.Format != 0, (self, reader.pos, len(reader.data)) |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 693 | |
jvr | f7ef96c | 2002-09-10 19:26:38 +0000 | [diff] [blame] | 694 | def writeFormat(self, writer): |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 695 | writer.writeUShort(self.Format) |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 696 | |
Behdad Esfahbod | d76fa68 | 2013-12-09 00:39:25 -0500 | [diff] [blame] | 697 | def toXML(self, xmlWriter, font, attrs=None, name=None): |
| 698 | BaseTable.toXML(self, xmlWriter, font, attrs, name=self.__class__.__name__) |
| 699 | |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 700 | |
jvr | 64b5c80 | 2002-05-11 10:21:36 +0000 | [diff] [blame] | 701 | # |
| 702 | # Support for ValueRecords |
| 703 | # |
| 704 | # This data type is so different from all other OpenType data types that |
| 705 | # it requires quite a bit of code for itself. It even has special support |
| 706 | # in OTTableReader and OTTableWriter... |
| 707 | # |
| 708 | |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 709 | valueRecordFormat = [ |
| 710 | # Mask Name isDevice signed |
| 711 | (0x0001, "XPlacement", 0, 1), |
| 712 | (0x0002, "YPlacement", 0, 1), |
| 713 | (0x0004, "XAdvance", 0, 1), |
| 714 | (0x0008, "YAdvance", 0, 1), |
| 715 | (0x0010, "XPlaDevice", 1, 0), |
| 716 | (0x0020, "YPlaDevice", 1, 0), |
| 717 | (0x0040, "XAdvDevice", 1, 0), |
| 718 | (0x0080, "YAdvDevice", 1, 0), |
| 719 | # reserved: |
| 720 | (0x0100, "Reserved1", 0, 0), |
| 721 | (0x0200, "Reserved2", 0, 0), |
| 722 | (0x0400, "Reserved3", 0, 0), |
| 723 | (0x0800, "Reserved4", 0, 0), |
| 724 | (0x1000, "Reserved5", 0, 0), |
| 725 | (0x2000, "Reserved6", 0, 0), |
| 726 | (0x4000, "Reserved7", 0, 0), |
| 727 | (0x8000, "Reserved8", 0, 0), |
| 728 | ] |
| 729 | |
| 730 | def _buildDict(): |
| 731 | d = {} |
| 732 | for mask, name, isDevice, signed in valueRecordFormat: |
| 733 | d[name] = mask, isDevice, signed |
| 734 | return d |
| 735 | |
| 736 | valueRecordFormatDict = _buildDict() |
| 737 | |
| 738 | |
Behdad Esfahbod | e388db5 | 2013-11-28 14:26:58 -0500 | [diff] [blame] | 739 | class ValueRecordFactory(object): |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 740 | |
jvr | 64b5c80 | 2002-05-11 10:21:36 +0000 | [diff] [blame] | 741 | """Given a format code, this object convert ValueRecords.""" |
Behdad Esfahbod | d01c44a | 2013-11-22 15:21:41 -0500 | [diff] [blame] | 742 | |
Behdad Esfahbod | 601bb94 | 2013-11-23 20:20:39 -0500 | [diff] [blame] | 743 | def __init__(self, valueFormat): |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 744 | format = [] |
| 745 | for mask, name, isDevice, signed in valueRecordFormat: |
| 746 | if valueFormat & mask: |
| 747 | format.append((name, isDevice, signed)) |
| 748 | self.format = format |
| 749 | |
| 750 | def readValueRecord(self, reader, font): |
| 751 | format = self.format |
| 752 | if not format: |
| 753 | return None |
| 754 | valueRecord = ValueRecord() |
| 755 | for name, isDevice, signed in format: |
| 756 | if signed: |
| 757 | value = reader.readShort() |
| 758 | else: |
| 759 | value = reader.readUShort() |
| 760 | if isDevice: |
| 761 | if value: |
Behdad Esfahbod | 2b06aaa | 2013-11-27 02:34:11 -0500 | [diff] [blame] | 762 | from . import otTables |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 763 | subReader = reader.getSubReader(value) |
| 764 | value = getattr(otTables, name)() |
| 765 | value.decompile(subReader, font) |
| 766 | else: |
| 767 | value = None |
| 768 | setattr(valueRecord, name, value) |
| 769 | return valueRecord |
| 770 | |
| 771 | def writeValueRecord(self, writer, font, valueRecord): |
| 772 | for name, isDevice, signed in self.format: |
| 773 | value = getattr(valueRecord, name, 0) |
| 774 | if isDevice: |
| 775 | if value: |
| 776 | subWriter = writer.getSubWriter() |
| 777 | writer.writeSubTable(subWriter) |
| 778 | value.compile(subWriter, font) |
| 779 | else: |
| 780 | writer.writeUShort(0) |
| 781 | elif signed: |
| 782 | writer.writeShort(value) |
| 783 | else: |
| 784 | writer.writeUShort(value) |
| 785 | |
| 786 | |
Behdad Esfahbod | e388db5 | 2013-11-28 14:26:58 -0500 | [diff] [blame] | 787 | class ValueRecord(object): |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 788 | |
| 789 | # see ValueRecordFactory |
| 790 | |
| 791 | def getFormat(self): |
| 792 | format = 0 |
| 793 | for name in self.__dict__.keys(): |
| 794 | format = format | valueRecordFormatDict[name][0] |
| 795 | return format |
| 796 | |
| 797 | def toXML(self, xmlWriter, font, valueName, attrs=None): |
| 798 | if attrs is None: |
| 799 | simpleItems = [] |
| 800 | else: |
| 801 | simpleItems = list(attrs) |
| 802 | for mask, name, isDevice, format in valueRecordFormat[:4]: # "simple" values |
| 803 | if hasattr(self, name): |
| 804 | simpleItems.append((name, getattr(self, name))) |
| 805 | deviceItems = [] |
| 806 | for mask, name, isDevice, format in valueRecordFormat[4:8]: # device records |
| 807 | if hasattr(self, name): |
| 808 | device = getattr(self, name) |
| 809 | if device is not None: |
| 810 | deviceItems.append((name, device)) |
| 811 | if deviceItems: |
| 812 | xmlWriter.begintag(valueName, simpleItems) |
| 813 | xmlWriter.newline() |
| 814 | for name, deviceRecord in deviceItems: |
| 815 | if deviceRecord is not None: |
| 816 | deviceRecord.toXML(xmlWriter, font) |
| 817 | xmlWriter.endtag(valueName) |
| 818 | xmlWriter.newline() |
| 819 | else: |
| 820 | xmlWriter.simpletag(valueName, simpleItems) |
| 821 | xmlWriter.newline() |
| 822 | |
Behdad Esfahbod | 3a9fd30 | 2013-11-27 03:19:32 -0500 | [diff] [blame] | 823 | def fromXML(self, name, attrs, content, font): |
Behdad Esfahbod | 2b06aaa | 2013-11-27 02:34:11 -0500 | [diff] [blame] | 824 | from . import otTables |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 825 | for k, v in attrs.items(): |
| 826 | setattr(self, k, int(v)) |
| 827 | for element in content: |
Behdad Esfahbod | b774f9f | 2013-11-27 05:17:37 -0500 | [diff] [blame] | 828 | if not isinstance(element, tuple): |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 829 | continue |
| 830 | name, attrs, content = element |
| 831 | value = getattr(otTables, name)() |
| 832 | for elem2 in content: |
Behdad Esfahbod | b774f9f | 2013-11-27 05:17:37 -0500 | [diff] [blame] | 833 | if not isinstance(elem2, tuple): |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 834 | continue |
Behdad Esfahbod | 3a9fd30 | 2013-11-27 03:19:32 -0500 | [diff] [blame] | 835 | name2, attrs2, content2 = elem2 |
| 836 | value.fromXML(name2, attrs2, content2, font) |
jvr | d4d1513 | 2002-05-11 00:59:27 +0000 | [diff] [blame] | 837 | setattr(self, name, value) |
| 838 | |
Behdad Esfahbod | 8ea6439 | 2013-12-06 22:25:48 -0500 | [diff] [blame] | 839 | def __ne__(self, other): |
| 840 | return not self.__eq__(other) |
Behdad Esfahbod | b7fd2e1 | 2013-11-27 18:58:45 -0500 | [diff] [blame] | 841 | def __eq__(self, other): |
| 842 | if type(self) != type(other): |
Behdad Esfahbod | 273a900 | 2013-12-07 03:40:44 -0500 | [diff] [blame] | 843 | return NotImplemented |
Behdad Esfahbod | b7fd2e1 | 2013-11-27 18:58:45 -0500 | [diff] [blame] | 844 | return self.__dict__ == other.__dict__ |