1

#include "lua_thread.h"

     3

     4

#include <string.h>

     5

#include <assert.h>

     6

     7

#include <lua5.1/lauxlib.h>

     8

     9

    10

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

    11

{

    12

    // zero

    13

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

    14

    15

    // store

    16

    thread->lua = lua;

    17

    thread->cb_func = cb_func;

    18

    thread->cb_arg = cb_arg;

    19

}

    20

    21

/**

    22

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

    23

 */

    24

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

    25

{

    26

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

    27

    lua_pushthread(L);

    28

    lua_pushnil(L);

    29

    lua_settable(L, LUA_REGISTRYINDEX);

    30

    31

    // drop our ref

    32

    thread->L = NULL;

    33

    34

    // call

    35

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

    36

}

    37

    38

/**

    39

 * Execute the lua_resume with zero arguments. If the thread finished, this returns zero, if it yielded, >0. For

    40

 * errors, returns -err_t.

    41

 */

    42

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

    43

{

    44

    int ret;

    45

    46

    (void) thread;

    47

    48

    // invoke it

    49

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

    50

        case LUA_YIELD:

    51

            // ok, running, wait

    52

            return 1;

    53

    54

        case 0:

    55

            // done

    56

            return 0;

    57

    58

        default:

    59

            // let caller handle

    60

            // XXX: backtrace...

    61

            return -nexus_lua_error(L, ret, err);

    62

    }

    63

}

    64

    65

struct lua_thread_start_ctx {

    66

    struct lua_thread *thread;

    67

    const char *chunk;

    68

};

    69

    70

/**

    71

 * Setup the given newthread's state

    72

 */

    73

static int lua_thread_setup (lua_State *L)

    74

{

    75

    struct lua_thread_start_ctx *ctx;

    76

    77

    // read the ctx argument off the stack

    78

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

    79

        return luaL_error(L, "lua_touserdata");

    80

    81

    // push the thread state as the key

    82

    lua_pushthread(L);

    83

    84

    // push the lua_thread as the value

    85

    lua_pushlightuserdata(L, ctx->thread);

    86

    87

    // store L -> lua_thread mapping in the registry

    88

    lua_settable(L, LUA_REGISTRYINDEX);

    89

    90

    // clean up the stack

    91

    lua_pop(L, 1);

    92

    93

    // ok

    94

    return 0;

    95

}

    96

    97

/**

    98

 * Create a new thread, set it up, and run the initial resume, returning the boolean result of that

    99

 * (true for yielded, false for done).

   100

 */

   101

static int _lua_thread_start (lua_State *L)

   102

{

   103

    struct lua_thread_start_ctx *ctx;

   104

    lua_State *TL;

   105

    error_t err;

   106

    int ret;

   107

   108

    // read the ctx argument off the stack

   109

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

   110

        return luaL_error(L, "lua_touserdata");

   111

    else

   112

        lua_pop(L, 1);

   113

   114

    // check

   115

    assert(!ctx->thread->L);

   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

        goto error;

   123

   124

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

   125

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

   126

        goto error;

   127

   128

    // initial resume on the loaded chunk

   129

    if ((ret = lua_thread_resume(TL, ctx->thread, &err)) < 0)

   130

        goto error;

   131

   132

    // yielded?

   133

    if (ret) 

   134

        // store

   135

        ctx->thread->L = TL;

   136

   137

    // pop thread to release for GC

   138

    lua_pop(L, 1);

   139

   140

    return 0;

   141

   142

error:

   143

    // pop thread to release for GC

   144

    lua_pop(L, 1);

   145

   146

    // drop ref

   147

    ctx->thread->L = NULL;

   148

   149

    // pass on error

   150

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

   151

}

   152

   153

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

   154

{

   155

    struct lua_thread_start_ctx ctx = { thread, chunk };

   156

   157

    // sanity-check

   158

    assert(!thread->L);

   159

   160

    // use protected mode to setup

   161

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

   162

        return -ERROR_CODE(err);

   163

   164

    // return true if yielded, false if done

   165

    return (thread->L != NULL);

   166

}

   167

   174

{

   175

    struct lua_thread *thread;

   176

    error_t err;

   177

    int ret;

   178

   182

    // lookup the thread's context

   183

    lua_pushthread(L);

   184

    lua_gettable(L, LUA_REGISTRYINDEX);

   192

   193

    // get it as a pointer

   194

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

   198

   199

    // handle the resume

   200

    if ((ret = lua_thread_resume(L, thread, &err)) < 0)

   201

        // notify user

   203

   204

    // finished?

   210

}

   211