topdown file loader

Author: thautwarm

purescripto/purescript_loader.py

@@ -1,54 +1,79 @@
-from pathlib import Path
-from typing import Union, Tuple
-from types import CodeType
-from pie import LoaderForBetterLife
-from importlib import import_module
-from purescripto import rts
-from purescripto.utilities import import_from_path
-from purescripto.workaround import suppress_cpy38_literal_is, workaround
-import marshal
-import functools
-
-RES = 'res'
-"""generated code object is stored in global variable $RES"""
-
-
-@functools.lru_cache()
-def _import_module_to_dict(m: str):
-    with suppress_cpy38_literal_is():
-        package, _, module = m.rpartition('.')
-        entry_path = import_module(package).__file__
-        loc = entry_path[:-len('__init__.py')] + module + '.py'
-        return import_from_path(m, loc).__dict__
-
-
-RTS_TEMPLATE = {
-    'zfsr32': rts.zfsr32,
-    'Error': Exception,
-    'import_module': _import_module_to_dict
-}
-
-
-class LoadPureScriptImplCode(LoaderForBetterLife[CodeType]):
-    def source_to_prog(self, src: bytes, path: Path) -> CodeType:
-        with workaround():
-            mod = import_from_path(self.qualified_name + '$',
-                                   str(path.absolute()))
-        return getattr(mod, RES)
-
-    def load_program(self, b: bytes) -> CodeType:
-        return marshal.loads(b)
-
-    def dump_program(self, prog: CodeType) -> bytes:
-        return marshal.dumps(prog)
-
-    def suffix(self) -> Union[str, Tuple[str, ...]]:
-        return '.src.py'
-
-
-def LoadPureScript(file: str, name: str):
-    loader = LoadPureScriptImplCode(file, name)
-    code = loader.load()
-    man_made_globals = RTS_TEMPLATE.copy()
-    exec(code, man_made_globals)
-    return man_made_globals['exports']
+from pathlib import Path
+from typing import Union, Tuple
+from types import CodeType
+from pie import LoaderForBetterLife
+from importlib import import_module
+from purescripto import rts
+from purescripto.utilities import import_from_path
+from purescripto.workaround import suppress_cpy38_literal_is, workaround
+from py_sexpr.stack_vm.emit import module_code
+from purescripto.topdown import load_topdown
+import marshal
+import functools
+
+RES = "res"
+"""generated code object is stored in global variable $RES"""
+
+
+@functools.lru_cache()
+def _import_module_to_dict(m: str):
+    with suppress_cpy38_literal_is():
+        package, _, module = m.rpartition(".")
+        entry_path = import_module(package).__file__
+        loc = entry_path[: -len("__init__.py")] + module + ".py"
+        return import_from_path(m, loc).__dict__
+
+
+RTS_TEMPLATE = {
+    "zfsr32": rts.zfsr32,
+    "Error": Exception,
+    "import_module": _import_module_to_dict,
+}
+
+
+def _META_ENV():
+    with workaround():
+        import py_sexpr.terms as terms
+
+        def make_pair(a, b):
+            return a, b
+
+        env = {each: getattr(terms, each) for each in terms.__all__}
+        env[make_pair.__name__] = make_pair
+    return env
+
+
+META_ENV = _META_ENV()
+
+
+class LoadPureScriptImplCode(LoaderForBetterLife[CodeType]):
+    def source_to_prog(self, src: bytes, path: Path) -> CodeType:
+
+        filename = str(path.absolute())
+        if path.name.endswith(".raw.py"):
+            meta_code = compile(src, filename, "eval")
+            sexpr = eval(meta_code, META_ENV)
+            code = module_code(sexpr, name=self.qualified_name + "$", filename=filename)
+        else:
+            assert path.name.endswith(".zip.py")
+            with path.open(mode="utf8") as f:
+                code = load_topdown(f, META_ENV)
+
+        return code
+
+    def load_program(self, b: bytes) -> CodeType:
+        return marshal.loads(b)
+
+    def dump_program(self, prog: CodeType) -> bytes:
+        return marshal.dumps(prog)
+
+    def suffix(self) -> Union[str, Tuple[str, ...]]:
+        return ".raw.py", ".zip.py"
+
+
+def LoadPureScript(file: str, name: str):
+    loader = LoadPureScriptImplCode(file, name)
+    code = loader.load()
+    man_made_globals = RTS_TEMPLATE.copy()
+    exec(code, man_made_globals)
+    return man_made_globals["exports"]

purescripto/topdown.py

@@ -0,0 +1,125 @@
+from typing import TextIO
+
+
+def _META_ENV():
+    import py_sexpr.terms as terms
+
+    def make_pair(a, b):
+        return a, b
+
+    env = {each: getattr(terms, each) for each in terms.__all__}
+    env[make_pair.__name__] = make_pair
+    return env
+
+
+META_ENV = _META_ENV()
+
+
+def load_topdown(file_io: TextIO, env):
+    readline, read = file_io.readline, file_io.read
+    n_entry = int(readline()[:-1])
+    ACTION_ATTR = 0
+    ACTION_APP = 1
+    ACTION_SEQ = 2
+
+    object_stack = []
+    actions = []
+    left_stack = []
+    push_object = object_stack.append
+    push_left = left_stack.append
+    push_action = actions.append
+    pop_object = object_stack.pop
+    pop_action = actions.pop
+    pop_left = left_stack.pop
+
+    def read_entry(readline=readline, read=read):
+        line = readline()
+        key, length = line[:-1].split()
+        value = read(int(length))
+        read(1)
+        return key, value
+
+    entries = dict(read_entry(readline, read) for _ in range(n_entry))
+    read(1)
+
+    def read_float(readline=readline, append=push_object):
+        return append(float(readline()[:-1]))
+
+    def read_int(readline=readline, append=push_object):
+        return append(int(readline()[:-1]))
+
+    # noinspection PyDefaultArgument
+    def read_bool(
+        readline=readline, mapping={"true": True, "false": False}, append=push_object,
+    ):
+        return append(mapping[readline()[:-1]])
+
+    def read_nil(append=push_object):
+        readline()
+        return append(None)
+
+    # noinspection PyDefaultArgument
+    def read_string(readline=readline, entries=entries, append=push_object):
+        append(entries[readline()[:-1]])
+
+    # noinspection PyDefaultArgument
+    def read_var(readline=readline, env=env, entries=entries, append=push_object):
+        return append(env[entries[readline()[:-1]]])
+
+    def read_acc(readline=readline, ACTION_ATTR=ACTION_ATTR):
+        attr_name = readline()[:-1]
+        return 1, (ACTION_ATTR, attr_name)
+
+    # noinspection PyDefaultArgument
+    def read_cons(env=env, readline=readline, entries=entries, ACTION_APP=ACTION_APP):
+        length, fn = readline()[:-1].split()
+        length = int(length)
+        fn = env[entries[fn]]
+        return length, (ACTION_APP, fn)
+
+    def read_seq(readline=readline, ACTION_SEQ=ACTION_SEQ):
+        length = int(readline()[:-1])
+        return length, ACTION_SEQ
+
+    terminal_maps = {
+        "s": read_string,
+        "i": read_int,
+        "b": read_bool,
+        "n": read_nil,
+        "f": read_float,
+        "v": read_var,
+    }
+    non_term_maps = {"a": read_acc, "c": read_cons, "l": read_seq}
+
+    left = 1
+
+    while True:
+        while left:
+            left -= 1
+            case = read(1)
+            term = terminal_maps.get(case)
+            if term:
+                term()
+                continue
+            push_left(left)
+            left, action = non_term_maps[case]()
+            push_action((left, action))
+
+        try:
+            left = pop_left()
+        except IndexError:
+            assert not actions and len(object_stack) == 1
+            return object_stack[0]
+        narg, action = pop_action()
+        args = [pop_object() for _ in range(narg)]
+        args.reverse()
+        if action is ACTION_SEQ:
+            push_object(args)
+            continue
+
+        action, op = action
+        if action is ACTION_APP:
+            push_object(op(*args))
+        else:
+            assert action is ACTION_ATTR and len(args) == 1
+            push_object(getattr(args[0], op))