51 #define MIN_PRINTF_ALLOC 16 71 char *buf = malloc(size *
sizeof(
char));
76 va_copy(args, orig_args);
77 returnsize = vsnprintf(buf, size, fmt, args);
81 if (returnsize < size) {
87 size = returnsize + 1;
88 buf = malloc(size *
sizeof(
char));
90 va_copy(args, orig_args);
91 returnsize = vsnprintf(buf, size, fmt, args);
94 assert(returnsize <= size);
105 va_start(args, first);
106 const char *arg = first;
109 arg = va_arg(args,
const char *);
115 char *
str = malloc(len*
sizeof(
char) + 1);
119 va_start(args, first);
120 const char *arg = first;
124 arg = va_arg(args,
const char *);
141 size_t lena = strlen(a);
142 size_t lenb = strlen(b);
144 size_t minlen = lena < lenb ? lena : lenb;
146 for (; i < minlen; i++)
157 assert(delim != NULL);
162 size_t delim_len = strlen(delim);
163 size_t len = strlen(str);
194 size_t len = strlen(str);
199 while (pos < len && str[pos] ==
' ')
206 while (pos < len && str[pos] !=
' ')
210 size_t len = off1 - off0;
211 char *tok = malloc(len + 1);
212 memcpy(tok, &str[off0], len);
242 char *end = str + strlen(str);
243 for(; ptr != end && isspace(*ptr); ptr++);
245 memmove(str, ptr, strlen(ptr)+1);
253 char *ptr = str + strlen(str) - 1;
254 for(; ptr+1 != str && isspace(*ptr); ptr--);
261 assert(haystack != NULL);
262 assert(needle != NULL);
265 int hlen = (int) strlen(haystack);
266 int nlen = (int) strlen(needle);
268 if (nlen > hlen)
return -1;
270 for (
int i = 0; i <= hlen - nlen; i++) {
271 if (!strncmp(&haystack[i], needle, nlen))
280 assert(haystack != NULL);
281 assert(needle != NULL);
284 int hlen = (int) strlen(haystack);
285 int nlen = (int) strlen(needle);
288 for (
int i = 0; i <= hlen - nlen; i++) {
289 if (!strncmp(&haystack[i], needle, nlen))
301 size_t slen = strlen(s);
302 for (
int i = 0; i < slen; i++) {
303 if (s[i] >=
'A' && s[i] <=
'Z')
304 s[i] = s[i] +
'a' -
'A';
314 size_t slen = strlen(s);
315 for (
int i = 0; i < slen; i++) {
316 if (s[i] >=
'a' && s[i] <=
'z')
317 s[i] = s[i] - (
'a' -
'A');
328 sb->
s = calloc(sb->
alloc, 1);
350 sb->
s = realloc(sb->
s, sb->
alloc);
353 sb->
s[sb->
size++] = c;
362 char back = sb->
s[--sb->
size];
373 char *buf = malloc(size *
sizeof(
char));
379 returnsize = vsnprintf(buf, size, fmt, args);
382 if (returnsize >= size) {
385 size = returnsize + 1;
386 buf = malloc(size *
sizeof(
char));
389 returnsize = vsnprintf(buf, size, fmt, args);
392 assert(returnsize <= size);
404 size_t len = strlen(str);
408 sb->
s = realloc(sb->
s, sb->
alloc);
411 memcpy(&sb->
s[sb->
size], str, len);
428 return strdup(sb->
s);
453 sf->
len = strlen(sf->
s);
486 return sf->
s[sf->
pos] != 0 && sf->
pos <= sf->
len;
492 assert(sf->
pos <= sf->
len);
494 char c = sf->
s[sf->
pos++];
509 assert(sf->
pos <= sf->
len);
511 if (sf->
pos + length > sf->
len)
512 length = sf->
len - sf->
pos;
514 char *substr = calloc(length+1,
sizeof(
char));
515 for (
int i = 0 ; i < length ; i++)
523 assert(sf->
pos <= sf->
len);
525 return sf->
s[sf->
pos];
532 assert(sf->
pos <= sf->
len);
534 if (sf->
pos + length > sf->
len)
535 length = sf->
len - sf->
pos;
537 char *substr = calloc(length+1,
sizeof(
char));
538 memcpy(substr, &sf->
s[sf->
pos], length*
sizeof(
char));
546 assert(sf->
pos <= sf->
len);
555 assert(sf->
pos <= sf->
len);
557 size_t len = strlen(str);
559 for (
int i = 0; i < len; i++) {
568 assert(haystack != NULL);
569 assert(needle != NULL);
571 size_t lens = strlen(haystack);
572 size_t lenneedle = strlen(needle);
574 if (lenneedle > lens)
577 return !strncmp(&haystack[lens - lenneedle], needle, lenneedle);
582 assert(haystack != NULL);
583 assert(needle != NULL);
590 while (haystack[pos] == needle[pos] && needle[pos] != 0)
593 return (needle[pos] == 0);
598 assert(haystack != NULL);
599 assert(needles != NULL);
600 assert(num_needles >= 0);
602 for (
int i = 0; i < num_needles; i++) {
603 assert(needles[i] != NULL);
613 assert(haystack != NULL);
614 assert(needles != NULL);
615 assert(num_needles >= 0);
617 for (
int i = 0; i < num_needles; i++) {
618 assert(needles[i] != NULL);
619 if (!strcmp(haystack, needles[i]))
629 assert(startidx >= 0 && startidx <= strlen(str)+1);
630 assert(endidx < 0 || endidx >= startidx);
631 assert(endidx < 0 || endidx <= strlen(str)+1);
634 endidx = (long) strlen(str);
636 size_t blen = endidx - startidx;
637 char *b = malloc(blen + 1);
638 memcpy(b, &str[startidx], blen);
643 char *
str_replace(
const char *haystack,
const char *needle,
const char *replacement)
645 assert(haystack != NULL);
646 assert(needle != NULL);
647 assert(replacement != NULL);
650 size_t haystack_len = strlen(haystack);
651 size_t needle_len = strlen(needle);
654 while (pos < haystack_len) {
663 if (needle_len == 0 && haystack_len == 0)
674 va_start(ap, _haystack);
676 char *haystack = strdup(_haystack);
679 char *needle = va_arg(ap,
char*);
683 char *replacement = va_arg(ap,
char*);
684 char *tmp =
str_replace(haystack, needle, replacement);
700 char *
s = malloc(salloc);
703 int slen = vsnprintf(s, salloc, fmt, ap);
706 if (slen >= salloc) {
707 s = realloc(s, slen + 1);
709 vsprintf((
char*) s, fmt, ap);
713 buf = realloc(buf, *bufpos + slen + 1);
716 memcpy(&buf[*bufpos], s, slen + 1);
724 if (c >=
'a' && c <=
'z')
727 if (c >=
'A' && c <=
'Z')
730 if (c >=
'0' && c <=
'9')
741 size_t inlen = strlen(in);
747 while (inpos < inlen) {
749 if (in[inpos] !=
'$') {
757 char *varname = NULL;
765 char *env = getenv(varname);
bool str_matches_any(const char *haystack, const char **needles, int num_needles)
zarray_t * str_split_spaces(const char *str)
char * str_lstrip(char *str)
char * str_trim(char *str)
void str_split_destroy(zarray_t *za)
bool str_ends_with(const char *haystack, const char *needle)
void string_buffer_append(string_buffer_t *sb, char c)
int str_diff_idx(const char *a, const char *b)
char string_buffer_pop_back(string_buffer_t *sb)
char * vsprintf_alloc(const char *fmt, va_list orig_args)
bool string_feeder_starts_with(string_feeder_t *sf, const char *str)
static void zarray_destroy(zarray_t *za)
char * string_buffer_to_string(string_buffer_t *sb)
char * str_rstrip(char *str)
char * string_feeder_peek_length(string_feeder_t *sf, size_t length)
char * str_substring(const char *str, size_t startidx, long endidx)
char string_feeder_next(string_feeder_t *sf)
static zarray_t * zarray_create(size_t el_sz)
int string_feeder_get_column(string_feeder_t *sf)
void string_buffer_appendf(string_buffer_t *sb, const char *fmt,...)
char * str_expand_envs(const char *in)
int string_feeder_get_line(string_feeder_t *sf)
size_t string_buffer_size(string_buffer_t *sb)
string_buffer_t * string_buffer_create()
char * string_feeder_next_length(string_feeder_t *sf, size_t length)
void string_feeder_require(string_feeder_t *sf, const char *str)
string_feeder_t * string_feeder_create(const char *str)
bool string_feeder_has_next(string_feeder_t *sf)
char * str_tolowercase(char *s)
char * str_replace_many(const char *_haystack,...)
bool str_starts_with(const char *haystack, const char *needle)
zarray_t * str_split(const char *str, const char *delim)
char * str_replace(const char *haystack, const char *needle, const char *replacement)
void string_feeder_destroy(string_feeder_t *sf)
void string_buffer_append_string(string_buffer_t *sb, const char *str)
char * sprintf_alloc(const char *fmt,...)
void string_buffer_reset(string_buffer_t *sb)
static void buffer_appendf(char **_buf, int *bufpos, void *fmt,...)
bool str_starts_with_any(const char *haystack, const char **needles, int num_needles)
int str_indexof(const char *haystack, const char *needle)
bool string_buffer_ends_with(string_buffer_t *sb, const char *str)
void zarray_vmap(zarray_t *za, void(*f)())
void string_buffer_destroy(string_buffer_t *sb)
char string_feeder_peek(string_feeder_t *sf)
int str_last_indexof(const char *haystack, const char *needle)
char * str_touppercase(char *s)
char * _str_concat_private(const char *first,...)
static int is_variable_character(char c)
static void zarray_add(zarray_t *za, const void *p)