def __new__(cls, *args):
"""
This constructor can be used in the grammar to create a parser for this
AST node.
"""
from langkit.parsers import _Row, _Transform
return _Transform(_Row(*args), T.Defer(cls._resolve, cls._name.camel))
def _create_parser(cls, typeref, *args):
"""
Construct a parser for this EnumNode subclass.
"""
from langkit.parsers import _Row, _Transform, Opt
if cls._qualifier:
# If the node is a boolean node, then we want to parse the
# sub-parsers as an optional parser that will be booleanized.
return Opt(*args).as_bool(cls)
else:
# Otherwise, we want to parse the sub-parsers as a row + transform
return _Transform(_Row(*args), typeref)
def create_parser_enum_node(cls, alt_typeref, *args):
# Otherwise, we want to parse the sub-parsers as a row + transform
return _Transform(_Row(*args), alt_typeref)
def lower(rule):
"""
Helper to lower one parser.
:param liblktlang.GrammarExpr rule: Grammar rule to lower.
:rtype: Parser
"""
# For convenience, accept null input rules, as we generally want to
# forward them as-is to the lower level parsing machinery.
if rule is None:
return None
loc = ctx.lkt_loc(rule)
with ctx.lkt_context(rule):
if isinstance(rule, liblktlang.ParseNodeExpr):
node = resolve_node_ref(rule.f_node_name)
# Lower the subparsers
subparsers = [
lower(subparser) for subparser in rule.f_sub_exprs
]
# Qualifier nodes are a special case: we produce one subclass
# or the other depending on whether the subparsers accept the
# input.
if node._type.is_bool_node:
return Opt(*subparsers, location=loc).as_bool(node)
# Likewise for enum nodes
elif node._type.base and node._type.base.is_enum_node:
return _Transform(_Row(*subparsers, location=loc),
node.type_ref,
location=loc)
# For other nodes, always create the node when the subparsers
# accept the input.
else:
return _Transform(parser=_Row(*subparsers),
typ=node,
location=loc)
elif isinstance(rule, liblktlang.GrammarToken):
token_name = rule.f_token_name.text
try:
val = tokens[token_name]
except KeyError:
check_source_language(
False, 'Unknown token: {}'.format(token_name))
match_text = ''
if rule.f_expr:
# The grammar is supposed to mainain this invariant
assert isinstance(rule.f_expr, liblktlang.TokenLit)
match_text = denoted_string_literal(rule.f_expr)
return _Token(val=val, match_text=match_text, location=loc)
elif isinstance(rule, liblktlang.TokenLit):
return _Token(denoted_string_literal(rule), location=loc)
elif isinstance(rule, liblktlang.GrammarList):
return List(lower(rule.f_expr),
empty_valid=rule.f_kind.text == '*',
list_cls=resolve_node_ref(rule.f_list_type),
sep=lower(rule.f_sep),
location=loc)
elif isinstance(
rule,
(liblktlang.GrammarImplicitPick, liblktlang.GrammarPick)):
return Pick(*[lower(subparser) for subparser in rule.f_exprs],
location=loc)
elif isinstance(rule, liblktlang.GrammarRuleRef):
return getattr(grammar, rule.f_node_name.text)
elif isinstance(rule, liblktlang.GrammarOrExpr):
return Or(
*[lower(subparser) for subparser in rule.f_sub_exprs],
location=loc)
elif isinstance(rule, liblktlang.GrammarOpt):
return Opt(lower(rule.f_expr), location=loc)
elif isinstance(rule, liblktlang.GrammarOptGroup):
return Opt(*[lower(subparser) for subparser in rule.f_expr],
location=loc)
elif isinstance(rule, liblktlang.GrammarExprList):
return Pick(*[lower(subparser) for subparser in rule],
location=loc)
elif isinstance(rule, liblktlang.GrammarDiscard):
return Discard(lower(rule.f_expr), location=loc)
elif isinstance(rule, liblktlang.GrammarNull):
return Null(resolve_node_ref(rule.f_name), location=loc)
elif isinstance(rule, liblktlang.GrammarSkip):
return Skip(resolve_node_ref(rule.f_name), location=loc)
elif isinstance(rule, liblktlang.GrammarDontSkip):
return DontSkip(lower(rule.f_expr),
lower(rule.f_dont_skip),
location=loc)
elif isinstance(rule, liblktlang.GrammarPredicate):
check_source_language(
isinstance(rule.f_prop_ref, liblktlang.DotExpr),
'Invalid property reference')
node = resolve_node_ref(rule.f_prop_ref.f_prefix)
prop_name = rule.f_prop_ref.f_suffix.text
try:
prop = getattr(node, prop_name)
except AttributeError:
check_source_language(
False, '{} has no {} property'.format(
node._name.camel_with_underscores, prop_name))
return Predicate(lower(rule.f_expr), prop, location=loc)
else:
raise NotImplementedError('unhandled parser: {}'.format(rule))
