spamoji 0.1.0__tar.gz

spamoji-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Philipp Dona
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

spamoji-0.1.0/PKG-INFO

@@ -0,0 +1,162 @@
+Metadata-Version: 2.4
+Name: spamoji
+Version: 0.1.0
+Summary: A programming language that only uses emojis as syntax.
+Author: iqnite
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# spamoji
+
+A programming language that only uses emojis as syntax and encourages writing spaghetti code.
+
+## Example
+
+```spamoji
+🗒️ A function to calculate factorial
+⚙️ 🔢❕🫸🔰🫷
+    👋 🏁 🫴 1
+    🔃 🔰 🤜 1
+        🏁 🫴 🏁 ✖️ 🔰
+        🔰 🫴 🔰 ➖ 1
+    ↩️ 🏁
+
+💭🫸🔤Enter a number to calculate the factorial: 🔤🫷
+👋 😀 🫴 🔢🫸⌨️❗🫷
+🤔 😀 🟰 ⚠️
+👍
+    💬🫸🔤Invalid input.🔤🫷
+👎
+    💬🫸🔤The factorial of 🔤😀🔤 is 🔤🫸🔢❕🫸😀🫷🫷🫷
+```
+
+## What's this all about?
+
+This language is a learning project. Since it lacks many features of a typical programming language, it is not recommended for production use. If this experiment is successful, I might move on and begin working on Esore, a more serious language I've been designing in the past 2 years.
+
+## Installation
+
+To install the spamoji interpreter, you will need to have Python 3.10 or higher installed on your machine. You can download Python from the [official website](https://www.python.org/downloads/).
+
+Once you have Python installed, you can install the spamoji interpreter using pip:
+
+```bash
+pip install spamoji
+```
+
+## Usage
+
+To run a spamoji program, you will need to use the spamoji interpreter.
+
+You can provide a spamoji file (with the .🍝 extension) as input to run it. For example:
+
+```bash
+spamoji my_program.🍝
+```
+
+If no file is supplied, the interactive REPL will start, which allows to enter and evaluate expressions directly.
+
+If the above command doesn't work, you can also run the interpreter using Python's -m flag:
+
+```bash
+python -m spamoji my_program.🍝
+```
+
+## Syntax
+
+> [!IMPORTANT]
+> The emojis used in the syntax were entered on a Windows machine. While they should work on other platforms, some emojis might not render correctly or might be replaced with different emojis. If you encounter any issues, please try copying and pasting the emojis from this documentation into your code.
+
+### Statements
+
+Each line of code starts with an emoji that indicates the type of statement. Each statement is followed by the relevant information, separated by spaces. Statements include:
+
+- 🗒️ Comment: Text in this line will be ignored
+- 👋 Variable declaration: Followed by the variable assignment
+- 🤔 If statement: Followed by the condition
+  - 👍 If true block
+  - 👎 Else block
+- 🔃 Loop: Followed by the loop variable and condition
+  - ⛔ Break statement: Used to exit the loop
+  - ⤴️ Continue statement: Used to skip to the next iteration of the loop
+- ⚙️ Function definition: Followed by the function name and parameters
+  - ↩️ Return statement: Followed by the value to return
+  <!-- - 🧩 Import statement: Followed by a file name, it gets replaced by the contents of that file before execution -->
+
+Some statements can be nested, such as if statements and loops. Indentation is used to indicate the scope of these statements. Indented blocks are considered part of the previous statement until the indentation level decreases. Variables declared inside of a block are only accessible inside of that block and any nested blocks.
+
+### Functions
+
+Functions are defined using the ⚙️ emoji, followed by the function name and parameters. The function body is indented and can contain any valid statements. The function can return a value using the ↩️ emoji.
+
+Functions can be called by using their name followed by the arguments, separated by 🔸, between 🫸 and 🫷. Functions with no arguments can also be called with the ❗ emoji.
+
+Here's an example of a function definition and call:
+
+```spamoji
+⚙️ greetAndAsk 🫸firstName 🔸 lastName🫷
+    💬🫸🔤Hello, 🔤firstName🔤 🔤lastName🔤! Please enter a number...🔤🫷
+    ↩️ ⌨️❗  🗒️ Return the user input
+
+greetAndAsk🫸🔤John🔤 🔸 🔤Doe🔤🫷
+```
+
+### Variables
+
+Variables are declared using the 👋 emoji, followed by the variable assignment expression. An assinment expression starts with the variable name, followed by 🫴 and a value. Variable names can be any combination of letters, numbers, and emojis, but must start with a letter or emoji. Variables can be used in expressions and statements after they have been assigned.
+
+### Expressions
+
+Many statements can be used as expressions within other statements. 🫸 and 🫷 can be used to group expressions and control the order of evaluation. For example, you can use a function call as part of an if statement condition or as part of a variable assignment.
+
+### Operators
+
+The language supports basic operators for logical and arithmetic operations. These can be used between two values to perform calculations.
+
+- ➕: Addition
+- ➖: Subtraction
+- ✖️: Multiplication
+- ➗: Division
+- 🟰: Equal
+- 🆚: Not equal
+- 🤜: Greater than
+- 🤛: Less than
+- 🤝: Logical AND
+- 🤲: Logical OR
+- 🙅: Logical NOT
+
+<!-- Operators can be used directly after 👋 in variable assignments to perform operations on the variable. For example, `👋➕ x 1` will increment the variable `x` by 1. -->
+
+### Strings
+
+Strings are sequences of characters enclosed in 🔤 on each side. They can contain any characters, including emojis. Strings can be used in variable assignments, printed to the console, and concatenated using the ➕ operator.
+
+Values directly before or after a string will also be concatenated with that string.
+
+### Built-ins
+
+The language includes several built-in functions and values for common operations, such as:
+
+- 💬: Print output to a new line in the console
+- 💭: Print output to the console
+- ⌨️: Get user input from the console
+- ⏳: Wait for a specified number of seconds
+- 🔢: Convert input to a number, return ⚠️ if the conversion fails
+- 🎲: Get a random integer between 2 numbers
+- 🛑: Stop the program
+- ✅: A special value representing true
+- ❌: A special value representing false
+- 🫥: A special value representing null
+- ⚠️: A special value representing an error or undefined value
+- 🐍: Evaluate a Python expression
+
+## Credits
+
+Thanks to Robert Nystrom for his book "Crafting Interpreters" which inspired the design of this language and provided guidance on how to implement it.
+
+Also thanks to Hack Club for providing a supportive community and motivating me to work on this project.
+
+This documentation was entirely written by hand. AI tools were used for assistance while writing the interpreter.

spamoji-0.1.0/README.md

@@ -0,0 +1,151 @@
+# spamoji
+
+A programming language that only uses emojis as syntax and encourages writing spaghetti code.
+
+## Example
+
+```spamoji
+🗒️ A function to calculate factorial
+⚙️ 🔢❕🫸🔰🫷
+    👋 🏁 🫴 1
+    🔃 🔰 🤜 1
+        🏁 🫴 🏁 ✖️ 🔰
+        🔰 🫴 🔰 ➖ 1
+    ↩️ 🏁
+
+💭🫸🔤Enter a number to calculate the factorial: 🔤🫷
+👋 😀 🫴 🔢🫸⌨️❗🫷
+🤔 😀 🟰 ⚠️
+👍
+    💬🫸🔤Invalid input.🔤🫷
+👎
+    💬🫸🔤The factorial of 🔤😀🔤 is 🔤🫸🔢❕🫸😀🫷🫷🫷
+```
+
+## What's this all about?
+
+This language is a learning project. Since it lacks many features of a typical programming language, it is not recommended for production use. If this experiment is successful, I might move on and begin working on Esore, a more serious language I've been designing in the past 2 years.
+
+## Installation
+
+To install the spamoji interpreter, you will need to have Python 3.10 or higher installed on your machine. You can download Python from the [official website](https://www.python.org/downloads/).
+
+Once you have Python installed, you can install the spamoji interpreter using pip:
+
+```bash
+pip install spamoji
+```
+
+## Usage
+
+To run a spamoji program, you will need to use the spamoji interpreter.
+
+You can provide a spamoji file (with the .🍝 extension) as input to run it. For example:
+
+```bash
+spamoji my_program.🍝
+```
+
+If no file is supplied, the interactive REPL will start, which allows to enter and evaluate expressions directly.
+
+If the above command doesn't work, you can also run the interpreter using Python's -m flag:
+
+```bash
+python -m spamoji my_program.🍝
+```
+
+## Syntax
+
+> [!IMPORTANT]
+> The emojis used in the syntax were entered on a Windows machine. While they should work on other platforms, some emojis might not render correctly or might be replaced with different emojis. If you encounter any issues, please try copying and pasting the emojis from this documentation into your code.
+
+### Statements
+
+Each line of code starts with an emoji that indicates the type of statement. Each statement is followed by the relevant information, separated by spaces. Statements include:
+
+- 🗒️ Comment: Text in this line will be ignored
+- 👋 Variable declaration: Followed by the variable assignment
+- 🤔 If statement: Followed by the condition
+  - 👍 If true block
+  - 👎 Else block
+- 🔃 Loop: Followed by the loop variable and condition
+  - ⛔ Break statement: Used to exit the loop
+  - ⤴️ Continue statement: Used to skip to the next iteration of the loop
+- ⚙️ Function definition: Followed by the function name and parameters
+  - ↩️ Return statement: Followed by the value to return
+  <!-- - 🧩 Import statement: Followed by a file name, it gets replaced by the contents of that file before execution -->
+
+Some statements can be nested, such as if statements and loops. Indentation is used to indicate the scope of these statements. Indented blocks are considered part of the previous statement until the indentation level decreases. Variables declared inside of a block are only accessible inside of that block and any nested blocks.
+
+### Functions
+
+Functions are defined using the ⚙️ emoji, followed by the function name and parameters. The function body is indented and can contain any valid statements. The function can return a value using the ↩️ emoji.
+
+Functions can be called by using their name followed by the arguments, separated by 🔸, between 🫸 and 🫷. Functions with no arguments can also be called with the ❗ emoji.
+
+Here's an example of a function definition and call:
+
+```spamoji
+⚙️ greetAndAsk 🫸firstName 🔸 lastName🫷
+    💬🫸🔤Hello, 🔤firstName🔤 🔤lastName🔤! Please enter a number...🔤🫷
+    ↩️ ⌨️❗  🗒️ Return the user input
+
+greetAndAsk🫸🔤John🔤 🔸 🔤Doe🔤🫷
+```
+
+### Variables
+
+Variables are declared using the 👋 emoji, followed by the variable assignment expression. An assinment expression starts with the variable name, followed by 🫴 and a value. Variable names can be any combination of letters, numbers, and emojis, but must start with a letter or emoji. Variables can be used in expressions and statements after they have been assigned.
+
+### Expressions
+
+Many statements can be used as expressions within other statements. 🫸 and 🫷 can be used to group expressions and control the order of evaluation. For example, you can use a function call as part of an if statement condition or as part of a variable assignment.
+
+### Operators
+
+The language supports basic operators for logical and arithmetic operations. These can be used between two values to perform calculations.
+
+- ➕: Addition
+- ➖: Subtraction
+- ✖️: Multiplication
+- ➗: Division
+- 🟰: Equal
+- 🆚: Not equal
+- 🤜: Greater than
+- 🤛: Less than
+- 🤝: Logical AND
+- 🤲: Logical OR
+- 🙅: Logical NOT
+
+<!-- Operators can be used directly after 👋 in variable assignments to perform operations on the variable. For example, `👋➕ x 1` will increment the variable `x` by 1. -->
+
+### Strings
+
+Strings are sequences of characters enclosed in 🔤 on each side. They can contain any characters, including emojis. Strings can be used in variable assignments, printed to the console, and concatenated using the ➕ operator.
+
+Values directly before or after a string will also be concatenated with that string.
+
+### Built-ins
+
+The language includes several built-in functions and values for common operations, such as:
+
+- 💬: Print output to a new line in the console
+- 💭: Print output to the console
+- ⌨️: Get user input from the console
+- ⏳: Wait for a specified number of seconds
+- 🔢: Convert input to a number, return ⚠️ if the conversion fails
+- 🎲: Get a random integer between 2 numbers
+- 🛑: Stop the program
+- ✅: A special value representing true
+- ❌: A special value representing false
+- 🫥: A special value representing null
+- ⚠️: A special value representing an error or undefined value
+- 🐍: Evaluate a Python expression
+
+## Credits
+
+Thanks to Robert Nystrom for his book "Crafting Interpreters" which inspired the design of this language and provided guidance on how to implement it.
+
+Also thanks to Hack Club for providing a supportive community and motivating me to work on this project.
+
+This documentation was entirely written by hand. AI tools were used for assistance while writing the interpreter.

spamoji-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "spamoji"
+version = "0.1.0"
+description = "A programming language that only uses emojis as syntax."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{ name = "iqnite" }]
+dependencies = []
+
+[project.scripts]
+spamoji = "spamoji.spamoji:main"
+
+[tool.setuptools]
+packages = ["spamoji"]

spamoji-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

spamoji-0.1.0/spamoji/__init__.py

@@ -0,0 +1,5 @@
+"""
+Interface for the Spamoji interpreter.
+"""
+
+from spamoji.spamoji import Spamoji, main

spamoji-0.1.0/spamoji/environment.py

@@ -0,0 +1,34 @@
+"""
+Contains classes and functions for variable environments.
+"""
+
+from spamoji.helpers import SpamojiRuntimeError
+from spamoji.token import Token
+
+
+class Environment:
+    values: dict[str, object]
+    enclosing: "Environment | None"
+
+    def __init__(self, enclosing: "Environment | None" = None):
+        self.values = {}
+        self.enclosing = enclosing
+
+    def define(self, name: str, value: object):
+        self.values[name] = value
+
+    def assign(self, name: Token, value: object):
+        if name.lexeme in self.values:
+            self.values[name.lexeme] = value
+            return
+        if self.enclosing is not None:
+            self.enclosing.assign(name, value)
+            return
+        raise SpamojiRuntimeError(name, "Undefined variable '" + name.lexeme + "'.")
+
+    def get(self, name: Token) -> object:
+        if name.lexeme in self.values:
+            return self.values[name.lexeme]
+        if self.enclosing is not None:
+            return self.enclosing.get(name)
+        raise SpamojiRuntimeError(name, f"Undefined variable '{name.lexeme}'.")

spamoji-0.1.0/spamoji/expr.py

@@ -0,0 +1,134 @@
+"""
+This module contains the Expr class and its subclasses.
+Generated by generate_ast.py
+"""
+
+from abc import ABC
+from spamoji.token import Token
+
+
+class Expr(ABC):
+    """Base class for all exprs."""
+    def accept(self, visitor: "Visitor") -> object:
+        pass
+
+
+class Visitor(ABC):
+    def visit_assign_expr(self, expr: "Assign") -> object:
+        pass
+    def visit_binary_expr(self, expr: "Binary") -> object:
+        pass
+    def visit_call_expr(self, expr: "Call") -> object:
+        pass
+    def visit_logical_expr(self, expr: "Logical") -> object:
+        pass
+    def visit_if_expr(self, expr: "If") -> object:
+        pass
+    def visit_grouping_expr(self, expr: "Grouping") -> object:
+        pass
+    def visit_literal_expr(self, expr: "Literal") -> object:
+        pass
+    def visit_unary_expr(self, expr: "Unary") -> object:
+        pass
+    def visit_variable_expr(self, expr: "Variable") -> object:
+        pass
+
+
+class Assign(Expr):
+    """Represents a assign expression."""
+
+    def __init__(self, name: Token, value: Expr):
+        self.name = name
+        self.value = value
+
+    def accept(self, visitor: Visitor) -> object:
+        return visitor.visit_assign_expr(self)
+
+
+class Binary(Expr):
+    """Represents a binary expression."""
+
+    def __init__(self, left: Expr, operator: Token, right: Expr):
+        self.left = left
+        self.operator = operator
+        self.right = right
+
+    def accept(self, visitor: Visitor) -> object:
+        return visitor.visit_binary_expr(self)
+
+
+class Call(Expr):
+    """Represents a call expression."""
+
+    def __init__(self, callee: Expr, paren: Token, arguments: list[Expr]):
+        self.callee = callee
+        self.paren = paren
+        self.arguments = arguments
+
+    def accept(self, visitor: Visitor) -> object:
+        return visitor.visit_call_expr(self)
+
+
+class Logical(Expr):
+    """Represents a logical expression."""
+
+    def __init__(self, left: Expr, operator: Token, right: Expr):
+        self.left = left
+        self.operator = operator
+        self.right = right
+
+    def accept(self, visitor: Visitor) -> object:
+        return visitor.visit_logical_expr(self)
+
+
+class If(Expr):
+    """Represents a if expression."""
+
+    def __init__(self, condition: Expr, then_branch: Expr, else_branch: Expr):
+        self.condition = condition
+        self.then_branch = then_branch
+        self.else_branch = else_branch
+
+    def accept(self, visitor: Visitor) -> object:
+        return visitor.visit_if_expr(self)
+
+
+class Grouping(Expr):
+    """Represents a grouping expression."""
+
+    def __init__(self, expression: Expr):
+        self.expression = expression
+
+    def accept(self, visitor: Visitor) -> object:
+        return visitor.visit_grouping_expr(self)
+
+
+class Literal(Expr):
+    """Represents a literal expression."""
+
+    def __init__(self, value: object):
+        self.value = value
+
+    def accept(self, visitor: Visitor) -> object:
+        return visitor.visit_literal_expr(self)
+
+
+class Unary(Expr):
+    """Represents a unary expression."""
+
+    def __init__(self, operator: Token, right: Expr):
+        self.operator = operator
+        self.right = right
+
+    def accept(self, visitor: Visitor) -> object:
+        return visitor.visit_unary_expr(self)
+
+
+class Variable(Expr):
+    """Represents a variable expression."""
+
+    def __init__(self, name: Token):
+        self.name = name
+
+    def accept(self, visitor: Visitor) -> object:
+        return visitor.visit_variable_expr(self)

spamoji-0.1.0/spamoji/functions.py

@@ -0,0 +1,50 @@
+"""
+Contains classes for functions and callables.
+"""
+
+from typing import TYPE_CHECKING
+
+from spamoji import stmt
+from spamoji.environment import Environment
+
+if TYPE_CHECKING:
+    from spamoji.interpreter import Interpreter
+
+
+class SpamojiCallable:
+    def call(self, interpreter: "Interpreter", arguments: list[object]) -> object: ...
+    def arity(self) -> int: ...
+
+
+class SpamojiFunction(SpamojiCallable):
+    def __init__(self, declaration: stmt.Function):
+        self.declaration = declaration
+
+    def call(self, interpreter: "Interpreter", arguments: list[object]) -> object:
+        environment = Environment(interpreter.globals)
+        for i, arg in enumerate(self.declaration.arguments):
+            environment.define(arg.lexeme, arguments[i])
+        try:
+            interpreter.execute_block(self.declaration.body, environment)
+        except Return as return_value:
+            return return_value.value
+
+    def arity(self) -> int:
+        return len(self.declaration.arguments)
+
+    def __str__(self) -> str:
+        return f"<⚙️ {self.declaration.name.lexeme}>"
+
+
+class Return(RuntimeError):
+    def __init__(self, value: object, *_):
+        super().__init__()
+        self.value = value
+
+
+class BreakLoop(RuntimeError):
+    pass
+
+
+class ContinueLoop(RuntimeError):
+    pass

spamoji-0.1.0/spamoji/helpers.py

@@ -0,0 +1,61 @@
+"""
+Contains helper functions and classes for the Spamoji interpreter.
+"""
+
+import typing
+
+from spamoji.expr import Binary, Expr, Grouping, Literal, Unary, Visitor
+from spamoji.token import Token, TokenType
+
+
+def error_token(
+    token: Token,
+    message: str,
+    error_handler: typing.Callable[[int, str, str], typing.Any],
+):
+    """Reports an error with a given message and token."""
+    if token.token_type == TokenType.EOF:
+        error_handler(token.line, " at end", message)
+    else:
+        error_handler(token.line, f" at '{token.lexeme}'", message)
+
+
+class ASTPrinter(Visitor):
+    """Prints an AST in a human-readable format."""
+
+    def print(self, expr: Expr) -> str:
+        """Prints an AST in a human-readable format."""
+        return f"{expr.accept(self)}"
+
+    def visit_binary_expr(self, expr: Binary) -> str:
+        return self.parenthesize(expr.operator.lexeme, expr.left, expr.right)
+
+    def visit_grouping_expr(self, expr: Grouping) -> str:
+        return self.parenthesize("group", expr.expression)
+
+    def visit_literal_expr(self, expr: Literal) -> str:
+        if expr.value is None:
+            return "nil"
+        return str(expr.value)
+
+    def visit_unary_expr(self, expr: Unary) -> str:
+        return self.parenthesize(expr.operator.lexeme, expr.right)
+
+    def parenthesize(self, name: str, *exprs: Expr) -> str:
+        result = f"({name}"
+        for expr in exprs:
+            result += f" {expr.accept(self)}"
+        result += ")"
+        return result
+
+
+class SpamojiRuntimeError(RuntimeError):
+    def __init__(self, token: Token, message: str, *args: object):
+        super().__init__(message, *args)
+        self.token = token
+
+
+class SpamojiValueError: ...
+
+
+spamojiValueError = SpamojiValueError()