def run(name, prop):
print('== {} =='.format(name))
class FooNode(ASTNode):
resolve_ref = prop
class Decl(FooNode):
name = Field()
refs = Field()
env_spec = EnvSpec(
add_to_env(New(T.env_assoc, key=Self.name.symbol, val=Self)),
add_env())
class Ref(FooNode):
name = Field()
env_spec = EnvSpec(
add_to_env(New(T.env_assoc, key=Self.name.symbol, val=Self),
resolver=FooNode.resolve_ref))
@langkit_property(public=True)
def resolve():
return Self.node_env.get(Self.name.symbol).at(0)
grammar = Grammar('main_rule')
grammar.add_rules(
main_rule=List(grammar.decl),
decl=Decl(Tok(Token.Identifier, keep=True), Tok(Token.LPar),
List(grammar.ref, empty_valid=True), Tok(Token.RPar)),
ref=Ref(Tok(Token.Identifier, keep=True)),
)
emit_and_print_errors(grammar)
def run(name, lhs, rhs):
"""
Emit and print the errors we get for the below grammar with "expr" as
a property in Example.
"""
global FooNode, BarNode, ListNode
print('== {} =='.format(name))
class FooNode(ASTNode):
pass
class Example(FooNode):
prop = Property(lhs.equals(rhs), dynamic_vars=[Env])
use_prop = Property(Env.bind(Self.node_env, Self.prop), public=True)
class Lit(FooNode):
tok = Field()
grammar = Grammar('main_rule')
grammar.add_rules(main_rule=Or(Example(Tok(Token.Example)),
Lit(Tok(Token.Number, keep=True))), )
emit_and_print_errors(grammar)
Env.unfreeze()
print('')
def lang_def():
foo_grammar = Grammar('main_rule')
foo_grammar.add_rules(
main_rule=Example('example', Opt(foo_grammar.name)),
name=Name(Tok(Token.Identifier, keep=True)),
)
return foo_grammar
def run(name, prop_fn, prop_memoized):
"""
Emit and print the errors we get for the below grammar with "expr" as
a property in BarNode.
"""
print('== {} =='.format(name))
class FooNode(ASTNode):
pass
class Literal(FooNode):
tok = Field()
class EmptyNode(FooNode):
pass
class LiteralList(Literal.list):
prop = Property(prop_fn(), memoized=prop_memoized)
grammar = Grammar('main_rule')
grammar.add_rules(
main_rule=grammar.list_rule,
list_rule=Pick('(', List(grammar.list_item, sep=',', cls=LiteralList),
')'),
list_item=Literal(Tok(Token.Number, keep=True)),
)
emit_and_print_errors(grammar)
print('')
def run(name, expr_fn):
"""
Emit and print the errors we get for the below grammar with "expr_fn" as a
property in Example.
"""
print('== {} =='.format(name))
@abstract
class FooNode(ASTNode):
pass
class Example(FooNode):
name = Field()
prop = Property(expr_fn)
class Name(FooNode):
tok = Field()
grammar = Grammar('main_rule')
grammar.add_rules(
main_rule=Example('example', Opt(grammar.name)),
name=Name(Tok(Token.Identifier, keep=True)),
)
emit_and_print_errors(grammar)
print('')
def run(expr):
"""
Emit and print the errors we get for the below grammar for the given
"expr" property expression.
"""
print('== {} =='.format(expr))
class FooNode(ASTNode):
pass
class ExampleNode(FooNode):
tok = Field()
implicit_prop = Property(Self.as_bare_entity, dynamic_vars=[Env])
prop = Property(expr, public=True)
use_implicit_prop = Property(
Env.bind(Self.node_env, Self.implicit_prop),
public=True
)
grammar = Grammar('main_rule')
grammar.add_rules(
main_rule=ExampleNode(Tok('example', keep=True)),
)
emit_and_print_errors(grammar)
Env.unfreeze()
print('')
def run(name, expr):
"""
Emit and print the errors we get for the below grammar with "expr" as
a property in BarNode.
"""
global FooNode
print('== {} =='.format(name))
class FooNode(ASTNode):
pass
class BarNode(FooNode):
list_node = Field()
class ListNode(FooNode):
nb_list = Field()
prop = Property(expr, public=True)
class NumberNode(FooNode):
tok = Field()
grammar = Grammar('main_rule')
grammar.add_rules(
main_rule=BarNode('example', grammar.list_rule),
list_rule=ListNode(List(NumberNode(Tok(Token.Number, keep=True)))),
)
emit_and_print_errors(grammar)
print('')
def lang_def():
foo_grammar = Grammar('main_rule')
foo_grammar.add_rules(
main_rule=Row('example', foo_grammar.list_rule) ^ BarNode,
list_rule=Row(
List(Tok(Token.Number, keep=True) ^ NumberNode)
) ^ ListNode,
)
return foo_grammar
def run(name, match_expr):
"""
Emit and print the errors we get for the below grammar with "match_expr" as
a property in ExampleNode.
"""
global BodyNode, Compound, Expression, FooNode, NullNode, Number
print('== {} =='.format(name))
@abstract
class FooNode(ASTNode):
prop = Property(Literal(0), public=True)
@abstract
class BodyNode(FooNode):
pass
class NullNode(BodyNode):
pass
@abstract
class Expression(BodyNode):
pass
class Number(Expression):
tok = Field()
class Compound(Expression):
prefix = Field()
suffix = Field()
class ExampleNode(FooNode):
body = Field()
prop = Property(match_expr)
grammar = Grammar('main_rule')
grammar.add_rules(
main_rule=ExampleNode(
'example',
Or(
grammar.expression,
NullNode('null')
)
),
number=Number(Tok(Token.Number, keep=True)),
expression=Or(
Compound(grammar.number, ',', grammar.expression),
grammar.number
),
)
emit_and_print_errors(grammar)
print('')
def lang_def():
foo_grammar = Grammar('stmts_rule')
foo_grammar.add_rules(
def_rule=Row(Tok(Token.Identifier, keep=True),
Opt(Row('(', foo_grammar.stmts_rule, ')')[1])) ^ Def,
stmt_rule=(foo_grammar.def_rule
| Row('{', List(foo_grammar.stmt_rule, empty_valid=True),
'}') ^ Block),
stmts_rule=List(foo_grammar.stmt_rule))
return foo_grammar
def lang_def():
foo_grammar = Grammar('main_rule')
foo_grammar.add_rules(
main_rule=foo_grammar.list_rule,
list_rule=Row(
'(', List(foo_grammar.list_item, sep=',', cls=LiteralList),
')')[0],
list_item=Row(Tok(Token.Number, keep=True)) ^ Literal,
)
return foo_grammar
def lang_def():
foo_grammar = Grammar('main_rule')
foo_grammar.add_rules(
main_rule=Row('example',
Or(foo_grammar.expression,
Row('null') ^ NullNode)) ^ ExampleNode,
number=Tok(Token.Number, keep=True) ^ Number,
expression=Or(
Row(foo_grammar.number, ',', foo_grammar.expression)
^ Compound, foo_grammar.number),
)
return foo_grammar
def lang_def():
@root_grammar_class()
class FooNode(ASTNode):
pass
class Def(FooNode):
name = Field()
body = Field()
env_spec = EnvSpec(add_env=True, add_to_env=(Self.name, Self))
foo_grammar = Grammar('stmt_rule')
foo_grammar.add_rules(
def_rule=Row(
Tok(Token.Identifier, keep=True),
'(', foo_grammar.stmt_rule, ')'
) ^ Def,
stmt_rule=List(
foo_grammar.def_rule
| Row('{', List(foo_grammar.stmt_rule, empty_valid=True), '}')[1],
empty_valid=True
)
)
return foo_grammar
def run(md_constructor):
"""
Emit and print he errors we get for the below grammar. `md_constructor` is
called to create the lexical environment metadata.
"""
print('== {} =='.format(md_constructor.__name__))
class FooNode(ASTNode):
pass
class Example(FooNode):
pass
grammar = Grammar('main_rule')
grammar.add_rules(main_rule=Example(Tok(Token.Example)))
try:
md_constructor()
except DiagnosticError:
reset_langkit()
else:
emit_and_print_errors(grammar)
print('')
from langkit.expressions import DynamicVariable, Property, Self
from langkit.parsers import Grammar, Tok
from lexer_example import Token
from utils import emit_and_print_errors
dynvar = DynamicVariable('dynvar', T.FooNode)
class FooNode(ASTNode):
pass
class Example(FooNode):
tok = Field()
# The "construct" pass on p1 will require the type of p2 and thus trigger
# the construction of p2. A bug used to propagate the binding of "dynvar"
# from the construction of p1 to p2's.
p1 = Property(dynvar.bind(Self, Self.p2).as_bare_entity, public=True)
p2 = Property(dynvar)
grammar = Grammar('main_rule')
grammar.add_rules(
main_rule=Example(Tok(Token.Example, keep=True)),
)
emit_and_print_errors(grammar)
print('Done')
class Ref(FooNode):
name = Field()
env_spec = EnvSpec(
add_to_env(
New(T.env_assoc, key=Self.name.symbol, val=Self),
)
)
@langkit_property(public=True)
def resolve():
return Env.bind(Self.parent.parent.node_env,
Env.get(Self.name.symbol).at(0))
foo_grammar = Grammar('main_rule')
foo_grammar.add_rules(
main_rule=List(foo_grammar.decl),
decl=Decl(
Tok(Token.Identifier, keep=True),
Tok(Token.LPar),
List(foo_grammar.ref, empty_valid=True),
Tok(Token.RPar)
),
ref=Ref(Tok(Token.Identifier, keep=True)),
)
build_and_run(foo_grammar, 'main.py')
print('Done')
class Ref(Atom):
tok = Field()
prop1 = Property(3)
prop2 = Property(3)
prop3 = Property(3)
class Plus(Expr):
lhs = Field()
rhs = Field()
prop1 = Property(4)
prop2 = Property(4)
prop3 = Property(4)
grammar = Grammar('main_rule')
grammar.add_rules(
main_rule=List(grammar.expr),
expr=Or(grammar.atom, grammar.plus),
atom=Or(grammar.lit, grammar.ref),
lit=Lit(Tok(Token.Number, keep=True)),
ref=Ref(Tok(Token.Identifier, keep=True)),
plus=Pick('(', Plus(grammar.expr, '+', grammar.expr), ')'),
)
emit_and_print_errors(grammar)
print('Done')
env_spec = EnvSpec(
add_to_env(mappings=New(T.env_assoc, key=Self.name.symbol, val=Self)),
add_env(),
reference(Self.imports.map(lambda i: i.cast(T.FooNode)),
# If PropertyDef rewriting omits the following references,
# env lookup will never reach DerivedRef.referenced_env, so
# resolution will sometimes fail to reach definition.
T.MiddleRef.referenced_env)
)
grammar = Grammar('main_rule')
grammar.add_rules(
main_rule=List(Or(
Def('def', Tok(Token.Identifier, keep=True),
grammar.imports, grammar.vars, grammar.expr),
grammar.expr
)),
imports=Pick('(', List(grammar.derived_ref, empty_valid=True), ')'),
var=Var(Tok(Token.Identifier, keep=True), '=', grammar.expr),
vars=Pick('{', List(grammar.var, empty_valid=True), '}'),
expr=Or(grammar.atom, grammar.plus),
atom=Or(grammar.lit, grammar.ref),
lit=Lit(Tok(Token.Number, keep=True)),
ref=Ref(Tok(Token.Identifier, keep=True)),
derived_ref=DerivedRef(Tok(Token.Identifier, keep=True)),
pass
@abstract
class Expression(FooNode):
result = AbstractProperty(type=LongType)
class Literal(Expression):
tok = Field()
result = ExternalProperty()
class Plus(Expression):
left = Field()
right = Field()
result = Property(Self.left.result + Self.right.result)
foo_grammar = Grammar('main_rule')
foo_grammar.add_rules(
main_rule=Or(
Row(foo_grammar.atom, '+', foo_grammar.main_rule) ^ Plus,
foo_grammar.atom),
atom=Row(Tok(Token.Number, keep=True)) ^ Literal,
)
build_and_run(foo_grammar, 'main.py')
print 'Done'
result = ExternalProperty(uses_entity_info=False, uses_envs=False)
class Name(Expression):
tok = Field()
designated_unit = ExternalProperty(type=AnalysisUnitType,
uses_entity_info=False,
uses_envs=True)
result = Property(Self.designated_unit.root.cast(Expression).result)
class Plus(Expression):
left = Field()
right = Field()
result = Property(Self.left.result + Self.right.result)
foo_grammar = Grammar('main_rule')
foo_grammar.add_rules(
main_rule=Or(Plus(foo_grammar.atom, '+', foo_grammar.main_rule),
foo_grammar.atom),
atom=Or(
Literal(Tok(Token.Number, keep=True)),
Name(Tok(Token.Identifier, keep=True)),
),
)
build_and_run(foo_grammar, 'main.py')
print('Done')
from lexer_example import Token
from utils import build_and_run
class FooNode(ASTNode):
prop = AbstractProperty(runtime_check=True, type=LongType, public=True)
class Literal(FooNode):
tok = Field()
a = AbstractProperty(runtime_check=True, type=FooNode.entity)
var = UserField(LogicVarType, public=False)
@langkit_property(return_type=T.Literal.entity)
def node():
return Self.as_entity
b = Property(Bind(Self.var, Self.a, Self.node))
@langkit_property(public=True)
def public_pro():
return Let(lambda _=Self.b: Self.as_bare_entity)
foo_grammar = Grammar('main_rule')
foo_grammar.add_rules(main_rule=Literal(Tok(Token.Number, keep=True)), )
build_and_run(foo_grammar, 'main.py')
print('Done')
env_spec = EnvSpec(
add_to_env(mappings=New(T.env_assoc, key=Self.name.symbol, val=Self),
metadata=New(Metadata, b=Self.has_plus))
)
@langkit_property(public=True, return_type=T.Ref.entity.array)
def entity_items():
return Self.as_entity.items.map(lambda i: i)
class Ref(FooNode):
name = Field()
@langkit_property(public=True, return_type=Decl.entity)
def decl():
return Self.children_env.get(Self.name).at(0).cast_or_raise(Decl)
fg = Grammar('main_rule')
fg.add_rules(
main_rule=List(fg.decl),
decl=Decl(Opt('+').as_bool(),
Tok(Token.Identifier, keep=True),
'(', fg.ref_list, ')'),
ref_list=List(fg.ref, empty_valid=True),
ref=Ref(Tok(Token.Identifier, keep=True)),
)
build_and_run(fg, 'main.py')
print('Done')
from utils import build_and_run
class FooNode(ASTNode):
prop = AbstractProperty(runtime_check=True, type=LongType, public=True)
class Literal(FooNode):
tok = Field()
a = AbstractProperty(runtime_check=True, type=FooNode.entity)
var = UserField(LogicVarType, public=False)
@langkit_property(return_type=BoolType)
def is_eq(other=T.Literal.entity):
return (Self.as_entity == other)
b = Property(Bind(Self.var, Self.a, eq_prop=Self.is_eq))
@langkit_property(public=True)
def public_prop():
return Let(lambda _=Self.b: Self.as_bare_entity)
foo_grammar = Grammar('main_rule')
foo_grammar.add_rules(
main_rule=Literal(Tok(Token.Number, keep=True)),
)
build_and_run(foo_grammar, 'main.py')
print('Done')
class Decl(FooNode):
name = Field()
items = Field()
env_spec = EnvSpec(
add_to_env(mappings=New(T.env_assoc, key=Self.name.symbol, val=Self)))
class Ref(FooNode):
name = Field()
@langkit_property(public=True, return_type=Decl.entity)
def decl_wrapper():
return Entity.decl
@langkit_property(public=True, return_type=Decl.entity)
def decl():
return Self.children_env.get_first(Self.name).cast_or_raise(Decl)
fg = Grammar('main_rule')
fg.add_rules(
main_rule=List(fg.decl),
decl=Decl(Tok(Token.Identifier, keep=True), '(', fg.ref_list, ')'),
ref_list=List(fg.ref, empty_valid=True),
ref=Ref(Tok(Token.Identifier, keep=True)),
)
build_and_run(fg, 'main.py')
print('Done')
PrivatePart(List(A.task_item, empty_valid=True,
list_cls=DeclList))), end_named_block()),
task_type_decl=TaskTypeDecl("task", "type", A.identifier,
Opt(A.discriminant_part), A.aspect_spec,
Opt(A.task_def), sc()),
subtype_decl=SubtypeDecl("subtype", A.identifier, "is",
A.subtype_indication, A.aspect_spec, sc()),
interface_type_def=InterfaceTypeDef(
Opt(
Or(
InterfaceKind.alt_limited("limited"),
InterfaceKind.alt_task("task"),
InterfaceKind.alt_protected(
L.Identifier(match_text="protected"), ),
InterfaceKind.alt_synchronized(
Tok(L.Identifier, match_text="synchronized")))),
L.Identifier(match_text="interface"), Opt("and", A.parent_list)),
unconstrained_index=UnconstrainedArrayIndex(A.subtype_indication, "range",
"<>"),
array_type_def=ArrayTypeDef(
"array", "(",
Or(UnconstrainedArrayIndices(List(A.unconstrained_index, sep=",")),
ConstrainedArrayIndices(A.constraint_list)), ")", "of",
A.component_def),
discrete_subtype_definition=A.discrete_range | A.subtype_indication,
constraint_list=List(A.discrete_subtype_definition,
sep=",",
list_cls=ConstraintList),
signed_int_type_def=SignedIntTypeDef(A.range_spec),
mod_int_type_def=ModIntTypeDef("mod", A.sexpr_or_box),
derived_type_def=DerivedTypeDef(
from langkit.dsl import ASTNode, Field
from langkit.envs import EnvSpec
from langkit.expressions import Self
from langkit.parsers import Grammar, List, Pick, Tok
from lexer_example import Token
from utils import emit_and_print_errors
class FooNode(ASTNode):
pass
class Def(FooNode):
name = Field()
body = Field()
env_spec = EnvSpec(add_env=True, add_to_env=(Self.name, Self))
grammar = Grammar('stmt_rule')
grammar.add_rules(
def_rule=Def(Tok(Token.Identifier, keep=True), '(', grammar.stmt_rule,
')'),
stmt_rule=List(grammar.def_rule
| Pick('{', List(grammar.stmt_rule, empty_valid=True), '}'),
empty_valid=True))
emit_and_print_errors(grammar)
print('Done')
from langkit.parsers import Grammar, Row, Tok
from lexer_example import Token
from utils import build_and_run
Diagnostics.set_lang_source_dir(os.path.abspath(__file__))
@root_grammar_class()
class FooNode(ASTNode):
prop = AbstractProperty(runtime_check=True, type=LongType)
class BarNode(FooNode):
pass
class Literal(FooNode):
tok = Field()
a = AbstractProperty(runtime_check=True, type=FooNode.env_el())
var = UserField(LogicVarType, is_private=True)
b = Property(Bind(Self.var, Self.a), private=True)
foo_grammar = Grammar('main_rule')
foo_grammar.add_rules(main_rule=Row(Tok(Token.Number, keep=True)) ^ Literal, )
build_and_run(foo_grammar, 'main.py')
print 'Done'
@abstract
class Stmt(FooNode):
pass
class Def(Stmt):
id = Field()
body = Field()
name = Property(Self.id)
env_spec = EnvSpec(add_to_env(Self.id.symbol, Self), add_env())
faulty_prop = Property(Self._env_mappings_0)
class Block(Stmt):
items = Field()
env_spec = EnvSpec(add_env())
grammar = Grammar('stmts_rule')
grammar.add_rules(
def_rule=Def(Tok(Token.Identifier, keep=True),
Opt('(', grammar.stmts_rule, ')')),
stmt_rule=(grammar.def_rule
| Block('{', List(grammar.stmt_rule, empty_valid=True), '}')),
stmts_rule=List(grammar.stmt_rule))
emit_and_print_errors(grammar)
print('Done')
)
@langkit_property(public=True, return_type=T.BoolType)
def test_env(other=T.FooNode.entity):
return Self.children_env.env_orphan == other.children_env.env_orphan
@langkit_property(public=True, return_type=T.BoolType)
def test_struct(other=T.FooNode.entity):
return Self.env_struct == other.env_struct
@langkit_property(public=True, return_type=T.BoolType)
def test_array(other=T.FooNode.entity):
return Self.env_array == other.env_array
class Ref(FooNode):
name = Field()
fg = Grammar('main_rule')
fg.add_rules(
main_rule=List(fg.decl),
decl=Decl(
Opt('+').as_bool(HasPlus), Tok(Token.Identifier, keep=True), '(',
fg.ref_list, ')'),
ref_list=List(fg.ref, empty_valid=True),
ref=Ref(Tok(Token.Identifier, keep=True)),
)
build_and_run(fg, 'main.py')
print('Done')
from lexer_example import Token
from utils import build_and_run
class FooNode(ASTNode):
root_node = Property(Self.unit.root.as_bare_entity, public=True)
@abstract
class Expression(FooNode):
pass
class Literal(Expression):
tok = Field()
class Plus(Expression):
left = Field()
right = Field()
foo_grammar = Grammar('main_rule')
foo_grammar.add_rules(
main_rule=Or(Plus(foo_grammar.atom, '+', foo_grammar.main_rule),
foo_grammar.atom),
atom=Literal(Tok(Token.Number, keep=True)),
)
build_and_run(foo_grammar, 'main.py')
print('Done')
