GCC Code Coverage Report

Line	Branch	Exec	Source
1			/*
2			* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3			*
4			* Copyright 2021 Mike Becker, Olaf Wintermann All rights reserved.
5			*
6			* Redistribution and use in source and binary forms, with or without
7			* modification, are permitted provided that the following conditions are met:
8			*
9			* 1. Redistributions of source code must retain the above copyright
10			* notice, this list of conditions and the following disclaimer.
11			*
12			* 2. Redistributions in binary form must reproduce the above copyright
13			* notice, this list of conditions and the following disclaimer in the
14			* documentation and/or other materials provided with the distribution.
15			*
16			* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17			* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19			* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
20			* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21			* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22			* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23			* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24			* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25			* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26			* POSSIBILITY OF SUCH DAMAGE.
27			*/
28			/**
29			* @file string.h
30			* @brief Strings that know their length.
31			* @author Mike Becker
32			* @author Olaf Wintermann
33			* @copyright 2-Clause BSD License
34			*/
35
36			#ifndef UCX_STRING_H
37			#define UCX_STRING_H
38
39			#include "common.h"
40			#include "allocator.h"
41
42			/**
43			* The maximum length of the "needle" in cx_strstr() that can use SBO.
44			*/
45			cx_attr_export
46			extern const unsigned cx_strstr_sbo_size;
47
48			/**
49			* The UCX string structure.
50			*/
51			struct cx_mutstr_s {
52			/**
53			* A pointer to the string.
54			* @note The string is not necessarily @c NULL terminated.
55			*/
56			char *ptr;
57			/** The length of the string */
58			size_t length;
59			};
60
61			/**
62			* A mutable string.
63			*/
64			typedef struct cx_mutstr_s cxmutstr;
65
66			/**
67			* The UCX string structure for immutable (constant) strings.
68			*/
69			struct cx_string_s {
70			/**
71			* A pointer to the immutable string.
72			* @note The string is not necessarily @c NULL terminated.
73			*/
74			const char *ptr;
75			/** The length of the string */
76			size_t length;
77			};
78
79			/**
80			* An immutable string.
81			*/
82			typedef struct cx_string_s cxstring;
83
84			/**
85			* Context for string tokenizing.
86			*/
87			struct cx_strtok_ctx_s {
88			/**
89			* The string to tokenize.
90			*/
91			cxstring str;
92			/**
93			* The primary delimiter.
94			*/
95			cxstring delim;
96			/**
97			* Optional array of more delimiters.
98			*/
99			const cxstring *delim_more;
100			/**
101			* Length of the array containing more delimiters.
102			*/
103			size_t delim_more_count;
104			/**
105			* Position of the currently active token in the source string.
106			*/
107			size_t pos;
108			/**
109			* Position of next delimiter in the source string.
110			*
111			* If the tokenizer has not yet returned a token, the content of this field
112			* is undefined. If the tokenizer reached the end of the string, this field
113			* contains the length of the source string.
114			*/
115			size_t delim_pos;
116			/**
117			* The position of the next token in the source string.
118			*/
119			size_t next_pos;
120			/**
121			* The number of already found tokens.
122			*/
123			size_t found;
124			/**
125			* The maximum number of tokens that shall be returned.
126			*/
127			size_t limit;
128			};
129
130			/**
131			* A string tokenizing context.
132			*/
133			typedef struct cx_strtok_ctx_s CxStrtokCtx;
134
135			#ifdef __cplusplus
136			extern "C" {
137
138			/**
139			* A literal initializer for an UCX string structure.
140			*
141			* @param literal the string literal
142			*/
143			#define CX_STR(literal) cxstring{literal, sizeof(literal) - 1}
144
145			#else // __cplusplus
146
147			/**
148			* A literal initializer for an UCX string structure.
149			*
150			* The argument MUST be a string (const char*) @em literal.
151			*
152			* @param literal the string literal
153			*/
154			#define CX_STR(literal) ((cxstring){literal, sizeof(literal) - 1})
155
156			#endif
157
158
159			/**
160			* Wraps a mutable string that must be zero-terminated.
161			*
162			* The length is implicitly inferred by using a call to @c strlen().
163			*
164			* @note the wrapped string will share the specified pointer to the string.
165			* If you do want a copy, use cx_strdup() on the return value of this function.
166			*
167			* If you need to wrap a constant string, use cx_str().
168			*
169			* @param cstring the string to wrap, must be zero-terminated
170			* @return the wrapped string
171			*
172			* @see cx_mutstrn()
173			*/
174			cx_attr_nonnull
175			cx_attr_nodiscard
176			cx_attr_cstr_arg(1)
177			cx_attr_export
178			cxmutstr cx_mutstr(char *cstring);
179
180			/**
181			* Wraps a string that does not need to be zero-terminated.
182			*
183			* The argument may be @c NULL if the length is zero.
184			*
185			* @note the wrapped string will share the specified pointer to the string.
186			* If you do want a copy, use cx_strdup() on the return value of this function.
187			*
188			* If you need to wrap a constant string, use cx_strn().
189			*
190			* @param cstring the string to wrap (or @c NULL, only if the length is zero)
191			* @param length the length of the string
192			* @return the wrapped string
193			*
194			* @see cx_mutstr()
195			*/
196			cx_attr_nodiscard
197			cx_attr_access_rw(1, 2)
198			cx_attr_export
199			cxmutstr cx_mutstrn(
200			char *cstring,
201			size_t length
202			);
203
204			/**
205			* Wraps a string that must be zero-terminated.
206			*
207			* The length is implicitly inferred by using a call to @c strlen().
208			*
209			* @note the wrapped string will share the specified pointer to the string.
210			* If you do want a copy, use cx_strdup() on the return value of this function.
211			*
212			* If you need to wrap a non-constant string, use cx_mutstr().
213			*
214			* @param cstring the string to wrap, must be zero-terminated
215			* @return the wrapped string
216			*
217			* @see cx_strn()
218			*/
219			cx_attr_nonnull
220			cx_attr_nodiscard
221			cx_attr_cstr_arg(1)
222			cx_attr_export
223			cxstring cx_str(const char *cstring);
224
225
226			/**
227			* Wraps a string that does not need to be zero-terminated.
228			*
229			* The argument may be @c NULL if the length is zero.
230			*
231			* @note the wrapped string will share the specified pointer to the string.
232			* If you do want a copy, use cx_strdup() on the return value of this function.
233			*
234			* If you need to wrap a non-constant string, use cx_mutstrn().
235			*
236			* @param cstring the string to wrap (or @c NULL, only if the length is zero)
237			* @param length the length of the string
238			* @return the wrapped string
239			*
240			* @see cx_str()
241			*/
242			cx_attr_nodiscard
243			cx_attr_access_r(1, 2)
244			cx_attr_export
245			cxstring cx_strn(
246			const char *cstring,
247			size_t length
248			);
249
250			#ifdef __cplusplus
251			} // extern "C"
252			cx_attr_nodiscard
253			static inline cxstring cx_strcast(cxmutstr str) {
254			return cx_strn(str.ptr, str.length);
255			}
256			cx_attr_nodiscard
257			static inline cxstring cx_strcast(cxstring str) {
258			return str;
259			}
260			extern "C" {
261			#else
262			/**
263			* Internal function, do not use.
264			* @param str
265			* @return
266			* @see cx_strcast()
267			*/
268			cx_attr_nodiscard
269		663	static inline cxstring cx_strcast_m(cxmutstr str) {
270		663	return (cxstring) {str.ptr, str.length};
271			}
272			/**
273			* Internal function, do not use.
274			* @param str
275			* @return
276			* @see cx_strcast()
277			*/
278			cx_attr_nodiscard
279		1265	static inline cxstring cx_strcast_c(cxstring str) {
280		1265	return str;
281			}
282
283			/**
284			* Casts a mutable string to an immutable string.
285			*
286			* Does nothing for already immutable strings.
287			*
288			* @note This is not seriously a cast. Instead, you get a copy
289			* of the struct with the desired pointer type. Both structs still
290			* point to the same location, though!
291			*
292			* @param str (@c cxstring or @c cxmutstr) the string to cast
293			* @return (@c cxstring) an immutable copy of the string pointer
294			*/
295			#define cx_strcast(str) _Generic((str), \
296			cxmutstr: cx_strcast_m, \
297			cxstring: cx_strcast_c) \
298			(str)
299			#endif
300
301			/**
302			* Passes the pointer in this string to @c free().
303			*
304			* The pointer in the struct is set to @c NULL and the length is set to zero
305			* which means that this function protects you against double-free.
306			*
307			* @note There is no implementation for cxstring, because it is unlikely that
308			* you ever have a <code>const char*</code> you are really supposed to free.
309			* If you encounter such situation, you should double-check your code.
310			*
311			* @param str the string to free
312			*/
313			cx_attr_export
314			void cx_strfree(cxmutstr *str);
315
316			/**
317			* Passes the pointer in this string to the allocators free function.
318			*
319			* The pointer in the struct is set to @c NULL and the length is set to zero
320			* which means that this function protects you against double-free.
321			*
322			* @note There is no implementation for cxstring, because it is unlikely that
323			* you ever have a <code>const char*</code> you are really supposed to free.
324			* If you encounter such situation, you should double-check your code.
325			*
326			* @param alloc the allocator
327			* @param str the string to free
328			*/
329			cx_attr_nonnull_arg(1)
330			cx_attr_export
331			void cx_strfree_a(
332			const CxAllocator *alloc,
333			cxmutstr *str
334			);
335
336			/**
337			* Returns the accumulated length of all specified strings.
338			*
339			* If this sum overflows, errno is set to EOVERFLOW.
340			*
341			* @attention if the count argument is larger than the number of the
342			* specified strings, the behavior is undefined.
343			*
344			* @param count the total number of specified strings
345			* @param ... all strings
346			* @return the accumulated length of all strings
347			*/
348			cx_attr_nodiscard
349			cx_attr_export
350			size_t cx_strlen(
351			size_t count,
352			...
353			);
354
355			/**
356			* Concatenates strings.
357			*
358			* The resulting string will be allocated by the specified allocator.
359			* So developers @em must pass the return value to cx_strfree_a() eventually.
360			*
361			* If @p str already contains a string, the memory will be reallocated and
362			* the other strings are appended. Otherwise, new memory is allocated.
363			*
364			* If memory allocation fails, the pointer in the returned string will
365			* be @c NULL. Depending on the allocator, @c errno might be set.
366			*
367			* @note It is guaranteed that there is only one allocation for the
368			* resulting string.
369			* It is also guaranteed that the returned string is zero-terminated.
370			*
371			* @param alloc the allocator to use
372			* @param str the string the other strings shall be concatenated to
373			* @param count the number of the other following strings to concatenate
374			* @param ... all other UCX strings
375			* @return the concatenated string
376			*/
377			cx_attr_nodiscard
378			cx_attr_nonnull
379			cx_attr_export
380			cxmutstr cx_strcat_ma(
381			const CxAllocator *alloc,
382			cxmutstr str,
383			size_t count,
384			...
385			);
386
387			/**
388			* Concatenates strings and returns a new string.
389			*
390			* The resulting string will be allocated by the specified allocator.
391			* So developers @em must pass the return value to cx_strfree_a() eventually.
392			*
393			* If memory allocation fails, the pointer in the returned string will
394			* be @c NULL. Depending on the allocator, @c errno might be set.
395			*
396			* @note It is guaranteed that there is only one allocation for the
397			* resulting string.
398			* It is also guaranteed that the returned string is zero-terminated.
399			*
400			* @param alloc (@c CxAllocator*) the allocator to use
401			* @param count (@c size_t) the number of the other following strings to concatenate
402			* @param ... all other UCX strings
403			* @return (@c cxmutstr) the concatenated string
404			*/
405			#define cx_strcat_a(alloc, count, ...) \
406			cx_strcat_ma(alloc, cx_mutstrn(NULL, 0), count, __VA_ARGS__)
407
408			/**
409			* Concatenates strings and returns a new string.
410			*
411			* The resulting string will be allocated by standard @c malloc().
412			* So developers @em must pass the return value to cx_strfree() eventually.
413			*
414			* If memory allocation fails, the pointer in the returned string will
415			* be @c NULL and @c errno might be set.
416			*
417			* @note It is guaranteed that there is only one allocation for the
418			* resulting string.
419			* It is also guaranteed that the returned string is zero-terminated.
420			*
421			* @param count (@c size_t) the number of the other following strings to concatenate
422			* @param ... all other UCX strings
423			* @return (@c cxmutstr) the concatenated string
424			*/
425			#define cx_strcat(count, ...) \
426			cx_strcat_ma(cxDefaultAllocator, cx_mutstrn(NULL, 0), count, __VA_ARGS__)
427
428			/**
429			* Concatenates strings.
430			*
431			* The resulting string will be allocated by standard @c malloc().
432			* So developers @em must pass the return value to cx_strfree() eventually.
433			*
434			* If @p str already contains a string, the memory will be reallocated and
435			* the other strings are appended. Otherwise, new memory is allocated.
436			*
437			* If memory allocation fails, the pointer in the returned string will
438			* be @c NULL and @c errno might be set.
439			*
440			* @note It is guaranteed that there is only one allocation for the
441			* resulting string.
442			* It is also guaranteed that the returned string is zero-terminated.
443			*
444			* @param str (@c cxmutstr) the string the other strings shall be concatenated to
445			* @param count (@c size_t) the number of the other following strings to concatenate
446			* @param ... all other strings
447			* @return (@c cxmutstr) the concatenated string
448			*/
449			#define cx_strcat_m(str, count, ...) \
450			cx_strcat_ma(cxDefaultAllocator, str, count, __VA_ARGS__)
451
452			/**
453			* Returns a substring starting at the specified location.
454			*
455			* @attention the new string references the same memory area as the
456			* input string and is usually @em not zero-terminated.
457			* Use cx_strdup() to get a copy.
458			*
459			* @param string input string
460			* @param start start location of the substring
461			* @return a substring of @p string starting at @p start
462			*
463			* @see cx_strsubsl()
464			* @see cx_strsubs_m()
465			* @see cx_strsubsl_m()
466			*/
467			cx_attr_nodiscard
468			cx_attr_export
469			cxstring cx_strsubs(
470			cxstring string,
471			size_t start
472			);
473
474			/**
475			* Returns a substring starting at the specified location.
476			*
477			* The returned string will be limited to @p length bytes or the number
478			* of bytes available in @p string, whichever is smaller.
479			*
480			* @attention the new string references the same memory area as the
481			* input string and is usually @em not zero-terminated.
482			* Use cx_strdup() to get a copy.
483			*
484			* @param string input string
485			* @param start start location of the substring
486			* @param length the maximum length of the returned string
487			* @return a substring of @p string starting at @p start
488			*
489			* @see cx_strsubs()
490			* @see cx_strsubs_m()
491			* @see cx_strsubsl_m()
492			*/
493			cx_attr_nodiscard
494			cx_attr_export
495			cxstring cx_strsubsl(
496			cxstring string,
497			size_t start,
498			size_t length
499			);
500
501			/**
502			* Returns a substring starting at the specified location.
503			*
504			* @attention the new string references the same memory area as the
505			* input string and is usually @em not zero-terminated.
506			* Use cx_strdup() to get a copy.
507			*
508			* @param string input string
509			* @param start start location of the substring
510			* @return a substring of @p string starting at @p start
511			*
512			* @see cx_strsubsl_m()
513			* @see cx_strsubs()
514			* @see cx_strsubsl()
515			*/
516			cx_attr_nodiscard
517			cx_attr_export
518			cxmutstr cx_strsubs_m(
519			cxmutstr string,
520			size_t start
521			);
522
523			/**
524			* Returns a substring starting at the specified location.
525			*
526			* The returned string will be limited to @p length bytes or the number
527			* of bytes available in @p string, whichever is smaller.
528			*
529			* @attention the new string references the same memory area as the
530			* input string and is usually @em not zero-terminated.
531			* Use cx_strdup() to get a copy.
532			*
533			* @param string input string
534			* @param start start location of the substring
535			* @param length the maximum length of the returned string
536			* @return a substring of @p string starting at @p start
537			*
538			* @see cx_strsubs_m()
539			* @see cx_strsubs()
540			* @see cx_strsubsl()
541			*/
542			cx_attr_nodiscard
543			cx_attr_export
544			cxmutstr cx_strsubsl_m(
545			cxmutstr string,
546			size_t start,
547			size_t length
548			);
549
550			/**
551			* Returns a substring starting at the location of the first occurrence of the
552			* specified character.
553			*
554			* If the string does not contain the character, an empty string is returned.
555			*
556			* @param string the string where to locate the character
557			* @param chr the character to locate
558			* @return a substring starting at the first location of @p chr
559			*
560			* @see cx_strchr_m()
561			*/
562			cx_attr_nodiscard
563			cx_attr_export
564			cxstring cx_strchr(
565			cxstring string,
566			int chr
567			);
568
569			/**
570			* Returns a substring starting at the location of the first occurrence of the
571			* specified character.
572			*
573			* If the string does not contain the character, an empty string is returned.
574			*
575			* @param string the string where to locate the character
576			* @param chr the character to locate
577			* @return a substring starting at the first location of @p chr
578			*
579			* @see cx_strchr()
580			*/
581			cx_attr_nodiscard
582			cx_attr_export
583			cxmutstr cx_strchr_m(
584			cxmutstr string,
585			int chr
586			);
587
588			/**
589			* Returns a substring starting at the location of the last occurrence of the
590			* specified character.
591			*
592			* If the string does not contain the character, an empty string is returned.
593			*
594			* @param string the string where to locate the character
595			* @param chr the character to locate
596			* @return a substring starting at the last location of @p chr
597			*
598			* @see cx_strrchr_m()
599			*/
600			cx_attr_nodiscard
601			cx_attr_export
602			cxstring cx_strrchr(
603			cxstring string,
604			int chr
605			);
606
607			/**
608			* Returns a substring starting at the location of the last occurrence of the
609			* specified character.
610			*
611			* If the string does not contain the character, an empty string is returned.
612			*
613			* @param string the string where to locate the character
614			* @param chr the character to locate
615			* @return a substring starting at the last location of @p chr
616			*
617			* @see cx_strrchr()
618			*/
619			cx_attr_nodiscard
620			cx_attr_export
621			cxmutstr cx_strrchr_m(
622			cxmutstr string,
623			int chr
624			);
625
626			/**
627			* Returns a substring starting at the location of the first occurrence of the
628			* specified string.
629			*
630			* If @p haystack does not contain @p needle, an empty string is returned.
631			*
632			* If @p needle is an empty string, the complete @p haystack is
633			* returned.
634			*
635			* @param haystack the string to be scanned
636			* @param needle string containing the sequence of characters to match
637			* @return a substring starting at the first occurrence of
638			* @p needle, or an empty string, if the sequence is not
639			* contained
640			* @see cx_strstr_m()
641			*/
642			cx_attr_nodiscard
643			cx_attr_export
644			cxstring cx_strstr(
645			cxstring haystack,
646			cxstring needle
647			);
648
649			/**
650			* Returns a substring starting at the location of the first occurrence of the
651			* specified string.
652			*
653			* If @p haystack does not contain @p needle, an empty string is returned.
654			*
655			* If @p needle is an empty string, the complete @p haystack is
656			* returned.
657			*
658			* @param haystack the string to be scanned
659			* @param needle string containing the sequence of characters to match
660			* @return a substring starting at the first occurrence of
661			* @p needle, or an empty string, if the sequence is not
662			* contained
663			* @see cx_strstr()
664			*/
665			cx_attr_nodiscard
666			cx_attr_export
667			cxmutstr cx_strstr_m(
668			cxmutstr haystack,
669			cxstring needle
670			);
671
672			/**
673			* Splits a given string using a delimiter string.
674			*
675			* @note The resulting array contains strings that point to the source
676			* @p string. Use cx_strdup() to get copies.
677			*
678			* @param string the string to split
679			* @param delim the delimiter
680			* @param limit the maximum number of split items
681			* @param output a preallocated array of at least @p limit length
682			* @return the actual number of split items
683			*/
684			cx_attr_nodiscard
685			cx_attr_nonnull
686			cx_attr_access_w(4, 3)
687			cx_attr_export
688			size_t cx_strsplit(
689			cxstring string,
690			cxstring delim,
691			size_t limit,
692			cxstring *output
693			);
694
695			/**
696			* Splits a given string using a delimiter string.
697			*
698			* The array pointed to by @p output will be allocated by @p allocator.
699			*
700			* @note The resulting array contains strings that point to the source
701			* @p string. Use cx_strdup() to get copies.
702			*
703			* @attention If allocation fails, the @c NULL pointer will be written to
704			* @p output and the number returned will be zero.
705			*
706			* @param allocator the allocator to use for allocating the resulting array
707			* @param string the string to split
708			* @param delim the delimiter
709			* @param limit the maximum number of split items
710			* @param output a pointer where the address of the allocated array shall be
711			* written to
712			* @return the actual number of split items
713			*/
714			cx_attr_nodiscard
715			cx_attr_nonnull
716			cx_attr_access_w(5)
717			cx_attr_export
718			size_t cx_strsplit_a(
719			const CxAllocator *allocator,
720			cxstring string,
721			cxstring delim,
722			size_t limit,
723			cxstring **output
724			);
725
726
727			/**
728			* Splits a given string using a delimiter string.
729			*
730			* @note The resulting array contains strings that point to the source
731			* @p string. Use cx_strdup() to get copies.
732			*
733			* @param string the string to split
734			* @param delim the delimiter
735			* @param limit the maximum number of split items
736			* @param output a preallocated array of at least @p limit length
737			* @return the actual number of split items
738			*/
739			cx_attr_nodiscard
740			cx_attr_nonnull
741			cx_attr_access_w(4, 3)
742			cx_attr_export
743			size_t cx_strsplit_m(
744			cxmutstr string,
745			cxstring delim,
746			size_t limit,
747			cxmutstr *output
748			);
749
750			/**
751			* Splits a given string using a delimiter string.
752			*
753			* The array pointed to by @p output will be allocated by @p allocator.
754			*
755			* @note The resulting array contains strings that point to the source
756			* @p string. Use cx_strdup() to get copies.
757			*
758			* @attention If allocation fails, the @c NULL pointer will be written to
759			* @p output and the number returned will be zero.
760			*
761			* @param allocator the allocator to use for allocating the resulting array
762			* @param string the string to split
763			* @param delim the delimiter
764			* @param limit the maximum number of split items
765			* @param output a pointer where the address of the allocated array shall be
766			* written to
767			* @return the actual number of split items
768			*/
769			cx_attr_nodiscard
770			cx_attr_nonnull
771			cx_attr_access_w(5)
772			cx_attr_export
773			size_t cx_strsplit_ma(
774			const CxAllocator *allocator,
775			cxmutstr string,
776			cxstring delim,
777			size_t limit,
778			cxmutstr **output
779			);
780
781			/**
782			* Compares two strings.
783			*
784			* @param s1 the first string
785			* @param s2 the second string
786			* @return negative if @p s1 is smaller than @p s2, positive if @p s1 is larger
787			* than @p s2, zero if both strings equal
788			*/
789			cx_attr_nodiscard
790			cx_attr_export
791			int cx_strcmp(
792			cxstring s1,
793			cxstring s2
794			);
795
796			/**
797			* Compares two strings ignoring case.
798			*
799			* @param s1 the first string
800			* @param s2 the second string
801			* @return negative if @p s1 is smaller than @p s2, positive if @p s1 is larger
802			* than @p s2, zero if both strings equal ignoring case
803			*/
804			cx_attr_nodiscard
805			cx_attr_export
806			int cx_strcasecmp(
807			cxstring s1,
808			cxstring s2
809			);
810
811			/**
812			* Compares two strings.
813			*
814			* This function has a compatible signature for the use as a cx_compare_func.
815			*
816			* @param s1 the first string
817			* @param s2 the second string
818			* @return negative if @p s1 is smaller than @p s2, positive if @p s1 is larger
819			* than @p s2, zero if both strings equal
820			*/
821			cx_attr_nodiscard
822			cx_attr_nonnull
823			cx_attr_export
824			int cx_strcmp_p(
825			const void *s1,
826			const void *s2
827			);
828
829			/**
830			* Compares two strings ignoring case.
831			*
832			* This function has a compatible signature for the use as a cx_compare_func.
833			*
834			* @param s1 the first string
835			* @param s2 the second string
836			* @return negative if @p s1 is smaller than @p s2, positive if @p s1 is larger
837			* than @p s2, zero if both strings equal ignoring case
838			*/
839			cx_attr_nodiscard
840			cx_attr_nonnull
841			cx_attr_export
842			int cx_strcasecmp_p(
843			const void *s1,
844			const void *s2
845			);
846
847
848			/**
849			* Creates a duplicate of the specified string.
850			*
851			* The new string will contain a copy allocated by @p allocator.
852			*
853			* @note The returned string is guaranteed to be zero-terminated.
854			*
855			* @param allocator the allocator to use
856			* @param string the string to duplicate
857			* @return a duplicate of the string
858			* @see cx_strdup()
859			*/
860			cx_attr_nodiscard
861			cx_attr_nonnull
862			cx_attr_export
863			cxmutstr cx_strdup_a_(
864			const CxAllocator *allocator,
865			cxstring string
866			);
867
868			/**
869			* Creates a duplicate of the specified string.
870			*
871			* The new string will contain a copy allocated by @p allocator.
872			*
873			* @note The returned string is guaranteed to be zero-terminated.
874			*
875			* @param allocator (@c CxAllocator*) the allocator to use
876			* @param string the string to duplicate
877			* @return (@c cxmutstr) a duplicate of the string
878			* @see cx_strdup()
879			* @see cx_strfree_a()
880			*/
881			#define cx_strdup_a(allocator, string) \
882			cx_strdup_a_((allocator), cx_strcast(string))
883
884			/**
885			* Creates a duplicate of the specified string.
886			*
887			* The new string will contain a copy allocated by standard
888			* @c malloc(). So developers @em must pass the return value to cx_strfree().
889			*
890			* @note The returned string is guaranteed to be zero-terminated.
891			*
892			* @param string the string to duplicate
893			* @return (@c cxmutstr) a duplicate of the string
894			* @see cx_strdup_a()
895			* @see cx_strfree()
896			*/
897			#define cx_strdup(string) cx_strdup_a(cxDefaultAllocator, string)
898
899			/**
900			* Omits leading and trailing spaces.
901			*
902			* @note the returned string references the same memory, thus you
903			* must @em not free the returned memory.
904			*
905			* @param string the string that shall be trimmed
906			* @return the trimmed string
907			*/
908			cx_attr_nodiscard
909			cx_attr_export
910			cxstring cx_strtrim(cxstring string);
911
912			/**
913			* Omits leading and trailing spaces.
914			*
915			* @note the returned string references the same memory, thus you
916			* must @em not free the returned memory.
917			*
918			* @param string the string that shall be trimmed
919			* @return the trimmed string
920			*/
921			cx_attr_nodiscard
922			cx_attr_export
923			cxmutstr cx_strtrim_m(cxmutstr string);
924
925			/**
926			* Checks, if a string has a specific prefix.
927			*
928			* @param string the string to check
929			* @param prefix the prefix the string should have
930			* @return @c true, if and only if the string has the specified prefix,
931			* @c false otherwise
932			*/
933			cx_attr_nodiscard
934			cx_attr_export
935			bool cx_strprefix(
936			cxstring string,
937			cxstring prefix
938			);
939
940			/**
941			* Checks, if a string has a specific suffix.
942			*
943			* @param string the string to check
944			* @param suffix the suffix the string should have
945			* @return @c true, if and only if the string has the specified suffix,
946			* @c false otherwise
947			*/
948			cx_attr_nodiscard
949			cx_attr_export
950			bool cx_strsuffix(
951			cxstring string,
952			cxstring suffix
953			);
954
955			/**
956			* Checks, if a string has a specific prefix, ignoring the case.
957			*
958			* @param string the string to check
959			* @param prefix the prefix the string should have
960			* @return @c true, if and only if the string has the specified prefix,
961			* @c false otherwise
962			*/
963			cx_attr_nodiscard
964			cx_attr_export
965			bool cx_strcaseprefix(
966			cxstring string,
967			cxstring prefix
968			);
969
970			/**
971			* Checks, if a string has a specific suffix, ignoring the case.
972			*
973			* @param string the string to check
974			* @param suffix the suffix the string should have
975			* @return @c true, if and only if the string has the specified suffix,
976			* @c false otherwise
977			*/
978			cx_attr_nodiscard
979			cx_attr_export
980			bool cx_strcasesuffix(
981			cxstring string,
982			cxstring suffix
983			);
984
985			/**
986			* Replaces a string with another string.
987			*
988			* Replaces at most @p replmax occurrences.
989			*
990			* The returned string will be allocated by @p allocator and is guaranteed
991			* to be zero-terminated.
992			*
993			* If allocation fails, or the input string is empty,
994			* the returned string will be empty.
995			*
996			* @param allocator the allocator to use
997			* @param str the string where replacements should be applied
998			* @param search the string to search for
999			* @param replacement the replacement string
1000			* @param replmax maximum number of replacements
1001			* @return the resulting string after applying the replacements
1002			*/
1003			cx_attr_nodiscard
1004			cx_attr_nonnull
1005			cx_attr_export
1006			cxmutstr cx_strreplacen_a(
1007			const CxAllocator *allocator,
1008			cxstring str,
1009			cxstring search,
1010			cxstring replacement,
1011			size_t replmax
1012			);
1013
1014			/**
1015			* Replaces a string with another string.
1016			*
1017			* Replaces at most @p replmax occurrences.
1018			*
1019			* The returned string will be allocated by @c malloc() and is guaranteed
1020			* to be zero-terminated.
1021			*
1022			* If allocation fails, or the input string is empty,
1023			* the returned string will be empty.
1024			*
1025			* @param str (@c cxstring) the string where replacements should be applied
1026			* @param search (@c cxstring) the string to search for
1027			* @param replacement (@c cxstring) the replacement string
1028			* @param replmax (@c size_t) maximum number of replacements
1029			* @return (@c cxmutstr) the resulting string after applying the replacements
1030			*/
1031			#define cx_strreplacen(str, search, replacement, replmax) \
1032			cx_strreplacen_a(cxDefaultAllocator, str, search, replacement, replmax)
1033
1034			/**
1035			* Replaces a string with another string.
1036			*
1037			* The returned string will be allocated by @p allocator and is guaranteed
1038			* to be zero-terminated.
1039			*
1040			* If allocation fails, or the input string is empty,
1041			* the returned string will be empty.
1042			*
1043			* @param allocator (@c CxAllocator*) the allocator to use
1044			* @param str (@c cxstring) the string where replacements should be applied
1045			* @param search (@c cxstring) the string to search for
1046			* @param replacement (@c cxstring) the replacement string
1047			* @return (@c cxmutstr) the resulting string after applying the replacements
1048			*/
1049			#define cx_strreplace_a(allocator, str, search, replacement) \
1050			cx_strreplacen_a(allocator, str, search, replacement, SIZE_MAX)
1051
1052			/**
1053			* Replaces a string with another string.
1054			*
1055			* The returned string will be allocated by @c malloc() and is guaranteed
1056			* to be zero-terminated.
1057			*
1058			* If allocation fails, or the input string is empty,
1059			* the returned string will be empty.
1060			*
1061			* @param str (@c cxstring) the string where replacements should be applied
1062			* @param search (@c cxstring) the string to search for
1063			* @param replacement (@c cxstring) the replacement string
1064			* @return (@c cxmutstr) the resulting string after applying the replacements
1065			*/
1066			#define cx_strreplace(str, search, replacement) \
1067			cx_strreplacen_a(cxDefaultAllocator, str, search, replacement, SIZE_MAX)
1068
1069			/**
1070			* Creates a string tokenization context.
1071			*
1072			* @param str the string to tokenize
1073			* @param delim the delimiter (must not be empty)
1074			* @param limit the maximum number of tokens that shall be returned
1075			* @return a new string tokenization context
1076			*/
1077			cx_attr_nodiscard
1078			cx_attr_export
1079			CxStrtokCtx cx_strtok_(
1080			cxstring str,
1081			cxstring delim,
1082			size_t limit
1083			);
1084
1085			/**
1086			* Creates a string tokenization context.
1087			*
1088			* @param str the string to tokenize
1089			* @param delim the delimiter string (must not be empty)
1090			* @param limit (@c size_t) the maximum number of tokens that shall be returned
1091			* @return (@c CxStrtokCtx) a new string tokenization context
1092			*/
1093			#define cx_strtok(str, delim, limit) \
1094			cx_strtok_(cx_strcast(str), cx_strcast(delim), (limit))
1095
1096			/**
1097			* Returns the next token.
1098			*
1099			* The token will point to the source string.
1100			*
1101			* @param ctx the tokenization context
1102			* @param token a pointer to memory where the next token shall be stored
1103			* @return true if successful, false if the limit or the end of the string
1104			* has been reached
1105			*/
1106			cx_attr_nonnull
1107			cx_attr_nodiscard
1108			cx_attr_access_w(2)
1109			cx_attr_export
1110			bool cx_strtok_next(
1111			CxStrtokCtx *ctx,
1112			cxstring *token
1113			);
1114
1115			/**
1116			* Returns the next token of a mutable string.
1117			*
1118			* The token will point to the source string.
1119			*
1120			* @attention
1121			* If the context was not initialized over a mutable string, modifying
1122			* the data of the returned token is undefined behavior.
1123			*
1124			* @param ctx the tokenization context
1125			* @param token a pointer to memory where the next token shall be stored
1126			* @return true if successful, false if the limit or the end of the string
1127			* has been reached
1128			*/
1129			cx_attr_nonnull
1130			cx_attr_nodiscard
1131			cx_attr_access_w(2)
1132			cx_attr_export
1133			bool cx_strtok_next_m(
1134			CxStrtokCtx *ctx,
1135			cxmutstr *token
1136			);
1137
1138			/**
1139			* Defines an array of more delimiters for the specified tokenization context.
1140			*
1141			* @param ctx the tokenization context
1142			* @param delim array of more delimiters
1143			* @param count number of elements in the array
1144			*/
1145			cx_attr_nonnull
1146			cx_attr_access_r(2, 3)
1147			cx_attr_export
1148			void cx_strtok_delim(
1149			CxStrtokCtx *ctx,
1150			const cxstring *delim,
1151			size_t count
1152			);
1153
1154			/* ------------------------------------------------------------------------- *
1155			* string to number conversion functions *
1156			* ------------------------------------------------------------------------- */
1157
1158			/**
1159			* Converts a string to a number.
1160			*
1161			* The function returns non-zero when conversion is not possible.
1162			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1163			* It sets errno to ERANGE when the target datatype is too small.
1164			*
1165			* @param str the string to convert
1166			* @param output a pointer to the integer variable where the result shall be stored
1167			* @param base 2, 8, 10, or 16
1168			* @param groupsep each character in this string is treated as group separator and ignored during conversion
1169			* @retval zero success
1170			* @retval non-zero conversion was not possible
1171			*/
1172			cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
1173			int cx_strtos_lc_(cxstring str, short *output, int base, const char *groupsep);
1174
1175			/**
1176			* Converts a string to a number.
1177			*
1178			* The function returns non-zero when conversion is not possible.
1179			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1180			* It sets errno to ERANGE when the target datatype is too small.
1181			*
1182			* @param str the string to convert
1183			* @param output a pointer to the integer variable where the result shall be stored
1184			* @param base 2, 8, 10, or 16
1185			* @param groupsep each character in this string is treated as group separator and ignored during conversion
1186			* @retval zero success
1187			* @retval non-zero conversion was not possible
1188			*/
1189			cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
1190			int cx_strtoi_lc_(cxstring str, int *output, int base, const char *groupsep);
1191
1192			/**
1193			* Converts a string to a number.
1194			*
1195			* The function returns non-zero when conversion is not possible.
1196			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1197			* It sets errno to ERANGE when the target datatype is too small.
1198			*
1199			* @param str the string to convert
1200			* @param output a pointer to the integer variable where the result shall be stored
1201			* @param base 2, 8, 10, or 16
1202			* @param groupsep each character in this string is treated as group separator and ignored during conversion
1203			* @retval zero success
1204			* @retval non-zero conversion was not possible
1205			*/
1206			cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
1207			int cx_strtol_lc_(cxstring str, long *output, int base, const char *groupsep);
1208
1209			/**
1210			* Converts a string to a number.
1211			*
1212			* The function returns non-zero when conversion is not possible.
1213			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1214			* It sets errno to ERANGE when the target datatype is too small.
1215			*
1216			* @param str the string to convert
1217			* @param output a pointer to the integer variable where the result shall be stored
1218			* @param base 2, 8, 10, or 16
1219			* @param groupsep each character in this string is treated as group separator and ignored during conversion
1220			* @retval zero success
1221			* @retval non-zero conversion was not possible
1222			*/
1223			cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
1224			int cx_strtoll_lc_(cxstring str, long long *output, int base, const char *groupsep);
1225
1226			/**
1227			* Converts a string to a number.
1228			*
1229			* The function returns non-zero when conversion is not possible.
1230			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1231			* It sets errno to ERANGE when the target datatype is too small.
1232			*
1233			* @param str the string to convert
1234			* @param output a pointer to the integer variable where the result shall be stored
1235			* @param base 2, 8, 10, or 16
1236			* @param groupsep each character in this string is treated as group separator and ignored during conversion
1237			* @retval zero success
1238			* @retval non-zero conversion was not possible
1239			*/
1240			cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
1241			int cx_strtoi8_lc_(cxstring str, int8_t *output, int base, const char *groupsep);
1242
1243			/**
1244			* Converts a string to a number.
1245			*
1246			* The function returns non-zero when conversion is not possible.
1247			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1248			* It sets errno to ERANGE when the target datatype is too small.
1249			*
1250			* @param str the string to convert
1251			* @param output a pointer to the integer variable where the result shall be stored
1252			* @param base 2, 8, 10, or 16
1253			* @param groupsep each character in this string is treated as group separator and ignored during conversion
1254			* @retval zero success
1255			* @retval non-zero conversion was not possible
1256			*/
1257			cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
1258			int cx_strtoi16_lc_(cxstring str, int16_t *output, int base, const char *groupsep);
1259
1260			/**
1261			* Converts a string to a number.
1262			*
1263			* The function returns non-zero when conversion is not possible.
1264			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1265			* It sets errno to ERANGE when the target datatype is too small.
1266			*
1267			* @param str the string to convert
1268			* @param output a pointer to the integer variable where the result shall be stored
1269			* @param base 2, 8, 10, or 16
1270			* @param groupsep each character in this string is treated as group separator and ignored during conversion
1271			* @retval zero success
1272			* @retval non-zero conversion was not possible
1273			*/
1274			cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
1275			int cx_strtoi32_lc_(cxstring str, int32_t *output, int base, const char *groupsep);
1276
1277			/**
1278			* Converts a string to a number.
1279			*
1280			* The function returns non-zero when conversion is not possible.
1281			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1282			* It sets errno to ERANGE when the target datatype is too small.
1283			*
1284			* @param str the string to convert
1285			* @param output a pointer to the integer variable where the result shall be stored
1286			* @param base 2, 8, 10, or 16
1287			* @param groupsep each character in this string is treated as group separator and ignored during conversion
1288			* @retval zero success
1289			* @retval non-zero conversion was not possible
1290			*/
1291			cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
1292			int cx_strtoi64_lc_(cxstring str, int64_t *output, int base, const char *groupsep);
1293
1294			/**
1295			* Converts a string to a number.
1296			*
1297			* The function returns non-zero when conversion is not possible.
1298			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1299			* It sets errno to ERANGE when the target datatype is too small.
1300			*
1301			* @param str the string to convert
1302			* @param output a pointer to the integer variable where the result shall be stored
1303			* @param base 2, 8, 10, or 16
1304			* @param groupsep each character in this string is treated as group separator and ignored during conversion
1305			* @retval zero success
1306			* @retval non-zero conversion was not possible
1307			*/
1308			cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
1309			int cx_strtous_lc_(cxstring str, unsigned short *output, int base, const char *groupsep);
1310
1311			/**
1312			* Converts a string to a number.
1313			*
1314			* The function returns non-zero when conversion is not possible.
1315			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1316			* It sets errno to ERANGE when the target datatype is too small.
1317			*
1318			* @param str the string to convert
1319			* @param output a pointer to the integer variable where the result shall be stored
1320			* @param base 2, 8, 10, or 16
1321			* @param groupsep each character in this string is treated as group separator and ignored during conversion
1322			* @retval zero success
1323			* @retval non-zero conversion was not possible
1324			*/
1325			cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
1326			int cx_strtou_lc_(cxstring str, unsigned int *output, int base, const char *groupsep);
1327
1328			/**
1329			* Converts a string to a number.
1330			*
1331			* The function returns non-zero when conversion is not possible.
1332			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1333			* It sets errno to ERANGE when the target datatype is too small.
1334			*
1335			* @param str the string to convert
1336			* @param output a pointer to the integer variable where the result shall be stored
1337			* @param base 2, 8, 10, or 16
1338			* @param groupsep each character in this string is treated as group separator and ignored during conversion
1339			* @retval zero success
1340			* @retval non-zero conversion was not possible
1341			*/
1342			cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
1343			int cx_strtoul_lc_(cxstring str, unsigned long *output, int base, const char *groupsep);
1344
1345			/**
1346			* Converts a string to a number.
1347			*
1348			* The function returns non-zero when conversion is not possible.
1349			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1350			* It sets errno to ERANGE when the target datatype is too small.
1351			*
1352			* @param str the string to convert
1353			* @param output a pointer to the integer variable where the result shall be stored
1354			* @param base 2, 8, 10, or 16
1355			* @param groupsep each character in this string is treated as group separator and ignored during conversion
1356			* @retval zero success
1357			* @retval non-zero conversion was not possible
1358			*/
1359			cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
1360			int cx_strtoull_lc_(cxstring str, unsigned long long *output, int base, const char *groupsep);
1361
1362			/**
1363			* Converts a string to a number.
1364			*
1365			* The function returns non-zero when conversion is not possible.
1366			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1367			* It sets errno to ERANGE when the target datatype is too small.
1368			*
1369			* @param str the string to convert
1370			* @param output a pointer to the integer variable where the result shall be stored
1371			* @param base 2, 8, 10, or 16
1372			* @param groupsep each character in this string is treated as group separator and ignored during conversion
1373			* @retval zero success
1374			* @retval non-zero conversion was not possible
1375			*/
1376			cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
1377			int cx_strtou8_lc_(cxstring str, uint8_t *output, int base, const char *groupsep);
1378
1379			/**
1380			* Converts a string to a number.
1381			*
1382			* The function returns non-zero when conversion is not possible.
1383			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1384			* It sets errno to ERANGE when the target datatype is too small.
1385			*
1386			* @param str the string to convert
1387			* @param output a pointer to the integer variable where the result shall be stored
1388			* @param base 2, 8, 10, or 16
1389			* @param groupsep each character in this string is treated as group separator and ignored during conversion
1390			* @retval zero success
1391			* @retval non-zero conversion was not possible
1392			*/
1393			cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
1394			int cx_strtou16_lc_(cxstring str, uint16_t *output, int base, const char *groupsep);
1395
1396			/**
1397			* Converts a string to a number.
1398			*
1399			* The function returns non-zero when conversion is not possible.
1400			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1401			* It sets errno to ERANGE when the target datatype is too small.
1402			*
1403			* @param str the string to convert
1404			* @param output a pointer to the integer variable where the result shall be stored
1405			* @param base 2, 8, 10, or 16
1406			* @param groupsep each character in this string is treated as group separator and ignored during conversion
1407			* @retval zero success
1408			* @retval non-zero conversion was not possible
1409			*/
1410			cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
1411			int cx_strtou32_lc_(cxstring str, uint32_t *output, int base, const char *groupsep);
1412
1413			/**
1414			* Converts a string to a number.
1415			*
1416			* The function returns non-zero when conversion is not possible.
1417			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1418			* It sets errno to ERANGE when the target datatype is too small.
1419			*
1420			* @param str the string to convert
1421			* @param output a pointer to the integer variable where the result shall be stored
1422			* @param base 2, 8, 10, or 16
1423			* @param groupsep each character in this string is treated as group separator and ignored during conversion
1424			* @retval zero success
1425			* @retval non-zero conversion was not possible
1426			*/
1427			cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
1428			int cx_strtou64_lc_(cxstring str, uint64_t *output, int base, const char *groupsep);
1429
1430			/**
1431			* Converts a string to a number.
1432			*
1433			* The function returns non-zero when conversion is not possible.
1434			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1435			* It sets errno to ERANGE when the target datatype is too small.
1436			*
1437			* @param str the string to convert
1438			* @param output a pointer to the integer variable where the result shall be stored
1439			* @param base 2, 8, 10, or 16
1440			* @param groupsep each character in this string is treated as group separator and ignored during conversion
1441			* @retval zero success
1442			* @retval non-zero conversion was not possible
1443			*/
1444			cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
1445			int cx_strtoz_lc_(cxstring str, size_t *output, int base, const char *groupsep);
1446
1447			/**
1448			* Converts a string to a single precision floating point number.
1449			*
1450			* The function returns non-zero when conversion is not possible.
1451			* In that case the function sets errno to EINVAL when the reason is an invalid character.
1452			* It sets errno to ERANGE when the necessary representation would exceed the limits defined in libc's float.h.
1453			*
1454			* @param str the string to convert
1455			* @param output a pointer to the float variable where the result shall be stored
1456			* @param decsep the decimal separator
1457			* @param groupsep each character in this string is treated as group separator and ignored during conversion
1458			* @retval zero success
1459			* @retval non-zero conversion was not possible
1460			*/
1461			cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
1462			int cx_strtof_lc_(cxstring str, float *output, char decsep, const char *groupsep);
1463
1464			/**
1465			* Converts a string to a double precision floating point number.
1466			*
1467			* The function returns non-zero when conversion is not possible.
1468			* In that case the function sets errno to EINVAL when the reason is an invalid character.
1469			* It sets errno to ERANGE when the necessary representation would exceed the limits defined in libc's float.h.
1470			*
1471			* @param str the string to convert
1472			* @param output a pointer to the float variable where the result shall be stored
1473			* @param decsep the decimal separator
1474			* @param groupsep each character in this string is treated as group separator and ignored during conversion
1475			* @retval zero success
1476			* @retval non-zero conversion was not possible
1477			*/
1478			cx_attr_access_w(2) cx_attr_nonnull_arg(2) cx_attr_export
1479			int cx_strtod_lc_(cxstring str, double *output, char decsep, const char *groupsep);
1480
1481			/**
1482			* Converts a string to a number.
1483			*
1484			* The function returns non-zero when conversion is not possible.
1485			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1486			* It sets errno to ERANGE when the target datatype is too small.
1487			*
1488			* @param str the string to convert
1489			* @param output a pointer to the integer variable where the result shall be stored
1490			* @param base 2, 8, 10, or 16
1491			* @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion
1492			* @retval zero success
1493			* @retval non-zero conversion was not possible
1494			*/
1495			#define cx_strtos_lc(str, output, base, groupsep) cx_strtos_lc_(cx_strcast(str), output, base, groupsep)
1496
1497			/**
1498			* Converts a string to a number.
1499			*
1500			* The function returns non-zero when conversion is not possible.
1501			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1502			* It sets errno to ERANGE when the target datatype is too small.
1503			*
1504			* @param str the string to convert
1505			* @param output a pointer to the integer variable where the result shall be stored
1506			* @param base 2, 8, 10, or 16
1507			* @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion
1508			* @retval zero success
1509			* @retval non-zero conversion was not possible
1510			*/
1511			#define cx_strtoi_lc(str, output, base, groupsep) cx_strtoi_lc_(cx_strcast(str), output, base, groupsep)
1512
1513			/**
1514			* Converts a string to a number.
1515			*
1516			* The function returns non-zero when conversion is not possible.
1517			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1518			* It sets errno to ERANGE when the target datatype is too small.
1519			*
1520			* @param str the string to convert
1521			* @param output a pointer to the integer variable where the result shall be stored
1522			* @param base 2, 8, 10, or 16
1523			* @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion
1524			* @retval zero success
1525			* @retval non-zero conversion was not possible
1526			*/
1527			#define cx_strtol_lc(str, output, base, groupsep) cx_strtol_lc_(cx_strcast(str), output, base, groupsep)
1528
1529			/**
1530			* Converts a string to a number.
1531			*
1532			* The function returns non-zero when conversion is not possible.
1533			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1534			* It sets errno to ERANGE when the target datatype is too small.
1535			*
1536			* @param str the string to convert
1537			* @param output a pointer to the integer variable where the result shall be stored
1538			* @param base 2, 8, 10, or 16
1539			* @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion
1540			* @retval zero success
1541			* @retval non-zero conversion was not possible
1542			*/
1543			#define cx_strtoll_lc(str, output, base, groupsep) cx_strtoll_lc_(cx_strcast(str), output, base, groupsep)
1544
1545			/**
1546			* Converts a string to a number.
1547			*
1548			* The function returns non-zero when conversion is not possible.
1549			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1550			* It sets errno to ERANGE when the target datatype is too small.
1551			*
1552			* @param str the string to convert
1553			* @param output a pointer to the integer variable where the result shall be stored
1554			* @param base 2, 8, 10, or 16
1555			* @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion
1556			* @retval zero success
1557			* @retval non-zero conversion was not possible
1558			*/
1559			#define cx_strtoi8_lc(str, output, base, groupsep) cx_strtoi8_lc_(cx_strcast(str), output, base, groupsep)
1560
1561			/**
1562			* Converts a string to a number.
1563			*
1564			* The function returns non-zero when conversion is not possible.
1565			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1566			* It sets errno to ERANGE when the target datatype is too small.
1567			*
1568			* @param str the string to convert
1569			* @param output a pointer to the integer variable where the result shall be stored
1570			* @param base 2, 8, 10, or 16
1571			* @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion
1572			* @retval zero success
1573			* @retval non-zero conversion was not possible
1574			*/
1575			#define cx_strtoi16_lc(str, output, base, groupsep) cx_strtoi16_lc_(cx_strcast(str), output, base, groupsep)
1576
1577			/**
1578			* Converts a string to a number.
1579			*
1580			* The function returns non-zero when conversion is not possible.
1581			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1582			* It sets errno to ERANGE when the target datatype is too small.
1583			*
1584			* @param str the string to convert
1585			* @param output a pointer to the integer variable where the result shall be stored
1586			* @param base 2, 8, 10, or 16
1587			* @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion
1588			* @retval zero success
1589			* @retval non-zero conversion was not possible
1590			*/
1591			#define cx_strtoi32_lc(str, output, base, groupsep) cx_strtoi32_lc_(cx_strcast(str), output, base, groupsep)
1592
1593			/**
1594			* Converts a string to a number.
1595			*
1596			* The function returns non-zero when conversion is not possible.
1597			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1598			* It sets errno to ERANGE when the target datatype is too small.
1599			*
1600			* @param str the string to convert
1601			* @param output a pointer to the integer variable where the result shall be stored
1602			* @param base 2, 8, 10, or 16
1603			* @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion
1604			* @retval zero success
1605			* @retval non-zero conversion was not possible
1606			*/
1607			#define cx_strtoi64_lc(str, output, base, groupsep) cx_strtoi64_lc_(cx_strcast(str), output, base, groupsep)
1608
1609			/**
1610			* Converts a string to a number.
1611			*
1612			* The function returns non-zero when conversion is not possible.
1613			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1614			* It sets errno to ERANGE when the target datatype is too small.
1615			*
1616			* @param str the string to convert
1617			* @param output a pointer to the integer variable where the result shall be stored
1618			* @param base 2, 8, 10, or 16
1619			* @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion
1620			* @retval zero success
1621			* @retval non-zero conversion was not possible
1622			*/
1623			#define cx_strtous_lc(str, output, base, groupsep) cx_strtous_lc_(cx_strcast(str), output, base, groupsep)
1624
1625			/**
1626			* Converts a string to a number.
1627			*
1628			* The function returns non-zero when conversion is not possible.
1629			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1630			* It sets errno to ERANGE when the target datatype is too small.
1631			*
1632			* @param str the string to convert
1633			* @param output a pointer to the integer variable where the result shall be stored
1634			* @param base 2, 8, 10, or 16
1635			* @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion
1636			* @retval zero success
1637			* @retval non-zero conversion was not possible
1638			*/
1639			#define cx_strtou_lc(str, output, base, groupsep) cx_strtou_lc_(cx_strcast(str), output, base, groupsep)
1640
1641			/**
1642			* Converts a string to a number.
1643			*
1644			* The function returns non-zero when conversion is not possible.
1645			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1646			* It sets errno to ERANGE when the target datatype is too small.
1647			*
1648			* @param str the string to convert
1649			* @param output a pointer to the integer variable where the result shall be stored
1650			* @param base 2, 8, 10, or 16
1651			* @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion
1652			* @retval zero success
1653			* @retval non-zero conversion was not possible
1654			*/
1655			#define cx_strtoul_lc(str, output, base, groupsep) cx_strtoul_lc_(cx_strcast(str), output, base, groupsep)
1656
1657			/**
1658			* Converts a string to a number.
1659			*
1660			* The function returns non-zero when conversion is not possible.
1661			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1662			* It sets errno to ERANGE when the target datatype is too small.
1663			*
1664			* @param str the string to convert
1665			* @param output a pointer to the integer variable where the result shall be stored
1666			* @param base 2, 8, 10, or 16
1667			* @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion
1668			* @retval zero success
1669			* @retval non-zero conversion was not possible
1670			*/
1671			#define cx_strtoull_lc(str, output, base, groupsep) cx_strtoull_lc_(cx_strcast(str), output, base, groupsep)
1672
1673			/**
1674			* Converts a string to a number.
1675			*
1676			* The function returns non-zero when conversion is not possible.
1677			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1678			* It sets errno to ERANGE when the target datatype is too small.
1679			*
1680			* @param str the string to convert
1681			* @param output a pointer to the integer variable where the result shall be stored
1682			* @param base 2, 8, 10, or 16
1683			* @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion
1684			* @retval zero success
1685			* @retval non-zero conversion was not possible
1686			*/
1687			#define cx_strtou8_lc(str, output, base, groupsep) cx_strtou8_lc_(cx_strcast(str), output, base, groupsep)
1688
1689			/**
1690			* Converts a string to a number.
1691			*
1692			* The function returns non-zero when conversion is not possible.
1693			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1694			* It sets errno to ERANGE when the target datatype is too small.
1695			*
1696			* @param str the string to convert
1697			* @param output a pointer to the integer variable where the result shall be stored
1698			* @param base 2, 8, 10, or 16
1699			* @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion
1700			* @retval zero success
1701			* @retval non-zero conversion was not possible
1702			*/
1703			#define cx_strtou16_lc(str, output, base, groupsep) cx_strtou16_lc_(cx_strcast(str), output, base, groupsep)
1704
1705			/**
1706			* Converts a string to a number.
1707			*
1708			* The function returns non-zero when conversion is not possible.
1709			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1710			* It sets errno to ERANGE when the target datatype is too small.
1711			*
1712			* @param str the string to convert
1713			* @param output a pointer to the integer variable where the result shall be stored
1714			* @param base 2, 8, 10, or 16
1715			* @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion
1716			* @retval zero success
1717			* @retval non-zero conversion was not possible
1718			*/
1719			#define cx_strtou32_lc(str, output, base, groupsep) cx_strtou32_lc_(cx_strcast(str), output, base, groupsep)
1720
1721			/**
1722			* Converts a string to a number.
1723			*
1724			* The function returns non-zero when conversion is not possible.
1725			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1726			* It sets errno to ERANGE when the target datatype is too small.
1727			*
1728			* @param str the string to convert
1729			* @param output a pointer to the integer variable where the result shall be stored
1730			* @param base 2, 8, 10, or 16
1731			* @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion
1732			* @retval zero success
1733			* @retval non-zero conversion was not possible
1734			*/
1735			#define cx_strtou64_lc(str, output, base, groupsep) cx_strtou64_lc_(cx_strcast(str), output, base, groupsep)
1736
1737			/**
1738			* Converts a string to a number.
1739			*
1740			* The function returns non-zero when conversion is not possible.
1741			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1742			* It sets errno to ERANGE when the target datatype is too small.
1743			*
1744			* @param str the string to convert
1745			* @param output a pointer to the integer variable where the result shall be stored
1746			* @param base 2, 8, 10, or 16
1747			* @param groupsep (@c const @c char*) each character in this string is treated as group separator and ignored during conversion
1748			* @retval zero success
1749			* @retval non-zero conversion was not possible
1750			*/
1751			#define cx_strtoz_lc(str, output, base, groupsep) cx_strtoz_lc_(cx_strcast(str), output, base, groupsep)
1752
1753			/**
1754			* Converts a string to a number.
1755			*
1756			* The function returns non-zero when conversion is not possible.
1757			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1758			* It sets errno to ERANGE when the target datatype is too small.
1759			*
1760			* The comma character is treated as group separator and ignored during parsing.
1761			* If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()).
1762			*
1763			* @param str the string to convert
1764			* @param output a pointer to the integer variable where the result shall be stored
1765			* @param base 2, 8, 10, or 16
1766			* @retval zero success
1767			* @retval non-zero conversion was not possible
1768			*/
1769			#define cx_strtos(str, output, base) cx_strtos_lc_(cx_strcast(str), output, base, ",")
1770
1771			/**
1772			* Converts a string to a number.
1773			*
1774			* The function returns non-zero when conversion is not possible.
1775			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1776			* It sets errno to ERANGE when the target datatype is too small.
1777			*
1778			* The comma character is treated as group separator and ignored during parsing.
1779			* If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()).
1780			*
1781			* @param str the string to convert
1782			* @param output a pointer to the integer variable where the result shall be stored
1783			* @param base 2, 8, 10, or 16
1784			* @retval zero success
1785			* @retval non-zero conversion was not possible
1786			*/
1787			#define cx_strtoi(str, output, base) cx_strtoi_lc_(cx_strcast(str), output, base, ",")
1788
1789			/**
1790			* Converts a string to a number.
1791			*
1792			* The function returns non-zero when conversion is not possible.
1793			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1794			* It sets errno to ERANGE when the target datatype is too small.
1795			*
1796			* The comma character is treated as group separator and ignored during parsing.
1797			* If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()).
1798			*
1799			* @param str the string to convert
1800			* @param output a pointer to the integer variable where the result shall be stored
1801			* @param base 2, 8, 10, or 16
1802			* @retval zero success
1803			* @retval non-zero conversion was not possible
1804			*/
1805			#define cx_strtol(str, output, base) cx_strtol_lc_(cx_strcast(str), output, base, ",")
1806
1807			/**
1808			* Converts a string to a number.
1809			*
1810			* The function returns non-zero when conversion is not possible.
1811			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1812			* It sets errno to ERANGE when the target datatype is too small.
1813			*
1814			* The comma character is treated as group separator and ignored during parsing.
1815			* If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()).
1816			*
1817			* @param str the string to convert
1818			* @param output a pointer to the integer variable where the result shall be stored
1819			* @param base 2, 8, 10, or 16
1820			* @retval zero success
1821			* @retval non-zero conversion was not possible
1822			*/
1823			#define cx_strtoll(str, output, base) cx_strtoll_lc_(cx_strcast(str), output, base, ",")
1824
1825			/**
1826			* Converts a string to a number.
1827			*
1828			* The function returns non-zero when conversion is not possible.
1829			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1830			* It sets errno to ERANGE when the target datatype is too small.
1831			*
1832			* The comma character is treated as group separator and ignored during parsing.
1833			* If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()).
1834			*
1835			* @param str the string to convert
1836			* @param output a pointer to the integer variable where the result shall be stored
1837			* @param base 2, 8, 10, or 16
1838			* @retval zero success
1839			* @retval non-zero conversion was not possible
1840			*/
1841			#define cx_strtoi8(str, output, base) cx_strtoi8_lc_(cx_strcast(str), output, base, ",")
1842
1843			/**
1844			* Converts a string to a number.
1845			*
1846			* The function returns non-zero when conversion is not possible.
1847			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1848			* It sets errno to ERANGE when the target datatype is too small.
1849			*
1850			* The comma character is treated as group separator and ignored during parsing.
1851			* If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()).
1852			*
1853			* @param str the string to convert
1854			* @param output a pointer to the integer variable where the result shall be stored
1855			* @param base 2, 8, 10, or 16
1856			* @retval zero success
1857			* @retval non-zero conversion was not possible
1858			*/
1859			#define cx_strtoi16(str, output, base) cx_strtoi16_lc_(cx_strcast(str), output, base, ",")
1860
1861			/**
1862			* Converts a string to a number.
1863			*
1864			* The function returns non-zero when conversion is not possible.
1865			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1866			* It sets errno to ERANGE when the target datatype is too small.
1867			*
1868			* The comma character is treated as group separator and ignored during parsing.
1869			* If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()).
1870			*
1871			* @param str the string to convert
1872			* @param output a pointer to the integer variable where the result shall be stored
1873			* @param base 2, 8, 10, or 16
1874			* @retval zero success
1875			* @retval non-zero conversion was not possible
1876			*/
1877			#define cx_strtoi32(str, output, base) cx_strtoi32_lc_(cx_strcast(str), output, base, ",")
1878
1879			/**
1880			* Converts a string to a number.
1881			*
1882			* The function returns non-zero when conversion is not possible.
1883			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1884			* It sets errno to ERANGE when the target datatype is too small.
1885			*
1886			* The comma character is treated as group separator and ignored during parsing.
1887			* If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()).
1888			*
1889			* @param str the string to convert
1890			* @param output a pointer to the integer variable where the result shall be stored
1891			* @param base 2, 8, 10, or 16
1892			* @retval zero success
1893			* @retval non-zero conversion was not possible
1894			*/
1895			#define cx_strtoi64(str, output, base) cx_strtoi64_lc_(cx_strcast(str), output, base, ",")
1896
1897			/**
1898			* Converts a string to a number.
1899			*
1900			* The function returns non-zero when conversion is not possible.
1901			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1902			* It sets errno to ERANGE when the target datatype is too small.
1903			*
1904			* The comma character is treated as group separator and ignored during parsing.
1905			* If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()).
1906			*
1907			* @param str the string to convert
1908			* @param output a pointer to the integer variable where the result shall be stored
1909			* @param base 2, 8, 10, or 16
1910			* @retval zero success
1911			* @retval non-zero conversion was not possible
1912			*/
1913			#define cx_strtoz(str, output, base) cx_strtoz_lc_(cx_strcast(str), output, base, ",")
1914
1915			/**
1916			* Converts a string to a number.
1917			*
1918			* The function returns non-zero when conversion is not possible.
1919			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1920			* It sets errno to ERANGE when the target datatype is too small.
1921			*
1922			* The comma character is treated as group separator and ignored during parsing.
1923			* If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()).
1924			*
1925			* @param str the string to convert
1926			* @param output a pointer to the integer variable where the result shall be stored
1927			* @param base 2, 8, 10, or 16
1928			* @retval zero success
1929			* @retval non-zero conversion was not possible
1930			*/
1931			#define cx_strtous(str, output, base) cx_strtous_lc_(cx_strcast(str), output, base, ",")
1932
1933			/**
1934			* Converts a string to a number.
1935			*
1936			* The function returns non-zero when conversion is not possible.
1937			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1938			* It sets errno to ERANGE when the target datatype is too small.
1939			*
1940			* The comma character is treated as group separator and ignored during parsing.
1941			* If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()).
1942			*
1943			* @param str the string to convert
1944			* @param output a pointer to the integer variable where the result shall be stored
1945			* @param base 2, 8, 10, or 16
1946			* @retval zero success
1947			* @retval non-zero conversion was not possible
1948			*/
1949			#define cx_strtou(str, output, base) cx_strtou_lc_(cx_strcast(str), output, base, ",")
1950
1951			/**
1952			* Converts a string to a number.
1953			*
1954			* The function returns non-zero when conversion is not possible.
1955			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1956			* It sets errno to ERANGE when the target datatype is too small.
1957			*
1958			* The comma character is treated as group separator and ignored during parsing.
1959			* If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()).
1960			*
1961			* @param str the string to convert
1962			* @param output a pointer to the integer variable where the result shall be stored
1963			* @param base 2, 8, 10, or 16
1964			* @retval zero success
1965			* @retval non-zero conversion was not possible
1966			*/
1967			#define cx_strtoul(str, output, base) cx_strtoul_lc_(cx_strcast(str), output, base, ",")
1968
1969			/**
1970			* Converts a string to a number.
1971			*
1972			* The function returns non-zero when conversion is not possible.
1973			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1974			* It sets errno to ERANGE when the target datatype is too small.
1975			*
1976			* The comma character is treated as group separator and ignored during parsing.
1977			* If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()).
1978			*
1979			* @param str the string to convert
1980			* @param output a pointer to the integer variable where the result shall be stored
1981			* @param base 2, 8, 10, or 16
1982			* @retval zero success
1983			* @retval non-zero conversion was not possible
1984			*/
1985			#define cx_strtoull(str, output, base) cx_strtoull_lc_(cx_strcast(str), output, base, ",")
1986
1987			/**
1988			* Converts a string to a number.
1989			*
1990			* The function returns non-zero when conversion is not possible.
1991			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
1992			* It sets errno to ERANGE when the target datatype is too small.
1993			*
1994			* The comma character is treated as group separator and ignored during parsing.
1995			* If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()).
1996			*
1997			* @param str the string to convert
1998			* @param output a pointer to the integer variable where the result shall be stored
1999			* @param base 2, 8, 10, or 16
2000			* @retval zero success
2001			* @retval non-zero conversion was not possible
2002			*/
2003			#define cx_strtou8(str, output, base) cx_strtou8_lc_(cx_strcast(str), output, base, ",")
2004
2005			/**
2006			* Converts a string to a number.
2007			*
2008			* The function returns non-zero when conversion is not possible.
2009			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
2010			* It sets errno to ERANGE when the target datatype is too small.
2011			*
2012			* The comma character is treated as group separator and ignored during parsing.
2013			* If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()).
2014			*
2015			* @param str the string to convert
2016			* @param output a pointer to the integer variable where the result shall be stored
2017			* @param base 2, 8, 10, or 16
2018			* @retval zero success
2019			* @retval non-zero conversion was not possible
2020			*/
2021			#define cx_strtou16(str, output, base) cx_strtou16_lc_(cx_strcast(str), output, base, ",")
2022
2023			/**
2024			* Converts a string to a number.
2025			*
2026			* The function returns non-zero when conversion is not possible.
2027			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
2028			* It sets errno to ERANGE when the target datatype is too small.
2029			*
2030			* The comma character is treated as group separator and ignored during parsing.
2031			* If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()).
2032			*
2033			* @param str the string to convert
2034			* @param output a pointer to the integer variable where the result shall be stored
2035			* @param base 2, 8, 10, or 16
2036			* @retval zero success
2037			* @retval non-zero conversion was not possible
2038			*/
2039			#define cx_strtou32(str, output, base) cx_strtou32_lc_(cx_strcast(str), output, base, ",")
2040
2041			/**
2042			* Converts a string to a number.
2043			*
2044			* The function returns non-zero when conversion is not possible.
2045			* In that case the function sets errno to EINVAL when the reason is an invalid character or an unsupported base.
2046			* It sets errno to ERANGE when the target datatype is too small.
2047			*
2048			* The comma character is treated as group separator and ignored during parsing.
2049			* If you want to choose the set of group separators, use the @c _lc variant of this function (e.g. cx_strtoz_lc()).
2050			*
2051			* @param str the string to convert
2052			* @param output a pointer to the integer variable where the result shall be stored
2053			* @param base 2, 8, 10, or 16
2054			* @retval zero success
2055			* @retval non-zero conversion was not possible
2056			*/
2057			#define cx_strtou64(str, output, base) cx_strtou64_lc_(cx_strcast(str), output, base, ",")
2058
2059			/**
2060			* Converts a string to a single precision floating point number.
2061			*
2062			* The function returns non-zero when conversion is not possible.
2063			* In that case the function sets errno to EINVAL when the reason is an invalid character.
2064			* It sets errno to ERANGE when the necessary representation would exceed the limits defined in libc's float.h.
2065			*
2066			* @param str the string to convert
2067			* @param output a pointer to the float variable where the result shall be stored
2068			* @param decsep the decimal separator
2069			* @param groupsep each character in this string is treated as group separator and ignored during conversion
2070			* @retval zero success
2071			* @retval non-zero conversion was not possible
2072			*/
2073			#define cx_strtof_lc(str, output, decsep, groupsep) cx_strtof_lc_(cx_strcast(str), output, decsep, groupsep)
2074
2075			/**
2076			* Converts a string to a double precision floating point number.
2077			*
2078			* The function returns non-zero when conversion is not possible.
2079			* In that case the function sets errno to EINVAL when the reason is an invalid character.
2080			*
2081			* @param str the string to convert
2082			* @param output a pointer to the double variable where the result shall be stored
2083			* @param decsep the decimal separator
2084			* @param groupsep each character in this string is treated as group separator and ignored during conversion
2085			* @retval zero success
2086			* @retval non-zero conversion was not possible
2087			*/
2088			#define cx_strtod_lc(str, output, decsep, groupsep) cx_strtod_lc_(cx_strcast(str), output, decsep, groupsep)
2089
2090			/**
2091			* Converts a string to a single precision floating point number.
2092			*
2093			* The function returns non-zero when conversion is not possible.
2094			* In that case the function sets errno to EINVAL when the reason is an invalid character.
2095			* It sets errno to ERANGE when the necessary representation would exceed the limits defined in libc's float.h.
2096			*
2097			* The decimal separator is assumed to be a dot character.
2098			* The comma character is treated as group separator and ignored during parsing.
2099			* If you want to choose a different format, use cx_strtof_lc().
2100			*
2101			* @param str the string to convert
2102			* @param output a pointer to the float variable where the result shall be stored
2103			* @retval zero success
2104			* @retval non-zero conversion was not possible
2105			*/
2106			#define cx_strtof(str, output) cx_strtof_lc_(cx_strcast(str), output, '.', ",")
2107
2108			/**
2109			* Converts a string to a double precision floating point number.
2110			*
2111			* The function returns non-zero when conversion is not possible.
2112			* In that case the function sets errno to EINVAL when the reason is an invalid character.
2113			*
2114			* The decimal separator is assumed to be a dot character.
2115			* The comma character is treated as group separator and ignored during parsing.
2116			* If you want to choose a different format, use cx_strtof_lc().
2117			*
2118			* @param str the string to convert
2119			* @param output a pointer to the double variable where the result shall be stored
2120			* @retval zero success
2121			* @retval non-zero conversion was not possible
2122			*/
2123			#define cx_strtod(str, output) cx_strtod_lc_(cx_strcast(str), output, '.', ",")
2124
2125			#ifdef __cplusplus
2126			} // extern "C"
2127			#endif
2128
2129			#endif //UCX_STRING_H
2130