Source code for fontTools.voltLib.ast

from fontTools.voltLib.error import VoltLibError
from typing import NamedTuple

[docs]class Pos(NamedTuple): adv: int dx: int dy: int adv_adjust_by: dict dx_adjust_by: dict dy_adjust_by: dict def __str__(self): res = ' POS' for attr in ('adv', 'dx', 'dy'): value = getattr(self, attr) if value is not None: res += f' {attr.upper()} {value}' adjust_by = getattr(self, f'{attr}_adjust_by', {}) for size, adjustment in adjust_by.items(): res += f' ADJUST_BY {adjustment} AT {size}' res += ' END_POS' return res
[docs]class Element(object): def __init__(self, location=None): self.location = location
[docs] def build(self, builder): pass
def __str__(self): raise NotImplementedError
[docs]class Statement(Element): pass
[docs]class Expression(Element): pass
[docs]class VoltFile(Statement): def __init__(self): Statement.__init__(self, location=None) self.statements = []
[docs] def build(self, builder): for s in self.statements:
def __str__(self): return '\n' + '\n'.join(str(s) for s in self.statements) + ' END\n'
[docs]class GlyphDefinition(Statement): def __init__(self, name, gid, gunicode, gtype, components, location=None): Statement.__init__(self, location) = name = gid self.unicode = gunicode self.type = gtype self.components = components def __str__(self): res = f'DEF_GLYPH "{}" ID {}' if self.unicode is not None: if len(self.unicode) > 1: unicodes = ','.join(f'U+{u:04X}' for u in self.unicode) res += f' UNICODEVALUES "{unicodes}"' else: res += f' UNICODE {self.unicode[0]}' if self.type is not None: res += f' TYPE {self.type}' if self.components is not None: res += f' COMPONENTS {self.components}' res += ' END_GLYPH' return res
[docs]class GroupDefinition(Statement): def __init__(self, name, enum, location=None): Statement.__init__(self, location) = name self.enum = enum self.glyphs_ = None
[docs] def glyphSet(self, groups=None): if groups is not None and in groups: raise VoltLibError( 'Group "%s" contains itself.' % (, self.location) if self.glyphs_ is None: if groups is None: groups = set({}) else: groups.add( self.glyphs_ = self.enum.glyphSet(groups) return self.glyphs_
def __str__(self): enum = self.enum and str(self.enum) or '' return f'DEF_GROUP "{}"\n{enum}\nEND_GROUP'
[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,)
def __str__(self): return f' GLYPH "{self.glyph}"'
[docs]class Enum(Expression): """An enum""" def __init__(self, enum, location=None): Expression.__init__(self, location) self.enum = enum def __iter__(self): for e in self.glyphSet(): yield e
[docs] def glyphSet(self, groups=None): glyphs = [] for element in self.enum: if isinstance(element, (GroupName, Enum)): glyphs.extend(element.glyphSet(groups)) else: glyphs.extend(element.glyphSet()) return tuple(glyphs)
def __str__(self): enum = ''.join(str(e) for e in self.enum) return f' ENUM{enum} END_ENUM'
[docs]class GroupName(Expression): """A glyph group""" def __init__(self, group, parser, location=None): Expression.__init__(self, location) = group self.parser_ = parser
[docs] def glyphSet(self, groups=None): group = self.parser_.resolve_group( if group is not None: self.glyphs_ = group.glyphSet(groups) return self.glyphs_ else: raise VoltLibError( 'Group "%s" is used but undefined.' % (, self.location)
def __str__(self): return f' GROUP "{}"'
[docs]class Range(Expression): """A glyph range""" def __init__(self, start, end, parser, location=None): Expression.__init__(self, location) self.start = start self.end = end self.parser = parser
[docs] def glyphSet(self): return tuple(self.parser.glyph_range(self.start, self.end))
def __str__(self): return f' RANGE "{self.start}" TO "{self.end}"'
[docs]class ScriptDefinition(Statement): def __init__(self, name, tag, langs, location=None): Statement.__init__(self, location) = name self.tag = tag self.langs = langs def __str__(self): res = 'DEF_SCRIPT' if is not None: res += f' NAME "{}"' res += f' TAG "{self.tag}"\n\n' for lang in self.langs: res += f'{lang}' res += 'END_SCRIPT' return res
[docs]class LangSysDefinition(Statement): def __init__(self, name, tag, features, location=None): Statement.__init__(self, location) = name self.tag = tag self.features = features def __str__(self): res = 'DEF_LANGSYS' if is not None: res += f' NAME "{}"' res += f' TAG "{self.tag}"\n\n' for feature in self.features: res += f'{feature}' res += 'END_LANGSYS\n' return res
[docs]class FeatureDefinition(Statement): def __init__(self, name, tag, lookups, location=None): Statement.__init__(self, location) = name self.tag = tag self.lookups = lookups def __str__(self): res = f'DEF_FEATURE NAME "{}" TAG "{self.tag}"\n' res += ' ' + ' '.join(f'LOOKUP "{l}"' for l in self.lookups) + '\n' res += 'END_FEATURE\n' return res
[docs]class LookupDefinition(Statement): def __init__(self, name, process_base, process_marks, mark_glyph_set, direction, reversal, comments, context, sub, pos, location=None): Statement.__init__(self, location) = name self.process_base = process_base self.process_marks = process_marks self.mark_glyph_set = mark_glyph_set self.direction = direction self.reversal = reversal self.comments = comments self.context = context self.sub = sub self.pos = pos def __str__(self): res = f'DEF_LOOKUP "{}"' res += f' {self.process_base and "PROCESS_BASE" or "SKIP_BASE"}' if self.process_marks: res += ' PROCESS_MARKS ' if self.mark_glyph_set: res += f'MARK_GLYPH_SET "{self.mark_glyph_set}"' elif isinstance(self.process_marks, str): res += f'"{self.process_marks}"' else: res += 'ALL' else: res += ' SKIP_MARKS' if self.direction is not None: res += f' DIRECTION {self.direction}' if self.reversal: res += ' REVERSAL' if self.comments is not None: comments = self.comments.replace('\n', r'\n') res += f'\nCOMMENTS "{comments}"' if self.context: res += '\n' + '\n'.join(str(c) for c in self.context) else: res += '\nIN_CONTEXT\nEND_CONTEXT' if self.sub: res += f'\n{self.sub}' if self.pos: res += f'\n{self.pos}' return res
[docs]class SubstitutionDefinition(Statement): def __init__(self, mapping, location=None): Statement.__init__(self, location) self.mapping = mapping def __str__(self): res = 'AS_SUBSTITUTION\n' for src, dst in self.mapping.items(): src = ''.join(str(s) for s in src) dst = ''.join(str(d) for d in dst) res += f'SUB{src}\nWITH{dst}\nEND_SUB\n' res += 'END_SUBSTITUTION' return res
[docs]class SubstitutionSingleDefinition(SubstitutionDefinition): pass
[docs]class SubstitutionMultipleDefinition(SubstitutionDefinition): pass
[docs]class SubstitutionLigatureDefinition(SubstitutionDefinition): pass
[docs]class SubstitutionReverseChainingSingleDefinition(SubstitutionDefinition): pass
[docs]class PositionAttachDefinition(Statement): def __init__(self, coverage, coverage_to, location=None): Statement.__init__(self, location) self.coverage = coverage self.coverage_to = coverage_to def __str__(self): coverage = ''.join(str(c) for c in self.coverage) res = f'AS_POSITION\nATTACH{coverage}\nTO' for coverage, anchor in self.coverage_to: coverage = ''.join(str(c) for c in coverage) res += f'{coverage} AT ANCHOR "{anchor}"' res += '\nEND_ATTACH\nEND_POSITION' return res
[docs]class PositionAttachCursiveDefinition(Statement): def __init__(self, coverages_exit, coverages_enter, location=None): Statement.__init__(self, location) self.coverages_exit = coverages_exit self.coverages_enter = coverages_enter def __str__(self): res = 'AS_POSITION\nATTACH_CURSIVE' for coverage in self.coverages_exit: coverage = ''.join(str(c) for c in coverage) res += f'\nEXIT {coverage}' for coverage in self.coverages_enter: coverage = ''.join(str(c) for c in coverage) res += f'\nENTER {coverage}' res += '\nEND_ATTACH\nEND_POSITION' return res
[docs]class PositionAdjustPairDefinition(Statement): def __init__(self, coverages_1, coverages_2, adjust_pair, location=None): Statement.__init__(self, location) self.coverages_1 = coverages_1 self.coverages_2 = coverages_2 self.adjust_pair = adjust_pair def __str__(self): res = 'AS_POSITION\nADJUST_PAIR\n' for coverage in self.coverages_1: coverage = ' '.join(str(c) for c in coverage) res += f' FIRST {coverage}' res += '\n' for coverage in self.coverages_2: coverage = ' '.join(str(c) for c in coverage) res += f' SECOND {coverage}' res += '\n' for (id_1, id_2), (pos_1, pos_2) in self.adjust_pair.items(): res += f' {id_1} {id_2} BY{pos_1}{pos_2}\n' res += '\nEND_ADJUST\nEND_POSITION' return res
[docs]class PositionAdjustSingleDefinition(Statement): def __init__(self, adjust_single, location=None): Statement.__init__(self, location) self.adjust_single = adjust_single def __str__(self): res = 'AS_POSITION\nADJUST_SINGLE' for coverage, pos in self.adjust_single: coverage = ''.join(str(c) for c in coverage) res += f'{coverage} BY{pos}' res += '\nEND_ADJUST\nEND_POSITION' return res
[docs]class ContextDefinition(Statement): def __init__(self, ex_or_in, left=None, right=None, location=None): Statement.__init__(self, location) self.ex_or_in = ex_or_in self.left = left if left is not None else [] self.right = right if right is not None else [] def __str__(self): res = self.ex_or_in + '\n' for coverage in self.left: coverage = ''.join(str(c) for c in coverage) res += f' LEFT{coverage}\n' for coverage in self.right: coverage = ''.join(str(c) for c in coverage) res += f' RIGHT{coverage}\n' res += 'END_CONTEXT' return res
[docs]class AnchorDefinition(Statement): def __init__(self, name, gid, glyph_name, component, locked, pos, location=None): Statement.__init__(self, location) = name self.gid = gid self.glyph_name = glyph_name self.component = component self.locked = locked self.pos = pos def __str__(self): locked = self.locked and ' LOCKED' or '' return (f'DEF_ANCHOR "{}"' f' ON {self.gid}' f' GLYPH {self.glyph_name}' f' COMPONENT {self.component}' f'{locked}' f' AT {self.pos} END_ANCHOR')
[docs]class SettingDefinition(Statement): def __init__(self, name, value, location=None): Statement.__init__(self, location) = name self.value = value def __str__(self): if self.value is True: return f'{}' if isinstance(self.value, (tuple, list)): value = " ".join(str(v) for v in self.value) return f'{} {value}' return f'{} {self.value}'