CodeGen Upgrades

.gitignore

@@ -1,4 +1,9 @@
 .vs
+.vscode
 build
 out
+venv
 __pycache__
+
+CodeGen/*.json
+CodeGen/*.h

CodeGen/components.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass, field
+from interfaces.component import IComponent
+
+@dataclass
+class EnumComponent(IComponent):
+    underlying_type: str = "u32"
+    values: list[str] = field(default_factory=dict)
+
+    def calculate_bytes(self, registry):
+        return registry.get_byte_size(self.underlying_type)

CodeGen/emitters/code_buffer.py

@@ -0,0 +1,28 @@
+class CodeBuffer:
+    def __init__(self, indent_char: str = "    "):
+        self._lines: list[str] = []
+        self._indent_level: int = 0
+        self._indent_char: str = indent_char
+
+    def write_line(self, text: str = "") -> None:
+        if text.strip() == "":
+            self._lines.append("")
+        else:
+            indent = self._indent_char * self._indent_level
+            self._lines.append(f"{indent}{text}")
+
+    def open_block(self, prefix_text: str = "") -> None:
+        if prefix_text:
+            self.write_line(prefix_text)
+        self.write_line("{")
+        self._indent_level += 1
+
+    def close_block(self, suffix_text: str = "") -> None:
+        self._indent_level = max(0, self._indent_level - 1)
+        self.write_line(f"}}{suffix_text}")
+
+    def comment(self, text: str) -> None:
+        self.write_line(f"// {text}")
+
+    def get_content(self) -> str:
+        return "\n".join(self._lines)

CodeGen/emitters/default_emitter.py

@@ -0,0 +1,10 @@
+from .structure_emitter import BaseStructureEmitter
+
+class DefaultEmitter(BaseStructureEmitter):
+    def _emit_structure(self, buffer, struct):
+        buffer.open_block(f"struct {struct.name}")
+        for name, type in struct.fields.items():
+            buffer.write_line(f"{type} {name};")
+
+        buffer.close_block(";")
+        buffer.write_line()

CodeGen/emitters/enum_emitter.py

@@ -0,0 +1,28 @@
+import components
+from .emitter import ICodeEmitter
+
+class EnumEmitter(ICodeEmitter):
+    def emit_component(self, buffer, component):
+        if not isinstance(component, components.EnumComponent):
+            raise TypeError("EnumEmitter cannot process components other than enum!")
+
+        enum: components.EnumComponent = component
+        buffer.open_block(f"enum class {enum.name} : {enum.underlying_type}") # open enum
+
+        for idx, val in enumerate(enum.values):
+            buffer.write_line(f"{val:<24} = {idx},")
+
+        buffer.write_line(f"{'INVALID':<24} = std::numeric_limits<{enum.underlying_type}>::max()")
+        buffer.close_block(";\n") # close enum
+
+        buffer.open_block(f"[[nodiscard]] inline constexpr const char* ToString({enum.name} value) noexcept") # open function
+        buffer.open_block("switch (value)") # open switch
+
+        for val in enum.values:
+            buffer.write_line(f"case {enum.name}::{val}: return \"{val}\";")
+        buffer.write_line(f"case {enum.name}::INVALID: return \"INVALID\"")
+        buffer.write_line("default: return \"UNKNOWN\";")
+
+        buffer.close_block() # close switch
+        buffer.close_block() # close function
+        buffer.write_line()

CodeGen/emitters/soa_emitter.py

@@ -0,0 +1,10 @@
+from .structure_emitter import BaseStructureEmitter
+
+class SoAEmitter(BaseStructureEmitter):
+    def _emit_structure(self, buffer, struct):
+        buffer.open_block(f"struct {struct.name}SoA")
+        for name, type in struct.fields.items():
+            buffer.write_line(f"{type}* {name};")
+
+        buffer.close_block(";")
+        buffer.write_line()

CodeGen/emitters/structure_emitter.py

@@ -0,0 +1,15 @@
+from components import StructureComponent
+from .emitter import ICodeEmitter
+from .code_buffer import CodeBuffer
+from abc import abstractmethod
+
+class BaseStructureEmitter(ICodeEmitter):
+    def emit_component(self, buffer, component):
+        if not isinstance(component, StructureComponent):
+            raise TypeError("AosEmitter cannot emit components other than structures")
+
+        self._emit_structure(buffer, component)
+
+    @abstractmethod
+    def _emit_structure(self, buffer: CodeBuffer, struct: StructureComponent):
+        pass

CodeGen/emitters/view_emitter.py

@@ -0,0 +1,16 @@
+from .structure_emitter import BaseStructureEmitter
+
+class ViewEmitter(BaseStructureEmitter):
+    def _emit_structure(self, buffer, struct):
+        struct_type_name = f"{struct.name}View"
+
+        buffer.open_block(f"struct {struct_type_name}")
+        buffer.comment("delete default constructor")
+        buffer.write_line(f"{struct_type_name}() = delete;")
+        buffer.write_line()
+
+        for name, type in struct.fields.items():
+            buffer.write_line(f"{type}& {name};")
+
+        buffer.close_block(";")
+        buffer.write_line()

CodeGen/generators.py

@@ -0,0 +1,40 @@
+from interfaces.file_generator import IFileGenerator
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from schema import Schema
+
+class CppFileGenerator(IFileGenerator):
+    def write_comment(self, text) -> None:
+        self.write_line(f"// {text}")
+
+    def open_block(self, prefix: str = "") -> None:
+        if prefix:
+            self.write_line(prefix)
+
+        self.write_line("{")
+        self._indent_level += 1
+
+    def close_block(self, suffix = ""):
+        self._indent_level = max(0, self._indent_level - 1)
+        self.write_line(f"}}{suffix}")
+
+    def generate(self, schema_data, registry):
+        self.write_comment("="*100)
+        self.write_comment("FILE GENERATED BY DELTA CODEGEN UTILITY".center(100))
+        self.write_comment("="*100)
+        self.write_line()
+
+        self.write_line("#pragma once")
+        self.write_line("#include <cstdint>")
+        self.write_line("#include <cstddef>")
+        self.write_line()
+
+        # TODO: Namespace, structures, enums and anything else
+
+def select_generator(schema: "Schema", outfile: str) -> IFileGenerator:
+    type = schema.generator_type.lower()
+    if type == "cpp":
+        return CppFileGenerator(outfile)
+    else:
+        raise RuntimeError(f"Unrecognized generator type: '{schema.generator_type}'")

CodeGen/interfaces/component.py

@@ -0,0 +1,20 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Dict, Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from type_registries import ITypeRegistry
+
+@dataclass
+class IComponent(ABC):
+    _name: str
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @abstractmethod
+    def calculate_bytes(self, registry: "ITypeRegistry") -> int:
+        """Calculates the byte footprint of the component."""
+        pass