auxlua -> dreamluau conversion (#4027)

* auxlua -> dreamluau conversion

* Update `InstallDeps.sh` to latest /tg/ version

Author: Absolucy

.github/workflows/run_integration_tests.yml

@@ -46,9 +46,9 @@ jobs:
       - name: Install rust-g
         run: |
           bash tools/ci/install_rust_g.sh
-      - name: Install auxlua
+      - name: Install dreamluau
         run: |
-          bash tools/ci/install_auxlua.sh
+          bash tools/ci/install_dreamluau.sh
       - name: Configure version
         run: |
           echo "BYOND_MAJOR=${{ inputs.major }}" >> $GITHUB_ENV

auxlua.dll

@@ -1,38 +1,3 @@
-#define AUXTOOLS_FULL_INIT 2
-#define AUXTOOLS_PARTIAL_INIT 1
-
-GLOBAL_LIST_EMPTY(auxtools_initialized)
-GLOBAL_PROTECT(auxtools_initialized)
-
-#define AUXTOOLS_CHECK(LIB)\
-	if (!CONFIG_GET(flag/auxtools_enabled)) {\
-		CRASH("Auxtools is not enabled in config!");\
-	}\
-	if (GLOB.auxtools_initialized[LIB] != AUXTOOLS_FULL_INIT) {\
-		if (fexists(LIB)) {\
-			var/string = call_ext(LIB,"auxtools_init")();\
-			if(findtext(string, "SUCCESS")) {\
-				GLOB.auxtools_initialized[LIB] = AUXTOOLS_FULL_INIT;\
-			} else {\
-				CRASH(string);\
-			}\
-		} else {\
-			CRASH("No file named [LIB] found!")\
-		}\
-	}\
-
-#define AUXTOOLS_SHUTDOWN(LIB)\
-	if (GLOB.auxtools_initialized[LIB] == AUXTOOLS_FULL_INIT && fexists(LIB)){\
-		call_ext(LIB,"auxtools_shutdown")();\
-		GLOB.auxtools_initialized[LIB] = AUXTOOLS_PARTIAL_INIT;\
-	}\
-
-#define AUXTOOLS_FULL_SHUTDOWN(LIB)\
-	if (GLOB.auxtools_initialized[LIB] && fexists(LIB)){\
-		call_ext(LIB,"auxtools_full_shutdown")();\
-		GLOB.auxtools_initialized[LIB] = FALSE;\
-	}
-
 /proc/auxtools_stack_trace(msg)
 	CRASH(msg)
 

code/__HELPERS/_auxtools_api.dm

@@ -0,0 +1,301 @@
+/* This comment bypasses grep checks */ /var/__dreamluau
+
+/* This comment also bypasses grep checks */ /var/__dreamluau_exists
+
+#define DREAMLUAU_EXISTS (__dreamluau_exists ||= fexists(DREAMLUAU))
+
+#define DREAMLUAU (world.system_type == MS_WINDOWS ? "dreamluau.dll" : (__dreamluau ||= __detect_auxtools("dreamluau")))
+
+#define DREAMLUAU_CALL(func) (!DREAMLUAU_EXISTS) ? null : call_ext(DREAMLUAU, "byond:" + #func)
+
+/**
+ * All of the following functions will return a string if the underlying rust code returns an error or a wrapped panic.
+ * The return values specified for each function are what they will return if successful.
+ */
+
+/**
+ * As of 515.1631, byondapi does not provide direct access to `usr`.
+ * Use this function to pass `usr` into the dreamluau binary so that luau scripts can retrieve it.
+ *
+ * @return null on success
+ */
+#define DREAMLUAU_SET_USR DREAMLUAU_CALL(set_usr)(usr)
+
+
+/**
+ * Sets the execution limit, in milliseconds.
+ *
+ * @param limit the new execution limit
+ *
+ * @return null on success
+ */
+#define DREAMLUAU_SET_EXECUTION_LIMIT_MILLIS(limit) DREAMLUAU_CALL(set_execution_limit_millis)((limit))
+
+/**
+ * Sets the execution limit, in seconds.
+ *
+ * @param limit the new execution limit
+ *
+ * @return null on success
+ */
+#define DREAMLUAU_SET_EXECUTION_LIMIT_SECS(limit) DREAMLUAU_CALL(set_execution_limit_secs)((limit))
+
+/**
+ * Clears the execution limit, allowing scripts to run as long as they need to.
+ *
+ * WARNING: This allows infinite loops to block Dream Daemon indefinitely, with no safety checks.
+ * Do not use this if you have no reason for scripts to run arbitrarily long.
+ *
+ * @return null on success
+ */
+#define DREAMLUAU_CLEAR_EXECUTION_LIMIT DREAMLUAU_CALL(clear_execution_limit)
+
+//Wrapper setters/clearers
+
+/**
+ * Set the wrapper for instancing new datums with `dm.new`.
+ * Clears it if the argument is null.
+ * If unset, the object will be instantiated using the default `new` instruction.
+ *
+ * The wrapper must be a proc with the signature `(type as path, list/arguments)`.
+ *
+ * @param wrapper the path to the proc to use as the new wrapper
+ *
+ * @return null on success
+ */
+#define DREAMLUAU_SET_NEW_WRAPPER(wrapper) DREAMLUAU_CALL(set_new_wrapper)((wrapper))
+
+/**
+ * Set the wrapper for reading the vars of an object.
+ * Clears it if the argument is null.
+ * If unset, the var will be read directly, without any safety checks.
+ *
+ * The wrapper must be a proc with the signature `(target, var)`.
+ *
+ * @param wrapper the path to the proc to use as the new wrapper
+ *
+ * @return null on success
+ */
+#define DREAMLUAU_SET_VAR_GET_WRAPPER(wrapper) DREAMLUAU_CALL(set_var_get_wrapper)((wrapper))
+
+/**
+ * Set the wrapper for writing the vars of an object.
+ * Clears it if the argument is null.
+ * If unset, the var will be modified directly, without any safety checks.
+ *
+ * The wrapper must be a proc with the signature `(target, var, value)`.
+ *
+ * @param wrapper the path to the proc to use as the new wrapper
+ *
+ * @return null on success
+ */
+#define DREAMLUAU_SET_VAR_SET_WRAPPER(wrapper) DREAMLUAU_CALL(set_var_set_wrapper)((wrapper))
+
+/**
+ * Set the wrapper for calling a proc on an object.
+ * Clears it if the argument is null.
+ * If unset, the proc will be called directly, without any safety checks.
+ *
+ * The wrapper must be a proc with the signature `(target, procname as text, list/arguments)`.
+ *
+ * @param wrapper the path to the proc to use as the new wrapper
+ *
+ * @return null on success
+ */
+#define DREAMLUAU_SET_OBJECT_CALL_WRAPPER(wrapper) DREAMLUAU_CALL(set_object_call_wrapper)((wrapper))
+
+/**
+ * Set the wrapper for calling a global proc.
+ * Clears it if the argument is null.
+ * If unset, the proc will be called directly, without any safety checks.
+ *
+ * The wrapper must be a proc with the signature `(procname as text, list/arguments)`.
+ *
+ * @param wrapper the path to the proc to use as the new wrapper
+ *
+ * @return null on success
+ */
+#define DREAMLUAU_SET_GLOBAL_CALL_WRAPPER(wrapper) DREAMLUAU_CALL(set_global_call_wrapper)((wrapper))
+
+/**
+ * Set the wrapper for printing with the `print` function.
+ * Clears it if the argument is null.
+ * If unset, `print` will raise an error.
+ *
+ * The wrapper must be a proc with the signature `(list/arguments)`.
+ *
+ * @param wrapper the path to the proc to use as the new wrapper
+ *
+ * @return null on success
+ */
+#define DREAMLUAU_SET_PRINT_WRAPPER(wrapper) DREAMLUAU_CALL(set_print_wrapper)((wrapper))
+
+
+
+/**
+ * Create a new luau state.
+ *
+ * @return a handle to the created state.
+ */
+#define DREAMLUAU_NEW_STATE DREAMLUAU_CALL(new_state)
+
+/**
+ * Some of the following functions return values that cannot be cleanly converted from luau to DM.
+ * To account for this, these functions also return a list of variant specifiers, equivalent to
+ * an array of objects of the type described beloe:
+ * ```
+ * type Variants = {
+ *     key?: "error"|Array<Variants?>
+ *     value?: "error"|Array<Variants?>
+ * }
+ * ```
+ */
+
+/**
+ * The following 4 functions execute luau code and return
+ * an associative list containing information about the result.
+ * This list has the following params.
+ *
+ * - "status": either "finished", "sleep", "yield", or "error"
+ * - "return_values": if "status" is "finished" or "yield", contains a list of the return values
+ * - "variants": a list of variant specifiers for the "return_values" param
+ * - "message": if "status" is "error", contains the error message
+ * - "name": the name of the executed code, according to the `what` field of `debug.getinfo`
+ */
+
+/**
+ * Load and execute a luau script.
+ *
+ * @param state the handle to the state
+ * @param code the source code of the script to run
+ * @param name an optional name to give to the script, for debugging purposes
+ *
+ * @return an associative list containing result information as specified above
+ */
+#define DREAMLUAU_LOAD DREAMLUAU_CALL(load)
+
+/**
+ * Awaken the thread at the front of the specified state's sleeping thread queue.
+ *
+ * @param state the handle to the state
+ *
+ * @return an associative list containing result information as specified above
+ */
+#define DREAMLUAU_AWAKEN(state) DREAMLUAU_CALL(awaken)((state))
+
+/**
+ * Resume one of the state's yielded threads.
+ *
+ * @param state the handle to the state
+ * @param index the index of the thread in the state's yielded threads list
+ * @param ...arguments arguments that will be returned by the `coroutine.yield` that yielded the thread
+ *
+ * @return an associative list containing result information as specified above
+ */
+#define DREAMLUAU_RESUME DREAMLUAU_CALL(resume)
+
+/**
+ * Call a function accessible from the global table.
+ *
+ * @param state the handle to the state
+ * @param function a list of nested indices from the global table to the specified function
+ * @param ...arguments arguments to pass to the function
+ *
+ * @return an associative list containing result information as specified above
+ */
+#define DREAMLUAU_CALL_FUNCTION DREAMLUAU_CALL(call_function)
+
+// State information collection functions
+
+/**
+ * Obtain a copy of the state's global table, converted to DM.
+ *
+ * @param state the handle to the state
+ *
+ * @return an associative list with the follwing entries:
+ * - "values": The actual values of the global table
+ * - "variants": Variant specifiers for "values"
+ */
+#define DREAMLUAU_GET_GLOBALS(state) DREAMLUAU_CALL(get_globals)((state))
+
+/**
+ * List the names of all sleeping or yielded threads for the state.
+ *
+ * @param state the handle to the state
+ *
+ * @return an associative list with the following entries:
+ *  - "sleeps": A list of sleeping threads
+ *  - "yields": A list of yielded threads
+ */
+#define DREAMLUAU_LIST_THREADS(state) DREAMLUAU_CALL(list_threads)((state))
+
+// Cleanup functions
+
+/**
+ * Run garbage collection on the state.
+ *
+ * This may be necessary to prevent hanging references, as some
+ * hard references may persist in unreachable luau objects that
+ * would be collected after a garbage collection cycle or two.
+ *
+ * @param state the handle to the state
+ *
+ * @return null on success
+ */
+#define DREAMLUAU_COLLECT_GARBAGE(state) DREAMLUAU_CALL(collect_garbage)((state))
+
+/**
+ * Remove a sleeping thread from the sleep queue, without executing it.
+ *
+ * @param state the handle to the state
+ * @param thread the index in the sleep queue to the target thread
+ *
+ * @return null on success
+ */
+#define DREAMLUAU_KILL_SLEEPING_THREAD(state, thread) DREAMLUAU_CALL(kill_sleeping_thread)((state), (thread))
+
+/**
+ * Remove a yielded thread from the yield table, without executing it.
+ *
+ * @param state the handle to the state
+ * @param thread the index in the yield table to the target thread
+ *
+ * @return null on success
+ */
+#define DREAMLUAU_KILL_YIELDED_THREAD(state, thread) DREAMLUAU_CALL(kill_yielded_thread)((state), (thread))
+
+/**
+ * Delete a state. The state's handle will be freed for any new states created afterwards.
+ *
+ * @param state the handle to the state
+ *
+ * @return null on success
+ */
+#define DREAMLUAU_KILL_STATE(state) DREAMLUAU_CALL(kill_state)((state))
+
+/**
+ * Retrieve lua traceback info, containing every lua stack frame between the lua entrypoint and the re-entry to dm code.
+ *
+ * @param level the level of lua execution to get the traceback for,
+ * with 1 being the lua code that executed the dm code that called this function,
+ * 2 being the lua code that executed the dm code that executed the lua code
+ * that executed the dm code that called this function, etc.
+ *
+ * @return the callstack of the specified lua level if valid, null if invalid
+ */
+#define DREAMLUAU_GET_TRACEBACK(index) DREAMLUAU_CALL(get_traceback)((index))
+
+/**
+ * Luau userdata corresponding to a ref-counted DM type counts as a hard reference for BYOND's garbage collector.
+ * If you need to delete a DM object, and you cannot be certain that there are no references to it in any luau state,
+ * call this function before deleting that object to disassociate it from any userdata in any luau state.
+ *
+ * Hard deleting an object without clearing userdata corresponding to it leaves the userdata to become associated with
+ * the next DM object to receive the old object's reference ID, which may be undesirable behavior.
+ *
+ * @param object the object to disassociate from userdata.
+ *
+ * @return null on success
+ */
+#define DREAMLUAU_CLEAR_REF_USERDATA(object) DREAMLUAU_CALL(clear_ref_userdata)((object))
+