fonttools 4.55.4__cp313-cp313-musllinux_1_2_aarch64.whl → 4.61.1__cp313-cp313-musllinux_1_2_aarch64.whl

fontTools/voltLib/voltToFea.py

@@ -46,6 +46,7 @@ Limitations
 import logging
 import re
 from io import StringIO
+from graphlib import TopologicalSorter
 
 from fontTools.feaLib import ast
 from fontTools.ttLib import TTFont, TTLibError
@@ -57,32 +58,39 @@ log = logging.getLogger("fontTools.voltLib.voltToFea")
 TABLES = ["GDEF", "GSUB", "GPOS"]
 
 
-class MarkClassDefinition(ast.MarkClassDefinition):
-    def asFea(self, indent=""):
-        res = ""
-        if not getattr(self, "used", False):
-            res += "#"
-        res += ast.MarkClassDefinition.asFea(self, indent)
-        return res
-
-
-# For sorting voltLib.ast.GlyphDefinition, see its use below.
-class Group:
-    def __init__(self, group):
-        self.name = group.name.lower()
-        self.groups = [
-            x.group.lower() for x in group.enum.enum if isinstance(x, VAst.GroupName)
+def _flatten_group(group):
+    ret = []
+    if isinstance(group, (tuple, list)):
+        for item in group:
+            ret.extend(_flatten_group(item))
+    elif hasattr(group, "enum"):
+        ret.extend(_flatten_group(group.enum))
+    else:
+        ret.append(group)
+    return ret
+
+
+# Topologically sort of group definitions to ensure that all groups are defined
+# before they are referenced. This is necessary because FEA requires it but
+# VOLT does not, see below.
+def sort_groups(groups):
+    group_map = {group.name.lower(): group for group in groups}
+    graph = {
+        group.name.lower(): [
+            x.group.lower()
+            for x in _flatten_group(group)
+            if isinstance(x, VAst.GroupName)
         ]
+        for group in groups
+    }
+    sorter = TopologicalSorter(graph)
+    return [group_map[name] for name in sorter.static_order()]
+
 
-    def __lt__(self, other):
-        if self.name in other.groups:
-            return True
-        if other.name in self.groups:
-            return False
-        if self.groups and not other.groups:
-            return False
-        if not self.groups and other.groups:
-            return True
+class Lookup(ast.LookupBlock):
+    def __init__(self, name, use_extension=False, location=None):
+        super().__init__(name, use_extension, location)
+        self.chained = []
 
 
 class VoltToFea:
@@ -90,7 +98,10 @@ class VoltToFea:
     _NOT_CLASS_NAME_RE = re.compile(r"[^A-Za-z_0-9.\-]")
 
     def __init__(self, file_or_path, font=None):
-        self._file_or_path = file_or_path
+        if isinstance(file_or_path, VAst.VoltFile):
+            self._doc, self._file_or_path = file_or_path, None
+        else:
+            self._doc, self._file_or_path = None, file_or_path
         self._font = font
 
         self._glyph_map = {}
@@ -128,23 +139,26 @@ class VoltToFea:
             self._class_names[name] = res
         return self._class_names[name]
 
-    def _collectStatements(self, doc, tables):
+    def _collectStatements(self, doc, tables, ignore_unsupported_settings=False):
+        # Collect glyph difinitions first, as we need them to map VOLT glyph names to font glyph name.
+        for statement in doc.statements:
+            if isinstance(statement, VAst.GlyphDefinition):
+                self._glyphDefinition(statement)
+
         # Collect and sort group definitions first, to make sure a group
         # definition that references other groups comes after them since VOLT
         # does not enforce such ordering, and feature file require it.
         groups = [s for s in doc.statements if isinstance(s, VAst.GroupDefinition)]
-        for statement in sorted(groups, key=lambda x: Group(x)):
-            self._groupDefinition(statement)
+        for group in sort_groups(groups):
+            self._groupDefinition(group)
 
         for statement in doc.statements:
-            if isinstance(statement, VAst.GlyphDefinition):
-                self._glyphDefinition(statement)
-            elif isinstance(statement, VAst.AnchorDefinition):
+            if isinstance(statement, VAst.AnchorDefinition):
                 if "GPOS" in tables:
                     self._anchorDefinition(statement)
             elif isinstance(statement, VAst.SettingDefinition):
-                self._settingDefinition(statement)
-            elif isinstance(statement, VAst.GroupDefinition):
+                self._settingDefinition(statement, ignore_unsupported_settings)
+            elif isinstance(statement, (VAst.GlyphDefinition, VAst.GroupDefinition)):
                 pass  # Handled above
             elif isinstance(statement, VAst.ScriptDefinition):
                 self._scriptDefinition(statement)
@@ -176,35 +190,57 @@ class VoltToFea:
         if self._lookups:
             statements.append(ast.Comment("\n# Lookups"))
             for lookup in self._lookups.values():
-                statements.extend(getattr(lookup, "targets", []))
+                statements.extend(lookup.chained)
                 statements.append(lookup)
 
         # Prune features
         features = self._features.copy()
-        for ftag in features:
-            scripts = features[ftag]
-            for stag in scripts:
-                langs = scripts[stag]
-                for ltag in langs:
-                    langs[ltag] = [l for l in langs[ltag] if l.lower() in self._lookups]
-                scripts[stag] = {t: l for t, l in langs.items() if l}
-            features[ftag] = {t: s for t, s in scripts.items() if s}
+        for feature_tag in features:
+            scripts = features[feature_tag]
+            for script_tag in scripts:
+                langs = scripts[script_tag]
+                for language_tag in langs:
+                    langs[language_tag] = [
+                        l for l in langs[language_tag] if l.lower() in self._lookups
+                    ]
+                scripts[script_tag] = {t: l for t, l in langs.items() if l}
+            features[feature_tag] = {t: s for t, s in scripts.items() if s}
         features = {t: f for t, f in features.items() if f}
 
         if features:
             statements.append(ast.Comment("# Features"))
-            for ftag, scripts in features.items():
-                feature = ast.FeatureBlock(ftag)
-                stags = sorted(scripts, key=lambda k: 0 if k == "DFLT" else 1)
-                for stag in stags:
-                    feature.statements.append(ast.ScriptStatement(stag))
-                    ltags = sorted(scripts[stag], key=lambda k: 0 if k == "dflt" else 1)
-                    for ltag in ltags:
-                        include_default = True if ltag == "dflt" else False
-                        feature.statements.append(
-                            ast.LanguageStatement(ltag, include_default=include_default)
+            for feature_tag, scripts in features.items():
+                feature = ast.FeatureBlock(feature_tag)
+                script_tags = sorted(scripts, key=lambda k: 0 if k == "DFLT" else 1)
+                if feature_tag == "aalt" and len(script_tags) > 1:
+                    log.warning(
+                        "FEA syntax does not allow script statements in 'aalt' feature, "
+                        "so only lookups from the first script will be included."
+                    )
+                    script_tags = script_tags[:1]
+                for script_tag in script_tags:
+                    if feature_tag != "aalt":
+                        feature.statements.append(ast.ScriptStatement(script_tag))
+                    language_tags = sorted(
+                        scripts[script_tag],
+                        key=lambda k: 0 if k == "dflt" else 1,
+                    )
+                    if feature_tag == "aalt" and len(language_tags) > 1:
+                        log.warning(
+                            "FEA syntax does not allow language statements in 'aalt' feature, "
+                            "so only lookups from the first language will be included."
                         )
-                        for name in scripts[stag][ltag]:
+                        language_tags = language_tags[:1]
+                    for language_tag in language_tags:
+                        if feature_tag != "aalt":
+                            include_default = True if language_tag == "dflt" else False
+                            feature.statements.append(
+                                ast.LanguageStatement(
+                                    language_tag.ljust(4),
+                                    include_default=include_default,
+                                )
+                            )
+                        for name in scripts[script_tag][language_tag]:
                             lookup = self._lookups[name.lower()]
                             lookupref = ast.LookupReferenceStatement(lookup)
                             feature.statements.append(lookupref)
@@ -227,15 +263,17 @@ class VoltToFea:
 
         return doc
 
-    def convert(self, tables=None):
-        doc = VoltParser(self._file_or_path).parse()
+    def convert(self, tables=None, ignore_unsupported_settings=False):
+        if self._doc is None:
+            self._doc = VoltParser(self._file_or_path).parse()
+        doc = self._doc
 
         if tables is None:
             tables = TABLES
         if self._font is not None:
             self._glyph_order = self._font.getGlyphOrder()
 
-        self._collectStatements(doc, tables)
+        self._collectStatements(doc, tables, ignore_unsupported_settings)
         fea = self._buildFeatureFile(tables)
         return fea.asFea()
 
@@ -253,7 +291,13 @@ class VoltToFea:
             name = group
         return ast.GlyphClassName(self._glyphclasses[name.lower()])
 
-    def _coverage(self, coverage):
+    def _glyphSet(self, item):
+        return [
+            (self._glyphName(x) if isinstance(x, (str, VAst.GlyphName)) else x)
+            for x in item.glyphSet()
+        ]
+
+    def _coverage(self, coverage, flatten=False):
         items = []
         for item in coverage:
             if isinstance(item, VAst.GlyphName):
@@ -261,31 +305,38 @@ class VoltToFea:
             elif isinstance(item, VAst.GroupName):
                 items.append(self._groupName(item))
             elif isinstance(item, VAst.Enum):
-                items.append(self._enum(item))
+                item = self._coverage(item.enum, flatten=True)
+                if flatten:
+                    items.extend(item)
+                else:
+                    items.append(ast.GlyphClass(item))
             elif isinstance(item, VAst.Range):
-                items.append((item.start, item.end))
+                item = self._glyphSet(item)
+                if flatten:
+                    items.extend(item)
+                else:
+                    items.append(ast.GlyphClass(item))
             else:
                 raise NotImplementedError(item)
         return items
 
-    def _enum(self, enum):
-        return ast.GlyphClass(self._coverage(enum.enum))
-
     def _context(self, context):
         out = []
         for item in context:
-            coverage = self._coverage(item)
-            if not isinstance(coverage, (tuple, list)):
-                coverage = [coverage]
-            out.extend(coverage)
+            coverage = self._coverage(item, flatten=True)
+            if len(coverage) > 1:
+                coverage = ast.GlyphClass(coverage)
+            else:
+                coverage = coverage[0]
+            out.append(coverage)
         return out
 
     def _groupDefinition(self, group):
         name = self._className(group.name)
-        glyphs = self._enum(group.enum)
-        glyphclass = ast.GlyphClassDefinition(name, glyphs)
-
-        self._glyphclasses[group.name.lower()] = glyphclass
+        glyphs = self._coverage(group.enum.enum, flatten=True)
+        glyphclass = ast.GlyphClass(glyphs)
+        classdef = ast.GlyphClassDefinition(name, glyphclass)
+        self._glyphclasses[group.name.lower()] = classdef
 
     def _glyphDefinition(self, glyph):
         try:
@@ -317,10 +368,10 @@ class VoltToFea:
                 assert ltag not in self._features[ftag][stag]
                 self._features[ftag][stag][ltag] = lookups.keys()
 
-    def _settingDefinition(self, setting):
+    def _settingDefinition(self, setting, ignore_unsupported=False):
         if setting.name.startswith("COMPILER_"):
             self._settings[setting.name] = setting.value
-        else:
+        elif not ignore_unsupported:
             log.warning(f"Unsupported setting ignored: {setting.name}")
 
     def _adjustment(self, adjustment):
@@ -358,18 +409,15 @@ class VoltToFea:
         glyphname = anchordef.glyph_name
         anchor = self._anchor(anchordef.pos)
 
+        if glyphname not in self._anchors:
+            self._anchors[glyphname] = {}
         if anchorname.startswith("MARK_"):
-            name = "_".join(anchorname.split("_")[1:])
-            markclass = ast.MarkClass(self._className(name))
-            glyph = self._glyphName(glyphname)
-            markdef = MarkClassDefinition(markclass, anchor, glyph)
-            self._markclasses[(glyphname, anchorname)] = markdef
+            anchorname = anchorname[:5] + anchorname[5:].lower()
         else:
-            if glyphname not in self._anchors:
-                self._anchors[glyphname] = {}
-            if anchorname not in self._anchors[glyphname]:
-                self._anchors[glyphname][anchorname] = {}
-            self._anchors[glyphname][anchorname][anchordef.component] = anchor
+            anchorname = anchorname.lower()
+        if anchorname not in self._anchors[glyphname]:
+            self._anchors[glyphname][anchorname] = {}
+        self._anchors[glyphname][anchorname][anchordef.component] = anchor
 
     def _gposLookup(self, lookup, fealookup):
         statements = fealookup.statements
@@ -408,43 +456,66 @@ class VoltToFea:
                 )
         elif isinstance(pos, VAst.PositionAttachDefinition):
             anchors = {}
-            for marks, classname in pos.coverage_to:
-                for mark in marks:
-                    # Set actually used mark classes. Basically a hack to get
-                    # around the feature file syntax limitation of making mark
-                    # classes global and not allowing mark positioning to
-                    # specify mark coverage.
-                    for name in mark.glyphSet():
-                        key = (name, "MARK_" + classname)
-                        self._markclasses[key].used = True
-                markclass = ast.MarkClass(self._className(classname))
+            allmarks = set()
+            for coverage, anchorname in pos.coverage_to:
+                # In feature files mark classes are global, but in VOLT they
+                # are defined per-lookup. If we output mark class definitions
+                # for all marks that use a given anchor, we might end up with a
+                # mark used in two different classes in the same lookup, which
+                # is causes feature file compilation error.
+                # At the expense of uglier feature code, we make the mark class
+                # name by appending the current lookup name not the anchor
+                # name, and output mark class definitions only for marks used
+                # in this lookup.
+                classname = self._className(f"{anchorname}.{lookup.name}")
+                markclass = ast.MarkClass(classname)
+
+                # Anchor names are case-insensitive in VOLT
+                anchorname = anchorname.lower()
+
+                # We might still end in marks used in two different anchor
+                # classes, so we filter out already used marks.
+                marks = set()
+                for mark in coverage:
+                    marks.update(mark.glyphSet())
+                if not marks.isdisjoint(allmarks):
+                    marks.difference_update(allmarks)
+                    if not marks:
+                        continue
+                allmarks.update(marks)
+
+                for glyphname in marks:
+                    glyph = self._glyphName(glyphname)
+                    anchor = self._anchors[glyphname][f"MARK_{anchorname}"][1]
+                    markdef = ast.MarkClassDefinition(markclass, anchor, glyph)
+                    self._markclasses[(glyphname, classname)] = markdef
+
                 for base in pos.coverage:
                     for name in base.glyphSet():
                         if name not in anchors:
                             anchors[name] = []
-                        if classname not in anchors[name]:
-                            anchors[name].append(classname)
+                        if (anchorname, classname) not in anchors[name]:
+                            anchors[name].append((anchorname, classname))
 
+            is_ligature = all(n in self._ligatures for n in anchors)
+            is_mark = all(n in self._marks for n in anchors)
             for name in anchors:
                 components = 1
-                if name in self._ligatures:
+                if is_ligature:
                     components = self._ligatures[name]
 
-                marks = []
-                for mark in anchors[name]:
-                    markclass = ast.MarkClass(self._className(mark))
+                marks = [[] for _ in range(components)]
+                for mark, classname in anchors[name]:
+                    markclass = ast.MarkClass(classname)
                     for component in range(1, components + 1):
-                        if len(marks) < component:
-                            marks.append([])
-                        anchor = None
                         if component in self._anchors[name][mark]:
                             anchor = self._anchors[name][mark][component]
-                        marks[component - 1].append((anchor, markclass))
+                            marks[component - 1].append((anchor, markclass))
 
                 base = self._glyphName(name)
-                if name in self._marks:
+                if is_mark:
                     mark = ast.MarkMarkPosStatement(base, marks[0])
-                elif name in self._ligatures:
+                elif is_ligature:
                     mark = ast.MarkLigPosStatement(base, marks)
                 else:
                     mark = ast.MarkBasePosStatement(base, marks[0])
@@ -481,13 +552,9 @@ class VoltToFea:
         else:
             raise NotImplementedError(pos)
 
-    def _gposContextLookup(
-        self, lookup, prefix, suffix, ignore, fealookup, targetlookup
-    ):
+    def _gposContextLookup(self, lookup, prefix, suffix, ignore, fealookup, chained):
         statements = fealookup.statements
 
-        assert not lookup.reversal
-
         pos = lookup.pos
         if isinstance(pos, VAst.PositionAdjustPairDefinition):
             for (idx1, idx2), (pos1, pos2) in pos.adjust_pair.items():
@@ -500,79 +567,181 @@ class VoltToFea:
                 if ignore:
                     statement = ast.IgnorePosStatement([(prefix, glyphs, suffix)])
                 else:
-                    lookups = (targetlookup, targetlookup)
                     statement = ast.ChainContextPosStatement(
-                        prefix, glyphs, suffix, lookups
+                        prefix, glyphs, suffix, [chained, chained]
                     )
                 statements.append(statement)
         elif isinstance(pos, VAst.PositionAdjustSingleDefinition):
             glyphs = [ast.GlyphClass()]
-            for a, b in pos.adjust_single:
-                glyph = self._coverage(a)
-                glyphs[0].extend(glyph)
+            for a, _ in pos.adjust_single:
+                glyphs[0].extend(self._coverage(a, flatten=True))
 
             if ignore:
                 statement = ast.IgnorePosStatement([(prefix, glyphs, suffix)])
             else:
                 statement = ast.ChainContextPosStatement(
-                    prefix, glyphs, suffix, [targetlookup]
+                    prefix, glyphs, suffix, [chained]
                 )
             statements.append(statement)
         elif isinstance(pos, VAst.PositionAttachDefinition):
             glyphs = [ast.GlyphClass()]
             for coverage, _ in pos.coverage_to:
-                glyphs[0].extend(self._coverage(coverage))
+                glyphs[0].extend(self._coverage(coverage, flatten=True))
 
             if ignore:
                 statement = ast.IgnorePosStatement([(prefix, glyphs, suffix)])
             else:
                 statement = ast.ChainContextPosStatement(
-                    prefix, glyphs, suffix, [targetlookup]
+                    prefix, glyphs, suffix, [chained]
                 )
             statements.append(statement)
         else:
             raise NotImplementedError(pos)
 
-    def _gsubLookup(self, lookup, prefix, suffix, ignore, chain, fealookup):
+    def _gsubLookup(self, lookup, fealookup):
         statements = fealookup.statements
 
         sub = lookup.sub
+
+        # Alternate substitutions are represented by adding multiple
+        # substitutions for the same glyph, so we need to collect them into one
+        # to many mapping.
+        if isinstance(sub, VAst.SubstitutionAlternateDefinition):
+            alternates = {}
+            for key, val in sub.mapping.items():
+                if not key or not val:
+                    path, line, column = sub.location
+                    log.warning(f"{path}:{line}:{column}: Ignoring empty substitution")
+                    continue
+                glyphs = self._coverage(key)
+                replacements = self._coverage(val)
+                assert len(glyphs) == 1
+                for src_glyph, repl_glyph in zip(
+                    glyphs[0].glyphSet(), replacements[0].glyphSet()
+                ):
+                    alternates.setdefault(str(self._glyphName(src_glyph)), []).append(
+                        str(self._glyphName(repl_glyph))
+                    )
+
+            for glyph, replacements in alternates.items():
+                statement = ast.AlternateSubstStatement(
+                    [], glyph, [], ast.GlyphClass(replacements)
+                )
+                statements.append(statement)
+            return
+
         for key, val in sub.mapping.items():
             if not key or not val:
                 path, line, column = sub.location
                 log.warning(f"{path}:{line}:{column}: Ignoring empty substitution")
                 continue
-            statement = None
             glyphs = self._coverage(key)
             replacements = self._coverage(val)
-            if ignore:
-                chain_context = (prefix, glyphs, suffix)
-                statement = ast.IgnoreSubstStatement([chain_context])
-            elif isinstance(sub, VAst.SubstitutionSingleDefinition):
+            if isinstance(sub, VAst.SubstitutionSingleDefinition):
                 assert len(glyphs) == 1
                 assert len(replacements) == 1
-                statement = ast.SingleSubstStatement(
-                    glyphs, replacements, prefix, suffix, chain
+                statements.append(
+                    ast.SingleSubstStatement(glyphs, replacements, [], [], False)
                 )
             elif isinstance(sub, VAst.SubstitutionReverseChainingSingleDefinition):
-                assert len(glyphs) == 1
-                assert len(replacements) == 1
-                statement = ast.ReverseChainSingleSubstStatement(
-                    prefix, suffix, glyphs, replacements
-                )
+                # This is handled in gsubContextLookup()
+                pass
             elif isinstance(sub, VAst.SubstitutionMultipleDefinition):
                 assert len(glyphs) == 1
-                statement = ast.MultipleSubstStatement(
-                    prefix, glyphs[0], suffix, replacements, chain
+                statements.append(
+                    ast.MultipleSubstStatement([], glyphs[0], [], replacements)
                 )
             elif isinstance(sub, VAst.SubstitutionLigatureDefinition):
                 assert len(replacements) == 1
                 statement = ast.LigatureSubstStatement(
-                    prefix, glyphs, suffix, replacements[0], chain
+                    [], glyphs, [], replacements[0], False
                 )
+
+                # If any of the input glyphs is a group, we need to
+                # explode the substitution into multiple ligature substitutions
+                # since feature file syntax does not support classes in
+                # ligature substitutions.
+                n = max(len(x.glyphSet()) for x in glyphs)
+                if n > 1:
+                    # All input should either be groups of the same length or single glyphs
+                    assert all(len(x.glyphSet()) in (n, 1) for x in glyphs)
+                    glyphs = [x.glyphSet() for x in glyphs]
+                    glyphs = [([x[0]] * n if len(x) == 1 else x) for x in glyphs]
+
+                    # In this case ligature replacements must be a group of the same length
+                    # as the input groups, or a single glyph. VOLT
+                    # allows the replacement glyphs to be longer and truncates them.
+                    # So well allow that and zip() below will do the truncation
+                    # for us.
+                    replacement = replacements[0].glyphSet()
+                    if len(replacement) == 1:
+                        replacement = [replacement[0]] * n
+                    assert len(replacement) >= n
+
+                    # Add the unexploded statement commented out for reference.
+                    statements.append(ast.Comment(f"# {statement}"))
+
+                    for zipped in zip(*glyphs, replacement):
+                        zipped = [self._glyphName(x) for x in zipped]
+                        statements.append(
+                            ast.LigatureSubstStatement(
+                                [], zipped[:-1], [], zipped[-1], False
+                            )
+                        )
+                else:
+                    statements.append(statement)
             else:
                 raise NotImplementedError(sub)
-            statements.append(statement)
+
+    def _gsubContextLookup(self, lookup, prefix, suffix, ignore, fealookup, chained):
+        statements = fealookup.statements
+
+        sub = lookup.sub
+
+        if isinstance(sub, VAst.SubstitutionReverseChainingSingleDefinition):
+            # Reverse substitutions is a special case, it can’t use chained lookups.
+            for key, val in sub.mapping.items():
+                if not key or not val:
+                    path, line, column = sub.location
+                    log.warning(f"{path}:{line}:{column}: Ignoring empty substitution")
+                    continue
+                glyphs = self._coverage(key)
+                replacements = self._coverage(val)
+                statements.append(
+                    ast.ReverseChainSingleSubstStatement(
+                        prefix, suffix, glyphs, replacements
+                    )
+                )
+            fealookup.chained = []
+            return
+
+        if not isinstance(
+            sub,
+            (
+                VAst.SubstitutionSingleDefinition,
+                VAst.SubstitutionMultipleDefinition,
+                VAst.SubstitutionLigatureDefinition,
+                VAst.SubstitutionAlternateDefinition,
+            ),
+        ):
+            raise NotImplementedError(type(sub))
+
+        glyphs = []
+        for key, val in sub.mapping.items():
+            if not key or not val:
+                path, line, column = sub.location
+                log.warning(f"{path}:{line}:{column}: Ignoring empty substitution")
+                continue
+            glyphs.extend(self._coverage(key, flatten=True))
+
+        if len(glyphs) > 1:
+            glyphs = [ast.GlyphClass(glyphs)]
+        if ignore:
+            statements.append(ast.IgnoreSubstStatement([(prefix, glyphs, suffix)]))
+        else:
+            statements.append(
+                ast.ChainContextSubstStatement(prefix, glyphs, suffix, [chained])
+            )
 
     def _lookupDefinition(self, lookup):
         mark_attachement = None
@@ -598,13 +767,21 @@ class VoltToFea:
             lookupflags = ast.LookupFlagStatement(
                 flags, mark_attachement, mark_filtering
             )
+
+        use_extension = False
+        if self._settings.get("COMPILER_USEEXTENSIONLOOKUPS"):
+            use_extension = True
+
         if "\\" in lookup.name:
             # Merge sub lookups as subtables (lookups named “base\sub”),
             # makeotf/feaLib will issue a warning and ignore the subtable
             # statement if it is not a pairpos lookup, though.
             name = lookup.name.split("\\")[0]
             if name.lower() not in self._lookups:
-                fealookup = ast.LookupBlock(self._lookupName(name))
+                fealookup = Lookup(
+                    self._lookupName(name),
+                    use_extension=use_extension,
+                )
                 if lookupflags is not None:
                     fealookup.statements.append(lookupflags)
                 fealookup.statements.append(ast.Comment("# " + lookup.name))
@@ -614,7 +791,10 @@ class VoltToFea:
                 fealookup.statements.append(ast.Comment("# " + lookup.name))
             self._lookups[name.lower()] = fealookup
         else:
-            fealookup = ast.LookupBlock(self._lookupName(lookup.name))
+            fealookup = Lookup(
+                self._lookupName(lookup.name),
+                use_extension=use_extension,
+            )
             if lookupflags is not None:
                 fealookup.statements.append(lookupflags)
             self._lookups[lookup.name.lower()] = fealookup
@@ -623,39 +803,40 @@ class VoltToFea:
             fealookup.statements.append(ast.Comment("# " + lookup.comments))
 
         contexts = []
-        if lookup.context:
-            for context in lookup.context:
-                prefix = self._context(context.left)
-                suffix = self._context(context.right)
-                ignore = context.ex_or_in == "EXCEPT_CONTEXT"
-                contexts.append([prefix, suffix, ignore, False])
-                # It seems that VOLT will create contextual substitution using
-                # only the input if there is no other contexts in this lookup.
-                if ignore and len(lookup.context) == 1:
-                    contexts.append([[], [], False, True])
-        else:
-            contexts.append([[], [], False, False])
-
-        targetlookup = None
-        for prefix, suffix, ignore, chain in contexts:
+        for context in lookup.context:
+            prefix = self._context(context.left)
+            suffix = self._context(context.right)
+            ignore = context.ex_or_in == "EXCEPT_CONTEXT"
+            contexts.append([prefix, suffix, ignore])
+            # It seems that VOLT will create contextual substitution using
+            # only the input if there is no other contexts in this lookup.
+            if ignore and len(lookup.context) == 1:
+                contexts.append([[], [], False])
+
+        if contexts:
+            chained = ast.LookupBlock(
+                self._lookupName(lookup.name + " chained"),
+                use_extension=use_extension,
+            )
+            fealookup.chained.append(chained)
             if lookup.sub is not None:
-                self._gsubLookup(lookup, prefix, suffix, ignore, chain, fealookup)
-
-            if lookup.pos is not None:
-                if self._settings.get("COMPILER_USEEXTENSIONLOOKUPS"):
-                    fealookup.use_extension = True
-                if prefix or suffix or chain or ignore:
-                    if not ignore and targetlookup is None:
-                        targetname = self._lookupName(lookup.name + " target")
-                        targetlookup = ast.LookupBlock(targetname)
-                        fealookup.targets = getattr(fealookup, "targets", [])
-                        fealookup.targets.append(targetlookup)
-                        self._gposLookup(lookup, targetlookup)
+                self._gsubLookup(lookup, chained)
+            elif lookup.pos is not None:
+                self._gposLookup(lookup, chained)
+            for prefix, suffix, ignore in contexts:
+                if lookup.sub is not None:
+                    self._gsubContextLookup(
+                        lookup, prefix, suffix, ignore, fealookup, chained
+                    )
+                elif lookup.pos is not None:
                     self._gposContextLookup(
-                        lookup, prefix, suffix, ignore, fealookup, targetlookup
+                        lookup, prefix, suffix, ignore, fealookup, chained
                     )
-                else:
-                    self._gposLookup(lookup, fealookup)
+        else:
+            if lookup.sub is not None:
+                self._gsubLookup(lookup, fealookup)
+            elif lookup.pos is not None:
+                self._gposLookup(lookup, fealookup)
 
 
 def main(args=None):