1

#include "lua_thread.h"

     2

     3

#include <string.h>

     4

#include <assert.h>

     5

     6

#include <lua5.1/lauxlib.h>

     7

     8

     9

void lua_thread_init (struct lua_thread *thread, struct nexus_lua *lua, lua_thread_cb cb_func, void *cb_arg)

    10

{

    11

    // zero

    12

    memset(thread, 0, sizeof(*thread));

    13

    14

    // store

    15

    thread->lua = lua;

    16

    thread->cb_func = cb_func;

    17

    thread->cb_arg = cb_arg;

    18

}

    19

    20

/**

    21

 * Thread completed, cleanup and call user callback with given error (NULL for success).

    22

 */

    23

static void lua_thread_done (lua_State *L, struct lua_thread *thread, error_t *err)

    24

{

    25

    // remove from registry so thread can be GC'd

    26

    lua_pushthread(L);

    27

    lua_pushnil(L);

    28

    lua_settable(L, LUA_REGISTRYINDEX);

    29

    30

    // drop our ref

    31

    thread->L = NULL;

    32

    33

    // call

    35

}

    36

    37

/**

    40

 */

    42

{

    43

    int ret;

    44

    47

    // invoke it

    48

    switch ((ret = lua_resume(L, 0))) {

    49

        case LUA_YIELD:

    50

            // ok, running, wait

    52

    53

        case 0:

    56

    57

        default:

    58

            // let caller handle

    59

            // XXX: backtrace...

    61

    }

    62

}

    63

    64

struct lua_thread_start_ctx {

    65

    struct lua_thread *thread;

    66

    const char *chunk;

    67

};

    68

    69

/**

    71

 */

    72

static int lua_thread_setup (lua_State *L)

    73

{

    74

    struct lua_thread_start_ctx *ctx;

    75

    76

    // read the ctx argument off the stack

    77

    if ((ctx = lua_touserdata(L, 1)) == NULL)

    79

    80

    // push the thread state as the key

    81

    lua_pushthread(L);

    82

    83

    // push the lua_thread as the value

    84

    lua_pushlightuserdata(L, ctx->thread);

    85

    86

    // store L -> lua_thread mapping in the registry

    87

    lua_settable(L, LUA_REGISTRYINDEX);

    88

    89

    // clean up the stack

    90

    lua_pop(L, 1);

    91

    92

    // ok

    93

    return 0;

    94

}

    95

   100

static int _lua_thread_start (lua_State *L)

   101

{

   102

    struct lua_thread_start_ctx *ctx;

   103

    lua_State *TL;

   104

    error_t err;

   106

   107

    // read the ctx argument off the stack

   108

    if ((ctx = lua_touserdata(L, 1)) == NULL)

   112

   116

    // create new thread

   117

    TL = lua_newthread(L);

   119

    // create thread and do setup on it

   122

   135

   138

   139

    return 0;

   150

}

   151

   153

{

   154

    struct lua_thread_start_ctx ctx = { thread, chunk };

   155

   156

    // sanity-check

   157

    assert(!thread->L);

   158

   159

    // use protected mode to setup

   160

    if (nexus_lua_error(thread->lua->st, lua_cpcall(thread->lua->st, _lua_thread_start, &ctx), err))

   162

   165

}

   166

   167

void lua_thread_resume_state (lua_State *L)

   168

{

   169

    struct lua_thread *thread;

   170

    error_t err;

   172

   173

    // lookup the thread's context

   174

    lua_pushthread(L);

   175

    lua_gettable(L, LUA_REGISTRYINDEX);

   176

   177

    // get it as a pointer

   178

    if ((thread = lua_touserdata(L, -1)) == NULL)

   179

        luaL_error(L, "lua_thread_resume_state: lua_touserdata");

   180

   181

    // handle the resume

   183

        // notify user

   189

}

   190