Espresso/lib/string.c

#include <stdlib.h>
#include <stdio.h>
#include <vector_extentions/sse.h>

#include <string.h>


extern int32_t sse_initialized;

size_t strlen(const char* str)
{
  size_t len = 0;
  while (str[len])
  {
    len++;
  }
  return len;
}

int32_t strcmp(const char *s1, const char *s2)
{
  while (*s1 && (*s1 == *s2))
  {
    s1++;
    s2++;
  }
  return (unsigned char)*s1 - (unsigned char)*s2;
}


int32_t strncmp(const char *s1, const char *s2, size_t n)
{
  while (n--)
  {
    unsigned char c1 = (unsigned char)*s1++;
    unsigned char c2 = (unsigned char)*s2++;
    if (c1 != c2)
    {
      return c1 - c2;
    }
    if (c1 == '\0')
    {
      break;
    }
  }
  return 0;
}

int32_t strcasecmp(const char* s1, const char* s2)
{
  unsigned char c1, c2;

  while (*s1 && *s2)
  {
    c1 = lower((unsigned char)*s1);
    c2 = lower((unsigned char)*s2);

    if (c1 != c2)
    {
      return c1 - c2;
    }

    s1++;
    s2++;
  }

  return lower((unsigned char)*s1) - lower((unsigned char)*s2);
}

char* strcpy(char *dst, const char *src)
{
  char *ret = dst;
  while ((*dst++ = *src++) != 0);
  return ret;
}


char* strncpy(char *dest, const char *src, uint32_t n)
{
  if (sse_initialized > 0)
  {
    return sse2_strncpy(dest, src, n);
  }

  uint32_t i = 0;
  for (; i < n && src[i]; ++i)
  {
    dest[i] = src[i];
  }

  for (; i < n; ++i)
  {
    dest[i] = '\0';
  }

  return dest;
}

char* strcat(char *dest, const char *src)
{
  char *end = dest + strlen(dest);
  while (*src)
  {
    *end++ = *src++;
  }
  
  *end = '\0';
  return dest;
}


char* strdup(const char* s)
{
  if (!s)
  {
    return NULL;
  }

  size_t len = strlen(s);
  char* copy = (char*)malloc(len + 1);

  if (!copy)
  {
    return NULL;
  }

  memcpy(copy, s, len);
  copy[len] = '\0';

  return copy;
}

char* strtok(char* str, const char* delim)
{
  static char* next_token = NULL;

  if (str != NULL)
  {
    next_token = str;
  }
  else if (next_token == NULL)
  {
    return NULL;
  }

  while (*next_token && strchr(delim, *next_token))
  {
    next_token++;
  }

  if (*next_token == '\0')
  {
    return NULL;
  }

  char* token_start = next_token;

  while (*next_token && !strchr(delim, *next_token))
  {
    next_token++;
  }

  if (*next_token)
  {
    *next_token = '\0';
    next_token++;
  }

  return token_start;
}

char* strchr(const char* s, int c)
{
  while (*s)
  {
    if (*s == (char)c)
    {
      return (char*)s;
    }
    s++;
  }

  return NULL;
}



void* memset(void *dst, char c, uint32_t n)
{
  char *temp = dst;
  for (; n != 0; n--)
  {
    *temp++ = c;
  }
  return dst;
}

void* memcpy(void *dst, const void *src, uint32_t n)
{
  if (sse_initialized > 1)
  {
    return sse2_memcpy(dst, src, n);
  }

  char *d = dst;
  const char *s = src;
  while (n--)
  {
    *d++ = *s++;
  }
  
  return dst;
}

int32_t memcmp(const void *s1, const void *s2, size_t n)
{
  const uint8_t *p1 = (const uint8_t *)s1;
  const uint8_t *p2 = (const uint8_t *)s2;
  
  printf("p1: %i, p2: %i\n", (int32_t)*p1, (int32_t)*p2);

  for (size_t i = 0; i < n; i++)
  {
    if (p1[i] != p2[i])
    {
      return (int32_t)p1[i] - (int32_t)p2[i];
    }
  }
  return 0;
}


void* memclr(void* m_start, size_t m_count)
{
  if (sse_initialized > 1)
  {
    return memclr_sse2(m_start, m_count);
  }
  
  return memset(m_start, '\0', (uint32_t)m_count);
}

int32_t isspace(char c)
{
  return c == ' ' || c == '\t' || c == '\n' || c == '\v' || c == '\f' || c == '\r';
}

int32_t isalpha(char c)
{
  return (((c >= 'A') && (c <= 'Z')) || ((c >= 'a') && (c <= 'z')));
}

int32_t ischar(int32_t c)
{
  return ((c >= 32) && (c <= 126));
}

char upper(char c)
{
  if ((c >= 'a') && (c <= 'z'))
  {
    return (c - 32);
  }
  return c;
}

char lower(char c)
{
  if ((c >= 'A') && (c <= 'Z'))
  {
    return (c + 32);
  }
  return c;
}

char toupper(char c)
{
  return upper(c);
}

char tolower(char c)
{
  return lower(c);
}