stringsup.c

Go to the documentation of this file.

#include "user_config.h"

#include <string.h>
#include "lib/stringsup.h"

// =============================================
MEMSPACE
void sep()
{
    printf("==============================\n");
}

// =============================================
// 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;
    }
}


// =============================================
MEMSPACE
void trim_tail(char *str)
{
    int len = strlen(str);
    while(len--)
    {
        if(str[len] > ' ')
            break;
        str[len] = 0;
    }
}

// =============================================
MEMSPACE
char *skipspaces(char *ptr)
{
    if(!ptr)
        return(ptr);

    while(*ptr == ' ' || *ptr == '\t')
        ++ptr;
    return(ptr);
}

// =============================================
MEMSPACE
char *nextspace(char *ptr)
{
    if(!ptr)
        return(ptr);

    while(*ptr)
    {
        if(*ptr == ' ' || *ptr == '\t')
            break;
        ++ptr;
    }
    return(ptr);
}

// =============================================
MEMSPACE
char *skipchars(char *str, char *pat)
{
    char *base;
    if(!str)
        return(str);

    while(*str)
    {
        base = pat;
        while(*base)
        {
            if(*base == *str)
                break;
            ++base;
        }
        if(*base != *str)
            return(str);
        ++str;
    }
    return(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);
}

// =============================================
MEMSPACE
int MATCH(char *str, char *pat)
{
    int len;
    len = strlen(pat);
    if(strcmp(str,pat) == 0 )
        return(len);
    return(0);
}
MEMSPACE
int MATCHARGS(char *str, char *pat, int min, int argc)
{
    if(MATCH(str,pat))
    {
        if(argc >= min)
            return(1);
        else
            printf("%s expected %d arguments only got %d\n", pat, min,argc);
    }
    return(0);
}


// =============================================
MEMSPACE
int MATCHI(char *str, char *pat)
{
    int len;
    len = strlen(pat);
    if(strcasecmp(str,pat) == 0 )
        return(len);
    return(0);
}
// =============================================
MEMSPACE
int MATCH_LEN(char *str, char *pat)
{
    int len;

    if(!str || !pat)
        return(0);
    len = strlen(pat);

    if( len )
    {
        if(strncmp(str,pat,len) == 0 )
            return(len);
    }
    return(0);
}

// =============================================
MEMSPACE
int MATCHI_LEN(char *str, char *pat)
{
    int len;

    if(!str || !pat)
        return(0);
    len = strlen(pat);

    if( len )
    {
        if(strncasecmp(str,pat,len) == 0 )
            return(len);
    }
    return(0);
}

// =============================================
MEMSPACE
int split_args(char *str, char *argv[], int max)
{
    int i;
    int count = 0;
    // NULL ?

    for(i=0;i<max;++i)
        argv[i] = NULL; 

    // You may replace argv[0]
    // argv[count++] = "main";

    if(!max)
        return(0);

    if(!str)
        return(0);

    while(*str && count < max)
    {
        str = skipspaces(str);
        if(!*str)
            break;

        // string processing
        if(*str == '"')
        {
            ++str;
            // Save string pointer
            argv[count++] = str;
            while(*str && *str != '"')
                ++str;
            if(*str == '"')
                *str++ = 0;
            continue;
        }

        argv[count++] = str;
        // Find size of token
        while(*str > ' ' && *str <= 0x7e)
            ++str;
        if(!*str)
            break;
        *str  = 0;
        ++str;
    }
    return(count);
}

// =============================================
MEMSPACE
char *get_token(char *str, char *token, int max)
{
    int len;

    *token = 0;

    // NULL ?
    if(!str)
        return(NULL);

    str = skipspaces(str);

    // Find size of token
    len = 0;
    while(*str > ' ' && *str <= 0x7e && len < max)
    {
        // clip token to max length
        if(len < max)
        {
            *token++ = *str++;
            ++len;
        }
    }
    *token = 0;
    // str points past the token
    if(!len)
        return(NULL);
    return(str);
}


// =============================================

MEMSPACE
int token(char *str, char *pat)
{
    int patlen;
    int len;
    char *ptr;

    ptr = skipspaces(str);
    len = 0;
    while(*ptr > ' ' && *ptr <= 0x7e )
    {
        ++len;
        ++ptr;
    }

    if(!len)
        return(0);

    patlen = strlen(pat);

    if(len != patlen)
        return(0);

    if(strncmp(str,pat,patlen) == 0)
        return(len);
    return(0);
}
// =============================================

MEMSPACE
int32_t get_value(char *str)
{ 
    int base;
    int ret;
    char *ptr;
    char *endptr;


    ptr = skipspaces(str);
    base = 10;

    // convert number base 10, 16, 8 and 2
    if( (ret = MATCHI_LEN(ptr,"0x")) )
    {
        base = 16;
        ptr += ret;
    }
    else if( (ret = MATCHI_LEN(ptr,"0o")) )
    {
        base = 8;
        ptr += ret;
    }
    else if( (ret = MATCHI_LEN(ptr,"0b")) )
    {
        base = 2;
        ptr += ret;
    }
    return(strtol(ptr, (char **)&endptr, base));
}

// =============================================
// 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);
}