hexus-lang 0.1.0b1__tar.gz

hexus_lang-0.1.0b1/Hexus/cli.py

@@ -0,0 +1,57 @@
+import sys
+import os
+from Hexus.lexer import tokenizer_tokens
+from Hexus.parser import HexusParser
+from Hexus.interpreter import HexusInterpreter
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Hexus Programming Language")
+        print("Use: hexus <file.he>")
+        sys.exit(1)
+
+    file_name = sys.argv[1]
+
+    if file_name in ["--help", "-h"]:
+        print("Hexus Programming Language CLI")
+        print("Use: hexus <file.he>")
+        sys.exit(0)
+
+    if not os.path.exists(file_name):
+        print(f"Error: File '{file_name}' does not exist!")
+        sys.exit(1)
+
+    try:
+        with open(file_name, "r", encoding="utf-8") as file:
+            source_code = file.read()
+    except Exception as e:
+        print(f"Error while openning file: {e}")
+        sys.exit(1)
+
+    try:
+        token_list = tokenizer_tokens(source_code)
+        clear_tokens = [t for t in token_list if t[0] != "SKIP"]
+
+        parser = HexusParser(clear_tokens)
+        program_tree = parser.parse()
+
+        interpreter = HexusInterpreter()
+        interpreter.interpret(program_tree)
+
+    except SyntaxError as e:
+        print(f"\n{e}")
+        sys.exit(1)
+    except NameError as e:
+        print(f"\n\n{e}")
+        sys.exit(1)
+    except KeyboardInterrupt:
+        print("\nThe program's operation was interrupted (Ctrl+C).")
+        sys.exit(0)
+    except Exception as e:
+        print(f"\nUnexpected error:\n{e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

hexus_lang-0.1.0b1/Hexus/interpreter.py

@@ -0,0 +1,515 @@
+from Hexus.parser import FunctionDefNode
+from typing import Any, Callable
+import importlib
+import pkgutil
+from Hexus import modules
+
+
+class BreakException(Exception):
+    pass
+
+class ContinueException(Exception):
+    pass
+
+class ReturnException(Exception):
+    def __init__(self, value):
+        self.value = value
+
+class Environment:
+    def __init__(self, parent=None):
+        self.vars = {}
+        self.parent = parent
+
+    def get(self, name):
+        if name in self.vars:
+            return self.vars[name]
+        if self.parent:
+            return self.parent.get(name)
+        raise NameError(f"Variable '{name}' is not defined!!!")
+
+    def set(self, name, value):
+        self.vars[name] = value
+
+    def __contains__(self, name):
+        try:
+            self.get(name)
+            return True
+        except NameError:
+            return False
+
+
+
+class HexusInterpreter:
+    def __init__(self):
+        self.env = Environment()
+        self._register_type1_modules()
+        self.timer = 0
+        self.timer2 = 0
+        self.timerset = False
+
+    def _register_type1_modules(self):
+        for _, mod_name, _ in pkgutil.iter_modules(modules.__path__):
+            if mod_name.endswith("_ext"):
+                continue
+
+            py_mod = importlib.import_module(f".modules.{mod_name}", package=__package__)
+            for attr_name in dir(py_mod):
+                attr = getattr(py_mod, attr_name)
+                if attr_name.endswith("Interpreter") and hasattr(attr, "register_handlers"):
+                    attr.register_handlers(self)
+
+    def visit(self, node) -> Any:
+        method_name = f"visit_{type(node).__name__}"
+        visitor: Callable[[Any], Any] = getattr(self, method_name, self.generic_visit)
+        return visitor(node)
+
+    def generic_visit(self, node, *args, **kwargs):
+        _ = args, kwargs, self
+        raise Exception(f"Interpreter error: No visit method defined for {type(node).__name__}")
+
+    def visit_NumberNode(self, node):
+        _ = self
+        value = str(node.value)
+        if "." in value:
+            return float(value)
+        return int(value)
+
+
+    def visit_StringNode(self, node):
+        if isinstance(node.value, str):
+            words_list = node.value.split()
+        else:
+            words_list = node.value
+
+
+        if len(words_list) == 1:
+            text = words_list[0][1:-1]
+            if text.startswith("{") and text.endswith("}"):
+                var_name = text[1:-1]
+                if var_name in self.env:
+                    return str(self.env.get(var_name))
+            return text
+        first = words_list[0][1:]
+        middle = words_list[1:-1]
+        last = words_list[-1][:-1]
+        newtxt = [first] + middle + [last]
+        for i, t in enumerate(newtxt):
+            if t.startswith("{") and t.endswith("}"):
+                t = t[1:-1]
+                if t in self.env:
+                    txt = self.env.get(t)
+                    newtxt[i] = str(txt)
+
+        full_txt = " ".join(newtxt)
+        return full_txt
+
+    def visit_VariableNode(self, node):
+        if node.name in self.env:
+            return self.env.get(node.name)
+        raise NameError(f"Variable '{node.name}' is not defined!!!")
+
+    def visit_NowNode(self, node):
+        _ = node, self
+        import time
+        now = time.strftime("%Y-%m-%d %H:%M:%S")
+        return now
+
+    def visit_BoolNode(self, node):
+        _ = self
+        return bool(node.value)
+
+
+    def visit_BinaryOpNode(self, node):
+        left_val = self.visit(node.left)
+        right_val = self.visit(node.right)
+
+        if node.op == "+": return left_val + right_val
+        if node.op == "-": return left_val - right_val
+        if node.op == "*": return left_val * right_val
+        if node.op == "/": return left_val / right_val
+        if node.op == "==": return left_val == right_val
+        if node.op == "!=": return left_val != right_val
+        if node.op == "and": return bool(left_val) and bool(right_val)
+        if node.op == "or": return bool(left_val) or bool(right_val)
+        if node.op == ">": return left_val > right_val
+        if node.op == "<": return left_val < right_val
+        if node.op == "<=": return left_val <= right_val
+        if node.op == ">=": return left_val >= right_val
+        if node.op == "%": return left_val % right_val
+        raise ValueError(f"Unknown binary operator: {node.op}")
+
+    def visit_SendCommandNode(self, node):
+        result = self.visit(node.text_value)
+        if node.target == "console":
+            print(result)
+
+    def visit_SetVar(self, node):
+        var = node.var_name.strip()
+        if node.list is True:
+            if node.value is None:
+                self.env.set(var, [])
+                return
+            elif node.value:
+                list_val = []
+                for v in node.value:
+                    result = self.visit(v)
+                    list_val.append(result)
+                self.env.set(var, list_val)
+                return
+        value = self.visit(node.value)
+        self.env.set(var, value)
+
+    def visit_ReadCommandNode(self, node):
+        value = self.visit(node.text_value)
+        var = node.var_name.strip()
+        v = None
+        if node.target == "console":
+            v = input(value)
+
+            if v.isdigit():
+                v = int(v)
+            else:
+                try:
+                    v = float(v)
+                except ValueError:
+                    pass
+
+        self.env.set(var, v)
+
+    def visit_ComNode(self, node):
+        pass
+
+    def visit_IfNode(self, node):
+        exp = self.visit(node.exp)
+        if exp:
+            for val in node.value:
+                self.visit(val)
+            return
+        elifv = node.elifv
+        if elifv:
+            for e_exp, e_value in elifv.items():
+                if bool(self.visit(e_exp)):
+                    for val in e_value:
+                        self.visit(val)
+                    return
+
+        if node.value2:
+            for val in node.value2:
+                self.visit(val)
+
+
+    def visit_ListAddNode(self, node):
+        var_name = node.var.name
+        current_value = self.env.get(var_name)
+        value = self.visit(node.value)
+        if isinstance(current_value, list):
+            if not node.pos:
+                pos = len(current_value) + 1
+            else:
+                pos = self.visit(node.pos)
+            pos -= 1
+            current_value.insert(pos, value)
+            self.env.set(var_name, current_value)
+        else:
+            raise NameError(f"Interpreter Error: Variable '{var_name}' (value: {current_value}) is not a list")
+
+    def visit_ListRemoveNode(self, node):
+        value = None
+        var_name = node.var.name
+        current_value = self.env.get(var_name)
+        if node.value:
+            value = self.visit(node.value)
+        if isinstance(current_value, list):
+            if node.pos:
+                pos = self.visit(node.pos)
+                pos -= 1
+                current_value.pop(pos)
+                self.env.set(var_name, current_value)
+            elif value:
+                current_value.remove(value)
+                self.env.set(var_name, current_value)
+        else:
+            raise NameError(f"Interpreter Error: Variable '{var_name}' (value: {current_value}) is not a list")
+
+
+    def visit_WaitNode(self, node):
+        import time
+
+        value = self.visit(node.value)
+
+        if hasattr(node.value2, "name"):
+            value2 = node.value2.name
+        else:
+            value2 = self.visit(node.value2)
+
+        if value2 == "s":
+            time.sleep(value)
+        elif value2 == "m":
+            time.sleep(value * 60)
+        elif value2 == "h":
+            time.sleep(value * 60 * 60)
+        elif value2 == "d":
+            time.sleep(value * 60 * 60 * 24)
+        else:
+            raise ValueError(f"Unknown wait unit: {value2}")
+
+
+    def visit_WhileNode(self, node):
+        while bool(self.visit(node.exp)):
+            try:
+                for val in node.value:
+                    try:
+                        self.visit(val)
+                    except ContinueException:
+                        break
+            except BreakException:
+                break
+
+
+    def visit_RepeatNode(self, node):
+        value = self.visit(node.value)
+        value2 = node.value2
+        time = 1
+        while time <= value:
+            try:
+                for val in value2:
+                    try:
+                        self.visit(val)
+                    except ContinueException:
+                        break
+                time += 1
+            except BreakException:
+                break
+
+    def visit_ClearNode(self, node):
+        _ = node, self
+        import subprocess
+        import os
+        subprocess.run('cls' if os.name == 'nt' else 'clear', shell=True)
+
+
+    def visit_StopNode(self, node):
+        if node.value is None:
+            value = None
+        else:
+            value = self.visit(node.value)
+        import sys
+        if value is None:
+            sys.exit("Program stop")
+        else:
+            sys.exit(value)
+
+
+    def visit_MakeNode(self, node):
+        var = node.var.strip()
+        value = node.value
+        current_str = self.env.get(var)
+        if value == "lower":
+            self.env.set(var, current_str.lower())
+        elif value == "upper":
+            self.env.set(var, current_str.upper())
+
+
+    def visit_MinusNode(self, node):
+        return -self.visit(node.value)
+
+
+    def visit_PlusNode(self, node):
+        return +self.visit(node.value)
+
+
+    def visit_NotNode(self, node):
+        value = self.visit(node.value)
+        return not value
+
+
+    def visit_LengthNode(self, node):
+        var = self.visit(node.var)
+        return len(var)
+
+    def visit_TimeNode(self, node):
+        _ = self
+        import time
+        value = node.value
+        if value == "hour":
+            return time.strftime("%H")
+        elif value == "minute":
+            return time.strftime("%M")
+        elif value == "second":
+            return time.strftime("%S")
+        else:
+            raise NameError(f"Don't know {value}")
+
+
+    def visit_BreakNode(self, node):
+        raise BreakException
+
+
+    def visit_ContinueNode(self, node):
+        raise ContinueException
+
+
+    def visit_FunctionDefNode(self, node):
+        self.env.set(node.name, node)
+
+
+    def visit_ReturnNode(self, node):
+        value = None
+        if node.value is not None:
+            value = self.visit(node.value)
+        raise ReturnException(value)
+
+
+    def visit_FunctionCallNode(self, node):
+        func_node = self.env.get(node.name)
+        if not isinstance(func_node, FunctionDefNode):
+            raise TypeError(f"'{node.name}' is not a function")
+        if len(node.args) != len(func_node.para):
+            raise TypeError(f"Function '{node.name}' expects {len(func_node.para)} arguments, but got {len(node.args)}")
+        arg_values = [self.visit(arg) for arg in node.args]
+        previous_env = self.env
+        local_env = Environment(parent=previous_env)
+        for para_name, val in zip (func_node.para, arg_values):
+            local_env.set(para_name, val)
+        self.env = local_env
+        return_value = None
+        try:
+            for stmt in func_node.body:
+                self.visit(stmt)
+        except ReturnException as ret:
+            return_value = ret.value
+        finally:
+            self.env = previous_env
+
+        return return_value
+
+
+    def visit_StartTimerNode(self, node):
+        _ = node
+        import time
+        self.timer = time.time()
+        self.timerset = False
+
+
+    def visit_StopTimerNode(self, node):
+        _ = node
+        import time
+        now = time.time()
+        self.timer2 = round(now - self.timer)
+        self.timerset = True
+
+    def visit_TimerNode(self, node):
+        _ = node
+        if not self.timerset:
+            import time
+            now = time.time()
+            self.timer2 = round(now - self.timer)
+            return self.timer2
+        else:
+            return self.timer2
+
+
+
+    def visit_IndexNode(self, node):
+        target = self.visit(node.target)
+        pos = self.visit(node.pos)
+        try:
+            return target[pos - 1]
+        except Exception:
+            raise TypeError(f"{target} is not a list")
+
+
+    def visit_RandomNode(self, node):
+        value1 = self.visit(node.value1)
+        value2 = self.visit(node.value2)
+        import random
+        return random.randrange(value1, value2)
+
+
+
+    def visit_ForNode(self, node):
+        if hasattr(node.value, "name"):
+            var_name = node.value.name
+        else:
+            raise TypeError("???")
+        list_value = self.visit(node.list_value)
+        had_var = var_name in self.env.vars
+        old_value = self.env.vars.get(var_name)
+        try:
+            for item in list(list_value):
+                self.env.set(var_name, item)
+                try:
+                    for stmt in node.value2:
+                        try:
+                            self.visit(stmt)
+                        except ContinueException:
+                            break
+                except BreakException:
+                    break
+        finally:
+            if had_var:
+                self.env.vars[var_name] = old_value
+            else:
+                self.env.vars.pop(var_name, None)
+
+
+
+    def visit_VarPlusNode(self, node):
+        value = node.value
+        var = node.var.strip()
+        old_value = self.env.vars[var]
+        value = old_value + int(value)
+        self.env.vars[var] = value
+
+
+
+
+    def visit_VarMinusNode(self, node):
+        value = node.value
+        var = node.var.strip()
+        old_value = self.env.vars[var]
+        value = old_value - int(value)
+        self.env.vars[var] = value
+
+
+
+    def visit_NumberForNode(self, node):
+        if hasattr(node.var, "name"):
+            var_name = node.var.name
+        else:
+            raise TypeError("???")
+        start_value = self.visit(node.value)
+        end_value = self.visit(node.value2)
+        had_var = var_name in self.env.vars
+        old_value = self.env.vars.get(var_name)
+        try:
+            for item in range(start_value, end_value):
+                self.env.set(var_name, item)
+
+                try:
+                    for stmt in node.block:
+                        try:
+                            self.visit(stmt)
+                        except ContinueException:
+                            break
+                except BreakException:
+                    break
+        finally:
+            if had_var:
+                self.env.vars[var_name] = old_value
+            else:
+                self.env.vars.pop(var_name, None)
+
+
+
+
+
+
+
+
+
+
+
+    def interpret(self, nodes):
+        for node in nodes:
+            self.visit(node)

hexus_lang-0.1.0b1/Hexus/lexer.py

@@ -0,0 +1,42 @@
+import re
+
+token_pattern = [
+        ("HASH", r"#"),
+        ("INT", r"\d+"),
+        ("BOOL", r"\b(True|False)\b"),
+        ("DASHS", r"\/\/"),
+        ("OP", r">=|<=|==|!=|%|[+\-=*/><]"),
+        ("STRING", r'"[^"\\]*(?:\\.[^"\\]*)*"'),
+        ("VAR", r'[a-zA-Z_][a-zA-Z0-9_]*'),
+        ("LBRACE", r'\{'),
+        ("RBRACE", r'\}'),
+        ("LSBRACE", r"\["),
+        ("RSBRACE", r"\]"),
+        ("SKIP", r'[ \t]+'),
+        ("NEWLINE", r'\n'),
+        ("COMMA", r"\,"),
+        ("DOT", r"\."),
+        ("LPAREN", r"\("),
+        ("RPAREN", r"\)")
+    ]
+
+def tokenizer(text, definition):
+    patter = []
+    for name, regex in definition:
+        patter.append(f"(?P<{name}>{regex})")
+
+    full_regex = "|".join(patter)
+
+    tokens = []
+
+    for match in re.finditer(full_regex, text):
+        kind = match.lastgroup
+        value = match.group()
+
+        tokens.append((kind, value))
+
+    return tokens
+
+def tokenizer_tokens(text):
+    tokens = tokenizer(text, token_pattern)
+    return tokens

hexus_lang-0.1.0b1/Hexus/main.py

@@ -0,0 +1,34 @@
+from Hexus.interpreter import HexusInterpreter
+from Hexus.parser import HexusParser
+from Hexus.lexer import tokenizer_tokens
+
+def main():
+    file_name = "test.he"
+    try:
+        with open(file_name, "r", encoding="utf-8") as file:
+            source_code = file.read()
+
+    except FileNotFoundError:
+        print(f"File {file_name} not found!!!")
+        return
+    token_list = tokenizer_tokens(source_code)
+
+    clear_tokens = [t for t in token_list if t[0] != "SKIP"]
+    try:
+        for token in clear_tokens:
+            print(token)
+        parser = HexusParser(clear_tokens)
+
+        program_tree = parser.parse()
+
+        print(program_tree)
+
+        interpreter = HexusInterpreter()
+
+        interpreter.interpret(program_tree)
+
+    except SyntaxError as e:
+        print(e)
+
+if __name__ == "__main__":
+    main()