aas-core-codegen 0.0.16__py3-none-any.whl

aas_core_codegen/golang/__init__.py

@@ -0,0 +1 @@
+"""Generate Golang code based on the intermediate meta-model."""

aas_core_codegen/golang/aas_common/__init__.py

@@ -0,0 +1,4 @@
+"""Generate Golang code for common functions."""
+from aas_core_codegen.golang.aas_common import _generate
+
+generate = _generate.generate

aas_core_codegen/golang/aas_common/_generate.py

@@ -0,0 +1,152 @@
+"""Generate Golang code of common functions by including the code directly."""
+
+import io
+
+from icontract import ensure
+
+from aas_core_codegen.common import (
+    Stripped,
+)
+from aas_core_codegen.golang import (
+    common as golang_common,
+)
+from aas_core_codegen.golang.common import INDENT as I, INDENT2 as II, INDENT3 as III
+
+
+# fmt: off
+@ensure(
+    lambda result:
+    result.endswith('\n'),
+    "Trailing newline mandatory for valid end-of-files"
+)
+# fmt: on
+def generate() -> str:
+    """Generate the Golang code for common functions."""
+    blocks = [
+        Stripped(
+            """\
+// Package common provides common functions shared among the other packages.
+package common"""
+        ),
+        golang_common.WARNING,
+        Stripped(
+            f"""\
+import (
+{I}"strings"
+)"""
+        ),
+        Stripped(
+            f"""\
+func Concat(
+{I}parts ...string,
+) string {{
+{I}b := new(strings.Builder)
+{I}for _, part := range parts {{
+{II}b.WriteString(part)
+{I}}}
+{I}return b.String()
+}}"""
+        ),
+        Stripped(
+            f"""\
+// Check if the map contains the given key.
+func MapContains[K comparable, V any](m map[K]V, k K) bool {{
+{I}_, ok := m[k]
+{I}return ok
+}}"""
+        ),
+        Stripped(
+            f"""\
+// Check if any of the elements satisfy the condition.
+func Some[V any](condition func(V) bool, l []V) bool {{
+{I}ok := false
+{I}for _, v := range l {{
+{II}ok = ok || condition(v)
+{I}}}
+{I}return ok
+}}"""
+        ),
+        Stripped(
+            f"""\
+// Check if all the elements satisfy the condition.
+func All[V any](condition func(V) bool, l []V) bool {{
+{I}for _, v := range l {{
+{II}if !condition(v) {{
+{III}return false
+{II}}}
+{I}}}
+{I}return true
+}}"""
+        ),
+        Stripped(
+            f"""\
+// Check if some of the elements in the given range satisfy the condition.
+func SomeRange(condition func(int) bool, start int, end int) bool {{
+{I}for i := start; i < end; i++ {{
+{II}if condition(i) {{
+{III}return true
+{II}}}
+{I}}}
+{I}return false
+}}"""
+        ),
+        Stripped(
+            f"""\
+// Check if all the elements in the given range satisfy the condition.
+func AllRange(condition func(int) bool, start int, end int) bool {{
+{I}for i := start; i < end; i++ {{
+{II}if !condition(i) {{
+{III}return false
+{II}}}
+{I}}}
+{I}return true
+}}"""
+        ),
+        Stripped(
+            f"""\
+// Create a new instance of the `value` and return the pointer to it.
+func NewBool(value bool) *bool {{
+{I}return &value
+}}"""
+        ),
+        Stripped(
+            f"""\
+// Create a new instance of the `value` and return the pointer to it.
+func NewInt(value int) *int {{
+{I}return &value
+}}"""
+        ),
+        Stripped(
+            f"""\
+// Create a new instance of the `value` and return the pointer to it.
+func NewInt64(value int64) *int64 {{
+{I}return &value
+}}"""
+        ),
+        Stripped(
+            f"""\
+// Create a new instance of the `value` and return the pointer to it.
+func NewFloat64(value float64) *float64 {{
+{I}return &value
+}}"""
+        ),
+        Stripped(
+            f"""\
+// Create a new instance of the `value` and return the pointer to it.
+func NewString(value string) *string {{
+{I}return &value
+}}"""
+        ),
+        golang_common.WARNING,
+    ]
+
+    writer = io.StringIO()
+    for i, block in enumerate(blocks):
+        if i > 0:
+            writer.write("\n\n")
+
+        writer.write(block)
+
+    writer.write("\n")
+
+    return writer.getvalue()

aas_core_codegen/golang/common.py

@@ -0,0 +1,303 @@
+"""Provide common functions shared among different Go code generation modules."""
+import io
+import math
+from typing import List, Tuple, Optional
+
+from icontract import ensure
+
+from aas_core_codegen import intermediate
+from aas_core_codegen.common import Stripped, assert_never, Identifier
+from aas_core_codegen.golang import (
+    naming as golang_naming,
+    pointering as golang_pointering,
+)
+
+
+@ensure(lambda result: result.startswith('"'))
+@ensure(lambda result: result.endswith('"'))
+def string_literal(text: str) -> Stripped:
+    """Generate a Go string literal from the ``text``."""
+    escaped = []  # type: List[str]
+
+    for character in text:
+        code_point = ord(character)
+
+        if character == "\a":
+            escaped.append("\\a")
+        elif character == "\b":
+            escaped.append("\\b")
+        elif character == "\f":
+            escaped.append("\\f")
+        elif character == "\n":
+            escaped.append("\\n")
+        elif character == "\r":
+            escaped.append("\\r")
+        elif character == "\t":
+            escaped.append("\\t")
+        elif character == "\v":
+            escaped.append("\\v")
+        elif character == '"':
+            escaped.append('\\"')
+        elif character == "\\":
+            escaped.append("\\\\")
+        elif code_point < 32:
+            # Non-printable ASCII characters
+            escaped.append(f"\\x{ord(character):x}")
+        elif 255 < code_point < 65536:
+            # Above ASCII
+            escaped.append(f"\\u{ord(character):04x}")
+        elif code_point >= 65536:
+            # Above Unicode Binary Multilingual Pane
+            escaped.append(f"\\U{ord(character):08x}")
+        else:
+            escaped.append(character)
+
+    return Stripped('"{}"'.format("".join(escaped)))
+
+
+def needs_escaping(text: str) -> bool:
+    """Check whether the ``text`` contains a character that needs escaping."""
+    for character in text:
+        if character == "\a":
+            return True
+        elif character == "\b":
+            return True
+        elif character == "\f":
+            return True
+        elif character == "\n":
+            return True
+        elif character == "\r":
+            return True
+        elif character == "\t":
+            return True
+        elif character == "\v":
+            return True
+        elif character == '"':
+            return True
+        elif character == "\\":
+            return True
+        else:
+            pass
+
+    return False
+
+
+def boolean_literal(value: bool) -> Stripped:
+    """Generate the boolean literal corresponding to the ``value``."""
+    return Stripped("true") if value else Stripped("false")
+
+
+def float_literal(value: float) -> Stripped:
+    """Generate the float literal.
+
+    We assume that the precision of the literal is not critical and rely on
+    Python's ``str(.)`` function. However, if you want to specify the exact
+    number, you have to format the number yourself, probably using G17 representation.
+    """
+    if math.isnan(value):
+        return Stripped("math.NaN")
+    if value == math.inf:
+        return Stripped("math.Inf(1)")
+    elif value == -math.inf:
+        return Stripped("math.Inf(-1)")
+    else:
+        return Stripped(str(value))
+
+
+# NOTE (mristin, 2023-01-13):
+# See: https://stackoverflow.com/questions/19094704/indentation-in-go-tabs-or-spaces
+INDENT = "\t"
+
+
+def bytes_literal(value: bytes) -> Tuple[Stripped, bool]:
+    """
+    Generate an expression representing the ``value``.
+
+    If there are more than 8 bytes, a multi-line expression is returned.
+
+    :param value: to be represented
+    :return: (Golang expression, is multi-line)
+    """
+    if len(value) == 0:
+        return Stripped("[...]byte{}"), False
+
+    writer = io.StringIO()
+
+    if len(value) <= 8:
+        items_joined = ", ".join(f"0x{byte:02x}" for byte in value)
+        return Stripped(f"[...]byte{{{items_joined}}}"), False
+    else:
+        writer.write(
+            """\
+[...]byte {"""
+        )
+
+        for start in range(0, len(value), 8):
+            if start == 0:
+                writer.write(f"\n{INDENT}")
+            else:
+                writer.write(f",\n{INDENT}")
+
+            end = min(start + 8, len(value))
+
+            assert start < end
+
+            for i, byte in enumerate(value[start:end]):
+                if i > 0:
+                    writer.write(", ")
+
+                writer.write(f"0x{byte:02x}")
+
+        writer.write("\n}")
+
+        return Stripped(writer.getvalue()), True
+
+
+PRIMITIVE_TYPE_MAP = {
+    intermediate.PrimitiveType.BOOL: Stripped("bool"),
+    intermediate.PrimitiveType.INT: Stripped("int64"),
+    intermediate.PrimitiveType.FLOAT: Stripped("float64"),
+    intermediate.PrimitiveType.STR: Stripped("string"),
+    intermediate.PrimitiveType.BYTEARRAY: Stripped("[]byte"),
+}
+
+
+def _assert_all_primitive_types_are_mapped() -> None:
+    """Assert that we have explicitly mapped all the primitive types to Go."""
+    all_primitive_literals = set(literal.value for literal in PRIMITIVE_TYPE_MAP)
+
+    mapped_primitive_literals = set(
+        literal.value for literal in intermediate.PrimitiveType
+    )
+
+    all_diff = all_primitive_literals.difference(mapped_primitive_literals)
+    mapped_diff = mapped_primitive_literals.difference(all_primitive_literals)
+
+    messages = []  # type: List[str]
+    if len(mapped_diff) > 0:
+        messages.append(
+            f"More primitive maps are mapped than there were defined "
+            f"in the ``intermediate._types``: {sorted(mapped_diff)}"
+        )
+
+    if len(all_diff) > 0:
+        messages.append(
+            f"One or more primitive types in the ``intermediate._types`` were not "
+            f"mapped in PRIMITIVE_TYPE_MAP: {sorted(all_diff)}"
+        )
+
+    if len(messages) > 0:
+        raise AssertionError("\n\n".join(messages))
+
+
+_assert_all_primitive_types_are_mapped()
+
+TYPES_PACKAGE = Identifier("aastypes")
+CONSTANTS_PACKAGE = Identifier("aasconstants")
+VERIFICATION_PACKAGE = Identifier("aasverification")
+
+
+def generate_type(
+    type_annotation: intermediate.TypeAnnotationUnion,
+    types_package: Optional[Identifier] = None,
+) -> Stripped:
+    """
+    Generate the Go type for the given type annotation.
+
+    If ``types_package`` is specified, it is prepended to all our types.
+    """
+    if isinstance(type_annotation, intermediate.PrimitiveTypeAnnotation):
+        return PRIMITIVE_TYPE_MAP[type_annotation.a_type]
+
+    elif isinstance(type_annotation, intermediate.OurTypeAnnotation):
+        our_type = type_annotation.our_type
+
+        if isinstance(our_type, intermediate.Enumeration):
+            enum_name = golang_naming.enum_name(type_annotation.our_type.name)
+            if types_package is None:
+                return enum_name
+
+            return Stripped(f"{types_package}.{enum_name}")
+
+        elif isinstance(our_type, intermediate.ConstrainedPrimitive):
+            return PRIMITIVE_TYPE_MAP[our_type.constrainee]
+
+        elif isinstance(
+            our_type, (intermediate.AbstractClass, intermediate.ConcreteClass)
+        ):
+            # NOTE (mristin, 2023-03-28):
+            # We always refer to interfaces even in cases of concrete classes without
+            # concrete descendants since we want to allow enhancing.
+            interface_name = golang_naming.interface_name(our_type.name)
+
+            if types_package is None:
+                return interface_name
+
+            return Stripped(f"{types_package}.{interface_name}")
+
+    elif isinstance(type_annotation, intermediate.ListTypeAnnotation):
+        item_type = generate_type(
+            type_annotation=type_annotation.items, types_package=types_package
+        )
+
+        return Stripped(f"[]{item_type}")
+
+    elif isinstance(type_annotation, intermediate.OptionalTypeAnnotation):
+        value_type = generate_type(
+            type_annotation=type_annotation.value, types_package=types_package
+        )
+
+        if golang_pointering.is_pointer_type(type_annotation):
+            return Stripped(f"*{value_type}")
+
+        return value_type
+
+    else:
+        assert_never(type_annotation)
+
+    raise AssertionError("Should not have gotten here")
+
+
+INDENT2 = INDENT * 2
+INDENT3 = INDENT * 3
+INDENT4 = INDENT * 4
+INDENT5 = INDENT * 5
+INDENT6 = INDENT * 6
+
+WARNING = Stripped(
+    """\
+// This code has been automatically generated by aas-core-codegen.
+// Do NOT edit or append."""
+)
+
+
+class GeneratorForLoopVariables:
+    """
+    Generate a unique variable name based on ``item`` stem.
+
+    >>> generator = GeneratorForLoopVariables()
+
+    >>> next(generator)
+    'v'
+
+    >>> next(generator)
+    'v1'
+
+    >>> next(generator)
+    'v2'
+    """
+
+    def __init__(self) -> None:
+        """Initialize with the zero counter."""
+        self.counter = 0
+
+    def __next__(self) -> Identifier:
+        """Generate the next variable name."""
+        if self.counter == 0:
+            result = Identifier("v")
+        else:
+            result = Identifier(f"v{self.counter}")
+
+        self.counter += 1
+
+        return result

aas_core_codegen/golang/constants/__init__.py

@@ -0,0 +1,5 @@
+"""Generate Golang constants corresponding to the constants of the meta-model."""
+
+from aas_core_codegen.golang.constants import _generate
+
+generate = _generate.generate