Test cleanup.

Author: Goubermouche

premake5.lua

@@ -13,7 +13,7 @@ workspace "sigma"
 
     -- buildoptions { "-fsanitize=address" }
     -- linkoptions { "-fsanitize=address" }
-   --  debugformat "C7"
+    --  debugformat "C7"
 
     filter "configurations:Release"
         defines { "NDEBUG" }
@@ -185,7 +185,7 @@ project "compiler"
     kind "ConsoleApp"
     location "source/compiler"
 
-    debugargs { "compile", "./test/main.s" }
+    debugargs { "compile", "./test/main.s", "-e", "./test/a.obj" }
 
     files {
         "source/compiler/**.h",

source/compiler/compiler/compiler.cpp

@@ -20,18 +20,18 @@ namespace sigma {
 		: m_description(description) {}
 
 	auto compiler::compile() -> utility::result<void> {
-		utility::console::print("compiling file: {}\n", m_description.path);
+		utility::console::print("compiling file: {} ({})\n", m_description.source_path, m_description.emit_path);
 
-		ASSERT(m_description.emit != emit_target::EXECUTABLE, "executable support not implemented");
-		TRY(verify_file(m_description.path));
+		TRY(verify_file(m_description.source_path));
+		TRY(m_emit_target, get_emit_target_from_path(m_description.emit_path));
 
 		// frontend
 		// TODO: the entire frontend can be multi-threaded
 		frontend_context frontend;
 
 		// generate the AST
-		TRY(const std::string file, utility::fs::file<std::string>::load(m_description.path));
-		TRY(tokenizer::tokenize(file, &m_description.path, frontend));
+		TRY(const std::string file, utility::fs::file<std::string>::load(m_description.source_path));
+		TRY(tokenizer::tokenize(file, &m_description.source_path, frontend));
 		TRY(parser::parse(frontend));
 
 		// backend
@@ -47,9 +47,8 @@ namespace sigma {
 		backend.module.compile();
 
 		//emit as an object file
-		if(m_description.emit == OBJECT) {
-			const filepath object_path = get_object_file_path();
-			emit_object_file(backend.module, object_path);
+		if(m_emit_target == emit_target::OBJECT) {
+			emit_object_file(backend.module, m_description.emit_path);
 		}
 
 		return SUCCESS;
@@ -80,10 +79,23 @@ namespace sigma {
 		};
 
 		const char* format = object_formats[static_cast<u8>(m_description.target.get_system())];
-		return m_description.path.get_parent_path() / (name + format);
+		return m_description.source_path.get_parent_path() / (name + format);
 	}
 
 	void compiler::emit_object_file(ir::module& module, const filepath& path) {
 		utility::fs::file<utility::contiguous_container<utility::byte>>::save(path, module.generate_object_file());
 	}
+
+	auto compiler::get_emit_target_from_path(const filepath& path) -> utility::result<emit_target> {
+		if(path.get_extension() == ".exe") {
+			return emit_target::EXECUTABLE;
+		}
+
+		if(path.get_extension() == ".obj" || path.get_extension() == ".o") {
+			return emit_target::OBJECT;
+		}
+
+		NOT_IMPLEMENTED();
+		return emit_target::NONE;
+	}
 } // namespace sigma

source/compiler/compiler/compiler.h

@@ -23,17 +23,16 @@ namespace sigma {
 		class module;
 	} // namespace sigma::ir
 
-	enum emit_target : u8 {
+	enum class emit_target : u8 {
 		NONE,
 		OBJECT,
 		EXECUTABLE
 	};
 
 	struct compiler_description {
-		filepath path;
+		filepath source_path;
+		filepath emit_path;
 		ir::target target;
-
-		emit_target emit;
 	};
 
 	class compiler {
@@ -47,8 +46,12 @@ namespace sigma {
 
 		static auto verify_file(const filepath& path) -> utility::result<void>;
 		static void emit_object_file(ir::module& module, const filepath& path);
+
+		static auto get_emit_target_from_path(const filepath& path) -> utility::result<emit_target>;
 	private:
 		compiler_description m_description;
+
+		emit_target m_emit_target;
 	};
 } // namespace sigma
 

source/compiler/main.cpp

@@ -5,10 +5,11 @@ using namespace utility::types;
 
 i32 compile(const parametric::parameters& params) {
 	const sigma::compiler_description description {
-		.path = params.get<filepath>("file"),
+		.source_path = params.get<filepath>("file"),
+		.emit_path = params.get<filepath>("emit"),
+
 		// 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
@@ -43,9 +44,9 @@ auto main(i32 argc, char* argv[]) -> i32 {
 	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<filepath>("emit", "filepath to emit to", "e", "./a.obj");
 	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
 

source/compiler/test/main.s

@@ -9,13 +9,28 @@
 // -   add namespaces to error messages, whenever applicable (ie. x::y::test)
 // -   cleanup ir gen alignment sizes (u64 vs u32 vs u16)
 // -   set crashes with more than 4(?) parameters
+// -   implicit returns for non-void functions should be a thing
 
 i32 main() {
-   bool a = true;
-   printf("%d\n", a);
-   printf("%d\n", !a);
+	i32* memory = cast<i32*>(malloc(100));
+	
+	memory[0] = 1;
+	memory[1] = 2;
 
-	 bool b = 1;
-	 printf("%d\n", b);
-	 printf("%d\n", !b);
+	printf("%d %d\n", memory[0], memory[1]);
+
+	ret 0;
 }
+
+
+// THIS CRASHES
+// i32 main() {
+// 	i32* memory = cast<i32*>(malloc(100));
+// 	
+// 	memory[0] = 1;
+// 	memory[1] = 2;
+// 	
+// 	printf("%d %d\n", memory[0], memory[1]);
+// 
+// 	ret 0; a
+// }

source/tests/app_STDERR.txt

@@ -0,0 +1 @@
+200