CM: String & memory set functions added

Also includes:
* Associated unittests.

Author: coderarjob

include/cm/cm.h

@@ -63,3 +63,11 @@ static inline void* cm_process_get_datamem_start()
 typedef void (*cm_event_handler)(OSIF_ProcessEvent const * const);
 bool cm_process_register_event_handler(OSIF_ProcessEvents event, cm_event_handler h);
 bool cm_process_handle_events();
+
+/***************************************************************************************************
+ * String and memory functions
+ ***************************************************************************************************/
+void* cm_memcpy (void* dest, const void* src, size_t n);
+UINT cm_strlen (const char* s);
+char* cm_strncpy (char* d, const char* s, SIZE n);
+void* cm_memset (void* const s, U8 c, size_t n);

src/cm/CMakeLists.txt

@@ -26,6 +26,7 @@ set(APPLIB_SOURCES
         ${CMAKE_CURRENT_SOURCE_DIR}/printf.c
         ${CMAKE_CURRENT_SOURCE_DIR}/debug.c
         ${CMAKE_CURRENT_SOURCE_DIR}/cm.c
+        ${CMAKE_CURRENT_SOURCE_DIR}/string.c
     )
 
     if (MOS_GRAPHICS_ENABLED)

src/cm/string.c

@@ -0,0 +1,76 @@
+/*
+ * -------------------------------------------------------------------------------------------------
+ * Megha Operating System V2 - App Library - String/Memory functions
+ * -------------------------------------------------------------------------------------------------
+ */
+
+#include <cm/types.h>
+
+/***************************************************************************************************
+ * Copies n bytes from src to dest. Can handle overlaps.
+ *
+ * @Input dest     Pointer to the destination. Should not be NULL.
+ * @Input src      Pointer to the source. Should not be NULL.
+ * @Input n        Number of bytes to copy.
+ * @return         Pointer to the start of the destination.
+ ***************************************************************************************************/
+void* cm_memcpy (void* dest, const void* src, size_t n)
+{
+    U8* cdest = (U8*)dest;
+    U8* csrc  = (U8*)src;
+
+    // This handles the scenario where destination overlaps the source.
+    cdest += n - 1;
+    csrc += n - 1;
+
+    while (n--)
+        *cdest-- = *csrc--;
+
+    return (CHAR*)dest;
+}
+
+/***************************************************************************************************
+ * Gets lenght of a NULL terminated string.
+ *
+ * @Input s     Pointer to NULL terminated string
+ * @return      Length of the string not including the NULL character.
+ * TODO: Make the implementation mode efficient
+ ***************************************************************************************************/
+UINT cm_strlen (const char* s)
+{
+    UINT len = 0;
+    for (; *s != '\0'; len++, s++)
+        ;
+
+    return len;
+}
+
+/***************************************************************************************************
+ * Copies at most 'n' characters from one string to another.
+ *
+ * @Input d     Destination
+ * @Input s     Source
+ * @Input n     Number of characters (bytes) to copy from destination to source.
+ * @return      Pointer to destination
+ ***************************************************************************************************/
+char* cm_strncpy (char* d, const char* s, SIZE n)
+{
+    char* dh = d;
+    for (; n > 0 && (*d = *s) != '\0'; s++, d++, n--)
+        ;
+
+    return dh;
+}
+
+/***************************************************************************************************
+ * Fills memory with constant byte
+ *
+ * @Input s     Pointer to the destination. Should not be NULL.
+ * @Input c     Byte to fill the destination with.
+ * @Input n     Number of bytes to fill.
+ * @return      Pointer to the start of the destination.
+ ***************************************************************************************************/
+void* cm_memset (void* const s, U8 c, size_t n)
+{
+    return __builtin_memset (s, c, n);
+}

src/unittests/cm/CMakeLists.txt

@@ -8,3 +8,12 @@ test(
         ${PROJECT_SOURCE_DIR}/src/unittests/unittest.c
         ${CMAKE_CURRENT_SOURCE_DIR}/printf_test.c
     )
+
+test(
+    NAME cm_string_test
+    DEPENDENT_FOR build-all
+    SOURCES
+        ${PROJECT_SOURCE_DIR}/src/cm/string.c
+        ${PROJECT_SOURCE_DIR}/src/unittests/unittest.c
+        ${CMAKE_CURRENT_SOURCE_DIR}/string_test.c
+    )

src/unittests/cm/string_test.c

@@ -0,0 +1,115 @@
+#include <cm/types.h>
+#include <cm/cm.h>
+#include <unittest/unittest.h>
+#include <mock/kernel/paging.h>
+
+extern bool panic_invoked;
+
+TEST (MEM, memset_one_byte)
+{
+    U8 dest;
+    EQ_SCALAR ((PTR)cm_memset (&dest, 0x1A, 1), (PTR)&dest);
+    EQ_SCALAR (dest, 0x1A);
+    END();
+}
+
+TEST (STRING, string_length)
+{
+    EQ_SCALAR (cm_strlen (""), 0);
+    EQ_SCALAR (cm_strlen ("ABCD"), 4);
+    EQ_SCALAR (cm_strlen ("A\n\tB"), 4);
+    END();
+}
+
+TEST (STRING, string_copy)
+{
+    char destination[10];
+    char* source = NULL;
+
+    // Copy empty string
+    source = "";
+    EQ_SCALAR ((PTR)cm_strncpy (destination, source, ARRAY_LENGTH (destination)), (PTR)destination);
+    EQ_STRING (source, destination);
+
+    // Copy < size of destination
+    source = "ABC";
+    EQ_SCALAR ((PTR)cm_strncpy (destination, source, ARRAY_LENGTH (destination)), (PTR)destination);
+    EQ_STRING (source, destination);
+
+    //// Copy = size of destination
+    source = "123456789";
+    EQ_SCALAR ((PTR)cm_strncpy (destination, source, ARRAY_LENGTH (destination)), (PTR)destination);
+    EQ_STRING (source, destination);
+
+    //// Copy > size of destination
+    // source = "123456789ABCD";
+    EQ_SCALAR ((PTR)cm_strncpy (destination, source, ARRAY_LENGTH (destination)), (PTR)destination);
+    EQ_STRING ("123456789", destination); // Not more than size of destination is copied.
+    END();
+}
+
+TEST (MEM, memcpy_overlap)
+{
+    // Here is the memory layout for this test;
+    // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14   < byte indices]
+    // |-----------------|   <src]
+    // 1 2 3 4 5 6 7 8 9 10  <src contents before copy]
+    //           |----------------------| <dest]
+    //           1 2 3 4 5 6  7  8  9  10  <dest contents after copy]
+    // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14   < byte indices]
+
+    U8 memory[15] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
+    CHAR* src     = &memory[0];
+    CHAR* dest    = &memory[5];
+
+    EQ_SCALAR ((PTR)cm_memcpy (dest, src, 10), (PTR)dest);
+
+    for (int i = 0; i < 10; i++)
+        EQ_SCALAR (dest[i], i + 1); // Dest[0 to 9] has 1 to 10
+
+    for (int i = 0; i < 5; i++) {
+        EQ_SCALAR (src[i], i + 1);     // Src[0 to 4]  has 1 to 5
+        EQ_SCALAR (src[i + 5], i + 1); // Src[5 to 9]  has 1 to 5
+    }
+
+    END();
+}
+
+TEST (MEM, memcpy_normal)
+{
+    CHAR* src = "123456789ABCDEF0";
+    CHAR dest[10];
+
+    EQ_SCALAR ((PTR)cm_memcpy (dest, src, ARRAY_LENGTH (dest)), (PTR)&dest);
+
+    for (int i = 0; i < ARRAY_LENGTH (dest); i++)
+        EQ_SCALAR (dest[i], src[i]);
+
+    END();
+}
+
+TEST (MEM, memset_normal)
+{
+    U8 dest[10];
+
+    EQ_SCALAR ((PTR)cm_memset (dest, 0x1A, ARRAY_LENGTH (dest)), (PTR)&dest);
+
+    for (int i = 0; i < ARRAY_LENGTH (dest); i++)
+        EQ_SCALAR (dest[i], 0x1A);
+
+    END();
+}
+
+void reset()
+{
+}
+
+int main()
+{
+    memset_one_byte();
+    memset_normal();
+    memcpy_normal();
+    memcpy_overlap();
+    string_length();
+    string_copy();
+}