main.py

from rpython.rlib import jit
from rpython.rtyper.lltypesystem import rffi, lltype, llmemory
import vectormath
from evaluator.loader import TraceEntry
import uv_stream
import base
import space
import time
import module_resolution
import os
import pathobj
import rlibuv as uv
from stdlib import api # XXX: perhaps give every module an init?
                       # Probably better way is to move the path resolution from api into here.
import core
import uv_logging

@jit.dont_look_inside # cast_ptr_to_adr
def wakeup_sleeper(handle):
    ec = core.get_ec()

    task = ec.uv_sleepers.pop( rffi.cast_ptr_to_adr(handle) )
    ec.enqueue(task)

    uv.timer_stop(handle)
    uv.close(rffi.cast(uv.handle_ptr, handle), uv.free)

inf = float("inf")

def new_entry_point(config, default_lever_path=u''):
    import naming
    naming.breath_first_search(base.module, 1.0)
    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)
        core.g.finalizer_ec = ec
        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)

        live = True
        while live:
            uv.run(ec.uv_loop, uv.RUN_DEFAULT)
            live = core.enqueue_for_exit(ec)

        #uv.loop_close(ec.uv_loop)

        uv.tty_reset_mode()
        log.last_chance_logging()
        return ec.exit_status
    return entry_point

@space.Builtin
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

class Suspended(object):
    _immutable_fields_ = ['wakeup', 'greenlet']
    def __init__(self, wakeup, greenlet):
        assert isinstance(greenlet, Greenlet)
        self.wakeup = wakeup
        self.greenlet = greenlet

@base.builtin
def sleep(argv):
    if len(argv) == 1:
        return sleep_greenlet(argv)
    elif len(argv) == 2:
        return sleep_callback(argv)
    else:
        raise space.OldError(u"expected 1 or 2 arguments to sleep(), got %d" % len(argv))

@space.signature(space.Float)
@jit.dont_look_inside # cast_ptr_to_adr
def sleep_greenlet(duration):
    ec = core.get_ec()
    if ec.current == ec.eventloop:
        raise space.OldError(u"bad context for greenlet sleep")
    assert ec.current.is_exhausted() == False

    uv_sleeper = uv.malloc_bytes(uv.timer_ptr, uv.handle_size(uv.TIMER))
    ec.uv_sleepers[rffi.cast_ptr_to_adr(uv_sleeper)] = ec.current
    uv.timer_init(ec.uv_loop, uv_sleeper)
    uv.timer_start(uv_sleeper, wakeup_sleeper, int(duration.number*1000), 0)

    return core.switch([ec.eventloop])

@space.signature(space.Float, space.Object)
@jit.dont_look_inside # cast_ptr_to_adr
def sleep_callback(duration, func):
    ec = core.get_ec()

    uv_sleeper = uv.malloc_bytes(uv.timer_ptr, uv.handle_size(uv.TIMER))
    ec.uv_sleepers[rffi.cast_ptr_to_adr(uv_sleeper)] = core.to_greenlet([func])
    uv.timer_init(ec.uv_loop, uv_sleeper)
    uv.timer_start(uv_sleeper, wakeup_sleeper, int(duration.number*1000), 0)
    return space.null


# This is a rare case when it's better to do nothing than
# something, even if it means that we won't get any
# diagnostics of the error.
def initialize_stdio(uv_loop, fd, readable):
    from uv_stream import TTY, Pipe
    from stdlib.fs import File, ReadStream, WriteStream
    handle_type = uv.guess_handle(fd)
    if handle_type == uv.TTY:
        tty = lltype.malloc(uv.tty_ptr.TO, flavor="raw", zero=True)
        status = uv.tty_init(uv_loop, tty, fd, readable)
        if status < 0:
            lltype.free(tty, flavor='raw')
            return space.null
        return TTY(tty, fd)
    elif handle_type == uv.NAMED_PIPE:
        pipe = lltype.malloc(uv.pipe_ptr.TO, flavor="raw", zero=True)
        status = uv.pipe_init(uv_loop, pipe, 1)
        if status >= 0:
            status = uv.pipe_open(pipe, fd)
        if status < 0:
            lltype.free(pipe, flavor='raw')
            return space.null
        return Pipe(pipe)
    elif handle_type == uv.FILE:
        if readable != 0:
            return ReadStream(File(fd), 0)
        else:
            return WriteStream(File(fd), 0)
    else:
        return space.null