def listattr(self):
listing = space.Object.listattr(self)
listing.append(space.String(u"doc"))
listing.append(space.String(u"loc"))
listing.append(space.String(u"spec"))
listing.append(space.String(u"code"))
return listing
def getattr(self, name):
if name == u"doc":
return self.doc
elif name == u"loc":
source, start, stop = self.source_location
obj = space.Exnihilo()
obj.setattr(u"source", space.String(source))
obj.setattr(u"start", space.Integer(start))
obj.setattr(u"stop", space.Integer(stop))
return obj
elif name == u"spec":
argc, optional, variadic, varnames, argtypes = self.spec
varnames = [
space.String(name.decode('utf-8')) for name in varnames
]
spec = space.Exnihilo()
spec.setattr(u'argc', space.Integer(rffi.r_long(argc)))
spec.setattr(u'optional', space.Integer(rffi.r_long(optional)))
spec.setattr(u'is_variadic', space.boolean(variadic))
spec.setattr(u'varnames', space.List(list(varnames)))
if argtypes is not None:
spec.setattr(u'argtypes', space.List(list(argtypes)))
else:
spec.setattr(u'argtypes', space.null)
return spec
else:
return Object.getattr(self, name)
def getattr(self, name):
if name == u"name":
return space.String(err_name.decode('utf-8'))
elif name == u"strerror":
return space.String(
rffi.charp2str(uv.strerror(errno)).decode('utf-8'))
else:
return space.LException.getattr(self, name)
def setattr(self, name, value):
custom_interface = jit.promote(self.custom_interface)
method = custom_interface.lookup_method(u"+setattr")
if method is None:
return self.setattr_direct(name, value)
else:
return method.call([Id(self), space.String(name), value])
def from_file(path):
stream = bincode.decoder.open_file(path)
assert stream.read(8) == bincode.common.header
functions = []
for i in range(stream.read_u16()):
flags = stream.read_u16()
regc = stream.read_u16()
argc = stream.read_u16()
localc = stream.read_u16()
blocklen = stream.read_u16()
block = lltype.malloc(u16_array, blocklen)
for i in range(blocklen):
block[i] = rffi.r_ushort(stream.read_u16())
functions.append(Function(flags, regc, argc, localc, block))
constants = []
for i in range(stream.read_u16()):
klass = stream.read_ubyte()
if klass == 1:
constants.append(space.String(stream.read_string()))
elif klass == 2:
constants.append(space.Integer(rffi.r_long(stream.read_u64())))
elif klass == 3:
constants.append(space.Integer(-rffi.r_long(stream.read_u64())))
elif klass == 4:
constants.append(space.Float(stream.read_double()))
else:
assert False, klass
return Program(Unit(constants[:], functions[:]))
def listattr(self):
listing = Object.listattr(self)
for name, cell in self.cells.items():
if isinstance(cell, ShadowCell) and cell.link is not None:
continue
listing.append(space.String(name))
return listing
def Integer_to_string(integer, base):
base = 10 if base is None else base.value
if base >= len(digits):
raise space.unwind(space.LError(u"not enough digits to represent this base %d" % base))
if base < 0:
raise space.unwind(space.LError(u"negative base not supported"))
return space.String(integer_to_string(integer.value, base))
def log(self, which, obj):
entry = space.Exnihilo()
entry.setattr(u"type", space.String(which))
entry.setattr(u"value", obj)
for logger in list(self.loggers):
if logger.closed:
self.loggers.remove(logger)
else:
logger.append(entry)
return len(self.loggers)
def pc_location(self):
pc = self.pc
sources = self.sources
sourcemap = self.sourcemap
if not isinstance(sourcemap, space.Uint8Data):
return space.String(u"<no sourcemap>"), 0, 0, -1, -1
i = 0
while i < sourcemap.length:
i, count = dec_vlq(sourcemap, i)
i, file_id = dec_vlq(sourcemap, i)
i, col0 = dec_vlq(sourcemap, i)
i, lno0 = dec_vlq(sourcemap, i)
i, col1 = dec_vlq(sourcemap, i)
i, lno1 = dec_vlq(sourcemap, i)
if pc <= count and file_id < len(sources):
return sources[file_id], col0, lno0, col1, lno1
else:
pc -= count
return space.String(u"<over sourcemap>"), 0, 0, -1, -1
def decode_string(stream):
string = u''
stream.expect(u'"')
while not stream.shift(u'"'):
ch = stream.advance()
if ch == u'\\':
ch = stream.advance()
string += escape_ch(ch)
else:
string += ch
return space.String(string)
def log(self, which, obj):
entry = space.Exnihilo()
entry.setattr(u"type", space.String(which))
entry.setattr(u"value", obj)
if core.g.ec.get(
) is not self.ec: # TODO: Fix this using 'async' signaling?
return 0 # user logs are not getting
# cross-thread log messages.
for logger in list(self.loggers):
if logger.closed:
self.loggers.remove(logger)
else:
logger.append(entry)
return len(self.loggers)
def from_object(obj):
constants_list = obj.getitem(space.String(u"constants"))
assert isinstance(constants_list, space.List)
constants = constants_list.contents
functions = []
functions_list = obj.getitem(space.String(u"functions"))
assert isinstance(functions_list, space.List)
for function_list in functions_list.contents:
flags = as_i(function_list.getitem(space.Integer(0)))
regc = as_i(function_list.getitem(space.Integer(1)))
argc = rffi.r_ulong(as_i(function_list.getitem(space.Integer(2))))
topc = rffi.r_ulong(as_i(function_list.getitem(space.Integer(3))))
localc = as_i(function_list.getitem(space.Integer(4)))
block_list = function_list.getitem(space.Integer(5))
sourcemap = function_list.getitem(space.Integer(6))
exc_table = function_list.getitem(space.Integer(7))
assert isinstance(exc_table, space.List)
assert isinstance(block_list, space.List)
block = lltype.malloc(u16_array, len(block_list.contents))
i = 0
for n in block_list.contents:
block[i] = rffi.r_ushort(as_i(n))
i += 1
excs = []
for n in exc_table.contents:
excs.append(
Exc(
rffi.r_ulong(as_i(n.getitem(space.Integer(0)))),
rffi.r_ulong(as_i(n.getitem(space.Integer(1)))),
rffi.r_ulong(as_i(n.getitem(space.Integer(2)))),
rffi.r_ulong(as_i(n.getitem(space.Integer(3)))),
))
functions.append(
Function(flags, regc, argc, topc, localc, block, sourcemap,
excs[:]))
return Program(Unit(constants[:], functions[:]))
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 decode_json(action, ch, ctx):
if action == 0x1: # push list
ctx.ds.append(space.List([]))
# Push object to ds
elif action == 0x2: # push object
ctx.ds.append(space.Dict())
elif action == 0x3: # pop & append
val = ctx.ds.pop()
top = ctx.ds[len(ctx.ds) - 1]
assert isinstance(top, List) # we can trust this.
top.contents.append(val)
elif action == 0x4: # pop pop & setitem
val = ctx.ds.pop()
key = ctx.ds.pop()
top = ctx.ds[len(ctx.ds) - 1]
assert isinstance(top, Dict) # again..
top.data[key] = val
elif action == 0x5: # push null
ctx.ds.append(space.null)
elif action == 0x6: # push true
ctx.ds.append(space.true)
elif action == 0x7: # push false
ctx.ds.append(space.false)
elif action == 0x8: # push string
val = ctx.ss.build()
ctx.ds.append(space.String(val))
ctx.ss = UnicodeBuilder()
ctx.es = UnicodeBuilder()
elif action == 0x9:
val = int(ctx.ss.build().encode('utf-8')) # push int
ctx.ds.append(space.Integer(val))
ctx.ss = UnicodeBuilder()
elif action == 0xA:
val = float(ctx.ss.build().encode('utf-8')) # push float
ctx.ds.append(space.Float(val))
ctx.ss = UnicodeBuilder()
elif action == 0xB: # push ch to ss
ctx.ss.append(ch)
elif action == 0xC: # push ch to es
ctx.es.append(ch)
elif action == 0xD: # push escape
ctx.ss.append(unichr(escape_characters[ch]))
elif action == 0xE: # push unicode point
ctx.ss.append(unichr(int(ctx.es.build().encode('utf-8'), 16)))
ctx.es = UnicodeBuilder()
else: # This is very unlikely to happen.
assert False, "JSON decoder bug"
def Dict_update(self, other):
if isinstance(other, Dict):
self.data.update(other.data)
elif isinstance(other, space.Exnihilo):
for name in other.map.attribute_indexes:
self.setitem(space.String(name), other.getattr(name))
else:
it = other.iter()
try:
while True:
item = it.callattr(u"next", [])
key = item.getitem(Integer(0))
val = item.getitem(Integer(1))
self.setitem(key, val)
except StopIteration as stop:
pass
return space.null
def instantiate(other):
dict_ = Dict()
if other is not None:
if isinstance(other, Dict):
dict_.data.update(other.data)
elif isinstance(other, space.Exnihilo):
for name in other.map.attribute_indexes:
dict_.setitem(space.String(name), other.getattr(name))
else:
it = other.iter()
try:
while True:
item = it.callattr(u"next", [])
key = item.getitem(Integer(0))
val = item.getitem(Integer(1))
dict_.setitem(key, val)
except StopIteration as stop:
pass
return dict_
def other(self, which, obj):
if self.log(which, obj) == 0:
std = self.stderr if which != u"info" else self.stdout
if which == u"info" and isinstance(obj, space.List):
sep = u''
out = u""
for arg in obj.contents:
if isinstance(arg, space.String):
string = arg.string
else:
string = arg.repr()
out += sep + string
sep = u' '
obj = space.String(out)
if isinstance(obj, space.String):
data = obj.string.encode('utf-8') + "\n"
else:
data = obj.repr().encode('utf-8') + "\n"
self.write_message(std, data)
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
def utf8_decoder_call(self, data):
return space.String(utf8_decoder_operate(self, data.to_str(), False))
def get_config(config, text, default):
return config.data.get(space.String(text), default)
def listattr(self):
listing = space.Object.listattr(self)
listing.append(space.String(u"doc"))
listing.append(space.String(u"source_location"))
listing.append(space.String(u"spec"))
return listing
def from_object(obj, path):
if as_i(obj.getitem(space.String(u"version"))) != 0:
raise space.unwind(space.LError(u"bytecode version=0 required"))
sources = as_list(obj.getitem(space.String(u"sources")))
constants = as_list(obj.getitem(space.String(u"constants")))
functions = []
for function_list in as_list(obj.getitem(space.String(u"functions"))):
flags = as_i(function_list.getitem(space.String(u"flags")))
regc = as_i(function_list.getitem(space.String(u"regc")))
argc = rffi.r_ulong(as_i(function_list.getitem(space.String(u"argc"))))
topc = rffi.r_ulong(as_i(function_list.getitem(space.String(u"topc"))))
localc = as_i(function_list.getitem(space.String(u"localc")))
block_list = as_u8a(function_list.getitem(space.String(u"code")))
sourcemap = function_list.getitem(space.String(u"sourcemap"))
exc_table = as_list(function_list.getitem(space.String(u"exceptions")))
block = [
getindex_u16(block_list, i) for i in range(block_list.length / 2)
]
#block = lltype.malloc(u16_array, block_list.length/2)
#for i in range(block_list.length/2):
# a = rffi.r_long(block_list.uint8data[i*2+0])
# b = rffi.r_long(block_list.uint8data[i*2+1])
# block[i] = rffi.r_ushort((a << 8) | b)
excs = [
Exc(rffi.r_ulong(as_i(n.getitem(space.Integer(0)))),
rffi.r_ulong(as_i(n.getitem(space.Integer(1)))),
rffi.r_ulong(as_i(n.getitem(space.Integer(2)))),
rffi.r_ulong(as_i(n.getitem(space.Integer(3)))))
for n in exc_table
]
#excs = []
#for n in exc_table:
# excs.append()
varnames = space.null # TODO: #function_list.getitem(space.String(u"varnames"))
functions.append(
Function(flags, regc, argc, topc, localc, block, sourcemap,
excs[:], varnames))
return Program(Unit(constants[:], functions[:], sources[:], path))
def listattr(self):
listing = []
for name in self.__class__.interface.methods.keys():
listing.append(space.String(name))
return listing
def listattr(self):
listing = []
listing.append(space.String(u"doc"))
for methodname in self.methods.keys():
listing.append(space.String(methodname))
return listing
def write_string(obj, config):
return space.String(configured_stringify(obj, config))
def Utf8Decoder_finish(self):
return space.String(utf8_decoder_operate(self, '', True))
def listattr(self):
listing = Object.listattr(self)
listing.append(space.String(u"link"))
listing.append(space.String(u"name"))
listing.append(space.String(u"parent"))
return listing
def listattr(self):
listing = Object.listattr(self)
for name in self.cells:
listing.append(space.String(name))
return listing
def Float_to_string(self):
return space.String(float_to_string(self.number))
def listattr(self):
listing = Object.listattr(self)
for name in self.map.attribute_indexes:
listing.append(space.String(name))
return listing
