parsing.c

Go to the documentation of this file.

 
#include "user_config.h"
 
#include <inttypes.h>
#include <stdint.h>
 
#include <string.h>
#include "parsing.h"
 
// =============================================
MEMSPACE
void sep()
{
    printf("==============================\n");
}
 
 
// =============================================
MEMSPACE
void trim_tail(char *str)
{
    if(!str)
        return;
    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);
}
 
 
// =============================================
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(MATCHI(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)
{
 
    *token = 0;
 
    if(!str || *str == 0)
        return(str);
 
// Skip beginning spaces
    str = skipspaces(str);
// Delete all trailing spaces
    trim_tail(str);
 
    while(*str > ' ' && max > 0)
    {
 
// String processing
// A token can be a quoted string
        if(*str == '"')
        {
            ++str;
// We are pointing at the body of the quoted string now
            while(*str && *str != '"' && max > 0)
            {
                *token++ = *str++;
                --max;
            }
            if(*str == '"')
            {
                ++str;
                *token = 0;
                --max;
                break;
            }
            break;
        }
 
// If we have a comma, outside of a string, break
        if(*str == ',' )
            break;
 
// copy token
        *token++ = *str++;
        --max;
    }
 
// Skip trailing spaces
    str = skipspaces(str);
// If we had a trailing comma skip it
    if(*str == ',' )
        ++str;
 
    *token = 0;
    return(str);
}
 
 
// =============================================
 
MEMSPACE
int token(char *str, char *pat)
{
    int patlen;
    int len;
    char *ptr;
 
    if(!str || *str == 0)
        return(0);
 
    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;
 
    if(!str || *str == 0)
        return(0);
 
    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));
}
 
 
// =============================================