Tamar 0.7.5 → 0.7.6

Sign up to get free protection for your applications and to get access to all the features.
Files changed (118) hide show
  1. data/.gitmodules +3 -0
  2. data/HISTORY +22 -5
  3. data/Tamar.gemspec +114 -1
  4. data/VERSION +1 -1
  5. data/src/lua/CMakeLists.txt +176 -0
  6. data/src/lua/COPYRIGHT +34 -0
  7. data/src/lua/FindReadline.cmake +25 -0
  8. data/src/lua/HISTORY +183 -0
  9. data/src/lua/INSTALL +99 -0
  10. data/src/lua/Makefile +128 -0
  11. data/src/lua/README +46 -0
  12. data/src/lua/dist.cmake +450 -0
  13. data/src/lua/dist.info +10 -0
  14. data/src/lua/doc/amazon.gif +0 -0
  15. data/src/lua/doc/contents.html +499 -0
  16. data/src/lua/doc/cover.png +0 -0
  17. data/src/lua/doc/logo.gif +0 -0
  18. data/src/lua/doc/lua.1 +163 -0
  19. data/src/lua/doc/lua.css +41 -0
  20. data/src/lua/doc/lua.html +172 -0
  21. data/src/lua/doc/luac.1 +136 -0
  22. data/src/lua/doc/luac.html +145 -0
  23. data/src/lua/doc/manual.css +13 -0
  24. data/src/lua/doc/manual.html +8801 -0
  25. data/src/lua/doc/readme.html +40 -0
  26. data/src/lua/etc/Makefile +44 -0
  27. data/src/lua/etc/README +37 -0
  28. data/src/lua/etc/all.c +38 -0
  29. data/src/lua/etc/lua.hpp +9 -0
  30. data/src/lua/etc/lua.ico +0 -0
  31. data/src/lua/etc/lua.pc +31 -0
  32. data/src/lua/etc/luavs.bat +28 -0
  33. data/src/lua/etc/min.c +39 -0
  34. data/src/lua/etc/noparser.c +50 -0
  35. data/src/lua/etc/strict.lua +41 -0
  36. data/src/lua/src/Makefile +182 -0
  37. data/src/lua/src/lapi.c +1087 -0
  38. data/src/lua/src/lapi.h +16 -0
  39. data/src/lua/src/lauxlib.c +652 -0
  40. data/src/lua/src/lauxlib.h +174 -0
  41. data/src/lua/src/lbaselib.c +653 -0
  42. data/src/lua/src/lcode.c +831 -0
  43. data/src/lua/src/lcode.h +76 -0
  44. data/src/lua/src/ldblib.c +398 -0
  45. data/src/lua/src/ldebug.c +638 -0
  46. data/src/lua/src/ldebug.h +33 -0
  47. data/src/lua/src/ldo.c +518 -0
  48. data/src/lua/src/ldo.h +57 -0
  49. data/src/lua/src/ldump.c +164 -0
  50. data/src/lua/src/lfunc.c +174 -0
  51. data/src/lua/src/lfunc.h +34 -0
  52. data/src/lua/src/lgc.c +711 -0
  53. data/src/lua/src/lgc.h +110 -0
  54. data/src/lua/src/linit.c +38 -0
  55. data/src/lua/src/liolib.c +556 -0
  56. data/src/lua/src/llex.c +463 -0
  57. data/src/lua/src/llex.h +81 -0
  58. data/src/lua/src/llimits.h +128 -0
  59. data/src/lua/src/lmathlib.c +263 -0
  60. data/src/lua/src/lmem.c +86 -0
  61. data/src/lua/src/lmem.h +49 -0
  62. data/src/lua/src/loadlib.c +666 -0
  63. data/src/lua/src/loadlib_rel.c +719 -0
  64. data/src/lua/src/lobject.c +214 -0
  65. data/src/lua/src/lobject.h +381 -0
  66. data/src/lua/src/lopcodes.c +102 -0
  67. data/src/lua/src/lopcodes.h +268 -0
  68. data/src/lua/src/loslib.c +243 -0
  69. data/src/lua/src/lparser.c +1339 -0
  70. data/src/lua/src/lparser.h +82 -0
  71. data/src/lua/src/lstate.c +214 -0
  72. data/src/lua/src/lstate.h +169 -0
  73. data/src/lua/src/lstring.c +111 -0
  74. data/src/lua/src/lstring.h +31 -0
  75. data/src/lua/src/lstrlib.c +871 -0
  76. data/src/lua/src/ltable.c +588 -0
  77. data/src/lua/src/ltable.h +40 -0
  78. data/src/lua/src/ltablib.c +287 -0
  79. data/src/lua/src/ltm.c +75 -0
  80. data/src/lua/src/ltm.h +54 -0
  81. data/src/lua/src/lua.c +392 -0
  82. data/src/lua/src/lua.def +131 -0
  83. data/src/lua/src/lua.h +388 -0
  84. data/src/lua/src/lua.rc +28 -0
  85. data/src/lua/src/lua_dll.rc +26 -0
  86. data/src/lua/src/luac.c +200 -0
  87. data/src/lua/src/luac.rc +1 -0
  88. data/src/lua/src/luaconf.h.in +724 -0
  89. data/src/lua/src/luaconf.h.orig +763 -0
  90. data/src/lua/src/lualib.h +53 -0
  91. data/src/lua/src/lundump.c +227 -0
  92. data/src/lua/src/lundump.h +36 -0
  93. data/src/lua/src/lvm.c +766 -0
  94. data/src/lua/src/lvm.h +36 -0
  95. data/src/lua/src/lzio.c +82 -0
  96. data/src/lua/src/lzio.h +67 -0
  97. data/src/lua/src/print.c +227 -0
  98. data/src/lua/test/README +26 -0
  99. data/src/lua/test/bisect.lua +27 -0
  100. data/src/lua/test/cf.lua +16 -0
  101. data/src/lua/test/echo.lua +5 -0
  102. data/src/lua/test/env.lua +7 -0
  103. data/src/lua/test/factorial.lua +32 -0
  104. data/src/lua/test/fib.lua +40 -0
  105. data/src/lua/test/fibfor.lua +13 -0
  106. data/src/lua/test/globals.lua +13 -0
  107. data/src/lua/test/hello.lua +3 -0
  108. data/src/lua/test/life.lua +111 -0
  109. data/src/lua/test/luac.lua +7 -0
  110. data/src/lua/test/printf.lua +7 -0
  111. data/src/lua/test/readonly.lua +12 -0
  112. data/src/lua/test/sieve.lua +29 -0
  113. data/src/lua/test/sort.lua +66 -0
  114. data/src/lua/test/table.lua +12 -0
  115. data/src/lua/test/trace-calls.lua +32 -0
  116. data/src/lua/test/trace-globals.lua +38 -0
  117. data/src/lua/test/xd.lua +14 -0
  118. metadata +115 -2
data/src/lua/src/ldo.c ADDED
@@ -0,0 +1,518 @@
1
+ /*
2
+ ** $Id: ldo.c,v 2.38.1.3 2008/01/18 22:31:22 roberto Exp $
3
+ ** Stack and Call structure of Lua
4
+ ** See Copyright Notice in lua.h
5
+ */
6
+
7
+
8
+ #include <setjmp.h>
9
+ #include <stdlib.h>
10
+ #include <string.h>
11
+
12
+ #define ldo_c
13
+ #define LUA_CORE
14
+
15
+ #include "lua.h"
16
+
17
+ #include "ldebug.h"
18
+ #include "ldo.h"
19
+ #include "lfunc.h"
20
+ #include "lgc.h"
21
+ #include "lmem.h"
22
+ #include "lobject.h"
23
+ #include "lopcodes.h"
24
+ #include "lparser.h"
25
+ #include "lstate.h"
26
+ #include "lstring.h"
27
+ #include "ltable.h"
28
+ #include "ltm.h"
29
+ #include "lundump.h"
30
+ #include "lvm.h"
31
+ #include "lzio.h"
32
+
33
+
34
+
35
+
36
+ /*
37
+ ** {======================================================
38
+ ** Error-recovery functions
39
+ ** =======================================================
40
+ */
41
+
42
+
43
+ /* chain list of long jump buffers */
44
+ struct lua_longjmp {
45
+ struct lua_longjmp *previous;
46
+ luai_jmpbuf b;
47
+ volatile int status; /* error code */
48
+ };
49
+
50
+
51
+ void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop) {
52
+ switch (errcode) {
53
+ case LUA_ERRMEM: {
54
+ setsvalue2s(L, oldtop, luaS_newliteral(L, MEMERRMSG));
55
+ break;
56
+ }
57
+ case LUA_ERRERR: {
58
+ setsvalue2s(L, oldtop, luaS_newliteral(L, "error in error handling"));
59
+ break;
60
+ }
61
+ case LUA_ERRSYNTAX:
62
+ case LUA_ERRRUN: {
63
+ setobjs2s(L, oldtop, L->top - 1); /* error message on current top */
64
+ break;
65
+ }
66
+ }
67
+ L->top = oldtop + 1;
68
+ }
69
+
70
+
71
+ static void restore_stack_limit (lua_State *L) {
72
+ lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK - 1);
73
+ if (L->size_ci > LUAI_MAXCALLS) { /* there was an overflow? */
74
+ int inuse = cast_int(L->ci - L->base_ci);
75
+ if (inuse + 1 < LUAI_MAXCALLS) /* can `undo' overflow? */
76
+ luaD_reallocCI(L, LUAI_MAXCALLS);
77
+ }
78
+ }
79
+
80
+
81
+ static void resetstack (lua_State *L, int status) {
82
+ L->ci = L->base_ci;
83
+ L->base = L->ci->base;
84
+ luaF_close(L, L->base); /* close eventual pending closures */
85
+ luaD_seterrorobj(L, status, L->base);
86
+ L->nCcalls = L->baseCcalls;
87
+ L->allowhook = 1;
88
+ restore_stack_limit(L);
89
+ L->errfunc = 0;
90
+ L->errorJmp = NULL;
91
+ }
92
+
93
+
94
+ void luaD_throw (lua_State *L, int errcode) {
95
+ if (L->errorJmp) {
96
+ L->errorJmp->status = errcode;
97
+ LUAI_THROW(L, L->errorJmp);
98
+ }
99
+ else {
100
+ L->status = cast_byte(errcode);
101
+ if (G(L)->panic) {
102
+ resetstack(L, errcode);
103
+ lua_unlock(L);
104
+ G(L)->panic(L);
105
+ }
106
+ exit(EXIT_FAILURE);
107
+ }
108
+ }
109
+
110
+
111
+ int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) {
112
+ struct lua_longjmp lj;
113
+ lj.status = 0;
114
+ lj.previous = L->errorJmp; /* chain new error handler */
115
+ L->errorJmp = &lj;
116
+ LUAI_TRY(L, &lj,
117
+ (*f)(L, ud);
118
+ );
119
+ L->errorJmp = lj.previous; /* restore old error handler */
120
+ return lj.status;
121
+ }
122
+
123
+ /* }====================================================== */
124
+
125
+
126
+ static void correctstack (lua_State *L, TValue *oldstack) {
127
+ CallInfo *ci;
128
+ GCObject *up;
129
+ L->top = (L->top - oldstack) + L->stack;
130
+ for (up = L->openupval; up != NULL; up = up->gch.next)
131
+ gco2uv(up)->v = (gco2uv(up)->v - oldstack) + L->stack;
132
+ for (ci = L->base_ci; ci <= L->ci; ci++) {
133
+ ci->top = (ci->top - oldstack) + L->stack;
134
+ ci->base = (ci->base - oldstack) + L->stack;
135
+ ci->func = (ci->func - oldstack) + L->stack;
136
+ }
137
+ L->base = (L->base - oldstack) + L->stack;
138
+ }
139
+
140
+
141
+ void luaD_reallocstack (lua_State *L, int newsize) {
142
+ TValue *oldstack = L->stack;
143
+ int realsize = newsize + 1 + EXTRA_STACK;
144
+ lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK - 1);
145
+ luaM_reallocvector(L, L->stack, L->stacksize, realsize, TValue);
146
+ L->stacksize = realsize;
147
+ L->stack_last = L->stack+newsize;
148
+ correctstack(L, oldstack);
149
+ }
150
+
151
+
152
+ void luaD_reallocCI (lua_State *L, int newsize) {
153
+ CallInfo *oldci = L->base_ci;
154
+ luaM_reallocvector(L, L->base_ci, L->size_ci, newsize, CallInfo);
155
+ L->size_ci = newsize;
156
+ L->ci = (L->ci - oldci) + L->base_ci;
157
+ L->end_ci = L->base_ci + L->size_ci - 1;
158
+ }
159
+
160
+
161
+ void luaD_growstack (lua_State *L, int n) {
162
+ if (n <= L->stacksize) /* double size is enough? */
163
+ luaD_reallocstack(L, 2*L->stacksize);
164
+ else
165
+ luaD_reallocstack(L, L->stacksize + n);
166
+ }
167
+
168
+
169
+ static CallInfo *growCI (lua_State *L) {
170
+ if (L->size_ci > LUAI_MAXCALLS) /* overflow while handling overflow? */
171
+ luaD_throw(L, LUA_ERRERR);
172
+ else {
173
+ luaD_reallocCI(L, 2*L->size_ci);
174
+ if (L->size_ci > LUAI_MAXCALLS)
175
+ luaG_runerror(L, "stack overflow");
176
+ }
177
+ return ++L->ci;
178
+ }
179
+
180
+
181
+ void luaD_callhook (lua_State *L, int event, int line) {
182
+ lua_Hook hook = L->hook;
183
+ if (hook && L->allowhook) {
184
+ ptrdiff_t top = savestack(L, L->top);
185
+ ptrdiff_t ci_top = savestack(L, L->ci->top);
186
+ lua_Debug ar;
187
+ ar.event = event;
188
+ ar.currentline = line;
189
+ if (event == LUA_HOOKTAILRET)
190
+ ar.i_ci = 0; /* tail call; no debug information about it */
191
+ else
192
+ ar.i_ci = cast_int(L->ci - L->base_ci);
193
+ luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */
194
+ L->ci->top = L->top + LUA_MINSTACK;
195
+ lua_assert(L->ci->top <= L->stack_last);
196
+ L->allowhook = 0; /* cannot call hooks inside a hook */
197
+ lua_unlock(L);
198
+ (*hook)(L, &ar);
199
+ lua_lock(L);
200
+ lua_assert(!L->allowhook);
201
+ L->allowhook = 1;
202
+ L->ci->top = restorestack(L, ci_top);
203
+ L->top = restorestack(L, top);
204
+ }
205
+ }
206
+
207
+
208
+ static StkId adjust_varargs (lua_State *L, Proto *p, int actual) {
209
+ int i;
210
+ int nfixargs = p->numparams;
211
+ Table *htab = NULL;
212
+ StkId base, fixed;
213
+ for (; actual < nfixargs; ++actual)
214
+ setnilvalue(L->top++);
215
+ #if defined(LUA_COMPAT_VARARG)
216
+ if (p->is_vararg & VARARG_NEEDSARG) { /* compat. with old-style vararg? */
217
+ int nvar = actual - nfixargs; /* number of extra arguments */
218
+ lua_assert(p->is_vararg & VARARG_HASARG);
219
+ luaC_checkGC(L);
220
+ htab = luaH_new(L, nvar, 1); /* create `arg' table */
221
+ for (i=0; i<nvar; i++) /* put extra arguments into `arg' table */
222
+ setobj2n(L, luaH_setnum(L, htab, i+1), L->top - nvar + i);
223
+ /* store counter in field `n' */
224
+ setnvalue(luaH_setstr(L, htab, luaS_newliteral(L, "n")), cast_num(nvar));
225
+ }
226
+ #endif
227
+ /* move fixed parameters to final position */
228
+ fixed = L->top - actual; /* first fixed argument */
229
+ base = L->top; /* final position of first argument */
230
+ for (i=0; i<nfixargs; i++) {
231
+ setobjs2s(L, L->top++, fixed+i);
232
+ setnilvalue(fixed+i);
233
+ }
234
+ /* add `arg' parameter */
235
+ if (htab) {
236
+ sethvalue(L, L->top++, htab);
237
+ lua_assert(iswhite(obj2gco(htab)));
238
+ }
239
+ return base;
240
+ }
241
+
242
+
243
+ static StkId tryfuncTM (lua_State *L, StkId func) {
244
+ const TValue *tm = luaT_gettmbyobj(L, func, TM_CALL);
245
+ StkId p;
246
+ ptrdiff_t funcr = savestack(L, func);
247
+ if (!ttisfunction(tm))
248
+ luaG_typeerror(L, func, "call");
249
+ /* Open a hole inside the stack at `func' */
250
+ for (p = L->top; p > func; p--) setobjs2s(L, p, p-1);
251
+ incr_top(L);
252
+ func = restorestack(L, funcr); /* previous call may change stack */
253
+ setobj2s(L, func, tm); /* tag method is the new function to be called */
254
+ return func;
255
+ }
256
+
257
+
258
+
259
+ #define inc_ci(L) \
260
+ ((L->ci == L->end_ci) ? growCI(L) : \
261
+ (condhardstacktests(luaD_reallocCI(L, L->size_ci)), ++L->ci))
262
+
263
+
264
+ int luaD_precall (lua_State *L, StkId func, int nresults) {
265
+ LClosure *cl;
266
+ ptrdiff_t funcr;
267
+ if (!ttisfunction(func)) /* `func' is not a function? */
268
+ func = tryfuncTM(L, func); /* check the `function' tag method */
269
+ funcr = savestack(L, func);
270
+ cl = &clvalue(func)->l;
271
+ L->ci->savedpc = L->savedpc;
272
+ if (!cl->isC) { /* Lua function? prepare its call */
273
+ CallInfo *ci;
274
+ StkId st, base;
275
+ Proto *p = cl->p;
276
+ luaD_checkstack(L, p->maxstacksize);
277
+ func = restorestack(L, funcr);
278
+ if (!p->is_vararg) { /* no varargs? */
279
+ base = func + 1;
280
+ if (L->top > base + p->numparams)
281
+ L->top = base + p->numparams;
282
+ }
283
+ else { /* vararg function */
284
+ int nargs = cast_int(L->top - func) - 1;
285
+ base = adjust_varargs(L, p, nargs);
286
+ func = restorestack(L, funcr); /* previous call may change the stack */
287
+ }
288
+ ci = inc_ci(L); /* now `enter' new function */
289
+ ci->func = func;
290
+ L->base = ci->base = base;
291
+ ci->top = L->base + p->maxstacksize;
292
+ lua_assert(ci->top <= L->stack_last);
293
+ L->savedpc = p->code; /* starting point */
294
+ ci->tailcalls = 0;
295
+ ci->nresults = nresults;
296
+ for (st = L->top; st < ci->top; st++)
297
+ setnilvalue(st);
298
+ L->top = ci->top;
299
+ if (L->hookmask & LUA_MASKCALL) {
300
+ L->savedpc++; /* hooks assume 'pc' is already incremented */
301
+ luaD_callhook(L, LUA_HOOKCALL, -1);
302
+ L->savedpc--; /* correct 'pc' */
303
+ }
304
+ return PCRLUA;
305
+ }
306
+ else { /* if is a C function, call it */
307
+ CallInfo *ci;
308
+ int n;
309
+ luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */
310
+ ci = inc_ci(L); /* now `enter' new function */
311
+ ci->func = restorestack(L, funcr);
312
+ L->base = ci->base = ci->func + 1;
313
+ ci->top = L->top + LUA_MINSTACK;
314
+ lua_assert(ci->top <= L->stack_last);
315
+ ci->nresults = nresults;
316
+ if (L->hookmask & LUA_MASKCALL)
317
+ luaD_callhook(L, LUA_HOOKCALL, -1);
318
+ lua_unlock(L);
319
+ n = (*curr_func(L)->c.f)(L); /* do the actual call */
320
+ lua_lock(L);
321
+ if (n < 0) /* yielding? */
322
+ return PCRYIELD;
323
+ else {
324
+ luaD_poscall(L, L->top - n);
325
+ return PCRC;
326
+ }
327
+ }
328
+ }
329
+
330
+
331
+ static StkId callrethooks (lua_State *L, StkId firstResult) {
332
+ ptrdiff_t fr = savestack(L, firstResult); /* next call may change stack */
333
+ luaD_callhook(L, LUA_HOOKRET, -1);
334
+ if (f_isLua(L->ci)) { /* Lua function? */
335
+ while ((L->hookmask & LUA_MASKRET) && L->ci->tailcalls--) /* tail calls */
336
+ luaD_callhook(L, LUA_HOOKTAILRET, -1);
337
+ }
338
+ return restorestack(L, fr);
339
+ }
340
+
341
+
342
+ int luaD_poscall (lua_State *L, StkId firstResult) {
343
+ StkId res;
344
+ int wanted, i;
345
+ CallInfo *ci;
346
+ if (L->hookmask & LUA_MASKRET)
347
+ firstResult = callrethooks(L, firstResult);
348
+ ci = L->ci--;
349
+ res = ci->func; /* res == final position of 1st result */
350
+ wanted = ci->nresults;
351
+ L->base = (ci - 1)->base; /* restore base */
352
+ L->savedpc = (ci - 1)->savedpc; /* restore savedpc */
353
+ /* move results to correct place */
354
+ for (i = wanted; i != 0 && firstResult < L->top; i--)
355
+ setobjs2s(L, res++, firstResult++);
356
+ while (i-- > 0)
357
+ setnilvalue(res++);
358
+ L->top = res;
359
+ return (wanted - LUA_MULTRET); /* 0 iff wanted == LUA_MULTRET */
360
+ }
361
+
362
+
363
+ /*
364
+ ** Call a function (C or Lua). The function to be called is at *func.
365
+ ** The arguments are on the stack, right after the function.
366
+ ** When returns, all the results are on the stack, starting at the original
367
+ ** function position.
368
+ */
369
+ void luaD_call (lua_State *L, StkId func, int nResults) {
370
+ if (++L->nCcalls >= LUAI_MAXCCALLS) {
371
+ if (L->nCcalls == LUAI_MAXCCALLS)
372
+ luaG_runerror(L, "C stack overflow");
373
+ else if (L->nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS>>3)))
374
+ luaD_throw(L, LUA_ERRERR); /* error while handing stack error */
375
+ }
376
+ if (luaD_precall(L, func, nResults) == PCRLUA) /* is a Lua function? */
377
+ luaV_execute(L, 1); /* call it */
378
+ L->nCcalls--;
379
+ luaC_checkGC(L);
380
+ }
381
+
382
+
383
+ static void resume (lua_State *L, void *ud) {
384
+ StkId firstArg = cast(StkId, ud);
385
+ CallInfo *ci = L->ci;
386
+ if (L->status == 0) { /* start coroutine? */
387
+ lua_assert(ci == L->base_ci && firstArg > L->base);
388
+ if (luaD_precall(L, firstArg - 1, LUA_MULTRET) != PCRLUA)
389
+ return;
390
+ }
391
+ else { /* resuming from previous yield */
392
+ lua_assert(L->status == LUA_YIELD);
393
+ L->status = 0;
394
+ if (!f_isLua(ci)) { /* `common' yield? */
395
+ /* finish interrupted execution of `OP_CALL' */
396
+ lua_assert(GET_OPCODE(*((ci-1)->savedpc - 1)) == OP_CALL ||
397
+ GET_OPCODE(*((ci-1)->savedpc - 1)) == OP_TAILCALL);
398
+ if (luaD_poscall(L, firstArg)) /* complete it... */
399
+ L->top = L->ci->top; /* and correct top if not multiple results */
400
+ }
401
+ else /* yielded inside a hook: just continue its execution */
402
+ L->base = L->ci->base;
403
+ }
404
+ luaV_execute(L, cast_int(L->ci - L->base_ci));
405
+ }
406
+
407
+
408
+ static int resume_error (lua_State *L, const char *msg) {
409
+ L->top = L->ci->base;
410
+ setsvalue2s(L, L->top, luaS_new(L, msg));
411
+ incr_top(L);
412
+ lua_unlock(L);
413
+ return LUA_ERRRUN;
414
+ }
415
+
416
+
417
+ LUA_API int lua_resume (lua_State *L, int nargs) {
418
+ int status;
419
+ lua_lock(L);
420
+ if (L->status != LUA_YIELD && (L->status != 0 || L->ci != L->base_ci))
421
+ return resume_error(L, "cannot resume non-suspended coroutine");
422
+ if (L->nCcalls >= LUAI_MAXCCALLS)
423
+ return resume_error(L, "C stack overflow");
424
+ luai_userstateresume(L, nargs);
425
+ lua_assert(L->errfunc == 0);
426
+ L->baseCcalls = ++L->nCcalls;
427
+ status = luaD_rawrunprotected(L, resume, L->top - nargs);
428
+ if (status != 0) { /* error? */
429
+ L->status = cast_byte(status); /* mark thread as `dead' */
430
+ luaD_seterrorobj(L, status, L->top);
431
+ L->ci->top = L->top;
432
+ }
433
+ else {
434
+ lua_assert(L->nCcalls == L->baseCcalls);
435
+ status = L->status;
436
+ }
437
+ --L->nCcalls;
438
+ lua_unlock(L);
439
+ return status;
440
+ }
441
+
442
+
443
+ LUA_API int lua_yield (lua_State *L, int nresults) {
444
+ luai_userstateyield(L, nresults);
445
+ lua_lock(L);
446
+ if (L->nCcalls > L->baseCcalls)
447
+ luaG_runerror(L, "attempt to yield across metamethod/C-call boundary");
448
+ L->base = L->top - nresults; /* protect stack slots below */
449
+ L->status = LUA_YIELD;
450
+ lua_unlock(L);
451
+ return -1;
452
+ }
453
+
454
+
455
+ int luaD_pcall (lua_State *L, Pfunc func, void *u,
456
+ ptrdiff_t old_top, ptrdiff_t ef) {
457
+ int status;
458
+ unsigned short oldnCcalls = L->nCcalls;
459
+ ptrdiff_t old_ci = saveci(L, L->ci);
460
+ lu_byte old_allowhooks = L->allowhook;
461
+ ptrdiff_t old_errfunc = L->errfunc;
462
+ L->errfunc = ef;
463
+ status = luaD_rawrunprotected(L, func, u);
464
+ if (status != 0) { /* an error occurred? */
465
+ StkId oldtop = restorestack(L, old_top);
466
+ luaF_close(L, oldtop); /* close eventual pending closures */
467
+ luaD_seterrorobj(L, status, oldtop);
468
+ L->nCcalls = oldnCcalls;
469
+ L->ci = restoreci(L, old_ci);
470
+ L->base = L->ci->base;
471
+ L->savedpc = L->ci->savedpc;
472
+ L->allowhook = old_allowhooks;
473
+ restore_stack_limit(L);
474
+ }
475
+ L->errfunc = old_errfunc;
476
+ return status;
477
+ }
478
+
479
+
480
+
481
+ /*
482
+ ** Execute a protected parser.
483
+ */
484
+ struct SParser { /* data to `f_parser' */
485
+ ZIO *z;
486
+ Mbuffer buff; /* buffer to be used by the scanner */
487
+ const char *name;
488
+ };
489
+
490
+ static void f_parser (lua_State *L, void *ud) {
491
+ int i;
492
+ Proto *tf;
493
+ Closure *cl;
494
+ struct SParser *p = cast(struct SParser *, ud);
495
+ int c = luaZ_lookahead(p->z);
496
+ luaC_checkGC(L);
497
+ tf = ((c == LUA_SIGNATURE[0]) ? luaU_undump : luaY_parser)(L, p->z,
498
+ &p->buff, p->name);
499
+ cl = luaF_newLclosure(L, tf->nups, hvalue(gt(L)));
500
+ cl->l.p = tf;
501
+ for (i = 0; i < tf->nups; i++) /* initialize eventual upvalues */
502
+ cl->l.upvals[i] = luaF_newupval(L);
503
+ setclvalue(L, L->top, cl);
504
+ incr_top(L);
505
+ }
506
+
507
+
508
+ int luaD_protectedparser (lua_State *L, ZIO *z, const char *name) {
509
+ struct SParser p;
510
+ int status;
511
+ p.z = z; p.name = name;
512
+ luaZ_initbuffer(L, &p.buff);
513
+ status = luaD_pcall(L, f_parser, &p, savestack(L, L->top), L->errfunc);
514
+ luaZ_freebuffer(L, &p.buff);
515
+ return status;
516
+ }
517
+
518
+
data/src/lua/src/ldo.h ADDED
@@ -0,0 +1,57 @@
1
+ /*
2
+ ** $Id: ldo.h,v 2.7.1.1 2007/12/27 13:02:25 roberto Exp $
3
+ ** Stack and Call structure of Lua
4
+ ** See Copyright Notice in lua.h
5
+ */
6
+
7
+ #ifndef ldo_h
8
+ #define ldo_h
9
+
10
+
11
+ #include "lobject.h"
12
+ #include "lstate.h"
13
+ #include "lzio.h"
14
+
15
+
16
+ #define luaD_checkstack(L,n) \
17
+ if ((char *)L->stack_last - (char *)L->top <= (n)*(int)sizeof(TValue)) \
18
+ luaD_growstack(L, n); \
19
+ else condhardstacktests(luaD_reallocstack(L, L->stacksize - EXTRA_STACK - 1));
20
+
21
+
22
+ #define incr_top(L) {luaD_checkstack(L,1); L->top++;}
23
+
24
+ #define savestack(L,p) ((char *)(p) - (char *)L->stack)
25
+ #define restorestack(L,n) ((TValue *)((char *)L->stack + (n)))
26
+
27
+ #define saveci(L,p) ((char *)(p) - (char *)L->base_ci)
28
+ #define restoreci(L,n) ((CallInfo *)((char *)L->base_ci + (n)))
29
+
30
+
31
+ /* results from luaD_precall */
32
+ #define PCRLUA 0 /* initiated a call to a Lua function */
33
+ #define PCRC 1 /* did a call to a C function */
34
+ #define PCRYIELD 2 /* C funtion yielded */
35
+
36
+
37
+ /* type of protected functions, to be ran by `runprotected' */
38
+ typedef void (*Pfunc) (lua_State *L, void *ud);
39
+
40
+ LUAI_FUNC int luaD_protectedparser (lua_State *L, ZIO *z, const char *name);
41
+ LUAI_FUNC void luaD_callhook (lua_State *L, int event, int line);
42
+ LUAI_FUNC int luaD_precall (lua_State *L, StkId func, int nresults);
43
+ LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults);
44
+ LUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u,
45
+ ptrdiff_t oldtop, ptrdiff_t ef);
46
+ LUAI_FUNC int luaD_poscall (lua_State *L, StkId firstResult);
47
+ LUAI_FUNC void luaD_reallocCI (lua_State *L, int newsize);
48
+ LUAI_FUNC void luaD_reallocstack (lua_State *L, int newsize);
49
+ LUAI_FUNC void luaD_growstack (lua_State *L, int n);
50
+
51
+ LUAI_FUNC void luaD_throw (lua_State *L, int errcode);
52
+ LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud);
53
+
54
+ LUAI_FUNC void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop);
55
+
56
+ #endif
57
+