string.h
Go to the documentation of this file.
/* Simple Plugin API
*
* Copyright © 2021 Red Hat, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
#ifndef SPA_UTILS_STRING_H
#define SPA_UTILS_STRING_H
#ifdef __cplusplus
extern "C" {
#endif
#include <stdarg.h>
#include <stdbool.h>
#include <errno.h>
#include <spa/utils/defs.h>
static inline bool spa_streq(const char *s1, const char *s2)
{
return SPA_LIKELY(s1 && s2) ? strcmp(s1, s2) == 0 : s1 == s2;
}
static inline bool spa_strneq(const char *s1, const char *s2, size_t len)
{
return SPA_LIKELY(s1 && s2) ? strncmp(s1, s2, len) == 0 : s1 == s2;
}
static inline bool spa_strstartswith(const char *s, const char *prefix)
{
if (SPA_UNLIKELY(s == NULL))
return false;
spa_assert_se(prefix);
return strncmp(s, prefix, strlen(prefix)) == 0;
}
static inline bool spa_strendswith(const char *s, const char *suffix)
{
size_t l1, l2;
if (SPA_UNLIKELY(s == NULL))
return false;
spa_assert_se(suffix);
l1 = strlen(s);
l2 = strlen(suffix);
return l1 >= l2 && spa_streq(s + l1 - l2, suffix);
}
static inline bool spa_atoi32(const char *str, int32_t *val, int base)
{
char *endptr;
long v;
if (!str || *str =='\0')
return false;
errno = 0;
v = strtol(str, &endptr, base);
if (errno != 0 || *endptr != '\0')
return false;
if (v != (int32_t)v)
return false;
*val = v;
return true;
}
static inline bool spa_atou32(const char *str, uint32_t *val, int base)
{
char *endptr;
unsigned long long v;
if (!str || *str =='\0')
return false;
errno = 0;
v = strtoull(str, &endptr, base);
if (errno != 0 || *endptr != '\0')
return false;
if (v != (uint32_t)v)
return false;
*val = v;
return true;
}
static inline bool spa_atoi64(const char *str, int64_t *val, int base)
{
char *endptr;
long long v;
if (!str || *str =='\0')
return false;
errno = 0;
v = strtoll(str, &endptr, base);
if (errno != 0 || *endptr != '\0')
return false;
*val = v;
return true;
}
static inline bool spa_atou64(const char *str, uint64_t *val, int base)
{
char *endptr;
unsigned long long v;
if (!str || *str =='\0')
return false;
errno = 0;
v = strtoull(str, &endptr, base);
if (errno != 0 || *endptr != '\0')
return false;
*val = v;
return true;
}
static inline bool spa_atob(const char *str)
{
return spa_streq(str, "true") || spa_streq(str, "1");
}
SPA_PRINTF_FUNC(3, 0)
static inline int spa_vscnprintf(char *buffer, size_t size, const char *format, va_list args)
{
int r;
spa_assert_se((ssize_t)size > 0);
r = vsnprintf(buffer, size, format, args);
if (SPA_UNLIKELY(r < 0))
buffer[0] = '\0';
if (SPA_LIKELY(r < (ssize_t)size))
return r;
return size - 1;
}
SPA_PRINTF_FUNC(3, 4)
static inline int spa_scnprintf(char *buffer, size_t size, const char *format, ...)
{
int r;
va_list args;
va_start(args, format);
r = spa_vscnprintf(buffer, size, format, args);
va_end(args);
return r;
}
static inline bool spa_atof(const char *str, float *val)
{
char *endptr;
float v;
if (!str || *str =='\0')
return false;
errno = 0;
v = strtof(str, &endptr);
if (errno != 0 || *endptr != '\0')
return false;
*val = v;
return true;
}
static inline bool spa_atod(const char *str, double *val)
{
char *endptr;
double v;
if (!str || *str =='\0')
return false;
errno = 0;
v = strtod(str, &endptr);
if (errno != 0 || *endptr != '\0')
return false;
*val = v;
return true;
}
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* SPA_UTILS_STRING_H */
defs.h
spa/utils/defs.h
spa_atod
static bool spa_atod(const char *str, double *val)
Convert str to a double and store the result in val.
Definition: string.h:302
spa_atou64
static bool spa_atou64(const char *str, uint64_t *val, int base)
Convert str to an uint64_t with the given base and store the result in val.
Definition: string.h:199
spa_strstartswith
static bool spa_strstartswith(const char *s, const char *prefix)
Definition: string.h:80
spa_atob
static bool spa_atob(const char *str)
Convert str to a boolean.
Definition: string.h:222
spa_atoi64
static bool spa_atoi64(const char *str, int64_t *val, int base)
Convert str to an int64_t with the given base and store the result in val.
Definition: string.h:174
spa_atou32
static bool spa_atou32(const char *str, uint32_t *val, int base)
Convert str to an uint32_t with the given base and store the result in val.
Definition: string.h:146
spa_atoi32
static bool spa_atoi32(const char *str, int32_t *val, int base)
Convert str to an int32_t with the given base and store the result in val.
Definition: string.h:118
spa_strendswith
static bool spa_strendswith(const char *s, const char *suffix)
Definition: string.h:96
spa_strneq
static bool spa_strneq(const char *s1, const char *s2, size_t len)
Definition: string.h:69
spa_vscnprintf
static int spa_vscnprintf(char *buffer, size_t size, const char *format, va_list args)
Definition: string.h:236
spa_streq
static bool spa_streq(const char *s1, const char *s2)
Definition: string.h:59
spa_atof
static bool spa_atof(const char *str, float *val)
Convert str to a float and store the result in val.
Definition: string.h:278
spa_scnprintf
static int spa_scnprintf(char *buffer, size_t size, const char *format,...)
Definition: string.h:259
spa_assert_se
#define spa_assert_se(expr)
Definition: defs.h:345
SPA_LIKELY
#define SPA_LIKELY(x)
Definition: defs.h:313
SPA_PRINTF_FUNC
#define SPA_PRINTF_FUNC(fmt, arg1)
Definition: defs.h:260
SPA_UNLIKELY
#define SPA_UNLIKELY(x)
Definition: defs.h:315