|
|
|
@ -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); |
|
|
|
|
Roberto Ierusalimschy
28 years ago