Alteracao para retirar codificacao de NOP's, substituindo

pela utilizacao de "union" com "chars" para codificar Word e float.
Observa-se que foram realizados testes antes da alteracao e constatou-se
que do bytecode anteriormente gerado, NOP representava de 10 a 13% do
total de bytes do codigo. Esta percentagem chegava ate' a 20% na caso
de descricao de metafile utilizando Lua.

3 files changed, 193 insertions, 113 deletions

diff --git a/lua.stx b/lua.stx
index 3c2f6efa..d84b82ac 100644
--- a/lua.stx
+++ b/lua.stx
@@ -1,6 +1,6 @@
 %{
 
-char *rcs_luastx = "$Id: lua.stx,v 1.4 1994/02/13 20:38:20 roberto Exp celes $";
+char *rcs_luastx = "$Id: lua.stx,v 1.5 1994/03/28 15:14:54 celes Exp celes $";
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -16,10 +16,6 @@ char *rcs_luastx = "$Id: lua.stx,v 1.4 1994/02/13 20:38:20 roberto Exp celes $";
 
 #define LISTING 0
 
-#ifndef ALIGNMENT
-#define ALIGNMENT       (sizeof(void *))
-#endif
-
 #ifndef MAXCODE
 #define MAXCODE 1024
 #endif
@@ -56,34 +52,30 @@ static void code_byte (Byte c)
  *pc++ = c;
 }
 
-#define align(t,n)  align_n(sizeof(t),n)
-static void align_n (unsigned size, int gap)
+static void code_word (Word n)
 {
- if (size > ALIGNMENT) size = ALIGNMENT;
- while (((pc+gap-code)%size) != 0)      /* +gap to include BYTECODEs */
-  code_byte (NOP);
+ CodeWord code;
+ code.w = n;
+ code_byte(code.m.c1);
+ code_byte(code.m.c2);
 }
 
-static void code_word (Word n)
+static void code_float (float n)
 {
- if (pc-basepc>MAXCODE-sizeof(Word))
- {
-  lua_error ("code buffer overflow");
-  err = 1;
- }
- *((Word *)pc) = n;
- pc += sizeof(Word);
+ CodeFloat code;
+ code.f = n;
+ code_byte(code.m.c1);
+ code_byte(code.m.c2);
+ code_byte(code.m.c3);
+ code_byte(code.m.c4);
 }
 
-static void code_float (float n)
+static void code_word_at (Byte *p, Word n)
 {
- if (pc-basepc>MAXCODE-sizeof(float))
- {
-  lua_error ("code buffer overflow");
-  err = 1;
- }
- *((float *)pc) = n;
- pc += sizeof(float);
+ CodeWord code;
+ code.w = n;
+ *p++ = code.m.c1;
+ *p++ = code.m.c2;
 }
 
 static void push_field (Word name)
@@ -101,7 +93,6 @@ static void flush_record (int n)
 {
   int i;
   if (n == 0) return;
-  align(Word,2);  /* two bytes before the actual word */
   code_byte(STORERECORD);
   code_byte(n);
   for (i=0; i<n; i++)
@@ -168,14 +159,12 @@ static void code_number (float f)
    }
    else
    {
-    align(Word,1);
     code_byte(PUSHWORD);
     code_word(i);
    }
   }
   else
   {
-   align(float,1);
    code_byte(PUSHFLOAT);
    code_float(f);
   }
@@ -229,7 +218,7 @@ functionlist : /* empty */
                 {
                   maincode=pc;
 #if LISTING
- PrintCode(basepc,maincode);
+ PrintCode(basepc,maincode,(Byte*)mainbuffer);
 #endif
                 }
              | functionlist function
@@ -240,7 +229,6 @@ function     : FUNCTION NAME {pc=basepc=code; nlocalvar=0;} '(' parlist ')'
                {
                 if (lua_debug)
                 {
-                 align(Word,1);
                  code_byte(SETFUNCTION); 
                  code_word(lua_nfile-1);
                  code_word($2);
@@ -256,7 +244,7 @@ function     : FUNCTION NAME {pc=basepc=code; nlocalvar=0;} '(' parlist ')'
                 s_bvalue($2) = calloc (pc-code, sizeof(Byte));
                 memcpy (s_bvalue($2), code, (pc-code)*sizeof(Byte));
 #if LISTING
-PrintCode(code,pc);
+PrintCode(code,pc,(Byte*)buffer);
 #endif
                }
                ;
@@ -269,7 +257,7 @@ stat	 : {
             ntemp = 0; 
             if (lua_debug)
             {
-             align(Word,1); code_byte(SETLINE); code_word(lua_linenumber);
+             code_byte(SETLINE); code_word(lua_linenumber);
             }
            }
            stat1
@@ -284,16 +272,15 @@ stat1  : IF expr1 THEN PrepJump block PrepJump elsepart END
          if (pc - elseinit == 0)                /* no else */
          {
           pc -= sizeof(Word)+1;
-         /* if (*(pc-1) == NOP) --pc; */
           elseinit = pc;
          }
          else
          {
           *($6) = JMP;
-          *((Word *)($6+1)) = pc - elseinit;
+          code_word_at($6+1, pc - elseinit);
          }
          *($4) = IFFJMP;
-         *((Word *)($4+1)) = elseinit - ($4 + sizeof(Word)+1);
+         code_word_at($4+1, elseinit - ($4 + sizeof(Word)+1));
         }
        }
      
@@ -301,17 +288,17 @@ stat1  : IF expr1 THEN PrepJump block PrepJump elsepart END
         
        {
         *($5) = IFFJMP;
-        *((Word *)($5+1)) = pc - ($5 + sizeof(Word)+1);
+        code_word_at($5+1, pc - ($5 + sizeof(Word)+1));
         
         *($7) = UPJMP;
-        *((Word *)($7+1)) = pc - $<pByte>2;
+        code_word_at($7+1, pc - $<pByte>2);
        }
      
        | REPEAT {$<pByte>$ = pc;} block UNTIL expr1 PrepJump
         
        {
         *($6) = IFFUPJMP;
-        *((Word *)($6+1)) = pc - $<pByte>2;
+        code_word_at($6+1, pc - $<pByte>2);
        }
 
 
@@ -347,10 +334,10 @@ elsepart : /* empty */
            else
            {
             *($6) = JMP;
-            *((Word *)($6+1)) = pc - elseinit;
+            code_word_at($6+1, pc - elseinit);
            }
            *($4) = IFFJMP;
-           *((Word *)($4+1)) = elseinit - ($4 + sizeof(Word)+1);
+           code_word_at($4+1, elseinit - ($4 + sizeof(Word)+1));
           }  
          }   
          ;
@@ -366,7 +353,7 @@ block    : {$<vInt>$ = nlocalvar;} statlist {ntemp = 0;} ret
          ;
 
 ret     : /* empty */
-        | { if (lua_debug){align(Word,1);code_byte(SETLINE);code_word(lua_linenumber);}}
+        | { if (lua_debug){code_byte(SETLINE);code_word(lua_linenumber);}}
           RETURN  exprlist sc   
           { 
            if (lua_debug) code_byte(RESET); 
@@ -376,7 +363,6 @@ ret	: /* empty */
 
 PrepJump : /* empty */
          { 
-          align(Word,1); 
           $$ = pc;
           code_byte(0);         /* open space */
           code_word (0);
@@ -409,7 +395,6 @@ expr :	'(' expr ')'    { $$ = $2; }
      |  NUMBER          { code_number($1); $$ = 1; }
      |  STRING
      {
-      align(Word,1);
       code_byte(PUSHSTRING);
       code_word($1);
       $$ = 1;
@@ -421,20 +406,20 @@ expr :	'(' expr ')'    { $$ = $2; }
       $$ = 0;
       if (lua_debug)
       {
-       align(Word,1); code_byte(SETLINE); code_word(lua_linenumber);
+       code_byte(SETLINE); code_word(lua_linenumber);
       }
      }
      |  NOT expr1       { code_byte(NOTOP);  $$ = 1;}
      |  expr1 AND PrepJump {code_byte(POP); ntemp--;} expr1
      { 
       *($3) = ONFJMP;
-      *((Word *)($3+1)) = pc - ($3 + sizeof(Word)+1);
+      code_word_at($3+1, pc - ($3 + sizeof(Word)+1));
       $$ = 1;
      }
      |  expr1 OR PrepJump {code_byte(POP); ntemp--;} expr1      
      { 
       *($3) = ONTJMP;
-      *((Word *)($3+1)) = pc - ($3 + sizeof(Word)+1);
+      code_word_at($3+1, pc - ($3 + sizeof(Word)+1));
       $$ = 1;
      }
      ;
@@ -465,7 +450,7 @@ typeconstructor: '@'
        $$ = 0;
        if (lua_debug)
        {
-        align(Word,1); code_byte(SETLINE); code_word(lua_linenumber);
+        code_byte(SETLINE); code_word(lua_linenumber);
        }
       }
      }
@@ -566,7 +551,6 @@ var	  :	NAME
           }
           |     var {lua_pushvar ($1);} '.' NAME
           {
-           align(Word,1);
            code_byte(PUSHSTRING);
            code_word(lua_findconstant (s_name($4))); incr_ntemp();
            $$ = 0;              /* indexed variable */
@@ -605,7 +589,6 @@ static void lua_pushvar (long number)
 { 
  if (number > 0)        /* global var */
  {
-  align(Word,1);
   code_byte(PUSHGLOBAL);
   code_word(number-1);
   incr_ntemp();
@@ -638,7 +621,6 @@ static void lua_codestore (int i)
 {
  if (varbuffer[i] > 0)          /* global var */
  {
-  align(Word,1);
   code_byte(STOREGLOBAL);
   code_word(varbuffer[i]-1);
  }
@@ -703,14 +685,13 @@ int lua_parse (void)
 
 #if LISTING
 
-static void PrintCode (Byte *p, Byte *end)
+static void PrintCode (Byte *p, Byte *end, Byte *code)
 {
  printf ("\n\nCODE\n");
  while (p != end)
  {
   switch ((OpCode)*p)
   {
-   case NOP:            printf ("%d    NOP\n", (p++)-code); break;
    case PUSHNIL:        printf ("%d    PUSHNIL\n", (p++)-code); break;
    case PUSH0: case PUSH1: case PUSH2:
                         printf ("%d    PUSH%c\n", p-code, *p-PUSH0+'0');
@@ -721,16 +702,31 @@ static void PrintCode (Byte *p, Byte *end)
                         p++;
                         break;
    case PUSHWORD:
-                        printf ("%d    PUSHWORD   %d\n", p-code, *((Word *)(p+1)));
-                        p += 1 + sizeof(Word);
+                        {
+                         CodeWord c;
+                         int n = p-code;
+                         p++;
+                         get_word(c,p);
+                         printf ("%d    PUSHWORD   %d\n", n, c.w);
+                        }
                         break;
    case PUSHFLOAT:
-                        printf ("%d    PUSHFLOAT  %f\n", p-code, *((float *)(p+1)));
-                        p += 1 + sizeof(float);
+                        {
+                         CodeFloat c;
+                         int n = p-code;
+                         p++;
+                         get_float(c,p);
+                         printf ("%d    PUSHFLOAT  %f\n", n, c.f);
+                        }
                         break;
    case PUSHSTRING:
-                        printf ("%d    PUSHSTRING   %d\n", p-code, *((Word *)(p+1)));
-                        p += 1 + sizeof(Word);
+                        {
+                         CodeWord c;
+                         int n = p-code;
+                         p++;
+                         get_word(c,p);
+                         printf ("%d    PUSHSTRING   %d\n", n, c.w);
+                        }
                         break;
    case PUSHLOCAL0: case PUSHLOCAL1: case PUSHLOCAL2: case PUSHLOCAL3:
    case PUSHLOCAL4: case PUSHLOCAL5: case PUSHLOCAL6: case PUSHLOCAL7:
@@ -742,8 +738,13 @@ static void PrintCode (Byte *p, Byte *end)
                         p++;
                         break;
    case PUSHGLOBAL:
-                        printf ("%d    PUSHGLOBAL   %d\n", p-code, *((Word *)(p+1)));
-                        p += 1 + sizeof(Word);
+                        {
+                         CodeWord c;
+                         int n = p-code;
+                         p++;
+                         get_word(c,p);
+                         printf ("%d    PUSHGLOBAL   %d\n", n, c.w);
+                        }
                         break;
    case PUSHINDEXED:    printf ("%d    PUSHINDEXED\n", (p++)-code); break;
    case PUSHMARK:       printf ("%d    PUSHMARK\n", (p++)-code); break;
@@ -759,8 +760,13 @@ static void PrintCode (Byte *p, Byte *end)
                         p++;
                         break;
    case STOREGLOBAL:
-                        printf ("%d    STOREGLOBAL   %d\n", p-code, *((Word *)(p+1)));
-                        p += 1 + sizeof(Word);
+                        {
+                         CodeWord c;
+                         int n = p-code;
+                         p++;
+                         get_word(c,p);
+                         printf ("%d    STOREGLOBAL   %d\n", n, c.w);
+                        }
                         break;
    case STOREINDEXED0:  printf ("%d    STOREINDEXED0\n", (p++)-code); break;
    case STOREINDEXED:   printf ("%d    STOREINDEXED   %d\n", p-code, *(++p));
@@ -794,28 +800,58 @@ static void PrintCode (Byte *p, Byte *end)
    case MINUSOP:        printf ("%d    MINUSOP\n", (p++)-code); break;
    case NOTOP:          printf ("%d    NOTOP\n", (p++)-code); break;
    case ONTJMP:    
-                        printf ("%d    ONTJMP  %d\n", p-code, *((Word *)(p+1)));
-                        p += sizeof(Word) + 1;
+                        {
+                         CodeWord c;
+                         int n = p-code;
+                         p++;
+                         get_word(c,p);
+                         printf ("%d    ONTJMP  %d\n", n, c.w);
+                        }
                         break;
    case ONFJMP:    
-                        printf ("%d    ONFJMP  %d\n", p-code, *((Word *)(p+1)));
-                        p += sizeof(Word) + 1;
+                        {
+                         CodeWord c;
+                         int n = p-code;
+                         p++;
+                         get_word(c,p);
+                         printf ("%d    ONFJMP  %d\n", n, c.w);
+                        }
                         break;
    case JMP:       
-                        printf ("%d    JMP  %d\n", p-code, *((Word *)(p+1)));
-                        p += sizeof(Word) + 1;
+                        {
+                         CodeWord c;
+                         int n = p-code;
+                         p++;
+                         get_word(c,p);
+                         printf ("%d    JMP  %d\n", n, c.w);
+                        }
                         break;
    case UPJMP:
-                        printf ("%d    UPJMP  %d\n", p-code, *((Word *)(p+1)));
-                        p += sizeof(Word) + 1;
+                        {
+                         CodeWord c;
+                         int n = p-code;
+                         p++;
+                         get_word(c,p);
+                         printf ("%d    UPJMP  %d\n", n, c.w);
+                        }
                         break;
    case IFFJMP:
-                        printf ("%d    IFFJMP  %d\n", p-code, *((Word *)(p+1)));
-                        p += sizeof(Word) + 1;
+                        {
+                         CodeWord c;
+                         int n = p-code;
+                         p++;
+                         get_word(c,p);
+                         printf ("%d    IFFJMP  %d\n", n, c.w);
+                        }
                         break;
    case IFFUPJMP:
-                        printf ("%d    IFFUPJMP  %d\n", p-code, *((Word *)(p+1)));
-                        p += sizeof(Word) + 1;
+                        {
+                         CodeWord c;
+                         int n = p-code;
+                         p++;
+                         get_word(c,p);
+                         printf ("%d    IFFUPJMP  %d\n", n, c.w);
+                        }
                         break;
    case POP:            printf ("%d    POP\n", (p++)-code); break;
    case CALLFUNC:       printf ("%d    CALLFUNC\n", (p++)-code); break;
@@ -823,7 +859,7 @@ static void PrintCode (Byte *p, Byte *end)
                         printf ("%d    RETCODE   %d\n", p-code, *(++p));
                         p++;
                         break;
-   default:             printf ("%d    Cannot happen\n", (p++)-code); break;
+   default:             printf ("%d    Cannot happen: code %d\n", (p++)-code, *(p-1)); break;
   }
  }
 }
diff --git a/opcode.c b/opcode.c
index 5fc75b5c..aaf38b51 100644
--- a/opcode.c
+++ b/opcode.c
@@ -3,7 +3,7 @@
 ** TecCGraf - PUC-Rio
 */
 
-char *rcs_opcode="$Id: opcode.c,v 1.2 1994/02/13 20:36:51 roberto Exp celes $";
+char *rcs_opcode="$Id: opcode.c,v 1.3 1994/03/28 15:14:02 celes Exp celes $";
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -147,8 +147,6 @@ int lua_execute (Byte *pc)
   OpCode opcode;
   switch (opcode = (OpCode)*pc++)
   {
-   case NOP: break;
-   
    case PUSHNIL: tag(top++) = T_NIL; break;
    
    case PUSH0: tag(top) = T_NUMBER; nvalue(top++) = 0; break;
@@ -158,17 +156,26 @@ int lua_execute (Byte *pc)
    case PUSHBYTE: tag(top) = T_NUMBER; nvalue(top++) = *pc++; break;
    
    case PUSHWORD: 
-    tag(top) = T_NUMBER; nvalue(top++) = *((Word *)(pc)); pc += sizeof(Word);
+   {
+    CodeWord code;
+    get_word(code,pc);
+    tag(top) = T_NUMBER; nvalue(top++) = code.w;
+   }
    break;
    
    case PUSHFLOAT:
-    tag(top) = T_NUMBER; nvalue(top++) = *((float *)(pc)); pc += sizeof(float);
+   {
+    CodeFloat code;
+    get_float(code,pc);
+    tag(top) = T_NUMBER; nvalue(top++) = code.f;
+   }
    break;
+
    case PUSHSTRING:
    {
-    int w = *((Word *)(pc));
-    pc += sizeof(Word);
-    tag(top) = T_STRING; svalue(top++) = lua_constant[w];
+    CodeWord code;
+    get_word(code,pc);
+    tag(top) = T_STRING; svalue(top++) = lua_constant[code.w];
    }
    break;
    
@@ -180,7 +187,11 @@ int lua_execute (Byte *pc)
    case PUSHLOCAL: *top++ = *(base + (*pc++)); break;
    
    case PUSHGLOBAL: 
-    *top++ = s_object(*((Word *)(pc))); pc += sizeof(Word);
+   {
+    CodeWord code;
+    get_word(code,pc);
+    *top++ = s_object(code.w);
+   }
    break;
    
    case PUSHINDEXED:
@@ -209,7 +220,11 @@ int lua_execute (Byte *pc)
    case STORELOCAL: *(base + (*pc++)) = *(--top); break;
    
    case STOREGLOBAL:
-    s_object(*((Word *)(pc))) = *(--top); pc += sizeof(Word);
+   {
+    CodeWord code;
+    get_word(code,pc);
+    s_object(code.w) = *(--top);
+   }
    break;
 
    case STOREINDEXED0:
@@ -278,9 +293,9 @@ int lua_execute (Byte *pc)
     }
     while (n)
     {
-     int w = *((Word *)(pc));
-     pc += sizeof(Word);
-     tag(top) = T_STRING; svalue(top) = lua_constant[w];
+     CodeWord code;
+     get_word(code,pc);
+     tag(top) = T_STRING; svalue(top) = lua_constant[code.w];
      *(lua_hashdefine (avalue(arr), top)) = *(top-1);
      top--;
      n--;
@@ -438,39 +453,51 @@ int lua_execute (Byte *pc)
    
    case ONTJMP:
    {
-    int n = *((Word *)(pc));
-    pc += sizeof(Word);
-    if (tag(top-1) != T_NIL) pc += n;
+    CodeWord code;
+    get_word(code,pc);
+    if (tag(top-1) != T_NIL) pc += code.w;
    }
    break;
    
    case ONFJMP:    
    {
-    int n = *((Word *)(pc));
-    pc += sizeof(Word);
-    if (tag(top-1) == T_NIL) pc += n;
+    CodeWord code;
+    get_word(code,pc);
+    if (tag(top-1) == T_NIL) pc += code.w;
    }
    break;
    
-   case JMP: pc += *((Word *)(pc)) + sizeof(Word); break;
+   case JMP:
+   {
+    CodeWord code;
+    get_word(code,pc);
+    pc += code.w;
+   }
+   break;
     
-   case UPJMP: pc -= *((Word *)(pc)) - sizeof(Word); break; 
+   case UPJMP:
+   {
+    CodeWord code;
+    get_word(code,pc);
+    pc -= code.w;
+   }
+   break;
    
    case IFFJMP:
    {
-    int n = *((Word *)(pc));
-    pc += sizeof(Word);
+    CodeWord code;
+    get_word(code,pc);
     top--;
-    if (tag(top) == T_NIL) pc += n;
+    if (tag(top) == T_NIL) pc += code.w;
    }
    break;
 
    case IFFUPJMP:
    {
-    int n = *((Word *)(pc));
-    pc += sizeof(Word);
+    CodeWord code;
+    get_word(code,pc);
     top--;
-    if (tag(top) == T_NIL) pc -= n;
+    if (tag(top) == T_NIL) pc -= code.w;
    }
    break;
 
@@ -547,19 +574,20 @@ int lua_execute (Byte *pc)
    
    case SETFUNCTION:
    {
-    int file, func;
-    file = *((Word *)(pc));
-    pc += sizeof(Word);
-    func = *((Word *)(pc));
-    pc += sizeof(Word);
-    if (lua_pushfunction (file, func))
+    CodeWord file, func;
+    get_word(file,pc);
+    get_word(func,pc);
+    if (lua_pushfunction (file.w, func.w))
      return 1;
    }
    break;
    
    case SETLINE:
-    lua_debugline = *((Word *)(pc));
-    pc += sizeof(Word);
+   {
+    CodeWord code;
+    get_word(code,pc);
+    lua_debugline = code.w;
+   }
    break;
    
    case RESET:
diff --git a/opcode.h b/opcode.h
index 8139f9c8..f48e50fd 100644
--- a/opcode.h
+++ b/opcode.h
@@ -1,6 +1,6 @@
 /*
 ** TeCGraf - PUC-Rio
-** $Id: opcode.h,v 1.2 1993/12/22 21:15:16 roberto Exp roberto $
+** $Id: opcode.h,v 1.3 1994/02/13 20:35:53 roberto Exp celes $
 */
 
 #ifndef opcode_h
@@ -20,9 +20,20 @@ typedef unsigned char  Byte;
 
 typedef unsigned short Word;
 
+typedef union
+{
+ struct {char c1; char c2;} m;
+ Word w;
+} CodeWord;
+
+typedef union
+{
+ struct {char c1; char c2; char c3; char c4;} m;
+ float f;
+} CodeFloat;
+
 typedef enum 
 { 
- NOP,
  PUSHNIL,
  PUSH0, PUSH1, PUSH2,
  PUSHBYTE,
@@ -129,6 +140,11 @@ typedef struct
 #define s_fvalue(i)     (fvalue(&s_object(i)))
 #define s_uvalue(i)     (uvalue(&s_object(i)))
 
+#define get_word(code,pc)    {code.m.c1 = *pc++; code.m.c2 = *pc++;}
+#define get_float(code,pc)   {code.m.c1 = *pc++; code.m.c2 = *pc++;\
+                              code.m.c3 = *pc++; code.m.c4 = *pc++;}
+ 
+
 
 /* Exported functions */
 int     lua_execute   (Byte *pc);