Support Linux/MacOS

.gitignore

@@ -382,6 +382,7 @@ FodyWeavers.xsd
 !.vscode/tasks.json
 !.vscode/launch.json
 !.vscode/extensions.json
+!.vscode/c_cpp_properties.json
 *.code-workspace
 
 # Local History for Visual Studio Code
@@ -396,3 +397,18 @@ FodyWeavers.xsd
 
 # JetBrains Rider
 *.sln.iml
+
+# CMake
+CMakeLists.txt.user
+CMakeCache.txt
+CMakeFiles
+CMakeScripts
+Testing
+Makefile
+cmake_install.cmake
+install_manifest.txt
+compile_commands.json
+CTestTestfile.cmake
+_deps
+CMakeUserPresets.json
+.cmake

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "Luau"]
+	path = Luau
+	url = https://github.com/luau-lang/luau.git

.vscode/c_cpp_properties.json

@@ -0,0 +1,19 @@
+{
+    "configurations": [
+        {
+            "name": "Linux",
+            "includePath": [
+                "${workspaceFolder}/shared/",
+                "${workspaceFolder}/Luau/CodeGen/include",
+                "${workspaceFolder}/Luau/Ast/include",
+                "${workspaceFolder}/Luau/Common/include",
+                "${workspaceFolder}/Luau/Compiler/include"
+            ],
+            "defines": [],
+            "cStandard": "c17",
+            "cppStandard": "c++20",
+            "intelliSenseMode": "linux-clang-x64"
+        }
+    ],
+    "version": 4
+}

CMakeLists.txt

@@ -0,0 +1,29 @@
+cmake_minimum_required(VERSION 3.20)
+project(runluau LANGUAGES CXX C)
+
+# Set C++ standard to C++20
+set(CMAKE_CXX_STANDARD 20)
+
+if(UNIX)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DUNIX")
+elseif(WIN32)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DWINDOWS")
+endif()
+
+include_directories(shared)
+
+
+# Add Luau submodule as a subdirectory
+add_subdirectory(Luau ${CMAKE_BINARY_DIR}/_deps/Luau)
+
+# Include Luau directories (adjust as needed)
+include_directories(Luau/Compiler/include)
+include_directories(Luau/Ast/include)
+include_directories(Luau/CodeGen/include)
+include_directories(Luau/Common/include)
+
+# Add your source files
+add_executable(runluau main.cpp execute.cpp plugins.cpp)
+
+# Link against Luau libraries
+target_link_libraries(runluau Luau)

execute.cpp

@@ -1,12 +1,18 @@
 #include "execute.h"
 
+#ifdef _WIN32
 #include <Windows.h>
+#else
+#include <unistd.h>
+#endif
 
 #include <Luau/Compiler.h>
 
 #include "colors.h"
 #include "plugins.h"
+#include "errors.h"
 #include "base_funcs.h"
+#include "Luau/VM/include/lualib.h"
 
 using namespace runluau;
 

luau-dynamic/luau.cpp

@@ -215,7 +215,7 @@ API bool luau::resume_and_handle_status(lua_State* thread, lua_State* from, int
 void luau::start_scheduler() {
 	HANDLE timer = CreateWaitableTimer(NULL, TRUE, NULL);
 	if (!timer) {
-		DWORD error = GetLastError();
+		unsigned long error = GetLastError();
 		printf("Failed to CreateWaitableTimer: %d\n", error);
 		exit(error);
 	}
@@ -252,7 +252,7 @@ void luau::start_scheduler() {
 
 API void signal_yield_ready(yield_ready_event_t yield_ready_event) {
 	if (!SetEvent(yield_ready_event)) {
-		DWORD error = GetLastError();
+		unsigned long error = GetLastError();
 		printf("Failed to SetEvent: %d\n", error);
 		exit(error);
 	}

luau-dynamic/pch.h

@@ -1,6 +1,10 @@
 #pragma once
 
+#ifdef _WIN32
 #include <Windows.h>
+#else
+#include <unistd.h>
+#endif
 
 #include <list>
 #include <format>

main.cpp

@@ -1,5 +1,11 @@
 #include <stdio.h>
+#ifdef _WIN32
 #include <Windows.h>
+#else
+#include <unistd.h>
+#include <csignal>
+#include <signal.h>
+#endif
 
 #include <cerrno>
 #include <string>
@@ -8,11 +14,13 @@
 #include <fstream>
 #include <format>
 
+#include "errors.h"
 #include "file.h"
 #include "execute.h"
 #include "plugins.h"
 #include "build.h"
 #include "luaurc.h"
+#include "luau.h"
 
 void help_then_exit(std::string notice_message) {
 	printf(R"(%s Help is below:
@@ -22,9 +30,7 @@ runluau <mode> <...>
 Modes:
 	- Run a script. `args` is optional. If specified, everything after it will be passed into the script. If not specified, `script` will be set to "init".
 	runluau run <path>? <options> --args <...>
-	- Build a script to an executable, with an optional list of plugins to embed into the output. If `plugins` isn't specified, it will use every plugin installed.
-	runluau build <path> <output> <options> --plugins <...>
-Options for `run` and `build`:
+Options:
 	- [default: 1] Optimization level 0-2:
 	-O/-o <n>
 	- [default: 1] Debug level 0-2:
@@ -89,25 +95,46 @@ runluau::settings_run_build read_args_run_build(std::vector<std::string>& args,
 	return settings;
 }
 
-BOOL WINAPI ctrl_handler(DWORD type) {
+inline uintptr_t align(uintptr_t value, uintptr_t alignment) {
+	return (value + (alignment - 1)) & ~(alignment - 1);
+}
+#ifdef _WIN32
+BOOL WINAPI ctrl_handler(unsigned long type) {
+#else
+int ctrl_handler(int type) {
+#endif
 	switch (type) {
+	#ifdef _WIN32
 	case CTRL_C_EVENT:
+	#else
+	case SIGINT:
+	#endif
 		printf("Exiting\n");
+		#ifdef _WIN32
 		__fastfail(ERROR_PROCESS_ABORTED);
-		return TRUE;
+		#else
+		raise(SIGABRT);
+		#endif
+		return 1;
 	default:
-		return FALSE;
+		return 0;
 	}
 }
 int main(int argc, char* argv[]) {
+#ifdef _WIN32
 	SetConsoleCtrlHandler(ctrl_handler, TRUE);
+#else
+	signal(SIGINT, (void(*)(int))ctrl_handler);
+#endif
+#ifdef _WIN32
 	HANDLE console = GetStdHandle(STD_OUTPUT_HANDLE);
 	if (console) {
 		DWORD mode;
 		GetConsoleMode(console, &mode);
 		mode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
 		SetConsoleMode(console, mode);
 	}
+#endif
 	std::vector<std::string> args(argv + 1, argv + argc);
 	const auto minimum_arguments = [&args](size_t amount) -> void {
 		if (args.size() - 1 < amount) {

plugins.cpp

@@ -4,35 +4,56 @@
 #include <unordered_set>
 #include <stack>
 #include <vector>
+#ifdef _WIN32
 #include <Windows.h>
-
+#else
+#include <unistd.h>
+#include <dlfcn.h>
+#endif
+#include "errors.h"
+#include "macros.h"
 #include "luau.h"
 
 typedef void(__fastcall* register_library_t)(lua_State* state);
 typedef const char**(__fastcall* get_dependencies_t)();
 
 
+#ifdef _WIN32
 HMODULE load_plugin(const fs::path& path) {
-	HMODULE plugin_module = GetModuleHandleW(path.wstring().c_str());
-	if (!plugin_module) {
-		plugin_module = LoadLibraryW(path.wstring().c_str());
-		if (!plugin_module) {
-			wprintf(L"Failed to load plugin %s\n", path.wstring().c_str());
-			exit(ERROR_MOD_NOT_FOUND);
-		}
+	HMODULE plugin_module = LoadLibraryW(path.wstring().c_str());
+	if (!plugin_module) [[unlikely]] {
+		wprintf(L"Failed to load plugin %s\n", path.wstring().c_str());
+		exit(ERROR_MOD_NOT_FOUND);
 	}
 	return plugin_module;
 }
-
+#else
+void* load_plugin(const fs::path& path) {
+	void* plugin_module = dlopen(path.c_str(), RTLD_LAZY);
+	if (!plugin_module) [[unlikely]] {
+		fprintf(stderr, "Failed to load plugin %s\n", dlerror());
+		exit(ERROR_MOD_NOT_FOUND);
+	}
+	return plugin_module;
+}
+#endif
 std::unordered_map<std::string, std::vector<std::string>> collect_dependencies(const fs::path& folder) {
 	std::unordered_map<std::string, std::vector<std::string>> dependencies;
 	for (const auto& file : fs::directory_iterator(folder)) {
 		if (file.is_directory()) {
 			auto subdir_dependencies = collect_dependencies(file);
 			dependencies.insert(subdir_dependencies.begin(), subdir_dependencies.end());
 		} else if (file.path().extension() == ".dll") {
-			HMODULE plugin_module = load_plugin(file.path());
+			auto plugin_module = load_plugin(file.path());
+#ifdef _WIN32
 			get_dependencies_t get_dependencies = (get_dependencies_t)GetProcAddress(plugin_module, "get_dependencies");
+#else
+			get_dependencies_t get_dependencies = (get_dependencies_t)dlsym(plugin_module, "get_dependencies");
+			if (!get_dependencies) [[unlikely]] {
+				fprintf(stderr, "Failed to find get_dependencies export in plugin %s\n", file.path().filename().c_str());
+				exit(EINVAL);
+			}
+#endif
 			std::vector<std::string> wanted_dependencies;
 			if (get_dependencies) {
 				for (const char** wanted_dependency = get_dependencies(); *wanted_dependency; ++wanted_dependency) {
@@ -112,11 +133,15 @@ void apply_plugins(lua_State* state, std::optional<std::unordered_set<std::strin
 			}
 		}
 		fs::path plugin_path = folder / plugin_name;
-		HMODULE plugin_module = load_plugin(plugin_path);
+		auto plugin_module = load_plugin(plugin_path);
+		#ifdef _WIN32
 		register_library_t register_library = (register_library_t)GetProcAddress(plugin_module, "register_library");
+		#else
+		register_library_t register_library = (register_library_t)dlsym(plugin_module, "register_library");
+		#endif
 		if (!register_library) {
 			wprintf(L"Invalid plugin %s (missing register_library export)\n", plugin_path.wstring().c_str());
-			exit(ERROR_PROC_NOT_FOUND);
+			exit(ERROR_NOT_FOUND);
 		}
 		register_library(state);
 	}

plugins.h

@@ -4,7 +4,8 @@
 #include <filesystem>
 namespace fs = std::filesystem;
 
-#include <lua.h>
+#include "Luau/VM/include/lua.h"
+#include <optional>
 
 fs::path get_plugins_folder();
 void apply_plugins(lua_State* state, std::optional<std::unordered_set<std::string>> plugins_to_load = std::nullopt);