dbutils: comparison ucx/cx/string.h

-:80f9d007cb52
+:0aa8cbd7912e
 #include "allocator.h"
 /**
 * The maximum length of the "needle" in cx_strstr() that can use SBO.
 */
-extern unsigned const cx_strstr_sbo_size;
+extern const unsigned cx_strstr_sbo_size;
 /**
 * The UCX string structure.
 */
 struct cx_mutstr_s {
 /**
 * A pointer to the immutable string.
 * \note The string is not necessarily \c NULL terminated.
 * Always use the length.
 */
-char const *ptr;
+const char *ptr;
 /** The length of the string */
 size_t length;
 };
 /**
 */
 cxstring delim;
 /**
 * Optional array of more delimiters.
 */
-cxstring const *delim_more;
+const cxstring *delim_more;
 /**
 * Length of the array containing more delimiters.
 */
 size_t delim_more_count;
 /**
 * @param cstring the string to wrap, must be zero-terminated
 * @return the wrapped string
 *
 * @see cx_mutstrn()
 */
-__attribute__((__warn_unused_result__, __nonnull__))
+cx_attr_nonnull
+cx_attr_nodiscard
+cx_attr_cstr_arg(1)
 cxmutstr cx_mutstr(char *cstring);
 /**
 * Wraps a string that does not need to be zero-terminated.
 *
 * @param length   the length of the string
 * @return the wrapped string
 *
 * @see cx_mutstr()
 */
-__attribute__((__warn_unused_result__))
+cx_attr_nodiscard
+cx_attr_access_rw(1, 2)
 cxmutstr cx_mutstrn(
 char *cstring,
 size_t length
 );
 * @param cstring the string to wrap, must be zero-terminated
 * @return the wrapped string
 *
 * @see cx_strn()
 */
-__attribute__((__warn_unused_result__, __nonnull__))
+cx_attr_nonnull
-cxstring cx_str(char const *cstring);
+cx_attr_nodiscard
+cx_attr_cstr_arg(1)
+cxstring cx_str(const char *cstring);
 /**
 * Wraps a string that does not need to be zero-terminated.
 *
 * @param length   the length of the string
 * @return the wrapped string
 *
 * @see cx_str()
 */
-__attribute__((__warn_unused_result__))
+cx_attr_nodiscard
+cx_attr_access_r(1, 2)
 cxstring cx_strn(
-char const *cstring,
+const char *cstring,
 size_t length
 );
+#ifdef __cplusplus
+} // extern "C"
+cx_attr_nodiscard
+static inline cxstring cx_strcast(cxmutstr str) {
+return cx_strn(str.ptr, str.length);
+}
+cx_attr_nodiscard
+static inline cxstring cx_strcast(cxstring str) {
+return str;
+}
+extern "C" {
+#else
+/**
+* Internal function, do not use.
+* @param str
+* @return
+* @see cx_strcast()
+*/
+cx_attr_nodiscard
+static inline cxstring cx_strcast_m(cxmutstr str) {
+return (cxstring) {str.ptr, str.length};
+}
+/**
+* Internal function, do not use.
+* @param str
+* @return
+* @see cx_strcast()
+*/
+cx_attr_nodiscard
+static inline cxstring cx_strcast_c(cxstring str) {
+return str;
+}
 /**
 * Casts a mutable string to an immutable string.
 *
-* \note This is not seriously a cast. Instead you get a copy
+* Does nothing for already immutable strings.
+*
+* \note This is not seriously a cast. Instead, you get a copy
 * of the struct with the desired pointer type. Both structs still
 * point to the same location, though!
 *
 * @param str the mutable string to cast
 * @return an immutable copy of the string pointer
 */
-__attribute__((__warn_unused_result__))
+#define cx_strcast(str) _Generic((str), \
-cxstring cx_strcast(cxmutstr str);
+cxmutstr: cx_strcast_m, \
+cxstring: cx_strcast_c) \
+(str)
+#endif
 /**
 * Passes the pointer in this string to \c free().
 *
 * The pointer in the struct is set to \c NULL and the length is set to zero.
 *
 * \note There is no implementation for cxstring, because it is unlikely that
-* you ever have a \c char \c const* you are really supposed to free. If you
+* you ever have a <code>const char*</code> you are really supposed to free.
-* encounter such situation, you should double-check your code.
+* If you encounter such situation, you should double-check your code.
 *
 * @param str the string to free
 */
-__attribute__((__nonnull__))
 void cx_strfree(cxmutstr *str);
 /**
 * Passes the pointer in this string to the allocators free function.
 *
 * The pointer in the struct is set to \c NULL and the length is set to zero.
 *
 * \note There is no implementation for cxstring, because it is unlikely that
-* you ever have a \c char \c const* you are really supposed to free. If you
+* you ever have a <code>const char*</code> you are really supposed to free.
-* encounter such situation, you should double-check your code.
+* If you encounter such situation, you should double-check your code.
 *
 * @param alloc the allocator
 * @param str the string to free
 */
-__attribute__((__nonnull__))
+cx_attr_nonnull_arg(1)
 void cx_strfree_a(
-CxAllocator const *alloc,
+const CxAllocator *alloc,
 cxmutstr *str
 );
 /**
 * Returns the accumulated length of all specified strings.
+*
+* If this sum overflows, errno is set to EOVERFLOW.
 *
 * \attention if the count argument is larger than the number of the
 * specified strings, the behavior is undefined.
 *
 * @param count    the total number of specified strings
 * @param ...      all strings
 * @return the accumulated length of all strings
 */
-__attribute__((__warn_unused_result__))
+cx_attr_nodiscard
 size_t cx_strlen(
 size_t count,
 ...
 );
 * So developers \em must pass the return value to cx_strfree_a() eventually.
 *
 * If \p str already contains a string, the memory will be reallocated and
 * the other strings are appended. Otherwise, new memory is allocated.
 *
-* \note It is guaranteed that there is only one allocation.
+* If memory allocation fails, the pointer in the returned string will
+* be \c NULL. Depending on the allocator, \c errno might be set.
+*
+* \note It is guaranteed that there is only one allocation for the
+* resulting string.
 * It is also guaranteed that the returned string is zero-terminated.
 *
 * @param alloc the allocator to use
 * @param str   the string the other strings shall be concatenated to
 * @param count the number of the other following strings to concatenate
 * @param ...   all other strings
 * @return the concatenated string
 */
-__attribute__((__warn_unused_result__, __nonnull__))
+cx_attr_nodiscard
+cx_attr_nonnull
 cxmutstr cx_strcat_ma(
-CxAllocator const *alloc,
+const CxAllocator *alloc,
 cxmutstr str,
 size_t count,
 ...
 );
 * Concatenates strings and returns a new string.
 *
 * The resulting string will be allocated by the specified allocator.
 * So developers \em must pass the return value to cx_strfree_a() eventually.
 *
-* \note It is guaranteed that there is only one allocation.
+* If memory allocation fails, the pointer in the returned string will
+* be \c NULL. Depending on the allocator, \c errno might be set.
+*
+* \note It is guaranteed that there is only one allocation for the
+* resulting string.
 * It is also guaranteed that the returned string is zero-terminated.
 *
 * @param alloc the allocator to use
 * @param count the number of the other following strings to concatenate
 * @param ...   all other strings
 * Concatenates strings and returns a new string.
 *
 * The resulting string will be allocated by standard \c malloc().
 * So developers \em must pass the return value to cx_strfree() eventually.
 *
-* \note It is guaranteed that there is only one allocation.
+* If memory allocation fails, the pointer in the returned string will
+* be \c NULL and \c errno might be set.
+*
+* \note It is guaranteed that there is only one allocation for the
+* resulting string.
 * It is also guaranteed that the returned string is zero-terminated.
 *
 * @param count   the number of the other following strings to concatenate
 * @param ...     all other strings
 * @return the concatenated string
 * So developers \em must pass the return value to cx_strfree() eventually.
 *
 * If \p str already contains a string, the memory will be reallocated and
 * the other strings are appended. Otherwise, new memory is allocated.
 *
-* \note It is guaranteed that there is only one allocation.
+* If memory allocation fails, the pointer in the returned string will
+* be \c NULL and \c errno might be set.
+*
+* \note It is guaranteed that there is only one allocation for the
+* resulting string.
 * It is also guaranteed that the returned string is zero-terminated.
 *
 * @param str     the string the other strings shall be concatenated to
 * @param count   the number of the other following strings to concatenate
 * @param ...     all other strings
 *
 * @see cx_strsubsl()
 * @see cx_strsubs_m()
 * @see cx_strsubsl_m()
 */
-__attribute__((__warn_unused_result__))
+cx_attr_nodiscard
 cxstring cx_strsubs(
 cxstring string,
 size_t start
 );
 *
 * @see cx_strsubs()
 * @see cx_strsubs_m()
 * @see cx_strsubsl_m()
 */
-__attribute__((__warn_unused_result__))
+cx_attr_nodiscard
 cxstring cx_strsubsl(
 cxstring string,
 size_t start,
 size_t length
 );
 *
 * @see cx_strsubsl_m()
 * @see cx_strsubs()
 * @see cx_strsubsl()
 */
-__attribute__((__warn_unused_result__))
+cx_attr_nodiscard
 cxmutstr cx_strsubs_m(
 cxmutstr string,
 size_t start
 );
 *
 * @see cx_strsubs_m()
 * @see cx_strsubs()
 * @see cx_strsubsl()
 */
-__attribute__((__warn_unused_result__))
+cx_attr_nodiscard
 cxmutstr cx_strsubsl_m(
 cxmutstr string,
 size_t start,
 size_t length
 );
 * @param chr    the character to locate
 * @return       a substring starting at the first location of \p chr
 *
 * @see cx_strchr_m()
 */
-__attribute__((__warn_unused_result__))
+cx_attr_nodiscard
 cxstring cx_strchr(
 cxstring string,
 int chr
 );
 * @param chr    the character to locate
 * @return       a substring starting at the first location of \p chr
 *
 * @see cx_strchr()
 */
-__attribute__((__warn_unused_result__))
+cx_attr_nodiscard
 cxmutstr cx_strchr_m(
 cxmutstr string,
 int chr
 );
 * @param chr    the character to locate
 * @return       a substring starting at the last location of \p chr
 *
 * @see cx_strrchr_m()
 */
-__attribute__((__warn_unused_result__))
+cx_attr_nodiscard
 cxstring cx_strrchr(
 cxstring string,
 int chr
 );
 * @param chr    the character to locate
 * @return       a substring starting at the last location of \p chr
 *
 * @see cx_strrchr()
 */
-__attribute__((__warn_unused_result__))
+cx_attr_nodiscard
 cxmutstr cx_strrchr_m(
 cxmutstr string,
 int chr
 );
 * @return       a substring starting at the first occurrence of
 *               \p needle, or an empty string, if the sequence is not
 *               contained
 * @see cx_strstr_m()
 */
-__attribute__((__warn_unused_result__))
+cx_attr_nodiscard
 cxstring cx_strstr(
 cxstring haystack,
 cxstring needle
 );
 * @return       a substring starting at the first occurrence of
 *               \p needle, or an empty string, if the sequence is not
 *               contained
 * @see cx_strstr()
 */
-__attribute__((__warn_unused_result__))
+cx_attr_nodiscard
 cxmutstr cx_strstr_m(
 cxmutstr haystack,
 cxstring needle
 );
 * @param delim  the delimiter
 * @param limit the maximum number of split items
 * @param output a pre-allocated array of at least \p limit length
 * @return the actual number of split items
 */
-__attribute__((__warn_unused_result__, __nonnull__))
+cx_attr_nodiscard
+cx_attr_nonnull
+cx_attr_access_w(4, 3)
 size_t cx_strsplit(
 cxstring string,
 cxstring delim,
 size_t limit,
 cxstring *output
 * @param limit the maximum number of split items
 * @param output a pointer where the address of the allocated array shall be
 * written to
 * @return the actual number of split items
 */
-__attribute__((__warn_unused_result__, __nonnull__))
+cx_attr_nodiscard
+cx_attr_nonnull
+cx_attr_access_w(5)
 size_t cx_strsplit_a(
-CxAllocator const *allocator,
+const CxAllocator *allocator,
 cxstring string,
 cxstring delim,
 size_t limit,
 cxstring **output
 );
 * @param delim  the delimiter
 * @param limit the maximum number of split items
 * @param output a pre-allocated array of at least \p limit length
 * @return the actual number of split items
 */
-__attribute__((__warn_unused_result__, __nonnull__))
+cx_attr_nodiscard
+cx_attr_nonnull
+cx_attr_access_w(4, 3)
 size_t cx_strsplit_m(
 cxmutstr string,
 cxstring delim,
 size_t limit,
 cxmutstr *output
 * @param limit the maximum number of split items
 * @param output a pointer where the address of the allocated array shall be
 * written to
 * @return the actual number of split items
 */
-__attribute__((__warn_unused_result__, __nonnull__))
+cx_attr_nodiscard
+cx_attr_nonnull
+cx_attr_access_w(5)
 size_t cx_strsplit_ma(
-CxAllocator const *allocator,
+const CxAllocator *allocator,
 cxmutstr string,
 cxstring delim,
 size_t limit,
 cxmutstr **output
 );
 * @param s1 the first string
 * @param s2 the second string
 * @return negative if \p s1 is smaller than \p s2, positive if \p s1 is larger
 * than \p s2, zero if both strings equal
 */
-__attribute__((__warn_unused_result__))
+cx_attr_nodiscard
 int cx_strcmp(
 cxstring s1,
 cxstring s2
 );
 * @param s1 the first string
 * @param s2 the second string
 * @return negative if \p s1 is smaller than \p s2, positive if \p s1 is larger
 * than \p s2, zero if both strings equal ignoring case
 */
-__attribute__((__warn_unused_result__))
+cx_attr_nodiscard
 int cx_strcasecmp(
 cxstring s1,
 cxstring s2
 );
 * @param s1 the first string
 * @param s2 the second string
 * @return negative if \p s1 is smaller than \p s2, positive if \p s1 is larger
 * than \p s2, zero if both strings equal
 */
-__attribute__((__warn_unused_result__, __nonnull__))
+cx_attr_nodiscard
+cx_attr_nonnull
 int cx_strcmp_p(
-void const *s1,
+const void *s1,
-void const *s2
+const void *s2
 );
 /**
 * Compares two strings ignoring case.
 *
 * @param s1 the first string
 * @param s2 the second string
 * @return negative if \p s1 is smaller than \p s2, positive if \p s1 is larger
 * than \p s2, zero if both strings equal ignoring case
 */
-__attribute__((__warn_unused_result__, __nonnull__))
+cx_attr_nodiscard
+cx_attr_nonnull
 int cx_strcasecmp_p(
-void const *s1,
+const void *s1,
-void const *s2
+const void *s2
 );
 /**
 * Creates a duplicate of the specified string.
 * @param allocator the allocator to use
 * @param string the string to duplicate
 * @return a duplicate of the string
 * @see cx_strdup()
 */
-__attribute__((__warn_unused_result__, __nonnull__))
+cx_attr_nodiscard
+cx_attr_nonnull
 cxmutstr cx_strdup_a(
-CxAllocator const *allocator,
+const CxAllocator *allocator,
 cxstring string
 );
 /**
 * Creates a duplicate of the specified string.
 * must \em not free the returned memory.
 *
 * @param string the string that shall be trimmed
 * @return the trimmed string
 */
-__attribute__((__warn_unused_result__))
+cx_attr_nodiscard
 cxstring cx_strtrim(cxstring string);
 /**
 * Omits leading and trailing spaces.
 *
 * must \em not free the returned memory.
 *
 * @param string the string that shall be trimmed
 * @return the trimmed string
 */
-__attribute__((__warn_unused_result__))
+cx_attr_nodiscard
 cxmutstr cx_strtrim_m(cxmutstr string);
 /**
 * Checks, if a string has a specific prefix.
 *
 * @param string the string to check
 * @param prefix the prefix the string should have
 * @return \c true, if and only if the string has the specified prefix,
 * \c false otherwise
 */
-__attribute__((__warn_unused_result__))
+cx_attr_nodiscard
 bool cx_strprefix(
 cxstring string,
 cxstring prefix
 );
 * @param string the string to check
 * @param suffix the suffix the string should have
 * @return \c true, if and only if the string has the specified suffix,
 * \c false otherwise
 */
-__attribute__((__warn_unused_result__))
+cx_attr_nodiscard
 bool cx_strsuffix(
 cxstring string,
 cxstring suffix
 );
 * @param string the string to check
 * @param prefix the prefix the string should have
 * @return \c true, if and only if the string has the specified prefix,
 * \c false otherwise
 */
-__attribute__((__warn_unused_result__))
+cx_attr_nodiscard
 bool cx_strcaseprefix(
 cxstring string,
 cxstring prefix
 );
 * @param string the string to check
 * @param suffix the suffix the string should have
 * @return \c true, if and only if the string has the specified suffix,
 * \c false otherwise
 */
-__attribute__((__warn_unused_result__))
+cx_attr_nodiscard
 bool cx_strcasesuffix(
 cxstring string,
 cxstring suffix
 );
 * @param pattern the pattern to search for
 * @param replacement the replacement string
 * @param replmax maximum number of replacements
 * @return the resulting string after applying the replacements
 */
-__attribute__((__warn_unused_result__, __nonnull__))
+cx_attr_nodiscard
+cx_attr_nonnull
 cxmutstr cx_strreplacen_a(
-CxAllocator const *allocator,
+const CxAllocator *allocator,
 cxstring str,
 cxstring pattern,
 cxstring replacement,
 size_t replmax
 );
 * @param str the string to tokenize
 * @param delim the delimiter (must not be empty)
 * @param limit the maximum number of tokens that shall be returned
 * @return a new string tokenization context
 */
-__attribute__((__warn_unused_result__))
+cx_attr_nodiscard
 CxStrtokCtx cx_strtok(
 cxstring str,
 cxstring delim,
 size_t limit
 );
 * @param str the string to tokenize
 * @param delim the delimiter (must not be empty)
 * @param limit the maximum number of tokens that shall be returned
 * @return a new string tokenization context
 */
-__attribute__((__warn_unused_result__))
+cx_attr_nodiscard
 CxStrtokCtx cx_strtok_m(
 cxmutstr str,
 cxstring delim,
 size_t limit
 );
 * @param ctx the tokenization context
 * @param token a pointer to memory where the next token shall be stored
 * @return true if successful, false if the limit or the end of the string
 * has been reached
 */
-__attribute__((__warn_unused_result__, __nonnull__))
+cx_attr_nonnull
+cx_attr_nodiscard
+cx_attr_access_w(2)
 bool cx_strtok_next(
 CxStrtokCtx *ctx,
 cxstring *token
 );
 * @param ctx the tokenization context
 * @param token a pointer to memory where the next token shall be stored
 * @return true if successful, false if the limit or the end of the string
 * has been reached
 */
-__attribute__((__warn_unused_result__, __nonnull__))
+cx_attr_nonnull
+cx_attr_nodiscard
+cx_attr_access_w(2)
 bool cx_strtok_next_m(
 CxStrtokCtx *ctx,
 cxmutstr *token
 );
 *
 * @param ctx the tokenization context
 * @param delim array of more delimiters
 * @param count number of elements in the array
 */
-__attribute__((__nonnull__))
+cx_attr_nonnull
+cx_attr_access_r(2, 3)
 void cx_strtok_delim(
 CxStrtokCtx *ctx,
-cxstring const *delim,
+const cxstring *delim,
 size_t count
 );
+/* ------------------------------------------------------------------------- *
+*                string to number conversion functions                      *
+* ------------------------------------------------------------------------- */
+/**
+* \copydoc cx_strtouz_lc()
+*/
+cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+int cx_strtos_lc(cxstring str, short *output, int base, const char *groupsep);
+/**
+* \copydoc cx_strtouz_lc()
+*/
+cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+int cx_strtoi_lc(cxstring str, int *output, int base, const char *groupsep);
+/**
+* \copydoc cx_strtouz_lc()
+*/
+cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+int cx_strtol_lc(cxstring str, long *output, int base, const char *groupsep);
+/**
+* \copydoc cx_strtouz_lc()
+*/
+cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+int cx_strtoll_lc(cxstring str, long long *output, int base, const char *groupsep);
+/**
+* \copydoc cx_strtouz_lc()
+*/
+cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+int cx_strtoi8_lc(cxstring str, int8_t *output, int base, const char *groupsep);
+/**
+* \copydoc cx_strtouz_lc()
+*/
+cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+int cx_strtoi16_lc(cxstring str, int16_t *output, int base, const char *groupsep);
+/**
+* \copydoc cx_strtouz_lc()
+*/
+cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+int cx_strtoi32_lc(cxstring str, int32_t *output, int base, const char *groupsep);
+/**
+* \copydoc cx_strtouz_lc()
+*/
+cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+int cx_strtoi64_lc(cxstring str, int64_t *output, int base, const char *groupsep);
+/**
+* \copydoc cx_strtouz_lc()
+*/
+cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+int cx_strtoz_lc(cxstring str, ssize_t *output, int base, const char *groupsep);
+/**
+* \copydoc cx_strtouz_lc()
+*/
+cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+int cx_strtous_lc(cxstring str, unsigned short *output, int base, const char *groupsep);
+/**
+* \copydoc cx_strtouz_lc()
+*/
+cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+int cx_strtou_lc(cxstring str, unsigned int *output, int base, const char *groupsep);
+/**
+* \copydoc cx_strtouz_lc()
+*/
+cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+int cx_strtoul_lc(cxstring str, unsigned long *output, int base, const char *groupsep);
+/**
+* \copydoc cx_strtouz_lc()
+*/
+cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+int cx_strtoull_lc(cxstring str, unsigned long long *output, int base, const char *groupsep);
+/**
+* \copydoc cx_strtouz_lc()
+*/
+cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+int cx_strtou8_lc(cxstring str, uint8_t *output, int base, const char *groupsep);
+/**
+* \copydoc cx_strtouz_lc()
+*/
+cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+int cx_strtou16_lc(cxstring str, uint16_t *output, int base, const char *groupsep);
+/**
+* \copydoc cx_strtouz_lc()
+*/
+cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+int cx_strtou32_lc(cxstring str, uint32_t *output, int base, const char *groupsep);
+/**
+* \copydoc cx_strtouz_lc()
+*/
+cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+int cx_strtou64_lc(cxstring str, uint64_t *output, int base, const char *groupsep);
+/**
+* Converts a string to a number.
+*
+* The function returns non-zero when conversion is not possible.
+* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
+* It sets errno to ERANGE when the target datatype is too small.
+*
+* @param str the string to convert
+* @param output a pointer to the integer variable where the result shall be stored
+* @param base 2, 8, 10, or 16
+* @param groupsep each character in this string is treated as group separator and ignored during conversion
+* @return zero on success, non-zero if conversion was not possible
+*/
+cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+int cx_strtouz_lc(cxstring str, size_t *output, int base, const char *groupsep);
+/**
+* Converts a string to a single precision floating point number.
+*
+* The function returns non-zero when conversion is not possible.
+* In that case the function sets errno to EINVAL when the reason is an invalid character.
+* It sets errno to ERANGE when the necessary representation would exceed the limits defined in libc's float.h.
+*
+* The decimal separator is assumed to be a dot character.
+* The comma character is treated as group separator and ignored during parsing.
+* If you want to choose a different format, use cx_strtof_lc().
+*
+* @param str the string to convert
+* @param output a pointer to the float variable where the result shall be stored
+* @param decsep the decimal separator
+* @param groupsep each character in this string is treated as group separator and ignored during conversion
+* @return zero on success, non-zero if conversion was not possible
+*/
+cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+int cx_strtof_lc(cxstring str, float *output, char decsep, const char *groupsep);
+/**
+* Converts a string to a double precision floating point number.
+*
+* The function returns non-zero when conversion is not possible.
+* In that case the function sets errno to EINVAL when the reason is an invalid character.
+* It sets errno to ERANGE when the necessary representation would exceed the limits defined in libc's float.h.
+*
+* The decimal separator is assumed to be a dot character.
+* The comma character is treated as group separator and ignored during parsing.
+* If you want to choose a different format, use cx_strtof_lc().
+*
+* @param str the string to convert
+* @param output a pointer to the float variable where the result shall be stored
+* @param decsep the decimal separator
+* @param groupsep each character in this string is treated as group separator and ignored during conversion
+* @return zero on success, non-zero if conversion was not possible
+*/
+cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+int cx_strtod_lc(cxstring str, double *output, char decsep, const char *groupsep);
+#ifndef CX_STR_IMPLEMENTATION
+/**
+* \copydoc cx_strtouz_lc()
+*/
+#define cx_strtos_lc(str, output, base, groupsep) cx_strtos_lc(cx_strcast(str), output, base, groupsep)
+/**
+* \copydoc cx_strtouz_lc()
+*/
+#define cx_strtoi_lc(str, output, base, groupsep) cx_strtoi_lc(cx_strcast(str), output, base, groupsep)
+/**
+* \copydoc cx_strtouz_lc()
+*/
+#define cx_strtol_lc(str, output, base, groupsep) cx_strtol_lc(cx_strcast(str), output, base, groupsep)
+/**
+* \copydoc cx_strtouz_lc()
+*/
+#define cx_strtoll_lc(str, output, base, groupsep) cx_strtoll_lc(cx_strcast(str), output, base, groupsep)
+/**
+* \copydoc cx_strtouz_lc()
+*/
+#define cx_strtoi8_lc(str, output, base, groupsep) cx_strtoi8_lc(cx_strcast(str), output, base, groupsep)
+/**
+* \copydoc cx_strtouz_lc()
+*/
+#define cx_strtoi16_lc(str, output, base, groupsep) cx_strtoi16_lc(cx_strcast(str), output, base, groupsep)
+/**
+* \copydoc cx_strtouz_lc()
+*/
+#define cx_strtoi32_lc(str, output, base, groupsep) cx_strtoi32_lc(cx_strcast(str), output, base, groupsep)
+/**
+* \copydoc cx_strtouz_lc()
+*/
+#define cx_strtoi64_lc(str, output, base, groupsep) cx_strtoi64_lc(cx_strcast(str), output, base, groupsep)
+/**
+* \copydoc cx_strtouz_lc()
+*/
+#define cx_strtoz_lc(str, output, base, groupsep) cx_strtoz_lc(cx_strcast(str), output, base, groupsep)
+/**
+* \copydoc cx_strtouz_lc()
+*/
+#define cx_strtous_lc(str, output, base, groupsep) cx_strtous_lc(cx_strcast(str), output, base, groupsep)
+/**
+* \copydoc cx_strtouz_lc()
+*/
+#define cx_strtou_lc(str, output, base, groupsep) cx_strtou_lc(cx_strcast(str), output, base, groupsep)
+/**
+* \copydoc cx_strtouz_lc()
+*/
+#define cx_strtoul_lc(str, output, base, groupsep) cx_strtoul_lc(cx_strcast(str), output, base, groupsep)
+/**
+* \copydoc cx_strtouz_lc()
+*/
+#define cx_strtoull_lc(str, output, base, groupsep) cx_strtoull_lc(cx_strcast(str), output, base, groupsep)
+/**
+* \copydoc cx_strtouz_lc()
+*/
+#define cx_strtou8_lc(str, output, base, groupsep) cx_strtou8_lc(cx_strcast(str), output, base, groupsep)
+/**
+* \copydoc cx_strtouz_lc()
+*/
+#define cx_strtou16_lc(str, output, base, groupsep) cx_strtou16_lc(cx_strcast(str), output, base, groupsep)
+/**
+* \copydoc cx_strtouz_lc()
+*/
+#define cx_strtou32_lc(str, output, base, groupsep) cx_strtou32_lc(cx_strcast(str), output, base, groupsep)
+/**
+* \copydoc cx_strtouz_lc()
+*/
+#define cx_strtou64_lc(str, output, base, groupsep) cx_strtou64_lc(cx_strcast(str), output, base, groupsep)
+/**
+* Converts a string to a number.
+*
+* The function returns non-zero when conversion is not possible.
+* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
+* It sets errno to ERANGE when the target datatype is too small.
+*
+* @param str the string to convert
+* @param output a pointer to the integer variable where the result shall be stored
+* @param base 2, 8, 10, or 16
+* @param groupsep each character in this string is treated as group separator and ignored during conversion
+* @return zero on success, non-zero if conversion was not possible
+*/
+#define cx_strtouz_lc(str, output, base, groupsep) cx_strtouz_lc(cx_strcast(str), output, base, groupsep)
+/**
+* \copydoc cx_strtouz()
+*/
+#define cx_strtos(str, output, base) cx_strtos_lc(str, output, base, ",")
+/**
+* \copydoc cx_strtouz()
+*/
+#define cx_strtoi(str, output, base) cx_strtoi_lc(str, output, base, ",")
+/**
+* \copydoc cx_strtouz()
+*/
+#define cx_strtol(str, output, base) cx_strtol_lc(str, output, base, ",")
+/**
+* \copydoc cx_strtouz()
+*/
+#define cx_strtoll(str, output, base) cx_strtoll_lc(str, output, base, ",")
+/**
+* \copydoc cx_strtouz()
+*/
+#define cx_strtoi8(str, output, base) cx_strtoi8_lc(str, output, base, ",")
+/**
+* \copydoc cx_strtouz()
+*/
+#define cx_strtoi16(str, output, base) cx_strtoi16_lc(str, output, base, ",")
+/**
+* \copydoc cx_strtouz()
+*/
+#define cx_strtoi32(str, output, base) cx_strtoi32_lc(str, output, base, ",")
+/**
+* \copydoc cx_strtouz()
+*/
+#define cx_strtoi64(str, output, base) cx_strtoi64_lc(str, output, base, ",")
+/**
+* \copydoc cx_strtouz()
+*/
+#define cx_strtoz(str, output, base) cx_strtoz_lc(str, output, base, ",")
+/**
+* \copydoc cx_strtouz()
+*/
+#define cx_strtous(str, output, base) cx_strtous_lc(str, output, base, ",")
+/**
+* \copydoc cx_strtouz()
+*/
+#define cx_strtou(str, output, base) cx_strtou_lc(str, output, base, ",")
+/**
+* \copydoc cx_strtouz()
+*/
+#define cx_strtoul(str, output, base) cx_strtoul_lc(str, output, base, ",")
+/**
+* \copydoc cx_strtouz()
+*/
+#define cx_strtoull(str, output, base) cx_strtoull_lc(str, output, base, ",")
+/**
+* \copydoc cx_strtouz()
+*/
+#define cx_strtou8(str, output, base) cx_strtou8_lc(str, output, base, ",")
+/**
+* \copydoc cx_strtouz()
+*/
+#define cx_strtou16(str, output, base) cx_strtou16_lc(str, output, base, ",")
+/**
+* \copydoc cx_strtouz()
+*/
+#define cx_strtou32(str, output, base) cx_strtou32_lc(str, output, base, ",")
+/**
+* \copydoc cx_strtouz()
+*/
+#define cx_strtou64(str, output, base) cx_strtou64_lc(str, output, base, ",")
+/**
+* Converts a string to a number.
+*
+* The function returns non-zero when conversion is not possible.
+* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
+* It sets errno to ERANGE when the target datatype is too small.
+*
+* The comma character is treated as group separator and ignored during parsing.
+* If you want to choose the set of group separators, use the \c _lc variant of this function (e.g. cx_strtouz_lc()).
+*
+* @param str the string to convert
+* @param output a pointer to the integer variable where the result shall be stored
+* @param base 2, 8, 10, or 16
+* @return zero on success, non-zero if conversion was not possible
+*/
+#define cx_strtouz(str, output, base) cx_strtouz_lc(str, output, base, ",")
+/**
+* Converts a string to a single precision floating point number.
+*
+* The function returns non-zero when conversion is not possible.
+* In that case the function sets errno to EINVAL when the reason is an invalid character.
+* It sets errno to ERANGE when the necessary representation would exceed the limits defined in libc's float.h.
+*
+* The decimal separator is assumed to be a dot character.
+* The comma character is treated as group separator and ignored during parsing.
+* If you want to choose a different format, use cx_strtof_lc().
+*
+* @param str the string to convert
+* @param output a pointer to the float variable where the result shall be stored
+* @param decsep the decimal separator
+* @param groupsep each character in this string is treated as group separator and ignored during conversion
+* @return zero on success, non-zero if conversion was not possible
+*/
+#define cx_strtof_lc(str, output, decsep, groupsep) cx_strtof_lc(cx_strcast(str), output, decsep, groupsep)
+/**
+* Converts a string to a double precision floating point number.
+*
+* The function returns non-zero when conversion is not possible.
+* In that case the function sets errno to EINVAL when the reason is an invalid character.
+* It sets errno to ERANGE when the necessary representation would exceed the limits defined in libc's float.h.
+*
+* The decimal separator is assumed to be a dot character.
+* The comma character is treated as group separator and ignored during parsing.
+* If you want to choose a different format, use cx_strtof_lc().
+*
+* @param str the string to convert
+* @param output a pointer to the float variable where the result shall be stored
+* @param decsep the decimal separator
+* @param groupsep each character in this string is treated as group separator and ignored during conversion
+* @return zero on success, non-zero if conversion was not possible
+*/
+#define cx_strtod_lc(str, output, decsep, groupsep) cx_strtod_lc(cx_strcast(str), output, decsep, groupsep)
+/**
+* Converts a string to a single precision floating point number.
+*
+* The function returns non-zero when conversion is not possible.
+* In that case the function sets errno to EINVAL when the reason is an invalid character.
+* It sets errno to ERANGE when the necessary representation would exceed the limits defined in libc's float.h.
+*
+* The decimal separator is assumed to be a dot character.
+* The comma character is treated as group separator and ignored during parsing.
+* If you want to choose a different format, use cx_strtof_lc().
+*
+* @param str the string to convert
+* @param output a pointer to the float variable where the result shall be stored
+* @return zero on success, non-zero if conversion was not possible
+*/
+#define cx_strtof(str, output) cx_strtof_lc(str, output, '.', ",")
+/**
+* Converts a string to a double precision floating point number.
+*
+* The function returns non-zero when conversion is not possible.
+* In that case the function sets errno to EINVAL when the reason is an invalid character.
+* It sets errno to ERANGE when the necessary representation would exceed the limits defined in libc's float.h.
+*
+* The decimal separator is assumed to be a dot character.
+* The comma character is treated as group separator and ignored during parsing.
+* If you want to choose a different format, use cx_strtof_lc().
+*
+* @param str the string to convert
+* @param output a pointer to the float variable where the result shall be stored
+* @return zero on success, non-zero if conversion was not possible
+*/
+#define cx_strtod(str, output) cx_strtod_lc(str, output, '.', ",")
+#endif
 #ifdef __cplusplus
 } // extern "C"
 #endif

Mercurial > hg > dbutils / file comparison

comparison: ucx/cx/string.h

ucx/cx/string.h