solpl 2.7.0__tar.gz → 4.0.0__tar.gz

{solpl-2.7.0/solpl.egg-info → solpl-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solpl
-Version: 2.7.0
+Version: 4.0.0
 Summary: A lightweight, multi-threaded interpreter for the Sol programming language
 Author-email: stefand-0 <stefand-0@users.noreply.github.com>
 License-Expression: Apache-2.0

{solpl-2.7.0 → solpl-4.0.0}/interpreter/sol.py

@@ -41,7 +41,6 @@ class SolInterpreter:
         return False
 
     def _split_on_op(self, string, op):
-        """Split on first occurrence of op outside quotes. Returns (left, right) or (None, None)."""
         in_quote = False
         quote_char = None
         for i, char in enumerate(string):
@@ -96,7 +95,6 @@ class SolInterpreter:
 
     def _compute(self, expr):
         expr = str(expr).strip()
-        
         # Handle parentheses
         idx = 0
         while True:
@@ -106,7 +104,6 @@ class SolInterpreter:
             start_idx = expr.rfind('(', 0, end_idx)
             if start_idx == -1:
                 break
-            # Skip function calls
             if start_idx > 0 and (expr[start_idx - 1].isalnum() or expr[start_idx - 1] == '_'):
                 idx = end_idx + 1
                 continue
@@ -114,8 +111,7 @@ class SolInterpreter:
             inner_result = self._compute(inner_expr)
             expr = expr[:start_idx] + str(inner_result) + expr[end_idx + 1:]
             idx = 0
-        
-        # Handle string concatenation with +
+        # String concatenation with +
         plus_parts = self._split_outside_quotes(expr, '+')
         if len(plus_parts) > 1:
             is_string_concat = False
@@ -130,16 +126,14 @@ class SolInterpreter:
                     val = self._resolve(p.strip())
                     result += str(val) if val is not None else ""
                 return result
-        
-        # Check for equality (=) - comparison operator
+        # Equality comparison (=)
         left, right = self._split_on_op(expr, '=')
         if left is not None:
             r1 = self._resolve(left.strip())
             r2 = self._resolve(right.strip())
             if r1 is not None and r2 is not None:
                 return 1 if r1 == r2 else 0
-        
-        # Level 1: + and -
+        # + and -
         for op in ['+', '-']:
             idx = self._find_last_op(expr, op)
             if idx != -1:
@@ -153,8 +147,7 @@ class SolInterpreter:
                 val2 = float(r2)
                 if op == '+': return val1 + val2
                 if op == '-': return val1 - val2
-        
-        # Level 2: * and :
+        # * and :
         last_idx = -1
         last_op = None
         for op in ['*', ':']:
@@ -174,7 +167,6 @@ class SolInterpreter:
                 val2 = float(r2)
                 if last_op == '*': return val1 * val2
                 if last_op == ':': return val1 / val2
-        
         return self._resolve(expr)
 
     def _lookup(self, name):
@@ -207,6 +199,11 @@ class SolInterpreter:
                 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)
+            for func_name in self.functions:
+                if func_name.endswith("." + name):
+                    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(func_name, args)
         if "[" in val and "]" in val:
             try:
                 name, idx_part = val.split("[", 1)
@@ -215,16 +212,23 @@ class SolInterpreter:
                 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)
-
+            parts = val.split(".")
+            obj = self._lookup(parts[0])
+            for part in parts[1:]:
+                if isinstance(obj, dict):
+                    obj = obj.get(part, 0)
+                else:
+                    return 0
+            return obj
         for scope in reversed(self.scope_stack):
             if val in scope: return scope[val]
-
+        if val in self.functions:
+            return ("func_ref", val)
+        for func_name in self.functions:
+            if func_name.endswith("." + val):
+                return ("func_ref", func_name)
         if val.replace('.', '', 1).isdigit() or (val.startswith('-') and val[1:].replace('.', '', 1).isdigit()):
             return float(val) if '.' in val else int(val)
-
         return None 
 
     def _native_fetch(self, url):
@@ -253,15 +257,12 @@ class SolInterpreter:
         self.threads.append(t)
 
     def _evaluate_condition(self, cond):
-        # Equality comparison uses =
         left, right = self._split_on_op(cond, "=")
         if left is not None:
-            return self._compute(cond)  # _compute handles =
-        # Less than
+            return self._compute(cond)
         left, right = self._split_on_op(cond, "<")
         if left is not None:
             return self._compute(left.strip()) < self._compute(right.strip())
-        # Greater than
         left, right = self._split_on_op(cond, ">")
         if left is not None:
             return self._compute(left.strip()) > self._compute(right.strip())
@@ -279,33 +280,78 @@ class SolInterpreter:
             pc += 1
         return pc
 
+    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 = os.path.splitext(os.path.basename(filename))[0]
+            lines = []
+            for l in code.split('\n'):
+                l = l.strip()
+                if not l: continue
+                if l.startswith(';'): continue
+                if l.startswith('//'): continue
+                if ';' in l:
+                    l = l.split(';', 1)[0].strip()
+                if l:
+                    lines.append(l)
+            # Parse structs first
+            for pc, line in enumerate(lines):
+                if line.endswith("{}") and "->" not in line and ">>" not in line and "?" not in line and not line.startswith("_"):
+                    struct_name = line.split("{}")[0].strip()
+                    fields = {}
+                    npc = pc + 1
+                    while npc < len(lines) and lines[npc] != "end":
+                        if "->" in lines[npc]:
+                            key, val = [x.strip() for x in lines[npc].split("->")]
+                            fields[key] = self._resolve(val)
+                        npc += 1
+                    self.struct_blueprints[struct_name] = fields
+                    self.variables[struct_name] = fields.copy()
+            # Parse functions
+            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 execute(self, code):
         raw_lines = code.split('\n')
         self.lines = []
         for l in raw_lines:
             l = l.strip()
-            if not l:
-                continue
-            if l.startswith(';'):
-                continue
-            if l.startswith('//'):
-                continue
+            if not l: continue
+            if l.startswith(';'): continue
+            if l.startswith('//'): continue
             if ';' in l:
                 l = l.split(';', 1)[0].strip()
             if l:
                 self.lines.append(l)
-        
         self.threads = []
         pc = 0
+        depth = 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")):
+            if line == "end":
+                depth -= 1
+                pc += 1
+                continue
+            if depth == 0 and "(" 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 line.endswith("{}") and "->" not in line and ">>" not in line and "?" not in line and not line.startswith("_"):
+                func_name = parts[0].strip()
+                if not func_name.startswith("_"):
+                    self.functions[func_name] = {"start_pc": pc + 1, "params": [p.strip() for p in parts[1].replace(")", "").split(",")] if parts[1].replace(")", "").strip() else []}
+                    depth += 1
+            elif depth == 0 and line.endswith("{}") and "->" not in line and ">>" not in line and "?" not in line and not line.startswith("_"):
                 pc = self._parse_struct(pc)
                 pc += 1
                 continue
+            elif depth > 0 and line.startswith(("if ", "while ", "for ")):
+                depth += 1
             pc += 1
         for i, line in enumerate(self.lines):
             if line == "main()":
@@ -325,7 +371,7 @@ class SolInterpreter:
                 fields[key] = self._resolve(val)
             pc += 1
         self.struct_blueprints[struct_name] = fields
-        self._assign(struct_name, fields.copy())
+        self.variables[struct_name] = fields.copy()
         return pc
 
     def _call_function(self, name, args):
@@ -348,13 +394,18 @@ class SolInterpreter:
         return 0
 
     def _execute_line(self, line):
-        # Handle imports
         if line.startswith("_get("):
             filename = line.split('"')[1]
             self._import_file(filename)
             return
-        
-        # Handle piping input
+        if line.startswith("_call("):
+            inner = line[6:-1].strip()
+            parts = [p.strip() for p in inner.split(",")]
+            func_name = self._resolve(parts[0])
+            if isinstance(func_name, tuple) and func_name[0] == "func_ref":
+                func_name = func_name[1]
+            args = [self._compute(p) for p in parts[1:]]
+            return self._call_function(func_name, args)
         if ">>" in line and "_in" in line:
             parts = [p.strip() for p in line.split(">>")]
             if len(parts) >= 3 and parts[1] == "_in":
@@ -365,19 +416,14 @@ class SolInterpreter:
                 try: self._assign(var_name, float(val) if '.' in val else int(val))
                 except: self._assign(var_name, val)
                 return
-        
-        # Check if async
         is_async = False
         if ">>" in line:
             parts = [p.strip() for p in line.split(">>")]
             if parts[-1] == "_async":
                 line = ">>".join(line.split(">>")[:-1]).strip()
                 is_async = True
-        
         if line.startswith("_return ->"):
             raise ReturnSignal(self._compute(line.split("->", 1)[1]))
-        
-        # Handle _out with piping
         if ">>" in line and "_out" in line:
             parts = [p.strip() for p in line.split(">>")]
             if len(parts) == 2 and parts[1] == "_out":
@@ -388,7 +434,6 @@ class SolInterpreter:
                 else:
                     print(val if val is not None else "")
                 return
-        
         if line.startswith("_out"):
             val = self._compute(line.split("->", 1)[1].strip())
             if is_async:
@@ -397,7 +442,6 @@ class SolInterpreter:
             else:
                 print(val if val is not None else "")
             return
-        
         if line.startswith("_in"):
             if "->" in line:
                 var_name = line.split("->", 1)[1].strip()
@@ -406,45 +450,44 @@ class SolInterpreter:
                 try: self._assign(var_name, float(val) if '.' in val else int(val))
                 except: self._assign(var_name, val)
             return
-        
         if "_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]))
             return
-        
         if "_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]))
             return
-        
         if "_listen(" in line:
             p, h = [p.strip() for p in line.replace("_listen(", "").replace(")", "").split(",")]
             self._native_listen(self._compute(p), h)
             return
-        
-        # List declaration
         if "<" in line and ">" in line and "->" not in line and ">>" not in line and "?" not in line and not line.startswith("_"):
             parts = line.split("<")
             if len(parts) == 2 and ">" in parts[1]:
                 list_name = parts[1].split(">")[0].strip()
                 self._assign(list_name, [])
                 return
-        
-        # Assignment - ONLY with ->
         if "->" in line:
             var, val = [x.strip() for x in line.split("->", 1)]
             if "." in var:
-                obj, prop = var.split(".", 1)
-                target = self._lookup(obj)
-                if isinstance(target, dict): target[prop] = self._compute(val)
+                parts = var.split(".")
+                target = self._lookup(parts[0])
+                if isinstance(target, dict):
+                    for part in parts[1:-1]:
+                        if isinstance(target, dict) and part in target:
+                            target = target[part]
+                        else:
+                            target = None
+                            break
+                    if target is not None and isinstance(target, dict):
+                        target[parts[-1]] = self._compute(val)
             else:
                 computed = self._compute(val)
                 self._assign(var, computed)
             return
-        
-        # Function call
         if "(" in line and line.endswith(")") and not line.startswith("_"):
             parts = line.split("(")
             func_name = parts[0].strip()
@@ -463,6 +506,19 @@ class SolInterpreter:
         while pc < len(self.lines):
             line = self.lines[pc]
             is_executing = all(level["executing"] for level in control_stack)
+            if is_executing and "(" 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")):
+                func_candidate = line.split("(")[0].strip()
+                if func_candidate in self.functions:
+                    depth = 1
+                    npc = pc + 1
+                    while npc < len(self.lines) and depth > 0:
+                        if self.lines[npc].startswith(("if ", "while ", "for ")):
+                            depth += 1
+                        elif self.lines[npc] == "end":
+                            depth -= 1
+                        npc += 1
+                    pc = npc
+                    continue
             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

{solpl-2.7.0 → solpl-4.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "solpl"
-version = "2.7.0"
+version = "4.0.0"
 authors = [
     { name = "stefand-0", email = "stefand-0@users.noreply.github.com" }
 ]

{solpl-2.7.0 → solpl-4.0.0/solpl.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solpl
-Version: 2.7.0
+Version: 4.0.0
 Summary: A lightweight, multi-threaded interpreter for the Sol programming language
 Author-email: stefand-0 <stefand-0@users.noreply.github.com>
 License-Expression: Apache-2.0