chore: necdrv: AST improvements and frontend milestones and new

keywords.

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

2 files changed, 90 insertions, 15 deletions

diff --git a/src/CompilerKit/src/Assemblers/Assembler+AMD64.cc b/src/CompilerKit/src/Assemblers/Assembler+AMD64.cc
index efe9b8c..e8283d3 100644
--- a/src/CompilerKit/src/Assemblers/Assembler+AMD64.cc
+++ b/src/CompilerKit/src/Assemblers/Assembler+AMD64.cc
@@ -608,7 +608,8 @@ bool CompilerKit::EncoderAMD64::WriteNumber(const std::size_t& pos, std::string&
     }
   }
 
-  auto res = strtol(jump_label.substr(pos).c_str(), nullptr, 10);
+  /// @note We assume base 10 here. As other cases have failed.
+  auto res = strtol(jump_label.substr(pos + 1).c_str(), nullptr, 10);
   res += kOrigin;
 
   if (errno != 0) {
@@ -622,7 +623,7 @@ bool CompilerKit::EncoderAMD64::WriteNumber(const std::size_t& pos, std::string&
   }
 
   if (kVerbose) {
-    kStdOut << "AssemblerAMD64: Found a base 10 number here: " << jump_label.substr(pos) << "\n";
+    kStdOut << "AssemblerAMD64: Found a base 10 number here: " << jump_label.substr(pos + 1) << "\n";
   }
 
   return true;
diff --git a/src/CompilerKit/src/Compilers/NectarCompiler+AMD64.cc b/src/CompilerKit/src/Compilers/NectarCompiler+AMD64.cc
index 0827ea1..25349ad 100644
--- a/src/CompilerKit/src/Compilers/NectarCompiler+AMD64.cc
+++ b/src/CompilerKit/src/Compilers/NectarCompiler+AMD64.cc
@@ -285,6 +285,7 @@ static auto nectar_get_impl_member(const CompilerKit::STLString& class_name,
 CompilerKit::SyntaxLeafList::SyntaxLeaf CompilerFrontendNectarAMD64::Compile(
     CompilerKit::STLString& text, const CompilerKit::STLString& file) {
   CompilerKit::SyntaxLeafList::SyntaxLeaf syntax_tree;
+  CompilerKit::STLString syntax_rem_buffer;
 
   if (text.empty()) return syntax_tree;
 
@@ -575,9 +576,6 @@ CompilerKit::SyntaxLeafList::SyntaxLeaf CompilerFrontendNectarAMD64::Compile(
 
         if (valueOfVar.find("{") != CompilerKit::STLString::npos) {
           break;
-        } else if (CompilerKit::KeywordKind::kKeywordKindFunctionAccess == keyword.first.fKeywordKind) {
-          syntax_tree.fUserValue += (kNasmOutput ? "section .text\nextern " : "extern_segment .code64") +
-                                    text.substr(0, text.find(keyword.first.fKeywordName)) + "\n";
         }
 
         if (CompilerKit::KeywordKind::kKeywordKindFunctionAccess == keyword.first.fKeywordKind)
@@ -597,6 +595,20 @@ CompilerKit::SyntaxLeafList::SyntaxLeaf CompilerFrontendNectarAMD64::Compile(
 
         auto method = text.substr(0, text.find(keyword.first.fKeywordName));
 
+        if (method.find("let ") != CompilerKit::STLString::npos) {
+          method.erase(0, method.find("let ") + strlen("let "));
+        } else if (method.find("const ") != CompilerKit::STLString::npos) {
+          method.erase(0, method.find("const ") + strlen("const "));
+        }
+
+        if (method.find(":=") != CompilerKit::STLString::npos) {
+          method.erase(0, method.find(":=") + strlen(":="));
+        }
+
+        while (method.find(" ") != CompilerKit::STLString::npos) {
+          method.erase(method.find(" "), 1);
+        }
+
         if (!nectar_get_variable_ref(nameVar).empty())
           syntax_tree.fUserValue += "lea r8, " + nectar_get_variable_ref(nameVar) + "\n";
 
@@ -609,6 +621,8 @@ CompilerKit::SyntaxLeafList::SyntaxLeaf CompilerFrontendNectarAMD64::Compile(
         auto                   index = 9;
         auto                   cnter = 0;
 
+        CompilerKit::STLString buf;
+
         for (auto& ch : args) {
           if (ch == ',' || ch == ')') {
             if (index <= 15) {
@@ -626,8 +640,7 @@ CompilerKit::SyntaxLeafList::SyntaxLeaf CompilerFrontendNectarAMD64::Compile(
                 }
               }
 
-              if (!arg.empty())
-                syntax_tree.fUserValue += "mov r" + std::to_string(index) + ", " + val + "\n";
+              if (!arg.empty()) buf += "mov r" + std::to_string(index) + ", " + val + "\n";
 
               arg.clear();
               ++index;
@@ -642,6 +655,7 @@ CompilerKit::SyntaxLeafList::SyntaxLeaf CompilerFrontendNectarAMD64::Compile(
 
         if (!nectar_get_variable_ref(nameVar).empty()) {
           if (!kNasmOutput) {
+            syntax_tree.fUserValue += buf;
             syntax_tree.fUserValue += "call ";
             syntax_tree.fUserValue +=
                 (keyword.first.fKeywordName.ends_with('>') ? " __ptr __offset " : " __offset ") +
@@ -661,7 +675,11 @@ CompilerKit::SyntaxLeafList::SyntaxLeaf CompilerFrontendNectarAMD64::Compile(
             }
           }
         } else {
-          syntax_tree.fUserValue += "call " + method + "\n";
+          auto res = buf;
+          res += "call " + method + "\n";
+          res += syntax_rem_buffer;
+
+          syntax_tree.fUserValue += res;
         }
 
         break;
@@ -821,16 +839,16 @@ CompilerKit::SyntaxLeafList::SyntaxLeaf CompilerFrontendNectarAMD64::Compile(
             kExternalSymbols.insert(mangled + valueOfVar);
 
             if (!kNasmOutput) {
-              if (valueOfVar.ends_with(")"))
+              if (valueOfVar.ends_with(")") &&
+                      valueOfVar.find("->") != CompilerKit::STLString::npos ||
+                  valueOfVar.find(".") != CompilerKit::STLString::npos)
                 syntax_tree.fUserValue += instr + nectar_get_variable_ref(varName) +
                                           ", __thiscall " + mangled + valueOfVar + "\n";
               else
                 syntax_tree.fUserValue +=
                     instr + nectar_get_variable_ref(varName) + ", " + mangled + valueOfVar + "\n";
             } else {
-              // NASM: Generate call and move result
-              syntax_tree.fUserValue += "call " + mangled + valueOfVar + "\n";
-              syntax_tree.fUserValue += instr + nectar_get_variable_ref(varName) + ", rax\n";
+              syntax_rem_buffer = instr + nectar_get_variable_ref(varName) + ", rax\n";
             }
           }
 
@@ -844,6 +862,40 @@ CompilerKit::SyntaxLeafList::SyntaxLeaf CompilerFrontendNectarAMD64::Compile(
 
         break;
       }
+      case CompilerKit::KeywordKind::kKeywordKindImport: {
+        auto tmp = text;
+
+        if (tmp.find(";") != CompilerKit::STLString::npos)
+          tmp.erase(tmp.find(";"));
+
+        while (tmp.find(" ") != CompilerKit::STLString::npos) {
+          tmp.erase(tmp.find(" "), 1);
+        }
+
+        if (!kNasmOutput)
+          syntax_tree.fUserValue += "extern_segment .zero64 _" + tmp.substr(tmp.find(keyword.first.fKeywordName) + keyword.first.fKeywordName.size()) + "\n";
+        else
+          syntax_tree.fUserValue += "section .data\nextern _" + tmp.substr(tmp.find(keyword.first.fKeywordName) + keyword.first.fKeywordName.size()) + "\n";
+
+        break;
+      }
+      case CompilerKit::KeywordKind::kKeywordKindExtern: {
+        auto tmp = text;
+
+        if (tmp.find(";") != CompilerKit::STLString::npos)
+          tmp.erase(tmp.find(";"));
+
+        while (tmp.find(" ") != CompilerKit::STLString::npos) {
+          tmp.erase(tmp.find(" "), 1);
+        }
+        
+        if (!kNasmOutput)
+          syntax_tree.fUserValue += "extern_segment .code64 _" + tmp.substr(tmp.find(keyword.first.fKeywordName) + keyword.first.fKeywordName.size()) + "\n";
+        else
+          syntax_tree.fUserValue += "section .text\nextern _" + tmp.substr(tmp.find(keyword.first.fKeywordName) + keyword.first.fKeywordName.size()) + "\n";
+
+        break;
+      }
       case CompilerKit::KeywordKind::kKeywordKindReturn: {
         try {
           auto pos = text.find("return");
@@ -1107,7 +1159,8 @@ static Int32 nectar_allocate_stack_variable(const CompilerKit::STLString& var_na
           "CompilerKit");
 
     if (var->fStackOffset > 0)
-      CompilerKit::Detail::print_error("Variable " + var_name + " is already defined.", "CompilerKit");
+      CompilerKit::Detail::print_error("Variable " + var_name + " is already defined.",
+                                       "CompilerKit");
   }
 
   VariableInfo varInfo;
@@ -1407,10 +1460,29 @@ class AssemblyNectarInterfaceAMD64 final CK_ASSEMBLY_INTERFACE {
 
     // First pass: compile all lines and collect symbols
     CompilerKit::STLString compiledCode;
+    std::size_t            lastRes{};
+    std::string            prevRes;
+    std::string            nextRes;
+
     while (std::getline(src_fp, line_source)) {
-      auto res = kFrontend->Compile(line_source, src).fUserValue;
+      auto res = kFrontend->Compile(line_source, src);
       if (kAcceptableErrors > 0) return EXIT_FAILURE;
-      compiledCode += res;
+
+      if (res.fPlaceType == CompilerKit::SyntaxLeafList::SyntaxLeaf::kPlaceBefore) {
+        compiledCode.insert(compiledCode.find(prevRes), res.fUserValue, 0, res.fUserValue.size());
+      } else if (res.fPlaceType == CompilerKit::SyntaxLeafList::SyntaxLeaf::kPlaceAfter) {
+        nextRes = res.fUserValue;
+        continue;
+      } else {
+        compiledCode += res.fUserValue;
+        if (!nextRes.empty()) {
+          compiledCode += nextRes;
+          nextRes.clear();
+        }
+      }
+
+      lastRes = res.fUserValue.size();
+      prevRes = res.fUserValue;
     }
 
     // Output header
@@ -1465,6 +1537,8 @@ NECTAR_MODULE(CompilerNectarAMD64) {
   kKeywords.emplace_back("(", CompilerKit::KeywordKind::kKeywordKindFunctionAccess);
   kKeywords.emplace_back(";", CompilerKit::KeywordKind::kKeywordKindEndLine);
   kKeywords.emplace_back("return", CompilerKit::KeywordKind::kKeywordKindReturn);
+  kKeywords.emplace_back("extern", CompilerKit::KeywordKind::kKeywordKindExtern);
+  kKeywords.emplace_back("import", CompilerKit::KeywordKind::kKeywordKindImport);
 
   kKeywords.emplace_back("if", CompilerKit::KeywordKind::kKeywordKindIf);