From be87758fe56d049d707026bedba3da408d14ff13 Mon Sep 17 00:00:00 2001 From: James Roseborough Date: Fri, 21 Sep 2007 16:50:29 +0000 Subject: [PATCH] add compiler to vm as add-on --- .../java/lua/addon/compile/CheckCode.java | 12 + .../java/lua/addon/compile/Compiler.java | 66 + .../java/lua/addon/compile/DumpState.java | 174 ++ .../java/lua/addon/compile/FuncState.java | 1054 ++++++++++ .../lua/addon/compile/InstructionPtr.java | 17 + src/addon/java/lua/addon/compile/IntPtr.java | 10 + .../java/lua/addon/compile/LexState.java | 1858 +++++++++++++++++ src/addon/java/lua/addon/compile/LuaC.java | 125 ++ src/test/compile/lua5.1-tests.zip | Bin 0 -> 166534 bytes src/test/compile/regressions.zip | Bin 0 -> 3137 bytes src/test/compile/repack.sh | 20 + src/test/compile/unpack.sh | 12 + .../lua/addon/compile/AbstractUnitTests.java | 96 + .../lua/addon/compile/CompilerUnitTests.java | 35 + .../lua/addon/compile/RegressionTests.java | 31 + .../java/lua/addon/compile/SimpleTests.java | 76 + 16 files changed, 3586 insertions(+) create mode 100644 src/addon/java/lua/addon/compile/CheckCode.java create mode 100644 src/addon/java/lua/addon/compile/Compiler.java create mode 100644 src/addon/java/lua/addon/compile/DumpState.java create mode 100644 src/addon/java/lua/addon/compile/FuncState.java create mode 100644 src/addon/java/lua/addon/compile/InstructionPtr.java create mode 100644 src/addon/java/lua/addon/compile/IntPtr.java create mode 100644 src/addon/java/lua/addon/compile/LexState.java create mode 100644 src/addon/java/lua/addon/compile/LuaC.java create mode 100644 src/test/compile/lua5.1-tests.zip create mode 100644 src/test/compile/regressions.zip create mode 100644 src/test/compile/repack.sh create mode 100644 src/test/compile/unpack.sh create mode 100644 src/test/java/lua/addon/compile/AbstractUnitTests.java create mode 100644 src/test/java/lua/addon/compile/CompilerUnitTests.java create mode 100644 src/test/java/lua/addon/compile/RegressionTests.java create mode 100644 src/test/java/lua/addon/compile/SimpleTests.java diff --git a/src/addon/java/lua/addon/compile/CheckCode.java b/src/addon/java/lua/addon/compile/CheckCode.java new file mode 100644 index 00000000..9d59a4cf --- /dev/null +++ b/src/addon/java/lua/addon/compile/CheckCode.java @@ -0,0 +1,12 @@ +package lua.addon.compile; + +import lua.io.Proto; + +public class CheckCode { + + public static boolean checkcode(Proto f) { + // TODO: port logic from ldebug.c + return true; + } + +} diff --git a/src/addon/java/lua/addon/compile/Compiler.java b/src/addon/java/lua/addon/compile/Compiler.java new file mode 100644 index 00000000..644341b0 --- /dev/null +++ b/src/addon/java/lua/addon/compile/Compiler.java @@ -0,0 +1,66 @@ +package lua.addon.compile; + +import java.io.Reader; +import java.util.Hashtable; + +import lua.io.Proto; +import lua.value.LString; + +public class Compiler { + + public int nCcalls; + + public static Proto compile( Reader reader, String name ) { + Compiler compiler = new Compiler(); + return compiler.luaY_parser(reader, name); + } + + + Proto luaY_parser(Reader z, String name) { + LexState lexstate = new LexState(this, z); + FuncState funcstate = new FuncState(); + // lexstate.buff = buff; + lexstate.setinput( this, z, new LString(name) ); + lexstate.open_func(funcstate); + /* main func. is always vararg */ + funcstate.varargflags = LuaC.VARARG_ISVARARG; + funcstate.f.is_vararg = true; + funcstate.f.source = new LString("@"+name); + lexstate.next(); /* read first token */ + lexstate.chunk(); + lexstate.check(LexState.TK_EOS); + lexstate.close_func(); + LuaC._assert (funcstate.prev == null); + LuaC._assert (funcstate.f.nups == 0); + LuaC._assert (lexstate.fs == null); + return funcstate.f; + } + + + // these string utilities were originally + // part of the Lua C State object, so we have + // left them here for now until we deterimine + // what exact purpose they serve. + + // table of all strings -> TString mapping. + // this includes reserved words that must be identified + // during lexical analysis for the compiler to work at all. + // TODO: consider moving this to LexState and simplifying + // all the various "newstring()" like functions + Hashtable strings = new Hashtable(); + + public LString newTString(String s) { + LString t = (LString) strings.get(s); + if ( t == null ) + strings.put( s, t = new LString(s) ); + return t; + } + + public String pushfstring(String string) { + return string; + } + + public LString newlstr(char[] chars, int offset, int len) { + return newTString( new String(chars,offset,len) ); + } +} diff --git a/src/addon/java/lua/addon/compile/DumpState.java b/src/addon/java/lua/addon/compile/DumpState.java new file mode 100644 index 00000000..5c85f273 --- /dev/null +++ b/src/addon/java/lua/addon/compile/DumpState.java @@ -0,0 +1,174 @@ +package lua.addon.compile; + +import java.io.DataOutputStream; +import java.io.IOException; +import java.io.OutputStream; + +import lua.io.Proto; +import lua.value.LBoolean; +import lua.value.LNil; +import lua.value.LNumber; +import lua.value.LString; +import lua.value.LValue; + +public class DumpState { + + /** mark for precompiled code (`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 byte[] LUAC_HEADER_SIGNATURE = { '\033', 'L', 'u', 'a' }; + + // header fields + private static final int IS_LITTLE_ENDIAN = 0; + private static final int SIZEOF_INT = 4; + private static final int SIZEOF_SIZET = 4; + private static final int SIZEOF_INSTRUCTION = 4; + private static final int SIZEOF_LUA_NUMBER = 8; + private static final int IS_NUMBER_INTEGRAL = 0; + + // types of lua constants + 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; + + DataOutputStream writer; + boolean strip; + int status; + + public DumpState(OutputStream w, boolean strip) { + this.writer = new DataOutputStream( w ); + this.strip = strip; + this.status = 0; + } + + void dumpBlock(final byte[] b, int size) throws IOException { + writer.write(b, 0, size); + } + + void dumpChar(int b) throws IOException { + writer.write( b ); + } + + void dumpInt(int x) throws IOException { + writer.writeInt(x); + } + + void dumpString(LString s) throws IOException { + final int len = s.length(); + dumpInt( len+1 ); + s.write( writer, 0, len ); + writer.write( 0 ); + } + + void dumpNumber(double d) throws IOException { + long l = Double.doubleToLongBits(d); + writer.writeLong(l); + } + + void dumpCode( final Proto f ) throws IOException { + int n = f.code.length; + dumpInt( n ); + for ( int i=0; i l ) + errorlimit( l, msg ); + } + + void errorlimit (int limit, String what) { + String msg = (f.linedefined == 0) ? + L.pushfstring("main function has more than "+limit+" "+what) : + L.pushfstring("function at line "+f.linedefined+" has more than "+limit+" "+what); + ls.lexerror(msg, 0); + } + + + int indexupvalue(LString name, expdesc v) { + int i; + for (i = 0; i < f.nups; i++) { + if (upvalues[i].k == v.k && upvalues[i].info == v.u.s.info) { + _assert(f.upvalues[i] == name); + return i; + } + } + /* new one */ + checklimit(f.nups + 1, LUAI_MAXUPVALUES, "upvalues"); + if ( f.upvalues == null || f.nups + 1 > f.upvalues.length) + f.upvalues = realloc( f.upvalues, f.nups*2+1 ); + f.upvalues[f.nups] = name; + _assert (v.k == LexState.VLOCAL || v.k == LexState.VUPVAL); + upvalues[f.nups] = new upvaldesc(); + upvalues[f.nups].k = (byte) (v.k); + upvalues[f.nups].info = (byte) (v.u.s.info); + return f.nups++; + } + + int searchvar(LString n) { + int i; + for (i = nactvar - 1; i >= 0; i--) { + if (n == getlocvar(i).varname) + return i; + } + return -1; /* not found */ + } + + void markupval(int level) { + BlockCnt bl = this.bl; + while (bl != null && bl.nactvar > level) + bl = bl.previous; + if (bl != null) + bl.upval = true; + } + + int singlevaraux(LString n, expdesc var, int base) { + int v = searchvar(n); /* look up at current level */ + if (v >= 0) { + var.init(LexState.VLOCAL, v); + if (base == 0) + markupval(v); /* local will be used as an upval */ + return LexState.VLOCAL; + } else { /* not found at current level; try upper one */ + if (prev == null) { /* no more levels? */ + /* default is global variable */ + var.init(LexState.VGLOBAL, NO_REG); + return LexState.VGLOBAL; + } + if (prev.singlevaraux(n, var, 0) == LexState.VGLOBAL) + return LexState.VGLOBAL; + var.u.s.info = indexupvalue(n, var); /* else was LOCAL or UPVAL */ + var.k = LexState.VUPVAL; /* upvalue in this level */ + return LexState.VUPVAL; + } + } + + void enterblock (BlockCnt bl, boolean isbreakable) { + bl.breaklist.i = LexState.NO_JUMP; + bl.isbreakable = isbreakable; + bl.nactvar = this.nactvar; + bl.upval = false; + bl.previous = this.bl; + this.bl = bl; + _assert(this.freereg == this.nactvar); + } + + // +// void leaveblock (FuncState *fs) { +// BlockCnt *bl = this.bl; +// this.bl = bl.previous; +// removevars(this.ls, bl.nactvar); +// if (bl.upval) +// this.codeABC(OP_CLOSE, bl.nactvar, 0, 0); +// /* a block either controls scope or breaks (never both) */ +// assert(!bl.isbreakable || !bl.upval); +// assert(bl.nactvar == this.nactvar); +// this.freereg = this.nactvar; /* free registers */ +// this.patchtohere(bl.breaklist); +// } + + void leaveblock() { + BlockCnt bl = this.bl; + this.bl = bl.previous; + ls.removevars(bl.nactvar); + if (bl.upval) + this.codeABC(OP_CLOSE, bl.nactvar, 0, 0); + /* a block either controls scope or breaks (never both) */ + _assert (!bl.isbreakable || !bl.upval); + _assert (bl.nactvar == this.nactvar); + this.freereg = this.nactvar; /* free registers */ + this.patchtohere(bl.breaklist.i); + } + + void closelistfield(ConsControl cc) { + if (cc.v.k == LexState.VVOID) + return; /* there is no list item */ + this.exp2nextreg(cc.v); + cc.v.k = LexState.VVOID; + if (cc.tostore == LFIELDS_PER_FLUSH) { + this.setlist(cc.t.u.s.info, cc.na, cc.tostore); /* flush */ + cc.tostore = 0; /* no more items pending */ + } + } + + boolean hasmultret(int k) { + return ((k) == LexState.VCALL || (k) == LexState.VVARARG); + } + + void lastlistfield (ConsControl cc) { + if (cc.tostore == 0) return; + if (hasmultret(cc.v.k)) { + this.setmultret(cc.v); + this.setlist(cc.t.u.s.info, cc.na, LUA_MULTRET); + cc.na--; /** do not count last expression (unknown number of elements) */ + } + else { + if (cc.v.k != LexState.VVOID) + this.exp2nextreg(cc.v); + this.setlist(cc.t.u.s.info, cc.na, cc.tostore); + } + } + + + + // ============================================================= + // from lcode.c + // ============================================================= + + void nil(int from, int n) { + InstructionPtr previous; + if (this.pc > this.lasttarget) { /* no jumps to current position? */ + if (this.pc == 0) { /* function start? */ + if (from >= this.nactvar) + return; /* positions are already clean */ + } else { + previous = new InstructionPtr(this.f.code, this.pc - 1); + if (GET_OPCODE(previous.get()) == OP_LOADNIL) { + int pfrom = GETARG_A(previous.get()); + int pto = GETARG_B(previous.get()); + if (pfrom <= from && from <= pto + 1) { /* can connect both? */ + if (from + n - 1 > pto) + SETARG_B(previous, from + n - 1); + return; + } + } + } + } + /* else no optimization */ + this.codeABC(OP_LOADNIL, from, from + n - 1, 0); + } + + + int jump() { + int jpc = this.jpc.i; /* save list of jumps to here */ + this.jpc.i = LexState.NO_JUMP; + IntPtr j = new IntPtr(this.codeAsBx(OP_JMP, 0, LexState.NO_JUMP)); + this.concat(j, jpc); /* keep them on hold */ + return j.i; + } + + void ret(int first, int nret) { + this.codeABC(OP_RETURN, first, nret + 1, 0); + } + + int condjump(int /* OpCode */op, int A, int B, int C) { + this.codeABC(op, A, B, C); + return this.jump(); + } + + void fixjump(int pc, int dest) { + InstructionPtr jmp = new InstructionPtr(this.f.code, pc); + int offset = dest - (pc + 1); + _assert (dest != LexState.NO_JUMP); + if (Math.abs(offset) > MAXARG_sBx) + ls.syntaxerror("control structure too long"); + SETARG_sBx(jmp, offset); + } + + + /* + * * returns current `pc' and marks it as a jump target (to avoid wrong * + * optimizations with consecutive instructions not in the same basic block). + */ + int getlabel() { + this.lasttarget = this.pc; + return this.pc; + } + + + int getjump(int pc) { + int offset = GETARG_sBx(this.f.code[pc]); + /* point to itself represents end of list */ + if (offset == LexState.NO_JUMP) + /* end of list */ + return LexState.NO_JUMP; + else + /* turn offset into absolute position */ + return (pc + 1) + offset; + } + + + InstructionPtr getjumpcontrol(int pc) { + InstructionPtr pi = new InstructionPtr(this.f.code, pc); + if (pc >= 1 && testTMode(GET_OPCODE(pi.code[pi.idx - 1]))) + return new InstructionPtr(pi.code, pi.idx - 1); + else + return pi; + } + + + /* + * * check whether list has any jump that do not produce a value * (or + * produce an inverted value) + */ + boolean need_value(int list) { + for (; list != LexState.NO_JUMP; list = this.getjump(list)) { + int i = this.getjumpcontrol(list).get(); + if (GET_OPCODE(i) != OP_TESTSET) + return true; + } + return false; /* not found */ + } + + + boolean patchtestreg(int node, int reg) { + InstructionPtr i = this.getjumpcontrol(node); + if (GET_OPCODE(i.get()) != OP_TESTSET) + /* cannot patch other instructions */ + return false; + if (reg != NO_REG && reg != GETARG_B(i.get())) + SETARG_A(i, reg); + else + /* no register to put value or register already has the value */ + i.set(CREATE_ABC(OP_TEST, GETARG_B(i.get()), 0, Lua.GETARG_C(i.get()))); + + return true; + } + + + void removevalues(int list) { + for (; list != LexState.NO_JUMP; list = this.getjump(list)) + this.patchtestreg(list, NO_REG); + } + + void patchlistaux(int list, int vtarget, int reg, int dtarget) { + while (list != LexState.NO_JUMP) { + int next = this.getjump(list); + if (this.patchtestreg(list, reg)) + this.fixjump(list, vtarget); + else + this.fixjump(list, dtarget); /* jump to default target */ + list = next; + } + } + + void dischargejpc() { + this.patchlistaux(this.jpc.i, this.pc, NO_REG, this.pc); + this.jpc.i = LexState.NO_JUMP; + } + + void patchlist(int list, int target) { + if (target == this.pc) + this.patchtohere(list); + else { + _assert (target < this.pc); + this.patchlistaux(list, target, NO_REG, target); + } + } + + void patchtohere(int list) { + this.getlabel(); + this.concat(this.jpc, list); + } + + void concat(IntPtr l1, int l2) { + if (l2 == LexState.NO_JUMP) + return; + if (l1.i == LexState.NO_JUMP) + l1.i = l2; + else { + int list = l1.i; + int next; + while ((next = this.getjump(list)) != LexState.NO_JUMP) + /* find last element */ + list = next; + this.fixjump(list, l2); + } + } + + void checkstack(int n) { + int newstack = this.freereg + n; + if (newstack > this.f.maxstacksize) { + if (newstack >= MAXSTACK) + ls.syntaxerror("function or expression too complex"); + this.f.maxstacksize = (byte) newstack; + } + } + + void reserveregs(int n) { + this.checkstack(n); + this.freereg += n; + } + + void freereg(int reg) { + if (!ISK(reg) && reg >= this.nactvar) { + this.freereg--; + _assert (reg == this.freereg); + } + } + + void freeexp(expdesc e) { + if (e.k == LexState.VNONRELOC) + this.freereg(e.u.s.info); + } + + int addk(LValue v) { + int idx; + if (this.htable.containsKey(v)) { + idx = ((Integer) htable.get(v)).intValue(); + } else { + idx = this.nk; + this.htable.put(v, new Integer(idx)); + final Proto f = this.f; + if (f.k == null || nk + 1 >= f.k.length) + f.k = realloc( f.k, nk*2 + 1 ); + f.k[this.nk++] = v; + } + return idx; + } + + int stringK(LString s) { + return this.addk(s); + } + + int numberK(LNumber r) { + if ( r instanceof LDouble ) { + double d = r.luaAsDouble(); + int i = (int) d; + if ( d == (double) i ) + r = new LInteger(i); + } + return this.addk(r); + } + + int boolK(boolean b) { + return this.addk((b ? LBoolean.TRUE : LBoolean.FALSE)); + } + + int nilK() { + return this.addk(LNil.NIL); + } + + void setreturns(expdesc e, int nresults) { + if (e.k == LexState.VCALL) { /* expression is an open function call? */ + SETARG_C(this.getcodePtr(e), nresults + 1); + } else if (e.k == LexState.VVARARG) { + SETARG_B(this.getcodePtr(e), nresults + 1); + SETARG_A(this.getcodePtr(e), this.freereg); + this.reserveregs(1); + } + } + + void setoneret(expdesc e) { + if (e.k == LexState.VCALL) { /* expression is an open function call? */ + e.k = LexState.VNONRELOC; + e.u.s.info = GETARG_A(this.getcode(e)); + } else if (e.k == LexState.VVARARG) { + SETARG_B(this.getcodePtr(e), 2); + e.k = LexState.VRELOCABLE; /* can relocate its simple result */ + } + } + + void dischargevars(expdesc e) { + switch (e.k) { + case LexState.VLOCAL: { + e.k = LexState.VNONRELOC; + break; + } + case LexState.VUPVAL: { + e.u.s.info = this.codeABC(OP_GETUPVAL, 0, e.u.s.info, 0); + e.k = LexState.VRELOCABLE; + break; + } + case LexState.VGLOBAL: { + e.u.s.info = this.codeABx(OP_GETGLOBAL, 0, e.u.s.info); + e.k = LexState.VRELOCABLE; + break; + } + case LexState.VINDEXED: { + this.freereg(e.u.s.aux); + this.freereg(e.u.s.info); + e.u.s.info = this + .codeABC(OP_GETTABLE, 0, e.u.s.info, e.u.s.aux); + e.k = LexState.VRELOCABLE; + break; + } + case LexState.VVARARG: + case LexState.VCALL: { + this.setoneret(e); + break; + } + default: + break; /* there is one value available (somewhere) */ + } + } + + int code_label(int A, int b, int jump) { + this.getlabel(); /* those instructions may be jump targets */ + return this.codeABC(OP_LOADBOOL, A, b, jump); + } + + void discharge2reg(expdesc e, int reg) { + this.dischargevars(e); + switch (e.k) { + case LexState.VNIL: { + this.nil(reg, 1); + break; + } + case LexState.VFALSE: + case LexState.VTRUE: { + this.codeABC(OP_LOADBOOL, reg, (e.k == LexState.VTRUE ? 1 : 0), + 0); + break; + } + case LexState.VK: { + this.codeABx(OP_LOADK, reg, e.u.s.info); + break; + } + case LexState.VKNUM: { + this.codeABx(OP_LOADK, reg, this.numberK(e.u.nval())); + break; + } + case LexState.VRELOCABLE: { + InstructionPtr pc = this.getcodePtr(e); + SETARG_A(pc, reg); + break; + } + case LexState.VNONRELOC: { + if (reg != e.u.s.info) + this.codeABC(OP_MOVE, reg, e.u.s.info, 0); + break; + } + default: { + _assert (e.k == LexState.VVOID || e.k == LexState.VJMP); + return; /* nothing to do... */ + } + } + e.u.s.info = reg; + e.k = LexState.VNONRELOC; + } + + void discharge2anyreg(expdesc e) { + if (e.k != LexState.VNONRELOC) { + this.reserveregs(1); + this.discharge2reg(e, this.freereg - 1); + } + } + + void exp2reg(expdesc e, int reg) { + this.discharge2reg(e, reg); + if (e.k == LexState.VJMP) + this.concat(e.t, e.u.s.info); /* put this jump in `t' list */ + if (e.hasjumps()) { + int _final; /* position after whole expression */ + int p_f = LexState.NO_JUMP; /* position of an eventual LOAD false */ + int p_t = LexState.NO_JUMP; /* position of an eventual LOAD true */ + if (this.need_value(e.t.i) || this.need_value(e.f.i)) { + int fj = (e.k == LexState.VJMP) ? LexState.NO_JUMP : this + .jump(); + p_f = this.code_label(reg, 0, 1); + p_t = this.code_label(reg, 1, 0); + this.patchtohere(fj); + } + _final = this.getlabel(); + this.patchlistaux(e.f.i, _final, reg, p_f); + this.patchlistaux(e.t.i, _final, reg, p_t); + } + e.f.i = e.t.i = LexState.NO_JUMP; + e.u.s.info = reg; + e.k = LexState.VNONRELOC; + } + + void exp2nextreg(expdesc e) { + this.dischargevars(e); + this.freeexp(e); + this.reserveregs(1); + this.exp2reg(e, this.freereg - 1); + } + + int exp2anyreg(expdesc e) { + this.dischargevars(e); + if (e.k == LexState.VNONRELOC) { + if (!e.hasjumps()) + return e.u.s.info; /* exp is already in a register */ + if (e.u.s.info >= this.nactvar) { /* reg. is not a local? */ + this.exp2reg(e, e.u.s.info); /* put value on it */ + return e.u.s.info; + } + } + this.exp2nextreg(e); /* default */ + return e.u.s.info; + } + + void exp2val(expdesc e) { + if (e.hasjumps()) + this.exp2anyreg(e); + else + this.dischargevars(e); + } + + int exp2RK(expdesc e) { + this.exp2val(e); + switch (e.k) { + case LexState.VKNUM: + case LexState.VTRUE: + case LexState.VFALSE: + case LexState.VNIL: { + if (this.nk <= MAXINDEXRK) { /* constant fit in RK operand? */ + e.u.s.info = (e.k == LexState.VNIL) ? this.nilK() + : (e.k == LexState.VKNUM) ? this.numberK(e.u.nval()) + : this.boolK((e.k == LexState.VTRUE)); + e.k = LexState.VK; + return RKASK(e.u.s.info); + } else + break; + } + case LexState.VK: { + if (e.u.s.info <= MAXINDEXRK) /* constant fit in argC? */ + return RKASK(e.u.s.info); + else + break; + } + default: + break; + } + /* not a constant in the right range: put it in a register */ + return this.exp2anyreg(e); + } + + void storevar(expdesc var, expdesc ex) { + switch (var.k) { + case LexState.VLOCAL: { + this.freeexp(ex); + this.exp2reg(ex, var.u.s.info); + return; + } + case LexState.VUPVAL: { + int e = this.exp2anyreg(ex); + this.codeABC(OP_SETUPVAL, e, var.u.s.info, 0); + break; + } + case LexState.VGLOBAL: { + int e = this.exp2anyreg(ex); + this.codeABx(OP_SETGLOBAL, e, var.u.s.info); + break; + } + case LexState.VINDEXED: { + int e = this.exp2RK(ex); + this.codeABC(OP_SETTABLE, var.u.s.info, var.u.s.aux, e); + break; + } + default: { + _assert (false); /* invalid var kind to store */ + break; + } + } + this.freeexp(ex); + } + + void self(expdesc e, expdesc key) { + int func; + this.exp2anyreg(e); + this.freeexp(e); + func = this.freereg; + this.reserveregs(2); + this.codeABC(OP_SELF, func, e.u.s.info, this.exp2RK(key)); + this.freeexp(key); + e.u.s.info = func; + e.k = LexState.VNONRELOC; + } + + void invertjump(expdesc e) { + InstructionPtr pc = this.getjumpcontrol(e.u.s.info); + _assert (testTMode(GET_OPCODE(pc.get())) + && GET_OPCODE(pc.get()) != OP_TESTSET && Lua + .GET_OPCODE(pc.get()) != OP_TEST); + // SETARG_A(pc, !(GETARG_A(pc.get()))); + int a = GETARG_A(pc.get()); + int nota = (a!=0? 0: 1); + SETARG_A(pc, nota); + } + + int jumponcond(expdesc e, int cond) { + if (e.k == LexState.VRELOCABLE) { + int ie = this.getcode(e); + if (GET_OPCODE(ie) == OP_NOT) { + this.pc--; /* remove previous OP_NOT */ + return this.condjump(OP_TEST, GETARG_B(ie), 0, (cond!=0? 0: 1)); + } + /* else go through */ + } + this.discharge2anyreg(e); + this.freeexp(e); + return this.condjump(OP_TESTSET, NO_REG, e.u.s.info, cond); + } + + void goiftrue(expdesc e) { + int pc; /* pc of last jump */ + this.dischargevars(e); + switch (e.k) { + case LexState.VK: + case LexState.VKNUM: + case LexState.VTRUE: { + pc = LexState.NO_JUMP; /* always true; do nothing */ + break; + } + case LexState.VFALSE: { + pc = this.jump(); /* always jump */ + break; + } + case LexState.VJMP: { + this.invertjump(e); + pc = e.u.s.info; + break; + } + default: { + pc = this.jumponcond(e, 0); + break; + } + } + this.concat(e.f, pc); /* insert last jump in `f' list */ + this.patchtohere(e.t.i); + e.t.i = LexState.NO_JUMP; + } + + void goiffalse(expdesc e) { + int pc; /* pc of last jump */ + this.dischargevars(e); + switch (e.k) { + case LexState.VNIL: + case LexState.VFALSE: { + pc = LexState.NO_JUMP; /* always false; do nothing */ + break; + } + case LexState.VTRUE: { + pc = this.jump(); /* always jump */ + break; + } + case LexState.VJMP: { + pc = e.u.s.info; + break; + } + default: { + pc = this.jumponcond(e, 1); + break; + } + } + this.concat(e.t, pc); /* insert last jump in `t' list */ + this.patchtohere(e.f.i); + e.f.i = LexState.NO_JUMP; + } + + void codenot(expdesc e) { + this.dischargevars(e); + switch (e.k) { + case LexState.VNIL: + case LexState.VFALSE: { + e.k = LexState.VTRUE; + break; + } + case LexState.VK: + case LexState.VKNUM: + case LexState.VTRUE: { + e.k = LexState.VFALSE; + break; + } + case LexState.VJMP: { + this.invertjump(e); + break; + } + case LexState.VRELOCABLE: + case LexState.VNONRELOC: { + this.discharge2anyreg(e); + this.freeexp(e); + e.u.s.info = this.codeABC(OP_NOT, 0, e.u.s.info, 0); + e.k = LexState.VRELOCABLE; + break; + } + default: { + _assert (false); /* cannot happen */ + break; + } + } + /* interchange true and false lists */ + { + int temp = e.f.i; + e.f.i = e.t.i; + e.t.i = temp; + } + this.removevalues(e.f.i); + this.removevalues(e.t.i); + } + + void indexed(expdesc t, expdesc k) { + t.u.s.aux = this.exp2RK(k); + t.k = LexState.VINDEXED; + } + + boolean constfolding(int op, expdesc e1, expdesc e2) { + LNumber v1, v2, r; + if (!e1.isnumeral() || !e2.isnumeral()) + return false; + v1 = e1.u.nval(); + v2 = e2.u.nval(); + switch (op) { + case OP_ADD: + case OP_SUB: + case OP_MUL: + case OP_DIV: + case OP_MOD: + r = (LNumber) v2.luaBinOpUnknown(op, v1); + break; + case OP_POW: + r = new LDouble( Math.pow(v1.luaAsDouble(), v2.luaAsDouble() ) ); + break; + case OP_UNM: + r = (LNumber) v1.luaUnaryMinus(); + break; + case OP_LEN: + return false; /* no constant folding for 'len' */ + default: + _assert (false); + r = null; + break; + } + if (Double.NaN == r.luaAsDouble()) + return false; /* do not attempt to produce NaN */ + e1.u.setNval( r ); + return true; + } + + void codearith(int op, expdesc e1, expdesc e2) { + if (constfolding(op, e1, e2)) + return; + else { + int o2 = (op != OP_UNM && op != OP_LEN) ? this.exp2RK(e2) + : 0; + int o1 = this.exp2RK(e1); + if (o1 > o2) { + this.freeexp(e1); + this.freeexp(e2); + } else { + this.freeexp(e2); + this.freeexp(e1); + } + e1.u.s.info = this.codeABC(op, 0, o1, o2); + e1.k = LexState.VRELOCABLE; + } + } + + void codecomp(int /* OpCode */op, int cond, expdesc e1, expdesc e2) { + int o1 = this.exp2RK(e1); + int o2 = this.exp2RK(e2); + this.freeexp(e2); + this.freeexp(e1); + if (cond == 0 && op != OP_EQ) { + int temp; /* exchange args to replace by `<' or `<=' */ + temp = o1; + o1 = o2; + o2 = temp; /* o1 <==> o2 */ + cond = 1; + } + e1.u.s.info = this.condjump(op, cond, o1, o2); + e1.k = LexState.VJMP; + } + + void prefix(int /* UnOpr */op, expdesc e) { + expdesc e2 = new expdesc(); + e2.init(LexState.VKNUM, 0); + switch (op) { + case LexState.OPR_MINUS: { + if (e.k == LexState.VK) + this.exp2anyreg(e); /* cannot operate on non-numeric constants */ + this.codearith(OP_UNM, e, e2); + break; + } + case LexState.OPR_NOT: + this.codenot(e); + break; + case LexState.OPR_LEN: { + this.exp2anyreg(e); /* cannot operate on constants */ + this.codearith(OP_LEN, e, e2); + break; + } + default: + _assert (false); + } + } + + void infix(int /* BinOpr */op, expdesc v) { + switch (op) { + case LexState.OPR_AND: { + this.goiftrue(v); + break; + } + case LexState.OPR_OR: { + this.goiffalse(v); + break; + } + case LexState.OPR_CONCAT: { + this.exp2nextreg(v); /* operand must be on the `stack' */ + break; + } + case LexState.OPR_ADD: + case LexState.OPR_SUB: + case LexState.OPR_MUL: + case LexState.OPR_DIV: + case LexState.OPR_MOD: + case LexState.OPR_POW: { + if (!v.isnumeral()) + this.exp2RK(v); + break; + } + default: { + this.exp2RK(v); + break; + } + } + } + + + void posfix(int op, expdesc e1, expdesc e2) { + switch (op) { + case LexState.OPR_AND: { + _assert (e1.t.i == LexState.NO_JUMP); /* list must be closed */ + this.dischargevars(e2); + this.concat(e2.f, e1.f.i); + // *e1 = *e2; + e1.setvalue(e2); + break; + } + case LexState.OPR_OR: { + _assert (e1.f.i == LexState.NO_JUMP); /* list must be closed */ + this.dischargevars(e2); + this.concat(e2.t, e1.t.i); + // *e1 = *e2; + e1.setvalue(e2); + break; + } + case LexState.OPR_CONCAT: { + this.exp2val(e2); + if (e2.k == LexState.VRELOCABLE + && GET_OPCODE(this.getcode(e2)) == OP_CONCAT) { + _assert (e1.u.s.info == GETARG_B(this.getcode(e2)) - 1); + this.freeexp(e1); + SETARG_B(this.getcodePtr(e2), e1.u.s.info); + e1.k = LexState.VRELOCABLE; + e1.u.s.info = e2.u.s.info; + } else { + this.exp2nextreg(e2); /* operand must be on the 'stack' */ + this.codearith(OP_CONCAT, e1, e2); + } + break; + } + case LexState.OPR_ADD: + this.codearith(OP_ADD, e1, e2); + break; + case LexState.OPR_SUB: + this.codearith(OP_SUB, e1, e2); + break; + case LexState.OPR_MUL: + this.codearith(OP_MUL, e1, e2); + break; + case LexState.OPR_DIV: + this.codearith(OP_DIV, e1, e2); + break; + case LexState.OPR_MOD: + this.codearith(OP_MOD, e1, e2); + break; + case LexState.OPR_POW: + this.codearith(OP_POW, e1, e2); + break; + case LexState.OPR_EQ: + this.codecomp(OP_EQ, 1, e1, e2); + break; + case LexState.OPR_NE: + this.codecomp(OP_EQ, 0, e1, e2); + break; + case LexState.OPR_LT: + this.codecomp(OP_LT, 1, e1, e2); + break; + case LexState.OPR_LE: + this.codecomp(OP_LE, 1, e1, e2); + break; + case LexState.OPR_GT: + this.codecomp(OP_LT, 0, e1, e2); + break; + case LexState.OPR_GE: + this.codecomp(OP_LE, 0, e1, e2); + break; + default: + _assert (false); + } + } + + + void fixline(int line) { + this.f.lineinfo[this.pc - 1] = line; + } + + + int code(int instruction, int line) { + Proto f = this.f; + this.dischargejpc(); /* `pc' will change */ + /* put new instruction in code array */ + if (f.code == null || this.pc + 1 > f.code.length) + f.code = LexState.realloc(f.code, this.pc * 2 + 1); + f.code[this.pc] = instruction; + /* save corresponding line information */ + if (f.lineinfo == null || this.pc + 1 > f.lineinfo.length) + f.lineinfo = LexState.realloc(f.lineinfo, + this.pc * 2 + 1); + f.lineinfo[this.pc] = line; + return this.pc++; + } + + + int codeABC(int o, int a, int b, int c) { + _assert (getOpMode(o) == iABC); + _assert (getBMode(o) != OpArgN || b == 0); + _assert (getCMode(o) != OpArgN || c == 0); + return this.code(CREATE_ABC(o, a, b, c), this.ls.lastline); + } + + + int codeABx(int o, int a, int bc) { + _assert (getOpMode(o) == iABx || getOpMode(o) == iAsBx); + _assert (getCMode(o) == OpArgN); + return this.code(CREATE_ABx(o, a, bc), this.ls.lastline); + } + + + void setlist(int base, int nelems, int tostore) { + int c = (nelems - 1) / LFIELDS_PER_FLUSH + 1; + int b = (tostore == LUA_MULTRET) ? 0 : tostore; + _assert (tostore != 0); + if (c <= MAXARG_C) + this.codeABC(OP_SETLIST, base, b, c); + else { + this.codeABC(OP_SETLIST, base, b, 0); + this.code(c, this.ls.lastline); + } + this.freereg = base + 1; /* free registers with list values */ + } + +} diff --git a/src/addon/java/lua/addon/compile/InstructionPtr.java b/src/addon/java/lua/addon/compile/InstructionPtr.java new file mode 100644 index 00000000..23ef70dc --- /dev/null +++ b/src/addon/java/lua/addon/compile/InstructionPtr.java @@ -0,0 +1,17 @@ + +package lua.addon.compile; + +class InstructionPtr { + final int[] code; + final int idx; + InstructionPtr(int[] code, int idx ) { + this.code = code; + this.idx = idx; + } + int get() { + return code[idx]; + } + void set(int value) { + code[idx] = value; + } +} \ No newline at end of file diff --git a/src/addon/java/lua/addon/compile/IntPtr.java b/src/addon/java/lua/addon/compile/IntPtr.java new file mode 100644 index 00000000..5157cf9c --- /dev/null +++ b/src/addon/java/lua/addon/compile/IntPtr.java @@ -0,0 +1,10 @@ +package lua.addon.compile; + +public class IntPtr { + int i; + IntPtr() { + } + IntPtr(int value) { + this.i = value; + } +} diff --git a/src/addon/java/lua/addon/compile/LexState.java b/src/addon/java/lua/addon/compile/LexState.java new file mode 100644 index 00000000..4d2173ae --- /dev/null +++ b/src/addon/java/lua/addon/compile/LexState.java @@ -0,0 +1,1858 @@ +package lua.addon.compile; + +import java.io.IOException; +import java.io.Reader; +import java.text.NumberFormat; +import java.text.ParseException; +import java.util.Hashtable; + +import lua.Lua; +import lua.addon.compile.FuncState.BlockCnt; +import lua.io.LocVars; +import lua.io.Proto; +import lua.value.LDouble; +import lua.value.LInteger; +import lua.value.LNumber; +import lua.value.LString; + +public class LexState extends LuaC { + + private static final int EOZ = (-1); + private static final int MAXSRC = 80; + private static final int MAX_INT = Integer.MAX_VALUE-2; + private static final int UCHAR_MAX = 255; // TODO, convert to unicode CHAR_MAX? + private static final int LUAI_MAXCCALLS = 200; + + private static final String LUA_QS(String s) { return "'"+s+"'"; } + private static final String LUA_QL(Object o) { return LUA_QS(String.valueOf(o)); } + + + private static final int LUA_COMPAT_LSTR = 1; // 1 for compatibility, 2 for old behavior + private static final boolean LUA_COMPAT_VARARG = true; + + + + /* + ** Marks the end of a patch list. It is an invalid value both as an absolute + ** address, and as a list link (would link an element to itself). + */ + static final int NO_JUMP = (-1); + + /* + ** grep "ORDER OPR" if you change these enums + */ + static final int + OPR_ADD=0, OPR_SUB=1, OPR_MUL=2, OPR_DIV=3, OPR_MOD=4, OPR_POW=5, + OPR_CONCAT=6, + OPR_NE=7, OPR_EQ=8, + OPR_LT=9, OPR_LE=10, OPR_GT=11, OPR_GE=12, + OPR_AND=13, OPR_OR=14, + OPR_NOBINOPR=15; + + static final int + OPR_MINUS=0, OPR_NOT=1, OPR_LEN=2, OPR_NOUNOPR=3; + + /* exp kind */ + static final int + VVOID = 0, /* no value */ + VNIL = 1, + VTRUE = 2, + VFALSE = 3, + VK = 4, /* info = index of constant in `k' */ + VKNUM = 5, /* nval = numerical value */ + VLOCAL = 6, /* info = local register */ + VUPVAL = 7, /* info = index of upvalue in `upvalues' */ + VGLOBAL = 8, /* info = index of table, aux = index of global name in `k' */ + VINDEXED = 9, /* info = table register, aux = index register (or `k') */ + VJMP = 10, /* info = instruction pc */ + VRELOCABLE = 11, /* info = instruction pc */ + VNONRELOC = 12, /* info = result register */ + VCALL = 13, /* info = instruction pc */ + VVARARG = 14; /* info = instruction pc */ + + /* semantics information */ + private static class SemInfo { + LNumber r; + LString ts; + }; + + private static class Token { + int token; + final SemInfo seminfo = new SemInfo(); + public void set(Token other) { + this.token = other.token; + this.seminfo.r = other.seminfo.r; + this.seminfo.ts = other.seminfo.ts; + } + }; + + int current; /* current character (charint) */ + int linenumber; /* input line counter */ + int lastline; /* line of last token `consumed' */ + final Token t = new Token(); /* current token */ + final Token lookahead = new Token(); /* look ahead token */ + FuncState fs; /* `FuncState' is private to the parser */ + Compiler L; + Reader z; /* input stream */ + char[] buff; /* buffer for tokens */ + int nbuff; /* length of buffer */ + LString source; /* current source name */ + char decpoint; /* locale decimal point */ + + /* ORDER RESERVED */ + final static String luaX_tokens [] = { + "and", "break", "do", "else", "elseif", + "end", "false", "for", "function", "if", + "in", "local", "nil", "not", "or", "repeat", + "return", "then", "true", "until", "while", + "..", "...", "==", ">=", "<=", "~=", + "", "", "", "", + }; + + final static int + /* terminal symbols denoted by reserved words */ + TK_AND=257, TK_BREAK=258, TK_DO=259, TK_ELSE=260, TK_ELSEIF=261, + TK_END=262, TK_FALSE=263, TK_FOR=264, TK_FUNCTION=265, TK_IF=266, + TK_IN=267, TK_LOCAL=268, TK_NIL=269, TK_NOT=270, TK_OR=271, TK_REPEAT=272, + TK_RETURN=273, TK_THEN=274, TK_TRUE=275, TK_UNTIL=276, TK_WHILE=277, + /* other terminal symbols */ + TK_CONCAT=278, TK_DOTS=279, TK_EQ=280, TK_GE=281, TK_LE=282, TK_NE=283, + TK_NUMBER=284, TK_NAME=285, TK_STRING=286, TK_EOS=287; + + final static int FIRST_RESERVED = TK_AND; + final static int NUM_RESERVED = TK_WHILE+1-FIRST_RESERVED; + + final static Hashtable RESERVED = new Hashtable(); + static { + for ( int i=0; i buff.length ) + buff = realloc( buff, nbuff*2+1 ); + buff[nbuff++] = (char) c; + } + + + String token2str( int token ) { + if ( token < FIRST_RESERVED ) { + return iscntrl(token)? + L.pushfstring( "char("+((int)token)+")" ): + L.pushfstring( String.valueOf( (char) token ) ); + } else { + return luaX_tokens[token-FIRST_RESERVED]; + } + } + + private static boolean iscntrl(int token) { + return token < ' '; + } + + String txtToken(int token) { + switch ( token ) { + case TK_NAME: + case TK_STRING: + case TK_NUMBER: + return new String( buff, 0, nbuff ); + default: + return token2str( token ); + } + } + + void lexerror( String msg, int token ) { + String cid = chunkid( source.toString() ); // TODO: get source name from source + L.pushfstring( cid+":"+linenumber+": "+msg ); + if ( token != 0 ) + L.pushfstring( "syntax error: "+msg+" near "+txtToken(token) ); + throw new RuntimeException(cid+":"+linenumber+": "+msg); + } + + String chunkid( String source ) { + if ( source.startsWith("=") ) + return source.substring(1); + String end = ""; + if ( source.startsWith("@") ) { + source = source.substring(1); + } else { + source = "[string \""+source; + end = "\"]"; + } + int n = source.length() + end.length(); + if ( n > MAXSRC ) + source = source.substring(0,MAXSRC-end.length()-3) + "..."; + return source + end; + } + + void syntaxerror( String msg ) { + lexerror( msg, t.token ); + } + + LString newstring( char[] chars, int offset, int len) { + return newstring( new String(chars, offset, len) ); + } + + LString newstring( String s ) { + return L.newTString( s ); + } + + void inclinenumber() { + int old = current; + _assert( currIsNewline() ); + nextChar(); /* skip '\n' or '\r' */ + if ( currIsNewline() && current != old ) + nextChar(); /* skip '\n\r' or '\r\n' */ + if ( ++linenumber >= MAX_INT ) + syntaxerror("chunk has too many lines"); + } + + void setinput( Compiler L, Reader z, LString source ) { + this.decpoint = '.'; + this.L = L; + this.lookahead.token = TK_EOS; /* no look-ahead token */ + this.z = z; + this.fs = null; + this.linenumber = 1; + this.lastline = 1; + this.source = source; + this.nbuff = 0; /* initialize buffer */ + this.nextChar(); /* read first char */ + this.skipShebang(); + } + + private void skipShebang() { + if ( current == '#' ) + while (!currIsNewline() && current != EOZ) + nextChar(); + } + + + + /* + ** ======================================================= + ** LEXICAL ANALYZER + ** ======================================================= + */ + + + boolean check_next(String set) { + if (set.indexOf(current) < 0) + return false; + save_and_next(); + return true; + } + + void buffreplace(char from, char to) { + int n = nbuff; + char[] p = buff; + while ((--n) >= 0) + if (p[n] == from) + p[n] = to; + } + + boolean str2d(String str, SemInfo seminfo) { + try { + double d = Double.parseDouble(str); + seminfo.r = new LDouble(d); + return true; + } catch (NumberFormatException e) { + e.printStackTrace(); + return false; + } + } + + // + // TODO: reexamine this source and see if it should be ported differently + // + // static void trydecpoint (LexState *ls, SemInfo *seminfo) { + // /* format error: try to update decimal point separator */ + // struct lconv *cv = localeconv(); + // char old = this.decpoint; + // this.decpoint = (cv ? cv->decimal_point[0] : '.'); + // buffreplace(ls, old, this.decpoint); /* try updated decimal separator */ + // if (!luaO_str2d(luaZ_buffer(this.buff), &seminfo->r)) { + // /* format error with correct decimal point: no more options */ + // buffreplace(ls, this.decpoint, '.'); /* undo change (for error message) */ + // luaX_lexerror(ls, "malformed number", TK_NUMBER); + // } + // } + // + void trydecpoint(String str, SemInfo seminfo) { + NumberFormat nf = NumberFormat.getInstance(); + try { + Number n = nf.parse(str); + double d = n.doubleValue(); + seminfo.r = new LDouble(d); + } catch (ParseException e) { + lexerror("malformed number", TK_NUMBER); + } + } + + void read_numeral(SemInfo seminfo) { + _assert (isdigit(current)); + do { + save_and_next(); + } while (isdigit(current) || current == '.'); + if (check_next("Ee")) /* `E'? */ + check_next("+-"); /* optional exponent sign */ + while (isalnum(current) || current == '_') + save_and_next(); + save('\0'); + buffreplace('.', decpoint); /* follow locale for decimal point */ + String str = new String(buff, 0, nbuff); + if (!str2d(str, seminfo)) /* format error? */ + trydecpoint(str, seminfo); /* try to update decimal point separator */ + } + + int skip_sep() { + int count = 0; + int s = current; + _assert (s == '[' || s == ']'); + save_and_next(); + while (current == '=') { + save_and_next(); + count++; + } + return (current == s) ? count : (-count) - 1; + } + + void read_long_string(SemInfo seminfo, int sep) { + int cont = 0; + save_and_next(); /* skip 2nd `[' */ + if (currIsNewline()) /* string starts with a newline? */ + inclinenumber(); /* skip it */ + for (boolean endloop = false; !endloop;) { + switch (current) { + case EOZ: + lexerror((seminfo != null) ? "unfinished long string" + : "unfinished long comment", TK_EOS); + break; /* to avoid warnings */ + case '[': { + if (skip_sep() == sep) { + save_and_next(); /* skip 2nd `[' */ + cont++; + if (LUA_COMPAT_LSTR == 1) { + if (sep == 0) + lexerror("nesting of [[...]] is deprecated", '['); + } + } + break; + } + case ']': { + if (skip_sep() == sep) { + save_and_next(); /* skip 2nd `]' */ + if (LUA_COMPAT_LSTR == 2) { + cont--; + if (sep == 0 && cont >= 0) + break; + } + endloop = true; + } + break; + } + case '\n': + case '\r': { + save('\n'); + inclinenumber(); + if (seminfo == null) + nbuff = 0; /* avoid wasting space */ + break; + } + default: { + if (seminfo != null) + save_and_next(); + else + nextChar(); + } + } + } + if (seminfo != null) + seminfo.ts = newstring(buff, 2 + sep, nbuff - 2 * (2 + sep)); + } + + void read_string(int del, SemInfo seminfo) { + save_and_next(); + while (current != del) { + switch (current) { + case EOZ: + lexerror("unfinished string", TK_EOS); + continue; /* to avoid warnings */ + case '\n': + case '\r': + lexerror("unfinished string", TK_STRING); + continue; /* to avoid warnings */ + case '\\': { + int c; + nextChar(); /* do not save the `\' */ + switch (current) { + case 'a': /* bell */ + c = '\u0007'; + break; + case 'b': /* backspace */ + c = '\b'; + break; + case 'f': /* form feed */ + c = '\f'; + break; + case 'n': /* newline */ + c = '\n'; + break; + case 'r': /* carriage return */ + c = '\r'; + break; + case 't': /* tab */ + c = '\t'; + break; + case 'v': /* vertical tab */ + c = '\u000B'; + break; + case '\n': /* go through */ + case '\r': + save('\n'); + inclinenumber(); + continue; + case EOZ: + continue; /* will raise an error next loop */ + default: { + if (!isdigit(current)) + save_and_next(); /* handles \\, \", \', and \? */ + else { /* \xxx */ + int i = 0; + c = 0; + do { + c = 10 * c + (current - '0'); + nextChar(); + } while (++i < 3 && isdigit(current)); + if (c > UCHAR_MAX) + lexerror("escape sequence too large", TK_STRING); + save(c); + } + continue; + } + } + save(c); + nextChar(); + continue; + } + default: + save_and_next(); + } + } + save_and_next(); /* skip delimiter */ + seminfo.ts = newstring(buff, 1, nbuff - 2); + } + + int llex(SemInfo seminfo) { + nbuff = 0; + while (true) { + switch (current) { + case '\n': + case '\r': { + inclinenumber(); + continue; + } + case '-': { + nextChar(); + if (current != '-') + return '-'; + /* else is a comment */ + nextChar(); + if (current == '[') { + int sep = skip_sep(); + nbuff = 0; /* `skip_sep' may dirty the buffer */ + if (sep >= 0) { + read_long_string(null, sep); /* long comment */ + nbuff = 0; + continue; + } + } + /* else short comment */ + while (!currIsNewline() && current != EOZ) + nextChar(); + continue; + } + case '[': { + int sep = skip_sep(); + if (sep >= 0) { + read_long_string(seminfo, sep); + return TK_STRING; + } else if (sep == -1) + return '['; + else + lexerror("invalid long string delimiter", TK_STRING); + } + case '=': { + nextChar(); + if (current != '=') + return '='; + else { + nextChar(); + return TK_EQ; + } + } + case '<': { + nextChar(); + if (current != '=') + return '<'; + else { + nextChar(); + return TK_LE; + } + } + case '>': { + nextChar(); + if (current != '=') + return '>'; + else { + nextChar(); + return TK_GE; + } + } + case '~': { + nextChar(); + if (current != '=') + return '~'; + else { + nextChar(); + return TK_NE; + } + } + case '"': + case '\'': { + read_string(current, seminfo); + return TK_STRING; + } + case '.': { + save_and_next(); + if (check_next(".")) { + if (check_next(".")) + return TK_DOTS; /* ... */ + else + return TK_CONCAT; /* .. */ + } else if (!isdigit(current)) + return '.'; + else { + read_numeral(seminfo); + return TK_NUMBER; + } + } + case EOZ: { + return TK_EOS; + } + default: { + if (isspace(current)) { + _assert (!currIsNewline()); + nextChar(); + continue; + } else if (isdigit(current)) { + read_numeral(seminfo); + return TK_NUMBER; + } else if (isalpha(current) || current == '_') { + /* identifier or reserved word */ + LString ts; + do { + save_and_next(); + } while (isalnum(current) || current == '_'); + ts = newstring(buff, 0, nbuff); + if ( RESERVED.containsKey(ts) ) + return ((Integer)RESERVED.get(ts)).intValue(); + else { + seminfo.ts = ts; + return TK_NAME; + } + } else { + int c = current; + nextChar(); + return c; /* single-char tokens (+ - / ...) */ + } + } + } + } + } + + void next() { + lastline = linenumber; + if (lookahead.token != TK_EOS) { /* is there a look-ahead token? */ + t.set( lookahead ); /* use this one */ + lookahead.token = TK_EOS; /* and discharge it */ + } else + t.token = llex(t.seminfo); /* read next token */ + } + + void lookahead() { + _assert (lookahead.token == TK_EOS); + lookahead.token = llex(lookahead.seminfo); + } + + // ============================================================= + // from lcode.h + // ============================================================= + + + // ============================================================= + // from lparser.c + // ============================================================= + + static class expdesc { + int k; // expkind, from enumerated list, above + static class U { // originally a union + static class S { + int info, aux; + } + final S s = new S(); + private LNumber _nval; + public void setNval(LNumber r) { + _nval = r; + } + public LNumber nval() { + return (_nval == null? new LInteger(s.info): _nval); + } + }; + final U u = new U(); + final IntPtr t = new IntPtr(); /* patch list of `exit when true' */ + final IntPtr f = new IntPtr(); /* patch list of `exit when false' */ + void init( int k, int i ) { + this.f.i = NO_JUMP; + this.t.i = NO_JUMP; + this.k = k; + this.u.s.info = i; + } + + boolean hasjumps() { + return (t.i != f.i); + } + + boolean isnumeral() { + return (k == VKNUM && t.i == NO_JUMP && f.i == NO_JUMP); + } + + public void setvalue(expdesc other) { + this.k = other.k; + this.u._nval = other.u._nval; + this.u.s.info = other.u.s.info; + this.u.s.aux = other.u.s.aux; + this.t.i = other.t.i; + this.f.i = other.f.i; + } + } + + boolean hasmultret(int k) { + return ((k) == VCALL || (k) == VVARARG); + } + + /*---------------------------------------------------------------------- + name args description + ------------------------------------------------------------------------*/ + + /* + * * prototypes for recursive non-terminal functions + */ + + void error_expected(int token) { + syntaxerror(L.pushfstring(LUA_QS(token2str(token)) + " expected")); + } + + boolean testnext(int c) { + if (t.token == c) { + next(); + return true; + } else + return false; + } + + void check(int c) { + if (t.token != c) + error_expected(c); + } + + void checknext (int c) { + check(c); + next(); + } + + void check_condition(boolean c, String msg) { + if (!(c)) + syntaxerror(msg); + } + + + void check_match(int what, int who, int where) { + if (!testnext(what)) { + if (where == linenumber) + error_expected(what); + else { + syntaxerror(L.pushfstring(LUA_QS(token2str(what)) + + " expected " + "(to close " + LUA_QS(token2str(who)) + + " at line " + where + ")")); + } + } + } + + LString str_checkname() { + LString ts; + check(TK_NAME); + ts = t.seminfo.ts; + next(); + return ts; + } + + void codestring(expdesc e, LString s) { + e.init(VK, fs.stringK(s)); + } + + void checkname(expdesc e) { + codestring(e, str_checkname()); + } + + + int registerlocalvar(LString varname) { + FuncState fs = this.fs; + Proto f = fs.f; + if (f.locvars == null || fs.nlocvars + 1 > f.locvars.length) + f.locvars = realloc( f.locvars, fs.nlocvars*2+1 ); + f.locvars[fs.nlocvars] = new LocVars(varname,0,0); + return fs.nlocvars++; + } + + +// +// #define new_localvarliteral(ls,v,n) \ +// this.new_localvar(luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char))-1), n) +// + void new_localvarliteral(String v, int n) { + LString ts = newstring(v); + new_localvar(ts, n); + } + + void new_localvar(LString name, int n) { + FuncState fs = this.fs; + fs.checklimit(fs.nactvar + n + 1, FuncState.LUAI_MAXVARS, "local variables"); + fs.actvar[fs.nactvar + n] = (short) registerlocalvar(name); + } + + void adjustlocalvars(int nvars) { + FuncState fs = this.fs; + fs.nactvar = (byte) (fs.nactvar + nvars); + for (; nvars > 0; nvars--) { + fs.getlocvar(fs.nactvar - nvars).startpc = fs.pc; + } + } + + void removevars(int tolevel) { + FuncState fs = this.fs; + while (fs.nactvar > tolevel) + fs.getlocvar(--fs.nactvar).endpc = fs.pc; + } + + void singlevar(expdesc var) { + LString varname = this.str_checkname(); + FuncState fs = this.fs; + if (fs.singlevaraux(varname, var, 1) == VGLOBAL) + var.u.s.info = fs.stringK(varname); /* info points to global name */ + } + + void adjust_assign(int nvars, int nexps, expdesc e) { + FuncState fs = this.fs; + int extra = nvars - nexps; + if (hasmultret(e.k)) { + /* includes call itself */ + extra++; + if (extra < 0) + extra = 0; + /* last exp. provides the difference */ + fs.setreturns(e, extra); + if (extra > 1) + fs.reserveregs(extra - 1); + } else { + /* close last expression */ + if (e.k != VVOID) + fs.exp2nextreg(e); + if (extra > 0) { + int reg = fs.freereg; + fs.reserveregs(extra); + fs.nil(reg, extra); + } + } + } + + void enterlevel() { + if (++L.nCcalls > LUAI_MAXCCALLS) + lexerror("chunk has too many syntax levels", 0); + } + + void leavelevel() { + L.nCcalls--; + } + + void pushclosure(FuncState func, expdesc v) { + FuncState fs = this.fs; + Proto f = fs.f; + if (f.p == null || fs.np + 1 > f.p.length) + f.p = realloc( f.p, fs.np*2 + 1 ); + f.p[fs.np++] = func.f; + v.init(VRELOCABLE, fs.codeABx(Lua.OP_CLOSURE, 0, fs.np - 1)); + for (int i = 0; i < func.f.nups; i++) { + int o = (func.upvalues[i].k == VLOCAL) ? Lua.OP_MOVE + : Lua.OP_GETUPVAL; + fs.codeABC(o, 0, func.upvalues[i].info, 0); + } + } + + void open_func (FuncState fs) { + Compiler L = this.L; + Proto f = new Proto(); + if ( this.fs!=null ) + f.source = this.fs.f.source; + fs.f = f; + fs.prev = this.fs; /* linked list of funcstates */ + fs.ls = this; + fs.L = L; + this.fs = fs; + fs.pc = 0; + fs.lasttarget = -1; + fs.jpc = new IntPtr( NO_JUMP ); + fs.freereg = 0; + fs.nk = 0; + fs.np = 0; + fs.nlocvars = 0; + fs.nactvar = 0; + fs.bl = null; + f.maxstacksize = 2; /* registers 0/1 are always valid */ + //fs.h = new LTable(); + fs.htable = new Hashtable(); + fs.varargflags = 0; + } + + void close_func() { + Compiler L = this.L; + FuncState fs = this.fs; + Proto f = fs.f; + this.removevars(0); + fs.ret(0, 0); /* final return */ + f.code = realloc(f.code, fs.pc); + f.lineinfo = realloc(f.lineinfo, fs.pc); + // f.sizelineinfo = fs.pc; + f.k = realloc(f.k, fs.nk); + f.p = realloc(f.p, fs.np); + f.locvars = realloc(f.locvars, fs.nlocvars); + // f.sizelocvars = fs.nlocvars; + f.upvalues = realloc(f.upvalues, f.nups); + _assert (CheckCode.checkcode(f)); + _assert (fs.bl == null); + this.fs = fs.prev; +// L.top -= 2; /* remove table and prototype from the stack */ + // /* last token read was anchored in defunct function; must reanchor it + // */ + // if (fs!=null) ls.anchor_token(); + } + + /*============================================================*/ + /* GRAMMAR RULES */ + /*============================================================*/ + + void field(expdesc v) { + /* field -> ['.' | ':'] NAME */ + FuncState fs = this.fs; + expdesc key = new expdesc(); + fs.exp2anyreg(v); + this.next(); /* skip the dot or colon */ + this.checkname(key); + fs.indexed(v, key); + } + + void yindex(expdesc v) { + /* index -> '[' expr ']' */ + this.next(); /* skip the '[' */ + this.expr(v); + this.fs.exp2val(v); + this.checknext(']'); + } + + + /* + ** {====================================================================== + ** Rules for Constructors + ** ======================================================================= + */ + + + static class ConsControl { + expdesc v = new expdesc(); /* last list item read */ + expdesc t; /* table descriptor */ + int nh; /* total number of `record' elements */ + int na; /* total number of array elements */ + int tostore; /* number of array elements pending to be stored */ + }; + + + void recfield(ConsControl cc) { + /* recfield -> (NAME | `['exp1`]') = exp1 */ + FuncState fs = this.fs; + int reg = this.fs.freereg; + expdesc key = new expdesc(); + expdesc val = new expdesc(); + int rkkey; + if (this.t.token == TK_NAME) { + fs.checklimit(cc.nh, MAX_INT, "items in a constructor"); + this.checkname(key); + } else + /* this.t.token == '[' */ + this.yindex(key); + cc.nh++; + this.checknext('='); + rkkey = fs.exp2RK(key); + this.expr(val); + fs.codeABC(Lua.OP_SETTABLE, cc.t.u.s.info, rkkey, fs.exp2RK(val)); + fs.freereg = reg; /* free registers */ + } + + void listfield (ConsControl cc) { + this.expr(cc.v); + fs.checklimit(cc.na, MAX_INT, "items in a constructor"); + cc.na++; + cc.tostore++; + } + + + void constructor(expdesc t) { + /* constructor -> ?? */ + FuncState fs = this.fs; + int line = this.linenumber; + int pc = fs.codeABC(Lua.OP_NEWTABLE, 0, 0, 0); + ConsControl cc = new ConsControl(); + cc.na = cc.nh = cc.tostore = 0; + cc.t = t; + t.init(VRELOCABLE, pc); + cc.v.init(VVOID, 0); /* no value (yet) */ + fs.exp2nextreg(t); /* fix it at stack top (for gc) */ + this.checknext('{'); + do { + _assert (cc.v.k == VVOID || cc.tostore > 0); + if (this.t.token == '}') + break; + fs.closelistfield(cc); + switch (this.t.token) { + case TK_NAME: { /* may be listfields or recfields */ + this.lookahead(); + if (this.lookahead.token != '=') /* expression? */ + this.listfield(cc); + else + this.recfield(cc); + break; + } + case '[': { /* constructor_item -> recfield */ + this.recfield(cc); + break; + } + default: { /* constructor_part -> listfield */ + this.listfield(cc); + break; + } + } + } while (this.testnext(',') || this.testnext(';')); + this.check_match('}', '{', line); + fs.lastlistfield(cc); + InstructionPtr i = new InstructionPtr(fs.f.code, pc); + SETARG_B(i, luaO_int2fb(cc.na)); /* set initial array size */ + SETARG_C(i, luaO_int2fb(cc.nh)); /* set initial table size */ + } + + /* + ** converts an integer to a "floating point byte", represented as + ** (eeeeexxx), where the real value is (1xxx) * 2^(eeeee - 1) if + ** eeeee != 0 and (xxx) otherwise. + */ + static int luaO_int2fb (int x) { + int e = 0; /* expoent */ + while (x >= 16) { + x = (x+1) >> 1; + e++; + } + if (x < 8) return x; + else return ((e+1) << 3) | (((int)x) - 8); + } + + + /* }====================================================================== */ + + void parlist () { + /* parlist -> [ param { `,' param } ] */ + FuncState fs = this.fs; + Proto f = fs.f; + int nparams = 0; + f.is_vararg = false; + if (this.t.token != ')') { /* is `parlist' not empty? */ + do { + switch (this.t.token) { + case TK_NAME: { /* param . NAME */ + this.new_localvar(this.str_checkname(), nparams++); + break; + } + case TK_DOTS: { /* param . `...' */ + this.next(); + if (LUA_COMPAT_VARARG) { + /* use `arg' as default name */ + this.new_localvarliteral("arg", nparams++); + // f.is_vararg = VARARG_HASARG | VARARG_NEEDSARG; + fs.varargflags = VARARG_HASARG | VARARG_NEEDSARG; + } + // f.is_vararg |= VARARG_ISVARARG; + fs.varargflags |= VARARG_ISVARARG; + f.is_vararg = true; + break; + } + default: this.syntaxerror(" or " + LUA_QL("...") + " expected"); + } + } while (!f.is_vararg && this.testnext(',')); + } + this.adjustlocalvars(nparams); + f.numparams = (fs.nactvar - (fs.varargflags & VARARG_HASARG)); + fs.reserveregs(fs.nactvar); /* reserve register for parameters */ + } + + + void body(expdesc e, boolean needself, int line) { + /* body -> `(' parlist `)' chunk END */ + FuncState new_fs = new FuncState(); + open_func(new_fs); + new_fs.f.linedefined = line; + this.checknext('('); + if (needself) { + new_localvarliteral("self", 0); + adjustlocalvars(1); + } + this.parlist(); + this.checknext(')'); + this.chunk(); + new_fs.f.lastlinedefined = this.linenumber; + this.check_match(TK_END, TK_FUNCTION, line); + this.close_func(); + this.pushclosure(new_fs, e); + } + + int explist1(expdesc v) { + /* explist1 -> expr { `,' expr } */ + int n = 1; /* at least one expression */ + this.expr(v); + while (this.testnext(',')) { + fs.exp2nextreg(v); + this.expr(v); + n++; + } + return n; + } + + + void funcargs(expdesc f) { + FuncState fs = this.fs; + expdesc args = new expdesc(); + int base, nparams; + int line = this.linenumber; + switch (this.t.token) { + case '(': { /* funcargs -> `(' [ explist1 ] `)' */ + if (line != this.lastline) + this.syntaxerror("ambiguous syntax (function call x new statement)"); + this.next(); + if (this.t.token == ')') /* arg list is empty? */ + args.k = VVOID; + else { + this.explist1(args); + fs.setmultret(args); + } + this.check_match(')', '(', line); + break; + } + case '{': { /* funcargs -> constructor */ + this.constructor(args); + break; + } + case TK_STRING: { /* funcargs -> STRING */ + this.codestring(args, this.t.seminfo.ts); + this.next(); /* must use `seminfo' before `next' */ + break; + } + default: { + this.syntaxerror("function arguments expected"); + return; + } + } + _assert (f.k == VNONRELOC); + base = f.u.s.info; /* base register for call */ + if (hasmultret(args.k)) + nparams = Lua.LUA_MULTRET; /* open call */ + else { + if (args.k != VVOID) + fs.exp2nextreg(args); /* close last argument */ + nparams = fs.freereg - (base + 1); + } + f.init(VCALL, fs.codeABC(Lua.OP_CALL, base, nparams + 1, 2)); + fs.fixline(line); + fs.freereg = base+1; /* call remove function and arguments and leaves + * (unless changed) one result */ + } + + + /* + ** {====================================================================== + ** Expression parsing + ** ======================================================================= + */ + + void prefixexp(expdesc v) { + /* prefixexp -> NAME | '(' expr ')' */ + switch (this.t.token) { + case '(': { + int line = this.linenumber; + this.next(); + this.expr(v); + this.check_match(')', '(', line); + fs.dischargevars(v); + return; + } + case TK_NAME: { + this.singlevar(v); + return; + } + default: { + this.syntaxerror("unexpected symbol"); + return; + } + } + } + + + void primaryexp(expdesc v) { + /* + * primaryexp -> prefixexp { `.' NAME | `[' exp `]' | `:' NAME funcargs | + * funcargs } + */ + FuncState fs = this.fs; + this.prefixexp(v); + for (;;) { + switch (this.t.token) { + case '.': { /* field */ + this.field(v); + break; + } + case '[': { /* `[' exp1 `]' */ + expdesc key = new expdesc(); + fs.exp2anyreg(v); + this.yindex(key); + fs.indexed(v, key); + break; + } + case ':': { /* `:' NAME funcargs */ + expdesc key = new expdesc(); + this.next(); + this.checkname(key); + fs.self(v, key); + this.funcargs(v); + break; + } + case '(': + case TK_STRING: + case '{': { /* funcargs */ + fs.exp2nextreg(v); + this.funcargs(v); + break; + } + default: + return; + } + } + } + + + void simpleexp(expdesc v) { + /* + * simpleexp -> NUMBER | STRING | NIL | true | false | ... | constructor | + * FUNCTION body | primaryexp + */ + switch (this.t.token) { + case TK_NUMBER: { + v.init(VKNUM, 0); + v.u.setNval(this.t.seminfo.r); + break; + } + case TK_STRING: { + this.codestring(v, this.t.seminfo.ts); + break; + } + case TK_NIL: { + v.init(VNIL, 0); + break; + } + case TK_TRUE: { + v.init(VTRUE, 0); + break; + } + case TK_FALSE: { + v.init(VFALSE, 0); + break; + } + case TK_DOTS: { /* vararg */ + FuncState fs = this.fs; + this.check_condition(fs.f.is_vararg, "cannot use " + LUA_QL("...") + + " outside a vararg function"); + // fs.f.is_vararg &= ~VARARG_NEEDSARG; /* don't need 'arg' */ + fs.varargflags &= ~VARARG_NEEDSARG; /* don't need 'arg' */ + fs.f.is_vararg = (fs.varargflags != 0); + v.init(VVARARG, fs.codeABC(Lua.OP_VARARG, 0, 1, 0)); + break; + } + case '{': { /* constructor */ + this.constructor(v); + return; + } + case TK_FUNCTION: { + this.next(); + this.body(v, false, this.linenumber); + return; + } + default: { + this.primaryexp(v); + return; + } + } + this.next(); + } + + + int getunopr(int op) { + switch (op) { + case TK_NOT: + return OPR_NOT; + case '-': + return OPR_MINUS; + case '#': + return OPR_LEN; + default: + return OPR_NOUNOPR; + } + } + + + int getbinopr(int op) { + switch (op) { + case '+': + return OPR_ADD; + case '-': + return OPR_SUB; + case '*': + return OPR_MUL; + case '/': + return OPR_DIV; + case '%': + return OPR_MOD; + case '^': + return OPR_POW; + case TK_CONCAT: + return OPR_CONCAT; + case TK_NE: + return OPR_NE; + case TK_EQ: + return OPR_EQ; + case '<': + return OPR_LT; + case TK_LE: + return OPR_LE; + case '>': + return OPR_GT; + case TK_GE: + return OPR_GE; + case TK_AND: + return OPR_AND; + case TK_OR: + return OPR_OR; + default: + return OPR_NOBINOPR; + } + } + + static class Priority { + final byte left; /* left priority for each binary operator */ + + final byte right; /* right priority */ + + public Priority(int i, int j) { + left = (byte) i; + right = (byte) j; + } + }; + + static Priority[] priority = { /* ORDER OPR */ + new Priority(6, 6), new Priority(6, 6), new Priority(7, 7), new Priority(7, 7), new Priority(7, 7), /* `+' `-' `/' `%' */ + new Priority(10, 9), new Priority(5, 4), /* power and concat (right associative) */ + new Priority(3, 3), new Priority(3, 3), /* equality and inequality */ + new Priority(3, 3), new Priority(3, 3), new Priority(3, 3), new Priority(3, 3), /* order */ + new Priority(2, 2), new Priority(1, 1) /* logical (and/or) */ + }; + + static final int UNARY_PRIORITY = 8; /* priority for unary operators */ + + + /* + ** subexpr -> (simpleexp | unop subexpr) { binop subexpr } + ** where `binop' is any binary operator with a priority higher than `limit' + */ + int subexpr(expdesc v, int limit) { + int op; + int uop; + this.enterlevel(); + uop = getunopr(this.t.token); + if (uop != OPR_NOUNOPR) { + this.next(); + this.subexpr(v, UNARY_PRIORITY); + fs.prefix(uop, v); + } else + this.simpleexp(v); + /* expand while operators have priorities higher than `limit' */ + op = getbinopr(this.t.token); + while (op != OPR_NOBINOPR && priority[op].left > limit) { + expdesc v2 = new expdesc(); + int nextop; + this.next(); + fs.infix(op, v); + /* read sub-expression with higher priority */ + nextop = this.subexpr(v2, priority[op].right); + fs.posfix(op, v, v2); + op = nextop; + } + this.leavelevel(); + return op; /* return first untreated operator */ + } + + void expr(expdesc v) { + this.subexpr(v, 0); + } + + /* }==================================================================== */ + + + + /* + ** {====================================================================== + ** Rules for Statements + ** ======================================================================= + */ + + + boolean block_follow (int token) { + switch (token) { + case TK_ELSE: case TK_ELSEIF: case TK_END: + case TK_UNTIL: case TK_EOS: + return true; + default: return false; + } + } + + + void block () { + /* block -> chunk */ + FuncState fs = this.fs; + BlockCnt bl = new BlockCnt(); + fs.enterblock(bl, false); + this.chunk(); + _assert(bl.breaklist.i == NO_JUMP); + fs.leaveblock(); + } + + + /* + ** structure to chain all variables in the left-hand side of an + ** assignment + */ + static class LHS_assign { + LHS_assign prev; + /* variable (global, local, upvalue, or indexed) */ + expdesc v = new expdesc(); + }; + + + /* + ** check whether, in an assignment to a local variable, the local variable + ** is needed in a previous assignment (to a table). If so, save original + ** local value in a safe place and use this safe copy in the previous + ** assignment. + */ + void check_conflict (LHS_assign lh, expdesc v) { + FuncState fs = this.fs; + int extra = fs.freereg; /* eventual position to save local variable */ + boolean conflict = false; + for (; lh!=null; lh = lh.prev) { + if (lh.v.k == VINDEXED) { + if (lh.v.u.s.info == v.u.s.info) { /* conflict? */ + conflict = true; + lh.v.u.s.info = extra; /* previous assignment will use safe copy */ + } + if (lh.v.u.s.aux == v.u.s.info) { /* conflict? */ + conflict = true; + lh.v.u.s.aux = extra; /* previous assignment will use safe copy */ + } + } + } + if (conflict) { + fs.codeABC(Lua.OP_MOVE, fs.freereg, v.u.s.info, 0); /* make copy */ + fs.reserveregs(1); + } + } + + + void assignment (LHS_assign lh, int nvars) { + expdesc e = new expdesc(); + this.check_condition(VLOCAL <= lh.v.k && lh.v.k <= VINDEXED, + "syntax error"); + if (this.testnext(',')) { /* assignment -> `,' primaryexp assignment */ + LHS_assign nv = new LHS_assign(); + nv.prev = lh; + this.primaryexp(nv.v); + if (nv.v.k == VLOCAL) + this.check_conflict(lh, nv.v); + this.assignment(nv, nvars+1); + } + else { /* assignment . `=' explist1 */ + int nexps; + this.checknext('='); + nexps = this.explist1(e); + if (nexps != nvars) { + this.adjust_assign(nvars, nexps, e); + if (nexps > nvars) + this.fs.freereg -= nexps - nvars; /* remove extra values */ + } + else { + fs.setoneret(e); /* close last expression */ + fs.storevar(lh.v, e); + return; /* avoid default */ + } + } + e.init(VNONRELOC, this.fs.freereg-1); /* default assignment */ + fs.storevar(lh.v, e); + } + + + int cond() { + /* cond -> exp */ + expdesc v = new expdesc(); + /* read condition */ + this.expr(v); + /* `falses' are all equal here */ + if (v.k == VNIL) + v.k = VFALSE; + fs.goiftrue(v); + return v.f.i; + } + + + void breakstat() { + FuncState fs = this.fs; + BlockCnt bl = fs.bl; + boolean upval = false; + while (bl != null && !bl.isbreakable) { + upval |= bl.upval; + bl = bl.previous; + } + if (bl == null) + this.syntaxerror("no loop to break"); + if (upval) + fs.codeABC(Lua.OP_CLOSE, bl.nactvar, 0, 0); + fs.concat(bl.breaklist, fs.jump()); + } + + + void whilestat (int line) { + /* whilestat -> WHILE cond DO block END */ + FuncState fs = this.fs; + int whileinit; + int condexit; + BlockCnt bl = new BlockCnt(); + this.next(); /* skip WHILE */ + whileinit = fs.getlabel(); + condexit = this.cond(); + fs.enterblock(bl, true); + this.checknext(TK_DO); + this.block(); + fs.patchlist(fs.jump(), whileinit); + this.check_match(TK_END, TK_WHILE, line); + fs.leaveblock(); + fs.patchtohere(condexit); /* false conditions finish the loop */ + } + + void repeatstat(int line) { + /* repeatstat -> REPEAT block UNTIL cond */ + int condexit; + FuncState fs = this.fs; + int repeat_init = fs.getlabel(); + BlockCnt bl1 = new BlockCnt(); + BlockCnt bl2 = new BlockCnt(); + fs.enterblock(bl1, true); /* loop block */ + fs.enterblock(bl2, false); /* scope block */ + this.next(); /* skip REPEAT */ + this.chunk(); + this.check_match(TK_UNTIL, TK_REPEAT, line); + condexit = this.cond(); /* read condition (inside scope block) */ + if (!bl2.upval) { /* no upvalues? */ + fs.leaveblock(); /* finish scope */ + fs.patchlist(condexit, repeat_init); /* close the loop */ + } else { /* complete semantics when there are upvalues */ + this.breakstat(); /* if condition then break */ + fs.patchtohere(condexit); /* else... */ + fs.leaveblock(); /* finish scope... */ + fs.patchlist(fs.jump(), repeat_init); /* and repeat */ + } + fs.leaveblock(); /* finish loop */ + } + + + int exp1() { + expdesc e = new expdesc(); + int k; + this.expr(e); + k = e.k; + fs.exp2nextreg(e); + return k; + } + + + void forbody(int base, int line, int nvars, boolean isnum) { + /* forbody -> DO block */ + BlockCnt bl = new BlockCnt(); + FuncState fs = this.fs; + int prep, endfor; + this.adjustlocalvars(3); /* control variables */ + this.checknext(TK_DO); + prep = isnum ? fs.codeAsBx(Lua.OP_FORPREP, base, NO_JUMP) : fs.jump(); + fs.enterblock(bl, false); /* scope for declared variables */ + this.adjustlocalvars(nvars); + fs.reserveregs(nvars); + this.block(); + fs.leaveblock(); /* end of scope for declared variables */ + fs.patchtohere(prep); + endfor = (isnum) ? fs.codeAsBx(Lua.OP_FORLOOP, base, NO_JUMP) : fs + .codeABC(Lua.OP_TFORLOOP, base, 0, nvars); + fs.fixline(line); /* pretend that `Lua.OP_FOR' starts the loop */ + fs.patchlist((isnum ? endfor : fs.jump()), prep + 1); + } + + + void fornum(LString varname, int line) { + /* fornum -> NAME = exp1,exp1[,exp1] forbody */ + FuncState fs = this.fs; + int base = fs.freereg; + this.new_localvarliteral("(for index)", 0); + this.new_localvarliteral("(for limit)", 1); + this.new_localvarliteral("(for step)", 2); + this.new_localvar(varname, 3); + this.checknext('='); + this.exp1(); /* initial value */ + this.checknext(','); + this.exp1(); /* limit */ + if (this.testnext(',')) + this.exp1(); /* optional step */ + else { /* default step = 1 */ + fs.codeABx(Lua.OP_LOADK, fs.freereg, fs.numberK(new LInteger(1))); + fs.reserveregs(1); + } + this.forbody(base, line, 1, true); + } + + + void forlist(LString indexname) { + /* forlist -> NAME {,NAME} IN explist1 forbody */ + FuncState fs = this.fs; + expdesc e = new expdesc(); + int nvars = 0; + int line; + int base = fs.freereg; + /* create control variables */ + this.new_localvarliteral("(for generator)", nvars++); + this.new_localvarliteral("(for state)", nvars++); + this.new_localvarliteral("(for control)", nvars++); + /* create declared variables */ + this.new_localvar(indexname, nvars++); + while (this.testnext(',')) + this.new_localvar(this.str_checkname(), nvars++); + this.checknext(TK_IN); + line = this.linenumber; + this.adjust_assign(3, this.explist1(e), e); + fs.checkstack(3); /* extra space to call generator */ + this.forbody(base, line, nvars - 3, false); + } + + + void forstat(int line) { + /* forstat -> FOR (fornum | forlist) END */ + FuncState fs = this.fs; + LString varname; + BlockCnt bl = new BlockCnt(); + fs.enterblock(bl, true); /* scope for loop and control variables */ + this.next(); /* skip `for' */ + varname = this.str_checkname(); /* first variable name */ + switch (this.t.token) { + case '=': + this.fornum(varname, line); + break; + case ',': + case TK_IN: + this.forlist(varname); + break; + default: + this.syntaxerror(LUA_QL("=") + " or " + LUA_QL("in") + " expected"); + } + this.check_match(TK_END, TK_FOR, line); + fs.leaveblock(); /* loop scope (`break' jumps to this point) */ + } + + + int test_then_block() { + /* test_then_block -> [IF | ELSEIF] cond THEN block */ + int condexit; + this.next(); /* skip IF or ELSEIF */ + condexit = this.cond(); + this.checknext(TK_THEN); + this.block(); /* `then' part */ + return condexit; + } + + + void ifstat(int line) { + /* ifstat -> IF cond THEN block {ELSEIF cond THEN block} [ELSE block] + * END */ + FuncState fs = this.fs; + int flist; + IntPtr escapelist = new IntPtr(NO_JUMP); + flist = test_then_block(); /* IF cond THEN block */ + while (this.t.token == TK_ELSEIF) { + fs.concat(escapelist, fs.jump()); + fs.patchtohere(flist); + flist = test_then_block(); /* ELSEIF cond THEN block */ + } + if (this.t.token == TK_ELSE) { + fs.concat(escapelist, fs.jump()); + fs.patchtohere(flist); + this.next(); /* skip ELSE (after patch, for correct line info) */ + this.block(); /* `else' part */ + } else + fs.concat(escapelist, flist); + fs.patchtohere(escapelist.i); + this.check_match(TK_END, TK_IF, line); + } + + void localfunc() { + expdesc v = new expdesc(); + expdesc b = new expdesc(); + FuncState fs = this.fs; + this.new_localvar(this.str_checkname(), 0); + v.init(VLOCAL, fs.freereg); + fs.reserveregs(1); + this.adjustlocalvars(1); + this.body(b, false, this.linenumber); + fs.storevar(v, b); + /* debug information will only see the variable after this point! */ + fs.getlocvar(fs.nactvar - 1).startpc = fs.pc; + } + + + void localstat() { + /* stat -> LOCAL NAME {`,' NAME} [`=' explist1] */ + int nvars = 0; + int nexps; + expdesc e = new expdesc(); + do { + this.new_localvar(this.str_checkname(), nvars++); + } while (this.testnext(',')); + if (this.testnext('=')) + nexps = this.explist1(e); + else { + e.k = VVOID; + nexps = 0; + } + this.adjust_assign(nvars, nexps, e); + this.adjustlocalvars(nvars); + } + + + boolean funcname(expdesc v) { + /* funcname -> NAME {field} [`:' NAME] */ + boolean needself = false; + this.singlevar(v); + while (this.t.token == '.') + this.field(v); + if (this.t.token == ':') { + needself = true; + this.field(v); + } + return needself; + } + + + void funcstat(int line) { + /* funcstat -> FUNCTION funcname body */ + boolean needself; + expdesc v = new expdesc(); + expdesc b = new expdesc(); + this.next(); /* skip FUNCTION */ + needself = this.funcname(v); + this.body(b, needself, line); + fs.storevar(v, b); + fs.fixline(line); /* definition `happens' in the first line */ + } + + + void exprstat() { + /* stat -> func | assignment */ + FuncState fs = this.fs; + LHS_assign v = new LHS_assign(); + this.primaryexp(v.v); + if (v.v.k == VCALL) /* stat -> func */ + SETARG_C(fs.getcodePtr(v.v), 1); /* call statement uses no results */ + else { /* stat -> assignment */ + v.prev = null; + this.assignment(v, 1); + } + } + + void retstat() { + /* stat -> RETURN explist */ + FuncState fs = this.fs; + expdesc e = new expdesc(); + int first, nret; /* registers with returned values */ + this.next(); /* skip RETURN */ + if (block_follow(this.t.token) || this.t.token == ';') + first = nret = 0; /* return no values */ + else { + nret = this.explist1(e); /* optional return values */ + if (hasmultret(e.k)) { + fs.setmultret(e); + if (e.k == VCALL && nret == 1) { /* tail call? */ + SET_OPCODE(fs.getcodePtr(e), Lua.OP_TAILCALL); + _assert (Lua.GETARG_A(fs.getcode(e)) == fs.nactvar); + } + first = fs.nactvar; + nret = Lua.LUA_MULTRET; /* return all values */ + } else { + if (nret == 1) /* only one single value? */ + first = fs.exp2anyreg(e); + else { + fs.exp2nextreg(e); /* values must go to the `stack' */ + first = fs.nactvar; /* return all `active' values */ + _assert (nret == fs.freereg - first); + } + } + } + fs.ret(first, nret); + } + + + boolean statement() { + int line = this.linenumber; /* may be needed for error messages */ + switch (this.t.token) { + case TK_IF: { /* stat -> ifstat */ + this.ifstat(line); + return false; + } + case TK_WHILE: { /* stat -> whilestat */ + this.whilestat(line); + return false; + } + case TK_DO: { /* stat -> DO block END */ + this.next(); /* skip DO */ + this.block(); + this.check_match(TK_END, TK_DO, line); + return false; + } + case TK_FOR: { /* stat -> forstat */ + this.forstat(line); + return false; + } + case TK_REPEAT: { /* stat -> repeatstat */ + this.repeatstat(line); + return false; + } + case TK_FUNCTION: { + this.funcstat(line); /* stat -> funcstat */ + return false; + } + case TK_LOCAL: { /* stat -> localstat */ + this.next(); /* skip LOCAL */ + if (this.testnext(TK_FUNCTION)) /* local function? */ + this.localfunc(); + else + this.localstat(); + return false; + } + case TK_RETURN: { /* stat -> retstat */ + this.retstat(); + return true; /* must be last statement */ + } + case TK_BREAK: { /* stat -> breakstat */ + this.next(); /* skip BREAK */ + this.breakstat(); + return true; /* must be last statement */ + } + default: { + this.exprstat(); + return false; /* to avoid warnings */ + } + } + } + + void chunk() { + /* chunk -> { stat [`;'] } */ + boolean islast = false; + this.enterlevel(); + while (!islast && !block_follow(this.t.token)) { + islast = this.statement(); + this.testnext(';'); + _assert (this.fs.f.maxstacksize >= this.fs.freereg + && this.fs.freereg >= this.fs.nactvar); + this.fs.freereg = this.fs.nactvar; /* free registers */ + } + this.leavelevel(); + } + + /* }====================================================================== */ + +} diff --git a/src/addon/java/lua/addon/compile/LuaC.java b/src/addon/java/lua/addon/compile/LuaC.java new file mode 100644 index 00000000..a91fbdf4 --- /dev/null +++ b/src/addon/java/lua/addon/compile/LuaC.java @@ -0,0 +1,125 @@ +package lua.addon.compile; + +import lua.Lua; +import lua.io.LocVars; +import lua.io.Proto; +import lua.value.LString; +import lua.value.LValue; + +/** + * Additional constants and utilities required for the compiler, + * but not required for the interpreter. + * + */ +public class LuaC extends Lua { + protected static void _assert(boolean b) { + if (!b) throw new RuntimeException("assert failed"); + } + + static final int LUAI_MAXUPVALUES = 60; + static final int LUAI_MAXVARS = 200; + static final int LFIELDS_PER_FLUSH = 50; + static final int NO_REG = MAXARG_A; + + /* masks for new-style vararg */ + static final int VARARG_HASARG = 1; + static final int VARARG_ISVARARG = 2; + static final int VARARG_NEEDSARG = 4; + + + /* OpMode - basic instruction format */ + static final int + iABC = 0, + iABx = 1, + iAsBx = 2; + + /* OpArgMask */ + static final int + OpArgN = 0, /* argument is not used */ + OpArgU = 1, /* argument is used */ + OpArgR = 2, /* argument is a register or a jump offset */ + OpArgK = 3; /* argument is a constant or register/constant */ + + + static void SET_OPCODE(InstructionPtr i,int o) { + i.set( ( i.get() & (MASK_NOT_OP)) | ((o << POS_OP) & MASK_OP) ); + } + + static void SETARG_A(InstructionPtr i,int u) { + i.set( ( i.get() & (MASK_NOT_A)) | ((u << POS_A) & MASK_A) ); + } + + static void SETARG_B(InstructionPtr i,int u) { + i.set( ( i.get() & (MASK_NOT_B)) | ((u << POS_B) & MASK_B) ); + } + + static void SETARG_C(InstructionPtr i,int u) { + i.set( ( i.get() & (MASK_NOT_C)) | ((u << POS_C) & MASK_C) ); + } + + static void SETARG_Bx(InstructionPtr i,int u) { + i.set( ( i.get() & (MASK_NOT_Bx)) | ((u << POS_Bx) & MASK_Bx) ); + } + + static void SETARG_sBx(InstructionPtr i,int u) { + SETARG_Bx( i, u + MAXARG_sBx ); + } + + static int CREATE_ABC(int o, int a, int b, int c) { + return ((o << POS_OP) & MASK_OP) | + ((a << POS_A) & MASK_A) | + ((b << POS_B) & MASK_B) | + ((c << POS_C) & MASK_C) ; + } + + static int CREATE_ABx(int o, int a, int bc) { + return ((o << POS_OP) & MASK_OP) | + ((a << POS_A) & MASK_A) | + ((bc << POS_Bx) & MASK_Bx) ; + } + + // vector reallocation + + static LValue[] realloc(LValue[] v, int n) { + LValue[] a = new LValue[n]; + if ( v != null ) + System.arraycopy(v, 0, a, 0, Math.min(v.length,n)); + return a; + } + + static Proto[] realloc(Proto[] v, int n) { + Proto[] a = new Proto[n]; + if ( v != null ) + System.arraycopy(v, 0, a, 0, Math.min(v.length,n)); + return a; + } + + static LString[] realloc(LString[] v, int n) { + LString[] a = new LString[n]; + if ( v != null ) + System.arraycopy(v, 0, a, 0, Math.min(v.length,n)); + return a; + } + + static LocVars[] realloc(LocVars[] v, int n) { + LocVars[] a = new LocVars[n]; + if ( v != null ) + System.arraycopy(v, 0, a, 0, Math.min(v.length,n)); + return a; + } + + static int[] realloc(int[] v, int n) { + int[] a = new int[n]; + if ( v != null ) + System.arraycopy(v, 0, a, 0, Math.min(v.length,n)); + return a; + } + + static char[] realloc(char[] v, int n) { + char[] a = new char[n]; + if ( v != null ) + System.arraycopy(v, 0, a, 0, Math.min(v.length,n)); + return a; + } + +} diff --git a/src/test/compile/lua5.1-tests.zip b/src/test/compile/lua5.1-tests.zip new file mode 100644 index 0000000000000000000000000000000000000000..c937b1aef2827a4a917ccc996dc213dd47e92c98 GIT binary patch literal 166534 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
%{lx$6?_tR7 zhs5a>WB{8k^CL>jy|c!F#5QC`gK;^#2B_R5!@k2vl@m=-YZB_7c8$nFPrk^TmfkTI zqj4#>cA7a+?=46EaOefD$FoN=%rU}mSPRp=0)ECcgBf}-r_LglVP;#47BW%Y{U`NT zyayNVC7WHpvqa|bP^N6PD*E%Hf^n>dy*53}aqbyrGH;eP4bgc>V5}~H+`6>9_RzUx zNsq>8Ea;v3;zZEJsi*8xZj`Vt8_M&q&O9}xmtRG~yP~O5)6}`7Cr6xc#Ap?+%}xv% zAs3oGj)oZ!9A{srsvI-Ex)0~zye&Je3~A;*);|a95_9XTG^P-1pm&EGL@^L8u55q? zllVf8X`KvgaHnWD7nBS#IC6jYaux*Q4`O_F`Y%aSYR5BSvu6C zHr;>24OxTC6C6kP92bC@qG7%ek4|@ko;a7k-vdHEt&hx9s>3=8Gk@dNl7+c+d4Bsb(XZMn)zCaG0XA4(!RRp`() z^&Ry)!Ulv3ZAJA@s%#f4$9iAW_1jyGYnpbSvkk zTTtFvh2KQ_!|cxLTab}5b;GCTB(~=*WtlEi={90sM=)q`ZvL z)m9S}aQcNaP5@%!^!mE-PfY1-|J=p!tNlnAHQvMJ-{QeMI`=@x4esTSp3S>yqLquk8SAaoZ=X%{ zX3x%NM6^@D-+oN;O*Jj_6-+5+zywjIr;gZV*K{x`sqr5%K6P$g;dAVa%kot4D=ADL$)b=xKqR$U{aB zlcyGGE~e|pNePv`l0VdFzg*$W?^@>$$4w<*l;1LGmNwU88s(d^8uE$m@Sd;h(y(Kp zMoU0Py$%A8O@zJBY9WKZ@?1;6o&HeY$|3II^$&)VKf^1#jf78|MZ-GpJ{#_vmiNts z$1~?;#!btQ^BH$Gvd@|X+r_bd-@@UXUnR0qWhOZvvXy>RAB>BtoOEYyrt#&k%S(fA z%u3j`b;0ht%IL@NkCb)p0>7r9Fyh@X8PeC_i4%dBT>`%ly?|9g%gOVtD+4WU*f8s_ zF*638`K-;jtDy6j#SS-F z{652NXz{+8;|FG)yU&?TUozfWZevkD-VrtL>u^yh;uA9v-$hHtqItC&tJV^M0^5ww z9BlL{B1eQcIT~I+#8_*HIcI>G5AXRmtWKkHo0-gmM?s+;t;|seHfzrDk=HGLh;4&K z7X9f;^jW=t^`KuhtESG!tcl}(`cNdy2T2$P)(h}9UZUZw=I^^<`m~Eg1Aa~Jy8^Ax z{wKvv`CKlx&aD`$#RB=?1wd|SHM-{759_;}zSp;EIlxVk>yA4c>SkpzW2LZyB+n_S z$q#?6q|JTb-k*9V-DRiM?oIQ6wsUwKk@^j82bepPJSRfqo%I{(%?q>Q8#rzZ^#$O? zO>VYw*-zcih1atIbi~D)0+9opx>m0tAk*4xJMMCF19n1e$V}5TTF(^;R4=Rm_M0ex zSO&uHUGQcpCP5h(KD~%V#AsBkKu6$Cb2#s^%`fvHAY5vtaHPTP=Daw^Quv?`c2HJk zabYB2UW&cPT@ER~^Xi@Pm)M`3{0XFNF%Py{xo<4+FZIKZK9&w%11|ld37S$AV1ttY zmqsxULY%Qc1=8?6bi+Kr>ms$8w8yo{5W_#!#WFA$>pC>hoKP|s>%r?;Yx4ZdCM)fj zV{2*7cHpBTVP7?IA;`@p@uQ+OHbbUn&gr(QXq`e^sr9b~_tKgLckHp6DED6$n?`!! z>98mc^wp9B?47wn#8dh4k`*dJfq64%9J;k^BkhhmtA|>X}*}3Ge-_|22fLc(2R@vg2L1&7bk{q1RMr#uT3xw=DCaKn3aFO-( z(VyB-3q^EmC!fw@-d5$kzU$X8E4QzA-%z$a@tK0=Pqij+E=SoCaft=;v8ZzVz{^_$ zb1NHYt`!*^f~{KaSv>~7uj8trt2(si)>3Gwe!o+kkI($!>c?yde(`zZPKmHJ`}A}5 z6pz40K?jA0_&7s_mdV?AsaUqi`4z}TC;}dNeXh)o`mYK2H}$c?O_9!@+V)HISt(vy zW~==v0F8==9?2h{DnHg-joRg_XCnbQTp~Ym-*ROgw$V#hIe_%dTV%xAsePTLeBnQR zttox$3h(fXjasE{C7S)N?uP=R=D^FO9=UVYIz*6Myi6b@lyH>ipj{^EC$!NVNo%=(U-K>^sn!>a zMZC5yR4Y{J)N2>rywizRy-Sihp-dFq5dB4;+|n0a?Ri(y7p|)DAIh8miKQ~on3e>R za<7*RyCGeDo3I|IJ6T?g*&!mvH(yD{=Qrei$h`W#(Z20^KV|d#zPcMlwLTFxB|YNv z&l7&77WO%VGg4O&`w3ZfSe2OcNLRX#o8Ed}@NkJ(L7UU;7&TcQpX6G`hRcKJ-4hvP zS2`oL2IzbZF&IV8*U=2s;!%^OJ16-$ijn3(F``p!^zZ6a#5=o563>&zXAF=n!gF|_ z$R3<*h9MuE`3>FGBPe_v9NFCqZYW{gL~0YudiFJa+O>Z+UW%*^!gm%YHKHU#LM&HW z*n&)|FfxP|%xff!<#dLaHg)S*8e8TqlTSk{?E%Eg{XWPORT4yLc^Lq5K` zP6ZG%9-Ewa;&fYV;YIJg(j~rbwiaLai?mU>o; zzw-SF-vY@vWIuUnKX#&;7(aAeVz{AO|2O=ZNo7tC{ZFnD6wG+K+CE=zlW2et^;sk5 zxlOnfifb0q+ts8$d&R!6R%u4OMg71wwQP-TvgK0JxR|7+SJ#Pj0r3qKB@Q4iA8*zf zO};xPd0?p*9GaZ7c`y#o+weRi1i1d&HToyfdYEXIl9IuN=Q-W%^Srh&7|gg9KJRUn z)?=(s1=DA`57ZPu%Gb=w0Fk3>CXlnPJdxN+{x2+S7$Dypjv60G9c}H;8Ax>k>3L|S zn*5BF9YX_{(IGTAS8tpPYXSX;*dzsy56QpNSM-pLHPuWX3!Kw?HH(Q|Yb^_(C$IRu zn;0#&jV>KQjZY{OTVj3^&F*`4J-ae?y<-y@Rh~jq9Oxqd^(h^=)vK&Y=P|H=Pg`PvcaCFYBM!-d!kiL~khR?J!?m#=zpF*?k~ zxV=6q@(_0e%=+UjUx|7Zg+4M{-3!X@=CA(alOHTz{oYogo=%YweOC`` z^U}dg96(8qKgof*rwadXjXl+JS*2jp9c4SmxJ~AF64A9k%x)(l!m~eFZaOW+7QBw^+$R$R2 zI>97F5j;X~p&s=9UoHAOM_!#XZNZDj7pbb$x4mKFZVhri&7ZwovTD~PBJ+vj1TEM1 zzZv+NB+SHJsercTd|bHRZ#%SiW0B6>7?YAeT74B$5;Xm7cR1mC*{?gHZgdEr>v(Rw zL%-CX2Z7gJnZl-O!}s18wu||pw$+l2rD_l-EJn1Wiy>u2oF96{unb!)f<}b=$5X(X zBj4OnhtB~gTJ*CF*33nWGKI*T=o?&wVI!#yQX@=z0MTJna(7aqZJ!1DqK!xaNi8Wy zp!7GLif2K7E6KbIegPn_2Zwl4W2X)JgRa{@Uw3ig_Vde?K4-{E7g$cn>qN=KeYI-} z=~Buu<+TP!#m5unFe|{Ta%GzFAm1AG^S@HgGQ17aLQpTL*>I(fySZ!D7_`fin#WtiI^1M0xk|?SzGAruH57@J7BS7h!Xt*0qymvPlS9^wy?f!&_-C9dtxXef*Y4LdVQ`)U{PHvQ z{JLc&rSz^JQ*rg)NSnHu?te?7U+B#CQTL}aYxiZ;YYq`P59sV*7N^Re=gvEVmf~AE z1KbxQ-PQU#@%lRP`@He`yz%?q@cL2_cNFkJJQ1OGbBx#y)a}go9^<02ERcS3Dd&U5 zv?Yk@?#uzeCKj2$GL9*9MCELANze+@ zq4CmZ1j2;lx{xDz;-aXR<;N$NEKJ($5PG4D3hX^PQY9La{iy_z`s*l>XHgPwDpHc& zGMk|h>0ZA!CLU0Y!?@om`Ohu&p9z~-`@B3e(_-G1_iq^2tbzOfz#MSn#(PM`HO=`> zv+>(wiAmjU%~^eZrVL0;Mm6X?R}#Z~O&T>s6>}*VbG+F)+G*8%xlgc!WzR`W0K#q| z&-D*g!R5iG&|bnDB=9S?Yrs$^Vpkd5mNxiR6}b9zpgSEQFG^Ka{z6|So`yEKx`WEW3j;qT*W?rXBOFxq&lcu~mS_16^^I zfi^^odVd@(PDEe05Ybg36HZ``Dw7K2ASw>CVAh%j=6Nlsl{fwvHWJ=_#}DXRk9F$D znZVAoAwJhVbl1IP*S#&2OYj?Pg2d;TKyWx0+piM5XDx_7lebz-_MO(d_^8iWc+c9Q z_IMsTf%Ds$;7gaGy{ynZ_+DW`O;_FG2l#>o@)&1*E|>&yeX@jHh1a4v&welpwC{a= zzwtaKK$gB7VHEJWhywH20?L-|@(%k1$UjSzm|J@|;gaWxy?L zQ6};F+Wkelgm$~29Q+Wwm_y+8!2v%#Soe&;?S;CUq0~qKN^MP00JWLa?@dAO2{eHr zbS-2JVJEHjjXnM(H`L8(E0wRVLthr(0avXj1zTnhIK%H7fvT?n-C#n#4{<0Okb~mK z0Q+a}7kgX{q#`EpJbw3k$53IK(T46@s;6X;12IoBrEbuh&AX;HZj+qAc#yI9l z{={?Dhqx5oSR#3>IQpb*8wD9|Z_G36nX2gml&p_6SgW||R-TNwR!~iz{q&u&VkzPD zW2_NVbJ?Gi@4Uye(! z1TJm2i1}d2Xj)FD7EF|fw4pAQi0s8BUZR-`6zCW)>f=`m&|X5(m_Mdp-n&WMt1rZU zS~Z+sv6C>`7Dph`nn$fz%%{T0af;d?Fn6nN+{Fg<#C<7Jr=t;5i9SSLMqEaql%IqN z%BA@h!k4U*dkN_e_^}67l;X>>Yd!|;_v+J}_?AtaB))#Tvwpdz>dnDEsDyxJ+EM3^ zH>kU)e3**XeS#mfVt=b!{*MnKuIMJ{PvQ4+(4_p&6twh@!Z#NZ9`gUWF3VEckK_|g z*<3x@(o8$1C6n=c8>)CIDrFul9h82R1;o-!`d=-qo@q?K=5cqDVE$*23Ne~&DaO4% z(SJf}2Nq3HWlu~`JN^@rvQ_Jro;HyB{oVQLsf4IxY?~+r<3B_Amn2a!)Fo0Yp)3t5bHM`bk6FMpUmBl<+5#*L@4of;h#K--zzTA zd6&x^i2EV)^DCVeOp8f%C|DXw&)-W+b%;v8vhfqqNzHSA%pImPaI+5)WBe2(?V)-P z!{jqW!)a(*O~qPv8QjaHXOQ>j`}ES*_6eN$MTSLgYZ>xi`)|R*{J})uzle(}%Smo4 z@jnx9kvFvBq9snusf8_;?Xqn`3~?hzgTquEDZBK0021d0bu(V8YoO(ihVr~hB}R8p zdA(x(?#}x4MZ#QQY$9A>Xok9Fbo`CHoFOXS-c@;&SfG0=k~xU*hfpSVz5kKGqmJr8 zY6}$hmE!~lh^3u6%l;$F*otiOCd;tu=vPUmTr4BktPke0tUr}@!uT~HXqlu3>|7%J+O#tS~3b_=L0UjWwt|fl`)Bll70S*#5SP0JUTkV_I?v zuAq`B{fe%@CeP?N_RQRn{+~I?7FN+VVH;d>SuL>%Z{D%QX9Yjc=tRetP^#`lqD$88 zN>`fJxkeo7tUckRJ?ZpOLh$kV-^2-vtYWR@Zw$|=+W&q#@_&MS{x3^+2iyO`_mpUT zn;DFu`XeV?)ftbBI|LCq@KFfPmWl;VxY*JBmj_I{k5w5iEjDk)gT(x$=aKflk+Qw&@*||(h|>9CB@OJpQDSu2xz+8rK2kxY{=*T z_`d3uRXf2Yv${ra(-O!rl4LWCj~(oU+aO(AJ#7pvHW`6idvLJS`2z|Te#l5W_OUJ|jZ#mSPh{Rf4T87c@$_P&e! zBDul(Uxpe8ddaZSwVeMXn#CdaJ%<9^Tpv(1qRA#?l38br0sEF?VDCK5@?M6XNw5dd zTyMBDrMOjqh<-$sa1;l^Be8J~P1OBN1fx!c5v-?QA&k5$RNO>}OA;Zlo4#!B%w zd+u?L?~BZF_;)zDk`G}r0fS?2e|QozrA0LQlf(=D5fd33z&Tj%FU~b$dpO zdO49qj9u4Y&1Ic;7w%y$W&Jr0ax4hR408@nE0q#PM?s&4z1u}X@%J7lU*%>K=VIwL;=py7fXm0fe9K>KX> zA`j{K^r{otM#(@EPdKkdP169B`f55 zaX~^Rr2K*TG=G=%ZpDZStCwng2<(o?fUP(S=NbNJ9OYNcjb>0Cfo2o69Who<=QSd#*(;rC$NYrH!))sn<)xHQ<-6+rnD_> z0fDHnVvW`_#M0#&BfCtHtgEEZl8^JUpalnmw?%Ifhjf{vHm+C^N+;C_zK6JfGTPuxE+c z){kFYyT6`-ur3sM@}|JD0>MKZFlsgxf!=yS75Pc*LG`y{{r8*_f*C#{vUT3etg z(A`iF4bZ}tjFyx7QX-yB7|D{#69MA%eB9}Si%+t(N=;qk?d1l-C=j_#E{Xr{KZZS- z#W3~sZ}dc(yy5G)(ZUL@Ta+v?aOjk8?+hk{3l-AHH#mK+goa~siGVD)3P2b;5u=gR zTM}nX4+Y^DsN#ndCwUmQASNAyYJe5P7h~izx1s4UQz@J+4F_t>z+w?Esd`-cQ;FAD;5hC(cwE-w##bgL5L^9%cId zi%3cl--N`beDLBDLStKfUy>m_r~lS13wHmXMWx-2P~;@@&Q;Nuo@v;BZ><77%GCaE zM^*msA2lU&^@eI?u&zj`sn}9jg2}(uI1`YrwKw>;z6=@{%{Uv(mZ!eUOypMS1(QWvRufU4^i4!f6rmQ#nkz8Ldy9?nFvcPmQ|fv-d7;gOPr2%+<}LGy zFUv(G8&t02l&6$sgZ8UoPwX`t0nfU}6|+fa`ot2Dr#HJ$P>7Ke&ek0^J__l9q@b=8 zaoC`*hxPFEsKU;dKhHs-;-HzCre7lKx~eIuJt(r}@<;ZLcamkM6wBL?nI4Ps+rUvq|aO8W0$Y|IdNR~6D^E-b#Ljmpt%AJdMVMQn|Raf6GxH)>7S2xk_BaBa-A z{4+yj9r;B_$=1EhR{-yPQy1B2?SnEHgv^hJ9acAml(Aq5f&o>uqANlTH(}e%lll<=lfs~6r`;e)3UpiNU^CSPQ%!bbL$@_Ts4?}xi>1!Y zPLcghXPdVL6++bd{$e?xtlEp#9{K`(xI_b1WN6o?l61&s6Xnvx$L&y((`Nh!`I_tR z)lq>XzyAv#0$En3Yxg-R(I#an-;7U!`Pz=>Cqly!Nl(H}aXFH-E5uY$tW@vwpR(su z0ar&_JwmQB@*;9+MpY)3M{to~lfnSW9;PS``cT9yQ|qus8az~%c)M2-V@xEWMhz3I zmz4>CPF1b#M#l9qSLNv(?aDb%B?>g)9kRLrKBR9(J_YE;Vi9;v4b>StDWm4ZRfI9P ztEid9lx-(>i3%{}&ucI1_JY($Q&^xFsZz%co>^eZMjAW&0uR0SwSx6Ti%j*j&c&GH zU)%Q(F8|eCA5ZaS<5;{{m=uUE%T`yEl$>@`{_yhQ%~TGPUZ?jo59olUFa=~p_gDJk zW)l6w0qu-Y9UB3cpuvVkM?Zc)i`VKt&(O!RL5$ph%sGB?m|M$&7A2CWVFFGQ0-RB$Fz8pjz^&zO52!0*ty3Y}4 zkytXCwskXU+-DTYG^nq$cjs-{Y(OlIpvQ&+$BJ-Nfm>fh)P#P%adi_B-_uf)Fd=J; zm{`P^(zyN5PdW1a`<&dvk@2#?Gc(T;cWd;_G{LRG z*M;j#3a??Tni72=^%tVR9@<`9Kdf-j>EzAkgmD*)5w`h02McZf{GCuI!3@OmH0XpF zFkn#&0q2X#1{oy+@!c%ClMpn}|8<4&=c$L9k2=5Nj2h1zMj{k5vf#AAmP7)T5Ai^! zfQ=a=b^)k3QiE1n?i;oD3nrJPF08%#E(dlC-qZhxGlaA?W2t0Z3^Ta)5w2L|+6;T! z3c*43-<`OKSJUmx&JTD8`|C83=dSvaVBLqdblR!Z^aWf3V21a&%*zb7MXCi9p}&1Q zPno|4s8DU#M-JzEcjezM-`JmD|6R1N@-nZve9K6)QvUBn`~L}P!uUU>AOArBw*1T(_-op8P&md*Z zIFeB1TT0Z*%;s34+&bf9Y+ChLgyY=&+#oe1F|FSuJd|@@L7J2#U z{uPJa7hF;fJ8K!VH`*`*b#1(vKFY5RYR?a+q(~Zm{AYcFSs9d=dWTsRr{6nVH$<0X zg?xoSZImT|P~;P5Mb=C+?D5nzgF+-QNX|*nmU`5VZ1it_!m`z5U~B_{b5T2ic3n}t zh+k*_ZGkZ^}s?k+9GRjA4G9bLuV z4gEgrlP+f9JelE}m-4+`GCV758^nJAfMW}yq}p9zOQBy761#;Y^m<5F8Q#Kb(DdgK z)xMoG^Y#T7GPVoF%*G`dlFHMKk-a-JV7M{MalDr|b2P9Wd=%5=g^{f^*g8a@XGO5r zT2Vj<`fE*atC{Pv*=U2x#UTghNk;CVJ%3U^{MHSwgOT%QefrRC`byMuIogvg!CWu? z79!^*73!A21@R;L4AIUZQQuC`lap{H9P132GrM_PwOc)@$PP=00ijpE#N{Wr=zH+;N{n{P#0 z7lhUg3ka%_H5jCw=nVOYU!S4QU%9SEq&~w9HNjL;Lv05XR!iJbjE70=9KsRBJF$uu zafp5IWYf81n2iiCXC7lu@QhCQR=#K9C1l~%9XrQh z$+IQ7QyOx!%0 z*aTUuiXaa^Jkq2DUf7Oh0UyNSU%_wN6YzQ|=KBQaYdt2`!G1?5-M-GYH`wbrSX@co1 zbP_a!i3HM^eA{(MLlj_94gYW&WDcLtV_S^T39?zffusC@N?@$wtEVsKHLtIE6$DFA zG^pZg#<{~?G=a?(RtWWi^P6N%deG6Pc^cp6@Tp|A29Np`IWPbmJ!A=b#HUtpG|^|zOe$kmtt;9Ts1_}ExwyEvNo z<4pS$+xcqr=FJc+o$N7neNm(dkm{|fZGPvrM&kx!{D4xcD<1s$q4eNm+=3QMC{9c; z;_86Yf?>S96>dvTZI1b`x^Ngc!RJ<=Whx1mS#9?Ba0WJccdBHJ3&WCs1;MaY;Umwm@< zuRVd|_FB50dW-&%8u?h)?cA z5mQh-`=Z<+dwtB2n)XA34s%Gm@SskhG1Ho3+?iw&n!F|il5*DC$CK76x z{O){J-xcPQ1O;@o@cO!7U$cH+&5RjLOzT)hebq5kHEDL(LHf&sO|f;htfw9*9gWH2^Sg^J#uHWnHfJ#3;Pn1N zjJxwsp1^s37b}#2`5AMVEpy5ycSt+@r1oDL;Zzacp{^|m+$7JrNS1nB zyz`o=R8~OG8BU|@uUMwuQp4L73JsF{*+WmbgS-wE>yT@!pW*On zfz1W2vHu`;7KI?d|yBAQ8chj0JXp ziyMm7hd^47G-E{#_iGE0DbKL5S;m#NhVZ-U&Yiii0wy+{Lro&P>BczVn&dBYiy^|9 zhG6q_m4=&*iYKT{@Dw z1{OH%bVu8TSLW?uBRMhs%Hv7%M6A2;%6tLMPmQ^P`aoc=af*b>4BTnHzy=l}f0*xR zzB2X=Fz61qzfEVjO-I+Zm9M3)KI*1RdM1?a!UjOjg^fH7S=QmMF%+o-jqgOb(i4dp zbA%Xml-e?N)>i~B${F|jmdMAB?V6y~nO+6=D?F z1({z%ll&?2La_`b4q_(@3|dh{5a&5y@%n5&m6#MDhAq%EWmwqc0Y| zY~Q^sdSR^4z&CnS0nF~UK^6wDXAF;{!oV9#3I{m~3%P_@1Fj817BEym(V`et6V?p* zOMoNJ7j8Jx-H1Wk4>lCh+(1DANtytk_q%TWxM;GcNe24bveM)q3OTu+*9EJr z&J{22Wvr{AjYnA9&OPVf_m|mp>_izYUf5VTjp6Pi?K$3|_OmC(4Xh6GNZ7~_5QLk) zF|2*X$1&KW9bt~LP$S^oY9vI*axep1H_yd7>w)fYp3+xzWYq)0GB&W;*adyUUwlVb zhhRa0&U^)(FOoKD6a`;nhDD14n{ppS{hE8HNH2tFA>l#k=E|g~V*Qgo*K{l`wdQ_s zP=loJXB-(Z2^wDNX6*y&ZIo|J9!SLP`_r9qw>;wVOh6pCFkzi!7Ojp{=bUR zpC;d1#yYVq3l}MGt8SD-`kPs)1HY|iJTY*?G+;zqauyLyI)Zn%P_{w}FUf{kyx?~q1xA$q!9`ku$rqlvei)nmIvc)re=*NFzfZucU+?{k``y_GY{l-U{*a9y*&)=pB8n#CieIL;|t#+m2PM5>`bYbZX z7$sf!1F@2e55nDLT6hZ{9u?zkdBUq4jUF$j3aB&K!*$9IEH$v#x&(FY5 z5g>&F_CwFca^7#sIQbY=?pnjlO`Yg>g?H7;`An07%3+vcLZv zh^>zLYh>TBU*seDM(o|-!^c_-pMakw2dGkL4viD_z;uS7Z2ye%6hXq7;Fp+39AU^M z-wAewJo(9VCD6{qnVKUt6J~3L~HmPQV%W@&N;e_)MeRl-1?ShNsFO zQ_`GW_-@8l$rrxn3*KhAZv88b7*A6XDrn!gTVme`S03sIw8(9O@>Ww1=h#fsXMci6 zd0$_I3NT7ifM!5m8=_ulUqBx8Ip1>Nqa`++@UtP9{!fxoJ`e@Q-?jp@WWc`zhejh@ ztFRlkg`>X(YUL6PgF!3wPmjGt8`KtmSQC_P=9DbO_zRok8E2d7`jMwip}Y?pMAx?P(V#*+XngxUL~xlmaJputC?GxN#!Tg^&2p`( zd|PWvMN-Tt%Z$0-551sPh=`wbVI%rW_WOAP#l@#18T|6!64{0(rs_ z-^LQM+r}X;xEssFK#tj}&SDoj2*LTjO^}?%F;FU;y*;{>r?{dJAdwFZ(ZNq4Xx}OY zE{&8fD=#Teb(V^SxE@&Je4eOFuu^hJTnSz=M^JPhv9|hCPLCLigl{dMrA|4BT$ewt zn`Ou9&@R{D*_l(<7ODS%1hYvRu+PY1`W=Xw|3|o=53J9RpCiyNudn$=9(`qI>iFmx z^H*3ke^x_jNg+%93ffCKyvnzKdANL@Fi;#4v8zc&$?Z|}U#WRxo^ZEVL7oZCyE)fN z+57~%P-L(wI7?bHq1ZaW5{(Us(r_tA)_tjT_J32Zq!e8zUK@E-JpINX^JA-|Gp~Qr7 zM4O1`|44g%LW`}xpK+}ZPZCPI%vzGK^vB|d!=AQmeU7bO^54?7YGA-5Dyk$`nu2f^nwxpD4ZWTB; z{3UWbv8gnB$FaW}jbd2#84`29HU17y`pPQEa_11DoI{b!xm6HS`pPB*XZz5UoI|vX z3rAlK;CC71#$T`)tol~Sb9dNY83Kn$Ksro^=on>(Zs8~;Qio`rOo;BDTl%qcWQ5Fp z=MZT+*EyPm&K^>F+XCgKQ)Cg~h9}*lTc)d@5=v(;7QlRrRw^T^OLmAR0$@HzBL^^_ zqK)e8$pIWU0y}m0LS(vzDYw?ZF43Qtpgh85WZ`DBa^0IFLf~baBP_8cTOyJH4ik{_ zoqe*=9`$0tgT7x_Ov_+D84P+LyE-9@tx23y$2$6iqq)xdjG{dhqPe!ow${l2FkN-9 zTVHrPhS>F4B+F!J-^^h2a@!KI>XwLRtQ*Pb=kNC!(z`gij{|yn>=xgb8sWQJbV6N} zz&uEAE9{~;qrHDGD1Qs=qT5_xJp9=054@dZFn{Xn3OSEIj$ixwEXT1_-Q^#5c+b&1 z&y!d;>aMfrx`*2~V9g&j;IUi4&yT7h0j}$K_8p((wsye!=LzlgHzv4Kw4X8x@cR-C zA8^x-_v`}>oP$u{0O_7BZtc*o3}kE#sB4L+)1}Pqkp?=aKEGCpc0aYDZCjwK>+E?B z!PlW}R|ng3U+cSG8zGK8e)Yillp%eVA@!`2eUqBChmaxtRGeVd3VGG;}VWki+VhTx8$S9wJrU}5V?Qae)Uw} zdiOMw^Isyc$+MVvZu^htF@v|HRxOcLy_$maU2@akCee%;U;k~eWOlEYL-B3zN~Qe2 zciI1cp)o(jghb`UQdQ)vH<(bm@!yG|^f^FBNyGKg&gfO>5|X>~3f2*299#r&$4>0rdBFEHy(7 zgl*b^waz1LIW1Wc)LL-*cL+NOV0Ok5sfI&XlJ1$WI9Nh5akQ~|4zM>2WJ5Fox|oh7 zHQvJ@^CBBq{_jan`;klsz=ozn)8FdsEw1wGwHI^(Rjc>77c8=xpWJbFAmyEM0l zA9VE9j+SBb(T_Z1C5M>)NdDWN_FkTx6n;&2jePkW{ou)zSn8@oR4dwptu=7yL2H`)g zV!vP-=d=rC77Sn#_u;W0=A}pk*x5YYj87vwLQd(se8uPT8^e}bRM*Pa>NC8Wq&@;G z_+z@xse`c2EWv}Ve@i=Qw$)NO1(R(uxv_R8Qp-mdAX(tYSi{zN9h7c5NfaJm^3IW- zr(i|`bl{*l5aTE(F@T&jrI8i1V~%q8mg^3RQx}O~PJh`b?;5T=Xy!|RXo`4=lN$YUKj4ydChw)K zQvEAAXSnjkdm1z-U%#OKi-)i5D}s*%4gw+t_5XF8{x82WXL~1?|CYR0wY6SnLizlr zAaEg&awN;m*XXCc4jR~08`D)2ccNiP$cx&Jr>3w`9gIHaoy+TOZKMln3i~8px-ic0 z@hpqeV)Gd0s5sZJwJ{yfwQ5vuNY#+&N4z7EP3K1h6A6Oiel`Vmi#3_aA&9q?DAo5^ z2$rv|WEG}P5agwi<-nJb5jC==#Tb-IA@8nU>x3c8==uVgdpG4jv_%s7{ku{XqUZRMo)UW|D{R|;NIVap&1CEzC!Pg0^ z5zQP7Fz@19g&li#iFmbU9Z`F}b0yQBu-1##S%+;MqV$eNl)|1bS^IR@|q>c588hy!Ja~8Q}KHwlDD=3?LU$!i! z{_^3(yTaMfsjhHjTzZnLNoah-V|Ux^(x3^3KEawzPdKYQ6xXUb&yAcZ=o9=l@SeJt ziYgo0v;j?m5LNAjYGdxYQEvy|LFx`lS8F1;5Pam(@lRH4@IfpyhT39G9I-DN5D0!d zU5V=YtAiJPe#1^AJ_!c|SrtSCX$PyKzhmA{e#7NY%RKDAG7Qus@R2prx^-LLwrx$o zYC>ze+1;?7BZQ_TvIyy75zGxwruxBl6Ni|KnmMCI(&=%V^~vXI%k*8|E4nxVmQ87# zIFHOGj`mdCGya5cl0VKit;teRj*FOO%RL#~xrBan22`YbxV+uF#f62u#%bZR{fVCFcN0U7>( zrTG7OFZ(S~4e|}1WCt)axR^S-I5Yky#lH=Hr<^gwF#P#=-x6(vF_=>X`}2!QV1)RE zX&_nfSBFFsej<~NL?us|H2yQAI+q2@o)=jXAC7NSD_IQ2?$%0^a4&+zwol8wHW()s zOeMJ4?>@=hTpg!}RdrdiFMV@;I@9m1Tix{Z+wwrnsI0_YK?3pe+`=K?@>*dhT;|?e z!E^_qoVAgD;`5uogB)dw}#+Q&#GYvQA1^PTskpIN!^@=yUdV-KkEy zKjMvqzBEh-0><(ASoe7}#C15);5`0Kaf}y{m^Svl_s33d#;C<1)lC?^3xCKfh;17F_LoZSfL3E#zvDUuIBycafG@EUd4 zhIw=zYm0KP+JDpS(k8l68}4NA9E>#G5IAKv1-rufm$;9MGsnu{b9r2xC2@&2Q;|8@ z$8wFO=k8Ijf7}HdWDPHIkL*ZbS~LOi-WsP4pQnXD+-X--7atxh+x&Ux6=fkJq8_Tv%>GWEN9SX<^Mdf{7IW`CIg^&pLh90)|K1uG}2+n z3mXO|V)8#1y>rPC3iyx?k>W8sTyjXtJI3-c!msVVHQdmEn z=EMEdY!w?t9r4oJ*D3}-j0W-}84l`j7v?v9B^9lv(a3rkp{URq@o@cj`4?g+Rqdy)VwS6IYahOigqknk;$l9 z6EU2f>}<4t7jJjuprIJzRyLtSCg}*#XS>h22P83FNG9}Av_MkF+M;ysVI*R$Wh{3Q zJYfrj#&SOeDD}?cAsknVUj!He{ey;3LvyFq+gm1fd1R-Y`wdF9o@O5=JEXR15pH~t zNdV<7b`}sn>QNXG9UR6@W@|oN-fSdcTu!sA&mI+l%CCyfkqUcZLbqHX#SHN};_ z<_OD^tR_06C~U3e+JKdVkZG&9C&UxXp0(tOR}ei_F)H|MiwSAnHA0Ph;|<$-!%0X* zO@Bsk^y|wmox}vZ7a`Twm{uouUz)v!b?dV8HqK3ay_a~AhyeTCX_dZBtcb-DLoSc} zhNlr!FNF&q+&72MOY3|NykbldwG8eUVYnJ5(9o{q83$gF(DWWneu`Y z+bWJy=MO^6fTW=5aXYmCr?9Vps0FT+cOk%-l22+%uZY6Bt7BaN#oMvw&&xv`?Qoo{)RJ z@FzmwafjPM&~<`#BmF@P=_cYVuBQ#{!TjvPhdq#18J5hs3fcFn580McCRTSI{+Ct2Hzkvon`}85}iLruL%Wu+dP7^|NsI z4^U+wbERfpSRq3)l^Y^E=-9->1TsjMl|Vtdu+RB#J}FAyF$jbz;&+otLzO99qVo$t zC{EspiH)$(el%0LTqKCOK~vsY2$!h<9|_WpShcFWV{0eAaf_Wk4;&KKf0}hi@FRWn z^aRSq-}4!^#C6!7Dl{@Y2Xtq@-`DN{phg$ThU&kWTZ>d&5?8_tz&o~ zeN%GB14R%0F(xM=jnk(p)_u7xRI2-O{Azqu z`Rl98aWS|8dfEQ;ZyHfYZV>`hRU>37=Pj^|1l%Ke&tn$*h1fV;m1U-i;_|hNd!2)x zQ*cPZmMSr-Am{HxbW93ZaM)mqS~yHMhM7kWcs|=j)}y&YTYS~o1@8I!WiwxNLwv5- z_YP{@DnPa+lbx}S&P9MEfC{hi@Yt9I4dhvY1@^lVy-%3aAnsQE%&1j&{dU?m#Z&w%P`kk$3(52I*p}e?r{VP=It?H; zkHMH4%TGVo?hF=e?RQwkwqHRnV5m1K%PrW-ihB$fbC`f4iJ9Ek6;b;7JKTG!OEb(f z)0%Et%Z7OIpq>fEjgjcLNs-1a{mfLrm~Rz%d%SBml9tK_5lrt)F{z8k7fU56+yf;9 z2b55Z3x=SlrkXW9+gJ5_Dz{A)bu9~W{+z%AVLzPhgU z1~>_xv`gF~q$Oi8-G}@Pfj+>4xvuN>1$E0b!r=_+t+(8` zbUohF?mubIqD)ZmeSPAI@kx6b8_;=5L&+A}2`r3B9@ z3gA!-XUiG+X$R-CC@yZI4_~-u@ZurU1+0TqB(NyyxSPxSs$t%XR;%X(=?dg6oISz7 z%{{5$d*XV2OUC|lwzKxVR^P#i0UN1Jl7=u5sqLcFVGFI~0!3-R=nLd{&D8z9i89go@Hettk^@ zE3tf%J(~1>g+?h#^x7QLU?XZPlRT4$lTQ&D-?+8B^i)sMk1gzZfZ!}PLL|)iDF zJ4&cyl2CTbTeuIxN~Zx&weVL_C*%vnTe0GT*{+Ur)%aN5J^ ze08mVo1?_)?($ez{YxkN>l?o8=aE?lSlj3#UC6~kEpQc*jW|*VRT2%L*gXH6e-`Il zo-TzKgU38M@UZsp?dOlDTECs@cW=zouY6}_O)!SV4?eF?%8_`W%_cB~+BT-0oW*f2 zgTBzbmDZ$Op&p!BzN^$OzVjJ7r`SqZsB%RH-S$46(tf4UHYP;42#I9cA>ouZVUK| zpLkvzgVb?62|8y#x|o=$L7A)&2{ys+4s2Vg81*KzaKxp_@^+iOMac|T{t=18N?ki( z93U3cyi=QM$Wo!%Elb4P>? z#U@}k*Fxy;Gxm13&wsxDXmANc*dQC&gaq!F#|Ed@>MGSTXhjE`9Xh6v4yL~HJB%#W z6$1$whsN4AoW$(DJKiA7b<~!`cx-4Ic|AGOiJg&HPd+I)o+wd1T*oTIN$T^lIkfbc zZx~Mjy4B#+@4r0J!ATpUaXx^>aVszkTRVaqcxh4CSu6Ui7}_Kx%$0I$(+Vd0@amf< zr|}lF%Eu^H|0tw65_V(nX{j$nzK+9!Kij-WR`@dzvtt>Y@gl5FIhPAP+@s8f8LXGf z?Sv)fbY}z#LIs4WC}K8Q@pvTC*=qQ0PACSI*7lJLDSqO}x~q5Vq;&gCrc_`{Bz7n! z48AOvxapb0S?+G?AEeAVCUVI+P%B*gKuH*Js?%mNf#a|BB&2kGeESx%vkcn}s<#hi z67_b*ApKc-@#-K;rb?albM~D5Z#wj z@pIYBTfGPr)-E0U!iTGkTJqL2j%U|mBCv5~|G?Q|pL^5+Dx9z6B_D~YhIIRtIGUL| z8E?))Wtn1=%(Z@)Wy~p@hPtNI(aR>xeTiIb&TRL~1<$zG-`v#jD4rYzCazp{vqd%J z{QT)--s7Fqm$$goei4_$y?mgQjzft*X14t_&Y>)tOm^AC4Figs}7v#Qu)rE&*&Y{^uqY<5Af7LT#K>+ z$CHGON7K;r3CWo1O*FgHeaY)TCVWqShM0{4?LfSxs4#wc+l|)^HQwB*PkvN1yjS>G zm--~bXh<8!J=f`lphQgloZ%T1r~$os9k~;oox!OpkT7bZzG(u zl*~qp9z0UE&pB5hE+e3!%kYO?hZ^GVo!bhux2%c-I0a~1EzhsSxU_kR=OAw;hRv{j^uKd zp^RFjHngx1TKsh~oEvmw?y0V_f4d32PN+Y%S>{}bCyMw^ilin6N=_vyFHz=pjybg$10-bTm8qDKzkxmXZlvUaB`0F_RJ zq!tIn7GDKzz6w(6$zS5Z$C{@)s+@CG0NqME zH6NUaaF#+{`0Sd{SJ(jCp3o!6;}*sQzjF5H6XxkAnb-L^vea64QZ`lF4g>)@g8w1RtWdC_kRuL1kp^T{iD)EDtH9M1=jWGHUpeA-W<;mNNRwp~0Qt zUGA!LI4Kh9N!QhC0EP6|@0?s|h7_&(M1Bh+@@0eK%+aDOl?C6UN|9!%l^HWSms?d{ zOjb93Z+&LUW3n4c64Dr1&gO(5+hT6St|XP0h*l6iQ(a;;&yTb~RdQo?8O>qDzlwrD z;V`=8pX{>umI~Mb5@d_*jqR+|bI49%?4X@;cE8K;O9wqly;VO>>b6!Wi>_Gf-$Aqc-XEpn|g;5r4EM@V7#hr;hAaeo7{Qbs&EMP>yD#* zg?c?2%Wq_F-(Xf}eQ5EdxLPR)9-bT-XOuyl5U0Z?%~ zIv=2v**}j^DPIZ3%NHI70p0bATBkG`o@nUbR0-mvk1Dhl=7a&4XvZYR69B zI1K`N=oQGDC&Mc7|5(RV0f~A+Rk^jJgimau*K3w`!MJH!XGyrXkTr3lx|7*r+i-bK~4jX7V@@)|>+ye09Sb0^H; z)I#k$=Q%3RElh#qAROMM^@;;TR8SV`wJCPtyxaw2|HV=+`xs*6v*sinzlI2sL6z+z z_S_r2BH7W7oq!EqQJYbUk~g29&+O6LY4WzOWYjXyUC`mgsn$5-N{nR4c&*Rb}82buICFuHtⅇ{gP`~-aKBn!=XT`< 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 0 ) + baos.write( buffer, 0, n ); + is.close(); + return baos.toByteArray(); + } + + protected Proto loadFromBytes(byte[] bytes, String script) throws IOException { + StackState state = new StackState(); + InputStream is = new ByteArrayInputStream( bytes ); + return LoadState.undump(state, is, script); + } + + protected String protoToString(Proto p) { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + PrintStream ps = new PrintStream( baos ); + Print.ps = ps; + new Print().printFunction(p, true); + return baos.toString(); + } + + +} diff --git a/src/test/java/lua/addon/compile/CompilerUnitTests.java b/src/test/java/lua/addon/compile/CompilerUnitTests.java new file mode 100644 index 00000000..cdd31e52 --- /dev/null +++ b/src/test/java/lua/addon/compile/CompilerUnitTests.java @@ -0,0 +1,35 @@ +package lua.addon.compile; + + +public class CompilerUnitTests extends AbstractUnitTests { + + public CompilerUnitTests() { + super( "src/test/compile/lua5.1-tests.zip", + "lua5.1-tests" ); + } + + public void testAll() { doTest("all.lua"); } + public void testApi() { doTest("api.lua"); } + public void testAttrib() { doTest("attrib.lua"); } + public void testBig() { doTest("big.lua"); } + public void testCalls() { doTest("calls.lua"); } + public void testChecktable() { doTest("checktable.lua"); } + public void testClosure() { doTest("closure.lua"); } + public void testCode() { doTest("code.lua"); } + public void testConstruct() { doTest("constructs.lua"); } + public void testDb() { doTest("db.lua"); } + public void testErrors() { doTest("errors.lua"); } + public void testEvents() { doTest("events.lua"); } + public void testFiles() { doTest("files.lua"); } + public void testGc() { doTest("gc.lua"); } + public void testLiterals() { doTest("literals.lua"); } + public void testLocals() { doTest("locals.lua"); } + public void testMain() { doTest("main.lua"); } + public void testMath() { doTest("math.lua"); } + public void testNextvar() { doTest("nextvar.lua"); } + public void testPm() { doTest("pm.lua"); } + public void testSort() { doTest("sort.lua"); } + public void testStrings() { doTest("strings.lua"); } + public void testVararg() { doTest("vararg.lua"); } + public void testVerybig() { doTest("verybig.lua"); } +} diff --git a/src/test/java/lua/addon/compile/RegressionTests.java b/src/test/java/lua/addon/compile/RegressionTests.java new file mode 100644 index 00000000..2cdb2674 --- /dev/null +++ b/src/test/java/lua/addon/compile/RegressionTests.java @@ -0,0 +1,31 @@ +package lua.addon.compile; + +/** + * Framework to add regression tests as problem areas are found. + * + * To add a new regression test: + * 1) run "unpack.sh" in the project root + * 2) add a new "lua" file in the "regressions" subdirectory + * 3) run "repack.sh" in the project root + * 4) add a line to the source file naming the new test + * + * After adding a test, check in the zip file + * rather than the individual regression test files. + * + * @author jrosebor + */ +public class RegressionTests extends AbstractUnitTests { + + public RegressionTests() { + super( "src/test/compile/regressions.zip", + "regressions" ); + } + + public void testModulo() { doTest("modulo.lua"); } + public void testConstruct() { doTest("construct.lua"); } + public void testBigAttrs() { doTest("bigattr.lua"); } + public void testControlChars() { doTest("controlchars.lua"); } + public void testComparators() { doTest("comparators.lua"); } + public void testMathRandomseed() { doTest("mathrandomseed.lua"); } + +} diff --git a/src/test/java/lua/addon/compile/SimpleTests.java b/src/test/java/lua/addon/compile/SimpleTests.java new file mode 100644 index 00000000..bb7195ba --- /dev/null +++ b/src/test/java/lua/addon/compile/SimpleTests.java @@ -0,0 +1,76 @@ +package lua.addon.compile; + +import java.io.Reader; +import java.io.StringReader; + +import junit.framework.TestCase; +import lua.Print; +import lua.StackState; +import lua.addon.compile.Compiler; +import lua.io.Closure; +import lua.io.Proto; +import lua.value.LValue; + +public class SimpleTests extends TestCase { + + private void doTest( String script ) { + Reader r = new StringReader( script ); + Proto p = Compiler.compile( r, "script" ); + assertNotNull( p ); + Print.printCode( p ); + + // try running the code! + StackState state = new StackState(); + Closure c = new Closure( state, p ); + state.doCall( c, new LValue[0] ); + + } + + public void testTrivial() { + String s = "print( 2 )\n"; + doTest( s ); + } + + public void testAlmostTrivial() { + String s = "print( 2 )\n" + + "print( 3 )\n"; + doTest( s ); + } + + public void testSimple() { + String s = "print( 'hello, world' )\n"+ + "for i = 2,4 do\n" + + " print( 'i', i )\n" + + "end\n"; + doTest( s ); + } + + public void testBreak() { + String s = "a=1\n"+ + "while true do\n"+ + " if a>10 then\n"+ + " break\n"+ + " end\n"+ + " a=a+1\n"+ + " print( a )\n"+ + "end\n"; + doTest( s ); + } + + public void testShebang() { + String s = "#!../lua\n"+ + "print( 2 )\n"; + doTest( s ); + } + + public void testInlineTable() { + String s = "A = {g=10}\n"+ + "print( A )\n"; + doTest( s ); + } + + public void testEqualsAnd() { + String s = "print( 1 == b and b )\n"; + doTest( s ); + } +}