← Back to branch summary

~ilya-yanok/ubuntu/precise/grub2/fix-for-948716

« back to all changes in this revision

Viewing changes to script/lua/ldo.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Millan
  • Date: 2009-07-25 19:00:53 UTC
  • mfrom: (1.6.3 upstream)
  • mto: (17.4.13 sid)
  • mto: This revision was merged to the branch mainline in revision 53.
  • Revision ID: james.westby@ubuntu.com-20090725190053-uv3lm6ya3zxs77ep
Import upstream version 1.96+20090725

Show diffs side-by-side

added added

removed removed

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