solpl 2.2.0__tar.gz → 2.3.0__tar.gz

{solpl-2.2.0/solpl.egg-info → solpl-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solpl
-Version: 2.2.0
+Version: 2.3.0
 Summary: Sol Programming Language Interpreter
 Requires-Python: >=3.7
 License-File: LICENSE

solpl-2.3.0/interpreter/sol.py

@@ -0,0 +1,342 @@
+import threading
+import time
+import sys
+import os
+import urllib.request
+import http.server
+
+class ReturnSignal(Exception):
+    def __init__(self, value):
+        self.value = value
+
+class SolInterpreter:
+    def __init__(self):
+        self.variables = {}
+        self.thread_local = threading.local()
+        self.functions = {}
+        self.struct_blueprints = {} 
+        self.lines = []
+        self.threads = []
+        self._server_started = False 
+
+    @property
+    def scope_stack(self):
+        if not hasattr(self.thread_local, "stack"):
+            self.thread_local.stack = [self.variables]
+        return self.thread_local.stack
+
+    def _import_file(self, filename):
+        if not os.path.exists(filename):
+            print(f"Error: Module '{filename}' not found.")
+            return
+
+        with open(filename, "r") as f:
+            code = f.read()
+            module_name = filename.replace(".sol", "")
+            lines = [l.strip() for l in code.split('\n') if l.strip()]
+            for pc, line in enumerate(lines):
+                if "(" in line and ")" in line and "main" not in line and "end" not in line and "->" not in line and ">>" not in line and "?" not in line and not line.startswith(("if ", "while ", "for ", "elseif", "else")):
+                    parts = line.split("(")
+                    name = parts[0].strip()
+                    params_str = parts[1].replace(")", "").strip()
+                    params = [p.strip() for p in params_str.split(",")] if params_str else []
+                    self.functions[f"{module_name}.{name}"] = {"start_pc": pc + 1, "params": params, "source_lines": lines}
+
+    def _compute(self, expr):
+        expr = str(expr).strip()
+        if "+" in expr and any(c.isalpha() or c in ['"', "'"] for c in expr):
+            parts = expr.split("+")
+            result = ""
+            for p in parts:
+                val = self._resolve(p.strip())
+                result += str(val) if val is not None else ""
+            return result
+        ops = ['+', '-', '*', ':']
+        for op in ops:
+            if op in expr:
+                try:
+                    left, right = expr.split(op, 1)
+                    r1 = self._resolve(left)
+                    r2 = self._resolve(right)
+                    if r1 is None or r2 is None: continue
+                    val1 = float(r1)
+                    val2 = float(r2)
+                    if op == '+': return val1 + val2
+                    if op == '-': return val1 - val2
+                    if op == '*': return val1 * val2
+                    if op == ':': return val1 / val2
+                except (ValueError, TypeError): continue
+        return self._resolve(expr)
+
+    def _lookup(self, name):
+        for scope in reversed(self.scope_stack):
+            if name in scope: return scope[name]
+        return None
+
+    def _assign(self, name, val):
+        self.scope_stack[-1][name] = val
+
+    def _resolve(self, val):
+        val = str(val).strip()
+        if (val.startswith('"') and val.endswith('"')) or (val.startswith("'") and val.endswith("'")):
+            return val[1:-1]
+        if val.startswith("_fetch(") and val.endswith(")"):
+            url_expr = val[7:-1].strip()
+            return self._native_fetch(str(self._compute(url_expr)))
+        if "(" in val and val.endswith(")") and not val.startswith("_"):
+            parts = val.split("(", 1)
+            name = parts[0].strip()
+            if name in self.functions:
+                args_str = parts[1][:-1].strip()
+                args = [self._compute(a.strip()) for a in args_str.split(",")] if args_str else []
+                return self._call_function(name, args)
+        if "[" in val and "]" in val:
+            try:
+                name, idx_part = val.split("[")
+                idx = int(idx_part.replace("]", "").strip())
+                container = self._lookup(name)
+                if isinstance(container, list): return container[idx]
+            except (ValueError, IndexError, KeyError): pass
+        if "." in val:
+            obj_name, prop = val.split(".", 1)
+            obj = self._lookup(obj_name)
+            if isinstance(obj, dict): return obj.get(prop, 0)
+        existing_val = self._lookup(val)
+        if existing_val is not None: return existing_val
+        try: return float(val) if '.' in val else int(val)
+        except: return None 
+
+    def _async_worker(self, expr, action):
+        result = self._compute(expr)
+        if action == "_out": print(f"[ASYNC OUTPUT] {result}")
+
+    def _async_input_worker(self, prompt, var_name):
+        user_val = input(prompt)
+        try:
+            if '.' in user_val: user_val = float(user_val)
+            else: user_val = int(user_val)
+        except ValueError: pass
+        self._assign(var_name, user_val)
+
+    def _native_fetch(self, url):
+        try:
+            with urllib.request.urlopen(url, timeout=5) as response:
+                return response.read().decode('utf-8', errors='replace')
+        except Exception as e: return f"Error: {str(e)}"
+
+    def _native_listen(self, port, handler_name):
+        if self._server_started: return
+        self._server_started = True
+        interpreter_instance = self
+        class SolHTTPHandler(http.server.BaseHTTPRequestHandler):
+            def do_GET(self):
+                self.send_response(200)
+                self.send_header("Content-type", "text/html")
+                self.end_headers()
+                response_body = interpreter_instance._call_function(handler_name, [self.path])
+                self.wfile.write(bytes(str(response_body), "utf-8"))
+            def log_message(self, format, *args): pass 
+        def server_thread():
+            server = http.server.HTTPServer(("0.0.0.0", int(port)), SolHTTPHandler)
+            server.serve_forever()
+        t = threading.Thread(target=server_thread, daemon=True)
+        t.start()
+        self.threads.append(t)
+
+    def _evaluate_condition(self, cond):
+        if "=" in cond:
+            left, right = cond.split("=")
+            return self._compute(left.strip()) == self._compute(right.strip())
+        elif "<" in cond:
+            left, right = cond.split("<")
+            return self._compute(left.strip()) < self._compute(right.strip())
+        elif ">" in cond:
+            left, right = cond.split(">")
+            return self._compute(left.strip()) > self._compute(right.strip())
+        return False
+
+    def _get_block_end(self, start_pc):
+        depth = 1
+        pc = start_pc + 1
+        while pc < len(self.lines):
+            line = self.lines[pc]
+            if line.startswith("if ") or line.startswith("while ") or line.startswith("for "): depth += 1
+            elif line == "end":
+                depth -= 1
+                if depth == 0: return pc
+            pc += 1
+        return pc
+
+    def execute(self, code):
+        self.lines = [l.strip() for l in code.split('\n') if l.strip() and ';' not in l or (';' in l and l.split(';', 1)[0].strip())]
+        self.lines = [l.split(';', 1)[0].strip() for l in self.lines]
+        self.threads = []
+        pc = 0
+        while pc < len(self.lines):
+            line = self.lines[pc]
+            if "(" in line and ")" in line and "main" not in line and "end" not in line and "->" not in line and ">>" not in line and "?" not in line and not line.startswith(("if ", "while ", "for ", "elseif", "else")):
+                parts = line.split("(")
+                self.functions[parts[0].strip()] = {"start_pc": pc + 1, "params": [p.strip() for p in parts[1].replace(")", "").split(",")] if parts[1].replace(")", "").strip() else []}
+            elif "{" in line: pc = self._parse_struct(pc)
+            pc += 1
+        for i, line in enumerate(self.lines):
+            if line == "main()":
+                try: self._run_block(i + 1)
+                except ReturnSignal: pass
+                break
+        for t in self.threads:
+            if t.is_alive() and not t.daemon: t.join()
+
+    def _parse_struct(self, pc):
+        struct_name = self.lines[pc].split("{}")[0].strip()
+        fields = {}
+        pc += 1
+        while pc < len(self.lines) and self.lines[pc] != "end":
+            if "->" in self.lines[pc]:
+                key, val = [x.strip() for x in self.lines[pc].split("->")]
+                fields[key] = self._resolve(val)
+            pc += 1
+        self.struct_blueprints[struct_name] = fields
+        self._assign(struct_name, fields.copy())
+        return pc
+
+    def _call_function(self, name, args):
+        if "." in name and name in self.functions:
+            orig_lines = self.lines
+            self.lines = self.functions[name]["source_lines"]
+            res = self._run_with_scope(self.functions[name]["start_pc"], self.functions[name]["params"], args)
+            self.lines = orig_lines
+            return res
+        return self._run_with_scope(self.functions[name]["start_pc"], self.functions[name]["params"], args)
+
+    def _run_with_scope(self, start_pc, params, args):
+        local_scope = {p: a for p, a in zip(params, args)}
+        self.scope_stack.append(local_scope)
+        try: self._run_block(start_pc)
+        except ReturnSignal as sig: return sig.value
+        finally: self.scope_stack.pop()
+        return 0
+
+    def _execute_line(self, line):
+        if "_get(" in line:
+            filename = line.split('"')[1]
+            self._import_file(filename)
+            return
+        if ">>" in line and "_input" in line:
+            parts = [p.strip() for p in line.split(">>")]
+            t = threading.Thread(target=self._async_input_worker, args=(str(self._compute(parts[0])), parts[2]))
+            t.start(); self.threads.append(t); return
+        is_async_func = ">>" in line and "_async" in line and "(" in line and not line.startswith("_")
+        if is_async_func: line = line.split(">>")[0].strip()
+        if line.startswith("_return ->"): raise ReturnSignal(self._compute(line.split("->", 1)[1]))
+        elif ">>" in line and "_async" in line:
+            parts = line.split(">>")
+            t = threading.Thread(target=self._async_worker, args=(parts[0].strip(), parts[2].strip()))
+            t.start(); self.threads.append(t)
+        elif line.startswith("_in"):
+            prompt = line.split('(')[1].split(')')[0].replace('"', '').replace("'", "") if "(" in line else f"Input {line.split('->')[1].strip()}: "
+            sys.stdout.write(prompt + " "); sys.stdout.flush()
+            val = sys.stdin.readline().strip()
+            try: self._assign(line.split("->")[1].strip(), float(val) if '.' in val else int(val))
+            except: self._assign(line.split("->")[1].strip(), val)
+        elif "_add(" in line:
+            parts = [p.strip() for p in line.replace("_add(", "").replace(")", "").split(",")]
+            container = self._lookup(parts[0])
+            if isinstance(container, list): container.insert(int(parts[1]), self._resolve(parts[2]))
+        elif "_remove(" in line:
+            parts = [p.strip() for p in line.replace("_remove(", "").replace(")", "").split(",")]
+            container = self._lookup(parts[0])
+            if isinstance(container, list): container.pop(int(parts[1]))
+        elif "_listen(" in line:
+            p, h = [p.strip() for p in line.replace("_listen(", "").replace(")", "").split(",")]
+            self._native_listen(self._compute(p), h)
+        elif "_out" in line:
+            val = self._compute(line.split("->")[1].strip())
+            print(val if val is not None else "Error")
+        elif "mylist<" in line: self._assign(line.split("<")[1].split(">")[0], [])
+        elif "->" in line:
+            var, val = [x.strip() for x in line.split("->")]
+            if "." in var:
+                obj, prop = var.split(".", 1)
+                target = self._lookup(obj)
+                if isinstance(target, dict): target[prop] = self._compute(val)
+            else: self._assign(var, self._compute(val))
+        elif "(" in line and line.endswith(")") and not line.startswith("_"):
+            parts = line.split("(")
+            if is_async_func:
+                t = threading.Thread(target=self._call_function, args=(parts[0].strip(), [self._compute(a.strip()) for a in parts[1].replace(")", "").split(",")]))
+                t.start(); self.threads.append(t)
+            else: self._call_function(parts[0].strip(), [self._compute(a.strip()) for a in parts[1].replace(")", "").split(",")])
+
+    def _run_block(self, start_pc):
+        pc = start_pc
+        control_stack = [] 
+        while pc < len(self.lines):
+            line = self.lines[pc]
+            is_executing = all(level["executing"] for level in control_stack)
+            if line.startswith("if "):
+                control_stack.append({"type": "if", "executing": is_executing and self._evaluate_condition(line.split("if ", 1)[1].strip()), "any_branch_true": False})
+                pc += 1; continue
+            elif line.startswith("elseif "):
+                cond = line.split("elseif ", 1)[1].strip()
+                parent_active = all(level["executing"] for level in control_stack[:-1]) if len(control_stack) > 1 else True
+                if control_stack and control_stack[-1]["type"] == "if":
+                    if parent_active and not control_stack[-1]["any_branch_true"] and self._evaluate_condition(cond):
+                        control_stack[-1]["executing"] = True
+                        control_stack[-1]["any_branch_true"] = True
+                    else: control_stack[-1]["executing"] = False
+                pc += 1; continue
+            elif line == "else":
+                parent_active = all(level["executing"] for level in control_stack[:-1]) if len(control_stack) > 1 else True
+                if control_stack and control_stack[-1]["type"] == "if":
+                    control_stack[-1]["executing"] = parent_active and not control_stack[-1]["any_branch_true"]
+                pc += 1; continue
+            elif line.startswith("while "):
+                cond = line.split("while ", 1)[1].strip()
+                end_pc = self._get_block_end(pc)
+                if is_executing and self._evaluate_condition(cond):
+                    control_stack.append({"type": "while", "executing": True, "start_pc": pc, "end_pc": end_pc})
+                    pc += 1
+                else: pc = end_pc + 1
+                continue
+            elif line.startswith("for "):
+                parts = line.split("for ", 1)[1].split("->")
+                var_name = parts[0].strip()
+                start_v = int(self._compute(parts[1].split(" to ")[0].strip()))
+                end_v = int(self._compute(parts[1].split(" to ")[1].strip()))
+                end_pc = self._get_block_end(pc)
+                if is_executing and start_v <= end_v:
+                    self._assign(var_name, start_v)
+                    control_stack.append({"type": "for", "executing": True, "var": var_name, "end_val": end_v, "start_pc": pc, "end_pc": end_pc})
+                    pc += 1
+                else: pc = end_pc + 1
+                continue
+            elif line == "end":
+                if control_stack:
+                    top = control_stack.pop()
+                    if top.get("type") == "while" and top["executing"]: pc = top["start_pc"] - 1
+                    elif top.get("type") == "for" and top["executing"]:
+                        curr = self._lookup(top["var"]) + 1
+                        if curr <= top["end_val"]:
+                            self._assign(top["var"], curr)
+                            pc = top["start_pc"] - 1
+                pc += 1; continue
+            if is_executing:
+                if "?" in line:
+                    cond, action = line.split("?", 1)
+                    if self._evaluate_condition(cond.strip()): self._execute_line(action.strip())
+                else: self._execute_line(line)
+            pc += 1
+
+def main():
+    engine = SolInterpreter()
+    if not sys.stdin.isatty():
+        code = sys.stdin.read()
+    elif len(sys.argv) > 1:
+        with open(sys.argv[1], "r") as f: code = f.read()
+    else:
+        print("Usage: solpl <file.sol> OR cat file.sol | python sol.py"); sys.exit(1)
+    engine.execute(code)
+
+if __name__ == "__main__":
+    main()

{solpl-2.2.0 → solpl-2.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "solpl"
-version = "2.2.0"
+version = "2.3.0"
 description = "Sol Programming Language Interpreter"
 requires-python = ">=3.7"
 

{solpl-2.2.0 → solpl-2.3.0/solpl.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solpl
-Version: 2.2.0
+Version: 2.3.0
 Summary: Sol Programming Language Interpreter
 Requires-Python: >=3.7
 License-File: LICENSE

solpl-2.2.0/interpreter/sol.py

@@ -1,462 +0,0 @@
-import math
-import threading
-import time
-import sys
-import os
-import urllib.request
-import http.server
-
-class ReturnSignal(Exception):
-    def __init__(self, value):
-        self.value = value
-
-class SolInterpreter:
-    def __init__(self):
-        self.variables = {}
-        self.thread_local = threading.local()
-        self.functions = {}
-        self.struct_blueprints = {} 
-        self.lines = []
-        self.threads = []
-
-    @property
-    def scope_stack(self):
-        if not hasattr(self.thread_local, "stack"):
-            self.thread_local.stack = [self.variables]
-        return self.thread_local.stack
-
-    def _compute(self, expr):
-        expr = str(expr).strip()
-        
-        if "+" in expr and any(c.isalpha() or c in ['"', "'"] for c in expr):
-            parts = expr.split("+")
-            result = ""
-            for p in parts:
-                val = str(self._resolve(p.strip()))
-                result += val
-            return result
-
-        ops = ['+', '-', '*', ':']
-        for op in ops:
-            if op in expr:
-                try:
-                    left, right = expr.split(op, 1)
-                    val1 = float(self._resolve(left))
-                    val2 = float(self._resolve(right))
-                    if op == '+': return val1 + val2
-                    if op == '-': return val1 - val2
-                    if op == '*': return val1 * val2
-                    if op == ':': return val1 / val2
-                except ValueError:
-                    continue
-        return self._resolve(expr)
-
-    def _lookup(self, name):
-        for scope in reversed(self.scope_stack):
-            if name in scope:
-                return scope[name]
-        return None
-
-    def _assign(self, name, val):
-        self.scope_stack[-1][name] = val
-
-    def _resolve(self, val):
-        val = str(val).strip()
-
-        if val.startswith("_fetch(") and val.endswith(")"):
-            url_expr = val[7:-1].strip()
-            url = str(self._compute(url_expr))
-            return self._native_fetch(url)
-
-        if "(" in val and val.endswith(")") and not val.startswith("_"):
-            parts = val.split("(", 1)
-            name = parts[0].strip()
-            if name in self.functions:
-                args_str = parts[1][:-1].strip()
-                args = [self._compute(a.strip()) for a in args_str.split(",")] if args_str else []
-                return self._call_function(name, args)
-
-        if "[" in val and "]" in val:
-            try:
-                name, idx_part = val.split("[")
-                idx = int(idx_part.replace("]", "").strip())
-                container = self._lookup(name)
-                if isinstance(container, list):
-                    return container[idx]
-            except (ValueError, IndexError, KeyError): pass
-        if "." in val:
-            obj_name, prop = val.split(".", 1)
-            obj = self._lookup(obj_name)
-            if isinstance(obj, dict):
-                return obj.get(prop, 0)
-
-        existing_val = self._lookup(val)
-        if existing_val is not None: return existing_val
-        try: return float(val) if '.' in val else int(val)
-        except: return val.replace('"', '').replace("'", "")
-
-    def _async_worker(self, expr, action):
-        result = self._compute(expr)
-        if action == "_out":
-            print(f"[ASYNC OUTPUT] {result}")
-
-    def _async_input_worker(self, prompt, var_name):
-        user_val = input(prompt)
-        try:
-            if '.' in user_val: user_val = float(user_val)
-            else: user_val = int(user_val)
-        except ValueError: pass
-        self._assign(var_name, user_val)
-
-    def _native_fetch(self, url):
-        try:
-            with urllib.request.urlopen(url, timeout=5) as response:
-                # Fix: Added errors='replace' to handle non-UTF-8 bytes safely
-                return response.read().decode('utf-8', errors='replace')
-        except Exception as e:
-            return f"Error fetching URL: {str(e)}"
-
-    def _native_listen(self, port, handler_name):
-        interpreter_instance = self
-        class SolHTTPHandler(http.server.BaseHTTPRequestHandler):
-            def do_GET(self):
-                self.send_response(200)
-                self.send_header("Content-type", "text/html")
-                self.end_headers()
-                response_body = interpreter_instance._call_function(handler_name, [self.path])
-                self.wfile.write(bytes(str(response_body), "utf-8"))
-            def log_message(self, format, *args):
-                pass 
-
-        def server_thread():
-            server = http.server.HTTPServer(("0.0.0.0", int(port)), SolHTTPHandler)
-            server.serve_forever()
-
-        t = threading.Thread(target=server_thread, daemon=True)
-        t.start()
-        self.threads.append(t)
-
-    def _evaluate_condition(self, cond):
-        if "=" in cond:
-            left, right = cond.split("=")
-            return self._compute(left.strip()) == self._compute(right.strip())
-        elif "<" in cond:
-            left, right = cond.split("<")
-            return self._compute(left.strip()) < self._compute(right.strip())
-        elif ">" in cond:
-            left, right = cond.split(">")
-            return self._compute(left.strip()) > self._compute(right.strip())
-        return False
-
-    def _get_block_end(self, start_pc):
-        depth = 1
-        pc = start_pc + 1
-        while pc < len(self.lines):
-            line = self.lines[pc]
-            if line.startswith("if ") or line.startswith("while ") or line.startswith("for "):
-                depth += 1
-            elif line == "end":
-                depth -= 1
-                if depth == 0:
-                    return pc
-            pc += 1
-        return pc
-
-    def execute(self, code):
-        self.lines = []
-        for raw_line in code.split('\n'):
-            if ';' in raw_line:
-                raw_line = raw_line.split(';', 1)[0]
-            trimmed = raw_line.strip()
-            if trimmed:
-                self.lines.append(trimmed)
-
-        self.threads = []
-
-        pc = 0
-        while pc < len(self.lines):
-            line = self.lines[pc]
-            if "(" in line and ")" in line and "main" not in line and "end" not in line and "->" not in line and ">>" not in line and "?" not in line and not line.startswith("if ") and not line.startswith("while ") and not line.startswith("for "):
-                parts = line.split("(")
-                name = parts[0].strip()
-                params_str = parts[1].replace(")", "").strip()
-                params = [p.strip() for p in params_str.split(",")] if params_str else []
-                self.functions[name] = {"start_pc": pc + 1, "params": params}
-            elif "{" in line:
-                pc = self._parse_struct(pc)
-                continue
-            pc += 1
-
-        for i, line in enumerate(self.lines):
-            if line == "main()":
-                try:
-                    self._run_block(i + 1)
-                except ReturnSignal:
-                    pass
-                break
-
-        for t in self.threads:
-            if t.is_alive() and not t.daemon:
-                t.join()
-
-    def _parse_struct(self, pc):
-        line = self.lines[pc]
-        struct_name = line.split("{}")[0].strip()
-        fields = {}
-        pc += 1
-        while pc < len(self.lines) and self.lines[pc] != "end":
-            if "->" in self.lines[pc]:
-                key, val = [x.strip() for x in self.lines[pc].split("->")]
-                fields[key] = self._resolve(val)
-            pc += 1
-        self.struct_blueprints[struct_name] = fields
-        self._assign(struct_name, fields.copy())
-        return pc
-
-    def _call_function(self, name, args):
-        func_info = self.functions[name]
-        start_pc = func_info["start_pc"]
-        params = func_info["params"]
-
-        local_scope = {}
-        for param, arg in zip(params, args):
-            local_scope[param] = arg
-
-        self.scope_stack.append(local_scope)
-
-        return_value = 0
-        try:
-            self._run_block(start_pc)
-        except ReturnSignal as sig:
-            return_value = sig.value
-        finally:
-            self.scope_stack.pop()
-
-        return return_value
-
-    def _execute_line(self, line):
-        if ">>" in line and "_input" in line:
-            parts = [p.strip() for p in line.split(">>")]
-            if len(parts) == 3 and parts[1] == "_input":
-                prompt_string = str(self._compute(parts[0]))
-                target_variable = parts[2]
-                
-                t = threading.Thread(target=self._async_input_worker, args=(prompt_string, target_variable))
-                t.start()
-                self.threads.append(t)
-                return
-
-        is_async_func = False
-        if ">>" in line and "_async" in line and "(" in line and not line.startswith("_"):
-            is_async_func = True
-            line = line.split(">>")[0].strip()
-
-        if line.startswith("_return ->"):
-            val_expr = line.split("->", 1)[1].strip()
-            result = self._compute(val_expr)
-            raise ReturnSignal(result)
-
-        elif ">>" in line and "_async" in line and not is_async_func:
-            parts = line.split(">>")
-            t = threading.Thread(target=self._async_worker, args=(parts[0].strip(), parts[2].strip()))
-            t.start()
-            self.threads.append(t)
-
-        elif line.startswith("_in"):
-            if "(" in line and ")" in line:
-                parts = line.split("(")
-                prompt = parts[1].split(")")[0].strip().replace('"', '').replace("'", "")
-                var_name = line.split("->")[1].strip()
-            else:
-                var_name = line.split("->")[1].strip()
-                prompt = f"[INPUT REQUIRED FOR %s]: " % var_name
-            
-            user_val = input(prompt + " ")
-            try:
-                if '.' in user_val: user_val = float(user_val)
-                else: user_val = int(user_val)
-            except ValueError: pass
-            self._assign(var_name, user_val)
-
-        elif "_add(" in line:
-            content = line.replace("_add(", "").replace(")", "")
-            parts = [p.strip() for p in content.split(",")]
-            container = self._lookup(parts[0])
-            if isinstance(container, list):
-                container.insert(int(parts[1]), self._resolve(parts[2]))
-        elif "_remove(" in line:
-            content = line.replace("_remove(", "").replace(")", "")
-            parts = [p.strip() for p in content.split(",")]
-            container = self._lookup(parts[0])
-            if isinstance(container, list):
-                container.pop(int(parts[1]))
-        elif "_listen(" in line:
-            content = line.replace("_listen(", "").replace(")", "")
-            port_expr, handler_expr = [p.strip() for p in content.split(",")]
-            port = self._compute(port_expr)
-            self._native_listen(port, handler_expr)
-        elif "_out" in line:
-            val = line.split("->")[1].strip()
-            print(self._compute(val))
-
-        elif "mylist<" in line and ">" in line:
-            var_name = line.split("<")[1].split(">")[0]
-            self._assign(var_name, [])
-
-        elif "->" in line:
-            var, val = [x.strip() for x in line.split("->")]
-            if "." in var:
-                obj, prop = var.split(".", 1)
-                target_obj = self._lookup(obj)
-                if isinstance(target_obj, dict):
-                    target_obj[prop] = self._compute(val)
-            else:
-                self._assign(var, self._compute(val))
-        else:
-            if "(" in line and line.endswith(")") and not line.startswith("_"):
-                parts = line.split("(")
-                name = parts[0].strip()
-                if name in self.functions:
-                    args_str = parts[1][:-1].strip()
-                    args = [self._compute(a.strip()) for a in args_str.split(",")] if args_str else []
-
-                    if is_async_func:
-                        t = threading.Thread(target=self._call_function, args=(name, args))
-                        t.start()
-                        self.threads.append(t)
-                    else:
-                        self._call_function(name, args)
-
-    def _run_block(self, start_pc):
-        pc = start_pc
-        control_stack = [] 
-
-        while pc < len(self.lines):
-            line = self.lines[pc]
-            is_executing = all(level["executing"] for level in control_stack)
-
-            if line.startswith("if "):
-                cond = line.split("if ", 1)[1].strip()
-                if is_executing:
-                    cond_true = self._evaluate_condition(cond)
-                    control_stack.append({"type": "if", "executing": cond_true, "any_branch_true": cond_true})
-                else:
-                    control_stack.append({"type": "if", "executing": False, "any_branch_true": True})
-                pc += 1
-                continue
-
-            elif line.startswith("elseif "):
-                cond = line.split("elseif ", 1)[1].strip()
-                parent_active = all(level["executing"] for level in control_stack[:-1]) if len(control_stack) > 1 else True
-
-                if control_stack and control_stack[-1]["type"] == "if":
-                    if parent_active and not control_stack[-1]["any_branch_true"]:
-                        cond_true = self._evaluate_condition(cond)
-                        control_stack[-1]["executing"] = cond_true
-                        control_stack[-1]["any_branch_true"] = cond_true
-                    else:
-                        control_stack[-1]["executing"] = False
-                pc += 1
-                continue
-
-            elif line == "else":
-                parent_active = all(level["executing"] for level in control_stack[:-1]) if len(control_stack) > 1 else True
-                if control_stack and control_stack[-1]["type"] == "if":
-                    if parent_active and not control_stack[-1]["any_branch_true"]:
-                        control_stack[-1]["executing"] = True
-                        control_stack[-1]["any_branch_true"] = True
-                    else:
-                        control_stack[-1]["executing"] = False
-                pc += 1
-                continue
-
-            elif line.startswith("while "):
-                cond = line.split("while ", 1)[1].strip()
-                if is_executing:
-                    end_pc = self._get_block_end(pc)
-                    if self._evaluate_condition(cond):
-                        control_stack.append({"type": "while", "executing": True, "start_pc": pc, "end_pc": end_pc})
-                        pc += 1
-                    else:
-                        pc = end_pc + 1
-                else:
-                    control_stack.append({"type": "while", "executing": False})
-                    pc += 1
-                continue
-
-            elif line.startswith("for "):
-                if is_executing:
-                    parts = line.split("for ", 1)[1].split("->")
-                    var_name = parts[0].strip()
-                    range_parts = parts[1].split(" to ")
-                    start_val = int(self._compute(range_parts[0].strip()))
-                    end_val = int(self._compute(range_parts[1].strip()))
-
-                    self._assign(var_name, start_val)
-                    end_pc = self._get_block_end(pc)
-
-                    if start_val <= end_val:
-                        control_stack.append({"type": "for", "executing": True, "var": var_name, "end_val": end_val, "start_pc": pc, "end_pc": end_pc})
-                        pc += 1
-                    else:
-                        pc = end_pc + 1
-                else:
-                    control_stack.append({"type": "for", "executing": False})
-                    pc += 1
-                continue
-
-            elif line == "end":
-                if control_stack:
-                    top = control_stack[-1]
-                    if top.get("type") == "while" and top["executing"]:
-                        pc = top["start_pc"]
-                        control_stack.pop()
-                        continue
-                    elif top.get("type") == "for" and top["executing"]:
-                        var_name = top["var"]
-                        next_val = self._lookup(var_name) + 1
-                        if next_val <= top["end_val"]:
-                            self._assign(var_name, next_val)
-                            pc = top["start_pc"] + 1
-                            continue
-                        else:
-                            control_stack.pop()
-                            pc += 1
-                            continue
-                    else:
-                        control_stack.pop()
-                        pc += 1
-                        continue
-                else:
-                    break 
-
-            if is_executing:
-                if "?" in line:
-                    cond, action = line.split("?", 1)
-                    if self._evaluate_condition(cond.strip()):
-                        self._execute_line(action.strip())
-                else:
-                    self._execute_line(line)
-            pc += 1
-
-def main():
-    if len(sys.argv) < 2:
-        print("Error: No script file provided.\nUsage: solpl <filename.sol>", file=sys.stderr)
-        sys.exit(1)
-
-    filename = sys.argv[1]
-    if not filename.endswith(".sol"):
-        print("Error: File must have a '.sol' extension.", file=sys.stderr)
-        sys.exit(1)
-    if not os.path.exists(filename):
-        print(f"Error: File '{filename}' not found.", file=sys.stderr)
-        sys.exit(1)
-
-    with open(filename, "r") as f:
-        code_content = f.read()
-
-    engine = SolInterpreter()
-    engine.execute(code_content)
-
-if __name__ == "__main__":
-    main()