[Logs] Implement format_n for char[N]

orbis-kernel/include/orbis/sys/sysproto.hpp

@@ -615,10 +615,10 @@ SysResult sys_jitshm_alias(Thread *thread /* TODO */);
 SysResult sys_dl_get_list(Thread *thread /* TODO */);
 SysResult sys_dl_get_info(Thread *thread /* TODO */);
 SysResult sys_dl_notify_event(Thread *thread /* TODO */);
-SysResult sys_evf_create(Thread *thread, ptr<char> name, sint attrs,
+SysResult sys_evf_create(Thread *thread, ptr<const char[32]> name, sint attrs,
                          ptr<struct evFlag> evf);
 SysResult sys_evf_delete(Thread *thread, sint id);
-SysResult sys_evf_open(Thread *thread, ptr<char> name);
+SysResult sys_evf_open(Thread *thread, ptr<const char[32]> name);
 SysResult sys_evf_close(Thread *thread, sint id);
 SysResult sys_evf_wait(Thread *thread, sint id, uint64_t patternSet,
                        uint64_t mode, ptr<uint64_t> pPatternSet,
@@ -640,7 +640,7 @@ SysResult sys_osem_wait(Thread *thread /* TODO */);
 SysResult sys_osem_trywait(Thread *thread /* TODO */);
 SysResult sys_osem_post(Thread *thread /* TODO */);
 SysResult sys_osem_cancel(Thread *thread /* TODO */);
-SysResult sys_namedobj_create(Thread *thread, ptr<const char> name,
+SysResult sys_namedobj_create(Thread *thread, ptr<const char[32]> name,
                               ptr<void> object, uint16_t type);
 SysResult sys_namedobj_delete(Thread *thread, uint16_t id, uint16_t type);
 SysResult sys_set_vm_container(Thread *thread /* TODO */);

orbis-kernel/include/orbis/utils/Logs.hpp

@@ -34,18 +34,31 @@ template <typename T>
 struct log_class_string<T *, void> : log_class_string<void *, void> {};
 
 template <> struct log_class_string<char *, void> {
+  static void format_n(std::string &out, const void *str, std::size_t n);
   static void format(std::string &out, const void *arg);
 };
 
+template <>
+struct log_class_string<const char *, void> : log_class_string<char *> {};
+
 template <std::size_t N> struct log_class_string<char[N]> {
   static void format(std::string &out, const void *arg) {
-    out += reinterpret_cast<const char *>(arg);
+    log_class_string<char *, void>::format_n(out, arg, N);
+  }
+};
+
+template <std::size_t N> struct log_class_string<const char[N]> {
+  static void format(std::string &out, const void *arg) {
+    log_class_string<char *, void>::format_n(out, arg, N);
   }
 };
 
 template <>
 struct log_class_string<char8_t *, void> : log_class_string<char *> {};
 
+template <>
+struct log_class_string<const char8_t *, void> : log_class_string<char *> {};
+
 template <typename... Args>
 using log_args_t = const void *(&&)[sizeof...(Args) + 1];
 
@@ -59,22 +72,9 @@ struct log_type_info {
   }
 };
 
-namespace detail {
-template <typename T> struct remove_const_data {
-  using type = T;
-};
-template <typename T> struct remove_const_data<const T *> {
-  using type = T *;
-};
-
-template <typename T>
-using remove_const_data_t = typename remove_const_data<T>::type;
-} // namespace detail
-
 template <typename... Args>
 constexpr const log_type_info type_info_v[sizeof...(Args) + 1]{
-    log_type_info::make<
+    log_type_info::make<std::remove_cvref_t<Args>>()...};
-        detail::remove_const_data_t<std::remove_cvref_t<Args>>>()...};
 
 void _orbis_log_print(LogLevel lvl, const char *msg, std::string_view names,
                       const log_type_info *sup, ...);

orbis-kernel/src/sys/sys_sce.cpp

@@ -84,8 +84,9 @@ orbis::SysResult orbis::sys_dl_get_info(Thread *thread /* TODO */) {
 orbis::SysResult orbis::sys_dl_notify_event(Thread *thread /* TODO */) {
   return ErrorCode::NOSYS;
 }
-orbis::SysResult orbis::sys_evf_create(Thread *thread, ptr<char> name,
+orbis::SysResult orbis::sys_evf_create(Thread *thread, ptr<const char[32]> name,
                                        sint attrs, ptr<struct evFlag> evf) {
+  ORBIS_LOG_WARNING(__FUNCTION__, name, attrs, evf);
   if (name == nullptr || evf != nullptr) {
     return ErrorCode::INVAL;
   }
@@ -116,7 +117,7 @@ orbis::SysResult orbis::sys_evf_create(Thread *thread, ptr<char> name,
   }
 
   char _name[32];
-  if (auto result = ureadString(_name, sizeof(_name), name);
+  if (auto result = ureadString(_name, sizeof(_name), (const char *)name);
       result != ErrorCode{}) {
     return result;
   }
@@ -135,8 +136,6 @@ orbis::SysResult orbis::sys_evf_create(Thread *thread, ptr<char> name,
     eventFlag = knew<EventFlag>(attrs);
   }
 
-  ORBIS_LOG_WARNING(__FUNCTION__, _name);
-
   thread->retval[0] = thread->tproc->evfMap.insert(eventFlag);
   return {};
 }
@@ -149,16 +148,15 @@ orbis::SysResult orbis::sys_evf_delete(Thread *thread, sint id) {
   thread->tproc->evfMap.destroy(id);
   return {};
 }
-orbis::SysResult orbis::sys_evf_open(Thread *thread, ptr<char> name) {
+orbis::SysResult orbis::sys_evf_open(Thread *thread, ptr<const char[32]> name) {
+  ORBIS_LOG_WARNING(__FUNCTION__, name);
   char _name[32];
-  if (auto result = ureadString(_name, sizeof(_name), name);
+  if (auto result = ureadString(_name, sizeof(_name), (const char *)name);
       result != ErrorCode{}) {
     return result;
   }
 
-  ORBIS_LOG_WARNING(__FUNCTION__, _name);
+  auto eventFlag = thread->tproc->context->findEventFlag(_name);
-
-  auto eventFlag = thread->tproc->context->findEventFlag(name);
 
   if (eventFlag == nullptr) {
     // HACK :)
@@ -301,11 +299,11 @@ orbis::SysResult orbis::sys_osem_cancel(Thread *thread /* TODO */) {
   return ErrorCode::NOSYS;
 }
 orbis::SysResult orbis::sys_namedobj_create(Thread *thread,
-                                            ptr<const char> name,
+                                            ptr<const char[32]> name,
                                             ptr<void> object, uint16_t type) {
-  ORBIS_LOG_NOTICE(__FUNCTION__, name, object, type);
+  ORBIS_LOG_NOTICE(__FUNCTION__, *name, object, type);
   char _name[32];
-  if (auto result = ureadString(_name, sizeof(_name), name);
+  if (auto result = ureadString(_name, sizeof(_name), (const char *)name);
       result != ErrorCode{}) {
     return result;
   }

orbis-kernel/src/utils/Logs.cpp

@@ -18,8 +18,27 @@ void log_class_string<void *>::format(std::string &out, const void *arg) {
   append_hex(out, reinterpret_cast<std::uintptr_t>(ptr));
 }
 
+void log_class_string<char *>::format_n(std::string &out, const void *arg,
+                                        std::size_t n) {
+  const char *ptr = reinterpret_cast<const char *>(arg);
+  const auto addr = reinterpret_cast<std::uintptr_t>(ptr);
+  const auto _end = n ? addr + n - 1 : addr;
+  if (addr < 0x10000 || std::max(n, _end) > 0x7fff'ffff'ffff) {
+    out += "{{{{{BAD_ADDR:";
+    append_hex(out, addr);
+    out += "}}}}}";
+    return;
+  }
+  while (n--) {
+    const char c = *ptr++;
+    if (!c)
+      break;
+    out += c;
+  }
+}
+
 void log_class_string<char *>::format(std::string &out, const void *arg) {
-  const char* ptr = *reinterpret_cast<const char *const *>(arg);
+  const char *ptr = *reinterpret_cast<const char *const *>(arg);
   const auto addr = reinterpret_cast<std::uintptr_t>(ptr);
   if (addr < 0x10000 || addr > 0x7fff'ffff'ffff) {
     out += "{{{{{BAD_ADDR:";