diff --git a/src/core/org/luaj/vm2/Buffer.java b/src/core/org/luaj/vm2/Buffer.java index 7b330f66..c3423d38 100644 --- a/src/core/org/luaj/vm2/Buffer.java +++ b/src/core/org/luaj/vm2/Buffer.java @@ -74,7 +74,7 @@ public final class Buffer { this.length = length; } - public final LuaString tostrvalue() { + public final LuaString tostring() { return new LuaString( realloc( bytes, length ) ); } diff --git a/src/core/org/luaj/vm2/LoadState.java b/src/core/org/luaj/vm2/LoadState.java index 2f602f30..cd765155 100644 --- a/src/core/org/luaj/vm2/LoadState.java +++ b/src/core/org/luaj/vm2/LoadState.java @@ -24,7 +24,6 @@ package org.luaj.vm2; import java.io.DataInputStream; import java.io.IOException; import java.io.InputStream; -import java.util.Hashtable; /* ** Loader to load compiled function prototypes diff --git a/src/core/org/luaj/vm2/LuaClosure.java b/src/core/org/luaj/vm2/LuaClosure.java index 347b44ce..7e8d2692 100644 --- a/src/core/org/luaj/vm2/LuaClosure.java +++ b/src/core/org/luaj/vm2/LuaClosure.java @@ -236,7 +236,7 @@ public class LuaClosure extends LuaFunction { Buffer sb = new Buffer(); for ( ; b<=c; ) sb.append( stack[b++].checkstring() ); - stack[a] = sb.tostrvalue(); + stack[a] = sb.tostring(); } continue; diff --git a/src/core/org/luaj/vm2/LuaTable.java b/src/core/org/luaj/vm2/LuaTable.java index 31282bfc..b8fd9a29 100644 --- a/src/core/org/luaj/vm2/LuaTable.java +++ b/src/core/org/luaj/vm2/LuaTable.java @@ -56,13 +56,17 @@ public class LuaTable extends LuaValue { rawset(named[i], named[i+1]); } - public LuaTable(Varargs varargs) { - int n = varargs.narg(); + this(varargs,1); + } + + public LuaTable(Varargs varargs, int firstarg) { + int nskip = firstarg-1; + int n = Math.max(varargs.narg()-nskip,0); presize( n, 1 ); set(N, valueOf(n)); for ( int i=1; i<=n; i++ ) - set(i, varargs.arg(i)); + set(i, varargs.arg(i+nskip)); } private void presize(int narray, int nhash) { @@ -232,7 +236,7 @@ public class LuaTable extends LuaValue { sb.append( get(i).checkstring() ); } } - return sb.tostrvalue(); + return sb.tostring(); } public LuaValue getn() { diff --git a/src/core/org/luaj/vm2/LuaValue.java b/src/core/org/luaj/vm2/LuaValue.java index d3fcce9b..bb878774 100644 --- a/src/core/org/luaj/vm2/LuaValue.java +++ b/src/core/org/luaj/vm2/LuaValue.java @@ -286,7 +286,7 @@ public class LuaValue extends Varargs { public LuaValue or( LuaValue rhs ) { return this.toboolean()? this: rhs; } // for loop helpers - /** test numeric for loop */ + /** @deprecated - used during development only */ public boolean testfor_b(LuaValue limit, boolean stepgtzero) { return stepgtzero? lteq_b(limit): gteq_b(limit); } /** used in for loop only */ public boolean testfor_b(LuaValue limit, LuaValue step) { return step.gt_b(0)? lteq_b(limit): gteq_b(limit); } @@ -312,7 +312,7 @@ public class LuaValue extends Varargs { // table initializers public static LuaTable tableOf() { return new LuaTable(); } - public static LuaTable tableOf(Varargs varargs, int firstarg) { return new LuaTable(varargs.subargs(firstarg)); } + public static LuaTable tableOf(Varargs varargs, int firstarg) { return new LuaTable(varargs,firstarg); } public static LuaTable tableOf(int narray, int nhash) { return new LuaTable(narray, nhash); } public static LuaTable listOf(LuaValue[] unnamedValues) { return new LuaTable(null,unnamedValues,null); } public static LuaTable listOf(LuaValue[] unnamedValues,Varargs lastarg) { return new LuaTable(null,unnamedValues,lastarg); } @@ -421,8 +421,12 @@ public class LuaValue extends Varargs { public static Varargs varargsOf(LuaValue v1,LuaValue v2,Varargs v3) { switch ( v3.narg() ) { case 0: return new PairVarargs(v1,v2); - default: return new ArrayVarargs(new LuaValue[] {v1,v2},v3); } + default: return new ArrayVarargs(new LuaValue[] {v1,v2},v3); } + } + public static Varargs tailcallOf(LuaValue func, Varargs args) { + return new TailcallVarargs(func, args); + } // empty varargs private static final class None extends LuaNil { diff --git a/src/core/org/luaj/vm2/TailcallVarargs.java b/src/core/org/luaj/vm2/TailcallVarargs.java index d313916a..c6068198 100644 --- a/src/core/org/luaj/vm2/TailcallVarargs.java +++ b/src/core/org/luaj/vm2/TailcallVarargs.java @@ -48,21 +48,18 @@ public class TailcallVarargs extends Varargs { } while (nextcall != null); } - @Override public LuaValue arg( int i ) { if ( result == null ) eval(); return result.arg(i); } - @Override public LuaValue arg1() { if (result == null) eval(); return result.arg1(); } - @Override public int narg() { if (result == null) eval(); diff --git a/src/core/org/luaj/vm2/Varargs.java b/src/core/org/luaj/vm2/Varargs.java index 443b38be..f9befb22 100644 --- a/src/core/org/luaj/vm2/Varargs.java +++ b/src/core/org/luaj/vm2/Varargs.java @@ -143,5 +143,4 @@ public abstract class Varargs { return end+1-start; } } - } diff --git a/src/core/org/luaj/vm2/lib/StringLib.java b/src/core/org/luaj/vm2/lib/StringLib.java index 46cd894f..b34b39d9 100644 --- a/src/core/org/luaj/vm2/lib/StringLib.java +++ b/src/core/org/luaj/vm2/lib/StringLib.java @@ -259,7 +259,7 @@ public class StringLib extends OneArgFunction { } } - return result.tostrvalue(); + return result.tostring(); } private static void addquoted(Buffer buf, LuaString s) { @@ -575,7 +575,7 @@ public class StringLib extends OneArgFunction { break; } lbuf.append( src.substring( soffset, srclen ) ); - return varargsOf(lbuf.tostrvalue(), valueOf(n)); + return varargsOf(lbuf.tostring(), valueOf(n)); } /** diff --git a/src/jse/lua.java b/src/jse/lua.java index bee9bfa9..4b3646f3 100644 --- a/src/jse/lua.java +++ b/src/jse/lua.java @@ -35,7 +35,7 @@ import org.luaj.vm2.LuaValue; import org.luaj.vm2.Varargs; import org.luaj.vm2.compiler.LuaC; import org.luaj.vm2.lib.JsePlatform; -import org.luaj.vm2.luajc.JavaBytecodeCompiler; +import org.luaj.vm2.luajc.LuaJC; /** @@ -89,7 +89,7 @@ public class lua { // input script - defer to last stage break; case 'j': - JavaBytecodeCompiler.install(); + LuaJC.install(); break; case 'l': if ( ++i >= args.length ) diff --git a/src/jse/luajc.java b/src/jse/luajc.java index 2077dcb4..2fd3380c 100644 --- a/src/jse/luajc.java +++ b/src/jse/luajc.java @@ -30,7 +30,7 @@ import java.util.Hashtable; import org.luaj.vm2.Lua; import org.luaj.vm2.compiler.DumpState; -import org.luaj.vm2.luajc.JavaBytecodeCompiler; +import org.luaj.vm2.luajc.LuaJC; @@ -155,7 +155,7 @@ public class luajc { private void processScript( InputStream script, String chunkname, OutputStream out ) throws IOException { try { // create the chunk - Hashtable t = JavaBytecodeCompiler.loadClasses(script, chunkname); + Hashtable t = LuaJC.getInstance().compileAll(script, chunkname, chunkname); // write out the chunk if (!parseonly) { diff --git a/src/jse/org/luaj/vm2/luajc/JavaBuilder.java b/src/jse/org/luaj/vm2/luajc/JavaBuilder.java new file mode 100644 index 00000000..600edcf8 --- /dev/null +++ b/src/jse/org/luaj/vm2/luajc/JavaBuilder.java @@ -0,0 +1,701 @@ +/******************************************************************************* +* Copyright (c) 2010 Luaj.org. All rights reserved. +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to deal +* in the Software without restriction, including without limitation the rights +* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +* copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +* THE SOFTWARE. +******************************************************************************/ +package org.luaj.vm2.luajc; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; + +import org.apache.bcel.Constants; +import org.apache.bcel.generic.AASTORE; +import org.apache.bcel.generic.ALOAD; +import org.apache.bcel.generic.ANEWARRAY; +import org.apache.bcel.generic.ASTORE; +import org.apache.bcel.generic.ArrayType; +import org.apache.bcel.generic.BranchInstruction; +import org.apache.bcel.generic.ClassGen; +import org.apache.bcel.generic.CompoundInstruction; +import org.apache.bcel.generic.ConstantPoolGen; +import org.apache.bcel.generic.FieldGen; +import org.apache.bcel.generic.GOTO; +import org.apache.bcel.generic.IFEQ; +import org.apache.bcel.generic.IFNE; +import org.apache.bcel.generic.Instruction; +import org.apache.bcel.generic.InstructionConstants; +import org.apache.bcel.generic.InstructionFactory; +import org.apache.bcel.generic.InstructionHandle; +import org.apache.bcel.generic.InstructionList; +import org.apache.bcel.generic.LocalVariableGen; +import org.apache.bcel.generic.MethodGen; +import org.apache.bcel.generic.ObjectType; +import org.apache.bcel.generic.PUSH; +import org.apache.bcel.generic.Type; +import org.luaj.vm2.Buffer; +import org.luaj.vm2.Lua; +import org.luaj.vm2.LuaBoolean; +import org.luaj.vm2.LuaDouble; +import org.luaj.vm2.LuaInteger; +import org.luaj.vm2.LuaNumber; +import org.luaj.vm2.LuaString; +import org.luaj.vm2.LuaTable; +import org.luaj.vm2.LuaValue; +import org.luaj.vm2.Prototype; +import org.luaj.vm2.Varargs; +import org.luaj.vm2.lib.OneArgFunction; +import org.luaj.vm2.lib.ThreeArgFunction; +import org.luaj.vm2.lib.TwoArgFunction; +import org.luaj.vm2.lib.VarArgFunction; +import org.luaj.vm2.lib.ZeroArgFunction; + +public class JavaBuilder { + + private static final String STR_VARARGS = Varargs.class.getName(); + private static final String STR_LUAVALUE = LuaValue.class.getName(); + private static final String STR_LUASTRING = LuaString.class.getName(); + private static final String STR_LUAINTEGER = LuaInteger.class.getName(); + private static final String STR_LUADOUBLE = LuaDouble.class.getName(); + private static final String STR_LUANUMBER = LuaNumber.class.getName(); + private static final String STR_LUABOOLEAN = LuaBoolean.class.getName(); + private static final String STR_LUATABLE = LuaTable.class.getName(); + private static final String STR_BUFFER = Buffer.class.getName(); + private static final String STR_STRING = String.class.getName(); + + private static final ObjectType TYPE_VARARGS = new ObjectType(STR_VARARGS); + private static final ObjectType TYPE_LUAVALUE = new ObjectType(STR_LUAVALUE); + private static final ObjectType TYPE_LUASTRING = new ObjectType(STR_LUASTRING); + private static final ObjectType TYPE_LUAINTEGER = new ObjectType(STR_LUAINTEGER); + private static final ObjectType TYPE_LUADOUBLE = new ObjectType(STR_LUADOUBLE); + private static final ObjectType TYPE_LUANUMBER = new ObjectType(STR_LUANUMBER); + private static final ObjectType TYPE_LUABOOLEAN = new ObjectType(STR_LUABOOLEAN); + private static final ObjectType TYPE_LUATABLE = new ObjectType(STR_LUATABLE); + private static final ObjectType TYPE_BUFFER = new ObjectType(STR_BUFFER); + + private static final ArrayType TYPE_LOCALUPVALUE = new ArrayType( TYPE_LUAVALUE, 1 ); + private static final ArrayType TYPE_CHARARRAY = new ArrayType( Type.CHAR, 1 ); + + private static final Class[] NO_INNER_CLASSES = {}; + + private static final String STR_FUNCV = VarArgFunction.class.getName(); + private static final String STR_FUNC0 = ZeroArgFunction.class.getName(); + private static final String STR_FUNC1 = OneArgFunction.class.getName(); + private static final String STR_FUNC2 = TwoArgFunction.class.getName(); + private static final String STR_FUNC3 = ThreeArgFunction.class.getName(); + + // names, arg types for main prototype classes + private static final String[] SUPER_NAME_N = { STR_FUNC0, STR_FUNC1, STR_FUNC2, STR_FUNC3, STR_FUNCV, }; + private static final ObjectType[] RETURN_TYPE_N = { TYPE_LUAVALUE, TYPE_LUAVALUE, TYPE_LUAVALUE, TYPE_LUAVALUE, TYPE_VARARGS, }; + private static final Type[][] ARG_TYPES_N = { {}, {TYPE_LUAVALUE}, {TYPE_LUAVALUE,TYPE_LUAVALUE}, {TYPE_LUAVALUE,TYPE_LUAVALUE,TYPE_LUAVALUE}, {TYPE_VARARGS}, }; + private static final String[][] ARG_NAMES_N = { {}, {"arg"}, {"arg1","arg2"}, {"arg1","arg2","arg3"}, {"args"}, }; + private static final String[] METH_NAME_N = { "call", "call", "call", "call", "invoke", }; + + // varable naming + private static final String PREFIX_CONSTANT = "k"; + private static final String PREFIX_UPVALUE = "u"; + private static final String PREFIX_PLAIN_SLOT = "s"; + private static final String PREFIX_UPVALUE_SLOT = "a"; + private static final String NAME_VARRESULT = "v"; + + // basic info + private final Prototype p; + private final String classname; + private final Slots slots; + + // bcel variables + private final ClassGen cg; + private final ConstantPoolGen cp; + private final InstructionFactory factory; + + // main instruction list for the main function of this class + private final InstructionList init; + private final InstructionList main; + private final MethodGen mg; + + // the superclass arg count, 0-3 args, 4=varargs + private int superclassType; + private static int SUPERTYPE_VARARGS = 4; + + // storage for goto locations + private final int[] targets; + private final BranchInstruction[] branches; + private final InstructionHandle[] branchDestHandles; + private InstructionHandle beginningOfLuaInstruction; + + // hold vararg result + private LocalVariableGen varresult = null; + + public JavaBuilder(Prototype p, String classname, String filename) { + this.p = p; + this.classname = classname; + this.slots = new Slots(p); + + // what class to inherit from + superclassType = p.numparams; + if ( p.is_vararg != 0 || superclassType >= SUPERTYPE_VARARGS ) + superclassType = SUPERTYPE_VARARGS; + for ( int i=0, n=p.code.length; i 2) ) + superclassType = SUPERTYPE_VARARGS; + } + + // create class generator + cg = new ClassGen(classname, SUPER_NAME_N[superclassType], filename, + Constants.ACC_PUBLIC | Constants.ACC_SUPER, null); + cp = cg.getConstantPool(); // cg creates constant pool + + // main instruction lists + factory = new InstructionFactory(cg); + init = new InstructionList(); + main = new InstructionList(); + + // create the fields + for ( int i=0; i 0 ) { + append(new ALOAD(1)); + append(new PUSH(cp, 1 + p.numparams)); + append(factory.createInvoke(STR_VARARGS, "subargs", TYPE_VARARGS, new Type[] { Type.INT }, Constants.INVOKEVIRTUAL)); + append(new ASTORE(1)); + } + } else { + // fixed arg function between 0 and 3 arguments + for ( slot=0; slot", cg + .getClassName(), init, cg.getConstantPool()); + init.append(InstructionConstants.RETURN); + mg.setMaxStack(); + cg.addMethod(mg.getMethod()); + init.dispose(); + } + + // add default constructor + cg.addEmptyConstructor(Constants.ACC_PUBLIC); + + // gen method + resolveBranches(); + mg.setMaxStack(); + cg.addMethod(mg.getMethod()); + main.dispose(); + + // convert to class bytes + try { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + cg.getJavaClass().dump(baos); + return baos.toByteArray(); + } catch ( IOException ioe ) { + throw new RuntimeException("JavaClass.dump() threw "+ioe); + } + } + + public void dup() { + append(InstructionConstants.DUP); + } + + public void pop() { + append(InstructionConstants.POP); + } + + public void loadNil() { + append(factory.createFieldAccess(STR_LUAVALUE, "NIL", TYPE_LUAVALUE, Constants.GETSTATIC)); + } + + public void loadNone() { + append(factory.createFieldAccess(STR_LUAVALUE, "NONE", TYPE_LUAVALUE, Constants.GETSTATIC)); + } + + public void loadBoolean(boolean b) { + String field = (b? "TRUE": "FALSE"); + append(factory.createFieldAccess(STR_LUAVALUE, field, TYPE_LUABOOLEAN, Constants.GETSTATIC)); + } + + private Map plainSlotVars = new HashMap(); + private Map upvalueSlotVars = new HashMap(); + private int findSlot( int slot, Map map, String prefix, Type type ) { + if ( map.containsKey(slot) ) + return map.get(slot); + String name = prefix+slot; + LocalVariableGen local = mg.addLocalVariable(name, type, null, null); + int index = local.getIndex(); + map.put(slot, index); + return index; + } + private int findSlotIndex( int slot, boolean isupvalue ) { + return isupvalue? + findSlot( slot, upvalueSlotVars, PREFIX_UPVALUE_SLOT, TYPE_LOCALUPVALUE ): + findSlot( slot, plainSlotVars, PREFIX_PLAIN_SLOT, TYPE_LUAVALUE ); + } + + public void loadLocal(int pc, int slot) { + boolean isupval = slots.isUpvalueRefer(pc, slot); + int index = findSlotIndex( slot, isupval ); + append(new ALOAD(index)); + if (isupval) { + append(new PUSH(cp, 0)); + append(InstructionConstants.AALOAD); + } + } + + public void storeLocal(int pc, int slot) { + boolean isupval = slots.isUpvalueAssign(pc, slot); + int index = findSlotIndex( slot, isupval ); + if (isupval) { + boolean isupcreate = slots.isUpvalueCreate(pc, slot); + if ( isupcreate ) { + append(new PUSH(cp, 1)); + append(new ANEWARRAY(cp.addClass(STR_LUAVALUE))); + append(InstructionConstants.DUP); + append(new ASTORE(index)); + } else { + append(new ALOAD(index)); + } + append(InstructionConstants.SWAP); + append(new PUSH(cp, 0)); + append(InstructionConstants.SWAP); + append(InstructionConstants.AASTORE); + } else { + append(new ASTORE(index)); + } + } + + private static String upvalueName(int upindex) { + return PREFIX_UPVALUE+upindex; + } + + public void loadUpvalue(int upindex) { + append(InstructionConstants.THIS); + append(factory.createFieldAccess(classname, upvalueName(upindex), TYPE_LOCALUPVALUE, Constants.GETFIELD)); + append(new PUSH(cp,0)); + append(InstructionConstants.AALOAD); + } + + public void storeUpvalue(int pc, int upindex, int slot) { + append(InstructionConstants.THIS); + append(factory.createFieldAccess(classname, upvalueName(upindex), TYPE_LOCALUPVALUE, Constants.GETFIELD)); + append(new PUSH(cp,0)); + loadLocal(pc, slot); + append(InstructionConstants.AASTORE); + } + + public void newTable( int b, int c ) { + append(new PUSH(cp, b)); + append(new PUSH(cp, c)); + append(factory.createInvoke(STR_LUAVALUE, "tableOf", TYPE_LUATABLE, new Type[] { Type.INT, Type.INT }, Constants.INVOKESTATIC)); + } + + public void loadEnv() { + append(InstructionConstants.THIS); + append(factory.createFieldAccess(classname, "env", TYPE_LUAVALUE, Constants.GETFIELD)); + } + + public void loadVarargs() { + append(new ALOAD(1)); + } + + public void loadVarargs(int argindex) { + loadVarargs(); + arg(argindex); + } + + public void arg(int argindex) { + if ( argindex == 1 ) { + append(factory.createInvoke(STR_VARARGS, "arg1", TYPE_LUAVALUE, new Type[] {}, Constants.INVOKEVIRTUAL)); + } else { + append(new PUSH(cp, argindex)); + append(factory.createInvoke(STR_VARARGS, "arg", TYPE_LUAVALUE, new Type[] { Type.INT }, Constants.INVOKEVIRTUAL)); + } + } + + private int getVarresultIndex() { + if ( varresult == null ) + varresult = mg.addLocalVariable(NAME_VARRESULT, TYPE_VARARGS, null, null); + return varresult.getIndex(); + } + + public void loadVarresult() { + append(new ALOAD(getVarresultIndex())); + } + + public void storeVarresult() { + append(new ASTORE(getVarresultIndex())); + } + + public void subargs(int firstarg) { + append(new PUSH(cp, firstarg)); + append(factory.createInvoke(STR_VARARGS, "subargs", TYPE_VARARGS, new Type[] { Type.INT }, Constants.INVOKEVIRTUAL)); + } + + public void getTable() { + append(factory.createInvoke(STR_LUAVALUE, "get", TYPE_LUAVALUE, new Type[] { TYPE_LUAVALUE }, Constants.INVOKEVIRTUAL)); + } + + public void setTable() { + append(factory.createInvoke(STR_LUAVALUE, "set", Type.VOID, new Type[] { TYPE_LUAVALUE, TYPE_LUAVALUE }, Constants.INVOKEVIRTUAL)); + } + + public void unaryop(int o) { + String op; + switch (o) { + default: + case Lua.OP_UNM: op = "neg"; break; + case Lua.OP_NOT: op = "not"; break; + case Lua.OP_LEN: op = "len"; break; + } + append(factory.createInvoke(STR_LUAVALUE, op, TYPE_LUAVALUE, Type.NO_ARGS, Constants.INVOKEVIRTUAL)); + } + + public void binaryop(int o) { + String op; + switch (o) { + default: + case Lua.OP_ADD: op = "add"; break; + case Lua.OP_SUB: op = "sub"; break; + case Lua.OP_MUL: op = "mul"; break; + case Lua.OP_DIV: op = "div"; break; + case Lua.OP_MOD: op = "mod"; break; + case Lua.OP_POW: op = "pow"; break; + } + append(factory.createInvoke(STR_LUAVALUE, op, TYPE_LUAVALUE, new Type[] { TYPE_LUAVALUE }, Constants.INVOKEVIRTUAL)); + } + + public void compareop(int o) { + String op; + switch (o) { + default: + case Lua.OP_EQ: op = "eq_b"; break; + case Lua.OP_LT: op = "lt_b"; break; + case Lua.OP_LE: op = "lteq_b"; break; + } + append(factory.createInvoke(STR_LUAVALUE, op, Type.BOOLEAN, new Type[] { TYPE_LUAVALUE }, Constants.INVOKEVIRTUAL)); + } + + public void areturn() { + append(InstructionConstants.ARETURN); + } + + public void toBoolean() { + append(factory.createInvoke(STR_LUAVALUE, "toboolean", Type.BOOLEAN, Type.NO_ARGS, Constants.INVOKEVIRTUAL)); + } + + public void tostring() { + append(factory.createInvoke(STR_BUFFER, "tostring", TYPE_LUASTRING, Type.NO_ARGS, Constants.INVOKEVIRTUAL)); + } + + public void isNil() { + append(factory.createInvoke(STR_LUAVALUE, "isnil", Type.BOOLEAN, Type.NO_ARGS, Constants.INVOKEVIRTUAL)); + } + + public void testForLoop() { + append(factory.createInvoke(STR_LUAVALUE, "testfor_b", Type.BOOLEAN, new Type[] { TYPE_LUAVALUE, TYPE_LUAVALUE }, Constants.INVOKEVIRTUAL)); + } + + public void loadArrayArgs(int pc, int firstslot, int nargs) { + append(new PUSH(cp, nargs)); + append(new ANEWARRAY(cp.addClass(STR_LUAVALUE))); + for ( int i=0; i", Type.VOID, Type.NO_ARGS, Constants.INVOKESPECIAL)); + append(InstructionConstants.DUP); + loadEnv(); + append(factory.createInvoke(STR_LUAVALUE, "setfenv", Type.VOID, new Type[] { TYPE_LUAVALUE }, Constants.INVOKEVIRTUAL)); + } + + public void closureInitUpvalueFromUpvalue(String protoname, int newup, int upindex) { + String srcname = upvalueName(upindex); + String destname = upvalueName(newup); + append(InstructionConstants.THIS); + append(factory.createFieldAccess(classname, srcname, TYPE_LOCALUPVALUE, Constants.GETFIELD)); + append(factory.createFieldAccess(protoname, destname, TYPE_LOCALUPVALUE, Constants.PUTFIELD)); + } + + public void closureInitUpvalueFromLocal(String protoname, int newup, int pc, int srcslot) { + String destname = upvalueName(newup); + int index = findSlotIndex( srcslot, true ); + append(new ALOAD(index)); + append(factory.createFieldAccess(protoname, destname, TYPE_LOCALUPVALUE, Constants.PUTFIELD)); + } + + private Map constants = new HashMap(); + + public void loadConstant(LuaValue value) { + String name = constants.get(value); + if ( name == null ) { + name = value.type() == LuaValue.TNUMBER? + value.isinttype()? + createLuaIntegerField(value.checkint()): + createLuaDoubleField(value.checkdouble()): + createLuaStringField(value.checkstring()); + constants.put(value, name); + } + append(factory.createGetStatic(classname, name, TYPE_LUAVALUE)); + } + + private String createLuaIntegerField(int value) { + String name = PREFIX_CONSTANT+constants.size(); + FieldGen fg = new FieldGen(Constants.ACC_STATIC | Constants.ACC_FINAL, + TYPE_LUAVALUE, name, cp); + cg.addField(fg.getField()); + init.append(new PUSH(cp, value)); + init.append(factory.createInvoke(STR_LUAVALUE, "valueOf", + TYPE_LUAINTEGER, new Type[] { Type.INT }, Constants.INVOKESTATIC)); + init.append(factory.createPutStatic(classname, name, TYPE_LUAVALUE)); + return name; + } + + private String createLuaDoubleField(double value) { + String name = PREFIX_CONSTANT+constants.size(); + FieldGen fg = new FieldGen(Constants.ACC_STATIC | Constants.ACC_FINAL, + TYPE_LUAVALUE, name, cp); + cg.addField(fg.getField()); + init.append(new PUSH(cp, value)); + init.append(factory.createInvoke(STR_LUAVALUE, "valueOf", + TYPE_LUANUMBER, new Type[] { Type.DOUBLE }, Constants.INVOKESTATIC)); + init.append(factory.createPutStatic(classname, name, TYPE_LUAVALUE)); + return name; + } + + private String createLuaStringField(LuaString value) { + String name = PREFIX_CONSTANT+constants.size(); + FieldGen fg = new FieldGen(Constants.ACC_STATIC | Constants.ACC_FINAL, + TYPE_LUAVALUE, name, cp); + cg.addField(fg.getField()); + LuaString ls = value.checkstring(); + if ( ls.isValidUtf8() ) { + init.append(new PUSH(cp, value.toString())); + init.append(factory.createInvoke(STR_LUASTRING, "valueOf", + TYPE_LUASTRING, new Type[] { Type.STRING }, Constants.INVOKESTATIC)); + } else { + char[] c = new char[ls.m_length]; + for ( int j=0; j", Type.VOID, Type.NO_ARGS, Constants.INVOKESPECIAL)); + } + + public void appendBuffer() { + append(factory.createInvoke(STR_LUAVALUE, "checkstring", TYPE_LUASTRING, Type.NO_ARGS, Constants.INVOKEVIRTUAL)); + append(factory.createInvoke(STR_BUFFER, "append", Type.VOID, new Type[] { TYPE_LUASTRING }, Constants.INVOKEVIRTUAL)); + } +} diff --git a/src/jse/org/luaj/vm2/luajc/JavaBytecodeCompiler.java b/src/jse/org/luaj/vm2/luajc/JavaBytecodeCompiler.java deleted file mode 100644 index e2511ab2..00000000 --- a/src/jse/org/luaj/vm2/luajc/JavaBytecodeCompiler.java +++ /dev/null @@ -1,129 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2009 Luaj.org. All rights reserved. - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in - * all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN - * THE SOFTWARE. - ******************************************************************************/ -package org.luaj.vm2.luajc; - -import java.io.IOException; -import java.io.InputStream; -import java.util.Hashtable; - -import org.luaj.vm2.LoadState; -import org.luaj.vm2.LuaClosure; -import org.luaj.vm2.LuaFunction; -import org.luaj.vm2.LuaValue; -import org.luaj.vm2.Prototype; -import org.luaj.vm2.LoadState.LuaCompiler; -import org.luaj.vm2.compiler.LuaC; -import org.luaj.vm2.lib.PackageLib; - -public class JavaBytecodeCompiler implements LuaCompiler { - - private static JavaBytecodeCompiler instance; - private JavaBytecodeGenerator gen; - private LuaC luac; - - public static JavaBytecodeCompiler getInstance() { - if ( instance == null ) - instance = new JavaBytecodeCompiler(); - return instance; - } - - /** - * Install the compiler as the main compiler to use. - * Will fall back to the LuaC prototype compiler. - */ - public static final void install() { - LoadState.compiler = getInstance(); - } - - public JavaBytecodeCompiler() { - luac = new LuaC(); - gen = new JavaBytecodeGenerator(); - } - - /** Compile int a prototype */ - public static Prototype compile(InputStream is, String chunkname) throws IOException { - return getInstance().compile(is.read(), is, chunkname); - } - - /** Compile and load a chunk - * @throws IOException */ - public static LuaValue load(InputStream is, String filename, LuaValue _g) throws IOException { - return getInstance().load(is.read(), is, filename, _g); - } - - /** Compile into protoype form. */ - public Prototype compile(int firstByte, InputStream stream, String chunkname) throws IOException { - return luac.compile(firstByte, stream, chunkname); - } - - /** Compile and load a chunk - * @throws IOException */ - public static byte[] loadClass(InputStream is, String filename) throws IOException { - return getInstance().loadClass( is.read(), is, filename ); - } - - /** Compile into class form. */ - public LuaFunction load(int firstByte, InputStream stream, String filename, LuaValue env) throws IOException { - Prototype p = compile( firstByte, stream, filename); - return load( p, filename, env ); - } - - /** Compile into a class */ - private byte[] loadClass(int firstByte, InputStream stream, String filename) throws IOException { - Prototype p = compile(firstByte, stream, filename); - return gen.generateBytecode(p, PackageLib.toClassname(filename), toSourcename(filename)); - } - - /** Compile all classes produced by a prototype, and put results in a hashtable */ - public static Hashtable loadClasses( InputStream stream, String filename ) throws IOException { - if ( LoadState.compiler == null ) - install(); - Prototype p = LoadState.compile( stream, filename ); - Hashtable t = new Hashtable(); - getInstance().genClass(t, p, PackageLib.toClassname(filename), toSourcename(filename)); - return t; - } - - private void genClass( Hashtable t, Prototype p, String classname, String sourceName ) throws IOException { - t.put( classname, gen.generateBytecode( p, classname, sourceName ) ); - for ( int i=0, n=p.p!=null? p.p.length: 0; i0? new Class[p.p.length]: NO_INNER_CLASSES); - for ( int i=0, n=inners.length; i> 6) & 0xff; - } - private static final int B(int i) { - return i >>> 23; - } - private static final int Bx(int i) { - return i >>> 14; - } - private static final int C(int i) { - return (i >> 14) & 0x1ff; - } - - byte[] generateBytecode(Prototype p, String classname, String filename) - throws IOException { - - // use fresh context - byte[] bytes = new Context(p,classname,filename).bytes; - - // write the bytes for debugging! - if (DUMPCLASSES) { - FileOutputStream fos = new FileOutputStream(classname + ".class"); - fos.write(bytes); - fos.close(); - } - - // return the byte array - return bytes; - } - - private static final class Context { - - // parameters - private final Prototype p; - private final String classname; - private final String filename; - - // bcel variables - private final ClassGen cg; - private final ConstantPoolGen cp; - - // constants in lua file - private final Field[] k; - - // upvalues are also fields - private final Field[] u; - - // the class bytes - this is the last thing we compute - private final byte[] bytes; - - // locals - private final int np; // num params - private final int nl; // num locals - private final LocalVariableGen[] locals; - - // main instruction list for main function - private final InstructionList init; - private final InstructionList il; - private final MethodGen mg; - private final InstructionFactory factory; - - // variable that holds vararg results - LocalVariableGen nil = null; - LocalVariableGen none = null; - LocalVariableGen env = null; - LocalVariableGen vret = null; - int vbase = -1; - - // first branch or top of loop - private final int firstbranch; - - // true if needs the "arg" variable - private final boolean needsarg; - - // locals that are upvalues - private final boolean isup[]; - private final boolean isinited[]; - - // current program counter - private int pc; - - // construct a context, and generate class bytes - private Context(Prototype p, String classname, String filename) throws IOException { - // parameters - this.p = p; - this.classname = classname; - this.filename = filename; - - // compile our class next - cg = new ClassGen(classname, STR_FUNCV, filename, - Constants.ACC_PUBLIC | Constants.ACC_SUPER, null); - cp = cg.getConstantPool(); // cg creates constant pool - - // static initializer for static constants - this.k = createLuaConstantFields(); - - // upvalues are fields - this.u = createUpvalueFields(); - - // lua slots map to java locals - np = p.numparams; - nl = p.maxstacksize; - locals = new LocalVariableGen[nl]; - - // implement LuaValue.onInvoke(Varargs args) - init = new InstructionList(); - il = new InstructionList(); - mg = new MethodGen( - Constants.ACC_PUBLIC | Constants.ACC_FINAL, // access flags - TYPE_VARARGS, // return type - new Type[] { TYPE_VARARGS }, // argument types - new String[] { "args" }, // arg names - "onInvoke", STR_LUAVALUE, // method, class - il, cp); - factory = new InstructionFactory(cg); - - // common iterators used for code - int[] code = p.code; - int nc = code.length; - int i, a, b, c; - - // initialize locals - isup = new boolean[nl]; - isinited = new boolean[nl]; - markups(p, isup, code); - - // find first branch or jump-back-to - firstbranch = findfirstbranch(); - - // initialize upvalud slots - needsarg = ((p.is_vararg & Lua.VARARG_NEEDSARG) != 0); - - // storage for goto locations - int[] targets = new int[nc]; - BranchInstruction[] branches = new BranchInstruction[nc]; - InstructionHandle[] ih = new InstructionHandle[nc]; - - // each lua bytecode gets some java bytecodes - for (pc = 0; pc < nc; pc++) { - - // make sure locals are initialized - if ( pc == firstbranch ) - for ( int j=0; j0xff? k[c&0x0ff]: stack[c]); - ih[pc] = - loadLocal(B(i)); - if ((c=C(i))>0xff) - il.append(factory.createFieldAccess(classname, k[c&0x0ff].getName(), TYPE_LUAVALUE, Constants.GETSTATIC)); - else - loadLocal(c); - il.append(factory.createInvoke(STR_LUAVALUE, "get", TYPE_LUAVALUE, new Type[] { TYPE_LUAVALUE }, Constants.INVOKEVIRTUAL)); - storeLocal(a); - break; - - case Lua.OP_SETGLOBAL: /* A Bx Gbl[Kst(Bx)]:= R(A) */ - // env.set(k[Bx(i)], stack[a]); - ih[pc] = - loadEnv(il); - il.append(factory.createFieldAccess(classname, k[Bx(i)].getName(), TYPE_LUAVALUE, Constants.GETSTATIC)); - loadLocal(a); - il.append(factory.createInvoke(STR_LUAVALUE, "set", Type.VOID, new Type[] { TYPE_LUAVALUE, TYPE_LUAVALUE }, Constants.INVOKEVIRTUAL)); - break; - - case Lua.OP_SETUPVAL: /* A B UpValue[B]:= R(A) */ - // upValues[B(i)].setValue(stack[a]); - ih[pc] = - il.append(InstructionConstants.THIS); - il.append(factory.createFieldAccess(classname, u[B(i)].getName(), TYPE_LOCALUPVALUE, Constants.GETFIELD)); - il.append(new PUSH(cp,0)); - loadLocal(a); - il.append(InstructionConstants.AASTORE); - break; - - case Lua.OP_SETTABLE: /* A B C R(A)[RK(B)]:= RK(C) */ - // stack[a].set(((b=B(i))>0xff? k[b&0x0ff]: stack[b]), (c=C(i))>0xff? k[c&0x0ff]: stack[c]); - ih[pc] = - loadLocal(a); - if ((b=B(i))>0xff) - il.append(factory.createFieldAccess(classname, k[b&0x0ff].getName(), TYPE_LUAVALUE, Constants.GETSTATIC)); - else - loadLocal(b); - if ((c=C(i))>0xff) - il.append(factory.createFieldAccess(classname, k[c&0x0ff].getName(), TYPE_LUAVALUE, Constants.GETSTATIC)); - else - loadLocal(c); - il.append(factory.createInvoke(STR_LUAVALUE, "set", Type.VOID, new Type[] { TYPE_LUAVALUE, TYPE_LUAVALUE }, Constants.INVOKEVIRTUAL)); - break; - - case Lua.OP_NEWTABLE: /* A B C R(A):= {} (size = B,C) */ - // stack[a] = new LuaTable(B(i),C(i)); - ih[pc] = - il.append(new PUSH(cp, B(i))); - il.append(new PUSH(cp, C(i))); - il.append(factory.createInvoke(STR_LUAVALUE, "tableOf", TYPE_LUATABLE, new Type[] { Type.INT, Type.INT }, Constants.INVOKESTATIC)); - storeLocal(a); - break; - - case Lua.OP_SELF: /* A B C R(A+1):= R(B): R(A):= R(B)[RK(C)] */ - // stack[a+1] = (o = stack[B(i)]); - ih[pc] = - loadLocal(B(i)); - il.append(InstructionConstants.DUP); - storeLocal(a+1); - // stack[a] = o.get((c=C(i))>0xff? k[c&0x0ff]: stack[c]); - if ((c=C(i))>0xff) - il.append(factory.createFieldAccess(classname, k[c&0x0ff].getName(), TYPE_LUAVALUE, Constants.GETSTATIC)); - else - loadLocal(c); - il.append(factory.createInvoke(STR_LUAVALUE, "get", TYPE_LUAVALUE, new Type[] { TYPE_LUAVALUE }, Constants.INVOKEVIRTUAL)); - storeLocal(a); - break; - - case Lua.OP_ADD: /* A B C R(A):= RK(B) + RK(C) */ - case Lua.OP_SUB: /* A B C R(A):= RK(B) - RK(C) */ - case Lua.OP_MUL: /* A B C R(A):= RK(B) * RK(C) */ - case Lua.OP_DIV: /* A B C R(A):= RK(B) / RK(C) */ - case Lua.OP_MOD: /* A B C R(A):= RK(B) % RK(C) */ - case Lua.OP_POW: /* A B C R(A):= RK(B) ^ RK(C) */ - { - String op; - switch (OP(i)) { - default: - case Lua.OP_ADD: op = "add"; break; - case Lua.OP_SUB: op = "sub"; break; - case Lua.OP_MUL: op = "mul"; break; - case Lua.OP_DIV: op = "div"; break; - case Lua.OP_MOD: op = "mod"; break; - case Lua.OP_POW: op = "pow"; break; - } - // stack[a] = ((b=B(i))>0xff? k[b&0x0ff]: stack[b]).add((c=C(i))>0xff? k[c&0x0ff]: stack[c]); - if ((b=B(i))>0xff) - ih[pc] = - il.append(factory.createFieldAccess(classname, k[b&0x0ff].getName(), TYPE_LUAVALUE, Constants.GETSTATIC)); - else - ih[pc] = - loadLocal(b); - if ((c=C(i))>0xff) - il.append(factory.createFieldAccess(classname, k[c&0x0ff].getName(), TYPE_LUAVALUE, Constants.GETSTATIC)); - else - loadLocal(c); - il.append(factory.createInvoke(STR_LUAVALUE, op, TYPE_LUAVALUE, new Type[] { TYPE_LUAVALUE }, Constants.INVOKEVIRTUAL)); - storeLocal(a); - break; - } - case Lua.OP_UNM: /* A B R(A):= -R(B) */ - // stack[a] = stack[B(i)].neg(); - ih[pc] = - loadLocal(B(i)); - il.append(factory.createInvoke(STR_LUAVALUE, "neg", TYPE_LUAVALUE, Type.NO_ARGS, Constants.INVOKEVIRTUAL)); - storeLocal(a); - break; - - case Lua.OP_NOT: /* A B R(A):= not R(B) */ - // stack[a] = stack[B(i)].not(); - ih[pc] = - loadLocal(B(i)); - il.append(factory.createInvoke(STR_LUAVALUE, "not", TYPE_LUAVALUE, Type.NO_ARGS, Constants.INVOKEVIRTUAL)); - storeLocal(a); - break; - - case Lua.OP_LEN: /* A B R(A):= length of R(B) */ - // stack[a] = stack[B(i)].len(); - ih[pc] = - loadLocal(B(i)); - il.append(factory.createInvoke(STR_LUAVALUE, "len", TYPE_LUAVALUE, Type.NO_ARGS, Constants.INVOKEVIRTUAL)); - storeLocal(a); - break; - - case Lua.OP_CONCAT: /* A B C R(A):= R(B).. ... ..R(C) */ - { - b = B(i); - c = C(i); - - // Buffer sb = new Buffer(); - ih[pc] = - il.append(factory.createNew(TYPE_BUFFER)); - il.append(InstructionConstants.DUP); - il.append(factory.createInvoke(STR_BUFFER, "", Type.VOID, Type.NO_ARGS, Constants.INVOKESPECIAL)); - - // concatenate - for ( ; b<=c; ) { - // sb.append( stack[b++].checkstring() ); - il.append(InstructionConstants.DUP); - loadLocal(b++); - il.append(factory.createInvoke(STR_LUAVALUE, "checkstring", TYPE_LUASTRING, Type.NO_ARGS, Constants.INVOKEVIRTUAL)); - il.append(factory.createInvoke(STR_BUFFER, "append", Type.VOID, new Type[] { TYPE_LUASTRING }, Constants.INVOKEVIRTUAL)); - } - - // store - // stack[a] = sb.tostrvalue(); - il.append(factory.createInvoke(STR_BUFFER, "tostrvalue", TYPE_LUASTRING, Type.NO_ARGS, Constants.INVOKEVIRTUAL)); - storeLocal(a); - } - break; - - case Lua.OP_JMP: /* sBx pc+=sBx */ - // pc += (Bx(i))-0x1ffff; - branches[pc] = new GOTO(null); - targets[pc] = pc + 1 + (Bx(i))-0x1ffff; - ih[pc] = - il.append(branches[pc]); - break; - - case Lua.OP_EQ: /* A B C if ((RK(B) == RK(C)) ~= A) then pc++ */ - case Lua.OP_LT: /* A B C if ((RK(B) < RK(C)) ~= A) then pc++ */ - case Lua.OP_LE: /* A B C if ((RK(B) <= RK(C)) ~= A) then pc++ */ - { - String op; - switch (OP(i)) { - default: - case Lua.OP_EQ: op = "eq_b"; break; - case Lua.OP_LT: op = "lt_b"; break; - case Lua.OP_LE: op = "lteq_b"; break; - } - if ((b=B(i))>0xff) - ih[pc] = - il.append(factory.createFieldAccess(classname, k[b&0x0ff].getName(), TYPE_LUAVALUE, Constants.GETSTATIC)); - else - ih[pc] = - loadLocal(b); - if ((c=C(i))>0xff) - il.append(factory.createFieldAccess(classname, k[c&0x0ff].getName(), TYPE_LUAVALUE, Constants.GETSTATIC)); - else - loadLocal(c); - il.append(factory.createInvoke(STR_LUAVALUE, op, Type.BOOLEAN, new Type[] { TYPE_LUAVALUE }, Constants.INVOKEVIRTUAL)); - branches[pc] = (a!=0)? new IFEQ(null): new IFNE(null); - targets[pc] = pc + 2; - il.append(branches[pc]); - break; - } - case Lua.OP_TEST: /* A C if not (R(A) <=> C) then pc++ */ - ih[pc] = - loadLocal(a); - il.append(factory.createInvoke(STR_LUAVALUE, "toboolean", Type.BOOLEAN, Type.NO_ARGS, Constants.INVOKEVIRTUAL)); - branches[pc] = (C(i)!=0)? new IFEQ(null): new IFNE(null); - targets[pc] = pc + 2; - il.append(branches[pc]); - break; - - case Lua.OP_TESTSET: /* A B C if (R(B) <=> C) then R(A):= R(B) else pc++ */ - /* note: doc appears to be reversed */ - //if ( (o=stack[B(i)]).toboolean() != (C(i)!=0) ) - // ++pc; - //else - // stack[a] = o; // TODO: should be sBx? - ih[pc] = - loadLocal(B(i)); - il.append(factory.createInvoke(STR_LUAVALUE, "toboolean", Type.BOOLEAN, Type.NO_ARGS, Constants.INVOKEVIRTUAL)); - branches[pc] = (C(i)!=0)? new IFEQ(null): new IFNE(null); - targets[pc] = pc + 2; - il.append(branches[pc]); - loadLocal(B(i)); - storeLocal(a); - break; - - case Lua.OP_CALL: /* A B C R(A), ... ,R(A+C-2):= R(A)(R(A+1), ... ,R(A+B-1)) */ - case Lua.OP_TAILCALL: /* A B C return R(A)(R(A+1), ... ,R(A+B-1)) */ - ih[pc] = - loadLocal(a); - b = B(i); - c = C(i); - switch ( b ) { - case 1: // noargs - loadNone(il); - break; - case 2: // one arg - loadLocal(a+1); - break; - case 3: // two args - loadLocal(a+1); - loadLocal(a+2); - il.append(factory.createInvoke(STR_LUAVALUE, "varargsOf", TYPE_VARARGS, new Type[] { TYPE_LUAVALUE, TYPE_VARARGS }, Constants.INVOKESTATIC)); - break; - case 4: // three args - loadLocal(a+1); - loadLocal(a+2); - loadLocal(a+3); - il.append(factory.createInvoke(STR_LUAVALUE, "varargsOf", TYPE_VARARGS, new Type[] { TYPE_LUAVALUE, TYPE_LUAVALUE, TYPE_VARARGS }, Constants.INVOKESTATIC)); - break; - default: // fixed arg count - il.append(new PUSH(cp, b-1)); - il.append(new ANEWARRAY(cp.addClass(STR_LUAVALUE))); - for ( int j=0; j=) R(A)*/ - ih[pc] = il.append(InstructionConstants.NOP); // for branching - for ( int j=nl; --j>=a; ) { - isinited[j] = true; - if ( isup[j] ) { - this.initLocal(j, false); - il.append(new PUSH(cp, 1)); - il.append(new ANEWARRAY(cp.addClass(STR_LUAVALUE))); - il.append(new ASTORE(locals[j].getIndex())); - } - } - break; - - case Lua.OP_CLOSURE: /* A Bx R(A):= closure(KPROTO[Bx], R(A), ... ,R(A+n)) */ - { - b = Bx(i); - Prototype newp = p.p[b]; - String protoname = classname+"$"+b; - - // instantiate the class - ih[pc] = - il.append(factory.createNew(new ObjectType(protoname))); - il.append(InstructionConstants.DUP); - il.append(factory.createInvoke(protoname, "", Type.VOID, Type.NO_ARGS, Constants.INVOKESPECIAL)); - - // set the environment - il.append(InstructionConstants.DUP); - loadEnv( il ); - il.append(factory.createInvoke(STR_LUAVALUE, "setfenv", Type.VOID, new Type[] { TYPE_LUAVALUE }, Constants.INVOKEVIRTUAL)); - - // initialize upvalues of new instance - for ( int j=0, nup=newp.nups; j 0) { - il.append(new PUSH(cp, 1 + np)); - il.append(factory.createInvoke(STR_VARARGS, "subargs", - TYPE_VARARGS, new Type[] { Type.INT }, - Constants.INVOKEVIRTUAL)); - } - storeVarreturns(il); - vbase = a; - } else { - for ( int j=1; j", cg - .getClassName(), il, cg.getConstantPool()); - InstructionFactory factory = new InstructionFactory(cg); - - // initialze the constants - for (int i = 0; i < nk; i++) { - LuaValue ki = p.k[i]; - switch (ki.type()) { - case LuaValue.TNIL: - il.append(factory.createFieldAccess(STR_LUAVALUE, "NIL", - TYPE_LUAVALUE, Constants.GETSTATIC)); - il.append(factory.createPutStatic(classname, - k[i].getName(), k[i].getType())); - break; - case LuaValue.TBOOLEAN: - String b = ki.toboolean() ? "TRUE" : "FALSE"; - il.append(factory.createFieldAccess(STR_LUAVALUE, b, - TYPE_LUABOOLEAN, Constants.GETSTATIC)); - il.append(factory.createPutStatic(classname, - k[i].getName(), k[i].getType())); - break; - case LuaValue.TSTRING: - LuaString ls = ki.checkstring(); - if ( ls.isValidUtf8() ) { - il.append(new PUSH(cp, ki.toString())); - il.append(factory.createInvoke(STR_LUASTRING, "valueOf", - TYPE_LUASTRING, new Type[] { Type.STRING }, - Constants.INVOKESTATIC)); - } else { - char[] c = new char[ls.m_length]; - for ( int j=0; j= upvalues.length || upvalues[i] == null ) - return "u"+i; - return "$"+upvalues[i].toString(); - } - - // find the upvalues implied by the subsequent instructions - private void markups(Prototype p, boolean[] isup, int[] code) { - for ( int pc=0; pc stringBuffers = new Stack(); - public StringBuffer sb; - private int indent = 0; - - public JavaCodeGenerator() { - this.sb = new StringBuffer(); - } - - private String writeChunk(LSChunk chunk) { - pushFunctionContext(); - writeln( "import org.luaj.vm2.*;" ); - writeln( "import org.luaj.vm2.lib.*;" ); - writeln(); - writeln( "public class "+chunk.chunkname+" extends VarArgFunction {" ); - ++indent; - writeln( "public Varargs invoke(Varargs $args) {"); - ++indent; - writeFunctionBody( chunk.function ); - --indent; - writeln( "}"); - --indent; - // TODO: write out chunk constants - writeln( "}" ); - return popFunctionContext(); - } - - private void pushFunctionContext() { - stringBuffers.push( sb = new StringBuffer() ); - } - - private String popFunctionContext() { - String v = stringBuffers.pop().toString(); - sb = stringBuffers.isEmpty()? null: stringBuffers.lastElement(); - return v; - } - - private void writeFunctionBody(LSFunction function) { - if ( function.hasandlogic || function.hasorlogic ) - writeln( "LuaValue $t;" ); - if ( function.hasvarargassign ) - writeln( "Varargs $v;" ); - writeStatements( function.stats ); - if ( LSStatement.isNextStatementReachable( function.stats ) ) - writeln( "return NONE;" ); - } - - private void writeStatements(List statements) { - for ( LSStatement s : statements ) { - writeStatement( s ); - } - } - - private void writeStatement(LSStatement s) { - if ( s==null ) return; - switch ( s.type ) { - case functionCall: writeFunctionCall( (LSStatement.FunctionCall) s ); break; - case doBlock: writeDoBlock( (LSStatement.DoBlock) s ); break; - case whileLoop: writeWhileLoop( (LSStatement.WhileLoop) s ); break; - case repeatUntil: writeRepeatUntil( (LSStatement.RepeatUntil) s ); break; - case varAssign: writeVarAssign( (LSStatement.VarAssign) s ); break; - case forLoop: writeForLoop( (LSStatement.ForLoop) s ); break; - case forList: writeForList( (LSStatement.ForList) s ); break; - case varNamedFunction: writeVarNamedFunction((LSStatement.VarNamedFunction) s ); break; - case localFunction: writeLocalFunction( (LSStatement.LocalFunction) s ); break; - case localAssign: writeLocalAssign( (LSStatement.LocalAssign) s ); break; - case returnStat: writeReturnStat( (LSStatement.ReturnStat) s ); break; - case breakStat: writeBreakStat( (LSStatement.BreakStat) s ); break; - case ifStat: writeIfStat( (LSIfStatement) s ); break; - } - } - - private void writeFunctionCall(FunctionCall s) { - writeindent(); - write( eval(s.variable)+";" ); - writeln(); - } - - private void writeDoBlock(DoBlock s) { - writeln( "{" ); - ++indent; - writeStatements( s.statements ); - --indent; - writeln( "}" ); - } - - private void writeWhileLoop(WhileLoop s) { - writeln( "while ("+eval(s.condition)+".toboolean()) {" ); - ++indent; - writeStatements( s.statements ); - --indent; - writeln( "}" ); - } - - private void writeRepeatUntil(RepeatUntil s) { - writeln( "do {" ); - ++indent; - writeStatements( s.statements ); - --indent; - writeln( "} while (!"+eval(s.condition)+");" ); - } - - private void writeForLoop(ForLoop s) { - writeln( "{" ); - ++indent; - // TODO: name handling, also upvalues! - String index = javaName( s.index ); - String limit = javaName( s.scope.declare("$limit") ); - String step = javaName( s.scope.declare("$step") ); - writeln( "LuaValue "+index+"="+eval(s.initial)+";" ); - writeln( "final LuaValue "+limit+"="+eval(s.limit)+";" ); - if ( s.step != null ) { - writeln( "final LuaValue "+step+"="+eval(s.step)+";" ); - writeln( "final boolean "+step+"$b="+step+".gt_b(0);" ); - } - if ( s.step != null ) { - writeln( "for ( ; "+index+".testfor_b("+limit+","+step+"$b); "+index+"="+index+".add("+step+") ) {" ); - } else { - writeln( "for ( ; "+index+".lteq_b("+limit+"); "+index+"="+index+".add(1) ) {" ); - } - ++indent; - writeStatements( s.statements ); - --indent; - writeln( "}" ); - --indent; - writeln( "}" ); - } - - private void writeForList(ForList s) { - writeln( "{" ); - ++indent; - List exprs = evalExpressions(s.expressions, 3, s.scope); - // TODO: upvalues handling! - String fun = javaName( s.scope.declare("$f") ); - String sta = javaName( s.scope.declare("$s") ); - String var = javaName( s.scope.declare("$var") ); - String res = javaName( s.scope.declare("$res") ); - writeln( "LuaValue "+fun+"="+exprs.get(0)+";" ); - writeln( "LuaValue "+sta+"="+exprs.get(1)+";" ); - writeln( "LuaValue "+var+"="+exprs.get(2)+";" ); - writeln( "while ( true ) {" ); - ++indent; - writeln( "Varargs "+res+" = "+fun+".invoke(varargsOf("+sta+","+var+"));" ); - for ( int i=1, n=s.names.size(); i<=n; i++ ) - writeln( "LuaValue "+javaName(s.names.get(i-1))+"="+res+".arg("+i+");" ); - writeln( var+"="+javaName(s.names.get(0))+";" ); - writeln( "if ( "+var+".isnil() ) break;" ); - writeStatements( s.statements ); - --indent; - writeln( "}" ); - --indent; - writeln( "}" ); - } - - private final static Set reserved = new HashSet(); - static { - String[] specials = { - // keywors used by our code generator - "name", "opcode", "env", - - // java keywords - "abstract", "continue", "for", "new", "switch", - "assert", "default", "goto", "package", "synchronized", - "boolean", "do", "if", "private", "this", - "break", "double", "implements", "protected", "throw", - "byte", "else", "import", "public", "throws", - "case", "enum", "instanceof", "return", "transient", - "catch", "extends", "int", "short", "try", - "char", "final", "interface", "static", "void", - "class", "finally", "long", "strictfp", "volatile", - "const", "float", "native", "super", "while", - }; - for ( int i=0; i0? - name.luaname+"$"+name.innerrevision: - reserved.contains(name.luaname)? (name.luaname+"$"): name.luaname; - } - - private void writeVarNamedFunction(VarNamedFunction s) { - String funcdef = evalFuncbody(s.funcbody); - writeAssign( s.funcname, funcdef ); - } - - private String evalFuncbody(LSFunction funcbody) { - pushFunctionContext(); - int n = funcbody.paramnames!=null? funcbody.paramnames.size(): 0; - boolean isvararg = (funcbody.isvararg || n > 3); - if ( isvararg ) { - write( "new VarArgFunction(env) {\n" ); - ++indent; - writeln( "public Varargs invoke(Varargs $args) {" ); - ++indent; - for ( int i=0; i 0 && funcbody.usesvarargs) || funcbody.needsarg ) - writeln( "$args = $args.subargs("+(n+1)+");" ); - if ( funcbody.needsarg ) - writeln( "LuaValue arg = new LuaTable($args);" ); - else if ( funcbody.hasarg ) - writeln( "LuaValue arg = NIL;" ); - writeFunctionBody(funcbody); - --indent; - writeln( "}" ); - --indent; - writeindent(); - write( "}" ); - } else { - write( - n==0? "new ZeroArgFunction(env) {\n": - n==1? "new OneArgFunction(env) {\n": - n==2? "new TwoArgFunction(env) {\n": - "new ThreeArgFunction(env) {\n" ); - ++indent; - writeindent(); - write( "public LuaValue call("); - for ( int i=0; i0) write( "," ); - Name name = funcbody.paramnames.get(i); - if ( name.isupvalue ) - write( "LuaValue "+javaName(name)+"$u" ); - else - write( "LuaValue "+javaName(name) ); - } - write( ") {" ); - writeln(); - ++indent; - - // upvalues - for ( int i=0; i exprs = evalExpressions(s.expressions, nassign, s.scope); - for ( int i=0; i exprs = evalExpressions(s.expressions, nassign, s.scope); - for ( int i=0; i evalExpressions(List exprs, int nassign, Scope scope) { - int nexpr = (exprs!=null? exprs.size(): 0); - List e = new ArrayList(nexpr); - boolean hasvarargs = false; - for ( int i=0; i1); - if ( hasvarargs ) - e.add( "($v="+eval(exprs.get(i))+").arg1()" ); - else - e.add( eval(exprs.get(i)) ); - } else if (hasvarargs) { - e.add( "$v.arg("+(i-nexpr+2)+")" ); - } else { - e.add( "NIL" ); - } - } - return e; - } - - - private void writeReturnStat(ReturnStat s) { - int n = s.expressions!=null? s.expressions.size(): 0; - if ( ! s.function.isvararg ) - writeln( n==0? "return NONE;": "return "+eval(s.expressions.get(0))+";" ); - else { - writeindent(); - switch ( n ) { - case 0: - write( "return NONE;" ); - break; - case 1: - write( "return "+eval( s.expressions.get(0))+";" ); - break; - case 2: case 3: { - write( "return varargsOf(" ); - for ( int i=0; i0) write( "," ); - write( eval( s.expressions.get(i)) ); - } - write( ");" ); - break; - } - default: { - write( "return varargsOf(new LuaValue[] {" ); - for ( int i=0; i0) write( "," ); - write( eval( s.expressions.get(i)) ); - } - write( "},"+eval(s.expressions.get(n-1))+");" ); - break; - } - } - writeln(); - } - } - - private void writeBreakStat(BreakStat s) { - writeln( "break;" ); - } - - private void writeIfStat(LSIfStatement s) { - writeln( "if ("+eval_bool(s.condition)+") {" ); - ++indent; - writeStatements( s.statements ); - if ( s.elseifs != null ) { - for ( LSIfStatement.ElseIf elseif : s.elseifs ) { - --indent; - writeln( "} else if ("+eval_bool(elseif.condition)+") {" ); - ++indent; - writeStatements( elseif.statements ); - } - } - if ( s.elsestatements != null ) { - --indent; - writeln( "} else {" ); - ++indent; - writeStatements( s.elsestatements ); - } - --indent; - writeln( "}" ); - } - - //------------------------------------------- - // assignment using variables - //------------------------------------------- - - /** Write assignment of a particular variable value */ - private void writeAssign(LSVariable v, String expression) { - switch ( v.type ) { - case nameVariable: writeNameAssign( (LSVariable.NameReference) v, expression); break; - case fieldVariable: writeFieldAssign( (LSVariable.Field) v, expression); break; - case methodVariable: writeMethodAssign( (LSVariable.Method) v, expression); break; - case parenthesesVariable: writeParenAssign( (LSVariable.Parentheses) v, expression); break; - case indexVariable: writeIndexAssign( (LSVariable.Index) v, expression); break; - case callFunctionVariable: writeCallFuncAssign((LSVariable.CallFunction)v, expression); break; - case callMethodVariable: writeCallMethAssign((LSVariable.CallMethod) v, expression); break; - } - } - - private void writeNameAssign(NameReference v, String expression) { - if ( v.name.isGlobal() ) - writeln( "env.set(\""+v.name.luaname+"\","+expression+");"); - else if ( v.name.isupvalue ) - writeln( javaName(v.name)+"[0]="+expression+";"); - else - writeln( javaName(v.name)+"="+expression+";"); - } - - private void writeFieldAssign(Field v, String expression) { - String base = eval(v.variable); - writeln( base+".set(\""+v.field+"\","+expression+");"); - } - - private void writeMethodAssign(Method v, String expression) { - String base = eval(v.variable); - writeln( base+".set(\""+v.method+"\","+expression+");"); - } - - private void writeParenAssign(Parentheses v, String expression) { - throw new IllegalArgumentException("no assignment for parenthesis expressions"); - } - - private void writeIndexAssign(Index v, String expression) { - String base = eval(v.variable); - writeln( base+".set("+eval(v.expression)+","+expression+");"); - } - - private void writeCallFuncAssign(CallFunction v, String expression) { - throw new IllegalArgumentException("no assignment for call function expressions"); - } - - private void writeCallMethAssign(CallMethod v, String expression) { - throw new IllegalArgumentException("no assignment for call method expressions"); - } - - //------------------------------------------- - // write out expressions - //------------------------------------------- - - private String eval_bool(LSExpression e) { - return eval(e)+".toboolean()"; - } - - /** evaluate the expression to a particular operand type */ - private String eval(LSExpression e) { - if ( e==null ) return "NONE"; - switch ( e.type ) { - case nilConstant: return "NIL"; - case trueConstant: return "TRUE"; - case falseConstant: return "FALSE"; - case unop: return evalUnop( (LSExpression.UnopExpr) e); - case binop: return evalBinop( (LSExpression.BinopExpr) e); - case functionExpr: return evalFunction((LSExpression.FunctionExpr) e); - case tableConstructor: return evalTable( (LSExpression.TableConstructor) e); - case numberConstant: return evalNumber( (LSExpression.NumberConstant) e); - case stringConstant: return evalString( (LSExpression.StringConstant) e); - - // variable types - case nameVariable: return evalNameRef( (LSVariable.NameReference) e); - case fieldVariable: return evalField( (LSVariable.Field) e); - case methodVariable: return evalMethod( (LSVariable.Method) e); - case parenthesesVariable: return evalParen( (LSVariable.Parentheses) e); - case indexVariable: return evalIndex( (LSVariable.Index) e); - case callFunctionVariable: return evalCallFunc((LSVariable.CallFunction) e); - case callMethodVariable: return evalCallMeth((LSVariable.CallMethod) e); - case varargsRef: return evalVarargs( (LSExpression.VarargsRef) e); - - default: throw new IllegalArgumentException("unknown expression type: "+e.type); - } - } - - private String evalUnop(UnopExpr e) { - switch ( e.op.type ) { - case neg: return eval( e.rhs )+".neg()"; - case not: return eval( e.rhs )+".not()"; - case len: return eval( e.rhs )+".len()"; - } - throw new IllegalArgumentException("unknown unary operand: "+e.op ); - } - - private String evalBinop(BinopExpr e) { - switch ( e.op.type ) { - case pow: return eval(e.lhs)+".pow("+eval(e.rhs)+")"; - case mul: return eval(e.lhs)+".mul("+eval(e.rhs)+")"; - case div: return eval(e.lhs)+".div("+eval(e.rhs)+")"; - case mod: return eval(e.lhs)+".mod("+eval(e.rhs)+")"; - case add: return eval(e.lhs)+".add("+eval(e.rhs)+")"; - case sub: return eval(e.lhs)+".sub("+eval(e.rhs)+")"; - case concat: return eval(e.lhs)+".concat("+eval(e.rhs)+")"; - case lt: return eval(e.lhs)+".lt("+eval(e.rhs)+")"; - case lteq: return eval(e.lhs)+".lteq("+eval(e.rhs)+")"; - case gt: return eval(e.lhs)+".gt("+eval(e.rhs)+")"; - case gteq: return eval(e.lhs)+".gteq("+eval(e.rhs)+")"; - case eq: return eval(e.lhs)+".eq("+eval(e.rhs)+")"; - case neq: return eval(e.lhs)+".neq("+eval(e.rhs)+")"; - case and: return "(($t="+eval(e.lhs)+").toboolean()? "+eval(e.rhs)+": $t)"; - case or: return "(($t="+eval(e.lhs)+").toboolean()? $t: "+eval(e.rhs)+")"; - default: throw new IllegalStateException("unknoqn binary operator: "+e.op); - } - } - - private String evalFunction(FunctionExpr e) { - return evalFuncbody(e.function); - } - - private String evalTable(TableConstructor e) { - StringBuffer named = new StringBuffer(); - StringBuffer numbered = new StringBuffer(); - LSExpression varargsLastListValue = null; - for ( int i=0, n=e.fields.size(); i0? "new LuaValue[] {"+named +"}": "null")+"," - +(numbered.length()>0? "new LuaValue[] {"+numbered+"}": "null") - +(varargsLastListValue!=null? ","+eval(varargsLastListValue): "")+")"; - } - - private String evalNumber(NumberConstant e) { - // TODO: internalize constants - return "valueOf("+e.value+")"; - } - - private String evalString(StringConstant e) { - // TODO: internalize constants - return "valueOf("+toStrValueInitializer(e.bytes)+")"; - } - - private String toStrValueInitializer(byte[] bytes) { - int n = bytes.length; - StringBuffer sb = new StringBuffer(n+2); - - // check for characters beyond ascii 128 - for ( int i=0; i0 ) sb.append(","); - byte b = bytes[j]; - switch ( b ) { - case '\n': sb.append( "'\\n'" ); break; - case '\r': sb.append( "'\\r'" ); break; - case '\t': sb.append( "'\\t'" ); break; - case '\\': sb.append( "'\\\\'" ); break; - default: - if ( b >= ' ' ) { - sb.append( '\''); - sb.append( (char) b ); - sb.append( '\''); - } else { - sb.append( String.valueOf((int)b) ); - } - break; - } - } - sb.append( "}" ); - return sb.toString(); - } - - sb.append('"'); - for ( int i=0; i= ' ' ) { - sb.append( (char) b ); break; - } else { - // convert from UTF-8 - int u = 0xff & (int) b; - if ( u>=0xc0 && i+1=0xe0 && i+2 1; - boolean isVarargsCall = n>0 && e.parameters.get(n-1).getNumReturns() < 0; - String base = eval(e.variable); - if ( n <= 3 && !isVarargsReturn && !isVarargsCall ) { - return base+".call("+evalParamList(e.parameters)+")"; - } else { - String coerce = e.numReturns==1? ".arg1()": ""; - switch ( n ) { - case 0: - return base+".invoke()"+coerce; - case 1: - case 2: - case 3: - return base+".invoke("+evalParamList(e.parameters)+")"+coerce; - default: - if ( isVarargsCall ) { - LSExpression last = e.parameters.remove(n-1); - return base+".invoke(new LuaValue[]{"+evalParamList(e.parameters)+"},"+eval(last)+")"+coerce; - } else { - return base+".invoke(new LuaValue[]{"+evalParamList(e.parameters)+"})"+coerce; - } - } - } - } - - private String evalCallMeth(CallMethod e) { - int n = e.parameters.size(); - String base = eval(e.variable); - if ( n <= 3 && e.numReturns == 0 || e.numReturns == 1 ) { - return base+".method(\""+e.method+"\""+(e.parameters.size()>0? ",": "")+evalParamList(e.parameters)+")"; - } else { - return base+".invokemethod(\""+e.method+"\",new LuaValue[]{"+evalParamList(e.parameters)+"})"; - } - } - - private String evalVarargs(VarargsRef e) { - switch ( e.numReturns ) { - case 0: return "NIL"; - case 1: return "$args.arg1()"; - default: return "$args"; - } - } - - private String evalParamList(List parameters) { - if ( parameters == null || parameters.size() == 0 ) - return ""; - StringBuffer p = new StringBuffer(); - for ( int i=0, n=parameters.size(); i0) p.append(","); - p.append( eval( parameters.get(i) ) ); - } - return p.toString(); - } - - - //------------------------------------------- - // write individual strings and lines - //------------------------------------------- - - - private void writeindent() { - for ( int i=0; i C) then pc++ */ + builder.loadLocal( pc, a ); + builder.toBoolean(); + builder.addBranch(pc, (c!=0? JavaBuilder.BRANCH_IFEQ: JavaBuilder.BRANCH_IFNE), pc+2); + break; + + case Lua.OP_TESTSET: /* A B C if (R(B) <=> C) then R(A):= R(B) else pc++ */ + builder.loadLocal( pc, b ); + builder.toBoolean(); + builder.addBranch(pc, (c!=0? JavaBuilder.BRANCH_IFEQ: JavaBuilder.BRANCH_IFNE), pc+2); + builder.loadLocal( pc, b ); + builder.storeLocal( pc, a ); + break; + + case Lua.OP_CALL: /* A B C R(A), ... ,R(A+C-2):= R(A)(R(A+1), ... ,R(A+B-1)) */ + + // load function + builder.loadLocal(pc, a); + + // load args + int narg = b - 1; + switch ( narg ) { + case 0: case 1: case 2: case 3: + for ( int i=1; i 3 + builder.newVarargs( pc, a+1, b-1 ); + narg = -1; + break; + case -1: // prev vararg result + loadVarargResults( builder, pc, a+1, vresultbase ); + narg = -1; + break; + } + + // call or invoke + boolean useinvoke = narg<0 || c<1 || c>2; + if ( useinvoke ) + builder.invoke(narg); + else + builder.call(narg); + + // handle results + switch ( c ) { + case 1: + builder.pop(); + break; + case 2: + if ( useinvoke ) + builder.arg( 1 ); + builder.storeLocal(pc, a); + break; + default: // fixed result count - unpack args + for ( int i=1; i 1 + builder.newVarargs( pc, a+1, b-1 ); + break; + case 0: // prev vararg result + loadVarargResults( builder, pc, a+1, vresultbase ); + break; + } + builder.newTailcallVarargs(); + builder.areturn(); + break; + + case Lua.OP_RETURN: /* A B return R(A), ... ,R(A+B-2) (see note) */ + if ( c == 1 ) + break; + switch ( b ) { + case 0: loadVarargResults( builder, pc, a, vresultbase ); break; + case 1: builder.loadNone(); break; + case 2: builder.loadLocal(pc, a); break; + default: builder.newVarargs(pc, a, b-1); break; + } + builder.areturn(); + break; + + case Lua.OP_FORPREP: /* A sBx R(A)-=R(A+2): pc+=sBx */ + builder.loadLocal(pc, a); + builder.loadLocal(pc, a+2); + builder.binaryop( Lua.OP_SUB ); + builder.storeLocal(pc, a); + builder.addBranch(pc, JavaBuilder.BRANCH_GOTO, pc+1+sbx); + break; + + case Lua.OP_FORLOOP: /* A sBx R(A)+=R(A+2): if R(A) 0 ) { + builder.setlistStack( pc, a+1, index0, nstack ); + index0 += nstack; + } + builder.setlistVarargs( index0, vresultbase ); + } else { + builder.setlistStack( pc, a+1, index0, b ); + builder.pop(); + } + break; + + case Lua.OP_CLOSE: /* A close all variables in the stack up to (>=) R(A)*/ + break; + + case Lua.OP_CLOSURE: /* A Bx R(A):= closure(KPROTO[Bx], R(A), ... ,R(A+n)) */ + { + Prototype newp = p.p[bx]; + String protoname = closureName(classname, bx); + int nup = newp.nups; + builder.closureCreate( protoname ); + if ( nup > 0 ) + builder.dup(); + builder.storeLocal( pc, a ); + if ( nup > 0 ) { + for ( int up=0; up unloaded = new HashMap(); + + public JavaLoader( LuaValue env ) { + this.env = env; + } + + public LuaValue load( InputStream is, String classname, String filename ) throws IOException { + Prototype p = LuaC.compile(is, classname); + return load( p, classname, filename ); + } + + public LuaValue load( Prototype p, String classname, String filename ) { + JavaGen jg = new JavaGen( p, classname, filename ); + return load( jg ); + } + + public LuaValue load( JavaGen jg ) { + include( jg ); + return load( jg.classname ); + } + + public LuaValue load(String classname) { + try { + Class c = loadClass( classname ); + LuaValue v = (LuaValue) c.newInstance(); + v.setfenv(env); + return v; + } catch ( Exception e ) { + e.printStackTrace(); + throw new IllegalStateException("bad class gen: "+e); + } + } + + public void include( JavaGen jg ) { + unloaded.put( jg.classname, jg.bytecode ); + for ( int i=0; i dest = Arrays.asList(new File[] { new File("bin") }); - StandardJavaFileManager fm = compiler.getStandardFileManager( null, null, null); - fm.setLocation(StandardLocation.CLASS_OUTPUT, dest); - - // compile the file - Iterable compilationUnits = fm.getJavaFileObjects(source); - CompilationTask task = compiler.getTask(null, fm, null, null, null, compilationUnits); - boolean success = task.call(); - - // instantiate, config and return - if (success) { - // compile sub-prototypes -// if ( p.p != null ) { -// for ( int i=0, n=p.p.length; i 0 ) sb.append( "\n" ); + byte[] s = slots[i]; + for ( int j=s.length; --j>=0; ) { + if ( s[j] == 0 ) + s[j] = ' '; + } + sb.append( i>0 && branchdest[i]? "D": " " ); + sb.append( new String(s) ); + } + return sb.toString(); + } + + private void markassignments( Prototype p ) { + // mark initial assignments and references + int j=0; + for ( ; j C) then pc++ */ + s[a] = REFER; + branchdest[index+2] = true; + break; + + case Lua.OP_TESTSET: /* A B C if (R(B) <=> C) then R(A):= R(B) else pc++ */ + s[a] = REFER; + s[b] = REFER; + branchdest[index+2] = true; + break; + + case Lua.OP_CALL: /* A B C R(A), ... ,R(A+C-2):= R(A)(R(A+1), ... ,R(A+B-1)) */ + while ( a < c-1 || a < b ) + s[a++] = (byte) (a=) R(A)*/ + while ( aassign) + slots[index--][j] = UPVAL_USE; + } + + private void promoteUpvalueAfter(byte[] s, int index, int j) { + int end = nextUndefined(index,j); + int access = lastAccessBefore(end,index,j); + while ( index<=access ) + slots[index++][j] = UPVAL_USE; + } + + private int prevUndefined(int index, int j) { + while ( index>0 && slots[index][j] != INVALID ) + --index; + return index; + } + + private int firstAssignAfter(int index, int limit, int j) { + for ( ; indexlimit; --index ) { + switch (slots[index][j]) { + case ASSIGN: + case REFER_ASSIGN: + case REFER: + return index; + case UPVAL_CREATE: + case UPVAL_USE: + throw new IllegalStateException("overlapping upvalues"); + } + } + return index; + } + +} diff --git a/src/jse/org/luaj/vm2/luajc/antlr/AntlrLuaJCompiler.java b/src/jse/org/luaj/vm2/luajc/antlr/AntlrLuaJCompiler.java deleted file mode 100644 index fbaea0fe..00000000 --- a/src/jse/org/luaj/vm2/luajc/antlr/AntlrLuaJCompiler.java +++ /dev/null @@ -1,60 +0,0 @@ -/******************************************************************************* -* Copyright (c) 2009 Luaj.org. All rights reserved. -* -* Permission is hereby granted, free of charge, to any person obtaining a copy -* of this software and associated documentation files (the "Software"), to deal -* in the Software without restriction, including without limitation the rights -* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -* copies of the Software, and to permit persons to whom the Software is -* furnished to do so, subject to the following conditions: -* -* The above copyright notice and this permission notice shall be included in -* all copies or substantial portions of the Software. -* -* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -* THE SOFTWARE. -******************************************************************************/ -package org.luaj.vm2.luajc.antlr; - -import java.io.IOException; -import java.io.InputStream; - -import org.antlr.runtime.ANTLRInputStream; -import org.antlr.runtime.CommonTokenStream; -import org.antlr.runtime.RecognitionException; -import org.luaj.vm2.luajc.JavaCodeGenerator; -import org.luaj.vm2.luajc.antlr.LuaLexer; -import org.luaj.vm2.luajc.antlr.LuaParser; -import org.luaj.vm2.luajc.lst.LSChunk; - -/** - * Implementation of lua-to-java compiler using antlr - */ -public class AntlrLuaJCompiler { - - private final String chunkname; - - public AntlrLuaJCompiler(String chunkname) { - this.chunkname = chunkname; - } - - public static String compile(InputStream script, String chunkname) throws RecognitionException, IOException { - return new AntlrLuaJCompiler(chunkname).docompile( script ); - } - - private String docompile(InputStream script) throws RecognitionException, IOException { - - ANTLRInputStream input = new ANTLRInputStream(script); - LuaLexer lexer = new LuaLexer(input); - CommonTokenStream tokens = new CommonTokenStream(lexer); - LuaParser parser = new LuaParser(tokens); - LSChunk chunk = parser.chunk(chunkname); - return new JavaCodeGenerator().toJava( chunk ); - } - -} diff --git a/src/jse/org/luaj/vm2/luajc/antlr/Lua.g b/src/jse/org/luaj/vm2/luajc/antlr/Lua.g deleted file mode 100644 index 3a4e52a3..00000000 --- a/src/jse/org/luaj/vm2/luajc/antlr/Lua.g +++ /dev/null @@ -1,301 +0,0 @@ -/* - * Lua 5.1 grammar producing typed parse tree. - * - * Adapted from the grammar produced by Nicolai Mainiero, May 2007 - * - * see http://www.antlr.org/grammar/list - */ - -grammar Lua; - -options { - backtrack=true; -} - -@header { - package org.luaj.vm2.luajc.antlr; - import org.luaj.vm2.luajc.lst.*; -} -@lexer::header { - package org.luaj.vm2.luajc.antlr; -} -@members { - LSChunk CHK = null; -} - -chunk [String chunkname] returns [LSChunk c] - @init { CHK = new LSChunk(chunkname); } - : funcblock[CHK.function] {$c=CHK;} - ; - -funcblock [LSFunction f] - scope { LSFunction func; } - @init { $funcblock::func = $f; } - : {CHK.pushScope("body");} block {$f.setStatements($block.stats); CHK.popScope("body"); } - ; - -block returns [List stats] - @init { $stats = new ArrayList(); } - : (stat {$stats.add($stat.s);} (';')?)* - (laststat {$stats.add($laststat.s);} (';')?)? - ; - -stat returns [LSStatement s] - @init { Name name=null; List names=null; } - : varlist1 '=' explist1 { $s=LSStatement.varAssignStatement($varlist1.vars,$explist1.exprs, CHK.peekScope(), $funcblock::func); } - | functioncall { $s=LSStatement.functionCallStatement($functioncall.v); } - | 'do' {CHK.pushScope("do");} block {CHK.popScope("do");} 'end' - { $s=LSStatement.doBlockStatement($block.stats); } - | 'while' exp 'do' {CHK.pushScope("while");} block {CHK.popScope("while");} 'end' - { $s=LSStatement.whileLoopStatement($exp.e,$block.stats); } - | 'repeat' {CHK.pushScope("repeat");} block {CHK.popScope("repeat");} 'until' exp - { $s=LSStatement.repeatUntilStatement($block.stats,$exp.e); } - | ifstat { $s=$ifstat.s; } - | 'for' {CHK.pushScope("fori");} NAME {name=CHK.declare($NAME.text);} '=' e1=exp ',' e2=exp (',' e3=exp)? 'do' {CHK.pushScope("foriblock");} block {CHK.popScope("foriblock");} 'end' - { $s=LSStatement.forLoopStatement(name,$e1.e,$e2.e,$e3.e,$block.stats,CHK.peekScope()); CHK.popScope("fori"); } - | 'for' {CHK.pushScope("for");} namelist {names=CHK.declare($namelist.names);} 'in' explist1 'do' {CHK.pushScope("forblock");} block {CHK.popScope("forblock");}'end' - { $s=LSStatement.forListStatement(names,$explist1.exprs,$block.stats,CHK.peekScope(), $funcblock::func); CHK.popScope("for");} - | 'function' funcname funcbody { $s=LSStatement.varFunctionStatement($funcname.v,$funcbody.f); } - | 'local' 'function' NAME {name=CHK.declare($NAME.text);} funcbody - { $s=LSStatement.localFunctionStatement(name,$funcbody.f); } - | 'local' namelist ('=' explist1)? { $s=LSStatement.localAssignStatement(CHK.declare($namelist.names),$explist1.exprs,CHK.peekScope(), $funcblock::func); } - ; - -ifstat returns [LSStatement s] - scope { LSIfStatement current; } - : 'if' e1=exp 'then' {CHK.pushScope("if");} b1=block {$ifstat::current=new LSIfStatement($e1.e,$b1.stats); CHK.popScope("if");} - ('elseif' e2=exp 'then' {CHK.pushScope("elseif");} b2=block {$ifstat::current.addElseif($e2.e,$b2.stats); CHK.popScope("elseif");})* - ('else' {CHK.pushScope("else");} b3=block {$ifstat::current.addElse($b3.stats); CHK.popScope("else");})? - 'end' - { $s=$ifstat::current; } - ; - -laststat returns [LSStatement s] - : 'return' (e=explist1)? {$s=LSStatement.returnStatement($funcblock::func,$e.exprs);} - | 'break' {$s=LSStatement.breakStatement();} - ; - -funcname returns [LSVariable v] - : n=NAME {$v = LSVariable.nameVariable(CHK.reference($n.text,$funcblock::func));} - ('.' n2=NAME {$v = $v.fieldVariable($n2.text);})* - (':' n3=NAME {$v = $v.methodVariable($n3.text);})? - ; - -varlist1 returns [List vars] - @init { $vars = new ArrayList(); } - : v1=var {$vars.add($v1.v);} - (',' v2=var {$vars.add($v2.v);})* - ; - -namelist returns [List names] - : n=NAME {$names=new ArrayList(); $names.add($n.text);} - (',' n2=NAME {$names.add($n2.text);})* - ; - -explist1 returns [List exprs] - @init { $exprs = new ArrayList(); } - : (e1=exp ',' {$exprs.add($e1.e);})* - e2=exp {$exprs.add($e2.e);} - ; - -exp returns [LSExpression e] - : ('nil' { $e=LSExpression.ENIL; } - | 'false' { $e=LSExpression.EFALSE; } - | 'true' { $e=LSExpression.ETRUE; } - | number { $e=LSExpression.numberExpression($number.text); } - | string { $e=$string.e; } - | '...' { $e=LSExpression.varargsRef(); $funcblock::func.setUsesVarargs(); } - | function { $e=LSExpression.functionExpression($function.f); } - | prefixexp { $e=$prefixexp.v; } - | tableconstructor { $e=$tableconstructor.e;} - | unop e1=exp { $e=LSExpression.unopExpression($unop.op,$e1.e,CHK.peekScope());} - ) (binop e2=exp { $e=LSExpression.binopExpression($e,$binop.op,$e2.e,CHK.peekScope());})* - ; - -var returns [LSVariable v] - scope { LSVariable current; } - : (n=NAME {$var::current=LSVariable.nameVariable(CHK.reference($n.text,$funcblock::func));} - | '(' exp ')' {$var::current=LSVariable.parenthesesVariable($exp.e);} varSuffix) - varSuffix* - {$v=$var::current;} - ; - -varSuffix - : (n=nameAndArgs[$var::current] {$var::current=$n.v;})* - ('[' e=exp ']' {$var::current=$var::current.indexVariable($e.e);} - | '.' n2=NAME {$var::current=$var::current.fieldVariable($n2.text);} - ) - ; - -prefixexp returns [LSVariable v] - scope { LSVariable current; } - : e=varOrExp {$prefixexp::current=$e.v;} - (n=nameAndArgs[$prefixexp::current] {$prefixexp::current=$n.v;})* - {$v=$prefixexp::current;} - ; - -functioncall returns [LSVariable v] - scope { LSVariable current; } - : e=varOrExp {$functioncall::current=$e.v;} - (n=nameAndArgs[$functioncall::current] {$functioncall::current=$n.v;})+ - {$v=$functioncall::current;} - ; - -varOrExp returns [LSVariable v] - : var {$v=$var.v;} - | '(' exp ')' {$v=LSVariable.parenthesesVariable($exp.e);} - ; - -nameAndArgs [LSVariable vin] returns [LSVariable v] - @init { String method=null; } - : (':' n=NAME {method=$n.text;})? - a=args {$v=((method==null)? - $vin.callFuncVariable($a.exprs): - $vin.callMethVariable(method,$a.exprs));} - ; - -args returns [List exprs] - @init { $exprs = new ArrayList(); } - : '(' (e=explist1 {$exprs=$e.exprs;})? ')' - | t=tableconstructor {$exprs.add($t.e);} - | s=string {$exprs.add($s.e);} - ; - -function returns [LSFunction f] - : 'function' b=funcbody {$f = $b.f;} - ; - -funcbody returns [LSFunction f] - @init { - $f = new LSFunction(); - $funcblock::func.functions.add($f); - } - : {CHK.pushScope("func",true);} '(' (parlist1 [f])? ')' funcblock[f] 'end' {CHK.popScope("func");} - ; - -parlist1 [LSFunction f] - : namelist {f.setParameterNames(CHK.declare($namelist.names));} (',' '...' {f.isvararg=true;})? - | '...' {f.isvararg=true;} - ; - -tableconstructor returns [LSExpression e] - @init { List fields = new ArrayList(); } - : '{' (fieldlist[fields])? '}' {$e=LSExpression.tableConstructorExpression(fields);} - ; - -fieldlist [List fields] - : field [fields] (fieldsep field [fields])* (fieldsep)? - ; - -field [List fields] - : '[' k=exp ']' '=' e=exp {$fields.add(LSField.keyValueField($k.e,$e.e));} - | n=NAME '=' e=exp {$fields.add(LSField.nameValueField($n.text,$e.e));} - | e=exp {$fields.add(LSField.valueField($e.e));} - ; - -fieldsep - : ',' - | ';' - ; - -binop returns [BinOp op] - : '+' {$op=BinOp.ADD;} - | '-' {$op=BinOp.SUB;} - | '*' {$op=BinOp.MUL;} - | '/' {$op=BinOp.DIV;} - | '^' {$op=BinOp.POW;} - | '%' {$op=BinOp.MOD;} - | '..' {$op=BinOp.CONCAT;} - | '<' {$op=BinOp.LT;} - | '<=' {$op=BinOp.LTEQ;} - | '>' {$op=BinOp.GT;} - | '>=' {$op=BinOp.GTEQ;} - | '==' {$op=BinOp.EQ;} - | '~=' {$op=BinOp.NEQ;} - | 'and' {$op=BinOp.AND; $funcblock::func.hasandlogic=true;} - | 'or' {$op=BinOp.OR; $funcblock::func.hasorlogic=true;} - ; - -unop returns [UnOp op] - : '-' {$op=UnOp.NEG;} - | 'not' {$op=UnOp.NOT;} - | '#' {$op=UnOp.LEN;} - ; - -number - : ('-')? INT - | ('-')? FLOAT1 - | ('-')? FLOAT2 - | ('-')? FLOAT3 - | ('-')? EXP - | HEX - ; - -string returns [LSExpression e] - : NORMALSTRING {$e=LSExpression.normalStringExpression($NORMALSTRING.text);} - | CHARSTRING {$e=LSExpression.charStringExpression($CHARSTRING.text);} - | LONGSTRING {$e=LSExpression.longStringExpression($LONGSTRING.text);} - ; - - -// LEXER - - -NAME :('a'..'z'|'A'..'Z'|'_')(options{greedy=true;}: 'a'..'z'|'A'..'Z'|'_'|'0'..'9')* - ; - -INT : ('0'..'9')+; - -FLOAT1 :'.' INT ; - -FLOAT2 :INT '.' ; - -FLOAT3 :INT '.' INT ; - -EXP : (INT | FLOAT1 | FLOAT2 | FLOAT3) ('E'|'e') ('-'|'+')? INT; - -HEX :'0' ('x' | 'X') ('0'..'9'| 'a'..'f' | 'A'..'F')+ ; - - - -NORMALSTRING - : '"' ( EscapeSequence | ~('\\'|'"') )* '"' - ; - -CHARSTRING - : '\'' ( EscapeSequence | ~('\\'|'\'') )* '\'' - ; - -LONGSTRING - : '['('=')*'[' ( EscapeSequence | ~('\\'|']') )* ']'('=')*']' - ; - -fragment -EscapeSequence - : '\\' ('a'|'b'|'f'|'n'|'r'|'t'|'v'|'\"'|'\''|'\\'|'\n') - | DecimalEscape - ; - -fragment -DecimalEscape - : '\\' ('0'..'9') (('0'..'9') ('0'..'9')?)? - ; - - -COMMENT - : '--[[' ( options {greedy=false;} : . )* '--]]' {skip();} - | '--[=[' ( options {greedy=false;} : . )* '--]==]' {skip();} - | '--[==[' ( options {greedy=false;} : . )* '--]==]' {skip();} - | '--[===[' ( options {greedy=false;} : . )* '--]===]' {skip();} - ; - -LINE_COMMENT - : '--' ~('\n'|'\r')* '\r'? '\n' {skip();} - ; - - -WS : (' '|'\t'|'\u000C') {skip();} - ; - -NEWLINE : ('\r')? '\n' {skip();} - ; diff --git a/src/jse/org/luaj/vm2/luajc/antlr/Lua.tokens b/src/jse/org/luaj/vm2/luajc/antlr/Lua.tokens deleted file mode 100644 index 4b8d63cd..00000000 --- a/src/jse/org/luaj/vm2/luajc/antlr/Lua.tokens +++ /dev/null @@ -1,110 +0,0 @@ -T__66=66 -T__64=64 -T__29=29 -T__65=65 -T__28=28 -T__62=62 -T__27=27 -T__63=63 -T__26=26 -T__25=25 -T__24=24 -T__23=23 -T__22=22 -T__21=21 -T__20=20 -T__61=61 -T__60=60 -FLOAT3=8 -FLOAT2=7 -FLOAT1=6 -T__55=55 -T__56=56 -T__57=57 -NAME=4 -T__58=58 -T__51=51 -T__52=52 -T__53=53 -T__54=54 -EXP=9 -HEX=10 -T__59=59 -DecimalEscape=15 -COMMENT=16 -T__50=50 -T__42=42 -T__43=43 -T__40=40 -T__41=41 -T__46=46 -T__47=47 -T__44=44 -T__45=45 -LINE_COMMENT=17 -T__48=48 -T__49=49 -CHARSTRING=12 -INT=5 -LONGSTRING=13 -T__30=30 -NORMALSTRING=11 -T__31=31 -T__32=32 -WS=18 -T__33=33 -T__34=34 -NEWLINE=19 -T__35=35 -T__36=36 -T__37=37 -T__38=38 -T__39=39 -EscapeSequence=14 -'..'=56 -'end'=23 -'#'=66 -'>='=60 -'=='=61 -'/'=53 -'then'=33 -'>'=59 -'repeat'=25 -';'=20 -'='=21 -'return'=36 -'for'=27 -'+'=50 -')'=45 -'function'=30 -'.'=38 -'^'=54 -'%'=55 -'do'=22 -'elseif'=34 -'true'=42 -'}'=49 -'else'=35 -'and'=63 -'break'=37 -'{'=48 -'...'=43 -'~='=62 -'nil'=40 -'until'=26 -'<='=58 -'false'=41 -'<'=57 -'if'=32 -'not'=65 -':'=39 -'('=44 -'or'=64 -'*'=52 -'-'=51 -'['=46 -'while'=24 -'local'=31 -','=28 -'in'=29 -']'=47 diff --git a/src/jse/org/luaj/vm2/luajc/antlr/LuaLexer.java b/src/jse/org/luaj/vm2/luajc/antlr/LuaLexer.java deleted file mode 100644 index 66825aef..00000000 --- a/src/jse/org/luaj/vm2/luajc/antlr/LuaLexer.java +++ /dev/null @@ -1,3814 +0,0 @@ -// $ANTLR 3.1.3 Mar 17, 2009 19:23:44 Lua.g 2009-10-19 10:13:34 - - package org.luaj.vm2.luajc.antlr; - - -import org.antlr.runtime.*; -import java.util.Stack; -import java.util.List; -import java.util.ArrayList; - -public class LuaLexer extends Lexer { - public static final int T__66=66; - public static final int T__64=64; - public static final int T__29=29; - public static final int T__28=28; - public static final int T__65=65; - public static final int T__27=27; - public static final int T__62=62; - public static final int T__26=26; - public static final int T__63=63; - public static final int T__25=25; - public static final int T__24=24; - public static final int T__23=23; - public static final int T__22=22; - public static final int T__21=21; - public static final int T__20=20; - public static final int T__61=61; - public static final int EOF=-1; - public static final int T__60=60; - public static final int FLOAT3=8; - public static final int FLOAT2=7; - public static final int FLOAT1=6; - public static final int T__55=55; - public static final int T__56=56; - public static final int T__57=57; - public static final int NAME=4; - public static final int T__58=58; - public static final int T__51=51; - public static final int T__52=52; - public static final int T__53=53; - public static final int T__54=54; - public static final int EXP=9; - public static final int HEX=10; - public static final int T__59=59; - public static final int DecimalEscape=15; - public static final int COMMENT=16; - public static final int T__50=50; - public static final int T__42=42; - public static final int T__43=43; - public static final int T__40=40; - public static final int T__41=41; - public static final int T__46=46; - public static final int T__47=47; - public static final int T__44=44; - public static final int T__45=45; - public static final int LINE_COMMENT=17; - public static final int T__48=48; - public static final int T__49=49; - public static final int INT=5; - public static final int CHARSTRING=12; - public static final int LONGSTRING=13; - public static final int T__30=30; - public static final int T__31=31; - public static final int NORMALSTRING=11; - public static final int T__32=32; - public static final int T__33=33; - public static final int WS=18; - public static final int T__34=34; - public static final int T__35=35; - public static final int NEWLINE=19; - public static final int T__36=36; - public static final int T__37=37; - public static final int T__38=38; - public static final int T__39=39; - public static final int EscapeSequence=14; - - // delegates - // delegators - - public LuaLexer() {;} - public LuaLexer(CharStream input) { - this(input, new RecognizerSharedState()); - } - public LuaLexer(CharStream input, RecognizerSharedState state) { - super(input,state); - - } - public String getGrammarFileName() { return "Lua.g"; } - - // $ANTLR start "T__20" - public final void mT__20() throws RecognitionException { - try { - int _type = T__20; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:7:7: ( ';' ) - // Lua.g:7:9: ';' - { - match(';'); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__20" - - // $ANTLR start "T__21" - public final void mT__21() throws RecognitionException { - try { - int _type = T__21; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:8:7: ( '=' ) - // Lua.g:8:9: '=' - { - match('='); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__21" - - // $ANTLR start "T__22" - public final void mT__22() throws RecognitionException { - try { - int _type = T__22; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:9:7: ( 'do' ) - // Lua.g:9:9: 'do' - { - match("do"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__22" - - // $ANTLR start "T__23" - public final void mT__23() throws RecognitionException { - try { - int _type = T__23; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:10:7: ( 'end' ) - // Lua.g:10:9: 'end' - { - match("end"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__23" - - // $ANTLR start "T__24" - public final void mT__24() throws RecognitionException { - try { - int _type = T__24; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:11:7: ( 'while' ) - // Lua.g:11:9: 'while' - { - match("while"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__24" - - // $ANTLR start "T__25" - public final void mT__25() throws RecognitionException { - try { - int _type = T__25; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:12:7: ( 'repeat' ) - // Lua.g:12:9: 'repeat' - { - match("repeat"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__25" - - // $ANTLR start "T__26" - public final void mT__26() throws RecognitionException { - try { - int _type = T__26; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:13:7: ( 'until' ) - // Lua.g:13:9: 'until' - { - match("until"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__26" - - // $ANTLR start "T__27" - public final void mT__27() throws RecognitionException { - try { - int _type = T__27; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:14:7: ( 'for' ) - // Lua.g:14:9: 'for' - { - match("for"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__27" - - // $ANTLR start "T__28" - public final void mT__28() throws RecognitionException { - try { - int _type = T__28; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:15:7: ( ',' ) - // Lua.g:15:9: ',' - { - match(','); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__28" - - // $ANTLR start "T__29" - public final void mT__29() throws RecognitionException { - try { - int _type = T__29; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:16:7: ( 'in' ) - // Lua.g:16:9: 'in' - { - match("in"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__29" - - // $ANTLR start "T__30" - public final void mT__30() throws RecognitionException { - try { - int _type = T__30; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:17:7: ( 'function' ) - // Lua.g:17:9: 'function' - { - match("function"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__30" - - // $ANTLR start "T__31" - public final void mT__31() throws RecognitionException { - try { - int _type = T__31; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:18:7: ( 'local' ) - // Lua.g:18:9: 'local' - { - match("local"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__31" - - // $ANTLR start "T__32" - public final void mT__32() throws RecognitionException { - try { - int _type = T__32; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:19:7: ( 'if' ) - // Lua.g:19:9: 'if' - { - match("if"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__32" - - // $ANTLR start "T__33" - public final void mT__33() throws RecognitionException { - try { - int _type = T__33; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:20:7: ( 'then' ) - // Lua.g:20:9: 'then' - { - match("then"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__33" - - // $ANTLR start "T__34" - public final void mT__34() throws RecognitionException { - try { - int _type = T__34; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:21:7: ( 'elseif' ) - // Lua.g:21:9: 'elseif' - { - match("elseif"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__34" - - // $ANTLR start "T__35" - public final void mT__35() throws RecognitionException { - try { - int _type = T__35; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:22:7: ( 'else' ) - // Lua.g:22:9: 'else' - { - match("else"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__35" - - // $ANTLR start "T__36" - public final void mT__36() throws RecognitionException { - try { - int _type = T__36; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:23:7: ( 'return' ) - // Lua.g:23:9: 'return' - { - match("return"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__36" - - // $ANTLR start "T__37" - public final void mT__37() throws RecognitionException { - try { - int _type = T__37; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:24:7: ( 'break' ) - // Lua.g:24:9: 'break' - { - match("break"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__37" - - // $ANTLR start "T__38" - public final void mT__38() throws RecognitionException { - try { - int _type = T__38; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:25:7: ( '.' ) - // Lua.g:25:9: '.' - { - match('.'); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__38" - - // $ANTLR start "T__39" - public final void mT__39() throws RecognitionException { - try { - int _type = T__39; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:26:7: ( ':' ) - // Lua.g:26:9: ':' - { - match(':'); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__39" - - // $ANTLR start "T__40" - public final void mT__40() throws RecognitionException { - try { - int _type = T__40; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:27:7: ( 'nil' ) - // Lua.g:27:9: 'nil' - { - match("nil"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__40" - - // $ANTLR start "T__41" - public final void mT__41() throws RecognitionException { - try { - int _type = T__41; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:28:7: ( 'false' ) - // Lua.g:28:9: 'false' - { - match("false"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__41" - - // $ANTLR start "T__42" - public final void mT__42() throws RecognitionException { - try { - int _type = T__42; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:29:7: ( 'true' ) - // Lua.g:29:9: 'true' - { - match("true"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__42" - - // $ANTLR start "T__43" - public final void mT__43() throws RecognitionException { - try { - int _type = T__43; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:30:7: ( '...' ) - // Lua.g:30:9: '...' - { - match("..."); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__43" - - // $ANTLR start "T__44" - public final void mT__44() throws RecognitionException { - try { - int _type = T__44; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:31:7: ( '(' ) - // Lua.g:31:9: '(' - { - match('('); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__44" - - // $ANTLR start "T__45" - public final void mT__45() throws RecognitionException { - try { - int _type = T__45; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:32:7: ( ')' ) - // Lua.g:32:9: ')' - { - match(')'); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__45" - - // $ANTLR start "T__46" - public final void mT__46() throws RecognitionException { - try { - int _type = T__46; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:33:7: ( '[' ) - // Lua.g:33:9: '[' - { - match('['); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__46" - - // $ANTLR start "T__47" - public final void mT__47() throws RecognitionException { - try { - int _type = T__47; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:34:7: ( ']' ) - // Lua.g:34:9: ']' - { - match(']'); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__47" - - // $ANTLR start "T__48" - public final void mT__48() throws RecognitionException { - try { - int _type = T__48; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:35:7: ( '{' ) - // Lua.g:35:9: '{' - { - match('{'); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__48" - - // $ANTLR start "T__49" - public final void mT__49() throws RecognitionException { - try { - int _type = T__49; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:36:7: ( '}' ) - // Lua.g:36:9: '}' - { - match('}'); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__49" - - // $ANTLR start "T__50" - public final void mT__50() throws RecognitionException { - try { - int _type = T__50; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:37:7: ( '+' ) - // Lua.g:37:9: '+' - { - match('+'); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__50" - - // $ANTLR start "T__51" - public final void mT__51() throws RecognitionException { - try { - int _type = T__51; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:38:7: ( '-' ) - // Lua.g:38:9: '-' - { - match('-'); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__51" - - // $ANTLR start "T__52" - public final void mT__52() throws RecognitionException { - try { - int _type = T__52; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:39:7: ( '*' ) - // Lua.g:39:9: '*' - { - match('*'); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__52" - - // $ANTLR start "T__53" - public final void mT__53() throws RecognitionException { - try { - int _type = T__53; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:40:7: ( '/' ) - // Lua.g:40:9: '/' - { - match('/'); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__53" - - // $ANTLR start "T__54" - public final void mT__54() throws RecognitionException { - try { - int _type = T__54; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:41:7: ( '^' ) - // Lua.g:41:9: '^' - { - match('^'); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__54" - - // $ANTLR start "T__55" - public final void mT__55() throws RecognitionException { - try { - int _type = T__55; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:42:7: ( '%' ) - // Lua.g:42:9: '%' - { - match('%'); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__55" - - // $ANTLR start "T__56" - public final void mT__56() throws RecognitionException { - try { - int _type = T__56; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:43:7: ( '..' ) - // Lua.g:43:9: '..' - { - match(".."); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__56" - - // $ANTLR start "T__57" - public final void mT__57() throws RecognitionException { - try { - int _type = T__57; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:44:7: ( '<' ) - // Lua.g:44:9: '<' - { - match('<'); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__57" - - // $ANTLR start "T__58" - public final void mT__58() throws RecognitionException { - try { - int _type = T__58; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:45:7: ( '<=' ) - // Lua.g:45:9: '<=' - { - match("<="); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__58" - - // $ANTLR start "T__59" - public final void mT__59() throws RecognitionException { - try { - int _type = T__59; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:46:7: ( '>' ) - // Lua.g:46:9: '>' - { - match('>'); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__59" - - // $ANTLR start "T__60" - public final void mT__60() throws RecognitionException { - try { - int _type = T__60; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:47:7: ( '>=' ) - // Lua.g:47:9: '>=' - { - match(">="); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__60" - - // $ANTLR start "T__61" - public final void mT__61() throws RecognitionException { - try { - int _type = T__61; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:48:7: ( '==' ) - // Lua.g:48:9: '==' - { - match("=="); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__61" - - // $ANTLR start "T__62" - public final void mT__62() throws RecognitionException { - try { - int _type = T__62; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:49:7: ( '~=' ) - // Lua.g:49:9: '~=' - { - match("~="); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__62" - - // $ANTLR start "T__63" - public final void mT__63() throws RecognitionException { - try { - int _type = T__63; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:50:7: ( 'and' ) - // Lua.g:50:9: 'and' - { - match("and"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__63" - - // $ANTLR start "T__64" - public final void mT__64() throws RecognitionException { - try { - int _type = T__64; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:51:7: ( 'or' ) - // Lua.g:51:9: 'or' - { - match("or"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__64" - - // $ANTLR start "T__65" - public final void mT__65() throws RecognitionException { - try { - int _type = T__65; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:52:7: ( 'not' ) - // Lua.g:52:9: 'not' - { - match("not"); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__65" - - // $ANTLR start "T__66" - public final void mT__66() throws RecognitionException { - try { - int _type = T__66; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:53:7: ( '#' ) - // Lua.g:53:9: '#' - { - match('#'); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "T__66" - - // $ANTLR start "NAME" - public final void mNAME() throws RecognitionException { - try { - int _type = NAME; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:240:6: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( options {greedy=true; } : 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* ) - // Lua.g:240:7: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( options {greedy=true; } : 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* - { - if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) { - input.consume(); - - } - else { - MismatchedSetException mse = new MismatchedSetException(null,input); - recover(mse); - throw mse;} - - // Lua.g:240:30: ( options {greedy=true; } : 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* - loop1: - do { - int alt1=5; - switch ( input.LA(1) ) { - case 'a': - case 'b': - case 'c': - case 'd': - case 'e': - case 'f': - case 'g': - case 'h': - case 'i': - case 'j': - case 'k': - case 'l': - case 'm': - case 'n': - case 'o': - case 'p': - case 'q': - case 'r': - case 's': - case 't': - case 'u': - case 'v': - case 'w': - case 'x': - case 'y': - case 'z': - { - alt1=1; - } - break; - case 'A': - case 'B': - case 'C': - case 'D': - case 'E': - case 'F': - case 'G': - case 'H': - case 'I': - case 'J': - case 'K': - case 'L': - case 'M': - case 'N': - case 'O': - case 'P': - case 'Q': - case 'R': - case 'S': - case 'T': - case 'U': - case 'V': - case 'W': - case 'X': - case 'Y': - case 'Z': - { - alt1=2; - } - break; - case '_': - { - alt1=3; - } - break; - case '0': - case '1': - case '2': - case '3': - case '4': - case '5': - case '6': - case '7': - case '8': - case '9': - { - alt1=4; - } - break; - - } - - switch (alt1) { - case 1 : - // Lua.g:240:54: 'a' .. 'z' - { - matchRange('a','z'); - - } - break; - case 2 : - // Lua.g:240:63: 'A' .. 'Z' - { - matchRange('A','Z'); - - } - break; - case 3 : - // Lua.g:240:72: '_' - { - match('_'); - - } - break; - case 4 : - // Lua.g:240:76: '0' .. '9' - { - matchRange('0','9'); - - } - break; - - default : - break loop1; - } - } while (true); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "NAME" - - // $ANTLR start "INT" - public final void mINT() throws RecognitionException { - try { - int _type = INT; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:243:5: ( ( '0' .. '9' )+ ) - // Lua.g:243:7: ( '0' .. '9' )+ - { - // Lua.g:243:7: ( '0' .. '9' )+ - int cnt2=0; - loop2: - do { - int alt2=2; - int LA2_0 = input.LA(1); - - if ( ((LA2_0>='0' && LA2_0<='9')) ) { - alt2=1; - } - - - switch (alt2) { - case 1 : - // Lua.g:243:8: '0' .. '9' - { - matchRange('0','9'); - - } - break; - - default : - if ( cnt2 >= 1 ) break loop2; - EarlyExitException eee = - new EarlyExitException(2, input); - throw eee; - } - cnt2++; - } while (true); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "INT" - - // $ANTLR start "FLOAT1" - public final void mFLOAT1() throws RecognitionException { - try { - int _type = FLOAT1; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:245:9: ( '.' INT ) - // Lua.g:245:10: '.' INT - { - match('.'); - mINT(); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "FLOAT1" - - // $ANTLR start "FLOAT2" - public final void mFLOAT2() throws RecognitionException { - try { - int _type = FLOAT2; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:247:9: ( INT '.' ) - // Lua.g:247:10: INT '.' - { - mINT(); - match('.'); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "FLOAT2" - - // $ANTLR start "FLOAT3" - public final void mFLOAT3() throws RecognitionException { - try { - int _type = FLOAT3; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:249:9: ( INT '.' INT ) - // Lua.g:249:10: INT '.' INT - { - mINT(); - match('.'); - mINT(); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "FLOAT3" - - // $ANTLR start "EXP" - public final void mEXP() throws RecognitionException { - try { - int _type = EXP; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:251:5: ( ( INT | FLOAT1 | FLOAT2 | FLOAT3 ) ( 'E' | 'e' ) ( '-' | '+' )? INT ) - // Lua.g:251:7: ( INT | FLOAT1 | FLOAT2 | FLOAT3 ) ( 'E' | 'e' ) ( '-' | '+' )? INT - { - // Lua.g:251:7: ( INT | FLOAT1 | FLOAT2 | FLOAT3 ) - int alt3=4; - alt3 = dfa3.predict(input); - switch (alt3) { - case 1 : - // Lua.g:251:8: INT - { - mINT(); - - } - break; - case 2 : - // Lua.g:251:14: FLOAT1 - { - mFLOAT1(); - - } - break; - case 3 : - // Lua.g:251:23: FLOAT2 - { - mFLOAT2(); - - } - break; - case 4 : - // Lua.g:251:32: FLOAT3 - { - mFLOAT3(); - - } - break; - - } - - if ( input.LA(1)=='E'||input.LA(1)=='e' ) { - input.consume(); - - } - else { - MismatchedSetException mse = new MismatchedSetException(null,input); - recover(mse); - throw mse;} - - // Lua.g:251:50: ( '-' | '+' )? - int alt4=2; - int LA4_0 = input.LA(1); - - if ( (LA4_0=='+'||LA4_0=='-') ) { - alt4=1; - } - switch (alt4) { - case 1 : - // Lua.g: - { - if ( input.LA(1)=='+'||input.LA(1)=='-' ) { - input.consume(); - - } - else { - MismatchedSetException mse = new MismatchedSetException(null,input); - recover(mse); - throw mse;} - - - } - break; - - } - - mINT(); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "EXP" - - // $ANTLR start "HEX" - public final void mHEX() throws RecognitionException { - try { - int _type = HEX; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:253:5: ( '0' ( 'x' | 'X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+ ) - // Lua.g:253:6: '0' ( 'x' | 'X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+ - { - match('0'); - if ( input.LA(1)=='X'||input.LA(1)=='x' ) { - input.consume(); - - } - else { - MismatchedSetException mse = new MismatchedSetException(null,input); - recover(mse); - throw mse;} - - // Lua.g:253:22: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )+ - int cnt5=0; - loop5: - do { - int alt5=2; - int LA5_0 = input.LA(1); - - if ( ((LA5_0>='0' && LA5_0<='9')||(LA5_0>='A' && LA5_0<='F')||(LA5_0>='a' && LA5_0<='f')) ) { - alt5=1; - } - - - switch (alt5) { - case 1 : - // Lua.g: - { - if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||(input.LA(1)>='a' && input.LA(1)<='f') ) { - input.consume(); - - } - else { - MismatchedSetException mse = new MismatchedSetException(null,input); - recover(mse); - throw mse;} - - - } - break; - - default : - if ( cnt5 >= 1 ) break loop5; - EarlyExitException eee = - new EarlyExitException(5, input); - throw eee; - } - cnt5++; - } while (true); - - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "HEX" - - // $ANTLR start "NORMALSTRING" - public final void mNORMALSTRING() throws RecognitionException { - try { - int _type = NORMALSTRING; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:258:5: ( '\"' ( EscapeSequence | ~ ( '\\\\' | '\"' ) )* '\"' ) - // Lua.g:258:8: '\"' ( EscapeSequence | ~ ( '\\\\' | '\"' ) )* '\"' - { - match('\"'); - // Lua.g:258:12: ( EscapeSequence | ~ ( '\\\\' | '\"' ) )* - loop6: - do { - int alt6=3; - int LA6_0 = input.LA(1); - - if ( (LA6_0=='\\') ) { - alt6=1; - } - else if ( ((LA6_0>='\u0000' && LA6_0<='!')||(LA6_0>='#' && LA6_0<='[')||(LA6_0>=']' && LA6_0<='\uFFFF')) ) { - alt6=2; - } - - - switch (alt6) { - case 1 : - // Lua.g:258:14: EscapeSequence - { - mEscapeSequence(); - - } - break; - case 2 : - // Lua.g:258:31: ~ ( '\\\\' | '\"' ) - { - if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { - input.consume(); - - } - else { - MismatchedSetException mse = new MismatchedSetException(null,input); - recover(mse); - throw mse;} - - - } - break; - - default : - break loop6; - } - } while (true); - - match('\"'); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "NORMALSTRING" - - // $ANTLR start "CHARSTRING" - public final void mCHARSTRING() throws RecognitionException { - try { - int _type = CHARSTRING; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:262:4: ( '\\'' ( EscapeSequence | ~ ( '\\\\' | '\\'' ) )* '\\'' ) - // Lua.g:262:6: '\\'' ( EscapeSequence | ~ ( '\\\\' | '\\'' ) )* '\\'' - { - match('\''); - // Lua.g:262:11: ( EscapeSequence | ~ ( '\\\\' | '\\'' ) )* - loop7: - do { - int alt7=3; - int LA7_0 = input.LA(1); - - if ( (LA7_0=='\\') ) { - alt7=1; - } - else if ( ((LA7_0>='\u0000' && LA7_0<='&')||(LA7_0>='(' && LA7_0<='[')||(LA7_0>=']' && LA7_0<='\uFFFF')) ) { - alt7=2; - } - - - switch (alt7) { - case 1 : - // Lua.g:262:13: EscapeSequence - { - mEscapeSequence(); - - } - break; - case 2 : - // Lua.g:262:30: ~ ( '\\\\' | '\\'' ) - { - if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) { - input.consume(); - - } - else { - MismatchedSetException mse = new MismatchedSetException(null,input); - recover(mse); - throw mse;} - - - } - break; - - default : - break loop7; - } - } while (true); - - match('\''); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "CHARSTRING" - - // $ANTLR start "LONGSTRING" - public final void mLONGSTRING() throws RecognitionException { - try { - int _type = LONGSTRING; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:266:2: ( '[' ( '=' )* '[' ( EscapeSequence | ~ ( '\\\\' | ']' ) )* ']' ( '=' )* ']' ) - // Lua.g:266:4: '[' ( '=' )* '[' ( EscapeSequence | ~ ( '\\\\' | ']' ) )* ']' ( '=' )* ']' - { - match('['); - // Lua.g:266:7: ( '=' )* - loop8: - do { - int alt8=2; - int LA8_0 = input.LA(1); - - if ( (LA8_0=='=') ) { - alt8=1; - } - - - switch (alt8) { - case 1 : - // Lua.g:266:8: '=' - { - match('='); - - } - break; - - default : - break loop8; - } - } while (true); - - match('['); - // Lua.g:266:17: ( EscapeSequence | ~ ( '\\\\' | ']' ) )* - loop9: - do { - int alt9=3; - int LA9_0 = input.LA(1); - - if ( (LA9_0=='\\') ) { - alt9=1; - } - else if ( ((LA9_0>='\u0000' && LA9_0<='[')||(LA9_0>='^' && LA9_0<='\uFFFF')) ) { - alt9=2; - } - - - switch (alt9) { - case 1 : - // Lua.g:266:19: EscapeSequence - { - mEscapeSequence(); - - } - break; - case 2 : - // Lua.g:266:36: ~ ( '\\\\' | ']' ) - { - if ( (input.LA(1)>='\u0000' && input.LA(1)<='[')||(input.LA(1)>='^' && input.LA(1)<='\uFFFF') ) { - input.consume(); - - } - else { - MismatchedSetException mse = new MismatchedSetException(null,input); - recover(mse); - throw mse;} - - - } - break; - - default : - break loop9; - } - } while (true); - - match(']'); - // Lua.g:266:54: ( '=' )* - loop10: - do { - int alt10=2; - int LA10_0 = input.LA(1); - - if ( (LA10_0=='=') ) { - alt10=1; - } - - - switch (alt10) { - case 1 : - // Lua.g:266:55: '=' - { - match('='); - - } - break; - - default : - break loop10; - } - } while (true); - - match(']'); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "LONGSTRING" - - // $ANTLR start "EscapeSequence" - public final void mEscapeSequence() throws RecognitionException { - try { - // Lua.g:271:5: ( '\\\\' ( 'a' | 'b' | 'f' | 'n' | 'r' | 't' | 'v' | '\\\"' | '\\'' | '\\\\' | '\\n' ) | DecimalEscape ) - int alt11=2; - int LA11_0 = input.LA(1); - - if ( (LA11_0=='\\') ) { - int LA11_1 = input.LA(2); - - if ( (LA11_1=='\n'||LA11_1=='\"'||LA11_1=='\''||LA11_1=='\\'||(LA11_1>='a' && LA11_1<='b')||LA11_1=='f'||LA11_1=='n'||LA11_1=='r'||LA11_1=='t'||LA11_1=='v') ) { - alt11=1; - } - else if ( ((LA11_1>='0' && LA11_1<='9')) ) { - alt11=2; - } - else { - NoViableAltException nvae = - new NoViableAltException("", 11, 1, input); - - throw nvae; - } - } - else { - NoViableAltException nvae = - new NoViableAltException("", 11, 0, input); - - throw nvae; - } - switch (alt11) { - case 1 : - // Lua.g:271:9: '\\\\' ( 'a' | 'b' | 'f' | 'n' | 'r' | 't' | 'v' | '\\\"' | '\\'' | '\\\\' | '\\n' ) - { - match('\\'); - if ( input.LA(1)=='\n'||input.LA(1)=='\"'||input.LA(1)=='\''||input.LA(1)=='\\'||(input.LA(1)>='a' && input.LA(1)<='b')||input.LA(1)=='f'||input.LA(1)=='n'||input.LA(1)=='r'||input.LA(1)=='t'||input.LA(1)=='v' ) { - input.consume(); - - } - else { - MismatchedSetException mse = new MismatchedSetException(null,input); - recover(mse); - throw mse;} - - - } - break; - case 2 : - // Lua.g:272:9: DecimalEscape - { - mDecimalEscape(); - - } - break; - - } - } - finally { - } - } - // $ANTLR end "EscapeSequence" - - // $ANTLR start "DecimalEscape" - public final void mDecimalEscape() throws RecognitionException { - try { - // Lua.g:277:5: ( '\\\\' ( '0' .. '9' ) ( ( '0' .. '9' ) ( '0' .. '9' )? )? ) - // Lua.g:277:9: '\\\\' ( '0' .. '9' ) ( ( '0' .. '9' ) ( '0' .. '9' )? )? - { - match('\\'); - // Lua.g:277:14: ( '0' .. '9' ) - // Lua.g:277:15: '0' .. '9' - { - matchRange('0','9'); - - } - - // Lua.g:277:25: ( ( '0' .. '9' ) ( '0' .. '9' )? )? - int alt13=2; - int LA13_0 = input.LA(1); - - if ( ((LA13_0>='0' && LA13_0<='9')) ) { - alt13=1; - } - switch (alt13) { - case 1 : - // Lua.g:277:26: ( '0' .. '9' ) ( '0' .. '9' )? - { - // Lua.g:277:26: ( '0' .. '9' ) - // Lua.g:277:27: '0' .. '9' - { - matchRange('0','9'); - - } - - // Lua.g:277:37: ( '0' .. '9' )? - int alt12=2; - int LA12_0 = input.LA(1); - - if ( ((LA12_0>='0' && LA12_0<='9')) ) { - alt12=1; - } - switch (alt12) { - case 1 : - // Lua.g:277:38: '0' .. '9' - { - matchRange('0','9'); - - } - break; - - } - - - } - break; - - } - - - } - - } - finally { - } - } - // $ANTLR end "DecimalEscape" - - // $ANTLR start "COMMENT" - public final void mCOMMENT() throws RecognitionException { - try { - int _type = COMMENT; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:282:5: ( '--[[' ( options {greedy=false; } : . )* '--]]' | '--[=[' ( options {greedy=false; } : . )* '--]==]' | '--[==[' ( options {greedy=false; } : . )* '--]==]' | '--[===[' ( options {greedy=false; } : . )* '--]===]' ) - int alt18=4; - alt18 = dfa18.predict(input); - switch (alt18) { - case 1 : - // Lua.g:282:9: '--[[' ( options {greedy=false; } : . )* '--]]' - { - match("--[["); - - // Lua.g:282:16: ( options {greedy=false; } : . )* - loop14: - do { - int alt14=2; - int LA14_0 = input.LA(1); - - if ( (LA14_0=='-') ) { - int LA14_1 = input.LA(2); - - if ( (LA14_1=='-') ) { - int LA14_3 = input.LA(3); - - if ( (LA14_3==']') ) { - int LA14_4 = input.LA(4); - - if ( (LA14_4==']') ) { - alt14=2; - } - else if ( ((LA14_4>='\u0000' && LA14_4<='\\')||(LA14_4>='^' && LA14_4<='\uFFFF')) ) { - alt14=1; - } - - - } - else if ( ((LA14_3>='\u0000' && LA14_3<='\\')||(LA14_3>='^' && LA14_3<='\uFFFF')) ) { - alt14=1; - } - - - } - else if ( ((LA14_1>='\u0000' && LA14_1<=',')||(LA14_1>='.' && LA14_1<='\uFFFF')) ) { - alt14=1; - } - - - } - else if ( ((LA14_0>='\u0000' && LA14_0<=',')||(LA14_0>='.' && LA14_0<='\uFFFF')) ) { - alt14=1; - } - - - switch (alt14) { - case 1 : - // Lua.g:282:44: . - { - matchAny(); - - } - break; - - default : - break loop14; - } - } while (true); - - match("--]]"); - - skip(); - - } - break; - case 2 : - // Lua.g:283:9: '--[=[' ( options {greedy=false; } : . )* '--]==]' - { - match("--[=["); - - // Lua.g:283:17: ( options {greedy=false; } : . )* - loop15: - do { - int alt15=2; - int LA15_0 = input.LA(1); - - if ( (LA15_0=='-') ) { - int LA15_1 = input.LA(2); - - if ( (LA15_1=='-') ) { - int LA15_3 = input.LA(3); - - if ( (LA15_3==']') ) { - int LA15_4 = input.LA(4); - - if ( (LA15_4=='=') ) { - int LA15_5 = input.LA(5); - - if ( (LA15_5=='=') ) { - int LA15_6 = input.LA(6); - - if ( (LA15_6==']') ) { - alt15=2; - } - else if ( ((LA15_6>='\u0000' && LA15_6<='\\')||(LA15_6>='^' && LA15_6<='\uFFFF')) ) { - alt15=1; - } - - - } - else if ( ((LA15_5>='\u0000' && LA15_5<='<')||(LA15_5>='>' && LA15_5<='\uFFFF')) ) { - alt15=1; - } - - - } - else if ( ((LA15_4>='\u0000' && LA15_4<='<')||(LA15_4>='>' && LA15_4<='\uFFFF')) ) { - alt15=1; - } - - - } - else if ( ((LA15_3>='\u0000' && LA15_3<='\\')||(LA15_3>='^' && LA15_3<='\uFFFF')) ) { - alt15=1; - } - - - } - else if ( ((LA15_1>='\u0000' && LA15_1<=',')||(LA15_1>='.' && LA15_1<='\uFFFF')) ) { - alt15=1; - } - - - } - else if ( ((LA15_0>='\u0000' && LA15_0<=',')||(LA15_0>='.' && LA15_0<='\uFFFF')) ) { - alt15=1; - } - - - switch (alt15) { - case 1 : - // Lua.g:283:45: . - { - matchAny(); - - } - break; - - default : - break loop15; - } - } while (true); - - match("--]==]"); - - skip(); - - } - break; - case 3 : - // Lua.g:284:9: '--[==[' ( options {greedy=false; } : . )* '--]==]' - { - match("--[==["); - - // Lua.g:284:18: ( options {greedy=false; } : . )* - loop16: - do { - int alt16=2; - int LA16_0 = input.LA(1); - - if ( (LA16_0=='-') ) { - int LA16_1 = input.LA(2); - - if ( (LA16_1=='-') ) { - int LA16_3 = input.LA(3); - - if ( (LA16_3==']') ) { - int LA16_4 = input.LA(4); - - if ( (LA16_4=='=') ) { - int LA16_5 = input.LA(5); - - if ( (LA16_5=='=') ) { - int LA16_6 = input.LA(6); - - if ( (LA16_6==']') ) { - alt16=2; - } - else if ( ((LA16_6>='\u0000' && LA16_6<='\\')||(LA16_6>='^' && LA16_6<='\uFFFF')) ) { - alt16=1; - } - - - } - else if ( ((LA16_5>='\u0000' && LA16_5<='<')||(LA16_5>='>' && LA16_5<='\uFFFF')) ) { - alt16=1; - } - - - } - else if ( ((LA16_4>='\u0000' && LA16_4<='<')||(LA16_4>='>' && LA16_4<='\uFFFF')) ) { - alt16=1; - } - - - } - else if ( ((LA16_3>='\u0000' && LA16_3<='\\')||(LA16_3>='^' && LA16_3<='\uFFFF')) ) { - alt16=1; - } - - - } - else if ( ((LA16_1>='\u0000' && LA16_1<=',')||(LA16_1>='.' && LA16_1<='\uFFFF')) ) { - alt16=1; - } - - - } - else if ( ((LA16_0>='\u0000' && LA16_0<=',')||(LA16_0>='.' && LA16_0<='\uFFFF')) ) { - alt16=1; - } - - - switch (alt16) { - case 1 : - // Lua.g:284:46: . - { - matchAny(); - - } - break; - - default : - break loop16; - } - } while (true); - - match("--]==]"); - - skip(); - - } - break; - case 4 : - // Lua.g:285:9: '--[===[' ( options {greedy=false; } : . )* '--]===]' - { - match("--[===["); - - // Lua.g:285:19: ( options {greedy=false; } : . )* - loop17: - do { - int alt17=2; - int LA17_0 = input.LA(1); - - if ( (LA17_0=='-') ) { - int LA17_1 = input.LA(2); - - if ( (LA17_1=='-') ) { - int LA17_3 = input.LA(3); - - if ( (LA17_3==']') ) { - int LA17_4 = input.LA(4); - - if ( (LA17_4=='=') ) { - int LA17_5 = input.LA(5); - - if ( (LA17_5=='=') ) { - int LA17_6 = input.LA(6); - - if ( (LA17_6=='=') ) { - int LA17_7 = input.LA(7); - - if ( (LA17_7==']') ) { - alt17=2; - } - else if ( ((LA17_7>='\u0000' && LA17_7<='\\')||(LA17_7>='^' && LA17_7<='\uFFFF')) ) { - alt17=1; - } - - - } - else if ( ((LA17_6>='\u0000' && LA17_6<='<')||(LA17_6>='>' && LA17_6<='\uFFFF')) ) { - alt17=1; - } - - - } - else if ( ((LA17_5>='\u0000' && LA17_5<='<')||(LA17_5>='>' && LA17_5<='\uFFFF')) ) { - alt17=1; - } - - - } - else if ( ((LA17_4>='\u0000' && LA17_4<='<')||(LA17_4>='>' && LA17_4<='\uFFFF')) ) { - alt17=1; - } - - - } - else if ( ((LA17_3>='\u0000' && LA17_3<='\\')||(LA17_3>='^' && LA17_3<='\uFFFF')) ) { - alt17=1; - } - - - } - else if ( ((LA17_1>='\u0000' && LA17_1<=',')||(LA17_1>='.' && LA17_1<='\uFFFF')) ) { - alt17=1; - } - - - } - else if ( ((LA17_0>='\u0000' && LA17_0<=',')||(LA17_0>='.' && LA17_0<='\uFFFF')) ) { - alt17=1; - } - - - switch (alt17) { - case 1 : - // Lua.g:285:47: . - { - matchAny(); - - } - break; - - default : - break loop17; - } - } while (true); - - match("--]===]"); - - skip(); - - } - break; - - } - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "COMMENT" - - // $ANTLR start "LINE_COMMENT" - public final void mLINE_COMMENT() throws RecognitionException { - try { - int _type = LINE_COMMENT; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:289:5: ( '--' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' ) - // Lua.g:289:7: '--' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' - { - match("--"); - - // Lua.g:289:12: (~ ( '\\n' | '\\r' ) )* - loop19: - do { - int alt19=2; - int LA19_0 = input.LA(1); - - if ( ((LA19_0>='\u0000' && LA19_0<='\t')||(LA19_0>='\u000B' && LA19_0<='\f')||(LA19_0>='\u000E' && LA19_0<='\uFFFF')) ) { - alt19=1; - } - - - switch (alt19) { - case 1 : - // Lua.g:289:12: ~ ( '\\n' | '\\r' ) - { - if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) { - input.consume(); - - } - else { - MismatchedSetException mse = new MismatchedSetException(null,input); - recover(mse); - throw mse;} - - - } - break; - - default : - break loop19; - } - } while (true); - - // Lua.g:289:26: ( '\\r' )? - int alt20=2; - int LA20_0 = input.LA(1); - - if ( (LA20_0=='\r') ) { - alt20=1; - } - switch (alt20) { - case 1 : - // Lua.g:289:26: '\\r' - { - match('\r'); - - } - break; - - } - - match('\n'); - skip(); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "LINE_COMMENT" - - // $ANTLR start "WS" - public final void mWS() throws RecognitionException { - try { - int _type = WS; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:293:5: ( ( ' ' | '\\t' | '\\u000C' ) ) - // Lua.g:293:8: ( ' ' | '\\t' | '\\u000C' ) - { - if ( input.LA(1)=='\t'||input.LA(1)=='\f'||input.LA(1)==' ' ) { - input.consume(); - - } - else { - MismatchedSetException mse = new MismatchedSetException(null,input); - recover(mse); - throw mse;} - - skip(); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "WS" - - // $ANTLR start "NEWLINE" - public final void mNEWLINE() throws RecognitionException { - try { - int _type = NEWLINE; - int _channel = DEFAULT_TOKEN_CHANNEL; - // Lua.g:296:9: ( ( '\\r' )? '\\n' ) - // Lua.g:296:11: ( '\\r' )? '\\n' - { - // Lua.g:296:11: ( '\\r' )? - int alt21=2; - int LA21_0 = input.LA(1); - - if ( (LA21_0=='\r') ) { - alt21=1; - } - switch (alt21) { - case 1 : - // Lua.g:296:12: '\\r' - { - match('\r'); - - } - break; - - } - - match('\n'); - skip(); - - } - - state.type = _type; - state.channel = _channel; - } - finally { - } - } - // $ANTLR end "NEWLINE" - - public void mTokens() throws RecognitionException { - // Lua.g:1:8: ( T__20 | T__21 | T__22 | T__23 | T__24 | T__25 | T__26 | T__27 | T__28 | T__29 | T__30 | T__31 | T__32 | T__33 | T__34 | T__35 | T__36 | T__37 | T__38 | T__39 | T__40 | T__41 | T__42 | T__43 | T__44 | T__45 | T__46 | T__47 | T__48 | T__49 | T__50 | T__51 | T__52 | T__53 | T__54 | T__55 | T__56 | T__57 | T__58 | T__59 | T__60 | T__61 | T__62 | T__63 | T__64 | T__65 | T__66 | NAME | INT | FLOAT1 | FLOAT2 | FLOAT3 | EXP | HEX | NORMALSTRING | CHARSTRING | LONGSTRING | COMMENT | LINE_COMMENT | WS | NEWLINE ) - int alt22=61; - alt22 = dfa22.predict(input); - switch (alt22) { - case 1 : - // Lua.g:1:10: T__20 - { - mT__20(); - - } - break; - case 2 : - // Lua.g:1:16: T__21 - { - mT__21(); - - } - break; - case 3 : - // Lua.g:1:22: T__22 - { - mT__22(); - - } - break; - case 4 : - // Lua.g:1:28: T__23 - { - mT__23(); - - } - break; - case 5 : - // Lua.g:1:34: T__24 - { - mT__24(); - - } - break; - case 6 : - // Lua.g:1:40: T__25 - { - mT__25(); - - } - break; - case 7 : - // Lua.g:1:46: T__26 - { - mT__26(); - - } - break; - case 8 : - // Lua.g:1:52: T__27 - { - mT__27(); - - } - break; - case 9 : - // Lua.g:1:58: T__28 - { - mT__28(); - - } - break; - case 10 : - // Lua.g:1:64: T__29 - { - mT__29(); - - } - break; - case 11 : - // Lua.g:1:70: T__30 - { - mT__30(); - - } - break; - case 12 : - // Lua.g:1:76: T__31 - { - mT__31(); - - } - break; - case 13 : - // Lua.g:1:82: T__32 - { - mT__32(); - - } - break; - case 14 : - // Lua.g:1:88: T__33 - { - mT__33(); - - } - break; - case 15 : - // Lua.g:1:94: T__34 - { - mT__34(); - - } - break; - case 16 : - // Lua.g:1:100: T__35 - { - mT__35(); - - } - break; - case 17 : - // Lua.g:1:106: T__36 - { - mT__36(); - - } - break; - case 18 : - // Lua.g:1:112: T__37 - { - mT__37(); - - } - break; - case 19 : - // Lua.g:1:118: T__38 - { - mT__38(); - - } - break; - case 20 : - // Lua.g:1:124: T__39 - { - mT__39(); - - } - break; - case 21 : - // Lua.g:1:130: T__40 - { - mT__40(); - - } - break; - case 22 : - // Lua.g:1:136: T__41 - { - mT__41(); - - } - break; - case 23 : - // Lua.g:1:142: T__42 - { - mT__42(); - - } - break; - case 24 : - // Lua.g:1:148: T__43 - { - mT__43(); - - } - break; - case 25 : - // Lua.g:1:154: T__44 - { - mT__44(); - - } - break; - case 26 : - // Lua.g:1:160: T__45 - { - mT__45(); - - } - break; - case 27 : - // Lua.g:1:166: T__46 - { - mT__46(); - - } - break; - case 28 : - // Lua.g:1:172: T__47 - { - mT__47(); - - } - break; - case 29 : - // Lua.g:1:178: T__48 - { - mT__48(); - - } - break; - case 30 : - // Lua.g:1:184: T__49 - { - mT__49(); - - } - break; - case 31 : - // Lua.g:1:190: T__50 - { - mT__50(); - - } - break; - case 32 : - // Lua.g:1:196: T__51 - { - mT__51(); - - } - break; - case 33 : - // Lua.g:1:202: T__52 - { - mT__52(); - - } - break; - case 34 : - // Lua.g:1:208: T__53 - { - mT__53(); - - } - break; - case 35 : - // Lua.g:1:214: T__54 - { - mT__54(); - - } - break; - case 36 : - // Lua.g:1:220: T__55 - { - mT__55(); - - } - break; - case 37 : - // Lua.g:1:226: T__56 - { - mT__56(); - - } - break; - case 38 : - // Lua.g:1:232: T__57 - { - mT__57(); - - } - break; - case 39 : - // Lua.g:1:238: T__58 - { - mT__58(); - - } - break; - case 40 : - // Lua.g:1:244: T__59 - { - mT__59(); - - } - break; - case 41 : - // Lua.g:1:250: T__60 - { - mT__60(); - - } - break; - case 42 : - // Lua.g:1:256: T__61 - { - mT__61(); - - } - break; - case 43 : - // Lua.g:1:262: T__62 - { - mT__62(); - - } - break; - case 44 : - // Lua.g:1:268: T__63 - { - mT__63(); - - } - break; - case 45 : - // Lua.g:1:274: T__64 - { - mT__64(); - - } - break; - case 46 : - // Lua.g:1:280: T__65 - { - mT__65(); - - } - break; - case 47 : - // Lua.g:1:286: T__66 - { - mT__66(); - - } - break; - case 48 : - // Lua.g:1:292: NAME - { - mNAME(); - - } - break; - case 49 : - // Lua.g:1:297: INT - { - mINT(); - - } - break; - case 50 : - // Lua.g:1:301: FLOAT1 - { - mFLOAT1(); - - } - break; - case 51 : - // Lua.g:1:308: FLOAT2 - { - mFLOAT2(); - - } - break; - case 52 : - // Lua.g:1:315: FLOAT3 - { - mFLOAT3(); - - } - break; - case 53 : - // Lua.g:1:322: EXP - { - mEXP(); - - } - break; - case 54 : - // Lua.g:1:326: HEX - { - mHEX(); - - } - break; - case 55 : - // Lua.g:1:330: NORMALSTRING - { - mNORMALSTRING(); - - } - break; - case 56 : - // Lua.g:1:343: CHARSTRING - { - mCHARSTRING(); - - } - break; - case 57 : - // Lua.g:1:354: LONGSTRING - { - mLONGSTRING(); - - } - break; - case 58 : - // Lua.g:1:365: COMMENT - { - mCOMMENT(); - - } - break; - case 59 : - // Lua.g:1:373: LINE_COMMENT - { - mLINE_COMMENT(); - - } - break; - case 60 : - // Lua.g:1:386: WS - { - mWS(); - - } - break; - case 61 : - // Lua.g:1:389: NEWLINE - { - mNEWLINE(); - - } - break; - - } - - } - - - protected DFA3 dfa3 = new DFA3(this); - protected DFA18 dfa18 = new DFA18(this); - protected DFA22 dfa22 = new DFA22(this); - static final String DFA3_eotS = - "\7\uffff"; - static final String DFA3_eofS = - "\7\uffff"; - static final String DFA3_minS = - "\2\56\2\uffff\1\60\2\uffff"; - static final String DFA3_maxS = - "\1\71\1\145\2\uffff\1\145\2\uffff"; - static final String DFA3_acceptS = - "\2\uffff\1\2\1\1\1\uffff\1\4\1\3"; - static final String DFA3_specialS = - "\7\uffff}>"; - static final String[] DFA3_transitionS = { - "\1\2\1\uffff\12\1", - "\1\4\1\uffff\12\1\13\uffff\1\3\37\uffff\1\3", - "", - "", - "\12\5\13\uffff\1\6\37\uffff\1\6", - "", - "" - }; - - static final short[] DFA3_eot = DFA.unpackEncodedString(DFA3_eotS); - static final short[] DFA3_eof = DFA.unpackEncodedString(DFA3_eofS); - static final char[] DFA3_min = DFA.unpackEncodedStringToUnsignedChars(DFA3_minS); - static final char[] DFA3_max = DFA.unpackEncodedStringToUnsignedChars(DFA3_maxS); - static final short[] DFA3_accept = DFA.unpackEncodedString(DFA3_acceptS); - static final short[] DFA3_special = DFA.unpackEncodedString(DFA3_specialS); - static final short[][] DFA3_transition; - - static { - int numStates = DFA3_transitionS.length; - DFA3_transition = new short[numStates][]; - for (int i=0; i"; - static final String[] DFA18_transitionS = { - "\1\1", - "\1\2", - "\1\3", - "\1\5\35\uffff\1\4", - "", - "\1\7\35\uffff\1\6", - "", - "\1\11\35\uffff\1\10", - "", - "" - }; - - static final short[] DFA18_eot = DFA.unpackEncodedString(DFA18_eotS); - static final short[] DFA18_eof = DFA.unpackEncodedString(DFA18_eofS); - static final char[] DFA18_min = DFA.unpackEncodedStringToUnsignedChars(DFA18_minS); - static final char[] DFA18_max = DFA.unpackEncodedStringToUnsignedChars(DFA18_maxS); - static final short[] DFA18_accept = DFA.unpackEncodedString(DFA18_acceptS); - static final short[] DFA18_special = DFA.unpackEncodedString(DFA18_specialS); - static final short[][] DFA18_transition; - - static { - int numStates = DFA18_transitionS.length; - DFA18_transition = new short[numStates][]; - for (int i=0; i"; - static final String[] DFA22_transitionS = { - "\1\50\1\51\1\uffff\1\50\1\51\22\uffff\1\50\1\uffff\1\46\1\42"+ - "\1\uffff\1\34\1\uffff\1\47\1\21\1\22\1\31\1\27\1\11\1\30\1\16"+ - "\1\32\1\44\11\45\1\17\1\1\1\35\1\2\1\36\2\uffff\32\43\1\23\1"+ - "\uffff\1\24\1\33\1\43\1\uffff\1\40\1\15\1\43\1\3\1\4\1\10\2"+ - "\43\1\12\2\43\1\13\1\43\1\20\1\41\2\43\1\6\1\43\1\14\1\7\1\43"+ - "\1\5\3\43\1\25\1\uffff\1\26\1\37", - "", - "\1\52", - "\1\54", - "\1\56\1\uffff\1\55", - "\1\57", - "\1\60", - "\1\61", - "\1\64\15\uffff\1\62\5\uffff\1\63", - "", - "\1\66\7\uffff\1\65", - "\1\67", - "\1\70\11\uffff\1\71", - "\1\72", - "\1\73\1\uffff\12\74", - "", - "\1\76\5\uffff\1\77", - "", - "", - "\1\100\35\uffff\1\100", - "", - "", - "", - "", - "\1\102", - "", - "", - "", - "", - "\1\104", - "\1\106", - "", - "\1\110", - "\1\111", - "", - "", - "\1\114\1\uffff\12\45\13\uffff\1\115\22\uffff\1\112\14\uffff"+ - "\1\115\22\uffff\1\112", - "\1\114\1\uffff\12\45\13\uffff\1\115\37\uffff\1\115", - "", - "", - "", - "", - "", - "", - "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", - "\1\117", - "\1\120", - "\1\121", - "\1\122\3\uffff\1\123", - "\1\124", - "\1\125", - "\1\126", - "\1\127", - "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", - "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", - "\1\132", - "\1\133", - "\1\134", - "\1\135", - "\1\136", - "\12\74\13\uffff\1\115\37\uffff\1\115", - "", - "\1\141", - "\1\142", - "", - "", - "\133\144\1\143\uffa4\144", - "", - "", - "", - "", - "", - "\1\145", - "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", - "", - "", - "\12\147\13\uffff\1\115\37\uffff\1\115", - "", - "", - "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", - "\1\152", - "\1\153", - "\1\154", - "\1\155", - "\1\156", - "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", - "\1\160", - "\1\161", - "", - "", - "\1\162", - "\1\163", - "\1\164", - "\1\165", - "", - "", - "", - "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", - "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", - "\75\144\1\171\35\144\1\170\uffa4\144", - "", - "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", - "", - "\12\147\13\uffff\1\115\37\uffff\1\115", - "", - "", - "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\10\43\1\174\21\43", - "\1\176", - "\1\177", - "\1\u0080", - "\1\u0081", - "", - "\1\u0082", - "\1\u0083", - "\1\u0084", - "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", - "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", - "\1\u0087", - "", - "", - "\12\u008b\1\u008a\2\u008b\1\u0089\37\u008b\1\u0088\uffd2\u008b", - "\75\144\1\u008d\35\144\1\u008c\uffa4\144", - "", - "", - "\1\u008e", - "", - "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", - "\1\u0090", - "\1\u0091", - "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", - "\1\u0093", - "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", - "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", - "", - "", - "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", - "\12\u008b\1\u008a\2\u008b\1\u0089\37\u008b\1\u0097\uffd2\u008b", - "\12\u0098\1\u008a\ufff5\u0098", - "\0\u0098", - "\12\u008b\1\u008a\2\u008b\1\u0089\37\u008b\1\u0088\uffd2\u008b", - "\12\u009c\1\u009b\2\u009c\1\u009a\37\u009c\1\u0099\uffd2\u009c", - "\75\144\1\u009e\35\144\1\u009d\uffa4\144", - "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", - "", - "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", - "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", - "", - "\1\u00a2", - "", - "", - "", - "\12\u008b\1\u008a\2\u008b\1\u0089\37\u008b\1\u0097\57\u008b"+ - "\1\u00a3\uffa2\u008b", - "", - "\12\u009c\1\u009b\2\u009c\1\u009a\37\u009c\1\u00a4\uffd2\u009c", - "\12\u0098\1\u009b\ufff5\u0098", - "\0\u0098", - "\12\u009c\1\u009b\2\u009c\1\u009a\37\u009c\1\u0099\uffd2\u009c", - "\12\u00a8\1\u00a6\2\u00a8\1\u00a5\37\u00a8\1\u00a7\uffd2\u00a8", - "\133\144\1\u00a9\uffa4\144", - "", - "", - "", - "\1\u00aa", - "\12\u008b\1\u008a\2\u008b\1\u0089\37\u008b\1\u0088\57\u008b"+ - "\1\u00ab\uffa2\u008b", - "\12\u009c\1\u009b\2\u009c\1\u009a\37\u009c\1\u00a4\57\u009c"+ - "\1\u00ac\uffa2\u009c", - "\12\u0098\1\u00a6\ufff5\u0098", - "\0\u0098", - "\12\u00a8\1\u00a6\2\u00a8\1\u00a5\37\u00a8\1\u00ad\uffd2\u00a8", - "\12\u00a8\1\u00a6\2\u00a8\1\u00a5\37\u00a8\1\u00a7\uffd2\u00a8", - "\12\u00b1\1\u00af\2\u00b1\1\u00ae\37\u00b1\1\u00b0\uffd2\u00b1", - "\12\43\7\uffff\32\43\4\uffff\1\43\1\uffff\32\43", - "\12\u008b\1\u008a\2\u008b\1\u0089\37\u008b\1\u0088\uffd2\u008b", - "\12\u009c\1\u009b\2\u009c\1\u009a\37\u009c\1\u0099\17\u009c"+ - "\1\u00b3\uffc2\u009c", - "\12\u00a8\1\u00a6\2\u00a8\1\u00a5\37\u00a8\1\u00ad\57\u00a8"+ - "\1\u00b4\uffa2\u00a8", - "\12\u0098\1\u00af\ufff5\u0098", - "\0\u0098", - "\12\u00b1\1\u00af\2\u00b1\1\u00ae\37\u00b1\1\u00b5\uffd2\u00b1", - "\12\u00b1\1\u00af\2\u00b1\1\u00ae\37\u00b1\1\u00b0\uffd2\u00b1", - "", - "\12\u009c\1\u009b\2\u009c\1\u009a\37\u009c\1\u0099\17\u009c"+ - "\1\u00b6\uffc2\u009c", - "\12\u00a8\1\u00a6\2\u00a8\1\u00a5\37\u00a8\1\u00a7\17\u00a8"+ - "\1\u00b7\uffc2\u00a8", - "\12\u00b1\1\u00af\2\u00b1\1\u00ae\37\u00b1\1\u00b5\57\u00b1"+ - "\1\u00b8\uffa2\u00b1", - "\12\u009c\1\u009b\2\u009c\1\u009a\37\u009c\1\u0099\57\u009c"+ - "\1\u00b9\uffa2\u009c", - "\12\u00a8\1\u00a6\2\u00a8\1\u00a5\37\u00a8\1\u00a7\17\u00a8"+ - "\1\u00ba\uffc2\u00a8", - "\12\u00b1\1\u00af\2\u00b1\1\u00ae\37\u00b1\1\u00b0\17\u00b1"+ - "\1\u00bb\uffc2\u00b1", - "\12\u009c\1\u009b\2\u009c\1\u009a\37\u009c\1\u0099\uffd2\u009c", - "\12\u00a8\1\u00a6\2\u00a8\1\u00a5\37\u00a8\1\u00a7\57\u00a8"+ - "\1\u00bc\uffa2\u00a8", - "\12\u00b1\1\u00af\2\u00b1\1\u00ae\37\u00b1\1\u00b0\17\u00b1"+ - "\1\u00bd\uffc2\u00b1", - "\12\u00a8\1\u00a6\2\u00a8\1\u00a5\37\u00a8\1\u00a7\uffd2\u00a8", - "\12\u00b1\1\u00af\2\u00b1\1\u00ae\37\u00b1\1\u00b0\17\u00b1"+ - "\1\u00be\uffc2\u00b1", - "\12\u00b1\1\u00af\2\u00b1\1\u00ae\37\u00b1\1\u00b0\57\u00b1"+ - "\1\u00bf\uffa2\u00b1", - "\12\u00b1\1\u00af\2\u00b1\1\u00ae\37\u00b1\1\u00b0\uffd2\u00b1" - }; - - static final short[] DFA22_eot = DFA.unpackEncodedString(DFA22_eotS); - static final short[] DFA22_eof = DFA.unpackEncodedString(DFA22_eofS); - static final char[] DFA22_min = DFA.unpackEncodedStringToUnsignedChars(DFA22_minS); - static final char[] DFA22_max = DFA.unpackEncodedStringToUnsignedChars(DFA22_maxS); - static final short[] DFA22_accept = DFA.unpackEncodedString(DFA22_acceptS); - static final short[] DFA22_special = DFA.unpackEncodedString(DFA22_specialS); - static final short[][] DFA22_transition; - - static { - int numStates = DFA22_transitionS.length; - DFA22_transition = new short[numStates][]; - for (int i=0; i='\u0000' && LA22_151<='\t')||(LA22_151>='\u000B' && LA22_151<='\f')||(LA22_151>='\u000E' && LA22_151<=',')||(LA22_151>='.' && LA22_151<='\\')||(LA22_151>='^' && LA22_151<='\uFFFF')) ) {s = 139;} - - if ( s>=0 ) return s; - break; - case 1 : - int LA22_158 = input.LA(1); - - s = -1; - if ( (LA22_158=='[') ) {s = 169;} - - else if ( ((LA22_158>='\u0000' && LA22_158<='Z')||(LA22_158>='\\' && LA22_158<='\uFFFF')) ) {s = 100;} - - if ( s>=0 ) return s; - break; - case 2 : - int LA22_141 = input.LA(1); - - s = -1; - if ( (LA22_141=='[') ) {s = 157;} - - else if ( (LA22_141=='=') ) {s = 158;} - - else if ( ((LA22_141>='\u0000' && LA22_141<='<')||(LA22_141>='>' && LA22_141<='Z')||(LA22_141>='\\' && LA22_141<='\uFFFF')) ) {s = 100;} - - if ( s>=0 ) return s; - break; - case 3 : - int LA22_171 = input.LA(1); - - s = -1; - if ( (LA22_171=='-') ) {s = 136;} - - else if ( (LA22_171=='\r') ) {s = 137;} - - else if ( (LA22_171=='\n') ) {s = 138;} - - else if ( ((LA22_171>='\u0000' && LA22_171<='\t')||(LA22_171>='\u000B' && LA22_171<='\f')||(LA22_171>='\u000E' && LA22_171<=',')||(LA22_171>='.' && LA22_171<='\uFFFF')) ) {s = 139;} - - else s = 152; - - if ( s>=0 ) return s; - break; - case 4 : - int LA22_165 = input.LA(1); - - s = -1; - if ( ((LA22_165>='\u0000' && LA22_165<='\t')||(LA22_165>='\u000B' && LA22_165<='\uFFFF')) ) {s = 152;} - - else if ( (LA22_165=='\n') ) {s = 166;} - - if ( s>=0 ) return s; - break; - case 5 : - int LA22_120 = input.LA(1); - - s = -1; - if ( (LA22_120=='-') ) {s = 136;} - - else if ( (LA22_120=='\r') ) {s = 137;} - - else if ( (LA22_120=='\n') ) {s = 138;} - - else if ( ((LA22_120>='\u0000' && LA22_120<='\t')||(LA22_120>='\u000B' && LA22_120<='\f')||(LA22_120>='\u000E' && LA22_120<=',')||(LA22_120>='.' && LA22_120<='\uFFFF')) ) {s = 139;} - - if ( s>=0 ) return s; - break; - case 6 : - int LA22_172 = input.LA(1); - - s = -1; - if ( (LA22_172=='=') ) {s = 179;} - - else if ( (LA22_172=='\r') ) {s = 154;} - - else if ( (LA22_172=='\n') ) {s = 155;} - - else if ( (LA22_172=='-') ) {s = 153;} - - else if ( ((LA22_172>='\u0000' && LA22_172<='\t')||(LA22_172>='\u000B' && LA22_172<='\f')||(LA22_172>='\u000E' && LA22_172<=',')||(LA22_172>='.' && LA22_172<='<')||(LA22_172>='>' && LA22_172<='\uFFFF')) ) {s = 156;} - - if ( s>=0 ) return s; - break; - case 7 : - int LA22_182 = input.LA(1); - - s = -1; - if ( (LA22_182==']') ) {s = 185;} - - else if ( (LA22_182=='\r') ) {s = 154;} - - else if ( (LA22_182=='\n') ) {s = 155;} - - else if ( (LA22_182=='-') ) {s = 153;} - - else if ( ((LA22_182>='\u0000' && LA22_182<='\t')||(LA22_182>='\u000B' && LA22_182<='\f')||(LA22_182>='\u000E' && LA22_182<=',')||(LA22_182>='.' && LA22_182<='\\')||(LA22_182>='^' && LA22_182<='\uFFFF')) ) {s = 156;} - - if ( s>=0 ) return s; - break; - case 8 : - int LA22_179 = input.LA(1); - - s = -1; - if ( (LA22_179=='=') ) {s = 182;} - - else if ( (LA22_179=='-') ) {s = 153;} - - else if ( (LA22_179=='\r') ) {s = 154;} - - else if ( (LA22_179=='\n') ) {s = 155;} - - else if ( ((LA22_179>='\u0000' && LA22_179<='\t')||(LA22_179>='\u000B' && LA22_179<='\f')||(LA22_179>='\u000E' && LA22_179<=',')||(LA22_179>='.' && LA22_179<='<')||(LA22_179>='>' && LA22_179<='\uFFFF')) ) {s = 156;} - - if ( s>=0 ) return s; - break; - case 9 : - int LA22_139 = input.LA(1); - - s = -1; - if ( (LA22_139=='-') ) {s = 136;} - - else if ( (LA22_139=='\r') ) {s = 137;} - - else if ( (LA22_139=='\n') ) {s = 138;} - - else if ( ((LA22_139>='\u0000' && LA22_139<='\t')||(LA22_139>='\u000B' && LA22_139<='\f')||(LA22_139>='\u000E' && LA22_139<=',')||(LA22_139>='.' && LA22_139<='\uFFFF')) ) {s = 139;} - - if ( s>=0 ) return s; - break; - case 10 : - int LA22_153 = input.LA(1); - - s = -1; - if ( (LA22_153=='-') ) {s = 164;} - - else if ( (LA22_153=='\r') ) {s = 154;} - - else if ( (LA22_153=='\n') ) {s = 155;} - - else if ( ((LA22_153>='\u0000' && LA22_153<='\t')||(LA22_153>='\u000B' && LA22_153<='\f')||(LA22_153>='\u000E' && LA22_153<=',')||(LA22_153>='.' && LA22_153<='\uFFFF')) ) {s = 156;} - - if ( s>=0 ) return s; - break; - case 11 : - int LA22_175 = input.LA(1); - - s = -1; - if ( ((LA22_175>='\u0000' && LA22_175<='\uFFFF')) ) {s = 152;} - - else s = 100; - - if ( s>=0 ) return s; - break; - case 12 : - int LA22_163 = input.LA(1); - - s = -1; - if ( (LA22_163==']') ) {s = 171;} - - else if ( (LA22_163=='-') ) {s = 136;} - - else if ( (LA22_163=='\r') ) {s = 137;} - - else if ( (LA22_163=='\n') ) {s = 138;} - - else if ( ((LA22_163>='\u0000' && LA22_163<='\t')||(LA22_163>='\u000B' && LA22_163<='\f')||(LA22_163>='\u000E' && LA22_163<=',')||(LA22_163>='.' && LA22_163<='\\')||(LA22_163>='^' && LA22_163<='\uFFFF')) ) {s = 139;} - - if ( s>=0 ) return s; - break; - case 13 : - int LA22_136 = input.LA(1); - - s = -1; - if ( (LA22_136=='-') ) {s = 151;} - - else if ( (LA22_136=='\r') ) {s = 137;} - - else if ( (LA22_136=='\n') ) {s = 138;} - - else if ( ((LA22_136>='\u0000' && LA22_136<='\t')||(LA22_136>='\u000B' && LA22_136<='\f')||(LA22_136>='\u000E' && LA22_136<=',')||(LA22_136>='.' && LA22_136<='\uFFFF')) ) {s = 139;} - - if ( s>=0 ) return s; - break; - case 14 : - int LA22_154 = input.LA(1); - - s = -1; - if ( ((LA22_154>='\u0000' && LA22_154<='\t')||(LA22_154>='\u000B' && LA22_154<='\uFFFF')) ) {s = 152;} - - else if ( (LA22_154=='\n') ) {s = 155;} - - if ( s>=0 ) return s; - break; - case 15 : - int LA22_191 = input.LA(1); - - s = -1; - if ( (LA22_191=='\r') ) {s = 174;} - - else if ( (LA22_191=='\n') ) {s = 175;} - - else if ( (LA22_191=='-') ) {s = 176;} - - else if ( ((LA22_191>='\u0000' && LA22_191<='\t')||(LA22_191>='\u000B' && LA22_191<='\f')||(LA22_191>='\u000E' && LA22_191<=',')||(LA22_191>='.' && LA22_191<='\uFFFF')) ) {s = 177;} - - else s = 152; - - if ( s>=0 ) return s; - break; - case 16 : - int LA22_186 = input.LA(1); - - s = -1; - if ( (LA22_186==']') ) {s = 188;} - - else if ( (LA22_186=='\r') ) {s = 165;} - - else if ( (LA22_186=='\n') ) {s = 166;} - - else if ( (LA22_186=='-') ) {s = 167;} - - else if ( ((LA22_186>='\u0000' && LA22_186<='\t')||(LA22_186>='\u000B' && LA22_186<='\f')||(LA22_186>='\u000E' && LA22_186<=',')||(LA22_186>='.' && LA22_186<='\\')||(LA22_186>='^' && LA22_186<='\uFFFF')) ) {s = 168;} - - if ( s>=0 ) return s; - break; - case 17 : - int LA22_183 = input.LA(1); - - s = -1; - if ( (LA22_183=='=') ) {s = 186;} - - else if ( (LA22_183=='\r') ) {s = 165;} - - else if ( (LA22_183=='\n') ) {s = 166;} - - else if ( (LA22_183=='-') ) {s = 167;} - - else if ( ((LA22_183>='\u0000' && LA22_183<='\t')||(LA22_183>='\u000B' && LA22_183<='\f')||(LA22_183>='\u000E' && LA22_183<=',')||(LA22_183>='.' && LA22_183<='<')||(LA22_183>='>' && LA22_183<='\uFFFF')) ) {s = 168;} - - if ( s>=0 ) return s; - break; - case 18 : - int LA22_140 = input.LA(1); - - s = -1; - if ( (LA22_140=='-') ) {s = 153;} - - else if ( (LA22_140=='\r') ) {s = 154;} - - else if ( (LA22_140=='\n') ) {s = 155;} - - else if ( ((LA22_140>='\u0000' && LA22_140<='\t')||(LA22_140>='\u000B' && LA22_140<='\f')||(LA22_140>='\u000E' && LA22_140<=',')||(LA22_140>='.' && LA22_140<='\uFFFF')) ) {s = 156;} - - if ( s>=0 ) return s; - break; - case 19 : - int LA22_167 = input.LA(1); - - s = -1; - if ( (LA22_167=='-') ) {s = 173;} - - else if ( (LA22_167=='\r') ) {s = 165;} - - else if ( (LA22_167=='\n') ) {s = 166;} - - else if ( ((LA22_167>='\u0000' && LA22_167<='\t')||(LA22_167>='\u000B' && LA22_167<='\f')||(LA22_167>='\u000E' && LA22_167<=',')||(LA22_167>='.' && LA22_167<='\uFFFF')) ) {s = 168;} - - if ( s>=0 ) return s; - break; - case 20 : - int LA22_180 = input.LA(1); - - s = -1; - if ( (LA22_180=='=') ) {s = 183;} - - else if ( (LA22_180=='\r') ) {s = 165;} - - else if ( (LA22_180=='\n') ) {s = 166;} - - else if ( (LA22_180=='-') ) {s = 167;} - - else if ( ((LA22_180>='\u0000' && LA22_180<='\t')||(LA22_180>='\u000B' && LA22_180<='\f')||(LA22_180>='\u000E' && LA22_180<=',')||(LA22_180>='.' && LA22_180<='<')||(LA22_180>='>' && LA22_180<='\uFFFF')) ) {s = 168;} - - if ( s>=0 ) return s; - break; - case 21 : - int LA22_164 = input.LA(1); - - s = -1; - if ( (LA22_164==']') ) {s = 172;} - - else if ( (LA22_164=='-') ) {s = 164;} - - else if ( (LA22_164=='\r') ) {s = 154;} - - else if ( (LA22_164=='\n') ) {s = 155;} - - else if ( ((LA22_164>='\u0000' && LA22_164<='\t')||(LA22_164>='\u000B' && LA22_164<='\f')||(LA22_164>='\u000E' && LA22_164<=',')||(LA22_164>='.' && LA22_164<='\\')||(LA22_164>='^' && LA22_164<='\uFFFF')) ) {s = 156;} - - if ( s>=0 ) return s; - break; - case 22 : - int LA22_137 = input.LA(1); - - s = -1; - if ( ((LA22_137>='\u0000' && LA22_137<='\t')||(LA22_137>='\u000B' && LA22_137<='\uFFFF')) ) {s = 152;} - - else if ( (LA22_137=='\n') ) {s = 138;} - - if ( s>=0 ) return s; - break; - case 23 : - int LA22_177 = input.LA(1); - - s = -1; - if ( (LA22_177=='\r') ) {s = 174;} - - else if ( (LA22_177=='\n') ) {s = 175;} - - else if ( (LA22_177=='-') ) {s = 176;} - - else if ( ((LA22_177>='\u0000' && LA22_177<='\t')||(LA22_177>='\u000B' && LA22_177<='\f')||(LA22_177>='\u000E' && LA22_177<=',')||(LA22_177>='.' && LA22_177<='\uFFFF')) ) {s = 177;} - - if ( s>=0 ) return s; - break; - case 24 : - int LA22_176 = input.LA(1); - - s = -1; - if ( (LA22_176=='-') ) {s = 181;} - - else if ( (LA22_176=='\r') ) {s = 174;} - - else if ( (LA22_176=='\n') ) {s = 175;} - - else if ( ((LA22_176>='\u0000' && LA22_176<='\t')||(LA22_176>='\u000B' && LA22_176<='\f')||(LA22_176>='\u000E' && LA22_176<=',')||(LA22_176>='.' && LA22_176<='\uFFFF')) ) {s = 177;} - - if ( s>=0 ) return s; - break; - case 25 : - int LA22_187 = input.LA(1); - - s = -1; - if ( (LA22_187=='=') ) {s = 189;} - - else if ( (LA22_187=='\r') ) {s = 174;} - - else if ( (LA22_187=='\n') ) {s = 175;} - - else if ( (LA22_187=='-') ) {s = 176;} - - else if ( ((LA22_187>='\u0000' && LA22_187<='\t')||(LA22_187>='\u000B' && LA22_187<='\f')||(LA22_187>='\u000E' && LA22_187<=',')||(LA22_187>='.' && LA22_187<='<')||(LA22_187>='>' && LA22_187<='\uFFFF')) ) {s = 177;} - - if ( s>=0 ) return s; - break; - case 26 : - int LA22_184 = input.LA(1); - - s = -1; - if ( (LA22_184=='=') ) {s = 187;} - - else if ( (LA22_184=='\r') ) {s = 174;} - - else if ( (LA22_184=='\n') ) {s = 175;} - - else if ( (LA22_184=='-') ) {s = 176;} - - else if ( ((LA22_184>='\u0000' && LA22_184<='\t')||(LA22_184>='\u000B' && LA22_184<='\f')||(LA22_184>='\u000E' && LA22_184<=',')||(LA22_184>='.' && LA22_184<='<')||(LA22_184>='>' && LA22_184<='\uFFFF')) ) {s = 177;} - - if ( s>=0 ) return s; - break; - case 27 : - int LA22_155 = input.LA(1); - - s = -1; - if ( ((LA22_155>='\u0000' && LA22_155<='\uFFFF')) ) {s = 152;} - - else s = 100; - - if ( s>=0 ) return s; - break; - case 28 : - int LA22_66 = input.LA(1); - - s = -1; - if ( (LA22_66=='[') ) {s = 99;} - - else if ( ((LA22_66>='\u0000' && LA22_66<='Z')||(LA22_66>='\\' && LA22_66<='\uFFFF')) ) {s = 100;} - - if ( s>=0 ) return s; - break; - case 29 : - int LA22_173 = input.LA(1); - - s = -1; - if ( (LA22_173==']') ) {s = 180;} - - else if ( (LA22_173=='-') ) {s = 173;} - - else if ( (LA22_173=='\r') ) {s = 165;} - - else if ( (LA22_173=='\n') ) {s = 166;} - - else if ( ((LA22_173>='\u0000' && LA22_173<='\t')||(LA22_173>='\u000B' && LA22_173<='\f')||(LA22_173>='\u000E' && LA22_173<=',')||(LA22_173>='.' && LA22_173<='\\')||(LA22_173>='^' && LA22_173<='\uFFFF')) ) {s = 168;} - - if ( s>=0 ) return s; - break; - case 30 : - int LA22_188 = input.LA(1); - - s = -1; - if ( (LA22_188=='\r') ) {s = 165;} - - else if ( (LA22_188=='\n') ) {s = 166;} - - else if ( (LA22_188=='-') ) {s = 167;} - - else if ( ((LA22_188>='\u0000' && LA22_188<='\t')||(LA22_188>='\u000B' && LA22_188<='\f')||(LA22_188>='\u000E' && LA22_188<=',')||(LA22_188>='.' && LA22_188<='\uFFFF')) ) {s = 168;} - - else s = 152; - - if ( s>=0 ) return s; - break; - case 31 : - int LA22_189 = input.LA(1); - - s = -1; - if ( (LA22_189=='=') ) {s = 190;} - - else if ( (LA22_189=='\r') ) {s = 174;} - - else if ( (LA22_189=='\n') ) {s = 175;} - - else if ( (LA22_189=='-') ) {s = 176;} - - else if ( ((LA22_189>='\u0000' && LA22_189<='\t')||(LA22_189>='\u000B' && LA22_189<='\f')||(LA22_189>='\u000E' && LA22_189<=',')||(LA22_189>='.' && LA22_189<='<')||(LA22_189>='>' && LA22_189<='\uFFFF')) ) {s = 177;} - - if ( s>=0 ) return s; - break; - case 32 : - int LA22_190 = input.LA(1); - - s = -1; - if ( (LA22_190==']') ) {s = 191;} - - else if ( (LA22_190=='\r') ) {s = 174;} - - else if ( (LA22_190=='\n') ) {s = 175;} - - else if ( (LA22_190=='-') ) {s = 176;} - - else if ( ((LA22_190>='\u0000' && LA22_190<='\t')||(LA22_190>='\u000B' && LA22_190<='\f')||(LA22_190>='\u000E' && LA22_190<=',')||(LA22_190>='.' && LA22_190<='\\')||(LA22_190>='^' && LA22_190<='\uFFFF')) ) {s = 177;} - - if ( s>=0 ) return s; - break; - case 33 : - int LA22_157 = input.LA(1); - - s = -1; - if ( (LA22_157=='\r') ) {s = 165;} - - else if ( (LA22_157=='\n') ) {s = 166;} - - else if ( (LA22_157=='-') ) {s = 167;} - - else if ( ((LA22_157>='\u0000' && LA22_157<='\t')||(LA22_157>='\u000B' && LA22_157<='\f')||(LA22_157>='\u000E' && LA22_157<=',')||(LA22_157>='.' && LA22_157<='\uFFFF')) ) {s = 168;} - - if ( s>=0 ) return s; - break; - case 34 : - int LA22_138 = input.LA(1); - - s = -1; - if ( ((LA22_138>='\u0000' && LA22_138<='\uFFFF')) ) {s = 152;} - - else s = 100; - - if ( s>=0 ) return s; - break; - case 35 : - int LA22_181 = input.LA(1); - - s = -1; - if ( (LA22_181==']') ) {s = 184;} - - else if ( (LA22_181=='-') ) {s = 181;} - - else if ( (LA22_181=='\r') ) {s = 174;} - - else if ( (LA22_181=='\n') ) {s = 175;} - - else if ( ((LA22_181>='\u0000' && LA22_181<='\t')||(LA22_181>='\u000B' && LA22_181<='\f')||(LA22_181>='\u000E' && LA22_181<=',')||(LA22_181>='.' && LA22_181<='\\')||(LA22_181>='^' && LA22_181<='\uFFFF')) ) {s = 177;} - - if ( s>=0 ) return s; - break; - case 36 : - int LA22_185 = input.LA(1); - - s = -1; - if ( (LA22_185=='-') ) {s = 153;} - - else if ( (LA22_185=='\r') ) {s = 154;} - - else if ( (LA22_185=='\n') ) {s = 155;} - - else if ( ((LA22_185>='\u0000' && LA22_185<='\t')||(LA22_185>='\u000B' && LA22_185<='\f')||(LA22_185>='\u000E' && LA22_185<=',')||(LA22_185>='.' && LA22_185<='\uFFFF')) ) {s = 156;} - - else s = 152; - - if ( s>=0 ) return s; - break; - case 37 : - int LA22_168 = input.LA(1); - - s = -1; - if ( (LA22_168=='\r') ) {s = 165;} - - else if ( (LA22_168=='\n') ) {s = 166;} - - else if ( (LA22_168=='-') ) {s = 167;} - - else if ( ((LA22_168>='\u0000' && LA22_168<='\t')||(LA22_168>='\u000B' && LA22_168<='\f')||(LA22_168>='\u000E' && LA22_168<=',')||(LA22_168>='.' && LA22_168<='\uFFFF')) ) {s = 168;} - - if ( s>=0 ) return s; - break; - case 38 : - int LA22_169 = input.LA(1); - - s = -1; - if ( (LA22_169=='\r') ) {s = 174;} - - else if ( (LA22_169=='\n') ) {s = 175;} - - else if ( (LA22_169=='-') ) {s = 176;} - - else if ( ((LA22_169>='\u0000' && LA22_169<='\t')||(LA22_169>='\u000B' && LA22_169<='\f')||(LA22_169>='\u000E' && LA22_169<=',')||(LA22_169>='.' && LA22_169<='\uFFFF')) ) {s = 177;} - - if ( s>=0 ) return s; - break; - case 39 : - int LA22_174 = input.LA(1); - - s = -1; - if ( ((LA22_174>='\u0000' && LA22_174<='\t')||(LA22_174>='\u000B' && LA22_174<='\uFFFF')) ) {s = 152;} - - else if ( (LA22_174=='\n') ) {s = 175;} - - if ( s>=0 ) return s; - break; - case 40 : - int LA22_99 = input.LA(1); - - s = -1; - if ( (LA22_99=='[') ) {s = 120;} - - else if ( (LA22_99=='=') ) {s = 121;} - - else if ( ((LA22_99>='\u0000' && LA22_99<='<')||(LA22_99>='>' && LA22_99<='Z')||(LA22_99>='\\' && LA22_99<='\uFFFF')) ) {s = 100;} - - if ( s>=0 ) return s; - break; - case 41 : - int LA22_166 = input.LA(1); - - s = -1; - if ( ((LA22_166>='\u0000' && LA22_166<='\uFFFF')) ) {s = 152;} - - else s = 100; - - if ( s>=0 ) return s; - break; - case 42 : - int LA22_121 = input.LA(1); - - s = -1; - if ( (LA22_121=='[') ) {s = 140;} - - else if ( (LA22_121=='=') ) {s = 141;} - - else if ( ((LA22_121>='\u0000' && LA22_121<='<')||(LA22_121>='>' && LA22_121<='Z')||(LA22_121>='\\' && LA22_121<='\uFFFF')) ) {s = 100;} - - if ( s>=0 ) return s; - break; - case 43 : - int LA22_156 = input.LA(1); - - s = -1; - if ( (LA22_156=='\r') ) {s = 154;} - - else if ( (LA22_156=='\n') ) {s = 155;} - - else if ( (LA22_156=='-') ) {s = 153;} - - else if ( ((LA22_156>='\u0000' && LA22_156<='\t')||(LA22_156>='\u000B' && LA22_156<='\f')||(LA22_156>='\u000E' && LA22_156<=',')||(LA22_156>='.' && LA22_156<='\uFFFF')) ) {s = 156;} - - if ( s>=0 ) return s; - break; - } - NoViableAltException nvae = - new NoViableAltException(getDescription(), 22, _s, input); - error(nvae); - throw nvae; - } - } - - -} \ No newline at end of file diff --git a/src/jse/org/luaj/vm2/luajc/antlr/LuaParser.java b/src/jse/org/luaj/vm2/luajc/antlr/LuaParser.java deleted file mode 100644 index 2fe29941..00000000 --- a/src/jse/org/luaj/vm2/luajc/antlr/LuaParser.java +++ /dev/null @@ -1,5168 +0,0 @@ -// $ANTLR 3.1.3 Mar 17, 2009 19:23:44 Lua.g 2009-10-19 10:13:33 - - package org.luaj.vm2.luajc.antlr; - import org.luaj.vm2.luajc.lst.*; - - -import org.antlr.runtime.*; -import java.util.Stack; -import java.util.List; -import java.util.ArrayList; -import java.util.Map; -import java.util.HashMap; -public class LuaParser extends Parser { - public static final String[] tokenNames = new String[] { - "", "", "", "", "NAME", "INT", "FLOAT1", "FLOAT2", "FLOAT3", "EXP", "HEX", "NORMALSTRING", "CHARSTRING", "LONGSTRING", "EscapeSequence", "DecimalEscape", "COMMENT", "LINE_COMMENT", "WS", "NEWLINE", "';'", "'='", "'do'", "'end'", "'while'", "'repeat'", "'until'", "'for'", "','", "'in'", "'function'", "'local'", "'if'", "'then'", "'elseif'", "'else'", "'return'", "'break'", "'.'", "':'", "'nil'", "'false'", "'true'", "'...'", "'('", "')'", "'['", "']'", "'{'", "'}'", "'+'", "'-'", "'*'", "'/'", "'^'", "'%'", "'..'", "'<'", "'<='", "'>'", "'>='", "'=='", "'~='", "'and'", "'or'", "'not'", "'#'" - }; - public static final int T__66=66; - public static final int T__64=64; - public static final int T__29=29; - public static final int T__65=65; - public static final int T__28=28; - public static final int T__62=62; - public static final int T__27=27; - public static final int T__63=63; - public static final int T__26=26; - public static final int T__25=25; - public static final int T__24=24; - public static final int T__23=23; - public static final int T__22=22; - public static final int T__21=21; - public static final int T__20=20; - public static final int T__61=61; - public static final int T__60=60; - public static final int EOF=-1; - public static final int FLOAT3=8; - public static final int FLOAT2=7; - public static final int FLOAT1=6; - public static final int T__55=55; - public static final int T__56=56; - public static final int T__57=57; - public static final int NAME=4; - public static final int T__58=58; - public static final int T__51=51; - public static final int T__52=52; - public static final int T__53=53; - public static final int T__54=54; - public static final int EXP=9; - public static final int HEX=10; - public static final int T__59=59; - public static final int DecimalEscape=15; - public static final int COMMENT=16; - public static final int T__50=50; - public static final int T__42=42; - public static final int T__43=43; - public static final int T__40=40; - public static final int T__41=41; - public static final int T__46=46; - public static final int T__47=47; - public static final int T__44=44; - public static final int T__45=45; - public static final int LINE_COMMENT=17; - public static final int T__48=48; - public static final int T__49=49; - public static final int CHARSTRING=12; - public static final int INT=5; - public static final int LONGSTRING=13; - public static final int T__30=30; - public static final int NORMALSTRING=11; - public static final int T__31=31; - public static final int T__32=32; - public static final int WS=18; - public static final int T__33=33; - public static final int T__34=34; - public static final int NEWLINE=19; - public static final int T__35=35; - public static final int T__36=36; - public static final int T__37=37; - public static final int T__38=38; - public static final int T__39=39; - public static final int EscapeSequence=14; - - // delegates - // delegators - - - public LuaParser(TokenStream input) { - this(input, new RecognizerSharedState()); - } - public LuaParser(TokenStream input, RecognizerSharedState state) { - super(input, state); - - } - - - public String[] getTokenNames() { return LuaParser.tokenNames; } - public String getGrammarFileName() { return "Lua.g"; } - - - LSChunk CHK = null; - - - - // $ANTLR start "chunk" - // Lua.g:22:1: chunk[String chunkname] returns [LSChunk c] : funcblock[CHK.function] ; - public final LSChunk chunk(String chunkname) throws RecognitionException { - LSChunk c = null; - - CHK = new LSChunk(chunkname); - try { - // Lua.g:24:2: ( funcblock[CHK.function] ) - // Lua.g:24:4: funcblock[CHK.function] - { - pushFollow(FOLLOW_funcblock_in_chunk58); - funcblock(CHK.function); - - state._fsp--; - if (state.failed) return c; - if ( state.backtracking==0 ) { - c =CHK; - } - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - } - return c; - } - // $ANTLR end "chunk" - - protected static class funcblock_scope { - LSFunction func; - } - protected Stack funcblock_stack = new Stack(); - - - // $ANTLR start "funcblock" - // Lua.g:27:1: funcblock[LSFunction f] : block ; - public final void funcblock(LSFunction f) throws RecognitionException { - funcblock_stack.push(new funcblock_scope()); - List block1 = null; - - - ((funcblock_scope)funcblock_stack.peek()).func = f; - try { - // Lua.g:30:2: ( block ) - // Lua.g:30:4: block - { - if ( state.backtracking==0 ) { - CHK.pushScope("body"); - } - pushFollow(FOLLOW_block_in_funcblock88); - block1=block(); - - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - f.setStatements(block1); CHK.popScope("body"); - } - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - funcblock_stack.pop(); - } - return ; - } - // $ANTLR end "funcblock" - - - // $ANTLR start "block" - // Lua.g:33:1: block returns [List stats] : ( stat ( ';' )? )* ( laststat ( ';' )? )? ; - public final List block() throws RecognitionException { - List stats = null; - - LSStatement stat2 = null; - - LSStatement laststat3 = null; - - - stats = new ArrayList(); - try { - // Lua.g:35:2: ( ( stat ( ';' )? )* ( laststat ( ';' )? )? ) - // Lua.g:35:4: ( stat ( ';' )? )* ( laststat ( ';' )? )? - { - // Lua.g:35:4: ( stat ( ';' )? )* - loop2: - do { - int alt2=2; - int LA2_0 = input.LA(1); - - if ( (LA2_0==NAME||LA2_0==22||(LA2_0>=24 && LA2_0<=25)||LA2_0==27||(LA2_0>=30 && LA2_0<=32)||LA2_0==44) ) { - alt2=1; - } - - - switch (alt2) { - case 1 : - // Lua.g:35:5: stat ( ';' )? - { - pushFollow(FOLLOW_stat_in_block113); - stat2=stat(); - - state._fsp--; - if (state.failed) return stats; - if ( state.backtracking==0 ) { - stats.add(stat2); - } - // Lua.g:35:33: ( ';' )? - int alt1=2; - int LA1_0 = input.LA(1); - - if ( (LA1_0==20) ) { - alt1=1; - } - switch (alt1) { - case 1 : - // Lua.g:35:34: ';' - { - match(input,20,FOLLOW_20_in_block118); if (state.failed) return stats; - - } - break; - - } - - - } - break; - - default : - break loop2; - } - } while (true); - - // Lua.g:36:3: ( laststat ( ';' )? )? - int alt4=2; - int LA4_0 = input.LA(1); - - if ( ((LA4_0>=36 && LA4_0<=37)) ) { - alt4=1; - } - switch (alt4) { - case 1 : - // Lua.g:36:4: laststat ( ';' )? - { - pushFollow(FOLLOW_laststat_in_block128); - laststat3=laststat(); - - state._fsp--; - if (state.failed) return stats; - if ( state.backtracking==0 ) { - stats.add(laststat3); - } - // Lua.g:36:40: ( ';' )? - int alt3=2; - int LA3_0 = input.LA(1); - - if ( (LA3_0==20) ) { - alt3=1; - } - switch (alt3) { - case 1 : - // Lua.g:36:41: ';' - { - match(input,20,FOLLOW_20_in_block133); if (state.failed) return stats; - - } - break; - - } - - - } - break; - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - } - return stats; - } - // $ANTLR end "block" - - - // $ANTLR start "stat" - // Lua.g:39:1: stat returns [LSStatement s] : ( varlist1 '=' explist1 | functioncall | 'do' block 'end' | 'while' exp 'do' block 'end' | 'repeat' block 'until' exp | ifstat | 'for' NAME '=' e1= exp ',' e2= exp ( ',' e3= exp )? 'do' block 'end' | 'for' namelist 'in' explist1 'do' block 'end' | 'function' funcname funcbody | 'local' 'function' NAME funcbody | 'local' namelist ( '=' explist1 )? ); - public final LSStatement stat() throws RecognitionException { - LSStatement s = null; - - Token NAME13=null; - Token NAME20=null; - LSExpression e1 = null; - - LSExpression e2 = null; - - LSExpression e3 = null; - - List varlist14 = null; - - List explist15 = null; - - LSVariable functioncall6 = null; - - List block7 = null; - - LSExpression exp8 = null; - - List block9 = null; - - List block10 = null; - - LSExpression exp11 = null; - - LSStatement ifstat12 = null; - - List block14 = null; - - List namelist15 = null; - - List explist116 = null; - - List block17 = null; - - LSVariable funcname18 = null; - - LSFunction funcbody19 = null; - - LSFunction funcbody21 = null; - - List namelist22 = null; - - List explist123 = null; - - - Name name=null; List names=null; - try { - // Lua.g:41:2: ( varlist1 '=' explist1 | functioncall | 'do' block 'end' | 'while' exp 'do' block 'end' | 'repeat' block 'until' exp | ifstat | 'for' NAME '=' e1= exp ',' e2= exp ( ',' e3= exp )? 'do' block 'end' | 'for' namelist 'in' explist1 'do' block 'end' | 'function' funcname funcbody | 'local' 'function' NAME funcbody | 'local' namelist ( '=' explist1 )? ) - int alt7=11; - alt7 = dfa7.predict(input); - switch (alt7) { - case 1 : - // Lua.g:41:4: varlist1 '=' explist1 - { - pushFollow(FOLLOW_varlist1_in_stat159); - varlist14=varlist1(); - - state._fsp--; - if (state.failed) return s; - match(input,21,FOLLOW_21_in_stat161); if (state.failed) return s; - pushFollow(FOLLOW_explist1_in_stat163); - explist15=explist1(); - - state._fsp--; - if (state.failed) return s; - if ( state.backtracking==0 ) { - s =LSStatement.varAssignStatement(varlist14,explist15, CHK.peekScope(), ((funcblock_scope)funcblock_stack.peek()).func); - } - - } - break; - case 2 : - // Lua.g:42:4: functioncall - { - pushFollow(FOLLOW_functioncall_in_stat183); - functioncall6=functioncall(); - - state._fsp--; - if (state.failed) return s; - if ( state.backtracking==0 ) { - s =LSStatement.functionCallStatement(functioncall6); - } - - } - break; - case 3 : - // Lua.g:43:4: 'do' block 'end' - { - match(input,22,FOLLOW_22_in_stat213); if (state.failed) return s; - if ( state.backtracking==0 ) { - CHK.pushScope("do"); - } - pushFollow(FOLLOW_block_in_stat217); - block7=block(); - - state._fsp--; - if (state.failed) return s; - if ( state.backtracking==0 ) { - CHK.popScope("do"); - } - match(input,23,FOLLOW_23_in_stat221); if (state.failed) return s; - if ( state.backtracking==0 ) { - s =LSStatement.doBlockStatement(block7); - } - - } - break; - case 4 : - // Lua.g:45:4: 'while' exp 'do' block 'end' - { - match(input,24,FOLLOW_24_in_stat286); if (state.failed) return s; - pushFollow(FOLLOW_exp_in_stat288); - exp8=exp(); - - state._fsp--; - if (state.failed) return s; - match(input,22,FOLLOW_22_in_stat290); if (state.failed) return s; - if ( state.backtracking==0 ) { - CHK.pushScope("while"); - } - pushFollow(FOLLOW_block_in_stat294); - block9=block(); - - state._fsp--; - if (state.failed) return s; - if ( state.backtracking==0 ) { - CHK.popScope("while"); - } - match(input,23,FOLLOW_23_in_stat298); if (state.failed) return s; - if ( state.backtracking==0 ) { - s =LSStatement.whileLoopStatement(exp8,block9); - } - - } - break; - case 5 : - // Lua.g:47:4: 'repeat' block 'until' exp - { - match(input,25,FOLLOW_25_in_stat344); if (state.failed) return s; - if ( state.backtracking==0 ) { - CHK.pushScope("repeat"); - } - pushFollow(FOLLOW_block_in_stat349); - block10=block(); - - state._fsp--; - if (state.failed) return s; - if ( state.backtracking==0 ) { - CHK.popScope("repeat"); - } - match(input,26,FOLLOW_26_in_stat354); if (state.failed) return s; - pushFollow(FOLLOW_exp_in_stat356); - exp11=exp(); - - state._fsp--; - if (state.failed) return s; - if ( state.backtracking==0 ) { - s =LSStatement.repeatUntilStatement(block10,exp11); - } - - } - break; - case 6 : - // Lua.g:49:4: ifstat - { - pushFollow(FOLLOW_ifstat_in_stat410); - ifstat12=ifstat(); - - state._fsp--; - if (state.failed) return s; - if ( state.backtracking==0 ) { - s =ifstat12; - } - - } - break; - case 7 : - // Lua.g:50:4: 'for' NAME '=' e1= exp ',' e2= exp ( ',' e3= exp )? 'do' block 'end' - { - match(input,27,FOLLOW_27_in_stat445); if (state.failed) return s; - if ( state.backtracking==0 ) { - CHK.pushScope("fori"); - } - NAME13=(Token)match(input,NAME,FOLLOW_NAME_in_stat449); if (state.failed) return s; - if ( state.backtracking==0 ) { - name=CHK.declare((NAME13!=null?NAME13.getText():null)); - } - match(input,21,FOLLOW_21_in_stat453); if (state.failed) return s; - pushFollow(FOLLOW_exp_in_stat457); - e1=exp(); - - state._fsp--; - if (state.failed) return s; - match(input,28,FOLLOW_28_in_stat459); if (state.failed) return s; - pushFollow(FOLLOW_exp_in_stat463); - e2=exp(); - - state._fsp--; - if (state.failed) return s; - // Lua.g:50:94: ( ',' e3= exp )? - int alt5=2; - int LA5_0 = input.LA(1); - - if ( (LA5_0==28) ) { - alt5=1; - } - switch (alt5) { - case 1 : - // Lua.g:50:95: ',' e3= exp - { - match(input,28,FOLLOW_28_in_stat466); if (state.failed) return s; - pushFollow(FOLLOW_exp_in_stat470); - e3=exp(); - - state._fsp--; - if (state.failed) return s; - - } - break; - - } - - match(input,22,FOLLOW_22_in_stat474); if (state.failed) return s; - if ( state.backtracking==0 ) { - CHK.pushScope("foriblock"); - } - pushFollow(FOLLOW_block_in_stat478); - block14=block(); - - state._fsp--; - if (state.failed) return s; - if ( state.backtracking==0 ) { - CHK.popScope("foriblock"); - } - match(input,23,FOLLOW_23_in_stat482); if (state.failed) return s; - if ( state.backtracking==0 ) { - s =LSStatement.forLoopStatement(name,e1,e2,e3,block14,CHK.peekScope()); CHK.popScope("fori"); - } - - } - break; - case 8 : - // Lua.g:52:4: 'for' namelist 'in' explist1 'do' block 'end' - { - match(input,27,FOLLOW_27_in_stat528); if (state.failed) return s; - if ( state.backtracking==0 ) { - CHK.pushScope("for"); - } - pushFollow(FOLLOW_namelist_in_stat533); - namelist15=namelist(); - - state._fsp--; - if (state.failed) return s; - if ( state.backtracking==0 ) { - names=CHK.declare(namelist15); - } - match(input,29,FOLLOW_29_in_stat537); if (state.failed) return s; - pushFollow(FOLLOW_explist1_in_stat539); - explist116=explist1(); - - state._fsp--; - if (state.failed) return s; - match(input,22,FOLLOW_22_in_stat541); if (state.failed) return s; - if ( state.backtracking==0 ) { - CHK.pushScope("forblock"); - } - pushFollow(FOLLOW_block_in_stat545); - block17=block(); - - state._fsp--; - if (state.failed) return s; - if ( state.backtracking==0 ) { - CHK.popScope("forblock"); - } - match(input,23,FOLLOW_23_in_stat548); if (state.failed) return s; - if ( state.backtracking==0 ) { - s =LSStatement.forListStatement(names,explist116,block17,CHK.peekScope(), ((funcblock_scope)funcblock_stack.peek()).func); CHK.popScope("for"); - } - - } - break; - case 9 : - // Lua.g:54:4: 'function' funcname funcbody - { - match(input,30,FOLLOW_30_in_stat593); if (state.failed) return s; - pushFollow(FOLLOW_funcname_in_stat595); - funcname18=funcname(); - - state._fsp--; - if (state.failed) return s; - pushFollow(FOLLOW_funcbody_in_stat597); - funcbody19=funcbody(); - - state._fsp--; - if (state.failed) return s; - if ( state.backtracking==0 ) { - s =LSStatement.varFunctionStatement(funcname18,funcbody19); - } - - } - break; - case 10 : - // Lua.g:55:4: 'local' 'function' NAME funcbody - { - match(input,31,FOLLOW_31_in_stat610); if (state.failed) return s; - match(input,30,FOLLOW_30_in_stat612); if (state.failed) return s; - NAME20=(Token)match(input,NAME,FOLLOW_NAME_in_stat614); if (state.failed) return s; - if ( state.backtracking==0 ) { - name=CHK.declare((NAME20!=null?NAME20.getText():null)); - } - pushFollow(FOLLOW_funcbody_in_stat618); - funcbody21=funcbody(); - - state._fsp--; - if (state.failed) return s; - if ( state.backtracking==0 ) { - s =LSStatement.localFunctionStatement(name,funcbody21); - } - - } - break; - case 11 : - // Lua.g:57:4: 'local' namelist ( '=' explist1 )? - { - match(input,31,FOLLOW_31_in_stat666); if (state.failed) return s; - pushFollow(FOLLOW_namelist_in_stat668); - namelist22=namelist(); - - state._fsp--; - if (state.failed) return s; - // Lua.g:57:21: ( '=' explist1 )? - int alt6=2; - int LA6_0 = input.LA(1); - - if ( (LA6_0==21) ) { - alt6=1; - } - switch (alt6) { - case 1 : - // Lua.g:57:22: '=' explist1 - { - match(input,21,FOLLOW_21_in_stat671); if (state.failed) return s; - pushFollow(FOLLOW_explist1_in_stat673); - explist123=explist1(); - - state._fsp--; - if (state.failed) return s; - - } - break; - - } - - if ( state.backtracking==0 ) { - s =LSStatement.localAssignStatement(CHK.declare(namelist22),explist123,CHK.peekScope(), ((funcblock_scope)funcblock_stack.peek()).func); - } - - } - break; - - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - } - return s; - } - // $ANTLR end "stat" - - protected static class ifstat_scope { - LSIfStatement current; - } - protected Stack ifstat_stack = new Stack(); - - - // $ANTLR start "ifstat" - // Lua.g:60:1: ifstat returns [LSStatement s] : 'if' e1= exp 'then' b1= block ( 'elseif' e2= exp 'then' b2= block )* ( 'else' b3= block )? 'end' ; - public final LSStatement ifstat() throws RecognitionException { - ifstat_stack.push(new ifstat_scope()); - LSStatement s = null; - - LSExpression e1 = null; - - List b1 = null; - - LSExpression e2 = null; - - List b2 = null; - - List b3 = null; - - - try { - // Lua.g:62:2: ( 'if' e1= exp 'then' b1= block ( 'elseif' e2= exp 'then' b2= block )* ( 'else' b3= block )? 'end' ) - // Lua.g:62:4: 'if' e1= exp 'then' b1= block ( 'elseif' e2= exp 'then' b2= block )* ( 'else' b3= block )? 'end' - { - match(input,32,FOLLOW_32_in_ifstat699); if (state.failed) return s; - pushFollow(FOLLOW_exp_in_ifstat703); - e1=exp(); - - state._fsp--; - if (state.failed) return s; - match(input,33,FOLLOW_33_in_ifstat705); if (state.failed) return s; - if ( state.backtracking==0 ) { - CHK.pushScope("if"); - } - pushFollow(FOLLOW_block_in_ifstat712); - b1=block(); - - state._fsp--; - if (state.failed) return s; - if ( state.backtracking==0 ) { - ((ifstat_scope)ifstat_stack.peek()).current =new LSIfStatement(e1,b1); CHK.popScope("if"); - } - // Lua.g:63:4: ( 'elseif' e2= exp 'then' b2= block )* - loop8: - do { - int alt8=2; - int LA8_0 = input.LA(1); - - if ( (LA8_0==34) ) { - alt8=1; - } - - - switch (alt8) { - case 1 : - // Lua.g:63:5: 'elseif' e2= exp 'then' b2= block - { - match(input,34,FOLLOW_34_in_ifstat721); if (state.failed) return s; - pushFollow(FOLLOW_exp_in_ifstat725); - e2=exp(); - - state._fsp--; - if (state.failed) return s; - match(input,33,FOLLOW_33_in_ifstat727); if (state.failed) return s; - if ( state.backtracking==0 ) { - CHK.pushScope("elseif"); - } - pushFollow(FOLLOW_block_in_ifstat734); - b2=block(); - - state._fsp--; - if (state.failed) return s; - if ( state.backtracking==0 ) { - ((ifstat_scope)ifstat_stack.peek()).current.addElseif(e2,b2); CHK.popScope("elseif"); - } - - } - break; - - default : - break loop8; - } - } while (true); - - // Lua.g:64:4: ( 'else' b3= block )? - int alt9=2; - int LA9_0 = input.LA(1); - - if ( (LA9_0==35) ) { - alt9=1; - } - switch (alt9) { - case 1 : - // Lua.g:64:5: 'else' b3= block - { - match(input,35,FOLLOW_35_in_ifstat745); if (state.failed) return s; - if ( state.backtracking==0 ) { - CHK.pushScope("else"); - } - pushFollow(FOLLOW_block_in_ifstat752); - b3=block(); - - state._fsp--; - if (state.failed) return s; - if ( state.backtracking==0 ) { - ((ifstat_scope)ifstat_stack.peek()).current.addElse(b3); CHK.popScope("else"); - } - - } - break; - - } - - match(input,23,FOLLOW_23_in_ifstat762); if (state.failed) return s; - if ( state.backtracking==0 ) { - s =((ifstat_scope)ifstat_stack.peek()).current; - } - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - ifstat_stack.pop(); - } - return s; - } - // $ANTLR end "ifstat" - - - // $ANTLR start "laststat" - // Lua.g:69:1: laststat returns [LSStatement s] : ( 'return' (e= explist1 )? | 'break' ); - public final LSStatement laststat() throws RecognitionException { - LSStatement s = null; - - List e = null; - - - try { - // Lua.g:70:2: ( 'return' (e= explist1 )? | 'break' ) - int alt11=2; - int LA11_0 = input.LA(1); - - if ( (LA11_0==36) ) { - alt11=1; - } - else if ( (LA11_0==37) ) { - alt11=2; - } - else { - if (state.backtracking>0) {state.failed=true; return s;} - NoViableAltException nvae = - new NoViableAltException("", 11, 0, input); - - throw nvae; - } - switch (alt11) { - case 1 : - // Lua.g:70:4: 'return' (e= explist1 )? - { - match(input,36,FOLLOW_36_in_laststat782); if (state.failed) return s; - // Lua.g:70:13: (e= explist1 )? - int alt10=2; - int LA10_0 = input.LA(1); - - if ( ((LA10_0>=NAME && LA10_0<=LONGSTRING)||LA10_0==30||(LA10_0>=40 && LA10_0<=44)||LA10_0==48||LA10_0==51||(LA10_0>=65 && LA10_0<=66)) ) { - alt10=1; - } - switch (alt10) { - case 1 : - // Lua.g:70:14: e= explist1 - { - pushFollow(FOLLOW_explist1_in_laststat787); - e=explist1(); - - state._fsp--; - if (state.failed) return s; - - } - break; - - } - - if ( state.backtracking==0 ) { - s =LSStatement.returnStatement(((funcblock_scope)funcblock_stack.peek()).func,e); - } - - } - break; - case 2 : - // Lua.g:71:4: 'break' - { - match(input,37,FOLLOW_37_in_laststat797); if (state.failed) return s; - if ( state.backtracking==0 ) { - s =LSStatement.breakStatement(); - } - - } - break; - - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - } - return s; - } - // $ANTLR end "laststat" - - - // $ANTLR start "funcname" - // Lua.g:74:1: funcname returns [LSVariable v] : n= NAME ( '.' n2= NAME )* ( ':' n3= NAME )? ; - public final LSVariable funcname() throws RecognitionException { - LSVariable v = null; - - Token n=null; - Token n2=null; - Token n3=null; - - try { - // Lua.g:75:2: (n= NAME ( '.' n2= NAME )* ( ':' n3= NAME )? ) - // Lua.g:75:4: n= NAME ( '.' n2= NAME )* ( ':' n3= NAME )? - { - n=(Token)match(input,NAME,FOLLOW_NAME_in_funcname831); if (state.failed) return v; - if ( state.backtracking==0 ) { - v = LSVariable.nameVariable(CHK.reference((n!=null?n.getText():null),((funcblock_scope)funcblock_stack.peek()).func)); - } - // Lua.g:76:3: ( '.' n2= NAME )* - loop12: - do { - int alt12=2; - int LA12_0 = input.LA(1); - - if ( (LA12_0==38) ) { - alt12=1; - } - - - switch (alt12) { - case 1 : - // Lua.g:76:4: '.' n2= NAME - { - match(input,38,FOLLOW_38_in_funcname839); if (state.failed) return v; - n2=(Token)match(input,NAME,FOLLOW_NAME_in_funcname843); if (state.failed) return v; - if ( state.backtracking==0 ) { - v = v.fieldVariable((n2!=null?n2.getText():null)); - } - - } - break; - - default : - break loop12; - } - } while (true); - - // Lua.g:77:3: ( ':' n3= NAME )? - int alt13=2; - int LA13_0 = input.LA(1); - - if ( (LA13_0==39) ) { - alt13=1; - } - switch (alt13) { - case 1 : - // Lua.g:77:4: ':' n3= NAME - { - match(input,39,FOLLOW_39_in_funcname854); if (state.failed) return v; - n3=(Token)match(input,NAME,FOLLOW_NAME_in_funcname858); if (state.failed) return v; - if ( state.backtracking==0 ) { - v = v.methodVariable((n3!=null?n3.getText():null)); - } - - } - break; - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - } - return v; - } - // $ANTLR end "funcname" - - - // $ANTLR start "varlist1" - // Lua.g:80:1: varlist1 returns [List vars] : v1= var ( ',' v2= var )* ; - public final List varlist1() throws RecognitionException { - List vars = null; - - LSVariable v1 = null; - - LSVariable v2 = null; - - - vars = new ArrayList(); - try { - // Lua.g:82:2: (v1= var ( ',' v2= var )* ) - // Lua.g:82:4: v1= var ( ',' v2= var )* - { - pushFollow(FOLLOW_var_in_varlist1887); - v1=var(); - - state._fsp--; - if (state.failed) return vars; - if ( state.backtracking==0 ) { - vars.add(v1); - } - // Lua.g:83:3: ( ',' v2= var )* - loop14: - do { - int alt14=2; - int LA14_0 = input.LA(1); - - if ( (LA14_0==28) ) { - alt14=1; - } - - - switch (alt14) { - case 1 : - // Lua.g:83:4: ',' v2= var - { - match(input,28,FOLLOW_28_in_varlist1894); if (state.failed) return vars; - pushFollow(FOLLOW_var_in_varlist1898); - v2=var(); - - state._fsp--; - if (state.failed) return vars; - if ( state.backtracking==0 ) { - vars.add(v2); - } - - } - break; - - default : - break loop14; - } - } while (true); - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - } - return vars; - } - // $ANTLR end "varlist1" - - - // $ANTLR start "namelist" - // Lua.g:86:1: namelist returns [List names] : n= NAME ( ',' n2= NAME )* ; - public final List namelist() throws RecognitionException { - List names = null; - - Token n=null; - Token n2=null; - - try { - // Lua.g:87:2: (n= NAME ( ',' n2= NAME )* ) - // Lua.g:87:4: n= NAME ( ',' n2= NAME )* - { - n=(Token)match(input,NAME,FOLLOW_NAME_in_namelist919); if (state.failed) return names; - if ( state.backtracking==0 ) { - names =new ArrayList(); names.add((n!=null?n.getText():null)); - } - // Lua.g:88:3: ( ',' n2= NAME )* - loop15: - do { - int alt15=2; - int LA15_0 = input.LA(1); - - if ( (LA15_0==28) ) { - int LA15_2 = input.LA(2); - - if ( (LA15_2==NAME) ) { - alt15=1; - } - - - } - - - switch (alt15) { - case 1 : - // Lua.g:88:4: ',' n2= NAME - { - match(input,28,FOLLOW_28_in_namelist927); if (state.failed) return names; - n2=(Token)match(input,NAME,FOLLOW_NAME_in_namelist931); if (state.failed) return names; - if ( state.backtracking==0 ) { - names.add((n2!=null?n2.getText():null)); - } - - } - break; - - default : - break loop15; - } - } while (true); - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - } - return names; - } - // $ANTLR end "namelist" - - - // $ANTLR start "explist1" - // Lua.g:91:1: explist1 returns [List exprs] : (e1= exp ',' )* e2= exp ; - public final List explist1() throws RecognitionException { - List exprs = null; - - LSExpression e1 = null; - - LSExpression e2 = null; - - - exprs = new ArrayList(); - try { - // Lua.g:93:2: ( (e1= exp ',' )* e2= exp ) - // Lua.g:93:4: (e1= exp ',' )* e2= exp - { - // Lua.g:93:4: (e1= exp ',' )* - loop16: - do { - int alt16=2; - alt16 = dfa16.predict(input); - switch (alt16) { - case 1 : - // Lua.g:93:5: e1= exp ',' - { - pushFollow(FOLLOW_exp_in_explist1960); - e1=exp(); - - state._fsp--; - if (state.failed) return exprs; - match(input,28,FOLLOW_28_in_explist1962); if (state.failed) return exprs; - if ( state.backtracking==0 ) { - exprs.add(e1); - } - - } - break; - - default : - break loop16; - } - } while (true); - - pushFollow(FOLLOW_exp_in_explist1973); - e2=exp(); - - state._fsp--; - if (state.failed) return exprs; - if ( state.backtracking==0 ) { - exprs.add(e2); - } - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - } - return exprs; - } - // $ANTLR end "explist1" - - - // $ANTLR start "exp" - // Lua.g:97:1: exp returns [LSExpression e] : ( 'nil' | 'false' | 'true' | number | string | '...' | function | prefixexp | tableconstructor | unop e1= exp ) ( binop e2= exp )* ; - public final LSExpression exp() throws RecognitionException { - LSExpression e = null; - - LSExpression e1 = null; - - LSExpression e2 = null; - - LuaParser.number_return number24 = null; - - LSExpression string25 = null; - - LSFunction function26 = null; - - LSVariable prefixexp27 = null; - - LSExpression tableconstructor28 = null; - - UnOp unop29 = null; - - BinOp binop30 = null; - - - try { - // Lua.g:98:2: ( ( 'nil' | 'false' | 'true' | number | string | '...' | function | prefixexp | tableconstructor | unop e1= exp ) ( binop e2= exp )* ) - // Lua.g:98:4: ( 'nil' | 'false' | 'true' | number | string | '...' | function | prefixexp | tableconstructor | unop e1= exp ) ( binop e2= exp )* - { - // Lua.g:98:4: ( 'nil' | 'false' | 'true' | number | string | '...' | function | prefixexp | tableconstructor | unop e1= exp ) - int alt17=10; - alt17 = dfa17.predict(input); - switch (alt17) { - case 1 : - // Lua.g:98:5: 'nil' - { - match(input,40,FOLLOW_40_in_exp991); if (state.failed) return e; - if ( state.backtracking==0 ) { - e =LSExpression.ENIL; - } - - } - break; - case 2 : - // Lua.g:99:5: 'false' - { - match(input,41,FOLLOW_41_in_exp1013); if (state.failed) return e; - if ( state.backtracking==0 ) { - e =LSExpression.EFALSE; - } - - } - break; - case 3 : - // Lua.g:100:5: 'true' - { - match(input,42,FOLLOW_42_in_exp1030); if (state.failed) return e; - if ( state.backtracking==0 ) { - e =LSExpression.ETRUE; - } - - } - break; - case 4 : - // Lua.g:101:5: number - { - pushFollow(FOLLOW_number_in_exp1048); - number24=number(); - - state._fsp--; - if (state.failed) return e; - if ( state.backtracking==0 ) { - e =LSExpression.numberExpression((number24!=null?input.toString(number24.start,number24.stop):null)); - } - - } - break; - case 5 : - // Lua.g:102:5: string - { - pushFollow(FOLLOW_string_in_exp1066); - string25=string(); - - state._fsp--; - if (state.failed) return e; - if ( state.backtracking==0 ) { - e =string25; - } - - } - break; - case 6 : - // Lua.g:103:5: '...' - { - match(input,43,FOLLOW_43_in_exp1084); if (state.failed) return e; - if ( state.backtracking==0 ) { - e =LSExpression.varargsRef(); ((funcblock_scope)funcblock_stack.peek()).func.setUsesVarargs(); - } - - } - break; - case 7 : - // Lua.g:104:5: function - { - pushFollow(FOLLOW_function_in_exp1103); - function26=function(); - - state._fsp--; - if (state.failed) return e; - if ( state.backtracking==0 ) { - e =LSExpression.functionExpression(function26); - } - - } - break; - case 8 : - // Lua.g:105:5: prefixexp - { - pushFollow(FOLLOW_prefixexp_in_exp1119); - prefixexp27=prefixexp(); - - state._fsp--; - if (state.failed) return e; - if ( state.backtracking==0 ) { - e =prefixexp27; - } - - } - break; - case 9 : - // Lua.g:106:5: tableconstructor - { - pushFollow(FOLLOW_tableconstructor_in_exp1134); - tableconstructor28=tableconstructor(); - - state._fsp--; - if (state.failed) return e; - if ( state.backtracking==0 ) { - e =tableconstructor28; - } - - } - break; - case 10 : - // Lua.g:107:5: unop e1= exp - { - pushFollow(FOLLOW_unop_in_exp1142); - unop29=unop(); - - state._fsp--; - if (state.failed) return e; - pushFollow(FOLLOW_exp_in_exp1146); - e1=exp(); - - state._fsp--; - if (state.failed) return e; - if ( state.backtracking==0 ) { - e =LSExpression.unopExpression(unop29,e1,CHK.peekScope()); - } - - } - break; - - } - - // Lua.g:108:5: ( binop e2= exp )* - loop18: - do { - int alt18=2; - alt18 = dfa18.predict(input); - switch (alt18) { - case 1 : - // Lua.g:108:6: binop e2= exp - { - pushFollow(FOLLOW_binop_in_exp1160); - binop30=binop(); - - state._fsp--; - if (state.failed) return e; - pushFollow(FOLLOW_exp_in_exp1164); - e2=exp(); - - state._fsp--; - if (state.failed) return e; - if ( state.backtracking==0 ) { - e =LSExpression.binopExpression(e,binop30,e2,CHK.peekScope()); - } - - } - break; - - default : - break loop18; - } - } while (true); - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - } - return e; - } - // $ANTLR end "exp" - - protected static class var_scope { - LSVariable current; - } - protected Stack var_stack = new Stack(); - - - // $ANTLR start "var" - // Lua.g:111:1: var returns [LSVariable v] : (n= NAME | '(' exp ')' varSuffix ) ( varSuffix )* ; - public final LSVariable var() throws RecognitionException { - var_stack.push(new var_scope()); - LSVariable v = null; - - Token n=null; - LSExpression exp31 = null; - - - try { - // Lua.g:113:2: ( (n= NAME | '(' exp ')' varSuffix ) ( varSuffix )* ) - // Lua.g:113:4: (n= NAME | '(' exp ')' varSuffix ) ( varSuffix )* - { - // Lua.g:113:4: (n= NAME | '(' exp ')' varSuffix ) - int alt19=2; - int LA19_0 = input.LA(1); - - if ( (LA19_0==NAME) ) { - alt19=1; - } - else if ( (LA19_0==44) ) { - alt19=2; - } - else { - if (state.backtracking>0) {state.failed=true; return v;} - NoViableAltException nvae = - new NoViableAltException("", 19, 0, input); - - throw nvae; - } - switch (alt19) { - case 1 : - // Lua.g:113:5: n= NAME - { - n=(Token)match(input,NAME,FOLLOW_NAME_in_var1195); if (state.failed) return v; - if ( state.backtracking==0 ) { - ((var_scope)var_stack.peek()).current =LSVariable.nameVariable(CHK.reference((n!=null?n.getText():null),((funcblock_scope)funcblock_stack.peek()).func)); - } - - } - break; - case 2 : - // Lua.g:114:8: '(' exp ')' varSuffix - { - match(input,44,FOLLOW_44_in_var1207); if (state.failed) return v; - pushFollow(FOLLOW_exp_in_var1209); - exp31=exp(); - - state._fsp--; - if (state.failed) return v; - match(input,45,FOLLOW_45_in_var1211); if (state.failed) return v; - if ( state.backtracking==0 ) { - ((var_scope)var_stack.peek()).current =LSVariable.parenthesesVariable(exp31); - } - pushFollow(FOLLOW_varSuffix_in_var1215); - varSuffix(); - - state._fsp--; - if (state.failed) return v; - - } - break; - - } - - // Lua.g:115:7: ( varSuffix )* - loop20: - do { - int alt20=2; - alt20 = dfa20.predict(input); - switch (alt20) { - case 1 : - // Lua.g:0:0: varSuffix - { - pushFollow(FOLLOW_varSuffix_in_var1225); - varSuffix(); - - state._fsp--; - if (state.failed) return v; - - } - break; - - default : - break loop20; - } - } while (true); - - if ( state.backtracking==0 ) { - v =((var_scope)var_stack.peek()).current; - } - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - var_stack.pop(); - } - return v; - } - // $ANTLR end "var" - - - // $ANTLR start "varSuffix" - // Lua.g:119:1: varSuffix : (n= nameAndArgs[$var::current] )* ( '[' e= exp ']' | '.' n2= NAME ) ; - public final void varSuffix() throws RecognitionException { - Token n2=null; - LSVariable n = null; - - LSExpression e = null; - - - try { - // Lua.g:120:2: ( (n= nameAndArgs[$var::current] )* ( '[' e= exp ']' | '.' n2= NAME ) ) - // Lua.g:120:4: (n= nameAndArgs[$var::current] )* ( '[' e= exp ']' | '.' n2= NAME ) - { - // Lua.g:120:4: (n= nameAndArgs[$var::current] )* - loop21: - do { - int alt21=2; - int LA21_0 = input.LA(1); - - if ( ((LA21_0>=NORMALSTRING && LA21_0<=LONGSTRING)||LA21_0==39||LA21_0==44||LA21_0==48) ) { - alt21=1; - } - - - switch (alt21) { - case 1 : - // Lua.g:120:5: n= nameAndArgs[$var::current] - { - pushFollow(FOLLOW_nameAndArgs_in_varSuffix1245); - n=nameAndArgs(((var_scope)var_stack.peek()).current); - - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - ((var_scope)var_stack.peek()).current =n; - } - - } - break; - - default : - break loop21; - } - } while (true); - - // Lua.g:121:3: ( '[' e= exp ']' | '.' n2= NAME ) - int alt22=2; - int LA22_0 = input.LA(1); - - if ( (LA22_0==46) ) { - alt22=1; - } - else if ( (LA22_0==38) ) { - alt22=2; - } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 22, 0, input); - - throw nvae; - } - switch (alt22) { - case 1 : - // Lua.g:121:4: '[' e= exp ']' - { - match(input,46,FOLLOW_46_in_varSuffix1256); if (state.failed) return ; - pushFollow(FOLLOW_exp_in_varSuffix1260); - e=exp(); - - state._fsp--; - if (state.failed) return ; - match(input,47,FOLLOW_47_in_varSuffix1262); if (state.failed) return ; - if ( state.backtracking==0 ) { - ((var_scope)var_stack.peek()).current =((var_scope)var_stack.peek()).current.indexVariable(e); - } - - } - break; - case 2 : - // Lua.g:122:5: '.' n2= NAME - { - match(input,38,FOLLOW_38_in_varSuffix1275); if (state.failed) return ; - n2=(Token)match(input,NAME,FOLLOW_NAME_in_varSuffix1279); if (state.failed) return ; - if ( state.backtracking==0 ) { - ((var_scope)var_stack.peek()).current =((var_scope)var_stack.peek()).current.fieldVariable((n2!=null?n2.getText():null)); - } - - } - break; - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - } - return ; - } - // $ANTLR end "varSuffix" - - protected static class prefixexp_scope { - LSVariable current; - } - protected Stack prefixexp_stack = new Stack(); - - - // $ANTLR start "prefixexp" - // Lua.g:126:1: prefixexp returns [LSVariable v] : e= varOrExp (n= nameAndArgs[$prefixexp::current] )* ; - public final LSVariable prefixexp() throws RecognitionException { - prefixexp_stack.push(new prefixexp_scope()); - LSVariable v = null; - - LSVariable e = null; - - LSVariable n = null; - - - try { - // Lua.g:128:2: (e= varOrExp (n= nameAndArgs[$prefixexp::current] )* ) - // Lua.g:128:4: e= varOrExp (n= nameAndArgs[$prefixexp::current] )* - { - pushFollow(FOLLOW_varOrExp_in_prefixexp1311); - e=varOrExp(); - - state._fsp--; - if (state.failed) return v; - if ( state.backtracking==0 ) { - ((prefixexp_scope)prefixexp_stack.peek()).current =e; - } - // Lua.g:129:3: (n= nameAndArgs[$prefixexp::current] )* - loop23: - do { - int alt23=2; - alt23 = dfa23.predict(input); - switch (alt23) { - case 1 : - // Lua.g:129:4: n= nameAndArgs[$prefixexp::current] - { - pushFollow(FOLLOW_nameAndArgs_in_prefixexp1321); - n=nameAndArgs(((prefixexp_scope)prefixexp_stack.peek()).current); - - state._fsp--; - if (state.failed) return v; - if ( state.backtracking==0 ) { - ((prefixexp_scope)prefixexp_stack.peek()).current =n; - } - - } - break; - - default : - break loop23; - } - } while (true); - - if ( state.backtracking==0 ) { - v =((prefixexp_scope)prefixexp_stack.peek()).current; - } - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - prefixexp_stack.pop(); - } - return v; - } - // $ANTLR end "prefixexp" - - protected static class functioncall_scope { - LSVariable current; - } - protected Stack functioncall_stack = new Stack(); - - - // $ANTLR start "functioncall" - // Lua.g:133:1: functioncall returns [LSVariable v] : e= varOrExp (n= nameAndArgs[$functioncall::current] )+ ; - public final LSVariable functioncall() throws RecognitionException { - functioncall_stack.push(new functioncall_scope()); - LSVariable v = null; - - LSVariable e = null; - - LSVariable n = null; - - - try { - // Lua.g:135:2: (e= varOrExp (n= nameAndArgs[$functioncall::current] )+ ) - // Lua.g:135:4: e= varOrExp (n= nameAndArgs[$functioncall::current] )+ - { - pushFollow(FOLLOW_varOrExp_in_functioncall1352); - e=varOrExp(); - - state._fsp--; - if (state.failed) return v; - if ( state.backtracking==0 ) { - ((functioncall_scope)functioncall_stack.peek()).current =e; - } - // Lua.g:136:3: (n= nameAndArgs[$functioncall::current] )+ - int cnt24=0; - loop24: - do { - int alt24=2; - alt24 = dfa24.predict(input); - switch (alt24) { - case 1 : - // Lua.g:136:4: n= nameAndArgs[$functioncall::current] - { - pushFollow(FOLLOW_nameAndArgs_in_functioncall1362); - n=nameAndArgs(((functioncall_scope)functioncall_stack.peek()).current); - - state._fsp--; - if (state.failed) return v; - if ( state.backtracking==0 ) { - ((functioncall_scope)functioncall_stack.peek()).current =n; - } - - } - break; - - default : - if ( cnt24 >= 1 ) break loop24; - if (state.backtracking>0) {state.failed=true; return v;} - EarlyExitException eee = - new EarlyExitException(24, input); - throw eee; - } - cnt24++; - } while (true); - - if ( state.backtracking==0 ) { - v =((functioncall_scope)functioncall_stack.peek()).current; - } - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - functioncall_stack.pop(); - } - return v; - } - // $ANTLR end "functioncall" - - - // $ANTLR start "varOrExp" - // Lua.g:140:1: varOrExp returns [LSVariable v] : ( var | '(' exp ')' ); - public final LSVariable varOrExp() throws RecognitionException { - LSVariable v = null; - - LSVariable var32 = null; - - LSExpression exp33 = null; - - - try { - // Lua.g:141:2: ( var | '(' exp ')' ) - int alt25=2; - int LA25_0 = input.LA(1); - - if ( (LA25_0==NAME) ) { - alt25=1; - } - else if ( (LA25_0==44) ) { - int LA25_2 = input.LA(2); - - if ( (synpred42_Lua()) ) { - alt25=1; - } - else if ( (true) ) { - alt25=2; - } - else { - if (state.backtracking>0) {state.failed=true; return v;} - NoViableAltException nvae = - new NoViableAltException("", 25, 2, input); - - throw nvae; - } - } - else { - if (state.backtracking>0) {state.failed=true; return v;} - NoViableAltException nvae = - new NoViableAltException("", 25, 0, input); - - throw nvae; - } - switch (alt25) { - case 1 : - // Lua.g:141:4: var - { - pushFollow(FOLLOW_var_in_varOrExp1386); - var32=var(); - - state._fsp--; - if (state.failed) return v; - if ( state.backtracking==0 ) { - v =var32; - } - - } - break; - case 2 : - // Lua.g:142:4: '(' exp ')' - { - match(input,44,FOLLOW_44_in_varOrExp1401); if (state.failed) return v; - pushFollow(FOLLOW_exp_in_varOrExp1403); - exp33=exp(); - - state._fsp--; - if (state.failed) return v; - match(input,45,FOLLOW_45_in_varOrExp1405); if (state.failed) return v; - if ( state.backtracking==0 ) { - v =LSVariable.parenthesesVariable(exp33); - } - - } - break; - - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - } - return v; - } - // $ANTLR end "varOrExp" - - - // $ANTLR start "nameAndArgs" - // Lua.g:145:1: nameAndArgs[LSVariable vin] returns [LSVariable v] : ( ':' n= NAME )? a= args ; - public final LSVariable nameAndArgs(LSVariable vin) throws RecognitionException { - LSVariable v = null; - - Token n=null; - List a = null; - - - String method=null; - try { - // Lua.g:147:2: ( ( ':' n= NAME )? a= args ) - // Lua.g:147:4: ( ':' n= NAME )? a= args - { - // Lua.g:147:4: ( ':' n= NAME )? - int alt26=2; - int LA26_0 = input.LA(1); - - if ( (LA26_0==39) ) { - alt26=1; - } - switch (alt26) { - case 1 : - // Lua.g:147:5: ':' n= NAME - { - match(input,39,FOLLOW_39_in_nameAndArgs1431); if (state.failed) return v; - n=(Token)match(input,NAME,FOLLOW_NAME_in_nameAndArgs1435); if (state.failed) return v; - if ( state.backtracking==0 ) { - method=(n!=null?n.getText():null); - } - - } - break; - - } - - pushFollow(FOLLOW_args_in_nameAndArgs1452); - a=args(); - - state._fsp--; - if (state.failed) return v; - if ( state.backtracking==0 ) { - v =((method==null)? - vin.callFuncVariable(a): - vin.callMethVariable(method,a)); - } - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - } - return v; - } - // $ANTLR end "nameAndArgs" - - - // $ANTLR start "args" - // Lua.g:153:1: args returns [List exprs] : ( '(' (e= explist1 )? ')' | t= tableconstructor | s= string ); - public final List args() throws RecognitionException { - List exprs = null; - - List e = null; - - LSExpression t = null; - - LSExpression s = null; - - - exprs = new ArrayList(); - try { - // Lua.g:155:2: ( '(' (e= explist1 )? ')' | t= tableconstructor | s= string ) - int alt28=3; - switch ( input.LA(1) ) { - case 44: - { - alt28=1; - } - break; - case 48: - { - alt28=2; - } - break; - case NORMALSTRING: - case CHARSTRING: - case LONGSTRING: - { - alt28=3; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return exprs;} - NoViableAltException nvae = - new NoViableAltException("", 28, 0, input); - - throw nvae; - } - - switch (alt28) { - case 1 : - // Lua.g:155:5: '(' (e= explist1 )? ')' - { - match(input,44,FOLLOW_44_in_args1476); if (state.failed) return exprs; - // Lua.g:155:9: (e= explist1 )? - int alt27=2; - int LA27_0 = input.LA(1); - - if ( ((LA27_0>=NAME && LA27_0<=LONGSTRING)||LA27_0==30||(LA27_0>=40 && LA27_0<=44)||LA27_0==48||LA27_0==51||(LA27_0>=65 && LA27_0<=66)) ) { - alt27=1; - } - switch (alt27) { - case 1 : - // Lua.g:155:10: e= explist1 - { - pushFollow(FOLLOW_explist1_in_args1481); - e=explist1(); - - state._fsp--; - if (state.failed) return exprs; - if ( state.backtracking==0 ) { - exprs =e; - } - - } - break; - - } - - match(input,45,FOLLOW_45_in_args1487); if (state.failed) return exprs; - - } - break; - case 2 : - // Lua.g:156:4: t= tableconstructor - { - pushFollow(FOLLOW_tableconstructor_in_args1495); - t=tableconstructor(); - - state._fsp--; - if (state.failed) return exprs; - if ( state.backtracking==0 ) { - exprs.add(t); - } - - } - break; - case 3 : - // Lua.g:157:4: s= string - { - pushFollow(FOLLOW_string_in_args1505); - s=string(); - - state._fsp--; - if (state.failed) return exprs; - if ( state.backtracking==0 ) { - exprs.add(s); - } - - } - break; - - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - } - return exprs; - } - // $ANTLR end "args" - - - // $ANTLR start "function" - // Lua.g:160:1: function returns [LSFunction f] : 'function' b= funcbody ; - public final LSFunction function() throws RecognitionException { - LSFunction f = null; - - LSFunction b = null; - - - try { - // Lua.g:161:2: ( 'function' b= funcbody ) - // Lua.g:161:4: 'function' b= funcbody - { - match(input,30,FOLLOW_30_in_function1532); if (state.failed) return f; - pushFollow(FOLLOW_funcbody_in_function1536); - b=funcbody(); - - state._fsp--; - if (state.failed) return f; - if ( state.backtracking==0 ) { - f = b; - } - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - } - return f; - } - // $ANTLR end "function" - - - // $ANTLR start "funcbody" - // Lua.g:164:1: funcbody returns [LSFunction f] : '(' ( parlist1[f] )? ')' funcblock[f] 'end' ; - public final LSFunction funcbody() throws RecognitionException { - LSFunction f = null; - - - f = new LSFunction(); - ((funcblock_scope)funcblock_stack.peek()).func.functions.add(f); - - try { - // Lua.g:169:2: ( '(' ( parlist1[f] )? ')' funcblock[f] 'end' ) - // Lua.g:169:4: '(' ( parlist1[f] )? ')' funcblock[f] 'end' - { - if ( state.backtracking==0 ) { - CHK.pushScope("func",true); - } - match(input,44,FOLLOW_44_in_funcbody1561); if (state.failed) return f; - // Lua.g:169:38: ( parlist1[f] )? - int alt29=2; - int LA29_0 = input.LA(1); - - if ( (LA29_0==NAME||LA29_0==43) ) { - alt29=1; - } - switch (alt29) { - case 1 : - // Lua.g:169:39: parlist1[f] - { - pushFollow(FOLLOW_parlist1_in_funcbody1564); - parlist1(f); - - state._fsp--; - if (state.failed) return f; - - } - break; - - } - - match(input,45,FOLLOW_45_in_funcbody1570); if (state.failed) return f; - pushFollow(FOLLOW_funcblock_in_funcbody1572); - funcblock(f); - - state._fsp--; - if (state.failed) return f; - match(input,23,FOLLOW_23_in_funcbody1575); if (state.failed) return f; - if ( state.backtracking==0 ) { - CHK.popScope("func"); - } - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - } - return f; - } - // $ANTLR end "funcbody" - - - // $ANTLR start "parlist1" - // Lua.g:172:1: parlist1[LSFunction f] : ( namelist ( ',' '...' )? | '...' ); - public final void parlist1(LSFunction f) throws RecognitionException { - List namelist34 = null; - - - try { - // Lua.g:173:2: ( namelist ( ',' '...' )? | '...' ) - int alt31=2; - int LA31_0 = input.LA(1); - - if ( (LA31_0==NAME) ) { - alt31=1; - } - else if ( (LA31_0==43) ) { - alt31=2; - } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 31, 0, input); - - throw nvae; - } - switch (alt31) { - case 1 : - // Lua.g:173:4: namelist ( ',' '...' )? - { - pushFollow(FOLLOW_namelist_in_parlist11591); - namelist34=namelist(); - - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - f.setParameterNames(CHK.declare(namelist34)); - } - // Lua.g:173:66: ( ',' '...' )? - int alt30=2; - int LA30_0 = input.LA(1); - - if ( (LA30_0==28) ) { - alt30=1; - } - switch (alt30) { - case 1 : - // Lua.g:173:67: ',' '...' - { - match(input,28,FOLLOW_28_in_parlist11596); if (state.failed) return ; - match(input,43,FOLLOW_43_in_parlist11598); if (state.failed) return ; - if ( state.backtracking==0 ) { - f.isvararg=true; - } - - } - break; - - } - - - } - break; - case 2 : - // Lua.g:174:4: '...' - { - match(input,43,FOLLOW_43_in_parlist11608); if (state.failed) return ; - if ( state.backtracking==0 ) { - f.isvararg=true; - } - - } - break; - - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - } - return ; - } - // $ANTLR end "parlist1" - - - // $ANTLR start "tableconstructor" - // Lua.g:177:1: tableconstructor returns [LSExpression e] : '{' ( fieldlist[fields] )? '}' ; - public final LSExpression tableconstructor() throws RecognitionException { - LSExpression e = null; - - List fields = new ArrayList(); - try { - // Lua.g:179:2: ( '{' ( fieldlist[fields] )? '}' ) - // Lua.g:179:4: '{' ( fieldlist[fields] )? '}' - { - match(input,48,FOLLOW_48_in_tableconstructor1631); if (state.failed) return e; - // Lua.g:179:8: ( fieldlist[fields] )? - int alt32=2; - int LA32_0 = input.LA(1); - - if ( ((LA32_0>=NAME && LA32_0<=LONGSTRING)||LA32_0==30||(LA32_0>=40 && LA32_0<=44)||LA32_0==46||LA32_0==48||LA32_0==51||(LA32_0>=65 && LA32_0<=66)) ) { - alt32=1; - } - switch (alt32) { - case 1 : - // Lua.g:179:9: fieldlist[fields] - { - pushFollow(FOLLOW_fieldlist_in_tableconstructor1634); - fieldlist(fields); - - state._fsp--; - if (state.failed) return e; - - } - break; - - } - - match(input,49,FOLLOW_49_in_tableconstructor1639); if (state.failed) return e; - if ( state.backtracking==0 ) { - e =LSExpression.tableConstructorExpression(fields); - } - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - } - return e; - } - // $ANTLR end "tableconstructor" - - - // $ANTLR start "fieldlist" - // Lua.g:182:1: fieldlist[List fields] : field[fields] ( fieldsep field[fields] )* ( fieldsep )? ; - public final void fieldlist(List fields) throws RecognitionException { - try { - // Lua.g:183:2: ( field[fields] ( fieldsep field[fields] )* ( fieldsep )? ) - // Lua.g:183:4: field[fields] ( fieldsep field[fields] )* ( fieldsep )? - { - pushFollow(FOLLOW_field_in_fieldlist1654); - field(fields); - - state._fsp--; - if (state.failed) return ; - // Lua.g:183:19: ( fieldsep field[fields] )* - loop33: - do { - int alt33=2; - int LA33_0 = input.LA(1); - - if ( (LA33_0==20||LA33_0==28) ) { - int LA33_1 = input.LA(2); - - if ( ((LA33_1>=NAME && LA33_1<=LONGSTRING)||LA33_1==30||(LA33_1>=40 && LA33_1<=44)||LA33_1==46||LA33_1==48||LA33_1==51||(LA33_1>=65 && LA33_1<=66)) ) { - alt33=1; - } - - - } - - - switch (alt33) { - case 1 : - // Lua.g:183:20: fieldsep field[fields] - { - pushFollow(FOLLOW_fieldsep_in_fieldlist1659); - fieldsep(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_field_in_fieldlist1661); - field(fields); - - state._fsp--; - if (state.failed) return ; - - } - break; - - default : - break loop33; - } - } while (true); - - // Lua.g:183:46: ( fieldsep )? - int alt34=2; - int LA34_0 = input.LA(1); - - if ( (LA34_0==20||LA34_0==28) ) { - alt34=1; - } - switch (alt34) { - case 1 : - // Lua.g:183:47: fieldsep - { - pushFollow(FOLLOW_fieldsep_in_fieldlist1668); - fieldsep(); - - state._fsp--; - if (state.failed) return ; - - } - break; - - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - } - return ; - } - // $ANTLR end "fieldlist" - - - // $ANTLR start "field" - // Lua.g:186:1: field[List fields] : ( '[' k= exp ']' '=' e= exp | n= NAME '=' e= exp | e= exp ); - public final void field(List fields) throws RecognitionException { - Token n=null; - LSExpression k = null; - - LSExpression e = null; - - - try { - // Lua.g:187:2: ( '[' k= exp ']' '=' e= exp | n= NAME '=' e= exp | e= exp ) - int alt35=3; - switch ( input.LA(1) ) { - case 46: - { - alt35=1; - } - break; - case NAME: - { - int LA35_2 = input.LA(2); - - if ( (LA35_2==21) ) { - alt35=2; - } - else if ( (LA35_2==EOF||(LA35_2>=NORMALSTRING && LA35_2<=LONGSTRING)||LA35_2==20||LA35_2==28||(LA35_2>=38 && LA35_2<=39)||LA35_2==44||LA35_2==46||(LA35_2>=48 && LA35_2<=64)) ) { - alt35=3; - } - else { - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 35, 2, input); - - throw nvae; - } - } - break; - case INT: - case FLOAT1: - case FLOAT2: - case FLOAT3: - case EXP: - case HEX: - case NORMALSTRING: - case CHARSTRING: - case LONGSTRING: - case 30: - case 40: - case 41: - case 42: - case 43: - case 44: - case 48: - case 51: - case 65: - case 66: - { - alt35=3; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return ;} - NoViableAltException nvae = - new NoViableAltException("", 35, 0, input); - - throw nvae; - } - - switch (alt35) { - case 1 : - // Lua.g:187:4: '[' k= exp ']' '=' e= exp - { - match(input,46,FOLLOW_46_in_field1683); if (state.failed) return ; - pushFollow(FOLLOW_exp_in_field1687); - k=exp(); - - state._fsp--; - if (state.failed) return ; - match(input,47,FOLLOW_47_in_field1689); if (state.failed) return ; - match(input,21,FOLLOW_21_in_field1691); if (state.failed) return ; - pushFollow(FOLLOW_exp_in_field1695); - e=exp(); - - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - fields.add(LSField.keyValueField(k,e)); - } - - } - break; - case 2 : - // Lua.g:188:4: n= NAME '=' e= exp - { - n=(Token)match(input,NAME,FOLLOW_NAME_in_field1706); if (state.failed) return ; - match(input,21,FOLLOW_21_in_field1708); if (state.failed) return ; - pushFollow(FOLLOW_exp_in_field1712); - e=exp(); - - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - fields.add(LSField.nameValueField((n!=null?n.getText():null),e)); - } - - } - break; - case 3 : - // Lua.g:189:4: e= exp - { - pushFollow(FOLLOW_exp_in_field1728); - e=exp(); - - state._fsp--; - if (state.failed) return ; - if ( state.backtracking==0 ) { - fields.add(LSField.valueField(e)); - } - - } - break; - - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - } - return ; - } - // $ANTLR end "field" - - - // $ANTLR start "fieldsep" - // Lua.g:192:1: fieldsep : ( ',' | ';' ); - public final void fieldsep() throws RecognitionException { - try { - // Lua.g:193:2: ( ',' | ';' ) - // Lua.g: - { - if ( input.LA(1)==20||input.LA(1)==28 ) { - input.consume(); - state.errorRecovery=false;state.failed=false; - } - else { - if (state.backtracking>0) {state.failed=true; return ;} - MismatchedSetException mse = new MismatchedSetException(null,input); - throw mse; - } - - - } - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - } - return ; - } - // $ANTLR end "fieldsep" - - - // $ANTLR start "binop" - // Lua.g:197:1: binop returns [BinOp op] : ( '+' | '-' | '*' | '/' | '^' | '%' | '..' | '<' | '<=' | '>' | '>=' | '==' | '~=' | 'and' | 'or' ); - public final BinOp binop() throws RecognitionException { - BinOp op = null; - - try { - // Lua.g:198:2: ( '+' | '-' | '*' | '/' | '^' | '%' | '..' | '<' | '<=' | '>' | '>=' | '==' | '~=' | 'and' | 'or' ) - int alt36=15; - switch ( input.LA(1) ) { - case 50: - { - alt36=1; - } - break; - case 51: - { - alt36=2; - } - break; - case 52: - { - alt36=3; - } - break; - case 53: - { - alt36=4; - } - break; - case 54: - { - alt36=5; - } - break; - case 55: - { - alt36=6; - } - break; - case 56: - { - alt36=7; - } - break; - case 57: - { - alt36=8; - } - break; - case 58: - { - alt36=9; - } - break; - case 59: - { - alt36=10; - } - break; - case 60: - { - alt36=11; - } - break; - case 61: - { - alt36=12; - } - break; - case 62: - { - alt36=13; - } - break; - case 63: - { - alt36=14; - } - break; - case 64: - { - alt36=15; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return op;} - NoViableAltException nvae = - new NoViableAltException("", 36, 0, input); - - throw nvae; - } - - switch (alt36) { - case 1 : - // Lua.g:198:4: '+' - { - match(input,50,FOLLOW_50_in_binop1781); if (state.failed) return op; - if ( state.backtracking==0 ) { - op =BinOp.ADD; - } - - } - break; - case 2 : - // Lua.g:199:4: '-' - { - match(input,51,FOLLOW_51_in_binop1790); if (state.failed) return op; - if ( state.backtracking==0 ) { - op =BinOp.SUB; - } - - } - break; - case 3 : - // Lua.g:200:4: '*' - { - match(input,52,FOLLOW_52_in_binop1800); if (state.failed) return op; - if ( state.backtracking==0 ) { - op =BinOp.MUL; - } - - } - break; - case 4 : - // Lua.g:201:4: '/' - { - match(input,53,FOLLOW_53_in_binop1810); if (state.failed) return op; - if ( state.backtracking==0 ) { - op =BinOp.DIV; - } - - } - break; - case 5 : - // Lua.g:202:4: '^' - { - match(input,54,FOLLOW_54_in_binop1820); if (state.failed) return op; - if ( state.backtracking==0 ) { - op =BinOp.POW; - } - - } - break; - case 6 : - // Lua.g:203:4: '%' - { - match(input,55,FOLLOW_55_in_binop1830); if (state.failed) return op; - if ( state.backtracking==0 ) { - op =BinOp.MOD; - } - - } - break; - case 7 : - // Lua.g:204:4: '..' - { - match(input,56,FOLLOW_56_in_binop1840); if (state.failed) return op; - if ( state.backtracking==0 ) { - op =BinOp.CONCAT; - } - - } - break; - case 8 : - // Lua.g:205:4: '<' - { - match(input,57,FOLLOW_57_in_binop1849); if (state.failed) return op; - if ( state.backtracking==0 ) { - op =BinOp.LT; - } - - } - break; - case 9 : - // Lua.g:206:4: '<=' - { - match(input,58,FOLLOW_58_in_binop1858); if (state.failed) return op; - if ( state.backtracking==0 ) { - op =BinOp.LTEQ; - } - - } - break; - case 10 : - // Lua.g:207:4: '>' - { - match(input,59,FOLLOW_59_in_binop1867); if (state.failed) return op; - if ( state.backtracking==0 ) { - op =BinOp.GT; - } - - } - break; - case 11 : - // Lua.g:208:4: '>=' - { - match(input,60,FOLLOW_60_in_binop1876); if (state.failed) return op; - if ( state.backtracking==0 ) { - op =BinOp.GTEQ; - } - - } - break; - case 12 : - // Lua.g:209:4: '==' - { - match(input,61,FOLLOW_61_in_binop1885); if (state.failed) return op; - if ( state.backtracking==0 ) { - op =BinOp.EQ; - } - - } - break; - case 13 : - // Lua.g:210:4: '~=' - { - match(input,62,FOLLOW_62_in_binop1894); if (state.failed) return op; - if ( state.backtracking==0 ) { - op =BinOp.NEQ; - } - - } - break; - case 14 : - // Lua.g:211:4: 'and' - { - match(input,63,FOLLOW_63_in_binop1903); if (state.failed) return op; - if ( state.backtracking==0 ) { - op =BinOp.AND; ((funcblock_scope)funcblock_stack.peek()).func.hasandlogic=true; - } - - } - break; - case 15 : - // Lua.g:212:4: 'or' - { - match(input,64,FOLLOW_64_in_binop1911); if (state.failed) return op; - if ( state.backtracking==0 ) { - op =BinOp.OR; ((funcblock_scope)funcblock_stack.peek()).func.hasorlogic=true; - } - - } - break; - - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - } - return op; - } - // $ANTLR end "binop" - - - // $ANTLR start "unop" - // Lua.g:215:1: unop returns [UnOp op] : ( '-' | 'not' | '#' ); - public final UnOp unop() throws RecognitionException { - UnOp op = null; - - try { - // Lua.g:216:2: ( '-' | 'not' | '#' ) - int alt37=3; - switch ( input.LA(1) ) { - case 51: - { - alt37=1; - } - break; - case 65: - { - alt37=2; - } - break; - case 66: - { - alt37=3; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return op;} - NoViableAltException nvae = - new NoViableAltException("", 37, 0, input); - - throw nvae; - } - - switch (alt37) { - case 1 : - // Lua.g:216:4: '-' - { - match(input,51,FOLLOW_51_in_unop1930); if (state.failed) return op; - if ( state.backtracking==0 ) { - op =UnOp.NEG; - } - - } - break; - case 2 : - // Lua.g:217:4: 'not' - { - match(input,65,FOLLOW_65_in_unop1940); if (state.failed) return op; - if ( state.backtracking==0 ) { - op =UnOp.NOT; - } - - } - break; - case 3 : - // Lua.g:218:4: '#' - { - match(input,66,FOLLOW_66_in_unop1949); if (state.failed) return op; - if ( state.backtracking==0 ) { - op =UnOp.LEN; - } - - } - break; - - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - } - return op; - } - // $ANTLR end "unop" - - public static class number_return extends ParserRuleReturnScope { - }; - - // $ANTLR start "number" - // Lua.g:221:1: number : ( ( '-' )? INT | ( '-' )? FLOAT1 | ( '-' )? FLOAT2 | ( '-' )? FLOAT3 | ( '-' )? EXP | HEX ); - public final LuaParser.number_return number() throws RecognitionException { - LuaParser.number_return retval = new LuaParser.number_return(); - retval.start = input.LT(1); - - try { - // Lua.g:222:2: ( ( '-' )? INT | ( '-' )? FLOAT1 | ( '-' )? FLOAT2 | ( '-' )? FLOAT3 | ( '-' )? EXP | HEX ) - int alt43=6; - switch ( input.LA(1) ) { - case 51: - { - switch ( input.LA(2) ) { - case EXP: - { - alt43=5; - } - break; - case FLOAT1: - { - alt43=2; - } - break; - case FLOAT3: - { - alt43=4; - } - break; - case FLOAT2: - { - alt43=3; - } - break; - case INT: - { - alt43=1; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return retval;} - NoViableAltException nvae = - new NoViableAltException("", 43, 1, input); - - throw nvae; - } - - } - break; - case INT: - { - alt43=1; - } - break; - case FLOAT1: - { - alt43=2; - } - break; - case FLOAT2: - { - alt43=3; - } - break; - case FLOAT3: - { - alt43=4; - } - break; - case EXP: - { - alt43=5; - } - break; - case HEX: - { - alt43=6; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return retval;} - NoViableAltException nvae = - new NoViableAltException("", 43, 0, input); - - throw nvae; - } - - switch (alt43) { - case 1 : - // Lua.g:222:4: ( '-' )? INT - { - // Lua.g:222:4: ( '-' )? - int alt38=2; - int LA38_0 = input.LA(1); - - if ( (LA38_0==51) ) { - alt38=1; - } - switch (alt38) { - case 1 : - // Lua.g:222:5: '-' - { - match(input,51,FOLLOW_51_in_number1967); if (state.failed) return retval; - - } - break; - - } - - match(input,INT,FOLLOW_INT_in_number1971); if (state.failed) return retval; - - } - break; - case 2 : - // Lua.g:223:4: ( '-' )? FLOAT1 - { - // Lua.g:223:4: ( '-' )? - int alt39=2; - int LA39_0 = input.LA(1); - - if ( (LA39_0==51) ) { - alt39=1; - } - switch (alt39) { - case 1 : - // Lua.g:223:5: '-' - { - match(input,51,FOLLOW_51_in_number1978); if (state.failed) return retval; - - } - break; - - } - - match(input,FLOAT1,FOLLOW_FLOAT1_in_number1982); if (state.failed) return retval; - - } - break; - case 3 : - // Lua.g:224:4: ( '-' )? FLOAT2 - { - // Lua.g:224:4: ( '-' )? - int alt40=2; - int LA40_0 = input.LA(1); - - if ( (LA40_0==51) ) { - alt40=1; - } - switch (alt40) { - case 1 : - // Lua.g:224:5: '-' - { - match(input,51,FOLLOW_51_in_number1989); if (state.failed) return retval; - - } - break; - - } - - match(input,FLOAT2,FOLLOW_FLOAT2_in_number1993); if (state.failed) return retval; - - } - break; - case 4 : - // Lua.g:225:4: ( '-' )? FLOAT3 - { - // Lua.g:225:4: ( '-' )? - int alt41=2; - int LA41_0 = input.LA(1); - - if ( (LA41_0==51) ) { - alt41=1; - } - switch (alt41) { - case 1 : - // Lua.g:225:5: '-' - { - match(input,51,FOLLOW_51_in_number2000); if (state.failed) return retval; - - } - break; - - } - - match(input,FLOAT3,FOLLOW_FLOAT3_in_number2004); if (state.failed) return retval; - - } - break; - case 5 : - // Lua.g:226:4: ( '-' )? EXP - { - // Lua.g:226:4: ( '-' )? - int alt42=2; - int LA42_0 = input.LA(1); - - if ( (LA42_0==51) ) { - alt42=1; - } - switch (alt42) { - case 1 : - // Lua.g:226:5: '-' - { - match(input,51,FOLLOW_51_in_number2011); if (state.failed) return retval; - - } - break; - - } - - match(input,EXP,FOLLOW_EXP_in_number2015); if (state.failed) return retval; - - } - break; - case 6 : - // Lua.g:227:4: HEX - { - match(input,HEX,FOLLOW_HEX_in_number2021); if (state.failed) return retval; - - } - break; - - } - retval.stop = input.LT(-1); - - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - } - return retval; - } - // $ANTLR end "number" - - - // $ANTLR start "string" - // Lua.g:230:1: string returns [LSExpression e] : ( NORMALSTRING | CHARSTRING | LONGSTRING ); - public final LSExpression string() throws RecognitionException { - LSExpression e = null; - - Token NORMALSTRING35=null; - Token CHARSTRING36=null; - Token LONGSTRING37=null; - - try { - // Lua.g:231:2: ( NORMALSTRING | CHARSTRING | LONGSTRING ) - int alt44=3; - switch ( input.LA(1) ) { - case NORMALSTRING: - { - alt44=1; - } - break; - case CHARSTRING: - { - alt44=2; - } - break; - case LONGSTRING: - { - alt44=3; - } - break; - default: - if (state.backtracking>0) {state.failed=true; return e;} - NoViableAltException nvae = - new NoViableAltException("", 44, 0, input); - - throw nvae; - } - - switch (alt44) { - case 1 : - // Lua.g:231:4: NORMALSTRING - { - NORMALSTRING35=(Token)match(input,NORMALSTRING,FOLLOW_NORMALSTRING_in_string2037); if (state.failed) return e; - if ( state.backtracking==0 ) { - e =LSExpression.normalStringExpression((NORMALSTRING35!=null?NORMALSTRING35.getText():null)); - } - - } - break; - case 2 : - // Lua.g:232:4: CHARSTRING - { - CHARSTRING36=(Token)match(input,CHARSTRING,FOLLOW_CHARSTRING_in_string2044); if (state.failed) return e; - if ( state.backtracking==0 ) { - e =LSExpression.charStringExpression((CHARSTRING36!=null?CHARSTRING36.getText():null)); - } - - } - break; - case 3 : - // Lua.g:233:4: LONGSTRING - { - LONGSTRING37=(Token)match(input,LONGSTRING,FOLLOW_LONGSTRING_in_string2053); if (state.failed) return e; - if ( state.backtracking==0 ) { - e =LSExpression.longStringExpression((LONGSTRING37!=null?LONGSTRING37.getText():null)); - } - - } - break; - - } - } - catch (RecognitionException re) { - reportError(re); - recover(input,re); - } - finally { - } - return e; - } - // $ANTLR end "string" - - // $ANTLR start synpred5_Lua - public final void synpred5_Lua_fragment() throws RecognitionException { - // Lua.g:41:4: ( varlist1 '=' explist1 ) - // Lua.g:41:4: varlist1 '=' explist1 - { - pushFollow(FOLLOW_varlist1_in_synpred5_Lua159); - varlist1(); - - state._fsp--; - if (state.failed) return ; - match(input,21,FOLLOW_21_in_synpred5_Lua161); if (state.failed) return ; - pushFollow(FOLLOW_explist1_in_synpred5_Lua163); - explist1(); - - state._fsp--; - if (state.failed) return ; - - } - } - // $ANTLR end synpred5_Lua - - // $ANTLR start synpred6_Lua - public final void synpred6_Lua_fragment() throws RecognitionException { - // Lua.g:42:4: ( functioncall ) - // Lua.g:42:4: functioncall - { - pushFollow(FOLLOW_functioncall_in_synpred6_Lua183); - functioncall(); - - state._fsp--; - if (state.failed) return ; - - } - } - // $ANTLR end synpred6_Lua - - // $ANTLR start synpred12_Lua - public final void synpred12_Lua_fragment() throws RecognitionException { - LSExpression e1 = null; - - LSExpression e2 = null; - - LSExpression e3 = null; - - - // Lua.g:50:4: ( 'for' NAME '=' e1= exp ',' e2= exp ( ',' e3= exp )? 'do' block 'end' ) - // Lua.g:50:4: 'for' NAME '=' e1= exp ',' e2= exp ( ',' e3= exp )? 'do' block 'end' - { - match(input,27,FOLLOW_27_in_synpred12_Lua445); if (state.failed) return ; - match(input,NAME,FOLLOW_NAME_in_synpred12_Lua449); if (state.failed) return ; - match(input,21,FOLLOW_21_in_synpred12_Lua453); if (state.failed) return ; - pushFollow(FOLLOW_exp_in_synpred12_Lua457); - e1=exp(); - - state._fsp--; - if (state.failed) return ; - match(input,28,FOLLOW_28_in_synpred12_Lua459); if (state.failed) return ; - pushFollow(FOLLOW_exp_in_synpred12_Lua463); - e2=exp(); - - state._fsp--; - if (state.failed) return ; - // Lua.g:50:94: ( ',' e3= exp )? - int alt47=2; - int LA47_0 = input.LA(1); - - if ( (LA47_0==28) ) { - alt47=1; - } - switch (alt47) { - case 1 : - // Lua.g:50:95: ',' e3= exp - { - match(input,28,FOLLOW_28_in_synpred12_Lua466); if (state.failed) return ; - pushFollow(FOLLOW_exp_in_synpred12_Lua470); - e3=exp(); - - state._fsp--; - if (state.failed) return ; - - } - break; - - } - - match(input,22,FOLLOW_22_in_synpred12_Lua474); if (state.failed) return ; - pushFollow(FOLLOW_block_in_synpred12_Lua478); - block(); - - state._fsp--; - if (state.failed) return ; - match(input,23,FOLLOW_23_in_synpred12_Lua482); if (state.failed) return ; - - } - } - // $ANTLR end synpred12_Lua - - // $ANTLR start synpred13_Lua - public final void synpred13_Lua_fragment() throws RecognitionException { - // Lua.g:52:4: ( 'for' namelist 'in' explist1 'do' block 'end' ) - // Lua.g:52:4: 'for' namelist 'in' explist1 'do' block 'end' - { - match(input,27,FOLLOW_27_in_synpred13_Lua528); if (state.failed) return ; - pushFollow(FOLLOW_namelist_in_synpred13_Lua533); - namelist(); - - state._fsp--; - if (state.failed) return ; - match(input,29,FOLLOW_29_in_synpred13_Lua537); if (state.failed) return ; - pushFollow(FOLLOW_explist1_in_synpred13_Lua539); - explist1(); - - state._fsp--; - if (state.failed) return ; - match(input,22,FOLLOW_22_in_synpred13_Lua541); if (state.failed) return ; - pushFollow(FOLLOW_block_in_synpred13_Lua545); - block(); - - state._fsp--; - if (state.failed) return ; - match(input,23,FOLLOW_23_in_synpred13_Lua548); if (state.failed) return ; - - } - } - // $ANTLR end synpred13_Lua - - // $ANTLR start synpred15_Lua - public final void synpred15_Lua_fragment() throws RecognitionException { - // Lua.g:55:4: ( 'local' 'function' NAME funcbody ) - // Lua.g:55:4: 'local' 'function' NAME funcbody - { - match(input,31,FOLLOW_31_in_synpred15_Lua610); if (state.failed) return ; - match(input,30,FOLLOW_30_in_synpred15_Lua612); if (state.failed) return ; - match(input,NAME,FOLLOW_NAME_in_synpred15_Lua614); if (state.failed) return ; - pushFollow(FOLLOW_funcbody_in_synpred15_Lua618); - funcbody(); - - state._fsp--; - if (state.failed) return ; - - } - } - // $ANTLR end synpred15_Lua - - // $ANTLR start synpred25_Lua - public final void synpred25_Lua_fragment() throws RecognitionException { - LSExpression e1 = null; - - - // Lua.g:93:5: (e1= exp ',' ) - // Lua.g:93:5: e1= exp ',' - { - pushFollow(FOLLOW_exp_in_synpred25_Lua960); - e1=exp(); - - state._fsp--; - if (state.failed) return ; - match(input,28,FOLLOW_28_in_synpred25_Lua962); if (state.failed) return ; - - } - } - // $ANTLR end synpred25_Lua - - // $ANTLR start synpred29_Lua - public final void synpred29_Lua_fragment() throws RecognitionException { - // Lua.g:101:5: ( number ) - // Lua.g:101:5: number - { - pushFollow(FOLLOW_number_in_synpred29_Lua1048); - number(); - - state._fsp--; - if (state.failed) return ; - - } - } - // $ANTLR end synpred29_Lua - - // $ANTLR start synpred35_Lua - public final void synpred35_Lua_fragment() throws RecognitionException { - LSExpression e2 = null; - - - // Lua.g:108:6: ( binop e2= exp ) - // Lua.g:108:6: binop e2= exp - { - pushFollow(FOLLOW_binop_in_synpred35_Lua1160); - binop(); - - state._fsp--; - if (state.failed) return ; - pushFollow(FOLLOW_exp_in_synpred35_Lua1164); - e2=exp(); - - state._fsp--; - if (state.failed) return ; - - } - } - // $ANTLR end synpred35_Lua - - // $ANTLR start synpred37_Lua - public final void synpred37_Lua_fragment() throws RecognitionException { - // Lua.g:115:7: ( varSuffix ) - // Lua.g:115:7: varSuffix - { - pushFollow(FOLLOW_varSuffix_in_synpred37_Lua1225); - varSuffix(); - - state._fsp--; - if (state.failed) return ; - - } - } - // $ANTLR end synpred37_Lua - - // $ANTLR start synpred40_Lua - public final void synpred40_Lua_fragment() throws RecognitionException { - LSVariable n = null; - - - // Lua.g:129:4: (n= nameAndArgs[$prefixexp::current] ) - // Lua.g:129:4: n= nameAndArgs[$prefixexp::current] - { - pushFollow(FOLLOW_nameAndArgs_in_synpred40_Lua1321); - n=nameAndArgs(((prefixexp_scope)prefixexp_stack.peek()).current); - - state._fsp--; - if (state.failed) return ; - - } - } - // $ANTLR end synpred40_Lua - - // $ANTLR start synpred41_Lua - public final void synpred41_Lua_fragment() throws RecognitionException { - LSVariable n = null; - - - // Lua.g:136:4: (n= nameAndArgs[$functioncall::current] ) - // Lua.g:136:4: n= nameAndArgs[$functioncall::current] - { - pushFollow(FOLLOW_nameAndArgs_in_synpred41_Lua1362); - n=nameAndArgs(((functioncall_scope)functioncall_stack.peek()).current); - - state._fsp--; - if (state.failed) return ; - - } - } - // $ANTLR end synpred41_Lua - - // $ANTLR start synpred42_Lua - public final void synpred42_Lua_fragment() throws RecognitionException { - // Lua.g:141:4: ( var ) - // Lua.g:141:4: var - { - pushFollow(FOLLOW_var_in_synpred42_Lua1386); - var(); - - state._fsp--; - if (state.failed) return ; - - } - } - // $ANTLR end synpred42_Lua - - // Delegated rules - - public final boolean synpred25_Lua() { - state.backtracking++; - int start = input.mark(); - try { - synpred25_Lua_fragment(); // can never throw exception - } catch (RecognitionException re) { - System.err.println("impossible: "+re); - } - boolean success = !state.failed; - input.rewind(start); - state.backtracking--; - state.failed=false; - return success; - } - public final boolean synpred41_Lua() { - state.backtracking++; - int start = input.mark(); - try { - synpred41_Lua_fragment(); // can never throw exception - } catch (RecognitionException re) { - System.err.println("impossible: "+re); - } - boolean success = !state.failed; - input.rewind(start); - state.backtracking--; - state.failed=false; - return success; - } - public final boolean synpred40_Lua() { - state.backtracking++; - int start = input.mark(); - try { - synpred40_Lua_fragment(); // can never throw exception - } catch (RecognitionException re) { - System.err.println("impossible: "+re); - } - boolean success = !state.failed; - input.rewind(start); - state.backtracking--; - state.failed=false; - return success; - } - public final boolean synpred42_Lua() { - state.backtracking++; - int start = input.mark(); - try { - synpred42_Lua_fragment(); // can never throw exception - } catch (RecognitionException re) { - System.err.println("impossible: "+re); - } - boolean success = !state.failed; - input.rewind(start); - state.backtracking--; - state.failed=false; - return success; - } - public final boolean synpred13_Lua() { - state.backtracking++; - int start = input.mark(); - try { - synpred13_Lua_fragment(); // can never throw exception - } catch (RecognitionException re) { - System.err.println("impossible: "+re); - } - boolean success = !state.failed; - input.rewind(start); - state.backtracking--; - state.failed=false; - return success; - } - public final boolean synpred35_Lua() { - state.backtracking++; - int start = input.mark(); - try { - synpred35_Lua_fragment(); // can never throw exception - } catch (RecognitionException re) { - System.err.println("impossible: "+re); - } - boolean success = !state.failed; - input.rewind(start); - state.backtracking--; - state.failed=false; - return success; - } - public final boolean synpred5_Lua() { - state.backtracking++; - int start = input.mark(); - try { - synpred5_Lua_fragment(); // can never throw exception - } catch (RecognitionException re) { - System.err.println("impossible: "+re); - } - boolean success = !state.failed; - input.rewind(start); - state.backtracking--; - state.failed=false; - return success; - } - public final boolean synpred29_Lua() { - state.backtracking++; - int start = input.mark(); - try { - synpred29_Lua_fragment(); // can never throw exception - } catch (RecognitionException re) { - System.err.println("impossible: "+re); - } - boolean success = !state.failed; - input.rewind(start); - state.backtracking--; - state.failed=false; - return success; - } - public final boolean synpred12_Lua() { - state.backtracking++; - int start = input.mark(); - try { - synpred12_Lua_fragment(); // can never throw exception - } catch (RecognitionException re) { - System.err.println("impossible: "+re); - } - boolean success = !state.failed; - input.rewind(start); - state.backtracking--; - state.failed=false; - return success; - } - public final boolean synpred15_Lua() { - state.backtracking++; - int start = input.mark(); - try { - synpred15_Lua_fragment(); // can never throw exception - } catch (RecognitionException re) { - System.err.println("impossible: "+re); - } - boolean success = !state.failed; - input.rewind(start); - state.backtracking--; - state.failed=false; - return success; - } - public final boolean synpred6_Lua() { - state.backtracking++; - int start = input.mark(); - try { - synpred6_Lua_fragment(); // can never throw exception - } catch (RecognitionException re) { - System.err.println("impossible: "+re); - } - boolean success = !state.failed; - input.rewind(start); - state.backtracking--; - state.failed=false; - return success; - } - public final boolean synpred37_Lua() { - state.backtracking++; - int start = input.mark(); - try { - synpred37_Lua_fragment(); // can never throw exception - } catch (RecognitionException re) { - System.err.println("impossible: "+re); - } - boolean success = !state.failed; - input.rewind(start); - state.backtracking--; - state.failed=false; - return success; - } - - - protected DFA7 dfa7 = new DFA7(this); - protected DFA16 dfa16 = new DFA16(this); - protected DFA17 dfa17 = new DFA17(this); - protected DFA18 dfa18 = new DFA18(this); - protected DFA20 dfa20 = new DFA20(this); - protected DFA23 dfa23 = new DFA23(this); - protected DFA24 dfa24 = new DFA24(this); - static final String DFA7_eotS = - "\20\uffff"; - static final String DFA7_eofS = - "\20\uffff"; - static final String DFA7_minS = - "\1\4\2\0\4\uffff\1\0\1\uffff\1\0\6\uffff"; - static final String DFA7_maxS = - "\1\54\2\0\4\uffff\1\0\1\uffff\1\0\6\uffff"; - static final String DFA7_acceptS = - "\3\uffff\1\3\1\4\1\5\1\6\1\uffff\1\11\1\uffff\1\1\1\2\1\7\1\10"+ - "\1\12\1\13"; - static final String DFA7_specialS = - "\1\uffff\1\0\1\1\4\uffff\1\2\1\uffff\1\3\6\uffff}>"; - static final String[] DFA7_transitionS = { - "\1\1\21\uffff\1\3\1\uffff\1\4\1\5\1\uffff\1\7\2\uffff\1\10"+ - "\1\11\1\6\13\uffff\1\2", - "\1\uffff", - "\1\uffff", - "", - "", - "", - "", - "\1\uffff", - "", - "\1\uffff", - "", - "", - "", - "", - "", - "" - }; - - static final short[] DFA7_eot = DFA.unpackEncodedString(DFA7_eotS); - static final short[] DFA7_eof = DFA.unpackEncodedString(DFA7_eofS); - static final char[] DFA7_min = DFA.unpackEncodedStringToUnsignedChars(DFA7_minS); - static final char[] DFA7_max = DFA.unpackEncodedStringToUnsignedChars(DFA7_maxS); - static final short[] DFA7_accept = DFA.unpackEncodedString(DFA7_acceptS); - static final short[] DFA7_special = DFA.unpackEncodedString(DFA7_specialS); - static final short[][] DFA7_transition; - - static { - int numStates = DFA7_transitionS.length; - DFA7_transition = new short[numStates][]; - for (int i=0; i=0 ) return s; - break; - case 1 : - int LA16_2 = input.LA(1); - - - int index16_2 = input.index(); - input.rewind(); - s = -1; - if ( (synpred25_Lua()) ) {s = 21;} - - else if ( (true) ) {s = 22;} - - - input.seek(index16_2); - if ( s>=0 ) return s; - break; - case 2 : - int LA16_3 = input.LA(1); - - - int index16_3 = input.index(); - input.rewind(); - s = -1; - if ( (synpred25_Lua()) ) {s = 21;} - - else if ( (true) ) {s = 22;} - - - input.seek(index16_3); - if ( s>=0 ) return s; - break; - case 3 : - int LA16_4 = input.LA(1); - - - int index16_4 = input.index(); - input.rewind(); - s = -1; - if ( (synpred25_Lua()) ) {s = 21;} - - else if ( (true) ) {s = 22;} - - - input.seek(index16_4); - if ( s>=0 ) return s; - break; - case 4 : - int LA16_5 = input.LA(1); - - - int index16_5 = input.index(); - input.rewind(); - s = -1; - if ( (synpred25_Lua()) ) {s = 21;} - - else if ( (true) ) {s = 22;} - - - input.seek(index16_5); - if ( s>=0 ) return s; - break; - case 5 : - int LA16_6 = input.LA(1); - - - int index16_6 = input.index(); - input.rewind(); - s = -1; - if ( (synpred25_Lua()) ) {s = 21;} - - else if ( (true) ) {s = 22;} - - - input.seek(index16_6); - if ( s>=0 ) return s; - break; - case 6 : - int LA16_7 = input.LA(1); - - - int index16_7 = input.index(); - input.rewind(); - s = -1; - if ( (synpred25_Lua()) ) {s = 21;} - - else if ( (true) ) {s = 22;} - - - input.seek(index16_7); - if ( s>=0 ) return s; - break; - case 7 : - int LA16_8 = input.LA(1); - - - int index16_8 = input.index(); - input.rewind(); - s = -1; - if ( (synpred25_Lua()) ) {s = 21;} - - else if ( (true) ) {s = 22;} - - - input.seek(index16_8); - if ( s>=0 ) return s; - break; - case 8 : - int LA16_9 = input.LA(1); - - - int index16_9 = input.index(); - input.rewind(); - s = -1; - if ( (synpred25_Lua()) ) {s = 21;} - - else if ( (true) ) {s = 22;} - - - input.seek(index16_9); - if ( s>=0 ) return s; - break; - case 9 : - int LA16_10 = input.LA(1); - - - int index16_10 = input.index(); - input.rewind(); - s = -1; - if ( (synpred25_Lua()) ) {s = 21;} - - else if ( (true) ) {s = 22;} - - - input.seek(index16_10); - if ( s>=0 ) return s; - break; - case 10 : - int LA16_11 = input.LA(1); - - - int index16_11 = input.index(); - input.rewind(); - s = -1; - if ( (synpred25_Lua()) ) {s = 21;} - - else if ( (true) ) {s = 22;} - - - input.seek(index16_11); - if ( s>=0 ) return s; - break; - case 11 : - int LA16_12 = input.LA(1); - - - int index16_12 = input.index(); - input.rewind(); - s = -1; - if ( (synpred25_Lua()) ) {s = 21;} - - else if ( (true) ) {s = 22;} - - - input.seek(index16_12); - if ( s>=0 ) return s; - break; - case 12 : - int LA16_13 = input.LA(1); - - - int index16_13 = input.index(); - input.rewind(); - s = -1; - if ( (synpred25_Lua()) ) {s = 21;} - - else if ( (true) ) {s = 22;} - - - input.seek(index16_13); - if ( s>=0 ) return s; - break; - case 13 : - int LA16_14 = input.LA(1); - - - int index16_14 = input.index(); - input.rewind(); - s = -1; - if ( (synpred25_Lua()) ) {s = 21;} - - else if ( (true) ) {s = 22;} - - - input.seek(index16_14); - if ( s>=0 ) return s; - break; - case 14 : - int LA16_15 = input.LA(1); - - - int index16_15 = input.index(); - input.rewind(); - s = -1; - if ( (synpred25_Lua()) ) {s = 21;} - - else if ( (true) ) {s = 22;} - - - input.seek(index16_15); - if ( s>=0 ) return s; - break; - case 15 : - int LA16_16 = input.LA(1); - - - int index16_16 = input.index(); - input.rewind(); - s = -1; - if ( (synpred25_Lua()) ) {s = 21;} - - else if ( (true) ) {s = 22;} - - - input.seek(index16_16); - if ( s>=0 ) return s; - break; - case 16 : - int LA16_17 = input.LA(1); - - - int index16_17 = input.index(); - input.rewind(); - s = -1; - if ( (synpred25_Lua()) ) {s = 21;} - - else if ( (true) ) {s = 22;} - - - input.seek(index16_17); - if ( s>=0 ) return s; - break; - case 17 : - int LA16_18 = input.LA(1); - - - int index16_18 = input.index(); - input.rewind(); - s = -1; - if ( (synpred25_Lua()) ) {s = 21;} - - else if ( (true) ) {s = 22;} - - - input.seek(index16_18); - if ( s>=0 ) return s; - break; - case 18 : - int LA16_19 = input.LA(1); - - - int index16_19 = input.index(); - input.rewind(); - s = -1; - if ( (synpred25_Lua()) ) {s = 21;} - - else if ( (true) ) {s = 22;} - - - input.seek(index16_19); - if ( s>=0 ) return s; - break; - case 19 : - int LA16_20 = input.LA(1); - - - int index16_20 = input.index(); - input.rewind(); - s = -1; - if ( (synpred25_Lua()) ) {s = 21;} - - else if ( (true) ) {s = 22;} - - - input.seek(index16_20); - if ( s>=0 ) return s; - break; - } - if (state.backtracking>0) {state.failed=true; return -1;} - NoViableAltException nvae = - new NoViableAltException(getDescription(), 16, _s, input); - error(nvae); - throw nvae; - } - } - static final String DFA17_eotS = - "\14\uffff"; - static final String DFA17_eofS = - "\14\uffff"; - static final String DFA17_minS = - "\1\4\3\uffff\1\0\7\uffff"; - static final String DFA17_maxS = - "\1\102\3\uffff\1\0\7\uffff"; - static final String DFA17_acceptS = - "\1\uffff\1\1\1\2\1\3\1\uffff\1\4\1\5\1\6\1\7\1\10\1\11\1\12"; - static final String DFA17_specialS = - "\4\uffff\1\0\7\uffff}>"; - static final String[] DFA17_transitionS = { - "\1\11\6\5\3\6\20\uffff\1\10\11\uffff\1\1\1\2\1\3\1\7\1\11\3"+ - "\uffff\1\12\2\uffff\1\4\15\uffff\2\13", - "", - "", - "", - "\1\uffff", - "", - "", - "", - "", - "", - "", - "" - }; - - static final short[] DFA17_eot = DFA.unpackEncodedString(DFA17_eotS); - static final short[] DFA17_eof = DFA.unpackEncodedString(DFA17_eofS); - static final char[] DFA17_min = DFA.unpackEncodedStringToUnsignedChars(DFA17_minS); - static final char[] DFA17_max = DFA.unpackEncodedStringToUnsignedChars(DFA17_maxS); - static final short[] DFA17_accept = DFA.unpackEncodedString(DFA17_acceptS); - static final short[] DFA17_special = DFA.unpackEncodedString(DFA17_specialS); - static final short[][] DFA17_transition; - - static { - int numStates = DFA17_transitionS.length; - DFA17_transition = new short[numStates][]; - for (int i=0; i=0 ) return s; - break; - } - if (state.backtracking>0) {state.failed=true; return -1;} - NoViableAltException nvae = - new NoViableAltException(getDescription(), 17, _s, input); - error(nvae); - throw nvae; - } - } - static final String DFA18_eotS = - "\22\uffff"; - static final String DFA18_eofS = - "\1\1\21\uffff"; - static final String DFA18_minS = - "\1\4\1\uffff\17\0\1\uffff"; - static final String DFA18_maxS = - "\1\100\1\uffff\17\0\1\uffff"; - static final String DFA18_acceptS = - "\1\uffff\1\2\17\uffff\1\1"; - static final String DFA18_specialS = - "\2\uffff\1\7\1\2\1\15\1\10\1\4\1\5\1\12\1\16\1\0\1\13\1\6\1\3\1"+ - "\14\1\11\1\1\1\uffff}>"; - static final String[] DFA18_transitionS = { - "\1\1\17\uffff\1\1\1\uffff\7\1\1\uffff\10\1\6\uffff\2\1\1\uffff"+ - "\1\1\1\uffff\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13"+ - "\1\14\1\15\1\16\1\17\1\20", - "", - "\1\uffff", - "\1\uffff", - "\1\uffff", - "\1\uffff", - "\1\uffff", - "\1\uffff", - "\1\uffff", - "\1\uffff", - "\1\uffff", - "\1\uffff", - "\1\uffff", - "\1\uffff", - "\1\uffff", - "\1\uffff", - "\1\uffff", - "" - }; - - static final short[] DFA18_eot = DFA.unpackEncodedString(DFA18_eotS); - static final short[] DFA18_eof = DFA.unpackEncodedString(DFA18_eofS); - static final char[] DFA18_min = DFA.unpackEncodedStringToUnsignedChars(DFA18_minS); - static final char[] DFA18_max = DFA.unpackEncodedStringToUnsignedChars(DFA18_maxS); - static final short[] DFA18_accept = DFA.unpackEncodedString(DFA18_acceptS); - static final short[] DFA18_special = DFA.unpackEncodedString(DFA18_specialS); - static final short[][] DFA18_transition; - - static { - int numStates = DFA18_transitionS.length; - DFA18_transition = new short[numStates][]; - for (int i=0; i=0 ) return s; - break; - case 1 : - int LA18_16 = input.LA(1); - - - int index18_16 = input.index(); - input.rewind(); - s = -1; - if ( (synpred35_Lua()) ) {s = 17;} - - else if ( (true) ) {s = 1;} - - - input.seek(index18_16); - if ( s>=0 ) return s; - break; - case 2 : - int LA18_3 = input.LA(1); - - - int index18_3 = input.index(); - input.rewind(); - s = -1; - if ( (synpred35_Lua()) ) {s = 17;} - - else if ( (true) ) {s = 1;} - - - input.seek(index18_3); - if ( s>=0 ) return s; - break; - case 3 : - int LA18_13 = input.LA(1); - - - int index18_13 = input.index(); - input.rewind(); - s = -1; - if ( (synpred35_Lua()) ) {s = 17;} - - else if ( (true) ) {s = 1;} - - - input.seek(index18_13); - if ( s>=0 ) return s; - break; - case 4 : - int LA18_6 = input.LA(1); - - - int index18_6 = input.index(); - input.rewind(); - s = -1; - if ( (synpred35_Lua()) ) {s = 17;} - - else if ( (true) ) {s = 1;} - - - input.seek(index18_6); - if ( s>=0 ) return s; - break; - case 5 : - int LA18_7 = input.LA(1); - - - int index18_7 = input.index(); - input.rewind(); - s = -1; - if ( (synpred35_Lua()) ) {s = 17;} - - else if ( (true) ) {s = 1;} - - - input.seek(index18_7); - if ( s>=0 ) return s; - break; - case 6 : - int LA18_12 = input.LA(1); - - - int index18_12 = input.index(); - input.rewind(); - s = -1; - if ( (synpred35_Lua()) ) {s = 17;} - - else if ( (true) ) {s = 1;} - - - input.seek(index18_12); - if ( s>=0 ) return s; - break; - case 7 : - int LA18_2 = input.LA(1); - - - int index18_2 = input.index(); - input.rewind(); - s = -1; - if ( (synpred35_Lua()) ) {s = 17;} - - else if ( (true) ) {s = 1;} - - - input.seek(index18_2); - if ( s>=0 ) return s; - break; - case 8 : - int LA18_5 = input.LA(1); - - - int index18_5 = input.index(); - input.rewind(); - s = -1; - if ( (synpred35_Lua()) ) {s = 17;} - - else if ( (true) ) {s = 1;} - - - input.seek(index18_5); - if ( s>=0 ) return s; - break; - case 9 : - int LA18_15 = input.LA(1); - - - int index18_15 = input.index(); - input.rewind(); - s = -1; - if ( (synpred35_Lua()) ) {s = 17;} - - else if ( (true) ) {s = 1;} - - - input.seek(index18_15); - if ( s>=0 ) return s; - break; - case 10 : - int LA18_8 = input.LA(1); - - - int index18_8 = input.index(); - input.rewind(); - s = -1; - if ( (synpred35_Lua()) ) {s = 17;} - - else if ( (true) ) {s = 1;} - - - input.seek(index18_8); - if ( s>=0 ) return s; - break; - case 11 : - int LA18_11 = input.LA(1); - - - int index18_11 = input.index(); - input.rewind(); - s = -1; - if ( (synpred35_Lua()) ) {s = 17;} - - else if ( (true) ) {s = 1;} - - - input.seek(index18_11); - if ( s>=0 ) return s; - break; - case 12 : - int LA18_14 = input.LA(1); - - - int index18_14 = input.index(); - input.rewind(); - s = -1; - if ( (synpred35_Lua()) ) {s = 17;} - - else if ( (true) ) {s = 1;} - - - input.seek(index18_14); - if ( s>=0 ) return s; - break; - case 13 : - int LA18_4 = input.LA(1); - - - int index18_4 = input.index(); - input.rewind(); - s = -1; - if ( (synpred35_Lua()) ) {s = 17;} - - else if ( (true) ) {s = 1;} - - - input.seek(index18_4); - if ( s>=0 ) return s; - break; - case 14 : - int LA18_9 = input.LA(1); - - - int index18_9 = input.index(); - input.rewind(); - s = -1; - if ( (synpred35_Lua()) ) {s = 17;} - - else if ( (true) ) {s = 1;} - - - input.seek(index18_9); - if ( s>=0 ) return s; - break; - } - if (state.backtracking>0) {state.failed=true; return -1;} - NoViableAltException nvae = - new NoViableAltException(getDescription(), 18, _s, input); - error(nvae); - throw nvae; - } - } - static final String DFA20_eotS = - "\56\uffff"; - static final String DFA20_eofS = - "\1\1\55\uffff"; - static final String DFA20_minS = - "\1\4\2\uffff\6\0\45\uffff"; - static final String DFA20_maxS = - "\1\100\2\uffff\6\0\45\uffff"; - static final String DFA20_acceptS = - "\1\uffff\1\2\52\uffff\1\1\1\uffff"; - static final String DFA20_specialS = - "\3\uffff\1\0\1\1\1\2\1\3\1\4\1\5\45\uffff}>"; - static final String[] DFA20_transitionS = { - "\1\1\6\uffff\1\6\1\7\1\10\6\uffff\11\1\1\uffff\10\1\1\54\1"+ - "\3\4\uffff\1\4\1\1\1\54\1\1\1\5\20\1", - "", - "", - "\1\uffff", - "\1\uffff", - "\1\uffff", - "\1\uffff", - "\1\uffff", - "\1\uffff", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "" - }; - - static final short[] DFA20_eot = DFA.unpackEncodedString(DFA20_eotS); - static final short[] DFA20_eof = DFA.unpackEncodedString(DFA20_eofS); - static final char[] DFA20_min = DFA.unpackEncodedStringToUnsignedChars(DFA20_minS); - static final char[] DFA20_max = DFA.unpackEncodedStringToUnsignedChars(DFA20_maxS); - static final short[] DFA20_accept = DFA.unpackEncodedString(DFA20_acceptS); - static final short[] DFA20_special = DFA.unpackEncodedString(DFA20_specialS); - static final short[][] DFA20_transition; - - static { - int numStates = DFA20_transitionS.length; - DFA20_transition = new short[numStates][]; - for (int i=0; i=0 ) return s; - break; - case 1 : - int LA20_4 = input.LA(1); - - - int index20_4 = input.index(); - input.rewind(); - s = -1; - if ( (synpred37_Lua()) ) {s = 44;} - - else if ( (true) ) {s = 1;} - - - input.seek(index20_4); - if ( s>=0 ) return s; - break; - case 2 : - int LA20_5 = input.LA(1); - - - int index20_5 = input.index(); - input.rewind(); - s = -1; - if ( (synpred37_Lua()) ) {s = 44;} - - else if ( (true) ) {s = 1;} - - - input.seek(index20_5); - if ( s>=0 ) return s; - break; - case 3 : - int LA20_6 = input.LA(1); - - - int index20_6 = input.index(); - input.rewind(); - s = -1; - if ( (synpred37_Lua()) ) {s = 44;} - - else if ( (true) ) {s = 1;} - - - input.seek(index20_6); - if ( s>=0 ) return s; - break; - case 4 : - int LA20_7 = input.LA(1); - - - int index20_7 = input.index(); - input.rewind(); - s = -1; - if ( (synpred37_Lua()) ) {s = 44;} - - else if ( (true) ) {s = 1;} - - - input.seek(index20_7); - if ( s>=0 ) return s; - break; - case 5 : - int LA20_8 = input.LA(1); - - - int index20_8 = input.index(); - input.rewind(); - s = -1; - if ( (synpred37_Lua()) ) {s = 44;} - - else if ( (true) ) {s = 1;} - - - input.seek(index20_8); - if ( s>=0 ) return s; - break; - } - if (state.backtracking>0) {state.failed=true; return -1;} - NoViableAltException nvae = - new NoViableAltException(getDescription(), 20, _s, input); - error(nvae); - throw nvae; - } - } - static final String DFA23_eotS = - "\53\uffff"; - static final String DFA23_eofS = - "\1\1\52\uffff"; - static final String DFA23_minS = - "\1\4\31\uffff\1\0\20\uffff"; - static final String DFA23_maxS = - "\1\100\31\uffff\1\0\20\uffff"; - static final String DFA23_acceptS = - "\1\uffff\1\2\44\uffff\1\1\4\uffff"; - static final String DFA23_specialS = - "\32\uffff\1\0\20\uffff}>"; - static final String[] DFA23_transitionS = { - "\1\1\6\uffff\3\46\6\uffff\1\1\1\uffff\7\1\1\uffff\10\1\1\uffff"+ - "\1\46\4\uffff\1\32\1\1\1\uffff\1\1\1\46\20\1", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "\1\uffff", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "" - }; - - static final short[] DFA23_eot = DFA.unpackEncodedString(DFA23_eotS); - static final short[] DFA23_eof = DFA.unpackEncodedString(DFA23_eofS); - static final char[] DFA23_min = DFA.unpackEncodedStringToUnsignedChars(DFA23_minS); - static final char[] DFA23_max = DFA.unpackEncodedStringToUnsignedChars(DFA23_maxS); - static final short[] DFA23_accept = DFA.unpackEncodedString(DFA23_acceptS); - static final short[] DFA23_special = DFA.unpackEncodedString(DFA23_specialS); - static final short[][] DFA23_transition; - - static { - int numStates = DFA23_transitionS.length; - DFA23_transition = new short[numStates][]; - for (int i=0; i=0 ) return s; - break; - } - if (state.backtracking>0) {state.failed=true; return -1;} - NoViableAltException nvae = - new NoViableAltException(getDescription(), 23, _s, input); - error(nvae); - throw nvae; - } - } - static final String DFA24_eotS = - "\27\uffff"; - static final String DFA24_eofS = - "\1\1\26\uffff"; - static final String DFA24_minS = - "\1\4\11\uffff\1\0\14\uffff"; - static final String DFA24_maxS = - "\1\60\11\uffff\1\0\14\uffff"; - static final String DFA24_acceptS = - "\1\uffff\1\2\20\uffff\1\1\4\uffff"; - static final String DFA24_specialS = - "\12\uffff\1\0\14\uffff}>"; - static final String[] DFA24_transitionS = { - "\1\1\6\uffff\3\22\6\uffff\1\1\1\uffff\6\1\2\uffff\3\1\1\uffff"+ - "\4\1\1\uffff\1\22\4\uffff\1\12\3\uffff\1\22", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "\1\uffff", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "", - "" - }; - - static final short[] DFA24_eot = DFA.unpackEncodedString(DFA24_eotS); - static final short[] DFA24_eof = DFA.unpackEncodedString(DFA24_eofS); - static final char[] DFA24_min = DFA.unpackEncodedStringToUnsignedChars(DFA24_minS); - static final char[] DFA24_max = DFA.unpackEncodedStringToUnsignedChars(DFA24_maxS); - static final short[] DFA24_accept = DFA.unpackEncodedString(DFA24_acceptS); - static final short[] DFA24_special = DFA.unpackEncodedString(DFA24_specialS); - static final short[][] DFA24_transition; - - static { - int numStates = DFA24_transitionS.length; - DFA24_transition = new short[numStates][]; - for (int i=0; i=0 ) return s; - break; - } - if (state.backtracking>0) {state.failed=true; return -1;} - NoViableAltException nvae = - new NoViableAltException(getDescription(), 24, _s, input); - error(nvae); - throw nvae; - } - } - - - public static final BitSet FOLLOW_funcblock_in_chunk58 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_block_in_funcblock88 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_stat_in_block113 = new BitSet(new long[]{0x00001031CB500012L}); - public static final BitSet FOLLOW_20_in_block118 = new BitSet(new long[]{0x00001031CB500012L}); - public static final BitSet FOLLOW_laststat_in_block128 = new BitSet(new long[]{0x0000000000100002L}); - public static final BitSet FOLLOW_20_in_block133 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_varlist1_in_stat159 = new BitSet(new long[]{0x0000000000200000L}); - public static final BitSet FOLLOW_21_in_stat161 = new BitSet(new long[]{0x00091F0040003FF0L,0x0000000000000006L}); - public static final BitSet FOLLOW_explist1_in_stat163 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_functioncall_in_stat183 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_22_in_stat213 = new BitSet(new long[]{0x00001031CB500010L}); - public static final BitSet FOLLOW_block_in_stat217 = new BitSet(new long[]{0x0000000000800000L}); - public static final BitSet FOLLOW_23_in_stat221 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_24_in_stat286 = new BitSet(new long[]{0x00091F0040003FF0L,0x0000000000000006L}); - public static final BitSet FOLLOW_exp_in_stat288 = new BitSet(new long[]{0x0000000000400000L}); - public static final BitSet FOLLOW_22_in_stat290 = new BitSet(new long[]{0x00001031CB500010L}); - public static final BitSet FOLLOW_block_in_stat294 = new BitSet(new long[]{0x0000000000800000L}); - public static final BitSet FOLLOW_23_in_stat298 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_25_in_stat344 = new BitSet(new long[]{0x00001031CB500010L}); - public static final BitSet FOLLOW_block_in_stat349 = new BitSet(new long[]{0x0000000004000000L}); - public static final BitSet FOLLOW_26_in_stat354 = new BitSet(new long[]{0x00091F0040003FF0L,0x0000000000000006L}); - public static final BitSet FOLLOW_exp_in_stat356 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_ifstat_in_stat410 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_27_in_stat445 = new BitSet(new long[]{0x0000000000000010L}); - public static final BitSet FOLLOW_NAME_in_stat449 = new BitSet(new long[]{0x0000000000200000L}); - public static final BitSet FOLLOW_21_in_stat453 = new BitSet(new long[]{0x00091F0040003FF0L,0x0000000000000006L}); - public static final BitSet FOLLOW_exp_in_stat457 = new BitSet(new long[]{0x0000000010000000L}); - public static final BitSet FOLLOW_28_in_stat459 = new BitSet(new long[]{0x00091F0040003FF0L,0x0000000000000006L}); - public static final BitSet FOLLOW_exp_in_stat463 = new BitSet(new long[]{0x0000000010400000L}); - public static final BitSet FOLLOW_28_in_stat466 = new BitSet(new long[]{0x00091F0040003FF0L,0x0000000000000006L}); - public static final BitSet FOLLOW_exp_in_stat470 = new BitSet(new long[]{0x0000000000400000L}); - public static final BitSet FOLLOW_22_in_stat474 = new BitSet(new long[]{0x00001031CB500010L}); - public static final BitSet FOLLOW_block_in_stat478 = new BitSet(new long[]{0x0000000000800000L}); - public static final BitSet FOLLOW_23_in_stat482 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_27_in_stat528 = new BitSet(new long[]{0x0000000000000010L}); - public static final BitSet FOLLOW_namelist_in_stat533 = new BitSet(new long[]{0x0000000020000000L}); - public static final BitSet FOLLOW_29_in_stat537 = new BitSet(new long[]{0x00091F0040003FF0L,0x0000000000000006L}); - public static final BitSet FOLLOW_explist1_in_stat539 = new BitSet(new long[]{0x0000000000400000L}); - public static final BitSet FOLLOW_22_in_stat541 = new BitSet(new long[]{0x00001031CB500010L}); - public static final BitSet FOLLOW_block_in_stat545 = new BitSet(new long[]{0x0000000000800000L}); - public static final BitSet FOLLOW_23_in_stat548 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_30_in_stat593 = new BitSet(new long[]{0x0000000000000010L}); - public static final BitSet FOLLOW_funcname_in_stat595 = new BitSet(new long[]{0x0000100000000000L}); - public static final BitSet FOLLOW_funcbody_in_stat597 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_31_in_stat610 = new BitSet(new long[]{0x0000000040000000L}); - public static final BitSet FOLLOW_30_in_stat612 = new BitSet(new long[]{0x0000000000000010L}); - public static final BitSet FOLLOW_NAME_in_stat614 = new BitSet(new long[]{0x0000100000000000L}); - public static final BitSet FOLLOW_funcbody_in_stat618 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_31_in_stat666 = new BitSet(new long[]{0x0000000000000010L}); - public static final BitSet FOLLOW_namelist_in_stat668 = new BitSet(new long[]{0x0000000000200002L}); - public static final BitSet FOLLOW_21_in_stat671 = new BitSet(new long[]{0x00091F0040003FF0L,0x0000000000000006L}); - public static final BitSet FOLLOW_explist1_in_stat673 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_32_in_ifstat699 = new BitSet(new long[]{0x00091F0040003FF0L,0x0000000000000006L}); - public static final BitSet FOLLOW_exp_in_ifstat703 = new BitSet(new long[]{0x0000000200000000L}); - public static final BitSet FOLLOW_33_in_ifstat705 = new BitSet(new long[]{0x00001031CB500010L}); - public static final BitSet FOLLOW_block_in_ifstat712 = new BitSet(new long[]{0x0000000C00800000L}); - public static final BitSet FOLLOW_34_in_ifstat721 = new BitSet(new long[]{0x00091F0040003FF0L,0x0000000000000006L}); - public static final BitSet FOLLOW_exp_in_ifstat725 = new BitSet(new long[]{0x0000000200000000L}); - public static final BitSet FOLLOW_33_in_ifstat727 = new BitSet(new long[]{0x00001031CB500010L}); - public static final BitSet FOLLOW_block_in_ifstat734 = new BitSet(new long[]{0x0000000C00800000L}); - public static final BitSet FOLLOW_35_in_ifstat745 = new BitSet(new long[]{0x00001031CB500010L}); - public static final BitSet FOLLOW_block_in_ifstat752 = new BitSet(new long[]{0x0000000000800000L}); - public static final BitSet FOLLOW_23_in_ifstat762 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_36_in_laststat782 = new BitSet(new long[]{0x00091F0040003FF2L,0x0000000000000006L}); - public static final BitSet FOLLOW_explist1_in_laststat787 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_37_in_laststat797 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_NAME_in_funcname831 = new BitSet(new long[]{0x000000C000000002L}); - public static final BitSet FOLLOW_38_in_funcname839 = new BitSet(new long[]{0x0000000000000010L}); - public static final BitSet FOLLOW_NAME_in_funcname843 = new BitSet(new long[]{0x000000C000000002L}); - public static final BitSet FOLLOW_39_in_funcname854 = new BitSet(new long[]{0x0000000000000010L}); - public static final BitSet FOLLOW_NAME_in_funcname858 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_var_in_varlist1887 = new BitSet(new long[]{0x0000000010000002L}); - public static final BitSet FOLLOW_28_in_varlist1894 = new BitSet(new long[]{0x0000100000000010L}); - public static final BitSet FOLLOW_var_in_varlist1898 = new BitSet(new long[]{0x0000000010000002L}); - public static final BitSet FOLLOW_NAME_in_namelist919 = new BitSet(new long[]{0x0000000010000002L}); - public static final BitSet FOLLOW_28_in_namelist927 = new BitSet(new long[]{0x0000000000000010L}); - public static final BitSet FOLLOW_NAME_in_namelist931 = new BitSet(new long[]{0x0000000010000002L}); - public static final BitSet FOLLOW_exp_in_explist1960 = new BitSet(new long[]{0x0000000010000000L}); - public static final BitSet FOLLOW_28_in_explist1962 = new BitSet(new long[]{0x00091F0040003FF0L,0x0000000000000006L}); - public static final BitSet FOLLOW_exp_in_explist1973 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_40_in_exp991 = new BitSet(new long[]{0xFFFC000000000002L,0x0000000000000001L}); - public static final BitSet FOLLOW_41_in_exp1013 = new BitSet(new long[]{0xFFFC000000000002L,0x0000000000000001L}); - public static final BitSet FOLLOW_42_in_exp1030 = new BitSet(new long[]{0xFFFC000000000002L,0x0000000000000001L}); - public static final BitSet FOLLOW_number_in_exp1048 = new BitSet(new long[]{0xFFFC000000000002L,0x0000000000000001L}); - public static final BitSet FOLLOW_string_in_exp1066 = new BitSet(new long[]{0xFFFC000000000002L,0x0000000000000001L}); - public static final BitSet FOLLOW_43_in_exp1084 = new BitSet(new long[]{0xFFFC000000000002L,0x0000000000000001L}); - public static final BitSet FOLLOW_function_in_exp1103 = new BitSet(new long[]{0xFFFC000000000002L,0x0000000000000001L}); - public static final BitSet FOLLOW_prefixexp_in_exp1119 = new BitSet(new long[]{0xFFFC000000000002L,0x0000000000000001L}); - public static final BitSet FOLLOW_tableconstructor_in_exp1134 = new BitSet(new long[]{0xFFFC000000000002L,0x0000000000000001L}); - public static final BitSet FOLLOW_unop_in_exp1142 = new BitSet(new long[]{0x00091F0040003FF0L,0x0000000000000006L}); - public static final BitSet FOLLOW_exp_in_exp1146 = new BitSet(new long[]{0xFFFC000000000002L,0x0000000000000001L}); - public static final BitSet FOLLOW_binop_in_exp1160 = new BitSet(new long[]{0x00091F0040003FF0L,0x0000000000000006L}); - public static final BitSet FOLLOW_exp_in_exp1164 = new BitSet(new long[]{0xFFFC000000000002L,0x0000000000000001L}); - public static final BitSet FOLLOW_NAME_in_var1195 = new BitSet(new long[]{0x000150C000003802L}); - public static final BitSet FOLLOW_44_in_var1207 = new BitSet(new long[]{0x00091F0040003FF0L,0x0000000000000006L}); - public static final BitSet FOLLOW_exp_in_var1209 = new BitSet(new long[]{0x0000200000000000L}); - public static final BitSet FOLLOW_45_in_var1211 = new BitSet(new long[]{0x000150C000003800L}); - public static final BitSet FOLLOW_varSuffix_in_var1215 = new BitSet(new long[]{0x000150C000003802L}); - public static final BitSet FOLLOW_varSuffix_in_var1225 = new BitSet(new long[]{0x000150C000003802L}); - public static final BitSet FOLLOW_nameAndArgs_in_varSuffix1245 = new BitSet(new long[]{0x000150C000003800L}); - public static final BitSet FOLLOW_46_in_varSuffix1256 = new BitSet(new long[]{0x00091F0040003FF0L,0x0000000000000006L}); - public static final BitSet FOLLOW_exp_in_varSuffix1260 = new BitSet(new long[]{0x0000800000000000L}); - public static final BitSet FOLLOW_47_in_varSuffix1262 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_38_in_varSuffix1275 = new BitSet(new long[]{0x0000000000000010L}); - public static final BitSet FOLLOW_NAME_in_varSuffix1279 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_varOrExp_in_prefixexp1311 = new BitSet(new long[]{0x0001108000003802L}); - public static final BitSet FOLLOW_nameAndArgs_in_prefixexp1321 = new BitSet(new long[]{0x0001108000003802L}); - public static final BitSet FOLLOW_varOrExp_in_functioncall1352 = new BitSet(new long[]{0x0001108000003800L}); - public static final BitSet FOLLOW_nameAndArgs_in_functioncall1362 = new BitSet(new long[]{0x0001108000003802L}); - public static final BitSet FOLLOW_var_in_varOrExp1386 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_44_in_varOrExp1401 = new BitSet(new long[]{0x00091F0040003FF0L,0x0000000000000006L}); - public static final BitSet FOLLOW_exp_in_varOrExp1403 = new BitSet(new long[]{0x0000200000000000L}); - public static final BitSet FOLLOW_45_in_varOrExp1405 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_39_in_nameAndArgs1431 = new BitSet(new long[]{0x0000000000000010L}); - public static final BitSet FOLLOW_NAME_in_nameAndArgs1435 = new BitSet(new long[]{0x0001108000003800L}); - public static final BitSet FOLLOW_args_in_nameAndArgs1452 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_44_in_args1476 = new BitSet(new long[]{0x00093F0040003FF0L,0x0000000000000006L}); - public static final BitSet FOLLOW_explist1_in_args1481 = new BitSet(new long[]{0x0000200000000000L}); - public static final BitSet FOLLOW_45_in_args1487 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_tableconstructor_in_args1495 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_string_in_args1505 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_30_in_function1532 = new BitSet(new long[]{0x0000100000000000L}); - public static final BitSet FOLLOW_funcbody_in_function1536 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_44_in_funcbody1561 = new BitSet(new long[]{0x0000280000000010L}); - public static final BitSet FOLLOW_parlist1_in_funcbody1564 = new BitSet(new long[]{0x0000200000000000L}); - public static final BitSet FOLLOW_45_in_funcbody1570 = new BitSet(new long[]{0x00001031CB500010L}); - public static final BitSet FOLLOW_funcblock_in_funcbody1572 = new BitSet(new long[]{0x0000000000800000L}); - public static final BitSet FOLLOW_23_in_funcbody1575 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_namelist_in_parlist11591 = new BitSet(new long[]{0x0000000010000002L}); - public static final BitSet FOLLOW_28_in_parlist11596 = new BitSet(new long[]{0x0000080000000000L}); - public static final BitSet FOLLOW_43_in_parlist11598 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_43_in_parlist11608 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_48_in_tableconstructor1631 = new BitSet(new long[]{0x000B5F0040003FF0L,0x0000000000000006L}); - public static final BitSet FOLLOW_fieldlist_in_tableconstructor1634 = new BitSet(new long[]{0x0002000000000000L}); - public static final BitSet FOLLOW_49_in_tableconstructor1639 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_field_in_fieldlist1654 = new BitSet(new long[]{0x0000000010100002L}); - public static final BitSet FOLLOW_fieldsep_in_fieldlist1659 = new BitSet(new long[]{0x00095F0040003FF0L,0x0000000000000006L}); - public static final BitSet FOLLOW_field_in_fieldlist1661 = new BitSet(new long[]{0x0000000010100002L}); - public static final BitSet FOLLOW_fieldsep_in_fieldlist1668 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_46_in_field1683 = new BitSet(new long[]{0x00091F0040003FF0L,0x0000000000000006L}); - public static final BitSet FOLLOW_exp_in_field1687 = new BitSet(new long[]{0x0000800000000000L}); - public static final BitSet FOLLOW_47_in_field1689 = new BitSet(new long[]{0x0000000000200000L}); - public static final BitSet FOLLOW_21_in_field1691 = new BitSet(new long[]{0x00091F0040003FF0L,0x0000000000000006L}); - public static final BitSet FOLLOW_exp_in_field1695 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_NAME_in_field1706 = new BitSet(new long[]{0x0000000000200000L}); - public static final BitSet FOLLOW_21_in_field1708 = new BitSet(new long[]{0x00091F0040003FF0L,0x0000000000000006L}); - public static final BitSet FOLLOW_exp_in_field1712 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_exp_in_field1728 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_set_in_fieldsep0 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_50_in_binop1781 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_51_in_binop1790 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_52_in_binop1800 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_53_in_binop1810 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_54_in_binop1820 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_55_in_binop1830 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_56_in_binop1840 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_57_in_binop1849 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_58_in_binop1858 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_59_in_binop1867 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_60_in_binop1876 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_61_in_binop1885 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_62_in_binop1894 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_63_in_binop1903 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_64_in_binop1911 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_51_in_unop1930 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_65_in_unop1940 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_66_in_unop1949 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_51_in_number1967 = new BitSet(new long[]{0x0000000000000020L}); - public static final BitSet FOLLOW_INT_in_number1971 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_51_in_number1978 = new BitSet(new long[]{0x0000000000000040L}); - public static final BitSet FOLLOW_FLOAT1_in_number1982 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_51_in_number1989 = new BitSet(new long[]{0x0000000000000080L}); - public static final BitSet FOLLOW_FLOAT2_in_number1993 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_51_in_number2000 = new BitSet(new long[]{0x0000000000000100L}); - public static final BitSet FOLLOW_FLOAT3_in_number2004 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_51_in_number2011 = new BitSet(new long[]{0x0000000000000200L}); - public static final BitSet FOLLOW_EXP_in_number2015 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_HEX_in_number2021 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_NORMALSTRING_in_string2037 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_CHARSTRING_in_string2044 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_LONGSTRING_in_string2053 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_varlist1_in_synpred5_Lua159 = new BitSet(new long[]{0x0000000000200000L}); - public static final BitSet FOLLOW_21_in_synpred5_Lua161 = new BitSet(new long[]{0x00091F0040003FF0L,0x0000000000000006L}); - public static final BitSet FOLLOW_explist1_in_synpred5_Lua163 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_functioncall_in_synpred6_Lua183 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_27_in_synpred12_Lua445 = new BitSet(new long[]{0x0000000000000010L}); - public static final BitSet FOLLOW_NAME_in_synpred12_Lua449 = new BitSet(new long[]{0x0000000000200000L}); - public static final BitSet FOLLOW_21_in_synpred12_Lua453 = new BitSet(new long[]{0x00091F0040003FF0L,0x0000000000000006L}); - public static final BitSet FOLLOW_exp_in_synpred12_Lua457 = new BitSet(new long[]{0x0000000010000000L}); - public static final BitSet FOLLOW_28_in_synpred12_Lua459 = new BitSet(new long[]{0x00091F0040003FF0L,0x0000000000000006L}); - public static final BitSet FOLLOW_exp_in_synpred12_Lua463 = new BitSet(new long[]{0x0000000010400000L}); - public static final BitSet FOLLOW_28_in_synpred12_Lua466 = new BitSet(new long[]{0x00091F0040003FF0L,0x0000000000000006L}); - public static final BitSet FOLLOW_exp_in_synpred12_Lua470 = new BitSet(new long[]{0x0000000000400000L}); - public static final BitSet FOLLOW_22_in_synpred12_Lua474 = new BitSet(new long[]{0x00001031CB500010L}); - public static final BitSet FOLLOW_block_in_synpred12_Lua478 = new BitSet(new long[]{0x0000000000800000L}); - public static final BitSet FOLLOW_23_in_synpred12_Lua482 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_27_in_synpred13_Lua528 = new BitSet(new long[]{0x0000000000000010L}); - public static final BitSet FOLLOW_namelist_in_synpred13_Lua533 = new BitSet(new long[]{0x0000000020000000L}); - public static final BitSet FOLLOW_29_in_synpred13_Lua537 = new BitSet(new long[]{0x00091F0040003FF0L,0x0000000000000006L}); - public static final BitSet FOLLOW_explist1_in_synpred13_Lua539 = new BitSet(new long[]{0x0000000000400000L}); - public static final BitSet FOLLOW_22_in_synpred13_Lua541 = new BitSet(new long[]{0x00001031CB500010L}); - public static final BitSet FOLLOW_block_in_synpred13_Lua545 = new BitSet(new long[]{0x0000000000800000L}); - public static final BitSet FOLLOW_23_in_synpred13_Lua548 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_31_in_synpred15_Lua610 = new BitSet(new long[]{0x0000000040000000L}); - public static final BitSet FOLLOW_30_in_synpred15_Lua612 = new BitSet(new long[]{0x0000000000000010L}); - public static final BitSet FOLLOW_NAME_in_synpred15_Lua614 = new BitSet(new long[]{0x0000100000000000L}); - public static final BitSet FOLLOW_funcbody_in_synpred15_Lua618 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_exp_in_synpred25_Lua960 = new BitSet(new long[]{0x0000000010000000L}); - public static final BitSet FOLLOW_28_in_synpred25_Lua962 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_number_in_synpred29_Lua1048 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_binop_in_synpred35_Lua1160 = new BitSet(new long[]{0x00091F0040003FF0L,0x0000000000000006L}); - public static final BitSet FOLLOW_exp_in_synpred35_Lua1164 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_varSuffix_in_synpred37_Lua1225 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_nameAndArgs_in_synpred40_Lua1321 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_nameAndArgs_in_synpred41_Lua1362 = new BitSet(new long[]{0x0000000000000002L}); - public static final BitSet FOLLOW_var_in_synpred42_Lua1386 = new BitSet(new long[]{0x0000000000000002L}); - -} \ No newline at end of file diff --git a/src/jse/org/luaj/vm2/luajc/lst/BinOp.java b/src/jse/org/luaj/vm2/luajc/lst/BinOp.java deleted file mode 100644 index 56b059af..00000000 --- a/src/jse/org/luaj/vm2/luajc/lst/BinOp.java +++ /dev/null @@ -1,63 +0,0 @@ -/******************************************************************************* -* Copyright (c) 2009 Luaj.org. All rights reserved. -* -* Permission is hereby granted, free of charge, to any person obtaining a copy -* of this software and associated documentation files (the "Software"), to deal -* in the Software without restriction, including without limitation the rights -* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -* copies of the Software, and to permit persons to whom the Software is -* furnished to do so, subject to the following conditions: -* -* The above copyright notice and this permission notice shall be included in -* all copies or substantial portions of the Software. -* -* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -* THE SOFTWARE. -******************************************************************************/ -package org.luaj.vm2.luajc.lst; - - -public class BinOp { - // unary precedence is between POW and MUL - public static final int UNARY_PRECEDENCE = 7; - - public enum Type { - pow,mul,div,mod,add,sub,concat,lt,lteq,gt,gteq,eq,neq,and,or, - } - - public static final BinOp POW = new BinOp(Type.pow, 8, true, "^"); - public static final BinOp MUL = new BinOp(Type.mul, 6, false, "*"); - public static final BinOp DIV = new BinOp(Type.div, 6, false, "/"); - public static final BinOp MOD = new BinOp(Type.mod, 6, false, "%"); - public static final BinOp ADD = new BinOp(Type.add, 5, false, "+"); - public static final BinOp SUB = new BinOp(Type.sub, 5, false, "-"); - public static final BinOp CONCAT = new BinOp(Type.concat, 4, true, ".."); - public static final BinOp LT = new BinOp(Type.lt, 3, false, "<"); - public static final BinOp LTEQ = new BinOp(Type.lteq, 3, false, "<="); - public static final BinOp GT = new BinOp(Type.gt, 3, false, ">"); - public static final BinOp GTEQ = new BinOp(Type.gteq, 3, false, ">="); - public static final BinOp EQ = new BinOp(Type.eq, 3, false, "=="); - public static final BinOp NEQ = new BinOp(Type.neq, 3, false, "~="); - public static final BinOp AND = new BinOp(Type.and, 2, true, "and"); - public static final BinOp OR = new BinOp(Type.or, 1, true, "or"); - - public final Type type; - public final int precedence; - public final boolean isrightassoc; - public final String luaop; - - private BinOp(Type type, int precedence, boolean isrightassoc, String luaop) { - super(); - this.type = type; - this.precedence = precedence; - this.isrightassoc = isrightassoc; - this.luaop = luaop; - } - - public String toString() { return luaop; } -} diff --git a/src/jse/org/luaj/vm2/luajc/lst/LSChunk.java b/src/jse/org/luaj/vm2/luajc/lst/LSChunk.java deleted file mode 100644 index 2924da0b..00000000 --- a/src/jse/org/luaj/vm2/luajc/lst/LSChunk.java +++ /dev/null @@ -1,106 +0,0 @@ -/******************************************************************************* -* Copyright (c) 2009 Luaj.org. All rights reserved. -* -* Permission is hereby granted, free of charge, to any person obtaining a copy -* of this software and associated documentation files (the "Software"), to deal -* in the Software without restriction, including without limitation the rights -* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -* copies of the Software, and to permit persons to whom the Software is -* furnished to do so, subject to the following conditions: -* -* The above copyright notice and this permission notice shall be included in -* all copies or substantial portions of the Software. -* -* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -* THE SOFTWARE. -******************************************************************************/ -package org.luaj.vm2.luajc.lst; - -import java.util.ArrayList; -import java.util.List; - - -/* A Lua Source Chunk */ -public class LSChunk { - public static final boolean SCOPES = System.getProperty("SCOPES")!=null; - - public final String chunkname; - public final LSFunction function; - public Scope scope; - - public LSChunk( String chunkname ) { - this.chunkname = chunkname; - this.function = new LSFunction( true ); - this.scope = null; - } - - public String toString() { - return "@"+chunkname+": "+function; - } - - /** push a block scope onto the name scope stack */ - public void pushScope(String name) { - scope = new Scope(scope, false); - if(SCOPES)System.out.println(space(scope)+"push "+name+" scope="+scope); - - } - - /** push a function scope onto the name scope stack */ - public void pushScope(String name,boolean isFunction) { - scope = new Scope(scope, isFunction); - if(SCOPES)System.out.println(space(scope)+"push "+name+" scope="+scope); - } - - /** pop a scope from the scope stack */ - public Scope popScope(String name) { - Scope s = scope; - scope = scope.parent; - if(SCOPES)System.out.println(space(s)+"pop "+name+" scope="+scope); - return s; - } - - /** return the current scope */ - public Scope peekScope() { - return scope; - } - - /** Declare a single name in the current scope, and return the Name element for it */ - public Name declare(String name) { - Name n = scope.declare( name ); - if(SCOPES)System.out.println(space(scope)+" declared "+n+" scope="+scope); - return n; - } - - /** Declare a list of names in the current scope, and return List of Name for them */ - public List declare(List names) { - List results = new ArrayList(names.size()); - for ( String s : names ) - results.add( declare(s) ); - return results; - } - - /** Reference a name, and find either the local scope within the function, the upvalue, or a global name - * @param func */ - public Name reference(String name, LSFunction func) { - Name n = scope.reference(name); - if ("arg".equals(name) && n.isGlobal() && func.isvararg && !scope.isMainChunkScope()) { - n = scope.declare(name); - func.setHasArg(); - } - if(SCOPES)System.out.println(space(scope)+" reference "+n+" scope="+scope); - return n; - } - - /** Print out indentation for a scope */ - private static final String ws = " "; - private String space(Scope i) { - return ws.substring(0,i.level*2); - } - - -} diff --git a/src/jse/org/luaj/vm2/luajc/lst/LSExpression.java b/src/jse/org/luaj/vm2/luajc/lst/LSExpression.java deleted file mode 100644 index 038b4bfe..00000000 --- a/src/jse/org/luaj/vm2/luajc/lst/LSExpression.java +++ /dev/null @@ -1,267 +0,0 @@ -/******************************************************************************* -* Copyright (c) 2009 Luaj.org. All rights reserved. -* -* Permission is hereby granted, free of charge, to any person obtaining a copy -* of this software and associated documentation files (the "Software"), to deal -* in the Software without restriction, including without limitation the rights -* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -* copies of the Software, and to permit persons to whom the Software is -* furnished to do so, subject to the following conditions: -* -* The above copyright notice and this permission notice shall be included in -* all copies or substantial portions of the Software. -* -* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -* THE SOFTWARE. -******************************************************************************/ -package org.luaj.vm2.luajc.lst; - -import java.io.ByteArrayOutputStream; -import java.util.List; - -public class LSExpression { - public enum Type { - unop, - binop, - functionExpr, - tableConstructor, - nilConstant, - trueConstant, - falseConstant, - varargsRef, - numberConstant, - stringConstant, - - // variable types - nameVariable, - fieldVariable, - methodVariable, - parenthesesVariable, - indexVariable, - callFunctionVariable, - callMethodVariable, - } - - public static final LSExpression ENIL = new LSExpression(Type.nilConstant); // nil - public static final LSExpression EFALSE = new LSExpression(Type.falseConstant); // false - public static final LSExpression ETRUE = new LSExpression(Type.trueConstant); // true - - public final Type type; - - LSExpression(Type type) { - this.type = type; - } - - public static LSExpression functionExpression(LSFunction function) { - return new FunctionExpr(function); - } - - public static LSExpression unopExpression(UnOp unop, LSExpression rhs, Scope scope) { - if ( rhs instanceof BinopExpr ) { - BinopExpr b = (BinopExpr) rhs; - if ( BinOp.UNARY_PRECEDENCE > b.op.precedence ) - return binopExpression( unopExpression( unop, b.lhs, scope ), b.op, b.rhs, scope ); - } - return new UnopExpr( unop, rhs ); - } - - public static LSExpression binopExpression(LSExpression lhs, BinOp binop, LSExpression rhs, Scope scope) { - if ( lhs instanceof UnopExpr ) { - UnopExpr u = (UnopExpr) lhs; - if ( binop.precedence > BinOp.UNARY_PRECEDENCE ) - return unopExpression( u.op, binopExpression( u.rhs, binop, rhs, scope ), scope ); - } - // TODO: cumulate string concatenations together - // TODO: constant folding - if ( lhs instanceof BinopExpr ) { - BinopExpr b = (BinopExpr) lhs; - if ( (binop.precedence > b.op.precedence) || - ((binop.precedence == b.op.precedence) && binop.isrightassoc) ) - return binopExpression( b.lhs, b.op, binopExpression( b.rhs, binop, rhs, scope ), scope ); - } - if ( rhs instanceof BinopExpr ) { - BinopExpr b = (BinopExpr) rhs; - if ( (binop.precedence > b.op.precedence) || - ((binop.precedence == b.op.precedence) && ! binop.isrightassoc) ) - return binopExpression( binopExpression( lhs, binop, b.lhs, scope ), b.op, b.rhs, scope ); - } - return new BinopExpr( lhs, binop, rhs, scope ); - } - - public static LSExpression numberExpression(String number) { - return new NumberConstant(number); - } - - public static LSExpression tableConstructorExpression(List fields) { - return new TableConstructor( fields ); - } - - public static LSExpression normalStringExpression(String luaSourceString) { - return new StringConstant(luaSourceString.substring(1,luaSourceString.length()-1)); - } - - public static LSExpression charStringExpression(String luaSourceString) { - return new StringConstant(luaSourceString.substring(1,luaSourceString.length()-1)); - } - - public static LSExpression longStringExpression(String luaSourceString) { - luaSourceString = luaSourceString.substring(1,luaSourceString.length()-1); - luaSourceString = luaSourceString.substring(luaSourceString.indexOf('[',1)+1, luaSourceString.lastIndexOf(']')); - return new StringConstant(luaSourceString); - } - - public static LSExpression varargsRef() { - return new VarargsRef(); - } - - /** varargs such as "..." */ - public static class VarargsRef extends LSExpression { - public int numReturns = -1; - public VarargsRef() { - super( Type.varargsRef ); - } - public void setNumReturns(int i) { - this.numReturns = i; - } - public int getNumReturns() { - return numReturns; - } - public String toString() { return "..."; } - } - - /** prefix expression such as "(foo)(bar)" ? */ - public static class FunctionExpr extends LSExpression { - public final LSFunction function; - public FunctionExpr( LSFunction function) { - super( Type.functionExpr ); - this.function = function; - } - public String toString() { return function.toString(); } - } - - /** unary operator such as "not foo" */ - public static class UnopExpr extends LSExpression { - public final UnOp op; - public final LSExpression rhs; - public UnopExpr( UnOp op, LSExpression rhs ) { - super( Type.unop ); - this.op = op; - this.rhs = rhs; - } - public String toString() { return op.luaop+rhs; } - } - - /** binary operator such as "a + b" */ - public static class BinopExpr extends LSExpression { - public final LSExpression lhs; - public final BinOp op; - public final LSExpression rhs; - public final Scope scope; - public BinopExpr( LSExpression lhs, BinOp op, LSExpression rhs, Scope scope ) { - super( Type.binop ); - this.lhs = lhs; - this.op = op; - this.rhs = rhs; - this.scope = scope; - } - public String toString() { return lhs+op.luaop+rhs; } - } - - /** table constructor such as "{ 'foo', [0]='bar' }" */ - public static class TableConstructor extends LSExpression { - public final List fields; - public TableConstructor( List fields ) { - super( Type.tableConstructor ); - this.fields = fields; - int n = fields.size(); - for ( int i=0; i0 ) - fields.get(n-1).setNumReturns(-1); - } - public String toString() { return "{"+fields+"}"; } - } - - /** number constants such as '123', "4.56", "0x11fe */ - public static class NumberConstant extends LSExpression { - public final Number value; - public NumberConstant( String number ) { - super( Type.numberConstant ); - number = number.toLowerCase(); - if ( number.startsWith("0x") ) { - Long l = Long.parseLong(number.substring(2), 16); - value = (l.intValue()==l.longValue()? (Number) Integer.valueOf(l.intValue()): (Number) l); - } else { - Double d = Double.parseDouble(number); - value = (d.doubleValue()==(double)d.intValue()? (Number) Integer.valueOf(d.intValue()): (Number) d); - } - } - public String toString() { return value.toString(); } - } - - /** string constants such as 'abc', "def", [[ghi]], and [==[pqr]==] */ - public static class StringConstant extends LSExpression { - public final byte[] bytes; - public StringConstant( String luaSourceChars ) { - super( Type.stringConstant ); - this.bytes = unquoteLua( luaSourceChars ); - } - public String toString() { return "\""+new String(bytes)+"\""; } - } - - /** Unquote lua quoted sequences, and convert to the bytes represented by the source string. */ - public static byte[] unquoteLua( String luaSourceChars ) { - ByteArrayOutputStream baos = new ByteArrayOutputStream(); - char[] c = luaSourceChars.toCharArray(); - int n = c.length; - for ( int i=0; i='0' && c[i]<='9'; i++, j++ ) - d = d * 10 + (int) (c[i]-'0'); - baos.write( (byte) d ); - --i; - continue; - case 'a': baos.write( (byte) 7 ); continue; - case 'b': baos.write( (byte) '\b' ); continue; - case 'f': baos.write( (byte) '\f' ); continue; - case 'n': baos.write( (byte) '\n' ); continue; - case 'r': baos.write( (byte) '\r' ); continue; - case 't': baos.write( (byte) '\t' ); continue; - case 'v': baos.write( (byte) 11 ); continue; - case '"': baos.write( (byte) '"' ); continue; - case '\'': baos.write( (byte) '\'' ); continue; - case '\\': baos.write( (byte) '\\' ); continue; - default: baos.write( (byte) c[i] ); break; - } - } else { - baos.write( (byte) c[i] ); - } - } - return baos.toByteArray(); - } - - /** Set number of return values, return actual number of returns in practice. - * - * @param i desired number of returns, or -1 for varargs. - */ - public void setNumReturns(int i) { - } - - /** Get actual number of returns for this subexpression, or -1 for varargs. - * - * @return actual number of returns, or -1 for varargs. - */ - public int getNumReturns() { - return 1; - } - -} diff --git a/src/jse/org/luaj/vm2/luajc/lst/LSField.java b/src/jse/org/luaj/vm2/luajc/lst/LSField.java deleted file mode 100644 index 136296f4..00000000 --- a/src/jse/org/luaj/vm2/luajc/lst/LSField.java +++ /dev/null @@ -1,92 +0,0 @@ -/******************************************************************************* -* Copyright (c) 2009 Luaj.org. All rights reserved. -* -* Permission is hereby granted, free of charge, to any person obtaining a copy -* of this software and associated documentation files (the "Software"), to deal -* in the Software without restriction, including without limitation the rights -* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -* copies of the Software, and to permit persons to whom the Software is -* furnished to do so, subject to the following conditions: -* -* The above copyright notice and this permission notice shall be included in -* all copies or substantial portions of the Software. -* -* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -* THE SOFTWARE. -******************************************************************************/ -package org.luaj.vm2.luajc.lst; - -public class LSField { - public enum Type { - keyValue, - nameValue, - listValue, - } - - public final Type type; - - LSField(Type type) { - this.type = type; - } - - public static LSField keyValueField(LSExpression key, LSExpression value) { - return new KeyValue(key, value); - } - - public static LSField nameValueField(String name, LSExpression value) { - return new NameValue(name, value); - } - - public static LSField valueField(LSExpression value) { - return new ListValue(value); - } - - /** table constructor field with an explicit key index value */ - public static class KeyValue extends LSField { - public final LSExpression key; - public final LSExpression value; - public KeyValue(LSExpression key, LSExpression value) { - super( Type.keyValue ); - this.key = key; - this.value = value; - value.setNumReturns(1); - } - public String toString() { return "["+key+"]="+value; } - } - - - /** table constructor field with an named field for key */ - public static class NameValue extends LSField { - public final String name; - public final LSExpression value; - public NameValue(String name, LSExpression value) { - super( Type.nameValue ); - this.name = name; - this.value = value; - value.setNumReturns(1); - } - public String toString() { return name+"="+value; } - } - - /** table constructor field with an implied index key */ - public static class ListValue extends LSField { - public final LSExpression value; - public ListValue(LSExpression value) { - super( Type.listValue ); - this.value = value; - } - public void setNumReturns(int i) { - value.setNumReturns(i); - } - public String toString() { return value.toString(); } - } - - public void setNumReturns(int i) { - } - -} diff --git a/src/jse/org/luaj/vm2/luajc/lst/LSFunction.java b/src/jse/org/luaj/vm2/luajc/lst/LSFunction.java deleted file mode 100644 index 102bd455..00000000 --- a/src/jse/org/luaj/vm2/luajc/lst/LSFunction.java +++ /dev/null @@ -1,75 +0,0 @@ -/******************************************************************************* -* Copyright (c) 2009 Luaj.org. All rights reserved. -* -* Permission is hereby granted, free of charge, to any person obtaining a copy -* of this software and associated documentation files (the "Software"), to deal -* in the Software without restriction, including without limitation the rights -* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -* copies of the Software, and to permit persons to whom the Software is -* furnished to do so, subject to the following conditions: -* -* The above copyright notice and this permission notice shall be included in -* all copies or substantial portions of the Software. -* -* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -* THE SOFTWARE. -******************************************************************************/ -package org.luaj.vm2.luajc.lst; - -import java.util.ArrayList; -import java.util.List; - -public class LSFunction { - - public final List stats = new ArrayList(); - public final List functions = new ArrayList(); - public final List paramnames = new ArrayList(); - - /** set if this is a vararg function */ - public boolean isvararg; - - /** needsarg is set if the code is vararg and needs the "arg" table to be created. */ - public boolean hasarg,needsarg; - - /** max number of returns, or -1 for varargs */ - public int maxReturns = 0; - - /** set if there are logical subexpressions, or varargs assignment */ - public boolean hasandlogic, hasorlogic, hasvarargassign, usesvarargs; - - public LSFunction() { - } - - public LSFunction(boolean isvararg) { - this.isvararg = isvararg; - } - - public void setStatements(List stats) { - this.stats.clear(); - this.stats.addAll(stats); - } - - public void setParameterNames(List list) { - this.paramnames.clear(); - this.paramnames.addAll( list ); - } - - public String toString() { return "function("+paramnames+") "+stats+" end"; } - - public void setUsesVarargs() { - this.usesvarargs = true; - if ( this.hasarg ) - this.needsarg = false; - } - - public void setHasArg() { - this.hasarg = true; - if ( ! this.usesvarargs ) - this.needsarg = true; - } -} diff --git a/src/jse/org/luaj/vm2/luajc/lst/LSIfStatement.java b/src/jse/org/luaj/vm2/luajc/lst/LSIfStatement.java deleted file mode 100644 index eae05bcf..00000000 --- a/src/jse/org/luaj/vm2/luajc/lst/LSIfStatement.java +++ /dev/null @@ -1,76 +0,0 @@ -/******************************************************************************* -* Copyright (c) 2009 Luaj.org. All rights reserved. -* -* Permission is hereby granted, free of charge, to any person obtaining a copy -* of this software and associated documentation files (the "Software"), to deal -* in the Software without restriction, including without limitation the rights -* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -* copies of the Software, and to permit persons to whom the Software is -* furnished to do so, subject to the following conditions: -* -* The above copyright notice and this permission notice shall be included in -* all copies or substantial portions of the Software. -* -* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -* THE SOFTWARE. -******************************************************************************/ -package org.luaj.vm2.luajc.lst; - -import java.util.ArrayList; -import java.util.List; - -public class LSIfStatement extends LSStatement { - - public final LSExpression condition; - public final List statements; - public List elseifs; - public List elsestatements; - - public static class ElseIf { - public final LSExpression condition; - public final List statements; - public ElseIf(LSExpression condition, List statements) { - this.condition = condition; - this.statements = statements; - } - } - - public LSIfStatement(LSExpression condition, List statements) { - super( Type.ifStat ); - this.condition = condition; - this.statements = statements; - } - - public void addElseif(LSExpression condition, List statements) { - if ( elseifs == null ) - elseifs = new ArrayList(); - elseifs.add( new ElseIf( condition, statements ) ); - } - - public void addElse(List statements) { - elsestatements = statements; - } - - public String toString() { - return "if "+condition+" then "+statements+ - (elseifs!=null? elseifs.toString(): "")+ - (elsestatements!=null? " else "+elsestatements: ""); - } - public boolean isNextStatementReachable() { - if ( isNextStatementReachable(statements) ) - return true; - if ( elseifs != null ) - for ( ElseIf e : elseifs ) - if ( isNextStatementReachable(statements) ) - return true; - if ( isNextStatementReachable(elsestatements) ) - return true; - return false; - } - -} diff --git a/src/jse/org/luaj/vm2/luajc/lst/LSStatement.java b/src/jse/org/luaj/vm2/luajc/lst/LSStatement.java deleted file mode 100644 index 87625ffb..00000000 --- a/src/jse/org/luaj/vm2/luajc/lst/LSStatement.java +++ /dev/null @@ -1,327 +0,0 @@ -/******************************************************************************* -* Copyright (c) 2009 Luaj.org. All rights reserved. -* -* Permission is hereby granted, free of charge, to any person obtaining a copy -* of this software and associated documentation files (the "Software"), to deal -* in the Software without restriction, including without limitation the rights -* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -* copies of the Software, and to permit persons to whom the Software is -* furnished to do so, subject to the following conditions: -* -* The above copyright notice and this permission notice shall be included in -* all copies or substantial portions of the Software. -* -* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -* THE SOFTWARE. -******************************************************************************/ -package org.luaj.vm2.luajc.lst; - -import java.util.List; - -public class LSStatement { - - public enum Type { - functionCall, - doBlock, - whileLoop, - repeatUntil, - varAssign, - forLoop, - forList, - varNamedFunction, - localFunction, - localAssign, - returnStat, - breakStat, - ifStat, - } - - public final Type type; - - LSStatement( Type type ) { - this.type = type; - } - - public static LSStatement functionCallStatement(LSVariable variable) { - return new FunctionCall( variable ); - } - - public static LSStatement doBlockStatement(List statements) { - return new DoBlock( statements ); - } - - public static LSStatement whileLoopStatement(LSExpression condition, List statements) { - return new WhileLoop( condition, statements ); - } - - public static LSStatement repeatUntilStatement(List statements, LSExpression condition) { - return new RepeatUntil( statements, condition ); - } - - public static LSStatement forLoopStatement(Name name, LSExpression initial, - LSExpression limit, LSExpression step, List statements, Scope scope) { - return new ForLoop( name, initial, limit, step, statements, scope ); - } - - public static LSStatement forListStatement(List names, - List expressions, List statements, Scope scope, LSFunction function) { - return new ForList( names, expressions, statements, scope, function ); - } - - public static LSStatement varFunctionStatement(LSVariable funcname, LSFunction funcbody) { - return new VarNamedFunction( funcname, funcbody ); - } - - public static LSStatement localFunctionStatement(Name name, LSFunction funcbody) { - return new LocalFunction( name, funcbody ); - } - - public static LSStatement varAssignStatement(List variables, List expressions, Scope scope, LSFunction function) { - setExprNumReturns( variables.size(), expressions, function ); - return new VarAssign( variables, expressions, scope ); - } - - public static LSStatement localAssignStatement(List names, List expressions, Scope scope, LSFunction function) { - setExprNumReturns( names.size(), expressions, function ); - return new LocalAssign( names, expressions, scope ); - } - - public static void setExprNumReturns( int nassign, List expressions, LSFunction function ) { - int nexpr = expressions!=null? expressions.size(): 0; - for ( int i=0; i nexpr && nexpr > 0 && expressions.get(nexpr-1).getNumReturns() == -1 ) - function.hasvarargassign = true; - } - - public static LSStatement returnStatement(LSFunction function, List expressions) { - int n=expressions!=null? expressions.size(): 0; - - // set num returns of subexpressions - for ( int i=0; i 0 ) { - LSExpression last = expressions.get(n-1); - int lastreturns = last.getNumReturns(); - nreturns = (lastreturns<0? -1: lastreturns+n-1); - } - - // change the containing function to varargs if necessary. - if ( function.maxReturns != -1 && function.maxReturns < nreturns ) - function.maxReturns = nreturns; - if ( function.maxReturns == -1 || function.maxReturns > 1 || nreturns < 0 ) - function.isvararg = true; - - return new ReturnStat( function, expressions ); - } - - public static LSStatement breakStatement() { - return new BreakStat(); - } - - /** Statement representing a function call on a variable, such as "foo.bar()" */ - public static final class FunctionCall extends LSStatement { - public final LSVariable variable; - FunctionCall(LSVariable variable) { - super( Type.functionCall ); - this.variable = variable; - } - public String toString() { return variable.toString()+"();"; } - } - - /** do block, such as "do foo = bar end" */ - public static final class DoBlock extends LSStatement { - public final List statements; - DoBlock(List statements) { - super( Type.doBlock ); - this.statements = statements; - } - public String toString() { return "do "+statements+" end;"; } - public boolean isNextStatementReachable() { - return isNextStatementReachable(statements); - } - } - - /** while loop, such as "while foo = true do bar() end" */ - public static final class WhileLoop extends LSStatement { - public final LSExpression condition; - public final List statements; - WhileLoop(LSExpression condition, List statements) { - super( Type.whileLoop ); - this.condition = condition; - this.statements = statements; - } - public String toString() { return "while "+condition+" do "+statements+" end;"; } - public boolean isNextStatementReachable() { - return isNextStatementReachable(statements); - } - } - - /** repeat loop, such as "repeat foo() until bar == true" */ - public static final class RepeatUntil extends LSStatement { - public final List statements; - public final LSExpression condition; - RepeatUntil(List statements, LSExpression condition) { - super( Type.repeatUntil ); - this.statements = statements; - this.condition = condition; - } - public String toString() { return "repeat "+statements+" until "+condition+";"; } - public boolean isNextStatementReachable() { - return isNextStatementReachable(statements); - } - } - - /** assignment to variables, such as "x.a,y.b = foo,bar" */ - public static final class VarAssign extends LSStatement { - public final List variables; - public final List expressions; - public final Scope scope; - VarAssign(List variables, List expressions, Scope scope) { - super( Type.varAssign ); - this.variables = variables; - this.expressions = expressions; - this.scope = scope; - } - public String toString() { return variables+"="+expressions+";"; } - } - - /** for loop with index, such as "for i=1,10,2 do ... end" */ - public static final class ForLoop extends LSStatement { - public final Name index; - public final LSExpression initial; - public final LSExpression limit; - public final LSExpression step; - public final List statements; - public final Scope scope; - ForLoop(Name name, LSExpression initial, LSExpression limit, LSExpression step, List statements, Scope scope) { - super( Type.forLoop ); - this.index = name; - this.initial = initial; - this.limit = limit; - this.step = step; - this.statements = statements; - this.scope = scope; - initial.setNumReturns(1); - limit.setNumReturns(1); - if ( step != null ) - step.setNumReturns(1); - } - public String toString() { return "for "+index+"="+initial+","+limit+","+step+" do "+statements+" end;"; } - public boolean isNextStatementReachable() { - return isNextStatementReachable(statements); - } - } - - /** for loop with variable, such as "for i,j,k in foo() do ... end" */ - public static final class ForList extends LSStatement { - public final List names; - public final List expressions; - public final List statements; - public final Scope scope; - ForList(List names, List expressions, List statements, Scope scope, LSFunction function) { - super( Type.forList ); - this.names = names; - this.expressions = expressions; - this.statements = statements; - this.scope = scope; - - // set return value count for each expression in list; - int ne = expressions.size(); - for ( int i=0; i names; - public final List expressions; - public final Scope scope; - LocalAssign(List list, List expressions, Scope scope) { - super( Type.localAssign ); - this.names = list; - this.expressions = expressions; - this.scope = scope; - } - public String toString() { return names+"="+expressions+";"; } - } - - /** return statement, such as "return foo,bar" */ - public static final class ReturnStat extends LSStatement { - public final LSFunction function; - public final List expressions; - ReturnStat(LSFunction function, List expressions) { - super( Type.returnStat ); - this.function = function; - this.expressions = expressions; - } - public String toString() { return "return "+expressions+";"; } - public boolean isNextStatementReachable() { - return false; - } - } - - /** break statement */ - public static final class BreakStat extends LSStatement { - BreakStat() { - super( Type.breakStat ); - } - public String toString() { return "break;"; } - } - - /** True of this statment could return and therefore the next statement is reachable. */ - public boolean isNextStatementReachable() { - return true; - } - - public static boolean isNextStatementReachable(List stats) { - if ( stats == null ) - return true; - for ( LSStatement s : stats ) - if ( ! s.isNextStatementReachable() ) - return false; - return true; - } -} diff --git a/src/jse/org/luaj/vm2/luajc/lst/LSVariable.java b/src/jse/org/luaj/vm2/luajc/lst/LSVariable.java deleted file mode 100644 index c36f96cf..00000000 --- a/src/jse/org/luaj/vm2/luajc/lst/LSVariable.java +++ /dev/null @@ -1,172 +0,0 @@ -/******************************************************************************* -* Copyright (c) 2009 Luaj.org. All rights reserved. -* -* Permission is hereby granted, free of charge, to any person obtaining a copy -* of this software and associated documentation files (the "Software"), to deal -* in the Software without restriction, including without limitation the rights -* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -* copies of the Software, and to permit persons to whom the Software is -* furnished to do so, subject to the following conditions: -* -* The above copyright notice and this permission notice shall be included in -* all copies or substantial portions of the Software. -* -* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -* THE SOFTWARE. -******************************************************************************/ -package org.luaj.vm2.luajc.lst; - -import java.util.List; - -public class LSVariable extends LSExpression { - - LSVariable(Type type) { - super(type); - } - - /** name, such as 'foo' */ - public static LSVariable nameVariable(Name name) { - return new NameReference(name); - } - - /** table field, such as 'a.b' */ - public LSVariable fieldVariable(String field) { - return new Field(this, field); - } - - /** method reference, such as foo:bar */ - public LSVariable methodVariable(String method) { - return new Method(this, method); - } - - /** parenthetical reference, such as '(foo())' */ - public static LSVariable parenthesesVariable(LSExpression expression) { - if ( expression != null ) - expression.setNumReturns(1); - return new Parentheses(expression); - } - - /** table index, such as 'a[b]' */ - public LSVariable indexVariable(LSExpression expression) { - return new Index(this, expression); - } - - /** Variable is a method, such as 'a(x,y)' */ - public LSVariable callFuncVariable(List parameters) { - int n = parameters.size(); - for ( int i=0; i parameters) { - int n = parameters.size(); - for ( int i=0; i parameters; - public int numReturns = 0; - public CallFunction(LSVariable variable, List parameters) { - super( Type.callFunctionVariable ); - this.variable = variable; - this.parameters = parameters; - } - public void setNumReturns(int i) { - this.numReturns = i; - } - public int getNumReturns() { - return numReturns; - } - public String toString() { return variable+"("+parameters+")"; } - } - - /** Variable is a method invocation, such as 'a:bc()' */ - public static class CallMethod extends LSVariable { - public final LSVariable variable; - public final String method; - public final List parameters; - public int numReturns = 0; - public CallMethod(LSVariable variable, String method, List parameters) { - super( Type.callMethodVariable ); - this.variable = variable; - this.method = method; - this.parameters = parameters; - } - public void setNumReturns(int i) { - this.numReturns = i; - } - public int getNumReturns() { - return numReturns; - } - public String toString() { return variable+":"+method+"("+parameters+")"; } - } - -} diff --git a/src/jse/org/luaj/vm2/luajc/lst/Name.java b/src/jse/org/luaj/vm2/luajc/lst/Name.java deleted file mode 100644 index f94242a4..00000000 --- a/src/jse/org/luaj/vm2/luajc/lst/Name.java +++ /dev/null @@ -1,73 +0,0 @@ -/******************************************************************************* -* Copyright (c) 2009 Luaj.org. All rights reserved. -* -* Permission is hereby granted, free of charge, to any person obtaining a copy -* of this software and associated documentation files (the "Software"), to deal -* in the Software without restriction, including without limitation the rights -* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -* copies of the Software, and to permit persons to whom the Software is -* furnished to do so, subject to the following conditions: -* -* The above copyright notice and this permission notice shall be included in -* all copies or substantial portions of the Software. -* -* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -* THE SOFTWARE. -******************************************************************************/ -package org.luaj.vm2.luajc.lst; - -/** A name in lua source, which resolves to one of: - * - global reference - * - local that is not an upvalue - * - local that is an upvalue - */ -public class Name { - - /** Name in lua source file */ - public final String luaname; - - /** 0 if in outermost scope, 1 if in next inner scope, ect. */ - public final int scopelevel; - - /** 0 if first declaration in global program, 1 if second use, etc. */ - public final int outerrevision; - - /** 0 if first declaration in nearest enclosing function, 1 if second use, etc */ - public final int innerrevision; - - /** true if used as an upvalue by some enclosed function */ - public boolean isupvalue; - - /** Construct a name instance */ - public Name(String luaname, int scopelevel, int outerrevision, int innterrevision) { - super(); - this.luaname = luaname; - this.scopelevel = scopelevel; - this.outerrevision = outerrevision; - this.innerrevision = innterrevision; - } - - /** Construct a name reference representing a global reference */ - public Name(String name) { - this.luaname = name; - this.scopelevel = -1; - this.outerrevision = -1; - this.innerrevision = -1; - } - - public String toString() { - return scopelevel<0? - "_G$"+luaname: - luaname+"$s"+scopelevel+"$v"+outerrevision+"$f"+innerrevision; - } - - public boolean isGlobal() { - return -1 == outerrevision; - } - -} diff --git a/src/jse/org/luaj/vm2/luajc/lst/Scope.java b/src/jse/org/luaj/vm2/luajc/lst/Scope.java deleted file mode 100644 index 77114a37..00000000 --- a/src/jse/org/luaj/vm2/luajc/lst/Scope.java +++ /dev/null @@ -1,103 +0,0 @@ -/******************************************************************************* -* Copyright (c) 2009 Luaj.org. All rights reserved. -* -* Permission is hereby granted, free of charge, to any person obtaining a copy -* of this software and associated documentation files (the "Software"), to deal -* in the Software without restriction, including without limitation the rights -* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -* copies of the Software, and to permit persons to whom the Software is -* furnished to do so, subject to the following conditions: -* -* The above copyright notice and this permission notice shall be included in -* all copies or substantial portions of the Software. -* -* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -* THE SOFTWARE. -******************************************************************************/ -package org.luaj.vm2.luajc.lst; - -import java.util.HashMap; -import java.util.Map; - -/** A name scope in lua source terms. - * Combination of function scope and block scope. - */ -public class Scope { - public final Scope parent; - public final int level; - public final boolean isFunctionScope; - public boolean hasAndOrLogic; - public final Map names = new HashMap(); - - /** Construct a new default scope for a chunk */ - public Scope() { - this.parent = null; - this.isFunctionScope = true; - this.level = 0; - } - - /** Construct an inner scope - * @param parent the outer scope to fall back to, or null if a global scope - * @param isFunctionScope true if this is a function scope, false otherwise - */ - public Scope(Scope parent, boolean isFunctionScope) { - this.parent = parent; - this.isFunctionScope = isFunctionScope; - this.level = parent!=null? parent.level + 1: 0; - } - - /** Declare a single name in the current scope, and return the Name element for it */ - public Name declare(String name) { - boolean crossesFunctionBoundary = false; - for ( Scope s=this; s!=null; s=s.parent ) { - Name n = s.names.get(name); - if ( n != null ) { - Name result = new Name(name, - level, - n.outerrevision+1, - crossesFunctionBoundary? 0: n.innerrevision+1); - names.put(name, result); - return result; - } - if ( s.isFunctionScope ) - crossesFunctionBoundary = true; - } - Name result = new Name(name, level, 0, 0); - names.put(name, result); - return result; - } - - /** Reference a name, and find either the local scope within the function, the upvalue, or a global name */ - public Name reference(String name) { - boolean crossesFunctionBoundary = false; - for ( Scope s=this; s!=null; s=s.parent ) { - Name n = s.names.get(name); - if ( n != null ) { - if ( crossesFunctionBoundary ) { - n.isupvalue = true; - } - return n; - } - if ( s.isFunctionScope ) - crossesFunctionBoundary = true; - } - // globally scoped name - return new Name(name); - } - - public String toString() { - String ours = (isFunctionScope? "F": "")+names; - return (parent==null? ours: ours+"->"+parent.toString()); - } - - /** Return true iff this scope is part the main chunk */ - public boolean isMainChunkScope() { - return isFunctionScope? false: parent==null? true: parent.isMainChunkScope(); - } -} - diff --git a/src/jse/org/luaj/vm2/luajc/lst/UnOp.java b/src/jse/org/luaj/vm2/luajc/lst/UnOp.java deleted file mode 100644 index 2fc2b44c..00000000 --- a/src/jse/org/luaj/vm2/luajc/lst/UnOp.java +++ /dev/null @@ -1,43 +0,0 @@ -/******************************************************************************* -* Copyright (c) 2009 Luaj.org. All rights reserved. -* -* Permission is hereby granted, free of charge, to any person obtaining a copy -* of this software and associated documentation files (the "Software"), to deal -* in the Software without restriction, including without limitation the rights -* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -* copies of the Software, and to permit persons to whom the Software is -* furnished to do so, subject to the following conditions: -* -* The above copyright notice and this permission notice shall be included in -* all copies or substantial portions of the Software. -* -* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -* THE SOFTWARE. -******************************************************************************/ -package org.luaj.vm2.luajc.lst; - -public class UnOp { - public enum Type { - neg,not,len - } - - public static final UnOp NEG = new UnOp(Type.neg, "-"); - public static final UnOp NOT = new UnOp(Type.not, "~"); - public static final UnOp LEN = new UnOp(Type.len, "#"); - - public final Type type; - public final String luaop; - - private UnOp(Type type, String luaop) { - super(); - this.type = type; - this.luaop = luaop; - } - - public String toString() { return luaop; } -} diff --git a/test/java/org/luaj/luajc/TestLuaJC.java b/test/java/org/luaj/luajc/TestLuaJC.java index e68fb130..c18ca5d7 100644 --- a/test/java/org/luaj/luajc/TestLuaJC.java +++ b/test/java/org/luaj/luajc/TestLuaJC.java @@ -28,7 +28,7 @@ import org.luaj.vm2.LuaTable; import org.luaj.vm2.LuaValue; import org.luaj.vm2.Varargs; import org.luaj.vm2.lib.JsePlatform; -import org.luaj.vm2.luajc.LuaJCompiler; +import org.luaj.vm2.luajc.LuaJC; public class TestLuaJC { // create the script @@ -48,9 +48,7 @@ public class TestLuaJC { LuaValue chunk; if ( ! (args.length>0 && args[0].equals("nocompile")) ) { InputStream is = new ByteArrayInputStream( script.getBytes() ); - String java =LuaJCompiler.compileToJava(is, "script"); - System.out.println("java:\n"+java); - chunk = LuaJCompiler.javaCompile(java, "script"); + chunk = LuaJC.getInstance().load(is, "script", _G); } else { chunk = (LuaValue) Class.forName("script").newInstance(); } diff --git a/test/junit/org/luaj/vm2/CompatibiltyTest.java b/test/junit/org/luaj/vm2/CompatibiltyTest.java index e3722920..fa8335bc 100644 --- a/test/junit/org/luaj/vm2/CompatibiltyTest.java +++ b/test/junit/org/luaj/vm2/CompatibiltyTest.java @@ -25,7 +25,7 @@ import junit.framework.Test; import junit.framework.TestSuite; import org.luaj.vm2.compiler.LuaC; -import org.luaj.vm2.luajc.JavaBytecodeCompiler; +import org.luaj.vm2.luajc.LuaJC; /** * Compatibility tests for the Luaj VM @@ -92,7 +92,7 @@ public class CompatibiltyTest { protected void setUp() throws Exception { super.setUp(); System.setProperty("JME", "false"); - JavaBytecodeCompiler.install(); + LuaJC.install(); } // not supported on this platform - don't test public void testDebugLib() {} diff --git a/test/junit/org/luaj/vm2/FragmentsTest.java b/test/junit/org/luaj/vm2/FragmentsTest.java index a62df6ed..988a80e7 100644 --- a/test/junit/org/luaj/vm2/FragmentsTest.java +++ b/test/junit/org/luaj/vm2/FragmentsTest.java @@ -27,7 +27,7 @@ import java.io.InputStream; import junit.framework.TestCase; import org.luaj.vm2.compiler.LuaC; -import org.luaj.vm2.luajc.JavaBytecodeCompiler; +import org.luaj.vm2.luajc.LuaJC; /** * Test compilation of various fragments that have @@ -43,7 +43,7 @@ public class FragmentsTest extends TestCase { InputStream is = new ByteArrayInputStream(script.getBytes("UTF-8")); LuaValue chunk ; if ( true ) { - chunk = JavaBytecodeCompiler.load(is,name,_G); + chunk = LuaJC.getInstance().load(is,name,_G); } else { chunk = (new LuaC()).load( is, name, _G ); } diff --git a/test/junit/org/luaj/vm2/ScriptDrivenTest.java b/test/junit/org/luaj/vm2/ScriptDrivenTest.java index 47ecfcc3..2c328d65 100644 --- a/test/junit/org/luaj/vm2/ScriptDrivenTest.java +++ b/test/junit/org/luaj/vm2/ScriptDrivenTest.java @@ -32,7 +32,7 @@ import java.io.PrintStream; import junit.framework.TestCase; import org.luaj.vm2.lib.BaseLib; -import org.luaj.vm2.luajc.JavaBytecodeCompiler; +import org.luaj.vm2.luajc.LuaJC; abstract public class ScriptDrivenTest extends TestCase { @@ -111,7 +111,7 @@ public class ScriptDrivenTest extends TestCase { return c; } else { script = new FileInputStream(file); - return JavaBytecodeCompiler.load( script, name, _G); + return LuaJC.getInstance().load( script, name, _G); } default: script = new FileInputStream(file);