Field Instruction.key put inside a union

So that we can get its space for other uses, if needed.

5 files changed, 28 insertions, 26 deletions

diff --git a/lpcode.c b/lpcode.c
index f2ae754..f537904 100644
--- a/lpcode.c
+++ b/lpcode.c
@@ -499,7 +499,7 @@ static int nextinstruction (CompileState *compst) {
 static int addinstruction (CompileState *compst, Opcode op, int aux) {
   int i = nextinstruction(compst);
   getinstr(compst, i).i.code = op;
-  getinstr(compst, i).i.aux = aux;
+  getinstr(compst, i).i.aux1 = aux;
   return i;
 }
 
@@ -528,8 +528,8 @@ static void codeutfr (CompileState *compst, TTree *tree) {
   int to = sib1(tree)->u.n;
   assert(sib1(tree)->tag == TXInfo);
   getinstr(compst, i + 1).offset = tree->u.n;
-  getinstr(compst, i).i.aux = to & 0xff;
-  getinstr(compst, i).i.key = to >> 8;
+  getinstr(compst, i).i.aux1 = to & 0xff;
+  getinstr(compst, i).i.aux2.key = to >> 8;
 }
 
 
@@ -542,7 +542,7 @@ static void codeutfr (CompileState *compst, TTree *tree) {
 static int addinstcap (CompileState *compst, Opcode op, int cap, int key,
                        int aux) {
   int i = addinstruction(compst, op, joinkindoff(cap, aux));
-  getinstr(compst, i).i.key = key;
+  getinstr(compst, i).i.aux2.key = key;
   return i;
 }
 
@@ -575,7 +575,7 @@ static void jumptohere (CompileState *compst, int instruction) {
 */
 static void codechar (CompileState *compst, int c, int tt) {
   if (tt >= 0 && getinstr(compst, tt).i.code == ITestChar &&
-                 getinstr(compst, tt).i.aux == c)
+                 getinstr(compst, tt).i.aux1 == c)
     addinstruction(compst, IAny, 0);
   else
     addinstruction(compst, IChar, c);
@@ -636,7 +636,7 @@ static int codetestset (CompileState *compst, Charset *cs, int e) {
       case IAny: return addoffsetinst(compst, ITestAny);
       case IChar: {
         int i = addoffsetinst(compst, ITestChar);
-        getinstr(compst, i).i.aux = c;
+        getinstr(compst, i).i.aux1 = c;
         return i;
       }
       case ISet: {
@@ -862,7 +862,7 @@ static void correctcalls (CompileState *compst, int *positions,
   Instruction *code = compst->p->code;
   for (i = from; i < to; i += sizei(&code[i])) {
     if (code[i].i.code == IOpenCall) {
-      int n = code[i].i.key;  /* rule number */
+      int n = code[i].i.aux2.key;  /* rule number */
       int rule = positions[n];  /* rule position */
       assert(rule == from || code[rule - 1].i.code == IRet);
       if (code[finaltarget(code, i + 2)].i.code == IRet)  /* call; ret ? */
@@ -904,7 +904,7 @@ static void codegrammar (CompileState *compst, TTree *grammar) {
 static void codecall (CompileState *compst, TTree *call) {
   int c = addoffsetinst(compst, IOpenCall);  /* to be corrected later */
   assert(sib1(sib2(call))->tag == TXInfo);
-  getinstr(compst, c).i.key = sib1(sib2(call))->u.n;  /* rule number */
+  getinstr(compst, c).i.aux2.key = sib1(sib2(call))->u.n;  /* rule number */
 }
 
 
diff --git a/lpprint.c b/lpprint.c
index 1c1b7b6..1b5c488 100644
--- a/lpprint.c
+++ b/lpprint.c
@@ -62,11 +62,11 @@ void printinst (const Instruction *op, const Instruction *p) {
   printf("%02ld: %s ", (long)(p - op), names[p->i.code]);
   switch ((Opcode)p->i.code) {
     case IChar: {
-      printf("'%c' (%02x)", p->i.aux, p->i.aux);
+      printf("'%c' (%02x)", p->i.aux1, p->i.aux1);
       break;
     }
     case ITestChar: {
-      printf("'%c' (%02x)", p->i.aux, p->i.aux); printjmp(op, p);
+      printf("'%c' (%02x)", p->i.aux1, p->i.aux1); printjmp(op, p);
       break;
     }
     case IUTFR: {
@@ -75,11 +75,11 @@ void printinst (const Instruction *op, const Instruction *p) {
     }
     case IFullCapture: {
       printf("%s (size = %d)  (idx = %d)",
-             capkind(getkind(p)), getoff(p), p->i.key);
+             capkind(getkind(p)), getoff(p), p->i.aux2.key);
       break;
     }
     case IOpenCapture: {
-      printf("%s (idx = %d)", capkind(getkind(p)), p->i.key);
+      printf("%s (idx = %d)", capkind(getkind(p)), p->i.aux2.key);
       break;
     }
     case ISet: {
@@ -99,7 +99,7 @@ void printinst (const Instruction *op, const Instruction *p) {
       break;
     }
     case IBehind: {
-      printf("%d", p->i.aux);
+      printf("%d", p->i.aux1);
       break;
     }
     case IJmp: case ICall: case ICommit: case IChoice:
diff --git a/lptypes.h b/lptypes.h
index 98b9597..81aa61e 100644
--- a/lptypes.h
+++ b/lptypes.h
@@ -111,8 +111,8 @@ typedef struct Charset {
 ** in capture instructions, 'kind' of capture and its offset are
 ** packed in field 'aux', 4 bits for each
 */
-#define getkind(op)             ((op)->i.aux & 0xF)
-#define getoff(op)              (((op)->i.aux >> 4) & 0xF)
+#define getkind(op)             ((op)->i.aux1 & 0xF)
+#define getoff(op)              (((op)->i.aux1 >> 4) & 0xF)
 #define joinkindoff(k,o)        ((k) | ((o) << 4))
 
 #define MAXOFF          0xF
diff --git a/lpvm.c b/lpvm.c
index 8c001fc..9ee00a7 100644
--- a/lpvm.c
+++ b/lpvm.c
@@ -20,7 +20,7 @@
 
 #define getoffset(p)    (((p) + 1)->offset)
 
-static const Instruction giveup = {{IGiveup, 0, 0}};
+static const Instruction giveup = {{IGiveup, 0, {0}}};
 
 
 /*
@@ -249,12 +249,12 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
         continue;
       }
       case IChar: {
-        if ((byte)*s == p->i.aux && s < e) { p++; s++; }
+        if ((byte)*s == p->i.aux1 && s < e) { p++; s++; }
         else goto fail;
         continue;
       }
       case ITestChar: {
-        if ((byte)*s == p->i.aux && s < e) p += 2;
+        if ((byte)*s == p->i.aux1 && s < e) p += 2;
         else p += getoffset(p);
         continue;
       }
@@ -273,7 +273,7 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
         continue;
       }
       case IBehind: {
-        int n = p->i.aux;
+        int n = p->i.aux1;
         if (n > s - o) goto fail;
         s -= n; p++;
         continue;
@@ -404,7 +404,7 @@ const char *match (lua_State *L, const char *o, const char *s, const char *e,
         capture[captop].s = s - getoff(p);
         /* goto pushcapture; */
       pushcapture: {
-        capture[captop].idx = p->i.key;
+        capture[captop].idx = p->i.aux2.key;
         capture[captop].kind = getkind(p);
         captop++;
         capture = growcap(L, capture, &capsize, captop, 0, ptop);
diff --git a/lpvm.h b/lpvm.h
index cc79dcd..607bf48 100644
--- a/lpvm.h
+++ b/lpvm.h
@@ -8,14 +8,14 @@
 /* Virtual Machine's instructions */
 typedef enum Opcode {
   IAny, /* if no char, fail */
-  IChar,  /* if char != aux, fail */
+  IChar,  /* if char != aux1, fail */
   ISet,  /* if char not in buff, fail */
   ITestAny,  /* in no char, jump to 'offset' */
-  ITestChar,  /* if char != aux, jump to 'offset' */
+  ITestChar,  /* if char != aux1, jump to 'offset' */
   ITestSet,  /* if char not in buff, jump to 'offset' */
   ISpan,  /* read a span of chars in buff */
   IUTFR,  /* if codepoint not in range [offset, utf_to], fail */
-  IBehind,  /* walk back 'aux' characters (fail if not possible) */
+  IBehind,  /* walk back 'aux1' characters (fail if not possible) */
   IRet,  /* return from a rule */
   IEnd,  /* end of pattern */
   IChoice,  /* stack a choice; next fail will jump to 'offset' */
@@ -40,8 +40,10 @@ typedef enum Opcode {
 typedef union Instruction {
   struct Inst {
     byte code;
-    byte aux;
-    short key;
+    byte aux1;
+    union {
+      short key;
+    } aux2;
   } i;
   int offset;
   byte buff[1];
@@ -49,7 +51,7 @@ typedef union Instruction {
 
 
 /* extract 24-bit value from an instruction */
-#define utf_to(inst)    (((inst)->i.key << 8) | (inst)->i.aux)
+#define utf_to(inst)    (((inst)->i.aux2.key << 8) | (inst)->i.aux1)
 
 
 void printpatt (Instruction *p, int n);