lua52.patch

diff -rup llex.c llex.c
--- llex.c	2015-02-10 03:56:34.000000000 +1000
+++ llex.c	2021-06-13 14:41:50.090467203 +1000
@@ -34,7 +34,7 @@
 
 /* ORDER RESERVED */
 static const char *const luaX_tokens [] = {
-    "and", "break", "do", "else", "elseif",
+    "and", "break", "continue", "do", "else", "elseif",
     "end", "false", "for", "function", "goto", "if",
     "in", "local", "nil", "not", "or", "repeat",
     "return", "then", "true", "until", "while",
diff -rup llex.h llex.h
--- llex.h	2013-04-13 04:48:47.000000000 +1000
+++ llex.h	2021-06-13 14:42:13.330646803 +1000
@@ -21,7 +21,7 @@
 */
 enum RESERVED {
   /* terminal symbols denoted by reserved words */
-  TK_AND = FIRST_RESERVED, TK_BREAK,
+  TK_AND = FIRST_RESERVED, TK_BREAK, TK_CONTINUE,
   TK_DO, TK_ELSE, TK_ELSEIF, TK_END, TK_FALSE, TK_FOR, TK_FUNCTION,
   TK_GOTO, TK_IF, TK_IN, TK_LOCAL, TK_NIL, TK_NOT, TK_OR, TK_REPEAT,
   TK_RETURN, TK_THEN, TK_TRUE, TK_UNTIL, TK_WHILE,
diff -rup lparser.c lparser.c
--- lparser.c	2013-04-13 04:48:47.000000000 +1000
+++ lparser.c	2021-06-13 14:44:32.661658408 +1000
@@ -457,6 +457,15 @@ static void breaklabel (LexState *ls) {
 }
 
 /*
+** create a label named 'continue' to resolve continue statements
+*/
+static void continuelabel (LexState *ls, int pc) {
+  TString *n = luaS_new(ls->L, "continue");
+  int l = newlabelentry(ls, &ls->dyd->label, n, 0, pc);
+  findgotos(ls, &ls->dyd->label.arr[l]);
+}
+
+/*
 ** generates an error for an undefined 'goto'; choose appropriate
 ** message when label name is a reserved word (which can only be 'break')
 */
@@ -1094,7 +1103,7 @@ static void block (LexState *ls) {
 ** assignment
 */
 struct LHS_assign {
-  struct LHS_assign *prev;
+  struct LHS_assign *prev, *next;
   expdesc v;  /* variable (global, local, upvalue, or indexed) */
 };
 
@@ -1132,22 +1141,138 @@ static void check_conflict (LexState *ls
   }
 }
 
+enum {
+  NORMAL_ASSIGNMENT,
+  COMPOUND_ASSIGNMENT
+};
+
+
+static int compound_assignment(LexState *ls, struct LHS_assign *lh, int nvars) {
+  BinOpr op = getbinopr(ls->t.token);
+  FuncState * fs=ls->fs;
+  int tolevel=fs->nactvar;
+  int old_free=fs->freereg;
+  expdesc e,infix;
+  double inc=0;
+  int nexps=0,i;
+  int line=ls->linenumber;
+  struct LHS_assign * assign=lh;
+  while(assign->prev) assign=assign->prev;
+  luaX_next(ls);
+
+  { /* create temporary local variables to lock up any registers needed 
+       by VINDEXED lvalues. */
+     lu_byte top=fs->nactvar;
+     struct LHS_assign * a = lh;
+     int nextra;
+     while(a) {
+       expdesc * v= &a->v;
+       /* protect both the table and index result registers,
+       ** ensuring that they won't be overwritten prior to the 
+       ** storevar calls. */
+       if(v->k==VINDEXED) {
+         if( !ISK( v->u.ind.t ) && v->u.ind.t  >= top) {
+           top= v->u.ind.t+1;
+         }
+         if( !ISK( v->u.ind.idx ) && v->u.ind.idx >= top) {
+           top= v->u.ind.idx+1;
+         }
+       }
+       a=a->prev;
+     }
+     nextra=top-fs->nactvar;
+     if(nextra) {
+       for(i=0;i<nextra;i++) {
+         new_localvarliteral(ls,"(temp)");
+       }
+       adjustlocalvars(ls,nextra);
+     }   
+  }
+  if(op==OPR_ADD && testnext(ls,'+')) {
+    /* the increment case.  supporting this is a bit silly, but
+    ** also fairly simple.
+    ** note that `a,b,c++` increments a,b, and c. */
+    for(i=0;i<nvars;i++) {
+      init_exp(&e, VKNUM, 0);
+      e.u.nval = 1;
+      infix=assign->v;
+      luaK_infix(fs,op,&infix);
+      luaK_posfix(fs, op, &infix, &e, line);
+      luaK_storevar(fs, &assign->v, &infix);
+      assign=assign->next;
+    }
+    goto done;
+  }
+  checknext(ls, '=');
+  do {
+    if(!assign) {
+      luaX_syntaxerror(ls,"too many right hand side values in compound assignment");
+    }
+    infix=assign->v;
+    luaK_infix(fs,op,&infix);
+    expr(ls, &e);
+    if(ls->t.token == ',') {
+      luaK_posfix(fs, op, &infix, &e, line);
+      luaK_storevar(fs, &assign->v, &infix);
+      assign=assign->next;
+      nexps++;
+    }
+  } while (testnext(ls, ','));
+
+  if(nexps+1==nvars ) {
+      luaK_posfix(fs, op, &infix, &e, line);
+      luaK_storevar(fs, &lh->v, &infix);
+  } else if( hasmultret(e.k) ) {
+    adjust_assign(ls, nvars-nexps, 1, &e);
+    assign=lh;
+    {
+      int top=ls->fs->freereg-1;
+      int first_top=top;
+      for(i=0;i<nvars-nexps;i++) {
+        infix=assign->v;
+        luaK_infix(fs,op,&infix);
+
+        init_exp(&e, VNONRELOC, top--); 
+        luaK_posfix(fs, op, &infix, &e, line);
+        luaK_storevar(fs, &assign->v, &infix);
+        assign=assign->prev;
+      }
+    }
+  } else {
+    luaX_syntaxerror(ls,"insufficient right hand variables in compound assignment.");
+  }
+
+  done:
+  removevars(fs,tolevel);
+  if(old_free<fs->freereg) {
+    fs->freereg=old_free;
+  }
+  return COMPOUND_ASSIGNMENT;
+}
 
-static void assignment (LexState *ls, struct LHS_assign *lh, int nvars) {
+static int assignment (LexState *ls, struct LHS_assign *lh, int nvars) {
   expdesc e;
+  int assignment_type = NORMAL_ASSIGNMENT;
   check_condition(ls, vkisvar(lh->v.k), "syntax error");
   if (testnext(ls, ',')) {  /* assignment -> ',' suffixedexp assignment */
     struct LHS_assign nv;
     nv.prev = lh;
+    nv.next = NULL;
+    lh->next = &nv;
     suffixedexp(ls, &nv.v);
     if (nv.v.k != VINDEXED)
       check_conflict(ls, lh, &nv.v);
     checklimit(ls->fs, nvars + ls->L->nCcalls, LUAI_MAXCCALLS,
                     "C levels");
-    assignment(ls, &nv, nvars+1);
+    assignment_type=assignment(ls, &nv, nvars+1);
   }
   else {  /* assignment -> `=' explist */
     int nexps;
+    switch(ls->t.token) {
+      /* hook for compound_assignment */
+      case '+': case '-': case '*': case '/': case TK_CONCAT:
+        return compound_assignment(ls,lh,nvars);
+    }
     checknext(ls, '=');
     nexps = explist(ls, &e);
     if (nexps != nvars) {
@@ -1158,11 +1283,13 @@ static void assignment (LexState *ls, st
     else {
       luaK_setoneret(ls->fs, &e);  /* close last expression */
       luaK_storevar(ls->fs, &lh->v, &e);
-      return;  /* avoid default */
+      return assignment_type;  /* avoid default */
     }
   }
+  if(assignment_type==COMPOUND_ASSIGNMENT) return assignment_type;
   init_exp(&e, VNONRELOC, ls->fs->freereg-1);  /* default assignment */
   luaK_storevar(ls->fs, &lh->v, &e);
+  return assignment_type;
 }
 
 
@@ -1182,6 +1309,8 @@ static void gotostat (LexState *ls, int
   int g;
   if (testnext(ls, TK_GOTO))
     label = str_checkname(ls);
+  else if (testnext(ls, TK_CONTINUE))
+    label = luaS_new(ls->L, "continue");
   else {
     luaX_next(ls);  /* skip break */
     label = luaS_new(ls->L, "break");
@@ -1244,6 +1373,7 @@ static void whilestat (LexState *ls, int
   block(ls);
   luaK_jumpto(fs, whileinit);
   check_match(ls, TK_END, TK_WHILE, line);
+  continuelabel(ls, whileinit);
   leaveblock(fs);
   luaK_patchtohere(fs, condexit);  /* false conditions finish the loop */
 }
@@ -1251,7 +1381,7 @@ static void whilestat (LexState *ls, int
 
 static void repeatstat (LexState *ls, int line) {
   /* repeatstat -> REPEAT block UNTIL cond */
-  int condexit;
+  int condexit, iter;
   FuncState *fs = ls->fs;
   int repeat_init = luaK_getlabel(fs);
   BlockCnt bl1, bl2;
@@ -1260,11 +1390,13 @@ static void repeatstat (LexState *ls, in
   luaX_next(ls);  /* skip REPEAT */
   statlist(ls);
   check_match(ls, TK_UNTIL, TK_REPEAT, line);
+  iter = fs->pc; // continue jumps here
   condexit = cond(ls);  /* read condition (inside scope block) */
   if (bl2.upval)  /* upvalues? */
     luaK_patchclose(fs, condexit, bl2.nactvar);
   leaveblock(fs);  /* finish scope */
   luaK_patchlist(fs, condexit, repeat_init);  /* close the loop */
+  continuelabel(ls, iter);
   leaveblock(fs);  /* finish loop */
 }
 
@@ -1294,6 +1426,7 @@ static void forbody (LexState *ls, int b
   block(ls);
   leaveblock(fs);  /* end of scope for declared variables */
   luaK_patchtohere(fs, prep);
+  continuelabel(ls, luaK_getlabel(fs));
   if (isnum)  /* numeric for? */
     endfor = luaK_codeAsBx(fs, OP_FORLOOP, base, NO_JUMP);
   else {  /* generic for */
@@ -1482,13 +1615,11 @@ static void exprstat (LexState *ls) {
   FuncState *fs = ls->fs;
   struct LHS_assign v;
   suffixedexp(ls, &v.v);
-  if (ls->t.token == '=' || ls->t.token == ',') { /* stat -> assignment ? */
-    v.prev = NULL;
-    assignment(ls, &v, 1);
-  }
-  else {  /* stat -> func */
-    check_condition(ls, v.v.k == VCALL, "syntax error");
+  if (v.v.k == VCALL) 
     SETARG_C(getcode(fs, &v.v), 1);  /* call statement uses no results */
+  else { /* stat -> assignment ? */
+    v.prev = v.next = NULL;
+    assignment(ls, &v, 1);
   }
 }
 
@@ -1579,6 +1710,7 @@ static void statement (LexState *ls) {
       break;
     }
     case TK_BREAK:   /* stat -> breakstat */
+    case TK_CONTINUE: /* stat -> continuestat */
     case TK_GOTO: {  /* stat -> 'goto' NAME */
       gotostat(ls, luaK_jump(ls->fs));
       break;