 @@ -1,14 +1,14 @@
-/*	$NetBSD: lcode.c,v 1.12 2023/04/16 20:46:17 nikita Exp $	*/
+/*	$NetBSD: lcode.c,v 1.13 2023/04/17 19:19:00 nikita Exp $	*/
 /*
 ** Id: lcode.c
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
 #define lcode_c
 #define LUA_CORE
 #include "lprefix.h"
 @@ -1416,27 +1416,30 @@ static void finishbinexpval (FuncState *
   e1->k = VRELOC;  /* all those operations are relocatable */
   luaK_fixline(fs, line);
   luaK_codeABCk(fs, mmop, v1, v2, event, flip);  /* to call metamethod */
   luaK_fixline(fs, line);
+}
 /*
 ** Emit code for binary expressions that "produce values" over
 ** two registers.
 */
 static void codebinexpval (FuncState *fs, OpCode op,
                            expdesc *e1, expdesc *e2, int line) {
-  int v2 = luaK_exp2anyreg(fs, e2);  /* both operands are in registers */
+  int v2 = luaK_exp2anyreg(fs, e2);  /* make sure 'e2' is in a register */
   /* 'e1' must be already in a register or it is a constant */
   lua_assert((VNIL <= e1->k && e1->k <= VKSTR) ||
              e1->k == VNONRELOC || e1->k == VRELOC);
   lua_assert(OP_ADD <= op && op <= OP_SHR);
   finishbinexpval(fs, e1, e2, op, v2, 0, line, OP_MMBIN,
                   cast(TMS, (op - OP_ADD) + TM_ADD));
+}
 /*
 ** Code binary operators with immediate operands.
 */
 static void codebini (FuncState *fs, OpCode op,
                        expdesc *e1, expdesc *e2, int flip, int line,
                        TMS event) {
   int v2 = int2sC(cast_int(e2->u.ival));  /* immediate operand */
 @@ -1503,39 +1506,39 @@ static void codecommutative (FuncState *
   int flip = 0;
   if (tonumeral(e1, NULL)) {  /* is first operand a numeric constant? */
     swapexps(e1, e2);  /* change order */
     flip = 1;
+  }
   if (op == OPR_ADD && isSCint(e2))  /* immediate operand? */
     codebini(fs, cast(OpCode, OP_ADDI), e1, e2, flip, line, TM_ADD);
   else
     codearith(fs, op, e1, e2, flip, line);
+}
 /*
-** Code bitwise operations; they are all associative, so the function
+** Code bitwise operations; they are all commutative, so the function
 ** tries to put an integer constant as the 2nd operand (a K operand).
 */
 static void codebitwise (FuncState *fs, BinOpr opr,
                          expdesc *e1, expdesc *e2, int line) {
   int flip = 0;
   int v2;
   OpCode op;
-  if (e1->k == VKINT && luaK_exp2RK(fs, e1)) {
+  if (e1->k == VKINT && luaK_exp2K(fs, e1)) {
     swapexps(e1, e2);  /* 'e2' will be the constant operand */
     flip = 1;
+  }
-  else if (!(e2->k == VKINT && luaK_exp2RK(fs, e2))) {  /* no constants? */
+  else if (!(e2->k == VKINT && luaK_exp2K(fs, e2))) {  /* no constants? */
     op = cast(OpCode, opr + OP_ADD);
     codebinexpval(fs, op, e1, e2, line);  /* all-register opcodes */
     return;
+  }
   v2 = e2->u.info;  /* index in K array */
   op = cast(OpCode, opr + OP_ADDK);
   lua_assert(ttisinteger(&fs->f->k[v2]));
   finishbinexpval(fs, e1, e2, op, v2, flip, line, OP_MMBINK,
                   cast(TMS, opr + TM_ADD));
+}
 /*
 @@ -1576,27 +1579,27 @@ static void codeeq (FuncState *fs, BinOp
   int r1, r2;
   int im;
   int isfloat = 0;  /* not needed here, but kept for symmetry */
   OpCode op;
   if (e1->k != VNONRELOC) {
     lua_assert(e1->k == VK || e1->k == VKINT || e1->k == VKFLT);
     swapexps(e1, e2);
+  }
   r1 = luaK_exp2anyreg(fs, e1);  /* 1st expression must be in register */
   if (isSCnumber(e2, &im, &isfloat)) {
     op = OP_EQI;
     r2 = im;  /* immediate operand */
+  }
-  else if (luaK_exp2RK(fs, e2)) {  /* 1st expression is constant? */
+  else if (luaK_exp2RK(fs, e2)) {  /* 2nd expression is constant? */
     op = OP_EQK;
     r2 = e2->u.info;  /* constant index */
+  }
   else {
     op = OP_EQ;  /* will compare two registers */
     r2 = luaK_exp2anyreg(fs, e2);
+  }
   freeexps(fs, e1, e2);
   e1->u.info = condjump(fs, op, r1, r2, isfloat, (opr == OPR_EQ));
   e1->k = VJMP;
+}
 @@ -1641,27 +1644,28 @@ void luaK_infix (FuncState *fs, BinOpr o
+    }
     case OPR_ADD: case OPR_SUB:
 #ifndef _KERNEL
     case OPR_MUL: case OPR_DIV: case OPR_IDIV:
     case OPR_MOD: case OPR_POW:
 #else /* _KERNEL */
     case OPR_MUL: case OPR_IDIV:
     case OPR_MOD:
 #endif /* _KERNEL */
     case OPR_BAND: case OPR_BOR: case OPR_BXOR:
     case OPR_SHL: case OPR_SHR: {
       if (!tonumeral(v, NULL))
         luaK_exp2anyreg(fs, v);
-      /* else keep numeral, which may be folded with 2nd operand */
+      /* else keep numeral, which may be folded or used as an immediate
         operand */
       break;
+    }
     case OPR_EQ: case OPR_NE: {
       if (!tonumeral(v, NULL))
         luaK_exp2RK(fs, v);
       /* else keep numeral, which may be an immediate operand */
       break;
+    }
     case OPR_LT: case OPR_LE:
     case OPR_GT: case OPR_GE: {
       int dummy, dummy2;
       if (!isSCnumber(v, &dummy, &dummy2))
         luaK_exp2anyreg(fs, v);