def generic_formal_part(parameters: Sequence[FormalDeclaration] = None) -> str:
if parameters is None:
return ""
return ("generic" +
("".join(f"\n {p}"
for p in unique(parameters)) if parameters else "") +
"\n")
def declarative_items(declarations: List[Declaration],
private: bool = False) -> str:
result = "\n\n".join(
indent(str(d), 3) for d in unique(declarations) if str(d))
if result:
result = f"private\n\n{result}" if private else result
result += "\n\n"
return result
def variables(self) -> List["Variable"]:
variables = []
for ce in self.condition_expressions:
variables.extend(ce[0].variables())
variables.extend(ce[1].variables())
if self.else_expression:
variables.extend(self.else_expression.variables())
return list(unique(variables))
def _add_missing_types_and_validate(self) -> None:
error = self._check_duplicates()
types = [t for s in self._sessions for t in s.direct_dependencies.values()] + [*self._types]
types = [d for t in types for d in t.dependencies]
self._types = list(unique(types))
error += self._check_conflicts()
error.propagate()
def create_internal_functions(
self,
message: Message,
scalar_fields: Mapping[Field, Type],
composite_fields: Sequence[Field],
) -> UnitPart:
def result(field: Field, message: Message) -> NamedAggregate:
aggregate: List[Tuple[str, Expr]] = [
("Fld", Variable(field.affixed_name))
]
if field in message.fields and isinstance(message.types[field],
Scalar):
aggregate.append((
f"{field.name}_Value",
Call(
"Extract",
[
Slice(
Variable("Ctx.Buffer.all"),
Variable("Buffer_First"),
Variable("Buffer_Last"),
),
Variable("Offset"),
],
),
))
return NamedAggregate(*aggregate)
return UnitPart(
[],
[
ExpressionFunctionDeclaration(
FunctionSpecification("Composite_Field", "Boolean",
[Parameter(["Fld"], "Field")]),
Case(
Variable("Fld"),
[(Variable(f.affixed_name),
TRUE if f in composite_fields else FALSE)
for f in message.fields],
),
),
SubprogramBody(
FunctionSpecification(
"Get_Field_Value",
"Field_Dependent_Value",
[
Parameter(["Ctx"], "Context"),
Parameter(["Fld"], "Field")
],
),
[
*common.field_bit_location_declarations(
Variable("Fld")),
*common.field_byte_location_declarations(),
*unique(
self.extract_function(common.full_base_type_name(
t)) for t in message.types.values()
if isinstance(t, Scalar)),
] if scalar_fields else [],
[
ReturnStatement(
Case(
Variable("Fld"),
[(Variable(f.affixed_name), result(f, message))
for f in message.fields],
))
],
[
Precondition(
AndThen(
Call("Has_Buffer", [Variable("Ctx")]),
Call("Valid_Next",
[Variable("Ctx"),
Variable("Fld")]),
Call("Sufficient_Buffer_Length",
[Variable("Ctx"),
Variable("Fld")]),
)),
Postcondition(
Equal(
Selected(Result("Get_Field_Value"), "Fld"),
Variable("Fld"),
)),
],
),
],
)
def context_clause(context: Sequence[ContextItem]) -> str:
return ("\n".join(map(str, unique(context))) + "\n\n") if context else ""
def specification(self) -> str:
context_clause = ""
if self.context:
context_clause = "\n".join(map(str, unique(self.context)))
context_clause = f"{context_clause}\n\n"
return f"{context_clause}{self.__specification}"
def create_internal_functions(
self, message: Message,
scalar_fields: Mapping[Field, Scalar]) -> UnitPart:
return UnitPart(
[],
[
SubprogramBody(
ProcedureSpecification(
"Set_Field_Value",
[
InOutParameter(["Ctx"], "Context"),
Parameter(["Val"], "Field_Dependent_Value"),
OutParameter(["Fst", "Lst"],
const.TYPES_BIT_INDEX),
],
),
[
*common.field_bit_location_declarations(
Variable("Val.Fld")),
*common.field_byte_location_declarations(),
*unique(
self.insert_function(common.full_base_type_name(t))
for t in message.types.values()
if isinstance(t, Scalar)),
],
[
Assignment("Fst", Variable("First")),
Assignment("Lst", Variable("Last")),
CaseStatement(
Variable("Val.Fld"),
[(
Variable(f.affixed_name),
[
CallStatement(
"Insert",
[
Variable(f"Val.{f.name}_Value"),
Slice(
Variable("Ctx.Buffer.all"),
Variable("Buffer_First"),
Variable("Buffer_Last"),
),
Variable("Offset"),
],
)
if f in scalar_fields else NullStatement()
],
) for f in message.all_fields],
),
],
[
Precondition(
AndThen(
Not(Constrained("Ctx")),
Call("Has_Buffer", [Variable("Ctx")]),
In(Variable("Val.Fld"), Range("Field")),
Call("Valid_Next",
[Variable("Ctx"),
Variable("Val.Fld")]),
common.sufficient_space_for_field_condition(
Variable("Val.Fld")),
ForAllIn(
"F",
Range("Field"),
If([(
Call(
"Structural_Valid",
[
Indexed(
Variable("Ctx.Cursors"),
Variable("F"),
)
],
),
LessEqual(
Selected(
Indexed(
Variable("Ctx.Cursors"),
Variable("F"),
),
"Last",
),
Call(
"Field_Last",
[
Variable("Ctx"),
Variable("Val.Fld")
],
),
),
)]),
),
)),
Postcondition(
And(
Call("Has_Buffer", [Variable("Ctx")]),
Equal(
Variable("Fst"),
Call(
"Field_First",
[Variable("Ctx"),
Variable("Val.Fld")]),
),
Equal(
Variable("Lst"),
Call(
"Field_Last",
[Variable("Ctx"),
Variable("Val.Fld")]),
),
GreaterEqual(Variable("Fst"),
Variable("Ctx.First")),
LessEqual(Variable("Fst"),
Add(Variable("Lst"), Number(1))),
LessEqual(
Call(const.TYPES_BYTE_INDEX,
[Variable("Lst")]),
Variable("Ctx.Buffer_Last"),
),
ForAllIn(
"F",
Range("Field"),
If([(
Call(
"Structural_Valid",
[
Indexed(
Variable("Ctx.Cursors"),
Variable("F"),
)
],
),
LessEqual(
Selected(
Indexed(
Variable("Ctx.Cursors"),
Variable("F"),
),
"Last",
),
Variable("Lst"),
),
)]),
),
*[
Equal(e, Old(e)) for e in [
Variable("Ctx.Buffer_First"),
Variable("Ctx.Buffer_Last"),
Variable("Ctx.First"),
Variable("Ctx.Cursors"),
]
],
)),
],
)
] if scalar_fields else [],
)
def variables(self) -> List["Variable"]:
return list(unique([v for t in self.terms for v in t.variables()]))
def variables(self) -> List["Variable"]:
return list(unique(self.left.variables() + self.right.variables()))
def variables(self) -> List["Variable"]:
return list(unique(self.iterable.variables() + self.predicate.variables()))
def variables(self) -> List["Variable"]:
variables = self.control_expression.variables()
for cs in self.case_statements:
variables.extend(cs[0].variables())
variables.extend(cs[1].variables())
return list(unique(variables))
def variables(self, proof: bool = False) -> List["Variable"]:
return list(unique([v for t in self.terms
for v in t.variables(proof)]))
def variables(self, proof: bool = False) -> List["Variable"]:
return list(
unique(self.left.variables(proof) + self.right.variables(proof)))
def variables(self, proof: bool = False) -> List["Variable"]:
return list(
unique(
self.iterable.variables(proof) +
self.predicate.variables(proof)))
