From f5a153c3f888f82edaf5038e5762f9bd70356db4 Mon Sep 17 00:00:00 2001 From: Amlal El Mahrouss Date: Wed, 8 Jan 2025 10:28:10 +0100 Subject: KAN-8: Compiler tweaks and AARCH64 in progress. - Refactor C compilers. - Add Encoder for ARM64. - Add and working on assembler for AARCH64. Signed-off-by: Amlal El Mahrouss --- dev/LibCompiler/src/Assembler32x0.cc | 2 +- dev/LibCompiler/src/Assembler64x0.cc | 2 +- dev/LibCompiler/src/AssemblerAMD64.cc | 2 +- dev/LibCompiler/src/AssemblerARM64.cc | 712 +++++++++++++++++++++ dev/LibCompiler/src/AssemblerPower.cc | 36 +- dev/LibCompiler/src/AssemblyFactory.cc | 2 +- dev/LibCompiler/src/CCompiler64x0.cc | 130 ++-- dev/LibCompiler/src/CCompilerARM64.cc | 134 ++-- dev/LibCompiler/src/CCompilerPower64.cc | 168 ++--- dev/LibCompiler/src/CPlusPlusCompilerAMD64.cc | 23 +- .../src/CPlusPlusCompilerPreProcessor.cc | 8 +- dev/LibCompiler/src/CPlusPlusLinkerELF.cc | 6 +- dev/LibCompiler/src/CPlusPlusLinkerPEF.cc | 28 +- 13 files changed, 982 insertions(+), 271 deletions(-) (limited to 'dev/LibCompiler/src') diff --git a/dev/LibCompiler/src/Assembler32x0.cc b/dev/LibCompiler/src/Assembler32x0.cc index e6a055f..5064894 100644 --- a/dev/LibCompiler/src/Assembler32x0.cc +++ b/dev/LibCompiler/src/Assembler32x0.cc @@ -44,7 +44,7 @@ ///////////////////////////////////////////////////////////////////////////////////////// -TOOLCHAINKIT_MODULE(ZKAAssemblerMain32000) +LIBCOMPILER_MODULE(ZKAAssemblerMain32000) { return 0; } diff --git a/dev/LibCompiler/src/Assembler64x0.cc b/dev/LibCompiler/src/Assembler64x0.cc index 8789e1b..b04d50f 100644 --- a/dev/LibCompiler/src/Assembler64x0.cc +++ b/dev/LibCompiler/src/Assembler64x0.cc @@ -111,7 +111,7 @@ namespace Details ///////////////////////////////////////////////////////////////////////////////////////// -TOOLCHAINKIT_MODULE(AssemblerMain64x0) +LIBCOMPILER_MODULE(AssemblerMain64x0) { for (size_t i = 1; i < argc; ++i) { diff --git a/dev/LibCompiler/src/AssemblerAMD64.cc b/dev/LibCompiler/src/AssemblerAMD64.cc index aa87887..330931e 100644 --- a/dev/LibCompiler/src/AssemblerAMD64.cc +++ b/dev/LibCompiler/src/AssemblerAMD64.cc @@ -91,7 +91,7 @@ static bool asm_read_attributes(std::string& line); ///////////////////////////////////////////////////////////////////////////////////////// -TOOLCHAINKIT_MODULE(AssemblerAMD64) +LIBCOMPILER_MODULE(AssemblerMainAMD64) { //////////////// CPU OPCODES BEGIN //////////////// diff --git a/dev/LibCompiler/src/AssemblerARM64.cc b/dev/LibCompiler/src/AssemblerARM64.cc index e69de29..1429f58 100644 --- a/dev/LibCompiler/src/AssemblerARM64.cc +++ b/dev/LibCompiler/src/AssemblerARM64.cc @@ -0,0 +1,712 @@ +/* ------------------------------------------- + + Copyright (C) 2024 Theater Quality Corp, all rights reserved + +------------------------------------------- */ + +///////////////////////////////////////////////////////////////////////////////////////// + +/// @file AssemblerARM64.cxx +/// @author EL Mahrouss Amlal +/// @brief 'ACORN' Assembler. + +/// REMINDER: when dealing with an undefined symbol use (string +/// size):LinkerFindSymbol:(string) so that li will look for it. + +///////////////////////////////////////////////////////////////////////////////////////// + +#define __ASM_NEED_ARM64__ 1 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +///////////////////// + +// ANSI ESCAPE CODES + +///////////////////// + +#define kBlank "\e[0;30m" +#define kRed "\e[0;31m" +#define kWhite "\e[0;97m" +#define kYellow "\e[0;33m" + +#define kStdOut (std::cout << kWhite) +#define kStdErr (std::cout << kRed) + +constexpr auto cPowerIPAlignment = 0x4U; + +static CharType kOutputArch = LibCompiler::kPefArchARM64; +static Boolean kOutputAsBinary = false; + +static UInt32 kErrorLimit = 10; +static UInt32 kAcceptableErrors = 0; + +static std::size_t kCounter = 1UL; + +static std::uintptr_t kOrigin = kPefBaseOrigin; +static std::vector> kOriginLabel; + +static bool kVerbose = false; + +static std::vector kBytes; + +static LibCompiler::AERecordHeader kCurrentRecord{ + .fName = "", .fKind = LibCompiler::kPefCode, .fSize = 0, .fOffset = 0}; + +static std::vector kRecords; +static std::vector kUndefinedSymbols; + +static const std::string kUndefinedSymbol = ":UndefinedSymbol:"; +static const std::string kRelocSymbol = ":RuntimeSymbol:"; + +// \brief forward decl. +static bool asm_read_attributes(std::string& line); + +/// Do not move it on top! it uses the assembler detail namespace! +#include + +///////////////////////////////////////////////////////////////////////////////////////// + +/// @brief POWER assembler entrypoint, the program/module starts here. + +///////////////////////////////////////////////////////////////////////////////////////// + +LIBCOMPILER_MODULE(AssemblerMainARM64) +{ + 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: AARCH64 Assembler Driver.\nAssemblerPower: " << kDistVersion << "\nAssemblerPower: " + "Copyright (c) " + "Theater Quality Corp\n"; + return 0; + } + else if (strcmp(argv[i], "--h") == 0) + { + kStdOut << "AssemblerPower: AARCH64 Assembler Driver.\nAssemblerPower: Copyright (c) 2024 " + "Theater Quality Corp\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; + + LibCompiler::AEHeader hdr{0}; + + memset(hdr.fPad, kAENullType, kAEPad); + + hdr.fMagic[0] = kAEMag0; + hdr.fMagic[1] = kAEMag1; + hdr.fSize = sizeof(LibCompiler::AEHeader); + hdr.fArch = kOutputArch; + + ///////////////////////////////////////////////////////////////////////////////////////// + + // COMPILATION LOOP + + ///////////////////////////////////////////////////////////////////////////////////////// + + LibCompiler::EncoderARM64 asm64; + + while (std::getline(file_ptr, line)) + { + if (auto ln = asm64.CheckLine(line, argv[i]); !ln.empty()) + { + Details::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(); + Details::print_warning("exit because of: " + what, "LibCompiler"); + } + + 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 |= LibCompiler::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) + { + LibCompiler::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(&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 LIBCOMPILER_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 (LibCompiler::find_word(line, "extern_segment")) + { + if (kOutputAsBinary) + { + Details::print_error("Invalid extern_segment directive in flat binary mode.", + "LibCompiler"); + throw std::runtime_error("invalid_extern_segment_bin"); + } + + auto name = line.substr(line.find("extern_segment") + strlen("extern_segment") + 1); + + if (name.size() == 0) + { + Details::print_error("Invalid extern_segment", "LibCompiler"); + 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 = LibCompiler::kPefCode; + } + else if (name.find(".data64") != std::string::npos) + { + // no code will be executed from here. + kCurrentRecord.fKind = LibCompiler::kPefData; + } + else if (name.find(".zero64") != std::string::npos) + { + // this is a bss section. + kCurrentRecord.fKind = LibCompiler::kPefZero; + } + + // this is a special case for the start stub. + // we want this so that li can find it. + + if (name == kPefStart) + { + kCurrentRecord.fKind = LibCompiler::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 (LibCompiler::find_word(line, "public_segment")) + { + if (kOutputAsBinary) + { + Details::print_error("Invalid public_segment directive in flat binary mode.", + "LibCompiler"); + 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 = LibCompiler::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 = LibCompiler::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 = LibCompiler::kPefZero; + } + + // this is a special case for the start stub. + // we want this so that li can find it. + + if (name == kPefStart) + { + kCurrentRecord.fKind = LibCompiler::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 Details::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_arm64(const std::string& str) + { + return std::find_if(str.begin(), str.end(), is_not_alnum_space) == str.end(); + } +} // namespace Details::algorithm + +///////////////////////////////////////////////////////////////////////////////////////// + +// @brief Check for line (syntax check) + +///////////////////////////////////////////////////////////////////////////////////////// + +std::string LibCompiler::EncoderARM64::CheckLine(std::string& line, + const std::string& file) +{ + std::string err_str; + + if (line.empty() || LibCompiler::find_word(line, "extern_segment") || + LibCompiler::find_word(line, "public_segment") || + line.find('#') != std::string::npos || LibCompiler::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 (!Details::algorithm::is_valid_arm64(line)) + { + err_str = "Line contains non alphanumeric characters.\nhere -> "; + err_str += line; + } + } + + return err_str; + } + + if (!Details::algorithm::is_valid_arm64(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; + } + } + } + + return err_str; +} + +bool LibCompiler::EncoderARM64::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) + { + Details::print_error("invalid hex number: " + jump_label, "LibCompiler"); + throw std::runtime_error("invalid_hex"); + } + } + + LibCompiler::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) + { + Details::print_error("invalid binary number: " + jump_label, "LibCompiler"); + throw std::runtime_error("invalid_bin"); + } + } + + LibCompiler::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) + { + Details::print_error("invalid octal number: " + jump_label, "LibCompiler"); + throw std::runtime_error("invalid_octal"); + } + } + + LibCompiler::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; + } + } + + LibCompiler::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 LibCompiler::EncoderARM64::WriteLine(std::string& line, + const std::string& file) +{ + if (LibCompiler::find_word(line, "public_segment")) + return false; + + if (!Details::algorithm::is_valid_arm64(line)) + return false; + + + return true; +} + +// Last rev 13-1-24 diff --git a/dev/LibCompiler/src/AssemblerPower.cc b/dev/LibCompiler/src/AssemblerPower.cc index 5014575..a98e3e8 100644 --- a/dev/LibCompiler/src/AssemblerPower.cc +++ b/dev/LibCompiler/src/AssemblerPower.cc @@ -81,7 +81,7 @@ static bool asm_read_attributes(std::string& line); ///////////////////////////////////////////////////////////////////////////////////////// -TOOLCHAINKIT_MODULE(AssemblerMainPower64) +LIBCOMPILER_MODULE(AssemblerMainPower64) { for (size_t i = 1; i < argc; ++i) { @@ -299,7 +299,7 @@ asm_fail_exit: if (kVerbose) kStdOut << "AssemblerPower: Exit failed.\n"; - return TOOLCHAINKIT_EXEC_ERROR; + return LIBCOMPILER_EXEC_ERROR; } ///////////////////////////////////////////////////////////////////////////////////////// @@ -573,9 +573,9 @@ std::string LibCompiler::EncoderPowerPC::CheckLine(std::string& line, // these don't. std::vector filter_inst = {"blr", "bl", "sc"}; - for (auto& opcodePPC : kOpcodesPowerPC) + for (auto& opcode_risc : kOpcodesPowerPC) { - if (LibCompiler::find_word(line, opcodePPC.name)) + if (LibCompiler::find_word(line, opcode_risc.name)) { for (auto& op : operands_inst) { @@ -591,16 +591,16 @@ std::string LibCompiler::EncoderPowerPC::CheckLine(std::string& line, // if it is like that -> addr1, 0x0 if (auto it = - std::find(filter_inst.begin(), filter_inst.end(), opcodePPC.name); + std::find(filter_inst.begin(), filter_inst.end(), opcode_risc.name); it == filter_inst.cend()) { - if (LibCompiler::find_word(line, opcodePPC.name)) + if (LibCompiler::find_word(line, opcode_risc.name)) { if (!isspace( - line[line.find(opcodePPC.name) + strlen(opcodePPC.name)])) + line[line.find(opcode_risc.name) + strlen(opcode_risc.name)])) { err_str += "\nMissing space between "; - err_str += opcodePPC.name; + err_str += opcode_risc.name; err_str += " and operands.\nhere -> "; err_str += line; } @@ -746,24 +746,24 @@ bool LibCompiler::EncoderPowerPC::WriteLine(std::string& line, const std::string& file) { if (LibCompiler::find_word(line, "public_segment")) - return true; + return false; if (!Details::algorithm::is_valid_power64(line)) - return true; + return false; - for (auto& opcodePPC : kOpcodesPowerPC) + for (auto& opcode_risc : kOpcodesPowerPC) { // strict check here - if (LibCompiler::find_word(line, opcodePPC.name)) + if (LibCompiler::find_word(line, opcode_risc.name)) { - std::string name(opcodePPC.name); + std::string name(opcode_risc.name); std::string jump_label, cpy_jump_label; std::vector found_registers_index; // check funct7 type. - switch (opcodePPC.ops->type) + switch (opcode_risc.ops->type) { default: { - NumberCast32 num(opcodePPC.opcode); + NumberCast32 num(opcode_risc.opcode); for (auto ch : num.number) { @@ -791,10 +791,10 @@ bool LibCompiler::EncoderPowerPC::WriteLine(std::string& line, // \brief how many registers we found. std::size_t found_some_count = 0UL; std::size_t register_count = 0UL; - std::string opcodeName = opcodePPC.name; + std::string opcodeName = opcode_risc.name; std::size_t register_sum = 0; - NumberCast64 num(opcodePPC.opcode); + NumberCast64 num(opcode_risc.opcode); for (size_t line_index = 0UL; line_index < line.size(); line_index++) @@ -1058,7 +1058,7 @@ bool LibCompiler::EncoderPowerPC::WriteLine(std::string& line, } // we're not in immediate addressing, reg to reg. - if (opcodePPC.ops->type != GREG) + if (opcode_risc.ops->type != GREG) { // remember! register to register! if (found_some_count == 1) diff --git a/dev/LibCompiler/src/AssemblyFactory.cc b/dev/LibCompiler/src/AssemblyFactory.cc index 1e6ac48..6a2918c 100644 --- a/dev/LibCompiler/src/AssemblyFactory.cc +++ b/dev/LibCompiler/src/AssemblyFactory.cc @@ -30,7 +30,7 @@ namespace LibCompiler const Int32& arch) noexcept { if (sourceFile.length() < 1 || !fMounted) - return TOOLCHAINKIT_UNIMPLEMENTED; + return LIBCOMPILER_UNIMPLEMENTED; return fMounted->CompileToFormat(sourceFile, arch); } diff --git a/dev/LibCompiler/src/CCompiler64x0.cc b/dev/LibCompiler/src/CCompiler64x0.cc index 8888a72..23bd11a 100644 --- a/dev/LibCompiler/src/CCompiler64x0.cc +++ b/dev/LibCompiler/src/CCompiler64x0.cc @@ -147,10 +147,10 @@ public: explicit CompilerFrontend64x0() = default; ~CompilerFrontend64x0() override = default; - TOOLCHAINKIT_COPY_DEFAULT(CompilerFrontend64x0); + LIBCOMPILER_COPY_DEFAULT(CompilerFrontend64x0); std::string Check(const char* text, const char* file); - bool Compile(const std::string text, const std::string file) override; + bool Compile(std::string text, const std::string file) override; const char* Language() override { @@ -200,9 +200,9 @@ namespace Details ///////////////////////////////////////////////////////////////////////////////////////// -bool CompilerFrontend64x0::Compile(const std::string text, const std::string file) +bool CompilerFrontend64x0::Compile(std::string text_, const std::string file) { - std::string textBuffer = text; + std::string text = text_; bool typeFound = false; bool fnFound = false; @@ -216,7 +216,7 @@ bool CompilerFrontend64x0::Compile(const std::string text, const std::string fil std::mt19937 generator(seq); // start parsing - for (size_t text_index = 0; text_index < textBuffer.size(); ++text_index) + for (size_t text_index = 0; text_index < text.size(); ++text_index) { auto syntaxLeaf = LibCompiler::SyntaxLeafList::SyntaxLeaf(); @@ -227,7 +227,7 @@ bool CompilerFrontend64x0::Compile(const std::string text, const std::string fil if (!typeFound) { - auto substr = textBuffer.substr(text_index); + auto substr = text.substr(text_index); std::string match_type; for (size_t y = 0; y < substr.size(); ++y) @@ -255,7 +255,7 @@ bool CompilerFrontend64x0::Compile(const std::string text, const std::string fil break; } - if (textBuffer.find('(') != std::string::npos) + if (text.find('(') != std::string::npos) { syntaxLeaf.fUserValue = buf; @@ -274,7 +274,7 @@ bool CompilerFrontend64x0::Compile(const std::string text, const std::string fil } } - if (textBuffer[text_index] == '{') + if (text[text_index] == '{') { if (kInStruct) { @@ -288,7 +288,7 @@ bool CompilerFrontend64x0::Compile(const std::string text, const std::string fil } // return keyword handler - if (textBuffer[text_index] == 'r') + if (text[text_index] == 'r') { std::string return_keyword; return_keyword += "return"; @@ -297,18 +297,18 @@ bool CompilerFrontend64x0::Compile(const std::string text, const std::string fil std::string value; - for (size_t return_index = text_index; return_index < textBuffer.size(); + for (size_t return_index = text_index; return_index < text.size(); ++return_index) { - if (textBuffer[return_index] != return_keyword[index]) + if (text[return_index] != return_keyword[index]) { for (size_t value_index = return_index; - value_index < textBuffer.size(); ++value_index) + value_index < text.size(); ++value_index) { - if (textBuffer[value_index] == ';') + if (text[value_index] == ';') break; - value += textBuffer[value_index]; + value += text[value_index]; } break; @@ -354,10 +354,10 @@ bool CompilerFrontend64x0::Compile(const std::string text, const std::string fil } } - if (textBuffer[text_index] == 'i' && textBuffer[text_index + 1] == 'f') + if (text[text_index] == 'i' && text[text_index + 1] == 'f') { - auto expr = textBuffer.substr(text_index + 2); - textBuffer.erase(text_index, 2); + auto expr = text.substr(text_index + 2); + text.erase(text_index, 2); if (expr.find("{") != std::string::npos) { @@ -370,7 +370,7 @@ bool CompilerFrontend64x0::Compile(const std::string text, const std::string fil if (expr.find(")") != std::string::npos) expr.erase(expr.find(")")); - kIfFunction = "__TOOLCHAINKIT_IF_PROC_"; + kIfFunction = "__LIBCOMPILER_IF_PROC_"; kIfFunction += std::to_string(time_off._Raw); syntaxLeaf.fUserValue = "\tlda r12, extern_segment "; @@ -387,32 +387,32 @@ bool CompilerFrontend64x0::Compile(const std::string text, const std::string fil // Parse expressions and instructions here. // what does this mean? // we encounter an assignment, or we reached the end of an expression. - if (textBuffer[text_index] == '=' || textBuffer[text_index] == ';') + if (text[text_index] == '=' || text[text_index] == ';') { if (fnFound) continue; if (kIfFound) continue; - if (textBuffer[text_index] == ';' && kInStruct) + if (text[text_index] == ';' && kInStruct) continue; - if (textBuffer.find("typedef ") != std::string::npos) + if (text.find("typedef ") != std::string::npos) continue; - if (textBuffer[text_index] == '=' && kInStruct) + if (text[text_index] == '=' && kInStruct) { - Details::print_error("assignement of value in struct " + textBuffer, + Details::print_error("assignement of value in struct " + text, file); continue; } - if (textBuffer[text_index] == ';' && kInStruct) + if (text[text_index] == ';' && kInStruct) { bool space_found_ = false; std::string sym; - for (auto& ch : textBuffer) + for (auto& ch : text) { if (ch == ' ') { @@ -437,26 +437,26 @@ bool CompilerFrontend64x0::Compile(const std::string text, const std::string fil continue; } - if (textBuffer[text_index] == '=' && kInStruct) + if (text[text_index] == '=' && kInStruct) { continue; } - if (textBuffer[text_index + 1] == '=' || - textBuffer[text_index - 1] == '!' || - textBuffer[text_index - 1] == '<' || - textBuffer[text_index - 1] == '>') + if (text[text_index + 1] == '=' || + text[text_index - 1] == '!' || + text[text_index - 1] == '<' || + text[text_index - 1] == '>') { continue; } std::string substr; - if (textBuffer.find('=') != std::string::npos && kInBraces && !kIfFound) + if (text.find('=') != std::string::npos && kInBraces && !kIfFound) { - if (textBuffer.find("*") != std::string::npos) + if (text.find("*") != std::string::npos) { - if (textBuffer.find("=") > textBuffer.find("*")) + if (text.find("=") > text.find("*")) substr += "\tlda "; else substr += "\tldw "; @@ -466,7 +466,7 @@ bool CompilerFrontend64x0::Compile(const std::string text, const std::string fil substr += "\tldw "; } } - else if (textBuffer.find('=') != std::string::npos && !kInBraces) + else if (text.find('=') != std::string::npos && !kInBraces) { substr += "stw public_segment .data64 "; } @@ -475,10 +475,10 @@ bool CompilerFrontend64x0::Compile(const std::string text, const std::string fil std::string str_name; - for (size_t text_index_2 = 0; text_index_2 < textBuffer.size(); + for (size_t text_index_2 = 0; text_index_2 < text.size(); ++text_index_2) { - if (textBuffer[text_index_2] == '\"') + if (text[text_index_2] == '\"') { ++text_index_2; @@ -486,29 +486,29 @@ bool CompilerFrontend64x0::Compile(const std::string text, const std::string fil // string. substr += '"'; - for (; text_index_2 < textBuffer.size(); ++text_index_2) + for (; text_index_2 < text.size(); ++text_index_2) { - if (textBuffer[text_index_2] == '\"') + if (text[text_index_2] == '\"') break; - substr += textBuffer[text_index_2]; + substr += text[text_index_2]; } } - if (textBuffer[text_index_2] == '{' || textBuffer[text_index_2] == '}') + if (text[text_index_2] == '{' || text[text_index_2] == '}') continue; - if (textBuffer[text_index_2] == ';') + if (text[text_index_2] == ';') { break; } - if (textBuffer[text_index_2] == ' ' || - textBuffer[text_index_2] == '\t') + if (text[text_index_2] == ' ' || + text[text_index_2] == '\t') { if (first_encountered != 2) { - if (textBuffer[text_index] != '=' && + if (text[text_index] != '=' && substr.find("public_segment .data64") == std::string::npos && !kInStruct) substr += "public_segment .data64 "; @@ -519,7 +519,7 @@ bool CompilerFrontend64x0::Compile(const std::string text, const std::string fil continue; } - if (textBuffer[text_index_2] == '=') + if (text[text_index_2] == '=') { if (!kInBraces) { @@ -531,7 +531,7 @@ bool CompilerFrontend64x0::Compile(const std::string text, const std::string fil continue; } - substr += textBuffer[text_index_2]; + substr += text[text_index_2]; } for (auto& clType : kCompilerTypes) @@ -586,13 +586,13 @@ bool CompilerFrontend64x0::Compile(const std::string text, const std::string fil syntaxLeaf.fUserValue += substr; kState.fSyntaxTree->fLeafList.push_back(syntaxLeaf); - if (textBuffer[text_index] == '=') + if (text[text_index] == '=') break; } // function handler. - if (textBuffer[text_index] == '(' && !fnFound && !kIfFound) + if (text[text_index] == '(' && !fnFound && !kIfFound) { std::string substr; std::string args_buffer; @@ -600,20 +600,20 @@ bool CompilerFrontend64x0::Compile(const std::string text, const std::string fil bool type_crossed = false; - for (size_t idx = textBuffer.find('(') + 1; idx < textBuffer.size(); + for (size_t idx = text.find('(') + 1; idx < text.size(); ++idx) { - if (textBuffer[idx] == ',') + if (text[idx] == ',') continue; - if (textBuffer[idx] == ' ') + if (text[idx] == ' ') continue; - if (textBuffer[idx] == ')') + if (text[idx] == ')') break; } - for (char substr_first_index : textBuffer) + for (char substr_first_index : text) { if (substr_first_index != ',') args_buffer += substr_first_index; @@ -649,7 +649,7 @@ bool CompilerFrontend64x0::Compile(const std::string text, const std::string fil } } - for (char _text_i : textBuffer) + for (char _text_i : text) { if (_text_i == '\t' || _text_i == ' ') { @@ -692,27 +692,27 @@ bool CompilerFrontend64x0::Compile(const std::string text, const std::string fil fnFound = true; } - kCompilerFunctions.push_back(textBuffer); + kCompilerFunctions.push_back(text); } - if (textBuffer[text_index] == '-' && textBuffer[text_index + 1] == '-') + if (text[text_index] == '-' && text[text_index + 1] == '-') { - textBuffer = textBuffer.replace(textBuffer.find("--"), strlen("--"), ""); + text = text.replace(text.find("--"), strlen("--"), ""); - for (int _text_i = 0; _text_i < textBuffer.size(); ++_text_i) + for (int _text_i = 0; _text_i < text.size(); ++_text_i) { - if (textBuffer[_text_i] == '\t' || textBuffer[_text_i] == ' ') - textBuffer.erase(_text_i, 1); + if (text[_text_i] == '\t' || text[_text_i] == ' ') + text.erase(_text_i, 1); } syntaxLeaf.fUserValue += "sub "; - syntaxLeaf.fUserValue += textBuffer; + syntaxLeaf.fUserValue += text; kState.fSyntaxTree->fLeafList.push_back(syntaxLeaf); break; } - if (textBuffer[text_index] == '}') + if (text[text_index] == '}') { kRegisterCounter = kStartUsable; @@ -1300,7 +1300,7 @@ public: explicit AssemblyCCInterface() = default; ~AssemblyCCInterface() override = default; - TOOLCHAINKIT_COPY_DEFAULT(AssemblyCCInterface); + LIBCOMPILER_COPY_DEFAULT(AssemblyCCInterface); [[maybe_unused]] static Int32 Arch() noexcept { @@ -1478,7 +1478,7 @@ public: ///////////////////////////////////////////////////////////////////////////////////////// -#include +#include #define kPrintF printf #define kSplashCxx() \ @@ -1493,7 +1493,7 @@ static void cc_print_help() #define kExt ".c" -TOOLCHAINKIT_MODULE(ZkaOSCompilerCLang64x0) +LIBCOMPILER_MODULE(ZkaOSCompilerCLang64x0) { kCompilerTypes.push_back({.fName = "void", .fValue = "void"}); kCompilerTypes.push_back({.fName = "char", .fValue = "byte"}); diff --git a/dev/LibCompiler/src/CCompilerARM64.cc b/dev/LibCompiler/src/CCompilerARM64.cc index d985b2e..476596d 100644 --- a/dev/LibCompiler/src/CCompilerARM64.cc +++ b/dev/LibCompiler/src/CCompilerARM64.cc @@ -147,10 +147,10 @@ public: explicit CompilerFrontendARM64() = default; ~CompilerFrontendARM64() override = default; - TOOLCHAINKIT_COPY_DEFAULT(CompilerFrontendARM64); + LIBCOMPILER_COPY_DEFAULT(CompilerFrontendARM64); std::string Check(const char* text, const char* file); - bool Compile(const std::string text, const std::string file) override; + bool Compile(std::string text, const std::string file) override; const char* Language() override { @@ -200,10 +200,8 @@ namespace Details ///////////////////////////////////////////////////////////////////////////////////////// -bool CompilerFrontendARM64::Compile(const std::string text, const std::string file) +bool CompilerFrontendARM64::Compile(std::string text, const std::string file) { - std::string textBuffer = text; - bool typeFound = false; bool fnFound = false; @@ -216,7 +214,7 @@ bool CompilerFrontendARM64::Compile(const std::string text, const std::string fi std::mt19937 generator(seq); // start parsing - for (size_t text_index = 0; text_index < textBuffer.size(); ++text_index) + for (size_t text_index = 0; text_index < text.size(); ++text_index) { auto syntaxLeaf = LibCompiler::SyntaxLeafList::SyntaxLeaf(); @@ -227,7 +225,7 @@ bool CompilerFrontendARM64::Compile(const std::string text, const std::string fi if (!typeFound) { - auto substr = textBuffer.substr(text_index); + auto substr = text.substr(text_index); std::string match_type; for (size_t y = 0; y < substr.size(); ++y) @@ -255,7 +253,7 @@ bool CompilerFrontendARM64::Compile(const std::string text, const std::string fi break; } - if (textBuffer.find('(') != std::string::npos) + if (text.find('(') != std::string::npos) { syntaxLeaf.fUserValue = buf; @@ -274,7 +272,7 @@ bool CompilerFrontendARM64::Compile(const std::string text, const std::string fi } } - if (textBuffer[text_index] == '{') + if (text[text_index] == '{') { if (kInStruct) { @@ -288,7 +286,7 @@ bool CompilerFrontendARM64::Compile(const std::string text, const std::string fi } // return keyword handler - if (textBuffer[text_index] == 'r') + if (text[text_index] == 'r') { std::string return_keyword; return_keyword += "return"; @@ -297,18 +295,18 @@ bool CompilerFrontendARM64::Compile(const std::string text, const std::string fi std::string value; - for (size_t return_index = text_index; return_index < textBuffer.size(); + for (size_t return_index = text_index; return_index < text.size(); ++return_index) { - if (textBuffer[return_index] != return_keyword[index]) + if (text[return_index] != return_keyword[index]) { for (size_t value_index = return_index; - value_index < textBuffer.size(); ++value_index) + value_index < text.size(); ++value_index) { - if (textBuffer[value_index] == ';') + if (text[value_index] == ';') break; - value += textBuffer[value_index]; + value += text[value_index]; } break; @@ -354,10 +352,10 @@ bool CompilerFrontendARM64::Compile(const std::string text, const std::string fi } } - if (textBuffer[text_index] == 'i' && textBuffer[text_index + 1] == 'f') + if (text[text_index] == 'i' && text[text_index + 1] == 'f') { - auto expr = textBuffer.substr(text_index + 2); - textBuffer.erase(text_index, 2); + auto expr = text.substr(text_index + 2); + text.erase(text_index, 2); if (expr.find("{") != std::string::npos) { @@ -370,7 +368,7 @@ bool CompilerFrontendARM64::Compile(const std::string text, const std::string fi if (expr.find(")") != std::string::npos) expr.erase(expr.find(")")); - kIfFunction = "__TOOLCHAINKIT_IF_PROC_"; + kIfFunction = "__LIBCOMPILER_IF_PROC_"; kIfFunction += std::to_string(time_off._Raw); syntaxLeaf.fUserValue = "\tlda r12, extern_segment "; @@ -387,32 +385,32 @@ bool CompilerFrontendARM64::Compile(const std::string text, const std::string fi // Parse expressions and instructions here. // what does this mean? // we encounter an assignment, or we reached the end of an expression. - if (textBuffer[text_index] == '=' || textBuffer[text_index] == ';') + if (text[text_index] == '=' || text[text_index] == ';') { if (fnFound) continue; if (kIfFound) continue; - if (textBuffer[text_index] == ';' && kInStruct) + if (text[text_index] == ';' && kInStruct) continue; - if (textBuffer.find("typedef ") != std::string::npos) + if (text.find("typedef ") != std::string::npos) continue; - if (textBuffer[text_index] == '=' && kInStruct) + if (text[text_index] == '=' && kInStruct) { - Details::print_error("assignement of value in struct " + textBuffer, + Details::print_error("assignement of value in struct " + text, file); continue; } - if (textBuffer[text_index] == ';' && kInStruct) + if (text[text_index] == ';' && kInStruct) { bool space_found_ = false; std::string sym; - for (auto& ch : textBuffer) + for (auto& ch : text) { if (ch == ' ') { @@ -437,26 +435,26 @@ bool CompilerFrontendARM64::Compile(const std::string text, const std::string fi continue; } - if (textBuffer[text_index] == '=' && kInStruct) + if (text[text_index] == '=' && kInStruct) { continue; } - if (textBuffer[text_index + 1] == '=' || - textBuffer[text_index - 1] == '!' || - textBuffer[text_index - 1] == '<' || - textBuffer[text_index - 1] == '>') + if (text[text_index + 1] == '=' || + text[text_index - 1] == '!' || + text[text_index - 1] == '<' || + text[text_index - 1] == '>') { continue; } std::string substr; - if (textBuffer.find('=') != std::string::npos && kInBraces && !kIfFound) + if (text.find('=') != std::string::npos && kInBraces && !kIfFound) { - if (textBuffer.find("*") != std::string::npos) + if (text.find("*") != std::string::npos) { - if (textBuffer.find("=") > textBuffer.find("*")) + if (text.find("=") > text.find("*")) substr += "\tlda "; else substr += "\tldw "; @@ -466,7 +464,7 @@ bool CompilerFrontendARM64::Compile(const std::string text, const std::string fi substr += "\tldw "; } } - else if (textBuffer.find('=') != std::string::npos && !kInBraces) + else if (text.find('=') != std::string::npos && !kInBraces) { substr += "stw public_segment .data64 "; } @@ -475,10 +473,10 @@ bool CompilerFrontendARM64::Compile(const std::string text, const std::string fi std::string str_name; - for (size_t text_index_2 = 0; text_index_2 < textBuffer.size(); + for (size_t text_index_2 = 0; text_index_2 < text.size(); ++text_index_2) { - if (textBuffer[text_index_2] == '\"') + if (text[text_index_2] == '\"') { ++text_index_2; @@ -486,29 +484,29 @@ bool CompilerFrontendARM64::Compile(const std::string text, const std::string fi // string. substr += '"'; - for (; text_index_2 < textBuffer.size(); ++text_index_2) + for (; text_index_2 < text.size(); ++text_index_2) { - if (textBuffer[text_index_2] == '\"') + if (text[text_index_2] == '\"') break; - substr += textBuffer[text_index_2]; + substr += text[text_index_2]; } } - if (textBuffer[text_index_2] == '{' || textBuffer[text_index_2] == '}') + if (text[text_index_2] == '{' || text[text_index_2] == '}') continue; - if (textBuffer[text_index_2] == ';') + if (text[text_index_2] == ';') { break; } - if (textBuffer[text_index_2] == ' ' || - textBuffer[text_index_2] == '\t') + if (text[text_index_2] == ' ' || + text[text_index_2] == '\t') { if (first_encountered != 2) { - if (textBuffer[text_index] != '=' && + if (text[text_index] != '=' && substr.find("public_segment .data64") == std::string::npos && !kInStruct) substr += "public_segment .data64 "; @@ -519,7 +517,7 @@ bool CompilerFrontendARM64::Compile(const std::string text, const std::string fi continue; } - if (textBuffer[text_index_2] == '=') + if (text[text_index_2] == '=') { if (!kInBraces) { @@ -531,7 +529,7 @@ bool CompilerFrontendARM64::Compile(const std::string text, const std::string fi continue; } - substr += textBuffer[text_index_2]; + substr += text[text_index_2]; } for (auto& clType : kCompilerTypes) @@ -586,13 +584,13 @@ bool CompilerFrontendARM64::Compile(const std::string text, const std::string fi syntaxLeaf.fUserValue += substr; kState.fSyntaxTree->fLeafList.push_back(syntaxLeaf); - if (textBuffer[text_index] == '=') + if (text[text_index] == '=') break; } // function handler. - if (textBuffer[text_index] == '(' && !fnFound && !kIfFound) + if (text[text_index] == '(' && !fnFound && !kIfFound) { std::string substr; std::string args_buffer; @@ -600,20 +598,20 @@ bool CompilerFrontendARM64::Compile(const std::string text, const std::string fi bool type_crossed = false; - for (size_t idx = textBuffer.find('(') + 1; idx < textBuffer.size(); + for (size_t idx = text.find('(') + 1; idx < text.size(); ++idx) { - if (textBuffer[idx] == ',') + if (text[idx] == ',') continue; - if (textBuffer[idx] == ' ') + if (text[idx] == ' ') continue; - if (textBuffer[idx] == ')') + if (text[idx] == ')') break; } - for (char substr_first_index : textBuffer) + for (char substr_first_index : text) { if (substr_first_index != ',') args_buffer += substr_first_index; @@ -649,7 +647,7 @@ bool CompilerFrontendARM64::Compile(const std::string text, const std::string fi } } - for (char _text_i : textBuffer) + for (char _text_i : text) { if (_text_i == '\t' || _text_i == ' ') { @@ -692,27 +690,27 @@ bool CompilerFrontendARM64::Compile(const std::string text, const std::string fi fnFound = true; } - kCompilerFunctions.push_back(textBuffer); + kCompilerFunctions.push_back(text); } - if (textBuffer[text_index] == '-' && textBuffer[text_index + 1] == '-') + if (text[text_index] == '-' && text[text_index + 1] == '-') { - textBuffer = textBuffer.replace(textBuffer.find("--"), strlen("--"), ""); + text = text.replace(text.find("--"), strlen("--"), ""); - for (int _text_i = 0; _text_i < textBuffer.size(); ++_text_i) + for (int _text_i = 0; _text_i < text.size(); ++_text_i) { - if (textBuffer[_text_i] == '\t' || textBuffer[_text_i] == ' ') - textBuffer.erase(_text_i, 1); + if (text[_text_i] == '\t' || text[_text_i] == ' ') + text.erase(_text_i, 1); } syntaxLeaf.fUserValue += "sub "; - syntaxLeaf.fUserValue += textBuffer; + syntaxLeaf.fUserValue += text; kState.fSyntaxTree->fLeafList.push_back(syntaxLeaf); break; } - if (textBuffer[text_index] == '}') + if (text[text_index] == '}') { kRegisterCounter = kStartUsable; @@ -1300,11 +1298,11 @@ public: explicit AssemblyCCInterface() = default; ~AssemblyCCInterface() override = default; - TOOLCHAINKIT_COPY_DEFAULT(AssemblyCCInterface); + LIBCOMPILER_COPY_DEFAULT(AssemblyCCInterface); [[maybe_unused]] static Int32 Arch() noexcept { - return LibCompiler::AssemblyFactory::kArchARM64; + return LibCompiler::AssemblyFactory::kArchAARCH64; } Int32 CompileToFormat(std::string& src, Int32 arch) override @@ -1478,7 +1476,7 @@ public: ///////////////////////////////////////////////////////////////////////////////////////// -#include +#include #define kPrintF printf #define kSplashCxx() \ @@ -1493,7 +1491,7 @@ static void cc_print_help() #define kCExtension ".c" -TOOLCHAINKIT_MODULE(ZkaOSCompilerCLangARM64) +LIBCOMPILER_MODULE(ZkaOSCompilerCLangARM64) { kCompilerTypes.push_back({.fName = "void", .fValue = "void"}); kCompilerTypes.push_back({.fName = "char", .fValue = "byte"}); @@ -1505,7 +1503,7 @@ TOOLCHAINKIT_MODULE(ZkaOSCompilerCLangARM64) bool skip = false; kFactory.Mount(new AssemblyCCInterface()); - kMachine = LibCompiler::AssemblyFactory::kArchARM64; + kMachine = LibCompiler::AssemblyFactory::kArchAARCH64; kCompilerFrontend = new CompilerFrontendARM64(); for (auto index = 1UL; index < argc; ++index) diff --git a/dev/LibCompiler/src/CCompilerPower64.cc b/dev/LibCompiler/src/CCompilerPower64.cc index 328c429..4338c68 100644 --- a/dev/LibCompiler/src/CCompilerPower64.cc +++ b/dev/LibCompiler/src/CCompilerPower64.cc @@ -70,20 +70,20 @@ namespace Details struct CompilerState final { std::vector fSyntaxTreeList; - std::vector kStackFrame; - std::vector kStructMap; + std::vector kStackFrame; + std::vector kStructMap; LibCompiler::SyntaxLeafList* fSyntaxTree{nullptr}; - std::unique_ptr fOutputAssembly; - std::string fLastFile; - std::string fLastError; - bool fVerbose; + std::unique_ptr fOutputAssembly; + std::string fLastFile; + std::string fLastError; + bool fVerbose; }; } // namespace Details static Details::CompilerState kState; -static SizeType kErrorLimit = 100; -static std::string kIfFunction = ""; -static Int32 kAcceptableErrors = 0; +static SizeType kErrorLimit = 100; +static std::string kIfFunction = ""; +static Int32 kAcceptableErrors = 0; namespace Details { @@ -122,14 +122,14 @@ static std::string kRegisterPrefix = kAsmRegisterPrefix; ///////////////////////////////////////// -static std::vector kFileList; -static LibCompiler::AssemblyFactory kFactory; -static bool kInStruct = false; -static bool kOnWhileLoop = false; -static bool kOnForLoop = false; -static bool kInBraces = false; -static bool kIfFound = false; -static size_t kBracesCount = 0UL; +static std::vector kFileList; +static LibCompiler::AssemblyFactory kFactory; +static bool kInStruct = false; +static bool kOnWhileLoop = false; +static bool kOnForLoop = false; +static bool kInBraces = false; +static bool kIfFound = false; +static size_t kBracesCount = 0UL; /* @brief C compiler backend for C */ class CompilerFrontendPower64 final : public LibCompiler::ICompilerFrontend @@ -138,10 +138,10 @@ public: explicit CompilerFrontendPower64() = default; ~CompilerFrontendPower64() override = default; - TOOLCHAINKIT_COPY_DEFAULT(CompilerFrontendPower64); + LIBCOMPILER_COPY_DEFAULT(CompilerFrontendPower64); std::string Check(const char* text, const char* file); - bool Compile(const std::string text, const std::string file) override; + bool Compile(std::string text, const std::string file) override; const char* Language() override { @@ -149,9 +149,9 @@ public: } }; -static CompilerFrontendPower64* kCompilerFrontend = nullptr; +static CompilerFrontendPower64* kCompilerFrontend = nullptr; static std::vector kCompilerVariables; -static std::vector kCompilerFunctions; +static std::vector kCompilerFunctions; static std::vector kCompilerTypes; namespace Details @@ -191,9 +191,9 @@ namespace Details ///////////////////////////////////////////////////////////////////////////////////////// -bool CompilerFrontendPower64::Compile(const std::string text, const std::string file) +bool CompilerFrontendPower64::Compile(std::string text_, const std::string file) { - std::string textBuffer = text; + std::string text = text_; bool typeFound = false; bool fnFound = false; @@ -207,7 +207,7 @@ bool CompilerFrontendPower64::Compile(const std::string text, const std::string std::mt19937 generator(seq); // start parsing - for (size_t text_index = 0; text_index < textBuffer.size(); ++text_index) + for (size_t text_index = 0; text_index < text.size(); ++text_index) { auto syntaxLeaf = LibCompiler::SyntaxLeafList::SyntaxLeaf(); @@ -218,7 +218,7 @@ bool CompilerFrontendPower64::Compile(const std::string text, const std::string if (!typeFound) { - auto substr = textBuffer.substr(text_index); + auto substr = text.substr(text_index); std::string match_type; for (size_t y = 0; y < substr.size(); ++y) @@ -246,7 +246,7 @@ bool CompilerFrontendPower64::Compile(const std::string text, const std::string break; } - if (textBuffer.find('(') != std::string::npos) + if (text.find('(') != std::string::npos) { syntaxLeaf.fUserValue = buf; @@ -265,7 +265,7 @@ bool CompilerFrontendPower64::Compile(const std::string text, const std::string } } - if (textBuffer[text_index] == '{') + if (text[text_index] == '{') { if (kInStruct) { @@ -279,7 +279,7 @@ bool CompilerFrontendPower64::Compile(const std::string text, const std::string } // return keyword handler - if (textBuffer[text_index] == 'r') + if (text[text_index] == 'r') { std::string return_keyword; return_keyword += "return"; @@ -288,18 +288,18 @@ bool CompilerFrontendPower64::Compile(const std::string text, const std::string std::string value; - for (size_t return_index = text_index; return_index < textBuffer.size(); + for (size_t return_index = text_index; return_index < text.size(); ++return_index) { - if (textBuffer[return_index] != return_keyword[index]) + if (text[return_index] != return_keyword[index]) { for (size_t value_index = return_index; - value_index < textBuffer.size(); ++value_index) + value_index < text.size(); ++value_index) { - if (textBuffer[value_index] == ';') + if (text[value_index] == ';') break; - value += textBuffer[value_index]; + value += text[value_index]; } break; @@ -364,10 +364,10 @@ bool CompilerFrontendPower64::Compile(const std::string text, const std::string } } - if (textBuffer[text_index] == 'i' && textBuffer[text_index + 1] == 'f') + if (text[text_index] == 'i' && text[text_index + 1] == 'f') { - auto expr = textBuffer.substr(text_index + 2); - textBuffer.erase(text_index, 2); + auto expr = text.substr(text_index + 2); + text.erase(text_index, 2); if (expr.find("{") != std::string::npos) { @@ -380,7 +380,7 @@ bool CompilerFrontendPower64::Compile(const std::string text, const std::string if (expr.find(")") != std::string::npos) expr.erase(expr.find(")")); - kIfFunction = "__TOOLCHAINKIT_IF_PROC_"; + kIfFunction = "__LIBCOMPILER_IF_PROC_"; kIfFunction += std::to_string(time_off._Raw); syntaxLeaf.fUserValue = @@ -398,32 +398,32 @@ bool CompilerFrontendPower64::Compile(const std::string text, const std::string // Parse expressions and instructions here. // what does this mean? // we encounter an assignment, or we reached the end of an expression. - if (textBuffer[text_index] == '=' || textBuffer[text_index] == ';') + if (text[text_index] == '=' || text[text_index] == ';') { if (fnFound) continue; if (kIfFound) continue; - if (textBuffer[text_index] == ';' && kInStruct) + if (text[text_index] == ';' && kInStruct) continue; - if (textBuffer.find("typedef ") != std::string::npos) + if (text.find("typedef ") != std::string::npos) continue; - if (textBuffer[text_index] == '=' && kInStruct) + if (text[text_index] == '=' && kInStruct) { Details::print_error( - "assignement of value inside a struct " + textBuffer, file); + "assignement of value inside a struct " + text, file); continue; } - if (textBuffer[text_index] == ';' && kInStruct) + if (text[text_index] == ';' && kInStruct) { bool space_found_ = false; std::string sym; - for (auto& ch : textBuffer) + for (auto& ch : text) { if (ch == ' ') { @@ -448,26 +448,26 @@ bool CompilerFrontendPower64::Compile(const std::string text, const std::string continue; } - if (textBuffer[text_index] == '=' && kInStruct) + if (text[text_index] == '=' && kInStruct) { continue; } - if (textBuffer[text_index + 1] == '=' || - textBuffer[text_index - 1] == '!' || - textBuffer[text_index - 1] == '<' || - textBuffer[text_index - 1] == '>') + if (text[text_index + 1] == '=' || + text[text_index - 1] == '!' || + text[text_index - 1] == '<' || + text[text_index - 1] == '>') { continue; } std::string substr; - if (textBuffer.find('=') != std::string::npos && kInBraces && !kIfFound) + if (text.find('=') != std::string::npos && kInBraces && !kIfFound) { - if (textBuffer.find("*") != std::string::npos) + if (text.find("*") != std::string::npos) { - if (textBuffer.find("=") > textBuffer.find("*")) + if (text.find("=") > text.find("*")) substr += "\tli "; else substr += "\tli "; @@ -477,7 +477,7 @@ bool CompilerFrontendPower64::Compile(const std::string text, const std::string substr += "\tli "; } } - else if (textBuffer.find('=') != std::string::npos && !kInBraces) + else if (text.find('=') != std::string::npos && !kInBraces) { substr += "stw public_segment .data64 "; } @@ -486,10 +486,10 @@ bool CompilerFrontendPower64::Compile(const std::string text, const std::string std::string str_name; - for (size_t text_index_2 = 0; text_index_2 < textBuffer.size(); + for (size_t text_index_2 = 0; text_index_2 < text.size(); ++text_index_2) { - if (textBuffer[text_index_2] == '\"') + if (text[text_index_2] == '\"') { ++text_index_2; @@ -497,29 +497,29 @@ bool CompilerFrontendPower64::Compile(const std::string text, const std::string // string. substr += '"'; - for (; text_index_2 < textBuffer.size(); ++text_index_2) + for (; text_index_2 < text.size(); ++text_index_2) { - if (textBuffer[text_index_2] == '\"') + if (text[text_index_2] == '\"') break; - substr += textBuffer[text_index_2]; + substr += text[text_index_2]; } } - if (textBuffer[text_index_2] == '{' || textBuffer[text_index_2] == '}') + if (text[text_index_2] == '{' || text[text_index_2] == '}') continue; - if (textBuffer[text_index_2] == ';') + if (text[text_index_2] == ';') { break; } - if (textBuffer[text_index_2] == ' ' || - textBuffer[text_index_2] == '\t') + if (text[text_index_2] == ' ' || + text[text_index_2] == '\t') { if (first_encountered != 2) { - if (textBuffer[text_index] != '=' && + if (text[text_index] != '=' && substr.find("public_segment .data64") == std::string::npos && !kInStruct) substr += "public_segment .data64 "; @@ -530,7 +530,7 @@ bool CompilerFrontendPower64::Compile(const std::string text, const std::string continue; } - if (textBuffer[text_index_2] == '=') + if (text[text_index_2] == '=') { if (!kInBraces) { @@ -542,7 +542,7 @@ bool CompilerFrontendPower64::Compile(const std::string text, const std::string continue; } - substr += textBuffer[text_index_2]; + substr += text[text_index_2]; } for (auto& clType : kCompilerTypes) @@ -582,7 +582,7 @@ bool CompilerFrontendPower64::Compile(const std::string text, const std::string kCompilerVariables.push_back({.fName = substr}); - if (textBuffer[text_index] == ';') + if (text[text_index] == ';') break; std::string reg = kAsmRegisterPrefix; @@ -614,7 +614,7 @@ bool CompilerFrontendPower64::Compile(const std::string text, const std::string // function handler. - if (textBuffer[text_index] == '(' && !fnFound && !kIfFound) + if (text[text_index] == '(' && !fnFound && !kIfFound) { std::string substr; std::string args_buffer; @@ -622,20 +622,20 @@ bool CompilerFrontendPower64::Compile(const std::string text, const std::string bool type_crossed = false; - for (size_t idx = textBuffer.find('(') + 1; idx < textBuffer.size(); + for (size_t idx = text.find('(') + 1; idx < text.size(); ++idx) { - if (textBuffer[idx] == ',') + if (text[idx] == ',') continue; - if (textBuffer[idx] == ' ') + if (text[idx] == ' ') continue; - if (textBuffer[idx] == ')') + if (text[idx] == ')') break; } - for (char substr_first_index : textBuffer) + for (char substr_first_index : text) { if (substr_first_index != ',') args_buffer += substr_first_index; @@ -671,7 +671,7 @@ bool CompilerFrontendPower64::Compile(const std::string text, const std::string } } - for (char _text_i : textBuffer) + for (char _text_i : text) { if (_text_i == '\t' || _text_i == ' ') { @@ -715,27 +715,27 @@ bool CompilerFrontendPower64::Compile(const std::string text, const std::string fnFound = true; } - kCompilerFunctions.push_back(textBuffer); + kCompilerFunctions.push_back(text); } - if (textBuffer[text_index] == '-' && textBuffer[text_index + 1] == '-') + if (text[text_index] == '-' && text[text_index + 1] == '-') { - textBuffer = textBuffer.replace(textBuffer.find("--"), strlen("--"), ""); + text = text.replace(text.find("--"), strlen("--"), ""); - for (int _text_i = 0; _text_i < textBuffer.size(); ++_text_i) + for (int _text_i = 0; _text_i < text.size(); ++_text_i) { - if (textBuffer[_text_i] == '\t' || textBuffer[_text_i] == ' ') - textBuffer.erase(_text_i, 1); + if (text[_text_i] == '\t' || text[_text_i] == ' ') + text.erase(_text_i, 1); } syntaxLeaf.fUserValue += "dec "; - syntaxLeaf.fUserValue += textBuffer; + syntaxLeaf.fUserValue += text; kState.fSyntaxTree->fLeafList.push_back(syntaxLeaf); break; } - if (textBuffer[text_index] == '}') + if (text[text_index] == '}') { kRegisterCounter = kStartUsable; @@ -1323,7 +1323,7 @@ public: explicit AssemblyMountpointCLang() = default; ~AssemblyMountpointCLang() override = default; - TOOLCHAINKIT_COPY_DEFAULT(AssemblyMountpointCLang); + LIBCOMPILER_COPY_DEFAULT(AssemblyMountpointCLang); [[maybe_unused]] static Int32 Arch() noexcept { @@ -1498,7 +1498,7 @@ public: ///////////////////////////////////////////////////////////////////////////////////////// -#include +#include #define kPrintF printf #define kSplashCxx() \ @@ -1513,7 +1513,7 @@ static void cc_print_help() #define kExt ".c" -TOOLCHAINKIT_MODULE(ZkaOSCompilerCLangPowerPC) +LIBCOMPILER_MODULE(ZkaOSCompilerCLangPowerPC) { kCompilerTypes.push_back({.fName = "void", .fValue = "void"}); kCompilerTypes.push_back({.fName = "char", .fValue = "byte"}); diff --git a/dev/LibCompiler/src/CPlusPlusCompilerAMD64.cc b/dev/LibCompiler/src/CPlusPlusCompilerAMD64.cc index ba805bd..e2b66f2 100644 --- a/dev/LibCompiler/src/CPlusPlusCompilerAMD64.cc +++ b/dev/LibCompiler/src/CPlusPlusCompilerAMD64.cc @@ -9,7 +9,6 @@ /// BUGS: 1 -#include #define kPrintF printf #define kExitOK (EXIT_SUCCESS) @@ -24,6 +23,8 @@ #include #include +#include + /* ZKA C++ Compiler */ /* This is part of the LibCompiler. */ /* (c) Theater Quality Corp. */ @@ -162,7 +163,7 @@ public: explicit CompilerFrontendCPlusPlus() = default; ~CompilerFrontendCPlusPlus() override = default; - TOOLCHAINKIT_COPY_DEFAULT(CompilerFrontendCPlusPlus); + LIBCOMPILER_COPY_DEFAULT(CompilerFrontendCPlusPlus); bool Compile(const std::string text, const std::string file) override; @@ -431,13 +432,13 @@ bool CompilerFrontendCPlusPlus::Compile(const std::string text, ++indexFnName; } - syntax_tree.fUserValue = "public_segment .code64 __TOOLCHAINKIT_" + fnName + "\n"; + syntax_tree.fUserValue = "public_segment .code64 __LIBCOMPILER_" + fnName + "\n"; ++kFunctionEmbedLevel; break; tk_write_assembly: - syntax_tree.fUserValue = "jmp __TOOLCHAINKIT_" + fnName + "\n"; + syntax_tree.fUserValue = "jmp __LIBCOMPILER_" + fnName + "\n"; } case LibCompiler::KeywordKind::kKeywordKindFunctionEnd: { if (text.ends_with(";")) @@ -572,8 +573,8 @@ tk_write_assembly: if (valueOfVar[0] == '\"') { - syntax_tree.fUserValue = "segment .data64 __TOOLCHAINKIT_LOCAL_VAR_" + varName + ": db " + valueOfVar + ", 0\n\n"; - syntax_tree.fUserValue += instr + kRegisterList[kRegisterMap.size() - 1] + ", " + "__TOOLCHAINKIT_LOCAL_VAR_" + varName + "\n"; + syntax_tree.fUserValue = "segment .data64 __LIBCOMPILER_LOCAL_VAR_" + varName + ": db " + valueOfVar + ", 0\n\n"; + syntax_tree.fUserValue += instr + kRegisterList[kRegisterMap.size() - 1] + ", " + "__LIBCOMPILER_LOCAL_VAR_" + varName + "\n"; } else { @@ -589,8 +590,8 @@ tk_write_assembly: if (valueOfVar[0] == '\"') { - syntax_tree.fUserValue = "segment .data64 __TOOLCHAINKIT_LOCAL_VAR_" + varName + ": db " + valueOfVar + ", 0\n"; - syntax_tree.fUserValue += instr + kRegisterList[kRegisterMap.size()] + ", " + "__TOOLCHAINKIT_LOCAL_VAR_" + varName + "\n"; + syntax_tree.fUserValue = "segment .data64 __LIBCOMPILER_LOCAL_VAR_" + varName + ": db " + valueOfVar + ", 0\n"; + syntax_tree.fUserValue += instr + kRegisterList[kRegisterMap.size()] + ", " + "__LIBCOMPILER_LOCAL_VAR_" + varName + "\n"; } else { @@ -767,7 +768,7 @@ tk_write_assembly: } else { - syntax_tree.fUserValue = "__TOOLCHAINKIT_LOCAL_RETURN_STRING: db " + subText + ", 0\nmov rcx, __TOOLCHAINKIT_LOCAL_RETURN_STRING\n"; + syntax_tree.fUserValue = "__LIBCOMPILER_LOCAL_RETURN_STRING: db " + subText + ", 0\nmov rcx, __LIBCOMPILER_LOCAL_RETURN_STRING\n"; syntax_tree.fUserValue += "mov rax, rcx\r\nret\n"; } @@ -806,7 +807,7 @@ public: explicit AssemblyCPlusPlusInterface() = default; ~AssemblyCPlusPlusInterface() override = default; - TOOLCHAINKIT_COPY_DEFAULT(AssemblyCPlusPlusInterface); + LIBCOMPILER_COPY_DEFAULT(AssemblyCPlusPlusInterface); [[maybe_unused]] static Int32 Arch() noexcept { @@ -924,7 +925,7 @@ static void cxx_print_help() ".cpp", ".cxx", ".cc", ".c++", ".cp" \ } -TOOLCHAINKIT_MODULE(CompilerCPlusPlusX8664) +LIBCOMPILER_MODULE(CompilerCPlusPlusX8664) { bool skip = false; diff --git a/dev/LibCompiler/src/CPlusPlusCompilerPreProcessor.cc b/dev/LibCompiler/src/CPlusPlusCompilerPreProcessor.cc index 906ba4e..90db68b 100644 --- a/dev/LibCompiler/src/CPlusPlusCompilerPreProcessor.cc +++ b/dev/LibCompiler/src/CPlusPlusCompilerPreProcessor.cc @@ -74,7 +74,7 @@ namespace Details explicit bpp_pragma() = default; ~bpp_pragma() = default; - TOOLCHAINKIT_COPY_DEFAULT(bpp_pragma); + LIBCOMPILER_COPY_DEFAULT(bpp_pragma); std::string fMacroName; bpp_parser_fn_t fParse; @@ -908,7 +908,7 @@ void bpp_parse_file(std::ifstream& hdr_file, std::ofstream& pp_out) ///////////////////////////////////////////////////////////////////////////////////////// -TOOLCHAINKIT_MODULE(CPlusPlusPreprocessorMain) +LIBCOMPILER_MODULE(CPlusPlusPreprocessorMain) { try { @@ -931,7 +931,7 @@ TOOLCHAINKIT_MODULE(CPlusPlusPreprocessorMain) Details::bpp_macro macro_zka; - macro_zka.fName = "__TOOLCHAINKIT__"; + macro_zka.fName = "__LIBCOMPILER__"; macro_zka.fValue = "1"; kMacros.push_back(macro_zka); @@ -1044,7 +1044,7 @@ TOOLCHAINKIT_MODULE(CPlusPlusPreprocessorMain) } if (kFiles.empty()) - return TOOLCHAINKIT_EXEC_ERROR; + return LIBCOMPILER_EXEC_ERROR; for (auto& file : kFiles) { diff --git a/dev/LibCompiler/src/CPlusPlusLinkerELF.cc b/dev/LibCompiler/src/CPlusPlusLinkerELF.cc index 5b85afc..de7cbd1 100644 --- a/dev/LibCompiler/src/CPlusPlusLinkerELF.cc +++ b/dev/LibCompiler/src/CPlusPlusLinkerELF.cc @@ -55,8 +55,8 @@ namespace Details { struct DynamicLinkerBlob final { - std::vector fPefBlob; // PEF code/bss/data blob. - std::uintptr_t fAEOffset; // the offset of the PEF container header.. + std::vector mBlob; // PEF code/bss/data blob. + std::uintptr_t mObjOffset; // the offset of the PEF container header.. }; } @@ -84,7 +84,7 @@ static uintptr_t kByteCount = 1024; /// @brief ZKA 64-bit Linker. /// @note This linker is made for XCOFF executable, thus ZKA based OSes. -TOOLCHAINKIT_MODULE(DynamicLinker64XCOFF) +LIBCOMPILER_MODULE(DynamicLinker64XCOFF) { return EXIT_SUCCESS; } diff --git a/dev/LibCompiler/src/CPlusPlusLinkerPEF.cc b/dev/LibCompiler/src/CPlusPlusLinkerPEF.cc index 2e5e40b..a7abc92 100644 --- a/dev/LibCompiler/src/CPlusPlusLinkerPEF.cc +++ b/dev/LibCompiler/src/CPlusPlusLinkerPEF.cc @@ -55,8 +55,8 @@ namespace Details { struct DynamicLinkerBlob final { - std::vector fPefBlob; // PEF code/bss/data blob. - std::uintptr_t fAEOffset; // the offset of the PEF container header.. + std::vector mBlob; // PEF code/bss/data blob. + std::uintptr_t mObjOffset; // the offset of the PEF container header.. }; } @@ -92,7 +92,7 @@ static uintptr_t kByteCount = 1024; /// @brief ZKA 64-bit Linker. /// @note This linker is made for PEF executable, thus ZKA based OSes. -TOOLCHAINKIT_MODULE(DynamicLinker64PEF) +LIBCOMPILER_MODULE(DynamicLinker64PEF) { bool is_executable = true; @@ -213,14 +213,14 @@ TOOLCHAINKIT_MODULE(DynamicLinker64PEF) if (kOutput.empty()) { kStdOut << "no output filename set." << std::endl; - return TOOLCHAINKIT_EXEC_ERROR; + return LIBCOMPILER_EXEC_ERROR; } // sanity check. if (kObjectList.empty()) { kStdOut << "no input files." << std::endl; - return TOOLCHAINKIT_EXEC_ERROR; + return LIBCOMPILER_EXEC_ERROR; } else { @@ -234,7 +234,7 @@ TOOLCHAINKIT_MODULE(DynamicLinker64PEF) // if filesystem doesn't find file // -> throw error. kStdOut << "no such file: " << obj << std::endl; - return TOOLCHAINKIT_EXEC_ERROR; + return LIBCOMPILER_EXEC_ERROR; } } } @@ -243,7 +243,7 @@ TOOLCHAINKIT_MODULE(DynamicLinker64PEF) if (kArch == 0) { kStdOut << "no target architecture set, can't continue." << std::endl; - return TOOLCHAINKIT_EXEC_ERROR; + return LIBCOMPILER_EXEC_ERROR; } LibCompiler::PEFContainer pef_container{}; @@ -274,7 +274,7 @@ TOOLCHAINKIT_MODULE(DynamicLinker64PEF) kStdOut << "error: " << strerror(errno) << "\n"; } - return TOOLCHAINKIT_FILE_NOT_FOUND; + return LIBCOMPILER_FILE_NOT_FOUND; } //! Read AE to convert as PEF. @@ -312,7 +312,7 @@ TOOLCHAINKIT_MODULE(DynamicLinker64PEF) "treated as a FAT binary." << std::endl; - return TOOLCHAINKIT_FAT_ERROR; + return LIBCOMPILER_FAT_ERROR; } else { @@ -412,7 +412,7 @@ TOOLCHAINKIT_MODULE(DynamicLinker64PEF) for (auto& byte : bytes) { - kObjectBytes.push_back({ .fPefBlob = bytes, .fAEOffset = ae_header.fStartCode }); + kObjectBytes.push_back({ .mBlob = bytes, .mObjOffset = ae_header.fStartCode }); } reader_protocol.FP.close(); @@ -422,7 +422,7 @@ TOOLCHAINKIT_MODULE(DynamicLinker64PEF) kStdOut << "Not an object container: " << objectFile << std::endl; // don't continue, it is a fatal error. - return TOOLCHAINKIT_EXEC_ERROR; + return LIBCOMPILER_EXEC_ERROR; } pef_container.Cpu = archs; @@ -723,14 +723,14 @@ TOOLCHAINKIT_MODULE(DynamicLinker64PEF) kStdOut << "Multiple symbols of " << symbol << ".\n"; } - return TOOLCHAINKIT_EXEC_ERROR; + return LIBCOMPILER_EXEC_ERROR; } // step 2.5: write program bytes. for (auto& struct_of_blob : kObjectBytes) { - output_fc.write(struct_of_blob.fPefBlob.data(), struct_of_blob.fPefBlob.size()); + output_fc.write(struct_of_blob.mBlob.data(), struct_of_blob.mBlob.size()); } if (kVerbose) @@ -765,7 +765,7 @@ TOOLCHAINKIT_MODULE(DynamicLinker64PEF) kStdOut << "file: " << kOutput << ", is corrupt, removing file...\n"; - return TOOLCHAINKIT_EXEC_ERROR; + return LIBCOMPILER_EXEC_ERROR; } return EXIT_SUCCESS; -- cgit v1.2.3