Implement new loading system

Author: iiPythonx

main.py

@@ -69,13 +69,13 @@ def getvar(self, name: str, **kwargs) -> XTDatastore:
 
     def execute(self, line: str, raise_error: bool = False) -> Any:
         if self._live and ((self.linetrk and self.linetrk[-1][0] != "<stdin>") or not self.linetrk):
-            self.linetrk.append(["<stdin>", "<stdin>.global", 0, False, "<stdin>"])
+            self.linetrk.append({"file": "<stdin>", "path": "<stdin>", "section": "<stdin>.global", "start": 0, "ended": False, "as": "<stdin>"})
 
         try:
             tokens = self.parseline(line)
             try:
                 trkdata = self.linetrk[-1]
-                prevline = self.sections[trkdata[1]]["lines"][trkdata[2] - self.sections[trkdata[1]]["start"] - 2]
+                prevline = self.sections[trkdata["section"]]["lines"][trkdata["start"] - self.sections[trkdata["section"]]["start"] - 2]
                 if prevline[-2:] in [" \\", ".."]:
                     return None
 
@@ -89,16 +89,16 @@ def execute(self, line: str, raise_error: bool = False) -> Any:
             return self._opmap[operator](XTContext(self.memory, tokens[1:]))
 
         except Exception as e:
-            if raise_error:
+            if raise_error or True:
                 raise e
 
             elif config.get("quiet", False):
                 return None
 
             print("Exception occured in x2 thread!")
             for tracker in self.linetrk:
-                line = self.sections[tracker[1]]["lines"][tracker[2] - self.sections[tracker[1]]["start"] - 1].lstrip()
-                print(f"{tracker[0]} line {tracker[2]}, in {tracker[1].split('.')[1]}:\n  > {line}")
+                line = self.sections[tracker['section']]["lines"][tracker['start'] - self.sections[tracker['section']]["start"] - 1].lstrip()
+                print(f"{tracker['file']} line {tracker['start']}, in {tracker['section'].split('.')[1]}:\n  > {line}")
 
             print(f"\n{type(e).__name__}: {e}")
             if not self._live:
@@ -170,17 +170,21 @@ def parseline(self, line: str, multiline_offset: int = 0) -> list:
 
         return data["line"]
 
-    def load_sections(self, code: str, filename: str, namespace: str = None, external: bool = False) -> None:
+    def load_sections(self, code: str, filepath: str, namespace: str = None, external: bool = False) -> None:
+        filename = filepath.replace("\\", "/").split("/")[-1]
         if not hasattr(self, "_entrypoint"):
             self._entrypoint = filename
 
-        self.memory.vars["file"][filename] = {}
+        self.memory.vars["file"][filepath] = {}
 
-        fileid = (namespace or filename).removesuffix(".xt")
+        fileid = (namespace or filepath.replace("/", ".")).removesuffix(".xt")
         dt = {
             "active": "global",
             "code": [],
-            "sections": {f"{fileid}.global": {"lines": [], "priv": False, "file": filename, "start": 0, "args": [], "ret": None, "as": fileid}}
+            "sections": {f"{fileid}.global": {
+                "lines": [], "priv": False, "file": filename, "path": filepath,
+                "start": 0, "args": [], "ret": None, "as": fileid
+            }}
         }
         for lno, line in enumerate(code.split("\n")):
             if line.strip():
@@ -198,7 +202,7 @@ def load_sections(self, code: str, filename: str, namespace: str = None, externa
                     dt["sections"][ns]["lines"] = dt["code"]
                     dt["sections"][f"{fileid}.{sid}"] = {
                         "file": filename, "start": lno + 1, "lines": [], "priv": priv,
-                        "args": line.split(" ")[1:], "ret": None, "as": fileid
+                        "args": line.split(" ")[1:], "ret": None, "as": fileid, "path": filepath
                     }
                     dt["code"] = []
                     dt["active"] = sid
@@ -215,7 +219,7 @@ def load_sections(self, code: str, filename: str, namespace: str = None, externa
             del self.sections[f"{fileid}.global"]  # Save memory
 
     def find_section(self, section: str) -> Tuple[str, str]:
-        current_file = (self.linetrk or [(self._entrypoint,)])[-1][-1].removesuffix(".xt")
+        current_file = (self.linetrk[-1]["path"] if self.linetrk else self._entrypoint).removesuffix(".xt").replace("/", ".")
         if "." not in section:
             section = f"{current_file}.{section}"
 
@@ -234,12 +238,12 @@ def run_section(self, section: str) -> Any:
         if section not in self.memory.vars["local"]:
             self.memory.vars["local"][section] = {}
 
-        self.linetrk.append([s["file"], section, s["start"], False, s["as"]])
+        self.linetrk.append({"file": s["file"], "path": s["path"], "section": section, "start": s["start"], "ended": False, "as": s["as"]})
         for line in s["lines"]:
-            self.linetrk[-1][2] += 1
+            self.linetrk[-1]["start"] += 1
             if line.strip() and line[:2] != "::":
                 self.execute(line)
-                if self.linetrk[-1][3]:
+                if self.linetrk[-1]['ended']:
                     break
 
         del self.memory.vars["local"][section]
@@ -292,5 +296,6 @@ def run_section(self, section: str) -> Any:
         print("x2: failed to load file")
         os._exit(1)
 
-    inter.load_sections(code, file.replace("\\", "/").split("/")[-1])
-    [inter.run_section(s) for s in ["global", "main"]]
+    inter.load_sections(code, file)
+    file = file.replace("\\", "/").replace("/", ".").removesuffix(".xt")
+    [inter.run_section(s) for s in [f"{file}.global", f"{file}.main"]]

smth/main.xt

@@ -0,0 +1,8 @@
+evl "setvar('@x', 5)"
+
+imp "stdlib"
+
+:main
+    evl "from rich import print; print(x2.sections)"
+    out @x
+    wait 999

x2/datastore.py

@@ -13,8 +13,8 @@ class XTDatastore(object):
     def __init__(self, mem: XTMemory, raw: str, section_override: str = None) -> None:
         self.mem, self.raw, self.flags = mem, raw, []
 
-        self.active_file = self.mem.interpreter.linetrk[-1][0]
-        self.active_section = section_override or self.mem.interpreter.linetrk[-1][1]
+        self.active_file = self.mem.interpreter.linetrk[-1]["path"]
+        self.active_section = section_override or self.mem.interpreter.linetrk[-1]["section"]
 
         self.keydict = {
             "#": self.mem.vars["globals"],

x2/operators/primary.py

@@ -131,7 +131,7 @@ def imp(ctx) -> None:
 
         ctx.memory.interpreter.load_sections(
             code,
-            path.replace("\\", "/").split("/")[-1],
+            path,
             namespace = namespace,
             external = True
         )
@@ -178,7 +178,7 @@ def ret(ctx) -> None:
         if not ctx.args:
             raise MissingArguments("required: val")
 
-        ctx.memory.interpreter.sections[ctx.memory.interpreter.linetrk[-1][1]]["ret"] = ctx.args[0].value
+        ctx.memory.interpreter.sections[ctx.memory.interpreter.linetrk[-1]["section"]]["ret"] = ctx.args[0].value
         XTOperators.end(ctx)
 
     def pvk(ctx) -> Any:
@@ -228,7 +228,7 @@ def end(ctx) -> None:
 
         end
         """
-        ctx.memory.interpreter.linetrk[-1][3] = True
+        ctx.memory.interpreter.linetrk[-1]["ended"] = True
 
     def try_(ctx) -> None:
         """