cne_strings.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright (c) 2019-2022 Intel Corporation.
 */
 
#ifndef _M_STRINGS_H_
#define _M_STRINGS_H_
 
#include <stdio.h>        // for NULL, snprintf
#include <ctype.h>
#include <stdint.h>        // for uint8_t, UINT16_MAX, UINT8_MAX, uint32_t
#include <stdlib.h>        // for strtoul
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <arpa/inet.h>        // for inet_ntop
#include <bsd/bsd.h>
#include <errno.h>             // for errno
#include <bsd/string.h>        // for strlcpy
#include <sys/socket.h>        // for AF_INET
 
#include <cne_common.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
enum {
    STR_MAX_ARGVS  = 64,  
    STR_TOKEN_SIZE = 128, 
};
 
static __inline__ char *
strtrimset(char *str, const char *set)
{
    if (!str || !*str || !set || (strlen(set) != 2))
        return NULL;
 
    /* Find the beginning set character, while trimming white space */
    while ((*str == set[0]) || isspace(*str))
        str++;
 
    if (*str) {
        char *p = &str[strlen(str) - 1];
 
        while ((p >= str) && (isspace(*p) || (*p == set[1])))
            p--;
 
        p[1] = '\0';
    }
 
    return str;
}
 
static __inline__ char *
strtrim_quotes(char *str)
{
    if (strlen(str) >= 2) {
        if (str[0] == '"')
            return strtrimset(str, "\"\"");
        else if (str[0] == '\'')
            return strtrimset(str, "''");
    }
    return str;
}
 
static __inline__ char *
strtrim(char *str)
{
    if (!str || !*str)
        return str;
 
    /* trim white space characters at the front */
    while (isspace(*str))
        str++;
 
    /* Make sure the string is not empty */
    if (*str) {
        char *p = &str[strlen(str) - 1];
 
        /* trim trailing white space characters */
        while ((p >= str) && isspace(*p))
            p--;
 
        p[1] = '\0';
    }
    return str;
}
 
static __inline__ int
cne_strtok(char *str, const char *delim, char *entries[], int maxtokens)
{
    int i = 0;
    char *saved;
 
    if (!str || !delim || !strlen(delim) || !entries || !maxtokens)
        return -1;
    if (!strlen(str))
        return 0;
 
    do {
        entries[i] = strtrim(strtok_r(str, delim, &saved));
        str        = NULL;
    } while (entries[i] && (++i < maxtokens));
 
    return i;
}
 
static __inline__ int
cne_strqtok(char *str, const char *delim, char *argv[], int maxtokens)
{
    char *p, *start_of_word, *s;
    int argc                                                             = 0;
    enum { INIT, WORD, STRING_QUOTE, STRING_TICK, STRING_BRACKET } state = WORD;
 
    if (!str || !delim || !argv || maxtokens == 0)
        return -1;
 
    /* Remove white space from start and end of string */
    s = strtrim(str);
 
    start_of_word = s;
    for (p = s; (argc < maxtokens) && (*p != '\0'); p++) {
        int c = (unsigned char)*p;
 
        if (c == '\\') {
            start_of_word = ++p;
            continue;
        }
 
        switch (state) {
        case INIT:
            if (c == '"') {
                state         = STRING_QUOTE;
                start_of_word = p + 1;
            } else if (c == '\'') {
                state         = STRING_TICK;
                start_of_word = p + 1;
            } else if (c == '{') {
                state         = STRING_BRACKET;
                start_of_word = p + 1;
            } else if (!strchr(delim, c)) {
                state         = WORD;
                start_of_word = p;
            }
            break;
 
        case STRING_QUOTE:
            if (c == '"') {
                *p           = 0;
                argv[argc++] = start_of_word;
                state        = INIT;
            }
            break;
 
        case STRING_TICK:
            if (c == '\'') {
                *p           = 0;
                argv[argc++] = start_of_word;
                state        = INIT;
            }
            break;
 
        case STRING_BRACKET:
            if (c == '}') {
                *p           = 0;
                argv[argc++] = start_of_word;
                state        = INIT;
            }
            break;
 
        case WORD:
            if (strchr(delim, c)) {
                *p            = 0;
                argv[argc++]  = start_of_word;
                state         = INIT;
                start_of_word = p + 1;
            }
            break;
 
        default:
            break;
        }
    }
 
    if ((state != INIT) && (argc < maxtokens))
        argv[argc++] = start_of_word;
 
    if ((argc == 0) && (p != str))
        argv[argc++] = str;
 
    argv[argc] = NULL;
 
    return argc;
}
 
static __inline__ char *
cne_strtolower(char *str)
{
    if (!str)
        return NULL;
 
    for (int i = 0; i <= (int)(strlen(str)); i++)
        str[i] = tolower(str[i]);
 
    return str;
}
 
static __inline__ char *
cne_strtoupper(char *str)
{
    if (!str)
        return NULL;
 
    for (int i = 0; i <= (int)(strlen(str)); i++)
        str[i] = toupper(str[i]);
 
    return str;
}
 
static __inline__ int
cne_stropt(const char *list, char *str, const char *delim)
{
    char *argv[STR_MAX_ARGVS + 1], *buf;
 
    if (!list || !str || !delim)
        return -1;
 
    if ((list[0] == '%') && (list[1] == '|'))
        list += 2;
 
    if (!*list)
        return -1;
 
    size_t n = strlen(list) + 2;
 
    buf = (char *)alloca(n);
    if (buf) {
        snprintf(buf, n, "%s", list);
 
        int nb = cne_strtok(buf, delim, argv, STR_MAX_ARGVS);
        if (nb < 0)
            return -1;
        for (int i = 0; i < nb; i++)
            if (!strcmp(argv[i], str))
                return i;
    }
 
    return -1;
}
 
static __inline__ char *
cne_strdupf(char *str, char *newstr)
{
    if (str)
        free(str);
    return (newstr == NULL) ? NULL : strdup(newstr);
}
 
static __inline__ int
cne_strcnt(char *s, char c)
{
    return (s == NULL || *s == '\0') ? 0 : cne_strcnt(s + 1, c) + (*s == c);
}
 
#ifndef _MASK_SIZE_
#define _MASK_SIZE_
static __inline__ int
mask_size(uint32_t mask)
{
    if (mask == 0)
        return 0;
    else if (mask == 0xFF000000)
        return 8;
    else if (mask == 0xFFFF0000)
        return 16;
    else if (mask == 0xFFFFFF00)
        return 24;
    else if (mask == 0xFFFFFFFF)
        return 32;
    else {
        int i;
        for (i = 0; i < 32; i++)
            if ((mask & (1 << (31 - i))) == 0)
                break;
        return i;
    }
}
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif /* _M_STRINGS_H_ */