ra8_freestanding_str.c

Go to the documentation of this file.

 
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC optimize("no-tree-loop-distribute-patterns")
#endif
 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_freestanding.h"
 
#if !defined(RA8_OFF_TARGET) || defined(RA8_TEST_FREESTANDING)

size_t strlen(const char* s)
{
  size_t len = 0U;
  while (s[len] != '\0') {
    ++len;
  }
  return len;
}

size_t strnlen(const char* s, size_t maxlen)
{
  size_t len = 0U;
  while (len < maxlen) {
    if (s[len] == '\0') {
      break;
    }
    ++len;
  }
  return len;
}

int strcmp(const char* s1, const char* s2)
{
  const uint8_t* p1 = (const uint8_t*)s1;
  const uint8_t* p2 = (const uint8_t*)s2;
  while (*p1 != 0U) {
    if (*p1 != *p2) {
      break;
    }
    ++p1;
    ++p2;
  }
  return (int)*p1 - (int)*p2;
}

int strncmp(const char* s1, const char* s2, size_t n)
{
  if (n == 0U) {
    return 0;
  }
  const uint8_t* p1 = (const uint8_t*)s1;
  const uint8_t* p2 = (const uint8_t*)s2;
  for (size_t i = 0U; i < n; ++i) {
    if (p1[i] != p2[i]) {
      return (int)p1[i] - (int)p2[i];
    }
    if (p1[i] == 0U) {
      return 0;
    }
  }
  return 0;
}

char* strchr(const char* s, int c)
{
  const char  target = (char)c;
  const char* cursor = s;
  char*       result = nullptr;
  while (*cursor != '\0') {
    if (*cursor == target) {
      (void)memcpy((void*)&result, (const void*)&cursor, sizeof(result));
      break;
    }
    ++cursor;
  }
  if (target == '\0') {
    (void)memcpy((void*)&result, (const void*)&cursor, sizeof(result));
  }
  return result;
}

char* strrchr(const char* s, int c)
{
  const char  target = (char)c;
  const char* cursor = s;
  const char* last   = nullptr;
  while (*cursor != '\0') {
    if (*cursor == target) {
      last = cursor;
    }
    ++cursor;
  }
  const char* result_source = (target == '\0') ? cursor : last;
  char*       result        = nullptr;
  (void)memcpy((void*)&result, (const void*)&result_source, sizeof(result));
  return result;
}

char* strstr(const char* haystack, const char* needle)
{
  if (needle[0] == '\0') {
    char* result = nullptr;
    (void)memcpy((void*)&result, (const void*)&haystack, sizeof(result));
    return result;
  }
  for (size_t i = 0U; haystack[i] != '\0'; ++i) {
    size_t j = 0U;
    while (needle[j] != '\0') {
      if (haystack[i + j] != needle[j]) {
        break;
      }
      ++j;
    }
    if (needle[j] == '\0') {
      const char* result_source = &haystack[i];
      char*       result        = nullptr;
      (void)memcpy((void*)&result, (const void*)&result_source, sizeof(result));
      return result;
    }
  }
  return nullptr;
}

char* strcpy(char* dst, const char* src)
{
  size_t i = 0U;
  while (src[i] != '\0') {
    dst[i] = src[i];
    ++i;
  }
  dst[i] = '\0';
  return dst;
}

char* strncpy(char* dst, const char* src, size_t n)
{
  size_t i = 0U;
  while (i < n) {
    if (src[i] == '\0') {
      break;
    }
    dst[i] = src[i];
    ++i;
  }
  while (i < n) {
    dst[i] = '\0';
    ++i;
  }
  return dst;
}
 
#endif /* !RA8_OFF_TARGET || RA8_TEST_FREESTANDING */