feat! breaking changes on necti sources.

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

1 files changed, 0 insertions, 911 deletions

diff --git a/dev/CompilerKit/src/Backend/AssemblerPowerPC.cc b/dev/CompilerKit/src/Backend/AssemblerPowerPC.cc
deleted file mode 100644
index b4f14ea..0000000
--- a/dev/CompilerKit/src/Backend/AssemblerPowerPC.cc
+++ /dev/null
@@ -1,911 +0,0 @@
-/* ========================================
-
-  Copyright (C) 2024-2025 Amlal El Mahrouss, Licensed under the Apache 2.0 license
-
-======================================== */
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-/// @file AssemblerPower.cc
-/// @author Amlal El Mahrouss
-/// @brief POWER Assembler.
-
-/// REMINDER: when dealing with an undefined symbol use (string
-/// size):LinkerFindSymbol:(string) so that li will look for it.
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-#ifndef __ASM_NEED_PPC__
-#define __ASM_NEED_PPC__ 1
-#endif
-
-#include <CompilerKit/AE.h>
-#include <CompilerKit/ErrorID.h>
-#include <CompilerKit/Frontend.h>
-#include <CompilerKit/PEF.h>
-#include <CompilerKit/Version.h>
-#include <CompilerKit/impl/PowerPC.h>
-#include <CompilerKit/utils/AsmUtils.h>
-#include <algorithm>
-#include <filesystem>
-#include <fstream>
-#include <iostream>
-#include <vector>
-
-/////////////////////
-
-// ANSI ESCAPE CODES
-
-/////////////////////
-
-#define kBlank "\e[0;30m"
-#define kRed "\e[0;31m"
-#define kWhite "\e[0;97m"
-#define kYellow "\e[0;33m"
-
-constexpr auto cPowerIPAlignment = 0x4U;
-
-static Char kOutputArch = CompilerKit::kPefArchPowerPC;
-
-static std::size_t kCounter = 1UL;
-
-static std::uintptr_t                                      kOrigin = kPefBaseOrigin;
-static std::vector<std::pair<std::string, std::uintptr_t>> kOriginLabel;
-
-static std::vector<uint8_t> kBytes;
-
-static CompilerKit::AERecordHeader kCurrentRecord{
-    .fName = "", .fKind = CompilerKit::kPefCode, .fSize = 0, .fOffset = 0};
-
-static std::vector<CompilerKit::AERecordHeader> kRecords;
-static std::vector<std::string>                 kUndefinedSymbols;
-
-static const std::string kUndefinedSymbol = ":UndefinedSymbol:";
-static const std::string kRelocSymbol     = ":RuntimeSymbol:";
-
-// \brief forward decl.
-static bool asm_read_attributes(std::string line);
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-/// @brief POWER assembler entrypoint, the program/module starts here.
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-NECTI_MODULE(AssemblerMainPower64) {
-  CompilerKit::install_signal(SIGSEGV, Detail::drvi_crash_handler);
-
-  for (size_t i = 1; i < argc; ++i) {
-    if (argv[i][0] == '-') {
-      if (strcmp(argv[i], "--ver") == 0 || strcmp(argv[i], "--v") == 0) {
-        kStdOut << "AssemblerPower: POWER64 Assembler Driver.\nAssemblerPower: " << kDistVersion
-                << "\nAssemblerPower: "
-                   "Copyright (c) "
-                   "Amlal El Mahrouss\n";
-        return 0;
-      } else if (strcmp(argv[i], "--h") == 0) {
-        kStdOut << "AssemblerPower: POWER64 Assembler Driver.\nAssemblerPower: Copyright (c) 2024 "
-                   "Amlal El Mahrouss\n";
-        kStdOut << "--version,/v: print program version.\n";
-        kStdOut << "--verbose: print verbose output.\n";
-        kStdOut << "--binary: output as flat binary.\n";
-
-        return 0;
-      } else if (strcmp(argv[i], "--binary") == 0) {
-        kOutputAsBinary = true;
-        continue;
-      } else if (strcmp(argv[i], "--verbose") == 0) {
-        kVerbose = true;
-        continue;
-      }
-
-      kStdOut << "AssemblerPower: ignore " << argv[i] << "\n";
-      continue;
-    }
-
-    if (!std::filesystem::exists(argv[i])) {
-      kStdOut << "AssemblerPower: can't open: " << argv[i] << std::endl;
-      goto asm_fail_exit;
-    }
-
-    std::string object_output(argv[i]);
-
-    for (auto& ext : kAsmFileExts) {
-      if (object_output.find(ext) != std::string::npos) {
-        object_output.erase(object_output.find(ext), std::strlen(ext));
-      }
-    }
-
-    object_output += kOutputAsBinary ? kBinaryFileExt : kObjectFileExt;
-
-    std::ifstream file_ptr(argv[i]);
-    std::ofstream file_ptr_out(object_output, std::ofstream::binary);
-
-    if (file_ptr_out.bad()) {
-      if (kVerbose) {
-        kStdOut << "AssemblerPower: error: " << strerror(errno) << "\n";
-      }
-    }
-
-    std::string line;
-
-    CompilerKit::AEHeader hdr{0};
-
-    memset(hdr.fPad, kAENullType, kAEPad);
-
-    hdr.fMagic[0] = kAEMag0;
-    hdr.fMagic[1] = kAEMag1;
-    hdr.fSize     = sizeof(CompilerKit::AEHeader);
-    hdr.fArch     = kOutputArch;
-
-    /////////////////////////////////////////////////////////////////////////////////////////
-
-    // COMPILATION LOOP
-
-    /////////////////////////////////////////////////////////////////////////////////////////
-
-    CompilerKit::EncoderPowerPC asm64;
-
-    while (std::getline(file_ptr, line)) {
-      if (auto ln = asm64.CheckLine(line, argv[i]); !ln.empty()) {
-        Detail::print_error(ln, argv[i]);
-        continue;
-      }
-
-      try {
-        asm_read_attributes(line);
-        asm64.WriteLine(line, argv[i]);
-      } catch (const std::exception& e) {
-        if (kVerbose) {
-          std::string what = e.what();
-          Detail::print_warning("exit because of: " + what, "CompilerKit");
-        }
-
-        std::filesystem::remove(object_output);
-        goto asm_fail_exit;
-      }
-    }
-
-    if (!kOutputAsBinary) {
-      if (kVerbose) {
-        kStdOut << "AssemblerPower: Writing object file...\n";
-      }
-
-      // this is the final step, write everything to the file.
-
-      auto pos = file_ptr_out.tellp();
-
-      hdr.fCount = kRecords.size() + kUndefinedSymbols.size();
-
-      file_ptr_out << hdr;
-
-      if (kRecords.empty()) {
-        kStdErr << "AssemblerPower: At least one record is needed to write an object "
-                   "file.\nAssemblerPower: Make one using `public_segment .code64 foo_bar`.\n";
-
-        std::filesystem::remove(object_output);
-        return 1;
-      }
-
-      kRecords[kRecords.size() - 1].fSize = kBytes.size();
-
-      std::size_t record_count = 0UL;
-
-      for (auto& record_hdr : kRecords) {
-        record_hdr.fFlags |= CompilerKit::kKindRelocationAtRuntime;
-        record_hdr.fOffset = record_count;
-        ++record_count;
-
-        file_ptr_out << record_hdr;
-
-        if (kVerbose) kStdOut << "AssemblerPower: Wrote record " << record_hdr.fName << "...\n";
-      }
-
-      // increment once again, so that we won't lie about the kUndefinedSymbols.
-      ++record_count;
-
-      for (auto& sym : kUndefinedSymbols) {
-        CompilerKit::AERecordHeader undefined_sym{0};
-
-        if (kVerbose) kStdOut << "AssemblerPower: Wrote symbol " << sym << " to file...\n";
-
-        undefined_sym.fKind   = kAENullType;
-        undefined_sym.fSize   = sym.size();
-        undefined_sym.fOffset = record_count;
-
-        ++record_count;
-
-        memset(undefined_sym.fPad, kAENullType, kAEPad);
-        memcpy(undefined_sym.fName, sym.c_str(), sym.size());
-
-        file_ptr_out << undefined_sym;
-
-        ++kCounter;
-      }
-
-      auto pos_end = file_ptr_out.tellp();
-
-      file_ptr_out.seekp(pos);
-
-      hdr.fStartCode = pos_end;
-      hdr.fCodeSize  = kBytes.size();
-
-      file_ptr_out << hdr;
-
-      file_ptr_out.seekp(pos_end);
-    } else {
-      if (kVerbose) {
-        kStdOut << "AssemblerPower: Write raw binary...\n";
-      }
-    }
-
-    // byte from byte, we write this.
-    for (auto& byte : kBytes) {
-      file_ptr_out.write(reinterpret_cast<const char*>(&byte), sizeof(byte));
-    }
-
-    if (kVerbose) kStdOut << "AssemblerPower: Wrote file with program in it.\n";
-
-    file_ptr_out.flush();
-    file_ptr_out.close();
-
-    if (kVerbose) kStdOut << "AssemblerPower: Exit succeeded.\n";
-
-    return 0;
-  }
-
-asm_fail_exit:
-
-  if (kVerbose) kStdOut << "AssemblerPower: Exit failed.\n";
-
-  return NECTI_EXEC_ERROR;
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-// @brief Check for attributes
-// returns true if any was found.
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-static bool asm_read_attributes(std::string line) {
-  // extern_segment is the opposite of public_segment, it signals to the li
-  // that we need this symbol.
-  if (CompilerKit::find_word(line, "extern_segment")) {
-    if (kOutputAsBinary) {
-      Detail::print_error("Invalid extern_segment directive in flat binary mode.", "CompilerKit");
-      throw std::runtime_error("invalid_extern_segment_bin");
-    }
-
-    auto name = line.substr(line.find("extern_segment") + strlen("extern_segment") + 1);
-
-    if (name.size() == 0) {
-      Detail::print_error("Invalid extern_segment", "CompilerKit");
-      throw std::runtime_error("invalid_extern_segment");
-    }
-
-    std::string result = std::to_string(name.size());
-    result += kUndefinedSymbol;
-
-    // mangle this
-    for (char& j : name) {
-      if (j == ' ' || j == ',') j = '$';
-    }
-
-    result += name;
-
-    if (name.find(".code64") != std::string::npos) {
-      // data is treated as code.
-      kCurrentRecord.fKind = CompilerKit::kPefCode;
-    } else if (name.find(".data64") != std::string::npos) {
-      // no code will be executed from here.
-      kCurrentRecord.fKind = CompilerKit::kPefData;
-    } else if (name.find(".zero64") != std::string::npos) {
-      // this is a bss section.
-      kCurrentRecord.fKind = CompilerKit::kPefZero;
-    }
-
-    // this is a special case for the start stub.
-    // we want this so that li can find it.
-
-    if (name == kPefStart) {
-      kCurrentRecord.fKind = CompilerKit::kPefCode;
-    }
-
-    // now we can tell the code size of the previous kCurrentRecord.
-
-    if (!kRecords.empty()) kRecords[kRecords.size() - 1].fSize = kBytes.size();
-
-    memset(kCurrentRecord.fName, 0, kAESymbolLen);
-    memcpy(kCurrentRecord.fName, result.c_str(), result.size());
-
-    ++kCounter;
-
-    memset(kCurrentRecord.fPad, kAENullType, kAEPad);
-
-    kRecords.emplace_back(kCurrentRecord);
-
-    return true;
-  }
-  // public_segment is a special keyword used by AssemblerPower to tell the AE output stage to
-  // mark this section as a header. it currently supports .code64, .data64.,
-  // .zero64
-  else if (CompilerKit::find_word(line, "public_segment")) {
-    if (kOutputAsBinary) {
-      Detail::print_error("Invalid public_segment directive in flat binary mode.", "CompilerKit");
-      throw std::runtime_error("invalid_public_segment_bin");
-    }
-
-    auto name = line.substr(line.find("public_segment") + strlen("public_segment"));
-
-    std::string name_copy = name;
-
-    for (char& j : name) {
-      if (j == ' ') j = '$';
-    }
-
-    if (name.find(".code64") != std::string::npos) {
-      // data is treated as code.
-
-      name_copy.erase(name_copy.find(".code64"), strlen(".code64"));
-      kCurrentRecord.fKind = CompilerKit::kPefCode;
-    } else if (name.find(".data64") != std::string::npos) {
-      // no code will be executed from here.
-
-      name_copy.erase(name_copy.find(".data64"), strlen(".data64"));
-      kCurrentRecord.fKind = CompilerKit::kPefData;
-    } else if (name.find(".zero64") != std::string::npos) {
-      // this is a bss section.
-
-      name_copy.erase(name_copy.find(".zero64"), strlen(".zero64"));
-      kCurrentRecord.fKind = CompilerKit::kPefZero;
-    }
-
-    // this is a special case for the start stub.
-    // we want this so that li can find it.
-
-    if (name == kPefStart) {
-      kCurrentRecord.fKind = CompilerKit::kPefCode;
-    }
-
-    while (name_copy.find(" ") != std::string::npos) name_copy.erase(name_copy.find(" "), 1);
-
-    kOriginLabel.push_back(std::make_pair(name_copy, kOrigin));
-    ++kOrigin;
-
-    // now we can tell the code size of the previous kCurrentRecord.
-
-    if (!kRecords.empty()) kRecords[kRecords.size() - 1].fSize = kBytes.size();
-
-    memset(kCurrentRecord.fName, 0, kAESymbolLen);
-    memcpy(kCurrentRecord.fName, name.c_str(), name.size());
-
-    ++kCounter;
-
-    memset(kCurrentRecord.fPad, kAENullType, kAEPad);
-
-    kRecords.emplace_back(kCurrentRecord);
-
-    return true;
-  }
-
-  return false;
-}
-
-// \brief algorithms and helpers.
-
-namespace Detail::algorithm {
-// \brief authorize a brief set of characters.
-static inline bool is_not_alnum_space(char c) {
-  return !(isalpha(c) || isdigit(c) || (c == ' ') || (c == '\t') || (c == ',') || (c == '(') ||
-           (c == ')') || (c == '"') || (c == '\'') || (c == '[') || (c == ']') || (c == '+') ||
-           (c == '_') || (c == ':') || (c == '@') || (c == '.'));
-}
-
-bool is_valid_power64(std::string str) {
-  return std::find_if(str.begin(), str.end(), is_not_alnum_space) == str.end();
-}
-}  // namespace Detail::algorithm
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-// @brief Check for line (syntax check)
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-std::string CompilerKit::EncoderPowerPC::CheckLine(std::string line, std::string file) {
-  std::string err_str;
-
-  if (line.empty() || CompilerKit::find_word(line, "extern_segment") ||
-      CompilerKit::find_word(line, "public_segment") || line.find('#') != std::string::npos ||
-      CompilerKit::find_word(line, ";")) {
-    if (line.find('#') != std::string::npos) {
-      line.erase(line.find('#'));
-    } else if (line.find(';') != std::string::npos) {
-      line.erase(line.find(';'));
-    } else {
-      /// does the line contains valid input?
-      if (!Detail::algorithm::is_valid_power64(line)) {
-        err_str = "Line contains non alphanumeric characters.\nhere -> ";
-        err_str += line;
-      }
-    }
-
-    return err_str;
-  }
-
-  if (!Detail::algorithm::is_valid_power64(line)) {
-    err_str = "Line contains non alphanumeric characters.\nhere -> ";
-    err_str += line;
-
-    return err_str;
-  }
-
-  // check for a valid instruction format.
-
-  if (line.find(',') != std::string::npos) {
-    if (line.find(',') + 1 == line.size()) {
-      err_str += "\nInstruction lacks right register, here -> ";
-      err_str += line.substr(line.find(','));
-
-      return err_str;
-    } else {
-      bool nothing_on_right = true;
-
-      if (line.find(',') + 1 > line.size()) {
-        err_str += "\nInstruction not complete, here -> ";
-        err_str += line;
-
-        return err_str;
-      }
-
-      auto substr = line.substr(line.find(',') + 1);
-
-      for (auto& ch : substr) {
-        if (ch != ' ' && ch != '\t') {
-          nothing_on_right = false;
-        }
-      }
-
-      // this means we found nothing after that ',' .
-      if (nothing_on_right) {
-        err_str += "\nInstruction not complete, here -> ";
-        err_str += line;
-
-        return err_str;
-      }
-    }
-  }
-
-  // these do take an argument.
-  std::vector<std::string> operands_inst = {"stw", "li"};
-
-  // these don't.
-  std::vector<std::string> filter_inst = {"blr", "bl", "sc"};
-
-  for (auto& opcode_risc : kOpcodesPowerPC) {
-    if (CompilerKit::find_word(line, opcode_risc.name)) {
-      for (auto& op : operands_inst) {
-        // if only the instruction was found.
-        if (line == op) {
-          err_str += "\nMalformed ";
-          err_str += op;
-          err_str += " instruction, here -> ";
-          err_str += line;
-        }
-      }
-
-      // if it is like that -> addr1, 0x0
-      if (auto it = std::find(filter_inst.begin(), filter_inst.end(), opcode_risc.name);
-          it == filter_inst.cend()) {
-        if (CompilerKit::find_word(line, opcode_risc.name)) {
-          if (!isspace(line[line.find(opcode_risc.name) + strlen(opcode_risc.name)])) {
-            err_str += "\nMissing space between ";
-            err_str += opcode_risc.name;
-            err_str += " and operands.\nhere -> ";
-            err_str += line;
-          }
-        }
-      }
-
-      return err_str;
-    }
-  }
-
-  err_str += "Unrecognized instruction: " + line;
-
-  return err_str;
-}
-
-bool CompilerKit::EncoderPowerPC::WriteNumber(const std::size_t& pos, std::string& jump_label) {
-  if (!isdigit(jump_label[pos])) return false;
-
-  switch (jump_label[pos + 1]) {
-    case 'x': {
-      if (auto res = strtol(jump_label.substr(pos + 2).c_str(), nullptr, 16); !res) {
-        if (errno != 0) {
-          Detail::print_error("invalid hex number: " + jump_label, "CompilerKit");
-          throw std::runtime_error("invalid_hex");
-        }
-      }
-
-      CompilerKit::NumberCast64 num(strtol(jump_label.substr(pos + 2).c_str(), nullptr, 16));
-
-      for (char& i : num.number) {
-        kBytes.push_back(i);
-      }
-
-      if (kVerbose) {
-        kStdOut << "AssemblerPower: found a base 16 number here: " << jump_label.substr(pos)
-                << "\n";
-      }
-
-      return true;
-    }
-    case 'b': {
-      if (auto res = strtol(jump_label.substr(pos + 2).c_str(), nullptr, 2); !res) {
-        if (errno != 0) {
-          Detail::print_error("invalid binary number: " + jump_label, "CompilerKit");
-          throw std::runtime_error("invalid_bin");
-        }
-      }
-
-      CompilerKit::NumberCast64 num(strtol(jump_label.substr(pos + 2).c_str(), nullptr, 2));
-
-      if (kVerbose) {
-        kStdOut << "AssemblerPower: found a base 2 number here: " << jump_label.substr(pos) << "\n";
-      }
-
-      for (char& i : num.number) {
-        kBytes.push_back(i);
-      }
-
-      return true;
-    }
-    case 'o': {
-      if (auto res = strtol(jump_label.substr(pos + 2).c_str(), nullptr, 7); !res) {
-        if (errno != 0) {
-          Detail::print_error("invalid octal number: " + jump_label, "CompilerKit");
-          throw std::runtime_error("invalid_octal");
-        }
-      }
-
-      CompilerKit::NumberCast64 num(strtol(jump_label.substr(pos + 2).c_str(), nullptr, 7));
-
-      if (kVerbose) {
-        kStdOut << "AssemblerPower: found a base 8 number here: " << jump_label.substr(pos) << "\n";
-      }
-
-      for (char& i : num.number) {
-        kBytes.push_back(i);
-      }
-
-      return true;
-    }
-    default: {
-      break;
-    }
-  }
-
-  /* check for errno and stuff like that */
-  if (auto res = strtol(jump_label.substr(pos).c_str(), nullptr, 10); !res) {
-    if (errno != 0) {
-      return false;
-    }
-  }
-
-  CompilerKit::NumberCast64 num(strtol(jump_label.substr(pos).c_str(), nullptr, 10));
-
-  for (char& i : num.number) {
-    kBytes.push_back(i);
-  }
-
-  if (kVerbose) {
-    kStdOut << "AssemblerPower: found a base 10 number here: " << jump_label.substr(pos) << "\n";
-  }
-
-  return true;
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-/// @brief Read and write an instruction to the output array.
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-bool CompilerKit::EncoderPowerPC::WriteLine(std::string line, std::string file) {
-  if (CompilerKit::find_word(line, "public_segment")) return false;
-  if (!Detail::algorithm::is_valid_power64(line)) return false;
-
-  for (auto& opcode_risc : kOpcodesPowerPC) {
-    // strict check here
-    if (CompilerKit::find_word(line, opcode_risc.name)) {
-      std::string         name(opcode_risc.name);
-      std::string         jump_label, cpy_jump_label;
-      std::vector<size_t> found_registers_index;
-
-      // check funct7 type.
-      switch (opcode_risc.ops->type) {
-        default: {
-          NumberCast32 num(opcode_risc.opcode);
-
-          for (auto ch : num.number) {
-            kBytes.emplace_back(ch);
-          }
-          break;
-        }
-        case BADDR:
-        case PCREL: {
-          auto num = GetNumber32(line, name);
-
-          kBytes.emplace_back(num.number[0]);
-          kBytes.emplace_back(num.number[1]);
-          kBytes.emplace_back(num.number[2]);
-          kBytes.emplace_back(0x48);
-
-          break;
-        }
-        /// General purpose, float, vector operations. Everything that involve
-        /// registers.
-        case G0REG:
-        case FREG:
-        case VREG:
-        case GREG: {
-          // \brief how many registers we found.
-          std::size_t found_some_count = 0UL;
-          std::size_t register_count   = 0UL;
-          std::string opcodeName       = opcode_risc.name;
-          std::size_t register_sum     = 0;
-
-          NumberCast64 num(opcode_risc.opcode);
-
-          for (size_t line_index = 0UL; line_index < line.size(); line_index++) {
-            if (line[line_index] == kAsmRegisterPrefix[0] && isdigit(line[line_index + 1])) {
-              std::string register_syntax = kAsmRegisterPrefix;
-              register_syntax += line[line_index + 1];
-
-              if (isdigit(line[line_index + 2])) register_syntax += line[line_index + 2];
-
-              std::string reg_str;
-              reg_str += line[line_index + 1];
-
-              if (isdigit(line[line_index + 2])) reg_str += line[line_index + 2];
-
-              // it ranges from r0 to r19
-              // 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];
-                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");
-              }
-
-              // finally cast to a size_t
-              std::size_t reg_index = strtol(reg_str.c_str(), nullptr, 10);
-
-              if (reg_index > kAsmRegisterLimit) {
-                Detail::print_error("invalid register index, r" + reg_str, file);
-                throw std::runtime_error("invalid_register_index");
-              }
-
-              if (opcodeName == "li") {
-                char numIndex = 0;
-
-                for (size_t i = 0; i != reg_index; i++) {
-                  numIndex += 0x20;
-                }
-
-                auto num = GetNumber32(line, reg_str);
-
-                kBytes.push_back(num.number[0]);
-                kBytes.push_back(num.number[1]);
-                kBytes.push_back(numIndex);
-                kBytes.push_back(0x38);
-
-                // check if bigger than two.
-                for (size_t i = 2; i < 4; i++) {
-                  if (num.number[i] > 0) {
-                    Detail::print_warning("number overflow on li operation.", file);
-                    break;
-                  }
-                }
-
-                break;
-              }
-
-              if ((opcodeName[0] == 's' && opcodeName[1] == 't')) {
-                if (register_sum == 0) {
-                  for (size_t indexReg = 0UL; indexReg < reg_index; ++indexReg) {
-                    register_sum += 0x20;
-                  }
-                } else {
-                  register_sum += reg_index;
-                }
-              }
-
-              if (opcodeName == "mr") {
-                switch (register_count) {
-                  case 0: {
-                    kBytes.push_back(0x78);
-
-                    char numIndex = 0x3;
-
-                    for (size_t i = 0; i != reg_index; i++) {
-                      numIndex += 0x8;
-                    }
-
-                    kBytes.push_back(numIndex);
-
-                    break;
-                  }
-                  case 1: {
-                    char numIndex = 0x1;
-
-                    for (size_t i = 0; i != reg_index; i++) {
-                      numIndex += 0x20;
-                    }
-
-                    for (size_t i = 0; i != reg_index; i++) {
-                      kBytes[kBytes.size() - 1] += 0x8;
-                    }
-
-                    kBytes[kBytes.size() - 1] -= 0x8;
-
-                    kBytes.push_back(numIndex);
-
-                    if (reg_index >= 10 && reg_index < 20)
-                      kBytes.push_back(0x7d);
-                    else if (reg_index >= 20 && reg_index < 30)
-                      kBytes.push_back(0x7e);
-                    else if (reg_index >= 30)
-                      kBytes.push_back(0x7f);
-                    else
-                      kBytes.push_back(0x7c);
-
-                    break;
-                  }
-                  default:
-                    break;
-                }
-
-                ++register_count;
-                ++found_some_count;
-              }
-
-              if (opcodeName == "addi") {
-                if (found_some_count == 2 || found_some_count == 0)
-                  kBytes.emplace_back(reg_index);
-                else if (found_some_count == 1)
-                  kBytes.emplace_back(0x00);
-
-                ++found_some_count;
-
-                if (found_some_count > 3) {
-                  Detail::print_error("Too much registers. -> " + line, file);
-                  throw std::runtime_error("too_much_regs");
-                }
-              }
-
-              if (opcodeName.find("cmp") != std::string::npos) {
-                ++found_some_count;
-
-                if (found_some_count > 3) {
-                  Detail::print_error("Too much registers. -> " + line, file);
-                  throw std::runtime_error("too_much_regs");
-                }
-              }
-
-              if (opcodeName.find("mf") != std::string::npos ||
-                  opcodeName.find("mt") != std::string::npos) {
-                char numIndex = 0;
-
-                for (size_t i = 0; i != reg_index; i++) {
-                  numIndex += 0x20;
-                }
-
-                num.number[2] += numIndex;
-
-                ++found_some_count;
-
-                if (found_some_count > 1) {
-                  Detail::print_error("Too much registers. -> " + line, file);
-                  throw std::runtime_error("too_much_regs");
-                }
-
-                if (kVerbose) {
-                  kStdOut << "AssemblerPower: Found register: " << register_syntax << "\n";
-                  kStdOut << "AssemblerPower: Amount of registers in instruction: "
-                          << found_some_count << "\n";
-                }
-
-                if (reg_index >= 10 && reg_index < 20)
-                  num.number[3] = 0x7d;
-                else if (reg_index >= 20 && reg_index < 30)
-                  num.number[3] = 0x7e;
-                else if (reg_index >= 30)
-                  num.number[3] = 0x7f;
-                else
-                  num.number[3] = 0x7c;
-
-                for (auto ch : num.number) {
-                  kBytes.emplace_back(ch);
-                }
-              }
-
-              found_registers_index.push_back(reg_index);
-            }
-          }
-
-          if (opcodeName == "addi") {
-            kBytes.emplace_back(0x38);
-          }
-
-          if (opcodeName.find("cmp") != std::string::npos) {
-            char rightReg = 0x0;
-
-            for (size_t i = 0; i != found_registers_index[1]; i++) {
-              rightReg += 0x08;
-            }
-
-            kBytes.emplace_back(0x00);
-            kBytes.emplace_back(rightReg);
-            kBytes.emplace_back(found_registers_index[0]);
-            kBytes.emplace_back(0x7c);
-          }
-
-          if ((opcodeName[0] == 's' && opcodeName[1] == 't')) {
-            size_t offset = 0UL;
-
-            if (line.find('+') != std::string::npos) {
-              auto number = GetNumber32(line.substr(line.find("+")), "+");
-              offset      = number.raw;
-            }
-
-            kBytes.push_back(offset);
-            kBytes.push_back(0x00);
-            kBytes.push_back(register_sum);
-
-            kBytes.emplace_back(0x90);
-          }
-
-          if (opcodeName == "mr") {
-            if (register_count == 1) {
-              Detail::print_error("Too few registers. -> " + line, file);
-              throw std::runtime_error("too_few_registers");
-            }
-          }
-
-          // we're not in immediate addressing, reg to reg.
-          if (opcode_risc.ops->type != GREG) {
-            // remember! register to register!
-            if (found_some_count == 1) {
-              Detail::print_error(
-                  "Unrecognized register found.\ntip: each AssemblerPower register "
-                  "starts with 'r'.\nline: " +
-                      line,
-                  file);
-
-              throw std::runtime_error("not_a_register");
-            }
-          }
-
-          if (found_some_count < 1 && name[0] != 'l' && name[0] != 's') {
-            Detail::print_error("invalid combination of opcode and registers.\nline: " + line,
-                                file);
-            throw std::runtime_error("invalid_comb_op_reg");
-          }
-
-          break;
-        }
-      }
-
-      kOrigin += cPowerIPAlignment;
-      break;
-    }
-  }
-
-  return true;
-}
-
-// Last rev 13-1-24