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

    assert(L == thread->L);

    26

    27

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

    28

    lua_pushthread(L);

    29

    lua_pushnil(L);

    30

    lua_settable(L, LUA_REGISTRYINDEX);

    31

    32

    // drop our ref

    33

    thread->L = NULL;

    34

    35

    // call

    36

    thread->cb_func(thread, err, thread->cb_arg);

    37

}

    38

    39

/**

    40

 * Execute the lua_resume with zero arguments, invoking the callback on succesful completion, and returning any

    41

 * error.

    42

 */

    43

static err_t lua_thread_resume (lua_State *L, struct lua_thread *thread, error_t *err)

    44

{

    45

    int ret;

    46

    47

    // invoke it

    48

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

    49

        case LUA_YIELD:

    50

            // ok, running, wait

    51

            return SUCCESS;

    52

    53

        case 0:

    54

            // done, notify user

    55

            lua_thread_done(L, thread, NULL);

    56

    57

            return SUCCESS;

    58

    59

        default:

    60

            // let caller handle

    61

            // XXX: backtrace...

    62

            return nexus_lua_error(L, ret, err);

    63

    }

    64

}

    65

    66

struct lua_thread_start_ctx {

    67

    struct lua_thread *thread;

    68

    const char *chunk;

    69

};

    70

    71

/**

    72

 * Setup the given newthread state, context, and load/run the given chunk

    73

 */

    74

static int lua_thread_setup (lua_State *L)

    75

{

    76

    struct lua_thread_start_ctx *ctx;

    77

    error_t err;

    78

    79

    // read the ctx argument off the stack

    80

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

    81

        luaL_error(L, "lua_touserdata");

    82

    83

    // push the thread state as the key

    84

    lua_pushthread(L);

    85

    86

    // push the lua_thread as the value

    87

    lua_pushlightuserdata(L, ctx->thread);

    88

    89

    // store L -> lua_thread mapping in the registry

    90

    lua_settable(L, LUA_REGISTRYINDEX);

    91

    92

    // clean up the stack

    93

    lua_pop(L, 1);

    94

    95

    // load the chunk as a lua function into the thread's state

    96

    if (nexus_lua_error(L, luaL_loadstring(L, ctx->chunk), &err))

    97

        luaL_error(L, "%s", error_msg(&err));

    98

    99

    // initial resume on the loaded chunk

   100

    if (lua_thread_resume(L, ctx->thread, &err))

   101

        luaL_error(L, "%s", error_msg(&err));

   102

   103

    // ok

   104

    return 0;

   105

}

   106

   107

static int _lua_thread_start (lua_State *L)

   108

{

   109

    struct lua_thread_start_ctx *ctx;

   110

    lua_State *TL;

   111

    error_t err;

   112

   113

    // read the ctx argument off the stack

   114

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

   115

        luaL_error(L, "lua_touserdata");

   116

   117

    // create new thread

   118

    TL = lua_newthread(L);

   119

   120

    // create thread and do setup on it

   121

    if (nexus_lua_error(TL, lua_cpcall(TL, lua_thread_setup, ctx), &err)) {

   122

        // cleanup stack (ctx, TL, error message)

   123

        lua_pop(L, 3);

   124

   125

        // pass on error

   126

        luaL_error(L, "lua_thread_setup: %s", error_msg(&err));

   127

    }

   128

   129

    // drop the thread for GC, we don't need it, and also our ctx arg

   130

    lua_pop(L, 2);

   131

   132

    // store

   133

    ctx->thread->L = TL;

   134

   135

    return 0;

   136

}

   137

   138

err_t lua_thread_start (struct lua_thread *thread, const char *chunk, error_t *err)

   139

{

   140

    struct lua_thread_start_ctx ctx = { thread, chunk };

   141

   142

    // sanity-check

   143

    assert(!thread->L);

   144

   145

    // use protected mode to setup

   146

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

   147

        return ERROR_CODE(err);

   148

   149

    // ok

   150

    return SUCCESS;

   151

}

   152

   153

void lua_thread_resume_state (lua_State *L)

   154

{

   155

    struct lua_thread *thread;

   156

    error_t err;

   157

   158

    // lookup the thread's context

   159

    lua_pushthread(L);

   160

    lua_gettable(L, LUA_REGISTRYINDEX);

   161

   162

    // get it as a pointer

   163

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

   164

        luaL_error(L, "lua_thread_resume_state: lua_touserdata");

   165

   166

    // handle the resume

   167

    if (lua_thread_resume(L, thread, &err))

   168

        // notify user

   169

        lua_thread_done(thread->L, thread, &err);

   170

}

   171