def field_size(field: model.Field) -> expr.Expr:
if public:
return expr.Call(
"Field_Size", [expr.Variable("Ctx"), expr.Variable(field.affixed_name)]
)
return expr.Add(
expr.Sub(
expr.Selected(expr.Indexed(cursors, expr.Variable(field.affixed_name)), "Last"),
expr.Selected(expr.Indexed(cursors, expr.Variable(field.affixed_name)), "First"),
),
expr.Number(1),
)
def field_value(field: model.Field) -> expr.Expr:
if public:
return expr.Call(f"Get_{field.name}", [expr.Variable("Ctx")])
return expr.Selected(
expr.Indexed(
expr.Variable(ID("Ctx") * "Cursors" if not embedded else "Cursors"),
expr.Variable(field.affixed_name),
),
"Value",
)
def valid_predecessors_invariant() -> Expr:
return AndThen(
*[
If(
[
(
Call(
"Structural_Valid",
[
Indexed(
Variable("Cursors"),
Variable(f.affixed_name),
)
],
),
Or(
*[
expr.AndThen(
expr.Call(
"Structural_Valid"
if l.source in composite_fields
else "Valid",
[
expr.Indexed(
expr.Variable("Cursors"),
expr.Variable(l.source.affixed_name),
)
],
),
expr.Equal(
expr.Selected(
expr.Indexed(
expr.Variable("Cursors"),
expr.Variable(f.affixed_name),
),
"Predecessor",
),
expr.Variable(l.source.affixed_name),
),
l.condition.substituted(
substitution(message, embedded=True, prefix=prefix)
),
)
.simplified()
.ada_expr()
for l in message.incoming(f)
]
),
)
]
)
for f in message.fields
if f not in message.direct_successors(model.INITIAL)
]
)
def field_value(field: model.Field, field_type: model.Type) -> expr.Expr:
if isinstance(field_type, model.Enumeration):
if public:
return expr.Call(
"To_Base_Integer", [expr.Call(f"Get_{field.name}", [expr.Variable("Ctx")])]
)
return expr.Selected(
expr.Indexed(cursors, expr.Variable(field.affixed_name)),
"Value",
)
if isinstance(field_type, model.Scalar):
if public:
return expr.Call(f"Get_{field.name}", [expr.Variable("Ctx")])
return expr.Selected(
expr.Indexed(cursors, expr.Variable(field.affixed_name)),
"Value",
)
if isinstance(field_type, model.Composite):
return expr.Variable(field.name)
assert False, f'unexpected type "{type(field_type).__name__}"'
@pytest.mark.parametrize(
"string,expected",
[
("X'First", expr.First(expr.Variable("X"))),
("X'Last", expr.Last(expr.Variable("X"))),
("X'Size", expr.Size(expr.Variable("X"))),
("X'Head", expr.Head(expr.Variable("X"))),
("X'Opaque", expr.Opaque(expr.Variable("X"))),
("X'Present", expr.Present(expr.Variable("X"))),
("X'Valid", expr.Valid(expr.Variable("X"))),
("X'Valid_Checksum", expr.ValidChecksum(expr.Variable("X"))),
("X'Has_Data", expr.HasData(expr.Variable("X"))),
("X where X = 42", expr.Binding(expr.Variable("X"), {ID("X"): expr.Number(42)})),
("X'Head.Y", expr.Selected(expr.Head(expr.Variable("X")), "Y")),
],
)
def test_expression_suffix(string: str, expected: expr.Expr) -> None:
actual = parse_expression(string, lang.GrammarRule.extended_expression_rule)
assert actual == expected
assert actual.location
@pytest.mark.parametrize(
"string,expected",
[
(
"A - B * 2**3 - 1",
expr.Sub(
expr.Sub(
def func(expression: expr.Expr) -> expr.Expr: # pylint: disable = too-many-branches
def byte_aggregate(aggregate: expr.Aggregate) -> expr.Aggregate:
return expr.Aggregate(*[expr.Val(const.TYPES_BYTE, e) for e in aggregate.elements])
if isinstance(expression, expr.Name) and expression in facts:
return facts[expression]
if isinstance(expression, expr.String):
return expr.Aggregate(*expression.elements)
if isinstance(expression, (expr.Equal, expr.NotEqual)):
field = None
aggregate = None
if isinstance(expression.left, expr.Variable) and isinstance(
expression.right, expr.Aggregate
):
field = model.Field(expression.left.name)
aggregate = byte_aggregate(expression.right)
elif isinstance(expression.left, expr.Aggregate) and isinstance(
expression.right, expr.Variable
):
field = model.Field(expression.right.name)
aggregate = byte_aggregate(expression.left)
if field and field in message.fields and len(field.identifier.parts) == 1 and aggregate:
if embedded:
return expression.__class__(
expr.Indexed(
expr.Variable(ID("Buffer") * "all"),
expr.ValueRange(
expr.Call(
const.TYPES_TO_INDEX,
[
expr.Selected(
expr.Indexed(
expr.Variable("Cursors"),
expr.Variable(field.affixed_name),
),
"First",
)
],
),
expr.Call(
const.TYPES_TO_INDEX,
[
expr.Selected(
expr.Indexed(
expr.Variable("Cursors"),
expr.Variable(field.affixed_name),
),
"Last",
)
],
),
),
),
aggregate,
)
equal_call = expr.Call(
"Equal",
[expr.Variable("Ctx"), expr.Variable(field.affixed_name), aggregate],
)
return equal_call if isinstance(expression, expr.Equal) else expr.Not(equal_call)
boolean_literal = None
other = None
if (
isinstance(expression.left, expr.Literal)
and expression.left.identifier in model.BOOLEAN.literals
):
boolean_literal = expression.left
other = expression.right
if (
isinstance(expression.right, expr.Literal)
and expression.right.identifier in model.BOOLEAN.literals
):
boolean_literal = expression.right
other = expression.left
if boolean_literal and other:
return expression.__class__(
other, type_conversion(expr.Call("To_Base_Integer", [boolean_literal]))
)
def field_value(field: model.Field) -> expr.Expr:
if public:
return expr.Call(f"Get_{field.name}", [expr.Variable("Ctx")])
return expr.Selected(
expr.Indexed(
expr.Variable(ID("Ctx") * "Cursors" if not embedded else "Cursors"),
expr.Variable(field.affixed_name),
),
"Value",
)
if isinstance(expression, expr.Relation):
if (
isinstance(expression.left, expr.Variable)
and model.Field(expression.left.name) in message.fields
and isinstance(expression.right, expr.Number)
):
return expression.__class__(
field_value(model.Field(expression.left.name)), expression.right
)
if (
isinstance(expression.right, expr.Variable)
and model.Field(expression.right.name) in message.fields
and isinstance(expression.left, expr.Number)
):
return expression.__class__(
expression.left, field_value(model.Field(expression.right.name))
)
return expression
def prefixed(name: str) -> expr.Expr:
return expr.Selected(expr.Variable("Ctx"), name) if not embedded else expr.Variable(name)
def message_structure_invariant(
message: model.Message, prefix: str, link: model.Link = None, embedded: bool = False
) -> Expr:
def prefixed(name: str) -> expr.Expr:
return expr.Selected(expr.Variable("Ctx"), name) if not embedded else expr.Variable(name)
if not link:
return message_structure_invariant(
message, prefix, message.outgoing(model.INITIAL)[0], embedded
)
source = link.source
target = link.target
if target == model.FINAL:
return TRUE
field_type = message.types[target]
condition = link.condition.substituted(substitution(message, prefix, embedded)).simplified()
size = (
field_type.size
if isinstance(field_type, model.Scalar)
else link.size.substituted(
substitution(message, prefix, embedded, target_type=const.TYPES_BIT_LENGTH)
).simplified()
)
first = (
prefixed("First")
if source == model.INITIAL
else link.first.substituted(
substitution(message, prefix, embedded, target_type=const.TYPES_BIT_INDEX)
)
.substituted(
mapping={
expr.UNDEFINED: expr.Add(
expr.Selected(
expr.Indexed(prefixed("Cursors"), expr.Variable(source.affixed_name)),
"Last",
),
expr.Number(1),
)
}
)
.simplified()
)
invariant = [
message_structure_invariant(message, prefix, l, embedded) for l in message.outgoing(target)
]
return If(
[
(
AndThen(
Call(
"Structural_Valid",
[Indexed(prefixed("Cursors").ada_expr(), Variable(target.affixed_name))],
),
*([condition.ada_expr()] if condition != expr.TRUE else []),
),
AndThen(
Equal(
Add(
Sub(
Selected(
Indexed(
prefixed("Cursors").ada_expr(),
Variable(target.affixed_name),
),
"Last",
),
Selected(
Indexed(
prefixed("Cursors").ada_expr(),
Variable(target.affixed_name),
),
"First",
),
),
Number(1),
),
size.ada_expr(),
),
Equal(
Selected(
Indexed(
prefixed("Cursors").ada_expr(),
Variable(target.affixed_name),
),
"Predecessor",
),
Variable(source.affixed_name),
),
Equal(
Selected(
Indexed(
prefixed("Cursors").ada_expr(),
Variable(target.affixed_name),
),
"First",
),
first.ada_expr(),
),
*[i for i in invariant if i != TRUE],
),
)
]
)
def field_last(field: model.Field) -> expr.Expr:
if public:
return expr.Call(
"Field_Last", [expr.Variable("Ctx"), expr.Variable(field.affixed_name)]
)
return expr.Selected(expr.Indexed(cursors, expr.Variable(field.affixed_name)), "Last")
def test_selected_rflx_expr() -> None:
assert ada.Selected(ada.Variable("X"), "Y").rflx_expr() == expr.Selected(
expr.Variable("X"), "Y")