GCC Code Coverage Report

Line	Branch	Decision	Exec	Source
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