| #!/usr/bin/python |
| |
| # FontDame-to-FontTools for OpenType Layout tables |
| # |
| # Source language spec is available at: |
| # http://monotype.github.io/OpenType_Table_Source/otl_source.html |
| # https://github.com/Monotype/OpenType_Table_Source/ |
| |
| from fontTools import ttLib |
| from fontTools.ttLib.tables._c_m_a_p import cmap_classes |
| from fontTools.ttLib.tables import otTables as ot |
| from fontTools.ttLib.tables.otBase import ValueRecord, valueRecordFormatDict |
| from fontTools.otlLib import builder as otl |
| from contextlib import contextmanager |
| from fontTools.ttLib import newTable |
| from fontTools.feaLib.lookupDebugInfo import LOOKUP_DEBUG_ENV_VAR, LOOKUP_DEBUG_INFO_KEY |
| from operator import setitem |
| import os |
| import logging |
| |
| |
| class MtiLibError(Exception): |
| pass |
| |
| |
| class ReferenceNotFoundError(MtiLibError): |
| pass |
| |
| |
| class FeatureNotFoundError(ReferenceNotFoundError): |
| pass |
| |
| |
| class LookupNotFoundError(ReferenceNotFoundError): |
| pass |
| |
| |
| log = logging.getLogger("fontTools.mtiLib") |
| |
| |
| def makeGlyph(s): |
| if s[:2] in ["U ", "u "]: |
| return ttLib.TTFont._makeGlyphName(int(s[2:], 16)) |
| elif s[:2] == "# ": |
| return "glyph%.5d" % int(s[2:]) |
| assert s.find(" ") < 0, "Space found in glyph name: %s" % s |
| assert s, "Glyph name is empty" |
| return s |
| |
| |
| def makeGlyphs(l): |
| return [makeGlyph(g) for g in l] |
| |
| |
| def mapLookup(sym, mapping): |
| # Lookups are addressed by name. So resolved them using a map if available. |
| # Fallback to parsing as lookup index if a map isn't provided. |
| if mapping is not None: |
| try: |
| idx = mapping[sym] |
| except KeyError: |
| raise LookupNotFoundError(sym) |
| else: |
| idx = int(sym) |
| return idx |
| |
| |
| def mapFeature(sym, mapping): |
| # Features are referenced by index according the spec. So, if symbol is an |
| # integer, use it directly. Otherwise look up in the map if provided. |
| try: |
| idx = int(sym) |
| except ValueError: |
| try: |
| idx = mapping[sym] |
| except KeyError: |
| raise FeatureNotFoundError(sym) |
| return idx |
| |
| |
| def setReference(mapper, mapping, sym, setter, collection, key): |
| try: |
| mapped = mapper(sym, mapping) |
| except ReferenceNotFoundError as e: |
| try: |
| if mapping is not None: |
| mapping.addDeferredMapping( |
| lambda ref: setter(collection, key, ref), sym, e |
| ) |
| return |
| except AttributeError: |
| pass |
| raise |
| setter(collection, key, mapped) |
| |
| |
| class DeferredMapping(dict): |
| def __init__(self): |
| self._deferredMappings = [] |
| |
| def addDeferredMapping(self, setter, sym, e): |
| log.debug("Adding deferred mapping for symbol '%s' %s", sym, type(e).__name__) |
| self._deferredMappings.append((setter, sym, e)) |
| |
| def applyDeferredMappings(self): |
| for setter, sym, e in self._deferredMappings: |
| log.debug( |
| "Applying deferred mapping for symbol '%s' %s", sym, type(e).__name__ |
| ) |
| try: |
| mapped = self[sym] |
| except KeyError: |
| raise e |
| setter(mapped) |
| log.debug("Set to %s", mapped) |
| self._deferredMappings = [] |
| |
| |
| def parseScriptList(lines, featureMap=None): |
| self = ot.ScriptList() |
| records = [] |
| with lines.between("script table"): |
| for line in lines: |
| while len(line) < 4: |
| line.append("") |
| scriptTag, langSysTag, defaultFeature, features = line |
| log.debug("Adding script %s language-system %s", scriptTag, langSysTag) |
| |
| langSys = ot.LangSys() |
| langSys.LookupOrder = None |
| if defaultFeature: |
| setReference( |
| mapFeature, |
| featureMap, |
| defaultFeature, |
| setattr, |
| langSys, |
| "ReqFeatureIndex", |
| ) |
| else: |
| langSys.ReqFeatureIndex = 0xFFFF |
| syms = stripSplitComma(features) |
| langSys.FeatureIndex = theList = [3] * len(syms) |
| for i, sym in enumerate(syms): |
| setReference(mapFeature, featureMap, sym, setitem, theList, i) |
| langSys.FeatureCount = len(langSys.FeatureIndex) |
| |
| script = [s for s in records if s.ScriptTag == scriptTag] |
| if script: |
| script = script[0].Script |
| else: |
| scriptRec = ot.ScriptRecord() |
| scriptRec.ScriptTag = scriptTag + " " * (4 - len(scriptTag)) |
| scriptRec.Script = ot.Script() |
| records.append(scriptRec) |
| script = scriptRec.Script |
| script.DefaultLangSys = None |
| script.LangSysRecord = [] |
| script.LangSysCount = 0 |
| |
| if langSysTag == "default": |
| script.DefaultLangSys = langSys |
| else: |
| langSysRec = ot.LangSysRecord() |
| langSysRec.LangSysTag = langSysTag + " " * (4 - len(langSysTag)) |
| langSysRec.LangSys = langSys |
| script.LangSysRecord.append(langSysRec) |
| script.LangSysCount = len(script.LangSysRecord) |
| |
| for script in records: |
| script.Script.LangSysRecord = sorted( |
| script.Script.LangSysRecord, key=lambda rec: rec.LangSysTag |
| ) |
| self.ScriptRecord = sorted(records, key=lambda rec: rec.ScriptTag) |
| self.ScriptCount = len(self.ScriptRecord) |
| return self |
| |
| |
| def parseFeatureList(lines, lookupMap=None, featureMap=None): |
| self = ot.FeatureList() |
| self.FeatureRecord = [] |
| with lines.between("feature table"): |
| for line in lines: |
| name, featureTag, lookups = line |
| if featureMap is not None: |
| assert name not in featureMap, "Duplicate feature name: %s" % name |
| featureMap[name] = len(self.FeatureRecord) |
| # If feature name is integer, make sure it matches its index. |
| try: |
| assert int(name) == len(self.FeatureRecord), "%d %d" % ( |
| name, |
| len(self.FeatureRecord), |
| ) |
| except ValueError: |
| pass |
| featureRec = ot.FeatureRecord() |
| featureRec.FeatureTag = featureTag |
| featureRec.Feature = ot.Feature() |
| self.FeatureRecord.append(featureRec) |
| feature = featureRec.Feature |
| feature.FeatureParams = None |
| syms = stripSplitComma(lookups) |
| feature.LookupListIndex = theList = [None] * len(syms) |
| for i, sym in enumerate(syms): |
| setReference(mapLookup, lookupMap, sym, setitem, theList, i) |
| feature.LookupCount = len(feature.LookupListIndex) |
| |
| self.FeatureCount = len(self.FeatureRecord) |
| return self |
| |
| |
| def parseLookupFlags(lines): |
| flags = 0 |
| filterset = None |
| allFlags = [ |
| "righttoleft", |
| "ignorebaseglyphs", |
| "ignoreligatures", |
| "ignoremarks", |
| "markattachmenttype", |
| "markfiltertype", |
| ] |
| while lines.peeks()[0].lower() in allFlags: |
| line = next(lines) |
| flag = { |
| "righttoleft": 0x0001, |
| "ignorebaseglyphs": 0x0002, |
| "ignoreligatures": 0x0004, |
| "ignoremarks": 0x0008, |
| }.get(line[0].lower()) |
| if flag: |
| assert line[1].lower() in ["yes", "no"], line[1] |
| if line[1].lower() == "yes": |
| flags |= flag |
| continue |
| if line[0].lower() == "markattachmenttype": |
| flags |= int(line[1]) << 8 |
| continue |
| if line[0].lower() == "markfiltertype": |
| flags |= 0x10 |
| filterset = int(line[1]) |
| return flags, filterset |
| |
| |
| def parseSingleSubst(lines, font, _lookupMap=None): |
| mapping = {} |
| for line in lines: |
| assert len(line) == 2, line |
| line = makeGlyphs(line) |
| mapping[line[0]] = line[1] |
| return otl.buildSingleSubstSubtable(mapping) |
| |
| |
| def parseMultiple(lines, font, _lookupMap=None): |
| mapping = {} |
| for line in lines: |
| line = makeGlyphs(line) |
| mapping[line[0]] = line[1:] |
| return otl.buildMultipleSubstSubtable(mapping) |
| |
| |
| def parseAlternate(lines, font, _lookupMap=None): |
| mapping = {} |
| for line in lines: |
| line = makeGlyphs(line) |
| mapping[line[0]] = line[1:] |
| return otl.buildAlternateSubstSubtable(mapping) |
| |
| |
| def parseLigature(lines, font, _lookupMap=None): |
| mapping = {} |
| for line in lines: |
| assert len(line) >= 2, line |
| line = makeGlyphs(line) |
| mapping[tuple(line[1:])] = line[0] |
| return otl.buildLigatureSubstSubtable(mapping) |
| |
| |
| def parseSinglePos(lines, font, _lookupMap=None): |
| values = {} |
| for line in lines: |
| assert len(line) == 3, line |
| w = line[0].title().replace(" ", "") |
| assert w in valueRecordFormatDict |
| g = makeGlyph(line[1]) |
| v = int(line[2]) |
| if g not in values: |
| values[g] = ValueRecord() |
| assert not hasattr(values[g], w), (g, w) |
| setattr(values[g], w, v) |
| return otl.buildSinglePosSubtable(values, font.getReverseGlyphMap()) |
| |
| |
| def parsePair(lines, font, _lookupMap=None): |
| self = ot.PairPos() |
| self.ValueFormat1 = self.ValueFormat2 = 0 |
| typ = lines.peeks()[0].split()[0].lower() |
| if typ in ("left", "right"): |
| self.Format = 1 |
| values = {} |
| for line in lines: |
| assert len(line) == 4, line |
| side = line[0].split()[0].lower() |
| assert side in ("left", "right"), side |
| what = line[0][len(side) :].title().replace(" ", "") |
| mask = valueRecordFormatDict[what][0] |
| glyph1, glyph2 = makeGlyphs(line[1:3]) |
| value = int(line[3]) |
| if not glyph1 in values: |
| values[glyph1] = {} |
| if not glyph2 in values[glyph1]: |
| values[glyph1][glyph2] = (ValueRecord(), ValueRecord()) |
| rec2 = values[glyph1][glyph2] |
| if side == "left": |
| self.ValueFormat1 |= mask |
| vr = rec2[0] |
| else: |
| self.ValueFormat2 |= mask |
| vr = rec2[1] |
| assert not hasattr(vr, what), (vr, what) |
| setattr(vr, what, value) |
| self.Coverage = makeCoverage(set(values.keys()), font) |
| self.PairSet = [] |
| for glyph1 in self.Coverage.glyphs: |
| values1 = values[glyph1] |
| pairset = ot.PairSet() |
| records = pairset.PairValueRecord = [] |
| for glyph2 in sorted(values1.keys(), key=font.getGlyphID): |
| values2 = values1[glyph2] |
| pair = ot.PairValueRecord() |
| pair.SecondGlyph = glyph2 |
| pair.Value1 = values2[0] |
| pair.Value2 = values2[1] if self.ValueFormat2 else None |
| records.append(pair) |
| pairset.PairValueCount = len(pairset.PairValueRecord) |
| self.PairSet.append(pairset) |
| self.PairSetCount = len(self.PairSet) |
| elif typ.endswith("class"): |
| self.Format = 2 |
| classDefs = [None, None] |
| while lines.peeks()[0].endswith("class definition begin"): |
| typ = lines.peek()[0][: -len("class definition begin")].lower() |
| idx, klass = { |
| "first": (0, ot.ClassDef1), |
| "second": (1, ot.ClassDef2), |
| }[typ] |
| assert classDefs[idx] is None |
| classDefs[idx] = parseClassDef(lines, font, klass=klass) |
| self.ClassDef1, self.ClassDef2 = classDefs |
| self.Class1Count, self.Class2Count = ( |
| 1 + max(c.classDefs.values()) for c in classDefs |
| ) |
| self.Class1Record = [ot.Class1Record() for i in range(self.Class1Count)] |
| for rec1 in self.Class1Record: |
| rec1.Class2Record = [ot.Class2Record() for j in range(self.Class2Count)] |
| for rec2 in rec1.Class2Record: |
| rec2.Value1 = ValueRecord() |
| rec2.Value2 = ValueRecord() |
| for line in lines: |
| assert len(line) == 4, line |
| side = line[0].split()[0].lower() |
| assert side in ("left", "right"), side |
| what = line[0][len(side) :].title().replace(" ", "") |
| mask = valueRecordFormatDict[what][0] |
| class1, class2, value = (int(x) for x in line[1:4]) |
| rec2 = self.Class1Record[class1].Class2Record[class2] |
| if side == "left": |
| self.ValueFormat1 |= mask |
| vr = rec2.Value1 |
| else: |
| self.ValueFormat2 |= mask |
| vr = rec2.Value2 |
| assert not hasattr(vr, what), (vr, what) |
| setattr(vr, what, value) |
| for rec1 in self.Class1Record: |
| for rec2 in rec1.Class2Record: |
| rec2.Value1 = ValueRecord(self.ValueFormat1, rec2.Value1) |
| rec2.Value2 = ( |
| ValueRecord(self.ValueFormat2, rec2.Value2) |
| if self.ValueFormat2 |
| else None |
| ) |
| |
| self.Coverage = makeCoverage(set(self.ClassDef1.classDefs.keys()), font) |
| else: |
| assert 0, typ |
| return self |
| |
| |
| def parseKernset(lines, font, _lookupMap=None): |
| typ = lines.peeks()[0].split()[0].lower() |
| if typ in ("left", "right"): |
| with lines.until( |
| ("firstclass definition begin", "secondclass definition begin") |
| ): |
| return parsePair(lines, font) |
| return parsePair(lines, font) |
| |
| |
| def makeAnchor(data, klass=ot.Anchor): |
| assert len(data) <= 2 |
| anchor = klass() |
| anchor.Format = 1 |
| anchor.XCoordinate, anchor.YCoordinate = intSplitComma(data[0]) |
| if len(data) > 1 and data[1] != "": |
| anchor.Format = 2 |
| anchor.AnchorPoint = int(data[1]) |
| return anchor |
| |
| |
| def parseCursive(lines, font, _lookupMap=None): |
| records = {} |
| for line in lines: |
| assert len(line) in [3, 4], line |
| idx, klass = { |
| "entry": (0, ot.EntryAnchor), |
| "exit": (1, ot.ExitAnchor), |
| }[line[0]] |
| glyph = makeGlyph(line[1]) |
| if glyph not in records: |
| records[glyph] = [None, None] |
| assert records[glyph][idx] is None, (glyph, idx) |
| records[glyph][idx] = makeAnchor(line[2:], klass) |
| return otl.buildCursivePosSubtable(records, font.getReverseGlyphMap()) |
| |
| |
| def makeMarkRecords(data, coverage, c): |
| records = [] |
| for glyph in coverage.glyphs: |
| klass, anchor = data[glyph] |
| record = c.MarkRecordClass() |
| record.Class = klass |
| setattr(record, c.MarkAnchor, anchor) |
| records.append(record) |
| return records |
| |
| |
| def makeBaseRecords(data, coverage, c, classCount): |
| records = [] |
| idx = {} |
| for glyph in coverage.glyphs: |
| idx[glyph] = len(records) |
| record = c.BaseRecordClass() |
| anchors = [None] * classCount |
| setattr(record, c.BaseAnchor, anchors) |
| records.append(record) |
| for (glyph, klass), anchor in data.items(): |
| record = records[idx[glyph]] |
| anchors = getattr(record, c.BaseAnchor) |
| assert anchors[klass] is None, (glyph, klass) |
| anchors[klass] = anchor |
| return records |
| |
| |
| def makeLigatureRecords(data, coverage, c, classCount): |
| records = [None] * len(coverage.glyphs) |
| idx = {g: i for i, g in enumerate(coverage.glyphs)} |
| |
| for (glyph, klass, compIdx, compCount), anchor in data.items(): |
| record = records[idx[glyph]] |
| if record is None: |
| record = records[idx[glyph]] = ot.LigatureAttach() |
| record.ComponentCount = compCount |
| record.ComponentRecord = [ot.ComponentRecord() for i in range(compCount)] |
| for compRec in record.ComponentRecord: |
| compRec.LigatureAnchor = [None] * classCount |
| assert record.ComponentCount == compCount, ( |
| glyph, |
| record.ComponentCount, |
| compCount, |
| ) |
| |
| anchors = record.ComponentRecord[compIdx - 1].LigatureAnchor |
| assert anchors[klass] is None, (glyph, compIdx, klass) |
| anchors[klass] = anchor |
| return records |
| |
| |
| def parseMarkToSomething(lines, font, c): |
| self = c.Type() |
| self.Format = 1 |
| markData = {} |
| baseData = {} |
| Data = { |
| "mark": (markData, c.MarkAnchorClass), |
| "base": (baseData, c.BaseAnchorClass), |
| "ligature": (baseData, c.BaseAnchorClass), |
| } |
| maxKlass = 0 |
| for line in lines: |
| typ = line[0] |
| assert typ in ("mark", "base", "ligature") |
| glyph = makeGlyph(line[1]) |
| data, anchorClass = Data[typ] |
| extraItems = 2 if typ == "ligature" else 0 |
| extras = tuple(int(i) for i in line[2 : 2 + extraItems]) |
| klass = int(line[2 + extraItems]) |
| anchor = makeAnchor(line[3 + extraItems :], anchorClass) |
| if typ == "mark": |
| key, value = glyph, (klass, anchor) |
| else: |
| key, value = ((glyph, klass) + extras), anchor |
| assert key not in data, key |
| data[key] = value |
| maxKlass = max(maxKlass, klass) |
| |
| # Mark |
| markCoverage = makeCoverage(set(markData.keys()), font, c.MarkCoverageClass) |
| markArray = c.MarkArrayClass() |
| markRecords = makeMarkRecords(markData, markCoverage, c) |
| setattr(markArray, c.MarkRecord, markRecords) |
| setattr(markArray, c.MarkCount, len(markRecords)) |
| setattr(self, c.MarkCoverage, markCoverage) |
| setattr(self, c.MarkArray, markArray) |
| self.ClassCount = maxKlass + 1 |
| |
| # Base |
| self.classCount = 0 if not baseData else 1 + max(k[1] for k, v in baseData.items()) |
| baseCoverage = makeCoverage( |
| set([k[0] for k in baseData.keys()]), font, c.BaseCoverageClass |
| ) |
| baseArray = c.BaseArrayClass() |
| if c.Base == "Ligature": |
| baseRecords = makeLigatureRecords(baseData, baseCoverage, c, self.classCount) |
| else: |
| baseRecords = makeBaseRecords(baseData, baseCoverage, c, self.classCount) |
| setattr(baseArray, c.BaseRecord, baseRecords) |
| setattr(baseArray, c.BaseCount, len(baseRecords)) |
| setattr(self, c.BaseCoverage, baseCoverage) |
| setattr(self, c.BaseArray, baseArray) |
| |
| return self |
| |
| |
| class MarkHelper(object): |
| def __init__(self): |
| for Which in ("Mark", "Base"): |
| for What in ("Coverage", "Array", "Count", "Record", "Anchor"): |
| key = Which + What |
| if Which == "Mark" and What in ("Count", "Record", "Anchor"): |
| value = key |
| else: |
| value = getattr(self, Which) + What |
| if value == "LigatureRecord": |
| value = "LigatureAttach" |
| setattr(self, key, value) |
| if What != "Count": |
| klass = getattr(ot, value) |
| setattr(self, key + "Class", klass) |
| |
| |
| class MarkToBaseHelper(MarkHelper): |
| Mark = "Mark" |
| Base = "Base" |
| Type = ot.MarkBasePos |
| |
| |
| class MarkToMarkHelper(MarkHelper): |
| Mark = "Mark1" |
| Base = "Mark2" |
| Type = ot.MarkMarkPos |
| |
| |
| class MarkToLigatureHelper(MarkHelper): |
| Mark = "Mark" |
| Base = "Ligature" |
| Type = ot.MarkLigPos |
| |
| |
| def parseMarkToBase(lines, font, _lookupMap=None): |
| return parseMarkToSomething(lines, font, MarkToBaseHelper()) |
| |
| |
| def parseMarkToMark(lines, font, _lookupMap=None): |
| return parseMarkToSomething(lines, font, MarkToMarkHelper()) |
| |
| |
| def parseMarkToLigature(lines, font, _lookupMap=None): |
| return parseMarkToSomething(lines, font, MarkToLigatureHelper()) |
| |
| |
| def stripSplitComma(line): |
| return [s.strip() for s in line.split(",")] if line else [] |
| |
| |
| def intSplitComma(line): |
| return [int(i) for i in line.split(",")] if line else [] |
| |
| |
| # Copied from fontTools.subset |
| class ContextHelper(object): |
| def __init__(self, klassName, Format): |
| if klassName.endswith("Subst"): |
| Typ = "Sub" |
| Type = "Subst" |
| else: |
| Typ = "Pos" |
| Type = "Pos" |
| if klassName.startswith("Chain"): |
| Chain = "Chain" |
| InputIdx = 1 |
| DataLen = 3 |
| else: |
| Chain = "" |
| InputIdx = 0 |
| DataLen = 1 |
| ChainTyp = Chain + Typ |
| |
| self.Typ = Typ |
| self.Type = Type |
| self.Chain = Chain |
| self.ChainTyp = ChainTyp |
| self.InputIdx = InputIdx |
| self.DataLen = DataLen |
| |
| self.LookupRecord = Type + "LookupRecord" |
| |
| if Format == 1: |
| Coverage = lambda r: r.Coverage |
| ChainCoverage = lambda r: r.Coverage |
| ContextData = lambda r: (None,) |
| ChainContextData = lambda r: (None, None, None) |
| SetContextData = None |
| SetChainContextData = None |
| RuleData = lambda r: (r.Input,) |
| ChainRuleData = lambda r: (r.Backtrack, r.Input, r.LookAhead) |
| |
| def SetRuleData(r, d): |
| (r.Input,) = d |
| (r.GlyphCount,) = (len(x) + 1 for x in d) |
| |
| def ChainSetRuleData(r, d): |
| (r.Backtrack, r.Input, r.LookAhead) = d |
| ( |
| r.BacktrackGlyphCount, |
| r.InputGlyphCount, |
| r.LookAheadGlyphCount, |
| ) = (len(d[0]), len(d[1]) + 1, len(d[2])) |
| |
| elif Format == 2: |
| Coverage = lambda r: r.Coverage |
| ChainCoverage = lambda r: r.Coverage |
| ContextData = lambda r: (r.ClassDef,) |
| ChainContextData = lambda r: ( |
| r.BacktrackClassDef, |
| r.InputClassDef, |
| r.LookAheadClassDef, |
| ) |
| |
| def SetContextData(r, d): |
| (r.ClassDef,) = d |
| |
| def SetChainContextData(r, d): |
| (r.BacktrackClassDef, r.InputClassDef, r.LookAheadClassDef) = d |
| |
| RuleData = lambda r: (r.Class,) |
| ChainRuleData = lambda r: (r.Backtrack, r.Input, r.LookAhead) |
| |
| def SetRuleData(r, d): |
| (r.Class,) = d |
| (r.GlyphCount,) = (len(x) + 1 for x in d) |
| |
| def ChainSetRuleData(r, d): |
| (r.Backtrack, r.Input, r.LookAhead) = d |
| ( |
| r.BacktrackGlyphCount, |
| r.InputGlyphCount, |
| r.LookAheadGlyphCount, |
| ) = (len(d[0]), len(d[1]) + 1, len(d[2])) |
| |
| elif Format == 3: |
| Coverage = lambda r: r.Coverage[0] |
| ChainCoverage = lambda r: r.InputCoverage[0] |
| ContextData = None |
| ChainContextData = None |
| SetContextData = None |
| SetChainContextData = None |
| RuleData = lambda r: r.Coverage |
| ChainRuleData = lambda r: ( |
| r.BacktrackCoverage + r.InputCoverage + r.LookAheadCoverage |
| ) |
| |
| def SetRuleData(r, d): |
| (r.Coverage,) = d |
| (r.GlyphCount,) = (len(x) for x in d) |
| |
| def ChainSetRuleData(r, d): |
| (r.BacktrackCoverage, r.InputCoverage, r.LookAheadCoverage) = d |
| ( |
| r.BacktrackGlyphCount, |
| r.InputGlyphCount, |
| r.LookAheadGlyphCount, |
| ) = (len(x) for x in d) |
| |
| else: |
| assert 0, "unknown format: %s" % Format |
| |
| if Chain: |
| self.Coverage = ChainCoverage |
| self.ContextData = ChainContextData |
| self.SetContextData = SetChainContextData |
| self.RuleData = ChainRuleData |
| self.SetRuleData = ChainSetRuleData |
| else: |
| self.Coverage = Coverage |
| self.ContextData = ContextData |
| self.SetContextData = SetContextData |
| self.RuleData = RuleData |
| self.SetRuleData = SetRuleData |
| |
| if Format == 1: |
| self.Rule = ChainTyp + "Rule" |
| self.RuleCount = ChainTyp + "RuleCount" |
| self.RuleSet = ChainTyp + "RuleSet" |
| self.RuleSetCount = ChainTyp + "RuleSetCount" |
| self.Intersect = lambda glyphs, c, r: [r] if r in glyphs else [] |
| elif Format == 2: |
| self.Rule = ChainTyp + "ClassRule" |
| self.RuleCount = ChainTyp + "ClassRuleCount" |
| self.RuleSet = ChainTyp + "ClassSet" |
| self.RuleSetCount = ChainTyp + "ClassSetCount" |
| self.Intersect = lambda glyphs, c, r: ( |
| c.intersect_class(glyphs, r) |
| if c |
| else (set(glyphs) if r == 0 else set()) |
| ) |
| |
| self.ClassDef = "InputClassDef" if Chain else "ClassDef" |
| self.ClassDefIndex = 1 if Chain else 0 |
| self.Input = "Input" if Chain else "Class" |
| |
| |
| def parseLookupRecords(items, klassName, lookupMap=None): |
| klass = getattr(ot, klassName) |
| lst = [] |
| for item in items: |
| rec = klass() |
| item = stripSplitComma(item) |
| assert len(item) == 2, item |
| idx = int(item[0]) |
| assert idx > 0, idx |
| rec.SequenceIndex = idx - 1 |
| setReference(mapLookup, lookupMap, item[1], setattr, rec, "LookupListIndex") |
| lst.append(rec) |
| return lst |
| |
| |
| def makeClassDef(classDefs, font, klass=ot.Coverage): |
| if not classDefs: |
| return None |
| self = klass() |
| self.classDefs = dict(classDefs) |
| return self |
| |
| |
| def parseClassDef(lines, font, klass=ot.ClassDef): |
| classDefs = {} |
| with lines.between("class definition"): |
| for line in lines: |
| glyph = makeGlyph(line[0]) |
| assert glyph not in classDefs, glyph |
| classDefs[glyph] = int(line[1]) |
| return makeClassDef(classDefs, font, klass) |
| |
| |
| def makeCoverage(glyphs, font, klass=ot.Coverage): |
| if not glyphs: |
| return None |
| if isinstance(glyphs, set): |
| glyphs = sorted(glyphs) |
| coverage = klass() |
| coverage.glyphs = sorted(set(glyphs), key=font.getGlyphID) |
| return coverage |
| |
| |
| def parseCoverage(lines, font, klass=ot.Coverage): |
| glyphs = [] |
| with lines.between("coverage definition"): |
| for line in lines: |
| glyphs.append(makeGlyph(line[0])) |
| return makeCoverage(glyphs, font, klass) |
| |
| |
| def bucketizeRules(self, c, rules, bucketKeys): |
| buckets = {} |
| for seq, recs in rules: |
| buckets.setdefault(seq[c.InputIdx][0], []).append( |
| (tuple(s[1 if i == c.InputIdx else 0 :] for i, s in enumerate(seq)), recs) |
| ) |
| |
| rulesets = [] |
| for firstGlyph in bucketKeys: |
| if firstGlyph not in buckets: |
| rulesets.append(None) |
| continue |
| thisRules = [] |
| for seq, recs in buckets[firstGlyph]: |
| rule = getattr(ot, c.Rule)() |
| c.SetRuleData(rule, seq) |
| setattr(rule, c.Type + "Count", len(recs)) |
| setattr(rule, c.LookupRecord, recs) |
| thisRules.append(rule) |
| |
| ruleset = getattr(ot, c.RuleSet)() |
| setattr(ruleset, c.Rule, thisRules) |
| setattr(ruleset, c.RuleCount, len(thisRules)) |
| rulesets.append(ruleset) |
| |
| setattr(self, c.RuleSet, rulesets) |
| setattr(self, c.RuleSetCount, len(rulesets)) |
| |
| |
| def parseContext(lines, font, Type, lookupMap=None): |
| self = getattr(ot, Type)() |
| typ = lines.peeks()[0].split()[0].lower() |
| if typ == "glyph": |
| self.Format = 1 |
| log.debug("Parsing %s format %s", Type, self.Format) |
| c = ContextHelper(Type, self.Format) |
| rules = [] |
| for line in lines: |
| assert line[0].lower() == "glyph", line[0] |
| while len(line) < 1 + c.DataLen: |
| line.append("") |
| seq = tuple(makeGlyphs(stripSplitComma(i)) for i in line[1 : 1 + c.DataLen]) |
| recs = parseLookupRecords(line[1 + c.DataLen :], c.LookupRecord, lookupMap) |
| rules.append((seq, recs)) |
| |
| firstGlyphs = set(seq[c.InputIdx][0] for seq, recs in rules) |
| self.Coverage = makeCoverage(firstGlyphs, font) |
| bucketizeRules(self, c, rules, self.Coverage.glyphs) |
| elif typ.endswith("class"): |
| self.Format = 2 |
| log.debug("Parsing %s format %s", Type, self.Format) |
| c = ContextHelper(Type, self.Format) |
| classDefs = [None] * c.DataLen |
| while lines.peeks()[0].endswith("class definition begin"): |
| typ = lines.peek()[0][: -len("class definition begin")].lower() |
| idx, klass = { |
| 1: { |
| "": (0, ot.ClassDef), |
| }, |
| 3: { |
| "backtrack": (0, ot.BacktrackClassDef), |
| "": (1, ot.InputClassDef), |
| "lookahead": (2, ot.LookAheadClassDef), |
| }, |
| }[c.DataLen][typ] |
| assert classDefs[idx] is None, idx |
| classDefs[idx] = parseClassDef(lines, font, klass=klass) |
| c.SetContextData(self, classDefs) |
| rules = [] |
| for line in lines: |
| assert line[0].lower().startswith("class"), line[0] |
| while len(line) < 1 + c.DataLen: |
| line.append("") |
| seq = tuple(intSplitComma(i) for i in line[1 : 1 + c.DataLen]) |
| recs = parseLookupRecords(line[1 + c.DataLen :], c.LookupRecord, lookupMap) |
| rules.append((seq, recs)) |
| firstClasses = set(seq[c.InputIdx][0] for seq, recs in rules) |
| firstGlyphs = set( |
| g for g, c in classDefs[c.InputIdx].classDefs.items() if c in firstClasses |
| ) |
| self.Coverage = makeCoverage(firstGlyphs, font) |
| bucketizeRules(self, c, rules, range(max(firstClasses) + 1)) |
| elif typ.endswith("coverage"): |
| self.Format = 3 |
| log.debug("Parsing %s format %s", Type, self.Format) |
| c = ContextHelper(Type, self.Format) |
| coverages = tuple([] for i in range(c.DataLen)) |
| while lines.peeks()[0].endswith("coverage definition begin"): |
| typ = lines.peek()[0][: -len("coverage definition begin")].lower() |
| idx, klass = { |
| 1: { |
| "": (0, ot.Coverage), |
| }, |
| 3: { |
| "backtrack": (0, ot.BacktrackCoverage), |
| "input": (1, ot.InputCoverage), |
| "lookahead": (2, ot.LookAheadCoverage), |
| }, |
| }[c.DataLen][typ] |
| coverages[idx].append(parseCoverage(lines, font, klass=klass)) |
| c.SetRuleData(self, coverages) |
| lines = list(lines) |
| assert len(lines) == 1 |
| line = lines[0] |
| assert line[0].lower() == "coverage", line[0] |
| recs = parseLookupRecords(line[1:], c.LookupRecord, lookupMap) |
| setattr(self, c.Type + "Count", len(recs)) |
| setattr(self, c.LookupRecord, recs) |
| else: |
| assert 0, typ |
| return self |
| |
| |
| def parseContextSubst(lines, font, lookupMap=None): |
| return parseContext(lines, font, "ContextSubst", lookupMap=lookupMap) |
| |
| |
| def parseContextPos(lines, font, lookupMap=None): |
| return parseContext(lines, font, "ContextPos", lookupMap=lookupMap) |
| |
| |
| def parseChainedSubst(lines, font, lookupMap=None): |
| return parseContext(lines, font, "ChainContextSubst", lookupMap=lookupMap) |
| |
| |
| def parseChainedPos(lines, font, lookupMap=None): |
| return parseContext(lines, font, "ChainContextPos", lookupMap=lookupMap) |
| |
| |
| def parseReverseChainedSubst(lines, font, _lookupMap=None): |
| self = ot.ReverseChainSingleSubst() |
| self.Format = 1 |
| coverages = ([], []) |
| while lines.peeks()[0].endswith("coverage definition begin"): |
| typ = lines.peek()[0][: -len("coverage definition begin")].lower() |
| idx, klass = { |
| "backtrack": (0, ot.BacktrackCoverage), |
| "lookahead": (1, ot.LookAheadCoverage), |
| }[typ] |
| coverages[idx].append(parseCoverage(lines, font, klass=klass)) |
| self.BacktrackCoverage = coverages[0] |
| self.BacktrackGlyphCount = len(self.BacktrackCoverage) |
| self.LookAheadCoverage = coverages[1] |
| self.LookAheadGlyphCount = len(self.LookAheadCoverage) |
| mapping = {} |
| for line in lines: |
| assert len(line) == 2, line |
| line = makeGlyphs(line) |
| mapping[line[0]] = line[1] |
| self.Coverage = makeCoverage(set(mapping.keys()), font) |
| self.Substitute = [mapping[k] for k in self.Coverage.glyphs] |
| self.GlyphCount = len(self.Substitute) |
| return self |
| |
| |
| def parseLookup(lines, tableTag, font, lookupMap=None): |
| line = lines.expect("lookup") |
| _, name, typ = line |
| log.debug("Parsing lookup type %s %s", typ, name) |
| lookup = ot.Lookup() |
| lookup.LookupFlag, filterset = parseLookupFlags(lines) |
| if filterset is not None: |
| lookup.MarkFilteringSet = filterset |
| lookup.LookupType, parseLookupSubTable = { |
| "GSUB": { |
| "single": (1, parseSingleSubst), |
| "multiple": (2, parseMultiple), |
| "alternate": (3, parseAlternate), |
| "ligature": (4, parseLigature), |
| "context": (5, parseContextSubst), |
| "chained": (6, parseChainedSubst), |
| "reversechained": (8, parseReverseChainedSubst), |
| }, |
| "GPOS": { |
| "single": (1, parseSinglePos), |
| "pair": (2, parsePair), |
| "kernset": (2, parseKernset), |
| "cursive": (3, parseCursive), |
| "mark to base": (4, parseMarkToBase), |
| "mark to ligature": (5, parseMarkToLigature), |
| "mark to mark": (6, parseMarkToMark), |
| "context": (7, parseContextPos), |
| "chained": (8, parseChainedPos), |
| }, |
| }[tableTag][typ] |
| |
| with lines.until("lookup end"): |
| subtables = [] |
| |
| while lines.peek(): |
| with lines.until(("% subtable", "subtable end")): |
| while lines.peek(): |
| subtable = parseLookupSubTable(lines, font, lookupMap) |
| assert lookup.LookupType == subtable.LookupType |
| subtables.append(subtable) |
| if lines.peeks()[0] in ("% subtable", "subtable end"): |
| next(lines) |
| lines.expect("lookup end") |
| |
| lookup.SubTable = subtables |
| lookup.SubTableCount = len(lookup.SubTable) |
| if lookup.SubTableCount == 0: |
| # Remove this return when following is fixed: |
| # https://github.com/fonttools/fonttools/issues/789 |
| return None |
| return lookup |
| |
| |
| def parseGSUBGPOS(lines, font, tableTag): |
| container = ttLib.getTableClass(tableTag)() |
| lookupMap = DeferredMapping() |
| featureMap = DeferredMapping() |
| assert tableTag in ("GSUB", "GPOS") |
| log.debug("Parsing %s", tableTag) |
| self = getattr(ot, tableTag)() |
| self.Version = 0x00010000 |
| fields = { |
| "script table begin": ( |
| "ScriptList", |
| lambda lines: parseScriptList(lines, featureMap), |
| ), |
| "feature table begin": ( |
| "FeatureList", |
| lambda lines: parseFeatureList(lines, lookupMap, featureMap), |
| ), |
| "lookup": ("LookupList", None), |
| } |
| for attr, parser in fields.values(): |
| setattr(self, attr, None) |
| while lines.peek() is not None: |
| typ = lines.peek()[0].lower() |
| if typ not in fields: |
| log.debug("Skipping %s", lines.peek()) |
| next(lines) |
| continue |
| attr, parser = fields[typ] |
| if typ == "lookup": |
| if self.LookupList is None: |
| self.LookupList = ot.LookupList() |
| self.LookupList.Lookup = [] |
| _, name, _ = lines.peek() |
| lookup = parseLookup(lines, tableTag, font, lookupMap) |
| if lookupMap is not None: |
| assert name not in lookupMap, "Duplicate lookup name: %s" % name |
| lookupMap[name] = len(self.LookupList.Lookup) |
| else: |
| assert int(name) == len(self.LookupList.Lookup), "%d %d" % ( |
| name, |
| len(self.Lookup), |
| ) |
| self.LookupList.Lookup.append(lookup) |
| else: |
| assert getattr(self, attr) is None, attr |
| setattr(self, attr, parser(lines)) |
| if self.LookupList: |
| self.LookupList.LookupCount = len(self.LookupList.Lookup) |
| if lookupMap is not None: |
| lookupMap.applyDeferredMappings() |
| if os.environ.get(LOOKUP_DEBUG_ENV_VAR): |
| if "Debg" not in font: |
| font["Debg"] = newTable("Debg") |
| font["Debg"].data = {} |
| debug = ( |
| font["Debg"] |
| .data.setdefault(LOOKUP_DEBUG_INFO_KEY, {}) |
| .setdefault(tableTag, {}) |
| ) |
| for name, lookup in lookupMap.items(): |
| debug[str(lookup)] = ["", name, ""] |
| |
| featureMap.applyDeferredMappings() |
| container.table = self |
| return container |
| |
| |
| def parseGSUB(lines, font): |
| return parseGSUBGPOS(lines, font, "GSUB") |
| |
| |
| def parseGPOS(lines, font): |
| return parseGSUBGPOS(lines, font, "GPOS") |
| |
| |
| def parseAttachList(lines, font): |
| points = {} |
| with lines.between("attachment list"): |
| for line in lines: |
| glyph = makeGlyph(line[0]) |
| assert glyph not in points, glyph |
| points[glyph] = [int(i) for i in line[1:]] |
| return otl.buildAttachList(points, font.getReverseGlyphMap()) |
| |
| |
| def parseCaretList(lines, font): |
| carets = {} |
| with lines.between("carets"): |
| for line in lines: |
| glyph = makeGlyph(line[0]) |
| assert glyph not in carets, glyph |
| num = int(line[1]) |
| thisCarets = [int(i) for i in line[2:]] |
| assert num == len(thisCarets), line |
| carets[glyph] = thisCarets |
| return otl.buildLigCaretList(carets, {}, font.getReverseGlyphMap()) |
| |
| |
| def makeMarkFilteringSets(sets, font): |
| self = ot.MarkGlyphSetsDef() |
| self.MarkSetTableFormat = 1 |
| self.MarkSetCount = 1 + max(sets.keys()) |
| self.Coverage = [None] * self.MarkSetCount |
| for k, v in sorted(sets.items()): |
| self.Coverage[k] = makeCoverage(set(v), font) |
| return self |
| |
| |
| def parseMarkFilteringSets(lines, font): |
| sets = {} |
| with lines.between("set definition"): |
| for line in lines: |
| assert len(line) == 2, line |
| glyph = makeGlyph(line[0]) |
| # TODO accept set names |
| st = int(line[1]) |
| if st not in sets: |
| sets[st] = [] |
| sets[st].append(glyph) |
| return makeMarkFilteringSets(sets, font) |
| |
| |
| def parseGDEF(lines, font): |
| container = ttLib.getTableClass("GDEF")() |
| log.debug("Parsing GDEF") |
| self = ot.GDEF() |
| fields = { |
| "class definition begin": ( |
| "GlyphClassDef", |
| lambda lines, font: parseClassDef(lines, font, klass=ot.GlyphClassDef), |
| ), |
| "attachment list begin": ("AttachList", parseAttachList), |
| "carets begin": ("LigCaretList", parseCaretList), |
| "mark attachment class definition begin": ( |
| "MarkAttachClassDef", |
| lambda lines, font: parseClassDef(lines, font, klass=ot.MarkAttachClassDef), |
| ), |
| "markfilter set definition begin": ("MarkGlyphSetsDef", parseMarkFilteringSets), |
| } |
| for attr, parser in fields.values(): |
| setattr(self, attr, None) |
| while lines.peek() is not None: |
| typ = lines.peek()[0].lower() |
| if typ not in fields: |
| log.debug("Skipping %s", typ) |
| next(lines) |
| continue |
| attr, parser = fields[typ] |
| assert getattr(self, attr) is None, attr |
| setattr(self, attr, parser(lines, font)) |
| self.Version = 0x00010000 if self.MarkGlyphSetsDef is None else 0x00010002 |
| container.table = self |
| return container |
| |
| |
| def parseCmap(lines, font): |
| container = ttLib.getTableClass("cmap")() |
| log.debug("Parsing cmap") |
| tables = [] |
| while lines.peek() is not None: |
| lines.expect("cmap subtable %d" % len(tables)) |
| platId, encId, fmt, lang = [ |
| parseCmapId(lines, field) |
| for field in ("platformID", "encodingID", "format", "language") |
| ] |
| table = cmap_classes[fmt](fmt) |
| table.platformID = platId |
| table.platEncID = encId |
| table.language = lang |
| table.cmap = {} |
| line = next(lines) |
| while line[0] != "end subtable": |
| table.cmap[int(line[0], 16)] = line[1] |
| line = next(lines) |
| tables.append(table) |
| container.tableVersion = 0 |
| container.tables = tables |
| return container |
| |
| |
| def parseCmapId(lines, field): |
| line = next(lines) |
| assert field == line[0] |
| return int(line[1]) |
| |
| |
| def parseTable(lines, font, tableTag=None): |
| log.debug("Parsing table") |
| line = lines.peeks() |
| tag = None |
| if line[0].split()[0] == "FontDame": |
| tag = line[0].split()[1] |
| elif " ".join(line[0].split()[:3]) == "Font Chef Table": |
| tag = line[0].split()[3] |
| if tag is not None: |
| next(lines) |
| tag = tag.ljust(4) |
| if tableTag is None: |
| tableTag = tag |
| else: |
| assert tableTag == tag, (tableTag, tag) |
| |
| assert ( |
| tableTag is not None |
| ), "Don't know what table to parse and data doesn't specify" |
| |
| return { |
| "GSUB": parseGSUB, |
| "GPOS": parseGPOS, |
| "GDEF": parseGDEF, |
| "cmap": parseCmap, |
| }[tableTag](lines, font) |
| |
| |
| class Tokenizer(object): |
| def __init__(self, f): |
| # TODO BytesIO / StringIO as needed? also, figure out whether we work on bytes or unicode |
| lines = iter(f) |
| try: |
| self.filename = f.name |
| except: |
| self.filename = None |
| self.lines = iter(lines) |
| self.line = "" |
| self.lineno = 0 |
| self.stoppers = [] |
| self.buffer = None |
| |
| def __iter__(self): |
| return self |
| |
| def _next_line(self): |
| self.lineno += 1 |
| line = self.line = next(self.lines) |
| line = [s.strip() for s in line.split("\t")] |
| if len(line) == 1 and not line[0]: |
| del line[0] |
| if line and not line[-1]: |
| log.warning("trailing tab found on line %d: %s" % (self.lineno, self.line)) |
| while line and not line[-1]: |
| del line[-1] |
| return line |
| |
| def _next_nonempty(self): |
| while True: |
| line = self._next_line() |
| # Skip comments and empty lines |
| if line and line[0] and (line[0][0] != "%" or line[0] == "% subtable"): |
| return line |
| |
| def _next_buffered(self): |
| if self.buffer: |
| ret = self.buffer |
| self.buffer = None |
| return ret |
| else: |
| return self._next_nonempty() |
| |
| def __next__(self): |
| line = self._next_buffered() |
| if line[0].lower() in self.stoppers: |
| self.buffer = line |
| raise StopIteration |
| return line |
| |
| def next(self): |
| return self.__next__() |
| |
| def peek(self): |
| if not self.buffer: |
| try: |
| self.buffer = self._next_nonempty() |
| except StopIteration: |
| return None |
| if self.buffer[0].lower() in self.stoppers: |
| return None |
| return self.buffer |
| |
| def peeks(self): |
| ret = self.peek() |
| return ret if ret is not None else ("",) |
| |
| @contextmanager |
| def between(self, tag): |
| start = tag + " begin" |
| end = tag + " end" |
| self.expectendswith(start) |
| self.stoppers.append(end) |
| yield |
| del self.stoppers[-1] |
| self.expect(tag + " end") |
| |
| @contextmanager |
| def until(self, tags): |
| if type(tags) is not tuple: |
| tags = (tags,) |
| self.stoppers.extend(tags) |
| yield |
| del self.stoppers[-len(tags) :] |
| |
| def expect(self, s): |
| line = next(self) |
| tag = line[0].lower() |
| assert tag == s, "Expected '%s', got '%s'" % (s, tag) |
| return line |
| |
| def expectendswith(self, s): |
| line = next(self) |
| tag = line[0].lower() |
| assert tag.endswith(s), "Expected '*%s', got '%s'" % (s, tag) |
| return line |
| |
| |
| def build(f, font, tableTag=None): |
| """Convert a Monotype font layout file to an OpenType layout object |
| |
| A font object must be passed, but this may be a "dummy" font; it is only |
| used for sorting glyph sets when making coverage tables and to hold the |
| OpenType layout table while it is being built. |
| |
| Args: |
| f: A file object. |
| font (TTFont): A font object. |
| tableTag (string): If provided, asserts that the file contains data for the |
| given OpenType table. |
| |
| Returns: |
| An object representing the table. (e.g. ``table_G_S_U_B_``) |
| """ |
| lines = Tokenizer(f) |
| return parseTable(lines, font, tableTag=tableTag) |
| |
| |
| def main(args=None, font=None): |
| """Convert a FontDame OTL file to TTX XML |
| |
| Writes XML output to stdout. |
| |
| Args: |
| args: Command line arguments (``--font``, ``--table``, input files). |
| """ |
| import sys |
| from fontTools import configLogger |
| from fontTools.misc.testTools import MockFont |
| |
| if args is None: |
| args = sys.argv[1:] |
| |
| # configure the library logger (for >= WARNING) |
| configLogger() |
| # comment this out to enable debug messages from mtiLib's logger |
| # log.setLevel(logging.DEBUG) |
| |
| import argparse |
| |
| parser = argparse.ArgumentParser( |
| "fonttools mtiLib", |
| description=main.__doc__, |
| ) |
| |
| parser.add_argument( |
| "--font", |
| "-f", |
| metavar="FILE", |
| dest="font", |
| help="Input TTF files (used for glyph classes and sorting coverage tables)", |
| ) |
| parser.add_argument( |
| "--table", |
| "-t", |
| metavar="TABLE", |
| dest="tableTag", |
| help="Table to fill (sniffed from input file if not provided)", |
| ) |
| parser.add_argument( |
| "inputs", metavar="FILE", type=str, nargs="+", help="Input FontDame .txt files" |
| ) |
| |
| args = parser.parse_args(args) |
| |
| if font is None: |
| if args.font: |
| font = ttLib.TTFont(args.font) |
| else: |
| font = MockFont() |
| |
| for f in args.inputs: |
| log.debug("Processing %s", f) |
| with open(f, "rt", encoding="utf-8") as f: |
| table = build(f, font, tableTag=args.tableTag) |
| blob = table.compile(font) # Make sure it compiles |
| decompiled = table.__class__() |
| decompiled.decompile(blob, font) # Make sure it decompiles! |
| |
| # continue |
| from fontTools.misc import xmlWriter |
| |
| tag = table.tableTag |
| writer = xmlWriter.XMLWriter(sys.stdout) |
| writer.begintag(tag) |
| writer.newline() |
| # table.toXML(writer, font) |
| decompiled.toXML(writer, font) |
| writer.endtag(tag) |
| writer.newline() |
| |
| |
| if __name__ == "__main__": |
| import sys |
| |
| sys.exit(main()) |
