duk_bi_thread.c File Reference

#include "duk_internal.h"

Go to the source code of this file.

Functions
DUK_INTERNAL duk_ret_t	duk_bi_thread_constructor (duk_context *ctx)
DUK_INTERNAL duk_ret_t	duk_bi_thread_resume (duk_context *ctx)
DUK_INTERNAL duk_ret_t	duk_bi_thread_yield (duk_context *ctx)
DUK_INTERNAL duk_ret_t	duk_bi_thread_current (duk_context *ctx)

Function Documentation

duk_bi_thread_constructor()

DUK_INTERNAL duk_ret_t duk_bi_thread_constructor

(

duk_context *

ctx

)

Definition at line 11 of file duktape-1.5.2/src-separate/duk_bi_thread.c.

                                                                   {
    duk_hthread *new_thr;
    duk_hobject *func;
 
    /* XXX: need a duk_require_func_or_lfunc_coerce() */
    if (!duk_is_callable(ctx, 0)) {
        return DUK_RET_TYPE_ERROR;
    }
    func = duk_require_hobject_or_lfunc_coerce(ctx, 0);
    DUK_ASSERT(func != NULL);
 
    duk_push_thread(ctx);
    new_thr = (duk_hthread *) duk_get_hobject(ctx, -1);
    DUK_ASSERT(new_thr != NULL);
    new_thr->state = DUK_HTHREAD_STATE_INACTIVE;
 
    /* push initial function call to new thread stack; this is
     * picked up by resume().
     */
    duk_push_hobject((duk_context *) new_thr, func);
 
    return 1;  /* return thread */
}

References DUK_ASSERT, duk_get_hobject(), DUK_HTHREAD_STATE_INACTIVE, duk_is_callable, duk_push_hobject(), duk_push_thread, duk_require_hobject_or_lfunc_coerce(), DUK_RET_TYPE_ERROR, NULL, and duk_hthread::state.

duk_bi_thread_current()

DUK_INTERNAL duk_ret_t duk_bi_thread_current

(

duk_context *

ctx

)

Definition at line 302 of file duktape-1.5.2/src-separate/duk_bi_thread.c.

                                                               {
    duk_push_current_thread(ctx);
    return 1;
}

References duk_push_current_thread().

duk_bi_thread_resume()

DUK_INTERNAL duk_ret_t duk_bi_thread_resume

(

duk_context *

ctx

)

Definition at line 50 of file duktape-1.5.2/src-separate/duk_bi_thread.c.

                                                              {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hthread *thr_resume;
    duk_tval *tv;
    duk_hobject *func;
    duk_hobject *caller_func;
    duk_small_int_t is_error;
 
    DUK_DDD(DUK_DDDPRINT("Duktape.Thread.resume(): thread=%!T, value=%!T, is_error=%!T",
                         (duk_tval *) duk_get_tval(ctx, 0),
                         (duk_tval *) duk_get_tval(ctx, 1),
                         (duk_tval *) duk_get_tval(ctx, 2)));
 
    DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING);
    DUK_ASSERT(thr->heap->curr_thread == thr);
 
    thr_resume = duk_require_hthread(ctx, 0);
    is_error = (duk_small_int_t) duk_to_boolean(ctx, 2);
    duk_set_top(ctx, 2);
 
    /* [ thread value ] */
 
    /*
     *  Thread state and calling context checks
     */
 
    if (thr->callstack_top < 2) {
        DUK_DD(DUK_DDPRINT("resume state invalid: callstack should contain at least 2 entries (caller and Duktape.Thread.resume)"));
        goto state_error;
    }
    DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1) != NULL);  /* us */
    DUK_ASSERT(DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1)));
    DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2) != NULL);  /* caller */
 
    caller_func = DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2);
    if (!DUK_HOBJECT_IS_COMPILEDFUNCTION(caller_func)) {
        DUK_DD(DUK_DDPRINT("resume state invalid: caller must be Ecmascript code"));
        goto state_error;
    }
 
    /* Note: there is no requirement that: 'thr->callstack_preventcount == 1'
     * like for yield.
     */
 
    if (thr_resume->state != DUK_HTHREAD_STATE_INACTIVE &&
        thr_resume->state != DUK_HTHREAD_STATE_YIELDED) {
        DUK_DD(DUK_DDPRINT("resume state invalid: target thread must be INACTIVE or YIELDED"));
        goto state_error;
    }
 
    DUK_ASSERT(thr_resume->state == DUK_HTHREAD_STATE_INACTIVE ||
               thr_resume->state == DUK_HTHREAD_STATE_YIELDED);
 
    /* Further state-dependent pre-checks */
 
    if (thr_resume->state == DUK_HTHREAD_STATE_YIELDED) {
        /* no pre-checks now, assume a previous yield() has left things in
         * tip-top shape (longjmp handler will assert for these).
         */
    } else {
        DUK_ASSERT(thr_resume->state == DUK_HTHREAD_STATE_INACTIVE);
 
        if ((thr_resume->callstack_top != 0) ||
            (thr_resume->valstack_top - thr_resume->valstack != 1)) {
            goto state_invalid_initial;
        }
        tv = &thr_resume->valstack_top[-1];
        DUK_ASSERT(tv >= thr_resume->valstack && tv < thr_resume->valstack_top);
        if (!DUK_TVAL_IS_OBJECT(tv)) {
            goto state_invalid_initial;
        }
        func = DUK_TVAL_GET_OBJECT(tv);
        DUK_ASSERT(func != NULL);
        if (!DUK_HOBJECT_IS_COMPILEDFUNCTION(func)) {
            /* Note: cannot be a bound function either right now,
             * this would be easy to relax though.
             */
            goto state_invalid_initial;
        }
 
    }
 
    /*
     *  The error object has been augmented with a traceback and other
     *  info from its creation point -- usually another thread.  The
     *  error handler is called here right before throwing, but it also
     *  runs in the resumer's thread.  It might be nice to get a traceback
     *  from the resumee but this is not the case now.
     */
 
#if defined(DUK_USE_AUGMENT_ERROR_THROW)
    if (is_error) {
        DUK_ASSERT_TOP(ctx, 2);  /* value (error) is at stack top */
        duk_err_augment_error_throw(thr);  /* in resumer's context */
    }
#endif
 
#ifdef DUK_USE_DEBUG
    if (is_error) {
        DUK_DDD(DUK_DDDPRINT("RESUME ERROR: thread=%!T, value=%!T",
                             (duk_tval *) duk_get_tval(ctx, 0),
                             (duk_tval *) duk_get_tval(ctx, 1)));
    } else if (thr_resume->state == DUK_HTHREAD_STATE_YIELDED) {
        DUK_DDD(DUK_DDDPRINT("RESUME NORMAL: thread=%!T, value=%!T",
                             (duk_tval *) duk_get_tval(ctx, 0),
                             (duk_tval *) duk_get_tval(ctx, 1)));
    } else {
        DUK_DDD(DUK_DDDPRINT("RESUME INITIAL: thread=%!T, value=%!T",
                             (duk_tval *) duk_get_tval(ctx, 0),
                             (duk_tval *) duk_get_tval(ctx, 1)));
    }
#endif
 
    thr->heap->lj.type = DUK_LJ_TYPE_RESUME;
 
    /* lj value2: thread */
    DUK_ASSERT(thr->valstack_bottom < thr->valstack_top);
    DUK_TVAL_SET_TVAL_UPDREF(thr, &thr->heap->lj.value2, &thr->valstack_bottom[0]);  /* side effects */
 
    /* lj value1: value */
    DUK_ASSERT(thr->valstack_bottom + 1 < thr->valstack_top);
    DUK_TVAL_SET_TVAL_UPDREF(thr, &thr->heap->lj.value1, &thr->valstack_bottom[1]);  /* side effects */
    DUK_TVAL_CHKFAST_INPLACE(&thr->heap->lj.value1);
 
    thr->heap->lj.iserror = is_error;
 
    DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL);  /* call is from executor, so we know we have a jmpbuf */
    duk_err_longjmp(thr);  /* execution resumes in bytecode executor */
    return 0;  /* never here */
 
 state_invalid_initial:
    DUK_ERROR_TYPE(thr, "invalid initial thread state/stack");
    return 0;  /* never here */
 
 state_error:
    DUK_ERROR_TYPE(thr, "invalid state");
    return 0;  /* never here */
}

References duk_hthread::callstack, duk_hthread::callstack_top, duk_heap::curr_thread, DUK_ACT_GET_FUNC, DUK_ASSERT, DUK_ASSERT_TOP, DUK_DD, DUK_DDD, DUK_DDDPRINT, DUK_DDPRINT, duk_err_augment_error_throw(), duk_err_longjmp(), DUK_ERROR_TYPE, duk_get_tval(), DUK_HOBJECT_IS_COMPILEDFUNCTION, DUK_HOBJECT_IS_NATIVEFUNCTION, DUK_HTHREAD_STATE_INACTIVE, DUK_HTHREAD_STATE_RUNNING, DUK_HTHREAD_STATE_YIELDED, DUK_LJ_TYPE_RESUME, duk_require_hthread(), duk_set_top(), duk_to_boolean(), DUK_TVAL_CHKFAST_INPLACE, DUK_TVAL_GET_OBJECT, DUK_TVAL_IS_OBJECT, DUK_TVAL_SET_TVAL_UPDREF, duk_hthread::heap, duk_ljstate::iserror, duk_ljstate::jmpbuf_ptr, duk_heap::lj, NULL, duk_hthread::state, duk_ljstate::type, duk_hthread::valstack, duk_hthread::valstack_bottom, duk_hthread::valstack_top, duk_ljstate::value1, and duk_ljstate::value2.

duk_bi_thread_yield()

DUK_INTERNAL duk_ret_t duk_bi_thread_yield

(

duk_context *

ctx

)

Definition at line 204 of file duktape-1.5.2/src-separate/duk_bi_thread.c.

                                                             {
    duk_hthread *thr = (duk_hthread *) ctx;
    duk_hobject *caller_func;
    duk_small_int_t is_error;
 
    DUK_DDD(DUK_DDDPRINT("Duktape.Thread.yield(): value=%!T, is_error=%!T",
                         (duk_tval *) duk_get_tval(ctx, 0),
                         (duk_tval *) duk_get_tval(ctx, 1)));
 
    DUK_ASSERT(thr->state == DUK_HTHREAD_STATE_RUNNING);
    DUK_ASSERT(thr->heap->curr_thread == thr);
 
    is_error = (duk_small_int_t) duk_to_boolean(ctx, 1);
    duk_set_top(ctx, 1);
 
    /* [ value ] */
 
    /*
     *  Thread state and calling context checks
     */
 
    if (!thr->resumer) {
        DUK_DD(DUK_DDPRINT("yield state invalid: current thread must have a resumer"));
        goto state_error;
    }
    DUK_ASSERT(thr->resumer->state == DUK_HTHREAD_STATE_RESUMED);
 
    if (thr->callstack_top < 2) {
        DUK_DD(DUK_DDPRINT("yield state invalid: callstack should contain at least 2 entries (caller and Duktape.Thread.yield)"));
        goto state_error;
    }
    DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1) != NULL);  /* us */
    DUK_ASSERT(DUK_HOBJECT_IS_NATIVEFUNCTION(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 1)));
    DUK_ASSERT(DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2) != NULL);  /* caller */
 
    caller_func = DUK_ACT_GET_FUNC(thr->callstack + thr->callstack_top - 2);
    if (!DUK_HOBJECT_IS_COMPILEDFUNCTION(caller_func)) {
        DUK_DD(DUK_DDPRINT("yield state invalid: caller must be Ecmascript code"));
        goto state_error;
    }
 
    DUK_ASSERT(thr->callstack_preventcount >= 1);  /* should never be zero, because we (Duktape.Thread.yield) are on the stack */
    if (thr->callstack_preventcount != 1) {
        /* Note: the only yield-preventing call is Duktape.Thread.yield(), hence check for 1, not 0 */
        DUK_DD(DUK_DDPRINT("yield state invalid: there must be no yield-preventing calls in current thread callstack (preventcount is %ld)",
                           (long) thr->callstack_preventcount));
        goto state_error;
    }
 
    /*
     *  The error object has been augmented with a traceback and other
     *  info from its creation point -- usually the current thread.
     *  The error handler, however, is called right before throwing
     *  and runs in the yielder's thread.
     */
 
#if defined(DUK_USE_AUGMENT_ERROR_THROW)
    if (is_error) {
        DUK_ASSERT_TOP(ctx, 1);  /* value (error) is at stack top */
        duk_err_augment_error_throw(thr);  /* in yielder's context */
    }
#endif
 
#ifdef DUK_USE_DEBUG
    if (is_error) {
        DUK_DDD(DUK_DDDPRINT("YIELD ERROR: value=%!T",
                             (duk_tval *) duk_get_tval(ctx, 0)));
    } else {
        DUK_DDD(DUK_DDDPRINT("YIELD NORMAL: value=%!T",
                             (duk_tval *) duk_get_tval(ctx, 0)));
    }
#endif
 
    /*
     *  Process yield
     *
     *  After longjmp(), processing continues in bytecode executor longjmp
     *  handler, which will e.g. update thr->resumer to NULL.
     */
 
    thr->heap->lj.type = DUK_LJ_TYPE_YIELD;
 
    /* lj value1: value */
    DUK_ASSERT(thr->valstack_bottom < thr->valstack_top);
    DUK_TVAL_SET_TVAL_UPDREF(thr, &thr->heap->lj.value1, &thr->valstack_bottom[0]);  /* side effects */
    DUK_TVAL_CHKFAST_INPLACE(&thr->heap->lj.value1);
 
    thr->heap->lj.iserror = is_error;
 
    DUK_ASSERT(thr->heap->lj.jmpbuf_ptr != NULL);  /* call is from executor, so we know we have a jmpbuf */
    duk_err_longjmp(thr);  /* execution resumes in bytecode executor */
    return 0;  /* never here */
 
 state_error:
    DUK_ERROR_TYPE(thr, "invalid state");
    return 0;  /* never here */
}

References duk_hthread::callstack, duk_hthread::callstack_preventcount, duk_hthread::callstack_top, duk_heap::curr_thread, DUK_ACT_GET_FUNC, DUK_ASSERT, DUK_ASSERT_TOP, DUK_DD, DUK_DDD, DUK_DDDPRINT, DUK_DDPRINT, duk_err_augment_error_throw(), duk_err_longjmp(), DUK_ERROR_TYPE, duk_get_tval(), DUK_HOBJECT_IS_COMPILEDFUNCTION, DUK_HOBJECT_IS_NATIVEFUNCTION, DUK_HTHREAD_STATE_RESUMED, DUK_HTHREAD_STATE_RUNNING, DUK_LJ_TYPE_YIELD, duk_set_top(), duk_to_boolean(), DUK_TVAL_CHKFAST_INPLACE, DUK_TVAL_SET_TVAL_UPDREF, duk_hthread::heap, duk_ljstate::iserror, duk_ljstate::jmpbuf_ptr, duk_heap::lj, NULL, duk_hthread::resumer, duk_hthread::state, duk_ljstate::type, duk_hthread::valstack_bottom, duk_hthread::valstack_top, and duk_ljstate::value1.