From 14f1b95938aae1ed5afbb71d472c6f291d7f30bd Mon Sep 17 00:00:00 2001 From: Tobias Reiher Date: Thu, 14 Jul 2022 17:55:57 +0200 Subject: [PATCH] Simplify handling of identifiers Ref. #691, #1106 --- rflx/ada.py | 203 +++++++++--------- rflx/expression.py | 18 +- rflx/generator/allocator.py | 10 +- rflx/generator/common.py | 43 ++-- rflx/generator/const.py | 17 +- rflx/generator/generator.py | 103 +++++---- rflx/generator/message.py | 159 +++++++------- rflx/generator/parser.py | 60 +++--- rflx/generator/serializer.py | 182 ++++++---------- rflx/generator/session.py | 398 ++++++++++++++++++----------------- rflx/identifier.py | 14 +- tests/unit/ada_test.py | 37 ++-- tests/unit/generator_test.py | 6 +- tests/utils.py | 6 +- 14 files changed, 611 insertions(+), 645 deletions(-) diff --git a/rflx/ada.py b/rflx/ada.py index a1d29ae452..5a799a7aa6 100644 --- a/rflx/ada.py +++ b/rflx/ada.py @@ -11,43 +11,14 @@ from sys import intern from typing import List, Mapping, Optional, Sequence, Tuple, Union -import rflx.identifier from rflx import expression as expr from rflx.common import Base, file_name, indent, indent_next, unique from rflx.contract import invariant +from rflx.identifier import ID, StrID MAX_LINE_LENGTH = 100 -class ID(rflx.identifier.ID): - @property - def _separator(self) -> str: - return "." - - def __add__(self, other: object) -> "ID": - result = super().__add__(other) - assert isinstance(result, ID) - return result - - def __radd__(self, other: object) -> "ID": - result = super().__radd__(other) - assert isinstance(result, ID) - return result - - def __mul__(self, other: object) -> "ID": - result = super().__mul__(other) - assert isinstance(result, ID) - return result - - def __rmul__(self, other: object) -> "ID": - result = super().__rmul__(other) - assert isinstance(result, ID) - return result - - -StrID = Union[str, ID] - - class Precedence(Enum): UNDEFINED = 0 BOOLEAN_OPERATOR = 1 @@ -360,7 +331,7 @@ def precedence(self) -> Precedence: class Literal(Name): def __init__(self, identifier: StrID) -> None: self.identifier = ID(identifier) - super().__init__(False) + super().__init__(negative=False) @property def _representation(self) -> str: @@ -368,10 +339,10 @@ def _representation(self) -> str: @property def name(self) -> str: - return str(self.identifier) + return self.identifier.ada_str def rflx_expr(self) -> expr.Literal: - return expr.Literal(ID(self.identifier)) + return expr.Literal(self.identifier) class Variable(Name): @@ -388,10 +359,10 @@ def _representation(self) -> str: @property def name(self) -> str: - return str(self.identifier) + return self.identifier.ada_str def rflx_expr(self) -> expr.Variable: - return expr.Variable(ID(self.identifier)) + return expr.Variable(self.identifier) TRUE = Literal("True") @@ -539,7 +510,9 @@ def __init__(self, prefix: Union[StrID, Expr], *associations: Tuple[StrID, Expr] @property def _representation(self) -> str: assert len(self.associations) > 0 - associations = ", ".join(f"{name} => {element}" for name, element in self.associations) + associations = ", ".join( + f"{name.ada_str} => {element}" for name, element in self.associations + ) return f"{self.prefix}'{self.__class__.__name__} ({associations})" @@ -586,7 +559,7 @@ def _representation(self) -> str: return f"{self.prefix}.{self.selector}" def rflx_expr(self) -> expr.Selected: - return expr.Selected(self.prefix.rflx_expr(), ID(self.selector), self.negative) + return expr.Selected(self.prefix.rflx_expr(), self.selector, self.negative) class Call(Name): @@ -617,14 +590,12 @@ def _representation(self) -> str: ) if arguments: arguments = f" ({arguments})" - call = f"{self.identifier}{arguments}" + call = f"{self.identifier.ada_str}{arguments}" return call def rflx_expr(self) -> expr.Call: assert not self.named_arguments - return expr.Call( - ID(self.identifier), [a.rflx_expr() for a in self.arguments], self.negative - ) + return expr.Call(self.identifier, [a.rflx_expr() for a in self.arguments], self.negative) class Slice(Name): @@ -684,7 +655,12 @@ def __init__(self, *elements: Tuple[Union[StrID, Expr], Expr]) -> None: def _update_str(self) -> None: assert len(self.elements) > 0 self._str = intern( - "(" + ", ".join(f"{name} => {element}" for name, element in self.elements) + ")" + "(" + + ", ".join( + f"{name.ada_str if isinstance(name, ID) else name} => {element}" + for name, element in self.elements + ) + + ")" ) @property @@ -692,9 +668,9 @@ def precedence(self) -> Precedence: raise NotImplementedError def rflx_expr(self) -> expr.NamedAggregate: - elements: list[tuple[Union[StrID, expr.Expr], expr.Expr]] = [ + elements: list[tuple[Union[ID, expr.Expr], expr.Expr]] = [ ( - ID(n) if isinstance(n, ID) else n.rflx_expr(), + n if isinstance(n, ID) else n.rflx_expr(), e.rflx_expr(), ) for n, e in self.elements @@ -864,8 +840,8 @@ def __init__(self, parameter_identifier: StrID, iterable: Expr, predicate: Expr) def _update_str(self) -> None: self._str = intern( - f"(for {self.quantifier} {self.parameter_identifier} {self.keyword} {self.iterable}" - f" =>\n{indent(str(self.predicate), 4)})" + f"(for {self.quantifier} {self.parameter_identifier.ada_str} {self.keyword}" + f" {self.iterable} =>\n{indent(str(self.predicate), 4)})" ) @property @@ -925,13 +901,13 @@ def __init__(self, lower: Expr, upper: Expr, type_identifier: StrID = None): super().__init__() self.lower = lower self.upper = upper - self.type_id = type_identifier + self.type_identifier = ID(type_identifier) if type_identifier else None def _update_str(self) -> None: - if self.type_id is None: + if self.type_identifier is None: self._str = intern(f"{self.lower} .. {self.upper}") else: - self._str = intern(f"{self.type_id} range {self.lower} .. {self.upper}") + self._str = intern(f"{self.type_identifier.ada_str} range {self.lower} .. {self.upper}") @property def precedence(self) -> Precedence: @@ -948,14 +924,14 @@ def __init__(self, identifier: StrID, argument: Expr) -> None: self.argument = argument def _update_str(self) -> None: - self._str = intern(f"{self.identifier} ({self.argument})") + self._str = intern(f"{self.identifier.ada_str} ({self.argument})") @property def precedence(self) -> Precedence: return Precedence.LITERAL def rflx_expr(self) -> expr.Conversion: - return expr.Conversion(ID(self.identifier), self.argument.rflx_expr()) + return expr.Conversion(self.identifier, self.argument.rflx_expr()) class QualifiedExpr(Expr): @@ -970,7 +946,7 @@ def _update_str(self) -> None: if isinstance(self.expression, (Aggregate, NamedAggregate)) else f"({self.expression})" ) - self._str = intern(f"{self.type_identifier}'{operand}") + self._str = intern(f"{self.type_identifier.ada_str}'{operand}") @property def precedence(self) -> Precedence: @@ -988,7 +964,7 @@ def __init__(self, identifier: StrID, string: Expr = None) -> None: def _update_str(self) -> None: string = f" with {self.string}" if self.string else "" - self._str = intern(f"raise {self.identifier}{string}") + self._str = intern(f"raise {self.identifier.ada_str}{string}") @property def precedence(self) -> Precedence: @@ -1034,17 +1010,17 @@ def __str__(self) -> str: class WithClause(ContextItem): def __str__(self) -> str: - return f"with {self.identifier};" + return f"with {self.identifier.ada_str};" class UsePackageClause(ContextItem, Declaration): def __str__(self) -> str: - return f"use {self.identifier};" + return f"use {self.identifier.ada_str};" class UseTypeClause(ContextItem, Declaration): def __str__(self) -> str: - return f"use type {self.identifier};" + return f"use type {self.identifier.ada_str};" class Aspect(Base): @@ -1132,7 +1108,7 @@ def definition(self) -> str: class Depends(Aspect): def __init__(self, dependencies: Mapping[StrID, Sequence[StrID]]) -> None: - self.dependencies = dependencies + self.dependencies = {ID(k): v for k, v in dependencies.items()} @property def mark(self) -> str: @@ -1148,7 +1124,7 @@ def input_values(values: Sequence[StrID]) -> str: return "(" + ", ".join(str(p) for p in values) + ")" dependencies = indent_next( - ", ".join(f"{o} => {input_values(i)}" for o, i in self.dependencies.items()), 1 + ", ".join(f"{o.ada_str} => {input_values(i)}" for o, i in self.dependencies.items()), 1 ) return f"({dependencies})" @@ -1294,15 +1270,23 @@ def __str__(self) -> str: class FormalPackageDeclaration(FormalDeclaration): def __init__( - self, identifier: StrID, generic_identifier: StrID, associations: Sequence[StrID] = None + self, + identifier: StrID, + generic_identifier: StrID, + associations: Sequence[StrID] = None, ) -> None: self.identifier = ID(identifier) self.generic_identifier = ID(generic_identifier) - self.associations = list(map(str, associations or [])) + self.associations = list(map(ID, associations or [])) def __str__(self) -> str: - associations = ", ".join(map(str, self.associations)) if self.associations else "<>" - return f"with package {self.identifier} is new {self.generic_identifier} ({associations});" + associations = ( + ", ".join([a.ada_str for a in self.associations]) if self.associations else "<>" + ) + return ( + f"with package {self.identifier.ada_str} is new {self.generic_identifier.ada_str}" + f" ({associations});" + ) class PackageDeclaration(Declaration): @@ -1323,10 +1307,10 @@ def __init__( def __str__(self) -> str: return ( f"{generic_formal_part(self.formal_parameters)}" - f"package {self.identifier}{aspect_specification(self.aspects)}\nis\n\n" + f"package {self.identifier.ada_str}{aspect_specification(self.aspects)}\nis\n\n" f"{declarative_items(self.declarations)}" f"{declarative_items(self.private_declarations, private=True)}" - f"end {self.identifier};\n" + f"end {self.identifier.ada_str};\n" ) @@ -1354,14 +1338,17 @@ def __str__(self) -> str: ) return ( - f"package body {self.identifier}{aspect_specification(self.aspects)}\nis\n\n" - f"{declarative_items(self.declarations)}{statements}end {self.identifier};\n" + f"package body {self.identifier.ada_str}{aspect_specification(self.aspects)}\nis\n\n" + f"{declarative_items(self.declarations)}{statements}end {self.identifier.ada_str};\n" ) class GenericPackageInstantiation(Declaration): def __init__( - self, identifier: StrID, generic_package: StrID, associations: Sequence[StrID] = None + self, + identifier: StrID, + generic_package: StrID, + associations: Sequence[StrID] = None, ) -> None: self.identifier = ID(identifier) self.generic_package = ID(generic_package) @@ -1371,10 +1358,13 @@ def __hash__(self) -> int: return hash(self.identifier) def __str__(self) -> str: - associations = ", ".join(map(str, self.associations)) + associations = ", ".join([a.ada_str for a in self.associations]) if associations: associations = f" ({associations})" - return f"package {self.identifier} is new {self.generic_package}{associations};" + return ( + f"package {self.identifier.ada_str} is new {self.generic_package.ada_str}" + f"{associations};" + ) class PackageRenamingDeclaration(Declaration): @@ -1383,7 +1373,7 @@ def __init__(self, identifier: StrID, package_identifier: StrID) -> None: self.package_identifier = ID(package_identifier) def __str__(self) -> str: - return f"package {self.identifier} renames {self.package_identifier};" + return f"package {self.identifier.ada_str} renames {self.package_identifier.ada_str};" class ObjectDeclaration(Declaration): @@ -1430,7 +1420,7 @@ def __init__( def __str__(self) -> str: identifiers = ", ".join(map(str, self.identifiers)) default = f" := {self.default}" if self.default else "" - return f"{identifiers} : {self.type_identifier}{default}" + return f"{identifiers} : {self.type_identifier.ada_str}{default}" class TypeDeclaration(Declaration, FormalDeclaration): @@ -1449,7 +1439,7 @@ def __hash__(self) -> int: def __str__(self) -> str: return ( - f"type {self.identifier}{self.discriminant_part} is{self.type_definition}" + f"type {self.identifier.ada_str}{self.discriminant_part} is{self.type_definition}" f"{aspect_specification(self.aspects)};{self.extra_declaration}" ) @@ -1524,7 +1514,7 @@ def extra_declaration(self) -> str: f"{k} => {v}" for k, v in self.literals.items() if v is not None ) return ( - f"\nfor {self.identifier} use ({literal_representation});" + f"\nfor {self.identifier.ada_str} use ({literal_representation});" if literal_representation else "" ) @@ -1542,7 +1532,7 @@ def __str__(self) -> str: @property def type_definition(self) -> str: - return f" {self.base_identifier}" + return f" {self.base_identifier.ada_str}" class RangeSubtype(Subtype): @@ -1553,7 +1543,7 @@ def __init__(self, identifier: StrID, base_identifier: StrID, first: Expr, last: @property def type_definition(self) -> str: - return f" {self.base_identifier} range {self.first} .. {self.last}" + return f" {self.base_identifier.ada_str} range {self.first} .. {self.last}" class DerivedType(TypeDeclaration): @@ -1582,7 +1572,7 @@ def type_definition(self) -> str: ) extension = f" with\n record\n{components} end record" - return f" new {self.type_identifier}{extension}" + return f" new {self.type_identifier.ada_str}{extension}" class PrivateType(TypeDeclaration): @@ -1605,13 +1595,13 @@ def __init__(self, identifier: StrID, index_type: StrID, component_identifier: S @property def type_definition(self) -> str: - return f" array ({self.index_type}) of {self.component_identifier}" + return f" array ({self.index_type.ada_str}) of {self.component_identifier.ada_str}" class UnconstrainedArrayType(ArrayType): @property def type_definition(self) -> str: - return f" array ({self.index_type} range <>) of {self.component_identifier}" + return f" array ({self.index_type.ada_str} range <>) of {self.component_identifier.ada_str}" class AccessType(TypeDeclaration): @@ -1621,7 +1611,7 @@ def __init__(self, identifier: StrID, object_identifier: StrID) -> None: @property def type_definition(self) -> str: - return f" access {self.object_identifier}" + return f" access {self.object_identifier.ada_str}" class Component(Base): @@ -1642,7 +1632,7 @@ def __init__( def __str__(self) -> str: default = f" := {self.default}" if self.default else "" aliased = "aliased " if self.aliased else "" - return f"{self.identifier} : {aliased}{self.type_identifier}{default};" + return f"{self.identifier.ada_str} : {aliased}{self.type_identifier}{default};" class NullComponent(Component): @@ -1671,7 +1661,7 @@ def __init__(self, discriminant_identifier: StrID, variants: Sequence[Variant]) def __str__(self) -> str: variants = "\n".join(map(str, self.variants)) - return f"case {self.discriminant_identifier} is\n{variants}\nend case;\n" + return f"case {self.discriminant_identifier.ada_str} is\n{variants}\nend case;\n" class RecordType(TypeDeclaration): @@ -1728,12 +1718,12 @@ def __str__(self) -> str: class Assignment(Statement): - def __init__(self, identifier: Union[StrID, Expr], expression: Expr) -> None: - self.identifier = identifier if isinstance(identifier, Expr) else Variable(identifier) + def __init__(self, name: Union[StrID, Expr], expression: Expr) -> None: + self.name = name if isinstance(name, Expr) else Variable(name) self.expression = expression def __str__(self) -> str: - return f"{self.identifier} := {self.expression};" + return f"{self.name} := {self.expression};" class CallStatement(Statement): @@ -1755,7 +1745,7 @@ def __str__(self) -> str: ] ) arguments = f" ({arguments})" if arguments else "" - return f"{self.identifier}{arguments};" + return f"{self.identifier.ada_str}{arguments};" class PragmaStatement(Statement): @@ -1767,8 +1757,10 @@ def __str__(self) -> str: parameters = "" if self.pragma_parameters: parameters = ", ".join(map(str, self.pragma_parameters)) - parameters = " (" + indent_next(str(parameters), len(str(self.identifier)) + 9) + ")" - return f"pragma {self.identifier}{parameters};" + parameters = ( + " (" + indent_next(str(parameters), len(str(self.identifier.ada_str)) + 9) + ")" + ) + return f"pragma {self.identifier.ada_str}{parameters};" class ReturnStatement(Statement): @@ -1808,7 +1800,7 @@ def __init__(self, identifier: StrID) -> None: self.identifier = ID(identifier) def __str__(self) -> str: - return f"<<{self.identifier}>>" + return f"<<{self.identifier.ada_str}>>" class CommentStatement(Statement): @@ -1915,7 +1907,7 @@ def __init__( reverse: bool = False, ) -> None: assert len(statements) > 0 - self.identifier = identifier + self.identifier = ID(identifier) self.iterator = iterator self.statements = statements self.reverse = reverse @@ -1924,7 +1916,7 @@ def __str__(self) -> str: statements = indent("\n".join(str(s) for s in self.statements), 3) reverse = "reverse " if self.reverse else "" return ( - f"for {self.identifier} {self.iterator_spec} " + f"for {self.identifier.ada_str} {self.iterator_spec} " f"{reverse}{self.iterator} loop\n{statements}\nend loop;" ) @@ -1954,7 +1946,7 @@ def __init__(self, identifier: StrID, string: Expr = None) -> None: def __str__(self) -> str: string = f" with {self.string}" if self.string else "" - return f"raise {self.identifier}{string};" + return f"raise {self.identifier.ada_str}{string};" class Declare(Statement): @@ -1981,7 +1973,7 @@ def __init__( def __str__(self) -> str: identifiers = ", ".join(map(str, self.identifiers)) default = f" := {self.default}" if self.default else "" - return f"{identifiers} : {self.mode}{self.type_identifier}{default}" + return f"{identifiers} : {self.mode}{self.type_identifier.ada_str}{default}" @property def mode(self) -> str: @@ -2034,7 +2026,7 @@ def __str__(self) -> str: class ProcedureSpecification(SubprogramSpecification): def __str__(self) -> str: - return f"procedure {self.identifier}{self._parameters()}" + return f"procedure {self.identifier.ada_str}{self._parameters()}" class FunctionSpecification(SubprogramSpecification): @@ -2045,7 +2037,10 @@ def __init__( self.return_type = ID(return_type) def __str__(self) -> str: - return f"function {self.identifier}{self._parameters()} return {self.return_type}" + return ( + f"function {self.identifier.ada_str}{self._parameters()}" + f" return {self.return_type.ada_str}" + ) class Subprogram(Declaration): @@ -2107,7 +2102,7 @@ def __str__(self) -> str: f"{self._declarations()}" f"begin\n" f"{self._statements()}\n" - f"end {self.specification.identifier};" + f"end {self.specification.identifier.ada_str};" ) @@ -2140,10 +2135,13 @@ def __init__( self.associations = list(map(ID, associations or [])) def __str__(self) -> str: - associations = ", ".join(map(str, self.associations)) + associations = ", ".join([a.ada_str for a in self.associations]) if associations: associations = f" ({associations})" - return f"procedure {self.identifier} is new {self.specification.identifier}{associations};" + return ( + f"procedure {self.identifier.ada_str} is new {self.specification.identifier.ada_str}" + f"{associations};" + ) class GenericFunctionInstantiation(Subprogram): @@ -2159,10 +2157,13 @@ def __init__( self.associations = list(map(ID, associations or [])) def __str__(self) -> str: - associations = ", ".join(map(str, self.associations)) + associations = ", ".join([a.ada_str for a in self.associations]) if associations: associations = f" ({associations})" - return f"function {self.identifier} is new {self.specification.identifier}{associations};" + return ( + f"function {self.identifier.ada_str} is new {self.specification.identifier.ada_str}" + f"{associations};" + ) class SubprogramRenamingDeclaration(Subprogram): @@ -2173,7 +2174,7 @@ def __init__( self.subprogram_identifier = ID(subprogram_identifier) def __str__(self) -> str: - return f"{self.specification} renames {self.subprogram_identifier};" + return f"{self.specification} renames {self.subprogram_identifier.ada_str};" class Pragma(Declaration, ContextItem): @@ -2194,7 +2195,7 @@ def __str__(self) -> str: if self.pragma_parameters: parameters = ", ".join(map(str, self.pragma_parameters)) parameters = f" ({parameters})" - return f"pragma {self.identifier}{parameters};" + return f"pragma {self.identifier.ada_str}{parameters};" class Unit(Base): diff --git a/rflx/expression.py b/rflx/expression.py index f26cfe7527..3503cd87d2 100644 --- a/rflx/expression.py +++ b/rflx/expression.py @@ -1078,7 +1078,7 @@ def variables(self) -> List[Variable]: return [] def ada_expr(self) -> ada.Expr: - return ada.Literal(ada.ID(self.identifier)) + return ada.Literal(self.identifier) @lru_cache(maxsize=None) def z3expr(self) -> z3.ExprRef: @@ -1144,7 +1144,7 @@ def variables(self) -> List["Variable"]: return [self] def ada_expr(self) -> ada.Expr: - return ada.Variable(ada.ID(self.identifier), self.negative) + return ada.Variable(self.identifier, self.negative) @lru_cache(maxsize=None) def z3expr(self) -> z3.ExprRef: @@ -1516,7 +1516,7 @@ def substituted( return expr def ada_expr(self) -> ada.Expr: - return ada.Selected(self.prefix.ada_expr(), ada.ID(self.selector), self.negative) + return ada.Selected(self.prefix.ada_expr(), ID(self.selector), self.negative) @lru_cache(maxsize=None) def z3expr(self) -> z3.ExprRef: @@ -1612,9 +1612,7 @@ def representation(self) -> str: return call def ada_expr(self) -> ada.Expr: - return ada.Call( - ada.ID(self.identifier), [a.ada_expr() for a in self.args], {}, self.negative - ) + return ada.Call(self.identifier, [a.ada_expr() for a in self.args], {}, self.negative) @lru_cache(maxsize=None) def z3expr(self) -> z3.ExprRef: @@ -1812,9 +1810,9 @@ def simplified(self) -> Expr: raise NotImplementedError def ada_expr(self) -> ada.Expr: - elements: List[Tuple[Union[ada.StrID, ada.Expr], ada.Expr]] = [ + elements: List[Tuple[Union[ID, ada.Expr], ada.Expr]] = [ ( - ada.ID(n) if isinstance(n, ID) else n.ada_expr(), + n if isinstance(n, ID) else n.ada_expr(), e.ada_expr(), ) for n, e in self.elements @@ -2437,7 +2435,7 @@ def simplified(self) -> Expr: ) def ada_expr(self) -> ada.Expr: - return ada.Conversion(ada.ID(self.identifier), self.argument.ada_expr()) + return ada.Conversion(self.identifier, self.argument.ada_expr()) @lru_cache(maxsize=None) def z3expr(self) -> z3.ExprRef: @@ -2477,7 +2475,7 @@ def simplified(self) -> Expr: return QualifiedExpr(self.type_identifier, self.expression.simplified()) def ada_expr(self) -> ada.Expr: - return ada.QualifiedExpr(ada.ID(self.type_identifier), self.expression.ada_expr()) + return ada.QualifiedExpr(self.type_identifier, self.expression.ada_expr()) def z3expr(self) -> z3.ArithRef: raise NotImplementedError diff --git a/rflx/generator/allocator.py b/rflx/generator/allocator.py index f8c5a5c24f..0f7c67d4f2 100644 --- a/rflx/generator/allocator.py +++ b/rflx/generator/allocator.py @@ -4,9 +4,8 @@ from itertools import zip_longest from typing import Dict, List, Optional, Sequence -from rflx import expression as expr, identifier as rid, typing_ as rty +from rflx import expression as expr, typing_ as rty from rflx.ada import ( - ID, Add, And, AndThen, @@ -43,6 +42,7 @@ WithClause, ) from rflx.error import Location +from rflx.identifier import ID from rflx.integration import Integration from rflx.model import Session, State, declaration as decl, statement as stmt @@ -92,7 +92,7 @@ def __init__(self, session: Session, integration: Integration, prefix: str = "") @property def unit_identifier(self) -> ID: - return ID(self._session.identifier.parent * f"{self._session.identifier.name}_Allocator") + return self._session.identifier.parent * f"{self._session.identifier.name}_Allocator" @property def declaration_context(self) -> List[ContextItem]: @@ -121,7 +121,7 @@ def get_slot_ptr(self, location: Optional[Location]) -> ID: slot_id: int = self._allocation_slots[location] return self._slot_name(slot_id) - def get_size(self, variable: Optional[rid.ID] = None, state: Optional[rid.ID] = None) -> int: + def get_size(self, variable: Optional[ID] = None, state: Optional[ID] = None) -> int: return self._integration.get_size(self._session.identifier, variable, state) @staticmethod @@ -344,7 +344,7 @@ def _allocate_global_slots(self) -> List[SlotInfo]: return slots @staticmethod - def _scope(state: State, var_id: rid.ID) -> Optional[rid.ID]: + def _scope(state: State, var_id: ID) -> Optional[ID]: """ Return the scope of the variable var_id. diff --git a/rflx/generator/common.py b/rflx/generator/common.py index 4f13d874e8..d225246426 100644 --- a/rflx/generator/common.py +++ b/rflx/generator/common.py @@ -3,9 +3,8 @@ import enum from typing import Callable, List, Mapping, Optional, Sequence, Tuple -from rflx import expression as expr, identifier as rid, model +from rflx import expression as expr, model from rflx.ada import ( - ID, TRUE, Add, And, @@ -50,6 +49,7 @@ WithClause, ) from rflx.const import BUILTINS_PACKAGE +from rflx.identifier import ID from . import const @@ -101,7 +101,7 @@ def byte_aggregate(aggregate: expr.Aggregate) -> expr.Aggregate: if embedded: return expression.__class__( expr.Indexed( - expr.Variable(rid.ID("Buffer") * "all"), + expr.Variable(ID("Buffer") * "all"), expr.ValueRange( expr.Call( const.TYPES_TO_INDEX, @@ -161,7 +161,7 @@ def field_value(field: model.Field) -> expr.Expr: return expr.Call(f"Get_{field.name}", [expr.Variable("Ctx")]) return expr.Selected( expr.Indexed( - expr.Variable(rid.ID("Ctx") * "Cursors" if not embedded else "Cursors"), + expr.Variable(ID("Ctx") * "Cursors" if not embedded else "Cursors"), expr.Variable(field.affixed_name), ), "Value", @@ -198,7 +198,7 @@ def substitution_facts( target_type: Optional[ID] = const.TYPES_BASE_INT, ) -> Mapping[expr.Name, expr.Expr]: def prefixed(name: str) -> expr.Expr: - return expr.Variable(rid.ID("Ctx") * name) if not embedded else expr.Variable(name) + return expr.Variable(ID("Ctx") * name) if not embedded else expr.Variable(name) first = prefixed("First") last = expr.Call("Written_Last", [expr.Variable("Ctx")]) if public else prefixed("Written_Last") @@ -798,7 +798,7 @@ def field_condition_call( aggregate: Expr = None, size: Expr = None, ) -> Expr: - package = ID(prefix * message.identifier) + package = prefix * message.identifier if value is None: value = Number(0) if aggregate is None: @@ -820,17 +820,17 @@ def field_condition_call( ) -def to_base_integer(prefix: str, type_package: rid.ID) -> ID: +def to_base_integer(prefix: str, type_package: ID) -> ID: if type_package == BUILTINS_PACKAGE: return ID("To_Base_Integer") - return prefix * ID(type_package) * "To_Base_Integer" + return prefix * type_package * "To_Base_Integer" -def ada_type_identifier(type_identifier: rid.ID) -> ID: +def ada_type_identifier(type_identifier: ID) -> ID: if model.is_builtin_type(type_identifier): - return ID(type_identifier.name) + return type_identifier.name - return ID(type_identifier) + return type_identifier def prefixed_type_identifier(type_identifier: ID, prefix: str) -> ID: @@ -841,20 +841,18 @@ def prefixed_type_identifier(type_identifier: ID, prefix: str) -> ID: def enum_name(enum_type: model.Enumeration) -> ID: - return ID(enum_type.name + "_Enum") + return ID(enum_type.name) + "_Enum" def full_enum_name(enum_type: model.Enumeration) -> ID: - return ID(enum_type.identifier + "_Enum") + return enum_type.identifier + "_Enum" def sequence_name(message: model.Message, field: model.Field) -> ID: - return ID(message.types[field].identifier) + return message.types[field].identifier -def contains_function_name( - refinement_package: rid.ID, pdu: rid.ID, sdu: rid.ID, field: rid.ID -) -> str: +def contains_function_name(refinement_package: ID, pdu: ID, sdu: ID, field: ID) -> str: sdu_name = sdu.name if sdu.parent == refinement_package else sdu pdu_name = pdu.name if pdu.parent == refinement_package else pdu return f"{sdu_name.flat}_In_{pdu_name.flat}_{field}" @@ -908,7 +906,7 @@ def create_sequence_instantiation( flat: bool = False, ) -> Tuple[List[ContextItem], GenericPackageInstantiation]: element_type = sequence_type.element_type - element_type_package = ID(element_type.package.name) + element_type_package = element_type.package.name sequence_context: List[ContextItem] = [] sequence_package: GenericPackageInstantiation @@ -936,7 +934,7 @@ def create_sequence_instantiation( ], ) elif isinstance(element_type, model.Scalar): - element_type_identifier = ID(prefix * element_type.identifier) + element_type_identifier = prefix * element_type.identifier sequence_context = [ WithClause(prefix * const.SCALAR_SEQUENCE_PACKAGE), *( @@ -1093,8 +1091,11 @@ def byte_aligned_field(prefix: str, message: model.Message, field: model.Field) return Equal( Rem( Call( - ID(prefix * message.identifier * "Field_First"), - [Variable("Ctx"), Variable(ID(prefix * message.identifier * field.affixed_name))], + prefix * message.identifier * "Field_First", + [ + Variable("Ctx"), + Variable(prefix * message.identifier * field.affixed_name), + ], ), Size(const.TYPES_BYTE), ), diff --git a/rflx/generator/const.py b/rflx/generator/const.py index 6b83ce3601..d33db1a96e 100644 --- a/rflx/generator/const.py +++ b/rflx/generator/const.py @@ -1,15 +1,16 @@ from rflx import ada from rflx.common import file_name +from rflx.identifier import ID -REFINEMENT_PACKAGE = ada.ID("Contains") +REFINEMENT_PACKAGE = ID("Contains") -ARITHMETIC_PACKAGE = ada.ID("RFLX_Arithmetic") -BUILTIN_TYPES_CONVERSIONS_PACKAGE = ada.ID("RFLX_Builtin_Types.Conversions") -BUILTIN_TYPES_PACKAGE = ada.ID("RFLX_Builtin_Types") -GENERIC_TYPES_PACKAGE = ada.ID("RFLX_Generic_Types") -MESSAGE_SEQUENCE_PACKAGE = ada.ID("RFLX_Message_Sequence") -SCALAR_SEQUENCE_PACKAGE = ada.ID("RFLX_Scalar_Sequence") -TYPES_PACKAGE = ada.ID("RFLX_Types") +ARITHMETIC_PACKAGE = ID("RFLX_Arithmetic") +BUILTIN_TYPES_CONVERSIONS_PACKAGE = ID("RFLX_Builtin_Types.Conversions") +BUILTIN_TYPES_PACKAGE = ID("RFLX_Builtin_Types") +GENERIC_TYPES_PACKAGE = ID("RFLX_Generic_Types") +MESSAGE_SEQUENCE_PACKAGE = ID("RFLX_Message_Sequence") +SCALAR_SEQUENCE_PACKAGE = ID("RFLX_Scalar_Sequence") +TYPES_PACKAGE = ID("RFLX_Types") LIBRARY_FILES = [ file_name(str(p)) + ".ads" diff --git a/rflx/generator/generator.py b/rflx/generator/generator.py index 8331ab1e8f..da257749b2 100644 --- a/rflx/generator/generator.py +++ b/rflx/generator/generator.py @@ -13,7 +13,6 @@ from rflx import __version__, expression as expr from rflx.ada import ( FALSE, - ID, TRUE, Add, Aggregate, @@ -68,7 +67,6 @@ SizeAspect, Slice, SparkMode, - StrID, String, Subprogram, SubprogramBody, @@ -86,6 +84,7 @@ from rflx.common import file_name from rflx.const import BUILTINS_PACKAGE, INTERNAL_PACKAGE, MAX_SCALAR_SIZE from rflx.error import Subsystem, fail, warn +from rflx.identifier import ID, StrID from rflx.integration import Integration from rflx.model import ( BOOLEAN, @@ -228,11 +227,11 @@ def _generate(self, model: Model, integration: Integration) -> dict[ID, Unit]: log.info("Generating %s", t.identifier) if t.package not in units: - unit = self._create_unit(ID(t.package), terminating=False) - units[ID(t.package)] = unit + unit = self._create_unit(t.package, terminating=False) + units[t.package] = unit if isinstance(t, (Scalar, Composite)): - units.update(self._create_type(t, ID(t.package), units)) + units.update(self._create_type(t, t.package, units)) elif isinstance(t, Message): # https://github.com/Componolit/RecordFlux/issues/276 @@ -260,8 +259,8 @@ def _generate(self, model: Model, integration: Integration) -> dict[ID, Unit]: log.info("Generating %s", s.identifier) if s.package not in units: - unit = self._create_unit(ID(s.package), terminating=False) - units[ID(s.package)] = unit + unit = self._create_unit(s.package, terminating=False) + units[s.package] = unit units.update(self._create_session(s, integration)) @@ -367,16 +366,16 @@ def _create_message(self, message: Message) -> dict[ID, Unit]: if isinstance(field_type, Scalar) and field_type.package != message.package: context.extend( [ - WithClause(self._prefix * ID(field_type.package)), - UsePackageClause(self._prefix * ID(field_type.package)), + WithClause(self._prefix * field_type.package), + UsePackageClause(self._prefix * field_type.package), ] ) elif isinstance(field_type, Sequence): - context.append(WithClause(self._prefix * ID(field_type.identifier))) + context.append(WithClause(self._prefix * field_type.identifier)) - unit = self._create_unit(ID(message.identifier), context) - units[ID(message.identifier)] = unit + unit = self._create_unit(message.identifier, context) + units[message.identifier] = unit scalar_fields = {} composite_fields = [] @@ -642,8 +641,8 @@ def find_literals(expression: expr.Expr) -> expr.Expr: if len(l.identifier.parts) == 2 and l.identifier.parent != refinement.package: unit.declaration_context.extend( [ - WithClause(self._prefix * ID(l.identifier.parent)), - UsePackageClause(self._prefix * ID(l.identifier.parent)), + WithClause(self._prefix * l.identifier.parent), + UsePackageClause(self._prefix * l.identifier.parent), ] ) @@ -661,13 +660,13 @@ def find_literals(expression: expr.Expr) -> expr.Expr: unit.declaration_context.extend( [ - WithClause(self._prefix * ID(pdu_package)), - UsePackageClause(self._prefix * ID(pdu_package)), + WithClause(self._prefix * pdu_package), + UsePackageClause(self._prefix * pdu_package), ] ) - pdu_identifier = self._prefix * ID(refinement.pdu.identifier) - sdu_identifier = self._prefix * ID(refinement.sdu.identifier) + pdu_identifier = self._prefix * refinement.pdu.identifier + sdu_identifier = self._prefix * refinement.sdu.identifier unit.declaration_context.append(WithClause(pdu_identifier)) @@ -862,23 +861,23 @@ def _enumeration_functions(self, enum: Enumeration) -> UnitPart: ["Enum"], self._prefix * ( - ID(common.full_enum_name(enum)) + common.full_enum_name(enum) if enum.always_valid - else ID(enum.identifier) + else enum.identifier ), ) ], ), Case( Variable("Enum"), - [(Variable(ID(key)), value.ada_expr()) for key, value in enum.literals.items()], + [(Variable(key), value.ada_expr()) for key, value in enum.literals.items()], ), ) ) conversion_function = FunctionSpecification( "To_Actual", - self._prefix * ID(enum.identifier), + self._prefix * enum.identifier, [Parameter(["Val"], self._prefix * const.TYPES_BASE_INT)], ) precondition = Precondition(Call(f"Valid_{enum.name}", [Variable("Val")])) @@ -889,7 +888,7 @@ def _enumeration_functions(self, enum: Enumeration) -> UnitPart: ExpressionFunctionDeclaration( FunctionSpecification( "To_Actual", - self._prefix * ID(enum.identifier), + self._prefix * enum.identifier, [Parameter(["Enum"], common.enum_name(enum))], ), Aggregate(TRUE, Variable("Enum")), @@ -897,7 +896,7 @@ def _enumeration_functions(self, enum: Enumeration) -> UnitPart: ) conversion_cases.extend( - (value.ada_expr(), Aggregate(Variable("True"), Variable(ID(key)))) + (value.ada_expr(), Aggregate(Variable("True"), Variable(key))) for key, value in enum.literals.items() ) conversion_cases.append( @@ -915,7 +914,7 @@ def _enumeration_functions(self, enum: Enumeration) -> UnitPart: FunctionSpecification( "To_Base_Integer", self._prefix * const.TYPES_BASE_INT, - [Parameter(["Val"], self._prefix * ID(enum.identifier))], + [Parameter(["Val"], self._prefix * enum.identifier)], ), If( [(Variable("Val.Known"), Call("To_Base_Integer", [Variable("Val.Enum")]))], @@ -926,12 +925,9 @@ def _enumeration_functions(self, enum: Enumeration) -> UnitPart: else: conversion_cases.extend( [ - *[ - (value.ada_expr(), Variable(ID(key))) - for key, value in enum.literals.items() - ], + *[(value.ada_expr(), Variable(key)) for key, value in enum.literals.items()], *( - [(Variable("others"), Last(self._prefix * ID(enum.identifier)))] + [(Variable("others"), Last(self._prefix * enum.identifier))] if incomplete else [] ), @@ -956,7 +952,7 @@ def _create_contains_function( condition_fields: ty.Mapping[Field, Type], null_sdu: bool, ) -> SubprogramUnitPart: - pdu_identifier = self._prefix * ID(refinement.pdu.identifier) + pdu_identifier = self._prefix * refinement.pdu.identifier condition = refinement.condition for f, t in condition_fields.items(): if isinstance(t, Enumeration) and t.always_valid: @@ -988,7 +984,7 @@ def _create_contains_function( specification = FunctionSpecification( contains_function_name(refinement), "Boolean", - [Parameter(["Ctx"], ID(pdu_identifier) * "Context")], + [Parameter(["Ctx"], pdu_identifier * "Context")], ) return SubprogramUnitPart( @@ -1008,8 +1004,8 @@ def _create_contains_function( def _create_switch_procedure( self, refinement: Refinement, condition_fields: ty.Mapping[Field, Type] ) -> UnitPart: - pdu_identifier = self._prefix * ID(refinement.pdu.identifier) - sdu_identifier = self._prefix * ID(refinement.sdu.identifier) + pdu_identifier = self._prefix * refinement.pdu.identifier + sdu_identifier = self._prefix * refinement.sdu.identifier pdu_context = f"{refinement.pdu.identifier.flat}_PDU_Context" sdu_context = f"{refinement.sdu.identifier.flat}_SDU_Context" refined_field_affixed_name = pdu_identifier * refinement.field.affixed_name @@ -1017,8 +1013,8 @@ def _create_switch_procedure( specification = ProcedureSpecification( f"Switch_To_{refinement.field.name}", [ - InOutParameter([pdu_context], ID(pdu_identifier) * "Context"), - OutParameter([sdu_context], ID(sdu_identifier) * "Context"), + InOutParameter([pdu_context], pdu_identifier * "Context"), + OutParameter([sdu_context], sdu_identifier * "Context"), ], ) @@ -1039,7 +1035,7 @@ def _create_switch_procedure( ], Call( self._prefix - * ID(refinement.package) + * refinement.package * const.REFINEMENT_PACKAGE * contains_function_name(refinement), [Variable(pdu_context)], @@ -1157,17 +1153,17 @@ def _create_switch_procedure( def _create_copy_refined_field_procedure( self, refinement: Refinement, condition_fields: ty.Mapping[Field, Type] ) -> UnitPart: - pdu_identifier = self._prefix * ID(refinement.pdu.identifier) - sdu_identifier = self._prefix * ID(refinement.sdu.identifier) - pdu_context = ID(refinement.pdu.identifier.flat) + "_PDU_Context" - sdu_context = ID(refinement.sdu.identifier.flat) + "_SDU_Context" + pdu_identifier = self._prefix * refinement.pdu.identifier + sdu_identifier = self._prefix * refinement.sdu.identifier + pdu_context = ID(refinement.pdu.identifier.flat + "_PDU_Context") + sdu_context = ID(refinement.sdu.identifier.flat + "_SDU_Context") refined_field_affixed_name = pdu_identifier * refinement.field.affixed_name specification = ProcedureSpecification( f"Copy_{refinement.field.name}", [ - Parameter([pdu_context], ID(pdu_identifier) * "Context"), - InOutParameter([sdu_context], ID(sdu_identifier) * "Context"), + Parameter([pdu_context], pdu_identifier * "Context"), + InOutParameter([sdu_context], sdu_identifier * "Context"), ], ) @@ -1188,7 +1184,7 @@ def _create_copy_refined_field_procedure( ], Call( self._prefix - * ID(refinement.package) + * refinement.package * const.REFINEMENT_PACKAGE * contains_function_name(refinement), [Variable(pdu_context)], @@ -1282,7 +1278,7 @@ def _create_copy_refined_field_procedure( [ Variable("Off"), String( - f'"{sdu_context}" is set by "Take_Buffer"' + f'"{sdu_context.ada_str}" is set by "Take_Buffer"' " but not used after the call" ), ], @@ -1296,7 +1292,7 @@ def _create_copy_refined_field_procedure( [ Variable("On"), String( - f'"{sdu_context}" is set by "Take_Buffer"' + f'"{sdu_context.ada_str}" is set by "Take_Buffer"' " but not used after the call" ), ], @@ -1387,17 +1383,17 @@ def _integer_conversion_functions(self, integer: Integer) -> ty.Sequence[Subprog FunctionSpecification( "To_Base_Integer", self._prefix * const.TYPES_BASE_INT, - [Parameter(["Val"], self._prefix * ID(integer.identifier))], + [Parameter(["Val"], self._prefix * integer.identifier)], ), Call(self._prefix * const.TYPES_BASE_INT, [Variable("Val")]), ), ExpressionFunctionDeclaration( FunctionSpecification( "To_Actual", - self._prefix * ID(integer.identifier), + self._prefix * integer.identifier, [Parameter(["Val"], self._prefix * const.TYPES_BASE_INT)], ), - Call(self._prefix * ID(integer.identifier), [Variable("Val")]), + Call(self._prefix * integer.identifier, [Variable("Val")]), [Precondition(Call(f"Valid_{integer.name}", [Variable("Val")]))], ), ] @@ -1409,7 +1405,7 @@ def _refinement_conditions( condition_fields: ty.Mapping[Field, Type], null_sdu: bool, ) -> ty.Sequence[expr.Expr]: - pdu_identifier = self._prefix * ID(refinement.pdu.identifier) + pdu_identifier = self._prefix * refinement.pdu.identifier conditions: ty.List[expr.Expr] = [ expr.Call(pdu_identifier * "Has_Buffer", [expr.Variable(pdu_context)]) @@ -1451,7 +1447,10 @@ def _refinement_conditions( [ expr.Call( pdu_identifier * "Valid", - [expr.Variable(pdu_context), expr.Variable(pdu_identifier * f.affixed_name)], + [ + expr.Variable(pdu_context), + expr.Variable(pdu_identifier * f.affixed_name), + ], ) for f in condition_fields ] @@ -1497,7 +1496,7 @@ def enumeration_types(enum: Enumeration) -> ty.List[Declaration]: types.append( EnumerationType( common.enum_name(enum) if enum.always_valid else enum.name, - {ID(k): Number(v.value) for k, v in enum.literals.items()}, + {k: Number(v.value) for k, v in enum.literals.items()}, enum.size_expr.ada_expr(), ) ) diff --git a/rflx/generator/message.py b/rflx/generator/message.py index 4c7809ba47..7941b69f6d 100644 --- a/rflx/generator/message.py +++ b/rflx/generator/message.py @@ -5,10 +5,9 @@ import itertools import typing as ty -from rflx import expression as expr, identifier as rid +from rflx import expression as expr from rflx.ada import ( FALSE, - ID, NULL, TRUE, Add, @@ -88,6 +87,7 @@ Variant, VariantPart, ) +from rflx.identifier import ID from rflx.model import ( FINAL, INITIAL, @@ -448,7 +448,7 @@ def create_context_type(message: Message) -> UnitPart: Variable("Context.Buffer"), Variable("Context.Cursors"), *[ - Variable("Context" * ID(p.identifier)) + Variable("Context" * p.identifier) for p in message.parameter_types ], ], @@ -555,7 +555,7 @@ def create_initialize_procedure(message: Message) -> UnitPart: Variable("Buffer"), Call(const.TYPES_TO_FIRST_BIT_INDEX, [First("Buffer")]), Call(const.TYPES_TO_LAST_BIT_INDEX, [Last("Buffer")]), - *[Variable(ID(p.identifier)) for p in message.parameter_types], + *[Variable(p.identifier) for p in message.parameter_types], Variable("Written_Last"), ], ) @@ -662,7 +662,7 @@ def create_restricted_initialize_procedure(message: Message) -> UnitPart: Variable("Buffer_Last"), Variable("First"), Variable("Last"), - *[Variable(ID(p.identifier)) for p in message.parameter_types], + *[Variable(p.identifier) for p in message.parameter_types], Sub(Variable("First"), Number(1)), If( [ @@ -774,7 +774,7 @@ def create_reset_procedure(prefix: str, message: Message) -> UnitPart: Precondition( And( Not(Constrained("Ctx")), - Call(ID(prefix * message.identifier * "Has_Buffer"), [Variable("Ctx")]), + Call(prefix * message.identifier * "Has_Buffer", [Variable("Ctx")]), ) ), Postcondition( @@ -818,7 +818,7 @@ def create_reset_procedure(prefix: str, message: Message) -> UnitPart: Variable("Ctx"), Call(const.TYPES_TO_FIRST_BIT_INDEX, [First("Ctx.Buffer")]), Call(const.TYPES_TO_LAST_BIT_INDEX, [Last("Ctx.Buffer")]), - *[Variable(ID(p.identifier)) for p in message.parameter_types], + *[Variable(p.identifier) for p in message.parameter_types], ], ) ], @@ -846,7 +846,7 @@ def create_restricted_reset_procedure(prefix: str, message: Message) -> UnitPart Precondition( And( Not(Constrained("Ctx")), - Call(ID(prefix * message.identifier * "Has_Buffer"), [Variable("Ctx")]), + Call(prefix * message.identifier * "Has_Buffer", [Variable("Ctx")]), GreaterEqual( Call(const.TYPES_TO_INDEX, [Variable("First")]), Variable("Ctx.Buffer_First"), @@ -891,7 +891,7 @@ def create_restricted_reset_procedure(prefix: str, message: Message) -> UnitPart Variable("Ctx.Buffer_Last"), Variable("First"), Variable("Last"), - *[Variable(ID(p.identifier)) for p in message.parameter_types], + *[Variable(p.identifier) for p in message.parameter_types], Sub(Variable("First"), Number(1)), Sub(Variable("First"), Number(1)), Variable("Ctx.Buffer"), @@ -916,7 +916,7 @@ def create_take_buffer_procedure(prefix: str, message: Message) -> UnitPart: specification, [ Precondition( - Call(ID(prefix * message.identifier * "Has_Buffer"), [Variable("Ctx")]) + Call(prefix * message.identifier * "Has_Buffer", [Variable("Ctx")]) ), Postcondition( And( @@ -958,14 +958,15 @@ def create_copy_procedure(prefix: str, message: Message) -> UnitPart: [ Precondition( AndThen( - Call(ID(prefix * message.identifier * "Has_Buffer"), [Variable("Ctx")]), + Call(prefix * message.identifier * "Has_Buffer", [Variable("Ctx")]), Call( - ID(prefix * message.identifier * "Structural_Valid_Message"), + prefix * message.identifier * "Structural_Valid_Message", [Variable("Ctx")], ), Equal( Call( - ID(prefix * message.identifier * "Byte_Size"), [Variable("Ctx")] + prefix * message.identifier * "Byte_Size", + [Variable("Ctx")], ), Length("Buffer"), ), @@ -1034,9 +1035,9 @@ def create_read_function(prefix: str, message: Message) -> UnitPart: Ghost(), Precondition( AndThen( - Call(ID(prefix * message.identifier * "Has_Buffer"), [Variable("Ctx")]), + Call(prefix * message.identifier * "Has_Buffer", [Variable("Ctx")]), Call( - ID(prefix * message.identifier * "Structural_Valid_Message"), + prefix * message.identifier * "Structural_Valid_Message", [Variable("Ctx")], ), ) @@ -1091,9 +1092,9 @@ def create_generic_read_procedure(prefix: str, message: Message) -> UnitPart: [ Precondition( AndThen( - Call(ID(prefix * message.identifier * "Has_Buffer"), [Variable("Ctx")]), + Call(prefix * message.identifier * "Has_Buffer", [Variable("Ctx")]), Call( - ID(prefix * message.identifier * "Structural_Valid_Message"), + prefix * message.identifier * "Structural_Valid_Message", [Variable("Ctx")], ), Call("Pre", [Call("Read", [Variable("Ctx")])]), @@ -1186,11 +1187,11 @@ def create_generic_write_procedure(prefix: str, message: Message) -> UnitPart: Precondition( AndThen( Not(Constrained("Ctx")), - Call(ID(prefix * message.identifier * "Has_Buffer"), [Variable("Ctx")]), + Call(prefix * message.identifier * "Has_Buffer", [Variable("Ctx")]), Less( Variable("Offset"), Call( - ID(prefix * message.identifier * "Buffer_Length"), + prefix * message.identifier * "Buffer_Length", [Variable("Ctx")], ), ), @@ -1198,7 +1199,7 @@ def create_generic_write_procedure(prefix: str, message: Message) -> UnitPart: "Pre", [ Call( - ID(prefix * message.identifier * "Buffer_Length"), + prefix * message.identifier * "Buffer_Length", [Variable("Ctx")], ), Variable("Offset"), @@ -1264,7 +1265,7 @@ def create_generic_write_procedure(prefix: str, message: Message) -> UnitPart: Variable("Ctx"), Call(const.TYPES_TO_FIRST_BIT_INDEX, [Variable("Ctx.Buffer_First")]), Call(const.TYPES_TO_LAST_BIT_INDEX, [Variable("Ctx.Buffer_Last")]), - *[Variable(ID("Ctx" * p.identifier)) for p in message.parameter_types], + *[Variable("Ctx" * p.identifier) for p in message.parameter_types], ], ), CallStatement( @@ -1439,7 +1440,7 @@ def condition(field: Field, message: Message) -> Expr: Precondition( And( Call( - ID(prefix * message.identifier * "Valid_Predecessor"), + prefix * message.identifier * "Valid_Predecessor", [Variable("Ctx"), Variable("Fld")], ), ) @@ -1492,7 +1493,7 @@ def create_field_size_function( Precondition( And( Call( - ID(prefix * message.identifier * "Valid_Next"), + prefix * message.identifier * "Valid_Next", [Variable("Ctx"), Variable("Fld")], ), ) @@ -1549,9 +1550,9 @@ def create_field_first_function(prefix: str, message: Message) -> UnitPart: contiguous_first = expr.Add( expr.Selected( expr.Indexed( - expr.Variable(rid.ID("Ctx") * "Cursors"), + expr.Variable(ID("Ctx") * "Cursors"), expr.Selected( - expr.Indexed(expr.Variable(rid.ID("Ctx") * "Cursors"), expr.Variable("Fld")), + expr.Indexed(expr.Variable(ID("Ctx") * "Cursors"), expr.Variable("Fld")), "Predecessor", ), ), @@ -1615,7 +1616,7 @@ def substituted( Precondition( And( Call( - ID(prefix * message.identifier * "Valid_Next"), + prefix * message.identifier * "Valid_Next", [Variable("Ctx"), Variable("Fld")], ), ) @@ -1666,16 +1667,16 @@ def create_field_last_function( Precondition( AndThen( Call( - ID(prefix * message.identifier * "Valid_Next"), + prefix * message.identifier * "Valid_Next", [Variable("Ctx"), Variable("Fld")], ), GreaterEqual( Call( - ID(prefix * message.identifier * "Available_Space"), + prefix * message.identifier * "Available_Space", [Variable("Ctx"), Variable("Fld")], ), Call( - ID(prefix * message.identifier * "Field_Size"), + prefix * message.identifier * "Field_Size", [Variable("Ctx"), Variable("Fld")], ), ), @@ -1739,9 +1740,9 @@ def condition(field: Field, message: Message) -> Expr: c: expr.Expr = expr.Or(*[l.condition for l in message.outgoing(field)]) c = c.substituted( mapping={ - expr.Size(field.name): expr.Call(const.TYPES_BASE_INT, [expr.Variable("Size")]), + expr.Size(field.name): expr.Call(ID(const.TYPES_BASE_INT), [expr.Variable("Size")]), expr.Last(field.name): expr.Call( - const.TYPES_BASE_INT, + ID(const.TYPES_BASE_INT), [ expr.Call( "Field_Last", @@ -1802,15 +1803,15 @@ def condition(field: Field, message: Message) -> Expr: [ Precondition( AndThen( - Call(ID(prefix * message.identifier * "Has_Buffer"), [Variable("Ctx")]), + Call(prefix * message.identifier * "Has_Buffer", [Variable("Ctx")]), Call( - ID(prefix * message.identifier * "Valid_Predecessor"), + prefix * message.identifier * "Valid_Predecessor", [Variable("Ctx"), Variable("Fld")], ), *( [ Call( - ID(prefix * message.identifier * "Valid_Value"), + prefix * message.identifier * "Valid_Value", [Variable("Fld"), Variable("Val")], ) ] @@ -1818,16 +1819,16 @@ def condition(field: Field, message: Message) -> Expr: else [] ), Call( - ID(prefix * message.identifier * "Valid_Next"), + prefix * message.identifier * "Valid_Next", [Variable("Ctx"), Variable("Fld")], ), GreaterEqual( Call( - ID(prefix * message.identifier * "Available_Space"), + prefix * message.identifier * "Available_Space", [Variable("Ctx"), Variable("Fld")], ), Call( - ID(prefix * message.identifier * "Field_Size"), + prefix * message.identifier * "Field_Size", [Variable("Ctx"), Variable("Fld")], ), ), @@ -1936,13 +1937,13 @@ def create_successor_function(prefix: str, message: Message) -> UnitPart: [ Precondition( And( - Call(ID(prefix * message.identifier * "Has_Buffer"), [Variable("Ctx")]), + Call(prefix * message.identifier * "Has_Buffer", [Variable("Ctx")]), Call( - ID(prefix * message.identifier * "Structural_Valid"), + prefix * message.identifier * "Structural_Valid", [Variable("Ctx"), Variable("Fld")], ), Call( - ID(prefix * message.identifier * "Valid_Predecessor"), + prefix * message.identifier * "Valid_Predecessor", [Variable("Ctx"), Variable("Fld")], ), ) @@ -2018,11 +2019,7 @@ def create_buffer_length_function(prefix: str, message: Message) -> UnitPart: [ SubprogramDeclaration( specification, - [ - Precondition( - Call(ID(prefix * message.identifier * "Has_Buffer"), [Variable("Ctx")]) - ) - ], + [Precondition(Call(prefix * message.identifier * "Has_Buffer", [Variable("Ctx")]))], ) ], private=[ExpressionFunctionDeclaration(specification, Length("Ctx.Buffer"))], @@ -2069,7 +2066,7 @@ def create_valid_predecessor_function( else "Valid", [ expr.Indexed( - expr.Variable(rid.ID("Ctx") * "Cursors"), + expr.Variable(ID("Ctx") * "Cursors"), expr.Variable(p.affixed_name), ) ], @@ -2079,7 +2076,7 @@ def create_valid_predecessor_function( expr.Equal( expr.Selected( expr.Indexed( - expr.Variable(rid.ID("Ctx") * "Cursors"), + expr.Variable(ID("Ctx") * "Cursors"), expr.Variable("Fld"), ), "Predecessor", @@ -2162,9 +2159,9 @@ def create_message_last_function(prefix: str, message: Message) -> UnitPart: [ Precondition( AndThen( - Call(ID(prefix * message.identifier * "Has_Buffer"), [Variable("Ctx")]), + Call(prefix * message.identifier * "Has_Buffer", [Variable("Ctx")]), Call( - ID(prefix * message.identifier * "Structural_Valid_Message"), + prefix * message.identifier * "Structural_Valid_Message", [Variable("Ctx")], ), ) @@ -2206,15 +2203,15 @@ def create_data_procedure(prefix: str, message: Message) -> UnitPart: [ Precondition( AndThen( - Call(ID(prefix * message.identifier * "Has_Buffer"), [Variable("Ctx")]), + Call(prefix * message.identifier * "Has_Buffer", [Variable("Ctx")]), Call( - ID(prefix * message.identifier * "Structural_Valid_Message"), + prefix * message.identifier * "Structural_Valid_Message", [Variable("Ctx")], ), Equal( Length("Data"), Call( - ID(prefix * message.identifier * "Byte_Size"), + prefix * message.identifier * "Byte_Size", [ Variable("Ctx"), ], @@ -2279,7 +2276,7 @@ def create_available_space_function(prefix: str, message: Message) -> UnitPart: [ Precondition( Call( - ID(prefix * message.identifier * "Valid_Next"), + prefix * message.identifier * "Valid_Next", [Variable("Ctx"), Variable("Fld")], ) ) @@ -2350,9 +2347,9 @@ def create_equal_function( [ Precondition( And( - Call(ID(prefix * message.identifier * "Has_Buffer"), [Variable("Ctx")]), + Call(prefix * message.identifier * "Has_Buffer", [Variable("Ctx")]), Call( - ID(prefix * message.identifier * "Valid_Next"), + prefix * message.identifier * "Valid_Next", [Variable("Ctx"), Variable("Fld")], ), ) @@ -2439,9 +2436,9 @@ def create_sufficient_buffer_length_function(prefix: str, message: Message) -> U [ Precondition( And( - Call(ID(prefix * message.identifier * "Has_Buffer"), [Variable("Ctx")]), + Call(prefix * message.identifier * "Has_Buffer", [Variable("Ctx")]), Call( - ID(prefix * message.identifier * "Valid_Next"), + prefix * message.identifier * "Valid_Next", [Variable("Ctx"), Variable("Fld")], ), ) @@ -2546,7 +2543,7 @@ def create_reset_dependent_fields_procedure(prefix: str, message: Message) -> Un Precondition( And( Call( - ID(prefix * message.identifier * "Valid_Next"), + prefix * message.identifier * "Valid_Next", [Variable("Ctx"), Variable("Fld")], ), ), @@ -2652,28 +2649,28 @@ def specification(field: Field) -> ProcedureSpecification: AndThen( Not(Constrained("Ctx")), Not(Constrained("Seq_Ctx")), - Call(ID(prefix * message.identifier * "Has_Buffer"), [Variable("Ctx")]), + Call(prefix * message.identifier * "Has_Buffer", [Variable("Ctx")]), Call( - ID(prefix * message.identifier * "Valid_Next"), + prefix * message.identifier * "Valid_Next", [ Variable("Ctx"), - Variable(ID(prefix * message.identifier * f.affixed_name)), + Variable(prefix * message.identifier * f.affixed_name), ], ), Greater( Call( - ID(prefix * message.identifier * "Field_Size"), + prefix * message.identifier * "Field_Size", [ Variable("Ctx"), - Variable(ID(prefix * message.identifier * f.affixed_name)), + Variable(prefix * message.identifier * f.affixed_name), ], ), Number(0), ), common.byte_aligned_field(prefix, message, f), common.sufficient_space_for_field_condition( - ID(prefix * message.identifier), - Variable(ID(prefix * message.identifier * f.affixed_name)), + prefix * message.identifier, + Variable(prefix * message.identifier * f.affixed_name), ), common.field_condition_call(prefix, message, f), ) @@ -2819,10 +2816,10 @@ def specification(field: Field) -> FunctionSpecification: [ Precondition( Call( - ID(prefix * message.identifier * "Valid_Next"), + prefix * message.identifier * "Valid_Next", [ Variable("Ctx"), - Variable(ID(prefix * message.identifier * f.affixed_name)), + Variable(prefix * message.identifier * f.affixed_name), ], ), ) @@ -2888,14 +2885,14 @@ def take_buffer_arguments(field: Field) -> ty.Sequence[Expr]: Precondition( AndThen( Call( - ID(prefix * message.identifier * "Present"), + prefix * message.identifier * "Present", [ Variable("Ctx"), - Variable(ID(prefix * message.identifier * f.affixed_name)), + Variable(prefix * message.identifier * f.affixed_name), ], ), Call( - ID(prefix * message.identifier * f"Complete_{f.name}"), + prefix * message.identifier * f"Complete_{f.name}", [Variable("Ctx"), Variable("Seq_Ctx")], ), *_switch_update_conditions(prefix, message, f), @@ -3109,7 +3106,7 @@ def _create_structure_type(prefix: str, message: Message) -> UnitPart: component_type: ty.Union[ID, Expr] if isinstance(type_, Scalar): - component_type = common.prefixed_type_identifier(ID(type_.identifier), prefix) + component_type = common.prefixed_type_identifier(type_.identifier, prefix) elif isinstance(type_, Opaque): component_type = Indexed( Variable(const.TYPES_BYTES), @@ -3129,7 +3126,7 @@ def _create_structure_type(prefix: str, message: Message) -> UnitPart: else: assert False - components.append(Component(ID(link.target.identifier), component_type)) + components.append(Component(link.target.identifier, component_type)) return UnitPart( [ @@ -3145,7 +3142,7 @@ def _create_valid_structure_function(prefix: str, message: Message) -> UnitPart: Call( ID(prefix * t.package * f"Valid_{t.name}"), [ - Variable(ID("Struct" * f.identifier)), + Variable("Struct" * f.identifier), ], ) for f, t in message.types.items() @@ -3329,9 +3326,9 @@ def _create_to_structure_procedure(prefix: str, message: Message) -> UnitPart: [ Precondition( AndThen( - Call(ID(prefix * message.identifier * "Has_Buffer"), [Variable("Ctx")]), + Call(prefix * message.identifier * "Has_Buffer", [Variable("Ctx")]), Call( - ID(prefix * message.identifier * "Structural_Valid_Message"), + prefix * message.identifier * "Structural_Valid_Message", [Variable("Ctx")], ), ) @@ -3370,7 +3367,7 @@ def func(expression: expr.Expr) -> expr.Expr: if isinstance(field_type, Scalar): return expr.Call( - const.TYPES_BASE_INT, + ID(const.TYPES_BASE_INT), [expr.Variable("Struct" * expression.identifier)], ) @@ -3406,7 +3403,7 @@ def _create_to_context_procedure(prefix: str, message: Message) -> UnitPart: ) .substituted( lambda x: expr.Call( - const.TYPES_BIT_LENGTH, + ID(const.TYPES_BIT_LENGTH), [expr.Variable("Struct" * x.identifier)], ) if isinstance(x, expr.Variable) @@ -3462,13 +3459,13 @@ def _create_to_context_procedure(prefix: str, message: Message) -> UnitPart: Precondition( AndThen( Not(Constrained("Ctx")), - Call(ID(prefix * message.identifier * "Has_Buffer"), [Variable("Ctx")]), + Call(prefix * message.identifier * "Has_Buffer", [Variable("Ctx")]), Call( - ID(prefix * message.identifier * "Valid_Structure"), + prefix * message.identifier * "Valid_Structure", [Variable("Struct")], ), Call( - ID(prefix * message.identifier * "Sufficient_Buffer_Length"), + prefix * message.identifier * "Sufficient_Buffer_Length", [Variable("Ctx"), Variable("Struct")], ), ) @@ -3497,7 +3494,7 @@ def _create_to_context_procedure(prefix: str, message: Message) -> UnitPart: def _switch_update_conditions(prefix: str, message: Message, field: Field) -> ty.Sequence[Expr]: return [ - Not(Call(ID(prefix * message.identifier * "Has_Buffer"), [Variable("Ctx")])), + Not(Call(prefix * message.identifier * "Has_Buffer", [Variable("Ctx")])), Call(prefix * common.sequence_name(message, field) * "Has_Buffer", [Variable("Seq_Ctx")]), Equal(Variable("Ctx.Buffer_First"), Variable("Seq_Ctx.Buffer_First")), Equal(Variable("Ctx.Buffer_Last"), Variable("Seq_Ctx.Buffer_Last")), diff --git a/rflx/generator/parser.py b/rflx/generator/parser.py index 384d46d164..3a9b6ad08f 100644 --- a/rflx/generator/parser.py +++ b/rflx/generator/parser.py @@ -4,7 +4,6 @@ import rflx.expression as expr from rflx.ada import ( - ID, TRUE, Add, And, @@ -60,6 +59,7 @@ Variable, ) from rflx.const import BUILTINS_PACKAGE +from rflx.identifier import ID from rflx.model import FINAL, ByteOrder, Composite, Field, Message, Scalar, Type from . import common, const @@ -197,11 +197,11 @@ def create_get_function( Precondition( AndThen( Call( - ID(self.prefix * message.identifier * "Has_Buffer"), + self.prefix * message.identifier * "Has_Buffer", [Variable("Ctx")], ), Call( - ID(self.prefix * message.identifier * "Valid_Next"), + self.prefix * message.identifier * "Valid_Next", [Variable("Ctx"), Variable("Fld")], ), Call( @@ -382,7 +382,7 @@ def create_verify_procedure( [ Precondition( Call( - ID(self.prefix * message.identifier * "Has_Buffer"), + self.prefix * message.identifier * "Has_Buffer", [Variable("Ctx")], ) ), @@ -527,7 +527,7 @@ def create_verify_message_procedure(self, message: Message) -> UnitPart: [ Precondition( Call( - ID(self.prefix * message.identifier * "Has_Buffer"), + self.prefix * message.identifier * "Has_Buffer", [Variable("Ctx")], ) ), @@ -719,7 +719,7 @@ def create_structural_valid_message_function(self, message: Message) -> UnitPart [ Precondition( Call( - ID(self.prefix * message.identifier * "Has_Buffer"), + self.prefix * message.identifier * "Has_Buffer", [Variable("Ctx")], ) ) @@ -746,7 +746,7 @@ def create_valid_message_function(self, message: Message) -> UnitPart: [ Precondition( Call( - ID(self.prefix * message.identifier * "Has_Buffer"), + self.prefix * message.identifier * "Has_Buffer", [Variable("Ctx")], ) ) @@ -802,7 +802,7 @@ def specification(field: Field, field_type: Type) -> FunctionSpecification: if field_type.package == BUILTINS_PACKAGE: type_identifier = ID(field_type.name) else: - type_identifier = self.prefix * ID(field_type.identifier) + type_identifier = self.prefix * field_type.identifier return FunctionSpecification( f"Get_{field.name}", type_identifier, [Parameter(["Ctx"], "Context")] @@ -824,12 +824,10 @@ def result(field: Field) -> Expr: [ Precondition( Call( - ID(self.prefix * message.identifier * "Valid"), + self.prefix * message.identifier * "Valid", [ Variable("Ctx"), - Variable( - ID(self.prefix * message.identifier * f.affixed_name) - ), + Variable(self.prefix * message.identifier * f.affixed_name), ], ), ) @@ -867,25 +865,21 @@ def specification(field: Field) -> FunctionSpecification: Precondition( AndThen( Call( - ID(self.prefix * message.identifier * "Has_Buffer"), + self.prefix * message.identifier * "Has_Buffer", [Variable("Ctx")], ), Call( - ID(self.prefix * message.identifier * "Structural_Valid"), + self.prefix * message.identifier * "Structural_Valid", [ Variable("Ctx"), - Variable( - ID(self.prefix * message.identifier * f.affixed_name) - ), + Variable(self.prefix * message.identifier * f.affixed_name), ], ), Call( - ID(self.prefix * message.identifier * "Valid_Next"), + self.prefix * message.identifier * "Valid_Next", [ Variable("Ctx"), - Variable( - ID(self.prefix * message.identifier * f.affixed_name) - ), + Variable(self.prefix * message.identifier * f.affixed_name), ], ), ) @@ -977,25 +971,21 @@ def specification(field: Field) -> ProcedureSpecification: Precondition( AndThen( Call( - ID(self.prefix * message.identifier * "Has_Buffer"), + self.prefix * message.identifier * "Has_Buffer", [Variable("Ctx")], ), Call( - ID(self.prefix * message.identifier * "Structural_Valid"), + self.prefix * message.identifier * "Structural_Valid", [ Variable("Ctx"), - Variable( - ID(self.prefix * message.identifier * f.affixed_name) - ), + Variable(self.prefix * message.identifier * f.affixed_name), ], ), Call( - ID(self.prefix * message.identifier * "Valid_Next"), + self.prefix * message.identifier * "Valid_Next", [ Variable("Ctx"), - Variable( - ID(self.prefix * message.identifier * f.affixed_name) - ), + Variable(self.prefix * message.identifier * f.affixed_name), ], ), Equal( @@ -1004,7 +994,7 @@ def specification(field: Field) -> ProcedureSpecification: const.TYPES_TO_LENGTH, [ Call( - ID(self.prefix * message.identifier * "Field_Size"), + self.prefix * message.identifier * "Field_Size", [ Variable("Ctx"), Variable( @@ -1113,16 +1103,14 @@ def specification(field: Field) -> ProcedureSpecification: Precondition( And( Call( - ID(self.prefix * message.identifier * "Has_Buffer"), + self.prefix * message.identifier * "Has_Buffer", [Variable("Ctx")], ), Call( - ID(self.prefix * message.identifier * "Present"), + self.prefix * message.identifier * "Present", [ Variable("Ctx"), - Variable( - ID(self.prefix * message.identifier * f.affixed_name) - ), + Variable(self.prefix * message.identifier * f.affixed_name), ], ), ) diff --git a/rflx/generator/serializer.py b/rflx/generator/serializer.py index a69ddc7c74..e7b53c19a4 100644 --- a/rflx/generator/serializer.py +++ b/rflx/generator/serializer.py @@ -5,7 +5,6 @@ from rflx import expression as expr from rflx.ada import ( - ID, TRUE, Add, Aggregate, @@ -51,7 +50,6 @@ Size, Slice, Statement, - StrID, String, Sub, SubprogramBody, @@ -62,6 +60,7 @@ Variable, ) from rflx.const import BUILTINS_PACKAGE +from rflx.identifier import ID, StrID from rflx.model import ( FINAL, INITIAL, @@ -152,7 +151,7 @@ def create_valid_size_function(self, message: Message) -> UnitPart: Precondition( And( Call( - ID(self.prefix * message.identifier * "Valid_Next"), + self.prefix * message.identifier * "Valid_Next", [Variable("Ctx"), Variable("Fld")], ), ) @@ -186,7 +185,7 @@ def create_valid_length_function(self, message: Message) -> UnitPart: Precondition( And( Call( - ID(self.prefix * message.identifier * "Valid_Next"), + self.prefix * message.identifier * "Valid_Next", [Variable("Ctx"), Variable("Fld")], ), ) @@ -393,25 +392,25 @@ def set_context_cursor(field_type: CursorState) -> Assignment: Precondition( AndThen( Call( - ID(self.prefix * message.identifier * "Has_Buffer"), + self.prefix * message.identifier * "Has_Buffer", [Variable("Ctx")], ), Call( - ID(self.prefix * message.identifier * "Valid_Next"), + self.prefix * message.identifier * "Valid_Next", [Variable("Ctx"), Variable("Fld")], ), Call( - ID(self.prefix * message.identifier * "Valid_Value"), + self.prefix * message.identifier * "Valid_Value", [Variable("Fld"), Variable("Val")], ), Call( - ID(self.prefix * message.identifier * "Valid_Size"), + self.prefix * message.identifier * "Valid_Size", [Variable("Ctx"), Variable("Fld"), Variable("Size")], ), LessEqual( Variable("Size"), Call( - ID(self.prefix * message.identifier * "Available_Space"), + self.prefix * message.identifier * "Available_Space", [Variable("Ctx"), Variable("Fld")], ), ), @@ -421,11 +420,9 @@ def set_context_cursor(field_type: CursorState) -> Assignment: [ ( Call( - ID( - self.prefix - * message.identifier - * "Composite_Field" - ), + self.prefix + * message.identifier + * "Composite_Field", [Variable("Fld")], ), Equal( @@ -585,7 +582,7 @@ def specification( ) else: type_identifier = common.prefixed_type_identifier( - ID(field_type.identifier), self.prefix + field_type.identifier, self.prefix ) return ProcedureSpecification( @@ -599,12 +596,12 @@ def precondition( return Precondition( AndThen( *self.setter_preconditions( - message, ID(self.prefix * message.identifier * field.affixed_name) + message, self.prefix * message.identifier * field.affixed_name ), Call( f"Valid_{field_type.name}" if is_builtin_type(field_type.identifier) - else ID(self.prefix * field_type.package * f"Valid_{field_type.name}"), + else self.prefix * field_type.package * f"Valid_{field_type.name}", [ Variable("Val") if use_enum_records_directly @@ -615,8 +612,8 @@ def precondition( ], ), common.sufficient_space_for_field_condition( - ID(self.prefix * message.identifier), - Variable(ID(self.prefix * message.identifier * field.affixed_name)), + self.prefix * message.identifier, + Variable(self.prefix * message.identifier * field.affixed_name), ), common.field_condition_call( self.prefix, @@ -797,26 +794,26 @@ def body( ChoiceList(*[Variable(f.affixed_name) for f in scalar_fields]), ), Call( - ID(self.prefix * message.identifier * "Valid_Value"), + self.prefix * message.identifier * "Valid_Value", [Variable("Fld"), Variable("Val")], ), Call( - ID(self.prefix * message.identifier * "Valid_Size"), + self.prefix * message.identifier * "Valid_Size", [ Variable("Ctx"), Variable("Fld"), Call( - ID(self.prefix * message.identifier * "Field_Size"), + self.prefix * message.identifier * "Field_Size", [Variable("Ctx"), Variable("Fld")], ), ], ), common.sufficient_space_for_field_condition( - ID(self.prefix * message.identifier), Variable("Fld") + self.prefix * message.identifier, Variable("Fld") ), In( Call( - ID(self.prefix * message.identifier * "Field_Size"), + self.prefix * message.identifier * "Field_Size", [Variable("Ctx"), Variable("Fld")], ), ValueRange(Number(1), Size(const.TYPES_BASE_INT)), @@ -829,11 +826,7 @@ def body( "Natural", [ Call( - ID( - self.prefix - * message.identifier - * "Field_Size" - ), + self.prefix * message.identifier * "Field_Size", [Variable("Ctx"), Variable("Fld")], ) ], @@ -907,7 +900,7 @@ def specification(field: Field) -> ProcedureSpecification: AndThen( *self.setter_preconditions( message, - ID(self.prefix * message.identifier * f.affixed_name), + self.prefix * message.identifier * f.affixed_name, ), *self.composite_setter_preconditions(message, f), *self.composite_setter_field_condition_precondition( @@ -915,15 +908,13 @@ def specification(field: Field) -> ProcedureSpecification: ), Equal( Call( - ID(self.prefix * message.identifier * "Field_Size"), + self.prefix * message.identifier * "Field_Size", [ Variable("Ctx"), Variable( - ID( - self.prefix - * message.identifier - * f.affixed_name - ) + self.prefix + * message.identifier + * f.affixed_name ), ], ), @@ -996,19 +987,18 @@ def specification(field: Field) -> ProcedureSpecification: Precondition( AndThen( *self.setter_preconditions( - message, ID(self.prefix * message.identifier * f.affixed_name) + message, + self.prefix * message.identifier * f.affixed_name, ), *self.composite_setter_preconditions(message, f), *self.composite_setter_field_condition_precondition( message, f, empty=True ), Call( - ID(self.prefix * message.identifier * "Valid_Length"), + self.prefix * message.identifier * "Valid_Length", [ Variable("Ctx"), - Variable( - ID(self.prefix * message.identifier * f.affixed_name) - ), + Variable(self.prefix * message.identifier * f.affixed_name), Call( self.prefix * common.sequence_name(message, f) @@ -1123,22 +1113,21 @@ def specification(field: Field) -> ProcedureSpecification: Precondition( AndThen( *self.setter_preconditions( - message, ID(self.prefix * message.identifier * f.affixed_name) + message, + self.prefix * message.identifier * f.affixed_name, ), *self.composite_setter_preconditions(message, f), Call( - ID(self.prefix * message.identifier * "Valid_Length"), + self.prefix * message.identifier * "Valid_Length", [ Variable("Ctx"), - Variable( - ID(self.prefix * message.identifier * f.affixed_name) - ), + Variable(self.prefix * message.identifier * f.affixed_name), Length("Data"), ], ), common.sufficient_space_for_field_condition( - ID(self.prefix * message.identifier), - Variable(ID(self.prefix * message.identifier * f.affixed_name)), + self.prefix * message.identifier, + Variable(self.prefix * message.identifier * f.affixed_name), Mul(Length("Data"), Size(const.TYPES_BYTE)), ), *self.composite_setter_field_condition_precondition(message, f), @@ -1283,16 +1272,15 @@ def formal_parameters(field: Field) -> List[FormalSubprogramDeclaration]: Precondition( AndThen( *self.setter_preconditions( - message, ID(self.prefix * message.identifier * f.affixed_name) + message, + self.prefix * message.identifier * f.affixed_name, ), *self.composite_setter_preconditions(message, f), Call( - ID(self.prefix * message.identifier * "Valid_Length"), + self.prefix * message.identifier * "Valid_Length", [ Variable("Ctx"), - Variable( - ID(self.prefix * message.identifier * f.affixed_name) - ), + Variable(self.prefix * message.identifier * f.affixed_name), Variable("Length"), ], ), @@ -1301,19 +1289,15 @@ def formal_parameters(field: Field) -> List[FormalSubprogramDeclaration]: const.TYPES_TO_LENGTH, [ Call( - ID( - self.prefix - * message.identifier - * "Available_Space" - ), + self.prefix + * message.identifier + * "Available_Space", [ Variable("Ctx"), Variable( - ID( - self.prefix - * message.identifier - * f.affixed_name - ) + self.prefix + * message.identifier + * f.affixed_name ), ], ), @@ -1436,11 +1420,7 @@ def specification_public_with_length(field: Field) -> ProcedureSpecification: AndThen( *self.setter_preconditions( message, - ID( - self.prefix - * message.identifier - * f.affixed_name - ), + self.prefix * message.identifier * f.affixed_name, ), *self.composite_setter_preconditions(message, f), ) @@ -1466,26 +1446,16 @@ def specification_public_with_length(field: Field) -> ProcedureSpecification: AndThen( *self.setter_preconditions( message, - ID( - self.prefix - * message.identifier - * f.affixed_name - ), + self.prefix * message.identifier * f.affixed_name, ), Call( - ID( - self.prefix - * message.identifier - * "Valid_Length" - ), + self.prefix * message.identifier * "Valid_Length", [ Variable("Ctx"), Variable( - ID( - self.prefix - * message.identifier - * f.affixed_name - ) + self.prefix + * message.identifier + * f.affixed_name ), Variable("Length"), ], @@ -1565,18 +1535,14 @@ def specification_public_with_length(field: Field) -> ProcedureSpecification: AndThen( *self.setter_preconditions( message, - ID(self.prefix * message.identifier * f.affixed_name), + self.prefix * message.identifier * f.affixed_name, ), Call( - ID(self.prefix * message.identifier * "Valid_Length"), + self.prefix * message.identifier * "Valid_Length", [ Variable("Ctx"), Variable( - ID( - self.prefix - * message.identifier - * f.affixed_name - ) + self.prefix * message.identifier * f.affixed_name ), Variable("Length"), ], @@ -1586,19 +1552,15 @@ def specification_public_with_length(field: Field) -> ProcedureSpecification: const.TYPES_TO_LENGTH, [ Call( - ID( - self.prefix - * message.identifier - * "Available_Space" - ), + self.prefix + * message.identifier + * "Available_Space", [ Variable("Ctx"), Variable( - ID( - self.prefix - * message.identifier - * f.affixed_name - ) + self.prefix + * message.identifier + * f.affixed_name ), ], ), @@ -1609,17 +1571,13 @@ def specification_public_with_length(field: Field) -> ProcedureSpecification: Equal( Mod( Call( - ID( - self.prefix * message.identifier * "Field_First" - ), + self.prefix * message.identifier * "Field_First", [ Variable("Ctx"), Variable( - ID( - self.prefix - * message.identifier - * f.affixed_name - ) + self.prefix + * message.identifier + * f.affixed_name ), ], ), @@ -1694,9 +1652,9 @@ def specification_public_with_length(field: Field) -> ProcedureSpecification: def setter_preconditions(self, message: Message, field_name: StrID) -> List[Expr]: return [ Not(Constrained("Ctx")), - Call(ID(self.prefix * message.identifier * "Has_Buffer"), [Variable("Ctx")]), + Call(self.prefix * message.identifier * "Has_Buffer", [Variable("Ctx")]), Call( - ID(self.prefix * message.identifier * "Valid_Next"), + self.prefix * message.identifier * "Valid_Next", [Variable("Ctx"), Variable(field_name)], ), ] @@ -1824,8 +1782,8 @@ def composite_setter_preconditions( ) -> List[Expr]: return [ common.sufficient_space_for_field_condition( - ID(self.prefix * message.identifier), - Variable(ID(self.prefix * message.identifier * field.affixed_name)), + self.prefix * message.identifier, + Variable(self.prefix * message.identifier * field.affixed_name), size, ), ] diff --git a/rflx/generator/session.py b/rflx/generator/session.py index 892132b86e..484f58387a 100644 --- a/rflx/generator/session.py +++ b/rflx/generator/session.py @@ -19,10 +19,9 @@ import attr -from rflx import expression as expr, identifier as rid, model, typing_ as rty +from rflx import expression as expr, model, typing_ as rty from rflx.ada import ( FALSE, - ID, TRUE, Add, And, @@ -100,6 +99,7 @@ ) from rflx.const import BUILTINS_PACKAGE, INTERNAL_PACKAGE from rflx.error import Location, Subsystem, fail, fatal_fail +from rflx.identifier import ID from rflx.model import declaration as decl, statement as stmt from . import common, const @@ -108,12 +108,12 @@ @dataclass class SessionContext: - referenced_types: List[rid.ID] = dataclass_field(default_factory=list) - referenced_types_body: List[rid.ID] = dataclass_field(default_factory=list) - referenced_packages_body: List[rid.ID] = dataclass_field(default_factory=list) - used_types: List[rid.ID] = dataclass_field(default_factory=list) - used_types_body: List[rid.ID] = dataclass_field(default_factory=list) - state_exception: Set[rid.ID] = dataclass_field(default_factory=set) + referenced_types: List[ID] = dataclass_field(default_factory=list) + referenced_types_body: List[ID] = dataclass_field(default_factory=list) + referenced_packages_body: List[ID] = dataclass_field(default_factory=list) + used_types: List[ID] = dataclass_field(default_factory=list) + used_types_body: List[ID] = dataclass_field(default_factory=list) + state_exception: Set[ID] = dataclass_field(default_factory=set) @dataclass @@ -137,7 +137,7 @@ def __iadd__(self, other: object) -> "EvaluatedDeclaration": @attr.s() class ExceptionHandler: - session_context_state_exception: Set[rid.ID] = attr.ib() + session_context_state_exception: Set[ID] = attr.ib() state: model.State = attr.ib() finalization: Sequence[Statement] = attr.ib() inside_declare: bool = attr.ib(False) @@ -195,7 +195,7 @@ def local(self) -> Generator["ExceptionHandler", None, None]: @dataclass class ChannelAccess: - state: rid.ID + state: ID message: ID message_type: ID @@ -222,7 +222,7 @@ def __init__( @property def unit_identifier(self) -> ID: - return ID(self._session.identifier) + return self._session.identifier @property def declaration_context(self) -> List[ContextItem]: @@ -236,13 +236,13 @@ def body_context(self) -> List[ContextItem]: def unit_part(self) -> UnitPart: return self._unit_part - def _ada_type(self, identifier: rid.ID) -> ID: + def _ada_type(self, identifier: ID) -> ID: if model.is_builtin_type(identifier): - return ID(identifier.name) + return identifier.name - return ID(model.internal_type_identifier(identifier, self._session.package)) + return model.internal_type_identifier(identifier, self._session.package) - def _model_type(self, identifier: rid.ID) -> model.Type: + def _model_type(self, identifier: ID) -> model.Type: return self._session.types[ model.internal_type_identifier(identifier, self._session.package) ] @@ -293,7 +293,7 @@ def _create_context(self) -> Tuple[List[ContextItem], List[ContextItem]]: ), *( [ - WithClause(self._prefix * ID(type_.identifier)), + WithClause(self._prefix * type_.identifier), ] if isinstance(type_, (model.Message, model.Sequence)) else [] @@ -313,7 +313,11 @@ def _create_context(self) -> Tuple[List[ContextItem], List[ContextItem]]: continue if type_identifier in self._session_context.used_types: continue - if type_identifier in [const.TYPES_LENGTH, const.TYPES_INDEX, const.TYPES_BIT_LENGTH]: + if type_identifier in [ + const.TYPES_LENGTH, + const.TYPES_INDEX, + const.TYPES_BIT_LENGTH, + ]: body_context.append( WithClause(self._prefix * const.TYPES_PACKAGE), ) @@ -326,7 +330,7 @@ def _create_context(self) -> Tuple[List[ContextItem], List[ContextItem]]: def _create_use_clauses_body(self) -> list[Declaration]: return [ - UseTypeClause(self._prefix * ID(type_identifier)) + UseTypeClause(self._prefix * type_identifier) for type_identifier in self._session_context.used_types_body if type_identifier.parent not in [INTERNAL_PACKAGE, BUILTINS_PACKAGE, self._session.identifier.parent] @@ -412,10 +416,10 @@ def is_global(identifier: ID) -> bool: @staticmethod def _channel_io( session: model.Session, read: bool = False, write: bool = False - ) -> dict[rid.ID, list[ChannelAccess]]: + ) -> dict[ID, list[ChannelAccess]]: assert (read and not write) or (not read and write) - channels: dict[rid.ID, list[ChannelAccess]] = { + channels: dict[ID, list[ChannelAccess]] = { parameter.identifier: [] for parameter in session.parameters.values() if isinstance(parameter, decl.ChannelDeclaration) @@ -431,14 +435,14 @@ def _channel_io( channels[action.identifier].append( ChannelAccess( state.identifier, - ID(action.parameter.identifier), - ID(action.parameter.type_.identifier), + action.parameter.identifier, + action.parameter.type_.identifier, ) ) return channels - def _create_use_clauses(self, used_types: Sequence[rid.ID]) -> UnitPart: + def _create_use_clauses(self, used_types: Sequence[ID]) -> UnitPart: return UnitPart( [ UseTypeClause(self._prefix * ID(t)) @@ -469,7 +473,7 @@ def _create_channel_and_state_types(session: model.Session) -> UnitPart: ) def _create_context_type( - self, initial_state: rid.ID, global_variables: Mapping[ID, Tuple[ID, Optional[Expr]]] + self, initial_state: ID, global_variables: Mapping[ID, Tuple[ID, Optional[Expr]]] ) -> UnitPart: return UnitPart( [ @@ -594,14 +598,14 @@ def _create_abstract_function( ) procedure_parameters.append( Parameter( - [ID(a.identifier)], + [a.identifier], ID(const.TYPES_BYTES) if a.type_ == rty.OPAQUE else ID("Boolean") if a.type_ == rty.BOOLEAN - else ID(self._prefix * a.type_identifier * "Structure") + else self._prefix * a.type_identifier * "Structure" if isinstance(a.type_, rty.Message) - else ID(self._prefix * a.type_identifier), + else self._prefix * a.type_identifier, ) ) @@ -623,7 +627,7 @@ def _create_abstract_function( return [ SubprogramDeclaration( ProcedureSpecification( - ID(function.identifier), + function.identifier, procedure_parameters, ), [ClassPrecondition(Not(Constrained("RFLX_Result")))] @@ -634,7 +638,9 @@ def _create_abstract_function( ] def _create_uninitialized_function( - self, composite_globals: Sequence[decl.VariableDeclaration], is_global: Callable[[ID], bool] + self, + composite_globals: Sequence[decl.VariableDeclaration], + is_global: Callable[[ID], bool], ) -> UnitPart: specification = FunctionSpecification( "Uninitialized", @@ -652,7 +658,7 @@ def _create_uninitialized_function( *[ Not( Call( - ID(declaration.type_.identifier * "Has_Buffer"), + declaration.type_.identifier * "Has_Buffer", [Variable(context_id(declaration.identifier, is_global))], ) ) @@ -662,7 +668,7 @@ def _create_uninitialized_function( *( [ Call( - ID(self._allocator.unit_identifier * "Uninitialized"), + self._allocator.unit_identifier * "Uninitialized", [Variable("Ctx.P.Slots")], ), ] @@ -675,12 +681,14 @@ def _create_uninitialized_function( ) def _create_global_initialized_function( - self, composite_globals: Sequence[decl.VariableDeclaration], is_global: Callable[[ID], bool] + self, + composite_globals: Sequence[decl.VariableDeclaration], + is_global: Callable[[ID], bool], ) -> UnitPart: if not composite_globals: return UnitPart() - self._session_context.used_types.append(const.TYPES_INDEX) + self._session_context.used_types.append(ID(ID(const.TYPES_INDEX))) specification = FunctionSpecification( "Global_Initialized", @@ -698,17 +706,17 @@ def _create_global_initialized_function( for d in composite_globals for e in [ Call( - ID(d.type_identifier) * "Has_Buffer", + d.type_identifier * "Has_Buffer", [Variable(context_id(d.identifier, is_global))], ), Equal( Variable(context_id(d.identifier, is_global) * "Buffer_First"), - First(const.TYPES_INDEX), + First(ID(const.TYPES_INDEX)), ), Equal( Variable(context_id(d.identifier, is_global) * "Buffer_Last"), Add( - First(const.TYPES_INDEX), + First(ID(const.TYPES_INDEX)), Number(self._allocator.get_size(d.identifier) - 1), ), ), @@ -754,7 +762,7 @@ def _create_initialized_function( *( [ Call( - ID(self._allocator.unit_identifier * "Global_Allocated"), + self._allocator.unit_identifier * "Global_Allocated", [Variable("Ctx.P.Slots")], ), ] @@ -774,7 +782,7 @@ def _create_states( is_global: Callable[[ID], bool], ) -> UnitPart: if self._allocator.get_global_slot_ptrs() or self._allocator.get_local_slot_ptrs(): - self._session_context.used_types_body.append(const.TYPES_BYTES_PTR) + self._session_context.used_types_body.append(ID(const.TYPES_BYTES_PTR)) unit_body: List[Declaration] = [] @@ -788,7 +796,7 @@ def _create_states( assert isinstance(d, decl.VariableDeclaration) if isinstance(d.type_, (rty.Integer, rty.Enumeration)): parameters.append( - InOutParameter([ID(d.identifier)], self._ada_type(d.type_.identifier)) + InOutParameter([d.identifier], self._ada_type(d.type_.identifier)) ) else: assert isinstance(d.type_, (rty.Message, rty.Sequence)) @@ -882,7 +890,7 @@ def _create_states( unit_body += [ SubprogramBody( ProcedureSpecification( - ID(state.identifier), + state.identifier, [ InOutParameter(["Ctx"], "Context'Class"), ], @@ -1059,7 +1067,7 @@ def _create_reset_messages_before_write_procedure( session: model.Session, is_global: Callable[[ID], bool], ) -> UnitPart: - self._session_context.used_types_body.append(const.TYPES_BIT_LENGTH) + self._session_context.used_types_body.append(ID(ID(const.TYPES_BIT_LENGTH))) specification = ProcedureSpecification( "Reset_Messages_Before_Write", [InOutParameter(["Ctx"], "Context'Class")] @@ -1069,7 +1077,7 @@ def _create_reset_messages_before_write_procedure( state, [ ( - ID(action.parameter.identifier), + action.parameter.identifier, action.parameter.type_, ) for action in state.actions @@ -1096,7 +1104,7 @@ def _create_reset_messages_before_write_procedure( Variable(f"S_{state.identifier}"), [ CallStatement( - ID(message_type.identifier) * "Reset", + message_type.identifier * "Reset", [ Variable(context_id(message, is_global)), Variable(context_id(message, is_global) * "First"), @@ -1155,7 +1163,7 @@ def _create_tick_procedure(self, session: model.Session, has_writes: bool) -> Un Variable(f"S_{s.identifier}"), [ *self._debug_output(f"State: {s.identifier}"), - CallStatement(ID(s.identifier), [Variable("Ctx")]) + CallStatement(s.identifier, [Variable("Ctx")]) if s.identifier != session.final else NullStatement(), ], @@ -1256,7 +1264,7 @@ def _create_state_function() -> UnitPart: @staticmethod def _create_has_data_function( - channel_writes: dict[rid.ID, list[ChannelAccess]], + channel_writes: dict[ID, list[ChannelAccess]], is_global: Callable[[ID], bool], ) -> UnitPart: specification = FunctionSpecification( @@ -1324,7 +1332,7 @@ def _create_has_data_function( ) @staticmethod - def _create_needs_data_function(channel_reads: dict[rid.ID, list[ChannelAccess]]) -> UnitPart: + def _create_needs_data_function(channel_reads: dict[ID, list[ChannelAccess]]) -> UnitPart: specification = FunctionSpecification( "Needs_Data", "Boolean", @@ -1362,7 +1370,7 @@ def _create_needs_data_function(channel_reads: dict[rid.ID, list[ChannelAccess]] @staticmethod def _create_read_buffer_size_function( - channel_writes: dict[rid.ID, list[ChannelAccess]], + channel_writes: dict[ID, list[ChannelAccess]], is_global: Callable[[ID], bool], ) -> UnitPart: specification = FunctionSpecification( @@ -1423,7 +1431,7 @@ def _create_read_buffer_size_function( @staticmethod def _create_write_buffer_size_function( - channel_reads: dict[rid.ID, list[ChannelAccess]], + channel_reads: dict[ID, list[ChannelAccess]], is_global: Callable[[ID], bool], ) -> UnitPart: specification = FunctionSpecification( @@ -1485,11 +1493,11 @@ def _create_write_buffer_size_function( def _create_read_procedure( self, - channel_writes: dict[rid.ID, list[ChannelAccess]], + channel_writes: dict[ID, list[ChannelAccess]], is_global: Callable[[ID], bool], ) -> UnitPart: - self._session_context.used_types.append(const.TYPES_INDEX) - self._session_context.used_types.append(const.TYPES_LENGTH) + self._session_context.used_types.append(ID(const.TYPES_INDEX)) + self._session_context.used_types.append(ID(const.TYPES_LENGTH)) specification = ProcedureSpecification( "Read", @@ -1513,7 +1521,7 @@ def _create_read_procedure( Greater(Length("Buffer"), Number(0)), LessEqual( Variable("Offset"), - Sub(Last(const.TYPES_LENGTH), Length("Buffer")), + Sub(Last(ID(const.TYPES_LENGTH)), Length("Buffer")), ), LessEqual( Add(Length("Buffer"), Variable("Offset")), @@ -1674,11 +1682,11 @@ def _create_read_procedure( def _create_write_procedure( self, - channel_reads: dict[rid.ID, list[ChannelAccess]], + channel_reads: dict[ID, list[ChannelAccess]], is_global: Callable[[ID], bool], ) -> UnitPart: - self._session_context.used_types.append(const.TYPES_INDEX) - self._session_context.used_types.append(const.TYPES_LENGTH) + self._session_context.used_types.append(ID(const.TYPES_INDEX)) + self._session_context.used_types.append(ID(const.TYPES_LENGTH)) specification = ProcedureSpecification( "Write", @@ -1702,7 +1710,7 @@ def _create_write_procedure( Greater(Length("Buffer"), Number(0)), LessEqual( Variable("Offset"), - Sub(Last(const.TYPES_LENGTH), Length("Buffer")), + Sub(Last(ID(const.TYPES_LENGTH)), Length("Buffer")), ), LessEqual( Add(Length("Buffer"), Variable("Offset")), @@ -1743,7 +1751,7 @@ def _create_write_procedure( ), LessEqual( Variable("Offset"), - Sub(Last(const.TYPES_LENGTH), Length("Buffer")), + Sub(Last(ID(const.TYPES_LENGTH)), Length("Buffer")), ), LessEqual( Add(Length("Buffer"), Variable("Offset")), @@ -1802,7 +1810,7 @@ def _create_write_procedure( LessEqual( Variable("Offset"), Sub( - Last(const.TYPES_LENGTH), + Last(ID(const.TYPES_LENGTH)), Length("Message_Buffer"), ), ), @@ -1926,13 +1934,13 @@ def always_true(_: ID) -> bool: result.initialization.insert( 0, CallStatement( - ID(self._allocator.unit_identifier * "Initialize"), + self._allocator.unit_identifier * "Initialize", [Variable("Ctx.P.Slots"), Variable("Ctx.P.Memory")], ), ) result.finalization.append( CallStatement( - ID(self._allocator.unit_identifier * "Finalize"), + self._allocator.unit_identifier * "Finalize", [Variable("Ctx.P.Slots")], ) ) @@ -1941,7 +1949,7 @@ def always_true(_: ID) -> bool: def _state_action( self, - state: rid.ID, + state: ID, action: stmt.Statement, exception_handler: ExceptionHandler, is_global: Callable[[ID], bool], @@ -2001,7 +2009,7 @@ def _state_action( def _declare( # pylint: disable = too-many-arguments, too-many-branches self, - identifier: rid.ID, + identifier: ID, type_: rty.Type, is_global: Callable[[ID], bool], alloc_id: Optional[Location], @@ -2028,8 +2036,8 @@ def _declare( # pylint: disable = too-many-arguments, too-many-branches if len(expression.elements) == 0: object_type = Slice( Variable(const.TYPES_BYTES), - Last(const.TYPES_INDEX), - First(const.TYPES_INDEX), + Last(ID(const.TYPES_INDEX)), + First(ID(const.TYPES_INDEX)), ) initialization = None if len(expression.elements) > 0: @@ -2039,7 +2047,7 @@ def _declare( # pylint: disable = too-many-arguments, too-many-branches result.global_declarations.append( ObjectDeclaration( - [ID(identifier)], + [identifier], object_type, initialization.substituted(self._substitution(is_global)).ada_expr() if initialization @@ -2053,7 +2061,7 @@ def _declare( # pylint: disable = too-many-arguments, too-many-branches elif isinstance(type_, (rty.Integer, rty.Enumeration)): result.global_declarations.append( ObjectDeclaration( - [ID(identifier)], + [identifier], self._ada_type(type_.identifier), expression.ada_expr() if expression else None, ) @@ -2078,12 +2086,12 @@ def _declare( # pylint: disable = too-many-arguments, too-many-branches result.global_declarations.append( self._declare_context( - ID(identifier), + identifier, type_identifier, (lambda x: False) if session_global else is_global, ) ) - result.initialization_declarations.append(self._declare_buffer(ID(identifier))) + result.initialization_declarations.append(self._declare_buffer(identifier)) result.initialization.extend( [ *self._allocate_buffer(identifier, alloc_id), @@ -2104,7 +2112,7 @@ def _declare( # pylint: disable = too-many-arguments, too-many-branches ] ) result.finalization.extend( - self._free_context_buffer(ID(identifier), type_identifier, is_global, alloc_id) + self._free_context_buffer(identifier, type_identifier, is_global, alloc_id) ) else: @@ -2125,11 +2133,11 @@ def _declare( # pylint: disable = too-many-arguments, too-many-branches def _declare_and_assign( # pylint: disable = too-many-arguments self, - variables: Sequence[Tuple[rid.ID, rty.Type, expr.Expr]], + variables: Sequence[Tuple[ID, rty.Type, expr.Expr]], statements: Sequence[Statement], exception_handler: ExceptionHandler, is_global: Callable[[ID], bool], - state: rid.ID, + state: ID, alloc_id: Optional[Location], constant: bool = False, ) -> Sequence[Statement]: @@ -2182,12 +2190,12 @@ def _declare_and_assign( # pylint: disable = too-many-arguments def _assign( # pylint: disable = too-many-arguments self, - target: rid.ID, + target: ID, target_type: rty.Type, expression: expr.Expr, exception_handler: ExceptionHandler, is_global: Callable[[ID], bool], - state: rid.ID, + state: ID, alloc_id: Optional[Location], ) -> Sequence[Statement]: if isinstance(expression, expr.MessageAggregate): @@ -2272,11 +2280,11 @@ def _assign( # pylint: disable = too-many-arguments def _assign_to_binding( # pylint: disable = too-many-branches, too-many-locals, too-many-arguments self, - target: rid.ID, + target: ID, binding: expr.Binding, exception_handler: ExceptionHandler, is_global: Callable[[ID], bool], - state: rid.ID, + state: ID, alloc_id: Optional[Location], ) -> Sequence[Statement]: variables = [] @@ -2346,7 +2354,7 @@ def _assign_to_binding( # pylint: disable = too-many-branches, too-many-locals, def _assign_to_selected( self, - target: rid.ID, + target: ID, selected: expr.Selected, exception_handler: ExceptionHandler, is_global: Callable[[ID], bool], @@ -2361,7 +2369,7 @@ def _assign_to_selected( assert isinstance(selected.prefix.type_, rty.Message) - message_type = ID(selected.prefix.type_.identifier) + message_type = selected.prefix.type_.identifier message_context = context_id(selected.prefix.identifier, is_global) selector = selected.selector @@ -2421,16 +2429,16 @@ def _assign_to_selected( def _assign_to_message_aggregate( self, - target: rid.ID, + target: ID, message_aggregate: expr.MessageAggregate, exception_handler: ExceptionHandler, is_global: Callable[[ID], bool], ) -> Sequence[Statement]: assert isinstance(message_aggregate.type_, rty.Message) - self._session_context.used_types_body.append(const.TYPES_BIT_LENGTH) + self._session_context.used_types_body.append(ID(const.TYPES_BIT_LENGTH)) - target_type = ID(message_aggregate.type_.identifier) + target_type = message_aggregate.type_.identifier target_context = context_id(target, is_global) parameter_values = [ (f, v, t) @@ -2463,7 +2471,7 @@ def _assign_to_message_aggregate( def _assign_to_head( # pylint: disable = too-many-locals self, - target: rid.ID, + target: ID, head: expr.Head, exception_handler: ExceptionHandler, is_global: Callable[[ID], bool], @@ -2484,11 +2492,11 @@ def _assign_to_head( # pylint: disable = too-many-locals if not isinstance(head.prefix, expr.Variable): _unsupported_expression(head.prefix, "in Head attribute") - target_type = ID(head.type_.identifier) - sequence_type = ID(head.prefix.type_.identifier) - sequence_id = ID(head.prefix.identifier) + target_type = head.type_.identifier + sequence_type = head.prefix.type_.identifier + sequence_id = head.prefix.identifier sequence_context = context_id(sequence_id, is_global) - sequence_identifier = ID(rid.ID(f"{head.prefix}")) + sequence_identifier = ID(ID(f"{head.prefix}")) if isinstance(head.prefix.type_.element, (rty.Integer, rty.Enumeration)): return [ @@ -2504,7 +2512,7 @@ def _assign_to_head( # pylint: disable = too-many-locals sequence_type * "Size", [Variable(sequence_context)], ), - Size(ID(head.prefix.type_.element.identifier)), + Size(head.prefix.type_.element.identifier), ), ), [ @@ -2524,8 +2532,8 @@ def _assign_to_head( # pylint: disable = too-many-locals assert isinstance(head.prefix.type_.element, rty.Message) - self._session_context.used_types_body.append(const.TYPES_LENGTH) - self._session_context.referenced_types_body.append(target_type) + self._session_context.used_types_body.append(ID(const.TYPES_LENGTH)) + self._session_context.referenced_types_body.append(ID(target_type)) target_context = context_id(target, is_global) target_buffer = buffer_id("RFLX_Target_" + target) @@ -2626,7 +2634,7 @@ def _assign_to_head( # pylint: disable = too-many-locals def _assign_to_comprehension( # pylint: disable = too-many-arguments self, - target: rid.ID, + target: ID, target_type: rty.Sequence, comprehension: expr.Comprehension, exception_handler: ExceptionHandler, @@ -2638,24 +2646,22 @@ def _assign_to_comprehension( # pylint: disable = too-many-arguments assert isinstance(comprehension.type_, (rty.Sequence, rty.Aggregate)) assert isinstance(comprehension.sequence.type_, rty.Sequence) - self._session_context.used_types_body.append(const.TYPES_BIT_LENGTH) + self._session_context.used_types_body.append(ID(const.TYPES_BIT_LENGTH)) target_id = ID(target) target_context = context_id(target_id, is_global) - sequence_type_id = ID(comprehension.sequence.type_.identifier) + sequence_type_id = comprehension.sequence.type_.identifier iterator_id = ID(comprehension.iterator) sequence_element_type = comprehension.sequence.type_.element - reset_target = CallStatement( - ID(target_type.identifier) * "Reset", [Variable(target_context)] - ) + reset_target = CallStatement(target_type.identifier * "Reset", [Variable(target_context)]) if isinstance(sequence_element_type, rty.Message): - iterator_type_id = ID(sequence_element_type.identifier) + iterator_type_id = sequence_element_type.identifier if isinstance(comprehension.sequence, expr.Variable): - sequence_id = ID(rid.ID(f"{comprehension.sequence}")) + sequence_id = ID(ID(f"{comprehension.sequence}")) with exception_handler.local() as local_exception_handler: return [ reset_target, @@ -2694,9 +2700,9 @@ def _assign_to_comprehension( # pylint: disable = too-many-arguments assert isinstance(selected.prefix.type_, rty.Message) message_id = ID(selected.prefix.name) - message_type = ID(selected.prefix.type_.identifier) + message_type = selected.prefix.type_.identifier sequence_id = ID( - rid.ID( + ID( f"RFLX_{selected.prefix}_{selected.selector}", location=selected.location, ) @@ -2751,11 +2757,11 @@ def _assign_to_comprehension( # pylint: disable = too-many-arguments def _assign_to_call( # pylint: disable = too-many-locals self, - target: rid.ID, + target: ID, call_expr: expr.Call, exception_handler: ExceptionHandler, is_global: Callable[[ID], bool], - state: rid.ID, + state: ID, ) -> Sequence[Statement]: pre_call: list[Statement] = [] post_call = [] @@ -2768,21 +2774,21 @@ def _assign_to_call( # pylint: disable = too-many-locals local_declarations.append( ObjectDeclaration( [target_id], - ID(type_identifier) * "Structure", + type_identifier * "Structure", ) ) post_call.append( self._if( - Call(ID(type_identifier) * "Valid_Structure", [Variable(target_id)]), + Call(type_identifier * "Valid_Structure", [Variable(target_id)]), [ self._if( Call( - ID(type_identifier) * "Sufficient_Buffer_Length", + type_identifier * "Sufficient_Buffer_Length", [Variable(message_id), Variable(target_id)], ), [ CallStatement( - ID(type_identifier) * "To_Context", + type_identifier * "To_Context", [ Variable(target_id), Variable(message_id), @@ -2825,16 +2831,16 @@ def _assign_to_call( # pylint: disable = too-many-locals type_identifier = self._ada_type(a.type_.identifier) local_declarations.append( ObjectDeclaration( - [ID(a.identifier)], - ID(type_identifier) * "Structure", + [a.identifier], + type_identifier * "Structure", ) ) pre_call.append( CallStatement( - ID(type_identifier) * "To_Structure", + type_identifier * "To_Structure", [ Variable(context_id(a.identifier, is_global)), - Variable(ID(a.identifier)), + Variable(a.identifier), ], ), ) @@ -2847,11 +2853,11 @@ def _assign_to_call( # pylint: disable = too-many-locals argument_length = f"{argument_name}_Length" argument = expr.Slice( expr.Variable(argument_name), - expr.First(const.TYPES_INDEX), + expr.First(ID(const.TYPES_INDEX)), expr.Add( - expr.First(const.TYPES_INDEX), + expr.First(ID(const.TYPES_INDEX)), expr.Call( - const.TYPES_INDEX, + ID(const.TYPES_INDEX), [ expr.Variable(argument_length), ], @@ -2868,9 +2874,9 @@ def _assign_to_call( # pylint: disable = too-many-locals [argument_name], Slice( Variable(const.TYPES_BYTES), - First(const.TYPES_INDEX), + First(ID(const.TYPES_INDEX)), Add( - First(const.TYPES_INDEX), + First(ID(const.TYPES_INDEX)), Number( self._allocator.get_size(a.prefix.identifier, state) - 1 ), @@ -2917,16 +2923,16 @@ def _assign_to_call( # pylint: disable = too-many-locals and isinstance(a.prefix, expr.Variable) and isinstance(a.prefix.type_, (rty.Message, rty.Sequence)) ): - self._session_context.used_types_body.append(const.TYPES_LENGTH) + self._session_context.used_types_body.append(ID(const.TYPES_LENGTH)) argument_name = f"RFLX_{call_expr.identifier}_Arg_{i}_{a.prefix}" argument_length = f"{argument_name}_Length" argument = expr.Slice( expr.Variable(argument_name), - expr.First(const.TYPES_INDEX), + expr.First(ID(const.TYPES_INDEX)), expr.Add( - expr.First(const.TYPES_INDEX), + expr.First(ID(const.TYPES_INDEX)), expr.Call( - const.TYPES_INDEX, + ID(const.TYPES_INDEX), [expr.Add(expr.Variable(argument_length), expr.Number(1))], ), -expr.Number(2), @@ -2942,9 +2948,9 @@ def _assign_to_call( # pylint: disable = too-many-locals [argument_name], Slice( Variable(const.TYPES_BYTES), - First(const.TYPES_INDEX), + First(ID(const.TYPES_INDEX)), Add( - First(const.TYPES_INDEX), + First(ID(const.TYPES_INDEX)), Number( self._allocator.get_size(a.prefix.identifier, state) - 1 ), @@ -3008,7 +3014,7 @@ def _assign_to_call( # pylint: disable = too-many-locals call = [ CallStatement( - ID(call_expr.identifier), + call_expr.identifier, [ Variable("Ctx"), *[a.substituted(self._substitution(is_global)).ada_expr() for a in arguments], @@ -3038,7 +3044,7 @@ def _assign_to_call( # pylint: disable = too-many-locals def _assign_to_conversion( self, - target: rid.ID, + target: ID, conversion: expr.Conversion, exception_handler: ExceptionHandler, is_global: Callable[[ID], bool], @@ -3086,7 +3092,7 @@ def _assign_to_conversion( ], ), CallStatement( - ID(sdu.identifier) * "Verify_Message", + sdu.identifier * "Verify_Message", [ Variable(context_id(target, is_global)), ], @@ -3099,8 +3105,8 @@ def _assign_to_conversion( def _assign_message_field( # pylint: disable = too-many-arguments self, - target: rid.ID, - target_field: rid.ID, + target: ID, + target_field: ID, message_type: rty.Type, value: expr.Expr, exception_handler: ExceptionHandler, @@ -3121,11 +3127,11 @@ def _append( append: stmt.Append, exception_handler: ExceptionHandler, is_global: Callable[[ID], bool], - state: rid.ID, + state: ID, ) -> Sequence[Statement]: assert isinstance(append.type_, rty.Sequence) - self._session_context.used_types_body.append(const.TYPES_BIT_LENGTH) + self._session_context.used_types_body.append(ID(const.TYPES_BIT_LENGTH)) def check( sequence_type: ID, required_space: Expr, precondition: Expr = None @@ -3180,9 +3186,9 @@ def check( if isinstance(append.type_.element, (rty.Integer, rty.Enumeration)): if isinstance(append.parameter, (expr.Variable, expr.Literal, expr.Number)): - sequence_type = ID(append.type_.identifier) + sequence_type = append.type_.identifier sequence_context = context_id(append.identifier, is_global) - element_type = ID(append.type_.element.identifier) + element_type = append.type_.element.identifier return [ *check(sequence_type, Size(element_type)), @@ -3195,9 +3201,9 @@ def check( _unsupported_expression(append.parameter, "in Append statement") if isinstance(append.type_.element, rty.Message): - sequence_type = ID(append.type_.identifier) + sequence_type = append.type_.identifier sequence_context = context_id(append.identifier, is_global) - element_type = ID(append.type_.element.identifier) + element_type = append.type_.element.identifier element_context = context_id("RFLX_Element_" + append.identifier, is_global) self._session_context.referenced_types_body.append(element_type) @@ -3248,7 +3254,7 @@ def _read(read: stmt.Read, is_global: Callable[[ID], bool]) -> Sequence[Statemen if not isinstance(read.parameter, expr.Variable): _unsupported_expression(read.parameter, "in Read statement") - target_type = ID(read.parameter.type_.identifier) + target_type = read.parameter.type_.identifier target_context = context_id(read.parameter.identifier, is_global) return [ CallStatement(target_type * "Verify_Message", [Variable(target_context)]), @@ -3272,7 +3278,7 @@ def _reset( ) -> Sequence[Statement]: assert isinstance(reset.type_, (rty.Message, rty.Sequence)) - target_type = ID(reset.type_.identifier) + target_type = reset.type_.identifier target_context = context_id(reset.identifier, is_global) return [ CallStatement( @@ -3291,11 +3297,11 @@ def _message_size(self, message_aggregate: expr.MessageAggregate) -> expr.Expr: return message.size({model.Field(f): v for f, v in message_aggregate.field_values.items()}) def _required_space( - self, size: expr.Expr, is_global: Callable[[ID], bool], state: rid.ID + self, size: expr.Expr, is_global: Callable[[ID], bool], state: ID ) -> tuple[Expr, Optional[Expr]]: required_space = ( size.substituted( - lambda x: expr.Call(const.TYPES_BIT_LENGTH, [x]) + lambda x: expr.Call(ID(const.TYPES_BIT_LENGTH), [x]) if (isinstance(x, expr.Variable) and isinstance(x.type_, rty.AnyInteger)) or (isinstance(x, expr.Selected) and x.type_ != rty.OPAQUE) else x @@ -3352,7 +3358,7 @@ def func(expression: expr.Expr) -> expr.Expr: expression.selector, ) return expr.Call( - ID(expression.prefix.type_.identifier) * ID(f"Get_{expression.selector}"), + expression.prefix.type_.identifier * ID(f"Get_{expression.selector}"), [expr.Variable(context_id(expression.prefix.identifier, is_global))], ) @@ -3362,13 +3368,13 @@ def func(expression: expr.Expr) -> expr.Expr: if isinstance(expression.prefix, expr.Variable): if isinstance(expression.prefix.type_, rty.Message): return expr.Call( - ID(expression.prefix.type_.identifier) * ID("Structural_Valid_Message"), + expression.prefix.type_.identifier * ID("Structural_Valid_Message"), [expr.Variable(context_id(expression.prefix.identifier, is_global))], ) if isinstance(expression.prefix.type_, rty.Sequence): return expr.Call( - ID(expression.prefix.type_.identifier) * ID("Valid"), + expression.prefix.type_.identifier * "Valid", [expr.Variable(context_id(expression.prefix.identifier, is_global))], ) @@ -3377,13 +3383,13 @@ def func(expression: expr.Expr) -> expr.Expr: if isinstance(expression.prefix, expr.Selected): assert isinstance(expression.prefix.prefix, expr.Variable) assert isinstance(expression.prefix.prefix.type_, rty.Message) - type_name = ID(expression.prefix.prefix.type_.identifier) + type_name = expression.prefix.prefix.type_.identifier return expr.Call( type_name * ( - ID("Valid") + "Valid" if isinstance(expression.prefix.type_, (rty.Integer, rty.Enumeration)) - else ID("Structural_Valid") + else "Structural_Valid" ), [ expr.Variable( @@ -3399,9 +3405,9 @@ def func(expression: expr.Expr) -> expr.Expr: if isinstance(expression.prefix, expr.Selected): assert isinstance(expression.prefix.prefix, expr.Variable) assert isinstance(expression.prefix.prefix.type_, rty.Message) - type_name = ID(expression.prefix.prefix.type_.identifier) + type_name = expression.prefix.prefix.type_.identifier return expr.Call( - type_name * ID("Present"), + type_name * "Present", [ expr.Variable( context_id(expression.prefix.prefix.identifier, is_global) @@ -3417,11 +3423,13 @@ def func(expression: expr.Expr) -> expr.Expr: if len(expression.elements) == 1: return expr.NamedAggregate( ( - str(expr.First(const.TYPES_INDEX)), - expr.Val(const.TYPES_BYTE, expression.elements[0]), + str(expr.First(ID(const.TYPES_INDEX))), + expr.Val(ID(const.TYPES_BYTE), expression.elements[0]), ) ) - return expr.Aggregate(*[expr.Val(const.TYPES_BYTE, e) for e in expression.elements]) + return expr.Aggregate( + *[expr.Val(ID(const.TYPES_BYTE), e) for e in expression.elements] + ) if isinstance(expression, expr.Equal): if expression.left == expr.TRUE and isinstance(expression.right, expr.Variable): @@ -3511,7 +3519,7 @@ def func(expression: expr.Expr) -> expr.Expr: isinstance(expression.prefix.type_, (rty.Message, rty.Sequence)) and expression.prefix.type_ != rty.OPAQUE ): - type_ = ID(expression.prefix.type_.identifier) + type_ = expression.prefix.type_.identifier context = context_id(expression.prefix.identifier, is_global) return expr.Call(type_ * "Size", [expr.Variable(context)]) @@ -3520,7 +3528,7 @@ def func(expression: expr.Expr) -> expr.Expr: if isinstance(expression.prefix, expr.Selected): assert isinstance(expression.prefix.prefix, expr.Variable) assert isinstance(expression.prefix.prefix.type_, rty.Message) - type_ = ID(expression.prefix.prefix.type_.identifier) + type_ = expression.prefix.prefix.type_.identifier context = context_id(expression.prefix.prefix.identifier, is_global) return expr.Call( type_ * "Field_Size", @@ -3535,7 +3543,7 @@ def func(expression: expr.Expr) -> expr.Expr: if isinstance(expression, expr.HasData): assert isinstance(expression.prefix, expr.Variable) assert isinstance(expression.prefix.type_, rty.Message) - type_ = ID(expression.prefix.type_.identifier) + type_ = expression.prefix.type_.identifier context = context_id(expression.prefix.identifier, is_global) return expr.Greater( expr.Call(type_ * "Byte_Size", [expr.Variable(context)]), expr.Number(0) @@ -3545,7 +3553,7 @@ def func(expression: expr.Expr) -> expr.Expr: assert expression.type_ == rty.OPAQUE if isinstance(expression.prefix, expr.Variable): if isinstance(expression.prefix.type_, (rty.Message, rty.Sequence)): - type_ = ID(expression.prefix.type_.identifier) + type_ = expression.prefix.type_.identifier context = context_id(expression.prefix.identifier, is_global) return expr.Call(type_ * "Data", [expr.Variable(context)]) @@ -3622,7 +3630,7 @@ def _if_structural_valid_message_field( message_type * "Structural_Valid", [ Variable(message_context), - Variable(message_type * model.Field(message_field).affixed_name), + Variable(message_type * model.Field(ID(message_field)).affixed_name), ], ), statements, @@ -3764,8 +3772,8 @@ def _set_message_field( ) -> list[Statement]: # pylint: disable = too-many-arguments, too-many-statements, too-many-branches, too-many-locals - message_type_id = ID(message_type.identifier) - field_type = message_type.field_types[field] + message_type_id = message_type.identifier + field_type = message_type.field_types[ID(field)] statements: list[Statement] = [] result = statements @@ -3811,7 +3819,7 @@ def _set_message_field( if isinstance(value, expr.Variable) and isinstance( value.type_, (rty.Message, rty.Sequence) ): - type_ = ID(value.type_.identifier) + type_ = value.type_.identifier context = context_id(value.identifier, is_global) statements = self._ensure( statements, @@ -3832,7 +3840,7 @@ def _set_message_field( elif isinstance(value, expr.Selected): assert isinstance(value.prefix, expr.Variable) assert isinstance(value.prefix.type_, rty.Message) - value_message_type_id = ID(value.prefix.type_.identifier) + value_message_type_id = value.prefix.type_.identifier value_message_context = context_id(value.prefix.identifier, is_global) statements = self._ensure( statements, @@ -3918,7 +3926,7 @@ def _set_message_field( and isinstance(value.prefix, expr.Variable) and isinstance(value.prefix.type_, rty.Message) ): - value_message_type_id = ID(value.prefix.type_.identifier) + value_message_type_id = value.prefix.type_.identifier value_message_context = context_id(value.prefix.identifier, is_global) statements = self._ensure( statements, @@ -3955,15 +3963,15 @@ def _set_message_field( ) else: assert field_type == rty.OPAQUE - self._session_context.used_types_body.append(const.TYPES_LENGTH) + self._session_context.used_types_body.append(ID(const.TYPES_LENGTH)) statements.extend( [ self._set_opaque_field_to_message_field( message_type_id, message_context, ID(field), - value_message_type_id, - value_message_context, + ID(value_message_type_id), + ID(value_message_context), ID(value.selector), ), ] @@ -3971,7 +3979,7 @@ def _set_message_field( elif isinstance(value, expr.Opaque) and isinstance(value.prefix, expr.Variable): assert value.type_ == rty.OPAQUE assert isinstance(value.prefix.type_, rty.Message) - value_message_type_id = ID(value.prefix.type_.identifier) + value_message_type_id = value.prefix.type_.identifier value_message_context = context_id(value.prefix.identifier, is_global) statements.extend( [ @@ -3979,8 +3987,8 @@ def _set_message_field( message_type_id, message_context, ID(field), - value_message_type_id, - value_message_context, + ID(value_message_type_id), + ID(value_message_context), ), ] ) @@ -4195,7 +4203,7 @@ def _declare_context( type_: ID, is_global: Callable[[ID], bool], ) -> Declaration: - self._session_context.referenced_types_body.append(type_) + self._session_context.referenced_types_body.append(ID(type_)) return ObjectDeclaration([context_id(identifier, is_global)], type_ * "Context") @staticmethod @@ -4287,7 +4295,8 @@ def _declare_message_field_sequence_copy( # pylint: disable = too-many-argument [ Variable(context_id(message_identifier, is_global)), Variable( - message_type * model.Field(message_field).affixed_name + message_type + * model.Field(ID(message_field)).affixed_name ), ], ), @@ -4296,7 +4305,8 @@ def _declare_message_field_sequence_copy( # pylint: disable = too-many-argument [ Variable(context_id(message_identifier, is_global)), Variable( - message_type * model.Field(message_field).affixed_name + message_type + * model.Field(ID(message_field)).affixed_name ), ], ), @@ -4327,7 +4337,7 @@ def _comprehension( # pylint: disable = too-many-arguments assert isinstance(target_type.element, (rty.Integer, rty.Enumeration, rty.Message)) - target_type_id = ID(target_type.identifier) + target_type_id = target_type.identifier with exception_handler.local() as local_exception_handler: return While( @@ -4447,7 +4457,7 @@ def _comprehension_append_element( exception_handler: ExceptionHandler, is_global: Callable[[ID], bool], ) -> List[Statement]: - target_type_id = ID(target_type.identifier) + target_type_id = target_type.identifier required_space: Expr append_element: Statement @@ -4460,19 +4470,19 @@ def _comprehension_append_element( location=selector.location, ) - element_id = ID(selector.identifier + "_Ctx") + element_id = selector.identifier + "_Ctx" required_space = Call( - ID(target_type.element.identifier * "Size"), + target_type.element.identifier * "Size", [Variable(element_id)], ) append_element = self._if_structural_valid_message( - ID(target_type.element.identifier), + target_type.element.identifier, element_id, [ self._if( Greater( Call( - ID(target_type.element.identifier) * "Size", + target_type.element.identifier * "Size", [ Variable(element_id), ], @@ -4561,7 +4571,9 @@ def _take_buffer( "Warnings", [ Variable("Off"), - String(f'"{context}" is set by "Take_Buffer" but not used after the call'), + String( + f'"{context.ada_str}" is set by "Take_Buffer" but not used after the call' + ), ], ), CallStatement( @@ -4575,7 +4587,9 @@ def _take_buffer( "Warnings", [ Variable("On"), - String(f'"{context}" is set by "Take_Buffer" but not used after the call'), + String( + f'"{context.ada_str}" is set by "Take_Buffer" but not used after the call' + ), ], ), ] @@ -4590,7 +4604,10 @@ def _update_context( "Warnings", [ Variable("Off"), - String(f'"{element_context}" is set by "Update" but not used after the call'), + String( + f'"{element_context.ada_str}" is set by "Update" ' + f"but not used after the call" + ), ], ), CallStatement( @@ -4604,15 +4621,16 @@ def _update_context( "Warnings", [ Variable("On"), - String(f'"{element_context}" is set by "Update" but not used after the call'), + String( + f'"{element_context.ada_str}" is set by "Update"' + f" but not used after the call" + ), ], ), ] - def _allocate_buffer( - self, identifier: rid.ID, alloc_id: Optional[Location] - ) -> Sequence[Statement]: - self._session_context.used_types_body.append(const.TYPES_INDEX) + def _allocate_buffer(self, identifier: ID, alloc_id: Optional[Location]) -> Sequence[Statement]: + self._session_context.used_types_body.append(ID(const.TYPES_INDEX)) slot_id = Variable("Ctx.P.Slots" * self._allocator.get_slot_ptr(alloc_id)) return [ Assignment(buffer_id(identifier), slot_id), @@ -4623,7 +4641,7 @@ def _allocate_buffer( @staticmethod def _initialize_context( # pylint: disable = too-many-arguments - identifier: rid.ID, + identifier: ID, type_: ID, is_global: Callable[[ID], bool], first: Expr = None, @@ -4651,9 +4669,13 @@ def _initialize_context( # pylint: disable = too-many-arguments ) def _copy_to_buffer( - self, type_: ID, source_context: ID, target_buffer: ID, exception_handler: ExceptionHandler + self, + type_: ID, + source_context: ID, + target_buffer: ID, + exception_handler: ExceptionHandler, ) -> IfStatement: - self._session_context.used_types_body.append(const.TYPES_LENGTH) + self._session_context.used_types_body.append(ID(const.TYPES_LENGTH)) return IfStatement( [ ( @@ -4710,7 +4732,7 @@ def _convert_type( assert isinstance(target_type, (rty.Integer, rty.Enumeration)), target_type - self._session_context.referenced_types_body.append(ID(target_type.identifier)) + self._session_context.referenced_types_body.append(target_type.identifier) return expr.Conversion(target_type.identifier, expression) def _debug_output(self, string: str) -> List[CallStatement]: @@ -4732,17 +4754,15 @@ def copy_id(identifier: ID) -> ID: return ID("RFLX_Copy_" + identifier.flat) -def variable_id(identifier: rid.ID, is_global: Callable[[ID], bool]) -> ID: - identifier = ID(identifier) - +def variable_id(identifier: ID, is_global: Callable[[ID], bool]) -> ID: if is_global(identifier): return "Ctx.P" * identifier return identifier -def context_id(identifier: rid.ID, is_global: Callable[[ID], bool]) -> ID: - identifier = ID(identifier + "_Ctx") +def context_id(identifier: ID, is_global: Callable[[ID], bool]) -> ID: + identifier = identifier + "_Ctx" if is_global(identifier): return "Ctx.P" * identifier @@ -4750,8 +4770,8 @@ def context_id(identifier: rid.ID, is_global: Callable[[ID], bool]) -> ID: return identifier -def buffer_id(identifier: rid.ID) -> ID: - return ID(identifier + "_Buffer") +def buffer_id(identifier: ID) -> ID: + return identifier + "_Buffer" def _unexpected_expression(expression: expr.Expr, context: str) -> NoReturn: diff --git a/rflx/identifier.py b/rflx/identifier.py index 9ae178ba07..05987acf7d 100644 --- a/rflx/identifier.py +++ b/rflx/identifier.py @@ -1,3 +1,5 @@ +from __future__ import annotations + import re from typing import Optional, Sequence, TypeVar, Union @@ -8,7 +10,7 @@ class ID: def __init__( - self, identifier: Union[str, Sequence[str], "ID"], location: Location = None + self, identifier: Union[str, Sequence[str], ID], location: Location = None ) -> None: self._parts: Sequence[str] self.location = location @@ -58,7 +60,7 @@ def __repr__(self) -> str: return f'ID("{self}")' def __str__(self) -> str: - return self._separator.join(self.parts) + return "::".join(self.parts) def __add__(self: Self, other: object) -> Self: if isinstance(other, (str, ID)): @@ -74,14 +76,14 @@ def __mul__(self: Self, other: object) -> Self: if isinstance(other, (str, ID)): if str(other) == "": return self.__class__(self, self._location(other)) - return self.__class__(f"{self}{self._separator}{other}", self._location(other)) + return self.__class__(f"{self}::{other}", self._location(other)) return NotImplemented def __rmul__(self: Self, other: object) -> Self: if isinstance(other, (str, ID)): if str(other) == "": return self.__class__(self, self._location(other)) - return self.__class__(f"{other}{self._separator}{self}", self._location(other)) + return self.__class__(f"{other}::{self}", self._location(other)) return NotImplemented def _location(self, other: object) -> Optional[Location]: @@ -112,8 +114,8 @@ def flat(self: Self) -> str: return "_".join(self._parts) @property - def _separator(self) -> str: - return "::" + def ada_str(self) -> str: + return ".".join(self.parts) StrID = Union[str, ID] diff --git a/tests/unit/ada_test.py b/tests/unit/ada_test.py index 3c53aec7af..8671a76839 100644 --- a/tests/unit/ada_test.py +++ b/tests/unit/ada_test.py @@ -3,35 +3,36 @@ import pytest from rflx import ada, expression as expr +from rflx.identifier import ID from tests.utils import assert_equal, multilinestr def test_id_str() -> None: - assert str(ada.ID("A.B.C")) == "A.B.C" + assert ID("A.B.C").ada_str == "A.B.C" def test_id_add() -> None: - assert ada.ID("A") + ada.ID("B.C") == ada.ID("AB.C") - assert ada.ID("B.C") + ada.ID("D") == ada.ID("B.CD") + assert ID("A") + ID("B.C") == ID("AB.C") + assert ID("B.C") + ID("D") == ID("B.CD") def test_id_add_str() -> None: - assert "A" + ada.ID("B.C") == ada.ID("AB.C") - assert ada.ID("B.C") + "D" == ada.ID("B.CD") - assert ada.ID("B.C") + "" == ada.ID("B.C") - assert "" + ada.ID("B.C") == ada.ID("B.C") + assert "A" + ID("B.C") == ID("AB.C") + assert ID("B.C") + "D" == ID("B.CD") + assert ID("B.C") + "" == ID("B.C") + assert "" + ID("B.C") == ID("B.C") def test_id_mul_id() -> None: - assert ada.ID("A") * ada.ID("B.C") == ada.ID("A.B.C") - assert ada.ID("B.C") * ada.ID("D") == ada.ID("B.C.D") + assert ID("A") * ID("B.C") == ID("A.B.C") + assert ID("B.C") * ID("D") == ID("B.C.D") def test_id_mul_str() -> None: - assert "A" * ada.ID("B.C") == ada.ID("A.B.C") - assert ada.ID("B.C") * "D" == ada.ID("B.C.D") - assert "" * ada.ID("B.C") == ada.ID("B.C") - assert ada.ID("B.C") * "" == ada.ID("B.C") + assert "A" * ID("B.C") == ID("A.B.C") + assert ID("B.C") * "D" == ID("B.C.D") + assert "" * ID("B.C") == ID("B.C") + assert ID("B.C") * "" == ID("B.C") def test_not_rflx_expr() -> None: @@ -540,7 +541,7 @@ def test_call_str() -> None: assert str(ada.Call("A", [])) == "A" assert str(ada.Call("A", [ada.Variable("B"), ada.Variable("C")])) == "A (B, C)" assert ( - str(ada.Call("A", [], {ada.ID("B"): ada.Number(1), ada.ID("C"): ada.Number(2)})) + str(ada.Call("A", [], {ID("B"): ada.Number(1), ID("C"): ada.Number(2)})) == "A (B => 1, C => 2)" ) assert ( @@ -548,7 +549,7 @@ def test_call_str() -> None: ada.Call( "A", [ada.Variable("B"), ada.Variable("C")], - {ada.ID("D"): ada.Number(1), ada.ID("E"): ada.Number(2)}, + {ID("D"): ada.Number(1), ID("E"): ada.Number(2)}, ) ) == "A (B, C, D => 1, E => 2)" @@ -693,7 +694,7 @@ def test_call_statement_str() -> None: assert str(ada.CallStatement("A", [])) == "A;" assert str(ada.CallStatement("A", [ada.Variable("B"), ada.Variable("C")])) == "A (B, C);" assert ( - str(ada.CallStatement("A", [], {ada.ID("B"): ada.Number(1), ada.ID("C"): ada.Number(2)})) + str(ada.CallStatement("A", [], {ID("B"): ada.Number(1), ID("C"): ada.Number(2)})) == "A (B => 1, C => 2);" ) assert ( @@ -701,7 +702,7 @@ def test_call_statement_str() -> None: ada.CallStatement( "A", [ada.Variable("B"), ada.Variable("C")], - {ada.ID("D"): ada.Number(1), ada.ID("E"): ada.Number(2)}, + {ID("D"): ada.Number(1), ID("E"): ada.Number(2)}, ) ) == "A (B, C, D => 1, E => 2);" @@ -755,7 +756,7 @@ def test_qualified_expr_rflx_expr() -> None: def test_parameter() -> None: assert str(ada.Parameter(["P1"], "T")) == "P1 : T" - assert str(ada.Parameter(["P1"], ada.ID("Boolean"))) == "P1 : Boolean" + assert str(ada.Parameter(["P1"], ID("Boolean"))) == "P1 : Boolean" def test_raise_statement() -> None: diff --git a/tests/unit/generator_test.py b/tests/unit/generator_test.py index ab0120e3b9..e5af1e8c51 100644 --- a/tests/unit/generator_test.py +++ b/tests/unit/generator_test.py @@ -47,7 +47,7 @@ def test_invalid_prefix() -> None: - with pytest.raises(FatalError, match=r'^id: error: empty part in identifier "A..B"$'): + with pytest.raises(FatalError, match=r'^id: error: empty part in identifier "A::::B"$'): Generator("A..B") @@ -258,9 +258,9 @@ def test_substitution_relation_scalar( def test_prefixed_type_identifier() -> None: - assert common.prefixed_type_identifier(ada.ID("Modular"), "P") == ada.ID("P.Modular") + assert common.prefixed_type_identifier(ID("Modular"), "P") == ID("P.Modular") for t in BUILTIN_TYPES: - assert common.prefixed_type_identifier(ada.ID(t), "P") == t.name + assert common.prefixed_type_identifier(ID(t), "P") == t.name DUMMY_SESSION = Session( diff --git a/tests/utils.py b/tests/utils.py index 7633985d3f..27bd552c8a 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -13,7 +13,7 @@ from rflx.error import Location, RecordFluxError from rflx.expression import Expr from rflx.generator import Debug, Generator, const -from rflx.identifier import ID +from rflx.identifier import ID, StrID from rflx.integration import Integration from rflx.model import Field, Link, Message, Model, Session, State, Type, declaration as decl from rflx.specification import Parser @@ -279,13 +279,13 @@ def session_main( output_channels: Sequence[str] = None, context: Sequence[ada.ContextItem] = None, subprograms: Sequence[ada.SubprogramBody] = None, - session_package: ada.StrID = "RFLX.Test.Session", + session_package: StrID = "RFLX.Test.Session", ) -> Mapping[str, str]: input_channels = input_channels or {} output_channels = output_channels or [] context = context or [] subprograms = subprograms or [] - session_package = ada.ID(session_package) + session_package = ID(session_package) run_procedure_spec = ada.ProcedureSpecification("Run") run_procedure_decl = ada.SubprogramDeclaration(run_procedure_spec)