CHDK_DE Vorschauversion  Trunk Rev. 6014
 Alle Datenstrukturen Dateien Funktionen Variablen Typdefinitionen Aufzählungen Aufzählungswerte Makrodefinitionen
Makrodefinitionen | Funktionen
lcode.c-Dateireferenz
#include <stdlib.h>
#include "lua.h"
#include "lcode.h"
#include "ldebug.h"
#include "ldo.h"
#include "lgc.h"
#include "llex.h"
#include "lmem.h"
#include "lobject.h"
#include "lopcodes.h"
#include "lparser.h"
#include "ltable.h"
+ Include-Abhängigkeitsdiagramm für lcode.c:

gehe zum Quellcode dieser Datei

Makrodefinitionen

#define lcode_c
 
#define LUA_CORE
 
#define hasjumps(e)   ((e)->t != (e)->f)
 

Funktionen

static int isnumeral (expdesc *e)
 
LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n)
 
LUAI_FUNC int luaK_jump (FuncState *fs)
 
LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret)
 
static int condjump (FuncState *fs, OpCode op, int A, int B, int C)
 
static void fixjump (FuncState *fs, int pc, int dest)
 
LUAI_FUNC int luaK_getlabel (FuncState *fs)
 
static int getjump (FuncState *fs, int pc)
 
static Instruction * getjumpcontrol (FuncState *fs, int pc)
 
static int need_value (FuncState *fs, int list)
 
static int patchtestreg (FuncState *fs, int node, int reg)
 
static void removevalues (FuncState *fs, int list)
 
static void patchlistaux (FuncState *fs, int list, int vtarget, int reg, int dtarget)
 
static void dischargejpc (FuncState *fs)
 
LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target)
 
LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list)
 
LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2)
 
LUAI_FUNC void luaK_checkstack (FuncState *fs, int n)
 
LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n)
 
static void freereg (FuncState *fs, int reg)
 
static void freeexp (FuncState *fs, expdesc *e)
 
static int addk (FuncState *fs, TValue *k, TValue *v)
 
LUAI_FUNC int luaK_stringK (FuncState *fs, TString *s)
 
LUAI_FUNC int luaK_numberK (FuncState *fs, lua_Number r)
 
static int boolK (FuncState *fs, int b)
 
static int nilK (FuncState *fs)
 
LUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults)
 
LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e)
 
LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e)
 
static int code_label (FuncState *fs, int A, int b, int jump)
 
static void discharge2reg (FuncState *fs, expdesc *e, int reg)
 
static void discharge2anyreg (FuncState *fs, expdesc *e)
 
static void exp2reg (FuncState *fs, expdesc *e, int reg)
 
LUAI_FUNC void luaK_exp2nextreg (FuncState *fs, expdesc *e)
 
LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e)
 
LUAI_FUNC void luaK_exp2val (FuncState *fs, expdesc *e)
 
LUAI_FUNC int luaK_exp2RK (FuncState *fs, expdesc *e)
 
LUAI_FUNC void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex)
 
LUAI_FUNC void luaK_self (FuncState *fs, expdesc *e, expdesc *key)
 
static void invertjump (FuncState *fs, expdesc *e)
 
static int jumponcond (FuncState *fs, expdesc *e, int cond)
 
LUAI_FUNC void luaK_goiftrue (FuncState *fs, expdesc *e)
 
static void luaK_goiffalse (FuncState *fs, expdesc *e)
 
static void codenot (FuncState *fs, expdesc *e)
 
LUAI_FUNC void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k)
 
static int constfolding (OpCode op, expdesc *e1, expdesc *e2)
 
static void codearith (FuncState *fs, OpCode op, expdesc *e1, expdesc *e2)
 
static void codecomp (FuncState *fs, OpCode op, int cond, expdesc *e1, expdesc *e2)
 
LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e)
 
LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v)
 
LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *e1, expdesc *e2)
 
LUAI_FUNC void luaK_fixline (FuncState *fs, int line)
 
static int luaK_code (FuncState *fs, Instruction i, int line)
 
LUAI_FUNC int luaK_codeABC (FuncState *fs, OpCode o, int a, int b, int c)
 
LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int a, unsigned int bc)
 
LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore)
 

Makro-Dokumentation

#define hasjumps (   e)    ((e)->t != (e)->f)

Definiert in Zeile 27 der Datei lcode.c.

#define lcode_c

Definiert in Zeile 10 der Datei lcode.c.

#define LUA_CORE

Definiert in Zeile 11 der Datei lcode.c.

Dokumentation der Funktionen

static int addk ( FuncState *  fs,
TValue *  k,
TValue *  v 
)
static

Definiert in Zeile 229 der Datei lcode.c.

229  {
230  lua_State *L = fs->L;
231  TValue *idx = luaH_set(L, fs->h, k);
232  Proto *f = fs->f;
233  int oldsize = f->sizek;
234  if (ttisnumber(idx)) {
235  lua_assert(luaO_rawequalObj(&fs->f->k[cast_int(nvalue(idx))], v));
236  return cast_int(nvalue(idx));
237  }
238  else { /* constant not found; create a new entry */
239  setnvalue(idx, cast_num(fs->nk));
240  luaM_growvector(L, f->k, fs->nk, f->sizek, TValue,
241  MAXARG_Bx, "constant table overflow");
242  while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]);
243  setobj(L, &f->k[fs->nk], v);
244  luaC_barrier(L, f, v);
245  return fs->nk++;
246  }
247 }
static int boolK ( FuncState *  fs,
int  b 
)
static

Definiert in Zeile 264 der Datei lcode.c.

264  {
265  TValue o;
266  setbvalue(&o, b);
267  return addk(fs, &o, &o);
268 }
static int code_label ( FuncState *  fs,
int  A,
int  b,
int  jump 
)
static

Definiert in Zeile 337 der Datei lcode.c.

337  {
338  luaK_getlabel(fs); /* those instructions may be jump targets */
339  return luaK_codeABC(fs, OP_LOADBOOL, A, b, jump);
340 }
static void codearith ( FuncState *  fs,
OpCode  op,
expdesc *  e1,
expdesc *  e2 
)
static

Definiert in Zeile 653 der Datei lcode.c.

653  {
654  if (constfolding(op, e1, e2))
655  return;
656  else {
657  int o2 = (op != OP_UNM && op != OP_LEN) ? luaK_exp2RK(fs, e2) : 0;
658  int o1 = luaK_exp2RK(fs, e1);
659  if (o1 > o2) {
660  freeexp(fs, e1);
661  freeexp(fs, e2);
662  }
663  else {
664  freeexp(fs, e2);
665  freeexp(fs, e1);
666  }
667  e1->u.s.info = luaK_codeABC(fs, op, 0, o1, o2);
668  e1->k = VRELOCABLE;
669  }
670 }
static void codecomp ( FuncState *  fs,
OpCode  op,
int  cond,
expdesc *  e1,
expdesc *  e2 
)
static

Definiert in Zeile 673 der Datei lcode.c.

674  {
675  int o1 = luaK_exp2RK(fs, e1);
676  int o2 = luaK_exp2RK(fs, e2);
677  freeexp(fs, e2);
678  freeexp(fs, e1);
679  if (cond == 0 && op != OP_EQ) {
680  int temp; /* exchange args to replace by `<' or `<=' */
681  temp = o1; o1 = o2; o2 = temp; /* o1 <==> o2 */
682  cond = 1;
683  }
684  e1->u.s.info = condjump(fs, op, cond, o1, o2);
685  e1->k = VJMP;
686 }
static void codenot ( FuncState *  fs,
expdesc *  e 
)
static

Definiert in Zeile 586 der Datei lcode.c.

586  {
587  luaK_dischargevars(fs, e);
588  switch (e->k) {
589  case VNIL: case VFALSE: {
590  e->k = VTRUE;
591  break;
592  }
593  case VK: case VKNUM: case VTRUE: {
594  e->k = VFALSE;
595  break;
596  }
597  case VJMP: {
598  invertjump(fs, e);
599  break;
600  }
601  case VRELOCABLE:
602  case VNONRELOC: {
603  discharge2anyreg(fs, e);
604  freeexp(fs, e);
605  e->u.s.info = luaK_codeABC(fs, OP_NOT, 0, e->u.s.info, 0);
606  e->k = VRELOCABLE;
607  break;
608  }
609  default: {
610  lua_assert(0); /* cannot happen */
611  break;
612  }
613  }
614  /* interchange true and false lists */
615  { int temp = e->f; e->f = e->t; e->t = temp; }
616  removevalues(fs, e->f);
617  removevalues(fs, e->t);
618 }
static int condjump ( FuncState *  fs,
OpCode  op,
int  A,
int  B,
int  C 
)
static

Definiert in Zeile 74 der Datei lcode.c.

74  {
75  luaK_codeABC(fs, op, A, B, C);
76  return luaK_jump(fs);
77 }
static int constfolding ( OpCode  op,
expdesc *  e1,
expdesc *  e2 
)
static

Definiert in Zeile 627 der Datei lcode.c.

627  {
628  lua_Number v1, v2, r;
629  if (!isnumeral(e1) || !isnumeral(e2)) return 0;
630  v1 = e1->u.nval;
631  v2 = e2->u.nval;
632  switch (op) {
633  case OP_ADD: r = luai_numadd(v1, v2); break;
634  case OP_SUB: r = luai_numsub(v1, v2); break;
635  case OP_MUL: r = luai_nummul(v1, v2); break;
636  case OP_DIV:
637  if (v2 == 0) return 0; /* do not attempt to divide by 0 */
638  r = luai_numdiv(v1, v2); break;
639  case OP_MOD:
640  if (v2 == 0) return 0; /* do not attempt to divide by 0 */
641  r = luai_nummod(v1, v2); break;
642  case OP_POW: r = luai_numpow(v1, v2); break;
643  case OP_UNM: r = luai_numunm(v1); break;
644  case OP_LEN: return 0; /* no constant folding for 'len' */
645  default: lua_assert(0); r = 0; break;
646  }
647  if (luai_numisnan(r)) return 0; /* do not attempt to produce NaN */
648  e1->u.nval = r;
649  return 1;
650 }
static void discharge2anyreg ( FuncState *  fs,
expdesc *  e 
)
static

Definiert in Zeile 382 der Datei lcode.c.

382  {
383  if (e->k != VNONRELOC) {
384  luaK_reserveregs(fs, 1);
385  discharge2reg(fs, e, fs->freereg-1);
386  }
387 }
static void discharge2reg ( FuncState *  fs,
expdesc *  e,
int  reg 
)
static

Definiert in Zeile 343 der Datei lcode.c.

343  {
344  luaK_dischargevars(fs, e);
345  switch (e->k) {
346  case VNIL: {
347  luaK_nil(fs, reg, 1);
348  break;
349  }
350  case VFALSE: case VTRUE: {
351  luaK_codeABC(fs, OP_LOADBOOL, reg, e->k == VTRUE, 0);
352  break;
353  }
354  case VK: {
355  luaK_codeABx(fs, OP_LOADK, reg, e->u.s.info);
356  break;
357  }
358  case VKNUM: {
359  luaK_codeABx(fs, OP_LOADK, reg, luaK_numberK(fs, e->u.nval));
360  break;
361  }
362  case VRELOCABLE: {
363  Instruction *pc = &getcode(fs, e);
364  SETARG_A(*pc, reg);
365  break;
366  }
367  case VNONRELOC: {
368  if (reg != e->u.s.info)
369  luaK_codeABC(fs, OP_MOVE, reg, e->u.s.info, 0);
370  break;
371  }
372  default: {
373  lua_assert(e->k == VVOID || e->k == VJMP);
374  return; /* nothing to do... */
375  }
376  }
377  e->u.s.info = reg;
378  e->k = VNONRELOC;
379 }
static void dischargejpc ( FuncState *  fs)
static

Definiert in Zeile 163 der Datei lcode.c.

163  {
164  patchlistaux(fs, fs->jpc, fs->pc, NO_REG, fs->pc);
165  fs->jpc = NO_JUMP;
166 }
static void exp2reg ( FuncState *  fs,
expdesc *  e,
int  reg 
)
static

Definiert in Zeile 390 der Datei lcode.c.

390  {
391  discharge2reg(fs, e, reg);
392  if (e->k == VJMP)
393  luaK_concat(fs, &e->t, e->u.s.info); /* put this jump in `t' list */
394  if (hasjumps(e)) {
395  int final; /* position after whole expression */
396  int p_f = NO_JUMP; /* position of an eventual LOAD false */
397  int p_t = NO_JUMP; /* position of an eventual LOAD true */
398  if (need_value(fs, e->t) || need_value(fs, e->f)) {
399  int fj = (e->k == VJMP) ? NO_JUMP : luaK_jump(fs);
400  p_f = code_label(fs, reg, 0, 1);
401  p_t = code_label(fs, reg, 1, 0);
402  luaK_patchtohere(fs, fj);
403  }
404  final = luaK_getlabel(fs);
405  patchlistaux(fs, e->f, final, reg, p_f);
406  patchlistaux(fs, e->t, final, reg, p_t);
407  }
408  e->f = e->t = NO_JUMP;
409  e->u.s.info = reg;
410  e->k = VNONRELOC;
411 }
static void fixjump ( FuncState *  fs,
int  pc,
int  dest 
)
static

Definiert in Zeile 80 der Datei lcode.c.

80  {
81  Instruction *jmp = &fs->f->code[pc];
82  int offset = dest-(pc+1);
83  lua_assert(dest != NO_JUMP);
84  if (abs(offset) > MAXARG_sBx)
85  luaX_syntaxerror(fs->ls, "control structure too long");
86  SETARG_sBx(*jmp, offset);
87 }
static void freeexp ( FuncState *  fs,
expdesc *  e 
)
static

Definiert in Zeile 223 der Datei lcode.c.

223  {
224  if (e->k == VNONRELOC)
225  freereg(fs, e->u.s.info);
226 }
static void freereg ( FuncState *  fs,
int  reg 
)
static

Definiert in Zeile 215 der Datei lcode.c.

215  {
216  if (!ISK(reg) && reg >= fs->nactvar) {
217  fs->freereg--;
218  lua_assert(reg == fs->freereg);
219  }
220 }
static int getjump ( FuncState *  fs,
int  pc 
)
static

Definiert in Zeile 100 der Datei lcode.c.

100  {
101  int offset = GETARG_sBx(fs->f->code[pc]);
102  if (offset == NO_JUMP) /* point to itself represents end of list */
103  return NO_JUMP; /* end of list */
104  else
105  return (pc+1)+offset; /* turn offset into absolute position */
106 }
static Instruction* getjumpcontrol ( FuncState *  fs,
int  pc 
)
static

Definiert in Zeile 109 der Datei lcode.c.

109  {
110  Instruction *pi = &fs->f->code[pc];
111  if (pc >= 1 && testTMode(GET_OPCODE(*(pi-1))))
112  return pi-1;
113  else
114  return pi;
115 }
static void invertjump ( FuncState *  fs,
expdesc *  e 
)
static

Definiert in Zeile 516 der Datei lcode.c.

516  {
517  Instruction *pc = getjumpcontrol(fs, e->u.s.info);
518  lua_assert(testTMode(GET_OPCODE(*pc)) && GET_OPCODE(*pc) != OP_TESTSET &&
519  GET_OPCODE(*pc) != OP_TEST);
520  SETARG_A(*pc, !(GETARG_A(*pc)));
521 }
static int isnumeral ( expdesc *  e)
static

Definiert in Zeile 30 der Datei lcode.c.

30  {
31  return (e->k == VKNUM && e->t == NO_JUMP && e->f == NO_JUMP);
32 }
static int jumponcond ( FuncState *  fs,
expdesc *  e,
int  cond 
)
static

Definiert in Zeile 524 der Datei lcode.c.

524  {
525  if (e->k == VRELOCABLE) {
526  Instruction ie = getcode(fs, e);
527  if (GET_OPCODE(ie) == OP_NOT) {
528  fs->pc--; /* remove previous OP_NOT */
529  return condjump(fs, OP_TEST, GETARG_B(ie), 0, !cond);
530  }
531  /* else go through */
532  }
533  discharge2anyreg(fs, e);
534  freeexp(fs, e);
535  return condjump(fs, OP_TESTSET, NO_REG, e->u.s.info, cond);
536 }
LUAI_FUNC void luaK_checkstack ( FuncState *  fs,
int  n 
)

Definiert in Zeile 199 der Datei lcode.c.

199  {
200  int newstack = fs->freereg + n;
201  if (newstack > fs->f->maxstacksize) {
202  if (newstack >= MAXSTACK)
203  luaX_syntaxerror(fs->ls, "function or expression too complex");
204  fs->f->maxstacksize = cast_byte(newstack);
205  }
206 }
static int luaK_code ( FuncState *  fs,
Instruction  i,
int  line 
)
static

Definiert in Zeile 789 der Datei lcode.c.

789  {
790  Proto *f = fs->f;
791  dischargejpc(fs); /* `pc' will change */
792  /* put new instruction in code array */
793  luaM_growvector(fs->L, f->code, fs->pc, f->sizecode, Instruction,
794  MAX_INT, "code size overflow");
795  f->code[fs->pc] = i;
796  /* save corresponding line information */
797  luaM_growvector(fs->L, f->lineinfo, fs->pc, f->sizelineinfo, int,
798  MAX_INT, "code size overflow");
799  f->lineinfo[fs->pc] = line;
800  return fs->pc++;
801 }
LUAI_FUNC int luaK_codeABC ( FuncState *  fs,
OpCode  o,
int  a,
int  b,
int  c 
)

Definiert in Zeile 804 der Datei lcode.c.

804  {
805  lua_assert(getOpMode(o) == iABC);
806  lua_assert(getBMode(o) != OpArgN || b == 0);
807  lua_assert(getCMode(o) != OpArgN || c == 0);
808  return luaK_code(fs, CREATE_ABC(o, a, b, c), fs->ls->lastline);
809 }
LUAI_FUNC int luaK_codeABx ( FuncState *  fs,
OpCode  o,
int  a,
unsigned int  bc 
)

Definiert in Zeile 812 der Datei lcode.c.

812  {
813  lua_assert(getOpMode(o) == iABx || getOpMode(o) == iAsBx);
814  lua_assert(getCMode(o) == OpArgN);
815  return luaK_code(fs, CREATE_ABx(o, a, bc), fs->ls->lastline);
816 }
LUAI_FUNC void luaK_concat ( FuncState *  fs,
int *  l1,
int  l2 
)

Definiert in Zeile 185 der Datei lcode.c.

185  {
186  if (l2 == NO_JUMP) return;
187  else if (*l1 == NO_JUMP)
188  *l1 = l2;
189  else {
190  int list = *l1;
191  int next;
192  while ((next = getjump(fs, list)) != NO_JUMP) /* find last element */
193  list = next;
194  fixjump(fs, list, l2);
195  }
196 }
LUAI_FUNC void luaK_dischargevars ( FuncState *  fs,
expdesc *  e 
)

Definiert in Zeile 304 der Datei lcode.c.

304  {
305  switch (e->k) {
306  case VLOCAL: {
307  e->k = VNONRELOC;
308  break;
309  }
310  case VUPVAL: {
311  e->u.s.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.s.info, 0);
312  e->k = VRELOCABLE;
313  break;
314  }
315  case VGLOBAL: {
316  e->u.s.info = luaK_codeABx(fs, OP_GETGLOBAL, 0, e->u.s.info);
317  e->k = VRELOCABLE;
318  break;
319  }
320  case VINDEXED: {
321  freereg(fs, e->u.s.aux);
322  freereg(fs, e->u.s.info);
323  e->u.s.info = luaK_codeABC(fs, OP_GETTABLE, 0, e->u.s.info, e->u.s.aux);
324  e->k = VRELOCABLE;
325  break;
326  }
327  case VVARARG:
328  case VCALL: {
329  luaK_setoneret(fs, e);
330  break;
331  }
332  default: break; /* there is one value available (somewhere) */
333  }
334 }
LUAI_FUNC int luaK_exp2anyreg ( FuncState *  fs,
expdesc *  e 
)

Definiert in Zeile 422 der Datei lcode.c.

422  {
423  luaK_dischargevars(fs, e);
424  if (e->k == VNONRELOC) {
425  if (!hasjumps(e)) return e->u.s.info; /* exp is already in a register */
426  if (e->u.s.info >= fs->nactvar) { /* reg. is not a local? */
427  exp2reg(fs, e, e->u.s.info); /* put value on it */
428  return e->u.s.info;
429  }
430  }
431  luaK_exp2nextreg(fs, e); /* default */
432  return e->u.s.info;
433 }
LUAI_FUNC void luaK_exp2nextreg ( FuncState *  fs,
expdesc *  e 
)

Definiert in Zeile 414 der Datei lcode.c.

414  {
415  luaK_dischargevars(fs, e);
416  freeexp(fs, e);
417  luaK_reserveregs(fs, 1);
418  exp2reg(fs, e, fs->freereg - 1);
419 }
LUAI_FUNC int luaK_exp2RK ( FuncState *  fs,
expdesc *  e 
)

Definiert in Zeile 444 der Datei lcode.c.

444  {
445  luaK_exp2val(fs, e);
446  switch (e->k) {
447  case VKNUM:
448  case VTRUE:
449  case VFALSE:
450  case VNIL: {
451  if (fs->nk <= MAXINDEXRK) { /* constant fit in RK operand? */
452  e->u.s.info = (e->k == VNIL) ? nilK(fs) :
453  (e->k == VKNUM) ? luaK_numberK(fs, e->u.nval) :
454  boolK(fs, (e->k == VTRUE));
455  e->k = VK;
456  return RKASK(e->u.s.info);
457  }
458  else break;
459  }
460  case VK: {
461  if (e->u.s.info <= MAXINDEXRK) /* constant fit in argC? */
462  return RKASK(e->u.s.info);
463  else break;
464  }
465  default: break;
466  }
467  /* not a constant in the right range: put it in a register */
468  return luaK_exp2anyreg(fs, e);
469 }
LUAI_FUNC void luaK_exp2val ( FuncState *  fs,
expdesc *  e 
)

Definiert in Zeile 436 der Datei lcode.c.

436  {
437  if (hasjumps(e))
438  luaK_exp2anyreg(fs, e);
439  else
440  luaK_dischargevars(fs, e);
441 }
LUAI_FUNC void luaK_fixline ( FuncState *  fs,
int  line 
)

Definiert in Zeile 784 der Datei lcode.c.

784  {
785  fs->f->lineinfo[fs->pc - 1] = line;
786 }
LUAI_FUNC int luaK_getlabel ( FuncState *  fs)

Definiert in Zeile 94 der Datei lcode.c.

94  {
95  fs->lasttarget = fs->pc;
96  return fs->pc;
97 }
static void luaK_goiffalse ( FuncState *  fs,
expdesc *  e 
)
static

Definiert in Zeile 563 der Datei lcode.c.

563  {
564  int pc; /* pc of last jump */
565  luaK_dischargevars(fs, e);
566  switch (e->k) {
567  case VNIL: case VFALSE: {
568  pc = NO_JUMP; /* always false; do nothing */
569  break;
570  }
571  case VJMP: {
572  pc = e->u.s.info;
573  break;
574  }
575  default: {
576  pc = jumponcond(fs, e, 1);
577  break;
578  }
579  }
580  luaK_concat(fs, &e->t, pc); /* insert last jump in `t' list */
581  luaK_patchtohere(fs, e->f);
582  e->f = NO_JUMP;
583 }
LUAI_FUNC void luaK_goiftrue ( FuncState *  fs,
expdesc *  e 
)

Definiert in Zeile 539 der Datei lcode.c.

539  {
540  int pc; /* pc of last jump */
541  luaK_dischargevars(fs, e);
542  switch (e->k) {
543  case VK: case VKNUM: case VTRUE: {
544  pc = NO_JUMP; /* always true; do nothing */
545  break;
546  }
547  case VJMP: {
548  invertjump(fs, e);
549  pc = e->u.s.info;
550  break;
551  }
552  default: {
553  pc = jumponcond(fs, e, 0);
554  break;
555  }
556  }
557  luaK_concat(fs, &e->f, pc); /* insert last jump in `f' list */
558  luaK_patchtohere(fs, e->t);
559  e->t = NO_JUMP;
560 }
LUAI_FUNC void luaK_indexed ( FuncState *  fs,
expdesc *  t,
expdesc *  k 
)

Definiert in Zeile 621 der Datei lcode.c.

621  {
622  t->u.s.aux = luaK_exp2RK(fs, k);
623  t->k = VINDEXED;
624 }
LUAI_FUNC void luaK_infix ( FuncState *  fs,
BinOpr  op,
expdesc *  v 
)

Definiert in Zeile 710 der Datei lcode.c.

710  {
711  switch (op) {
712  case OPR_AND: {
713  luaK_goiftrue(fs, v);
714  break;
715  }
716  case OPR_OR: {
717  luaK_goiffalse(fs, v);
718  break;
719  }
720  case OPR_CONCAT: {
721  luaK_exp2nextreg(fs, v); /* operand must be on the `stack' */
722  break;
723  }
724  case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV:
725  case OPR_MOD: case OPR_POW: {
726  if (!isnumeral(v)) luaK_exp2RK(fs, v);
727  break;
728  }
729  default: {
730  luaK_exp2RK(fs, v);
731  break;
732  }
733  }
734 }
LUAI_FUNC int luaK_jump ( FuncState *  fs)

Definiert in Zeile 59 der Datei lcode.c.

59  {
60  int jpc = fs->jpc; /* save list of jumps to here */
61  int j;
62  fs->jpc = NO_JUMP;
63  j = luaK_codeAsBx(fs, OP_JMP, 0, NO_JUMP);
64  luaK_concat(fs, &j, jpc); /* keep them on hold */
65  return j;
66 }
LUAI_FUNC void luaK_nil ( FuncState *  fs,
int  from,
int  n 
)

Definiert in Zeile 35 der Datei lcode.c.

35  {
36  Instruction *previous;
37  if (fs->pc > fs->lasttarget) { /* no jumps to current position? */
38  if (fs->pc == 0) { /* function start? */
39  if (from >= fs->nactvar)
40  return; /* positions are already clean */
41  }
42  else {
43  previous = &fs->f->code[fs->pc-1];
44  if (GET_OPCODE(*previous) == OP_LOADNIL) {
45  int pfrom = GETARG_A(*previous);
46  int pto = GETARG_B(*previous);
47  if (pfrom <= from && from <= pto+1) { /* can connect both? */
48  if (from+n-1 > pto)
49  SETARG_B(*previous, from+n-1);
50  return;
51  }
52  }
53  }
54  }
55  luaK_codeABC(fs, OP_LOADNIL, from, from+n-1, 0); /* else no optimization */
56 }
LUAI_FUNC int luaK_numberK ( FuncState *  fs,
lua_Number  r 
)

Definiert in Zeile 257 der Datei lcode.c.

257  {
258  TValue o;
259  setnvalue(&o, r);
260  return addk(fs, &o, &o);
261 }
LUAI_FUNC void luaK_patchlist ( FuncState *  fs,
int  list,
int  target 
)

Definiert in Zeile 169 der Datei lcode.c.

169  {
170  if (target == fs->pc)
171  luaK_patchtohere(fs, list);
172  else {
173  lua_assert(target < fs->pc);
174  patchlistaux(fs, list, target, NO_REG, target);
175  }
176 }
LUAI_FUNC void luaK_patchtohere ( FuncState *  fs,
int  list 
)

Definiert in Zeile 179 der Datei lcode.c.

179  {
180  luaK_getlabel(fs);
181  luaK_concat(fs, &fs->jpc, list);
182 }
LUAI_FUNC void luaK_posfix ( FuncState *  fs,
BinOpr  op,
expdesc *  e1,
expdesc *  e2 
)

Definiert in Zeile 737 der Datei lcode.c.

737  {
738  switch (op) {
739  case OPR_AND: {
740  lua_assert(e1->t == NO_JUMP); /* list must be closed */
741  luaK_dischargevars(fs, e2);
742  luaK_concat(fs, &e2->f, e1->f);
743  *e1 = *e2;
744  break;
745  }
746  case OPR_OR: {
747  lua_assert(e1->f == NO_JUMP); /* list must be closed */
748  luaK_dischargevars(fs, e2);
749  luaK_concat(fs, &e2->t, e1->t);
750  *e1 = *e2;
751  break;
752  }
753  case OPR_CONCAT: {
754  luaK_exp2val(fs, e2);
755  if (e2->k == VRELOCABLE && GET_OPCODE(getcode(fs, e2)) == OP_CONCAT) {
756  lua_assert(e1->u.s.info == GETARG_B(getcode(fs, e2))-1);
757  freeexp(fs, e1);
758  SETARG_B(getcode(fs, e2), e1->u.s.info);
759  e1->k = VRELOCABLE; e1->u.s.info = e2->u.s.info;
760  }
761  else {
762  luaK_exp2nextreg(fs, e2); /* operand must be on the 'stack' */
763  codearith(fs, OP_CONCAT, e1, e2);
764  }
765  break;
766  }
767  case OPR_ADD: codearith(fs, OP_ADD, e1, e2); break;
768  case OPR_SUB: codearith(fs, OP_SUB, e1, e2); break;
769  case OPR_MUL: codearith(fs, OP_MUL, e1, e2); break;
770  case OPR_DIV: codearith(fs, OP_DIV, e1, e2); break;
771  case OPR_MOD: codearith(fs, OP_MOD, e1, e2); break;
772  case OPR_POW: codearith(fs, OP_POW, e1, e2); break;
773  case OPR_EQ: codecomp(fs, OP_EQ, 1, e1, e2); break;
774  case OPR_NE: codecomp(fs, OP_EQ, 0, e1, e2); break;
775  case OPR_LT: codecomp(fs, OP_LT, 1, e1, e2); break;
776  case OPR_LE: codecomp(fs, OP_LE, 1, e1, e2); break;
777  case OPR_GT: codecomp(fs, OP_LT, 0, e1, e2); break;
778  case OPR_GE: codecomp(fs, OP_LE, 0, e1, e2); break;
779  default: lua_assert(0);
780  }
781 }
LUAI_FUNC void luaK_prefix ( FuncState *  fs,
UnOpr  op,
expdesc *  e 
)

Definiert in Zeile 689 der Datei lcode.c.

689  {
690  expdesc e2;
691  e2.t = e2.f = NO_JUMP; e2.k = VKNUM; e2.u.nval = 0;
692  switch (op) {
693  case OPR_MINUS: {
694  if (!isnumeral(e))
695  luaK_exp2anyreg(fs, e); /* cannot operate on non-numeric constants */
696  codearith(fs, OP_UNM, e, &e2);
697  break;
698  }
699  case OPR_NOT: codenot(fs, e); break;
700  case OPR_LEN: {
701  luaK_exp2anyreg(fs, e); /* cannot operate on constants */
702  codearith(fs, OP_LEN, e, &e2);
703  break;
704  }
705  default: lua_assert(0);
706  }
707 }
LUAI_FUNC void luaK_reserveregs ( FuncState *  fs,
int  n 
)

Definiert in Zeile 209 der Datei lcode.c.

209  {
210  luaK_checkstack(fs, n);
211  fs->freereg += n;
212 }
LUAI_FUNC void luaK_ret ( FuncState *  fs,
int  first,
int  nret 
)

Definiert in Zeile 69 der Datei lcode.c.

69  {
70  luaK_codeABC(fs, OP_RETURN, first, nret+1, 0);
71 }
LUAI_FUNC void luaK_self ( FuncState *  fs,
expdesc *  e,
expdesc *  key 
)

Definiert in Zeile 503 der Datei lcode.c.

503  {
504  int func;
505  luaK_exp2anyreg(fs, e);
506  freeexp(fs, e);
507  func = fs->freereg;
508  luaK_reserveregs(fs, 2);
509  luaK_codeABC(fs, OP_SELF, func, e->u.s.info, luaK_exp2RK(fs, key));
510  freeexp(fs, key);
511  e->u.s.info = func;
512  e->k = VNONRELOC;
513 }
LUAI_FUNC void luaK_setlist ( FuncState *  fs,
int  base,
int  nelems,
int  tostore 
)

Definiert in Zeile 819 der Datei lcode.c.

819  {
820  int c = (nelems - 1)/LFIELDS_PER_FLUSH + 1;
821  int b = (tostore == LUA_MULTRET) ? 0 : tostore;
822  lua_assert(tostore != 0);
823  if (c <= MAXARG_C)
824  luaK_codeABC(fs, OP_SETLIST, base, b, c);
825  else {
826  luaK_codeABC(fs, OP_SETLIST, base, b, 0);
827  luaK_code(fs, cast(Instruction, c), fs->ls->lastline);
828  }
829  fs->freereg = base + 1; /* free registers with list values */
830 }
LUAI_FUNC void luaK_setoneret ( FuncState *  fs,
expdesc *  e 
)

Definiert in Zeile 292 der Datei lcode.c.

292  {
293  if (e->k == VCALL) { /* expression is an open function call? */
294  e->k = VNONRELOC;
295  e->u.s.info = GETARG_A(getcode(fs, e));
296  }
297  else if (e->k == VVARARG) {
298  SETARG_B(getcode(fs, e), 2);
299  e->k = VRELOCABLE; /* can relocate its simple result */
300  }
301 }
LUAI_FUNC void luaK_setreturns ( FuncState *  fs,
expdesc *  e,
int  nresults 
)

Definiert in Zeile 280 der Datei lcode.c.

280  {
281  if (e->k == VCALL) { /* expression is an open function call? */
282  SETARG_C(getcode(fs, e), nresults+1);
283  }
284  else if (e->k == VVARARG) {
285  SETARG_B(getcode(fs, e), nresults+1);
286  SETARG_A(getcode(fs, e), fs->freereg);
287  luaK_reserveregs(fs, 1);
288  }
289 }
LUAI_FUNC void luaK_storevar ( FuncState *  fs,
expdesc *  var,
expdesc *  ex 
)

Definiert in Zeile 472 der Datei lcode.c.

472  {
473  switch (var->k) {
474  case VLOCAL: {
475  freeexp(fs, ex);
476  exp2reg(fs, ex, var->u.s.info);
477  return;
478  }
479  case VUPVAL: {
480  int e = luaK_exp2anyreg(fs, ex);
481  luaK_codeABC(fs, OP_SETUPVAL, e, var->u.s.info, 0);
482  break;
483  }
484  case VGLOBAL: {
485  int e = luaK_exp2anyreg(fs, ex);
486  luaK_codeABx(fs, OP_SETGLOBAL, e, var->u.s.info);
487  break;
488  }
489  case VINDEXED: {
490  int e = luaK_exp2RK(fs, ex);
491  luaK_codeABC(fs, OP_SETTABLE, var->u.s.info, var->u.s.aux, e);
492  break;
493  }
494  default: {
495  lua_assert(0); /* invalid var kind to store */
496  break;
497  }
498  }
499  freeexp(fs, ex);
500 }
LUAI_FUNC int luaK_stringK ( FuncState *  fs,
TString *  s 
)

Definiert in Zeile 250 der Datei lcode.c.

250  {
251  TValue o;
252  setsvalue(fs->L, &o, s);
253  return addk(fs, &o, &o);
254 }
static int need_value ( FuncState *  fs,
int  list 
)
static

Definiert in Zeile 122 der Datei lcode.c.

122  {
123  for (; list != NO_JUMP; list = getjump(fs, list)) {
124  Instruction i = *getjumpcontrol(fs, list);
125  if (GET_OPCODE(i) != OP_TESTSET) return 1;
126  }
127  return 0; /* not found */
128 }
static int nilK ( FuncState *  fs)
static

Definiert in Zeile 271 der Datei lcode.c.

271  {
272  TValue k, v;
273  setnilvalue(&v);
274  /* cannot use nil as key; instead use table itself to represent nil */
275  sethvalue(fs->L, &k, fs->h);
276  return addk(fs, &k, &v);
277 }
static void patchlistaux ( FuncState *  fs,
int  list,
int  vtarget,
int  reg,
int  dtarget 
)
static

Definiert in Zeile 150 der Datei lcode.c.

151  {
152  while (list != NO_JUMP) {
153  int next = getjump(fs, list);
154  if (patchtestreg(fs, list, reg))
155  fixjump(fs, list, vtarget);
156  else
157  fixjump(fs, list, dtarget); /* jump to default target */
158  list = next;
159  }
160 }
static int patchtestreg ( FuncState *  fs,
int  node,
int  reg 
)
static

Definiert in Zeile 131 der Datei lcode.c.

131  {
132  Instruction *i = getjumpcontrol(fs, node);
133  if (GET_OPCODE(*i) != OP_TESTSET)
134  return 0; /* cannot patch other instructions */
135  if (reg != NO_REG && reg != GETARG_B(*i))
136  SETARG_A(*i, reg);
137  else /* no register to put value or register already has the value */
138  *i = CREATE_ABC(OP_TEST, GETARG_B(*i), 0, GETARG_C(*i));
139 
140  return 1;
141 }
static void removevalues ( FuncState *  fs,
int  list 
)
static

Definiert in Zeile 144 der Datei lcode.c.

144  {
145  for (; list != NO_JUMP; list = getjump(fs, list))
146  patchtestreg(fs, list, NO_REG);
147 }