feat(LibCompiler): Reworking architecture to integrate the Arch() method in the AssemblyInterface.

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

1 files changed, 28 insertions, 79 deletions

diff --git a/dev/LibCompiler/src/CPlusPlusCompilerAMD64.cc b/dev/LibCompiler/src/CPlusPlusCompilerAMD64.cc
index f5e9bf7..344622e 100644
--- a/dev/LibCompiler/src/CPlusPlusCompilerAMD64.cc
+++ b/dev/LibCompiler/src/CPlusPlusCompilerAMD64.cc
@@ -148,7 +148,7 @@ class CompilerFrontendCPlusPlus final : public LibCompiler::ICompilerFrontend {
 
   LIBCOMPILER_COPY_DEFAULT(CompilerFrontendCPlusPlus);
 
-  Boolean Compile(const std::string text, const std::string file) override;
+  Boolean Compile(const std::string text, std::string file) override;
 
   const char* Language() override;
 };
@@ -174,7 +174,7 @@ static std::size_t kFunctionEmbedLevel = 0UL;
 /// detail namespaces
 
 const char* CompilerFrontendCPlusPlus::Language() {
-  return "NeKernel C++";
+  return "AMD64 C++";
 }
 
 static std::uintptr_t                                      kOrigin = 0x1000000;
@@ -187,37 +187,15 @@ static std::vector<std::pair<std::string, std::uintptr_t>> kOriginMap;
 
 /////////////////////////////////////////////////////////////////////////////////////////
 
-Boolean CompilerFrontendCPlusPlus::Compile(std::string text, const std::string file) {
+Boolean CompilerFrontendCPlusPlus::Compile(std::string text, std::string file) {
   if (text.empty()) return false;
 
-  // Clean whitespace and tabs
-  std::string cleanLine = text;
-  cleanLine.erase(std::remove(cleanLine.begin(), cleanLine.end(), '\t'), cleanLine.end());
-  cleanLine.erase(0, cleanLine.find_first_not_of(" \r\n"));
-  cleanLine.erase(cleanLine.find_last_not_of(" \r\n") + 1);
-
-  // Skip empty, doc, or block comment lines
-  if (cleanLine.empty() || cleanLine.starts_with("///") || cleanLine.starts_with("//") ||
-      cleanLine.starts_with("/*"))
-    return false;
-
   std::size_t                                                       index = 0UL;
   std::vector<std::pair<LibCompiler::CompilerKeyword, std::size_t>> keywords_list;
 
-  Boolean        found        = false;
-  static Boolean commentBlock = false;
-
   for (auto& keyword : kKeywords) {
     if (text.find(keyword.keyword_name) != std::string::npos) {
       switch (keyword.keyword_kind) {
-        case LibCompiler::kKeywordKindCommentMultiLineStart: {
-          commentBlock = true;
-          return true;
-        }
-        case LibCompiler::kKeywordKindCommentMultiLineEnd: {
-          commentBlock = false;
-          break;
-        }
         case LibCompiler::kKeywordKindCommentInline: {
           break;
         }
@@ -239,22 +217,13 @@ Boolean CompilerFrontendCPlusPlus::Compile(std::string text, const std::string f
 
       keywords_list.emplace_back(std::make_pair(keyword, index));
       ++index;
-
-      found = true;
     }
   }
 
-  if (!found && !commentBlock) {
-    for (size_t i = 0; i < text.size(); i++) {
-      if (isalnum(text[i])) {
-        Detail::print_error("syntax error: " + text, file);
-        return NO;
-      }
-    }
-  }
+  auto syntax_tree = LibCompiler::SyntaxLeafList::SyntaxLeaf();
 
   for (auto& keyword : keywords_list) {
-    auto syntax_tree = LibCompiler::SyntaxLeafList::SyntaxLeaf();
+    kStdOut << keyword.second;
 
     switch (keyword.first.keyword_kind) {
       case LibCompiler::KeywordKind::kKeywordKindClass: {
@@ -408,10 +377,10 @@ Boolean CompilerFrontendCPlusPlus::Compile(std::string text, const std::string f
                                  return fnName == pair.first;
                                });
 
-        std::stringstream ss;
-        ss << std::hex << it->second;
-
         if (it != kOriginMap.end()) {
+          std::stringstream ss;
+          ss << std::hex << it->second;
+
           syntax_tree.fUserValue = "jmp " + ss.str() + "\n";
           kOrigin += 1UL;
         }
@@ -506,12 +475,12 @@ Boolean CompilerFrontendCPlusPlus::Compile(std::string text, const std::string f
             valueOfVar.erase(i, 1);
           }
 
-          constexpr auto cTrueVal  = "true";
-          constexpr auto cFalseVal = "false";
+          constexpr auto kTrueVal  = "true";
+          constexpr auto kFalseVal = "false";
 
-          if (valueOfVar == cTrueVal) {
+          if (valueOfVar == kTrueVal) {
             valueOfVar = "1";
-          } else if (valueOfVar == cFalseVal) {
+          } else if (valueOfVar == kFalseVal) {
             valueOfVar = "0";
           }
 
@@ -620,14 +589,14 @@ Boolean CompilerFrontendCPlusPlus::Compile(std::string text, const std::string f
           valueOfVar.erase(valueOfVar.find("\t"), 1);
         }
 
-        constexpr auto cTrueVal  = "true";
-        constexpr auto cFalseVal = "false";
+        constexpr auto kTrueVal  = "true";
+        constexpr auto kFalseVal = "false";
 
         /// interpet boolean values, since we're on C++
 
-        if (valueOfVar == cTrueVal) {
+        if (valueOfVar == kTrueVal) {
           valueOfVar = "1";
-        } else if (valueOfVar == cFalseVal) {
+        } else if (valueOfVar == kFalseVal) {
           valueOfVar = "0";
         }
 
@@ -726,16 +695,15 @@ Boolean CompilerFrontendCPlusPlus::Compile(std::string text, const std::string f
         }
       }
       default: {
-        break;
+        continue;
       }
     }
 
-    syntax_tree.fUserData = keyword.first;
-
-    kState.fOutputAssembly << syntax_tree.fUserValue;
+    break;
   }
 
 lc_compile_ok:
+  kState.fOutputAssembly << syntax_tree.fUserValue;
   return true;
 }
 
@@ -754,37 +722,23 @@ class AssemblyCPlusPlusInterface final ASSEMBLY_INTERFACE {
 
   LIBCOMPILER_COPY_DEFAULT(AssemblyCPlusPlusInterface);
 
-  [[maybe_unused]] static Int32 Arch() noexcept { return LibCompiler::AssemblyFactory::kArchAMD64; }
+  [[maybe_unused]] Int32 Arch() noexcept override {
+    return LibCompiler::AssemblyFactory::kArchAMD64;
+  }
 
   Int32 CompileToFormat(std::string src, Int32 arch) override {
-    if (arch != AssemblyCPlusPlusInterface::Arch()) return 1;
-
-    if (kCompilerFrontend == nullptr) return 1;
+    if (kCompilerFrontend == nullptr) return kExitNO;
 
     /* @brief copy contents wihtout extension */
-    std::string   src_file = src;
-    std::ifstream src_fp   = std::ifstream(src_file, std::ios::in);
+    std::ifstream src_fp = std::ifstream(src, std::ios::in);
 
-    const char* cExts[] = kAsmFileExts;
+    std::string dest = src;
+    dest += ".masm";
 
-    std::string dest = src_file;
-    dest += cExts[2];
+    std::string line_source;
 
     kState.fOutputAssembly.open(dest);
 
-    if (!kState.fOutputAssembly.good()) return kExitNO;
-
-    kState.fOutputAssembly
-        << "; Assembler Dialect: AMD64 LibCompiler Assembler. (Generated from C++)\n";
-    kState.fOutputAssembly << "; Date: " << LibCompiler::current_date() << "\n"
-                           << "#bits 64\n#org " << kOrigin << "\n";
-
-    // ===================================
-    // Parse source file.
-    // ===================================
-
-    std::string line_source;
-
     while (std::getline(src_fp, line_source)) {
       kCompilerFrontend->Compile(line_source, src);
     }
@@ -951,12 +905,7 @@ LIBCOMPILER_MODULE(CompilerCPlusPlusAMD64) {
       return kExitNO;
     }
 
-    kStdOut << "CPlusPlusCompilerAMD64: Building: " << argv[index] << std::endl;
-
-    if (kFactory.Compile(argv_i, kMachine) != kExitOK) {
-      kStdOut << "CPlusPlusCompilerAMD64: Failed to build: " << argv[index] << std::endl;
-      return kExitNO;
-    }
+    kFactory.Compile(argv_i, kMachine);
   }
 
   return kExitOK;