Internal symbols renamed to avoid potential naming conflicts with standard headers.

maxim2266 · maxim2266 · commit 05fab479f9e8 · 2024-10-25T15:36:17.000+01:00
diff --git a/str.c b/str.c
@@ -60,7 +60,7 @@ void str_free(const str s)
 }
 
 // version of str_free() for str_auto macro
-void _str_free(const str* const ps)
+void str_free_auto(const str* const ps)
 {
 	if(ps)
 		str_free(*ps);
@@ -88,7 +88,7 @@ void str_swap(str* const s1, str* const s2)
 }
 
 // empty string
-const char* const _empty_string = "";
+const char* const str_empty_string = "";
 
 // string comparison ---------------------------------------------------------------------
 // compare two strings lexicographically
@@ -141,10 +141,10 @@ bool str_has_suffix(const str s, const str suffix)
 // create a reference to the given range of chars
 str str_ref_chars(const char* const s, const size_t n)
 {
-	return (s && n > 0) ? ((str){ s, _ref_info(n) }) : str_null;
+	return (s && n > 0) ? ((str){ s, str_ref_info(n) }) : str_null;
 }
 
-str _str_ref_from_ptr(const char* const s)
+str str_ref_from_ptr(const char* const s)
 {
 	return s ? str_ref_chars(s, strlen(s)) : str_null;
 }
@@ -161,7 +161,7 @@ str str_acquire_chars(const char* const s, const size_t n)
 		return str_null;
 	}
 
-	return (str){ s, _owner_info(n) };
+	return (str){ s, str_owner_info(n) };
 }
 
 // take ownership of the given C string
@@ -171,7 +171,7 @@ str str_acquire(const char* const s)
 }
 
 // allocate a copy of the given string
-int _str_dup(str* const dest, const str s)
+int str_dup_impl(str* const dest, const str s)
 {
 	const size_t n = str_len(s);
 
@@ -311,7 +311,7 @@ size_t total_length(const str* src, size_t count)
 }
 
 // concatenate strings
-int _str_cat_range(str* const dest, const str* src, size_t count)
+int str_cat_range_impl(str* const dest, const str* src, size_t count)
 {
 	if(!src)
 	{
@@ -344,7 +344,7 @@ int _str_cat_range(str* const dest, const str* src, size_t count)
 }
 
 // writing to file descriptor
-int _str_cpy_to_fd(const int fd, const str s)
+int str_cpy_to_fd(const int fd, const str s)
 {
 	size_t n = str_len(s);
 	const void* p = str_ptr(s);
@@ -363,7 +363,7 @@ int _str_cpy_to_fd(const int fd, const str s)
 }
 
 // writing to byte stream
-int _str_cpy_to_stream(FILE* const stream, const str s)
+int str_cpy_to_stream(FILE* const stream, const str s)
 {
 	const size_t n = str_len(s);
 
@@ -412,7 +412,7 @@ struct iovec* vec_append_nonempty(struct iovec* const pv, const str s)
 	return str_is_empty(s) ? pv : vec_append(pv, s);
 }
 
-int _str_cat_range_to_fd(const int fd, const str* src, size_t count)
+int str_cat_range_to_fd(const int fd, const str* src, size_t count)
 {
 	if(!src)
 		return 0;
@@ -440,7 +440,7 @@ int _str_cat_range_to_fd(const int fd, const str* src, size_t count)
 	return 0;
 }
 
-int _str_cat_range_to_stream(FILE* const stream, const str* src, size_t count)
+int str_cat_range_to_stream(FILE* const stream, const str* src, size_t count)
 {
 	if(!src)
 		return 0;
@@ -454,7 +454,7 @@ int _str_cat_range_to_stream(FILE* const stream, const str* src, size_t count)
 }
 
 // join strings
-int _str_join_range(str* const dest, const str sep, const str* src, size_t count)
+int str_join_range_impl(str* const dest, const str sep, const str* src, size_t count)
 {
 	// test for simple cases
 	if(str_is_empty(sep))
@@ -487,7 +487,7 @@ int _str_join_range(str* const dest, const str sep, const str* src, size_t count
 	return 0;
 }
 
-int _str_join_range_to_fd(const int fd, const str sep, const str* src, size_t count)
+int str_join_range_to_fd(const int fd, const str sep, const str* src, size_t count)
 {
 	if(str_is_empty(sep))
 		return str_cat_range(fd, src, count);
@@ -523,7 +523,7 @@ int _str_join_range_to_fd(const int fd, const str sep, const str* src, size_t co
 	return 0;
 }
 
-int _str_join_range_to_stream(FILE* const stream, const str sep, const str* src, size_t count)
+int str_join_range_to_stream(FILE* const stream, const str sep, const str* src, size_t count)
 {
 	if(str_is_empty(sep))
 		return str_cat_range(stream, src, count);
@@ -656,7 +656,7 @@ size_t str_unique_range(str* const array, const size_t count)
 // string iterator function
 #ifdef __STDC_UTF_32__
 
-char32_t _cp_iterator_next(_cp_iterator* const it)
+char32_t str_cp_iterator_next(str_cp_iterator* const it)
 {
 	if(it->curr >= it->end)
 		return CPI_END_OF_STRING;
diff --git a/str.h b/str.h
@@ -50,8 +50,8 @@ typedef struct
 #define str_null ((str){ 0, 0 })
 
 // helper macros
-#define _ref_info(n)	((n) << 1)
-#define _owner_info(n)	(_ref_info(n) | 1)
+#define str_ref_info(n)	((n) << 1)
+#define str_owner_info(n)	(str_ref_info(n) | 1)
 
 // string properties ----------------------------------------------------------------------
 // length of the string
@@ -62,9 +62,9 @@ size_t str_len(const str s) { return s.info >> 1; }
 static inline
 const char* str_ptr(const str s)
 {
-	extern const char* const _empty_string;
+	extern const char* const str_empty_string;
 
-	return s.ptr ? s.ptr : _empty_string;
+	return s.ptr ? s.ptr : str_empty_string;
 }
 
 // end of the string
@@ -88,9 +88,9 @@ bool str_is_ref(const str s) { return !str_is_owner(s); }
 void str_free(const str s);
 
 // automatic cleanup
-void _str_free(const str* const ps);
+void str_free_auto(const str* const ps);
 
-#define str_auto	str __attribute__((cleanup(_str_free)))
+#define str_auto	str __attribute__((cleanup(str_free_auto)))
 
 // string movements -----------------------------------------------------------------------
 // free target string, then assign the new value to it
@@ -135,29 +135,29 @@ bool str_has_suffix(const str s, const str suffix);
 
 // string composition ------------------------------------------------------------------
 // implementation helpers
-int _str_dup(str* const dest, const str s);
-int _str_cpy_to_fd(const int fd, const str s);
-int _str_cpy_to_stream(FILE* const stream, const str s);
+int str_dup_impl(str* const dest, const str s);
+int str_cpy_to_fd(const int fd, const str s);
+int str_cpy_to_stream(FILE* const stream, const str s);
 
 // copy string
 #define str_cpy(dest, src)	\
 	_Generic((dest),	\
-		str*:	_str_dup,	\
-		int:	_str_cpy_to_fd,	\
-		FILE*:	_str_cpy_to_stream	\
+		str*:	str_dup_impl,	\
+		int:	str_cpy_to_fd,	\
+		FILE*:	str_cpy_to_stream	\
 	)((dest), (src))
 
 // implementation helpers
-int _str_cat_range(str* const dest, const str* src, size_t count);
-int _str_cat_range_to_fd(const int fd, const str* src, size_t count);
-int _str_cat_range_to_stream(FILE* const stream, const str* src, size_t count);
+int str_cat_range_impl(str* const dest, const str* src, size_t count);
+int str_cat_range_to_fd(const int fd, const str* src, size_t count);
+int str_cat_range_to_stream(FILE* const stream, const str* src, size_t count);
 
 // concatenate range of strings
 #define str_cat_range(dest, src, count)	\
 	_Generic((dest),	\
-		str*:	_str_cat_range,	\
-		int:	_str_cat_range_to_fd,	\
-		FILE*:	_str_cat_range_to_stream	\
+		str*:	str_cat_range_impl,	\
+		int:	str_cat_range_to_fd,	\
+		FILE*:	str_cat_range_to_stream	\
 	)((dest), (src), (count))
 
 // concatenate string arguments
@@ -168,16 +168,16 @@ int _str_cat_range_to_stream(FILE* const stream, const str* src, size_t count);
 })
 
 // implementation helpers
-int _str_join_range(str* const dest, const str sep, const str* src, size_t count);
-int _str_join_range_to_fd(const int fd, const str sep, const str* src, size_t count);
-int _str_join_range_to_stream(FILE* const stream, const str sep, const str* src, size_t count);
+int str_join_range_impl(str* const dest, const str sep, const str* src, size_t count);
+int str_join_range_to_fd(const int fd, const str sep, const str* src, size_t count);
+int str_join_range_to_stream(FILE* const stream, const str sep, const str* src, size_t count);
 
 // join strings around the separator
 #define str_join_range(dest, sep, src, count)	\
 	_Generic((dest),	\
-		str*:	_str_join_range,	\
-		int:	_str_join_range_to_fd,	\
-		FILE*:	_str_join_range_to_stream	\
+		str*:	str_join_range_impl,	\
+		int:	str_join_range_to_fd,	\
+		FILE*:	str_join_range_to_stream	\
 	)((dest), (sep), (src), (count))
 
 // join string arguments around the separator
@@ -189,19 +189,19 @@ int _str_join_range_to_stream(FILE* const stream, const str sep, const str* src,
 
 // constructors ----------------------------------------------------------------------------
 // string reference from a string literal
-#define str_lit(s)	((str){ "" s, _ref_info(sizeof(s) - 1) })
+#define str_lit(s)	((str){ "" s, str_ref_info(sizeof(s) - 1) })
 
 static inline
-str _str_ref(const str s) { return (str){ s.ptr, s.info & ~(size_t)1 }; }
+str str_ref_impl(const str s) { return (str){ s.ptr, s.info & ~(size_t)1 }; }
 
-str _str_ref_from_ptr(const char* const s);
+str str_ref_from_ptr(const char* const s);
 
 // string reference from anything
 #define str_ref(s)	\
 	_Generic((s),	\
-		str:			_str_ref,	\
-		char*:			_str_ref_from_ptr,	\
-		const char*:	_str_ref_from_ptr	\
+		str:			str_ref_impl,	\
+		char*:			str_ref_from_ptr,	\
+		const char*:	str_ref_from_ptr	\
 	)(s)
 
 // create a reference to the given range of chars
@@ -246,34 +246,34 @@ size_t str_unique_range(str* const array, const size_t count);
 
 // iterator
 #define for_each_codepoint(var, src)	\
-	_for_each_cp((var), (src), _CAT(__it_, __COUNTER__))
+	for_each_cp((var), (src), CAT1(inner_it_, __COUNTER__))
 
 // iterator error codes
 #define CPI_END_OF_STRING			((char32_t)-1)
 #define CPI_ERR_INCOMPLETE_SEQ		((char32_t)-2)
 #define CPI_ERR_INVALID_ENCODING	((char32_t)-3)
 
 // implementation
-#define _for_each_cp(var, src, it)	\
-	for(_cp_iterator it = _make_cp_iterator(src); (var = _cp_iterator_next(&it)) <= 0x10FFFFu;)
+#define for_each_cp(var, src, it)	\
+	for(str_cp_iterator it = str_make_cp_iterator(src); (var = str_cp_iterator_next(&it)) <= 0x10FFFFu;)
 
-#define _CAT(x, y)	__CAT(x, y)
-#define __CAT(x, y)	x ## y
+#define CAT1(x, y)	CAT2(x, y)
+#define CAT2(x, y)	x ## y
 
 typedef struct
 {
 	const char* curr;
 	const char* const end;
 	mbstate_t state;
-} _cp_iterator;
+} str_cp_iterator;
 
 static inline
-_cp_iterator _make_cp_iterator(const str s)
+str_cp_iterator str_make_cp_iterator(const str s)
 {
-	return (_cp_iterator){ .curr = str_ptr(s), .end = str_end(s) };
+	return (str_cp_iterator){ .curr = str_ptr(s), .end = str_end(s) };
 }
 
-char32_t _cp_iterator_next(_cp_iterator* const it);
+char32_t str_cp_iterator_next(str_cp_iterator* const it);
 
 #endif	// ifdef __STDC_UTF_32__
 

Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ void str_free(const str s)`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`// version of str_free() for str_auto macro`
`63`		`-void _str_free(const str* const ps)`
	`63`	`+void str_free_auto(const str* const ps)`
`64`	`64`	`{`
`65`	`65`	`if(ps)`
`66`	`66`	`str_free(*ps);`
`@@ -88,7 +88,7 @@ void str_swap(str* const s1, str* const s2)`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`// empty string`
`91`		`-const char* const _empty_string = "";`
	`91`	`+const char* const str_empty_string = "";`
`92`	`92`
`93`	`93`	`// string comparison ---------------------------------------------------------------------`
`94`	`94`	`// compare two strings lexicographically`
`@@ -141,10 +141,10 @@ bool str_has_suffix(const str s, const str suffix)`
`141`	`141`	`// create a reference to the given range of chars`
`142`	`142`	`str str_ref_chars(const char* const s, const size_t n)`
`143`	`143`	`{`
`144`		`- return (s && n > 0) ? ((str){ s, _ref_info(n) }) : str_null;`
	`144`	`+ return (s && n > 0) ? ((str){ s, str_ref_info(n) }) : str_null;`
`145`	`145`	`}`
`146`	`146`
`147`		`-str _str_ref_from_ptr(const char* const s)`
	`147`	`+str str_ref_from_ptr(const char* const s)`
`148`	`148`	`{`
`149`	`149`	`return s ? str_ref_chars(s, strlen(s)) : str_null;`
`150`	`150`	`}`
`@@ -161,7 +161,7 @@ str str_acquire_chars(const char* const s, const size_t n)`
`161`	`161`	`return str_null;`
`162`	`162`	`}`
`163`	`163`
`164`		`- return (str){ s, _owner_info(n) };`
	`164`	`+ return (str){ s, str_owner_info(n) };`
`165`	`165`	`}`
`166`	`166`
`167`	`167`	`// take ownership of the given C string`
`@@ -171,7 +171,7 @@ str str_acquire(const char* const s)`
`171`	`171`	`}`
`172`	`172`
`173`	`173`	`// allocate a copy of the given string`
`174`		`-int _str_dup(str* const dest, const str s)`
	`174`	`+int str_dup_impl(str* const dest, const str s)`
`175`	`175`	`{`
`176`	`176`	`const size_t n = str_len(s);`
`177`	`177`
`@@ -311,7 +311,7 @@ size_t total_length(const str* src, size_t count)`
`311`	`311`	`}`
`312`	`312`
`313`	`313`	`// concatenate strings`
`314`		`-int _str_cat_range(str* const dest, const str* src, size_t count)`
	`314`	`+int str_cat_range_impl(str* const dest, const str* src, size_t count)`
`315`	`315`	`{`
`316`	`316`	`if(!src)`
`317`	`317`	`{`
`@@ -344,7 +344,7 @@ int _str_cat_range(str* const dest, const str* src, size_t count)`
`344`	`344`	`}`
`345`	`345`
`346`	`346`	`// writing to file descriptor`
`347`		`-int _str_cpy_to_fd(const int fd, const str s)`
	`347`	`+int str_cpy_to_fd(const int fd, const str s)`
`348`	`348`	`{`
`349`	`349`	`size_t n = str_len(s);`
`350`	`350`	`const void* p = str_ptr(s);`
`@@ -363,7 +363,7 @@ int _str_cpy_to_fd(const int fd, const str s)`
`363`	`363`	`}`
`364`	`364`
`365`	`365`	`// writing to byte stream`
`366`		`-int _str_cpy_to_stream(FILE* const stream, const str s)`
	`366`	`+int str_cpy_to_stream(FILE* const stream, const str s)`
`367`	`367`	`{`
`368`	`368`	`const size_t n = str_len(s);`
`369`	`369`
`@@ -412,7 +412,7 @@ struct iovec* vec_append_nonempty(struct iovec* const pv, const str s)`
`412`	`412`	`return str_is_empty(s) ? pv : vec_append(pv, s);`
`413`	`413`	`}`
`414`	`414`
`415`		`-int _str_cat_range_to_fd(const int fd, const str* src, size_t count)`
	`415`	`+int str_cat_range_to_fd(const int fd, const str* src, size_t count)`
`416`	`416`	`{`
`417`	`417`	`if(!src)`
`418`	`418`	`return 0;`
`@@ -440,7 +440,7 @@ int _str_cat_range_to_fd(const int fd, const str* src, size_t count)`
`440`	`440`	`return 0;`
`441`	`441`	`}`
`442`	`442`
`443`		`-int _str_cat_range_to_stream(FILE* const stream, const str* src, size_t count)`
	`443`	`+int str_cat_range_to_stream(FILE* const stream, const str* src, size_t count)`
`444`	`444`	`{`
`445`	`445`	`if(!src)`
`446`	`446`	`return 0;`
`@@ -454,7 +454,7 @@ int _str_cat_range_to_stream(FILE* const stream, const str* src, size_t count)`
`454`	`454`	`}`
`455`	`455`
`456`	`456`	`// join strings`
`457`		`-int _str_join_range(str* const dest, const str sep, const str* src, size_t count)`
	`457`	`+int str_join_range_impl(str* const dest, const str sep, const str* src, size_t count)`
`458`	`458`	`{`
`459`	`459`	`// test for simple cases`
`460`	`460`	`if(str_is_empty(sep))`
`@@ -487,7 +487,7 @@ int _str_join_range(str* const dest, const str sep, const str* src, size_t count`
`487`	`487`	`return 0;`
`488`	`488`	`}`
`489`	`489`
`490`		`-int _str_join_range_to_fd(const int fd, const str sep, const str* src, size_t count)`
	`490`	`+int str_join_range_to_fd(const int fd, const str sep, const str* src, size_t count)`
`491`	`491`	`{`
`492`	`492`	`if(str_is_empty(sep))`
`493`	`493`	`return str_cat_range(fd, src, count);`
`@@ -523,7 +523,7 @@ int _str_join_range_to_fd(const int fd, const str sep, const str* src, size_t co`
`523`	`523`	`return 0;`
`524`	`524`	`}`
`525`	`525`
`526`		`-int _str_join_range_to_stream(FILE* const stream, const str sep, const str* src, size_t count)`
	`526`	`+int str_join_range_to_stream(FILE* const stream, const str sep, const str* src, size_t count)`
`527`	`527`	`{`
`528`	`528`	`if(str_is_empty(sep))`
`529`	`529`	`return str_cat_range(stream, src, count);`
`@@ -656,7 +656,7 @@ size_t str_unique_range(str* const array, const size_t count)`
`656`	`656`	`// string iterator function`
`657`	`657`	`#ifdef __STDC_UTF_32__`
`658`	`658`
`659`		`-char32_t _cp_iterator_next(_cp_iterator* const it)`
	`659`	`+char32_t str_cp_iterator_next(str_cp_iterator* const it)`
`660`	`660`	`{`
`661`	`661`	`if(it->curr >= it->end)`
`662`	`662`	`return CPI_END_OF_STRING;`