2360 lines
96 KiB
Python
2360 lines
96 KiB
Python
from fontTools.feaLib.error import FeatureLibError
|
|
from fontTools.feaLib.lexer import Lexer, IncludingLexer, NonIncludingLexer
|
|
from fontTools.feaLib.variableScalar import VariableScalar
|
|
from fontTools.misc.encodingTools import getEncoding
|
|
from fontTools.misc.textTools import bytechr, tobytes, tostr
|
|
import fontTools.feaLib.ast as ast
|
|
import logging
|
|
import os
|
|
import re
|
|
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
|
|
class Parser(object):
|
|
"""Initializes a Parser object.
|
|
|
|
Example:
|
|
|
|
.. code:: python
|
|
|
|
from fontTools.feaLib.parser import Parser
|
|
parser = Parser(file, font.getReverseGlyphMap())
|
|
parsetree = parser.parse()
|
|
|
|
Note: the ``glyphNames`` iterable serves a double role to help distinguish
|
|
glyph names from ranges in the presence of hyphens and to ensure that glyph
|
|
names referenced in a feature file are actually part of a font's glyph set.
|
|
If the iterable is left empty, no glyph name in glyph set checking takes
|
|
place, and all glyph tokens containing hyphens are treated as literal glyph
|
|
names, not as ranges. (Adding a space around the hyphen can, in any case,
|
|
help to disambiguate ranges from glyph names containing hyphens.)
|
|
|
|
By default, the parser will follow ``include()`` statements in the feature
|
|
file. To turn this off, pass ``followIncludes=False``. Pass a directory string as
|
|
``includeDir`` to explicitly declare a directory to search included feature files
|
|
in.
|
|
"""
|
|
|
|
extensions = {}
|
|
ast = ast
|
|
SS_FEATURE_TAGS = {"ss%02d" % i for i in range(1, 20 + 1)}
|
|
CV_FEATURE_TAGS = {"cv%02d" % i for i in range(1, 99 + 1)}
|
|
|
|
def __init__(
|
|
self, featurefile, glyphNames=(), followIncludes=True, includeDir=None, **kwargs
|
|
):
|
|
if "glyphMap" in kwargs:
|
|
from fontTools.misc.loggingTools import deprecateArgument
|
|
|
|
deprecateArgument("glyphMap", "use 'glyphNames' (iterable) instead")
|
|
if glyphNames:
|
|
raise TypeError(
|
|
"'glyphNames' and (deprecated) 'glyphMap' are " "mutually exclusive"
|
|
)
|
|
glyphNames = kwargs.pop("glyphMap")
|
|
if kwargs:
|
|
raise TypeError(
|
|
"unsupported keyword argument%s: %s"
|
|
% ("" if len(kwargs) == 1 else "s", ", ".join(repr(k) for k in kwargs))
|
|
)
|
|
|
|
self.glyphNames_ = set(glyphNames)
|
|
self.doc_ = self.ast.FeatureFile()
|
|
self.anchors_ = SymbolTable()
|
|
self.glyphclasses_ = SymbolTable()
|
|
self.lookups_ = SymbolTable()
|
|
self.valuerecords_ = SymbolTable()
|
|
self.symbol_tables_ = {self.anchors_, self.valuerecords_}
|
|
self.next_token_type_, self.next_token_ = (None, None)
|
|
self.cur_comments_ = []
|
|
self.next_token_location_ = None
|
|
lexerClass = IncludingLexer if followIncludes else NonIncludingLexer
|
|
self.lexer_ = lexerClass(featurefile, includeDir=includeDir)
|
|
self.missing = {}
|
|
self.advance_lexer_(comments=True)
|
|
|
|
def parse(self):
|
|
"""Parse the file, and return a :class:`fontTools.feaLib.ast.FeatureFile`
|
|
object representing the root of the abstract syntax tree containing the
|
|
parsed contents of the file."""
|
|
statements = self.doc_.statements
|
|
while self.next_token_type_ is not None or self.cur_comments_:
|
|
self.advance_lexer_(comments=True)
|
|
if self.cur_token_type_ is Lexer.COMMENT:
|
|
statements.append(
|
|
self.ast.Comment(self.cur_token_, location=self.cur_token_location_)
|
|
)
|
|
elif self.is_cur_keyword_("include"):
|
|
statements.append(self.parse_include_())
|
|
elif self.cur_token_type_ is Lexer.GLYPHCLASS:
|
|
statements.append(self.parse_glyphclass_definition_())
|
|
elif self.is_cur_keyword_(("anon", "anonymous")):
|
|
statements.append(self.parse_anonymous_())
|
|
elif self.is_cur_keyword_("anchorDef"):
|
|
statements.append(self.parse_anchordef_())
|
|
elif self.is_cur_keyword_("languagesystem"):
|
|
statements.append(self.parse_languagesystem_())
|
|
elif self.is_cur_keyword_("lookup"):
|
|
statements.append(self.parse_lookup_(vertical=False))
|
|
elif self.is_cur_keyword_("markClass"):
|
|
statements.append(self.parse_markClass_())
|
|
elif self.is_cur_keyword_("feature"):
|
|
statements.append(self.parse_feature_block_())
|
|
elif self.is_cur_keyword_("conditionset"):
|
|
statements.append(self.parse_conditionset_())
|
|
elif self.is_cur_keyword_("variation"):
|
|
statements.append(self.parse_feature_block_(variation=True))
|
|
elif self.is_cur_keyword_("table"):
|
|
statements.append(self.parse_table_())
|
|
elif self.is_cur_keyword_("valueRecordDef"):
|
|
statements.append(self.parse_valuerecord_definition_(vertical=False))
|
|
elif (
|
|
self.cur_token_type_ is Lexer.NAME
|
|
and self.cur_token_ in self.extensions
|
|
):
|
|
statements.append(self.extensions[self.cur_token_](self))
|
|
elif self.cur_token_type_ is Lexer.SYMBOL and self.cur_token_ == ";":
|
|
continue
|
|
else:
|
|
raise FeatureLibError(
|
|
"Expected feature, languagesystem, lookup, markClass, "
|
|
'table, or glyph class definition, got {} "{}"'.format(
|
|
self.cur_token_type_, self.cur_token_
|
|
),
|
|
self.cur_token_location_,
|
|
)
|
|
# Report any missing glyphs at the end of parsing
|
|
if self.missing:
|
|
error = [
|
|
" %s (first found at %s)" % (name, loc)
|
|
for name, loc in self.missing.items()
|
|
]
|
|
raise FeatureLibError(
|
|
"The following glyph names are referenced but are missing from the "
|
|
"glyph set:\n" + ("\n".join(error)),
|
|
None,
|
|
)
|
|
return self.doc_
|
|
|
|
def parse_anchor_(self):
|
|
# Parses an anchor in any of the four formats given in the feature
|
|
# file specification (2.e.vii).
|
|
self.expect_symbol_("<")
|
|
self.expect_keyword_("anchor")
|
|
location = self.cur_token_location_
|
|
|
|
if self.next_token_ == "NULL": # Format D
|
|
self.expect_keyword_("NULL")
|
|
self.expect_symbol_(">")
|
|
return None
|
|
|
|
if self.next_token_type_ == Lexer.NAME: # Format E
|
|
name = self.expect_name_()
|
|
anchordef = self.anchors_.resolve(name)
|
|
if anchordef is None:
|
|
raise FeatureLibError(
|
|
'Unknown anchor "%s"' % name, self.cur_token_location_
|
|
)
|
|
self.expect_symbol_(">")
|
|
return self.ast.Anchor(
|
|
anchordef.x,
|
|
anchordef.y,
|
|
name=name,
|
|
contourpoint=anchordef.contourpoint,
|
|
xDeviceTable=None,
|
|
yDeviceTable=None,
|
|
location=location,
|
|
)
|
|
|
|
x, y = self.expect_number_(variable=True), self.expect_number_(variable=True)
|
|
|
|
contourpoint = None
|
|
if self.next_token_ == "contourpoint": # Format B
|
|
self.expect_keyword_("contourpoint")
|
|
contourpoint = self.expect_number_()
|
|
|
|
if self.next_token_ == "<": # Format C
|
|
xDeviceTable = self.parse_device_()
|
|
yDeviceTable = self.parse_device_()
|
|
else:
|
|
xDeviceTable, yDeviceTable = None, None
|
|
|
|
self.expect_symbol_(">")
|
|
return self.ast.Anchor(
|
|
x,
|
|
y,
|
|
name=None,
|
|
contourpoint=contourpoint,
|
|
xDeviceTable=xDeviceTable,
|
|
yDeviceTable=yDeviceTable,
|
|
location=location,
|
|
)
|
|
|
|
def parse_anchor_marks_(self):
|
|
# Parses a sequence of ``[<anchor> mark @MARKCLASS]*.``
|
|
anchorMarks = [] # [(self.ast.Anchor, markClassName)*]
|
|
while self.next_token_ == "<":
|
|
anchor = self.parse_anchor_()
|
|
if anchor is None and self.next_token_ != "mark":
|
|
continue # <anchor NULL> without mark, eg. in GPOS type 5
|
|
self.expect_keyword_("mark")
|
|
markClass = self.expect_markClass_reference_()
|
|
anchorMarks.append((anchor, markClass))
|
|
return anchorMarks
|
|
|
|
def parse_anchordef_(self):
|
|
# Parses a named anchor definition (`section 2.e.viii <https://adobe-type-tools.github.io/afdko/OpenTypeFeatureFileSpecification.html#2.e.vii>`_).
|
|
assert self.is_cur_keyword_("anchorDef")
|
|
location = self.cur_token_location_
|
|
x, y = self.expect_number_(), self.expect_number_()
|
|
contourpoint = None
|
|
if self.next_token_ == "contourpoint":
|
|
self.expect_keyword_("contourpoint")
|
|
contourpoint = self.expect_number_()
|
|
name = self.expect_name_()
|
|
self.expect_symbol_(";")
|
|
anchordef = self.ast.AnchorDefinition(
|
|
name, x, y, contourpoint=contourpoint, location=location
|
|
)
|
|
self.anchors_.define(name, anchordef)
|
|
return anchordef
|
|
|
|
def parse_anonymous_(self):
|
|
# Parses an anonymous data block (`section 10 <https://adobe-type-tools.github.io/afdko/OpenTypeFeatureFileSpecification.html#10>`_).
|
|
assert self.is_cur_keyword_(("anon", "anonymous"))
|
|
tag = self.expect_tag_()
|
|
_, content, location = self.lexer_.scan_anonymous_block(tag)
|
|
self.advance_lexer_()
|
|
self.expect_symbol_("}")
|
|
end_tag = self.expect_tag_()
|
|
assert tag == end_tag, "bad splitting in Lexer.scan_anonymous_block()"
|
|
self.expect_symbol_(";")
|
|
return self.ast.AnonymousBlock(tag, content, location=location)
|
|
|
|
def parse_attach_(self):
|
|
# Parses a GDEF Attach statement (`section 9.b <https://adobe-type-tools.github.io/afdko/OpenTypeFeatureFileSpecification.html#9.b>`_)
|
|
assert self.is_cur_keyword_("Attach")
|
|
location = self.cur_token_location_
|
|
glyphs = self.parse_glyphclass_(accept_glyphname=True)
|
|
contourPoints = {self.expect_number_()}
|
|
while self.next_token_ != ";":
|
|
contourPoints.add(self.expect_number_())
|
|
self.expect_symbol_(";")
|
|
return self.ast.AttachStatement(glyphs, contourPoints, location=location)
|
|
|
|
def parse_enumerate_(self, vertical):
|
|
# Parse an enumerated pair positioning rule (`section 6.b.ii <https://adobe-type-tools.github.io/afdko/OpenTypeFeatureFileSpecification.html#6.b.ii>`_).
|
|
assert self.cur_token_ in {"enumerate", "enum"}
|
|
self.advance_lexer_()
|
|
return self.parse_position_(enumerated=True, vertical=vertical)
|
|
|
|
def parse_GlyphClassDef_(self):
|
|
# Parses 'GlyphClassDef @BASE, @LIGATURES, @MARKS, @COMPONENTS;'
|
|
assert self.is_cur_keyword_("GlyphClassDef")
|
|
location = self.cur_token_location_
|
|
if self.next_token_ != ",":
|
|
baseGlyphs = self.parse_glyphclass_(accept_glyphname=False)
|
|
else:
|
|
baseGlyphs = None
|
|
self.expect_symbol_(",")
|
|
if self.next_token_ != ",":
|
|
ligatureGlyphs = self.parse_glyphclass_(accept_glyphname=False)
|
|
else:
|
|
ligatureGlyphs = None
|
|
self.expect_symbol_(",")
|
|
if self.next_token_ != ",":
|
|
markGlyphs = self.parse_glyphclass_(accept_glyphname=False)
|
|
else:
|
|
markGlyphs = None
|
|
self.expect_symbol_(",")
|
|
if self.next_token_ != ";":
|
|
componentGlyphs = self.parse_glyphclass_(accept_glyphname=False)
|
|
else:
|
|
componentGlyphs = None
|
|
self.expect_symbol_(";")
|
|
return self.ast.GlyphClassDefStatement(
|
|
baseGlyphs, markGlyphs, ligatureGlyphs, componentGlyphs, location=location
|
|
)
|
|
|
|
def parse_glyphclass_definition_(self):
|
|
# Parses glyph class definitions such as '@UPPERCASE = [A-Z];'
|
|
location, name = self.cur_token_location_, self.cur_token_
|
|
self.expect_symbol_("=")
|
|
glyphs = self.parse_glyphclass_(accept_glyphname=False)
|
|
self.expect_symbol_(";")
|
|
glyphclass = self.ast.GlyphClassDefinition(name, glyphs, location=location)
|
|
self.glyphclasses_.define(name, glyphclass)
|
|
return glyphclass
|
|
|
|
def split_glyph_range_(self, name, location):
|
|
# Since v1.20, the OpenType Feature File specification allows
|
|
# for dashes in glyph names. A sequence like "a-b-c-d" could
|
|
# therefore mean a single glyph whose name happens to be
|
|
# "a-b-c-d", or it could mean a range from glyph "a" to glyph
|
|
# "b-c-d", or a range from glyph "a-b" to glyph "c-d", or a
|
|
# range from glyph "a-b-c" to glyph "d".Technically, this
|
|
# example could be resolved because the (pretty complex)
|
|
# definition of glyph ranges renders most of these splits
|
|
# invalid. But the specification does not say that a compiler
|
|
# should try to apply such fancy heuristics. To encourage
|
|
# unambiguous feature files, we therefore try all possible
|
|
# splits and reject the feature file if there are multiple
|
|
# splits possible. It is intentional that we don't just emit a
|
|
# warning; warnings tend to get ignored. To fix the problem,
|
|
# font designers can trivially add spaces around the intended
|
|
# split point, and we emit a compiler error that suggests
|
|
# how exactly the source should be rewritten to make things
|
|
# unambiguous.
|
|
parts = name.split("-")
|
|
solutions = []
|
|
for i in range(len(parts)):
|
|
start, limit = "-".join(parts[0:i]), "-".join(parts[i:])
|
|
if start in self.glyphNames_ and limit in self.glyphNames_:
|
|
solutions.append((start, limit))
|
|
if len(solutions) == 1:
|
|
start, limit = solutions[0]
|
|
return start, limit
|
|
elif len(solutions) == 0:
|
|
raise FeatureLibError(
|
|
'"%s" is not a glyph in the font, and it can not be split '
|
|
"into a range of known glyphs" % name,
|
|
location,
|
|
)
|
|
else:
|
|
ranges = " or ".join(['"%s - %s"' % (s, l) for s, l in solutions])
|
|
raise FeatureLibError(
|
|
'Ambiguous glyph range "%s"; '
|
|
"please use %s to clarify what you mean" % (name, ranges),
|
|
location,
|
|
)
|
|
|
|
def parse_glyphclass_(self, accept_glyphname, accept_null=False):
|
|
# Parses a glyph class, either named or anonymous, or (if
|
|
# ``bool(accept_glyphname)``) a glyph name. If ``bool(accept_null)`` then
|
|
# also accept the special NULL glyph.
|
|
if accept_glyphname and self.next_token_type_ in (Lexer.NAME, Lexer.CID):
|
|
if accept_null and self.next_token_ == "NULL":
|
|
# If you want a glyph called NULL, you should escape it.
|
|
self.advance_lexer_()
|
|
return self.ast.NullGlyph(location=self.cur_token_location_)
|
|
glyph = self.expect_glyph_()
|
|
self.check_glyph_name_in_glyph_set(glyph)
|
|
return self.ast.GlyphName(glyph, location=self.cur_token_location_)
|
|
if self.next_token_type_ is Lexer.GLYPHCLASS:
|
|
self.advance_lexer_()
|
|
gc = self.glyphclasses_.resolve(self.cur_token_)
|
|
if gc is None:
|
|
raise FeatureLibError(
|
|
"Unknown glyph class @%s" % self.cur_token_,
|
|
self.cur_token_location_,
|
|
)
|
|
if isinstance(gc, self.ast.MarkClass):
|
|
return self.ast.MarkClassName(gc, location=self.cur_token_location_)
|
|
else:
|
|
return self.ast.GlyphClassName(gc, location=self.cur_token_location_)
|
|
|
|
self.expect_symbol_("[")
|
|
location = self.cur_token_location_
|
|
glyphs = self.ast.GlyphClass(location=location)
|
|
while self.next_token_ != "]":
|
|
if self.next_token_type_ is Lexer.NAME:
|
|
glyph = self.expect_glyph_()
|
|
location = self.cur_token_location_
|
|
if "-" in glyph and self.glyphNames_ and glyph not in self.glyphNames_:
|
|
start, limit = self.split_glyph_range_(glyph, location)
|
|
self.check_glyph_name_in_glyph_set(start, limit)
|
|
glyphs.add_range(
|
|
start, limit, self.make_glyph_range_(location, start, limit)
|
|
)
|
|
elif self.next_token_ == "-":
|
|
start = glyph
|
|
self.expect_symbol_("-")
|
|
limit = self.expect_glyph_()
|
|
self.check_glyph_name_in_glyph_set(start, limit)
|
|
glyphs.add_range(
|
|
start, limit, self.make_glyph_range_(location, start, limit)
|
|
)
|
|
else:
|
|
if "-" in glyph and not self.glyphNames_:
|
|
log.warning(
|
|
str(
|
|
FeatureLibError(
|
|
f"Ambiguous glyph name that looks like a range: {glyph!r}",
|
|
location,
|
|
)
|
|
)
|
|
)
|
|
self.check_glyph_name_in_glyph_set(glyph)
|
|
glyphs.append(glyph)
|
|
elif self.next_token_type_ is Lexer.CID:
|
|
glyph = self.expect_glyph_()
|
|
if self.next_token_ == "-":
|
|
range_location = self.cur_token_location_
|
|
range_start = self.cur_token_
|
|
self.expect_symbol_("-")
|
|
range_end = self.expect_cid_()
|
|
self.check_glyph_name_in_glyph_set(
|
|
f"cid{range_start:05d}",
|
|
f"cid{range_end:05d}",
|
|
)
|
|
glyphs.add_cid_range(
|
|
range_start,
|
|
range_end,
|
|
self.make_cid_range_(range_location, range_start, range_end),
|
|
)
|
|
else:
|
|
glyph_name = f"cid{self.cur_token_:05d}"
|
|
self.check_glyph_name_in_glyph_set(glyph_name)
|
|
glyphs.append(glyph_name)
|
|
elif self.next_token_type_ is Lexer.GLYPHCLASS:
|
|
self.advance_lexer_()
|
|
gc = self.glyphclasses_.resolve(self.cur_token_)
|
|
if gc is None:
|
|
raise FeatureLibError(
|
|
"Unknown glyph class @%s" % self.cur_token_,
|
|
self.cur_token_location_,
|
|
)
|
|
if isinstance(gc, self.ast.MarkClass):
|
|
gc = self.ast.MarkClassName(gc, location=self.cur_token_location_)
|
|
else:
|
|
gc = self.ast.GlyphClassName(gc, location=self.cur_token_location_)
|
|
glyphs.add_class(gc)
|
|
else:
|
|
raise FeatureLibError(
|
|
"Expected glyph name, glyph range, "
|
|
f"or glyph class reference, found {self.next_token_!r}",
|
|
self.next_token_location_,
|
|
)
|
|
self.expect_symbol_("]")
|
|
return glyphs
|
|
|
|
def parse_glyph_pattern_(self, vertical):
|
|
# Parses a glyph pattern, including lookups and context, e.g.::
|
|
#
|
|
# a b
|
|
# a b c' d e
|
|
# a b c' lookup ChangeC d e
|
|
prefix, glyphs, lookups, values, suffix = ([], [], [], [], [])
|
|
hasMarks = False
|
|
while self.next_token_ not in {"by", "from", ";", ","}:
|
|
gc = self.parse_glyphclass_(accept_glyphname=True)
|
|
marked = False
|
|
if self.next_token_ == "'":
|
|
self.expect_symbol_("'")
|
|
hasMarks = marked = True
|
|
if marked:
|
|
if suffix:
|
|
# makeotf also reports this as an error, while FontForge
|
|
# silently inserts ' in all the intervening glyphs.
|
|
# https://github.com/fonttools/fonttools/pull/1096
|
|
raise FeatureLibError(
|
|
"Unsupported contextual target sequence: at most "
|
|
"one run of marked (') glyph/class names allowed",
|
|
self.cur_token_location_,
|
|
)
|
|
glyphs.append(gc)
|
|
elif glyphs:
|
|
suffix.append(gc)
|
|
else:
|
|
prefix.append(gc)
|
|
|
|
if self.is_next_value_():
|
|
values.append(self.parse_valuerecord_(vertical))
|
|
else:
|
|
values.append(None)
|
|
|
|
lookuplist = None
|
|
while self.next_token_ == "lookup":
|
|
if lookuplist is None:
|
|
lookuplist = []
|
|
self.expect_keyword_("lookup")
|
|
if not marked:
|
|
raise FeatureLibError(
|
|
"Lookups can only follow marked glyphs",
|
|
self.cur_token_location_,
|
|
)
|
|
lookup_name = self.expect_name_()
|
|
lookup = self.lookups_.resolve(lookup_name)
|
|
if lookup is None:
|
|
raise FeatureLibError(
|
|
'Unknown lookup "%s"' % lookup_name, self.cur_token_location_
|
|
)
|
|
lookuplist.append(lookup)
|
|
if marked:
|
|
lookups.append(lookuplist)
|
|
|
|
if not glyphs and not suffix: # eg., "sub f f i by"
|
|
assert lookups == []
|
|
return ([], prefix, [None] * len(prefix), values, [], hasMarks)
|
|
else:
|
|
if any(values[: len(prefix)]):
|
|
raise FeatureLibError(
|
|
"Positioning cannot be applied in the bactrack glyph sequence, "
|
|
"before the marked glyph sequence.",
|
|
self.cur_token_location_,
|
|
)
|
|
marked_values = values[len(prefix) : len(prefix) + len(glyphs)]
|
|
if any(marked_values):
|
|
if any(values[len(prefix) + len(glyphs) :]):
|
|
raise FeatureLibError(
|
|
"Positioning values are allowed only in the marked glyph "
|
|
"sequence, or after the final glyph node when only one glyph "
|
|
"node is marked.",
|
|
self.cur_token_location_,
|
|
)
|
|
values = marked_values
|
|
elif values and values[-1]:
|
|
if len(glyphs) > 1 or any(values[:-1]):
|
|
raise FeatureLibError(
|
|
"Positioning values are allowed only in the marked glyph "
|
|
"sequence, or after the final glyph node when only one glyph "
|
|
"node is marked.",
|
|
self.cur_token_location_,
|
|
)
|
|
values = values[-1:]
|
|
elif any(values):
|
|
raise FeatureLibError(
|
|
"Positioning values are allowed only in the marked glyph "
|
|
"sequence, or after the final glyph node when only one glyph "
|
|
"node is marked.",
|
|
self.cur_token_location_,
|
|
)
|
|
return (prefix, glyphs, lookups, values, suffix, hasMarks)
|
|
|
|
def parse_ignore_glyph_pattern_(self, sub):
|
|
location = self.cur_token_location_
|
|
prefix, glyphs, lookups, values, suffix, hasMarks = self.parse_glyph_pattern_(
|
|
vertical=False
|
|
)
|
|
if any(lookups):
|
|
raise FeatureLibError(
|
|
f'No lookups can be specified for "ignore {sub}"', location
|
|
)
|
|
if not hasMarks:
|
|
error = FeatureLibError(
|
|
f'Ambiguous "ignore {sub}", there should be least one marked glyph',
|
|
location,
|
|
)
|
|
log.warning(str(error))
|
|
suffix, glyphs = glyphs[1:], glyphs[0:1]
|
|
chainContext = (prefix, glyphs, suffix)
|
|
return chainContext
|
|
|
|
def parse_ignore_context_(self, sub):
|
|
location = self.cur_token_location_
|
|
chainContext = [self.parse_ignore_glyph_pattern_(sub)]
|
|
while self.next_token_ == ",":
|
|
self.expect_symbol_(",")
|
|
chainContext.append(self.parse_ignore_glyph_pattern_(sub))
|
|
self.expect_symbol_(";")
|
|
return chainContext
|
|
|
|
def parse_ignore_(self):
|
|
# Parses an ignore sub/pos rule.
|
|
assert self.is_cur_keyword_("ignore")
|
|
location = self.cur_token_location_
|
|
self.advance_lexer_()
|
|
if self.cur_token_ in ["substitute", "sub"]:
|
|
chainContext = self.parse_ignore_context_("sub")
|
|
return self.ast.IgnoreSubstStatement(chainContext, location=location)
|
|
if self.cur_token_ in ["position", "pos"]:
|
|
chainContext = self.parse_ignore_context_("pos")
|
|
return self.ast.IgnorePosStatement(chainContext, location=location)
|
|
raise FeatureLibError(
|
|
'Expected "substitute" or "position"', self.cur_token_location_
|
|
)
|
|
|
|
def parse_include_(self):
|
|
assert self.cur_token_ == "include"
|
|
location = self.cur_token_location_
|
|
filename = self.expect_filename_()
|
|
# self.expect_symbol_(";")
|
|
return ast.IncludeStatement(filename, location=location)
|
|
|
|
def parse_language_(self):
|
|
assert self.is_cur_keyword_("language")
|
|
location = self.cur_token_location_
|
|
language = self.expect_language_tag_()
|
|
include_default, required = (True, False)
|
|
if self.next_token_ in {"exclude_dflt", "include_dflt"}:
|
|
include_default = self.expect_name_() == "include_dflt"
|
|
if self.next_token_ == "required":
|
|
self.expect_keyword_("required")
|
|
required = True
|
|
self.expect_symbol_(";")
|
|
return self.ast.LanguageStatement(
|
|
language, include_default, required, location=location
|
|
)
|
|
|
|
def parse_ligatureCaretByIndex_(self):
|
|
assert self.is_cur_keyword_("LigatureCaretByIndex")
|
|
location = self.cur_token_location_
|
|
glyphs = self.parse_glyphclass_(accept_glyphname=True)
|
|
carets = [self.expect_number_()]
|
|
while self.next_token_ != ";":
|
|
carets.append(self.expect_number_())
|
|
self.expect_symbol_(";")
|
|
return self.ast.LigatureCaretByIndexStatement(glyphs, carets, location=location)
|
|
|
|
def parse_ligatureCaretByPos_(self):
|
|
assert self.is_cur_keyword_("LigatureCaretByPos")
|
|
location = self.cur_token_location_
|
|
glyphs = self.parse_glyphclass_(accept_glyphname=True)
|
|
carets = [self.expect_number_(variable=True)]
|
|
while self.next_token_ != ";":
|
|
carets.append(self.expect_number_(variable=True))
|
|
self.expect_symbol_(";")
|
|
return self.ast.LigatureCaretByPosStatement(glyphs, carets, location=location)
|
|
|
|
def parse_lookup_(self, vertical):
|
|
# Parses a ``lookup`` - either a lookup block, or a lookup reference
|
|
# inside a feature.
|
|
assert self.is_cur_keyword_("lookup")
|
|
location, name = self.cur_token_location_, self.expect_name_()
|
|
|
|
if self.next_token_ == ";":
|
|
lookup = self.lookups_.resolve(name)
|
|
if lookup is None:
|
|
raise FeatureLibError(
|
|
'Unknown lookup "%s"' % name, self.cur_token_location_
|
|
)
|
|
self.expect_symbol_(";")
|
|
return self.ast.LookupReferenceStatement(lookup, location=location)
|
|
|
|
use_extension = False
|
|
if self.next_token_ == "useExtension":
|
|
self.expect_keyword_("useExtension")
|
|
use_extension = True
|
|
|
|
block = self.ast.LookupBlock(name, use_extension, location=location)
|
|
self.parse_block_(block, vertical)
|
|
self.lookups_.define(name, block)
|
|
return block
|
|
|
|
def parse_lookupflag_(self):
|
|
# Parses a ``lookupflag`` statement, either specified by number or
|
|
# in words.
|
|
assert self.is_cur_keyword_("lookupflag")
|
|
location = self.cur_token_location_
|
|
|
|
# format B: "lookupflag 6;"
|
|
if self.next_token_type_ == Lexer.NUMBER:
|
|
value = self.expect_number_()
|
|
self.expect_symbol_(";")
|
|
return self.ast.LookupFlagStatement(value, location=location)
|
|
|
|
# format A: "lookupflag RightToLeft MarkAttachmentType @M;"
|
|
value_seen = False
|
|
value, markAttachment, markFilteringSet = 0, None, None
|
|
flags = {
|
|
"RightToLeft": 1,
|
|
"IgnoreBaseGlyphs": 2,
|
|
"IgnoreLigatures": 4,
|
|
"IgnoreMarks": 8,
|
|
}
|
|
seen = set()
|
|
while self.next_token_ != ";":
|
|
if self.next_token_ in seen:
|
|
raise FeatureLibError(
|
|
"%s can be specified only once" % self.next_token_,
|
|
self.next_token_location_,
|
|
)
|
|
seen.add(self.next_token_)
|
|
if self.next_token_ == "MarkAttachmentType":
|
|
self.expect_keyword_("MarkAttachmentType")
|
|
markAttachment = self.parse_glyphclass_(accept_glyphname=False)
|
|
elif self.next_token_ == "UseMarkFilteringSet":
|
|
self.expect_keyword_("UseMarkFilteringSet")
|
|
markFilteringSet = self.parse_glyphclass_(accept_glyphname=False)
|
|
elif self.next_token_ in flags:
|
|
value_seen = True
|
|
value = value | flags[self.expect_name_()]
|
|
else:
|
|
raise FeatureLibError(
|
|
'"%s" is not a recognized lookupflag' % self.next_token_,
|
|
self.next_token_location_,
|
|
)
|
|
self.expect_symbol_(";")
|
|
|
|
if not any([value_seen, markAttachment, markFilteringSet]):
|
|
raise FeatureLibError(
|
|
"lookupflag must have a value", self.next_token_location_
|
|
)
|
|
|
|
return self.ast.LookupFlagStatement(
|
|
value,
|
|
markAttachment=markAttachment,
|
|
markFilteringSet=markFilteringSet,
|
|
location=location,
|
|
)
|
|
|
|
def parse_markClass_(self):
|
|
assert self.is_cur_keyword_("markClass")
|
|
location = self.cur_token_location_
|
|
glyphs = self.parse_glyphclass_(accept_glyphname=True)
|
|
if not glyphs.glyphSet():
|
|
raise FeatureLibError(
|
|
"Empty glyph class in mark class definition", location
|
|
)
|
|
anchor = self.parse_anchor_()
|
|
name = self.expect_class_name_()
|
|
self.expect_symbol_(";")
|
|
markClass = self.doc_.markClasses.get(name)
|
|
if markClass is None:
|
|
markClass = self.ast.MarkClass(name)
|
|
self.doc_.markClasses[name] = markClass
|
|
self.glyphclasses_.define(name, markClass)
|
|
mcdef = self.ast.MarkClassDefinition(
|
|
markClass, anchor, glyphs, location=location
|
|
)
|
|
markClass.addDefinition(mcdef)
|
|
return mcdef
|
|
|
|
def parse_position_(self, enumerated, vertical):
|
|
assert self.cur_token_ in {"position", "pos"}
|
|
if self.next_token_ == "cursive": # GPOS type 3
|
|
return self.parse_position_cursive_(enumerated, vertical)
|
|
elif self.next_token_ == "base": # GPOS type 4
|
|
return self.parse_position_base_(enumerated, vertical)
|
|
elif self.next_token_ == "ligature": # GPOS type 5
|
|
return self.parse_position_ligature_(enumerated, vertical)
|
|
elif self.next_token_ == "mark": # GPOS type 6
|
|
return self.parse_position_mark_(enumerated, vertical)
|
|
|
|
location = self.cur_token_location_
|
|
prefix, glyphs, lookups, values, suffix, hasMarks = self.parse_glyph_pattern_(
|
|
vertical
|
|
)
|
|
self.expect_symbol_(";")
|
|
|
|
if any(lookups):
|
|
# GPOS type 8: Chaining contextual positioning; explicit lookups
|
|
if any(values):
|
|
raise FeatureLibError(
|
|
'If "lookup" is present, no values must be specified', location
|
|
)
|
|
return self.ast.ChainContextPosStatement(
|
|
prefix, glyphs, suffix, lookups, location=location
|
|
)
|
|
|
|
# Pair positioning, format A: "pos V 10 A -10;"
|
|
# Pair positioning, format B: "pos V A -20;"
|
|
if not prefix and not suffix and len(glyphs) == 2 and not hasMarks:
|
|
if values[0] is None: # Format B: "pos V A -20;"
|
|
values.reverse()
|
|
return self.ast.PairPosStatement(
|
|
glyphs[0],
|
|
values[0],
|
|
glyphs[1],
|
|
values[1],
|
|
enumerated=enumerated,
|
|
location=location,
|
|
)
|
|
|
|
if enumerated:
|
|
raise FeatureLibError(
|
|
'"enumerate" is only allowed with pair positionings', location
|
|
)
|
|
return self.ast.SinglePosStatement(
|
|
list(zip(glyphs, values)),
|
|
prefix,
|
|
suffix,
|
|
forceChain=hasMarks,
|
|
location=location,
|
|
)
|
|
|
|
def parse_position_cursive_(self, enumerated, vertical):
|
|
location = self.cur_token_location_
|
|
self.expect_keyword_("cursive")
|
|
if enumerated:
|
|
raise FeatureLibError(
|
|
'"enumerate" is not allowed with ' "cursive attachment positioning",
|
|
location,
|
|
)
|
|
glyphclass = self.parse_glyphclass_(accept_glyphname=True)
|
|
entryAnchor = self.parse_anchor_()
|
|
exitAnchor = self.parse_anchor_()
|
|
self.expect_symbol_(";")
|
|
return self.ast.CursivePosStatement(
|
|
glyphclass, entryAnchor, exitAnchor, location=location
|
|
)
|
|
|
|
def parse_position_base_(self, enumerated, vertical):
|
|
location = self.cur_token_location_
|
|
self.expect_keyword_("base")
|
|
if enumerated:
|
|
raise FeatureLibError(
|
|
'"enumerate" is not allowed with '
|
|
"mark-to-base attachment positioning",
|
|
location,
|
|
)
|
|
base = self.parse_glyphclass_(accept_glyphname=True)
|
|
marks = self.parse_anchor_marks_()
|
|
self.expect_symbol_(";")
|
|
return self.ast.MarkBasePosStatement(base, marks, location=location)
|
|
|
|
def parse_position_ligature_(self, enumerated, vertical):
|
|
location = self.cur_token_location_
|
|
self.expect_keyword_("ligature")
|
|
if enumerated:
|
|
raise FeatureLibError(
|
|
'"enumerate" is not allowed with '
|
|
"mark-to-ligature attachment positioning",
|
|
location,
|
|
)
|
|
ligatures = self.parse_glyphclass_(accept_glyphname=True)
|
|
marks = [self.parse_anchor_marks_()]
|
|
while self.next_token_ == "ligComponent":
|
|
self.expect_keyword_("ligComponent")
|
|
marks.append(self.parse_anchor_marks_())
|
|
self.expect_symbol_(";")
|
|
return self.ast.MarkLigPosStatement(ligatures, marks, location=location)
|
|
|
|
def parse_position_mark_(self, enumerated, vertical):
|
|
location = self.cur_token_location_
|
|
self.expect_keyword_("mark")
|
|
if enumerated:
|
|
raise FeatureLibError(
|
|
'"enumerate" is not allowed with '
|
|
"mark-to-mark attachment positioning",
|
|
location,
|
|
)
|
|
baseMarks = self.parse_glyphclass_(accept_glyphname=True)
|
|
marks = self.parse_anchor_marks_()
|
|
self.expect_symbol_(";")
|
|
return self.ast.MarkMarkPosStatement(baseMarks, marks, location=location)
|
|
|
|
def parse_script_(self):
|
|
assert self.is_cur_keyword_("script")
|
|
location, script = self.cur_token_location_, self.expect_script_tag_()
|
|
self.expect_symbol_(";")
|
|
return self.ast.ScriptStatement(script, location=location)
|
|
|
|
def parse_substitute_(self):
|
|
assert self.cur_token_ in {"substitute", "sub", "reversesub", "rsub"}
|
|
location = self.cur_token_location_
|
|
reverse = self.cur_token_ in {"reversesub", "rsub"}
|
|
(
|
|
old_prefix,
|
|
old,
|
|
lookups,
|
|
values,
|
|
old_suffix,
|
|
hasMarks,
|
|
) = self.parse_glyph_pattern_(vertical=False)
|
|
if any(values):
|
|
raise FeatureLibError(
|
|
"Substitution statements cannot contain values", location
|
|
)
|
|
new = []
|
|
if self.next_token_ == "by":
|
|
keyword = self.expect_keyword_("by")
|
|
while self.next_token_ != ";":
|
|
gc = self.parse_glyphclass_(accept_glyphname=True, accept_null=True)
|
|
new.append(gc)
|
|
elif self.next_token_ == "from":
|
|
keyword = self.expect_keyword_("from")
|
|
new = [self.parse_glyphclass_(accept_glyphname=False)]
|
|
else:
|
|
keyword = None
|
|
self.expect_symbol_(";")
|
|
if len(new) == 0 and not any(lookups):
|
|
raise FeatureLibError(
|
|
'Expected "by", "from" or explicit lookup references',
|
|
self.cur_token_location_,
|
|
)
|
|
|
|
# GSUB lookup type 3: Alternate substitution.
|
|
# Format: "substitute a from [a.1 a.2 a.3];"
|
|
if keyword == "from":
|
|
if reverse:
|
|
raise FeatureLibError(
|
|
'Reverse chaining substitutions do not support "from"', location
|
|
)
|
|
if len(old) != 1 or len(old[0].glyphSet()) != 1:
|
|
raise FeatureLibError('Expected a single glyph before "from"', location)
|
|
if len(new) != 1:
|
|
raise FeatureLibError(
|
|
'Expected a single glyphclass after "from"', location
|
|
)
|
|
return self.ast.AlternateSubstStatement(
|
|
old_prefix, old[0], old_suffix, new[0], location=location
|
|
)
|
|
|
|
num_lookups = len([l for l in lookups if l is not None])
|
|
|
|
is_deletion = False
|
|
if len(new) == 1 and isinstance(new[0], ast.NullGlyph):
|
|
new = [] # Deletion
|
|
is_deletion = True
|
|
|
|
# GSUB lookup type 1: Single substitution.
|
|
# Format A: "substitute a by a.sc;"
|
|
# Format B: "substitute [one.fitted one.oldstyle] by one;"
|
|
# Format C: "substitute [a-d] by [A.sc-D.sc];"
|
|
if not reverse and len(old) == 1 and len(new) == 1 and num_lookups == 0:
|
|
glyphs = list(old[0].glyphSet())
|
|
replacements = list(new[0].glyphSet())
|
|
if len(replacements) == 1:
|
|
replacements = replacements * len(glyphs)
|
|
if len(glyphs) != len(replacements):
|
|
raise FeatureLibError(
|
|
'Expected a glyph class with %d elements after "by", '
|
|
"but found a glyph class with %d elements"
|
|
% (len(glyphs), len(replacements)),
|
|
location,
|
|
)
|
|
return self.ast.SingleSubstStatement(
|
|
old, new, old_prefix, old_suffix, forceChain=hasMarks, location=location
|
|
)
|
|
|
|
# Glyph deletion, built as GSUB lookup type 2: Multiple substitution
|
|
# with empty replacement.
|
|
if is_deletion and len(old) == 1 and num_lookups == 0:
|
|
return self.ast.MultipleSubstStatement(
|
|
old_prefix,
|
|
old[0],
|
|
old_suffix,
|
|
(),
|
|
forceChain=hasMarks,
|
|
location=location,
|
|
)
|
|
|
|
# GSUB lookup type 2: Multiple substitution.
|
|
# Format: "substitute f_f_i by f f i;"
|
|
#
|
|
# GlyphsApp introduces two additional formats:
|
|
# Format 1: "substitute [f_i f_l] by [f f] [i l];"
|
|
# Format 2: "substitute [f_i f_l] by f [i l];"
|
|
# http://handbook.glyphsapp.com/en/layout/multiple-substitution-with-classes/
|
|
if not reverse and len(old) == 1 and len(new) > 1 and num_lookups == 0:
|
|
count = len(old[0].glyphSet())
|
|
for n in new:
|
|
if not list(n.glyphSet()):
|
|
raise FeatureLibError("Empty class in replacement", location)
|
|
if len(n.glyphSet()) != 1 and len(n.glyphSet()) != count:
|
|
raise FeatureLibError(
|
|
f'Expected a glyph class with 1 or {count} elements after "by", '
|
|
f"but found a glyph class with {len(n.glyphSet())} elements",
|
|
location,
|
|
)
|
|
return self.ast.MultipleSubstStatement(
|
|
old_prefix,
|
|
old[0],
|
|
old_suffix,
|
|
new,
|
|
forceChain=hasMarks,
|
|
location=location,
|
|
)
|
|
|
|
# GSUB lookup type 4: Ligature substitution.
|
|
# Format: "substitute f f i by f_f_i;"
|
|
if (
|
|
not reverse
|
|
and len(old) > 1
|
|
and len(new) == 1
|
|
and len(new[0].glyphSet()) == 1
|
|
and num_lookups == 0
|
|
):
|
|
return self.ast.LigatureSubstStatement(
|
|
old_prefix,
|
|
old,
|
|
old_suffix,
|
|
list(new[0].glyphSet())[0],
|
|
forceChain=hasMarks,
|
|
location=location,
|
|
)
|
|
|
|
# GSUB lookup type 8: Reverse chaining substitution.
|
|
if reverse:
|
|
if len(old) != 1:
|
|
raise FeatureLibError(
|
|
"In reverse chaining single substitutions, "
|
|
"only a single glyph or glyph class can be replaced",
|
|
location,
|
|
)
|
|
if len(new) != 1:
|
|
raise FeatureLibError(
|
|
"In reverse chaining single substitutions, "
|
|
'the replacement (after "by") must be a single glyph '
|
|
"or glyph class",
|
|
location,
|
|
)
|
|
if num_lookups != 0:
|
|
raise FeatureLibError(
|
|
"Reverse chaining substitutions cannot call named lookups", location
|
|
)
|
|
glyphs = sorted(list(old[0].glyphSet()))
|
|
replacements = sorted(list(new[0].glyphSet()))
|
|
if len(replacements) == 1:
|
|
replacements = replacements * len(glyphs)
|
|
if len(glyphs) != len(replacements):
|
|
raise FeatureLibError(
|
|
'Expected a glyph class with %d elements after "by", '
|
|
"but found a glyph class with %d elements"
|
|
% (len(glyphs), len(replacements)),
|
|
location,
|
|
)
|
|
return self.ast.ReverseChainSingleSubstStatement(
|
|
old_prefix, old_suffix, old, new, location=location
|
|
)
|
|
|
|
if len(old) > 1 and len(new) > 1:
|
|
raise FeatureLibError(
|
|
"Direct substitution of multiple glyphs by multiple glyphs "
|
|
"is not supported",
|
|
location,
|
|
)
|
|
|
|
# If there are remaining glyphs to parse, this is an invalid GSUB statement
|
|
if len(new) != 0 or is_deletion:
|
|
raise FeatureLibError("Invalid substitution statement", location)
|
|
|
|
# GSUB lookup type 6: Chaining contextual substitution.
|
|
rule = self.ast.ChainContextSubstStatement(
|
|
old_prefix, old, old_suffix, lookups, location=location
|
|
)
|
|
return rule
|
|
|
|
def parse_subtable_(self):
|
|
assert self.is_cur_keyword_("subtable")
|
|
location = self.cur_token_location_
|
|
self.expect_symbol_(";")
|
|
return self.ast.SubtableStatement(location=location)
|
|
|
|
def parse_size_parameters_(self):
|
|
# Parses a ``parameters`` statement used in ``size`` features. See
|
|
# `section 8.b <https://adobe-type-tools.github.io/afdko/OpenTypeFeatureFileSpecification.html#8.b>`_.
|
|
assert self.is_cur_keyword_("parameters")
|
|
location = self.cur_token_location_
|
|
DesignSize = self.expect_decipoint_()
|
|
SubfamilyID = self.expect_number_()
|
|
RangeStart = 0.0
|
|
RangeEnd = 0.0
|
|
if self.next_token_type_ in (Lexer.NUMBER, Lexer.FLOAT) or SubfamilyID != 0:
|
|
RangeStart = self.expect_decipoint_()
|
|
RangeEnd = self.expect_decipoint_()
|
|
|
|
self.expect_symbol_(";")
|
|
return self.ast.SizeParameters(
|
|
DesignSize, SubfamilyID, RangeStart, RangeEnd, location=location
|
|
)
|
|
|
|
def parse_size_menuname_(self):
|
|
assert self.is_cur_keyword_("sizemenuname")
|
|
location = self.cur_token_location_
|
|
platformID, platEncID, langID, string = self.parse_name_()
|
|
return self.ast.FeatureNameStatement(
|
|
"size", platformID, platEncID, langID, string, location=location
|
|
)
|
|
|
|
def parse_table_(self):
|
|
assert self.is_cur_keyword_("table")
|
|
location, name = self.cur_token_location_, self.expect_tag_()
|
|
table = self.ast.TableBlock(name, location=location)
|
|
self.expect_symbol_("{")
|
|
handler = {
|
|
"GDEF": self.parse_table_GDEF_,
|
|
"head": self.parse_table_head_,
|
|
"hhea": self.parse_table_hhea_,
|
|
"vhea": self.parse_table_vhea_,
|
|
"name": self.parse_table_name_,
|
|
"BASE": self.parse_table_BASE_,
|
|
"OS/2": self.parse_table_OS_2_,
|
|
"STAT": self.parse_table_STAT_,
|
|
}.get(name)
|
|
if handler:
|
|
handler(table)
|
|
else:
|
|
raise FeatureLibError(
|
|
'"table %s" is not supported' % name.strip(), location
|
|
)
|
|
self.expect_symbol_("}")
|
|
end_tag = self.expect_tag_()
|
|
if end_tag != name:
|
|
raise FeatureLibError(
|
|
'Expected "%s"' % name.strip(), self.cur_token_location_
|
|
)
|
|
self.expect_symbol_(";")
|
|
return table
|
|
|
|
def parse_table_GDEF_(self, table):
|
|
statements = table.statements
|
|
while self.next_token_ != "}" or self.cur_comments_:
|
|
self.advance_lexer_(comments=True)
|
|
if self.cur_token_type_ is Lexer.COMMENT:
|
|
statements.append(
|
|
self.ast.Comment(self.cur_token_, location=self.cur_token_location_)
|
|
)
|
|
elif self.is_cur_keyword_("Attach"):
|
|
statements.append(self.parse_attach_())
|
|
elif self.is_cur_keyword_("GlyphClassDef"):
|
|
statements.append(self.parse_GlyphClassDef_())
|
|
elif self.is_cur_keyword_("LigatureCaretByIndex"):
|
|
statements.append(self.parse_ligatureCaretByIndex_())
|
|
elif self.is_cur_keyword_("LigatureCaretByPos"):
|
|
statements.append(self.parse_ligatureCaretByPos_())
|
|
elif self.cur_token_ == ";":
|
|
continue
|
|
else:
|
|
raise FeatureLibError(
|
|
"Expected Attach, LigatureCaretByIndex, " "or LigatureCaretByPos",
|
|
self.cur_token_location_,
|
|
)
|
|
|
|
def parse_table_head_(self, table):
|
|
statements = table.statements
|
|
while self.next_token_ != "}" or self.cur_comments_:
|
|
self.advance_lexer_(comments=True)
|
|
if self.cur_token_type_ is Lexer.COMMENT:
|
|
statements.append(
|
|
self.ast.Comment(self.cur_token_, location=self.cur_token_location_)
|
|
)
|
|
elif self.is_cur_keyword_("FontRevision"):
|
|
statements.append(self.parse_FontRevision_())
|
|
elif self.cur_token_ == ";":
|
|
continue
|
|
else:
|
|
raise FeatureLibError("Expected FontRevision", self.cur_token_location_)
|
|
|
|
def parse_table_hhea_(self, table):
|
|
statements = table.statements
|
|
fields = ("CaretOffset", "Ascender", "Descender", "LineGap")
|
|
while self.next_token_ != "}" or self.cur_comments_:
|
|
self.advance_lexer_(comments=True)
|
|
if self.cur_token_type_ is Lexer.COMMENT:
|
|
statements.append(
|
|
self.ast.Comment(self.cur_token_, location=self.cur_token_location_)
|
|
)
|
|
elif self.cur_token_type_ is Lexer.NAME and self.cur_token_ in fields:
|
|
key = self.cur_token_.lower()
|
|
value = self.expect_number_()
|
|
statements.append(
|
|
self.ast.HheaField(key, value, location=self.cur_token_location_)
|
|
)
|
|
if self.next_token_ != ";":
|
|
raise FeatureLibError(
|
|
"Incomplete statement", self.next_token_location_
|
|
)
|
|
elif self.cur_token_ == ";":
|
|
continue
|
|
else:
|
|
raise FeatureLibError(
|
|
"Expected CaretOffset, Ascender, " "Descender or LineGap",
|
|
self.cur_token_location_,
|
|
)
|
|
|
|
def parse_table_vhea_(self, table):
|
|
statements = table.statements
|
|
fields = ("VertTypoAscender", "VertTypoDescender", "VertTypoLineGap")
|
|
while self.next_token_ != "}" or self.cur_comments_:
|
|
self.advance_lexer_(comments=True)
|
|
if self.cur_token_type_ is Lexer.COMMENT:
|
|
statements.append(
|
|
self.ast.Comment(self.cur_token_, location=self.cur_token_location_)
|
|
)
|
|
elif self.cur_token_type_ is Lexer.NAME and self.cur_token_ in fields:
|
|
key = self.cur_token_.lower()
|
|
value = self.expect_number_()
|
|
statements.append(
|
|
self.ast.VheaField(key, value, location=self.cur_token_location_)
|
|
)
|
|
if self.next_token_ != ";":
|
|
raise FeatureLibError(
|
|
"Incomplete statement", self.next_token_location_
|
|
)
|
|
elif self.cur_token_ == ";":
|
|
continue
|
|
else:
|
|
raise FeatureLibError(
|
|
"Expected VertTypoAscender, "
|
|
"VertTypoDescender or VertTypoLineGap",
|
|
self.cur_token_location_,
|
|
)
|
|
|
|
def parse_table_name_(self, table):
|
|
statements = table.statements
|
|
while self.next_token_ != "}" or self.cur_comments_:
|
|
self.advance_lexer_(comments=True)
|
|
if self.cur_token_type_ is Lexer.COMMENT:
|
|
statements.append(
|
|
self.ast.Comment(self.cur_token_, location=self.cur_token_location_)
|
|
)
|
|
elif self.is_cur_keyword_("nameid"):
|
|
statement = self.parse_nameid_()
|
|
if statement:
|
|
statements.append(statement)
|
|
elif self.cur_token_ == ";":
|
|
continue
|
|
else:
|
|
raise FeatureLibError("Expected nameid", self.cur_token_location_)
|
|
|
|
def parse_name_(self):
|
|
"""Parses a name record. See `section 9.e <https://adobe-type-tools.github.io/afdko/OpenTypeFeatureFileSpecification.html#9.e>`_."""
|
|
platEncID = None
|
|
langID = None
|
|
if self.next_token_type_ in Lexer.NUMBERS:
|
|
platformID = self.expect_any_number_()
|
|
location = self.cur_token_location_
|
|
if platformID not in (1, 3):
|
|
raise FeatureLibError("Expected platform id 1 or 3", location)
|
|
if self.next_token_type_ in Lexer.NUMBERS:
|
|
platEncID = self.expect_any_number_()
|
|
langID = self.expect_any_number_()
|
|
else:
|
|
platformID = 3
|
|
location = self.cur_token_location_
|
|
|
|
if platformID == 1: # Macintosh
|
|
platEncID = platEncID or 0 # Roman
|
|
langID = langID or 0 # English
|
|
else: # 3, Windows
|
|
platEncID = platEncID or 1 # Unicode
|
|
langID = langID or 0x0409 # English
|
|
|
|
string = self.expect_string_()
|
|
self.expect_symbol_(";")
|
|
|
|
encoding = getEncoding(platformID, platEncID, langID)
|
|
if encoding is None:
|
|
raise FeatureLibError("Unsupported encoding", location)
|
|
unescaped = self.unescape_string_(string, encoding)
|
|
return platformID, platEncID, langID, unescaped
|
|
|
|
def parse_stat_name_(self):
|
|
platEncID = None
|
|
langID = None
|
|
if self.next_token_type_ in Lexer.NUMBERS:
|
|
platformID = self.expect_any_number_()
|
|
location = self.cur_token_location_
|
|
if platformID not in (1, 3):
|
|
raise FeatureLibError("Expected platform id 1 or 3", location)
|
|
if self.next_token_type_ in Lexer.NUMBERS:
|
|
platEncID = self.expect_any_number_()
|
|
langID = self.expect_any_number_()
|
|
else:
|
|
platformID = 3
|
|
location = self.cur_token_location_
|
|
|
|
if platformID == 1: # Macintosh
|
|
platEncID = platEncID or 0 # Roman
|
|
langID = langID or 0 # English
|
|
else: # 3, Windows
|
|
platEncID = platEncID or 1 # Unicode
|
|
langID = langID or 0x0409 # English
|
|
|
|
string = self.expect_string_()
|
|
encoding = getEncoding(platformID, platEncID, langID)
|
|
if encoding is None:
|
|
raise FeatureLibError("Unsupported encoding", location)
|
|
unescaped = self.unescape_string_(string, encoding)
|
|
return platformID, platEncID, langID, unescaped
|
|
|
|
def parse_nameid_(self):
|
|
assert self.cur_token_ == "nameid", self.cur_token_
|
|
location, nameID = self.cur_token_location_, self.expect_any_number_()
|
|
if nameID > 32767:
|
|
raise FeatureLibError(
|
|
"Name id value cannot be greater than 32767", self.cur_token_location_
|
|
)
|
|
platformID, platEncID, langID, string = self.parse_name_()
|
|
return self.ast.NameRecord(
|
|
nameID, platformID, platEncID, langID, string, location=location
|
|
)
|
|
|
|
def unescape_string_(self, string, encoding):
|
|
if encoding == "utf_16_be":
|
|
s = re.sub(r"\\[0-9a-fA-F]{4}", self.unescape_unichr_, string)
|
|
else:
|
|
unescape = lambda m: self.unescape_byte_(m, encoding)
|
|
s = re.sub(r"\\[0-9a-fA-F]{2}", unescape, string)
|
|
# We now have a Unicode string, but it might contain surrogate pairs.
|
|
# We convert surrogates to actual Unicode by round-tripping through
|
|
# Python's UTF-16 codec in a special mode.
|
|
utf16 = tobytes(s, "utf_16_be", "surrogatepass")
|
|
return tostr(utf16, "utf_16_be")
|
|
|
|
@staticmethod
|
|
def unescape_unichr_(match):
|
|
n = match.group(0)[1:]
|
|
return chr(int(n, 16))
|
|
|
|
@staticmethod
|
|
def unescape_byte_(match, encoding):
|
|
n = match.group(0)[1:]
|
|
return bytechr(int(n, 16)).decode(encoding)
|
|
|
|
def parse_table_BASE_(self, table):
|
|
statements = table.statements
|
|
while self.next_token_ != "}" or self.cur_comments_:
|
|
self.advance_lexer_(comments=True)
|
|
if self.cur_token_type_ is Lexer.COMMENT:
|
|
statements.append(
|
|
self.ast.Comment(self.cur_token_, location=self.cur_token_location_)
|
|
)
|
|
elif self.is_cur_keyword_("HorizAxis.BaseTagList"):
|
|
horiz_bases = self.parse_base_tag_list_()
|
|
elif self.is_cur_keyword_("HorizAxis.BaseScriptList"):
|
|
horiz_scripts = self.parse_base_script_list_(len(horiz_bases))
|
|
statements.append(
|
|
self.ast.BaseAxis(
|
|
horiz_bases,
|
|
horiz_scripts,
|
|
False,
|
|
location=self.cur_token_location_,
|
|
)
|
|
)
|
|
elif self.is_cur_keyword_("VertAxis.BaseTagList"):
|
|
vert_bases = self.parse_base_tag_list_()
|
|
elif self.is_cur_keyword_("VertAxis.BaseScriptList"):
|
|
vert_scripts = self.parse_base_script_list_(len(vert_bases))
|
|
statements.append(
|
|
self.ast.BaseAxis(
|
|
vert_bases,
|
|
vert_scripts,
|
|
True,
|
|
location=self.cur_token_location_,
|
|
)
|
|
)
|
|
elif self.cur_token_ == ";":
|
|
continue
|
|
|
|
def parse_table_OS_2_(self, table):
|
|
statements = table.statements
|
|
numbers = (
|
|
"FSType",
|
|
"TypoAscender",
|
|
"TypoDescender",
|
|
"TypoLineGap",
|
|
"winAscent",
|
|
"winDescent",
|
|
"XHeight",
|
|
"CapHeight",
|
|
"WeightClass",
|
|
"WidthClass",
|
|
"LowerOpSize",
|
|
"UpperOpSize",
|
|
)
|
|
ranges = ("UnicodeRange", "CodePageRange")
|
|
while self.next_token_ != "}" or self.cur_comments_:
|
|
self.advance_lexer_(comments=True)
|
|
if self.cur_token_type_ is Lexer.COMMENT:
|
|
statements.append(
|
|
self.ast.Comment(self.cur_token_, location=self.cur_token_location_)
|
|
)
|
|
elif self.cur_token_type_ is Lexer.NAME:
|
|
key = self.cur_token_.lower()
|
|
value = None
|
|
if self.cur_token_ in numbers:
|
|
value = self.expect_number_()
|
|
elif self.is_cur_keyword_("Panose"):
|
|
value = []
|
|
for i in range(10):
|
|
value.append(self.expect_number_())
|
|
elif self.cur_token_ in ranges:
|
|
value = []
|
|
while self.next_token_ != ";":
|
|
value.append(self.expect_number_())
|
|
elif self.is_cur_keyword_("Vendor"):
|
|
value = self.expect_string_()
|
|
statements.append(
|
|
self.ast.OS2Field(key, value, location=self.cur_token_location_)
|
|
)
|
|
elif self.cur_token_ == ";":
|
|
continue
|
|
|
|
def parse_STAT_ElidedFallbackName(self):
|
|
assert self.is_cur_keyword_("ElidedFallbackName")
|
|
self.expect_symbol_("{")
|
|
names = []
|
|
while self.next_token_ != "}" or self.cur_comments_:
|
|
self.advance_lexer_()
|
|
if self.is_cur_keyword_("name"):
|
|
platformID, platEncID, langID, string = self.parse_stat_name_()
|
|
nameRecord = self.ast.STATNameStatement(
|
|
"stat",
|
|
platformID,
|
|
platEncID,
|
|
langID,
|
|
string,
|
|
location=self.cur_token_location_,
|
|
)
|
|
names.append(nameRecord)
|
|
else:
|
|
if self.cur_token_ != ";":
|
|
raise FeatureLibError(
|
|
f"Unexpected token {self.cur_token_} " f"in ElidedFallbackName",
|
|
self.cur_token_location_,
|
|
)
|
|
self.expect_symbol_("}")
|
|
if not names:
|
|
raise FeatureLibError('Expected "name"', self.cur_token_location_)
|
|
return names
|
|
|
|
def parse_STAT_design_axis(self):
|
|
assert self.is_cur_keyword_("DesignAxis")
|
|
names = []
|
|
axisTag = self.expect_tag_()
|
|
if (
|
|
axisTag not in ("ital", "opsz", "slnt", "wdth", "wght")
|
|
and not axisTag.isupper()
|
|
):
|
|
log.warning(f"Unregistered axis tag {axisTag} should be uppercase.")
|
|
axisOrder = self.expect_number_()
|
|
self.expect_symbol_("{")
|
|
while self.next_token_ != "}" or self.cur_comments_:
|
|
self.advance_lexer_()
|
|
if self.cur_token_type_ is Lexer.COMMENT:
|
|
continue
|
|
elif self.is_cur_keyword_("name"):
|
|
location = self.cur_token_location_
|
|
platformID, platEncID, langID, string = self.parse_stat_name_()
|
|
name = self.ast.STATNameStatement(
|
|
"stat", platformID, platEncID, langID, string, location=location
|
|
)
|
|
names.append(name)
|
|
elif self.cur_token_ == ";":
|
|
continue
|
|
else:
|
|
raise FeatureLibError(
|
|
f'Expected "name", got {self.cur_token_}', self.cur_token_location_
|
|
)
|
|
|
|
self.expect_symbol_("}")
|
|
return self.ast.STATDesignAxisStatement(
|
|
axisTag, axisOrder, names, self.cur_token_location_
|
|
)
|
|
|
|
def parse_STAT_axis_value_(self):
|
|
assert self.is_cur_keyword_("AxisValue")
|
|
self.expect_symbol_("{")
|
|
locations = []
|
|
names = []
|
|
flags = 0
|
|
while self.next_token_ != "}" or self.cur_comments_:
|
|
self.advance_lexer_(comments=True)
|
|
if self.cur_token_type_ is Lexer.COMMENT:
|
|
continue
|
|
elif self.is_cur_keyword_("name"):
|
|
location = self.cur_token_location_
|
|
platformID, platEncID, langID, string = self.parse_stat_name_()
|
|
name = self.ast.STATNameStatement(
|
|
"stat", platformID, platEncID, langID, string, location=location
|
|
)
|
|
names.append(name)
|
|
elif self.is_cur_keyword_("location"):
|
|
location = self.parse_STAT_location()
|
|
locations.append(location)
|
|
elif self.is_cur_keyword_("flag"):
|
|
flags = self.expect_stat_flags()
|
|
elif self.cur_token_ == ";":
|
|
continue
|
|
else:
|
|
raise FeatureLibError(
|
|
f"Unexpected token {self.cur_token_} " f"in AxisValue",
|
|
self.cur_token_location_,
|
|
)
|
|
self.expect_symbol_("}")
|
|
if not names:
|
|
raise FeatureLibError('Expected "Axis Name"', self.cur_token_location_)
|
|
if not locations:
|
|
raise FeatureLibError('Expected "Axis location"', self.cur_token_location_)
|
|
if len(locations) > 1:
|
|
for location in locations:
|
|
if len(location.values) > 1:
|
|
raise FeatureLibError(
|
|
"Only one value is allowed in a "
|
|
"Format 4 Axis Value Record, but "
|
|
f"{len(location.values)} were found.",
|
|
self.cur_token_location_,
|
|
)
|
|
format4_tags = []
|
|
for location in locations:
|
|
tag = location.tag
|
|
if tag in format4_tags:
|
|
raise FeatureLibError(
|
|
f"Axis tag {tag} already " "defined.", self.cur_token_location_
|
|
)
|
|
format4_tags.append(tag)
|
|
|
|
return self.ast.STATAxisValueStatement(
|
|
names, locations, flags, self.cur_token_location_
|
|
)
|
|
|
|
def parse_STAT_location(self):
|
|
values = []
|
|
tag = self.expect_tag_()
|
|
if len(tag.strip()) != 4:
|
|
raise FeatureLibError(
|
|
f"Axis tag {self.cur_token_} must be 4 " "characters",
|
|
self.cur_token_location_,
|
|
)
|
|
|
|
while self.next_token_ != ";":
|
|
if self.next_token_type_ is Lexer.FLOAT:
|
|
value = self.expect_float_()
|
|
values.append(value)
|
|
elif self.next_token_type_ is Lexer.NUMBER:
|
|
value = self.expect_number_()
|
|
values.append(value)
|
|
else:
|
|
raise FeatureLibError(
|
|
f'Unexpected value "{self.next_token_}". '
|
|
"Expected integer or float.",
|
|
self.next_token_location_,
|
|
)
|
|
if len(values) == 3:
|
|
nominal, min_val, max_val = values
|
|
if nominal < min_val or nominal > max_val:
|
|
raise FeatureLibError(
|
|
f"Default value {nominal} is outside "
|
|
f"of specified range "
|
|
f"{min_val}-{max_val}.",
|
|
self.next_token_location_,
|
|
)
|
|
return self.ast.AxisValueLocationStatement(tag, values)
|
|
|
|
def parse_table_STAT_(self, table):
|
|
statements = table.statements
|
|
design_axes = []
|
|
while self.next_token_ != "}" or self.cur_comments_:
|
|
self.advance_lexer_(comments=True)
|
|
if self.cur_token_type_ is Lexer.COMMENT:
|
|
statements.append(
|
|
self.ast.Comment(self.cur_token_, location=self.cur_token_location_)
|
|
)
|
|
elif self.cur_token_type_ is Lexer.NAME:
|
|
if self.is_cur_keyword_("ElidedFallbackName"):
|
|
names = self.parse_STAT_ElidedFallbackName()
|
|
statements.append(self.ast.ElidedFallbackName(names))
|
|
elif self.is_cur_keyword_("ElidedFallbackNameID"):
|
|
value = self.expect_number_()
|
|
statements.append(self.ast.ElidedFallbackNameID(value))
|
|
self.expect_symbol_(";")
|
|
elif self.is_cur_keyword_("DesignAxis"):
|
|
designAxis = self.parse_STAT_design_axis()
|
|
design_axes.append(designAxis.tag)
|
|
statements.append(designAxis)
|
|
self.expect_symbol_(";")
|
|
elif self.is_cur_keyword_("AxisValue"):
|
|
axisValueRecord = self.parse_STAT_axis_value_()
|
|
for location in axisValueRecord.locations:
|
|
if location.tag not in design_axes:
|
|
# Tag must be defined in a DesignAxis before it
|
|
# can be referenced
|
|
raise FeatureLibError(
|
|
"DesignAxis not defined for " f"{location.tag}.",
|
|
self.cur_token_location_,
|
|
)
|
|
statements.append(axisValueRecord)
|
|
self.expect_symbol_(";")
|
|
else:
|
|
raise FeatureLibError(
|
|
f"Unexpected token {self.cur_token_}", self.cur_token_location_
|
|
)
|
|
elif self.cur_token_ == ";":
|
|
continue
|
|
|
|
def parse_base_tag_list_(self):
|
|
# Parses BASE table entries. (See `section 9.a <https://adobe-type-tools.github.io/afdko/OpenTypeFeatureFileSpecification.html#9.a>`_)
|
|
assert self.cur_token_ in (
|
|
"HorizAxis.BaseTagList",
|
|
"VertAxis.BaseTagList",
|
|
), self.cur_token_
|
|
bases = []
|
|
while self.next_token_ != ";":
|
|
bases.append(self.expect_script_tag_())
|
|
self.expect_symbol_(";")
|
|
return bases
|
|
|
|
def parse_base_script_list_(self, count):
|
|
assert self.cur_token_ in (
|
|
"HorizAxis.BaseScriptList",
|
|
"VertAxis.BaseScriptList",
|
|
), self.cur_token_
|
|
scripts = [(self.parse_base_script_record_(count))]
|
|
while self.next_token_ == ",":
|
|
self.expect_symbol_(",")
|
|
scripts.append(self.parse_base_script_record_(count))
|
|
self.expect_symbol_(";")
|
|
return scripts
|
|
|
|
def parse_base_script_record_(self, count):
|
|
script_tag = self.expect_script_tag_()
|
|
base_tag = self.expect_script_tag_()
|
|
coords = [self.expect_number_() for i in range(count)]
|
|
return script_tag, base_tag, coords
|
|
|
|
def parse_device_(self):
|
|
result = None
|
|
self.expect_symbol_("<")
|
|
self.expect_keyword_("device")
|
|
if self.next_token_ == "NULL":
|
|
self.expect_keyword_("NULL")
|
|
else:
|
|
result = [(self.expect_number_(), self.expect_number_())]
|
|
while self.next_token_ == ",":
|
|
self.expect_symbol_(",")
|
|
result.append((self.expect_number_(), self.expect_number_()))
|
|
result = tuple(result) # make it hashable
|
|
self.expect_symbol_(">")
|
|
return result
|
|
|
|
def is_next_value_(self):
|
|
return (
|
|
self.next_token_type_ is Lexer.NUMBER
|
|
or self.next_token_ == "<"
|
|
or self.next_token_ == "("
|
|
)
|
|
|
|
def parse_valuerecord_(self, vertical):
|
|
if (
|
|
self.next_token_type_ is Lexer.SYMBOL and self.next_token_ == "("
|
|
) or self.next_token_type_ is Lexer.NUMBER:
|
|
number, location = (
|
|
self.expect_number_(variable=True),
|
|
self.cur_token_location_,
|
|
)
|
|
if vertical:
|
|
val = self.ast.ValueRecord(
|
|
yAdvance=number, vertical=vertical, location=location
|
|
)
|
|
else:
|
|
val = self.ast.ValueRecord(
|
|
xAdvance=number, vertical=vertical, location=location
|
|
)
|
|
return val
|
|
self.expect_symbol_("<")
|
|
location = self.cur_token_location_
|
|
if self.next_token_type_ is Lexer.NAME:
|
|
name = self.expect_name_()
|
|
if name == "NULL":
|
|
self.expect_symbol_(">")
|
|
return self.ast.ValueRecord()
|
|
vrd = self.valuerecords_.resolve(name)
|
|
if vrd is None:
|
|
raise FeatureLibError(
|
|
'Unknown valueRecordDef "%s"' % name, self.cur_token_location_
|
|
)
|
|
value = vrd.value
|
|
xPlacement, yPlacement = (value.xPlacement, value.yPlacement)
|
|
xAdvance, yAdvance = (value.xAdvance, value.yAdvance)
|
|
else:
|
|
xPlacement, yPlacement, xAdvance, yAdvance = (
|
|
self.expect_number_(variable=True),
|
|
self.expect_number_(variable=True),
|
|
self.expect_number_(variable=True),
|
|
self.expect_number_(variable=True),
|
|
)
|
|
|
|
if self.next_token_ == "<":
|
|
xPlaDevice, yPlaDevice, xAdvDevice, yAdvDevice = (
|
|
self.parse_device_(),
|
|
self.parse_device_(),
|
|
self.parse_device_(),
|
|
self.parse_device_(),
|
|
)
|
|
allDeltas = sorted(
|
|
[
|
|
delta
|
|
for size, delta in (xPlaDevice if xPlaDevice else ())
|
|
+ (yPlaDevice if yPlaDevice else ())
|
|
+ (xAdvDevice if xAdvDevice else ())
|
|
+ (yAdvDevice if yAdvDevice else ())
|
|
]
|
|
)
|
|
if allDeltas[0] < -128 or allDeltas[-1] > 127:
|
|
raise FeatureLibError(
|
|
"Device value out of valid range (-128..127)",
|
|
self.cur_token_location_,
|
|
)
|
|
else:
|
|
xPlaDevice, yPlaDevice, xAdvDevice, yAdvDevice = (None, None, None, None)
|
|
|
|
self.expect_symbol_(">")
|
|
return self.ast.ValueRecord(
|
|
xPlacement,
|
|
yPlacement,
|
|
xAdvance,
|
|
yAdvance,
|
|
xPlaDevice,
|
|
yPlaDevice,
|
|
xAdvDevice,
|
|
yAdvDevice,
|
|
vertical=vertical,
|
|
location=location,
|
|
)
|
|
|
|
def parse_valuerecord_definition_(self, vertical):
|
|
# Parses a named value record definition. (See section `2.e.v <https://adobe-type-tools.github.io/afdko/OpenTypeFeatureFileSpecification.html#2.e.v>`_)
|
|
assert self.is_cur_keyword_("valueRecordDef")
|
|
location = self.cur_token_location_
|
|
value = self.parse_valuerecord_(vertical)
|
|
name = self.expect_name_()
|
|
self.expect_symbol_(";")
|
|
vrd = self.ast.ValueRecordDefinition(name, value, location=location)
|
|
self.valuerecords_.define(name, vrd)
|
|
return vrd
|
|
|
|
def parse_languagesystem_(self):
|
|
assert self.cur_token_ == "languagesystem"
|
|
location = self.cur_token_location_
|
|
script = self.expect_script_tag_()
|
|
language = self.expect_language_tag_()
|
|
self.expect_symbol_(";")
|
|
return self.ast.LanguageSystemStatement(script, language, location=location)
|
|
|
|
def parse_feature_block_(self, variation=False):
|
|
if variation:
|
|
assert self.cur_token_ == "variation"
|
|
else:
|
|
assert self.cur_token_ == "feature"
|
|
location = self.cur_token_location_
|
|
tag = self.expect_tag_()
|
|
vertical = tag in {"vkrn", "vpal", "vhal", "valt"}
|
|
|
|
stylisticset = None
|
|
cv_feature = None
|
|
size_feature = False
|
|
if tag in self.SS_FEATURE_TAGS:
|
|
stylisticset = tag
|
|
elif tag in self.CV_FEATURE_TAGS:
|
|
cv_feature = tag
|
|
elif tag == "size":
|
|
size_feature = True
|
|
|
|
if variation:
|
|
conditionset = self.expect_name_()
|
|
|
|
use_extension = False
|
|
if self.next_token_ == "useExtension":
|
|
self.expect_keyword_("useExtension")
|
|
use_extension = True
|
|
|
|
if variation:
|
|
block = self.ast.VariationBlock(
|
|
tag, conditionset, use_extension=use_extension, location=location
|
|
)
|
|
else:
|
|
block = self.ast.FeatureBlock(
|
|
tag, use_extension=use_extension, location=location
|
|
)
|
|
self.parse_block_(block, vertical, stylisticset, size_feature, cv_feature)
|
|
return block
|
|
|
|
def parse_feature_reference_(self):
|
|
assert self.cur_token_ == "feature", self.cur_token_
|
|
location = self.cur_token_location_
|
|
featureName = self.expect_tag_()
|
|
self.expect_symbol_(";")
|
|
return self.ast.FeatureReferenceStatement(featureName, location=location)
|
|
|
|
def parse_featureNames_(self, tag):
|
|
"""Parses a ``featureNames`` statement found in stylistic set features.
|
|
See section `8.c <https://adobe-type-tools.github.io/afdko/OpenTypeFeatureFileSpecification.html#8.c>`_.
|
|
"""
|
|
assert self.cur_token_ == "featureNames", self.cur_token_
|
|
block = self.ast.NestedBlock(
|
|
tag, self.cur_token_, location=self.cur_token_location_
|
|
)
|
|
self.expect_symbol_("{")
|
|
for symtab in self.symbol_tables_:
|
|
symtab.enter_scope()
|
|
while self.next_token_ != "}" or self.cur_comments_:
|
|
self.advance_lexer_(comments=True)
|
|
if self.cur_token_type_ is Lexer.COMMENT:
|
|
block.statements.append(
|
|
self.ast.Comment(self.cur_token_, location=self.cur_token_location_)
|
|
)
|
|
elif self.is_cur_keyword_("name"):
|
|
location = self.cur_token_location_
|
|
platformID, platEncID, langID, string = self.parse_name_()
|
|
block.statements.append(
|
|
self.ast.FeatureNameStatement(
|
|
tag, platformID, platEncID, langID, string, location=location
|
|
)
|
|
)
|
|
elif self.cur_token_ == ";":
|
|
continue
|
|
else:
|
|
raise FeatureLibError('Expected "name"', self.cur_token_location_)
|
|
self.expect_symbol_("}")
|
|
for symtab in self.symbol_tables_:
|
|
symtab.exit_scope()
|
|
self.expect_symbol_(";")
|
|
return block
|
|
|
|
def parse_cvParameters_(self, tag):
|
|
# Parses a ``cvParameters`` block found in Character Variant features.
|
|
# See section `8.d <https://adobe-type-tools.github.io/afdko/OpenTypeFeatureFileSpecification.html#8.d>`_.
|
|
assert self.cur_token_ == "cvParameters", self.cur_token_
|
|
block = self.ast.NestedBlock(
|
|
tag, self.cur_token_, location=self.cur_token_location_
|
|
)
|
|
self.expect_symbol_("{")
|
|
for symtab in self.symbol_tables_:
|
|
symtab.enter_scope()
|
|
|
|
statements = block.statements
|
|
while self.next_token_ != "}" or self.cur_comments_:
|
|
self.advance_lexer_(comments=True)
|
|
if self.cur_token_type_ is Lexer.COMMENT:
|
|
statements.append(
|
|
self.ast.Comment(self.cur_token_, location=self.cur_token_location_)
|
|
)
|
|
elif self.is_cur_keyword_(
|
|
{
|
|
"FeatUILabelNameID",
|
|
"FeatUITooltipTextNameID",
|
|
"SampleTextNameID",
|
|
"ParamUILabelNameID",
|
|
}
|
|
):
|
|
statements.append(self.parse_cvNameIDs_(tag, self.cur_token_))
|
|
elif self.is_cur_keyword_("Character"):
|
|
statements.append(self.parse_cvCharacter_(tag))
|
|
elif self.cur_token_ == ";":
|
|
continue
|
|
else:
|
|
raise FeatureLibError(
|
|
"Expected statement: got {} {}".format(
|
|
self.cur_token_type_, self.cur_token_
|
|
),
|
|
self.cur_token_location_,
|
|
)
|
|
|
|
self.expect_symbol_("}")
|
|
for symtab in self.symbol_tables_:
|
|
symtab.exit_scope()
|
|
self.expect_symbol_(";")
|
|
return block
|
|
|
|
def parse_cvNameIDs_(self, tag, block_name):
|
|
assert self.cur_token_ == block_name, self.cur_token_
|
|
block = self.ast.NestedBlock(tag, block_name, location=self.cur_token_location_)
|
|
self.expect_symbol_("{")
|
|
for symtab in self.symbol_tables_:
|
|
symtab.enter_scope()
|
|
while self.next_token_ != "}" or self.cur_comments_:
|
|
self.advance_lexer_(comments=True)
|
|
if self.cur_token_type_ is Lexer.COMMENT:
|
|
block.statements.append(
|
|
self.ast.Comment(self.cur_token_, location=self.cur_token_location_)
|
|
)
|
|
elif self.is_cur_keyword_("name"):
|
|
location = self.cur_token_location_
|
|
platformID, platEncID, langID, string = self.parse_name_()
|
|
block.statements.append(
|
|
self.ast.CVParametersNameStatement(
|
|
tag,
|
|
platformID,
|
|
platEncID,
|
|
langID,
|
|
string,
|
|
block_name,
|
|
location=location,
|
|
)
|
|
)
|
|
elif self.cur_token_ == ";":
|
|
continue
|
|
else:
|
|
raise FeatureLibError('Expected "name"', self.cur_token_location_)
|
|
self.expect_symbol_("}")
|
|
for symtab in self.symbol_tables_:
|
|
symtab.exit_scope()
|
|
self.expect_symbol_(";")
|
|
return block
|
|
|
|
def parse_cvCharacter_(self, tag):
|
|
assert self.cur_token_ == "Character", self.cur_token_
|
|
location, character = self.cur_token_location_, self.expect_any_number_()
|
|
self.expect_symbol_(";")
|
|
if not (0xFFFFFF >= character >= 0):
|
|
raise FeatureLibError(
|
|
"Character value must be between "
|
|
"{:#x} and {:#x}".format(0, 0xFFFFFF),
|
|
location,
|
|
)
|
|
return self.ast.CharacterStatement(character, tag, location=location)
|
|
|
|
def parse_FontRevision_(self):
|
|
# Parses a ``FontRevision`` statement found in the head table. See
|
|
# `section 9.c <https://adobe-type-tools.github.io/afdko/OpenTypeFeatureFileSpecification.html#9.c>`_.
|
|
assert self.cur_token_ == "FontRevision", self.cur_token_
|
|
location, version = self.cur_token_location_, self.expect_float_()
|
|
self.expect_symbol_(";")
|
|
if version <= 0:
|
|
raise FeatureLibError("Font revision numbers must be positive", location)
|
|
return self.ast.FontRevisionStatement(version, location=location)
|
|
|
|
def parse_conditionset_(self):
|
|
name = self.expect_name_()
|
|
|
|
conditions = {}
|
|
self.expect_symbol_("{")
|
|
|
|
while self.next_token_ != "}":
|
|
self.advance_lexer_()
|
|
if self.cur_token_type_ is not Lexer.NAME:
|
|
raise FeatureLibError("Expected an axis name", self.cur_token_location_)
|
|
|
|
axis = self.cur_token_
|
|
if axis in conditions:
|
|
raise FeatureLibError(
|
|
f"Repeated condition for axis {axis}", self.cur_token_location_
|
|
)
|
|
|
|
if self.next_token_type_ is Lexer.FLOAT:
|
|
min_value = self.expect_float_()
|
|
elif self.next_token_type_ is Lexer.NUMBER:
|
|
min_value = self.expect_number_(variable=False)
|
|
|
|
if self.next_token_type_ is Lexer.FLOAT:
|
|
max_value = self.expect_float_()
|
|
elif self.next_token_type_ is Lexer.NUMBER:
|
|
max_value = self.expect_number_(variable=False)
|
|
self.expect_symbol_(";")
|
|
|
|
conditions[axis] = (min_value, max_value)
|
|
|
|
self.expect_symbol_("}")
|
|
|
|
finalname = self.expect_name_()
|
|
if finalname != name:
|
|
raise FeatureLibError('Expected "%s"' % name, self.cur_token_location_)
|
|
return self.ast.ConditionsetStatement(name, conditions)
|
|
|
|
def parse_block_(
|
|
self, block, vertical, stylisticset=None, size_feature=False, cv_feature=None
|
|
):
|
|
self.expect_symbol_("{")
|
|
for symtab in self.symbol_tables_:
|
|
symtab.enter_scope()
|
|
|
|
statements = block.statements
|
|
while self.next_token_ != "}" or self.cur_comments_:
|
|
self.advance_lexer_(comments=True)
|
|
if self.cur_token_type_ is Lexer.COMMENT:
|
|
statements.append(
|
|
self.ast.Comment(self.cur_token_, location=self.cur_token_location_)
|
|
)
|
|
elif self.cur_token_type_ is Lexer.GLYPHCLASS:
|
|
statements.append(self.parse_glyphclass_definition_())
|
|
elif self.is_cur_keyword_("anchorDef"):
|
|
statements.append(self.parse_anchordef_())
|
|
elif self.is_cur_keyword_({"enum", "enumerate"}):
|
|
statements.append(self.parse_enumerate_(vertical=vertical))
|
|
elif self.is_cur_keyword_("feature"):
|
|
statements.append(self.parse_feature_reference_())
|
|
elif self.is_cur_keyword_("ignore"):
|
|
statements.append(self.parse_ignore_())
|
|
elif self.is_cur_keyword_("language"):
|
|
statements.append(self.parse_language_())
|
|
elif self.is_cur_keyword_("lookup"):
|
|
statements.append(self.parse_lookup_(vertical))
|
|
elif self.is_cur_keyword_("lookupflag"):
|
|
statements.append(self.parse_lookupflag_())
|
|
elif self.is_cur_keyword_("markClass"):
|
|
statements.append(self.parse_markClass_())
|
|
elif self.is_cur_keyword_({"pos", "position"}):
|
|
statements.append(
|
|
self.parse_position_(enumerated=False, vertical=vertical)
|
|
)
|
|
elif self.is_cur_keyword_("script"):
|
|
statements.append(self.parse_script_())
|
|
elif self.is_cur_keyword_({"sub", "substitute", "rsub", "reversesub"}):
|
|
statements.append(self.parse_substitute_())
|
|
elif self.is_cur_keyword_("subtable"):
|
|
statements.append(self.parse_subtable_())
|
|
elif self.is_cur_keyword_("valueRecordDef"):
|
|
statements.append(self.parse_valuerecord_definition_(vertical))
|
|
elif stylisticset and self.is_cur_keyword_("featureNames"):
|
|
statements.append(self.parse_featureNames_(stylisticset))
|
|
elif cv_feature and self.is_cur_keyword_("cvParameters"):
|
|
statements.append(self.parse_cvParameters_(cv_feature))
|
|
elif size_feature and self.is_cur_keyword_("parameters"):
|
|
statements.append(self.parse_size_parameters_())
|
|
elif size_feature and self.is_cur_keyword_("sizemenuname"):
|
|
statements.append(self.parse_size_menuname_())
|
|
elif (
|
|
self.cur_token_type_ is Lexer.NAME
|
|
and self.cur_token_ in self.extensions
|
|
):
|
|
statements.append(self.extensions[self.cur_token_](self))
|
|
elif self.cur_token_ == ";":
|
|
continue
|
|
else:
|
|
raise FeatureLibError(
|
|
"Expected glyph class definition or statement: got {} {}".format(
|
|
self.cur_token_type_, self.cur_token_
|
|
),
|
|
self.cur_token_location_,
|
|
)
|
|
|
|
self.expect_symbol_("}")
|
|
for symtab in self.symbol_tables_:
|
|
symtab.exit_scope()
|
|
|
|
name = self.expect_name_()
|
|
if name != block.name.strip():
|
|
raise FeatureLibError(
|
|
'Expected "%s"' % block.name.strip(), self.cur_token_location_
|
|
)
|
|
self.expect_symbol_(";")
|
|
|
|
# A multiple substitution may have a single destination, in which case
|
|
# it will look just like a single substitution. So if there are both
|
|
# multiple and single substitutions, upgrade all the single ones to
|
|
# multiple substitutions.
|
|
|
|
# Check if we have a mix of non-contextual singles and multiples.
|
|
has_single = False
|
|
has_multiple = False
|
|
for s in statements:
|
|
if isinstance(s, self.ast.SingleSubstStatement):
|
|
has_single = not any([s.prefix, s.suffix, s.forceChain])
|
|
elif isinstance(s, self.ast.MultipleSubstStatement):
|
|
has_multiple = not any([s.prefix, s.suffix, s.forceChain])
|
|
|
|
# Upgrade all single substitutions to multiple substitutions.
|
|
if has_single and has_multiple:
|
|
statements = []
|
|
for s in block.statements:
|
|
if isinstance(s, self.ast.SingleSubstStatement):
|
|
glyphs = s.glyphs[0].glyphSet()
|
|
replacements = s.replacements[0].glyphSet()
|
|
if len(replacements) == 1:
|
|
replacements *= len(glyphs)
|
|
for i, glyph in enumerate(glyphs):
|
|
statements.append(
|
|
self.ast.MultipleSubstStatement(
|
|
s.prefix,
|
|
glyph,
|
|
s.suffix,
|
|
[replacements[i]],
|
|
s.forceChain,
|
|
location=s.location,
|
|
)
|
|
)
|
|
else:
|
|
statements.append(s)
|
|
block.statements = statements
|
|
|
|
def is_cur_keyword_(self, k):
|
|
if self.cur_token_type_ is Lexer.NAME:
|
|
if isinstance(k, type("")): # basestring is gone in Python3
|
|
return self.cur_token_ == k
|
|
else:
|
|
return self.cur_token_ in k
|
|
return False
|
|
|
|
def expect_class_name_(self):
|
|
self.advance_lexer_()
|
|
if self.cur_token_type_ is not Lexer.GLYPHCLASS:
|
|
raise FeatureLibError("Expected @NAME", self.cur_token_location_)
|
|
return self.cur_token_
|
|
|
|
def expect_cid_(self):
|
|
self.advance_lexer_()
|
|
if self.cur_token_type_ is Lexer.CID:
|
|
return self.cur_token_
|
|
raise FeatureLibError("Expected a CID", self.cur_token_location_)
|
|
|
|
def expect_filename_(self):
|
|
self.advance_lexer_()
|
|
if self.cur_token_type_ is not Lexer.FILENAME:
|
|
raise FeatureLibError("Expected file name", self.cur_token_location_)
|
|
return self.cur_token_
|
|
|
|
def expect_glyph_(self):
|
|
self.advance_lexer_()
|
|
if self.cur_token_type_ is Lexer.NAME:
|
|
return self.cur_token_.lstrip("\\")
|
|
elif self.cur_token_type_ is Lexer.CID:
|
|
return "cid%05d" % self.cur_token_
|
|
raise FeatureLibError("Expected a glyph name or CID", self.cur_token_location_)
|
|
|
|
def check_glyph_name_in_glyph_set(self, *names):
|
|
"""Adds a glyph name (just `start`) or glyph names of a
|
|
range (`start` and `end`) which are not in the glyph set
|
|
to the "missing list" for future error reporting.
|
|
|
|
If no glyph set is present, does nothing.
|
|
"""
|
|
if self.glyphNames_:
|
|
for name in names:
|
|
if name in self.glyphNames_:
|
|
continue
|
|
if name not in self.missing:
|
|
self.missing[name] = self.cur_token_location_
|
|
|
|
def expect_markClass_reference_(self):
|
|
name = self.expect_class_name_()
|
|
mc = self.glyphclasses_.resolve(name)
|
|
if mc is None:
|
|
raise FeatureLibError(
|
|
"Unknown markClass @%s" % name, self.cur_token_location_
|
|
)
|
|
if not isinstance(mc, self.ast.MarkClass):
|
|
raise FeatureLibError(
|
|
"@%s is not a markClass" % name, self.cur_token_location_
|
|
)
|
|
return mc
|
|
|
|
def expect_tag_(self):
|
|
self.advance_lexer_()
|
|
if self.cur_token_type_ is not Lexer.NAME:
|
|
raise FeatureLibError("Expected a tag", self.cur_token_location_)
|
|
if len(self.cur_token_) > 4:
|
|
raise FeatureLibError(
|
|
"Tags cannot be longer than 4 characters", self.cur_token_location_
|
|
)
|
|
return (self.cur_token_ + " ")[:4]
|
|
|
|
def expect_script_tag_(self):
|
|
tag = self.expect_tag_()
|
|
if tag == "dflt":
|
|
raise FeatureLibError(
|
|
'"dflt" is not a valid script tag; use "DFLT" instead',
|
|
self.cur_token_location_,
|
|
)
|
|
return tag
|
|
|
|
def expect_language_tag_(self):
|
|
tag = self.expect_tag_()
|
|
if tag == "DFLT":
|
|
raise FeatureLibError(
|
|
'"DFLT" is not a valid language tag; use "dflt" instead',
|
|
self.cur_token_location_,
|
|
)
|
|
return tag
|
|
|
|
def expect_symbol_(self, symbol):
|
|
self.advance_lexer_()
|
|
if self.cur_token_type_ is Lexer.SYMBOL and self.cur_token_ == symbol:
|
|
return symbol
|
|
raise FeatureLibError("Expected '%s'" % symbol, self.cur_token_location_)
|
|
|
|
def expect_keyword_(self, keyword):
|
|
self.advance_lexer_()
|
|
if self.cur_token_type_ is Lexer.NAME and self.cur_token_ == keyword:
|
|
return self.cur_token_
|
|
raise FeatureLibError('Expected "%s"' % keyword, self.cur_token_location_)
|
|
|
|
def expect_name_(self):
|
|
self.advance_lexer_()
|
|
if self.cur_token_type_ is Lexer.NAME:
|
|
return self.cur_token_
|
|
raise FeatureLibError("Expected a name", self.cur_token_location_)
|
|
|
|
def expect_number_(self, variable=False):
|
|
self.advance_lexer_()
|
|
if self.cur_token_type_ is Lexer.NUMBER:
|
|
return self.cur_token_
|
|
if variable and self.cur_token_type_ is Lexer.SYMBOL and self.cur_token_ == "(":
|
|
return self.expect_variable_scalar_()
|
|
raise FeatureLibError("Expected a number", self.cur_token_location_)
|
|
|
|
def expect_variable_scalar_(self):
|
|
self.advance_lexer_() # "("
|
|
scalar = VariableScalar()
|
|
while True:
|
|
if self.cur_token_type_ == Lexer.SYMBOL and self.cur_token_ == ")":
|
|
break
|
|
location, value = self.expect_master_()
|
|
scalar.add_value(location, value)
|
|
return scalar
|
|
|
|
def expect_master_(self):
|
|
location = {}
|
|
while True:
|
|
if self.cur_token_type_ is not Lexer.NAME:
|
|
raise FeatureLibError("Expected an axis name", self.cur_token_location_)
|
|
axis = self.cur_token_
|
|
self.advance_lexer_()
|
|
if not (self.cur_token_type_ is Lexer.SYMBOL and self.cur_token_ == "="):
|
|
raise FeatureLibError(
|
|
"Expected an equals sign", self.cur_token_location_
|
|
)
|
|
value = self.expect_number_()
|
|
location[axis] = value
|
|
if self.next_token_type_ is Lexer.NAME and self.next_token_[0] == ":":
|
|
# Lexer has just read the value as a glyph name. We'll correct it later
|
|
break
|
|
self.advance_lexer_()
|
|
if not (self.cur_token_type_ is Lexer.SYMBOL and self.cur_token_ == ","):
|
|
raise FeatureLibError(
|
|
"Expected an comma or an equals sign", self.cur_token_location_
|
|
)
|
|
self.advance_lexer_()
|
|
self.advance_lexer_()
|
|
value = int(self.cur_token_[1:])
|
|
self.advance_lexer_()
|
|
return location, value
|
|
|
|
def expect_any_number_(self):
|
|
self.advance_lexer_()
|
|
if self.cur_token_type_ in Lexer.NUMBERS:
|
|
return self.cur_token_
|
|
raise FeatureLibError(
|
|
"Expected a decimal, hexadecimal or octal number", self.cur_token_location_
|
|
)
|
|
|
|
def expect_float_(self):
|
|
self.advance_lexer_()
|
|
if self.cur_token_type_ is Lexer.FLOAT:
|
|
return self.cur_token_
|
|
raise FeatureLibError(
|
|
"Expected a floating-point number", self.cur_token_location_
|
|
)
|
|
|
|
def expect_decipoint_(self):
|
|
if self.next_token_type_ == Lexer.FLOAT:
|
|
return self.expect_float_()
|
|
elif self.next_token_type_ is Lexer.NUMBER:
|
|
return self.expect_number_() / 10
|
|
else:
|
|
raise FeatureLibError(
|
|
"Expected an integer or floating-point number", self.cur_token_location_
|
|
)
|
|
|
|
def expect_stat_flags(self):
|
|
value = 0
|
|
flags = {
|
|
"OlderSiblingFontAttribute": 1,
|
|
"ElidableAxisValueName": 2,
|
|
}
|
|
while self.next_token_ != ";":
|
|
if self.next_token_ in flags:
|
|
name = self.expect_name_()
|
|
value = value | flags[name]
|
|
else:
|
|
raise FeatureLibError(
|
|
f"Unexpected STAT flag {self.cur_token_}", self.cur_token_location_
|
|
)
|
|
return value
|
|
|
|
def expect_stat_values_(self):
|
|
if self.next_token_type_ == Lexer.FLOAT:
|
|
return self.expect_float_()
|
|
elif self.next_token_type_ is Lexer.NUMBER:
|
|
return self.expect_number_()
|
|
else:
|
|
raise FeatureLibError(
|
|
"Expected an integer or floating-point number", self.cur_token_location_
|
|
)
|
|
|
|
def expect_string_(self):
|
|
self.advance_lexer_()
|
|
if self.cur_token_type_ is Lexer.STRING:
|
|
return self.cur_token_
|
|
raise FeatureLibError("Expected a string", self.cur_token_location_)
|
|
|
|
def advance_lexer_(self, comments=False):
|
|
if comments and self.cur_comments_:
|
|
self.cur_token_type_ = Lexer.COMMENT
|
|
self.cur_token_, self.cur_token_location_ = self.cur_comments_.pop(0)
|
|
return
|
|
else:
|
|
self.cur_token_type_, self.cur_token_, self.cur_token_location_ = (
|
|
self.next_token_type_,
|
|
self.next_token_,
|
|
self.next_token_location_,
|
|
)
|
|
while True:
|
|
try:
|
|
(
|
|
self.next_token_type_,
|
|
self.next_token_,
|
|
self.next_token_location_,
|
|
) = next(self.lexer_)
|
|
except StopIteration:
|
|
self.next_token_type_, self.next_token_ = (None, None)
|
|
if self.next_token_type_ != Lexer.COMMENT:
|
|
break
|
|
self.cur_comments_.append((self.next_token_, self.next_token_location_))
|
|
|
|
@staticmethod
|
|
def reverse_string_(s):
|
|
"""'abc' --> 'cba'"""
|
|
return "".join(reversed(list(s)))
|
|
|
|
def make_cid_range_(self, location, start, limit):
|
|
"""(location, 999, 1001) --> ["cid00999", "cid01000", "cid01001"]"""
|
|
result = list()
|
|
if start > limit:
|
|
raise FeatureLibError(
|
|
"Bad range: start should be less than limit", location
|
|
)
|
|
for cid in range(start, limit + 1):
|
|
result.append("cid%05d" % cid)
|
|
return result
|
|
|
|
def make_glyph_range_(self, location, start, limit):
|
|
"""(location, "a.sc", "d.sc") --> ["a.sc", "b.sc", "c.sc", "d.sc"]"""
|
|
result = list()
|
|
if len(start) != len(limit):
|
|
raise FeatureLibError(
|
|
'Bad range: "%s" and "%s" should have the same length' % (start, limit),
|
|
location,
|
|
)
|
|
|
|
rev = self.reverse_string_
|
|
prefix = os.path.commonprefix([start, limit])
|
|
suffix = rev(os.path.commonprefix([rev(start), rev(limit)]))
|
|
if len(suffix) > 0:
|
|
start_range = start[len(prefix) : -len(suffix)]
|
|
limit_range = limit[len(prefix) : -len(suffix)]
|
|
else:
|
|
start_range = start[len(prefix) :]
|
|
limit_range = limit[len(prefix) :]
|
|
|
|
if start_range >= limit_range:
|
|
raise FeatureLibError(
|
|
"Start of range must be smaller than its end", location
|
|
)
|
|
|
|
uppercase = re.compile(r"^[A-Z]$")
|
|
if uppercase.match(start_range) and uppercase.match(limit_range):
|
|
for c in range(ord(start_range), ord(limit_range) + 1):
|
|
result.append("%s%c%s" % (prefix, c, suffix))
|
|
return result
|
|
|
|
lowercase = re.compile(r"^[a-z]$")
|
|
if lowercase.match(start_range) and lowercase.match(limit_range):
|
|
for c in range(ord(start_range), ord(limit_range) + 1):
|
|
result.append("%s%c%s" % (prefix, c, suffix))
|
|
return result
|
|
|
|
digits = re.compile(r"^[0-9]{1,3}$")
|
|
if digits.match(start_range) and digits.match(limit_range):
|
|
for i in range(int(start_range, 10), int(limit_range, 10) + 1):
|
|
number = ("000" + str(i))[-len(start_range) :]
|
|
result.append("%s%s%s" % (prefix, number, suffix))
|
|
return result
|
|
|
|
raise FeatureLibError('Bad range: "%s-%s"' % (start, limit), location)
|
|
|
|
|
|
class SymbolTable(object):
|
|
def __init__(self):
|
|
self.scopes_ = [{}]
|
|
|
|
def enter_scope(self):
|
|
self.scopes_.append({})
|
|
|
|
def exit_scope(self):
|
|
self.scopes_.pop()
|
|
|
|
def define(self, name, item):
|
|
self.scopes_[-1][name] = item
|
|
|
|
def resolve(self, name):
|
|
for scope in reversed(self.scopes_):
|
|
item = scope.get(name)
|
|
if item:
|
|
return item
|
|
return None
|