433 lines
10 KiB
Java
433 lines
10 KiB
Java
package lua.io;
|
|
|
|
import java.io.DataInputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
|
|
import lua.StackState;
|
|
import lua.value.LBoolean;
|
|
import lua.value.LDouble;
|
|
import lua.value.LInteger;
|
|
import lua.value.LNil;
|
|
import lua.value.LNumber;
|
|
import lua.value.LValue;
|
|
import lua.value.LString;
|
|
|
|
/*
|
|
** Function Prototypes
|
|
*/
|
|
public class LoadState {
|
|
|
|
/** mark for precompiled code (`<esc>Lua') */
|
|
public static final String LUA_SIGNATURE = "\033Lua";
|
|
|
|
|
|
/** for header of binary files -- this is Lua 5.1 */
|
|
public static final int LUAC_VERSION = 0x51;
|
|
|
|
/** for header of binary files -- this is the official format */
|
|
public static final int LUAC_FORMAT = 0;
|
|
|
|
/** size of header of binary files */
|
|
public static final int LUAC_HEADERSIZE = 12;
|
|
|
|
/** expected lua header bytes */
|
|
private static final int LUAC_HEADER_SIGNATURE = ('\033'<<24) | ('L'<<16) | ('u'<<8) | ('a');
|
|
|
|
// values read from the header
|
|
private int luacVersion;
|
|
private int luacFormat;
|
|
private boolean luacLittleEndian;
|
|
private int luacSizeofInt;
|
|
private int luacSizeofSizeT;
|
|
private int luacSizeofInstruction;
|
|
private int luacSizeofLuaNumber;
|
|
private boolean luacIsNumberIntegral;
|
|
|
|
/** The lua state that is loading the code */
|
|
private StackState L;
|
|
|
|
/** input stream from which we are loading */
|
|
private DataInputStream is;
|
|
|
|
/** Name of what is being loaded? */
|
|
String name;
|
|
|
|
|
|
private static final int LUA_TNONE = (-1);
|
|
|
|
private static final int LUA_TNIL = 0;
|
|
private static final int LUA_TBOOLEAN = 1;
|
|
private static final int LUA_TLIGHTUSERDATA = 2;
|
|
private static final int LUA_TNUMBER = 3;
|
|
private static final int LUA_TSTRING = 4;
|
|
private static final int LUA_TTABLE = 5;
|
|
private static final int LUA_TFUNCTION = 6;
|
|
private static final int LUA_TUSERDATA = 7;
|
|
private static final int LUA_TTHREAD = 8;
|
|
|
|
// /*
|
|
// ** $Id$
|
|
// ** load precompiled Lua chunks
|
|
// ** See Copyright Notice in lua.h
|
|
// */
|
|
//
|
|
// #include <string.h>
|
|
//
|
|
// #define lundump_c
|
|
// #define LUA_CORE
|
|
//
|
|
// #include "lua.h"
|
|
//
|
|
// #include "ldebug.h"
|
|
// #include "ldo.h"
|
|
// #include "lfunc.h"
|
|
// #include "lmem.h"
|
|
// #include "lobject.h"
|
|
// #include "lstring.h"
|
|
// #include "lundump.h"
|
|
// #include "lzio.h"
|
|
//
|
|
// typedef struct {
|
|
// lua_State* L;
|
|
// ZIO* Z;
|
|
// Mbuffer* b;
|
|
// const char* name;
|
|
// } LoadState;
|
|
//
|
|
// #ifdef LUAC_TRUST_BINARIES
|
|
// #define IF(c,s)
|
|
// #else
|
|
// #define IF(c,s) if (c) error(S,s)
|
|
//
|
|
// static void error(LoadState* S, const char* why)
|
|
// {
|
|
// luaO_pushfstring(S->L,"%s: %s in precompiled chunk",S->name,why);
|
|
// luaD_throw(S->L,LUA_ERRSYNTAX);
|
|
// }
|
|
// #endif
|
|
//
|
|
// #define LoadMem(S,b,n,size) LoadBlock(S,b,(n)*(size))
|
|
// #define LoadByte(S) (lu_byte)LoadChar(S)
|
|
// #define LoadVar(S,x) LoadMem(S,&x,1,sizeof(x))
|
|
// #define LoadVector(S,b,n,size) LoadMem(S,b,n,size)
|
|
//
|
|
// static void LoadBlock(LoadState* S, void* b, size_t size)
|
|
// {
|
|
// size_t r=luaZ_read(S->Z,b,size);
|
|
// IF (r!=0, "unexpected end");
|
|
// }
|
|
//
|
|
// static int LoadChar(LoadState* S)
|
|
// {
|
|
// char x;
|
|
// LoadVar(S,x);
|
|
// return x;
|
|
// }
|
|
int loadByte() throws IOException {
|
|
return is.readUnsignedByte();
|
|
}
|
|
//
|
|
// static int LoadInt(LoadState* S)
|
|
// {
|
|
// int x;
|
|
// LoadVar(S,x);
|
|
// IF (x<0, "bad integer");
|
|
// return x;
|
|
// }
|
|
int loadInt() throws IOException {
|
|
if ( this.luacLittleEndian ) {
|
|
int a = is.readUnsignedByte();
|
|
int b = is.readUnsignedByte();
|
|
int c = is.readUnsignedByte();
|
|
int d = is.readUnsignedByte();
|
|
return (d << 24) | (c << 16) | (b << 8) | a;
|
|
} else {
|
|
return is.readInt();
|
|
}
|
|
}
|
|
|
|
long loadInt64() throws IOException {
|
|
int a,b;
|
|
if ( this.luacLittleEndian ) {
|
|
a = loadInt();
|
|
b = loadInt();
|
|
} else {
|
|
b = loadInt();
|
|
a = loadInt();
|
|
}
|
|
return (((long)b)<<32) | (((long)a)&0xffffffffL);
|
|
}
|
|
//
|
|
// static lua_Number LoadNumber(LoadState* S)
|
|
// {
|
|
// lua_Number x;
|
|
// LoadVar(S,x);
|
|
// return x;
|
|
// }
|
|
//
|
|
// static TString* LoadString(LoadState* S)
|
|
// {
|
|
// size_t size;
|
|
// LoadVar(S,size);
|
|
// if (size==0)
|
|
// return NULL;
|
|
// else
|
|
// {
|
|
// char* s=luaZ_openspace(S->L,S->b,size);
|
|
// LoadBlock(S,s,size);
|
|
// return luaS_newlstr(S->L,s,size-1); /* remove trailing '\0' */
|
|
// }
|
|
// }
|
|
LString loadString() throws IOException {
|
|
int size = loadInt();
|
|
if ( size == 0 )
|
|
return null;
|
|
byte[] bytes = new byte[size];
|
|
is.readFully( bytes );
|
|
String s = new String( bytes, 0, size-1 );
|
|
return new LString( s );
|
|
}
|
|
|
|
LNumber loadNumber() throws IOException {
|
|
if ( this.luacIsNumberIntegral ) {
|
|
int value = loadInt();
|
|
return new LInteger( value );
|
|
} else {
|
|
long bits = loadInt64();
|
|
double value = Double.longBitsToDouble(bits);
|
|
return new LDouble( value );
|
|
}
|
|
}
|
|
//
|
|
// static void LoadCode(LoadState* S, Proto* f)
|
|
// {
|
|
// int n=LoadInt(S);
|
|
// f->code=luaM_newvector(S->L,n,Instruction);
|
|
// f->sizecode=n;
|
|
// LoadVector(S,f->code,n,sizeof(Instruction));
|
|
// }
|
|
public void loadCode( Proto f ) throws IOException {
|
|
int n = loadInt();
|
|
int[] code = new int[n];
|
|
for ( int i=0; i<n; i++ )
|
|
code[i] = loadInt();
|
|
f.code = code;
|
|
}
|
|
//
|
|
// static Proto* LoadFunction(LoadState* S, TString* p);
|
|
//
|
|
// static void LoadConstants(LoadState* S, Proto* f)
|
|
// {
|
|
// int i,n;
|
|
// n=LoadInt(S);
|
|
// f->k=luaM_newvector(S->L,n,TValue);
|
|
// f->sizek=n;
|
|
// for (i=0; i<n; i++) setnilvalue(&f->k[i]);
|
|
// for (i=0; i<n; i++)
|
|
// {
|
|
// TValue* o=&f->k[i];
|
|
// int t=LoadChar(S);
|
|
// switch (t)
|
|
// {
|
|
// case LUA_TNIL:
|
|
// setnilvalue(o);
|
|
// break;
|
|
// case LUA_TBOOLEAN:
|
|
// setbvalue(o,LoadChar(S));
|
|
// break;
|
|
// case LUA_TNUMBER:
|
|
// setnvalue(o,LoadNumber(S));
|
|
// break;
|
|
// case LUA_TSTRING:
|
|
// setsvalue2n(S->L,o,LoadString(S));
|
|
// break;
|
|
// default:
|
|
// IF (1, "bad constant");
|
|
// break;
|
|
// }
|
|
// }
|
|
// n=LoadInt(S);
|
|
// f->p=luaM_newvector(S->L,n,Proto*);
|
|
// f->sizep=n;
|
|
// for (i=0; i<n; i++) f->p[i]=NULL;
|
|
// for (i=0; i<n; i++) f->p[i]=LoadFunction(S,f->source);
|
|
// }
|
|
void loadConstants(Proto f) throws IOException {
|
|
int n = loadInt();
|
|
LValue[] values = new LValue[n];
|
|
for ( int i=0; i<n; i++ ) {
|
|
switch ( loadByte() ) {
|
|
case LUA_TNIL:
|
|
values[i] = LNil.NIL;
|
|
break;
|
|
case LUA_TBOOLEAN:
|
|
values[i] = (0 != loadByte()? LBoolean.TRUE: LBoolean.FALSE);
|
|
break;
|
|
case LUA_TNUMBER:
|
|
values[i] = loadNumber();
|
|
break;
|
|
case LUA_TSTRING:
|
|
values[i] = loadString();
|
|
break;
|
|
default:
|
|
throw new IllegalStateException("bad constant");
|
|
}
|
|
}
|
|
f.k = values;
|
|
|
|
n = loadInt();
|
|
Proto[] protos = new Proto[n];
|
|
for ( int i=0; i<n; i++ )
|
|
protos[i] = loadFunction(f.source);
|
|
f.p = protos;
|
|
}
|
|
//
|
|
// static void LoadDebug(LoadState* S, Proto* f)
|
|
// {
|
|
// int i,n;
|
|
// n=LoadInt(S);
|
|
// f->lineinfo=luaM_newvector(S->L,n,int);
|
|
// f->sizelineinfo=n;
|
|
// LoadVector(S,f->lineinfo,n,sizeof(int));
|
|
|
|
// n=LoadInt(S);
|
|
// f->locvars=luaM_newvector(S->L,n,LocVar);
|
|
// f->sizelocvars=n;
|
|
// for (i=0; i<n; i++) f->locvars[i].varname=NULL;
|
|
// for (i=0; i<n; i++)
|
|
// {
|
|
// f->locvars[i].varname=LoadString(S);
|
|
// f->locvars[i].startpc=LoadInt(S);
|
|
// f->locvars[i].endpc=LoadInt(S);
|
|
// }
|
|
|
|
// n=LoadInt(S);
|
|
// f->upvalues=luaM_newvector(S->L,n,TString*);
|
|
// f->sizeupvalues=n;
|
|
// for (i=0; i<n; i++) f->upvalues[i]=NULL;
|
|
// for (i=0; i<n; i++) f->upvalues[i]=LoadString(S);
|
|
// }
|
|
void loadDebug( Proto f ) throws IOException {
|
|
int n = loadInt();
|
|
f.lineinfo = new int[n];
|
|
for ( int i=0; i<n; i++ )
|
|
f.lineinfo[i] = loadInt();
|
|
|
|
n = loadInt();
|
|
f.locvars = new LocVars[n];
|
|
for ( int i=0; i<n; i++ ) {
|
|
LString varname = loadString();
|
|
int startpc = loadInt();
|
|
int endpc = loadInt();
|
|
f.locvars[i] = new LocVars(varname, startpc, endpc);
|
|
}
|
|
|
|
n = loadInt();
|
|
f.upvalues = new LString[n];
|
|
for ( int i=0; i<n; i++ ) {
|
|
f.upvalues[i] = loadString();
|
|
}
|
|
}
|
|
//
|
|
// static Proto* LoadFunction(LoadState* S, TString* p)
|
|
// {
|
|
// Proto* f=luaF_newproto(S->L);
|
|
// setptvalue2s(S->L,S->L->top,f); incr_top(S->L);
|
|
// f->source=LoadString(S); if (f->source==NULL) f->source=p;
|
|
// f->linedefined=LoadInt(S);
|
|
// f->lastlinedefined=LoadInt(S);
|
|
// f->nups=LoadByte(S);
|
|
// f->numparams=LoadByte(S);
|
|
// f->is_vararg=LoadByte(S);
|
|
// f->maxstacksize=LoadByte(S);
|
|
// LoadCode(S,f);
|
|
// LoadConstants(S,f);
|
|
// LoadDebug(S,f);
|
|
// IF (!luaG_checkcode(f), "bad code");
|
|
// S->L->top--;
|
|
// return f;
|
|
// }
|
|
public Proto loadFunction(LString p) throws IOException {
|
|
Proto f = new Proto(this.L);
|
|
this.L.push(f);
|
|
f.source = loadString();
|
|
f.linedefined = loadInt();
|
|
f.lastlinedefined = loadInt();
|
|
f.nups = loadByte();
|
|
f.numparams = loadByte();
|
|
f.is_vararg = (0 != loadByte());
|
|
f.maxstacksize = loadByte();
|
|
loadCode(f);
|
|
loadConstants(f);
|
|
loadDebug(f);
|
|
|
|
// TODO: add check here, for debugging purposes, I believe
|
|
// see ldebug.c
|
|
// IF (!luaG_checkcode(f), "bad code");
|
|
|
|
this.L.pop();
|
|
return f;
|
|
}
|
|
//
|
|
// static void LoadHeader(LoadState* S)
|
|
// {
|
|
// char h[LUAC_HEADERSIZE];
|
|
// char s[LUAC_HEADERSIZE];
|
|
// luaU_header(h);
|
|
// LoadBlock(S,s,LUAC_HEADERSIZE);
|
|
// IF (memcmp(h,s,LUAC_HEADERSIZE)!=0, "bad header");
|
|
// }
|
|
public void loadHeader() throws IOException {
|
|
int sig = is.readInt();
|
|
luacVersion = is.readByte();
|
|
luacFormat = is.readByte();
|
|
luacLittleEndian = (0 != is.readByte());
|
|
luacSizeofInt = is.readByte();
|
|
luacSizeofSizeT = is.readByte();
|
|
luacSizeofInstruction = is.readByte();
|
|
luacSizeofLuaNumber = is.readByte();
|
|
luacIsNumberIntegral = (0 != is.readByte());
|
|
if ( sig != LUAC_HEADER_SIGNATURE )
|
|
throw new IllegalArgumentException("bad signature");
|
|
}
|
|
//
|
|
// /*
|
|
// ** load precompiled chunk
|
|
// */
|
|
// Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name)
|
|
// {
|
|
// LoadState S;
|
|
// if (*name=='@' || *name=='=')
|
|
// S.name=name+1;
|
|
// else if (*name==LUA_SIGNATURE[0])
|
|
// S.name="binary string";
|
|
// else
|
|
// S.name=name;
|
|
// S.L=L;
|
|
// S.Z=Z;
|
|
// S.b=buff;
|
|
// LoadHeader(&S);
|
|
// return LoadFunction(&S,luaS_newliteral(L,"=?"));
|
|
// }
|
|
|
|
public static Proto undump( StackState L, InputStream stream, String name ) throws IOException {
|
|
String sname = name;
|
|
if ( name.startsWith("@") || name.startsWith("=") )
|
|
sname = name.substring(1);
|
|
else if ( name.startsWith("\033") )
|
|
sname = "binary string";
|
|
LoadState s = new LoadState( L, stream, sname );
|
|
s.loadHeader();
|
|
LString literal = new LString(L, "=?");
|
|
return s.loadFunction( literal );
|
|
}
|
|
|
|
/** Private constructor for create a load state */
|
|
private LoadState( StackState L, InputStream stream, String name ) {
|
|
this.L = L;
|
|
this.name = name;
|
|
this.is = new DataInputStream( stream );
|
|
}
|
|
}
|