Adding upstream version 1.6.0.upstream/1.6.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 445 insertions, 0 deletions

diff --git a/lib/silfont/feax_ast.py b/lib/silfont/feax_ast.py
new file mode 100644
index 0000000..67d45b1
--- /dev/null
+++ b/lib/silfont/feax_ast.py
@@ -0,0 +1,445 @@
+import ast as pyast
+from fontTools.feaLib import ast
+from fontTools.feaLib.ast import asFea
+from fontTools.feaLib.error import FeatureLibError
+import re, math
+
+def asFea(g):
+    if hasattr(g, 'asClassFea'):
+        return g.asClassFea()
+    elif 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 ast.fea_keywords:
+        return "\\" + g
+    else:
+        return g
+
+ast.asFea = asFea
+SHIFT = ast.SHIFT
+
+def asLiteralFea(self, indent=""):
+    Element.mode = 'literal'
+    return self.asFea(indent=indent)
+    Element.mode = 'flat'
+
+ast.Element.asLiteralFea = asLiteralFea
+ast.Element.mode = 'flat'
+
+class ast_Comment(ast.Comment):
+    def __init__(self, text, location=None):
+        super(ast_Comment, self).__init__(text, location=location)
+        self.pretext = ""
+        self.posttext = ""
+
+    def asFea(self, indent=""):
+        return self.pretext + self.text + self.posttext
+
+class ast_MarkClass(ast.MarkClass):
+    # This is better fixed upstream in parser.parse_glyphclass_ to handle MarkClasses
+    def asClassFea(self, indent=""):
+        return "[" + " ".join(map(asFea, self.glyphs)) + "]"
+
+class ast_BaseClass(ast_MarkClass) :
+    def asFea(self, indent="") :
+        return "@" + self.name + " = [" + " ".join(map(asFea, self.glyphs.keys())) + "];"
+
+class ast_BaseClassDefinition(ast.MarkClassDefinition):
+    def asFea(self, indent="") :
+        # like base class asFea
+        return ("# " if self.mode != 'literal' else "") + \
+                "{}baseClass {} {} @{};".format(indent, self.glyphs.asFea(),
+                                               self.anchor.asFea(), self.markClass.name)
+
+class ast_MarkBasePosStatement(ast.MarkBasePosStatement):
+    def asFea(self, indent=""):
+        # handles members added by parse_position_base_ with feax syntax
+        if isinstance(self.base, ast.MarkClassName): # flattens pos @BASECLASS mark @MARKCLASS
+            res = ""
+            if self.mode == 'literal':
+                res += "pos base @{} ".format(self.base.markClass.name)
+                res += " ".join("mark @{}".format(m.name) for m in self.marks)
+                res += ";"
+            else:
+                for bcd in self.base.markClass.definitions:
+                    if res != "":
+                        res += "\n{}".format(indent)
+                    res += "pos base {} {}".format(bcd.glyphs.asFea(), bcd.anchor.asFea())
+                    res += "".join(" mark @{}".format(m.name) for m in self.marks)
+                    res += ";"
+        else: # like base class method
+            res = "pos base {}".format(self.base.asFea())
+            res += "".join(" {} mark @{}".format(a.asFea(), m.name) for a, m in self.marks)
+            res += ";"
+        return res
+
+    def build(self, builder) :
+        #TODO: do the right thing here (write to ttf?)
+        pass
+
+class ast_MarkMarkPosStatement(ast.MarkMarkPosStatement):
+    # super class __init__() for reference
+    # def __init__(self, location, baseMarks, marks):
+    #     Statement.__init__(self, location)
+    #     self.baseMarks, self.marks = baseMarks, marks
+
+    def asFea(self, indent=""):
+        # handles members added by parse_position_base_ with feax syntax
+        if isinstance(self.baseMarks, ast.MarkClassName): # flattens pos @MARKCLASS mark @MARKCLASS
+            res = ""
+            if self.mode == 'literal':
+                res += "pos mark @{} ".format(self.base.markClass.name)
+                res += " ".join("mark @{}".format(m.name) for m in self.marks)
+                res += ";"
+            else:
+                for mcd in self.baseMarks.markClass.definitions:
+                    if res != "":
+                        res += "\n{}".format(indent)
+                    res += "pos mark {} {}".format(mcd.glyphs.asFea(), mcd.anchor.asFea())
+                    for m in self.marks:
+                        res += " mark @{}".format(m.name)
+                    res += ";"
+        else: # like base class method
+            res = "pos mark {}".format(self.baseMarks.asFea())
+            for a, m in self.marks:
+                res += " {} mark @{}".format(a.asFea() if a else "<anchor NULL>", m.name)
+            res += ";"
+        return res
+
+    def build(self, builder):
+        # builder.add_mark_mark_pos(self.location, self.baseMarks.glyphSet(), self.marks)
+        #TODO: do the right thing
+        pass
+
+class ast_CursivePosStatement(ast.CursivePosStatement):
+    # super class __init__() for reference
+    # def __init__(self, location, glyphclass, entryAnchor, exitAnchor):
+    #     Statement.__init__(self, location)
+    #     self.glyphclass = glyphclass
+    #     self.entryAnchor, self.exitAnchor = entryAnchor, exitAnchor
+
+    def asFea(self, indent=""):
+        if isinstance(self.exitAnchor, ast.MarkClass): # pos cursive @BASE1 @BASE2
+            res = ""
+            if self.mode == 'literal':
+                res += "pos cursive @{} @{};".format(self.glyphclass.name, self.exitAnchor.name)
+            else:
+                allglyphs = set(self.glyphclass.glyphSet())
+                allglyphs.update(self.exitAnchor.glyphSet())
+                for g in sorted(allglyphs):
+                    entry = self.glyphclass.glyphs.get(g, None)
+                    exit = self.exitAnchor.glyphs.get(g, None)
+                    if res != "":
+                        res += "\n{}".format(indent)
+                    res += "pos cursive {} {} {};".format(g,
+                                (entry.anchor.asFea() if entry else "<anchor NULL>"),
+                                (exit.anchor.asFea() if exit else "<anchor NULL>"))
+        else:
+            res = super(ast_CursivePosStatement, self).asFea(indent)
+        return res
+
+    def build(self, builder) :
+        #TODO: do the right thing here (write to ttf?)
+        pass
+
+class ast_MarkLigPosStatement(ast.MarkLigPosStatement):
+    def __init__(self, ligatures, marks, location=None):
+        ast.MarkLigPosStatement.__init__(self, ligatures, marks, location)
+        self.classBased = False
+        for l in marks:
+            if l is not None:
+                for m in l:
+                    if m is not None and not isinstance(m[0], ast.Anchor):
+                        self.classBased = True
+                        break
+
+    def build(self, builder):
+        builder.add_mark_lig_pos(self.location, self.ligatures.glyphSet(), self.marks)
+
+    def asFea(self, indent=""):
+        if not self.classBased or self.mode == "literal":
+            return super(ast_MarkLigPosStatement, self).asFea(indent)
+
+        res = []
+        for g in self.ligatures.glyphSet():
+            comps = []
+            for l in self.marks:
+                onecomp = []
+                if l is not None and len(l):
+                    for a, m in l:
+                        if not isinstance(a, ast.Anchor):
+                            if g not in a.markClass.glyphs:
+                                continue
+                            left = a.markClass.glyphs[g].anchor.asFea()
+                        else:
+                            left = a.asFea()
+                        onecomp.append("{} mark @{}".format(left, m.name))
+                if not len(onecomp):
+                    onecomp = ["<anchor NULL>"]
+                comps.append(" ".join(onecomp))
+            res.append("pos ligature {} ".format(asFea(g)) + ("\n"+indent+SHIFT+"ligComponent ").join(comps))
+        return (";\n"+indent).join(res) + ";"
+
+#similar to ast.MultipleSubstStatement
+#one-to-many substitution, one glyph class is on LHS, multiple glyph classes may be on RHS
+# equivalent to generation of one stmt for each glyph in the LHS class
+# that's matched to corresponding glyphs in the RHS classes
+#prefix and suffx are for contextual lookups and do not need processing
+#replacement could contain multiple slots
+#TODO: below only supports one RHS class?
+class ast_MultipleSubstStatement(ast.Statement):
+    def __init__(self, prefix, glyph, suffix, replacement, forceChain, location=None):
+        ast.Statement.__init__(self, location)
+        self.prefix, self.glyph, self.suffix = prefix, glyph, suffix
+        self.replacement = replacement
+        self.forceChain = forceChain
+        lenglyphs = len(self.glyph.glyphSet())
+        for i, r in enumerate(self.replacement) :
+            if len(r.glyphSet()) == lenglyphs:
+                self.multindex = i #first RHS slot with a glyph class
+                break
+        else:
+            if lenglyphs > 1:
+                raise FeatureLibError("No replacement class is of the same length as the matching class",
+                                        location)
+            else:
+                self.multindex = 0;
+
+    def build(self, builder):
+        prefix = [p.glyphSet() for p in self.prefix]
+        suffix = [s.glyphSet() for s in self.suffix]
+        glyphs = self.glyph.glyphSet()
+        replacements = self.replacement[self.multindex].glyphSet()
+        lenglyphs = len(glyphs)
+        for i in range(max(lenglyphs, len(replacements))) :
+            builder.add_multiple_subst(
+                self.location, prefix, glyphs[i if lenglyphs > 1 else 0], suffix,
+                self.replacement[0:self.multindex] + [replacements[i]] + self.replacement[self.multindex+1:],
+                self.forceChain)
+
+    def asFea(self, indent=""):
+        res = ""
+        pres = (" ".join(map(asFea, self.prefix)) + " ") if len(self.prefix) else ""
+        sufs = (" " + " ".join(map(asFea, self.suffix))) if len(self.suffix) else ""
+        mark = "'" if len(self.prefix) or len(self.suffix) or self.forceChain else ""
+        if self.mode == 'literal':
+            res += "sub " + pres + self.glyph.asFea() + mark + sufs + " by "
+            res += " ".join(asFea(g) for g in self.replacement) + ";"
+            return res
+        glyphs = self.glyph.glyphSet()
+        replacements = self.replacement[self.multindex].glyphSet()
+        lenglyphs = len(glyphs)
+        count = max(lenglyphs, len(replacements))
+        for i in range(count) :
+            res += ("\n" + indent if i > 0 else "") + "sub " + pres
+            res += asFea(glyphs[i if lenglyphs > 1 else 0]) + mark + sufs
+            res += " by "
+            res += " ".join(asFea(g) for g in self.replacement[0:self.multindex] + [replacements[i]] + self.replacement[self.multindex+1:])
+            res += ";" 
+        return res
+
+
+# similar to ast.LigatureSubstStatement
+# many-to-one substitution, one glyph class is on RHS, multiple glyph classes may be on LHS
+# equivalent to generation of one stmt for each glyph in the RHS class
+# that's matched to corresponding glyphs in the LHS classes
+# it's unclear which LHS class should correspond to the RHS class
+# prefix and suffx are for contextual lookups and do not need processing
+# replacement could contain multiple slots
+#TODO: below only supports one LHS class?
+class ast_LigatureSubstStatement(ast.Statement):
+    def __init__(self, prefix, glyphs, suffix, replacement,
+                 forceChain, location=None):
+        ast.Statement.__init__(self, location)
+        self.prefix, self.glyphs, self.suffix = (prefix, glyphs, suffix)
+        self.replacement, self.forceChain = replacement, forceChain
+        lenreplace = len(self.replacement.glyphSet())
+        for i, g in enumerate(self.glyphs):
+            if len(g.glyphSet()) == lenreplace:
+                self.multindex = i #first LHS slot with a glyph class
+                break
+        else:
+            if lenreplace > 1:
+                raise FeatureLibError("No class matches replacement class length", location)
+            else:
+                self.multindex = 0
+
+    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]
+        replacements = self.replacement.glyphSet()
+        lenreplace = len(replacements.glyphSet())
+        glyphs = self.glyphs[self.multindex].glyphSet()
+        for i in range(max(len(glyphs), len(replacements))):
+            builder.add_ligature_subst(
+                self.location, prefix,
+                self.glyphs[:self.multindex] + glyphs[i] + self.glyphs[self.multindex+1:],
+                suffix, replacements[i if lenreplace > 1 else 0], self.forceChain)
+
+    def asFea(self, indent=""):
+        res = ""
+        pres = (" ".join(map(asFea, self.prefix)) + " ") if len(self.prefix) else ""
+        sufs = (" " + " ".join(map(asFea, self.suffix))) if len(self.suffix) else ""
+        mark = "'" if len(self.prefix) or len(self.suffix) or self.forceChain else ""
+        if self.mode == 'literal':
+            res += "sub " + pres + " ".join(asFea(g)+mark for g in self.glyphs) + sufs + " by "
+            res += self.replacements.asFea() + ";"
+            return res
+        glyphs = self.glyphs[self.multindex].glyphSet()
+        replacements = self.replacement.glyphSet()
+        lenreplace = len(replacements)
+        count = max(len(glyphs), len(replacements))
+        for i in range(count) :
+            res += ("\n" + indent if i > 0 else "") + "sub " + pres
+            res += " ".join(asFea(g)+mark for g in self.glyphs[:self.multindex] + [glyphs[i]] + self.glyphs[self.multindex+1:])
+            res += sufs + " by "
+            res += asFea(replacements[i if lenreplace > 1 else 0])
+            res += ";"
+        return res
+
+class ast_AlternateSubstStatement(ast.Statement):
+    def __init__(self, prefix, glyphs, suffix, replacements, location=None):
+        ast.Statement.__init__(self, location)
+        self.prefix, self.glyphs, self.suffix = (prefix, glyphs, suffix)
+        self.replacements = replacements
+
+    def build(self, builder):
+        prefix = [p.glyphSet() for p in self.prefix]
+        suffix = [s.glyphSet() for s in self.suffix]
+        l = len(self.glyphs.glyphSet())
+        for i, glyph in enumerate(self.glyphs.glyphSet()):
+            replacement = self.replacements.glyphSet()[i::l]
+            builder.add_alternate_subst(self.location, prefix, glyph, suffix,
+                                    replacement)
+
+    def asFea(self, indent=""):
+        res = ""
+        l = len(self.glyphs.glyphSet())
+        for i, glyph in enumerate(self.glyphs.glyphSet()):
+            if i > 0:
+                res += "\n" + indent
+            res += "sub "
+            if len(self.prefix) or len(self.suffix):
+                if len(self.prefix):
+                    res += " ".join(map(asFea, self.prefix)) + " "
+                res += asFea(glyph) + "'"    # even though we really only use 1
+                if len(self.suffix):
+                    res += " " + " ".join(map(asFea, self.suffix))
+            else:
+                res += asFea(glyph)
+            res += " from "
+            replacements = ast.GlyphClass(glyphs=self.replacements.glyphSet()[i::l], location=self.location)
+            res += asFea(replacements)
+            res += ";"
+        return res
+
+class ast_IfBlock(ast.Block):
+    def __init__(self, testfn, name, cond, location=None):
+        ast.Block.__init__(self, location=location)
+        self.testfn = testfn
+        self.name = name
+
+    def asFea(self, indent=""):
+        if self.mode == 'literal':
+            res = "{}if{}({}) {{".format(indent, name, cond)
+            res += ast.Block.asFea(self, indent=indent)
+            res += indent + "}\n"
+            return res
+        elif self.testfn():
+            return ast.Block.asFea(self, indent=indent)
+        else:
+            return ""
+
+
+class ast_DoSubStatement(ast.Statement):
+    def __init__(self, varnames, location=None):
+        ast.Statement.__init__(self, location=location)
+        self.names = varnames
+
+    def items(self, variables):
+        yield ((None, None),)
+
+class ast_DoForSubStatement(ast_DoSubStatement):
+    def __init__(self, varname, glyphs, location=None):
+        ast_DoSubStatement.__init__(self, [varname], location=location)
+        self.glyphs = glyphs.glyphSet()
+
+    def items(self, variables):
+        for g in self.glyphs:
+            yield((self.names[0], g),)
+
+def safeeval(exp):
+    # no dunders in attribute names
+    for n in pyast.walk(pyast.parse(exp)):
+        v = getattr(n, 'id', "")
+        # if v in ('_getiter_', '__next__'):
+        #     continue
+        if "__" in v:
+            return False
+    return True
+
+class ast_DoLetSubStatement(ast_DoSubStatement):
+    def __init__(self, varnames, expression, parser, location=None):
+        ast_DoSubStatement.__init__(self, varnames, location=location)
+        self.parser = parser
+        if not safeeval(expression):
+            expression='"Unsafe Expression"'
+        self.expr = expression
+
+    def items(self, variables):
+        gbls = dict(self.parser.fns, **variables)
+        try:
+            v = eval(self.expr, gbls)
+        except Exception as e:
+            raise FeatureLibError(str(e) + " in " + self.expr, self.location)
+        if self.names is None:      # in an if
+            yield((None, v),)
+        elif len(self.names) == 1:
+            yield((self.names[0], v),)
+        else:
+            yield(zip(self.names, list(v) + [None] * (len(self.names) - len(v))))
+
+class ast_DoIfSubStatement(ast_DoLetSubStatement):
+    def __init__(self, expression, parser, block, location=None):
+        ast_DoLetSubStatement.__init__(self, None, expression, parser, location=None)
+        self.block = block
+
+    def items(self, variables):
+        (_, v) = list(ast_DoLetSubStatement.items(self, variables))[0][0]
+        yield (None, (v if v else None),)
+
+class ast_KernPairsStatement(ast.Statement):
+    def __init__(self, kerninfo, location=None):
+        super(ast_KernPairsStatement, self).__init__(location)
+        self.kerninfo = kerninfo
+
+    def asFea(self, indent=""):
+        # return ("\n"+indent).join("pos {} {} {};".format(k1, round(v), k2) \
+        #           for k1, x in self.kerninfo.items() for k2, v in x.items())
+        coverage = set()
+        rules = dict()
+
+        # first sort into lists by type of rule
+        for k1, x in self.kerninfo.items():
+            for k2, v in x.items():
+                # Determine pair kern type, where:
+                #   'gg' = glyph-glyph, 'gc' = glyph-class', 'cg' = class-glyph, 'cc' = class-class
+                ruleType = 'gc'[k1[0]=='@'] + 'gc'[k2[0]=='@']
+                rules.setdefault(ruleType, list()).append([k1, round(v), k2])
+                # for glyph-glyph rules, make list of first glyphs:
+                if ruleType == 'gg':
+                    coverage.add(k1)
+
+        # Now assemble lines in order and convert gc rules to gg where possible:
+        res = []
+        for ruleType in filter(lambda x: x in rules, ('gg', 'gc', 'cg', 'cc')):
+            if ruleType != 'gc':
+                res.extend(['pos {} {} {};'.format(k1, v, k2) for k1,v,k2 in rules[ruleType]])
+            else:
+                res.extend(['enum pos {} {} {};'.format(k1, v, k2) for k1, v, k2 in rules[ruleType] if k1 not in coverage])
+                res.extend(['pos {} {} {};'.format(k1, v, k2) for k1, v, k2 in rules[ruleType] if k1 in coverage])
+
+        return ("\n"+indent).join(res)
+