blackspace 0.0.47__tar.gz

blackspace-0.0.47/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: blackspace
+Version: 0.0.47
+Summary: BlackSpace
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Provides-Extra: build
+Requires-Dist: pip-tools; extra == "build"
+Requires-Dist: setuptools; extra == "build"
+Requires-Dist: twine; extra == "build"
+Provides-Extra: publish
+Requires-Dist: twine; extra == "publish"
+Provides-Extra: types
+Requires-Dist: types-mock; extra == "types"
+Provides-Extra: test
+Requires-Dist: black; extra == "test"
+Requires-Dist: mock; extra == "test"
+Requires-Dist: mypy; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-mock; extra == "test"
+Requires-Dist: pytest-mypy; extra == "test"
+Requires-Dist: pytest-timeout; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: dotenv
+Requires-Dist: python-dotenv; extra == "dotenv"
+
+# BlackSpace
+
+BlackSpace is a programming language that compiles to WhiteSpace, an esoteric programming language
+that uses only spaces, tabs, and linefeeds as syntax. BlackSpace is designed to make it easier
+to write and read WhiteSpace programs by providing a higher-level syntax.
+
+Currently the parser is not implemented, and only the compiler from an AST to WhiteSpace
+is available.

blackspace-0.0.47/README.md

@@ -0,0 +1,8 @@
+# BlackSpace
+
+BlackSpace is a programming language that compiles to WhiteSpace, an esoteric programming language
+that uses only spaces, tabs, and linefeeds as syntax. BlackSpace is designed to make it easier
+to write and read WhiteSpace programs by providing a higher-level syntax.
+
+Currently the parser is not implemented, and only the compiler from an AST to WhiteSpace
+is available.

blackspace-0.0.47/blackspace.egg-info/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.4
+Name: blackspace
+Version: 0.0.47
+Summary: BlackSpace
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Provides-Extra: build
+Requires-Dist: pip-tools; extra == "build"
+Requires-Dist: setuptools; extra == "build"
+Requires-Dist: twine; extra == "build"
+Provides-Extra: publish
+Requires-Dist: twine; extra == "publish"
+Provides-Extra: types
+Requires-Dist: types-mock; extra == "types"
+Provides-Extra: test
+Requires-Dist: black; extra == "test"
+Requires-Dist: mock; extra == "test"
+Requires-Dist: mypy; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-mock; extra == "test"
+Requires-Dist: pytest-mypy; extra == "test"
+Requires-Dist: pytest-timeout; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: dotenv
+Requires-Dist: python-dotenv; extra == "dotenv"
+
+# BlackSpace
+
+BlackSpace is a programming language that compiles to WhiteSpace, an esoteric programming language
+that uses only spaces, tabs, and linefeeds as syntax. BlackSpace is designed to make it easier
+to write and read WhiteSpace programs by providing a higher-level syntax.
+
+Currently the parser is not implemented, and only the compiler from an AST to WhiteSpace
+is available.

blackspace-0.0.47/blackspace.egg-info/SOURCES.txt

@@ -0,0 +1,73 @@
+README.md
+pyproject.toml
+blackspace.egg-info/PKG-INFO
+blackspace.egg-info/SOURCES.txt
+blackspace.egg-info/dependency_links.txt
+blackspace.egg-info/entry_points.txt
+blackspace.egg-info/requires.txt
+blackspace.egg-info/top_level.txt
+blackspace_compiler/__init__.py
+blackspace_compiler/__main__.py
+blackspace_compiler/ast/__init__.py
+blackspace_compiler/ast/debugstatement.py
+blackspace_compiler/ast/node.py
+blackspace_compiler/ast/context/__init__.py
+blackspace_compiler/ast/context/evaluation_context.py
+blackspace_compiler/ast/context/function_registry.py
+blackspace_compiler/ast/context/issue_level.py
+blackspace_compiler/ast/context/label_registry.py
+blackspace_compiler/ast/context/heap/__init__.py
+blackspace_compiler/ast/context/heap/consts.py
+blackspace_compiler/ast/context/heap/helpers.py
+blackspace_compiler/ast/context/stack/__init__.py
+blackspace_compiler/ast/context/stack/helpers.py
+blackspace_compiler/ast/definitions/__init__.py
+blackspace_compiler/ast/definitions/function.py
+blackspace_compiler/ast/definitions/variable.py
+blackspace_compiler/ast/expressions/__init__.py
+blackspace_compiler/ast/expressions/expression.py
+blackspace_compiler/ast/expressions/builtinfunctions/__init__.py
+blackspace_compiler/ast/expressions/builtinfunctions/sizeof.py
+blackspace_compiler/ast/expressions/functions/__init__.py
+blackspace_compiler/ast/expressions/functions/function_call.py
+blackspace_compiler/ast/expressions/literals/__init__.py
+blackspace_compiler/ast/expressions/literals/array.py
+blackspace_compiler/ast/expressions/literals/bool.py
+blackspace_compiler/ast/expressions/literals/int.py
+blackspace_compiler/ast/expressions/literals/string.py
+blackspace_compiler/ast/expressions/operations/__init__.py
+blackspace_compiler/ast/expressions/operations/arithmetic.py
+blackspace_compiler/ast/expressions/operations/boolean.py
+blackspace_compiler/ast/expressions/operations/comparison.py
+blackspace_compiler/ast/expressions/operations/operator.py
+blackspace_compiler/ast/expressions/variables/__init__.py
+blackspace_compiler/ast/expressions/variables/array_index.py
+blackspace_compiler/ast/expressions/variables/memory_fetch.py
+blackspace_compiler/ast/expressions/variables/variable_access.py
+blackspace_compiler/ast/statements/__init__.py
+blackspace_compiler/ast/statements/assignment.py
+blackspace_compiler/ast/statements/compound.py
+blackspace_compiler/ast/statements/condition.py
+blackspace_compiler/ast/statements/function.py
+blackspace_compiler/ast/statements/io.py
+blackspace_compiler/ast/statements/loop.py
+blackspace_compiler/ast/statements/program.py
+blackspace_compiler/ast/statements/statement.py
+blackspace_compiler/ast/statements/void.py
+blackspace_compiler/ast/types/__init__.py
+blackspace_compiler/ast/types/type.py
+blackspace_compiler/ast/types/complex/array.py
+blackspace_compiler/ast/types/complex/memory.py
+blackspace_compiler/ast/types/complex/string.py
+blackspace_compiler/ast/types/primitives/__init__.py
+blackspace_compiler/ast/types/primitives/bool.py
+blackspace_compiler/ast/types/primitives/int.py
+blackspace_compiler/ast/types/primitives/void.py
+blackspace_compiler/ast/utils/__init__.py
+blackspace_compiler/ast/utils/error_message.py
+blackspace_compiler/ast/utils/indent.py
+blackspace_compiler/whitespace/__init__.py
+blackspace_compiler/whitespace/converters.py
+blackspace_compiler/whitespace/printstr.py
+blackspace_compiler/whitespace/snippets.py
+blackspace_compiler/whitespace/tokens.py

blackspace-0.0.47/blackspace.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

blackspace-0.0.47/blackspace.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+blackspace = blackspace_compiler.__main__:main

blackspace-0.0.47/blackspace.egg-info/requires.txt

@@ -0,0 +1,24 @@
+
+[build]
+pip-tools
+setuptools
+twine
+
+[dotenv]
+python-dotenv
+
+[publish]
+twine
+
+[test]
+black
+mock
+mypy
+pytest-cov
+pytest-mock
+pytest-mypy
+pytest-timeout
+pytest
+
+[types]
+types-mock

blackspace-0.0.47/blackspace.egg-info/top_level.txt

@@ -0,0 +1 @@
+blackspace_compiler

blackspace-0.0.47/blackspace_compiler/__main__.py

@@ -0,0 +1,6 @@
+def main() -> None:
+    pass
+
+
+if __name__ == "__main__":
+    main()

blackspace-0.0.47/blackspace_compiler/ast/context/__init__.py

@@ -0,0 +1,4 @@
+from .evaluation_context import EvaluationContext
+from .issue_level import IssueLevel
+
+__all__ = ["EvaluationContext", "IssueLevel"]

blackspace-0.0.47/blackspace_compiler/ast/context/evaluation_context.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from contextlib import contextmanager
+from dataclasses import dataclass
+from typing import Callable
+
+from ..node import AstNode
+from .function_registry import FunctionRegistry
+from .issue_level import IssueLevel
+from .label_registry import LabelRegistry
+
+
+@dataclass
+class Issue:
+    level: IssueLevel
+    node: AstNode
+    message: str
+
+
+@contextmanager
+def increment_stack(context: EvaluationContext, by: int = 1):
+    try:
+        context._stack_offset += by
+        yield
+    finally:
+        context._stack_offset -= by
+
+
+@contextmanager
+def reset_stack(context: EvaluationContext):
+    try:
+        original_offset = context._stack_offset
+        context._stack_offset = 0
+        yield
+    finally:
+        if context._stack_offset != 0:
+            raise RuntimeError("Stack offset must be zero when exiting reset_stack context")
+        context._stack_offset = original_offset
+
+
+class EvaluationContext:
+    def __init__(self) -> None:
+        self.label_registry = LabelRegistry()
+        self.function_registry = FunctionRegistry()
+
+        self._issues: list[Issue] = []
+        self._stack_offset = 0
+
+    def register_issue(self, level: IssueLevel, node: AstNode, message: str) -> None:
+        self._issues.append(Issue(level, node, message))
+
+    def with_incremented_stack(self, fn: Callable[[EvaluationContext], str]) -> str:
+        with increment_stack(self):
+            return fn(self)
+
+    @property
+    def stack_offset(self) -> int:
+        return self._stack_offset
+
+    def print_issues(self, strict: bool = False) -> None:
+        has_warnings = False
+        has_errors = False
+
+        for issue in self._issues:
+            print(f"[{issue.level.name}] {issue.message} (at {issue.node})")
+
+            if issue.level == IssueLevel.ERROR:
+                has_errors = True
+            elif issue.level == IssueLevel.WARNING:
+                has_warnings = True
+
+        if has_errors:
+            raise RuntimeError("Compilation failed due to errors.")
+        if strict and has_warnings:
+            raise RuntimeError("Compilation failed due to warnings in strict mode.")

blackspace-0.0.47/blackspace_compiler/ast/context/function_registry.py

@@ -0,0 +1,45 @@
+from contextlib import contextmanager
+
+from ..definitions.function import FunctionSignature
+
+
+class FunctionRegistry:
+    def __init__(self) -> None:
+        self._functions: list[FunctionSignature] = []
+        self._labels: dict[str, int] = {}
+        self._current_function: FunctionSignature | None = None
+
+    def register_function(self, function: FunctionSignature, label_id: int) -> None:
+        if any(fn.name == function.name for fn in self._functions):
+            raise RuntimeError(f"Function '{function.name}' is already registered.")
+
+        self._functions.append(function)
+        self._labels[function.name] = label_id
+
+    def get_function_definition(self, function_name: str) -> FunctionSignature | None:
+        for function in self._functions:
+            if function.name == function_name:
+                return function
+        return None
+
+    def get_function_label(self, function_name: str) -> int:
+        """
+        Get the label ID for the given function name.
+        Should not be called unless the function is known to exist by using
+        `get_function_definition` first.
+        """
+        return self._labels[function_name]
+
+    @contextmanager
+    def function_context(self, function: FunctionSignature):
+        if self._current_function is not None:
+            raise RuntimeError("Nested function definitions are not supported.")
+        self._current_function = function
+        try:
+            yield
+        finally:
+            self._current_function = None
+
+    @property
+    def current_function(self) -> FunctionSignature | None:
+        return self._current_function

blackspace-0.0.47/blackspace_compiler/ast/context/heap/consts.py

@@ -0,0 +1,16 @@
+REGISTER_A = 0
+REGISTER_B = 1
+REGISTER_C = 2
+REGISTER_D = 3
+
+_max_parameter_count = 15
+_function_parameter_start = REGISTER_D + 1
+FUNCTION_PARAMETER_REGISTERS = list(
+    range(_function_parameter_start, _function_parameter_start + _max_parameter_count)
+)
+
+FIRST_PROGRAM_STACK_HEAP_ADDRESS = max(FUNCTION_PARAMETER_REGISTERS) + 1
+PROGRAM_STACK_LIMIT = FIRST_PROGRAM_STACK_HEAP_ADDRESS + 2048 * 128
+
+FREE_HEAP_ALLOCATION_COUNTER = PROGRAM_STACK_LIMIT + 1
+FREE_HEAP_START = FREE_HEAP_ALLOCATION_COUNTER + 1

blackspace-0.0.47/blackspace_compiler/ast/context/heap/helpers.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ....whitespace.snippets import ADD, DUPLICATE, FETCH, PUSH, STORE, SWAP
+from ...debugstatement import debug_statement
+from .consts import FREE_HEAP_ALLOCATION_COUNTER, FREE_HEAP_START
+
+if TYPE_CHECKING:
+    from ..evaluation_context import EvaluationContext
+
+
+def initialize_heap(context: EvaluationContext) -> str:
+    """
+    Initialize the heap by setting up the heap allocation counter.
+    This function should be called once at the start of the program execution.
+    """
+    _ = context  # Unused
+    return (
+        debug_statement("Initializing heap")
+        + PUSH(FREE_HEAP_ALLOCATION_COUNTER)
+        + PUSH(FREE_HEAP_START)
+        + STORE
+    )
+
+
+def place_const_data_on_heap(context: EvaluationContext, data: list[int]) -> str:
+    """
+    Place constant data on the heap and return the starting address.
+    This can be used for string literals or other constant data.
+    The context stack offset is NOT incremented, that is the responsibility of the caller.
+    """
+    _ = context  # Unused
+
+    # get the current free heap location address
+    res = (
+        debug_statement(f"Placing {len(data)} long const data on heap")
+        + PUSH(FREE_HEAP_ALLOCATION_COUNTER)
+        + FETCH
+        + DUPLICATE
+    )
+
+    data = [len(data)] + data  # prepend length
+
+    for i in range(len(data)):
+        res += DUPLICATE
+        res += PUSH(data[i]) + STORE
+        res += PUSH(1) + ADD
+    res += PUSH(FREE_HEAP_ALLOCATION_COUNTER) + SWAP + STORE
+    return res
+
+
+def allocate_data_on_heap(context: EvaluationContext, size: int) -> str:
+    """
+    Allocate space on the heap for a given size and return the starting address.
+    The first word at that address will contain the size of the allocated block.
+    The context stack offset is NOT incremented, that is the responsibility of the caller.
+    """
+    _ = context  # Unused
+
+    # get the current free heap location address
+    res = (
+        debug_statement(f"Allocating {size} long space on heap")
+        + PUSH(FREE_HEAP_ALLOCATION_COUNTER)
+        + FETCH
+    )
+
+    # on the free location, first store the size
+    res += DUPLICATE + PUSH(size) + STORE
+
+    # increment the free heap location by size + 1
+    res += DUPLICATE + PUSH(size + 1) + ADD
+    res += PUSH(FREE_HEAP_ALLOCATION_COUNTER) + SWAP + STORE
+
+    return res

blackspace-0.0.47/blackspace_compiler/ast/context/issue_level.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+class IssueLevel(Enum):
+    WARNING = "warning"
+    ERROR = "error"

blackspace-0.0.47/blackspace_compiler/ast/context/label_registry.py

@@ -0,0 +1,8 @@
+class LabelRegistry:
+    def __init__(self):
+        self._counter = 0
+
+    def new_label(self) -> int:
+        label = self._counter
+        self._counter += 1
+        return label

blackspace-0.0.47/blackspace_compiler/ast/context/stack/helpers.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ....whitespace.snippets import ADD, COPY, DUPLICATE, FETCH, POP, PUSH, STORE
+from ...debugstatement import debug_statement
+from ..heap.consts import FIRST_PROGRAM_STACK_HEAP_ADDRESS
+
+if TYPE_CHECKING:
+    from ..evaluation_context import EvaluationContext
+
+
+# A function stack is a stack frame used during the evaluation of functions.
+# When entering a function, a new stack frame is created to hold local variables and state.
+# When exiting a function, the stack frame is removed, and control returns to the previous stack.
+# The data of the stack frames is stored on the runtime heap.
+# The stack data store location is pushed to the whitespace stack.
+
+
+def _get_datastack_location(context: EvaluationContext) -> str:
+    """Get the heap location of the current data stack."""
+    return COPY(context.stack_offset)
+
+
+def enter_first_stack(context: EvaluationContext) -> str:
+    """Enter the first stack of the execution context."""
+    _ = context  # Unused
+    return (
+        debug_statement("Entering first stack")
+        + PUSH(FIRST_PROGRAM_STACK_HEAP_ADDRESS)
+        + DUPLICATE
+        + PUSH(1)
+        + STORE
+    )
+
+
+def enter_new_stack(context: EvaluationContext) -> str:
+    """Enter a new stack in the execution context. Assumes there is already at least one stack."""
+    # Get the location of the current stack, get the length of the current stack,
+    # add them together to the the start of the new stack.
+    # Push 1 to the new stack to indicate its length is starting at 1.
+    res = debug_statement(f"Entering new stack with stack offset {context.stack_offset}")
+    res += _get_datastack_location(context)
+    res += DUPLICATE + FETCH + ADD
+    res += DUPLICATE + PUSH(1) + STORE
+    return res
+
+
+def exit_stack(context: EvaluationContext) -> str:
+    """Exit the current stack in the execution context."""
+    _ = context  # Unused
+    return debug_statement(f"Exiting stack with stack offset {context.stack_offset}") + POP
+
+
+def silently_allocate_on_datastack(context: EvaluationContext, length: int) -> str:
+    """
+    Allocate data on the current data stack.
+    The starting location of the data is NOT pushed onto the whitespace stack.
+    """
+    res = _get_datastack_location(context)
+    res += DUPLICATE + FETCH + PUSH(length) + ADD + STORE
+    return res
+
+
+def get_datastack_location(context: EvaluationContext, offset: int) -> str:
+    """
+    Get the heap location of the current data stack plus the given offset.
+    **Skips the first element of the data stack, which is the length of the stack.**
+    The resulting location is pushed onto the whitespace stack.
+    The context stack offset is NOT incremented, that is the responsibility of the caller.
+    """
+    offset += 1  # Skip the length element
+    res = _get_datastack_location(context)
+    if offset != 0:
+        res += PUSH(offset) + ADD
+    return res

blackspace-0.0.47/blackspace_compiler/ast/debugstatement.py

@@ -0,0 +1,27 @@
+from ..whitespace.printstr import print_str
+
+ENABLE_DEBUG = False
+
+
+def debug_statement(text: str) -> str:
+    if not ENABLE_DEBUG:
+        return ""
+    return (
+        code_comment(f"DEBUG: {text}")
+        + print_str(f"DEBUG: {text}\n")
+        + code_comment("// end of debug statement print")
+    )
+
+
+def debug_instructions(instructions: str) -> str:
+    if not ENABLE_DEBUG:
+        return ""
+    return instructions
+
+
+def code_comment(text: str) -> str:
+    if "\n" in text:
+        raise ValueError("Code comments cannot contain newlines")
+    if "\t" in text:
+        raise ValueError("Code comments cannot contain tabs")
+    return text.replace(" ", "·")

blackspace-0.0.47/blackspace_compiler/ast/definitions/function.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from ..types.type import Type
+from .variable import VariableDefinition
+
+
+@dataclass
+class ParameterDefinition:
+    name: str
+    type: Type
+
+
+@dataclass
+class FunctionSignature:
+    name: str
+    parameters: list[ParameterDefinition]
+    return_type: Type
+    variables: list[VariableDefinition]
+
+    def assert_correct_variable_configuration(self) -> None:
+        """
+        Validates that the function variable setup is correct according to the parameters.
+        Each parameter will be stored into a variable by the same name. The first N variables
+        must match the N parameters.
+        """
+        if len(self.variables) < len(self.parameters):
+            raise RuntimeError(
+                f"Function '{self.name}' has fewer variables ({len(self.variables)}) "
+                f"than parameters ({len(self.parameters)})."
+            )
+        for i in range(len(self.parameters)):
+            param = self.parameters[i]
+            var = self.variables[i]
+            if param.name != var.name:
+                raise RuntimeError(
+                    f"Function '{self.name}' parameter {i} name '{param.name}' does not match "
+                    f"variable name '{var.name}'."
+                )
+            if param.type != var.type:
+                raise RuntimeError(
+                    f"Function '{self.name}' parameter {i} type '{param.type}' does not match "
+                    f"variable type '{var.type}'."
+                )
+
+    def get_variable(self, name: str) -> VariableOffset | None:
+        offset = 0
+        for variable in self.variables:
+            if variable.name == name:
+                return VariableOffset(definition=variable, offset=offset)
+            else:
+                offset += variable.type.get_size()
+        return None
+
+
+@dataclass
+class VariableOffset:
+    definition: VariableDefinition
+    offset: int

blackspace-0.0.47/blackspace_compiler/ast/definitions/variable.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+from ..types.type import Type
+
+
+@dataclass
+class VariableDefinition:
+    name: str
+    type: Type
+    is_mutable: bool

blackspace-0.0.47/blackspace_compiler/ast/expressions/builtinfunctions/sizeof.py

@@ -0,0 +1,21 @@
+from ...context import EvaluationContext
+from ...types.primitives.int import IntegerType
+from ..expression import Expression
+from ..literals.int import IntLiteral
+
+
+class SizeofExpression(Expression):
+    def __init__(self, inner_expression: Expression):
+        super().__init__()
+        self.inner_expression = inner_expression
+
+    def __repr__(self):
+        return f"sizeof({self.inner_expression})"
+
+    def get_type(self, context):
+        return IntegerType()
+
+    def evaluate(self, context: EvaluationContext) -> str:
+        inner_type = self.inner_expression.get_type(context)
+        size = inner_type.get_size()
+        return IntLiteral(size).evaluate(context)

blackspace-0.0.47/blackspace_compiler/ast/expressions/expression.py

@@ -0,0 +1,16 @@
+from abc import ABC, abstractmethod
+
+from ..context import EvaluationContext
+from ..node import AstNode
+from ..types.type import Type
+
+
+class Expression(AstNode, ABC):
+
+    @abstractmethod
+    def get_type(self, context: EvaluationContext) -> Type:
+        pass
+
+    @abstractmethod
+    def evaluate(self, context: EvaluationContext) -> str:
+        pass