#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"

Macros
#define	lcode_c

#define	LUA_CORE

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

Functions
static int	isnumeral (expdesc *e)

void	luaK_nil (FuncState *fs, int from, int n)

int	luaK_jump (FuncState *fs)

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)

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)

void	luaK_patchlist (FuncState *fs, int list, int target)

void	luaK_patchtohere (FuncState *fs, int list)

void	luaK_concat (FuncState fs, int l1, int l2)

void	luaK_checkstack (FuncState *fs, int n)

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)

int	luaK_stringK (FuncState fs, TString s)

int	luaK_numberK (FuncState *fs, lua_Number r)

static int	boolK (FuncState *fs, int b)

static int	nilK (FuncState *fs)

void	luaK_setreturns (FuncState fs, expdesc e, int nresults)

void	luaK_setoneret (FuncState fs, expdesc e)

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)

void	luaK_exp2nextreg (FuncState fs, expdesc e)

int	luaK_exp2anyreg (FuncState fs, expdesc e)

void	luaK_exp2val (FuncState fs, expdesc e)

int	luaK_exp2RK (FuncState fs, expdesc e)

void	luaK_storevar (FuncState fs, expdesc var, expdesc *ex)

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)

void	luaK_goiftrue (FuncState fs, expdesc e)

static void	luaK_goiffalse (FuncState fs, expdesc e)

static void	codenot (FuncState fs, expdesc e)

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)

void	luaK_prefix (FuncState fs, UnOpr op, expdesc e)

void	luaK_infix (FuncState fs, BinOpr op, expdesc v)

void	luaK_posfix (FuncState fs, BinOpr op, expdesc e1, expdesc *e2)

void	luaK_fixline (FuncState *fs, int line)

static int	luaK_code (FuncState *fs, Instruction i, int line)

int	luaK_codeABC (FuncState *fs, OpCode o, int a, int b, int c)

int	luaK_codeABx (FuncState *fs, OpCode o, int a, unsigned int bc)

void	luaK_setlist (FuncState *fs, int base, int nelems, int tostore)

Macro Definition Documentation

◆ hasjumps

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

Definition at line 27 of file lua-5.1.5/src/lcode.c.

Referenced by exp2reg(), luaK_exp2anyreg(), and luaK_exp2val().

◆ lcode_c

#define lcode_c

Definition at line 10 of file lua-5.1.5/src/lcode.c.

◆ LUA_CORE

#define LUA_CORE

Definition at line 11 of file lua-5.1.5/src/lcode.c.

Function Documentation

◆ addk()

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

static

Definition at line 229 of file lua-5.1.5/src/lcode.c.

                                                      {
  lua_State *L = fs->L;
  TValue *idx = luaH_set(L, fs->h, k);
  Proto *f = fs->f;
  int oldsize = f->sizek;
  if (ttisnumber(idx)) {
    lua_assert(luaO_rawequalObj(&fs->f->k[cast_int(nvalue(idx))], v));
    return cast_int(nvalue(idx));
  }
  else {  /* constant not found; create a new entry */
    setnvalue(idx, cast_num(fs->nk));
    luaM_growvector(L, f->k, fs->nk, f->sizek, TValue,
                    MAXARG_Bx, "constant table overflow");
    while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]);
    setobj(L, &f->k[fs->nk], v);
    luaC_barrier(L, f, v);
    return fs->nk++;
  }
}

References cast_int, cast_num, FuncState::f, FuncState::h, Proto::k, FuncState::L, lua_assert, luaC_barrier, luaH_set(), luaM_growvector, luaO_rawequalObj(), MAXARG_Bx, FuncState::nk, nvalue, setnilvalue, setnvalue, setobj, Proto::sizek, and ttisnumber.

Referenced by boolK(), luaK_numberK(), luaK_stringK(), and nilK().

◆ boolK()

static int boolK	(	FuncState *	fs,
		int	b )

static

Definition at line 264 of file lua-5.1.5/src/lcode.c.

                                        {
  TValue o;
  setbvalue(&o, b);
  return addk(fs, &o, &o);
}

References addk(), and setbvalue.

Referenced by luaK_exp2RK().

◆ code_label()

static int code_label	(	FuncState *	fs,
		int	A,
		int	b,
		int	jump )

static

Definition at line 337 of file lua-5.1.5/src/lcode.c.

                                                              {
  luaK_getlabel(fs);  /* those instructions may be jump targets */
  return luaK_codeABC(fs, OP_LOADBOOL, A, b, jump);
}

References luaK_codeABC, luaK_getlabel(), and OP_LOADBOOL.

Referenced by exp2reg().

◆ codearith()

static void codearith	(	FuncState *	fs,
		OpCode	op,
		expdesc *	e1,
		expdesc *	e2 )

static

Definition at line 653 of file lua-5.1.5/src/lcode.c.

                                                                           {
  if (constfolding(op, e1, e2))
    return;
  else {
    int o2 = (op != OP_UNM && op != OP_LEN) ? luaK_exp2RK(fs, e2) : 0;
    int o1 = luaK_exp2RK(fs, e1);
    if (o1 > o2) {
      freeexp(fs, e1);
      freeexp(fs, e2);
    }
    else {
      freeexp(fs, e2);
      freeexp(fs, e1);
    }
    e1->u.s.info = luaK_codeABC(fs, op, 0, o1, o2);
    e1->k = VRELOCABLE;
  }
}

References constfolding(), freeexp(), expdesc::info, expdesc::k, luaK_codeABC, luaK_exp2RK(), OP_LEN, OP_UNM, expdesc::s, expdesc::u, and VRELOCABLE.

Referenced by luaK_posfix(), and luaK_prefix().

◆ codecomp()

static void codecomp	(	FuncState *	fs,
		OpCode	op,
		int	cond,
		expdesc *	e1,
		expdesc *	e2 )

static

Definition at line 673 of file lua-5.1.5/src/lcode.c.

                                                                       {
  int o1 = luaK_exp2RK(fs, e1);
  int o2 = luaK_exp2RK(fs, e2);
  freeexp(fs, e2);
  freeexp(fs, e1);
  if (cond == 0 && op != OP_EQ) {
    int temp;  /* exchange args to replace by `<' or `<=' */
    temp = o1; o1 = o2; o2 = temp;  /* o1 <==> o2 */
    cond = 1;
  }
  e1->u.s.info = condjump(fs, op, cond, o1, o2);
  e1->k = VJMP;
}

References cond(), condjump(), freeexp(), expdesc::info, expdesc::k, luaK_exp2RK(), OP_EQ, expdesc::s, expdesc::u, and VJMP.

Referenced by luaK_posfix().

◆ codenot()

static void codenot	(	FuncState *	fs,
		expdesc *	e )

static

Definition at line 586 of file lua-5.1.5/src/lcode.c.

                                                {
  luaK_dischargevars(fs, e);
  switch (e->k) {
    case VNIL: case VFALSE: {
      e->k = VTRUE;
      break;
    }
    case VK: case VKNUM: case VTRUE: {
      e->k = VFALSE;
      break;
    }
    case VJMP: {
      invertjump(fs, e);
      break;
    }
    case VRELOCABLE:
    case VNONRELOC: {
      discharge2anyreg(fs, e);
      freeexp(fs, e);
      e->u.s.info = luaK_codeABC(fs, OP_NOT, 0, e->u.s.info, 0);
      e->k = VRELOCABLE;
      break;
    }
    default: {
      lua_assert(0);  /* cannot happen */
      break;
    }
  }
  /* interchange true and false lists */
  { int temp = e->f; e->f = e->t; e->t = temp; }
  removevalues(fs, e->f);
  removevalues(fs, e->t);
}

References discharge2anyreg(), expdesc::f, freeexp(), expdesc::info, invertjump(), expdesc::k, lua_assert, luaK_codeABC, luaK_dischargevars(), OP_NOT, removevalues(), expdesc::s, expdesc::t, expdesc::u, VFALSE, VJMP, VK, VKNUM, VNIL, VNONRELOC, VRELOCABLE, and VTRUE.

Referenced by luaK_prefix().

◆ condjump()

static int condjump	(	FuncState *	fs,
		OpCode	op,
		int	A,
		int	B,
		int	C )

static

Definition at line 74 of file lua-5.1.5/src/lcode.c.

                                                                    {
  luaK_codeABC(fs, op, A, B, C);
  return luaK_jump(fs);
}

References luaK_codeABC, and luaK_jump().

Referenced by codecomp(), and jumponcond().

◆ constfolding()

static int constfolding	(	OpCode	op,
		expdesc *	e1,
		expdesc *	e2 )

static

Definition at line 627 of file lua-5.1.5/src/lcode.c.

                                                              {
  lua_Number v1, v2, r;
  if (!isnumeral(e1) || !isnumeral(e2)) return 0;
  v1 = e1->u.nval;
  v2 = e2->u.nval;
  switch (op) {
    case OP_ADD: r = luai_numadd(v1, v2); break;
    case OP_SUB: r = luai_numsub(v1, v2); break;
    case OP_MUL: r = luai_nummul(v1, v2); break;
    case OP_DIV:
      if (v2 == 0) return 0;  /* do not attempt to divide by 0 */
      r = luai_numdiv(v1, v2); break;
    case OP_MOD:
      if (v2 == 0) return 0;  /* do not attempt to divide by 0 */
      r = luai_nummod(v1, v2); break;
    case OP_POW: r = luai_numpow(v1, v2); break;
    case OP_UNM: r = luai_numunm(v1); break;
    case OP_LEN: return 0;  /* no constant folding for 'len' */
    default: lua_assert(0); r = 0; break;
  }
  if (luai_numisnan(r)) return 0;  /* do not attempt to produce NaN */
  e1->u.nval = r;
  return 1;
}

References isnumeral(), lua_assert, luai_numadd, luai_numdiv, luai_numisnan, luai_nummod, luai_nummul, luai_numpow, luai_numsub, luai_numunm, expdesc::nval, OP_ADD, OP_DIV, OP_LEN, OP_MOD, OP_MUL, OP_POW, OP_SUB, OP_UNM, and expdesc::u.

Referenced by codearith().

◆ discharge2anyreg()

static void discharge2anyreg	(	FuncState *	fs,
		expdesc *	e )

static

Definition at line 382 of file lua-5.1.5/src/lcode.c.

                                                         {
  if (e->k != VNONRELOC) {
    luaK_reserveregs(fs, 1);
    discharge2reg(fs, e, fs->freereg-1);
  }
}

References discharge2reg(), FuncState::freereg, expdesc::k, luaK_reserveregs(), and VNONRELOC.

Referenced by codenot(), and jumponcond().

◆ discharge2reg()

static void discharge2reg	(	FuncState *	fs,
		expdesc *	e,
		int	reg )

static

Definition at line 343 of file lua-5.1.5/src/lcode.c.

                                                               {
  luaK_dischargevars(fs, e);
  switch (e->k) {
    case VNIL: {
      luaK_nil(fs, reg, 1);
      break;
    }
    case VFALSE:  case VTRUE: {
      luaK_codeABC(fs, OP_LOADBOOL, reg, e->k == VTRUE, 0);
      break;
    }
    case VK: {
      luaK_codeABx(fs, OP_LOADK, reg, e->u.s.info);
      break;
    }
    case VKNUM: {
      luaK_codeABx(fs, OP_LOADK, reg, luaK_numberK(fs, e->u.nval));
      break;
    }
    case VRELOCABLE: {
      Instruction *pc = &getcode(fs, e);
      SETARG_A(*pc, reg);
      break;
    }
    case VNONRELOC: {
      if (reg != e->u.s.info)
        luaK_codeABC(fs, OP_MOVE, reg, e->u.s.info, 0);
      break;
    }
    default: {
      lua_assert(e->k == VVOID || e->k == VJMP);
      return;  /* nothing to do... */
    }
  }
  e->u.s.info = reg;
  e->k = VNONRELOC;
}

References getcode, expdesc::info, expdesc::k, lua_assert, luaK_codeABC, luaK_codeABx(), luaK_dischargevars(), luaK_nil(), luaK_numberK(), expdesc::nval, OP_LOADBOOL, OP_LOADK, OP_MOVE, expdesc::s, SETARG_A, expdesc::u, VFALSE, VJMP, VK, VKNUM, VNIL, VNONRELOC, VRELOCABLE, VTRUE, and VVOID.

Referenced by discharge2anyreg(), and exp2reg().

◆ dischargejpc()

static void dischargejpc ( FuncState * fs )

static

Definition at line 163 of file lua-5.1.5/src/lcode.c.

                                         {
  patchlistaux(fs, fs->jpc, fs->pc, NO_REG, fs->pc);
  fs->jpc = NO_JUMP;
}

References FuncState::jpc, NO_JUMP, NO_REG, patchlistaux(), and FuncState::pc.

Referenced by luaK_code().

◆ exp2reg()

static void exp2reg	(	FuncState *	fs,
		expdesc *	e,
		int	reg )

static

Definition at line 390 of file lua-5.1.5/src/lcode.c.

                                                         {
  discharge2reg(fs, e, reg);
  if (e->k == VJMP)
    luaK_concat(fs, &e->t, e->u.s.info);  /* put this jump in `t' list */
  if (hasjumps(e)) {
    int final;  /* position after whole expression */
    int p_f = NO_JUMP;  /* position of an eventual LOAD false */
    int p_t = NO_JUMP;  /* position of an eventual LOAD true */
    if (need_value(fs, e->t) || need_value(fs, e->f)) {
      int fj = (e->k == VJMP) ? NO_JUMP : luaK_jump(fs);
      p_f = code_label(fs, reg, 0, 1);
      p_t = code_label(fs, reg, 1, 0);
      luaK_patchtohere(fs, fj);
    }
    final = luaK_getlabel(fs);
    patchlistaux(fs, e->f, final, reg, p_f);
    patchlistaux(fs, e->t, final, reg, p_t);
  }
  e->f = e->t = NO_JUMP;
  e->u.s.info = reg;
  e->k = VNONRELOC;
}

References code_label(), discharge2reg(), expdesc::f, hasjumps, expdesc::info, expdesc::k, luaK_concat(), luaK_getlabel(), luaK_jump(), luaK_patchtohere(), need_value(), NO_JUMP, patchlistaux(), expdesc::s, expdesc::t, expdesc::u, VJMP, and VNONRELOC.

Referenced by luaK_exp2anyreg(), luaK_exp2nextreg(), and luaK_storevar().

◆ fixjump()

static void fixjump	(	FuncState *	fs,
		int	pc,
		int	dest )

static

Definition at line 80 of file lua-5.1.5/src/lcode.c.

                                                      {
  Instruction *jmp = &fs->f->code[pc];
  int offset = dest-(pc+1);
  lua_assert(dest != NO_JUMP);
  if (abs(offset) > MAXARG_sBx)
    luaX_syntaxerror(fs->ls, "control structure too long");
  SETARG_sBx(*jmp, offset);
}

References Proto::code, FuncState::f, FuncState::ls, lua_assert, luaX_syntaxerror(), MAXARG_sBx, NO_JUMP, and SETARG_sBx.

Referenced by luaK_concat(), and patchlistaux().

◆ freeexp()

static void freeexp	(	FuncState *	fs,
		expdesc *	e )

static

Definition at line 223 of file lua-5.1.5/src/lcode.c.

                                                {
  if (e->k == VNONRELOC)
    freereg(fs, e->u.s.info);
}

References freereg(), expdesc::info, expdesc::k, expdesc::s, expdesc::u, and VNONRELOC.

Referenced by codearith(), codecomp(), codenot(), jumponcond(), luaK_exp2nextreg(), luaK_posfix(), luaK_self(), and luaK_storevar().

◆ freereg()

static void freereg	(	FuncState *	fs,
		int	reg )

static

Definition at line 215 of file lua-5.1.5/src/lcode.c.

                                             {
  if (!ISK(reg) && reg >= fs->nactvar) {
    fs->freereg--;
    lua_assert(reg == fs->freereg);
  }
}

References FuncState::freereg, ISK, lua_assert, and FuncState::nactvar.

Referenced by freeexp(), and luaK_dischargevars().

◆ getjump()

static int getjump	(	FuncState *	fs,
		int	pc )

static

Definition at line 100 of file lua-5.1.5/src/lcode.c.

                                           {
  int offset = GETARG_sBx(fs->f->code[pc]);
  if (offset == NO_JUMP)  /* point to itself represents end of list */
    return NO_JUMP;  /* end of list */
  else
    return (pc+1)+offset;  /* turn offset into absolute position */
}

References Proto::code, FuncState::f, GETARG_sBx, and NO_JUMP.

Referenced by luaK_concat(), need_value(), patchlistaux(), and removevalues().

◆ getjumpcontrol()

static Instruction * getjumpcontrol	(	FuncState *	fs,
		int	pc )

static

Definition at line 109 of file lua-5.1.5/src/lcode.c.

                                                           {
  Instruction *pi = &fs->f->code[pc];
  if (pc >= 1 && testTMode(GET_OPCODE(*(pi-1))))
    return pi-1;
  else
    return pi;
}

References Proto::code, FuncState::f, GET_OPCODE, and testTMode.

Referenced by invertjump(), need_value(), and patchtestreg().

◆ invertjump()

static void invertjump	(	FuncState *	fs,
		expdesc *	e )

static

Definition at line 516 of file lua-5.1.5/src/lcode.c.

                                                   {
  Instruction *pc = getjumpcontrol(fs, e->u.s.info);
  lua_assert(testTMode(GET_OPCODE(*pc)) && GET_OPCODE(*pc) != OP_TESTSET &&
                                           GET_OPCODE(*pc) != OP_TEST);
  SETARG_A(*pc, !(GETARG_A(*pc)));
}

References GET_OPCODE, GETARG_A, getjumpcontrol(), expdesc::info, lua_assert, OP_TEST, OP_TESTSET, expdesc::s, SETARG_A, testTMode, and expdesc::u.

Referenced by codenot(), and luaK_goiftrue().

◆ isnumeral()

static int isnumeral ( expdesc * e )

static

Definition at line 30 of file lua-5.1.5/src/lcode.c.

                                 {
  return (e->k == VKNUM && e->t == NO_JUMP && e->f == NO_JUMP);
}

References expdesc::f, expdesc::k, NO_JUMP, expdesc::t, and VKNUM.

Referenced by constfolding(), luaK_infix(), and luaK_prefix().

◆ jumponcond()

static int jumponcond	(	FuncState *	fs,
		expdesc *	e,
		int	cond )

static

Definition at line 524 of file lua-5.1.5/src/lcode.c.

                                                            {
  if (e->k == VRELOCABLE) {
    Instruction ie = getcode(fs, e);
    if (GET_OPCODE(ie) == OP_NOT) {
      fs->pc--;  /* remove previous OP_NOT */
      return condjump(fs, OP_TEST, GETARG_B(ie), 0, !cond);
    }
    /* else go through */
  }
  discharge2anyreg(fs, e);
  freeexp(fs, e);
  return condjump(fs, OP_TESTSET, NO_REG, e->u.s.info, cond);
}

References cond(), condjump(), discharge2anyreg(), freeexp(), GET_OPCODE, GETARG_B, getcode, expdesc::info, expdesc::k, NO_REG, OP_NOT, OP_TEST, OP_TESTSET, FuncState::pc, expdesc::s, expdesc::u, and VRELOCABLE.

Referenced by luaK_goiffalse(), and luaK_goiftrue().

◆ luaK_checkstack()

void luaK_checkstack	(	FuncState *	fs,
		int	n )

Definition at line 199 of file lua-5.1.5/src/lcode.c.

                                            {
  int newstack = fs->freereg + n;
  if (newstack > fs->f->maxstacksize) {
    if (newstack >= MAXSTACK)
      luaX_syntaxerror(fs->ls, "function or expression too complex");
    fs->f->maxstacksize = cast_byte(newstack);
  }
}

References cast_byte, FuncState::f, FuncState::freereg, FuncState::ls, luaX_syntaxerror(), MAXSTACK, and Proto::maxstacksize.

Referenced by forlist(), forlist(), forlist(), forlist(), and luaK_reserveregs().

◆ luaK_code()

static int luaK_code	(	FuncState *	fs,
		Instruction	i,
		int	line )

static

Definition at line 789 of file lua-5.1.5/src/lcode.c.

                                                              {
  Proto *f = fs->f;
  dischargejpc(fs);  /* `pc' will change */
  /* put new instruction in code array */
  luaM_growvector(fs->L, f->code, fs->pc, f->sizecode, Instruction,
                  MAX_INT, "code size overflow");
  f->code[fs->pc] = i;
  /* save corresponding line information */
  luaM_growvector(fs->L, f->lineinfo, fs->pc, f->sizelineinfo, int,
                  MAX_INT, "code size overflow");
  f->lineinfo[fs->pc] = line;
  return fs->pc++;
}

References Proto::code, dischargejpc(), FuncState::f, FuncState::L, Proto::lineinfo, luaM_growvector, MAX_INT, FuncState::pc, Proto::sizecode, and Proto::sizelineinfo.

Referenced by constructor(), luaK_codeABC(), luaK_codeABx(), and luaK_setlist().

◆ luaK_codeABC()

int luaK_codeABC	(	FuncState *	fs,
		OpCode	o,
		int	a,
		int	b,
		int	c )

Definition at line 804 of file lua-5.1.5/src/lcode.c.

                                                                {
  lua_assert(getOpMode(o) == iABC);
  lua_assert(getBMode(o) != OpArgN || b == 0);
  lua_assert(getCMode(o) != OpArgN || c == 0);
  return luaK_code(fs, CREATE_ABC(o, a, b, c), fs->ls->lastline);
}

References CREATE_ABC, getBMode, getCMode, getOpMode, iABC, LexState::lastline, FuncState::ls, lua_assert, luaK_code(), and OpArgN.

◆ luaK_codeABx()

int luaK_codeABx	(	FuncState *	fs,
		OpCode	o,
		int	a,
		unsigned int	bc )

Definition at line 812 of file lua-5.1.5/src/lcode.c.

                                                                   {
  lua_assert(getOpMode(o) == iABx || getOpMode(o) == iAsBx);
  lua_assert(getCMode(o) == OpArgN);
  return luaK_code(fs, CREATE_ABx(o, a, bc), fs->ls->lastline);
}

References CREATE_ABx, getCMode, getOpMode, iABx, iAsBx, LexState::lastline, FuncState::ls, lua_assert, luaK_code(), and OpArgN.

Referenced by codeclosure(), codeclosure(), codeclosure(), discharge2reg(), forbody(), fornum(), luaK_dischargevars(), luaK_storevar(), and pushclosure().

◆ luaK_concat()

void luaK_concat	(	FuncState *	fs,
		int *	l1,
		int	l2 )

Definition at line 185 of file lua-5.1.5/src/lcode.c.

                                                  {
  if (l2 == NO_JUMP) return;
  else if (*l1 == NO_JUMP)
    *l1 = l2;
  else {
    int list = *l1;
    int next;
    while ((next = getjump(fs, list)) != NO_JUMP)  /* find last element */
      list = next;
    fixjump(fs, list, l2);
  }
}

References fixjump(), getjump(), next, and NO_JUMP.

Referenced by breakstat(), exp2reg(), ifstat(), luaK_goiffalse(), luaK_goiftrue(), luaK_jump(), luaK_patchtohere(), luaK_posfix(), test_then_block(), test_then_block(), and test_then_block().

◆ luaK_dischargevars()

void luaK_dischargevars	(	FuncState *	fs,
		expdesc *	e )

Definition at line 304 of file lua-5.1.5/src/lcode.c.

                                                    {
  switch (e->k) {
    case VLOCAL: {
      e->k = VNONRELOC;
      break;
    }
    case VUPVAL: {
      e->u.s.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.s.info, 0);
      e->k = VRELOCABLE;
      break;
    }
    case VGLOBAL: {
      e->u.s.info = luaK_codeABx(fs, OP_GETGLOBAL, 0, e->u.s.info);
      e->k = VRELOCABLE;
      break;
    }
    case VINDEXED: {
      freereg(fs, e->u.s.aux);
      freereg(fs, e->u.s.info);
      e->u.s.info = luaK_codeABC(fs, OP_GETTABLE, 0, e->u.s.info, e->u.s.aux);
      e->k = VRELOCABLE;
      break;
    }
    case VVARARG:
    case VCALL: {
      luaK_setoneret(fs, e);
      break;
    }
    default: break;  /* there is one value available (somewhere) */
  }
}

References expdesc::aux, freereg(), expdesc::info, expdesc::k, luaK_codeABC, luaK_codeABx(), luaK_setoneret(), OP_GETGLOBAL, OP_GETTABLE, OP_GETUPVAL, expdesc::s, expdesc::u, VCALL, VGLOBAL, VINDEXED, VLOCAL, VNONRELOC, VRELOCABLE, VUPVAL, and VVARARG.

Referenced by codenot(), discharge2reg(), luaK_exp2anyreg(), luaK_exp2nextreg(), luaK_exp2val(), luaK_goiffalse(), luaK_goiftrue(), luaK_posfix(), prefixexp(), primaryexp(), primaryexp(), and primaryexp().

◆ luaK_exp2anyreg()

int luaK_exp2anyreg	(	FuncState *	fs,
		expdesc *	e )

Definition at line 422 of file lua-5.1.5/src/lcode.c.

                                                {
  luaK_dischargevars(fs, e);
  if (e->k == VNONRELOC) {
    if (!hasjumps(e)) return e->u.s.info;  /* exp is already in a register */
    if (e->u.s.info >= fs->nactvar) {  /* reg. is not a local? */
      exp2reg(fs, e, e->u.s.info);  /* put value on it */
      return e->u.s.info;
    }
  }
  luaK_exp2nextreg(fs, e);  /* default */
  return e->u.s.info;
}

References exp2reg(), hasjumps, expdesc::info, expdesc::k, luaK_dischargevars(), luaK_exp2nextreg(), FuncState::nactvar, expdesc::s, expdesc::u, and VNONRELOC.

Referenced by field(), luaK_exp2RK(), luaK_exp2val(), luaK_prefix(), luaK_self(), luaK_storevar(), primaryexp(), retstat(), retstat(), retstat(), and retstat().

◆ luaK_exp2nextreg()

void luaK_exp2nextreg	(	FuncState *	fs,
		expdesc *	e )

Definition at line 414 of file lua-5.1.5/src/lcode.c.

                                                  {
  luaK_dischargevars(fs, e);
  freeexp(fs, e);
  luaK_reserveregs(fs, 1);
  exp2reg(fs, e, fs->freereg - 1);
}

References exp2reg(), freeexp(), FuncState::freereg, luaK_dischargevars(), and luaK_reserveregs().

Referenced by adjust_assign(), adjust_assign(), adjust_assign(), adjust_assign(), closelistfield(), closelistfield(), closelistfield(), closelistfield(), codeclosure(), codeclosure(), codeclosure(), constructor(), constructor(), constructor(), exp1(), exp1(), exp1(), exp1(), explist(), explist(), explist(), explist1(), funcargs(), funcargs(), funcargs(), funcargs(), lastlistfield(), lastlistfield(), lastlistfield(), lastlistfield(), luaK_exp2anyreg(), luaK_infix(), luaK_posfix(), primaryexp(), retstat(), retstat(), retstat(), retstat(), suffixedexp(), suffixedexp(), and suffixedexp().

◆ luaK_exp2RK()

int luaK_exp2RK	(	FuncState *	fs,
		expdesc *	e )

Definition at line 444 of file lua-5.1.5/src/lcode.c.

                                            {
  luaK_exp2val(fs, e);
  switch (e->k) {
    case VKNUM:
    case VTRUE:
    case VFALSE:
    case VNIL: {
      if (fs->nk <= MAXINDEXRK) {  /* constant fit in RK operand? */
        e->u.s.info = (e->k == VNIL)  ? nilK(fs) :
                      (e->k == VKNUM) ? luaK_numberK(fs, e->u.nval) :
                                        boolK(fs, (e->k == VTRUE));
        e->k = VK;
        return RKASK(e->u.s.info);
      }
      else break;
    }
    case VK: {
      if (e->u.s.info <= MAXINDEXRK)  /* constant fit in argC? */
        return RKASK(e->u.s.info);
      else break;
    }
    default: break;
  }
  /* not a constant in the right range: put it in a register */
  return luaK_exp2anyreg(fs, e);
}

References boolK(), expdesc::info, expdesc::k, luaK_exp2anyreg(), luaK_exp2val(), luaK_numberK(), MAXINDEXRK, nilK(), FuncState::nk, expdesc::nval, RKASK, expdesc::s, expdesc::u, VFALSE, VK, VKNUM, VNIL, and VTRUE.

Referenced by codearith(), codecomp(), luaK_indexed(), luaK_infix(), luaK_self(), luaK_storevar(), recfield(), recfield(), and recfield().

◆ luaK_exp2val()

void luaK_exp2val	(	FuncState *	fs,
		expdesc *	e )

Definition at line 436 of file lua-5.1.5/src/lcode.c.

                                              {
  if (hasjumps(e))
    luaK_exp2anyreg(fs, e);
  else
    luaK_dischargevars(fs, e);
}

References hasjumps, luaK_dischargevars(), and luaK_exp2anyreg().

Referenced by luaK_exp2RK(), luaK_posfix(), yindex(), yindex(), yindex(), and yindex().

◆ luaK_fixline()

void luaK_fixline	(	FuncState *	fs,
		int	line )

Definition at line 784 of file lua-5.1.5/src/lcode.c.

                                            {
  fs->f->lineinfo[fs->pc - 1] = line;
}

References FuncState::f, Proto::lineinfo, and FuncState::pc.

Referenced by forbody(), forbody(), forbody(), forbody(), funcargs(), funcargs(), funcargs(), funcargs(), funcstat(), funcstat(), funcstat(), and funcstat().

◆ luaK_getlabel()

int luaK_getlabel ( FuncState * fs )

Definition at line 94 of file lua-5.1.5/src/lcode.c.

                                  {
  fs->lasttarget = fs->pc;
  return fs->pc;
}

References FuncState::lasttarget, and FuncState::pc.

Referenced by code_label(), createlabel(), exp2reg(), forbody(), labelstat(), luaK_patchtohere(), repeatstat(), repeatstat(), repeatstat(), repeatstat(), whilestat(), whilestat(), whilestat(), and whilestat().

◆ luaK_goiffalse()

static void luaK_goiffalse	(	FuncState *	fs,
		expdesc *	e )

static

Definition at line 563 of file lua-5.1.5/src/lcode.c.

                                                       {
  int pc;  /* pc of last jump */
  luaK_dischargevars(fs, e);
  switch (e->k) {
    case VNIL: case VFALSE: {
      pc = NO_JUMP;  /* always false; do nothing */
      break;
    }
    case VJMP: {
      pc = e->u.s.info;
      break;
    }
    default: {
      pc = jumponcond(fs, e, 1);
      break;
    }
  }
  luaK_concat(fs, &e->t, pc);  /* insert last jump in `t' list */
  luaK_patchtohere(fs, e->f);
  e->f = NO_JUMP;
}

References expdesc::f, expdesc::info, jumponcond(), expdesc::k, luaK_concat(), luaK_dischargevars(), luaK_patchtohere(), NO_JUMP, expdesc::s, expdesc::t, expdesc::u, VFALSE, VJMP, and VNIL.

Referenced by luaK_infix(), test_then_block(), test_then_block(), and test_then_block().

◆ luaK_goiftrue()

void luaK_goiftrue	(	FuncState *	fs,
		expdesc *	e )

Definition at line 539 of file lua-5.1.5/src/lcode.c.

                                               {
  int pc;  /* pc of last jump */
  luaK_dischargevars(fs, e);
  switch (e->k) {
    case VK: case VKNUM: case VTRUE: {
      pc = NO_JUMP;  /* always true; do nothing */
      break;
    }
    case VJMP: {
      invertjump(fs, e);
      pc = e->u.s.info;
      break;
    }
    default: {
      pc = jumponcond(fs, e, 0);
      break;
    }
  }
  luaK_concat(fs, &e->f, pc);  /* insert last jump in `f' list */
  luaK_patchtohere(fs, e->t);
  e->t = NO_JUMP;
}

References expdesc::f, expdesc::info, invertjump(), jumponcond(), expdesc::k, luaK_concat(), luaK_dischargevars(), luaK_patchtohere(), NO_JUMP, expdesc::s, expdesc::t, expdesc::u, VJMP, VK, VKNUM, and VTRUE.

Referenced by cond(), cond(), cond(), cond(), luaK_infix(), test_then_block(), test_then_block(), and test_then_block().

◆ luaK_indexed()

void luaK_indexed	(	FuncState *	fs,
		expdesc *	t,
		expdesc *	k )

Definition at line 621 of file lua-5.1.5/src/lcode.c.

                                                          {
  t->u.s.aux = luaK_exp2RK(fs, k);
  t->k = VINDEXED;
}

References expdesc::aux, expdesc::k, luaK_exp2RK(), expdesc::s, expdesc::u, and VINDEXED.

Referenced by field(), fieldsel(), fieldsel(), fieldsel(), primaryexp(), recfield(), singlevar(), singlevar(), singlevar(), suffixedexp(), suffixedexp(), and suffixedexp().

◆ luaK_infix()

void luaK_infix	(	FuncState *	fs,
		BinOpr	op,
		expdesc *	v )

Definition at line 710 of file lua-5.1.5/src/lcode.c.

                                                       {
  switch (op) {
    case OPR_AND: {
      luaK_goiftrue(fs, v);
      break;
    }
    case OPR_OR: {
      luaK_goiffalse(fs, v);
      break;
    }
    case OPR_CONCAT: {
      luaK_exp2nextreg(fs, v);  /* operand must be on the `stack' */
      break;
    }
    case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV:
    case OPR_MOD: case OPR_POW: {
      if (!isnumeral(v)) luaK_exp2RK(fs, v);
      break;
    }
    default: {
      luaK_exp2RK(fs, v);
      break;
    }
  }
}

References isnumeral(), luaK_exp2nextreg(), luaK_exp2RK(), luaK_goiffalse(), luaK_goiftrue(), OPR_ADD, OPR_AND, OPR_CONCAT, OPR_DIV, OPR_MOD, OPR_MUL, OPR_OR, OPR_POW, and OPR_SUB.

Referenced by subexpr(), subexpr(), subexpr(), and subexpr().

◆ luaK_jump()

int luaK_jump ( FuncState * fs )

Definition at line 59 of file lua-5.1.5/src/lcode.c.

                              {
  int jpc = fs->jpc;  /* save list of jumps to here */
  int j;
  fs->jpc = NO_JUMP;
  j = luaK_codeAsBx(fs, OP_JMP, 0, NO_JUMP);
  luaK_concat(fs, &j, jpc);  /* keep them on hold */
  return j;
}

References FuncState::jpc, luaK_codeAsBx, luaK_concat(), NO_JUMP, and OP_JMP.

Referenced by breakstat(), breakstat(), condjump(), exp2reg(), forbody(), forbody(), forbody(), gotostat(), ifstat(), leaveblock(), leaveblock(), repeatstat(), repeatstat(), statement(), statement(), test_then_block(), test_then_block(), test_then_block(), and whilestat().

◆ luaK_nil()

void luaK_nil	(	FuncState *	fs,
		int	from,
		int	n )

Definition at line 35 of file lua-5.1.5/src/lcode.c.

                                               {
  Instruction *previous;
  if (fs->pc > fs->lasttarget) {  /* no jumps to current position? */
    if (fs->pc == 0) {  /* function start? */
      if (from >= fs->nactvar)
        return;  /* positions are already clean */
    }
    else {
      previous = &fs->f->code[fs->pc-1];
      if (GET_OPCODE(*previous) == OP_LOADNIL) {
        int pfrom = GETARG_A(*previous);
        int pto = GETARG_B(*previous);
        if (pfrom <= from && from <= pto+1) {  /* can connect both? */
          if (from+n-1 > pto)
            SETARG_B(*previous, from+n-1);
          return;
        }
      }
    }
  }
  luaK_codeABC(fs, OP_LOADNIL, from, from+n-1, 0);  /* else no optimization */
}

References Proto::code, FuncState::f, GET_OPCODE, GETARG_A, GETARG_B, FuncState::lasttarget, luaK_codeABC, FuncState::nactvar, OP_LOADNIL, FuncState::pc, and SETARG_B.

Referenced by adjust_assign(), adjust_assign(), adjust_assign(), adjust_assign(), and discharge2reg().

◆ luaK_numberK()

int luaK_numberK	(	FuncState *	fs,
		lua_Number	r )

Definition at line 257 of file lua-5.1.5/src/lcode.c.

                                               {
  TValue o;
  setnvalue(&o, r);
  return addk(fs, &o, &o);
}

References addk(), and setnvalue.

Referenced by discharge2reg(), fornum(), fornum(), and luaK_exp2RK().

◆ luaK_patchlist()

void luaK_patchlist	(	FuncState *	fs,
		int	list,
		int	target )

Definition at line 169 of file lua-5.1.5/src/lcode.c.

                                                          {
  if (target == fs->pc)
    luaK_patchtohere(fs, list);
  else {
    lua_assert(target < fs->pc);
    patchlistaux(fs, list, target, NO_REG, target);
  }
}

References lua_assert, luaK_patchtohere(), NO_REG, patchlistaux(), and FuncState::pc.

Referenced by closegoto(), closegoto(), forbody(), forbody(), forbody(), gotostat(), repeatstat(), repeatstat(), repeatstat(), repeatstat(), solvegoto(), and whilestat().

◆ luaK_patchtohere()

void luaK_patchtohere	(	FuncState *	fs,
		int	list )

Definition at line 179 of file lua-5.1.5/src/lcode.c.

                                                {
  luaK_getlabel(fs);
  luaK_concat(fs, &fs->jpc, list);
}

References FuncState::jpc, luaK_concat(), and luaK_getlabel().

Referenced by exp2reg(), forbody(), forbody(), forbody(), ifstat(), ifstat(), ifstat(), ifstat(), leaveblock(), leaveblock(), leaveblock(), luaK_goiffalse(), luaK_goiftrue(), luaK_patchlist(), repeatstat(), repeatstat(), test_then_block(), test_then_block(), test_then_block(), whilestat(), whilestat(), whilestat(), and whilestat().

◆ luaK_posfix()

void luaK_posfix	(	FuncState *	fs,
		BinOpr	op,
		expdesc *	e1,
		expdesc *	e2 )

Definition at line 737 of file lua-5.1.5/src/lcode.c.

                                                                      {
  switch (op) {
    case OPR_AND: {
      lua_assert(e1->t == NO_JUMP);  /* list must be closed */
      luaK_dischargevars(fs, e2);
      luaK_concat(fs, &e2->f, e1->f);
      *e1 = *e2;
      break;
    }
    case OPR_OR: {
      lua_assert(e1->f == NO_JUMP);  /* list must be closed */
      luaK_dischargevars(fs, e2);
      luaK_concat(fs, &e2->t, e1->t);
      *e1 = *e2;
      break;
    }
    case OPR_CONCAT: {
      luaK_exp2val(fs, e2);
      if (e2->k == VRELOCABLE && GET_OPCODE(getcode(fs, e2)) == OP_CONCAT) {
        lua_assert(e1->u.s.info == GETARG_B(getcode(fs, e2))-1);
        freeexp(fs, e1);
        SETARG_B(getcode(fs, e2), e1->u.s.info);
        e1->k = VRELOCABLE; e1->u.s.info = e2->u.s.info;
      }
      else {
        luaK_exp2nextreg(fs, e2);  /* operand must be on the 'stack' */
        codearith(fs, OP_CONCAT, e1, e2);
      }
      break;
    }
    case OPR_ADD: codearith(fs, OP_ADD, e1, e2); break;
    case OPR_SUB: codearith(fs, OP_SUB, e1, e2); break;
    case OPR_MUL: codearith(fs, OP_MUL, e1, e2); break;
    case OPR_DIV: codearith(fs, OP_DIV, e1, e2); break;
    case OPR_MOD: codearith(fs, OP_MOD, e1, e2); break;
    case OPR_POW: codearith(fs, OP_POW, e1, e2); break;
    case OPR_EQ: codecomp(fs, OP_EQ, 1, e1, e2); break;
    case OPR_NE: codecomp(fs, OP_EQ, 0, e1, e2); break;
    case OPR_LT: codecomp(fs, OP_LT, 1, e1, e2); break;
    case OPR_LE: codecomp(fs, OP_LE, 1, e1, e2); break;
    case OPR_GT: codecomp(fs, OP_LT, 0, e1, e2); break;
    case OPR_GE: codecomp(fs, OP_LE, 0, e1, e2); break;
    default: lua_assert(0);
  }
}

References codearith(), codecomp(), expdesc::f, freeexp(), GET_OPCODE, GETARG_B, getcode, expdesc::info, expdesc::k, lua_assert, luaK_concat(), luaK_dischargevars(), luaK_exp2nextreg(), luaK_exp2val(), NO_JUMP, OP_ADD, OP_CONCAT, OP_DIV, OP_EQ, OP_LE, OP_LT, OP_MOD, OP_MUL, OP_POW, OP_SUB, OPR_ADD, OPR_AND, OPR_CONCAT, OPR_DIV, OPR_EQ, OPR_GE, OPR_GT, OPR_LE, OPR_LT, OPR_MOD, OPR_MUL, OPR_NE, OPR_OR, OPR_POW, OPR_SUB, expdesc::s, SETARG_B, expdesc::t, expdesc::u, and VRELOCABLE.

Referenced by subexpr(), subexpr(), subexpr(), and subexpr().

◆ luaK_prefix()

void luaK_prefix	(	FuncState *	fs,
		UnOpr	op,
		expdesc *	e )

Definition at line 689 of file lua-5.1.5/src/lcode.c.

                                                       {
  expdesc e2;
  e2.t = e2.f = NO_JUMP; e2.k = VKNUM; e2.u.nval = 0;
  switch (op) {
    case OPR_MINUS: {
      if (!isnumeral(e))
        luaK_exp2anyreg(fs, e);  /* cannot operate on non-numeric constants */
      codearith(fs, OP_UNM, e, &e2);
      break;
    }
    case OPR_NOT: codenot(fs, e); break;
    case OPR_LEN: {
      luaK_exp2anyreg(fs, e);  /* cannot operate on constants */
      codearith(fs, OP_LEN, e, &e2);
      break;
    }
    default: lua_assert(0);
  }
}

References codearith(), codenot(), expdesc::f, isnumeral(), expdesc::k, lua_assert, luaK_exp2anyreg(), NO_JUMP, expdesc::nval, OP_LEN, OP_UNM, OPR_LEN, OPR_MINUS, OPR_NOT, expdesc::t, expdesc::u, and VKNUM.

Referenced by subexpr(), subexpr(), subexpr(), and subexpr().

◆ luaK_reserveregs()

void luaK_reserveregs	(	FuncState *	fs,
		int	n )

Definition at line 209 of file lua-5.1.5/src/lcode.c.

                                             {
  luaK_checkstack(fs, n);
  fs->freereg += n;
}

References FuncState::freereg, and luaK_checkstack().

Referenced by adjust_assign(), adjust_assign(), adjust_assign(), adjust_assign(), check_conflict(), check_conflict(), check_conflict(), check_conflict(), constructor(), discharge2anyreg(), forbody(), forbody(), forbody(), forbody(), fornum(), fornum(), fornum(), fornum(), localfunc(), luaK_exp2nextreg(), luaK_self(), luaK_setreturns(), parlist(), parlist(), parlist(), and parlist().

◆ luaK_ret()

void luaK_ret	(	FuncState *	fs,
		int	first,
		int	nret )

Definition at line 69 of file lua-5.1.5/src/lcode.c.

                                                   {
  luaK_codeABC(fs, OP_RETURN, first, nret+1, 0);
}

References luaK_codeABC, and OP_RETURN.

Referenced by close_func(), close_func(), close_func(), close_func(), retstat(), retstat(), retstat(), and retstat().

◆ luaK_self()

void luaK_self	(	FuncState *	fs,
		expdesc *	e,
		expdesc *	key )

Definition at line 503 of file lua-5.1.5/src/lcode.c.

                                                         {
  int func;
  luaK_exp2anyreg(fs, e);
  freeexp(fs, e);
  func = fs->freereg;
  luaK_reserveregs(fs, 2);
  luaK_codeABC(fs, OP_SELF, func, e->u.s.info, luaK_exp2RK(fs, key));
  freeexp(fs, key);
  e->u.s.info = func;
  e->k = VNONRELOC;
}

References freeexp(), FuncState::freereg, expdesc::info, expdesc::k, luaK_codeABC, luaK_exp2anyreg(), luaK_exp2RK(), luaK_reserveregs(), OP_SELF, expdesc::s, expdesc::u, and VNONRELOC.

Referenced by primaryexp(), suffixedexp(), suffixedexp(), and suffixedexp().

◆ luaK_setlist()

void luaK_setlist	(	FuncState *	fs,
		int	base,
		int	nelems,
		int	tostore )

Definition at line 819 of file lua-5.1.5/src/lcode.c.

                                                                     {
  int c =  (nelems - 1)/LFIELDS_PER_FLUSH + 1;
  int b = (tostore == LUA_MULTRET) ? 0 : tostore;
  lua_assert(tostore != 0);
  if (c <= MAXARG_C)
    luaK_codeABC(fs, OP_SETLIST, base, b, c);
  else {
    luaK_codeABC(fs, OP_SETLIST, base, b, 0);
    luaK_code(fs, cast(Instruction, c), fs->ls->lastline);
  }
  fs->freereg = base + 1;  /* free registers with list values */
}

References cast, FuncState::freereg, LexState::lastline, LFIELDS_PER_FLUSH, FuncState::ls, lua_assert, LUA_MULTRET, luaK_code(), luaK_codeABC, MAXARG_C, and OP_SETLIST.

Referenced by closelistfield(), closelistfield(), closelistfield(), closelistfield(), lastlistfield(), lastlistfield(), lastlistfield(), and lastlistfield().

◆ luaK_setoneret()

void luaK_setoneret	(	FuncState *	fs,
		expdesc *	e )

Definition at line 292 of file lua-5.1.5/src/lcode.c.

                                                {
  if (e->k == VCALL) {  /* expression is an open function call? */
    e->k = VNONRELOC;
    e->u.s.info = GETARG_A(getcode(fs, e));
  }
  else if (e->k == VVARARG) {
    SETARG_B(getcode(fs, e), 2);
    e->k = VRELOCABLE;  /* can relocate its simple result */
  }
}

References GETARG_A, getcode, expdesc::info, expdesc::k, expdesc::s, SETARG_B, expdesc::u, VCALL, VNONRELOC, VRELOCABLE, and VVARARG.

Referenced by assignment(), assignment(), assignment(), luaK_dischargevars(), and restassign().

◆ luaK_setreturns()

void luaK_setreturns	(	FuncState *	fs,
		expdesc *	e,
		int	nresults )

Definition at line 280 of file lua-5.1.5/src/lcode.c.

                                                               {
  if (e->k == VCALL) {  /* expression is an open function call? */
    SETARG_C(getcode(fs, e), nresults+1);
  }
  else if (e->k == VVARARG) {
    SETARG_B(getcode(fs, e), nresults+1);
    SETARG_A(getcode(fs, e), fs->freereg);
    luaK_reserveregs(fs, 1);
  }
}

References FuncState::freereg, getcode, expdesc::k, luaK_reserveregs(), SETARG_A, SETARG_B, SETARG_C, VCALL, and VVARARG.

Referenced by adjust_assign(), adjust_assign(), adjust_assign(), and adjust_assign().

◆ luaK_storevar()

void luaK_storevar	(	FuncState *	fs,
		expdesc *	var,
		expdesc *	ex )

Definition at line 472 of file lua-5.1.5/src/lcode.c.

                                                              {
  switch (var->k) {
    case VLOCAL: {
      freeexp(fs, ex);
      exp2reg(fs, ex, var->u.s.info);
      return;
    }
    case VUPVAL: {
      int e = luaK_exp2anyreg(fs, ex);
      luaK_codeABC(fs, OP_SETUPVAL, e, var->u.s.info, 0);
      break;
    }
    case VGLOBAL: {
      int e = luaK_exp2anyreg(fs, ex);
      luaK_codeABx(fs, OP_SETGLOBAL, e, var->u.s.info);
      break;
    }
    case VINDEXED: {
      int e = luaK_exp2RK(fs, ex);
      luaK_codeABC(fs, OP_SETTABLE, var->u.s.info, var->u.s.aux, e);
      break;
    }
    default: {
      lua_assert(0);  /* invalid var kind to store */
      break;
    }
  }
  freeexp(fs, ex);
}

References expdesc::aux, exp2reg(), freeexp(), expdesc::info, expdesc::k, lua_assert, luaK_codeABC, luaK_codeABx(), luaK_exp2anyreg(), luaK_exp2RK(), OP_SETGLOBAL, OP_SETTABLE, OP_SETUPVAL, expdesc::s, expdesc::u, VGLOBAL, VINDEXED, VLOCAL, and VUPVAL.

Referenced by assignment(), assignment(), assignment(), funcstat(), funcstat(), funcstat(), funcstat(), localfunc(), recfield(), and restassign().

◆ luaK_stringK()

int luaK_stringK	(	FuncState *	fs,
		TString *	s )

Definition at line 250 of file lua-5.1.5/src/lcode.c.

                                             {
  TValue o;
  setsvalue(fs->L, &o, s);
  return addk(fs, &o, &o);
}

References addk(), FuncState::L, s, and setsvalue.

Referenced by codestring(), codestring(), codestring(), and singlevar().

◆ need_value()

static int need_value	(	FuncState *	fs,
		int	list )

static

Definition at line 122 of file lua-5.1.5/src/lcode.c.

                                                {
  for (; list != NO_JUMP; list = getjump(fs, list)) {
    Instruction i = *getjumpcontrol(fs, list);
    if (GET_OPCODE(i) != OP_TESTSET) return 1;
  }
  return 0;  /* not found */
}

References GET_OPCODE, getjump(), getjumpcontrol(), NO_JUMP, and OP_TESTSET.

Referenced by exp2reg().

◆ nilK()

static int nilK ( FuncState * fs )

static

Definition at line 271 of file lua-5.1.5/src/lcode.c.

                                {
  TValue k, v;
  setnilvalue(&v);
  /* cannot use nil as key; instead use table itself to represent nil */
  sethvalue(fs->L, &k, fs->h);
  return addk(fs, &k, &v);
}

References addk(), FuncState::h, FuncState::L, sethvalue, and setnilvalue.

Referenced by luaK_exp2RK().

◆ patchlistaux()

static void patchlistaux	(	FuncState *	fs,
		int	list,
		int	vtarget,
		int	reg,
		int	dtarget )

static

Definition at line 150 of file lua-5.1.5/src/lcode.c.

                                       {
  while (list != NO_JUMP) {
    int next = getjump(fs, list);
    if (patchtestreg(fs, list, reg))
      fixjump(fs, list, vtarget);
    else
      fixjump(fs, list, dtarget);  /* jump to default target */
    list = next;
  }
}

References fixjump(), getjump(), next, NO_JUMP, and patchtestreg().

Referenced by dischargejpc(), exp2reg(), and luaK_patchlist().

◆ patchtestreg()

static int patchtestreg	(	FuncState *	fs,
		int	node,
		int	reg )

static

Definition at line 131 of file lua-5.1.5/src/lcode.c.

                                                           {
  Instruction *i = getjumpcontrol(fs, node);
  if (GET_OPCODE(*i) != OP_TESTSET)
    return 0;  /* cannot patch other instructions */
  if (reg != NO_REG && reg != GETARG_B(*i))
    SETARG_A(*i, reg);
  else  /* no register to put value or register already has the value */
    *i = CREATE_ABC(OP_TEST, GETARG_B(*i), 0, GETARG_C(*i));
 
  return 1;
}

References CREATE_ABC, GET_OPCODE, GETARG_B, GETARG_C, getjumpcontrol(), NO_REG, OP_TEST, OP_TESTSET, and SETARG_A.

Referenced by patchlistaux(), and removevalues().

◆ removevalues()

static void removevalues	(	FuncState *	fs,
		int	list )

static

Definition at line 144 of file lua-5.1.5/src/lcode.c.

                                                   {
  for (; list != NO_JUMP; list = getjump(fs, list))
      patchtestreg(fs, list, NO_REG);
}

References getjump(), NO_JUMP, NO_REG, and patchtestreg().

Referenced by codenot().

Macros

Functions

Macro Definition Documentation

◆ hasjumps

◆ lcode_c

◆ LUA_CORE

Function Documentation

◆ addk()

◆ boolK()

◆ code_label()

◆ codearith()

◆ codecomp()

◆ codenot()

◆ condjump()

◆ constfolding()

◆ discharge2anyreg()

◆ discharge2reg()

◆ dischargejpc()

◆ exp2reg()

◆ fixjump()

◆ freeexp()

◆ freereg()

◆ getjump()

◆ getjumpcontrol()

◆ invertjump()

◆ isnumeral()

◆ jumponcond()

◆ luaK_checkstack()

◆ luaK_code()

◆ luaK_codeABC()

◆ luaK_codeABx()

◆ luaK_concat()

◆ luaK_dischargevars()

◆ luaK_exp2anyreg()

◆ luaK_exp2nextreg()

◆ luaK_exp2RK()

◆ luaK_exp2val()

◆ luaK_fixline()

◆ luaK_getlabel()

◆ luaK_goiffalse()

◆ luaK_goiftrue()

◆ luaK_indexed()

◆ luaK_infix()

◆ luaK_jump()

◆ luaK_nil()

◆ luaK_numberK()

◆ luaK_patchlist()

◆ luaK_patchtohere()

◆ luaK_posfix()

◆ luaK_prefix()

◆ luaK_reserveregs()

◆ luaK_ret()

◆ luaK_self()

◆ luaK_setlist()

◆ luaK_setoneret()

◆ luaK_setreturns()

◆ luaK_storevar()

◆ luaK_stringK()

◆ need_value()

◆ nilK()

◆ patchlistaux()

◆ patchtestreg()

◆ removevalues()