]>
git.zerfleddert.de Git - proxmark3-svn/blob - liblua/lcode.c
2 ** $Id: lcode.c,v 2.62 2012/08/16 17:34:28 roberto Exp $
3 ** Code generator for Lua
4 ** See Copyright Notice in lua.h
29 #define hasjumps(e) ((e)->t != (e)->f)
32 static int isnumeral(expdesc
*e
) {
33 return (e
->k
== VKNUM
&& e
->t
== NO_JUMP
&& e
->f
== NO_JUMP
);
37 void luaK_nil (FuncState
*fs
, int from
, int n
) {
38 Instruction
*previous
;
39 int l
= from
+ n
- 1; /* last register to set nil */
40 if (fs
->pc
> fs
->lasttarget
) { /* no jumps to current position? */
41 previous
= &fs
->f
->code
[fs
->pc
-1];
42 if (GET_OPCODE(*previous
) == OP_LOADNIL
) {
43 int pfrom
= GETARG_A(*previous
);
44 int pl
= pfrom
+ GETARG_B(*previous
);
45 if ((pfrom
<= from
&& from
<= pl
+ 1) ||
46 (from
<= pfrom
&& pfrom
<= l
+ 1)) { /* can connect both? */
47 if (pfrom
< from
) from
= pfrom
; /* from = min(from, pfrom) */
48 if (pl
> l
) l
= pl
; /* l = max(l, pl) */
49 SETARG_A(*previous
, from
);
50 SETARG_B(*previous
, l
- from
);
53 } /* else go through */
55 luaK_codeABC(fs
, OP_LOADNIL
, from
, n
- 1, 0); /* else no optimization */
59 int luaK_jump (FuncState
*fs
) {
60 int jpc
= fs
->jpc
; /* save list of jumps to here */
63 j
= luaK_codeAsBx(fs
, OP_JMP
, 0, NO_JUMP
);
64 luaK_concat(fs
, &j
, jpc
); /* keep them on hold */
69 void luaK_ret (FuncState
*fs
, int first
, int nret
) {
70 luaK_codeABC(fs
, OP_RETURN
, first
, nret
+1, 0);
74 static int condjump (FuncState
*fs
, OpCode op
, int A
, int B
, int C
) {
75 luaK_codeABC(fs
, op
, A
, B
, C
);
80 static void fixjump (FuncState
*fs
, int pc
, int dest
) {
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
);
91 ** returns current `pc' and marks it as a jump target (to avoid wrong
92 ** optimizations with consecutive instructions not in the same basic block).
94 int luaK_getlabel (FuncState
*fs
) {
95 fs
->lasttarget
= fs
->pc
;
100 static int getjump (FuncState
*fs
, int pc
) {
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 */
105 return (pc
+1)+offset
; /* turn offset into absolute position */
109 static Instruction
*getjumpcontrol (FuncState
*fs
, int pc
) {
110 Instruction
*pi
= &fs
->f
->code
[pc
];
111 if (pc
>= 1 && testTMode(GET_OPCODE(*(pi
-1))))
119 ** check whether list has any jump that do not produce a value
120 ** (or produce an inverted value)
122 static int need_value (FuncState
*fs
, int list
) {
123 for (; list
!= NO_JUMP
; list
= getjump(fs
, list
)) {
124 Instruction i
= *getjumpcontrol(fs
, list
);
125 if (GET_OPCODE(i
) != OP_TESTSET
) return 1;
127 return 0; /* not found */
131 static int patchtestreg (FuncState
*fs
, int node
, int reg
) {
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
))
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
));
144 static void removevalues (FuncState
*fs
, int list
) {
145 for (; list
!= NO_JUMP
; list
= getjump(fs
, list
))
146 patchtestreg(fs
, list
, NO_REG
);
150 static void patchlistaux (FuncState
*fs
, int list
, int vtarget
, int reg
,
152 while (list
!= NO_JUMP
) {
153 int next
= getjump(fs
, list
);
154 if (patchtestreg(fs
, list
, reg
))
155 fixjump(fs
, list
, vtarget
);
157 fixjump(fs
, list
, dtarget
); /* jump to default target */
163 static void dischargejpc (FuncState
*fs
) {
164 patchlistaux(fs
, fs
->jpc
, fs
->pc
, NO_REG
, fs
->pc
);
169 void luaK_patchlist (FuncState
*fs
, int list
, int target
) {
170 if (target
== fs
->pc
)
171 luaK_patchtohere(fs
, list
);
173 lua_assert(target
< fs
->pc
);
174 patchlistaux(fs
, list
, target
, NO_REG
, target
);
179 LUAI_FUNC
void luaK_patchclose (FuncState
*fs
, int list
, int level
) {
180 level
++; /* argument is +1 to reserve 0 as non-op */
181 while (list
!= NO_JUMP
) {
182 int next
= getjump(fs
, list
);
183 lua_assert(GET_OPCODE(fs
->f
->code
[list
]) == OP_JMP
&&
184 (GETARG_A(fs
->f
->code
[list
]) == 0 ||
185 GETARG_A(fs
->f
->code
[list
]) >= level
));
186 SETARG_A(fs
->f
->code
[list
], level
);
192 void luaK_patchtohere (FuncState
*fs
, int list
) {
194 luaK_concat(fs
, &fs
->jpc
, list
);
198 void luaK_concat (FuncState
*fs
, int *l1
, int l2
) {
199 if (l2
== NO_JUMP
) return;
200 else if (*l1
== NO_JUMP
)
205 while ((next
= getjump(fs
, list
)) != NO_JUMP
) /* find last element */
207 fixjump(fs
, list
, l2
);
212 static int luaK_code (FuncState
*fs
, Instruction i
) {
214 dischargejpc(fs
); /* `pc' will change */
215 /* put new instruction in code array */
216 luaM_growvector(fs
->ls
->L
, f
->code
, fs
->pc
, f
->sizecode
, Instruction
,
219 /* save corresponding line information */
220 luaM_growvector(fs
->ls
->L
, f
->lineinfo
, fs
->pc
, f
->sizelineinfo
, int,
222 f
->lineinfo
[fs
->pc
] = fs
->ls
->lastline
;
227 int luaK_codeABC (FuncState
*fs
, OpCode o
, int a
, int b
, int c
) {
228 lua_assert(getOpMode(o
) == iABC
);
229 lua_assert(getBMode(o
) != OpArgN
|| b
== 0);
230 lua_assert(getCMode(o
) != OpArgN
|| c
== 0);
231 lua_assert(a
<= MAXARG_A
&& b
<= MAXARG_B
&& c
<= MAXARG_C
);
232 return luaK_code(fs
, CREATE_ABC(o
, a
, b
, c
));
236 int luaK_codeABx (FuncState
*fs
, OpCode o
, int a
, unsigned int bc
) {
237 lua_assert(getOpMode(o
) == iABx
|| getOpMode(o
) == iAsBx
);
238 lua_assert(getCMode(o
) == OpArgN
);
239 lua_assert(a
<= MAXARG_A
&& bc
<= MAXARG_Bx
);
240 return luaK_code(fs
, CREATE_ABx(o
, a
, bc
));
244 static int codeextraarg (FuncState
*fs
, int a
) {
245 lua_assert(a
<= MAXARG_Ax
);
246 return luaK_code(fs
, CREATE_Ax(OP_EXTRAARG
, a
));
250 int luaK_codek (FuncState
*fs
, int reg
, int k
) {
252 return luaK_codeABx(fs
, OP_LOADK
, reg
, k
);
254 int p
= luaK_codeABx(fs
, OP_LOADKX
, reg
, 0);
261 void luaK_checkstack (FuncState
*fs
, int n
) {
262 int newstack
= fs
->freereg
+ n
;
263 if (newstack
> fs
->f
->maxstacksize
) {
264 if (newstack
>= MAXSTACK
)
265 luaX_syntaxerror(fs
->ls
, "function or expression too complex");
266 fs
->f
->maxstacksize
= cast_byte(newstack
);
271 void luaK_reserveregs (FuncState
*fs
, int n
) {
272 luaK_checkstack(fs
, n
);
277 static void freereg (FuncState
*fs
, int reg
) {
278 if (!ISK(reg
) && reg
>= fs
->nactvar
) {
280 lua_assert(reg
== fs
->freereg
);
285 static void freeexp (FuncState
*fs
, expdesc
*e
) {
286 if (e
->k
== VNONRELOC
)
287 freereg(fs
, e
->u
.info
);
291 static int addk (FuncState
*fs
, TValue
*key
, TValue
*v
) {
292 lua_State
*L
= fs
->ls
->L
;
293 TValue
*idx
= luaH_set(L
, fs
->h
, key
);
296 if (ttisnumber(idx
)) {
297 lua_Number n
= nvalue(idx
);
298 lua_number2int(k
, n
);
299 if (luaV_rawequalobj(&f
->k
[k
], v
))
301 /* else may be a collision (e.g., between 0.0 and "\0\0\0\0\0\0\0\0");
302 go through and create a new entry for this value */
304 /* constant not found; create a new entry */
307 /* numerical value does not need GC barrier;
308 table has no metatable, so it does not need to invalidate cache */
309 setnvalue(idx
, cast_num(k
));
310 luaM_growvector(L
, f
->k
, k
, f
->sizek
, TValue
, MAXARG_Ax
, "constants");
311 while (oldsize
< f
->sizek
) setnilvalue(&f
->k
[oldsize
++]);
312 setobj(L
, &f
->k
[k
], v
);
314 luaC_barrier(L
, f
, v
);
319 int luaK_stringK (FuncState
*fs
, TString
*s
) {
321 setsvalue(fs
->ls
->L
, &o
, s
);
322 return addk(fs
, &o
, &o
);
326 int luaK_numberK (FuncState
*fs
, lua_Number r
) {
328 lua_State
*L
= fs
->ls
->L
;
331 if (r
== 0 || luai_numisnan(NULL
, r
)) { /* handle -0 and NaN */
332 /* use raw representation as key to avoid numeric problems */
333 setsvalue(L
, L
->top
++, luaS_newlstr(L
, (char *)&r
, sizeof(r
)));
334 n
= addk(fs
, L
->top
- 1, &o
);
338 n
= addk(fs
, &o
, &o
); /* regular case */
343 static int boolK (FuncState
*fs
, int b
) {
346 return addk(fs
, &o
, &o
);
350 static int nilK (FuncState
*fs
) {
353 /* cannot use nil as key; instead use table itself to represent nil */
354 sethvalue(fs
->ls
->L
, &k
, fs
->h
);
355 return addk(fs
, &k
, &v
);
359 void luaK_setreturns (FuncState
*fs
, expdesc
*e
, int nresults
) {
360 if (e
->k
== VCALL
) { /* expression is an open function call? */
361 SETARG_C(getcode(fs
, e
), nresults
+1);
363 else if (e
->k
== VVARARG
) {
364 SETARG_B(getcode(fs
, e
), nresults
+1);
365 SETARG_A(getcode(fs
, e
), fs
->freereg
);
366 luaK_reserveregs(fs
, 1);
371 void luaK_setoneret (FuncState
*fs
, expdesc
*e
) {
372 if (e
->k
== VCALL
) { /* expression is an open function call? */
374 e
->u
.info
= GETARG_A(getcode(fs
, e
));
376 else if (e
->k
== VVARARG
) {
377 SETARG_B(getcode(fs
, e
), 2);
378 e
->k
= VRELOCABLE
; /* can relocate its simple result */
383 void luaK_dischargevars (FuncState
*fs
, expdesc
*e
) {
390 e
->u
.info
= luaK_codeABC(fs
, OP_GETUPVAL
, 0, e
->u
.info
, 0);
395 OpCode op
= OP_GETTABUP
; /* assume 't' is in an upvalue */
396 freereg(fs
, e
->u
.ind
.idx
);
397 if (e
->u
.ind
.vt
== VLOCAL
) { /* 't' is in a register? */
398 freereg(fs
, e
->u
.ind
.t
);
401 e
->u
.info
= luaK_codeABC(fs
, op
, 0, e
->u
.ind
.t
, e
->u
.ind
.idx
);
407 luaK_setoneret(fs
, e
);
410 default: break; /* there is one value available (somewhere) */
415 static int code_label (FuncState
*fs
, int A
, int b
, int jump
) {
416 luaK_getlabel(fs
); /* those instructions may be jump targets */
417 return luaK_codeABC(fs
, OP_LOADBOOL
, A
, b
, jump
);
421 static void discharge2reg (FuncState
*fs
, expdesc
*e
, int reg
) {
422 luaK_dischargevars(fs
, e
);
425 luaK_nil(fs
, reg
, 1);
428 case VFALSE
: case VTRUE
: {
429 luaK_codeABC(fs
, OP_LOADBOOL
, reg
, e
->k
== VTRUE
, 0);
433 luaK_codek(fs
, reg
, e
->u
.info
);
437 luaK_codek(fs
, reg
, luaK_numberK(fs
, e
->u
.nval
));
441 Instruction
*pc
= &getcode(fs
, e
);
446 if (reg
!= e
->u
.info
)
447 luaK_codeABC(fs
, OP_MOVE
, reg
, e
->u
.info
, 0);
451 lua_assert(e
->k
== VVOID
|| e
->k
== VJMP
);
452 return; /* nothing to do... */
460 static void discharge2anyreg (FuncState
*fs
, expdesc
*e
) {
461 if (e
->k
!= VNONRELOC
) {
462 luaK_reserveregs(fs
, 1);
463 discharge2reg(fs
, e
, fs
->freereg
-1);
468 static void exp2reg (FuncState
*fs
, expdesc
*e
, int reg
) {
469 discharge2reg(fs
, e
, reg
);
471 luaK_concat(fs
, &e
->t
, e
->u
.info
); /* put this jump in `t' list */
473 int final
; /* position after whole expression */
474 int p_f
= NO_JUMP
; /* position of an eventual LOAD false */
475 int p_t
= NO_JUMP
; /* position of an eventual LOAD true */
476 if (need_value(fs
, e
->t
) || need_value(fs
, e
->f
)) {
477 int fj
= (e
->k
== VJMP
) ? NO_JUMP
: luaK_jump(fs
);
478 p_f
= code_label(fs
, reg
, 0, 1);
479 p_t
= code_label(fs
, reg
, 1, 0);
480 luaK_patchtohere(fs
, fj
);
482 final
= luaK_getlabel(fs
);
483 patchlistaux(fs
, e
->f
, final
, reg
, p_f
);
484 patchlistaux(fs
, e
->t
, final
, reg
, p_t
);
486 e
->f
= e
->t
= NO_JUMP
;
492 void luaK_exp2nextreg (FuncState
*fs
, expdesc
*e
) {
493 luaK_dischargevars(fs
, e
);
495 luaK_reserveregs(fs
, 1);
496 exp2reg(fs
, e
, fs
->freereg
- 1);
500 int luaK_exp2anyreg (FuncState
*fs
, expdesc
*e
) {
501 luaK_dischargevars(fs
, e
);
502 if (e
->k
== VNONRELOC
) {
503 if (!hasjumps(e
)) return e
->u
.info
; /* exp is already in a register */
504 if (e
->u
.info
>= fs
->nactvar
) { /* reg. is not a local? */
505 exp2reg(fs
, e
, e
->u
.info
); /* put value on it */
509 luaK_exp2nextreg(fs
, e
); /* default */
514 void luaK_exp2anyregup (FuncState
*fs
, expdesc
*e
) {
515 if (e
->k
!= VUPVAL
|| hasjumps(e
))
516 luaK_exp2anyreg(fs
, e
);
520 void luaK_exp2val (FuncState
*fs
, expdesc
*e
) {
522 luaK_exp2anyreg(fs
, e
);
524 luaK_dischargevars(fs
, e
);
528 int luaK_exp2RK (FuncState
*fs
, expdesc
*e
) {
534 if (fs
->nk
<= MAXINDEXRK
) { /* constant fits in RK operand? */
535 e
->u
.info
= (e
->k
== VNIL
) ? nilK(fs
) : boolK(fs
, (e
->k
== VTRUE
));
537 return RKASK(e
->u
.info
);
542 e
->u
.info
= luaK_numberK(fs
, e
->u
.nval
);
547 if (e
->u
.info
<= MAXINDEXRK
) /* constant fits in argC? */
548 return RKASK(e
->u
.info
);
553 /* not a constant in the right range: put it in a register */
554 return luaK_exp2anyreg(fs
, e
);
558 void luaK_storevar (FuncState
*fs
, expdesc
*var
, expdesc
*ex
) {
562 exp2reg(fs
, ex
, var
->u
.info
);
566 int e
= luaK_exp2anyreg(fs
, ex
);
567 luaK_codeABC(fs
, OP_SETUPVAL
, e
, var
->u
.info
, 0);
571 OpCode op
= (var
->u
.ind
.vt
== VLOCAL
) ? OP_SETTABLE
: OP_SETTABUP
;
572 int e
= luaK_exp2RK(fs
, ex
);
573 luaK_codeABC(fs
, op
, var
->u
.ind
.t
, var
->u
.ind
.idx
, e
);
577 lua_assert(0); /* invalid var kind to store */
585 void luaK_self (FuncState
*fs
, expdesc
*e
, expdesc
*key
) {
587 luaK_exp2anyreg(fs
, e
);
588 ereg
= e
->u
.info
; /* register where 'e' was placed */
590 e
->u
.info
= fs
->freereg
; /* base register for op_self */
592 luaK_reserveregs(fs
, 2); /* function and 'self' produced by op_self */
593 luaK_codeABC(fs
, OP_SELF
, e
->u
.info
, ereg
, luaK_exp2RK(fs
, key
));
598 static void invertjump (FuncState
*fs
, expdesc
*e
) {
599 Instruction
*pc
= getjumpcontrol(fs
, e
->u
.info
);
600 lua_assert(testTMode(GET_OPCODE(*pc
)) && GET_OPCODE(*pc
) != OP_TESTSET
&&
601 GET_OPCODE(*pc
) != OP_TEST
);
602 SETARG_A(*pc
, !(GETARG_A(*pc
)));
606 static int jumponcond (FuncState
*fs
, expdesc
*e
, int cond
) {
607 if (e
->k
== VRELOCABLE
) {
608 Instruction ie
= getcode(fs
, e
);
609 if (GET_OPCODE(ie
) == OP_NOT
) {
610 fs
->pc
--; /* remove previous OP_NOT */
611 return condjump(fs
, OP_TEST
, GETARG_B(ie
), 0, !cond
);
613 /* else go through */
615 discharge2anyreg(fs
, e
);
617 return condjump(fs
, OP_TESTSET
, NO_REG
, e
->u
.info
, cond
);
621 void luaK_goiftrue (FuncState
*fs
, expdesc
*e
) {
622 int pc
; /* pc of last jump */
623 luaK_dischargevars(fs
, e
);
630 case VK
: case VKNUM
: case VTRUE
: {
631 pc
= NO_JUMP
; /* always true; do nothing */
635 pc
= jumponcond(fs
, e
, 0);
639 luaK_concat(fs
, &e
->f
, pc
); /* insert last jump in `f' list */
640 luaK_patchtohere(fs
, e
->t
);
645 void luaK_goiffalse (FuncState
*fs
, expdesc
*e
) {
646 int pc
; /* pc of last jump */
647 luaK_dischargevars(fs
, e
);
653 case VNIL
: case VFALSE
: {
654 pc
= NO_JUMP
; /* always false; do nothing */
658 pc
= jumponcond(fs
, e
, 1);
662 luaK_concat(fs
, &e
->t
, pc
); /* insert last jump in `t' list */
663 luaK_patchtohere(fs
, e
->f
);
668 static void codenot (FuncState
*fs
, expdesc
*e
) {
669 luaK_dischargevars(fs
, e
);
671 case VNIL
: case VFALSE
: {
675 case VK
: case VKNUM
: case VTRUE
: {
685 discharge2anyreg(fs
, e
);
687 e
->u
.info
= luaK_codeABC(fs
, OP_NOT
, 0, e
->u
.info
, 0);
692 lua_assert(0); /* cannot happen */
696 /* interchange true and false lists */
697 { int temp
= e
->f
; e
->f
= e
->t
; e
->t
= temp
; }
698 removevalues(fs
, e
->f
);
699 removevalues(fs
, e
->t
);
703 void luaK_indexed (FuncState
*fs
, expdesc
*t
, expdesc
*k
) {
704 lua_assert(!hasjumps(t
));
705 t
->u
.ind
.t
= t
->u
.info
;
706 t
->u
.ind
.idx
= luaK_exp2RK(fs
, k
);
707 t
->u
.ind
.vt
= (t
->k
== VUPVAL
) ? VUPVAL
708 : check_exp(vkisinreg(t
->k
), VLOCAL
);
713 static int constfolding (OpCode op
, expdesc
*e1
, expdesc
*e2
) {
715 if (!isnumeral(e1
) || !isnumeral(e2
)) return 0;
716 if ((op
== OP_DIV
|| op
== OP_MOD
) && e2
->u
.nval
== 0)
717 return 0; /* do not attempt to divide by 0 */
718 r
= luaO_arith(op
- OP_ADD
+ LUA_OPADD
, e1
->u
.nval
, e2
->u
.nval
);
724 static void codearith (FuncState
*fs
, OpCode op
,
725 expdesc
*e1
, expdesc
*e2
, int line
) {
726 if (constfolding(op
, e1
, e2
))
729 int o2
= (op
!= OP_UNM
&& op
!= OP_LEN
) ? luaK_exp2RK(fs
, e2
) : 0;
730 int o1
= luaK_exp2RK(fs
, e1
);
739 e1
->u
.info
= luaK_codeABC(fs
, op
, 0, o1
, o2
);
741 luaK_fixline(fs
, line
);
746 static void codecomp (FuncState
*fs
, OpCode op
, int cond
, expdesc
*e1
,
748 int o1
= luaK_exp2RK(fs
, e1
);
749 int o2
= luaK_exp2RK(fs
, e2
);
752 if (cond
== 0 && op
!= OP_EQ
) {
753 int temp
; /* exchange args to replace by `<' or `<=' */
754 temp
= o1
; o1
= o2
; o2
= temp
; /* o1 <==> o2 */
757 e1
->u
.info
= condjump(fs
, op
, cond
, o1
, o2
);
762 void luaK_prefix (FuncState
*fs
, UnOpr op
, expdesc
*e
, int line
) {
764 e2
.t
= e2
.f
= NO_JUMP
; e2
.k
= VKNUM
; e2
.u
.nval
= 0;
767 if (isnumeral(e
)) /* minus constant? */
768 e
->u
.nval
= luai_numunm(NULL
, e
->u
.nval
); /* fold it */
770 luaK_exp2anyreg(fs
, e
);
771 codearith(fs
, OP_UNM
, e
, &e2
, line
);
775 case OPR_NOT
: codenot(fs
, e
); break;
777 luaK_exp2anyreg(fs
, e
); /* cannot operate on constants */
778 codearith(fs
, OP_LEN
, e
, &e2
, line
);
781 default: lua_assert(0);
786 void luaK_infix (FuncState
*fs
, BinOpr op
, expdesc
*v
) {
789 luaK_goiftrue(fs
, v
);
793 luaK_goiffalse(fs
, v
);
797 luaK_exp2nextreg(fs
, v
); /* operand must be on the `stack' */
800 case OPR_ADD
: case OPR_SUB
: case OPR_MUL
: case OPR_DIV
:
801 case OPR_MOD
: case OPR_POW
: {
802 if (!isnumeral(v
)) luaK_exp2RK(fs
, v
);
813 void luaK_posfix (FuncState
*fs
, BinOpr op
,
814 expdesc
*e1
, expdesc
*e2
, int line
) {
817 lua_assert(e1
->t
== NO_JUMP
); /* list must be closed */
818 luaK_dischargevars(fs
, e2
);
819 luaK_concat(fs
, &e2
->f
, e1
->f
);
824 lua_assert(e1
->f
== NO_JUMP
); /* list must be closed */
825 luaK_dischargevars(fs
, e2
);
826 luaK_concat(fs
, &e2
->t
, e1
->t
);
831 luaK_exp2val(fs
, e2
);
832 if (e2
->k
== VRELOCABLE
&& GET_OPCODE(getcode(fs
, e2
)) == OP_CONCAT
) {
833 lua_assert(e1
->u
.info
== GETARG_B(getcode(fs
, e2
))-1);
835 SETARG_B(getcode(fs
, e2
), e1
->u
.info
);
836 e1
->k
= VRELOCABLE
; e1
->u
.info
= e2
->u
.info
;
839 luaK_exp2nextreg(fs
, e2
); /* operand must be on the 'stack' */
840 codearith(fs
, OP_CONCAT
, e1
, e2
, line
);
844 case OPR_ADD
: case OPR_SUB
: case OPR_MUL
: case OPR_DIV
:
845 case OPR_MOD
: case OPR_POW
: {
846 codearith(fs
, cast(OpCode
, op
- OPR_ADD
+ OP_ADD
), e1
, e2
, line
);
849 case OPR_EQ
: case OPR_LT
: case OPR_LE
: {
850 codecomp(fs
, cast(OpCode
, op
- OPR_EQ
+ OP_EQ
), 1, e1
, e2
);
853 case OPR_NE
: case OPR_GT
: case OPR_GE
: {
854 codecomp(fs
, cast(OpCode
, op
- OPR_NE
+ OP_EQ
), 0, e1
, e2
);
857 default: lua_assert(0);
862 void luaK_fixline (FuncState
*fs
, int line
) {
863 fs
->f
->lineinfo
[fs
->pc
- 1] = line
;
867 void luaK_setlist (FuncState
*fs
, int base
, int nelems
, int tostore
) {
868 int c
= (nelems
- 1)/LFIELDS_PER_FLUSH
+ 1;
869 int b
= (tostore
== LUA_MULTRET
) ? 0 : tostore
;
870 lua_assert(tostore
!= 0);
872 luaK_codeABC(fs
, OP_SETLIST
, base
, b
, c
);
873 else if (c
<= MAXARG_Ax
) {
874 luaK_codeABC(fs
, OP_SETLIST
, base
, b
, 0);
878 luaX_syntaxerror(fs
->ls
, "constructor too long");
879 fs
->freereg
= base
+ 1; /* free registers with list values */