strb.h

Go to the documentation of this file.

// Copyright 2024 Christopher Bazley
// SPDX-License-Identifier: MIT
#ifndef STRB_H
#define STRB_H
 
#include <inttypes.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#ifndef STRB_EXT_STATE
#define STRB_EXT_STATE 1
#endif
 
#ifndef STRB_UNPUTC
#define STRB_UNPUTC 1
#endif
 
#ifndef STRB_RESTORE
#define STRB_RESTORE 1
#endif
 
#ifndef STRB_REUSE_CONST
#define STRB_REUSE_CONST 1
#endif
 
#if defined(_MSC_VER) ||                                                       \
    (defined(__STDC_VERSION__) && __STDC_VERSION__ < 199901L)
#define STRB_SIZE_HINT(X)
#else
#define STRB_SIZE_HINT(X) static restrict X
#endif
 
#if STRB_FREESTANDING
// No static or dynamic allocation
#define STRB_MAX SIZE_MAX
typedef uint8_t strbsize_t;
#define PRIstrbsize PRIu8
 
#define STRB_MAX_SIZE UINT8_MAX
 
#elif STRB_STATIC_ALLOC
// About 2KB of static storage
#define STRB_MAX (8) // must not exceed 8
 
typedef uint8_t strbsize_t;
 
#define PRIstrbsize PRIu8
 
#define STRB_MAX_SIZE (256 - 8)
 
#else
// Unlimited dynamic allocation
#define STRB_MAX SIZE_MAX
 
typedef uint16_t strbsize_t;
 
#define PRIstrbsize PRIu16
 
#define STRB_MAX_SIZE UINT16_MAX
 
#define STRB_DFL_SIZE (256)
 
#define STRB_MAX_INTERNAL_SIZE (256)
 
#define STRB_GROW_FACTOR (2)
 
#endif
 
/* A type qualifier named _Optional has been used throughout this interface to
 * clarify declarations. This qualifier was proposed by N3089, which was
 * reviewed by the committee at the Strasbourg meeting in January 2024 with
 * strong consensus to proceed. It can be ignored (here, by defining it as an
 * empty macro) without substantially changing the meaning of the code.
 */
#ifdef USE_OPTIONAL
 
#if !STRB_FREESTANDING
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
 
static inline void optional_free(_Optional void *x)
{
    free((void *)x);
}
#undef free
#define free(x) optional_free(x)
 
static inline _Optional void *optional_malloc(size_t n)
{
    return malloc(n);
}
#undef malloc
#define malloc(n) optional_malloc(n)
 
static inline _Optional void *optional_realloc(_Optional void *p, size_t n)
{
    return realloc((void *)p, n);
}
#undef realloc
#define realloc(p, n) optional_realloc(p, n)
 
static inline int optional_vsnprintf(_Optional char *buffer, size_t sz,
                                     const char *format, va_list vlist)
{
    return vsnprintf((char *)buffer, sz, format, vlist);
}
#undef vsnprintf
#define vsnprintf(buffer, sz, format, vlist)                                   \
    optional_vsnprintf(buffer, sz, format, vlist)
#endif // !STRB_FREESTANDING
 
#undef NULL
#define NULL ((_Optional void *)0)
 
#else
#define _Optional
#endif
 
typedef struct strb_t strb_t;
 
typedef struct {
#if STRB_UNPUTC
    char unputc_char;
#endif
#if STRB_RESTORE
    char restore_char;
#endif
    char flags;
    strbsize_t len, size, pos;
    char *buf;
} strbprivate_t;
 
#if STRB_EXT_STATE
 
typedef struct {
    strbprivate_t p;
} strbstate_t;
 
strb_t *strb_use(strbstate_t *restrict sbs, size_t size,
                 char buf[STRB_SIZE_HINT(size)]);
 
_Optional strb_t *strb_reuse(strbstate_t *restrict sbs, size_t size,
                             char buf[STRB_SIZE_HINT(size)]);
 
#if STRB_REUSE_CONST
_Optional const strb_t *strb_reuse_const(strbstate_t *restrict sbs,
                                         const char buf[STRB_SIZE_HINT(1)]);
#endif
 
#elif !STRB_FREESTANDING
 
_Optional strb_t *strb_use(size_t size, char buf[STRB_SIZE_HINT(size)]);
 
_Optional strb_t *strb_reuse(size_t size, char buf[STRB_SIZE_HINT(size)]);
 
#endif
 
#if !STRB_FREESTANDING
_Optional strb_t *strb_alloc(size_t n);
 
_Optional strb_t *strb_dup(const char *str);
 
_Optional strb_t *strb_ndup(const char *str, size_t n);
 
_Optional strb_t *strb_aprintf(const char *restrict format, ...);
 
_Optional strb_t *strb_vaprintf(const char *restrict format, va_list args);
 
void strb_free(_Optional strb_t *sb);
#endif
 
char *strb_ptr(strb_t *sb);
 
const char *strb_cptr(strb_t const *sb);
 
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
#define strb_ptr(sb)                                                           \
    _Generic(sb, strb_t *: strb_ptr, const strb_t *: strb_cptr)(sb)
#endif
 
size_t strb_len(strb_t const *sb);
 
enum {
    strb_insert,
    strb_overwrite
};
 
int strb_setmode(strb_t *sb, int mode);
 
int strb_getmode(const strb_t *sb);
 
int strb_seek(strb_t *sb, size_t pos);
 
size_t strb_tell(strb_t const *sb);
 
int strb_putc(strb_t *sb, int c);
 
int strb_nputc(strb_t *sb, int c, size_t n);
 
#if STRB_UNPUTC
int strb_unputc(strb_t *sb);
#endif
 
int strb_puts(strb_t *restrict sb, const char *restrict str);
 
int strb_nputs(strb_t *restrict sb, const char *restrict str, size_t n);
 
#if !STRB_FREESTANDING
int strb_vputf(strb_t *restrict sb, const char *restrict format, va_list args);
 
int strb_putf(strb_t *restrict sb, const char *restrict format, ...);
#endif
 
_Optional char *strb_write(strb_t *sb, size_t n);
 
void strb_split(strb_t *sb);
 
void strb_restore(strb_t *sb);
 
#define strb_wrote(sb) strb_restore(sb)
 
void strb_delto(strb_t *sb, size_t pos);
 
int strb_cpy(strb_t *restrict sb, const char *restrict str);
 
int strb_ncpy(strb_t *restrict sb, const char *restrict str, size_t n);
 
#if !STRB_FREESTANDING
 
int strb_vprintf(strb_t *restrict sb, const char *restrict format,
                 va_list args);
 
int strb_printf(strb_t *restrict sb, const char *restrict format, ...);
#endif
 
bool strb_error(strb_t const *sb);
 
void strb_clearerr(strb_t *sb);
 
#endif // STRB_H