Added a basic CLI interface using parametric.

Author: Goubermouche

premake5.lua

@@ -188,8 +188,7 @@ project "compiler"
     kind "ConsoleApp"
     location "source/compiler"
 
-    -- debugargs { "compile", "-s", "test/main.s", "-o", "test/app.exe" }
-    debugargs { "./test/main.s" }
+    debugargs { "compile", "./test/main.s" }
 
     files {
         "source/compiler/**.h",
@@ -226,6 +225,38 @@ project "compiler"
             "-lstdc++"
         }
 
+workspace "tests"
+    configurations { "Release", "Debug", "Profile" }
+    startproject "tests"
+
+    architecture "x64"
+    language "C++"
+    cppdialect "C++latest"
+
+    flags {
+        "MultiProcessorCompile"
+    }
+
+    filter "configurations:Release"
+        defines { "NDEBUG" }
+        optimize "On"
+        warnings "High"
+        symbols "Off"
+
+    filter "configurations:Debug"
+        symbols "On"
+        optimize "Off"
+        runtime "Debug"
+        defines { "DEBUG", "_DEBUG" }
+        warnings "Extra"
+
+    filter "configurations:Profile"
+        defines { "NDEBUG" }
+        optimize "On"
+        warnings "High"
+        symbols "On"
+
+
 project "tests"
     kind "ConsoleApp"
     location "source/tests"
@@ -235,6 +266,8 @@ project "tests"
         "source/tests/**.cpp"
     }
 
+    libdirs { "../sigma/output/compiler/bin/%{cfg.buildcfg}" }
+
     includedirs {
         "source"
     }
@@ -257,4 +290,4 @@ project "tests"
 
         linkoptions {
             "-lstdc++"
-        }
+        }

source/compiler/compiler/compiler.cpp

@@ -21,6 +21,8 @@ namespace sigma {
 
 	auto compiler::compile() const -> utility::result<void> {
 		utility::console::println("compiling file: {}", m_description.path.string());
+
+		ASSERT(m_description.emit != emit_target::EXECUTABLE, "executable support not implemented");
 		TRY(verify_file(m_description.path));
 
 		// frontend
@@ -48,8 +50,11 @@ namespace sigma {
 		backend.module.compile();
 
 		// emit as an object file
-		const filepath object_path = get_object_file_path();
-		emit_object_file(backend.module, object_path);
+		if(m_description.emit == OBJECT) {
+			const filepath object_path = get_object_file_path();
+			emit_object_file(backend.module, object_path);
+		}
+		
 		return SUCCESS;
 	}
 

source/compiler/compiler/compiler.h

@@ -12,6 +12,7 @@
 
 #pragma once
 #include <intermediate_representation/target/target.h>
+#include <utility/parametric/parametric.h>
 #include <utility/diagnostics.h>
 #include <utility/macros.h>
 
@@ -22,9 +23,16 @@ namespace sigma {
 		class module;
 	} // namespace sigma::ir
 
+	enum emit_target : u8 {
+		OBJECT,
+		EXECUTABLE
+	};
+
 	struct compiler_description {
 		filepath path;
 		ir::target target;
+
+		emit_target emit;
 	};
 
 	class compiler {
@@ -42,3 +50,51 @@ namespace sigma {
 		compiler_description m_description;
 	};
 } // namespace sigma
+
+template<>
+struct parametric::options_parser<sigma::filepath> {
+	static auto parse(const std::string& value) -> sigma::filepath {
+		return value;
+	}
+};
+
+template<>
+struct parametric::options_parser<sigma::ir::arch> {
+	static auto parse(const std::string& value) -> sigma::ir::arch {
+		if (value == "x64") {
+			return sigma::ir::arch::X64;
+		}
+
+		throw std::invalid_argument("invalid argument");
+	}
+};
+
+template<>
+struct parametric::options_parser<sigma::ir::system> {
+	static auto parse(const std::string& value) -> sigma::ir::system {
+		if (value == "windows") {
+			return sigma::ir::system::WINDOWS;
+		}
+
+		if (value == "linux") {
+			return sigma::ir::system::WINDOWS;
+		}
+
+		throw std::invalid_argument("invalid argument");
+	}
+};
+
+template<>
+struct parametric::options_parser<sigma::emit_target> {
+	static auto parse(const std::string& value) -> sigma::emit_target {
+		if (value == "object") {
+			return sigma::emit_target::OBJECT;
+		}
+
+		if (value == "executable") {
+			return sigma::emit_target::EXECUTABLE;
+		}
+
+		throw std::invalid_argument("invalid argument");
+	}
+};

source/compiler/main.cpp

@@ -1,62 +1,56 @@
 #include "compiler/compiler.h"
-#include <intermediate_representation/builder.h>
-
-#include "utility/filesystem/file.h"
+#include <utility/shell.h>
 
 using namespace utility::types;
 
-auto main(i32 argc, char* argv[]) -> i32 {
-	SUPPRESS_C4100(argc);
-
+i32 compile(const parametric::parameters& params) {
 	const sigma::compiler_description description {
-	.path = argv[1],
-	.target = { sigma::ir::arch::X64, sigma::ir::system::WINDOWS }
+		.path = params.get<filepath>("file"),
+		// default to x64 win for now
+		.target = { sigma::ir::arch::X64, sigma::ir::system::WINDOWS },
+		.emit = params.get<sigma::emit_target>("emit")
 	};
 
 	// compile the specified description, check for errors after we finish
-	PRINT_ERROR(sigma::compiler::compile(description));
-	return 0;
+	const auto result = sigma::compiler::compile(description);
+
+	if (result.has_error()) {
+		utility::console::println(result.get_error_message());
+		return 1;
+	}
 
-	//sigma::ir::target target(sigma::ir::arch::X64, sigma::ir::system::WINDOWS);
-	//sigma::ir::module module(target);
-	//sigma::ir::builder builder(module);
-
-	//// printf
-	//const sigma::ir::function_signature printf_func_ty{
-	//	.identifier = "printf",
-	//	.parameters = { PTR_TYPE },
-	//	.returns = { I32_TYPE },
-	//	.has_var_args = true
-	//};
-
-	//const auto printf_external = builder.create_external(printf_func_ty, sigma::ir::linkage::SO_LOCAL);
-
-	//// test
-	//const sigma::ir::function_signature test_func_ty {
-	//	.identifier = "test",
-	//	.parameters = { },
-	//	.returns = { I32_TYPE },
-	//	.has_var_args = false
-	//};
-
-	//const auto test = builder.create_function(test_func_ty, sigma::ir::linkage::PUBLIC);
-	//const auto message = builder.create_string("test\n");
-	//builder.create_call(printf_external, printf_func_ty, { message });
-	//builder.create_return({ builder.create_signed_integer(0, 32) });
-
-	//// main
-	//const sigma::ir::function_signature main_func_ty{
-	//.identifier = "main",
-	//.returns = { I32_TYPE }
-	//};
-
-	//builder.create_function(main_func_ty, sigma::ir::linkage::PUBLIC);
-	//builder.create_call(test, {});
-	//builder.create_return({ builder.create_signed_integer(0, 32) });
-
-	//module.compile();
-
-	//auto object_file = module.generate_object_file();
-	//utility::file::write(object_file, "./test/a.obj");
 	return 0;
 }
+
+i32 show_docs(const parametric::parameters& params) {
+	SUPPRESS_C4100(params);
+
+	// TODO: add a link to the relevant github wiki
+	const std::string link = "https://github.com/Goubermouche/sigma";
+
+	if(utility::shell::open_link(link) == 0) {
+		return 0;
+	}
+
+	std::cout << std::format("error: unable to open the documentation link ({})\n", link);
+	return 1;
+}
+
+auto main(i32 argc, char* argv[]) -> i32 {
+	parametric::program program;
+
+	// compilation
+	auto& compile_command = program.add_command("compile", "compile the specified source file", compile);
+
+	compile_command.add_positional_argument<filepath>("file", "source file to compile");
+	compile_command.add_flag<sigma::ir::arch>("arch", "CPU architecture to compile for [x64]");
+	compile_command.add_flag<sigma::ir::system>("system", "operating system to compile for [windows, linux]");
+	compile_command.add_flag<sigma::emit_target>("emit", "file the compiler should emit [object, executable]", "e", sigma::emit_target::OBJECT);
+
+	// TODO: add support for emitting multiple files at once
+
+	// documentation
+	program.add_command("docs", "show project documentation", show_docs);
+
+	return program.parse(argc, argv);
+}

source/compiler/test/main.s

@@ -2,9 +2,6 @@
 // -   linking: link /OUT:a.exe a.obj /LIBPATH:C:\dev\projects\sigma\source\compiler\test\libraries libcmt.lib libvcruntime.lib libucrt.lib
 
 // TODO: 
-// -   stack scope system
-// -   typechecker
-//     -   convert values into IR types ?
 // -   parser
 //     -   check for memory oversteps
 // -   IR translator 

source/tests/main.cpp

@@ -1,54 +1,68 @@
 #include <utility/diagnostics.h>
 #include <utility/filesystem/file.h>
-#include <utility/containers/stack.h>
+#include <utility/string_helper.h>
 
 // Runs all tests in sigma/tests and checks against a database of expected results. Should only
 // be invoked via the run_tests.bat file.
 
-#define WIN_COMPILER_PATH utility::fs::get_canonical_path("./output/compiler/bin/Debug/compiler.exe").string()
-#define ERR_FILE_PATH "err.txt"
-
+//#define WIN_COMPILER_PATH utility::fs::get_canonical_path("../../../../output/compiler/bin/Debug/compiler.exe").string()
+//#define ERR_FILE_PATH "err.txt"
+//
 using namespace utility::types;
+//
+//auto compile_file(const filepath& path) -> utility::result<bool> {
+//	const std::string command = WIN_COMPILER_PATH + " " + utility::fs::get_canonical_path(path).string() + " NO_EMIT" + " 1> err.txt";
+//	const bool has_error = system(command.c_str());
+//
+//	if(has_error) {
+//		TRY(std::string message, utility::file::read_text_file(ERR_FILE_PATH));
+//
+//		// message = utility::detail::remove_first_line(message);
+//		// message.erase(message.size() - 1); // remove the trailing newline
+//		// utility::console::println("\033[31m'{}'\033[0m", message);
+//	}
+//
+//	return has_error;
+//}
 
-auto compile_file(const filepath& path) -> bool {
-	const std::string command = WIN_COMPILER_PATH + " " + utility::fs::get_canonical_path(path).string() + " 1> err.txt";
-	const bool error = system(command.c_str());
-
-	if(error) {
-		// std::string message = utility::file::read_text_file(ERR_FILE_PATH);
-		// message.erase(message.size() - 1); // remove the trailing newline
-		// utility::console::println("\033[31m'{}'\033[0m", message);
-	}
-
-	return error;
-}
-
-i32 main() {
-	std::queue<filepath> paths({ utility::fs::get_canonical_path("./tests") });
-
-	utility::console::println("running tests...");
-	utility::console::println("{}", std::string(32, '-'));
-
-	while(!paths.empty()) {
-		const filepath current = paths.front();
-		paths.pop();
-
-		utility::directory::for_all_directory_items(current, [&](const filepath& path) {
-			if(utility::fs::is_directory(path)) {
-				paths.push(path);
-				return;
-			}
-
-			static const char* result_codes[] = {
-				"OK",
-				"ERROR",
-			};
-
-			const bool error = compile_file(path);
-			utility::console::println("{:<30}{}", path.stem().string(), result_codes[error]);
-		});
-	}
+//i32 main() {
+//	std::queue<filepath> paths({ utility::fs::get_canonical_path("../../../../tests") });
+//
+//	std::cout << paths.front() << '\n';
+//
+//	utility::console::println("running tests...");
+//	utility::console::println("{}", std::string(32, '-'));
+//
+//	while(!paths.empty()) {
+//		const filepath current = paths.front();
+//		paths.pop();
+//
+//		utility::directory::for_all_directory_items(current, [&](const filepath& path) {
+//			if(utility::fs::is_directory(path)) {
+//				paths.push(path);
+//				return;
+//			}
+//
+//			static const char* result_codes[] = {
+//				"OK",
+//				"ERROR",
+//			};
+//
+//			const auto result = compile_file(path);
+//
+//			if(result.has_error()) {
+//				utility::console::println(result.get_error_message());
+//				return;
+//			}
+//
+//			utility::console::println("{:<30}{}", path.stem().string(), result_codes[result.get_value()]);
+//		});
+//	}
+//
+//	utility::fs::remove(ERR_FILE_PATH);
+//	return 0;
+//}
 
-	utility::fs::remove(ERR_FILE_PATH);
-	return 0;
-}
+i32 main(i32 argc, char* argv[]) {
+	// 
+}