path: root/src/string/mpu-str8ing.c

/***************************************************************
  MPU-STR8ING.C

       This file contains string operation functions for
       ordinary 8-bit C strings.

       PART OF : MPUIO - library .

       Copyright (C) 2000 - 2026  by Andrey V.Kosteltsev.
       All Rights Reserved.
 ***************************************************************/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <libmpuio.h>
#include <mpu-symbols.h>
#include <mpu-string.h>


/***************************************************************
  mpu_str8cat()

     Добавляет строку SRC в конец строки DEST.
     NOTE:
     ====
        Размер памяти, выделенной для размещения строки DEST,
        должен быть достаточен для размещения двух строк
        SRC и DEST. Например, код:

           __mpu_char8_t *dest = "string1 ";
           __mpu_char8_t *src  = "string2";

           mpu_str16cat( dest, src );

        даст ошибку на этапе выполнения программы.
 ***************************************************************/
__mpu_char8_t *
mpu_str8cat( __mpu_char8_t *dest, const __mpu_char8_t *src )
{
  return strcat( dest, src );
}


/***************************************************************
  mpu_str8chr()

     Поиск символа C в первых N символах строки S.
 ***************************************************************/
__mpu_char8_t *
mpu_str8chr( const __mpu_char8_t *s, int c )
{
  return strchr( s, c );
}


/***************************************************************
  mpu_str8chrnul()

     Поиск символа C в первых N символах строки S.
     Если символ не найден, функция возвращает указатель
     на завершающий нуль( '\0' ).
 ***************************************************************/
__mpu_char8_t *
mpu_str8chrnul( const __mpu_char8_t *s, int c )
{
  while( *s != '\0' && (__mpu_char8_t)*s != (__mpu_char8_t)c )
    ++s;

  return (__mpu_char8_t *)s;
}


/***************************************************************
  mpu_str8cmp()

     Сравнивает лексикографически строки S1 и S2.
     Возвращает значение:
        меньше нуля, если S1  < S2;
        равное нулю, если S1 == S2;
        больше нуля, если S1  > S2. 
 ***************************************************************/
int
mpu_str8cmp( const __mpu_char8_t *s1, const __mpu_char8_t *s2 )
{
  return strcmp( s1, s2 );
}


/***************************************************************
  mpu_str8cpy()

     Копирует SRC в DEST.
 ***************************************************************/
__mpu_char8_t *
mpu_str8cpy( __mpu_char8_t *dest, const __mpu_char8_t *src )
{
  return strcpy( dest, src );
}


/***************************************************************
  mpu_str8cspn()

     Возвращает длину начального сегмента строки S
     не содержашего ни одного символа из набора REJECT.
     Завершающий нуль не учитывается.

     Если S начинается с символа из набора REJECT,
     то функция возвращает 0.
 ***************************************************************/
__mpu_size_t
mpu_str8cspn( const __mpu_char8_t *s, const __mpu_char8_t *reject )
{
  return strcspn( s, reject );
}


/***************************************************************
  mpu_str8len()

     Возвращает длину строки S.
 ***************************************************************/
__mpu_size_t
mpu_str8len( const __mpu_char8_t *s )
{
  return strlen( s );
}


/***************************************************************
  mpu_str8ncat()

     Добавляет не более N символов из строки SRC
     в конец строки DEST.
     NOTE:
     ====
        Размер памяти, выделенной для размещения строки DEST,
        должен быть достаточен для размещения строки DEST и еще
        N символов плюс завершающий нуль. Например, код:

           __tx_char8_t *dest = "string1 ";
           __tx_char8_t *src  = "string2";

           __tx_str16ncat( dest, src, 7 );

        даст ошибку на этапе выполнения программы.
 ***************************************************************/
__mpu_char8_t *
mpu_str8ncat( __mpu_char8_t *dest, const __mpu_char8_t *src, __mpu_size_t n )
{
  return strncat( dest, src, n );
}


/***************************************************************
  mpu_str8ncmp()

     Сравнивает лексикографически не более N символов
     в строках S1 и S2.
     Возвращает значение:
        меньше нуля, если S1  < S2;
        равное нулю, если S1 == S2;
        больше нуля, если S1  > S2. 
 ***************************************************************/
int
mpu_str8ncmp( const __mpu_char8_t *s1, const __mpu_char8_t *s2, __mpu_size_t n )
{
  return strncmp( s1, s2, n );
}


/***************************************************************
  mpu_str8ncpy()

     Копирует не более N символов из SRC в DEST.
 ***************************************************************/
__mpu_char8_t *
mpu_str8ncpy( __mpu_char8_t *dest, const __mpu_char8_t *src, __mpu_size_t n )
{
  return strncpy( dest, src, n );
}


/***************************************************************
  mpu_str8nlen()

     Возвращает число равное длине строки S, но не большее
     чем MAXLEN.
 ***************************************************************/
__mpu_size_t
mpu_str8nlen( const __mpu_char8_t *s, __mpu_size_t maxlen )
{
  const __mpu_char8_t *p = s;

  while( maxlen != 0 && *p != '\0' )
  {
    ++p;
    --maxlen;
  }

  return (__mpu_size_t)(p - s);
}


/***************************************************************
  mpu_str8pbrk()

     Находит первое вхождение любого символа из набора ACCEPT
     в строке S.
 ***************************************************************/
__mpu_char8_t *
mpu_str8pbrk( const __mpu_char8_t *s, const __mpu_char8_t *accept )
{
  return strpbrk( s, accept );
}


/***************************************************************
  mpu_str8rchr()

     Поиск последнего вхождения символа C в строке S.
 ***************************************************************/
__mpu_char8_t *
mpu_str8rchr( const __mpu_char8_t *s, int c )
{
  return strrchr( s, c );
}


/***************************************************************
  mpu_str8spn()

     Возвращает длину начального сегмента строки S
     содержашего только символы из набора ACCEPT.
     Завершающий нуль не учитывается.

     Если S начинается с символа, не входящего в
     набор ACCEPT, то функция возвращает 0.
 ***************************************************************/
__mpu_size_t
mpu_str8spn( const __mpu_char8_t *s, const __mpu_char8_t *accept )
{
  return strspn( s, accept );
}


/***************************************************************
  mpu_str8str()

     Возвращает указатель на первое вхождение подстроки, адрес
     которой задается значением параметра NEEDLE, в строке,
     адрес которой задается значением параметра HAYSTACK.

     Возвращаемое значение:
        Указатель по строке HAYSTACK на символ, с которого
        начинается первое вхождение подстроки NEEDLE в строке
        HAYSTACK. Значение NULL, если вхождение не найдено.
 ***************************************************************/
__mpu_char8_t *
mpu_str8str( const __mpu_char8_t *haystack, const __mpu_char8_t *needle )
{
  return strstr( haystack, needle );
}


/***************************************************************
  mpu_str8rstr()

     Возвращает указатель на последнее вхождение подстроки,
     адрес которой задается значением параметра NEEDLE, в
     строке, адрес которой задается значением параметра
     HAYSTACK.

     Возвращаемое значение:
        Указатель по строке HAYSTACK на символ, с которого
        начинается последнее вхождение подстроки NEEDLE в
        строке HAYSTACK. Значение NULL, если вхождение не
        найдено. Значение HAYSTACK, если строка NEEDLE пуста.
 ***************************************************************/
__mpu_char8_t *
mpu_str8rstr( const __mpu_char8_t *haystack, const __mpu_char8_t *needle )
{
  const __mpu_char8_t *last = NULL;
  const __mpu_char8_t *p = haystack;
  __mpu_size_t nlen = strlen( needle );

  if( nlen == 0 )
    return (__mpu_char8_t *)(haystack + strlen( haystack ));

  while( (p = strstr( p, needle )) != NULL )
  {
    last = p;
    ++p;
  }

  return (__mpu_char8_t *)last;
}


/***************************************************************
  mpu_str8pcpy()

     Копирует SRC в DEST.
     Возвращает адрес завершающего нуля в DEST.
 ***************************************************************/
__mpu_char8_t *
mpu_str8pcpy( __mpu_char8_t *dest, const __mpu_char8_t *src )
{
  while( (*dest = *src) != '\0' )
  {
    ++dest;
    ++src;
  }

  return dest;
}


/***************************************************************
  mpu_str8pncpy()

     Копирует не более N символов из SRC в DEST.
     Возвращает адрес последнего скопированного символа в DEST.
 ***************************************************************/
__mpu_char8_t *
mpu_str8pncpy( __mpu_char8_t *dest, const __mpu_char8_t *src, __mpu_size_t n )
{
  __mpu_char8_t *p = dest;
  __mpu_char8_t *end;

  while( n != 0 && *src != '\0' )
  {
    *p++ = *src++;
    --n;
  }

  if( n == 0 )
    return p;

  end = p;
  while( n-- != 0 )
    *p++ = '\0';

  return end;
}


/***************************************************************
  mpu_str8tok()

     Разбор строки, расположенной по адресу S, на лексические
     единицы (tokens). Символы DELIM, находящиеся по адресу
     DELIM, используются как разделители лексических единиц.

     Если token заканчивается символом из набора DELIM,
     то разделитель (непосредственно следующий за token)
     заменяется нулем ('\0'), а функция mpu_str8tok()
     возвращает адрес следующего за разделителем символа.

     Каждый вызов mpu_str8tok() дает один token, и для разбора
     всей строки надо организовать цикл обращений к функции
     mpu_str8tok().

     Символы в наборе DELIM могут быть разными для каждого
     вызова функции mpu_str8tok().

     NOTE:
     ====
        Функция mpu_str8tok() изменяет содержимое памяти
        по адресу S.

        Функция mpu_str8tok() не может использоваться
        со строками имеющими тип const.

     Если S равен нулю, SAVE_PTR используется как указатель
     на следующую стартовую точку разбора. Например:

     __mpu_char8_t   s[] = "-abc-=-def";
     __mpu_char8_t  *sp;

     x = str8tok( s, "-", &sp );     // x = "abc", sp = "=-def"
     x = str8tok( NULL, "-=", &sp ); // x = "def", sp = NULL
     x = str8tok( NULL, "-=", &sp ); // x = NULL

     В результате содержимое S будет равно S = "-abc\0=-def\0".

     Возвращаемое значение:
        Указатель на следующую лексическую единицу или NULL,
        если таковых не осталось.
 ***************************************************************/
__mpu_char8_t *
mpu_str8tok( __mpu_char8_t *s, const __mpu_char8_t *delim )
{
  static MPU_THREAD_LOCAL __mpu_char8_t *saveptr;

  return mpu_str8tok_r( s, delim, &saveptr );
}


__mpu_char8_t *
mpu_str8tok_r( __mpu_char8_t *s, const __mpu_char8_t *delim, __mpu_char8_t **saveptr )
{
  __mpu_char8_t *token;

  if( s == NULL )
    s = *saveptr;

  s += strspn( s, delim );
  if( *s == '\0' )
  {
    *saveptr = s;
    return NULL;
  }

  token = s;
  s = strpbrk( token, delim );
  if( s == NULL )
    *saveptr = token + strlen( token );
  else
  {
    *s = '\0';
    *saveptr = s + 1;
  }

  return token;
}


__mpu_char8_t *
mpu_str8ndup( const __mpu_char8_t *s, __mpu_size_t n )
{
  __mpu_size_t len;
  __mpu_char8_t *copy;

  if( s == NULL )
  {
    errno = EINVAL;
    return NULL;
  }

  len = mpu_str8nlen( s, n );
  copy = (__mpu_char8_t *)malloc( len + 1 );
  if( copy == NULL )
    return NULL;

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


__mpu_char8_t *
mpu_str8dup( const __mpu_char8_t *s )
{
  __mpu_size_t len;
  __mpu_char8_t *copy;

  if( s == NULL )
  {
    errno = EINVAL;
    return NULL;
  }

  len = strlen( s ) + 1;
  copy = (__mpu_char8_t *)malloc( len );
  if( copy == NULL )
    return NULL;

  memcpy( copy, s, len );
  return copy;
}