#!/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
[docs]
class MtiLibError(Exception):
pass
[docs]
class ReferenceNotFoundError(MtiLibError):
pass
[docs]
class FeatureNotFoundError(ReferenceNotFoundError):
pass
[docs]
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)
[docs]
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
[docs]
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)
[docs]
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())