refactor: moving bytecode related magic constants to Compiler/Common.hpp

Author: SuperFola

include/Ark/Compiler/Common.hpp

@@ -16,6 +16,7 @@
 #include <string_view>
 #include <vector>
 #include <cinttypes>
+#include <Ark/Constants.hpp>
 
 namespace Ark
 {
@@ -24,6 +25,21 @@ namespace Ark
 
 namespace Ark::internal
 {
+    namespace bytecode
+    {
+        constexpr std::array Magic = { 'a', 'r', 'k', '\0' };
+        constexpr std::array Version = {
+            ARK_VERSION_MAJOR & 0xff00,
+            ARK_VERSION_MAJOR & 0x00ff,
+            ARK_VERSION_MINOR & 0xff00,
+            ARK_VERSION_MINOR & 0x00ff,
+            ARK_VERSION_PATCH & 0xff00,
+            ARK_VERSION_PATCH & 0x00ff
+        };
+        constexpr std::size_t TimestampLength = 8;
+        constexpr std::size_t HeaderSize = Magic.size() + Version.size() + TimestampLength;
+    }
+
     /// The different node types available
     enum class NodeType
     {

src/arkreactor/Compiler/BytecodeReader.cpp

@@ -40,9 +40,11 @@ namespace Ark
 
     bool BytecodeReader::checkMagic() const
     {
-        return m_bytecode.size() >= 4 && m_bytecode[0] == 'a' &&
-            m_bytecode[1] == 'r' && m_bytecode[2] == 'k' &&
-            m_bytecode[3] == internal::Instruction::NOP;
+        return m_bytecode.size() >= bytecode::Magic.size() &&
+            m_bytecode[0] == bytecode::Magic[0] &&
+            m_bytecode[1] == bytecode::Magic[1] &&
+            m_bytecode[2] == bytecode::Magic[2] &&
+            m_bytecode[3] == bytecode::Magic[3];
     }
 
     const bytecode_t& BytecodeReader::bytecode() noexcept
@@ -52,7 +54,7 @@ namespace Ark
 
     Version BytecodeReader::version() const
     {
-        if (!checkMagic() || m_bytecode.size() < 10)
+        if (!checkMagic() || m_bytecode.size() < bytecode::Magic.size() + bytecode::Version.size())
             return Version { 0, 0, 0 };
 
         return Version {
@@ -65,7 +67,7 @@ namespace Ark
     unsigned long long BytecodeReader::timestamp() const
     {
         // 4 (ark\0) + version (2 bytes / number) + timestamp = 18 bytes
-        if (!checkMagic() || m_bytecode.size() < 18)
+        if (!checkMagic() || m_bytecode.size() < bytecode::HeaderSize)
             return 0;
 
         // reading the timestamp in big endian
@@ -82,27 +84,27 @@ namespace Ark
 
     std::vector<unsigned char> BytecodeReader::sha256() const
     {
-        if (!checkMagic() || m_bytecode.size() < 18 + picosha2::k_digest_size)
+        if (!checkMagic() || m_bytecode.size() < bytecode::HeaderSize + picosha2::k_digest_size)
             return {};
 
         std::vector<unsigned char> sha(picosha2::k_digest_size);
         for (std::size_t i = 0; i < picosha2::k_digest_size; ++i)
-            sha[i] = m_bytecode[18 + i];
+            sha[i] = m_bytecode[bytecode::HeaderSize + i];
         return sha;
     }
 
     Symbols BytecodeReader::symbols() const
     {
-        if (!checkMagic() || m_bytecode.size() < 18 + picosha2::k_digest_size ||
-            m_bytecode[18 + picosha2::k_digest_size] != SYM_TABLE_START)
+        if (!checkMagic() || m_bytecode.size() < bytecode::HeaderSize + picosha2::k_digest_size ||
+            m_bytecode[bytecode::HeaderSize + picosha2::k_digest_size] != SYM_TABLE_START)
             return {};
 
-        std::size_t i = 18 + picosha2::k_digest_size + 1;
+        std::size_t i = bytecode::HeaderSize + picosha2::k_digest_size + 1;
         const uint16_t size = readNumber(i);
         i++;
 
         Symbols block;
-        block.start = 18 + picosha2::k_digest_size;
+        block.start = bytecode::HeaderSize + picosha2::k_digest_size;
         block.symbols.reserve(size);
 
         for (uint16_t j = 0; j < size; ++j)
@@ -209,7 +211,7 @@ namespace Ark
     {
         if (!checkMagic())
         {
-            fmt::print("Invalid format");
+            fmt::println("Invalid format");
             return;
         }
 

src/arkreactor/Compiler/IntermediateRepresentation/IRCompiler.cpp

@@ -41,12 +41,10 @@ namespace Ark::internal
             m_bytecode.push_back(0_u8);
         }
 
-        constexpr std::size_t header_size = 18;
-
         // generate a hash of the tables + bytecode
         std::vector<unsigned char> hash_out(picosha2::k_digest_size);
-        picosha2::hash256(m_bytecode.begin() + header_size, m_bytecode.end(), hash_out);
-        m_bytecode.insert(m_bytecode.begin() + header_size, hash_out.begin(), hash_out.end());
+        picosha2::hash256(m_bytecode.begin() + bytecode::HeaderSize, m_bytecode.end(), hash_out);
+        m_bytecode.insert(m_bytecode.begin() + bytecode::HeaderSize, hash_out.begin(), hash_out.end());
 
         m_logger.traceEnd();
     }

src/arkreactor/VM/State.cpp

@@ -155,7 +155,7 @@ namespace Ark
         const auto bytecode_hash = bcr.sha256();
 
         std::vector<unsigned char> hash(picosha2::k_digest_size);
-        picosha2::hash256(m_bytecode.begin() + 18 + picosha2::k_digest_size, m_bytecode.end(), hash);
+        picosha2::hash256(m_bytecode.begin() + bytecode::HeaderSize + picosha2::k_digest_size, m_bytecode.end(), hash);
         // checking integrity
         for (std::size_t j = 0; j < picosha2::k_digest_size; ++j)
         {

tests/unittests/BytecodeReaderSuite.cpp

@@ -2,6 +2,7 @@
 
 #include <Ark/Compiler/BytecodeReader.hpp>
 #include <Ark/Compiler/Welder.hpp>
+#include <picosha2.h>
 
 #include <string>
 #include <chrono>
@@ -31,7 +32,8 @@ ut::suite<"BytecodeReader"> bcr_suite = [] {
                                             .count());
 
     Ark::BytecodeReader bcr;
-    bcr.feed(welder.bytecode());
+    const auto bytecode = welder.bytecode();
+    bcr.feed(bytecode);
 
     "bytecode"_test = [&] {
         should("find the version") = [bcr] {
@@ -47,14 +49,12 @@ ut::suite<"BytecodeReader"> bcr_suite = [] {
             expect(that % time <= time_end);
         };
 
-        should("find the sha256") = [bcr] {
+        should("find the sha256") = [bcr, bytecode] {
             const auto sha256 = bcr.sha256();
-            const auto expected_sha = std::vector<unsigned char> {
-                0xcf, 0x79, 0x82, 0x6b, 0x81, 0x5c, 0xe4, 0x11,
-                0xce, 0x25, 0xbe, 0xc3, 0x05, 0x91, 0x21, 0x7f,
-                0x6c, 0x70, 0x54, 0x70, 0xd8, 0x8b, 0x2b, 0x90,
-                0x82, 0xcd, 0x70, 0x2e, 0xeb, 0x51, 0xb2, 0x75
-            };
+            std::vector<unsigned char> expected_sha(picosha2::k_digest_size);
+            // compute sha256 after header + sha
+            picosha2::hash256(bytecode.begin() + Ark::internal::bytecode::HeaderSize + 32, bytecode.end(), expected_sha);
+
             expect(that % sha256 == expected_sha);
         };