aergia-lang 1.6.0__tar.gz

aergia_lang-1.6.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nayif Ehan
+
+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.

aergia_lang-1.6.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: aergia-lang
+Version: 1.6.0
+Summary: The Aergia programming language
+Author: las-r
+Requires-Python: >=3.7
+License-File: LICENSE
+Dynamic: license-file

aergia_lang-1.6.0/README.md

@@ -0,0 +1,34 @@
+# Aergia
+**Aergia** is a minimalist yet still usable programming language, depending on your definition of usable.
+
+## Installation
+### Global Installation (pip)
+```bash
+pip install git+https://github.com/las-r/aergia.git
+```
+
+### Local Installation (in a directory)
+Copy the contents of `/aergia` to your working directory.
+
+## Usage
+```bash
+aergia <filename.aer>
+```
+Alternatively (for local installations):
+```bash
+python -m aergia <filename.aer>
+```
+
+## Updating
+### ≥v1.5.0
+```
+aergia --ghupdate
+```
+
+### <v1.5.0
+```
+pip install --upgrade git+https://github.com/las-r/aergia.git
+```
+
+## Documentation
+Documentation can be found [here](https://las-r.github.io/aergia/).

aergia_lang-1.6.0/aergia/__main__.py

@@ -0,0 +1,80 @@
+import argparse
+import subprocess
+import sys
+from .lexer import tokenize
+from .parser import parse, ExitException
+
+# aergia main
+# made by las-r on github
+
+def main():
+    # constants
+    VER = "Aergia v1.6.0"
+    REPO = "git+https://github.com/las-r/aergia.git"
+    
+    # arguments
+    aparser = argparse.ArgumentParser(
+        prog="aergia",
+        description="Aergia Language Interpreter"
+    )
+    aparser.add_argument("filename", nargs="?", help="the .aer file to execute")
+    aparser.add_argument("--version", action="version", version=VER)
+    aparser.add_argument("-d", "--debug", action="store_true", help="print tokens and abstract syntax tree")
+    aparser.add_argument("-gu", "--ghupdate", action="store_true", help="update aergia to the latest version from github")
+    args = aparser.parse_args()
+    
+    # handle update
+    if args.ghupdate:
+        print("Checking for updates...")
+        try:
+            subprocess.check_call([sys.executable, "-m", "pip", "install", "--upgrade", REPO])
+            sys.exit(0)
+        except subprocess.CalledProcessError as e:
+            print(f"Update failed: {e}")
+            sys.exit(1)
+
+    # global environment
+    env = {}
+    
+    try:
+        # run file
+        if args.filename:
+            # read file
+            with open(args.filename, "r") as f:
+                code = f.read()
+            
+            # create tokens and tree
+            tokens = tokenize(code)
+            ast = parse(tokens)
+            
+            # debug
+            if args.debug:
+                print(f"DEBUG - Tokens: {tokens}")
+                print(f"DEBUG - AST: {ast}")
+            
+            # interpret
+            for node in ast:
+                if node:
+                    node.eval(env)
+        
+        # run repl
+        else:
+            print(f"{VER} REPL")
+            while True:
+                line = input(";> ")
+                tokens = tokenize(line)
+                ast = parse(tokens)
+                for node in ast:
+                    if node:
+                        print(node.eval(env))
+         
+    except ExitException as e:
+        sys.exit(e.value)       
+    except FileNotFoundError:
+        print(f"Aergia Error: File '{args.filename}' not found")
+    except Exception as e:
+        print(f"Aergia Error: {e}")
+        
+
+if __name__ == "__main__":
+    main()

aergia_lang-1.6.0/aergia/lexer.py

@@ -0,0 +1,20 @@
+import re
+
+# aergia lexer
+# made by las-r on github
+
+# constants
+TOKENPATTERN = r'"(?:[^"\\]|\\.)*"|==|<<|>>|<=|>=|\+>|\*>|\*<|~>|[\(\)\[\]\{\}\+\-\*\/%\^=;\&\|!\~<>:@\?,.\'`]|\b[\w.]+\b'
+
+# preprocessor
+def preprocess(code):
+    lines = code.splitlines()
+    cleaned = []
+    for line in lines:
+        cleaned.append(line.split("#")[0])
+    return " ".join(cleaned)
+
+# tokenizer
+def tokenize(code):
+    tokens = re.findall(TOKENPATTERN, preprocess(code))
+    return tokens

aergia_lang-1.6.0/aergia/nodes.py

@@ -0,0 +1,295 @@
+import importlib
+import operator
+from .lexer import tokenize
+
+# aergia nodes
+# made by las-r on github
+
+# constants
+OPS = {
+        "+": lambda l, r: str(l) + str(r) if isinstance(l, str) or isinstance(r, str) else l + r,
+        "-": operator.sub, 
+        "*": operator.mul,
+        "/": operator.truediv, 
+        "^": operator.pow, 
+        "%": operator.mod,
+        "|": operator.or_,
+        "&": operator.and_,
+        "$": operator.xor,
+        "==": lambda l, r: 1 if l == r else 0,
+        "!=": lambda l, r: 1 if l != r else 0,
+        "<<": lambda l, r: 1 if l < r else 0,
+        ">>": lambda l, r: 1 if l > r else 0,
+        "<=": lambda l, r: 1 if l <= r else 0,
+        ">=": lambda l, r: 1 if l >= r else 0,
+    }
+
+# exceptions
+class ReturnException(Exception):
+    def __init__(self, value):
+        self.value = value
+        
+class ExitException(Exception):
+    def __init__(self, value):
+        self.value = value
+
+# value nodes
+class LiteralNode:
+    def __init__(self, value):
+        self.value = value
+    
+    def eval(self, env):
+        return self.value
+
+class VariableNode:
+    def __init__(self, name):
+        self.name = name
+    
+    def eval(self, env):
+        if self.name not in env:
+            raise NameError(f"No variable '{self.name}' found")
+        return env[self.name]
+
+# assignment
+class AssignNode:
+    def __init__(self, name, child):
+        self.name = name
+        self.child = child
+    
+    def eval(self, env):
+        value = self.child.eval(env)
+        env[self.name] = value
+        return value
+    
+# output
+class OutputNode:
+    def __init__(self, child):
+        self.child = child
+    
+    def eval(self, env):
+        print(self.child.eval(env))
+        return 0
+
+# input
+class StringInputNode:
+    def __init__(self):
+        pass
+    
+    def eval(self, env):
+        return input()
+
+class IntInputNode:
+    def __init__(self):
+        pass
+    
+    def eval(self, env):
+        return int(input())
+
+class FloatInputNode:
+    def __init__(self):
+        pass
+    
+    def eval(self, env):
+        return float(input())
+
+# operation nodes
+class UnaryOpNode:
+    def __init__(self, op, child):
+        self.op = op
+        self.child = child
+    
+    def eval(self, env):
+        v = self.child.eval(env)
+        if self.op == "!":
+            if not v: return 1
+            else: return 0
+        elif self.op == "~": return ~v
+
+class BinaryOpNode:
+    def __init__(self, op, left, right):
+        self.op = op
+        self.left = left
+        self.right = right
+        
+    def eval(self, env):
+        vl = self.left.eval(env)
+        vr = self.right.eval(env)
+        return OPS[self.op](vl, vr)
+    
+# array nodes
+class ArrayNode:
+    def __init__(self, elements):
+        self.elements = elements
+    
+    def eval(self, env):
+        return [e.eval(env) for e in self.elements]
+
+class IndexNode:
+    def __init__(self, array_node, index_node):
+        self.array_node = array_node
+        self.index_node = index_node
+        
+    def eval(self, env):
+        arr = self.array_node.eval(env)
+        idx = self.index_node.eval(env)
+        if not isinstance(arr, list):
+            raise TypeError(f"Object of type {type(arr)} is not indexable")
+        return arr[int(idx)]
+
+# control flow nodes
+class IfNode:
+    def __init__(self, cond, mainbody, elsebody=[]):
+        self.cond = cond
+        self.mainbody = mainbody
+        self.elsebody = elsebody
+    
+    def eval(self, env):
+        last = 0
+        if self.cond.eval(env):
+            for node in self.mainbody:
+                last = node.eval(env)
+        else:
+            for node in self.elsebody:
+                last = node.eval(env)
+        return last
+
+class WhileNode:
+    def __init__(self, cond, body):
+        self.cond = cond
+        self.body = body
+    
+    def eval(self, env):
+        last = 0
+        while self.cond.eval(env):
+            for node in self.body:
+                last = node.eval(env)
+        return last
+    
+class ForNode:
+    def __init__(self, array, iname, body):
+        self.array = array
+        self.iname = iname
+        self.body = body
+
+    def eval(self, env):
+        iterable = self.array.eval(env)
+        if not hasattr(iterable, "__iter__"):
+            raise TypeError(f"'{type(iterable).__name__}' object is not iterable")
+        last = 0
+        for item in iterable:
+            env[self.iname] = item
+            for node in self.body:
+                last = node.eval(env)
+        return last
+    
+# function nodes
+class FunctionNode:
+    def __init__(self, name, para, body):
+        self.name = name
+        self.para = para
+        self.body = body
+    
+    def eval(self, env):
+        env[self.name] = self
+        return 0
+    
+class CallNode:
+    def __init__(self, name, args):
+        self.name = name
+        self.args = args
+
+    def eval(self, env):
+        func = env.get(self.name)
+        if not func:
+            raise Exception(f"Function {self.name} not defined")
+        eargs = [arg.eval(env) for arg in self.args]
+        if callable(func):
+            return func(*eargs)
+        fenv = env.copy() 
+        for name, val in zip(func.para, eargs):
+            fenv[name] = val
+        try:
+            for node in func.body:
+                node.eval(fenv)
+            return 0
+        except ReturnException as e:
+            return e.value
+        
+class ReturnNode:
+    def __init__(self, value):
+        self.value = value
+        
+    def eval(self, env):
+        raise ReturnException(self.value.eval(env))
+    
+# import nodes
+class ImportNode:
+    def __init__(self, file):
+        self.file = file
+    
+    def eval(self, env):
+        from .parser import parse
+        file = self.file.eval(env)
+        if "__imports__" not in env:
+            env["__imports__"] = set()
+        if file in env["__imports__"]:
+            return 0
+        env["__imports__"].add(file)
+        with open(file, "r") as f:
+            code = f.read()
+        try:
+            tokens = tokenize(code)
+            ast = parse(tokens)
+            for node in ast:
+                if node:
+                    node.eval(env)
+        except Exception as e:
+            print(f"Aergia Error ({file}): {e}")
+        return 0
+    
+class PyImportNode:
+    def __init__(self, name, rname, closed):
+        self.name = name
+        self.rname = rname
+        self.closed = closed
+        
+    def eval(self, env):
+        module = importlib.import_module(self.name)
+        for name, value in vars(module).items():
+            if not name.startswith("_"):
+                if not self.closed:
+                    env[name] = value
+                else:
+                    env[f"{self.rname}_{name}"] = value
+                if isinstance(value, type):
+                    for sname, sval in vars(value).items():
+                        if not sname.startswith("_"):
+                            if not self.closed:
+                                env[f"{name}_{sname}"] = sval
+                            else:
+                                env[f"{self.rname}_{name}_{sname}"] = sval
+        return 0
+
+# low control nodes
+class EvaluationNode:
+    def __init__(self, value):
+        self.value = value
+    
+    def eval(self, env):
+        from .parser import parse
+        code = self.value.eval(env)
+        tokens = tokenize(code)
+        ast = parse(tokens)
+        last = 0
+        for node in ast:
+            if node:
+                last = node.eval(env)
+        return last
+    
+class ExitNode:
+    def __init__(self, value):
+        self.value = value
+    
+    def eval(self, env):
+        exitc = self.value.eval(env)
+        raise ExitException(exitc)

aergia_lang-1.6.0/aergia/parser.py

@@ -0,0 +1,155 @@
+import re
+from .nodes import *
+
+# aergia parser
+# made by las-r on github
+
+# expression parser
+def parseexpr(tokens):
+    if not tokens:
+        return None
+    token = tokens.pop(0)
+    
+    # if block
+    if token == "(":
+        cond = parseexpr(tokens)
+        body = []
+        while tokens and tokens[0] != ")":
+            body.append(parseexpr(tokens))
+        if tokens: tokens.pop(0)
+        elsebody = []
+        if tokens and tokens[0] == "(":
+            tokens.pop(0)
+            while tokens and tokens[0] != ")":
+                elsebody.append(parseexpr(tokens))
+            if tokens: tokens.pop(0)
+        return IfNode(cond, body, elsebody)
+    
+    # while/for block
+    if token == "[":
+        if tokens and tokens[0] == "`":
+            tokens.pop(0)
+            array = parseexpr(tokens)
+            iname = tokens.pop(0)
+            body = []
+            while tokens and tokens[0] != "]":
+                body.append(parseexpr(tokens))
+            if tokens: tokens.pop(0)
+            return ForNode(array, iname, body)
+        else:
+            cond = parseexpr(tokens)
+            body = []
+            while tokens and tokens[0] != "]":
+                body.append(parseexpr(tokens))
+            if tokens: tokens.pop(0)
+            return WhileNode(cond, body)
+    
+    # function block
+    if token == "{":
+        name = tokens.pop(0)
+        para = []
+        if tokens and tokens[0] == ":":
+            tokens.pop(0)
+            while tokens and tokens[0] != ":":
+                para.append(tokens.pop(0))
+            if tokens: tokens.pop(0)
+        body = []
+        while tokens and tokens[0] != "}":
+            body.append(parseexpr(tokens))
+        if tokens: tokens.pop(0)
+        return FunctionNode(name, para, body)
+    
+    # array definition
+    if token == "<":
+        elements = []
+        while tokens and tokens[0] != ">":
+            elements.append(parseexpr(tokens))
+        if tokens: tokens.pop(0)
+        return ArrayNode(elements)
+    
+    # array index
+    if token == ":":
+        array = parseexpr(tokens)
+        index = parseexpr(tokens)
+        return IndexNode(array, index)
+    
+    # exit
+    if token == "~>":
+        value = parseexpr(tokens)
+        return ExitNode(value)
+    
+    # imports
+    if token == "+>":
+        file = parseexpr(tokens)
+        return ImportNode(file)
+    if token == "*>":
+        name = tokens.pop(0)
+        return PyImportNode(name, name, False)
+    if token == "*<":
+        name = tokens.pop(0)
+        rname = tokens.pop(0)
+        return PyImportNode(name, rname, True)
+    
+    # evaluation
+    if token == ";":
+        value = parseexpr(tokens)
+        return EvaluationNode(value)
+    
+    # assignments
+    if token == "=":
+        name = tokens.pop(0)
+        value = parseexpr(tokens)
+        return AssignNode(name, value)
+    
+    # binary ops
+    if token in ("+", "-", "*", "/", "==", "!=", ">>", "<<", ">=", "<=", "^", "%", "&", "|", "$"):
+        left = parseexpr(tokens)
+        right = parseexpr(tokens)
+        return BinaryOpNode(token, left, right)
+    
+    # unary ops and output
+    if token in ("!", "~", ">"):
+        child = parseexpr(tokens)
+        if token == ">": return OutputNode(child)
+        return UnaryOpNode(token, child)
+    
+    # input
+    if token == ".": return IntInputNode()
+    if token == ",": return StringInputNode()
+    if token == "'": return FloatInputNode()
+    
+    # function return
+    if token == "?": return ReturnNode(parseexpr(tokens))
+    
+    # function call
+    if token == "@":
+        name = tokens.pop(0)
+        args = []
+        if tokens and tokens[0] == ":":
+            tokens.pop(0)
+            while tokens and tokens[0] != ":":
+                args.append(parseexpr(tokens))
+            if tokens: tokens.pop(0)
+        return CallNode(name, args)
+    
+    # string
+    if token.startswith('"'):
+        content = token[1:-1]
+        unescaped = re.sub(r'\\(.)', r'\1', content)
+        return LiteralNode(unescaped)
+    
+    # number and variable
+    try:
+        val = float(token)
+        return LiteralNode(int(val) if val.is_integer() else val)
+    except ValueError:
+        return VariableNode(token)
+
+# tree maker
+def parse(tokens):
+    ast = []
+    while tokens:
+        node = parseexpr(tokens)
+        if node:
+            ast.append(node)
+    return ast

aergia_lang-1.6.0/aergia_lang.egg-info/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: aergia-lang
+Version: 1.6.0
+Summary: The Aergia programming language
+Author: las-r
+Requires-Python: >=3.7
+License-File: LICENSE
+Dynamic: license-file

aergia_lang-1.6.0/aergia_lang.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+aergia/__init__.py
+aergia/__main__.py
+aergia/lexer.py
+aergia/nodes.py
+aergia/parser.py
+aergia_lang.egg-info/PKG-INFO
+aergia_lang.egg-info/SOURCES.txt
+aergia_lang.egg-info/dependency_links.txt
+aergia_lang.egg-info/entry_points.txt
+aergia_lang.egg-info/top_level.txt

aergia_lang-1.6.0/aergia_lang.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

aergia_lang-1.6.0/aergia_lang.egg-info/entry_points.txt

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

aergia_lang-1.6.0/aergia_lang.egg-info/top_level.txt

@@ -0,0 +1 @@
+aergia

aergia_lang-1.6.0/pyproject.toml

@@ -0,0 +1,17 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "aergia-lang"
+version = "1.6.0"
+description = "The Aergia programming language"
+authors = [{ name = "las-r" }]
+dependencies = []
+requires-python = ">=3.7"
+
+[project.scripts]
+aergia = "aergia.__main__:main"
+
+[tool.setuptools.packages.find]
+include = ["aergia*"]

aergia_lang-1.6.0/setup.cfg

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