Merge pull request #34 from 0xf00sec/0xf00sec-patch-2

Revise rt_* mem APIs

1 files changed, 124 insertions, 128 deletions

diff --git a/dev/kernel/src/Utils.cc b/dev/kernel/src/Utils.cc
index 484bcfaa..6c770798 100644
--- a/dev/kernel/src/Utils.cc
+++ b/dev/kernel/src/Utils.cc
@@ -7,187 +7,183 @@
 #include <NeKit/Utils.h>
 
 namespace Kernel {
-Int32 rt_string_cmp(const Char* src, const Char* cmp, Size size) {
-  Int32 counter = 0;
-
-  for (Size index = 0; index < size; ++index) {
-    if (src[index] != cmp[index]) ++counter;
-  }
 
-  return counter;
-}
+STATIC Int rt_copy_memory_safe(const voidPtr src, voidPtr dst, Size len, Size dst_size);
+STATIC voidPtr rt_set_memory_safe(voidPtr dst, UInt32 value, Size len, Size dst_size);
 
-Void rt_zero_memory(voidPtr pointer, Size len) {
-  rt_set_memory(pointer, 0, len);
+Int32 rt_string_cmp(const Char* src, const Char* cmp, Size size) {
+  for (Size i = 0; i < size; ++i) {
+    if (src[i] != cmp[i])
+      return static_cast<Int32>(src[i]) - static_cast<Int32>(cmp[i]);
+  }
+  return 0;
 }
 
-SizeT rt_string_len(const Char* str, SizeT _len) {
-  SizeT len{0};
-
-  do {
-    if (len > _len) {
-      return _len;
-    }
-
+SizeT rt_string_len(const Char* str, SizeT max_len) {
+  SizeT len = 0;
+  while (len < max_len && str[len] != '\0')
     ++len;
-  } while (str[len] != '\0');
-
   return len;
 }
 
 Size rt_string_len(const Char* ptr) {
-  SizeT cnt{0};
-
-  while (ptr[cnt] != 0) ++cnt;
-
+  Size cnt = 0;
+  while (ptr[cnt] != '\0')
+    ++cnt;
   return cnt;
 }
 
-voidPtr rt_set_memory(voidPtr src, UInt32 value, Size len) {
-  UInt32* start = reinterpret_cast<UInt32*>(src);
-
-  while (len) {
-    *start = value;
-    ++start;
-    --len;
-  }
-
-  return (voidPtr) start;
-}
-
-Int rt_move_memory(const voidPtr src, voidPtr dst, Size len) {
-  Char* srcChr  = reinterpret_cast<Char*>(src);
-  Char* dstChar = reinterpret_cast<Char*>(dst);
-  SizeT index   = 0;
-
-  while (index < len) {
-    dstChar[index] = srcChr[index];
-    srcChr[index]  = 0;
-
-    ++index;
+const Char* rt_alloc_string(const Char* src) {
+  SizeT slen = rt_string_len(src);
+  Char* buffer = new Char[slen + 1];
+  if (!buffer) return nullptr;
+
+  if (rt_copy_memory_safe(reinterpret_cast<voidPtr>(const_cast<Char*>(src)),
+                          reinterpret_cast<voidPtr>(buffer),
+                          slen,
+                          slen + 1) < 0) {
+    delete[] buffer;
+    return nullptr;
   }
 
-  return 0;
+  buffer[slen] = '\0';
+  return buffer;
 }
 
-Int rt_copy_memory(const voidPtr src, voidPtr dst, Size len) {
-  char* srcChr  = reinterpret_cast<char*>(src);
-  char* dstChar = reinterpret_cast<char*>(dst);
-  Size  index   = 0;
-
-  while (index < len) {
-    dstChar[index] = srcChr[index];
-    ++index;
+STATIC Int rt_copy_memory_safe(const voidPtr src, voidPtr dst, Size len, Size dst_size) {
+  if (!src || !dst || len > dst_size) {
+    if (dst && dst_size) {
+      rt_set_memory_safe(dst, 0, dst_size, dst_size);
+    }
+    return -1;
   }
-
-  return index;
+  auto s = reinterpret_cast<const unsigned char*>(src);
+  auto d = reinterpret_cast<unsigned char*>(dst);
+  for (Size i = 0; i < len; ++i)
+    d[i] = s[i];
+  return static_cast<Int>(len);
+}
+
+STATIC voidPtr rt_set_memory_safe(voidPtr dst, UInt32 value, Size len, Size dst_size) {
+  if (!dst || len > dst_size) return nullptr;
+  auto p = reinterpret_cast<unsigned char*>(dst);
+  unsigned char v = static_cast<unsigned char>(value & 0xFF);
+  for (Size i = 0; i < len; ++i)
+    p[i] = v;
+  return dst;
 }
 
-const Char* rt_alloc_string(const Char* src) {
-  const Char* string = new Char[rt_string_len(src) + 1];
-
-  if (!string) return nullptr;
-
-  voidPtr v_src = reinterpret_cast<voidPtr>(const_cast<char*>(src));
-  voidPtr v_dst = reinterpret_cast<voidPtr>(const_cast<char*>(string));
-
-  rt_copy_memory(v_src, v_dst, rt_string_len(src) + 1);
-
-  return string;
+Void rt_zero_memory(voidPtr pointer, Size len) {
+  rt_set_memory_safe(pointer, 0, len, len);
 }
 
-Int32 rt_to_uppercase(Int32 character) {
-  if (character >= 'a' && character <= 'z') return character - 0x20;
 
-  return character;
+[[deprecated("Use rt_set_memory_safe instead")]]
+voidPtr rt_set_memory(voidPtr src, UInt32 value, Size len) {
+  if (!src) return nullptr;
+  auto p = reinterpret_cast<unsigned char*>(src);
+  unsigned char v = static_cast<unsigned char>(value & 0xFF);
+  for (Size i = 0; i < len; ++i)
+    p[i] = v;
+  return src;
 }
 
-Int32 rt_is_alnum(Int32 character) {
-  return (character >= 'a' && character <= 'z') || (character >= 'A' && character <= 'Z') ||
-         (character >= '0' && character <= '9');
+[[deprecated("Use rt_copy_memory_safe instead")]]
+Int rt_copy_memory(const voidPtr src, voidPtr dst, Size len) {
+  if (!src || !dst) return -1;
+  auto s = reinterpret_cast<const unsigned char*>(src);
+  auto d = reinterpret_cast<unsigned char*>(dst);
+  for (Size i = 0; i < len; ++i)
+    d[i] = s[i];
+  return static_cast<Int>(len);
 }
 
-Int32 rt_to_lower(Int32 character) {
-  if (character >= 'A' && character <= 'Z') return character + 0x20;
 
-  return character;
+Int32 rt_to_uppercase(Int32 ch) {
+  return (ch >= 'a' && ch <= 'z') ? ch - 0x20 : ch;
 }
 
-Boolean rt_is_space(Char chr) {
-  return chr == ' ';
+Int32 rt_to_lower(Int32 ch) {
+  return (ch >= 'A' && ch <= 'Z') ? ch + 0x20 : ch;
 }
 
-Boolean rt_is_newln(Char chr) {
-  return chr == '\n';
+Int32 rt_is_alnum(Int32 ch) {
+  return (ch >= 'a' && ch <= 'z') ||
+         (ch >= 'A' && ch <= 'Z') ||
+         (ch >= '0' && ch <= '9');
 }
 
-VoidPtr rt_string_in_string(const Char* in, const Char* needle) {
-  for (SizeT i = 0; i < rt_string_len(in); ++i) {
-    if (rt_string_cmp(in + i, needle, rt_string_len(needle)) == 0)
-      return reinterpret_cast<voidPtr>(const_cast<char*>(in + i));
-  }
+Boolean rt_is_space(Char ch) {
+  return ch == ' ';
+}
 
-  return nullptr;
+Boolean rt_is_newln(Char ch) {
+  return ch == '\n';
 }
 
-Char rt_to_char(UInt64 base, Int32 limit) {
-  Char kNumbers[17] = "0123456789ABCDEF";
-  return kNumbers[base % limit];
+Char rt_to_char(UInt64 value, Int32 base) {
+  static constexpr Char kDigits[] = "0123456789ABCDEF";
+  return kDigits[value % base];
 }
 
-Bool rt_to_string(Char* str, UInt64 base, Int32 limit) {
+Bool rt_to_string(Char* str, UInt64 value, Int32 base) {
 #ifdef __NE_AMD64__
-  auto i = 0;
-
-  auto final_number = base;
-
-  auto mult  = 1;
-  auto elems = 0L;
-
-  base /= 10;
-
-  while (base > 0) {
-    elems++;
-    mult *= 10;
-    base /= 10;
-  }
-
-  while (elems > -1) {
-    final_number = (final_number % mult) * 10 + final_number / mult;
-    str[i]       = rt_to_char(final_number, limit);
-
-    --elems;
-    ++i;
+  Int i = 0;
+  do {
+    str[i++] = rt_to_char(value, base);
+    value /= base;
+  } while (value);
+  str[i] = '\0';
+  // in-place
+  for (Int j = 0; j < i / 2; ++j) {
+    Char tmp = str[j];
+    str[j] = str[i - j - 1];
+    str[i - j - 1] = tmp;
   }
 #endif
-
-  return YES;
+  return true;
 }
 
-/// @brief Checks for a string start at the character.
 
-Char* rt_string_has_char(Char* str, Char chr) {
-  while (*str != chr) {
-    ++str;
+VoidPtr rt_string_in_string(const Char* haystack, const Char* needle) {
+  SizeT needle_len = rt_string_len(needle);
+  SizeT hay_len = rt_string_len(haystack);
 
-    if (*str == 0) return nullptr;
+  if (needle_len > hay_len) return nullptr;
+  for (SizeT i = 0; i <= hay_len - needle_len; ++i) {
+    if (rt_string_cmp(haystack + i, needle, needle_len) == 0) {
+      return reinterpret_cast<voidPtr>(const_cast<Char*>(haystack + i));
+    }
   }
+  return nullptr;
+}
 
-  return str;
+Char* rt_string_has_char(Char* str, Char ch) {
+  while (*str && *str != ch) ++str;
+  return (*str == ch) ? str : nullptr;
 }
-}  // namespace Kernel
 
-////// @note These symbols were written to satisfy gcc, clang and other compiler complaints.
+Int32 rt_strcmp(const Char* a, const Char* b) {
+  Size i = 0;
+  while (a[i] != '\0' && b[i] != '\0' && a[i] == b[i]) {
+    ++i;
+  }
+  return static_cast<Int32>(static_cast<unsigned char>(a[i]) -
+                            static_cast<unsigned char>(b[i]));
+}
 
-EXTERN_C void* memset(void* dst, int c, long long unsigned int len) {
-  return Kernel::rt_set_memory(dst, c, len);
+  // @uses the deprecated version callers should ensure 'len' is valid.
+extern "C" void* memset(void* dst, int c, long long unsigned int len) {
+  return Kernel::rt_set_memory(dst, c, static_cast<Size>(len));
 }
 
-EXTERN_C void* memcpy(void* dst, const void* src, long long unsigned int len) {
-  Kernel::rt_copy_memory(const_cast<void*>(src), dst, len);
+extern "C" void* memcpy(void* dst, const void* src, long long unsigned int len) {
+  Kernel::rt_copy_memory(const_cast<void*>(src), dst, static_cast<Size>(len));
   return dst;
 }
 
-EXTERN_C Kernel::Int32 strcmp(const char* dst, const char* src) {
-  return Kernel::rt_string_cmp(dst, src, Kernel::rt_string_len(dst));
+extern "C" Kernel::Int32 strcmp(const char* a, const char* b) {
+  return Kernel::rt_strcmp(a, b);
 }
+
+}