- * The buffer can begin initially as a wrapped {@link LuaValue} - * and only when concatenation actually occurs are the bytes first copied. - *
- * To convert back to a {@link LuaValue} again, - * the function {@link Buffer#value()} is used. + * The buffer can begin initially as a wrapped {@link LuaValue} and only when + * concatenation actually occurs are the bytes first copied. + *
+ * To convert back to a {@link LuaValue} again, the function + * {@link Buffer#value()} is used. + * * @see LuaValue * @see LuaValue#buffer() * @see LuaString */ public final class Buffer { - + /** Default capacity for a buffer: 64 */ private static final int DEFAULT_CAPACITY = 64; - + /** Shared static array with no bytes */ private static final byte[] NOBYTES = {}; /** Bytes in this buffer */ private byte[] bytes; - + /** Length of this buffer */ private int length; - + /** Offset into the byte array */ private int offset; - + /** Value of this buffer, when not represented in bytes */ private LuaValue value; - + /** * Create buffer with default capacity + * * @see #DEFAULT_CAPACITY */ public Buffer() { this(DEFAULT_CAPACITY); } - + /** * Create buffer with specified initial capacity + * * @param initialCapacity the initial capacity */ - public Buffer( int initialCapacity ) { - bytes = new byte[ initialCapacity ]; + public Buffer(int initialCapacity) { + bytes = new byte[initialCapacity]; length = 0; offset = 0; value = null; } - + /** * Create buffer with specified initial value + * * @param value the initial value */ public Buffer(LuaValue value) { @@ -84,16 +87,18 @@ public final class Buffer { this.value = value; } - /** + /** * Get buffer contents as a {@link LuaValue} + * * @return value as a {@link LuaValue}, converting as necessary */ public LuaValue value() { return value != null? value: this.tostring(); } - /** + /** * Set buffer contents as a {@link LuaValue} + * * @param value value to set */ public Buffer setvalue(LuaValue value) { @@ -102,145 +107,170 @@ public final class Buffer { this.value = value; return this; } - - /** + + /** * Convert the buffer to a {@link LuaString} + * * @return the value as a {@link LuaString} */ public final LuaString tostring() { - realloc( length, 0 ); - return LuaString.valueOf( bytes, offset, length ); + realloc(length, 0); + return LuaString.valueOf(bytes, offset, length); } - - /** + + /** * Convert the buffer to a Java String + * * @return the value as a Java String */ public String tojstring() { return value().tojstring(); } - - /** + + /** * Convert the buffer to a Java String + * * @return the value as a Java String */ public String toString() { return tojstring(); } - /** + /** * Append a single byte to the buffer. + * * @return {@code this} to allow call chaining */ - public final Buffer append( byte b ) { - makeroom( 0, 1 ); - bytes[ offset + length++ ] = b; + public final Buffer append(byte b) { + makeroom(0, 1); + bytes[offset+length++] = b; return this; } - /** + /** * Append a {@link LuaValue} to the buffer. + * * @return {@code this} to allow call chaining */ - public final Buffer append( LuaValue val ) { - append( val.strvalue() ); + public final Buffer append(LuaValue val) { + append(val.strvalue()); return this; } - - /** + + /** * Append a {@link LuaString} to the buffer. + * * @return {@code this} to allow call chaining */ - public final Buffer append( LuaString str ) { + public final Buffer append(LuaString str) { final int n = str.m_length; - makeroom( 0, n ); - str.copyInto( 0, bytes, offset + length, n ); + makeroom(0, n); + str.copyInto(0, bytes, offset+length, n); length += n; return this; } - - /** - * Append a Java String to the buffer. - * The Java string will be converted to bytes using the UTF8 encoding. + + /** + * Append a Java String to the buffer. The Java string will be converted to + * bytes using the UTF8 encoding. + * * @return {@code this} to allow call chaining * @see LuaString#encodeToUtf8(char[], int, byte[], int) */ - public final Buffer append( String str ) { + public final Buffer append(String str) { char[] c = str.toCharArray(); - final int n = LuaString.lengthAsUtf8( c ); - makeroom( 0, n ); - LuaString.encodeToUtf8( c, c.length, bytes, offset + length ); + final int n = LuaString.lengthAsUtf8(c); + makeroom(0, n); + LuaString.encodeToUtf8(c, c.length, bytes, offset+length); length += n; return this; } - /** Concatenate this buffer onto a {@link LuaValue} - * @param lhs the left-hand-side value onto which we are concatenating {@code this} + /** + * Concatenate this buffer onto a {@link LuaValue} + * + * @param lhs the left-hand-side value onto which we are concatenating + * {@code this} * @return {@link Buffer} for use in call chaining. */ public Buffer concatTo(LuaValue lhs) { return setvalue(lhs.concat(value())); } - /** Concatenate this buffer onto a {@link LuaString} - * @param lhs the left-hand-side value onto which we are concatenating {@code this} + /** + * Concatenate this buffer onto a {@link LuaString} + * + * @param lhs the left-hand-side value onto which we are concatenating + * {@code this} * @return {@link Buffer} for use in call chaining. */ public Buffer concatTo(LuaString lhs) { - return value!=null&&!value.isstring()? setvalue(lhs.concat(value)): prepend(lhs); + return value != null && !value.isstring()? setvalue(lhs.concat(value)): prepend(lhs); } - /** Concatenate this buffer onto a {@link LuaNumber} + /** + * Concatenate this buffer onto a {@link LuaNumber} *
- * The {@link LuaNumber} will be converted to a string before concatenating.
- * @param lhs the left-hand-side value onto which we are concatenating {@code this}
+ * The {@link LuaNumber} will be converted to a string before concatenating.
+ *
+ * @param lhs the left-hand-side value onto which we are concatenating
+ * {@code this}
* @return {@link Buffer} for use in call chaining.
*/
public Buffer concatTo(LuaNumber lhs) {
- return value!=null&&!value.isstring()? setvalue(lhs.concat(value)): prepend(lhs.strvalue());
+ return value != null && !value.isstring()? setvalue(lhs.concat(value)): prepend(lhs.strvalue());
}
- /** Concatenate bytes from a {@link LuaString} onto the front of this buffer
- * @param s the left-hand-side value which we will concatenate onto the front of {@code this}
+ /**
+ * Concatenate bytes from a {@link LuaString} onto the front of this buffer
+ *
+ * @param s the left-hand-side value which we will concatenate onto the
+ * front of {@code this}
* @return {@link Buffer} for use in call chaining.
*/
public Buffer prepend(LuaString s) {
int n = s.m_length;
- makeroom( n, 0 );
- System.arraycopy( s.m_bytes, s.m_offset, bytes, offset-n, n );
+ makeroom(n, 0);
+ System.arraycopy(s.m_bytes, s.m_offset, bytes, offset-n, n);
offset -= n;
length += n;
value = null;
return this;
}
- /** Ensure there is enough room before and after the bytes.
- * @param nbefore number of unused bytes which must precede the data after this completes
- * @param nafter number of unused bytes which must follow the data after this completes
+ /**
+ * Ensure there is enough room before and after the bytes.
+ *
+ * @param nbefore number of unused bytes which must precede the data after
+ * this completes
+ * @param nafter number of unused bytes which must follow the data after
+ * this completes
*/
- public final void makeroom( int nbefore, int nafter ) {
- if ( value != null ) {
+ public final void makeroom(int nbefore, int nafter) {
+ if (value != null) {
LuaString s = value.strvalue();
value = null;
length = s.m_length;
offset = nbefore;
bytes = new byte[nbefore+length+nafter];
System.arraycopy(s.m_bytes, s.m_offset, bytes, offset, length);
- } else if ( offset+length+nafter > bytes.length || offset
- * For specialized circumstances, the Globals may be constructed directly and loaded
- * with only those libraries that are needed, for example.
- *
- * There are alternate flows when the direct lua-to-Java bytecode compiling {@link org.luaj.vm2.luajc.LuaJC} is used.
+ * There are alternate flows when the direct lua-to-Java bytecode compiling
+ * {@link org.luaj.vm2.luajc.LuaJC} is used.
*
*
* @see org.luaj.vm2.lib.jse.JsePlatform
@@ -115,7 +136,7 @@ import org.luaj.vm2.lib.ResourceFinder;
public class Globals extends LuaTable {
/** The current default input stream. */
- public InputStream STDIN = null;
+ public InputStream STDIN = null;
/** The current default output stream. */
public PrintStream STDOUT = System.out;
@@ -125,28 +146,42 @@ public class Globals extends LuaTable {
/** The installed ResourceFinder for looking files by name. */
public ResourceFinder finder;
-
- /** The currently running thread. Should not be changed by non-library code. */
+
+ /**
+ * The currently running thread. Should not be changed by non-library code.
+ */
public LuaThread running = new LuaThread(this);
/** The BaseLib instance loaded into this Globals */
public BaseLib baselib;
-
+
/** The PackageLib instance loaded into this Globals */
public PackageLib package_;
-
- /** The DebugLib instance loaded into this Globals, or null if debugging is not enabled */
+
+ /**
+ * The DebugLib instance loaded into this Globals, or null if debugging is
+ * not enabled
+ */
public DebugLib debuglib;
- /** Interface for module that converts a Prototype into a LuaFunction with an environment. */
+ /**
+ * Interface for module that converts a Prototype into a LuaFunction with an
+ * environment.
+ */
public interface Loader {
- /** Convert the prototype into a LuaFunction with the supplied environment. */
+ /**
+ * Convert the prototype into a LuaFunction with the supplied
+ * environment.
+ */
LuaFunction load(Prototype prototype, String chunkname, LuaValue env) throws IOException;
}
/** Interface for module that converts lua source text into a prototype. */
public interface Compiler {
- /** Compile lua source into a Prototype. The InputStream is assumed to be in UTF-8. */
+ /**
+ * Compile lua source into a Prototype. The InputStream is assumed to be
+ * in UTF-8.
+ */
Prototype compile(InputStream stream, String chunkname) throws IOException;
}
@@ -155,100 +190,142 @@ public class Globals extends LuaTable {
/** Load the supplied input stream into a prototype. */
Prototype undump(InputStream stream, String chunkname) throws IOException;
}
-
- /** Check that this object is a Globals object, and return it, otherwise throw an error. */
+
+ /**
+ * Check that this object is a Globals object, and return it, otherwise
+ * throw an error.
+ */
public Globals checkglobals() {
return this;
}
-
- /** The installed loader.
- * @see Loader */
+
+ /**
+ * The installed loader.
+ *
+ * @see Loader
+ */
public Loader loader;
- /** The installed compiler.
- * @see Compiler */
+ /**
+ * The installed compiler.
+ *
+ * @see Compiler
+ */
public Compiler compiler;
- /** The installed undumper.
- * @see Undumper */
+ /**
+ * The installed undumper.
+ *
+ * @see Undumper
+ */
public Undumper undumper;
- /** Convenience function for loading a file that is either binary lua or lua source.
+ /**
+ * Convenience function for loading a file that is either binary lua or lua
+ * source.
+ *
* @param filename Name of the file to load.
* @return LuaValue that can be call()'ed or invoke()'ed.
* @throws LuaError if the file could not be loaded.
*/
public LuaValue loadfile(String filename) {
try {
- return load(finder.findResource(filename), "@"+filename, "bt", this);
+ return load(finder.findResource(filename), "@" + filename, "bt", this);
} catch (Exception e) {
- return error("load "+filename+": "+e);
+ return error("load " + filename + ": " + e);
}
}
- /** Convenience function to load a string value as a script. Must be lua source.
- * @param script Contents of a lua script, such as "print 'hello, world.'"
+ /**
+ * Convenience function to load a string value as a script. Must be lua
+ * source.
+ *
+ * @param script Contents of a lua script, such as "print 'hello,
+ * world.'"
* @param chunkname Name that will be used within the chunk as the source.
- * @return LuaValue that may be executed via .call(), .invoke(), or .method() calls.
+ * @return LuaValue that may be executed via .call(), .invoke(), or
+ * .method() calls.
* @throws LuaError if the script could not be compiled.
*/
public LuaValue load(String script, String chunkname) {
return load(new StrReader(script), chunkname);
}
-
- /** Convenience function to load a string value as a script. Must be lua source.
+
+ /**
+ * Convenience function to load a string value as a script. Must be lua
+ * source.
+ *
* @param script Contents of a lua script, such as "print 'hello, world.'"
- * @return LuaValue that may be executed via .call(), .invoke(), or .method() calls.
+ * @return LuaValue that may be executed via .call(), .invoke(), or
+ * .method() calls.
* @throws LuaError if the script could not be compiled.
*/
public LuaValue load(String script) {
return load(new StrReader(script), script);
}
- /** Convenience function to load a string value as a script with a custom environment.
- * Must be lua source.
- * @param script Contents of a lua script, such as "print 'hello, world.'"
- * @param chunkname Name that will be used within the chunk as the source.
- * @param environment LuaTable to be used as the environment for the loaded function.
- * @return LuaValue that may be executed via .call(), .invoke(), or .method() calls.
+ /**
+ * Convenience function to load a string value as a script with a custom
+ * environment. Must be lua source.
+ *
+ * @param script Contents of a lua script, such as "print 'hello,
+ * world.'"
+ * @param chunkname Name that will be used within the chunk as the source.
+ * @param environment LuaTable to be used as the environment for the loaded
+ * function.
+ * @return LuaValue that may be executed via .call(), .invoke(), or
+ * .method() calls.
* @throws LuaError if the script could not be compiled.
*/
public LuaValue load(String script, String chunkname, LuaTable environment) {
return load(new StrReader(script), chunkname, environment);
}
- /** Load the content form a reader as a text file. Must be lua source.
- * The source is converted to UTF-8, so any characters appearing in quoted literals
- * above the range 128 will be converted into multiple bytes.
- * @param reader Reader containing text of a lua script, such as "print 'hello, world.'"
+ /**
+ * Load the content form a reader as a text file. Must be lua source. The
+ * source is converted to UTF-8, so any characters appearing in quoted
+ * literals above the range 128 will be converted into multiple bytes.
+ *
+ * @param reader Reader containing text of a lua script, such as "print
+ * 'hello, world.'"
* @param chunkname Name that will be used within the chunk as the source.
- * @return LuaValue that may be executed via .call(), .invoke(), or .method() calls.
+ * @return LuaValue that may be executed via .call(), .invoke(), or
+ * .method() calls.
* @throws LuaError if the script could not be compiled.
- */
+ */
public LuaValue load(Reader reader, String chunkname) {
return load(new UTF8Stream(reader), chunkname, "t", this);
}
- /** Load the content form a reader as a text file, supplying a custom environment.
- * Must be lua source. The source is converted to UTF-8, so any characters
- * appearing in quoted literals above the range 128 will be converted into
- * multiple bytes.
- * @param reader Reader containing text of a lua script, such as "print 'hello, world.'"
- * @param chunkname Name that will be used within the chunk as the source.
- * @param environment LuaTable to be used as the environment for the loaded function.
- * @return LuaValue that may be executed via .call(), .invoke(), or .method() calls.
+ /**
+ * Load the content form a reader as a text file, supplying a custom
+ * environment. Must be lua source. The source is converted to UTF-8, so any
+ * characters appearing in quoted literals above the range 128 will be
+ * converted into multiple bytes.
+ *
+ * @param reader Reader containing text of a lua script, such as "print
+ * 'hello, world.'"
+ * @param chunkname Name that will be used within the chunk as the source.
+ * @param environment LuaTable to be used as the environment for the loaded
+ * function.
+ * @return LuaValue that may be executed via .call(), .invoke(), or
+ * .method() calls.
* @throws LuaError if the script could not be compiled.
- */
+ */
public LuaValue load(Reader reader, String chunkname, LuaTable environment) {
return load(new UTF8Stream(reader), chunkname, "t", environment);
- }
+ }
- /** Load the content form an input stream as a binary chunk or text file.
- * @param is InputStream containing a lua script or compiled lua"
- * @param chunkname Name that will be used within the chunk as the source.
- * @param mode String containing 'b' or 't' or both to control loading as binary or text or either.
- * @param environment LuaTable to be used as the environment for the loaded function.
- * */
+ /**
+ * Load the content form an input stream as a binary chunk or text file.
+ *
+ * @param is InputStream containing a lua script or compiled lua"
+ * @param chunkname Name that will be used within the chunk as the source.
+ * @param mode String containing 'b' or 't' or both to control
+ * loading as binary or text or either.
+ * @param environment LuaTable to be used as the environment for the loaded
+ * function.
+ */
public LuaValue load(InputStream is, String chunkname, String mode, LuaValue environment) {
try {
Prototype p = loadPrototype(is, chunkname, mode);
@@ -256,16 +333,20 @@ public class Globals extends LuaTable {
} catch (LuaError l) {
throw l;
} catch (Exception e) {
- return error("load "+chunkname+": "+e);
+ return error("load " + chunkname + ": " + e);
}
}
- /** Load lua source or lua binary from an input stream into a Prototype.
- * The InputStream is either a binary lua chunk starting with the lua binary chunk signature,
- * or a text input file. If it is a text input file, it is interpreted as a UTF-8 byte sequence.
- * @param is Input stream containing a lua script or compiled lua"
+ /**
+ * Load lua source or lua binary from an input stream into a Prototype. The
+ * InputStream is either a binary lua chunk starting with the lua binary
+ * chunk signature, or a text input file. If it is a text input file, it is
+ * interpreted as a UTF-8 byte sequence.
+ *
+ * @param is Input stream containing a lua script or compiled lua"
* @param chunkname Name that will be used within the chunk as the source.
- * @param mode String containing 'b' or 't' or both to control loading as binary or text or either.
+ * @param mode String containing 'b' or 't' or both to control loading
+ * as binary or text or either.
*/
public Prototype loadPrototype(InputStream is, String chunkname, String mode) throws IOException {
if (mode.indexOf('b') >= 0) {
@@ -282,21 +363,25 @@ public class Globals extends LuaTable {
if (mode.indexOf('t') >= 0) {
return compilePrototype(is, chunkname);
}
- error("Failed to load prototype "+chunkname+" using mode '"+mode+"'");
+ error("Failed to load prototype " + chunkname + " using mode '" + mode + "'");
return null;
}
-
- /** Compile lua source from a Reader into a Prototype. The characters in the reader
- * are converted to bytes using the UTF-8 encoding, so a string literal containing
- * characters with codepoints 128 or above will be converted into multiple bytes.
+
+ /**
+ * Compile lua source from a Reader into a Prototype. The characters in the
+ * reader are converted to bytes using the UTF-8 encoding, so a string
+ * literal containing characters with codepoints 128 or above will be
+ * converted into multiple bytes.
*/
public Prototype compilePrototype(Reader reader, String chunkname) throws IOException {
return compilePrototype(new UTF8Stream(reader), chunkname);
}
-
- /** Compile lua source from an InputStream into a Prototype.
- * The input is assumed to be UTf-8, but since bytes in the range 128-255 are passed along as
- * literal bytes, any ASCII-compatible encoding such as ISO 8859-1 may also be used.
+
+ /**
+ * Compile lua source from an InputStream into a Prototype. The input is
+ * assumed to be UTf-8, but since bytes in the range 128-255 are passed
+ * along as literal bytes, any ASCII-compatible encoding such as ISO 8859-1
+ * may also be used.
*/
public Prototype compilePrototype(InputStream stream, String chunkname) throws IOException {
if (compiler == null)
@@ -304,9 +389,13 @@ public class Globals extends LuaTable {
return compiler.compile(stream, chunkname);
}
- /** Function which yields the current thread.
- * @param args Arguments to supply as return values in the resume function of the resuming thread.
- * @return Values supplied as arguments to the resume() call that reactivates this thread.
+ /**
+ * Function which yields the current thread.
+ *
+ * @param args Arguments to supply as return values in the resume function
+ * of the resuming thread.
+ * @return Values supplied as arguments to the resume() call that
+ * reactivates this thread.
*/
public Varargs yield(Varargs args) {
if (running == null || running.isMainThread())
@@ -318,23 +407,27 @@ public class Globals extends LuaTable {
/** Reader implementation to read chars from a String in JME or JSE. */
static class StrReader extends Reader {
final String s;
- int i = 0;
- final int n;
+ int i = 0;
+ final int n;
+
StrReader(String s) {
this.s = s;
n = s.length();
}
+
public void close() throws IOException {
i = n;
}
+
public int read() throws IOException {
- return i < n ? s.charAt(i++) : -1;
+ return i < n? s.charAt(i++): -1;
}
+
public int read(char[] cbuf, int off, int len) throws IOException {
int j = 0;
for (; j < len && i < n; ++j, ++i)
cbuf[off+j] = s.charAt(i);
- return j > 0 || len == 0 ? j : -1;
+ return j > 0 || len == 0? j: -1;
}
}
@@ -343,49 +436,61 @@ public class Globals extends LuaTable {
*/
abstract static class AbstractBufferedStream extends InputStream {
protected byte[] b;
- protected int i = 0, j = 0;
+ protected int i = 0, j = 0;
+
protected AbstractBufferedStream(int buflen) {
this.b = new byte[buflen];
}
+
abstract protected int avail() throws IOException;
+
public int read() throws IOException {
int a = avail();
- return (a <= 0 ? -1 : 0xff & b[i++]);
+ return (a <= 0? -1: 0xff & b[i++]);
}
+
public int read(byte[] b) throws IOException {
return read(b, 0, b.length);
}
+
public int read(byte[] b, int i0, int n) throws IOException {
int a = avail();
- if (a <= 0) return -1;
+ if (a <= 0)
+ return -1;
final int n_read = Math.min(a, n);
- System.arraycopy(this.b, i, b, i0, n_read);
+ System.arraycopy(this.b, i, b, i0, n_read);
i += n_read;
return n_read;
}
+
public long skip(long n) throws IOException {
- final long k = Math.min(n, j - i);
+ final long k = Math.min(n, j-i);
i += k;
return k;
- }
+ }
+
public int available() throws IOException {
- return j - i;
+ return j-i;
}
}
- /** Simple converter from Reader to InputStream using UTF8 encoding that will work
- * on both JME and JSE.
- * This class may be moved to its own package in the future.
+ /**
+ * Simple converter from Reader to InputStream using UTF8 encoding that will
+ * work on both JME and JSE. This class may be moved to its own package in
+ * the future.
*/
static class UTF8Stream extends AbstractBufferedStream {
private final char[] c = new char[32];
private final Reader r;
+
UTF8Stream(Reader r) {
super(96);
this.r = r;
}
+
protected int avail() throws IOException {
- if (i < j) return j - i;
+ if (i < j)
+ return j-i;
int n = r.read(c);
if (n < 0)
return -1;
@@ -399,31 +504,38 @@ public class Globals extends LuaTable {
j = LuaString.encodeToUtf8(c, n, b, i = 0);
return j;
}
+
public void close() throws IOException {
r.close();
}
}
-
- /** Simple buffered InputStream that supports mark.
- * Used to examine an InputStream for a 4-byte binary lua signature,
- * and fall back to text input when the signature is not found,
- * as well as speed up normal compilation and reading of lua scripts.
- * This class may be moved to its own package in the future.
+
+ /**
+ * Simple buffered InputStream that supports mark. Used to examine an
+ * InputStream for a 4-byte binary lua signature, and fall back to text
+ * input when the signature is not found, as well as speed up normal
+ * compilation and reading of lua scripts. This class may be moved to its
+ * own package in the future.
*/
static class BufferedStream extends AbstractBufferedStream {
private final InputStream s;
+
public BufferedStream(InputStream s) {
this(128, s);
}
+
BufferedStream(int buflen, InputStream s) {
super(buflen);
this.s = s;
}
+
protected int avail() throws IOException {
- if (i < j) return j - i;
- if (j >= b.length) i = j = 0;
+ if (i < j)
+ return j-i;
+ if (j >= b.length)
+ i = j = 0;
// leave previous bytes in place to implement mark()/reset().
- int n = s.read(b, j, b.length - j);
+ int n = s.read(b, j, b.length-j);
if (n < 0)
return -1;
if (n == 0) {
@@ -436,21 +548,25 @@ public class Globals extends LuaTable {
j += n;
return n;
}
+
public void close() throws IOException {
s.close();
}
+
public synchronized void mark(int n) {
if (i > 0 || n > b.length) {
- byte[] dest = n > b.length ? new byte[n] : b;
- System.arraycopy(b, i, dest, 0, j - i);
+ byte[] dest = n > b.length? new byte[n]: b;
+ System.arraycopy(b, i, dest, 0, j-i);
j -= i;
i = 0;
b = dest;
}
}
+
public boolean markSupported() {
return true;
}
+
public synchronized void reset() throws IOException {
i = 0;
}
diff --git a/luaj-core/src/main/java/org/luaj/vm2/LoadState.java b/luaj-core/src/main/java/org/luaj/vm2/LoadState.java
index 8d71a74a..c8624556 100644
--- a/luaj-core/src/main/java/org/luaj/vm2/LoadState.java
+++ b/luaj-core/src/main/java/org/luaj/vm2/LoadState.java
@@ -25,116 +25,141 @@ import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
-
/**
-* Class to undump compiled lua bytecode into a {@link Prototype} instances.
-*
-* The {@link LoadState} class provides the default {@link Globals.Undumper}
-* which is used to undump a string of bytes that represent a lua binary file
-* using either the C-based lua compiler, or luaj's
-* {@link org.luaj.vm2.compiler.LuaC} compiler.
-*
-* The canonical method to load and execute code is done
-* indirectly using the Globals:
-*
-* By default, when using {@link org.luaj.vm2.lib.jse.JsePlatform} or
-* {@link org.luaj.vm2.lib.jme.JmePlatform}
-* to construct globals, the {@link LoadState} default undumper is installed
-* as the default {@link Globals.Undumper}.
-*
-*
-* A lua binary file is created via the {@link org.luaj.vm2.compiler.DumpState} class
-:
-*
+ * The {@link LoadState} class provides the default {@link Globals.Undumper}
+ * which is used to undump a string of bytes that represent a lua binary file
+ * using either the C-based lua compiler, or luaj's
+ * {@link org.luaj.vm2.compiler.LuaC} compiler.
+ *
+ * The canonical method to load and execute code is done indirectly using the
+ * Globals:
+ *
+ *
+ * By default, when using {@link org.luaj.vm2.lib.jse.JsePlatform} or
+ * {@link org.luaj.vm2.lib.jme.JmePlatform} to construct globals, the
+ * {@link LoadState} default undumper is installed as the default
+ * {@link Globals.Undumper}.
+ *
+ *
+ * A lua binary file is created via the {@link org.luaj.vm2.compiler.DumpState}
+ * class :
+ *
+ *
- * These instance are not instantiated directly by clients.
- * Instead, there are exactly twon instances of this class,
- * {@link LuaValue#TRUE} and {@link LuaValue#FALSE}
- * representing the lua values {@code true} and {@code false}.
- * The function {@link LuaValue#valueOf(boolean)} will always
- * return one of these two values.
+ * These instance are not instantiated directly by clients. Instead, there are
+ * exactly twon instances of this class, {@link LuaValue#TRUE} and
+ * {@link LuaValue#FALSE} representing the lua values {@code true} and
+ * {@code false}. The function {@link LuaValue#valueOf(boolean)} will always
+ * return one of these two values.
*
- * Any {@link LuaValue} can be converted to its equivalent
- * boolean representation using {@link LuaValue#toboolean()}
+ * Any {@link LuaValue} can be converted to its equivalent boolean
+ * representation using {@link LuaValue#toboolean()}
*
+ *
* @see LuaValue
* @see LuaValue#valueOf(boolean)
* @see LuaValue#TRUE
@@ -43,10 +43,10 @@ public final class LuaBoolean extends LuaValue {
/** The singleton instance representing lua {@code true} */
static final LuaBoolean _TRUE = new LuaBoolean(true);
-
+
/** The singleton instance representing lua {@code false} */
static final LuaBoolean _FALSE = new LuaBoolean(false);
-
+
/** Shared static metatable for boolean values represented in lua. */
public static LuaValue s_metatable;
@@ -70,11 +70,12 @@ public final class LuaBoolean extends LuaValue {
}
public LuaValue not() {
- return v ? FALSE : LuaValue.TRUE;
+ return v? FALSE: LuaValue.TRUE;
}
/**
* Return the boolean value for this boolean
+ *
* @return value as a Java boolean
*/
public boolean booleanValue() {
@@ -86,18 +87,18 @@ public final class LuaBoolean extends LuaValue {
}
public String tojstring() {
- return v ? "true" : "false";
+ return v? "true": "false";
}
public boolean optboolean(boolean defval) {
return this.v;
}
-
+
public boolean checkboolean() {
return v;
}
-
- public LuaValue getmetatable() {
- return s_metatable;
+
+ public LuaValue getmetatable() {
+ return s_metatable;
}
}
diff --git a/luaj-core/src/main/java/org/luaj/vm2/LuaClosure.java b/luaj-core/src/main/java/org/luaj/vm2/LuaClosure.java
index 46a3556f..aa3ac55b 100644
--- a/luaj-core/src/main/java/org/luaj/vm2/LuaClosure.java
+++ b/luaj-core/src/main/java/org/luaj/vm2/LuaClosure.java
@@ -26,44 +26,56 @@ import org.luaj.vm2.lib.DebugLib.CallFrame;
/**
* Extension of {@link LuaFunction} which executes lua bytecode.
*
- * A {@link LuaClosure} is a combination of a {@link Prototype}
- * and a {@link LuaValue} to use as an environment for execution.
- * Normally the {@link LuaValue} is a {@link Globals} in which case the environment
- * will contain standard lua libraries.
+ * A {@link LuaClosure} is a combination of a {@link Prototype} and a
+ * {@link LuaValue} to use as an environment for execution. Normally the
+ * {@link LuaValue} is a {@link Globals} in which case the environment will
+ * contain standard lua libraries.
*
*
* There are three main ways {@link LuaClosure} instances are created:
*
- * To construct it directly, the {@link Prototype} is typically created via a compiler such as
- * {@link org.luaj.vm2.compiler.LuaC}:
- *
- * To construct it indirectly, the {@link Globals#load(java.io.Reader, String)} method may be used:
- *
* In this example, the "checkclosure()" may fail if direct lua-to-java-bytecode
- * compiling using LuaJC is installed, because no LuaClosure is created in that case
- * and the value returned is a {@link LuaFunction} but not a {@link LuaClosure}.
+ * compiling using LuaJC is installed, because no LuaClosure is created in that
+ * case and the value returned is a {@link LuaFunction} but not a
+ * {@link LuaClosure}.
*
- * Since a {@link LuaClosure} is a {@link LuaFunction} which is a {@link LuaValue},
- * all the value operations can be used directly such as:
+ * Since a {@link LuaClosure} is a {@link LuaFunction} which is a
+ * {@link LuaValue}, all the value operations can be used directly such as:
*
- * These instance are not instantiated directly by clients, but indirectly
- * via the static functions {@link LuaValue#valueOf(int)} or {@link LuaValue#valueOf(double)}
- * functions. This ensures that values which can be represented as int
- * are wrapped in {@link LuaInteger} instead of {@link LuaDouble}.
+ * These instance are not instantiated directly by clients, but indirectly via
+ * the static functions {@link LuaValue#valueOf(int)} or
+ * {@link LuaValue#valueOf(double)} functions. This ensures that values which
+ * can be represented as int are wrapped in {@link LuaInteger} instead of
+ * {@link LuaDouble}.
*
- * Almost all API's implemented in LuaDouble are defined and documented in {@link LuaValue}.
+ * Almost all API's implemented in LuaDouble are defined and documented in
+ * {@link LuaValue}.
*
* However the constants {@link #NAN}, {@link #POSINF}, {@link #NEGINF},
- * {@link #JSTR_NAN}, {@link #JSTR_POSINF}, and {@link #JSTR_NEGINF} may be useful
- * when dealing with Nan or Infinite values.
+ * {@link #JSTR_NAN}, {@link #JSTR_POSINF}, and {@link #JSTR_NEGINF} may be
+ * useful when dealing with Nan or Infinite values.
*
- * LuaDouble also defines functions for handling the unique math rules of lua devision and modulo in
+ * LuaDouble also defines functions for handling the unique math rules of lua
+ * devision and modulo in
*
+ *
* @see LuaValue
* @see LuaNumber
* @see LuaInteger
@@ -54,186 +58,260 @@ import org.luaj.vm2.lib.MathLib;
public class LuaDouble extends LuaNumber {
/** Constant LuaDouble representing NaN (not a number) */
- public static final LuaDouble NAN = new LuaDouble( Double.NaN );
-
+ public static final LuaDouble NAN = new LuaDouble(Double.NaN);
+
/** Constant LuaDouble representing positive infinity */
- public static final LuaDouble POSINF = new LuaDouble( Double.POSITIVE_INFINITY );
-
+ public static final LuaDouble POSINF = new LuaDouble(Double.POSITIVE_INFINITY);
+
/** Constant LuaDouble representing negative infinity */
- public static final LuaDouble NEGINF = new LuaDouble( Double.NEGATIVE_INFINITY );
-
+ public static final LuaDouble NEGINF = new LuaDouble(Double.NEGATIVE_INFINITY);
+
/** Constant String representation for NaN (not a number), "nan" */
- public static final String JSTR_NAN = "nan";
-
+ public static final String JSTR_NAN = "nan";
+
/** Constant String representation for positive infinity, "inf" */
public static final String JSTR_POSINF = "inf";
/** Constant String representation for negative infinity, "-inf" */
public static final String JSTR_NEGINF = "-inf";
-
+
/** The value being held by this instance. */
final double v;
public static LuaNumber valueOf(double d) {
int id = (int) d;
- return d==id? (LuaNumber) LuaInteger.valueOf(id): (LuaNumber) new LuaDouble(d);
+ return d == id? (LuaNumber) LuaInteger.valueOf(id): (LuaNumber) new LuaDouble(d);
}
-
- /** Don't allow ints to be boxed by DoubleValues */
+
+ /** Don't allow ints to be boxed by DoubleValues */
private LuaDouble(double d) {
this.v = d;
}
public int hashCode() {
- long l = Double.doubleToLongBits(v + 1);
- return ((int)(l>>32)) + (int) l;
+ long l = Double.doubleToLongBits(v+1);
+ return ((int) (l>>32))+(int) l;
}
-
+
public boolean islong() {
return v == (long) v;
}
-
- public byte tobyte() { return (byte) (long) v; }
- public char tochar() { return (char) (long) v; }
- public double todouble() { return v; }
- public float tofloat() { return (float) v; }
- public int toint() { return (int) (long) v; }
- public long tolong() { return (long) v; }
- public short toshort() { return (short) (long) v; }
- public double optdouble(double defval) { return v; }
- public int optint(int defval) { return (int) (long) v; }
- public LuaInteger optinteger(LuaInteger defval) { return LuaInteger.valueOf((int) (long)v); }
- public long optlong(long defval) { return (long) v; }
-
- public LuaInteger checkinteger() { return LuaInteger.valueOf( (int) (long) v ); }
-
+ public byte tobyte() { return (byte) (long) v; }
+
+ public char tochar() { return (char) (long) v; }
+
+ public double todouble() { return v; }
+
+ public float tofloat() { return (float) v; }
+
+ public int toint() { return (int) (long) v; }
+
+ public long tolong() { return (long) v; }
+
+ public short toshort() { return (short) (long) v; }
+
+ public double optdouble(double defval) { return v; }
+
+ public int optint(int defval) { return (int) (long) v; }
+
+ public LuaInteger optinteger(LuaInteger defval) { return LuaInteger.valueOf((int) (long) v); }
+
+ public long optlong(long defval) { return (long) v; }
+
+ public LuaInteger checkinteger() { return LuaInteger.valueOf((int) (long) v); }
+
// unary operators
public LuaValue neg() { return valueOf(-v); }
-
+
// object equality, used for key comparison
- public boolean equals(Object o) { return o instanceof LuaDouble? ((LuaDouble)o).v == v: false; }
-
+ public boolean equals(Object o) { return o instanceof LuaDouble? ((LuaDouble) o).v == v: false; }
+
// equality w/ metatable processing
- public LuaValue eq( LuaValue val ) { return val.raweq(v)? TRUE: FALSE; }
- public boolean eq_b( LuaValue val ) { return val.raweq(v); }
+ public LuaValue eq(LuaValue val) { return val.raweq(v)? TRUE: FALSE; }
+
+ public boolean eq_b(LuaValue val) { return val.raweq(v); }
// equality w/o metatable processing
- public boolean raweq( LuaValue val ) { return val.raweq(v); }
- public boolean raweq( double val ) { return v == val; }
- public boolean raweq( int val ) { return v == val; }
-
+ public boolean raweq(LuaValue val) { return val.raweq(v); }
+
+ public boolean raweq(double val) { return v == val; }
+
+ public boolean raweq(int val) { return v == val; }
+
// basic binary arithmetic
- public LuaValue add( LuaValue rhs ) { return rhs.add(v); }
- public LuaValue add( double lhs ) { return LuaDouble.valueOf(lhs + v); }
- public LuaValue sub( LuaValue rhs ) { return rhs.subFrom(v); }
- public LuaValue sub( double rhs ) { return LuaDouble.valueOf(v - rhs); }
- public LuaValue sub( int rhs ) { return LuaDouble.valueOf(v - rhs); }
- public LuaValue subFrom( double lhs ) { return LuaDouble.valueOf(lhs - v); }
- public LuaValue mul( LuaValue rhs ) { return rhs.mul(v); }
- public LuaValue mul( double lhs ) { return LuaDouble.valueOf(lhs * v); }
- public LuaValue mul( int lhs ) { return LuaDouble.valueOf(lhs * v); }
- public LuaValue pow( LuaValue rhs ) { return rhs.powWith(v); }
- public LuaValue pow( double rhs ) { return MathLib.dpow(v,rhs); }
- public LuaValue pow( int rhs ) { return MathLib.dpow(v,rhs); }
- public LuaValue powWith( double lhs ) { return MathLib.dpow(lhs,v); }
- public LuaValue powWith( int lhs ) { return MathLib.dpow(lhs,v); }
- public LuaValue div( LuaValue rhs ) { return rhs.divInto(v); }
- public LuaValue div( double rhs ) { return LuaDouble.ddiv(v,rhs); }
- public LuaValue div( int rhs ) { return LuaDouble.ddiv(v,rhs); }
- public LuaValue divInto( double lhs ) { return LuaDouble.ddiv(lhs,v); }
- public LuaValue mod( LuaValue rhs ) { return rhs.modFrom(v); }
- public LuaValue mod( double rhs ) { return LuaDouble.dmod(v,rhs); }
- public LuaValue mod( int rhs ) { return LuaDouble.dmod(v,rhs); }
- public LuaValue modFrom( double lhs ) { return LuaDouble.dmod(lhs,v); }
-
-
- /** Divide two double numbers according to lua math, and return a {@link LuaValue} result.
+ public LuaValue add(LuaValue rhs) { return rhs.add(v); }
+
+ public LuaValue add(double lhs) { return LuaDouble.valueOf(lhs+v); }
+
+ public LuaValue sub(LuaValue rhs) { return rhs.subFrom(v); }
+
+ public LuaValue sub(double rhs) { return LuaDouble.valueOf(v-rhs); }
+
+ public LuaValue sub(int rhs) { return LuaDouble.valueOf(v-rhs); }
+
+ public LuaValue subFrom(double lhs) { return LuaDouble.valueOf(lhs-v); }
+
+ public LuaValue mul(LuaValue rhs) { return rhs.mul(v); }
+
+ public LuaValue mul(double lhs) { return LuaDouble.valueOf(lhs*v); }
+
+ public LuaValue mul(int lhs) { return LuaDouble.valueOf(lhs*v); }
+
+ public LuaValue pow(LuaValue rhs) { return rhs.powWith(v); }
+
+ public LuaValue pow(double rhs) { return MathLib.dpow(v, rhs); }
+
+ public LuaValue pow(int rhs) { return MathLib.dpow(v, rhs); }
+
+ public LuaValue powWith(double lhs) { return MathLib.dpow(lhs, v); }
+
+ public LuaValue powWith(int lhs) { return MathLib.dpow(lhs, v); }
+
+ public LuaValue div(LuaValue rhs) { return rhs.divInto(v); }
+
+ public LuaValue div(double rhs) { return LuaDouble.ddiv(v, rhs); }
+
+ public LuaValue div(int rhs) { return LuaDouble.ddiv(v, rhs); }
+
+ public LuaValue divInto(double lhs) { return LuaDouble.ddiv(lhs, v); }
+
+ public LuaValue mod(LuaValue rhs) { return rhs.modFrom(v); }
+
+ public LuaValue mod(double rhs) { return LuaDouble.dmod(v, rhs); }
+
+ public LuaValue mod(int rhs) { return LuaDouble.dmod(v, rhs); }
+
+ public LuaValue modFrom(double lhs) { return LuaDouble.dmod(lhs, v); }
+
+ /**
+ * Divide two double numbers according to lua math, and return a
+ * {@link LuaValue} result.
+ *
* @param lhs Left-hand-side of the division.
* @param rhs Right-hand-side of the division.
- * @return {@link LuaValue} for the result of the division,
- * taking into account positive and negiative infinity, and Nan
+ * @return {@link LuaValue} for the result of the division, taking into
+ * account positive and negiative infinity, and Nan
* @see #ddiv_d(double, double)
*/
public static LuaValue ddiv(double lhs, double rhs) {
- return rhs!=0? valueOf( lhs / rhs ): lhs>0? POSINF: lhs==0? NAN: NEGINF;
+ return rhs != 0? valueOf(lhs/rhs): lhs > 0? POSINF: lhs == 0? NAN: NEGINF;
}
-
- /** Divide two double numbers according to lua math, and return a double result.
+
+ /**
+ * Divide two double numbers according to lua math, and return a double
+ * result.
+ *
* @param lhs Left-hand-side of the division.
* @param rhs Right-hand-side of the division.
- * @return Value of the division, taking into account positive and negative infinity, and Nan
+ * @return Value of the division, taking into account positive and negative
+ * infinity, and Nan
* @see #ddiv(double, double)
*/
public static double ddiv_d(double lhs, double rhs) {
- return rhs!=0? lhs / rhs: lhs>0? Double.POSITIVE_INFINITY: lhs==0? Double.NaN: Double.NEGATIVE_INFINITY;
+ return rhs != 0? lhs/rhs: lhs > 0? Double.POSITIVE_INFINITY: lhs == 0? Double.NaN: Double.NEGATIVE_INFINITY;
}
-
- /** Take modulo double numbers according to lua math, and return a {@link LuaValue} result.
+
+ /**
+ * Take modulo double numbers according to lua math, and return a
+ * {@link LuaValue} result.
+ *
* @param lhs Left-hand-side of the modulo.
* @param rhs Right-hand-side of the modulo.
- * @return {@link LuaValue} for the result of the modulo,
- * using lua's rules for modulo
+ * @return {@link LuaValue} for the result of the modulo, using lua's rules
+ * for modulo
* @see #dmod_d(double, double)
*/
public static LuaValue dmod(double lhs, double rhs) {
- if (rhs == 0 || lhs == Double.POSITIVE_INFINITY || lhs == Double.NEGATIVE_INFINITY) return NAN;
+ if (rhs == 0 || lhs == Double.POSITIVE_INFINITY || lhs == Double.NEGATIVE_INFINITY)
+ return NAN;
if (rhs == Double.POSITIVE_INFINITY) {
- return lhs < 0 ? POSINF : valueOf(lhs);
+ return lhs < 0? POSINF: valueOf(lhs);
}
if (rhs == Double.NEGATIVE_INFINITY) {
- return lhs > 0 ? NEGINF : valueOf(lhs);
+ return lhs > 0? NEGINF: valueOf(lhs);
}
- return valueOf( lhs-rhs*Math.floor(lhs/rhs) );
+ return valueOf(lhs-rhs*Math.floor(lhs/rhs));
}
- /** Take modulo for double numbers according to lua math, and return a double result.
+ /**
+ * Take modulo for double numbers according to lua math, and return a double
+ * result.
+ *
* @param lhs Left-hand-side of the modulo.
* @param rhs Right-hand-side of the modulo.
- * @return double value for the result of the modulo,
- * using lua's rules for modulo
+ * @return double value for the result of the modulo, using lua's rules for
+ * modulo
* @see #dmod(double, double)
*/
public static double dmod_d(double lhs, double rhs) {
- if (rhs == 0 || lhs == Double.POSITIVE_INFINITY || lhs == Double.NEGATIVE_INFINITY) return Double.NaN;
+ if (rhs == 0 || lhs == Double.POSITIVE_INFINITY || lhs == Double.NEGATIVE_INFINITY)
+ return Double.NaN;
if (rhs == Double.POSITIVE_INFINITY) {
- return lhs < 0 ? Double.POSITIVE_INFINITY : lhs;
+ return lhs < 0? Double.POSITIVE_INFINITY: lhs;
}
if (rhs == Double.NEGATIVE_INFINITY) {
- return lhs > 0 ? Double.NEGATIVE_INFINITY : lhs;
+ return lhs > 0? Double.NEGATIVE_INFINITY: lhs;
}
return lhs-rhs*Math.floor(lhs/rhs);
}
// relational operators
- public LuaValue lt( LuaValue rhs ) { return rhs instanceof LuaNumber ? (rhs.gt_b(v)? TRUE: FALSE) : super.lt(rhs); }
- public LuaValue lt( double rhs ) { return v < rhs? TRUE: FALSE; }
- public LuaValue lt( int rhs ) { return v < rhs? TRUE: FALSE; }
- public boolean lt_b( LuaValue rhs ) { return rhs instanceof LuaNumber ? rhs.gt_b(v) : super.lt_b(rhs); }
- public boolean lt_b( int rhs ) { return v < rhs; }
- public boolean lt_b( double rhs ) { return v < rhs; }
- public LuaValue lteq( LuaValue rhs ) { return rhs instanceof LuaNumber ? (rhs.gteq_b(v)? TRUE: FALSE) : super.lteq(rhs); }
- public LuaValue lteq( double rhs ) { return v <= rhs? TRUE: FALSE; }
- public LuaValue lteq( int rhs ) { return v <= rhs? TRUE: FALSE; }
- public boolean lteq_b( LuaValue rhs ) { return rhs instanceof LuaNumber ? rhs.gteq_b(v) : super.lteq_b(rhs); }
- public boolean lteq_b( int rhs ) { return v <= rhs; }
- public boolean lteq_b( double rhs ) { return v <= rhs; }
- public LuaValue gt( LuaValue rhs ) { return rhs instanceof LuaNumber ? (rhs.lt_b(v)? TRUE: FALSE) : super.gt(rhs); }
- public LuaValue gt( double rhs ) { return v > rhs? TRUE: FALSE; }
- public LuaValue gt( int rhs ) { return v > rhs? TRUE: FALSE; }
- public boolean gt_b( LuaValue rhs ) { return rhs instanceof LuaNumber ? rhs.lt_b(v) : super.gt_b(rhs); }
- public boolean gt_b( int rhs ) { return v > rhs; }
- public boolean gt_b( double rhs ) { return v > rhs; }
- public LuaValue gteq( LuaValue rhs ) { return rhs instanceof LuaNumber ? (rhs.lteq_b(v)? TRUE: FALSE) : super.gteq(rhs); }
- public LuaValue gteq( double rhs ) { return v >= rhs? TRUE: FALSE; }
- public LuaValue gteq( int rhs ) { return v >= rhs? TRUE: FALSE; }
- public boolean gteq_b( LuaValue rhs ) { return rhs instanceof LuaNumber ? rhs.lteq_b(v) : super.gteq_b(rhs); }
- public boolean gteq_b( int rhs ) { return v >= rhs; }
- public boolean gteq_b( double rhs ) { return v >= rhs; }
-
+ public LuaValue lt(LuaValue rhs) { return rhs instanceof LuaNumber? (rhs.gt_b(v)? TRUE: FALSE): super.lt(rhs); }
+
+ public LuaValue lt(double rhs) { return v < rhs? TRUE: FALSE; }
+
+ public LuaValue lt(int rhs) { return v < rhs? TRUE: FALSE; }
+
+ public boolean lt_b(LuaValue rhs) { return rhs instanceof LuaNumber? rhs.gt_b(v): super.lt_b(rhs); }
+
+ public boolean lt_b(int rhs) { return v < rhs; }
+
+ public boolean lt_b(double rhs) { return v < rhs; }
+
+ public LuaValue lteq(LuaValue rhs) {
+ return rhs instanceof LuaNumber? (rhs.gteq_b(v)? TRUE: FALSE): super.lteq(rhs);
+ }
+
+ public LuaValue lteq(double rhs) { return v <= rhs? TRUE: FALSE; }
+
+ public LuaValue lteq(int rhs) { return v <= rhs? TRUE: FALSE; }
+
+ public boolean lteq_b(LuaValue rhs) { return rhs instanceof LuaNumber? rhs.gteq_b(v): super.lteq_b(rhs); }
+
+ public boolean lteq_b(int rhs) { return v <= rhs; }
+
+ public boolean lteq_b(double rhs) { return v <= rhs; }
+
+ public LuaValue gt(LuaValue rhs) { return rhs instanceof LuaNumber? (rhs.lt_b(v)? TRUE: FALSE): super.gt(rhs); }
+
+ public LuaValue gt(double rhs) { return v > rhs? TRUE: FALSE; }
+
+ public LuaValue gt(int rhs) { return v > rhs? TRUE: FALSE; }
+
+ public boolean gt_b(LuaValue rhs) { return rhs instanceof LuaNumber? rhs.lt_b(v): super.gt_b(rhs); }
+
+ public boolean gt_b(int rhs) { return v > rhs; }
+
+ public boolean gt_b(double rhs) { return v > rhs; }
+
+ public LuaValue gteq(LuaValue rhs) {
+ return rhs instanceof LuaNumber? (rhs.lteq_b(v)? TRUE: FALSE): super.gteq(rhs);
+ }
+
+ public LuaValue gteq(double rhs) { return v >= rhs? TRUE: FALSE; }
+
+ public LuaValue gteq(int rhs) { return v >= rhs? TRUE: FALSE; }
+
+ public boolean gteq_b(LuaValue rhs) { return rhs instanceof LuaNumber? rhs.lteq_b(v): super.gteq_b(rhs); }
+
+ public boolean gteq_b(int rhs) { return v >= rhs; }
+
+ public boolean gteq_b(double rhs) { return v >= rhs; }
+
// string comparison
- public int strcmp( LuaString rhs ) { typerror("attempt to compare number with string"); return 0; }
-
+ public int strcmp(LuaString rhs) { typerror("attempt to compare number with string"); return 0; }
+
public String tojstring() {
/*
if ( v == 0.0 ) { // never occurs in J2me
@@ -242,58 +320,63 @@ public class LuaDouble extends LuaNumber {
}
*/
long l = (long) v;
- if ( l == v )
+ if (l == v)
return Long.toString(l);
- if ( Double.isNaN(v) )
+ if (Double.isNaN(v))
return JSTR_NAN;
- if ( Double.isInfinite(v) )
- return (v<0? JSTR_NEGINF: JSTR_POSINF);
- return Float.toString((float)v);
+ if (Double.isInfinite(v))
+ return (v < 0? JSTR_NEGINF: JSTR_POSINF);
+ return Float.toString((float) v);
}
-
+
public LuaString strvalue() {
return LuaString.valueOf(tojstring());
}
-
+
public LuaString optstring(LuaString defval) {
return LuaString.valueOf(tojstring());
}
-
+
public LuaValue tostring() {
return LuaString.valueOf(tojstring());
}
-
+
public String optjstring(String defval) {
return tojstring();
}
-
+
public LuaNumber optnumber(LuaNumber defval) {
return this;
}
-
+
public boolean isnumber() {
return true;
}
-
+
public boolean isstring() {
return true;
}
-
+
public LuaValue tonumber() {
return this;
}
- public int checkint() { return (int) (long) v; }
- public long checklong() { return (long) v; }
- public LuaNumber checknumber() { return this; }
- public double checkdouble() { return v; }
-
+
+ public int checkint() { return (int) (long) v; }
+
+ public long checklong() { return (long) v; }
+
+ public LuaNumber checknumber() { return this; }
+
+ public double checkdouble() { return v; }
+
public String checkjstring() {
return tojstring();
}
+
public LuaString checkstring() {
return LuaString.valueOf(tojstring());
}
-
+
public boolean isvalidkey() {
return !Double.isNaN(v);
}
diff --git a/luaj-core/src/main/java/org/luaj/vm2/LuaError.java b/luaj-core/src/main/java/org/luaj/vm2/LuaError.java
index 37a8df8d..dffe6636 100644
--- a/luaj-core/src/main/java/org/luaj/vm2/LuaError.java
+++ b/luaj-core/src/main/java/org/luaj/vm2/LuaError.java
@@ -21,38 +21,38 @@
******************************************************************************/
package org.luaj.vm2;
-
/**
- * RuntimeException that is thrown and caught in response to a lua error.
+ * RuntimeException that is thrown and caught in response to a lua error.
*
- * {@link LuaError} is used wherever a lua call to {@code error()}
- * would be used within a script.
+ * {@link LuaError} is used wherever a lua call to {@code error()} would be used
+ * within a script.
*
* Since it is an unchecked exception inheriting from {@link RuntimeException},
- * Java method signatures do notdeclare this exception, althoug it can
- * be thrown on almost any luaj Java operation.
- * This is analagous to the fact that any lua script can throw a lua error at any time.
- *
- * The LuaError may be constructed with a message object, in which case the message
- * is the string representation of that object. getMessageObject will get the object
- * supplied at construct time, or a LuaString containing the message of an object
- * was not supplied.
+ * Java method signatures do notdeclare this exception, althoug it can be thrown
+ * on almost any luaj Java operation. This is analagous to the fact that any lua
+ * script can throw a lua error at any time.
+ *
+ * The LuaError may be constructed with a message object, in which case the
+ * message is the string representation of that object. getMessageObject will
+ * get the object supplied at construct time, or a LuaString containing the
+ * message of an object was not supplied.
*/
public class LuaError extends RuntimeException {
private static final long serialVersionUID = 1L;
-
+
protected int level;
-
+
protected String fileline;
-
+
protected String traceback;
-
+
protected Throwable cause;
private LuaValue object;
-
- /** Get the string message if it was supplied, or a string
- * representation of the message object if that was supplied.
+
+ /**
+ * Get the string message if it was supplied, or a string representation of
+ * the message object if that was supplied.
*/
public String getMessage() {
if (traceback != null)
@@ -65,66 +65,70 @@ public class LuaError extends RuntimeException {
return m;
}
- /** Get the LuaValue that was provided in the constructor, or
- * a LuaString containing the message if it was a string error argument.
+ /**
+ * Get the LuaValue that was provided in the constructor, or a LuaString
+ * containing the message if it was a string error argument.
+ *
* @return LuaValue which was used in the constructor, or a LuaString
- * containing the message.
+ * containing the message.
*/
public LuaValue getMessageObject() {
- if (object != null) return object;
+ if (object != null)
+ return object;
String m = getMessage();
- return m != null ? LuaValue.valueOf(m): null;
+ return m != null? LuaValue.valueOf(m): null;
}
-
- /** Construct LuaError when a program exception occurs.
- *
+
+ /**
+ * Construct LuaError when a program exception occurs.
+ *
* All errors generated from lua code should throw LuaError(String) instead.
- * @param cause the Throwable that caused the error, if known.
+ *
+ * @param cause the Throwable that caused the error, if known.
*/
public LuaError(Throwable cause) {
- super( "vm error: "+cause );
+ super("vm error: " + cause);
this.cause = cause;
this.level = 1;
}
/**
- * Construct a LuaError with a specific message.
- *
+ * Construct a LuaError with a specific message.
+ *
* @param message message to supply
*/
public LuaError(String message) {
- super( message );
+ super(message);
this.level = 1;
- }
+ }
/**
- * Construct a LuaError with a message, and level to draw line number information from.
+ * Construct a LuaError with a message, and level to draw line number
+ * information from.
+ *
* @param message message to supply
- * @param level where to supply line info from in call stack
+ * @param level where to supply line info from in call stack
*/
public LuaError(String message, int level) {
- super( message );
+ super(message);
this.level = level;
- }
+ }
/**
- * Construct a LuaError with a LuaValue as the message object,
- * and level to draw line number information from.
+ * Construct a LuaError with a LuaValue as the message object, and level to
+ * draw line number information from.
+ *
* @param message_object message string or object to supply
*/
public LuaError(LuaValue message_object) {
- super( message_object.tojstring() );
+ super(message_object.tojstring());
this.object = message_object;
this.level = 1;
- }
-
-
- /**
- * Get the cause, if any.
- */
- public Throwable getCause() {
- return cause;
}
+ /**
+ * Get the cause, if any.
+ */
+ public Throwable getCause() { return cause; }
}
diff --git a/luaj-core/src/main/java/org/luaj/vm2/LuaFunction.java b/luaj-core/src/main/java/org/luaj/vm2/LuaFunction.java
index 83bee86d..e1f8e647 100644
--- a/luaj-core/src/main/java/org/luaj/vm2/LuaFunction.java
+++ b/luaj-core/src/main/java/org/luaj/vm2/LuaFunction.java
@@ -21,41 +21,39 @@
******************************************************************************/
package org.luaj.vm2;
-
/**
* Base class for functions implemented in Java.
*
- * Direct subclass include {@link org.luaj.vm2.lib.LibFunction}
- * which is the base class for
- * all built-in library functions coded in Java,
- * and {@link LuaClosure}, which represents a lua closure
- * whose bytecode is interpreted when the function is invoked.
+ * Direct subclass include {@link org.luaj.vm2.lib.LibFunction} which is the
+ * base class for all built-in library functions coded in Java, and
+ * {@link LuaClosure}, which represents a lua closure whose bytecode is
+ * interpreted when the function is invoked.
+ *
* @see LuaValue
* @see LuaClosure
* @see org.luaj.vm2.lib.LibFunction
*/
-abstract
-public class LuaFunction extends LuaValue {
-
+abstract public class LuaFunction extends LuaValue {
+
/** Shared static metatable for all functions and closures. */
public static LuaValue s_metatable;
public int type() {
return TFUNCTION;
}
-
+
public String typename() {
return "function";
}
-
+
public boolean isfunction() {
return true;
}
- public LuaFunction checkfunction() {
+ public LuaFunction checkfunction() {
return this;
}
-
+
public LuaFunction optfunction(LuaFunction defval) {
return this;
}
@@ -72,20 +70,29 @@ public class LuaFunction extends LuaValue {
return valueOf(tojstring());
}
- /** Return the last part of the class name, to be used as a function name in tojstring and elsewhere.
- * @return String naming the last part of the class name after the last dot (.) or dollar sign ($).
- * If the first character is '_', it is skipped.
+ /**
+ * Return the last part of the class name, to be used as a function name in
+ * tojstring and elsewhere.
+ *
+ * @return String naming the last part of the class name after the last dot
+ * (.) or dollar sign ($). If the first character is '_', it is
+ * skipped.
*/
public String classnamestub() {
String s = getClass().getName();
- int offset = Math.max(s.lastIndexOf('.'), s.lastIndexOf('$')) + 1;
- if (s.charAt(offset) == '_') offset++;
+ int offset = Math.max(s.lastIndexOf('.'), s.lastIndexOf('$'))+1;
+ if (s.charAt(offset) == '_')
+ offset++;
return s.substring(offset);
}
-
- /** Return a human-readable name for this function. Returns the last part of the class name by default.
- * Is overridden by LuaClosure to return the source file and line, and by LibFunctions to return the name.
- * @return common name for this function. */
+
+ /**
+ * Return a human-readable name for this function. Returns the last part of
+ * the class name by default. Is overridden by LuaClosure to return the
+ * source file and line, and by LibFunctions to return the name.
+ *
+ * @return common name for this function.
+ */
public String name() {
return classnamestub();
}
diff --git a/luaj-core/src/main/java/org/luaj/vm2/LuaInteger.java b/luaj-core/src/main/java/org/luaj/vm2/LuaInteger.java
index e5e651dc..867cec74 100644
--- a/luaj-core/src/main/java/org/luaj/vm2/LuaInteger.java
+++ b/luaj-core/src/main/java/org/luaj/vm2/LuaInteger.java
@@ -26,13 +26,13 @@ import org.luaj.vm2.lib.MathLib;
/**
* Extension of {@link LuaNumber} which can hold a Java int as its value.
*
- * These instance are not instantiated directly by clients, but indirectly
- * via the static functions {@link LuaValue#valueOf(int)} or {@link LuaValue#valueOf(double)}
- * functions. This ensures that policies regarding pooling of instances are
- * encapsulated.
+ * These instance are not instantiated directly by clients, but indirectly via
+ * the static functions {@link LuaValue#valueOf(int)} or
+ * {@link LuaValue#valueOf(double)} functions. This ensures that policies
+ * regarding pooling of instances are encapsulated.
*
- * There are no API's specific to LuaInteger that are useful beyond what is already
- * exposed in {@link LuaValue}.
+ * There are no API's specific to LuaInteger that are useful beyond what is
+ * already exposed in {@link LuaValue}.
*
* @see LuaValue
* @see LuaNumber
@@ -44,16 +44,18 @@ public class LuaInteger extends LuaNumber {
private static final LuaInteger[] intValues = new LuaInteger[512];
static {
- for ( int i=0; i<512; i++ )
+ for (int i = 0; i < 512; i++)
intValues[i] = new LuaInteger(i-256);
}
public static LuaInteger valueOf(int i) {
- return i<=255 && i>=-256? intValues[i+256]: new LuaInteger(i);
+ return i <= 255 && i >= -256? intValues[i+256]: new LuaInteger(i);
};
-
- // TODO consider moving this to LuaValue
- /** Return a LuaNumber that represents the value provided
+
+ // TODO consider moving this to LuaValue
+ /**
+ * Return a LuaNumber that represents the value provided
+ *
* @param l long value to represent.
* @return LuaNumber that is eithe LuaInteger or LuaDouble representing l
* @see LuaValue#valueOf(int)
@@ -61,38 +63,49 @@ public class LuaInteger extends LuaNumber {
*/
public static LuaNumber valueOf(long l) {
int i = (int) l;
- return l==i? (i<=255 && i>=-256? intValues[i+256]:
- (LuaNumber) new LuaInteger(i)):
- (LuaNumber) LuaDouble.valueOf(l);
+ return l == i? (i <= 255 && i >= -256? intValues[i+256]: (LuaNumber) new LuaInteger(i))
+ : (LuaNumber) LuaDouble.valueOf(l);
}
-
+
/** The value being held by this instance. */
public final int v;
-
+
/**
* Package protected constructor.
+ *
* @see LuaValue#valueOf(int)
**/
LuaInteger(int i) {
this.v = i;
}
-
- public boolean isint() { return true; }
- public boolean isinttype() { return true; }
- public boolean islong() { return true; }
-
- public byte tobyte() { return (byte) v; }
- public char tochar() { return (char) v; }
- public double todouble() { return v; }
- public float tofloat() { return v; }
- public int toint() { return v; }
- public long tolong() { return v; }
- public short toshort() { return (short) v; }
- public double optdouble(double defval) { return v; }
- public int optint(int defval) { return v; }
- public LuaInteger optinteger(LuaInteger defval) { return this; }
- public long optlong(long defval) { return v; }
+ public boolean isint() { return true; }
+
+ public boolean isinttype() { return true; }
+
+ public boolean islong() { return true; }
+
+ public byte tobyte() { return (byte) v; }
+
+ public char tochar() { return (char) v; }
+
+ public double todouble() { return v; }
+
+ public float tofloat() { return v; }
+
+ public int toint() { return v; }
+
+ public long tolong() { return v; }
+
+ public short toshort() { return (short) v; }
+
+ public double optdouble(double defval) { return v; }
+
+ public int optint(int defval) { return v; }
+
+ public LuaInteger optinteger(LuaInteger defval) { return this; }
+
+ public long optlong(long defval) { return v; }
public String tojstring() {
return Integer.toString(v);
@@ -101,27 +114,27 @@ public class LuaInteger extends LuaNumber {
public LuaString strvalue() {
return LuaString.valueOf(Integer.toString(v));
}
-
+
public LuaString optstring(LuaString defval) {
return LuaString.valueOf(Integer.toString(v));
}
-
+
public LuaValue tostring() {
return LuaString.valueOf(Integer.toString(v));
}
-
+
public String optjstring(String defval) {
return Integer.toString(v);
}
-
+
public LuaInteger checkinteger() {
return this;
}
-
+
public boolean isstring() {
return true;
}
-
+
public int hashCode() {
return v;
}
@@ -131,89 +144,146 @@ public class LuaInteger extends LuaNumber {
}
// unary operators
- public LuaValue neg() { return valueOf(-(long)v); }
-
+ public LuaValue neg() { return valueOf(-(long) v); }
+
// object equality, used for key comparison
- public boolean equals(Object o) { return o instanceof LuaInteger? ((LuaInteger)o).v == v: false; }
-
+ public boolean equals(Object o) { return o instanceof LuaInteger? ((LuaInteger) o).v == v: false; }
+
// equality w/ metatable processing
- public LuaValue eq( LuaValue val ) { return val.raweq(v)? TRUE: FALSE; }
- public boolean eq_b( LuaValue val ) { return val.raweq(v); }
-
+ public LuaValue eq(LuaValue val) { return val.raweq(v)? TRUE: FALSE; }
+
+ public boolean eq_b(LuaValue val) { return val.raweq(v); }
+
// equality w/o metatable processing
- public boolean raweq( LuaValue val ) { return val.raweq(v); }
- public boolean raweq( double val ) { return v == val; }
- public boolean raweq( int val ) { return v == val; }
-
+ public boolean raweq(LuaValue val) { return val.raweq(v); }
+
+ public boolean raweq(double val) { return v == val; }
+
+ public boolean raweq(int val) { return v == val; }
+
// arithmetic operators
- public LuaValue add( LuaValue rhs ) { return rhs.add(v); }
- public LuaValue add( double lhs ) { return LuaDouble.valueOf(lhs + v); }
- public LuaValue add( int lhs ) { return LuaInteger.valueOf(lhs + (long)v); }
- public LuaValue sub( LuaValue rhs ) { return rhs.subFrom(v); }
- public LuaValue sub( double rhs ) { return LuaDouble.valueOf(v - rhs); }
- public LuaValue sub( int rhs ) { return LuaDouble.valueOf(v - rhs); }
- public LuaValue subFrom( double lhs ) { return LuaDouble.valueOf(lhs - v); }
- public LuaValue subFrom( int lhs ) { return LuaInteger.valueOf(lhs - (long)v); }
- public LuaValue mul( LuaValue rhs ) { return rhs.mul(v); }
- public LuaValue mul( double lhs ) { return LuaDouble.valueOf(lhs * v); }
- public LuaValue mul( int lhs ) { return LuaInteger.valueOf(lhs * (long)v); }
- public LuaValue pow( LuaValue rhs ) { return rhs.powWith(v); }
- public LuaValue pow( double rhs ) { return MathLib.dpow(v,rhs); }
- public LuaValue pow( int rhs ) { return MathLib.dpow(v,rhs); }
- public LuaValue powWith( double lhs ) { return MathLib.dpow(lhs,v); }
- public LuaValue powWith( int lhs ) { return MathLib.dpow(lhs,v); }
- public LuaValue div( LuaValue rhs ) { return rhs.divInto(v); }
- public LuaValue div( double rhs ) { return LuaDouble.ddiv(v,rhs); }
- public LuaValue div( int rhs ) { return LuaDouble.ddiv(v,rhs); }
- public LuaValue divInto( double lhs ) { return LuaDouble.ddiv(lhs,v); }
- public LuaValue mod( LuaValue rhs ) { return rhs.modFrom(v); }
- public LuaValue mod( double rhs ) { return LuaDouble.dmod(v,rhs); }
- public LuaValue mod( int rhs ) { return LuaDouble.dmod(v,rhs); }
- public LuaValue modFrom( double lhs ) { return LuaDouble.dmod(lhs,v); }
-
+ public LuaValue add(LuaValue rhs) { return rhs.add(v); }
+
+ public LuaValue add(double lhs) { return LuaDouble.valueOf(lhs+v); }
+
+ public LuaValue add(int lhs) { return LuaInteger.valueOf(lhs+(long) v); }
+
+ public LuaValue sub(LuaValue rhs) { return rhs.subFrom(v); }
+
+ public LuaValue sub(double rhs) { return LuaDouble.valueOf(v-rhs); }
+
+ public LuaValue sub(int rhs) { return LuaDouble.valueOf(v-rhs); }
+
+ public LuaValue subFrom(double lhs) { return LuaDouble.valueOf(lhs-v); }
+
+ public LuaValue subFrom(int lhs) { return LuaInteger.valueOf(lhs-(long) v); }
+
+ public LuaValue mul(LuaValue rhs) { return rhs.mul(v); }
+
+ public LuaValue mul(double lhs) { return LuaDouble.valueOf(lhs*v); }
+
+ public LuaValue mul(int lhs) { return LuaInteger.valueOf(lhs*(long) v); }
+
+ public LuaValue pow(LuaValue rhs) { return rhs.powWith(v); }
+
+ public LuaValue pow(double rhs) { return MathLib.dpow(v, rhs); }
+
+ public LuaValue pow(int rhs) { return MathLib.dpow(v, rhs); }
+
+ public LuaValue powWith(double lhs) { return MathLib.dpow(lhs, v); }
+
+ public LuaValue powWith(int lhs) { return MathLib.dpow(lhs, v); }
+
+ public LuaValue div(LuaValue rhs) { return rhs.divInto(v); }
+
+ public LuaValue div(double rhs) { return LuaDouble.ddiv(v, rhs); }
+
+ public LuaValue div(int rhs) { return LuaDouble.ddiv(v, rhs); }
+
+ public LuaValue divInto(double lhs) { return LuaDouble.ddiv(lhs, v); }
+
+ public LuaValue mod(LuaValue rhs) { return rhs.modFrom(v); }
+
+ public LuaValue mod(double rhs) { return LuaDouble.dmod(v, rhs); }
+
+ public LuaValue mod(int rhs) { return LuaDouble.dmod(v, rhs); }
+
+ public LuaValue modFrom(double lhs) { return LuaDouble.dmod(lhs, v); }
+
// relational operators
- public LuaValue lt( LuaValue rhs ) { return rhs instanceof LuaNumber ? (rhs.gt_b(v)? TRUE: FALSE) : super.lt(rhs); }
- public LuaValue lt( double rhs ) { return v < rhs? TRUE: FALSE; }
- public LuaValue lt( int rhs ) { return v < rhs? TRUE: FALSE; }
- public boolean lt_b( LuaValue rhs ) { return rhs instanceof LuaNumber ? rhs.gt_b(v) : super.lt_b(rhs); }
- public boolean lt_b( int rhs ) { return v < rhs; }
- public boolean lt_b( double rhs ) { return v < rhs; }
- public LuaValue lteq( LuaValue rhs ) { return rhs instanceof LuaNumber ? (rhs.gteq_b(v)? TRUE: FALSE) : super.lteq(rhs); }
- public LuaValue lteq( double rhs ) { return v <= rhs? TRUE: FALSE; }
- public LuaValue lteq( int rhs ) { return v <= rhs? TRUE: FALSE; }
- public boolean lteq_b( LuaValue rhs ) { return rhs instanceof LuaNumber ? rhs.gteq_b(v) : super.lteq_b(rhs); }
- public boolean lteq_b( int rhs ) { return v <= rhs; }
- public boolean lteq_b( double rhs ) { return v <= rhs; }
- public LuaValue gt( LuaValue rhs ) { return rhs instanceof LuaNumber ? (rhs.lt_b(v)? TRUE: FALSE) : super.gt(rhs); }
- public LuaValue gt( double rhs ) { return v > rhs? TRUE: FALSE; }
- public LuaValue gt( int rhs ) { return v > rhs? TRUE: FALSE; }
- public boolean gt_b( LuaValue rhs ) { return rhs instanceof LuaNumber ? rhs.lt_b(v) : super.gt_b(rhs); }
- public boolean gt_b( int rhs ) { return v > rhs; }
- public boolean gt_b( double rhs ) { return v > rhs; }
- public LuaValue gteq( LuaValue rhs ) { return rhs instanceof LuaNumber ? (rhs.lteq_b(v)? TRUE: FALSE) : super.gteq(rhs); }
- public LuaValue gteq( double rhs ) { return v >= rhs? TRUE: FALSE; }
- public LuaValue gteq( int rhs ) { return v >= rhs? TRUE: FALSE; }
- public boolean gteq_b( LuaValue rhs ) { return rhs instanceof LuaNumber ? rhs.lteq_b(v) : super.gteq_b(rhs); }
- public boolean gteq_b( int rhs ) { return v >= rhs; }
- public boolean gteq_b( double rhs ) { return v >= rhs; }
-
+ public LuaValue lt(LuaValue rhs) { return rhs instanceof LuaNumber? (rhs.gt_b(v)? TRUE: FALSE): super.lt(rhs); }
+
+ public LuaValue lt(double rhs) { return v < rhs? TRUE: FALSE; }
+
+ public LuaValue lt(int rhs) { return v < rhs? TRUE: FALSE; }
+
+ public boolean lt_b(LuaValue rhs) { return rhs instanceof LuaNumber? rhs.gt_b(v): super.lt_b(rhs); }
+
+ public boolean lt_b(int rhs) { return v < rhs; }
+
+ public boolean lt_b(double rhs) { return v < rhs; }
+
+ public LuaValue lteq(LuaValue rhs) {
+ return rhs instanceof LuaNumber? (rhs.gteq_b(v)? TRUE: FALSE): super.lteq(rhs);
+ }
+
+ public LuaValue lteq(double rhs) { return v <= rhs? TRUE: FALSE; }
+
+ public LuaValue lteq(int rhs) { return v <= rhs? TRUE: FALSE; }
+
+ public boolean lteq_b(LuaValue rhs) { return rhs instanceof LuaNumber? rhs.gteq_b(v): super.lteq_b(rhs); }
+
+ public boolean lteq_b(int rhs) { return v <= rhs; }
+
+ public boolean lteq_b(double rhs) { return v <= rhs; }
+
+ public LuaValue gt(LuaValue rhs) { return rhs instanceof LuaNumber? (rhs.lt_b(v)? TRUE: FALSE): super.gt(rhs); }
+
+ public LuaValue gt(double rhs) { return v > rhs? TRUE: FALSE; }
+
+ public LuaValue gt(int rhs) { return v > rhs? TRUE: FALSE; }
+
+ public boolean gt_b(LuaValue rhs) { return rhs instanceof LuaNumber? rhs.lt_b(v): super.gt_b(rhs); }
+
+ public boolean gt_b(int rhs) { return v > rhs; }
+
+ public boolean gt_b(double rhs) { return v > rhs; }
+
+ public LuaValue gteq(LuaValue rhs) {
+ return rhs instanceof LuaNumber? (rhs.lteq_b(v)? TRUE: FALSE): super.gteq(rhs);
+ }
+
+ public LuaValue gteq(double rhs) { return v >= rhs? TRUE: FALSE; }
+
+ public LuaValue gteq(int rhs) { return v >= rhs? TRUE: FALSE; }
+
+ public boolean gteq_b(LuaValue rhs) { return rhs instanceof LuaNumber? rhs.lteq_b(v): super.gteq_b(rhs); }
+
+ public boolean gteq_b(int rhs) { return v >= rhs; }
+
+ public boolean gteq_b(double rhs) { return v >= rhs; }
+
// string comparison
- public int strcmp( LuaString rhs ) { typerror("attempt to compare number with string"); return 0; }
-
+ public int strcmp(LuaString rhs) { typerror("attempt to compare number with string"); return 0; }
+
public int checkint() {
return v;
}
+
public long checklong() {
return v;
}
+
public double checkdouble() {
return v;
}
+
public String checkjstring() {
return String.valueOf(v);
}
+
public LuaString checkstring() {
- return valueOf( String.valueOf(v) );
+ return valueOf(String.valueOf(v));
}
}
diff --git a/luaj-core/src/main/java/org/luaj/vm2/LuaNil.java b/luaj-core/src/main/java/org/luaj/vm2/LuaNil.java
index 1b247cbd..b0ab3822 100644
--- a/luaj-core/src/main/java/org/luaj/vm2/LuaNil.java
+++ b/luaj-core/src/main/java/org/luaj/vm2/LuaNil.java
@@ -22,27 +22,27 @@
package org.luaj.vm2;
/**
- * Class to encapsulate behavior of the singleton instance {@code nil}
+ * Class to encapsulate behavior of the singleton instance {@code nil}
*
- * There will be one instance of this class, {@link LuaValue#NIL},
- * per Java virtual machine.
- * However, the {@link Varargs} instance {@link LuaValue#NONE}
- * which is the empty list,
- * is also considered treated as a nil value by default.
+ * There will be one instance of this class, {@link LuaValue#NIL}, per Java
+ * virtual machine. However, the {@link Varargs} instance {@link LuaValue#NONE}
+ * which is the empty list, is also considered treated as a nil value by
+ * default.
*
- * Although it is possible to test for nil using Java == operator,
- * the recommended approach is to use the method {@link LuaValue#isnil()}
- * instead. By using that any ambiguities between
- * {@link LuaValue#NIL} and {@link LuaValue#NONE} are avoided.
+ * Although it is possible to test for nil using Java == operator, the
+ * recommended approach is to use the method {@link LuaValue#isnil()} instead.
+ * By using that any ambiguities between {@link LuaValue#NIL} and
+ * {@link LuaValue#NONE} are avoided.
+ *
* @see LuaValue
* @see LuaValue#NIL
*/
public class LuaNil extends LuaValue {
-
+
static final LuaNil _NIL = new LuaNil();
-
+
public static LuaValue s_metatable;
-
+
LuaNil() {}
public int type() {
@@ -50,59 +50,73 @@ public class LuaNil extends LuaValue {
}
public String toString() {
- return "nil";
+ return "nil";
}
-
+
public String typename() {
return "nil";
}
-
+
public String tojstring() {
return "nil";
}
- public LuaValue not() {
- return LuaValue.TRUE;
+ public LuaValue not() {
+ return LuaValue.TRUE;
}
-
- public boolean toboolean() {
- return false;
+
+ public boolean toboolean() {
+ return false;
}
-
+
public boolean isnil() {
return true;
}
-
- public LuaValue getmetatable() {
- return s_metatable;
+
+ public LuaValue getmetatable() {
+ return s_metatable;
}
-
+
public boolean equals(Object o) {
return o instanceof LuaNil;
}
- public LuaValue checknotnil() {
+ public LuaValue checknotnil() {
return argerror("value");
}
-
+
public boolean isvalidkey() {
return false;
}
// optional argument conversions - nil alwas falls badk to default value
- public boolean optboolean(boolean defval) { return defval; }
- public LuaClosure optclosure(LuaClosure defval) { return defval; }
- public double optdouble(double defval) { return defval; }
- public LuaFunction optfunction(LuaFunction defval) { return defval; }
- public int optint(int defval) { return defval; }
- public LuaInteger optinteger(LuaInteger defval) { return defval; }
- public long optlong(long defval) { return defval; }
- public LuaNumber optnumber(LuaNumber defval) { return defval; }
- public LuaTable opttable(LuaTable defval) { return defval; }
- public LuaThread optthread(LuaThread defval) { return defval; }
- public String optjstring(String defval) { return defval; }
- public LuaString optstring(LuaString defval) { return defval; }
- public Object optuserdata(Object defval) { return defval; }
- public Object optuserdata(Class c, Object defval) { return defval; }
- public LuaValue optvalue(LuaValue defval) { return defval; }
+ public boolean optboolean(boolean defval) { return defval; }
+
+ public LuaClosure optclosure(LuaClosure defval) { return defval; }
+
+ public double optdouble(double defval) { return defval; }
+
+ public LuaFunction optfunction(LuaFunction defval) { return defval; }
+
+ public int optint(int defval) { return defval; }
+
+ public LuaInteger optinteger(LuaInteger defval) { return defval; }
+
+ public long optlong(long defval) { return defval; }
+
+ public LuaNumber optnumber(LuaNumber defval) { return defval; }
+
+ public LuaTable opttable(LuaTable defval) { return defval; }
+
+ public LuaThread optthread(LuaThread defval) { return defval; }
+
+ public String optjstring(String defval) { return defval; }
+
+ public LuaString optstring(LuaString defval) { return defval; }
+
+ public Object optuserdata(Object defval) { return defval; }
+
+ public Object optuserdata(Class c, Object defval) { return defval; }
+
+ public LuaValue optvalue(LuaValue defval) { return defval; }
}
diff --git a/luaj-core/src/main/java/org/luaj/vm2/LuaNumber.java b/luaj-core/src/main/java/org/luaj/vm2/LuaNumber.java
index ef972218..57fa8d27 100644
--- a/luaj-core/src/main/java/org/luaj/vm2/LuaNumber.java
+++ b/luaj-core/src/main/java/org/luaj/vm2/LuaNumber.java
@@ -21,61 +21,64 @@
******************************************************************************/
package org.luaj.vm2;
-/**
- * Base class for representing numbers as lua values directly.
+/**
+ * Base class for representing numbers as lua values directly.
*
- * The main subclasses are {@link LuaInteger} which holds values that fit in a java int,
- * and {@link LuaDouble} which holds all other number values.
+ * The main subclasses are {@link LuaInteger} which holds values that fit in a
+ * java int, and {@link LuaDouble} which holds all other number values.
+ *
* @see LuaInteger
* @see LuaDouble
* @see LuaValue
*
*/
-abstract
-public class LuaNumber extends LuaValue {
+abstract public class LuaNumber extends LuaValue {
/** Shared static metatable for all number values represented in lua. */
public static LuaValue s_metatable;
-
+
public int type() {
return TNUMBER;
}
-
+
public String typename() {
return "number";
}
-
+
public LuaNumber checknumber() {
- return this;
+ return this;
}
-
+
public LuaNumber checknumber(String errmsg) {
- return this;
+ return this;
}
-
+
public LuaNumber optnumber(LuaNumber defval) {
- return this;
+ return this;
}
-
+
public LuaValue tonumber() {
return this;
}
-
+
public boolean isnumber() {
return true;
}
-
+
public boolean isstring() {
return true;
}
-
- public LuaValue getmetatable() {
- return s_metatable;
+
+ public LuaValue getmetatable() {
+ return s_metatable;
}
- public LuaValue concat(LuaValue rhs) { return rhs.concatTo(this); }
- public Buffer concat(Buffer rhs) { return rhs.concatTo(this); }
- public LuaValue concatTo(LuaNumber lhs) { return strvalue().concatTo(lhs.strvalue()); }
- public LuaValue concatTo(LuaString lhs) { return strvalue().concatTo(lhs); }
+ public LuaValue concat(LuaValue rhs) { return rhs.concatTo(this); }
+
+ public Buffer concat(Buffer rhs) { return rhs.concatTo(this); }
+
+ public LuaValue concatTo(LuaNumber lhs) { return strvalue().concatTo(lhs.strvalue()); }
+
+ public LuaValue concatTo(LuaString lhs) { return strvalue().concatTo(lhs); }
}
diff --git a/luaj-core/src/main/java/org/luaj/vm2/LuaString.java b/luaj-core/src/main/java/org/luaj/vm2/LuaString.java
index 08c1022b..b0a56eb1 100644
--- a/luaj-core/src/main/java/org/luaj/vm2/LuaString.java
+++ b/luaj-core/src/main/java/org/luaj/vm2/LuaString.java
@@ -21,7 +21,6 @@
******************************************************************************/
package org.luaj.vm2;
-
import java.io.ByteArrayInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
@@ -33,27 +32,27 @@ import org.luaj.vm2.lib.MathLib;
/**
* Subclass of {@link LuaValue} for representing lua strings.
*
- * Because lua string values are more nearly sequences of bytes than
- * sequences of characters or unicode code points, the {@link LuaString}
- * implementation holds the string value in an internal byte array.
+ * Because lua string values are more nearly sequences of bytes than sequences
+ * of characters or unicode code points, the {@link LuaString} implementation
+ * holds the string value in an internal byte array.
*
- * {@link LuaString} values are not considered mutable once constructed,
- * so multiple {@link LuaString} values can chare a single byte array.
+ * {@link LuaString} values are not considered mutable once constructed, so
+ * multiple {@link LuaString} values can chare a single byte array.
*
* Currently {@link LuaString}s are pooled via a centrally managed weak table.
* To ensure that as many string values as possible take advantage of this,
- * Constructors are not exposed directly. As with number, booleans, and nil,
- * instance construction should be via {@link LuaValue#valueOf(byte[])} or similar API.
+ * Constructors are not exposed directly. As with number, booleans, and nil,
+ * instance construction should be via {@link LuaValue#valueOf(byte[])} or
+ * similar API.
*
* Because of this pooling, users of LuaString must not directly alter the
* bytes in a LuaString, or undefined behavior will result.
*
- * When Java Strings are used to initialize {@link LuaString} data, the UTF8 encoding is assumed.
- * The functions
- * {@link #lengthAsUtf8(char[])},
+ * When Java Strings are used to initialize {@link LuaString} data, the UTF8
+ * encoding is assumed. The functions {@link #lengthAsUtf8(char[])},
* {@link #encodeToUtf8(char[], int, byte[], int)}, and
- * {@link #decodeAsUtf8(byte[], int, int)}
- * are used to convert back and forth between UTF8 byte arrays and character arrays.
+ * {@link #decodeAsUtf8(byte[], int, int)} are used to convert back and forth
+ * between UTF8 byte arrays and character arrays.
*
* @see LuaValue
* @see LuaValue#valueOf(String)
@@ -61,54 +60,66 @@ import org.luaj.vm2.lib.MathLib;
*/
public class LuaString extends LuaValue {
- /** The singleton instance for string metatables that forwards to the string functions.
- * Typically, this is set to the string metatable as a side effect of loading the string
- * library, and is read-write to provide flexible behavior by default. When used in a
- * server environment where there may be roge scripts, this should be replaced with a
- * read-only table since it is shared across all lua code in this Java VM.
+ /**
+ * The singleton instance for string metatables that forwards to the string
+ * functions. Typically, this is set to the string metatable as a side
+ * effect of loading the string library, and is read-write to provide
+ * flexible behavior by default. When used in a server environment where
+ * there may be roge scripts, this should be replaced with a read-only table
+ * since it is shared across all lua code in this Java VM.
*/
public static LuaValue s_metatable;
-
- /** The bytes for the string. These must not be mutated directly because
- * the backing may be shared by multiple LuaStrings, and the hash code is
- * computed only at construction time.
- * It is exposed only for performance and legacy reasons. */
+
+ /**
+ * The bytes for the string. These must not be mutated
+ * directly because the backing may be shared by multiple
+ * LuaStrings, and the hash code is computed only at construction time. It
+ * is exposed only for performance and legacy reasons.
+ */
public final byte[] m_bytes;
-
+
/** The offset into the byte array, 0 means start at the first byte */
public final int m_offset;
-
+
/** The number of bytes that comprise this string */
public final int m_length;
-
- /** The hashcode for this string. Computed at construct time. */
+
+ /** The hashcode for this string. Computed at construct time. */
private final int m_hashcode;
- /** Size of cache of recent short strings. This is the maximum number of LuaStrings that
- * will be retained in the cache of recent short strings. Exposed to package for testing. */
+ /**
+ * Size of cache of recent short strings. This is the maximum number of
+ * LuaStrings that will be retained in the cache of recent short strings.
+ * Exposed to package for testing.
+ */
static final int RECENT_STRINGS_CACHE_SIZE = 128;
- /** Maximum length of a string to be considered for recent short strings caching.
- * This effectively limits the total memory that can be spent on the recent strings cache,
- * because no LuaString whose backing exceeds this length will be put into the cache.
- * Exposed to package for testing. */
+ /**
+ * Maximum length of a string to be considered for recent short strings
+ * caching. This effectively limits the total memory that can be spent on
+ * the recent strings cache, because no LuaString whose backing exceeds this
+ * length will be put into the cache. Exposed to package for testing.
+ */
static final int RECENT_STRINGS_MAX_LENGTH = 32;
- /** Simple cache of recently created strings that are short.
- * This is simply a list of strings, indexed by their hash codes modulo the cache size
- * that have been recently constructed. If a string is being constructed frequently
- * from different contexts, it will generally show up as a cache hit and resolve
- * to the same value. */
+ /**
+ * Simple cache of recently created strings that are short. This is simply a
+ * list of strings, indexed by their hash codes modulo the cache size that
+ * have been recently constructed. If a string is being constructed
+ * frequently from different contexts, it will generally show up as a cache
+ * hit and resolve to the same value.
+ */
private static final class RecentShortStrings {
- private static final LuaString recent_short_strings[] =
- new LuaString[RECENT_STRINGS_CACHE_SIZE];
+ private static final LuaString recent_short_strings[] = new LuaString[RECENT_STRINGS_CACHE_SIZE];
}
/**
- * Get a {@link LuaString} instance whose bytes match
- * the supplied Java String using the UTF8 encoding.
+ * Get a {@link LuaString} instance whose bytes match the supplied Java
+ * String using the UTF8 encoding.
+ *
* @param string Java String containing characters to encode as UTF8
- * @return {@link LuaString} with UTF8 bytes corresponding to the supplied String
+ * @return {@link LuaString} with UTF8 bytes corresponding to the supplied
+ * String
*/
public static LuaString valueOf(String string) {
char[] c = string.toCharArray();
@@ -117,25 +128,29 @@ public class LuaString extends LuaValue {
return valueUsing(b, 0, b.length);
}
- /** Construct a {@link LuaString} for a portion of a byte array.
+ /**
+ * Construct a {@link LuaString} for a portion of a byte array.
*
- * The array is first be used as the backing for this object, so clients must not change contents.
- * If the supplied value for 'len' is more than half the length of the container, the
- * supplied byte array will be used as the backing, otherwise the bytes will be copied to a
- * new byte array, and cache lookup may be performed.
+ * The array is first be used as the backing for this object, so clients
+ * must not change contents. If the supplied value for 'len' is more than
+ * half the length of the container, the supplied byte array will be used as
+ * the backing, otherwise the bytes will be copied to a new byte array, and
+ * cache lookup may be performed.
*
+ *
* @param bytes byte buffer
- * @param off offset into the byte buffer
- * @param len length of the byte buffer
+ * @param off offset into the byte buffer
+ * @param len length of the byte buffer
* @return {@link LuaString} wrapping the byte buffer
*/
public static LuaString valueOf(byte[] bytes, int off, int len) {
if (len > RECENT_STRINGS_MAX_LENGTH)
return valueFromCopy(bytes, off, len);
final int hash = hashCode(bytes, off, len);
- final int bucket = hash & (RECENT_STRINGS_CACHE_SIZE - 1);
+ final int bucket = hash & (RECENT_STRINGS_CACHE_SIZE-1);
final LuaString t = RecentShortStrings.recent_short_strings[bucket];
- if (t != null && t.m_hashcode == hash && t.byteseq(bytes, off, len)) return t;
+ if (t != null && t.m_hashcode == hash && t.byteseq(bytes, off, len))
+ return t;
final LuaString s = valueFromCopy(bytes, off, len);
RecentShortStrings.recent_short_strings[bucket] = s;
return s;
@@ -148,75 +163,96 @@ public class LuaString extends LuaValue {
return new LuaString(copy, 0, len);
}
- /** Construct a {@link LuaString} around, possibly using the the supplied
+ /**
+ * Construct a {@link LuaString} around, possibly using the the supplied
* byte array as the backing store.
*
* The caller must ensure that the array is not mutated after the call.
* However, if the string is short enough the short-string cache is checked
* for a match which may be used instead of the supplied byte array.
*
+ *
* @param bytes byte buffer
- * @return {@link LuaString} wrapping the byte buffer, or an equivalent string.
+ * @return {@link LuaString} wrapping the byte buffer, or an equivalent
+ * string.
*/
static public LuaString valueUsing(byte[] bytes, int off, int len) {
if (bytes.length > RECENT_STRINGS_MAX_LENGTH)
return new LuaString(bytes, off, len);
final int hash = hashCode(bytes, off, len);
- final int bucket = hash & (RECENT_STRINGS_CACHE_SIZE - 1);
+ final int bucket = hash & (RECENT_STRINGS_CACHE_SIZE-1);
final LuaString t = RecentShortStrings.recent_short_strings[bucket];
- if (t != null && t.m_hashcode == hash && t.byteseq(bytes, off, len)) return t;
+ if (t != null && t.m_hashcode == hash && t.byteseq(bytes, off, len))
+ return t;
final LuaString s = new LuaString(bytes, off, len);
RecentShortStrings.recent_short_strings[bucket] = s;
return s;
}
- /** Construct a {@link LuaString} using the supplied characters as byte values.
+ /**
+ * Construct a {@link LuaString} using the supplied characters as byte
+ * values.
*
- * Only the low-order 8-bits of each character are used, the remainder is ignored.
+ * Only the low-order 8-bits of each character are used, the remainder is
+ * ignored.
*
- * This is most useful for constructing byte sequences that do not conform to UTF8.
- * @param bytes array of char, whose values are truncated at 8-bits each and put into a byte array.
+ * This is most useful for constructing byte sequences that do not conform
+ * to UTF8.
+ *
+ * @param bytes array of char, whose values are truncated at 8-bits each and
+ * put into a byte array.
* @return {@link LuaString} wrapping a copy of the byte buffer
*/
public static LuaString valueOf(char[] bytes) {
return valueOf(bytes, 0, bytes.length);
}
- /** Construct a {@link LuaString} using the supplied characters as byte values.
+ /**
+ * Construct a {@link LuaString} using the supplied characters as byte
+ * values.
*
- * Only the low-order 8-bits of each character are used, the remainder is ignored.
+ * Only the low-order 8-bits of each character are used, the remainder is
+ * ignored.
*
- * This is most useful for constructing byte sequences that do not conform to UTF8.
- * @param bytes array of char, whose values are truncated at 8-bits each and put into a byte array.
+ * This is most useful for constructing byte sequences that do not conform
+ * to UTF8.
+ *
+ * @param bytes array of char, whose values are truncated at 8-bits each and
+ * put into a byte array.
* @return {@link LuaString} wrapping a copy of the byte buffer
*/
public static LuaString valueOf(char[] bytes, int off, int len) {
byte[] b = new byte[len];
- for ( int i=0; i
+ *
* @param bytes byte buffer
* @return {@link LuaString} wrapping the byte buffer
*/
public static LuaString valueOf(byte[] bytes) {
return valueOf(bytes, 0, bytes.length);
}
-
- /** Construct a {@link LuaString} for all the bytes in a byte array, possibly using
- * the supplied array as the backing store.
+
+ /**
+ * Construct a {@link LuaString} for all the bytes in a byte array, possibly
+ * using the supplied array as the backing store.
*
- * The LuaString returned will either be a new LuaString containing the byte array,
- * or be an existing LuaString used already having the same value.
+ * The LuaString returned will either be a new LuaString containing the byte
+ * array, or be an existing LuaString used already having the same value.
*
- * The caller must not mutate the contents of the byte array after this call, as
- * it may be used elsewhere due to recent short string caching.
+ * The caller must not mutate the contents of the byte array after this
+ * call, as it may be used elsewhere due to recent short string caching.
+ *
* @param bytes byte buffer
* @return {@link LuaString} wrapping the byte buffer
*/
@@ -224,11 +260,15 @@ public class LuaString extends LuaValue {
return valueUsing(bytes, 0, bytes.length);
}
- /** Construct a {@link LuaString} around a byte array without copying the contents.
+ /**
+ * Construct a {@link LuaString} around a byte array without copying the
+ * contents.
*
- * The array is used directly after this is called, so clients must not change contents.
+ * The array is used directly after this is called, so clients must not
+ * change contents.
*
- * @param bytes byte buffer
+ *
+ * @param bytes byte buffer
* @param offset offset into the byte buffer
* @param length length of the byte buffer
* @return {@link LuaString} wrapping the byte buffer
@@ -243,11 +283,11 @@ public class LuaString extends LuaValue {
public boolean isstring() {
return true;
}
-
+
public LuaValue getmetatable() {
return s_metatable;
}
-
+
public int type() {
return LuaValue.TSTRING;
}
@@ -255,7 +295,7 @@ public class LuaString extends LuaValue {
public String typename() {
return "string";
}
-
+
public String tojstring() {
return decodeAsUtf8(m_bytes, m_offset, m_length);
}
@@ -264,53 +304,119 @@ public class LuaString extends LuaValue {
public LuaValue neg() { double d = scannumber(); return Double.isNaN(d)? super.neg(): valueOf(-d); }
// basic binary arithmetic
- public LuaValue add( LuaValue rhs ) { double d = scannumber(); return Double.isNaN(d)? arithmt(ADD,rhs): rhs.add(d); }
- public LuaValue add( double rhs ) { return valueOf( checkarith() + rhs ); }
- public LuaValue add( int rhs ) { return valueOf( checkarith() + rhs ); }
- public LuaValue sub( LuaValue rhs ) { double d = scannumber(); return Double.isNaN(d)? arithmt(SUB,rhs): rhs.subFrom(d); }
- public LuaValue sub( double rhs ) { return valueOf( checkarith() - rhs ); }
- public LuaValue sub( int rhs ) { return valueOf( checkarith() - rhs ); }
- public LuaValue subFrom( double lhs ) { return valueOf( lhs - checkarith() ); }
- public LuaValue mul( LuaValue rhs ) { double d = scannumber(); return Double.isNaN(d)? arithmt(MUL,rhs): rhs.mul(d); }
- public LuaValue mul( double rhs ) { return valueOf( checkarith() * rhs ); }
- public LuaValue mul( int rhs ) { return valueOf( checkarith() * rhs ); }
- public LuaValue pow( LuaValue rhs ) { double d = scannumber(); return Double.isNaN(d)? arithmt(POW,rhs): rhs.powWith(d); }
- public LuaValue pow( double rhs ) { return MathLib.dpow(checkarith(),rhs); }
- public LuaValue pow( int rhs ) { return MathLib.dpow(checkarith(),rhs); }
- public LuaValue powWith( double lhs ) { return MathLib.dpow(lhs, checkarith()); }
- public LuaValue powWith( int lhs ) { return MathLib.dpow(lhs, checkarith()); }
- public LuaValue div( LuaValue rhs ) { double d = scannumber(); return Double.isNaN(d)? arithmt(DIV,rhs): rhs.divInto(d); }
- public LuaValue div( double rhs ) { return LuaDouble.ddiv(checkarith(),rhs); }
- public LuaValue div( int rhs ) { return LuaDouble.ddiv(checkarith(),rhs); }
- public LuaValue divInto( double lhs ) { return LuaDouble.ddiv(lhs, checkarith()); }
- public LuaValue mod( LuaValue rhs ) { double d = scannumber(); return Double.isNaN(d)? arithmt(MOD,rhs): rhs.modFrom(d); }
- public LuaValue mod( double rhs ) { return LuaDouble.dmod(checkarith(), rhs); }
- public LuaValue mod( int rhs ) { return LuaDouble.dmod(checkarith(), rhs); }
- public LuaValue modFrom( double lhs ) { return LuaDouble.dmod(lhs, checkarith()); }
-
+ public LuaValue add(LuaValue rhs) {
+ double d = scannumber();
+ return Double.isNaN(d)? arithmt(ADD, rhs): rhs.add(d);
+ }
+
+ public LuaValue add(double rhs) { return valueOf(checkarith()+rhs); }
+
+ public LuaValue add(int rhs) { return valueOf(checkarith()+rhs); }
+
+ public LuaValue sub(LuaValue rhs) {
+ double d = scannumber();
+ return Double.isNaN(d)? arithmt(SUB, rhs): rhs.subFrom(d);
+ }
+
+ public LuaValue sub(double rhs) { return valueOf(checkarith()-rhs); }
+
+ public LuaValue sub(int rhs) { return valueOf(checkarith()-rhs); }
+
+ public LuaValue subFrom(double lhs) { return valueOf(lhs-checkarith()); }
+
+ public LuaValue mul(LuaValue rhs) {
+ double d = scannumber();
+ return Double.isNaN(d)? arithmt(MUL, rhs): rhs.mul(d);
+ }
+
+ public LuaValue mul(double rhs) { return valueOf(checkarith()*rhs); }
+
+ public LuaValue mul(int rhs) { return valueOf(checkarith()*rhs); }
+
+ public LuaValue pow(LuaValue rhs) {
+ double d = scannumber();
+ return Double.isNaN(d)? arithmt(POW, rhs): rhs.powWith(d);
+ }
+
+ public LuaValue pow(double rhs) { return MathLib.dpow(checkarith(), rhs); }
+
+ public LuaValue pow(int rhs) { return MathLib.dpow(checkarith(), rhs); }
+
+ public LuaValue powWith(double lhs) { return MathLib.dpow(lhs, checkarith()); }
+
+ public LuaValue powWith(int lhs) { return MathLib.dpow(lhs, checkarith()); }
+
+ public LuaValue div(LuaValue rhs) {
+ double d = scannumber();
+ return Double.isNaN(d)? arithmt(DIV, rhs): rhs.divInto(d);
+ }
+
+ public LuaValue div(double rhs) { return LuaDouble.ddiv(checkarith(), rhs); }
+
+ public LuaValue div(int rhs) { return LuaDouble.ddiv(checkarith(), rhs); }
+
+ public LuaValue divInto(double lhs) { return LuaDouble.ddiv(lhs, checkarith()); }
+
+ public LuaValue mod(LuaValue rhs) {
+ double d = scannumber();
+ return Double.isNaN(d)? arithmt(MOD, rhs): rhs.modFrom(d);
+ }
+
+ public LuaValue mod(double rhs) { return LuaDouble.dmod(checkarith(), rhs); }
+
+ public LuaValue mod(int rhs) { return LuaDouble.dmod(checkarith(), rhs); }
+
+ public LuaValue modFrom(double lhs) { return LuaDouble.dmod(lhs, checkarith()); }
+
// relational operators, these only work with other strings
- public LuaValue lt( LuaValue rhs ) { return rhs.isstring() ? (rhs.strcmp(this)>0? LuaValue.TRUE: FALSE) : super.lt(rhs); }
- public boolean lt_b( LuaValue rhs ) { return rhs.isstring() ? rhs.strcmp(this)>0 : super.lt_b(rhs); }
- public boolean lt_b( int rhs ) { typerror("attempt to compare string with number"); return false; }
- public boolean lt_b( double rhs ) { typerror("attempt to compare string with number"); return false; }
- public LuaValue lteq( LuaValue rhs ) { return rhs.isstring() ? (rhs.strcmp(this)>=0? LuaValue.TRUE: FALSE) : super.lteq(rhs); }
- public boolean lteq_b( LuaValue rhs ) { return rhs.isstring() ? rhs.strcmp(this)>=0 : super.lteq_b(rhs); }
- public boolean lteq_b( int rhs ) { typerror("attempt to compare string with number"); return false; }
- public boolean lteq_b( double rhs ) { typerror("attempt to compare string with number"); return false; }
- public LuaValue gt( LuaValue rhs ) { return rhs.isstring() ? (rhs.strcmp(this)<0? LuaValue.TRUE: FALSE) : super.gt(rhs); }
- public boolean gt_b( LuaValue rhs ) { return rhs.isstring() ? rhs.strcmp(this)<0 : super.gt_b(rhs); }
- public boolean gt_b( int rhs ) { typerror("attempt to compare string with number"); return false; }
- public boolean gt_b( double rhs ) { typerror("attempt to compare string with number"); return false; }
- public LuaValue gteq( LuaValue rhs ) { return rhs.isstring() ? (rhs.strcmp(this)<=0? LuaValue.TRUE: FALSE) : super.gteq(rhs); }
- public boolean gteq_b( LuaValue rhs ) { return rhs.isstring() ? rhs.strcmp(this)<=0 : super.gteq_b(rhs); }
- public boolean gteq_b( int rhs ) { typerror("attempt to compare string with number"); return false; }
- public boolean gteq_b( double rhs ) { typerror("attempt to compare string with number"); return false; }
+ public LuaValue lt(LuaValue rhs) {
+ return rhs.isstring()? (rhs.strcmp(this) > 0? LuaValue.TRUE: FALSE): super.lt(rhs);
+ }
+
+ public boolean lt_b(LuaValue rhs) { return rhs.isstring()? rhs.strcmp(this) > 0: super.lt_b(rhs); }
+
+ public boolean lt_b(int rhs) { typerror("attempt to compare string with number"); return false; }
+
+ public boolean lt_b(double rhs) { typerror("attempt to compare string with number"); return false; }
+
+ public LuaValue lteq(LuaValue rhs) {
+ return rhs.isstring()? (rhs.strcmp(this) >= 0? LuaValue.TRUE: FALSE): super.lteq(rhs);
+ }
+
+ public boolean lteq_b(LuaValue rhs) { return rhs.isstring()? rhs.strcmp(this) >= 0: super.lteq_b(rhs); }
+
+ public boolean lteq_b(int rhs) { typerror("attempt to compare string with number"); return false; }
+
+ public boolean lteq_b(double rhs) { typerror("attempt to compare string with number"); return false; }
+
+ public LuaValue gt(LuaValue rhs) {
+ return rhs.isstring()? (rhs.strcmp(this) < 0? LuaValue.TRUE: FALSE): super.gt(rhs);
+ }
+
+ public boolean gt_b(LuaValue rhs) { return rhs.isstring()? rhs.strcmp(this) < 0: super.gt_b(rhs); }
+
+ public boolean gt_b(int rhs) { typerror("attempt to compare string with number"); return false; }
+
+ public boolean gt_b(double rhs) { typerror("attempt to compare string with number"); return false; }
+
+ public LuaValue gteq(LuaValue rhs) {
+ return rhs.isstring()? (rhs.strcmp(this) <= 0? LuaValue.TRUE: FALSE): super.gteq(rhs);
+ }
+
+ public boolean gteq_b(LuaValue rhs) { return rhs.isstring()? rhs.strcmp(this) <= 0: super.gteq_b(rhs); }
+
+ public boolean gteq_b(int rhs) { typerror("attempt to compare string with number"); return false; }
+
+ public boolean gteq_b(double rhs) { typerror("attempt to compare string with number"); return false; }
// concatenation
- public LuaValue concat(LuaValue rhs) { return rhs.concatTo(this); }
- public Buffer concat(Buffer rhs) { return rhs.concatTo(this); }
- public LuaValue concatTo(LuaNumber lhs) { return concatTo(lhs.strvalue()); }
- public LuaValue concatTo(LuaString lhs) {
+ public LuaValue concat(LuaValue rhs) { return rhs.concatTo(this); }
+
+ public Buffer concat(Buffer rhs) { return rhs.concatTo(this); }
+
+ public LuaValue concatTo(LuaNumber lhs) { return concatTo(lhs.strvalue()); }
+
+ public LuaValue concatTo(LuaString lhs) {
byte[] b = new byte[lhs.m_length+this.m_length];
System.arraycopy(lhs.m_bytes, lhs.m_offset, b, 0, lhs.m_length);
System.arraycopy(this.m_bytes, this.m_offset, b, lhs.m_length, this.m_length);
@@ -318,57 +424,63 @@ public class LuaString extends LuaValue {
}
// string comparison
- public int strcmp(LuaValue lhs) { return -lhs.strcmp(this); }
+ public int strcmp(LuaValue lhs) { return -lhs.strcmp(this); }
+
public int strcmp(LuaString rhs) {
- for ( int i=0, j=0; i
- * The string should be measured first with lengthAsUtf8
- * to make sure the given byte array is large enough.
- * @param chars Array of unicode characters to be encoded as UTF-8
+ * The string should be measured first with lengthAsUtf8 to make sure the
+ * given byte array is large enough.
+ *
+ * @param chars Array of unicode characters to be encoded as UTF-8
* @param nchars Number of characters in the array to convert.
- * @param bytes byte array to hold the result
- * @param off offset into the byte array to start writing
+ * @param bytes byte array to hold the result
+ * @param off offset into the byte array to start writing
* @return number of bytes converted.
* @see #lengthAsUtf8(char[])
* @see #decodeAsUtf8(byte[], int, int)
@@ -689,158 +830,180 @@ public class LuaString extends LuaValue {
public static int encodeToUtf8(char[] chars, int nchars, byte[] bytes, int off) {
char c;
int j = off;
- for ( int i=0; i
- * If a table is needed, the one of the type-checking functions can be used such as
- * {@link #istable()},
- * {@link #checktable()}, or
- * {@link #opttable(LuaTable)}
+ * If a table is needed, the one of the type-checking functions can be used such
+ * as {@link #istable()}, {@link #checktable()}, or {@link #opttable(LuaTable)}
*
- * The main table operations are defined on {@link LuaValue}
- * for getting and setting values with and without metatag processing:
+ * The main table operations are defined on {@link LuaValue} for getting and
+ * setting values with and without metatag processing:
*
* To iterate over key-value pairs from Java, use
- *
- * As with other types, {@link LuaTable} instances should be constructed via one of the table constructor
- * methods on {@link LuaValue}:
+ * As with other types, {@link LuaTable} instances should be constructed via one
+ * of the table constructor methods on {@link LuaValue}:
*
- * A LuaThread is typically created in response to a scripted call to
+ * A LuaThread is typically created in response to a scripted call to
* {@code coroutine.create()}
*
- * The threads must be initialized with the globals, so that
- * the global environment may be passed along according to rules of lua.
- * This is done via the constructor arguments {@link #LuaThread(Globals)} or
+ * The threads must be initialized with the globals, so that the global
+ * environment may be passed along according to rules of lua. This is done via
+ * the constructor arguments {@link #LuaThread(Globals)} or
* {@link #LuaThread(Globals, LuaValue)}.
- *
- * The utility classes {@link org.luaj.vm2.lib.jse.JsePlatform} and
- * {@link org.luaj.vm2.lib.jme.JmePlatform}
- * see to it that this {@link Globals} are initialized properly.
*
- * The behavior of coroutine threads matches closely the behavior
- * of C coroutine library. However, because of the use of Java threads
- * to manage call state, it is possible to yield from anywhere in luaj.
+ * The utility classes {@link org.luaj.vm2.lib.jse.JsePlatform} and
+ * {@link org.luaj.vm2.lib.jme.JmePlatform} see to it that this {@link Globals}
+ * are initialized properly.
*
- * Each Java thread wakes up at regular intervals and checks a weak reference
- * to determine if it can ever be resumed. If not, it throws
- * {@link OrphanedThread} which is an {@link java.lang.Error}.
- * Applications should not catch {@link OrphanedThread}, because it can break
- * the thread safety of luaj. The value controlling the polling interval
- * is {@link #thread_orphan_check_interval} and may be set by the user.
- *
- * There are two main ways to abandon a coroutine. The first is to call
- * {@code yield()} from lua, or equivalently {@link Globals#yield(Varargs)},
- * and arrange to have it never resumed possibly by values passed to yield.
- * The second is to throw {@link OrphanedThread}, which should put the thread
- * in a dead state. In either case all references to the thread must be
- * dropped, and the garbage collector must run for the thread to be
- * garbage collected.
+ * The behavior of coroutine threads matches closely the behavior of C coroutine
+ * library. However, because of the use of Java threads to manage call state, it
+ * is possible to yield from anywhere in luaj.
+ *
+ * Each Java thread wakes up at regular intervals and checks a weak reference to
+ * determine if it can ever be resumed. If not, it throws {@link OrphanedThread}
+ * which is an {@link java.lang.Error}. Applications should not catch
+ * {@link OrphanedThread}, because it can break the thread safety of luaj. The
+ * value controlling the polling interval is
+ * {@link #thread_orphan_check_interval} and may be set by the user.
+ *
+ * There are two main ways to abandon a coroutine. The first is to call
+ * {@code yield()} from lua, or equivalently {@link Globals#yield(Varargs)}, and
+ * arrange to have it never resumed possibly by values passed to yield. The
+ * second is to throw {@link OrphanedThread}, which should put the thread in a
+ * dead state. In either case all references to the thread must be dropped, and
+ * the garbage collector must run for the thread to be garbage collected.
*
- *
+ *
* @see LuaValue
* @see org.luaj.vm2.lib.jse.JsePlatform
* @see org.luaj.vm2.lib.jme.JmePlatform
@@ -70,107 +68,102 @@ public class LuaThread extends LuaValue {
/** Shared metatable for lua threads. */
public static LuaValue s_metatable;
- /** The current number of coroutines. Should not be set. */
+ /** The current number of coroutines. Should not be set. */
public static int coroutine_count = 0;
- /** Polling interval, in milliseconds, which each thread uses while waiting to
- * return from a yielded state to check if the lua threads is no longer
- * referenced and therefore should be garbage collected.
- * A short polling interval for many threads will consume server resources.
- * Orphaned threads cannot be detected and collected unless garbage
- * collection is run. This can be changed by Java startup code if desired.
+ /**
+ * Polling interval, in milliseconds, which each thread uses while waiting
+ * to return from a yielded state to check if the lua threads is no longer
+ * referenced and therefore should be garbage collected. A short polling
+ * interval for many threads will consume server resources. Orphaned threads
+ * cannot be detected and collected unless garbage collection is run. This
+ * can be changed by Java startup code if desired.
*/
public static long thread_orphan_check_interval = 5000;
-
- public static final int STATUS_INITIAL = 0;
- public static final int STATUS_SUSPENDED = 1;
- public static final int STATUS_RUNNING = 2;
- public static final int STATUS_NORMAL = 3;
- public static final int STATUS_DEAD = 4;
- public static final String[] STATUS_NAMES = {
- "suspended",
- "suspended",
- "running",
- "normal",
- "dead",};
-
+
+ public static final int STATUS_INITIAL = 0;
+ public static final int STATUS_SUSPENDED = 1;
+ public static final int STATUS_RUNNING = 2;
+ public static final int STATUS_NORMAL = 3;
+ public static final int STATUS_DEAD = 4;
+ public static final String[] STATUS_NAMES = { "suspended", "suspended", "running", "normal", "dead", };
+
public final State state;
- public static final int MAX_CALLSTACK = 256;
+ public static final int MAX_CALLSTACK = 256;
- /** Thread-local used by DebugLib to store debugging state.
- * This is an opaque value that should not be modified by applications. */
+ /**
+ * Thread-local used by DebugLib to store debugging state. This is an opaque
+ * value that should not be modified by applications.
+ */
public Object callstack;
public final Globals globals;
- /** Error message handler for this thread, if any. */
+ /** Error message handler for this thread, if any. */
public LuaValue errorfunc;
-
+
/** Private constructor for main thread only */
public LuaThread(Globals globals) {
state = new State(globals, this, null);
state.status = STATUS_RUNNING;
this.globals = globals;
}
-
- /**
+
+ /**
* Create a LuaThread around a function and environment
+ *
* @param func The function to execute
*/
- public LuaThread(Globals globals, LuaValue func) {
+ public LuaThread(Globals globals, LuaValue func) {
LuaValue.assert_(func != null, "function cannot be null");
state = new State(globals, this, func);
this.globals = globals;
}
-
+
public int type() {
return LuaValue.TTHREAD;
}
-
+
public String typename() {
return "thread";
}
-
+
public boolean isthread() {
return true;
}
-
+
public LuaThread optthread(LuaThread defval) {
return this;
}
-
+
public LuaThread checkthread() {
return this;
}
-
- public LuaValue getmetatable() {
- return s_metatable;
- }
-
- public String getStatus() {
- return STATUS_NAMES[state.status];
+
+ public LuaValue getmetatable() {
+ return s_metatable;
}
- public boolean isMainThread() {
- return this.state.function == null;
- }
+ public String getStatus() { return STATUS_NAMES[state.status]; }
+
+ public boolean isMainThread() { return this.state.function == null; }
public Varargs resume(Varargs args) {
final LuaThread.State s = this.state;
if (s.status > LuaThread.STATUS_SUSPENDED)
- return LuaValue.varargsOf(LuaValue.FALSE,
- LuaValue.valueOf("cannot resume "+(s.status==LuaThread.STATUS_DEAD? "dead": "non-suspended")+" coroutine"));
+ return LuaValue.varargsOf(LuaValue.FALSE, LuaValue.valueOf(
+ "cannot resume " + (s.status == LuaThread.STATUS_DEAD? "dead": "non-suspended") + " coroutine"));
return s.lua_resume(this, args);
}
public static class State implements Runnable {
private final Globals globals;
- final WeakReference lua_thread;
+ final WeakReference lua_thread;
public final LuaValue function;
- Varargs args = LuaValue.NONE;
- Varargs result = LuaValue.NONE;
- String error = null;
+ Varargs args = LuaValue.NONE;
+ Varargs result = LuaValue.NONE;
+ String error = null;
/** Hook function control state used by debug lib. */
public LuaValue hookfunc;
@@ -178,11 +171,11 @@ public class LuaThread extends LuaValue {
public boolean hookline;
public boolean hookcall;
public boolean hookrtrn;
- public int hookcount;
+ public int hookcount;
public boolean inhook;
- public int lastline;
- public int bytecodes;
-
+ public int lastline;
+ public int bytecodes;
+
public int status = LuaThread.STATUS_INITIAL;
State(Globals globals, LuaThread lua_thread, LuaValue function) {
@@ -190,7 +183,7 @@ public class LuaThread extends LuaValue {
this.lua_thread = new WeakReference(lua_thread);
this.function = function;
}
-
+
public synchronized void run() {
try {
Varargs a = this.args;
@@ -210,8 +203,8 @@ public class LuaThread extends LuaValue {
globals.running = new_thread;
this.args = args;
if (this.status == STATUS_INITIAL) {
- this.status = STATUS_RUNNING;
- new Thread(this, "Coroutine-"+(++coroutine_count)).start();
+ this.status = STATUS_RUNNING;
+ new Thread(this, "Coroutine-" + (++coroutine_count)).start();
} else {
this.notify();
}
@@ -219,9 +212,8 @@ public class LuaThread extends LuaValue {
previous_thread.state.status = STATUS_NORMAL;
this.status = STATUS_RUNNING;
this.wait();
- return (this.error != null?
- LuaValue.varargsOf(LuaValue.FALSE, LuaValue.valueOf(this.error)):
- LuaValue.varargsOf(LuaValue.TRUE, this.result));
+ return (this.error != null? LuaValue.varargsOf(LuaValue.FALSE, LuaValue.valueOf(this.error))
+ : LuaValue.varargsOf(LuaValue.TRUE, this.result));
} catch (InterruptedException ie) {
throw new OrphanedThread();
} finally {
@@ -230,7 +222,7 @@ public class LuaThread extends LuaValue {
this.error = null;
globals.running = previous_thread;
if (previous_thread != null)
- globals.running.state.status =STATUS_RUNNING;
+ globals.running.state.status = STATUS_RUNNING;
}
}
@@ -245,7 +237,7 @@ public class LuaThread extends LuaValue {
this.status = STATUS_DEAD;
throw new OrphanedThread();
}
- } while (this.status == STATUS_SUSPENDED);
+ } while ( this.status == STATUS_SUSPENDED );
return this.args;
} catch (InterruptedException ie) {
this.status = STATUS_DEAD;
@@ -256,5 +248,5 @@ public class LuaThread extends LuaValue {
}
}
}
-
+
}
diff --git a/luaj-core/src/main/java/org/luaj/vm2/LuaUserdata.java b/luaj-core/src/main/java/org/luaj/vm2/LuaUserdata.java
index b6f58e09..0104502f 100644
--- a/luaj-core/src/main/java/org/luaj/vm2/LuaUserdata.java
+++ b/luaj-core/src/main/java/org/luaj/vm2/LuaUserdata.java
@@ -21,29 +21,28 @@
******************************************************************************/
package org.luaj.vm2;
-
public class LuaUserdata extends LuaValue {
-
- public Object m_instance;
+
+ public Object m_instance;
public LuaValue m_metatable;
-
+
public LuaUserdata(Object obj) {
m_instance = obj;
}
-
+
public LuaUserdata(Object obj, LuaValue metatable) {
m_instance = obj;
m_metatable = metatable;
}
-
+
public String tojstring() {
return String.valueOf(m_instance);
}
-
+
public int type() {
return LuaValue.TUSERDATA;
}
-
+
public String typename() {
return "userdata";
}
@@ -51,22 +50,27 @@ public class LuaUserdata extends LuaValue {
public int hashCode() {
return m_instance.hashCode();
}
-
+
public Object userdata() {
return m_instance;
}
-
- public boolean isuserdata() { return true; }
- public boolean isuserdata(Class c) { return c.isAssignableFrom(m_instance.getClass()); }
- public Object touserdata() { return m_instance; }
- public Object touserdata(Class c) { return c.isAssignableFrom(m_instance.getClass())? m_instance: null; }
- public Object optuserdata(Object defval) { return m_instance; }
+
+ public boolean isuserdata() { return true; }
+
+ public boolean isuserdata(Class c) { return c.isAssignableFrom(m_instance.getClass()); }
+
+ public Object touserdata() { return m_instance; }
+
+ public Object touserdata(Class c) { return c.isAssignableFrom(m_instance.getClass())? m_instance: null; }
+
+ public Object optuserdata(Object defval) { return m_instance; }
+
public Object optuserdata(Class c, Object defval) {
if (!c.isAssignableFrom(m_instance.getClass()))
typerror(c.getName());
return m_instance;
}
-
+
public LuaValue getmetatable() {
return m_metatable;
}
@@ -79,48 +83,53 @@ public class LuaUserdata extends LuaValue {
public Object checkuserdata() {
return m_instance;
}
-
- public Object checkuserdata(Class c) {
- if ( c.isAssignableFrom(m_instance.getClass()) )
- return m_instance;
+
+ public Object checkuserdata(Class c) {
+ if (c.isAssignableFrom(m_instance.getClass()))
+ return m_instance;
return typerror(c.getName());
}
-
- public LuaValue get( LuaValue key ) {
- return m_metatable!=null? gettable(this,key): NIL;
- }
-
- public void set( LuaValue key, LuaValue value ) {
- if ( m_metatable==null || ! settable(this,key,value) )
- error( "cannot set "+key+" for userdata" );
+
+ public LuaValue get(LuaValue key) {
+ return m_metatable != null? gettable(this, key): NIL;
}
- public boolean equals( Object val ) {
- if ( this == val )
+ public void set(LuaValue key, LuaValue value) {
+ if (m_metatable == null || !settable(this, key, value))
+ error("cannot set " + key + " for userdata");
+ }
+
+ public boolean equals(Object val) {
+ if (this == val)
return true;
- if ( ! (val instanceof LuaUserdata) )
+ if (!(val instanceof LuaUserdata))
return false;
LuaUserdata u = (LuaUserdata) val;
return m_instance.equals(u.m_instance);
}
// equality w/ metatable processing
- public LuaValue eq( LuaValue val ) { return eq_b(val)? TRUE: FALSE; }
- public boolean eq_b( LuaValue val ) {
- if ( val.raweq(this) ) return true;
- if ( m_metatable == null || !val.isuserdata() ) return false;
+ public LuaValue eq(LuaValue val) { return eq_b(val)? TRUE: FALSE; }
+
+ public boolean eq_b(LuaValue val) {
+ if (val.raweq(this))
+ return true;
+ if (m_metatable == null || !val.isuserdata())
+ return false;
LuaValue valmt = val.getmetatable();
- return valmt!=null && LuaValue.eqmtcall(this, m_metatable, val, valmt);
+ return valmt != null && LuaValue.eqmtcall(this, m_metatable, val, valmt);
}
-
+
// equality w/o metatable processing
- public boolean raweq( LuaValue val ) { return val.raweq(this); }
- public boolean raweq( LuaUserdata val ) {
- return this == val || (m_metatable == val.m_metatable && m_instance.equals(val.m_instance));
+ public boolean raweq(LuaValue val) { return val.raweq(this); }
+
+ public boolean raweq(LuaUserdata val) {
+ return this == val || (m_metatable == val.m_metatable && m_instance.equals(val.m_instance));
}
-
+
// __eq metatag processing
- public boolean eqmt( LuaValue val ) {
- return m_metatable!=null && val.isuserdata()? LuaValue.eqmtcall(this, m_metatable, val, val.getmetatable()): false;
+ public boolean eqmt(LuaValue val) {
+ return m_metatable != null && val.isuserdata()? LuaValue.eqmtcall(this, m_metatable, val, val.getmetatable())
+ : false;
}
}
diff --git a/luaj-core/src/main/java/org/luaj/vm2/LuaValue.java b/luaj-core/src/main/java/org/luaj/vm2/LuaValue.java
index 9d3af18d..d4773fd2 100644
--- a/luaj-core/src/main/java/org/luaj/vm2/LuaValue.java
+++ b/luaj-core/src/main/java/org/luaj/vm2/LuaValue.java
@@ -24,63 +24,86 @@ package org.luaj.vm2;
/**
* Base class for all concrete lua type values.
*
- * Establishes base implementations for all the operations on lua types.
- * This allows Java clients to deal essentially with one type for all Java values, namely {@link LuaValue}.
+ * Establishes base implementations for all the operations on lua types. This
+ * allows Java clients to deal essentially with one type for all Java values,
+ * namely {@link LuaValue}.
*
* Constructors are provided as static methods for common Java types, such as
- * {@link LuaValue#valueOf(int)} or {@link LuaValue#valueOf(String)}
- * to allow for instance pooling.
+ * {@link LuaValue#valueOf(int)} or {@link LuaValue#valueOf(String)} to allow
+ * for instance pooling.
*
- * Constants are defined for the lua values
- * {@link #NIL}, {@link #TRUE}, and {@link #FALSE}.
- * A constant {@link #NONE} is defined which is a {@link Varargs} list having no values.
+ * Constants are defined for the lua values {@link #NIL}, {@link #TRUE}, and
+ * {@link #FALSE}. A constant {@link #NONE} is defined which is a
+ * {@link Varargs} list having no values.
*
- * Operations are performed on values directly via their Java methods.
- * For example, the following code divides two numbers:
- *
- * Field access and function calls are similar, with common overloads to simplify Java usage:
- *
* To supply variable arguments or get multiple return values, use
* {@link #invoke(Varargs)} or {@link #invokemethod(LuaValue, Varargs)} methods:
- *
* To load and run a script, {@link LoadState} is used:
- *
* although {@code require} could also be used:
- *
- * In general a {@link LuaError} may be thrown on any operation when the
- * types supplied to any operation are illegal from a lua perspective.
- * Examples could be attempting to concatenate a NIL value, or attempting arithmetic
- * on values that are not number.
+ * In general a {@link LuaError} may be thrown on any operation when the types
+ * supplied to any operation are illegal from a lua perspective. Examples could
+ * be attempting to concatenate a NIL value, or attempting arithmetic on values
+ * that are not number.
*
* There are several methods for preinitializing tables, such as:
*
- * Predefined constants exist for the standard lua type constants
- * {@link #TNIL}, {@link #TBOOLEAN}, {@link #TLIGHTUSERDATA}, {@link #TNUMBER}, {@link #TSTRING},
- * {@link #TTABLE}, {@link #TFUNCTION}, {@link #TUSERDATA}, {@link #TTHREAD},
- * and extended lua type constants
- * {@link #TINT}, {@link #TNONE}, {@link #TVALUE}
+ * Predefined constants exist for the standard lua type constants {@link #TNIL},
+ * {@link #TBOOLEAN}, {@link #TLIGHTUSERDATA}, {@link #TNUMBER},
+ * {@link #TSTRING}, {@link #TTABLE}, {@link #TFUNCTION}, {@link #TUSERDATA},
+ * {@link #TTHREAD}, and extended lua type constants {@link #TINT},
+ * {@link #TNONE}, {@link #TVALUE}
*
- * Predefined constants exist for all strings used as metatags:
- * {@link #INDEX}, {@link #NEWINDEX}, {@link #CALL}, {@link #MODE}, {@link #METATABLE},
+ * Predefined constants exist for all strings used as metatags: {@link #INDEX},
+ * {@link #NEWINDEX}, {@link #CALL}, {@link #MODE}, {@link #METATABLE},
* {@link #ADD}, {@link #SUB}, {@link #DIV}, {@link #MUL}, {@link #POW},
* {@link #MOD}, {@link #UNM}, {@link #LEN}, {@link #EQ}, {@link #LT},
* {@link #LE}, {@link #TOSTRING}, and {@link #CONCAT}.
@@ -106,185 +129,189 @@ package org.luaj.vm2;
* @see LoadState
* @see Varargs
*/
-abstract
-public class LuaValue extends Varargs {
-
- /** Type enumeration constant for lua numbers that are ints, for compatibility with lua 5.1 number patch only */
- public static final int TINT = (-2);
-
- /** Type enumeration constant for lua values that have no type, for example weak table entries */
- public static final int TNONE = (-1);
-
- /** Type enumeration constant for lua nil */
- public static final int TNIL = 0;
-
- /** Type enumeration constant for lua booleans */
- public static final int TBOOLEAN = 1;
-
- /** Type enumeration constant for lua light userdata, for compatibility with C-based lua only */
- public static final int TLIGHTUSERDATA = 2;
-
- /** Type enumeration constant for lua numbers */
- public static final int TNUMBER = 3;
-
- /** Type enumeration constant for lua strings */
- public static final int TSTRING = 4;
-
- /** Type enumeration constant for lua tables */
- public static final int TTABLE = 5;
-
- /** Type enumeration constant for lua functions */
- public static final int TFUNCTION = 6;
-
- /** Type enumeration constant for lua userdatas */
- public static final int TUSERDATA = 7;
-
- /** Type enumeration constant for lua threads */
- public static final int TTHREAD = 8;
-
- /** Type enumeration constant for unknown values, for compatibility with C-based lua only */
- public static final int TVALUE = 9;
+abstract public class LuaValue extends Varargs {
- /** String array constant containing names of each of the lua value types
+ /**
+ * Type enumeration constant for lua numbers that are ints, for
+ * compatibility with lua 5.1 number patch only
+ */
+ public static final int TINT = (-2);
+
+ /**
+ * Type enumeration constant for lua values that have no type, for example
+ * weak table entries
+ */
+ public static final int TNONE = (-1);
+
+ /** Type enumeration constant for lua nil */
+ public static final int TNIL = 0;
+
+ /** Type enumeration constant for lua booleans */
+ public static final int TBOOLEAN = 1;
+
+ /**
+ * Type enumeration constant for lua light userdata, for compatibility with
+ * C-based lua only
+ */
+ public static final int TLIGHTUSERDATA = 2;
+
+ /** Type enumeration constant for lua numbers */
+ public static final int TNUMBER = 3;
+
+ /** Type enumeration constant for lua strings */
+ public static final int TSTRING = 4;
+
+ /** Type enumeration constant for lua tables */
+ public static final int TTABLE = 5;
+
+ /** Type enumeration constant for lua functions */
+ public static final int TFUNCTION = 6;
+
+ /** Type enumeration constant for lua userdatas */
+ public static final int TUSERDATA = 7;
+
+ /** Type enumeration constant for lua threads */
+ public static final int TTHREAD = 8;
+
+ /**
+ * Type enumeration constant for unknown values, for compatibility with
+ * C-based lua only
+ */
+ public static final int TVALUE = 9;
+
+ /**
+ * String array constant containing names of each of the lua value types
+ *
* @see #type()
* @see #typename()
*/
- public static final String[] TYPE_NAMES = {
- "nil",
- "boolean",
- "lightuserdata",
- "number",
- "string",
- "table",
- "function",
- "userdata",
- "thread",
- "value",
- };
-
+ public static final String[] TYPE_NAMES = { "nil", "boolean", "lightuserdata", "number", "string", "table",
+ "function", "userdata", "thread", "value", };
+
/** LuaValue constant corresponding to lua {@code #NIL} */
- public static final LuaValue NIL = LuaNil._NIL;
-
+ public static final LuaValue NIL = LuaNil._NIL;
+
/** LuaBoolean constant corresponding to lua {@code true} */
- public static final LuaBoolean TRUE = LuaBoolean._TRUE;
+ public static final LuaBoolean TRUE = LuaBoolean._TRUE;
/** LuaBoolean constant corresponding to lua {@code false} */
- public static final LuaBoolean FALSE = LuaBoolean._FALSE;
+ public static final LuaBoolean FALSE = LuaBoolean._FALSE;
+
+ /**
+ * LuaValue constant corresponding to a {@link Varargs} list of no values
+ */
+ public static final LuaValue NONE = None._NONE;
- /** LuaValue constant corresponding to a {@link Varargs} list of no values */
- public static final LuaValue NONE = None._NONE;
-
/** LuaValue number constant equal to 0 */
- public static final LuaNumber ZERO = LuaInteger.valueOf(0);
-
+ public static final LuaNumber ZERO = LuaInteger.valueOf(0);
+
/** LuaValue number constant equal to 1 */
- public static final LuaNumber ONE = LuaInteger.valueOf(1);
+ public static final LuaNumber ONE = LuaInteger.valueOf(1);
/** LuaValue number constant equal to -1 */
- public static final LuaNumber MINUSONE = LuaInteger.valueOf(-1);
-
+ public static final LuaNumber MINUSONE = LuaInteger.valueOf(-1);
+
/** LuaValue array constant with no values */
- public static final LuaValue[] NOVALS = {};
+ public static final LuaValue[] NOVALS = {};
/** The variable name of the environment. */
- public static LuaString ENV = valueOf("_ENV");
+ public static LuaString ENV = valueOf("_ENV");
/** LuaString constant with value "__index" for use as metatag */
- public static final LuaString INDEX = valueOf("__index");
+ public static final LuaString INDEX = valueOf("__index");
/** LuaString constant with value "__newindex" for use as metatag */
- public static final LuaString NEWINDEX = valueOf("__newindex");
+ public static final LuaString NEWINDEX = valueOf("__newindex");
/** LuaString constant with value "__call" for use as metatag */
- public static final LuaString CALL = valueOf("__call");
+ public static final LuaString CALL = valueOf("__call");
/** LuaString constant with value "__mode" for use as metatag */
- public static final LuaString MODE = valueOf("__mode");
+ public static final LuaString MODE = valueOf("__mode");
/** LuaString constant with value "__metatable" for use as metatag */
- public static final LuaString METATABLE = valueOf("__metatable");
+ public static final LuaString METATABLE = valueOf("__metatable");
/** LuaString constant with value "__add" for use as metatag */
- public static final LuaString ADD = valueOf("__add");
+ public static final LuaString ADD = valueOf("__add");
/** LuaString constant with value "__sub" for use as metatag */
- public static final LuaString SUB = valueOf("__sub");
+ public static final LuaString SUB = valueOf("__sub");
/** LuaString constant with value "__div" for use as metatag */
- public static final LuaString DIV = valueOf("__div");
+ public static final LuaString DIV = valueOf("__div");
/** LuaString constant with value "__mul" for use as metatag */
- public static final LuaString MUL = valueOf("__mul");
+ public static final LuaString MUL = valueOf("__mul");
/** LuaString constant with value "__pow" for use as metatag */
- public static final LuaString POW = valueOf("__pow");
+ public static final LuaString POW = valueOf("__pow");
/** LuaString constant with value "__mod" for use as metatag */
- public static final LuaString MOD = valueOf("__mod");
+ public static final LuaString MOD = valueOf("__mod");
/** LuaString constant with value "__unm" for use as metatag */
- public static final LuaString UNM = valueOf("__unm");
+ public static final LuaString UNM = valueOf("__unm");
/** LuaString constant with value "__len" for use as metatag */
- public static final LuaString LEN = valueOf("__len");
+ public static final LuaString LEN = valueOf("__len");
/** LuaString constant with value "__eq" for use as metatag */
- public static final LuaString EQ = valueOf("__eq");
+ public static final LuaString EQ = valueOf("__eq");
/** LuaString constant with value "__lt" for use as metatag */
- public static final LuaString LT = valueOf("__lt");
+ public static final LuaString LT = valueOf("__lt");
/** LuaString constant with value "__le" for use as metatag */
- public static final LuaString LE = valueOf("__le");
+ public static final LuaString LE = valueOf("__le");
/** LuaString constant with value "__tostring" for use as metatag */
- public static final LuaString TOSTRING = valueOf("__tostring");
+ public static final LuaString TOSTRING = valueOf("__tostring");
/** LuaString constant with value "__concat" for use as metatag */
- public static final LuaString CONCAT = valueOf("__concat");
-
+ public static final LuaString CONCAT = valueOf("__concat");
+
/** LuaString constant with value "" */
public static final LuaString EMPTYSTRING = valueOf("");
/** Limit on lua stack size */
private static int MAXSTACK = 250;
-
- /** Array of {@link #NIL} values to optimize filling stacks using System.arraycopy().
- * Must not be modified.
+
+ /**
+ * Array of {@link #NIL} values to optimize filling stacks using
+ * System.arraycopy(). Must not be modified.
*/
public static final LuaValue[] NILS = new LuaValue[MAXSTACK];
static {
- for ( int i=0; i
* No attempt to convert from string will be made by this call.
- * @return true if this is a {@code LuaInteger},
- * otherwise false
+ *
+ * @return true if this is a {@code LuaInteger}, otherwise false
* @see #isint()
* @see #isnumber()
* @see #tonumber()
* @see #TNUMBER
*/
- public boolean isinttype() { return false; }
-
- /** Check if {@code this} is a {@code number} and is representable by java long
- * without rounding or truncation
- * @return true if this is a {@code number}
- * meaning derives from {@link LuaNumber}
- * or derives from {@link LuaString} and is convertible to a number,
- * and can be represented by long,
- * otherwise false
+ public boolean isinttype() { return false; }
+
+ /**
+ * Check if {@code this} is a {@code number} and is representable by java
+ * long without rounding or truncation
+ *
+ * @return true if this is a {@code number} meaning derives from
+ * {@link LuaNumber} or derives from {@link LuaString} and is
+ * convertible to a number, and can be represented by long,
+ * otherwise false
* @see #tonumber()
* @see #checklong()
* @see #optlong(long)
* @see #TNUMBER
*/
- public boolean islong() { return false; }
-
- /** Check if {@code this} is {@code #NIL}
+ public boolean islong() { return false; }
+
+ /**
+ * Check if {@code this} is {@code #NIL}
+ *
* @return true if this is {@code #NIL}, otherwise false
* @see #NIL
* @see #NONE
@@ -365,48 +401,56 @@ public class LuaValue extends Varargs {
* @see #TNIL
* @see #TNONE
*/
- public boolean isnil() { return false; }
-
- /** Check if {@code this} is a {@code number}
- * @return true if this is a {@code number},
- * meaning derives from {@link LuaNumber}
- * or derives from {@link LuaString} and is convertible to a number,
- * otherwise false
+ public boolean isnil() { return false; }
+
+ /**
+ * Check if {@code this} is a {@code number}
+ *
+ * @return true if this is a {@code number}, meaning derives from
+ * {@link LuaNumber} or derives from {@link LuaString} and is
+ * convertible to a number, otherwise false
* @see #tonumber()
* @see #checknumber()
* @see #optnumber(LuaNumber)
* @see #TNUMBER
*/
- public boolean isnumber() { return false; } // may convert from string
-
- /** Check if {@code this} is a {@code string}
- * @return true if this is a {@code string},
- * meaning derives from {@link LuaString} or {@link LuaNumber},
- * otherwise false
+ public boolean isnumber() { return false; } // may convert from string
+
+ /**
+ * Check if {@code this} is a {@code string}
+ *
+ * @return true if this is a {@code string}, meaning derives from
+ * {@link LuaString} or {@link LuaNumber}, otherwise false
* @see #tostring()
* @see #checkstring()
* @see #optstring(LuaString)
* @see #TSTRING
*/
- public boolean isstring() { return false; }
-
- /** Check if {@code this} is a {@code thread}
+ public boolean isstring() { return false; }
+
+ /**
+ * Check if {@code this} is a {@code thread}
+ *
* @return true if this is a {@code thread}, otherwise false
* @see #checkthread()
* @see #optthread(LuaThread)
* @see #TTHREAD
*/
- public boolean isthread() { return false; }
-
- /** Check if {@code this} is a {@code table}
+ public boolean isthread() { return false; }
+
+ /**
+ * Check if {@code this} is a {@code table}
+ *
* @return true if this is a {@code table}, otherwise false
* @see #checktable()
* @see #opttable(LuaTable)
* @see #TTABLE
*/
- public boolean istable() { return false; }
-
- /** Check if {@code this} is a {@code userdata}
+ public boolean istable() { return false; }
+
+ /**
+ * Check if {@code this} is a {@code userdata}
+ *
* @return true if this is a {@code userdata}, otherwise false
* @see #isuserdata(Class)
* @see #touserdata()
@@ -414,52 +458,66 @@ public class LuaValue extends Varargs {
* @see #optuserdata(Object)
* @see #TUSERDATA
*/
- public boolean isuserdata() { return false; }
-
- /** Check if {@code this} is a {@code userdata} of type {@code c}
+ public boolean isuserdata() { return false; }
+
+ /**
+ * Check if {@code this} is a {@code userdata} of type {@code c}
+ *
* @param c Class to test instance against
- * @return true if this is a {@code userdata}
- * and the instance is assignable to {@code c},
- * otherwise false
+ * @return true if this is a {@code userdata} and the instance is assignable
+ * to {@code c}, otherwise false
* @see #isuserdata()
* @see #touserdata(Class)
* @see #checkuserdata(Class)
* @see #optuserdata(Class, Object)
* @see #TUSERDATA
*/
- public boolean isuserdata(Class c) { return false; }
-
- /** Convert to boolean false if {@link #NIL} or {@link #FALSE}, true if anything else
- * @return Value cast to byte if number or string convertible to number, otherwise 0
+ public boolean isuserdata(Class c) { return false; }
+
+ /**
+ * Convert to boolean false if {@link #NIL} or {@link #FALSE}, true if
+ * anything else
+ *
+ * @return Value cast to byte if number or string convertible to number,
+ * otherwise 0
* @see #optboolean(boolean)
* @see #checkboolean()
* @see #isboolean()
* @see #TBOOLEAN
*/
- public boolean toboolean() { return true; }
-
- /** Convert to byte if numeric, or 0 if not.
- * @return Value cast to byte if number or string convertible to number, otherwise 0
+ public boolean toboolean() { return true; }
+
+ /**
+ * Convert to byte if numeric, or 0 if not.
+ *
+ * @return Value cast to byte if number or string convertible to number,
+ * otherwise 0
* @see #toint()
* @see #todouble()
* @see #checknumber()
* @see #isnumber()
* @see #TNUMBER
*/
- public byte tobyte() { return 0; }
-
- /** Convert to char if numeric, or 0 if not.
- * @return Value cast to char if number or string convertible to number, otherwise 0
+ public byte tobyte() { return 0; }
+
+ /**
+ * Convert to char if numeric, or 0 if not.
+ *
+ * @return Value cast to char if number or string convertible to number,
+ * otherwise 0
* @see #toint()
* @see #todouble()
* @see #checknumber()
* @see #isnumber()
* @see #TNUMBER
*/
- public char tochar() { return 0; }
-
- /** Convert to double if numeric, or 0 if not.
- * @return Value cast to double if number or string convertible to number, otherwise 0
+ public char tochar() { return 0; }
+
+ /**
+ * Convert to double if numeric, or 0 if not.
+ *
+ * @return Value cast to double if number or string convertible to number,
+ * otherwise 0
* @see #toint()
* @see #tobyte()
* @see #tochar()
@@ -471,20 +529,26 @@ public class LuaValue extends Varargs {
* @see #isnumber()
* @see #TNUMBER
*/
- public double todouble() { return 0; }
-
- /** Convert to float if numeric, or 0 if not.
- * @return Value cast to float if number or string convertible to number, otherwise 0
+ public double todouble() { return 0; }
+
+ /**
+ * Convert to float if numeric, or 0 if not.
+ *
+ * @return Value cast to float if number or string convertible to number,
+ * otherwise 0
* @see #toint()
* @see #todouble()
* @see #checknumber()
* @see #isnumber()
* @see #TNUMBER
*/
- public float tofloat() { return 0; }
-
- /** Convert to int if numeric, or 0 if not.
- * @return Value cast to int if number or string convertible to number, otherwise 0
+ public float tofloat() { return 0; }
+
+ /**
+ * Convert to int if numeric, or 0 if not.
+ *
+ * @return Value cast to int if number or string convertible to number,
+ * otherwise 0
* @see #tobyte()
* @see #tochar()
* @see #toshort()
@@ -496,10 +560,13 @@ public class LuaValue extends Varargs {
* @see #isnumber()
* @see #TNUMBER
*/
- public int toint() { return 0; }
-
- /** Convert to long if numeric, or 0 if not.
- * @return Value cast to long if number or string convertible to number, otherwise 0
+ public int toint() { return 0; }
+
+ /**
+ * Convert to long if numeric, or 0 if not.
+ *
+ * @return Value cast to long if number or string convertible to number,
+ * otherwise 0
* @see #isint()
* @see #isinttype()
* @see #toint()
@@ -509,19 +576,24 @@ public class LuaValue extends Varargs {
* @see #isnumber()
* @see #TNUMBER
*/
- public long tolong() { return 0; }
-
- /** Convert to short if numeric, or 0 if not.
- * @return Value cast to short if number or string convertible to number, otherwise 0
+ public long tolong() { return 0; }
+
+ /**
+ * Convert to short if numeric, or 0 if not.
+ *
+ * @return Value cast to short if number or string convertible to number,
+ * otherwise 0
* @see #toint()
* @see #todouble()
* @see #checknumber()
* @see #isnumber()
* @see #TNUMBER
*/
- public short toshort() { return 0; }
-
- /** Convert to human readable String for any type.
+ public short toshort() { return 0; }
+
+ /**
+ * Convert to human readable String for any type.
+ *
* @return String for use by human readers based on type.
* @see #tostring()
* @see #optjstring(String)
@@ -529,29 +601,34 @@ public class LuaValue extends Varargs {
* @see #isstring()
* @see #TSTRING
*/
- public String tojstring() { return typename() + ": " + Integer.toHexString(hashCode()); }
-
- /** Convert to userdata instance, or null.
+ public String tojstring() { return typename() + ": " + Integer.toHexString(hashCode()); }
+
+ /**
+ * Convert to userdata instance, or null.
+ *
* @return userdata instance if userdata, or null if not {@link LuaUserdata}
* @see #optuserdata(Object)
* @see #checkuserdata()
* @see #isuserdata()
* @see #TUSERDATA
*/
- public Object touserdata() { return null; }
-
- /** Convert to userdata instance if specific type, or null.
- * @return userdata instance if is a userdata whose instance derives from {@code c},
- * or null if not {@link LuaUserdata}
+ public Object touserdata() { return null; }
+
+ /**
+ * Convert to userdata instance if specific type, or null.
+ *
+ * @return userdata instance if is a userdata whose instance derives from
+ * {@code c}, or null if not {@link LuaUserdata}
* @see #optuserdata(Class,Object)
* @see #checkuserdata(Class)
* @see #isuserdata(Class)
* @see #TUSERDATA
*/
- public Object touserdata(Class c) { return null; }
+ public Object touserdata(Class c) { return null; }
/**
* Convert the value to a human readable string using {@link #tojstring()}
+ *
* @return String value intended to be human readible.
* @see #tostring()
* @see #tojstring()
@@ -560,78 +637,86 @@ public class LuaValue extends Varargs {
* @see #toString()
*/
public String toString() { return tojstring(); }
-
- /** Conditionally convert to lua number without throwing errors.
+
+ /**
+ * Conditionally convert to lua number without throwing errors.
*
- * In lua all numbers are strings, but not all strings are numbers.
- * This function will return
- * the {@link LuaValue} {@code this} if it is a number
- * or a string convertible to a number,
- * and {@link #NIL} for all other cases.
+ * In lua all numbers are strings, but not all strings are numbers. This
+ * function will return the {@link LuaValue} {@code this} if it is a number
+ * or a string convertible to a number, and {@link #NIL} for all other
+ * cases.
*
- * This allows values to be tested for their "numeric-ness" without
- * the penalty of throwing exceptions,
- * nor the cost of converting the type and creating storage for it.
- * @return {@code this} if it is a {@link LuaNumber}
- * or {@link LuaString} that can be converted to a number,
- * otherwise {@link #NIL}
+ * This allows values to be tested for their "numeric-ness" without the
+ * penalty of throwing exceptions, nor the cost of converting the type and
+ * creating storage for it.
+ *
+ * @return {@code this} if it is a {@link LuaNumber} or {@link LuaString}
+ * that can be converted to a number, otherwise {@link #NIL}
* @see #tostring()
* @see #optnumber(LuaNumber)
* @see #checknumber()
* @see #toint()
* @see #todouble()
*/
- public LuaValue tonumber() { return NIL; }
-
- /** Conditionally convert to lua string without throwing errors.
+ public LuaValue tonumber() { return NIL; }
+
+ /**
+ * Conditionally convert to lua string without throwing errors.
*
- * In lua all numbers are strings, so this function will return
- * the {@link LuaValue} {@code this} if it is a string or number,
- * and {@link #NIL} for all other cases.
+ * In lua all numbers are strings, so this function will return the
+ * {@link LuaValue} {@code this} if it is a string or number, and
+ * {@link #NIL} for all other cases.
*
- * This allows values to be tested for their "string-ness" without
- * the penalty of throwing exceptions.
+ * This allows values to be tested for their "string-ness" without the
+ * penalty of throwing exceptions.
+ *
* @return {@code this} if it is a {@link LuaString} or {@link LuaNumber},
- * otherwise {@link #NIL}
+ * otherwise {@link #NIL}
* @see #tonumber()
* @see #tojstring()
* @see #optstring(LuaString)
* @see #checkstring()
* @see #toString()
*/
- public LuaValue tostring() { return NIL; }
+ public LuaValue tostring() { return NIL; }
- /** Check that optional argument is a boolean and return its boolean value
+ /**
+ * Check that optional argument is a boolean and return its boolean value
+ *
* @param defval boolean value to return if {@code this} is nil or none
* @return {@code this} cast to boolean if a {@link LuaBoolean},
- * {@code defval} if nil or none,
- * throws {@link LuaError} otherwise
+ * {@code defval} if nil or none, throws {@link LuaError} otherwise
* @throws LuaError if was not a boolean or nil or none.
* @see #checkboolean()
* @see #isboolean()
* @see #TBOOLEAN
*/
- public boolean optboolean(boolean defval) { argerror("boolean"); return false; }
+ public boolean optboolean(boolean defval) { argerror("boolean"); return false; }
- /** Check that optional argument is a closure and return as {@link LuaClosure}
+ /**
+ * Check that optional argument is a closure and return as
+ * {@link LuaClosure}
*
- * A {@link LuaClosure} is a {@link LuaFunction} that executes lua byteccode.
+ * A {@link LuaClosure} is a {@link LuaFunction} that executes lua
+ * byteccode.
+ *
* @param defval {@link LuaClosure} to return if {@code this} is nil or none
* @return {@code this} cast to {@link LuaClosure} if a function,
- * {@code defval} if nil or none,
- * throws {@link LuaError} otherwise
+ * {@code defval} if nil or none, throws {@link LuaError} otherwise
* @throws LuaError if was not a closure or nil or none.
* @see #checkclosure()
* @see #isclosure()
* @see #TFUNCTION
*/
- public LuaClosure optclosure(LuaClosure defval) { argerror("closure"); return null; }
+ public LuaClosure optclosure(LuaClosure defval) { argerror("closure"); return null; }
- /** Check that optional argument is a number or string convertible to number and return as double
+ /**
+ * Check that optional argument is a number or string convertible to number
+ * and return as double
+ *
* @param defval double to return if {@code this} is nil or none
- * @return {@code this} cast to double if numeric,
- * {@code defval} if nil or none,
- * throws {@link LuaError} otherwise
+ * @return {@code this} cast to double if numeric, {@code defval} if nil or
+ * none, throws {@link LuaError} otherwise
* @throws LuaError if was not numeric or nil or none.
* @see #optint(int)
* @see #optinteger(LuaInteger)
@@ -641,29 +726,34 @@ public class LuaValue extends Varargs {
* @see #isnumber()
* @see #TNUMBER
*/
- public double optdouble(double defval) { argerror("number"); return 0; }
+ public double optdouble(double defval) { argerror("number"); return 0; }
- /** Check that optional argument is a function and return as {@link LuaFunction}
+ /**
+ * Check that optional argument is a function and return as
+ * {@link LuaFunction}
*
* A {@link LuaFunction} may either be a Java function that implements
- * functionality directly in Java, or a {@link LuaClosure}
- * which is a {@link LuaFunction} that executes lua bytecode.
- * @param defval {@link LuaFunction} to return if {@code this} is nil or none
+ * functionality directly in Java, or a {@link LuaClosure} which is a
+ * {@link LuaFunction} that executes lua bytecode.
+ *
+ * @param defval {@link LuaFunction} to return if {@code this} is nil or
+ * none
* @return {@code this} cast to {@link LuaFunction} if a function,
- * {@code defval} if nil or none,
- * throws {@link LuaError} otherwise
+ * {@code defval} if nil or none, throws {@link LuaError} otherwise
* @throws LuaError if was not a function or nil or none.
* @see #checkfunction()
* @see #isfunction()
* @see #TFUNCTION
*/
- public LuaFunction optfunction(LuaFunction defval) { argerror("function"); return null; }
+ public LuaFunction optfunction(LuaFunction defval) { argerror("function"); return null; }
- /** Check that optional argument is a number or string convertible to number and return as int
+ /**
+ * Check that optional argument is a number or string convertible to number
+ * and return as int
+ *
* @param defval int to return if {@code this} is nil or none
- * @return {@code this} cast to int if numeric,
- * {@code defval} if nil or none,
- * throws {@link LuaError} otherwise
+ * @return {@code this} cast to int if numeric, {@code defval} if nil or
+ * none, throws {@link LuaError} otherwise
* @throws LuaError if was not numeric or nil or none.
* @see #optdouble(double)
* @see #optlong(long)
@@ -674,13 +764,16 @@ public class LuaValue extends Varargs {
* @see #isnumber()
* @see #TNUMBER
*/
- public int optint(int defval) { argerror("int"); return 0; }
+ public int optint(int defval) { argerror("int"); return 0; }
- /** Check that optional argument is a number or string convertible to number and return as {@link LuaInteger}
+ /**
+ * Check that optional argument is a number or string convertible to number
+ * and return as {@link LuaInteger}
+ *
* @param defval {@link LuaInteger} to return if {@code this} is nil or none
- * @return {@code this} converted and wrapped in {@link LuaInteger} if numeric,
- * {@code defval} if nil or none,
- * throws {@link LuaError} otherwise
+ * @return {@code this} converted and wrapped in {@link LuaInteger} if
+ * numeric, {@code defval} if nil or none, throws {@link LuaError}
+ * otherwise
* @throws LuaError if was not numeric or nil or none.
* @see #optdouble(double)
* @see #optint(int)
@@ -690,13 +783,15 @@ public class LuaValue extends Varargs {
* @see #isnumber()
* @see #TNUMBER
*/
- public LuaInteger optinteger(LuaInteger defval) { argerror("integer"); return null; }
+ public LuaInteger optinteger(LuaInteger defval) { argerror("integer"); return null; }
- /** Check that optional argument is a number or string convertible to number and return as long
+ /**
+ * Check that optional argument is a number or string convertible to number
+ * and return as long
+ *
* @param defval long to return if {@code this} is nil or none
- * @return {@code this} cast to long if numeric,
- * {@code defval} if nil or none,
- * throws {@link LuaError} otherwise
+ * @return {@code this} cast to long if numeric, {@code defval} if nil or
+ * none, throws {@link LuaError} otherwise
* @throws LuaError if was not numeric or nil or none.
* @see #optdouble(double)
* @see #optint(int)
@@ -706,13 +801,15 @@ public class LuaValue extends Varargs {
* @see #isnumber()
* @see #TNUMBER
*/
- public long optlong(long defval) { argerror("long"); return 0; }
+ public long optlong(long defval) { argerror("long"); return 0; }
- /** Check that optional argument is a number or string convertible to number and return as {@link LuaNumber}
+ /**
+ * Check that optional argument is a number or string convertible to number
+ * and return as {@link LuaNumber}
+ *
* @param defval {@link LuaNumber} to return if {@code this} is nil or none
- * @return {@code this} cast to {@link LuaNumber} if numeric,
- * {@code defval} if nil or none,
- * throws {@link LuaError} otherwise
+ * @return {@code this} cast to {@link LuaNumber} if numeric, {@code defval}
+ * if nil or none, throws {@link LuaError} otherwise
* @throws LuaError if was not numeric or nil or none.
* @see #optdouble(double)
* @see #optlong(long)
@@ -723,13 +820,16 @@ public class LuaValue extends Varargs {
* @see #isnumber()
* @see #TNUMBER
*/
- public LuaNumber optnumber(LuaNumber defval) { argerror("number"); return null; }
+ public LuaNumber optnumber(LuaNumber defval) { argerror("number"); return null; }
- /** Check that optional argument is a string or number and return as Java String
+ /**
+ * Check that optional argument is a string or number and return as Java
+ * String
+ *
* @param defval {@link LuaString} to return if {@code this} is nil or none
* @return {@code this} converted to String if a string or number,
- * {@code defval} if nil or none,
- * throws {@link LuaError} if some other type
+ * {@code defval} if nil or none, throws {@link LuaError} if some
+ * other type
* @throws LuaError if was not a string or number or nil or none.
* @see #tojstring()
* @see #optstring(LuaString)
@@ -737,13 +837,16 @@ public class LuaValue extends Varargs {
* @see #toString()
* @see #TSTRING
*/
- public String optjstring(String defval) { argerror("String"); return null; }
+ public String optjstring(String defval) { argerror("String"); return null; }
- /** Check that optional argument is a string or number and return as {@link LuaString}
+ /**
+ * Check that optional argument is a string or number and return as
+ * {@link LuaString}
+ *
* @param defval {@link LuaString} to return if {@code this} is nil or none
- * @return {@code this} converted to {@link LuaString} if a string or number,
- * {@code defval} if nil or none,
- * throws {@link LuaError} if some other type
+ * @return {@code this} converted to {@link LuaString} if a string or
+ * number, {@code defval} if nil or none, throws {@link LuaError} if
+ * some other type
* @throws LuaError if was not a string or number or nil or none.
* @see #tojstring()
* @see #optjstring(String)
@@ -751,61 +854,70 @@ public class LuaValue extends Varargs {
* @see #toString()
* @see #TSTRING
*/
- public LuaString optstring(LuaString defval) { argerror("string"); return null; }
+ public LuaString optstring(LuaString defval) { argerror("string"); return null; }
- /** Check that optional argument is a table and return as {@link LuaTable}
+ /**
+ * Check that optional argument is a table and return as {@link LuaTable}
+ *
* @param defval {@link LuaTable} to return if {@code this} is nil or none
- * @return {@code this} cast to {@link LuaTable} if a table,
- * {@code defval} if nil or none,
- * throws {@link LuaError} if some other type
+ * @return {@code this} cast to {@link LuaTable} if a table, {@code defval}
+ * if nil or none, throws {@link LuaError} if some other type
* @throws LuaError if was not a table or nil or none.
* @see #checktable()
* @see #istable()
* @see #TTABLE
*/
- public LuaTable opttable(LuaTable defval) { argerror("table"); return null; }
+ public LuaTable opttable(LuaTable defval) { argerror("table"); return null; }
- /** Check that optional argument is a thread and return as {@link LuaThread}
+ /**
+ * Check that optional argument is a thread and return as {@link LuaThread}
+ *
* @param defval {@link LuaThread} to return if {@code this} is nil or none
- * @return {@code this} cast to {@link LuaTable} if a thread,
- * {@code defval} if nil or none,
- * throws {@link LuaError} if some other type
+ * @return {@code this} cast to {@link LuaTable} if a thread, {@code defval}
+ * if nil or none, throws {@link LuaError} if some other type
* @throws LuaError if was not a thread or nil or none.
* @see #checkthread()
* @see #isthread()
* @see #TTHREAD
*/
- public LuaThread optthread(LuaThread defval) { argerror("thread"); return null; }
+ public LuaThread optthread(LuaThread defval) { argerror("thread"); return null; }
- /** Check that optional argument is a userdata and return the Object instance
+ /**
+ * Check that optional argument is a userdata and return the Object instance
+ *
* @param defval Object to return if {@code this} is nil or none
* @return Object instance of the userdata if a {@link LuaUserdata},
- * {@code defval} if nil or none,
- * throws {@link LuaError} if some other type
+ * {@code defval} if nil or none, throws {@link LuaError} if some
+ * other type
* @throws LuaError if was not a userdata or nil or none.
* @see #checkuserdata()
* @see #isuserdata()
* @see #optuserdata(Class, Object)
* @see #TUSERDATA
*/
- public Object optuserdata(Object defval) { argerror("object"); return null; }
+ public Object optuserdata(Object defval) { argerror("object"); return null; }
- /** Check that optional argument is a userdata whose instance is of a type
+ /**
+ * Check that optional argument is a userdata whose instance is of a type
* and return the Object instance
- * @param c Class to test userdata instance against
+ *
+ * @param c Class to test userdata instance against
* @param defval Object to return if {@code this} is nil or none
- * @return Object instance of the userdata if a {@link LuaUserdata} and instance is assignable to {@code c},
- * {@code defval} if nil or none,
- * throws {@link LuaError} if some other type
- * @throws LuaError if was not a userdata whose instance is assignable to {@code c} or nil or none.
+ * @return Object instance of the userdata if a {@link LuaUserdata} and
+ * instance is assignable to {@code c}, {@code defval} if nil or
+ * none, throws {@link LuaError} if some other type
+ * @throws LuaError if was not a userdata whose instance is assignable to
+ * {@code c} or nil or none.
* @see #checkuserdata(Class)
* @see #isuserdata(Class)
* @see #optuserdata(Object)
* @see #TUSERDATA
*/
- public Object optuserdata(Class c, Object defval) { argerror(c.getName()); return null; }
+ public Object optuserdata(Class c, Object defval) { argerror(c.getName()); return null; }
- /** Perform argument check that this is not nil or none.
+ /**
+ * Perform argument check that this is not nil or none.
+ *
* @param defval {@link LuaValue} to return if {@code this} is nil or none
* @return {@code this} if not nil or none, else {@code defval}
* @see #NIL
@@ -815,22 +927,26 @@ public class LuaValue extends Varargs {
* @see #TNIL
* @see #TNONE
*/
- public LuaValue optvalue(LuaValue defval) { return this; }
+ public LuaValue optvalue(LuaValue defval) { return this; }
-
- /** Check that the value is a {@link LuaBoolean},
- * or throw {@link LuaError} if not
+ /**
+ * Check that the value is a {@link LuaBoolean}, or throw {@link LuaError}
+ * if not
+ *
* @return boolean value for {@code this} if it is a {@link LuaBoolean}
* @throws LuaError if not a {@link LuaBoolean}
* @see #optboolean(boolean)
* @see #TBOOLEAN
*/
- public boolean checkboolean() { argerror("boolean"); return false; }
-
- /** Check that the value is a {@link LuaClosure} ,
- * or throw {@link LuaError} if not
+ public boolean checkboolean() { argerror("boolean"); return false; }
+
+ /**
+ * Check that the value is a {@link LuaClosure} , or throw {@link LuaError}
+ * if not
*
- * {@link LuaClosure} is a subclass of {@link LuaFunction} that interprets lua bytecode.
+ * {@link LuaClosure} is a subclass of {@link LuaFunction} that interprets
+ * lua bytecode.
+ *
* @return {@code this} cast as {@link LuaClosure}
* @throws LuaError if not a {@link LuaClosure}
* @see #checkfunction()
@@ -838,93 +954,118 @@ public class LuaValue extends Varargs {
* @see #isclosure()
* @see #TFUNCTION
*/
- public LuaClosure checkclosure() { argerror("closure"); return null; }
-
- /** Check that the value is numeric and return the value as a double,
- * or throw {@link LuaError} if not numeric
+ public LuaClosure checkclosure() { argerror("closure"); return null; }
+
+ /**
+ * Check that the value is numeric and return the value as a double, or
+ * throw {@link LuaError} if not numeric
*
* Values that are {@link LuaNumber} and values that are {@link LuaString}
* that can be converted to a number will be converted to double.
+ *
* @return value cast to a double if numeric
- * @throws LuaError if not a {@link LuaNumber} or is a {@link LuaString} that can't be converted to number
+ * @throws LuaError if not a {@link LuaNumber} or is a {@link LuaString}
+ * that can't be converted to number
* @see #checkint()
* @see #checkinteger()
* @see #checklong()
* @see #optdouble(double)
* @see #TNUMBER
*/
- public double checkdouble() { argerror("number"); return 0; }
-
- /** Check that the value is a function , or throw {@link LuaError} if not
+ public double checkdouble() { argerror("number"); return 0; }
+
+ /**
+ * Check that the value is a function , or throw {@link LuaError} if not
*
* A {@link LuaFunction} may either be a Java function that implements
- * functionality directly in Java, or a {@link LuaClosure}
- * which is a {@link LuaFunction} that executes lua bytecode.
+ * functionality directly in Java, or a {@link LuaClosure} which is a
+ * {@link LuaFunction} that executes lua bytecode.
+ *
* @return {@code this} if it is a lua function or closure
* @throws LuaError if not a function
* @see #checkclosure()
*/
- public LuaFunction checkfunction() { argerror("function"); return null; }
+ public LuaFunction checkfunction() { argerror("function"); return null; }
-
- /** Check that the value is a Globals instance, or throw {@link LuaError} if not
+ /**
+ * Check that the value is a Globals instance, or throw {@link LuaError} if
+ * not
*
- * {@link Globals} are a special {@link LuaTable} that establish the default global environment.
+ * {@link Globals} are a special {@link LuaTable} that establish the default
+ * global environment.
+ *
* @return {@code this} if if an instance fof {@link Globals}
* @throws LuaError if not a {@link Globals} instance.
*/
- public Globals checkglobals() { argerror("globals"); return null; }
+ public Globals checkglobals() { argerror("globals"); return null; }
- /** Check that the value is numeric, and convert and cast value to int, or throw {@link LuaError} if not numeric
+ /**
+ * Check that the value is numeric, and convert and cast value to int, or
+ * throw {@link LuaError} if not numeric
*
- * Values that are {@link LuaNumber} will be cast to int and may lose precision.
- * Values that are {@link LuaString} that can be converted to a number will be converted,
- * then cast to int, so may also lose precision.
+ * Values that are {@link LuaNumber} will be cast to int and may lose
+ * precision. Values that are {@link LuaString} that can be converted to a
+ * number will be converted, then cast to int, so may also lose precision.
+ *
* @return value cast to a int if numeric
- * @throws LuaError if not a {@link LuaNumber} or is a {@link LuaString} that can't be converted to number
+ * @throws LuaError if not a {@link LuaNumber} or is a {@link LuaString}
+ * that can't be converted to number
* @see #checkinteger()
* @see #checklong()
* @see #checkdouble()
* @see #optint(int)
* @see #TNUMBER
*/
- public int checkint() { argerror("int"); return 0; }
+ public int checkint() { argerror("int"); return 0; }
- /** Check that the value is numeric, and convert and cast value to int, or throw {@link LuaError} if not numeric
+ /**
+ * Check that the value is numeric, and convert and cast value to int, or
+ * throw {@link LuaError} if not numeric
*
- * Values that are {@link LuaNumber} will be cast to int and may lose precision.
- * Values that are {@link LuaString} that can be converted to a number will be converted,
- * then cast to int, so may also lose precision.
+ * Values that are {@link LuaNumber} will be cast to int and may lose
+ * precision. Values that are {@link LuaString} that can be converted to a
+ * number will be converted, then cast to int, so may also lose precision.
+ *
* @return value cast to a int and wrapped in {@link LuaInteger} if numeric
- * @throws LuaError if not a {@link LuaNumber} or is a {@link LuaString} that can't be converted to number
+ * @throws LuaError if not a {@link LuaNumber} or is a {@link LuaString}
+ * that can't be converted to number
* @see #checkint()
* @see #checklong()
* @see #checkdouble()
* @see #optinteger(LuaInteger)
* @see #TNUMBER
*/
- public LuaInteger checkinteger() { argerror("integer"); return null; }
-
- /** Check that the value is numeric, and convert and cast value to long, or throw {@link LuaError} if not numeric
+ public LuaInteger checkinteger() { argerror("integer"); return null; }
+
+ /**
+ * Check that the value is numeric, and convert and cast value to long, or
+ * throw {@link LuaError} if not numeric
*
- * Values that are {@link LuaNumber} will be cast to long and may lose precision.
- * Values that are {@link LuaString} that can be converted to a number will be converted,
- * then cast to long, so may also lose precision.
+ * Values that are {@link LuaNumber} will be cast to long and may lose
+ * precision. Values that are {@link LuaString} that can be converted to a
+ * number will be converted, then cast to long, so may also lose precision.
+ *
* @return value cast to a long if numeric
- * @throws LuaError if not a {@link LuaNumber} or is a {@link LuaString} that can't be converted to number
+ * @throws LuaError if not a {@link LuaNumber} or is a {@link LuaString}
+ * that can't be converted to number
* @see #checkint()
* @see #checkinteger()
* @see #checkdouble()
* @see #optlong(long)
* @see #TNUMBER
*/
- public long checklong() { argerror("long"); return 0; }
-
- /** Check that the value is numeric, and return as a LuaNumber if so, or throw {@link LuaError}
+ public long checklong() { argerror("long"); return 0; }
+
+ /**
+ * Check that the value is numeric, and return as a LuaNumber if so, or
+ * throw {@link LuaError}
*
- * Values that are {@link LuaString} that can be converted to a number will be converted and returned.
+ * Values that are {@link LuaString} that can be converted to a number will
+ * be converted and returned.
+ *
* @return value as a {@link LuaNumber} if numeric
- * @throws LuaError if not a {@link LuaNumber} or is a {@link LuaString} that can't be converted to number
+ * @throws LuaError if not a {@link LuaNumber} or is a {@link LuaString}
+ * that can't be converted to number
* @see #checkint()
* @see #checkinteger()
* @see #checkdouble()
@@ -932,14 +1073,19 @@ public class LuaValue extends Varargs {
* @see #optnumber(LuaNumber)
* @see #TNUMBER
*/
- public LuaNumber checknumber() { argerror("number"); return null; }
-
- /** Check that the value is numeric, and return as a LuaNumber if so, or throw {@link LuaError}
+ public LuaNumber checknumber() { argerror("number"); return null; }
+
+ /**
+ * Check that the value is numeric, and return as a LuaNumber if so, or
+ * throw {@link LuaError}
*
- * Values that are {@link LuaString} that can be converted to a number will be converted and returned.
+ * Values that are {@link LuaString} that can be converted to a number will
+ * be converted and returned.
+ *
* @param msg String message to supply if conversion fails
* @return value as a {@link LuaNumber} if numeric
- * @throws LuaError if not a {@link LuaNumber} or is a {@link LuaString} that can't be converted to number
+ * @throws LuaError if not a {@link LuaNumber} or is a {@link LuaString}
+ * that can't be converted to number
* @see #checkint()
* @see #checkinteger()
* @see #checkdouble()
@@ -947,13 +1093,15 @@ public class LuaValue extends Varargs {
* @see #optnumber(LuaNumber)
* @see #TNUMBER
*/
- public LuaNumber checknumber(String msg) { throw new LuaError(msg); }
-
- /** Convert this value to a Java String.
+ public LuaNumber checknumber(String msg) { throw new LuaError(msg); }
+
+ /**
+ * Convert this value to a Java String.
*
- * The string representations here will roughly match what is produced by the
- * C lua distribution, however hash codes have no relationship,
- * and there may be differences in number formatting.
+ * The string representations here will roughly match what is produced by
+ * the C lua distribution, however hash codes have no relationship, and
+ * there may be differences in number formatting.
+ *
* @return String representation of the value
* @see #checkstring()
* @see #optjstring(String)
@@ -961,15 +1109,17 @@ public class LuaValue extends Varargs {
* @see #isstring
* @see #TSTRING
*/
- public String checkjstring() { argerror("string"); return null; }
-
- /** Check that this is a lua string, or throw {@link LuaError} if it is not.
+ public String checkjstring() { argerror("string"); return null; }
+
+ /**
+ * Check that this is a lua string, or throw {@link LuaError} if it is not.
*
- * In lua all numbers are strings, so this will succeed for
- * anything that derives from {@link LuaString} or {@link LuaNumber}.
- * Numbers will be converted to {@link LuaString}.
+ * In lua all numbers are strings, so this will succeed for anything that
+ * derives from {@link LuaString} or {@link LuaNumber}. Numbers will be
+ * converted to {@link LuaString}.
*
- * @return {@link LuaString} representation of the value if it is a {@link LuaString} or {@link LuaNumber}
+ * @return {@link LuaString} representation of the value if it is a
+ * {@link LuaString} or {@link LuaNumber}
* @throws LuaError if {@code this} is not a {@link LuaTable}
* @see #checkjstring()
* @see #optstring(LuaString)
@@ -977,27 +1127,36 @@ public class LuaValue extends Varargs {
* @see #isstring()
* @see #TSTRING
*/
- public LuaString checkstring() { argerror("string"); return null; }
-
- /** Check that this is a {@link LuaTable}, or throw {@link LuaError} if it is not
+ public LuaString checkstring() { argerror("string"); return null; }
+
+ /**
+ * Check that this is a {@link LuaTable}, or throw {@link LuaError} if it is
+ * not
+ *
* @return {@code this} if it is a {@link LuaTable}
* @throws LuaError if {@code this} is not a {@link LuaTable}
* @see #istable()
* @see #opttable(LuaTable)
* @see #TTABLE
*/
- public LuaTable checktable() { argerror("table"); return null; }
-
- /** Check that this is a {@link LuaThread}, or throw {@link LuaError} if it is not
+ public LuaTable checktable() { argerror("table"); return null; }
+
+ /**
+ * Check that this is a {@link LuaThread}, or throw {@link LuaError} if it
+ * is not
+ *
* @return {@code this} if it is a {@link LuaThread}
* @throws LuaError if {@code this} is not a {@link LuaThread}
* @see #isthread()
* @see #optthread(LuaThread)
* @see #TTHREAD
*/
- public LuaThread checkthread() { argerror("thread"); return null; }
-
- /** Check that this is a {@link LuaUserdata}, or throw {@link LuaError} if it is not
+ public LuaThread checkthread() { argerror("thread"); return null; }
+
+ /**
+ * Check that this is a {@link LuaUserdata}, or throw {@link LuaError} if it
+ * is not
+ *
* @return {@code this} if it is a {@link LuaUserdata}
* @throws LuaError if {@code this} is not a {@link LuaUserdata}
* @see #isuserdata()
@@ -1005,9 +1164,12 @@ public class LuaValue extends Varargs {
* @see #checkuserdata(Class)
* @see #TUSERDATA
*/
- public Object checkuserdata() { argerror("userdata"); return null; }
-
- /** Check that this is a {@link LuaUserdata}, or throw {@link LuaError} if it is not
+ public Object checkuserdata() { argerror("userdata"); return null; }
+
+ /**
+ * Check that this is a {@link LuaUserdata}, or throw {@link LuaError} if it
+ * is not
+ *
* @return {@code this} if it is a {@link LuaUserdata}
* @throws LuaError if {@code this} is not a {@link LuaUserdata}
* @see #isuserdata(Class)
@@ -1015,293 +1177,388 @@ public class LuaValue extends Varargs {
* @see #checkuserdata()
* @see #TUSERDATA
*/
- public Object checkuserdata(Class c) { argerror("userdata"); return null; }
-
- /** Check that this is not the value {@link #NIL}, or throw {@link LuaError} if it is
+ public Object checkuserdata(Class c) { argerror("userdata"); return null; }
+
+ /**
+ * Check that this is not the value {@link #NIL}, or throw {@link LuaError}
+ * if it is
+ *
* @return {@code this} if it is not {@link #NIL}
* @throws LuaError if {@code this} is {@link #NIL}
* @see #optvalue(LuaValue)
*/
- public LuaValue checknotnil() { return this; }
-
- /** Return true if this is a valid key in a table index operation.
+ public LuaValue checknotnil() { return this; }
+
+ /**
+ * Return true if this is a valid key in a table index operation.
+ *
* @return true if valid as a table key, otherwise false
* @see #isnil()
* @see #isinttype()
*/
- public boolean isvalidkey() { return true; }
-
+ public boolean isvalidkey() { return true; }
+
/**
* Throw a {@link LuaError} with a particular message
+ *
* @param message String providing message details
* @throws LuaError in all cases
*/
public static LuaValue error(String message) { throw new LuaError(message); }
/**
- * Assert a condition is true, or throw a {@link LuaError} if not
- * Returns no value when b is true, throws {@link #error(String)} with {@code msg} as argument
- * and does not return if b is false.
- * @param b condition to test
+ * Assert a condition is true, or throw a {@link LuaError} if not Returns no
+ * value when b is true, throws {@link #error(String)} with {@code msg} as
+ * argument and does not return if b is false.
+ *
+ * @param b condition to test
* @param msg String message to produce on failure
* @throws LuaError if b is not true
*/
- public static void assert_(boolean b,String msg) { if(!b) throw new LuaError(msg); }
-
+ public static void assert_(boolean b, String msg) {
+ if (!b)
+ throw new LuaError(msg);
+ }
+
/**
- * Throw a {@link LuaError} indicating an invalid argument was supplied to a function
+ * Throw a {@link LuaError} indicating an invalid argument was supplied to a
+ * function
+ *
* @param expected String naming the type that was expected
* @throws LuaError in all cases
*/
- protected LuaValue argerror(String expected) { throw new LuaError("bad argument: "+expected+" expected, got "+typename()); }
-
+ protected LuaValue argerror(String expected) {
+ throw new LuaError("bad argument: " + expected + " expected, got " + typename());
+ }
+
/**
- * Throw a {@link LuaError} indicating an invalid argument was supplied to a function
+ * Throw a {@link LuaError} indicating an invalid argument was supplied to a
+ * function
+ *
* @param iarg index of the argument that was invalid, first index is 1
- * @param msg String providing information about the invalid argument
+ * @param msg String providing information about the invalid argument
* @throws LuaError in all cases
*/
- public static LuaValue argerror(int iarg,String msg) { throw new LuaError("bad argument #"+iarg+": "+msg); }
-
+ public static LuaValue argerror(int iarg, String msg) {
+ throw new LuaError("bad argument #" + iarg + ": " + msg);
+ }
+
/**
- * Throw a {@link LuaError} indicating an invalid type was supplied to a function
+ * Throw a {@link LuaError} indicating an invalid type was supplied to a
+ * function
+ *
* @param expected String naming the type that was expected
* @throws LuaError in all cases
*/
- protected LuaValue typerror(String expected) { throw new LuaError(expected+" expected, got "+typename()); }
-
+ protected LuaValue typerror(String expected) { throw new LuaError(expected + " expected, got " + typename()); }
+
/**
* Throw a {@link LuaError} indicating an operation is not implemented
+ *
* @throws LuaError in all cases
*/
- protected LuaValue unimplemented(String fun) { throw new LuaError("'"+fun+"' not implemented for "+typename()); }
-
+ protected LuaValue unimplemented(String fun) {
+ throw new LuaError("'" + fun + "' not implemented for " + typename());
+ }
+
/**
* Throw a {@link LuaError} indicating an illegal operation occurred,
* typically involved in managing weak references
+ *
* @throws LuaError in all cases
*/
- protected LuaValue illegal(String op,String typename) { throw new LuaError("illegal operation '"+op+"' for "+typename); }
-
+ protected LuaValue illegal(String op, String typename) {
+ throw new LuaError("illegal operation '" + op + "' for " + typename);
+ }
+
/**
- * Throw a {@link LuaError} based on the len operator,
- * typically due to an invalid operand type
+ * Throw a {@link LuaError} based on the len operator, typically due to an
+ * invalid operand type
+ *
* @throws LuaError in all cases
*/
- protected LuaValue lenerror() { throw new LuaError("attempt to get length of "+typename()); }
-
+ protected LuaValue lenerror() { throw new LuaError("attempt to get length of " + typename()); }
+
/**
- * Throw a {@link LuaError} based on an arithmetic error such as add, or pow,
- * typically due to an invalid operand type
+ * Throw a {@link LuaError} based on an arithmetic error such as add, or
+ * pow, typically due to an invalid operand type
+ *
* @throws LuaError in all cases
*/
- protected LuaValue aritherror() { throw new LuaError("attempt to perform arithmetic on "+typename()); }
-
+ protected LuaValue aritherror() { throw new LuaError("attempt to perform arithmetic on " + typename()); }
+
/**
- * Throw a {@link LuaError} based on an arithmetic error such as add, or pow,
- * typically due to an invalid operand type
+ * Throw a {@link LuaError} based on an arithmetic error such as add, or
+ * pow, typically due to an invalid operand type
+ *
* @param fun String description of the function that was attempted
* @throws LuaError in all cases
*/
- protected LuaValue aritherror(String fun) { throw new LuaError("attempt to perform arithmetic '"+fun+"' on "+typename()); }
-
+ protected LuaValue aritherror(String fun) {
+ throw new LuaError("attempt to perform arithmetic '" + fun + "' on " + typename());
+ }
+
/**
- * Throw a {@link LuaError} based on a comparison error such as greater-than or less-than,
- * typically due to an invalid operand type
- * @param rhs String description of what was on the right-hand-side of the comparison that resulted in the error.
+ * Throw a {@link LuaError} based on a comparison error such as greater-than
+ * or less-than, typically due to an invalid operand type
+ *
+ * @param rhs String description of what was on the right-hand-side of the
+ * comparison that resulted in the error.
* @throws LuaError in all cases
*/
- protected LuaValue compareerror(String rhs) { throw new LuaError("attempt to compare "+typename()+" with "+rhs); }
-
+ protected LuaValue compareerror(String rhs) {
+ throw new LuaError("attempt to compare " + typename() + " with " + rhs);
+ }
+
/**
- * Throw a {@link LuaError} based on a comparison error such as greater-than or less-than,
- * typically due to an invalid operand type
+ * Throw a {@link LuaError} based on a comparison error such as greater-than
+ * or less-than, typically due to an invalid operand type
+ *
* @param rhs Right-hand-side of the comparison that resulted in the error.
* @throws LuaError in all cases
*/
- protected LuaValue compareerror(LuaValue rhs) { throw new LuaError("attempt to compare "+typename()+" with "+rhs.typename()); }
-
- /** Get a value in a table including metatag processing using {@link #INDEX}.
+ protected LuaValue compareerror(LuaValue rhs) {
+ throw new LuaError("attempt to compare " + typename() + " with " + rhs.typename());
+ }
+
+ /**
+ * Get a value in a table including metatag processing using {@link #INDEX}.
+ *
* @param key the key to look up, must not be {@link #NIL} or null
- * @return {@link LuaValue} for that key, or {@link #NIL} if not found and no metatag
- * @throws LuaError if {@code this} is not a table,
- * or there is no {@link #INDEX} metatag,
- * or key is {@link #NIL}
+ * @return {@link LuaValue} for that key, or {@link #NIL} if not found and
+ * no metatag
+ * @throws LuaError if {@code this} is not a table, or there is no
+ * {@link #INDEX} metatag, or key is {@link #NIL}
* @see #get(int)
* @see #get(String)
* @see #rawget(LuaValue)
*/
- public LuaValue get( LuaValue key ) { return gettable(this,key); }
-
- /** Get a value in a table including metatag processing using {@link #INDEX}.
+ public LuaValue get(LuaValue key) { return gettable(this, key); }
+
+ /**
+ * Get a value in a table including metatag processing using {@link #INDEX}.
+ *
* @param key the key to look up
* @return {@link LuaValue} for that key, or {@link #NIL} if not found
- * @throws LuaError if {@code this} is not a table,
- * or there is no {@link #INDEX} metatag
+ * @throws LuaError if {@code this} is not a table, or there is no
+ * {@link #INDEX} metatag
* @see #get(LuaValue)
* @see #rawget(int)
*/
- public LuaValue get( int key ) { return get(LuaInteger.valueOf(key)); }
+ public LuaValue get(int key) { return get(LuaInteger.valueOf(key)); }
- /** Get a value in a table including metatag processing using {@link #INDEX}.
+ /**
+ * Get a value in a table including metatag processing using {@link #INDEX}.
+ *
* @param key the key to look up, must not be null
* @return {@link LuaValue} for that key, or {@link #NIL} if not found
- * @throws LuaError if {@code this} is not a table,
- * or there is no {@link #INDEX} metatag
+ * @throws LuaError if {@code this} is not a table, or there is no
+ * {@link #INDEX} metatag
* @see #get(LuaValue)
* @see #rawget(String)
*/
- public LuaValue get( String key ) { return get(valueOf(key)); }
-
- /** Set a value in a table without metatag processing using {@link #NEWINDEX}.
- * @param key the key to use, must not be {@link #NIL} or null
- * @param value the value to use, can be {@link #NIL}, must not be null
- * @throws LuaError if {@code this} is not a table,
- * or key is {@link #NIL},
- * or there is no {@link #NEWINDEX} metatag
- */
- public void set( LuaValue key, LuaValue value ) { settable(this, key, value); }
-
- /** Set a value in a table without metatag processing using {@link #NEWINDEX}.
- * @param key the key to use
- * @param value the value to use, can be {@link #NIL}, must not be null
- * @throws LuaError if {@code this} is not a table,
- * or there is no {@link #NEWINDEX} metatag
- */
- public void set( int key, LuaValue value ) { set(LuaInteger.valueOf(key), value ); }
-
- /** Set a value in a table without metatag processing using {@link #NEWINDEX}.
- * @param key the key to use
- * @param value the value to use, must not be null
- * @throws LuaError if {@code this} is not a table,
- * or there is no {@link #NEWINDEX} metatag
- */
- public void set( int key, String value ) { set(key, valueOf(value) ); }
-
- /** Set a value in a table without metatag processing using {@link #NEWINDEX}.
- * @param key the key to use, must not be {@link #NIL} or null
- * @param value the value to use, can be {@link #NIL}, must not be null
- * @throws LuaError if {@code this} is not a table,
- * or there is no {@link #NEWINDEX} metatag
- */
- public void set( String key, LuaValue value ) { set(valueOf(key), value ); }
-
- /** Set a value in a table without metatag processing using {@link #NEWINDEX}.
- * @param key the key to use, must not be null
- * @param value the value to use
- * @throws LuaError if {@code this} is not a table,
- * or there is no {@link #NEWINDEX} metatag
- */
- public void set( String key, double value ) { set(valueOf(key), valueOf(value) ); }
-
- /** Set a value in a table without metatag processing using {@link #NEWINDEX}.
- * @param key the key to use, must not be null
- * @param value the value to use
- * @throws LuaError if {@code this} is not a table,
- * or there is no {@link #NEWINDEX} metatag
- */
- public void set( String key, int value ) { set(valueOf(key), valueOf(value) ); }
-
- /** Set a value in a table without metatag processing using {@link #NEWINDEX}.
- * @param key the key to use, must not be null
- * @param value the value to use, must not be null
- * @throws LuaError if {@code this} is not a table,
- * or there is no {@link #NEWINDEX} metatag
- */
- public void set( String key, String value ) { set(valueOf(key), valueOf(value) ); }
+ public LuaValue get(String key) { return get(valueOf(key)); }
- /** Get a value in a table without metatag processing.
+ /**
+ * Set a value in a table without metatag processing using
+ * {@link #NEWINDEX}.
+ *
+ * @param key the key to use, must not be {@link #NIL} or null
+ * @param value the value to use, can be {@link #NIL}, must not be null
+ * @throws LuaError if {@code this} is not a table, or key is {@link #NIL},
+ * or there is no {@link #NEWINDEX} metatag
+ */
+ public void set(LuaValue key, LuaValue value) { settable(this, key, value); }
+
+ /**
+ * Set a value in a table without metatag processing using
+ * {@link #NEWINDEX}.
+ *
+ * @param key the key to use
+ * @param value the value to use, can be {@link #NIL}, must not be null
+ * @throws LuaError if {@code this} is not a table, or there is no
+ * {@link #NEWINDEX} metatag
+ */
+ public void set(int key, LuaValue value) { set(LuaInteger.valueOf(key), value); }
+
+ /**
+ * Set a value in a table without metatag processing using
+ * {@link #NEWINDEX}.
+ *
+ * @param key the key to use
+ * @param value the value to use, must not be null
+ * @throws LuaError if {@code this} is not a table, or there is no
+ * {@link #NEWINDEX} metatag
+ */
+ public void set(int key, String value) { set(key, valueOf(value)); }
+
+ /**
+ * Set a value in a table without metatag processing using
+ * {@link #NEWINDEX}.
+ *
+ * @param key the key to use, must not be {@link #NIL} or null
+ * @param value the value to use, can be {@link #NIL}, must not be null
+ * @throws LuaError if {@code this} is not a table, or there is no
+ * {@link #NEWINDEX} metatag
+ */
+ public void set(String key, LuaValue value) { set(valueOf(key), value); }
+
+ /**
+ * Set a value in a table without metatag processing using
+ * {@link #NEWINDEX}.
+ *
+ * @param key the key to use, must not be null
+ * @param value the value to use
+ * @throws LuaError if {@code this} is not a table, or there is no
+ * {@link #NEWINDEX} metatag
+ */
+ public void set(String key, double value) { set(valueOf(key), valueOf(value)); }
+
+ /**
+ * Set a value in a table without metatag processing using
+ * {@link #NEWINDEX}.
+ *
+ * @param key the key to use, must not be null
+ * @param value the value to use
+ * @throws LuaError if {@code this} is not a table, or there is no
+ * {@link #NEWINDEX} metatag
+ */
+ public void set(String key, int value) { set(valueOf(key), valueOf(value)); }
+
+ /**
+ * Set a value in a table without metatag processing using
+ * {@link #NEWINDEX}.
+ *
+ * @param key the key to use, must not be null
+ * @param value the value to use, must not be null
+ * @throws LuaError if {@code this} is not a table, or there is no
+ * {@link #NEWINDEX} metatag
+ */
+ public void set(String key, String value) { set(valueOf(key), valueOf(value)); }
+
+ /**
+ * Get a value in a table without metatag processing.
+ *
* @param key the key to look up, must not be {@link #NIL} or null
* @return {@link LuaValue} for that key, or {@link #NIL} if not found
* @throws LuaError if {@code this} is not a table, or key is {@link #NIL}
*/
- public LuaValue rawget( LuaValue key ) { return unimplemented("rawget"); }
+ public LuaValue rawget(LuaValue key) { return unimplemented("rawget"); }
- /** Get a value in a table without metatag processing.
+ /**
+ * Get a value in a table without metatag processing.
+ *
* @param key the key to look up
* @return {@link LuaValue} for that key, or {@link #NIL} if not found
* @throws LuaError if {@code this} is not a table
*/
- public LuaValue rawget( int key ) { return rawget(valueOf(key)); }
+ public LuaValue rawget(int key) { return rawget(valueOf(key)); }
- /** Get a value in a table without metatag processing.
+ /**
+ * Get a value in a table without metatag processing.
+ *
* @param key the key to look up, must not be null
* @return {@link LuaValue} for that key, or {@link #NIL} if not found
* @throws LuaError if {@code this} is not a table
*/
- public LuaValue rawget( String key ) { return rawget(valueOf(key)); }
-
- /** Set a value in a table without metatag processing.
- * @param key the key to use, must not be {@link #NIL} or null
+ public LuaValue rawget(String key) { return rawget(valueOf(key)); }
+
+ /**
+ * Set a value in a table without metatag processing.
+ *
+ * @param key the key to use, must not be {@link #NIL} or null
* @param value the value to use, can be {@link #NIL}, must not be null
* @throws LuaError if {@code this} is not a table, or key is {@link #NIL}
*/
- public void rawset( LuaValue key, LuaValue value ) { unimplemented("rawset"); }
-
- /** Set a value in a table without metatag processing.
- * @param key the key to use
+ public void rawset(LuaValue key, LuaValue value) { unimplemented("rawset"); }
+
+ /**
+ * Set a value in a table without metatag processing.
+ *
+ * @param key the key to use
* @param value the value to use, can be {@link #NIL}, must not be null
* @throws LuaError if {@code this} is not a table
*/
- public void rawset( int key, LuaValue value ) { rawset(valueOf(key),value); }
-
- /** Set a value in a table without metatag processing.
- * @param key the key to use
+ public void rawset(int key, LuaValue value) { rawset(valueOf(key), value); }
+
+ /**
+ * Set a value in a table without metatag processing.
+ *
+ * @param key the key to use
* @param value the value to use, can be {@link #NIL}, must not be null
* @throws LuaError if {@code this} is not a table
*/
- public void rawset( int key, String value ) { rawset(key,valueOf(value)); }
-
- /** Set a value in a table without metatag processing.
- * @param key the key to use, must not be null
+ public void rawset(int key, String value) { rawset(key, valueOf(value)); }
+
+ /**
+ * Set a value in a table without metatag processing.
+ *
+ * @param key the key to use, must not be null
* @param value the value to use, can be {@link #NIL}, must not be null
* @throws LuaError if {@code this} is not a table
*/
- public void rawset( String key, LuaValue value ) { rawset(valueOf(key),value); }
-
- /** Set a value in a table without metatag processing.
- * @param key the key to use, must not be null
+ public void rawset(String key, LuaValue value) { rawset(valueOf(key), value); }
+
+ /**
+ * Set a value in a table without metatag processing.
+ *
+ * @param key the key to use, must not be null
* @param value the value to use
* @throws LuaError if {@code this} is not a table
*/
- public void rawset( String key, double value ) { rawset(valueOf(key),valueOf(value)); }
-
- /** Set a value in a table without metatag processing.
- * @param key the key to use, must not be null
+ public void rawset(String key, double value) { rawset(valueOf(key), valueOf(value)); }
+
+ /**
+ * Set a value in a table without metatag processing.
+ *
+ * @param key the key to use, must not be null
* @param value the value to use
* @throws LuaError if {@code this} is not a table
*/
- public void rawset( String key, int value ) { rawset(valueOf(key),valueOf(value)); }
-
- /** Set a value in a table without metatag processing.
- * @param key the key to use, must not be null
+ public void rawset(String key, int value) { rawset(valueOf(key), valueOf(value)); }
+
+ /**
+ * Set a value in a table without metatag processing.
+ *
+ * @param key the key to use, must not be null
* @param value the value to use, must not be null
* @throws LuaError if {@code this} is not a table
*/
- public void rawset( String key, String value ) { rawset(valueOf(key),valueOf(value)); }
+ public void rawset(String key, String value) { rawset(valueOf(key), valueOf(value)); }
- /** Set list values in a table without invoking metatag processing
+ /**
+ * Set list values in a table without invoking metatag processing
*
* Primarily used internally in response to a SETLIST bytecode.
- * @param key0 the first key to set in the table
+ *
+ * @param key0 the first key to set in the table
* @param values the list of values to set
* @throws LuaError if this is not a table.
*/
- public void rawsetlist( int key0, Varargs values ) { for ( int i=0, n=values.narg(); i
* To iterate over all key-value pairs in a table you can use
- *
* To iterate over integer keys in a table you can use
- *
- * For {@link LuaTable} and {@link LuaUserdata} instances,
- * the metatable returned is this instance metatable.
- * For all other types, the class metatable value will be returned.
+ * For {@link LuaTable} and {@link LuaUserdata} instances, the metatable
+ * returned is this instance metatable. For all other types, the class
+ * metatable value will be returned.
+ *
* @return metatable, or null if it there is none
* @see LuaBoolean#s_metatable
* @see LuaNumber#s_metatable
@@ -1380,13 +1652,16 @@ public class LuaValue extends Varargs {
* @see LuaThread#s_metatable
*/
public LuaValue getmetatable() { return null; }
-
+
/**
* Set the metatable for this {@link LuaValue}
*
- * For {@link LuaTable} and {@link LuaUserdata} instances, the metatable is per instance.
- * For all other types, there is one metatable per type that can be set directly from java
- * @param metatable {@link LuaValue} instance to serve as the metatable, or null to reset it.
+ * For {@link LuaTable} and {@link LuaUserdata} instances, the metatable is
+ * per instance. For all other types, there is one metatable per type that
+ * can be set directly from java
+ *
+ * @param metatable {@link LuaValue} instance to serve as the metatable, or
+ * null to reset it.
* @return {@code this} to allow chaining of Java function calls
* @see LuaBoolean#s_metatable
* @see LuaNumber#s_metatable
@@ -1395,23 +1670,26 @@ public class LuaValue extends Varargs {
* @see LuaThread#s_metatable
*/
public LuaValue setmetatable(LuaValue metatable) { return argerror("table"); }
-
- /** Call {@code this} with 0 arguments, including metatag processing,
- * and return only the first return value.
+
+ /**
+ * Call {@code this} with 0 arguments, including metatag processing, and
+ * return only the first return value.
*
- * If {@code this} is a {@link LuaFunction}, call it,
- * and return only its first return value, dropping any others.
- * Otherwise, look for the {@link #CALL} metatag and call that.
+ * If {@code this} is a {@link LuaFunction}, call it, and return only its
+ * first return value, dropping any others. Otherwise, look for the
+ * {@link #CALL} metatag and call that.
*
- * If the return value is a {@link Varargs}, only the 1st value will be returned.
- * To get multiple values, use {@link #invoke()} instead.
+ * If the return value is a {@link Varargs}, only the 1st value will be
+ * returned. To get multiple values, use {@link #invoke()} instead.
*
- * To call {@code this} as a method call, use {@link #method(LuaValue)} instead.
+ * To call {@code this} as a method call, use {@link #method(LuaValue)}
+ * instead.
*
- * @return First return value {@code (this())}, or {@link #NIL} if there were none.
- * @throws LuaError if not a function and {@link #CALL} is not defined,
- * or the invoked function throws a {@link LuaError}
- * or the invoked closure throw a lua {@code error}
+ * @return First return value {@code (this())}, or {@link #NIL} if there
+ * were none.
+ * @throws LuaError if not a function and {@link #CALL} is not defined, or
+ * the invoked function throws a {@link LuaError} or the
+ * invoked closure throw a lua {@code error}
* @see #call(LuaValue)
* @see #call(LuaValue,LuaValue)
* @see #call(LuaValue, LuaValue, LuaValue)
@@ -1421,23 +1699,26 @@ public class LuaValue extends Varargs {
*/
public LuaValue call() { return callmt().call(this); }
- /** Call {@code this} with 1 argument, including metatag processing,
- * and return only the first return value.
+ /**
+ * Call {@code this} with 1 argument, including metatag processing, and
+ * return only the first return value.
*
- * If {@code this} is a {@link LuaFunction}, call it,
- * and return only its first return value, dropping any others.
- * Otherwise, look for the {@link #CALL} metatag and call that.
+ * If {@code this} is a {@link LuaFunction}, call it, and return only its
+ * first return value, dropping any others. Otherwise, look for the
+ * {@link #CALL} metatag and call that.
*
- * If the return value is a {@link Varargs}, only the 1st value will be returned.
- * To get multiple values, use {@link #invoke()} instead.
+ * If the return value is a {@link Varargs}, only the 1st value will be
+ * returned. To get multiple values, use {@link #invoke()} instead.
*
- * To call {@code this} as a method call, use {@link #method(LuaValue)} instead.
+ * To call {@code this} as a method call, use {@link #method(LuaValue)}
+ * instead.
*
* @param arg First argument to supply to the called function
- * @return First return value {@code (this(arg))}, or {@link #NIL} if there were none.
- * @throws LuaError if not a function and {@link #CALL} is not defined,
- * or the invoked function throws a {@link LuaError}
- * or the invoked closure throw a lua {@code error}
+ * @return First return value {@code (this(arg))}, or {@link #NIL} if there
+ * were none.
+ * @throws LuaError if not a function and {@link #CALL} is not defined, or
+ * the invoked function throws a {@link LuaError} or the
+ * invoked closure throw a lua {@code error}
* @see #call()
* @see #call(LuaValue,LuaValue)
* @see #call(LuaValue, LuaValue, LuaValue)
@@ -1445,33 +1726,40 @@ public class LuaValue extends Varargs {
* @see #method(String,LuaValue)
* @see #method(LuaValue,LuaValue)
*/
- public LuaValue call(LuaValue arg) { return callmt().call(this,arg); }
+ public LuaValue call(LuaValue arg) { return callmt().call(this, arg); }
- /** Convenience function which calls a luavalue with a single, string argument.
- * @param arg String argument to the function. This will be converted to a LuaString.
+ /**
+ * Convenience function which calls a luavalue with a single, string
+ * argument.
+ *
+ * @param arg String argument to the function. This will be converted to a
+ * LuaString.
* @return return value of the invocation.
* @see #call(LuaValue)
*/
public LuaValue call(String arg) { return call(valueOf(arg)); }
-
- /** Call {@code this} with 2 arguments, including metatag processing,
- * and return only the first return value.
+
+ /**
+ * Call {@code this} with 2 arguments, including metatag processing, and
+ * return only the first return value.
*
- * If {@code this} is a {@link LuaFunction}, call it,
- * and return only its first return value, dropping any others.
- * Otherwise, look for the {@link #CALL} metatag and call that.
+ * If {@code this} is a {@link LuaFunction}, call it, and return only its
+ * first return value, dropping any others. Otherwise, look for the
+ * {@link #CALL} metatag and call that.
*
- * If the return value is a {@link Varargs}, only the 1st value will be returned.
- * To get multiple values, use {@link #invoke()} instead.
+ * If the return value is a {@link Varargs}, only the 1st value will be
+ * returned. To get multiple values, use {@link #invoke()} instead.
*
- * To call {@code this} as a method call, use {@link #method(LuaValue)} instead.
+ * To call {@code this} as a method call, use {@link #method(LuaValue)}
+ * instead.
*
* @param arg1 First argument to supply to the called function
* @param arg2 Second argument to supply to the called function
- * @return First return value {@code (this(arg1,arg2))}, or {@link #NIL} if there were none.
- * @throws LuaError if not a function and {@link #CALL} is not defined,
- * or the invoked function throws a {@link LuaError}
- * or the invoked closure throw a lua {@code error}
+ * @return First return value {@code (this(arg1,arg2))}, or {@link #NIL} if
+ * there were none.
+ * @throws LuaError if not a function and {@link #CALL} is not defined, or
+ * the invoked function throws a {@link LuaError} or the
+ * invoked closure throw a lua {@code error}
* @see #call()
* @see #call(LuaValue)
* @see #call(LuaValue, LuaValue, LuaValue)
@@ -1479,27 +1767,30 @@ public class LuaValue extends Varargs {
* @see #method(String,LuaValue,LuaValue)
* @see #method(LuaValue,LuaValue,LuaValue)
*/
- public LuaValue call(LuaValue arg1, LuaValue arg2) { return callmt().call(this,arg1,arg2); }
+ public LuaValue call(LuaValue arg1, LuaValue arg2) { return callmt().call(this, arg1, arg2); }
- /** Call {@code this} with 3 arguments, including metatag processing,
- * and return only the first return value.
+ /**
+ * Call {@code this} with 3 arguments, including metatag processing, and
+ * return only the first return value.
*
- * If {@code this} is a {@link LuaFunction}, call it,
- * and return only its first return value, dropping any others.
- * Otherwise, look for the {@link #CALL} metatag and call that.
+ * If {@code this} is a {@link LuaFunction}, call it, and return only its
+ * first return value, dropping any others. Otherwise, look for the
+ * {@link #CALL} metatag and call that.
*
- * If the return value is a {@link Varargs}, only the 1st value will be returned.
- * To get multiple values, use {@link #invoke()} instead.
+ * If the return value is a {@link Varargs}, only the 1st value will be
+ * returned. To get multiple values, use {@link #invoke()} instead.
*
- * To call {@code this} as a method call, use {@link #method(LuaValue)} instead.
+ * To call {@code this} as a method call, use {@link #method(LuaValue)}
+ * instead.
*
* @param arg1 First argument to supply to the called function
* @param arg2 Second argument to supply to the called function
* @param arg3 Second argument to supply to the called function
- * @return First return value {@code (this(arg1,arg2,arg3))}, or {@link #NIL} if there were none.
- * @throws LuaError if not a function and {@link #CALL} is not defined,
- * or the invoked function throws a {@link LuaError}
- * or the invoked closure throw a lua {@code error}
+ * @return First return value {@code (this(arg1,arg2,arg3))}, or
+ * {@link #NIL} if there were none.
+ * @throws LuaError if not a function and {@link #CALL} is not defined, or
+ * the invoked function throws a {@link LuaError} or the
+ * invoked closure throw a lua {@code error}
* @see #call()
* @see #call(LuaValue)
* @see #call(LuaValue, LuaValue)
@@ -1507,26 +1798,30 @@ public class LuaValue extends Varargs {
* @see #invokemethod(String,Varargs)
* @see #invokemethod(LuaValue,Varargs)
*/
- public LuaValue call(LuaValue arg1, LuaValue arg2, LuaValue arg3) { return callmt().invoke(new LuaValue[]{this,arg1,arg2,arg3}).arg1(); }
-
- /** Call named method on {@code this} with 0 arguments, including metatag processing,
- * and return only the first return value.
+ public LuaValue call(LuaValue arg1, LuaValue arg2, LuaValue arg3) {
+ return callmt().invoke(new LuaValue[] { this, arg1, arg2, arg3 }).arg1();
+ }
+
+ /**
+ * Call named method on {@code this} with 0 arguments, including metatag
+ * processing, and return only the first return value.
*
- * Look up {@code this[name]} and if it is a {@link LuaFunction},
- * call it inserting {@code this} as an additional first argument.
- * and return only its first return value, dropping any others.
- * Otherwise, look for the {@link #CALL} metatag and call that.
+ * Look up {@code this[name]} and if it is a {@link LuaFunction}, call it
+ * inserting {@code this} as an additional first argument. and return only
+ * its first return value, dropping any others. Otherwise, look for the
+ * {@link #CALL} metatag and call that.
*
- * If the return value is a {@link Varargs}, only the 1st value will be returned.
- * To get multiple values, use {@link #invoke()} instead.
+ * If the return value is a {@link Varargs}, only the 1st value will be
+ * returned. To get multiple values, use {@link #invoke()} instead.
*
* To call {@code this} as a plain call, use {@link #call()} instead.
*
* @param name Name of the method to look up for invocation
- * @return All values returned from {@code this:name()} as a {@link Varargs} instance
- * @throws LuaError if not a function and {@link #CALL} is not defined,
- * or the invoked function throws a {@link LuaError}
- * or the invoked closure throw a lua {@code error}
+ * @return All values returned from {@code this:name()} as a {@link Varargs}
+ * instance
+ * @throws LuaError if not a function and {@link #CALL} is not defined, or
+ * the invoked function throws a {@link LuaError} or the
+ * invoked closure throw a lua {@code error}
* @see #call()
* @see #invoke()
* @see #method(LuaValue)
@@ -1535,24 +1830,26 @@ public class LuaValue extends Varargs {
*/
public LuaValue method(String name) { return this.get(name).call(this); }
- /** Call named method on {@code this} with 0 arguments, including metatag processing,
- * and return only the first return value.
+ /**
+ * Call named method on {@code this} with 0 arguments, including metatag
+ * processing, and return only the first return value.
*
- * Look up {@code this[name]} and if it is a {@link LuaFunction},
- * call it inserting {@code this} as an additional first argument,
- * and return only its first return value, dropping any others.
- * Otherwise, look for the {@link #CALL} metatag and call that.
+ * Look up {@code this[name]} and if it is a {@link LuaFunction}, call it
+ * inserting {@code this} as an additional first argument, and return only
+ * its first return value, dropping any others. Otherwise, look for the
+ * {@link #CALL} metatag and call that.
*
- * If the return value is a {@link Varargs}, only the 1st value will be returned.
- * To get multiple values, use {@link #invoke()} instead.
+ * If the return value is a {@link Varargs}, only the 1st value will be
+ * returned. To get multiple values, use {@link #invoke()} instead.
*
* To call {@code this} as a plain call, use {@link #call()} instead.
*
* @param name Name of the method to look up for invocation
- * @return All values returned from {@code this:name()} as a {@link Varargs} instance
- * @throws LuaError if not a function and {@link #CALL} is not defined,
- * or the invoked function throws a {@link LuaError}
- * or the invoked closure throw a lua {@code error}
+ * @return All values returned from {@code this:name()} as a {@link Varargs}
+ * instance
+ * @throws LuaError if not a function and {@link #CALL} is not defined, or
+ * the invoked function throws a {@link LuaError} or the
+ * invoked closure throw a lua {@code error}
* @see #call()
* @see #invoke()
* @see #method(String)
@@ -1560,129 +1857,147 @@ public class LuaValue extends Varargs {
* @see #method(LuaValue,LuaValue,LuaValue)
*/
public LuaValue method(LuaValue name) { return this.get(name).call(this); }
-
- /** Call named method on {@code this} with 1 argument, including metatag processing,
- * and return only the first return value.
+
+ /**
+ * Call named method on {@code this} with 1 argument, including metatag
+ * processing, and return only the first return value.
*
- * Look up {@code this[name]} and if it is a {@link LuaFunction},
- * call it inserting {@code this} as an additional first argument,
- * and return only its first return value, dropping any others.
- * Otherwise, look for the {@link #CALL} metatag and call that.
+ * Look up {@code this[name]} and if it is a {@link LuaFunction}, call it
+ * inserting {@code this} as an additional first argument, and return only
+ * its first return value, dropping any others. Otherwise, look for the
+ * {@link #CALL} metatag and call that.
*
- * If the return value is a {@link Varargs}, only the 1st value will be returned.
- * To get multiple values, use {@link #invoke()} instead.
+ * If the return value is a {@link Varargs}, only the 1st value will be
+ * returned. To get multiple values, use {@link #invoke()} instead.
*
- * To call {@code this} as a plain call, use {@link #call(LuaValue)} instead.
+ * To call {@code this} as a plain call, use {@link #call(LuaValue)}
+ * instead.
*
* @param name Name of the method to look up for invocation
- * @param arg Argument to supply to the method
- * @return All values returned from {@code this:name(arg)} as a {@link Varargs} instance
- * @throws LuaError if not a function and {@link #CALL} is not defined,
- * or the invoked function throws a {@link LuaError}
- * or the invoked closure throw a lua {@code error}
+ * @param arg Argument to supply to the method
+ * @return All values returned from {@code this:name(arg)} as a
+ * {@link Varargs} instance
+ * @throws LuaError if not a function and {@link #CALL} is not defined, or
+ * the invoked function throws a {@link LuaError} or the
+ * invoked closure throw a lua {@code error}
* @see #call(LuaValue)
* @see #invoke(Varargs)
* @see #method(String)
* @see #method(LuaValue)
* @see #method(String,LuaValue,LuaValue)
*/
- public LuaValue method(String name, LuaValue arg) { return this.get(name).call(this,arg); }
-
- /** Call named method on {@code this} with 1 argument, including metatag processing,
- * and return only the first return value.
+ public LuaValue method(String name, LuaValue arg) { return this.get(name).call(this, arg); }
+
+ /**
+ * Call named method on {@code this} with 1 argument, including metatag
+ * processing, and return only the first return value.
*
- * Look up {@code this[name]} and if it is a {@link LuaFunction},
- * call it inserting {@code this} as an additional first argument,
- * and return only its first return value, dropping any others.
- * Otherwise, look for the {@link #CALL} metatag and call that.
+ * Look up {@code this[name]} and if it is a {@link LuaFunction}, call it
+ * inserting {@code this} as an additional first argument, and return only
+ * its first return value, dropping any others. Otherwise, look for the
+ * {@link #CALL} metatag and call that.
*
- * If the return value is a {@link Varargs}, only the 1st value will be returned.
- * To get multiple values, use {@link #invoke()} instead.
+ * If the return value is a {@link Varargs}, only the 1st value will be
+ * returned. To get multiple values, use {@link #invoke()} instead.
*
- * To call {@code this} as a plain call, use {@link #call(LuaValue)} instead.
+ * To call {@code this} as a plain call, use {@link #call(LuaValue)}
+ * instead.
*
* @param name Name of the method to look up for invocation
- * @param arg Argument to supply to the method
- * @return All values returned from {@code this:name(arg)} as a {@link Varargs} instance
- * @throws LuaError if not a function and {@link #CALL} is not defined,
- * or the invoked function throws a {@link LuaError}
- * or the invoked closure throw a lua {@code error}
+ * @param arg Argument to supply to the method
+ * @return All values returned from {@code this:name(arg)} as a
+ * {@link Varargs} instance
+ * @throws LuaError if not a function and {@link #CALL} is not defined, or
+ * the invoked function throws a {@link LuaError} or the
+ * invoked closure throw a lua {@code error}
* @see #call(LuaValue)
* @see #invoke(Varargs)
* @see #method(String,LuaValue)
* @see #method(LuaValue)
* @see #method(LuaValue,LuaValue,LuaValue)
*/
- public LuaValue method(LuaValue name, LuaValue arg) { return this.get(name).call(this,arg); }
+ public LuaValue method(LuaValue name, LuaValue arg) { return this.get(name).call(this, arg); }
- /** Call named method on {@code this} with 2 arguments, including metatag processing,
- * and return only the first return value.
+ /**
+ * Call named method on {@code this} with 2 arguments, including metatag
+ * processing, and return only the first return value.
*
- * Look up {@code this[name]} and if it is a {@link LuaFunction},
- * call it inserting {@code this} as an additional first argument,
- * and return only its first return value, dropping any others.
- * Otherwise, look for the {@link #CALL} metatag and call that.
+ * Look up {@code this[name]} and if it is a {@link LuaFunction}, call it
+ * inserting {@code this} as an additional first argument, and return only
+ * its first return value, dropping any others. Otherwise, look for the
+ * {@link #CALL} metatag and call that.
*
- * If the return value is a {@link Varargs}, only the 1st value will be returned.
- * To get multiple values, use {@link #invoke()} instead.
+ * If the return value is a {@link Varargs}, only the 1st value will be
+ * returned. To get multiple values, use {@link #invoke()} instead.
*
- * To call {@code this} as a plain call, use {@link #call(LuaValue,LuaValue)} instead.
+ * To call {@code this} as a plain call, use
+ * {@link #call(LuaValue,LuaValue)} instead.
*
* @param name Name of the method to look up for invocation
* @param arg1 First argument to supply to the method
* @param arg2 Second argument to supply to the method
- * @return All values returned from {@code this:name(arg1,arg2)} as a {@link Varargs} instance
- * @throws LuaError if not a function and {@link #CALL} is not defined,
- * or the invoked function throws a {@link LuaError}
- * or the invoked closure throw a lua {@code error}
+ * @return All values returned from {@code this:name(arg1,arg2)} as a
+ * {@link Varargs} instance
+ * @throws LuaError if not a function and {@link #CALL} is not defined, or
+ * the invoked function throws a {@link LuaError} or the
+ * invoked closure throw a lua {@code error}
* @see #call(LuaValue,LuaValue)
* @see #invoke(LuaValue,Varargs)
* @see #method(String,LuaValue)
* @see #method(LuaValue,LuaValue,LuaValue)
*/
- public LuaValue method(String name, LuaValue arg1, LuaValue arg2) { return this.get(name).call(this,arg1,arg2); }
+ public LuaValue method(String name, LuaValue arg1, LuaValue arg2) {
+ return this.get(name).call(this, arg1, arg2);
+ }
- /** Call named method on {@code this} with 2 arguments, including metatag processing,
- * and return only the first return value.
+ /**
+ * Call named method on {@code this} with 2 arguments, including metatag
+ * processing, and return only the first return value.
*
- * Look up {@code this[name]} and if it is a {@link LuaFunction},
- * call it inserting {@code this} as an additional first argument,
- * and return only its first return value, dropping any others.
- * Otherwise, look for the {@link #CALL} metatag and call that.
+ * Look up {@code this[name]} and if it is a {@link LuaFunction}, call it
+ * inserting {@code this} as an additional first argument, and return only
+ * its first return value, dropping any others. Otherwise, look for the
+ * {@link #CALL} metatag and call that.
*
- * If the return value is a {@link Varargs}, only the 1st value will be returned.
- * To get multiple values, use {@link #invoke()} instead.
+ * If the return value is a {@link Varargs}, only the 1st value will be
+ * returned. To get multiple values, use {@link #invoke()} instead.
*
- * To call {@code this} as a plain call, use {@link #call(LuaValue,LuaValue)} instead.
+ * To call {@code this} as a plain call, use
+ * {@link #call(LuaValue,LuaValue)} instead.
*
* @param name Name of the method to look up for invocation
* @param arg1 First argument to supply to the method
* @param arg2 Second argument to supply to the method
- * @return All values returned from {@code this:name(arg1,arg2)} as a {@link Varargs} instance
- * @throws LuaError if not a function and {@link #CALL} is not defined,
- * or the invoked function throws a {@link LuaError}
- * or the invoked closure throw a lua {@code error}
+ * @return All values returned from {@code this:name(arg1,arg2)} as a
+ * {@link Varargs} instance
+ * @throws LuaError if not a function and {@link #CALL} is not defined, or
+ * the invoked function throws a {@link LuaError} or the
+ * invoked closure throw a lua {@code error}
* @see #call(LuaValue,LuaValue)
* @see #invoke(LuaValue,Varargs)
* @see #method(LuaValue,LuaValue)
* @see #method(String,LuaValue,LuaValue)
*/
- public LuaValue method(LuaValue name, LuaValue arg1, LuaValue arg2) { return this.get(name).call(this,arg1,arg2); }
-
- /** Call {@code this} with 0 arguments, including metatag processing,
- * and retain all return values in a {@link Varargs}.
+ public LuaValue method(LuaValue name, LuaValue arg1, LuaValue arg2) {
+ return this.get(name).call(this, arg1, arg2);
+ }
+
+ /**
+ * Call {@code this} with 0 arguments, including metatag processing, and
+ * retain all return values in a {@link Varargs}.
*
* If {@code this} is a {@link LuaFunction}, call it, and return all values.
* Otherwise, look for the {@link #CALL} metatag and call that.
*
* To get a particular return value, us {@link Varargs#arg(int)}
*
- * To call {@code this} as a method call, use {@link #invokemethod(LuaValue)} instead.
+ * To call {@code this} as a method call, use
+ * {@link #invokemethod(LuaValue)} instead.
*
* @return All return values as a {@link Varargs} instance.
- * @throws LuaError if not a function and {@link #CALL} is not defined,
- * or the invoked function throws a {@link LuaError}
- * or the invoked closure throw a lua {@code error}
+ * @throws LuaError if not a function and {@link #CALL} is not defined, or
+ * the invoked function throws a {@link LuaError} or the
+ * invoked closure throw a lua {@code error}
* @see #call()
* @see #invoke(Varargs)
* @see #invokemethod(String)
@@ -1690,7 +2005,8 @@ public class LuaValue extends Varargs {
*/
public Varargs invoke() { return invoke(NONE); }
- /** Call {@code this} with variable arguments, including metatag processing,
+ /**
+ * Call {@code this} with variable arguments, including metatag processing,
* and retain all return values in a {@link Varargs}.
*
* If {@code this} is a {@link LuaFunction}, call it, and return all values.
@@ -1698,13 +2014,15 @@ public class LuaValue extends Varargs {
*
* To get a particular return value, us {@link Varargs#arg(int)}
*
- * To call {@code this} as a method call, use {@link #invokemethod(LuaValue)} instead.
+ * To call {@code this} as a method call, use
+ * {@link #invokemethod(LuaValue)} instead.
*
- * @param args Varargs containing the arguments to supply to the called function
+ * @param args Varargs containing the arguments to supply to the called
+ * function
* @return All return values as a {@link Varargs} instance.
- * @throws LuaError if not a function and {@link #CALL} is not defined,
- * or the invoked function throws a {@link LuaError}
- * or the invoked closure throw a lua {@code error}
+ * @throws LuaError if not a function and {@link #CALL} is not defined, or
+ * the invoked function throws a {@link LuaError} or the
+ * invoked closure throw a lua {@code error}
* @see #varargsOf(LuaValue[])
* @see #call(LuaValue)
* @see #invoke()
@@ -1712,9 +2030,10 @@ public class LuaValue extends Varargs {
* @see #invokemethod(String,Varargs)
* @see #invokemethod(LuaValue,Varargs)
*/
- public Varargs invoke(Varargs args) { return callmt().invoke(this,args); }
+ public Varargs invoke(Varargs args) { return callmt().invoke(this, args); }
- /** Call {@code this} with variable arguments, including metatag processing,
+ /**
+ * Call {@code this} with variable arguments, including metatag processing,
* and retain all return values in a {@link Varargs}.
*
* If {@code this} is a {@link LuaFunction}, call it, and return all values.
@@ -1722,23 +2041,26 @@ public class LuaValue extends Varargs {
*
* To get a particular return value, us {@link Varargs#arg(int)}
*
- * To call {@code this} as a method call, use {@link #invokemethod(LuaValue,Varargs)} instead.
+ * To call {@code this} as a method call, use
+ * {@link #invokemethod(LuaValue,Varargs)} instead.
*
- * @param arg The first argument to supply to the called function
- * @param varargs Varargs containing the remaining arguments to supply to the called function
+ * @param arg The first argument to supply to the called function
+ * @param varargs Varargs containing the remaining arguments to supply to
+ * the called function
* @return All return values as a {@link Varargs} instance.
- * @throws LuaError if not a function and {@link #CALL} is not defined,
- * or the invoked function throws a {@link LuaError}
- * or the invoked closure throw a lua {@code error}
+ * @throws LuaError if not a function and {@link #CALL} is not defined, or
+ * the invoked function throws a {@link LuaError} or the
+ * invoked closure throw a lua {@code error}
* @see #varargsOf(LuaValue[])
* @see #call(LuaValue,LuaValue)
* @see #invoke(LuaValue,Varargs)
* @see #invokemethod(String,Varargs)
* @see #invokemethod(LuaValue,Varargs)
*/
- public Varargs invoke(LuaValue arg,Varargs varargs) { return invoke(varargsOf(arg,varargs)); }
+ public Varargs invoke(LuaValue arg, Varargs varargs) { return invoke(varargsOf(arg, varargs)); }
- /** Call {@code this} with variable arguments, including metatag processing,
+ /**
+ * Call {@code this} with variable arguments, including metatag processing,
* and retain all return values in a {@link Varargs}.
*
* If {@code this} is a {@link LuaFunction}, call it, and return all values.
@@ -1746,24 +2068,29 @@ public class LuaValue extends Varargs {
*
* To get a particular return value, us {@link Varargs#arg(int)}
*
- * To call {@code this} as a method call, use {@link #invokemethod(LuaValue,Varargs)} instead.
+ * To call {@code this} as a method call, use
+ * {@link #invokemethod(LuaValue,Varargs)} instead.
*
- * @param arg1 The first argument to supply to the called function
- * @param arg2 The second argument to supply to the called function
- * @param varargs Varargs containing the remaining arguments to supply to the called function
+ * @param arg1 The first argument to supply to the called function
+ * @param arg2 The second argument to supply to the called function
+ * @param varargs Varargs containing the remaining arguments to supply to
+ * the called function
* @return All return values as a {@link Varargs} instance.
- * @throws LuaError if not a function and {@link #CALL} is not defined,
- * or the invoked function throws a {@link LuaError}
- * or the invoked closure throw a lua {@code error}
+ * @throws LuaError if not a function and {@link #CALL} is not defined, or
+ * the invoked function throws a {@link LuaError} or the
+ * invoked closure throw a lua {@code error}
* @see #varargsOf(LuaValue[])
* @see #call(LuaValue,LuaValue,LuaValue)
* @see #invoke(LuaValue,LuaValue,Varargs)
* @see #invokemethod(String,Varargs)
* @see #invokemethod(LuaValue,Varargs)
*/
- public Varargs invoke(LuaValue arg1,LuaValue arg2,Varargs varargs) { return invoke(varargsOf(arg1,arg2,varargs)); }
+ public Varargs invoke(LuaValue arg1, LuaValue arg2, Varargs varargs) {
+ return invoke(varargsOf(arg1, arg2, varargs));
+ }
- /** Call {@code this} with variable arguments, including metatag processing,
+ /**
+ * Call {@code this} with variable arguments, including metatag processing,
* and retain all return values in a {@link Varargs}.
*
* If {@code this} is a {@link LuaFunction}, call it, and return all values.
@@ -1771,13 +2098,14 @@ public class LuaValue extends Varargs {
*
* To get a particular return value, us {@link Varargs#arg(int)}
*
- * To call {@code this} as a method call, use {@link #invokemethod(LuaValue,Varargs)} instead.
+ * To call {@code this} as a method call, use
+ * {@link #invokemethod(LuaValue,Varargs)} instead.
*
* @param args Array of arguments to supply to the called function
* @return All return values as a {@link Varargs} instance.
- * @throws LuaError if not a function and {@link #CALL} is not defined,
- * or the invoked function throws a {@link LuaError}
- * or the invoked closure throw a lua {@code error}
+ * @throws LuaError if not a function and {@link #CALL} is not defined, or
+ * the invoked function throws a {@link LuaError} or the
+ * invoked closure throw a lua {@code error}
* @see #varargsOf(LuaValue[])
* @see #call(LuaValue,LuaValue,LuaValue)
* @see #invoke(LuaValue,LuaValue,Varargs)
@@ -1786,7 +2114,8 @@ public class LuaValue extends Varargs {
*/
public Varargs invoke(LuaValue[] args) { return invoke(varargsOf(args)); }
- /** Call {@code this} with variable arguments, including metatag processing,
+ /**
+ * Call {@code this} with variable arguments, including metatag processing,
* and retain all return values in a {@link Varargs}.
*
* If {@code this} is a {@link LuaFunction}, call it, and return all values.
@@ -1794,14 +2123,16 @@ public class LuaValue extends Varargs {
*
* To get a particular return value, us {@link Varargs#arg(int)}
*
- * To call {@code this} as a method call, use {@link #invokemethod(LuaValue,Varargs)} instead.
+ * To call {@code this} as a method call, use
+ * {@link #invokemethod(LuaValue,Varargs)} instead.
*
- * @param args Array of arguments to supply to the called function
- * @param varargs Varargs containing additional arguments to supply to the called function
+ * @param args Array of arguments to supply to the called function
+ * @param varargs Varargs containing additional arguments to supply to the
+ * called function
* @return All return values as a {@link Varargs} instance.
- * @throws LuaError if not a function and {@link #CALL} is not defined,
- * or the invoked function throws a {@link LuaError}
- * or the invoked closure throw a lua {@code error}
+ * @throws LuaError if not a function and {@link #CALL} is not defined, or
+ * the invoked function throws a {@link LuaError} or the
+ * invoked closure throw a lua {@code error}
* @see #varargsOf(LuaValue[])
* @see #call(LuaValue,LuaValue,LuaValue)
* @see #invoke(LuaValue,LuaValue,Varargs)
@@ -1810,25 +2141,27 @@ public class LuaValue extends Varargs {
* @see #invokemethod(String,Varargs)
* @see #invokemethod(LuaValue,Varargs)
*/
- public Varargs invoke(LuaValue[] args,Varargs varargs) { return invoke(varargsOf(args,varargs)); }
-
- /** Call named method on {@code this} with 0 arguments, including metatag processing,
- * and retain all return values in a {@link Varargs}.
+ public Varargs invoke(LuaValue[] args, Varargs varargs) { return invoke(varargsOf(args, varargs)); }
+
+ /**
+ * Call named method on {@code this} with 0 arguments, including metatag
+ * processing, and retain all return values in a {@link Varargs}.
*
- * Look up {@code this[name]} and if it is a {@link LuaFunction},
- * call it inserting {@code this} as an additional first argument,
- * and return all return values as a {@link Varargs} instance.
- * Otherwise, look for the {@link #CALL} metatag and call that.
+ * Look up {@code this[name]} and if it is a {@link LuaFunction}, call it
+ * inserting {@code this} as an additional first argument, and return all
+ * return values as a {@link Varargs} instance. Otherwise, look for the
+ * {@link #CALL} metatag and call that.
*
* To get a particular return value, us {@link Varargs#arg(int)}
*
* To call {@code this} as a plain call, use {@link #invoke()} instead.
*
* @param name Name of the method to look up for invocation
- * @return All values returned from {@code this:name()} as a {@link Varargs} instance
- * @throws LuaError if not a function and {@link #CALL} is not defined,
- * or the invoked function throws a {@link LuaError}
- * or the invoked closure throw a lua {@code error}
+ * @return All values returned from {@code this:name()} as a {@link Varargs}
+ * instance
+ * @throws LuaError if not a function and {@link #CALL} is not defined, or
+ * the invoked function throws a {@link LuaError} or the
+ * invoked closure throw a lua {@code error}
* @see #call()
* @see #invoke()
* @see #method(String)
@@ -1839,24 +2172,26 @@ public class LuaValue extends Varargs {
* @see #invokemethod(LuaValue, Varargs)
*/
public Varargs invokemethod(String name) { return get(name).invoke(this); }
-
- /** Call named method on {@code this} with 0 arguments, including metatag processing,
- * and retain all return values in a {@link Varargs}.
+
+ /**
+ * Call named method on {@code this} with 0 arguments, including metatag
+ * processing, and retain all return values in a {@link Varargs}.
*
- * Look up {@code this[name]} and if it is a {@link LuaFunction},
- * call it inserting {@code this} as an additional first argument,
- * and return all return values as a {@link Varargs} instance.
- * Otherwise, look for the {@link #CALL} metatag and call that.
+ * Look up {@code this[name]} and if it is a {@link LuaFunction}, call it
+ * inserting {@code this} as an additional first argument, and return all
+ * return values as a {@link Varargs} instance. Otherwise, look for the
+ * {@link #CALL} metatag and call that.
*
* To get a particular return value, us {@link Varargs#arg(int)}
*
* To call {@code this} as a plain call, use {@link #invoke()} instead.
*
* @param name Name of the method to look up for invocation
- * @return All values returned from {@code this:name()} as a {@link Varargs} instance
- * @throws LuaError if not a function and {@link #CALL} is not defined,
- * or the invoked function throws a {@link LuaError}
- * or the invoked closure throw a lua {@code error}
+ * @return All values returned from {@code this:name()} as a {@link Varargs}
+ * instance
+ * @throws LuaError if not a function and {@link #CALL} is not defined, or
+ * the invoked function throws a {@link LuaError} or the
+ * invoked closure throw a lua {@code error}
* @see #call()
* @see #invoke()
* @see #method(LuaValue)
@@ -1867,25 +2202,29 @@ public class LuaValue extends Varargs {
* @see #invokemethod(LuaValue, Varargs)
*/
public Varargs invokemethod(LuaValue name) { return get(name).invoke(this); }
-
- /** Call named method on {@code this} with 1 argument, including metatag processing,
- * and retain all return values in a {@link Varargs}.
+
+ /**
+ * Call named method on {@code this} with 1 argument, including metatag
+ * processing, and retain all return values in a {@link Varargs}.
*
- * Look up {@code this[name]} and if it is a {@link LuaFunction},
- * call it inserting {@code this} as an additional first argument,
- * and return all return values as a {@link Varargs} instance.
- * Otherwise, look for the {@link #CALL} metatag and call that.
+ * Look up {@code this[name]} and if it is a {@link LuaFunction}, call it
+ * inserting {@code this} as an additional first argument, and return all
+ * return values as a {@link Varargs} instance. Otherwise, look for the
+ * {@link #CALL} metatag and call that.
*
* To get a particular return value, us {@link Varargs#arg(int)}
*
- * To call {@code this} as a plain call, use {@link #invoke(Varargs)} instead.
+ * To call {@code this} as a plain call, use {@link #invoke(Varargs)}
+ * instead.
*
* @param name Name of the method to look up for invocation
- * @param args {@link Varargs} containing arguments to supply to the called function after {@code this}
- * @return All values returned from {@code this:name(args)} as a {@link Varargs} instance
- * @throws LuaError if not a function and {@link #CALL} is not defined,
- * or the invoked function throws a {@link LuaError}
- * or the invoked closure throw a lua {@code error}
+ * @param args {@link Varargs} containing arguments to supply to the called
+ * function after {@code this}
+ * @return All values returned from {@code this:name(args)} as a
+ * {@link Varargs} instance
+ * @throws LuaError if not a function and {@link #CALL} is not defined, or
+ * the invoked function throws a {@link LuaError} or the
+ * invoked closure throw a lua {@code error}
* @see #call()
* @see #invoke(Varargs)
* @see #method(String)
@@ -1895,26 +2234,30 @@ public class LuaValue extends Varargs {
* @see #invokemethod(LuaValue, LuaValue[])
* @see #invokemethod(LuaValue, Varargs)
*/
- public Varargs invokemethod(String name, Varargs args) { return get(name).invoke(varargsOf(this,args)); }
-
- /** Call named method on {@code this} with variable arguments, including metatag processing,
- * and retain all return values in a {@link Varargs}.
+ public Varargs invokemethod(String name, Varargs args) { return get(name).invoke(varargsOf(this, args)); }
+
+ /**
+ * Call named method on {@code this} with variable arguments, including
+ * metatag processing, and retain all return values in a {@link Varargs}.
*
- * Look up {@code this[name]} and if it is a {@link LuaFunction},
- * call it inserting {@code this} as an additional first argument,
- * and return all return values as a {@link Varargs} instance.
- * Otherwise, look for the {@link #CALL} metatag and call that.
+ * Look up {@code this[name]} and if it is a {@link LuaFunction}, call it
+ * inserting {@code this} as an additional first argument, and return all
+ * return values as a {@link Varargs} instance. Otherwise, look for the
+ * {@link #CALL} metatag and call that.
*
* To get a particular return value, us {@link Varargs#arg(int)}
*
- * To call {@code this} as a plain call, use {@link #invoke(Varargs)} instead.
+ * To call {@code this} as a plain call, use {@link #invoke(Varargs)}
+ * instead.
*
* @param name Name of the method to look up for invocation
- * @param args {@link Varargs} containing arguments to supply to the called function after {@code this}
- * @return All values returned from {@code this:name(args)} as a {@link Varargs} instance
- * @throws LuaError if not a function and {@link #CALL} is not defined,
- * or the invoked function throws a {@link LuaError}
- * or the invoked closure throw a lua {@code error}
+ * @param args {@link Varargs} containing arguments to supply to the called
+ * function after {@code this}
+ * @return All values returned from {@code this:name(args)} as a
+ * {@link Varargs} instance
+ * @throws LuaError if not a function and {@link #CALL} is not defined, or
+ * the invoked function throws a {@link LuaError} or the
+ * invoked closure throw a lua {@code error}
* @see #call()
* @see #invoke(Varargs)
* @see #method(String)
@@ -1924,26 +2267,30 @@ public class LuaValue extends Varargs {
* @see #invokemethod(String, Varargs)
* @see #invokemethod(LuaValue, LuaValue[])
*/
- public Varargs invokemethod(LuaValue name, Varargs args) { return get(name).invoke(varargsOf(this,args)); }
-
- /** Call named method on {@code this} with 1 argument, including metatag processing,
- * and retain all return values in a {@link Varargs}.
+ public Varargs invokemethod(LuaValue name, Varargs args) { return get(name).invoke(varargsOf(this, args)); }
+
+ /**
+ * Call named method on {@code this} with 1 argument, including metatag
+ * processing, and retain all return values in a {@link Varargs}.
*
- * Look up {@code this[name]} and if it is a {@link LuaFunction},
- * call it inserting {@code this} as an additional first argument,
- * and return all return values as a {@link Varargs} instance.
- * Otherwise, look for the {@link #CALL} metatag and call that.
+ * Look up {@code this[name]} and if it is a {@link LuaFunction}, call it
+ * inserting {@code this} as an additional first argument, and return all
+ * return values as a {@link Varargs} instance. Otherwise, look for the
+ * {@link #CALL} metatag and call that.
*
* To get a particular return value, us {@link Varargs#arg(int)}
*
- * To call {@code this} as a plain call, use {@link #invoke(Varargs)} instead.
+ * To call {@code this} as a plain call, use {@link #invoke(Varargs)}
+ * instead.
*
* @param name Name of the method to look up for invocation
- * @param args Array of {@link LuaValue} containing arguments to supply to the called function after {@code this}
- * @return All values returned from {@code this:name(args)} as a {@link Varargs} instance
- * @throws LuaError if not a function and {@link #CALL} is not defined,
- * or the invoked function throws a {@link LuaError}
- * or the invoked closure throw a lua {@code error}
+ * @param args Array of {@link LuaValue} containing arguments to supply to
+ * the called function after {@code this}
+ * @return All values returned from {@code this:name(args)} as a
+ * {@link Varargs} instance
+ * @throws LuaError if not a function and {@link #CALL} is not defined, or
+ * the invoked function throws a {@link LuaError} or the
+ * invoked closure throw a lua {@code error}
* @see #call()
* @see #invoke(Varargs)
* @see #method(String)
@@ -1954,26 +2301,32 @@ public class LuaValue extends Varargs {
* @see #invokemethod(LuaValue, Varargs)
* @see LuaValue#varargsOf(LuaValue[])
*/
- public Varargs invokemethod(String name, LuaValue[] args) { return get(name).invoke(varargsOf(this,varargsOf(args))); }
-
- /** Call named method on {@code this} with variable arguments, including metatag processing,
- * and retain all return values in a {@link Varargs}.
+ public Varargs invokemethod(String name, LuaValue[] args) {
+ return get(name).invoke(varargsOf(this, varargsOf(args)));
+ }
+
+ /**
+ * Call named method on {@code this} with variable arguments, including
+ * metatag processing, and retain all return values in a {@link Varargs}.
*
- * Look up {@code this[name]} and if it is a {@link LuaFunction},
- * call it inserting {@code this} as an additional first argument,
- * and return all return values as a {@link Varargs} instance.
- * Otherwise, look for the {@link #CALL} metatag and call that.
+ * Look up {@code this[name]} and if it is a {@link LuaFunction}, call it
+ * inserting {@code this} as an additional first argument, and return all
+ * return values as a {@link Varargs} instance. Otherwise, look for the
+ * {@link #CALL} metatag and call that.
*
* To get a particular return value, us {@link Varargs#arg(int)}
*
- * To call {@code this} as a plain call, use {@link #invoke(Varargs)} instead.
+ * To call {@code this} as a plain call, use {@link #invoke(Varargs)}
+ * instead.
*
* @param name Name of the method to look up for invocation
- * @param args Array of {@link LuaValue} containing arguments to supply to the called function after {@code this}
- * @return All values returned from {@code this:name(args)} as a {@link Varargs} instance
- * @throws LuaError if not a function and {@link #CALL} is not defined,
- * or the invoked function throws a {@link LuaError}
- * or the invoked closure throw a lua {@code error}
+ * @param args Array of {@link LuaValue} containing arguments to supply to
+ * the called function after {@code this}
+ * @return All values returned from {@code this:name(args)} as a
+ * {@link Varargs} instance
+ * @throws LuaError if not a function and {@link #CALL} is not defined, or
+ * the invoked function throws a {@link LuaError} or the
+ * invoked closure throw a lua {@code error}
* @see #call()
* @see #invoke(Varargs)
* @see #method(String)
@@ -1984,112 +2337,143 @@ public class LuaValue extends Varargs {
* @see #invokemethod(LuaValue, Varargs)
* @see LuaValue#varargsOf(LuaValue[])
*/
- public Varargs invokemethod(LuaValue name, LuaValue[] args) { return get(name).invoke(varargsOf(this,varargsOf(args))); }
-
+ public Varargs invokemethod(LuaValue name, LuaValue[] args) {
+ return get(name).invoke(varargsOf(this, varargsOf(args)));
+ }
+
/**
* Get the metatag value for the {@link #CALL} metatag, if it exists.
+ *
* @return {@link LuaValue} value if metatag is defined
* @throws LuaError if {@link #CALL} metatag is not defined.
*/
protected LuaValue callmt() {
return checkmetatag(CALL, "attempt to call ");
}
-
- /** Unary not: return inverse boolean value {@code (~this)} as defined by lua not operator
- * @return {@link #TRUE} if {@link #NIL} or {@link #FALSE}, otherwise {@link #FALSE}
- */
- public LuaValue not() { return FALSE; }
-
- /** Unary minus: return negative value {@code (-this)} as defined by lua unary minus operator
- * @return boolean inverse as {@link LuaBoolean} if boolean or nil,
- * numeric inverse as {@link LuaNumber} if numeric,
- * or metatag processing result if {@link #UNM} metatag is defined
- * @throws LuaError if {@code this} is not a table or string, and has no {@link #UNM} metatag
- */
- public LuaValue neg() { return checkmetatag(UNM, "attempt to perform arithmetic on ").call(this); }
-
- /** Length operator: return lua length of object {@code (#this)} including metatag processing as java int
- * @return length as defined by the lua # operator
- * or metatag processing result
- * @throws LuaError if {@code this} is not a table or string, and has no {@link #LEN} metatag
- */
- public LuaValue len() { return checkmetatag(LEN, "attempt to get length of ").call(this); }
- /** Length operator: return lua length of object {@code (#this)} including metatag processing as java int
- * @return length as defined by the lua # operator
- * or metatag processing result converted to java int using {@link #toint()}
- * @throws LuaError if {@code this} is not a table or string, and has no {@link #LEN} metatag
+ /**
+ * Unary not: return inverse boolean value {@code (~this)} as defined by lua
+ * not operator
+ *
+ * @return {@link #TRUE} if {@link #NIL} or {@link #FALSE}, otherwise
+ * {@link #FALSE}
*/
- public int length() { return len().toint(); }
-
- /** Get raw length of table or string without metatag processing.
+ public LuaValue not() { return FALSE; }
+
+ /**
+ * Unary minus: return negative value {@code (-this)} as defined by lua
+ * unary minus operator
+ *
+ * @return boolean inverse as {@link LuaBoolean} if boolean or nil, numeric
+ * inverse as {@link LuaNumber} if numeric, or metatag processing
+ * result if {@link #UNM} metatag is defined
+ * @throws LuaError if {@code this} is not a table or string, and has no
+ * {@link #UNM} metatag
+ */
+ public LuaValue neg() { return checkmetatag(UNM, "attempt to perform arithmetic on ").call(this); }
+
+ /**
+ * Length operator: return lua length of object {@code (#this)} including
+ * metatag processing as java int
+ *
+ * @return length as defined by the lua # operator or metatag processing
+ * result
+ * @throws LuaError if {@code this} is not a table or string, and has no
+ * {@link #LEN} metatag
+ */
+ public LuaValue len() { return checkmetatag(LEN, "attempt to get length of ").call(this); }
+
+ /**
+ * Length operator: return lua length of object {@code (#this)} including
+ * metatag processing as java int
+ *
+ * @return length as defined by the lua # operator or metatag processing
+ * result converted to java int using {@link #toint()}
+ * @throws LuaError if {@code this} is not a table or string, and has no
+ * {@link #LEN} metatag
+ */
+ public int length() { return len().toint(); }
+
+ /**
+ * Get raw length of table or string without metatag processing.
+ *
* @return the length of the table or string.
* @throws LuaError if {@code this} is not a table or string.
*/
public int rawlen() { typerror("table or string"); return 0; }
-
+
// object equality, used for key comparison
- public boolean equals(Object obj) { return this == obj; }
-
- /** Equals: Perform equality comparison with another value
- * including metatag processing using {@link #EQ}.
+ public boolean equals(Object obj) { return this == obj; }
+
+ /**
+ * Equals: Perform equality comparison with another value including metatag
+ * processing using {@link #EQ}.
+ *
* @param val The value to compare with.
- * @return {@link #TRUE} if values are comparable and {@code (this == rhs)},
- * {@link #FALSE} if comparable but not equal,
- * {@link LuaValue} if metatag processing occurs.
+ * @return {@link #TRUE} if values are comparable and {@code (this == rhs)},
+ * {@link #FALSE} if comparable but not equal, {@link LuaValue} if
+ * metatag processing occurs.
* @see #eq_b(LuaValue)
* @see #raweq(LuaValue)
* @see #neq(LuaValue)
* @see #eqmtcall(LuaValue, LuaValue, LuaValue, LuaValue)
* @see #EQ
*/
- public LuaValue eq( LuaValue val ) { return eq_b(val)? TRUE: FALSE; }
-
- /** Equals: Perform equality comparison with another value
- * including metatag processing using {@link #EQ},
- * and return java boolean
+ public LuaValue eq(LuaValue val) { return eq_b(val)? TRUE: FALSE; }
+
+ /**
+ * Equals: Perform equality comparison with another value including metatag
+ * processing using {@link #EQ}, and return java boolean
+ *
* @param val The value to compare with.
- * @return true if values are comparable and {@code (this == rhs)},
- * false if comparable but not equal,
- * result converted to java boolean if metatag processing occurs.
+ * @return true if values are comparable and {@code (this == rhs)}, false if
+ * comparable but not equal, result converted to java boolean if
+ * metatag processing occurs.
* @see #eq(LuaValue)
* @see #raweq(LuaValue)
* @see #neq_b(LuaValue)
* @see #eqmtcall(LuaValue, LuaValue, LuaValue, LuaValue)
* @see #EQ
*/
- public boolean eq_b( LuaValue val ) { return this == val; }
+ public boolean eq_b(LuaValue val) { return this == val; }
- /** Notquals: Perform inequality comparison with another value
- * including metatag processing using {@link #EQ}.
+ /**
+ * Notquals: Perform inequality comparison with another value including
+ * metatag processing using {@link #EQ}.
+ *
* @param val The value to compare with.
- * @return {@link #TRUE} if values are comparable and {@code (this != rhs)},
- * {@link #FALSE} if comparable but equal,
- * inverse of {@link LuaValue} converted to {@link LuaBoolean} if metatag processing occurs.
+ * @return {@link #TRUE} if values are comparable and {@code (this != rhs)},
+ * {@link #FALSE} if comparable but equal, inverse of
+ * {@link LuaValue} converted to {@link LuaBoolean} if metatag
+ * processing occurs.
* @see #eq(LuaValue)
* @see #raweq(LuaValue)
* @see #eqmtcall(LuaValue, LuaValue, LuaValue, LuaValue)
* @see #EQ
*/
- public LuaValue neq( LuaValue val ) { return eq_b(val)? FALSE: TRUE; }
+ public LuaValue neq(LuaValue val) { return eq_b(val)? FALSE: TRUE; }
- /** Notquals: Perform inequality comparison with another value
- * including metatag processing using {@link #EQ}.
+ /**
+ * Notquals: Perform inequality comparison with another value including
+ * metatag processing using {@link #EQ}.
+ *
* @param val The value to compare with.
- * @return true if values are comparable and {@code (this != rhs)},
- * false if comparable but equal,
- * inverse of result converted to boolean if metatag processing occurs.
+ * @return true if values are comparable and {@code (this != rhs)}, false if
+ * comparable but equal, inverse of result converted to boolean if
+ * metatag processing occurs.
* @see #eq_b(LuaValue)
* @see #raweq(LuaValue)
* @see #eqmtcall(LuaValue, LuaValue, LuaValue, LuaValue)
* @see #EQ
*/
- public boolean neq_b( LuaValue val ) { return !eq_b(val); }
+ public boolean neq_b(LuaValue val) { return !eq_b(val); }
- /** Equals: Perform direct equality comparison with another value
- * without metatag processing.
+ /**
+ * Equals: Perform direct equality comparison with another value without
+ * metatag processing.
+ *
* @param val The value to compare with.
- * @return true if {@code (this == rhs)}, false otherwise
+ * @return true if {@code (this == rhs)}, false otherwise
* @see #eq(LuaValue)
* @see #raweq(LuaUserdata)
* @see #raweq(LuaString)
@@ -2097,53 +2481,60 @@ public class LuaValue extends Varargs {
* @see #raweq(int)
* @see #EQ
*/
- public boolean raweq( LuaValue val ) { return this == val; }
-
- /** Equals: Perform direct equality comparison with a {@link LuaUserdata} value
- * without metatag processing.
+ public boolean raweq(LuaValue val) { return this == val; }
+
+ /**
+ * Equals: Perform direct equality comparison with a {@link LuaUserdata}
+ * value without metatag processing.
+ *
* @param val The {@link LuaUserdata} to compare with.
- * @return true if {@code this} is userdata
- * and their metatables are the same using ==
- * and their instances are equal using {@link #equals(Object)},
- * otherwise false
+ * @return true if {@code this} is userdata and their metatables are the
+ * same using == and their instances are equal using
+ * {@link #equals(Object)}, otherwise false
* @see #eq(LuaValue)
* @see #raweq(LuaValue)
*/
- public boolean raweq( LuaUserdata val ) { return false; }
+ public boolean raweq(LuaUserdata val) { return false; }
- /** Equals: Perform direct equality comparison with a {@link LuaString} value
+ /**
+ * Equals: Perform direct equality comparison with a {@link LuaString} value
* without metatag processing.
+ *
* @param val The {@link LuaString} to compare with.
- * @return true if {@code this} is a {@link LuaString}
- * and their byte sequences match,
- * otherwise false
+ * @return true if {@code this} is a {@link LuaString} and their byte
+ * sequences match, otherwise false
*/
- public boolean raweq( LuaString val ) { return false; }
+ public boolean raweq(LuaString val) { return false; }
- /** Equals: Perform direct equality comparison with a double value
- * without metatag processing.
+ /**
+ * Equals: Perform direct equality comparison with a double value without
+ * metatag processing.
+ *
* @param val The double value to compare with.
- * @return true if {@code this} is a {@link LuaNumber}
- * whose value equals val,
- * otherwise false
+ * @return true if {@code this} is a {@link LuaNumber} whose value equals
+ * val, otherwise false
*/
- public boolean raweq( double val ) { return false; }
+ public boolean raweq(double val) { return false; }
- /** Equals: Perform direct equality comparison with a int value
- * without metatag processing.
+ /**
+ * Equals: Perform direct equality comparison with a int value without
+ * metatag processing.
+ *
* @param val The double value to compare with.
- * @return true if {@code this} is a {@link LuaNumber}
- * whose value equals val,
- * otherwise false
+ * @return true if {@code this} is a {@link LuaNumber} whose value equals
+ * val, otherwise false
*/
- public boolean raweq( int val ) { return false; }
+ public boolean raweq(int val) { return false; }
- /** Perform equality testing metatag processing
- * @param lhs left-hand-side of equality expression
+ /**
+ * Perform equality testing metatag processing
+ *
+ * @param lhs left-hand-side of equality expression
* @param lhsmt metatag value for left-hand-side
- * @param rhs right-hand-side of equality expression
+ * @param rhs right-hand-side of equality expression
* @param rhsmt metatag value for right-hand-side
- * @return true if metatag processing result is not {@link #NIL} or {@link #FALSE}
+ * @return true if metatag processing result is not {@link #NIL} or
+ * {@link #FALSE}
* @throws LuaError if metatag was not defined for either operand
* @see #equals(Object)
* @see #eq(LuaValue)
@@ -2152,363 +2543,408 @@ public class LuaValue extends Varargs {
*/
public static final boolean eqmtcall(LuaValue lhs, LuaValue lhsmt, LuaValue rhs, LuaValue rhsmt) {
LuaValue h = lhsmt.rawget(EQ);
- return h.isnil() || h!=rhsmt.rawget(EQ)? false: h.call(lhs,rhs).toboolean();
+ return h.isnil() || h != rhsmt.rawget(EQ)? false: h.call(lhs, rhs).toboolean();
}
-
- /** Add: Perform numeric add operation with another value
- * including metatag processing.
+
+ /**
+ * Add: Perform numeric add operation with another value including metatag
+ * processing.
*
- * Each operand must derive from {@link LuaNumber}
- * or derive from {@link LuaString} and be convertible to a number
+ * Each operand must derive from {@link LuaNumber} or derive from
+ * {@link LuaString} and be convertible to a number
*
* @param rhs The right-hand-side value to perform the add with
- * @return value of {@code (this + rhs)} if both are numeric,
- * or {@link LuaValue} if metatag processing occurs
- * @throws LuaError if either operand is not a number or string convertible to number,
- * and neither has the {@link #ADD} metatag defined
+ * @return value of {@code (this + rhs)} if both are numeric, or
+ * {@link LuaValue} if metatag processing occurs
+ * @throws LuaError if either operand is not a number or string convertible
+ * to number, and neither has the {@link #ADD} metatag
+ * defined
* @see #arithmt(LuaValue, LuaValue)
*/
- public LuaValue add( LuaValue rhs ) { return arithmt(ADD,rhs); }
-
- /** Add: Perform numeric add operation with another value
- * of double type with metatag processing
+ public LuaValue add(LuaValue rhs) { return arithmt(ADD, rhs); }
+
+ /**
+ * Add: Perform numeric add operation with another value of double type with
+ * metatag processing
*
- * {@code this} must derive from {@link LuaNumber}
- * or derive from {@link LuaString} and be convertible to a number
+ * {@code this} must derive from {@link LuaNumber} or derive from
+ * {@link LuaString} and be convertible to a number
*
* @param rhs The right-hand-side value to perform the add with
- * @return value of {@code (this + rhs)} if this is numeric
- * @throws LuaError if {@code this} is not a number or string convertible to number
+ * @return value of {@code (this + rhs)} if this is numeric
+ * @throws LuaError if {@code this} is not a number or string convertible to
+ * number
* @see #add(LuaValue)
*/
- public LuaValue add(double rhs) { return arithmtwith(ADD,rhs); }
-
- /** Add: Perform numeric add operation with another value
- * of int type with metatag processing
+ public LuaValue add(double rhs) { return arithmtwith(ADD, rhs); }
+
+ /**
+ * Add: Perform numeric add operation with another value of int type with
+ * metatag processing
*
- * {@code this} must derive from {@link LuaNumber}
- * or derive from {@link LuaString} and be convertible to a number
+ * {@code this} must derive from {@link LuaNumber} or derive from
+ * {@link LuaString} and be convertible to a number
*
* @param rhs The right-hand-side value to perform the add with
- * @return value of {@code (this + rhs)} if this is numeric
- * @throws LuaError if {@code this} is not a number or string convertible to number
+ * @return value of {@code (this + rhs)} if this is numeric
+ * @throws LuaError if {@code this} is not a number or string convertible to
+ * number
* @see #add(LuaValue)
*/
- public LuaValue add(int rhs) { return add((double)rhs); }
-
- /** Subtract: Perform numeric subtract operation with another value
- * of unknown type,
- * including metatag processing.
+ public LuaValue add(int rhs) { return add((double) rhs); }
+
+ /**
+ * Subtract: Perform numeric subtract operation with another value of
+ * unknown type, including metatag processing.
*
- * Each operand must derive from {@link LuaNumber}
- * or derive from {@link LuaString} and be convertible to a number
+ * Each operand must derive from {@link LuaNumber} or derive from
+ * {@link LuaString} and be convertible to a number
*
* @param rhs The right-hand-side value to perform the subtract with
- * @return value of {@code (this - rhs)} if both are numeric,
- * or {@link LuaValue} if metatag processing occurs
- * @throws LuaError if either operand is not a number or string convertible to number,
- * and neither has the {@link #SUB} metatag defined
+ * @return value of {@code (this - rhs)} if both are numeric, or
+ * {@link LuaValue} if metatag processing occurs
+ * @throws LuaError if either operand is not a number or string convertible
+ * to number, and neither has the {@link #SUB} metatag
+ * defined
* @see #arithmt(LuaValue, LuaValue)
*/
- public LuaValue sub( LuaValue rhs ) { return arithmt(SUB,rhs); }
-
- /** Subtract: Perform numeric subtract operation with another value
- * of double type with metatag processing
+ public LuaValue sub(LuaValue rhs) { return arithmt(SUB, rhs); }
+
+ /**
+ * Subtract: Perform numeric subtract operation with another value of double
+ * type with metatag processing
*
- * {@code this} must derive from {@link LuaNumber}
- * or derive from {@link LuaString} and be convertible to a number
+ * {@code this} must derive from {@link LuaNumber} or derive from
+ * {@link LuaString} and be convertible to a number
*
* @param rhs The right-hand-side value to perform the subtract with
- * @return value of {@code (this - rhs)} if this is numeric
- * @throws LuaError if {@code this} is not a number or string convertible to number
+ * @return value of {@code (this - rhs)} if this is numeric
+ * @throws LuaError if {@code this} is not a number or string convertible to
+ * number
* @see #sub(LuaValue)
*/
- public LuaValue sub( double rhs ) { return aritherror("sub"); }
-
- /** Subtract: Perform numeric subtract operation with another value
- * of int type with metatag processing
+ public LuaValue sub(double rhs) { return aritherror("sub"); }
+
+ /**
+ * Subtract: Perform numeric subtract operation with another value of int
+ * type with metatag processing
*
- * {@code this} must derive from {@link LuaNumber}
- * or derive from {@link LuaString} and be convertible to a number
+ * {@code this} must derive from {@link LuaNumber} or derive from
+ * {@link LuaString} and be convertible to a number
*
* @param rhs The right-hand-side value to perform the subtract with
- * @return value of {@code (this - rhs)} if this is numeric
- * @throws LuaError if {@code this} is not a number or string convertible to number
+ * @return value of {@code (this - rhs)} if this is numeric
+ * @throws LuaError if {@code this} is not a number or string convertible to
+ * number
* @see #sub(LuaValue)
*/
- public LuaValue sub( int rhs ) { return aritherror("sub"); }
-
- /** Reverse-subtract: Perform numeric subtract operation from an int value
+ public LuaValue sub(int rhs) { return aritherror("sub"); }
+
+ /**
+ * Reverse-subtract: Perform numeric subtract operation from an int value
* with metatag processing
*
- * {@code this} must derive from {@link LuaNumber}
- * or derive from {@link LuaString} and be convertible to a number
+ * {@code this} must derive from {@link LuaNumber} or derive from
+ * {@link LuaString} and be convertible to a number
*
* @param lhs The left-hand-side value from which to perform the subtraction
- * @return value of {@code (lhs - this)} if this is numeric
- * @throws LuaError if {@code this} is not a number or string convertible to number
+ * @return value of {@code (lhs - this)} if this is numeric
+ * @throws LuaError if {@code this} is not a number or string convertible to
+ * number
* @see #sub(LuaValue)
* @see #sub(double)
* @see #sub(int)
*/
- public LuaValue subFrom(double lhs) { return arithmtwith(SUB,lhs); }
-
- /** Reverse-subtract: Perform numeric subtract operation from a double value
+ public LuaValue subFrom(double lhs) { return arithmtwith(SUB, lhs); }
+
+ /**
+ * Reverse-subtract: Perform numeric subtract operation from a double value
* without metatag processing
*
- * {@code this} must derive from {@link LuaNumber}
- * or derive from {@link LuaString} and be convertible to a number
+ * {@code this} must derive from {@link LuaNumber} or derive from
+ * {@link LuaString} and be convertible to a number
*
* For metatag processing {@link #sub(LuaValue)} must be used
*
* @param lhs The left-hand-side value from which to perform the subtraction
- * @return value of {@code (lhs - this)} if this is numeric
- * @throws LuaError if {@code this} is not a number or string convertible to number
+ * @return value of {@code (lhs - this)} if this is numeric
+ * @throws LuaError if {@code this} is not a number or string convertible to
+ * number
* @see #sub(LuaValue)
* @see #sub(double)
* @see #sub(int)
*/
- public LuaValue subFrom(int lhs) { return subFrom((double)lhs); }
-
- /** Multiply: Perform numeric multiply operation with another value
- * of unknown type,
- * including metatag processing.
+ public LuaValue subFrom(int lhs) { return subFrom((double) lhs); }
+
+ /**
+ * Multiply: Perform numeric multiply operation with another value of
+ * unknown type, including metatag processing.
*
- * Each operand must derive from {@link LuaNumber}
- * or derive from {@link LuaString} and be convertible to a number
+ * Each operand must derive from {@link LuaNumber} or derive from
+ * {@link LuaString} and be convertible to a number
*
* @param rhs The right-hand-side value to perform the multiply with
- * @return value of {@code (this * rhs)} if both are numeric,
- * or {@link LuaValue} if metatag processing occurs
- * @throws LuaError if either operand is not a number or string convertible to number,
- * and neither has the {@link #MUL} metatag defined
+ * @return value of {@code (this * rhs)} if both are numeric, or
+ * {@link LuaValue} if metatag processing occurs
+ * @throws LuaError if either operand is not a number or string convertible
+ * to number, and neither has the {@link #MUL} metatag
+ * defined
* @see #arithmt(LuaValue, LuaValue)
*/
- public LuaValue mul( LuaValue rhs ) { return arithmt(MUL,rhs); }
-
- /** Multiply: Perform numeric multiply operation with another value
- * of double type with metatag processing
+ public LuaValue mul(LuaValue rhs) { return arithmt(MUL, rhs); }
+
+ /**
+ * Multiply: Perform numeric multiply operation with another value of double
+ * type with metatag processing
*
- * {@code this} must derive from {@link LuaNumber}
- * or derive from {@link LuaString} and be convertible to a number
+ * {@code this} must derive from {@link LuaNumber} or derive from
+ * {@link LuaString} and be convertible to a number
*
* @param rhs The right-hand-side value to perform the multiply with
- * @return value of {@code (this * rhs)} if this is numeric
- * @throws LuaError if {@code this} is not a number or string convertible to number
+ * @return value of {@code (this * rhs)} if this is numeric
+ * @throws LuaError if {@code this} is not a number or string convertible to
+ * number
* @see #mul(LuaValue)
*/
- public LuaValue mul(double rhs) { return arithmtwith(MUL,rhs); }
-
- /** Multiply: Perform numeric multiply operation with another value
- * of int type with metatag processing
+ public LuaValue mul(double rhs) { return arithmtwith(MUL, rhs); }
+
+ /**
+ * Multiply: Perform numeric multiply operation with another value of int
+ * type with metatag processing
*
- * {@code this} must derive from {@link LuaNumber}
- * or derive from {@link LuaString} and be convertible to a number
+ * {@code this} must derive from {@link LuaNumber} or derive from
+ * {@link LuaString} and be convertible to a number
*
* @param rhs The right-hand-side value to perform the multiply with
- * @return value of {@code (this * rhs)} if this is numeric
- * @throws LuaError if {@code this} is not a number or string convertible to number
+ * @return value of {@code (this * rhs)} if this is numeric
+ * @throws LuaError if {@code this} is not a number or string convertible to
+ * number
* @see #mul(LuaValue)
*/
- public LuaValue mul(int rhs) { return mul((double)rhs); }
-
- /** Raise to power: Raise this value to a power
- * including metatag processing.
+ public LuaValue mul(int rhs) { return mul((double) rhs); }
+
+ /**
+ * Raise to power: Raise this value to a power including metatag processing.
*
- * Each operand must derive from {@link LuaNumber}
- * or derive from {@link LuaString} and be convertible to a number
+ * Each operand must derive from {@link LuaNumber} or derive from
+ * {@link LuaString} and be convertible to a number
*
* @param rhs The power to raise this value to
- * @return value of {@code (this ^ rhs)} if both are numeric,
- * or {@link LuaValue} if metatag processing occurs
- * @throws LuaError if either operand is not a number or string convertible to number,
- * and neither has the {@link #POW} metatag defined
+ * @return value of {@code (this ^ rhs)} if both are numeric, or
+ * {@link LuaValue} if metatag processing occurs
+ * @throws LuaError if either operand is not a number or string convertible
+ * to number, and neither has the {@link #POW} metatag
+ * defined
* @see #arithmt(LuaValue, LuaValue)
*/
- public LuaValue pow( LuaValue rhs ) { return arithmt(POW,rhs); }
-
- /** Raise to power: Raise this value to a power
- * of double type with metatag processing
+ public LuaValue pow(LuaValue rhs) { return arithmt(POW, rhs); }
+
+ /**
+ * Raise to power: Raise this value to a power of double type with metatag
+ * processing
*
- * {@code this} must derive from {@link LuaNumber}
- * or derive from {@link LuaString} and be convertible to a number
+ * {@code this} must derive from {@link LuaNumber} or derive from
+ * {@link LuaString} and be convertible to a number
*
* @param rhs The power to raise this value to
- * @return value of {@code (this ^ rhs)} if this is numeric
- * @throws LuaError if {@code this} is not a number or string convertible to number
+ * @return value of {@code (this ^ rhs)} if this is numeric
+ * @throws LuaError if {@code this} is not a number or string convertible to
+ * number
* @see #pow(LuaValue)
*/
- public LuaValue pow( double rhs ) { return aritherror("pow"); }
-
- /** Raise to power: Raise this value to a power
- * of int type with metatag processing
+ public LuaValue pow(double rhs) { return aritherror("pow"); }
+
+ /**
+ * Raise to power: Raise this value to a power of int type with metatag
+ * processing
*
- * {@code this} must derive from {@link LuaNumber}
- * or derive from {@link LuaString} and be convertible to a number
+ * {@code this} must derive from {@link LuaNumber} or derive from
+ * {@link LuaString} and be convertible to a number
*
* @param rhs The power to raise this value to
- * @return value of {@code (this ^ rhs)} if this is numeric
- * @throws LuaError if {@code this} is not a number or string convertible to number
+ * @return value of {@code (this ^ rhs)} if this is numeric
+ * @throws LuaError if {@code this} is not a number or string convertible to
+ * number
* @see #pow(LuaValue)
*/
- public LuaValue pow( int rhs ) { return aritherror("pow"); }
-
- /** Reverse-raise to power: Raise another value of double type to this power
+ public LuaValue pow(int rhs) { return aritherror("pow"); }
+
+ /**
+ * Reverse-raise to power: Raise another value of double type to this power
* with metatag processing
*
- * {@code this} must derive from {@link LuaNumber}
- * or derive from {@link LuaString} and be convertible to a number
+ * {@code this} must derive from {@link LuaNumber} or derive from
+ * {@link LuaString} and be convertible to a number
*
* @param lhs The left-hand-side value which will be raised to this power
- * @return value of {@code (lhs ^ this)} if this is numeric
- * @throws LuaError if {@code this} is not a number or string convertible to number
+ * @return value of {@code (lhs ^ this)} if this is numeric
+ * @throws LuaError if {@code this} is not a number or string convertible to
+ * number
* @see #pow(LuaValue)
* @see #pow(double)
* @see #pow(int)
*/
- public LuaValue powWith(double lhs) { return arithmtwith(POW,lhs); }
-
- /** Reverse-raise to power: Raise another value of double type to this power
+ public LuaValue powWith(double lhs) { return arithmtwith(POW, lhs); }
+
+ /**
+ * Reverse-raise to power: Raise another value of double type to this power
* with metatag processing
*
- * {@code this} must derive from {@link LuaNumber}
- * or derive from {@link LuaString} and be convertible to a number
+ * {@code this} must derive from {@link LuaNumber} or derive from
+ * {@link LuaString} and be convertible to a number
*
* @param lhs The left-hand-side value which will be raised to this power
- * @return value of {@code (lhs ^ this)} if this is numeric
- * @throws LuaError if {@code this} is not a number or string convertible to number
+ * @return value of {@code (lhs ^ this)} if this is numeric
+ * @throws LuaError if {@code this} is not a number or string convertible to
+ * number
* @see #pow(LuaValue)
* @see #pow(double)
* @see #pow(int)
*/
- public LuaValue powWith(int lhs) { return powWith((double)lhs); }
-
- /** Divide: Perform numeric divide operation by another value
- * of unknown type,
- * including metatag processing.
+ public LuaValue powWith(int lhs) { return powWith((double) lhs); }
+
+ /**
+ * Divide: Perform numeric divide operation by another value of unknown
+ * type, including metatag processing.
*
- * Each operand must derive from {@link LuaNumber}
- * or derive from {@link LuaString} and be convertible to a number
+ * Each operand must derive from {@link LuaNumber} or derive from
+ * {@link LuaString} and be convertible to a number
*
* @param rhs The right-hand-side value to perform the divulo with
- * @return value of {@code (this / rhs)} if both are numeric,
- * or {@link LuaValue} if metatag processing occurs
- * @throws LuaError if either operand is not a number or string convertible to number,
- * and neither has the {@link #DIV} metatag defined
+ * @return value of {@code (this / rhs)} if both are numeric, or
+ * {@link LuaValue} if metatag processing occurs
+ * @throws LuaError if either operand is not a number or string convertible
+ * to number, and neither has the {@link #DIV} metatag
+ * defined
* @see #arithmt(LuaValue, LuaValue)
*/
- public LuaValue div( LuaValue rhs ) { return arithmt(DIV,rhs); }
-
- /** Divide: Perform numeric divide operation by another value
- * of double type without metatag processing
+ public LuaValue div(LuaValue rhs) { return arithmt(DIV, rhs); }
+
+ /**
+ * Divide: Perform numeric divide operation by another value of double type
+ * without metatag processing
*
- * {@code this} must derive from {@link LuaNumber}
- * or derive from {@link LuaString} and be convertible to a number
+ * {@code this} must derive from {@link LuaNumber} or derive from
+ * {@link LuaString} and be convertible to a number
*
* For metatag processing {@link #div(LuaValue)} must be used
*
* @param rhs The right-hand-side value to perform the divulo with
- * @return value of {@code (this / rhs)} if this is numeric
- * @throws LuaError if {@code this} is not a number or string convertible to number
+ * @return value of {@code (this / rhs)} if this is numeric
+ * @throws LuaError if {@code this} is not a number or string convertible to
+ * number
* @see #div(LuaValue)
*/
- public LuaValue div( double rhs ) { return aritherror("div"); }
-
- /** Divide: Perform numeric divide operation by another value
- * of int type without metatag processing
+ public LuaValue div(double rhs) { return aritherror("div"); }
+
+ /**
+ * Divide: Perform numeric divide operation by another value of int type
+ * without metatag processing
*
- * {@code this} must derive from {@link LuaNumber}
- * or derive from {@link LuaString} and be convertible to a number
+ * {@code this} must derive from {@link LuaNumber} or derive from
+ * {@link LuaString} and be convertible to a number
*
* For metatag processing {@link #div(LuaValue)} must be used
*
* @param rhs The right-hand-side value to perform the divulo with
- * @return value of {@code (this / rhs)} if this is numeric
- * @throws LuaError if {@code this} is not a number or string convertible to number
+ * @return value of {@code (this / rhs)} if this is numeric
+ * @throws LuaError if {@code this} is not a number or string convertible to
+ * number
* @see #div(LuaValue)
*/
- public LuaValue div( int rhs ) { return aritherror("div"); }
-
- /** Reverse-divide: Perform numeric divide operation into another value
- * with metatag processing
+ public LuaValue div(int rhs) { return aritherror("div"); }
+
+ /**
+ * Reverse-divide: Perform numeric divide operation into another value with
+ * metatag processing
*
- * {@code this} must derive from {@link LuaNumber}
- * or derive from {@link LuaString} and be convertible to a number
+ * {@code this} must derive from {@link LuaNumber} or derive from
+ * {@link LuaString} and be convertible to a number
*
* @param lhs The left-hand-side value which will be divided by this
- * @return value of {@code (lhs / this)} if this is numeric
- * @throws LuaError if {@code this} is not a number or string convertible to number
+ * @return value of {@code (lhs / this)} if this is numeric
+ * @throws LuaError if {@code this} is not a number or string convertible to
+ * number
* @see #div(LuaValue)
* @see #div(double)
* @see #div(int)
*/
- public LuaValue divInto(double lhs) { return arithmtwith(DIV,lhs); }
-
- /** Modulo: Perform numeric modulo operation with another value
- * of unknown type,
- * including metatag processing.
+ public LuaValue divInto(double lhs) { return arithmtwith(DIV, lhs); }
+
+ /**
+ * Modulo: Perform numeric modulo operation with another value of unknown
+ * type, including metatag processing.
*
- * Each operand must derive from {@link LuaNumber}
- * or derive from {@link LuaString} and be convertible to a number
+ * Each operand must derive from {@link LuaNumber} or derive from
+ * {@link LuaString} and be convertible to a number
*
* @param rhs The right-hand-side value to perform the modulo with
- * @return value of {@code (this % rhs)} if both are numeric,
- * or {@link LuaValue} if metatag processing occurs
- * @throws LuaError if either operand is not a number or string convertible to number,
- * and neither has the {@link #MOD} metatag defined
+ * @return value of {@code (this % rhs)} if both are numeric, or
+ * {@link LuaValue} if metatag processing occurs
+ * @throws LuaError if either operand is not a number or string convertible
+ * to number, and neither has the {@link #MOD} metatag
+ * defined
* @see #arithmt(LuaValue, LuaValue)
*/
- public LuaValue mod( LuaValue rhs ) { return arithmt(MOD,rhs); }
-
- /** Modulo: Perform numeric modulo operation with another value
- * of double type without metatag processing
+ public LuaValue mod(LuaValue rhs) { return arithmt(MOD, rhs); }
+
+ /**
+ * Modulo: Perform numeric modulo operation with another value of double
+ * type without metatag processing
*
- * {@code this} must derive from {@link LuaNumber}
- * or derive from {@link LuaString} and be convertible to a number
+ * {@code this} must derive from {@link LuaNumber} or derive from
+ * {@link LuaString} and be convertible to a number
*
* For metatag processing {@link #mod(LuaValue)} must be used
*
* @param rhs The right-hand-side value to perform the modulo with
- * @return value of {@code (this % rhs)} if this is numeric
- * @throws LuaError if {@code this} is not a number or string convertible to number
+ * @return value of {@code (this % rhs)} if this is numeric
+ * @throws LuaError if {@code this} is not a number or string convertible to
+ * number
* @see #mod(LuaValue)
*/
- public LuaValue mod( double rhs ) { return aritherror("mod"); }
-
- /** Modulo: Perform numeric modulo operation with another value
- * of int type without metatag processing
+ public LuaValue mod(double rhs) { return aritherror("mod"); }
+
+ /**
+ * Modulo: Perform numeric modulo operation with another value of int type
+ * without metatag processing
*
- * {@code this} must derive from {@link LuaNumber}
- * or derive from {@link LuaString} and be convertible to a number
+ * {@code this} must derive from {@link LuaNumber} or derive from
+ * {@link LuaString} and be convertible to a number
*
* For metatag processing {@link #mod(LuaValue)} must be used
*
* @param rhs The right-hand-side value to perform the modulo with
- * @return value of {@code (this % rhs)} if this is numeric
- * @throws LuaError if {@code this} is not a number or string convertible to number
+ * @return value of {@code (this % rhs)} if this is numeric
+ * @throws LuaError if {@code this} is not a number or string convertible to
+ * number
* @see #mod(LuaValue)
*/
- public LuaValue mod( int rhs ) { return aritherror("mod"); }
-
- /** Reverse-modulo: Perform numeric modulo operation from another value
- * with metatag processing
+ public LuaValue mod(int rhs) { return aritherror("mod"); }
+
+ /**
+ * Reverse-modulo: Perform numeric modulo operation from another value with
+ * metatag processing
*
- * {@code this} must derive from {@link LuaNumber}
- * or derive from {@link LuaString} and be convertible to a number
+ * {@code this} must derive from {@link LuaNumber} or derive from
+ * {@link LuaString} and be convertible to a number
*
* @param lhs The left-hand-side value which will be modulo'ed by this
- * @return value of {@code (lhs % this)} if this is numeric
- * @throws LuaError if {@code this} is not a number or string convertible to number
+ * @return value of {@code (lhs % this)} if this is numeric
+ * @throws LuaError if {@code this} is not a number or string convertible to
+ * number
* @see #mod(LuaValue)
* @see #mod(double)
* @see #mod(int)
*/
- public LuaValue modFrom(double lhs) { return arithmtwith(MOD,lhs); }
-
- /** Perform metatag processing for arithmetic operations.
+ public LuaValue modFrom(double lhs) { return arithmtwith(MOD, lhs); }
+
+ /**
+ * Perform metatag processing for arithmetic operations.
*
- * Finds the supplied metatag value for {@code this} or {@code op2} and invokes it,
- * or throws {@link LuaError} if neither is defined.
+ * Finds the supplied metatag value for {@code this} or {@code op2} and
+ * invokes it, or throws {@link LuaError} if neither is defined.
+ *
* @param tag The metatag to look up
* @param op2 The other operand value to perform the operation with
* @return {@link LuaValue} resulting from metatag processing
@@ -2528,18 +2964,21 @@ public class LuaValue extends Varargs {
*/
protected LuaValue arithmt(LuaValue tag, LuaValue op2) {
LuaValue h = this.metatag(tag);
- if ( h.isnil() ) {
+ if (h.isnil()) {
h = op2.metatag(tag);
- if ( h.isnil() )
- error( "attempt to perform arithmetic "+tag+" on "+typename()+" and "+op2.typename() );
+ if (h.isnil())
+ error("attempt to perform arithmetic " + tag + " on " + typename() + " and " + op2.typename());
}
- return h.call( this, op2 );
+ return h.call(this, op2);
}
-
- /** Perform metatag processing for arithmetic operations when the left-hand-side is a number.
+
+ /**
+ * Perform metatag processing for arithmetic operations when the
+ * left-hand-side is a number.
*
- * Finds the supplied metatag value for {@code this} and invokes it,
- * or throws {@link LuaError} if neither is defined.
+ * Finds the supplied metatag value for {@code this} and invokes it, or
+ * throws {@link LuaError} if neither is defined.
+ *
* @param tag The metatag to look up
* @param op1 The value of the left-hand-side to perform the operation with
* @return {@link LuaValue} resulting from metatag processing
@@ -2559,734 +2998,827 @@ public class LuaValue extends Varargs {
*/
protected LuaValue arithmtwith(LuaValue tag, double op1) {
LuaValue h = metatag(tag);
- if ( h.isnil() )
- error( "attempt to perform arithmetic "+tag+" on number and "+typename() );
- return h.call( LuaValue.valueOf(op1), this );
+ if (h.isnil())
+ error("attempt to perform arithmetic " + tag + " on number and " + typename());
+ return h.call(LuaValue.valueOf(op1), this);
}
-
- /** Less than: Perform numeric or string comparison with another value
- * of unknown type,
- * including metatag processing, and returning {@link LuaValue}.
+
+ /**
+ * Less than: Perform numeric or string comparison with another value of
+ * unknown type, including metatag processing, and returning
+ * {@link LuaValue}.
*
- * To be comparable, both operands must derive from {@link LuaString}
- * or both must derive from {@link LuaNumber}.
+ * To be comparable, both operands must derive from {@link LuaString} or
+ * both must derive from {@link LuaNumber}.
*
* @param rhs The right-hand-side value to perform the comparison with
- * @return {@link #TRUE} if {@code (this < rhs)}, {@link #FALSE} if not,
- * or {@link LuaValue} if metatag processing occurs
- * @throws LuaError if either both operands are not a strings or both are not numbers
- * and no {@link #LT} metatag is defined.
+ * @return {@link #TRUE} if {@code (this < rhs)}, {@link #FALSE} if not, or
+ * {@link LuaValue} if metatag processing occurs
+ * @throws LuaError if either both operands are not a strings or both are
+ * not numbers and no {@link #LT} metatag is defined.
* @see #gteq_b(LuaValue)
* @see #comparemt(LuaValue, LuaValue)
*/
- public LuaValue lt( LuaValue rhs ) { return comparemt(LT,rhs); }
+ public LuaValue lt(LuaValue rhs) { return comparemt(LT, rhs); }
- /** Less than: Perform numeric comparison with another value
- * of double type,
+ /**
+ * Less than: Perform numeric comparison with another value of double type,
* including metatag processing, and returning {@link LuaValue}.
*
* To be comparable, this must derive from {@link LuaNumber}.
*
* @param rhs The right-hand-side value to perform the comparison with
- * @return {@link #TRUE} if {@code (this < rhs)}, {@link #FALSE} if not,
- * or {@link LuaValue} if metatag processing occurs
- * @throws LuaError if this is not a number
- * and no {@link #LT} metatag is defined.
+ * @return {@link #TRUE} if {@code (this < rhs)}, {@link #FALSE} if not, or
+ * {@link LuaValue} if metatag processing occurs
+ * @throws LuaError if this is not a number and no {@link #LT} metatag is
+ * defined.
* @see #gteq_b(double)
* @see #comparemt(LuaValue, LuaValue)
*/
- public LuaValue lt( double rhs ) { return compareerror("number"); }
+ public LuaValue lt(double rhs) { return compareerror("number"); }
- /** Less than: Perform numeric comparison with another value
- * of int type,
+ /**
+ * Less than: Perform numeric comparison with another value of int type,
* including metatag processing, and returning {@link LuaValue}.
*
* To be comparable, this must derive from {@link LuaNumber}.
*
* @param rhs The right-hand-side value to perform the comparison with
- * @return {@link #TRUE} if {@code (this < rhs)}, {@link #FALSE} if not,
- * or {@link LuaValue} if metatag processing occurs
- * @throws LuaError if this is not a number
- * and no {@link #LT} metatag is defined.
+ * @return {@link #TRUE} if {@code (this < rhs)}, {@link #FALSE} if not, or
+ * {@link LuaValue} if metatag processing occurs
+ * @throws LuaError if this is not a number and no {@link #LT} metatag is
+ * defined.
* @see #gteq_b(int)
* @see #comparemt(LuaValue, LuaValue)
*/
- public LuaValue lt( int rhs ) { return compareerror("number"); }
+ public LuaValue lt(int rhs) { return compareerror("number"); }
- /** Less than: Perform numeric or string comparison with another value
- * of unknown type, including metatag processing,
- * and returning java boolean.
+ /**
+ * Less than: Perform numeric or string comparison with another value of
+ * unknown type, including metatag processing, and returning java boolean.
*
- * To be comparable, both operands must derive from {@link LuaString}
- * or both must derive from {@link LuaNumber}.
+ * To be comparable, both operands must derive from {@link LuaString} or
+ * both must derive from {@link LuaNumber}.
*
* @param rhs The right-hand-side value to perform the comparison with
- * @return true if {@code (this < rhs)}, false if not,
- * and boolean interpreation of result if metatag processing occurs.
- * @throws LuaError if either both operands are not a strings or both are not numbers
- * and no {@link #LT} metatag is defined.
+ * @return true if {@code (this < rhs)}, false if not, and boolean
+ * interpreation of result if metatag processing occurs.
+ * @throws LuaError if either both operands are not a strings or both are
+ * not numbers and no {@link #LT} metatag is defined.
* @see #gteq(LuaValue)
* @see #comparemt(LuaValue, LuaValue)
*/
- public boolean lt_b( LuaValue rhs ) { return comparemt(LT,rhs).toboolean(); }
+ public boolean lt_b(LuaValue rhs) { return comparemt(LT, rhs).toboolean(); }
- /** Less than: Perform numeric comparison with another value
- * of int type,
- * including metatag processing,
- * and returning java boolean.
+ /**
+ * Less than: Perform numeric comparison with another value of int type,
+ * including metatag processing, and returning java boolean.
*
* To be comparable, this must derive from {@link LuaNumber}.
*
* @param rhs The right-hand-side value to perform the comparison with
- * @return true if {@code (this < rhs)}, false if not,
- * and boolean interpreation of result if metatag processing occurs.
- * @throws LuaError if this is not a number
- * and no {@link #LT} metatag is defined.
+ * @return true if {@code (this < rhs)}, false if not, and boolean
+ * interpreation of result if metatag processing occurs.
+ * @throws LuaError if this is not a number and no {@link #LT} metatag is
+ * defined.
* @see #gteq(int)
* @see #comparemt(LuaValue, LuaValue)
*/
- public boolean lt_b( int rhs ) { compareerror("number"); return false; }
+ public boolean lt_b(int rhs) { compareerror("number"); return false; }
- /** Less than: Perform numeric or string comparison with another value
- * of unknown type, including metatag processing,
- * and returning java boolean.
+ /**
+ * Less than: Perform numeric or string comparison with another value of
+ * unknown type, including metatag processing, and returning java boolean.
*
- * To be comparable, both operands must derive from {@link LuaString}
- * or both must derive from {@link LuaNumber}.
+ * To be comparable, both operands must derive from {@link LuaString} or
+ * both must derive from {@link LuaNumber}.
*
* @param rhs The right-hand-side value to perform the comparison with
- * @return true if {@code (this < rhs)}, false if not,
- * and boolean interpreation of result if metatag processing occurs.
- * @throws LuaError if either both operands are not a strings or both are not numbers
- * and no {@link #LT} metatag is defined.
+ * @return true if {@code (this < rhs)}, false if not, and boolean
+ * interpreation of result if metatag processing occurs.
+ * @throws LuaError if either both operands are not a strings or both are
+ * not numbers and no {@link #LT} metatag is defined.
* @see #gteq(LuaValue)
* @see #comparemt(LuaValue, LuaValue)
*/
- public boolean lt_b( double rhs ) { compareerror("number"); return false; }
+ public boolean lt_b(double rhs) { compareerror("number"); return false; }
- /** Less than or equals: Perform numeric or string comparison with another value
- * of unknown type,
- * including metatag processing, and returning {@link LuaValue}.
+ /**
+ * Less than or equals: Perform numeric or string comparison with another
+ * value of unknown type, including metatag processing, and returning
+ * {@link LuaValue}.
*
- * To be comparable, both operands must derive from {@link LuaString}
- * or both must derive from {@link LuaNumber}.
+ * To be comparable, both operands must derive from {@link LuaString} or
+ * both must derive from {@link LuaNumber}.
*
* @param rhs The right-hand-side value to perform the comparison with
- * @return {@link #TRUE} if {@code (this <= rhs)}, {@link #FALSE} if not,
- * or {@link LuaValue} if metatag processing occurs
- * @throws LuaError if either both operands are not a strings or both are not numbers
- * and no {@link #LE} metatag is defined.
+ * @return {@link #TRUE} if {@code (this <= rhs)}, {@link #FALSE} if not, or
+ * {@link LuaValue} if metatag processing occurs
+ * @throws LuaError if either both operands are not a strings or both are
+ * not numbers and no {@link #LE} metatag is defined.
* @see #gteq_b(LuaValue)
* @see #comparemt(LuaValue, LuaValue)
*/
- public LuaValue lteq( LuaValue rhs ) { return comparemt(LE,rhs); }
+ public LuaValue lteq(LuaValue rhs) { return comparemt(LE, rhs); }
- /** Less than or equals: Perform numeric comparison with another value
- * of double type,
- * including metatag processing, and returning {@link LuaValue}.
+ /**
+ * Less than or equals: Perform numeric comparison with another value of
+ * double type, including metatag processing, and returning
+ * {@link LuaValue}.
*
* To be comparable, this must derive from {@link LuaNumber}.
*
* @param rhs The right-hand-side value to perform the comparison with
- * @return {@link #TRUE} if {@code (this <= rhs)}, {@link #FALSE} if not,
- * or {@link LuaValue} if metatag processing occurs
- * @throws LuaError if this is not a number
- * and no {@link #LE} metatag is defined.
+ * @return {@link #TRUE} if {@code (this <= rhs)}, {@link #FALSE} if not, or
+ * {@link LuaValue} if metatag processing occurs
+ * @throws LuaError if this is not a number and no {@link #LE} metatag is
+ * defined.
* @see #gteq_b(double)
* @see #comparemt(LuaValue, LuaValue)
*/
- public LuaValue lteq( double rhs ) { return compareerror("number"); }
+ public LuaValue lteq(double rhs) { return compareerror("number"); }
- /** Less than or equals: Perform numeric comparison with another value
- * of int type,
- * including metatag processing, and returning {@link LuaValue}.
+ /**
+ * Less than or equals: Perform numeric comparison with another value of int
+ * type, including metatag processing, and returning {@link LuaValue}.
*
* To be comparable, this must derive from {@link LuaNumber}.
*
* @param rhs The right-hand-side value to perform the comparison with
- * @return {@link #TRUE} if {@code (this <= rhs)}, {@link #FALSE} if not,
- * or {@link LuaValue} if metatag processing occurs
- * @throws LuaError if this is not a number
- * and no {@link #LE} metatag is defined.
+ * @return {@link #TRUE} if {@code (this <= rhs)}, {@link #FALSE} if not, or
+ * {@link LuaValue} if metatag processing occurs
+ * @throws LuaError if this is not a number and no {@link #LE} metatag is
+ * defined.
* @see #gteq_b(int)
* @see #comparemt(LuaValue, LuaValue)
*/
- public LuaValue lteq( int rhs ) { return compareerror("number"); }
+ public LuaValue lteq(int rhs) { return compareerror("number"); }
- /** Less than or equals: Perform numeric or string comparison with another value
- * of unknown type, including metatag processing,
- * and returning java boolean.
+ /**
+ * Less than or equals: Perform numeric or string comparison with another
+ * value of unknown type, including metatag processing, and returning java
+ * boolean.
*
- * To be comparable, both operands must derive from {@link LuaString}
- * or both must derive from {@link LuaNumber}.
+ * To be comparable, both operands must derive from {@link LuaString} or
+ * both must derive from {@link LuaNumber}.
*
* @param rhs The right-hand-side value to perform the comparison with
- * @return true if {@code (this <= rhs)}, false if not,
- * and boolean interpreation of result if metatag processing occurs.
- * @throws LuaError if either both operands are not a strings or both are not numbers
- * and no {@link #LE} metatag is defined.
+ * @return true if {@code (this <= rhs)}, false if not, and boolean
+ * interpreation of result if metatag processing occurs.
+ * @throws LuaError if either both operands are not a strings or both are
+ * not numbers and no {@link #LE} metatag is defined.
* @see #gteq(LuaValue)
* @see #comparemt(LuaValue, LuaValue)
*/
- public boolean lteq_b( LuaValue rhs ) { return comparemt(LE,rhs).toboolean(); }
+ public boolean lteq_b(LuaValue rhs) { return comparemt(LE, rhs).toboolean(); }
- /** Less than or equals: Perform numeric comparison with another value
- * of int type,
- * including metatag processing,
- * and returning java boolean.
+ /**
+ * Less than or equals: Perform numeric comparison with another value of int
+ * type, including metatag processing, and returning java boolean.
*
* To be comparable, this must derive from {@link LuaNumber}.
*
* @param rhs The right-hand-side value to perform the comparison with
- * @return true if {@code (this <= rhs)}, false if not,
- * and boolean interpreation of result if metatag processing occurs.
- * @throws LuaError if this is not a number
- * and no {@link #LE} metatag is defined.
+ * @return true if {@code (this <= rhs)}, false if not, and boolean
+ * interpreation of result if metatag processing occurs.
+ * @throws LuaError if this is not a number and no {@link #LE} metatag is
+ * defined.
* @see #gteq(int)
* @see #comparemt(LuaValue, LuaValue)
*/
- public boolean lteq_b( int rhs ) { compareerror("number"); return false; }
+ public boolean lteq_b(int rhs) { compareerror("number"); return false; }
- /** Less than or equals: Perform numeric comparison with another value
- * of double type,
- * including metatag processing,
- * and returning java boolean.
+ /**
+ * Less than or equals: Perform numeric comparison with another value of
+ * double type, including metatag processing, and returning java boolean.
*
* To be comparable, this must derive from {@link LuaNumber}.
*
* @param rhs The right-hand-side value to perform the comparison with
- * @return true if {@code (this <= rhs)}, false if not,
- * and boolean interpreation of result if metatag processing occurs.
- * @throws LuaError if this is not a number
- * and no {@link #LE} metatag is defined.
+ * @return true if {@code (this <= rhs)}, false if not, and boolean
+ * interpreation of result if metatag processing occurs.
+ * @throws LuaError if this is not a number and no {@link #LE} metatag is
+ * defined.
* @see #gteq(double)
* @see #comparemt(LuaValue, LuaValue)
*/
- public boolean lteq_b( double rhs ) { compareerror("number"); return false; }
+ public boolean lteq_b(double rhs) { compareerror("number"); return false; }
- /** Greater than: Perform numeric or string comparison with another value
- * of unknown type,
- * including metatag processing, and returning {@link LuaValue}.
+ /**
+ * Greater than: Perform numeric or string comparison with another value of
+ * unknown type, including metatag processing, and returning
+ * {@link LuaValue}.
*
- * To be comparable, both operands must derive from {@link LuaString}
- * or both must derive from {@link LuaNumber}.
+ * To be comparable, both operands must derive from {@link LuaString} or
+ * both must derive from {@link LuaNumber}.
*
* @param rhs The right-hand-side value to perform the comparison with
- * @return {@link #TRUE} if {@code (this > rhs)}, {@link #FALSE} if not,
- * or {@link LuaValue} if metatag processing occurs
- * @throws LuaError if either both operands are not a strings or both are not numbers
- * and no {@link #LE} metatag is defined.
+ * @return {@link #TRUE} if {@code (this > rhs)}, {@link #FALSE} if not, or
+ * {@link LuaValue} if metatag processing occurs
+ * @throws LuaError if either both operands are not a strings or both are
+ * not numbers and no {@link #LE} metatag is defined.
* @see #gteq_b(LuaValue)
* @see #comparemt(LuaValue, LuaValue)
*/
- public LuaValue gt( LuaValue rhs ) { return rhs.comparemt(LE,this); }
+ public LuaValue gt(LuaValue rhs) { return rhs.comparemt(LE, this); }
- /** Greater than: Perform numeric comparison with another value
- * of double type,
- * including metatag processing, and returning {@link LuaValue}.
+ /**
+ * Greater than: Perform numeric comparison with another value of double
+ * type, including metatag processing, and returning {@link LuaValue}.
*
* To be comparable, this must derive from {@link LuaNumber}.
*
* @param rhs The right-hand-side value to perform the comparison with
- * @return {@link #TRUE} if {@code (this > rhs)}, {@link #FALSE} if not,
- * or {@link LuaValue} if metatag processing occurs
- * @throws LuaError if this is not a number
- * and no {@link #LE} metatag is defined.
+ * @return {@link #TRUE} if {@code (this > rhs)}, {@link #FALSE} if not, or
+ * {@link LuaValue} if metatag processing occurs
+ * @throws LuaError if this is not a number and no {@link #LE} metatag is
+ * defined.
* @see #gteq_b(double)
* @see #comparemt(LuaValue, LuaValue)
*/
- public LuaValue gt( double rhs ) { return compareerror("number"); }
+ public LuaValue gt(double rhs) { return compareerror("number"); }
- /** Greater than: Perform numeric comparison with another value
- * of int type,
+ /**
+ * Greater than: Perform numeric comparison with another value of int type,
* including metatag processing, and returning {@link LuaValue}.
*
* To be comparable, this must derive from {@link LuaNumber}.
*
* @param rhs The right-hand-side value to perform the comparison with
- * @return {@link #TRUE} if {@code (this > rhs)}, {@link #FALSE} if not,
- * or {@link LuaValue} if metatag processing occurs
- * @throws LuaError if this is not a number
- * and no {@link #LE} metatag is defined.
+ * @return {@link #TRUE} if {@code (this > rhs)}, {@link #FALSE} if not, or
+ * {@link LuaValue} if metatag processing occurs
+ * @throws LuaError if this is not a number and no {@link #LE} metatag is
+ * defined.
* @see #gteq_b(int)
* @see #comparemt(LuaValue, LuaValue)
*/
- public LuaValue gt( int rhs ) { return compareerror("number"); }
+ public LuaValue gt(int rhs) { return compareerror("number"); }
- /** Greater than: Perform numeric or string comparison with another value
- * of unknown type, including metatag processing,
- * and returning java boolean.
+ /**
+ * Greater than: Perform numeric or string comparison with another value of
+ * unknown type, including metatag processing, and returning java boolean.
*
- * To be comparable, both operands must derive from {@link LuaString}
- * or both must derive from {@link LuaNumber}.
+ * To be comparable, both operands must derive from {@link LuaString} or
+ * both must derive from {@link LuaNumber}.
*
* @param rhs The right-hand-side value to perform the comparison with
- * @return true if {@code (this > rhs)}, false if not,
- * and boolean interpreation of result if metatag processing occurs.
- * @throws LuaError if either both operands are not a strings or both are not numbers
- * and no {@link #LE} metatag is defined.
+ * @return true if {@code (this > rhs)}, false if not, and boolean
+ * interpreation of result if metatag processing occurs.
+ * @throws LuaError if either both operands are not a strings or both are
+ * not numbers and no {@link #LE} metatag is defined.
* @see #gteq(LuaValue)
* @see #comparemt(LuaValue, LuaValue)
*/
- public boolean gt_b( LuaValue rhs ) { return rhs.comparemt(LE,this).toboolean(); }
+ public boolean gt_b(LuaValue rhs) { return rhs.comparemt(LE, this).toboolean(); }
- /** Greater than: Perform numeric comparison with another value
- * of int type,
- * including metatag processing,
- * and returning java boolean.
+ /**
+ * Greater than: Perform numeric comparison with another value of int type,
+ * including metatag processing, and returning java boolean.
*
* To be comparable, this must derive from {@link LuaNumber}.
*
* @param rhs The right-hand-side value to perform the comparison with
- * @return true if {@code (this > rhs)}, false if not,
- * and boolean interpreation of result if metatag processing occurs.
- * @throws LuaError if this is not a number
- * and no {@link #LE} metatag is defined.
+ * @return true if {@code (this > rhs)}, false if not, and boolean
+ * interpreation of result if metatag processing occurs.
+ * @throws LuaError if this is not a number and no {@link #LE} metatag is
+ * defined.
* @see #gteq(int)
* @see #comparemt(LuaValue, LuaValue)
*/
- public boolean gt_b( int rhs ) { compareerror("number"); return false; }
+ public boolean gt_b(int rhs) { compareerror("number"); return false; }
- /** Greater than: Perform numeric or string comparison with another value
- * of unknown type, including metatag processing,
- * and returning java boolean.
+ /**
+ * Greater than: Perform numeric or string comparison with another value of
+ * unknown type, including metatag processing, and returning java boolean.
*
- * To be comparable, both operands must derive from {@link LuaString}
- * or both must derive from {@link LuaNumber}.
+ * To be comparable, both operands must derive from {@link LuaString} or
+ * both must derive from {@link LuaNumber}.
*
* @param rhs The right-hand-side value to perform the comparison with
- * @return true if {@code (this > rhs)}, false if not,
- * and boolean interpreation of result if metatag processing occurs.
- * @throws LuaError if either both operands are not a strings or both are not numbers
- * and no {@link #LE} metatag is defined.
+ * @return true if {@code (this > rhs)}, false if not, and boolean
+ * interpreation of result if metatag processing occurs.
+ * @throws LuaError if either both operands are not a strings or both are
+ * not numbers and no {@link #LE} metatag is defined.
* @see #gteq(LuaValue)
* @see #comparemt(LuaValue, LuaValue)
*/
- public boolean gt_b( double rhs ) { compareerror("number"); return false; }
+ public boolean gt_b(double rhs) { compareerror("number"); return false; }
- /** Greater than or equals: Perform numeric or string comparison with another value
- * of unknown type,
- * including metatag processing, and returning {@link LuaValue}.
+ /**
+ * Greater than or equals: Perform numeric or string comparison with another
+ * value of unknown type, including metatag processing, and returning
+ * {@link LuaValue}.
*
- * To be comparable, both operands must derive from {@link LuaString}
- * or both must derive from {@link LuaNumber}.
+ * To be comparable, both operands must derive from {@link LuaString} or
+ * both must derive from {@link LuaNumber}.
*
* @param rhs The right-hand-side value to perform the comparison with
- * @return {@link #TRUE} if {@code (this >= rhs)}, {@link #FALSE} if not,
- * or {@link LuaValue} if metatag processing occurs
- * @throws LuaError if either both operands are not a strings or both are not numbers
- * and no {@link #LT} metatag is defined.
+ * @return {@link #TRUE} if {@code (this >= rhs)}, {@link #FALSE} if not, or
+ * {@link LuaValue} if metatag processing occurs
+ * @throws LuaError if either both operands are not a strings or both are
+ * not numbers and no {@link #LT} metatag is defined.
* @see #gteq_b(LuaValue)
* @see #comparemt(LuaValue, LuaValue)
*/
- public LuaValue gteq( LuaValue rhs ) { return rhs.comparemt(LT,this); }
+ public LuaValue gteq(LuaValue rhs) { return rhs.comparemt(LT, this); }
- /** Greater than or equals: Perform numeric comparison with another value
- * of double type,
- * including metatag processing, and returning {@link LuaValue}.
+ /**
+ * Greater than or equals: Perform numeric comparison with another value of
+ * double type, including metatag processing, and returning
+ * {@link LuaValue}.
*
* To be comparable, this must derive from {@link LuaNumber}.
*
* @param rhs The right-hand-side value to perform the comparison with
- * @return {@link #TRUE} if {@code (this >= rhs)}, {@link #FALSE} if not,
- * or {@link LuaValue} if metatag processing occurs
- * @throws LuaError if this is not a number
- * and no {@link #LT} metatag is defined.
+ * @return {@link #TRUE} if {@code (this >= rhs)}, {@link #FALSE} if not, or
+ * {@link LuaValue} if metatag processing occurs
+ * @throws LuaError if this is not a number and no {@link #LT} metatag is
+ * defined.
* @see #gteq_b(double)
* @see #comparemt(LuaValue, LuaValue)
*/
- public LuaValue gteq( double rhs ) { return compareerror("number"); }
+ public LuaValue gteq(double rhs) { return compareerror("number"); }
- /** Greater than or equals: Perform numeric comparison with another value
- * of int type,
- * including metatag processing, and returning {@link LuaValue}.
+ /**
+ * Greater than or equals: Perform numeric comparison with another value of
+ * int type, including metatag processing, and returning {@link LuaValue}.
*
* To be comparable, this must derive from {@link LuaNumber}.
*
* @param rhs The right-hand-side value to perform the comparison with
- * @return {@link #TRUE} if {@code (this >= rhs)}, {@link #FALSE} if not,
- * or {@link LuaValue} if metatag processing occurs
- * @throws LuaError if this is not a number
- * and no {@link #LT} metatag is defined.
+ * @return {@link #TRUE} if {@code (this >= rhs)}, {@link #FALSE} if not, or
+ * {@link LuaValue} if metatag processing occurs
+ * @throws LuaError if this is not a number and no {@link #LT} metatag is
+ * defined.
* @see #gteq_b(int)
* @see #comparemt(LuaValue, LuaValue)
*/
- public LuaValue gteq( int rhs ) { return valueOf(todouble() >= rhs); }
+ public LuaValue gteq(int rhs) { return valueOf(todouble() >= rhs); }
- /** Greater than or equals: Perform numeric or string comparison with another value
- * of unknown type, including metatag processing,
- * and returning java boolean.
+ /**
+ * Greater than or equals: Perform numeric or string comparison with another
+ * value of unknown type, including metatag processing, and returning java
+ * boolean.
*
- * To be comparable, both operands must derive from {@link LuaString}
- * or both must derive from {@link LuaNumber}.
+ * To be comparable, both operands must derive from {@link LuaString} or
+ * both must derive from {@link LuaNumber}.
*
* @param rhs The right-hand-side value to perform the comparison with
- * @return true if {@code (this >= rhs)}, false if not,
- * and boolean interpreation of result if metatag processing occurs.
- * @throws LuaError if either both operands are not a strings or both are not numbers
- * and no {@link #LT} metatag is defined.
+ * @return true if {@code (this >= rhs)}, false if not, and boolean
+ * interpreation of result if metatag processing occurs.
+ * @throws LuaError if either both operands are not a strings or both are
+ * not numbers and no {@link #LT} metatag is defined.
* @see #gteq(LuaValue)
* @see #comparemt(LuaValue, LuaValue)
*/
- public boolean gteq_b( LuaValue rhs ) { return rhs.comparemt(LT,this).toboolean(); }
+ public boolean gteq_b(LuaValue rhs) { return rhs.comparemt(LT, this).toboolean(); }
- /** Greater than or equals: Perform numeric comparison with another value
- * of int type,
- * including metatag processing,
- * and returning java boolean.
+ /**
+ * Greater than or equals: Perform numeric comparison with another value of
+ * int type, including metatag processing, and returning java boolean.
*
* To be comparable, this must derive from {@link LuaNumber}.
*
* @param rhs The right-hand-side value to perform the comparison with
- * @return true if {@code (this >= rhs)}, false if not,
- * and boolean interpreation of result if metatag processing occurs.
- * @throws LuaError if this is not a number
- * and no {@link #LT} metatag is defined.
+ * @return true if {@code (this >= rhs)}, false if not, and boolean
+ * interpreation of result if metatag processing occurs.
+ * @throws LuaError if this is not a number and no {@link #LT} metatag is
+ * defined.
* @see #gteq(int)
* @see #comparemt(LuaValue, LuaValue)
*/
- public boolean gteq_b( int rhs ) { compareerror("number"); return false; }
+ public boolean gteq_b(int rhs) { compareerror("number"); return false; }
- /** Greater than or equals: Perform numeric comparison with another value
- * of double type,
- * including metatag processing,
- * and returning java boolean.
+ /**
+ * Greater than or equals: Perform numeric comparison with another value of
+ * double type, including metatag processing, and returning java boolean.
*
* To be comparable, this must derive from {@link LuaNumber}.
*
* @param rhs The right-hand-side value to perform the comparison with
- * @return true if {@code (this >= rhs)}, false if not,
- * and boolean interpreation of result if metatag processing occurs.
- * @throws LuaError if this is not a number
- * and no {@link #LT} metatag is defined.
+ * @return true if {@code (this >= rhs)}, false if not, and boolean
+ * interpreation of result if metatag processing occurs.
+ * @throws LuaError if this is not a number and no {@link #LT} metatag is
+ * defined.
* @see #gteq(double)
* @see #comparemt(LuaValue, LuaValue)
*/
- public boolean gteq_b( double rhs ) { compareerror("number"); return false; }
-
- /** Perform metatag processing for comparison operations.
+ public boolean gteq_b(double rhs) { compareerror("number"); return false; }
+
+ /**
+ * Perform metatag processing for comparison operations.
*
- * Finds the supplied metatag value and invokes it,
- * or throws {@link LuaError} if none applies.
+ * Finds the supplied metatag value and invokes it, or throws
+ * {@link LuaError} if none applies.
+ *
* @param tag The metatag to look up
* @param op1 The operand with which to to perform the operation
* @return {@link LuaValue} resulting from metatag processing
- * @throws LuaError if metatag was not defined for either operand,
- * or if the operands are not the same type,
- * or the metatag values for the two operands are different.
+ * @throws LuaError if metatag was not defined for either operand, or if the
+ * operands are not the same type, or the metatag values
+ * for the two operands are different.
* @see #gt(LuaValue)
* @see #gteq(LuaValue)
* @see #lt(LuaValue)
* @see #lteq(LuaValue)
*/
- public LuaValue comparemt( LuaValue tag, LuaValue op1 ) {
+ public LuaValue comparemt(LuaValue tag, LuaValue op1) {
LuaValue h;
if (!(h = metatag(tag)).isnil() || !(h = op1.metatag(tag)).isnil())
return h.call(this, op1);
if (LuaValue.LE.raweq(tag) && (!(h = metatag(LT)).isnil() || !(h = op1.metatag(LT)).isnil()))
return h.call(op1, this).not();
- return error("attempt to compare "+tag+" on "+typename()+" and "+op1.typename());
+ return error("attempt to compare " + tag + " on " + typename() + " and " + op1.typename());
}
-
- /** Perform string comparison with another value
- * of any type
- * using string comparison based on byte values.
+
+ /**
+ * Perform string comparison with another value of any type using string
+ * comparison based on byte values.
*
- * Only strings can be compared, meaning
- * each operand must derive from {@link LuaString}.
+ * Only strings can be compared, meaning each operand must derive from
+ * {@link LuaString}.
*
* @param rhs The right-hand-side value to perform the comparison with
- * @return int < 0 for {@code (this < rhs)}, int > 0 for {@code (this > rhs)}, or 0 when same string.
+ * @return int < 0 for {@code (this < rhs)}, int > 0 for
+ * {@code (this > rhs)}, or 0 when same string.
* @throws LuaError if either operand is not a string
*/
- public int strcmp( LuaValue rhs ) { error("attempt to compare "+typename()); return 0; }
+ public int strcmp(LuaValue rhs) { error("attempt to compare " + typename()); return 0; }
- /** Perform string comparison with another value
- * known to be a {@link LuaString}
- * using string comparison based on byte values.
+ /**
+ * Perform string comparison with another value known to be a
+ * {@link LuaString} using string comparison based on byte values.
*
- * Only strings can be compared, meaning
- * each operand must derive from {@link LuaString}.
+ * Only strings can be compared, meaning each operand must derive from
+ * {@link LuaString}.
*
* @param rhs The right-hand-side value to perform the comparison with
- * @return int < 0 for {@code (this < rhs)}, int > 0 for {@code (this > rhs)}, or 0 when same string.
+ * @return int < 0 for {@code (this < rhs)}, int > 0 for
+ * {@code (this > rhs)}, or 0 when same string.
* @throws LuaError if this is not a string
*/
- public int strcmp( LuaString rhs ) { error("attempt to compare "+typename()); return 0; }
+ public int strcmp(LuaString rhs) { error("attempt to compare " + typename()); return 0; }
- /** Concatenate another value onto this value and return the result
- * using rules of lua string concatenation including metatag processing.
+ /**
+ * Concatenate another value onto this value and return the result using
+ * rules of lua string concatenation including metatag processing.
*
- * Only strings and numbers as represented can be concatenated, meaning
- * each operand must derive from {@link LuaString} or {@link LuaNumber}.
+ * Only strings and numbers as represented can be concatenated, meaning each
+ * operand must derive from {@link LuaString} or {@link LuaNumber}.
*
* @param rhs The right-hand-side value to perform the operation with
- * @return {@link LuaValue} resulting from concatenation of {@code (this .. rhs)}
- * @throws LuaError if either operand is not of an appropriate type,
- * such as nil or a table
+ * @return {@link LuaValue} resulting from concatenation of
+ * {@code (this .. rhs)}
+ * @throws LuaError if either operand is not of an appropriate type, such as
+ * nil or a table
*/
- public LuaValue concat(LuaValue rhs) { return this.concatmt(rhs); }
+ public LuaValue concat(LuaValue rhs) { return this.concatmt(rhs); }
- /** Reverse-concatenation: concatenate this value onto another value
- * whose type is unknwon
- * and return the result using rules of lua string concatenation including
- * metatag processing.
+ /**
+ * Reverse-concatenation: concatenate this value onto another value whose
+ * type is unknwon and return the result using rules of lua string
+ * concatenation including metatag processing.
*
- * Only strings and numbers as represented can be concatenated, meaning
- * each operand must derive from {@link LuaString} or {@link LuaNumber}.
+ * Only strings and numbers as represented can be concatenated, meaning each
+ * operand must derive from {@link LuaString} or {@link LuaNumber}.
*
* @param lhs The left-hand-side value onto which this will be concatenated
- * @return {@link LuaValue} resulting from concatenation of {@code (lhs .. this)}
- * @throws LuaError if either operand is not of an appropriate type,
- * such as nil or a table
+ * @return {@link LuaValue} resulting from concatenation of
+ * {@code (lhs .. this)}
+ * @throws LuaError if either operand is not of an appropriate type, such as
+ * nil or a table
* @see #concat(LuaValue)
*/
- public LuaValue concatTo(LuaValue lhs) { return lhs.concatmt(this); }
+ public LuaValue concatTo(LuaValue lhs) { return lhs.concatmt(this); }
- /** Reverse-concatenation: concatenate this value onto another value
- * known to be a {@link LuaNumber}
- * and return the result using rules of lua string concatenation including
- * metatag processing.
+ /**
+ * Reverse-concatenation: concatenate this value onto another value known to
+ * be a {@link LuaNumber} and return the result using rules of lua string
+ * concatenation including metatag processing.
*
- * Only strings and numbers as represented can be concatenated, meaning
- * each operand must derive from {@link LuaString} or {@link LuaNumber}.
+ * Only strings and numbers as represented can be concatenated, meaning each
+ * operand must derive from {@link LuaString} or {@link LuaNumber}.
*
* @param lhs The left-hand-side value onto which this will be concatenated
- * @return {@link LuaValue} resulting from concatenation of {@code (lhs .. this)}
- * @throws LuaError if either operand is not of an appropriate type,
- * such as nil or a table
+ * @return {@link LuaValue} resulting from concatenation of
+ * {@code (lhs .. this)}
+ * @throws LuaError if either operand is not of an appropriate type, such as
+ * nil or a table
* @see #concat(LuaValue)
*/
- public LuaValue concatTo(LuaNumber lhs) { return lhs.concatmt(this); }
-
- /** Reverse-concatenation: concatenate this value onto another value
- * known to be a {@link LuaString}
- * and return the result using rules of lua string concatenation including
- * metatag processing.
+ public LuaValue concatTo(LuaNumber lhs) { return lhs.concatmt(this); }
+
+ /**
+ * Reverse-concatenation: concatenate this value onto another value known to
+ * be a {@link LuaString} and return the result using rules of lua string
+ * concatenation including metatag processing.
*
- * Only strings and numbers as represented can be concatenated, meaning
- * each operand must derive from {@link LuaString} or {@link LuaNumber}.
+ * Only strings and numbers as represented can be concatenated, meaning each
+ * operand must derive from {@link LuaString} or {@link LuaNumber}.
*
* @param lhs The left-hand-side value onto which this will be concatenated
- * @return {@link LuaValue} resulting from concatenation of {@code (lhs .. this)}
- * @throws LuaError if either operand is not of an appropriate type,
- * such as nil or a table
+ * @return {@link LuaValue} resulting from concatenation of
+ * {@code (lhs .. this)}
+ * @throws LuaError if either operand is not of an appropriate type, such as
+ * nil or a table
* @see #concat(LuaValue)
*/
- public LuaValue concatTo(LuaString lhs) { return lhs.concatmt(this); }
+ public LuaValue concatTo(LuaString lhs) { return lhs.concatmt(this); }
- /** Convert the value to a {@link Buffer} for more efficient concatenation of
+ /**
+ * Convert the value to a {@link Buffer} for more efficient concatenation of
* multiple strings.
+ *
* @return Buffer instance containing the string or number
*/
- public Buffer buffer() { return new Buffer(this); }
-
- /** Concatenate a {@link Buffer} onto this value and return the result
- * using rules of lua string concatenation including metatag processing.
+ public Buffer buffer() { return new Buffer(this); }
+
+ /**
+ * Concatenate a {@link Buffer} onto this value and return the result using
+ * rules of lua string concatenation including metatag processing.
*
- * Only strings and numbers as represented can be concatenated, meaning
- * each operand must derive from {@link LuaString} or {@link LuaNumber}.
+ * Only strings and numbers as represented can be concatenated, meaning each
+ * operand must derive from {@link LuaString} or {@link LuaNumber}.
*
- * @param rhs The right-hand-side {@link Buffer} to perform the operation with
+ * @param rhs The right-hand-side {@link Buffer} to perform the operation
+ * with
* @return LuaString resulting from concatenation of {@code (this .. rhs)}
- * @throws LuaError if either operand is not of an appropriate type,
- * such as nil or a table
+ * @throws LuaError if either operand is not of an appropriate type, such as
+ * nil or a table
*/
- public Buffer concat(Buffer rhs) { return rhs.concatTo(this); }
-
- /** Perform metatag processing for concatenation operations.
+ public Buffer concat(Buffer rhs) { return rhs.concatTo(this); }
+
+ /**
+ * Perform metatag processing for concatenation operations.
*
- * Finds the {@link #CONCAT} metatag value and invokes it,
- * or throws {@link LuaError} if it doesn't exist.
+ * Finds the {@link #CONCAT} metatag value and invokes it, or throws
+ * {@link LuaError} if it doesn't exist.
+ *
* @param rhs The right-hand-side value to perform the operation with
- * @return {@link LuaValue} resulting from metatag processing for {@link #CONCAT} metatag.
+ * @return {@link LuaValue} resulting from metatag processing for
+ * {@link #CONCAT} metatag.
* @throws LuaError if metatag was not defined for either operand
*/
public LuaValue concatmt(LuaValue rhs) {
- LuaValue h=metatag(CONCAT);
- if ( h.isnil() && (h=rhs.metatag(CONCAT)).isnil())
- error("attempt to concatenate "+typename()+" and "+rhs.typename());
- return h.call(this,rhs);
+ LuaValue h = metatag(CONCAT);
+ if (h.isnil() && (h = rhs.metatag(CONCAT)).isnil())
+ error("attempt to concatenate " + typename() + " and " + rhs.typename());
+ return h.call(this, rhs);
}
-
- /** Perform boolean {@code and} with another operand, based on lua rules for boolean evaluation.
- * This returns either {@code this} or {@code rhs} depending on the boolean value for {@code this}.
+
+ /**
+ * Perform boolean {@code and} with another operand, based on lua rules for
+ * boolean evaluation. This returns either {@code this} or {@code rhs}
+ * depending on the boolean value for {@code this}.
*
* @param rhs The right-hand-side value to perform the operation with
- * @return {@code this} if {@code this.toboolean()} is false, {@code rhs} otherwise.
+ * @return {@code this} if {@code this.toboolean()} is false, {@code rhs}
+ * otherwise.
*/
- public LuaValue and( LuaValue rhs ) { return this.toboolean()? rhs: this; }
-
- /** Perform boolean {@code or} with another operand, based on lua rules for boolean evaluation.
- * This returns either {@code this} or {@code rhs} depending on the boolean value for {@code this}.
+ public LuaValue and(LuaValue rhs) { return this.toboolean()? rhs: this; }
+
+ /**
+ * Perform boolean {@code or} with another operand, based on lua rules for
+ * boolean evaluation. This returns either {@code this} or {@code rhs}
+ * depending on the boolean value for {@code this}.
*
* @param rhs The right-hand-side value to perform the operation with
- * @return {@code this} if {@code this.toboolean()} is true, {@code rhs} otherwise.
+ * @return {@code this} if {@code this.toboolean()} is true, {@code rhs}
+ * otherwise.
*/
- public LuaValue or( LuaValue rhs ) { return this.toboolean()? this: rhs; }
-
- /** Perform end-condition test in for-loop processing.
+ public LuaValue or(LuaValue rhs) { return this.toboolean()? this: rhs; }
+
+ /**
+ * Perform end-condition test in for-loop processing.
*
* Used in lua-bytecode to Java-bytecode conversion.
*
* @param limit the numerical limit to complete the for loop
- * @param step the numberical step size to use.
+ * @param step the numberical step size to use.
* @return true if limit has not been reached, false otherwise.
*/
public boolean testfor_b(LuaValue limit, LuaValue step) { return step.gt_b(0)? lteq_b(limit): gteq_b(limit); }
-
+
/**
- * Convert this value to a string if it is a {@link LuaString} or {@link LuaNumber},
- * or throw a {@link LuaError} if it is not
- * @return {@link LuaString} corresponding to the value if a string or number
+ * Convert this value to a string if it is a {@link LuaString} or
+ * {@link LuaNumber}, or throw a {@link LuaError} if it is not
+ *
+ * @return {@link LuaString} corresponding to the value if a string or
+ * number
* @throws LuaError if not a string or number
*/
- public LuaString strvalue() { typerror("string or number"); return null; }
+ public LuaString strvalue() { typerror("string or number"); return null; }
- /** Return this value as a strong reference, or null if it was weak and is no longer referenced.
- * @return {@link LuaValue} referred to, or null if it was weak and is no longer referenced.
+ /**
+ * Return this value as a strong reference, or null if it was weak and is no
+ * longer referenced.
+ *
+ * @return {@link LuaValue} referred to, or null if it was weak and is no
+ * longer referenced.
* @see WeakTable
*/
- public LuaValue strongvalue() { return this; }
+ public LuaValue strongvalue() { return this; }
- /** Convert java boolean to a {@link LuaValue}.
+ /**
+ * Convert java boolean to a {@link LuaValue}.
*
* @param b boolean value to convert
- * @return {@link #TRUE} if not or {@link #FALSE} if false
+ * @return {@link #TRUE} if not or {@link #FALSE} if false
*/
- public static LuaBoolean valueOf(boolean b) { return b? LuaValue.TRUE: FALSE; };
+ public static LuaBoolean valueOf(boolean b) { return b? LuaValue.TRUE: FALSE; };
- /** Convert java int to a {@link LuaValue}.
+ /**
+ * Convert java int to a {@link LuaValue}.
*
* @param i int value to convert
* @return {@link LuaInteger} instance, possibly pooled, whose value is i
*/
- public static LuaInteger valueOf(int i) { return LuaInteger.valueOf(i); }
-
- /** Convert java double to a {@link LuaValue}.
- * This may return a {@link LuaInteger} or {@link LuaDouble} depending
- * on the value supplied.
+ public static LuaInteger valueOf(int i) { return LuaInteger.valueOf(i); }
+
+ /**
+ * Convert java double to a {@link LuaValue}. This may return a
+ * {@link LuaInteger} or {@link LuaDouble} depending on the value supplied.
*
* @param d double value to convert
* @return {@link LuaNumber} instance, possibly pooled, whose value is d
*/
- public static LuaNumber valueOf(double d) { return LuaDouble.valueOf(d); };
-
- /** Convert java string to a {@link LuaValue}.
+ public static LuaNumber valueOf(double d) { return LuaDouble.valueOf(d); };
+
+ /**
+ * Convert java string to a {@link LuaValue}.
*
* @param s String value to convert
* @return {@link LuaString} instance, possibly pooled, whose value is s
*/
- public static LuaString valueOf(String s) { return LuaString.valueOf(s); }
+ public static LuaString valueOf(String s) { return LuaString.valueOf(s); }
- /** Convert bytes in an array to a {@link LuaValue}.
+ /**
+ * Convert bytes in an array to a {@link LuaValue}.
*
* @param bytes byte array to convert
- * @return {@link LuaString} instance, possibly pooled, whose bytes are those in the supplied array
+ * @return {@link LuaString} instance, possibly pooled, whose bytes are
+ * those in the supplied array
*/
public static LuaString valueOf(byte[] bytes) { return LuaString.valueOf(bytes); }
-
- /** Convert bytes in an array to a {@link LuaValue}.
+
+ /**
+ * Convert bytes in an array to a {@link LuaValue}.
*
* @param bytes byte array to convert
- * @param off offset into the byte array, starting at 0
- * @param len number of bytes to include in the {@link LuaString}
- * @return {@link LuaString} instance, possibly pooled, whose bytes are those in the supplied array
+ * @param off offset into the byte array, starting at 0
+ * @param len number of bytes to include in the {@link LuaString}
+ * @return {@link LuaString} instance, possibly pooled, whose bytes are
+ * those in the supplied array
*/
public static LuaString valueOf(byte[] bytes, int off, int len) {
- return LuaString.valueOf(bytes,off,len);
+ return LuaString.valueOf(bytes, off, len);
}
-
- /** Construct an empty {@link LuaTable}.
+
+ /**
+ * Construct an empty {@link LuaTable}.
+ *
* @return new {@link LuaTable} instance with no values and no metatable.
*/
public static LuaTable tableOf() { return new LuaTable(); }
- /** Construct a {@link LuaTable} initialized with supplied array values.
- * @param varargs {@link Varargs} containing the values to use in initialization
- * @param firstarg the index of the first argument to use from the varargs, 1 being the first.
- * @return new {@link LuaTable} instance with sequential elements coming from the varargs.
+ /**
+ * Construct a {@link LuaTable} initialized with supplied array values.
+ *
+ * @param varargs {@link Varargs} containing the values to use in
+ * initialization
+ * @param firstarg the index of the first argument to use from the varargs,
+ * 1 being the first.
+ * @return new {@link LuaTable} instance with sequential elements coming
+ * from the varargs.
*/
- public static LuaTable tableOf(Varargs varargs, int firstarg) { return new LuaTable(varargs,firstarg); }
-
- /** Construct an empty {@link LuaTable} preallocated to hold array and hashed elements
+ public static LuaTable tableOf(Varargs varargs, int firstarg) { return new LuaTable(varargs, firstarg); }
+
+ /**
+ * Construct an empty {@link LuaTable} preallocated to hold array and hashed
+ * elements
+ *
* @param narray Number of array elements to preallocate
- * @param nhash Number of hash elements to preallocate
- * @return new {@link LuaTable} instance with no values and no metatable, but preallocated for array and hashed elements.
+ * @param nhash Number of hash elements to preallocate
+ * @return new {@link LuaTable} instance with no values and no metatable,
+ * but preallocated for array and hashed elements.
*/
public static LuaTable tableOf(int narray, int nhash) { return new LuaTable(narray, nhash); }
-
- /** Construct a {@link LuaTable} initialized with supplied array values.
- * @param unnamedValues array of {@link LuaValue} containing the values to use in initialization
- * @return new {@link LuaTable} instance with sequential elements coming from the array.
- */
- public static LuaTable listOf(LuaValue[] unnamedValues) { return new LuaTable(null,unnamedValues,null); }
-
- /** Construct a {@link LuaTable} initialized with supplied array values.
- * @param unnamedValues array of {@link LuaValue} containing the first values to use in initialization
- * @param lastarg {@link Varargs} containing additional values to use in initialization
- * to be put after the last unnamedValues element
- * @return new {@link LuaTable} instance with sequential elements coming from the array and varargs.
- */
- public static LuaTable listOf(LuaValue[] unnamedValues,Varargs lastarg) { return new LuaTable(null,unnamedValues,lastarg); }
- /** Construct a {@link LuaTable} initialized with supplied named values.
- * @param namedValues array of {@link LuaValue} containing the keys and values to use in initialization
- * in order {@code {key-a, value-a, key-b, value-b, ...} }
- * @return new {@link LuaTable} instance with non-sequential keys coming from the supplied array.
+ /**
+ * Construct a {@link LuaTable} initialized with supplied array values.
+ *
+ * @param unnamedValues array of {@link LuaValue} containing the values to
+ * use in initialization
+ * @return new {@link LuaTable} instance with sequential elements coming
+ * from the array.
*/
- public static LuaTable tableOf(LuaValue[] namedValues) { return new LuaTable(namedValues,null,null); }
+ public static LuaTable listOf(LuaValue[] unnamedValues) { return new LuaTable(null, unnamedValues, null); }
- /** Construct a {@link LuaTable} initialized with supplied named values and sequential elements.
- * The named values will be assigned first, and the sequential elements will be assigned later,
- * possibly overwriting named values at the same slot if there are conflicts.
- * @param namedValues array of {@link LuaValue} containing the keys and values to use in initialization
- * in order {@code {key-a, value-a, key-b, value-b, ...} }
- * @param unnamedValues array of {@link LuaValue} containing the sequenctial elements to use in initialization
- * in order {@code {value-1, value-2, ...} }, or null if there are none
- * @return new {@link LuaTable} instance with named and sequential values supplied.
+ /**
+ * Construct a {@link LuaTable} initialized with supplied array values.
+ *
+ * @param unnamedValues array of {@link LuaValue} containing the first
+ * values to use in initialization
+ * @param lastarg {@link Varargs} containing additional values to use
+ * in initialization to be put after the last
+ * unnamedValues element
+ * @return new {@link LuaTable} instance with sequential elements coming
+ * from the array and varargs.
*/
- public static LuaTable tableOf(LuaValue[] namedValues, LuaValue[] unnamedValues) {return new LuaTable(namedValues,unnamedValues,null); }
+ public static LuaTable listOf(LuaValue[] unnamedValues, Varargs lastarg) {
+ return new LuaTable(null, unnamedValues, lastarg);
+ }
- /** Construct a {@link LuaTable} initialized with supplied named values and sequential elements in an array part and as varargs.
- * The named values will be assigned first, and the sequential elements will be assigned later,
- * possibly overwriting named values at the same slot if there are conflicts.
- * @param namedValues array of {@link LuaValue} containing the keys and values to use in initialization
- * in order {@code {key-a, value-a, key-b, value-b, ...} }
- * @param unnamedValues array of {@link LuaValue} containing the first sequenctial elements to use in initialization
- * in order {@code {value-1, value-2, ...} }, or null if there are none
- * @param lastarg {@link Varargs} containing additional values to use in the sequential part of the initialization,
- * to be put after the last unnamedValues element
- * @return new {@link LuaTable} instance with named and sequential values supplied.
+ /**
+ * Construct a {@link LuaTable} initialized with supplied named values.
+ *
+ * @param namedValues array of {@link LuaValue} containing the keys and
+ * values to use in initialization in order
+ * {@code {key-a, value-a, key-b, value-b, ...} }
+ * @return new {@link LuaTable} instance with non-sequential keys coming
+ * from the supplied array.
*/
- public static LuaTable tableOf(LuaValue[] namedValues, LuaValue[] unnamedValues, Varargs lastarg) {return new LuaTable(namedValues,unnamedValues,lastarg); }
-
- /** Construct a LuaUserdata for an object.
+ public static LuaTable tableOf(LuaValue[] namedValues) { return new LuaTable(namedValues, null, null); }
+
+ /**
+ * Construct a {@link LuaTable} initialized with supplied named values and
+ * sequential elements. The named values will be assigned first, and the
+ * sequential elements will be assigned later, possibly overwriting named
+ * values at the same slot if there are conflicts.
+ *
+ * @param namedValues array of {@link LuaValue} containing the keys and
+ * values to use in initialization in order
+ * {@code {key-a, value-a, key-b, value-b, ...} }
+ * @param unnamedValues array of {@link LuaValue} containing the sequenctial
+ * elements to use in initialization in order
+ * {@code {value-1, value-2, ...} }, or null if there
+ * are none
+ * @return new {@link LuaTable} instance with named and sequential values
+ * supplied.
+ */
+ public static LuaTable tableOf(LuaValue[] namedValues, LuaValue[] unnamedValues) {
+ return new LuaTable(namedValues, unnamedValues, null);
+ }
+
+ /**
+ * Construct a {@link LuaTable} initialized with supplied named values and
+ * sequential elements in an array part and as varargs. The named values
+ * will be assigned first, and the sequential elements will be assigned
+ * later, possibly overwriting named values at the same slot if there are
+ * conflicts.
+ *
+ * @param namedValues array of {@link LuaValue} containing the keys and
+ * values to use in initialization in order
+ * {@code {key-a, value-a, key-b, value-b, ...} }
+ * @param unnamedValues array of {@link LuaValue} containing the first
+ * sequenctial elements to use in initialization in
+ * order {@code {value-1, value-2, ...} }, or null if
+ * there are none
+ * @param lastarg {@link Varargs} containing additional values to use
+ * in the sequential part of the initialization, to be
+ * put after the last unnamedValues element
+ * @return new {@link LuaTable} instance with named and sequential values
+ * supplied.
+ */
+ public static LuaTable tableOf(LuaValue[] namedValues, LuaValue[] unnamedValues, Varargs lastarg) {
+ return new LuaTable(namedValues, unnamedValues, lastarg);
+ }
+
+ /**
+ * Construct a LuaUserdata for an object.
*
* @param o The java instance to be wrapped as userdata
* @return {@link LuaUserdata} value wrapping the java instance.
*/
public static LuaUserdata userdataOf(Object o) { return new LuaUserdata(o); }
-
- /** Construct a LuaUserdata for an object with a user supplied metatable.
+
+ /**
+ * Construct a LuaUserdata for an object with a user supplied metatable.
*
- * @param o The java instance to be wrapped as userdata
+ * @param o The java instance to be wrapped as userdata
* @param metatable The metatble to associate with the userdata instance.
* @return {@link LuaUserdata} value wrapping the java instance.
*/
- public static LuaUserdata userdataOf(Object o,LuaValue metatable) { return new LuaUserdata(o,metatable); }
+ public static LuaUserdata userdataOf(Object o, LuaValue metatable) { return new LuaUserdata(o, metatable); }
/** Constant limiting metatag loop processing */
- private static final int MAXTAGLOOP = 100;
-
+ private static final int MAXTAGLOOP = 100;
+
/**
- * Return value for field reference including metatag processing, or {@link LuaValue#NIL} if it doesn't exist.
- * @param t {@link LuaValue} on which field is being referenced, typically a table or something with the metatag {@link LuaValue#INDEX} defined
+ * Return value for field reference including metatag processing, or
+ * {@link LuaValue#NIL} if it doesn't exist.
+ *
+ * @param t {@link LuaValue} on which field is being referenced, typically
+ * a table or something with the metatag {@link LuaValue#INDEX}
+ * defined
* @param key {@link LuaValue} naming the field to reference
- * @return {@link LuaValue} for the {@code key} if it exists, or {@link LuaValue#NIL}
+ * @return {@link LuaValue} for the {@code key} if it exists, or
+ * {@link LuaValue#NIL}
* @throws LuaError if there is a loop in metatag processing
*/
- /** get value from metatable operations, or NIL if not defined by metatables */
+ /**
+ * get value from metatable operations, or NIL if not defined by metatables
+ */
protected static LuaValue gettable(LuaValue t, LuaValue key) {
LuaValue tm;
int loop = 0;
@@ -3300,19 +3832,22 @@ public class LuaValue extends Varargs {
if (tm.isfunction())
return tm.call(t, key);
t = tm;
- }
- while ( ++loop < MAXTAGLOOP );
+ } while ( ++loop < MAXTAGLOOP );
error("loop in gettable");
return NIL;
}
-
+
/**
* Perform field assignment including metatag processing.
- * @param t {@link LuaValue} on which value is being set, typically a table or something with the metatag {@link LuaValue#NEWINDEX} defined
- * @param key {@link LuaValue} naming the field to assign
+ *
+ * @param t {@link LuaValue} on which value is being set, typically a
+ * table or something with the metatag
+ * {@link LuaValue#NEWINDEX} defined
+ * @param key {@link LuaValue} naming the field to assign
* @param value {@link LuaValue} the new value to assign to {@code key}
* @throws LuaError if there is a loop in metatag processing
- * @return true if assignment or metatag processing succeeded, false otherwise
+ * @return true if assignment or metatag processing succeeded, false
+ * otherwise
*/
protected static boolean settable(LuaValue t, LuaValue key, LuaValue value) {
LuaValue tm;
@@ -3330,68 +3865,73 @@ public class LuaValue extends Varargs {
return true;
}
t = tm;
- }
- while ( ++loop < MAXTAGLOOP );
+ } while ( ++loop < MAXTAGLOOP );
error("loop in settable");
return false;
}
-
- /**
- * Get particular metatag, or return {@link LuaValue#NIL} if it doesn't exist
- * @param tag Metatag name to look up, typically a string such as
- * {@link LuaValue#INDEX} or {@link LuaValue#NEWINDEX}
- * @return {@link LuaValue} for tag {@code reason}, or {@link LuaValue#NIL}
- */
- public LuaValue metatag(LuaValue tag) {
- LuaValue mt = getmetatable();
- if ( mt == null )
- return NIL;
- return mt.rawget(tag);
- }
- /**
- * Get particular metatag, or throw {@link LuaError} if it doesn't exist
- * @param tag Metatag name to look up, typically a string such as
- * {@link LuaValue#INDEX} or {@link LuaValue#NEWINDEX}
- * @param reason Description of error when tag lookup fails.
- * @return {@link LuaValue} that can be called
- * @throws LuaError when the lookup fails.
- */
+ /**
+ * Get particular metatag, or return {@link LuaValue#NIL} if it doesn't
+ * exist
+ *
+ * @param tag Metatag name to look up, typically a string such as
+ * {@link LuaValue#INDEX} or {@link LuaValue#NEWINDEX}
+ * @return {@link LuaValue} for tag {@code reason}, or {@link LuaValue#NIL}
+ */
+ public LuaValue metatag(LuaValue tag) {
+ LuaValue mt = getmetatable();
+ if (mt == null)
+ return NIL;
+ return mt.rawget(tag);
+ }
+
+ /**
+ * Get particular metatag, or throw {@link LuaError} if it doesn't exist
+ *
+ * @param tag Metatag name to look up, typically a string such as
+ * {@link LuaValue#INDEX} or {@link LuaValue#NEWINDEX}
+ * @param reason Description of error when tag lookup fails.
+ * @return {@link LuaValue} that can be called
+ * @throws LuaError when the lookup fails.
+ */
protected LuaValue checkmetatag(LuaValue tag, String reason) {
LuaValue h = this.metatag(tag);
- if ( h.isnil() )
+ if (h.isnil())
throw new LuaError(reason + "a " + typename() + " value");
return h;
}
/** Construct a Metatable instance from the given LuaValue */
protected static Metatable metatableOf(LuaValue mt) {
- if ( mt != null && mt.istable() ) {
+ if (mt != null && mt.istable()) {
LuaValue mode = mt.rawget(MODE);
- if ( mode.isstring() ) {
+ if (mode.isstring()) {
String m = mode.tojstring();
boolean weakkeys = m.indexOf('k') >= 0;
boolean weakvalues = m.indexOf('v') >= 0;
- if ( weakkeys || weakvalues ) {
+ if (weakkeys || weakvalues) {
return new WeakTable(weakkeys, weakvalues, mt);
}
}
- return (LuaTable)mt;
- } else if ( mt != null ) {
- return new NonTableMetatable( mt );
+ return (LuaTable) mt;
+ } else if (mt != null) {
+ return new NonTableMetatable(mt);
} else {
return null;
}
}
- /** Throw {@link LuaError} indicating index was attempted on illegal type
+ /**
+ * Throw {@link LuaError} indicating index was attempted on illegal type
+ *
* @throws LuaError when called.
*/
- private void indexerror(String key) {
- error( "attempt to index ? (a "+typename()+" value) with key '" + key + "'" );
+ private void indexerror(String key) {
+ error("attempt to index ? (a " + typename() + " value) with key '" + key + "'");
}
-
- /** Construct a {@link Varargs} around an array of {@link LuaValue}s.
+
+ /**
+ * Construct a {@link Varargs} around an array of {@link LuaValue}s.
*
* @param v The array of {@link LuaValue}s
* @return {@link Varargs} wrapping the supplied values.
@@ -3399,15 +3939,20 @@ public class LuaValue extends Varargs {
* @see LuaValue#varargsOf(LuaValue[], int, int)
*/
public static Varargs varargsOf(final LuaValue[] v) {
- switch ( v.length ) {
- case 0: return NONE;
- case 1: return v[0];
- case 2: return new Varargs.PairVarargs(v[0],v[1]);
- default: return new Varargs.ArrayVarargs(v,NONE);
+ switch (v.length) {
+ case 0:
+ return NONE;
+ case 1:
+ return v[0];
+ case 2:
+ return new Varargs.PairVarargs(v[0], v[1]);
+ default:
+ return new Varargs.ArrayVarargs(v, NONE);
}
}
-
- /** Construct a {@link Varargs} around an array of {@link LuaValue}s.
+
+ /**
+ * Construct a {@link Varargs} around an array of {@link LuaValue}s.
*
* @param v The array of {@link LuaValue}s
* @param r {@link Varargs} contain values to include at the end
@@ -3415,22 +3960,24 @@ public class LuaValue extends Varargs {
* @see LuaValue#varargsOf(LuaValue[])
* @see LuaValue#varargsOf(LuaValue[], int, int, Varargs)
*/
- public static Varargs varargsOf(final LuaValue[] v,Varargs r) {
- switch ( v.length ) {
- case 0: return r;
- case 1: return r.narg()>0?
- (Varargs) new Varargs.PairVarargs(v[0],r):
- (Varargs) v[0];
- case 2: return r.narg()>0?
- (Varargs) new Varargs.ArrayVarargs(v,r):
- (Varargs) new Varargs.PairVarargs(v[0],v[1]);
- default: return new Varargs.ArrayVarargs(v,r);
+ public static Varargs varargsOf(final LuaValue[] v, Varargs r) {
+ switch (v.length) {
+ case 0:
+ return r;
+ case 1:
+ return r.narg() > 0? (Varargs) new Varargs.PairVarargs(v[0], r): (Varargs) v[0];
+ case 2:
+ return r.narg() > 0? (Varargs) new Varargs.ArrayVarargs(v, r)
+ : (Varargs) new Varargs.PairVarargs(v[0], v[1]);
+ default:
+ return new Varargs.ArrayVarargs(v, r);
}
}
- /** Construct a {@link Varargs} around an array of {@link LuaValue}s.
+ /**
+ * Construct a {@link Varargs} around an array of {@link LuaValue}s.
*
- * @param v The array of {@link LuaValue}s
+ * @param v The array of {@link LuaValue}s
* @param offset number of initial values to skip in the array
* @param length number of values to include from the array
* @return {@link Varargs} wrapping the supplied values.
@@ -3438,82 +3985,95 @@ public class LuaValue extends Varargs {
* @see LuaValue#varargsOf(LuaValue[], int, int, Varargs)
*/
public static Varargs varargsOf(final LuaValue[] v, final int offset, final int length) {
- switch ( length ) {
- case 0: return NONE;
- case 1: return v[offset];
- case 2: return new Varargs.PairVarargs(v[offset+0],v[offset+1]);
- default: return new Varargs.ArrayPartVarargs(v, offset, length, NONE);
+ switch (length) {
+ case 0:
+ return NONE;
+ case 1:
+ return v[offset];
+ case 2:
+ return new Varargs.PairVarargs(v[offset+0], v[offset+1]);
+ default:
+ return new Varargs.ArrayPartVarargs(v, offset, length, NONE);
}
}
- /** Construct a {@link Varargs} around an array of {@link LuaValue}s.
+ /**
+ * Construct a {@link Varargs} around an array of {@link LuaValue}s.
*
- * Caller must ensure that array contents are not mutated after this call
- * or undefined behavior will result.
+ * Caller must ensure that array contents are not mutated after this call or
+ * undefined behavior will result.
*
- * @param v The array of {@link LuaValue}s
+ * @param v The array of {@link LuaValue}s
* @param offset number of initial values to skip in the array
* @param length number of values to include from the array
- * @param more {@link Varargs} contain values to include at the end
+ * @param more {@link Varargs} contain values to include at the end
* @return {@link Varargs} wrapping the supplied values.
* @see LuaValue#varargsOf(LuaValue[], Varargs)
* @see LuaValue#varargsOf(LuaValue[], int, int)
*/
public static Varargs varargsOf(final LuaValue[] v, final int offset, final int length, Varargs more) {
- switch ( length ) {
- case 0: return more;
- case 1: return more.narg()>0?
- (Varargs) new Varargs.PairVarargs(v[offset],more):
- (Varargs) v[offset];
- case 2: return more.narg()>0?
- (Varargs) new Varargs.ArrayPartVarargs(v,offset,length,more):
- (Varargs) new Varargs.PairVarargs(v[offset],v[offset+1]);
- default: return new Varargs.ArrayPartVarargs(v,offset,length,more);
+ switch (length) {
+ case 0:
+ return more;
+ case 1:
+ return more.narg() > 0? (Varargs) new Varargs.PairVarargs(v[offset], more): (Varargs) v[offset];
+ case 2:
+ return more.narg() > 0? (Varargs) new Varargs.ArrayPartVarargs(v, offset, length, more)
+ : (Varargs) new Varargs.PairVarargs(v[offset], v[offset+1]);
+ default:
+ return new Varargs.ArrayPartVarargs(v, offset, length, more);
}
}
- /** Construct a {@link Varargs} around a set of 2 or more {@link LuaValue}s.
+ /**
+ * Construct a {@link Varargs} around a set of 2 or more {@link LuaValue}s.
*
- * This can be used to wrap exactly 2 values, or a list consisting of 1 initial value
- * followed by another variable list of remaining values.
+ * This can be used to wrap exactly 2 values, or a list consisting of 1
+ * initial value followed by another variable list of remaining values.
*
* @param v First {@link LuaValue} in the {@link Varargs}
- * @param r {@link LuaValue} supplying the 2rd value,
- * or {@link Varargs}s supplying all values beyond the first
+ * @param r {@link LuaValue} supplying the 2rd value, or {@link Varargs}s
+ * supplying all values beyond the first
* @return {@link Varargs} wrapping the supplied values.
*/
public static Varargs varargsOf(LuaValue v, Varargs r) {
- switch ( r.narg() ) {
- case 0: return v;
- default: return new Varargs.PairVarargs(v,r);
+ switch (r.narg()) {
+ case 0:
+ return v;
+ default:
+ return new Varargs.PairVarargs(v, r);
}
}
-
- /** Construct a {@link Varargs} around a set of 3 or more {@link LuaValue}s.
+
+ /**
+ * Construct a {@link Varargs} around a set of 3 or more {@link LuaValue}s.
*
- * This can be used to wrap exactly 3 values, or a list consisting of 2 initial values
- * followed by another variable list of remaining values.
+ * This can be used to wrap exactly 3 values, or a list consisting of 2
+ * initial values followed by another variable list of remaining values.
*
* @param v1 First {@link LuaValue} in the {@link Varargs}
* @param v2 Second {@link LuaValue} in the {@link Varargs}
- * @param v3 {@link LuaValue} supplying the 3rd value,
- * or {@link Varargs}s supplying all values beyond the second
+ * @param v3 {@link LuaValue} supplying the 3rd value, or {@link Varargs}s
+ * supplying all values beyond the second
* @return {@link Varargs} wrapping the supplied values.
*/
- public static Varargs varargsOf(LuaValue v1,LuaValue v2,Varargs v3) {
- switch ( v3.narg() ) {
- case 0: return new Varargs.PairVarargs(v1,v2);
- default: return new Varargs.ArrayPartVarargs(new LuaValue[]{v1,v2}, 0, 2, v3);
+ public static Varargs varargsOf(LuaValue v1, LuaValue v2, Varargs v3) {
+ switch (v3.narg()) {
+ case 0:
+ return new Varargs.PairVarargs(v1, v2);
+ default:
+ return new Varargs.ArrayPartVarargs(new LuaValue[] { v1, v2 }, 0, 2, v3);
}
}
-
- /** Construct a {@link TailcallVarargs} around a function and arguments.
+
+ /**
+ * Construct a {@link TailcallVarargs} around a function and arguments.
*
* The tail call is not yet called or processing until the client invokes
* {@link TailcallVarargs#eval()} which performs the tail call processing.
*
- * This method is typically not used directly by client code.
- * Instead use one of the function invocation methods.
+ * This method is typically not used directly by client code. Instead use
+ * one of the function invocation methods.
*
* @param func {@link LuaValue} to be called as a tail call
* @param args {@link Varargs} containing the arguments to the call
@@ -3526,13 +4086,14 @@ public class LuaValue extends Varargs {
public static Varargs tailcallOf(LuaValue func, Varargs args) {
return new TailcallVarargs(func, args);
}
-
+
/**
* Callback used during tail call processing to invoke the function once.
*
* This may return a {@link TailcallVarargs} to be evaluated by the client.
*
- * This should not be called directly, instead use one of the call invocation functions.
+ * This should not be called directly, instead use one of the call
+ * invocation functions.
*
* @param args the arguments to the call invocation.
* @return Varargs the return values, possible a TailcallVarargs.
@@ -3545,34 +4106,51 @@ public class LuaValue extends Varargs {
return invoke(args);
}
- /** Hook for implementations such as LuaJC to load the environment of the main chunk
- * into the first upvalue location. If the function has no upvalues or is not a main chunk,
- * calling this will be no effect.
- * @param env The environment to load into the first upvalue, if there is one.
+ /**
+ * Hook for implementations such as LuaJC to load the environment of the
+ * main chunk into the first upvalue location. If the function has no
+ * upvalues or is not a main chunk, calling this will be no effect.
+ *
+ * @param env The environment to load into the first upvalue, if there is
+ * one.
*/
public void initupvalue1(LuaValue env) {}
- /** Varargs implemenation with no values.
+ /**
+ * Varargs implemenation with no values.
*
- * This is an internal class not intended to be used directly.
- * Instead use the predefined constant {@link LuaValue#NONE}
+ * This is an internal class not intended to be used directly. Instead use
+ * the predefined constant {@link LuaValue#NONE}
*
* @see LuaValue#NONE
*/
private static final class None extends LuaNil {
static None _NONE = new None();
+
public LuaValue arg(int i) { return NIL; }
+
public int narg() { return 0; }
+
public LuaValue arg1() { return NIL; }
+
public String tojstring() { return "none"; }
+
public Varargs subargs(final int start) { return start > 0? this: argerror(1, "start must be > 0"); }
- void copyto(LuaValue[] dest, int offset, int length) { for(;length>0; length--) dest[offset++] = NIL; }
+
+ void copyto(LuaValue[] dest, int offset, int length) {
+ for (; length > 0; length--)
+ dest[offset++] = NIL;
+ }
}
-
+
/**
- * Create a {@code Varargs} instance containing arguments starting at index {@code start}
- * @param start the index from which to include arguments, where 1 is the first argument.
- * @return Varargs containing argument { start, start+1, ... , narg-start-1 }
+ * Create a {@code Varargs} instance containing arguments starting at index
+ * {@code start}
+ *
+ * @param start the index from which to include arguments, where 1 is the
+ * first argument.
+ * @return Varargs containing argument { start, start+1, ... , narg-start-1
+ * }
*/
public Varargs subargs(final int start) {
if (start == 1)
diff --git a/luaj-core/src/main/java/org/luaj/vm2/Metatable.java b/luaj-core/src/main/java/org/luaj/vm2/Metatable.java
index 49c639b6..70f7418e 100644
--- a/luaj-core/src/main/java/org/luaj/vm2/Metatable.java
+++ b/luaj-core/src/main/java/org/luaj/vm2/Metatable.java
@@ -38,14 +38,14 @@ interface Metatable {
public LuaValue toLuaValue();
/** Return an instance of Slot appropriate for the given key and value. */
- public Slot entry( LuaValue key, LuaValue value );
+ public Slot entry(LuaValue key, LuaValue value);
/** Returns the given value wrapped in a weak reference if appropriate. */
- public LuaValue wrap( LuaValue value );
+ public LuaValue wrap(LuaValue value);
/**
- * Returns the value at the given index in the array, or null if it is a weak reference that
- * has been dropped.
+ * Returns the value at the given index in the array, or null if it is a
+ * weak reference that has been dropped.
*/
public LuaValue arrayget(LuaValue[] array, int index);
}
diff --git a/luaj-core/src/main/java/org/luaj/vm2/OrphanedThread.java b/luaj-core/src/main/java/org/luaj/vm2/OrphanedThread.java
index b3c931f1..a1ff7a50 100644
--- a/luaj-core/src/main/java/org/luaj/vm2/OrphanedThread.java
+++ b/luaj-core/src/main/java/org/luaj/vm2/OrphanedThread.java
@@ -29,7 +29,8 @@ package org.luaj.vm2;
* {@link LuaThread} being used as a coroutine that could not possibly be
* resumed again because there are no more references to the LuaThread with
* which it is associated. Rather than locking up resources forever, this error
- * is thrown, and should fall through all the way to the thread's {@link Thread#run()} method.
+ * is thrown, and should fall through all the way to the thread's
+ * {@link Thread#run()} method.
*
* Java code mixed with the luaj vm should not catch this error because it may
* occur when the coroutine is not running, so any processing done during error
diff --git a/luaj-core/src/main/java/org/luaj/vm2/Print.java b/luaj-core/src/main/java/org/luaj/vm2/Print.java
index 8b0bd572..585d5bbd 100644
--- a/luaj-core/src/main/java/org/luaj/vm2/Print.java
+++ b/luaj-core/src/main/java/org/luaj/vm2/Print.java
@@ -25,131 +25,96 @@ import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
/**
- * Debug helper class to pretty-print lua bytecodes.
+ * Debug helper class to pretty-print lua bytecodes.
+ *
* @see Prototype
- * @see LuaClosure
+ * @see LuaClosure
*/
public class Print extends Lua {
/** opcode names */
private static final String STRING_FOR_NULL = "null";
- public static PrintStream ps = System.out;
+ public static PrintStream ps = System.out;
/** String names for each lua opcode value. */
- public static final String[] OPNAMES = {
- "MOVE",
- "LOADK",
- "LOADKX",
- "LOADBOOL",
- "LOADNIL",
- "GETUPVAL",
- "GETTABUP",
- "GETTABLE",
- "SETTABUP",
- "SETUPVAL",
- "SETTABLE",
- "NEWTABLE",
- "SELF",
- "ADD",
- "SUB",
- "MUL",
- "DIV",
- "MOD",
- "POW",
- "UNM",
- "NOT",
- "LEN",
- "CONCAT",
- "JMP",
- "EQ",
- "LT",
- "LE",
- "TEST",
- "TESTSET",
- "CALL",
- "TAILCALL",
- "RETURN",
- "FORLOOP",
- "FORPREP",
- "TFORCALL",
- "TFORLOOP",
- "SETLIST",
- "CLOSURE",
- "VARARG",
- "EXTRAARG",
- null,
- };
-
+ public static final String[] OPNAMES = { "MOVE", "LOADK", "LOADKX", "LOADBOOL", "LOADNIL", "GETUPVAL", "GETTABUP",
+ "GETTABLE", "SETTABUP", "SETUPVAL", "SETTABLE", "NEWTABLE", "SELF", "ADD", "SUB", "MUL", "DIV", "MOD",
+ "POW", "UNM", "NOT", "LEN", "CONCAT", "JMP", "EQ", "LT", "LE", "TEST", "TESTSET", "CALL", "TAILCALL",
+ "RETURN", "FORLOOP", "FORPREP", "TFORCALL", "TFORLOOP", "SETLIST", "CLOSURE", "VARARG", "EXTRAARG", null, };
static void printString(PrintStream ps, final LuaString s) {
-
+
ps.print('"');
for (int i = 0, n = s.m_length; i < n; i++) {
int c = s.m_bytes[s.m_offset+i];
- if ( c >= ' ' && c <= '~' && c != '\"' && c != '\\' )
+ if (c >= ' ' && c <= '~' && c != '\"' && c != '\\')
ps.print((char) c);
else {
switch (c) {
- case '"':
- ps.print("\\\"");
- break;
- case '\\':
- ps.print("\\\\");
- break;
- case 0x0007: /* bell */
- ps.print("\\a");
- break;
- case '\b': /* backspace */
- ps.print("\\b");
- break;
- case '\f': /* form feed */
- ps.print("\\f");
- break;
- case '\t': /* tab */
- ps.print("\\t");
- break;
- case '\r': /* carriage return */
- ps.print("\\r");
- break;
- case '\n': /* newline */
- ps.print("\\n");
- break;
- case 0x000B: /* vertical tab */
- ps.print("\\v");
- break;
- default:
- ps.print('\\');
- ps.print(Integer.toString(1000 + 0xff&c).substring(1));
- break;
+ case '"':
+ ps.print("\\\"");
+ break;
+ case '\\':
+ ps.print("\\\\");
+ break;
+ case 0x0007: /* bell */
+ ps.print("\\a");
+ break;
+ case '\b': /* backspace */
+ ps.print("\\b");
+ break;
+ case '\f': /* form feed */
+ ps.print("\\f");
+ break;
+ case '\t': /* tab */
+ ps.print("\\t");
+ break;
+ case '\r': /* carriage return */
+ ps.print("\\r");
+ break;
+ case '\n': /* newline */
+ ps.print("\\n");
+ break;
+ case 0x000B: /* vertical tab */
+ ps.print("\\v");
+ break;
+ default:
+ ps.print('\\');
+ ps.print(Integer.toString(1000+0xff & c).substring(1));
+ break;
}
}
}
ps.print('"');
}
- static void printValue( PrintStream ps, LuaValue v ) {
+ static void printValue(PrintStream ps, LuaValue v) {
if (v == null) {
ps.print("null");
return;
}
- switch ( v.type() ) {
- case LuaValue.TSTRING: printString( ps, (LuaString) v ); break;
- default: ps.print( v.tojstring() );
-
+ switch (v.type()) {
+ case LuaValue.TSTRING:
+ printString(ps, (LuaString) v);
+ break;
+ default:
+ ps.print(v.tojstring());
+
}
}
-
+
static void printConstant(PrintStream ps, Prototype f, int i) {
- printValue( ps, i < f.k.length ? f.k[i] : LuaValue.valueOf("UNKNOWN_CONST_" + i) );
+ printValue(ps, i < f.k.length? f.k[i]: LuaValue.valueOf("UNKNOWN_CONST_" + i));
}
static void printUpvalue(PrintStream ps, Upvaldesc u) {
- ps.print( u.idx + " " );
- printValue( ps, u.name );
+ ps.print(u.idx + " ");
+ printValue(ps, u.name);
}
- /**
+ /**
* Print the code in a prototype
+ *
* @param f the {@link Prototype}
*/
public static void printCode(Prototype f) {
@@ -161,20 +126,22 @@ public class Print extends Lua {
}
}
- /**
+ /**
* Print an opcode in a prototype
- * @param f the {@link Prototype}
+ *
+ * @param f the {@link Prototype}
* @param pc the program counter to look up and print
* @return pc same as above or changed
*/
public static int printOpCode(Prototype f, int pc) {
- return printOpCode(ps,f,pc);
+ return printOpCode(ps, f, pc);
}
-
- /**
+
+ /**
* Print an opcode in a prototype
+ *
* @param ps the {@link PrintStream} to print to
- * @param f the {@link Prototype}
+ * @param f the {@link Prototype}
* @param pc the program counter to look up and print
* @return pc same as above or changed
*/
@@ -188,33 +155,33 @@ public class Print extends Lua {
int bx = GETARG_Bx(i);
int sbx = GETARG_sBx(i);
int line = getline(f, pc);
- ps.print(" " + (pc + 1) + " ");
+ ps.print(" " + (pc+1) + " ");
if (line > 0)
ps.print("[" + line + "] ");
else
ps.print("[-] ");
- if (o >= OPNAMES.length - 1) {
+ if (o >= OPNAMES.length-1) {
ps.print("UNKNOWN_OP_" + o + " ");
} else {
ps.print(OPNAMES[o] + " ");
switch (getOpMode(o)) {
case iABC:
- ps.print( a );
+ ps.print(a);
if (getBMode(o) != OpArgN)
- ps.print(" "+(ISK(b) ? (-1 - INDEXK(b)) : b));
+ ps.print(" " + (ISK(b)? (-1-INDEXK(b)): b));
if (getCMode(o) != OpArgN)
- ps.print(" "+(ISK(c) ? (-1 - INDEXK(c)) : c));
+ ps.print(" " + (ISK(c)? (-1-INDEXK(c)): c));
break;
case iABx:
if (getBMode(o) == OpArgK) {
- ps.print(a + " " + (-1 - bx));
+ ps.print(a + " " + (-1-bx));
} else {
ps.print(a + " " + (bx));
}
break;
case iAsBx:
if (o == OP_JMP)
- ps.print( sbx );
+ ps.print(sbx);
else
ps.print(a + " " + sbx);
break;
@@ -231,7 +198,7 @@ public class Print extends Lua {
printUpvalue(ps, f.upvalues[b]);
} else {
ps.print("UNKNOWN_UPVALUE_" + b);
- }
+ }
break;
case OP_GETTABUP:
ps.print(" ; ");
@@ -296,7 +263,7 @@ public class Print extends Lua {
case OP_JMP:
case OP_FORLOOP:
case OP_FORPREP:
- ps.print(" ; to " + (sbx + pc + 2));
+ ps.print(" ; to " + (sbx+pc+2));
break;
case OP_CLOSURE:
if (bx < f.p.length) {
@@ -312,8 +279,8 @@ public class Print extends Lua {
ps.print(" ; " + ((int) c));
break;
case OP_VARARG:
- ps.print( " ; is_vararg="+ f.is_vararg );
- break;
+ ps.print(" ; is_vararg=" + f.is_vararg);
+ break;
default:
break;
}
@@ -322,7 +289,7 @@ public class Print extends Lua {
}
private static int getline(Prototype f, int pc) {
- return pc>0 && f.lineinfo!=null && pc
- * Generally, the {@link Prototype} is not constructed directly is an intermediate result
- * as lua code is loaded using {@link Globals#load(java.io.Reader, String)}:
- *
- * To create a {@link Prototype} directly, a compiler such as
+ * To create a {@link Prototype} directly, a compiler such as
* {@link org.luaj.vm2.compiler.LuaC} may be used:
- *
- *
+ *
* @see LuaClosure
* @see Globals
* @see Globals#undumper
@@ -84,8 +116,8 @@ package org.luaj.vm2;
public class Prototype {
/* constants used by the function */
- public LuaValue[] k;
- public int[] code;
+ public LuaValue[] k;
+ public int[] code;
/* functions defined inside the function */
public Prototype[] p;
/* map from opcodes to source lines */
@@ -93,14 +125,14 @@ public class Prototype {
/* information about local variables */
public LocVars[] locvars;
/* upvalue information */
- public Upvaldesc[] upvalues;
- public LuaString source;
- public int linedefined;
- public int lastlinedefined;
- public int numparams;
- public int is_vararg;
- public int maxstacksize;
- private static final Upvaldesc[] NOUPVALUES = {};
+ public Upvaldesc[] upvalues;
+ public LuaString source;
+ public int linedefined;
+ public int lastlinedefined;
+ public int numparams;
+ public int is_vararg;
+ public int maxstacksize;
+ private static final Upvaldesc[] NOUPVALUES = {};
private static final Prototype[] NOSUBPROTOS = {};
public Prototype() {
@@ -112,35 +144,36 @@ public class Prototype {
p = NOSUBPROTOS;
upvalues = new Upvaldesc[n_upvalues];
}
-
+
public String toString() {
- return source + ":" + linedefined+"-"+lastlinedefined;
+ return source + ":" + linedefined + "-" + lastlinedefined;
}
-
- /** Get the name of a local variable.
+
+ /**
+ * Get the name of a local variable.
*
* @param number the local variable number to look up
- * @param pc the program counter
+ * @param pc the program counter
* @return the name, or null if not found
*/
public LuaString getlocalname(int number, int pc) {
- int i;
- for (i = 0; i
- * The tail call holds the next function and arguments,
- * and the client a call to {@link #eval()} executes the function
- * repeatedly until the tail calls are completed.
+ * The tail call holds the next function and arguments, and the client a call to
+ * {@link #eval()} executes the function repeatedly until the tail calls are
+ * completed.
*
- * Normally, users of luaj need not concern themselves with the
- * details of this mechanism, as it is built into the core
- * execution framework.
- * @see Prototype
+ * Normally, users of luaj need not concern themselves with the details of this
+ * mechanism, as it is built into the core execution framework.
+ *
+ * @see Prototype
* @see org.luaj.vm2.luajc.LuaJC
*/
public class TailcallVarargs extends Varargs {
private LuaValue func;
- private Varargs args;
- private Varargs result;
-
+ private Varargs args;
+ private Varargs result;
+
public TailcallVarargs(LuaValue f, Varargs args) {
this.func = f;
this.args = args;
}
-
+
public TailcallVarargs(LuaValue object, LuaValue methodname, Varargs args) {
this.func = object.get(methodname);
this.args = LuaValue.varargsOf(object, args);
}
-
- public boolean isTailcall() {
- return true;
- }
-
+
+ public boolean isTailcall() { return true; }
+
public Varargs eval() {
while ( result == null ) {
Varargs r = func.onInvoke(args);
@@ -67,28 +64,27 @@ public class TailcallVarargs extends Varargs {
TailcallVarargs t = (TailcallVarargs) r;
func = t.func;
args = t.args;
- }
- else {
- result = r;
+ } else {
+ result = r;
func = null;
args = null;
}
}
return result;
}
-
- public LuaValue arg( int i ) {
- if ( result == null )
+
+ public LuaValue arg(int i) {
+ if (result == null)
eval();
return result.arg(i);
}
-
+
public LuaValue arg1() {
if (result == null)
eval();
return result.arg1();
}
-
+
public int narg() {
if (result == null)
eval();
@@ -100,4 +96,4 @@ public class TailcallVarargs extends Varargs {
eval();
return result.subargs(start);
}
-}
\ No newline at end of file
+}
diff --git a/luaj-core/src/main/java/org/luaj/vm2/UpValue.java b/luaj-core/src/main/java/org/luaj/vm2/UpValue.java
index 8fa8186b..62a3ac4e 100644
--- a/luaj-core/src/main/java/org/luaj/vm2/UpValue.java
+++ b/luaj-core/src/main/java/org/luaj/vm2/UpValue.java
@@ -21,23 +21,25 @@
******************************************************************************/
package org.luaj.vm2;
-
-/** Upvalue used with Closure formulation
+/**
+ * Upvalue used with Closure formulation
*
+ *
* @see LuaClosure
* @see Prototype
*/
public final class UpValue {
LuaValue[] array; // initially the stack, becomes a holder
- int index;
+ int index;
/**
- * Create an upvalue relative to a stack
+ * Create an upvalue relative to a stack
+ *
* @param stack the stack
* @param index the index on the stack for the upvalue
*/
- public UpValue( LuaValue[] stack, int index) {
+ public UpValue(LuaValue[] stack, int index) {
this.array = stack;
this.index = index;
}
@@ -45,32 +47,31 @@ public final class UpValue {
public String toString() {
return index + "/" + array.length + " " + array[index];
}
-
- /**
+
+ /**
* Convert this upvalue to a Java String
+ *
* @return the Java String for this upvalue.
* @see LuaValue#tojstring()
*/
public String tojstring() {
return array[index].tojstring();
}
-
+
/**
* Get the value of the upvalue
+ *
* @return the {@link LuaValue} for this upvalue
*/
- public final LuaValue getValue() {
- return array[index];
- }
-
+ public final LuaValue getValue() { return array[index]; }
+
/**
* Set the value of the upvalue
+ *
* @param value the {@link LuaValue} to set it to
*/
- public final void setValue( LuaValue value ) {
- array[index] = value;
- }
-
+ public final void setValue(LuaValue value) { array[index] = value; }
+
/**
* Close this upvalue so it is no longer on the stack
*/
diff --git a/luaj-core/src/main/java/org/luaj/vm2/Upvaldesc.java b/luaj-core/src/main/java/org/luaj/vm2/Upvaldesc.java
index c1e44974..041e8e33 100644
--- a/luaj-core/src/main/java/org/luaj/vm2/Upvaldesc.java
+++ b/luaj-core/src/main/java/org/luaj/vm2/Upvaldesc.java
@@ -25,20 +25,20 @@ public class Upvaldesc {
/* upvalue name (for debug information) */
public LuaString name;
-
+
/* whether it is in stack */
public final boolean instack;
-
+
/* index of upvalue (in stack or in outer function's list) */
public final short idx;
-
+
public Upvaldesc(LuaString name, boolean instack, int idx) {
this.name = name;
this.instack = instack;
this.idx = (short) idx;
}
-
+
public String toString() {
- return idx + (instack? " instack ": " closed ") + String.valueOf(name);
+ return idx+(instack? " instack ": " closed ")+String.valueOf(name);
}
}
diff --git a/luaj-core/src/main/java/org/luaj/vm2/Varargs.java b/luaj-core/src/main/java/org/luaj/vm2/Varargs.java
index e56d8dcf..b5f6c05e 100644
--- a/luaj-core/src/main/java/org/luaj/vm2/Varargs.java
+++ b/luaj-core/src/main/java/org/luaj/vm2/Varargs.java
@@ -22,21 +22,23 @@
package org.luaj.vm2;
/**
- * Class to encapsulate varargs values, either as part of a variable argument list, or multiple return values.
+ * Class to encapsulate varargs values, either as part of a variable argument
+ * list, or multiple return values.
*
* To construct varargs, use one of the static methods such as
* {@code LuaValue.varargsOf(LuaValue,LuaValue)}
*
*
- * Any LuaValue can be used as a stand-in for Varargs, for both calls and return values.
- * When doing so, nargs() will return 1 and arg1() or arg(1) will return this.
- * This simplifies the case when calling or implementing varargs functions with only
- * 1 argument or 1 return value.
+ * Any LuaValue can be used as a stand-in for Varargs, for both calls and return
+ * values. When doing so, nargs() will return 1 and arg1() or arg(1) will return
+ * this. This simplifies the case when calling or implementing varargs functions
+ * with only 1 argument or 1 return value.
*
- * Varargs can also be derived from other varargs by appending to the front with a call
- * such as {@code LuaValue.varargsOf(LuaValue,Varargs)}
- * or by taking a portion of the args using {@code Varargs.subargs(int start)}
+ * Varargs can also be derived from other varargs by appending to the front with
+ * a call such as {@code LuaValue.varargsOf(LuaValue,Varargs)} or by taking a
+ * portion of the args using {@code Varargs.subargs(int start)}
*
+ *
* @see LuaValue#varargsOf(LuaValue[])
* @see LuaValue#varargsOf(LuaValue, Varargs)
* @see LuaValue#varargsOf(LuaValue[], Varargs)
@@ -49,22 +51,26 @@ public abstract class Varargs {
/**
* Get the n-th argument value (1-based).
+ *
* @param i the index of the argument to get, 1 is the first argument
* @return Value at position i, or LuaValue.NIL if there is none.
* @see Varargs#arg1()
* @see LuaValue#NIL
*/
- abstract public LuaValue arg( int i );
-
+ abstract public LuaValue arg(int i);
+
/**
* Get the number of arguments, or 0 if there are none.
+ *
* @return number of arguments.
*/
abstract public int narg();
-
+
/**
* Get the first argument in the list.
- * @return LuaValue which is first in the list, or LuaValue.NIL if there are no values.
+ *
+ * @return LuaValue which is first in the list, or LuaValue.NIL if there are
+ * no values.
* @see Varargs#arg(int)
* @see LuaValue#NIL
*/
@@ -72,25 +78,28 @@ public abstract class Varargs {
/**
* Evaluate any pending tail call and return result.
+ *
* @return the evaluated tail call result
*/
public Varargs eval() { return this; }
-
+
/**
* Return true if this is a TailcallVarargs
+ *
* @return true if a tail call, false otherwise
*/
- public boolean isTailcall() {
- return false;
- }
-
+ public boolean isTailcall() { return false; }
+
// -----------------------------------------------------------------------
// utilities to get specific arguments and type-check them.
// -----------------------------------------------------------------------
-
- /** Gets the type of argument {@code i}
+
+ /**
+ * Gets the type of argument {@code i}
+ *
* @param i the index of the argument to convert, 1 is the first argument
- * @return int value corresponding to one of the LuaValue integer type values
+ * @return int value corresponding to one of the LuaValue integer type
+ * values
* @see LuaValue#TNIL
* @see LuaValue#TBOOLEAN
* @see LuaValue#TNUMBER
@@ -99,438 +108,621 @@ public abstract class Varargs {
* @see LuaValue#TFUNCTION
* @see LuaValue#TUSERDATA
* @see LuaValue#TTHREAD
- * */
- public int type(int i) { return arg(i).type(); }
-
- /** Tests if argument i is nil.
+ */
+ public int type(int i) { return arg(i).type(); }
+
+ /**
+ * Tests if argument i is nil.
+ *
* @param i the index of the argument to test, 1 is the first argument
* @return true if the argument is nil or does not exist, false otherwise
* @see LuaValue#TNIL
- * */
- public boolean isnil(int i) { return arg(i).isnil(); }
+ */
+ public boolean isnil(int i) { return arg(i).isnil(); }
- /** Tests if argument i is a function.
+ /**
+ * Tests if argument i is a function.
+ *
* @param i the index of the argument to test, 1 is the first argument
- * @return true if the argument exists and is a function or closure, false otherwise
+ * @return true if the argument exists and is a function or closure, false
+ * otherwise
* @see LuaValue#TFUNCTION
- * */
- public boolean isfunction(int i) { return arg(i).isfunction(); }
+ */
+ public boolean isfunction(int i) { return arg(i).isfunction(); }
- /** Tests if argument i is a number.
- * Since anywhere a number is required, a string can be used that
- * is a number, this will return true for both numbers and
- * strings that can be interpreted as numbers.
+ /**
+ * Tests if argument i is a number. Since anywhere a number is required, a
+ * string can be used that is a number, this will return true for both
+ * numbers and strings that can be interpreted as numbers.
+ *
* @param i the index of the argument to test, 1 is the first argument
- * @return true if the argument exists and is a number or
- * string that can be interpreted as a number, false otherwise
+ * @return true if the argument exists and is a number or string that can be
+ * interpreted as a number, false otherwise
* @see LuaValue#TNUMBER
* @see LuaValue#TSTRING
- * */
- public boolean isnumber(int i) { return arg(i).isnumber(); }
+ */
+ public boolean isnumber(int i) { return arg(i).isnumber(); }
- /** Tests if argument i is a string.
- * Since all lua numbers can be used where strings are used,
- * this will return true for both strings and numbers.
+ /**
+ * Tests if argument i is a string. Since all lua numbers can be used where
+ * strings are used, this will return true for both strings and numbers.
+ *
* @param i the index of the argument to test, 1 is the first argument
- * @return true if the argument exists and is a string or number, false otherwise
+ * @return true if the argument exists and is a string or number, false
+ * otherwise
* @see LuaValue#TNUMBER
* @see LuaValue#TSTRING
- * */
- public boolean isstring(int i) { return arg(i).isstring(); }
+ */
+ public boolean isstring(int i) { return arg(i).isstring(); }
- /** Tests if argument i is a table.
+ /**
+ * Tests if argument i is a table.
+ *
* @param i the index of the argument to test, 1 is the first argument
* @return true if the argument exists and is a lua table, false otherwise
* @see LuaValue#TTABLE
- * */
- public boolean istable(int i) { return arg(i).istable(); }
+ */
+ public boolean istable(int i) { return arg(i).istable(); }
- /** Tests if argument i is a thread.
+ /**
+ * Tests if argument i is a thread.
+ *
* @param i the index of the argument to test, 1 is the first argument
* @return true if the argument exists and is a lua thread, false otherwise
* @see LuaValue#TTHREAD
- * */
- public boolean isthread(int i) { return arg(i).isthread(); }
+ */
+ public boolean isthread(int i) { return arg(i).isthread(); }
- /** Tests if argument i is a userdata.
+ /**
+ * Tests if argument i is a userdata.
+ *
* @param i the index of the argument to test, 1 is the first argument
* @return true if the argument exists and is a userdata, false otherwise
* @see LuaValue#TUSERDATA
- * */
- public boolean isuserdata(int i) { return arg(i).isuserdata(); }
+ */
+ public boolean isuserdata(int i) { return arg(i).isuserdata(); }
- /** Tests if a value exists at argument i.
+ /**
+ * Tests if a value exists at argument i.
+ *
* @param i the index of the argument to test, 1 is the first argument
* @return true if the argument exists, false otherwise
- * */
- public boolean isvalue(int i) { return i>0 && i<=narg(); }
-
- /** Return argument i as a boolean value, {@code defval} if nil, or throw a LuaError if any other type.
+ */
+ public boolean isvalue(int i) { return i > 0 && i <= narg(); }
+
+ /**
+ * Return argument i as a boolean value, {@code defval} if nil, or throw a
+ * LuaError if any other type.
+ *
* @param i the index of the argument to test, 1 is the first argument
- * @return true if argument i is boolean true, false if it is false, or defval if not supplied or nil
+ * @return true if argument i is boolean true, false if it is false, or
+ * defval if not supplied or nil
* @exception LuaError if the argument is not a lua boolean
- * */
- public boolean optboolean(int i, boolean defval) { return arg(i).optboolean(defval); }
+ */
+ public boolean optboolean(int i, boolean defval) { return arg(i).optboolean(defval); }
- /** Return argument i as a closure, {@code defval} if nil, or throw a LuaError if any other type.
+ /**
+ * Return argument i as a closure, {@code defval} if nil, or throw a
+ * LuaError if any other type.
+ *
* @param i the index of the argument to test, 1 is the first argument
- * @return LuaClosure if argument i is a closure, or defval if not supplied or nil
+ * @return LuaClosure if argument i is a closure, or defval if not supplied
+ * or nil
* @exception LuaError if the argument is not a lua closure
- * */
- public LuaClosure optclosure(int i, LuaClosure defval) { return arg(i).optclosure(defval); }
+ */
+ public LuaClosure optclosure(int i, LuaClosure defval) { return arg(i).optclosure(defval); }
- /** Return argument i as a double, {@code defval} if nil, or throw a LuaError if it cannot be converted to one.
+ /**
+ * Return argument i as a double, {@code defval} if nil, or throw a LuaError
+ * if it cannot be converted to one.
+ *
* @param i the index of the argument to test, 1 is the first argument
- * @return java double value if argument i is a number or string that converts to a number, or defval if not supplied or nil
+ * @return java double value if argument i is a number or string that
+ * converts to a number, or defval if not supplied or nil
* @exception LuaError if the argument is not a number
- * */
- public double optdouble(int i, double defval) { return arg(i).optdouble(defval); }
+ */
+ public double optdouble(int i, double defval) { return arg(i).optdouble(defval); }
- /** Return argument i as a function, {@code defval} if nil, or throw a LuaError if an incompatible type.
+ /**
+ * Return argument i as a function, {@code defval} if nil, or throw a
+ * LuaError if an incompatible type.
+ *
* @param i the index of the argument to test, 1 is the first argument
- * @return LuaValue that can be called if argument i is lua function or closure, or defval if not supplied or nil
+ * @return LuaValue that can be called if argument i is lua function or
+ * closure, or defval if not supplied or nil
* @exception LuaError if the argument is not a lua function or closure
- * */
- public LuaFunction optfunction(int i, LuaFunction defval) { return arg(i).optfunction(defval); }
+ */
+ public LuaFunction optfunction(int i, LuaFunction defval) { return arg(i).optfunction(defval); }
- /** Return argument i as a java int value, discarding any fractional part, {@code defval} if nil, or throw a LuaError if not a number.
+ /**
+ * Return argument i as a java int value, discarding any fractional part,
+ * {@code defval} if nil, or throw a LuaError if not a number.
+ *
* @param i the index of the argument to test, 1 is the first argument
- * @return int value with fraction discarded and truncated if necessary if argument i is number, or defval if not supplied or nil
+ * @return int value with fraction discarded and truncated if necessary if
+ * argument i is number, or defval if not supplied or nil
* @exception LuaError if the argument is not a number
- * */
- public int optint(int i, int defval) { return arg(i).optint(defval); }
+ */
+ public int optint(int i, int defval) { return arg(i).optint(defval); }
- /** Return argument i as a java int value, {@code defval} if nil, or throw a LuaError if not a number or is not representable by a java int.
+ /**
+ * Return argument i as a java int value, {@code defval} if nil, or throw a
+ * LuaError if not a number or is not representable by a java int.
+ *
* @param i the index of the argument to test, 1 is the first argument
- * @return LuaInteger value that fits in a java int without rounding, or defval if not supplied or nil
- * @exception LuaError if the argument cannot be represented by a java int value
- * */
- public LuaInteger optinteger(int i, LuaInteger defval) { return arg(i).optinteger(defval); }
+ * @return LuaInteger value that fits in a java int without rounding, or
+ * defval if not supplied or nil
+ * @exception LuaError if the argument cannot be represented by a java int
+ * value
+ */
+ public LuaInteger optinteger(int i, LuaInteger defval) { return arg(i).optinteger(defval); }
- /** Return argument i as a java long value, discarding any fractional part, {@code defval} if nil, or throw a LuaError if not a number.
+ /**
+ * Return argument i as a java long value, discarding any fractional part,
+ * {@code defval} if nil, or throw a LuaError if not a number.
+ *
* @param i the index of the argument to test, 1 is the first argument
- * @return long value with fraction discarded and truncated if necessary if argument i is number, or defval if not supplied or nil
+ * @return long value with fraction discarded and truncated if necessary if
+ * argument i is number, or defval if not supplied or nil
* @exception LuaError if the argument is not a number
- * */
- public long optlong(int i, long defval) { return arg(i).optlong(defval); }
+ */
+ public long optlong(int i, long defval) { return arg(i).optlong(defval); }
- /** Return argument i as a LuaNumber, {@code defval} if nil, or throw a LuaError if not a number or string that can be converted to a number.
- * @param i the index of the argument to test, 1 is the first argument, or defval if not supplied or nil
+ /**
+ * Return argument i as a LuaNumber, {@code defval} if nil, or throw a
+ * LuaError if not a number or string that can be converted to a number.
+ *
+ * @param i the index of the argument to test, 1 is the first argument, or
+ * defval if not supplied or nil
* @return LuaNumber if argument i is number or can be converted to a number
* @exception LuaError if the argument is not a number
- * */
- public LuaNumber optnumber(int i, LuaNumber defval) { return arg(i).optnumber(defval); }
+ */
+ public LuaNumber optnumber(int i, LuaNumber defval) { return arg(i).optnumber(defval); }
- /** Return argument i as a java String if a string or number, {@code defval} if nil, or throw a LuaError if any other type
+ /**
+ * Return argument i as a java String if a string or number, {@code defval}
+ * if nil, or throw a LuaError if any other type
+ *
* @param i the index of the argument to test, 1 is the first argument
- * @return String value if argument i is a string or number, or defval if not supplied or nil
+ * @return String value if argument i is a string or number, or defval if
+ * not supplied or nil
* @exception LuaError if the argument is not a string or number
- * */
- public String optjstring(int i, String defval) { return arg(i).optjstring(defval); }
+ */
+ public String optjstring(int i, String defval) { return arg(i).optjstring(defval); }
- /** Return argument i as a LuaString if a string or number, {@code defval} if nil, or throw a LuaError if any other type
+ /**
+ * Return argument i as a LuaString if a string or number, {@code defval} if
+ * nil, or throw a LuaError if any other type
+ *
* @param i the index of the argument to test, 1 is the first argument
- * @return LuaString value if argument i is a string or number, or defval if not supplied or nil
+ * @return LuaString value if argument i is a string or number, or defval if
+ * not supplied or nil
* @exception LuaError if the argument is not a string or number
- * */
- public LuaString optstring(int i, LuaString defval) { return arg(i).optstring(defval); }
+ */
+ public LuaString optstring(int i, LuaString defval) { return arg(i).optstring(defval); }
- /** Return argument i as a LuaTable if a lua table, {@code defval} if nil, or throw a LuaError if any other type.
+ /**
+ * Return argument i as a LuaTable if a lua table, {@code defval} if nil, or
+ * throw a LuaError if any other type.
+ *
* @param i the index of the argument to test, 1 is the first argument
* @return LuaTable value if a table, or defval if not supplied or nil
* @exception LuaError if the argument is not a lua table
- * */
- public LuaTable opttable(int i, LuaTable defval) { return arg(i).opttable(defval); }
+ */
+ public LuaTable opttable(int i, LuaTable defval) { return arg(i).opttable(defval); }
- /** Return argument i as a LuaThread if a lua thread, {@code defval} if nil, or throw a LuaError if any other type.
+ /**
+ * Return argument i as a LuaThread if a lua thread, {@code defval} if nil,
+ * or throw a LuaError if any other type.
+ *
* @param i the index of the argument to test, 1 is the first argument
* @return LuaThread value if a thread, or defval if not supplied or nil
* @exception LuaError if the argument is not a lua thread
- * */
- public LuaThread optthread(int i, LuaThread defval) { return arg(i).optthread(defval); }
+ */
+ public LuaThread optthread(int i, LuaThread defval) { return arg(i).optthread(defval); }
- /** Return argument i as a java Object if a userdata, {@code defval} if nil, or throw a LuaError if any other type.
+ /**
+ * Return argument i as a java Object if a userdata, {@code defval} if nil,
+ * or throw a LuaError if any other type.
+ *
* @param i the index of the argument to test, 1 is the first argument
- * @return java Object value if argument i is a userdata, or defval if not supplied or nil
+ * @return java Object value if argument i is a userdata, or defval if not
+ * supplied or nil
* @exception LuaError if the argument is not a userdata
- * */
- public Object optuserdata(int i, Object defval) { return arg(i).optuserdata(defval); }
+ */
+ public Object optuserdata(int i, Object defval) { return arg(i).optuserdata(defval); }
- /** Return argument i as a java Object if it is a userdata whose instance Class c or a subclass,
- * {@code defval} if nil, or throw a LuaError if any other type.
+ /**
+ * Return argument i as a java Object if it is a userdata whose instance
+ * Class c or a subclass, {@code defval} if nil, or throw a LuaError if any
+ * other type.
+ *
* @param i the index of the argument to test, 1 is the first argument
* @param c the class to which the userdata instance must be assignable
- * @return java Object value if argument i is a userdata whose instance Class c or a subclass, or defval if not supplied or nil
- * @exception LuaError if the argument is not a userdata or from whose instance c is not assignable
- * */
- public Object optuserdata(int i, Class c, Object defval) { return arg(i).optuserdata(c,defval); }
+ * @return java Object value if argument i is a userdata whose instance
+ * Class c or a subclass, or defval if not supplied or nil
+ * @exception LuaError if the argument is not a userdata or from whose
+ * instance c is not assignable
+ */
+ public Object optuserdata(int i, Class c, Object defval) { return arg(i).optuserdata(c, defval); }
- /** Return argument i as a LuaValue if it exists, or {@code defval}.
+ /**
+ * Return argument i as a LuaValue if it exists, or {@code defval}.
+ *
* @param i the index of the argument to test, 1 is the first argument
* @return LuaValue value if the argument exists, defval if not
* @exception LuaError if the argument does not exist.
- * */
- public LuaValue optvalue(int i, LuaValue defval) { return i>0 && i<=narg()? arg(i): defval; }
+ */
+ public LuaValue optvalue(int i, LuaValue defval) { return i > 0 && i <= narg()? arg(i): defval; }
- /** Return argument i as a boolean value, or throw an error if any other type.
+ /**
+ * Return argument i as a boolean value, or throw an error if any other
+ * type.
+ *
* @param i the index of the argument to test, 1 is the first argument
* @return true if argument i is boolean true, false if it is false
* @exception LuaError if the argument is not a lua boolean
- * */
- public boolean checkboolean(int i) { return arg(i).checkboolean(); }
+ */
+ public boolean checkboolean(int i) { return arg(i).checkboolean(); }
- /** Return argument i as a closure, or throw an error if any other type.
+ /**
+ * Return argument i as a closure, or throw an error if any other type.
+ *
* @param i the index of the argument to test, 1 is the first argument
* @return LuaClosure if argument i is a closure.
* @exception LuaError if the argument is not a lua closure
- * */
- public LuaClosure checkclosure(int i) { return arg(i).checkclosure(); }
+ */
+ public LuaClosure checkclosure(int i) { return arg(i).checkclosure(); }
- /** Return argument i as a double, or throw an error if it cannot be converted to one.
+ /**
+ * Return argument i as a double, or throw an error if it cannot be
+ * converted to one.
+ *
* @param i the index of the argument to test, 1 is the first argument
- * @return java double value if argument i is a number or string that converts to a number
+ * @return java double value if argument i is a number or string that
+ * converts to a number
* @exception LuaError if the argument is not a number
- * */
- public double checkdouble(int i) { return arg(i).checkdouble(); }
+ */
+ public double checkdouble(int i) { return arg(i).checkdouble(); }
- /** Return argument i as a function, or throw an error if an incompatible type.
+ /**
+ * Return argument i as a function, or throw an error if an incompatible
+ * type.
+ *
* @param i the index of the argument to test, 1 is the first argument
- * @return LuaValue that can be called if argument i is lua function or closure
+ * @return LuaValue that can be called if argument i is lua function or
+ * closure
* @exception LuaError if the argument is not a lua function or closure
- * */
- public LuaFunction checkfunction(int i) { return arg(i).checkfunction(); }
+ */
+ public LuaFunction checkfunction(int i) { return arg(i).checkfunction(); }
- /** Return argument i as a java int value, or throw an error if it cannot be converted to one.
+ /**
+ * Return argument i as a java int value, or throw an error if it cannot be
+ * converted to one.
+ *
* @param i the index of the argument to test, 1 is the first argument
- * @return int value if argument i is a number or string that converts to a number
- * @exception LuaError if the argument cannot be represented by a java int value
- * */
- public int checkint(int i) { return arg(i).checkint(); }
+ * @return int value if argument i is a number or string that converts to a
+ * number
+ * @exception LuaError if the argument cannot be represented by a java int
+ * value
+ */
+ public int checkint(int i) { return arg(i).checkint(); }
- /** Return argument i as a java int value, or throw an error if not a number or is not representable by a java int.
+ /**
+ * Return argument i as a java int value, or throw an error if not a number
+ * or is not representable by a java int.
+ *
* @param i the index of the argument to test, 1 is the first argument
* @return LuaInteger value that fits in a java int without rounding
- * @exception LuaError if the argument cannot be represented by a java int value
- * */
- public LuaInteger checkinteger(int i) { return arg(i).checkinteger(); }
+ * @exception LuaError if the argument cannot be represented by a java int
+ * value
+ */
+ public LuaInteger checkinteger(int i) { return arg(i).checkinteger(); }
- /** Return argument i as a java long value, or throw an error if it cannot be converted to one.
+ /**
+ * Return argument i as a java long value, or throw an error if it cannot be
+ * converted to one.
+ *
* @param i the index of the argument to test, 1 is the first argument
- * @return long value if argument i is a number or string that converts to a number
- * @exception LuaError if the argument cannot be represented by a java long value
- * */
- public long checklong(int i) { return arg(i).checklong(); }
+ * @return long value if argument i is a number or string that converts to a
+ * number
+ * @exception LuaError if the argument cannot be represented by a java long
+ * value
+ */
+ public long checklong(int i) { return arg(i).checklong(); }
- /** Return argument i as a LuaNumber, or throw an error if not a number or string that can be converted to a number.
+ /**
+ * Return argument i as a LuaNumber, or throw an error if not a number or
+ * string that can be converted to a number.
+ *
* @param i the index of the argument to test, 1 is the first argument
* @return LuaNumber if argument i is number or can be converted to a number
* @exception LuaError if the argument is not a number
- * */
- public LuaNumber checknumber(int i) { return arg(i).checknumber(); }
+ */
+ public LuaNumber checknumber(int i) { return arg(i).checknumber(); }
- /** Return argument i as a java String if a string or number, or throw an error if any other type
+ /**
+ * Return argument i as a java String if a string or number, or throw an
+ * error if any other type
+ *
* @param i the index of the argument to test, 1 is the first argument
* @return String value if argument i is a string or number
* @exception LuaError if the argument is not a string or number
- * */
- public String checkjstring(int i) { return arg(i).checkjstring(); }
+ */
+ public String checkjstring(int i) { return arg(i).checkjstring(); }
- /** Return argument i as a LuaString if a string or number, or throw an error if any other type
+ /**
+ * Return argument i as a LuaString if a string or number, or throw an error
+ * if any other type
+ *
* @param i the index of the argument to test, 1 is the first argument
* @return LuaString value if argument i is a string or number
* @exception LuaError if the argument is not a string or number
- * */
- public LuaString checkstring(int i) { return arg(i).checkstring(); }
+ */
+ public LuaString checkstring(int i) { return arg(i).checkstring(); }
- /** Return argument i as a LuaTable if a lua table, or throw an error if any other type.
+ /**
+ * Return argument i as a LuaTable if a lua table, or throw an error if any
+ * other type.
+ *
* @param i the index of the argument to test, 1 is the first argument
* @return LuaTable value if a table
* @exception LuaError if the argument is not a lua table
- * */
- public LuaTable checktable(int i) { return arg(i).checktable(); }
+ */
+ public LuaTable checktable(int i) { return arg(i).checktable(); }
- /** Return argument i as a LuaThread if a lua thread, or throw an error if any other type.
+ /**
+ * Return argument i as a LuaThread if a lua thread, or throw an error if
+ * any other type.
+ *
* @param i the index of the argument to test, 1 is the first argument
* @return LuaThread value if a thread
* @exception LuaError if the argument is not a lua thread
- * */
- public LuaThread checkthread(int i) { return arg(i).checkthread(); }
+ */
+ public LuaThread checkthread(int i) { return arg(i).checkthread(); }
- /** Return argument i as a java Object if a userdata, or throw an error if any other type.
+ /**
+ * Return argument i as a java Object if a userdata, or throw an error if
+ * any other type.
+ *
* @param i the index of the argument to test, 1 is the first argument
* @return java Object value if argument i is a userdata
* @exception LuaError if the argument is not a userdata
- * */
- public Object checkuserdata(int i) { return arg(i).checkuserdata(); }
+ */
+ public Object checkuserdata(int i) { return arg(i).checkuserdata(); }
- /** Return argument i as a java Object if it is a userdata whose instance Class c or a subclass,
- * or throw an error if any other type.
+ /**
+ * Return argument i as a java Object if it is a userdata whose instance
+ * Class c or a subclass, or throw an error if any other type.
+ *
* @param i the index of the argument to test, 1 is the first argument
* @param c the class to which the userdata instance must be assignable
- * @return java Object value if argument i is a userdata whose instance Class c or a subclass
- * @exception LuaError if the argument is not a userdata or from whose instance c is not assignable
- * */
- public Object checkuserdata(int i,Class c) { return arg(i).checkuserdata(c); }
+ * @return java Object value if argument i is a userdata whose instance
+ * Class c or a subclass
+ * @exception LuaError if the argument is not a userdata or from whose
+ * instance c is not assignable
+ */
+ public Object checkuserdata(int i, Class c) { return arg(i).checkuserdata(c); }
- /** Return argument i as a LuaValue if it exists, or throw an error.
+ /**
+ * Return argument i as a LuaValue if it exists, or throw an error.
+ *
* @param i the index of the argument to test, 1 is the first argument
* @return LuaValue value if the argument exists
* @exception LuaError if the argument does not exist.
- * */
- public LuaValue checkvalue(int i) { return i<=narg()? arg(i): LuaValue.argerror(i,"value expected"); }
+ */
+ public LuaValue checkvalue(int i) { return i <= narg()? arg(i): LuaValue.argerror(i, "value expected"); }
- /** Return argument i as a LuaValue if it is not nil, or throw an error if it is nil.
+ /**
+ * Return argument i as a LuaValue if it is not nil, or throw an error if it
+ * is nil.
+ *
* @param i the index of the argument to test, 1 is the first argument
* @return LuaValue value if the argument is not nil
* @exception LuaError if the argument doesn't exist or evaluates to nil.
- * */
- public LuaValue checknotnil(int i) { return arg(i).checknotnil(); }
-
- /** Performs test on argument i as a LuaValue when a user-supplied assertion passes, or throw an error.
- * Returns normally if the value of {@code test} is {@code true}, otherwise throws and argument error with
- * the supplied message, {@code msg}.
+ */
+ public LuaValue checknotnil(int i) { return arg(i).checknotnil(); }
+
+ /**
+ * Performs test on argument i as a LuaValue when a user-supplied assertion
+ * passes, or throw an error. Returns normally if the value of {@code test}
+ * is {@code true}, otherwise throws and argument error with the supplied
+ * message, {@code msg}.
+ *
* @param test user supplied assertion to test against
- * @param i the index to report in any error message
- * @param msg the error message to use when the test fails
+ * @param i the index to report in any error message
+ * @param msg the error message to use when the test fails
* @exception LuaError if the the value of {@code test} is {@code false}
- * */
- public void argcheck(boolean test, int i, String msg) { if (!test) LuaValue.argerror(i,msg); }
-
- /** Return true if there is no argument or nil at argument i.
+ */
+ public void argcheck(boolean test, int i, String msg) {
+ if (!test)
+ LuaValue.argerror(i, msg);
+ }
+
+ /**
+ * Return true if there is no argument or nil at argument i.
+ *
* @param i the index of the argument to test, 1 is the first argument
* @return true if argument i contains either no argument or nil
- * */
+ */
public boolean isnoneornil(int i) {
- return i>narg() || arg(i).isnil();
+ return i > narg() || arg(i).isnil();
}
-
- /** Convert argument {@code i} to java boolean based on lua rules for boolean evaluation.
- * @param i the index of the argument to convert, 1 is the first argument
- * @return {@code false} if argument i is nil or false, otherwise {@code true}
- * */
- public boolean toboolean(int i) { return arg(i).toboolean(); }
- /** Return argument i as a java byte value, discarding any fractional part and truncating,
- * or 0 if not a number.
+ /**
+ * Convert argument {@code i} to java boolean based on lua rules for boolean
+ * evaluation.
+ *
* @param i the index of the argument to convert, 1 is the first argument
- * @return byte value with fraction discarded and truncated if necessary if argument i is number, otherwise 0
- * */
- public byte tobyte(int i) { return arg(i).tobyte(); }
-
- /** Return argument i as a java char value, discarding any fractional part and truncating,
- * or 0 if not a number.
- * @param i the index of the argument to convert, 1 is the first argument
- * @return char value with fraction discarded and truncated if necessary if argument i is number, otherwise 0
- * */
- public char tochar(int i) { return arg(i).tochar(); }
+ * @return {@code false} if argument i is nil or false, otherwise
+ * {@code true}
+ */
+ public boolean toboolean(int i) { return arg(i).toboolean(); }
- /** Return argument i as a java double value or 0 if not a number.
+ /**
+ * Return argument i as a java byte value, discarding any fractional part
+ * and truncating, or 0 if not a number.
+ *
+ * @param i the index of the argument to convert, 1 is the first argument
+ * @return byte value with fraction discarded and truncated if necessary if
+ * argument i is number, otherwise 0
+ */
+ public byte tobyte(int i) { return arg(i).tobyte(); }
+
+ /**
+ * Return argument i as a java char value, discarding any fractional part
+ * and truncating, or 0 if not a number.
+ *
+ * @param i the index of the argument to convert, 1 is the first argument
+ * @return char value with fraction discarded and truncated if necessary if
+ * argument i is number, otherwise 0
+ */
+ public char tochar(int i) { return arg(i).tochar(); }
+
+ /**
+ * Return argument i as a java double value or 0 if not a number.
+ *
* @param i the index of the argument to convert, 1 is the first argument
* @return double value if argument i is number, otherwise 0
- * */
- public double todouble(int i) { return arg(i).todouble(); }
+ */
+ public double todouble(int i) { return arg(i).todouble(); }
- /** Return argument i as a java float value, discarding excess fractional part and truncating,
- * or 0 if not a number.
+ /**
+ * Return argument i as a java float value, discarding excess fractional
+ * part and truncating, or 0 if not a number.
+ *
* @param i the index of the argument to convert, 1 is the first argument
- * @return float value with excess fraction discarded and truncated if necessary if argument i is number, otherwise 0
- * */
- public float tofloat(int i) { return arg(i).tofloat(); }
-
- /** Return argument i as a java int value, discarding any fractional part and truncating,
- * or 0 if not a number.
- * @param i the index of the argument to convert, 1 is the first argument
- * @return int value with fraction discarded and truncated if necessary if argument i is number, otherwise 0
- * */
- public int toint(int i) { return arg(i).toint(); }
+ * @return float value with excess fraction discarded and truncated if
+ * necessary if argument i is number, otherwise 0
+ */
+ public float tofloat(int i) { return arg(i).tofloat(); }
- /** Return argument i as a java long value, discarding any fractional part and truncating,
- * or 0 if not a number.
+ /**
+ * Return argument i as a java int value, discarding any fractional part and
+ * truncating, or 0 if not a number.
+ *
* @param i the index of the argument to convert, 1 is the first argument
- * @return long value with fraction discarded and truncated if necessary if argument i is number, otherwise 0
- * */
- public long tolong(int i) { return arg(i).tolong(); }
+ * @return int value with fraction discarded and truncated if necessary if
+ * argument i is number, otherwise 0
+ */
+ public int toint(int i) { return arg(i).toint(); }
- /** Return argument i as a java String based on the type of the argument.
+ /**
+ * Return argument i as a java long value, discarding any fractional part
+ * and truncating, or 0 if not a number.
+ *
+ * @param i the index of the argument to convert, 1 is the first argument
+ * @return long value with fraction discarded and truncated if necessary if
+ * argument i is number, otherwise 0
+ */
+ public long tolong(int i) { return arg(i).tolong(); }
+
+ /**
+ * Return argument i as a java String based on the type of the argument.
+ *
* @param i the index of the argument to convert, 1 is the first argument
* @return String value representing the type
- * */
- public String tojstring(int i) { return arg(i).tojstring(); }
-
- /** Return argument i as a java short value, discarding any fractional part and truncating,
- * or 0 if not a number.
- * @param i the index of the argument to convert, 1 is the first argument
- * @return short value with fraction discarded and truncated if necessary if argument i is number, otherwise 0
- * */
- public short toshort(int i) { return arg(i).toshort(); }
+ */
+ public String tojstring(int i) { return arg(i).tojstring(); }
- /** Return argument i as a java Object if a userdata, or null.
+ /**
+ * Return argument i as a java short value, discarding any fractional part
+ * and truncating, or 0 if not a number.
+ *
+ * @param i the index of the argument to convert, 1 is the first argument
+ * @return short value with fraction discarded and truncated if necessary if
+ * argument i is number, otherwise 0
+ */
+ public short toshort(int i) { return arg(i).toshort(); }
+
+ /**
+ * Return argument i as a java Object if a userdata, or null.
+ *
* @param i the index of the argument to convert, 1 is the first argument
* @return java Object value if argument i is a userdata, otherwise null
- * */
- public Object touserdata(int i) { return arg(i).touserdata(); }
+ */
+ public Object touserdata(int i) { return arg(i).touserdata(); }
- /** Return argument i as a java Object if it is a userdata whose instance Class c or a subclass, or null.
+ /**
+ * Return argument i as a java Object if it is a userdata whose instance
+ * Class c or a subclass, or null.
+ *
* @param i the index of the argument to convert, 1 is the first argument
* @param c the class to which the userdata instance must be assignable
- * @return java Object value if argument i is a userdata whose instance Class c or a subclass, otherwise null
- * */
- public Object touserdata(int i,Class c) { return arg(i).touserdata(c); }
-
- /** Convert the list of varargs values to a human readable java String.
+ * @return java Object value if argument i is a userdata whose instance
+ * Class c or a subclass, otherwise null
+ */
+ public Object touserdata(int i, Class c) { return arg(i).touserdata(c); }
+
+ /**
+ * Convert the list of varargs values to a human readable java String.
+ *
* @return String value in human readable form such as {1,2}.
*/
public String tojstring() {
Buffer sb = new Buffer();
- sb.append( "(" );
- for ( int i=1,n=narg(); i<=n; i++ ) {
- if (i>1) sb.append( "," );
- sb.append( arg(i).tojstring() );
+ sb.append("(");
+ for (int i = 1, n = narg(); i <= n; i++) {
+ if (i > 1)
+ sb.append(",");
+ sb.append(arg(i).tojstring());
}
- sb.append( ")" );
+ sb.append(")");
return sb.tojstring();
}
-
- /** Convert the value or values to a java String using Varargs.tojstring()
+
+ /**
+ * Convert the value or values to a java String using Varargs.tojstring()
+ *
* @return String value in human readable form.
* @see Varargs#tojstring()
*/
public String toString() { return tojstring(); }
/**
- * Create a {@code Varargs} instance containing arguments starting at index {@code start}
- * @param start the index from which to include arguments, where 1 is the first argument.
- * @return Varargs containing argument { start, start+1, ... , narg-start-1 }
+ * Create a {@code Varargs} instance containing arguments starting at index
+ * {@code start}
+ *
+ * @param start the index from which to include arguments, where 1 is the
+ * first argument.
+ * @return Varargs containing argument { start, start+1, ... , narg-start-1
+ * }
*/
abstract public Varargs subargs(final int start);
/**
* Implementation of Varargs for use in the Varargs.subargs() function.
+ *
* @see Varargs#subargs(int)
*/
static class SubVarargs extends Varargs {
private final Varargs v;
- private final int start;
- private final int end;
+ private final int start;
+ private final int end;
+
public SubVarargs(Varargs varargs, int start, int end) {
this.v = varargs;
this.start = start;
this.end = end;
}
+
public LuaValue arg(int i) {
i += start-1;
- return i>=start && i<=end? v.arg(i): LuaValue.NIL;
+ return i >= start && i <= end? v.arg(i): LuaValue.NIL;
}
+
public LuaValue arg1() {
return v.arg(start);
}
+
public int narg() {
return end+1-start;
}
+
public Varargs subargs(final int start) {
if (start == 1)
return this;
- final int newstart = this.start + start - 1;
+ final int newstart = this.start+start-1;
if (start > 0) {
if (newstart >= this.end)
return LuaValue.NONE;
@@ -544,20 +736,23 @@ public abstract class Varargs {
}
}
- /** Varargs implemenation backed by two values.
+ /**
+ * Varargs implemenation backed by two values.
*
- * This is an internal class not intended to be used directly.
- * Instead use the corresponding static method on LuaValue.
+ * This is an internal class not intended to be used directly. Instead use
+ * the corresponding static method on LuaValue.
*
* @see LuaValue#varargsOf(LuaValue, Varargs)
*/
static final class PairVarargs extends Varargs {
private final LuaValue v1;
- private final Varargs v2;
- /** Construct a Varargs from an two LuaValue.
+ private final Varargs v2;
+
+ /**
+ * Construct a Varargs from an two LuaValue.
*
- * This is an internal class not intended to be used directly.
- * Instead use the corresponding static method on LuaValue.
+ * This is an internal class not intended to be used directly. Instead
+ * use the corresponding static method on LuaValue.
*
* @see LuaValue#varargsOf(LuaValue, Varargs)
*/
@@ -565,89 +760,104 @@ public abstract class Varargs {
this.v1 = v1;
this.v2 = v2;
}
+
public LuaValue arg(int i) {
- return i==1? v1: v2.arg(i-1);
+ return i == 1? v1: v2.arg(i-1);
}
+
public int narg() {
return 1+v2.narg();
}
+
public LuaValue arg1() {
return v1;
}
+
public Varargs subargs(final int start) {
if (start == 1)
return this;
if (start == 2)
return v2;
if (start > 2)
- return v2.subargs(start - 1);
+ return v2.subargs(start-1);
return LuaValue.argerror(1, "start must be > 0");
}
}
- /** Varargs implemenation backed by an array of LuaValues
+ /**
+ * Varargs implemenation backed by an array of LuaValues
*
- * This is an internal class not intended to be used directly.
- * Instead use the corresponding static methods on LuaValue.
+ * This is an internal class not intended to be used directly. Instead use
+ * the corresponding static methods on LuaValue.
*
* @see LuaValue#varargsOf(LuaValue[])
* @see LuaValue#varargsOf(LuaValue[], Varargs)
*/
static final class ArrayVarargs extends Varargs {
private final LuaValue[] v;
- private final Varargs r;
- /** Construct a Varargs from an array of LuaValue.
+ private final Varargs r;
+
+ /**
+ * Construct a Varargs from an array of LuaValue.
*
- * This is an internal class not intended to be used directly.
- * Instead use the corresponding static methods on LuaValue.
+ * This is an internal class not intended to be used directly. Instead
+ * use the corresponding static methods on LuaValue.
*
* @see LuaValue#varargsOf(LuaValue[])
* @see LuaValue#varargsOf(LuaValue[], Varargs)
*/
ArrayVarargs(LuaValue[] v, Varargs r) {
this.v = v;
- this.r = r ;
+ this.r = r;
}
+
public LuaValue arg(int i) {
- return i < 1 ? LuaValue.NIL: i <= v.length? v[i - 1]: r.arg(i-v.length);
+ return i < 1? LuaValue.NIL: i <= v.length? v[i-1]: r.arg(i-v.length);
}
+
public int narg() {
return v.length+r.narg();
}
- public LuaValue arg1() { return v.length>0? v[0]: r.arg1(); }
+
+ public LuaValue arg1() { return v.length > 0? v[0]: r.arg1(); }
+
public Varargs subargs(int start) {
if (start <= 0)
LuaValue.argerror(1, "start must be > 0");
if (start == 1)
return this;
if (start > v.length)
- return r.subargs(start - v.length);
- return LuaValue.varargsOf(v, start - 1, v.length - (start - 1), r);
+ return r.subargs(start-v.length);
+ return LuaValue.varargsOf(v, start-1, v.length-(start-1), r);
}
+
void copyto(LuaValue[] dest, int offset, int length) {
int n = Math.min(v.length, length);
System.arraycopy(v, 0, dest, offset, n);
- r.copyto(dest, offset + n, length - n);
+ r.copyto(dest, offset+n, length-n);
}
}
- /** Varargs implemenation backed by an array of LuaValues
+ /**
+ * Varargs implemenation backed by an array of LuaValues
*
- * This is an internal class not intended to be used directly.
- * Instead use the corresponding static methods on LuaValue.
+ * This is an internal class not intended to be used directly. Instead use
+ * the corresponding static methods on LuaValue.
*
* @see LuaValue#varargsOf(LuaValue[], int, int)
* @see LuaValue#varargsOf(LuaValue[], int, int, Varargs)
*/
static final class ArrayPartVarargs extends Varargs {
- private final int offset;
+ private final int offset;
private final LuaValue[] v;
- private final int length;
- private final Varargs more;
- /** Construct a Varargs from an array of LuaValue.
+ private final int length;
+ private final Varargs more;
+
+ /**
+ * Construct a Varargs from an array of LuaValue.
*
- * This is an internal class not intended to be used directly.
- * Instead use the corresponding static methods on LuaValue.
+ * This is an internal class not intended to be used directly. Instead
+ * use the corresponding static methods on LuaValue.
*
* @see LuaValue#varargsOf(LuaValue[], int, int)
*/
@@ -657,10 +867,13 @@ public abstract class Varargs {
this.length = length;
this.more = LuaValue.NONE;
}
- /** Construct a Varargs from an array of LuaValue and additional arguments.
+
+ /**
+ * Construct a Varargs from an array of LuaValue and additional
+ * arguments.
*
- * This is an internal class not intended to be used directly.
- * Instead use the corresponding static method on LuaValue.
+ * This is an internal class not intended to be used directly. Instead
+ * use the corresponding static method on LuaValue.
*
* @see LuaValue#varargsOf(LuaValue[], int, int, Varargs)
*/
@@ -670,52 +883,66 @@ public abstract class Varargs {
this.length = length;
this.more = more;
}
+
public LuaValue arg(final int i) {
return i < 1? LuaValue.NIL: i <= length? v[offset+i-1]: more.arg(i-length);
}
+
public int narg() {
- return length + more.narg();
+ return length+more.narg();
}
+
public LuaValue arg1() {
- return length>0? v[offset]: more.arg1();
+ return length > 0? v[offset]: more.arg1();
}
+
public Varargs subargs(int start) {
if (start <= 0)
LuaValue.argerror(1, "start must be > 0");
if (start == 1)
return this;
if (start > length)
- return more.subargs(start - length);
- return LuaValue.varargsOf(v, offset + start - 1, length - (start - 1), more);
+ return more.subargs(start-length);
+ return LuaValue.varargsOf(v, offset+start-1, length-(start-1), more);
}
+
void copyto(LuaValue[] dest, int offset, int length) {
int n = Math.min(this.length, length);
System.arraycopy(this.v, this.offset, dest, offset, n);
- more.copyto(dest, offset + n, length - n);
+ more.copyto(dest, offset+n, length-n);
}
}
- /** Copy values in a varargs into a destination array.
- * Internal utility method not intended to be called directly from user code.
+ /**
+ * Copy values in a varargs into a destination array. Internal utility
+ * method not intended to be called directly from user code.
+ *
* @return Varargs containing same values, but flattened.
*/
void copyto(LuaValue[] dest, int offset, int length) {
- for (int i=0; i
- * However, calling the constructors directly when weak tables are required from
- * Java will reduce overhead.
+ * Normally these are not created directly, but indirectly when changing the
+ * mode of a {@link LuaTable} as lua script executes.
+ *
+ * However, calling the constructors directly when weak tables are required from
+ * Java will reduce overhead.
*/
public class WeakTable implements Metatable {
- private boolean weakkeys, weakvalues;
+ private boolean weakkeys, weakvalues;
private LuaValue backing;
public static LuaTable make(boolean weakkeys, boolean weakvalues) {
LuaString mode;
- if ( weakkeys && weakvalues ) {
+ if (weakkeys && weakvalues) {
mode = LuaString.valueOf("kv");
- } else if ( weakkeys ) {
+ } else if (weakkeys) {
mode = LuaString.valueOf("k");
- } else if ( weakvalues ) {
+ } else if (weakvalues) {
mode = LuaString.valueOf("v");
} else {
return LuaTable.tableOf();
@@ -59,7 +59,8 @@ public class WeakTable implements Metatable {
/**
* Construct a table with weak keys, weak values, or both
- * @param weakkeys true to let the table have weak keys
+ *
+ * @param weakkeys true to let the table have weak keys
* @param weakvalues true to let the table have weak values
*/
public WeakTable(boolean weakkeys, boolean weakvalues, LuaValue backing) {
@@ -82,26 +83,26 @@ public class WeakTable implements Metatable {
public Slot entry(LuaValue key, LuaValue value) {
value = value.strongvalue();
- if ( value == null )
+ if (value == null)
return null;
- if ( weakkeys && !( key.isnumber() || key.isstring() || key.isboolean() )) {
- if ( weakvalues && !( value.isnumber() || value.isstring() || value.isboolean() )) {
- return new WeakKeyAndValueSlot( key, value, null );
+ if (weakkeys && !(key.isnumber() || key.isstring() || key.isboolean())) {
+ if (weakvalues && !(value.isnumber() || value.isstring() || value.isboolean())) {
+ return new WeakKeyAndValueSlot(key, value, null);
} else {
- return new WeakKeySlot( key, value, null );
+ return new WeakKeySlot(key, value, null);
}
}
- if ( weakvalues && ! (value.isnumber() || value.isstring() || value.isboolean() )) {
- return new WeakValueSlot( key, value, null );
+ if (weakvalues && !(value.isnumber() || value.isstring() || value.isboolean())) {
+ return new WeakValueSlot(key, value, null);
}
- return LuaTable.defaultEntry( key, value );
+ return LuaTable.defaultEntry(key, value);
}
public static abstract class WeakSlot implements Slot {
protected Object key;
protected Object value;
- protected Slot next;
+ protected Slot next;
protected WeakSlot(Object key, Object value, Slot next) {
this.key = key;
@@ -109,14 +110,14 @@ public class WeakTable implements Metatable {
this.next = next;
}
- public abstract int keyindex( int hashMask );
+ public abstract int keyindex(int hashMask);
public abstract Slot set(LuaValue value);
public StrongSlot first() {
LuaValue key = strongkey();
LuaValue value = strongvalue();
- if ( key != null && value != null ) {
+ if (key != null && value != null) {
return new LuaTable.NormalEntry(key, value);
} else {
this.key = null;
@@ -127,12 +128,12 @@ public class WeakTable implements Metatable {
public StrongSlot find(LuaValue key) {
StrongSlot first = first();
- return ( first != null ) ? first.find( key ) : null;
+ return (first != null)? first.find(key): null;
}
public boolean keyeq(LuaValue key) {
StrongSlot first = first();
- return ( first != null ) && first.keyeq( key );
+ return (first != null) && first.keyeq(key);
}
public Slot rest() {
@@ -146,46 +147,46 @@ public class WeakTable implements Metatable {
public Slot set(StrongSlot target, LuaValue value) {
LuaValue key = strongkey();
- if ( key != null && target.find( key ) != null ) {
- return set( value );
- } else if ( key != null ) {
+ if (key != null && target.find(key) != null) {
+ return set(value);
+ } else if (key != null) {
// Our key is still good.
- next = next.set( target, value );
+ next = next.set(target, value);
return this;
} else {
// our key was dropped, remove ourselves from the chain.
- return next.set( target, value );
+ return next.set(target, value);
}
}
- public Slot add( Slot entry ) {
- next = ( next != null ) ? next.add( entry ) : entry;
- if ( strongkey() != null && strongvalue() != null ) {
+ public Slot add(Slot entry) {
+ next = (next != null)? next.add(entry): entry;
+ if (strongkey() != null && strongvalue() != null) {
return this;
} else {
return next;
}
}
- public Slot remove( StrongSlot target ) {
+ public Slot remove(StrongSlot target) {
LuaValue key = strongkey();
- if ( key == null ) {
- return next.remove( target );
- } else if ( target.keyeq( key ) ) {
+ if (key == null) {
+ return next.remove(target);
+ } else if (target.keyeq(key)) {
this.value = null;
return this;
} else {
- next = next.remove( target );
+ next = next.remove(target);
return this;
}
}
- public Slot relink( Slot rest ) {
- if ( strongkey() != null && strongvalue() != null ) {
- if ( rest == null && this.next == null ) {
+ public Slot relink(Slot rest) {
+ if (strongkey() != null && strongvalue() != null) {
+ if (rest == null && this.next == null) {
return this;
} else {
- return copy( rest );
+ return copy(rest);
}
} else {
return rest;
@@ -200,25 +201,25 @@ public class WeakTable implements Metatable {
return (LuaValue) value;
}
- protected abstract WeakSlot copy( Slot next );
+ protected abstract WeakSlot copy(Slot next);
}
static class WeakKeySlot extends WeakSlot {
private final int keyhash;
- protected WeakKeySlot( LuaValue key, LuaValue value, Slot next ) {
+ protected WeakKeySlot(LuaValue key, LuaValue value, Slot next) {
super(weaken(key), value, next);
keyhash = key.hashCode();
}
- protected WeakKeySlot( WeakKeySlot copyFrom, Slot next ) {
- super( copyFrom.key, copyFrom.value, next );
+ protected WeakKeySlot(WeakKeySlot copyFrom, Slot next) {
+ super(copyFrom.key, copyFrom.value, next);
this.keyhash = copyFrom.keyhash;
}
- public int keyindex( int mask ) {
- return LuaTable.hashmod( keyhash, mask );
+ public int keyindex(int mask) {
+ return LuaTable.hashmod(keyhash, mask);
}
public Slot set(LuaValue value) {
@@ -227,26 +228,26 @@ public class WeakTable implements Metatable {
}
public LuaValue strongkey() {
- return strengthen( key );
+ return strengthen(key);
}
- protected WeakSlot copy( Slot rest ) {
- return new WeakKeySlot( this, rest );
+ protected WeakSlot copy(Slot rest) {
+ return new WeakKeySlot(this, rest);
}
}
static class WeakValueSlot extends WeakSlot {
- protected WeakValueSlot( LuaValue key, LuaValue value, Slot next ) {
- super( key, weaken(value), next);
+ protected WeakValueSlot(LuaValue key, LuaValue value, Slot next) {
+ super(key, weaken(value), next);
}
- protected WeakValueSlot( WeakValueSlot copyFrom, Slot next ) {
- super( copyFrom.key, copyFrom.value, next );
+ protected WeakValueSlot(WeakValueSlot copyFrom, Slot next) {
+ super(copyFrom.key, copyFrom.value, next);
}
- public int keyindex( int mask ) {
- return LuaTable.hashSlot( strongkey(), mask );
+ public int keyindex(int mask) {
+ return LuaTable.hashSlot(strongkey(), mask);
}
public Slot set(LuaValue value) {
@@ -255,11 +256,11 @@ public class WeakTable implements Metatable {
}
public LuaValue strongvalue() {
- return strengthen( value );
+ return strengthen(value);
}
protected WeakSlot copy(Slot next) {
- return new WeakValueSlot( this, next );
+ return new WeakValueSlot(this, next);
}
}
@@ -267,18 +268,18 @@ public class WeakTable implements Metatable {
private final int keyhash;
- protected WeakKeyAndValueSlot( LuaValue key, LuaValue value, Slot next ) {
- super( weaken(key), weaken(value), next );
+ protected WeakKeyAndValueSlot(LuaValue key, LuaValue value, Slot next) {
+ super(weaken(key), weaken(value), next);
keyhash = key.hashCode();
}
protected WeakKeyAndValueSlot(WeakKeyAndValueSlot copyFrom, Slot next) {
- super( copyFrom.key, copyFrom.value, next );
+ super(copyFrom.key, copyFrom.value, next);
keyhash = copyFrom.keyhash;
}
- public int keyindex( int hashMask ) {
- return LuaTable.hashmod( keyhash, hashMask );
+ public int keyindex(int hashMask) {
+ return LuaTable.hashmod(keyhash, hashMask);
}
public Slot set(LuaValue value) {
@@ -287,53 +288,58 @@ public class WeakTable implements Metatable {
}
public LuaValue strongkey() {
- return strengthen( key );
+ return strengthen(key);
}
public LuaValue strongvalue() {
- return strengthen( value );
+ return strengthen(value);
}
- protected WeakSlot copy( Slot next ) {
- return new WeakKeyAndValueSlot( this, next );
+ protected WeakSlot copy(Slot next) {
+ return new WeakKeyAndValueSlot(this, next);
}
}
/**
* Self-sent message to convert a value to its weak counterpart
+ *
* @param value value to convert
- * @return {@link LuaValue} that is a strong or weak reference, depending on type of {@code value}
+ * @return {@link LuaValue} that is a strong or weak reference, depending on
+ * type of {@code value}
*/
- protected static LuaValue weaken( LuaValue value ) {
- switch ( value.type() ) {
- case LuaValue.TFUNCTION:
- case LuaValue.TTHREAD:
- case LuaValue.TTABLE:
- return new WeakValue(value);
- case LuaValue.TUSERDATA:
- return new WeakUserdata(value);
- default:
- return value;
+ protected static LuaValue weaken(LuaValue value) {
+ switch (value.type()) {
+ case LuaValue.TFUNCTION:
+ case LuaValue.TTHREAD:
+ case LuaValue.TTABLE:
+ return new WeakValue(value);
+ case LuaValue.TUSERDATA:
+ return new WeakUserdata(value);
+ default:
+ return value;
}
}
/**
* Unwrap a LuaValue from a WeakReference and/or WeakUserdata.
+ *
* @param ref reference to convert
* @return LuaValue or null
* @see #weaken(LuaValue)
*/
protected static LuaValue strengthen(Object ref) {
- if ( ref instanceof WeakReference ) {
+ if (ref instanceof WeakReference) {
ref = ((WeakReference) ref).get();
}
- if ( ref instanceof WeakValue ) {
+ if (ref instanceof WeakValue) {
return ((WeakValue) ref).strongvalue();
}
return (LuaValue) ref;
}
- /** Internal class to implement weak values.
+ /**
+ * Internal class to implement weak values.
+ *
* @see WeakTable
*/
static class WeakValue extends LuaValue {
@@ -344,36 +350,38 @@ public class WeakTable implements Metatable {
}
public int type() {
- illegal("type","weak value");
+ illegal("type", "weak value");
return 0;
}
public String typename() {
- illegal("typename","weak value");
+ illegal("typename", "weak value");
return null;
}
public String toString() {
- return "weak<"+ref.get()+">";
+ return "weak<" + ref.get() + ">";
}
public LuaValue strongvalue() {
Object o = ref.get();
- return (LuaValue)o;
+ return (LuaValue) o;
}
public boolean raweq(LuaValue rhs) {
Object o = ref.get();
- return o!=null && rhs.raweq((LuaValue)o);
+ return o != null && rhs.raweq((LuaValue) o);
}
}
- /** Internal class to implement weak userdata values.
+ /**
+ * Internal class to implement weak userdata values.
+ *
* @see WeakTable
*/
static final class WeakUserdata extends WeakValue {
private final WeakReference ob;
- private final LuaValue mt;
+ private final LuaValue mt;
private WeakUserdata(LuaValue value) {
super(value);
@@ -383,11 +391,11 @@ public class WeakTable implements Metatable {
public LuaValue strongvalue() {
Object u = ref.get();
- if ( u != null )
+ if (u != null)
return (LuaValue) u;
Object o = ob.get();
- if ( o != null ) {
- LuaValue ud = LuaValue.userdataOf(o,mt);
+ if (o != null) {
+ LuaValue ud = LuaValue.userdataOf(o, mt);
ref = new WeakReference(ud);
return ud;
} else {
@@ -397,7 +405,7 @@ public class WeakTable implements Metatable {
}
public LuaValue wrap(LuaValue value) {
- return weakvalues ? weaken( value ) : value;
+ return weakvalues? weaken(value): value;
}
public LuaValue arrayget(LuaValue[] array, int index) {
diff --git a/luaj-core/src/main/java/org/luaj/vm2/compiler/Constants.java b/luaj-core/src/main/java/org/luaj/vm2/compiler/Constants.java
index fc505b49..60a7fcd6 100644
--- a/luaj-core/src/main/java/org/luaj/vm2/compiler/Constants.java
+++ b/luaj-core/src/main/java/org/luaj/vm2/compiler/Constants.java
@@ -36,153 +36,141 @@ import org.luaj.vm2.Upvaldesc;
* @see FuncState
*/
public class Constants extends Lua {
-
+
/** Maximum stack size of a luaj vm interpreter instance. */
public static final int MAXSTACK = 250;
static final int LUAI_MAXUPVAL = 0xff;
- static final int LUAI_MAXVARS = 200;
- static final int NO_REG = MAXARG_A;
-
+ static final int LUAI_MAXVARS = 200;
+ static final int NO_REG = MAXARG_A;
/* OpMode - basic instruction format */
- static final int
- iABC = 0,
- iABx = 1,
- iAsBx = 2;
+ static final int iABC = 0, iABx = 1, iAsBx = 2;
/* OpArgMask */
- static final int
- OpArgN = 0, /* argument is not used */
- OpArgU = 1, /* argument is used */
- OpArgR = 2, /* argument is a register or a jump offset */
- OpArgK = 3; /* argument is a constant or register/constant */
-
+ static final int OpArgN = 0, /* argument is not used */
+ OpArgU = 1, /* argument is used */
+ OpArgR = 2, /* argument is a register or a jump offset */
+ OpArgK = 3; /* argument is a constant or register/constant */
protected static void _assert(boolean b) {
if (!b)
throw new LuaError("compiler assert failed");
}
- static void SET_OPCODE(InstructionPtr i,int o) {
- i.set( ( i.get() & (MASK_NOT_OP)) | ((o << POS_OP) & MASK_OP) );
+ static void SET_OPCODE(InstructionPtr i, int o) {
+ i.set((i.get() & (MASK_NOT_OP)) | ((o<
* A lua binary file is created via {@link DumpState#dump}:
- *
- * Compiles lua source files into lua bytecode within a {@link Prototype},
- * loads lua binary files directly into a {@link Prototype},
- * and optionaly instantiates a {@link LuaClosure} around the result
- * using a user-supplied environment.
+ * Compiles lua source files into lua bytecode within a {@link Prototype}, loads
+ * lua binary files directly into a {@link Prototype}, and optionaly
+ * instantiates a {@link LuaClosure} around the result using a user-supplied
+ * environment.
*
*
- * Implements the {@link org.luaj.vm2.Globals.Compiler} interface for loading
- * initialized chunks, which is an interface common to
- * lua bytecode compiling and java bytecode compiling.
- *
- *
- * The {@link LuaC} compiler is installed by default by both the
- * {@link org.luaj.vm2.lib.jse.JsePlatform} and {@link org.luaj.vm2.lib.jme.JmePlatform} classes,
- * so in the following example, the default {@link LuaC} compiler
- * will be used:
- *
+ * The {@link LuaC} compiler is installed by default by both the
+ * {@link org.luaj.vm2.lib.jse.JsePlatform} and
+ * {@link org.luaj.vm2.lib.jme.JmePlatform} classes, so in the following
+ * example, the default {@link LuaC} compiler will be used:
+ *
+ *
- * This contains all library functions listed as "basic functions" in the lua documentation for JME.
- * The functions dofile and loadfile use the
- * {@link Globals#finder} instance to find resource files.
- * Since JME has no file system by default, {@link BaseLib} implements
- * {@link ResourceFinder} using {@link Class#getResource(String)},
- * which is the closest equivalent on JME.
+ * This contains all library functions listed as "basic functions" in the lua
+ * documentation for JME. The functions dofile and loadfile use the
+ * {@link Globals#finder} instance to find resource files. Since JME has no file
+ * system by default, {@link BaseLib} implements {@link ResourceFinder} using
+ * {@link Class#getResource(String)}, which is the closest equivalent on JME.
* The default loader chain in {@link PackageLib} will use these as well.
*
* To use basic library functions that include a {@link ResourceFinder} based on
@@ -50,47 +50,60 @@ import org.luaj.vm2.Varargs;
* Typically, this library is included as part of a call to either
* {@link org.luaj.vm2.lib.jse.JsePlatform#standardGlobals()} or
* {@link org.luaj.vm2.lib.jme.JmePlatform#standardGlobals()}
- *
- * For special cases where the smallest possible footprint is desired,
- * a minimal set of libraries could be loaded
- * directly via {@link Globals#load(LuaValue)} using code such as:
- *
* This is a direct port of the corresponding library in C.
+ *
* @see org.luaj.vm2.lib.jse.JseBaseLib
* @see ResourceFinder
* @see Globals#finder
* @see LibFunction
* @see org.luaj.vm2.lib.jse.JsePlatform
* @see org.luaj.vm2.lib.jme.JmePlatform
- * @see Lua 5.2 Base Lib Reference
+ * @see Lua 5.2 Base Lib
+ * Reference
*/
public class BaseLib extends TwoArgFunction implements ResourceFinder {
-
- Globals globals;
-
- /** Perform one-time initialization on the library by adding base functions
+ Globals globals;
+
+ /**
+ * Perform one-time initialization on the library by adding base functions
* to the supplied environment, and returning it as the return value.
+ *
* @param modname the module name supplied if this is loaded via 'require'.
- * @param env the environment to load into, which must be a Globals instance.
+ * @param env the environment to load into, which must be a Globals
+ * instance.
*/
public LuaValue call(LuaValue modname, LuaValue env) {
globals = env.checkglobals();
globals.finder = this;
globals.baselib = this;
- env.set( "_G", env );
- env.set( "_VERSION", Lua._VERSION );
+ env.set("_G", env);
+ env.set("_VERSION", Lua._VERSION);
env.set("assert", new _assert());
env.set("collectgarbage", new collectgarbage());
env.set("dofile", new dofile());
@@ -115,24 +128,24 @@ public class BaseLib extends TwoArgFunction implements ResourceFinder {
env.set("next", next = new next());
env.set("pairs", new pairs(next));
env.set("ipairs", new ipairs());
-
+
return env;
}
- /** ResourceFinder implementation
+ /**
+ * ResourceFinder implementation
*
* Tries to open the file as a resource, which can work for JSE and JME.
*/
public InputStream findResource(String filename) {
- return getClass().getResourceAsStream(filename.startsWith("/")? filename: "/"+filename);
+ return getClass().getResourceAsStream(filename.startsWith("/")? filename: "/" + filename);
}
-
// "assert", // ( v [,message] ) -> v, message | ERR
static final class _assert extends VarArgFunction {
public Varargs invoke(Varargs args) {
- if ( !args.arg1().toboolean() )
- error( args.narg()>1? args.optjstring(2,"assertion failed!"): "assertion failed!" );
+ if (!args.arg1().toboolean())
+ error(args.narg() > 1? args.optjstring(2, "assertion failed!"): "assertion failed!");
return args;
}
}
@@ -141,14 +154,14 @@ public class BaseLib extends TwoArgFunction implements ResourceFinder {
static final class collectgarbage extends VarArgFunction {
public Varargs invoke(Varargs args) {
String s = args.optjstring(1, "collect");
- if ( "collect".equals(s) ) {
+ if ("collect".equals(s)) {
System.gc();
return ZERO;
- } else if ( "count".equals(s) ) {
+ } else if ("count".equals(s)) {
Runtime rt = Runtime.getRuntime();
- long used = rt.totalMemory() - rt.freeMemory();
+ long used = rt.totalMemory()-rt.freeMemory();
return varargsOf(valueOf(used/1024.), valueOf(used%1024));
- } else if ( "step".equals(s) ) {
+ } else if ("step".equals(s)) {
System.gc();
return LuaValue.TRUE;
} else {
@@ -163,9 +176,8 @@ public class BaseLib extends TwoArgFunction implements ResourceFinder {
public Varargs invoke(Varargs args) {
args.argcheck(args.isstring(1) || args.isnil(1), 1, "filename must be string or nil");
String filename = args.isstring(1)? args.tojstring(1): null;
- Varargs v = filename == null?
- loadStream( globals.STDIN, "=stdin", "bt", globals ):
- loadFile( args.checkjstring(1), "bt", globals );
+ Varargs v = filename == null? loadStream(globals.STDIN, "=stdin", "bt", globals)
+ : loadFile(args.checkjstring(1), "bt", globals);
return v.isnil(1)? error(v.tojstring(2)): v.arg1().invoke();
}
}
@@ -173,8 +185,10 @@ public class BaseLib extends TwoArgFunction implements ResourceFinder {
// "error", // ( message [,level] ) -> ERR
static final class error extends TwoArgFunction {
public LuaValue call(LuaValue arg1, LuaValue arg2) {
- if (arg1.isnil()) throw new LuaError(NIL);
- if (!arg1.isstring() || arg2.optint(1) == 0) throw new LuaError(arg1);
+ if (arg1.isnil())
+ throw new LuaError(NIL);
+ if (!arg1.isstring() || arg2.optint(1) == 0)
+ throw new LuaError(arg1);
throw new LuaError(arg1.tojstring(), arg2.optint(1));
}
}
@@ -184,23 +198,26 @@ public class BaseLib extends TwoArgFunction implements ResourceFinder {
public LuaValue call() {
return argerror(1, "value expected");
}
+
public LuaValue call(LuaValue arg) {
LuaValue mt = arg.getmetatable();
- return mt!=null? mt.rawget(METATABLE).optvalue(mt): NIL;
+ return mt != null? mt.rawget(METATABLE).optvalue(mt): NIL;
}
}
+
// "load", // ( ld [, source [, mode [, env]]] ) -> chunk | nil, msg
final class load extends VarArgFunction {
public Varargs invoke(Varargs args) {
LuaValue ld = args.arg1();
if (!ld.isstring() && !ld.isfunction()) {
- throw new LuaError("bad argument #1 to 'load' (string or function expected, got " + ld.typename() + ")");
+ throw new LuaError(
+ "bad argument #1 to 'load' (string or function expected, got " + ld.typename() + ")");
}
String source = args.optjstring(2, ld.isstring()? ld.tojstring(): "=(load)");
String mode = args.optjstring(3, "bt");
LuaValue env = args.optvalue(4, globals);
- return loadStream(ld.isstring()? ld.strvalue().toInputStream():
- new StringInputStream(ld.checkfunction()), source, mode, env);
+ return loadStream(ld.isstring()? ld.strvalue().toInputStream(): new StringInputStream(ld.checkfunction()),
+ source, mode, env);
}
}
@@ -211,12 +228,10 @@ public class BaseLib extends TwoArgFunction implements ResourceFinder {
String filename = args.isstring(1)? args.tojstring(1): null;
String mode = args.optjstring(2, "bt");
LuaValue env = args.optvalue(3, globals);
- return filename == null?
- loadStream( globals.STDIN, "=stdin", mode, env ):
- loadFile( filename, mode, env );
+ return filename == null? loadStream(globals.STDIN, "=stdin", mode, env): loadFile(filename, mode, env);
}
}
-
+
// "pcall", // (f, arg1, ...) -> status, result1, ...
final class pcall extends VarArgFunction {
public Varargs invoke(Varargs args) {
@@ -225,12 +240,12 @@ public class BaseLib extends TwoArgFunction implements ResourceFinder {
globals.debuglib.onCall(this);
try {
return varargsOf(TRUE, func.invoke(args.subargs(2)));
- } catch ( LuaError le ) {
+ } catch (LuaError le) {
final LuaValue m = le.getMessageObject();
- return varargsOf(FALSE, m!=null? m: NIL);
- } catch ( Exception e ) {
+ return varargsOf(FALSE, m != null? m: NIL);
+ } catch (Exception e) {
final String m = e.getMessage();
- return varargsOf(FALSE, valueOf(m!=null? m: e.toString()));
+ return varargsOf(FALSE, valueOf(m != null? m: e.toString()));
} finally {
if (globals != null && globals.debuglib != null)
globals.debuglib.onReturn();
@@ -241,30 +256,34 @@ public class BaseLib extends TwoArgFunction implements ResourceFinder {
// "print", // (...) -> void
final class print extends VarArgFunction {
final BaseLib baselib;
+
print(BaseLib baselib) {
this.baselib = baselib;
}
+
public Varargs invoke(Varargs args) {
LuaValue tostring = globals.get("tostring");
- for ( int i=1, n=args.narg(); i<=n; i++ ) {
- if ( i>1 ) globals.STDOUT.print( '\t' );
- LuaString s = tostring.call( args.arg(i) ).strvalue();
+ for (int i = 1, n = args.narg(); i <= n; i++) {
+ if (i > 1)
+ globals.STDOUT.print('\t');
+ LuaString s = tostring.call(args.arg(i)).strvalue();
globals.STDOUT.print(s.tojstring());
}
globals.STDOUT.print('\n');
return NONE;
}
}
-
// "rawequal", // (v1, v2) -> boolean
static final class rawequal extends LibFunction {
public LuaValue call() {
return argerror(1, "value expected");
}
+
public LuaValue call(LuaValue arg) {
return argerror(2, "value expected");
}
+
public LuaValue call(LuaValue arg1, LuaValue arg2) {
return valueOf(arg1.raweq(arg2));
}
@@ -275,12 +294,12 @@ public class BaseLib extends TwoArgFunction implements ResourceFinder {
public LuaValue call(LuaValue arg) {
return argerror(2, "value expected");
}
+
public LuaValue call(LuaValue arg1, LuaValue arg2) {
return arg1.checktable().rawget(arg2);
}
}
-
// "rawlen", // (v) -> value
static final class rawlen extends LibFunction {
public LuaValue call(LuaValue arg) {
@@ -291,68 +310,73 @@ public class BaseLib extends TwoArgFunction implements ResourceFinder {
// "rawset", // (table, index, value) -> table
static final class rawset extends TableLibFunction {
public LuaValue call(LuaValue table) {
- return argerror(2,"value expected");
+ return argerror(2, "value expected");
}
+
public LuaValue call(LuaValue table, LuaValue index) {
- return argerror(3,"value expected");
+ return argerror(3, "value expected");
}
+
public LuaValue call(LuaValue table, LuaValue index, LuaValue value) {
LuaTable t = table.checktable();
- if (!index.isvalidkey()) argerror(2, "table index is nil");
+ if (!index.isvalidkey())
+ argerror(2, "table index is nil");
t.rawset(index, value);
return t;
}
}
-
+
// "select", // (f, ...) -> value1, ...
static final class select extends VarArgFunction {
public Varargs invoke(Varargs args) {
int n = args.narg()-1;
- if ( args.arg1().equals(valueOf("#")) )
+ if (args.arg1().equals(valueOf("#")))
return valueOf(n);
int i = args.checkint(1);
- if ( i == 0 || i < -n )
- argerror(1,"index out of range");
- return args.subargs(i<0? n+i+2: i+1);
+ if (i == 0 || i < -n)
+ argerror(1, "index out of range");
+ return args.subargs(i < 0? n+i+2: i+1);
}
}
-
+
// "setmetatable", // (table, metatable) -> table
static final class setmetatable extends TableLibFunction {
public LuaValue call(LuaValue table) {
- return argerror(2,"nil or table expected");
+ return argerror(2, "nil or table expected");
}
+
public LuaValue call(LuaValue table, LuaValue metatable) {
final LuaValue mt0 = table.checktable().getmetatable();
- if ( mt0!=null && !mt0.rawget(METATABLE).isnil() )
+ if (mt0 != null && !mt0.rawget(METATABLE).isnil())
error("cannot change a protected metatable");
return table.setmetatable(metatable.isnil()? null: metatable.checktable());
}
}
-
+
// "tonumber", // (e [,base]) -> value
static final class tonumber extends LibFunction {
public LuaValue call(LuaValue e) {
return e.tonumber();
}
+
public LuaValue call(LuaValue e, LuaValue base) {
if (base.isnil())
return e.tonumber();
final int b = base.checkint();
- if ( b < 2 || b > 36 )
+ if (b < 2 || b > 36)
argerror(2, "base out of range");
return e.checkstring().tonumber(b);
}
}
-
+
// "tostring", // (e) -> value
static final class tostring extends LibFunction {
public LuaValue call(LuaValue arg) {
LuaValue h = arg.metatag(TOSTRING);
- if ( ! h.isnil() )
+ if (!h.isnil())
return h.call(arg);
LuaValue v = arg.tostring();
- if ( ! v.isnil() )
+ if (!v.isnil())
return v;
return valueOf(arg.tojstring());
}
@@ -376,12 +400,12 @@ public class BaseLib extends TwoArgFunction implements ResourceFinder {
globals.debuglib.onCall(this);
try {
return varargsOf(TRUE, args.arg1().invoke(args.subargs(3)));
- } catch ( LuaError le ) {
+ } catch (LuaError le) {
final LuaValue m = le.getMessageObject();
- return varargsOf(FALSE, m!=null? m: NIL);
- } catch ( Exception e ) {
+ return varargsOf(FALSE, m != null? m: NIL);
+ } catch (Exception e) {
final String m = e.getMessage();
- return varargsOf(FALSE, valueOf(m!=null? m: e.toString()));
+ return varargsOf(FALSE, valueOf(m != null? m: e.toString()));
} finally {
if (globals != null && globals.debuglib != null)
globals.debuglib.onReturn();
@@ -391,56 +415,60 @@ public class BaseLib extends TwoArgFunction implements ResourceFinder {
}
}
}
-
+
// "pairs" (t) -> iter-func, t, nil
static final class pairs extends VarArgFunction {
final next next;
+
pairs(next next) {
this.next = next;
}
+
public Varargs invoke(Varargs args) {
- return varargsOf( next, args.checktable(1), NIL );
+ return varargsOf(next, args.checktable(1), NIL);
}
}
-
+
// // "ipairs", // (t) -> iter-func, t, 0
static final class ipairs extends VarArgFunction {
inext inext = new inext();
+
public Varargs invoke(Varargs args) {
- return varargsOf( inext, args.checktable(1), ZERO );
+ return varargsOf(inext, args.checktable(1), ZERO);
}
}
-
+
// "next" ( table, [index] ) -> next-index, next-value
static final class next extends VarArgFunction {
public Varargs invoke(Varargs args) {
return args.checktable(1).next(args.arg(2));
}
}
-
+
// "inext" ( table, [int-index] ) -> next-index, next-value
static final class inext extends VarArgFunction {
public Varargs invoke(Varargs args) {
return args.checktable(1).inext(args.arg(2));
}
}
-
+
/**
* Load from a named file, returning the chunk or nil,error of can't load
+ *
* @param env
* @param mode
* @return Varargs containing chunk, or NIL,error-text on error
*/
public Varargs loadFile(String filename, String mode, LuaValue env) {
InputStream is = globals.finder.findResource(filename);
- if ( is == null )
- return varargsOf(NIL, valueOf("cannot open "+filename+": No such file or directory"));
+ if (is == null)
+ return varargsOf(NIL, valueOf("cannot open " + filename + ": No such file or directory"));
try {
- return loadStream(is, "@"+filename, mode, env);
+ return loadStream(is, "@" + filename, mode, env);
} finally {
try {
is.close();
- } catch ( Exception e ) {
+ } catch (Exception e) {
e.printStackTrace();
}
}
@@ -448,28 +476,29 @@ public class BaseLib extends TwoArgFunction implements ResourceFinder {
public Varargs loadStream(InputStream is, String chunkname, String mode, LuaValue env) {
try {
- if ( is == null )
- return varargsOf(NIL, valueOf("not found: "+chunkname));
+ if (is == null)
+ return varargsOf(NIL, valueOf("not found: " + chunkname));
return globals.load(is, chunkname, mode, env);
} catch (Exception e) {
return varargsOf(NIL, valueOf(e.getMessage()));
}
}
-
-
+
private static class StringInputStream extends InputStream {
final LuaValue func;
- byte[] bytes;
- int offset, remaining = 0;
+ byte[] bytes;
+ int offset, remaining = 0;
+
StringInputStream(LuaValue func) {
this.func = func;
}
+
public int read() throws IOException {
- if ( remaining < 0 )
+ if (remaining < 0)
return -1;
- if ( remaining == 0 ) {
+ if (remaining == 0) {
LuaValue s = func.call();
- if ( s.isnil() )
+ if (s.isnil())
return remaining = -1;
LuaString ls = s.strvalue();
bytes = ls.m_bytes;
@@ -479,7 +508,7 @@ public class BaseLib extends TwoArgFunction implements ResourceFinder {
return -1;
}
--remaining;
- return 0xFF&bytes[offset++];
+ return 0xFF & bytes[offset++];
}
}
}
diff --git a/luaj-core/src/main/java/org/luaj/vm2/lib/Bit32Lib.java b/luaj-core/src/main/java/org/luaj/vm2/lib/Bit32Lib.java
index 699c6945..f15c2efc 100644
--- a/luaj-core/src/main/java/org/luaj/vm2/lib/Bit32Lib.java
+++ b/luaj-core/src/main/java/org/luaj/vm2/lib/Bit32Lib.java
@@ -26,68 +26,86 @@ import org.luaj.vm2.LuaValue;
import org.luaj.vm2.Varargs;
/**
- * Subclass of LibFunction that implements the Lua standard {@code bit32} library.
+ * Subclass of LibFunction that implements the Lua standard {@code bit32}
+ * library.
*
* Typically, this library is included as part of a call to either
- * {@link org.luaj.vm2.lib.jse.JsePlatform#standardGlobals()} or {@link org.luaj.vm2.lib.jme.JmePlatform#standardGlobals()}
- *
- * To instantiate and use it directly,
- * link it into your globals table via {@link LuaValue#load(LuaValue)} using code such as:
- *
- * This has been implemented to match as closely as possible the behavior in the corresponding library in C.
+ * This has been implemented to match as closely as possible the behavior in the
+ * corresponding library in C.
+ *
* @see LibFunction
* @see org.luaj.vm2.lib.jse.JsePlatform
* @see org.luaj.vm2.lib.jme.JmePlatform
- * @see Lua 5.2 Bitwise Operation Lib Reference
+ * @see Lua 5.2 Bitwise
+ * Operation Lib Reference
*/
public class Bit32Lib extends TwoArgFunction {
public Bit32Lib() {
}
- /** Perform one-time initialization on the library by creating a table
- * containing the library functions, adding that table to the supplied environment,
- * adding the table to package.loaded, and returning table as the return value.
+ /**
+ * Perform one-time initialization on the library by creating a table
+ * containing the library functions, adding that table to the supplied
+ * environment, adding the table to package.loaded, and returning table as
+ * the return value.
+ *
* @param modname the module name supplied if this is loaded via 'require'.
- * @param env the environment to load into, which must be a Globals instance.
+ * @param env the environment to load into, which must be a Globals
+ * instance.
*/
public LuaValue call(LuaValue modname, LuaValue env) {
LuaTable t = new LuaTable();
- bind(t, Bit32LibV.class, new String[] {
- "band", "bnot", "bor", "btest", "bxor", "extract", "replace"
- });
- bind(t, Bit32Lib2.class, new String[] {
- "arshift", "lrotate", "lshift", "rrotate", "rshift"
- });
+ bind(t, Bit32LibV.class, new String[] { "band", "bnot", "bor", "btest", "bxor", "extract", "replace" });
+ bind(t, Bit32Lib2.class, new String[] { "arshift", "lrotate", "lshift", "rrotate", "rshift" });
env.set("bit32", t);
- if (!env.get("package").isnil()) env.get("package").get("loaded").set("bit32", t);
+ if (!env.get("package").isnil())
+ env.get("package").get("loaded").set("bit32", t);
return t;
}
static final class Bit32LibV extends VarArgFunction {
public Varargs invoke(Varargs args) {
- switch ( opcode ) {
- case 0: return Bit32Lib.band( args );
- case 1: return Bit32Lib.bnot( args );
- case 2: return Bit32Lib.bor( args );
- case 3: return Bit32Lib.btest( args );
- case 4: return Bit32Lib.bxor( args );
+ switch (opcode) {
+ case 0:
+ return Bit32Lib.band(args);
+ case 1:
+ return Bit32Lib.bnot(args);
+ case 2:
+ return Bit32Lib.bor(args);
+ case 3:
+ return Bit32Lib.btest(args);
+ case 4:
+ return Bit32Lib.bxor(args);
case 5:
- return Bit32Lib.extract( args.checkint(1), args.checkint(2), args.optint(3, 1) );
+ return Bit32Lib.extract(args.checkint(1), args.checkint(2), args.optint(3, 1));
case 6:
- return Bit32Lib.replace( args.checkint(1), args.checkint(2),
- args.checkint(3), args.optint(4, 1) );
+ return Bit32Lib.replace(args.checkint(1), args.checkint(2), args.checkint(3), args.optint(4, 1));
}
return NIL;
}
@@ -96,23 +114,28 @@ public class Bit32Lib extends TwoArgFunction {
static final class Bit32Lib2 extends TwoArgFunction {
public LuaValue call(LuaValue arg1, LuaValue arg2) {
- switch ( opcode ) {
- case 0: return Bit32Lib.arshift(arg1.checkint(), arg2.checkint());
- case 1: return Bit32Lib.lrotate(arg1.checkint(), arg2.checkint());
- case 2: return Bit32Lib.lshift(arg1.checkint(), arg2.checkint());
- case 3: return Bit32Lib.rrotate(arg1.checkint(), arg2.checkint());
- case 4: return Bit32Lib.rshift(arg1.checkint(), arg2.checkint());
+ switch (opcode) {
+ case 0:
+ return Bit32Lib.arshift(arg1.checkint(), arg2.checkint());
+ case 1:
+ return Bit32Lib.lrotate(arg1.checkint(), arg2.checkint());
+ case 2:
+ return Bit32Lib.lshift(arg1.checkint(), arg2.checkint());
+ case 3:
+ return Bit32Lib.rrotate(arg1.checkint(), arg2.checkint());
+ case 4:
+ return Bit32Lib.rshift(arg1.checkint(), arg2.checkint());
}
return NIL;
}
-
+
}
static LuaValue arshift(int x, int disp) {
if (disp >= 0) {
- return bitsToValue(x >> disp);
+ return bitsToValue(x>>disp);
} else {
- return bitsToValue(x << -disp);
+ return bitsToValue(x<<-disp);
}
}
@@ -120,9 +143,9 @@ public class Bit32Lib extends TwoArgFunction {
if (disp >= 32 || disp <= -32) {
return ZERO;
} else if (disp >= 0) {
- return bitsToValue(x >>> disp);
+ return bitsToValue(x>>>disp);
} else {
- return bitsToValue(x << -disp);
+ return bitsToValue(x<<-disp);
}
}
@@ -130,46 +153,46 @@ public class Bit32Lib extends TwoArgFunction {
if (disp >= 32 || disp <= -32) {
return ZERO;
} else if (disp >= 0) {
- return bitsToValue(x << disp);
+ return bitsToValue(x<
* Typically, this library is included as part of a call to either
- * {@link org.luaj.vm2.lib.jse.JsePlatform#standardGlobals()} or {@link org.luaj.vm2.lib.jme.JmePlatform#standardGlobals()}
- *
- * To instantiate and use it directly,
- * link it into your globals table via {@link LuaValue#load(LuaValue)} using code such as:
- *
+ *
* @see LibFunction
* @see org.luaj.vm2.lib.jse.JsePlatform
* @see org.luaj.vm2.lib.jme.JmePlatform
- * @see Lua 5.2 Coroutine Lib Reference
+ * @see Lua 5.2
+ * Coroutine Lib Reference
*/
public class CoroutineLib extends TwoArgFunction {
static int coroutine_count = 0;
Globals globals;
-
- /** Perform one-time initialization on the library by creating a table
- * containing the library functions, adding that table to the supplied environment,
- * adding the table to package.loaded, and returning table as the return value.
+
+ /**
+ * Perform one-time initialization on the library by creating a table
+ * containing the library functions, adding that table to the supplied
+ * environment, adding the table to package.loaded, and returning table as
+ * the return value.
+ *
* @param modname the module name supplied if this is loaded via 'require'.
- * @param env the environment to load into, which must be a Globals instance.
+ * @param env the environment to load into, which must be a Globals
+ * instance.
*/
public LuaValue call(LuaValue modname, LuaValue env) {
globals = env.checkglobals();
@@ -82,7 +97,8 @@ public class CoroutineLib extends TwoArgFunction {
coroutine.set("yield", new yield());
coroutine.set("wrap", new wrap());
env.set("coroutine", coroutine);
- if (!env.get("package").isnil()) env.get("package").get("loaded").set("coroutine", coroutine);
+ if (!env.get("package").isnil())
+ env.get("package").get("loaded").set("coroutine", coroutine);
return coroutine;
}
@@ -95,7 +111,7 @@ public class CoroutineLib extends TwoArgFunction {
static final class resume extends VarArgFunction {
public Varargs invoke(Varargs args) {
final LuaThread t = args.checkthread(1);
- return t.resume( args.subargs(2) );
+ return t.resume(args.subargs(2));
}
}
@@ -109,13 +125,13 @@ public class CoroutineLib extends TwoArgFunction {
static final class status extends LibFunction {
public LuaValue call(LuaValue t) {
LuaThread lt = t.checkthread();
- return valueOf( lt.getStatus() );
+ return valueOf(lt.getStatus());
}
}
-
+
final class yield extends VarArgFunction {
public Varargs invoke(Varargs args) {
- return globals.yield( args );
+ return globals.yield(args);
}
}
@@ -129,15 +145,17 @@ public class CoroutineLib extends TwoArgFunction {
static final class wrapper extends VarArgFunction {
final LuaThread luathread;
+
wrapper(LuaThread luathread) {
this.luathread = luathread;
}
+
public Varargs invoke(Varargs args) {
final Varargs result = luathread.resume(args);
- if ( result.arg1().toboolean() ) {
+ if (result.arg1().toboolean()) {
return result.subargs(2);
} else {
- return error( result.arg(2).tojstring() );
+ return error(result.arg(2).tojstring());
}
}
}
diff --git a/luaj-core/src/main/java/org/luaj/vm2/lib/DebugLib.java b/luaj-core/src/main/java/org/luaj/vm2/lib/DebugLib.java
index 167ea36c..959b71e3 100644
--- a/luaj-core/src/main/java/org/luaj/vm2/lib/DebugLib.java
+++ b/luaj-core/src/main/java/org/luaj/vm2/lib/DebugLib.java
@@ -39,58 +39,73 @@ import org.luaj.vm2.Prototype;
import org.luaj.vm2.Varargs;
/**
- * Subclass of {@link LibFunction} which implements the lua standard {@code debug}
- * library.
+ * Subclass of {@link LibFunction} which implements the lua standard
+ * {@code debug} library.
*
- * The debug library in luaj tries to emulate the behavior of the corresponding C-based lua library.
- * To do this, it must maintain a separate stack of calls to {@link LuaClosure} and {@link LibFunction}
- * instances.
- * Especially when lua-to-java bytecode compiling is being used
- * via a {@link org.luaj.vm2.Globals.Compiler} such as {@link org.luaj.vm2.luajc.LuaJC},
- * this cannot be done in all cases.
+ * The debug library in luaj tries to emulate the behavior of the corresponding
+ * C-based lua library. To do this, it must maintain a separate stack of calls
+ * to {@link LuaClosure} and {@link LibFunction} instances. Especially when
+ * lua-to-java bytecode compiling is being used via a
+ * {@link org.luaj.vm2.Globals.Compiler} such as
+ * {@link org.luaj.vm2.luajc.LuaJC}, this cannot be done in all cases.
*
* Typically, this library is included as part of a call to either
* {@link org.luaj.vm2.lib.jse.JsePlatform#debugGlobals()} or
* {@link org.luaj.vm2.lib.jme.JmePlatform#debugGlobals()}
- *
- * To instantiate and use it directly,
- * link it into your globals table via {@link LuaValue#load(LuaValue)} using code such as:
- *
- * This library exposes the entire state of lua code, and provides method to see and modify
- * all underlying lua values within a Java VM so should not be exposed to client code
- * in a shared server environment.
+ * This library exposes the entire state of lua code, and provides method to see
+ * and modify all underlying lua values within a Java VM so should not be
+ * exposed to client code in a shared server environment.
*
* @see LibFunction
* @see org.luaj.vm2.lib.jse.JsePlatform
* @see org.luaj.vm2.lib.jme.JmePlatform
- * @see Lua 5.2 Debug Lib Reference
+ * @see Lua 5.2 Debug
+ * Lib Reference
*/
public class DebugLib extends TwoArgFunction {
public static boolean CALLS;
public static boolean TRACE;
static {
- try { CALLS = (null != System.getProperty("CALLS")); } catch (Exception e) {}
- try { TRACE = (null != System.getProperty("TRACE")); } catch (Exception e) {}
+ try {
+ CALLS = (null != System.getProperty("CALLS"));
+ } catch (Exception e) {
+ }
+ try {
+ TRACE = (null != System.getProperty("TRACE"));
+ } catch (Exception e) {
+ }
}
-
- static final LuaString LUA = valueOf("Lua");
- private static final LuaString QMARK = valueOf("?");
- private static final LuaString CALL = valueOf("call");
- private static final LuaString LINE = valueOf("line");
- private static final LuaString COUNT = valueOf("count");
- private static final LuaString RETURN = valueOf("return");
-
+
+ static final LuaString LUA = valueOf("Lua");
+ private static final LuaString QMARK = valueOf("?");
+ private static final LuaString CALL = valueOf("call");
+ private static final LuaString LINE = valueOf("line");
+ private static final LuaString COUNT = valueOf("count");
+ private static final LuaString RETURN = valueOf("return");
+
static final LuaString FUNC = valueOf("func");
static final LuaString ISTAILCALL = valueOf("istailcall");
static final LuaString ISVARARG = valueOf("isvararg");
@@ -107,12 +122,16 @@ public class DebugLib extends TwoArgFunction {
static final LuaString ACTIVELINES = valueOf("activelines");
Globals globals;
-
- /** Perform one-time initialization on the library by creating a table
- * containing the library functions, adding that table to the supplied environment,
- * adding the table to package.loaded, and returning table as the return value.
+
+ /**
+ * Perform one-time initialization on the library by creating a table
+ * containing the library functions, adding that table to the supplied
+ * environment, adding the table to package.loaded, and returning table as
+ * the return value.
+ *
* @param modname the module name supplied if this is loaded via 'require'.
- * @param env the environment to load into, which must be a Globals instance.
+ * @param env the environment to load into, which must be a Globals
+ * instance.
*/
public LuaValue call(LuaValue modname, LuaValue env) {
globals = env.checkglobals();
@@ -135,7 +154,8 @@ public class DebugLib extends TwoArgFunction {
debug.set("upvalueid", new upvalueid());
debug.set("upvaluejoin", new upvaluejoin());
env.set("debug", debug);
- if (!env.get("package").isnil()) env.get("package").get("loaded").set("debug", debug);
+ if (!env.get("package").isnil())
+ env.get("package").get("loaded").set("debug", debug);
return debug;
}
@@ -149,19 +169,17 @@ public class DebugLib extends TwoArgFunction {
// debug.gethook ([thread])
final class gethook extends VarArgFunction {
public Varargs invoke(Varargs args) {
- LuaThread t = args.narg() > 0 ? args.checkthread(1): globals.running;
+ LuaThread t = args.narg() > 0? args.checkthread(1): globals.running;
LuaThread.State s = t.state;
- return varargsOf(
- s.hookfunc != null? s.hookfunc: NIL,
- valueOf((s.hookcall?"c":"")+(s.hookline?"l":"")+(s.hookrtrn?"r":"")),
- valueOf(s.hookcount));
+ return varargsOf(s.hookfunc != null? s.hookfunc: NIL,
+ valueOf((s.hookcall? "c": "")+(s.hookline? "l": "")+(s.hookrtrn? "r": "")), valueOf(s.hookcount));
}
}
// debug.getinfo ([thread,] f [, what])
final class getinfo extends VarArgFunction {
public Varargs invoke(Varargs args) {
- int a=1;
+ int a = 1;
LuaThread thread = args.isthread(a)? args.checkthread(a++): globals.running;
LuaValue func = args.arg(a++);
String what = args.optjstring(a++, "flnStu");
@@ -169,12 +187,12 @@ public class DebugLib extends TwoArgFunction {
// find the stack info
DebugLib.CallFrame frame;
- if ( func.isnumber() ) {
+ if (func.isnumber()) {
frame = callstack.getCallFrame(func.toint());
if (frame == null)
return NONE;
func = frame.f;
- } else if ( func.isfunction() ) {
+ } else if (func.isfunction()) {
frame = callstack.findCallFrame(func);
} else {
return argerror(a-2, "function or level");
@@ -191,7 +209,7 @@ public class DebugLib extends TwoArgFunction {
info.set(LASTLINEDEFINED, valueOf(ar.lastlinedefined));
}
if (what.indexOf('l') >= 0) {
- info.set( CURRENTLINE, valueOf(ar.currentline) );
+ info.set(CURRENTLINE, valueOf(ar.currentline));
}
if (what.indexOf('u') >= 0) {
info.set(NUPS, valueOf(ar.nups));
@@ -199,7 +217,7 @@ public class DebugLib extends TwoArgFunction {
info.set(ISVARARG, ar.isvararg? ONE: ZERO);
}
if (what.indexOf('n') >= 0) {
- info.set(NAME, LuaValue.valueOf(ar.name!=null? ar.name: "?"));
+ info.set(NAME, LuaValue.valueOf(ar.name != null? ar.name: "?"));
info.set(NAMEWHAT, LuaValue.valueOf(ar.namewhat));
}
if (what.indexOf('t') >= 0) {
@@ -209,13 +227,13 @@ public class DebugLib extends TwoArgFunction {
LuaTable lines = new LuaTable();
info.set(ACTIVELINES, lines);
DebugLib.CallFrame cf;
- for (int l = 1; (cf=callstack.getCallFrame(l)) != null; ++l)
+ for (int l = 1; (cf = callstack.getCallFrame(l)) != null; ++l)
if (cf.f == func)
lines.insert(-1, valueOf(cf.currentline()));
}
if (what.indexOf('f') >= 0) {
if (func != null)
- info.set( FUNC, func );
+ info.set(FUNC, func);
}
return info;
}
@@ -224,7 +242,7 @@ public class DebugLib extends TwoArgFunction {
// debug.getlocal ([thread,] f, local)
final class getlocal extends VarArgFunction {
public Varargs invoke(Varargs args) {
- int a=1;
+ int a = 1;
LuaThread thread = args.isthread(a)? args.checkthread(a++): globals.running;
int level = args.checkint(a++);
int local = args.checkint(a++);
@@ -253,11 +271,11 @@ public class DebugLib extends TwoArgFunction {
public Varargs invoke(Varargs args) {
LuaValue func = args.checkfunction(1);
int up = args.checkint(2);
- if ( func instanceof LuaClosure ) {
+ if (func instanceof LuaClosure) {
LuaClosure c = (LuaClosure) func;
LuaString name = findupvalue(c, up);
- if ( name != null ) {
- return varargsOf(name, c.upValues[up-1].getValue() );
+ if (name != null) {
+ return varargsOf(name, c.upValues[up-1].getValue());
}
}
return NIL;
@@ -270,22 +288,27 @@ public class DebugLib extends TwoArgFunction {
return u.isuserdata()? u: NIL;
}
}
-
-
+
// debug.sethook ([thread,] hook, mask [, count])
final class sethook extends VarArgFunction {
public Varargs invoke(Varargs args) {
- int a=1;
+ int a = 1;
LuaThread t = args.isthread(a)? args.checkthread(a++): globals.running;
- LuaValue func = args.optfunction(a++, null);
- String str = args.optjstring(a++,"");
- int count = args.optint(a++,0);
- boolean call=false,line=false,rtrn=false;
- for ( int i=0; i
* It contains the implementation of the io library support that is common to
- * the JSE and JME platforms.
- * In practice on of the concrete IOLib subclasses is chosen:
- * {@link org.luaj.vm2.lib.jse.JseIoLib} for the JSE platform, and
+ * the JSE and JME platforms. In practice on of the concrete IOLib subclasses is
+ * chosen: {@link org.luaj.vm2.lib.jse.JseIoLib} for the JSE platform, and
* {@link org.luaj.vm2.lib.jme.JmeIoLib} for the JME platform.
*
* The JSE implementation conforms almost completely to the C-based lua library,
- * while the JME implementation follows closely except in the area of random-access files,
- * which are difficult to support properly on JME.
+ * while the JME implementation follows closely except in the area of
+ * random-access files, which are difficult to support properly on JME.
*
* Typically, this library is included as part of a call to either
- * {@link org.luaj.vm2.lib.jse.JsePlatform#standardGlobals()} or {@link org.luaj.vm2.lib.jme.JmePlatform#standardGlobals()}
- *
- * To instantiate and use it directly,
- * link it into your globals table via {@link LuaValue#load(LuaValue)} using code such as:
- *
- * This has been implemented to match as closely as possible the behavior in the corresponding library in C.
+ * This has been implemented to match as closely as possible the behavior in the
+ * corresponding library in C.
+ *
* @see LibFunction
* @see org.luaj.vm2.lib.jse.JsePlatform
* @see org.luaj.vm2.lib.jme.JmePlatform
* @see org.luaj.vm2.lib.jse.JseIoLib
* @see org.luaj.vm2.lib.jme.JmeIoLib
- * @see http://www.lua.org/manual/5.1/manual.html#5.7
+ * @see http://www.lua.org/manual/5.1/manual.html#5.7
*/
-abstract
-public class IoLib extends TwoArgFunction {
+abstract public class IoLib extends TwoArgFunction {
+
+ abstract protected class File extends LuaValue {
+ abstract public void write(LuaString string) throws IOException;
- abstract
- protected class File extends LuaValue{
- abstract public void write( LuaString string ) throws IOException;
abstract public void flush() throws IOException;
+
abstract public boolean isstdfile();
+
abstract public void close() throws IOException;
+
abstract public boolean isclosed();
+
// returns new position
abstract public int seek(String option, int bytecount) throws IOException;
+
abstract public void setvbuf(String mode, int size);
+
// get length remaining to read
abstract public int remaining() throws IOException;
+
// peek ahead one character
abstract public int peek() throws IOException, EOFException;
+
// return char if read, -1 if eof, throw IOException on other exception
abstract public int read() throws IOException, EOFException;
+
// return number of bytes read if positive, false if eof, throw IOException on other exception
abstract public int read(byte[] bytes, int offset, int length) throws IOException;
-
+
public boolean eof() throws IOException {
try {
return peek() < 0;
- } catch (EOFException e) { return true; }
+ } catch (EOFException e) {
+ return true;
+ }
}
-
+
// delegate method access to file methods table
- public LuaValue get( LuaValue key ) {
+ public LuaValue get(LuaValue key) {
return filemethods.get(key);
}
@@ -110,35 +133,38 @@ public class IoLib extends TwoArgFunction {
public int type() {
return LuaValue.TUSERDATA;
}
+
public String typename() {
return "userdata";
}
-
+
// displays as "file" type
public String tojstring() {
return "file: " + Integer.toHexString(hashCode());
}
-
+
public void finalize() {
if (!isclosed()) {
try {
close();
- } catch (IOException ignore) {}
+ } catch (IOException ignore) {
+ }
}
}
}
/** Enumerated value representing stdin */
- protected static final int FTYPE_STDIN = 0;
+ protected static final int FTYPE_STDIN = 0;
/** Enumerated value representing stdout */
protected static final int FTYPE_STDOUT = 1;
/** Enumerated value representing stderr */
protected static final int FTYPE_STDERR = 2;
/** Enumerated value representing a file type for a named file */
- protected static final int FTYPE_NAMED = 3;
+ protected static final int FTYPE_NAMED = 3;
/**
* Wrap the standard input.
+ *
* @return File
* @throws IOException
*/
@@ -146,32 +172,37 @@ public class IoLib extends TwoArgFunction {
/**
* Wrap the standard output.
+ *
* @return File
* @throws IOException
*/
abstract protected File wrapStdout() throws IOException;
-
+
/**
* Wrap the standard error output.
+ *
* @return File
* @throws IOException
*/
abstract protected File wrapStderr() throws IOException;
-
+
/**
* Open a file in a particular mode.
+ *
* @param filename
- * @param readMode true if opening in read mode
+ * @param readMode true if opening in read mode
* @param appendMode true if opening in append mode
* @param updateMode true if opening in update mode
* @param binaryMode true if opening in binary mode
* @return File object if successful
* @throws IOException if could not be opened
*/
- abstract protected File openFile( String filename, boolean readMode, boolean appendMode, boolean updateMode, boolean binaryMode ) throws IOException;
+ abstract protected File openFile(String filename, boolean readMode, boolean appendMode, boolean updateMode,
+ boolean binaryMode) throws IOException;
/**
* Open a temporary file.
+ *
* @return File object if successful
* @throws IOException if could not be opened
*/
@@ -179,6 +210,7 @@ public class IoLib extends TwoArgFunction {
/**
* Start a new process and return a file for input or output
+ *
* @param prog the program to execute
* @param mode "r" to read, "w" to write
* @return File to read to or write from
@@ -195,103 +227,88 @@ public class IoLib extends TwoArgFunction {
private static final LuaValue STDERR = valueOf("stderr");
private static final LuaValue FILE = valueOf("file");
private static final LuaValue CLOSED_FILE = valueOf("closed file");
-
- private static final int IO_CLOSE = 0;
- private static final int IO_FLUSH = 1;
- private static final int IO_INPUT = 2;
- private static final int IO_LINES = 3;
- private static final int IO_OPEN = 4;
- private static final int IO_OUTPUT = 5;
- private static final int IO_POPEN = 6;
- private static final int IO_READ = 7;
- private static final int IO_TMPFILE = 8;
- private static final int IO_TYPE = 9;
- private static final int IO_WRITE = 10;
- private static final int FILE_CLOSE = 11;
- private static final int FILE_FLUSH = 12;
- private static final int FILE_LINES = 13;
- private static final int FILE_READ = 14;
- private static final int FILE_SEEK = 15;
- private static final int FILE_SETVBUF = 16;
- private static final int FILE_WRITE = 17;
-
- private static final int IO_INDEX = 18;
- private static final int LINES_ITER = 19;
+ private static final int IO_CLOSE = 0;
+ private static final int IO_FLUSH = 1;
+ private static final int IO_INPUT = 2;
+ private static final int IO_LINES = 3;
+ private static final int IO_OPEN = 4;
+ private static final int IO_OUTPUT = 5;
+ private static final int IO_POPEN = 6;
+ private static final int IO_READ = 7;
+ private static final int IO_TMPFILE = 8;
+ private static final int IO_TYPE = 9;
+ private static final int IO_WRITE = 10;
- public static final String[] IO_NAMES = {
- "close",
- "flush",
- "input",
- "lines",
- "open",
- "output",
- "popen",
- "read",
- "tmpfile",
- "type",
- "write",
- };
-
- public static final String[] FILE_NAMES = {
- "close",
- "flush",
- "lines",
- "read",
- "seek",
- "setvbuf",
- "write",
- };
+ private static final int FILE_CLOSE = 11;
+ private static final int FILE_FLUSH = 12;
+ private static final int FILE_LINES = 13;
+ private static final int FILE_READ = 14;
+ private static final int FILE_SEEK = 15;
+ private static final int FILE_SETVBUF = 16;
+ private static final int FILE_WRITE = 17;
+
+ private static final int IO_INDEX = 18;
+ private static final int LINES_ITER = 19;
+
+ public static final String[] IO_NAMES = { "close", "flush", "input", "lines", "open", "output", "popen", "read",
+ "tmpfile", "type", "write", };
+
+ public static final String[] FILE_NAMES = { "close", "flush", "lines", "read", "seek", "setvbuf", "write", };
LuaTable filemethods;
-
+
protected Globals globals;
-
+
public LuaValue call(LuaValue modname, LuaValue env) {
globals = env.checkglobals();
-
+
// io lib functions
LuaTable t = new LuaTable();
- bind(t, IoLibV.class, IO_NAMES );
-
+ bind(t, IoLibV.class, IO_NAMES);
+
// create file methods table
filemethods = new LuaTable();
- bind(filemethods, IoLibV.class, FILE_NAMES, FILE_CLOSE );
+ bind(filemethods, IoLibV.class, FILE_NAMES, FILE_CLOSE);
// set up file metatable
LuaTable mt = new LuaTable();
- bind(mt, IoLibV.class, new String[] { "__index" }, IO_INDEX );
- t.setmetatable( mt );
-
+ bind(mt, IoLibV.class, new String[] { "__index" }, IO_INDEX);
+ t.setmetatable(mt);
+
// all functions link to library instance
- setLibInstance( t );
- setLibInstance( filemethods );
- setLibInstance( mt );
-
+ setLibInstance(t);
+ setLibInstance(filemethods);
+ setLibInstance(mt);
+
// return the table
env.set("io", t);
- if (!env.get("package").isnil()) env.get("package").get("loaded").set("io", t);
+ if (!env.get("package").isnil())
+ env.get("package").get("loaded").set("io", t);
return t;
}
private void setLibInstance(LuaTable t) {
LuaValue[] k = t.keys();
- for ( int i=0, n=k.length; i
- * To provide for common implementations in JME and JSE,
- * library functions are typically grouped on one or more library classes
- * and an opcode per library function is defined and used to key the switch
- * to the correct function within the library.
+ * To provide for common implementations in JME and JSE, library functions are
+ * typically grouped on one or more library classes and an opcode per library
+ * function is defined and used to key the switch to the correct function within
+ * the library.
*
- * Since lua functions can be called with too few or too many arguments,
- * and there are overloaded {@link LuaValue#call()} functions with varying
- * number of arguments, a Java function exposed in lua needs to handle the
- * argument fixup when a function is called with a number of arguments
- * differs from that expected.
+ * Since lua functions can be called with too few or too many arguments, and
+ * there are overloaded {@link LuaValue#call()} functions with varying number of
+ * arguments, a Java function exposed in lua needs to handle the argument fixup
+ * when a function is called with a number of arguments differs from that
+ * expected.
*
- * To simplify the creation of library functions,
- * there are 5 direct subclasses to handle common cases based on number of
- * argument values and number of return return values.
+ * To simplify the creation of library functions, there are 5 direct subclasses
+ * to handle common cases based on number of argument values and number of
+ * return return values.
*
- * To be a Java library that can be loaded via {@code require}, it should have
- * a public constructor that returns a {@link LuaValue} that, when executed,
+ * To be a Java library that can be loaded via {@code require}, it should have a
+ * public constructor that returns a {@link LuaValue} that, when executed,
* initializes the library.
*
* For example, the following code will implement a library called "hyperbolic"
* with two functions, "sinh", and "cosh":
-
* To test it, a script such as this can be used:
- *
* It should produce something like:
- *
- * See the source code in any of the library functions
- * such as {@link BaseLib} or {@link TableLib} for other examples.
+ * See the source code in any of the library functions such as {@link BaseLib}
+ * or {@link TableLib} for other examples.
*/
abstract public class LibFunction extends LuaFunction {
-
- /** User-defined opcode to differentiate between instances of the library function class.
+
+ /**
+ * User-defined opcode to differentiate between instances of the library
+ * function class.
*
- * Subclass will typicall switch on this value to provide the specific behavior for each function.
+ * Subclass will typicall switch on this value to provide the specific
+ * behavior for each function.
*/
protected int opcode;
-
- /** The common name for this function, useful for debugging.
+
+ /**
+ * The common name for this function, useful for debugging.
*
* Binding functions initialize this to the name to which it is bound.
*/
protected String name;
-
+
/** Default constructor for use by subclasses */
protected LibFunction() {
}
-
+
public String tojstring() {
- return name != null ? "function: " + name : super.tojstring();
+ return name != null? "function: " + name: super.tojstring();
}
-
+
/**
* Bind a set of library functions.
*
- * An array of names is provided, and the first name is bound
- * with opcode = 0, second with 1, etc.
- * @param env The environment to apply to each bound function
+ * An array of names is provided, and the first name is bound with opcode =
+ * 0, second with 1, etc.
+ *
+ * @param env The environment to apply to each bound function
* @param factory the Class to instantiate for each bound function
- * @param names array of String names, one for each function.
+ * @param names array of String names, one for each function.
* @see #bind(LuaValue, Class, String[], int)
*/
- protected void bind(LuaValue env, Class factory, String[] names ) {
- bind( env, factory, names, 0 );
+ protected void bind(LuaValue env, Class factory, String[] names) {
+ bind(env, factory, names, 0);
}
-
+
/**
* Bind a set of library functions, with an offset
*
- * An array of names is provided, and the first name is bound
- * with opcode = {@code firstopcode}, second with {@code firstopcode+1}, etc.
- * @param env The environment to apply to each bound function
- * @param factory the Class to instantiate for each bound function
- * @param names array of String names, one for each function.
+ * An array of names is provided, and the first name is bound with opcode =
+ * {@code firstopcode}, second with {@code firstopcode+1}, etc.
+ *
+ * @param env The environment to apply to each bound function
+ * @param factory the Class to instantiate for each bound function
+ * @param names array of String names, one for each function.
* @param firstopcode the first opcode to use
* @see #bind(LuaValue, Class, String[])
*/
- protected void bind(LuaValue env, Class factory, String[] names, int firstopcode ) {
+ protected void bind(LuaValue env, Class factory, String[] names, int firstopcode) {
try {
- for ( int i=0, n=names.length; i
* The implementations of {@code exp()} and {@code pow()} are constructed by
- * hand for JME, so will be slower and less accurate than when executed on the JSE platform.
+ * hand for JME, so will be slower and less accurate than when executed on the
+ * JSE platform.
*
* Typically, this library is included as part of a call to either
* {@link org.luaj.vm2.lib.jse.JsePlatform#standardGlobals()} or
* {@link org.luaj.vm2.lib.jme.JmePlatform#standardGlobals()}
- *
- * To instantiate and use it directly,
- * link it into your globals table via {@link LuaValue#load(LuaValue)} using code such as:
- *
- * This has been implemented to match as closely as possible the behavior in the corresponding library in C.
+ * This has been implemented to match as closely as possible the behavior in the
+ * corresponding library in C.
+ *
* @see LibFunction
* @see org.luaj.vm2.lib.jse.JsePlatform
* @see org.luaj.vm2.lib.jme.JmePlatform
* @see org.luaj.vm2.lib.jse.JseMathLib
- * @see Lua 5.2 Math Lib Reference
+ * @see Lua 5.2 Math Lib
+ * Reference
*/
public class MathLib extends TwoArgFunction {
- /** Pointer to the latest MathLib instance, used only to dispatch
- * math.exp to tha correct platform math library.
+ /**
+ * Pointer to the latest MathLib instance, used only to dispatch math.exp to
+ * tha correct platform math library.
*/
public static MathLib MATHLIB = null;
- /** Construct a MathLib, which can be initialized by calling it with a
+ /**
+ * Construct a MathLib, which can be initialized by calling it with a
* modname string, and a global environment table as arguments using
- * {@link #call(LuaValue, LuaValue)}. */
+ * {@link #call(LuaValue, LuaValue)}.
+ */
public MathLib() {
MATHLIB = this;
}
- /** Perform one-time initialization on the library by creating a table
- * containing the library functions, adding that table to the supplied environment,
- * adding the table to package.loaded, and returning table as the return value.
+ /**
+ * Perform one-time initialization on the library by creating a table
+ * containing the library functions, adding that table to the supplied
+ * environment, adding the table to package.loaded, and returning table as
+ * the return value.
+ *
* @param modname the module name supplied if this is loaded via 'require'.
- * @param env the environment to load into, typically a Globals instance.
+ * @param env the environment to load into, typically a Globals
+ * instance.
*/
public LuaValue call(LuaValue modname, LuaValue env) {
- LuaTable math = new LuaTable(0,30);
+ LuaTable math = new LuaTable(0, 30);
math.set("abs", new abs());
math.set("ceil", new ceil());
math.set("cos", new cos());
@@ -110,12 +131,12 @@ public class MathLib extends TwoArgFunction {
math.set("floor", new floor());
math.set("fmod", new fmod());
math.set("frexp", new frexp());
- math.set("huge", LuaDouble.POSINF );
+ math.set("huge", LuaDouble.POSINF);
math.set("ldexp", new ldexp());
math.set("max", new max());
math.set("min", new min());
math.set("modf", new modf());
- math.set("pi", Math.PI );
+ math.set("pi", Math.PI);
math.set("pow", new pow());
random r;
math.set("random", r = new random());
@@ -125,14 +146,16 @@ public class MathLib extends TwoArgFunction {
math.set("sqrt", new sqrt());
math.set("tan", new tan());
env.set("math", math);
- if (!env.get("package").isnil()) env.get("package").get("loaded").set("math", math);
+ if (!env.get("package").isnil())
+ env.get("package").get("loaded").set("math", math);
return math;
}
-
+
abstract protected static class UnaryOp extends OneArgFunction {
public LuaValue call(LuaValue arg) {
return valueOf(call(arg.checkdouble()));
}
+
abstract protected double call(double d);
}
@@ -140,43 +163,74 @@ public class MathLib extends TwoArgFunction {
public LuaValue call(LuaValue x, LuaValue y) {
return valueOf(call(x.checkdouble(), y.checkdouble()));
}
+
abstract protected double call(double x, double y);
}
- static final class abs extends UnaryOp { protected double call(double d) { return Math.abs(d); } }
- static final class ceil extends UnaryOp { protected double call(double d) { return Math.ceil(d); } }
- static final class cos extends UnaryOp { protected double call(double d) { return Math.cos(d); } }
- static final class deg extends UnaryOp { protected double call(double d) { return Math.toDegrees(d); } }
- static final class floor extends UnaryOp { protected double call(double d) { return Math.floor(d); } }
- static final class rad extends UnaryOp { protected double call(double d) { return Math.toRadians(d); } }
- static final class sin extends UnaryOp { protected double call(double d) { return Math.sin(d); } }
- static final class sqrt extends UnaryOp { protected double call(double d) { return Math.sqrt(d); } }
- static final class tan extends UnaryOp { protected double call(double d) { return Math.tan(d); } }
+ static final class abs extends UnaryOp {
+ protected double call(double d) { return Math.abs(d); }
+ }
+
+ static final class ceil extends UnaryOp {
+ protected double call(double d) { return Math.ceil(d); }
+ }
+
+ static final class cos extends UnaryOp {
+ protected double call(double d) { return Math.cos(d); }
+ }
+
+ static final class deg extends UnaryOp {
+ protected double call(double d) { return Math.toDegrees(d); }
+ }
+
+ static final class floor extends UnaryOp {
+ protected double call(double d) { return Math.floor(d); }
+ }
+
+ static final class rad extends UnaryOp {
+ protected double call(double d) { return Math.toRadians(d); }
+ }
+
+ static final class sin extends UnaryOp {
+ protected double call(double d) { return Math.sin(d); }
+ }
+
+ static final class sqrt extends UnaryOp {
+ protected double call(double d) { return Math.sqrt(d); }
+ }
+
+ static final class tan extends UnaryOp {
+ protected double call(double d) { return Math.tan(d); }
+ }
static final class exp extends UnaryOp {
final MathLib mathlib;
+
exp(MathLib mathlib) {
this.mathlib = mathlib;
}
+
protected double call(double d) {
- return mathlib.dpow_lib(Math.E,d);
+ return mathlib.dpow_lib(Math.E, d);
}
}
-
+
static final class fmod extends TwoArgFunction {
public LuaValue call(LuaValue xv, LuaValue yv) {
if (xv.islong() && yv.islong()) {
- return valueOf(xv.tolong() % yv.tolong());
+ return valueOf(xv.tolong()%yv.tolong());
}
- return valueOf(xv.checkdouble() % yv.checkdouble());
+ return valueOf(xv.checkdouble()%yv.checkdouble());
}
}
+
static final class ldexp extends BinaryOp {
protected double call(double x, double y) {
// This is the behavior on os-x, windows differs in rounding behavior.
- return x * Double.longBitsToDouble((((long) y) + 1023) << 52);
+ return x*Double.longBitsToDouble((((long) y)+1023)<<52);
}
}
+
static final class pow extends BinaryOp {
protected double call(double x, double y) {
return MathLib.dpow_default(x, y);
@@ -186,117 +240,127 @@ public class MathLib extends TwoArgFunction {
static class frexp extends VarArgFunction {
public Varargs invoke(Varargs args) {
double x = args.checkdouble(1);
- if ( x == 0 ) return varargsOf(ZERO,ZERO);
- long bits = Double.doubleToLongBits( x );
- double m = ((bits & (~(-1L<<52))) + (1L<<52)) * ((bits >= 0)? (.5 / (1L<<52)): (-.5 / (1L<<52)));
- double e = (((int) (bits >> 52)) & 0x7ff) - 1022;
- return varargsOf( valueOf(m), valueOf(e) );
+ if (x == 0)
+ return varargsOf(ZERO, ZERO);
+ long bits = Double.doubleToLongBits(x);
+ double m = ((bits & (~(-1L<<52)))+(1L<<52))*((bits >= 0)? (.5/(1L<<52)): (-.5/(1L<<52)));
+ double e = (((int) (bits>>52)) & 0x7ff)-1022;
+ return varargsOf(valueOf(m), valueOf(e));
}
}
static class max extends VarArgFunction {
public Varargs invoke(Varargs args) {
LuaValue m = args.checkvalue(1);
- for ( int i=2,n=args.narg(); i<=n; ++i ) {
+ for (int i = 2, n = args.narg(); i <= n; ++i) {
LuaValue v = args.checkvalue(i);
- if (m.lt_b(v)) m = v;
+ if (m.lt_b(v))
+ m = v;
}
return m;
}
}
-
+
static class min extends VarArgFunction {
public Varargs invoke(Varargs args) {
LuaValue m = args.checkvalue(1);
- for ( int i=2,n=args.narg(); i<=n; ++i ) {
+ for (int i = 2, n = args.narg(); i <= n; ++i) {
LuaValue v = args.checkvalue(i);
- if (v.lt_b(m)) m = v;
+ if (v.lt_b(m))
+ m = v;
}
return m;
}
}
-
+
static class modf extends VarArgFunction {
public Varargs invoke(Varargs args) {
LuaValue n = args.arg1();
/* number is its own integer part, no fractional part */
- if (n.islong()) return varargsOf(n, valueOf(0.0));
+ if (n.islong())
+ return varargsOf(n, valueOf(0.0));
double x = n.checkdouble();
/* integer part (rounds toward zero) */
- double intPart = ( x > 0 ) ? Math.floor( x ) : Math.ceil( x );
+ double intPart = (x > 0)? Math.floor(x): Math.ceil(x);
/* fractional part (test needed for inf/-inf) */
- double fracPart = x == intPart ? 0.0 : x - intPart;
- return varargsOf( valueOf(intPart), valueOf(fracPart) );
+ double fracPart = x == intPart? 0.0: x-intPart;
+ return varargsOf(valueOf(intPart), valueOf(fracPart));
}
}
-
+
static class random extends LibFunction {
Random random = new Random();
+
public LuaValue call() {
- return valueOf( random.nextDouble() );
+ return valueOf(random.nextDouble());
}
+
public LuaValue call(LuaValue a) {
int m = a.checkint();
- if (m<1) argerror(1, "interval is empty");
- return valueOf( 1 + random.nextInt(m) );
+ if (m < 1)
+ argerror(1, "interval is empty");
+ return valueOf(1+random.nextInt(m));
}
+
public LuaValue call(LuaValue a, LuaValue b) {
int m = a.checkint();
int n = b.checkint();
- if (n
- * Subclasses need only implement {@link LuaValue#call(LuaValue)} to complete this class,
- * simplifying development.
- * All other uses of {@link #call()}, {@link #invoke(Varargs)},etc,
- * are routed through this method by this class,
+ * Subclasses need only implement {@link LuaValue#call(LuaValue)} to complete
+ * this class, simplifying development. All other uses of {@link #call()},
+ * {@link #invoke(Varargs)},etc, are routed through this method by this class,
* dropping or extending arguments with {@code nil} values as required.
*
- * If more than one argument are required, or no arguments are required,
- * or variable argument or variable return values,
- * then use one of the related function
- * {@link ZeroArgFunction}, {@link TwoArgFunction}, {@link ThreeArgFunction}, or {@link VarArgFunction}.
+ * If more than one argument are required, or no arguments are required, or
+ * variable argument or variable return values, then use one of the related
+ * function {@link ZeroArgFunction}, {@link TwoArgFunction},
+ * {@link ThreeArgFunction}, or {@link VarArgFunction}.
*
- * See {@link LibFunction} for more information on implementation libraries and library functions.
+ * See {@link LibFunction} for more information on implementation libraries and
+ * library functions.
+ *
* @see #call(LuaValue)
* @see LibFunction
* @see ZeroArgFunction
@@ -49,11 +51,11 @@ import org.luaj.vm2.Varargs;
abstract public class OneArgFunction extends LibFunction {
abstract public LuaValue call(LuaValue arg);
-
+
/** Default constructor */
public OneArgFunction() {
}
-
+
public final LuaValue call() {
return call(NIL);
}
@@ -69,4 +71,4 @@ abstract public class OneArgFunction extends LibFunction {
public Varargs invoke(Varargs varargs) {
return call(varargs.arg1());
}
-}
+}
diff --git a/luaj-core/src/main/java/org/luaj/vm2/lib/OsLib.java b/luaj-core/src/main/java/org/luaj/vm2/lib/OsLib.java
index 85b8677e..7666a307 100644
--- a/luaj-core/src/main/java/org/luaj/vm2/lib/OsLib.java
+++ b/luaj-core/src/main/java/org/luaj/vm2/lib/OsLib.java
@@ -32,21 +32,21 @@ import org.luaj.vm2.LuaValue;
import org.luaj.vm2.Varargs;
/**
- * Subclass of {@link LibFunction} which implements the standard lua {@code os} library.
+ * Subclass of {@link LibFunction} which implements the standard lua {@code os}
+ * library.
*
- * It is a usable base with simplified stub functions
- * for library functions that cannot be implemented uniformly
- * on Jse and Jme.
+ * It is a usable base with simplified stub functions for library functions that
+ * cannot be implemented uniformly on Jse and Jme.
*
- * This can be installed as-is on either platform, or extended
- * and refined to be used in a complete Jse implementation.
+ * This can be installed as-is on either platform, or extended and refined to be
+ * used in a complete Jse implementation.
*
- * Because the nature of the {@code os} library is to encapsulate
- * os-specific features, the behavior of these functions varies considerably
- * from their counterparts in the C platform.
+ * Because the nature of the {@code os} library is to encapsulate os-specific
+ * features, the behavior of these functions varies considerably from their
+ * counterparts in the C platform.
*
- * The following functions have limited implementations of features
- * that are not supported well on Jme:
+ * The following functions have limited implementations of features that are not
+ * supported well on Jme:
*
* Typically, this library is included as part of a call to either
- * {@link org.luaj.vm2.lib.jse.JsePlatform#standardGlobals()} or {@link org.luaj.vm2.lib.jme.JmePlatform#standardGlobals()}
- *
- * To instantiate and use it directly,
- * link it into your globals table via {@link LuaValue#load(LuaValue)} using code such as:
- *
- * @see LibFunction
+ *
+ * @see LibFunction
* @see org.luaj.vm2.lib.jse.JseOsLib
* @see org.luaj.vm2.lib.jse.JsePlatform
* @see org.luaj.vm2.lib.jme.JmePlatform
- * @see http://www.lua.org/manual/5.1/manual.html#5.8
+ * @see http://www.lua.org/manual/5.1/manual.html#5.8
*/
public class OsLib extends TwoArgFunction {
- public static final String TMP_PREFIX = ".luaj";
- public static final String TMP_SUFFIX = "tmp";
+ public static final String TMP_PREFIX = ".luaj";
+ public static final String TMP_SUFFIX = "tmp";
private static final int CLOCK = 0;
private static final int DATE = 1;
@@ -95,36 +108,29 @@ public class OsLib extends TwoArgFunction {
private static final int TIME = 9;
private static final int TMPNAME = 10;
- private static final String[] NAMES = {
- "clock",
- "date",
- "difftime",
- "execute",
- "exit",
- "getenv",
- "remove",
- "rename",
- "setlocale",
- "time",
- "tmpname",
- };
-
- private static final long t0 = System.currentTimeMillis();
- private static long tmpnames = t0;
+ private static final String[] NAMES = { "clock", "date", "difftime", "execute", "exit", "getenv", "remove",
+ "rename", "setlocale", "time", "tmpname", };
+
+ private static final long t0 = System.currentTimeMillis();
+ private static long tmpnames = t0;
protected Globals globals;
-
+
/**
* Create and OsLib instance.
*/
public OsLib() {
}
-
- /** Perform one-time initialization on the library by creating a table
- * containing the library functions, adding that table to the supplied environment,
- * adding the table to package.loaded, and returning table as the return value.
+
+ /**
+ * Perform one-time initialization on the library by creating a table
+ * containing the library functions, adding that table to the supplied
+ * environment, adding the table to package.loaded, and returning table as
+ * the return value.
+ *
* @param modname the module name supplied if this is loaded via 'require'.
- * @param env the environment to load into, typically a Globals instance.
+ * @param env the environment to load into, typically a Globals
+ * instance.
*/
public LuaValue call(LuaValue modname, LuaValue env) {
globals = env.checkglobals();
@@ -132,7 +138,8 @@ public class OsLib extends TwoArgFunction {
for (int i = 0; i < NAMES.length; ++i)
os.set(NAMES[i], new OsLibFunc(i, NAMES[i]));
env.set("os", os);
- if (!env.get("package").isnil()) env.get("package").get("loaded").set("os", os);
+ if (!env.get("package").isnil())
+ env.get("package").get("loaded").set("os", os);
return os;
}
@@ -141,9 +148,10 @@ public class OsLib extends TwoArgFunction {
this.opcode = opcode;
this.name = name;
}
+
public Varargs invoke(Varargs args) {
try {
- switch ( opcode ) {
+ switch (opcode) {
case CLOCK:
return valueOf(clock());
case DATE: {
@@ -151,7 +159,7 @@ public class OsLib extends TwoArgFunction {
double t = args.isnumber(2)? args.todouble(2): time(null);
if (s.equals("*t")) {
Calendar d = Calendar.getInstance();
- d.setTime(new Date((long)(t*1000)));
+ d.setTime(new Date((long) (t*1000)));
LuaTable tbl = LuaValue.tableOf();
tbl.set("year", LuaValue.valueOf(d.get(Calendar.YEAR)));
tbl.set("month", LuaValue.valueOf(d.get(Calendar.MONTH)+1));
@@ -164,10 +172,10 @@ public class OsLib extends TwoArgFunction {
tbl.set("isdst", LuaValue.valueOf(isDaylightSavingsTime(d)));
return tbl;
}
- return valueOf( date(s, t==-1? time(null): t) );
+ return valueOf(date(s, t == -1? time(null): t));
}
case DIFFTIME:
- return valueOf(difftime(args.checkdouble(1),args.checkdouble(2)));
+ return valueOf(difftime(args.checkdouble(1), args.checkdouble(2)));
case EXECUTE:
return execute(args.optjstring(1, null));
case EXIT:
@@ -175,7 +183,7 @@ public class OsLib extends TwoArgFunction {
return NONE;
case GETENV: {
final String val = getenv(args.checkjstring(1));
- return val!=null? valueOf(val): NIL;
+ return val != null? valueOf(val): NIL;
}
case REMOVE:
remove(args.checkjstring(1));
@@ -184,8 +192,8 @@ public class OsLib extends TwoArgFunction {
rename(args.checkjstring(1), args.checkjstring(2));
return LuaValue.TRUE;
case SETLOCALE: {
- String s = setlocale(args.optjstring(1,null), args.optjstring(2, "all"));
- return s!=null? valueOf(s): NIL;
+ String s = setlocale(args.optjstring(1, null), args.optjstring(2, "all"));
+ return s != null? valueOf(s): NIL;
}
case TIME:
return valueOf(time(args.opttable(1, null)));
@@ -193,78 +201,79 @@ public class OsLib extends TwoArgFunction {
return valueOf(tmpname());
}
return NONE;
- } catch ( IOException e ) {
+ } catch (IOException e) {
return varargsOf(NIL, valueOf(e.getMessage()));
}
}
}
/**
- * @return an approximation of the amount in seconds of CPU time used by
- * the program. For luaj this simple returns the elapsed time since the
- * OsLib class was loaded.
+ * @return an approximation of the amount in seconds of CPU time used by the
+ * program. For luaj this simple returns the elapsed time since the
+ * OsLib class was loaded.
*/
protected double clock() {
- return (System.currentTimeMillis()-t0) / 1000.;
+ return (System.currentTimeMillis()-t0)/1000.;
}
/**
- * Returns the number of seconds from time t1 to time t2.
- * In POSIX, Windows, and some other systems, this value is exactly t2-t1.
+ * Returns the number of seconds from time t1 to time t2. In POSIX, Windows,
+ * and some other systems, this value is exactly t2-t1.
+ *
* @param t2
* @param t1
* @return diffeence in time values, in seconds
*/
protected double difftime(double t2, double t1) {
- return t2 - t1;
+ return t2-t1;
}
/**
- * If the time argument is present, this is the time to be formatted
- * (see the os.time function for a description of this value).
- * Otherwise, date formats the current time.
+ * If the time argument is present, this is the time to be formatted (see
+ * the os.time function for a description of this value). Otherwise, date
+ * formats the current time.
*
- * Date returns the date as a string,
- * formatted according to the same rules as ANSII strftime, but without
- * support for %g, %G, or %V.
+ * Date returns the date as a string, formatted according to the same rules
+ * as ANSII strftime, but without support for %g, %G, or %V.
*
- * When called without arguments, date returns a reasonable date and
- * time representation that depends on the host system and on the
- * current locale (that is, os.date() is equivalent to os.date("%c")).
+ * When called without arguments, date returns a reasonable date and time
+ * representation that depends on the host system and on the current locale
+ * (that is, os.date() is equivalent to os.date("%c")).
*
* @param format
- * @param time time since epoch, or -1 if not supplied
- * @return a LString or a LTable containing date and time,
- * formatted according to the given string format.
+ * @param time time since epoch, or -1 if not supplied
+ * @return a LString or a LTable containing date and time, formatted
+ * according to the given string format.
*/
public String date(String format, double time) {
Calendar d = Calendar.getInstance();
- d.setTime(new Date((long)(time*1000)));
+ d.setTime(new Date((long) (time*1000)));
if (format.startsWith("!")) {
time -= timeZoneOffset(d);
- d.setTime(new Date((long)(time*1000)));
+ d.setTime(new Date((long) (time*1000)));
format = format.substring(1);
}
byte[] fmt = format.getBytes();
final int n = fmt.length;
Buffer result = new Buffer(n);
byte c;
- for ( int i = 0; i < n; ) {
- switch ( c = fmt[i++ ] ) {
+ for (int i = 0; i < n;) {
+ switch (c = fmt[i++]) {
case '\n':
- result.append( "\n" );
+ result.append("\n");
break;
default:
- result.append( c );
+ result.append(c);
break;
case '%':
- if (i >= n) break;
- switch ( c = fmt[i++ ] ) {
+ if (i >= n)
+ break;
+ switch (c = fmt[i++]) {
default:
- LuaValue.argerror(1, "invalid conversion specifier '%"+c+"'");
+ LuaValue.argerror(1, "invalid conversion specifier '%" + c + "'");
break;
case '%':
- result.append( (byte)'%' );
+ result.append((byte) '%');
break;
case 'a':
result.append(WeekdayNameAbbrev[d.get(Calendar.DAY_OF_WEEK)-1]);
@@ -292,7 +301,7 @@ public class OsLib extends TwoArgFunction {
break;
case 'j': { // day of year.
Calendar y0 = beginningOfYear(d);
- int dayOfYear = (int) ((d.getTime().getTime() - y0.getTime().getTime()) / (24 * 3600L * 1000L));
+ int dayOfYear = (int) ((d.getTime().getTime()-y0.getTime().getTime())/(24*3600L*1000L));
result.append(String.valueOf(1001+dayOfYear).substring(1));
break;
}
@@ -330,11 +339,11 @@ public class OsLib extends TwoArgFunction {
result.append(String.valueOf(d.get(Calendar.YEAR)));
break;
case 'z': {
- final int tzo = timeZoneOffset(d) / 60;
+ final int tzo = timeZoneOffset(d)/60;
final int a = Math.abs(tzo);
- final String h = String.valueOf(100 + a / 60).substring(1);
- final String m = String.valueOf(100 + a % 60).substring(1);
- result.append((tzo>=0? "+": "-") + h + m);
+ final String h = String.valueOf(100+a/60).substring(1);
+ final String m = String.valueOf(100+a%60).substring(1);
+ result.append((tzo >= 0? "+": "-")+h+m);
break;
}
}
@@ -342,11 +351,14 @@ public class OsLib extends TwoArgFunction {
}
return result.tojstring();
}
-
+
private static final String[] WeekdayNameAbbrev = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
- private static final String[] WeekdayName = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };
- private static final String[] MonthNameAbbrev = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
- private static final String[] MonthName = { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" };
+ private static final String[] WeekdayName = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday",
+ "Friday", "Saturday" };
+ private static final String[] MonthNameAbbrev = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep",
+ "Oct", "Nov", "Dec" };
+ private static final String[] MonthName = { "January", "February", "March", "April", "May", "June", "July",
+ "August", "September", "October", "November", "December" };
private Calendar beginningOfYear(Calendar d) {
Calendar y0 = Calendar.getInstance();
@@ -359,42 +371,35 @@ public class OsLib extends TwoArgFunction {
y0.set(Calendar.MILLISECOND, 0);
return y0;
}
-
+
private int weekNumber(Calendar d, int startDay) {
- Calendar y0 = beginningOfYear(d);
- y0.set(Calendar.DAY_OF_MONTH, 1 + (startDay + 8 - y0.get(Calendar.DAY_OF_WEEK)) % 7);
+ Calendar y0 = beginningOfYear(d);
+ y0.set(Calendar.DAY_OF_MONTH, 1+(startDay+8-y0.get(Calendar.DAY_OF_WEEK))%7);
if (y0.after(d)) {
- y0.set(Calendar.YEAR, y0.get(Calendar.YEAR) - 1);
- y0.set(Calendar.DAY_OF_MONTH, 1 + (startDay + 8 - y0.get(Calendar.DAY_OF_WEEK)) % 7);
+ y0.set(Calendar.YEAR, y0.get(Calendar.YEAR)-1);
+ y0.set(Calendar.DAY_OF_MONTH, 1+(startDay+8-y0.get(Calendar.DAY_OF_WEEK))%7);
}
- long dt = d.getTime().getTime() - y0.getTime().getTime();
- return 1 + (int) (dt / (7L * 24L * 3600L * 1000L));
+ long dt = d.getTime().getTime()-y0.getTime().getTime();
+ return 1+(int) (dt/(7L*24L*3600L*1000L));
}
-
+
private int timeZoneOffset(Calendar d) {
- int localStandarTimeMillis = (
- d.get(Calendar.HOUR_OF_DAY) * 3600 +
- d.get(Calendar.MINUTE) * 60 +
- d.get(Calendar.SECOND)) * 1000;
- return d.getTimeZone().getOffset(
- 1,
- d.get(Calendar.YEAR),
- d.get(Calendar.MONTH),
- d.get(Calendar.DAY_OF_MONTH),
- d.get(Calendar.DAY_OF_WEEK),
- localStandarTimeMillis) / 1000;
+ int localStandarTimeMillis = (d.get(Calendar.HOUR_OF_DAY)*3600+d.get(Calendar.MINUTE)*60+d.get(Calendar.SECOND))
+ *1000;
+ return d.getTimeZone().getOffset(1, d.get(Calendar.YEAR), d.get(Calendar.MONTH), d.get(Calendar.DAY_OF_MONTH),
+ d.get(Calendar.DAY_OF_WEEK), localStandarTimeMillis)/1000;
}
-
+
private boolean isDaylightSavingsTime(Calendar d) {
- return timeZoneOffset(d) != d.getTimeZone().getRawOffset() / 1000;
+ return timeZoneOffset(d) != d.getTimeZone().getRawOffset()/1000;
}
-
+
/**
- * This function is equivalent to the C function system.
- * It passes command to be executed by an operating system shell.
- * It returns a status code, which is system-dependent.
- * If command is absent, then it returns nonzero if a shell
- * is available and zero otherwise.
+ * This function is equivalent to the C function system. It passes command
+ * to be executed by an operating system shell. It returns a status code,
+ * which is system-dependent. If command is absent, then it returns nonzero
+ * if a shell is available and zero otherwise.
+ *
* @param command command to pass to the system
*/
protected Varargs execute(String command) {
@@ -402,7 +407,9 @@ public class OsLib extends TwoArgFunction {
}
/**
- * Calls the C function exit, with an optional code, to terminate the host program.
+ * Calls the C function exit, with an optional code, to terminate the host
+ * program.
+ *
* @param code
*/
protected void exit(int code) {
@@ -410,19 +417,19 @@ public class OsLib extends TwoArgFunction {
}
/**
- * Returns the value of the process environment variable varname,
- * or the System property value for varname,
- * or null if the variable is not defined in either environment.
+ * Returns the value of the process environment variable varname, or the
+ * System property value for varname, or null if the variable is not defined
+ * in either environment.
*
- * The default implementation, which is used by the JmePlatform,
- * only queryies System.getProperty().
+ * The default implementation, which is used by the JmePlatform, only
+ * queryies System.getProperty().
*
- * The JsePlatform overrides this behavior and returns the
- * environment variable value using System.getenv() if it exists,
- * or the System property value if it does not.
+ * The JsePlatform overrides this behavior and returns the environment
+ * variable value using System.getenv() if it exists, or the System property
+ * value if it does not.
+ *
+ * A SecurityException may be thrown if access is not allowed for 'varname'.
*
- * A SecurityException may be thrown if access is not allowed
- * for 'varname'.
* @param varname
* @return String value, or null if not defined
*/
@@ -431,57 +438,57 @@ public class OsLib extends TwoArgFunction {
}
/**
- * Deletes the file or directory with the given name.
- * Directories must be empty to be removed.
- * If this function fails, it throws and IOException
+ * Deletes the file or directory with the given name. Directories must be
+ * empty to be removed. If this function fails, it throws and IOException
*
* @param filename
* @throws IOException if it fails
*/
protected void remove(String filename) throws IOException {
- throw new IOException( "not implemented" );
+ throw new IOException("not implemented");
}
/**
- * Renames file or directory named oldname to newname.
- * If this function fails,it throws and IOException
+ * Renames file or directory named oldname to newname. If this function
+ * fails,it throws and IOException
*
* @param oldname old file name
* @param newname new file name
* @throws IOException if it fails
*/
protected void rename(String oldname, String newname) throws IOException {
- throw new IOException( "not implemented" );
+ throw new IOException("not implemented");
}
/**
- * Sets the current locale of the program. locale is a string specifying
- * a locale; category is an optional string describing which category to change:
- * "all", "collate", "ctype", "monetary", "numeric", or "time"; the default category
- * is "all".
+ * Sets the current locale of the program. locale is a string specifying a
+ * locale; category is an optional string describing which category to
+ * change: "all", "collate", "ctype", "monetary", "numeric", or "time"; the
+ * default category is "all".
*
- * If locale is the empty string, the current locale is set to an implementation-
- * defined native locale. If locale is the string "C", the current locale is set
- * to the standard C locale.
+ * If locale is the empty string, the current locale is set to an
+ * implementation- defined native locale. If locale is the string "C", the
+ * current locale is set to the standard C locale.
*
- * When called with null as the first argument, this function only returns the
- * name of the current locale for the given category.
+ * When called with null as the first argument, this function only returns
+ * the name of the current locale for the given category.
*
* @param locale
* @param category
- * @return the name of the new locale, or null if the request
- * cannot be honored.
+ * @return the name of the new locale, or null if the request cannot be
+ * honored.
*/
protected String setlocale(String locale, String category) {
return "C";
}
/**
- * Returns the current time when called without arguments,
- * or a time representing the date and time specified by the given table.
- * This table must have fields year, month, and day,
- * and may have fields hour, min, sec, and isdst
- * (for a description of these fields, see the os.date function).
+ * Returns the current time when called without arguments, or a time
+ * representing the date and time specified by the given table. This table
+ * must have fields year, month, and day, and may have fields hour, min,
+ * sec, and isdst (for a description of these fields, see the os.date
+ * function).
+ *
* @param table
* @return long value for the time
*/
@@ -500,7 +507,7 @@ public class OsLib extends TwoArgFunction {
c.set(Calendar.MILLISECOND, 0);
d = c.getTime();
}
- return d.getTime() / 1000.;
+ return d.getTime()/1000.;
}
/**
@@ -508,16 +515,16 @@ public class OsLib extends TwoArgFunction {
* The file must be explicitly opened before its use and explicitly removed
* when no longer needed.
*
- * On some systems (POSIX), this function also creates a file with that name,
- * to avoid security risks. (Someone else might create the file with wrong
- * permissions in the time between getting the name and creating the file.)
- * You still have to open the file to use it and to remove it (even if you
- * do not use it).
+ * On some systems (POSIX), this function also creates a file with that
+ * name, to avoid security risks. (Someone else might create the file with
+ * wrong permissions in the time between getting the name and creating the
+ * file.) You still have to open the file to use it and to remove it (even
+ * if you do not use it).
*
* @return String filename to use
*/
protected String tmpname() {
- synchronized ( OsLib.class ) {
+ synchronized (OsLib.class) {
return TMP_PREFIX+(tmpnames++)+TMP_SUFFIX;
}
}
diff --git a/luaj-core/src/main/java/org/luaj/vm2/lib/PackageLib.java b/luaj-core/src/main/java/org/luaj/vm2/lib/PackageLib.java
index 4c2147c9..e5450cf1 100644
--- a/luaj-core/src/main/java/org/luaj/vm2/lib/PackageLib.java
+++ b/luaj-core/src/main/java/org/luaj/vm2/lib/PackageLib.java
@@ -31,56 +31,73 @@ import org.luaj.vm2.LuaValue;
import org.luaj.vm2.Varargs;
/**
- * Subclass of {@link LibFunction} which implements the lua standard package and module
- * library functions.
+ * Subclass of {@link LibFunction} which implements the lua standard package and
+ * module library functions.
*
- *
- * To instantiate and use it directly,
- * link it into your globals table via {@link LuaValue#load(LuaValue)} using code such as:
- *
+ *
* @see LibFunction
* @see BaseLib
* @see org.luaj.vm2.lib.jse.JseBaseLib
* @see org.luaj.vm2.lib.jse.JsePlatform
* @see org.luaj.vm2.lib.jme.JmePlatform
- * @see Lua 5.2 Package Lib Reference
+ * @see Lua 5.2 Package
+ * Lib Reference
*/
public class PackageLib extends TwoArgFunction {
- /** The default value to use for package.path. This can be set with the system property
- *
- * This is used by required to load files that are part of
- * the application, and implemented by BaseLib
- * for both the Jme and Jse platforms.
+ * This is used by required to load files that are part of the application, and
+ * implemented by BaseLib for both the Jme and Jse platforms.
*
- * The Jme version of base lib {@link BaseLib}
- * implements {@link Globals#finder} via {@link Class#getResourceAsStream(String)},
- * while the Jse version {@link org.luaj.vm2.lib.jse.JseBaseLib} implements it using {@link java.io.File#File(String)}.
+ * The Jme version of base lib {@link BaseLib} implements {@link Globals#finder}
+ * via {@link Class#getResourceAsStream(String)}, while the Jse version
+ * {@link org.luaj.vm2.lib.jse.JseBaseLib} implements it using
+ * {@link java.io.File#File(String)}.
*
* The io library does not use this API for file manipulation.
*
+ *
* @see BaseLib
* @see Globals#finder
* @see org.luaj.vm2.lib.jse.JseBaseLib
* @see org.luaj.vm2.lib.jme.JmePlatform
- * @see org.luaj.vm2.lib.jse.JsePlatform
+ * @see org.luaj.vm2.lib.jse.JsePlatform
*/
public interface ResourceFinder {
-
- /**
+
+ /**
* Try to open a file, or return null if not found.
*
* @see org.luaj.vm2.lib.BaseLib
* @see org.luaj.vm2.lib.jse.JseBaseLib
*
* @param filename
- * @return InputStream, or null if not found.
+ * @return InputStream, or null if not found.
*/
- public InputStream findResource( String filename );
-}
\ No newline at end of file
+ public InputStream findResource(String filename);
+}
diff --git a/luaj-core/src/main/java/org/luaj/vm2/lib/StringLib.java b/luaj-core/src/main/java/org/luaj/vm2/lib/StringLib.java
index 8011459a..c49f741f 100644
--- a/luaj-core/src/main/java/org/luaj/vm2/lib/StringLib.java
+++ b/luaj-core/src/main/java/org/luaj/vm2/lib/StringLib.java
@@ -33,53 +33,70 @@ import org.luaj.vm2.Varargs;
import org.luaj.vm2.compiler.DumpState;
/**
- * Subclass of {@link LibFunction} which implements the lua standard {@code string}
- * library.
+ * Subclass of {@link LibFunction} which implements the lua standard
+ * {@code string} library.
*
* Typically, this library is included as part of a call to either
- * {@link org.luaj.vm2.lib.jse.JsePlatform#standardGlobals()} or {@link org.luaj.vm2.lib.jme.JmePlatform#standardGlobals()}
- *
- * To instantiate and use it directly,
- * link it into your globals table via {@link LuaValue#load(LuaValue)} using code such as:
- *
* This is a direct port of the corresponding library in C.
+ *
* @see LibFunction
* @see org.luaj.vm2.lib.jse.JsePlatform
* @see org.luaj.vm2.lib.jme.JmePlatform
- * @see Lua 5.2 String Lib Reference
+ * @see Lua 5.2 String
+ * Lib Reference
*/
public class StringLib extends TwoArgFunction {
- /** Construct a StringLib, which can be initialized by calling it with a
+ /**
+ * Construct a StringLib, which can be initialized by calling it with a
* modname string, and a global environment table as arguments using
- * {@link #call(LuaValue, LuaValue)}. */
+ * {@link #call(LuaValue, LuaValue)}.
+ */
public StringLib() {
}
- /** Perform one-time initialization on the library by creating a table
- * containing the library functions, adding that table to the supplied environment,
- * adding the table to package.loaded, and returning table as the return value.
- * Creates a metatable that uses __INDEX to fall back on itself to support string
- * method operations.
- * If the shared strings metatable instance is null, will set the metatable as
- * the global shared metatable for strings.
+ /**
+ * Perform one-time initialization on the library by creating a table
+ * containing the library functions, adding that table to the supplied
+ * environment, adding the table to package.loaded, and returning table as
+ * the return value. Creates a metatable that uses __INDEX to fall back on
+ * itself to support string method operations. If the shared strings
+ * metatable instance is null, will set the metatable as the global shared
+ * metatable for strings.
*
- * All tables and metatables are read-write by default so if this will be used in
- * a server environment, sandboxing should be used. In particular, the
- * {@link LuaString#s_metatable} table should probably be made read-only.
+ * All tables and metatables are read-write by default so if this will be
+ * used in a server environment, sandboxing should be used. In particular,
+ * the {@link LuaString#s_metatable} table should probably be made
+ * read-only.
+ *
* @param modname the module name supplied if this is loaded via 'require'.
- * @param env the environment to load into, typically a Globals instance.
+ * @param env the environment to load into, typically a Globals
+ * instance.
*/
public LuaValue call(LuaValue modname, LuaValue env) {
LuaTable string = new LuaTable();
@@ -97,21 +114,21 @@ public class StringLib extends TwoArgFunction {
string.set("reverse", new reverse());
string.set("sub", new sub());
string.set("upper", new upper());
-
+
env.set("string", string);
- if (!env.get("package").isnil()) env.get("package").get("loaded").set("string", string);
+ if (!env.get("package").isnil())
+ env.get("package").get("loaded").set("string", string);
if (LuaString.s_metatable == null) {
LuaString.s_metatable = LuaValue.tableOf(new LuaValue[] { INDEX, string });
}
return string;
}
-
+
/**
* string.byte (s [, i [, j]])
*
- * Returns the internal numerical codes of the
- * characters s[i], s[i+1], ..., s[j]. The default value for i is 1; the
- * default value for j is i.
+ * Returns the internal numerical codes of the characters s[i], s[i+1], ...,
+ * s[j]. The default value for i is 1; the default value for j is i.
*
* Note that numerical codes are not necessarily portable across platforms.
*
@@ -121,17 +138,20 @@ public class StringLib extends TwoArgFunction {
public Varargs invoke(Varargs args) {
LuaString s = args.checkstring(1);
int l = s.m_length;
- int posi = posrelat( args.optint(2,1), l );
- int pose = posrelat( args.optint(3,posi), l );
- int n,i;
- if (posi <= 0) posi = 1;
- if (pose > l) pose = l;
- if (posi > pose) return NONE; /* empty interval; return no values */
- n = (int)(pose - posi + 1);
- if (posi + n <= pose) /* overflow? */
- error("string slice too long");
+ int posi = posrelat(args.optint(2, 1), l);
+ int pose = posrelat(args.optint(3, posi), l);
+ int n, i;
+ if (posi <= 0)
+ posi = 1;
+ if (pose > l)
+ pose = l;
+ if (posi > pose)
+ return NONE; /* empty interval; return no values */
+ n = (int) (pose-posi+1);
+ if (posi+n <= pose) /* overflow? */
+ error("string slice too long");
LuaValue[] v = new LuaValue[n];
- for (i=0; i
* Typically, this library is included as part of a call to either
- * {@link org.luaj.vm2.lib.jse.JsePlatform#standardGlobals()} or {@link org.luaj.vm2.lib.jme.JmePlatform#standardGlobals()}
- *
- * To instantiate and use it directly,
- * link it into your globals table via {@link LuaValue#load(LuaValue)} using code such as:
- *
- * This has been implemented to match as closely as possible the behavior in the corresponding library in C.
+ * This has been implemented to match as closely as possible the behavior in the
+ * corresponding library in C.
+ *
* @see LibFunction
* @see org.luaj.vm2.lib.jse.JsePlatform
* @see org.luaj.vm2.lib.jme.JmePlatform
- * @see Lua 5.2 Table Lib Reference
+ * @see Lua 5.2 Table
+ * Lib Reference
*/
public class TableLib extends TwoArgFunction {
- /** Perform one-time initialization on the library by creating a table
- * containing the library functions, adding that table to the supplied environment,
- * adding the table to package.loaded, and returning table as the return value.
+ /**
+ * Perform one-time initialization on the library by creating a table
+ * containing the library functions, adding that table to the supplied
+ * environment, adding the table to package.loaded, and returning table as
+ * the return value.
+ *
* @param modname the module name supplied if this is loaded via 'require'.
- * @param env the environment to load into, typically a Globals instance.
+ * @param env the environment to load into, typically a Globals
+ * instance.
*/
public LuaValue call(LuaValue modname, LuaValue env) {
LuaTable table = new LuaTable();
@@ -70,23 +86,27 @@ public class TableLib extends TwoArgFunction {
table.set("sort", new sort());
table.set("unpack", new unpack());
env.set("table", table);
- if (!env.get("package").isnil()) env.get("package").get("loaded").set("table", table);
+ if (!env.get("package").isnil())
+ env.get("package").get("loaded").set("table", table);
return NIL;
}
-
+
// "concat" (table [, sep [, i [, j]]]) -> string
static class concat extends TableLibFunction {
public LuaValue call(LuaValue list) {
- return list.checktable().concat(EMPTYSTRING,1,list.length());
+ return list.checktable().concat(EMPTYSTRING, 1, list.length());
}
+
public LuaValue call(LuaValue list, LuaValue sep) {
- return list.checktable().concat(sep.checkstring(),1,list.length());
+ return list.checktable().concat(sep.checkstring(), 1, list.length());
}
+
public LuaValue call(LuaValue list, LuaValue sep, LuaValue i) {
- return list.checktable().concat(sep.checkstring(),i.checkint(),list.length());
+ return list.checktable().concat(sep.checkstring(), i.checkint(), list.length());
}
+
public LuaValue call(LuaValue list, LuaValue sep, LuaValue i, LuaValue j) {
- return list.checktable().concat(sep.checkstring(),i.checkint(),j.checkint());
+ return list.checktable().concat(sep.checkstring(), i.checkint(), j.checkint());
}
}
@@ -96,14 +116,15 @@ public class TableLib extends TwoArgFunction {
switch (args.narg()) {
case 2: {
LuaTable table = args.checktable(1);
- table.insert(table.length()+1,args.arg(2));
+ table.insert(table.length()+1, args.arg(2));
return NONE;
}
case 3: {
LuaTable table = args.checktable(1);
int pos = args.checkint(2);
- int max = table.length() + 1;
- if (pos < 1 || pos > max) argerror(2, "position out of bounds: " + pos + " not between 1 and " + max);
+ int max = table.length()+1;
+ if (pos < 1 || pos > max)
+ argerror(2, "position out of bounds: " + pos + " not between 1 and " + max);
table.insert(pos, args.arg(3));
return NONE;
}
@@ -113,7 +134,7 @@ public class TableLib extends TwoArgFunction {
}
}
}
-
+
// "pack" (...) -> table
static class pack extends VarArgFunction {
public Varargs invoke(Varargs args) {
@@ -129,8 +150,8 @@ public class TableLib extends TwoArgFunction {
LuaTable table = args.checktable(1);
int size = table.length();
int pos = args.optint(2, size);
- if (pos != size && (pos < 1 || pos > size + 1)) {
- argerror(2, "position out of bounds: " + pos + " not between 1 and " + (size + 1));
+ if (pos != size && (pos < 1 || pos > size+1)) {
+ argerror(2, "position out of bounds: " + pos + " not between 1 and " + (size+1));
}
return table.remove(pos);
}
@@ -139,19 +160,17 @@ public class TableLib extends TwoArgFunction {
// "sort" (table [, comp])
static class sort extends VarArgFunction {
public Varargs invoke(Varargs args) {
- args.checktable(1).sort(
- args.isnil(2)? NIL: args.checkfunction(2));
+ args.checktable(1).sort(args.isnil(2)? NIL: args.checkfunction(2));
return NONE;
}
}
-
// "unpack", // (list [,i [,j]]) -> result1, ...
static class unpack extends VarArgFunction {
public Varargs invoke(Varargs args) {
LuaTable t = args.checktable(1);
// do not waste resource for calc rawlen if arg3 is not nil
- int len = args.arg(3).isnil() ? t.length() : 0;
+ int len = args.arg(3).isnil()? t.length(): 0;
return t.unpack(args.optint(2, 1), args.optint(3, len));
}
}
diff --git a/luaj-core/src/main/java/org/luaj/vm2/lib/ThreeArgFunction.java b/luaj-core/src/main/java/org/luaj/vm2/lib/ThreeArgFunction.java
index 68ceb243..dcb72db8 100644
--- a/luaj-core/src/main/java/org/luaj/vm2/lib/ThreeArgFunction.java
+++ b/luaj-core/src/main/java/org/luaj/vm2/lib/ThreeArgFunction.java
@@ -24,21 +24,24 @@ package org.luaj.vm2.lib;
import org.luaj.vm2.LuaValue;
import org.luaj.vm2.Varargs;
-/** Abstract base class for Java function implementations that take two arguments and
- * return one value.
+/**
+ * Abstract base class for Java function implementations that take two arguments
+ * and return one value.
*
- * Subclasses need only implement {@link LuaValue#call(LuaValue,LuaValue,LuaValue)} to complete this class,
- * simplifying development.
- * All other uses of {@link #call()}, {@link #invoke(Varargs)},etc,
- * are routed through this method by this class,
+ * Subclasses need only implement
+ * {@link LuaValue#call(LuaValue,LuaValue,LuaValue)} to complete this class,
+ * simplifying development. All other uses of {@link #call()},
+ * {@link #invoke(Varargs)},etc, are routed through this method by this class,
* dropping or extending arguments with {@code nil} values as required.
*
- * If more or less than three arguments are required,
- * or variable argument or variable return values,
- * then use one of the related function
- * {@link ZeroArgFunction}, {@link OneArgFunction}, {@link TwoArgFunction}, or {@link VarArgFunction}.
+ * If more or less than three arguments are required, or variable argument or
+ * variable return values, then use one of the related function
+ * {@link ZeroArgFunction}, {@link OneArgFunction}, {@link TwoArgFunction}, or
+ * {@link VarArgFunction}.
*
- * See {@link LibFunction} for more information on implementation libraries and library functions.
+ * See {@link LibFunction} for more information on implementation libraries and
+ * library functions.
+ *
* @see #call(LuaValue,LuaValue,LuaValue)
* @see LibFunction
* @see ZeroArgFunction
@@ -49,11 +52,11 @@ import org.luaj.vm2.Varargs;
abstract public class ThreeArgFunction extends LibFunction {
abstract public LuaValue call(LuaValue arg1, LuaValue arg2, LuaValue arg3);
-
+
/** Default constructor */
public ThreeArgFunction() {
}
-
+
public final LuaValue call() {
return call(NIL, NIL, NIL);
}
@@ -65,9 +68,9 @@ abstract public class ThreeArgFunction extends LibFunction {
public LuaValue call(LuaValue arg1, LuaValue arg2) {
return call(arg1, arg2, NIL);
}
-
+
public Varargs invoke(Varargs varargs) {
- return call(varargs.arg1(),varargs.arg(2),varargs.arg(3));
+ return call(varargs.arg1(), varargs.arg(2), varargs.arg(3));
}
-
-}
+
+}
diff --git a/luaj-core/src/main/java/org/luaj/vm2/lib/TwoArgFunction.java b/luaj-core/src/main/java/org/luaj/vm2/lib/TwoArgFunction.java
index 8a97f6fb..7309946b 100644
--- a/luaj-core/src/main/java/org/luaj/vm2/lib/TwoArgFunction.java
+++ b/luaj-core/src/main/java/org/luaj/vm2/lib/TwoArgFunction.java
@@ -24,21 +24,24 @@ package org.luaj.vm2.lib;
import org.luaj.vm2.LuaValue;
import org.luaj.vm2.Varargs;
-/** Abstract base class for Java function implementations that take two arguments and
- * return one value.
+/**
+ * Abstract base class for Java function implementations that take two arguments
+ * and return one value.
*
- * Subclasses need only implement {@link LuaValue#call(LuaValue,LuaValue)} to complete this class,
- * simplifying development.
- * All other uses of {@link #call()}, {@link #invoke(Varargs)},etc,
- * are routed through this method by this class,
- * dropping or extending arguments with {@code nil} values as required.
+ * Subclasses need only implement {@link LuaValue#call(LuaValue,LuaValue)} to
+ * complete this class, simplifying development. All other uses of
+ * {@link #call()}, {@link #invoke(Varargs)},etc, are routed through this method
+ * by this class, dropping or extending arguments with {@code nil} values as
+ * required.
*
- * If more or less than two arguments are required,
- * or variable argument or variable return values,
- * then use one of the related function
- * {@link ZeroArgFunction}, {@link OneArgFunction}, {@link ThreeArgFunction}, or {@link VarArgFunction}.
+ * If more or less than two arguments are required, or variable argument or
+ * variable return values, then use one of the related function
+ * {@link ZeroArgFunction}, {@link OneArgFunction}, {@link ThreeArgFunction}, or
+ * {@link VarArgFunction}.
*
- * See {@link LibFunction} for more information on implementation libraries and library functions.
+ * See {@link LibFunction} for more information on implementation libraries and
+ * library functions.
+ *
* @see #call(LuaValue,LuaValue)
* @see LibFunction
* @see ZeroArgFunction
@@ -49,11 +52,11 @@ import org.luaj.vm2.Varargs;
abstract public class TwoArgFunction extends LibFunction {
abstract public LuaValue call(LuaValue arg1, LuaValue arg2);
-
+
/** Default constructor */
public TwoArgFunction() {
}
-
+
public final LuaValue call() {
return call(NIL, NIL);
}
@@ -65,9 +68,9 @@ abstract public class TwoArgFunction extends LibFunction {
public LuaValue call(LuaValue arg1, LuaValue arg2, LuaValue arg3) {
return call(arg1, arg2);
}
-
+
public Varargs invoke(Varargs varargs) {
- return call(varargs.arg1(),varargs.arg(2));
+ return call(varargs.arg1(), varargs.arg(2));
}
-
-}
+
+}
diff --git a/luaj-core/src/main/java/org/luaj/vm2/lib/VarArgFunction.java b/luaj-core/src/main/java/org/luaj/vm2/lib/VarArgFunction.java
index 8e2bd614..8fc7a743 100644
--- a/luaj-core/src/main/java/org/luaj/vm2/lib/VarArgFunction.java
+++ b/luaj-core/src/main/java/org/luaj/vm2/lib/VarArgFunction.java
@@ -24,20 +24,23 @@ package org.luaj.vm2.lib;
import org.luaj.vm2.LuaValue;
import org.luaj.vm2.Varargs;
-/** Abstract base class for Java function implementations that takes varaiable arguments and
- * returns multiple return values.
+/**
+ * Abstract base class for Java function implementations that takes varaiable
+ * arguments and returns multiple return values.
*
- * Subclasses need only implement {@link LuaValue#invoke(Varargs)} to complete this class,
- * simplifying development.
- * All other uses of {@link #call(LuaValue)}, {@link #invoke()},etc,
- * are routed through this method by this class,
- * converting arguments to {@link Varargs} and
- * dropping or extending return values with {@code nil} values as required.
+ * Subclasses need only implement {@link LuaValue#invoke(Varargs)} to complete
+ * this class, simplifying development. All other uses of
+ * {@link #call(LuaValue)}, {@link #invoke()},etc, are routed through this
+ * method by this class, converting arguments to {@link Varargs} and dropping or
+ * extending return values with {@code nil} values as required.
*
- * If between one and three arguments are required, and only one return value is returned,
- * {@link ZeroArgFunction}, {@link OneArgFunction}, {@link TwoArgFunction}, or {@link ThreeArgFunction}.
+ * If between one and three arguments are required, and only one return value is
+ * returned, {@link ZeroArgFunction}, {@link OneArgFunction},
+ * {@link TwoArgFunction}, or {@link ThreeArgFunction}.
*
- * See {@link LibFunction} for more information on implementation libraries and library functions.
+ * See {@link LibFunction} for more information on implementation libraries and
+ * library functions.
+ *
* @see #invoke(Varargs)
* @see LibFunction
* @see ZeroArgFunction
@@ -49,7 +52,7 @@ abstract public class VarArgFunction extends LibFunction {
public VarArgFunction() {
}
-
+
public LuaValue call() {
return invoke(NONE).arg1();
}
@@ -59,25 +62,25 @@ abstract public class VarArgFunction extends LibFunction {
}
public LuaValue call(LuaValue arg1, LuaValue arg2) {
- return invoke(varargsOf(arg1,arg2)).arg1();
+ return invoke(varargsOf(arg1, arg2)).arg1();
}
public LuaValue call(LuaValue arg1, LuaValue arg2, LuaValue arg3) {
- return invoke(varargsOf(arg1,arg2,arg3)).arg1();
+ return invoke(varargsOf(arg1, arg2, arg3)).arg1();
}
- /**
- * Subclass responsibility.
- * May not have expected behavior for tail calls.
- * Should not be used if:
- * - function has a possibility of returning a TailcallVarargs
+ /**
+ * Subclass responsibility. May not have expected behavior for tail calls.
+ * Should not be used if: - function has a possibility of returning a
+ * TailcallVarargs
+ *
* @param args the arguments to the function call.
*/
public Varargs invoke(Varargs args) {
return onInvoke(args).eval();
}
-
+
public Varargs onInvoke(Varargs args) {
return invoke(args);
}
-}
+}
diff --git a/luaj-core/src/main/java/org/luaj/vm2/lib/ZeroArgFunction.java b/luaj-core/src/main/java/org/luaj/vm2/lib/ZeroArgFunction.java
index 06169d74..d40f4f6e 100644
--- a/luaj-core/src/main/java/org/luaj/vm2/lib/ZeroArgFunction.java
+++ b/luaj-core/src/main/java/org/luaj/vm2/lib/ZeroArgFunction.java
@@ -24,19 +24,21 @@ package org.luaj.vm2.lib;
import org.luaj.vm2.LuaValue;
import org.luaj.vm2.Varargs;
-/** Abstract base class for Java function implementations that take no arguments and
- * return one value.
+/**
+ * Abstract base class for Java function implementations that take no arguments
+ * and return one value.
*
- * Subclasses need only implement {@link LuaValue#call()} to complete this class,
- * simplifying development.
- * All other uses of {@link #call(LuaValue)}, {@link #invoke(Varargs)},etc,
- * are routed through this method by this class.
+ * Subclasses need only implement {@link LuaValue#call()} to complete this
+ * class, simplifying development. All other uses of {@link #call(LuaValue)},
+ * {@link #invoke(Varargs)},etc, are routed through this method by this class.
*
- * If one or more arguments are required, or variable argument or variable return values,
- * then use one of the related function
- * {@link OneArgFunction}, {@link TwoArgFunction}, {@link ThreeArgFunction}, or {@link VarArgFunction}.
+ * If one or more arguments are required, or variable argument or variable
+ * return values, then use one of the related function {@link OneArgFunction},
+ * {@link TwoArgFunction}, {@link ThreeArgFunction}, or {@link VarArgFunction}.
*
- * See {@link LibFunction} for more information on implementation libraries and library functions.
+ * See {@link LibFunction} for more information on implementation libraries and
+ * library functions.
+ *
* @see #call()
* @see LibFunction
* @see OneArgFunction
@@ -51,7 +53,7 @@ abstract public class ZeroArgFunction extends LibFunction {
/** Default constructor */
public ZeroArgFunction() {
}
-
+
public LuaValue call(LuaValue arg) {
return call();
}
@@ -67,4 +69,4 @@ abstract public class ZeroArgFunction extends LibFunction {
public Varargs invoke(Varargs varargs) {
return call();
}
-}
+}
diff --git a/luaj-jme/src/main/java/org/luaj/vm2/lib/jme/JmeIoLib.java b/luaj-jme/src/main/java/org/luaj/vm2/lib/jme/JmeIoLib.java
index e7cbd3c1..c0b41e8a 100644
--- a/luaj-jme/src/main/java/org/luaj/vm2/lib/jme/JmeIoLib.java
+++ b/luaj-jme/src/main/java/org/luaj/vm2/lib/jme/JmeIoLib.java
@@ -34,61 +34,74 @@ import org.luaj.vm2.LuaValue;
import org.luaj.vm2.lib.IoLib;
import org.luaj.vm2.lib.LibFunction;
-/**
- * Subclass of {@link IoLib} and therefore {@link LibFunction} which implements the lua standard {@code io}
- * library for the JSE platform.
- *
- * The implementation of the is based on CLDC 1.0 and StreamConnection.
- * However, seek is not supported.
+/**
+ * Subclass of {@link IoLib} and therefore {@link LibFunction} which implements
+ * the lua standard {@code io} library for the JSE platform.
*
- * Typically, this library is included as part of a call to
+ * The implementation of the is based on CLDC 1.0 and StreamConnection. However,
+ * seek is not supported.
+ *
+ * Typically, this library is included as part of a call to
* {@link org.luaj.vm2.lib.jme.JmePlatform#standardGlobals()}
- *
- * For special cases where the smallest possible footprint is desired,
- * a minimal set of libraries could be loaded
- * directly via {@link Globals#load(LuaValue)} using code such as:
- * However, other libraries such as MathLib are not loaded in this case.
+ * For special cases where the smallest possible footprint is desired, a minimal
+ * set of libraries could be loaded directly via {@link Globals#load(LuaValue)}
+ * using code such as:
+ *
+ *
- * This has been implemented to match as closely as possible the behavior in the corresponding library in C.
+ * However, other libraries such as MathLib are not loaded in this
+ * case.
+ *
+ * This has been implemented to match as closely as possible the behavior in the
+ * corresponding library in C.
+ *
* @see LibFunction
* @see org.luaj.vm2.lib.jse.JsePlatform
* @see org.luaj.vm2.lib.jme.JmePlatform
* @see IoLib
* @see org.luaj.vm2.lib.jse.JseIoLib
- * @see Lua 5.2 I/O Lib Reference
+ * @see Lua 5.2 I/O Lib
+ * Reference
*/
public class JmeIoLib extends IoLib {
-
+
protected File wrapStdin() throws IOException {
return new FileImpl(globals.STDIN);
}
-
+
protected File wrapStdout() throws IOException {
return new FileImpl(globals.STDOUT);
}
-
+
protected File wrapStderr() throws IOException {
return new FileImpl(globals.STDERR);
}
-
- protected File openFile( String filename, boolean readMode, boolean appendMode, boolean updateMode, boolean binaryMode ) throws IOException {
+
+ protected File openFile(String filename, boolean readMode, boolean appendMode, boolean updateMode,
+ boolean binaryMode) throws IOException {
String url = "file:///" + filename;
- int mode = readMode? Connector.READ: Connector.READ_WRITE;
- StreamConnection conn = (StreamConnection) Connector.open( url, mode );
- File f = readMode?
- new FileImpl(conn, conn.openInputStream(), null):
- new FileImpl(conn, conn.openInputStream(), conn.openOutputStream());
+ int mode = readMode? Connector.READ: Connector.READ_WRITE;
+ StreamConnection conn = (StreamConnection) Connector.open(url, mode);
+ File f = readMode? new FileImpl(conn, conn.openInputStream(), null)
+ : new FileImpl(conn, conn.openInputStream(), conn.openOutputStream());
/*
if ( appendMode ) {
f.seek("end",0);
@@ -99,11 +112,11 @@ public class JmeIoLib extends IoLib {
*/
return f;
}
-
+
private static void notimplemented() throws IOException {
throw new IOException("not implemented");
}
-
+
protected File openProgram(String prog, String mode) throws IOException {
notimplemented();
return null;
@@ -113,52 +126,62 @@ public class JmeIoLib extends IoLib {
notimplemented();
return null;
}
-
+
private final class FileImpl extends File {
private final StreamConnection conn;
- private final InputStream is;
- private final OutputStream os;
- private boolean closed = false;
- private boolean nobuffer = false;
- private int lookahead = -1;
- private FileImpl( StreamConnection conn, InputStream is, OutputStream os ) {
+ private final InputStream is;
+ private final OutputStream os;
+ private boolean closed = false;
+ private boolean nobuffer = false;
+ private int lookahead = -1;
+
+ private FileImpl(StreamConnection conn, InputStream is, OutputStream os) {
this.conn = conn;
this.is = is;
this.os = os;
}
- private FileImpl( InputStream i ) {
- this( null, i, null );
+
+ private FileImpl(InputStream i) {
+ this(null, i, null);
}
- private FileImpl( OutputStream o ) {
- this( null, null, o );
+
+ private FileImpl(OutputStream o) {
+ this(null, null, o);
}
+
public String tojstring() {
- return "file ("+this.hashCode()+")";
+ return "file (" + this.hashCode() + ")";
}
+
public boolean isstdfile() {
return conn == null;
}
- public void close() throws IOException {
+
+ public void close() throws IOException {
closed = true;
- if ( conn != null ) {
+ if (conn != null) {
conn.close();
}
}
+
public void flush() throws IOException {
- if ( os != null )
+ if (os != null)
os.flush();
}
+
public void write(LuaString s) throws IOException {
- if ( os != null )
- os.write( s.m_bytes, s.m_offset, s.m_length );
+ if (os != null)
+ os.write(s.m_bytes, s.m_offset, s.m_length);
else
notimplemented();
- if ( nobuffer )
+ if (nobuffer)
flush();
}
+
public boolean isclosed() {
return closed;
}
+
public int seek(String option, int pos) throws IOException {
/*
if ( conn != null ) {
@@ -177,6 +200,7 @@ public class JmeIoLib extends IoLib {
notimplemented();
return 0;
}
+
public void setvbuf(String mode, int size) {
nobuffer = "no".equals(mode);
}
@@ -185,22 +209,22 @@ public class JmeIoLib extends IoLib {
public int remaining() throws IOException {
return -1;
}
-
+
// peek ahead one character
public int peek() throws IOException {
- if ( lookahead < 0 )
+ if (lookahead < 0)
lookahead = is.read();
return lookahead;
- }
-
+ }
+
// return char if read, -1 if eof, throw IOException on other exception
public int read() throws IOException {
- if ( lookahead >= 0 ) {
+ if (lookahead >= 0) {
int c = lookahead;
lookahead = -1;
return c;
}
- if ( is != null )
+ if (is != null)
return is.read();
notimplemented();
return 0;
@@ -208,17 +232,17 @@ public class JmeIoLib extends IoLib {
// return number of bytes read if positive, -1 if eof, throws IOException
public int read(byte[] bytes, int offset, int length) throws IOException {
- int n,i=0;
- if (is!=null) {
- if ( length > 0 && lookahead >= 0 ) {
+ int n, i = 0;
+ if (is != null) {
+ if (length > 0 && lookahead >= 0) {
bytes[offset] = (byte) lookahead;
lookahead = -1;
i += 1;
}
- for ( ; i
- * The JME platform, being limited, cannot implement all libraries in all aspects. The main limitations are
+ * The JME platform, being limited, cannot implement all libraries in all
+ * aspects. The main limitations are
*
- * It is used to allocate either a set of standard globals using
+ * It is used to allocate either a set of standard globals using
* {@link #standardGlobals()} or debug globals using {@link #debugGlobals()}
*
* A simple example of initializing globals and using them from Java is:
- *
* Once globals are created, a simple way to load and run a script is:
- *
- * although {@code require} could also be used:
- *
- * The standard globals will contain all standard libraries in their JME flavors:
+ * The standard globals will contain all standard libraries in their JME
+ * flavors:
*
- * The debug globals are simply the standard globals plus the {@code debug} library {@link DebugLib}.
+ * In addition, the {@link LuaC} compiler is installed so lua files may be
+ * loaded in their source form.
+ *
+ * The debug globals are simply the standard globals plus the {@code debug}
+ * library {@link DebugLib}.
*
*
- * The class ensures that initialization is done in the correct order.
+ * The class ensures that initialization is done in the correct order.
*
* @see Globals
* @see org.luaj.vm2.lib.jse.JsePlatform
@@ -116,12 +138,14 @@ public class JmePlatform {
globals.load(new JmeIoLib());
LoadState.install(globals);
LuaC.install(globals);
- return globals;
+ return globals;
}
-
- /** Create standard globals including the {@link DebugLib} library.
+
+ /**
+ * Create standard globals including the {@link DebugLib} library.
*
- * @return Table of globals initialized with the standard JSE and debug libraries
+ * @return Table of globals initialized with the standard JSE and debug
+ * libraries
* @see #standardGlobals()
* @see org.luaj.vm2.lib.jse.JsePlatform
* @see org.luaj.vm2.lib.jme.JmePlatform
diff --git a/luaj-jse/src/main/java/lua.java b/luaj-jse/src/main/java/lua.java
index 39e488f2..073bdf07 100644
--- a/luaj-jse/src/main/java/lua.java
+++ b/luaj-jse/src/main/java/lua.java
@@ -1,3 +1,4 @@
+
/*******************************************************************************
* Copyright (c) 2009-2012 Luaj.org. All rights reserved.
*
@@ -38,37 +39,30 @@ import org.luaj.vm2.Varargs;
import org.luaj.vm2.lib.jse.JsePlatform;
import org.luaj.vm2.luajc.LuaJC;
-
/**
* lua command for use in JSE environments.
*/
public class lua {
private static final String version = Lua._VERSION + " Copyright (c) 2012 Luaj.org.org";
- private static final String usage =
- "usage: java -cp luaj-jse.jar lua [options] [script [args]].\n" +
- "Available options are:\n" +
- " -e stat execute string 'stat'\n" +
- " -l name require library 'name'\n" +
- " -i enter interactive mode after executing 'script'\n" +
- " -v show version information\n" +
- " -b use luajc bytecode-to-bytecode compiler (requires bcel on class path)\n" +
- " -n nodebug - do not load debug library by default\n" +
- " -p print the prototype\n" +
- " -c enc use the supplied encoding 'enc' for input files\n" +
- " -- stop handling options\n" +
- " - execute stdin and stop handling options";
+ private static final String usage = "usage: java -cp luaj-jse.jar lua [options] [script [args]].\n"
+ + "Available options are:\n" + " -e stat execute string 'stat'\n" + " -l name require library 'name'\n"
+ + " -i enter interactive mode after executing 'script'\n" + " -v show version information\n"
+ + " -b use luajc bytecode-to-bytecode compiler (requires bcel on class path)\n"
+ + " -n nodebug - do not load debug library by default\n" + " -p print the prototype\n"
+ + " -c enc use the supplied encoding 'enc' for input files\n" + " -- stop handling options\n"
+ + " - execute stdin and stop handling options";
private static void usageExit() {
System.out.println(usage);
- System.exit(-1);
+ System.exit(-1);
}
private static Globals globals;
- private static boolean print = false;
- private static String encoding = null;
-
- public static void main( String[] args ) throws IOException {
+ private static boolean print = false;
+ private static String encoding = null;
+
+ public static void main(String[] args) throws IOException {
// process args
boolean interactive = (args.length == 0);
@@ -79,17 +73,17 @@ public class lua {
Vector libs = null;
try {
// stateful argument processing
- for ( int i=0; i
- * To coerce scalar types, the various, generally the {@code valueOf(type)} methods
- * on {@link LuaValue} may be used:
+ * To coerce scalar types, the various, generally the {@code valueOf(type)}
+ * methods on {@link LuaValue} may be used:
*
- * To coerce arrays of objects and lists, the {@code listOf(..)} and {@code tableOf(...)} methods
- * on {@link LuaValue} may be used:
+ * To coerce arrays of objects and lists, the {@code listOf(..)} and
+ * {@code tableOf(...)} methods on {@link LuaValue} may be used:
*
- * Integral types {@code boolean}, {@code byte}, {@code char}, and {@code int}
- * will become {@link LuaInteger};
- * {@code long}, {@code float}, and {@code double} will become {@link LuaDouble};
- * {@code String} and {@code byte[]} will become {@link LuaString};
- * types inheriting from {@link LuaValue} will be returned without coercion;
- * other types will become {@link LuaUserdata}.
+ * Integral types {@code boolean}, {@code byte}, {@code char}, and
+ * {@code int} will become {@link LuaInteger}; {@code long}, {@code float},
+ * and {@code double} will become {@link LuaDouble}; {@code String} and
+ * {@code byte[]} will become {@link LuaString}; types inheriting from
+ * {@link LuaValue} will be returned without coercion; other types will
+ * become {@link LuaUserdata}.
+ *
* @param o Java object needing conversion
- * @return {@link LuaValue} corresponding to the supplied Java value.
+ * @return {@link LuaValue} corresponding to the supplied Java value.
* @see LuaValue
* @see LuaInteger
* @see LuaDouble
@@ -175,22 +175,20 @@ public class CoerceJavaToLua {
* @see LuaUserdata
*/
public static LuaValue coerce(Object o) {
- if ( o == null )
+ if (o == null)
return LuaValue.NIL;
Class clazz = o.getClass();
- Coercion c = (Coercion) COERCIONS.get( clazz );
- if ( c == null ) {
- c = clazz.isArray()? arrayCoercion:
- o instanceof LuaValue ? luaCoercion:
- instanceCoercion;
- COERCIONS.put( clazz, c );
+ Coercion c = (Coercion) COERCIONS.get(clazz);
+ if (c == null) {
+ c = clazz.isArray()? arrayCoercion: o instanceof LuaValue? luaCoercion: instanceCoercion;
+ COERCIONS.put(clazz, c);
}
return c.coerce(o);
}
static final Coercion instanceCoercion = new InstanceCoercion();
-
- static final Coercion arrayCoercion = new ArrayCoercion();
- static final Coercion luaCoercion = new LuaCoercion() ;
+ static final Coercion arrayCoercion = new ArrayCoercion();
+
+ static final Coercion luaCoercion = new LuaCoercion();
}
diff --git a/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/CoerceLuaToJava.java b/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/CoerceLuaToJava.java
index c658aacc..eb72abfc 100644
--- a/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/CoerceLuaToJava.java
+++ b/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/CoerceLuaToJava.java
@@ -31,13 +31,13 @@ import org.luaj.vm2.LuaTable;
import org.luaj.vm2.LuaValue;
/**
- * Helper class to coerce values from lua to Java within the luajava library.
+ * Helper class to coerce values from lua to Java within the luajava library.
*
- * This class is primarily used by the {@link org.luaj.vm2.lib.jse.LuajavaLib},
- * but can also be used directly when working with Java/lua bindings.
+ * This class is primarily used by the {@link org.luaj.vm2.lib.jse.LuajavaLib},
+ * but can also be used directly when working with Java/lua bindings.
*
- * To coerce to specific Java values, generally the {@code toType()} methods
- * on {@link LuaValue} may be used:
+ * To coerce to specific Java values, generally the {@code toType()} methods on
+ * {@link LuaValue} may be used:
*
- * For data in lua tables, the various methods on {@link LuaTable} can be used directly
- * to convert data to something more useful.
+ * For data in lua tables, the various methods on {@link LuaTable} can be used
+ * directly to convert data to something more useful.
*
* @see org.luaj.vm2.lib.jse.LuajavaLib
* @see CoerceJavaToLua
*/
public class CoerceLuaToJava {
- static int SCORE_NULL_VALUE = 0x10;
- static int SCORE_WRONG_TYPE = 0x100;
- static int SCORE_UNCOERCIBLE = 0x10000;
-
- static interface Coercion {
- public int score( LuaValue value );
- public Object coerce( LuaValue value );
+ static int SCORE_NULL_VALUE = 0x10;
+ static int SCORE_WRONG_TYPE = 0x100;
+ static int SCORE_UNCOERCIBLE = 0x10000;
+
+ static interface Coercion {
+ public int score(LuaValue value);
+
+ public Object coerce(LuaValue value);
};
- /**
+ /**
* Coerce a LuaValue value to a specified java class
+ *
* @param value LuaValue to coerce
* @param clazz Class to coerce into
- * @return Object of type clazz (or a subclass) with the corresponding value.
+ * @return Object of type clazz (or a subclass) with the corresponding
+ * value.
*/
public static Object coerce(LuaValue value, Class clazz) {
return getCoercion(clazz).coerce(value);
}
-
+
static final Map COERCIONS = Collections.synchronizedMap(new HashMap());
-
+
static final class BoolCoercion implements Coercion {
public String toString() {
return "BoolCoercion()";
}
- public int score( LuaValue value ) {
- switch ( value.type() ) {
+
+ public int score(LuaValue value) {
+ switch (value.type()) {
case LuaValue.TBOOLEAN:
return 0;
}
@@ -98,74 +102,84 @@ public class CoerceLuaToJava {
}
static final class NumericCoercion implements Coercion {
- static final int TARGET_TYPE_BYTE = 0;
- static final int TARGET_TYPE_CHAR = 1;
- static final int TARGET_TYPE_SHORT = 2;
- static final int TARGET_TYPE_INT = 3;
- static final int TARGET_TYPE_LONG = 4;
- static final int TARGET_TYPE_FLOAT = 5;
- static final int TARGET_TYPE_DOUBLE = 6;
- static final String[] TYPE_NAMES = { "byte", "char", "short", "int", "long", "float", "double" };
- final int targetType;
+ static final int TARGET_TYPE_BYTE = 0;
+ static final int TARGET_TYPE_CHAR = 1;
+ static final int TARGET_TYPE_SHORT = 2;
+ static final int TARGET_TYPE_INT = 3;
+ static final int TARGET_TYPE_LONG = 4;
+ static final int TARGET_TYPE_FLOAT = 5;
+ static final int TARGET_TYPE_DOUBLE = 6;
+ static final String[] TYPE_NAMES = { "byte", "char", "short", "int", "long", "float", "double" };
+ final int targetType;
+
public String toString() {
- return "NumericCoercion("+TYPE_NAMES[targetType]+")";
+ return "NumericCoercion(" + TYPE_NAMES[targetType] + ")";
}
+
NumericCoercion(int targetType) {
this.targetType = targetType;
}
- public int score( LuaValue value ) {
+
+ public int score(LuaValue value) {
int fromStringPenalty = 0;
- if ( value.type() == LuaValue.TSTRING ) {
+ if (value.type() == LuaValue.TSTRING) {
value = value.tonumber();
- if ( value.isnil() ) {
+ if (value.isnil()) {
return SCORE_UNCOERCIBLE;
}
fromStringPenalty = 4;
}
- if ( value.isint() ) {
- switch ( targetType ) {
+ if (value.isint()) {
+ switch (targetType) {
case TARGET_TYPE_BYTE: {
int i = value.toint();
- return fromStringPenalty + ((i==(byte)i)? 0: SCORE_WRONG_TYPE);
+ return fromStringPenalty+((i == (byte) i)? 0: SCORE_WRONG_TYPE);
}
case TARGET_TYPE_CHAR: {
int i = value.toint();
- return fromStringPenalty + ((i==(byte)i)? 1: (i==(char)i)? 0: SCORE_WRONG_TYPE);
+ return fromStringPenalty+((i == (byte) i)? 1: (i == (char) i)? 0: SCORE_WRONG_TYPE);
}
case TARGET_TYPE_SHORT: {
int i = value.toint();
- return fromStringPenalty +
- ((i==(byte)i)? 1: (i==(short)i)? 0: SCORE_WRONG_TYPE);
+ return fromStringPenalty+((i == (byte) i)? 1: (i == (short) i)? 0: SCORE_WRONG_TYPE);
}
- case TARGET_TYPE_INT: {
+ case TARGET_TYPE_INT: {
int i = value.toint();
- return fromStringPenalty +
- ((i==(byte)i)? 2: ((i==(char)i) || (i==(short)i))? 1: 0);
+ return fromStringPenalty+((i == (byte) i)? 2: ((i == (char) i) || (i == (short) i))? 1: 0);
}
- case TARGET_TYPE_FLOAT: return fromStringPenalty + 1;
- case TARGET_TYPE_LONG: return fromStringPenalty + 1;
- case TARGET_TYPE_DOUBLE: return fromStringPenalty + 2;
- default: return SCORE_WRONG_TYPE;
+ case TARGET_TYPE_FLOAT:
+ return fromStringPenalty+1;
+ case TARGET_TYPE_LONG:
+ return fromStringPenalty+1;
+ case TARGET_TYPE_DOUBLE:
+ return fromStringPenalty+2;
+ default:
+ return SCORE_WRONG_TYPE;
}
- } else if ( value.isnumber() ) {
- switch ( targetType ) {
- case TARGET_TYPE_BYTE: return SCORE_WRONG_TYPE;
- case TARGET_TYPE_CHAR: return SCORE_WRONG_TYPE;
- case TARGET_TYPE_SHORT: return SCORE_WRONG_TYPE;
- case TARGET_TYPE_INT: return SCORE_WRONG_TYPE;
+ } else if (value.isnumber()) {
+ switch (targetType) {
+ case TARGET_TYPE_BYTE:
+ return SCORE_WRONG_TYPE;
+ case TARGET_TYPE_CHAR:
+ return SCORE_WRONG_TYPE;
+ case TARGET_TYPE_SHORT:
+ return SCORE_WRONG_TYPE;
+ case TARGET_TYPE_INT:
+ return SCORE_WRONG_TYPE;
case TARGET_TYPE_LONG: {
double d = value.todouble();
- return fromStringPenalty + ((d==(long)d)? 0: SCORE_WRONG_TYPE);
+ return fromStringPenalty+((d == (long) d)? 0: SCORE_WRONG_TYPE);
}
case TARGET_TYPE_FLOAT: {
double d = value.todouble();
- return fromStringPenalty + ((d==(float)d)? 0: SCORE_WRONG_TYPE);
+ return fromStringPenalty+((d == (float) d)? 0: SCORE_WRONG_TYPE);
}
case TARGET_TYPE_DOUBLE: {
double d = value.todouble();
- return fromStringPenalty + (((d==(long)d) || (d==(float)d))? 1: 0);
+ return fromStringPenalty+(((d == (long) d) || (d == (float) d))? 1: 0);
}
- default: return SCORE_WRONG_TYPE;
+ default:
+ return SCORE_WRONG_TYPE;
}
} else {
return SCORE_UNCOERCIBLE;
@@ -173,45 +187,56 @@ public class CoerceLuaToJava {
}
public Object coerce(LuaValue value) {
- switch ( targetType ) {
- case TARGET_TYPE_BYTE: return new Byte( (byte) value.toint() );
- case TARGET_TYPE_CHAR: return new Character( (char) value.toint() );
- case TARGET_TYPE_SHORT: return new Short( (short) value.toint() );
- case TARGET_TYPE_INT: return new Integer( (int) value.toint() );
- case TARGET_TYPE_LONG: return new Long( (long) value.todouble() );
- case TARGET_TYPE_FLOAT: return new Float( (float) value.todouble() );
- case TARGET_TYPE_DOUBLE: return new Double( (double) value.todouble() );
- default: return null;
+ switch (targetType) {
+ case TARGET_TYPE_BYTE:
+ return new Byte((byte) value.toint());
+ case TARGET_TYPE_CHAR:
+ return new Character((char) value.toint());
+ case TARGET_TYPE_SHORT:
+ return new Short((short) value.toint());
+ case TARGET_TYPE_INT:
+ return new Integer((int) value.toint());
+ case TARGET_TYPE_LONG:
+ return new Long((long) value.todouble());
+ case TARGET_TYPE_FLOAT:
+ return new Float((float) value.todouble());
+ case TARGET_TYPE_DOUBLE:
+ return new Double((double) value.todouble());
+ default:
+ return null;
}
}
}
static final class StringCoercion implements Coercion {
public static final int TARGET_TYPE_STRING = 0;
- public static final int TARGET_TYPE_BYTES = 1;
- final int targetType;
+ public static final int TARGET_TYPE_BYTES = 1;
+ final int targetType;
+
public StringCoercion(int targetType) {
this.targetType = targetType;
}
+
public String toString() {
- return "StringCoercion("+(targetType==TARGET_TYPE_STRING? "String": "byte[]")+")";
+ return "StringCoercion(" + (targetType == TARGET_TYPE_STRING? "String": "byte[]") + ")";
}
+
public int score(LuaValue value) {
- switch ( value.type() ) {
+ switch (value.type()) {
case LuaValue.TSTRING:
- return value.checkstring().isValidUtf8()?
- (targetType==TARGET_TYPE_STRING? 0: 1):
- (targetType==TARGET_TYPE_BYTES? 0: SCORE_WRONG_TYPE);
+ return value.checkstring().isValidUtf8()? (targetType == TARGET_TYPE_STRING? 0: 1)
+ : (targetType == TARGET_TYPE_BYTES? 0: SCORE_WRONG_TYPE);
case LuaValue.TNIL:
return SCORE_NULL_VALUE;
default:
return targetType == TARGET_TYPE_STRING? SCORE_WRONG_TYPE: SCORE_UNCOERCIBLE;
}
}
+
public Object coerce(LuaValue value) {
- if ( value.isnil() )
+ if (value.isnil())
return null;
- if ( targetType == TARGET_TYPE_STRING )
+ if (targetType == TARGET_TYPE_STRING)
return value.tojstring();
LuaString s = value.checkstring();
byte[] b = new byte[s.m_length];
@@ -221,33 +246,37 @@ public class CoerceLuaToJava {
}
static final class ArrayCoercion implements Coercion {
- final Class componentType;
+ final Class componentType;
final Coercion componentCoercion;
+
public ArrayCoercion(Class componentType) {
this.componentType = componentType;
this.componentCoercion = getCoercion(componentType);
}
+
public String toString() {
- return "ArrayCoercion("+componentType.getName()+")";
+ return "ArrayCoercion(" + componentType.getName() + ")";
}
+
public int score(LuaValue value) {
- switch ( value.type() ) {
+ switch (value.type()) {
case LuaValue.TTABLE:
- return value.length()==0? 0: componentCoercion.score( value.get(1) );
+ return value.length() == 0? 0: componentCoercion.score(value.get(1));
case LuaValue.TUSERDATA:
- return inheritanceLevels( componentType, value.touserdata().getClass().getComponentType() );
+ return inheritanceLevels(componentType, value.touserdata().getClass().getComponentType());
case LuaValue.TNIL:
return SCORE_NULL_VALUE;
- default:
+ default:
return SCORE_UNCOERCIBLE;
}
}
+
public Object coerce(LuaValue value) {
- switch ( value.type() ) {
+ switch (value.type()) {
case LuaValue.TTABLE: {
int n = value.length();
Object a = Array.newInstance(componentType, n);
- for ( int i=0; i
- * This class is not used directly.
- * It is returned by calls to {@link CoerceJavaToLua#coerce(Object)}
- * when an array is supplied.
+ * This class is not used directly. It is returned by calls to
+ * {@link CoerceJavaToLua#coerce(Object)} when an array is supplied.
+ *
* @see CoerceJavaToLua
* @see CoerceLuaToJava
*/
@@ -43,44 +43,43 @@ class JavaArray extends LuaUserdata {
private static final class LenFunction extends OneArgFunction {
public LuaValue call(LuaValue u) {
- return LuaValue.valueOf(Array.getLength(((LuaUserdata)u).m_instance));
+ return LuaValue.valueOf(Array.getLength(((LuaUserdata) u).m_instance));
}
}
static final LuaValue LENGTH = valueOf("length");
-
+
static final LuaTable array_metatable;
static {
array_metatable = new LuaTable();
array_metatable.rawset(LuaValue.LEN, new LenFunction());
}
-
+
JavaArray(Object instance) {
super(instance);
setmetatable(array_metatable);
}
-
+
public LuaValue get(LuaValue key) {
- if ( key.equals(LENGTH) )
+ if (key.equals(LENGTH))
return valueOf(Array.getLength(m_instance));
- if ( key.isint() ) {
- int i = key.toint() - 1;
- return i>=0 && i
- * Will respond to get() and set() by returning field values, or java methods.
+ * Will respond to get() and set() by returning field values, or java methods.
*
- * This class is not used directly.
- * It is returned by calls to {@link CoerceJavaToLua#coerce(Object)}
- * when a Class is supplied.
+ * This class is not used directly. It is returned by calls to
+ * {@link CoerceJavaToLua#coerce(Object)} when a Class is supplied.
+ *
* @see CoerceJavaToLua
* @see CoerceLuaToJava
*/
@@ -51,18 +51,18 @@ class JavaClass extends JavaInstance implements CoerceJavaToLua.Coercion {
static final Map classes = Collections.synchronizedMap(new HashMap());
static final LuaValue NEW = valueOf("new");
-
+
Map fields;
Map methods;
Map innerclasses;
-
+
static JavaClass forClass(Class c) {
JavaClass j = (JavaClass) classes.get(c);
- if ( j == null )
- classes.put( c, j = new JavaClass(c) );
+ if (j == null)
+ classes.put(c, j = new JavaClass(c));
return j;
}
-
+
JavaClass(Class c) {
super(c);
this.jclass = this;
@@ -71,14 +71,14 @@ class JavaClass extends JavaInstance implements CoerceJavaToLua.Coercion {
public LuaValue coerce(Object javaValue) {
return this;
}
-
+
Field getField(LuaValue key) {
- if ( fields == null ) {
+ if (fields == null) {
Map m = new HashMap();
- Field[] f = ((Class)m_instance).getFields();
- for ( int i=0; i
- * This class is not used directly.
- * It is returned by calls to {@link JavaClass#new(LuaValue key)}
- * when the value of key is "new".
+ * This class is not used directly. It is returned by calls to
+ * {@link JavaClass#new(LuaValue key)} when the value of key is "new".
+ *
* @see CoerceJavaToLua
* @see CoerceLuaToJava
*/
class JavaConstructor extends JavaMember {
static final Map constructors = Collections.synchronizedMap(new HashMap());
-
+
static JavaConstructor forConstructor(Constructor c) {
JavaConstructor j = (JavaConstructor) constructors.get(c);
- if ( j == null )
- constructors.put( c, j = new JavaConstructor(c) );
+ if (j == null)
+ constructors.put(c, j = new JavaConstructor(c));
return j;
}
-
+
public static LuaValue forConstructors(JavaConstructor[] array) {
return new Overload(array);
}
final Constructor constructor;
-
+
private JavaConstructor(Constructor c) {
- super( c.getParameterTypes(), c.getModifiers() );
+ super(c.getParameterTypes(), c.getModifiers());
this.constructor = c;
}
-
+
public Varargs invoke(Varargs args) {
Object[] a = convertArgs(args);
try {
- return CoerceJavaToLua.coerce( constructor.newInstance(a) );
+ return CoerceJavaToLua.coerce(constructor.newInstance(a));
} catch (InvocationTargetException e) {
throw new LuaError(e.getTargetException());
} catch (Exception e) {
- return LuaValue.error("coercion error "+e);
+ return LuaValue.error("coercion error " + e);
}
}
@@ -82,12 +82,13 @@ class JavaConstructor extends JavaMember {
*
* On invocation, will pick the best method from the list, and invoke it.
*
- * This class is not used directly.
- * It is returned by calls to calls to {@link JavaClass#get(LuaValue key)}
- * when key is "new" and there is more than one public constructor.
+ * This class is not used directly. It is returned by calls to calls to
+ * {@link JavaClass#get(LuaValue key)} when key is "new" and there is more
+ * than one public constructor.
*/
static class Overload extends VarArgFunction {
- final JavaConstructor[] constructors;
+ final JavaConstructor[] constructors;
+
public Overload(JavaConstructor[] c) {
this.constructors = c;
}
@@ -95,20 +96,20 @@ class JavaConstructor extends JavaMember {
public Varargs invoke(Varargs args) {
JavaConstructor best = null;
int score = CoerceLuaToJava.SCORE_UNCOERCIBLE;
- for ( int i=0; i
- * This class is not used directly.
- * It is returned by calls to {@link CoerceJavaToLua#coerce(Object)}
- * when a subclass of Object is supplied.
+ * This class is not used directly. It is returned by calls to
+ * {@link CoerceJavaToLua#coerce(Object)} when a subclass of Object is supplied.
+ *
* @see CoerceJavaToLua
* @see CoerceLuaToJava
*/
class JavaInstance extends LuaUserdata {
JavaClass jclass;
-
+
JavaInstance(Object instance) {
super(instance);
}
public LuaValue get(LuaValue key) {
- if ( jclass == null )
+ if (jclass == null)
jclass = JavaClass.forClass(m_instance.getClass());
Field f = jclass.getField(key);
- if ( f != null )
+ if (f != null)
try {
return CoerceJavaToLua.coerce(f.get(m_instance));
} catch (Exception e) {
throw new LuaError(e);
}
LuaValue m = jclass.getMethod(key);
- if ( m != null )
+ if (m != null)
return m;
Class c = jclass.getInnerClass(key);
- if ( c != null )
+ if (c != null)
return JavaClass.forClass(c);
return super.get(key);
}
public void set(LuaValue key, LuaValue value) {
- if ( jclass == null )
+ if (jclass == null)
jclass = JavaClass.forClass(m_instance.getClass());
Field f = jclass.getField(key);
- if ( f != null )
+ if (f != null)
try {
f.set(m_instance, CoerceLuaToJava.coerce(value, f.getType()));
return;
@@ -77,6 +77,6 @@ class JavaInstance extends LuaUserdata {
throw new LuaError(e);
}
super.set(key, value);
- }
-
+ }
+
}
diff --git a/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/JavaMember.java b/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/JavaMember.java
index e4e9b7ed..886b7c40 100644
--- a/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/JavaMember.java
+++ b/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/JavaMember.java
@@ -28,56 +28,56 @@ import org.luaj.vm2.lib.jse.CoerceLuaToJava.Coercion;
/**
* Java method or constructor.
*
- * Primarily handles argument coercion for parameter lists including scoring of compatibility and
- * java varargs handling.
+ * Primarily handles argument coercion for parameter lists including scoring of
+ * compatibility and java varargs handling.
*
- * This class is not used directly.
- * It is an abstract base class for {@link JavaConstructor} and {@link JavaMethod}.
+ * This class is not used directly. It is an abstract base class for
+ * {@link JavaConstructor} and {@link JavaMethod}.
+ *
* @see JavaConstructor
* @see JavaMethod
* @see CoerceJavaToLua
* @see CoerceLuaToJava
*/
-abstract
-class JavaMember extends VarArgFunction {
-
+abstract class JavaMember extends VarArgFunction {
+
static final int METHOD_MODIFIERS_VARARGS = 0x80;
final Coercion[] fixedargs;
- final Coercion varargs;
-
+ final Coercion varargs;
+
protected JavaMember(Class[] params, int modifiers) {
boolean isvarargs = ((modifiers & METHOD_MODIFIERS_VARARGS) != 0);
fixedargs = new CoerceLuaToJava.Coercion[isvarargs? params.length-1: params.length];
- for ( int i=0; i
- * This class is not used directly.
- * It is returned by calls to calls to {@link JavaInstance#get(LuaValue key)}
- * when a method is named.
+ * This class is not used directly. It is returned by calls to calls to
+ * {@link JavaInstance#get(LuaValue key)} when a method is named.
+ *
* @see CoerceJavaToLua
* @see CoerceLuaToJava
*/
class JavaMethod extends JavaMember {
static final Map methods = Collections.synchronizedMap(new HashMap());
-
+
static JavaMethod forMethod(Method m) {
JavaMethod j = (JavaMethod) methods.get(m);
- if ( j == null )
- methods.put( m, j = new JavaMethod(m) );
+ if (j == null)
+ methods.put(m, j = new JavaMethod(m));
return j;
}
-
+
static LuaFunction forMethods(JavaMethod[] m) {
return new Overload(m);
}
-
+
final Method method;
-
+
private JavaMethod(Method m) {
- super( m.getParameterTypes(), m.getModifiers() );
+ super(m.getParameterTypes(), m.getModifiers());
this.method = m;
try {
if (!m.isAccessible())
@@ -81,39 +81,39 @@ class JavaMethod extends JavaMember {
public LuaValue call(LuaValue arg1, LuaValue arg2) {
return invokeMethod(arg1.checkuserdata(), arg2);
}
-
+
public LuaValue call(LuaValue arg1, LuaValue arg2, LuaValue arg3) {
return invokeMethod(arg1.checkuserdata(), LuaValue.varargsOf(arg2, arg3));
}
-
+
public Varargs invoke(Varargs args) {
return invokeMethod(args.checkuserdata(1), args.subargs(2));
}
-
+
LuaValue invokeMethod(Object instance, Varargs args) {
Object[] a = convertArgs(args);
try {
- return CoerceJavaToLua.coerce( method.invoke(instance, a) );
+ return CoerceJavaToLua.coerce(method.invoke(instance, a));
} catch (InvocationTargetException e) {
throw new LuaError(e.getTargetException());
} catch (Exception e) {
- return LuaValue.error("coercion error "+e);
+ return LuaValue.error("coercion error " + e);
}
}
-
+
/**
* LuaValue that represents an overloaded Java method.
*
* On invocation, will pick the best method from the list, and invoke it.
*
- * This class is not used directly.
- * It is returned by calls to calls to {@link JavaInstance#get(LuaValue key)}
- * when an overloaded method is named.
+ * This class is not used directly. It is returned by calls to calls to
+ * {@link JavaInstance#get(LuaValue key)} when an overloaded method is
+ * named.
*/
static class Overload extends LuaFunction {
final JavaMethod[] methods;
-
+
Overload(JavaMethod[] methods) {
this.methods = methods;
}
@@ -129,11 +129,11 @@ class JavaMethod extends JavaMember {
public LuaValue call(LuaValue arg1, LuaValue arg2) {
return invokeBestMethod(arg1.checkuserdata(), arg2);
}
-
+
public LuaValue call(LuaValue arg1, LuaValue arg2, LuaValue arg3) {
return invokeBestMethod(arg1.checkuserdata(), LuaValue.varargsOf(arg2, arg3));
}
-
+
public Varargs invoke(Varargs args) {
return invokeBestMethod(args.checkuserdata(1), args.subargs(2));
}
@@ -141,20 +141,20 @@ class JavaMethod extends JavaMember {
private LuaValue invokeBestMethod(Object instance, Varargs args) {
JavaMethod best = null;
int score = CoerceLuaToJava.SCORE_UNCOERCIBLE;
- for ( int i=0; i
- * Typically, this library is included as part of a call to
+ * Since JME has no file system by default, {@link BaseLib} implements
+ * {@link ResourceFinder} using {@link Class#getResource(String)}. The
+ * {@link org.luaj.vm2.lib.jse.JseBaseLib} implements {@link Globals#finder} by
+ * scanning the current directory first, then falling back to
+ * {@link Class#getResource(String)} if that fails. Otherwise, the behavior is
+ * the same as that of {@link BaseLib}.
+ *
+ * Typically, this library is included as part of a call to
* {@link org.luaj.vm2.lib.jse.JsePlatform#standardGlobals()}
- *
- * For special cases where the smallest possible footprint is desired,
- * a minimal set of libraries could be loaded
- * directly via {@link Globals#load(LuaValue)} using code such as:
- * However, other libraries such as PackageLib are not loaded in this case.
+ * For special cases where the smallest possible footprint is desired, a minimal
+ * set of libraries could be loaded directly via {@link Globals#load(LuaValue)}
+ * using code such as:
+ *
+ *
+ * However, other libraries such as PackageLib are not loaded in this
+ * case.
*
* This is a direct port of the corresponding library in C.
+ *
* @see Globals
* @see BaseLib
* @see ResourceFinder
@@ -68,18 +81,24 @@ import org.luaj.vm2.lib.ResourceFinder;
* @see LibFunction
* @see org.luaj.vm2.lib.jse.JsePlatform
* @see org.luaj.vm2.lib.jme.JmePlatform
- * @see Lua 5.2 Base Lib Reference
+ * @see Lua 5.2 Base Lib
+ * Reference
*/
public class JseBaseLib extends org.luaj.vm2.lib.BaseLib {
-
- /** Perform one-time initialization on the library by creating a table
- * containing the library functions, adding that table to the supplied environment,
- * adding the table to package.loaded, and returning table as the return value.
- * Specifically, extend the library loading to set the default value for {@link Globals#STDIN}
+ /**
+ * Perform one-time initialization on the library by creating a table
+ * containing the library functions, adding that table to the supplied
+ * environment, adding the table to package.loaded, and returning table as
+ * the return value.
+ *
+ * Specifically, extend the library loading to set the default value for
+ * {@link Globals#STDIN}
+ *
* @param modname the module name supplied if this is loaded via 'require'.
- * @param env the environment to load into, which must be a Globals instance.
+ * @param env the environment to load into, which must be a Globals
+ * instance.
*/
public LuaValue call(LuaValue modname, LuaValue env) {
super.call(modname, env);
@@ -87,30 +106,28 @@ public class JseBaseLib extends org.luaj.vm2.lib.BaseLib {
return env;
}
-
- /**
- * Try to open a file in the current working directory,
- * or fall back to base opener if not found.
+ /**
+ * Try to open a file in the current working directory, or fall back to base
+ * opener if not found.
*
- * This implementation attempts to open the file using new File(filename).
+ * This implementation attempts to open the file using new File(filename).
* It falls back to the base implementation that looks it up as a resource
- * in the class path if not found as a plain file.
- *
+ * in the class path if not found as a plain file.
+ *
* @see org.luaj.vm2.lib.BaseLib
* @see org.luaj.vm2.lib.ResourceFinder
*
* @param filename
- * @return InputStream, or null if not found.
+ * @return InputStream, or null if not found.
*/
public InputStream findResource(String filename) {
File f = new File(filename);
- if ( ! f.exists() )
+ if (!f.exists())
return super.findResource(filename);
try {
return new BufferedInputStream(new FileInputStream(f));
- } catch ( IOException ioe ) {
+ } catch (IOException ioe) {
return null;
}
}
}
-
diff --git a/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/JseIoLib.java b/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/JseIoLib.java
index cfaf6f4a..99d4b6ac 100644
--- a/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/JseIoLib.java
+++ b/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/JseIoLib.java
@@ -37,135 +37,157 @@ import org.luaj.vm2.lib.IoLib;
import org.luaj.vm2.lib.LibFunction;
/**
- * Subclass of {@link IoLib} and therefore {@link LibFunction} which implements the lua standard {@code io}
- * library for the JSE platform.
+ * Subclass of {@link IoLib} and therefore {@link LibFunction} which implements
+ * the lua standard {@code io} library for the JSE platform.
*
* It uses RandomAccessFile to implement seek on files.
*
* Typically, this library is included as part of a call to
* {@link org.luaj.vm2.lib.jse.JsePlatform#standardGlobals()}
- *
- * For special cases where the smallest possible footprint is desired,
- * a minimal set of libraries could be loaded
- * directly via {@link Globals#load(LuaValue)} using code such as:
- * However, other libraries such as MathLib are not loaded in this case.
+ * For special cases where the smallest possible footprint is desired, a minimal
+ * set of libraries could be loaded directly via {@link Globals#load(LuaValue)}
+ * using code such as:
+ *
+ *
- * This has been implemented to match as closely as possible the behavior in the corresponding library in C.
+ * However, other libraries such as MathLib are not loaded in this
+ * case.
+ *
+ * This has been implemented to match as closely as possible the behavior in the
+ * corresponding library in C.
+ *
* @see LibFunction
* @see org.luaj.vm2.lib.jse.JsePlatform
* @see org.luaj.vm2.lib.jme.JmePlatform
* @see IoLib
* @see org.luaj.vm2.lib.jme.JmeIoLib
- * @see Lua 5.2 I/O Lib Reference
+ * @see Lua 5.2 I/O Lib
+ * Reference
*/
public class JseIoLib extends IoLib {
protected File wrapStdin() throws IOException {
return new StdinFile();
}
-
+
protected File wrapStdout() throws IOException {
return new StdoutFile(FTYPE_STDOUT);
}
-
+
protected File wrapStderr() throws IOException {
return new StdoutFile(FTYPE_STDERR);
}
-
- protected File openFile( String filename, boolean readMode, boolean appendMode, boolean updateMode, boolean binaryMode ) throws IOException {
- RandomAccessFile f = new RandomAccessFile(filename,readMode? "r": "rw");
- if ( appendMode ) {
+
+ protected File openFile(String filename, boolean readMode, boolean appendMode, boolean updateMode,
+ boolean binaryMode) throws IOException {
+ RandomAccessFile f = new RandomAccessFile(filename, readMode? "r": "rw");
+ if (appendMode) {
f.seek(f.length());
} else {
- if ( ! readMode )
+ if (!readMode)
f.setLength(0);
}
- return new FileImpl( f );
+ return new FileImpl(f);
}
-
+
protected File openProgram(String prog, String mode) throws IOException {
final Process p = Runtime.getRuntime().exec(prog);
- return "w".equals(mode)?
- new FileImpl( p.getOutputStream() ):
- new FileImpl( p.getInputStream() );
+ return "w".equals(mode)? new FileImpl(p.getOutputStream()): new FileImpl(p.getInputStream());
}
protected File tmpFile() throws IOException {
- java.io.File f = java.io.File.createTempFile(".luaj","bin");
+ java.io.File f = java.io.File.createTempFile(".luaj", "bin");
f.deleteOnExit();
- return new FileImpl( new RandomAccessFile(f,"rw") );
+ return new FileImpl(new RandomAccessFile(f, "rw"));
}
-
+
private static void notimplemented() {
throw new LuaError("not implemented");
}
-
private final class FileImpl extends File {
private final RandomAccessFile file;
- private final InputStream is;
- private final OutputStream os;
- private boolean closed = false;
- private boolean nobuffer = false;
- private FileImpl( RandomAccessFile file, InputStream is, OutputStream os ) {
+ private final InputStream is;
+ private final OutputStream os;
+ private boolean closed = false;
+ private boolean nobuffer = false;
+
+ private FileImpl(RandomAccessFile file, InputStream is, OutputStream os) {
this.file = file;
- this.is = is!=null? is.markSupported()? is: new BufferedInputStream(is): null;
+ this.is = is != null? is.markSupported()? is: new BufferedInputStream(is): null;
this.os = os;
}
- private FileImpl( RandomAccessFile f ) {
- this( f, null, null );
+
+ private FileImpl(RandomAccessFile f) {
+ this(f, null, null);
}
- private FileImpl( InputStream i ) {
- this( null, i, null );
+
+ private FileImpl(InputStream i) {
+ this(null, i, null);
}
- private FileImpl( OutputStream o ) {
- this( null, null, o );
+
+ private FileImpl(OutputStream o) {
+ this(null, null, o);
}
+
public String tojstring() {
- return "file (" + (this.closed ? "closed" : String.valueOf(this.hashCode())) + ")";
+ return "file (" + (this.closed? "closed": String.valueOf(this.hashCode())) + ")";
}
+
public boolean isstdfile() {
return file == null;
}
- public void close() throws IOException {
+
+ public void close() throws IOException {
closed = true;
- if ( file != null ) {
+ if (file != null) {
file.close();
}
}
+
public void flush() throws IOException {
- if ( os != null )
+ if (os != null)
os.flush();
}
+
public void write(LuaString s) throws IOException {
- if ( os != null )
- os.write( s.m_bytes, s.m_offset, s.m_length );
- else if ( file != null )
- file.write( s.m_bytes, s.m_offset, s.m_length );
+ if (os != null)
+ os.write(s.m_bytes, s.m_offset, s.m_length);
+ else if (file != null)
+ file.write(s.m_bytes, s.m_offset, s.m_length);
else
notimplemented();
- if ( nobuffer )
+ if (nobuffer)
flush();
}
+
public boolean isclosed() {
return closed;
}
+
public int seek(String option, int pos) throws IOException {
- if ( file != null ) {
- if ( "set".equals(option) ) {
+ if (file != null) {
+ if ("set".equals(option)) {
file.seek(pos);
- } else if ( "end".equals(option) ) {
+ } else if ("end".equals(option)) {
file.seek(file.length()+pos);
} else {
file.seek(file.getFilePointer()+pos);
@@ -175,23 +197,24 @@ public class JseIoLib extends IoLib {
notimplemented();
return 0;
}
+
public void setvbuf(String mode, int size) {
nobuffer = "no".equals(mode);
}
// get length remaining to read
public int remaining() throws IOException {
- return file!=null? (int) (file.length()-file.getFilePointer()): -1;
+ return file != null? (int) (file.length()-file.getFilePointer()): -1;
}
-
+
// peek ahead one character
public int peek() throws IOException {
- if ( is != null ) {
+ if (is != null) {
is.mark(1);
int c = is.read();
is.reset();
return c;
- } else if ( file != null ) {
+ } else if (file != null) {
long fp = file.getFilePointer();
int c = file.read();
file.seek(fp);
@@ -200,12 +223,12 @@ public class JseIoLib extends IoLib {
notimplemented();
return 0;
}
-
+
// return char if read, -1 if eof, throw IOException on other exception
public int read() throws IOException {
- if ( is != null )
+ if (is != null)
return is.read();
- else if ( file != null ) {
+ else if (file != null) {
return file.read();
}
notimplemented();
@@ -214,9 +237,9 @@ public class JseIoLib extends IoLib {
// return number of bytes read if positive, -1 if eof, throws IOException
public int read(byte[] bytes, int offset, int length) throws IOException {
- if (file!=null) {
+ if (file != null) {
return file.read(bytes, offset, length);
- } else if (is!=null) {
+ } else if (is != null) {
return is.read(bytes, offset, length);
} else {
notimplemented();
@@ -233,14 +256,10 @@ public class JseIoLib extends IoLib {
}
public String tojstring() {
- return "file ("+this.hashCode()+")";
+ return "file (" + this.hashCode() + ")";
}
- private final PrintStream getPrintStream() {
- return file_type == FTYPE_STDERR?
- globals.STDERR:
- globals.STDOUT;
- }
+ private final PrintStream getPrintStream() { return file_type == FTYPE_STDERR? globals.STDERR: globals.STDOUT; }
public void write(LuaString string) throws IOException {
getPrintStream().write(string.m_bytes, string.m_offset, string.m_length);
@@ -281,8 +300,7 @@ public class JseIoLib extends IoLib {
return 0;
}
- public int read(byte[] bytes, int offset, int length)
- throws IOException {
+ public int read(byte[] bytes, int offset, int length) throws IOException {
return 0;
}
}
@@ -292,7 +310,7 @@ public class JseIoLib extends IoLib {
}
public String tojstring() {
- return "file ("+this.hashCode()+")";
+ return "file (" + this.hashCode() + ")";
}
public void write(LuaString string) throws IOException {
@@ -335,8 +353,7 @@ public class JseIoLib extends IoLib {
return globals.STDIN.read();
}
- public int read(byte[] bytes, int offset, int length)
- throws IOException {
+ public int read(byte[] bytes, int offset, int length) throws IOException {
return globals.STDIN.read(bytes, offset, length);
}
}
diff --git a/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/JseMathLib.java b/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/JseMathLib.java
index 87f133a1..516f8277 100644
--- a/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/JseMathLib.java
+++ b/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/JseMathLib.java
@@ -26,58 +26,76 @@ import org.luaj.vm2.LuaValue;
import org.luaj.vm2.lib.LibFunction;
import org.luaj.vm2.lib.TwoArgFunction;
-/**
- * Subclass of {@link LibFunction} which implements the lua standard {@code math}
- * library.
- *
- * It contains all lua math functions, including those not available on the JME platform.
- * See {@link org.luaj.vm2.lib.MathLib} for the exception list.
+/**
+ * Subclass of {@link LibFunction} which implements the lua standard
+ * {@code math} library.
*
- * Typically, this library is included as part of a call to
+ * It contains all lua math functions, including those not available on the JME
+ * platform. See {@link org.luaj.vm2.lib.MathLib} for the exception list.
+ *
+ * Typically, this library is included as part of a call to
* {@link org.luaj.vm2.lib.jse.JsePlatform#standardGlobals()}
- *
- * For special cases where the smallest possible footprint is desired,
- * a minimal set of libraries could be loaded
- * directly via {@link Globals#load(LuaValue)} using code such as:
- * However, other libraries such as CoroutineLib are not loaded in this case.
+ * For special cases where the smallest possible footprint is desired, a minimal
+ * set of libraries could be loaded directly via {@link Globals#load(LuaValue)}
+ * using code such as:
+ *
+ *
- * This has been implemented to match as closely as possible the behavior in the corresponding library in C.
+ * However, other libraries such as CoroutineLib are not loaded in this
+ * case.
+ *
+ * This has been implemented to match as closely as possible the behavior in the
+ * corresponding library in C.
+ *
* @see LibFunction
* @see org.luaj.vm2.lib.jse.JsePlatform
* @see org.luaj.vm2.lib.jme.JmePlatform
* @see org.luaj.vm2.lib.jse.JseMathLib
- * @see Lua 5.2 Math Lib Reference
+ * @see Lua 5.2 Math Lib
+ * Reference
*/
public class JseMathLib extends org.luaj.vm2.lib.MathLib {
-
+
public JseMathLib() {}
-
- /** Perform one-time initialization on the library by creating a table
- * containing the library functions, adding that table to the supplied environment,
- * adding the table to package.loaded, and returning table as the return value.
- * Specifically, adds all library functions that can be implemented directly
- * in JSE but not JME: acos, asin, atan, atan2, cosh, exp, log, pow, sinh, and tanh.
+ /**
+ * Perform one-time initialization on the library by creating a table
+ * containing the library functions, adding that table to the supplied
+ * environment, adding the table to package.loaded, and returning table as
+ * the return value.
+ *
+ * Specifically, adds all library functions that can be implemented directly
+ * in JSE but not JME: acos, asin, atan, atan2, cosh, exp, log, pow, sinh,
+ * and tanh.
+ *
* @param modname the module name supplied if this is loaded via 'require'.
- * @param env the environment to load into, which must be a Globals instance.
+ * @param env the environment to load into, which must be a Globals
+ * instance.
*/
public LuaValue call(LuaValue modname, LuaValue env) {
super.call(modname, env);
LuaValue math = env.get("math");
math.set("acos", new acos());
math.set("asin", new asin());
- LuaValue atan = new atan2();
+ LuaValue atan = new atan2();
math.set("atan", atan);
math.set("atan2", atan);
math.set("cosh", new cosh());
@@ -89,32 +107,53 @@ public class JseMathLib extends org.luaj.vm2.lib.MathLib {
return math;
}
- static final class acos extends UnaryOp { protected double call(double d) { return Math.acos(d); } }
- static final class asin extends UnaryOp { protected double call(double d) { return Math.asin(d); } }
- static final class atan2 extends TwoArgFunction {
+ static final class acos extends UnaryOp {
+ protected double call(double d) { return Math.acos(d); }
+ }
+
+ static final class asin extends UnaryOp {
+ protected double call(double d) { return Math.asin(d); }
+ }
+
+ static final class atan2 extends TwoArgFunction {
public LuaValue call(LuaValue x, LuaValue y) {
return valueOf(Math.atan2(x.checkdouble(), y.optdouble(1)));
- }
+ }
}
- static final class cosh extends UnaryOp { protected double call(double d) { return Math.cosh(d); } }
- static final class exp extends UnaryOp { protected double call(double d) { return Math.exp(d); } }
+
+ static final class cosh extends UnaryOp {
+ protected double call(double d) { return Math.cosh(d); }
+ }
+
+ static final class exp extends UnaryOp {
+ protected double call(double d) { return Math.exp(d); }
+ }
+
static final class log extends TwoArgFunction {
public LuaValue call(LuaValue x, LuaValue base) {
double nat = Math.log(x.checkdouble());
double b = base.optdouble(Math.E);
- if (b != Math.E) nat /= Math.log(b);
+ if (b != Math.E)
+ nat /= Math.log(b);
return valueOf(nat);
}
}
- static final class pow extends BinaryOp { protected double call(double x, double y) { return Math.pow(x, y); } }
- static final class sinh extends UnaryOp { protected double call(double d) { return Math.sinh(d); } }
- static final class tanh extends UnaryOp { protected double call(double d) { return Math.tanh(d); } }
+
+ static final class pow extends BinaryOp {
+ protected double call(double x, double y) { return Math.pow(x, y); }
+ }
+
+ static final class sinh extends UnaryOp {
+ protected double call(double d) { return Math.sinh(d); }
+ }
+
+ static final class tanh extends UnaryOp {
+ protected double call(double d) { return Math.tanh(d); }
+ }
/** Faster, better version of pow() used by arithmetic operator ^ */
public double dpow_lib(double a, double b) {
return Math.pow(a, b);
}
-
-
-}
+}
diff --git a/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/JseOsLib.java b/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/JseOsLib.java
index af63c8af..af21d7cc 100644
--- a/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/JseOsLib.java
+++ b/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/JseOsLib.java
@@ -31,10 +31,11 @@ import org.luaj.vm2.lib.LibFunction;
import org.luaj.vm2.lib.OsLib;
/**
- * Subclass of {@link LibFunction} which implements the standard lua {@code os} library.
+ * Subclass of {@link LibFunction} which implements the standard lua {@code os}
+ * library.
*
- * This contains more complete implementations of the following functions
- * using features that are specific to JSE:
+ * This contains more complete implementations of the following functions using
+ * features that are specific to JSE:
*
- * Because the nature of the {@code os} library is to encapsulate
- * os-specific features, the behavior of these functions varies considerably
- * from their counterparts in the C platform.
+ * Because the nature of the {@code os} library is to encapsulate os-specific
+ * features, the behavior of these functions varies considerably from their
+ * counterparts in the C platform.
*
* Typically, this library is included as part of a call to
* {@link org.luaj.vm2.lib.jse.JsePlatform#standardGlobals()}
- *
- * For special cases where the smallest possible footprint is desired,
- * a minimal set of libraries could be loaded
- * directly via {@link Globals#load(LuaValue)} using code such as:
- * However, other libraries such as MathLib are not loaded in this case.
+ * For special cases where the smallest possible footprint is desired, a minimal
+ * set of libraries could be loaded directly via {@link Globals#load(LuaValue)}
+ * using code such as:
+ *
+ *
+ * However, other libraries such as MathLib are not loaded in this
+ * case.
+ *
+ *
* @see LibFunction
* @see OsLib
* @see org.luaj.vm2.lib.jse.JsePlatform
* @see org.luaj.vm2.lib.jme.JmePlatform
- * @see Lua 5.2 OS Lib Reference
+ * @see Lua 5.2 OS Lib
+ * Reference
*/
public class JseOsLib extends org.luaj.vm2.lib.OsLib {
-
+
/** return code indicating the execute() threw an I/O exception */
- public static final int EXEC_IOEXCEPTION = 1;
-
+ public static final int EXEC_IOEXCEPTION = 1;
+
/** return code indicating the execute() was interrupted */
public static final int EXEC_INTERRUPTED = -2;
-
+
/** return code indicating the execute() threw an unknown exception */
- public static final int EXEC_ERROR = -3;
-
+ public static final int EXEC_ERROR = -3;
+
/** public constructor */
public JseOsLib() {
}
protected String getenv(String varname) {
String s = System.getenv(varname);
- return s != null? s : System.getProperty(varname);
+ return s != null? s: System.getProperty(varname);
}
protected Varargs execute(String command) {
@@ -109,27 +122,27 @@ public class JseOsLib extends org.luaj.vm2.lib.OsLib {
protected void remove(String filename) throws IOException {
File f = new File(filename);
- if ( ! f.exists() )
+ if (!f.exists())
throw new IOException("No such file or directory");
- if ( ! f.delete() )
+ if (!f.delete())
throw new IOException("Failed to delete");
}
protected void rename(String oldname, String newname) throws IOException {
File f = new File(oldname);
- if ( ! f.exists() )
+ if (!f.exists())
throw new IOException("No such file or directory");
- if ( ! f.renameTo(new File(newname)) )
+ if (!f.renameTo(new File(newname)))
throw new IOException("Failed to rename");
}
protected String tmpname() {
try {
- java.io.File f = java.io.File.createTempFile(TMP_PREFIX ,TMP_SUFFIX);
+ java.io.File f = java.io.File.createTempFile(TMP_PREFIX, TMP_SUFFIX);
return f.getAbsolutePath();
- } catch ( IOException ioe ) {
+ } catch (IOException ioe) {
return super.tmpname();
}
}
-
+
}
diff --git a/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/JsePlatform.java b/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/JsePlatform.java
index 00575aaf..7c5954b6 100644
--- a/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/JsePlatform.java
+++ b/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/JsePlatform.java
@@ -34,31 +34,45 @@ import org.luaj.vm2.lib.ResourceFinder;
import org.luaj.vm2.lib.StringLib;
import org.luaj.vm2.lib.TableLib;
-/** The {@link org.luaj.vm2.lib.jse.JsePlatform} class is a convenience class to standardize
- * how globals tables are initialized for the JSE platform.
+/**
+ * The {@link org.luaj.vm2.lib.jse.JsePlatform} class is a convenience class to
+ * standardize how globals tables are initialized for the JSE platform.
*
* It is used to allocate either a set of standard globals using
* {@link #standardGlobals()} or debug globals using {@link #debugGlobals()}
*
* A simple example of initializing globals and using them from Java is:
- *
* Once globals are created, a simple way to load and run a script is:
- *
* although {@code require} could also be used:
- *
- * The standard globals will contain all standard libraries plus {@code luajava}:
+ * The standard globals will contain all standard libraries plus
+ * {@code luajava}:
*
- * The debug globals are simply the standard globals plus the {@code debug} library {@link DebugLib}.
+ * The debug globals are simply the standard globals plus the {@code debug}
+ * library {@link DebugLib}.
*
* The class ensures that initialization is done in the correct order.
*
@@ -108,9 +124,11 @@ public class JsePlatform {
return globals;
}
- /** Create standard globals including the {@link DebugLib} library.
+ /**
+ * Create standard globals including the {@link DebugLib} library.
*
- * @return Table of globals initialized with the standard JSE and debug libraries
+ * @return Table of globals initialized with the standard JSE and debug
+ * libraries
* @see #standardGlobals()
* @see org.luaj.vm2.lib.jse.JsePlatform
* @see org.luaj.vm2.lib.jme.JmePlatform
@@ -122,10 +140,11 @@ public class JsePlatform {
return globals;
}
-
- /** Simple wrapper for invoking a lua function with command line arguments.
- * The supplied function is first given a new Globals object as its environment
- * then the program is run with arguments.
+ /**
+ * Simple wrapper for invoking a lua function with command line arguments.
+ * The supplied function is first given a new Globals object as its
+ * environment then the program is run with arguments.
+ *
* @return {@link Varargs} containing any values returned by mainChunk.
*/
public static Varargs luaMain(LuaValue mainChunk, String[] args) {
diff --git a/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/JseProcess.java b/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/JseProcess.java
index 3fcd79f1..42a5d528 100644
--- a/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/JseProcess.java
+++ b/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/JseProcess.java
@@ -25,37 +25,48 @@ import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
-/** Analog of Process that pipes input and output to client-specified streams.
+/**
+ * Analog of Process that pipes input and output to client-specified streams.
*/
public class JseProcess {
final Process process;
- final Thread input,output,error;
+ final Thread input, output, error;
- /** Construct a process around a command, with specified streams to redirect input and output to.
+ /**
+ * Construct a process around a command, with specified streams to redirect
+ * input and output to.
*
- * @param cmd The command to execute, including arguments, if any
- * @param stdin Optional InputStream to read from as process input, or null if input is not needed.
- * @param stdout Optional OutputStream to copy process output to, or null if output is ignored.
- * @param stderr Optinoal OutputStream to copy process stderr output to, or null if output is ignored.
+ * @param cmd The command to execute, including arguments, if any
+ * @param stdin Optional InputStream to read from as process input, or null
+ * if input is not needed.
+ * @param stdout Optional OutputStream to copy process output to, or null if
+ * output is ignored.
+ * @param stderr Optinoal OutputStream to copy process stderr output to, or
+ * null if output is ignored.
* @throws IOException If the system process could not be created.
* @see Process
*/
public JseProcess(String[] cmd, InputStream stdin, OutputStream stdout, OutputStream stderr) throws IOException {
- this(Runtime.getRuntime().exec(cmd), stdin, stdout, stderr);
+ this(Runtime.getRuntime().exec(cmd), stdin, stdout, stderr);
}
- /** Construct a process around a command, with specified streams to redirect input and output to.
+ /**
+ * Construct a process around a command, with specified streams to redirect
+ * input and output to.
*
- * @param cmd The command to execute, including arguments, if any
- * @param stdin Optional InputStream to read from as process input, or null if input is not needed.
- * @param stdout Optional OutputStream to copy process output to, or null if output is ignored.
- * @param stderr Optinoal OutputStream to copy process stderr output to, or null if output is ignored.
+ * @param cmd The command to execute, including arguments, if any
+ * @param stdin Optional InputStream to read from as process input, or null
+ * if input is not needed.
+ * @param stdout Optional OutputStream to copy process output to, or null if
+ * output is ignored.
+ * @param stderr Optinoal OutputStream to copy process stderr output to, or
+ * null if output is ignored.
* @throws IOException If the system process could not be created.
* @see Process
*/
public JseProcess(String cmd, InputStream stdin, OutputStream stdout, OutputStream stderr) throws IOException {
- this(Runtime.getRuntime().exec(cmd), stdin, stdout, stderr);
+ this(Runtime.getRuntime().exec(cmd), stdin, stdout, stderr);
}
private JseProcess(Process process, InputStream stdin, OutputStream stdout, OutputStream stderr) {
@@ -70,7 +81,9 @@ public class JseProcess {
return process.exitValue();
}
- /** Wait for the process to complete, and all pending output to finish.
+ /**
+ * Wait for the process to complete, and all pending output to finish.
+ *
* @return The exit status.
* @throws InterruptedException
*/
@@ -87,9 +100,8 @@ public class JseProcess {
}
/** Create a thread to copy bytes from input to output. */
- private Thread copyBytes(final InputStream input,
- final OutputStream output, final InputStream ownedInput,
- final OutputStream ownedOutput) {
+ private Thread copyBytes(final InputStream input, final OutputStream output, final InputStream ownedInput,
+ final OutputStream ownedOutput) {
Thread t = (new CopyThread(output, ownedOutput, ownedInput, input));
t.start();
return t;
@@ -98,11 +110,10 @@ public class JseProcess {
private static final class CopyThread extends Thread {
private final OutputStream output;
private final OutputStream ownedOutput;
- private final InputStream ownedInput;
- private final InputStream input;
+ private final InputStream ownedInput;
+ private final InputStream input;
- private CopyThread(OutputStream output, OutputStream ownedOutput,
- InputStream ownedInput, InputStream input) {
+ private CopyThread(OutputStream output, OutputStream ownedOutput, InputStream ownedInput, InputStream input) {
this.output = output;
this.ownedOutput = ownedOutput;
this.ownedInput = ownedInput;
@@ -114,7 +125,7 @@ public class JseProcess {
byte[] buf = new byte[1024];
int r;
try {
- while ((r = input.read(buf)) >= 0) {
+ while ( (r = input.read(buf)) >= 0 ) {
output.write(buf, 0, r);
}
} finally {
diff --git a/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/JseStringLib.java b/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/JseStringLib.java
index 41177787..87c9f097 100644
--- a/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/JseStringLib.java
+++ b/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/JseStringLib.java
@@ -22,7 +22,7 @@
package org.luaj.vm2.lib.jse;
public class JseStringLib extends org.luaj.vm2.lib.StringLib {
-
+
/** public constructor */
public JseStringLib() {
}
@@ -30,7 +30,7 @@ public class JseStringLib extends org.luaj.vm2.lib.StringLib {
protected String format(String src, double x) {
String out;
try {
- out = String.format(src, new Object[] {Double.valueOf(x)});
+ out = String.format(src, new Object[] { Double.valueOf(x) });
} catch (Throwable e) {
out = super.format(src, x);
}
diff --git a/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/LuajavaLib.java b/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/LuajavaLib.java
index 35f1f850..53d46ccc 100644
--- a/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/LuajavaLib.java
+++ b/luaj-jse/src/main/java/org/luaj/vm2/lib/jse/LuajavaLib.java
@@ -21,7 +21,6 @@
******************************************************************************/
package org.luaj.vm2.lib.jse;
-
import java.lang.reflect.Array;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
@@ -38,40 +37,51 @@ import org.luaj.vm2.lib.LibFunction;
import org.luaj.vm2.lib.VarArgFunction;
/**
- * Subclass of {@link LibFunction} which implements the features of the luajava package.
+ * Subclass of {@link LibFunction} which implements the features of the luajava
+ * package.
*
- * Luajava is an approach to mixing lua and java using simple functions that bind
- * java classes and methods to lua dynamically. The API is documented on the
- * luajava documentation pages.
+ * Luajava is an approach to mixing lua and java using simple functions that
+ * bind java classes and methods to lua dynamically. The API is documented on
+ * the luajava documentation
+ * pages.
*
*
* Typically, this library is included as part of a call to
* {@link org.luaj.vm2.lib.jse.JsePlatform#standardGlobals()}
- *
- * To instantiate and use it directly,
- * link it into your globals table via {@link Globals#load} using code such as:
- *
*
- * The {@code luajava} library is available
- * on all JSE platforms via the call to {@link org.luaj.vm2.lib.jse.JsePlatform#standardGlobals()}
- * and the luajava api's are simply invoked from lua.
- * Because it makes extensive use of Java's reflection API, it is not available
- * on JME, but can be used in Android applications.
+ * The {@code luajava} library is available on all JSE platforms via the call to
+ * {@link org.luaj.vm2.lib.jse.JsePlatform#standardGlobals()} and the luajava
+ * api's are simply invoked from lua. Because it makes extensive use of Java's
+ * reflection API, it is not available on JME, but can be used in Android
+ * applications.
*
- * This has been implemented to match as closely as possible the behavior in the corresponding library in C.
+ * This has been implemented to match as closely as possible the behavior in the
+ * corresponding library in C.
*
* @see LibFunction
* @see org.luaj.vm2.lib.jse.JsePlatform
@@ -79,25 +89,20 @@ import org.luaj.vm2.lib.VarArgFunction;
* @see LuaC
* @see CoerceJavaToLua
* @see CoerceLuaToJava
- * @see http://www.keplerproject.org/luajava/manual.html#luareference
+ * @see http://www.keplerproject.org/luajava/manual.html#luareference
*/
public class LuajavaLib extends VarArgFunction {
- static final int INIT = 0;
- static final int BINDCLASS = 1;
- static final int NEWINSTANCE = 2;
- static final int NEW = 3;
- static final int CREATEPROXY = 4;
- static final int LOADLIB = 5;
+ static final int INIT = 0;
+ static final int BINDCLASS = 1;
+ static final int NEWINSTANCE = 2;
+ static final int NEW = 3;
+ static final int CREATEPROXY = 4;
+ static final int LOADLIB = 5;
+
+ static final String[] NAMES = { "bindClass", "newInstance", "new", "createProxy", "loadLib", };
- static final String[] NAMES = {
- "bindClass",
- "newInstance",
- "new",
- "createProxy",
- "loadLib",
- };
-
static final int METHOD_MODIFIERS_VARARGS = 0x80;
public LuajavaLib() {
@@ -105,14 +110,15 @@ public class LuajavaLib extends VarArgFunction {
public Varargs invoke(Varargs args) {
try {
- switch ( opcode ) {
+ switch (opcode) {
case INIT: {
// LuaValue modname = args.arg1();
LuaValue env = args.arg(2);
LuaTable t = new LuaTable();
- bind( t, this.getClass(), NAMES, BINDCLASS );
+ bind(t, this.getClass(), NAMES, BINDCLASS);
env.set("luajava", t);
- if (!env.get("package").isnil()) env.get("package").get("loaded").set("luajava", t);
+ if (!env.get("package").isnil())
+ env.get("package").get("loaded").set("luajava", t);
return t;
}
case BINDCLASS: {
@@ -123,30 +129,31 @@ public class LuajavaLib extends VarArgFunction {
case NEW: {
// get constructor
final LuaValue c = args.checkvalue(1);
- final Class clazz = (opcode==NEWINSTANCE? classForName(c.tojstring()): (Class) c.checkuserdata(Class.class));
+ final Class clazz = (opcode == NEWINSTANCE? classForName(c.tojstring())
+ : (Class) c.checkuserdata(Class.class));
final Varargs consargs = args.subargs(2);
return JavaClass.forClass(clazz).getConstructor().invoke(consargs);
}
-
+
case CREATEPROXY: {
final int niface = args.narg()-1;
- if ( niface <= 0 )
+ if (niface <= 0)
throw new LuaError("no interfaces");
final LuaValue lobj = args.checktable(niface+1);
-
+
// get the interfaces
final Class[] ifaces = new Class[niface];
- for ( int i=0; i
- * To override the default compiling behavior with {@link LuaJC}
- * lua-to-java bytecode compiler, install it before undumping code,
- * for example:
- *
- * This requires the bcel library to be on the class path to work as expected.
- * If the library is not found, the default {@link LuaC} lua-to-lua-bytecode
- * compiler will be used.
+ * This requires the bcel library to be on the class path to work as expected.
+ * If the library is not found, the default {@link LuaC} lua-to-lua-bytecode
+ * compiler will be used.
*
* @see Globals#compiler
* @see #install(Globals)
@@ -63,70 +65,75 @@ import org.luaj.vm2.compiler.LuaC;
* @see LuaValue
*/
public class LuaJC implements Globals.Loader {
-
+
public static final LuaJC instance = new LuaJC();
-
- /**
- * Install the compiler as the main Globals.Loader to use in a set of globals.
- * Will fall back to the LuaC prototype compiler.
+
+ /**
+ * Install the compiler as the main Globals.Loader to use in a set of
+ * globals. Will fall back to the LuaC prototype compiler.
*/
public static final void install(Globals G) {
- G.loader = instance;
+ G.loader = instance;
}
-
+
protected LuaJC() {}
- public Hashtable compileAll(InputStream script, String chunkname, String filename, Globals globals, boolean genmain) throws IOException {
- final String classname = toStandardJavaClassName( chunkname );
+ public Hashtable compileAll(InputStream script, String chunkname, String filename, Globals globals, boolean genmain)
+ throws IOException {
+ final String classname = toStandardJavaClassName(chunkname);
final Prototype p = globals.loadPrototype(script, classname, "bt");
return compileProtoAndSubProtos(p, classname, filename, genmain);
}
-
- public Hashtable compileAll(Reader script, String chunkname, String filename, Globals globals, boolean genmain) throws IOException {
- final String classname = toStandardJavaClassName( chunkname );
+
+ public Hashtable compileAll(Reader script, String chunkname, String filename, Globals globals, boolean genmain)
+ throws IOException {
+ final String classname = toStandardJavaClassName(chunkname);
final Prototype p = globals.compilePrototype(script, classname);
return compileProtoAndSubProtos(p, classname, filename, genmain);
}
-
- private Hashtable compileProtoAndSubProtos(Prototype p, String classname, String filename, boolean genmain) throws IOException {
- final String luaname = toStandardLuaFileName( filename );
+
+ private Hashtable compileProtoAndSubProtos(Prototype p, String classname, String filename, boolean genmain)
+ throws IOException {
+ final String luaname = toStandardLuaFileName(filename);
final Hashtable h = new Hashtable();
final JavaGen gen = new JavaGen(p, classname, luaname, genmain);
- insert( h, gen );
+ insert(h, gen);
return h;
}
-
+
private void insert(Hashtable h, JavaGen gen) {
h.put(gen.classname, gen.bytecode);
- for ( int i=0, n=gen.inners!=null? gen.inners.length: 0; i
- * If the system property 'org.luaj.debug' is set, the globals
- * created will be a debug globals that includes the debug
- * library. This may provide better stack traces, but may
- * have negative impact on performance.
+ * If the system property 'org.luaj.debug' is set, the globals created will
+ * be a debug globals that includes the debug library. This may provide
+ * better stack traces, but may have negative impact on performance.
*/
public LuajContext() {
- this("true".equals(System.getProperty("org.luaj.debug")),
- "true".equals(System.getProperty("org.luaj.luajc")));
+ this("true".equals(System.getProperty("org.luaj.debug")), "true".equals(System.getProperty("org.luaj.luajc")));
}
- /** Construct a LuajContext with its own globals, which
- * which optionally are debug globals, and optionally use the
- * luajc direct lua to java bytecode compiler.
+ /**
+ * Construct a LuajContext with its own globals, which which optionally are
+ * debug globals, and optionally use the luajc direct lua to java bytecode
+ * compiler.
*
- * If createDebugGlobals is set, the globals
- * created will be a debug globals that includes the debug
- * library. This may provide better stack traces, but may
- * have negative impact on performance.
- * @param createDebugGlobals true to create debug globals,
- * false for standard globals.
- * @param useLuaJCCompiler true to use the luajc compiler,
- * reqwuires bcel to be on the class path.
+ * If createDebugGlobals is set, the globals created will be a debug globals
+ * that includes the debug library. This may provide better stack traces,
+ * but may have negative impact on performance.
+ *
+ * @param createDebugGlobals true to create debug globals, false for
+ * standard globals.
+ * @param useLuaJCCompiler true to use the luajc compiler, reqwuires bcel
+ * to be on the class path.
*/
public LuajContext(boolean createDebugGlobals, boolean useLuaJCCompiler) {
- globals = createDebugGlobals?
- JsePlatform.debugGlobals():
- JsePlatform.standardGlobals();
- if (useLuaJCCompiler)
- LuaJC.install(globals);
- stdin = globals.STDIN;
- stdout = globals.STDOUT;
- stderr = globals.STDERR;
- }
-
- @Override
- public void setErrorWriter(Writer writer) {
- globals.STDERR = writer != null?
- new PrintStream(new WriterOutputStream(writer)):
- stderr;
+ globals = createDebugGlobals? JsePlatform.debugGlobals(): JsePlatform.standardGlobals();
+ if (useLuaJCCompiler)
+ LuaJC.install(globals);
+ stdin = globals.STDIN;
+ stdout = globals.STDOUT;
+ stderr = globals.STDERR;
}
@Override
- public void setReader(Reader reader) {
- globals.STDIN = reader != null?
- new ReaderInputStream(reader):
- stdin;
+ public void setErrorWriter(Writer writer) {
+ globals.STDERR = writer != null? new PrintStream(new WriterOutputStream(writer)): stderr;
}
+ @Override
+ public void setReader(Reader reader) { globals.STDIN = reader != null? new ReaderInputStream(reader): stdin; }
+
@Override
public void setWriter(Writer writer) {
- globals.STDOUT = writer != null?
- new PrintStream(new WriterOutputStream(writer), true):
- stdout;
+ globals.STDOUT = writer != null? new PrintStream(new WriterOutputStream(writer), true): stdout;
}
static final class WriterOutputStream extends OutputStream {
final Writer w;
+
WriterOutputStream(Writer w) {
this.w = w;
}
+
public void write(int b) throws IOException {
- w.write(new String(new byte[] {(byte)b}));
+ w.write(new String(new byte[] { (byte) b }));
}
+
public void write(byte[] b, int o, int l) throws IOException {
w.write(new String(b, o, l));
}
+
public void write(byte[] b) throws IOException {
w.write(new String(b));
}
+
public void close() throws IOException {
w.close();
}
+
public void flush() throws IOException {
w.flush();
}
}
-
+
static final class ReaderInputStream extends InputStream {
final Reader r;
+
ReaderInputStream(Reader r) {
this.r = r;
}
+
public int read() throws IOException {
return r.read();
}
diff --git a/luaj-jse/src/main/java/org/luaj/vm2/server/DefaultLauncher.java b/luaj-jse/src/main/java/org/luaj/vm2/server/DefaultLauncher.java
index 098f64a4..73e0491b 100644
--- a/luaj-jse/src/main/java/org/luaj/vm2/server/DefaultLauncher.java
+++ b/luaj-jse/src/main/java/org/luaj/vm2/server/DefaultLauncher.java
@@ -31,13 +31,13 @@ import org.luaj.vm2.lib.jse.CoerceJavaToLua;
import org.luaj.vm2.lib.jse.JsePlatform;
/**
- * Default {@link Launcher} instance that creates standard globals
- * and runs the supplied scripts with chunk name 'main'.
+ * Default {@link Launcher} instance that creates standard globals and runs the
+ * supplied scripts with chunk name 'main'.
*
* Arguments are coerced into lua using {@link CoerceJavaToLua#coerce(Object)}.
*
- * Return values with simple types are coerced into Java simple types.
- * Tables, threads, and functions are returned as lua objects.
+ * Return values with simple types are coerced into Java simple types. Tables,
+ * threads, and functions are returned as lua objects.
*
* @see Launcher
* @see LuajClassLoader
@@ -51,13 +51,15 @@ public class DefaultLauncher implements Launcher {
public DefaultLauncher() {
g = JsePlatform.standardGlobals();
}
-
+
/** Launches the script with chunk name 'main' */
public Object[] launch(String script, Object[] arg) {
return launchChunk(g.load(script, "main"), arg);
}
- /** Launches the script with chunk name 'main' and loading using modes 'bt' */
+ /**
+ * Launches the script with chunk name 'main' and loading using modes 'bt'
+ */
public Object[] launch(InputStream script, Object[] arg) {
return launchChunk(g.load(script, "main", "bt", g), arg);
}
@@ -102,4 +104,4 @@ public class DefaultLauncher implements Launcher {
}
return return_values;
}
-}
\ No newline at end of file
+}
diff --git a/luaj-jse/src/main/java/org/luaj/vm2/server/Launcher.java b/luaj-jse/src/main/java/org/luaj/vm2/server/Launcher.java
index 378f7c81..3d236be6 100644
--- a/luaj-jse/src/main/java/org/luaj/vm2/server/Launcher.java
+++ b/luaj-jse/src/main/java/org/luaj/vm2/server/Launcher.java
@@ -24,16 +24,19 @@ package org.luaj.vm2.server;
import java.io.InputStream;
import java.io.Reader;
-/** Interface to launch lua scripts using the {@link LuajClassLoader}.
+/**
+ * Interface to launch lua scripts using the {@link LuajClassLoader}.
*
- * Note: This class is experimental and subject to change in future versions.
+ * Note: This class is experimental and subject to change in future
+ * versions.
*
- * This interface is purposely genericized to defer class loading so that
- * luaj classes can come from the class loader.
+ * This interface is purposely genericized to defer class loading so that luaj
+ * classes can come from the class loader.
*
- * The implementation should be acquired using {@link LuajClassLoader#NewLauncher()}
- * or {@link LuajClassLoader#NewLauncher(Class)} which ensure that the classes are
- * loaded to give each Launcher instance a pristine set of Globals, including
+ * The implementation should be acquired using
+ * {@link LuajClassLoader#NewLauncher()} or
+ * {@link LuajClassLoader#NewLauncher(Class)} which ensure that the classes are
+ * loaded to give each Launcher instance a pristine set of Globals, including
* the shared metatables.
*
* @see LuajClassLoader
@@ -43,28 +46,31 @@ import java.io.Reader;
* @since luaj 3.0.1
*/
public interface Launcher {
-
- /** Launch a script contained in a String.
+
+ /**
+ * Launch a script contained in a String.
*
- * @param script The script contents.
- * @param arg Optional arguments supplied to the script.
+ * @param script The script contents.
+ * @param arg Optional arguments supplied to the script.
* @return return values from the script.
*/
- public Object[] launch(String script, Object[] arg);
+ public Object[] launch(String script, Object[] arg);
- /** Launch a script from an InputStream.
+ /**
+ * Launch a script from an InputStream.
*
- * @param script The script as an InputStream.
- * @param arg Optional arguments supplied to the script.
+ * @param script The script as an InputStream.
+ * @param arg Optional arguments supplied to the script.
* @return return values from the script.
*/
- public Object[] launch(InputStream script, Object[] arg);
+ public Object[] launch(InputStream script, Object[] arg);
- /** Launch a script from a Reader.
+ /**
+ * Launch a script from a Reader.
*
- * @param script The script as a Reader.
- * @param arg Optional arguments supplied to the script.
+ * @param script The script as a Reader.
+ * @param arg Optional arguments supplied to the script.
* @return return values from the script.
*/
public Object[] launch(Reader script, Object[] arg);
-}
\ No newline at end of file
+}
diff --git a/luaj-jse/src/main/java/org/luaj/vm2/server/LuajClassLoader.java b/luaj-jse/src/main/java/org/luaj/vm2/server/LuajClassLoader.java
index 3886c1f8..4e3d75d6 100644
--- a/luaj-jse/src/main/java/org/luaj/vm2/server/LuajClassLoader.java
+++ b/luaj-jse/src/main/java/org/luaj/vm2/server/LuajClassLoader.java
@@ -28,16 +28,16 @@ import java.util.Map;
/**
* Class loader that can be used to launch a lua script in a Java VM that has a
- * unique set of classes for org.luaj classes.
+ * unique set of classes for org.luaj classes.
*
-* Note: This class is experimental and subject to change in future versions.
+ * Note: This class is experimental and subject to change in future
+ * versions.
*
- * By using a custom class loader per script, it allows the script to have
- * its own set of globals, including static values such as shared metatables
- * that cannot access lua values from other scripts because their classes are
- * loaded from different class loaders. Thus normally unsafe libraries such
- * as luajava can be exposed to scripts in a server environment using these
- * techniques.
+ * By using a custom class loader per script, it allows the script to have its
+ * own set of globals, including static values such as shared metatables that
+ * cannot access lua values from other scripts because their classes are loaded
+ * from different class loaders. Thus normally unsafe libraries such as luajava
+ * can be exposed to scripts in a server environment using these techniques.
*
* All classes in the package "org.luaj.vm2." are considered user classes, and
* loaded into this class loader from their bytes in the class path. Other
@@ -61,10 +61,14 @@ import java.util.Map;
*/
public class LuajClassLoader extends ClassLoader {
- /** String describing the luaj packages to consider part of the user classes */
+ /**
+ * String describing the luaj packages to consider part of the user classes
+ */
static final String luajPackageRoot = "org.luaj.vm2.";
- /** String describing the Launcher interface to be considered a system class */
+ /**
+ * String describing the Launcher interface to be considered a system class
+ */
static final String launcherInterfaceRoot = Launcher.class.getName();
/** Local cache of classes loaded by this loader. */
@@ -75,54 +79,52 @@ public class LuajClassLoader extends ClassLoader {
* its own {@link LuajClassLoader} using the default implementation class
* {@link DefaultLauncher}.
*
- * The {@link Launcher} that is returned will be a pristine luaj vm
- * whose classes are loaded into this loader including static variables
- * such as shared metatables, and should not be able to directly access
- * variables from other Launcher instances.
+ * The {@link Launcher} that is returned will be a pristine luaj vm whose
+ * classes are loaded into this loader including static variables such as
+ * shared metatables, and should not be able to directly access variables
+ * from other Launcher instances.
*
* @return {@link Launcher} instance that can be used to launch scripts.
* @throws InstantiationException
* @throws IllegalAccessException
* @throws ClassNotFoundException
*/
- public static Launcher NewLauncher() throws InstantiationException,
- IllegalAccessException, ClassNotFoundException {
+ public static Launcher NewLauncher() throws InstantiationException, IllegalAccessException, ClassNotFoundException {
return NewLauncher(DefaultLauncher.class);
}
/**
- * Construct a {@link Launcher} instance that will load classes in
- * its own {@link LuajClassLoader} using a user-supplied implementation class
- * that implements {@link Launcher}.
+ * Construct a {@link Launcher} instance that will load classes in its own
+ * {@link LuajClassLoader} using a user-supplied implementation class that
+ * implements {@link Launcher}.
*
- * The {@link Launcher} that is returned will be a pristine luaj vm
- * whose classes are loaded into this loader including static variables
- * such as shared metatables, and should not be able to directly access
- * variables from other Launcher instances.
+ * The {@link Launcher} that is returned will be a pristine luaj vm whose
+ * classes are loaded into this loader including static variables such as
+ * shared metatables, and should not be able to directly access variables
+ * from other Launcher instances.
*
- * @return instance of type 'launcher_class' that can be used to launch scripts.
+ * @return instance of type 'launcher_class' that can be used to launch
+ * scripts.
* @throws InstantiationException
* @throws IllegalAccessException
* @throws ClassNotFoundException
*/
public static Launcher NewLauncher(Class launcher_class)
- throws InstantiationException, IllegalAccessException,
- ClassNotFoundException {
+ throws InstantiationException, IllegalAccessException, ClassNotFoundException {
final LuajClassLoader loader = new LuajClassLoader();
- final Object instance = loader.loadAsUserClass(launcher_class.getName())
- .newInstance();
+ final Object instance = loader.loadAsUserClass(launcher_class.getName()).newInstance();
return (Launcher) instance;
}
/**
- * Test if a class name should be considered a user class and loaded
- * by this loader, or a system class and loaded by the system loader.
+ * Test if a class name should be considered a user class and loaded by this
+ * loader, or a system class and loaded by the system loader.
+ *
* @param classname Class name to test.
* @return true if this should be loaded into this class loader.
*/
public static boolean isUserClass(String classname) {
- return classname.startsWith(luajPackageRoot)
- && !classname.startsWith(launcherInterfaceRoot);
+ return classname.startsWith(luajPackageRoot) && !classname.startsWith(launcherInterfaceRoot);
}
public Class loadClass(String classname) throws ClassNotFoundException {
@@ -143,13 +145,11 @@ public class LuajClassLoader extends ClassLoader {
for (int n = 0; (n = is.read(b)) >= 0;)
baos.write(b, 0, n);
byte[] bytes = baos.toByteArray();
- Class result = super.defineClass(classname, bytes, 0,
- bytes.length);
+ Class result = super.defineClass(classname, bytes, 0, bytes.length);
classes.put(classname, result);
return result;
} catch (java.io.IOException e) {
- throw new ClassNotFoundException("Read failed: " + classname
- + ": " + e);
+ throw new ClassNotFoundException("Read failed: " + classname + ": " + e);
}
}
throw new ClassNotFoundException("Not found: " + classname);
diff --git a/luaj-test/src/test/java/org/luaj/luajc/SampleMainChunk.java b/luaj-test/src/test/java/org/luaj/luajc/SampleMainChunk.java
index 87168ada..4d697f44 100644
--- a/luaj-test/src/test/java/org/luaj/luajc/SampleMainChunk.java
+++ b/luaj-test/src/test/java/org/luaj/luajc/SampleMainChunk.java
@@ -8,43 +8,43 @@ import org.luaj.vm2.lib.VarArgFunction;
public class SampleMainChunk extends VarArgFunction {
static final LuaValue $print = valueOf("print");
- static final LuaValue $foo = valueOf("foo");
-
- LuaValue[] rw_ENV; // The environment when it is read-write
+ static final LuaValue $foo = valueOf("foo");
+
+ LuaValue[] rw_ENV; // The environment when it is read-write
// LuaValue ro_ENV; // The environment when it is read-only in all sub-functions
-
- LuaValue[] rw_openup1; // upvalue that we create and modify in "slot" 1, passed to sub-function in initer.
- LuaValue[] rw_openup2; // array is instantiated on first set or before supply to closure, after that value is get, set.
- LuaValue[] rw_openup3; // closing these nulls them out, sub-functions still retain references to array & can use
- LuaValue ro_openup4; // open upvalue that is read-only once it is supplied to an inner function.
- LuaValue ro_openup5; // closing this also nulls it out.
-
+
+ LuaValue[] rw_openup1; // upvalue that we create and modify in "slot" 1, passed to sub-function in initer.
+ LuaValue[] rw_openup2; // array is instantiated on first set or before supply to closure, after that value is get, set.
+ LuaValue[] rw_openup3; // closing these nulls them out, sub-functions still retain references to array & can use
+ LuaValue ro_openup4; // open upvalue that is read-only once it is supplied to an inner function.
+ LuaValue ro_openup5; // closing this also nulls it out.
+
// Must have this in the main chunk so it can be loaded and instantiated on all platforms.
public SampleMainChunk() {
}
-
+
public void initupvalue1(LuaValue[] v) {
this.rw_ENV = v;
}
public Varargs invoke(Varargs args) {
rw_ENV[0].get($print).call($foo);
-
+
rw_ENV[0].set($print, new InnerFunction(rw_openup3, rw_openup1, ro_openup5));
-
+
return null;
}
-
+
static class InnerFunction extends TwoArgFunction {
static final LuaValue $print = valueOf("print"); // A constant, named for what it is.
- static final LuaValue $foo = valueOf("foo");
-
- final LuaValue[] rw_upvalue1; // from enclosing function, corresponds to upvaldesc not instack.
- final LuaValue[] rw_upvalue2; // from enclosing function, corresponds to upvaldesc not instack.
- final LuaValue ro_upvalue3; // from enclosing function, but read-only everywhere.
+ static final LuaValue $foo = valueOf("foo");
- LuaValue[] rw_openup1; // closing these nulls them out, sub-functions still retain references to array & can use
- LuaValue ro_openup2; // open upvalue that is read-only once it is supplied to an inner function.
+ final LuaValue[] rw_upvalue1; // from enclosing function, corresponds to upvaldesc not instack.
+ final LuaValue[] rw_upvalue2; // from enclosing function, corresponds to upvaldesc not instack.
+ final LuaValue ro_upvalue3; // from enclosing function, but read-only everywhere.
+
+ LuaValue[] rw_openup1; // closing these nulls them out, sub-functions still retain references to array & can use
+ LuaValue ro_openup2; // open upvalue that is read-only once it is supplied to an inner function.
InnerFunction(LuaValue[] rw_upvalue1, LuaValue[] rw_upvalue2, LuaValue ro_upvalue3) {
this.rw_upvalue1 = rw_upvalue1;
@@ -55,7 +55,7 @@ public class SampleMainChunk extends VarArgFunction {
public LuaValue call(LuaValue arg1, LuaValue arg2) {
return NIL;
}
-
+
}
}
diff --git a/luaj-test/src/test/java/org/luaj/luajc/TestLuaJ.java b/luaj-test/src/test/java/org/luaj/luajc/TestLuaJ.java
index eee17c5c..cbd8d7b5 100644
--- a/luaj-test/src/test/java/org/luaj/luajc/TestLuaJ.java
+++ b/luaj-test/src/test/java/org/luaj/luajc/TestLuaJ.java
@@ -30,41 +30,33 @@ import org.luaj.vm2.lib.jse.JsePlatform;
/** Test the plain old bytecode interpreter */
public class TestLuaJ {
// create the script
- public static String name = "script";
- public static String script =
- "function r(q,...)\n"+
- " local a=arg\n"+
- " return a and a[2]\n"+
- "end\n" +
- "function s(q,...)\n"+
- " local a=arg\n"+
- " local b=...\n"+
- " return a and a[2],b\n"+
- "end\n" +
- "print( r(111,222,333),s(111,222,333) )";
-
+ public static String name = "script";
+ public static String script = "function r(q,...)\n" + " local a=arg\n" + " return a and a[2]\n" + "end\n"
+ + "function s(q,...)\n" + " local a=arg\n" + " local b=...\n" + " return a and a[2],b\n" + "end\n"
+ + "print( r(111,222,333),s(111,222,333) )";
+
public static void main(String[] args) throws Exception {
System.out.println(script);
-
+
// create an environment to run in
Globals globals = JsePlatform.standardGlobals();
-
+
// compile into a chunk, or load as a class
LuaValue chunk = globals.load(script, "script");
-
+
// The loaded chunk should be a closure, which contains the prototype.
- print( chunk.checkclosure().p );
+ print(chunk.checkclosure().p);
// The chunk can be called with arguments as desired.
chunk.call(LuaValue.ZERO, LuaValue.ONE);
}
private static void print(Prototype p) {
- System.out.println("--- "+p);
+ System.out.println("--- " + p);
Print.printCode(p);
- if (p.p!=null)
- for ( int i=0,n=p.p.length; iConstructing and Initializing Instances
- * Typically, this is constructed indirectly by a call to
- * {@link org.luaj.vm2.lib.jse.JsePlatform#standardGlobals()} or
- * {@link org.luaj.vm2.lib.jme.JmePlatform#standardGlobals()},
- * and then used to load lua scripts for execution as in the following example.
- * {@code
- * Globals globals = JsePlatform.standardGlobals();
- * globals.load( new StringReader("print 'hello'"), "main.lua" ).call();
- * }
+ * Constructing and Initializing Instances
Typically, this is
+ * constructed indirectly by a call to
+ * {@link org.luaj.vm2.lib.jse.JsePlatform#standardGlobals()} or
+ * {@link org.luaj.vm2.lib.jme.JmePlatform#standardGlobals()}, and then used to
+ * load lua scripts for execution as in the following example.
+ *
+ *
+ * {
+ * @code
+ * Globals globals = JsePlatform.standardGlobals();
+ * globals.load(new StringReader("print 'hello'"), "main.lua").call();
+ * }
+ *
+ *
* The creates a complete global environment with the standard libraries loaded.
* {@code
- * Globals globals = new Globals();
- * globals.load( new BaseLib() );
- * }
+ * For specialized circumstances, the Globals may be constructed directly and
+ * loaded with only those libraries that are needed, for example.
*
- * Loading and Executing Lua Code
- * Globals contains convenience functions to load and execute lua source code given a Reader.
- * A simple example is:
- * {@code
+ *
*
- *
+ * {
+ * @code
+ * Globals globals = new Globals();
+ * globals.load(new BaseLib());
+ * }
+ *
+ *
+ * Loading and Executing Lua Code
Globals contains convenience
+ * functions to load and execute lua source code given a Reader. A simple
+ * example is:
+ *
+ *
+ * {@code
* globals.load( new StringReader("print 'hello'"), "main.lua" ).call();
- * }
+ * }
+ * Fine-Grained Control of Compiling and Loading Lua
- * Executable LuaFunctions are created from lua code in several steps
+ * Fine-Grained Control of Compiling and Loading Lua
Executable
+ * LuaFunctions are created from lua code in several steps
*
*
*
- *
*
- * Java Field
- * Certain public fields are provided that contain the current values of important global state:
+ * Java Field
Certain public fields are provided that contain the
+ * current values of important global state:
*
- *
*
- * Lua Environment Variables
- * When using {@link org.luaj.vm2.lib.jse.JsePlatform} or {@link org.luaj.vm2.lib.jme.JmePlatform},
- * these environment variables are created within the Globals.
+ * Lua Environment Variables
When using
+ * {@link org.luaj.vm2.lib.jse.JsePlatform} or
+ * {@link org.luaj.vm2.lib.jme.JmePlatform}, these environment variables are
+ * created within the Globals.
*
*
*
- * Use in Multithreaded Environments
- * In a multi-threaded server environment, each server thread should create one Globals instance,
- * which will be logically distinct and not interfere with each other, but share certain
- * static immutable resources such as class data and string data.
+ * Use in Multithreaded Environments
In a multi-threaded server
+ * environment, each server thread should create one Globals instance, which
+ * will be logically distinct and not interfere with each other, but share
+ * certain static immutable resources such as class data and string data.
* {@code
-* Globals globals = JsePlatform.standardGlobals();
-* LuaValue chunk = globasl.load("print('hello, world')", "main.lua");
-* chunk.call();
-* }
-* This should work regardless of which {@link Globals.Compiler} or {@link Globals.Undumper}
-* have been installed.
-* {@code
-* Globals globals = JsePlatform.standardGlobals();
-* Prototype p = globals.compilePrototype(new StringReader("print('hello, world')"), "main.lua");
-* ByteArrayOutputStream o = new ByteArrayOutputStream();
-* org.luaj.vm2.compiler.DumpState.dump(p, o, false);
-* byte[] lua_binary_file_bytes = o.toByteArray();
-* }
-*
-* The {@link LoadState}'s default undumper {@link #instance}
-* may be used directly to undump these bytes:
-* {@code
+ * Class to undump compiled lua bytecode into a {@link Prototype} instances.
+ *
+ *
+ *
+ * More commonly, the {@link Globals.Undumper} may be used to undump them:
+ *
+ *
+ * {
+ * @code
+ * Globals globals = JsePlatform.standardGlobals();
+ * LuaValue chunk = globasl.load("print('hello, world')", "main.lua");
+ * chunk.call();
+ * }
+ *
+ *
+ * This should work regardless of which {@link Globals.Compiler} or
+ * {@link Globals.Undumper} have been installed.
+ *
+ * {
+ * @code
+ * Globals globals = JsePlatform.standardGlobals();
+ * Prototype p = globals.compilePrototype(new StringReader("print('hello, world')"), "main.lua");
+ * ByteArrayOutputStream o = new ByteArrayOutputStream();
+ * org.luaj.vm2.compiler.DumpState.dump(p, o, false);
+ * byte[] lua_binary_file_bytes = o.toByteArray();
+ * }
+ *
+ *
+ * The {@link LoadState}'s default undumper {@link #instance} may be used
+ * directly to undump these bytes:
+ *
+ *
+ * {@code
* Prototypep = LoadState.instance.undump(new ByteArrayInputStream(lua_binary_file_bytes), "main.lua");
* LuaClosure c = new LuaClosure(p, globals);
* c.call();
-* }
-*
-*
-* More commonly, the {@link Globals.Undumper} may be used to undump them:
-* {@code
-* Prototype p = globals.loadPrototype(new ByteArrayInputStream(lua_binary_file_bytes), "main.lua", "b");
-* LuaClosure c = new LuaClosure(p, globals);
-* c.call();
-* }
-*
-* @see Globals.Compiler
-* @see Globals.Undumper
-* @see LuaClosure
-* @see LuaFunction
-* @see org.luaj.vm2.compiler.LuaC
-* @see org.luaj.vm2.luajc.LuaJC
-* @see Globals#compiler
-* @see Globals#load(InputStream, String, LuaValue)
-*/
+* }
+ *
+ * {
+ * @code
+ * Prototype p = globals.loadPrototype(new ByteArrayInputStream(lua_binary_file_bytes), "main.lua", "b");
+ * LuaClosure c = new LuaClosure(p, globals);
+ * c.call();
+ * }
+ *
+ *
+ * @see Globals.Compiler
+ * @see Globals.Undumper
+ * @see LuaClosure
+ * @see LuaFunction
+ * @see org.luaj.vm2.compiler.LuaC
+ * @see org.luaj.vm2.luajc.LuaJC
+ * @see Globals#compiler
+ * @see Globals#load(InputStream, String, LuaValue)
+ */
public class LoadState {
- /** Shared instance of Globals.Undumper to use loading prototypes from binary lua files */
+ /**
+ * Shared instance of Globals.Undumper to use loading prototypes from binary
+ * lua files
+ */
public static final Globals.Undumper instance = new GlobalsUndumper();
-
- /** format corresponding to non-number-patched lua, all numbers are floats or doubles */
- public static final int NUMBER_FORMAT_FLOATS_OR_DOUBLES = 0;
+
+ /**
+ * format corresponding to non-number-patched lua, all numbers are floats or
+ * doubles
+ */
+ public static final int NUMBER_FORMAT_FLOATS_OR_DOUBLES = 0;
/** format corresponding to non-number-patched lua, all numbers are ints */
- public static final int NUMBER_FORMAT_INTS_ONLY = 1;
-
- /** format corresponding to number-patched lua, all numbers are 32-bit (4 byte) ints */
- public static final int NUMBER_FORMAT_NUM_PATCH_INT32 = 4;
-
+ public static final int NUMBER_FORMAT_INTS_ONLY = 1;
+
+ /**
+ * format corresponding to number-patched lua, all numbers are 32-bit (4
+ * byte) ints
+ */
+ public static final int NUMBER_FORMAT_NUM_PATCH_INT32 = 4;
+
// type constants
- public static final int LUA_TINT = (-2);
- public static final int LUA_TNONE = (-1);
- public static final int LUA_TNIL = 0;
- public static final int LUA_TBOOLEAN = 1;
- public static final int LUA_TLIGHTUSERDATA = 2;
- public static final int LUA_TNUMBER = 3;
- public static final int LUA_TSTRING = 4;
- public static final int LUA_TTABLE = 5;
- public static final int LUA_TFUNCTION = 6;
- public static final int LUA_TUSERDATA = 7;
- public static final int LUA_TTHREAD = 8;
- public static final int LUA_TVALUE = 9;
-
- /** The character encoding to use for file encoding. Null means the default encoding */
+ public static final int LUA_TINT = (-2);
+ public static final int LUA_TNONE = (-1);
+ public static final int LUA_TNIL = 0;
+ public static final int LUA_TBOOLEAN = 1;
+ public static final int LUA_TLIGHTUSERDATA = 2;
+ public static final int LUA_TNUMBER = 3;
+ public static final int LUA_TSTRING = 4;
+ public static final int LUA_TTABLE = 5;
+ public static final int LUA_TFUNCTION = 6;
+ public static final int LUA_TUSERDATA = 7;
+ public static final int LUA_TTHREAD = 8;
+ public static final int LUA_TVALUE = 9;
+
+ /**
+ * The character encoding to use for file encoding. Null means the default
+ * encoding
+ */
public static String encoding = null;
-
+
/** Signature byte indicating the file is a compiled binary chunk */
- public static final byte[] LUA_SIGNATURE = { '\033', 'L', 'u', 'a' };
+ public static final byte[] LUA_SIGNATURE = { '\033', 'L', 'u', 'a' };
/** Data to catch conversion errors */
public static final byte[] LUAC_TAIL = { (byte) 0x19, (byte) 0x93, '\r', '\n', (byte) 0x1a, '\n', };
-
/** Name for compiled chunks */
public static final String SOURCE_BINARY_STRING = "binary string";
-
/** for header of binary files -- this is Lua 5.2 */
- public static final int LUAC_VERSION = 0x52;
+ public static final int LUAC_VERSION = 0x52;
/** for header of binary files -- this is the official format */
- public static final int LUAC_FORMAT = 0;
+ public static final int LUAC_FORMAT = 0;
/** size of header of binary files */
- public static final int LUAC_HEADERSIZE = 12;
+ public static final int LUAC_HEADERSIZE = 12;
// values read from the header
private int luacVersion;
@@ -144,7 +169,7 @@ public class LoadState {
private int luacSizeofSizeT;
private int luacSizeofInstruction;
private int luacSizeofLuaNumber;
- private int luacNumberFormat;
+ private int luacNumberFormat;
/** input stream from which we are loading */
public final DataInputStream is;
@@ -152,127 +177,141 @@ public class LoadState {
/** Name of what is being loaded? */
String name;
- private static final LuaValue[] NOVALUES = {};
- private static final Prototype[] NOPROTOS = {};
- private static final LocVars[] NOLOCVARS = {};
- private static final Upvaldesc[] NOUPVALDESCS = {};
- private static final int[] NOINTS = {};
-
+ private static final LuaValue[] NOVALUES = {};
+ private static final Prototype[] NOPROTOS = {};
+ private static final LocVars[] NOLOCVARS = {};
+ private static final Upvaldesc[] NOUPVALDESCS = {};
+ private static final int[] NOINTS = {};
+
/** Read buffer */
private byte[] buf = new byte[512];
- /** Install this class as the standard Globals.Undumper for the supplied Globals */
+ /**
+ * Install this class as the standard Globals.Undumper for the supplied
+ * Globals
+ */
public static void install(Globals globals) {
globals.undumper = instance;
}
-
- /** Load a 4-byte int value from the input stream
+
+ /**
+ * Load a 4-byte int value from the input stream
+ *
* @return the int value laoded.
**/
int loadInt() throws IOException {
- is.readFully(buf,0,4);
- return luacLittleEndian?
- (buf[3] << 24) | ((0xff & buf[2]) << 16) | ((0xff & buf[1]) << 8) | (0xff & buf[0]):
- (buf[0] << 24) | ((0xff & buf[1]) << 16) | ((0xff & buf[2]) << 8) | (0xff & buf[3]);
+ is.readFully(buf, 0, 4);
+ return luacLittleEndian? (buf[3]<<24) | ((0xff & buf[2])<<16) | ((0xff & buf[1])<<8) | (0xff & buf[0])
+ : (buf[0]<<24) | ((0xff & buf[1])<<16) | ((0xff & buf[2])<<8) | (0xff & buf[3]);
}
-
- /** Load an array of int values from the input stream
+
+ /**
+ * Load an array of int values from the input stream
+ *
* @return the array of int values laoded.
**/
int[] loadIntArray() throws IOException {
int n = loadInt();
- if ( n == 0 )
+ if (n == 0)
return NOINTS;
-
+
// read all data at once
- int m = n << 2;
- if ( buf.length < m )
+ int m = n<<2;
+ if (buf.length < m)
buf = new byte[m];
- is.readFully(buf,0,m);
+ is.readFully(buf, 0, m);
int[] array = new int[n];
- for ( int i=0, j=0; i
*
* {@code
- * String script = "print( 'hello, world' )";
- * InputStream is = new ByteArrayInputStream(script.getBytes());
- * Prototype p = LuaC.instance.compile(is, "script");
- * LuaValue globals = JsePlatform.standardGlobals();
- * LuaClosure f = new LuaClosure(p, globals);
- * f.call();
- * }
+ * To construct it directly, the {@link Prototype} is typically created via a
+ * compiler such as {@link org.luaj.vm2.compiler.LuaC}:
+ *
+ *
+ * {
+ * @code
+ * String script = "print( 'hello, world' )";
+ * InputStream is = new ByteArrayInputStream(script.getBytes());
+ * Prototype p = LuaC.instance.compile(is, "script");
+ * LuaValue globals = JsePlatform.standardGlobals();
+ * LuaClosure f = new LuaClosure(p, globals);
+ * f.call();
+ * }
+ *
* {@code
- * Globals globals = JsePlatform.standardGlobals();
- * LuaFunction f = globals.load(new StringReader(script), "script");
- * LuaClosure c = f.checkclosure(); // This may fail if LuaJC is installed.
- * c.call();
- * }
+ * To construct it indirectly, the {@link Globals#load(java.io.Reader, String)}
+ * method may be used:
+ *
+ *
+ * {
+ * @code
+ * Globals globals = JsePlatform.standardGlobals();
+ * LuaFunction f = globals.load(new StringReader(script), "script");
+ * LuaClosure c = f.checkclosure(); // This may fail if LuaJC is installed.
+ * c.call();
+ * }
+ *
*
*
+ *
* @see LuaValue
* @see LuaFunction
* @see LuaValue#isclosure()
@@ -85,16 +98,19 @@ import org.luaj.vm2.lib.DebugLib.CallFrame;
*/
public class LuaClosure extends LuaFunction {
private static final UpValue[] NOUPVALUES = new UpValue[0];
-
+
public final Prototype p;
public UpValue[] upValues;
-
+
final Globals globals;
-
- /** Create a closure around a Prototype with a specific environment.
- * If the prototype has upvalues, the environment will be written into the first upvalue.
- * @param p the Prototype to construct this Closure for.
+
+ /**
+ * Create a closure around a Prototype with a specific environment. If the
+ * prototype has upvalues, the environment will be written into the first
+ * upvalue.
+ *
+ * @param p the Prototype to construct this Closure for.
* @param env the environment to associate with the closure.
*/
public LuaClosure(Prototype p, LuaValue env) {
@@ -102,21 +118,20 @@ public class LuaClosure extends LuaFunction {
this.initupvalue1(env);
globals = env instanceof Globals? (Globals) env: null;
}
-
+
public void initupvalue1(LuaValue env) {
if (p.upvalues == null || p.upvalues.length == 0)
this.upValues = NOUPVALUES;
else {
this.upValues = new UpValue[p.upvalues.length];
- this.upValues[0] = new UpValue(new LuaValue[] {env}, 0);
+ this.upValues[0] = new UpValue(new LuaValue[] { env }, 0);
}
}
-
public boolean isclosure() {
return true;
}
-
+
public LuaClosure optclosure(LuaClosure defval) {
return this;
}
@@ -124,379 +139,435 @@ public class LuaClosure extends LuaFunction {
public LuaClosure checkclosure() {
return this;
}
-
+
public String tojstring() {
return "function: " + p.toString();
}
-
+
private LuaValue[] getNewStack() {
int max = p.maxstacksize;
LuaValue[] stack = new LuaValue[max];
System.arraycopy(NILS, 0, stack, 0, max);
return stack;
}
-
+
public final LuaValue call() {
LuaValue[] stack = getNewStack();
- return execute(stack,NONE).arg1();
+ return execute(stack, NONE).arg1();
}
public final LuaValue call(LuaValue arg) {
LuaValue[] stack = getNewStack();
- switch ( p.numparams ) {
- default: stack[0]=arg; return execute(stack,NONE).arg1();
- case 0: return execute(stack,arg).arg1();
+ switch (p.numparams) {
+ default:
+ stack[0] = arg;
+ return execute(stack, NONE).arg1();
+ case 0:
+ return execute(stack, arg).arg1();
}
}
-
+
public final LuaValue call(LuaValue arg1, LuaValue arg2) {
LuaValue[] stack = getNewStack();
- switch ( p.numparams ) {
- default: stack[0]=arg1; stack[1]=arg2; return execute(stack,NONE).arg1();
- case 1: stack[0]=arg1; return execute(stack,arg2).arg1();
- case 0: return execute(stack,p.is_vararg!=0? varargsOf(arg1,arg2): NONE).arg1();
+ switch (p.numparams) {
+ default:
+ stack[0] = arg1;
+ stack[1] = arg2;
+ return execute(stack, NONE).arg1();
+ case 1:
+ stack[0] = arg1;
+ return execute(stack, arg2).arg1();
+ case 0:
+ return execute(stack, p.is_vararg != 0? varargsOf(arg1, arg2): NONE).arg1();
}
}
public final LuaValue call(LuaValue arg1, LuaValue arg2, LuaValue arg3) {
LuaValue[] stack = getNewStack();
- switch ( p.numparams ) {
- default: stack[0]=arg1; stack[1]=arg2; stack[2]=arg3; return execute(stack,NONE).arg1();
- case 2: stack[0]=arg1; stack[1]=arg2; return execute(stack,arg3).arg1();
- case 1: stack[0]=arg1; return execute(stack,p.is_vararg!=0? varargsOf(arg2,arg3): NONE).arg1();
- case 0: return execute(stack,p.is_vararg!=0? varargsOf(arg1,arg2,arg3): NONE).arg1();
+ switch (p.numparams) {
+ default:
+ stack[0] = arg1;
+ stack[1] = arg2;
+ stack[2] = arg3;
+ return execute(stack, NONE).arg1();
+ case 2:
+ stack[0] = arg1;
+ stack[1] = arg2;
+ return execute(stack, arg3).arg1();
+ case 1:
+ stack[0] = arg1;
+ return execute(stack, p.is_vararg != 0? varargsOf(arg2, arg3): NONE).arg1();
+ case 0:
+ return execute(stack, p.is_vararg != 0? varargsOf(arg1, arg2, arg3): NONE).arg1();
}
}
public final Varargs invoke(Varargs varargs) {
return onInvoke(varargs).eval();
}
-
+
public final Varargs onInvoke(Varargs varargs) {
LuaValue[] stack = getNewStack();
- for ( int i=0; i
*
*
*
* {@code
+ *
+ *
*
*
+ * {@code
* LuaValue k = LuaValue.NIL;
* while ( true ) {
* Varargs n = table.next(k);
@@ -53,11 +55,12 @@ import java.util.Vector;
* break;
* LuaValue v = n.arg(2)
* process( k, v )
- * }}
+ * }}
+ *
*
+ *
* @see LuaValue
*/
public class LuaTable extends LuaValue implements Metatable {
- private static final int MIN_HASH_CAPACITY = 2;
- private static final LuaString N = valueOf("n");
-
+ private static final int MIN_HASH_CAPACITY = 2;
+ private static final LuaString N = valueOf("n");
+
/** the array values */
protected LuaValue[] array;
-
+
/** the hash part */
protected Slot[] hash;
-
+
/** the number of hash entries */
protected int hashEntries;
-
+
/** metatable for this table, or null */
protected Metatable m_metatable;
-
+
/** Construct empty table */
public LuaTable() {
array = NOVALS;
hash = NOBUCKETS;
}
-
+
/**
* Construct table with preset capacity.
+ *
* @param narray capacity of array part
- * @param nhash capacity of hash part
+ * @param nhash capacity of hash part
*/
public LuaTable(int narray, int nhash) {
presize(narray, nhash);
@@ -103,47 +110,52 @@ public class LuaTable extends LuaValue implements Metatable {
/**
* Construct table with named and unnamed parts.
- * @param named Named elements in order {@code key-a, value-a, key-b, value-b, ... }
+ *
+ * @param named Named elements in order
+ * {@code key-a, value-a, key-b, value-b, ... }
* @param unnamed Unnamed elements in order {@code value-1, value-2, ... }
* @param lastarg Additional unnamed values beyond {@code unnamed.length}
*/
public LuaTable(LuaValue[] named, LuaValue[] unnamed, Varargs lastarg) {
- int nn = (named!=null? named.length: 0);
- int nu = (unnamed!=null? unnamed.length: 0);
- int nl = (lastarg!=null? lastarg.narg(): 0);
+ int nn = (named != null? named.length: 0);
+ int nu = (unnamed != null? unnamed.length: 0);
+ int nl = (lastarg != null? lastarg.narg(): 0);
presize(nu+nl, nn>>1);
- for ( int i=0; i {@code
- * LuaValue a = LuaValue.valueOf( 5 );
- * LuaValue b = LuaValue.valueOf( 4 );
- * LuaValue c = a.div(b);
- * }
- * Note that in this example, c will be a {@link LuaDouble}, but would be a {@link LuaInteger}
- * if the value of a were changed to 8, say.
- * In general the value of c in practice will vary depending on both the types and values of a and b
- * as well as any metatable/metatag processing that occurs.
+ * Operations are performed on values directly via their Java methods. For
+ * example, the following code divides two numbers:
+ *
+ *
+ * {
+ * @code
+ * LuaValue a = LuaValue.valueOf(5);
+ * LuaValue b = LuaValue.valueOf(4);
+ * LuaValue c = a.div(b);
+ * }
+ *
+ *
+ * Note that in this example, c will be a {@link LuaDouble}, but would be a
+ * {@link LuaInteger} if the value of a were changed to 8, say. In general the
+ * value of c in practice will vary depending on both the types and values of a
+ * and b as well as any metatable/metatag processing that occurs.
* {@code
- * LuaValue globals = JsePlatform.standardGlobals();
- * LuaValue sqrt = globals.get("math").get("sqrt");
- * LuaValue print = globals.get("print");
- * LuaValue d = sqrt.call( a );
- * print.call( LuaValue.valueOf("sqrt(5):"), a );
- * }
+ * Field access and function calls are similar, with common overloads to
+ * simplify Java usage:
+ *
+ *
+ * {
+ * @code
+ * LuaValue globals = JsePlatform.standardGlobals();
+ * LuaValue sqrt = globals.get("math").get("sqrt");
+ * LuaValue print = globals.get("print");
+ * LuaValue d = sqrt.call(a);
+ * print.call(LuaValue.valueOf("sqrt(5):"), a);
+ * }
+ *
* {@code
- * LuaValue modf = globals.get("math").get("modf");
- * Varargs r = modf.invoke( d );
- * print.call( r.arg(1), r.arg(2) );
- * }
+ *
+ *
+ * {
+ * @code
+ * LuaValue modf = globals.get("math").get("modf");
+ * Varargs r = modf.invoke(d);
+ * print.call(r.arg(1), r.arg(2));
+ * }
+ *
* {@code
+ *
+ *
*
+ * {@code
* LoadState.load( new FileInputStream("main.lua"), "main.lua", globals ).call();
- * }
+ * }
+ * {@code
+ *
+ *
+ *
+ * For this to work the file must be in the current directory, or in the class
+ * path, dependening on the platform. See
+ * {@link org.luaj.vm2.lib.jse.JsePlatform} and
+ * {@link org.luaj.vm2.lib.jme.JmePlatform} for details.
*
+ * {@code
* globals.get("require").call(LuaValue.valueOf("main"));
- * }
- * For this to work the file must be in the current directory, or in the class path,
- * dependening on the platform.
- * See {@link org.luaj.vm2.lib.jse.JsePlatform} and {@link org.luaj.vm2.lib.jme.JmePlatform} for details.
+ * }
+ *
@@ -89,14 +112,14 @@ package org.luaj.vm2;
*
* {@code
+ *
+ *
+ *
+ * @param index {@link LuaInteger} value identifying a key to start from, or
+ * {@link #NIL} to start at the beginning
+ * @return {@link Varargs} containing {key,value} for the next entry, or
+ * {@link #NIL} if there are no more.
+ * @throws LuaError if {@code this} is not a table, or the supplied key is
+ * invalid.
* @see LuaTable
* @see #inext(LuaValue)
* @see #valueOf(int)
@@ -1323,12 +1583,16 @@ public class LuaValue extends Varargs {
* @see #isnil()
*/
public Varargs next(LuaValue index) { return typerror("table"); }
-
- /** Find the next integer-key,value pair if {@code this} is a table,
- * return {@link #NIL} if there are no more, or throw a {@link LuaError} if not a table.
+
+ /**
+ * Find the next integer-key,value pair if {@code this} is a table, return
+ * {@link #NIL} if there are no more, or throw a {@link LuaError} if not a
+ * table.
*
+ * {@code
* LuaValue k = LuaValue.NIL;
* while ( true ) {
* Varargs n = table.next(k);
@@ -1309,12 +1566,15 @@ public class LuaValue extends Varargs {
* break;
* LuaValue v = n.arg(2)
* process( k, v )
- * }}
- * @param index {@link LuaInteger} value identifying a key to start from,
- * or {@link #NIL} to start at the beginning
- * @return {@link Varargs} containing {key,value} for the next entry,
- * or {@link #NIL} if there are no more.
- * @throws LuaError if {@code this} is not a table, or the supplied key is invalid.
+ * }}
+ * {@code
+ *
+ *
+ *
+ * @param index {@link LuaInteger} value identifying a key to start from, or
+ * {@link #NIL} to start at the beginning
+ * @return {@link Varargs} containing {@code (key,value)} for the next
+ * entry, or {@link #NONE} if there are no more.
+ * @throws LuaError if {@code this} is not a table, or the supplied key is
+ * invalid.
* @see LuaTable
* @see #next(LuaValue)
* @see #valueOf(int)
@@ -1351,27 +1618,32 @@ public class LuaValue extends Varargs {
* @see #isnil()
*/
public Varargs inext(LuaValue index) { return typerror("table"); }
-
+
/**
- * Load a library instance by calling it with and empty string as the modname,
- * and this Globals as the environment. This is normally used to iniitalize the
- * library instance and which may install itself into these globals.
+ * Load a library instance by calling it with and empty string as the
+ * modname, and this Globals as the environment. This is normally used to
+ * iniitalize the library instance and which may install itself into these
+ * globals.
+ *
* @param library The callable {@link LuaValue} to load into {@code this}
* @return {@link LuaValue} returned by the initialization call.
*/
public LuaValue load(LuaValue library) { return library.call(EMPTYSTRING, this); }
// varargs references
- public LuaValue arg(int index) { return index==1? this: NIL; }
+ public LuaValue arg(int index) { return index == 1? this: NIL; }
+
public int narg() { return 1; };
+
public LuaValue arg1() { return this; }
-
+
/**
* Get the metatable for this {@link LuaValue}
*
+ * {@code
* LuaValue k = LuaValue.NIL;
* while ( true ) {
* Varargs n = table.inext(k);
@@ -1337,12 +1601,15 @@ public class LuaValue extends Varargs {
* LuaValue v = n.arg(2)
* process( k, v )
* }
- * }
- * @param index {@link LuaInteger} value identifying a key to start from,
- * or {@link #NIL} to start at the beginning
- * @return {@link Varargs} containing {@code (key,value)} for the next entry,
- * or {@link #NONE} if there are no more.
- * @throws LuaError if {@code this} is not a table, or the supplied key is invalid.
+ * }
+ * {@code
- * Globals globals = JsePlatform.standardGlobals();
- * globals.load( new StringReader("print 'hello'"), "main.lua" ).call();
- * }
+ * Generally, the {@link Prototype} is not constructed directly is an
+ * intermediate result as lua code is loaded using
+ * {@link Globals#load(java.io.Reader, String)}:
+ *
+ *
+ * {
+ * @code
+ * Globals globals = JsePlatform.standardGlobals();
+ * globals.load(new StringReader("print 'hello'"), "main.lua").call();
+ * }
+ *
*
* {@code
- * InputStream is = new ByteArrayInputStream("print('hello,world')".getBytes());
- * Prototype p = LuaC.instance.compile(is, "script");
- * }
*
- * To simplify loading, the {@link Globals#compilePrototype(java.io.InputStream, String)} method may be used:
- * {@code
- * Prototype p = globals.compileProtoytpe(is, "script");
- * }
+ *
+ * {
+ * @code
+ * InputStream is = new ByteArrayInputStream("print('hello,world')".getBytes());
+ * Prototype p = LuaC.instance.compile(is, "script");
+ * }
+ *
*
- * It may also be loaded from a {@link java.io.Reader} via {@link Globals#compilePrototype(java.io.Reader, String)}:
- * {@code
- * Prototype p = globals.compileProtoytpe(new StringReader(script), "script");
- * }
+ * To simplify loading, the
+ * {@link Globals#compilePrototype(java.io.InputStream, String)} method may be
+ * used:
*
- * To un-dump a binary file known to be a binary lua file that has been dumped to a string,
- * the {@link Globals.Undumper} interface may be used:
- * {@code
- * FileInputStream lua_binary_file = new FileInputStream("foo.lc"); // Known to be compiled lua.
- * Prototype p = globals.undumper.undump(lua_binary_file, "foo.lua");
- * }
+ *
+ * {
+ * @code
+ * Prototype p = globals.compileProtoytpe(is, "script");
+ * }
+ *
*
- * To execute the code represented by the {@link Prototype} it must be supplied to
- * the constructor of a {@link LuaClosure}:
- * {@code
- * Globals globals = JsePlatform.standardGlobals();
- * LuaClosure f = new LuaClosure(p, globals);
- * f.call();
- * }
+ * It may also be loaded from a {@link java.io.Reader} via
+ * {@link Globals#compilePrototype(java.io.Reader, String)}:
*
- * To simplify the debugging of prototype values, the contents may be printed using {@link Print#print}:
- * {@code
+ *
*
+ * {
+ * @code
+ * Prototype p = globals.compileProtoytpe(new StringReader(script), "script");
+ * }
+ *
+ *
+ * To un-dump a binary file known to be a binary lua file that has been dumped
+ * to a string, the {@link Globals.Undumper} interface may be used:
+ *
+ *
+ * {
+ * @code
+ * FileInputStream lua_binary_file = new FileInputStream("foo.lc"); // Known to be compiled lua.
+ * Prototype p = globals.undumper.undump(lua_binary_file, "foo.lua");
+ * }
+ *
+ *
+ * To execute the code represented by the {@link Prototype} it must be supplied
+ * to the constructor of a {@link LuaClosure}:
+ *
+ *
+ * {
+ * @code
+ * Globals globals = JsePlatform.standardGlobals();
+ * LuaClosure f = new LuaClosure(p, globals);
+ * f.call();
+ * }
+ *
+ *
+ * To simplify the debugging of prototype values, the contents may be printed
+ * using {@link Print#print}:
+ *
+ *
+ * {@code
* Print.print(p);
- * }
+ * }
+ * {@code
- * Globals globals = JsePlatform.standardGlobals();
- * Prototype p = globals.compilePrototype(new StringReader("print('hello, world')"), "main.lua");
- * ByteArrayOutputStream o = new ByteArrayOutputStream();
- * DumpState.dump(p, o, false);
- * byte[] lua_binary_file_bytes = o.toByteArray();
- * }
+ *
+ *
+ * {
+ * @code
+ * Globals globals = JsePlatform.standardGlobals();
+ * Prototype p = globals.compilePrototype(new StringReader("print('hello, world')"), "main.lua");
+ * ByteArrayOutputStream o = new ByteArrayOutputStream();
+ * DumpState.dump(p, o, false);
+ * byte[] lua_binary_file_bytes = o.toByteArray();
+ * }
+ *
*
* The {@link LoadState} may be used directly to undump these bytes:
- * {@code
+ *
+ *
*
*
* More commonly, the {@link Globals#undumper} may be used to undump them:
- *
+ * {@code
* Prototypep = LoadState.instance.undump(new ByteArrayInputStream(lua_binary_file_bytes), "main.lua");
* LuaClosure c = new LuaClosure(p, globals);
* c.call();
- * }
+ * }
+ * {@code
- * Prototype p = globals.loadPrototype(new ByteArrayInputStream(lua_binary_file_bytes), "main.lua", "b");
- * LuaClosure c = new LuaClosure(p, globals);
- * c.call();
- * }
+ *
+ *
+ * {
+ * @code
+ * Prototype p = globals.loadPrototype(new ByteArrayInputStream(lua_binary_file_bytes), "main.lua", "b");
+ * LuaClosure c = new LuaClosure(p, globals);
+ * c.call();
+ * }
+ *
*
* @see luac
* @see LoadState
@@ -71,33 +83,39 @@ public class DumpState {
/** set true to allow integer compilation */
public static boolean ALLOW_INTEGER_CASTING = false;
-
- /** format corresponding to non-number-patched lua, all numbers are floats or doubles */
- public static final int NUMBER_FORMAT_FLOATS_OR_DOUBLES = 0;
+
+ /**
+ * format corresponding to non-number-patched lua, all numbers are floats or
+ * doubles
+ */
+ public static final int NUMBER_FORMAT_FLOATS_OR_DOUBLES = 0;
/** format corresponding to non-number-patched lua, all numbers are ints */
- public static final int NUMBER_FORMAT_INTS_ONLY = 1;
-
- /** format corresponding to number-patched lua, all numbers are 32-bit (4 byte) ints */
- public static final int NUMBER_FORMAT_NUM_PATCH_INT32 = 4;
-
+ public static final int NUMBER_FORMAT_INTS_ONLY = 1;
+
+ /**
+ * format corresponding to number-patched lua, all numbers are 32-bit (4
+ * byte) ints
+ */
+ public static final int NUMBER_FORMAT_NUM_PATCH_INT32 = 4;
+
/** default number format */
public static final int NUMBER_FORMAT_DEFAULT = NUMBER_FORMAT_FLOATS_OR_DOUBLES;
// header fields
- private boolean IS_LITTLE_ENDIAN = true;
- private int NUMBER_FORMAT = NUMBER_FORMAT_DEFAULT;
- private int SIZEOF_LUA_NUMBER = 8;
- private static final int SIZEOF_INT = 4;
- private static final int SIZEOF_SIZET = 4;
+ private boolean IS_LITTLE_ENDIAN = true;
+ private int NUMBER_FORMAT = NUMBER_FORMAT_DEFAULT;
+ private int SIZEOF_LUA_NUMBER = 8;
+ private static final int SIZEOF_INT = 4;
+ private static final int SIZEOF_SIZET = 4;
private static final int SIZEOF_INSTRUCTION = 4;
DataOutputStream writer;
- boolean strip;
- int status;
+ boolean strip;
+ int status;
public DumpState(OutputStream w, boolean strip) {
- this.writer = new DataOutputStream( w );
+ this.writer = new DataOutputStream(w);
this.strip = strip;
this.status = 0;
}
@@ -107,58 +125,58 @@ public class DumpState {
}
void dumpChar(int b) throws IOException {
- writer.write( b );
+ writer.write(b);
}
void dumpInt(int x) throws IOException {
- if ( IS_LITTLE_ENDIAN ) {
- writer.writeByte(x&0xff);
- writer.writeByte((x>>8)&0xff);
- writer.writeByte((x>>16)&0xff);
- writer.writeByte((x>>24)&0xff);
+ if (IS_LITTLE_ENDIAN) {
+ writer.writeByte(x & 0xff);
+ writer.writeByte((x>>8) & 0xff);
+ writer.writeByte((x>>16) & 0xff);
+ writer.writeByte((x>>24) & 0xff);
} else {
writer.writeInt(x);
}
}
-
+
void dumpString(LuaString s) throws IOException {
final int len = s.len().toint();
- dumpInt( len+1 );
- s.write( writer, 0, len );
- writer.write( 0 );
+ dumpInt(len+1);
+ s.write(writer, 0, len);
+ writer.write(0);
}
-
+
void dumpDouble(double d) throws IOException {
long l = Double.doubleToLongBits(d);
- if ( IS_LITTLE_ENDIAN ) {
- dumpInt( (int) l );
- dumpInt( (int) (l>>32) );
+ if (IS_LITTLE_ENDIAN) {
+ dumpInt((int) l);
+ dumpInt((int) (l>>32));
} else {
writer.writeLong(l);
}
}
- void dumpCode( final Prototype f ) throws IOException {
+ void dumpCode(final Prototype f) throws IOException {
final int[] code = f.code;
int n = code.length;
- dumpInt( n );
- for ( int i=0; i {@code
- * Globals globals = JsePlatform.standardGlobals();
- * globals.load(new StringReader("print 'hello'"), "main.lua" ).call();
- * }
+ * Implements the {@link org.luaj.vm2.Globals.Compiler} interface for loading
+ * initialized chunks, which is an interface common to lua bytecode compiling
+ * and java bytecode compiling.
+ *
+ *
+ * {
+ * @code
+ * Globals globals = JsePlatform.standardGlobals();
+ * globals.load(new StringReader("print 'hello'"), "main.lua").call();
+ * }
+ *
*
* To load the LuaC compiler manually, use the install method:
- * {@code
+ *
+ *
*
* @see #install(Globals)
* @see Globals#compiler
@@ -76,10 +83,11 @@ public class LuaC extends Constants implements Globals.Compiler, Globals.Loader
/** A sharable instance of the LuaC compiler. */
public static final LuaC instance = new LuaC();
-
- /** Install the compiler so that LoadState will first
- * try to use it when handed bytes that are
- * not already a compiled lua chunk.
+
+ /**
+ * Install the compiler so that LoadState will first try to use it when
+ * handed bytes that are not already a compiled lua chunk.
+ *
* @param globals the Globals into which this is to be installed.
*/
public static void install(Globals globals) {
@@ -89,8 +97,11 @@ public class LuaC extends Constants implements Globals.Compiler, Globals.Loader
protected LuaC() {}
- /** Compile lua source into a Prototype.
- * @param stream InputStream representing the text source conforming to lua source syntax.
+ /**
+ * Compile lua source into a Prototype.
+ *
+ * @param stream InputStream representing the text source conforming to
+ * lua source syntax.
* @param chunkname String name of the chunk to use.
* @return Prototype representing the lua chunk for this source.
* @throws IOException
@@ -103,55 +114,57 @@ public class LuaC extends Constants implements Globals.Compiler, Globals.Loader
return new LuaClosure(prototype, env);
}
- /** @deprecated
- * Use Globals.load(InputString, String, String) instead,
- * or LuaC.compile(InputStream, String) and construct LuaClosure directly.
+ /**
+ * @deprecated Use Globals.load(InputString, String, String) instead, or
+ * LuaC.compile(InputStream, String) and construct LuaClosure
+ * directly.
*/
public LuaValue load(InputStream stream, String chunkname, Globals globals) throws IOException {
return new LuaClosure(compile(stream, chunkname), globals);
}
static class CompileState {
- int nCcalls = 0;
+ int nCcalls = 0;
private Hashtable strings = new Hashtable();
+
protected CompileState() {}
-
+
/** Parse the input */
- Prototype luaY_parser(InputStream z, String name) throws IOException{
+ Prototype luaY_parser(InputStream z, String name) throws IOException {
LexState lexstate = new LexState(this, z);
FuncState funcstate = new FuncState();
// lexstate.buff = buff;
lexstate.fs = funcstate;
- lexstate.setinput(this, z.read(), z, (LuaString) LuaValue.valueOf(name) );
+ lexstate.setinput(this, z.read(), z, (LuaString) LuaValue.valueOf(name));
/* main func. is always vararg */
funcstate.f = new Prototype();
funcstate.f.source = (LuaString) LuaValue.valueOf(name);
lexstate.mainfunc(funcstate);
- LuaC._assert (funcstate.prev == null);
+ LuaC._assert(funcstate.prev == null);
/* all scopes should be correctly finished */
- LuaC._assert (lexstate.dyd == null
- || (lexstate.dyd.n_actvar == 0 && lexstate.dyd.n_gt == 0 && lexstate.dyd.n_label == 0));
+ LuaC._assert(lexstate.dyd == null
+ || (lexstate.dyd.n_actvar == 0 && lexstate.dyd.n_gt == 0 && lexstate.dyd.n_label == 0));
return funcstate.f;
}
-
+
// look up and keep at most one copy of each string
public LuaString newTString(String s) {
return cachedLuaString(LuaString.valueOf(s));
}
-
+
// look up and keep at most one copy of each string
public LuaString newTString(LuaString s) {
return cachedLuaString(s);
}
-
+
public LuaString cachedLuaString(LuaString s) {
LuaString c = (LuaString) strings.get(s);
- if (c != null)
+ if (c != null)
return c;
strings.put(s, s);
return s;
}
-
+
public String pushfstring(String string) {
return string;
}
diff --git a/luaj-core/src/main/java/org/luaj/vm2/lib/BaseLib.java b/luaj-core/src/main/java/org/luaj/vm2/lib/BaseLib.java
index c9f9de40..3c5c2b65 100644
--- a/luaj-core/src/main/java/org/luaj/vm2/lib/BaseLib.java
+++ b/luaj-core/src/main/java/org/luaj/vm2/lib/BaseLib.java
@@ -34,14 +34,14 @@ import org.luaj.vm2.LuaValue;
import org.luaj.vm2.Varargs;
/**
- * Subclass of {@link LibFunction} which implements the lua basic library functions.
+ * Subclass of {@link LibFunction} which implements the lua basic library
+ * functions.
*
+ * {@code
* LuaC.install(globals);
- * }
+ * }
+ * {@code
- * Globals globals = JsePlatform.standardGlobals();
- * globals.get("print").call(LuaValue.valueOf("hello, world"));
- * }
+ *
+ *
+ * {
+ * @code
+ * Globals globals = JsePlatform.standardGlobals();
+ * globals.get("print").call(LuaValue.valueOf("hello, world"));
+ * }
+ *
* {@code
- * Globals globals = new Globals();
- * globals.load(new JseBaseLib());
- * globals.get("print").call(LuaValue.valueOf("hello, world"));
- * }
- * Doing so will ensure the library is properly initialized
- * and loaded into the globals table.
+ * For special cases where the smallest possible footprint is desired, a minimal
+ * set of libraries could be loaded directly via {@link Globals#load(LuaValue)}
+ * using code such as:
+ *
+ *
+ * {
+ * @code
+ * Globals globals = new Globals();
+ * globals.load(new JseBaseLib());
+ * globals.get("print").call(LuaValue.valueOf("hello, world"));
+ * }
+ *
+ *
+ * Doing so will ensure the library is properly initialized and loaded into the
+ * globals table.
* {@code
- * Globals globals = JsePlatform.standardGlobals();
- * System.out.println( globals.get("bit32").get("bnot").call( LuaValue.valueOf(2) ) );
- * }
+ * {@link org.luaj.vm2.lib.jse.JsePlatform#standardGlobals()} or
+ * {@link org.luaj.vm2.lib.jme.JmePlatform#standardGlobals()}
+ *
+ *
+ * {
+ * @code
+ * Globals globals = JsePlatform.standardGlobals();
+ * System.out.println(globals.get("bit32").get("bnot").call(LuaValue.valueOf(2)));
+ * }
+ *
* {@code
- * Globals globals = new Globals();
- * globals.load(new JseBaseLib());
- * globals.load(new PackageLib());
- * globals.load(new Bit32Lib());
- * System.out.println( globals.get("bit32").get("bnot").call( LuaValue.valueOf(2) ) );
- * }
+ * To instantiate and use it directly, link it into your globals table via
+ * {@link LuaValue#load(LuaValue)} using code such as:
+ *
+ *
+ * {
+ * @code
+ * Globals globals = new Globals();
+ * globals.load(new JseBaseLib());
+ * globals.load(new PackageLib());
+ * globals.load(new Bit32Lib());
+ * System.out.println(globals.get("bit32").get("bnot").call(LuaValue.valueOf(2)));
+ * }
+ *
* {@code
- * Globals globals = JsePlatform.standardGlobals();
- * System.out.println( globals.get("coroutine").get("running").call() );
- * }
+ * {@link org.luaj.vm2.lib.jse.JsePlatform#standardGlobals()} or
+ * {@link org.luaj.vm2.lib.jme.JmePlatform#standardGlobals()}
+ *
+ *
+ * {
+ * @code
+ * Globals globals = JsePlatform.standardGlobals();
+ * System.out.println(globals.get("coroutine").get("running").call());
+ * }
+ *
* {@code
- * Globals globals = new Globals();
- * globals.load(new JseBaseLib());
- * globals.load(new PackageLib());
- * globals.load(new CoroutineLib());
- * System.out.println( globals.get("coroutine").get("running").call() );
- * }
+ * To instantiate and use it directly, link it into your globals table via
+ * {@link LuaValue#load(LuaValue)} using code such as:
+ *
+ *
+ * {
+ * @code
+ * Globals globals = new Globals();
+ * globals.load(new JseBaseLib());
+ * globals.load(new PackageLib());
+ * globals.load(new CoroutineLib());
+ * System.out.println(globals.get("coroutine").get("running").call());
+ * }
+ *
* {@code
- * Globals globals = JsePlatform.debugGlobals();
- * System.out.println( globals.get("debug").get("traceback").call() );
- * }
+ *
+ *
+ * {
+ * @code
+ * Globals globals = JsePlatform.debugGlobals();
+ * System.out.println(globals.get("debug").get("traceback").call());
+ * }
+ *
* {@code
- * Globals globals = new Globals();
- * globals.load(new JseBaseLib());
- * globals.load(new PackageLib());
- * globals.load(new DebugLib());
- * System.out.println( globals.get("debug").get("traceback").call() );
- * }
+ * To instantiate and use it directly, link it into your globals table via
+ * {@link LuaValue#load(LuaValue)} using code such as:
+ *
+ *
+ * {
+ * @code
+ * Globals globals = new Globals();
+ * globals.load(new JseBaseLib());
+ * globals.load(new PackageLib());
+ * globals.load(new DebugLib());
+ * System.out.println(globals.get("debug").get("traceback").call());
+ * }
+ *
* {@code
- * Globals globals = JsePlatform.standardGlobals();
- * globals.get("io").get("write").call(LuaValue.valueOf("hello, world\n"));
- * }
- * In this example the platform-specific {@link org.luaj.vm2.lib.jse.JseIoLib} library will be loaded, which will include
- * the base functionality provided by this class, whereas the {@link org.luaj.vm2.lib.jse.JsePlatform} would load the
- * {@link org.luaj.vm2.lib.jse.JseIoLib}.
+ * {@link org.luaj.vm2.lib.jse.JsePlatform#standardGlobals()} or
+ * {@link org.luaj.vm2.lib.jme.JmePlatform#standardGlobals()}
+ *
+ *
+ * {
+ * @code
+ * Globals globals = JsePlatform.standardGlobals();
+ * globals.get("io").get("write").call(LuaValue.valueOf("hello, world\n"));
+ * }
+ *
+ *
+ * In this example the platform-specific {@link org.luaj.vm2.lib.jse.JseIoLib}
+ * library will be loaded, which will include the base functionality provided by
+ * this class, whereas the {@link org.luaj.vm2.lib.jse.JsePlatform} would load
+ * the {@link org.luaj.vm2.lib.jse.JseIoLib}.
* {@code
- * Globals globals = new Globals();
- * globals.load(new JseBaseLib());
- * globals.load(new PackageLib());
- * globals.load(new OsLib());
- * globals.get("io").get("write").call(LuaValue.valueOf("hello, world\n"));
- * }
+ * To instantiate and use it directly, link it into your globals table via
+ * {@link LuaValue#load(LuaValue)} using code such as:
+ *
+ *
+ * {
+ * @code
+ * Globals globals = new Globals();
+ * globals.load(new JseBaseLib());
+ * globals.load(new PackageLib());
+ * globals.load(new OsLib());
+ * globals.get("io").get("write").call(LuaValue.valueOf("hello, world\n"));
+ * }
+ *
*
*
* {@code
+ *
+ *
+ *
+ * The default constructor is used to instantiate the library in response to
+ * {@code require 'hyperbolic'} statement, provided it is on Java"s class
+ * path. This instance is then invoked with 2 arguments: the name supplied to
+ * require(), and the environment for this function. The library may ignore
+ * these, or use them to leave side effects in the global environment, for
+ * example. In the previous example, two functions are created, 'sinh', and
+ * 'cosh', and placed into a global table called 'hyperbolic' using the supplied
+ * 'env' argument.
*
+ * {@code
* import org.luaj.vm2.LuaValue;
* import org.luaj.vm2.lib.*;
*
@@ -85,18 +87,22 @@ import org.luaj.vm2.Varargs;
* }
* }
*}
- *}
- * The default constructor is used to instantiate the library
- * in response to {@code require 'hyperbolic'} statement,
- * provided it is on Java"s class path.
- * This instance is then invoked with 2 arguments: the name supplied to require(),
- * and the environment for this function. The library may ignore these, or use
- * them to leave side effects in the global environment, for example.
- * In the previous example, two functions are created, 'sinh', and 'cosh', and placed
- * into a global table called 'hyperbolic' using the supplied 'env' argument.
+ *}
+ * {@code
+ *
+ *
*
+ * {@code
* local t = require('hyperbolic')
* print( 't', t )
* print( 'hyperbolic', hyperbolic )
@@ -105,118 +111,147 @@ import org.luaj.vm2.Varargs;
* end
* print( 'sinh(.5)', hyperbolic.sinh(.5) )
* print( 'cosh(.5)', hyperbolic.cosh(.5) )
- * }
+ * }
+ * {@code
+ *
+ *
*
+ * {@code
* t table: 3dbbd23f
* hyperbolic table: 3dbbd23f
* k,v cosh function: 3dbbd128
* k,v sinh function: 3dbbd242
* sinh(.5) 0.5210953
* cosh(.5) 1.127626
- * }
+ * }
+ *
*
* {@code
- * Globals globals = JsePlatform.standardGlobals();
- * System.out.println( globals.get("math").get("sqrt").call( LuaValue.valueOf(2) ) );
- * }
- * When using {@link org.luaj.vm2.lib.jse.JsePlatform} as in this example,
- * the subclass {@link org.luaj.vm2.lib.jse.JseMathLib} will
- * be included, which also includes this base functionality.
+ *
+ *
+ * {
+ * @code
+ * Globals globals = JsePlatform.standardGlobals();
+ * System.out.println(globals.get("math").get("sqrt").call(LuaValue.valueOf(2)));
+ * }
+ *
+ *
+ * When using {@link org.luaj.vm2.lib.jse.JsePlatform} as in this example, the
+ * subclass {@link org.luaj.vm2.lib.jse.JseMathLib} will be included, which also
+ * includes this base functionality.
* {@code
- * Globals globals = new Globals();
- * globals.load(new JseBaseLib());
- * globals.load(new PackageLib());
- * globals.load(new MathLib());
- * System.out.println( globals.get("math").get("sqrt").call( LuaValue.valueOf(2) ) );
- * }
- * Doing so will ensure the library is properly initialized
- * and loaded into the globals table.
+ * To instantiate and use it directly, link it into your globals table via
+ * {@link LuaValue#load(LuaValue)} using code such as:
+ *
+ *
+ * {
+ * @code
+ * Globals globals = new Globals();
+ * globals.load(new JseBaseLib());
+ * globals.load(new PackageLib());
+ * globals.load(new MathLib());
+ * System.out.println(globals.get("math").get("sqrt").call(LuaValue.valueOf(2)));
+ * }
+ *
+ *
+ * Doing so will ensure the library is properly initialized and loaded into the
+ * globals table.
*
*
* {@code
- * Globals globals = JsePlatform.standardGlobals();
- * System.out.println( globals.get("os").get("time").call() );
- * }
- * In this example the platform-specific {@link org.luaj.vm2.lib.jse.JseOsLib} library will be loaded, which will include
- * the base functionality provided by this class.
+ * {@link org.luaj.vm2.lib.jse.JsePlatform#standardGlobals()} or
+ * {@link org.luaj.vm2.lib.jme.JmePlatform#standardGlobals()}
+ *
+ *
+ * {
+ * @code
+ * Globals globals = JsePlatform.standardGlobals();
+ * System.out.println(globals.get("os").get("time").call());
+ * }
+ *
+ *
+ * In this example the platform-specific {@link org.luaj.vm2.lib.jse.JseOsLib}
+ * library will be loaded, which will include the base functionality provided by
+ * this class.
* {@code
- * Globals globals = new Globals();
- * globals.load(new JseBaseLib());
- * globals.load(new PackageLib());
- * globals.load(new OsLib());
- * System.out.println( globals.get("os").get("time").call() );
- * }
+ * To instantiate and use it directly, link it into your globals table via
+ * {@link LuaValue#load(LuaValue)} using code such as:
+ *
+ *
+ * {
+ * @code
+ * Globals globals = new Globals();
+ * globals.load(new JseBaseLib());
+ * globals.load(new PackageLib());
+ * globals.load(new OsLib());
+ * System.out.println(globals.get("os").get("time").call());
+ * }
+ *
* Lua Environment Variables
- * The following variables are available to lua scrips when this library has been loaded:
+ * Lua Environment Variables
The following variables are available to
+ * lua scrips when this library has been loaded:
*
*
*
- * "package.loaded" Lua table of loaded modules.
* "package.path" Search path for lua scripts.
- * "package.preload" Lua table of uninitialized preload functions.
- * "package.searchers" Lua table of functions that search for object to load.
+ * "package.preload" Lua table of uninitialized preload
+ * functions.
+ * "package.searchers" Lua table of functions that search for
+ * object to load.
* Java Environment Variables
- * These Java environment variables affect the library behavior:
+ * Java Environment Variables
These Java environment variables affect
+ * the library behavior:
*
- *
*
- * "luaj.package.path" Initial value for "package.path". Default value is "?.lua"
+ * "luaj.package.path" Initial value for
+ * "package.path". Default value is "?.lua"
* Loading
- * Typically, this library is included as part of a call to either
- * {@link org.luaj.vm2.lib.jse.JsePlatform#standardGlobals()} or {@link org.luaj.vm2.lib.jme.JmePlatform#standardGlobals()}
- * {@code
+ *
* Loading
Typically, this library is included as part of a call to
+ * either {@link org.luaj.vm2.lib.jse.JsePlatform#standardGlobals()} or
+ * {@link org.luaj.vm2.lib.jme.JmePlatform#standardGlobals()}
+ *
+ *
+ * {@code
* Globals globals = JsePlatform.standardGlobals();
* System.out.println( globals.get("require").call"foo") );
- * }
+ * }
+ * {@code
- * Globals globals = new Globals();
- * globals.load(new JseBaseLib());
- * globals.load(new PackageLib());
- * System.out.println( globals.get("require").call("foo") );
- * }
- * Limitations
- * This library has been implemented to match as closely as possible the behavior in the corresponding library in C.
- * However, the default filesystem search semantics are different and delegated to the bas library
- * as outlined in the {@link BaseLib} and {@link org.luaj.vm2.lib.jse.JseBaseLib} documentation.
+ * To instantiate and use it directly, link it into your globals table via
+ * {@link LuaValue#load(LuaValue)} using code such as:
+ *
+ *
+ * {
+ * @code
+ * Globals globals = new Globals();
+ * globals.load(new JseBaseLib());
+ * globals.load(new PackageLib());
+ * System.out.println(globals.get("require").call("foo"));
+ * }
+ *
+ *
+ * Limitations
This library has been implemented to match as closely as
+ * possible the behavior in the corresponding library in C. However, the default
+ * filesystem search semantics are different and delegated to the bas library as
+ * outlined in the {@link BaseLib} and {@link org.luaj.vm2.lib.jse.JseBaseLib}
+ * documentation.
* "luaj.package.path", and is "?.lua" by default. */
+ /**
+ * The default value to use for package.path. This can be set with the
+ * system property "luaj.package.path", and is
+ * "?.lua" by default.
+ */
public static final String DEFAULT_LUA_PATH;
static {
String path = null;
@@ -95,40 +112,49 @@ public class PackageLib extends TwoArgFunction {
DEFAULT_LUA_PATH = path;
}
- static final LuaString _LOADED = valueOf("loaded");
- private static final LuaString _LOADLIB = valueOf("loadlib");
- static final LuaString _PRELOAD = valueOf("preload");
- static final LuaString _PATH = valueOf("path");
- static final LuaString _SEARCHPATH = valueOf("searchpath");
- static final LuaString _SEARCHERS = valueOf("searchers");
-
+ static final LuaString _LOADED = valueOf("loaded");
+ private static final LuaString _LOADLIB = valueOf("loadlib");
+ static final LuaString _PRELOAD = valueOf("preload");
+ static final LuaString _PATH = valueOf("path");
+ static final LuaString _SEARCHPATH = valueOf("searchpath");
+ static final LuaString _SEARCHERS = valueOf("searchers");
+
/** The globals that were used to load this library. */
Globals globals;
/** The table for this package. */
LuaTable package_;
-
+
/** Loader that loads from {@code preload} table if found there */
public preload_searcher preload_searcher;
-
- /** Loader that loads as a lua script using the lua path currently in {@link path} */
+
+ /**
+ * Loader that loads as a lua script using the lua path currently in
+ * {@link path}
+ */
public lua_searcher lua_searcher;
-
- /** Loader that loads as a Java class. Class must have public constructor and be a LuaValue. */
+
+ /**
+ * Loader that loads as a Java class. Class must have public constructor and
+ * be a LuaValue.
+ */
public java_searcher java_searcher;
- private static final LuaString _SENTINEL = valueOf("\u0001");
-
+ private static final LuaString _SENTINEL = valueOf("\u0001");
+
private static final String FILE_SEP = System.getProperty("file.separator");
public PackageLib() {}
- /** Perform one-time initialization on the library by adding package functions
- * to the supplied environment, and returning it as the return value.
- * It also creates the package.preload and package.loaded tables for use by
- * other libraries.
+ /**
+ * Perform one-time initialization on the library by adding package
+ * functions to the supplied environment, and returning it as the return
+ * value. It also creates the package.preload and package.loaded tables for
+ * use by other libraries.
+ *
* @param modname the module name supplied if this is loaded via 'require'.
- * @param env the environment to load into, typically a Globals instance.
+ * @param env the environment to load into, typically a Globals
+ * instance.
*/
public LuaValue call(LuaValue modname, LuaValue env) {
globals = env.checkglobals();
@@ -141,8 +167,8 @@ public class PackageLib extends TwoArgFunction {
package_.set(_SEARCHPATH, new searchpath());
LuaTable searchers = new LuaTable();
searchers.set(1, preload_searcher = new preload_searcher());
- searchers.set(2, lua_searcher = new lua_searcher());
- searchers.set(3, java_searcher = new java_searcher());
+ searchers.set(2, lua_searcher = new lua_searcher());
+ searchers.set(3, java_searcher = new java_searcher());
package_.set(_SEARCHERS, searchers);
package_.set("config", FILE_SEP + "\n;\n?\n!\n-\n");
package_.get(_LOADED).set("package", package_);
@@ -150,94 +176,100 @@ public class PackageLib extends TwoArgFunction {
globals.package_ = this;
return env;
}
-
+
/** Allow packages to mark themselves as loaded */
public void setIsLoaded(String name, LuaTable value) {
package_.get(_LOADED).set(name, value);
}
-
- /** Set the lua path used by this library instance to a new value.
- * Merely sets the value of {@link path} to be used in subsequent searches. */
- public void setLuaPath( String newLuaPath ) {
+ /**
+ * Set the lua path used by this library instance to a new value. Merely
+ * sets the value of {@link path} to be used in subsequent searches.
+ */
+ public void setLuaPath(String newLuaPath) {
package_.set(_PATH, LuaValue.valueOf(newLuaPath));
}
-
+
public String tojstring() {
return "package";
}
-
+
// ======================== Package loading =============================
/**
* require (modname)
*
- * Loads the given module. The function starts by looking into the package.loaded table
- * to determine whether modname is already loaded. If it is, then require returns the value
- * stored at package.loaded[modname]. Otherwise, it tries to find a loader for the module.
+ * Loads the given module. The function starts by looking into the
+ * package.loaded table to determine whether modname is already loaded. If
+ * it is, then require returns the value stored at package.loaded[modname].
+ * Otherwise, it tries to find a loader for the module.
*
- * To find a loader, require is guided by the package.searchers sequence.
- * By changing this sequence, we can change how require looks for a module.
- * The following explanation is based on the default configuration for package.searchers.
+ * To find a loader, require is guided by the package.searchers sequence. By
+ * changing this sequence, we can change how require looks for a module. The
+ * following explanation is based on the default configuration for
+ * package.searchers.
*
- * First require queries package.preload[modname]. If it has a value, this value
- * (which should be a function) is the loader. Otherwise require searches for a Lua loader using
- * the path stored in package.path. If that also fails, it searches for a Java loader using
- * the classpath, using the public default constructor, and casting the instance to LuaFunction.
+ * First require queries package.preload[modname]. If it has a value, this
+ * value (which should be a function) is the loader. Otherwise require
+ * searches for a Lua loader using the path stored in package.path. If that
+ * also fails, it searches for a Java loader using the classpath, using the
+ * public default constructor, and casting the instance to LuaFunction.
*
- * Once a loader is found, require calls the loader with two arguments: modname and an extra value
- * dependent on how it got the loader. If the loader came from a file, this extra value is the file name.
- * If the loader is a Java instance of LuaFunction, this extra value is the environment.
- * If the loader returns any non-nil value, require assigns the returned value to package.loaded[modname].
- * If the loader does not return a non-nil value and has not assigned any value to package.loaded[modname],
- * then require assigns true to this entry.
- * In any case, require returns the final value of package.loaded[modname].
+ * Once a loader is found, require calls the loader with two arguments:
+ * modname and an extra value dependent on how it got the loader. If the
+ * loader came from a file, this extra value is the file name. If the loader
+ * is a Java instance of LuaFunction, this extra value is the environment.
+ * If the loader returns any non-nil value, require assigns the returned
+ * value to package.loaded[modname]. If the loader does not return a non-nil
+ * value and has not assigned any value to package.loaded[modname], then
+ * require assigns true to this entry. In any case, require returns the
+ * final value of package.loaded[modname].
*
- * If there is any error loading or running the module, or if it cannot find any loader for the module,
- * then require raises an error.
+ * If there is any error loading or running the module, or if it cannot find
+ * any loader for the module, then require raises an error.
*/
public class require extends OneArgFunction {
- public LuaValue call( LuaValue arg ) {
+ public LuaValue call(LuaValue arg) {
LuaString name = arg.checkstring();
LuaValue loaded = package_.get(_LOADED);
LuaValue result = loaded.get(name);
- if ( result.toboolean() ) {
- if ( result == _SENTINEL )
- error("loop or previous error loading module '"+name+"'");
+ if (result.toboolean()) {
+ if (result == _SENTINEL)
+ error("loop or previous error loading module '" + name + "'");
return result;
}
-
+
/* else must load it; iterate over available loaders */
LuaTable tbl = package_.get(_SEARCHERS).checktable();
StringBuffer sb = new StringBuffer();
Varargs loader = null;
- for ( int i=1; true; i++ ) {
+ for (int i = 1; true; i++) {
LuaValue searcher = tbl.get(i);
- if ( searcher.isnil() ) {
- error( "module '"+name+"' not found: "+name+sb );
- }
-
- /* call loader with module name as argument */
+ if (searcher.isnil()) {
+ error("module '" + name + "' not found: " + name + sb);
+ }
+
+ /* call loader with module name as argument */
loader = searcher.invoke(name);
- if ( loader.isfunction(1) )
+ if (loader.isfunction(1))
break;
- if ( loader.isstring(1) )
- sb.append( loader.tojstring(1) );
+ if (loader.isstring(1))
+ sb.append(loader.tojstring(1));
}
-
+
// load the module using the loader
loaded.set(name, _SENTINEL);
result = loader.arg1().call(name, loader.arg(2));
- if ( ! result.isnil() )
- loaded.set( name, result );
- else if ( (result = loaded.get(name)) == _SENTINEL )
- loaded.set( name, result = LuaValue.TRUE );
+ if (!result.isnil())
+ loaded.set(name, result);
+ else if ((result = loaded.get(name)) == _SENTINEL)
+ loaded.set(name, result = LuaValue.TRUE);
return result;
}
}
public static class loadlib extends VarArgFunction {
- public Varargs invoke( Varargs args ) {
+ public Varargs invoke(Varargs args) {
args.checkstring(1);
return varargsOf(NIL, valueOf("dynamic libraries not enabled"), valueOf("absent"));
}
@@ -247,36 +279,34 @@ public class PackageLib extends TwoArgFunction {
public Varargs invoke(Varargs args) {
LuaString name = args.checkstring(1);
LuaValue val = package_.get(_PRELOAD).get(name);
- return val.isnil()?
- valueOf("\n\tno field package.preload['"+name+"']"):
- val;
+ return val.isnil()? valueOf("\n\tno field package.preload['" + name + "']"): val;
}
}
public class lua_searcher extends VarArgFunction {
public Varargs invoke(Varargs args) {
LuaString name = args.checkstring(1);
-
+
// get package path
LuaValue path = package_.get(_PATH);
- if ( ! path.isstring() )
+ if (!path.isstring())
return valueOf("package.path is not a string");
-
+
// get the searchpath function.
Varargs v = package_.get(_SEARCHPATH).invoke(varargsOf(name, path));
-
+
// Did we get a result?
if (!v.isstring(1))
return v.arg(2).tostring();
LuaString filename = v.arg1().strvalue();
-
+
// Try to load the file.
v = globals.loadfile(filename.tojstring());
- if ( v.arg1().isfunction() )
+ if (v.arg1().isfunction())
return LuaValue.varargsOf(v.arg1(), filename);
-
+
// report error
- return varargsOf(NIL, valueOf("'"+filename+"': "+v.arg(2).tojstring()));
+ return varargsOf(NIL, valueOf("'" + filename + "': " + v.arg(2).tojstring()));
}
}
@@ -286,90 +316,91 @@ public class PackageLib extends TwoArgFunction {
String path = args.checkjstring(2);
String sep = args.optjstring(3, ".");
String rep = args.optjstring(4, FILE_SEP);
-
+
// check the path elements
int e = -1;
int n = path.length();
StringBuffer sb = null;
name = name.replace(sep.charAt(0), rep.charAt(0));
while ( e < n ) {
-
+
// find next template
int b = e+1;
- e = path.indexOf(';',b);
- if ( e < 0 )
+ e = path.indexOf(';', b);
+ if (e < 0)
e = path.length();
- String template = path.substring(b,e);
-
+ String template = path.substring(b, e);
+
// create filename
int q = template.indexOf('?');
String filename = template;
- if ( q >= 0 ) {
- filename = template.substring(0,q) + name + template.substring(q+1);
+ if (q >= 0) {
+ filename = template.substring(0, q)+name+template.substring(q+1);
}
-
+
// try opening the file
InputStream is = globals.finder.findResource(filename);
if (is != null) {
- try { is.close(); } catch ( java.io.IOException ioe ) {}
+ try {
+ is.close();
+ } catch (java.io.IOException ioe) {
+ }
return valueOf(filename);
}
-
+
// report error
- if ( sb == null )
+ if (sb == null)
sb = new StringBuffer();
- sb.append( "\n\t"+filename );
+ sb.append("\n\t" + filename);
}
return varargsOf(NIL, valueOf(sb.toString()));
}
}
-
+
public class java_searcher extends VarArgFunction {
public Varargs invoke(Varargs args) {
String name = args.checkjstring(1);
- String classname = toClassname( name );
+ String classname = toClassname(name);
Class c = null;
LuaValue v = null;
try {
c = Class.forName(classname);
v = (LuaValue) c.newInstance();
if (v.isfunction())
- ((LuaFunction)v).initupvalue1(globals);
+ ((LuaFunction) v).initupvalue1(globals);
return varargsOf(v, globals);
- } catch ( ClassNotFoundException cnfe ) {
- return valueOf("\n\tno class '"+classname+"'" );
- } catch ( Exception e ) {
- return valueOf("\n\tjava load failed on '"+classname+"', "+e );
+ } catch (ClassNotFoundException cnfe) {
+ return valueOf("\n\tno class '" + classname + "'");
+ } catch (Exception e) {
+ return valueOf("\n\tjava load failed on '" + classname + "', " + e);
}
}
}
-
+
/** Convert lua filename to valid class name */
- public static final String toClassname( String filename ) {
- int n=filename.length();
- int j=n;
- if ( filename.endsWith(".lua") )
+ public static final String toClassname(String filename) {
+ int n = filename.length();
+ int j = n;
+ if (filename.endsWith(".lua"))
j -= 4;
- for ( int k=0; k {@code
- * Globals globals = JsePlatform.standardGlobals();
- * System.out.println( globals.get("string").get("upper").call( LuaValue.valueOf("abcde") ) );
- * }
+ * {@link org.luaj.vm2.lib.jse.JsePlatform#standardGlobals()} or
+ * {@link org.luaj.vm2.lib.jme.JmePlatform#standardGlobals()}
+ *
+ *
+ * {
+ * @code
+ * Globals globals = JsePlatform.standardGlobals();
+ * System.out.println(globals.get("string").get("upper").call(LuaValue.valueOf("abcde")));
+ * }
+ *
* {@code
- * Globals globals = new Globals();
- * globals.load(new JseBaseLib());
- * globals.load(new PackageLib());
- * globals.load(new JseStringLib());
- * System.out.println( globals.get("string").get("upper").call( LuaValue.valueOf("abcde") ) );
- * }
+ * To instantiate and use it directly, link it into your globals table via
+ * {@link LuaValue#load(LuaValue)} using code such as:
+ *
+ *
+ * {
+ * @code
+ * Globals globals = new Globals();
+ * globals.load(new JseBaseLib());
+ * globals.load(new PackageLib());
+ * globals.load(new JseStringLib());
+ * System.out.println(globals.get("string").get("upper").call(LuaValue.valueOf("abcde")));
+ * }
+ *
* {@code
- * Globals globals = JsePlatform.standardGlobals();
- * System.out.println( globals.get("table").get("length").call( LuaValue.tableOf() ) );
- * }
+ * {@link org.luaj.vm2.lib.jse.JsePlatform#standardGlobals()} or
+ * {@link org.luaj.vm2.lib.jme.JmePlatform#standardGlobals()}
+ *
+ *
+ * {
+ * @code
+ * Globals globals = JsePlatform.standardGlobals();
+ * System.out.println(globals.get("table").get("length").call(LuaValue.tableOf()));
+ * }
+ *
* {@code
- * Globals globals = new Globals();
- * globals.load(new JseBaseLib());
- * globals.load(new PackageLib());
- * globals.load(new TableLib());
- * System.out.println( globals.get("table").get("length").call( LuaValue.tableOf() ) );
- * }
+ * To instantiate and use it directly, link it into your globals table via
+ * {@link LuaValue#load(LuaValue)} using code such as:
+ *
+ *
+ * {
+ * @code
+ * Globals globals = new Globals();
+ * globals.load(new JseBaseLib());
+ * globals.load(new PackageLib());
+ * globals.load(new TableLib());
+ * System.out.println(globals.get("table").get("length").call(LuaValue.tableOf()));
+ * }
+ *
* {@code
- * Globals globals = JmePlatform.standardGlobals();
- * globals.get("io").get("write").call(LuaValue.valueOf("hello, world\n"));
- * }
+ *
+ *
+ * {
+ * @code
+ * Globals globals = JmePlatform.standardGlobals();
+ * globals.get("io").get("write").call(LuaValue.valueOf("hello, world\n"));
+ * }
+ *
* {@code
- * Globals globals = new Globals();
- * globals.load(new JmeBaseLib());
- * globals.load(new PackageLib());
- * globals.load(new JmeIoLib());
- * globals.get("io").get("write").call(LuaValue.valueOf("hello, world\n"));
- * }
- *
+ * {
+ * @code
+ * Globals globals = new Globals();
+ * globals.load(new JmeBaseLib());
+ * globals.load(new PackageLib());
+ * globals.load(new JmeIoLib());
+ * globals.get("io").get("write").call(LuaValue.valueOf("hello, world\n"));
+ * }
+ *
*
- *
* {@code
- * Globals global = JmePlatform.standardGlobals();
- * global.get("print").call(LuaValue.valueOf("hello, world"));
- * }
+ *
+ *
+ * {
+ * @code
+ * Globals global = JmePlatform.standardGlobals();
+ * global.get("print").call(LuaValue.valueOf("hello, world"));
+ * }
+ *
* {@code
+ *
+ *
*
+ * {@code
* LoadState.load( getClass().getResourceAsStream("main.lua"), "main.lua", globals ).call();
- * }
+ * }
+ * {@code
+ * although {@code require} could also be used:
+ *
+ *
+ *
+ * For this to succeed, the file "main.lua" must be a resource in the class
+ * path. See {@link BaseLib} for details on finding scripts using
+ * {@link ResourceFinder}.
*
+ * {@code
* globals.get("require").call(LuaValue.valueOf("main"));
- * }
- * For this to succeed, the file "main.lua" must be a resource in the class path.
- * See {@link BaseLib} for details on finding scripts using {@link ResourceFinder}.
+ * }
+ *
*
- * In addition, the {@link LuaC} compiler is installed so lua files may be loaded in their source form.
- *
*
*
*
- * The method {@link CoerceJavaToLua#coerce(Object)} looks as the type and dimesioning
- * of the argument and tries to guess the best fit for corrsponding lua scalar,
- * table, or table of tables.
+ * The method {@link CoerceJavaToLua#coerce(Object)} looks as the type and
+ * dimesioning of the argument and tries to guess the best fit for corrsponding
+ * lua scalar, table, or table of tables.
*
* @see CoerceJavaToLua#coerce(Object)
* @see org.luaj.vm2.lib.jse.LuajavaLib
*/
public class CoerceJavaToLua {
- static interface Coercion {
- public LuaValue coerce( Object javaValue );
+ static interface Coercion {
+ public LuaValue coerce(Object javaValue);
};
-
+
private static final class BoolCoercion implements Coercion {
- public LuaValue coerce( Object javaValue ) {
+ public LuaValue coerce(Object javaValue) {
Boolean b = (Boolean) javaValue;
return b.booleanValue()? LuaValue.TRUE: LuaValue.FALSE;
}
}
-
+
private static final class IntCoercion implements Coercion {
- public LuaValue coerce( Object javaValue ) {
+ public LuaValue coerce(Object javaValue) {
Number n = (Number) javaValue;
- return LuaInteger.valueOf( n.intValue() );
+ return LuaInteger.valueOf(n.intValue());
}
}
private static final class CharCoercion implements Coercion {
- public LuaValue coerce( Object javaValue ) {
+ public LuaValue coerce(Object javaValue) {
Character c = (Character) javaValue;
- return LuaInteger.valueOf( c.charValue() );
+ return LuaInteger.valueOf(c.charValue());
}
}
private static final class DoubleCoercion implements Coercion {
- public LuaValue coerce( Object javaValue ) {
+ public LuaValue coerce(Object javaValue) {
Number n = (Number) javaValue;
- return LuaDouble.valueOf( n.doubleValue() );
+ return LuaDouble.valueOf(n.doubleValue());
}
}
private static final class StringCoercion implements Coercion {
- public LuaValue coerce( Object javaValue ) {
- return LuaString.valueOf( javaValue.toString() );
+ public LuaValue coerce(Object javaValue) {
+ return LuaString.valueOf(javaValue.toString());
}
}
private static final class BytesCoercion implements Coercion {
- public LuaValue coerce( Object javaValue ) {
+ public LuaValue coerce(Object javaValue) {
return LuaValue.valueOf((byte[]) javaValue);
}
}
private static final class ClassCoercion implements Coercion {
- public LuaValue coerce( Object javaValue ) {
+ public LuaValue coerce(Object javaValue) {
return JavaClass.forClass((Class) javaValue);
}
}
@@ -128,46 +128,46 @@ public class CoerceJavaToLua {
}
private static final class LuaCoercion implements Coercion {
- public LuaValue coerce( Object javaValue ) {
+ public LuaValue coerce(Object javaValue) {
return (LuaValue) javaValue;
}
}
-
static final Map COERCIONS = Collections.synchronizedMap(new HashMap());
-
+
static {
- Coercion boolCoercion = new BoolCoercion() ;
- Coercion intCoercion = new IntCoercion() ;
- Coercion charCoercion = new CharCoercion() ;
- Coercion doubleCoercion = new DoubleCoercion() ;
- Coercion stringCoercion = new StringCoercion() ;
- Coercion bytesCoercion = new BytesCoercion() ;
- Coercion classCoercion = new ClassCoercion() ;
- COERCIONS.put( Boolean.class, boolCoercion );
- COERCIONS.put( Byte.class, intCoercion );
- COERCIONS.put( Character.class, charCoercion );
- COERCIONS.put( Short.class, intCoercion );
- COERCIONS.put( Integer.class, intCoercion );
- COERCIONS.put( Long.class, doubleCoercion );
- COERCIONS.put( Float.class, doubleCoercion );
- COERCIONS.put( Double.class, doubleCoercion );
- COERCIONS.put( String.class, stringCoercion );
- COERCIONS.put( byte[].class, bytesCoercion );
- COERCIONS.put( Class.class, classCoercion );
+ Coercion boolCoercion = new BoolCoercion();
+ Coercion intCoercion = new IntCoercion();
+ Coercion charCoercion = new CharCoercion();
+ Coercion doubleCoercion = new DoubleCoercion();
+ Coercion stringCoercion = new StringCoercion();
+ Coercion bytesCoercion = new BytesCoercion();
+ Coercion classCoercion = new ClassCoercion();
+ COERCIONS.put(Boolean.class, boolCoercion);
+ COERCIONS.put(Byte.class, intCoercion);
+ COERCIONS.put(Character.class, charCoercion);
+ COERCIONS.put(Short.class, intCoercion);
+ COERCIONS.put(Integer.class, intCoercion);
+ COERCIONS.put(Long.class, doubleCoercion);
+ COERCIONS.put(Float.class, doubleCoercion);
+ COERCIONS.put(Double.class, doubleCoercion);
+ COERCIONS.put(String.class, stringCoercion);
+ COERCIONS.put(byte[].class, bytesCoercion);
+ COERCIONS.put(Class.class, classCoercion);
}
/**
- * Coerse a Java object to a corresponding lua value.
+ * Coerse a Java object to a corresponding lua value.
*
*
* {@code
- * Globals globals = JsePlatform.standardGlobals();
- * globals.get("print").call(LuaValue.valueOf("hello, world"));
- * }
+ *
+ *
+ * {
+ * @code
+ * Globals globals = JsePlatform.standardGlobals();
+ * globals.get("print").call(LuaValue.valueOf("hello, world"));
+ * }
+ *
* {@code
- * Globals globals = new Globals();
- * globals.load(new JseBaseLib());
- * globals.get("print").call(LuaValue.valueOf("hello, world"));
- * }
- *
+ * {
+ * @code
+ * Globals globals = new Globals();
+ * globals.load(new JseBaseLib());
+ * globals.get("print").call(LuaValue.valueOf("hello, world"));
+ * }
+ *
+ * {@code
- * Globals globals = JsePlatform.standardGlobals();
- * globals.get("io").get("write").call(LuaValue.valueOf("hello, world\n"));
- * }
+ *
+ *
+ * {
+ * @code
+ * Globals globals = JsePlatform.standardGlobals();
+ * globals.get("io").get("write").call(LuaValue.valueOf("hello, world\n"));
+ * }
+ *
* {@code
- * Globals globals = new Globals();
- * globals.load(new JseBaseLib());
- * globals.load(new PackageLib());
- * globals.load(new JseIoLib());
- * globals.get("io").get("write").call(LuaValue.valueOf("hello, world\n"));
- * }
- *
+ * {
+ * @code
+ * Globals globals = new Globals();
+ * globals.load(new JseBaseLib());
+ * globals.load(new PackageLib());
+ * globals.load(new JseIoLib());
+ * globals.get("io").get("write").call(LuaValue.valueOf("hello, world\n"));
+ * }
+ *
* {@code
- * Globals globals = JsePlatform.standardGlobals();
- * System.out.println( globals.get("math").get("sqrt").call( LuaValue.valueOf(2) ) );
- * }
+ *
+ *
+ * {
+ * @code
+ * Globals globals = JsePlatform.standardGlobals();
+ * System.out.println(globals.get("math").get("sqrt").call(LuaValue.valueOf(2)));
+ * }
+ *
* {@code
- * Globals globals = new Globals();
- * globals.load(new JseBaseLib());
- * globals.load(new PackageLib());
- * globals.load(new JseMathLib());
- * System.out.println( globals.get("math").get("sqrt").call( LuaValue.valueOf(2) ) );
- * }
- *
+ * {
+ * @code
+ * Globals globals = new Globals();
+ * globals.load(new JseBaseLib());
+ * globals.load(new PackageLib());
+ * globals.load(new JseMathLib());
+ * System.out.println(globals.get("math").get("sqrt").call(LuaValue.valueOf(2)));
+ * }
+ *
*
*
* {@code
- * Globals globals = JsePlatform.standardGlobals();
- * System.out.println( globals.get("os").get("time").call() );
- * }
+ *
+ *
+ * {
+ * @code
+ * Globals globals = JsePlatform.standardGlobals();
+ * System.out.println(globals.get("os").get("time").call());
+ * }
+ *
* {@code
- * Globals globals = new Globals();
- * globals.load(new JseBaseLib());
- * globals.load(new PackageLib());
- * globals.load(new JseOsLib());
- * System.out.println( globals.get("os").get("time").call() );
- * }
- *
+ * {
+ * @code
+ * Globals globals = new Globals();
+ * globals.load(new JseBaseLib());
+ * globals.load(new PackageLib());
+ * globals.load(new JseOsLib());
+ * System.out.println(globals.get("os").get("time").call());
+ * }
+ *
* {@code
- * Globals globals = JsePlatform.standardGlobals();
- * globals.get("print").call(LuaValue.valueOf("hello, world"));
- * }
+ *
+ *
+ * {
+ * @code
+ * Globals globals = JsePlatform.standardGlobals();
+ * globals.get("print").call(LuaValue.valueOf("hello, world"));
+ * }
+ *
* {@code
+ *
+ *
*
+ * {@code
* globals.load( new FileInputStream("main.lua"), "main.lua" ).call();
- * }
+ * }
+ * {@code
+ *
+ *
+ *
+ * For this to succeed, the file "main.lua" must be in the current directory or
+ * a resource. See {@link org.luaj.vm2.lib.jse.JseBaseLib} for details on
+ * finding scripts using {@link ResourceFinder}.
*
+ * {@code
* globals.get("require").call(LuaValue.valueOf("main"));
- * }
- * For this to succeed, the file "main.lua" must be in the current directory or a resource.
- * See {@link org.luaj.vm2.lib.jse.JseBaseLib} for details on finding scripts using {@link ResourceFinder}.
+ * }
+ *
*
- * In addition, the {@link LuaC} compiler is installed so lua files may be loaded in their source form.
+ * In addition, the {@link LuaC} compiler is installed so lua files may be
+ * loaded in their source form.
* {@code
- * Globals globals = JsePlatform.standardGlobals();
- * System.out.println( globals.get("luajava").get("bindClass").call( LuaValue.valueOf("java.lang.System") ).invokeMethod("currentTimeMillis") );
- * }
+ *
+ *
+ * {
+ * @code
+ * Globals globals = JsePlatform.standardGlobals();
+ * System.out.println(globals.get("luajava").get("bindClass").call(LuaValue.valueOf("java.lang.System"))
+ * .invokeMethod("currentTimeMillis"));
+ * }
+ *
* {@code
- * Globals globals = new Globals();
- * globals.load(new JseBaseLib());
- * globals.load(new PackageLib());
- * globals.load(new LuajavaLib());
- * globals.load(
- * "sys = luajava.bindClass('java.lang.System')\n"+
- * "print ( sys:currentTimeMillis() )\n", "main.lua" ).call();
- * }
+ * To instantiate and use it directly, link it into your globals table via
+ * {@link Globals#load} using code such as:
+ *
+ *
+ * {
+ * @code
+ * Globals globals = new Globals();
+ * globals.load(new JseBaseLib());
+ * globals.load(new PackageLib());
+ * globals.load(new LuajavaLib());
+ * globals.load("sys = luajava.bindClass('java.lang.System')\n" + "print ( sys:currentTimeMillis() )\n", "main.lua")
+ * .call();
+ * }
+ *
* {@code
+ * To override the default compiling behavior with {@link LuaJC} lua-to-java
+ * bytecode compiler, install it before undumping code, for example:
+ *
+ *
*
+ * {@code
* LuaValue globals = JsePlatform.standardGlobals();
* LuaJC.install(globals);
* LuaValue chunk = globals.load( "print('hello, world'), "main.lua");
* System.out.println(chunk.isclosure()); // Will be false when LuaJC is working.
* chunk.call();
- * }
+ * }
+ *