solpl 2.1.0__tar.gz → 2.2.0__tar.gz

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

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

solpl-2.2.0/interpreter/sol.py

@@ -0,0 +1,462 @@
+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()

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

@@ -4,12 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "solpl"
-version = "2.1.0"
+version = "2.2.0"
 description = "Sol Programming Language Interpreter"
 requires-python = ">=3.7"
 
 [project.scripts]
-solpl = "sol:main"
+solpl = "interpreter.sol:main"
 
 [tool.setuptools]
-py-modules = ["sol"]
+packages = ["interpreter"]

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

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

{solpl-2.1.0 → solpl-2.2.0}/solpl.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 LICENSE
 README.md
 pyproject.toml
+interpreter/sol.py
 solpl.egg-info/PKG-INFO
 solpl.egg-info/SOURCES.txt
 solpl.egg-info/dependency_links.txt

solpl-2.2.0/solpl.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+solpl = interpreter.sol:main

solpl-2.2.0/solpl.egg-info/top_level.txt

@@ -0,0 +1 @@
+interpreter

solpl-2.1.0/solpl.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-solpl = sol:main

solpl-2.1.0/solpl.egg-info/top_level.txt

@@ -1 +0,0 @@
-sol