refactor: rename pm-type-name

poor-type-name is more legible

Author: diegonehab

src/i-state-access.h

@@ -28,7 +28,7 @@
 #include "dump.h"
 #include "i-prefer-shadow-state.h"
 #include "meta.h"
-#include "pm-type-name.h"
+#include "poor-type-name.h"
 #include "tlb.h"
 
 namespace cartesi {
@@ -332,7 +332,7 @@ class i_state_access { // CRTP
         derived().template do_read_memory_word<T, A>(faddr, pma_index, pval);
         [[maybe_unused]] const auto fast_addr_name = std::is_same_v<fast_addr, uint64_t> ? "phys_addr" : "fast_addr";
         DSA_PRINTF("%s::read_memory_word<%s,%s>(%s{0x%" PRIx64 "}, %" PRIu64 ") = %" PRIu64 "(0x%" PRIx64 ")\n",
-            get_name(), pm_type_name_v<T>, pm_type_name_v<A>, fast_addr_name, faddr, pma_index,
+            get_name(), poor_type_name_v<T>, poor_type_name_v<A>, fast_addr_name, faddr, pma_index,
             static_cast<uint64_t>(*pval), static_cast<uint64_t>(*pval));
     }
 
@@ -349,7 +349,7 @@ class i_state_access { // CRTP
         derived().template do_write_memory_word<T, A>(faddr, pma_index, val);
         [[maybe_unused]] const auto fast_addr_name = std::is_same_v<fast_addr, uint64_t> ? "phys_addr" : "fast_addr";
         DSA_PRINTF("%s::write_memory_word<%s,%s>(%s{0x%" PRIx64 "}, %" PRIu64 ", %" PRIu64 "(0x%" PRIx64 "))\n",
-            get_name(), pm_type_name_v<T>, pm_type_name_v<A>, fast_addr_name, faddr, pma_index,
+            get_name(), poor_type_name_v<T>, poor_type_name_v<A>, fast_addr_name, faddr, pma_index,
             static_cast<uint64_t>(val), static_cast<uint64_t>(val));
     }
 

src/jsonrpc-machine.cpp

@@ -772,8 +772,8 @@ void jsonrpc_machine::do_send_cmio_response(uint16_t reason, const unsigned char
     request("machine.send_cmio_response", std::tie(reason, b64), result);
 }
 
-access_log jsonrpc_machine::do_log_send_cmio_response(uint16_t reason, const unsigned char *data,
-    uint64_t length, const access_log::type &log_type) {
+access_log jsonrpc_machine::do_log_send_cmio_response(uint16_t reason, const unsigned char *data, uint64_t length,
+    const access_log::type &log_type) {
     not_default_constructible<access_log> result;
     std::string b64 = cartesi::encode_base64(data, length);
     request("machine.log_send_cmio_response", std::tie(reason, b64, log_type), result);

src/machine-c-api.cpp

@@ -37,6 +37,7 @@
 #include "i-machine.h"
 #include "interpret.h"
 #include "json-util.h"
+#include "local-machine.h"
 #include "machine-c-api-internal.h"
 #include "machine-config.h"
 #include "machine-merkle-tree.h"
@@ -45,7 +46,6 @@
 #include "machine.h"
 #include "os-features.h"
 #include "pmas-defines.h"
-#include "local-machine.h"
 
 static_assert(AR_CMIO_RX_BUFFER_START_DEF == CM_AR_CMIO_RX_BUFFER_START);
 static_assert(AR_CMIO_RX_BUFFER_LOG2_SIZE_DEF == CM_AR_CMIO_RX_BUFFER_LOG2_SIZE);

src/pm-type-name.h src/poor-type-name.h

@@ -14,35 +14,35 @@
 // with this program (see COPYING). If not, see <https://www.gnu.org/licenses/>.
 //
 
-#ifndef PM_TYPE_NAME_H
-#define PM_TYPE_NAME_H
+#ifndef POOR_TYPE_NAME_H
+#define POOR_TYPE_NAME_H
 
 namespace cartesi {
 
 //?DD Poor man's rtti that works in microarchitecture
 template <typename T>
-struct pm_type_name {
+struct poor_type_name {
     static constexpr const char *value = "unknown";
 };
 
 template <typename T>
-constexpr const char *pm_type_name_v = pm_type_name<T>::value;
+constexpr const char *poor_type_name_v = poor_type_name<T>::value;
 
 // NOLINTBEGIN(cppcoreguidelines-macro-usage)
-#define PM_TYPE_NAME(type)                                                                                             \
+#define POOR_TYPE_NAME(type)                                                                                           \
     template <>                                                                                                        \
-    struct pm_type_name<type> {                                                                                        \
+    struct poor_type_name<type> {                                                                                      \
         static constexpr const char *value = #type;                                                                    \
     }
 
-PM_TYPE_NAME(uint8_t);
-PM_TYPE_NAME(int8_t);
-PM_TYPE_NAME(uint16_t);
-PM_TYPE_NAME(int16_t);
-PM_TYPE_NAME(uint32_t);
-PM_TYPE_NAME(int32_t);
-PM_TYPE_NAME(uint64_t);
-PM_TYPE_NAME(int64_t);
+POOR_TYPE_NAME(uint8_t);
+POOR_TYPE_NAME(int8_t);
+POOR_TYPE_NAME(uint16_t);
+POOR_TYPE_NAME(int16_t);
+POOR_TYPE_NAME(uint32_t);
+POOR_TYPE_NAME(int32_t);
+POOR_TYPE_NAME(uint64_t);
+POOR_TYPE_NAME(int64_t);
 // NOLINTEND(cppcoreguidelines-macro-usage)
 
 } // namespace cartesi