blob: 823171c014d208e93dc11b0ef95909ee8e5507ac [file] [log] [blame]
jvrd4d15132002-05-11 00:59:27 +00001from DefaultTable import DefaultTable
2import otData
3import struct
4from types import TupleType
5
jvr823f8cd2006-10-21 14:12:38 +00006class 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
17class OTLOffsetOverflowError(Exception):
18 def __init__(self, overflowErrorRecord):
19 self.value = overflowErrorRecord
20
21 def __str__(self):
22 return repr(self.value)
23
jvrd4d15132002-05-11 00:59:27 +000024
25class BaseTTXConverter(DefaultTable):
26
jvr3a6aa232003-09-02 19:23:13 +000027 """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 """
jvr64b5c802002-05-11 10:21:36 +000031
jvrd4d15132002-05-11 00:59:27 +000032 def decompile(self, data, font):
33 import otTables
Behdad Esfahbod0585b642013-11-22 16:20:59 -050034 cachingStats = None if True else {}
jvrcfadfd02002-07-22 22:13:57 +000035 reader = OTTableReader(data, self.tableTag, cachingStats=cachingStats)
jvrd4d15132002-05-11 00:59:27 +000036 tableClass = getattr(otTables, self.tableTag)
37 self.table = tableClass()
38 self.table.decompile(reader, font)
Behdad Esfahbod0585b642013-11-22 16:20:59 -050039 if cachingStats:
jvrcfadfd02002-07-22 22:13:57 +000040 stats = [(v, k) for k, v in cachingStats.items()]
41 stats.sort()
42 stats.reverse()
43 print "cachingsstats for ", self.tableTag
44 for v, k in stats:
45 if v < 2:
46 break
47 print v, k
48 print "---", len(stats)
jvrd4d15132002-05-11 00:59:27 +000049
50 def compile(self, font):
jvr823f8cd2006-10-21 14:12:38 +000051 """ Create a top-level OTFWriter for the GPOS/GSUB table.
52 Call the compile method for the the table
jvr1c734522008-03-09 20:13:16 +000053 for each 'converter' record in the table converter list
54 call converter's write method for each item in the value.
jvr823f8cd2006-10-21 14:12:38 +000055 - For simple items, the write method adds a string to the
56 writer's self.items list.
jvr1c734522008-03-09 20:13:16 +000057 - For Struct/Table/Subtable items, it add first adds new writer to the
jvr823f8cd2006-10-21 14:12:38 +000058 to the writer's self.items, then calls the item's compile method.
59 This creates a tree of writers, rooted at the GUSB/GPOS writer, with
60 each writer representing a table, and the writer.items list containing
61 the child data strings and writers.
jvr1c734522008-03-09 20:13:16 +000062 call the getAllData method
jvr823f8cd2006-10-21 14:12:38 +000063 call _doneWriting, which removes duplicates
jvr1c734522008-03-09 20:13:16 +000064 call _gatherTables. This traverses the tables, adding unique occurences to a flat list of tables
65 Traverse the flat list of tables, calling getDataLength on each to update their position
66 Traverse the flat list of tables again, calling getData each get the data in the table, now that
67 pos's and offset are known.
jvr823f8cd2006-10-21 14:12:38 +000068
69 If a lookup subtable overflows an offset, we have to start all over.
70 """
jvrd4d15132002-05-11 00:59:27 +000071 writer = OTTableWriter(self.tableTag)
jvr823f8cd2006-10-21 14:12:38 +000072 writer.parent = None
jvrd4d15132002-05-11 00:59:27 +000073 self.table.compile(writer, font)
jvrcfadfd02002-07-22 22:13:57 +000074 return writer.getAllData()
jvr823f8cd2006-10-21 14:12:38 +000075
jvrd4d15132002-05-11 00:59:27 +000076 def toXML(self, writer, font):
77 self.table.toXML2(writer, font)
78
79 def fromXML(self, (name, attrs, content), font):
80 import otTables
81 if not hasattr(self, "table"):
82 tableClass = getattr(otTables, self.tableTag)
83 self.table = tableClass()
84 self.table.fromXML((name, attrs, content), font)
85
86
Behdad Esfahbod3879cf92013-11-22 19:23:35 -050087class OTTableReader(object):
Behdad Esfahbod79817042013-11-24 16:59:42 -050088
jvr64b5c802002-05-11 10:21:36 +000089 """Helper class to retrieve data from an OpenType table."""
Behdad Esfahbod3879cf92013-11-22 19:23:35 -050090
Behdad Esfahbod79817042013-11-24 16:59:42 -050091 __slots__ = ('data', 'offset', 'pos', 'tableType', 'valueFormat', 'counts', 'cachingStats')
92
93 def __init__(self, data, tableType, offset=0, valueFormat=None, counts=None, cachingStats=None):
jvrd4d15132002-05-11 00:59:27 +000094 self.data = data
95 self.offset = offset
96 self.pos = offset
97 self.tableType = tableType
98 if valueFormat is None:
Behdad Esfahbod6e556aa2013-11-22 19:16:27 -050099 valueFormat = [None, None]
Behdad Esfahbod79817042013-11-24 16:59:42 -0500100 self.counts = counts
jvrd4d15132002-05-11 00:59:27 +0000101 self.valueFormat = valueFormat
102 self.cachingStats = cachingStats
Behdad Esfahbod79817042013-11-24 16:59:42 -0500103
Behdad Esfahbod0fac7fe2013-11-24 18:04:29 -0500104 def getSubReader(self, offset):
jvrd4d15132002-05-11 00:59:27 +0000105 offset = self.offset + offset
106 if self.cachingStats is not None:
Behdad Esfahbode84f9fd2013-11-24 18:05:59 -0500107 self.cachingStats[offset] = self.cachingStats.get(offset, 0) + 1
Behdad Esfahbodd01c44a2013-11-22 15:21:41 -0500108
jvrd4d15132002-05-11 00:59:27 +0000109 subReader = self.__class__(self.data, self.tableType, offset,
Behdad Esfahbod79817042013-11-24 16:59:42 -0500110 self.valueFormat, self.counts, self.cachingStats)
jvrd4d15132002-05-11 00:59:27 +0000111 return subReader
Behdad Esfahbod79817042013-11-24 16:59:42 -0500112
jvrd4d15132002-05-11 00:59:27 +0000113 def readUShort(self):
114 pos = self.pos
115 newpos = pos + 2
jvre69caf82002-05-13 18:08:19 +0000116 value, = struct.unpack(">H", self.data[pos:newpos])
jvrd4d15132002-05-11 00:59:27 +0000117 self.pos = newpos
118 return value
Behdad Esfahbod79817042013-11-24 16:59:42 -0500119
jvrd4d15132002-05-11 00:59:27 +0000120 def readShort(self):
121 pos = self.pos
122 newpos = pos + 2
jvre69caf82002-05-13 18:08:19 +0000123 value, = struct.unpack(">h", self.data[pos:newpos])
jvrd4d15132002-05-11 00:59:27 +0000124 self.pos = newpos
125 return value
Behdad Esfahbod79817042013-11-24 16:59:42 -0500126
jvrd4d15132002-05-11 00:59:27 +0000127 def readLong(self):
128 pos = self.pos
129 newpos = pos + 4
jvre69caf82002-05-13 18:08:19 +0000130 value, = struct.unpack(">l", self.data[pos:newpos])
jvrd4d15132002-05-11 00:59:27 +0000131 self.pos = newpos
132 return value
Behdad Esfahbod79817042013-11-24 16:59:42 -0500133
jvr823f8cd2006-10-21 14:12:38 +0000134 def readULong(self):
135 pos = self.pos
136 newpos = pos + 4
137 value, = struct.unpack(">L", self.data[pos:newpos])
138 self.pos = newpos
139 return value
140
jvrd4d15132002-05-11 00:59:27 +0000141 def readTag(self):
142 pos = self.pos
143 newpos = pos + 4
144 value = self.data[pos:newpos]
145 assert len(value) == 4
146 self.pos = newpos
147 return value
Behdad Esfahbod79817042013-11-24 16:59:42 -0500148
jvrd4d15132002-05-11 00:59:27 +0000149 def setValueFormat(self, format, which):
Behdad Esfahbod6e556aa2013-11-22 19:16:27 -0500150 self.valueFormat[which] = ValueRecordFactory(format)
Behdad Esfahbod79817042013-11-24 16:59:42 -0500151
jvrd4d15132002-05-11 00:59:27 +0000152 def readValueRecord(self, font, which):
153 return self.valueFormat[which].readValueRecord(self, font)
154
Behdad Esfahbod79817042013-11-24 16:59:42 -0500155 def setCount(self, name, value):
156 self.counts = self.counts.copy() if self.counts else dict()
157 self.counts[name] = value
158
159 def getCount(self, name):
160 return self.counts[name]
161
jvrd4d15132002-05-11 00:59:27 +0000162
Behdad Esfahbod3879cf92013-11-22 19:23:35 -0500163class OTTableWriter(object):
jvrd4d15132002-05-11 00:59:27 +0000164
jvr64b5c802002-05-11 10:21:36 +0000165 """Helper class to gather and assemble data for OpenType tables."""
166
Behdad Esfahbod79817042013-11-24 16:59:42 -0500167 def __init__(self, tableType, valueFormat=None, counts=None):
jvrd4d15132002-05-11 00:59:27 +0000168 self.items = []
169 self.tableType = tableType
170 if valueFormat is None:
Behdad Esfahbod6e556aa2013-11-22 19:16:27 -0500171 valueFormat = [None, None]
jvrd4d15132002-05-11 00:59:27 +0000172 self.valueFormat = valueFormat
Behdad Esfahbodee27eb82013-11-24 17:34:43 -0500173 self.counts = counts
jvrcfadfd02002-07-22 22:13:57 +0000174 self.pos = None
Behdad Esfahbod79817042013-11-24 16:59:42 -0500175
176 def setValueFormat(self, format, which):
177 self.valueFormat[which] = ValueRecordFactory(format)
178
179 def setCount(self, name, value):
180 self.counts = self.counts.copy() if self.counts else dict()
181 self.counts[name] = value
182
183 def getCount(self, name):
184 return self.counts[name]
185
jvr4105ca02002-07-23 08:43:03 +0000186 # assembler interface
187
188 def getAllData(self):
189 """Assemble all data, including all subtables."""
190 self._doneWriting()
jvr823f8cd2006-10-21 14:12:38 +0000191 tables, extTables = self._gatherTables()
jvr4105ca02002-07-23 08:43:03 +0000192 tables.reverse()
jvr823f8cd2006-10-21 14:12:38 +0000193 extTables.reverse()
jvr4105ca02002-07-23 08:43:03 +0000194 # 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()
jvr823f8cd2006-10-21 14:12:38 +0000200
201 for table in extTables:
202 table.pos = pos
203 pos = pos + table.getDataLength()
204
205
jvr4105ca02002-07-23 08:43:03 +0000206 data = []
207 for table in tables:
208 tableData = table.getData()
209 data.append(tableData)
jvr823f8cd2006-10-21 14:12:38 +0000210
211 for table in extTables:
212 tableData = table.getData()
213 data.append(tableData)
214
jvr4105ca02002-07-23 08:43:03 +0000215 return "".join(data)
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 Esfahbode0c2e8e2013-11-25 05:32:17 -0500222 if item.longOffset:
jvr823f8cd2006-10-21 14:12:38 +0000223 l = l + 4 # sizeof(ULong)
224 else:
225 l = l + 2 # sizeof(UShort)
jvr4105ca02002-07-23 08:43:03 +0000226 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
jvr823f8cd2006-10-21 14:12:38 +0000233 pos = self.pos
234 numItems = len(items)
235 for i in range(numItems):
jvr4105ca02002-07-23 08:43:03 +0000236 item = items[i]
jvr823f8cd2006-10-21 14:12:38 +0000237
jvr4105ca02002-07-23 08:43:03 +0000238 if hasattr(item, "getData"):
Behdad Esfahbode0c2e8e2013-11-25 05:32:17 -0500239 if item.longOffset:
jvr823f8cd2006-10-21 14:12:38 +0000240 items[i] = packULong(item.pos - pos)
241 else:
242 try:
243 items[i] = packUShort(item.pos - pos)
244 except AssertionError:
245 # provide data to fix overflow problem.
Behdad Esfahbod58acba22013-11-24 20:08:05 -0500246 # If the overflow is to a lookup, or from a lookup to a subtable,
jvr823f8cd2006-10-21 14:12:38 +0000247 # just report the current item.
248 if self.name in [ 'LookupList', 'Lookup']:
249 overflowErrorRecord = self.getOverflowErrorRecord(item)
250 else:
251 # overflow is within a subTable. Life is more complicated.
252 # If we split the sub-table just before the current item, we may still suffer overflow.
253 # This is because duplicate table merging is done only within an Extension subTable tree;
254 # when we split the subtable in two, some items may no longer be duplicates.
255 # Get worst case by adding up all the item lengths, depth first traversal.
256 # and then report the first item that overflows a short.
257 def getDeepItemLength(table):
258 if hasattr(table, "getDataLength"):
259 length = 0
260 for item in table.items:
261 length = length + getDeepItemLength(item)
262 else:
263 length = len(table)
264 return length
265
266 length = self.getDataLength()
267 if hasattr(self, "sortCoverageLast") and item.name == "Coverage":
268 # Coverage is first in the item list, but last in the table list,
269 # The original overflow is really in the item list. Skip the Coverage
270 # table in the following test.
271 items = items[i+1:]
272
273 for j in range(len(items)):
274 item = items[j]
275 length = length + getDeepItemLength(item)
276 if length > 65535:
277 break
278 overflowErrorRecord = self.getOverflowErrorRecord(item)
279
280
281 raise OTLOffsetOverflowError, overflowErrorRecord
282
jvr4105ca02002-07-23 08:43:03 +0000283 return "".join(items)
jvrd4d15132002-05-11 00:59:27 +0000284
jvrcfadfd02002-07-22 22:13:57 +0000285 def __hash__(self):
286 # only works after self._doneWriting() has been called
287 return hash(self.items)
288
289 def __cmp__(self, other):
Behdad Esfahbod0ba7aa72013-10-28 12:07:15 +0100290 if type(self) != type(other): return cmp(type(self), type(other))
291 if self.__class__ != other.__class__: return cmp(self.__class__, other.__class__)
Behdad Esfahbod96b321c2013-08-17 11:11:22 -0400292
293 return cmp(self.items, other.items)
jvrcfadfd02002-07-22 22:13:57 +0000294
jvrcfadfd02002-07-22 22:13:57 +0000295 def _doneWriting(self, internedTables=None):
jvr823f8cd2006-10-21 14:12:38 +0000296 # Convert CountData references to data string items
297 # collapse duplicate table references to a unique entry
298 # "tables" are OTTableWriter objects.
299
300 # For Extension Lookup types, we can
301 # eliminate duplicates only within the tree under the Extension Lookup,
302 # as offsets may exceed 64K even between Extension LookupTable subtables.
jvrcfadfd02002-07-22 22:13:57 +0000303 if internedTables is None:
304 internedTables = {}
305 items = self.items
jvr823f8cd2006-10-21 14:12:38 +0000306 iRange = range(len(items))
307
308 if hasattr(self, "Extension"):
309 newTree = 1
310 else:
311 newTree = 0
312 for i in iRange:
jvrcfadfd02002-07-22 22:13:57 +0000313 item = items[i]
314 if hasattr(item, "getCountData"):
315 items[i] = item.getCountData()
316 elif hasattr(item, "getData"):
jvr823f8cd2006-10-21 14:12:38 +0000317 if newTree:
318 item._doneWriting()
jvrcfadfd02002-07-22 22:13:57 +0000319 else:
jvr823f8cd2006-10-21 14:12:38 +0000320 item._doneWriting(internedTables)
321 if internedTables.has_key(item):
322 items[i] = item = internedTables[item]
323 else:
324 internedTables[item] = item
jvrcfadfd02002-07-22 22:13:57 +0000325 self.items = tuple(items)
326
jvr823f8cd2006-10-21 14:12:38 +0000327 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.
jvrcfadfd02002-07-22 22:13:57 +0000336 tables = []
jvr823f8cd2006-10-21 14:12:38 +0000337 extTables = []
jvrcfadfd02002-07-22 22:13:57 +0000338 done = {}
jvr823f8cd2006-10-21 14:12:38 +0000339
340 done[self] = 1
341
342 numItems = len(self.items)
343 iRange = range(numItems)
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
360 if not done.has_key(item):
361 item._gatherTables(tables, extTables, done)
362 else:
363 index = max(item.parent.keys())
364 item.parent[index + 1] = self
365
366 saveItem = None
367 for i in iRange:
368 item = self.items[i]
jvrcfadfd02002-07-22 22:13:57 +0000369 if not hasattr(item, "getData"):
370 continue
jvr823f8cd2006-10-21 14:12:38 +0000371
372 if sortCoverageLast and (i==1) and item.name == 'Coverage':
373 # we've already 'gathered' it above
374 continue
375
376 if appendExtensions:
377 assert extTables != None, "Program or XML editing error. Extension subtables cannot contain extensions subtables"
378 newDone = {}
379 item._gatherTables(extTables, None, newDone)
380
381 elif not done.has_key(item):
382 item._gatherTables(tables, extTables, done)
383 else:
384 index = max(item.parent.keys())
385 item.parent[index + 1] = self
386
387
jvrcfadfd02002-07-22 22:13:57 +0000388 tables.append(self)
jvr823f8cd2006-10-21 14:12:38 +0000389 return tables, extTables
jvrcfadfd02002-07-22 22:13:57 +0000390
jvr4105ca02002-07-23 08:43:03 +0000391 # interface for gathering data, as used by table.compile()
jvrcfadfd02002-07-22 22:13:57 +0000392
jvr4105ca02002-07-23 08:43:03 +0000393 def getSubWriter(self):
Behdad Esfahbod79817042013-11-24 16:59:42 -0500394 subwriter = self.__class__(self.tableType, self.valueFormat, self.counts)
jvr823f8cd2006-10-21 14:12:38 +0000395 subwriter.parent = {0:self} # because some subtables have idential values, we discard
396 # the duplicates under the getAllData method. Hence some
397 # subtable writers can have more than one parent writer.
398 return subwriter
jvrd4d15132002-05-11 00:59:27 +0000399
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))
406
407 def writeLong(self, value):
408 self.items.append(struct.pack(">l", value))
409
jvr823f8cd2006-10-21 14:12:38 +0000410 def writeULong(self, value):
411 self.items.append(struct.pack(">L", value))
412
jvrd4d15132002-05-11 00:59:27 +0000413 def writeTag(self, tag):
414 assert len(tag) == 4
415 self.items.append(tag)
416
417 def writeSubTable(self, subWriter):
418 self.items.append(subWriter)
419
420 def writeCountReference(self, table, name):
Behdad Esfahbod79817042013-11-24 16:59:42 -0500421 ref = CountReference(table, name)
422 self.items.append(ref)
Behdad Esfahbodee27eb82013-11-24 17:34:43 -0500423 return ref
jvrd4d15132002-05-11 00:59:27 +0000424
425 def writeStruct(self, format, values):
426 data = apply(struct.pack, (format,) + values)
427 self.items.append(data)
428
jvr823f8cd2006-10-21 14:12:38 +0000429 def writeData(self, data):
430 self.items.append(data)
431
jvrd4d15132002-05-11 00:59:27 +0000432 def writeValueRecord(self, value, font, which):
433 return self.valueFormat[which].writeValueRecord(self, font, value)
434
jvr823f8cd2006-10-21 14:12:38 +0000435 def getOverflowErrorRecord(self, item):
436 LookupListIndex = SubTableIndex = itemName = itemIndex = None
437 if self.name == 'LookupList':
438 LookupListIndex = item.repeatIndex
439 elif self.name == 'Lookup':
440 LookupListIndex = self.repeatIndex
441 SubTableIndex = item.repeatIndex
442 else:
443 itemName = item.name
444 if hasattr(item, 'repeatIndex'):
445 itemIndex = item.repeatIndex
446 if self.name == 'SubTable':
447 LookupListIndex = self.parent[0].repeatIndex
448 SubTableIndex = self.repeatIndex
449 elif self.name == 'ExtSubTable':
450 LookupListIndex = self.parent[0].parent[0].repeatIndex
451 SubTableIndex = self.parent[0].repeatIndex
452 else: # who knows how far below the SubTable level we are! Climb back up to the nearest subtable.
453 itemName = ".".join(self.name, item.name)
454 p1 = self.parent[0]
455 while p1 and p1.name not in ['ExtSubTable', 'SubTable']:
456 itemName = ".".join(p1.name, item.name)
457 p1 = p1.parent[0]
458 if p1:
459 if p1.name == 'ExtSubTable':
460 LookupListIndex = self.parent[0].parent[0].repeatIndex
461 SubTableIndex = self.parent[0].repeatIndex
462 else:
463 LookupListIndex = self.parent[0].repeatIndex
464 SubTableIndex = self.repeatIndex
465
466 return OverflowErrorRecord( (self.tableType, LookupListIndex, SubTableIndex, itemName, itemIndex) )
467
jvrd4d15132002-05-11 00:59:27 +0000468
469class CountReference:
jvrcfadfd02002-07-22 22:13:57 +0000470 """A reference to a Count value, not a count of references."""
jvrd4d15132002-05-11 00:59:27 +0000471 def __init__(self, table, name):
472 self.table = table
473 self.name = name
Behdad Esfahbod79817042013-11-24 16:59:42 -0500474 def setValue(self, value):
475 table = self.table
476 name = self.name
477 if table[name] is None:
478 table[name] = value
479 else:
480 assert table[name] == value, (table[name], value)
jvrcfadfd02002-07-22 22:13:57 +0000481 def getCountData(self):
jvrd4d15132002-05-11 00:59:27 +0000482 return packUShort(self.table[self.name])
483
484
jvr64b5c802002-05-11 10:21:36 +0000485def packUShort(value):
jvrcfadfd02002-07-22 22:13:57 +0000486 assert 0 <= value < 0x10000, value
jvr64b5c802002-05-11 10:21:36 +0000487 return struct.pack(">H", value)
jvrd4d15132002-05-11 00:59:27 +0000488
489
jvr823f8cd2006-10-21 14:12:38 +0000490def packULong(value):
jvrce47e0d2008-03-09 20:48:45 +0000491 assert 0 <= value < 0x100000000, value
jvr823f8cd2006-10-21 14:12:38 +0000492 return struct.pack(">L", value)
493
494
Behdad Esfahbod5988cc32013-11-19 17:20:54 -0500495class BaseTable(object):
jvr823f8cd2006-10-21 14:12:38 +0000496 def __init__(self):
497 self.compileStatus = 0 # 0 means table was created
498 # 1 means the table.read() function was called by a table which is subject
499 # to delayed compilation
500 # 2 means that it was subject to delayed compilation, and
501 # has been decompiled
jvr823f8cd2006-10-21 14:12:38 +0000502
503 self.recurse = 0
jvrd4d15132002-05-11 00:59:27 +0000504
jvr823f8cd2006-10-21 14:12:38 +0000505 def __getattr__(self, attr):
506 # we get here only when the table does not have the attribute.
507 # This method ovveride exists so that we can try to de-compile
508 # a table which is subject to delayed decompilation, and then try
509 # to get the value again after decompilation.
510 self.recurse +=1
511 if self.recurse > 2:
512 # shouldn't ever get here - we should only get to two levels of recursion.
513 # this guards against self.decompile NOT setting compileStatus to other than 1.
514 raise AttributeError, attr
515 if self.compileStatus == 1:
Behdad Esfahbodf50d0df2013-11-20 18:38:46 -0500516 self.ensureDecompiled()
jvr823f8cd2006-10-21 14:12:38 +0000517 val = getattr(self, attr)
518 self.recurse -=1
519 return val
520
521 raise AttributeError, attr
522
523
jvr64b5c802002-05-11 10:21:36 +0000524 """Generic base class for all OpenType (sub)tables."""
525
jvrd4d15132002-05-11 00:59:27 +0000526 def getConverters(self):
527 return self.converters
528
529 def getConverterByName(self, name):
530 return self.convertersByName[name]
531
Behdad Esfahbod078b3632013-11-24 17:08:06 -0500532 def decompile(self, reader, font):
jvr823f8cd2006-10-21 14:12:38 +0000533 self.compileStatus = 2 # table has been decompiled.
jvrf7ef96c2002-09-10 19:26:38 +0000534 self.readFormat(reader)
jvrd4d15132002-05-11 00:59:27 +0000535 table = {}
536 self.__rawTable = table # for debugging
Behdad Esfahbod41caf2d2013-11-22 19:12:14 -0500537 converters = self.getConverters()
538 for conv in converters:
jvrd4d15132002-05-11 00:59:27 +0000539 if conv.name == "SubTable":
540 conv = conv.getConverter(reader.tableType,
541 table["LookupType"])
jvr823f8cd2006-10-21 14:12:38 +0000542 if conv.name == "ExtSubTable":
543 conv = conv.getConverter(reader.tableType,
544 table["ExtensionLookupType"])
jvrd4d15132002-05-11 00:59:27 +0000545 if conv.repeat:
546 l = []
Behdad Esfahbodee27eb82013-11-24 17:34:43 -0500547 if conv.repeat in table:
548 countValue = table[conv.repeat]
549 else:
550 # conv.repeat is a propagated count
551 countValue = reader.getCount(conv.repeat)
Behdad Esfahbod6b6e9fa2013-11-24 22:11:41 -0500552 for i in range(countValue + conv.aux):
Behdad Esfahbod078b3632013-11-24 17:08:06 -0500553 l.append(conv.read(reader, font, table))
jvrd4d15132002-05-11 00:59:27 +0000554 table[conv.name] = l
555 else:
Behdad Esfahbod5b9cabc2013-11-25 04:01:56 -0500556 if conv.aux and not eval(conv.aux, None, table):
557 continue
Behdad Esfahbod078b3632013-11-24 17:08:06 -0500558 table[conv.name] = conv.read(reader, font, table)
Behdad Esfahbodee27eb82013-11-24 17:34:43 -0500559 if conv.isPropagatedCount:
Behdad Esfahbod79817042013-11-24 16:59:42 -0500560 reader.setCount(conv.name, table[conv.name])
Behdad Esfahbod41caf2d2013-11-22 19:12:14 -0500561
jvrd4d15132002-05-11 00:59:27 +0000562 self.postRead(table, font)
Behdad Esfahbod41caf2d2013-11-22 19:12:14 -0500563
jvrd4d15132002-05-11 00:59:27 +0000564 del self.__rawTable # succeeded, get rid of debugging info
jvr823f8cd2006-10-21 14:12:38 +0000565
Behdad Esfahbodf50d0df2013-11-20 18:38:46 -0500566 def ensureDecompiled(self):
567 if self.compileStatus != 1:
568 return
Behdad Esfahbodc491f452013-11-24 18:28:20 -0500569 subReader = self.reader.getSubReader(self.offset)
570 self.decompile(subReader, self.font)
571 del self.reader, self.font, self.offset
Behdad Esfahbodf50d0df2013-11-20 18:38:46 -0500572
Behdad Esfahbod078b3632013-11-24 17:08:06 -0500573 def compile(self, writer, font):
jvrd4d15132002-05-11 00:59:27 +0000574 table = self.preWrite(font)
jvr823f8cd2006-10-21 14:12:38 +0000575
576 if hasattr(self, 'sortCoverageLast'):
577 writer.sortCoverageLast = 1
578
jvrf7ef96c2002-09-10 19:26:38 +0000579 self.writeFormat(writer)
jvrd4d15132002-05-11 00:59:27 +0000580 for conv in self.getConverters():
581 value = table.get(conv.name)
582 if conv.repeat:
583 if value is None:
jvr64b5c802002-05-11 10:21:36 +0000584 value = []
Behdad Esfahbod6b6e9fa2013-11-24 22:11:41 -0500585 countValue = len(value) - conv.aux
Behdad Esfahbodee27eb82013-11-24 17:34:43 -0500586 if conv.repeat in table:
587 ref = table[conv.repeat]
588 table[conv.repeat] = None
589 ref.setValue(countValue)
590 else:
591 # conv.repeat is a propagated count
592 writer.getCount(conv.repeat).setValue(countValue)
jvr823f8cd2006-10-21 14:12:38 +0000593 for i in range(len(value)):
Behdad Esfahbod078b3632013-11-24 17:08:06 -0500594 conv.write(writer, font, table, value[i], i)
jvrd4d15132002-05-11 00:59:27 +0000595 elif conv.isCount:
596 # Special-case Count values.
597 # Assumption: a Count field will *always* precede
Behdad Esfahbodee27eb82013-11-24 17:34:43 -0500598 # the actual array(s).
jvrd4d15132002-05-11 00:59:27 +0000599 # We need a default value, as it may be set later by a nested
Behdad Esfahbod41caf2d2013-11-22 19:12:14 -0500600 # table. We will later store it here.
jvrd4d15132002-05-11 00:59:27 +0000601 # We add a reference: by the time the data is assembled
602 # the Count value will be filled in.
Behdad Esfahbodee27eb82013-11-24 17:34:43 -0500603 ref = writer.writeCountReference(table, conv.name)
604 if conv.isPropagatedCount:
605 table[conv.name] = None
606 writer.setCount(conv.name, ref)
607 else:
608 table[conv.name] = ref
jvrd4d15132002-05-11 00:59:27 +0000609 else:
Behdad Esfahbod5b9cabc2013-11-25 04:01:56 -0500610 if conv.aux and not eval(conv.aux, None, table):
611 continue
Behdad Esfahbod078b3632013-11-24 17:08:06 -0500612 conv.write(writer, font, table, value)
jvrd4d15132002-05-11 00:59:27 +0000613
jvrf7ef96c2002-09-10 19:26:38 +0000614 def readFormat(self, reader):
615 pass
616
617 def writeFormat(self, writer):
618 pass
619
jvrd4d15132002-05-11 00:59:27 +0000620 def postRead(self, table, font):
621 self.__dict__.update(table)
622
623 def preWrite(self, font):
Behdad Esfahbodf50d0df2013-11-20 18:38:46 -0500624 self.ensureDecompiled()
jvrd4d15132002-05-11 00:59:27 +0000625 return self.__dict__.copy()
626
627 def toXML(self, xmlWriter, font, attrs=None):
628 tableName = self.__class__.__name__
629 if attrs is None:
630 attrs = []
631 if hasattr(self, "Format"):
jvr64b5c802002-05-11 10:21:36 +0000632 attrs = attrs + [("Format", self.Format)]
jvrd4d15132002-05-11 00:59:27 +0000633 xmlWriter.begintag(tableName, attrs)
634 xmlWriter.newline()
635 self.toXML2(xmlWriter, font)
636 xmlWriter.endtag(tableName)
637 xmlWriter.newline()
638
639 def toXML2(self, xmlWriter, font):
640 # Simpler variant of toXML, *only* for the top level tables (like GPOS, GSUB).
641 # This is because in TTX our parent writes our main tag, and in otBase.py we
642 # do it ourselves. I think I'm getting schizophrenic...
643 for conv in self.getConverters():
jvr64b5c802002-05-11 10:21:36 +0000644 if conv.repeat:
Behdad Esfahbod5b9cabc2013-11-25 04:01:56 -0500645 value = getattr(self, conv.name)
jvrd4d15132002-05-11 00:59:27 +0000646 for i in range(len(value)):
647 item = value[i]
jvr64b5c802002-05-11 10:21:36 +0000648 conv.xmlWrite(xmlWriter, font, item, conv.name,
649 [("index", i)])
650 else:
Behdad Esfahbod5b9cabc2013-11-25 04:01:56 -0500651 if conv.aux and not eval(conv.aux, None, vars(self)):
652 continue
653 value = getattr(self, conv.name)
jvr64b5c802002-05-11 10:21:36 +0000654 conv.xmlWrite(xmlWriter, font, value, conv.name, [])
jvrd4d15132002-05-11 00:59:27 +0000655
656 def fromXML(self, (name, attrs, content), font):
657 try:
658 conv = self.getConverterByName(name)
659 except KeyError:
jvrd4d15132002-05-11 00:59:27 +0000660 raise # XXX on KeyError, raise nice error
661 value = conv.xmlRead(attrs, content, font)
jvrd4d15132002-05-11 00:59:27 +0000662 if conv.repeat:
jvr52966bb2002-09-12 16:45:48 +0000663 seq = getattr(self, conv.name, None)
664 if seq is None:
jvrd4d15132002-05-11 00:59:27 +0000665 seq = []
jvr64b5c802002-05-11 10:21:36 +0000666 setattr(self, conv.name, seq)
jvrd4d15132002-05-11 00:59:27 +0000667 seq.append(value)
668 else:
jvr64b5c802002-05-11 10:21:36 +0000669 setattr(self, conv.name, value)
jvrd4d15132002-05-11 00:59:27 +0000670
671 def __cmp__(self, other):
Behdad Esfahbod0ba7aa72013-10-28 12:07:15 +0100672 if type(self) != type(other): return cmp(type(self), type(other))
673 if self.__class__ != other.__class__: return cmp(self.__class__, other.__class__)
Behdad Esfahbod96b321c2013-08-17 11:11:22 -0400674
Behdad Esfahbodf50d0df2013-11-20 18:38:46 -0500675 self.ensureDecompiled()
676
Behdad Esfahbod96b321c2013-08-17 11:11:22 -0400677 return cmp(self.__dict__, other.__dict__)
jvrd4d15132002-05-11 00:59:27 +0000678
679
680class FormatSwitchingBaseTable(BaseTable):
681
jvrcfadfd02002-07-22 22:13:57 +0000682 """Minor specialization of BaseTable, for tables that have multiple
jvr64b5c802002-05-11 10:21:36 +0000683 formats, eg. CoverageFormat1 vs. CoverageFormat2."""
684
jvrd4d15132002-05-11 00:59:27 +0000685 def getConverters(self):
686 return self.converters[self.Format]
687
688 def getConverterByName(self, name):
689 return self.convertersByName[self.Format][name]
690
jvrf7ef96c2002-09-10 19:26:38 +0000691 def readFormat(self, reader):
jvrd4d15132002-05-11 00:59:27 +0000692 self.Format = reader.readUShort()
693 assert self.Format <> 0, (self, reader.pos, len(reader.data))
jvrd4d15132002-05-11 00:59:27 +0000694
jvrf7ef96c2002-09-10 19:26:38 +0000695 def writeFormat(self, writer):
jvrd4d15132002-05-11 00:59:27 +0000696 writer.writeUShort(self.Format)
jvrd4d15132002-05-11 00:59:27 +0000697
698
jvr64b5c802002-05-11 10:21:36 +0000699#
700# Support for ValueRecords
701#
702# This data type is so different from all other OpenType data types that
703# it requires quite a bit of code for itself. It even has special support
704# in OTTableReader and OTTableWriter...
705#
706
jvrd4d15132002-05-11 00:59:27 +0000707valueRecordFormat = [
708# Mask Name isDevice signed
709 (0x0001, "XPlacement", 0, 1),
710 (0x0002, "YPlacement", 0, 1),
711 (0x0004, "XAdvance", 0, 1),
712 (0x0008, "YAdvance", 0, 1),
713 (0x0010, "XPlaDevice", 1, 0),
714 (0x0020, "YPlaDevice", 1, 0),
715 (0x0040, "XAdvDevice", 1, 0),
716 (0x0080, "YAdvDevice", 1, 0),
717# reserved:
718 (0x0100, "Reserved1", 0, 0),
719 (0x0200, "Reserved2", 0, 0),
720 (0x0400, "Reserved3", 0, 0),
721 (0x0800, "Reserved4", 0, 0),
722 (0x1000, "Reserved5", 0, 0),
723 (0x2000, "Reserved6", 0, 0),
724 (0x4000, "Reserved7", 0, 0),
725 (0x8000, "Reserved8", 0, 0),
726]
727
728def _buildDict():
729 d = {}
730 for mask, name, isDevice, signed in valueRecordFormat:
731 d[name] = mask, isDevice, signed
732 return d
733
734valueRecordFormatDict = _buildDict()
735
736
737class ValueRecordFactory:
738
jvr64b5c802002-05-11 10:21:36 +0000739 """Given a format code, this object convert ValueRecords."""
Behdad Esfahbodd01c44a2013-11-22 15:21:41 -0500740
Behdad Esfahbod601bb942013-11-23 20:20:39 -0500741 def __init__(self, valueFormat):
jvrd4d15132002-05-11 00:59:27 +0000742 format = []
743 for mask, name, isDevice, signed in valueRecordFormat:
744 if valueFormat & mask:
745 format.append((name, isDevice, signed))
746 self.format = format
747
748 def readValueRecord(self, reader, font):
749 format = self.format
750 if not format:
751 return None
752 valueRecord = ValueRecord()
753 for name, isDevice, signed in format:
754 if signed:
755 value = reader.readShort()
756 else:
757 value = reader.readUShort()
758 if isDevice:
759 if value:
760 import otTables
761 subReader = reader.getSubReader(value)
762 value = getattr(otTables, name)()
763 value.decompile(subReader, font)
764 else:
765 value = None
766 setattr(valueRecord, name, value)
767 return valueRecord
768
769 def writeValueRecord(self, writer, font, valueRecord):
770 for name, isDevice, signed in self.format:
771 value = getattr(valueRecord, name, 0)
772 if isDevice:
773 if value:
774 subWriter = writer.getSubWriter()
775 writer.writeSubTable(subWriter)
776 value.compile(subWriter, font)
777 else:
778 writer.writeUShort(0)
779 elif signed:
780 writer.writeShort(value)
781 else:
782 writer.writeUShort(value)
783
784
785class ValueRecord:
786
787 # see ValueRecordFactory
788
789 def getFormat(self):
790 format = 0
791 for name in self.__dict__.keys():
792 format = format | valueRecordFormatDict[name][0]
793 return format
794
795 def toXML(self, xmlWriter, font, valueName, attrs=None):
796 if attrs is None:
797 simpleItems = []
798 else:
799 simpleItems = list(attrs)
800 for mask, name, isDevice, format in valueRecordFormat[:4]: # "simple" values
801 if hasattr(self, name):
802 simpleItems.append((name, getattr(self, name)))
803 deviceItems = []
804 for mask, name, isDevice, format in valueRecordFormat[4:8]: # device records
805 if hasattr(self, name):
806 device = getattr(self, name)
807 if device is not None:
808 deviceItems.append((name, device))
809 if deviceItems:
810 xmlWriter.begintag(valueName, simpleItems)
811 xmlWriter.newline()
812 for name, deviceRecord in deviceItems:
813 if deviceRecord is not None:
814 deviceRecord.toXML(xmlWriter, font)
815 xmlWriter.endtag(valueName)
816 xmlWriter.newline()
817 else:
818 xmlWriter.simpletag(valueName, simpleItems)
819 xmlWriter.newline()
820
821 def fromXML(self, (name, attrs, content), font):
822 import otTables
823 for k, v in attrs.items():
824 setattr(self, k, int(v))
825 for element in content:
826 if type(element) <> TupleType:
827 continue
828 name, attrs, content = element
829 value = getattr(otTables, name)()
830 for elem2 in content:
831 if type(elem2) <> TupleType:
832 continue
833 value.fromXML(elem2, font)
834 setattr(self, name, value)
835
836 def __cmp__(self, other):
Behdad Esfahbod0ba7aa72013-10-28 12:07:15 +0100837 if type(self) != type(other): return cmp(type(self), type(other))
838 if self.__class__ != other.__class__: return cmp(self.__class__, other.__class__)
jvrd4d15132002-05-11 00:59:27 +0000839
Behdad Esfahbod96b321c2013-08-17 11:11:22 -0400840 return cmp(self.__dict__, other.__dict__)