Permalink
Cannot retrieve contributors at this time
Name already in use
A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
lever/runtime/module_resolution.py
Go to fileThis commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
executable file
329 lines (294 sloc)
11.3 KB
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
from space import * | |
import base | |
import bon | |
import evaluator | |
import core | |
import os | |
import pathobj | |
import stdlib | |
import sys | |
class ModuleScope(Object): | |
def __init__(self, local, parent=None, frozen=False): | |
self.cache = {} # maps absolute path -> module cache entry | |
self.local = local | |
self.parent = parent | |
self.frozen = frozen # if frozen, the scope relies on cache. | |
self.compile_file = null | |
self.base_module = None | |
def setcache(self, m_path, module, mtime): | |
m = ModuleCache(m_path, module, mtime) | |
self.cache[pathobj.stringify(m_path)] = m | |
return m | |
def getcache(self, m_path): | |
s = pathobj.stringify(m_path) | |
try: | |
return self.cache[s] | |
except KeyError as k: | |
return None | |
def getattr(self, name): | |
if name == u"parent": | |
return self.parent if self.parent is not None else null | |
if name == u"local": | |
return self.local | |
if name == u"frozen": | |
return boolean(self.frozen) | |
if name == u"base_module": | |
if self.base_module is None: | |
return null | |
return self.base_module | |
if name == u"compile_file": | |
return self.compile_file | |
return Object.getattr(self, name) | |
def setattr(self, name, value): | |
if name == u"base_module": | |
if len(self.cache) > 0: | |
raise unwind(LTypeError(u"Cannot change base_module in active module scope")) | |
self.base_module = cast_n(value, Module, u"ModuleScope.base_module") | |
return null | |
return Object.setattr(self, name, value) | |
def listattr(self): | |
listing = Object.listattr(self) | |
listing.extend([ | |
String(u"parent"), | |
String(u"local"), | |
String(u"frozen"), | |
String(u"base_module"), | |
String(u"compile_file"), | |
]) | |
return listing | |
def getitem(self, item): | |
if isinstance(item, String): | |
if item.string in self.cache: | |
return self.cache[item.string] | |
raise OldError(u"%s not in module scope" % item.repr()) | |
def iter(self): | |
return ScopeIterator(self.cache.iterkeys()) | |
# | |
@ModuleScope.instantiator2(signature(pathobj.Path, ModuleScope, Object, optional=2)) | |
def _(local, parent, options): | |
scope = ModuleScope(local, parent) | |
if options: | |
key = String(u"compile_file") | |
if options.contains(key): | |
scope.compile_file = options.getitem(key) | |
return scope | |
class ScopeIterator(Object): | |
_immutable_fields_ = ['iterator'] | |
def __init__(self, iterator): | |
self.iterator = iterator | |
def iter(self): | |
return self | |
@ScopeIterator.builtin_method | |
@signature(ScopeIterator) | |
def next(self): | |
return String(self.iterator.next()) | |
class ModuleCache(Object): | |
def __init__(self, path, module, mtime): | |
self.path = path | |
self.module = module | |
self.mtime = mtime | |
def getattr(self, name): | |
if name == u"path": | |
return self.path | |
if name == u"module": | |
return self.module | |
if name == u"mtime": | |
return Float(self.mtime) | |
return Object.getattr(self, name) | |
def listattr(self): | |
listing = Object.listattr(self) | |
listing.extend([ | |
String(u"path"), | |
String(u"module"), | |
String(u"mtime"), | |
]) | |
return listing | |
@ModuleCache.builtin_method | |
@signature(ModuleCache) | |
def get_moduleinfo(self): | |
return moduleinfo(self.path) | |
root_module = ModuleScope(pathobj.parse(u"builtin:/"), frozen=True) | |
root_module.base_module = base.module | |
for py_module in stdlib.import_all_modules(): | |
assert isinstance(py_module.module, Module), "dependency cycle somewhere" | |
p = pathobj.concat(root_module.local, pathobj.parse(py_module.module.name)) | |
py_module.module.setattr_force(u"doc", pathobj.parse(u"doc:/" + py_module.module.name)) | |
root_module.setcache(p, py_module.module, 0.0) | |
import naming | |
naming.breath_first_search(py_module.module, 1.0) | |
base.module.setattr_force(u"doc", pathobj.parse(u"doc:/base")) | |
root_module.setcache(pathobj.parse(u"builtin:/" + base.module.name), base.module, 0.0) | |
# the importer poststage for base module will take place in | |
# entry generation at runtime/main.py because there are so many | |
# items added into the base module all around the system. | |
import main | |
def start(main_script): | |
assert isinstance(main_script, String) | |
lib_scope = ModuleScope( | |
pathobj.concat(core.get_ec().lever_path, pathobj.parse(u"lib")), | |
root_module) | |
lib_scope.compile_file = LazyLoader(lib_scope) | |
main_path = pathobj.os_parse(resuffix(main_script.string, u".lc", u"")) | |
mi = moduleinfo(pathobj.abspath(main_path)) | |
scope = ModuleScope(mi.directory, lib_scope) | |
this = Module(mi.name.string, {}, extends=base.module) # base.module | |
if not (mi.lc_present or mi.cb_present): | |
raise OldError(u"main module not present") | |
scope.setcache(main_path, this, max(mi.lc_mtime, mi.cb_mtime)) | |
mi.default_config(this, scope) | |
mi.loadit(this, scope) | |
return this | |
class LazyLoader(Object): | |
def __init__(self, lib_scope): | |
self.lib_scope = lib_scope | |
def call(self, argv): | |
lib_scope = self.lib_scope | |
mi = moduleinfo(pathobj.concat(lib_scope.local, pathobj.parse(u"compiler"))) | |
this = Module(mi.name.string, {}, extends=base.module) # base.module | |
mi.default_config(this, lib_scope) | |
mi.loadit(this, lib_scope) | |
lib_scope.compile_file = this.getattr(u"compile_file") | |
return lib_scope.compile_file.call(argv) | |
# plans: | |
# allow modules derive or create new scopes and isolate themselves. | |
# module path | |
def moduleinfo(module_path): | |
module_path = pathobj.abspath(module_path) | |
module_name = module_path.getattr(u"basename") | |
assert isinstance(module_name, String) | |
s = pathobj.os_stringify(module_path).encode('utf-8') | |
is_dir = False | |
if os.path.isdir(s): | |
w = os.path.join(s, "init") | |
if os.path.exists(w + ".lc.cb") or os.path.exists(w + ".lc"): | |
is_dir = True | |
s = w | |
else: | |
module_path = pathobj.directory(module_path) | |
cb_path = s + ".lc.cb" | |
cb_present = os.path.exists(cb_path) | |
cb_mtime = 0.0 | |
lc_path = s + ".lc" | |
lc_present = os.path.exists(lc_path) | |
lc_mtime = 0.0 | |
if cb_present: | |
cb_mtime = os.path.getmtime(cb_path) | |
if lc_present: | |
lc_mtime = os.path.getmtime(lc_path) | |
# This ignores outdated bytecode objects. | |
if cb_present and lc_present: | |
cb_present = not cb_mtime < lc_mtime | |
return ModuleInfo( | |
module_name, module_path, | |
pathobj.os_parse(cb_path.decode('utf-8')), cb_present, cb_mtime, | |
pathobj.os_parse(lc_path.decode('utf-8')), lc_present, lc_mtime, | |
) | |
class ModuleInfo(Object): | |
def __init__(self, name, directory, cb_path, cb_present, cb_mtime, lc_path, lc_present, lc_mtime): | |
self.name = name | |
self.directory = directory | |
self.cb_path = cb_path | |
self.cb_present = cb_present | |
self.cb_mtime = cb_mtime | |
self.lc_path = lc_path | |
self.lc_present = lc_present | |
self.lc_mtime = lc_mtime | |
def default_config(self, module, scope): | |
module.setattr(u"dir", self.directory) | |
module.setattr(u"name", self.name) | |
module.setattr(u"import", Import(self.directory, scope)) | |
return module | |
def loadit(self, module, scope): | |
if not self.cb_present: | |
while scope.compile_file is null and scope.parent is not None: | |
scope = scope.parent | |
if scope.compile_file is null: | |
raise OldError(u"Lever bytecode compiler stale or missing: " + self.lc_path.repr()) | |
scope.compile_file.call([self.cb_path, self.lc_path]) | |
self.cb_mtime = os.path.getmtime(pathobj.os_stringify(self.cb_path).encode('utf-8')) | |
self.cb_present = True | |
program = evaluator.loader.from_object(bon.open_file(self.cb_path), self.cb_path) | |
res = program.call([module]) | |
return res | |
def getattr(self, name): | |
if name == u"present": | |
return boolean(self.cb_present or self.lc_present) | |
if name == u"mtime": | |
return Float(max(self.lc_mtime, self.cb_mtime)) | |
return Object.getattr(self, name) | |
class Import(Object): | |
def __init__(self, local, scope): | |
self.local = local | |
self.scope = scope | |
def call(self, argv): | |
if len(argv) != 1: | |
raise OldError(u"wrong number of arguments to import") | |
name = argv[0] | |
if isinstance(name, pathobj.Path): | |
raise OldError(u"no direct loading yet") | |
elif not isinstance(name, String): | |
raise OldError(u"expected string") | |
# import resolution: | |
# local/script.lc | |
path = pathobj.concat(self.local, pathobj.to_path(name)) | |
cache = self.scope.getcache(path) | |
if cache: | |
return cache.module | |
if not self.scope.frozen: | |
mi = moduleinfo(path) | |
if mi.lc_present or mi.cb_present: | |
base_module = get_base_module(self.scope) | |
this = Module(name.string, {}, extends=base_module) # base.module | |
self.scope.setcache(path, this, max(mi.lc_mtime, mi.cb_mtime)) | |
mi.default_config(this, self.scope) | |
mi.loadit(this, self.scope) | |
return this | |
# scope/ | |
scope = self.scope | |
while scope is not None: | |
path = pathobj.concat(scope.local, pathobj.to_path(name)) | |
cache = scope.getcache(path) | |
if cache: | |
return cache.module | |
if not scope.frozen: | |
mi = moduleinfo(path) | |
if mi.lc_present or mi.cb_present: | |
base_module = get_base_module(scope) | |
this = Module(name.string, {}, extends=base_module) # base.module | |
scope.setcache(path, this, max(mi.lc_mtime, mi.cb_mtime)) | |
mi.default_config(this, scope) | |
mi.loadit(this, scope) | |
return this | |
scope = scope.parent | |
raise OldError(u"module '%s' not present" % name.string) | |
def getattr(self, name): | |
if name == u'scope': | |
return self.scope | |
if name == u"local": | |
return self.local | |
return Object.getattr(self, name) | |
def get_base_module(scope): | |
while scope.parent and scope.base_module is None: | |
scope = scope.parent | |
return scope.base_module | |
@Import.instantiator2(signature(pathobj.Path, ModuleScope)) | |
def _(local, scope): | |
return Import(local, scope) | |
@ModuleScope.builtin_method | |
@signature(ModuleScope, String) | |
def reimport(scope, obj): | |
if obj.string not in scope.cache: | |
raise OldError(u"Cannot reimport, module not present") | |
mc = scope.cache[obj.string] | |
mi = moduleinfo(mc.path) | |
mi.default_config(mc.module, scope) | |
mi.loadit(mc.module, scope) | |
mc.mtime = max(mi.lc_mtime, mi.cb_mtime) | |
return mc.module | |
def resuffix(string, suffix, new_suffix=u""): | |
if string.endswith(suffix): | |
i = max(0, len(string) - len(suffix)) | |
return string[0:i] + new_suffix | |
return string + new_suffix | |
base.module.setattr_force(u"ModuleScope", ModuleScope.interface) | |
base.module.setattr_force(u"Import", Import.interface) |