refactor: Refactor `CodeGenerator.h` API.

Signed-off-by: Amlal El Mahrouss <amlal@nekernel.org>

10 files changed, 67 insertions, 49 deletions

diff --git a/src/CompilerKit/src/Assemblers/Assembler+32x0.cc b/src/CompilerKit/src/Assemblers/Assembler+32x0.cc
index 9229cf1..1b8d9f6 100644
--- a/src/CompilerKit/src/Assemblers/Assembler+32x0.cc
+++ b/src/CompilerKit/src/Assemblers/Assembler+32x0.cc
@@ -23,8 +23,8 @@
 
 #include <CompilerKit/AE.h>
 #include <CompilerKit/AST.h>
-#include <CompilerKit/PEF.h>
 #include <CompilerKit/Detail/32x0.h>
+#include <CompilerKit/PEF.h>
 #include <CompilerKit/Utilities/Compiler.h>
 
 /////////////////////////////////////////////////////////////////////////////////////////
diff --git a/src/CompilerKit/src/Assemblers/Assembler+64x0.cc b/src/CompilerKit/src/Assemblers/Assembler+64x0.cc
index 35a6bb2..757f5b4 100644
--- a/src/CompilerKit/src/Assemblers/Assembler+64x0.cc
+++ b/src/CompilerKit/src/Assemblers/Assembler+64x0.cc
@@ -23,8 +23,8 @@
 
 #include <CompilerKit/AE.h>
 #include <CompilerKit/AST.h>
-#include <CompilerKit/PEF.h>
 #include <CompilerKit/Detail/64x0.h>
+#include <CompilerKit/PEF.h>
 #include <CompilerKit/Utilities/Compiler.h>
 #include <algorithm>
 #include <filesystem>
@@ -269,7 +269,8 @@ static bool asm_read_attributes(std::string line) {
   // that we need this symbol.
   if (CompilerKit::ast_find_needle(line, "extern_segment")) {
     if (kOutputAsBinary) {
-      CompilerKit::Detail::print_error("Invalid extern_segment directive in flat binary mode.", "CompilerKit");
+      CompilerKit::Detail::print_error("Invalid extern_segment directive in flat binary mode.",
+                                       "CompilerKit");
       throw std::runtime_error("invalid_extern_segment_bin");
     }
 
@@ -329,7 +330,8 @@ static bool asm_read_attributes(std::string line) {
   // .zero64
   else if (CompilerKit::ast_find_needle(line, "public_segment")) {
     if (kOutputAsBinary) {
-      CompilerKit::Detail::print_error("Invalid public_segment directive in flat binary mode.", "CompilerKit");
+      CompilerKit::Detail::print_error("Invalid public_segment directive in flat binary mode.",
+                                       "CompilerKit");
       throw std::runtime_error("invalid_public_segment_bin");
     }
 
@@ -616,7 +618,8 @@ bool CompilerKit::Encoder64x0::WriteLine(std::string line, std::string file) {
 
   for (auto& opcode64x0 : kOpcodes64x0) {
     // strict check here
-    if (CompilerKit::ast_find_needle(line, opcode64x0.fName) && CompilerKit::Detail::algorithm::is_valid_64x0(line)) {
+    if (CompilerKit::ast_find_needle(line, opcode64x0.fName) &&
+        CompilerKit::Detail::algorithm::is_valid_64x0(line)) {
       std::string name(opcode64x0.fName);
       std::string jump_label, cpy_jump_label;
 
@@ -649,9 +652,10 @@ bool CompilerKit::Encoder64x0::WriteLine(std::string line, std::string file) {
               if (kOutputArch == CompilerKit::kPefArch64000) {
                 if (isdigit(line[line_index + 3]) && isdigit(line[line_index + 2])) {
                   reg_str += line[line_index + 3];
-                  CompilerKit::Detail::print_error("invalid register index, r" + reg_str +
-                                          "\nnote: The 64x0 accepts registers from r0 to r20.",
-                                      file);
+                  CompilerKit::Detail::print_error(
+                      "invalid register index, r" + reg_str +
+                          "\nnote: The 64x0 accepts registers from r0 to r20.",
+                      file);
                   throw std::runtime_error("invalid_register_index");
                 }
               }
@@ -688,16 +692,16 @@ bool CompilerKit::Encoder64x0::WriteLine(std::string line, std::string file) {
           }
 
           if (found_some < 1 && name != "ldw" && name != "lda" && name != "stw") {
-            CompilerKit::Detail::print_error("invalid combination of opcode and registers.\nline: " + line,
-                                file);
+            CompilerKit::Detail::print_error(
+                "invalid combination of opcode and registers.\nline: " + line, file);
             throw std::runtime_error("invalid_comb_op_reg");
           } else if (found_some == 1 && name == "add") {
-            CompilerKit::Detail::print_error("invalid combination of opcode and registers.\nline: " + line,
-                                file);
+            CompilerKit::Detail::print_error(
+                "invalid combination of opcode and registers.\nline: " + line, file);
             throw std::runtime_error("invalid_comb_op_reg");
           } else if (found_some == 1 && name == "sub") {
-            CompilerKit::Detail::print_error("invalid combination of opcode and registers.\nline: " + line,
-                                file);
+            CompilerKit::Detail::print_error(
+                "invalid combination of opcode and registers.\nline: " + line, file);
             throw std::runtime_error("invalid_comb_op_reg");
           }
 
@@ -759,13 +763,14 @@ bool CompilerKit::Encoder64x0::WriteLine(std::string line, std::string file) {
         if (!this->WriteNumber(0, jump_label)) {
           // sta expects this: sta 0x000000, r0
           if (name == "sta") {
-            CompilerKit::Detail::print_error("invalid combination of opcode and operands.\nHere ->" + line,
-                                file);
+            CompilerKit::Detail::print_error(
+                "invalid combination of opcode and operands.\nHere ->" + line, file);
             throw std::runtime_error("invalid_comb_op_ops");
           }
         } else {
           if (name == "sta" && cpy_jump_label.find("extern_segment ") != std::string::npos) {
-            CompilerKit::Detail::print_error("invalid usage extern_segment on 'sta', here: " + line, file);
+            CompilerKit::Detail::print_error("invalid usage extern_segment on 'sta', here: " + line,
+                                             file);
             throw std::runtime_error("invalid_sta_usage");
           }
         }
@@ -783,7 +788,8 @@ bool CompilerKit::Encoder64x0::WriteLine(std::string line, std::string file) {
           cpy_jump_label.erase(cpy_jump_label.find("extern_segment"), strlen("extern_segment"));
 
           if (name == "sta") {
-            CompilerKit::Detail::print_error("extern_segment is not allowed on a sta operation.", file);
+            CompilerKit::Detail::print_error("extern_segment is not allowed on a sta operation.",
+                                             file);
             throw std::runtime_error("extern_segment_sta_op");
           } else {
             goto asm_end_label_cpy;
diff --git a/src/CompilerKit/src/Assemblers/Assembler+AMD64.cc b/src/CompilerKit/src/Assemblers/Assembler+AMD64.cc
index e69d4b6..7146a53 100644
--- a/src/CompilerKit/src/Assemblers/Assembler+AMD64.cc
+++ b/src/CompilerKit/src/Assemblers/Assembler+AMD64.cc
@@ -30,8 +30,8 @@
 
 #include <CompilerKit/AE.h>
 #include <CompilerKit/AST.h>
-#include <CompilerKit/PEF.h>
 #include <CompilerKit/Detail/AMD64.h>
+#include <CompilerKit/PEF.h>
 #include <algorithm>
 #include <cstdlib>
 #include <filesystem>
@@ -496,8 +496,8 @@ std::string CompilerKit::EncoderAMD64::CheckLine(std::string line, std::string f
 
   if (line.empty() || CompilerKit::ast_find_needle(line, "extern_segment") ||
       CompilerKit::ast_find_needle(line, "public_segment") ||
-      CompilerKit::ast_find_needle(line, kAssemblerPragmaSymStr) || CompilerKit::ast_find_needle(line, ";") ||
-      line[0] == kAssemblerPragmaSym) {
+      CompilerKit::ast_find_needle(line, kAssemblerPragmaSymStr) ||
+      CompilerKit::ast_find_needle(line, ";") || line[0] == kAssemblerPragmaSym) {
     if (line.find(';') != std::string::npos) {
       line.erase(line.find(';'));
     } else {
@@ -1006,9 +1006,10 @@ bool CompilerKit::EncoderAMD64::WriteLine(std::string line, std::string file) {
 
                 if (bits == 16) {
                   if (registerName[0] == 'r') {
-                    CompilerKit::Detail::print_error("invalid size for register, current bit width is: " +
-                                            std::to_string(kRegisterBitWidth),
-                                        file);
+                    CompilerKit::Detail::print_error(
+                        "invalid size for register, current bit width is: " +
+                            std::to_string(kRegisterBitWidth),
+                        file);
                     throw std::runtime_error("invalid_reg_size");
                   }
                 }
@@ -1047,7 +1048,7 @@ bool CompilerKit::EncoderAMD64::WriteLine(std::string line, std::string file) {
             } else if (bits == 16) {
               if (hasRBasedRegs) {
                 CompilerKit::Detail::print_error("Invalid combination of operands and registers.",
-                                    "CompilerKit");
+                                                 "CompilerKit");
                 throw std::runtime_error("comb_op_reg");
               } else {
                 kAppBytes.emplace_back(0x66);
@@ -1085,33 +1086,39 @@ bool CompilerKit::EncoderAMD64::WriteLine(std::string line, std::string file) {
           }
 
           if (currentRegList[1].fName[0] == 'r' && currentRegList[0].fName[0] == 'e') {
-            CompilerKit::Detail::print_error("Invalid combination of operands and registers.", "CompilerKit");
+            CompilerKit::Detail::print_error("Invalid combination of operands and registers.",
+                                             "CompilerKit");
             throw std::runtime_error("comb_op_reg");
           }
 
           if (currentRegList[0].fName[0] == 'r' && currentRegList[1].fName[0] == 'e') {
-            CompilerKit::Detail::print_error("Invalid combination of operands and registers.", "CompilerKit");
+            CompilerKit::Detail::print_error("Invalid combination of operands and registers.",
+                                             "CompilerKit");
             throw std::runtime_error("comb_op_reg");
           }
 
           if (bits == 16) {
             if (currentRegList[0].fName[0] == 'r' || currentRegList[0].fName[0] == 'e') {
-              CompilerKit::Detail::print_error("Invalid combination of operands and registers.", "CompilerKit");
+              CompilerKit::Detail::print_error("Invalid combination of operands and registers.",
+                                               "CompilerKit");
               throw std::runtime_error("comb_op_reg");
             }
 
             if (currentRegList[1].fName[0] == 'r' || currentRegList[1].fName[0] == 'e') {
-              CompilerKit::Detail::print_error("Invalid combination of operands and registers.", "CompilerKit");
+              CompilerKit::Detail::print_error("Invalid combination of operands and registers.",
+                                               "CompilerKit");
               throw std::runtime_error("comb_op_reg");
             }
           } else {
             if (currentRegList[0].fName[0] != 'r' || currentRegList[0].fName[0] == 'e') {
-              CompilerKit::Detail::print_error("Invalid combination of operands and registers.", "CompilerKit");
+              CompilerKit::Detail::print_error("Invalid combination of operands and registers.",
+                                               "CompilerKit");
               throw std::runtime_error("comb_op_reg");
             }
 
             if (currentRegList[1].fName[0] != 'r' || currentRegList[1].fName[0] == 'e') {
-              CompilerKit::Detail::print_error("Invalid combination of operands and registers.", "CompilerKit");
+              CompilerKit::Detail::print_error("Invalid combination of operands and registers.",
+                                               "CompilerKit");
               throw std::runtime_error("comb_op_reg");
             }
           }
diff --git a/src/CompilerKit/src/Assemblers/Assembler+ARM64.cc b/src/CompilerKit/src/Assemblers/Assembler+ARM64.cc
index c4e4fb6..5113704 100644
--- a/src/CompilerKit/src/Assemblers/Assembler+ARM64.cc
+++ b/src/CompilerKit/src/Assemblers/Assembler+ARM64.cc
@@ -21,10 +21,10 @@
 
 #include <CompilerKit/AE.h>
 #include <CompilerKit/AST.h>
+#include <CompilerKit/Detail/Aarch64.h>
 #include <CompilerKit/Detail/Config.h>
 #include <CompilerKit/ErrorID.h>
 #include <CompilerKit/PEF.h>
-#include <CompilerKit/Detail/Aarch64.h>
 #include <CompilerKit/Utilities/Assembler.h>
 #include <algorithm>
 #include <filesystem>
@@ -274,7 +274,8 @@ static bool asm_read_attributes(std::string line) {
   // that we need this symbol.
   if (CompilerKit::ast_find_needle(line, "extern_segment")) {
     if (kOutputAsBinary) {
-      CompilerKit::Detail::print_error("Invalid extern_segment directive in flat binary mode.", "CompilerKit");
+      CompilerKit::Detail::print_error("Invalid extern_segment directive in flat binary mode.",
+                                       "CompilerKit");
       throw std::runtime_error("invalid_extern_segment_bin");
     }
 
@@ -333,7 +334,8 @@ static bool asm_read_attributes(std::string line) {
   // .zero64
   else if (CompilerKit::ast_find_needle(line, "public_segment")) {
     if (kOutputAsBinary) {
-      CompilerKit::Detail::print_error("Invalid public_segment directive in flat binary mode.", "CompilerKit");
+      CompilerKit::Detail::print_error("Invalid public_segment directive in flat binary mode.",
+                                       "CompilerKit");
       throw std::runtime_error("invalid_public_segment_bin");
     }
 
diff --git a/src/CompilerKit/src/Assemblers/Assembler+PowerPC.cc b/src/CompilerKit/src/Assemblers/Assembler+PowerPC.cc
index 6c698bd..bad9535 100644
--- a/src/CompilerKit/src/Assemblers/Assembler+PowerPC.cc
+++ b/src/CompilerKit/src/Assemblers/Assembler+PowerPC.cc
@@ -22,9 +22,9 @@
 #include <CompilerKit/AE.h>
 #include <CompilerKit/AST.h>
 #include <CompilerKit/Detail/Config.h>
+#include <CompilerKit/Detail/Power64.h>
 #include <CompilerKit/ErrorID.h>
 #include <CompilerKit/PEF.h>
-#include <CompilerKit/Detail/Power64.h>
 #include <CompilerKit/Utilities/Assembler.h>
 #include <algorithm>
 #include <filesystem>
@@ -274,7 +274,8 @@ static bool asm_read_attributes(std::string line) {
   // that we need this symbol.
   if (CompilerKit::ast_find_needle(line, "extern_segment")) {
     if (kOutputAsBinary) {
-      CompilerKit::Detail::print_error("Invalid extern_segment directive in flat binary mode.", "CompilerKit");
+      CompilerKit::Detail::print_error("Invalid extern_segment directive in flat binary mode.",
+                                       "CompilerKit");
       throw std::runtime_error("invalid_extern_segment_bin");
     }
 
@@ -333,7 +334,8 @@ static bool asm_read_attributes(std::string line) {
   // .zero64
   else if (CompilerKit::ast_find_needle(line, "public_segment")) {
     if (kOutputAsBinary) {
-      CompilerKit::Detail::print_error("Invalid public_segment directive in flat binary mode.", "CompilerKit");
+      CompilerKit::Detail::print_error("Invalid public_segment directive in flat binary mode.",
+                                       "CompilerKit");
       throw std::runtime_error("invalid_public_segment_bin");
     }
 
@@ -676,9 +678,10 @@ bool CompilerKit::EncoderPowerPC::WriteLine(std::string line, std::string file)
               // something like r190 doesn't exist in the instruction set.
               if (isdigit(line[line_index + 3]) && isdigit(line[line_index + 2])) {
                 reg_str += line[line_index + 3];
-                CompilerKit::Detail::print_error("invalid register index, r" + reg_str +
-                                        "\nnote: The POWER accepts registers from r0 to r32.",
-                                    file);
+                CompilerKit::Detail::print_error(
+                    "invalid register index, r" + reg_str +
+                        "\nnote: The POWER accepts registers from r0 to r32.",
+                    file);
                 throw std::runtime_error("invalid_register_index");
               }
 
@@ -892,8 +895,8 @@ bool CompilerKit::EncoderPowerPC::WriteLine(std::string line, std::string file)
           }
 
           if (found_some_count < 1 && name[0] != 'l' && name[0] != 's') {
-            CompilerKit::Detail::print_error("invalid combination of opcode and registers.\nline: " + line,
-                                file);
+            CompilerKit::Detail::print_error(
+                "invalid combination of opcode and registers.\nline: " + line, file);
             throw std::runtime_error("invalid_comb_op_reg");
           }
 
diff --git a/src/CompilerKit/src/Compilers/CCompiler+64x0.cc b/src/CompilerKit/src/Compilers/CCompiler+64x0.cc
index 06768eb..394f933 100644
--- a/src/CompilerKit/src/Compilers/CCompiler+64x0.cc
+++ b/src/CompilerKit/src/Compilers/CCompiler+64x0.cc
@@ -11,8 +11,8 @@
 /// TODO: none
 
 #include <CompilerKit/AST.h>
-#include <CompilerKit/UUID.h>
 #include <CompilerKit/Detail/64x0.h>
+#include <CompilerKit/UUID.h>
 #include <CompilerKit/Utilities/Compiler.h>
 #include <cstdio>
 #include <fstream>
diff --git a/src/CompilerKit/src/Compilers/CCompiler+ARM64.cc b/src/CompilerKit/src/Compilers/CCompiler+ARM64.cc
index ad4227b..7b99b70 100644
--- a/src/CompilerKit/src/Compilers/CCompiler+ARM64.cc
+++ b/src/CompilerKit/src/Compilers/CCompiler+ARM64.cc
@@ -11,8 +11,8 @@
 /// TODO: none
 
 #include <CompilerKit/AST.h>
-#include <CompilerKit/UUID.h>
 #include <CompilerKit/Detail/Aarch64.h>
+#include <CompilerKit/UUID.h>
 #include <CompilerKit/Utilities/Compiler.h>
 
 #include <cstdio>
@@ -42,7 +42,6 @@
 
 /////////////////////
 
-
 /////////////////////////////////////
 
 // INTERNAL STUFF OF THE C COMPILER
diff --git a/src/CompilerKit/src/Compilers/CCompiler+Power64.cc b/src/CompilerKit/src/Compilers/CCompiler+Power64.cc
index e123c3d..993ee7c 100644
--- a/src/CompilerKit/src/Compilers/CCompiler+Power64.cc
+++ b/src/CompilerKit/src/Compilers/CCompiler+Power64.cc
@@ -8,8 +8,8 @@
  */
 
 #include <CompilerKit/AST.h>
-#include <CompilerKit/UUID.h>
 #include <CompilerKit/Detail/Power64.h>
+#include <CompilerKit/UUID.h>
 #include <CompilerKit/Utilities/Compiler.h>
 #include <cstdio>
 #include <fstream>
diff --git a/src/CompilerKit/src/Compilers/CPlusPlusCompiler+AMD64.cc b/src/CompilerKit/src/Compilers/CPlusPlusCompiler+AMD64.cc
index c54cc53..4f85f05 100644
--- a/src/CompilerKit/src/Compilers/CPlusPlusCompiler+AMD64.cc
+++ b/src/CompilerKit/src/Compilers/CPlusPlusCompiler+AMD64.cc
@@ -22,9 +22,9 @@
 ///////////////////////
 
 #include <CompilerKit/AST.h>
+#include <CompilerKit/Detail/AMD64.h>
 #include <CompilerKit/PEF.h>
 #include <CompilerKit/UUID.h>
-#include <CompilerKit/Detail/AMD64.h>
 #include <CompilerKit/Utilities/Compiler.h>
 #include <csignal>
 #include <cstdlib>
@@ -165,7 +165,7 @@ CompilerKit::SyntaxLeafList::SyntaxLeaf CompilerFrontendCPlusPlusAMD64::Compile(
 
   if (text.empty()) return syntax_tree;
 
-  std::size_t                                                       index = 0UL;
+  std::size_t                                                     index = 0UL;
   std::vector<std::pair<CompilerKit::SyntaxKeyword, std::size_t>> keywords_list;
 
   for (auto& keyword : kKeywords) {
diff --git a/src/Tools/pef-amd64-cxxdrv.cc b/src/Tools/pef-amd64-cxxdrv.cc
index fa03d25..9e8c0da 100644
--- a/src/Tools/pef-amd64-cxxdrv.cc
+++ b/src/Tools/pef-amd64-cxxdrv.cc
@@ -24,7 +24,8 @@ Int32 main(Int32 argc, Char const* argv[]) {
   CompilerKit::DLLTraits dylib;
   dylib(kPath, kSymbol);
 
-  CompilerKit::DLLTraits::Entrypoint entrypoint_cxx = reinterpret_cast<CompilerKit::DLLTraits::Entrypoint>(dylib.fEntrypoint);
+  CompilerKit::DLLTraits::Entrypoint entrypoint_cxx =
+      reinterpret_cast<CompilerKit::DLLTraits::Entrypoint>(dylib.fEntrypoint);
 
   if (!entrypoint_cxx) {
     kStdOut;