stringsup.c

Go to the documentation of this file.

 
#include "user_config.h"
 
#include <string.h>
#include "stringsup.h"
 
// =============================================
// Character functions
// =============================================
 
// =============================================
MEMSPACE
int
WEAK_ATR
isdigit(int c)
{
    if(c >= '0' && c <= '9')
        return(1);
    return(0);
}
 
 
// =============================================
MEMSPACE
int
WEAK_ATR
isupper(int c)
{
    if(c >= 'A' && c <= 'Z')
        return(1);
    return(0);
}
 
 
// =============================================
//@brief Is a character lower case
MEMSPACE
int
WEAK_ATR
islower(int c)
{
    if(c >= 'a' && c <= 'z')
        return(1);
    return(0);
}
 
 
// =============================================
MEMSPACE
int
WEAK_ATR
tolower(int c)
{
    if(isupper(c))
        return(c - 'A' + 'a');
    return(c);
}
 
 
// =============================================
MEMSPACE
int
WEAK_ATR
toupper(int c)
{
    if(islower(c))
        return(c - 'a' + 'A');
    return(c);
}
 
 
MEMSPACE
void *memchr(const void *str, int c, size_t size)
{
    const uint8_t *ptr = str;
    while(size--)
    {
        if (*ptr++ == (uint8_t) c)
            return (void *) (ptr - 1);
    }
    return NULL;
}
 
 
// =============================================
// String functions
// =============================================
// =============================================
MEMSPACE
size_t
WEAK_ATR
strlen(const char *str)
{
    int len=0;
// String length
    while(*str++)
        ++len;
    return(len);
}
 
 
MEMSPACE
WEAK_ATR char *
strcpy(char *dest, const char *src)
{
    char *ptr = dest;
    while(*src)
    {
        *ptr++ = *src++;
    }
    *ptr ++ = 0;
    return (ptr);
}
 
 
MEMSPACE
WEAK_ATR
char * strncpy(char *dest, const char *src, size_t size)
{
    char *ptr = dest;
    while(*src && size)
    {
        *ptr++ = *src++;
        size--;
    }
    while(size--)
        *ptr++ = 0;
    return (dest);
}
 
 
MEMSPACE
WEAK_ATR
char * strcat(char *dest, const char *src)
{
    char *ptr = dest;
    while(*ptr)
        ++ptr;
    strcpy(ptr,src);
    return(dest);
}
 
 
MEMSPACE
WEAK_ATR
char * strncat(char *dest, const char *src, size_t max)
{
    char *ptr = dest;
    while(*ptr)
        ++ptr;
    strncpy(ptr,src,max);
    return(dest);
}
 
 
// =============================================
MEMSPACE
void
WEAK_ATR
reverse(char *str)
{
    char temp;
    int i;
    int len = strlen(str);
// Reverse
// We only exchange up to half way
    for (i = 0; i < (len >> 1); i++)
    {
        temp = str[len - i - 1];
        str[len - i - 1] = str[i];
        str[i] = temp;
    }
}
 
 
// =============================================
MEMSPACE
void
WEAK_ATR
strupper(char *str)
{
    while(*str)
    {
        *str = toupper(*str);
        ++str;
    }
}
 
 
// =============================================
// String Matching
// =============================================
MEMSPACE
int
WEAK_ATR
strcmp(const char *str, const char *pat)
{
    int ret = 0;
    int c1,c2;
    while (1)
    {
        c1 = *str++;
        c2 = *pat++;
        if ( (ret = c1 - c2) != 0 || c2 == 0)
            break;
    }
    return(ret);
}
 
 
// =============================================
MEMSPACE
int
WEAK_ATR
strncmp(const char *str, const char *pat, size_t len)
{
    int ret = 0;
    int c1,c2;
    while (len--)
    {
        c1 = *str++;
        c2 = *pat++;
        if ( (ret = c1 - c2) != 0 || c2 == 0)
            break;
    }
    return(ret);
}
 
 
// =============================================
MEMSPACE
int
WEAK_ATR
strcasecmp(const char *str, const char *pat)
{
    int ret = 0;
    int c1,c2;
    while (1)
    {
        c1 = toupper(*str++);
        c2 = toupper(*pat++);
        if ( (ret = c1 - c2) != 0 || c2 == 0)
            break;
    }
    return(ret);
}
 
 
MEMSPACE
int
WEAK_ATR
strncasecmp(const char *str, const char *pat, size_t len)
{
    int ret = 0;
    int c1,c2;
    while (len--)
    {
        c1 = toupper(*str++);
        c2 = toupper(*pat++);
        if ( (ret = c1 - c2) != 0 || c2 == 0)
            break;
    }
    return(ret);
}
 
 
// =============================================
// String memory allocation functions
// =============================================
// =============================================
 
MEMSPACE
char *strnalloc(char *str, int len)
{
    char *ptr;
 
    if(!str)
        return(NULL);
    ptr = safecalloc(len+1,1);
    if(!ptr)
        return(ptr);
    strncpy(ptr,str,len);
    return(ptr);
 
}
 
 
// =============================================
MEMSPACE
char *stralloc(char *str)
{
    char *ptr;
    int len;
 
    if(!str)
        return(str);;
    len  = strlen(str);
    ptr = safecalloc(len+1,1);
    if(!ptr)
        return(ptr);
    strcpy(ptr,str);
    return(ptr);
}