53char *
BLI_strdupcat(
const char *__restrict str1,
const char *__restrict str2)
56 const size_t str1_len = strlen(str1);
57 const size_t str2_len = strlen(str2) + 1;
63 memcpy(s, str1, str1_len);
65 memcpy(s, str2, str2_len);
70char *
BLI_strncpy(
char *__restrict dst,
const char *__restrict src,
const size_t dst_maxncpy)
77 memcpy(dst, src, srclen);
83 const char *__restrict src,
99 if ((dst_maxncpy != 0) && (src[idx] !=
pad)) {
105 if ((srclen != 0) && (srclen == dst_maxncpy) && (src[srclen - 1] !=
pad)) {
109 memcpy(&dst[idx], src, srclen);
112 if ((idx != 0) && (dst[idx - 1] !=
pad)) {
121size_t BLI_strncpy_rlen(
char *__restrict dst,
const char *__restrict src,
const size_t dst_maxncpy)
128 memcpy(dst, src, srclen);
139char *
BLI_strncat(
char *__restrict dst,
const char *__restrict src,
const size_t dst_maxncpy)
144 if (
len < dst_maxncpy) {
158 const char *__restrict format,
167 const size_t n = size_t(vsnprintf(dst, dst_maxncpy, format, arg));
168 if (n < dst_maxncpy) {
172 dst[dst_maxncpy - 1] =
'\0';
180 const char *__restrict format,
189 size_t n = size_t(vsnprintf(dst, dst_maxncpy, format, arg));
190 if (n < dst_maxncpy) {
201size_t BLI_snprintf(
char *__restrict dst,
size_t dst_maxncpy,
const char *__restrict format, ...)
206 va_start(arg, format);
207 const size_t n =
BLI_vsnprintf(dst, dst_maxncpy, format, arg);
215 const char *__restrict format,
221 va_start(arg, format);
229 size_t fixed_buf_maxncpy,
231 const char *__restrict format,
235 va_start(args, format);
236 int retval = vsnprintf(fixed_buf, fixed_buf_maxncpy, format, args);
238 if (retval < 0) [[unlikely]] {
241 if (fixed_buf_maxncpy == 0) [[unlikely]] {
247 *result_len = size_t(retval);
248 if (
size_t(retval) < fixed_buf_maxncpy) {
253 const size_t size = size_t(retval) + 1;
255 va_start(args, format);
256 retval = vsnprintf(
result, size, format, args);
264 size_t fixed_buf_maxncpy,
266 const char *__restrict format,
270 va_copy(args_copy, args);
271 int retval = vsnprintf(fixed_buf, fixed_buf_maxncpy, format, args_copy);
273 if (retval < 0) [[unlikely]] {
276 if (fixed_buf_maxncpy == 0) [[unlikely]] {
282 *result_len = size_t(retval);
283 if (
size_t(retval) < fixed_buf_maxncpy) {
288 const size_t size = size_t(retval) + 1;
290 retval = vsnprintf(
result, size, format, args);
301 va_start(args, format);
303 fixed_buf,
sizeof(fixed_buf), &result_len, format, args);
305 if (
result != fixed_buf) {
308 size_t size = result_len + 1;
310 memcpy(
result, fixed_buf, size);
319 fixed_buf,
sizeof(fixed_buf), &result_len, format, args);
320 if (
result != fixed_buf) {
323 size_t size = result_len + 1;
325 memcpy(
result, fixed_buf, size);
340 const size_t dst_len_max = dst_maxncpy - 1;
343 for (; (dst_len < dst_len_max) && (src_idx < src.
size()); src_idx++, dst++, dst_len++) {
344 char c = src[src_idx];
345 if (
ELEM(c,
'\\',
'"') ||
346 ((c ==
'\t') && ((
void)(c =
't'),
true)) ||
347 ((c ==
'\n') && ((
void)(c =
'n'),
true)) ||
348 ((c ==
'\r') && ((
void)(c =
'r'),
true)) ||
349 ((c ==
'\a') && ((
void)(c =
'a'),
true)) ||
350 ((c ==
'\b') && ((
void)(c =
'b'),
true)) ||
351 ((c ==
'\f') && ((
void)(c =
'f'),
true)))
353 if (dst_len + 1 >= dst_len_max) [[unlikely]] {
369 if (
str.is_empty()) {
372 const size_t max_result_size = size_t(
str.size()) * 2 + 1;
374 result.resize(max_result_size);
376 result.resize(result_size);
382#define CASE_PAIR(value_src, value_dst) \
384 *r_out = value_dst; \
402 const char *__restrict src,
403 const size_t src_len,
405 const size_t dst_maxncpy,
412 bool is_complete =
true;
413 const size_t max_strlen = dst_maxncpy - 1;
414 for (
const char *src_end = src + src_len; (src < src_end) && *src; src++) {
415 if (
len == max_strlen) [[unlikely]] {
426 *r_is_complete = is_complete;
430size_t BLI_str_unescape(
char *__restrict dst,
const char *__restrict src,
const size_t src_len)
435 for (
const char *src_end = src + src_len; (src < src_end) && *src; src++) {
449 while (*
str && (*
str !=
'"' || escape)) {
452 escape = (escape ==
false) && (*
str ==
'\\');
455 return (*
str ==
'"') ?
str :
nullptr;
465 const char *__restrict prefix,
466 int *__restrict r_start,
467 int *__restrict r_end)
469 const char *str_start = strstr(
str, prefix);
470 if (str_start ==
nullptr) {
473 const size_t prefix_len = strlen(prefix);
474 if (prefix_len == 0) [[unlikely]] {
476 "Zero length prefix passed in, "
477 "caller must prevent this from happening!");
481 "Prefix includes trailing quote, "
482 "caller must prevent this from happening!");
484 str_start += prefix_len;
485 if (*str_start !=
'\"') [[unlikely]] {
490 if (str_end ==
nullptr) [[unlikely]] {
494 *r_start = int(str_start -
str);
495 *r_end = int(str_end -
str);
513char *BLI_str_quoted_substrN(
const char *__restrict
str,
const char *__restrict prefix)
515 int start_match_ofs, end_match_ofs;
519 const size_t escaped_len = size_t(end_match_ofs - start_match_ofs);
522 if (unescaped_len != escaped_len) {
530 const char *__restrict prefix,
532 size_t result_maxncpy)
536 int start_match_ofs, end_match_ofs;
540 const size_t escaped_len = size_t(end_match_ofs - start_match_ofs);
543 if (is_complete ==
false) {
565 if ((c = *find++) != 0) {
566 c = char(tolower(c));
570 if ((sc = *s++) == 0) {
573 sc = char(tolower(sc));
578 return (
const_cast<char *
>(s));
583 return (str_len / 2) + 1;
590 if ((match == haystack) || (*(match - 1) ==
' ') || ispunct(*(match - 1))) {
609 const bool all_words_matched = (
index == words_len);
611 return all_words_matched;
618 if ((c = *find++) != 0) {
619 c = char(tolower(c));
623 if ((sc = *s++) == 0) {
626 sc = char(tolower(sc));
633 if ((sc = *s++) == 0) {
636 sc = char(tolower(sc));
642 return (
const_cast<char *
>(s));
651 c1 = char(tolower(s1[i]));
652 c2 = char(tolower(s2[i]));
673 for (i = 0; i <
len; i++) {
674 c1 = char(tolower(s1[i]));
675 c2 = char(tolower(s2[i]));
694 const char *p1 = s1, *p2 = s2;
695 int numdigit, numzero1, numzero2;
698 for (numzero1 = 0; *p1 ==
'0'; numzero1++) {
701 for (numzero2 = 0; *p2 ==
'0'; numzero2++) {
706 for (numdigit = 0;; numdigit++) {
707 if (isdigit(*(p1 + numdigit)) && isdigit(*(p2 + numdigit))) {
710 if (isdigit(*(p1 + numdigit))) {
713 if (isdigit(*(p2 + numdigit))) {
721 int compare = strncmp(p1, p2,
size_t(numdigit));
729 if (*tiebreaker == 0) {
730 if (numzero1 > numzero2) {
733 else if (numzero1 < numzero2) {
752 if (isdigit(s1[d1]) && isdigit(s2[d2])) {
755 if (numcompare != 0) {
761 while (isdigit(s1[d1])) {
765 while (isdigit(s2[d2])) {
771 if (
ELEM(0, s1[d1], s2[d2])) {
775 c1 = char(tolower(s1[d1]));
776 c2 = char(tolower(s2[d2]));
782 else if (c1 ==
'.') {
785 else if (c2 ==
'.') {
805 return strcmp(s1, s2);
810 size_t str1_len, str2_len;
812 while (*str1 ==
pad) {
815 while (*str2 ==
pad) {
819 str1_len = strlen(str1);
820 str2_len = strlen(str2);
822 while (str1_len && (str1[str1_len - 1] ==
pad)) {
825 while (str2_len && (str2[str2_len - 1] ==
pad)) {
829 if (str1_len == str2_len) {
830 return strncmp(str1, str2, str2_len);
832 if (str1_len > str2_len) {
833 int ret = strncmp(str1, str2, str2_len);
840 int ret = strncmp(str1, str2, str1_len);
855 const char **__restrict str_array,
856 const int str_array_len)
859 const char **str_iter = str_array;
872 const char **str_iter = str_array;
874 for (
index = 0; *str_iter; str_iter++,
index++) {
884 for (; *
str && *start;
str++, start++) {
885 if (*
str != *start) {
890 return (*start ==
'\0');
895 size_t end_len = strlen(end);
897 if (end_len <= str_len) {
898 const char *iter = &
str[str_len - end_len];
900 if (*iter++ != *end++) {
911 const size_t str_len = strlen(
str);
942 while (!
ELEM(*p, ch,
'\0')) {
956 return (c >=
'A' && c <=
'Z') ? c + (
'a' -
'A') : c;
961 return (c >=
'a' && c <=
'z') ? c - (
'a' -
'A') : c;
968 for (i = 0; (i <
len) &&
str[i]; i++) {
977 for (i = 0; (i <
len) &&
str[i]; i++) {
990 for (
int i =
int(strlen(
str)) - 1; i >= 0; i--) {
991 if (isspace(
str[i])) {
1002 char *p = strchr(
str,
'.');
1007 end_p = p + (strlen(p) - 1);
1009 while (end_p != p && *end_p ==
'0') {
1023 int str_len = int(strlen(
str));
1024 while (str_len > 0 && isdigit(
str[str_len - 1])) {
1026 str[str_len] =
'\0';
1053 const bool from_right)
1059 *sep = *suf =
nullptr;
1061 for (d = delim; *d !=
'\0'; d++) {
1066 for (tmp = end - 1; (tmp >=
str) && (*tmp != *d); tmp--) {
1074 tmp = strchr(
str, *d);
1081 tmp = (from_right) ? strrchr(
str, *d) : strchr(
str, *d);
1084 if (tmp && (from_right ? (*sep < tmp) : (!*sep || *sep > tmp))) {
1091 return size_t(*sep -
str);
1094 return end ? size_t(end -
str) : strlen(
str);
1098 const char *
str,
const size_t str_maxlen,
const char delim,
int r_words[][2],
int words_max)
1101 bool charsearch =
true;
1104 for (i = 0; (i < int(str_maxlen)) && (
str[i] !=
'\0'); i++) {
1105 if (
str[i] != delim) {
1110 for (; (i < int(str_maxlen)) && (
str[i] !=
'\0') && (n < words_max); i++) {
1111 if ((
str[i] != delim) && (charsearch ==
true)) {
1116 if ((
str[i] == delim) && (charsearch ==
false)) {
1117 r_words[n][1] = i - r_words[n][0];
1124 if (charsearch ==
false) {
1125 r_words[n][1] = i - r_words[n][0];
1135 const size_t needle_len = strlen(needle);
1136 const char *p = haystack;
1139 if ((
size_t(p_next - p) == needle_len) && (memcmp(p, needle, needle_len) == 0)) {
1142 if (*p_next ==
'\0') {
1161 const char separator =
',';
1164 if (*p_src ==
'-') {
1165 *p_dst++ = *p_src++;
1169 for (commas = 2 - num_len % 3; *p_src; commas = (commas + 1) % 3) {
1170 *p_dst++ = *p_src++;
1172 *p_dst++ = separator;
1177 return size_t(p_dst - dst);
1187 const int num_len = int(
SNPRINTF(src,
"%d",
num));
1217 long long int bytes,
1223 double bytes_converted = double(bytes);
1226 const int base = base_10 ? 1000 : 1024;
1227 const char *units_base_10[] = {
"B",
"KB",
"MB",
"GB",
"TB",
"PB"};
1228 const char *units_base_2[] = {
"B",
"KiB",
"MiB",
"GiB",
"TiB",
"PiB"};
1229 const int units_num = int(
ARRAY_SIZE(units_base_2));
1233 while ((
fabs(bytes_converted) >= base) && ((order + 1) < units_num)) {
1234 bytes_converted /= base;
1237 decimals = std::max(order - 1, 0);
1243 BLI_strncpy(dst +
len, base_10 ? units_base_10[order] : units_base_2[order], dst_maxncpy -
len);
1247 long long int bytes,
1253 float number_to_format_converted =
float(bytes);
1255 const float base = base_10 ? 1000.0f : 1024.0f;
1256 const char *units[] = {
"B",
"K",
"M",
"G",
"T",
"P",
"E"};
1257 const int units_num = int(
ARRAY_SIZE(units));
1259 while ((
fabsf(number_to_format_converted) >= base) && ((order + 1) < units_num)) {
1260 number_to_format_converted /= base;
1264 const bool add_dot = (llabs(bytes) > 99999) &&
fabsf(number_to_format_converted) > 99;
1267 number_to_format_converted /= 100.0f;
1280 int number_to_format)
1284 float number_to_format_converted =
float(number_to_format);
1286 const float base = 1000.0f;
1287 const char *units[] = {
"",
"K",
"M",
"B"};
1288 const int units_num = int(
ARRAY_SIZE(units));
1290 while ((
fabsf(number_to_format_converted) >= base) && ((order + 1) < units_num)) {
1291 number_to_format_converted /= base;
1297 if ((order > 0) &&
fabsf(number_to_format_converted) < 100.0f) {
1300 BLI_snprintf(dst, dst_maxncpy,
"%.*f%s", decimals, number_to_format_converted, units[order]);
1304 const int number_to_format)
1309 float number_to_format_converted =
float(number_to_format);
1311 const float base = 1000;
1312 const char *units[] = {
"",
"K",
"M",
"B"};
1313 const int units_num = int(
ARRAY_SIZE(units));
1315 while ((
fabsf(number_to_format_converted) >= base) && ((order + 1) < units_num)) {
1316 number_to_format_converted /= base;
1320 const bool add_dot = (
abs(number_to_format) > 99999) &&
fabsf(number_to_format_converted) > 99;
1323 number_to_format_converted /= 100;
1330 number_to_format < 0 ?
"-" :
"",
1342#ifdef WITH_STRSIZE_DEBUG
1347 if (str_tail < str_maxncpy) {
#define BLI_STR_FORMAT_INT64_GROUPED_SIZE
#define BLI_STR_FORMAT_INT64_BYTE_UNIT_SIZE
#define SNPRINTF(dst, format,...)
#define BLI_STR_FORMAT_INT32_DECIMAL_UNIT_SIZE
#define BLI_string_debug_size_after_nil(str, str_maxncpy)
#define BLI_STR_FORMAT_INT32_GROUPED_SIZE
#define BLI_STR_FORMAT_INT32_INTEGER_UNIT_SIZE
#define BLI_string_debug_size(str, str_maxncpy)
#define BLI_STR_FORMAT_UINT64_GROUPED_SIZE
#define BLI_STR_FORMAT_INT64_BYTE_UNIT_COMPACT_SIZE
Read Blender memory allocation and freeing.
int pad[32 - sizeof(int)]
#define UNUSED_VARS_NDEBUG(...)
#define BLI_assert_msg(a, msg)
#define CASE_PAIR(value_src, value_dst)
#define MEM_realloc_uninitialized(vmemh, len)
constexpr int64_t size() const
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
ccl_device_inline dual3 fabs(const ccl_private dual3 &a)
void BLI_str_format_byte_unit(char dst[BLI_STR_FORMAT_INT64_BYTE_UNIT_SIZE], long long int bytes, bool base_10) ATTR_NONNULL(1)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
int char char int BLI_strcasecmp(const char *s1, const char *s2) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
void BLI_str_format_decimal_unit(char dst[BLI_STR_FORMAT_INT32_DECIMAL_UNIT_SIZE], int number_to_format) ATTR_NONNULL(1)
unsigned __int64 uint64_t
BLI_STATIC_ASSERT(ARRAY_SIZE(data_mode_strings)==CTX_MODE_NUM+1, "Must have a string for each context mode") const char *CTX_data_mode_string(const bContext *C)
size_t BLI_snprintf(char *__restrict dst, size_t dst_maxncpy, const char *__restrict format,...) ATTR_NONNULL(1
size_t BLI_vsnprintf(char *__restrict dst, size_t dst_maxncpy, const char *__restrict format, va_list arg) ATTR_PRINTF_FORMAT(3
void BLI_str_toupper_ascii(char *str, size_t len) ATTR_NONNULL(1)
int char char int int int BLI_strcasecmp_natural(const char *s1, const char *s2) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
int bool bool bool size_t BLI_str_partition(const char *str, const char delim[], const char **sep, const char **suf) ATTR_NONNULL(1
bool bool BLI_str_quoted_substr(const char *__restrict str, const char *__restrict prefix, char *result, size_t result_maxncpy)
void * MEM_new_array_uninitialized(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
int bool bool BLI_str_endswith(const char *__restrict str, const char *__restrict end) ATTR_NONNULL(1
char * BLI_strdupcat(const char *__restrict str1, const char *__restrict str2) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
char * BLI_sprintfN(const char *__restrict format,...) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1) ATTR_MALLOC ATTR_PRINTF_FORMAT(1
size_t BLI_str_format_int64_grouped(char dst[BLI_STR_FORMAT_INT64_GROUPED_SIZE], int64_t num) ATTR_NONNULL(1)
int bool bool bool BLI_strn_endswith(const char *__restrict str, const char *__restrict end, size_t str_len) ATTR_NONNULL(1
bool BLI_string_has_word_prefix(const char *haystack, const char *needle, size_t needle_len) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
char * BLI_strdupn(const char *str, size_t len) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
void BLI_str_format_byte_unit_compact(char dst[BLI_STR_FORMAT_INT64_BYTE_UNIT_COMPACT_SIZE], long long int bytes, bool base_10) ATTR_NONNULL(1)
size_t size_t const char * BLI_str_escape_find_quote(const char *str) ATTR_NONNULL(1)
char BLI_toupper_ascii(const char c) ATTR_WARN_UNUSED_RESULT
static int left_number_strcmp(const char *s1, const char *s2, int *tiebreaker)
int char * BLI_strcasestr(const char *s, const char *find) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
size_t BLI_snprintf_rlen(char *__restrict dst, size_t dst_maxncpy, const char *__restrict format,...) ATTR_NONNULL(1
bool bool int BLI_string_find_split_words(const char *str, size_t str_maxlen, char delim, int r_words[][2], int words_max) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
int BLI_str_index_in_array(const char *__restrict str, const char **__restrict str_array) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
char char * BLI_strncpy_ensure_pad(char *__restrict dst, const char *__restrict src, char pad, size_t dst_maxncpy) ATTR_NONNULL(1
bool bool int bool BLI_string_elem_split_by_delim(const char *haystack, const char delim, const char *needle) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
int char char int int BLI_strncasecmp(const char *s1, const char *s2, size_t len) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
char * BLI_strncpy(char *__restrict dst, const char *__restrict src, size_t dst_maxncpy) ATTR_NONNULL(1
static size_t BLI_str_format_int_grouped_ex(char *src, char *dst, int num_len)
BLI_INLINE bool str_unescape_pair(char c_next, char *r_out)
char char size_t BLI_str_escape(char *__restrict dst, StringRef src, size_t dst_maxncpy) ATTR_NONNULL(1)
int BLI_str_rstrip_float_zero(char *str, char pad) ATTR_NONNULL(1)
char char size_t BLI_strncpy_rlen(char *__restrict dst, const char *__restrict src, size_t dst_maxncpy) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
int bool bool bool size_t size_t size_t int BLI_string_max_possible_word_count(int str_len) ATTR_WARN_UNUSED_RESULT
constexpr size_t ARRAY_SIZE(const T(&arg)[N]) noexcept
int char char int int int int size_t BLI_strnlen(const char *str, size_t maxlen) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
int BLI_str_index_in_array_n(const char *__restrict str, const char **__restrict str_array, int str_array_len) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
ATTR_WARN_UNUSED_RESULT const size_t num
size_t BLI_str_unescape_ex(char *__restrict dst, const char *__restrict src, size_t src_len, size_t dst_maxncpy, bool *r_is_complete) ATTR_NONNULL(1
char BLI_tolower_ascii(const char c) ATTR_WARN_UNUSED_RESULT
void BLI_str_tolower_ascii(char *str, size_t len) ATTR_NONNULL(1)
size_t BLI_str_format_int_grouped(char dst[BLI_STR_FORMAT_INT32_GROUPED_SIZE], int num) ATTR_NONNULL(1)
char * BLI_strdup(const char *str) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1) ATTR_MALLOC
bool BLI_str_quoted_substr_range(const char *__restrict str, const char *__restrict prefix, int *__restrict r_start, int *__restrict r_end) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
size_t size_t BLI_vsnprintf_rlen(char *__restrict dst, size_t dst_maxncpy, const char *__restrict format, va_list arg) ATTR_PRINTF_FORMAT(3
void BLI_str_format_integer_unit(char dst[BLI_STR_FORMAT_INT32_INTEGER_UNIT_SIZE], int number_to_format) ATTR_NONNULL(1)
int bool BLI_str_startswith(const char *__restrict str, const char *__restrict start) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
void BLI_str_rstrip(char *str) ATTR_NONNULL(1)
size_t size_t char * BLI_sprintfN_with_buffer(char *fixed_buf, size_t fixed_buf_maxncpy, size_t *result_len, const char *__restrict format,...) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
int bool bool bool size_t size_t size_t BLI_str_partition_ex(const char *str, const char *end, const char delim[], const char **sep, const char **suf, bool from_right) ATTR_NONNULL(1
int bool bool bool size_t size_t BLI_str_rpartition(const char *str, const char delim[], const char **sep, const char **suf) ATTR_NONNULL(1
size_t size_t BLI_str_unescape(char *__restrict dst, const char *__restrict src, size_t src_len) ATTR_NONNULL(1
bool bool BLI_string_all_words_matched(const char *name, const char *str, int(*words)[2], int words_len) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
char * BLI_strdup_null(const char *str) ATTR_WARN_UNUSED_RESULT ATTR_MALLOC
char char * BLI_vsprintfN(const char *__restrict format, va_list args) ATTR_NONNULL(1) ATTR_MALLOC ATTR_PRINTF_FORMAT(1
int BLI_str_rstrip_digits(char *str) ATTR_NONNULL()
int BLI_strcaseeq(const char *a, const char *b) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
int char char * BLI_strncasestr(const char *s, const char *find, size_t len) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
char char size_t char * BLI_strncat(char *__restrict dst, const char *__restrict src, size_t dst_maxncpy) ATTR_NONNULL(1
size_t BLI_str_format_uint64_grouped(char dst[BLI_STR_FORMAT_UINT64_GROUPED_SIZE], uint64_t num) ATTR_NONNULL(1)
int char char int int int int BLI_strcmp_ignore_pad(const char *str1, const char *str2, char pad) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
char char size_t char const char * BLI_strchr_or_end(const char *str, char ch) ATTR_WARN_UNUSED_RESULT ATTR_RETURNS_NONNULL ATTR_NONNULL(1)
char * BLI_vsprintfN_with_buffer(char *fixed_buf, size_t fixed_buf_maxncpy, size_t *result_len, const char *__restrict format, va_list args) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float