Improved Lua error handling, propagating JVM errors through Lua as objects, display Lua call stacks

lua_glue.c

@@ -13,12 +13,7 @@ static int lua_jniFunc(lua_State *state) {
 	jint result = (*env)->CallIntMethod(env, *lua_JCClosure, callback, (long long) state);
 
 	if (result <= -1) {
-		const char* errMsg = lua_tostring(state, -1);
+		return lua_error(state);
-
-		if (errMsg == NULL)
-			return luaL_error(state, "Internal JVM Error");
-
-		return luaL_error(state, "%s", errMsg);
 	}
 
 	return result;

src/main/java/ru/dbotthepony/kstarbound/lua/LuaJNR.java

@@ -32,9 +32,9 @@ public interface LuaJNR {
 	@IgnoreError
 	public int lua_pcallk(@NotNull Pointer luaState, int numArgs, int numResults, int msgh, @LongLong long ctx, @LongLong long callback);
 	@IgnoreError
-	public int lua_callk(@NotNull Pointer luaState, int numArgs, int numResults, @LongLong long ctx, @LongLong long callback);
-	@IgnoreError
 	public long lua_atpanic(@NotNull Pointer luaState, @LongLong long fn);
+	@IgnoreError
+	public long luaL_traceback(@NotNull Pointer luaState, @NotNull Pointer forState, @NotNull String message, int level);
 
 	/**
 	 * Creates a new thread, pushes it on the stack, and returns a pointer to a lua_State that represents this new thread. The new thread returned by this function shares with the original thread its global environment, but has an independent execution stack.

src/main/kotlin/ru/dbotthepony/kstarbound/defs/item/ItemDescriptor.kt

@@ -274,7 +274,6 @@ data class ItemDescriptor(
 				push(parameters)
 				push(level)
 				push(seed)
-				5
 			}, { getJson() as JsonObject to getJson() as JsonObject }).get()
 		} finally {
 			lua.close()

src/main/kotlin/ru/dbotthepony/kstarbound/lua/Errors.kt

@@ -16,17 +16,6 @@ const val LUA_ERRMEM = 4
 const val LUA_ERRERR = 5
 
 class InvalidLuaSyntaxException(message: String? = null, cause: Throwable? = null) : RuntimeException(message, cause)
-class LuaMemoryAllocException(message: String? = null, cause: Throwable? = null) : RuntimeException(message, cause)
+class LuaMemoryAllocException(message: String? = null, cause: Throwable? = null) : Error(message, cause)
-class LuaGCException(message: String? = null, cause: Throwable? = null) : RuntimeException(message, cause)
 class LuaException(message: String? = null, cause: Throwable? = null) : RuntimeException(message, cause)
 class LuaRuntimeException(message: String? = null, cause: Throwable? = null) : RuntimeException(message, cause)
-
-fun throwPcallError(code: Int) {
-	when (code) {
-		LUA_OK -> {}
-		LUA_ERRRUN -> throw LuaException("Runtime Error")
-		LUA_ERRMEM -> throw LuaMemoryAllocException()
-		LUA_ERRERR -> throw LuaException("Exception inside Exception handler")
-		else -> throw LuaException("Unknown Lua Loading error: $code")
-	}
-}

src/main/kotlin/ru/dbotthepony/kstarbound/lua/LuaHandle.kt

@@ -1,36 +1,168 @@
 package ru.dbotthepony.kstarbound.lua
 
+import com.google.gson.JsonElement
+import com.google.gson.JsonNull
+import com.google.gson.JsonPrimitive
 import ru.dbotthepony.kstarbound.Starbound
+import ru.dbotthepony.kstarbound.json.InternedJsonElementAdapter
 import java.io.Closeable
 import java.lang.ref.Cleaner.Cleanable
 
-class LuaHandle(private val parent: LuaSharedState, val handle: Int, val key: Any?) : Closeable {
+interface LuaHandle : Closeable {
-	private val cleanable: Cleanable
+	fun push(into: LuaThread)
+	override fun close() {}
+	fun toJson(): JsonElement
+	val type: LuaType
 
-	var isValid = true
+	object Nil : LuaHandle {
-		private set
+		override fun push(into: LuaThread) {
-
+			into.push()
-	init {
-		val parent = parent
-		val handle = handle
-		val key = key
-
-		cleanable = Starbound.CLEANER.register(this) {
-			parent.freeHandle(handle, key)
 		}
 
+		override fun toString(): String {
+			return "LuaHandle.Nil"
+		}
+
+		override fun toJson(): JsonElement {
+			return JsonNull.INSTANCE
+		}
+
+		override val type: LuaType
+			get() = LuaType.NIL
 	}
 
-	fun push(into: LuaThread) {
+	object True : LuaHandle {
-		check(isValid) { "Tried to use NULL handle!" }
+		override fun push(into: LuaThread) {
-		parent.handlesThread.push()
+			into.push(true)
-		parent.handlesThread.copy(handle, -1)
+		}
-		parent.handlesThread.moveStackValuesOnto(into)
+
+		override fun toString(): String {
+			return "LuaHandle.True"
+		}
+
+		override fun toJson(): JsonElement {
+			return InternedJsonElementAdapter.TRUE
+		}
+
+		override val type: LuaType
+			get() = LuaType.BOOLEAN
 	}
 
-	override fun close() {
+	object False : LuaHandle {
-		if (!isValid) return
+		override fun push(into: LuaThread) {
-		cleanable.clean()
+			into.push(false)
-		isValid = false
+		}
+
+		override fun toString(): String {
+			return "LuaHandle.False"
+		}
+
+		override fun toJson(): JsonElement {
+			return InternedJsonElementAdapter.FALSE
+		}
+
+		override val type: LuaType
+			get() = LuaType.BOOLEAN
+	}
+
+	class LLong(val value: Long) : LuaHandle {
+		override fun push(into: LuaThread) {
+			into.push(value)
+		}
+
+		override fun equals(other: Any?): Boolean {
+			return other is LLong && other.value == value
+		}
+
+		override fun hashCode(): Int {
+			return value.hashCode()
+		}
+
+		override fun toString(): String {
+			return "LuaHandle.LLong[$value]"
+		}
+
+		override fun toJson(): JsonElement {
+			return JsonPrimitive(value)
+		}
+
+		override val type: LuaType
+			get() = LuaType.NUMBER
+	}
+
+	class LDouble(val value: Double) : LuaHandle {
+		override fun push(into: LuaThread) {
+			into.push(value)
+		}
+
+		override fun equals(other: Any?): Boolean {
+			return other is LDouble && other.value == value
+		}
+
+		override fun hashCode(): Int {
+			return value.hashCode()
+		}
+
+		override fun toString(): String {
+			return "LuaHandle.LDouble[$value]"
+		}
+
+		override fun toJson(): JsonElement {
+			return JsonPrimitive(value)
+		}
+
+		override val type: LuaType
+			get() = LuaType.NUMBER
+	}
+
+	class Regular(private val parent: LuaSharedState, val handle: Int, val key: Any?) : LuaHandle {
+		private val cleanable: Cleanable
+
+		var isValid = true
+			private set
+
+		override val type: LuaType by lazy(LazyThreadSafetyMode.NONE) {
+			check(isValid) { "Tried to use NULL handle!" }
+			parent.handlesThread.typeAt(handle)
+		}
+
+		init {
+			val parent = parent
+			val handle = handle
+			val key = key
+
+			cleanable = Starbound.CLEANER.register(this) {
+				parent.freeHandle(handle, key)
+			}
+
+		}
+
+		override fun push(into: LuaThread) {
+			check(isValid) { "Tried to use NULL handle!" }
+			parent.handlesThread.push()
+			parent.handlesThread.copy(handle, -1)
+			parent.handlesThread.moveStackValuesOnto(into)
+		}
+
+		override fun close() {
+			if (!isValid) return
+			cleanable.clean()
+			isValid = false
+		}
+
+		override fun toJson(): JsonElement {
+			check(isValid) { "Tried to use NULL handle!" }
+			return parent.handlesThread.getJson(handle)!!
+		}
+
+		override fun toString(): String {
+			return "LuaHandle[$parent - $handle / $key]"
+		}
+	}
+
+	companion object {
+		fun boolean(of: Boolean): LuaHandle {
+			if (of) return True else return False
+		}
 	}
 }

src/main/kotlin/ru/dbotthepony/kstarbound/lua/LuaMessageHandlerComponent.kt

@@ -38,19 +38,16 @@ class LuaMessageHandlerComponent(val lua: LuaThread, val nameProvider: () -> Str
 		return handlers[name]
 	}
 
-	inline fun handle(message: String, isLocal: Boolean, arguments: LuaThread.() -> Int): JsonElement? {
+	fun handle(message: String, isLocal: Boolean, arguments: LuaThread.() -> Int): JsonElement? {
 		val handler = lookupHandler(message) ?: return null
 		val top = lua.stackTop
 
 		try {
-			lua.push(handler)
+			return lua.call(1, {
-			lua.push(isLocal)
+				push(handler)
-			val amountOfArguments = arguments(lua)
+				push(isLocal)
-			check(amountOfArguments >= 0) { "Invalid amount of arguments to pass to Lua handler: $amountOfArguments" }
+				arguments(lua)
-
+			}, { getJson(it) })
-			lua.call(amountOfArguments + 1, 1)
-
-			return lua.getJson()
 		} catch (err: Throwable) {
 			if (logPacer.consumeAndReturnDeadline() <= 0L)
 				LOGGER.error("${nameProvider.invoke()}: Exception while handling message '$message'", err)

src/main/kotlin/ru/dbotthepony/kstarbound/lua/LuaSharedState.kt

@@ -30,6 +30,16 @@ class LuaSharedState(val handlesThread: LuaThread, private val cleanable: Cleana
 		check(isValid) { "Tried to use NULL LuaState!" }
 	}
 
+	var errorToStringFunction by Delegates.notNull<LuaHandle>()
+		private set
+
+	var errorTrapFunction by Delegates.notNull<LuaHandle>()
+		private set
+
+	override fun toString(): String {
+		return "LuaSharedState[$handlesThread]"
+	}
+
 	override fun close() {
 		if (!isValid) return
 		isValid = false
@@ -45,6 +55,36 @@ class LuaSharedState(val handlesThread: LuaThread, private val cleanable: Cleana
 			future = future,
 			pathFinder = pathFinder,
 		)
+
+		handlesThread.push {
+			//it.lua.push(it.nextObject<Throwable>().stackTraceToString())
+			it.lua.push(it.nextObject<Any?>().toString())
+			1
+		}
+
+		errorToStringFunction = allocateHandle(null)
+
+		handlesThread.push {
+			val peek = it.peek()
+
+			if (peek == LuaType.STRING) {
+				it.lua.traceback(it.lua.getString()!!, 1)
+				val err = LuaRuntimeException(it.lua.getString())
+				it.lua.push(err)
+			} else if (peek == LuaType.USERDATA) {
+				val obj = it.nextObject<Any>()
+
+				if (obj is Throwable && obj !is LuaRuntimeException) {
+					it.lua.traceback(obj.toString(), 1)
+					val err = LuaRuntimeException(it.lua.getString(), cause = obj)
+					it.lua.push(err)
+				}
+			}
+
+			1
+		}
+
+		errorTrapFunction = allocateHandle(null)
 	}
 
 	fun freeHandle(handle: Int, key: Any?) {
@@ -79,10 +119,10 @@ class LuaSharedState(val handlesThread: LuaThread, private val cleanable: Cleana
 
 		if (freeHandles.isEmpty()) {
 			if (nextHandle % 10 == 0) {
-				handlesThread.ensureExtraCapacity(10)
+				handlesThread.ensureExtraCapacity(20)
 			}
 
-			return LuaHandle(this, ++nextHandle, name).also {
+			return LuaHandle.Regular(this, ++nextHandle, name).also {
 				if (name != null) namedHandles[name] = it
 			}
 		} else {
@@ -92,7 +132,7 @@ class LuaSharedState(val handlesThread: LuaThread, private val cleanable: Cleana
 			handlesThread.copy(-1, handle)
 			handlesThread.pop()
 
-			return LuaHandle(this, handle, name).also {
+			return LuaHandle.Regular(this, handle, name).also {
 				if (name != null) namedHandles[name] = it
 			}
 		}

src/main/kotlin/ru/dbotthepony/kstarbound/lua/LuaThread.kt

@@ -96,8 +96,9 @@ class LuaThread private constructor(
 		provideUtilityBindings(this)
 		provideRootBindings(this)
 
-		load(globalScript, "@/internal/global.lua")
+		call {
-		call()
+			load(globalScript, "@/internal/global.lua")
+		}
 	}
 
 	fun interface Fn {
@@ -204,115 +205,219 @@ class LuaThread private constructor(
 		closure.dispose()
 	}
 
-	fun call(numArgs: Int = 0, numResults: Int = 0): Int {
+	private fun pcall(numArgs: Int, numResults: Int, handler: Int) {
-		sharedState.cleanup()
+		val status = LuaJNR.INSTANCE.lua_pcallk(this.pointer, numArgs, numResults, handler, 0L, 0L)
-		val status = LuaJNR.INSTANCE.lua_pcallk(this.pointer, numArgs, numResults, 0, 0L, 0L)
 
 		if (status == LUA_ERRRUN) {
-			throw LuaRuntimeException(this.getString())
+			val errObject = typeAt(-1)
-		}
 
-		return status
+			if (errObject == LuaType.STRING)
+				throw LuaRuntimeException(this.getString())
+			else if (errObject == LuaType.USERDATA)
+				throw getObject() as Throwable
+			else
+				throw RuntimeException("Lua raised an error, but it has invalid value as error: $errObject")
+		} else if (status == LUA_ERRMEM) {
+			throw LuaMemoryAllocException()
+		} else if (status == LUA_ERRERR) {
+			throw LuaException("Exception inside Exception handler")
+		}
 	}
 
-	/**
+	fun callConditional(block: LuaThread.() -> Boolean) {
-	 * Returns boolean indicating whenever function exists
+		sharedState.cleanup()
-	 */
+
-	inline fun invokeGlobal(name: String, arguments: LuaThread.() -> Int): Boolean {
 		val top = stackTop
+		push(sharedState.errorTrapFunction)
 
 		try {
-			val type = loadGlobal(name)
+			if (block(this)) {
-			if (type != LuaType.FUNCTION)
+				val newTop = stackTop
-				return false
 
-			val numArguments = arguments(this)
+				if (newTop == top + 1) {
-			check(numArguments >= 0) { "Invalid amount of arguments provided to Lua function" }
+					throw IllegalArgumentException("No function was pushed to stack")
-			call(numArguments)
+				}
-			return true
+
+				pcall(newTop - top - 2, 0, top + 1)
+			}
 		} finally {
-			setTop(top)
+			LuaJNR.INSTANCE.lua_settop(pointer, top)
 		}
 	}
 
-	/**
+	fun call(block: LuaThread.() -> Unit) {
-	 * Returns boolean indicating whenever function exists
+		return callConditional { block(this); true }
-	 */
+	}
-	fun invokeGlobal(name: String, numArguments: Int): Boolean {
+
+	fun <T> callConditional(numResults: Int, block: LuaThread.() -> Boolean, resultHandler: LuaThread.(firstStackIndex: Int) -> T): KOptional<T> {
+		require(numResults >= 0) { "Invalid amount of results to get from Lua call: $numResults" }
+		sharedState.cleanup()
+
 		val top = stackTop
+		push(sharedState.errorTrapFunction)
 
 		try {
-			val type = loadGlobal(name)
+			if (block(this)) {
+				val newTop = stackTop
 
-			if (type != LuaType.FUNCTION) {
+				if (newTop == top + 1) {
-				pop(numArguments)
+					throw IllegalArgumentException("No function was pushed to stack")
-				return false
+				}
+
+				pcall(newTop - top - 2, numResults, top + 1)
+				return KOptional(resultHandler(this, top + 2))
+			} else {
+				return KOptional()
+			}
+		} finally {
+			LuaJNR.INSTANCE.lua_settop(pointer, top)
+		}
+	}
+
+	fun <T> call(numResults: Int, block: LuaThread.() -> Unit, resultHandler: LuaThread.(firstStackIndex: Int) -> T): T {
+		return callConditional(numResults, { block(this); true }, resultHandler).value
+	}
+
+	fun callConditional(numResults: Int, block: LuaThread.() -> Boolean): List<LuaHandle>? {
+		require(numResults >= 0) { "Invalid amount of results to get from Lua call: $numResults" }
+		sharedState.cleanup()
+
+		val top = stackTop
+		push(sharedState.errorTrapFunction)
+
+		try {
+			if (!block(this))
+				return null
+
+			val newTop = stackTop
+
+			if (newTop == top + 1) {
+				throw IllegalArgumentException("No function was pushed to stack")
 			}
 
-			call(numArguments)
+			pcall(newTop - top - 2, numResults, top + 1)
-			return true
+
+			val handles = ArrayList<LuaHandle>()
+
+			for (i in 1 .. numResults) {
+				val stackIndex = top + 1 + i
+
+				when (typeAt(stackIndex)) {
+					LuaType.NONE, LuaType.NIL -> handles.add(LuaHandle.Nil)
+					LuaType.BOOLEAN -> handles.add(LuaHandle.boolean(getBooleanRaw(stackIndex)))
+
+					LuaType.NUMBER -> {
+						if (isInteger(stackIndex)) {
+							handles.add(LuaHandle.LLong(getLongRaw(stackIndex)))
+						} else {
+							handles.add(LuaHandle.LDouble(getDoubleRaw(stackIndex)))
+						}
+					}
+
+					else -> {
+						if (i != numResults) {
+							push()
+							copy(stackIndex, -1)
+						}
+
+						moveStackValuesOnto(sharedState.handlesThread)
+						handles.add(sharedState.allocateHandle(null))
+					}
+				}
+			}
+
+			return handles
 		} finally {
-			setTop(top)
+			LuaJNR.INSTANCE.lua_settop(pointer, top)
 		}
 	}
 
-	/**
+	fun call(numResults: Int, block: LuaThread.() -> Unit): List<LuaHandle> {
-	 * Returns empty [KOptional] if function does not exist
+		return callConditional(numResults, { block(this); true })!!
-	 */
+	}
-	inline fun <T> invokeGlobal(name: String, numResults: Int, arguments: LuaThread.() -> Int, results: LuaThread.(firstValue: Int) -> T): KOptional<T> {
-		require(numResults > 0) { "Invalid amount of results: $numResults" }
-		val top = stackTop
 
-		try {
+	fun traceback(message: String, level: Int = 0) {
+		LuaJNR.INSTANCE.luaL_traceback(pointer, pointer, message, level)
+	}
+
+	fun invokeGlobal(name: String): Boolean {
+		var exists = false
+
+		callConditional {
 			val type = loadGlobal(name)
 			if (type != LuaType.FUNCTION)
-				return KOptional()
+				return@callConditional false
 
-			val numArguments = arguments(this)
+			exists = true
-			call(numArguments, numResults)
+			return@callConditional true
-			return KOptional(results(this, top + 1))
+		}
-		} finally {
+
-			setTop(top)
+		return exists
+	}
+
+	fun invokeGlobal(name: String, arguments: LuaThread.() -> Unit): Boolean {
+		var exists = false
+
+		callConditional {
+			val type = loadGlobal(name)
+			if (type != LuaType.FUNCTION)
+				return@callConditional false
+
+			arguments(this)
+			exists = true
+			return@callConditional true
+		}
+
+		return exists
+	}
+
+	fun invokeGlobal(name: String, numResults: Int, arguments: LuaThread.() -> Unit): List<LuaHandle>? {
+		return callConditional(numResults) {
+			val type = loadGlobal(name)
+			if (type != LuaType.FUNCTION)
+				return@callConditional false
+
+			arguments(this)
+			return@callConditional true
 		}
 	}
 
-	inline fun <T> eval(chunk: String, name: String = "eval", numResults: Int, arguments: LuaThread.() -> Int, results: LuaThread.(firstValue: Int) -> T): T {
+	fun <T> invokeGlobal(name: String, numResults: Int, arguments: LuaThread.() -> Unit, resultHandler: LuaThread.(firstStackIndex: Int) -> T): KOptional<T> {
-		require(numResults > 0) { "Invalid amount of results: $numResults" }
+		return callConditional(numResults, {
+			val type = loadGlobal(name)
+			if (type != LuaType.FUNCTION)
+				return@callConditional false
 
-		val top = stackTop
+			arguments(this)
+			return@callConditional true
+		}, resultHandler)
+	}
 
-		try {
+	fun <T> eval(chunk: String, name: String = "eval", numResults: Int, arguments: LuaThread.() -> Unit, results: LuaThread.(firstValue: Int) -> T): T {
-			val numArguments = arguments(this)
+		return call(numResults, {
 			load(chunk, name)
-			call(numArguments, numResults)
+			arguments(this)
-			return results(this, top + 1)
+		}, results)
-		} finally {
+	}
-			setTop(top)
+
+	fun eval(chunk: String, name: String = "eval", numResults: Int, arguments: LuaThread.() -> Unit): List<LuaHandle> {
+		return call(numResults) {
+			load(chunk, name)
+			arguments(this)
 		}
 	}
 
-	inline fun eval(chunk: String, name: String = "eval", arguments: LuaThread.() -> Int) {
+	fun eval(chunk: String, name: String = "eval", arguments: LuaThread.() -> Unit) {
-		val top = stackTop
+		return call {
-
-		try {
-			val numArguments = arguments(this)
 			load(chunk, name)
-			call(numArguments, 0)
+			arguments(this)
-		} finally {
-			setTop(top)
 		}
 	}
 
 	fun eval(chunk: String, name: String = "eval"): JsonElement {
-		val top = stackTop
+		return call(1, {
-
-		try {
 			load(chunk, name)
-			call(numResults = 1)
+		}, { getJson(it)!! })
-			return getJson() ?: JsonNull.INSTANCE
-		} finally {
-			setTop(top)
-		}
 	}
 
 	private val attachedScripts = ArrayList<String>()
@@ -333,8 +438,9 @@ class LuaThread private constructor(
 		try {
 			// minor hiccups during unpopulated script cache should be tolerable
 			for ((chunk, path) in loadScripts) {
-				load(chunk.join(), "@$path")
+				call {
-				call()
+					load(chunk.join(), "@$path")
+				}
 			}
 		} catch (err: Exception) {
 			LOGGER.error("Failed to attach scripts to Lua environment", err)
@@ -343,16 +449,18 @@ class LuaThread private constructor(
 
 		try {
 			if (callInit) {
-				val type = loadGlobal("init")
+				callConditional {
+					val type = loadGlobal("init")
 
-				if (type == LuaType.FUNCTION) {
+					if (type == LuaType.NIL || type == LuaType.NONE) {
-					call()
+						return@callConditional false
-				} else if (type == LuaType.NIL || type == LuaType.NONE) {
+					} else if (type != LuaType.FUNCTION) {
-					pop()
+						throw LuaRuntimeException("init is not a function: $type")
-				} else {
+					}
-					pop()
+
-					throw LuaRuntimeException("init is not a function: $type")
+					true
 				}
+
 			}
 		} catch (err: Exception) {
 			LOGGER.error("Failed to call init() in Lua environment", err)
@@ -371,8 +479,9 @@ class LuaThread private constructor(
 		sharedState.ensureValid()
 		if (initCalled) {
 			// minor hiccups during unpopulated script cache should be tolerable
-			load(Starbound.readLuaScript(script).join(), "@$script")
+			call {
-			call()
+				load(Starbound.readLuaScript(script).join(), "@$script")
+			}
 		} else {
 			attachedScripts.add(script)
 		}
@@ -1106,7 +1215,7 @@ class LuaThread private constructor(
 		}
 	}
 
-	private fun closure(p: Long, function: Fn, performanceCritical: Boolean): Int {
+	private fun closure(p: Long, function: Fn): Int {
 		sharedState.cleanup()
 		val realLuaState: LuaThread
 
@@ -1118,69 +1227,33 @@ class LuaThread private constructor(
 		}
 
 		val args = realLuaState.ArgStack(realLuaState.stackTop)
-		val rememberStack: ArrayList<String>?
-
-		if (performanceCritical) {
-			rememberStack = null
-		} else {
-			rememberStack = ArrayList(Exception().stackTraceToString().split('\n'))
-
-			rememberStack.removeAt(0) // java.lang. ...
-			// rememberStack.removeAt(0) // at ... push( ... )
-		}
 
 		try {
 			val value = function.invoke(args)
 			check(value >= 0) { "Internal JVM error: ${function::class.qualifiedName} returned incorrect number of arguments to be popped from stack by Lua" }
 			return value
 		} catch (err: Throwable) {
-			try {
+			push(err)
-				if (performanceCritical) {
+			return -1
-					realLuaState.push(err.stackTraceToString())
-					return -1
-				} else {
-					rememberStack!!
-					val newStack = err.stackTraceToString().split('\n').toMutableList()
-
-					val rememberIterator = rememberStack.listIterator(rememberStack.size)
-					val iterator = newStack.listIterator(newStack.size)
-					var hit = false
-
-					while (rememberIterator.hasPrevious() && iterator.hasPrevious()) {
-						val a = rememberIterator.previous()
-						val b = iterator.previous()
-
-						if (a == b) {
-							hit = true
-							iterator.remove()
-						} else {
-							break
-						}
-					}
-
-					if (hit) {
-						newStack[newStack.size - 1] = "\t<...>"
-					}
-
-					realLuaState.push(newStack.joinToString("\n"))
-					return -1
-				}
-			} catch(err2: Throwable) {
-				realLuaState.push("JVM suffered an exception while handling earlier exception: ${err2.stackTraceToString()}; earlier: ${err.stackTraceToString()}")
-				return -1
-			}
 		}
 	}
 
-	fun push(function: Fn, performanceCritical: Boolean) {
+	fun push(err: Throwable) {
+		pushTable()
+		push("__tostring")
+		push(sharedState.errorToStringFunction)
+		setTableValue()
+		pushObject(err)
+	}
+
+	fun push(function: Fn) {
 		sharedState.ensureValid()
+
 		LuaJNI.lua_pushcclosure(pointer.address()) {
-			closure(it, function, performanceCritical)
+			closure(it, function)
 		}
 	}
 
-	fun push(function: Fn) = this.push(function, !RECORD_STACK_TRACES)
-
 	fun <T> push(self: T, function: Binding<T>) {
 		push {
 			function.invoke(self, it)
@@ -1590,8 +1663,8 @@ class LuaThread private constructor(
 			}
 
 			is JsonArray -> {
-				this.loadGlobal("jarray")
+				val handle = call(1) { loadGlobal("jarray") }.first()
-				this.call(numResults = 1)
+				handle.push(this)
 				val index = this.stackTop
 
 				for ((i, v) in value.withIndex()) {
@@ -1603,8 +1676,8 @@ class LuaThread private constructor(
 			}
 
 			is JsonObject -> {
-				this.loadGlobal("jobject")
+				val handle = call(1) { loadGlobal("jobject") }.first()
-				this.call(numResults = 1)
+				handle.push(this)
 
 				val index = this.stackTop
 
@@ -1622,6 +1695,10 @@ class LuaThread private constructor(
 		}
 	}
 
+	override fun toString(): String {
+		return "LuaThread at ${pointer.address()}"
+	}
+
 	companion object {
 		val LOGGER = LogManager.getLogger()
 

src/main/kotlin/ru/dbotthepony/kstarbound/lua/LuaUpdateComponent.kt

@@ -38,23 +38,26 @@ class LuaUpdateComponent(val lua: LuaThread, val name: Any) {
 		if (steps >= stepCount) {
 			steps %= stepCount
 
-			val type = lua.loadGlobal("update")
+			lua.callConditional {
+				val type = loadGlobal("update")
 
-			if (type != lastType) {
+				if (type != lastType) {
-				lastType = type
+					lastType = type
 
-				if (type != LuaType.FUNCTION) {
+					if (type != LuaType.FUNCTION) {
-					LOGGER.warn("Lua environment for $name has $type as global 'update', script update wasn't called")
+						LOGGER.warn("Lua environment for $name has $type as global 'update', script update wasn't called")
+					}
+				}
+
+				if (type == LuaType.FUNCTION) {
+					preRun()
+					push(stepCount * Starbound.TIMESTEP)
+					return@callConditional true
+				} else {
+					return@callConditional false
 				}
 			}
 
-			if (type == LuaType.FUNCTION) {
-				preRun()
-				lua.push(stepCount * Starbound.TIMESTEP)
-				lua.call(1)
-			} else {
-				lua.pop()
-			}
 		}
 	}
 

src/main/kotlin/ru/dbotthepony/kstarbound/lua/bindings/ServerWorldBindings.kt

@@ -386,6 +386,7 @@ fun provideServerWorldBindings(self: ServerWorld, lua: LuaThread) {
 	lua.setTableValueToStub("setLayerEnvironmentBiome")
 	lua.setTableValueToStub("setPlanetType")
 
-	lua.load(script, "@/internal/server_world.lua")
+	lua.call {
-	lua.call()
+		load(script, "@/internal/server_world.lua")
+	}
 }

src/main/kotlin/ru/dbotthepony/kstarbound/lua/bindings/WorldBindings.kt

@@ -943,6 +943,7 @@ fun provideWorldBindings(self: World<*, *>, lua: LuaThread) {
 
 	lua.pop()
 
-	lua.load(worldScript, "@/internal/world.lua")
+	lua.call {
-	lua.call()
+		load(worldScript, "@/internal/world.lua")
+	}
 }

src/main/kotlin/ru/dbotthepony/kstarbound/lua/userdata/BehaviorState.kt

@@ -154,14 +154,14 @@ private fun createNode(
 				}
 			}
 
-			check(lua.loadGlobal("ActionNode") == LuaType.FUNCTION) { "Global ActionNode is not a Lua function" }
+			val handle = lua.call(1) {
-			lua.push(name)
+				check(loadGlobal("ActionNode") == LuaType.FUNCTION) { "Global ActionNode is not a Lua function" }
-			push(lua, parameters)
+				push(name)
-			push(lua, output)
+				push(this, parameters)
-			lua.call(3, 1)
+				push(this, output)
-			val handle = lua.createHandle()
+			}[0]
+
 			handles.add(handle)
-			lua.pop()
 			return handle
 		}
 
@@ -169,15 +169,14 @@ private fun createNode(
 			functions.add(name)
 			val sacrifice = createNode(lua, data["child"] as JsonObject, treeParameters, blackboard, scripts, functions, handles)
 
-			check(lua.loadGlobal("DecoratorNode") == LuaType.FUNCTION) { "Global DecoratorNode is not a Lua function" }
+			val handle = lua.call(1) {
-			lua.push(name)
+				check(loadGlobal("DecoratorNode") == LuaType.FUNCTION) { "Global DecoratorNode is not a Lua function" }
-			push(lua, parameters)
+				push(name)
-			lua.push(sacrifice)
+				push(this, parameters)
-			lua.call(3, 1)
+				push(sacrifice)
-			val handle = lua.createHandle()
+			}[0]
-			handles.add(handle)
-			lua.pop()
 
+			handles.add(handle)
 			return handle
 		}
 
@@ -189,21 +188,20 @@ private fun createNode(
 
 			val factory = CompositeNodeType.entries.valueOf(name)
 
-			check(lua.loadGlobal(factory.fnName) == LuaType.FUNCTION) { "Global ${factory.fnName} is not a Lua function" }
+			val handle = lua.call(1) {
-			push(lua, parameters)
+				check(loadGlobal(factory.fnName) == LuaType.FUNCTION) { "Global ${factory.fnName} is not a Lua function" }
+				push(this, parameters)
 
-			lua.pushTable(children.size)
+				pushTable(children.size)
 
-			for ((i, child) in children.withIndex()) {
+				for ((i, child) in children.withIndex()) {
-				lua.push(i + 1L)
+					push(i + 1L)
-				lua.push(child)
+					push(child)
-				lua.setTableValue()
+					setTableValue()
-			}
+				}
+			}[0]
 
-			lua.call(2, 1)
-			val handle = lua.createHandle()
 			handles.add(handle)
-			lua.pop()
 			return handle
 		}
 
@@ -212,11 +210,7 @@ private fun createNode(
 }
 
 private fun createBlackboard(lua: LuaThread): LuaHandle {
-	lua.loadGlobal("Blackboard")
+	return lua.call(1) { lua.loadGlobal("Blackboard") }[0]
-	lua.call(numResults = 1)
-	val handle = lua.createHandle()
-	lua.pop()
-	return handle
 }
 
 private fun createBehaviorTree(args: LuaThread.ArgStack): Int {
@@ -278,22 +272,27 @@ private fun createBehaviorTree(args: LuaThread.ArgStack): Int {
 	args.lua.loadGlobal("require")
 
 	scripts.forEach {
-		args.lua.dup()
+		args.lua.call {
-		args.lua.push(it)
+			loadGlobal("require")
-		args.lua.call(1)
+			push(it)
+		}
 	}
 
-	check(args.lua.loadGlobal("BehaviorState") == LuaType.FUNCTION) { "Global BehaviorState is not a Lua function" }
+	val handle = args.lua.call(1) {
+		check(loadGlobal("BehaviorState") == LuaType.FUNCTION) { "Global BehaviorState is not a Lua function" }
 
-	args.lua.push(blackboard)
+		push(blackboard)
-	args.lua.push(root)
+		push(root)
-	args.lua.call(2, 1)
+	}[0]
 
-	args.lua.push("bake")
+	args.lua.call {
-	check(args.lua.loadTableValue() == LuaType.FUNCTION) { "BehaviorTree.bake is not a Lua function" }
+		handle.push(this)
-	args.lua.dup(-2)
+		push("bake")
-	args.lua.call(1)
+		check(loadTableValue() == LuaType.FUNCTION) { "BehaviorTree.bake is not a Lua function" }
+		handle.push(this)
+	}
 
+	handle.close()
 	handles.forEach { it.close() }
 	return 1
 }
@@ -309,6 +308,7 @@ fun provideBehaviorBindings(lua: LuaThread) {
 
 	lua.pop()
 
-	lua.load(script, "@/internal/behavior.lua")
+	lua.call {
-	lua.call()
+		load(script, "@/internal/behavior.lua")
+	}
 }

src/main/kotlin/ru/dbotthepony/kstarbound/server/world/LegacyWireProcessor.kt

@@ -97,10 +97,12 @@ class LegacyWireProcessor(val world: ServerWorld) {
 					if (newState != node.state) {
 						try {
 							node.state = newState
-							entity.lua.pushTable(hashSize = 2)
+
-							entity.lua.setTableValue("node", i)
+							entity.lua.invokeGlobal("onInputNodeChange") {
-							entity.lua.setTableValue("level", newState)
+								pushTable(hashSize = 2)
-							entity.lua.invokeGlobal("onInputNodeChange", 1)
+								setTableValue("node", i)
+								setTableValue("level", newState)
+							}
 						} catch (err: Throwable) {
 							LOGGER.error("Exception while updating wire state of $entity at ${entity.tilePosition} (input node index $i)", err)
 						}

src/main/kotlin/ru/dbotthepony/kstarbound/world/entities/MonsterEntity.kt

@@ -333,13 +333,13 @@ class MonsterEntity(val variant: MonsterVariant, level: Double? = null) : ActorE
 
 		// TODO: hitDamageNotificationLimiter++ < Globals.npcs.hitDamageNotificationLimit maybe?
 		if (totalDamage > 0.0) {
-			lua.pushTable(hashSize = 4)
+			lua.invokeGlobal("damage") {
-			lua.setTableValue("sourceId", damage.request.sourceEntityId)
+				pushTable(hashSize = 4)
-			lua.setTableValue("damage", totalDamage)
+				setTableValue("sourceId", damage.request.sourceEntityId)
-			lua.setTableValue("sourceDamage", damage.request.damage)
+				setTableValue("damage", totalDamage)
-			lua.setTableValue("sourceKind", damage.request.damageSourceKind)
+				setTableValue("sourceDamage", damage.request.damage)
-
+				setTableValue("sourceKind", damage.request.damageSourceKind)
-			lua.invokeGlobal("damage", 1)
+			}
 		}
 
 		if (health <= 0.0) {
@@ -350,7 +350,7 @@ class MonsterEntity(val variant: MonsterVariant, level: Double? = null) : ActorE
 	}
 
 	private val shouldDie: Boolean get() {
-		val result = lua.invokeGlobal("shouldDie", 1, { 0 }, { getBoolean() == true }).orElse(false)
+		val result = lua.invokeGlobal("shouldDie", 1, {}, { getBoolean() == true }).orElse(false)
 		return result || health <= 0.0 //|| lua.errorState
 	}
 

src/main/kotlin/ru/dbotthepony/kstarbound/world/entities/NPCEntity.kt

@@ -332,13 +332,13 @@ class NPCEntity(val variant: NPCVariant) : HumanoidActorEntity() {
 		val totalDamage = notifications.sumOf { it.healthLost }
 
 		if (totalDamage > 0.0 && hitDamageNotificationLimiter++ < Globals.npcs.hitDamageNotificationLimit) {
-			lua.pushTable(hashSize = 4)
+			lua.invokeGlobal("damage") {
-			lua.setTableValue("sourceId", damage.request.sourceEntityId)
+				pushTable(hashSize = 4)
-			lua.setTableValue("damage", totalDamage)
+				setTableValue("sourceId", damage.request.sourceEntityId)
-			lua.setTableValue("sourceDamage", damage.request.damage)
+				setTableValue("damage", totalDamage)
-			lua.setTableValue("sourceKind", damage.request.damageSourceKind)
+				setTableValue("sourceDamage", damage.request.damage)
-
+				setTableValue("sourceKind", damage.request.damageSourceKind)
-			lua.invokeGlobal("damage", 1)
+			}
 		}
 
 		return notifications
@@ -407,7 +407,7 @@ class NPCEntity(val variant: NPCVariant) : HumanoidActorEntity() {
 				remove(RemovalReason.DYING)
 				return
 			} else {
-				val shouldDie = lua.invokeGlobal("shouldDie", 1, { 0 }, { getBoolean() == true }).orElse(false)
+				val shouldDie = lua.invokeGlobal("shouldDie", 1, {}, { getBoolean() == true }).orElse(false)
 
 				if (shouldDie) {
 					remove(RemovalReason.DYING)
@@ -425,7 +425,7 @@ class NPCEntity(val variant: NPCVariant) : HumanoidActorEntity() {
 		super.onRemove(world, reason)
 
 		if (isLocal)
-			lua.invokeGlobal("die", 0)
+			lua.invokeGlobal("die")
 
 		val dropPools by lazy { dropPools.stream().map { it.entry }.filterNotNull().toList() }
 

src/main/kotlin/ru/dbotthepony/kstarbound/world/entities/StatusController.kt

@@ -191,7 +191,6 @@ class StatusController(val entity: ActorEntity, val config: StatusControllerConf
 	fun experienceDamage(damage: DamageData): List<DamageNotification> {
 		val results = lua.invokeGlobal("applyDamageRequest", 1, {
 			push(Starbound.gson.toJsonTree(damage))
-			1
 		}, { getJson() as? JsonArray }).flatMap { KOptional.ofNullable(it) }
 
 		if (results.isPresent) {
@@ -632,7 +631,7 @@ class StatusController(val entity: ActorEntity, val config: StatusControllerConf
 
 		fun remove() {
 			if (entity.isLocal)
-				lua.invokeGlobal("onExpire", 0)
+				lua.invokeGlobal("onExpire")
 
 			uniqueEffectMetadata.remove(metadataNetworkID)
 

src/main/kotlin/ru/dbotthepony/kstarbound/world/entities/tile/WorldObject.kt

@@ -306,13 +306,13 @@ open class WorldObject(val config: Registry.Entry<ObjectDefinition>) : TileEntit
 		fun addConnection(connection: WireConnection) {
 			if (connection !in connectionsInternal) {
 				connectionsInternal.add(connection.copy())
-				lua.invokeGlobal("onNodeConnectionChange", 0)
+				lua.invokeGlobal("onNodeConnectionChange")
 			}
 		}
 
 		fun removeConnection(connection: WireConnection) {
 			if (connectionsInternal.remove(connection)) {
-				lua.invokeGlobal("onNodeConnectionChange", 0)
+				lua.invokeGlobal("onNodeConnectionChange")
 			}
 		}
 
@@ -325,20 +325,20 @@ open class WorldObject(val config: Registry.Entry<ObjectDefinition>) : TileEntit
 					val any = otherConnections?.getOrNull(it.index)?.connectionsInternal?.removeIf { it.entityLocation == tilePosition && it.index == index }
 
 					if (any == true) {
-						otherEntity!!.lua.invokeGlobal("onNodeConnectionChange", 0)
+						otherEntity!!.lua.invokeGlobal("onNodeConnectionChange")
 					}
 
 					any == true
 				}
 
 				if (any)
-					lua.invokeGlobal("onNodeConnectionChange", 0)
+					lua.invokeGlobal("onNodeConnectionChange")
 			}
 		}
 
 		fun removeConnectionsTo(pos: Vector2i) {
 			if (connectionsInternal.removeIf { it.entityLocation == pos }) {
-				lua.invokeGlobal("onNodeConnectionChange", 0)
+				lua.invokeGlobal("onNodeConnectionChange")
 			}
 		}
 
@@ -599,8 +599,6 @@ open class WorldObject(val config: Registry.Entry<ObjectDefinition>) : TileEntit
 
 			setTableValue("source", diff)
 			setTableValue("sourceId", request.source)
-
-			1
 		}, { getJson() ?: JsonNull.INSTANCE })
 
 		if (result.isPresent) {
@@ -675,7 +673,7 @@ open class WorldObject(val config: Registry.Entry<ObjectDefinition>) : TileEntit
 						// break connection if other entity got removed
 						if (connection.otherEntity?.removalReason?.removal == true) {
 							itr.remove()
-							lua.invokeGlobal("onNodeConnectionChange", 0)
+							lua.invokeGlobal("onNodeConnectionChange")
 							continue
 						}
 
@@ -691,7 +689,7 @@ open class WorldObject(val config: Registry.Entry<ObjectDefinition>) : TileEntit
 						// break connection if we point at invalid node
 						if (otherNode == null) {
 							itr.remove()
-							lua.invokeGlobal("onNodeConnectionChange", 0)
+							lua.invokeGlobal("onNodeConnectionChange")
 						} else {
 							newState = newState!! || otherNode.state
 						}
@@ -706,10 +704,12 @@ open class WorldObject(val config: Registry.Entry<ObjectDefinition>) : TileEntit
 				// otherwise, keep current node state
 				if (newState != null && node.state != newState) {
 					node.state = newState
-					lua.pushTable(hashSize = 2)
+
-					lua.setTableValue("node", i)
+					lua.invokeGlobal("onInputNodeChange") {
-					lua.setTableValue("level", newState)
+						pushTable(hashSize = 2)
-					lua.invokeGlobal("onInputNodeChange", 1)
+						setTableValue("node", i)
+						setTableValue("level", newState)
+					}
 				}
 			}
 		}
@@ -781,9 +781,10 @@ open class WorldObject(val config: Registry.Entry<ObjectDefinition>) : TileEntit
 			}
 		}
 
-		if (!isRemote && reason.dying) {
+		if (isLocal && reason.dying) {
-			lua.push(health <= 0.0)
+			lua.invokeGlobal("die") {
-			lua.invokeGlobal("die", 1)
+				push(health <= 0.0)
+			}
 
 			try {
 				if (doSmash) {

src/test/kotlin/ru/dbotthepony/kstarbound/test/LuaTests.kt

@@ -12,13 +12,20 @@ object LuaTests {
 	fun test() {
 		val lua = LuaThread()
 
-		lua.ensureExtraCapacity(1000)
+		lua.push {
+			throw IllegalArgumentException("test!")
+		}
 
-		lua.loadGlobal("collectgarbage")
+		lua.storeGlobal("test")
-		lua.push("count")
-		lua.call(1, 1)
-		println(lua.popDouble()!! * 1024)
 
+		val results = lua.call(5) {
+			lua.load("""
+				return 1, 4, 4.0, 4.1, {a = 71}
+			""".trimIndent())
+		}
+
+		println(results)
+		println(results.last().toJson())
 		lua.close()
 	}
 }