gladlang 0.2.2__tar.gz → 0.2.4__tar.gz

{gladlang-0.2.2/src/gladlang.egg-info → gladlang-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gladlang
-Version: 0.2.2
+Version: 0.2.4
 Summary: The GladLang Interpreter
 Author: Glad432
 License: Copyright (c) 2025 - present GLAD432
@@ -465,7 +465,7 @@ LET b = 3  # Binary 011
 PRINTLN a & b   # 1 (AND)
 PRINTLN a | b   # 7 (OR)
 PRINTLN a ^ b   # 6 (XOR)
-PRINTLN ~a      # -6 (NOT)
+PRINTLN ~a      # 4294967290 (bitwise NOT as unsigned 32‑bit integer)
 PRINTLN 1 << 2  # 4 (Left Shift)
 PRINTLN 8 >> 2  # 2 (Right Shift)
 

{gladlang-0.2.2 → gladlang-0.2.4}/README.md

@@ -437,7 +437,7 @@ LET b = 3  # Binary 011
 PRINTLN a & b   # 1 (AND)
 PRINTLN a | b   # 7 (OR)
 PRINTLN a ^ b   # 6 (XOR)
-PRINTLN ~a      # -6 (NOT)
+PRINTLN ~a      # 4294967290 (bitwise NOT as unsigned 32‑bit integer)
 PRINTLN 1 << 2  # 4 (Left Shift)
 PRINTLN 8 >> 2  # 2 (Right Shift)
 

{gladlang-0.2.2 → gladlang-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gladlang"
-version = "0.2.2"
+version = "0.2.4"
 description = "The GladLang Interpreter"
 readme = "README.md"
 requires-python = ">=3.10"

{gladlang-0.2.2 → gladlang-0.2.4}/src/gladlang/__main__.py

@@ -140,8 +140,10 @@ def is_complete(text):
         return False
 
     depth = 0
+    bracket_depth = 0
+    brace_depth = 0
 
-    pattern = r"(\[|\]|\b(DEF|CLASS|ENUM|IF|ELSE\s+IF|ELSE|WHILE|FOR|TRY|SWITCH|ENDDEF|ENDCLASS|ENDENUM|ENDIF|ENDWHILE|ENDFOR|ENDTRY|ENDSWITCH)\b)"
+    pattern = r"(\[|\]|\{|\}|\b(DEF|CLASS|ENUM|IF|ELSE\s+IF|ELSE|WHILE|FOR|TRY|SWITCH|ENDDEF|ENDCLASS|ENDENUM|ENDIF|ENDWHILE|ENDFOR|ENDTRY|ENDSWITCH)\b)"
 
     tokens = re.finditer(pattern, temp_text)
 
@@ -161,9 +163,25 @@ def is_complete(text):
     for match in tokens:
         token = match.group()
 
+        if token == "[":
+            bracket_depth += 1
+            continue
+        elif token == "]":
+            bracket_depth -= 1
+            continue
+        elif token == "{":
+            brace_depth += 1
+            continue
+        elif token == "}":
+            brace_depth -= 1
+            continue
+
         if token in ("ELSE", "ELSE IF"):
             continue
 
+        if token == "FOR" and (bracket_depth > 0 or brace_depth > 0):
+            continue
+
         if token in start_keys:
             depth += 1
         elif token in end_keys:
@@ -174,11 +192,13 @@ def is_complete(text):
 
 def main():
     MAX_MEMORY_MB = 512
-    MAX_INSTRUCTIONS = 100000
+    MAX_INSTRUCTIONS = 1_000_000
+    MAX_SOURCE_BYTES = 1_000_000
+    MAX_REPL_BUFFER = 100_000
 
     set_memory_limit(MAX_MEMORY_MB)
 
-    GLADLANG_VERSION = "0.2.2"
+    GLADLANG_VERSION = "0.2.4"
     GLADLANG_HELP = f"""
 Usage: gladlang [command] [filename/code] [args...]
 
@@ -221,6 +241,13 @@ Commands:
 
                 full_text += line + "\n"
 
+                if len(full_text) > MAX_REPL_BUFFER:
+                    sys.stdout.write(
+                        "Error: Input buffer limit exceeded. Clearing buffer.\n"
+                    )
+                    full_text = ""
+                    continue
+
                 if is_complete(full_text):
                     if full_text.strip() == "":
                         full_text = ""
@@ -308,8 +335,9 @@ Commands:
                     try:
                         candidate = Path(arg_input).resolve()
                         allowed_root = Path.cwd().resolve()
-                        if not str(candidate).startswith(str(allowed_root)):
+                        if not candidate.is_relative_to(allowed_root):
                             raise PermissionError(f"Access denied: '{arg_input}'")
+
                         if candidate.is_file():
                             is_file = True
                             resolved = candidate
@@ -326,7 +354,27 @@ Commands:
                                 f"File must have .glad extension: '{arg_input}'\n"
                             )
                             sys.exit(1)
-                        text = path_to_read.read_text(encoding="utf-8")
+
+                        file_size = path_to_read.stat().st_size
+                        if file_size > MAX_SOURCE_BYTES:
+                            sys.stderr.write(
+                                f"File too large: '{arg_input}' ({file_size:,} bytes). "
+                                f"Maximum allowed: {MAX_SOURCE_BYTES:,} bytes.\n"
+                            )
+                            sys.exit(1)
+
+                        try:
+                            text = path_to_read.read_text(encoding="utf-8")
+                        except UnicodeDecodeError:
+                            sys.stderr.write(
+                                f"Encoding error: '{arg_input}' is not valid UTF-8. "
+                                "Save the file as UTF-8 and try again.\n"
+                            )
+                            sys.exit(1)
+                        except Exception as e:
+                            sys.stderr.write(f"An unexpected error occurred: {e}\n")
+                            sys.exit(1)
+
                         source_name = str(path_to_read)
                     else:
                         text = arg_input

{gladlang-0.2.2 → gladlang-0.2.4}/src/gladlang/errors.py

@@ -1,4 +1,6 @@
 class Position:
+    __slots__ = ("idx", "ln", "col", "fn", "ftxt")
+
     def __init__(self, idx, ln, col, fn, ftxt):
         self.idx = idx
         self.ln = ln

{gladlang-0.2.2 → gladlang-0.2.4}/src/gladlang/interpreter.py

@@ -12,6 +12,8 @@ from .values import (
     Instance,
     Enum,
     Value,
+    TailCall,
+    BoundMethod,
 )
 from .nodes import *
 from .errors import RTError
@@ -20,10 +22,15 @@ from .constants import *
 
 def is_final_anywhere(table, name):
     while table:
+        if table._finals_count == 0:
+            table = table.parent
+            continue
+
         with table._lock:
             if name in table.finals:
                 return True
         table = table.parent
+
     return False
 
 
@@ -32,6 +39,27 @@ class Interpreter:
         self.dispatch_cache = {}
         self.instruction_limit = instruction_limit
 
+        self._binop_dispatch = {
+            GL_PLUS: lambda l, r: l.added_to(r),
+            GL_MINUS: lambda l, r: l.subbed_by(r),
+            GL_MUL: lambda l, r: l.multed_by(r),
+            GL_DIV: lambda l, r: l.dived_by(r),
+            GL_MOD: lambda l, r: l.modded_by(r),
+            GL_FLOORDIV: lambda l, r: l.floordived_by(r),
+            GL_POW: lambda l, r: l.powed_by(r),
+            GL_EE: lambda l, r: l.get_comparison_eq(r),
+            GL_NE: lambda l, r: l.get_comparison_ne(r),
+            GL_LT: lambda l, r: l.get_comparison_lt(r),
+            GL_GT: lambda l, r: l.get_comparison_gt(r),
+            GL_LTE: lambda l, r: l.get_comparison_lte(r),
+            GL_GTE: lambda l, r: l.get_comparison_gte(r),
+            GL_BIT_AND: lambda l, r: l.bitted_and_by(r),
+            GL_BIT_OR: lambda l, r: l.bitted_or_by(r),
+            GL_BIT_XOR: lambda l, r: l.bitted_xor_by(r),
+            GL_LSHIFT: lambda l, r: l.lshifted_by(r),
+            GL_RSHIFT: lambda l, r: l.rshifted_by(r),
+        }
+
     def visit(self, node, context):
         if self.instruction_limit is not None:
             self.instruction_limit -= 1
@@ -204,7 +232,11 @@ class Interpreter:
         comp_context = Context("COMPREHENSION", context, node.pos_start)
         comp_context.symbol_table = SymbolTable(context.symbol_table)
 
+        had_error = False
+
         def evaluate_loops(spec_index):
+            nonlocal had_error
+
             if spec_index >= len(node.iteration_specs):
                 val = res.register(self.visit(node.output_expr_node, comp_context))
                 if not res.error:
@@ -222,6 +254,7 @@ class Interpreter:
             )
             if error:
                 res.failure(error)
+                had_error = True
                 return
 
             for element in iterator:
@@ -244,7 +277,7 @@ class Interpreter:
 
         evaluate_loops(0)
 
-        if res.error:
+        if res.error or had_error:
             return res
 
         return res.success(
@@ -388,16 +421,17 @@ class Interpreter:
 
         visibility = getattr(node, "target_visibility", "PUBLIC")
 
-        if node.is_declaration:
-            if is_final_anywhere(context.symbol_table, var_name):
-                return res.failure(
-                    RTError(
-                        node.var_name_tok.pos_start,
-                        node.var_name_tok.pos_end,
-                        f"Cannot reassign constant '{var_name}'",
-                        context,
-                    )
+        if is_final_anywhere(context.symbol_table, var_name):
+            return res.failure(
+                RTError(
+                    node.var_name_tok.pos_start,
+                    node.var_name_tok.pos_end,
+                    f"Cannot reassign constant '{var_name}'",
+                    context,
                 )
+            )
+
+        if node.is_declaration:
             context.symbol_table.set(var_name, value, visibility=visibility)
         else:
             err = context.symbol_table.update(var_name, value)
@@ -556,7 +590,11 @@ class Interpreter:
         comp_context = Context("DICT_COMPREHENSION", context, node.pos_start)
         comp_context.symbol_table = SymbolTable(context.symbol_table)
 
+        had_error = False
+
         def evaluate_loops(spec_index):
+            nonlocal had_error
+
             if spec_index >= len(node.iteration_specs):
                 key_val = res.register(self.visit(node.key_expr_node, comp_context))
                 if res.error:
@@ -577,6 +615,7 @@ class Interpreter:
                             comp_context,
                         )
                     )
+                    had_error = True
                     return
                 return
 
@@ -591,6 +630,7 @@ class Interpreter:
             )
             if error:
                 res.failure(error)
+                had_error = True
                 return
 
             for element in iterator:
@@ -613,7 +653,7 @@ class Interpreter:
 
         evaluate_loops(0)
 
-        if res.error:
+        if res.error or had_error:
             return res
 
         return res.success(
@@ -797,7 +837,7 @@ class Interpreter:
         if res.error:
             return res
 
-        value_to_call = value_to_call.copy().set_pos(node.pos_start, node.pos_end)
+        value_to_call = value_to_call.set_pos(node.pos_start, node.pos_end)
 
         for arg_node in node.arg_nodes:
             args.append(res.register(self.visit(arg_node, context)))
@@ -813,10 +853,31 @@ class Interpreter:
     def visit_ReturnNode(self, node, context):
         res = RTResult()
 
+        tco_func = getattr(context, "_tco_func", None)
+        if tco_func is not None and isinstance(node.node_to_return, CallNode):
+            ret_node = node.node_to_return
+
+            callee = res.register(self.visit(ret_node.node_to_call, context))
+            if res.error:
+                return res
+
+            if isinstance(callee, BoundMethod):
+                underlying = callee.function_to_bind
+            else:
+                underlying = callee
+
+            if underlying is tco_func or callee is tco_func:
+                tc_args = []
+                for arg_node in ret_node.arg_nodes:
+                    arg_val = res.register(self.visit(arg_node, context))
+                    if res.error:
+                        return res
+                    tc_args.append(arg_val)
+                return res.success_return(TailCall(callee, tc_args))
+
         value = res.register(self.visit(node.node_to_return, context))
         if res.error:
             return res
-
         return res.success_return(value)
 
     def visit_ClassNode(self, node, context):
@@ -1217,49 +1278,20 @@ class Interpreter:
         if res.error:
             return res
 
-        result, error = None, None
-
-        if node.op_tok.type == GL_PLUS:
-            result, error = left.added_to(right)
-        elif node.op_tok.type == GL_MINUS:
-            result, error = left.subbed_by(right)
-        elif node.op_tok.type == GL_MUL:
-            result, error = left.multed_by(right)
-        elif node.op_tok.type == GL_DIV:
-            result, error = left.dived_by(right)
-        elif node.op_tok.type == GL_MOD:
-            result, error = left.modded_by(right)
-        elif node.op_tok.type == GL_FLOORDIV:
-            result, error = left.floordived_by(right)
-        elif node.op_tok.type == GL_POW:
-            result, error = left.powed_by(right)
-        elif node.op_tok.type == GL_EE:
-            result, error = left.get_comparison_eq(right)
-        elif node.op_tok.type == GL_NE:
-            result, error = left.get_comparison_ne(right)
-        elif node.op_tok.type == GL_LT:
-            result, error = left.get_comparison_lt(right)
-        elif node.op_tok.type == GL_GT:
-            result, error = left.get_comparison_gt(right)
-        elif node.op_tok.type == GL_LTE:
-            result, error = left.get_comparison_lte(right)
-        elif node.op_tok.type == GL_GTE:
-            result, error = left.get_comparison_gte(right)
-        elif node.op_tok.matches(GL_KEYWORD, "IS"):
+        if node.op_tok.matches(GL_KEYWORD, "IS"):
             result, error = left.get_comparison_is(right)
+            if error:
+                return res.failure(error)
+            return res.success(result.set_pos(node.pos_start, node.pos_end))
+
         elif node.op_tok.matches(GL_KEYWORD, "INSTANCEOF"):
             result, error = left.get_comparison_instanceof(right)
-        elif node.op_tok.type == GL_BIT_AND:
-            result, error = left.bitted_and_by(right)
-        elif node.op_tok.type == GL_BIT_OR:
-            result, error = left.bitted_or_by(right)
-        elif node.op_tok.type == GL_BIT_XOR:
-            result, error = left.bitted_xor_by(right)
-        elif node.op_tok.type == GL_LSHIFT:
-            result, error = left.lshifted_by(right)
-        elif node.op_tok.type == GL_RSHIFT:
-            result, error = left.rshifted_by(right)
-        else:
+            if error:
+                return res.failure(error)
+            return res.success(result.set_pos(node.pos_start, node.pos_end))
+
+        op = self._binop_dispatch.get(node.op_tok.type)
+        if op is None:
             return res.failure(
                 RTError(
                     node.op_tok.pos_start,
@@ -1268,11 +1300,11 @@ class Interpreter:
                     context,
                 )
             )
-
+        result, error = op(left, right)
         if error:
             return res.failure(error)
-        else:
-            return res.success(result.set_pos(node.pos_start, node.pos_end))
+
+        return res.success(result.set_pos(node.pos_start, node.pos_end))
 
     def visit_TernaryOpNode(self, node, context):
         res = RTResult()

{gladlang-0.2.2 → gladlang-0.2.4}/src/gladlang/lexer.py

@@ -3,6 +3,8 @@ from .errors import Position, IllegalCharError, InvalidSyntaxError
 
 
 class Token:
+    __slots__ = ("type", "value", "pos_start", "pos_end")
+
     def __init__(self, type_, value=None, pos_start=None, pos_end=None):
         self.type = type_
         self.value = value
@@ -386,16 +388,17 @@ class Lexer:
 
         tokens.append(Token(GL_LPAREN, pos_start=pos_start))
 
-        string_part = ""
+        chars = []
         escape_character = False
 
-        while self.current_char != None and (
+        while self.current_char is not None and (
             self.current_char != "`" or escape_character
         ):
 
             if not escape_character and self.current_char == "$" and self.peek() == "{":
+                string_part = "".join(chars)
                 tokens.append(Token(GL_STRING, string_part, pos_start=pos_start))
-                string_part = ""
+                chars = []
 
                 tokens.append(Token(GL_PLUS, pos_start=self.pos))
                 tokens.append(Token(GL_IDENTIFIER, "STR", pos_start=self.pos))
@@ -450,24 +453,23 @@ class Lexer:
 
             elif escape_character:
                 if self.current_char == "n":
-                    string_part += "\n"
+                    chars.append("\n")
                 elif self.current_char == "t":
-                    string_part += "\t"
+                    chars.append("\t")
                 elif self.current_char == "r":
-                    string_part += "\r"
+                    chars.append("\r")
                 elif self.current_char == "`":
-                    string_part += "`"
+                    chars.append("`")
                 elif self.current_char == "\\":
-                    string_part += "\\"
+                    chars.append("\\")
                 elif self.current_char == '"':
-                    string_part += '"'
+                    chars.append('"')
                 elif self.current_char == "'":
-                    string_part += "'"
+                    chars.append("'")
                 elif self.current_char == "$":
-                    string_part += "$"
+                    chars.append("$")
                 else:
-                    string_part += self.current_char
-
+                    chars.append(self.current_char)
                 escape_character = False
                 self.advance()
 
@@ -476,9 +478,10 @@ class Lexer:
                 self.advance()
 
             else:
-                string_part += self.current_char
+                chars.append(self.current_char)
                 self.advance()
 
+        string_part = "".join(chars)
         tokens.append(Token(GL_STRING, string_part, pos_start=pos_start))
         tokens.append(Token(GL_RPAREN, pos_start=self.pos))
 
@@ -486,7 +489,7 @@ class Lexer:
         return tokens
 
     def make_string(self):
-        string = ""
+        chars = []
         pos_start = self.pos.copy()
 
         is_multiline = False
@@ -500,20 +503,20 @@ class Lexer:
 
         escape_character = False
 
-        while self.current_char != None:
+        while self.current_char is not None:
             if escape_character:
                 if self.current_char == "n":
-                    string += "\n"
+                    chars.append("\n")
                 elif self.current_char == "t":
-                    string += "\t"
+                    chars.append("\t")
                 elif self.current_char == "r":
-                    string += "\r"
+                    chars.append("\r")
                 elif self.current_char == '"':
-                    string += '"'
+                    chars.append('"')
                 elif self.current_char == "\\":
-                    string += "\\"
+                    chars.append("\\")
                 else:
-                    string += self.current_char
+                    chars.append(self.current_char)
                 escape_character = False
             elif self.current_char == "\\":
                 escape_character = True
@@ -525,13 +528,13 @@ class Lexer:
                             self.advance()
                             break
                         else:
-                            string += '""'
+                            chars.append('""')
                     else:
-                        string += '"'
+                        chars.append('"')
                 else:
                     break
             else:
-                string += self.current_char
+                chars.append(self.current_char)
 
             self.advance()
 
@@ -540,5 +543,6 @@ class Lexer:
                 pos_start, self.pos, "Unterminated string literal"
             )
 
+        string = "".join(chars)
         self.advance()
         return Token(GL_STRING, string, pos_start, self.pos)

{gladlang-0.2.2 → gladlang-0.2.4}/src/gladlang/runtime.py

@@ -1,23 +1,40 @@
 from threading import Lock
 
 
+class _NoLock:
+    __slots__ = ()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        pass
+
+
 class SymbolTable:
+    _THREADING_ENABLED = False
+
     def __init__(self, parent=None):
         self.symbols = {}
         self.parent = parent
         self.finals = set()
         self.visibilities = {}
         self.defining_classes = {}
-        self._lock = Lock()
+        self._lock = Lock() if SymbolTable._THREADING_ENABLED else _NoLock()
+        self._finals_count = 0
 
     def set(
         self, name, value, visibility="PUBLIC", as_final=False, defining_class=None
     ):
         with self._lock:
             self.symbols[name] = value
-            self.visibilities[name] = visibility
+            if visibility != "PUBLIC":
+                self.visibilities[name] = visibility
+
             if as_final:
                 self.finals.add(name)
+                self._finals_count += 1
+
             if defining_class:
                 self.defining_classes[name] = defining_class
 
@@ -34,20 +51,28 @@ class SymbolTable:
         with self._lock:
             if name in self.symbols:
                 return f"Variable '{name}' is already defined"
+
             if as_final and self.is_final_in_ancestors(name):
                 return f"Cannot declare constant '{name}' because it is already defined as constant in outer scope"
+
             self.symbols[name] = value
-            self.visibilities[name] = visibility
+            if visibility != "PUBLIC":
+                self.visibilities[name] = visibility
+
             if as_final:
                 self.finals.add(name)
+                self._finals_count += 1
+
             return None
 
     def get(self, name):
         with self._lock:
             value = self.symbols.get(name)
-            if value is None and self.parent:
-                return self.parent.get(name)
-            return value
+            has_parent = self.parent is not None
+
+        if value is None and has_parent:
+            return self.parent.get(name)
+        return value
 
     def update(self, name, value):
         with self._lock:
@@ -56,9 +81,11 @@ class SymbolTable:
             if name in self.symbols:
                 self.symbols[name] = value
                 return None
-            if self.parent:
-                return self.parent.update(name, value)
-            return f"'{name}' is not defined"
+            has_parent = self.parent is not None
+
+        if has_parent:
+            return self.parent.update(name, value)
+        return f"'{name}' is not defined"
 
     def remove(self, name):
         with self._lock:
@@ -78,10 +105,22 @@ class SymbolTable:
             new_table.visibilities = self.visibilities.copy()
             new_table.finals = self.finals.copy()
             new_table.defining_classes = self.defining_classes.copy()
+            new_table._finals_count = len(new_table.finals)
             return new_table
 
 
 class Context:
+    __slots__ = (
+        "display_name",
+        "parent",
+        "parent_entry_pos",
+        "symbol_table",
+        "depth",
+        "active_class",
+        "is_static",
+        "_tco_func",
+    )
+
     def __init__(self, display_name, parent=None, parent_entry_pos=None):
         self.display_name = display_name
         self.parent = parent
@@ -93,7 +132,19 @@ class Context:
 
 
 class RTResult:
+    __slots__ = (
+        "value",
+        "error",
+        "return_value",
+        "should_return",
+        "should_break",
+        "should_continue",
+    )
+
     def __init__(self):
+        self.reset()
+
+    def reset(self):
         self.value = None
         self.error = None
         self.return_value = None
@@ -101,7 +152,14 @@ class RTResult:
         self.should_break = False
         self.should_continue = False
 
+        return self
+
     def register(self, res):
+        if res.error is None and not (
+            res.should_return or res.should_break or res.should_continue
+        ):
+            return res.value
+
         if res.error:
             self.error = res.error
         if res.should_return:
@@ -111,6 +169,7 @@ class RTResult:
             self.should_break = True
         if res.should_continue:
             self.should_continue = True
+
         return res.value
 
     def success(self, value):

{gladlang-0.2.2 → gladlang-0.2.4}/src/gladlang/values.py

@@ -7,10 +7,21 @@ from .lexer import Token
 from .nodes import *
 
 
+class TailCall:
+    __slots__ = ("function", "args")
+
+    def __init__(self, function, args):
+        self.function = function
+        self.args = args
+
+
 class Value:
+    __slots__ = ("pos_start", "pos_end", "context")
+
     def __init__(self):
-        self.set_pos()
-        self.set_context()
+        self.pos_start = None
+        self.pos_end = None
+        self.context = None
 
     def set_pos(self, pos_start=None, pos_end=None):
         self.pos_start = pos_start
@@ -152,13 +163,32 @@ class Value:
 
 
 class Number(Value):
+    MAX_INT_BITS = 100_000
+
+    __slots__ = ("value",)
+
     def __init__(self, value):
         super().__init__()
         self.value = value
 
     def added_to(self, other):
         if isinstance(other, Number):
-            return Number(self.value + other.value).set_context(self.context), None
+            result = self.value + other.value
+            if isinstance(result, int) and result.bit_length() > Number.MAX_INT_BITS:
+                return None, RTError(
+                    other.pos_start,
+                    other.pos_end,
+                    "Arithmetic result too large (exceeds integer size limit)",
+                    self.context,
+                )
+            if isinstance(result, float) and math.isinf(result):
+                return None, RTError(
+                    other.pos_start,
+                    other.pos_end,
+                    "Arithmetic result is infinite (float overflow)",
+                    self.context,
+                )
+            return Number(result).set_context(self.context), None
         elif isinstance(other, String):
             return String(str(self.value) + other.value).set_context(self.context), None
         else:
@@ -166,13 +196,43 @@ class Number(Value):
 
     def subbed_by(self, other):
         if isinstance(other, Number):
-            return Number(self.value - other.value).set_context(self.context), None
+            result = self.value - other.value
+            if isinstance(result, int) and result.bit_length() > Number.MAX_INT_BITS:
+                return None, RTError(
+                    other.pos_start,
+                    other.pos_end,
+                    "Arithmetic result too large (exceeds integer size limit)",
+                    self.context,
+                )
+            if isinstance(result, float) and math.isinf(result):
+                return None, RTError(
+                    other.pos_start,
+                    other.pos_end,
+                    "Arithmetic result is infinite (float overflow)",
+                    self.context,
+                )
+            return Number(result).set_context(self.context), None
         else:
             return None, Value.illegal_operation(self, other)
 
     def multed_by(self, other):
         if isinstance(other, Number):
-            return Number(self.value * other.value).set_context(self.context), None
+            result = self.value * other.value
+            if isinstance(result, int) and result.bit_length() > Number.MAX_INT_BITS:
+                return None, RTError(
+                    other.pos_start,
+                    other.pos_end,
+                    "Arithmetic result too large (exceeds integer size limit)",
+                    self.context,
+                )
+            if isinstance(result, float) and math.isinf(result):
+                return None, RTError(
+                    other.pos_start,
+                    other.pos_end,
+                    "Arithmetic result is infinite (float overflow)",
+                    self.context,
+                )
+            return Number(result).set_context(self.context), None
         else:
             return None, Value.illegal_operation(self, other)
 
@@ -220,7 +280,7 @@ class Number(Value):
                 )
             try:
                 result = self.value**other.value
-            except (ValueError, ZeroDivisionError) as e:
+            except (ValueError, ZeroDivisionError, OverflowError) as e:
                 return None, RTError(
                     other.pos_start, other.pos_end, str(e), self.context
                 )
@@ -240,6 +300,13 @@ class Number(Value):
                     "Math domain error: result is NaN",
                     self.context,
                 )
+            if isinstance(result, float) and math.isinf(result):
+                return None, RTError(
+                    other.pos_start,
+                    other.pos_end,
+                    f"Arithmetic result is infinite (float overflow)",
+                    self.context,
+                )
             return Number(result).set_context(self.context), None
         else:
             return None, Value.illegal_operation(self, other)
@@ -294,24 +361,27 @@ class Number(Value):
 
     def anded_by(self, other):
         if isinstance(other, Number):
-            return (
-                Number(int(self.value and other.value)).set_context(self.context),
-                None,
-            )
+            if self.is_true() and other.is_true():
+                return Number(1), None
+            else:
+                return Number(0), None
         else:
-            return None, Value.illegal_operation(self, other)
+            return None, self.illegal_operation(other)
 
     def ored_by(self, other):
         if isinstance(other, Number):
-            return (
-                Number(int(self.value or other.value)).set_context(self.context),
-                None,
-            )
+            if self.is_true() or other.is_true():
+                return Number(1), None
+            else:
+                return Number(0), None
         else:
-            return None, Value.illegal_operation(self, other)
+            return None, self.illegal_operation(other)
 
     def notted(self):
-        return Number(1 if self.value == 0 else 0).set_context(self.context), None
+        if self.is_true():
+            return Number(0), None
+        else:
+            return Number(1), None
 
     def bitted_and_by(self, other):
         if isinstance(other, Number):
@@ -369,21 +439,55 @@ class Number(Value):
         return str(self.value)
 
 
-Number.false = Number(0)
-Number.true = Number(1)
-Number.null = Number.false.copy()
+class _FrozenNull(Number):
+    __slots__ = ()
+
+    def set_pos(self, *args):
+        return self
+
+    def set_context(self, *args):
+        return self
+
+    def copy(self):
+        return Number(self.value)
+
+
+Number.false = _FrozenNull(0)
+Number.true = _FrozenNull(1)
+Number.null = _FrozenNull(0)
 
 
 class String(Value):
+    MAX_STRING_SIZE = 10_000_000
+
+    __slots__ = ("value",)
+
     def __init__(self, value):
         super().__init__()
         self.value = value
 
     def added_to(self, other):
         if isinstance(other, String):
+            new_len = len(self.value) + len(other.value)
+            if new_len > String.MAX_STRING_SIZE:
+                return None, RTError(
+                    other.pos_start,
+                    other.pos_end,
+                    f"String concatenation result ({new_len:,} chars) exceeds maximum allowed size ({String.MAX_STRING_SIZE:,} chars)",
+                    self.context,
+                )
             return String(self.value + other.value).set_context(self.context), None
         elif isinstance(other, Number):
-            return String(self.value + str(other.value)).set_context(self.context), None
+            suffix = str(other.value)
+            new_len = len(self.value) + len(suffix)
+            if new_len > String.MAX_STRING_SIZE:
+                return None, RTError(
+                    other.pos_start,
+                    other.pos_end,
+                    f"String concatenation result exceeds maximum allowed size ({String.MAX_STRING_SIZE:,} chars)",
+                    self.context,
+                )
+            return String(self.value + suffix).set_context(self.context), None
         else:
             return None, self.illegal_operation(other)
 
@@ -471,6 +575,8 @@ class String(Value):
 class List(Value):
     MAX_LIST_SIZE = 1_000_000
 
+    __slots__ = ("elements",)
+
     def __init__(self, elements):
         super().__init__()
         self.elements = elements
@@ -480,6 +586,15 @@ class List(Value):
 
     def added_to(self, other):
         if isinstance(other, List):
+            new_len = len(self.elements) + len(other.elements)
+            if new_len > List.MAX_LIST_SIZE:
+                return None, RTError(
+                    other.pos_start,
+                    other.pos_end,
+                    f"List concatenation result ({new_len}) exceeds maximum "
+                    f"allowed size ({List.MAX_LIST_SIZE})",
+                    self.context,
+                )
             new_list = List(self.elements + other.elements)
             new_list.set_context(self.context)
             return new_list, None
@@ -605,6 +720,8 @@ class List(Value):
 class Dict(Value):
     MAX_DICT_SIZE = 1_000_000
 
+    __slots__ = ("elements",)
+
     def __init__(self, elements):
         super().__init__()
         self.elements = elements
@@ -661,6 +778,14 @@ class Dict(Value):
                 self.context,
             )
 
+        if key.value not in self.elements and len(self.elements) >= Dict.MAX_DICT_SIZE:
+            return None, RTError(
+                self.pos_start,
+                self.pos_end,
+                f"Dict size limit ({Dict.MAX_DICT_SIZE:,} entries) reached. Cannot insert more keys.",
+                self.context,
+            )
+
         self.elements[key.value] = value
         return value, None
 
@@ -731,6 +856,8 @@ class Dict(Value):
 
 
 class BaseFunction(Value):
+    __slots__ = ("name",)
+
     def __init__(self, name):
         super().__init__()
         self.name = name or "<anonymous>"
@@ -793,6 +920,16 @@ class BaseFunction(Value):
 
 
 class Function(BaseFunction):
+    __slots__ = (
+        "body_node",
+        "arg_name_toks",
+        "arg_names",
+        "context",
+        "visibility",
+        "defining_class",
+        "is_static",
+    )
+
     def __init__(
         self,
         name,
@@ -814,35 +951,60 @@ class Function(BaseFunction):
 
     def execute(self, args, interpreter):
         res = RTResult()
+        current_func = self
+        current_args = args
+        base_depth = None
+
+        while True:
+            new_context = current_func.generate_new_context()
+            new_context.active_class = current_func.defining_class
+            new_context.is_static = current_func.is_static
+
+            if base_depth is None:
+                base_depth = new_context.depth
+                if base_depth > 2000:
+                    return res.failure(
+                        RTError(
+                            current_func.pos_start,
+                            current_func.pos_end,
+                            "Recursion limit exceeded",
+                            current_func.context,
+                        )
+                    )
+            else:
+                new_context.depth = base_depth
 
-        new_context = self.generate_new_context()
-
-        new_context.active_class = self.defining_class
-        new_context.is_static = self.is_static
+            new_context._tco_func = current_func
 
-        if new_context.depth > 250:
-            return res.failure(
-                RTError(
-                    self.pos_start,
-                    self.pos_end,
-                    "Recursion limit exceeded",
-                    self.context,
+            res.register(
+                current_func.check_and_populate_args(
+                    current_func.arg_names, current_args, new_context
                 )
             )
 
-        res.register(self.check_and_populate_args(self.arg_names, args, new_context))
-        if res.error:
-            return res
+            if res.error:
+                return res
+
+            value_result = interpreter.visit(current_func.body_node, new_context)
+            if value_result.error:
+                return value_result
 
-        value_result = interpreter.visit(self.body_node, new_context)
+            if value_result.should_return:
+                ret_val = value_result.return_value
+                if isinstance(ret_val, TailCall):
+                    callee = ret_val.function
 
-        if value_result.error:
-            return value_result
+                    if isinstance(callee, BoundMethod):
+                        current_func = callee.function_to_bind
+                    else:
+                        current_func = callee
 
-        if value_result.should_return:
-            return res.success(value_result.return_value)
+                    current_args = ret_val.args
+                    res = RTResult()
+                    continue
+                return res.success(ret_val)
 
-        return res.success(value_result.value or Number.null.copy())
+            return res.success(value_result.value or Number.null.copy())
 
     def copy(self):
         copy = Function(
@@ -861,6 +1023,8 @@ class Function(BaseFunction):
 
 
 class FunctionGroup(BaseFunction):
+    __slots__ = ("functions", "visibility", "is_static", "defining_class")
+
     def __init__(self, name):
         super().__init__(name)
         self.functions = {}
@@ -934,6 +1098,8 @@ class FunctionGroup(BaseFunction):
 
 
 class Class(BaseFunction):
+    __slots__ = ("superclasses", "methods", "static_symbol_table", "mro")
+
     def __init__(self, name, superclasses, methods, static_symbol_table=None, mro=None):
         super().__init__(name)
         self.superclasses = superclasses
@@ -1135,6 +1301,8 @@ class Class(BaseFunction):
 
 
 class Instance(Value):
+    __slots__ = ("class_ref", "symbol_table")
+
     def __init__(self, class_ref):
         super().__init__()
         self.class_ref = class_ref
@@ -1337,6 +1505,8 @@ class Instance(Value):
 
 
 class Super(Value):
+    __slots__ = ("instance", "start_class")
+
     def __init__(self, instance, start_class):
         super().__init__()
         self.instance = instance
@@ -1418,6 +1588,8 @@ class Super(Value):
 
 
 class Type(Value):
+    __slots__ = ("name",)
+
     def __init__(self, name):
         super().__init__()
         self.name = name
@@ -1434,6 +1606,8 @@ class Type(Value):
 
 
 class Enum(Value):
+    __slots__ = ("name", "elements_dict")
+
     def __init__(self, name, elements_dict):
         super().__init__()
         self.name = name
@@ -1480,13 +1654,21 @@ class Enum(Value):
 
 
 class BoundMethod(BaseFunction):
+    __slots__ = (
+        "function_to_bind",
+        "instance",
+        "context",
+        "visibility",
+        "defining_class",
+        "is_static",
+    )
+
     def __init__(self, name, function_to_bind, instance):
         super().__init__(name)
         self.function_to_bind = function_to_bind
         self.instance = instance
         self.context = function_to_bind.context
         self.set_pos(function_to_bind.pos_start, function_to_bind.pos_end)
-
         self.visibility = getattr(function_to_bind, "visibility", "PUBLIC")
         self.defining_class = getattr(function_to_bind, "defining_class", None)
         self.is_static = getattr(function_to_bind, "is_static", False)
@@ -1501,43 +1683,74 @@ class BoundMethod(BaseFunction):
             full_args = [self.instance] + args
             return self.function_to_bind.execute(full_args, interpreter)
 
-        new_context = self.function_to_bind.generate_new_context()
-
-        new_context.active_class = self.function_to_bind.defining_class
-
-        new_context.is_static = self.function_to_bind.is_static
+        current_func = self.function_to_bind
+        current_instance = self.instance
+        current_args = args
+        base_depth = None
+
+        while True:
+            new_context = current_func.generate_new_context()
+            new_context.active_class = current_func.defining_class
+            new_context.is_static = current_func.is_static
+
+            if base_depth is None:
+                base_depth = new_context.depth
+                if base_depth > 2000:
+                    return res.failure(
+                        RTError(
+                            current_func.pos_start,
+                            current_func.pos_end,
+                            "Recursion limit exceeded",
+                            current_func.context,
+                        )
+                    )
+            else:
+                new_context.depth = base_depth
 
-        original_arg_names = self.function_to_bind.arg_names
+            new_context.symbol_table.set("THIS", current_instance)
+            new_context._tco_func = current_func
 
-        new_context.symbol_table.set("THIS", self.instance)
+            original_arg_names = current_func.arg_names
+            actual_args = current_args
 
-        actual_args = args
-        if len(args) > 0 and args[0] is self.instance:
-            actual_args = args[1:]
+            if len(actual_args) > 0 and actual_args[0] is current_instance:
+                actual_args = actual_args[1:]
 
-        if len(original_arg_names) > 0 and original_arg_names[0] == "THIS":
-            expected_arg_names = original_arg_names[1:]
-        else:
-            expected_arg_names = original_arg_names
+            if len(original_arg_names) > 0 and original_arg_names[0] == "THIS":
+                expected_arg_names = original_arg_names[1:]
+            else:
+                expected_arg_names = original_arg_names
 
-        res.register(
-            self.function_to_bind.check_and_populate_args(
-                expected_arg_names, actual_args, new_context
+            res.register(
+                current_func.check_and_populate_args(
+                    expected_arg_names, actual_args, new_context
+                )
             )
-        )
 
-        if res.error:
-            return res
+            if res.error:
+                return res
 
-        value_result = interpreter.visit(self.function_to_bind.body_node, new_context)
+            value_result = interpreter.visit(current_func.body_node, new_context)
+            if value_result.error:
+                return value_result
 
-        if value_result.error:
-            return value_result
+            if value_result.should_return:
+                ret_val = value_result.return_value
+                if isinstance(ret_val, TailCall):
+                    callee = ret_val.function
 
-        if value_result.should_return:
-            return res.success(value_result.return_value)
+                    if isinstance(callee, BoundMethod):
+                        current_func = callee.function_to_bind
+                        current_instance = callee.instance
+                    else:
+                        current_func = callee
 
-        return res.success(value_result.value or Number.null.copy())
+                    current_args = ret_val.args
+                    res = RTResult()
+                    continue
+                return res.success(ret_val)
+
+            return res.success(value_result.value or Number.null.copy())
 
     def copy(self):
         return (
@@ -1548,6 +1761,8 @@ class BoundMethod(BaseFunction):
 
 
 class BuiltInFunction(BaseFunction):
+    __slots__ = ()
+
     def __init__(self, name):
         super().__init__(name)
 
@@ -1672,8 +1887,10 @@ class BuiltInFunction(BaseFunction):
             if res.error:
                 return res
 
-            is_true = args[0].is_true()
-            return res.success(Number.true.copy() if is_true else Number.false.copy())
+            if args[0].is_true():
+                return res.success(Number(1))
+            else:
+                return res.success(Number(0))
 
         elif self.name == "LEN":
             res.register(self.check_args(["value"], args))
@@ -1703,6 +1920,14 @@ class BuiltInFunction(BaseFunction):
                         self.context,
                     )
                 )
+        return res.failure(
+            RTError(
+                self.pos_start,
+                self.pos_end,
+                f"Unknown built-in function '{self.name}'",
+                self.context,
+            )
+        )
 
     def copy(self):
         copy = BuiltInFunction(self.name)

{gladlang-0.2.2 → gladlang-0.2.4/src/gladlang.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gladlang
-Version: 0.2.2
+Version: 0.2.4
 Summary: The GladLang Interpreter
 Author: Glad432
 License: Copyright (c) 2025 - present GLAD432
@@ -465,7 +465,7 @@ LET b = 3  # Binary 011
 PRINTLN a & b   # 1 (AND)
 PRINTLN a | b   # 7 (OR)
 PRINTLN a ^ b   # 6 (XOR)
-PRINTLN ~a      # -6 (NOT)
+PRINTLN ~a      # 4294967290 (bitwise NOT as unsigned 32‑bit integer)
 PRINTLN 1 << 2  # 4 (Left Shift)
 PRINTLN 8 >> 2  # 2 (Right Shift)