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)))