Initial draft of interpreter. Lua compiled "chunks" can be unmarshalled. Approximately half of bytecodes implemented in some form or another.
This commit is contained in:
James Roseborough
23
src/main/java/lua/io/Closure.java
Normal file
23
src/main/java/lua/io/Closure.java
Normal file
@@ -0,0 +1,23 @@
|
||||
package lua.io;
|
||||
|
||||
import lua.StackState;
|
||||
import lua.value.LValue;
|
||||
|
||||
public class Closure extends LValue {
|
||||
public LValue env;
|
||||
public Proto p;
|
||||
public UpVal[] upVals;
|
||||
public Closure(StackState state, Proto p) {
|
||||
this.env = state.gt();
|
||||
this.p = p;
|
||||
upVals = new UpVal[p.nups];
|
||||
for ( int i=0; i<p.nups; i++ )
|
||||
upVals[i] = new UpVal();
|
||||
}
|
||||
|
||||
|
||||
// perform a lua call
|
||||
public void luaStackCall(StackState state, int base, int nresults) {
|
||||
state.vmExecute( this, base+1 );
|
||||
}
|
||||
}
|
||||
432
src/main/java/lua/io/LoadState.java
Normal file
432
src/main/java/lua/io/LoadState.java
Normal file
@@ -0,0 +1,432 @@
|
||||
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 );
|
||||
}
|
||||
}
|
||||
16
src/main/java/lua/io/LocVars.java
Normal file
16
src/main/java/lua/io/LocVars.java
Normal file
@@ -0,0 +1,16 @@
|
||||
package lua.io;
|
||||
|
||||
import lua.value.LString;
|
||||
|
||||
public class LocVars {
|
||||
final LString m_varname;
|
||||
final int m_startpc;
|
||||
final int m_endpc;
|
||||
|
||||
public LocVars(LString varname, int startpc, int endpc) {
|
||||
this.m_varname = varname;
|
||||
this.m_startpc = startpc;
|
||||
this.m_endpc = endpc;
|
||||
}
|
||||
|
||||
}
|
||||
39
src/main/java/lua/io/Proto.java
Normal file
39
src/main/java/lua/io/Proto.java
Normal file
@@ -0,0 +1,39 @@
|
||||
package lua.io;
|
||||
|
||||
import lua.StackState;
|
||||
import lua.value.LValue;
|
||||
import lua.value.LString;
|
||||
|
||||
/*
|
||||
** Function Prototypes
|
||||
*/
|
||||
public class Proto extends LValue {
|
||||
// TODO: what to do with state?
|
||||
public Proto(StackState l) {
|
||||
}
|
||||
|
||||
public LValue[] k; /* constants used by the function */
|
||||
// TValue *k; /* constants used by the function */
|
||||
// Instruction *code;
|
||||
public int[] code;
|
||||
// struct Proto **p; /* functions defined inside the function */
|
||||
public Proto[] p;
|
||||
// int *lineinfo; /* map from opcodes to source lines */
|
||||
public int[] lineinfo;
|
||||
// struct LocVar *locvars; /* information about local variables */
|
||||
public LocVars[] locvars;
|
||||
// TString **upvalues; /* upvalue names */
|
||||
public LString[] upvalues;
|
||||
public LString source;
|
||||
public int nups;
|
||||
public int sizeupvalues;
|
||||
public int sizek; /* size of `k' */
|
||||
public int sizecode;
|
||||
public int sizep; /* size of `p' */
|
||||
public int linedefined;
|
||||
public int lastlinedefined;
|
||||
// GCObject *gclist;
|
||||
public int numparams;
|
||||
public boolean is_vararg;
|
||||
public int maxstacksize;
|
||||
}
|
||||
5
src/main/java/lua/io/UpVal.java
Normal file
5
src/main/java/lua/io/UpVal.java
Normal file
@@ -0,0 +1,5 @@
|
||||
package lua.io;
|
||||
|
||||
public class UpVal {
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user