feat(src): delete `src` dir & rename `psi` dir

feat(frame): 添加`Lib` `Grammar` `Modules` 目录

11 files changed, 695 insertions, 0 deletions

diff --git a/psi/Grammar/Token b/psi/Grammar/Token
new file mode 100644
index 0000000..f73152f
--- /dev/null
+++ b/psi/Grammar/Token
@@ -0,0 +1,72 @@
+ENDMARKER
+NAME
+NUMBER
+STRING
+NEWLINE
+INDENT
+DEDENT
+
+LPAR                    '('
+RPAR                    ')'
+LSQB                    '['
+RSQB                    ']'
+COLON                   ':'
+COMMA                   ','
+SEMI                    ';'
+PLUS                    '+'
+MINUS                   '-'
+STAR                    '*'
+SLASH                   '/'
+VBAR                    '|'
+AMPER                   '&'
+LESS                    '<'
+GREATER                 '>'
+EQUAL                   '='
+DOT                     '.'
+PERCENT                 '%'
+LBRACE                  '{'
+RBRACE                  '}'
+EQEQUAL                 '=='
+NOTEQUAL                '!='
+LESSEQUAL               '<='
+GREATEREQUAL            '>='
+TILDE                   '~'
+CIRCUMFLEX              '^'
+LEFTSHIFT               '<<'
+RIGHTSHIFT              '>>'
+DOUBLESTAR              '**'
+PLUSEQUAL               '+='
+MINEQUAL                '-='
+STAREQUAL               '*='
+SLASHEQUAL              '/='
+PERCENTEQUAL            '%='
+AMPEREQUAL              '&='
+VBAREQUAL               '|='
+CIRCUMFLEXEQUAL         '^='
+LEFTSHIFTEQUAL          '<<='
+RIGHTSHIFTEQUAL         '>>='
+DOUBLESTAREQUAL         '**='
+DOUBLESLASH             '//'
+DOUBLESLASHEQUAL        '//='
+AT                      '@'
+ATEQUAL                 '@='
+RARROW                  '->'
+ELLIPSIS                '...'
+COLONEQUAL              ':='
+EXCLAMATION             '!'
+
+OP
+AWAIT
+ASYNC
+TYPE_IGNORE
+TYPE_COMMENT
+SOFT_KEYWORD
+FSTRING_START
+FSTRING_MIDDLE
+FSTRING_END
+COMMENT
+NL
+ERRORTOKEN
+
+# These aren't used by the C tokenizer but are needed for tokenize.py
+ENCODING
\ No newline at end of file
diff --git a/psi/Lib/IOStream/__init__.psi b/psi/Lib/IOStream/__init__.psi
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/psi/Lib/IOStream/__init__.psi
diff --git a/psi/Modules/asyncio/__init__.py b/psi/Modules/asyncio/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/psi/Modules/asyncio/__init__.py
diff --git a/psi/__init__.py b/psi/__init__.py
new file mode 100644
index 0000000..4bb4651
--- /dev/null
+++ b/psi/__init__.py
@@ -0,0 +1,73 @@
+"""Psi
+@TODO 词法分析器
+@BODY 似乎要写的还蛮多的，所以先写几个TODO List
+"""
+
+__all__ = ['psi']
+
+from psi.execution import Execution
+
+class Psi:
+    """
+    A class representing a Psi object.
+
+    Args:
+        input: The input value for the Psi object.
+
+    Returns:
+        None
+
+    Example:
+        ```python
+        obj = Psi("example")
+        ```
+    """
+
+    def __init__(self, input):
+        """
+        Initializes a Psi object.
+
+        Args:
+            input: The input value for the Psi object.
+
+        Returns:
+            None
+        """
+        self.input = input
+        self.execution = Execution(input)
+        self.result = None
+
+    def execute(self):
+        """
+        Executes the Psi object.
+
+        Returns:
+            The result of the execution.
+        """
+        self.result = self.execution.execute()
+        return self.result
+
+    def get_result(self):
+        """
+        Retrieves the result of the Psi object.
+
+        Returns:
+            The result of the execution.
+        """
+        return self.result
+
+    def set_input(self, input):
+        """
+        Sets the input value for the Psi object.
+
+        Args:
+            input: The new input value.
+
+        Returns:
+            None
+        """
+        self.input = input
+        self.execution = Execution(input)
+        self.result = None
+
+
diff --git a/psi/exception.py b/psi/exception.py
new file mode 100644
index 0000000..a8b7201
--- /dev/null
+++ b/psi/exception.py
@@ -0,0 +1,36 @@
+class PsiException(Exception):
+    """
+    An exception class for Psi-specific exceptions.
+
+    This class inherits from the built-in `Exception` class.
+
+    Example:
+        ```python
+        raise PsiException("An error occurred in the Psi code.")
+        ```
+    """
+
+    
+class ValueError(PsiException):
+    """
+    An exception class for value-related errors in Psi code.
+
+    This class inherits from the `PsiException` class.
+
+    Example:
+        ```python
+        raise ValueError("Invalid value encountered in the Psi code.")
+        ```
+    """
+
+class GrammarError(PsiException):
+    """
+    An exception class for grammar-related errors in Psi code.
+
+    This class inherits from the `PsiException` class.
+
+    Example:
+        ```python
+        raise GrammarError("Invalid grammar encountered in the Psi code.")
+        ```
+    """
diff --git a/psi/execution.py b/psi/execution.py
new file mode 100644
index 0000000..0abdf2c
--- /dev/null
+++ b/psi/execution.py
@@ -0,0 +1,46 @@
+from psi.parsers import Parser
+from psi.interpreter import Interpreter
+
+__all__ = ['Execution']
+
+class Execution:
+    """
+    A class representing the execution of Psi code.
+
+    Args:
+        input: The input code to be executed.
+
+    Returns:
+        None
+
+    Example:
+        ```python
+        execution = Execution("print('Hello, World!')")
+        execution.execute()
+        ```
+    """
+
+    def __init__(self, input):
+        """
+        Initializes an Execution object.
+
+        Args:
+            input: The input code to be executed.
+
+        Returns:
+            None
+        """
+        self.input = input
+
+    def execute(self):
+        """
+        Executes the input code.
+
+        Returns:
+            The result of the execution.
+        """
+        parser = Parser(self.input)
+        ast = parser.parse()
+
+        interpreter = Interpreter(ast)
+        return interpreter.interpret()
diff --git a/psi/interpreter.py b/psi/interpreter.py
new file mode 100644
index 0000000..8aa8fad
--- /dev/null
+++ b/psi/interpreter.py
@@ -0,0 +1,75 @@
+from psi.lexer import Token
+
+
+__all__ = ['Interpreter']
+
+class Interpreter:
+    """
+    A class representing an interpreter for Psi code.
+
+    Args:
+        ast: The abstract syntax tree (AST) of the code to be interpreted.
+
+    Returns:
+        None
+
+    Example:
+        ```python
+        interpreter = Interpreter(ast)
+        interpreter.interpret()
+        ```
+    """
+
+    def __init__(self, ast):
+        """
+        Initializes an Interpreter object.
+
+        Args:
+            ast: The abstract syntax tree (AST) of the code to be interpreted.
+
+        Returns:
+            None
+        """
+        self.ast = ast
+
+    def interpret(self):
+        """
+        Interprets the code represented by the AST.
+
+        Returns:
+            The result of the interpretation.
+        """
+        return self.interpret_expr(self.ast)
+
+    def interpret_expr(self, node):
+        """
+        Interprets an expression node in the AST.
+
+        Args:
+            node: The expression node to be interpreted.
+
+        Returns:
+            The result of the interpretation.
+        """
+        if isinstance(node, Token):
+            return node.value
+        elif isinstance(node, list):
+            for expr in node:
+                result = self.interpret_expr(expr)
+                if result is not None:
+                    return result
+
+    def interpret_condition(self, node):
+        """
+        Interprets a condition node in the AST.
+
+        Args:
+            node: The condition node to be interpreted.
+
+        Returns:
+            The result of the interpretation.
+        """
+        variable = self.interpret_expr(node[0])
+        value = self.interpret_expr(node[2])
+
+        return variable == value
diff --git a/psi/lexer.py b/psi/lexer.py
new file mode 100644
index 0000000..d2c6f68
--- /dev/null
+++ b/psi/lexer.py
@@ -0,0 +1,249 @@
+"""
+Token and Lexer Documentation
+=============================
+
+This module provides the `Token` and `Lexer` classes for tokenizing input strings.
+
+Token Class
+-----------
+
+The `Token` class represents a token with a type, value, and position in the input string. It is a subclass of the built-in `dict` class.
+
+Attributes:
+- `type` (str): The type of the token.
+- `value` (str or int): The value of the token.
+- `position` (int): The position of the token in the input string.
+
+Methods:
+- `__getattr__(self, name)`: Retrieves the value of an attribute by name. Raises an `AttributeError` if the attribute does not exist.
+
+Lexer Class
+-----------
+
+The `Lexer` class tokenizes an input string using a set of rules.
+
+Attributes:
+- `input` (str): The input string to tokenize.
+- `position` (int): The current position in the input string.
+- `tokens` (list): The list of tokens generated by the lexer.
+
+Methods:
+- `get_next_token(self)`: Retrieves the next token from the input string.
+- `__iter__(self)`: Returns an iterator over the tokens.
+- `__getitem__(self, index)`: Retrieves a token by index.
+- `__len__(self)`: Returns the number of tokens.
+
+Usage Example
+-------------
+
+```python
+lexer = Lexer('''
+@newMessage: {
+    ? message == 1: reply: hi
+    ! reply: no
+}
+''')
+
+token = lexer.get_next_token()
+while token['type'] != 'EOF':
+    print(f'Type: {token["type"]}, Value: {token["value"]}, Position: {token["position"]}')
+    token = lexer.get_next_token()
+
+print("\nAll tokens:")
+print([t['type'] for t in lexer])
+"""
+
+__all__ = ['Token', 'Lexer']
+
+class Token(dict):
+    """
+    A class representing a token in the lexer.
+
+    Args:
+        type: The type of the token.
+        value: The value of the token.
+        position: The position of the token.
+
+    Returns:
+        None
+
+    Example:
+        ```python
+        token = Token("identifier", "x", (1, 5))
+        ```
+    """
+
+    def __init__(self, type, value, position):
+        """
+        Initializes a Token object.
+
+        Args:
+            type: The type of the token.
+            value: The value of the token.
+            position: The position of the token.
+
+        Returns:
+            None
+        """
+        super().__init__(type=type, value=value, position=position)
+
+    def __getattr__(self, name):
+        """
+        Retrieves the value of an attribute from the Token object.
+
+        Args:
+            name: The name of the attribute.
+
+        Returns:
+            The value of the attribute.
+
+        Raises:
+            AttributeError: Raised when the attribute does not exist.
+        """
+        try:
+            return self[name]
+        except KeyError:
+            raise AttributeError(f"'Token' object has no attribute '{name}'")
+
+
+class Lexer:
+    """
+    A class representing a lexer for Psi code.
+
+    Args:
+        input: The input code to be lexed.
+
+    Returns:
+        None
+
+    Example:
+        ```python
+        lexer = Lexer("x = 10")
+        for token in lexer:
+            print(token)
+        ```
+    """
+    def __init__(self, input):
+        """
+        Initializes a Lexer object.
+
+        Args:
+            input: The input code to be lexed.
+
+        Returns:
+            None
+        """
+        self.input = input
+        self.position = 0
+        self.tokens = []
+
+    def get_next_token(self):
+        """
+        Retrieves the next token from the input code.
+
+        Returns:
+            The next token.
+
+        Raises:
+            Exception: Raised when an unknown character is encountered.
+        """
+        while self.position < len(self.input):
+            current_char = self.input[self.position]
+
+            if current_char.isspace():
+                self.position += 1
+                continue
+
+            if current_char == '#':
+                self.position += 1
+                while (self.position < len(self.input) and
+                       self.input[self.position] != '\n'):
+                    self.position += 1
+                continue
+
+            if current_char == '/' and self.position + 1 < len(self.input) and self.input[self.position + 1] == '*':
+                self.position += 2
+                while (self.position < len(self.input) - 1 and
+                       (self.input[self.position] != '*' or self.input[self.position + 1] != '/')):
+                    self.position += 1
+                if self.position < len(self.input) - 1:
+                    self.position += 2
+                continue
+
+            if current_char.isalpha():
+                start_position = self.position
+                while (self.position < len(self.input) and
+                       self.input[self.position].isalnum()):
+                    self.position += 1
+                token = Token('IDENTIFIER', self.input[start_position:self.position], start_position)
+                self.tokens.append(token)
+                return token
+
+            if current_char.isdigit():
+                start_position = self.position
+                while (self.position < len(self.input) and
+                       self.input[self.position].isdigit()):
+                    self.position += 1
+                token = Token('INTEGER', int(self.input[start_position:self.position]), start_position)
+                self.tokens.append(token)
+                return token
+
+            if current_char in {'<', '>', '=', '!', '&', '|', '@'}:
+                if (self.position + 1 < len(self.input) and
+                    self.input[self.position + 1] in {'=', '&', '|'}):
+                    token = Token('OPERATOR', current_char + self.input[self.position + 1], self.position)
+                    self.position += 2
+                else:
+                    token = Token('OPERATOR', current_char, self.position)
+                    self.position += 1
+                self.tokens.append(token)
+                return token
+
+            if current_char in {'{', '}', '(', ')', '[', ']', ';', ',', '.', ':'}:
+                token = Token('SEPARATOR', current_char, self.position)
+                self.position += 1
+                self.tokens.append(token)
+                return token
+
+            if current_char in {'?', '!', '|'}:
+                token = Token('CONTROL', current_char, self.position)
+                self.position += 1
+                self.tokens.append(token)
+                return token
+
+            self.position += 1
+            raise Exception(f'Unknown character: {current_char}')
+
+        token = Token('EOF', None, self.position)
+        self.tokens.append(token)
+        return token
+
+    def __iter__(self):
+        """
+        Returns an iterator over the tokens.
+
+        Returns:
+            An iterator over the tokens.
+        """
+        return iter(self.tokens)
+
+    def __getitem__(self, index):
+        """
+        Retrieves the token at the specified index.
+
+        Args:
+            index: The index of the token.
+
+        Returns:
+            The token at the specified index.
+        """
+        return self.tokens[index]
+
+    def __len__(self):
+        """
+        Returns the number of tokens.
+
+        Returns:
+            The number of tokens.
+        """
+        return len(self.tokens)
\ No newline at end of file
diff --git a/psi/mathmatics.py b/psi/mathmatics.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/psi/mathmatics.py
diff --git a/psi/parsers.py b/psi/parsers.py
new file mode 100644
index 0000000..f68f95f
--- /dev/null
+++ b/psi/parsers.py
@@ -0,0 +1,144 @@
+from psi.lexer import Lexer, Token
+
+
+__all__ = ['Parser']
+
+class Parser:
+    """
+    A class representing a parser for Psi code.
+
+    Args:
+        input: The input code to be parsed.
+
+    Returns:
+        None
+
+    Example:
+        ```python
+        parser = Parser(input)
+        parser.parse()
+        ```
+    """
+
+    def __init__(self, input):
+        """
+        Initializes a Parser object.
+
+        Args:
+            input: The input code to be parsed.
+
+        Returns:
+            None
+        """
+        self.lexer = Lexer(input)
+        self.tokens = iter(self.lexer)
+        self.current_token = next(self.tokens)
+
+    def parse(self):
+        """
+        Parses the input code.
+
+        Returns:
+            The result of the parsing.
+        """
+        return self.parse_expr()
+
+    def parse_expr(self):
+        """
+        Parses an expression in the input code.
+
+        Returns:
+            The result of the parsing.
+        """
+        token = self.current_token
+        if token.value == '?':
+            self.eat('?')
+
+            condition = self.parse_condition()
+
+            self.eat(':')
+
+            if condition:
+                result = self.parse_reply()
+            else:
+                result = None
+
+            return result
+
+    def parse_condition(self):
+        """
+        Parses a condition in the input code.
+
+        Returns:
+            The result of the parsing.
+        """
+        variable = self.parse_variable()
+        self.eat('==')
+        value = self.parse_value()
+
+        return variable == value
+
+    def parse_variable(self):
+        """
+        Parses a variable in the input code.
+
+        Returns:
+            The result of the parsing.
+        """
+        token = self.current_token
+        self.eat('IDENTIFIER')
+        return token.value
+
+    def parse_value(self):
+        """
+        Parses a value in the input code.
+
+        Returns:
+            The result of the parsing.
+
+        Raises:
+            Exception: Raised when an invalid value is encountered.
+        """
+        token = self.current_token
+        if token.type == 'INTEGER':
+            self.eat('INTEGER')
+            return token.value
+        else:
+            raise Exception(f'Invalid value: {token.value}')
+
+    def parse_reply(self):
+        """
+        Parses a reply in the input code.
+
+        Returns:
+            The result of the parsing.
+
+        Raises:
+            Exception: Raised when an invalid reply is encountered.
+        """
+        self.eat('reply')
+        self.eat(':')
+
+        token = self.current_token
+        if token.type != 'SEPARATOR':
+            raise Exception(f'Invalid reply: {token.value}')
+
+        return token.value
+
+    def eat(self, expected_type):
+        """
+        Consumes the current token if it matches the expected type.
+
+        Args:
+            expected_type: The expected type of the token.
+
+        Returns:
+            None
+
+        Raises:
+            Exception: Raised when an unexpected token is encountered.
+        """
+        if self.current_token.type == expected_type:
+            self.current_token = next(self.tokens)
+        else:
+            raise Exception(f'Unexpected token: {self.current_token.value}')
diff --git a/psi/type.py b/psi/type.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/psi/type.py