""" GTableUnparser: Base class for reading binary GSUB/GPOS tables ============================================================== """ from collections import OrderedDict from fontTools.misc.xmlWriter import XMLWriter import fontFeatures from io import BytesIO import warnings def glyph(x): """Helper routine to document that a glyph name goes in a slot.""" assert isinstance(x, str) return [x] class GTableUnparser: """Base class for reading binary GSUB/GPOS tables.""" def __init__(self, table, ff, languageSystems, font=None, config={}): """Create a new unparser Args: table: An object returned by ``font["GSUB"]`` or ``font["GPOS"]``. ff: A fontFeatures object in which to return the output. font: A ``TTFont`` object (optional). config: A dictionary mapping generated names to friendly names. The config dictionary is used to make the output more human readable. For example, after dumping a binary TTF and reading the output, you might discover that what we are calling ``SingleSubstitution1`` would be better named ``fiLigature``. Passing ``{"SingleSubstitution1": "fiLigature"}`` to the call will cause the routine to be renamed appropriately.""" self.table = table.table self.font = font self.fontFeatures = ff self.config = config self.index = 0 self.lookups = [] # We keep a separate list because this is per-table self.sharedClasses = {} self.languageSystems = languageSystems self.sharedLookups = OrderedDict() def _unparse_lookups(self, slr, inputs, in_lookups=None): lookups = [] note = None if in_lookups: lookups = in_lookups indices = [sl.SequenceIndex for sl in slr] if indices != list(sorted(indices)): # https://github.com/adobe-type-tools/afdko/issues/1167 note = ( f"Out-of-order lookup application in lookup {self.currentLookup}\n" f" A chaining rule calls lookups in the order {indices}\n" " This cannot be directly expressed in Adobe FEA syntax;\n" " asFea() output will be incorrect" ) warnings.warn(note) for sl in slr: if len(lookups) <= sl.SequenceIndex: lookups.extend([None] * (1 + sl.SequenceIndex - len(lookups))) if not lookups[sl.SequenceIndex]: lookups[sl.SequenceIndex] = [] if sl.LookupListIndex >= len(self.lookups): raise ValueError( "Lookups unparsed out of order: unparse %i first!" % sl.LookupListIndex ) rr = fontFeatures.RoutineReference(routine=self.lookups[sl.LookupListIndex]) lookups[sl.SequenceIndex].append(rr) if len(lookups) < len(inputs): lookups.extend([None] * (len(inputs) - len(lookups))) assert len(lookups) == len(inputs) return lookups, note def _invertClassDef(self, a, font): classes = {} for glyph, klass in a.items(): if klass not in classes: classes[klass] = [] classes[klass].append(glyph) glyphset = set(font.getGlyphOrder()) classes[0] = glyphset - set(a.keys()) return classes def getname(self, n): """Renames its input using the configuration dictionary""" return self.config.get(n, n) def gensym(self): """Generates a new unique name""" self.index = self.index + 1 return str(self.index) def unparse(self, doLookups=True): """Unparse the table to the fontFeatures object.""" if not self.table.ScriptList: return self.unparseLookups() self.collectFeatures() self.fontFeatures.resolveAllRoutines() def _prepareFeatureLangSys(self, langTag, langSys, table, features, scriptTag): # This is a part of prepareFeatures for featureIdx in langSys.FeatureIndex: featureRecord = self.table.FeatureList.FeatureRecord[featureIdx] featureTag = featureRecord.FeatureTag scripts = features.get(featureTag, None) if scripts is None: scripts = OrderedDict() features[featureTag] = scripts languages = scripts.get(scriptTag, None) if languages is None: languages = OrderedDict() scripts[scriptTag] = languages lookups = languages.get(langTag, None) if lookups is None: lookups = [] languages[langTag] = lookups for lookupIdx in featureRecord.Feature.LookupListIndex: if (scriptTag, langTag) not in self.lookups[lookupIdx].languages: self.lookups[lookupIdx].languages.append((scriptTag, langTag)) # Add reference if there isn't one if featureTag not in self.fontFeatures.features: self.fontFeatures.features[featureTag] = [] if not any( r.routine == self.lookups[lookupIdx] for r in self.fontFeatures.features[featureTag] ): self.fontFeatures.addFeature( featureTag, [self.lookups[lookupIdx]], ) lookups.append(lookupIdx) def collectFeatures(self): """Traverse the script/language table looking for features.""" features = OrderedDict() for scriptRecord in self.table.ScriptList.ScriptRecord: scriptTag = scriptRecord.ScriptTag if scriptRecord.Script.DefaultLangSys is not None: self._prepareFeatureLangSys( "dflt", scriptRecord.Script.DefaultLangSys, self.table, features, scriptTag, ) for langSysRecord in scriptRecord.Script.LangSysRecord: self._prepareFeatureLangSys( langSysRecord.LangSysTag, langSysRecord.LangSys, self.table, features, scriptTag, ) self.features = features def unparseLookups(self): """Unparses the lookups to fontFeatures routines.""" if not self.table.LookupList: return # Create a dummy list first, to allow resolving chained lookups for _ in self.table.LookupList.Lookup: r = fontFeatures.Routine() self.lookups.append(r) self.fontFeatures.routines.append(r) for lookupIdx, lookup in enumerate(self.table.LookupList.Lookup): routine, deps = self.unparseLookup(lookup, lookupIdx) debug = self.getDebugInfo(self._table, lookupIdx) if debug: routine.address = (self._table, lookupIdx, *debug) if debug[1]: routine.name = debug[1] self._copyRoutineToRoutine(routine, self.lookups[lookupIdx]) def _copyRoutineToRoutine(self, src, dst): dst.name = src.name dst.rules = src.rules dst.flags = src.flags dst.address = src.address dst.comments = src.comments dst.inlined = src.inlined dst.languages = src.languages dst.parent = src.parent dst.flags = src.flags dst.markFilteringSet = src.markFilteringSet dst.markAttachmentSet = src.markAttachmentSet def unparseLookup(self, lookup, lookupIdx): """Dispatches to the appropriate lookup unparser.""" self.currentLookup = lookupIdx unparser = getattr(self, "unparse" + self.lookupTypes[lookup.LookupType]) return unparser(lookup) def unparseExtension(self, lookup): """Handles extension lookups by recursing into them.""" routines = [] dependencies = [] for xt in lookup.SubTable: xt.SubTable = [xt.ExtSubTable] xt.LookupType = xt.ExtSubTable.LookupType xt.LookupFlag = lookup.LookupFlag if hasattr(lookup, "MarkFilteringSet"): xt.MarkFilteringSet = lookup.MarkFilteringSet routine, deps = self.unparseLookup(xt, self.currentLookup) routines.append(routine) dependencies.extend(deps) extension = fontFeatures.ExtensionRoutine( routines=routines, name=self.getname("Extension" + self.gensym()), ) self._fix_flags(extension, lookup) return extension, dependencies def getDebugInfo(self, table, ix): """If information is present in the font's Debg table, use that to retrieve the original address and routine names.""" if not self.font or "Debg" not in self.font: return None debug_data = self.font["Debg"].data if "com.github.fonttools.feaLib" not in debug_data: return None debug_data = debug_data["com.github.fonttools.feaLib"][table][str(ix)] return debug_data[0], debug_data[1].replace("-", "_") def _asXML(self, sub): writer = XMLWriter(BytesIO()) sub.toXML(writer, self.font) out = writer.file.getvalue().decode("utf-8") return out def unparsable(self, b, e, sub): """Warn about an unparsable lookup.""" import warnings warnings.warn( "# XXX Unparsable rule: " + str(e) + " in " + str(self.currentLookup) ) b.addComment("# ----") out = self._asXML(sub).splitlines() for ln in out: b.addComment("# " + ln) b.addComment("# ----\n") def _fix_flags(self, routine, lookup): routine.flags = lookup.LookupFlag mat = lookup.LookupFlag & 0xFF00 if mat: mat = mat >> 8 classDefs = self.font["GDEF"].table.MarkAttachClassDef.classDefs glyphs = [g for g in classDefs.keys() if classDefs[g] == mat] routine.markAttachmentSet = glyphs if lookup.LookupFlag & 0x10 and hasattr(lookup, "MarkFilteringSet"): routine.markFilteringSet = ( self.font["GDEF"] .table.MarkGlyphSetsDef.Coverage[lookup.MarkFilteringSet] .glyphs ) if routine.flags & 0x10: assert routine.markFilteringSet is not None def unparseContextual(self, lookup): """Handles a generic contextual lookup, in various formats.""" b = fontFeatures.Routine( name=self.getname("Contextual" + self._table + self.gensym()) ) self._fix_flags(b, lookup) for sub in lookup.SubTable: if sub.Format == 1: self._unparse_contextual_format1(sub, b, lookup) elif sub.Format == 2: self._unparse_contextual_format2(sub, b, lookup) elif sub.Format == 3: self._unparse_contextual_format3(sub, b, lookup) else: raise ValueError return b, [] def _unparse_contextual_format1(self, sub, b, lookup): lookups = [] rulesetattr, ruleattr, lookupattr = [ self._attrs[x] for x in ["format1_ruleset", "format1_rule", "lookup"] ] for subrulesets, input_ in zip(getattr(sub, rulesetattr), sub.Coverage.glyphs): for subrule in getattr(subrulesets, ruleattr): lookups = [] allinput = [glyph(x) for x in ([input_] + subrule.Input)] lookups, note = self._unparse_lookups( getattr(subrule, lookupattr), allinput ) rule = fontFeatures.Chaining( allinput, lookups=lookups, address=self.currentLookup, flags=lookup.LookupFlag, ) if note: rule.note = note b.addRule(rule) return def _unparse_contextual_format2(self, sub, b, lookup): return self._unparse_contextual_chain_format2(sub, b, lookup, chain=False) def _unparse_contextual_format3(self, sub, b, lookup): return self._unparse_contextual_chain_format3(sub, b, lookup, chain=False) def unparseChainedContextual(self, lookup): """Handles a generic chained contextual lookup, in various formats.""" b = fontFeatures.Routine( name=self.getname("ChainedContextual" + self._table + self.gensym()) ) self._fix_flags(b, lookup) for sub in lookup.SubTable: if sub.Format == 1: self._unparse_contextual_chain_format1(sub, b, lookup) elif sub.Format == 2: self._unparse_contextual_chain_format2(sub, b, lookup) elif sub.Format == 3: self._unparse_contextual_chain_format3(sub, b, lookup) else: raise ValueError return b, [] def _unparse_contextual_chain_format1(self, sub, b, lookup): rulesetattr, ruleattr, lookupattr = [ self._attrs[x] for x in ["chain_format1_ruleset", "chain_format1_rule", "lookup"] ] for subrulesets, input_ in zip(getattr(sub, rulesetattr), sub.Coverage.glyphs): for subrule in getattr(subrulesets, ruleattr): lookups = [] inputs = [glyph(x) for x in ([input_] + subrule.Input)] prefix = [glyph(x) for x in reversed(subrule.Backtrack)] suffix = [glyph(x) for x in subrule.LookAhead] lookups, note = self._unparse_lookups( getattr(subrule, lookupattr), inputs ) rule = fontFeatures.Chaining( inputs, prefix, suffix, lookups=lookups, address=self.currentLookup, flags=lookup.LookupFlag, ) if note: rule.note = note b.addRule(rule) def _unparse_contextual_chain_format2(self, sub, b, lookup, chain=True): if chain: rulesetattr, ruleattr, lookupattr = [ self._attrs[x] for x in ["chain_format2_classset", "chain_format2_rule", "lookup"] ] else: rulesetattr, ruleattr, lookupattr = [ self._attrs[x] for x in ["format2_classset", "format2_rule", "lookup"] ] if chain: backtrack = {} if sub.BacktrackClassDef: backtrack = self._invertClassDef( sub.BacktrackClassDef.classDefs, self.font ) lookahead = {} if sub.LookAheadClassDef: lookahead = self._invertClassDef( sub.LookAheadClassDef.classDefs, self.font ) inputs = {} inputs = self._invertClassDef(sub.InputClassDef.classDefs, self.font) else: inputs = self._invertClassDef(sub.ClassDef.classDefs, self.font) rulesets = getattr(sub, rulesetattr) for classId, ruleset in enumerate(rulesets): if not ruleset: continue rules = getattr(ruleset, ruleattr) inputclass = inputs.get(classId, []) # The coverage filters the input class... inputclass = [g for g in inputclass if g in sub.Coverage.glyphs] for r in rules: if chain: prefix = list(reversed([backtrack[x] for x in r.Backtrack])) suffix = [lookahead[x] for x in r.LookAhead] input_ = [inputclass] + [inputs[x] for x in r.Input] else: prefix, suffix = [], [] input_ = [inputclass] + [inputs[x] for x in r.Class] lookups, note = self._unparse_lookups(getattr(r, lookupattr), input_) rule = fontFeatures.Chaining( input_, prefix, suffix, lookups=lookups, address=self.currentLookup, flags=lookup.LookupFlag, ) if note: rule.note = note b.addRule(rule) def _unparse_contextual_chain_format3(self, sub, b, lookup, chain=True): lookupattr = self._attrs["lookup"] prefix, suffix, inputs = [], [], [] if chain: for coverage in reversed(sub.BacktrackCoverage): prefix.append(coverage.glyphs) for coverage in sub.LookAheadCoverage: suffix.append(coverage.glyphs) for coverage in sub.InputCoverage: inputs.append(coverage.glyphs) else: for coverage in sub.Coverage: inputs.append(coverage.glyphs) lookups, note = self._unparse_lookups(getattr(sub, lookupattr), inputs) rule = fontFeatures.Chaining( inputs, prefix, suffix, lookups=lookups, address=self.currentLookup, flags=lookup.LookupFlag, ) if note: rule.note = note b.addRule(rule)