some name changes

1 files changed, 86 insertions, 86 deletions

diff --git a/lcode.c b/lcode.c
index 1a5c23f7..de78c52f 100644
--- a/lcode.c
+++ b/lcode.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lcode.c,v 1.8 2000/03/09 13:57:37 roberto Exp roberto $
+** $Id: lcode.c,v 1.9 2000/03/10 14:38:10 roberto Exp roberto $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
@@ -32,8 +32,8 @@ static Instruction *previous_instruction (LexState *ls) {
   if (fs->pc > fs->lasttarget)  /* no jumps to current position? */
     return &fs->f->code[fs->pc-1];  /* returns previous instruction */
   else {
-    static Instruction dummy = CREATE_0(ENDCODE);
-    return &dummy;  /* no optimizations after an `ENDCODE' */
+    static Instruction dummy = CREATE_0(OP_END);
+    return &dummy;  /* no optimizations after an `END' */
   }
 }
 
@@ -49,10 +49,10 @@ int luaK_primitivecode (LexState *ls, Instruction i) {
 static void luaK_minus (LexState *ls) {
   Instruction *previous = previous_instruction(ls);
   switch(GET_OPCODE(*previous)) {
-    case PUSHINT: SETARG_S(*previous, -GETARG_S(*previous)); return;
-    case PUSHNUM: SET_OPCODE(*previous, PUSHNEGNUM); return;
-    case PUSHNEGNUM: SET_OPCODE(*previous, PUSHNUM); return;
-    default: luaK_primitivecode(ls, CREATE_0(MINUSOP));
+    case OP_PUSHINT: SETARG_S(*previous, -GETARG_S(*previous)); return;
+    case OP_PUSHNUM: SET_OPCODE(*previous, OP_PUSHNEGNUM); return;
+    case OP_PUSHNEGNUM: SET_OPCODE(*previous, OP_PUSHNUM); return;
+    default: luaK_primitivecode(ls, CREATE_0(OP_MINUS));
   }
 }
 
@@ -61,8 +61,8 @@ static void luaK_gettable (LexState *ls) {
   Instruction *previous = previous_instruction(ls);
   luaK_deltastack(ls, -1);
   switch(GET_OPCODE(*previous)) {
-    case PUSHSTRING: SET_OPCODE(*previous, GETDOTTED); break;
-    default: luaK_primitivecode(ls, CREATE_0(GETTABLE));
+    case OP_PUSHSTRING: SET_OPCODE(*previous, OP_GETDOTTED); break;
+    default: luaK_primitivecode(ls, CREATE_0(OP_GETTABLE));
   }
 }
 
@@ -71,8 +71,8 @@ static void luaK_add (LexState *ls) {
   Instruction *previous = previous_instruction(ls);
   luaK_deltastack(ls, -1);
   switch(GET_OPCODE(*previous)) {
-    case PUSHINT: SET_OPCODE(*previous, ADDI); break;
-    default: luaK_primitivecode(ls, CREATE_0(ADDOP));
+    case OP_PUSHINT: SET_OPCODE(*previous, OP_ADDI); break;
+    default: luaK_primitivecode(ls, CREATE_0(OP_ADD));
   }
 }
 
@@ -81,11 +81,11 @@ static void luaK_sub (LexState *ls) {
   Instruction *previous = previous_instruction(ls);
   luaK_deltastack(ls, -1);
   switch(GET_OPCODE(*previous)) {
-    case PUSHINT:
-      SET_OPCODE(*previous, ADDI);
+    case OP_PUSHINT:
+      SET_OPCODE(*previous, OP_ADDI);
       SETARG_S(*previous, -GETARG_S(*previous));
       break;
-    default: luaK_primitivecode(ls, CREATE_0(SUBOP));
+    default: luaK_primitivecode(ls, CREATE_0(OP_SUB));
   }
 }
 
@@ -94,43 +94,43 @@ static void luaK_conc (LexState *ls) {
   Instruction *previous = previous_instruction(ls);
   luaK_deltastack(ls, -1);
   switch(GET_OPCODE(*previous)) {
-    case CONCOP: SETARG_U(*previous, GETARG_U(*previous)+1); break;
-    default: luaK_primitivecode(ls, CREATE_U(CONCOP, 2));
+    case OP_CONC: SETARG_U(*previous, GETARG_U(*previous)+1); break;
+    default: luaK_primitivecode(ls, CREATE_U(OP_CONC, 2));
   }
 }
 
 
 static void luaK_eq (LexState *ls) {
   Instruction *previous = previous_instruction(ls);
-  if (*previous == CREATE_U(PUSHNIL, 1)) {
-    *previous = CREATE_0(NOTOP);
+  if (*previous == CREATE_U(OP_PUSHNIL, 1)) {
+    *previous = CREATE_0(OP_NOT);
     luaK_deltastack(ls, -1);  /* undo effect of PUSHNIL */
   }
   else
-    luaK_S(ls, IFEQJMP, 0, -2);
+    luaK_S(ls, OP_IFEQJMP, 0, -2);
 }
 
 
 static void luaK_neq (LexState *ls) {
   Instruction *previous = previous_instruction(ls);
-  if (*previous == CREATE_U(PUSHNIL, 1)) {
+  if (*previous == CREATE_U(OP_PUSHNIL, 1)) {
     ls->fs->pc--;  /* remove PUSHNIL */
     luaK_deltastack(ls, -1);  /* undo effect of PUSHNIL */
   }
   else
-    luaK_S(ls, IFNEQJMP, 0, -2);
+    luaK_S(ls, OP_IFNEQJMP, 0, -2);
 }
 
 
 void luaK_retcode (LexState *ls, int nlocals, int nexps) {
   Instruction *previous = previous_instruction(ls);
-  if (nexps > 0 && GET_OPCODE(*previous) == CALL) {
+  if (nexps > 0 && GET_OPCODE(*previous) == OP_CALL) {
     LUA_ASSERT(ls->L, GETARG_B(*previous) == MULT_RET, "call should be open");
-    SET_OPCODE(*previous, TAILCALL);
+    SET_OPCODE(*previous, OP_TAILCALL);
     SETARG_B(*previous, nlocals);
   }
   else
-    luaK_primitivecode(ls, CREATE_U(RETCODE, nlocals));
+    luaK_primitivecode(ls, CREATE_U(OP_RETURN, nlocals));
 }
 
 
@@ -138,8 +138,8 @@ static void luaK_pushnil (LexState *ls, int n) {
   Instruction *previous = previous_instruction(ls);
   luaK_deltastack(ls, n);
   switch(GET_OPCODE(*previous)) {
-    case PUSHNIL: SETARG_U(*previous, GETARG_U(*previous)+n); break;
-    default: luaK_primitivecode(ls, CREATE_U(PUSHNIL, n));
+    case OP_PUSHNIL: SETARG_U(*previous, GETARG_U(*previous)+n); break;
+    default: luaK_primitivecode(ls, CREATE_U(OP_PUSHNIL, n));
   }
 }
 
@@ -181,7 +181,7 @@ void luaK_deltastack (LexState *ls, int delta) {
 
 
 void luaK_kstr (LexState *ls, int c) {
-  luaK_U(ls, PUSHSTRING, c, 1);
+  luaK_U(ls, OP_PUSHSTRING, c, 1);
 }
 
 
@@ -189,32 +189,32 @@ void luaK_kstr (LexState *ls, int c) {
 #define LOOKBACKNUMS    20      /* arbitrary limit */
 #endif
 
-static int real_constant (LexState *ls, real r) {
+static int real_constant (LexState *ls, Number r) {
   /* check whether `r' has appeared within the last LOOKBACKNUMS entries */
-  TProtoFunc *f = ls->fs->f;
+  Proto *f = ls->fs->f;
   int c = f->nknum;
   int lim = c < LOOKBACKNUMS ? 0 : c-LOOKBACKNUMS;
   while (--c >= lim)
     if (f->knum[c] == r) return c;
   /* not found; create a new entry */
-  luaM_growvector(ls->L, f->knum, f->nknum, 1, real, constantEM, MAXARG_U);
+  luaM_growvector(ls->L, f->knum, f->nknum, 1, Number, constantEM, MAXARG_U);
   c = f->nknum++;
   f->knum[c] = r;
   return c;
 }
 
 
-void luaK_number (LexState *ls, real f) {
-  if (f <= (real)MAXARG_S && (int)f == f)
-    luaK_S(ls, PUSHINT, (int)f, 1);  /* f has a short integer value */
+void luaK_number (LexState *ls, Number f) {
+  if (f <= (Number)MAXARG_S && (int)f == f)
+    luaK_S(ls, OP_PUSHINT, (int)f, 1);  /* f has a short integer value */
   else
-    luaK_U(ls, PUSHNUM, real_constant(ls, f), 1);
+    luaK_U(ls, OP_PUSHNUM, real_constant(ls, f), 1);
 }
 
 
 void luaK_adjuststack (LexState *ls, int n) {
   if (n > 0)
-    luaK_U(ls, POP, n, -n);
+    luaK_U(ls, OP_POP, n, -n);
   else if (n < 0)
     luaK_pushnil(ls, -n);
 }
@@ -223,7 +223,7 @@ void luaK_adjuststack (LexState *ls, int n) {
 int luaK_lastisopen (LexState *ls) {
   /* check whether last instruction is an (open) function call */
   Instruction *i = previous_instruction(ls);
-  if (GET_OPCODE(*i) == CALL) {
+  if (GET_OPCODE(*i) == OP_CALL) {
     LUA_ASSERT(ls->L, GETARG_B(*i) == MULT_RET, "call should be open");
     return 1;
   }
@@ -233,7 +233,7 @@ int luaK_lastisopen (LexState *ls) {
 
 void luaK_setcallreturns (LexState *ls, int nresults) {
   Instruction *i = previous_instruction(ls);
-  if (GET_OPCODE(*i) == CALL) {  /* expression is a function call? */
+  if (GET_OPCODE(*i) == OP_CALL) {  /* expression is a function call? */
     LUA_ASSERT(ls->L, GETARG_B(*i) == MULT_RET, "call should be open");
     SETARG_B(*i, nresults);  /* set nresults */
     luaK_deltastack(ls, nresults);  /* push results */
@@ -249,10 +249,10 @@ static void assertglobal (LexState *ls, int index) {
 static int discharge (LexState *ls, expdesc *var) {
   switch (var->k) {
     case VLOCAL:
-      luaK_U(ls, PUSHLOCAL, var->u.index, 1);
+      luaK_U(ls, OP_PUSHLOCAL, var->u.index, 1);
       break;
     case VGLOBAL:
-      luaK_U(ls, GETGLOBAL, var->u.index, 1);
+      luaK_U(ls, OP_GETGLOBAL, var->u.index, 1);
       assertglobal(ls, var->u.index);  /* make sure that there is a global */
       break;
     case VINDEXED:
@@ -278,14 +278,14 @@ static void discharge1 (LexState *ls, expdesc *var) {
 void luaK_storevar (LexState *ls, const expdesc *var) {
   switch (var->k) {
     case VLOCAL:
-      luaK_U(ls, SETLOCAL, var->u.index, -1);
+      luaK_U(ls, OP_SETLOCAL, var->u.index, -1);
       break;
     case VGLOBAL:
-      luaK_U(ls, SETGLOBAL, var->u.index, -1);
+      luaK_U(ls, OP_SETGLOBAL, var->u.index, -1);
       assertglobal(ls, var->u.index);  /* make sure that there is a global */
       break;
     case VINDEXED:
-      luaK_0(ls, SETTABLEPOP, -3);
+      luaK_0(ls, OP_SETTABLEPOP, -3);
       break;
     default:
       LUA_INTERNALERROR(ls->L, "invalid var kind to store");
@@ -295,17 +295,17 @@ void luaK_storevar (LexState *ls, const expdesc *var) {
 
 static OpCode invertjump (OpCode op) {
   switch (op) {
-    case IFNEQJMP: return IFEQJMP;
-    case IFEQJMP: return IFNEQJMP;
-    case IFLTJMP: return IFGEJMP;
-    case IFLEJMP: return IFGTJMP;
-    case IFGTJMP: return IFLEJMP;
-    case IFGEJMP: return IFLTJMP;
-    case IFTJMP: case ONTJMP:  return IFFJMP;
-    case IFFJMP: case ONFJMP:  return IFTJMP;
+    case OP_IFNEQJMP: return OP_IFEQJMP;
+    case OP_IFEQJMP: return OP_IFNEQJMP;
+    case OP_IFLTJMP: return OP_IFGEJMP;
+    case OP_IFLEJMP: return OP_IFGTJMP;
+    case OP_IFGTJMP: return OP_IFLEJMP;
+    case OP_IFGEJMP: return OP_IFLTJMP;
+    case OP_IFTJMP: case OP_ONTJMP:  return OP_IFFJMP;
+    case OP_IFFJMP: case OP_ONFJMP:  return OP_IFTJMP;
     default:
       LUA_INTERNALERROR(NULL, "invalid jump instruction");
-      return ENDCODE;  /* to avoid warnings */
+      return OP_END;  /* to avoid warnings */
   }
 }
 
@@ -313,7 +313,7 @@ static OpCode invertjump (OpCode op) {
 static void luaK_jump (LexState *ls, OpCode jump) {
   Instruction *previous = previous_instruction(ls);
   luaK_deltastack(ls, -1);
-  if (*previous == CREATE_0(NOTOP))
+  if (*previous == CREATE_0(OP_NOT))
     *previous = CREATE_S(invertjump(jump), 0);
   else
     luaK_primitivecode(ls, CREATE_S(jump, 0));
@@ -342,10 +342,10 @@ static void luaK_patchlistaux (LexState *ls, int list, int target,
         SETARG_S(*i, special_target-(list+1));
       else {
         SETARG_S(*i, target-(list+1));  /* do the patch */
-        if (op == ONTJMP)  /* remove eventual values */
-          SET_OPCODE(*i, IFTJMP);
-        else if (op == ONFJMP)
-          SET_OPCODE(*i, IFFJMP);
+        if (op == OP_ONTJMP)  /* remove eventual values */
+          SET_OPCODE(*i, OP_IFTJMP);
+        else if (op == OP_ONFJMP)
+          SET_OPCODE(*i, OP_IFFJMP);
       }
       if (next == 0) return;
       list += next+1;
@@ -355,7 +355,7 @@ static void luaK_patchlistaux (LexState *ls, int list, int target,
 
 
 void luaK_patchlist (LexState *ls, int list, int target) {
-  luaK_patchlistaux(ls, list, target, ENDCODE, 0);
+  luaK_patchlistaux(ls, list, target, OP_END, 0);
 }
 
 
@@ -399,7 +399,7 @@ void luaK_goiftrue (LexState *ls, expdesc *v, int keepvalue) {
   if (ISJUMP(GET_OPCODE(*previous)))
     SET_OPCODE(*previous, invertjump(GET_OPCODE(*previous)));
   else {
-    OpCode jump = keepvalue ? ONFJMP : IFFJMP;
+    OpCode jump = keepvalue ? OP_ONFJMP : OP_IFFJMP;
     luaK_jump(ls, jump);
   }
   insert_last(fs, &v->u.l.f);
@@ -414,7 +414,7 @@ void luaK_goiffalse (LexState *ls, expdesc *v, int keepvalue) {
   discharge1(ls, v);
   previous = fs->f->code[fs->pc-1];
   if (!ISJUMP(GET_OPCODE(previous))) {
-    OpCode jump = keepvalue ? ONTJMP : IFTJMP;
+    OpCode jump = keepvalue ? OP_ONTJMP : OP_IFTJMP;
     luaK_jump(ls, jump);
   }
   insert_last(fs, &v->u.l.t);
@@ -440,28 +440,28 @@ void luaK_tostack (LexState *ls, expdesc *v, int onlyone) {
       int final;  /* position after whole expression */
       if (ISJUMP(previous)) {
         insert_last(fs, &v->u.l.t);  /* put `previous' in true list */
-        p_nil = luaK_0(ls, PUSHNILJMP, 0);
-        p_1 = luaK_S(ls, PUSHINT, 1, 1);
+        p_nil = luaK_0(ls, OP_PUSHNILJMP, 0);
+        p_1 = luaK_S(ls, OP_PUSHINT, 1, 1);
       }
       else {  /* still may need a PUSHNIL or a PUSHINT */
-        int need_nil = need_value(fs, v->u.l.f, ONFJMP);
-        int need_1 = need_value(fs, v->u.l.t, ONTJMP);
+        int need_nil = need_value(fs, v->u.l.f, OP_ONFJMP);
+        int need_1 = need_value(fs, v->u.l.t, OP_ONTJMP);
         if (need_nil && need_1) {
-          luaK_S(ls, JMP, 2, 0);  /* skip both pushes */
-          p_nil = luaK_0(ls, PUSHNILJMP, 0);
-          p_1 = luaK_S(ls, PUSHINT, 1, 0);
+          luaK_S(ls, OP_JMP, 2, 0);  /* skip both pushes */
+          p_nil = luaK_0(ls, OP_PUSHNILJMP, 0);
+          p_1 = luaK_S(ls, OP_PUSHINT, 1, 0);
         }
         else if (need_nil || need_1) {
-          luaK_S(ls, JMP, 1, 0);  /* skip one push */
+          luaK_S(ls, OP_JMP, 1, 0);  /* skip one push */
           if (need_nil)
-            p_nil = luaK_U(ls, PUSHNIL, 1, 0);
+            p_nil = luaK_U(ls, OP_PUSHNIL, 1, 0);
           else  /* need_1 */
-            p_1 = luaK_S(ls, PUSHINT, 1, 0);
+            p_1 = luaK_S(ls, OP_PUSHINT, 1, 0);
         }
       }
       final = luaK_getlabel(ls);
-      luaK_patchlistaux(ls, v->u.l.f, p_nil, ONFJMP, final);
-      luaK_patchlistaux(ls, v->u.l.t, p_1, ONTJMP, final);
+      luaK_patchlistaux(ls, v->u.l.f, p_nil, OP_ONFJMP, final);
+      luaK_patchlistaux(ls, v->u.l.t, p_1, OP_ONTJMP, final);
       v->u.l.f = v->u.l.t = 0;
     }
   }
@@ -481,7 +481,7 @@ void luaK_prefix (LexState *ls, int op, expdesc *v) {
     if (ISJUMP(GET_OPCODE(*previous)))
       SET_OPCODE(*previous, invertjump(GET_OPCODE(*previous)));
     else
-      luaK_0(ls, NOTOP, 0);
+      luaK_0(ls, OP_NOT, 0);
     /* interchange true and false lists */
     { int temp = v->u.l.f; v->u.l.f = v->u.l.t; v->u.l.t = temp; }
   }
@@ -489,9 +489,9 @@ void luaK_prefix (LexState *ls, int op, expdesc *v) {
 
 
 void luaK_infix (LexState *ls, int op, expdesc *v) {
-  if (op == AND)
+  if (op == TK_AND)
     luaK_goiftrue(ls, v, 1);
-  else if (op == OR)
+  else if (op == TK_OR)
     luaK_goiffalse(ls, v, 1);
   else
     luaK_tostack(ls, v, 1);  /* all other binary operators need a value */
@@ -499,13 +499,13 @@ void luaK_infix (LexState *ls, int op, expdesc *v) {
 
 
 void luaK_posfix (LexState *ls, int op, expdesc *v1, expdesc *v2) {
-  if (op == AND) {
+  if (op == TK_AND) {
     LUA_ASSERT(ls->L, v1->u.l.t == 0, "list must be closed");
     discharge1(ls, v2);
     v1->u.l.t = v2->u.l.t;
     concatlists(ls, &v1->u.l.f, v2->u.l.f);
   }
-  else if (op == OR) {
+  else if (op == TK_OR) {
     LUA_ASSERT(ls->L, v1->u.l.f == 0, "list must be closed");
     discharge1(ls, v2);
     v1->u.l.f = v2->u.l.f;
@@ -516,16 +516,16 @@ void luaK_posfix (LexState *ls, int op, expdesc *v1, expdesc *v2) {
     switch (op) {
       case '+': luaK_add(ls); break;
       case '-': luaK_sub(ls); break;
-      case '*': luaK_0(ls, MULTOP, -1); break;
-      case '/': luaK_0(ls, DIVOP, -1); break;
-      case '^': luaK_0(ls, POWOP, -1); break;
-      case CONC: luaK_conc(ls); break;
-      case EQ: luaK_eq(ls); break;
-      case NE: luaK_neq(ls); break;
-      case '>': luaK_S(ls, IFGTJMP, 0, -2); break;
-      case '<': luaK_S(ls, IFLTJMP, 0, -2); break;
-      case GE: luaK_S(ls, IFGEJMP, 0, -2); break;
-      case LE: luaK_S(ls, IFLEJMP, 0, -2); break;
+      case '*': luaK_0(ls, OP_MULT, -1); break;
+      case '/': luaK_0(ls, OP_DIV, -1); break;
+      case '^': luaK_0(ls, OP_POW, -1); break;
+      case TK_CONC: luaK_conc(ls); break;
+      case TK_EQ: luaK_eq(ls); break;
+      case TK_NE: luaK_neq(ls); break;
+      case '>': luaK_S(ls, OP_IFGTJMP, 0, -2); break;
+      case '<': luaK_S(ls, OP_IFLTJMP, 0, -2); break;
+      case TK_GE: luaK_S(ls, OP_IFGEJMP, 0, -2); break;
+      case TK_LE: luaK_S(ls, OP_IFLEJMP, 0, -2); break;
     }
   }
 }