1

#include "lua_thread.h"

     2

#include "log.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

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

    72

 * (true for yielded, false for done).

    73

 */

    74

static int _lua_thread_start (lua_State *L)

    75

{

    76

    struct lua_thread_start_ctx *ctx;

    77

    lua_State *TL;

    78

    error_t err;

    79

    int ret;

    80

    81

    // read the ctx argument off the stack

    82

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

    83

        return luaL_error(L, "lua_touserdata");

    84

    else

    85

        lua_pop(L, 1);

    86

    87

    // check

    88

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

    89

    90

    // create new thread

    91

    TL = lua_newthread(L);

    98

    99

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

   100

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

   101

        goto error;

   102

   103

    // initial resume on the loaded chunk

   104

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

   105

        goto error;

   106

   107

    // yielded?

   108

    if (ret) 

   109

        // store

   110

        ctx->thread->L = TL;

   111

   112

    // pop thread to release for GC

   113

    lua_pop(L, 1);

   114

   115

    return 0;

   116

   117

error:

   118

    // pop thread to release for GC

   119

    lua_pop(L, 1);

   120

   121

    // drop ref

   122

    ctx->thread->L = NULL;

   123

   124

    // pass on error

   125

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

   126

}

   127

   128

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

   129

{

   130

    struct lua_thread_start_ctx ctx = { thread, chunk };

   131

   132

    // sanity-check

   133

    assert(!thread->L);

   134

   135

    // use protected mode to setup

   136

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

   137

        return -ERROR_CODE(err);

   138

   139

    // return true if yielded, false if done

   140

    return (thread->L != NULL);

   141

}

   142

   143

int lua_thread_yield_state (lua_State *L)

   144

{

   145

    return lua_yield(L, 0);

   146

}

   147

   148

static int _lua_thread_resume_state (lua_State *L)

   149

{

   150

    struct lua_thread *thread;

   151

    error_t err;

   152

    int ret;

   153

   154

    // pop irrelevant context arg

   155

    lua_pop(L, 1);

   156

   157

    // lookup the thread's context

   158

    lua_pushthread(L);

   159

    lua_gettable(L, LUA_REGISTRYINDEX);

   160

   161

    // not registered?

   162

    if (lua_isnil(L, -1))

   163

        return luaL_error(L, "not a registered lua_thread state");

   164

   165

    else if (lua_isboolean(L, -1) && !lua_toboolean(L, -1))

   166

        return luaL_error(L, "lua_thread was aborted");

   167

   168

    // get it as a pointer

   169

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

   170

        return luaL_error(L, "lua_touserdata");

   171

    else

   172

        lua_pop(L, 1);

   173

   174

    // handle the resume

   175

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

   176

        // notify user

   177

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

   178

   179

    // finished?

   180

    else if (ret == 0)

   181

        lua_thread_done(thread->L, thread, NULL);

   182

   183

    // ok

   184

    return 0;

   185

}

   186

   187

void lua_thread_resume_state (lua_State *L)

   188

{

   189

    error_t err;

   190

   191

    // execute in protected mode

   192

    if (nexus_lua_error(L, lua_cpcall(L, _lua_thread_resume_state, NULL), &err))

   193

        log_warn_error(&err, "%p", L);

   194

}

   195

   196

static int _lua_thread_abort (lua_State *L)

   197

{

   198

    struct lua_thread *thread;

   199

   200

    // get context arg

   201

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

   202

        luaL_error(L, "lua_thread_resume_state: lua_touserdata");

   203

    else

   204

        lua_pop(L, 1);

   205

   206

    // no mechanism to actually abort the underlying wait yet

   207

    (void) thread;

   208

   209

    // invalidate in registry for later lua_thread_resume_state

   210

    lua_pushthread(L);

   211

    lua_pushboolean(L, false);

   212

    lua_settable(L, LUA_REGISTRYINDEX);

   213

   214

    // not much else we can do

   215

    return 0;

   216

}

   217

   218

void lua_thread_abort (struct lua_thread *thread)

   219

{

   220

    error_t err;

   221

   222

    if (!thread->L)

   223

        // no thread executing

   224

        return;

   225

   226

    // use protected mode

   227

    if (nexus_lua_error(thread->L, lua_cpcall(thread->L, _lua_thread_abort, thread), &err))

   228

        log_warn_error(&err, "_lua_thread_abort");

   229

   230

    // unset

   231

    thread->L = NULL;

   232

}

   233