luajit210.patch

diff -rup lj_errmsg.h lj_errmsg.h
--- lj_errmsg.h	2017-05-02 05:03:01.000000000 +1000
+++ lj_errmsg.h	2021-06-12 21:06:27.290866317 +1000
@@ -146,6 +146,11 @@ ERRDEF(XLUNDEF,	"undefined label " LUA_Q
 ERRDEF(XLDUP,	"duplicate label " LUA_QS)
 ERRDEF(XGSCOPE,	"<goto %s> jumps into the scope of local " LUA_QS)
 
+ERRDEF(XLEFTCOMPOUND,	"syntax error in left hand expression in compound assignment")
+ERRDEF(XRIGHTCOMPOUND,	"syntax error in right hand expression in compound assignment")
+ERRDEF(XNOTASSIGNABLE,	"syntax error expression not assignable")
+ERRDEF(XCONTINUE,	"no loop to continue")
+
 /* Bytecode reader errors. */
 ERRDEF(BCFMT,	"cannot load incompatible bytecode")
 ERRDEF(BCBAD,	"cannot load malformed bytecode")
diff -rup lj_lex.c lj_lex.c
--- lj_lex.c	2017-05-02 05:03:01.000000000 +1000
+++ lj_lex.c	2021-06-13 15:44:15.598060773 +1000
@@ -317,6 +317,7 @@ static LexToken lex_scan(LexState *ls, T
       continue;
     case '-':
       lex_next(ls);
+      if (ls->c == '=')  { lex_next(ls); return TK_csub; }
       if (ls->c != '-') return '-';
       lex_next(ls);
       if (ls->c == '[') {  /* Long comment "--[=*[...]=*]". */
@@ -359,6 +360,27 @@ static LexToken lex_scan(LexState *ls, T
     case ':':
       lex_next(ls);
       if (ls->c != ':') return ':'; else { lex_next(ls); return TK_label; }
+    
+    // compound injection
+    case '+':
+      lex_next(ls);
+      if (ls->c == '=') { lex_next(ls); return TK_cadd; }
+      if (ls->c == '+') { lex_next(ls); return TK_plusplus; }
+      return '+';
+    case '*':
+      lex_next(ls);
+      if (ls->c == '=') { lex_next(ls); return TK_cmul; }
+      return '*';
+    case '/':
+      lex_next(ls);
+      if (ls->c == '=') { lex_next(ls); return TK_cdiv; }
+      return '/';
+    case '%':
+      lex_next(ls);
+      if (ls->c == '=') { lex_next(ls); return TK_cmod; }
+      return '%';
+      
+      
     case '"':
     case '\'':
       lex_string(ls, tv);
@@ -370,6 +392,10 @@ static LexToken lex_scan(LexState *ls, T
 	  lex_next(ls);
 	  return TK_dots;   /* ... */
 	}
+	if (ls->c == '=') {
+		lex_next(ls);
+		return TK_cconcat;
+		}
 	return TK_concat;   /* .. */
       } else if (!lj_char_isdigit(ls->c)) {
 	return '.';
diff -rup lj_lex.h lj_lex.h
--- lj_lex.h	2017-05-02 05:03:01.000000000 +1000
+++ lj_lex.h	2021-06-12 23:40:02.001828762 +1000
@@ -13,13 +13,15 @@
 
 /* Lua lexer tokens. */
 #define TKDEF(_, __) \
-  _(and) _(break) _(do) _(else) _(elseif) _(end) _(false) \
+  _(and) _(break) _(continue) _(do) _(else) _(elseif) _(end) _(false) \
   _(for) _(function) _(goto) _(if) _(in) _(local) _(nil) _(not) _(or) \
   _(repeat) _(return) _(then) _(true) _(until) _(while) \
   __(concat, ..) __(dots, ...) __(eq, ==) __(ge, >=) __(le, <=) __(ne, ~=) \
   __(label, ::) __(number, <number>) __(name, <name>) __(string, <string>) \
+  __(cadd, +=) __(csub, -=) __(cmul, *=) __(cdiv, /=) __(cconcat, ..=) __(cmod, %=) \
+  __(plusplus, ++) \
   __(eof, <eof>)
-
+  
 enum {
   TK_OFS = 256,
 #define TKENUM1(name)		TK_##name,
diff -rup lj_parse.c lj_parse.c
--- lj_parse.c	2017-05-02 05:03:01.000000000 +1000
+++ lj_parse.c	2021-06-27 01:38:11.206258892 +1000
@@ -28,6 +28,8 @@
 #include "lj_vm.h"
 #include "lj_vmevent.h"
 
+#define vkisvar(k)(VLOCAL<=(k)&&(k)<=VINDEXED)
+
 /* -- Parser structures and definitions ----------------------------------- */
 
 /* Expression kinds. */
@@ -107,8 +109,12 @@ typedef struct FuncScope {
 #define FSCOPE_GOLA		0x04	/* Goto or label used in scope. */
 #define FSCOPE_UPVAL		0x08	/* Upvalue in scope. */
 #define FSCOPE_NOCLOSE		0x10	/* Do not close upvalues. */
+#define FSCOPE_CONTINUE		0x20	/* Continue used in scope. */
+//#define FSCOPE_FORINLOOP	0x40	/* Scope is a (breakable) for in loop. */
+//#define FSCOPE_DOWHILELOOP	0x80	/* Scope is a repeat/until loop. */
 
 #define NAME_BREAK		((GCstr *)(uintptr_t)1)
+#define NAME_CONTINUE		((GCstr *)(uintptr_t)2)
 
 /* Index into variable stack. */
 typedef uint16_t VarIndex;
@@ -1147,7 +1153,7 @@ static MSize gola_new(LexState *ls, GCst
       lj_lex_error(ls, 0, LJ_ERR_XLIMC, LJ_MAX_VSTACK);
     lj_mem_growvec(ls->L, ls->vstack, ls->sizevstack, LJ_MAX_VSTACK, VarInfo);
   }
-  lua_assert(name == NAME_BREAK || lj_tab_getstr(fs->kt, name) != NULL);
+  lua_assert(name == NAME_BREAK || name == NAME_CONTINUE || lj_tab_getstr(fs->kt, name) != NULL);
   /* NOBARRIER: name is anchored in fs->kt and ls->vstack is not a GCobj. */
   setgcref(ls->vstack[vtop].name, obj2gco(name));
   ls->vstack[vtop].startpc = pc;
@@ -1200,6 +1206,7 @@ static void gola_resolve(LexState *ls, F
 	lua_assert((uintptr_t)name >= VARNAME__MAX);
 	ls->linenumber = ls->fs->bcbase[vg->startpc].line;
 	lua_assert(strref(vg->name) != NAME_BREAK);
+	lua_assert(strref(vg->name) != NAME_CONTINUE);
 	lj_lex_error(ls, 0, LJ_ERR_XGSCOPE,
 		     strdata(strref(vg->name)), strdata(name));
       }
@@ -1225,8 +1232,9 @@ static void gola_fixup(LexState *ls, Fun
 	    gola_patch(ls, vg, v);
 	  }
       } else if (gola_isgoto(v)) {
-	if (bl->prev) {  /* Propagate goto or break to outer scope. */
-	  bl->prev->flags |= name == NAME_BREAK ? FSCOPE_BREAK : FSCOPE_GOLA;
+	if (bl->prev) {  /* Propagate goto or break, continue to outer scope. */
+	  bl->prev->flags |= name == NAME_BREAK ? FSCOPE_BREAK
+      : (name == NAME_CONTINUE ? FSCOPE_CONTINUE : FSCOPE_GOLA);
 	  v->slot = bl->nactvar;
 	  if ((bl->flags & FSCOPE_UPVAL))
 	    gola_close(ls, v);
@@ -1234,6 +1242,8 @@ static void gola_fixup(LexState *ls, Fun
 	  ls->linenumber = ls->fs->bcbase[v->startpc].line;
 	  if (name == NAME_BREAK)
 	    lj_lex_error(ls, 0, LJ_ERR_XBREAK);
+	  else if (name == NAME_CONTINUE)
+	    lj_lex_error(ls, 0, LJ_ERR_XCONTINUE);
 	  else
 	    lj_lex_error(ls, 0, LJ_ERR_XLUNDEF, strdata(name));
 	}
@@ -1266,6 +1276,29 @@ static void fscope_begin(FuncState *fs,
   lua_assert(fs->freereg == fs->nactvar);
 }
 
+/* When an FSCOPE_LOOP is ending, this is called to set the instruction continue statements
+ * should jump to. */
+static void fscope_loop_continue(FuncState *fs, BCPos pos)
+{
+  FuncScope *bl = fs->bl;
+  LexState *ls = fs->ls;
+
+  /* This must be called before the loop is closed, so we don't propagate FSCOPE_CONTINUE
+   * out to the enclosing scope. */
+  lua_assert((bl->flags & FSCOPE_LOOP));
+
+  /* If continue wasn't used in this scope, we have nothing to do. */
+  if (!(bl->flags & FSCOPE_CONTINUE))
+    return;
+
+  bl->flags &= ~FSCOPE_CONTINUE;
+
+  /* Generate a CONTINUE label, and resolve continues inside this scope to it. */
+  MSize idx = gola_new(ls, NAME_CONTINUE, VSTACK_LABEL, pos);
+  ls->vtop = idx;  /* Drop continue label immediately. */
+  gola_resolve(ls, bl, idx);
+}
+
 /* End a scope. */
 static void fscope_end(FuncState *fs)
 {
@@ -1287,7 +1320,7 @@ static void fscope_end(FuncState *fs)
       return;
     }
   }
-  if ((bl->flags & FSCOPE_GOLA)) {
+  if ((bl->flags & FSCOPE_GOLA) || (bl->flags & FSCOPE_CONTINUE)) {
     gola_fixup(ls, bl);
   }
 }
@@ -1929,6 +1962,10 @@ static void parse_args(LexState *ls, Exp
   fs->freereg = base+1;  /* Leave one result by default. */
 }
 
+
+static void inc_dec_op (LexState *ls, BinOpr op, ExpDesc *v, int isPost);
+
+
 /* Parse primary expression. */
 static void expr_primary(LexState *ls, ExpDesc *v)
 {
@@ -1959,7 +1996,12 @@ static void expr_primary(LexState *ls, E
       expr_str(ls, &key);
       bcemit_method(fs, v, &key);
       parse_args(ls, v);
-    } else if (ls->tok == '(' || ls->tok == TK_string || ls->tok == '{') {
+    } 
+    else if (ls->tok == TK_plusplus) {
+      lj_lex_next(ls);
+      inc_dec_op(ls, OPR_ADD, v, 1);
+    } 
+    else if (ls->tok == '(' || ls->tok == TK_string || ls->tok == '{') {
       expr_tonextreg(fs, v);
       if (LJ_FR2) bcreg_reserve(fs, 1);
       parse_args(ls, v);
@@ -1969,6 +2011,36 @@ static void expr_primary(LexState *ls, E
   }
 }
 
+static void inc_dec_op (LexState *ls, BinOpr op, ExpDesc *v, int isPost) {
+  FuncState *fs = ls->fs;
+  ExpDesc lv, e1, e2;
+  BCReg indices;
+  if(!v) v = &lv;
+  indices = fs->freereg;
+  expr_init(&e2, VKNUM, 0);
+  setintV(&e2.u.nval, 1);
+  if(isPost) {
+    checkcond(ls, vkisvar(v->k), LJ_ERR_XNOTASSIGNABLE);
+    lv = e1 = *v;
+    if (v->k == VINDEXED)
+      bcreg_reserve(fs, 1);
+    expr_tonextreg(fs, v);
+    bcreg_reserve(fs, 1); //copy again to operate on it
+    bcemit_arith(fs, op, &e1, &e2);
+    bcemit_store(fs, &lv, &e1);
+    --fs->freereg; //remove extra copy register
+    return;
+  }
+  expr_primary(ls, v);
+  checkcond(ls, vkisvar(v->k), LJ_ERR_XNOTASSIGNABLE);
+  e1 = *v;
+  if (v->k == VINDEXED)
+    bcreg_reserve(fs, fs->freereg - indices);
+  bcemit_arith(fs, op, &e1, &e2);
+  bcemit_store(fs, v, &e1);
+  if(v != &lv) expr_tonextreg(fs, v);
+}
+
 /* Parse simple expression. */
 static void expr_simple(LexState *ls, ExpDesc *v)
 {
@@ -2133,6 +2205,7 @@ static BCPos expr_cond(LexState *ls)
 typedef struct LHSVarList {
   ExpDesc v;			/* LHS variable. */
   struct LHSVarList *prev;	/* Link to previous LHS variable. */
+  struct LHSVarList *next;	/* Link to next LHS variable. */
 } LHSVarList;
 
 /* Eliminate write-after-read hazards for local variable assignment. */
@@ -2183,6 +2256,47 @@ static void assign_adjust(LexState *ls,
     ls->fs->freereg -= nexps - nvars;  /* Drop leftover regs. */
 }
 
+
+static int assign_compound (LexState *ls, LHSVarList *lh, LexToken opType) {
+
+  FuncState * fs=ls->fs;
+  ExpDesc lhv, infix, rh;
+  int32_t nexps;
+  BinOpr op;
+  /*store expression before grounding */
+  lhv = lh->v;
+
+  checkcond(ls, vkisvar(lh->v.k), LJ_ERR_XLEFTCOMPOUND);
+
+  /* parse Compound operation. */
+  switch (opType) {
+      case TK_cadd: op = OPR_ADD; break;
+      case TK_csub: op = OPR_SUB; break;
+      case TK_cmul: op = OPR_MUL; break;
+      case TK_cdiv: op = OPR_DIV; break;
+      case TK_cmod: op = OPR_MOD; break;
+      case TK_cconcat: op = OPR_CONCAT; break;
+  };
+  lj_lex_next(ls);
+
+  /* store compound results in a new register (needed for nested tables) */
+  if(lh->v.k == VINDEXED) bcreg_reserve(fs, 1);
+
+  /* ground the lhs expresion */
+  expr_tonextreg(fs, &lh->v);
+
+  /* parse right-hand expression */
+  nexps = expr_list(ls, &rh);
+  checkcond(ls, nexps == 1, LJ_ERR_XRIGHTCOMPOUND);
+
+  infix = lh->v;
+  bcemit_binop_left(fs,op,&infix);
+  bcemit_binop(fs, op, &infix, &rh);
+  /* use the lhs before grounding to store */
+  bcemit_store(fs, &lhv, &infix);
+return 1;
+}
+
 /* Recursively parse assignment statement. */
 static void parse_assignment(LexState *ls, LHSVarList *lh, BCReg nvars)
 {
@@ -2191,6 +2305,7 @@ static void parse_assignment(LexState *l
   if (lex_opt(ls, ',')) {  /* Collect LHS list and recurse upwards. */
     LHSVarList vl;
     vl.prev = lh;
+    lh->next = &vl;
     expr_primary(ls, &vl.v);
     if (vl.v.k == VLOCAL)
       assign_hazard(ls, lh, &vl.v);
@@ -2228,8 +2343,14 @@ static void parse_call_assign(LexState *
   expr_primary(ls, &vl.v);
   if (vl.v.k == VCALL) {  /* Function call statement. */
     setbc_b(bcptr(fs, &vl.v), 1);  /* No results. */
-  } else {  /* Start of an assignment. */
+}
+   else if (ls->tok >= TK_cadd && ls->tok <= TK_cmod) {
     vl.prev = NULL;
+    assign_compound(ls, &vl, ls->tok);
+  } else if (ls->tok == ';') {
+    /* TK_PLUSPLUS, TK_MINUMINUS should be already managed */
+  } else {  /* Start of an assignment. */
+    vl.prev = vl.next = NULL;
     parse_assignment(ls, &vl, 1);
   }
 }
@@ -2341,6 +2462,13 @@ static void parse_return(LexState *ls)
 }
 
 /* Parse 'break' statement. */
+static void parse_continue(LexState *ls)
+{
+  ls->fs->bl->flags |= FSCOPE_CONTINUE;
+  gola_new(ls, NAME_CONTINUE, VSTACK_GOTO, bcemit_jmp(ls->fs));
+}
+
+/* Parse 'break' statement. */
 static void parse_break(LexState *ls)
 {
   ls->fs->bl->flags |= FSCOPE_BREAK;
@@ -2418,6 +2546,7 @@ static void parse_while(LexState *ls, BC
   parse_block(ls);
   jmp_patch(fs, bcemit_jmp(fs), start);
   lex_match(ls, TK_end, TK_while, line);
+  fscope_loop_continue(fs, start);
   fscope_end(fs);
   jmp_tohere(fs, condexit);
   jmp_patchins(fs, loop, fs->pc);
@@ -2428,7 +2557,7 @@ static void parse_repeat(LexState *ls, B
 {
   FuncState *fs = ls->fs;
   BCPos loop = fs->lasttarget = fs->pc;
-  BCPos condexit;
+  BCPos condexit, iter;
   FuncScope bl1, bl2;
   fscope_begin(fs, &bl1, FSCOPE_LOOP);  /* Breakable loop scope. */
   fscope_begin(fs, &bl2, 0);  /* Inner scope. */
@@ -2436,6 +2565,7 @@ static void parse_repeat(LexState *ls, B
   bcemit_AD(fs, BC_LOOP, fs->nactvar, 0);
   parse_chunk(ls);
   lex_match(ls, TK_until, TK_repeat, line);
+  iter = fs->pc;
   condexit = expr_cond(ls);  /* Parse condition (still inside inner scope). */
   if (!(bl2.flags & FSCOPE_UPVAL)) {  /* No upvalues? Just end inner scope. */
     fscope_end(fs);
@@ -2447,6 +2577,7 @@ static void parse_repeat(LexState *ls, B
   }
   jmp_patch(fs, condexit, loop);  /* Jump backwards if !cond. */
   jmp_patchins(fs, loop, fs->pc);
+  fscope_loop_continue(fs, iter); /* continue statements jump to condexit. */
   fscope_end(fs);  /* End loop scope. */
 }
 
@@ -2486,6 +2617,7 @@ static void parse_for_num(LexState *ls,
   fs->bcbase[loopend].line = line;  /* Fix line for control ins. */
   jmp_patchins(fs, loopend, loop+1);
   jmp_patchins(fs, loop, fs->pc);
+  fscope_loop_continue(fs, loopend); /* continue statements jump to loopend. */
 }
 
 /* Try to predict whether the iterator is next() and specialize the bytecode.
@@ -2528,7 +2660,7 @@ static void parse_for_iter(LexState *ls,
   BCReg nvars = 0;
   BCLine line;
   BCReg base = fs->freereg + 3;
-  BCPos loop, loopend, exprpc = fs->pc;
+  BCPos loop, loopend, iter, exprpc = fs->pc;
   FuncScope bl;
   int isnext;
   /* Hidden control variables. */
@@ -2555,11 +2687,12 @@ static void parse_for_iter(LexState *ls,
   fscope_end(fs);
   /* Perform loop inversion. Loop control instructions are at the end. */
   jmp_patchins(fs, loop, fs->pc);
-  bcemit_ABC(fs, isnext ? BC_ITERN : BC_ITERC, base, nvars-3+1, 2+1);
+  iter = bcemit_ABC(fs, isnext ? BC_ITERN : BC_ITERC, base, nvars-3+1, 2+1);
   loopend = bcemit_AJ(fs, BC_ITERL, base, NO_JMP);
   fs->bcbase[loopend-1].line = line;  /* Fix line for control ins. */
   fs->bcbase[loopend].line = line;
   jmp_patchins(fs, loopend, loop+1);
+  fscope_loop_continue(fs, iter); /* continue statements jump to iter. */
 }
 
 /* Parse 'for' statement. */
@@ -2573,8 +2706,10 @@ static void parse_for(LexState *ls, BCLi
   varname = lex_str(ls);  /* Get first variable name. */
   if (ls->tok == '=')
     parse_for_num(ls, varname, line);
-  else if (ls->tok == ',' || ls->tok == TK_in)
+  else if (ls->tok == ',' || ls->tok == TK_in) {
     parse_for_iter(ls, varname);
+    //bl.flags |= FSCOPE_FORINLOOP;
+	}
   else
     err_syntax(ls, LJ_ERR_XFOR);
   lex_match(ls, TK_end, TK_for, line);
@@ -2650,6 +2785,10 @@ static int parse_stmt(LexState *ls)
   case TK_return:
     parse_return(ls);
     return 1;  /* Must be last. */
+  case TK_continue:
+    lj_lex_next(ls);
+    parse_continue(ls);
+    break;  /* Must be last in Lua 5.1. */
   case TK_break:
     lj_lex_next(ls);
     parse_break(ls);