subset.py revision 10a3fff5cba3e94c97e18e8cd83fed0d2549dca4 
1# Copyright 2013 Google, Inc. All Rights Reserved.
2#
3# Google Author(s): Behdad Esfahbod
4
5"""Python OpenType Layout Subsetter.
6
7Later grown into full OpenType subsetter, supporting all standard tables.
8"""
9
10from __future__ import print_function, division
11from fontTools.misc.py23 import *
12from fontTools import ttLib
13from fontTools.ttLib.tables import otTables
14from fontTools.misc import psCharStrings
15from fontTools.pens import basePen
16import sys
17import struct
18import time
19import array
20
21
22def _add_method(*clazzes):
23  """Returns a decorator function that adds a new method to one or
24  more classes."""
25  def wrapper(method):
26    for clazz in clazzes:
27      assert clazz.__name__ != 'DefaultTable', 'Oops, table class not found.'
28      assert not hasattr(clazz, method.__name__), \
29          "Oops, class '%s' has method '%s'." % (clazz.__name__,
30                                                 method.__name__)
31      setattr(clazz, method.__name__, method)
32    return None
33  return wrapper
34
35def _uniq_sort(l):
36  return sorted(set(l))
37
38def _set_update(s, *others):
39  # Jython's set.update only takes one other argument.
40  # Emulate real set.update...
41  for other in others:
42    s.update(other)
43
44
45@_add_method(otTables.Coverage)
46def intersect(self, glyphs):
47  "Returns ascending list of matching coverage values."
48  return [i for i,g in enumerate(self.glyphs) if g in glyphs]
49
50@_add_method(otTables.Coverage)
51def intersect_glyphs(self, glyphs):
52  "Returns set of intersecting glyphs."
53  return set(g for g in self.glyphs if g in glyphs)
54
55@_add_method(otTables.Coverage)
56def subset(self, glyphs):
57  "Returns ascending list of remaining coverage values."
58  indices = self.intersect(glyphs)
59  self.glyphs = [g for g in self.glyphs if g in glyphs]
60  return indices
61
62@_add_method(otTables.Coverage)
63def remap(self, coverage_map):
64  "Remaps coverage."
65  self.glyphs = [self.glyphs[i] for i in coverage_map]
66
67@_add_method(otTables.ClassDef)
68def intersect(self, glyphs):
69  "Returns ascending list of matching class values."
70  return _uniq_sort(
71     ([0] if any(g not in self.classDefs for g in glyphs) else []) +
72      [v for g,v in self.classDefs.items() if g in glyphs])
73
74@_add_method(otTables.ClassDef)
75def intersect_class(self, glyphs, klass):
76  "Returns set of glyphs matching class."
77  if klass == 0:
78    return set(g for g in glyphs if g not in self.classDefs)
79  return set(g for g,v in self.classDefs.items()
80              if v == klass and g in glyphs)
81
82@_add_method(otTables.ClassDef)
83def subset(self, glyphs, remap=False):
84  "Returns ascending list of remaining classes."
85  self.classDefs = dict((g,v) for g,v in self.classDefs.items() if g in glyphs)
86  # Note: while class 0 has the special meaning of "not matched",
87  # if no glyph will ever /not match/, we can optimize class 0 out too.
88  indices = _uniq_sort(
89     ([0] if any(g not in self.classDefs for g in glyphs) else []) +
90      list(self.classDefs.values()))
91  if remap:
92    self.remap(indices)
93  return indices
94
95@_add_method(otTables.ClassDef)
96def remap(self, class_map):
97  "Remaps classes."
98  self.classDefs = dict((g,class_map.index(v))
99                         for g,v in self.classDefs.items())
100
101@_add_method(otTables.SingleSubst)
102def closure_glyphs(self, s, cur_glyphs=None):
103  if cur_glyphs is None: cur_glyphs = s.glyphs
104  if self.Format in [1, 2]:
105    s.glyphs.update(v for g,v in self.mapping.items() if g in cur_glyphs)
106  else:
107    assert 0, "unknown format: %s" % self.Format
108
109@_add_method(otTables.SingleSubst)
110def subset_glyphs(self, s):
111  if self.Format in [1, 2]:
112    self.mapping = dict((g,v) for g,v in self.mapping.items()
113                        if g in s.glyphs and v in s.glyphs)
114    return bool(self.mapping)
115  else:
116    assert 0, "unknown format: %s" % self.Format
117
118@_add_method(otTables.MultipleSubst)
119def closure_glyphs(self, s, cur_glyphs=None):
120  if cur_glyphs is None: cur_glyphs = s.glyphs
121  if self.Format == 1:
122    indices = self.Coverage.intersect(cur_glyphs)
123    _set_update(s.glyphs, *(self.Sequence[i].Substitute for i in indices))
124  else:
125    assert 0, "unknown format: %s" % self.Format
126
127@_add_method(otTables.MultipleSubst)
128def subset_glyphs(self, s):
129  if self.Format == 1:
130    indices = self.Coverage.subset(s.glyphs)
131    self.Sequence = [self.Sequence[i] for i in indices]
132    # Now drop rules generating glyphs we don't want
133    indices = [i for i,seq in enumerate(self.Sequence)
134         if all(sub in s.glyphs for sub in seq.Substitute)]
135    self.Sequence = [self.Sequence[i] for i in indices]
136    self.Coverage.remap(indices)
137    self.SequenceCount = len(self.Sequence)
138    return bool(self.SequenceCount)
139  else:
140    assert 0, "unknown format: %s" % self.Format
141
142@_add_method(otTables.AlternateSubst)
143def closure_glyphs(self, s, cur_glyphs=None):
144  if cur_glyphs is None: cur_glyphs = s.glyphs
145  if self.Format == 1:
146    _set_update(s.glyphs, *(vlist for g,vlist in self.alternates.items()
147                            if g in cur_glyphs))
148  else:
149    assert 0, "unknown format: %s" % self.Format
150
151@_add_method(otTables.AlternateSubst)
152def subset_glyphs(self, s):
153  if self.Format == 1:
154    self.alternates = dict((g,vlist)
155                           for g,vlist in self.alternates.items()
156                           if g in s.glyphs and
157                              all(v in s.glyphs for v in vlist))
158    return bool(self.alternates)
159  else:
160    assert 0, "unknown format: %s" % self.Format
161
162@_add_method(otTables.LigatureSubst)
163def closure_glyphs(self, s, cur_glyphs=None):
164  if cur_glyphs is None: cur_glyphs = s.glyphs
165  if self.Format == 1:
166    _set_update(s.glyphs, *([seq.LigGlyph for seq in seqs
167                             if all(c in s.glyphs for c in seq.Component)]
168                            for g,seqs in self.ligatures.items()
169                            if g in cur_glyphs))
170  else:
171    assert 0, "unknown format: %s" % self.Format
172
173@_add_method(otTables.LigatureSubst)
174def subset_glyphs(self, s):
175  if self.Format == 1:
176    self.ligatures = dict((g,v) for g,v in self.ligatures.items()
177                          if g in s.glyphs)
178    self.ligatures = dict((g,[seq for seq in seqs
179                              if seq.LigGlyph in s.glyphs and
180                                 all(c in s.glyphs for c in seq.Component)])
181                           for g,seqs in self.ligatures.items())
182    self.ligatures = dict((g,v) for g,v in self.ligatures.items() if v)
183    return bool(self.ligatures)
184  else:
185    assert 0, "unknown format: %s" % self.Format
186
187@_add_method(otTables.ReverseChainSingleSubst)
188def closure_glyphs(self, s, cur_glyphs=None):
189  if cur_glyphs is None: cur_glyphs = s.glyphs
190  if self.Format == 1:
191    indices = self.Coverage.intersect(cur_glyphs)
192    if(not indices or
193        not all(c.intersect(s.glyphs)
194                 for c in self.LookAheadCoverage + self.BacktrackCoverage)):
195      return
196    s.glyphs.update(self.Substitute[i] for i in indices)
197  else:
198    assert 0, "unknown format: %s" % self.Format
199
200@_add_method(otTables.ReverseChainSingleSubst)
201def subset_glyphs(self, s):
202  if self.Format == 1:
203    indices = self.Coverage.subset(s.glyphs)
204    self.Substitute = [self.Substitute[i] for i in indices]
205    # Now drop rules generating glyphs we don't want
206    indices = [i for i,sub in enumerate(self.Substitute)
207         if sub in s.glyphs]
208    self.Substitute = [self.Substitute[i] for i in indices]
209    self.Coverage.remap(indices)
210    self.GlyphCount = len(self.Substitute)
211    return bool(self.GlyphCount and
212                 all(c.subset(s.glyphs)
213                      for c in self.LookAheadCoverage+self.BacktrackCoverage))
214  else:
215    assert 0, "unknown format: %s" % self.Format
216
217@_add_method(otTables.SinglePos)
218def subset_glyphs(self, s):
219  if self.Format == 1:
220    return len(self.Coverage.subset(s.glyphs))
221  elif self.Format == 2:
222    indices = self.Coverage.subset(s.glyphs)
223    self.Value = [self.Value[i] for i in indices]
224    self.ValueCount = len(self.Value)
225    return bool(self.ValueCount)
226  else:
227    assert 0, "unknown format: %s" % self.Format
228
229@_add_method(otTables.SinglePos)
230def prune_post_subset(self, options):
231  if not options.hinting:
232    # Drop device tables
233    self.ValueFormat &= ~0x00F0
234  return True
235
236@_add_method(otTables.PairPos)
237def subset_glyphs(self, s):
238  if self.Format == 1:
239    indices = self.Coverage.subset(s.glyphs)
240    self.PairSet = [self.PairSet[i] for i in indices]
241    for p in self.PairSet:
242      p.PairValueRecord = [r for r in p.PairValueRecord
243                           if r.SecondGlyph in s.glyphs]
244      p.PairValueCount = len(p.PairValueRecord)
245    self.PairSet = [p for p in self.PairSet if p.PairValueCount]
246    self.PairSetCount = len(self.PairSet)
247    return bool(self.PairSetCount)
248  elif self.Format == 2:
249    class1_map = self.ClassDef1.subset(s.glyphs, remap=True)
250    class2_map = self.ClassDef2.subset(s.glyphs, remap=True)
251    self.Class1Record = [self.Class1Record[i] for i in class1_map]
252    for c in self.Class1Record:
253      c.Class2Record = [c.Class2Record[i] for i in class2_map]
254    self.Class1Count = len(class1_map)
255    self.Class2Count = len(class2_map)
256    return bool(self.Class1Count and
257                 self.Class2Count and
258                 self.Coverage.subset(s.glyphs))
259  else:
260    assert 0, "unknown format: %s" % self.Format
261
262@_add_method(otTables.PairPos)
263def prune_post_subset(self, options):
264  if not options.hinting:
265    # Drop device tables
266    self.ValueFormat1 &= ~0x00F0
267    self.ValueFormat2 &= ~0x00F0
268  return True
269
270@_add_method(otTables.CursivePos)
271def subset_glyphs(self, s):
272  if self.Format == 1:
273    indices = self.Coverage.subset(s.glyphs)
274    self.EntryExitRecord = [self.EntryExitRecord[i] for i in indices]
275    self.EntryExitCount = len(self.EntryExitRecord)
276    return bool(self.EntryExitCount)
277  else:
278    assert 0, "unknown format: %s" % self.Format
279
280@_add_method(otTables.Anchor)
281def prune_hints(self):
282  # Drop device tables / contour anchor point
283  self.Format = 1
284
285@_add_method(otTables.CursivePos)
286def prune_post_subset(self, options):
287  if not options.hinting:
288    for rec in self.EntryExitRecord:
289      if rec.EntryAnchor: rec.EntryAnchor.prune_hints()
290      if rec.ExitAnchor: rec.ExitAnchor.prune_hints()
291  return True
292
293@_add_method(otTables.MarkBasePos)
294def subset_glyphs(self, s):
295  if self.Format == 1:
296    mark_indices = self.MarkCoverage.subset(s.glyphs)
297    self.MarkArray.MarkRecord = [self.MarkArray.MarkRecord[i]
298                                 for i in mark_indices]
299    self.MarkArray.MarkCount = len(self.MarkArray.MarkRecord)
300    base_indices = self.BaseCoverage.subset(s.glyphs)
301    self.BaseArray.BaseRecord = [self.BaseArray.BaseRecord[i]
302                                 for i in base_indices]
303    self.BaseArray.BaseCount = len(self.BaseArray.BaseRecord)
304    # Prune empty classes
305    class_indices = _uniq_sort(v.Class for v in self.MarkArray.MarkRecord)
306    self.ClassCount = len(class_indices)
307    for m in self.MarkArray.MarkRecord:
308      m.Class = class_indices.index(m.Class)
309    for b in self.BaseArray.BaseRecord:
310      b.BaseAnchor = [b.BaseAnchor[i] for i in class_indices]
311    return bool(self.ClassCount and
312                 self.MarkArray.MarkCount and
313                 self.BaseArray.BaseCount)
314  else:
315    assert 0, "unknown format: %s" % self.Format
316
317@_add_method(otTables.MarkBasePos)
318def prune_post_subset(self, options):
319    if not options.hinting:
320      for m in self.MarkArray.MarkRecord:
321        if m.MarkAnchor:
322          m.MarkAnchor.prune_hints()
323      for b in self.BaseArray.BaseRecord:
324        for a in b.BaseAnchor:
325          if a:
326            a.prune_hints()
327    return True
328
329@_add_method(otTables.MarkLigPos)
330def subset_glyphs(self, s):
331  if self.Format == 1:
332    mark_indices = self.MarkCoverage.subset(s.glyphs)
333    self.MarkArray.MarkRecord = [self.MarkArray.MarkRecord[i]
334                                 for i in mark_indices]
335    self.MarkArray.MarkCount = len(self.MarkArray.MarkRecord)
336    ligature_indices = self.LigatureCoverage.subset(s.glyphs)
337    self.LigatureArray.LigatureAttach = [self.LigatureArray.LigatureAttach[i]
338                                         for i in ligature_indices]
339    self.LigatureArray.LigatureCount = len(self.LigatureArray.LigatureAttach)
340    # Prune empty classes
341    class_indices = _uniq_sort(v.Class for v in self.MarkArray.MarkRecord)
342    self.ClassCount = len(class_indices)
343    for m in self.MarkArray.MarkRecord:
344      m.Class = class_indices.index(m.Class)
345    for l in self.LigatureArray.LigatureAttach:
346      for c in l.ComponentRecord:
347        c.LigatureAnchor = [c.LigatureAnchor[i] for i in class_indices]
348    return bool(self.ClassCount and
349                 self.MarkArray.MarkCount and
350                 self.LigatureArray.LigatureCount)
351  else:
352    assert 0, "unknown format: %s" % self.Format
353
354@_add_method(otTables.MarkLigPos)
355def prune_post_subset(self, options):
356    if not options.hinting:
357      for m in self.MarkArray.MarkRecord:
358        if m.MarkAnchor:
359          m.MarkAnchor.prune_hints()
360      for l in self.LigatureArray.LigatureAttach:
361        for c in l.ComponentRecord:
362          for a in c.LigatureAnchor:
363            if a:
364              a.prune_hints()
365    return True
366
367@_add_method(otTables.MarkMarkPos)
368def subset_glyphs(self, s):
369  if self.Format == 1:
370    mark1_indices = self.Mark1Coverage.subset(s.glyphs)
371    self.Mark1Array.MarkRecord = [self.Mark1Array.MarkRecord[i]
372                                  for i in mark1_indices]
373    self.Mark1Array.MarkCount = len(self.Mark1Array.MarkRecord)
374    mark2_indices = self.Mark2Coverage.subset(s.glyphs)
375    self.Mark2Array.Mark2Record = [self.Mark2Array.Mark2Record[i]
376                                   for i in mark2_indices]
377    self.Mark2Array.MarkCount = len(self.Mark2Array.Mark2Record)
378    # Prune empty classes
379    class_indices = _uniq_sort(v.Class for v in self.Mark1Array.MarkRecord)
380    self.ClassCount = len(class_indices)
381    for m in self.Mark1Array.MarkRecord:
382      m.Class = class_indices.index(m.Class)
383    for b in self.Mark2Array.Mark2Record:
384      b.Mark2Anchor = [b.Mark2Anchor[i] for i in class_indices]
385    return bool(self.ClassCount and
386                 self.Mark1Array.MarkCount and
387                 self.Mark2Array.MarkCount)
388  else:
389    assert 0, "unknown format: %s" % self.Format
390
391@_add_method(otTables.MarkMarkPos)
392def prune_post_subset(self, options):
393    if not options.hinting:
394      # Drop device tables or contour anchor point
395      for m in self.Mark1Array.MarkRecord:
396        if m.MarkAnchor:
397          m.MarkAnchor.prune_hints()
398      for b in self.Mark2Array.Mark2Record:
399        for m in b.Mark2Anchor:
400          if m:
401            m.prune_hints()
402    return True
403
404@_add_method(otTables.SingleSubst,
405             otTables.MultipleSubst,
406             otTables.AlternateSubst,
407             otTables.LigatureSubst,
408             otTables.ReverseChainSingleSubst,
409             otTables.SinglePos,
410             otTables.PairPos,
411             otTables.CursivePos,
412             otTables.MarkBasePos,
413             otTables.MarkLigPos,
414             otTables.MarkMarkPos)
415def subset_lookups(self, lookup_indices):
416  pass
417
418@_add_method(otTables.SingleSubst,
419             otTables.MultipleSubst,
420             otTables.AlternateSubst,
421             otTables.LigatureSubst,
422             otTables.ReverseChainSingleSubst,
423             otTables.SinglePos,
424             otTables.PairPos,
425             otTables.CursivePos,
426             otTables.MarkBasePos,
427             otTables.MarkLigPos,
428             otTables.MarkMarkPos)
429def collect_lookups(self):
430  return []
431
432@_add_method(otTables.SingleSubst,
433             otTables.MultipleSubst,
434             otTables.AlternateSubst,
435             otTables.LigatureSubst,
436             otTables.ContextSubst,
437             otTables.ChainContextSubst,
438             otTables.ReverseChainSingleSubst,
439             otTables.SinglePos,
440             otTables.PairPos,
441             otTables.CursivePos,
442             otTables.MarkBasePos,
443             otTables.MarkLigPos,
444             otTables.MarkMarkPos,
445             otTables.ContextPos,
446             otTables.ChainContextPos)
447def prune_pre_subset(self, options):
448  return True
449
450@_add_method(otTables.SingleSubst,
451             otTables.MultipleSubst,
452             otTables.AlternateSubst,
453             otTables.LigatureSubst,
454             otTables.ReverseChainSingleSubst,
455             otTables.ContextSubst,
456             otTables.ChainContextSubst,
457             otTables.ContextPos,
458             otTables.ChainContextPos)
459def prune_post_subset(self, options):
460  return True
461
462@_add_method(otTables.SingleSubst,
463             otTables.AlternateSubst,
464             otTables.ReverseChainSingleSubst)
465def may_have_non_1to1(self):
466  return False
467
468@_add_method(otTables.MultipleSubst,
469             otTables.LigatureSubst,
470             otTables.ContextSubst,
471             otTables.ChainContextSubst)
472def may_have_non_1to1(self):
473  return True
474
475@_add_method(otTables.ContextSubst,
476             otTables.ChainContextSubst,
477             otTables.ContextPos,
478             otTables.ChainContextPos)
479def __classify_context(self):
480
481  class ContextHelper(object):
482    def __init__(self, klass, Format):
483      if klass.__name__.endswith('Subst'):
484        Typ = 'Sub'
485        Type = 'Subst'
486      else:
487        Typ = 'Pos'
488        Type = 'Pos'
489      if klass.__name__.startswith('Chain'):
490        Chain = 'Chain'
491      else:
492        Chain = ''
493      ChainTyp = Chain+Typ
494
495      self.Typ = Typ
496      self.Type = Type
497      self.Chain = Chain
498      self.ChainTyp = ChainTyp
499
500      self.LookupRecord = Type+'LookupRecord'
501
502      if Format == 1:
503        Coverage = lambda r: r.Coverage
504        ChainCoverage = lambda r: r.Coverage
505        ContextData = lambda r:(None,)
506        ChainContextData = lambda r:(None, None, None)
507        RuleData = lambda r:(r.Input,)
508        ChainRuleData = lambda r:(r.Backtrack, r.Input, r.LookAhead)
509        SetRuleData = None
510        ChainSetRuleData = None
511      elif Format == 2:
512        Coverage = lambda r: r.Coverage
513        ChainCoverage = lambda r: r.Coverage
514        ContextData = lambda r:(r.ClassDef,)
515        ChainContextData = lambda r:(r.LookAheadClassDef,
516                                      r.InputClassDef,
517                                      r.BacktrackClassDef)
518        RuleData = lambda r:(r.Class,)
519        ChainRuleData = lambda r:(r.LookAhead, r.Input, r.Backtrack)
520        def SetRuleData(r, d):(r.Class,) = d
521        def ChainSetRuleData(r, d):(r.LookAhead, r.Input, r.Backtrack) = d
522      elif Format == 3:
523        Coverage = lambda r: r.Coverage[0]
524        ChainCoverage = lambda r: r.InputCoverage[0]
525        ContextData = None
526        ChainContextData = None
527        RuleData = lambda r: r.Coverage
528        ChainRuleData = lambda r:(r.LookAheadCoverage +
529                                   r.InputCoverage +
530                                   r.BacktrackCoverage)
531        SetRuleData = None
532        ChainSetRuleData = None
533      else:
534        assert 0, "unknown format: %s" % Format
535
536      if Chain:
537        self.Coverage = ChainCoverage
538        self.ContextData = ChainContextData
539        self.RuleData = ChainRuleData
540        self.SetRuleData = ChainSetRuleData
541      else:
542        self.Coverage = Coverage
543        self.ContextData = ContextData
544        self.RuleData = RuleData
545        self.SetRuleData = SetRuleData
546
547      if Format == 1:
548        self.Rule = ChainTyp+'Rule'
549        self.RuleCount = ChainTyp+'RuleCount'
550        self.RuleSet = ChainTyp+'RuleSet'
551        self.RuleSetCount = ChainTyp+'RuleSetCount'
552        self.Intersect = lambda glyphs, c, r: [r] if r in glyphs else []
553      elif Format == 2:
554        self.Rule = ChainTyp+'ClassRule'
555        self.RuleCount = ChainTyp+'ClassRuleCount'
556        self.RuleSet = ChainTyp+'ClassSet'
557        self.RuleSetCount = ChainTyp+'ClassSetCount'
558        self.Intersect = lambda glyphs, c, r: c.intersect_class(glyphs, r)
559
560        self.ClassDef = 'InputClassDef' if Chain else 'ClassDef'
561        self.ClassDefIndex = 1 if Chain else 0
562        self.Input = 'Input' if Chain else 'Class'
563
564  if self.Format not in [1, 2, 3]:
565    return None  # Don't shoot the messenger; let it go
566  if not hasattr(self.__class__, "__ContextHelpers"):
567    self.__class__.__ContextHelpers = {}
568  if self.Format not in self.__class__.__ContextHelpers:
569    helper = ContextHelper(self.__class__, self.Format)
570    self.__class__.__ContextHelpers[self.Format] = helper
571  return self.__class__.__ContextHelpers[self.Format]
572
573@_add_method(otTables.ContextSubst,
574             otTables.ChainContextSubst)
575def closure_glyphs(self, s, cur_glyphs=None):
576  if cur_glyphs is None: cur_glyphs = s.glyphs
577  c = self.__classify_context()
578
579  indices = c.Coverage(self).intersect(s.glyphs)
580  if not indices:
581    return []
582  cur_glyphs = c.Coverage(self).intersect_glyphs(s.glyphs);
583
584  if self.Format == 1:
585    ContextData = c.ContextData(self)
586    rss = getattr(self, c.RuleSet)
587    rssCount = getattr(self, c.RuleSetCount)
588    for i in indices:
589      if i >= rssCount or not rss[i]: continue
590      for r in getattr(rss[i], c.Rule):
591        if not r: continue
592        if all(all(c.Intersect(s.glyphs, cd, k) for k in klist)
593          for cd,klist in zip(ContextData, c.RuleData(r))):
594          chaos = False
595          for ll in getattr(r, c.LookupRecord):
596            if not ll: continue
597            seqi = ll.SequenceIndex
598            if chaos:
599              pos_glyphs = s.glyphs
600            else:
601              if seqi == 0:
602                pos_glyphs = set([c.Coverage(self).glyphs[i]])
603              else:
604                pos_glyphs = set([r.Input[seqi - 1]])
605            lookup = s.table.LookupList.Lookup[ll.LookupListIndex]
606            chaos = chaos or lookup.may_have_non_1to1()
607            lookup.closure_glyphs(s, cur_glyphs=pos_glyphs)
608  elif self.Format == 2:
609    ClassDef = getattr(self, c.ClassDef)
610    indices = ClassDef.intersect(cur_glyphs)
611    ContextData = c.ContextData(self)
612    rss = getattr(self, c.RuleSet)
613    rssCount = getattr(self, c.RuleSetCount)
614    for i in indices:
615      if i >= rssCount or not rss[i]: continue
616      for r in getattr(rss[i], c.Rule):
617        if not r: continue
618        if all(all(c.Intersect(s.glyphs, cd, k) for k in klist)
619          for cd,klist in zip(ContextData, c.RuleData(r))):
620          chaos = False
621          for ll in getattr(r, c.LookupRecord):
622            if not ll: continue
623            seqi = ll.SequenceIndex
624            if chaos:
625              pos_glyphs = s.glyphs
626            else:
627              if seqi == 0:
628                pos_glyphs = ClassDef.intersect_class(cur_glyphs, i)
629              else:
630                pos_glyphs = ClassDef.intersect_class(s.glyphs,
631                                                      getattr(r, c.Input)[seqi - 1])
632            lookup = s.table.LookupList.Lookup[ll.LookupListIndex]
633            chaos = chaos or lookup.may_have_non_1to1()
634            lookup.closure_glyphs(s, cur_glyphs=pos_glyphs)
635  elif self.Format == 3:
636    if not all(x.intersect(s.glyphs) for x in c.RuleData(self)):
637      return []
638    r = self
639    chaos = False
640    for ll in getattr(r, c.LookupRecord):
641      if not ll: continue
642      seqi = ll.SequenceIndex
643      if chaos:
644        pos_glyphs = s.glyphs
645      else:
646        if seqi == 0:
647          pos_glyphs = cur_glyphs
648        else:
649          pos_glyphs = r.InputCoverage[seqi].intersect_glyphs(s.glyphs)
650      lookup = s.table.LookupList.Lookup[ll.LookupListIndex]
651      chaos = chaos or lookup.may_have_non_1to1()
652      lookup.closure_glyphs(s, cur_glyphs=pos_glyphs)
653  else:
654    assert 0, "unknown format: %s" % self.Format
655
656@_add_method(otTables.ContextSubst,
657             otTables.ContextPos,
658             otTables.ChainContextSubst,
659             otTables.ChainContextPos)
660def subset_glyphs(self, s):
661  c = self.__classify_context()
662
663  if self.Format == 1:
664    indices = self.Coverage.subset(s.glyphs)
665    rss = getattr(self, c.RuleSet)
666    rss = [rss[i] for i in indices]
667    for rs in rss:
668      if not rs: continue
669      ss = getattr(rs, c.Rule)
670      ss = [r for r in ss
671            if r and all(all(g in s.glyphs for g in glist)
672              for glist in c.RuleData(r))]
673      setattr(rs, c.Rule, ss)
674      setattr(rs, c.RuleCount, len(ss))
675    # Prune empty subrulesets
676    rss = [rs for rs in rss if rs and getattr(rs, c.Rule)]
677    setattr(self, c.RuleSet, rss)
678    setattr(self, c.RuleSetCount, len(rss))
679    return bool(rss)
680  elif self.Format == 2:
681    if not self.Coverage.subset(s.glyphs):
682      return False
683    ContextData = c.ContextData(self)
684    klass_maps = [x.subset(s.glyphs, remap=True) for x in ContextData]
685
686    # Keep rulesets for class numbers that survived.
687    indices = klass_maps[c.ClassDefIndex]
688    rss = getattr(self, c.RuleSet)
689    rssCount = getattr(self, c.RuleSetCount)
690    rss = [rss[i] for i in indices if i < rssCount]
691    del rssCount
692    # Delete, but not renumber, unreachable rulesets.
693    indices = getattr(self, c.ClassDef).intersect(self.Coverage.glyphs)
694    rss = [rss if i in indices else None for i,rss in enumerate(rss)]
695    while rss and rss[-1] is None:
696      del rss[-1]
697
698    for rs in rss:
699      if not rs: continue
700      ss = getattr(rs, c.Rule)
701      ss = [r for r in ss
702            if r and all(all(k in klass_map for k in klist)
703              for klass_map,klist in zip(klass_maps, c.RuleData(r)))]
704      setattr(rs, c.Rule, ss)
705      setattr(rs, c.RuleCount, len(ss))
706
707      # Remap rule classes
708      for r in ss:
709        c.SetRuleData(r, [[klass_map.index(k) for k in klist]
710               for klass_map,klist in zip(klass_maps, c.RuleData(r))])
711    return bool(rss)
712  elif self.Format == 3:
713    return all(x.subset(s.glyphs) for x in c.RuleData(self))
714  else:
715    assert 0, "unknown format: %s" % self.Format
716
717@_add_method(otTables.ContextSubst,
718             otTables.ChainContextSubst,
719             otTables.ContextPos,
720             otTables.ChainContextPos)
721def subset_lookups(self, lookup_indices):
722  c = self.__classify_context()
723
724  if self.Format in [1, 2]:
725    for rs in getattr(self, c.RuleSet):
726      if not rs: continue
727      for r in getattr(rs, c.Rule):
728        if not r: continue
729        setattr(r, c.LookupRecord,
730                 [ll for ll in getattr(r, c.LookupRecord)
731                  if ll and ll.LookupListIndex in lookup_indices])
732        for ll in getattr(r, c.LookupRecord):
733          if not ll: continue
734          ll.LookupListIndex = lookup_indices.index(ll.LookupListIndex)
735  elif self.Format == 3:
736    setattr(self, c.LookupRecord,
737             [ll for ll in getattr(self, c.LookupRecord)
738              if ll and ll.LookupListIndex in lookup_indices])
739    for ll in getattr(self, c.LookupRecord):
740      if not ll: continue
741      ll.LookupListIndex = lookup_indices.index(ll.LookupListIndex)
742  else:
743    assert 0, "unknown format: %s" % self.Format
744
745@_add_method(otTables.ContextSubst,
746             otTables.ChainContextSubst,
747             otTables.ContextPos,
748             otTables.ChainContextPos)
749def collect_lookups(self):
750  c = self.__classify_context()
751
752  if self.Format in [1, 2]:
753    return [ll.LookupListIndex
754      for rs in getattr(self, c.RuleSet) if rs
755      for r in getattr(rs, c.Rule) if r
756      for ll in getattr(r, c.LookupRecord) if ll]
757  elif self.Format == 3:
758    return [ll.LookupListIndex
759      for ll in getattr(self, c.LookupRecord) if ll]
760  else:
761    assert 0, "unknown format: %s" % self.Format
762
763@_add_method(otTables.ExtensionSubst)
764def closure_glyphs(self, s, cur_glyphs=None):
765  if self.Format == 1:
766    self.ExtSubTable.closure_glyphs(s, cur_glyphs)
767  else:
768    assert 0, "unknown format: %s" % self.Format
769
770@_add_method(otTables.ExtensionSubst)
771def may_have_non_1to1(self):
772  if self.Format == 1:
773    return self.ExtSubTable.may_have_non_1to1()
774  else:
775    assert 0, "unknown format: %s" % self.Format
776
777@_add_method(otTables.ExtensionSubst,
778             otTables.ExtensionPos)
779def prune_pre_subset(self, options):
780  if self.Format == 1:
781    return self.ExtSubTable.prune_pre_subset(options)
782  else:
783    assert 0, "unknown format: %s" % self.Format
784
785@_add_method(otTables.ExtensionSubst,
786             otTables.ExtensionPos)
787def subset_glyphs(self, s):
788  if self.Format == 1:
789    return self.ExtSubTable.subset_glyphs(s)
790  else:
791    assert 0, "unknown format: %s" % self.Format
792
793@_add_method(otTables.ExtensionSubst,
794             otTables.ExtensionPos)
795def prune_post_subset(self, options):
796  if self.Format == 1:
797    return self.ExtSubTable.prune_post_subset(options)
798  else:
799    assert 0, "unknown format: %s" % self.Format
800
801@_add_method(otTables.ExtensionSubst,
802             otTables.ExtensionPos)
803def subset_lookups(self, lookup_indices):
804  if self.Format == 1:
805    return self.ExtSubTable.subset_lookups(lookup_indices)
806  else:
807    assert 0, "unknown format: %s" % self.Format
808
809@_add_method(otTables.ExtensionSubst,
810             otTables.ExtensionPos)
811def collect_lookups(self):
812  if self.Format == 1:
813    return self.ExtSubTable.collect_lookups()
814  else:
815    assert 0, "unknown format: %s" % self.Format
816
817@_add_method(otTables.Lookup)
818def closure_glyphs(self, s, cur_glyphs=None):
819  for st in self.SubTable:
820    if not st: continue
821    st.closure_glyphs(s, cur_glyphs)
822
823@_add_method(otTables.Lookup)
824def prune_pre_subset(self, options):
825  ret = False
826  for st in self.SubTable:
827    if not st: continue
828    if st.prune_pre_subset(options): ret = True
829  return ret
830
831@_add_method(otTables.Lookup)
832def subset_glyphs(self, s):
833  self.SubTable = [st for st in self.SubTable if st and st.subset_glyphs(s)]
834  self.SubTableCount = len(self.SubTable)
835  return bool(self.SubTableCount)
836
837@_add_method(otTables.Lookup)
838def prune_post_subset(self, options):
839  ret = False
840  for st in self.SubTable:
841    if not st: continue
842    if st.prune_post_subset(options): ret = True
843  return ret
844
845@_add_method(otTables.Lookup)
846def subset_lookups(self, lookup_indices):
847  for s in self.SubTable:
848    s.subset_lookups(lookup_indices)
849
850@_add_method(otTables.Lookup)
851def collect_lookups(self):
852  return _uniq_sort(sum((st.collect_lookups() for st in self.SubTable
853                         if st), []))
854
855@_add_method(otTables.Lookup)
856def may_have_non_1to1(self):
857  return any(st.may_have_non_1to1() for st in self.SubTable if st)
858
859@_add_method(otTables.LookupList)
860def prune_pre_subset(self, options):
861  ret = False
862  for l in self.Lookup:
863    if not l: continue
864    if l.prune_pre_subset(options): ret = True
865  return ret
866
867@_add_method(otTables.LookupList)
868def subset_glyphs(self, s):
869  "Returns the indices of nonempty lookups."
870  return [i for i,l in enumerate(self.Lookup) if l and l.subset_glyphs(s)]
871
872@_add_method(otTables.LookupList)
873def prune_post_subset(self, options):
874  ret = False
875  for l in self.Lookup:
876    if not l: continue
877    if l.prune_post_subset(options): ret = True
878  return ret
879
880@_add_method(otTables.LookupList)
881def subset_lookups(self, lookup_indices):
882  self.Lookup = [self.Lookup[i] for i in lookup_indices
883                 if i < self.LookupCount]
884  self.LookupCount = len(self.Lookup)
885  for l in self.Lookup:
886    l.subset_lookups(lookup_indices)
887
888@_add_method(otTables.LookupList)
889def closure_lookups(self, lookup_indices):
890  lookup_indices = _uniq_sort(lookup_indices)
891  recurse = lookup_indices
892  while True:
893    recurse_lookups = sum((self.Lookup[i].collect_lookups()
894                            for i in recurse if i < self.LookupCount), [])
895    recurse_lookups = [l for l in recurse_lookups
896                       if l not in lookup_indices and l < self.LookupCount]
897    if not recurse_lookups:
898      return _uniq_sort(lookup_indices)
899    recurse_lookups = _uniq_sort(recurse_lookups)
900    lookup_indices.extend(recurse_lookups)
901    recurse = recurse_lookups
902
903@_add_method(otTables.Feature)
904def subset_lookups(self, lookup_indices):
905  self.LookupListIndex = [l for l in self.LookupListIndex
906                          if l in lookup_indices]
907  # Now map them.
908  self.LookupListIndex = [lookup_indices.index(l)
909                          for l in self.LookupListIndex]
910  self.LookupCount = len(self.LookupListIndex)
911  return self.LookupCount or self.FeatureParams
912
913@_add_method(otTables.Feature)
914def collect_lookups(self):
915  return self.LookupListIndex[:]
916
917@_add_method(otTables.FeatureList)
918def subset_lookups(self, lookup_indices):
919  "Returns the indices of nonempty features."
920  feature_indices = [i for i,f in enumerate(self.FeatureRecord)
921                     if f.Feature.subset_lookups(lookup_indices)]
922  self.subset_features(feature_indices)
923  return feature_indices
924
925@_add_method(otTables.FeatureList)
926def collect_lookups(self, feature_indices):
927  return _uniq_sort(sum((self.FeatureRecord[i].Feature.collect_lookups()
928                         for i in feature_indices
929                          if i < self.FeatureCount), []))
930
931@_add_method(otTables.FeatureList)
932def subset_features(self, feature_indices):
933  self.FeatureRecord = [self.FeatureRecord[i] for i in feature_indices]
934  self.FeatureCount = len(self.FeatureRecord)
935  return bool(self.FeatureCount)
936
937@_add_method(otTables.DefaultLangSys,
938             otTables.LangSys)
939def subset_features(self, feature_indices):
940  if self.ReqFeatureIndex in feature_indices:
941    self.ReqFeatureIndex = feature_indices.index(self.ReqFeatureIndex)
942  else:
943    self.ReqFeatureIndex = 65535
944  self.FeatureIndex = [f for f in self.FeatureIndex if f in feature_indices]
945  # Now map them.
946  self.FeatureIndex = [feature_indices.index(f) for f in self.FeatureIndex
947                       if f in feature_indices]
948  self.FeatureCount = len(self.FeatureIndex)
949  return bool(self.FeatureCount or self.ReqFeatureIndex != 65535)
950
951@_add_method(otTables.DefaultLangSys,
952             otTables.LangSys)
953def collect_features(self):
954  feature_indices = self.FeatureIndex[:]
955  if self.ReqFeatureIndex != 65535:
956    feature_indices.append(self.ReqFeatureIndex)
957  return _uniq_sort(feature_indices)
958
959@_add_method(otTables.Script)
960def subset_features(self, feature_indices):
961  if(self.DefaultLangSys and
962      not self.DefaultLangSys.subset_features(feature_indices)):
963    self.DefaultLangSys = None
964  self.LangSysRecord = [l for l in self.LangSysRecord
965                        if l.LangSys.subset_features(feature_indices)]
966  self.LangSysCount = len(self.LangSysRecord)
967  return bool(self.LangSysCount or self.DefaultLangSys)
968
969@_add_method(otTables.Script)
970def collect_features(self):
971  feature_indices = [l.LangSys.collect_features() for l in self.LangSysRecord]
972  if self.DefaultLangSys:
973    feature_indices.append(self.DefaultLangSys.collect_features())
974  return _uniq_sort(sum(feature_indices, []))
975
976@_add_method(otTables.ScriptList)
977def subset_features(self, feature_indices):
978  self.ScriptRecord = [s for s in self.ScriptRecord
979                       if s.Script.subset_features(feature_indices)]
980  self.ScriptCount = len(self.ScriptRecord)
981  return bool(self.ScriptCount)
982
983@_add_method(otTables.ScriptList)
984def collect_features(self):
985  return _uniq_sort(sum((s.Script.collect_features()
986                         for s in self.ScriptRecord), []))
987
988@_add_method(ttLib.getTableClass('GSUB'))
989def closure_glyphs(self, s):
990  s.table = self.table
991  if self.table.ScriptList:
992    feature_indices = self.table.ScriptList.collect_features()
993  else:
994    feature_indices = []
995  if self.table.FeatureList:
996    lookup_indices = self.table.FeatureList.collect_lookups(feature_indices)
997  else:
998    lookup_indices = []
999  if self.table.LookupList:
1000    while True:
1001      orig_glyphs = s.glyphs.copy()
1002      for i in lookup_indices:
1003        if i >= self.table.LookupList.LookupCount: continue
1004        if not self.table.LookupList.Lookup[i]: continue
1005        self.table.LookupList.Lookup[i].closure_glyphs(s)
1006      if orig_glyphs == s.glyphs:
1007        break
1008  del s.table
1009
1010@_add_method(ttLib.getTableClass('GSUB'),
1011             ttLib.getTableClass('GPOS'))
1012def subset_glyphs(self, s):
1013  s.glyphs = s.glyphs_gsubed
1014  if self.table.LookupList:
1015    lookup_indices = self.table.LookupList.subset_glyphs(s)
1016  else:
1017    lookup_indices = []
1018  self.subset_lookups(lookup_indices)
1019  self.prune_lookups()
1020  return True
1021
1022@_add_method(ttLib.getTableClass('GSUB'),
1023             ttLib.getTableClass('GPOS'))
1024def subset_lookups(self, lookup_indices):
1025  """Retains specified lookups, then removes empty features, language
1026     systems, and scripts."""
1027  if self.table.LookupList:
1028    self.table.LookupList.subset_lookups(lookup_indices)
1029  if self.table.FeatureList:
1030    feature_indices = self.table.FeatureList.subset_lookups(lookup_indices)
1031  else:
1032    feature_indices = []
1033  if self.table.ScriptList:
1034    self.table.ScriptList.subset_features(feature_indices)
1035
1036@_add_method(ttLib.getTableClass('GSUB'),
1037             ttLib.getTableClass('GPOS'))
1038def prune_lookups(self):
1039  "Remove unreferenced lookups"
1040  if self.table.ScriptList:
1041    feature_indices = self.table.ScriptList.collect_features()
1042  else:
1043    feature_indices = []
1044  if self.table.FeatureList:
1045    lookup_indices = self.table.FeatureList.collect_lookups(feature_indices)
1046  else:
1047    lookup_indices = []
1048  if self.table.LookupList:
1049    lookup_indices = self.table.LookupList.closure_lookups(lookup_indices)
1050  else:
1051    lookup_indices = []
1052  self.subset_lookups(lookup_indices)
1053
1054@_add_method(ttLib.getTableClass('GSUB'),
1055             ttLib.getTableClass('GPOS'))
1056def subset_feature_tags(self, feature_tags):
1057  if self.table.FeatureList:
1058    feature_indices = [i for i,f in
1059                       enumerate(self.table.FeatureList.FeatureRecord)
1060                       if f.FeatureTag in feature_tags]
1061    self.table.FeatureList.subset_features(feature_indices)
1062  else:
1063    feature_indices = []
1064  if self.table.ScriptList:
1065    self.table.ScriptList.subset_features(feature_indices)
1066
1067@_add_method(ttLib.getTableClass('GSUB'),
1068             ttLib.getTableClass('GPOS'))
1069def prune_features(self):
1070  "Remove unreferenced featurs"
1071  if self.table.ScriptList:
1072    feature_indices = self.table.ScriptList.collect_features()
1073  else:
1074    feature_indices = []
1075  if self.table.FeatureList:
1076    self.table.FeatureList.subset_features(feature_indices)
1077  if self.table.ScriptList:
1078    self.table.ScriptList.subset_features(feature_indices)
1079
1080@_add_method(ttLib.getTableClass('GSUB'),
1081             ttLib.getTableClass('GPOS'))
1082def prune_pre_subset(self, options):
1083  # Drop undesired features
1084  if '*' not in options.layout_features:
1085    self.subset_feature_tags(options.layout_features)
1086  # Drop unreferenced lookups
1087  self.prune_lookups()
1088  # Prune lookups themselves
1089  if self.table.LookupList:
1090    self.table.LookupList.prune_pre_subset(options);
1091  return True
1092
1093@_add_method(ttLib.getTableClass('GSUB'),
1094             ttLib.getTableClass('GPOS'))
1095def remove_redundant_langsys(self):
1096  table = self.table
1097  if not table.ScriptList or not table.FeatureList:
1098    return
1099
1100  features = table.FeatureList.FeatureRecord
1101
1102  for s in table.ScriptList.ScriptRecord:
1103    d = s.Script.DefaultLangSys
1104    if not d:
1105      continue
1106    for lr in s.Script.LangSysRecord[:]:
1107      l = lr.LangSys
1108      # Compare d and l
1109      if len(d.FeatureIndex) != len(l.FeatureIndex):
1110        continue
1111      if (d.ReqFeatureIndex == 65535) != (l.ReqFeatureIndex == 65535):
1112        continue
1113
1114      if d.ReqFeatureIndex != 65535:
1115        if features[d.ReqFeatureIndex] != features[l.ReqFeatureIndex]:
1116          continue
1117
1118      for i in range(len(d.FeatureIndex)):
1119        if features[d.FeatureIndex[i]] != features[l.FeatureIndex[i]]:
1120          print(i)
1121	  print (features[d.FeatureIndex[i]])
1122	  print (features[l.FeatureIndex[i]])
1123          print(features[d.FeatureIndex[i]] == features[l.FeatureIndex[i]])
1124          print(features[d.FeatureIndex[i]] != features[l.FeatureIndex[i]])
1125          break
1126      else:
1127        # LangSys and default are equal; delete LangSys
1128        s.Script.LangSysRecord.remove(lr)
1129
1130@_add_method(ttLib.getTableClass('GSUB'),
1131             ttLib.getTableClass('GPOS'))
1132def prune_post_subset(self, options):
1133  table = self.table
1134
1135  # LookupList looks good.  Just prune lookups themselves
1136  if table.LookupList:
1137    table.LookupList.prune_post_subset(options);
1138    if not table.LookupList.Lookup:
1139      table.LookupList = None
1140
1141  if not table.LookupList:
1142    table.FeatureList = None
1143
1144  if table.FeatureList:
1145    self.remove_redundant_langsys()
1146    # Remove unreferenced features
1147    self.prune_features()
1148
1149  if table.FeatureList and not table.FeatureList.FeatureRecord:
1150    table.FeatureList = None
1151
1152  # Never drop scripts themselves as them just being available
1153  # holds semantic significance.
1154  if table.ScriptList and not table.ScriptList.ScriptRecord:
1155    table.ScriptList = None
1156
1157  return True
1158
1159@_add_method(ttLib.getTableClass('GDEF'))
1160def subset_glyphs(self, s):
1161  glyphs = s.glyphs_gsubed
1162  table = self.table
1163  if table.LigCaretList:
1164    indices = table.LigCaretList.Coverage.subset(glyphs)
1165    table.LigCaretList.LigGlyph = [table.LigCaretList.LigGlyph[i]
1166                                   for i in indices]
1167    table.LigCaretList.LigGlyphCount = len(table.LigCaretList.LigGlyph)
1168  if table.MarkAttachClassDef:
1169    table.MarkAttachClassDef.classDefs = dict((g,v) for g,v in
1170                                              table.MarkAttachClassDef.
1171                                                classDefs.items()
1172                                              if g in glyphs)
1173  if table.GlyphClassDef:
1174    table.GlyphClassDef.classDefs = dict((g,v) for g,v in
1175                                         table.GlyphClassDef.
1176                                           classDefs.items()
1177                                         if g in glyphs)
1178  if table.AttachList:
1179    indices = table.AttachList.Coverage.subset(glyphs)
1180    GlyphCount = table.AttachList.GlyphCount
1181    table.AttachList.AttachPoint = [table.AttachList.AttachPoint[i]
1182                                    for i in indices
1183                                    if i < GlyphCount]
1184    table.AttachList.GlyphCount = len(table.AttachList.AttachPoint)
1185  if hasattr(table, "MarkGlyphSetsDef") and table.MarkGlyphSetsDef:
1186    for coverage in table.MarkGlyphSetsDef.Coverage:
1187      coverage.subset(glyphs)
1188    # TODO: The following is disabled.  If enabling, we need to go fixup all
1189    # lookups that use MarkFilteringSet and map their set.
1190    #indices = table.MarkGlyphSetsDef.Coverage = [c for c in table.MarkGlyphSetsDef.Coverage if c.glyphs]
1191  return True
1192
1193@_add_method(ttLib.getTableClass('GDEF'))
1194def prune_post_subset(self, options):
1195  table = self.table
1196  if table.LigCaretList and not table.LigCaretList.LigGlyphCount:
1197    table.LigCaretList = None
1198  if table.MarkAttachClassDef and not table.MarkAttachClassDef.classDefs:
1199    table.MarkAttachClassDef = None
1200  if table.GlyphClassDef and not table.GlyphClassDef.classDefs:
1201    table.GlyphClassDef = None
1202  if table.AttachList and not table.AttachList.GlyphCount:
1203    table.AttachList = None
1204  if hasattr(table, "MarkGlyphSetsDef") and table.MarkGlyphSetsDef and not table.MarkGlyphSetsDef.Coverage:
1205    table.MarkGlyphSetsDef = None
1206    if table.Version == 0x00010002/0x10000:
1207      table.Version = 1.0
1208  return bool(table.LigCaretList or
1209              table.MarkAttachClassDef or
1210              table.GlyphClassDef or
1211              table.AttachList or
1212              (table.Version >= 0x00010002/0x10000 and table.MarkGlyphSetsDef))
1213
1214@_add_method(ttLib.getTableClass('kern'))
1215def prune_pre_subset(self, options):
1216  # Prune unknown kern table types
1217  self.kernTables = [t for t in self.kernTables if hasattr(t, 'kernTable')]
1218  return bool(self.kernTables)
1219
1220@_add_method(ttLib.getTableClass('kern'))
1221def subset_glyphs(self, s):
1222  glyphs = s.glyphs_gsubed
1223  for t in self.kernTables:
1224    t.kernTable = dict(((a,b),v) for (a,b),v in t.kernTable.items()
1225                       if a in glyphs and b in glyphs)
1226  self.kernTables = [t for t in self.kernTables if t.kernTable]
1227  return bool(self.kernTables)
1228
1229@_add_method(ttLib.getTableClass('vmtx'))
1230def subset_glyphs(self, s):
1231  self.metrics = dict((g,v) for g,v in self.metrics.items() if g in s.glyphs)
1232  return bool(self.metrics)
1233
1234@_add_method(ttLib.getTableClass('hmtx'))
1235def subset_glyphs(self, s):
1236  self.metrics = dict((g,v) for g,v in self.metrics.items() if g in s.glyphs)
1237  return True # Required table
1238
1239@_add_method(ttLib.getTableClass('hdmx'))
1240def subset_glyphs(self, s):
1241  self.hdmx = dict((sz,dict((g,v) for g,v in l.items() if g in s.glyphs))
1242                   for sz,l in self.hdmx.items())
1243  return bool(self.hdmx)
1244
1245@_add_method(ttLib.getTableClass('VORG'))
1246def subset_glyphs(self, s):
1247  self.VOriginRecords = dict((g,v) for g,v in self.VOriginRecords.items()
1248                             if g in s.glyphs)
1249  self.numVertOriginYMetrics = len(self.VOriginRecords)
1250  return True  # Never drop; has default metrics
1251
1252@_add_method(ttLib.getTableClass('post'))
1253def prune_pre_subset(self, options):
1254  if not options.glyph_names:
1255    self.formatType = 3.0
1256  return True # Required table
1257
1258@_add_method(ttLib.getTableClass('post'))
1259def subset_glyphs(self, s):
1260  self.extraNames = []  # This seems to do it
1261  return True # Required table
1262
1263@_add_method(ttLib.getTableModule('glyf').Glyph)
1264def remapComponentsFast(self, indices):
1265  if not self.data or struct.unpack(">h", self.data[:2])[0] >= 0:
1266    return  # Not composite
1267  data = array.array("B", self.data)
1268  i = 10
1269  more = 1
1270  while more:
1271    flags =(data[i] << 8) | data[i+1]
1272    glyphID =(data[i+2] << 8) | data[i+3]
1273    # Remap
1274    glyphID = indices.index(glyphID)
1275    data[i+2] = glyphID >> 8
1276    data[i+3] = glyphID & 0xFF
1277    i += 4
1278    flags = int(flags)
1279
1280    if flags & 0x0001: i += 4  # ARG_1_AND_2_ARE_WORDS
1281    else: i += 2
1282    if flags & 0x0008: i += 2  # WE_HAVE_A_SCALE
1283    elif flags & 0x0040: i += 4  # WE_HAVE_AN_X_AND_Y_SCALE
1284    elif flags & 0x0080: i += 8  # WE_HAVE_A_TWO_BY_TWO
1285    more = flags & 0x0020  # MORE_COMPONENTS
1286
1287  self.data = data.tostring()
1288
1289@_add_method(ttLib.getTableClass('glyf'))
1290def closure_glyphs(self, s):
1291  decompose = s.glyphs
1292  while True:
1293    components = set()
1294    for g in decompose:
1295      if g not in self.glyphs:
1296        continue
1297      gl = self.glyphs[g]
1298      for c in gl.getComponentNames(self):
1299        if c not in s.glyphs:
1300          components.add(c)
1301    components = set(c for c in components if c not in s.glyphs)
1302    if not components:
1303      break
1304    decompose = components
1305    s.glyphs.update(components)
1306
1307@_add_method(ttLib.getTableClass('glyf'))
1308def prune_pre_subset(self, options):
1309  if options.notdef_glyph and not options.notdef_outline:
1310    g = self[self.glyphOrder[0]]
1311    # Yay, easy!
1312    g.__dict__.clear()
1313    g.data = ""
1314  return True
1315
1316@_add_method(ttLib.getTableClass('glyf'))
1317def subset_glyphs(self, s):
1318  self.glyphs = dict((g,v) for g,v in self.glyphs.items() if g in s.glyphs)
1319  indices = [i for i,g in enumerate(self.glyphOrder) if g in s.glyphs]
1320  for v in self.glyphs.values():
1321    if hasattr(v, "data"):
1322      v.remapComponentsFast(indices)
1323    else:
1324      pass  # No need
1325  self.glyphOrder = [g for g in self.glyphOrder if g in s.glyphs]
1326  # Don't drop empty 'glyf' tables, otherwise 'loca' doesn't get subset.
1327  return True
1328
1329@_add_method(ttLib.getTableClass('glyf'))
1330def prune_post_subset(self, options):
1331  if not options.hinting:
1332    for v in self.glyphs.values():
1333      v.removeHinting()
1334  return True
1335
1336@_add_method(ttLib.getTableClass('CFF '))
1337def prune_pre_subset(self, options):
1338  cff = self.cff
1339  # CFF table must have one font only
1340  cff.fontNames = cff.fontNames[:1]
1341
1342  if options.notdef_glyph and not options.notdef_outline:
1343    for fontname in cff.keys():
1344      font = cff[fontname]
1345      c,_ = font.CharStrings.getItemAndSelector('.notdef')
1346      # XXX we should preserve the glyph width
1347      c.bytecode = '\x0e' # endchar
1348      c.program = None
1349
1350  return True # bool(cff.fontNames)
1351
1352@_add_method(ttLib.getTableClass('CFF '))
1353def subset_glyphs(self, s):
1354  cff = self.cff
1355  for fontname in cff.keys():
1356    font = cff[fontname]
1357    cs = font.CharStrings
1358
1359    # Load all glyphs
1360    for g in font.charset:
1361      if g not in s.glyphs: continue
1362      c,sel = cs.getItemAndSelector(g)
1363
1364    if cs.charStringsAreIndexed:
1365      indices = [i for i,g in enumerate(font.charset) if g in s.glyphs]
1366      csi = cs.charStringsIndex
1367      csi.items = [csi.items[i] for i in indices]
1368      csi.count = len(csi.items)
1369      del csi.file, csi.offsets
1370      if hasattr(font, "FDSelect"):
1371        sel = font.FDSelect
1372        sel.format = None
1373        sel.gidArray = [sel.gidArray[i] for i in indices]
1374      cs.charStrings = dict((g,indices.index(v))
1375                            for g,v in cs.charStrings.items()
1376                            if g in s.glyphs)
1377    else:
1378      cs.charStrings = dict((g,v)
1379                            for g,v in cs.charStrings.items()
1380                            if g in s.glyphs)
1381    font.charset = [g for g in font.charset if g in s.glyphs]
1382    font.numGlyphs = len(font.charset)
1383
1384  return True # any(cff[fontname].numGlyphs for fontname in cff.keys())
1385
1386@_add_method(psCharStrings.T2CharString)
1387def subset_subroutines(self, subrs, gsubrs):
1388  p = self.program
1389  assert len(p)
1390  for i in range(1, len(p)):
1391    if p[i] == 'callsubr':
1392      assert isinstance(p[i-1], int)
1393      p[i-1] = subrs._used.index(p[i-1] + subrs._old_bias) - subrs._new_bias
1394    elif p[i] == 'callgsubr':
1395      assert isinstance(p[i-1], int)
1396      p[i-1] = gsubrs._used.index(p[i-1] + gsubrs._old_bias) - gsubrs._new_bias
1397
1398@_add_method(psCharStrings.T2CharString)
1399def drop_hints(self):
1400  hints = self._hints
1401
1402  if hints.has_hint:
1403    self.program = self.program[hints.last_hint:]
1404    if hasattr(self, 'width'):
1405      # Insert width back if needed
1406      if self.width != self.private.defaultWidthX:
1407        self.program.insert(0, self.width - self.private.nominalWidthX)
1408
1409  if hints.has_hintmask:
1410    i = 0
1411    p = self.program
1412    while i < len(p):
1413      if p[i] in ['hintmask', 'cntrmask']:
1414        assert i + 1 <= len(p)
1415        del p[i:i+2]
1416        continue
1417      i += 1
1418
1419  # TODO: we currently don't drop calls to "empty" subroutines.
1420
1421  assert len(self.program)
1422
1423  del self._hints
1424
1425class _MarkingT2Decompiler(psCharStrings.SimpleT2Decompiler):
1426
1427  def __init__(self, localSubrs, globalSubrs):
1428    psCharStrings.SimpleT2Decompiler.__init__(self,
1429                                              localSubrs,
1430                                              globalSubrs)
1431    for subrs in [localSubrs, globalSubrs]:
1432      if subrs and not hasattr(subrs, "_used"):
1433        subrs._used = set()
1434
1435  def op_callsubr(self, index):
1436    self.localSubrs._used.add(self.operandStack[-1]+self.localBias)
1437    psCharStrings.SimpleT2Decompiler.op_callsubr(self, index)
1438
1439  def op_callgsubr(self, index):
1440    self.globalSubrs._used.add(self.operandStack[-1]+self.globalBias)
1441    psCharStrings.SimpleT2Decompiler.op_callgsubr(self, index)
1442
1443class _DehintingT2Decompiler(psCharStrings.SimpleT2Decompiler):
1444
1445  class Hints(object):
1446    def __init__(self):
1447      # Whether calling this charstring produces any hint stems
1448      self.has_hint = False
1449      # Index to start at to drop all hints
1450      self.last_hint = 0
1451      # Index up to which we know more hints are possible.  Only
1452      # relevant if status is 0 or 1.
1453      self.last_checked = 0
1454      # The status means:
1455      # 0: after dropping hints, this charstring is empty
1456      # 1: after dropping hints, there may be more hints continuing after this
1457      # 2: no more hints possible after this charstring
1458      self.status = 0
1459      # Has hintmask instructions; not recursive
1460      self.has_hintmask = False
1461    pass
1462
1463  def __init__(self, css, localSubrs, globalSubrs):
1464    self._css = css
1465    psCharStrings.SimpleT2Decompiler.__init__(self,
1466                                              localSubrs,
1467                                              globalSubrs)
1468
1469  def execute(self, charString):
1470    old_hints = charString._hints if hasattr(charString, '_hints') else None
1471    charString._hints = self.Hints()
1472
1473    psCharStrings.SimpleT2Decompiler.execute(self, charString)
1474
1475    hints = charString._hints
1476
1477    if hints.has_hint or hints.has_hintmask:
1478      self._css.add(charString)
1479
1480    if hints.status != 2:
1481      # Check from last_check, make sure we didn't have any operators.
1482      for i in range(hints.last_checked, len(charString.program) - 1):
1483        if isinstance(charString.program[i], str):
1484          hints.status = 2
1485          break;
1486        else:
1487          hints.status = 1 # There's *something* here
1488      hints.last_checked = len(charString.program)
1489
1490    if old_hints:
1491      assert hints.__dict__ == old_hints.__dict__
1492
1493  def op_callsubr(self, index):
1494    subr = self.localSubrs[self.operandStack[-1]+self.localBias]
1495    psCharStrings.SimpleT2Decompiler.op_callsubr(self, index)
1496    self.processSubr(index, subr)
1497
1498  def op_callgsubr(self, index):
1499    subr = self.globalSubrs[self.operandStack[-1]+self.globalBias]
1500    psCharStrings.SimpleT2Decompiler.op_callgsubr(self, index)
1501    self.processSubr(index, subr)
1502
1503  def op_hstem(self, index):
1504    psCharStrings.SimpleT2Decompiler.op_hstem(self, index)
1505    self.processHint(index)
1506  def op_vstem(self, index):
1507    psCharStrings.SimpleT2Decompiler.op_vstem(self, index)
1508    self.processHint(index)
1509  def op_hstemhm(self, index):
1510    psCharStrings.SimpleT2Decompiler.op_hstemhm(self, index)
1511    self.processHint(index)
1512  def op_vstemhm(self, index):
1513    psCharStrings.SimpleT2Decompiler.op_vstemhm(self, index)
1514    self.processHint(index)
1515  def op_hintmask(self, index):
1516    psCharStrings.SimpleT2Decompiler.op_hintmask(self, index)
1517    self.processHintmask(index)
1518  def op_cntrmask(self, index):
1519    psCharStrings.SimpleT2Decompiler.op_cntrmask(self, index)
1520    self.processHintmask(index)
1521
1522  def processHintmask(self, index):
1523    cs = self.callingStack[-1]
1524    hints = cs._hints
1525    hints.has_hintmask = True
1526    if hints.status != 2 and hints.has_hint:
1527      # Check from last_check, see if we may be an implicit vstem
1528      for i in range(hints.last_checked, index - 1):
1529        if isinstance(cs.program[i], str):
1530          hints.status = 2
1531          break;
1532      if hints.status != 2:
1533        # We are an implicit vstem
1534        hints.last_hint = index + 1
1535        hints.status = 0
1536    hints.last_checked = index + 1
1537
1538  def processHint(self, index):
1539    cs = self.callingStack[-1]
1540    hints = cs._hints
1541    hints.has_hint = True
1542    hints.last_hint = index
1543    hints.last_checked = index
1544
1545  def processSubr(self, index, subr):
1546    cs = self.callingStack[-1]
1547    hints = cs._hints
1548    subr_hints = subr._hints
1549
1550    if subr_hints.has_hint:
1551      if hints.status != 2:
1552        hints.has_hint = True
1553        hints.last_checked = index
1554        hints.status = subr_hints.status
1555        # Decide where to chop off from
1556        if subr_hints.status == 0:
1557          hints.last_hint = index
1558        else:
1559          hints.last_hint = index - 2 # Leave the subr call in
1560      else:
1561        # In my understanding, this is a font bug.  Ie. it has hint stems
1562        # *after* path construction.  I've seen this in widespread fonts.
1563        # Best to ignore the hints I suppose...
1564        pass
1565        #assert 0
1566    else:
1567      hints.status = max(hints.status, subr_hints.status)
1568      if hints.status != 2:
1569        # Check from last_check, make sure we didn't have
1570        # any operators.
1571        for i in range(hints.last_checked, index - 1):
1572          if isinstance(cs.program[i], str):
1573            hints.status = 2
1574            break;
1575        hints.last_checked = index
1576      if hints.status != 2:
1577        # Decide where to chop off from
1578        if subr_hints.status == 0:
1579          hints.last_hint = index
1580        else:
1581          hints.last_hint = index - 2 # Leave the subr call in
1582
1583@_add_method(ttLib.getTableClass('CFF '))
1584def prune_post_subset(self, options):
1585  cff = self.cff
1586  for fontname in cff.keys():
1587    font = cff[fontname]
1588    cs = font.CharStrings
1589
1590
1591    #
1592    # Drop unused FontDictionaries
1593    #
1594    if hasattr(font, "FDSelect"):
1595      sel = font.FDSelect
1596      indices = _uniq_sort(sel.gidArray)
1597      sel.gidArray = [indices.index (ss) for ss in sel.gidArray]
1598      arr = font.FDArray
1599      arr.items = [arr[i] for i in indices]
1600      arr.count = len(arr.items)
1601      del arr.file, arr.offsets
1602
1603
1604    #
1605    # Drop hints if not needed
1606    #
1607    if not options.hinting:
1608
1609      #
1610      # This can be tricky, but doesn't have to.  What we do is:
1611      #
1612      # - Run all used glyph charstrings and recurse into subroutines,
1613      # - For each charstring (including subroutines), if it has any
1614      #   of the hint stem operators, we mark it as such.  Upon returning,
1615      #   for each charstring we note all the subroutine calls it makes
1616      #   that (recursively) contain a stem,
1617      # - Dropping hinting then consists of the following two ops:
1618      #   * Drop the piece of the program in each charstring before the
1619      #     last call to a stem op or a stem-calling subroutine,
1620      #   * Drop all hintmask operations.
1621      # - It's trickier... A hintmask right after hints and a few numbers
1622      #   will act as an implicit vstemhm.  As such, we track whether
1623      #   we have seen any non-hint operators so far and do the right
1624      #   thing, recursively...  Good luck understanding that :(
1625      #
1626      css = set()
1627      for g in font.charset:
1628        c,sel = cs.getItemAndSelector(g)
1629        # Make sure it's decompiled.  We want our "decompiler" to walk
1630        # the program, not the bytecode.
1631        c.draw(basePen.NullPen())
1632        subrs = getattr(c.private, "Subrs", [])
1633        decompiler = _DehintingT2Decompiler(css, subrs, c.globalSubrs)
1634        decompiler.execute(c)
1635      for charstring in css:
1636        charstring.drop_hints()
1637
1638      # Drop font-wide hinting values
1639      all_privs = []
1640      if hasattr(font, 'FDSelect'):
1641        all_privs.extend(fd.Private for fd in font.FDArray)
1642      else:
1643        all_privs.append(font.Private)
1644      for priv in all_privs:
1645        for k in ['BlueValues', 'OtherBlues', 'FamilyBlues', 'FamilyOtherBlues',
1646                  'BlueScale', 'BlueShift', 'BlueFuzz',
1647                  'StemSnapH', 'StemSnapV', 'StdHW', 'StdVW']:
1648          if hasattr(priv, k):
1649            setattr(priv, k, None)
1650
1651
1652    #
1653    # Renumber subroutines to remove unused ones
1654    #
1655
1656    # Mark all used subroutines
1657    for g in font.charset:
1658      c,sel = cs.getItemAndSelector(g)
1659      subrs = getattr(c.private, "Subrs", [])
1660      decompiler = _MarkingT2Decompiler(subrs, c.globalSubrs)
1661      decompiler.execute(c)
1662
1663    all_subrs = [font.GlobalSubrs]
1664    if hasattr(font, 'FDSelect'):
1665      all_subrs.extend(fd.Private.Subrs for fd in font.FDArray if hasattr(fd.Private, 'Subrs') and fd.Private.Subrs)
1666    elif hasattr(font.Private, 'Subrs') and font.Private.Subrs:
1667      all_subrs.append(font.Private.Subrs)
1668
1669    subrs = set(subrs) # Remove duplicates
1670
1671    # Prepare
1672    for subrs in all_subrs:
1673      if not hasattr(subrs, '_used'):
1674        subrs._used = set()
1675      subrs._used = _uniq_sort(subrs._used)
1676      subrs._old_bias = psCharStrings.calcSubrBias(subrs)
1677      subrs._new_bias = psCharStrings.calcSubrBias(subrs._used)
1678
1679    # Renumber glyph charstrings
1680    for g in font.charset:
1681      c,sel = cs.getItemAndSelector(g)
1682      subrs = getattr(c.private, "Subrs", [])
1683      c.subset_subroutines (subrs, font.GlobalSubrs)
1684
1685    # Renumber subroutines themselves
1686    for subrs in all_subrs:
1687
1688      if subrs == font.GlobalSubrs:
1689        if not hasattr(font, 'FDSelect') and hasattr(font.Private, 'Subrs'):
1690          local_subrs = font.Private.Subrs
1691        else:
1692          local_subrs = []
1693      else:
1694        local_subrs = subrs
1695
1696      subrs.items = [subrs.items[i] for i in subrs._used]
1697      subrs.count = len(subrs.items)
1698      del subrs.file
1699      if hasattr(subrs, 'offsets'):
1700        del subrs.offsets
1701
1702      for i in range (subrs.count):
1703        subrs[i].subset_subroutines (local_subrs, font.GlobalSubrs)
1704
1705    # Cleanup
1706    for subrs in all_subrs:
1707      del subrs._used, subrs._old_bias, subrs._new_bias
1708
1709  return True
1710
1711@_add_method(ttLib.getTableClass('cmap'))
1712def closure_glyphs(self, s):
1713  tables = [t for t in self.tables
1714            if t.platformID == 3 and t.platEncID in [1, 10]]
1715  for u in s.unicodes_requested:
1716    found = False
1717    for table in tables:
1718      if u in table.cmap:
1719        s.glyphs.add(table.cmap[u])
1720        found = True
1721        break
1722    if not found:
1723      s.log("No glyph for Unicode value %s; skipping." % u)
1724
1725@_add_method(ttLib.getTableClass('cmap'))
1726def prune_pre_subset(self, options):
1727  if not options.legacy_cmap:
1728    # Drop non-Unicode / non-Symbol cmaps
1729    self.tables = [t for t in self.tables
1730                   if t.platformID == 3 and t.platEncID in [0, 1, 10]]
1731  if not options.symbol_cmap:
1732    self.tables = [t for t in self.tables
1733                   if t.platformID == 3 and t.platEncID in [1, 10]]
1734  # TODO(behdad) Only keep one subtable?
1735  # For now, drop format=0 which can't be subset_glyphs easily?
1736  self.tables = [t for t in self.tables if t.format != 0]
1737  self.numSubTables = len(self.tables)
1738  return True # Required table
1739
1740@_add_method(ttLib.getTableClass('cmap'))
1741def subset_glyphs(self, s):
1742  s.glyphs = s.glyphs_cmaped
1743  for t in self.tables:
1744    # For reasons I don't understand I need this here
1745    # to force decompilation of the cmap format 14.
1746    try:
1747      getattr(t, "asdf")
1748    except AttributeError:
1749      pass
1750    if t.format == 14:
1751      # TODO(behdad) XXX We drop all the default-UVS mappings(g==None).
1752      t.uvsDict = dict((v,[(u,g) for u,g in l if g in s.glyphs])
1753                       for v,l in t.uvsDict.items())
1754      t.uvsDict = dict((v,l) for v,l in t.uvsDict.items() if l)
1755    else:
1756      t.cmap = dict((u,g) for u,g in t.cmap.items()
1757                    if g in s.glyphs_requested or u in s.unicodes_requested)
1758  self.tables = [t for t in self.tables
1759                 if (t.cmap if t.format != 14 else t.uvsDict)]
1760  self.numSubTables = len(self.tables)
1761  # TODO(behdad) Convert formats when needed.
1762  # In particular, if we have a format=12 without non-BMP
1763  # characters, either drop format=12 one or convert it
1764  # to format=4 if there's not one.
1765  return True # Required table
1766
1767@_add_method(ttLib.getTableClass('name'))
1768def prune_pre_subset(self, options):
1769  if '*' not in options.name_IDs:
1770    self.names = [n for n in self.names if n.nameID in options.name_IDs]
1771  if not options.name_legacy:
1772    self.names = [n for n in self.names
1773                  if n.platformID == 3 and n.platEncID == 1]
1774  if '*' not in options.name_languages:
1775    self.names = [n for n in self.names if n.langID in options.name_languages]
1776  return True  # Required table
1777
1778
1779# TODO(behdad) OS/2 ulUnicodeRange / ulCodePageRange?
1780# TODO(behdad) Drop AAT tables.
1781# TODO(behdad) Drop unneeded GSUB/GPOS Script/LangSys entries.
1782# TODO(behdad) Drop empty GSUB/GPOS, and GDEF if no GSUB/GPOS left
1783# TODO(behdad) Drop GDEF subitems if unused by lookups
1784# TODO(behdad) Avoid recursing too much (in GSUB/GPOS and in CFF)
1785# TODO(behdad) Text direction considerations.
1786# TODO(behdad) Text script / language considerations.
1787# TODO(behdad) Optionally drop 'kern' table if GPOS available
1788
1789class Options(object):
1790
1791  class UnknownOptionError(Exception):
1792    pass
1793
1794  _drop_tables_default = ['BASE', 'JSTF', 'DSIG', 'EBDT', 'EBLC', 'EBSC', 'SVG ',
1795                          'PCLT', 'LTSH']
1796  _drop_tables_default += ['Feat', 'Glat', 'Gloc', 'Silf', 'Sill']  # Graphite
1797  _drop_tables_default += ['CBLC', 'CBDT', 'sbix', 'COLR', 'CPAL']  # Color
1798  _no_subset_tables_default = ['gasp', 'head', 'hhea', 'maxp', 'vhea', 'OS/2',
1799                               'loca', 'name', 'cvt ', 'fpgm', 'prep']
1800  _hinting_tables_default = ['cvt ', 'fpgm', 'prep', 'hdmx', 'VDMX']
1801
1802  # Based on HarfBuzz shapers
1803  _layout_features_groups = {
1804    # Default shaper
1805    'common': ['ccmp', 'liga', 'locl', 'mark', 'mkmk', 'rlig'],
1806    'horizontal': ['calt', 'clig', 'curs', 'kern', 'rclt'],
1807    'vertical':  ['valt', 'vert', 'vkrn', 'vpal', 'vrt2'],
1808    'ltr': ['ltra', 'ltrm'],
1809    'rtl': ['rtla', 'rtlm'],
1810    # Complex shapers
1811    'arabic': ['init', 'medi', 'fina', 'isol', 'med2', 'fin2', 'fin3',
1812               'cswh', 'mset'],
1813    'hangul': ['ljmo', 'vjmo', 'tjmo'],
1814    'tibetan': ['abvs', 'blws', 'abvm', 'blwm'],
1815    'indic': ['nukt', 'akhn', 'rphf', 'rkrf', 'pref', 'blwf', 'half',
1816              'abvf', 'pstf', 'cfar', 'vatu', 'cjct', 'init', 'pres',
1817              'abvs', 'blws', 'psts', 'haln', 'dist', 'abvm', 'blwm'],
1818  }
1819  _layout_features_default = _uniq_sort(sum(
1820      iter(_layout_features_groups.values()), []))
1821
1822  drop_tables = _drop_tables_default
1823  no_subset_tables = _no_subset_tables_default
1824  hinting_tables = _hinting_tables_default
1825  layout_features = _layout_features_default
1826  hinting = True
1827  glyph_names = False
1828  legacy_cmap = False
1829  symbol_cmap = False
1830  name_IDs = [1, 2]  # Family and Style
1831  name_legacy = False
1832  name_languages = [0x0409]  # English
1833  notdef_glyph = True # gid0 for TrueType / .notdef for CFF
1834  notdef_outline = False # No need for notdef to have an outline really
1835  recommended_glyphs = False  # gid1, gid2, gid3 for TrueType
1836  recalc_bounds = False # Recalculate font bounding boxes
1837  canonical_order = False # Order tables as recommended
1838  flavor = None # May be 'woff'
1839
1840  def __init__(self, **kwargs):
1841
1842    self.set(**kwargs)
1843
1844  def set(self, **kwargs):
1845    for k,v in kwargs.items():
1846      if not hasattr(self, k):
1847        raise self.UnknownOptionError("Unknown option '%s'" % k)
1848      setattr(self, k, v)
1849
1850  def parse_opts(self, argv, ignore_unknown=False):
1851    ret = []
1852    opts = {}
1853    for a in argv:
1854      orig_a = a
1855      if not a.startswith('--'):
1856        ret.append(a)
1857        continue
1858      a = a[2:]
1859      i = a.find('=')
1860      op = '='
1861      if i == -1:
1862        if a.startswith("no-"):
1863          k = a[3:]
1864          v = False
1865        else:
1866          k = a
1867          v = True
1868      else:
1869        k = a[:i]
1870        if k[-1] in "-+":
1871          op = k[-1]+'='  # Ops is '-=' or '+=' now.
1872          k = k[:-1]
1873        v = a[i+1:]
1874      k = k.replace('-', '_')
1875      if not hasattr(self, k):
1876        if ignore_unknown is True or k in ignore_unknown:
1877          ret.append(orig_a)
1878          continue
1879        else:
1880          raise self.UnknownOptionError("Unknown option '%s'" % a)
1881
1882      ov = getattr(self, k)
1883      if isinstance(ov, bool):
1884        v = bool(v)
1885      elif isinstance(ov, int):
1886        v = int(v)
1887      elif isinstance(ov, list):
1888        vv = v.split(',')
1889        if vv == ['']:
1890          vv = []
1891        vv = [int(x, 0) if len(x) and x[0] in "0123456789" else x for x in vv]
1892        if op == '=':
1893          v = vv
1894        elif op == '+=':
1895          v = ov
1896          v.extend(vv)
1897        elif op == '-=':
1898          v = ov
1899          for x in vv:
1900            if x in v:
1901              v.remove(x)
1902        else:
1903          assert False
1904
1905      opts[k] = v
1906    self.set(**opts)
1907
1908    return ret
1909
1910
1911class Subsetter(object):
1912
1913  def __init__(self, options=None, log=None):
1914
1915    if not log:
1916      log = Logger()
1917    if not options:
1918      options = Options()
1919
1920    self.options = options
1921    self.log = log
1922    self.unicodes_requested = set()
1923    self.glyphs_requested = set()
1924    self.glyphs = set()
1925
1926  def populate(self, glyphs=[], unicodes=[], text=""):
1927    self.unicodes_requested.update(unicodes)
1928    if isinstance(text, bytes):
1929      text = text.decode("utf8")
1930    for u in text:
1931      self.unicodes_requested.add(ord(u))
1932    self.glyphs_requested.update(glyphs)
1933    self.glyphs.update(glyphs)
1934
1935  def _prune_pre_subset(self, font):
1936
1937    for tag in font.keys():
1938      if tag == 'GlyphOrder': continue
1939
1940      if(tag in self.options.drop_tables or
1941         (tag in self.options.hinting_tables and not self.options.hinting)):
1942        self.log(tag, "dropped")
1943        del font[tag]
1944        continue
1945
1946      clazz = ttLib.getTableClass(tag)
1947
1948      if hasattr(clazz, 'prune_pre_subset'):
1949        table = font[tag]
1950        self.log.lapse("load '%s'" % tag)
1951        retain = table.prune_pre_subset(self.options)
1952        self.log.lapse("prune  '%s'" % tag)
1953        if not retain:
1954          self.log(tag, "pruned to empty; dropped")
1955          del font[tag]
1956          continue
1957        else:
1958          self.log(tag, "pruned")
1959
1960  def _closure_glyphs(self, font):
1961
1962    realGlyphs = set(font.getGlyphOrder())
1963
1964    self.glyphs = self.glyphs_requested.copy()
1965
1966    if 'cmap' in font:
1967      font['cmap'].closure_glyphs(self)
1968      self.glyphs.intersection_update(realGlyphs)
1969    self.glyphs_cmaped = self.glyphs
1970
1971    if self.options.notdef_glyph:
1972      if 'glyf' in font:
1973        self.glyphs.add(font.getGlyphName(0))
1974        self.log("Added gid0 to subset")
1975      else:
1976        self.glyphs.add('.notdef')
1977        self.log("Added .notdef to subset")
1978    if self.options.recommended_glyphs:
1979      if 'glyf' in font:
1980        for i in range(min(4, len(font.getGlyphOrder()))):
1981          self.glyphs.add(font.getGlyphName(i))
1982        self.log("Added first four glyphs to subset")
1983
1984    if 'GSUB' in font:
1985      self.log("Closing glyph list over 'GSUB': %d glyphs before" %
1986                len(self.glyphs))
1987      self.log.glyphs(self.glyphs, font=font)
1988      font['GSUB'].closure_glyphs(self)
1989      self.glyphs.intersection_update(realGlyphs)
1990      self.log("Closed  glyph list over 'GSUB': %d glyphs after" %
1991                len(self.glyphs))
1992      self.log.glyphs(self.glyphs, font=font)
1993      self.log.lapse("close glyph list over 'GSUB'")
1994    self.glyphs_gsubed = self.glyphs.copy()
1995
1996    if 'glyf' in font:
1997      self.log("Closing glyph list over 'glyf': %d glyphs before" %
1998                len(self.glyphs))
1999      self.log.glyphs(self.glyphs, font=font)
2000      font['glyf'].closure_glyphs(self)
2001      self.glyphs.intersection_update(realGlyphs)
2002      self.log("Closed  glyph list over 'glyf': %d glyphs after" %
2003                len(self.glyphs))
2004      self.log.glyphs(self.glyphs, font=font)
2005      self.log.lapse("close glyph list over 'glyf'")
2006    self.glyphs_glyfed = self.glyphs.copy()
2007
2008    self.glyphs_all = self.glyphs.copy()
2009
2010    self.log("Retaining %d glyphs: " % len(self.glyphs_all))
2011
2012    del self.glyphs
2013
2014
2015  def _subset_glyphs(self, font):
2016    for tag in font.keys():
2017      if tag == 'GlyphOrder': continue
2018      clazz = ttLib.getTableClass(tag)
2019
2020      if tag in self.options.no_subset_tables:
2021        self.log(tag, "subsetting not needed")
2022      elif hasattr(clazz, 'subset_glyphs'):
2023        table = font[tag]
2024        self.glyphs = self.glyphs_all
2025        retain = table.subset_glyphs(self)
2026        del self.glyphs
2027        self.log.lapse("subset '%s'" % tag)
2028        if not retain:
2029          self.log(tag, "subsetted to empty; dropped")
2030          del font[tag]
2031        else:
2032          self.log(tag, "subsetted")
2033      else:
2034        self.log(tag, "NOT subset; don't know how to subset; dropped")
2035        del font[tag]
2036
2037    glyphOrder = font.getGlyphOrder()
2038    glyphOrder = [g for g in glyphOrder if g in self.glyphs_all]
2039    font.setGlyphOrder(glyphOrder)
2040    font._buildReverseGlyphOrderDict()
2041    self.log.lapse("subset GlyphOrder")
2042
2043  def _prune_post_subset(self, font):
2044    for tag in font.keys():
2045      if tag == 'GlyphOrder': continue
2046      clazz = ttLib.getTableClass(tag)
2047      if hasattr(clazz, 'prune_post_subset'):
2048        table = font[tag]
2049        retain = table.prune_post_subset(self.options)
2050        self.log.lapse("prune  '%s'" % tag)
2051        if not retain:
2052          self.log(tag, "pruned to empty; dropped")
2053          del font[tag]
2054        else:
2055          self.log(tag, "pruned")
2056
2057  def subset(self, font):
2058
2059    self._prune_pre_subset(font)
2060    self._closure_glyphs(font)
2061    self._subset_glyphs(font)
2062    self._prune_post_subset(font)
2063
2064
2065class Logger(object):
2066
2067  def __init__(self, verbose=False, xml=False, timing=False):
2068    self.verbose = verbose
2069    self.xml = xml
2070    self.timing = timing
2071    self.last_time = self.start_time = time.time()
2072
2073  def parse_opts(self, argv):
2074    argv = argv[:]
2075    for v in ['verbose', 'xml', 'timing']:
2076      if "--"+v in argv:
2077        setattr(self, v, True)
2078        argv.remove("--"+v)
2079    return argv
2080
2081  def __call__(self, *things):
2082    if not self.verbose:
2083      return
2084    print(' '.join(str(x) for x in things))
2085
2086  def lapse(self, *things):
2087    if not self.timing:
2088      return
2089    new_time = time.time()
2090    print("Took %0.3fs to %s" %(new_time - self.last_time,
2091                                 ' '.join(str(x) for x in things)))
2092    self.last_time = new_time
2093
2094  def glyphs(self, glyphs, font=None):
2095    if not self.verbose:
2096      return
2097    self("Names: ", sorted(glyphs))
2098    if font:
2099      reverseGlyphMap = font.getReverseGlyphMap()
2100      self("Gids : ", sorted(reverseGlyphMap[g] for g in glyphs))
2101
2102  def font(self, font, file=sys.stdout):
2103    if not self.xml:
2104      return
2105    from fontTools.misc import xmlWriter
2106    writer = xmlWriter.XMLWriter(file)
2107    for tag in font.keys():
2108      writer.begintag(tag)
2109      writer.newline()
2110      font[tag].toXML(writer, font)
2111      writer.endtag(tag)
2112      writer.newline()
2113
2114
2115def load_font(fontFile,
2116              options,
2117              allowVID=False,
2118              checkChecksums=False,
2119              dontLoadGlyphNames=False):
2120
2121  font = ttLib.TTFont(fontFile,
2122                      allowVID=allowVID,
2123                      checkChecksums=checkChecksums,
2124                      recalcBBoxes=options.recalc_bounds)
2125
2126  # Hack:
2127  #
2128  # If we don't need glyph names, change 'post' class to not try to
2129  # load them.  It avoid lots of headache with broken fonts as well
2130  # as loading time.
2131  #
2132  # Ideally ttLib should provide a way to ask it to skip loading
2133  # glyph names.  But it currently doesn't provide such a thing.
2134  #
2135  if dontLoadGlyphNames:
2136    post = ttLib.getTableClass('post')
2137    saved = post.decode_format_2_0
2138    post.decode_format_2_0 = post.decode_format_3_0
2139    f = font['post']
2140    if f.formatType == 2.0:
2141      f.formatType = 3.0
2142    post.decode_format_2_0 = saved
2143
2144  return font
2145
2146def save_font(font, outfile, options):
2147  if options.flavor and not hasattr(font, 'flavor'):
2148    raise Exception("fonttools version does not support flavors.")
2149  font.flavor = options.flavor
2150  font.save(outfile, reorderTables=options.canonical_order)
2151
2152def main(args):
2153
2154  log = Logger()
2155  args = log.parse_opts(args)
2156
2157  options = Options()
2158  args = options.parse_opts(args, ignore_unknown=['text'])
2159
2160  if len(args) < 2:
2161    print("usage: pyftsubset font-file glyph... [--text=ABC]... [--option=value]...", file=sys.stderr)
2162    sys.exit(1)
2163
2164  fontfile = args[0]
2165  args = args[1:]
2166
2167  dontLoadGlyphNames =(not options.glyph_names and
2168         all(any(g.startswith(p)
2169             for p in ['gid', 'glyph', 'uni', 'U+'])
2170              for g in args))
2171
2172  font = load_font(fontfile, options, dontLoadGlyphNames=dontLoadGlyphNames)
2173  subsetter = Subsetter(options=options, log=log)
2174  log.lapse("load font")
2175
2176  names = font.getGlyphNames()
2177  log.lapse("loading glyph names")
2178
2179  glyphs = []
2180  unicodes = []
2181  text = ""
2182  for g in args:
2183    if g == '*':
2184      glyphs.extend(font.getGlyphOrder())
2185      continue
2186    if g in names:
2187      glyphs.append(g)
2188      continue
2189    if g.startswith('--text='):
2190      text += g[7:]
2191      continue
2192    if g.startswith('uni') or g.startswith('U+'):
2193      if g.startswith('uni') and len(g) > 3:
2194        g = g[3:]
2195      elif g.startswith('U+') and len(g) > 2:
2196        g = g[2:]
2197      u = int(g, 16)
2198      unicodes.append(u)
2199      continue
2200    if g.startswith('gid') or g.startswith('glyph'):
2201      if g.startswith('gid') and len(g) > 3:
2202        g = g[3:]
2203      elif g.startswith('glyph') and len(g) > 5:
2204        g = g[5:]
2205      try:
2206        glyphs.append(font.getGlyphName(int(g), requireReal=True))
2207      except ValueError:
2208        raise Exception("Invalid glyph identifier: %s" % g)
2209      continue
2210    raise Exception("Invalid glyph identifier: %s" % g)
2211  log.lapse("compile glyph list")
2212  log("Unicodes:", unicodes)
2213  log("Glyphs:", glyphs)
2214
2215  subsetter.populate(glyphs=glyphs, unicodes=unicodes, text=text)
2216  subsetter.subset(font)
2217
2218  outfile = fontfile + '.subset'
2219
2220  save_font (font, outfile, options)
2221  log.lapse("compile and save font")
2222
2223  log.last_time = log.start_time
2224  log.lapse("make one with everything(TOTAL TIME)")
2225
2226  if log.verbose:
2227    import os
2228    log("Input  font: %d bytes" % os.path.getsize(fontfile))
2229    log("Subset font: %d bytes" % os.path.getsize(outfile))
2230
2231  log.font(font)
2232
2233  font.close()
2234
2235
2236__all__ = [
2237  'Options',
2238  'Subsetter',
2239  'Logger',
2240  'load_font',
2241  'save_font',
2242  'main'
2243]
2244
2245if __name__ == '__main__':
2246  main(sys.argv[1:])
2247