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