1

#ifndef LUA_THREAD_H

     2

#define LUA_THREAD_H

     3

     4

/**

     5

 * @file

     6

 *

     7

 * Running code as lua coroutines for a nexus_lua

     8

 */

     9

#include "nexus_lua.h"

    10

#include <lua5.1/lua.h>

    11

    12

/*

    13

 * Forward-declare

    14

 */

    15

struct lua_thread;

    16

    17

/**

    18

 * Callback for async execution completion. The thread will be cleaned up for re-use before this is called.

    19

 *

    20

 * Called with err == NULL for success, error code otherwise.

    21

 *

    22

 * XXX: also return execution results (as a lua_State arg)?

    23

 */

    24

typedef void (*lua_thread_cb) (const error_t *err, void *arg);

    25

    26

/**

    27

 * A thread of execution

    28

 */

    29

struct lua_thread {

    30

    /** The lua_nexus environment we're running under */

    31

    struct nexus_lua *lua;

    32

    33

    /** Callback */

    34

    lua_thread_cb cb_func;

    35

    36

    /** Callback context argument */

    37

    void *cb_arg;

    38

    39

    /** Real lua thread state */

    40

    lua_State *L;

    41

};

    42

    43

/**

    44

 * Initialize the given lua_thread state for execution.

    45

 *

    46

 * You only need to call this once for each lua_thread that you use.

    47

 */

    48

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

    49

    50

/**

    51

 * Execute the given chunk in a thread context.

    52

 *

    53

 * This should be called from unprotected mode, and the thread must currently not be active.

    54

 *

    55

 * This will load the chunk, create a new lua thread state off the lua_nexus, and then do the initial 'lua_resume' call

    56

 * on the loaded chunk, to execute up to the first yield or final return.

    57

 *

    58

 * If this process raises an error, it will be returned directly. If the called chunk simply returns without yielding,

    59

 * this returns 0, and the callback is *NOT* called. Otherwise, this returns >0 and the thread's callback function will

    60

 * eventually be called once the thread either errors out or finishes execution.

    61

 */

    62

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

    63

    64

/**

    65

 * Protected-mode function to yield execution of the given lua_State, which must be a luaState created with

    66

 * lua_thread_start.

    67

 *

    68

 * This should be called the same way as lua_yield, except no results are supported yet.

    69

 */

    70

int lua_thread_yield_state (lua_State *L);

    71

    72

/**

    73

 * Resume execution of the given lua_State, which must be a lua_State created with lua_thread_start.

    74

 */

    75

void lua_thread_resume_state (lua_State *L);

    76

    77

/**

    78

 * Abort execution of the given thread, if it's running.

    79

 *

    80

 * Currently, there is no mechanism to actually abort a running thread, so this will instead release the lua_thread for

    81

 * new use, and then cause the lua_thread_resume to do nothing. 

    82

 */

    83

void lua_thread_abort (struct lua_thread *thread);

    84

    85

#endif