from fontTools.misc.py23 import *
from fontTools.feaLib.error import FeatureLibError
from fontTools.misc.encodingTools import getEncoding
from collections import OrderedDict
import itertools
SHIFT = " " * 4
__all__ = [
'AlternateSubstStatement',
'Anchor',
'AnchorDefinition',
'AnonymousBlock',
'AttachStatement',
'BaseAxis',
'Block',
'BytesIO',
'CVParametersNameStatement',
'ChainContextPosStatement',
'ChainContextSubstStatement',
'CharacterStatement',
'Comment',
'CursivePosStatement',
'Element',
'Expression',
'FeatureBlock',
'FeatureFile',
'FeatureLibError',
'FeatureNameStatement',
'FeatureReferenceStatement',
'FontRevisionStatement',
'GlyphClass',
'GlyphClassDefStatement',
'GlyphClassDefinition',
'GlyphClassName',
'GlyphName',
'HheaField',
'IgnorePosStatement',
'IgnoreSubstStatement',
'IncludeStatement',
'LanguageStatement',
'LanguageSystemStatement',
'LigatureCaretByIndexStatement',
'LigatureCaretByPosStatement',
'LigatureSubstStatement',
'LookupBlock',
'LookupFlagStatement',
'LookupReferenceStatement',
'MarkBasePosStatement',
'MarkClass',
'MarkClassDefinition',
'MarkClassName',
'MarkLigPosStatement',
'MarkMarkPosStatement',
'MultipleSubstStatement',
'NameRecord',
'NestedBlock',
'OS2Field',
'OrderedDict',
'PairPosStatement',
'Py23Error',
'ReverseChainSingleSubstStatement',
'ScriptStatement',
'SimpleNamespace',
'SinglePosStatement',
'SingleSubstStatement',
'SizeParameters',
'Statement',
'StringIO',
'SubtableStatement',
'TableBlock',
'Tag',
'UnicodeIO',
'ValueRecord',
'ValueRecordDefinition',
'VheaField',
]
def deviceToString(device):
if device is None:
return "<device NULL>"
else:
return "<device %s>" % ", ".join("%d %d" % t for t in device)
fea_keywords = set([
"anchor", "anchordef", "anon", "anonymous",
"by",
"contour", "cursive",
"device",
"enum", "enumerate", "excludedflt", "exclude_dflt",
"feature", "from",
"ignore", "ignorebaseglyphs", "ignoreligatures", "ignoremarks",
"include", "includedflt", "include_dflt",
"language", "languagesystem", "lookup", "lookupflag",
"mark", "markattachmenttype", "markclass",
"nameid", "null",
"parameters", "pos", "position",
"required", "righttoleft", "reversesub", "rsub",
"script", "sub", "substitute", "subtable",
"table",
"usemarkfilteringset", "useextension", "valuerecorddef",
"base", "gdef", "head", "hhea", "name", "vhea", "vmtx"]
)
def asFea(g):
if hasattr(g, 'asFea'):
return g.asFea()
elif isinstance(g, tuple) and len(g) == 2:
return asFea(g[0]) + "-" + asFea(g[1]) # a range
elif g.lower() in fea_keywords:
return "\\" + g
else:
return g
[docs]class Element(object):
def __init__(self, location=None):
self.location = location
[docs] def build(self, builder):
pass
[docs] def asFea(self, indent=""):
raise NotImplementedError
def __str__(self):
return self.asFea()
[docs]class Statement(Element):
pass
[docs]class Expression(Element):
pass
[docs]class GlyphName(Expression):
"""A single glyph name, such as cedilla."""
def __init__(self, glyph, location=None):
Expression.__init__(self, location)
self.glyph = glyph
[docs] def glyphSet(self):
return (self.glyph,)
[docs] def asFea(self, indent=""):
return asFea(self.glyph)
[docs]class GlyphClass(Expression):
"""A glyph class, such as [acute cedilla grave]."""
def __init__(self, glyphs=None, location=None):
Expression.__init__(self, location)
self.glyphs = glyphs if glyphs is not None else []
self.original = []
self.curr = 0
[docs] def glyphSet(self):
return tuple(self.glyphs)
[docs] def asFea(self, indent=""):
if len(self.original):
if self.curr < len(self.glyphs):
self.original.extend(self.glyphs[self.curr:])
self.curr = len(self.glyphs)
return "[" + " ".join(map(asFea, self.original)) + "]"
else:
return "[" + " ".join(map(asFea, self.glyphs)) + "]"
[docs] def extend(self, glyphs):
self.glyphs.extend(glyphs)
[docs] def append(self, glyph):
self.glyphs.append(glyph)
[docs] def add_range(self, start, end, glyphs):
if self.curr < len(self.glyphs):
self.original.extend(self.glyphs[self.curr:])
self.original.append((start, end))
self.glyphs.extend(glyphs)
self.curr = len(self.glyphs)
[docs] def add_cid_range(self, start, end, glyphs):
if self.curr < len(self.glyphs):
self.original.extend(self.glyphs[self.curr:])
self.original.append(("cid{:05d}".format(start), "cid{:05d}".format(end)))
self.glyphs.extend(glyphs)
self.curr = len(self.glyphs)
[docs] def add_class(self, gc):
if self.curr < len(self.glyphs):
self.original.extend(self.glyphs[self.curr:])
self.original.append(gc)
self.glyphs.extend(gc.glyphSet())
self.curr = len(self.glyphs)
[docs]class GlyphClassName(Expression):
"""A glyph class name, such as @FRENCH_MARKS."""
def __init__(self, glyphclass, location=None):
Expression.__init__(self, location)
assert isinstance(glyphclass, GlyphClassDefinition)
self.glyphclass = glyphclass
[docs] def glyphSet(self):
return tuple(self.glyphclass.glyphSet())
[docs] def asFea(self, indent=""):
return "@" + self.glyphclass.name
[docs]class MarkClassName(Expression):
"""A mark class name, such as @FRENCH_MARKS defined with markClass."""
def __init__(self, markClass, location=None):
Expression.__init__(self, location)
assert isinstance(markClass, MarkClass)
self.markClass = markClass
[docs] def glyphSet(self):
return self.markClass.glyphSet()
[docs] def asFea(self, indent=""):
return "@" + self.markClass.name
[docs]class AnonymousBlock(Statement):
def __init__(self, tag, content, location=None):
Statement.__init__(self, location)
self.tag, self.content = tag, content
[docs] def asFea(self, indent=""):
res = "anon {} {{\n".format(self.tag)
res += self.content
res += "}} {};\n\n".format(self.tag)
return res
[docs]class Block(Statement):
def __init__(self, location=None):
Statement.__init__(self, location)
self.statements = []
[docs] def build(self, builder):
for s in self.statements:
s.build(builder)
[docs] def asFea(self, indent=""):
indent += SHIFT
return indent + ("\n" + indent).join(
[s.asFea(indent=indent) for s in self.statements]) + "\n"
[docs]class FeatureFile(Block):
def __init__(self):
Block.__init__(self, location=None)
self.markClasses = {} # name --> ast.MarkClass
[docs] def asFea(self, indent=""):
return "\n".join(s.asFea(indent=indent) for s in self.statements)
[docs]class FeatureBlock(Block):
def __init__(self, name, use_extension=False, location=None):
Block.__init__(self, location)
self.name, self.use_extension = name, use_extension
[docs] def build(self, builder):
# TODO(sascha): Handle use_extension.
builder.start_feature(self.location, self.name)
# language exclude_dflt statements modify builder.features_
# limit them to this block with temporary builder.features_
features = builder.features_
builder.features_ = {}
Block.build(self, builder)
for key, value in builder.features_.items():
features.setdefault(key, []).extend(value)
builder.features_ = features
builder.end_feature()
[docs] def asFea(self, indent=""):
res = indent + "feature %s " % self.name.strip()
if self.use_extension:
res += "useExtension "
res += "{\n"
res += Block.asFea(self, indent=indent)
res += indent + "} %s;\n" % self.name.strip()
return res
[docs]class NestedBlock(Block):
def __init__(self, tag, block_name, location=None):
Block.__init__(self, location)
self.tag = tag
self.block_name = block_name
[docs] def build(self, builder):
Block.build(self, builder)
if self.block_name == "ParamUILabelNameID":
builder.add_to_cv_num_named_params(self.tag)
[docs] def asFea(self, indent=""):
res = "{}{} {{\n".format(indent, self.block_name)
res += Block.asFea(self, indent=indent)
res += "{}}};\n".format(indent)
return res
[docs]class LookupBlock(Block):
def __init__(self, name, use_extension=False, location=None):
Block.__init__(self, location)
self.name, self.use_extension = name, use_extension
[docs] def build(self, builder):
# TODO(sascha): Handle use_extension.
builder.start_lookup_block(self.location, self.name)
Block.build(self, builder)
builder.end_lookup_block()
[docs] def asFea(self, indent=""):
res = "lookup {} ".format(self.name)
if self.use_extension:
res += "useExtension "
res += "{\n"
res += Block.asFea(self, indent=indent)
res += "{}}} {};\n".format(indent, self.name)
return res
[docs]class TableBlock(Block):
def __init__(self, name, location=None):
Block.__init__(self, location)
self.name = name
[docs] def asFea(self, indent=""):
res = "table {} {{\n".format(self.name.strip())
res += super(TableBlock, self).asFea(indent=indent)
res += "}} {};\n".format(self.name.strip())
return res
[docs]class GlyphClassDefinition(Statement):
"""Example: @UPPERCASE = [A-Z];"""
def __init__(self, name, glyphs, location=None):
Statement.__init__(self, location)
self.name = name
self.glyphs = glyphs
[docs] def glyphSet(self):
return tuple(self.glyphs.glyphSet())
[docs] def asFea(self, indent=""):
return "@" + self.name + " = " + self.glyphs.asFea() + ";"
[docs]class GlyphClassDefStatement(Statement):
"""Example: GlyphClassDef @UPPERCASE, [B], [C], [D];"""
def __init__(self, baseGlyphs, markGlyphs, ligatureGlyphs,
componentGlyphs, location=None):
Statement.__init__(self, location)
self.baseGlyphs, self.markGlyphs = (baseGlyphs, markGlyphs)
self.ligatureGlyphs = ligatureGlyphs
self.componentGlyphs = componentGlyphs
[docs] def build(self, builder):
base = self.baseGlyphs.glyphSet() if self.baseGlyphs else tuple()
liga = self.ligatureGlyphs.glyphSet() \
if self.ligatureGlyphs else tuple()
mark = self.markGlyphs.glyphSet() if self.markGlyphs else tuple()
comp = (self.componentGlyphs.glyphSet()
if self.componentGlyphs else tuple())
builder.add_glyphClassDef(self.location, base, liga, mark, comp)
[docs] def asFea(self, indent=""):
return "GlyphClassDef {}, {}, {}, {};".format(
self.baseGlyphs.asFea() if self.baseGlyphs else "",
self.ligatureGlyphs.asFea() if self.ligatureGlyphs else "",
self.markGlyphs.asFea() if self.markGlyphs else "",
self.componentGlyphs.asFea() if self.componentGlyphs else "")
# While glyph classes can be defined only once, the feature file format
# allows expanding mark classes with multiple definitions, each using
# different glyphs and anchors. The following are two MarkClassDefinitions
# for the same MarkClass:
# markClass [acute grave] <anchor 350 800> @FRENCH_ACCENTS;
# markClass [cedilla] <anchor 350 -200> @FRENCH_ACCENTS;
[docs]class MarkClass(object):
def __init__(self, name):
self.name = name
self.definitions = []
self.glyphs = OrderedDict() # glyph --> ast.MarkClassDefinitions
[docs] def addDefinition(self, definition):
assert isinstance(definition, MarkClassDefinition)
self.definitions.append(definition)
for glyph in definition.glyphSet():
if glyph in self.glyphs:
otherLoc = self.glyphs[glyph].location
if otherLoc is None:
end = ""
else:
end = " at %s:%d:%d" % (
otherLoc[0], otherLoc[1], otherLoc[2])
raise FeatureLibError(
"Glyph %s already defined%s" % (glyph, end),
definition.location)
self.glyphs[glyph] = definition
[docs] def glyphSet(self):
return tuple(self.glyphs.keys())
[docs] def asFea(self, indent=""):
res = "\n".join(d.asFea() for d in self.definitions)
return res
[docs]class MarkClassDefinition(Statement):
def __init__(self, markClass, anchor, glyphs, location=None):
Statement.__init__(self, location)
assert isinstance(markClass, MarkClass)
assert isinstance(anchor, Anchor) and isinstance(glyphs, Expression)
self.markClass, self.anchor, self.glyphs = markClass, anchor, glyphs
[docs] def glyphSet(self):
return self.glyphs.glyphSet()
[docs] def asFea(self, indent=""):
return "markClass {} {} @{};".format(
self.glyphs.asFea(), self.anchor.asFea(),
self.markClass.name)
[docs]class AlternateSubstStatement(Statement):
def __init__(self, prefix, glyph, suffix, replacement, location=None):
Statement.__init__(self, location)
self.prefix, self.glyph, self.suffix = (prefix, glyph, suffix)
self.replacement = replacement
[docs] def build(self, builder):
glyph = self.glyph.glyphSet()
assert len(glyph) == 1, glyph
glyph = list(glyph)[0]
prefix = [p.glyphSet() for p in self.prefix]
suffix = [s.glyphSet() for s in self.suffix]
replacement = self.replacement.glyphSet()
builder.add_alternate_subst(self.location, prefix, glyph, suffix,
replacement)
[docs] def asFea(self, indent=""):
res = "sub "
if len(self.prefix) or len(self.suffix):
if len(self.prefix):
res += " ".join(map(asFea, self.prefix)) + " "
res += asFea(self.glyph) + "'" # even though we really only use 1
if len(self.suffix):
res += " " + " ".join(map(asFea, self.suffix))
else:
res += asFea(self.glyph)
res += " from "
res += asFea(self.replacement)
res += ";"
return res
[docs]class Anchor(Expression):
def __init__(self, x, y, name=None, contourpoint=None,
xDeviceTable=None, yDeviceTable=None, location=None):
Expression.__init__(self, location)
self.name = name
self.x, self.y, self.contourpoint = x, y, contourpoint
self.xDeviceTable, self.yDeviceTable = xDeviceTable, yDeviceTable
[docs] def asFea(self, indent=""):
if self.name is not None:
return "<anchor {}>".format(self.name)
res = "<anchor {} {}".format(self.x, self.y)
if self.contourpoint:
res += " contourpoint {}".format(self.contourpoint)
if self.xDeviceTable or self.yDeviceTable:
res += " "
res += deviceToString(self.xDeviceTable)
res += " "
res += deviceToString(self.yDeviceTable)
res += ">"
return res
[docs]class AnchorDefinition(Statement):
def __init__(self, name, x, y, contourpoint=None, location=None):
Statement.__init__(self, location)
self.name, self.x, self.y, self.contourpoint = name, x, y, contourpoint
[docs] def asFea(self, indent=""):
res = "anchorDef {} {}".format(self.x, self.y)
if self.contourpoint:
res += " contourpoint {}".format(self.contourpoint)
res += " {};".format(self.name)
return res
[docs]class AttachStatement(Statement):
def __init__(self, glyphs, contourPoints, location=None):
Statement.__init__(self, location)
self.glyphs, self.contourPoints = (glyphs, contourPoints)
[docs] def build(self, builder):
glyphs = self.glyphs.glyphSet()
builder.add_attach_points(self.location, glyphs, self.contourPoints)
[docs] def asFea(self, indent=""):
return "Attach {} {};".format(
self.glyphs.asFea(), " ".join(str(c) for c in self.contourPoints))
[docs]class ChainContextPosStatement(Statement):
def __init__(self, prefix, glyphs, suffix, lookups, location=None):
Statement.__init__(self, location)
self.prefix, self.glyphs, self.suffix = prefix, glyphs, suffix
self.lookups = lookups
[docs] def build(self, builder):
prefix = [p.glyphSet() for p in self.prefix]
glyphs = [g.glyphSet() for g in self.glyphs]
suffix = [s.glyphSet() for s in self.suffix]
builder.add_chain_context_pos(
self.location, prefix, glyphs, suffix, self.lookups)
[docs] def asFea(self, indent=""):
res = "pos "
if len(self.prefix) or len(self.suffix) or any([x is not None for x in self.lookups]):
if len(self.prefix):
res += " ".join(g.asFea() for g in self.prefix) + " "
for i, g in enumerate(self.glyphs):
res += g.asFea() + "'"
if self.lookups[i] is not None:
res += " lookup " + self.lookups[i].name
if i < len(self.glyphs) - 1:
res += " "
if len(self.suffix):
res += " " + " ".join(map(asFea, self.suffix))
else:
res += " ".join(map(asFea, self.glyph))
res += ";"
return res
[docs]class ChainContextSubstStatement(Statement):
def __init__(self, prefix, glyphs, suffix, lookups, location=None):
Statement.__init__(self, location)
self.prefix, self.glyphs, self.suffix = prefix, glyphs, suffix
self.lookups = lookups
[docs] def build(self, builder):
prefix = [p.glyphSet() for p in self.prefix]
glyphs = [g.glyphSet() for g in self.glyphs]
suffix = [s.glyphSet() for s in self.suffix]
builder.add_chain_context_subst(
self.location, prefix, glyphs, suffix, self.lookups)
[docs] def asFea(self, indent=""):
res = "sub "
if len(self.prefix) or len(self.suffix) or any([x is not None for x in self.lookups]):
if len(self.prefix):
res += " ".join(g.asFea() for g in self.prefix) + " "
for i, g in enumerate(self.glyphs):
res += g.asFea() + "'"
if self.lookups[i] is not None:
res += " lookup " + self.lookups[i].name
if i < len(self.glyphs) - 1:
res += " "
if len(self.suffix):
res += " " + " ".join(map(asFea, self.suffix))
else:
res += " ".join(map(asFea, self.glyph))
res += ";"
return res
[docs]class CursivePosStatement(Statement):
def __init__(self, glyphclass, entryAnchor, exitAnchor, location=None):
Statement.__init__(self, location)
self.glyphclass = glyphclass
self.entryAnchor, self.exitAnchor = entryAnchor, exitAnchor
[docs] def build(self, builder):
builder.add_cursive_pos(
self.location, self.glyphclass.glyphSet(), self.entryAnchor, self.exitAnchor)
[docs] def asFea(self, indent=""):
entry = self.entryAnchor.asFea() if self.entryAnchor else "<anchor NULL>"
exit = self.exitAnchor.asFea() if self.exitAnchor else "<anchor NULL>"
return "pos cursive {} {} {};".format(self.glyphclass.asFea(), entry, exit)
[docs]class FeatureReferenceStatement(Statement):
"""Example: feature salt;"""
def __init__(self, featureName, location=None):
Statement.__init__(self, location)
self.location, self.featureName = (location, featureName)
[docs] def build(self, builder):
builder.add_feature_reference(self.location, self.featureName)
[docs] def asFea(self, indent=""):
return "feature {};".format(self.featureName)
[docs]class IgnorePosStatement(Statement):
def __init__(self, chainContexts, location=None):
Statement.__init__(self, location)
self.chainContexts = chainContexts
[docs] def build(self, builder):
for prefix, glyphs, suffix in self.chainContexts:
prefix = [p.glyphSet() for p in prefix]
glyphs = [g.glyphSet() for g in glyphs]
suffix = [s.glyphSet() for s in suffix]
builder.add_chain_context_pos(
self.location, prefix, glyphs, suffix, [])
[docs] def asFea(self, indent=""):
contexts = []
for prefix, glyphs, suffix in self.chainContexts:
res = ""
if len(prefix) or len(suffix):
if len(prefix):
res += " ".join(map(asFea, prefix)) + " "
res += " ".join(g.asFea() + "'" for g in glyphs)
if len(suffix):
res += " " + " ".join(map(asFea, suffix))
else:
res += " ".join(map(asFea, glyphs))
contexts.append(res)
return "ignore pos " + ", ".join(contexts) + ";"
[docs]class IgnoreSubstStatement(Statement):
def __init__(self, chainContexts, location=None):
Statement.__init__(self, location)
self.chainContexts = chainContexts
[docs] def build(self, builder):
for prefix, glyphs, suffix in self.chainContexts:
prefix = [p.glyphSet() for p in prefix]
glyphs = [g.glyphSet() for g in glyphs]
suffix = [s.glyphSet() for s in suffix]
builder.add_chain_context_subst(
self.location, prefix, glyphs, suffix, [])
[docs] def asFea(self, indent=""):
contexts = []
for prefix, glyphs, suffix in self.chainContexts:
res = ""
if len(prefix) or len(suffix):
if len(prefix):
res += " ".join(map(asFea, prefix)) + " "
res += " ".join(g.asFea() + "'" for g in glyphs)
if len(suffix):
res += " " + " ".join(map(asFea, suffix))
else:
res += " ".join(map(asFea, glyphs))
contexts.append(res)
return "ignore sub " + ", ".join(contexts) + ";"
[docs]class IncludeStatement(Statement):
def __init__(self, filename, location=None):
super(IncludeStatement, self).__init__(location)
self.filename = filename
[docs] def build(self):
# TODO: consider lazy-loading the including parser/lexer?
raise FeatureLibError(
"Building an include statement is not implemented yet. "
"Instead, use Parser(..., followIncludes=True) for building.",
self.location)
[docs] def asFea(self, indent=""):
return indent + "include(%s);" % self.filename
[docs]class LanguageStatement(Statement):
def __init__(self, language, include_default=True, required=False,
location=None):
Statement.__init__(self, location)
assert(len(language) == 4)
self.language = language
self.include_default = include_default
self.required = required
[docs] def build(self, builder):
builder.set_language(location=self.location, language=self.language,
include_default=self.include_default,
required=self.required)
[docs] def asFea(self, indent=""):
res = "language {}".format(self.language.strip())
if not self.include_default:
res += " exclude_dflt"
if self.required:
res += " required"
res += ";"
return res
[docs]class LanguageSystemStatement(Statement):
def __init__(self, script, language, location=None):
Statement.__init__(self, location)
self.script, self.language = (script, language)
[docs] def build(self, builder):
builder.add_language_system(self.location, self.script, self.language)
[docs] def asFea(self, indent=""):
return "languagesystem {} {};".format(self.script, self.language.strip())
[docs]class FontRevisionStatement(Statement):
def __init__(self, revision, location=None):
Statement.__init__(self, location)
self.revision = revision
[docs] def build(self, builder):
builder.set_font_revision(self.location, self.revision)
[docs] def asFea(self, indent=""):
return "FontRevision {:.3f};".format(self.revision)
[docs]class LigatureCaretByIndexStatement(Statement):
def __init__(self, glyphs, carets, location=None):
Statement.__init__(self, location)
self.glyphs, self.carets = (glyphs, carets)
[docs] def build(self, builder):
glyphs = self.glyphs.glyphSet()
builder.add_ligatureCaretByIndex_(self.location, glyphs, set(self.carets))
[docs] def asFea(self, indent=""):
return "LigatureCaretByIndex {} {};".format(
self.glyphs.asFea(), " ".join(str(x) for x in self.carets))
[docs]class LigatureCaretByPosStatement(Statement):
def __init__(self, glyphs, carets, location=None):
Statement.__init__(self, location)
self.glyphs, self.carets = (glyphs, carets)
[docs] def build(self, builder):
glyphs = self.glyphs.glyphSet()
builder.add_ligatureCaretByPos_(self.location, glyphs, set(self.carets))
[docs] def asFea(self, indent=""):
return "LigatureCaretByPos {} {};".format(
self.glyphs.asFea(), " ".join(str(x) for x in self.carets))
[docs]class LigatureSubstStatement(Statement):
def __init__(self, prefix, glyphs, suffix, replacement,
forceChain, location=None):
Statement.__init__(self, location)
self.prefix, self.glyphs, self.suffix = (prefix, glyphs, suffix)
self.replacement, self.forceChain = replacement, forceChain
[docs] def build(self, builder):
prefix = [p.glyphSet() for p in self.prefix]
glyphs = [g.glyphSet() for g in self.glyphs]
suffix = [s.glyphSet() for s in self.suffix]
builder.add_ligature_subst(
self.location, prefix, glyphs, suffix, self.replacement,
self.forceChain)
[docs] def asFea(self, indent=""):
res = "sub "
if len(self.prefix) or len(self.suffix) or self.forceChain:
if len(self.prefix):
res += " ".join(g.asFea() for g in self.prefix) + " "
res += " ".join(g.asFea() + "'" for g in self.glyphs)
if len(self.suffix):
res += " " + " ".join(g.asFea() for g in self.suffix)
else:
res += " ".join(g.asFea() for g in self.glyphs)
res += " by "
res += asFea(self.replacement)
res += ";"
return res
[docs]class LookupFlagStatement(Statement):
def __init__(self, value=0, markAttachment=None, markFilteringSet=None,
location=None):
Statement.__init__(self, location)
self.value = value
self.markAttachment = markAttachment
self.markFilteringSet = markFilteringSet
[docs] def build(self, builder):
markAttach = None
if self.markAttachment is not None:
markAttach = self.markAttachment.glyphSet()
markFilter = None
if self.markFilteringSet is not None:
markFilter = self.markFilteringSet.glyphSet()
builder.set_lookup_flag(self.location, self.value,
markAttach, markFilter)
[docs] def asFea(self, indent=""):
res = []
flags = ["RightToLeft", "IgnoreBaseGlyphs", "IgnoreLigatures", "IgnoreMarks"]
curr = 1
for i in range(len(flags)):
if self.value & curr != 0:
res.append(flags[i])
curr = curr << 1
if self.markAttachment is not None:
res.append("MarkAttachmentType {}".format(self.markAttachment.asFea()))
if self.markFilteringSet is not None:
res.append("UseMarkFilteringSet {}".format(self.markFilteringSet.asFea()))
if not res:
res = ["0"]
return "lookupflag {};".format(" ".join(res))
[docs]class LookupReferenceStatement(Statement):
def __init__(self, lookup, location=None):
Statement.__init__(self, location)
self.location, self.lookup = (location, lookup)
[docs] def build(self, builder):
builder.add_lookup_call(self.lookup.name)
[docs] def asFea(self, indent=""):
return "lookup {};".format(self.lookup.name)
[docs]class MarkBasePosStatement(Statement):
def __init__(self, base, marks, location=None):
Statement.__init__(self, location)
self.base, self.marks = base, marks
[docs] def build(self, builder):
builder.add_mark_base_pos(self.location, self.base.glyphSet(), self.marks)
[docs] def asFea(self, indent=""):
res = "pos base {}".format(self.base.asFea())
for a, m in self.marks:
res += " {} mark @{}".format(a.asFea(), m.name)
res += ";"
return res
[docs]class MarkLigPosStatement(Statement):
def __init__(self, ligatures, marks, location=None):
Statement.__init__(self, location)
self.ligatures, self.marks = ligatures, marks
[docs] def build(self, builder):
builder.add_mark_lig_pos(self.location, self.ligatures.glyphSet(), self.marks)
[docs] def asFea(self, indent=""):
res = "pos ligature {}".format(self.ligatures.asFea())
ligs = []
for l in self.marks:
temp = ""
if l is None or not len(l):
temp = " <anchor NULL>"
else:
for a, m in l:
temp += " {} mark @{}".format(a.asFea(), m.name)
ligs.append(temp)
res += ("\n" + indent + SHIFT + "ligComponent").join(ligs)
res += ";"
return res
[docs]class MarkMarkPosStatement(Statement):
def __init__(self, baseMarks, marks, location=None):
Statement.__init__(self, location)
self.baseMarks, self.marks = baseMarks, marks
[docs] def build(self, builder):
builder.add_mark_mark_pos(self.location, self.baseMarks.glyphSet(), self.marks)
[docs] def asFea(self, indent=""):
res = "pos mark {}".format(self.baseMarks.asFea())
for a, m in self.marks:
res += " {} mark @{}".format(a.asFea(), m.name)
res += ";"
return res
[docs]class MultipleSubstStatement(Statement):
def __init__(
self, prefix, glyph, suffix, replacement, forceChain=False, location=None
):
Statement.__init__(self, location)
self.prefix, self.glyph, self.suffix = prefix, glyph, suffix
self.replacement = replacement
self.forceChain = forceChain
[docs] def build(self, builder):
prefix = [p.glyphSet() for p in self.prefix]
suffix = [s.glyphSet() for s in self.suffix]
builder.add_multiple_subst(
self.location, prefix, self.glyph, suffix, self.replacement,
self.forceChain)
[docs] def asFea(self, indent=""):
res = "sub "
if len(self.prefix) or len(self.suffix) or self.forceChain:
if len(self.prefix):
res += " ".join(map(asFea, self.prefix)) + " "
res += asFea(self.glyph) + "'"
if len(self.suffix):
res += " " + " ".join(map(asFea, self.suffix))
else:
res += asFea(self.glyph)
res += " by "
res += " ".join(map(asFea, self.replacement))
res += ";"
return res
[docs]class PairPosStatement(Statement):
def __init__(self, glyphs1, valuerecord1, glyphs2, valuerecord2,
enumerated=False, location=None):
Statement.__init__(self, location)
self.enumerated = enumerated
self.glyphs1, self.valuerecord1 = glyphs1, valuerecord1
self.glyphs2, self.valuerecord2 = glyphs2, valuerecord2
[docs] def build(self, builder):
if self.enumerated:
g = [self.glyphs1.glyphSet(), self.glyphs2.glyphSet()]
for glyph1, glyph2 in itertools.product(*g):
builder.add_specific_pair_pos(
self.location, glyph1, self.valuerecord1,
glyph2, self.valuerecord2)
return
is_specific = (isinstance(self.glyphs1, GlyphName) and
isinstance(self.glyphs2, GlyphName))
if is_specific:
builder.add_specific_pair_pos(
self.location, self.glyphs1.glyph, self.valuerecord1,
self.glyphs2.glyph, self.valuerecord2)
else:
builder.add_class_pair_pos(
self.location, self.glyphs1.glyphSet(), self.valuerecord1,
self.glyphs2.glyphSet(), self.valuerecord2)
[docs] def asFea(self, indent=""):
res = "enum " if self.enumerated else ""
if self.valuerecord2:
res += "pos {} {} {} {};".format(
self.glyphs1.asFea(), self.valuerecord1.asFea(),
self.glyphs2.asFea(), self.valuerecord2.asFea())
else:
res += "pos {} {} {};".format(
self.glyphs1.asFea(), self.glyphs2.asFea(),
self.valuerecord1.asFea())
return res
[docs]class ReverseChainSingleSubstStatement(Statement):
def __init__(self, old_prefix, old_suffix, glyphs, replacements,
location=None):
Statement.__init__(self, location)
self.old_prefix, self.old_suffix = old_prefix, old_suffix
self.glyphs = glyphs
self.replacements = replacements
[docs] def build(self, builder):
prefix = [p.glyphSet() for p in self.old_prefix]
suffix = [s.glyphSet() for s in self.old_suffix]
originals = self.glyphs[0].glyphSet()
replaces = self.replacements[0].glyphSet()
if len(replaces) == 1:
replaces = replaces * len(originals)
builder.add_reverse_chain_single_subst(
self.location, prefix, suffix, dict(zip(originals, replaces)))
[docs] def asFea(self, indent=""):
res = "rsub "
if len(self.old_prefix) or len(self.old_suffix):
if len(self.old_prefix):
res += " ".join(asFea(g) for g in self.old_prefix) + " "
res += " ".join(asFea(g) + "'" for g in self.glyphs)
if len(self.old_suffix):
res += " " + " ".join(asFea(g) for g in self.old_suffix)
else:
res += " ".join(map(asFea, self.glyphs))
res += " by {};".format(" ".join(asFea(g) for g in self.replacements))
return res
[docs]class SingleSubstStatement(Statement):
def __init__(self, glyphs, replace, prefix, suffix, forceChain,
location=None):
Statement.__init__(self, location)
self.prefix, self.suffix = prefix, suffix
self.forceChain = forceChain
self.glyphs = glyphs
self.replacements = replace
[docs] def build(self, builder):
prefix = [p.glyphSet() for p in self.prefix]
suffix = [s.glyphSet() for s in self.suffix]
originals = self.glyphs[0].glyphSet()
replaces = self.replacements[0].glyphSet()
if len(replaces) == 1:
replaces = replaces * len(originals)
builder.add_single_subst(self.location, prefix, suffix,
OrderedDict(zip(originals, replaces)),
self.forceChain)
[docs] def asFea(self, indent=""):
res = "sub "
if len(self.prefix) or len(self.suffix) or self.forceChain:
if len(self.prefix):
res += " ".join(asFea(g) for g in self.prefix) + " "
res += " ".join(asFea(g) + "'" for g in self.glyphs)
if len(self.suffix):
res += " " + " ".join(asFea(g) for g in self.suffix)
else:
res += " ".join(asFea(g) for g in self.glyphs)
res += " by {};".format(" ".join(asFea(g) for g in self.replacements))
return res
[docs]class ScriptStatement(Statement):
def __init__(self, script, location=None):
Statement.__init__(self, location)
self.script = script
[docs] def build(self, builder):
builder.set_script(self.location, self.script)
[docs] def asFea(self, indent=""):
return "script {};".format(self.script.strip())
[docs]class SinglePosStatement(Statement):
def __init__(self, pos, prefix, suffix, forceChain, location=None):
Statement.__init__(self, location)
self.pos, self.prefix, self.suffix = pos, prefix, suffix
self.forceChain = forceChain
[docs] def build(self, builder):
prefix = [p.glyphSet() for p in self.prefix]
suffix = [s.glyphSet() for s in self.suffix]
pos = [(g.glyphSet(), value) for g, value in self.pos]
builder.add_single_pos(self.location, prefix, suffix,
pos, self.forceChain)
[docs] def asFea(self, indent=""):
res = "pos "
if len(self.prefix) or len(self.suffix) or self.forceChain:
if len(self.prefix):
res += " ".join(map(asFea, self.prefix)) + " "
res += " ".join([asFea(x[0]) + "'" + (
(" " + x[1].asFea()) if x[1] else "") for x in self.pos])
if len(self.suffix):
res += " " + " ".join(map(asFea, self.suffix))
else:
res += " ".join([asFea(x[0]) + " " +
(x[1].asFea() if x[1] else "") for x in self.pos])
res += ";"
return res
[docs]class SubtableStatement(Statement):
def __init__(self, location=None):
Statement.__init__(self, location)
[docs] def build(self, builder):
builder.add_subtable_break(self.location)
[docs] def asFea(self, indent=""):
return "subtable;"
[docs]class ValueRecord(Expression):
def __init__(self, xPlacement=None, yPlacement=None,
xAdvance=None, yAdvance=None,
xPlaDevice=None, yPlaDevice=None,
xAdvDevice=None, yAdvDevice=None,
vertical=False, location=None):
Expression.__init__(self, location)
self.xPlacement, self.yPlacement = (xPlacement, yPlacement)
self.xAdvance, self.yAdvance = (xAdvance, yAdvance)
self.xPlaDevice, self.yPlaDevice = (xPlaDevice, yPlaDevice)
self.xAdvDevice, self.yAdvDevice = (xAdvDevice, yAdvDevice)
self.vertical = vertical
def __eq__(self, other):
return (self.xPlacement == other.xPlacement and
self.yPlacement == other.yPlacement and
self.xAdvance == other.xAdvance and
self.yAdvance == other.yAdvance and
self.xPlaDevice == other.xPlaDevice and
self.xAdvDevice == other.xAdvDevice)
def __ne__(self, other):
return not self.__eq__(other)
def __hash__(self):
return (hash(self.xPlacement) ^ hash(self.yPlacement) ^
hash(self.xAdvance) ^ hash(self.yAdvance) ^
hash(self.xPlaDevice) ^ hash(self.yPlaDevice) ^
hash(self.xAdvDevice) ^ hash(self.yAdvDevice))
[docs] def asFea(self, indent=""):
if not self:
return "<NULL>"
x, y = self.xPlacement, self.yPlacement
xAdvance, yAdvance = self.xAdvance, self.yAdvance
xPlaDevice, yPlaDevice = self.xPlaDevice, self.yPlaDevice
xAdvDevice, yAdvDevice = self.xAdvDevice, self.yAdvDevice
vertical = self.vertical
# Try format A, if possible.
if x is None and y is None:
if xAdvance is None and vertical:
return str(yAdvance)
elif yAdvance is None and not vertical:
return str(xAdvance)
# Make any remaining None value 0 to avoid generating invalid records.
x = x or 0
y = y or 0
xAdvance = xAdvance or 0
yAdvance = yAdvance or 0
# Try format B, if possible.
if (xPlaDevice is None and yPlaDevice is None and
xAdvDevice is None and yAdvDevice is None):
return "<%s %s %s %s>" % (x, y, xAdvance, yAdvance)
# Last resort is format C.
return "<%s %s %s %s %s %s %s %s>" % (
x, y, xAdvance, yAdvance,
deviceToString(xPlaDevice), deviceToString(yPlaDevice),
deviceToString(xAdvDevice), deviceToString(yAdvDevice))
def __bool__(self):
return any(
getattr(self, v) is not None
for v in [
"xPlacement",
"yPlacement",
"xAdvance",
"yAdvance",
"xPlaDevice",
"yPlaDevice",
"xAdvDevice",
"yAdvDevice",
]
)
__nonzero__ = __bool__
[docs]class ValueRecordDefinition(Statement):
def __init__(self, name, value, location=None):
Statement.__init__(self, location)
self.name = name
self.value = value
[docs] def asFea(self, indent=""):
return "valueRecordDef {} {};".format(self.value.asFea(), self.name)
def simplify_name_attributes(pid, eid, lid):
if pid == 3 and eid == 1 and lid == 1033:
return ""
elif pid == 1 and eid == 0 and lid == 0:
return "1"
else:
return "{} {} {}".format(pid, eid, lid)
[docs]class NameRecord(Statement):
def __init__(self, nameID, platformID, platEncID, langID, string,
location=None):
Statement.__init__(self, location)
self.nameID = nameID
self.platformID = platformID
self.platEncID = platEncID
self.langID = langID
self.string = string
[docs] def build(self, builder):
builder.add_name_record(
self.location, self.nameID, self.platformID,
self.platEncID, self.langID, self.string)
[docs] def asFea(self, indent=""):
def escape(c, escape_pattern):
# Also escape U+0022 QUOTATION MARK and U+005C REVERSE SOLIDUS
if c >= 0x20 and c <= 0x7E and c not in (0x22, 0x5C):
return unichr(c)
else:
return escape_pattern % c
encoding = getEncoding(self.platformID, self.platEncID, self.langID)
if encoding is None:
raise FeatureLibError("Unsupported encoding", self.location)
s = tobytes(self.string, encoding=encoding)
if encoding == "utf_16_be":
escaped_string = "".join([
escape(byteord(s[i]) * 256 + byteord(s[i + 1]), r"\%04x")
for i in range(0, len(s), 2)])
else:
escaped_string = "".join([escape(byteord(b), r"\%02x") for b in s])
plat = simplify_name_attributes(
self.platformID, self.platEncID, self.langID)
if plat != "":
plat += " "
return "nameid {} {}\"{}\";".format(self.nameID, plat, escaped_string)
[docs]class FeatureNameStatement(NameRecord):
[docs] def build(self, builder):
NameRecord.build(self, builder)
builder.add_featureName(self.nameID)
[docs] def asFea(self, indent=""):
if self.nameID == "size":
tag = "sizemenuname"
else:
tag = "name"
plat = simplify_name_attributes(self.platformID, self.platEncID, self.langID)
if plat != "":
plat += " "
return "{} {}\"{}\";".format(tag, plat, self.string)
[docs]class SizeParameters(Statement):
def __init__(self, DesignSize, SubfamilyID, RangeStart, RangeEnd,
location=None):
Statement.__init__(self, location)
self.DesignSize = DesignSize
self.SubfamilyID = SubfamilyID
self.RangeStart = RangeStart
self.RangeEnd = RangeEnd
[docs] def build(self, builder):
builder.set_size_parameters(self.location, self.DesignSize,
self.SubfamilyID, self.RangeStart, self.RangeEnd)
[docs] def asFea(self, indent=""):
res = "parameters {:.1f} {}".format(self.DesignSize, self.SubfamilyID)
if self.RangeStart != 0 or self.RangeEnd != 0:
res += " {} {}".format(int(self.RangeStart * 10), int(self.RangeEnd * 10))
return res + ";"
[docs]class CVParametersNameStatement(NameRecord):
def __init__(self, nameID, platformID, platEncID, langID, string,
block_name, location=None):
NameRecord.__init__(self, nameID, platformID, platEncID, langID,
string, location=location)
self.block_name = block_name
[docs] def build(self, builder):
item = ""
if self.block_name == "ParamUILabelNameID":
item = "_{}".format(builder.cv_num_named_params_.get(self.nameID, 0))
builder.add_cv_parameter(self.nameID)
self.nameID = (self.nameID, self.block_name + item)
NameRecord.build(self, builder)
[docs] def asFea(self, indent=""):
plat = simplify_name_attributes(self.platformID, self.platEncID,
self.langID)
if plat != "":
plat += " "
return "name {}\"{}\";".format(plat, self.string)
[docs]class CharacterStatement(Statement):
"""
Statement used in cvParameters blocks of Character Variant features (cvXX).
The Unicode value may be written with either decimal or hexadecimal
notation. The value must be preceded by '0x' if it is a hexadecimal value.
The largest Unicode value allowed is 0xFFFFFF.
"""
def __init__(self, character, tag, location=None):
Statement.__init__(self, location)
self.character = character
self.tag = tag
[docs] def build(self, builder):
builder.add_cv_character(self.character, self.tag)
[docs] def asFea(self, indent=""):
return "Character {:#x};".format(self.character)
[docs]class BaseAxis(Statement):
def __init__(self, bases, scripts, vertical, location=None):
Statement.__init__(self, location)
self.bases = bases
self.scripts = scripts
self.vertical = vertical
[docs] def build(self, builder):
builder.set_base_axis(self.bases, self.scripts, self.vertical)
[docs] def asFea(self, indent=""):
direction = "Vert" if self.vertical else "Horiz"
scripts = ["{} {} {}".format(a[0], a[1], " ".join(map(str, a[2]))) for a in self.scripts]
return "{}Axis.BaseTagList {};\n{}{}Axis.BaseScriptList {};".format(
direction, " ".join(self.bases), indent, direction, ", ".join(scripts))
[docs]class OS2Field(Statement):
def __init__(self, key, value, location=None):
Statement.__init__(self, location)
self.key = key
self.value = value
[docs] def build(self, builder):
builder.add_os2_field(self.key, self.value)
[docs] def asFea(self, indent=""):
def intarr2str(x):
return " ".join(map(str, x))
numbers = ("FSType", "TypoAscender", "TypoDescender", "TypoLineGap",
"winAscent", "winDescent", "XHeight", "CapHeight",
"WeightClass", "WidthClass", "LowerOpSize", "UpperOpSize")
ranges = ("UnicodeRange", "CodePageRange")
keywords = dict([(x.lower(), [x, str]) for x in numbers])
keywords.update([(x.lower(), [x, intarr2str]) for x in ranges])
keywords["panose"] = ["Panose", intarr2str]
keywords["vendor"] = ["Vendor", lambda y: '"{}"'.format(y)]
if self.key in keywords:
return "{} {};".format(keywords[self.key][0], keywords[self.key][1](self.value))
return "" # should raise exception
[docs]class HheaField(Statement):
def __init__(self, key, value, location=None):
Statement.__init__(self, location)
self.key = key
self.value = value
[docs] def build(self, builder):
builder.add_hhea_field(self.key, self.value)
[docs] def asFea(self, indent=""):
fields = ("CaretOffset", "Ascender", "Descender", "LineGap")
keywords = dict([(x.lower(), x) for x in fields])
return "{} {};".format(keywords[self.key], self.value)
[docs]class VheaField(Statement):
def __init__(self, key, value, location=None):
Statement.__init__(self, location)
self.key = key
self.value = value
[docs] def build(self, builder):
builder.add_vhea_field(self.key, self.value)
[docs] def asFea(self, indent=""):
fields = ("VertTypoAscender", "VertTypoDescender", "VertTypoLineGap")
keywords = dict([(x.lower(), x) for x in fields])
return "{} {};".format(keywords[self.key], self.value)