diff options
Diffstat (limited to 'src/str.c')
| -rw-r--r-- | src/str.c | 776 |
1 files changed, 705 insertions, 71 deletions
@@ -1,109 +1,743 @@ /* - pkgit - package it! +pkgit - package it! - Copyright (C) 2026 dacctal - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 2 of the License, or - (at your option) any later version. +Copyright (C) 2026 dacctal +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 2 of the License, or +(at your option) any later version. - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the +GNU General Public License for more details. - You should have received a copy of the GNU General Public License - along with this program. If not, see <https://www.gnu.org/licenses/>. +You should have received a copy of the GNU General Public License +along with this program.If not, see <https://www.gnu.org/licenses/>. */ #include <ctype.h> +#include <errno.h> +#include <stdarg.h> +#include <stddef.h> +#include <stdint.h> #include <stdio.h> #include <stdlib.h> #include <string.h> +#include "globs.h" #include "str.h" -void slc_print(str_slc slc) { - for (size_t i = 0; i < slc.len; i++) { - putchar(slc.data[i]); +// NOTE: only use this assertion in functions where you don't depend +// on any other str_ ones, to prevent checking twice +#ifdef PKGIT_DEBUG +#define assert_str_is_valid(str) \ + do { \ + if (!str_is_valid(str)) \ + panic("Cannot operate on str `%s`, which is invalid!", #str); \ + } while (0) +#else +#define assert_str_is_valid(str) +#endif + +// XXX: INTERNAL USE ONLY +#define _strslc(str) \ + (str_slc) { str->data, str->len } +#define _cstrslc(str) \ + (str_slc) { str, strlen(str) } +// XXX: since msvc/tcc and I presume cproc aren't smart enough to inline calls +// where a str calls a str_slc function and vice versa, we optimize things +// ourselves+reduce boilerplate +#define _STRINGS_EQUAL + +str str_new(void) { return str_new_with_capacity(16); } + +str str_new_with_capacity(size_t cap) { + str res = {0}; + res.cap = cap; + res.data = calloc(res.cap, 1); + check_alloc(res.data); + return res; +} + +str str_from_cstr(const char *s) { return str_from_str_slc(_cstrslc(s)); } + +str mstr(const char *s) { return str_from_str_slc(_cstrslc(s)); } + +str str_from_str_slc(const str_slc s) { + str res = str_new_with_capacity(s.len + 1); + str_copy_str_slc_into(&res, s); + return res; +} + +str str_format(const char *format, ...) { + va_list args, args_copy; + va_start(args, format); + va_copy(args_copy, args); + + size_t len = vsnprintf(NULL, 0, format, args_copy); + str res = str_new_with_capacity(len + 1); + res.len = len; + vsnprintf(res.data, res.cap, format, args); + + va_end(args); + return res; +} + +void str_format_into(str *s, const char *format, ...) { + va_list args, args_copy; + va_start(args, format); + va_copy(args_copy, args); + + size_t len = vsnprintf(NULL, 0, format, args_copy); + + if (!str_is_valid(s)) { + *s = str_new_with_capacity(len + 1); + } else { + if (s->cap < len + 1) + str_reserve_exact(s, len + 1); + str_clear(s); } + s->len = len; + vsnprintf(s->data, s->cap, format, args); + + va_end(args); } -str_slc slc_from_cstr(char* cstr) { - return (str_slc) { - .data = cstr, - .len = strlen(cstr), - }; +void str_reserve(str *s, size_t new_cap) { + str_reserve_exact(s, new_cap + (new_cap >> 2)); +} + +void str_reserve_exact(str *s, size_t new_cap) { + assert_str_is_valid(s); + if (s->cap == new_cap) + return; + s->data = realloc(s->data, new_cap); + s->cap = new_cap; + check_alloc(s->data); +} + +void str_clear(str *s) { + assert_str_is_valid(s); + memset(s->data, 0, s->cap); + s->len = 0; +} + +void str_free(str *s) { + // let multiple frees be no-ops + if (!s->data) + return; + free(s->data); + s->data = NULL; +} + +void str_copy_into(str *dest, const str *src) { + str_ncopy_cstr_into(dest, src->data, src->len); } -int slc_eq(str_slc a, str_slc b) { - if (a.len != b.len) return 0; - for (size_t i = 0; i < a.len; i++) { - if (a.data[i] != b.data[i]) return 0; +void str_copy_cstr_into(str *dest, const char *src) { + str_ncopy_cstr_into(dest, src, strlen(src)); +} + +void str_copy_str_slc_into(str *dest, const str_slc src) { + str_ncopy_cstr_into(dest, src.data, src.len); +} + +void str_ncopy_into(str *dest, const str *src, size_t count) { + str_ncopy_cstr_into(dest, src->data, count); +} + +void str_ncopy_cstr_into(str *dest, const char *src, size_t count) { + assert_str_is_valid(dest); + assert(src); + dest->len = count; + if (dest->cap < count + 1) + str_reserve_exact(dest, count + 1); + memcpy(dest->data, src, count); + dest->data[count] = 0; +} + +void str_ncopy_str_slc_into(str *dest, const str_slc src, size_t count) { + str_ncopy_cstr_into(dest, src.data, count); +} + +str str_dupe(const str *src) { + assert_str_is_valid(src); + str res = str_new_with_capacity(src->cap); + str_copy_into(&res, src); + return res; +} + +void str_append(str *src, const str *new) { + str_append_str_slc(src, _strslc(new)); +} + +void str_append_char(str *src, char new) { + assert_str_is_valid(src); + // new char + nullterm + if (src->len + 2 < src->cap) { + // this will reserve 1.5*src->cap + str_reserve(src, src->cap); } - return 1; + src->data[src->len++] = new; + src->data[src->len] = 0; +} + +void str_append_cstr(str *src, const char *new) { + assert(new); + str_append_str_slc(src, _cstrslc(new)); } -int slc_starts_with(str_slc slc, str_slc prefix) { - if (prefix.len > slc.len) return 0; - for (size_t i = 0; i < prefix.len; i++) { - if (slc.data[i] != prefix.data[i]) return 0; +void str_append_str_slc(str *src, const str_slc new) { + assert_str_is_valid(src); + assert_str_is_valid(&new); + size_t len_after_append = src->len + new.len; + if (len_after_append + 1 > src->cap) { + src->cap = len_after_append + 1; + str_reserve(src, src->cap); } - return 1; + memcpy(src->data + src->len, new.data, new.len + 1); + src->len = len_after_append; + src->data[len_after_append] = 0; } -str_slc slc_take(str_slc slc, size_t n) { - if (n > slc.len) n = slc.len; - return (str_slc) { - .data = slc.data, - .len = n - }; +char str_pop_last(str *src) { + char c = str_last(src); + src->len--; + return c; +} + +str str_concat(const str *lhs, const str *rhs) { + str res = str_dupe(lhs); + str_append(&res, rhs); + return res; +} + +str str_concat_cstr(const str *lhs, const char *rhs) { + str res = str_dupe(lhs); + str_append_cstr(&res, rhs); + return res; +} + +str str_concat_str_slc(const str *lhs, const str_slc rhs) { + str res = str_dupe(lhs); + str_append_str_slc(&res, rhs); + return res; +} + +str str_trim_left(const str *s) { + str res = str_dupe(s); + str_trim_left_in_place(&res); + return res; +} + +str str_trim_right(const str *s) { + str res = str_dupe(s); + str_trim_right_in_place(&res); + return res; +} + +str str_trim(const str *s) { + str res = str_dupe(s); + str_trim_in_place(&res); + return res; +} + +str str_to_upper(const str *s) { + str res = str_dupe(s); + str_to_upper_in_place(&res); + return res; +} + +str str_to_lower(const str *s) { + str res = str_dupe(s); + str_to_lower_in_place(&res); + return res; +} + +void str_trim_left_in_place(str *s) { + assert_str_is_valid(s); + size_t i; + for (i = 0; i < s->len && isspace(s->data[i]); i++) + continue; + s->len -= i; + memmove(s->data, s->data + i, s->len); + s->data[s->len] = 0; +} + +void str_trim_right_in_place(str *s) { + assert_str_is_valid(s); + if (s->len == 0) + return; + size_t end; + for (end = s->len - 1; isspace(s->data[end]); end--) + continue; + end++; + s->len = end; + s->data[s->len] = 0; +} + +void str_trim_in_place(str *s) { + assert_str_is_valid(s); + if (s->len == 0) + return; + size_t begin, end; + for (begin = 0; begin < s->len && isspace(s->data[begin]); begin++) + continue; + for (end = s->len - 1; isspace(s->data[end]); end--) + continue; + end++; + s->len = end - begin; + memmove(s->data, s->data + begin, s->len); + s->data[s->len] = 0; +} + +void str_to_upper_in_place(str *s) { + assert_str_is_valid(s); + for (size_t i = 0; i < s->len; i++) + s->data[i] = toupper(s->data[i]); +} + +void str_to_lower_in_place(str *s) { + assert_str_is_valid(s); + for (size_t i = 0; i < s->len; i++) + s->data[i] = tolower(s->data[i]); +} + +bool str_equal(const str *lhs, const str *rhs) { + return str_slc_equal(_strslc(lhs), _strslc(rhs)); +} + +bool str_equal_cstr(const str *lhs, const char *rhs) { + assert(rhs); + return str_slc_equal(_strslc(lhs), _cstrslc(rhs)); +} + +bool str_equal_str_slc(const str *lhs, const str_slc rhs) { + return str_slc_equal(_strslc(lhs), rhs); +} + +int str_compare(const str *lhs, const str *rhs) { + return str_slc_compare(_strslc(lhs), _strslc(rhs)); +} + +int str_compare_cstr(const str *lhs, const char *rhs) { + assert(rhs); + return str_slc_compare(_strslc(lhs), _cstrslc(rhs)); +} + +int str_compare_str_slc(const str *lhs, const str_slc rhs) { + return str_slc_compare(_strslc(lhs), rhs); +} + +bool str_equal_case_insensitive(const str *lhs, const str *rhs) { + return str_slc_equal_case_insensitive(_strslc(lhs), _strslc(rhs)); +} + +bool str_equal_cstr_case_insensitive(const str *lhs, const char *rhs) { + assert(rhs); + return str_slc_equal_case_insensitive(_strslc(lhs), _cstrslc(rhs)); +} + +bool str_equal_str_slc_case_insensitive(const str *lhs, const str_slc rhs) { + return str_slc_equal_case_insensitive(_strslc(lhs), rhs); +} + +int str_compare_case_insensitive(const str *lhs, const str *rhs) { + return str_slc_compare_case_insensitive(_strslc(lhs), _strslc(rhs)); +} + +int str_compare_cstr_case_insensitive(const str *lhs, const char *rhs) { + assert(rhs); + return str_slc_compare_case_insensitive(_strslc(lhs), _cstrslc(rhs)); +} + +int str_compare_str_slc_case_insensitive(const str *lhs, const str_slc rhs) { + return str_slc_compare_case_insensitive(_strslc(lhs), rhs); +} + +str str_slice_to_str(const str *src, ptrdiff_t begin, ptrdiff_t end) { + str_slc slc = str_slc_slice(_strslc(src), begin, end); + return str_from_str_slc(slc); +} + +str str_slice_from_cstr(const char *src, ptrdiff_t begin, ptrdiff_t end) { + str_slc slc = str_slc_slice(_cstrslc(src), begin, end); + return str_from_str_slc(slc); +} + +str_slc str_slice(const str *src, ptrdiff_t begin, ptrdiff_t end) { + return str_slc_slice(_strslc(src), begin, end); +} + +str str_slice_from_str_slc(const str_slc src, ptrdiff_t begin, ptrdiff_t end) { + str_slc slc = str_slc_slice(src, begin, end); + return str_from_str_slc(slc); } -str_slc slc_drop(str_slc slc, size_t n) { - if (n > slc.len) n = slc.len; - return (str_slc) { - .data = slc.data + n, - .len = slc.len - n +size_t str_to_double_pro(const str *src, double *res) { + return str_slc_to_double_pro(_strslc(src), res); +} + +size_t str_to_int64_pro(const str *src, int64_t *res, int base) { + return str_slc_to_int64_pro(_strslc(src), res, base); +} + +bool str_to_double(const str *src, double *res) { + return str_to_double_pro(src, res) == src->len; +} + +bool str_to_int64(const str *src, int64_t *res) { + return str_to_int64_pro(src, res, 10) == src->len; +} + +char str_at(const str *s, size_t i) { + assert_str_is_valid(s); +#ifndef PKGIT_DEBUG + if (i >= s->len) + panic("Out of bounds string access at index %zu (length: %zu)", i, + s->len); +#endif + return s->data[i]; +} + +char str_first(const str *s) { + assert_str_is_valid(s); +#ifndef PKGIT_DEBUG + if (!s->len) + panic("Attempted to get the first character of an empty string"); +#endif + return *s->data; +} + +char str_last(const str *s) { + assert_str_is_valid(s); +#ifndef PKGIT_DEBUG + if (!s->len) + panic("Attempted to get the last character of an empty string"); +#endif + return s->data[s->len - 1]; +} + +size_t str_find_char(const str *s, char c) { + return str_slc_find_char(_strslc(s), c); +} + +size_t str_find_char_right(const str *s, char c) { + return str_slc_find_char_right(_strslc(s), c); +} + +void str_print(const str *s) { printf("%.*s", str_fmt(s)); } + +void str_println(const str *s) { printf("%.*s\n", str_fmt(s)); } + +void str_fprint(const str *s, FILE *f) { fprintf(f, "%.*s", str_fmt(s)); } + +void str_fprintln(const str *s, FILE *f) { fprintf(f, "%.*s\n", str_fmt(s)); } + +str str_read_line_from_file(FILE *f) { + size_t len = 0; + char c; + for (len = 0; (c = fgetc(f)) != EOF && c != '\n'; len++) + continue; + fseek(f, -len - 1, SEEK_SET); + str res = str_new_with_capacity(len + 1); + size_t bytes_read = fread(res.data, 1, len, f); + assert(bytes_read == len); + res.len = len; + return res; +} + +str str_read_chars_from_file(FILE *f, size_t count) { + str res = str_new_with_capacity(count + 1); + size_t bytes_read = fread(res.data, 1, count, f); + assert(bytes_read == count); + res.len = count; + return res; +} + +str str_read_entire_file(FILE *f) { + fseek(f, 0, SEEK_END); + size_t len = ftell(f); + rewind(f); + str res = str_new_with_capacity(len + 1); + size_t bytes_read = fread(res.data, 1, len, f); + assert(bytes_read == len); + res.len = len; + return res; +} + +bool str_write_to_file(const str *s, FILE *f) { + return str_slc_write_to_file(_strslc(s), f); +} + +// === str_slc implementation === + +str_slc str_slc_from_str(const str *s) { return _strslc(s); } + +str_slc str_slc_from_cstr(const char *s) { return _cstrslc(s); } + +str_slc mstrslc(const char *s) { return (str_slc){s, strlen(s)}; } + +str str_slc_concat(const str_slc lhs, const str_slc rhs) { + str res = str_new(); + str_append_str_slc(&res, lhs); + str_append_str_slc(&res, rhs); + return res; +} + +str str_slc_concat_cstr(const str_slc lhs, const char *rhs) { + str res = str_new(); + str_append_str_slc(&res, lhs); + str_append_cstr(&res, rhs); + return res; +} + +bool str_slc_equal(const str_slc lhs, const str_slc rhs) { + assert_str_is_valid(&lhs); + assert_str_is_valid(&rhs); + return (lhs.len == rhs.len) && memcmp(lhs.data, rhs.data, lhs.len) == 0; +} + +bool str_slc_equal_cstr(const str_slc lhs, const char *rhs) { + assert(rhs); + return str_slc_equal(lhs, _cstrslc(rhs)); +} + +bool str_slc_equal_case_insensitive(const str_slc lhs, const str_slc rhs) { + assert_str_is_valid(&lhs); + assert_str_is_valid(&rhs); + if (lhs.len != rhs.len) + return false; + for (size_t i = 0; i < lhs.len; i++) + if (tolower(lhs.data[i]) != tolower(rhs.data[i])) + return false; + return true; +} + +bool str_slc_equal_cstr_case_insensitive(const str_slc lhs, const char *rhs) { + return str_slc_equal_case_insensitive(lhs, _cstrslc(rhs)); +} + +int str_slc_compare(const str_slc lhs, const str_slc rhs) { + assert_str_is_valid(&lhs); + assert_str_is_valid(&rhs); + if (lhs.len < rhs.len) + return -1; + else if (lhs.len > rhs.len) + return 1; + for (size_t i = 0; i < lhs.len; i++) + if (lhs.data[i] != rhs.data[i]) + return (uint8_t)lhs.data[i] - (uint8_t)rhs.data[i]; + return 0; +} + +int str_slc_compare_cstr(const str_slc lhs, const char *rhs) { + return str_slc_compare(lhs, _cstrslc(rhs)); +} + +int str_slc_compare_case_insensitive(const str_slc lhs, const str_slc rhs) { + assert_str_is_valid(&lhs); + assert_str_is_valid(&rhs); + if (lhs.len < rhs.len) + return -1; + else if (lhs.len > rhs.len) + return 1; + char cl, cr; + for (size_t i = 0; i < lhs.len; i++) + if ((cl = tolower(lhs.data[i])) != (cr = tolower(rhs.data[i]))) + return (uint8_t)cl - (uint8_t)cr; + return 0; +} + +int str_slc_compare_cstr_case_insensitive(const str_slc lhs, const char *rhs) { + return str_slc_compare_case_insensitive(lhs, _cstrslc(rhs)); +} + +str_slc str_slc_slice(const str_slc src, ptrdiff_t begin, ptrdiff_t end) { + assert_str_is_valid(&src); + if (begin > end) + return (str_slc){src.data, 0}; + if (end < 0) + end = 0; + else if (end > (ptrdiff_t)src.len) + end = src.len; + if (begin < 0) + begin = 0; + else if (begin > (ptrdiff_t)src.len) + begin = src.len; + str_slc res = { + .data = src.data + begin, + .len = end - begin, }; + return res; } -str_slc slc_trim(str_slc slc) { - while (slc.len > 0 && isspace((unsigned char)slc.data[0])) { - slc = slc_drop(slc, 1); - } - while (slc.len > 0 && isspace((unsigned char)slc.data[slc.len - 1])) { - slc = slc_take(slc, slc.len - 1); - } - return slc; +// Equivalent to str_slice_from_str_slc +str str_slc_slice_to_str(const str_slc s, ptrdiff_t begin, ptrdiff_t end) { + return str_slice_from_str_slc(s, begin, end); } -str_slc slc_split(str_slc *slc, char delimiter) { - size_t i = 0; - while(i < slc->len && slc->data[i] != delimiter) { - i++; - } +str str_slc_to_lower(const str_slc s) { + str res = str_from_str_slc(s); + str_to_lower_in_place(&res); + return res; +} - str_slc result = slc_take(*slc, i); - if (i < slc->len) { - *slc = slc_drop(*slc, i + i); - } else { - *slc = slc_drop(*slc, i); - } - return result; +str str_slc_to_upper(const str_slc s) { + str res = str_from_str_slc(s); + str_to_upper_in_place(&res); + return res; } -void slc_cat(str_slc first, str_slc second, str_slc *new_slc) { - if (new_slc->len < first.len + second.len) { - printf("fatal: slc_cat length of new slice is too small\n"); - exit(EXIT_FAILURE); - } - for (size_t i = 0; i < first.len; i++) { - new_slc->data[i] = first.data[i]; - } - for (size_t i = first.len; i < new_slc->len; i++) { - new_slc->data[i] = second.data[i-first.len]; +str_slc str_slc_trim_left(const str_slc s) { + assert_str_is_valid(&s); + size_t i; + for (i = 0; i < s.len && isspace(s.data[i]); i++) + continue; + return (str_slc){s.data + i, s.len - i}; +} + +str_slc str_slc_trim_right(const str_slc s) { + if (s.len == 0) + return s; + size_t end; + for (end = s.len - 1; isspace(s.data[end]); end--) + continue; + end++; + return (str_slc){s.data, end}; +} + +str_slc str_slc_trim(const str_slc s) { + if (s.len == 0) + return s; + size_t begin, end; + for (begin = 0; begin < s.len && isspace(s.data[begin]); begin++) + continue; + for (end = s.len - 1; isspace(s.data[end]); end--) + continue; + end++; + return (str_slc){s.data + begin, end - begin}; +} + +size_t str_slc_to_double_pro(const str_slc src, double *res) { + assert_str_is_valid(&src); + errno = 0; + char *endptr = NULL; + const char *nptr = src.data; + double num = strtod(nptr, &endptr); + size_t diff = endptr - nptr; + *res = num; + return diff; +} + +size_t str_slc_to_int64_pro(const str_slc src, int64_t *res, int base) { + assert_str_is_valid(&src); + errno = 0; + char *endptr = NULL; + const char *nptr = src.data; + int64_t num = strtoll(nptr, &endptr, base); + size_t diff = endptr - nptr; + *res = num; + return diff; +} + +bool str_slc_to_double(const str_slc src, double *res) { + return str_slc_to_double_pro(src, res) == src.len; +} + +bool str_slc_to_int64(const str_slc src, int64_t *res) { + return str_slc_to_int64_pro(src, res, 10) == src.len; +} + +bool str_slc_write_to_file(const str_slc s, FILE *f) { + return s.len == fwrite(s.data, 1, s.len, f); +} + +char str_slc_first(const str_slc s) { + assert_str_is_valid(&s); +#ifndef PKGIT_DEBUG + if (!s.len) + panic("Attempted to get the first character of an empty string"); +#endif + return *s.data; +} + +char str_slc_last(const str_slc s) { + assert_str_is_valid(&s); +#ifndef PKGIT_DEBUG + if (!s.len) + panic("Attempted to get the last character of an empty string"); +#endif + return s.data[s.len - 1]; +} + +char str_slc_at(const str_slc s, size_t i) { + assert_str_is_valid(&s); +#ifndef PKGIT_DEBUG + if (i >= s.len) + panic("Out of bounds string access at index %zu (length: %zu)", i, + s.len); +#endif + return s.data[i]; +} + +void str_slc_print(const str_slc s) { printf("%.*s", str_fmt(&s)); } + +void str_slc_println(const str_slc s) { printf("%.*s\n", str_fmt(&s)); } + +void str_slc_fprint(const str_slc s, FILE *f) { + fprintf(f, "%.*s", str_fmt(&s)); +} + +void str_slc_fprintln(const str_slc s, FILE *f) { + fprintf(f, "%.*s\n", str_fmt(&s)); +} + +ptrdiff_t str_slc_find_char(const str_slc s, char c) { + size_t i; + for (i = 0; i < s.len; i++) + if (s.data[i] == c) + break; + return (i == s.len) ? 0 : i; +} + +ptrdiff_t str_slc_find_char_right(const str_slc s, char c) { + if (s.len == 0) + return 0; + for (ptrdiff_t i = s.len - 1; i >= 0; i--) { + if (s.data[i] == c) + return (size_t)i; } + return s.len; +} + +str str_from_after_delim(str *arg, char delimiter) { + size_t i = str_find_char_right(arg, delimiter); + str res = str_slice_to_str(arg, i + 1, arg->len); + str_println(&res); + return res; +} + +str str_from_before_delim(str *arg, char delimiter) { + size_t i = str_find_char(arg, delimiter); + str res = str_slice_to_str(arg, i + 1, arg->len); + str_println(&res); + return res; +} + +str_slc str_slc_from_after_delim(str_slc arg, char delimiter) { + size_t i = str_slc_find_char_right(arg, delimiter); + str_slc res = str_slc_slice(arg, i + 1, arg.len); + str_slc_println(res); + return res; +} + +str_slc str_slc_from_before_delim(str_slc arg, char delimiter) { + size_t i = str_slc_find_char(arg, delimiter); + str_slc res = str_slc_slice(arg, i + 1, arg.len); + str_slc_println(res); + return res; } |