def read_file(path, dependencies, decorator):
basename = path.getattr(u"basename")
if isinstance(basename, String):
if not basename.string.endswith(u".json"):
dirname = path.getattr(u"dirname")
path = pathobj.concat(dirname,
pathobj.parse(basename.string + u".json"))
path = pathobj.concat(conf.headers_dir, path)
try:
apispec = json.read_file(path)
except OSError as error:
raise OldError(u"[Errno %d]: %s\n" % (error.errno, pathobj.stringify(path)))
return read_object(apispec, dependencies, decorator)
def attach_compiler(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")
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)
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 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
mi.default_config(this, self.scope)
mi.loadit(this, self.scope)
self.scope.setcache(path, this, max(mi.lc_mtime, mi.cb_mtime))
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
mi.default_config(this, scope)
mi.loadit(this, scope)
scope.setcache(path, this, max(mi.lc_mtime, mi.cb_mtime))
return this
scope = scope.parent
raise OldError(u"module '%s' not present" % name.string)
def read_file(path, dependencies, decorator):
basename = path.getattr(u"basename")
if isinstance(basename, String):
if not basename.string.endswith(u".json"):
path.setattr(
u"basename",
String(basename.string + u".json"))
path = pathobj.concat(conf.headers_dir, path)
try:
apispec = json.read_file(path)
except OSError as error:
raise OldError(u"[Errno %d]: %s\n" % (error.errno, pathobj.stringify(path)))
return read_object(apispec, dependencies, decorator)
def start(main_script):
assert isinstance(main_script, String)
lib_scope = ModuleScope(
pathobj.concat(main.get_ec().lever_path, pathobj.parse(u"lib")),
root_module)
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")
mi.default_config(this, scope)
mi.loadit(this)
scope.setcache(main_path, this, max(mi.lc_mtime, mi.cb_mtime))
return this
def normal_startup(argv):
if len(argv) > 0:
main_script = argv[0]
else:
main_script = pathobj.concat(core.get_ec().lever_path,
pathobj.parse(u"app/main.lc"))
main_script = space.String(pathobj.os_stringify(main_script))
module = module_resolution.start(main_script)
try:
main_func = module.getattr(u"main")
except space.Unwinder as unwinder:
pass # in this case main_func just isn't in the module.
else:
main_func.call([space.List(argv)])
return space.null
def start(main_script):
assert isinstance(main_script, String)
lib_scope = ModuleScope(
pathobj.concat(main.get_ec().lever_path, pathobj.parse(u"lib")),
root_module)
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")
mi.default_config(this, scope)
mi.loadit(this)
scope.setcache(main_path, this, max(mi.lc_mtime, mi.cb_mtime))
return this
def which(program):
if isinstance(program, String):
if program.string.count(u"/") > 0:
program = pathobj.to_path(program)
if isinstance(program, pathobj.Path):
path = pathobj.os_stringify(program).encode('utf-8')
if is_exe(path):
return pathobj.concat(pathobj.getcwd(), program)
return null
elif not isinstance(program, String):
raise OldError(u"string or path expected to .which()")
program = as_cstring(program)
for path in os.environ.get("PATH").split(os.pathsep):
path = path.strip('"')
exe_file = os.path.join(path, program)
if is_exe(exe_file):
return from_cstring(exe_file)
return null
def entry_point(raw_argv):
lever_path = os.environ.get('LEVER_PATH')
if lever_path is None:
lever_path = pathobj.parse(default_lever_path)
else:
lever_path = pathobj.os_parse(lever_path.decode('utf-8'))
lever_path = pathobj.concat(pathobj.getcwd(), lever_path)
# This should happen only once.
uv_loop = uv.default_loop()
uv_idler = uv.malloc_bytes(uv.idle_ptr, uv.handle_size(uv.IDLE))
uv.idle_init(uv_loop, uv_idler)
uv_stdin = initialize_stdio(uv_loop, 0, 1)
uv_stdout = initialize_stdio(uv_loop, 1, 0)
uv_stderr = initialize_stdio(uv_loop, 2, 0)
base.module.setattr_force(u"stdin", uv_stdin)
base.module.setattr_force(u"stdout", uv_stdout)
base.module.setattr_force(u"stderr", uv_stderr)
base.module.setattr_force(u"runtime_path", lever_path)
ec = core.init_executioncontext(config, lever_path, uv_loop, uv_idler)
core.g.log = log = uv_logging.Logger(ec, uv_stdout, uv_stderr)
api.init(lever_path)
vectormath.init_random()
argv = [normal_startup]
for arg in raw_argv[1:]:
argv.append(space.String(arg.decode('utf-8')))
core.schedule(argv)
uv.run(ec.uv_loop, uv.RUN_DEFAULT)
#uv.loop_close(ec.uv_loop)
uv.tty_reset_mode()
log.last_chance_logging()
return ec.exit_status
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))
importer_poststage(py_module.module)
root_module.setcache(p, py_module.module, 0.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.
def start(main_script):
assert isinstance(main_script, String)
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)
@ModuleCache.builtin_method
@signature(ModuleCache)
def get_moduleinfo(self):
return moduleinfo(self.path)
root_module = ModuleScope(pathobj.parse(u"builtin:/"), frozen=True)
for py_module in stdlib.import_all_modules():
p = pathobj.concat(root_module.local, pathobj.parse(py_module.module.name))
root_module.setcache(p, py_module.module, 0.0)
def start(main_script):
assert isinstance(main_script, String)
lib_scope = ModuleScope(
pathobj.concat(main.get_ec().lever_path, pathobj.parse(u"lib")),
root_module)
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")
mi.default_config(this, scope)
mi.loadit(this)
def get_header(path):
return pathobj.concat(conf.headers_dir, path)
def init(lever_path):
conf.headers_dir = pathobj.concat(lever_path, pathobj.parse(u"headers"))
def get_header(path):
return pathobj.concat(conf.headers_dir, path)
def init(lever_path):
conf.headers_dir = pathobj.concat(lever_path, pathobj.parse(u"headers"))
def attach_compiler(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")
