src/s21_string.c - develop - ne-ilyxa/C2_s21_stringplus

src/s21_string.c
305 строк7 KB
git1worker
Updated %g %e specf for sprintf
20 янв 2024, 19:34
20 янв 2024, 19:34de7841e
#include "s21_string.h"

void *s21_memchr(const void *str, int c, s21_size_t n) {
  unsigned char *ptr = (unsigned char *)str;
  unsigned char *res = S21_NULL;

  for (s21_size_t i = 0; i < n; i++) {
    if (ptr[i] == (unsigned char)c) {
      res = &ptr[i];
      i = n + 1;
    }
  }
  return res;
}

int s21_memcmp(const void *str1, const void *str2, s21_size_t n) {
  const unsigned char *ptr1 = (const unsigned char *)str1;
  const unsigned char *ptr2 = (const unsigned char *)str2;
  int res = 0;

  for (s21_size_t i = 0; i < n; i++) {
    if (ptr1[i] != ptr2[i]) {
      if (ptr1[i] > ptr2[i]) {
        res = 1;
      } else {
        res = -1;
      }
      i = n + 1;
    }
  }
  return res;
}

void *s21_memcpy(void *dest, const void *src, s21_size_t n) {
  unsigned char *destination = (unsigned char *)dest;
  const unsigned char *source = (const unsigned char *)src;
  if (dest != S21_NULL && src != S21_NULL) {
    for (s21_size_t i = 0; i < n; i++) {
      destination[i] = source[i];
    }
  }
  return (void *)(destination);
}

void *s21_memset(void *str, int c, s21_size_t n) {
  unsigned char *ptr = (unsigned char *)str;

  for (s21_size_t i = 0; i < n; i++) {
    ptr[i] = (unsigned char)c;
  }

  return (void *)(ptr);
}

char *s21_strncat(char *dest, const char *src, s21_size_t n) {
  int last = s21_strlen(dest);
  for (s21_size_t i = 0; i < n; i++) {
    dest[last] = src[i];
    last++;
  }
  dest[last] = '\0';
  return dest;
}

char *s21_strchr(const char *str, int c) {
  char *res = S21_NULL;
  if (str) {
    for (res = (char *)str; *res != '\0' && *res != c; ++res)
      ;
    if (c && *res == '\0') res = S21_NULL;
  }
  return res;
}

int s21_strncmp(const char *str1, const char *str2, s21_size_t n) {
  int res = 0;
  for (s21_size_t i = 0; i < n; i++) {
    if (str1[i] != str2[i]) {
      res = str1[i] - str2[i];
    }
    if (str1[i] == '\0' || res) {
      break;
    }
  }
  return res;
}

char *s21_strncpy(char *dest, const char *src, s21_size_t n) {
  for (s21_size_t i = 0; i != n; i++) {
    dest[i] = src[i];
  }
  return dest;
}

void *s21_to_upper(const char *str) {
  char *res = S21_NULL;
  if (str != S21_NULL) {
    int len = s21_strlen(str);
    res = (char *)malloc(len * sizeof(char) + 5);
    s21_size_t i;
    for (i = 0; str[i]; i++) {
      if (str[i] >= 'a' && str[i] <= 'z') {
        res[i] = str[i] - 32;
      } else {
        res[i] = str[i];
      }
    }
    res[i] = '\0';
  }
  return (void *)(res);
}

void *s21_to_lower(const char *str) {
  char *res = S21_NULL;
  if (str != S21_NULL) {
    int len = s21_strlen(str);
    res = (char *)malloc(len * sizeof(char) + 5);
    s21_size_t i;
    for (i = 0; str[i]; i++) {
      if (str[i] >= 'A' && str[i] <= 'Z') {
        res[i] = str[i] + 32;
      } else {
        res[i] = str[i];
      }
    }
    res[i] = '\0';
  }
  return (void *)(res);
}

s21_size_t s21_strcspn(const char *str1, const char *str2) {
  int count = 0;
  int k;
  int flag = 1;
  s21_size_t res = s21_strlen(str1);
  for (k = 0; k < (int)s21_strlen(str1) && flag; k++) {
    for (int i = 0; i < (int)s21_strlen(str2); i++) {
      if (str1[k] == str2[i]) {
        res = count;
        flag = 0;
        break;
      }
    }
    count++;
  }

  return res;
}

s21_size_t s21_strlen(const char *str) {
  int i = 0;
  while (str[i] != '\0') i++;
  return i;
}

char *s21_strpbrk(const char *str1, const char *str2) {
  int flg = 0;
  char *res = S21_NULL;
  for (int i = 0; i < (int)s21_strlen(str1) && flg == 0; i++)
    for (int j = 0; j < (int)s21_strlen(str2); j++) {
      if (str1[i] == str2[j]) {
        ++flg;
        res = (char *)str1 + i;
      }
    }
  return res;
}

char *s21_strrchr(const char *str, int c) {
  char *res = S21_NULL;
  while (*str != '\0') {
    if (*str == c) res = (char *)str;
    str++;
  }
  if (*str == c) res = (char *)str;
  return res;
}

char *s21_strstr(const char *haystack, const char *needle) {
  const char *k = needle;
  while (*haystack != '\0') {
    const char *h = haystack;
    while (*h == *k && *k != '\0') {
      h++;
      k++;
    }
    if (*k == '\0') break;
    haystack++;
  }
  return (*k == '\0') ? (char *)haystack : S21_NULL;
}

void *s21_insert(const char *src, const char *str, s21_size_t start_index) {
  char *tmp;
  if (!src || !str)
    tmp = NULL;
  else {
    tmp =
        (char *)malloc((s21_strlen(src) + s21_strlen(str)) * sizeof(char) + 5);
    if ((int)start_index > (int)s21_strlen(src) || (int)start_index < 0) {
      free(tmp);
      tmp = S21_NULL;
    } else {
      int n = 0;
      for (int i = 0; i < (int)start_index; i++) {
        tmp[n] = src[i];
        n++;
      }
      for (int j = 0; j < (int)s21_strlen(str); j++) {
        tmp[n] = str[j];
        n++;
      }
      for (int k = start_index; k < (int)s21_strlen(src); k++) {
        tmp[n] = src[k];
        n++;
      }
      tmp[n] = '\0';
    }
  }
  return tmp;
}

void *s21_trim(const char *src, const char *trim_chars) {
  char *tmp;
  if (!src || !trim_chars)
    tmp = NULL;
  else {
    tmp = (char *)malloc((int)s21_strlen(src) * sizeof(char) + 1);
    int n = 0;
    int flg = 0;

    for (int i = 0; i < (int)s21_strlen(src); i++) {
      for (int k = 0; k < (int)s21_strlen(trim_chars); k++) {
        if (src[i] == trim_chars[k]) flg = 1;
      }
      if (flg == 0) {
        tmp[n] = src[i];
        n++;
      }
      flg = 0;
    }
    tmp[n] = '\0';
  }
  return tmp;
}

char *s21_strerror(int errnum) {
  char *ERR[] = ERR_LIST;
  char *error;
#ifdef __linux__
  if (errnum >= 0 && errnum <= 132) error = ERR[errnum];
#endif
#ifdef __APPLE__
  if (errnum >= 0 && errnum <= 107) error = ERR[errnum];
#endif
  else
    error = "Unknown error";
  return error;
}

int s21_isDelimiter(const char c, const char *delim) {
  int result = s21_strchr(delim, c) != S21_NULL ? 1 : 0;
  return result;
}

char *s21_strtok(char *str, const char *delim) {
  char *start_of_token = S21_NULL;
  static char *next_token;

  if (str != S21_NULL) {
    next_token = str;
  }

  if (next_token != S21_NULL) {
    while (*next_token != '\0' && s21_isDelimiter(*next_token, delim)) {
      ++next_token;
    }

    if (*next_token != '\0') {
      start_of_token = next_token;

      while (*next_token != '\0' && !s21_isDelimiter(*next_token, delim)) {
        ++next_token;
      }

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

  return start_of_token;
}

char *s21_strcpy(char *destination, const char *source) {
  int i = 0;
  for (; source[i] != '\0'; ++i) destination[i] = source[i];
  destination[i] = source[i];
  return destination;
}