•Runtime upgrade to Java 8 or newer.

•Feature: Support Java 21 VirtualThread
Fix #66 : Broken license link.
2024-11-08 11:06:07 +08:00 · 2020-04-01 19:36:00 +03:00 · 2020-04-01 19:31:39 +03:00 · 2019-12-29 16:46:58 +02:00 · 2019-12-16 15:31:13 +02:00 · 2019-12-15 20:39:26 +02:00
50 changed files with 3240 additions and 2774 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,8 +1,8 @@
-bin
-target
-build
-lib
-jit
+bin/
+target/
+build/
+lib/
+jit/
 *.ser
 *.gz
 *.jar
--- a/21
+++ b/21
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2007 LuaJ. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
--- a/README.html
+++ b/README.html
@@ -1,27 +1,24 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
-<html>
+# This is a fork!
+<div style="border: 1px dotted red; margin: 1.em 0.5em; font-weight: bold; color: red;">
+This repository has been forked from the original CVS sources of Luaj.
+The commit history has been converted to make sure that the original work of
+James Roseborough and Ian Farmer is not lost.
+Unfortunately, I was not able to contact either James or Ian to hand over
+ownership of the Github organization/repo as I have originally intended to.
+The community however seems interested enough to continue work on the original
+sources and therefore I have decided to make sure that any useful pull requests
+that may add some value to the original code base shall be merged in from now
+on.<br>
+-- Benjamin P. Jung, Jan. 26th 2018
+</div>

-<head>
-<title>Getting Started with LuaJ</title>
-<link rel="stylesheet" type="text/css" href="http://www.lua.org/lua.css">
-<META HTTP-EQUIV="content-type" CONTENT="text/html; charset=iso-8859-1">
-</head>
-
-<body>
-
-<hr>
-<h1>
-<a href="README.html"><img src="http://sourceforge.net/dbimage.php?id=196139" alt="" border="0"></a>
-
-Getting Started with LuaJ
-
-</h1>
-James Roseborough, Ian Farmer, Version 3.0.1
+<h1>Getting Started with LuaJ</h1>
+James Roseborough, Ian Farmer, Version 3.0.2
 <p>
 <small>
 Copyright &copy; 2009-2014 Luaj.org.
 Freely available under the terms of the
-<a href="http://sourceforge.net/dbimage.php?id=196142">Luaj license</a>.
+<a href="LICENSE">Luaj license</a>.
 </small>
 <hr>
 <p>
@@ -120,7 +117,7 @@ in comparison with the standard C distribution.
 	<td>16.794</td>
 	<td>11.274</td>
 	<td>Java</td>
-	<td>java -cp luaj-jse-3.0.1.jar;bcel-5.2.jar lua <b>-b</b> fannkuch.lua 10</td></tr>
+	<td>java -cp luaj-jse-3.0.2.jar;bcel-5.2.jar lua <b>-b</b> fannkuch.lua 10</td></tr>
 <tr valign="top">
 	<td></td>
 	<td></td>
@@ -130,7 +127,7 @@ in comparison with the standard C distribution.
 	<td>36.894</td>
 	<td>15.163</td>
 	<td></td>
-	<td>java -cp luaj-jse-3.0.1.jar lua -n fannkuch.lua 10</td></tr>
+	<td>java -cp luaj-jse-3.0.2.jar lua -n fannkuch.lua 10</td></tr>
 <tr valign="top">
 	<td>lua</td>
 	<td>5.1.4</td>
@@ -186,7 +183,7 @@ It is also faster than Java-lua implementations Jill, Kahlua, and Mochalua for a
 From the main distribution directory line type:

 <pre>
-	java -cp lib/luaj-jse-3.0.1.jar lua examples/lua/hello.lua
+	java -cp luaj-jse-3.0.2.jar lua examples/lua/hello.lua
 </pre>

 <p>
@@ -198,7 +195,7 @@ You should see the following output:
 To see how luaj can be used to acccess most Java API's including swing, try:

 <pre>
-	java -cp lib/luaj-jse-3.0.1.jar lua examples/lua/swingapp.lua
+	java -cp luaj-jse-3.0.2.jar lua examples/lua/swingapp.lua
 </pre>

 <p>
@@ -213,8 +210,8 @@ Links to sources:<pre>
 From the main distribution directory line type:

 <pre>
-	java -cp lib/luaj-jse-3.0.1.jar luac examples/lua/hello.lua
-	java -cp lib/luaj-jse-3.0.1.jar lua luac.out
+	java -cp luaj-jse-3.0.2.jar luac examples/lua/hello.lua
+	java -cp luaj-jse-3.0.2.jar lua luac.out
 </pre>

 <p>
@@ -228,8 +225,8 @@ Luaj can compile lua sources or binaries directly to java bytecode if the bcel l

 <pre>
 	ant bcel-lib
-	java -cp &quot;lib/luaj-jse-3.0.1.jar;lib/bcel-5.2.jar&quot; luajc -s examples/lua -d . hello.lua
-	java -cp &quot;lib/luaj-jse-3.0.1.jar;.&quot; lua -l hello
+	java -cp &quot;luaj-jse-3.0.2.jar;lib/bcel-5.2.jar&quot; luajc -s examples/lua -d . hello.lua
+	java -cp &quot;luaj-jse-3.0.2.jar;.&quot; lua -l hello
 </pre>

 <p>
@@ -240,7 +237,7 @@ but the compiled classes must be in the class path at runtime, unless runtime ji
 <p>
 Lua scripts can also be run directly in this mode without precompiling using the <em>lua</em> command with the <b><em>-b</em></b> option and providing the <em>bcel</em> library in the class path:
 <pre>
-	java -cp &quot;lib/luaj-jse-3.0.1.jar;lib/bcel-5.2.jar&quot; lua -b examples/lua/hello.lua
+	java -cp &quot;luaj-jse-3.0.2.jar;lib/bcel-5.2.jar&quot; lua -b examples/lua/hello.lua
 </pre>


@@ -284,7 +281,7 @@ A simple example may be found in
 </pre>

 <p>
-You must include the library <b>lib/luaj-jse-3.0.1.jar</b> in your class path.
+You must include the library <b>luaj-jse-3.0.2.jar</b> in your class path.

 <h2>Run a script in a MIDlet</h2>

@@ -311,7 +308,7 @@ A simple example may be found in
 </pre>

 <p>
-You must include the library <b>lib/luaj-jme-3.0.1.jar</b> in your midlet jar.
+You must include the library <b>luaj-jme-3.0.2.jar</b> in your midlet jar.

 <p>
 An ant script to build and run the midlet is in
@@ -341,7 +338,7 @@ You can also look up the engine by language "lua" or mimetypes "text/lua" or "ap
 All standard aspects of script engines including compiled statements are supported.

 <p>
-You must include the library <b>lib/luaj-jse-3.0.1.jar</b> in your class path.
+You must include the library <b>luaj-jse-3.0.2.jar</b> in your class path.

 <p>
 A working example may be found in
@@ -352,8 +349,8 @@ A working example may be found in
 To compile and run it using Java 1.6 or higher:

 <pre>
-	javac -cp lib/luaj-jse-3.0.1.jar examples/jse/ScriptEngineSample.java
-	java -cp &quot;lib/luaj-jse-3.0.1.jar;examples/jse&quot; ScriptEngineSample
+	javac -cp luaj-jse-3.0.2.jar examples/jse/ScriptEngineSample.java
+	java -cp &quot;luaj-jse-3.0.2.jar;examples/jse&quot; ScriptEngineSample
 </pre>

 <h2>Excluding the lua bytecode compiler</h2>
@@ -415,7 +412,7 @@ and the math operations include all those supported by Java SE.
 Android applications should use the JsePlatform, and can include the <a href="#luajava">Luajava</a> library 
 to simplify access to underlying Android APIs.  
 A specialized Globals.finder should be provided to find scripts and data for loading.
-See <a href="examples/android/src/android/LuajView">examples/android/src/android/LuajView</a>
+See <a href="examples/android/src/android/LuajView.java">examples/android/src/android/LuajView.java</a>
 for an example that loads from the "res" Android project directory.
 The ant build script is <a href="examples/android/build.xml">examples/android/build.xml</a>.  

@@ -593,7 +590,7 @@ The following lua script will open a swing frame on Java SE:
 See a longer sample in <em>examples/lua/swingapp.lua</em> for details, including a simple animation loop, rendering graphics, mouse and key handling, and image loading. 
 Or try running it using: 
 <pre>
-	java -cp lib/luaj-jse-3.0.1.jar lua examples/lua/swingapp.lua
+	java -cp luaj-jse-3.0.2.jar lua examples/lua/swingapp.lua
 </pre>

 <p>
@@ -842,7 +839,7 @@ For JSE projects, add this dependency for the luaj-jse jar:
   &lt;dependency&gt;
      &lt;groupId&gt;org.luaj&lt;/groupId&gt;
      &lt;artifactId&gt;luaj-jse&lt;/artifactId&gt;
-      &lt;version&gt;3.0.1&lt;/version&gt;
+      &lt;version&gt;3.0.2&lt;/version&gt;
   &lt;/dependency&gt;	
 </pre>
 while for JME projects, use the luaj-jme jar:
@@ -850,7 +847,7 @@ while for JME projects, use the luaj-jme jar:
   &lt;dependency&gt;
      &lt;groupId&gt;org.luaj&lt;/groupId&gt;
      &lt;artifactId&gt;luaj-jme&lt;/artifactId&gt;
-      &lt;version&gt;3.0.1&lt;/version&gt;
+      &lt;version&gt;3.0.2&lt;/version&gt;
   &lt;/dependency&gt;	
 </pre>

@@ -880,7 +877,7 @@ Unit test scripts can be found in these locations
 	test/lua/*.lua
 	test/lua/errors/*.lua
 	test/lua/perf/*.lua
-	test/lua/luaj3.0.1-tests.zip
+	test/lua/luaj3.0.2-tests.zip
 </pre>

 <h2>Code coverage</h2>
@@ -930,7 +927,7 @@ Files are no longer hosted at LuaForge.
 <li>Enhance javadoc, put it <a href="docs/api/index.html">in distribution</a> 
 and at <a href="http://luaj.sourceforge.net/api/2.0/index.html">http://luaj.sourceforge.net/api/2.0/</a></li>
 <li>Major refactor of luajava type coercion logic, improve method selection.</li> 
-<li>Add lib/luaj-sources-2.0.2.jar for easier integration into an IDE such as Netbeans </li>
+<li>Add luaj-sources-2.0.2.jar for easier integration into an IDE such as Netbeans </li>

 <tr valign="top"><td>&nbsp;&nbsp;<b>2.0.3</b></td><td><ul>
 <li>Improve coroutine state logic including let unreferenced coroutines be garbage collected </li>
@@ -1017,6 +1014,16 @@ and at <a href="http://luaj.sourceforge.net/api/2.0/index.html">http://luaj.sour
 <li>Move online docs to <a href="http://luaj.org/luaj/3.0/api/index.html">http://luaj.org/luaj/3.0/api/</a></li>
 <li>Fix os.time() conversions for pm times.</li>

+<tr valign="top"><td>&nbsp;&nbsp;<b>3.0.2</b></td><td><ul>
+<li>Fix JsePlatform.luaMain() to provide an "arg" table in the chunk's environment.</li>
+<li>Let JsePlatform.luaMain() return values returned by the main chunk.</li>
+<li>Add synchronization to CoerceJavaToLua.COERCIONS map.</li>
+
+</ul></td></tr>
+<tr valign="top"><td>&nbsp;&nbsp;<b>3.1.0</b></td><td><ul>
+<li>Runtime upgrade to Java 8 or newer.</li>
+<li>Feature: Support Java 21 VirtualThread</li>
+
 </ul></td></tr>
 </table></td></tr></table>

--- a/build-libs.xml
+++ b/build-libs.xml
@@ -14,7 +14,7 @@
 		<attribute name="jars" default="**/*.jar"/>
 		<sequential>
 			<mkdir dir="lib"/>
-			<get src="http://luaj.sourceforge.net/lib/@{zipname}.tar.gz" 
+			<get src="https://luaj.sourceforge.net/lib/@{zipname}.tar.gz" 
 				dest="lib/@{zipname}.tar.gz"/>
 			<gunzip src="lib/@{zipname}.tar.gz" dest="lib/@{zipname}.tar"/>
 			<untar src="lib/@{zipname}.tar" dest="lib" overwrite="true">
--- a/build.xml
+++ b/build.xml
@@ -81,18 +81,24 @@
 			<pathelement path="lib/midpapi20.jar"/>
 			<pathelement path="lib/mmapi.jar"/>
 		</path>
-		<javac destdir="build/jme/classes" encoding="utf-8" source="1.3" target="1.2" bootclasspathref="wtk-libs"
-			srcdir="build/jme/src"/>
-		<javac destdir="build/jse/classes" encoding="utf-8" source="1.3" target="1.3"
+		<javac includeantruntime="false" destdir="build/jme/classes" encoding="utf-8" source="1.8" target="1.8"
+		    debug="on"
+			srcdir="build/jme/src">
+			<classpath refid="wtk-libs"/>
+		</javac>
+		<javac includeantruntime="false" destdir="build/jse/classes" encoding="utf-8" source="1.8" target="1.8"
 			classpath="lib/bcel-5.2.jar"
+			debug="on"
 			srcdir="build/jse/src"
 			excludes="**/script/*,**/Lua2Java*,**/server/*,lua*"/>
-		<javac destdir="build/jse/classes" encoding="utf-8" source="1.5" target="1.5"
+		<javac includeantruntime="false" destdir="build/jse/classes" encoding="utf-8" source="1.8" target="1.8"
 			classpath="build/jse/classes"
+			debug="on"
 			srcdir="build/jse/src"
 			includes="**/script/*,**/Lua2Java*,**/server/*"/>
-		<javac destdir="build/jse/classes" encoding="utf-8" source="1.3" target="1.3"
+		<javac includeantruntime="false" destdir="build/jse/classes" encoding="utf-8" source="1.8" target="1.8"
 			classpath="build/jse/classes"
+			debug="on"
 			srcdir="build/jse/src"
 			includes="lua*"/>
 	</target>
--- a/examples/jse/SampleApplet.java
+++ b/examples/jse/SampleApplet.java
@@ -11,13 +11,13 @@ import org.luaj.vm2.lib.Bit32Lib;
 import org.luaj.vm2.lib.CoroutineLib;
 import org.luaj.vm2.lib.PackageLib;
 import org.luaj.vm2.lib.ResourceFinder;
-import org.luaj.vm2.lib.StringLib;
 import org.luaj.vm2.lib.TableLib;
 import org.luaj.vm2.lib.jse.CoerceJavaToLua;
 import org.luaj.vm2.lib.jse.JseBaseLib;
 import org.luaj.vm2.lib.jse.JseIoLib;
 import org.luaj.vm2.lib.jse.JseMathLib;
 import org.luaj.vm2.lib.jse.JseOsLib;
+import org.luaj.vm2.lib.jse.JseStringLib;
 import org.luaj.vm2.lib.jse.LuajavaLib;

 /**
@@ -76,7 +76,7 @@ public class SampleApplet extends Applet implements ResourceFinder {
 		globals.load(new PackageLib());
 		globals.load(new Bit32Lib());
 		globals.load(new TableLib());
-		globals.load(new StringLib());
+		globals.load(new JseStringLib());
 		globals.load(new CoroutineLib());
 		globals.load(new JseMathLib());
 		globals.load(new JseIoLib());
--- a/examples/jse/SampleSandboxed.java
+++ b/examples/jse/SampleSandboxed.java
@@ -1,7 +1,21 @@
-import org.luaj.vm2.*;
+import org.luaj.vm2.Globals;
+import org.luaj.vm2.LoadState;
+import org.luaj.vm2.LuaBoolean;
+import org.luaj.vm2.LuaString;
+import org.luaj.vm2.LuaTable;
+import org.luaj.vm2.LuaThread;
+import org.luaj.vm2.LuaValue;
+import org.luaj.vm2.Varargs;
 import org.luaj.vm2.compiler.LuaC;
-import org.luaj.vm2.lib.*;
-import org.luaj.vm2.lib.jse.*;
+import org.luaj.vm2.lib.Bit32Lib;
+import org.luaj.vm2.lib.DebugLib;
+import org.luaj.vm2.lib.PackageLib;
+import org.luaj.vm2.lib.TableLib;
+import org.luaj.vm2.lib.TwoArgFunction;
+import org.luaj.vm2.lib.ZeroArgFunction;
+import org.luaj.vm2.lib.jse.JseBaseLib;
+import org.luaj.vm2.lib.jse.JseMathLib;
+import org.luaj.vm2.lib.jse.JseStringLib;

 /** Simple program that illustrates basic sand-boxing of client scripts
 * in a server environment.
@@ -29,7 +43,7 @@ public class SampleSandboxed {
 		server_globals = new Globals();
 		server_globals.load(new JseBaseLib());
 		server_globals.load(new PackageLib());
-		server_globals.load(new StringLib());
+		server_globals.load(new JseStringLib());

 		// To load scripts, we occasionally need a math library in addition to compiler support.
 		// To limit scripts using the debug library, they must be closures, so we only install LuaC.
@@ -82,7 +96,7 @@ public class SampleSandboxed {
 		user_globals.load(new PackageLib());
 		user_globals.load(new Bit32Lib());
 		user_globals.load(new TableLib());
-		user_globals.load(new StringLib());
+		user_globals.load(new JseStringLib());
 		user_globals.load(new JseMathLib());

 		// This library is dangerous as it gives unfettered access to the
--- a/src/core/org/luaj/vm2/LoadState.java
+++ b/src/core/org/luaj/vm2/LoadState.java
@@ -155,7 +155,6 @@ public class LoadState {
 	private static final LuaValue[]     NOVALUES    = {};
 	private static final Prototype[] NOPROTOS    = {};
 	private static final LocVars[]   NOLOCVARS   = {};
-	private static final LuaString[]  NOSTRVALUES = {};
 	private static final Upvaldesc[]  NOUPVALDESCS = {};
 	private static final int[]       NOINTS      = {};
 	
--- a/src/core/org/luaj/vm2/Lua.java
+++ b/src/core/org/luaj/vm2/Lua.java
@@ -80,7 +80,6 @@ public class Lua {
 	public static final int POS_Bx		= POS_C;
 	public static final int POS_Ax		= POS_A;

-
 	public static final int MAX_OP          = ((1<<SIZE_OP)-1);
 	public static final int MAXARG_A        = ((1<<SIZE_A)-1);
 	public static final int MAXARG_B        = ((1<<SIZE_B)-1);
@@ -94,6 +93,7 @@ public class Lua {
 	public static final int MASK_B  = ((1<<SIZE_B)-1)<<POS_B;
 	public static final int MASK_C  = ((1<<SIZE_C)-1)<<POS_C;
 	public static final int MASK_Bx = ((1<<SIZE_Bx)-1)<<POS_Bx;
+	public static final int MASK_Ax = ((1<<SIZE_Ax)-1)<<POS_Ax;

 	public static final int MASK_NOT_OP = ~MASK_OP;
 	public static final int MASK_NOT_A  = ~MASK_A;
@@ -208,7 +208,7 @@ public class Lua {

 	public static final int OP_CONCAT = 22; /*	A B C	R(A) := R(B).. ... ..R(C)			*/

-	public static final int OP_JMP = 23; /*	sBx	pc+=sBx					*/
+	public static final int OP_JMP = 23; /*	A sBx	pc+=sBx; if (A) close all upvalues >= R(A - 1)	*/
 	public static final int OP_EQ = 24; /*	A B C	if ((RK(B) == RK(C)) ~= A) then pc++		*/
 	public static final int OP_LT = 25; /*	A B C	if ((RK(B) <  RK(C)) ~= A) then pc++  		*/
 	public static final int OP_LE = 26; /*	A B C	if ((RK(B) <= RK(C)) ~= A) then pc++  		*/
--- a/src/core/org/luaj/vm2/LuaClosure.java
+++ b/src/core/org/luaj/vm2/LuaClosure.java
@@ -21,6 +21,8 @@
 ******************************************************************************/
 package org.luaj.vm2;

+import org.luaj.vm2.lib.DebugLib.CallFrame;
+
 /**
 * Extension of {@link LuaFunction} which executes lua bytecode.
 * <p>
@@ -97,15 +99,20 @@ public class LuaClosure extends LuaFunction {
 	 */
 	public LuaClosure(Prototype p, LuaValue env) {
 		this.p = p;
+		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);
 		}
-		globals = env instanceof Globals? (Globals) env: null;	
 	}

+	
 	public boolean isclosure() {
 		return true;
 	}
@@ -118,26 +125,24 @@ public class LuaClosure extends LuaFunction {
 		return this;
 	}
 	
-	public LuaValue getmetatable() { 
-		return s_metatable; 
-	}
-	
 	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 = new LuaValue[p.maxstacksize];
-		for (int i = 0; i < p.numparams; ++i )
-			stack[i] = NIL;
+		LuaValue[] stack = getNewStack();
 		return execute(stack,NONE).arg1();
 	}

 	public final LuaValue call(LuaValue arg) {
-		LuaValue[] stack = new LuaValue[p.maxstacksize];
-		System.arraycopy(NILS, 0, stack, 0, p.maxstacksize);
-		for (int i = 1; i < p.numparams; ++i )
-			stack[i] = NIL;
+		LuaValue[] stack = getNewStack();
 		switch ( p.numparams ) {
 		default: stack[0]=arg; return execute(stack,NONE).arg1();
 		case 0: return execute(stack,arg).arg1();
@@ -145,9 +150,7 @@ public class LuaClosure extends LuaFunction {
 	}
 	
 	public final LuaValue call(LuaValue arg1, LuaValue arg2) {
-		LuaValue[] stack = new LuaValue[p.maxstacksize];
-		for (int i = 2; i < p.numparams; ++i )
-			stack[i] = NIL;
+		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();
@@ -156,9 +159,7 @@ public class LuaClosure extends LuaFunction {
 	}

 	public final LuaValue call(LuaValue arg1, LuaValue arg2, LuaValue arg3) {
-		LuaValue[] stack = new LuaValue[p.maxstacksize];
-		for (int i = 3; i < p.numparams; ++i )
-			stack[i] = NIL;
+		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();
@@ -172,7 +173,7 @@ public class LuaClosure extends LuaFunction {
 	}
 	
 	public final Varargs onInvoke(Varargs varargs) {
-		LuaValue[] stack = new LuaValue[p.maxstacksize];
+		LuaValue[] stack = getNewStack();
 		for ( int i=0; i<p.numparams; i++ )
 			stack[i] = varargs.arg(i+1);
 		return execute(stack,p.is_vararg!=0? varargs.subargs(p.numparams+1): NONE);
@@ -215,6 +216,17 @@ public class LuaClosure extends LuaFunction {
 					stack[a] = k[i>>>14];
 					continue;
 					
+				case Lua.OP_LOADKX:/*	A 	R(A) := Kst(extra arg)					*/
+					++pc;
+					i = code[pc];
+					if ((i & 0x3f) != Lua.OP_EXTRAARG) {
+						int op = i & 0x3f;
+						throw new LuaError("OP_EXTRAARG expected after OP_LOADKX, got " +
+							(op < Print.OPNAMES.length - 1 ? Print.OPNAMES[op] : "UNKNOWN_OP_" + op));
+					}
+					stack[a] = k[i>>>6];
+					continue;
+					
 				case Lua.OP_LOADBOOL:/*	A B C	R(A):= (Bool)B: if (C) pc++			*/
 	                stack[a] = (i>>>23!=0)? LuaValue.TRUE: LuaValue.FALSE;
 	                if ((i&(0x1ff<<14)) != 0)
@@ -302,7 +314,7 @@ public class LuaClosure extends LuaFunction {
 						if ( c > b+1 ) {
 							Buffer sb = stack[c].buffer();
 							while ( --c>=b )
-								sb = stack[c].concat(sb);
+								sb.concatTo(stack[c]);
 							stack[a] = sb.value();
 						} else {
 							stack[a] = stack[c-1].concat(stack[c]);
@@ -310,7 +322,7 @@ public class LuaClosure extends LuaFunction {
 					}
 					continue;
 					
-				case Lua.OP_JMP: /*	sBx	pc+=sBx					*/
+				case Lua.OP_JMP: /*	A sBx	pc+=sBx; if (A) close all upvalues >= R(A - 1)	*/
 					pc  += (i>>>14)-0x1ffff;
 					if (a > 0) {
 						for (--a, b = openups.length; --b>=0; )
@@ -405,7 +417,7 @@ public class LuaClosure extends LuaFunction {
 					{
 			            LuaValue limit = stack[a + 1];
 						LuaValue step  = stack[a + 2];
-						LuaValue idx   = step.add(stack[a]);
+						LuaValue idx   = stack[a].add(step);
 			            if (step.gt_b(0)? idx.lteq_b(limit): idx.gteq_b(limit)) {
 		                    stack[a] = idx;
 		                    stack[a + 3] = idx;
@@ -537,8 +549,24 @@ public class LuaClosure extends LuaFunction {
 	}

 	private void processErrorHooks(LuaError le, Prototype p, int pc) {
-		le.fileline = (p.source != null? p.source.tojstring(): "?") + ":" 
-			+ (p.lineinfo != null && pc >= 0 && pc < p.lineinfo.length? String.valueOf(p.lineinfo[pc]): "?");
+		String file = "?";
+		int line = -1;
+		{
+			CallFrame frame = null;
+			if (globals != null && globals.debuglib != null) {
+				frame = globals.debuglib.getCallFrame(le.level);
+				if (frame != null) {
+					String src = frame.shortsource();
+					file = src != null ? src : "?";
+					line = frame.currentline();
+				}
+			}
+			if (frame == null) {
+				file = p.source != null? p.source.tojstring(): "?";
+				line = p.lineinfo != null && pc >= 0 && pc < p.lineinfo.length ? p.lineinfo[pc] : -1;
+			}
+		}
+		le.fileline = file + ":" + line;
 		le.traceback = errorHook(le.getMessage(), le.level);
 	}
 	
--- a/src/core/org/luaj/vm2/LuaDouble.java
+++ b/src/core/org/luaj/vm2/LuaDouble.java
@@ -177,7 +177,14 @@ public class LuaDouble extends LuaNumber {
 	 * @see #dmod_d(double, double)
 	 */
 	public static LuaValue dmod(double lhs, double rhs) {
-		return rhs!=0? valueOf( lhs-rhs*Math.floor(lhs/rhs) ): 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);
+		}
+		if (rhs == Double.NEGATIVE_INFINITY) {
+			return lhs > 0 ? NEGINF : valueOf(lhs);
+		}
+		return valueOf( lhs-rhs*Math.floor(lhs/rhs) );
 	}

 	/** Take modulo for double numbers according to lua math, and return a double result.
@@ -188,32 +195,39 @@ public class LuaDouble extends LuaNumber {
 	 * @see #dmod(double, double)
 	 */
 	public static double dmod_d(double lhs, double rhs) {
-		return rhs!=0? lhs-rhs*Math.floor(lhs/rhs): 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;
+		}
+		if (rhs == Double.NEGATIVE_INFINITY) {
+			return lhs > 0 ? Double.NEGATIVE_INFINITY : lhs;
+		}
+		return lhs-rhs*Math.floor(lhs/rhs);
 	}

 	// relational operators
-	public LuaValue   lt( LuaValue rhs )         { return rhs.gt_b(v)? LuaValue.TRUE: FALSE; }
+	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.gt_b(v); }
+	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.gteq_b(v)? LuaValue.TRUE: FALSE; }
+	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.gteq_b(v); }
+	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.lt_b(v)? LuaValue.TRUE: FALSE; }
+	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.lt_b(v); }
+	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.lteq_b(v)? LuaValue.TRUE: FALSE; }
+	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.lteq_b(v); }
+	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; }
 	
--- a/src/core/org/luaj/vm2/LuaFunction.java
+++ b/src/core/org/luaj/vm2/LuaFunction.java
@@ -74,10 +74,13 @@ public class LuaFunction extends LuaValue {

 	/** 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();
-		return s.substring(Math.max(s.lastIndexOf('.'),s.lastIndexOf('$'))+1);
+		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.
--- a/src/core/org/luaj/vm2/LuaInteger.java
+++ b/src/core/org/luaj/vm2/LuaInteger.java
@@ -172,28 +172,28 @@ public class LuaInteger extends LuaNumber {
 	public LuaValue   modFrom( double lhs )   { return LuaDouble.dmod(lhs,v); }
 	
 	// relational operators
-	public LuaValue   lt( LuaValue rhs )         { return rhs.gt_b(v)? TRUE: FALSE; }	
+	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.gt_b(v); }
+	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.gteq_b(v)? TRUE: FALSE; }
+	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.gteq_b(v); }
+	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.lt_b(v)? TRUE: FALSE; }
+	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.lt_b(v); }
+	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.lteq_b(v)? TRUE: FALSE; }
+	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.lteq_b(v); }
+	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; }
 	
--- a/src/core/org/luaj/vm2/LuaString.java
+++ b/src/core/org/luaj/vm2/LuaString.java
@@ -144,7 +144,7 @@ public class LuaString extends LuaValue {
 	/** Construct a new LuaString using a copy of the bytes array supplied */
 	private static LuaString valueFromCopy(byte[] bytes, int off, int len) {
 		final byte[] copy = new byte[len];
-		for (int i=0; i<len; ++i) copy[i] = bytes[off+i];
+		System.arraycopy(bytes, off, copy, 0, len);
 		return new LuaString(copy, 0, len);
 	}

@@ -289,20 +289,20 @@ public class LuaString extends LuaValue {
 	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.strcmp(this)>0? LuaValue.TRUE: FALSE; }
-	public boolean lt_b( LuaValue rhs )       { return rhs.strcmp(this)>0; }
+	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.strcmp(this)>=0? LuaValue.TRUE: FALSE; }
-	public boolean lteq_b( LuaValue rhs )     { return rhs.strcmp(this)>=0; }
+	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.strcmp(this)<0? LuaValue.TRUE: FALSE; }
-	public boolean gt_b( LuaValue rhs )       { return rhs.strcmp(this)<0; }
+	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.strcmp(this)<=0? LuaValue.TRUE: FALSE; }
-	public boolean gteq_b( LuaValue rhs )     { return rhs.strcmp(this)<=0; }
+	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; }

@@ -391,23 +391,23 @@ public class LuaString extends LuaValue {
 	public short   toshort()       { return (short) toint(); }

 	public double optdouble(double defval) {
-		return checknumber().checkdouble();
+		return checkdouble();
 	}
 	
 	public int optint(int defval) {
-		return checknumber().checkint();
+		return checkint();
 	}
 	
 	public LuaInteger optinteger(LuaInteger defval) {
-		return checknumber().checkinteger();
+		return checkinteger();
 	}
 	
 	public long optlong(long defval) {
-		return checknumber().checklong();
+		return checklong();
 	}
 	
 	public LuaNumber optnumber(LuaNumber defval) {
-		return checknumber().checknumber();
+		return checknumber();
 	}
 	
 	public LuaString optstring(LuaString defval) {
--- a/src/core/org/luaj/vm2/LuaTable.java
+++ b/src/core/org/luaj/vm2/LuaTable.java
@@ -266,8 +266,8 @@ public class LuaTable extends LuaValue implements Metatable {

 	/** caller must ensure key is not nil */
 	public void set( LuaValue key, LuaValue value ) {
-		if (!key.isvalidkey() && !metatag(NEWINDEX).isfunction())
-			typerror("table index");
+		if (key == null || !key.isvalidkey() && !metatag(NEWINDEX).isfunction())
+			throw new LuaError("value ('" + key + "') can not be used as a table index");
 		if ( m_metatable==null || ! rawget(key).isnil() ||  ! settable(this,key,value) )
 			rawset(key, value);
 	}
@@ -299,15 +299,15 @@ public class LuaTable extends LuaValue implements Metatable {
 	 * @return The removed item, or {@link #NONE} if not removed
 	 */
 	public LuaValue remove(int pos) {
-		int n = rawlen();
+		int n = length();
 		if ( pos == 0 )
 			pos = n;
 		else if (pos > n)
 			return NONE;
-		LuaValue v = rawget(pos);
+		LuaValue v = get(pos);
 		for ( LuaValue r=v; !r.isnil(); ) {
-			r = rawget(pos+1);
-			rawset(pos++, r);
+			r = get(pos+1);
+			set(pos++, r);
 		}
 		return v.isnil()? NONE: v;
 	}
@@ -319,10 +319,10 @@ public class LuaTable extends LuaValue implements Metatable {
 	 */
 	public void insert(int pos, LuaValue value) {
 		if ( pos == 0 )
-			pos = rawlen()+1;
+			pos = length()+1;
 		while ( ! value.isnil() ) {
-			LuaValue v = rawget( pos );
-			rawset(pos++, value);
+			LuaValue v = get( pos );
+			set(pos++, value);
 			value = v;
 		}
 	}
@@ -347,7 +347,12 @@ public class LuaTable extends LuaValue implements Metatable {
 	}

 	public int length() {
-		return m_metatable != null? len().toint(): rawlen(); 
+		if (m_metatable != null) {
+			LuaValue len = len();
+			if (!len.isint()) throw new LuaError("table length is not an integer: " + len);
+			return len.toint();
+		}
+		return rawlen();
 	}
 	
 	public LuaValue len()  {
@@ -390,7 +395,7 @@ public class LuaTable extends LuaValue implements Metatable {
 					}
 				}
 				if ( hash.length == 0 )
-					error( "invalid key to 'next'" );
+					error( "invalid key to 'next' 1: " + key );
 				i = hashSlot( key );
 				boolean found = false;
 				for ( Slot slot = hash[i]; slot != null; slot = slot.rest() ) {
@@ -404,7 +409,7 @@ public class LuaTable extends LuaValue implements Metatable {
 					}
 				}
 				if ( !found ) {
-					error( "invalid key to 'next'" );
+					error( "invalid key to 'next' 2: " + key );
 				}
 				i += 1+array.length;
 			}
@@ -467,7 +472,8 @@ public class LuaTable extends LuaValue implements Metatable {
 				}
 			}
 			if ( checkLoadFactor() ) {
-				if ( key.isinttype() && key.toint() > 0 ) {
+				if ( (m_metatable == null || !m_metatable.useWeakValues())
+					&& key.isinttype() && key.toint() > 0 ) {
 					// a rehash might make room in the array portion for this key.
 					rehash( key.toint() );
 					if ( arrayset(key.toint(), value) )
@@ -714,7 +720,7 @@ public class LuaTable extends LuaValue implements Metatable {
 					StrongSlot entry = slot.first();
 					if (entry != null)
 						newArray[ k - 1 ] = entry.value();
-				} else {
+				} else if ( !(slot instanceof DeadSlot) ) {
 					int j = slot.keyindex( newHashMask );
 					newHash[j] = slot.relink( newHash[j] );
 				}
@@ -780,36 +786,39 @@ public class LuaTable extends LuaValue implements Metatable {
 	 * @param comparator {@link LuaValue} to be called to compare elements.
 	 */
 	public void sort(LuaValue comparator) {
+		if (len().tolong() >= (long)Integer.MAX_VALUE) throw new LuaError("array too big: " + len().tolong());
 		if (m_metatable != null && m_metatable.useWeakValues()) {
 			dropWeakArrayValues();
 		}
-		int n = array.length;
-		while ( n > 0 && array[n-1] == null )
-			--n;
+		int n = length();
 		if ( n > 1 )
-			heapSort(n, comparator);
+			heapSort(n, comparator.isnil() ? null : comparator);
 	}

 	private void heapSort(int count, LuaValue cmpfunc) {
 		heapify(count, cmpfunc);
-		for ( int end=count-1; end>0; ) {
-			swap(end, 0);
-			siftDown(0, --end, cmpfunc);
+		for ( int end=count; end>1; ) {
+			LuaValue a = get(end); // swap(end, 1)
+			set(end, get(1));
+			set(1, a);
+			siftDown(1, --end, cmpfunc);
 		}
 	}

 	private void heapify(int count, LuaValue cmpfunc) {
-		for ( int start=count/2-1; start>=0; --start )
-			siftDown(start, count - 1, cmpfunc);
+		for ( int start=count/2; start>0; --start )
+			siftDown(start, count, cmpfunc);
 	}

 	private void siftDown(int start, int end, LuaValue cmpfunc) {
-		for ( int root=start; root*2+1 <= end; ) { 
-			int child = root*2+1; 
+		for ( int root=start; root*2 <= end; ) {
+			int child = root*2;
 			if (child < end && compare(child, child + 1, cmpfunc))
 				++child;
 			if (compare(root, child, cmpfunc)) {
-				swap(root, child);
+				LuaValue a = get(root); // swap(root, child)
+				set(root, get(child));
+				set(child, a);
 				root = child;
 			} else
 				return;
@@ -817,29 +826,16 @@ public class LuaTable extends LuaValue implements Metatable {
 	}

 	private boolean compare(int i, int j, LuaValue cmpfunc) {
-		LuaValue a, b;
-		if (m_metatable == null) {
-			a = array[i];
-			b = array[j];
-		} else {
-			a = m_metatable.arrayget(array, i);
-			b = m_metatable.arrayget(array, j);
-		}
+		LuaValue a = get(i), b = get(j);
 		if ( a == null || b == null )
 			return false;
-		if ( ! cmpfunc.isnil() ) {
+		if ( cmpfunc != null ) {
 			return cmpfunc.call(a,b).toboolean();
 		} else {
 			return a.lt_b(b);
 		}
 	}
 	
-	private void swap(int i, int j) {
-		LuaValue a = array[i];
-		array[i] = array[j];
-		array[j] = a;
-	}
-	
 	/** This may be deprecated in a future release.
 	 * It is recommended to count via iteration over next() instead
 	 * @return count of keys in the table
@@ -892,6 +888,11 @@ public class LuaTable extends LuaValue implements Metatable {

 	/** Unpack the elements from i to j inclusive */
 	public Varargs unpack(int i, int j) {
+		if (j < i) return NONE;
+		int count = j - i;
+		if (count < 0) throw new LuaError("too many results to unpack: greater " + Integer.MAX_VALUE); // integer overflow
+		int max = 0x00ffffff;
+		if (count >= max) throw new LuaError("too many results to unpack: " + count + " (max is " + max + ')');
 		int n = j + 1 - i;
 		switch (n) {
 		case 0: return NONE;
@@ -900,10 +901,14 @@ public class LuaTable extends LuaValue implements Metatable {
 		default:
 			if (n < 0)
 				return NONE;
-			LuaValue[] v = new LuaValue[n];
-			while (--n >= 0)
-				v[n] = get(i+n);
-			return varargsOf(v);
+			try {
+				LuaValue[] v = new LuaValue[n];
+				while (--n >= 0)
+					v[n] = get(i+n);
+				return varargsOf(v);
+			} catch (OutOfMemoryError e) {
+				throw new LuaError("too many results to unpack [out of memory]: " + n);
+			}
 		}
 	}

@@ -1231,13 +1236,14 @@ public class LuaTable extends LuaValue implements Metatable {
 		}

 		public Entry set(LuaValue value) {
-			LuaValue n = value.tonumber();
-			if ( !n.isnil() ) {
-				this.value = n.todouble();
-				return this;
-			} else {
-				return new NormalEntry( this.key, value );
+			if (value.type() == TNUMBER) {
+				LuaValue n = value.tonumber();
+				if (!n.isnil()) {
+					this.value = n.todouble();
+					return this;
+				}
 			}
+			return new NormalEntry( this.key, value );
 		}

 		public int keyindex( int mask ) {
--- a/src/core/org/luaj/vm2/LuaThread.java
+++ b/src/core/org/luaj/vm2/LuaThread.java
@@ -23,6 +23,10 @@ package org.luaj.vm2;


 import java.lang.ref.WeakReference;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;

 /** 
 * Subclass of {@link LuaValue} that implements 
@@ -82,6 +86,19 @@ public class LuaThread extends LuaValue {
 	 */
 	public static long thread_orphan_check_interval = 5000;
 	
+	public static final String USE_PLATFORM_THREAD = "USE_PLATFORM_THREAD";
+	
+	private static boolean SUPPORT_VIRTUAL_THREAD = false;
+	
+	static {
+		try {
+			Thread.class.getMethod("ofVirtual");
+			SUPPORT_VIRTUAL_THREAD = true;
+		} catch (Exception e) {
+			//e.printStackTrace();
+		} 
+	}
+	
 	public static final int STATUS_INITIAL       = 0;
 	public static final int STATUS_SUSPENDED     = 1;
 	public static final int STATUS_RUNNING       = 2;
@@ -184,6 +201,8 @@ public class LuaThread extends LuaValue {
 		public int bytecodes;
 		
 		public int status = LuaThread.STATUS_INITIAL;
+		private Lock locker = new ReentrantLock();
+		private Condition cond = locker.newCondition();

 		State(Globals globals, LuaThread lua_thread, LuaValue function) {
 			this.globals = globals;
@@ -191,68 +210,98 @@ public class LuaThread extends LuaValue {
 			this.function = function;
 		}
 		
-		public synchronized void run() {
+		public void run() {
+			locker.lock();
 			try {
-				Varargs a = this.args;
-				this.args = LuaValue.NONE;
-				this.result = function.invoke(a);
-			} catch (Throwable t) {
-				this.error = t.getMessage();
-			} finally {
-				this.status = LuaThread.STATUS_DEAD;
-				this.notify();
-			}
-		}
-
-		public synchronized Varargs lua_resume(LuaThread new_thread, Varargs args) {
-			LuaThread previous_thread = globals.running;
-			try {
-				globals.running = new_thread;
-				this.args = args;
-				if (this.status == STATUS_INITIAL) {
-					this.status = STATUS_RUNNING; 
-					new Thread(this, "Coroutine-"+(++coroutine_count)).start();
-				} else {
-					this.notify();
+				try {
+					Varargs a = this.args;
+					this.args = LuaValue.NONE;
+					this.result = function.invoke(a);
+				} catch (Throwable t) {
+					this.error = t.getMessage();
+				} finally {
+					this.status = LuaThread.STATUS_DEAD;
+					cond.signal();
 				}
-				if (previous_thread != null)
-					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));
-			} catch (InterruptedException ie) {
-				throw new OrphanedThread();
 			} finally {
-				this.args = LuaValue.NONE;
-				this.result = LuaValue.NONE;
-				this.error = null;
-				globals.running = previous_thread;
-				if (previous_thread != null)
-					globals.running.state.status =STATUS_RUNNING;
+				locker.unlock();
 			}
 		}

-		public synchronized Varargs lua_yield(Varargs args) {
+		public Varargs lua_resume(LuaThread new_thread, Varargs args) {
+			locker.lock();
 			try {
-				this.result = args;
-				this.status = STATUS_SUSPENDED;
-				this.notify();
-				do {
-					this.wait(thread_orphan_check_interval);
-					if (this.lua_thread.get() == null) {
-						this.status = STATUS_DEAD;
-						throw new OrphanedThread();
+				LuaThread previous_thread = globals.running;
+				try {
+					globals.running = new_thread;
+					this.args = args;
+					if (this.status == STATUS_INITIAL) {
+						this.status = STATUS_RUNNING;
+						Thread t = null;
+						if(SUPPORT_VIRTUAL_THREAD) {
+							LuaValue setting = globals.get(USE_PLATFORM_THREAD);
+							if(setting.isnil()) {//default
+								if(Thread.currentThread().isVirtual()) {
+									t = Thread.ofVirtual().name("Coroutine-"+(++coroutine_count)).start(this);
+								}
+							} else {
+								if(!setting.toboolean()) {
+									t = Thread.ofVirtual().name("Coroutine-"+(++coroutine_count)).start(this);
+								}
+							}
+						} 
+						if (t == null){
+							new Thread(this, "Coroutine-"+(++coroutine_count)).start();
+						}
+					} else {
+						cond.signal();
 					}
-				} while (this.status == STATUS_SUSPENDED);
-				return this.args;
-			} catch (InterruptedException ie) {
-				this.status = STATUS_DEAD;
-				throw new OrphanedThread();
+					if (previous_thread != null)
+						previous_thread.state.status = STATUS_NORMAL;
+					this.status = STATUS_RUNNING;
+					cond.await();
+					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 {
+					this.args = LuaValue.NONE;
+					this.result = LuaValue.NONE;
+					this.error = null;
+					globals.running = previous_thread;
+					if (previous_thread != null)
+						globals.running.state.status =STATUS_RUNNING;
+				}
 			} finally {
-				this.args = LuaValue.NONE;
-				this.result = LuaValue.NONE;
+				locker.unlock();
+			}
+		}
+
+		public Varargs lua_yield(Varargs args) {
+			locker.lock();
+			try {
+				try {
+					this.result = args;
+					this.status = STATUS_SUSPENDED;
+					cond.signal();
+					do {
+						cond.await(thread_orphan_check_interval,TimeUnit.MILLISECONDS);
+						if (this.lua_thread.get() == null) {
+							this.status = STATUS_DEAD;
+							throw new OrphanedThread();
+						}
+					} while (this.status == STATUS_SUSPENDED);
+					return this.args;
+				} catch (InterruptedException ie) {
+					this.status = STATUS_DEAD;
+					throw new OrphanedThread();
+				} finally {
+					this.args = LuaValue.NONE;
+					this.result = LuaValue.NONE;
+				}
+			} finally {
+				locker.unlock();
 			}
 		}
 	}
--- a/src/core/org/luaj/vm2/LuaValue.java
+++ b/src/core/org/luaj/vm2/LuaValue.java
@@ -21,8 +21,6 @@
 ******************************************************************************/
 package org.luaj.vm2;

-import org.luaj.vm2.Varargs;
-
 /**
 * Base class for all concrete lua type values.
 * <p>
@@ -643,7 +641,7 @@ public class LuaValue extends Varargs {
 	 * @see #isnumber()
 	 * @see #TNUMBER
 	 */
-	public double      optdouble(double defval)            { argerror("double");    return 0;     }
+	public double      optdouble(double defval)            { argerror("number");    return 0;     }

 	/** Check that optional argument is a function and return as {@link LuaFunction}
 	 * <p>
@@ -855,7 +853,7 @@ public class LuaValue extends Varargs {
 	 * @see #optdouble(double)
 	 * @see #TNUMBER
 	 */
-	public double      checkdouble()           { argerror("double");    return 0; }
+	public double      checkdouble()           { argerror("number");    return 0; }
 	
 	/** Check that the value is a function , or throw {@link LuaError} if not
 	 * <p>
@@ -2045,7 +2043,7 @@ public class LuaValue extends Varargs {
 	 * @see #eqmtcall(LuaValue, LuaValue, LuaValue, LuaValue)
 	 * @see #EQ
 	 */
-	public LuaValue   eq( LuaValue val )      { return this == val? TRUE: FALSE; }
+	public LuaValue   eq( LuaValue val )      { return eq_b(val)? TRUE: FALSE; }
 	
 	/** Equals: Perform equality comparison with another value
 	 * including metatag processing using {@link #EQ},
@@ -3143,7 +3141,7 @@ public class LuaValue extends Varargs {
 	 * @return {@link LuaString} corresponding to the value if a string or number
 	 * @throws LuaError if not a string or number
 	 */
-	public LuaString strvalue()     { typerror("strValue"); 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.
@@ -3298,7 +3296,7 @@ public class LuaValue extends Varargs {
 				if ((!res.isnil()) || (tm = t.metatag(INDEX)).isnil())
 					return res;
 			} else if ((tm = t.metatag(INDEX)).isnil())
-				t.indexerror();
+				t.indexerror(key.tojstring());
 			if (tm.isfunction())
 				return tm.call(t, key);
 			t = tm;
@@ -3326,7 +3324,7 @@ public class LuaValue extends Varargs {
 					return true;
 				}
 			} else if ((tm = t.metatag(NEWINDEX)).isnil())
-				t.typerror("index");
+				throw new LuaError("table expected for set index ('" + key + "') value, got " + t.typename());
 			if (tm.isfunction()) {
 				tm.call(t, key, value);
 				return true;
@@ -3362,7 +3360,7 @@ public class LuaValue extends Varargs {
 	protected LuaValue checkmetatag(LuaValue tag, String reason) {
 		LuaValue h = this.metatag(tag);
 		if ( h.isnil() )
-			throw new LuaError(reason+typename());
+			throw new LuaError(reason + "a " + typename() + " value");
 		return h;
 	}

@@ -3389,8 +3387,8 @@ public class LuaValue extends Varargs {
 	/** Throw {@link LuaError} indicating index was attempted on illegal type
 	 * @throws LuaError when called.
 	 */
-    private void indexerror() {
-		error( "attempt to index ? (a "+typename()+" value)" );
+    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.
--- a/src/core/org/luaj/vm2/Print.java
+++ b/src/core/org/luaj/vm2/Print.java
@@ -128,6 +128,10 @@ public class Print extends Lua {
 	}

 	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() );
@@ -136,7 +140,7 @@ public class Print extends Lua {
 	}
 	
 	static void printConstant(PrintStream ps, Prototype f, int i) {
-		printValue( ps, f.k[i] );
+		printValue( ps, i < f.k.length ? f.k[i] : LuaValue.valueOf("UNKNOWN_CONST_" + i) );
 	}

 	static void printUpvalue(PrintStream ps, Upvaldesc u) {
@@ -152,7 +156,7 @@ public class Print extends Lua {
 		int[] code = f.code;
 		int pc, n = code.length;
 		for (pc = 0; pc < n; pc++) {
-			printOpCode(f, pc);
+			pc = printOpCode(f, pc);
 			ps.println();
 		}
 	}
@@ -161,9 +165,10 @@ public class Print extends Lua {
 	 * Print an opcode in a 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 void printOpCode(Prototype f, int pc) {
-		printOpCode(ps,f,pc);
+	public static int printOpCode(Prototype f, int pc) {
+		return printOpCode(ps,f,pc);
 	}
 	
 	/** 
@@ -171,8 +176,9 @@ public class Print extends Lua {
 	 * @param ps the {@link PrintStream} to print to
 	 * @param f the {@link Prototype}
 	 * @param pc the program counter to look up and print
+	 * @return pc same as above or changed
 	 */
-	public static void printOpCode(PrintStream ps, Prototype f, int pc) {
+	public static int printOpCode(PrintStream ps, Prototype f, int pc) {
 		int[] code = f.code;
 		int i = code[pc];
 		int o = GET_OPCODE(i);
@@ -187,80 +193,67 @@ public class Print extends Lua {
 			ps.print("[" + line + "]  ");
 		else
 			ps.print("[-]  ");
-		ps.print(OPNAMES[o] + "  ");
-		switch (getOpMode(o)) {
-		case iABC:
-			ps.print( a );
-			if (getBMode(o) != OpArgN)
-				ps.print(" "+(ISK(b) ? (-1 - INDEXK(b)) : b));
-			if (getCMode(o) != OpArgN)
-				ps.print(" "+(ISK(c) ? (-1 - INDEXK(c)) : c));
-			break;
-		case iABx:
-			if (getBMode(o) == OpArgK) {
-				ps.print(a + " " + (-1 - bx));
-			} else {
-				ps.print(a + " " + (bx));
+		if (o >= OPNAMES.length - 1) {
+			ps.print("UNKNOWN_OP_" + o + "  ");
+		} else {
+			ps.print(OPNAMES[o] + "  ");
+			switch (getOpMode(o)) {
+			case iABC:
+				ps.print( a );
+				if (getBMode(o) != OpArgN)
+					ps.print(" "+(ISK(b) ? (-1 - INDEXK(b)) : b));
+				if (getCMode(o) != OpArgN)
+					ps.print(" "+(ISK(c) ? (-1 - INDEXK(c)) : c));
+				break;
+			case iABx:
+				if (getBMode(o) == OpArgK) {
+					ps.print(a + " " + (-1 - bx));
+				} else {
+					ps.print(a + " " + (bx));
+				}
+				break;
+			case iAsBx:
+				if (o == OP_JMP)
+					ps.print( sbx );
+				else
+					ps.print(a + " " + sbx);
+				break;
 			}
-			break;
-		case iAsBx:
-			if (o == OP_JMP)
-				ps.print( sbx );
-			else
-				ps.print(a + " " + sbx);
-			break;
-		}
-		switch (o) {
-		case OP_LOADK:
-			ps.print("  ; ");
-			printConstant(ps, f, bx);
-			break;
-		case OP_GETUPVAL:
-		case OP_SETUPVAL:
-			ps.print("  ; ");
-			printUpvalue(ps, f.upvalues[b]);
-			break;
-		case OP_GETTABUP:
-			ps.print("  ; ");
-			printUpvalue(ps, f.upvalues[b]);
-			ps.print(" ");
-			if (ISK(c))
-				printConstant(ps, f, INDEXK(c));
-			else
-				ps.print("-");
-			break;
-		case OP_SETTABUP:
-			ps.print("  ; ");
-			printUpvalue(ps, f.upvalues[a]);
-			ps.print(" ");
-			if (ISK(b))
-				printConstant(ps, f, INDEXK(b));
-			else
-				ps.print("-");
-			ps.print(" ");
-			if (ISK(c))
-				printConstant(ps, f, INDEXK(c));
-			else
-				ps.print("-");
-			break;
-		case OP_GETTABLE:
-		case OP_SELF:
-			if (ISK(c)) {
+			switch (o) {
+			case OP_LOADK:
 				ps.print("  ; ");
-				printConstant(ps, f, INDEXK(c));
-			}
-			break;
-		case OP_SETTABLE:
-		case OP_ADD:
-		case OP_SUB:
-		case OP_MUL:
-		case OP_DIV:
-		case OP_POW:
-		case OP_EQ:
-		case OP_LT:
-		case OP_LE:
-			if (ISK(b) || ISK(c)) {
+				printConstant(ps, f, bx);
+				break;
+			case OP_GETUPVAL:
+			case OP_SETUPVAL:
 				ps.print("  ; ");
+				if (b < f.upvalues.length) {
+					printUpvalue(ps, f.upvalues[b]);
+				} else {
+					ps.print("UNKNOWN_UPVALUE_" + b);
+				}	
+				break;
+			case OP_GETTABUP:
+				ps.print("  ; ");
+				if (b < f.upvalues.length) {
+					printUpvalue(ps, f.upvalues[b]);
+				} else {
+					ps.print("UNKNOWN_UPVALUE_" + b);
+				}
+				ps.print(" ");
+				if (ISK(c))
+					printConstant(ps, f, INDEXK(c));
+				else
+					ps.print("-");
+				break;
+			case OP_SETTABUP:
+				ps.print("  ; ");
+				if (a < f.upvalues.length) {
+					printUpvalue(ps, f.upvalues[a]);
+				} else {
+					ps.print("UNKNOWN_UPVALUE_" + a);
+				}
+				ps.print(" ");
 				if (ISK(b))
 					printConstant(ps, f, INDEXK(b));
 				else
@@ -270,28 +263,62 @@ public class Print extends Lua {
 					printConstant(ps, f, INDEXK(c));
 				else
 					ps.print("-");
+				break;
+			case OP_GETTABLE:
+			case OP_SELF:
+				if (ISK(c)) {
+					ps.print("  ; ");
+					printConstant(ps, f, INDEXK(c));
+				}
+				break;
+			case OP_SETTABLE:
+			case OP_ADD:
+			case OP_SUB:
+			case OP_MUL:
+			case OP_DIV:
+			case OP_POW:
+			case OP_EQ:
+			case OP_LT:
+			case OP_LE:
+				if (ISK(b) || ISK(c)) {
+					ps.print("  ; ");
+					if (ISK(b))
+						printConstant(ps, f, INDEXK(b));
+					else
+						ps.print("-");
+					ps.print(" ");
+					if (ISK(c))
+						printConstant(ps, f, INDEXK(c));
+					else
+						ps.print("-");
+				}
+				break;
+			case OP_JMP:
+			case OP_FORLOOP:
+			case OP_FORPREP:
+				ps.print("  ; to " + (sbx + pc + 2));
+				break;
+			case OP_CLOSURE:
+				if (bx < f.p.length) {
+					ps.print("  ; " + f.p[bx].getClass().getName());
+				} else {
+					ps.print("  ; UNKNOWN_PROTYPE_" + bx);
+				}
+				break;
+			case OP_SETLIST:
+				if (c == 0)
+					ps.print("  ; " + ((int) code[++pc]) + " (stored in the next OP)");
+				else
+					ps.print("  ; " + ((int) c));
+				break;
+			case OP_VARARG:
+				ps.print( "  ; is_vararg="+ f.is_vararg );
+				break;			
+			default:
+				break;
 			}
-			break;
-		case OP_JMP:
-		case OP_FORLOOP:
-		case OP_FORPREP:
-			ps.print("  ; to " + (sbx + pc + 2));
-			break;
-		case OP_CLOSURE:
-			ps.print("  ; " + f.p[bx].getClass().getName());
-			break;
-		case OP_SETLIST:
-			if (c == 0)
-				ps.print("  ; " + ((int) code[++pc]));
-			else
-				ps.print("  ; " + ((int) c));
-			break;
-		case OP_VARARG:
-			ps.print( "  ; is_vararg="+ f.is_vararg );
-			break;			
-		default:
-			break;
 		}
+		return pc;
 	}

 	private static int getline(Prototype f, int pc) {
--- a/src/core/org/luaj/vm2/Varargs.java
+++ b/src/core/org/luaj/vm2/Varargs.java
@@ -291,7 +291,7 @@ public abstract class Varargs {
 	 * @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).checknumber().todouble(); }
+	public double       checkdouble(int i)           { return arg(i).checkdouble(); }

 	/** 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
@@ -300,12 +300,12 @@ public abstract class Varargs {
 	 * */
 	public LuaFunction    checkfunction(int i)         { return arg(i).checkfunction(); }

-	/** Return argument i as a java int value, discarding any fractional part, or throw an error if not a number.
+	/** 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 with fraction discarded and truncated if necessary if argument i is number
-	 * @exception LuaError if the argument is not a number
+	 * @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).checknumber().toint(); }
+	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.
 	 * @param i the index of the argument to test, 1 is the first argument
@@ -314,12 +314,12 @@ public abstract class Varargs {
 	 * */
 	public LuaInteger   checkinteger(int i)          { return arg(i).checkinteger(); }

-	/** Return argument i as a java long value, discarding any fractional part, or throw an error if not a number.
+	/** 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 with fraction discarded and truncated if necessary if argument i is number
-	 * @exception LuaError if the argument is not a number
+	 * @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).checknumber().tolong(); }
+	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.
 	 * @param i the index of the argument to test, 1 is the first argument
@@ -707,8 +707,10 @@ public abstract class Varargs {
 	/** Return Varargs that cannot be using a shared array for the storage, and is flattened.
 	 * Internal utility method not intended to be called directly from user code.
 	 * @return Varargs containing same values, but flattened and with a new array if needed.
+	 * @exclude
+	 * @hide
 	 */
-	Varargs dealias() {
+	public Varargs dealias() {
 		int n = narg();
 		switch (n) {
 		case 0: return LuaValue.NONE;
--- a/src/core/org/luaj/vm2/compiler/Constants.java
+++ b/src/core/org/luaj/vm2/compiler/Constants.java
@@ -105,6 +105,11 @@ public class Constants extends Lua {
 				((bc << POS_Bx) & MASK_Bx) ;
 	}
 	
+	static int CREATE_Ax(int o, int a) {
+		return ((o << POS_OP) & MASK_OP) |
+				((a << POS_Ax) & MASK_Ax) ;
+ 	}
+
 	// vector reallocation
 	
 	static LuaValue[] realloc(LuaValue[] v, int n) {
--- a/src/core/org/luaj/vm2/compiler/DumpState.java
+++ b/src/core/org/luaj/vm2/compiler/DumpState.java
@@ -28,9 +28,9 @@ import java.io.OutputStream;
 import org.luaj.vm2.Globals;
 import org.luaj.vm2.LoadState;
 import org.luaj.vm2.LocVars;
-import org.luaj.vm2.Prototype;
 import org.luaj.vm2.LuaString;
 import org.luaj.vm2.LuaValue;
+import org.luaj.vm2.Prototype;


 /** Class to dump a {@link Prototype} into an output stream, as part of compiling.
@@ -85,7 +85,7 @@ public class DumpState {
 	public static final int NUMBER_FORMAT_DEFAULT = NUMBER_FORMAT_FLOATS_OR_DOUBLES;

 	// header fields
-	private boolean IS_LITTLE_ENDIAN = false;
+	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;
--- a/src/core/org/luaj/vm2/compiler/FuncState.java
+++ b/src/core/org/luaj/vm2/compiler/FuncState.java
@@ -50,7 +50,6 @@ public class FuncState extends Constants {
 	Hashtable h;  /* table to find (and reuse) elements in `k' */
 	FuncState prev;  /* enclosing function */
 	LexState ls;  /* lexical state */
-	LuaC.CompileState L;  /* compiler being invoked */
 	BlockCnt bl;  /* chain of current blocks */
 	int pc;  /* next position to code (equivalent to `ncode') */
 	int lasttarget;   /* `pc' of last `jump target' */
@@ -113,8 +112,8 @@ public class FuncState extends Constants {
 	void errorlimit (int limit, String what) {
 		// TODO: report message logic.
 	  	String msg = (f.linedefined == 0) ?
-	  	    L.pushfstring("main function has more than "+limit+" "+what) :
-	  	    L.pushfstring("function at line "+f.linedefined+" has more than "+limit+" "+what);
+	  	    ls.L.pushfstring("main function has more than "+limit+" "+what) :
+	  	    ls.L.pushfstring("function at line "+f.linedefined+" has more than "+limit+" "+what);
 	  	  ls.lexerror(msg, 0);
 	}

@@ -480,7 +479,7 @@ public class FuncState extends Constants {
 			return ((Integer) h.get(v)).intValue();
 		}
 		final int idx = this.nk;
-		this.h.put(v, new Integer(idx));
+		this.h.put(v, idx);
 		final Prototype f = this.f;
 		if (f.k == null || nk + 1 >= f.k.length)
 			f.k = realloc( f.k, nk*2 + 1 );
@@ -581,11 +580,11 @@ public class FuncState extends Constants {
 			break;
 		}
 		case LexState.VK: {
-			this.codeABx(OP_LOADK, reg, e.u.info);
+			this.codeK(reg, e.u.info);
 			break;
 		}
 		case LexState.VKNUM: {
-			this.codeABx(OP_LOADK, reg, this.numberK(e.u.nval()));
+			this.codeK(reg, this.numberK(e.u.nval()));
 			break;
 		}
 		case LexState.VRELOCABLE: {
@@ -1117,6 +1116,20 @@ public class FuncState extends Constants {
 		return this.code(CREATE_ABx(o, a, bc), this.ls.lastline);
 	}

+	int codeextraarg(int a) {
+		_assert(a <= MAXARG_Ax);
+		return this.code(CREATE_Ax(OP_EXTRAARG, a), this.ls.lastline);
+	}
+
+	int codeK(int reg, int k) {
+		if (k <= MAXARG_Bx)
+			return codeABx(OP_LOADK, reg, k);
+		else {
+			int p = codeABx(OP_LOADKX, reg, 0);
+			codeextraarg(k);
+			return p;
+		}
+	}

 	void setlist(int base, int nelems, int tostore) {
 		int c = (nelems - 1) / LFIELDS_PER_FLUSH + 1;
--- a/src/core/org/luaj/vm2/compiler/LexState.java
+++ b/src/core/org/luaj/vm2/compiler/LexState.java
@@ -170,7 +170,7 @@ public class LexState extends Constants {
 	static {
 		for ( int i=0; i<NUM_RESERVED; i++ ) {
 			LuaString ts = (LuaString) LuaValue.valueOf( luaX_tokens[i] );
-			RESERVED.put(ts, new Integer(FIRST_RESERVED+i));
+			RESERVED.put(ts, FIRST_RESERVED+i);
 		}
 	}

@@ -198,7 +198,7 @@ public class LexState extends Constants {
 	}
 	
 	private boolean isspace(int c) {
-		return (c <= ' ');
+		return (c >= 0 && c <= ' ');
 	}
 	
 	
@@ -388,8 +388,13 @@ public class LexState extends Constants {
 			seminfo.r = LuaValue.ZERO;
 		else if (str.indexOf('x')>=0 || str.indexOf('X')>=0)
 			seminfo.r = strx2number(str, seminfo);
-		else
-			seminfo.r = LuaValue.valueOf(Double.parseDouble(str.trim()));
+		else {
+			try {
+				seminfo.r = LuaValue.valueOf(Double.parseDouble(str.trim()));
+			} catch (NumberFormatException e) {
+				lexerror("malformed number (" + e.getMessage() + ")", TK_NUMBER);
+			}
+		}
 		return true;
 	}

@@ -408,7 +413,6 @@ public class LexState extends Constants {
 			else
 				break;
 		}
-		save('\0');
 		String str = new String(buff, 0, nbuff);
 		str2d(str, seminfo);
 	}
@@ -585,6 +589,13 @@ public class LexState extends Constants {
 				inclinenumber();
 				continue;
 			}
+			case ' ':
+			case '\f':
+			case '\t':
+			case 0x0B: /* \v */ {
+				nextChar();
+				continue;
+			}
 			case '-': {
 				nextChar();
 				if (current != '-')
@@ -688,19 +699,12 @@ public class LexState extends Constants {
 				return TK_EOS;
 			}
 			default: {
-				if (isspace(current)) {
-					_assert (!currIsNewline());
-					nextChar();
-					continue;
-				} else if (isdigit(current)) {
-					read_numeral(seminfo);
-					return TK_NUMBER;
-				} else if (isalpha(current) || current == '_') {
+				if (isalpha(current) || current == '_') {
 					/* identifier or reserved word */
 					LuaString ts;
 					do {
 						save_and_next();
-					} while (isalnum(current) || current == '_');
+					} while (isalnum(current));
 					ts = newstring(buff, 0, nbuff);
 					if ( RESERVED.containsKey(ts) )
 						return ((Integer)RESERVED.get(ts)).intValue();
@@ -1744,7 +1748,7 @@ public class LexState extends Constants {
 		fs.checkrepeated(dyd.label, dyd.n_label, label);  /* check for repeated labels */
 		checknext(TK_DBCOLON);  /* skip double colon */
 		/* create new entry for this label */
-		l = newlabelentry(dyd.label=grow(dyd.label, dyd.n_label+1), dyd.n_label++, label, line, fs.pc);
+		l = newlabelentry(dyd.label=grow(dyd.label, dyd.n_label+1), dyd.n_label++, label, line, fs.getlabel());
 		skipnoopstat();  /* skip other no-op statements */
 		if (block_follow(false)) {  /* label is last no-op statement in the block? */
 			/* assume that locals are already out of scope */
@@ -1845,7 +1849,7 @@ public class LexState extends Constants {
 		if (this.testnext(','))
 			this.exp1(); /* optional step */
 		else { /* default step = 1 */
-			fs.codeABx(Lua.OP_LOADK, fs.freereg, fs.numberK(LuaInteger.valueOf(1)));
+			fs.codeK(fs.freereg, fs.numberK(LuaInteger.valueOf(1)));
 			fs.reserveregs(1);
 		}
 		this.forbody(base, line, 1, true);
--- a/src/core/org/luaj/vm2/compiler/LuaC.java
+++ b/src/core/org/luaj/vm2/compiler/LuaC.java
@@ -117,7 +117,7 @@ public class LuaC extends Constants implements Globals.Compiler, Globals.Loader
 		protected CompileState() {}
 	
 		/** Parse the input */
-		private 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;
--- a/src/core/org/luaj/vm2/lib/BaseLib.java
+++ b/src/core/org/luaj/vm2/lib/BaseLib.java
@@ -152,7 +152,7 @@ public class BaseLib extends TwoArgFunction implements ResourceFinder {
 				System.gc();
 				return LuaValue.TRUE;
 			} else {
-				this.argerror("gc op");
+				argerror(1, "invalid option '" + s + "'");
 			}
 			return NIL;
 		}
@@ -173,16 +173,16 @@ public class BaseLib extends TwoArgFunction implements ResourceFinder {
 	// "error", // ( message [,level] ) -> ERR
 	static final class error extends TwoArgFunction {
 		public LuaValue call(LuaValue arg1, LuaValue arg2) {
-			throw arg1.isnil()? new LuaError(null, arg2.optint(1)): 
-				arg1.isstring()? new LuaError(arg1.tojstring(), arg2.optint(1)): 
-					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));
 		}
 	}

 	// "getmetatable", // ( object ) -> table
 	static final class getmetatable extends LibFunction {
 		public LuaValue call() {
-			return argerror(1, "value");
+			return argerror(1, "value expected");
 		}
 		public LuaValue call(LuaValue arg) {
 			LuaValue mt = arg.getmetatable();
@@ -193,7 +193,9 @@ public class BaseLib extends TwoArgFunction implements ResourceFinder {
 	final class load extends VarArgFunction {
 		public Varargs invoke(Varargs args) {
 			LuaValue ld = args.arg1();
-			args.argcheck(ld.isstring() || ld.isfunction(), 1, "ld must be string or function");
+			if (!ld.isstring() && !ld.isfunction()) {
+				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);
@@ -249,7 +251,7 @@ public class BaseLib extends TwoArgFunction implements ResourceFinder {
 				LuaString s = tostring.call( args.arg(i) ).strvalue();
 				globals.STDOUT.print(s.tojstring());
 			}
-			globals.STDOUT.println();
+			globals.STDOUT.print('\n');
 			return NONE;
 		}
 	}
@@ -258,10 +260,10 @@ public class BaseLib extends TwoArgFunction implements ResourceFinder {
 	// "rawequal", // (v1, v2) -> boolean
 	static final class rawequal extends LibFunction {
 		public LuaValue call() {
-			return argerror(1, "value");
+			return argerror(1, "value expected");
 		}
 		public LuaValue call(LuaValue arg) {
-			return argerror(2, "value");
+			return argerror(2, "value expected");
 		}
 		public LuaValue call(LuaValue arg1, LuaValue arg2) {
 			return valueOf(arg1.raweq(arg2));
@@ -269,12 +271,9 @@ public class BaseLib extends TwoArgFunction implements ResourceFinder {
 	}

 	// "rawget", // (table, index) -> value
-	static final class rawget extends LibFunction {
-		public LuaValue call() {
-			return argerror(1, "value");
-		}
+	static final class rawget extends TableLibFunction {
 		public LuaValue call(LuaValue arg) {
-			return argerror(2, "value");
+			return argerror(2, "value expected");
 		}
 		public LuaValue call(LuaValue arg1, LuaValue arg2) {
 			return arg1.checktable().rawget(arg2);
@@ -290,16 +289,17 @@ public class BaseLib extends TwoArgFunction implements ResourceFinder {
 	}

 	// "rawset", // (table, index, value) -> table
-	static final class rawset extends LibFunction {
+	static final class rawset extends TableLibFunction {
 		public LuaValue call(LuaValue table) {
-			return argerror(2,"value");
+			return argerror(2,"value expected");
 		}
 		public LuaValue call(LuaValue table, LuaValue index) {
-			return argerror(3,"value");
+			return argerror(3,"value expected");
 		}
 		public LuaValue call(LuaValue table, LuaValue index, LuaValue value) {
 			LuaTable t = table.checktable();
-			t.rawset(index.checknotnil(), value);
+			if (!index.isvalidkey()) argerror(2, "table index is nil");
+			t.rawset(index, value);
 			return t;
 		}
 	}
@@ -318,9 +318,9 @@ public class BaseLib extends TwoArgFunction implements ResourceFinder {
 	}
 	
 	// "setmetatable", // (table, metatable) -> table
-	static final class setmetatable extends LibFunction {
+	static final class setmetatable extends TableLibFunction {
 		public LuaValue call(LuaValue table) {
-			return argerror(2,"value");
+			return argerror(2,"nil or table expected");
 		}
 		public LuaValue call(LuaValue table, LuaValue metatable) {
 			final LuaValue mt0 = table.checktable().getmetatable();
@@ -465,10 +465,12 @@ public class BaseLib extends TwoArgFunction implements ResourceFinder {
 			this.func = func;
 		}
 		public int read() throws IOException {
-			if ( remaining <= 0 ) {
+			if ( remaining < 0 )
+				return -1;
+			if ( remaining == 0 ) {
 				LuaValue s = func.call();
 				if ( s.isnil() )
-					return -1;
+					return remaining = -1;
 				LuaString ls = s.strvalue();
 				bytes = ls.m_bytes;
 				offset = ls.m_offset;
@@ -477,7 +479,7 @@ public class BaseLib extends TwoArgFunction implements ResourceFinder {
 					return -1;
 			}
 			--remaining;
-			return bytes[offset++];
+			return 0xFF&bytes[offset++];
 		}
 	}
 }
--- a/src/core/org/luaj/vm2/lib/Bit32Lib.java
+++ b/src/core/org/luaj/vm2/lib/Bit32Lib.java
@@ -71,7 +71,7 @@ public class Bit32Lib extends TwoArgFunction {
 			"arshift", "lrotate", "lshift", "rrotate", "rshift"
 		});
 		env.set("bit32", t);
-		env.get("package").get("loaded").set("bit32", t);
+		if (!env.get("package").isnil()) env.get("package").get("loaded").set("bit32", t);
 		return t;
 	}

--- a/src/core/org/luaj/vm2/lib/CoroutineLib.java
+++ b/src/core/org/luaj/vm2/lib/CoroutineLib.java
@@ -79,10 +79,10 @@ public class CoroutineLib extends TwoArgFunction {
 		coroutine.set("resume", new resume());
 		coroutine.set("running", new running());
 		coroutine.set("status", new status());
-		coroutine.set("yield", new yield());
+		coroutine.set("yield", new Yield());
 		coroutine.set("wrap", new wrap());
 		env.set("coroutine", coroutine);
-		env.get("package").get("loaded").set("coroutine", coroutine);
+		if (!env.get("package").isnil()) env.get("package").get("loaded").set("coroutine", coroutine);
 		return coroutine;
 	}

@@ -92,7 +92,7 @@ public class CoroutineLib extends TwoArgFunction {
 		}
 	}

-	final class resume extends VarArgFunction {
+	static final class resume extends VarArgFunction {
 		public Varargs invoke(Varargs args) {
 			final LuaThread t = args.checkthread(1);
 			return t.resume( args.subargs(2) );
@@ -113,7 +113,7 @@ public class CoroutineLib extends TwoArgFunction {
 		}
 	}
 	
-	final class yield extends VarArgFunction {
+	private final class Yield extends VarArgFunction {
 		public Varargs invoke(Varargs args) {
 			return globals.yield( args );
 		}
@@ -127,7 +127,7 @@ public class CoroutineLib extends TwoArgFunction {
 		}
 	}

-	final class wrapper extends VarArgFunction {
+	static final class wrapper extends VarArgFunction {
 		final LuaThread luathread;
 		wrapper(LuaThread luathread) {
 			this.luathread = luathread;
--- a/src/core/org/luaj/vm2/lib/DebugLib.java
+++ b/src/core/org/luaj/vm2/lib/DebugLib.java
@@ -21,6 +21,9 @@
 ******************************************************************************/
 package org.luaj.vm2.lib;

+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+
 import org.luaj.vm2.Globals;
 import org.luaj.vm2.Lua;
 import org.luaj.vm2.LuaBoolean;
@@ -84,27 +87,27 @@ public class DebugLib extends TwoArgFunction {
 		try { TRACE = (null != System.getProperty("TRACE")); } catch (Exception e) {}
 	}
 	
-	private static final LuaString LUA             = valueOf("Lua");  
+	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");
 	
-	private static final LuaString FUNC            = valueOf("func");  
-	private static final LuaString ISTAILCALL      = valueOf("istailcall");  
-	private static final LuaString ISVARARG        = valueOf("isvararg");  
-	private static final LuaString NUPS            = valueOf("nups");  
-	private static final LuaString NPARAMS         = valueOf("nparams");  
-	private static final LuaString NAME            = valueOf("name");  
-	private static final LuaString NAMEWHAT        = valueOf("namewhat");  
-	private static final LuaString WHAT            = valueOf("what");  
-	private static final LuaString SOURCE          = valueOf("source");  
-	private static final LuaString SHORT_SRC       = valueOf("short_src");  
-	private static final LuaString LINEDEFINED     = valueOf("linedefined");  
-	private static final LuaString LASTLINEDEFINED = valueOf("lastlinedefined");  
-	private static final LuaString CURRENTLINE     = valueOf("currentline");  
-	private static final LuaString ACTIVELINES     = valueOf("activelines");  
+	static final LuaString FUNC            = valueOf("func");
+	static final LuaString ISTAILCALL      = valueOf("istailcall");
+	static final LuaString ISVARARG        = valueOf("isvararg");
+	static final LuaString NUPS            = valueOf("nups");
+	static final LuaString NPARAMS         = valueOf("nparams");
+	static final LuaString NAME            = valueOf("name");
+	static final LuaString NAMEWHAT        = valueOf("namewhat");
+	static final LuaString WHAT            = valueOf("what");
+	static final LuaString SOURCE          = valueOf("source");
+	static final LuaString SHORT_SRC       = valueOf("short_src");
+	static final LuaString LINEDEFINED     = valueOf("linedefined");
+	static final LuaString LASTLINEDEFINED = valueOf("lastlinedefined");
+	static final LuaString CURRENTLINE     = valueOf("currentline");
+	static final LuaString ACTIVELINES     = valueOf("activelines");

 	Globals globals;
 	
@@ -135,7 +138,7 @@ public class DebugLib extends TwoArgFunction {
 		debug.set("upvalueid", new upvalueid());
 		debug.set("upvaluejoin", new upvaluejoin());
 		env.set("debug", debug);
-		env.get("package").get("loaded").set("debug", debug);
+		if (!env.get("package").isnil()) env.get("package").get("loaded").set("debug", debug);
 		return debug;
 	}

@@ -234,7 +237,7 @@ public class DebugLib extends TwoArgFunction {
 	}

 	//	debug.getmetatable (value)
-	final class getmetatable extends LibFunction {
+	static final class getmetatable extends LibFunction {
 		public LuaValue call(LuaValue v) {
 			LuaValue mt = v.getmetatable();
 			return mt != null? mt: NIL;
@@ -311,7 +314,7 @@ public class DebugLib extends TwoArgFunction {
 	}

 	//	debug.setmetatable (value, table)
-	final class setmetatable extends TwoArgFunction { 
+	static final class setmetatable extends TwoArgFunction {
 		public LuaValue call(LuaValue value, LuaValue table) {
 			LuaValue mt = table.opttable(null);
 			switch ( value.type() ) {
@@ -328,7 +331,7 @@ public class DebugLib extends TwoArgFunction {
 	}

 	//	debug.setupvalue (f, up, value)
-	final class setupvalue extends VarArgFunction { 
+	static final class setupvalue extends VarArgFunction {
 		public Varargs invoke(Varargs args) {
 			LuaValue func = args.checkfunction(1);
 			int up = args.checkint(2);
@@ -346,7 +349,7 @@ public class DebugLib extends TwoArgFunction {
 	}

 	//	debug.setuservalue (udata, value)
-	final class setuservalue extends VarArgFunction { 
+	static final class setuservalue extends VarArgFunction {
 		public Varargs invoke(Varargs args) {
 			Object o = args.checkuserdata(1);
 			LuaValue v = args.checkvalue(2);
@@ -370,7 +373,7 @@ public class DebugLib extends TwoArgFunction {
 	}
 	
 	//	debug.upvalueid (f, n)
-	final class upvalueid extends VarArgFunction { 
+	static final class upvalueid extends VarArgFunction {
 		public Varargs invoke(Varargs args) {
 			LuaValue func = args.checkfunction(1);
 			int up = args.checkint(2);
@@ -385,7 +388,7 @@ public class DebugLib extends TwoArgFunction {
 	}

 	//	debug.upvaluejoin (f1, n1, f2, n2)
-	final class upvaluejoin extends VarArgFunction { 
+	static final class upvaluejoin extends VarArgFunction {
 		public Varargs invoke(Varargs args) {
 			LuaClosure f1 = args.checkclosure(1);
 			int n1 = args.checkint(2);
@@ -442,6 +445,10 @@ public class DebugLib extends TwoArgFunction {
 		return callstack().traceback(level);
 	}
 	
+	public CallFrame getCallFrame(int level) {
+		return callstack().getCallFrame(level);
+	}
+	
 	void callHook(LuaThread.State s, LuaValue type, LuaValue arg) {
 		if (s.inhook || s.hookfunc == null) return;
 		s.inhook = true;
@@ -503,43 +510,75 @@ public class DebugLib extends TwoArgFunction {
 		final static CallFrame[] EMPTY = {};
 		CallFrame[] frame = EMPTY;
 		int calls  = 0;
+		Lock lock = new ReentrantLock();

 		CallStack() {}
 		
-		synchronized int currentline() {
-			return calls > 0? frame[calls-1].currentline(): -1;
-		}
-
-		private synchronized CallFrame pushcall() {
-			if (calls >= frame.length) {
-				int n = Math.max(4, frame.length * 3 / 2);
-				CallFrame[] f = new CallFrame[n];
-				System.arraycopy(frame, 0, f, 0, frame.length);
-				for (int i = frame.length; i < n; ++i)
-					f[i] = new CallFrame();
-				frame = f;
-				for (int i = 1; i < n; ++i)
-					f[i].previous = f[i-1];
+		int currentline() {
+			lock.lock();
+			try {
+				return calls > 0? frame[calls-1].currentline(): -1;
+			} finally {
+				lock.unlock();
 			}
-			return frame[calls++];
 		}

-		final synchronized void onCall(LuaFunction function) {
-			pushcall().set(function);
+		private CallFrame pushcall() {
+			lock.lock();
+			try {
+				if (calls >= frame.length) {
+					int n = Math.max(4, frame.length * 3 / 2);
+					CallFrame[] f = new CallFrame[n];
+					System.arraycopy(frame, 0, f, 0, frame.length);
+					for (int i = frame.length; i < n; ++i)
+						f[i] = new CallFrame();
+					frame = f;
+					for (int i = 1; i < n; ++i)
+						f[i].previous = f[i-1];
+				}
+				return frame[calls++];
+			} finally {
+				lock.unlock();
+			}
 		}
 		
-		final synchronized void onCall(LuaClosure function, Varargs varargs, LuaValue[] stack) {
-			pushcall().set(function, varargs, stack);
+		final void onCall(LuaFunction function) {
+			lock.lock();
+			try {
+				pushcall().set(function);
+			} finally {
+				lock.unlock();
+			}
 		}

-		final synchronized void onReturn() {
-			if (calls > 0)
-				frame[--calls].reset();
+		final void onCall(LuaClosure function, Varargs varargs, LuaValue[] stack) {
+			lock.lock();
+			try {
+				pushcall().set(function, varargs, stack);
+			} finally {
+				lock.unlock();
+			}
+			
 		}
 		
-		final synchronized void onInstruction(int pc, Varargs v, int top) {
-			if (calls > 0)
-				frame[calls-1].instr(pc, v, top);
+		final void onReturn() {
+			lock.lock();
+			try {
+				if (calls > 0)
+					frame[--calls].reset();
+			} finally {
+				lock.unlock();
+			}
+		}
+		
+		final void onInstruction(int pc, Varargs v, int top) {
+			lock.lock();
+			try {
+				if (calls > 0)
+					frame[calls-1].instr(pc, v, top);
+			} finally {
+				lock.unlock();
+			}
 		}

 		/**
@@ -547,101 +586,125 @@ public class DebugLib extends TwoArgFunction {
 		 * @param level
 		 * @return String containing the traceback.
 		 */
-		synchronized String traceback(int level) {
-			StringBuffer sb = new StringBuffer();
-			sb.append( "stack traceback:" );
-			for (DebugLib.CallFrame c; (c = getCallFrame(level++)) != null; ) {
-				sb.append("\n\t");
-				sb.append( c.shortsource() );
-				sb.append( ':' );
-				if (c.currentline() > 0)
-					sb.append( c.currentline()+":" );
-				sb.append( " in " );
-				DebugInfo ar = auxgetinfo("n", c.f, c);
-				if (c.linedefined() == 0)
-					sb.append("main chunk");
-				else if ( ar.name != null ) {
-					sb.append( "function '" );
-					sb.append( ar.name );
-					sb.append( '\'' );
-				} else {
-					sb.append( "function <"+c.shortsource()+":"+c.linedefined()+">" );
+		String traceback(int level) {
+			lock.lock();
+			try {
+				StringBuffer sb = new StringBuffer();
+				sb.append( "stack traceback:" );
+				for (DebugLib.CallFrame c; (c = getCallFrame(level++)) != null; ) {
+					sb.append("\n\t");
+					sb.append( c.shortsource() );
+					sb.append( ':' );
+					if (c.currentline() > 0)
+						sb.append( c.currentline()+":" );
+					sb.append( " in " );
+					DebugInfo ar = auxgetinfo("n", c.f, c);
+					if (c.linedefined() == 0)
+						sb.append("main chunk");
+					else if ( ar.name != null ) {
+						sb.append( "function '" );
+						sb.append( ar.name );
+						sb.append( '\'' );
+					} else {
+						sb.append( "function <" );
+						sb.append( c.shortsource() );
+						sb.append( ':' );
+						sb.append( c.linedefined() );
+						sb.append( '>' );
+					}
 				}
+				sb.append("\n\t[Java]: in ?");
+				return sb.toString();
+			} finally {
+				lock.unlock();
 			}
-			sb.append("\n\t[Java]: in ?");
-			return sb.toString();
+			
 		}

-		synchronized DebugLib.CallFrame getCallFrame(int level) {
-			if (level < 1 || level > calls)
+		DebugLib.CallFrame getCallFrame(int level) {
+			lock.lock();
+			try {
+				if (level < 1 || level > calls)
+					return null;
+				return frame[calls-level];
+			} finally {
+				lock.unlock();
+			}
+		}
+
+		DebugLib.CallFrame findCallFrame(LuaValue func) {
+			lock.lock();
+			try {
+				for (int i = 1; i <= calls; ++i)
+					if (frame[calls-i].f == func)
+						return frame[i];
 				return null;
-			return frame[calls-level];
-		}
-
-		synchronized DebugLib.CallFrame findCallFrame(LuaValue func) {
-			for (int i = 1; i <= calls; ++i)
-				if (frame[calls-i].f == func)
-					return frame[i];
-			return null;
-		}	
-
-
-		synchronized DebugInfo auxgetinfo(String what, LuaFunction f, CallFrame ci) {
-			DebugInfo ar = new DebugInfo();
-			for (int i = 0, n = what.length(); i < n; ++i) {
-				switch (what.charAt(i)) {
-			      case 'S':
-			    	  ar.funcinfo(f);
-			    	  break;
-			      case 'l':
-			    	  ar.currentline = ci != null && ci.f.isclosure()? ci.currentline(): -1;
-			    	  break;
-			      case 'u':
-			    	  if (f != null && f.isclosure()) {
-			    		  Prototype p = f.checkclosure().p;
-			    		  ar.nups = (short) p.upvalues.length;
-			    		  ar.nparams = (short) p.numparams;
-			    		  ar.isvararg = p.is_vararg != 0;
-			    	  } else {
-				    	  ar.nups = 0;
-				    	  ar.isvararg = true;
-				    	  ar.nparams = 0;
-			    	  }
-			    	  break;
-			      case 't':
-			    	  ar.istailcall = false;
-			    	  break;
-			      case 'n': {
-			    	  /* calling function is a known Lua function? */
-			    	  if (ci != null && ci.previous != null) {
-			    		  if (ci.previous.f.isclosure()) {
-			    			  NameWhat nw = getfuncname(ci.previous);
-				    		  if (nw != null) {
-				    			  ar.name = nw.name;
-				    			  ar.namewhat = nw.namewhat;
-				    		  }
-			    		  }
-			    	  }
-			    	  if (ar.namewhat == null) {
-			    		  ar.namewhat = "";  /* not found */
-			    		  ar.name = null;
-			    	  }
-			    	  break;
-			      }
-			      case 'L':
-			      case 'f':
-			    	  break;
-			      default:
-			    	  // TODO: return bad status.
-			    	  break;
-				}
+			} finally {
+				lock.unlock();
 			}
-			return ar;
 		}

+
+		DebugInfo auxgetinfo(String what, LuaFunction f, CallFrame ci) {
+			lock.lock();
+			try {
+				DebugInfo ar = new DebugInfo();
+				for (int i = 0, n = what.length(); i < n; ++i) {
+					switch (what.charAt(i)) {
+				      case 'S':
+				    	  ar.funcinfo(f);
+				    	  break;
+				      case 'l':
+				    	  ar.currentline = ci != null && ci.f.isclosure()? ci.currentline(): -1;
+				    	  break;
+				      case 'u':
+				    	  if (f != null && f.isclosure()) {
+				    		  Prototype p = f.checkclosure().p;
+				    		  ar.nups = (short) p.upvalues.length;
+				    		  ar.nparams = (short) p.numparams;
+				    		  ar.isvararg = p.is_vararg != 0;
+				    	  } else {
+					    	  ar.nups = 0;
+					    	  ar.isvararg = true;
+					    	  ar.nparams = 0;
+				    	  }
+				    	  break;
+				      case 't':
+				    	  ar.istailcall = false;
+				    	  break;
+				      case 'n': {
+				    	  /* calling function is a known Lua function? */
+				    	  if (ci != null && ci.previous != null) {
+				    		  if (ci.previous.f.isclosure()) {
+				    			  NameWhat nw = getfuncname(ci.previous);
+					    		  if (nw != null) {
+					    			  ar.name = nw.name;
+					    			  ar.namewhat = nw.namewhat;
+					    		  }
+				    		  }
+				    	  }
+				    	  if (ar.namewhat == null) {
+				    		  ar.namewhat = "";  /* not found */
+				    		  ar.name = null;
+				    	  }
+				    	  break;
+				      }
+				      case 'L':
+				      case 'f':
+				    	  break;
+				      default:
+				    	  // TODO: return bad status.
+				    	  break;
+					}
+				}
+				return ar;
+			} finally {
+				lock.unlock();
+			}
+		}
 	}

-	static class CallFrame {
+	public static class CallFrame {
 		LuaFunction f;
 		int pc;
 		int top;
@@ -673,21 +736,21 @@ public class DebugLib extends TwoArgFunction {
 		}
 		Varargs getLocal(int i) {
 			LuaString name = getlocalname(i);
-			if ( name != null )
-				return varargsOf( name, stack[i-1] );
+			if ( i >= 1 && i <= stack.length && stack[i-1] != null )
+				return varargsOf( name == null ? NIL : name, stack[i-1] );
 			else
 				return NIL;
 		}
 		Varargs setLocal(int i, LuaValue value) {
 			LuaString name = getlocalname(i);
-			if ( name != null ) {
+			if ( i >= 1 && i <= stack.length && stack[i-1] != null ) {
 				stack[i-1] = value;
-				return name;
+				return name == null ? NIL : name;
 			} else {
 				return NIL;
 			}
 		}
-		int currentline() {
+		public int currentline() {
 			if ( !f.isclosure() ) return -1;
 			int[] li = f.checkclosure().p.lineinfo;
 			return li==null || pc<0 || pc>=li.length? -1: li[pc];
@@ -696,7 +759,7 @@ public class DebugLib extends TwoArgFunction {
 			if ( !f.isclosure() ) return f.tojstring();
 			return f.checkclosure().p.shortsource() + ":" + currentline();
 		}
-		private int linedefined() {
+		int linedefined() {
 			return f.isclosure()? f.checkclosure().p.linedefined: -1;
 		}
 		LuaString getlocalname(int index) {
@@ -792,13 +855,13 @@ public class DebugLib extends TwoArgFunction {
 		        LuaString vn = (Lua.GET_OPCODE(i) == Lua.OP_GETTABLE)  /* name of indexed variable */
 	                    ? p.getlocalname(t + 1, pc)
 	                    : (t < p.upvalues.length ? p.upvalues[t].name : QMARK);
-				name = kname(p, k);
-				return new NameWhat( name.tojstring(), vn != null && vn.eq_b(ENV)? "global": "field" );
+				String jname = kname(p, pc, k);
+				return new NameWhat( jname, vn != null && vn.eq_b(ENV)? "global": "field" );
 			}
 			case Lua.OP_GETUPVAL: {
 				int u = Lua.GETARG_B(i); /* upvalue index */
 				name = u < p.upvalues.length ? p.upvalues[u].name : QMARK;
-				return new NameWhat( name.tojstring(), "upvalue" );
+				return name == null ? null : new NameWhat( name.tojstring(), "upvalue" );
 			}
 		    case Lua.OP_LOADK:
 		    case Lua.OP_LOADKX: {
@@ -812,8 +875,8 @@ public class DebugLib extends TwoArgFunction {
 		    }
 			case Lua.OP_SELF: {
 				int k = Lua.GETARG_C(i); /* key index */
-				name = kname(p, k);
-				return new NameWhat( name.tojstring(), "method" );
+				String jname = kname(p, pc, k);
+				return new NameWhat( jname, "method" );
 			}
 			default:
 				break;
@@ -822,11 +885,20 @@ public class DebugLib extends TwoArgFunction {
 		return null; /* no useful name found */
 	}

-	static LuaString kname(Prototype p, int c) {
-		if (Lua.ISK(c) && p.k[Lua.INDEXK(c)].isstring())
-			return p.k[Lua.INDEXK(c)].strvalue();
-		else
-			return QMARK;
+	static String kname(Prototype p, int pc, int c) {
+		if (Lua.ISK(c)) {  /* is 'c' a constant? */
+			LuaValue k = p.k[Lua.INDEXK(c)];
+			if (k.isstring()) {  /* literal constant? */
+				return k.tojstring();  /* it is its own name */
+			} /* else no reasonable name found */
+		} else {  /* 'c' is a register */
+			NameWhat what = getobjname(p, pc, c); /* search for 'c' */
+		    if (what != null && "constant".equals(what.namewhat)) {  /* found a constant name? */
+		      return what.name;  /* 'name' already filled */
+		    }
+		    /* else no reasonable name found */
+		}
+		return "?";  /* no reasonable name found */
 	}

 	/*
@@ -867,6 +939,10 @@ public class DebugLib extends TwoArgFunction {
 	        if (reg == a) setreg = pc;  /* jumped code can change 'a' */
 	        break;
 	      }
+	      case Lua.OP_SETLIST: { // Lua.testAMode(Lua.OP_SETLIST) == false
+	    	if ( ((i>>14)&0x1ff) == 0 ) pc++; // if c == 0 then c stored in next op -> skip
+		break;
+	      }
 	      default:
 	        if (Lua.testAMode(op) && reg == a)  /* any instruction that set A */
 	          setreg = pc;
--- a/src/core/org/luaj/vm2/lib/IoLib.java
+++ b/src/core/org/luaj/vm2/lib/IoLib.java
@@ -95,6 +95,12 @@ public class IoLib extends TwoArgFunction {
 		// 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; }
+		}
+		
 		// delegate method access to file methods table
 		public LuaValue get( LuaValue key ) {
 			return filemethods.get(key);
@@ -112,6 +118,18 @@ public class IoLib extends TwoArgFunction {
 		public String tojstring() {
 			return "file: " + Integer.toHexString(hashCode());
 		}
+		
+		public void finalize() throws Throwable {
+			try {
+				if (!isclosed()) {
+					try {
+						close();
+					} catch (IOException ignore) {}
+				}
+			} finally {
+				super.finalize();
+			}
+		}
 	}

 	/** Enumerated value representing stdin */
@@ -256,7 +274,7 @@ public class IoLib extends TwoArgFunction {
 		
 		// return the table
 		env.set("io", t);
-		env.get("package").get("loaded").set("io", t);
+		if (!env.get("package").isnil()) env.get("package").get("loaded").set("io", t);
 		return t;
 	}

@@ -269,8 +287,15 @@ public class IoLib extends TwoArgFunction {
 	static final class IoLibV extends VarArgFunction {
 		private File f;
 		public IoLib iolib;
+		private boolean toclose;
+		private Varargs args;
 		public IoLibV() {
 		}
+		public IoLibV(File f, String name, int opcode, IoLib iolib, boolean toclose, Varargs args) {
+			this(f, name, opcode, iolib);
+			this.toclose = toclose;
+			this.args = args.dealias();
+		}
 		public IoLibV(File f, String name, int opcode, IoLib iolib) {
 			super();
 			this.f = f;
@@ -290,22 +315,26 @@ public class IoLib extends TwoArgFunction {
 				case IO_TYPE:		return iolib._io_type(args.arg1());
 				case IO_POPEN:		return iolib._io_popen(args.checkjstring(1),args.optjstring(2,"r"));
 				case IO_OPEN:		return iolib._io_open(args.checkjstring(1), args.optjstring(2,"r"));
-				case IO_LINES:		return iolib._io_lines(args.isvalue(1)? args.checkjstring(1): null);
+				case IO_LINES:		return iolib._io_lines(args);
 				case IO_READ:		return iolib._io_read(args);
 				case IO_WRITE:		return iolib._io_write(args);
 					
 				case FILE_CLOSE:	return iolib._file_close(args.arg1());
 				case FILE_FLUSH:	return iolib._file_flush(args.arg1());
-				case FILE_SETVBUF:	return iolib._file_setvbuf(args.arg1(),args.checkjstring(2),args.optint(3,1024));
-				case FILE_LINES:	return iolib._file_lines(args.arg1());
+				case FILE_SETVBUF:	return iolib._file_setvbuf(args.arg1(),args.checkjstring(2),args.optint(3,8192));
+				case FILE_LINES:	return iolib._file_lines(args);
 				case FILE_READ:		return iolib._file_read(args.arg1(),args.subargs(2));
 				case FILE_SEEK:		return iolib._file_seek(args.arg1(),args.optjstring(2,"cur"),args.optint(3,0));
 				case FILE_WRITE:	return iolib._file_write(args.arg1(),args.subargs(2));

 				case IO_INDEX:		return iolib._io_index(args.arg(2));
-				case LINES_ITER:	return iolib._lines_iter(f);
+				case LINES_ITER:	return iolib._lines_iter(f, toclose, this.args);
 				}
 			} catch ( IOException ioe ) {
+				if (opcode == LINES_ITER) {
+					String s = ioe.getMessage();
+					error(s != null ? s : ioe.toString());
+				}
 				return errorresult(ioe);
 			}
 			return NONE;
@@ -361,6 +390,7 @@ public class IoLib extends TwoArgFunction {

 	// io.popen(prog, [mode]) -> file
 	public Varargs _io_popen(String prog, String mode) throws IOException {
+		if (!"r".equals(mode) && !"w".equals(mode)) argerror(2, "invalid value: '" + mode + "'; must be one of 'r' or 'w'");
 		return openProgram(prog, mode);
 	}

@@ -369,11 +399,12 @@ public class IoLib extends TwoArgFunction {
 		return rawopenfile(FTYPE_NAMED, filename, mode);
 	}

-	//	io.lines(filename) -> iterator
-	public Varargs _io_lines(String filename) {
-		infile = filename==null? input(): ioopenfile(FTYPE_NAMED, filename,"r");
+	//	io.lines(filename, ...) -> iterator
+	public Varargs _io_lines(Varargs args) {
+		String filename = args.optjstring(1, null);
+		File infile = filename==null? input(): ioopenfile(FTYPE_NAMED, filename,"r");
 		checkopen(infile);
-		return lines(infile);
+		return lines(infile, filename != null, args.subargs(2));
 	}

 	//	io.read(...) -> (...)
@@ -401,13 +432,19 @@ public class IoLib extends TwoArgFunction {

 	// file:setvbuf(mode,[size]) -> void
 	public Varargs _file_setvbuf(LuaValue file, String mode, int size) {
+		if ("no".equals(mode)) {
+		} else if ("full".equals(mode)) {
+		} else if ("line".equals(mode)) {
+		} else {
+			argerror(1, "invalid value: '" + mode + "'; must be one of 'no', 'full' or 'line'");
+		}
 		checkfile(file).setvbuf(mode,size);
 		return LuaValue.TRUE;
 	}

-	// file:lines() -> iterator
-	public Varargs _file_lines(LuaValue file) {
-		return lines(checkfile(file));
+	// file:lines(...) -> iterator
+	public Varargs _file_lines(Varargs args) {
+		return lines(checkfile(args.arg1()), false, args.subargs(2));
 	}

 	//	file:read(...) -> (...)
@@ -417,6 +454,12 @@ public class IoLib extends TwoArgFunction {

 	//  file:seek([whence][,offset]) -> pos | nil,error
 	public Varargs _file_seek(LuaValue file, String whence, int offset) throws IOException {
+		if ("set".equals(whence)) {
+		} else if ("end".equals(whence)) {
+		} else if ("cur".equals(whence)) {
+		} else {
+			argerror(1, "invalid value: '" + whence + "'; must be one of 'set', 'cur' or 'end'");
+		}
 		return valueOf( checkfile(file).seek(whence,offset) );
 	}

@@ -433,8 +476,13 @@ public class IoLib extends TwoArgFunction {
 	}

 	//	lines iterator(s,var) -> var'
-	public Varargs _lines_iter(LuaValue file) throws IOException {
-		return freadline(checkfile(file));
+	public Varargs _lines_iter(LuaValue file, boolean toclose, Varargs args) throws IOException {
+		File f = optfile(file);
+		if ( f == null ) argerror(1, "not a file: " + file);
+		if ( f.isclosed() )	error("file is already closed");
+		Varargs ret = ioread(f, args);
+		if (toclose && ret.isnil(1) && f.eof()) f.close();
+		return ret;
 	}

 	private File output() {
@@ -467,7 +515,7 @@ public class IoLib extends TwoArgFunction {
 		return LuaValue.TRUE;
 	}

-	private static Varargs errorresult(Exception ioe) {
+	static Varargs errorresult(Exception ioe) {
 		String s = ioe.getMessage();
 		return errorresult("io error: "+(s!=null? s: ioe.toString()));
 	}
@@ -476,9 +524,9 @@ public class IoLib extends TwoArgFunction {
 		return varargsOf(NIL, valueOf(errortext));
 	}

-	private Varargs lines(final File f) {
+	private Varargs lines(final File f, boolean toclose, Varargs args) {
 		try {
-			return new IoLibV(f,"lnext",LINES_ITER,this);
+			return new IoLibV(f,"lnext",LINES_ITER,this,toclose,args);
 		} catch ( Exception e ) {
 			return error("lines: "+e);
 		}
@@ -492,6 +540,7 @@ public class IoLib extends TwoArgFunction {

 	private Varargs ioread(File f, Varargs args) throws IOException {
 		int i,n=args.narg();
+		if (n == 0) return freadline(f,false);
 		LuaValue[] v = new LuaValue[n];
 		LuaValue ai,vi;
 		LuaString fmt;
@@ -502,10 +551,11 @@ public class IoLib extends TwoArgFunction {
 					break item;
 				case LuaValue.TSTRING:
 					fmt = ai.checkstring();
-					if ( fmt.m_length == 2 && fmt.m_bytes[fmt.m_offset] == '*' ) {
+					if ( fmt.m_length >= 2 && fmt.m_bytes[fmt.m_offset] == '*' ) {
 						switch ( fmt.m_bytes[fmt.m_offset+1] ) {
 						case 'n': vi = freadnumber(f); break item;
-						case 'l': vi = freadline(f); break item;
+						case 'l': vi = freadline(f,false); break item;
+						case 'L': vi = freadline(f,true); break item;
 						case 'a': vi = freadall(f); break item;
 						}
 					}
@@ -537,6 +587,17 @@ public class IoLib extends TwoArgFunction {
 	}

 	private File rawopenfile(int filetype, String filename, String mode) throws IOException {
+		int len = mode.length();
+		for (int i = 0; i < len; i++) { // [rwa][+]?b*
+			char ch = mode.charAt(i);
+			if (i == 0 && "rwa".indexOf(ch) >= 0) continue;
+			if (i == 1 && ch == '+') continue;
+			if (i >= 1 && ch == 'b') continue;
+			len = -1;
+			break;
+		}
+		if (len <= 0) argerror(2, "invalid mode: '" + mode + "'");
+		
 		switch (filetype) {
 		case FTYPE_STDIN: return wrapStdin();
 		case FTYPE_STDOUT: return wrapStdout();
@@ -544,7 +605,7 @@ public class IoLib extends TwoArgFunction {
 		}
 		boolean isreadmode = mode.startsWith("r");
 		boolean isappend = mode.startsWith("a");
-		boolean isupdate = mode.indexOf("+") > 0;
+		boolean isupdate = mode.indexOf('+') > 0;
 		boolean isbinary = mode.endsWith("b");
 		return openFile( filename, isreadmode, isappend, isupdate, isbinary );
 	}
@@ -553,26 +614,27 @@ public class IoLib extends TwoArgFunction {
 	// ------------- file reading utilitied ------------------
 	
 	public static LuaValue freadbytes(File f, int count) throws IOException {
+		if (count == 0) return f.eof() ? NIL : EMPTYSTRING;
 		byte[] b = new byte[count];
 		int r;
 		if ( ( r = f.read(b,0,b.length) ) < 0 )
 			return NIL;
 		return LuaString.valueUsing(b, 0, r);
 	}
-	public static LuaValue freaduntil(File f,boolean lineonly) throws IOException {
+	public static LuaValue freaduntil(File f,boolean lineonly,boolean withend) throws IOException {
 		ByteArrayOutputStream baos = new ByteArrayOutputStream();
 		int c;
 		try {
 			if ( lineonly ) {
-				loop: while ( (c = f.read()) > 0 ) { 
+				loop: while ( (c = f.read()) >= 0 ) {
 					switch ( c ) {
-					case '\r': break;
-					case '\n': break loop;
+					case '\r': if (withend) baos.write(c); break;
+					case '\n': if (withend) baos.write(c); break loop;
 					default: baos.write(c); break;
 					}
 				}
 			} else {
-				while ( (c = f.read()) > 0 ) 
+				while ( (c = f.read()) >= 0 )
 					baos.write(c);
 			}
 		} catch ( EOFException e ) {
@@ -582,15 +644,15 @@ public class IoLib extends TwoArgFunction {
 			(LuaValue) NIL:
 			(LuaValue) LuaString.valueUsing(baos.toByteArray());
 	}
-	public static LuaValue freadline(File f) throws IOException {
-		return freaduntil(f,true);
+	public static LuaValue freadline(File f,boolean withend) throws IOException {
+		return freaduntil(f,true,withend);
 	}
 	public static LuaValue freadall(File f) throws IOException {
 		int n = f.remaining();
 		if ( n >= 0 ) {
-			return freadbytes(f, n);
+			return n == 0 ? EMPTYSTRING : freadbytes(f, n);
 		} else {
-			return freaduntil(f,false);
+			return freaduntil(f,false,false);
 		}
 	}
 	public static LuaValue freadnumber(File f) throws IOException {
--- a/src/core/org/luaj/vm2/lib/LibFunction.java
+++ b/src/core/org/luaj/vm2/lib/LibFunction.java
@@ -139,7 +139,7 @@ abstract public class LibFunction extends LuaFunction {
 	}
 	
 	public String tojstring() {
-		return name != null? name: super.tojstring();
+		return name != null ? "function: " + name : super.tojstring();
 	}
 	
 	/**
@@ -196,7 +196,7 @@ abstract public class LibFunction extends LuaFunction {
 	}

 	public LuaValue call() {
-		return argerror(1,"value");
+		return argerror(1,"value expected");
 	}
 	public LuaValue call(LuaValue a) {
 		return call();
--- a/src/core/org/luaj/vm2/lib/MathLib.java
+++ b/src/core/org/luaj/vm2/lib/MathLib.java
@@ -125,7 +125,7 @@ public class MathLib extends TwoArgFunction {
 		math.set("sqrt", new sqrt());
 		math.set("tan", new tan());
 		env.set("math", math);
-		env.get("package").get("loaded").set("math", math);
+		if (!env.get("package").isnil()) env.get("package").get("loaded").set("math", math);
 		return math;
 	}
 	
@@ -163,10 +163,12 @@ public class MathLib extends TwoArgFunction {
 		}
 	}
 	
-	static final class fmod extends BinaryOp {
-		protected double call(double x, double y) {
-			double q = x/y;
-			return x - y * (q>=0? Math.floor(q): Math.ceil(q));
+	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.checkdouble() % yv.checkdouble());
 		}
 	}
 	static final class ldexp extends BinaryOp {
@@ -194,27 +196,36 @@ public class MathLib extends TwoArgFunction {

 	static class max extends VarArgFunction {
 		public Varargs invoke(Varargs args) {
-			double m = args.checkdouble(1);
-			for ( int i=2,n=args.narg(); i<=n; ++i )
-				m = Math.max(m,args.checkdouble(i));
-			return valueOf(m);
+			LuaValue m = args.checkvalue(1);
+			for ( int i=2,n=args.narg(); i<=n; ++i ) {
+				LuaValue v = args.checkvalue(i);
+				if (m.lt_b(v)) m = v;
+			}
+			return m;
 		}
 	}
 	
 	static class min extends VarArgFunction {
 		public Varargs invoke(Varargs args) {
-			double m = args.checkdouble(1);
-			for ( int i=2,n=args.narg(); i<=n; ++i )
-				m = Math.min(m,args.checkdouble(i));
-			return valueOf(m);
+			LuaValue m = args.checkvalue(1);
+			for ( int i=2,n=args.narg(); i<=n; ++i ) {
+				LuaValue v = args.checkvalue(i);
+				if (v.lt_b(m)) m = v;
+			}
+			return m;
 		}
 	}
 	
 	static class modf extends VarArgFunction {
 		public Varargs invoke(Varargs args) {
-			double x = args.checkdouble(1);
+			LuaValue n = args.arg1();
+			/* number is its own integer part, no fractional part */
+			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 fracPart = x - intPart;
+			/* fractional part (test needed for inf/-inf) */
+			double fracPart = x == intPart ? 0.0 : x - intPart;
 			return varargsOf( valueOf(intPart), valueOf(fracPart) );
 		}
 	}
--- a/src/core/org/luaj/vm2/lib/OsLib.java
+++ b/src/core/org/luaj/vm2/lib/OsLib.java
@@ -80,8 +80,8 @@ import org.luaj.vm2.Varargs;
 * @see <a href="http://www.lua.org/manual/5.1/manual.html#5.8">http://www.lua.org/manual/5.1/manual.html#5.8</a>
 */
 public class OsLib extends TwoArgFunction {
-	public static String TMP_PREFIX    = ".luaj";
-	public static 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;
@@ -132,7 +132,7 @@ 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);
-		env.get("package").get("loaded").set("os", os);
+		if (!env.get("package").isnil()) env.get("package").get("loaded").set("os", os);
 		return os;
 	}

--- a/src/core/org/luaj/vm2/lib/PackageLib.java
+++ b/src/core/org/luaj/vm2/lib/PackageLib.java
@@ -81,23 +81,26 @@ public class PackageLib extends TwoArgFunction {

 	/** The default value to use for package.path.  This can be set with the system property
 	 * <code>"luaj.package.path"</code>, and is <code>"?.lua"</code> by default. */
-	public static String DEFAULT_LUA_PATH;
+	public static final String DEFAULT_LUA_PATH;
 	static {
+		String path = null;
 		try {
-			DEFAULT_LUA_PATH = System.getProperty("luaj.package.path");
+			path = System.getProperty("luaj.package.path");
 		} catch (Exception e) {
 			System.out.println(e.toString());
 		}
-		if (DEFAULT_LUA_PATH == null)
-			DEFAULT_LUA_PATH = "?.lua";
+		if (path == null) {
+			path = "?.lua";
+		}
+		DEFAULT_LUA_PATH = path;
 	}

-	private static final LuaString _LOADED      = valueOf("loaded");
+	static final LuaString _LOADED      = valueOf("loaded");
 	private static final LuaString _LOADLIB     = valueOf("loadlib");
-	private static final LuaString _PRELOAD     = valueOf("preload");
-	private static final LuaString _PATH        = valueOf("path");
-	private static final LuaString _SEARCHPATH  = valueOf("searchpath");
-	private static final LuaString _SEARCHERS   = valueOf("searchers");
+	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;
@@ -141,6 +144,7 @@ public class PackageLib extends TwoArgFunction {
 		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_);
 		env.set("package", package_);
 		globals.package_ = this;
@@ -233,7 +237,7 @@ public class PackageLib extends TwoArgFunction {
 	}

 	public static class loadlib extends VarArgFunction {
-		public Varargs loadlib( Varargs args ) {
+		public Varargs invoke( Varargs args ) {
 			args.checkstring(1);
 			return varargsOf(NIL, valueOf("dynamic libraries not enabled"), valueOf("absent"));
 		}
@@ -252,7 +256,6 @@ public class PackageLib extends TwoArgFunction {
 	public class lua_searcher extends VarArgFunction {
 		public Varargs invoke(Varargs args) {
 			LuaString name = args.checkstring(1);
-			InputStream is = null;
 					
 			// get package path
 			LuaValue path = package_.get(_PATH);
--- a/src/core/org/luaj/vm2/lib/StringLib.java
+++ b/src/core/org/luaj/vm2/lib/StringLib.java
@@ -24,8 +24,8 @@ package org.luaj.vm2.lib;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;

-import org.luaj.vm2.LuaClosure;
 import org.luaj.vm2.Buffer;
+import org.luaj.vm2.LuaClosure;
 import org.luaj.vm2.LuaString;
 import org.luaj.vm2.LuaTable;
 import org.luaj.vm2.LuaValue;
@@ -49,7 +49,7 @@ import org.luaj.vm2.compiler.DumpState;
 * Globals globals = new Globals();
 * globals.load(new JseBaseLib());
 * globals.load(new PackageLib());
- * globals.load(new StringLib());
+ * globals.load(new JseStringLib());
 * System.out.println( globals.get("string").get("upper").call( LuaValue.valueOf("abcde") ) );
 * } </pre>
 * <p>
@@ -83,8 +83,8 @@ public class StringLib extends TwoArgFunction {
 	 */
 	public LuaValue call(LuaValue modname, LuaValue env) {
 		LuaTable string = new LuaTable();
-		string.set("byte", new byte_());
-		string.set("char", new char_());
+		string.set("byte", new _byte());
+		string.set("char", new _char());
 		string.set("dump", new dump());
 		string.set("find", new find());
 		string.set("format", new format());
@@ -97,12 +97,12 @@ public class StringLib extends TwoArgFunction {
 		string.set("reverse", new reverse());
 		string.set("sub", new sub());
 		string.set("upper", new upper());
-		LuaTable mt = LuaValue.tableOf(
-				new LuaValue[] { INDEX, string });
+		
 		env.set("string", string);
-		env.get("package").get("loaded").set("string", string);
-		if (LuaString.s_metatable == null)
-			LuaString.s_metatable = mt;
+		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;
 	}
 	
@@ -117,7 +117,7 @@ public class StringLib extends TwoArgFunction {
 	 * 
 	 * @param args the calling args
 	 */
-	static final class byte_ extends VarArgFunction {
+	static final class _byte extends VarArgFunction {
 		public Varargs invoke(Varargs args) {
 			LuaString s = args.checkstring(1);
 			int l = s.m_length;
@@ -148,13 +148,13 @@ public class StringLib extends TwoArgFunction {
 	 * 
 	 * @param args the calling VM
 	 */
-	static final class char_ extends VarArgFunction {
+	static final class _char extends VarArgFunction {
 		public Varargs invoke(Varargs args) {
 			int n = args.narg();
 			byte[] bytes = new byte[n];
 			for ( int i=0, a=1; i<n; i++, a++ ) {
 				int c = args.checkint(a);
-				if (c<0 || c>=256) argerror(a, "invalid value");
+				if (c<0 || c>=256) argerror(a, "invalid value for string.char [0; 255]: " + c);
 				bytes[i] = (byte) c;
 			}
 			return LuaString.valueUsing( bytes );
@@ -162,20 +162,22 @@ public class StringLib extends TwoArgFunction {
 	}
 		
 	/**
-	 * string.dump (function)
+	 * string.dump (function[, stripDebug])
 	 * 
 	 * Returns a string containing a binary representation of the given function,
 	 * so that a later loadstring on this string returns a copy of the function.
 	 * function must be a Lua function without upvalues.
+	 * Boolean param stripDebug - true to strip debugging info, false otherwise.
+	 * The default value for stripDebug is true.
 	 * 
 	 * TODO: port dumping code as optional add-on
 	 */
-	static final class dump extends OneArgFunction {
-		public LuaValue call(LuaValue arg) {
-			LuaValue f = arg.checkfunction();
+	static final class dump extends VarArgFunction {
+		public Varargs invoke(Varargs args) {
+			LuaValue f = args.checkfunction(1);
 			ByteArrayOutputStream baos = new ByteArrayOutputStream();
 			try {
-				DumpState.dump( ((LuaClosure)f).p, baos, true );
+				DumpState.dump( ((LuaClosure)f).p, baos, args.optboolean(2, true) );
 				return LuaString.valueUsing(baos.toByteArray());
 			} catch (IOException e) {
 				return error( e.getMessage() );
@@ -228,7 +230,7 @@ public class StringLib extends TwoArgFunction {
 	 * This function does not accept string values containing embedded zeros,
 	 * except as arguments to the q option.
 	 */
-	static final class format extends VarArgFunction {
+	final class format extends VarArgFunction {
 		public Varargs invoke(Varargs args) {
 			LuaString fmt = args.checkstring( 1 );
 			final int n = fmt.length();
@@ -259,7 +261,7 @@ public class StringLib extends TwoArgFunction {
 								break;
 							case 'i':
 							case 'd':
-								fdsc.format( result, args.checkint( arg ) );
+								fdsc.format( result, args.checklong( arg ) );
 								break;
 							case 'o':
 							case 'u':
@@ -298,7 +300,7 @@ public class StringLib extends TwoArgFunction {
 		}
 	}
 	
-	private static void addquoted(Buffer buf, LuaString s) {
+	static void addquoted(Buffer buf, LuaString s) {
 		int c;
 		buf.append( (byte) '"' );
 		for ( int i = 0, n = s.length(); i < n; i++ ) {
@@ -328,7 +330,7 @@ public class StringLib extends TwoArgFunction {
 	
 	private static final String FLAGS = "-+ #0";
 	
-	static class FormatDesc {
+	class FormatDesc {
 		
 		private boolean leftAdjust;
 		private boolean zeroPad;
@@ -338,11 +340,13 @@ public class StringLib extends TwoArgFunction {
 		private static final int MAX_FLAGS = 5;
 		
 		private int width;
-		private int precision;
+		int precision;
 		
 		public final int conversion;
 		public final int length;
 		
+		public final String src;
+		
 		public FormatDesc(Varargs args, LuaString strfrmt, final int start) {
 			int p = start, n = strfrmt.length();
 			int c = 0;
@@ -390,6 +394,7 @@ public class StringLib extends TwoArgFunction {
 			zeroPad &= !leftAdjust; // '-' overrides '0'
 			conversion = c;
 			length = p - start;
+			src = strfrmt.substring(start - 1, p).tojstring();
 		}
 		
 		public void format(Buffer buf, byte c) {
@@ -465,8 +470,7 @@ public class StringLib extends TwoArgFunction {
 		}
 		
 		public void format(Buffer buf, double x) {
-			// TODO
-			buf.append( String.valueOf( x ) );
+			buf.append( StringLib.this.format(src, x) );
 		}
 		
 		public void format(Buffer buf, LuaString s) {
@@ -476,13 +480,17 @@ public class StringLib extends TwoArgFunction {
 			buf.append(s);
 		}
 		
-		public static final void pad(Buffer buf, char c, int n) {
+		public final void pad(Buffer buf, char c, int n) {
 			byte b = (byte)c;
 			while ( n-- > 0 )
 				buf.append(b);
 		}
 	}
 	
+	protected String format(String src, double x) {
+		return String.valueOf(x);
+	}
+	
 	/**
 	 * string.gmatch (s, pattern)
 	 * 
@@ -519,18 +527,20 @@ public class StringLib extends TwoArgFunction {
 		private final int srclen;
 		private final MatchState ms;
 		private int soffset;
+		private int lastmatch;
 		public GMatchAux(Varargs args, LuaString src, LuaString pat) {
 			this.srclen = src.length();
 			this.ms = new MatchState(args, src, pat);
 			this.soffset = 0;
+			this.lastmatch = -1;
 		}
 		public Varargs invoke(Varargs args) {
-			for ( ; soffset<srclen; soffset++ ) {
+			for ( ; soffset<=srclen; soffset++ ) {
 				ms.reset();
 				int res = ms.match(soffset, 0);
-				if ( res >=0 ) {
+				if ( res >=0 && res != lastmatch ) {
 					int soff = soffset;
-					soffset = res;
+					lastmatch = soffset = res;
 					return ms.push_captures( true, soff, res );
 				}
 			}
@@ -589,6 +599,7 @@ public class StringLib extends TwoArgFunction {
 			LuaString src = args.checkstring( 1 );
 			final int srclen = src.length();
 			LuaString p = args.checkstring( 2 );
+			int lastmatch = -1; /* end of last match */
 			LuaValue repl = args.arg( 3 );
 			int max_s = args.optint( 4, srclen + 1 );
 			final boolean anchor = p.length() > 0 && p.charAt( 0 ) == '^';
@@ -601,18 +612,15 @@ public class StringLib extends TwoArgFunction {
 			while ( n < max_s ) {
 				ms.reset();
 				int res = ms.match( soffset, anchor ? 1 : 0 );
-				if ( res != -1 ) {
+				if ( res != -1 && res != lastmatch ) {  /* match? */
 					n++;
-					ms.add_value( lbuf, soffset, res, repl );
+					ms.add_value( lbuf, soffset, res, repl );  /* add replacement to buffer */
+					soffset = lastmatch = res;
 				}
-				if ( res != -1 && res > soffset )
-					soffset = res;
-				else if ( soffset < srclen )
+				else if ( soffset < srclen ) /* otherwise, skip one character */
 					lbuf.append( (byte) src.luaByte( soffset++ ) );
-				else
-					break;
-				if ( anchor )
-					break;
+				else break;   /* end of subject */
+				if ( anchor ) break;
 			}
 			lbuf.append( src.substring( soffset, srclen ) );
 			return varargsOf(lbuf.tostring(), valueOf(n));
@@ -764,7 +772,7 @@ public class StringLib extends TwoArgFunction {
 			
 			boolean anchor = false;
 			int poff = 0;
-			if ( pat.luaByte( 0 ) == '^' ) {
+			if ( pat.length() > 0 && pat.luaByte( 0 ) == '^' ) {
 				anchor = true;
 				poff = 1;
 			}
@@ -785,7 +793,7 @@ public class StringLib extends TwoArgFunction {
 		return NIL;
 	}
 	
-	private static int posrelat( int pos, int len ) {
+	static int posrelat( int pos, int len ) {
 		return ( pos >= 0 ) ? pos : len + pos + 1;
 	}
 	
@@ -795,6 +803,8 @@ public class StringLib extends TwoArgFunction {
 	private static final LuaString SPECIALS = valueOf("^$*+?.([%-");
 	private static final int MAX_CAPTURES = 32;
 	
+	private static final int MAXCCALLS = 200;
+	
 	private static final int CAP_UNFINISHED = -1;
 	private static final int CAP_POSITION = -2;
 	
@@ -807,12 +817,12 @@ public class StringLib extends TwoArgFunction {
 	private static final byte MASK_CONTROL		= 0x40;
 	private static final byte MASK_HEXDIGIT		= (byte)0x80;
 	
-	private static final byte[] CHAR_TABLE;
+	static final byte[] CHAR_TABLE;
 	
 	static {
 		CHAR_TABLE = new byte[256];
 		
-		for ( int i = 0; i < 256; ++i ) {
+		for ( int i = 0; i < 128; ++i ) {
 			final char c = (char) i;
 			CHAR_TABLE[i] = (byte)( ( Character.isDigit( c ) ? MASK_DIGIT : 0 ) |
 							( Character.isLowerCase( c ) ? MASK_LOWERCASE : 0 ) |
@@ -821,7 +831,7 @@ public class StringLib extends TwoArgFunction {
 			if ( ( c >= 'a' && c <= 'f' ) || ( c >= 'A' && c <= 'F' ) || ( c >= '0' && c <= '9' ) ) {
 				CHAR_TABLE[i] |= MASK_HEXDIGIT;
 			}
-			if ( ( c >= '!' && c <= '/' ) || ( c >= ':' && c <= '@' ) ) {
+			if ( ( c >= '!' && c <= '/' ) || ( c >= ':' && c <= '@' ) || ( c >= '[' && c <= '`' ) || ( c >= '{' && c <= '~' ) ) {
 				CHAR_TABLE[i] |= MASK_PUNCT;
 			}
 			if ( ( CHAR_TABLE[i] & ( MASK_LOWERCASE | MASK_UPPERCASE ) ) != 0 ) {
@@ -833,11 +843,12 @@ public class StringLib extends TwoArgFunction {
 		CHAR_TABLE['\r'] |= MASK_SPACE;
 		CHAR_TABLE['\n'] |= MASK_SPACE;
 		CHAR_TABLE['\t'] |= MASK_SPACE;
-		CHAR_TABLE[0x0C /* '\v' */ ] |= MASK_SPACE;
+		CHAR_TABLE[0x0B /* '\v' */ ] |= MASK_SPACE;
 		CHAR_TABLE['\f'] |= MASK_SPACE;
 	};
 	
 	static class MatchState {
+		int matchdepth;  /* control for recursive depth (to avoid C stack overflow) */
 		final LuaString s;
 		final LuaString p;
 		final Varargs args;
@@ -852,10 +863,12 @@ public class StringLib extends TwoArgFunction {
 			this.level = 0;
 			this.cinit = new int[ MAX_CAPTURES ];
 			this.clen = new int[ MAX_CAPTURES ];
+			this.matchdepth = MAXCCALLS;
 		}
 		
 		void reset() {
 			level = 0;
+			this.matchdepth = MAXCCALLS;
 		}
 		
 		private void add_s( Buffer lbuf, LuaString news, int soff, int e ) {
@@ -866,8 +879,14 @@ public class StringLib extends TwoArgFunction {
 					lbuf.append( (byte) b );
 				} else {
 					++i; // skip ESC
-					b = (byte) news.luaByte( i );
+					b = (byte)(i < l ? news.luaByte( i ) : 0);
 					if ( !Character.isDigit( (char) b ) ) {
+						if (b != L_ESC) error( "invalid use of '" + (char)L_ESC +
+							"' in replacement string: after '" + (char)L_ESC +
+							"' must be '0'-'9' or '" + (char)L_ESC +
+							"', but found " + (i < l ? "symbol '" + (char)b + "' with code " + b +
+							" at pos " + (i + 1) :
+							"end of string"));
 						lbuf.append( b );
 					} else if ( b == '0' ) {
 						lbuf.append( s.substring( soff, e ) );
@@ -924,7 +943,7 @@ public class StringLib extends TwoArgFunction {
 				if ( i == 0 ) {
 					return s.substring( soff, end );
 				} else {
-					return error( "invalid capture index" );
+					return error( "invalid capture index %" + (i + 1) );
 				}
 			} else {
 				int l = clen[i];
@@ -943,7 +962,7 @@ public class StringLib extends TwoArgFunction {
 		private int check_capture( int l ) {
 			l -= '1';
 			if ( l < 0 || l >= level || this.clen[l] == CAP_UNFINISHED ) {
-				error("invalid capture index");
+				error("invalid capture index %" + (l + 1));
 			}
 			return l;
 		}
@@ -961,19 +980,19 @@ public class StringLib extends TwoArgFunction {
 			switch ( p.luaByte( poffset++ ) ) {
 			case L_ESC:
 				if ( poffset == p.length() ) {
-					error( "malformed pattern (ends with %)" );
+					error( "malformed pattern (ends with '%')" );
 				}
 				return poffset + 1;
 				
 			case '[':
-				if ( p.luaByte( poffset ) == '^' ) poffset++;
+				if ( poffset != p.length() && p.luaByte( poffset ) == '^' ) poffset++;
 				do {
 					if ( poffset == p.length() ) {
-						error( "malformed pattern (missing ])" );
+						error( "malformed pattern (missing ']')" );
 					}
-					if ( p.luaByte( poffset++ ) == L_ESC && poffset != p.length() )
-						poffset++;
-				} while ( p.luaByte( poffset ) != ']' );
+					if ( p.luaByte( poffset++ ) == L_ESC && poffset < p.length() )
+						poffset++; /* skip escapes (e.g. '%]') */
+				} while ( poffset == p.length() || p.luaByte( poffset ) != ']' );
 				return poffset + 1;
 			default:
 				return poffset;
@@ -993,9 +1012,10 @@ public class StringLib extends TwoArgFunction {
 			case 'c': res = ( cdata & MASK_CONTROL ) != 0; break;
 			case 'p': res = ( cdata & MASK_PUNCT ) != 0; break;
 			case 's': res = ( cdata & MASK_SPACE ) != 0; break;
+			case 'g': res = ( cdata & ( MASK_ALPHA | MASK_DIGIT | MASK_PUNCT ) ) != 0; break;
 			case 'w': res = ( cdata & ( MASK_ALPHA | MASK_DIGIT ) ) != 0; break;
 			case 'x': res = ( cdata & MASK_HEXDIGIT ) != 0; break;
-			case 'z': res = ( c == 0 ); break;
+			case 'z': res = ( c == 0 ); break;  /* deprecated option */
 			default: return cl == c;
 			}
 			return ( lcl == cl ) ? res : !res;
@@ -1037,80 +1057,86 @@ public class StringLib extends TwoArgFunction {
 		 * where match ends, otherwise returns -1.
 		 */
 		int match( int soffset, int poffset ) {
-			while ( true ) {
-				// Check if we are at the end of the pattern - 
-				// equivalent to the '\0' case in the C version, but our pattern
-				// string is not NUL-terminated.
-				if ( poffset == p.length() )
-					return soffset;
-				switch ( p.luaByte( poffset ) ) {
-				case '(':
-					if ( ++poffset < p.length() && p.luaByte( poffset ) == ')' )
-						return start_capture( soffset, poffset + 1, CAP_POSITION );
-					else
-						return start_capture( soffset, poffset, CAP_UNFINISHED );
-				case ')':
-					return end_capture( soffset, poffset + 1 );
-				case L_ESC:
-					if ( poffset + 1 == p.length() )
-						error("malformed pattern (ends with '%')");
-					switch ( p.luaByte( poffset + 1 ) ) {
-					case 'b':
-						soffset = matchbalance( soffset, poffset + 2 );
-						if ( soffset == -1 ) return -1;
-						poffset += 4;
-						continue;
-					case 'f': {
-						poffset += 2;
-						if ( p.luaByte( poffset ) != '[' ) {
-							error("Missing [ after %f in pattern");
+			if (matchdepth-- == 0) error("pattern too complex");
+			try {
+				while ( true ) {
+					// Check if we are at the end of the pattern -
+					// equivalent to the '\0' case in the C version, but our pattern
+					// string is not NUL-terminated.
+					if ( poffset == p.length() )
+						return soffset;
+					switch ( p.luaByte( poffset ) ) {
+					case '(':
+						if ( ++poffset < p.length() && p.luaByte( poffset ) == ')' )
+							return start_capture( soffset, poffset + 1, CAP_POSITION );
+						else
+							return start_capture( soffset, poffset, CAP_UNFINISHED );
+					case ')':
+						return end_capture( soffset, poffset + 1 );
+					case L_ESC:
+						if ( poffset + 1 == p.length() )
+							error("malformed pattern (ends with '%')");
+						switch ( p.luaByte( poffset + 1 ) ) {
+						case 'b':
+							soffset = matchbalance( soffset, poffset + 2 );
+							if ( soffset == -1 ) return -1;
+							poffset += 4;
+							continue;
+						case 'f': {
+							poffset += 2;
+							if ( poffset == p.length() || p.luaByte( poffset ) != '[' ) {
+								error("missing '[' after '%f' in pattern");
+							}
+							int ep = classend( poffset );
+							int previous = ( soffset == 0 ) ? '\0' : s.luaByte( soffset - 1 );
+							int next = ( soffset == s.length() ) ? '\0' : s.luaByte( soffset );
+							if ( matchbracketclass( previous, poffset, ep - 1 ) ||
+								 !matchbracketclass( next, poffset, ep - 1 ) )
+								return -1;
+							poffset = ep;
+							continue;
 						}
-						int ep = classend( poffset );
-						int previous = ( soffset == 0 ) ? -1 : s.luaByte( soffset - 1 );
-						if ( matchbracketclass( previous, poffset, ep - 1 ) ||
-							 matchbracketclass( s.luaByte( soffset ), poffset, ep - 1 ) )
+						default: {
+							int c = p.luaByte( poffset + 1 );
+							if ( Character.isDigit( (char) c ) ) {
+								soffset = match_capture( soffset, c );
+								if ( soffset == -1 )
+									return -1;
+								return match( soffset, poffset + 2 );
+							}
+						}
+						}
+					case '$':
+						if ( poffset + 1 == p.length() )
+							return ( soffset == s.length() ) ? soffset : -1;
+					}
+					int ep = classend( poffset );
+					boolean m = soffset < s.length() && singlematch( s.luaByte( soffset ), poffset, ep );
+					int pc = ( ep < p.length() ) ? p.luaByte( ep ) : '\0';
+					
+					switch ( pc ) {
+					case '?':
+						int res;
+						if ( m && ( ( res = match( soffset + 1, ep + 1 ) ) != -1 ) )
+							return res;
+						poffset = ep + 1;
+						continue;
+					case '*':
+						return max_expand( soffset, poffset, ep );
+					case '+':
+						return ( m ? max_expand( soffset + 1, poffset, ep ) : -1 );
+					case '-':
+						return min_expand( soffset, poffset, ep );
+					default:
+						if ( !m )
 							return -1;
+						soffset++;
 						poffset = ep;
 						continue;
 					}
-					default: {
-						int c = p.luaByte( poffset + 1 );
-						if ( Character.isDigit( (char) c ) ) {
-							soffset = match_capture( soffset, c );
-							if ( soffset == -1 )
-								return -1;
-							return match( soffset, poffset + 2 );
-						}
-					}
-					}
-				case '$':
-					if ( poffset + 1 == p.length() )
-						return ( soffset == s.length() ) ? soffset : -1;
-				}
-				int ep = classend( poffset );
-				boolean m = soffset < s.length() && singlematch( s.luaByte( soffset ), poffset, ep );
-				int pc = ( ep < p.length() ) ? p.luaByte( ep ) : '\0';
-				
-				switch ( pc ) {
-				case '?':
-					int res;
-					if ( m && ( ( res = match( soffset + 1, ep + 1 ) ) != -1 ) )
-						return res;
-					poffset = ep + 1;
-					continue;
-				case '*':
-					return max_expand( soffset, poffset, ep );
-				case '+':
-					return ( m ? max_expand( soffset + 1, poffset, ep ) : -1 );
-				case '-':
-					return min_expand( soffset, poffset, ep );
-				default:
-					if ( !m )
-						return -1;
-					soffset++;
-					poffset = ep;
-					continue;
 				}
+			} finally {
+				matchdepth++;
 			}
 		}
 		
@@ -1175,7 +1201,7 @@ public class StringLib extends TwoArgFunction {
 		int matchbalance( int soff, int poff ) {
 			final int plen = p.length();
 			if ( poff == plen || poff + 1 == plen ) {
-				error( "unbalanced pattern" );
+				error( "malformed pattern (missing arguments to '%b')" );
 			}
 			final int slen = s.length();
 			if ( soff >= slen )
--- a/src/core/org/luaj/vm2/lib/TableLib.java
+++ b/src/core/org/luaj/vm2/lib/TableLib.java
@@ -70,16 +70,10 @@ public class TableLib extends TwoArgFunction {
 		table.set("sort", new sort());
 		table.set("unpack", new unpack());
 		env.set("table", table);
-		env.get("package").get("loaded").set("table", table);
+		if (!env.get("package").isnil()) env.get("package").get("loaded").set("table", table);
 		return NIL;
 	}
 	
-	static class TableLibFunction extends LibFunction {
-		public LuaValue call() {
-			return argerror(1, "table expected, got no value");
-		}
-	}
-	
 	// "concat" (table [, sep [, i [, j]]]) -> string
 	static class concat extends TableLibFunction {
 		public LuaValue call(LuaValue list) {
@@ -100,18 +94,22 @@ public class TableLib extends TwoArgFunction {
 	static class insert extends VarArgFunction {
 		public Varargs invoke(Varargs args) {
 			switch (args.narg()) {
-			case 0: case 1: {
-				return argerror(2, "value expected");
-			}
 			case 2: {
-				LuaTable table = args.arg1().checktable();
+				LuaTable table = args.checktable(1);
 				table.insert(table.length()+1,args.arg(2));
 				return NONE;
 			}
-			default: {
-				args.arg1().checktable().insert(args.checkint(2),args.arg(3));
+			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);
+				table.insert(pos, args.arg(3));
 				return NONE;
 			}
+			default: {
+				return error("wrong number of arguments to 'table.insert': " + args.narg() + " (must be 2 or 3)");
+			}
 			}
 		}
 	}
@@ -128,15 +126,21 @@ public class TableLib extends TwoArgFunction {
 	// "remove" (table [, pos]) -> removed-ele
 	static class remove extends VarArgFunction {
 		public Varargs invoke(Varargs args) {
-			return args.arg1().checktable().remove(args.optint(2, 0));
+			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));
+			}
+			return table.remove(pos);
 		}
 	}

 	// "sort" (table [, comp])
 	static class sort extends VarArgFunction {
 		public Varargs invoke(Varargs args) {
-			args.arg1().checktable().sort(
-					args.arg(2).isnil()? NIL: args.arg(2).checkfunction());
+			args.checktable(1).sort(
+					args.isnil(2)? NIL: args.checkfunction(2));
 			return NONE;
 		}
 	}
@@ -146,11 +150,9 @@ public class TableLib extends TwoArgFunction {
 	static class unpack extends VarArgFunction {
 		public Varargs invoke(Varargs args) {
 			LuaTable t = args.checktable(1);
-			switch (args.narg()) {
-			case 1: return t.unpack();
-			case 2: return t.unpack(args.checkint(2));
-			default: return t.unpack(args.checkint(2), args.checkint(3));
-			}
+			// do not waste resource for calc rawlen if arg3 is not nil
+			int len = args.arg(3).isnil() ? t.length() : 0;
+			return t.unpack(args.optint(2, 1), args.optint(3, len));
 		}
 	}
 }
--- a/src/core/org/luaj/vm2/lib/TableLibFunction.java
+++ b/src/core/org/luaj/vm2/lib/TableLibFunction.java
@@ -0,0 +1,9 @@
+package org.luaj.vm2.lib;
+
+import org.luaj.vm2.LuaValue;
+
+class TableLibFunction extends LibFunction {
+	public LuaValue call() {
+		return argerror(1, "table expected, got no value");
+	}
+}
--- a/src/jse/org/luaj/vm2/ast/Visitor.java
+++ b/src/jse/org/luaj/vm2/ast/Visitor.java
@@ -101,7 +101,7 @@ abstract public class Visitor {
 		visitExps(args.exps);
 	}
 	public void visit(TableField field) {
-		if ( field.name != null );
+		if ( field.name != null )
 			visit( field.name );
 		if ( field.index != null )
 			field.index.accept(this);
--- a/src/jse/org/luaj/vm2/lib/jse/CoerceJavaToLua.java
+++ b/src/jse/org/luaj/vm2/lib/jse/CoerceJavaToLua.java
@@ -21,6 +21,7 @@
 ******************************************************************************/
 package org.luaj.vm2.lib.jse;

+import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;

@@ -133,7 +134,7 @@ public class CoerceJavaToLua {
 	}


-	static final Map COERCIONS = new HashMap();
+	static final Map COERCIONS = Collections.synchronizedMap(new HashMap());
 	
 	static {
 		Coercion boolCoercion = new BoolCoercion() ;
--- a/src/jse/org/luaj/vm2/lib/jse/CoerceLuaToJava.java
+++ b/src/jse/org/luaj/vm2/lib/jse/CoerceLuaToJava.java
@@ -174,13 +174,13 @@ 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() );
+			case TARGET_TYPE_BYTE: return (byte) value.toint() ;
+			case TARGET_TYPE_CHAR: return (char) value.toint() ;
+			case TARGET_TYPE_SHORT: return (short) value.toint();
+			case TARGET_TYPE_INT: return value.toint();
+			case TARGET_TYPE_LONG: return (long) value.todouble();
+			case TARGET_TYPE_FLOAT: return (float) value.todouble();
+			case TARGET_TYPE_DOUBLE: return (double) value.todouble();
 			default: return null;
 			}
 		}
@@ -308,7 +308,7 @@ public class CoerceLuaToJava {
 		public Object coerce(LuaValue value) {
 			switch ( value.type() ) {
 			case LuaValue.TNUMBER:
-				return value.isint()? (Object)new Integer(value.toint()): (Object)new Double(value.todouble());
+				return value.isint()? value.toint() : value.todouble();
 			case LuaValue.TBOOLEAN:
 				return value.toboolean()? Boolean.TRUE: Boolean.FALSE;
 			case LuaValue.TSTRING:
--- a/src/jse/org/luaj/vm2/lib/jse/JseBaseLib.java
+++ b/src/jse/org/luaj/vm2/lib/jse/JseBaseLib.java
@@ -21,6 +21,7 @@
 ******************************************************************************/
 package org.luaj.vm2.lib.jse;

+import java.io.BufferedInputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
@@ -106,9 +107,10 @@ public class JseBaseLib extends org.luaj.vm2.lib.BaseLib {
 		if ( ! f.exists() )
 			return super.findResource(filename);
 		try {
-			return new FileInputStream(f);
+			return new BufferedInputStream(new FileInputStream(f));
 		} catch ( IOException ioe ) {
 			return null;
 		}
 	}
 }
+
--- a/src/jse/org/luaj/vm2/lib/jse/JseIoLib.java
+++ b/src/jse/org/luaj/vm2/lib/jse/JseIoLib.java
@@ -133,7 +133,7 @@ public class JseIoLib extends IoLib {
 			this( null, null, o );
 		}
 		public String tojstring() {
-			return "file ("+this.hashCode()+")";
+			return "file (" + (this.closed ? "closed" : String.valueOf(this.hashCode())) + ")";
 		}
 		public boolean isstdfile() {
 			return file == null;
@@ -321,7 +321,7 @@ public class JseIoLib extends IoLib {
 		}

 		public int remaining() throws IOException {
-			return 0;
+			return -1;
 		}

 		public int peek() throws IOException, EOFException {
--- a/src/jse/org/luaj/vm2/lib/jse/JseMathLib.java
+++ b/src/jse/org/luaj/vm2/lib/jse/JseMathLib.java
@@ -24,6 +24,7 @@ package org.luaj.vm2.lib.jse;
 import org.luaj.vm2.Globals;
 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} 
@@ -76,8 +77,9 @@ public class JseMathLib extends org.luaj.vm2.lib.MathLib {
 		LuaValue math = env.get("math");
 		math.set("acos", new acos());
 		math.set("asin", new asin());
-		math.set("atan", new atan());
-		math.set("atan2", new atan2());
+		LuaValue atan =  new atan2();
+		math.set("atan", atan);
+		math.set("atan2", atan);
 		math.set("cosh", new cosh());
 		math.set("exp", new exp());
 		math.set("log", new log());
@@ -89,11 +91,21 @@ public class JseMathLib extends org.luaj.vm2.lib.MathLib {

 	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 atan extends UnaryOp { protected double call(double d) { return Math.atan(d); } }
-	static final class atan2 extends BinaryOp { protected double call(double y, double x) { return Math.atan2(y, x); } }
+	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 log extends UnaryOp { protected double call(double d) { return Math.log(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);
+			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); } }
@@ -105,3 +117,4 @@ public class JseMathLib extends org.luaj.vm2.lib.MathLib {
 	
 	
 }
+
--- a/src/jse/org/luaj/vm2/lib/jse/JseOsLib.java
+++ b/src/jse/org/luaj/vm2/lib/jse/JseOsLib.java
@@ -74,13 +74,13 @@ import org.luaj.vm2.lib.OsLib;
 public class JseOsLib extends org.luaj.vm2.lib.OsLib {
 	
 	/** return code indicating the execute() threw an I/O exception */
-	public static int EXEC_IOEXCEPTION =  1;
+	public static final int EXEC_IOEXCEPTION =  1;
 	
 	/** return code indicating the execute() was interrupted */
-	public static int EXEC_INTERRUPTED = -2;
+	public static final int EXEC_INTERRUPTED = -2;
 	
 	/** return code indicating the execute() threw an unknown exception */
-	public static int EXEC_ERROR       = -3;
+	public static final int EXEC_ERROR       = -3;
 	
 	/** public constructor */
 	public JseOsLib() {
@@ -120,13 +120,13 @@ public class JseOsLib extends org.luaj.vm2.lib.OsLib {
 		if ( ! f.exists() )
 			throw new IOException("No such file or directory");
 		if ( ! f.renameTo(new File(newname)) )
-			throw new IOException("Failed to delete");
+			throw new IOException("Failed to rename");
 	}

 	protected String tmpname() {
 		try {
 			java.io.File f = java.io.File.createTempFile(TMP_PREFIX ,TMP_SUFFIX);
-			return f.getName();
+			return f.getAbsolutePath();
 		} catch ( IOException ioe ) {
 			return super.tmpname();
 		}
--- a/src/jse/org/luaj/vm2/lib/jse/JsePlatform.java
+++ b/src/jse/org/luaj/vm2/lib/jse/JsePlatform.java
@@ -23,8 +23,8 @@ package org.luaj.vm2.lib.jse;

 import org.luaj.vm2.Globals;
 import org.luaj.vm2.LoadState;
-import org.luaj.vm2.LuaThread;
 import org.luaj.vm2.LuaValue;
+import org.luaj.vm2.Varargs;
 import org.luaj.vm2.compiler.LuaC;
 import org.luaj.vm2.lib.Bit32Lib;
 import org.luaj.vm2.lib.CoroutineLib;
@@ -97,7 +97,7 @@ public class JsePlatform {
 		globals.load(new PackageLib());
 		globals.load(new Bit32Lib());
 		globals.load(new TableLib());
-		globals.load(new StringLib());
+		globals.load(new JseStringLib());
 		globals.load(new CoroutineLib());
 		globals.load(new JseMathLib());
 		globals.load(new JseIoLib());
@@ -124,10 +124,11 @@ public class JsePlatform {


 	/** Simple wrapper for invoking a lua function with command line arguments.
-	 * The supplied function is first given a new Globals object, 
+	 * 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 void luaMain(LuaValue mainChunk, String[] args) {
+	public static Varargs luaMain(LuaValue mainChunk, String[] args) {
 		Globals g = standardGlobals();
 		int n = args.length;
 		LuaValue[] vargs = new LuaValue[args.length];
@@ -137,6 +138,6 @@ public class JsePlatform {
 		arg.set("n", n);
 		g.set("arg", arg);
 		mainChunk.initupvalue1(g);
-		mainChunk.invoke(LuaValue.varargsOf(vargs));
+		return mainChunk.invoke(LuaValue.varargsOf(vargs));
 	}
 }
--- a/src/jse/org/luaj/vm2/lib/jse/JseStringLib.java
+++ b/src/jse/org/luaj/vm2/lib/jse/JseStringLib.java
@@ -0,0 +1,39 @@
+/*******************************************************************************
+* Copyright (c) 2009 Luaj.org. All rights reserved.
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+* 
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+* THE SOFTWARE.
+******************************************************************************/
+package org.luaj.vm2.lib.jse;
+
+public class JseStringLib extends org.luaj.vm2.lib.StringLib {
+	
+	/** public constructor */
+	public JseStringLib() {
+	}
+
+	protected String format(String src, double x) {
+		String out;
+		try {
+			out = String.format(src, new Object[] {Double.valueOf(x)});
+		} catch (Throwable e) {
+			out = super.format(src, x);
+		}
+		return out;
+	}
+}
--- a/src/jse/org/luaj/vm2/lib/jse/LuajavaLib.java
+++ b/src/jse/org/luaj/vm2/lib/jse/LuajavaLib.java
@@ -112,7 +112,7 @@ public class LuajavaLib extends VarArgFunction {
 				LuaTable t = new LuaTable();
 				bind( t, this.getClass(), NAMES, BINDCLASS );
 				env.set("luajava", t);
-				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: {
--- a/src/jse/org/luaj/vm2/script/LuaScriptEngine.java
+++ b/src/jse/org/luaj/vm2/script/LuaScriptEngine.java
@@ -244,8 +244,8 @@ public class LuaScriptEngine extends AbstractScriptEngine implements ScriptEngin
 		case LuaValue.TSTRING: return luajValue.tojstring();
 		case LuaValue.TUSERDATA: return luajValue.checkuserdata(Object.class);
 		case LuaValue.TNUMBER: return luajValue.isinttype()? 
-				(Object) new Integer(luajValue.toint()): 
-				(Object) new Double(luajValue.todouble());
+				luajValue.toint(): 
+				luajValue.todouble();
 		default: return luajValue;
 		}
 	}
--- a/test/junit/org/luaj/vm2/AllTests.java
+++ b/test/junit/org/luaj/vm2/AllTests.java
@@ -32,6 +32,7 @@ import org.luaj.vm2.compiler.DumpLoadEndianIntTest;
 import org.luaj.vm2.compiler.LuaParserTests;
 import org.luaj.vm2.compiler.RegressionTests;
 import org.luaj.vm2.compiler.SimpleTests;
+import org.luaj.vm2.lib.jse.JsePlatformTest;
 import org.luaj.vm2.lib.jse.LuaJavaCoercionTest;
 import org.luaj.vm2.lib.jse.LuajavaAccessibleMembersTest;
 import org.luaj.vm2.lib.jse.LuajavaClassMembersTest;
@@ -85,6 +86,7 @@ public class AllTests {
 		
 		// library tests
 		TestSuite lib = new TestSuite("Library Tests");
+		lib.addTestSuite(JsePlatformTest.class);
 		lib.addTestSuite(LuajavaAccessibleMembersTest.class);
 		lib.addTestSuite(LuajavaClassMembersTest.class);
 		lib.addTestSuite(LuaJavaCoercionTest.class);
--- a/test/junit/org/luaj/vm2/lib/jse/JsePlatformTest.java
+++ b/test/junit/org/luaj/vm2/lib/jse/JsePlatformTest.java
@@ -0,0 +1,21 @@
+package org.luaj.vm2.lib.jse;
+
+import junit.framework.TestCase;
+
+import org.luaj.vm2.Globals;
+import org.luaj.vm2.LuaValue;
+import org.luaj.vm2.Varargs;
+
+
+public class JsePlatformTest extends TestCase {
+	public void testLuaMainPassesArguments() {
+		Globals globals = JsePlatform.standardGlobals();   
+		LuaValue chunk = globals.load("return #arg, arg.n, arg[2], arg[1]");
+		Varargs results = JsePlatform.luaMain(chunk, new String[] { "aaa", "bbb" });
+		assertEquals(results.narg(), 4);
+		assertEquals(results.arg(1), LuaValue.valueOf(2));
+		assertEquals(results.arg(2), LuaValue.valueOf(2));
+		assertEquals(results.arg(3), LuaValue.valueOf("bbb"));
+		assertEquals(results.arg(4), LuaValue.valueOf("aaa"));
+	}
+}
--- a/version.properties
+++ b/version.properties
@@ -1 +1 @@
-version: 3.0.1
+version: 3.1.0