changes by lhf

lundump.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lundump.c,v 1.4 1998/01/13 20:05:24 lhf Exp $
+** $Id: lundump.c,v 1.7 1998/03/05 15:45:08 lhf Exp lhf $
 ** load bytecodes from files
 ** See Copyright Notice in lua.h
 */
@@ -11,15 +11,31 @@
 #include "lstring.h"
 #include "lundump.h"
 
-typedef struct {
- ZIO* Z;
- int SwapNumber;
- int LoadFloat;
-} Sundump;
+#define	LoadBlock(b,size,Z)	ezread(Z,b,size)
+#define	LoadNative(t,D)		LoadBlock(&t,sizeof(t),D)
+
+/* LUA_NUMBER */
+/* if you change the definition of real, make sure you set ID_NUMBER
+* accordingly lundump.h, specially if sizeof(long)!=4.
+* for types other than the ones listed below, you'll have to write your own
+* dump and undump routines.
+*/
+
+#if ID_NUMBER==ID_REAL4
+	#define	LoadNumber	LoadFloat
+#elif ID_NUMBER==ID_REAL8
+	#define	LoadNumber	LoadDouble
+#elif ID_NUMBER==ID_INT4
+	#define	LoadNumber	LoadLong
+#elif ID_NUMBER==ID_NATIVE
+	#define	LoadNumber	LoadNative
+#else
+	#define	LoadNumber	LoadWhat
+#endif
 
 static void unexpectedEOZ(ZIO* Z)
 {
- luaL_verror("unexpected end of binary file %s",Z->name);
+ luaL_verror("unexpected end of file in %s",zname(Z));
 }
 
 static int ezgetc(ZIO* Z)
@@ -29,91 +45,77 @@ static int ezgetc(ZIO* Z)
  return c;
 }
 
-static int ezread(ZIO* Z, void* b, int n)
+static void ezread(ZIO* Z, void* b, int n)
 {
  int r=zread(Z,b,n);
  if (r!=0) unexpectedEOZ(Z);
- return r;
 }
 
-static int LoadWord(ZIO* Z)
+static unsigned int LoadWord(ZIO* Z)
 {
- int hi=ezgetc(Z);
- int lo=ezgetc(Z);
+ unsigned int hi=ezgetc(Z);
+ unsigned int lo=ezgetc(Z);
  return (hi<<8)|lo;
 }
 
-static void* LoadBlock(int size, ZIO* Z)
+static unsigned long LoadLong(ZIO* Z)
 {
- void* b=luaM_malloc(size);
- ezread(Z,b,size);
- return b;
+ unsigned long hi=LoadWord(Z);
+ unsigned long lo=LoadWord(Z);
+ return (hi<<16)|lo;
 }
 
-static int LoadSize(ZIO* Z)
+/* LUA_NUMBER */
+/* assumes sizeof(long)==4 and sizeof(float)==4 (IEEE) */
+static float LoadFloat(ZIO* Z)
 {
- int hi=LoadWord(Z);
- int lo=LoadWord(Z);
- int s=(hi<<16)|lo;
- if (hi!=0 && s==lo)
-  luaL_verror("code too long (%ld bytes)",(hi<<16)|(long)lo);
- return s;
+ long l=LoadLong(Z);
+ float f=*(float*)&l;
+ return f;
 }
 
-static char* LoadString(ZIO* Z)
+/* LUA_NUMBER */
+/* assumes sizeof(long)==4 and sizeof(double)==8 (IEEE) */
+static double LoadDouble(ZIO* Z)
 {
- int size=LoadWord(Z);
- if (size==0)
-  return NULL;
- else
+ long l[2];
+ double f;
+ int x=1;
+ if (*(char*)&x==1)			/* little-endian */
  {
-  char* b=luaL_openspace(size);
-  ezread(Z,b,size);
-  return b;
+  l[1]=LoadLong(Z);
+  l[0]=LoadLong(Z);
  }
+ else					/* big-endian */
+ {
+  l[0]=LoadLong(Z);
+  l[1]=LoadLong(Z);
+ }
+ f=*(double*)l;
+ return f;
 }
 
-static TaggedString* LoadTString(ZIO* Z)
-{
- char* s=LoadString(Z);
- return (s==NULL) ? NULL : luaS_new(s);
-}
-
-static void SwapFloat(float* f)
-{
- Byte* p=(Byte*)f;
- Byte* q=p+sizeof(float)-1;
- Byte t;
- t=*p; *p++=*q; *q--=t;
- t=*p; *p++=*q; *q--=t;
-}
-
-static void SwapDouble(double* f)
+static Byte* LoadCode(ZIO* Z)
 {
- Byte* p=(Byte*)f;
- Byte* q=p+sizeof(double)-1;
- Byte t;
- t=*p; *p++=*q; *q--=t;
- t=*p; *p++=*q; *q--=t;
- t=*p; *p++=*q; *q--=t;
- t=*p; *p++=*q; *q--=t;
+ long size=LoadLong(Z);
+ unsigned int s=size;
+ void* b;
+ if (s!=size) luaL_verror("code too long (%ld bytes) in %s",size,zname(Z));
+ b=luaM_malloc(size);
+ LoadBlock(b,size,Z);
+ return b;
 }
 
-static real LoadNumber(Sundump* S)
+static TaggedString* LoadTString(ZIO* Z)
 {
- if (S->LoadFloat)
- {
-  float f;
-  ezread(S->Z,&f,sizeof(f));
-  if (S->SwapNumber) SwapFloat(&f);
-  return f;
- }
+ int size=LoadWord(Z);
+ if (size==0)
+  return NULL;
  else
  {
-  double f;
-  ezread(S->Z,&f,sizeof(f));
-  if (S->SwapNumber) SwapDouble(&f);
-  return f;
+  char* s=luaL_openspace(size);
+  LoadBlock(s,size,Z);
+  return luaS_newlstr(s,size-1);
  }
 }
 
@@ -131,63 +133,51 @@ static void LoadLocals(TProtoFunc* tf, ZIO* Z)
  tf->locvars[i].varname=NULL;
 }
 
-static void LoadConstants(TProtoFunc* tf, Sundump* S)
+static TProtoFunc* LoadFunction(ZIO* Z);
+
+static void LoadConstants(TProtoFunc* tf, ZIO* Z)
 {
- int i,n=LoadWord(S->Z);
+ int i,n=LoadWord(Z);
  tf->nconsts=n;
  if (n==0) return;
  tf->consts=luaM_newvector(n,TObject);
  for (i=0; i<n; i++)
  {
   TObject* o=tf->consts+i;
-  int c=ezgetc(S->Z);
+  int c=ezgetc(Z);
   switch (c)
   {
    case ID_NUM:
 	ttype(o)=LUA_T_NUMBER;
-	nvalue(o)=LoadNumber(S);
+#if ID_NUMBER==ID_NATIVE
+	LoadNative(nvalue(o),Z)
+#else
+	nvalue(o)=LoadNumber(Z);
+#endif
 	break;
    case ID_STR:
 	ttype(o)=LUA_T_STRING;	
-	tsvalue(o)=LoadTString(S->Z);
+	tsvalue(o)=LoadTString(Z);
 	break;
    case ID_FUN:
 	ttype(o)=LUA_T_PROTO;
-	tfvalue(o)=NULL;
+	tfvalue(o)=LoadFunction(Z);
 	break;
-#ifdef DEBUG
-   default:				/* cannot happen */
-	luaL_verror("internal error in LoadConstants: "
-		"bad constant #%d type=%d ('%c')\n",i,c,c);
+   default:
+	luaL_verror("bad constant #%d in %s: type=%d ('%c')",i,zname(Z),c,c);
 	break;
-#endif
   }
  }
 }
 
-static TProtoFunc* LoadFunction(Sundump* S);
-
-static void LoadFunctions(TProtoFunc* tf, Sundump* S)
-{
- while (zgetc(S->Z)==ID_FUNCTION)
- {
-  int i=LoadWord(S->Z); 
-  TProtoFunc* t=LoadFunction(S);
-  TObject* o=tf->consts+i;
-  tfvalue(o)=t;
- }
-}
-
-static TProtoFunc* LoadFunction(Sundump* S)
+static TProtoFunc* LoadFunction(ZIO* Z)
 {
- ZIO* Z=S->Z;
  TProtoFunc* tf=luaF_newproto();
  tf->lineDefined=LoadWord(Z);
  tf->fileName=LoadTString(Z);
- tf->code=LoadBlock(LoadSize(Z),Z);
- LoadConstants(tf,S);
+ tf->code=LoadCode(Z);
  LoadLocals(tf,Z);
- LoadFunctions(tf,S);
+ LoadConstants(tf,Z);
  return tf;
 }
 
@@ -196,61 +186,42 @@ static void LoadSignature(ZIO* Z)
  char* s=SIGNATURE;
  while (*s!=0 && ezgetc(Z)==*s)
   ++s;
- if (*s!=0) luaL_verror("bad signature in binary file %s",Z->name);
+ if (*s!=0) luaL_verror("bad signature in %s",zname(Z));
 }
 
-static void LoadHeader(Sundump* S)
+static void LoadHeader(ZIO* Z)
 {
- ZIO* Z=S->Z;
- int version,sizeofR;
+ int version,id,sizeofR;
+ real f=-TEST_NUMBER,tf=TEST_NUMBER;
  LoadSignature(Z);
  version=ezgetc(Z);
  if (version>VERSION)
   luaL_verror(
-	"binary file %s too new: version=0x%02x; expected at most 0x%02x",
-	Z->name,version,VERSION);
+	"%s too new: version=0x%02x; expected at most 0x%02x",
+	zname(Z),version,VERSION);
  if (version<0x31)			/* major change in 3.1 */
   luaL_verror(
-	"binary file %s too old: version=0x%02x; expected at least 0x%02x",
-	Z->name,version,0x31);
- sizeofR=ezgetc(Z);			/* test float representation */
- if (sizeofR==sizeof(float))
+	"%s too old: version=0x%02x; expected at least 0x%02x",
+	zname(Z),version,0x31);
+ id=ezgetc(Z);				/* test number representation */
+ sizeofR=ezgetc(Z);
+ if (id!=ID_NUMBER || sizeofR!=sizeof(real))
  {
-  float f,tf=TEST_FLOAT;
-  ezread(Z,&f,sizeof(f));
-  if (f!=tf)
-  {
-   SwapFloat(&f);
-   if (f!=tf)
-    luaL_verror("unknown float representation in binary file %s",Z->name);
-   S->SwapNumber=1;
-  }
-  S->LoadFloat=1;
+  luaL_verror("unknown number representation in %s: "
+	"read 0x%02x %d; expected 0x%02x %d",
+	zname(Z),id,sizeofR,ID_NUMBER,sizeof(real));
  }
- else if (sizeofR==sizeof(double))
- {
-  double f,tf=TEST_FLOAT;
-  ezread(Z,&f,sizeof(f));
-  if (f!=tf)
-  {
-   SwapDouble(&f);
-   if (f!=tf)
-    luaL_verror("unknown float representation in binary file %s",Z->name);
-   S->SwapNumber=1;
-  }
-  S->LoadFloat=0;
- }
- else
-  luaL_verror(
-       "floats in binary file %s have %d bytes; "
-       "expected %d (float) or %d (double)",
-       Z->name,sizeofR,sizeof(float),sizeof(double));
+ f=LoadNumber(Z);
+ if (f!=tf)
+  luaL_verror("unknown number representation in %s: "
+	"read %g; expected %g",		/* LUA_NUMBER */
+	zname(Z),(double)f,(double)tf);
 }
 
-static TProtoFunc* LoadChunk(Sundump* S)
+static TProtoFunc* LoadChunk(ZIO* Z)
 {
- LoadHeader(S);
- return LoadFunction(S);
+ LoadHeader(Z);
+ return LoadFunction(Z);
 }
 
 /*
@@ -260,13 +231,9 @@ static TProtoFunc* LoadChunk(Sundump* S)
 TProtoFunc* luaU_undump1(ZIO* Z)
 {
  int c=zgetc(Z);
- Sundump S;
- S.Z=Z;
- S.SwapNumber=0;
- S.LoadFloat=1;
  if (c==ID_CHUNK)
-  return LoadChunk(&S);
+  return LoadChunk(Z);
  else if (c!=EOZ)
-  luaL_verror("%s is not a lua binary file",Z->name);
+  luaL_verror("%s is not a Lua binary file",zname(Z));
  return NULL;
 }

lundump.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lundump.h,v 1.4 1998/01/13 20:05:24 lhf Exp $
+** $Id: lundump.h,v 1.5 1998/02/06 20:05:39 lhf Exp lhf $
 ** load pre-compiled Lua chunks
 ** See Copyright Notice in lua.h
 */
@@ -10,18 +10,44 @@
 #include "lobject.h"
 #include "lzio.h"
 
+TProtoFunc* luaU_undump1(ZIO* Z);	/* load one chunk */
+
+#define	SIGNATURE	"Lua"
+#define	VERSION		0x31		/* last format change was in 3.1 */
+
+#define IsMain(f)	(f->lineDefined==0)
+
 #define ID_CHUNK	27		/* ESC */
-#define ID_FUNCTION	'#'
-#define ID_END		'$'
 #define ID_NUM		'N'
 #define ID_STR		'S'
 #define ID_FUN		'F'
-#define	SIGNATURE	"Lua"
-#define	VERSION		0x31		/* last format change was in 3.1 */
-#define	TEST_FLOAT	0.123456789e-23	/* a float for testing representation */
 
-#define IsMain(f)	(f->lineDefined==0)
+#define ID_INT4		'l'
+#define ID_REAL4	'f'
+#define ID_REAL8	'd'
+#define ID_NATIVE	'?'
 
-TProtoFunc* luaU_undump1(ZIO* Z);	/* load one chunk */
+/*
+* use a multiple of PI for testing number representation.
+* multiplying by 10E8 gives notrivial integer values.
+*/
+#define	TEST_NUMBER	3.14159265358979323846E8
+
+/* LUA_NUMBER */
+/* if you change the definition of real, make sure you set ID_NUMBER
+* accordingly, specially if sizeof(long)!=4.
+* for types other than the ones listed below, you'll have to write your own
+* dump and undump routines.
+*/
+
+#if real==float
+	#define	ID_NUMBER	ID_REAL4
+#elif real==double
+	#define	ID_NUMBER	ID_REAL8
+#elif real==long
+	#define	ID_NUMBER	ID_INT4
+#else
+	#define	ID_NUMBER	ID_NATIVE
+#endif
 
 #endif