using "zio" for parsing Lua code.

1 files changed, 51 insertions, 54 deletions

diff --git a/undump.c b/undump.c
index 4f1570eb..6fb16117 100644
--- a/undump.c
+++ b/undump.c
@@ -3,7 +3,7 @@
 ** load bytecodes from files
 */
 
-char* rcs_undump="$Id: undump.c,v 1.21 1996/11/18 11:18:29 lhf Exp lhf $";
+char* rcs_undump="$Id: undump.c,v 1.24 1997/06/13 11:08:47 lhf Exp $";
 
 #include <stdio.h>
 #include <string.h>
@@ -12,6 +12,7 @@ char* rcs_undump="$Id: undump.c,v 1.21 1996/11/18 11:18:29 lhf Exp lhf $";
 #include "luamem.h"
 #include "table.h"
 #include "undump.h"
+#include "zio.h"
 
 static int swapword=0;
 static int swapfloat=0;
@@ -147,10 +148,10 @@ static void Unthread(Byte* code, int i, int v)
  }
 }
 
-static int LoadWord(FILE* D)
+static int LoadWord(ZIO* Z)
 {
  Word w;
- fread(&w,sizeof(w),1,D);
+ zread(Z,&w,sizeof(w));
  if (swapword)
  {
   Byte* p=(Byte*)&w;
@@ -160,101 +161,101 @@ static int LoadWord(FILE* D)
  return w;
 }
 
-static int LoadSize(FILE* D)
+static int LoadSize(ZIO* Z)
 {
- Word hi=LoadWord(D);
- Word lo=LoadWord(D);
+ Word hi=LoadWord(Z);
+ Word lo=LoadWord(Z);
  int s=(hi<<16)|lo;
  if ((Word)s != s) lua_error("code too long");
  return s;
 }
 
-static void* LoadBlock(int size, FILE* D)
+static void* LoadBlock(int size, ZIO* Z)
 {
  void* b=luaI_malloc(size);
- fread(b,size,1,D);
+ zread(Z,b,size);
  return b;
 }
 
-static char* LoadString(FILE* D)
+static char* LoadString(ZIO* Z)
 {
- int size=LoadWord(D);
+ int size=LoadWord(Z);
  char *b=luaI_buffer(size);
- fread(b,size,1,D);
+ zread(Z,b,size);
  return b;
 }
 
-static char* LoadNewString(FILE* D)
+static char* LoadNewString(ZIO* Z)
 {
- return LoadBlock(LoadWord(D),D);
+ return LoadBlock(LoadWord(Z),Z);
 }
 
-static void LoadFunction(FILE* D)
+static void LoadFunction(ZIO* Z)
 {
  TFunc* tf=new(TFunc);
  tf->next=NULL;
  tf->locvars=NULL;
- tf->size=LoadSize(D);
- tf->lineDefined=LoadWord(D);
+ tf->size=LoadSize(Z);
+ tf->lineDefined=LoadWord(Z);
  if (IsMain(tf))                                /* new main */
  {
-  tf->fileName=LoadNewString(D);
+  tf->fileName=LoadNewString(Z);
   Main=lastF=tf;
  }
  else                                           /* fix PUSHFUNCTION */
  {
-  tf->marked=LoadWord(D);
+  tf->marked=LoadWord(Z);
   tf->fileName=Main->fileName;
   memcpy(Main->code+tf->marked,&tf,sizeof(tf));
   lastF=lastF->next=tf;
  }
- tf->code=LoadBlock(tf->size,D);
+ tf->code=LoadBlock(tf->size,Z);
  if (swapword || swapfloat) FixCode(tf->code,tf->code+tf->size);
  while (1)                                      /* unthread */
  {
-  int c=getc(D);
+  int c=zgetc(Z);
   if (c==ID_VAR)                                /* global var */
   {
-   int i=LoadWord(D);
-   char* s=LoadString(D);
+   int i=LoadWord(Z);
+   char* s=LoadString(Z);
    int v=luaI_findsymbolbyname(s);
    Unthread(tf->code,i,v);
   }
   else if (c==ID_STR)                           /* constant string */
   {
-   int i=LoadWord(D);
-   char* s=LoadString(D);
+   int i=LoadWord(Z);
+   char* s=LoadString(Z);
    int v=luaI_findconstantbyname(s);
    Unthread(tf->code,i,v);
   }
   else
   {
-   ungetc(c,D);
+   zungetc(Z);
    break;
   }
  }
 }
 
-static void LoadSignature(FILE* D)
+static void LoadSignature(ZIO* Z)
 {
  char* s=SIGNATURE;
- while (*s!=0 && getc(D)==*s)
+ while (*s!=0 && zgetc(Z)==*s)
   ++s;
  if (*s!=0) lua_error("cannot load binary file: bad signature");
 }
 
-static void LoadHeader(FILE* D)
+static void LoadHeader(ZIO* Z)
 {
  Word w,tw=TEST_WORD;
  float f,tf=TEST_FLOAT;
  int version;
- LoadSignature(D);
- version=getc(D);
+ LoadSignature(Z);
+ version=zgetc(Z);
  if (version>0x23)                              /* after 2.5 */
  {
-  int oldsizeofW=getc(D);
-  int oldsizeofF=getc(D);
-  int oldsizeofP=getc(D);
+  int oldsizeofW=zgetc(Z);
+  int oldsizeofF=zgetc(Z);
+  int oldsizeofP=zgetc(Z);
   if (oldsizeofW!=2)
    luaL_verror(
         "cannot load binary file created on machine with sizeof(Word)=%d; "
@@ -266,14 +267,14 @@ static void LoadHeader(FILE* D)
   if (oldsizeofP!=sizeof(TFunc*))               /* TODO: pack? */
    luaL_verror(
         "cannot load binary file created on machine with sizeof(TFunc*)=%d; "
-        "expected %d",oldsizeofP,sizeof(TFunc*));
+        "expected %d",oldsizeofP,(int)sizeof(TFunc*));
  }
- fread(&w,sizeof(w),1,D);                       /* test word */
+ zread(Z,&w,sizeof(w));                 /* test word */
  if (w!=tw)
  {
   swapword=1;
  }
- fread(&f,sizeof(f),1,D);                       /* test float */
+ zread(Z,&f,sizeof(f));                 /* test float */
  if (f!=tf)
  {
   Byte* p=(Byte*)&f;
@@ -286,13 +287,13 @@ static void LoadHeader(FILE* D)
  }
 }
 
-static void LoadChunk(FILE* D)
+static void LoadChunk(ZIO* Z)
 {
- LoadHeader(D);
+ LoadHeader(Z);
  while (1)
  {
-  int c=getc(D);
-  if (c==ID_FUN) LoadFunction(D); else { ungetc(c,D); break; }
+  int c=zgetc(Z);
+  if (c==ID_FUN) LoadFunction(Z); else { zungetc(Z); break; }
  }
 }
 
@@ -300,30 +301,26 @@ static void LoadChunk(FILE* D)
 ** load one chunk from a file.
 ** return list of functions found, headed by main, or NULL at EOF.
 */
-TFunc* luaI_undump1(FILE* D)
+static TFunc* luaI_undump1(ZIO* Z)
 {
- while (1)
+ int c=zgetc(Z);
+ if (c==ID_CHUNK)
  {
-  int c=getc(D);
-  if (c==ID_CHUNK)
-  {
-   LoadChunk(D);
-   return Main;
-  }
-  else if (c==EOF)
-   return NULL;
-  else
-   lua_error("not a lua binary file");
+  LoadChunk(Z);
+  return Main;
  }
+ else if (c!=EOZ)
+   lua_error("not a lua binary file");
+ return NULL;
 }
 
 /*
 ** load and run all chunks in a file
 */
-int luaI_undump(FILE* D)
+int luaI_undump(ZIO* Z)
 {
  TFunc* m;
- while ((m=luaI_undump1(D)))
+ while ((m=luaI_undump1(Z)))
  {
   int status=luaI_dorun(m);
   luaI_freefunc(m);