Source code for fontTools.feaLib.ast

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 Comment(Element): def __init__(self, text, location=None): super(Comment, self).__init__(location) self.text = text
[docs] def asFea(self, indent=""): return self.text
[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)