Browse Source
`sdd` was the first attempt at making one of these individually-allocated string management/utility things. I didn't end up liking the design, so I tried again from scratch, and called the new one `oso`. Let's see how that one turns out. The name might change again in the future, though I feel better about the design of this one.master
cancel
5 years ago
8 changed files with 462 additions and 350 deletions
@ -0,0 +1,232 @@ |
|||||
|
#include "oso.h" |
||||
|
#include <stdint.h> |
||||
|
#include <stdio.h> |
||||
|
#include <stdlib.h> |
||||
|
#include <string.h> |
||||
|
|
||||
|
#if (defined(__GNUC__) || defined(__clang__)) && defined(__has_attribute) |
||||
|
#if __has_attribute(noinline) && __has_attribute(noclone) |
||||
|
#define OSO_NOINLINE __attribute__((noinline, noclone)) |
||||
|
#elif __has_attribute(noinline) |
||||
|
#define OSO_NOINLINE __attribute__((noinline)) |
||||
|
#endif |
||||
|
#elif defined(_MSC_VER) |
||||
|
#define OSO_NOINLINE __declspec(noinline) |
||||
|
#endif |
||||
|
#ifndef OSO_NOINLINE |
||||
|
#define OSO_NOINLINE |
||||
|
#endif |
||||
|
|
||||
|
#define OSO_INTERNAL OSO_NOINLINE static |
||||
|
#define OSO_HDR(s) ((oso_header *)s - 1) |
||||
|
#define OSO_CAP_MAX (SIZE_MAX - (sizeof(oso_header) + 1)) |
||||
|
|
||||
|
typedef struct oso { |
||||
|
size_t len; |
||||
|
size_t cap; |
||||
|
} oso_header; |
||||
|
|
||||
|
OSO_INTERNAL oso *oso_impl_reallochdr(oso_header *hdr, size_t new_cap) { |
||||
|
if (hdr) { |
||||
|
oso_header *new_hdr = realloc(hdr, sizeof(oso_header) + new_cap + 1); |
||||
|
if (!new_hdr) { |
||||
|
free(hdr); |
||||
|
return NULL; |
||||
|
} |
||||
|
new_hdr->cap = new_cap; |
||||
|
return new_hdr + 1; |
||||
|
} |
||||
|
hdr = malloc(sizeof(oso_header) + new_cap + 1); |
||||
|
if (!hdr) |
||||
|
return NULL; |
||||
|
hdr->len = 0; |
||||
|
hdr->cap = new_cap; |
||||
|
((char *)(hdr + 1))[0] = '\0'; |
||||
|
return hdr + 1; |
||||
|
} |
||||
|
OSO_INTERNAL oso *oso_impl_catvprintf(oso *s, char const *fmt, va_list ap) { |
||||
|
size_t old_len; |
||||
|
int required; |
||||
|
va_list cpy; |
||||
|
va_copy(cpy, ap); |
||||
|
required = vsnprintf(NULL, 0, fmt, cpy); |
||||
|
va_end(cpy); |
||||
|
osomakeroomfor(&s, (size_t)required); |
||||
|
if (!s) |
||||
|
return NULL; |
||||
|
old_len = OSO_HDR(s)->len; |
||||
|
vsnprintf((char *)s + old_len, (size_t)required + 1, fmt, ap); |
||||
|
OSO_HDR(s)->len = old_len + (size_t)required; |
||||
|
return s; |
||||
|
} |
||||
|
|
||||
|
OSO_NOINLINE |
||||
|
void osoensurecap(oso **p, size_t new_cap) { |
||||
|
oso *s = *p; |
||||
|
if (new_cap > OSO_CAP_MAX) { |
||||
|
if (s) { |
||||
|
free(OSO_HDR(s)); |
||||
|
*p = NULL; |
||||
|
} |
||||
|
return; |
||||
|
} |
||||
|
oso_header *hdr = NULL; |
||||
|
if (s) { |
||||
|
hdr = OSO_HDR(s); |
||||
|
if (hdr->cap >= new_cap) |
||||
|
return; |
||||
|
} |
||||
|
*p = oso_impl_reallochdr(hdr, new_cap); |
||||
|
} |
||||
|
|
||||
|
OSO_NOINLINE |
||||
|
void osomakeroomfor(oso **p, size_t add_len) { |
||||
|
oso *s = *p; |
||||
|
oso_header *hdr = NULL; |
||||
|
size_t new_cap; |
||||
|
if (s) { |
||||
|
hdr = OSO_HDR(s); |
||||
|
size_t len = hdr->len, cap = hdr->cap; |
||||
|
if (len > OSO_CAP_MAX - add_len) { // overflow, goodnight
|
||||
|
free(hdr); |
||||
|
*p = NULL; |
||||
|
return; |
||||
|
} |
||||
|
new_cap = len + add_len; |
||||
|
if (cap >= new_cap) |
||||
|
return; |
||||
|
} else { |
||||
|
if (add_len > OSO_CAP_MAX) |
||||
|
return; |
||||
|
new_cap = add_len; |
||||
|
} |
||||
|
*p = oso_impl_reallochdr(hdr, new_cap); |
||||
|
} |
||||
|
|
||||
|
void osoput(oso **p, char const *restrict cstr) { |
||||
|
osoputlen(p, cstr, strlen(cstr)); |
||||
|
} |
||||
|
|
||||
|
OSO_NOINLINE |
||||
|
void osoputlen(oso **p, char const *restrict cstr, size_t len) { |
||||
|
oso *s = *p; |
||||
|
osoensurecap(&s, len); |
||||
|
if (s) { |
||||
|
OSO_HDR(s)->len = len; |
||||
|
memcpy((char *)s, cstr, len); |
||||
|
((char *)s)[len] = '\0'; |
||||
|
} |
||||
|
*p = s; |
||||
|
} |
||||
|
void osoputoso(oso **p, oso const *other) { |
||||
|
if (!other) |
||||
|
return; |
||||
|
osoputlen(p, (char const *)other, OSO_HDR(other)->len); |
||||
|
} |
||||
|
void osoputvprintf(oso **p, char const *fmt, va_list ap) { |
||||
|
*p = oso_impl_catvprintf(*p, fmt, ap); |
||||
|
} |
||||
|
void osoputprintf(oso **p, char const *fmt, ...) { |
||||
|
va_list ap; |
||||
|
va_start(ap, fmt); |
||||
|
*p = oso_impl_catvprintf(*p, fmt, ap); |
||||
|
va_end(ap); |
||||
|
} |
||||
|
void osocat(oso **p, char const *cstr) { osocatlen(p, cstr, strlen(cstr)); } |
||||
|
OSO_NOINLINE |
||||
|
void osocatlen(oso **p, char const *cstr, size_t len) { |
||||
|
oso *s = *p; |
||||
|
osomakeroomfor(&s, len); |
||||
|
if (s) { |
||||
|
oso_header *hdr = OSO_HDR(s); |
||||
|
size_t curr_len = hdr->len; |
||||
|
memcpy((char *)s + curr_len, cstr, len); |
||||
|
((char *)s)[curr_len + len] = '\0'; |
||||
|
hdr->len = curr_len + len; |
||||
|
} |
||||
|
*p = s; |
||||
|
} |
||||
|
void osocatoso(oso **p, oso const *other) { |
||||
|
if (!other) |
||||
|
return; |
||||
|
osocatlen(p, (char const *)other, OSO_HDR(other)->len); |
||||
|
} |
||||
|
void osocatvprintf(oso **p, char const *fmt, va_list ap) { |
||||
|
oso *s = *p; |
||||
|
if (s) { |
||||
|
OSO_HDR(s)->len = 0; |
||||
|
((char *)s)[0] = '\0'; |
||||
|
} |
||||
|
*p = oso_impl_catvprintf(s, fmt, ap); |
||||
|
} |
||||
|
void osocatprintf(oso **p, char const *fmt, ...) { |
||||
|
oso *s = *p; |
||||
|
if (s) { |
||||
|
OSO_HDR(s)->len = 0; |
||||
|
((char *)s)[0] = '\0'; |
||||
|
} |
||||
|
va_list ap; |
||||
|
va_start(ap, fmt); |
||||
|
*p = oso_impl_catvprintf(s, fmt, ap); |
||||
|
va_end(ap); |
||||
|
} |
||||
|
void osoclear(oso **p) { |
||||
|
oso *s = *p; |
||||
|
if (!s) |
||||
|
return; |
||||
|
OSO_HDR(s)->len = 0; |
||||
|
((char *)s)[0] = '\0'; |
||||
|
} |
||||
|
void osofree(oso *s) { |
||||
|
if (s) |
||||
|
free(OSO_HDR(s)); |
||||
|
} |
||||
|
void osowipe(oso **p) { |
||||
|
osofree(*p); |
||||
|
*p = NULL; |
||||
|
} |
||||
|
void ososwap(oso const **a, oso const **b) { |
||||
|
oso const *tmp = *a; |
||||
|
*a = *b; |
||||
|
*b = tmp; |
||||
|
} |
||||
|
size_t osolen(oso const *s) { return s ? OSO_HDR(s)->len : 0; } |
||||
|
size_t osocap(oso const *s) { return s ? OSO_HDR(s)->cap : 0; } |
||||
|
void osolencap(oso const *s, size_t *out_len, size_t *out_cap) { |
||||
|
if (!s) { |
||||
|
*out_len = 0; |
||||
|
*out_cap = 0; |
||||
|
return; |
||||
|
} |
||||
|
oso_header *hdr = OSO_HDR(s); |
||||
|
*out_len = hdr->len; |
||||
|
*out_cap = hdr->cap; |
||||
|
} |
||||
|
size_t osoavail(oso const *s) { |
||||
|
if (!s) |
||||
|
return 0; |
||||
|
oso_header *h = OSO_HDR(s); |
||||
|
return h->cap - h->len; |
||||
|
} |
||||
|
|
||||
|
void osotrim(oso *restrict s, char const *restrict cut_set) { |
||||
|
if (!s) |
||||
|
return; |
||||
|
char *str, *start, *end, *start_pos, *end_pos; |
||||
|
start_pos = start = str = (char *)s; |
||||
|
end_pos = end = str + OSO_HDR(s)->len - 1; |
||||
|
while (start_pos <= end && strchr(cut_set, *start_pos)) |
||||
|
start_pos++; |
||||
|
while (end_pos > start_pos && strchr(cut_set, *end_pos)) |
||||
|
end_pos--; |
||||
|
size_t len = (start_pos > end_pos) ? 0 : ((size_t)(end_pos - start_pos) + 1); |
||||
|
OSO_HDR(s)->len = len; |
||||
|
if (str != start_pos) |
||||
|
memmove(str, start_pos, len); |
||||
|
str[len] = '\0'; |
||||
|
} |
||||
|
|
||||
|
#undef OSO_HDR |
||||
|
#undef OSO_NOINLINE |
||||
|
#undef OSO_CAP_MAX |
||||
|
#undef OSO_INTERNAL |
||||
@ -0,0 +1,182 @@ |
|||||
|
#pragma once |
||||
|
// Heap-allocated string handling.
|
||||
|
// Inspired by antirez's sds and gingerBill's gb_string.h.
|
||||
|
//
|
||||
|
// "I need null-terminated strings to interact with libc and/or POSIX, and my
|
||||
|
// software isn't serious enough to warrant using arena or page allocation
|
||||
|
// strategies. Manually fussing with null-terminated strings with libc sucks,
|
||||
|
// even though we're allocating everything individually on the heap! Why can't
|
||||
|
// we at least get a nicer interface for the trade-off we've already made?"
|
||||
|
//
|
||||
|
// EXAMPLE
|
||||
|
// ---------
|
||||
|
// oso *mystring = NULL;
|
||||
|
// osoput(&mystring, "Hello World");
|
||||
|
// printf((char *)mystring);
|
||||
|
// osoput(&mystring, "How about some pancakes?");
|
||||
|
// printf((char *)mystring);
|
||||
|
// osocat(&mstring, " Sure!");
|
||||
|
// printf((char *)mystring);
|
||||
|
// osofree(mystring);
|
||||
|
//
|
||||
|
// > Hello World!
|
||||
|
// > How about some pancakes?
|
||||
|
// > How about some pancakes? Sure!
|
||||
|
//
|
||||
|
// RULES
|
||||
|
// -------
|
||||
|
// 1. `oso *` can always be cast to `char *`, but it's your job to check if
|
||||
|
// it's null before passing it to on something that doesn't tolerate null
|
||||
|
// pointers.
|
||||
|
//
|
||||
|
// 2. The functions defined in this header tolerate null pointers like this:
|
||||
|
//
|
||||
|
// `oso *` -> OK to be null.
|
||||
|
// `char const *` -> Must not be null.
|
||||
|
// `oso **` -> Must not be null, but the `oso *` pointed to
|
||||
|
// can be null. The pointed-to `oso *` may be
|
||||
|
// modified during the call.
|
||||
|
//
|
||||
|
// 3. `oso *` and `char const *` as arguments to the functions here must not
|
||||
|
// overlap in memory. During the call, the buffer pointed to by a `oso *`
|
||||
|
// might need to be reallocated in memory to make room for the `char const
|
||||
|
// *` contents, and if the `char const *` contents end up being moved by
|
||||
|
// that operation, the pointer will no longer be pointing at valid memory.
|
||||
|
// (This also applies to functions which accept two `oso *` as inputs.)
|
||||
|
//
|
||||
|
// Parameters with the type `oso *` are safe to pass as a null pointer. But
|
||||
|
// `oso **` parameters shouldn't be null. The `oso *` pointed to by the `oso
|
||||
|
// **` can be null, though. In other words, you need to do `&mystring` to pass
|
||||
|
// a `oso **` argument.
|
||||
|
//
|
||||
|
// During the function call, if the `oso *` pointed to by the `oso **` needs to
|
||||
|
// become non-null, or if the existing buffer needs to be moved to grow larger,
|
||||
|
// the `oso *` will be set to a new value.
|
||||
|
//
|
||||
|
// oso *mystring = NULL;
|
||||
|
// osolen(mystring); // Gives 0
|
||||
|
// osocat(&mystring, "waffles");
|
||||
|
// osolen(mystring); // Gives 7
|
||||
|
// osofree(mystring);
|
||||
|
//
|
||||
|
// NAMES
|
||||
|
// -------
|
||||
|
// osoput______ -> Copy a string into an oso string.
|
||||
|
// osocat______ -> Append a string onto the end of an oso string.
|
||||
|
// ______len -> Do it with an explicit length argument, so the C-string
|
||||
|
// doesn't have to be '\0'-terminated.
|
||||
|
// ______oso -> Do it with a second oso string.
|
||||
|
// ______printf -> Do it by using printf.
|
||||
|
//
|
||||
|
// ALLOC FAILURE
|
||||
|
// ---------------
|
||||
|
// If an allocation fails (including failing to reallocate) the `oso *` will be
|
||||
|
// set to null. If you decide to handle memory allocation failures, you'll need
|
||||
|
// to check for that.
|
||||
|
//
|
||||
|
// In the oso code, if a reallocation of an existing buffer fails (`realloc()`
|
||||
|
// returns null) then the old, still-valid buffer is immediately freed.
|
||||
|
// Therefore, in an out-of-memory situation, it's possible that you will *lose*
|
||||
|
// your strings without getting a chance to do something with the old buffers.
|
||||
|
//
|
||||
|
// Variations of the oso functions may be added in the future, with a _c suffix
|
||||
|
// or something, which preserve the old buffer and return an error code in the
|
||||
|
// event of a reallocation failure. I'm not sure how important this is, since
|
||||
|
// most existing libc-based software doesn't handle out-of-memory conditions
|
||||
|
// for small strings without imploding.
|
||||
|
//
|
||||
|
// (sds, for example, will lose your string *and* leak the old buffer if a
|
||||
|
// reallocation fails.)
|
||||
|
|
||||
|
#include <stdarg.h> |
||||
|
#include <stddef.h> |
||||
|
|
||||
|
#if (defined(__GNUC__) || defined(__clang__)) && defined(__has_attribute) |
||||
|
#if __has_attribute(format) |
||||
|
#define OSO_PRINTF(...) __attribute__((format(printf, __VA_ARGS__))) |
||||
|
#endif |
||||
|
#if __has_attribute(nonnull) |
||||
|
#define OSO_NONNULL(...) __attribute__((nonnull(__VA_ARGS__))) |
||||
|
#endif |
||||
|
#endif |
||||
|
#ifndef OSO_PRINTF |
||||
|
#define OSO_PRINTF(...) |
||||
|
#endif |
||||
|
#ifndef OSO_NONNULL |
||||
|
#define OSO_NONNULL(...) |
||||
|
#endif |
||||
|
|
||||
|
typedef struct oso oso; |
||||
|
|
||||
|
#define osoc(s) ((char const *)s) |
||||
|
|
||||
|
void osoput(oso **p, char const *cstr) OSO_NONNULL(); |
||||
|
// ^- Copies the '\0'-terminated string into the `oso *` string located at
|
||||
|
// `*p`. If `*p` is null or there isn't enough capacity to hold `cstr`, it
|
||||
|
// will be reallocated. The pointer value at `*p` will be updated if
|
||||
|
// necessary. `*p` and `cstr` must not point to overlapping memory.
|
||||
|
void osoputlen(oso **p, char const *cstr, size_t len) OSO_NONNULL(); |
||||
|
// ^- Same as above, but uses an additional parameter that specifies the length
|
||||
|
// of `cstr, and `cstr` does not have to be '\0'-terminated.
|
||||
|
// `*p` and `cstr` must not point to overlapping memory.
|
||||
|
void osoputoso(oso **p, oso const *other) OSO_NONNULL(1); |
||||
|
// ^- Same as above, but using another `oso`. `*p` and `other` must not point
|
||||
|
// to overlapping memory.
|
||||
|
void osoputvprintf(oso **p, char const *fmt, va_list ap) OSO_NONNULL(1, 2) |
||||
|
OSO_PRINTF(2, 0); |
||||
|
void osoputprintf(oso **p, char const *fmt, ...) OSO_NONNULL(1, 2) |
||||
|
OSO_PRINTF(2, 3); |
||||
|
// ^- Same as above, but do it by using printf.
|
||||
|
|
||||
|
void osocat(oso **p, char const *cstr) OSO_NONNULL(); |
||||
|
void osocatlen(oso **p, char const *cstr, size_t len) OSO_NONNULL(); |
||||
|
void osocatoso(oso **p, oso const *other) OSO_NONNULL(1); |
||||
|
void osocatvprintf(oso **p, char const *fmt, va_list ap) OSO_NONNULL(1, 2) |
||||
|
OSO_PRINTF(2, 0); |
||||
|
void osocatprintf(oso **p, char const *fmt, ...) OSO_NONNULL(1, 2) |
||||
|
OSO_PRINTF(2, 3); |
||||
|
// ^- Append string to oso string. Same rules as `osoput` family.
|
||||
|
|
||||
|
void osoensurecap(oso **p, size_t cap) OSO_NONNULL(); |
||||
|
// ^- Ensure that s has at least `cap` memory allocated for it. This does not
|
||||
|
// care about the strlen of the characters or the prefixed length count --
|
||||
|
// only the backing memory allocation.
|
||||
|
void osomakeroomfor(oso **p, size_t len) OSO_NONNULL(); |
||||
|
// ^- Ensure that s has enough allocated space after the '\0'-terminnation
|
||||
|
// character to hold an additional add_len characters. It does not adjust
|
||||
|
// the `length` number value, only the capacity, if necessary.
|
||||
|
//
|
||||
|
// Both `osoensurecap()` and `osomakeroomfor()` can be used to avoid making
|
||||
|
// multiple smaller reallactions as the string grows in the future. You can
|
||||
|
// also use them if you're going to modify the string buffer manually in
|
||||
|
// your own code, and need to create some space in the buffer.
|
||||
|
|
||||
|
void osoclear(oso **p) OSO_NONNULL(); |
||||
|
// ^- Set len to 0, write '\0' at pos 0. Leaves allocated memory in place.
|
||||
|
void osofree(oso *s); |
||||
|
// ^- You know. And calling with null is allowed.
|
||||
|
void osowipe(oso **p) OSO_NONNULL(); |
||||
|
// ^- It's like `osofree()`, except you give it a ptr-to-ptr, and it also sets
|
||||
|
// `*p` to null for you when it's done freeing the memory.
|
||||
|
void ososwap(oso const **a, oso const **b) OSO_NONNULL(); |
||||
|
// ^- Swaps the two pointers. Yeah, that's all it does. Why? Because it's
|
||||
|
// common when dealing memory management for individually allocated strings
|
||||
|
// and changing between old and new string values.
|
||||
|
void osopokelen(oso *s, size_t len) OSO_NONNULL(); |
||||
|
// ^- Manually updates length field. Doesn't do anything else for you.
|
||||
|
|
||||
|
size_t osolen(oso const *s); |
||||
|
// ^- Bytes in use by the string (not including the '\0' character.)
|
||||
|
size_t osocap(oso const *s); |
||||
|
// ^- Bytes allocated on heap (not including the '\0' terminator.)
|
||||
|
void osolencap(oso const *s, size_t *out_len, size_t *out_cap) |
||||
|
OSO_NONNULL(2, 3); |
||||
|
// ^- Get both the len and the cap in one call.
|
||||
|
size_t osoavail(oso const *s); |
||||
|
// ^- osocap(s) - osolen(s)
|
||||
|
|
||||
|
void osotrim(oso *restrict s, char const *restrict cut_set) OSO_NONNULL(2); |
||||
|
// ^- Remove the characters in `cut_set` from the beginning and ending of `s`.
|
||||
|
|
||||
|
#undef OSO_PRINTF |
||||
|
#undef OSO_NONNULL |
||||
@ -1,198 +0,0 @@ |
|||||
// Derived from gingerBill's public domain gb_string.h file.
|
|
||||
#include "sdd.h" |
|
||||
#include <stdint.h> |
|
||||
#include <stdio.h> |
|
||||
#include <stdlib.h> |
|
||||
#include <string.h> |
|
||||
|
|
||||
#if (defined(__GNUC__) || defined(__clang__)) && defined(__has_attribute) |
|
||||
#if __has_attribute(noinline) && __has_attribute(noclone) |
|
||||
#define SDD_NOINLINE __attribute__((noinline, noclone)) |
|
||||
#elif __has_attribute(noinline) |
|
||||
#define SDD_NOINLINE __attribute__((noinline)) |
|
||||
#endif |
|
||||
#elif defined(_MSC_VER) |
|
||||
#define SDD_NOINLINE __declspec(noinline) |
|
||||
#endif |
|
||||
#ifndef SDD_NOINLINE |
|
||||
#define SDD_NOINLINE |
|
||||
#endif |
|
||||
|
|
||||
#define SDD_INTERNAL SDD_NOINLINE static |
|
||||
#define SDD_HDR(s) ((sdd_header *)s - 1) |
|
||||
#define SDD_CAP_MAX (SIZE_MAX - (sizeof(sdd_header) + 1)) |
|
||||
|
|
||||
typedef struct sdd { |
|
||||
size_t len; |
|
||||
size_t cap; |
|
||||
} sdd_header; |
|
||||
|
|
||||
SDD_INTERNAL sdd *sdd_impl_new(char const *init, size_t len, size_t cap) { |
|
||||
if (cap > SDD_CAP_MAX) |
|
||||
return NULL; |
|
||||
sdd_header *header = (sdd *)malloc(sizeof(sdd) + cap + 1); |
|
||||
if (!header) |
|
||||
return NULL; |
|
||||
header->len = len; |
|
||||
header->cap = cap; |
|
||||
char *str = (char *)(header + 1); |
|
||||
if (init) |
|
||||
memcpy(str, init, len); |
|
||||
str[len] = '\0'; |
|
||||
return (sdd *)str; |
|
||||
} |
|
||||
SDD_INTERNAL sdd *sdd_impl_reallochdr(sdd_header *hdr, size_t new_cap) { |
|
||||
sdd_header *new_hdr = realloc(hdr, sizeof(sdd_header) + new_cap + 1); |
|
||||
if (!new_hdr) { |
|
||||
free(hdr); |
|
||||
return NULL; |
|
||||
} |
|
||||
new_hdr->cap = new_cap; |
|
||||
return new_hdr + 1; |
|
||||
} |
|
||||
SDD_INTERNAL sdd *sdd_impl_catvprintf(sdd *s, char const *fmt, va_list ap) { |
|
||||
size_t old_len; |
|
||||
int required; |
|
||||
va_list cpy; |
|
||||
va_copy(cpy, ap); |
|
||||
required = vsnprintf(NULL, 0, fmt, cpy); |
|
||||
va_end(cpy); |
|
||||
if (s) { |
|
||||
old_len = SDD_HDR(s)->len; |
|
||||
s = sdd_makeroomfor(s, (size_t)required); |
|
||||
} else { |
|
||||
old_len = 0; |
|
||||
s = sdd_newcap((size_t)required); |
|
||||
} |
|
||||
if (!s) |
|
||||
return NULL; |
|
||||
vsnprintf((char *)s + old_len, (size_t)required + 1, fmt, ap); |
|
||||
SDD_HDR(s)->len = old_len + (size_t)required; |
|
||||
return s; |
|
||||
} |
|
||||
|
|
||||
sdd *sdd_new(char const *str) { |
|
||||
size_t len = strlen(str); |
|
||||
return sdd_impl_new(str, len, len); |
|
||||
} |
|
||||
sdd *sdd_newlen(char const *init, size_t len) { |
|
||||
return sdd_impl_new(init, len, len); |
|
||||
} |
|
||||
sdd *sdd_newcap(size_t cap) { return sdd_impl_new(NULL, 0, cap); } |
|
||||
sdd *sdd_dup(sdd const *str) { |
|
||||
size_t len = SDD_HDR(str)->len; |
|
||||
return sdd_impl_new((char const *)str, len, len); |
|
||||
} |
|
||||
sdd *sdd_newvprintf(char const *fmt, va_list ap) { |
|
||||
return sdd_impl_catvprintf(NULL, fmt, ap); |
|
||||
} |
|
||||
sdd *sdd_newprintf(char const *fmt, ...) { |
|
||||
sdd *s; |
|
||||
va_list ap; |
|
||||
va_start(ap, fmt); |
|
||||
s = sdd_impl_catvprintf(NULL, fmt, ap); |
|
||||
va_end(ap); |
|
||||
return s; |
|
||||
} |
|
||||
void sdd_free(sdd *s) { |
|
||||
if (!s) |
|
||||
return; |
|
||||
free(s - 1); |
|
||||
} |
|
||||
sdd *sdd_cpy(sdd *restrict s, char const *restrict cstr) { |
|
||||
return sdd_cpylen(s, cstr, strlen(cstr)); |
|
||||
} |
|
||||
SDD_NOINLINE |
|
||||
sdd *sdd_cpylen(sdd *restrict s, char const *restrict cstr, size_t len) { |
|
||||
s = sdd_ensurecap(s, len); |
|
||||
if (!s) |
|
||||
return NULL; |
|
||||
SDD_HDR(s)->len = len; |
|
||||
memcpy(s, cstr, len); |
|
||||
((char *)s)[len] = '\0'; |
|
||||
return s; |
|
||||
} |
|
||||
sdd *sdd_cpysdd(sdd *restrict s, sdd const *restrict other) { |
|
||||
return sdd_cpylen(s, (char const *)other, SDD_HDR(other)->len); |
|
||||
} |
|
||||
sdd *sdd_cat(sdd *restrict s, char const *restrict other) { |
|
||||
return sdd_catlen(s, other, strlen(other)); |
|
||||
} |
|
||||
SDD_NOINLINE |
|
||||
sdd *sdd_catlen(sdd *restrict s, char const *restrict other, size_t other_len) { |
|
||||
size_t curr_len = SDD_HDR(s)->len; |
|
||||
s = sdd_makeroomfor(s, other_len); |
|
||||
if (!s) |
|
||||
return NULL; |
|
||||
memcpy((char *)s + curr_len, other, other_len); |
|
||||
((char *)s)[curr_len + other_len] = '\0'; |
|
||||
SDD_HDR(s)->len = curr_len + other_len; |
|
||||
return s; |
|
||||
} |
|
||||
sdd *sdd_catsdd(sdd *restrict s, sdd const *restrict other) { |
|
||||
return sdd_catlen(s, (char const *)other, SDD_HDR(other)->len); |
|
||||
} |
|
||||
sdd *sdd_catvprintf(sdd *restrict s, char const *fmt, va_list ap) { |
|
||||
return sdd_impl_catvprintf(s, fmt, ap); |
|
||||
} |
|
||||
sdd *sdd_catprintf(sdd *restrict s, char const *fmt, ...) { |
|
||||
va_list ap; |
|
||||
va_start(ap, fmt); |
|
||||
s = sdd_impl_catvprintf(s, fmt, ap); |
|
||||
va_end(ap); |
|
||||
return s; |
|
||||
} |
|
||||
SDD_NOINLINE |
|
||||
sdd *sdd_ensurecap(sdd *s, size_t new_cap) { |
|
||||
sdd_header *hdr = SDD_HDR(s); |
|
||||
if (new_cap > SDD_CAP_MAX) { |
|
||||
free(hdr); |
|
||||
return NULL; |
|
||||
} |
|
||||
if (hdr->cap >= new_cap) |
|
||||
return s; |
|
||||
return sdd_impl_reallochdr(hdr, new_cap); |
|
||||
} |
|
||||
SDD_NOINLINE |
|
||||
sdd *sdd_makeroomfor(sdd *s, size_t add_len) { |
|
||||
sdd_header *hdr = SDD_HDR(s); |
|
||||
size_t len = hdr->len, cap = hdr->cap; |
|
||||
if (len > SDD_CAP_MAX - add_len) { // overflow, goodnight
|
|
||||
free(hdr); |
|
||||
return NULL; |
|
||||
} |
|
||||
size_t new_cap = len + add_len; |
|
||||
if (cap >= new_cap) |
|
||||
return s; |
|
||||
return sdd_impl_reallochdr(hdr, new_cap); |
|
||||
} |
|
||||
size_t sdd_len(sdd const *s) { return SDD_HDR(s)->len; } |
|
||||
size_t sdd_cap(sdd const *s) { return SDD_HDR(s)->cap; } |
|
||||
size_t sdd_avail(sdd const *s) { |
|
||||
sdd_header *h = SDD_HDR(s); |
|
||||
return h->cap - h->len; |
|
||||
} |
|
||||
void sdd_clear(sdd *s) { |
|
||||
SDD_HDR(s)->len = 0; |
|
||||
((char *)s)[0] = '\0'; |
|
||||
} |
|
||||
void sdd_pokelen(sdd *s, size_t len) { SDD_HDR(s)->len = len; } |
|
||||
void sdd_trim(sdd *restrict s, char const *restrict cut_set) { |
|
||||
char *str, *start, *end, *start_pos, *end_pos; |
|
||||
start_pos = start = str = (char *)s; |
|
||||
end_pos = end = str + SDD_HDR(s)->len - 1; |
|
||||
while (start_pos <= end && strchr(cut_set, *start_pos)) |
|
||||
start_pos++; |
|
||||
while (end_pos > start_pos && strchr(cut_set, *end_pos)) |
|
||||
end_pos--; |
|
||||
size_t len = (start_pos > end_pos) ? 0 : ((size_t)(end_pos - start_pos) + 1); |
|
||||
SDD_HDR(s)->len = len; |
|
||||
if (str != start_pos) |
|
||||
memmove(str, start_pos, len); |
|
||||
str[len] = '\0'; |
|
||||
} |
|
||||
|
|
||||
#undef SDD_HDR |
|
||||
#undef SDD_NOINLINE |
|
||||
#undef SDD_CAP_MAX |
|
||||
#undef SDD_INTERNAL |
|
||||
@ -1,104 +0,0 @@ |
|||||
// Strings, Dynamic, Dumb
|
|
||||
#pragma once |
|
||||
#include <stdarg.h> |
|
||||
#include <stddef.h> |
|
||||
|
|
||||
#if (defined(__GNUC__) || defined(__clang__)) && defined(__has_attribute) |
|
||||
#if __has_attribute(format) |
|
||||
#define SDD_PRINTF(n1, n2) __attribute__((format(printf, n1, n2))) |
|
||||
#endif |
|
||||
#if __has_attribute(nonnull) |
|
||||
#define SDD_NONNULL(...) __attribute__((nonnull __VA_ARGS__)) |
|
||||
#endif |
|
||||
#if __has_attribute(malloc) && __has_attribute(warn_unused_result) |
|
||||
#define SDD_ALLOC __attribute__((malloc, warn_unused_result)) |
|
||||
#elif __has_attribute(warn_unused_result) |
|
||||
#define SDD_ALLOC __attribute__((warn_unused_result)) |
|
||||
#endif |
|
||||
#if __has_attribute(warn_unused_result) |
|
||||
#define SDD_USED __attribute__((warn_unused_result)) |
|
||||
#endif |
|
||||
#endif |
|
||||
#ifndef SDD_PRINTF |
|
||||
#define SDD_PRINTF(n1, n2) |
|
||||
#endif |
|
||||
#ifndef SDD_NONNULL |
|
||||
#define SDD_NONNULL(...) |
|
||||
#endif |
|
||||
#ifndef SDD_ALLOC |
|
||||
#define SDD_ALLOC |
|
||||
#endif |
|
||||
#ifndef SDD_USED |
|
||||
#define SDD_USED |
|
||||
#endif |
|
||||
|
|
||||
typedef struct sdd sdd; |
|
||||
|
|
||||
#define sddc(s) ((char *)s) |
|
||||
#define sddcc(s) ((char const *)s) |
|
||||
|
|
||||
sdd *sdd_new(char const *s) SDD_NONNULL() SDD_ALLOC; |
|
||||
// ^- Create new with copy of '\0'-terminated cstring.
|
|
||||
sdd *sdd_newlen(char const *s, size_t len) SDD_NONNULL() SDD_ALLOC; |
|
||||
// ^- Same, but without calling strlen().
|
|
||||
// Resulting new string will be '\0'-terminated.
|
|
||||
sdd *sdd_newcap(size_t cap) SDD_ALLOC; |
|
||||
// ^- 'Raw' new with a specific capacity.
|
|
||||
// Length will be set to 0, and '\0' written at position 0.
|
|
||||
sdd *sdd_dup(sdd const *s) SDD_ALLOC; |
|
||||
// ^- Same as sdd_newlen(str, sdd_len(str))
|
|
||||
sdd *sdd_newvprintf(char const *fmt, va_list ap) SDD_ALLOC; |
|
||||
sdd *sdd_newprintf(char const *fmt, ...) SDD_PRINTF(1, 2) SDD_ALLOC; |
|
||||
// ^- Create new by using printf
|
|
||||
void sdd_free(sdd *s); |
|
||||
// ^- Calling with null is allowed.
|
|
||||
|
|
||||
sdd *sdd_cpy(sdd *restrict s, char const *restrict cstr) SDD_NONNULL() SDD_USED; |
|
||||
// ^- Set `s` to contain the contents of `cstr`. This is really more like
|
|
||||
// "change into" rather than "copy".
|
|
||||
sdd *sdd_cpylen(sdd *restrict s, char const *restrict cstr, size_t len) |
|
||||
SDD_NONNULL() SDD_USED; |
|
||||
sdd *sdd_cpysdd(sdd *restrict s, sdd const *restrict other); |
|
||||
|
|
||||
sdd *sdd_cat(sdd *restrict s, char const *restrict other) |
|
||||
SDD_NONNULL() SDD_USED; |
|
||||
// ^- Appends contents. The two strings must not overlap in memory.
|
|
||||
sdd *sdd_catlen(sdd *restrict s, char const *restrict other, size_t len) |
|
||||
SDD_NONNULL() SDD_USED; |
|
||||
sdd *sdd_catsdd(sdd *restrict s, sdd const *restrict other) |
|
||||
SDD_NONNULL() SDD_USED; |
|
||||
sdd *sdd_catvprintf(sdd *restrict s, char const *fmt, va_list ap) |
|
||||
SDD_NONNULL((1, 2)) SDD_USED; |
|
||||
sdd *sdd_catprintf(sdd *restrict s, char const *fmt, ...) SDD_NONNULL((1, 2)) |
|
||||
SDD_PRINTF(2, 3) SDD_USED; |
|
||||
// ^- Appends by using printf.
|
|
||||
|
|
||||
size_t sdd_len(sdd const *s) SDD_NONNULL(); |
|
||||
// ^- Bytes used by string (excluding '\0' terminator)
|
|
||||
size_t sdd_cap(sdd const *s) SDD_NONNULL(); |
|
||||
// ^- Bytes allocated on heap (excluding '\0' terminator)
|
|
||||
size_t sdd_avail(sdd const *s) SDD_NONNULL(); |
|
||||
// ^- sdd_cap(s) - sdd_len(s)
|
|
||||
|
|
||||
void sdd_clear(sdd *s) SDD_NONNULL(); |
|
||||
// ^- Set len to 0, write '\0' at pos 0. Leaves allocated memory in place.
|
|
||||
void sdd_pokelen(sdd *s, size_t len) SDD_NONNULL(); |
|
||||
// ^- Manually update length field. Doesn't do anything else for you.
|
|
||||
|
|
||||
void sdd_trim(sdd *restrict s, char const *cut_set) SDD_NONNULL(); |
|
||||
// ^- Remove the characters in cut_set from the beginning and ending of s.
|
|
||||
sdd *sdd_ensurecap(sdd *s, size_t cap) SDD_NONNULL() SDD_USED; |
|
||||
// ^- Ensure that s has at least cap memory allocated for it. This does not
|
|
||||
// care about the strlen of the characters or the prefixed length count --
|
|
||||
// only the backing memory allocation.
|
|
||||
sdd *sdd_makeroomfor(sdd *s, size_t add_len) SDD_NONNULL() SDD_USED; |
|
||||
// ^- Ensure that s has enough allocated space after the valid,
|
|
||||
// null-terminated characters to hold an additional add_len characters. It
|
|
||||
// does not adjust the length, only the capacity, if necessary. Soon after
|
|
||||
// you call sdd_makeroomfor(), you probably will want to call sdd_pokelen(),
|
|
||||
// otherwise you're probably using it incorrectly.
|
|
||||
|
|
||||
#undef SDD_PRINTF |
|
||||
#undef SDD_NONNULL |
|
||||
#undef SDD_ALLOC |
|
||||
#undef SDD_USED |
|
||||
Loading…
Reference in new issue