1 /* 2 ** $Id: lcorolib.c $ 3 ** Coroutine Library 4 ** See Copyright Notice in lua.h 5 */ 6 7 #define lcorolib_c 8 #define LUA_LIB 9 10 #include "lprefix.h" 11 12 13 #include <stdlib.h> 14 15 #include "lua.h" 16 17 #include "lauxlib.h" 18 #include "lualib.h" 19 20 21 static lua_State *getco (lua_State *L) { 22 lua_State *co = lua_tothread(L, 1); 23 luaL_argexpected(L, co, 1, "thread"); 24 return co; 25 } 26 27 28 /* 29 ** Resumes a coroutine. Returns the number of results for non-error 30 ** cases or -1 for errors. 31 */ 32 static int auxresume (lua_State *L, lua_State *co, int narg) { 33 int status, nres; 34 if (l_unlikely(!lua_checkstack(co, narg))) { 35 lua_pushliteral(L, "too many arguments to resume"); 36 return -1; /* error flag */ 37 } 38 lua_xmove(L, co, narg); 39 status = lua_resume(co, L, narg, &nres); 40 if (l_likely(status == LUA_OK || status == LUA_YIELD)) { 41 if (l_unlikely(!lua_checkstack(L, nres + 1))) { 42 lua_pop(co, nres); /* remove results anyway */ 43 lua_pushliteral(L, "too many results to resume"); 44 return -1; /* error flag */ 45 } 46 lua_xmove(co, L, nres); /* move yielded values */ 47 return nres; 48 } 49 else { 50 lua_xmove(co, L, 1); /* move error message */ 51 return -1; /* error flag */ 52 } 53 } 54 55 56 static int luaB_coresume (lua_State *L) { 57 lua_State *co = getco(L); 58 int r; 59 r = auxresume(L, co, lua_gettop(L) - 1); 60 if (l_unlikely(r < 0)) { 61 lua_pushboolean(L, 0); 62 lua_insert(L, -2); 63 return 2; /* return false + error message */ 64 } 65 else { 66 lua_pushboolean(L, 1); 67 lua_insert(L, -(r + 1)); 68 return r + 1; /* return true + 'resume' returns */ 69 } 70 } 71 72 73 static int luaB_auxwrap (lua_State *L) { 74 lua_State *co = lua_tothread(L, lua_upvalueindex(1)); 75 int r = auxresume(L, co, lua_gettop(L)); 76 if (l_unlikely(r < 0)) { /* error? */ 77 int stat = lua_status(co); 78 if (stat != LUA_OK && stat != LUA_YIELD) { /* error in the coroutine? */ 79 stat = lua_closethread(co, L); /* close its tbc variables */ 80 lua_assert(stat != LUA_OK); 81 lua_xmove(co, L, 1); /* move error message to the caller */ 82 } 83 if (stat != LUA_ERRMEM && /* not a memory error and ... */ 84 lua_type(L, -1) == LUA_TSTRING) { /* ... error object is a string? */ 85 luaL_where(L, 1); /* add extra info, if available */ 86 lua_insert(L, -2); 87 lua_concat(L, 2); 88 } 89 return lua_error(L); /* propagate error */ 90 } 91 return r; 92 } 93 94 95 static int luaB_cocreate (lua_State *L) { 96 lua_State *NL; 97 luaL_checktype(L, 1, LUA_TFUNCTION); 98 NL = lua_newthread(L); 99 lua_pushvalue(L, 1); /* move function to top */ 100 lua_xmove(L, NL, 1); /* move function from L to NL */ 101 return 1; 102 } 103 104 105 static int luaB_cowrap (lua_State *L) { 106 luaB_cocreate(L); 107 lua_pushcclosure(L, luaB_auxwrap, 1); 108 return 1; 109 } 110 111 112 static int luaB_yield (lua_State *L) { 113 return lua_yield(L, lua_gettop(L)); 114 } 115 116 117 #define COS_RUN 0 118 #define COS_DEAD 1 119 #define COS_YIELD 2 120 #define COS_NORM 3 121 122 123 static const char *const statname[] = 124 {"running", "dead", "suspended", "normal"}; 125 126 127 static int auxstatus (lua_State *L, lua_State *co) { 128 if (L == co) return COS_RUN; 129 else { 130 switch (lua_status(co)) { 131 case LUA_YIELD: 132 return COS_YIELD; 133 case LUA_OK: { 134 lua_Debug ar; 135 if (lua_getstack(co, 0, &ar)) /* does it have frames? */ 136 return COS_NORM; /* it is running */ 137 else if (lua_gettop(co) == 0) 138 return COS_DEAD; 139 else 140 return COS_YIELD; /* initial state */ 141 } 142 default: /* some error occurred */ 143 return COS_DEAD; 144 } 145 } 146 } 147 148 149 static int luaB_costatus (lua_State *L) { 150 lua_State *co = getco(L); 151 lua_pushstring(L, statname[auxstatus(L, co)]); 152 return 1; 153 } 154 155 156 static int luaB_yieldable (lua_State *L) { 157 lua_State *co = lua_isnone(L, 1) ? L : getco(L); 158 lua_pushboolean(L, lua_isyieldable(co)); 159 return 1; 160 } 161 162 163 static int luaB_corunning (lua_State *L) { 164 int ismain = lua_pushthread(L); 165 lua_pushboolean(L, ismain); 166 return 2; 167 } 168 169 170 static int luaB_close (lua_State *L) { 171 lua_State *co = getco(L); 172 int status = auxstatus(L, co); 173 switch (status) { 174 case COS_DEAD: case COS_YIELD: { 175 status = lua_closethread(co, L); 176 if (status == LUA_OK) { 177 lua_pushboolean(L, 1); 178 return 1; 179 } 180 else { 181 lua_pushboolean(L, 0); 182 lua_xmove(co, L, 1); /* move error message */ 183 return 2; 184 } 185 } 186 default: /* normal or running coroutine */ 187 return luaL_error(L, "cannot close a %s coroutine", statname[status]); 188 } 189 } 190 191 192 static const luaL_Reg co_funcs[] = { 193 {"create", luaB_cocreate}, 194 {"resume", luaB_coresume}, 195 {"running", luaB_corunning}, 196 {"status", luaB_costatus}, 197 {"wrap", luaB_cowrap}, 198 {"yield", luaB_yield}, 199 {"isyieldable", luaB_yieldable}, 200 {"close", luaB_close}, 201 {NULL, NULL} 202 }; 203 204 205 206 LUAMOD_API int luaopen_coroutine (lua_State *L) { 207 luaL_newlib(L, co_funcs); 208 return 1; 209 } 210 211