ucx: comparison src/cx/string.h

-:8b0f162ac88e
+:36c0fb2b60b2
 * @param cstring the string to wrap (must be zero-terminated)
 * @return the wrapped string
 *
 * @see cx_mutstrn()
 */
-cx_attr_nodiscard cx_attr_cstr_arg(1)
+CX_NODISCARD CX_CSTR_ARG(1)
 CX_INLINE cxmutstr cx_mutstr(char *cstring) {
 cxmutstr str;
 str.ptr = cstring;
 str.length = cstring == NULL ? 0 : strlen(cstring);
 return str;
 * @param length   the length of the string
 * @return the wrapped string
 *
 * @see cx_mutstr()
 */
-cx_attr_nodiscard cx_attr_access_rw(1, 2)
+CX_NODISCARD CX_ACCESS_RW(1, 2)
 CX_INLINE cxmutstr cx_mutstrn(char *cstring, size_t length) {
 cxmutstr str;
 str.ptr = cstring;
 str.length = length;
 return str;
 * @param cstring the string to wrap (must be zero-terminated)
 * @return the wrapped string
 *
 * @see cx_strn()
 */
-cx_attr_nodiscard cx_attr_cstr_arg(1)
+CX_NODISCARD CX_CSTR_ARG(1)
 CX_INLINE cxstring cx_str(const char *cstring) {
 cxstring str;
 str.ptr = cstring;
 str.length = cstring == NULL ? 0 : strlen(cstring);
 return str;
 * @param length   the length of the string
 * @return the wrapped string
 *
 * @see cx_str()
 */
-cx_attr_nodiscard cx_attr_access_r(1, 2)
+CX_NODISCARD CX_ACCESS_R(1, 2)
 CX_INLINE cxstring cx_strn(const char *cstring, size_t length) {
 cxstring str;
 str.ptr = cstring;
 str.length = length;
 return str;
 }
 #ifdef __cplusplus
-cx_attr_nodiscard
+CX_NODISCARD
 CX_CPPDECL cxmutstr cx_strcast_m(cxmutstr str) {
 return str;
 }
-cx_attr_nodiscard
+CX_NODISCARD
 CX_CPPDECL cxstring cx_strcast_m(cxstring str) {
 return str;
 }
-cx_attr_nodiscard
+CX_NODISCARD
 CX_CPPDECL cxmutstr cx_strcast_m(char *str) {
 return cx_mutstr(str);
 }
-cx_attr_nodiscard
+CX_NODISCARD
 CX_CPPDECL cxmutstr cx_strcast_m(unsigned char *str) {
 return cx_mutstr(reinterpret_cast<char*>(str));
 }
-cx_attr_nodiscard
+CX_NODISCARD
 CX_CPPDECL cxstring cx_strcast_m(const char *str) {
 return cx_str(str);
 }
-cx_attr_nodiscard
+CX_NODISCARD
 CX_CPPDECL cxstring cx_strcast_m(const unsigned char *str) {
 return cx_str(reinterpret_cast<const char*>(str));
 }
-cx_attr_nodiscard
+CX_NODISCARD
 CX_CPPDECL cxstring cx_strcast_(cxmutstr str) {
 return cx_strn(str.ptr, str.length);
 }
-cx_attr_nodiscard
+CX_NODISCARD
 CX_CPPDECL cxstring cx_strcast_(cxstring str) {
 return str;
 }
 #define cx_strcast(s) cx_strcast_(cx_strcast_m(s))
-extern "C" {
 #else
 /**
 * Internal function, do not use.
 * @param str
 * @return
 * @see cx_strcast_m()
 * @see cx_strcast()
 */
-cx_attr_nodiscard
+CX_NODISCARD
 CX_INLINE cxmutstr cx_strcast_cxms(cxmutstr str) {
 return str;
 }
 /**
 * Internal function, do not use.
 * @param str
 * @return
 * @see cx_strcast_m()
 * @see cx_strcast()
 */
-cx_attr_nodiscard
+CX_NODISCARD
 CX_INLINE cxstring cx_strcast_cxs(cxstring str) {
 return str;
 }
 /**
 * @param str
 * @return
 * @see cx_strcast_m()
 * @see cx_strcast()
 */
-cx_attr_nodiscard
+CX_NODISCARD
 CX_INLINE cxmutstr cx_strcast_uc(unsigned char *str) {
 return cx_mutstr((char*)str);
 }
 /**
 * @param str
 * @return
 * @see cx_strcast_m()
 * @see cx_strcast()
 */
-cx_attr_nodiscard
+CX_NODISCARD
 CX_INLINE cxmutstr cx_strcast_c(char *str) {
 return cx_mutstr(str);
 }
 /**
 * @param str
 * @return
 * @see cx_strcast_m()
 * @see cx_strcast()
 */
-cx_attr_nodiscard
+CX_NODISCARD
 CX_INLINE cxstring cx_strcast_ucc(const unsigned char *str) {
 return cx_str((const char*)str);
 }
 /**
 * @param str
 * @return
 * @see cx_strcast_m()
 * @see cx_strcast()
 */
-cx_attr_nodiscard
+CX_NODISCARD
 CX_INLINE cxstring cx_strcast_cc(const char *str) {
 return cx_str(str);
 }
 /**
 * you ever have a <code>const char*</code> you are really supposed to free.
 * If you encounter such a situation, you should double-check your code.
 *
 * @param str the string to free
 */
-CX_EXPORT void cx_strfree(cxmutstr *str);
+CX_EXTERN
+void cx_strfree(cxmutstr *str);
 /**
 * Passes the pointer in this string to the allocator's free function.
 *
 * The pointer in the struct is set to @c NULL, and the length is set to zero,
 * If you encounter such a situation, you should double-check your code.
 *
 * @param alloc the allocator
 * @param str the string to free
 */
-cx_attr_nonnull_arg(1)
+CX_EXTERN CX_NONNULL_ARG(1)
-CX_EXPORT void cx_strfree_a(const CxAllocator *alloc, cxmutstr *str);
+void cx_strfree_a(const CxAllocator *alloc, cxmutstr *str);
 /**
 * Copies a string.
 *
 * Internal function - do not use.
 *
 * @retval zero success
 * @retval non-zero if re-allocation failed
 * @see cx_strcpy_a()
 */
-cx_attr_nonnull_arg(1)
+CX_EXTERN CX_NONNULL_ARG(1)
-CX_EXPORT int cx_strcpy_a_(const CxAllocator *alloc, cxmutstr *dest, cxstring src);
+int cx_strcpy_a_(const CxAllocator *alloc, cxmutstr *dest, cxstring src);
 /**
 * Copies a string.
 *
 * The memory in the @p dest structure is either allocated or re-allocated to fit the entire
 *
 * @param count    the total number of specified strings
 * @param ...      all strings
 * @return the accumulated length of all strings
 */
-cx_attr_nodiscard
+CX_EXTERN CX_NODISCARD
-CX_EXPORT size_t cx_strlen(size_t count, ...);
+size_t cx_strlen(size_t count, ...);
 /**
 * Concatenates strings.
 *
 * The resulting string will be allocated by the specified allocator.
 * @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 UCX strings
 * @return the concatenated string
 */
-cx_attr_nonnull
+CX_EXTERN CX_NONNULL
-CX_EXPORT cxmutstr cx_strcat_a(const CxAllocator *alloc,
+cxmutstr cx_strcat_a(const CxAllocator *alloc,
 cxmutstr str, size_t count, ...);
 /**
 * Concatenates strings and returns a new string.
 *
 * @param start  start location of the substring
 * @param length the maximum length of the returned string
 * @return a substring of @p string starting at @p start
 * @see cx_strsubsl()
 */
-cx_attr_nodiscard
+CX_EXTERN CX_NODISCARD
-CX_EXPORT cxstring cx_strsubsl_(cxstring string, size_t start, size_t length);
+cxstring cx_strsubsl_(cxstring string, size_t start, size_t length);
 /**
 * Returns a substring.
 *
 * Internal function - do not use.
 * @param string input string
 * @param start  start location of the substring
 * @return a substring of @p string starting at @p start
 * @see cx_strsubs()
 */
-cx_attr_nodiscard
+CX_EXTERN CX_NODISCARD
-CX_EXPORT cxstring cx_strsubs_(cxstring string, size_t start);
+cxstring cx_strsubs_(cxstring string, size_t start);
-CX_INLINE cxmutstr cx_strsubs_m_(cxmutstr string, size_t start) {
+CX_INLINE
+cxmutstr cx_strsubs_m_(cxmutstr string, size_t start) {
 return cx_mutstrcast(cx_strsubs_(cx_strcast(string), start));
 }
-CX_INLINE cxmutstr cx_strsubsl_m_(cxmutstr string, size_t start, size_t length) {
+CX_INLINE
+cxmutstr cx_strsubsl_m_(cxmutstr string, size_t start, size_t length) {
 return cx_mutstrcast(cx_strsubsl_(cx_strcast(string), start, length));
 }
 #ifdef __cplusplus
-} // extern "C"
 CX_CPPDECL cxstring cx_strsubs_cpp_(cxstring string, size_t start) {
 return cx_strsubs_(string, start);
 }
 CX_CPPDECL cxstring cx_strsubsl_cpp_(cxstring string, size_t start, size_t length) {
 return cx_strsubsl_(string, start, length);
 CX_CPPDECL cxmutstr cx_strsubsl_cpp_(cxmutstr string, size_t start, size_t length) {
 return cx_strsubsl_m_(string, start, length);
 }
 #define cx_strsubs(string, start) cx_strsubs_cpp_(cx_strcast_m(string), start)
 #define cx_strsubsl(string, start, length) cx_strsubsl_cpp_(cx_strcast_m(string), start, length)
-extern "C" {
 #else
 /**
 * Returns a substring starting at the specified location.
 *
 * @attention the new string references the same memory area as the
 * @param str the string
 * @param index the index offset
 * @return the character at the index
 * @see cx_strat()
 */
-CX_INLINE char cx_strat_(cxstring str, off_t index) {
+CX_INLINE
+char cx_strat_(cxstring str, off_t index) {
 size_t i;
 if (index >= 0) {
 i = index;
 } else {
 i = (size_t) (str.length + index);
 * @param chr    the character to locate
 * @return       a substring starting at the first location of @p chr
 *
 * @see cx_strchr_m()
 */
-cx_attr_nodiscard
+CX_EXTERN CX_NODISCARD
-CX_EXPORT cxstring cx_strchr(cxstring string, int chr);
+cxstring cx_strchr(cxstring string, int chr);
 /**
 * Returns a substring starting at the location of the first occurrence of the
 * specified character.
 *
 * @param chr    the character to locate
 * @return       a substring starting at the first location of @p chr
 *
 * @see cx_strchr()
 */
-cx_attr_nodiscard
+CX_EXTERN CX_NODISCARD
-CX_EXPORT cxmutstr cx_strchr_m(cxmutstr string, int chr);
+cxmutstr cx_strchr_m(cxmutstr string, int chr);
 /**
 * Returns a substring starting at the location of the last occurrence of the
 * specified character.
 *
 * @param chr    the character to locate
 * @return       a substring starting at the last location of @p chr
 *
 * @see cx_strrchr_m()
 */
-cx_attr_nodiscard
+CX_EXTERN CX_NODISCARD
-CX_EXPORT cxstring cx_strrchr(cxstring string, int chr);
+cxstring cx_strrchr(cxstring string, int chr);
 /**
 * Returns a substring starting at the location of the last occurrence of the
 * specified character.
 *
 * @param chr    the character to locate
 * @return       a substring starting at the last location of @p chr
 *
 * @see cx_strrchr()
 */
-cx_attr_nodiscard
+CX_EXTERN CX_NODISCARD
-CX_EXPORT cxmutstr cx_strrchr_m(cxmutstr string, int chr);
+cxmutstr cx_strrchr_m(cxmutstr string, int chr);
 /**
 * Searches for a specific substring.
 *
 * Internal function - do not use.
 * @param needle string containing the sequence of characters to match
 * @return a substring starting at the first occurrence of @p needle,
 * or an empty string, if the sequence is not contained
 * @see cx_strstr()
 */
-cx_attr_nodiscard
+CX_EXTERN CX_NODISCARD
-CX_EXPORT cxstring cx_strstr_(cxstring haystack, cxstring needle);
+cxstring cx_strstr_(cxstring haystack, cxstring needle);
 /**
 * Returns a substring starting at the location of the first occurrence of the
 * specified string.
 *
 * @param needle string containing the sequence of characters to match
 * @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()
 */
-cx_attr_nodiscard
+CX_EXTERN CX_NODISCARD
-CX_EXPORT cxmutstr cx_strstr_m_(cxmutstr haystack, cxstring needle);
+cxmutstr cx_strstr_m_(cxmutstr haystack, cxstring needle);
 /**
 * Returns a substring starting at the location of the first occurrence of the
 * specified string.
 *
 * @param limit the maximum number of split items
 * @param output the output array
 * @return the actual number of split items
 * @see cx_strsplit()
 */
-cx_attr_nodiscard cx_attr_nonnull cx_attr_access_w(4, 3)
+CX_EXTERN CX_NODISCARD CX_NONNULL CX_ACCESS_W(4, 3)
-CX_EXPORT size_t cx_strsplit_(cxstring string, cxstring delim,
+size_t cx_strsplit_(cxstring string, cxstring delim,
 size_t limit, cxstring *output);
 /**
 * Splits a given string using a delimiter string.
 *
 * @param limit the maximum number of split items
 * @param output the output array
 * @return the actual number of split items
 * @see cx_strsplit_a()
 */
-cx_attr_nodiscard cx_attr_nonnull cx_attr_access_w(5)
+CX_EXTERN CX_NODISCARD CX_NONNULL CX_ACCESS_W(5)
-CX_EXPORT size_t cx_strsplit_a_(const CxAllocator *allocator,
+size_t cx_strsplit_a_(const CxAllocator *allocator,
 cxstring string, cxstring delim,
 size_t limit, cxstring **output);
 /**
 * @param limit the maximum number of split items
 * @param output the output array
 * @return the actual number of split items
 * @see cx_strsplit_m()
 */
-cx_attr_nodiscard cx_attr_nonnull cx_attr_access_w(4, 3)
+CX_EXTERN CX_NODISCARD CX_NONNULL CX_ACCESS_W(4, 3)
-CX_EXPORT size_t cx_strsplit_m_(cxmutstr string, cxstring delim,
+size_t cx_strsplit_m_(cxmutstr string, cxstring delim,
 size_t limit, cxmutstr *output);
 /**
 * Splits a given string using a delimiter string.
 *
 * @param limit the maximum number of split items
 * @param output the output array
 * @return the actual number of split items
 * @see cx_strsplit_ma()
 */
-cx_attr_nodiscard cx_attr_nonnull cx_attr_access_w(5)
+CX_EXTERN CX_NODISCARD CX_NONNULL CX_ACCESS_W(5)
-CX_EXPORT size_t cx_strsplit_ma_(const CxAllocator *allocator,
+size_t cx_strsplit_ma_(const CxAllocator *allocator,
 cxmutstr string, cxstring delim, size_t limit,
 cxmutstr **output);
 /**
 * Splits a given string using a delimiter string.
 * @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
 */
-cx_attr_nodiscard
+CX_EXTERN CX_NODISCARD
-CX_EXPORT int cx_strcmp_(cxstring s1, cxstring s2);
+int cx_strcmp_(cxstring s1, cxstring s2);
 /**
 * Compares two strings.
 *
 * @param s1 the first string
 * @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
 */
-cx_attr_nodiscard
+CX_EXTERN CX_NODISCARD
-CX_EXPORT int cx_strcasecmp_(cxstring s1, cxstring s2);
+int cx_strcasecmp_(cxstring s1, cxstring s2);
 /**
 * Compares two strings ignoring case.
 *
 * @param s1 the first string
 * @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
 */
-cx_attr_nodiscard  cx_attr_nonnull
+CX_EXTERN CX_NODISCARD CX_NONNULL
-CX_EXPORT int cx_strcmp_p(const void *s1, const void *s2);
+int cx_strcmp_p(const void *s1, const void *s2);
 /**
 * Compares two strings ignoring case.
 *
 * This function has a compatible signature for the use as a cx_compare_func.
 * @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
 */
-cx_attr_nodiscard cx_attr_nonnull
+CX_EXTERN CX_NODISCARD CX_NONNULL
-CX_EXPORT int cx_strcasecmp_p(const void *s1, const void *s2);
+int cx_strcasecmp_p(const void *s1, const void *s2);
 /**
 * Creates a duplicate of the specified string.
 *
 * The new string will contain a copy allocated by @p allocator.
 * @param allocator the allocator to use
 * @param string the string to duplicate
 * @return a duplicate of the string
 * @see cx_strdup()
 */
-cx_attr_nodiscard cx_attr_nonnull
+CX_EXTERN CX_NODISCARD CX_NONNULL
-CX_EXPORT cxmutstr cx_strdup_a_(const CxAllocator *allocator, cxstring string);
+cxmutstr cx_strdup_a_(const CxAllocator *allocator, cxstring string);
 /**
 * Creates a duplicate of the specified string.
 *
 * The new string will contain a copy allocated by @p allocator.
 * must @em not free the returned memory.
 *
 * @param string the string that shall be trimmed
 * @return the trimmed string
 */
-cx_attr_nodiscard
+CX_EXTERN CX_NODISCARD
-CX_EXPORT cxstring cx_strtrim(cxstring string);
+cxstring cx_strtrim(cxstring string);
 /**
 * Omits leading and trailing spaces.
 *
 * @note the returned string references the same memory, thus you
 * must @em not free the returned memory.
 *
 * @param string the string that shall be trimmed
 * @return the trimmed string
 */
-cx_attr_nodiscard
+CX_EXTERN CX_NODISCARD
-CX_EXPORT cxmutstr cx_strtrim_m(cxmutstr string);
+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
 */
-cx_attr_nodiscard
+CX_EXTERN CX_NODISCARD
-CX_EXPORT bool cx_strprefix_(cxstring string, cxstring prefix);
+bool cx_strprefix_(cxstring string, cxstring prefix);
 /**
 * Checks if a string has a specific prefix.
 *
 * @param string the string to check
 * @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
 */
-cx_attr_nodiscard
+CX_EXTERN CX_NODISCARD
-CX_EXPORT bool cx_strsuffix_(cxstring string, cxstring suffix);
+bool cx_strsuffix_(cxstring string, cxstring suffix);
 /**
 * Checks if a string has a specific suffix.
 *
 * @param string the string to check
 * @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
 */
-cx_attr_nodiscard
+CX_EXTERN CX_NODISCARD
-CX_EXPORT bool cx_strcaseprefix_(cxstring string, cxstring prefix);
+bool cx_strcaseprefix_(cxstring string, cxstring prefix);
 /**
 * Checks if a string has a specific prefix, ignoring the case.
 *
 * @param string the string to check
 * @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
 */
-cx_attr_nodiscard
+CX_EXTERN CX_NODISCARD
-CX_EXPORT bool cx_strcasesuffix_(cxstring string, cxstring suffix);
+bool cx_strcasesuffix_(cxstring string, cxstring suffix);
 /**
 * Checks, if a string has a specific suffix, ignoring the case.
 *
 * @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
 */
 #define cx_strcasesuffix(string, suffix) cx_strcasesuffix_(cx_strcast(string), cx_strcast(suffix))
 /**
 * Replaces a string with another string.
 *
 * Internal function - do not use.
 * @see cx_strreplace_a()
 * @see cx_strreplace()
 * @see cx_strreplacen_a()
 * @see cx_strreplacen()
 */
-cx_attr_nodiscard cx_attr_nonnull
+CX_EXTERN CX_NODISCARD CX_NONNULL
-CX_EXPORT cxmutstr cx_strreplace_(const CxAllocator *allocator,
+cxmutstr cx_strreplace_(const CxAllocator *allocator,
 cxstring str, cxstring search, cxstring replacement, size_t replmax);
 /**
 * Replaces a string with another string.
 *
 * @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
 */
-cx_attr_nodiscard
+CX_EXTERN CX_NODISCARD
-CX_EXPORT CxStrtokCtx cx_strtok_(cxstring str, cxstring delim, size_t limit);
+CxStrtokCtx cx_strtok_(cxstring str, cxstring delim, size_t limit);
 /**
 * Creates a string tokenization context.
 *
 * @param str the string to tokenize
 * @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
 */
-cx_attr_nonnull  cx_attr_nodiscard  cx_attr_access_w(2)
+CX_EXTERN CX_NONNULL CX_NODISCARD CX_ACCESS_W(2)
-CX_EXPORT bool cx_strtok_next_(CxStrtokCtx *ctx, cxstring *token);
+bool cx_strtok_next_(CxStrtokCtx *ctx, cxstring *token);
 #ifdef __cplusplus
-} // extern "C"
 CX_CPPDECL cx_strtok_next(CxStrtokCtx *ctx, cxstring *token) {
 return cx_strtok_next_(ctx, token);
 }
 CX_CPPDECL cx_strtok_next(CxStrtokCtx *ctx, cxmutstr *token) {
 // Note: this is actually UB - fixed with start_lifetime_as() in C++23
 //       but it works on all supported platforms
 return cx_strtok_next_(ctx, reinterpret_cast<cxstring*>(token));
 }
-extern "C" {
 #else // ! __cplusplus
 /**
 * Returns the next token.
 *
 * The token will point to the source string.
 *
 * @param ctx the tokenization context
 * @param delim array of more delimiters
 * @param count number of elements in the array
 */
-cx_attr_nonnull cx_attr_access_r(2, 3)
+CX_EXTERN CX_NONNULL CX_ACCESS_R(2, 3)
-CX_EXPORT void cx_strtok_delim(CxStrtokCtx *ctx, const cxstring *delim, size_t count);
+void cx_strtok_delim(CxStrtokCtx *ctx, const cxstring *delim, size_t count);
 /* ------------------------------------------------------------------------- *
 *                string to number conversion functions                      *
 * ------------------------------------------------------------------------- */
 * @param base 2, 8, 10, or 16
 * @param groupsep each character in this string is treated as a group separator and ignored during conversion
 * @retval zero success
 * @retval non-zero conversion was not possible
 */
-cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
-CX_EXPORT int cx_strtos_lc_(cxstring str, short *output, int base, const char *groupsep);
+int cx_strtos_lc_(cxstring str, short *output, int base, const char *groupsep);
 /**
 * Converts a string to a number.
 *
 * The function returns non-zero when conversion is not possible.
 * @param base 2, 8, 10, or 16
 * @param groupsep each character in this string is treated as a group separator and ignored during conversion
 * @retval zero success
 * @retval non-zero conversion was not possible
 */
-cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
-CX_EXPORT int cx_strtoi_lc_(cxstring str, int *output, int base, const char *groupsep);
+int cx_strtoi_lc_(cxstring str, int *output, int base, const char *groupsep);
 /**
 * Converts a string to a number.
 *
 * The function returns non-zero when conversion is not possible.
 * @param base 2, 8, 10, or 16
 * @param groupsep each character in this string is treated as a group separator and ignored during conversion
 * @retval zero success
 * @retval non-zero conversion was not possible
 */
-cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
-CX_EXPORT int cx_strtol_lc_(cxstring str, long *output, int base, const char *groupsep);
+int cx_strtol_lc_(cxstring str, long *output, int base, const char *groupsep);
 /**
 * Converts a string to a number.
 *
 * The function returns non-zero when conversion is not possible.
 * @param base 2, 8, 10, or 16
 * @param groupsep each character in this string is treated as a group separator and ignored during conversion
 * @retval zero success
 * @retval non-zero conversion was not possible
 */
-cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
-CX_EXPORT int cx_strtoll_lc_(cxstring str, long long *output, int base, const char *groupsep);
+int cx_strtoll_lc_(cxstring str, long long *output, int base, const char *groupsep);
 /**
 * Converts a string to a number.
 *
 * The function returns non-zero when conversion is not possible.
 * @param base 2, 8, 10, or 16
 * @param groupsep each character in this string is treated as a group separator and ignored during conversion
 * @retval zero success
 * @retval non-zero conversion was not possible
 */
-cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
-CX_EXPORT int cx_strtoi8_lc_(cxstring str, int8_t *output, int base, const char *groupsep);
+int cx_strtoi8_lc_(cxstring str, int8_t *output, int base, const char *groupsep);
 /**
 * Converts a string to a number.
 *
 * The function returns non-zero when conversion is not possible.
 * @param base 2, 8, 10, or 16
 * @param groupsep each character in this string is treated as a group separator and ignored during conversion
 * @retval zero success
 * @retval non-zero conversion was not possible
 */
-cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
-CX_EXPORT int cx_strtoi16_lc_(cxstring str, int16_t *output, int base, const char *groupsep);
+int cx_strtoi16_lc_(cxstring str, int16_t *output, int base, const char *groupsep);
 /**
 * Converts a string to a number.
 *
 * The function returns non-zero when conversion is not possible.
 * @param base 2, 8, 10, or 16
 * @param groupsep each character in this string is treated as a group separator and ignored during conversion
 * @retval zero success
 * @retval non-zero conversion was not possible
 */
-cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
-CX_EXPORT int cx_strtoi32_lc_(cxstring str, int32_t *output, int base, const char *groupsep);
+int cx_strtoi32_lc_(cxstring str, int32_t *output, int base, const char *groupsep);
 /**
 * Converts a string to a number.
 *
 * The function returns non-zero when conversion is not possible.
 * @param base 2, 8, 10, or 16
 * @param groupsep each character in this string is treated as a group separator and ignored during conversion
 * @retval zero success
 * @retval non-zero conversion was not possible
 */
-cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
-CX_EXPORT int cx_strtoi64_lc_(cxstring str, int64_t *output, int base, const char *groupsep);
+int cx_strtoi64_lc_(cxstring str, int64_t *output, int base, const char *groupsep);
 /**
 * Converts a string to a number.
 *
 * The function returns non-zero when conversion is not possible.
 * @param base 2, 8, 10, or 16
 * @param groupsep each character in this string is treated as a group separator and ignored during conversion
 * @retval zero success
 * @retval non-zero conversion was not possible
 */
-cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
-CX_EXPORT int cx_strtous_lc_(cxstring str, unsigned short *output, int base, const char *groupsep);
+int cx_strtous_lc_(cxstring str, unsigned short *output, int base, const char *groupsep);
 /**
 * Converts a string to a number.
 *
 * The function returns non-zero when conversion is not possible.
 * @param base 2, 8, 10, or 16
 * @param groupsep each character in this string is treated as a group separator and ignored during conversion
 * @retval zero success
 * @retval non-zero conversion was not possible
 */
-cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
-CX_EXPORT int cx_strtou_lc_(cxstring str, unsigned int *output, int base, const char *groupsep);
+int cx_strtou_lc_(cxstring str, unsigned int *output, int base, const char *groupsep);
 /**
 * Converts a string to a number.
 *
 * The function returns non-zero when conversion is not possible.
 * @param base 2, 8, 10, or 16
 * @param groupsep each character in this string is treated as a group separator and ignored during conversion
 * @retval zero success
 * @retval non-zero conversion was not possible
 */
-cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
-CX_EXPORT int cx_strtoul_lc_(cxstring str, unsigned long *output, int base, const char *groupsep);
+int cx_strtoul_lc_(cxstring str, unsigned long *output, int base, const char *groupsep);
 /**
 * Converts a string to a number.
 *
 * The function returns non-zero when conversion is not possible.
 * @param base 2, 8, 10, or 16
 * @param groupsep each character in this string is treated as a group separator and ignored during conversion
 * @retval zero success
 * @retval non-zero conversion was not possible
 */
-cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
-CX_EXPORT int cx_strtoull_lc_(cxstring str, unsigned long long *output, int base, const char *groupsep);
+int cx_strtoull_lc_(cxstring str, unsigned long long *output, int base, const char *groupsep);
 /**
 * Converts a string to a number.
 *
 * The function returns non-zero when conversion is not possible.
 * @param base 2, 8, 10, or 16
 * @param groupsep each character in this string is treated as a group separator and ignored during conversion
 * @retval zero success
 * @retval non-zero conversion was not possible
 */
-cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
-CX_EXPORT int cx_strtou8_lc_(cxstring str, uint8_t *output, int base, const char *groupsep);
+int cx_strtou8_lc_(cxstring str, uint8_t *output, int base, const char *groupsep);
 /**
 * Converts a string to a number.
 *
 * The function returns non-zero when conversion is not possible.
 * @param base 2, 8, 10, or 16
 * @param groupsep each character in this string is treated as a group separator and ignored during conversion
 * @retval zero success
 * @retval non-zero conversion was not possible
 */
-cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
-CX_EXPORT int cx_strtou16_lc_(cxstring str, uint16_t *output, int base, const char *groupsep);
+int cx_strtou16_lc_(cxstring str, uint16_t *output, int base, const char *groupsep);
 /**
 * Converts a string to a number.
 *
 * The function returns non-zero when conversion is not possible.
 * @param base 2, 8, 10, or 16
 * @param groupsep each character in this string is treated as a group separator and ignored during conversion
 * @retval zero success
 * @retval non-zero conversion was not possible
 */
-cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
-CX_EXPORT int cx_strtou32_lc_(cxstring str, uint32_t *output, int base, const char *groupsep);
+int cx_strtou32_lc_(cxstring str, uint32_t *output, int base, const char *groupsep);
 /**
 * Converts a string to a number.
 *
 * The function returns non-zero when conversion is not possible.
 * @param base 2, 8, 10, or 16
 * @param groupsep each character in this string is treated as a group separator and ignored during conversion
 * @retval zero success
 * @retval non-zero conversion was not possible
 */
-cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
-CX_EXPORT int cx_strtou64_lc_(cxstring str, uint64_t *output, int base, const char *groupsep);
+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.
 * @param base 2, 8, 10, or 16
 * @param groupsep each character in this string is treated as a group separator and ignored during conversion
 * @retval zero success
 * @retval non-zero conversion was not possible
 */
-cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
-CX_EXPORT int cx_strtoz_lc_(cxstring str, size_t *output, int base, const char *groupsep);
+int cx_strtoz_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.
 * @param decsep the decimal separator
 * @param groupsep each character in this string is treated as a group separator and ignored during conversion
 * @retval zero success
 * @retval non-zero conversion was not possible
 */
-cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
-CX_EXPORT int cx_strtof_lc_(cxstring str, float *output, char decsep, const char *groupsep);
+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.
 * @param decsep the decimal separator
 * @param groupsep each character in this string is treated as a group separator and ignored during conversion
 * @retval zero success
 * @retval non-zero conversion was not possible
 */
-cx_attr_access_w(2) cx_attr_nonnull_arg(2)
+CX_EXTERN CX_ACCESS_W(2) CX_NONNULL_ARG(2)
-CX_EXPORT int cx_strtod_lc_(cxstring str, double *output, char decsep, const char *groupsep);
+int cx_strtod_lc_(cxstring str, double *output, char decsep, const char *groupsep);
 /**
 * Converts a string to a number.
 *
 * The function returns non-zero when conversion is not possible.
 * @retval zero success
 * @retval non-zero conversion was not possible
 */
 #define cx_strtod(str, output) cx_strtod_lc_(cx_strcast(str), output, '.', ",")
-#ifdef __cplusplus
-} // extern "C"
-#endif
 #endif //UCX_STRING_H

Mercurial > hg > ucx / file comparison

comparison: src/cx/string.h

src/cx/string.h