koskript 1.2.0__py3-none-any.whl

koskript/__init__.py

@@ -0,0 +1,86 @@
+from lark import Lark
+from .lang.emtypes import KoskriptObject
+from .lang.interpreter import KoskripInterpreter
+from .lang.astgen import KoskriptTransformer
+from .lang.errors import Errors
+import pathlib, os
+
+_grammar_path = os.path.join(pathlib.Path(__file__).resolve().parent, "grammar.lark")
+with open(_grammar_path, "r") as _grammar_file:
+    grammar = Lark(_grammar_file, parser="lalr", maybe_placeholders=False)
+
+
+def _wrap(value):
+    return value if isinstance(value, KoskriptObject) else KoskriptObject(value=value)
+
+
+class KoskriptRuntime(object):
+    """Embeddable Koskript runtime.
+
+    Any Python value or callable exposed to scripts is wrapped automatically,
+    so you can pass plain functions without building ``KoskriptObject`` by hand.
+
+    >>> rt = KoskriptRuntime({"print": print})
+    >>> rt.execute("local x = 10\\nx + 26")
+    36
+    """
+
+    def __init__(self, globals=None, _globals_=None):
+        if _globals_ is not None:
+            globals = {**(globals or {}), **_globals_}
+
+        self.globals = {}
+        self.__interpreter__ = KoskripInterpreter()
+        self.__ast__ = KoskriptTransformer()
+
+        if globals:
+            self.register_many(globals)
+
+    def register(self, name: str, value):
+        """Expose a Python value or callable to scripts.
+
+        Returns the runtime so calls can be chained.
+        """
+        obj = _wrap(value)
+        self.globals[name] = obj
+        self.__interpreter__.set_global(name, obj)
+        return self
+
+    def register_many(self, mapping: dict):
+        for name, value in mapping.items():
+            self.register(name, value)
+        return self
+
+    def __setitem__(self, name: str, value):
+        self.register(name, value)
+
+    def __getitem__(self, name: str):
+        return self.__interpreter__.get_global(name).value
+
+    def execute(self, code: str):
+        """Parse and run ``code``.
+
+        Returns the value of the last evaluated expression, or the value of a
+        top-level ``return`` if the script uses one.
+        """
+        tree = grammar.parse(code)
+        ast = self.__ast__.transform(tree)
+
+        if not isinstance(ast, list):
+            ast = [ast]
+
+        return self.__interpreter__.run(ast)
+
+
+def run(code: str, globals: dict = None, **kwargs):
+    """One-shot convenience helper.
+
+    >>> run("print(1 + 2)", print=print)
+    3
+    """
+    merged = dict(globals or {})
+    merged.update(kwargs)
+    return KoskriptRuntime(merged).execute(code)
+
+
+__all__ = ["KoskriptRuntime", "KoskriptObject", "Errors", "run"]

koskript/lang/astgen.py

@@ -0,0 +1,213 @@
+from lark import Transformer
+from .emtypes import *
+
+_ESCAPES = {
+    "n": "\n",
+    "t": "\t",
+    "r": "\r",
+    "0": "\0",
+    "\\": "\\",
+    '"': '"',
+    "'": "'",
+}
+
+
+def _unescape(raw: str) -> str:
+    out = []
+    i = 0
+    while i < len(raw):
+        ch = raw[i]
+        if ch == "\\" and i + 1 < len(raw):
+            nxt = raw[i + 1]
+            out.append(_ESCAPES.get(nxt, nxt))
+            i += 2
+        else:
+            out.append(ch)
+            i += 1
+    return "".join(out)
+
+
+class KoskriptTransformer(Transformer):
+    def start(self, tree): return (tree)
+
+    def NUMBER(self, token):
+        text = str(token)
+        if "." in text:
+            return FloatLit(value=float(text))
+        return IntLit(value=int(text))
+
+    def NAME(self, token): return NameRef(name=str(token))
+    def STRING(self, token): return StrLit(value=_unescape(str(token)[1:-1]))
+    def bool_true(self, tree): return BoolLit(value=True)
+    def bool_false(self, tree): return BoolLit(value=False)
+    def null_lit(self, tree): return NullLit(value=None)
+
+    def lambda_fn(self, tree):
+        return LambdaFnDef(params=[], body=tree[0])
+
+    def lambda_fn_args(self, tree):
+        params = [obj.name for obj in tree[:-1]]
+        body = tree[-1]
+        return LambdaFnDef(params=params, body=body)
+
+    def array(self, tree): return ArrayLit(value=tree)
+    def map(self, tree): return MapLit(value=tree)
+    def map_obj(self, tree): return MapValue(key=tree[0], value=tree[1])
+
+    def arg_list(self, tree): return tree
+
+    def add_stmt(self, tree):
+        left, right = tree
+        return AddStmt(left=left, right=right)
+    
+    def sub_stmt(self, tree):
+        left, right = tree
+        return SubStmt(left=left, right=right)
+    
+    def mul_stmt(self, tree):
+        left, right = tree
+        return MulStmt(left=left, right=right)
+    
+    def div_stmt(self, tree):
+        left, right = tree
+        return DivStmt(left=left, right=right)
+
+    def mod_stmt(self, tree):
+        left, right = tree
+        return ModStmt(left=left, right=right)
+
+    def neg_stmt(self, tree):
+        return NegStmt(value=tree[0])
+
+    def param_list(self, tree):
+        return [obj.name for obj in tree]
+    
+    def block(self, tree):
+        return tree
+    
+    # conditions and comparisons
+    def and_cond(self, tree):
+        left, right = tree
+        return AndCond(left=left, right=right)
+    
+    def not_cond(self, tree):
+        return NotCond(tree)
+    
+    def or_cond(self, tree):
+        left, right = tree
+        return OrCond(left=left, right=right)
+
+
+    def equ(self, tree):
+        left, right = tree
+        return EquComp(left=left, right=right)
+    def nequ(self, tree):
+        left, right = tree
+        return NequComp(left=left, right=right)
+    def gte(self, tree):
+        left, right = tree
+        return GteComp(left=left, right=right)
+    def lte(self, tree):
+        left, right = tree
+        return LteComp(left=left, right=right)
+    def lt(self, tree):
+        left, right = tree
+        return LtComp(left=left, right=right)
+    def gt(self, tree):
+        left, right = tree
+        return GtComp(left=left, right=right)
+    
+    def member_access(self, tree):
+        value, attr = tree
+        return MemberAccess(name=value, attrs=[attr])
+
+    def index_access(self, tree):
+        value, index = tree
+        return IndexAccess(value=value, index=index)
+
+    def if_stmt(self, tree):
+        condition = tree[0]
+        block = tree[1]
+        anexed_ifs = tree[2:]
+
+        return IfStmt(
+            condition=condition,
+            body=block,
+            if_tree=anexed_ifs
+        )
+    
+    def elseif_stmt(self, tree):
+        condition, block = tree
+        return ElseIfStmt(
+            condition=condition,
+            body=block
+        )
+
+    def elsestmt(self, tree):
+        return ElseStmt(
+            body=tree[0]
+        )
+
+    # declarations
+    def local_decl(self, tree):
+        name, expr = tree
+
+        return LocalDecl(
+            name=name.name, 
+            value=expr
+        )
+
+    def decl(self, tree):
+        name, expr = tree
+        return DeclStmt(
+            name=name.name, value=expr
+        )
+
+    def fn_def(self, tree):
+        name, params, block = tree
+        return FnDef(
+            name=name.name,
+            params=params,
+            body=block
+        )
+    
+    def fn_def_nargs(self, tree):
+        name, block = tree
+        return FnDef(
+            name=name.name,
+            params=[],
+            body=block
+        )
+
+    # flow
+    def return_value(self, tree):
+        if len(tree) >= 1:
+            return ReturnStmt(value=tree[0])
+        return ReturnStmt(value=None)
+
+    def return_void(self, tree):
+        return ReturnStmt(value=None)
+    
+    def while_stmt(self, tree):
+        condition, block = tree
+        return WhileStmt(condition=condition, body=block)
+    
+    def break_stmt(self, tree):
+        return BreakStmt()
+
+    def continue_stmt(self, tree):
+        return ContinueStmt()
+    
+    def for_stmt(self, tree):
+        varname, iterable, block = tree
+        return ForStmt(var=varname.name, iterable=iterable, body=block)
+    
+    def foritem_stmt(self, tree):
+        key, value, iterable, block = tree
+        return ForItemStmt(key=key.name, var=value.name, iterable=iterable, body=block)
+    
+    # Otros
+    def fn_call(self, tree):
+        name = tree[0]
+        args = tree[1] if len(tree) > 1 else []
+        return FnCall(name=name, args=args)

koskript/lang/emtypes.py

@@ -0,0 +1,84 @@
+from collections import namedtuple
+from .errors import Errors
+from typing import Any
+
+# Literals and references
+IntLit = namedtuple("IntLit", ["value"])
+FloatLit = namedtuple("FloatLit", ["value"])
+StrLit = namedtuple("StrLit", ["value"])
+BoolLit = namedtuple("BoolLit", ["value"])
+NullLit = namedtuple("NullLit", ["value"])
+ArrayLit = namedtuple("ArrayLit", ["value"])
+MapLit = namedtuple("MapLit", ["value"])
+MapValue = namedtuple("MapValue", ["key", "value"])
+NameRef = namedtuple("NameRef", ["name"])
+Function = namedtuple("Function", ["params", "body"])
+MemberAccess = namedtuple("MemberAccess", ["name", "attrs"])
+IndexAccess = namedtuple("IndexAccess", ["value", "index"])
+
+# Control-flow signal raised by `return` so it can unwind out of
+# if/while/for blocks and be caught by the enclosing function call.
+class ReturnSignal(Exception):
+    def __init__(self, value=None):
+        super().__init__("return")
+        self.value = value
+
+# Signals raised by `break` / `continue`, caught by the nearest loop.
+class BreakSignal(Exception):
+    def __init__(self):
+        super().__init__("break")
+
+class ContinueSignal(Exception):
+    def __init__(self):
+        super().__init__("continue")
+
+# Node Objects
+LocalDecl = namedtuple("LocalDecl", ["name", "value"])
+DeclStmt = namedtuple("DeclStmt", ["name", "value"])
+ReturnStmt = namedtuple("ReturnStmt", ["value"])
+FnDef  = namedtuple("FnDef",  ["name", "params", "body"])
+FnCall = namedtuple("FnCall", ["name", "args"])
+LambdaFnDef = namedtuple("LambdaFnDef", ["params", "body"])
+WhileStmt   = namedtuple("WhileStmt",   ["condition", "body"])
+ForStmt     = namedtuple("ForStmt",     ["var", "iterable", "body"])
+ForItemStmt = namedtuple("ForItemStmt", ["key", "var", "iterable", "body"])
+BreakStmt    = namedtuple("BreakStmt", [])
+ContinueStmt = namedtuple("ContinueStmt", [])
+AddStmt = namedtuple("AddStmt", ["left", "right"])
+SubStmt = namedtuple("SubStmt", ["left", "right"])
+MulStmt = namedtuple("MulStmt", ["left", "right"])
+DivStmt = namedtuple("DivStmt", ["left", "right"])
+ModStmt = namedtuple("ModStmt", ["left", "right"])
+NegStmt = namedtuple("NegStmt", ["value"])
+IfStmt = namedtuple("IfStmt", ["condition", "body", "if_tree"])
+ElseIfStmt = namedtuple("ElseIfStmt", ["condition", "body"])
+ElseStmt = namedtuple("ElseStmt", ["body"])
+
+# Conditions
+AndCond = namedtuple("AndCond", ["left", "right"])
+OrCond = namedtuple("OrCond", ["left", "right"])
+NotCond = namedtuple("NotCond", ["comparison"])
+
+# Comparisons
+EquComp = namedtuple("EquComp", ["left", "right"])
+NequComp = namedtuple("NequComp", ["left", "right"])
+LteComp = namedtuple("LteComp", ["left", "right"])
+GteComp = namedtuple("GteComp", ["left", "right"])
+LtComp = namedtuple("LtComp", ["left", "right"])
+GtComp = namedtuple("GtComp", ["left", "right"])
+
+
+class KoskriptObject(object):
+    def __init__(self, value: Any, read_only: bool = False):
+        self.value = value
+        self.read_only = read_only
+
+    def set_value(self, value: Any):
+        if self.read_only:
+            raise Errors.ProtectedObject("cannot modify a constant value.")
+
+        self.value = value
+
+    def __repr__(self):
+        return f"KoskriptObject(value={self.value}, read_only={self.read_only})"
+

koskript/lang/errors.py

@@ -0,0 +1,12 @@
+class Errors:
+    class MismatchType(Exception):
+        def __init__(self, *args):
+            super().__init__(*args)
+    
+    class ProtectedObject(Exception):
+        def __init__(self, *args):
+            super().__init__(*args)
+
+    class RuntimeError(Exception):
+        def __init__(self, *args):
+            super().__init__(*args)