CHDK_DE Vorschauversion  Trunk Rev. 5218
 Alle Datenstrukturen Dateien Funktionen Variablen Typdefinitionen Aufzählungen Aufzählungswerte Makrodefinitionen
ldo.c-Dateireferenz
#include <setjmp.h>
#include <stdlib.h>
#include <string.h>
#include "lua.h"
#include "ldebug.h"
#include "ldo.h"
#include "lfunc.h"
#include "lgc.h"
#include "lmem.h"
#include "lobject.h"
#include "lopcodes.h"
#include "lparser.h"
#include "lstate.h"
#include "lstring.h"
#include "ltable.h"
#include "ltm.h"
#include "lundump.h"
#include "lvm.h"
#include "lzio.h"
+ Include-Abhängigkeitsdiagramm für ldo.c:

gehe zum Quellcode dieser Datei

Datenstrukturen

struct  lua_longjmp
 
struct  SParser
 

Makrodefinitionen

#define ldo_c
 
#define LUA_CORE
 
#define inc_ci(L)
 

Funktionen

LUAI_FUNC void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop)
 
static void restore_stack_limit (lua_State *L)
 
static void resetstack (lua_State *L, int status)
 
LUAI_FUNC void luaD_throw (lua_State *L, int errcode)
 
LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud)
 
static void correctstack (lua_State *L, TValue *oldstack)
 
LUAI_FUNC void luaD_reallocstack (lua_State *L, int newsize)
 
LUAI_FUNC void luaD_reallocCI (lua_State *L, int newsize)
 
LUAI_FUNC void luaD_growstack (lua_State *L, int n)
 
static CallInfogrowCI (lua_State *L)
 
LUAI_FUNC void luaD_callhook (lua_State *L, int event, int line)
 
static StkId adjust_varargs (lua_State *L, Proto *p, int actual)
 
static StkId tryfuncTM (lua_State *L, StkId func)
 
LUAI_FUNC int luaD_precall (lua_State *L, StkId func, int nresults)
 
static StkId callrethooks (lua_State *L, StkId firstResult)
 
LUAI_FUNC int luaD_poscall (lua_State *L, StkId firstResult)
 
LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults)
 
static void resume (lua_State *L, void *ud)
 
static int resume_error (lua_State *L, const char *msg)
 
LUA_API int lua_resume (lua_State *L, int nargs)
 
LUA_API int lua_yield (lua_State *L, int nresults)
 
LUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u, ptrdiff_t old_top, ptrdiff_t ef)
 
static void f_parser (lua_State *L, void *ud)
 
LUAI_FUNC int luaD_protectedparser (lua_State *L, ZIO *z, const char *name)
 

Makro-Dokumentation

#define inc_ci (   L)
Wert:

Definiert in Zeile 260 der Datei ldo.c.

#define ldo_c

Definiert in Zeile 12 der Datei ldo.c.

#define LUA_CORE

Definiert in Zeile 13 der Datei ldo.c.

Dokumentation der Funktionen

static StkId adjust_varargs ( lua_State L,
Proto p,
int  actual 
)
static

Definiert in Zeile 208 der Datei ldo.c.

208  {
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 */
219  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 }
static StkId callrethooks ( lua_State L,
StkId  firstResult 
)
static

Definiert in Zeile 332 der Datei ldo.c.

332  {
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 */
338  }
339  return restorestack(L, fr);
340 }
static void correctstack ( lua_State L,
TValue oldstack 
)
static

Definiert in Zeile 126 der Datei ldo.c.

126  {
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 }
static void f_parser ( lua_State L,
void *  ud 
)
static

Definiert in Zeile 491 der Datei ldo.c.

491  {
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 }
static CallInfo* growCI ( lua_State L)
static

Definiert in Zeile 169 der Datei ldo.c.

169  {
170  if (L->size_ci > LUAI_MAXCALLS) /* overflow while handling overflow? */
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 }
LUA_API int lua_resume ( lua_State L,
int  nargs 
)

Definiert in Zeile 418 der Datei ldo.c.

418  {
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 }
LUA_API int lua_yield ( lua_State L,
int  nresults 
)

Definiert in Zeile 444 der Datei ldo.c.

444  {
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 }
LUAI_FUNC void luaD_call ( lua_State L,
StkId  func,
int  nResults 
)

Definiert in Zeile 370 der Datei ldo.c.

370  {
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 }
LUAI_FUNC void luaD_callhook ( lua_State L,
int  event,
int  line 
)

Definiert in Zeile 181 der Datei ldo.c.

181  {
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 }
LUAI_FUNC void luaD_growstack ( lua_State L,
int  n 
)

Definiert in Zeile 161 der Datei ldo.c.

161  {
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 }
LUAI_FUNC int luaD_pcall ( lua_State L,
Pfunc  func,
void *  u,
ptrdiff_t  old_top,
ptrdiff_t  ef 
)

Definiert in Zeile 456 der Datei ldo.c.

457  {
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;
475  }
476  L->errfunc = old_errfunc;
477  return status;
478 }
LUAI_FUNC int luaD_poscall ( lua_State L,
StkId  firstResult 
)

Definiert in Zeile 343 der Datei ldo.c.

343  {
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 }
LUAI_FUNC int luaD_precall ( lua_State L,
StkId  func,
int  nresults 
)

Definiert in Zeile 265 der Datei ldo.c.

265  {
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;
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 }
LUAI_FUNC int luaD_protectedparser ( lua_State L,
ZIO z,
const char *  name 
)

Definiert in Zeile 509 der Datei ldo.c.

509  {
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 }
LUAI_FUNC int luaD_rawrunprotected ( lua_State L,
Pfunc  f,
void *  ud 
)

Definiert in Zeile 111 der Datei ldo.c.

111  {
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 }
LUAI_FUNC void luaD_reallocCI ( lua_State L,
int  newsize 
)

Definiert in Zeile 152 der Datei ldo.c.

152  {
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 }
LUAI_FUNC void luaD_reallocstack ( lua_State L,
int  newsize 
)

Definiert in Zeile 141 der Datei ldo.c.

141  {
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 }
LUAI_FUNC void luaD_seterrorobj ( lua_State L,
int  errcode,
StkId  oldtop 
)

Definiert in Zeile 51 der Datei ldo.c.

51  {
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 }
LUAI_FUNC void luaD_throw ( lua_State L,
int  errcode 
)

Definiert in Zeile 94 der Datei ldo.c.

94  {
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); 2DO:JRI
107  }
108 }
static void resetstack ( lua_State L,
int  status 
)
static

Definiert in Zeile 81 der Datei ldo.c.

81  {
82  L->ci = L->base_ci;
83  L->base = L->ci->base;
84  luaF_close(L, L->base); /* close eventual pending closures */
86  L->nCcalls = L->baseCcalls;
87  L->allowhook = 1;
89  L->errfunc = 0;
90  L->errorJmp = NULL;
91 }
static void restore_stack_limit ( lua_State L)
static

Definiert in Zeile 71 der Datei ldo.c.

71  {
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? */
77  }
78 }
static void resume ( lua_State L,
void *  ud 
)
static

Definiert in Zeile 384 der Datei ldo.c.

384  {
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 }
static int resume_error ( lua_State L,
const char *  msg 
)
static

Definiert in Zeile 409 der Datei ldo.c.

409  {
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 }
static StkId tryfuncTM ( lua_State L,
StkId  func 
)
static

Definiert in Zeile 244 der Datei ldo.c.

244  {
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 }