CHDK_DE Vorschauversion  Trunk Rev. 5273
 Alle Datenstrukturen Dateien Funktionen Variablen Typdefinitionen Aufzählungen Aufzählungswerte Makrodefinitionen
ldo.h-Dateireferenz
#include "lobject.h"
#include "lstate.h"
#include "lzio.h"
+ Include-Abhängigkeitsdiagramm für ldo.h:
+ Dieser Graph zeigt, welche Datei direkt oder indirekt diese Datei enthält:

gehe zum Quellcode dieser Datei

Makrodefinitionen

#define luaD_checkstack(L, n)
 
#define incr_top(L)   {luaD_checkstack(L,1); L->top++;}
 
#define savestack(L, p)   ((char *)(p) - (char *)L->stack)
 
#define restorestack(L, n)   ((TValue *)((char *)L->stack + (n)))
 
#define saveci(L, p)   ((char *)(p) - (char *)L->base_ci)
 
#define restoreci(L, n)   ((CallInfo *)((char *)L->base_ci + (n)))
 
#define PCRLUA   0 /* initiated a call to a Lua function */
 
#define PCRC   1 /* did a call to a C function */
 
#define PCRYIELD   2 /* C funtion yielded */
 

Typdefinitionen

typedef void(* Pfunc )(lua_State *L, void *ud)
 

Funktionen

LUAI_FUNC int luaD_protectedparser (lua_State *L, ZIO *z, const char *name)
 
LUAI_FUNC void luaD_callhook (lua_State *L, int event, int line)
 
LUAI_FUNC int luaD_precall (lua_State *L, StkId func, int nresults)
 
LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults)
 
LUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u, ptrdiff_t oldtop, ptrdiff_t ef)
 
LUAI_FUNC int luaD_poscall (lua_State *L, StkId firstResult)
 
LUAI_FUNC void luaD_reallocCI (lua_State *L, int newsize)
 
LUAI_FUNC void luaD_reallocstack (lua_State *L, int newsize)
 
LUAI_FUNC void luaD_growstack (lua_State *L, int n)
 
LUAI_FUNC void luaD_throw (lua_State *L, int errcode)
 
LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud)
 
LUAI_FUNC void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop)
 

Makro-Dokumentation

#define incr_top (   L)    {luaD_checkstack(L,1); L->top++;}

Definiert in Zeile 22 der Datei ldo.h.

#define luaD_checkstack (   L,
  n 
)
Wert:
if ((char *)L->stack_last - (char *)L->top <= (n)*(int)sizeof(TValue)) \
luaD_growstack(L, n); \

Definiert in Zeile 16 der Datei ldo.h.

#define PCRC   1 /* did a call to a C function */

Definiert in Zeile 33 der Datei ldo.h.

#define PCRLUA   0 /* initiated a call to a Lua function */

Definiert in Zeile 32 der Datei ldo.h.

#define PCRYIELD   2 /* C funtion yielded */

Definiert in Zeile 34 der Datei ldo.h.

#define restoreci (   L,
  n 
)    ((CallInfo *)((char *)L->base_ci + (n)))

Definiert in Zeile 28 der Datei ldo.h.

#define restorestack (   L,
  n 
)    ((TValue *)((char *)L->stack + (n)))

Definiert in Zeile 25 der Datei ldo.h.

#define saveci (   L,
 
)    ((char *)(p) - (char *)L->base_ci)

Definiert in Zeile 27 der Datei ldo.h.

#define savestack (   L,
 
)    ((char *)(p) - (char *)L->stack)

Definiert in Zeile 24 der Datei ldo.h.

Dokumentation der benutzerdefinierten Typen

typedef void(* Pfunc)(lua_State *L, void *ud)

Definiert in Zeile 38 der Datei ldo.h.

Dokumentation der Funktionen

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  oldtop,
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 }