Provided by: libustr-dev_1.0.4-2_amd64 bug

NAME

       ustr - ustr string library functions

SYNOPSIS

  #include "ustr.h"

  struct Ustr *USTR(void *);
  struct Ustrp *USTRP(void *);
  struct Ustr *USTR1(symbol, const char[]);
  struct Ustr *USTR2(symbol, symbol, const char[]);
  struct Ustr *USTR4(symbol, symbol, symbol, symbol, const char[]);
  struct Ustr *USTR1_CHK(symbol, const char[]);
  struct Ustr *USTR2_CHK(symbol, symbol, const char[]);
  struct Ustr *USTR4_CHK(symbol, symbol, symbol, symbol, const char[]);
  struct Ustr *USTRP1(symbol, const char[]);
  struct Ustr *USTRP2(symbol, symbol, const char[]);
  struct Ustrp *USTRP4(symbol, symbol, symbol, symbol, const char[]);
  struct Ustr *USTRP1_CHK(symbol, const char[]);
  struct Ustr *USTRP2_CHK(symbol, symbol, const char[]);
  struct Ustrp *USTRP4_CHK(symbol, symbol, symbol, symbol, const char[]);

  size_t USTR_SIZE_FIXED(size_t);
  struct Ustr *ustr_init_fixed(void *, size_t, int, size_t);
  struct Ustr *USTR_SC_INIT_AUTO(char[], int, size_t);
  struct Ustr *USTR_SC_INIT_AUTO_OSTR(char[], int, size_t);

  int ustr_assert_valid(Ustr *);
  int ustr_assert_valid_subustr(Ustr *, size_t,  size_t);
  int USTR_CNTL_MALLOC_CHECK_BEG(int);
  int USTR_CNTL_MALLOC_CHECK_LVL(void);
  int USTR_CNTL_MALLOC_CHECK_MEM(void *);
  int USTR_CNTL_MALLOC_CHECK_MEM_SZ(void *, size_t);
  int USTR_CNTL_MALLOC_CHECK_MEM_MINSZ(void *, size_t);
  int USTR_CNTL_MALLOC_CHECK_MEM_USTR(Ustr *);
  int USTR_CNTL_MALLOC_CHECK_MEM_USTRP(Ustrp *);
  int USTR_CNTL_MALLOC_CHECK_END(void);
  int USTR_CNTL_MALLOC_CHECK_ADD(int);
  int USTR_CNTL_MALLOC_CHECK_DEL(int);

  size_t  ustr_init_size(size_t, size_t, int, size_t);
  struct Ustr *ustr_init_alloc(void *, size_t, size_t, size_t, int, int, size_t);
  struct Ustr *ustr_dupx_empty(size_t, size_t, int, int);
  struct Ustr *ustr_dup_empty(void);
  struct Ustr *ustr_dupx_undef(size_t, size_t, int, int, size_t);
  struct Ustr *ustr_dup_undef(size_t);
  struct Ustr *ustr_dup(const struct Ustr *);
  struct Ustr *ustr_dupx(size_t, size_t, int, int, const struct Ustr *);
  struct Ustr *ustr_sc_dup(struct Ustr **);
  struct Ustr *ustr_sc_dupx(size_t, size_t, int, int, struct Ustr **);
  struct Ustr *ustr_dup_buf(const void *, size_t);
  struct Ustr *ustr_dupx_buf(size_t, size_t, int, int, const void *, size_t);
  struct Ustr *ustr_dup_cstr(const char *);
  struct Ustr *ustr_dupx_cstr(size_t, size_t, int, int, const char *);
  struct Ustr *USTR_DUP_OSTR(const char []);
  struct Ustr *USTR_DUP_OBJ(...);
  struct Ustr *ustr_dup_subustr(const struct Ustr *, size_t, size_t);
  struct Ustr *ustr_dupx_subustr(size_t, size_t, int, int, const struct Ustr *, size_t, size_t);
  struct Ustr *ustr_dup_rep_chr(char, size_t);
  struct Ustr *ustr_dupx_rep_chr(size_t, size_t, int, int, char, size_t);
  struct  Ustr  *ustr_sc_vjoin(const  struct  Ustr  *,  const struct Ustr *, const struct Ustr *,
                             va_list);
  struct Ustr *ustr_sc_join(const struct Ustr *, const struct Ustr *, const struct Ustr *, ...);
  struct Ustr *ustr_sc_vjoinx(size_t, size_t, int, int, const struct Ustr *, const struct Ustr *,
                              const struct Ustr *, va_list);
  struct  Ustr *ustr_sc_joinx(size_t, size_t, int, int, const struct Ustr *, const struct Ustr *,
                             const struct Ustr *, ...);
  struct Ustr *ustr_sc_vconcat(const struct Ustr *, va_list);
  struct Ustr *ustr_sc_concat(const struct Ustr *, ...);
  struct Ustr *ustr_sc_vconcatx(size_t, size_t, int, int, const struct Ustr *, va_list);
  struct Ustr *ustr_sc_concatx(size_t, size_t, int, int, const struct Ustr *, ...);

  void  ustr_free(struct Ustr *);
  void  ustrp_free(struct Ustr_pool *, struct Ustrp *);
  void  ustr_sc_free(struct Ustr **);
  void  ustr_sc_free2(struct Ustr **, struct Ustr *);
  void  ustr_sc_free_shared(struct Ustr **);
  int  ustr_del(struct Ustr **, size_t);
  int  ustr_del_subustr(struct Ustr **, size_t,  size_t);
  void  ustr_sc_del(struct Ustr **);

  int ustr_add_undef(struct Ustr **, size_t);
  int ustr_add_buf(struct Ustr **, const void *, size_t);
  int  ustr_add_cstr(struct Ustr **, const char *);
  int  USTR_ADD_OSTR(struct Ustr **, const char []);
  int  USTR_ADD_OBJ(struct Ustr **, ...);
  int  ustr_add(struct Ustr **, const struct Ustr *);
  int  ustr_add_subustr(struct Ustr **, const struct Ustr *, size_t, size_t);
  int  ustr_add_rep_chr(struct Ustr **, char, size_t);

  int  ustr_set_undef(struct Ustr **,  size_t);
  int ustr_set_empty(struct Ustr **);
  int ustr_set_buf(struct Ustr **,  const void *, size_t);
  int ustr_set_cstr(struct Ustr **, const char *);
  int USTR_SET_OSTR(struct Ustr **, const char []);
  int USTR_SET_OBJ(struct Ustr **, ...);
  int ustr_set(struct Ustr **, const struct Ustr *);
  int ustr_set_subustr(struct Ustr **, const struct Ustr *, size_t, size_t);
  int ustr_set_rep_chr(struct Ustr **, char, size_t);

  int ustr_ins_undef(struct Ustr **, size_t, size_t);
  int ustr_ins_buf(struct Ustr **, size_t, const void *, size_t);
  int  ustr_ins_cstr(struct Ustr **, size_t, const char *);
  int  USTR_INS_OSTR(struct Ustr **, size_t, const char []);
  int  USTR_INS_OBJ(struct Ustr **, size_t, ...);
  int  ustr_ins(struct Ustr **, size_t, const struct Ustr *);
  int  ustr_ins_subustr(struct Ustr **, size_t, const struct Ustr *, size_t, size_t);
  int  ustr_ins_rep_chr(struct Ustr **, size_t, char, size_t);

  int  ustr_add_vfmt_lim(struct Ustr **, size_t, const char *, va_list);
  int  ustr_add_vfmt(struct Ustr **, const char *, va_list);
  int  ustr_add_fmt_lim(struct Ustr **, size_t, const char *, ...);
  int  ustr_add_fmt(struct Ustr **, const char *, ...);
  struct Ustr *ustr_dup_vfmt_lim(size_t, const char *, va_list);
  struct Ustr *ustr_dup_vfmt(size_t, const char *, va_list);
  struct Ustr *ustr_dup_fmt_lim(size_t, const char *, ...);
  struct Ustr *ustr_dup_fmt(const char *, ...);
  struct Ustr *ustr_dupx_fmt_lim(size_t, size_t, int, int, size_t, const char *, ...);
  struct Ustr *ustr_dupx_fmt(size_t, size_t, int, int, const char *, ...);
  int  ustr_set_vfmt_lim(struct Ustr **, size_t, const char *, va_list);
  int  ustr_set_vfmt(struct Ustr **, const char *, va_list);
  int  ustr_set_fmt_lim(struct Ustr **, size_t, const char *, ...);
  int  ustr_set_fmt(struct Ustr **, const char *, ...);
  int  ustr_ins_vfmt_lim(struct Ustr **, size_t, size_t, const char *, va_list);
  int  ustr_ins_vfmt(struct Ustr **, size_t, const char *, va_list);
  int  ustr_ins_fmt_lim(struct Ustr **, size_t, size_t, const char *, ...);
  int  ustr_ins_fmt(struct Ustr **, size_t, const char *, ...);
  int  ustr_sub_vfmt_lim(struct Ustr **, size_t, size_t, const char *, va_list);
  int  ustr_sub_vfmt(struct Ustr **, size_t, const char *, va_list);
  int  ustr_sub_fmt_lim(struct Ustr **, size_t, size_t, const char *, ...);
  int  ustr_sub_fmt(struct Ustr **, size_t, const char *, ...);
  int  ustr_sc_sub_vfmt_lim(struct Ustr **, size_t, size_t, size_t, const char *, va_list);
  int  ustr_sc_sub_vfmt(struct Ustr **, size_t, size_t, const char *, va_list);
  int  ustr_sc_sub_fmt_lim(struct Ustr **, size_t, size_t, size_t, const char *, ...);
  int  ustr_sc_sub_fmt(struct Ustr **, size_t, size_t, const char *, ...);

  size_t  ustr_len(const struct Ustr *);
  const char *ustr_cstr(const struct Ustr *);
  char *ustr_wstr(struct Ustr *);
  int ustr_alloc(const struct Ustr *);
  int ustr_exact(const struct Ustr *);
  int  ustr_sized(const struct Ustr *);
  int ustr_ro(const struct Ustr *);
  int  ustr_fixed(const struct Ustr *);
  int  ustr_enomem(const struct Ustr *);
  int  ustr_shared(const struct Ustr *);
  int  ustr_limited(const struct Ustr *);
  int  ustr_owner(const struct Ustr *);
  size_t  ustr_size(const struct Ustr *);
  size_t  ustr_size_alloc(const struct Ustr *);
  size_t  ustr_size_overhead(const struct Ustr *);
  void  ustr_conf(const struct Ustr *, size_t *, size_t *, int *, size_t *, size_t *);

  int  ustr_setf_enomem_err(struct Ustr *);
  int  ustr_setf_enomem_clr(struct Ustr *);
  int  ustr_setf_share(struct Ustr *);
  int  ustr_setf_owner(struct Ustr *);

  int  ustr_cmp_buf(const struct Ustr *, const void *, size_t);
  int  ustr_cmp(const struct Ustr *, const struct Ustr *);
  int  ustr_cmp_subustr(const struct Ustr *, const struct Ustr *, size_t, size_t);
  int  ustr_cmp_cstr(const struct Ustr *, const char *);
  int  ustr_cmp_fast_buf(const struct Ustr *, const void *, size_t);
  int  ustr_cmp_fast(const struct Ustr *, const struct Ustr *);
  int  ustr_cmp_fast_subustr(const struct Ustr *, const struct Ustr *, size_t, size_t);
  int  ustr_cmp_fast_cstr(const struct Ustr *, const char *);
  int  ustr_cmp_case_buf(const struct Ustr *, const void *, size_t);
  int  ustr_cmp_case(const struct Ustr *, const struct Ustr *);
  int  ustr_cmp_case_subustr(const struct Ustr *, const struct Ustr *, size_t, size_t);
  int  ustr_cmp_case_cstr(const struct Ustr *, const char *);
  int  ustr_cmp_eq(const struct Ustr *, const struct Ustr *);
  int  ustr_cmp_buf_eq(const struct Ustr *, const void *, size_t);
  int  ustr_cmp_subustr_eq(const struct Ustr *, const struct Ustr *, size_t, size_t);
  int  ustr_cmp_cstr_eq(const struct Ustr *, const char *);
  int  ustr_cmp_case_eq(const struct Ustr *, const struct Ustr *);
  int  ustr_cmp_case_buf_eq(const struct Ustr *, const void *, size_t);
  int  ustr_cmp_case_subustr_eq(const struct Ustr *, const struct Ustr *, size_t, size_t);
  int  ustr_cmp_case_cstr_eq(const struct Ustr *, const char *);
  int  ustr_cmp_prefix_eq(const struct Ustr *, const struct Ustr *);
  int  ustr_cmp_prefix_buf_eq(const struct Ustr *, const void *, size_t);
  int  ustr_cmp_prefix_cstr_eq(const struct Ustr *, const char *);
  int  ustr_cmp_prefix_subustr_eq(const struct Ustr *, const struct Ustr *, size_t, size_t);
  int  ustr_cmp_case_prefix_eq(const struct Ustr *, const struct Ustr *);
  int  ustr_cmp_case_prefix_buf_eq(const struct Ustr *, const void *, size_t);
  int  ustr_cmp_case_prefix_cstr_eq(const struct Ustr *, const char *);
  int  ustr_cmp_case_prefix_subustr_eq(const struct Ustr *, const struct Ustr *, size_t, size_t);
  int  ustr_cmp_suffix_eq(const struct Ustr *, const struct Ustr *);
  int  ustr_cmp_suffix_buf_eq(const struct Ustr *, const void *, size_t);
  int  ustr_cmp_suffix_cstr_eq(const struct Ustr *, const char *);
  int  ustr_cmp_suffix_subustr_eq(const struct Ustr *, const struct Ustr *, size_t, size_t);
  int  ustr_cmp_case_suffix_eq(const struct Ustr *, const struct Ustr *);
  int  ustr_cmp_case_suffix_buf_eq(const struct Ustr *, const void *, size_t);
  int  ustr_cmp_case_suffix_cstr_eq(const struct Ustr *, const char *);
  int  ustr_cmp_case_suffix_subustr_eq(const struct Ustr *, const struct Ustr *, size_t, size_t);

  size_t  ustr_srch_chr_fwd(const struct Ustr *, size_t, char);
  size_t  ustr_srch_chr_rev(const struct Ustr *, size_t, char);
  size_t  ustr_srch_buf_fwd(const struct Ustr *, size_t, const void *, size_t);
  size_t  ustr_srch_buf_rev(const struct Ustr *, size_t, const void *, size_t);
  size_t  ustr_srch_fwd(const struct Ustr *, size_t, const struct Ustr *);
  size_t  ustr_srch_rev(const struct Ustr *, size_t, const struct Ustr *);
  size_t  ustr_srch_cstr_fwd(const struct Ustr *, size_t, const char *);
  size_t  ustr_srch_cstr_rev(const struct Ustr *, size_t, const char *);
  size_t  ustr_srch_subustr_fwd(const struct  Ustr  *,  size_t,  const  struct  Ustr  *,  size_t,
                                size_t);
  size_t   ustr_srch_subustr_rev(const  struct  Ustr  *,   size_t,  const  struct Ustr *, size_t,
                                size_t);
  size_t  ustr_srch_case_chr_fwd(const struct Ustr *, size_t, char);
  size_t  ustr_srch_case_chr_rev(const struct Ustr *, size_t, char);
  size_t  ustr_srch_case_buf_fwd(const struct Ustr *, size_t, const void *, size_t);
  size_t  ustr_srch_case_buf_rev(const struct Ustr *, size_t, const void *, size_t);
  size_t  ustr_srch_case_fwd(const struct Ustr *, size_t, const struct Ustr *);
  size_t  ustr_srch_case_rev(const struct Ustr *, size_t, const struct Ustr *);
  size_t  ustr_srch_case_cstr_fwd(const struct Ustr *, size_t, const char *);
  size_t  ustr_srch_case_cstr_rev(const struct Ustr *, size_t, const char *);
  size_t  ustr_srch_case_subustr_fwd(const struct Ustr *, size_t, const struct  Ustr  *,  size_t,
                                     size_t);
  size_t   ustr_srch_case_subustr_rev(const  struct Ustr *,  size_t, const struct Ustr *, size_t,
                                     size_t);

  size_t  ustr_spn_chr_fwd(const struct Ustr *, size_t, char);
  size_t  ustr_spn_chr_rev(const struct Ustr *, size_t, char);
  size_t  ustr_spn_chrs_fwd(const struct Ustr *, size_t, const char *, size_t);
  size_t  ustr_spn_chrs_rev(const struct Ustr *, size_t, const char *, size_t);
  size_t  ustr_spn_fwd(const struct Ustr *, size_t, const struct Ustr *);
  size_t  ustr_spn_rev(const struct Ustr *, size_t, const struct Ustr *);
  size_t  ustr_spn_cstr_fwd(const struct Ustr *, size_t, const char *);
  size_t  ustr_spn_cstr_rev(const struct Ustr *, size_t, const char *);
  size_t  ustr_cspn_chr_fwd(const struct Ustr *, size_t, char);
  size_t  ustr_cspn_chr_rev(const struct Ustr *, size_t, char);
  size_t  ustr_cspn_chrs_fwd(const struct Ustr *, size_t, const char *, size_t);
  size_t  ustr_cspn_chrs_rev(const struct Ustr *, size_t, const char *, size_t);
  size_t  ustr_cspn_fwd(const struct Ustr *, size_t, const struct Ustr *);
  size_t  ustr_cspn_rev(const struct Ustr *, size_t, const struct Ustr *);
  size_t  ustr_cspn_cstr_fwd(const struct Ustr *, size_t, const char *);
  size_t  ustr_cspn_cstr_rev(const struct Ustr *, size_t, const char *);
  size_t  ustr_utf8_spn_chrs_fwd(const struct Ustr *, size_t, const char *, size_t);
  size_t  ustr_utf8_spn_chrs_rev(const struct Ustr *, size_t, const char *, size_t);
  size_t  ustr_utf8_spn_fwd(const struct Ustr *, size_t, const struct Ustr *);
  size_t  ustr_utf8_spn_rev(const struct Ustr *, size_t, const struct Ustr *);
  size_t  ustr_utf8_spn_cstr_fwd(const struct Ustr *, size_t, const char *);
  size_t  ustr_utf8_spn_cstr_rev(const struct Ustr *, size_t, const char *);
  size_t  ustr_utf8_cspn_chrs_fwd(const struct Ustr *, size_t, const char *, size_t);
  size_t  ustr_utf8_cspn_chrs_rev(const struct Ustr *, size_t, const char *, size_t);
  size_t  ustr_utf8_cspn_fwd(const struct Ustr *, size_t, const struct Ustr *);
  size_t  ustr_utf8_cspn_rev(const struct Ustr *, size_t, const struct Ustr *);
  size_t  ustr_utf8_cspn_cstr_fwd(const struct Ustr *, size_t, const char *);
  size_t  ustr_utf8_cspn_cstr_rev(const struct Ustr *, size_t, const char *);

  int  ustr_io_get(struct Ustr **, FILE *, size_t, size_t *);
  int  ustr_io_getfile(struct Ustr **, FILE *);
  int  ustr_io_getfilename(struct Ustr **, const char *);
  int  ustr_io_getdelim(struct Ustr **, FILE *, char);
  int  ustr_io_getline(struct Ustr **, FILE *);
  int ustr_io_put(struct Ustr **, FILE *, size_t);
  int  ustr_io_putline(struct Ustr **, FILE *, size_t);
  int  ustr_io_putfile(struct Ustr **, FILE *);
  int  ustr_io_putfileline(struct Ustr **, FILE *);
  int  ustr_io_putfilename(struct Ustr **, const char *, const char *);

  int  ustr_sub_undef(struct Ustr **, size_t, size_t);
  int  ustr_sub_buf(struct Ustr **, size_t, const void *, size_t);
  int  ustr_sub_cstr(struct Ustr **, size_t, const char *);
  int  USTR_SUB_OSTR(struct Ustr **, size_t, const char []);
  int  USTR_SUB_OBJ(struct Ustr **, size_t, ...);
  int  ustr_sub(struct Ustr **, size_t, const struct Ustr *);
  int  ustr_sub_subustr(struct Ustr **, size_t, const struct Ustr *, size_t, size_t);
  int  ustr_sc_sub_undef(struct Ustr **, size_t, size_t, size_t);
  int  ustr_sc_sub_buf(struct Ustr **, size_t , size_t , const void *, size_t );
  int  ustr_sc_sub_cstr(struct Ustr **, size_t, size_t, const char *);
  int  ustr_sc_sub(struct Ustr **, size_t, size_t, const struct Ustr *);
  int  ustr_sc_sub_subustr(struct Ustr **, size_t, size_t, const struct Ustr *, size_t, size_t);
  int  USTR_SC_SUB_OSTR(struct Ustr **, size_t, size_t, const char []);
  int  USTR_SC_SUB_OBJ(struct Ustr **, size_t, size_t, ...);
  size_t  ustr_replace_buf(struct Ustr **, const void *, size_t, const void *, size_t, size_t);
  size_t  ustr_replace_cstr(struct Ustr **, const char *, const char *, size_t);
  int  ustr_replace(struct Ustr **, const struct Ustr *, const struct Ustr *, size_t);
  size_t ustr_replace_rep_chr(struct Ustr **ps1, char, size_t, char, size_t nlen, size_t lim);

  struct Ustr *ustr_split_buf(const struct Ustr *, size_t *, const void *, size_t, struct Ustr *,
                              unsigned int);
  struct  Ustr  *ustr_split(const  struct  Ustr  *, size_t *, const struct Ustr *, struct Ustr *,
                          unsigned int);
  struct Ustr *ustr_split_cstr(const struct Ustr *, size_t  *,  const  char  *,  struct  Ustr  *,
                               unsigned int);
  struct  Ustr  *ustr_split_spn_chrs(const  struct Ustr *, size_t *, const char *, size_t, struct
                                   Ustr *, unsigned int);
  struct Ustr *ustr_split_spn_cstr(const struct Ustr *, size_t *, const char *,  struct  Ustr  *,
                                   unsigned int);
  struct  Ustr *ustr_split_spn(const struct Ustr *, size_t *, const struct Ustr *, struct Ustr *,
                              unsigned int);

  int  ustr_utf8_valid(const struct Ustr *);
  size_t  ustr_utf8_len(const struct Ustr *);
  ssize_t  ustr_utf8_width(const struct Ustr *);
  size_t  ustr_utf8_chars2bytes(const struct Ustr *, size_t, size_t, size_t *);
  size_t  ustr_utf8_bytes2chars(const struct Ustr *, size_t, size_t, size_t *);
  int ustr_sc_utf8_reverse(struct Ustr **);

  uintmax_t  ustr_parse_uintmaxx(const struct Ustr *, size_t, unsigned int, uintmax_t, uintmax_t,
                                 const char *, size_t *, unsigned int *);
  uintmax_t  ustr_parse_uintmax(const struct Ustr *, size_t, unsigned int, size_t *, unsigned int
                                *);
  intmax_t  ustr_parse_intmax(const struct Ustr *, size_t, unsigned int, size_t *,  unsigned  int
                              *);
  unsigned  long   ustr_parse_ulongx(const struct Ustr *,  size_t,  unsigned int,  unsigned long,
                                   unsigned long, const char *,  size_t *, unsigned int *);
  unsigned long  ustr_parse_ulong(const struct Ustr *, size_t, unsigned int, size_t  *,  unsigned
                                  int *);
  long  ustr_parse_long(const struct Ustr *, size_t, unsigned int, size_t *, unsigned int *);
  unsigned int  ustr_parse_uint(const struct Ustr *, size_t, unsigned int, size_t *, unsigned int
                                *);
  int  ustr_parse_int(const struct Ustr *, size_t, unsigned int, size_t *, unsigned int *);
  unsigned short  ustr_parse_ushort(const struct Ustr *, size_t, unsigned int, size_t *, unsigned
                                    int *);
  short  ustr_parse_short(const struct Ustr *, size_t, unsigned int, size_t *, unsigned int *);

  int  ustr_sc_ensure_owner(struct Ustr **);
  char *ustr_sc_wstr(struct Ustr **);
  char *ustr_sc_export_subustr(const struct Ustr *, size_t, size_t, void *(*)(size_t));
  char *ustr_sc_export(const struct Ustr *, void *(*)(size_t));
  char  *ustrp_sc_export_subustrp(struct  Ustr_pool  *, const struct Ustr *, size_t, size_t, void
                                 *(*)(size_t));
  char *ustrp_sc_export(struct Ustr_pool *, const struct Ustr *, void *(*)(size_t));
  int  ustr_sc_reverse(struct Ustr **);
  int  ustr_sc_tolower(struct Ustr **);
  int  ustr_sc_toupper(struct Ustr **);
  int  ustr_sc_ltrim_chrs(struct Ustr **, const char *, size_t);
  int  ustr_sc_ltrim(struct Ustr **, const struct Ustr *);
  int  ustr_sc_ltrim_cstr(struct Ustr **, const char *);
  int  ustr_sc_rtrim_chrs(struct Ustr **, const char *, size_t);
  int  ustr_sc_rtrim(struct Ustr **, const struct Ustr *);
  int  ustr_sc_rtrim_cstr(struct Ustr **, const char *);
  int  ustr_sc_trim_chrs(struct Ustr **, const char *, size_t);
  int  ustr_sc_trim(struct Ustr **, const struct Ustr *);
  int  ustr_sc_trim_cstr(struct Ustr **, const char *);

  int  ustr_add_b_uint16(struct Ustr **, uint_least16_t);
  int  ustr_add_b_uint32(struct Ustr **, uint_least32_t);
  int  ustr_add_b_uint64(struct Ustr **, uint_least64_t);

  uint_least16_t  ustr_parse_b_uint16(const struct Ustr *, size_t);
  uint_least32_t  ustr_parse_b_uint32(const struct Ustr *, size_t);
  uint_least64_t  ustr_parse_b_uint64(const struct Ustr *, size_t);

  int ustr_realloc(struct Ustr **, size_t);
  int  ustr_cntl_opt(int, ...);

  struct Ustr_pool *ustr_pool_ll_make(void);
  struct Ustr_pool *ustr_pool_make_subpool(struct Ustr_pool *);
  void ustr_pool_free(struct Ustr_pool *);
  void ustr_pool_clear(struct Ustr_pool *);

DESCRIPTION

        A very simple overview is that you can use ustr_dup_cstr() to  convert  a  C-style  to  a
       Ustr,   and  ustr_cstr()  to  convert  it  back.  You  can  also  use  USTR1()  to  create
       constant/read-only strings, and USTR_SC_INIT_AUTO() to create strings that use stack space
       upto a certain amount.
        Use  is  somewhat  unique  in  that,  by  default, it has an average overhead of only 55%
       overhead over strdup(), for strings in the range of 0 to 20 bytes. Or, to put  it  another
       way it only uses 8 bytes to store a 2 byte string where strdup() uses 3.

Creating read-only Ustr functions

     Function:  USTR()
       Returns: Ustr string
       Type: struct Ustr *

       Parameter[1]: Pointer to Ustr data
       Type[1]: void *

       Explanation:

         This macro function is normally used with the empty string "".

       Note:

         There is basically just a simple cast behind the macro.

     Function:  USTRP()
       Returns: Ustrp string
       Type: struct Ustrp *

       Parameter[1]: Pointer to Ustrp data
       Type[1]: void *

       Explanation:

         This macro function is normally used with the empty string "".

       Note:

         There is basically just a simple cast behind the macro.

     Function:  USTR1()
       Returns: Ustr string
       Type: struct Ustr *

       Parameter[1]: Encoded number of the length of Ustr string
       Type[1]: symbol

       Parameter[2]: Data for Ustr string
       Type[2]: const char[]

       Explanation:

         This  macro function simplifies the creation of read-only Ustr string's. And is normally
       used like...

         USTR1(\x4, "abcd")

        ...it is worth pointing out that running with debugging turned on
        (USTR_CONF_USE_ASSERT) will complain if the length isn't encoded correctly, as in...

         USTR1(\x3, "abcd")

        ...here ustr_assert_valid() will fail, which is called before most functions do
        anything in debugging mode. Note also that extra debugging (USTR_CONF_USE_EOS_MARK)  will
       still catch cases like...

         USTR1(\x3, "abc\0d")

        ...at least using debugging is esp. important if you are putting UTF-8
        characters into the strings.

       Note:

         Having  ustr_ro()  return  true  means  that  the  Ustr  cannot be written to without be
       reallocated into allocation space ... not that ustr_add() etc. will fail.
         There is now USTR1_CHK() which performs a compile time check so you can  never  have  an
       invalid ustr.

     Function:  USTR2()
       Returns: Ustr string
       Type: struct Ustr *

       Parameter[1]: Encoded 2nd byte of number of the length of Ustr string
       Type[1]: symbol

       Parameter[2]: Encoded 1st byte of number of the length of Ustr string
       Type[2]: symbol

       Parameter[3]: Data for Ustr string
       Type[3]: const char[]

       Explanation:

         This  function  works  in  the  same  way  as USTR1() but takes two length bytes, so the
       read-only string can be upto 65,535 (2**16 - 1) bytes in length.

     Function:  USTR4()
       Returns: Ustr string
       Type: struct Ustr *

       Parameter[1]: Encoded 4th byte of number of the length of Ustr string
       Type[1]: symbol

       Parameter[2]: Encoded 3rd byte of number of the length of Ustr string
       Type[2]: symbol

       Parameter[3]: Encoded 2nd byte of number of the length of Ustr string
       Type[3]: symbol

       Parameter[4]: Encoded 1st byte of number of the length of Ustr string
       Type[4]: symbol

       Parameter[5]: Data for Ustr string
       Type[5]: const char[]

       Explanation:

         This function works in the same way as USTR1() but  takes  four  length  bytes,  so  the
       read-only string can be upto 2**32 - 1 bytes in length.

     Function:  USTR1_CHK()
       Returns: Ustr string
       Type: struct Ustr *

       Parameter[1]: Encoded number of the length of Ustr string
       Type[1]: symbol

       Parameter[2]: Data for Ustr string
       Type[2]: const char[]

       Explanation:

         This function works in the same way as USTR1() but it does a check against the length of
       (Parameter[2]) using sizeof() - 1.

       Note:

         If the check fails the returned Ustr * will be "", so you can check ustr_len() to see if
       you screwed something up.

     Function:  USTR2_CHK()
       Returns: Ustr string
       Type: struct Ustr *

       Parameter[1]: Encoded 2nd byte of number of the length of Ustr string
       Type[1]: symbol

       Parameter[2]: Encoded 1st byte of number of the length of Ustr string
       Type[2]: symbol

       Parameter[3]: Data for Ustr string
       Type[3]: const char[]

       Explanation:

         This function works in the same way as USTR2() but it does a check against the length of
       (Parameter[2]) using sizeof() - 1.

       Note:

         If the check fails the returned Ustr * will be "".

     Function:  USTR4_CHK()
       Returns: Ustr string
       Type: struct Ustr *

       Parameter[1]: Encoded 4th byte of number of the length of Ustr string
       Type[1]: symbol

       Parameter[2]: Encoded 3rd byte of number of the length of Ustr string
       Type[2]: symbol

       Parameter[3]: Encoded 2nd byte of number of the length of Ustr string
       Type[3]: symbol

       Parameter[4]: Encoded 1st byte of number of the length of Ustr string
       Type[4]: symbol

       Parameter[5]: Data for Ustr string
       Type[5]: const char[]

       Explanation:

         This function works in the same way as USTR4() but it does a check against the length of
       (Parameter[2]) using sizeof() - 1.

       Note:

         If the check fails the returned Ustr * will be "".

     Function:  USTRP1()
       Returns: Ustr string
       Type: struct Ustr *

       Parameter[1]: Encoded number of the length of Ustr string
       Type[1]: symbol

       Parameter[2]: Data for Ustr string
       Type[2]: const char[]

       Explanation:

         This function works like USTR1(), but returns a Ustrp instead.

     Function:  USTRP2()
       Returns: Ustr string
       Type: struct Ustr *

       Parameter[1]: Encoded 2nd byte of number of the length of Ustr string
       Type[1]: symbol

       Parameter[2]: Encoded 1st byte of number of the length of Ustr string
       Type[2]: symbol

       Parameter[3]: Data for Ustr string
       Type[3]: const char[]

       Explanation:

         This function works like USTR4(), but returns a Ustrp instead.

     Function:  USTRP4()
       Returns: Ustrp string
       Type: struct Ustrp *

       Parameter[1]: Encoded 4th byte of number of the length of Ustrp string
       Type[1]: symbol

       Parameter[2]: Encoded 3rd byte of number of the length of Ustrp string
       Type[2]: symbol

       Parameter[3]: Encoded 2nd byte of number of the length of Ustrp string
       Type[3]: symbol

       Parameter[4]: Encoded 1st byte of number of the length of Ustrp string
       Type[4]: symbol

       Parameter[5]: Data for Ustr string
       Type[5]: const char[]

       Explanation:

         This function works like USTR2(), but returns a Ustrp instead.

     Function:  USTRP1_CHK()
       Returns: Ustr string
       Type: struct Ustr *

       Parameter[1]: Encoded number of the length of Ustr string
       Type[1]: symbol

       Parameter[2]: Data for Ustr string
       Type[2]: const char[]

       Explanation:

         This function works like USTR1_CHK(), but returns a Ustrp instead.

     Function:  USTRP2_CHK()
       Returns: Ustr string
       Type: struct Ustr *

       Parameter[1]: Encoded 2nd byte of number of the length of Ustr string
       Type[1]: symbol

       Parameter[2]: Encoded 1st byte of number of the length of Ustr string
       Type[2]: symbol

       Parameter[3]: Data for Ustr string
       Type[3]: const char[]

       Explanation:

         This function works like USTR4_CHK(), but returns a Ustrp instead.

     Function:  USTRP4_CHK()
       Returns: Ustrp string
       Type: struct Ustrp *

       Parameter[1]: Encoded 4th byte of number of the length of Ustrp string
       Type[1]: symbol

       Parameter[2]: Encoded 3rd byte of number of the length of Ustrp string
       Type[2]: symbol

       Parameter[3]: Encoded 2nd byte of number of the length of Ustrp string
       Type[3]: symbol

       Parameter[4]: Encoded 1st byte of number of the length of Ustrp string
       Type[4]: symbol

       Parameter[5]: Data for Ustr string
       Type[5]: const char[]

       Explanation:

         This function works like USTR2_CHK(), but returns a Ustrp instead.

Creating fixed Ustr functions

     Function:  USTR_SIZE_FIXED()
       Returns: Size of area of memory
       Type: size_t

       Parameter[1]: Size of area of memory
       Type[1]: size_t

       Explanation:

         This  macro  function  is  replaced  by  a static conversion from the max length desired
       (Parameter[1])  to  the  storage  size  needed.  In  other  words  it   works   out   what
       ustr_size_overhead() will be, and adds that value.

       Note:

         This is useful is you want a small fixed size allocation, as you can declare it like so:

         char buf[USTR_SIZE_FIXED(4)];
        ...to give you exactly 4 bytes as a maximum, this is esp. useful if you want
        a limited (ustr_limited() == USTR_TRUE) Ustr string.

     Function:  ustr_init_fixed()
       Returns: Ustr string
       Type: struct Ustr *

       Parameter[1]: Pointer to area of memory to use as a Ustr string
       Type[1]: void *

       Parameter[2]: Size of area of memory
       Type[2]: size_t

       Parameter[3]: Whether the fixed size Ustr should be limited
       Type[3]: int

       Parameter[4]: The initial length of the Ustr
       Type[4]: size_t

       Explanation:

         This creates a new Ustr string, which is "fixed". This means the Ustr storage is managed
       outside of the ustr_* API, it is often used for stack allocated strings.
         As you add data to the Ustr past the size allowed via. the fixed storge  the  Ustr  will
       automatically  be  converted  into  an  allocated  Ustr. So if this is possible you should
       always call ustr_free(), as this does nothing if given a fixed size Ustr.

       Note:

         For simplicity you probably want to use USTR_SC_INIT_AUTO() or USTR_SC_INIT_AUTO()  when
       possible.

     Function:  USTR_SC_INIT_AUTO()
       Returns: Ustr string
       Type: struct Ustr *

       Parameter[1]: Area of memory to use as a Ustr string
       Type[1]: char[]

       Parameter[2]: Whether the fixed size Ustr should be limited
       Type[2]: int

       Parameter[3]: The initial length of the Ustr
       Type[3]: size_t

       Explanation:

         This  calls  ustr_init_fixed()  with  sizeof()  the area of memory (Parameter[1]) as the
       second argument.

       Note:

         This does mean that the first argument must be the correct size, as far as  sizeof()  is
       concerned, as in...

        char buf_sz[1024];
        Ustr *s1 = USTR_SC_INIT_AUTO(buf_sz, USTR_FALSE, 0);

        ...so passing pointers to memory from malloc() will probably just return NULL.

     Function:  USTR_SC_INIT_AUTO_OSTR()
       Returns: Ustr string
       Type: struct Ustr *

       Parameter[1]: Area of memory to use as a Ustr string
       Type[1]: char[]

       Parameter[2]: Whether the fixed size Ustr should be limited
       Type[2]: int

       Parameter[3]: The initial string in the buffer, as a constant string
       Type[3]: size_t

       Explanation:

         This  calls  ustr_init_fixed()  with  sizeof()  the area of memory (Parameter[1]) as the
       second argument, given as an "object string".

       Note:

         This does mean that the first argument must be the correct size, as far as  sizeof()  is
       concerned, as in...

        char buf_sz[1024] = USTR_BEG_FIXED2 "abcd";
        Ustr *s1 = USTR_SC_INIT_AUTO_OSTR(buf_sz, USTR_FALSE, "abcd");

        ...so passing pointers to memory from malloc() will probably just return NULL.

Debugging functions

     Function:  ustr_assert_valid()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a Ustr string
       Type[1]: Ustr *

       Explanation:

         This  function  asserts a few internal consistency checks, and can help point out when a
       Ustr is invalid.

       Note:

         This calls ustr_assert_ret() so that  when  USTR_DEBUG  if  off  the  checks  are  still
       performed and the result is returned.

     Function:  ustr_assert_valid_subustr()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a Ustr string
       Type[1]: Ustr *

       Parameter[2]: Position in the Ustr
       Type[2]: size_t

       Parameter[3]: Length to delete from the Ustr
       Type[3]:  size_t

       Explanation:

         This function calls ustr_assert_valid() and also checks that the position and length are
       within the Ustr. If they aren't  valid  it  returns  0,  if  they  are  valid  it  returns
       ustr_len().

     Function:  USTR_CNTL_MALLOC_CHECK_BEG()
       Returns: Success or failure
       Type: int

       Parameter[1]: Condition for begin malloc checking or not
       Type[1]: int

       Explanation:

         This  function  begins malloc checking, meaning all ustr allocations will go through the
       malloc check routines, but it fails if the condition check (Parameter[1]) fails.

       Note:

         Turning malloc checking on after one or more allocations has happened will lead to false
       failures unless you really known what you are doing.
         You  can  automatically  turn  malloc checking on by giving the USTR_CNTL_MC environment
       variable the value of "1", "yes" or "on".

     Function:  USTR_CNTL_MALLOC_CHECK_LVL()
       Returns: Level of current malloc check
       Type: int

       Parameter[1]: Nothing
       Type[1]: void

       Explanation:

         This function returns the current "level" of the malloc check, with  0  indicating  that
       malloc check isn't enabled.
         The    level    goes    up    by    one    whenever    USTR_CNTL_MALLOC_CHECK_BEG()   or
       USTR_CNTL_MALLOC_CHECK_ADD()  returns   success,   and   goes   down   by   one   whenever
       USTR_CNTL_MALLOC_CHECK_DEL() or USTR_CNTL_MALLOC_CHECK_END() returns success.

     Function:  USTR_CNTL_MALLOC_CHECK_MEM()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer returned from malloc check
       Type[1]: void *

       Explanation:

         This  function  asserts  that  the  pointer  (Parameter[1])  was  allocated  from malloc
       checking.

       Note:

         Unless you are doing something special, or using a builtin Ustr_pool it is  very  likely
       you want to just call USTR_CNTL_MALLOC_CHECK_MEM_USTR().

     Function:  USTR_CNTL_MALLOC_CHECK_MEM_SZ()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer returned from malloc check
       Type[1]: void *

       Parameter[2]: Length of allocated memory
       Type[2]: size_t

       Explanation:

         This  function  asserts  that  the  pointer  (Parameter[1])  was  allocated  from malloc
       checking, and has the specified size (Parameter[2]).

       Note:

         Unless you are doing something special, or using a builtin Ustr_pool it is  very  likely
       you want to just call USTR_CNTL_MALLOC_CHECK_MEM_USTR().

     Function:  USTR_CNTL_MALLOC_CHECK_MEM_MINSZ()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer returned from malloc check
       Type[1]: void *

       Parameter[2]: Length of allocated memory
       Type[2]: size_t

       Explanation:

         This  function  asserts  that  the  pointer  (Parameter[1])  was  allocated  from malloc
       checking, and has at least the specified size (Parameter[2]).

       Note:

         Unless you are doing something special, or using a builtin Ustr_pool it is  very  likely
       you want to just call USTR_CNTL_MALLOC_CHECK_MEM_USTR().

     Function:  USTR_CNTL_MALLOC_CHECK_MEM_USTR()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a Ustr string
       Type[1]: Ustr *

       Explanation:

         This  function  asserts  that the pointer (Parameter[1]) is a Ustr allocated from malloc
       checking, if the Ustr is allocated (if not it returns TRUE).

       Note:

         Because of the layering between the Ustr code and the pool  code,  if  you  allocate  an
       implicity sized Ustrp from a pool and then delete some data from it (which fails) the Ustr
       layer will think it has an implicit less than the actual size so this function will  fail.
       This is what USTR_CNTL_MALLOC_CHECK_MEM_USTRP() is for.

     Function:  USTR_CNTL_MALLOC_CHECK_MEM_USTRP()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a Ustrp string
       Type[1]: Ustrp *

       Explanation:

         This function asserts that the pointer (Parameter[1]) is a Ustr allocated from a builtin
       pool using malloc checking, if the Ustr is allocated (if not it returns TRUE).

     Function:  USTR_CNTL_MALLOC_CHECK_END()
       Returns: Success or failure
       Type: int

       Parameter[1]: Nothing
       Type[1]: void

       Explanation:

         This macro will cleanup any memory used by malloc check, and assert that  no  memory  is
       left allocated.

       Note:

         If  any  memory  is  left  allocated,  each  one  found  is  output  to  stderr with the
       file/line/function of the level it was allocated from.

     Function:  USTR_CNTL_MALLOC_CHECK_ADD()
       Returns: Success or failure
       Type: int

       Parameter[1]: Condition to begin malloc checking or not
       Type[1]: int

       Explanation:

         This function works like USTR_CNTL_MALLOC_CHECK_END() but  it  fails  if  the  condition
       check (Parameter[1]) fails, or if USTR_CNTL_MALLOC_CHECK_LVL() is zero.

     Function:  USTR_CNTL_MALLOC_CHECK_DEL()
       Returns: Success or failure
       Type: int

       Parameter[1]: Condition to end malloc checking or not
       Type[1]: int

       Explanation:

         This  function  works  like  USTR_CNTL_MALLOC_CHECK_END()  but it fails if the condition
       check (Parameter[1]) fails, or if USTR_CNTL_MALLOC_CHECK_LVL() is one.

       Note:

         The condition (Parameter[1]) to this macro should almost certainly be the  return  value
       from USTR_CNTL_MALLOC_CHECK_ADD().

Creating allocated Ustr functions

     Function:  ustr_init_size()
       Returns: Size that needs to be allocated
       Type: size_t

       Parameter[1]: Size of allocated storage
       Type[1]: size_t

       Parameter[2]: Number of bytes to use for reference count
       Type[2]: size_t

       Parameter[3]: Exact memory allocations
       Type[3]: int

       Parameter[4]: Length of data in the Ustr
       Type[4]: size_t

       Explanation:

         This  function  finds out the exact size of memory needed to store the specified Ustr of
       the given configuration.

     Function:  ustr_init_alloc()
       Returns: Ustr string
       Type: struct Ustr *

       Parameter[1]: Pointer to area of memory to use as a Ustr string
       Type[1]: void *

       Parameter[2]: Size of area of memory
       Type[2]: size_t

       Parameter[3]: Whether Ustr should store the size
       Type[3]: size_t

       Parameter[4]: Number of bytes to use for references
       Type[4]: size_t

       Parameter[5]: Whether the Ustr should use exact allocations
       Type[5]: int

       Parameter[6]: Whether the Ustr should have the "enomem" flag set
       Type[6]: int

       Parameter[7]: The initial length of the Ustr
       Type[7]: size_t

       Explanation:

         This  creates  a  new  Ustr  string,  you  should   have   allocated   the   data   via.
       USTR_CONF_MALLOC()  or  bad  things  will  happen  if  the  Ustr  string is ever free'd or
       reallocated.

     Function:  ustr_dupx_empty()
       Returns: Ustr string
       Type: struct Ustr *

       Parameter[1]: Size of allocated storage
       Type[1]: size_t

       Parameter[2]: Number of bytes to use for reference count
       Type[2]: size_t

       Parameter[3]: Exact memory allocation flag
       Type[3]: int

       Parameter[4]: ENOMEM, memory error flag
       Type[4]: int

       Explanation:

         This function creates an empty Ustr, owned by you, that is allocated from system memory,
       or it returns NULL.
         The  size  is  the  desired  allocation size for the entire Ustr, including overhead for
       metadata. This value will be rounded up, if it's too small, so passing 1 as the size means
       you want a stored size but to allocate the smallest amount of memory possible.
         The  exact  memory  allocation  flag says if the Ustr should round allocations up to the
       nearest half power of two or should be no more than needed.
         The ENOMEM memory error flag sets the iniital state of the user visible flag for  memory
       allocation errors. Eg. ustr_enomem(), ustr_setf_enomem_clr() and ustr_setf_enomem_err()

       Note:

         The reference byte count can only be one of the following values: 0, 1, 2 or 4, or 8 (on
       environments with a 64bit size_t).
         It can be useful to ensure that the Ustr is in system memory, so that you can add things
       to it and check for errors with ustr_enomem().
         If  you chose to store the allocated size in the Ustr then the number of bytes allocated
       for the reference count will be a minimum of 2.

     Function:  ustr_dup_empty()
       Returns: Ustr string
       Type: struct Ustr *

       Parameter[1]: Nothing
       Type[1]: void

       Explanation:

         This function is the same as calling ustr_dupx_empty() with the current set  of  default
       options.

     Function:  ustr_dupx_undef()
       Returns: Ustr string
       Type: struct Ustr *

       Parameter[1]: Size of allocated storage
       Type[1]: size_t

       Parameter[2]: Number of bytes to use for reference count
       Type[2]: size_t

       Parameter[3]: Exact memory allocations
       Type[3]: int

       Parameter[4]: ENOMEM, memory error flag
       Type[4]: int

       Parameter[5]: Length of new undefined data
       Type[5]: size_t

       Explanation:

         This function works like you called ustr_dupx_empty() and then ustr_add_undef().

     Function:  ustr_dup_undef()
       Returns: Pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: Length of new undefined data
       Type[1]: size_t

       Explanation:

         This  function  is the same as calling ustr_dupx_undef() with the current set of default
       options.

     Function:  ustr_dup()
       Returns: A pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: Pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Explanation:

         This function tries to increase the reference count on the passed Ustr  string,  and  if
       that  succeeds  returns  that  as  an  argument. If that fails it tries creates a new Ustr
       string that looks identical to the old Ustr string, apart from the reference count.

       Note:

         Because the new Ustr string is configured identically to the old Ustr string this  means
       the  result  can  be  very  different  to  what  you  get  if you call ustr_dup_buf() with
       ustr_cstr() and ustr_len() from the original  string  where  the  configuration  would  be
       whatever the default is.
         Esp.  worth of note is that if you ustr_dup() a Ustr string with an explicit size of 900
       but a length of 1, and the reference count is full the returned Ustr string  will  have  a
       size of 900 bytes and so will have allocated a little over that. ustr_dup_buf(), even with
       a sized configuration would only allocate about 12 bytes and have a  size  a  little  less
       than that.

     Function:  ustr_dupx()
       Returns: Pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: Size of allocated storage
       Type[1]: size_t

       Parameter[2]: Number of bytes to use for reference count
       Type[2]: size_t

       Parameter[3]: Exact memory allocations
       Type[3]: int

       Parameter[4]: ENOMEM, memory error flag
       Type[4]: int

       Parameter[5]: Pointer to a constant Ustr string
       Type[5]: const struct Ustr *

       Explanation:

         This  function tries to add a reference if the value of the size, reference bytes, exact
       memory  allocations  and  ENOMEM  are  the  same  as  those  in  the  passed  Ustr  string
       (Parameter[5]). If the comparison fails or the addition of a reference fails it works like
       ustr_dupx_buf() using ustr_cstr() and ustr_len().

     Function:  ustr_sc_dup()
       Returns: A pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Explanation:

         This function works like calling ustr_dup(), but if the reference  count  is  maxed  out
       then  and  so  a  new  Ustr  string  has  been allocated then that is stored in the passed
       argument (Parameter[1]) and the "old" Ustr string is returned.

       Note:

         The reason to use this is that if you have a "main" Ustr string pointer that  a  lot  of
       things  are  getting references too then when the reference count maxes out you'll degrade
       into worst case behaviour which acts  as  though  there  are  no  reference  counts.  This
       function stops that problem.
         As  an  example,  if  you have a 1 byte reference count and have 255 * 2 references then
       using ustr_dup() will create 256 Ustr strings using  this  function  will  create  4  Ustr
       strings.

     Function:  ustr_sc_dupx()
       Returns: Pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: Size of allocated storage
       Type[1]: size_t

       Parameter[2]: Number of bytes to use for reference count
       Type[2]: size_t

       Parameter[3]: Exact memory allocations
       Type[3]: int

       Parameter[4]: ENOMEM, memory error flag
       Type[4]: int

       Parameter[5]: A pointer to a pointer to a Ustr string
       Type[5]: struct Ustr **

       Explanation:

         This  function  works  like calling ustr_dupx(), but if the reference count is maxed out
       then and so a new Ustr string is allocated then that is  stored  in  the  passed  argument
       (Parameter[1]) and the "old" Ustr string is returned.
         If  the  configurations of the new Ustr string and the old Ustr string are not the same,
       this function works identically to ustr_dupx().

       Note:

         The reason to use this is that if you have a "main" Ustr string pointer that  a  lot  of
       things  are  getting references too then when the reference count maxes out you'll degrade
       into worst case behaviour which acts  as  though  there  are  no  reference  counts.  This
       function stops that problem.
         As  an  example,  if  you have a 1 byte reference count and have 255 * 2 references then
       using ustr_dupx() will create 256 Ustr strings using this  function  will  create  4  Ustr
       strings.

     Function:  ustr_dup_buf()
       Returns: A pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: Pointer to data
       Type[1]: const void *

       Parameter[2]: Length of data
       Type[2]: size_t

       Explanation:

         This  function works as if you had called ustr_dup_undef() and then copied the data into
       the new undefined space.

     Function:  ustr_dupx_buf()
       Returns: Pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: Size of allocated storage
       Type[1]: size_t

       Parameter[2]: Number of bytes to use for reference count
       Type[2]: size_t

       Parameter[3]: Exact memory allocations
       Type[3]: int

       Parameter[4]: ENOMEM, memory error flag
       Type[4]: int

       Parameter[5]: Pointer to data
       Type[5]: const void *

       Parameter[6]: Length of data
       Type[6]: size_t

       Explanation:

         This function works as if you had called ustr_dupx_undef() and then copied the data into
       the new undefined space.

     Function:  ustr_dup_cstr()
       Returns: A pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: Pointer to constant C-style string
       Type[1]: const char *

       Explanation:

         This  function  works  as  if  you  had called ustr_dup_buf() and passed strlen() as the
       length.

     Function:  ustr_dupx_cstr()
       Returns: Pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: Size of allocated storage
       Type[1]: size_t

       Parameter[2]: Number of bytes to use for reference count
       Type[2]: size_t

       Parameter[3]: Exact memory allocations
       Type[3]: int

       Parameter[4]: ENOMEM, memory error flag
       Type[4]: int

       Parameter[5]: Pointer to constant C-style string
       Type[5]: const char *

       Explanation:

         This function works as if you had called ustr_dupx_buf()  and  passed  strlen()  as  the
       length.

     Function:  USTR_DUP_OSTR()
       Returns: A pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: A constant C-style string
       Type[1]: const char []

       Explanation:

         This  function  works as if you had called ustr_dup_buf() and passed sizeof() - 1 as the
       length.

     Function:  USTR_DUP_OBJ()
       Returns: A pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: A symbol
       Type[1]: ...

       Explanation:

         This function works as if you had called  ustr_dup_buf()  and  passed  sizeof()  as  the
       length.

       Note:

         In most cases you'll want to use USTR_DUP_OSTR().

     Function:  ustr_dup_subustr()
       Returns: A pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Position in the Ustr
       Type[2]: size_t

       Parameter[3]: Length to add from the Ustr
       Type[3]: size_t

       Explanation:

         This  function  mostly  works as if you had called ustr_dup_buf() with the ustr_cstr() +
       position - 1 and length values of the Ustr string to be added.

       Note:

         If the position is 1 and the length is the length of the Ustr string then it just  calls
       ustr_dup().

     Function:  ustr_dupx_subustr()
       Returns: Pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: Size of allocated storage
       Type[1]: size_t

       Parameter[2]: Number of bytes to use for reference count
       Type[2]: size_t

       Parameter[3]: Exact memory allocations
       Type[3]: int

       Parameter[4]: ENOMEM, memory error flag
       Type[4]: int

       Parameter[5]: A pointer to a constant Ustr string
       Type[5]: const struct Ustr *

       Parameter[6]: Position in the Ustr
       Type[6]: size_t

       Parameter[7]: Length to add from the Ustr
       Type[7]: size_t

       Explanation:

         This  function  mostly works as if you had called ustr_dupx_buf() with the ustr_cstr() +
       position - 1 and length values of the Ustr string to be added.

       Note:

         If the position is 1 and the length is the length of the Ustr string then it just  calls
       ustr_dupx().

     Function:  ustr_dup_rep_chr()
       Returns: A pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: Byte value of data
       Type[1]: char

       Parameter[2]: Length of bytes as data
       Type[2]: size_t

       Explanation:

         This function works as if you had called ustr_dup_undef() and then copied the byte value
       to each position.

     Function:  ustr_dupx_rep_chr()
       Returns: Pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: Size of allocated storage
       Type[1]: size_t

       Parameter[2]: Number of bytes to use for reference count
       Type[2]: size_t

       Parameter[3]: Exact memory allocations
       Type[3]: int

       Parameter[4]: ENOMEM, memory error flag
       Type[4]: int

       Parameter[5]: Byte value of data
       Type[5]: char

       Parameter[6]: Length of bytes as data
       Type[6]: size_t

       Explanation:

         This function works as if you had called ustr_dupx_undef()  and  then  copied  the  byte
       value to each position.

     Function:  ustr_sc_vjoin()
       Returns: Pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: Separator to go between Ustr strings
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to the first constant Ustr string
       Type[2]: const struct Ustr *

       Parameter[3]: A pointer to the second constant Ustr string
       Type[3]: const struct Ustr *

       Parameter[4]: Variable argument list variable, from va_start()
       Type[4]: va_list

       Explanation:

         This function works as if you called ustr_dup() on the first Ustr string (Parameter[2]),
       and then ustr_add() on the separator (Parameter[1]) followed by ustr_add() on  the  second
       Ustr  string  (Parameter[3]).  This  process  then repeats for all the Ustr strings in the
       variable argument list (Parameter[4]) until a USTR_NULL is reached.

       Note:

         This function doesn't guarantee to just take a reference  to  one  of  the  passed  Ustr
       strings, even if that is what would happen if you called the above manually.

     Function:  ustr_sc_join()
       Returns: Pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: Separator to go between Ustr strings
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to the first constant Ustr string
       Type[2]: const struct Ustr *

       Parameter[3]: A pointer to the second constant Ustr string
       Type[3]: const struct Ustr *

       Parameter[4]: Zero or more pointers to constant Ustr strings and then USTR_NULL
       Type[4]: ...

       Explanation:

         This  function  calls  va_start()  to  get  a  variable  argument  list  and  then calls
       ustr_sc_vjoin().

       Note:

         This function doesn't guarantee to just take a reference  to  one  of  the  passed  Ustr
       strings, even if that is what would happen if you called the above manually.

     Function:  ustr_sc_vjoinx()
       Returns: Pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: Size of allocated storage
       Type[1]: size_t

       Parameter[2]: Number of bytes to use for reference count
       Type[2]: size_t

       Parameter[3]: Exact memory allocations
       Type[3]: int

       Parameter[4]: ENOMEM, memory error flag
       Type[4]: int

       Parameter[5]: Separator to go between Ustr strings
       Type[5]: const struct Ustr *

       Parameter[6]: A pointer to the first constant Ustr string
       Type[6]: const struct Ustr *

       Parameter[7]: A pointer to the second constant Ustr string
       Type[7]: const struct Ustr *

       Parameter[8]: Variable argument list variable, from va_start()
       Type[8]: va_list

       Explanation:

         This   function   works   as  if  you  called  ustr_dupx()  on  the  first  Ustr  string
       (Parameter[2]), and then ustr_add() on the separator (Parameter[1]) followed by ustr_add()
       on  the  second  Ustr  string  (Parameter[3]).  This process then repeats for all the Ustr
       strings in the variable argument list (Parameter[4]) until a USTR_NULL is reached.

       Note:

         This function doesn't guarantee to just take a reference  to  one  of  the  passed  Ustr
       strings, even if that is what would happen if you called the above manually.

     Function:  ustr_sc_joinx()
       Returns: Pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: Size of allocated storage
       Type[1]: size_t

       Parameter[2]: Number of bytes to use for reference count
       Type[2]: size_t

       Parameter[3]: Exact memory allocations
       Type[3]: int

       Parameter[4]: ENOMEM, memory error flag
       Type[4]: int

       Parameter[5]: Separator to go between Ustr strings
       Type[5]: const struct Ustr *

       Parameter[6]: A pointer to the first constant Ustr string
       Type[6]: const struct Ustr *

       Parameter[7]: A pointer to the second constant Ustr string
       Type[7]: const struct Ustr *

       Parameter[8]: Zero or more pointers to constant Ustr strings and then USTR_NULL
       Type[8]: ...

       Explanation:

         This  function  calls  va_start()  to  get  a  variable  argument  list  and  then calls
       ustr_sc_vjoinx().

     Function:  ustr_sc_vconcat()
       Returns: Pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: A pointer to the first constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Variable argument list variable, from va_start()
       Type[2]: va_list

       Explanation:

         This function works as if you called ustr_dup() on the first Ustr string (Parameter[1]),
       and  then  ustr_add()  on the second Ustr string (Parameter[3]). This process then repeats
       for all the Ustr strings in the variable argument list (Parameter[4]) until a USTR_NULL is
       reached.

       Note:

         This  function  doesn't  guarantee  to  just  take a reference to one of the passed Ustr
       strings, even if that is what would happen if you called the above manually.

     Function:  ustr_sc_concat()
       Returns: Pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: A pointer to the first constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Zero or more pointers to constant Ustr strings and then USTR_NULL
       Type[2]: ...

       Explanation:

         This function  calls  va_start()  to  get  a  variable  argument  list  and  then  calls
       ustr_sc_vconcat().

     Function:  ustr_sc_vconcatx()
       Returns: Pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: Size of allocated storage
       Type[1]: size_t

       Parameter[2]: Number of bytes to use for reference count
       Type[2]: size_t

       Parameter[3]: Exact memory allocations
       Type[3]: int

       Parameter[4]: ENOMEM, memory error flag
       Type[4]: int

       Parameter[5]: A pointer to the first constant Ustr string
       Type[5]: const struct Ustr *

       Parameter[6]: Variable argument list variable, from va_start()
       Type[6]: va_list

       Explanation:

         This   function   works   as  if  you  called  ustr_dupx()  on  the  first  Ustr  string
       (Parameter[1]), and then ustr_add() on the second Ustr string (Parameter[3]). This process
       then repeats for all the Ustr strings in the variable argument list (Parameter[4]) until a
       USTR_NULL is reached.

       Note:

         This function doesn't guarantee to just take a reference  to  one  of  the  passed  Ustr
       strings, even if that is what would happen if you called the above manually.

     Function:  ustr_sc_concatx()
       Returns: Pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: Size of allocated storage
       Type[1]: size_t

       Parameter[2]: Number of bytes to use for reference count
       Type[2]: size_t

       Parameter[3]: Exact memory allocations
       Type[3]: int

       Parameter[4]: ENOMEM, memory error flag
       Type[4]: int

       Parameter[5]: A pointer to the first constant Ustr string
       Type[5]: const struct Ustr *

       Parameter[6]: Zero or more pointers to constant Ustr strings and then USTR_NULL
       Type[6]: ...

       Explanation:

         This  function  calls  va_start()  to  get  a  variable  argument  list  and  then calls
       ustr_sc_vconcatx().

Deleting a Ustr, or data within a Ustr

     Function:  ustr_free()
       Returns: Nothing
       Type: void

       Parameter[1]: Pointer to a Ustr
       Type[1]: struct Ustr *

       Explanation:

         This function decrements the reference count on a Ustr, if there is one, and  free's  it
       if it is allocated and the reference count becomes zero.

       Note:

         This function does nothing if passed USTR_NULL.

     Function:  ustrp_free()
       Returns: Nothing
       Type: void

       Parameter[1]: Pointer to a Ustr pool object
       Type[1]: struct Ustr_pool *

       Parameter[2]: Pointer to a Ustrp (pool allocated Ustr)
       Type[2]: struct Ustrp *

       Explanation:

         This  function  works  like  ustr_free()  but calls the pool_free member function of the
       Ustr_pool (Parameter[1]) instead of the ustr system free.

     Function:  ustr_sc_free()
       Returns: Nothing
       Type: void

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Explanation:

         This function calls ustr_free() and then sets the pointer (Parameter[1])  to  USTR_NULL,
       which is a noop when passed to ustr_free(). This can be used to help prevent "double free"
       errors.

       Note:

         While the point to the pointer must be non-NULL, this function also accepts a NULL  ustr
       and  does  nothing.  So  you can pass the same pointer to this function multiple times and
       only the first one will do anything.

     Function:  ustr_sc_free2()
       Returns: Nothing
       Type: void

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Pointer to a Ustr string
       Type[2]: struct Ustr *

       Explanation:

         This  function  works  like  ustr_sc_free()  but  instead   of   setting   the   pointer
       (Parameter[1]) to USTR_NULL it sets it to the Ustr string (Parameter[2]).

       Note:

         While  the point to the pointer must be non-NULL, this function also accepts a NULL ustr
       to be free'd and does nothing. So you can pass the same pointer to ustr_sc_free() and then
       this function safely.
         The  passed  value  (Parameter[2])  shouldn't  be  USTR_NULL,  and in debugging mode the
       function will assert() that it isn't.

     Function:  ustr_sc_free_shared()
       Returns: Nothing
       Type: void

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Explanation:

         This  function  is  a  simple  way  to  "free"  a  Ustr  string  that  has  been  shared
       (ustr_shared()  returns  USTR_TRUE),  normally  ustr_free()  is  ignored  on a shared Ustr
       string. It just calls ustr_setf_owner() and then ustr_sc_free().

     Function:  ustr_del()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Length to delete from the Ustr
       Type[2]: size_t

       Explanation:

         This function deletes data from the end of Ustr, possibly re-sizing the Ustr at the same
       time.

       Note:

         The  Ustr  is  never  re-sized  when the size is stored explicitly, so the pointer never
       changes.

     Function:  ustr_del_subustr()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Position in the Ustr
       Type[2]: size_t

       Parameter[3]: Length to delete from the Ustr
       Type[3]:  size_t

       Explanation:

         This function works like ustr_del() but can delete an arbitrary section of the Ustr.

     Function:  ustr_sc_del()
       Returns: Nothing
       Type: void

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Explanation:

         This function is like calling ustr_del() with ustr_len() as the length, however if  that
       fails it does a ustr_free() and then sets the pointer to USTR("").

       Note:

         While the benifit is that you don't have to check for memory failure errors, if there is
       a memory failure and you have a non-default configuration the  configuration  will  revert
       back to the default.

Adding data to a Ustr

     Function:  ustr_add_undef()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Length of new undefined data
       Type[2]: size_t

       Explanation:

         The  Ustr  string  is  expanded  (possibly  reallocated)  so  that it can contain length
       (Parameter[2]) extra data, if the length is not zero the Ustr will be writable.  Or  it'll
       return USTR_FALSE (zero) on failure.

     Function:  ustr_add_buf()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Pointer to data
       Type[2]: const void *

       Parameter[3]: Length of data
       Type[3]: size_t

       Explanation:

         This  function works as if you had called ustr_add_undef() and then copied the data into
       the new undefined space.

     Function:  ustr_add_cstr()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Pointer to constant C-style string
       Type[2]: const char *

       Explanation:

         This function works as if you had called  ustr_add_buf()  and  passed  strlen()  as  the
       length.

     Function:  USTR_ADD_OSTR()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A constant C-style string
       Type[2]: const char []

       Explanation:

         This  function  works as if you had called ustr_add_buf() and passed sizeof() - 1 as the
       length.

     Function:  USTR_ADD_OBJ()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A symbol
       Type[2]: ...

       Explanation:

         This function works as if you had called  ustr_add_buf()  and  passed  sizeof()  as  the
       length.

       Note:

         In most cases you'll want to use USTR_ADD_OSTR().

     Function:  ustr_add()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A pointer to a constant Ustr string
       Type[2]: const struct Ustr *

       Explanation:

         This  function mostly works as if you had called ustr_add_buf() with the ustr_cstr() and
       ustr_len() values of the Ustr string to be added.

       Note:

         If the Ustr string is zero length and isn't  writable  this  function  may  just  add  a
       reference,  this  is  fine  for  Ustr  strings  that are "constant" because if the Ustr is
       read-only then the memory will not be written to.

     Function:  ustr_add_subustr()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A pointer to a constant Ustr string
       Type[2]: const struct Ustr *

       Parameter[3]: Position in the Ustr
       Type[3]: size_t

       Parameter[4]: Length to add from the Ustr
       Type[4]: size_t

       Explanation:

         This function mostly works as if you had called ustr_add_buf() with  the  ustr_cstr()  +
       position  - 1 and length values of the Ustr string to be added. The exception being if you
       add a ustr to itself, while only having a single reference count, the simple method  would
       access a free'd ustr, but this function just works.

       Note:

         If  the position is 1 and the length is the length of the Ustr string then it just calls
       ustr_add().

     Function:  ustr_add_rep_chr()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Byte value of data
       Type[2]: char

       Parameter[3]: Length of bytes as data
       Type[3]: size_t

       Explanation:

         This function works as if you had called ustr_add_undef() and then copied the byte value
       to each position.

Setting a Ustr to some data

     Function:  ustr_set_undef()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]:  size_t
       Type[2]:  size_t

       Explanation:

         This  function  works  as  if  you  had  called ustr_del() for the entire string and the
       ustr_add_undef().

     Function:  ustr_set_empty()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Explanation:

         This function works as if you had called ustr_del() for the entire string,  however  the
       string will be allocated if this completes.

     Function:  ustr_set_buf()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Buffer containting data
       Type[2]:  const void *

       Parameter[3]: Length of Buffer
       Type[3]: size_t

       Explanation:

         This  function  works  as  if  you  had  called ustr_del() for the entire string and the
       ustr_add_buf().

     Function:  ustr_set_cstr()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A pointer to a constant C-style string
       Type[2]: const char *

       Explanation:

         This function works as if you had called ustr_del()  for  the  entire  string  and  then
       ustr_add_cstr().

     Function:  USTR_SET_OSTR()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A constant C-style string
       Type[2]: const char []

       Explanation:

         This  function  works  as  if  you  had called ustr_del() for the entire string and then
       USTR_ADD_OSTR().

     Function:  USTR_SET_OBJ()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A symbol
       Type[2]: ...

       Explanation:

         This function works as if you had called ustr_del()  for  the  entire  string  and  then
       USTR_ADD_OBJ().

       Note:

         In most cases you'll want to use USTR_SET_OSTR().

     Function:  ustr_set()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A pointer to a constant Ustr string
       Type[2]: const struct Ustr *

       Explanation:

         This  function  works  as  if  you  had  called ustr_del() for the entire string and the
       ustr_add().

     Function:  ustr_set_subustr()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A pointer to a constant Ustr string
       Type[2]: const struct Ustr *

       Parameter[3]: Position in the Ustr
       Type[3]: size_t

       Parameter[4]: Length to set from the Ustr
       Type[4]: size_t

       Explanation:

         This function works as if you had called  ustr_del()  for  the  entire  string  and  the
       ustr_add_subustr().  The  exception being if you set a ustr to itself, while only having a
       single reference count, the simple method would  access  a  free'd  ustr  data,  but  this
       function just works.

     Function:  ustr_set_rep_chr()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Byte value of data
       Type[2]: char

       Parameter[3]: Length of bytes as data
       Type[3]: size_t

       Explanation:

         This  function  works  as  if  you  had  called ustr_del() for the entire string and the
       ustr_add_rep_chr().

Inserting data into a Ustr

     Function:  ustr_ins_undef()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Position after which the data should be added
       Type[2]: size_t

       Parameter[3]: Length of new undefined data
       Type[3]: size_t

       Explanation:

         The Ustr string is expanded  (possibly  reallocated)  so  that  it  can  contain  length
       (Parameter[2]) extra data, from after the required position. If the length is not zero the
       Ustr will be writable. Or it'll return USTR_FALSE (zero) on failure. The data in the  Ustr
       is moved as needed to put the new data at position (Parameter[2]) + 1.

     Function:  ustr_ins_buf()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Position after which the data should be added
       Type[2]: size_t

       Parameter[3]: Pointer to data
       Type[3]: const void *

       Parameter[4]: Length of data
       Type[4]: size_t

       Explanation:

         This  function works as if you had called ustr_ins_undef() and then copied the data into
       the new undefined space.

     Function:  ustr_ins_cstr()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Position after which the data should be added
       Type[2]: size_t

       Parameter[3]: Pointer to constant C-style string
       Type[3]: const char *

       Explanation:

         This function works as if you had called  ustr_ins_buf()  and  passed  strlen()  as  the
       length.

     Function:  USTR_INS_OSTR()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Position after which the data should be added
       Type[2]: size_t

       Parameter[3]: A constant C-style string
       Type[3]: const char []

       Explanation:

         This  function  works as if you had called ustr_ins_buf() and passed sizeof() - 1 as the
       length.

     Function:  USTR_INS_OBJ()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Position after which the data should be added
       Type[2]: size_t

       Parameter[3]: A symbol
       Type[3]: ...

       Explanation:

         This function works as if you had called  ustr_ins_buf()  and  passed  sizeof()  as  the
       length.

       Note:

         In most cases you'll want to use USTR_INS_OSTR().

     Function:  ustr_ins()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Position after which the data should be added
       Type[2]: size_t

       Parameter[3]: A pointer to a constant Ustr string
       Type[3]: const struct Ustr *

       Explanation:

         This  function  works  as  if  you  had  called  ustr_ins_buf() with the ustr_cstr() and
       ustr_len() values of the Ustr string to be added.

     Function:  ustr_ins_subustr()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Position after which the data should be added
       Type[2]: size_t

       Parameter[2]: A pointer to a constant Ustr string
       Type[2]: const struct Ustr *

       Parameter[3]: Position in the Ustr
       Type[3]: size_t

       Parameter[4]: Length to ins from the Ustr
       Type[4]: size_t

       Explanation:

         This function mostly as if you had called ustr_ins_buf() with the ustr_cstr() + position
       -  1 and length values of the Ustr string to be insed. The exception being if you insert a
       ustr to itself, while only having a single reference count, the simple method would access
       a free'd ustr data, but this function just works.

     Function:  ustr_ins_rep_chr()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Position after which the data should be added
       Type[2]: size_t

       Parameter[2]: Byte value of data
       Type[2]: char

       Parameter[3]: Length of bytes as data
       Type[3]: size_t

       Explanation:

         This function works as if you had called ustr_ins_undef() and then copied the byte value
       to each position.

Adding, duplicating and setting formatted data to a Ustr

     Function:  ustr_add_vfmt_lim()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Limit of data to add
       Type[2]: size_t

       Parameter[3]: A pointer to a constant C-style string
       Type[3]: const char *

       Parameter[4]: Variable argument list variable, from va_start()
       Type[4]: va_list

       Explanation:

         This function works like calling the system vsnprintf() with the limit (Parameter[2]) as
       the limit to vsnprintf() and then calling ustr_add_buf().

     Function:  ustr_add_vfmt()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A pointer to a constant C-style string
       Type[2]: const char *

       Parameter[3]: Variable argument list variable, from va_start()
       Type[3]: va_list

       Explanation:

         This function works like calling the system vsnprintf() and then calling ustr_add_buf().

     Function:  ustr_add_fmt_lim()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Limit of data to add
       Type[2]: size_t

       Parameter[3]: A pointer to a constant C-style string
       Type[3]: const char *

       Parameter[4]: Options depending on value of Parameter[3]
       Type[4]: ...

       Explanation:

         This  function works like calling the system snprintf() with the limit (Parameter[2]) as
       the limit to snprintf() and then calling ustr_add_buf().

     Function:  ustr_add_fmt()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A pointer to a constant C-style string
       Type[2]: const char *

       Parameter[3]: Options depending on value of Parameter[2]
       Type[3]: ...

       Explanation:

         This function works like calling the system snprintf() and then calling ustr_add_buf().

     Function:  ustr_dup_vfmt_lim()
       Returns: Pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: Limit of data to dup
       Type[1]: size_t

       Parameter[2]: Pointer to a constant Ustr string
       Type[2]: const char *

       Parameter[3]: Variable argument list variable, from va_start()
       Type[3]: va_list

       Explanation:

         This function works like calling the system vsnprintf() with the limit (Parameter[2]) as
       the limit to vsnprintf() and then calling ustr_dup_buf().

     Function:  ustr_dup_vfmt()
       Returns: Pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: Limit of data to dup
       Type[1]: size_t

       Parameter[2]: Pointer to a constant Ustr string
       Type[2]: const char *

       Parameter[3]: Variable argument list variable, from va_start()
       Type[3]: va_list

       Explanation:

         This function works like calling the system vsnprintf() and then calling ustr_dup_buf().

     Function:  ustr_dup_fmt_lim()
       Returns: Pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: Limit of data to dup
       Type[1]: size_t

       Parameter[2]: Pointer to a constant Ustr string
       Type[2]: const char *

       Parameter[3]: Options depending on value of Parameter[2]
       Type[3]: ...

       Explanation:

         This  function works like calling the system snprintf() with the limit (Parameter[2]) as
       the limit to snprintf() and then calling ustr_dup_buf().

     Function:  ustr_dup_fmt()
       Returns: Pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: Pointer to a constant Ustr string
       Type[1]: const char *

       Parameter[2]: Options depending on value of Parameter[1]
       Type[2]: ...

       Explanation:

         This function works like calling the system snprintf() and then calling ustr_dup_buf().

     Function:  ustr_dupx_fmt_lim()
       Returns: Pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: Size of allocated storage
       Type[1]: size_t

       Parameter[2]: Number of bytes to use for reference count
       Type[2]: size_t

       Parameter[3]: Exact memory allocations
       Type[3]: int

       Parameter[4]: ENOMEM, memory error flag
       Type[4]: int

       Parameter[5]: Limit of data to dup
       Type[5]: size_t

       Parameter[6]: Pointer to a constant Ustr string
       Type[6]: const char *

       Parameter[7]: Options depending on value of Parameter[6]
       Type[7]: ...

       Explanation:

         This function works like calling the system snprintf() with the limit (Parameter[2])  as
       the limit to snprintf() and then calling ustr_dupx_buf().

     Function:  ustr_dupx_fmt()
       Returns: Pointer to a Ustr string
       Type: struct Ustr *

       Parameter[1]: Size of allocated storage
       Type[1]: size_t

       Parameter[2]: Number of bytes to use for reference count
       Type[2]: size_t

       Parameter[3]: Exact memory allocations
       Type[3]: int

       Parameter[4]: ENOMEM, memory error flag
       Type[4]: int

       Parameter[5]: Pointer to a constant Ustr string
       Type[5]: const char *

       Parameter[6]: Options depending on value of Parameter[5]
       Type[6]: ...

       Explanation:

         This function works like calling the system snprintf() and then calling ustr_dup_bufx().

     Function:  ustr_set_vfmt_lim()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Limit of data to set
       Type[2]: size_t

       Parameter[3]: A pointer to a constant C-style string
       Type[3]: const char *

       Parameter[4]: Variable argument list variable, from va_start()
       Type[4]: va_list

       Explanation:

         This   function   works   like   calling   ustr_del()   for   all   the  data  and  then
       ustr_add_vfmt_lim().

     Function:  ustr_set_vfmt()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A pointer to a constant C-style string
       Type[2]: const char *

       Parameter[3]: Variable argument list variable, from va_start()
       Type[3]: va_list

       Explanation:

         This function works like calling ustr_del() for all the data and then ustr_add_vfmt().

     Function:  ustr_set_fmt_lim()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Limit of data to set
       Type[2]: size_t

       Parameter[3]: A pointer to a constant C-style string
       Type[3]: const char *

       Parameter[4]: Options depending on value of Parameter[3]
       Type[4]: ...

       Explanation:

         This  function  works  like   calling   ustr_del()   for   all   the   data   and   then
       ustr_add_fmt_lim().

     Function:  ustr_set_fmt()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A pointer to a constant C-style string
       Type[2]: const char *

       Parameter[3]: Options depending on value of Parameter[2]
       Type[3]: ...

       Explanation:

         This function works like calling ustr_del() for all the data and then ustr_add_fmt().

     Function:  ustr_ins_vfmt_lim()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Position after which the data should be added
       Type[2]: size_t

       Parameter[3]: Limit of data to insert
       Type[3]: size_t

       Parameter[4]: A pointer to a constant C-style string
       Type[4]: const char *

       Parameter[5]: Variable argument list variable, from va_start()
       Type[5]: va_list

       Explanation:

         This function works like calling the system vsnprintf() with the limit (Parameter[3]) as
       the limit to vsnprintf() and then calling ustr_ins_buf().

     Function:  ustr_ins_vfmt()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Position after which the data should be added
       Type[2]: size_t

       Parameter[3]: A pointer to a constant C-style string
       Type[3]: const char *

       Parameter[4]: Variable argument list variable, from va_start()
       Type[4]: va_list

       Explanation:

         This function works like calling the system vsnprintf() and then calling ustr_ins_buf().

     Function:  ustr_ins_fmt_lim()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Position after which the data should be added
       Type[2]: size_t

       Parameter[3]: Limit of data to insert
       Type[3]: size_t

       Parameter[4]: A pointer to a constant C-style string
       Type[4]: const char *

       Parameter[5]: Options depending on value of Parameter[4]
       Type[5]: ...

       Explanation:

         This function works like calling the system snprintf() with the limit (Parameter[3])  as
       the limit to snprintf() and then calling ustr_ins_buf().

     Function:  ustr_ins_fmt()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Position after which the data should be added
       Type[2]: size_t

       Parameter[3]: A pointer to a constant C-style string
       Type[3]: const char *

       Parameter[4]: Options depending on value of Parameter[3]
       Type[4]: ...

       Explanation:

         This function works like calling the system snprintf() and then calling ustr_ins_buf().

     Function:  ustr_sub_vfmt_lim()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Position where to start substitution
       Type[2]: size_t

       Parameter[3]: Limit of data to substitute
       Type[3]: size_t

       Parameter[4]: A pointer to a constant C-style string
       Type[4]: const char *

       Parameter[5]: Variable argument list variable, from va_start()
       Type[5]: va_list

       Explanation:

         This function works like calling the system vsnprintf() with the limit (Parameter[3]) as
       the limit to vsnprintf() and then calling ustr_sub_buf().

     Function:  ustr_sub_vfmt()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Position where to start substitution
       Type[2]: size_t

       Parameter[3]: A pointer to a constant C-style string
       Type[3]: const char *

       Parameter[4]: Variable argument list variable, from va_start()
       Type[4]: va_list

       Explanation:

         This function works like calling the system vsnprintf() and then calling ustr_sub_buf().

     Function:  ustr_sub_fmt_lim()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Position where to start substitution
       Type[2]: size_t

       Parameter[3]: Limit of data to substitute
       Type[3]: size_t

       Parameter[4]: A pointer to a constant C-style string
       Type[4]: const char *

       Parameter[5]: Options depending on value of Parameter[4]
       Type[5]: ...

       Explanation:

         This function works like calling the system snprintf() with the limit (Parameter[3])  as
       the limit to snprintf() and then calling ustr_sub_buf().

     Function:  ustr_sub_fmt()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Position where to start substitution
       Type[2]: size_t

       Parameter[3]: A pointer to a constant C-style string
       Type[3]: const char *

       Parameter[4]: Options depending on value of Parameter[3]
       Type[4]: ...

       Explanation:

         This function works like calling the system snprintf() and then calling ustr_sub_buf().

     Function:  ustr_sc_sub_vfmt_lim()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Position where to start substitution
       Type[2]: size_t

       Parameter[3]: Length of substitution
       Type[3]: size_t

       Parameter[4]: Limit of data to substitute
       Type[4]: size_t

       Parameter[5]: A pointer to a constant C-style string
       Type[5]: const char *

       Parameter[6]: Variable argument list variable, from va_start()
       Type[6]: va_list

       Explanation:

         This function works like calling the system vsnprintf() with the limit (Parameter[4]) as
       the limit to vsnprintf() and then calling ustr_sc_sub_buf().

     Function:  ustr_sc_sub_vfmt()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Position where to start substitution
       Type[2]: size_t

       Parameter[3]: Length of substitution
       Type[3]: size_t

       Parameter[4]: A pointer to a constant C-style string
       Type[4]: const char *

       Parameter[5]: Variable argument list variable, from va_start()
       Type[5]: va_list

       Explanation:

         This  function  works  like  calling   the   system   vsnprintf()   and   then   calling
       ustr_sc_sub_buf().

     Function:  ustr_sc_sub_fmt_lim()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Position where to start substitution
       Type[2]: size_t

       Parameter[3]: Length of substitution
       Type[3]: size_t

       Parameter[4]: Limit of data to substitute
       Type[4]: size_t

       Parameter[5]: A pointer to a constant C-style string
       Type[5]: const char *

       Parameter[6]: Options depending on value of Parameter[5]
       Type[6]: ...

       Explanation:

         This  function works like calling the system snprintf() with the limit (Parameter[3]) as
       the limit to snprintf() and then calling ustr_sc_sub_buf().

     Function:  ustr_sc_sub_fmt()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Position where to start substitution
       Type[2]: size_t

       Parameter[3]: Length of substitution
       Type[3]: size_t

       Parameter[4]: A pointer to a constant C-style string
       Type[4]: const char *

       Parameter[5]: Options depending on value of Parameter[5]
       Type[5]: ...

       Explanation:

         This  function  works  like   calling   the   system   snprintf()   and   then   calling
       ustr_sc_sub_buf().

Accessing the variables of a Ustr

     Function:  ustr_len()
       Returns: The length of the Ustr
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Explanation:

         This  function  returns  the  length of the data within the Ustr, much like strlen() but
       without getting the value wrong in the case of extra NIL bytes.

     Function:  ustr_cstr()
       Returns: Read-only pointer to the start of data in the Ustr
       Type: const char *

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Explanation:

         This function returns a read-only pointer to the start of the data of the  Ustr  string.
       Due  to  there always being a terminating NIL byte in a Ustr, this is also a valid C-style
       string.

     Function:  ustr_wstr()
       Returns: Writable pointer to the start of data in the Ustr, or NULL
       Type: char *

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: struct Ustr *

       Explanation:

         This function returns a writable pointer to the start of the data of  the  Ustr  string.
       Due  to  there always being a terminating NIL byte in a Ustr, this is also a valid C-style
       string.
         If the ustr is read-only (ustr_ro() == USTR_TRUE) then this function will return NULL.

       Note:

         Unless the string is owned (ustr_owner() == USTR_TRUE) it can be a very bad idea to  use
       this to change data, as then all references will be updated. See ustr_sc_wstr().

     Function:  ustr_alloc()
       Returns: A boolean flag of either USTR_TRUE or USTR_FALSE
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Explanation:

         This function says if the Ustr is currently in allocated storage.

     Function:  ustr_exact()
       Returns: A boolean flag of either USTR_TRUE or USTR_FALSE
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Explanation:

         This  function says if the Ustr is doing exact allocations, so as the Ustr grows it will
       only have storage allocated exactly as required and not in half powers of two.

       Note:

         This will always be USTR_FALSE for read-only Ustr strings (ustr_ro() == USTR_TRUE), even
       though the default may be to used exact sized allocations when  adding data to them etc.

     Function:  ustr_sized()
       Returns: A boolean flag of either USTR_TRUE or USTR_FALSE
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Explanation:

         This  function  says  if the Ustr stores an explicit allocation size, if not the size is
       implied as the next highest half power of two.

     Function:  ustr_ro()
       Returns: A boolean flag of either USTR_TRUE or USTR_FALSE
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Explanation:

         This function says if the Ustr is current in read-only storage.
         Read-only storage is not writable but can be  referenced  via.  ustr_dup()  an  infinite
       amount of times.

     Function:  ustr_fixed()
       Returns: A boolean flag of either USTR_TRUE or USTR_FALSE
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Explanation:

         This function says if the Ustr is current in fixed size storage.
         Fixed size storage is writable but cannot be referenced.

       Note:

         Fixed size storage always explicitly stores the size of the storage.

     Function:  ustr_enomem()
       Returns: A boolean flag of either USTR_TRUE or USTR_FALSE
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Explanation:

         This  function  just  returns the value of the user settable flag in the Ustr. It can be
       set via. ustr_setf_enomem_err() and cleared by ustr_setf_enomem_clr().
         This function is automatically set to on whever a memory allocation failure happens  for
       a Ustr.

       Note:

         If a Ustr is referenced multiple times, ustr_setf_enomem_err() will fail.
         This always fails for Ustr's in read-only storage.

     Function:  ustr_shared()
       Returns: A boolean flag of either USTR_TRUE or USTR_FALSE
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Explanation:

         This  function  says  if  the  Ustr  is  in  the  "shared"  mode.  It  can  be  set via.
       ustr_setf_shared() and cleared by ustr_setf_owner() on allocated Ustr's.
         Shared mode means that a Ustr can be referenced and unreferenced an infinite  number  of
       times.

       Note:

         This always succeeds for Ustr's in read-only storage.
         This always fails for Ustr's in fixed size storage.

     Function:  ustr_limited()
       Returns: A boolean flag of either USTR_TRUE or USTR_FALSE
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Explanation:

         This  function  says  if  the Ustr is currently in fixed size storage and cannot move to
       allocated storage.

       Note:

         This always fails for Ustr's in allocated storage.
         This always fails for Ustr's in read-only storage.

     Function:  ustr_owner()
       Returns: A boolean flag of either USTR_TRUE or USTR_FALSE
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Explanation:

         This function says if there is only a single reference to the Ustr string.

       Note:

         This always fails for Ustr's in read-only storage.
         This always succeeds for Ustr's in fixed size storage.

     Function:  ustr_size()
       Returns: size_t
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Explanation:

         This function calculates the maximum amount of data that could be stored  (Ie.  the  max
       ustr_len()) without having to re-size the Ustr string.

     Function:  ustr_size_alloc()
       Returns: size_t
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Explanation:

         This function returns the size of the storage for the Ustr.

     Function:  ustr_size_overhead()
       Returns: size_t
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Explanation:

         This  function  returns  the  difference between the size of the storage and the maximum
       amount of data that could be stored without having to re-size the Ustr string.

     Function:  ustr_conf()
       Returns: Nothing
       Type: void

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Return size allocated number
       Type[2]: size_t *

       Parameter[3]: Return number of bytes used in the reference count
       Type[3]: size_t *

       Parameter[4]: Return exact allocations flag
       Type[4]: int *

       Parameter[5]: Return number of bytes used in the length
       Type[5]: size_t *

       Parameter[5]: Return number of references to this Ustr
       Type[5]: size_t *

       Explanation:

         This function gives the configuration of the current Ustr needed to  duplicate  it  via.
       the ustr_dupx_*() functions. It also gives the number of bytes used for the length and the
       number of references, which are mainly informational.

       Note:

         This function differs from calling the ustr_exact() etc. functions in  that  it  returns
       the  global  options if this Ustr isn't allocated, thus telling you what the configuration
       would be if the Ustr was turned into an allocated Ustr by adding data etc.
         Zero references for an allocated Ustr with a non-zero number of bytes  for  a  reference
       count means it's in "shared" mode).

Setting the flags of a Ustr

     Function:  ustr_setf_enomem_err()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a Ustr string
       Type[1]: struct Ustr *

       Explanation:

         This  function  sets  the  enomem  flag,  which  can  be observed via. the ustr_enomem()
       function.
         The implication of setting this flag is that a memory error has occured  in  a  previous
       function call on this Ustr.

       Note:

         This function fails if ustr_owner() fails for the Ustr.

     Function:  ustr_setf_enomem_clr()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a Ustr string
       Type[1]: struct Ustr *

       Explanation:

         This  function  clears  the  enomem  flag,  which can be observed via. the ustr_enomem()
       function.
         The implication of this flag being set is that a memory error has occured in a  previous
       function  call  on this Ustr, so on clearing the flag you should know you have brought the
       Ustr back to a known state.

       Note:

         This function fails if ustr_owner() fails for the Ustr.

     Function:  ustr_setf_share()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a Ustr string
       Type[1]: struct Ustr *

       Explanation:

         This function sets the shared  mode,  which  can  be  observed  via.  the  ustr_shared()
       function.
         This  is  used  on a Ustr so that it can have more references than it is able to hold in
       it's reference count. After this call the Ustr  can  be  referenced  and  unreferenced  an
       infinite number of times.

       Note:

         After this call the Ustr will never be deleted until ustr_setf_owner() is called.
         This function fails if ustr_alloc() fails for the Ustr.

     Function:  ustr_setf_owner()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a Ustr string
       Type[1]: struct Ustr *

       Explanation:

         This  function  removes  the  shared  mode, which can be observed via. the ustr_shared()
       function.
         This is used so that a Ustr in shared mode can be free'd.

       Note:

         This function fails if ustr_alloc() fails for the Ustr.

Comparing data in a Ustr

     Function:  ustr_cmp_buf()
       Returns: Less then zero, zero or greater than zero depending on comparison
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to constant bytes, to compare
       Type[2]: const void *

       Parameter[3]: Length of comparison bytes
       Type[3]: size_t

       Explanation:

         This function works like memcmp() on the Ustr and the passed data.

     Function:  ustr_cmp()
       Returns: Less then zero, zero or greater than zero depending on comparison
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to a constant Ustr string
       Type[2]: const struct Ustr *

       Explanation:

         This function works like ustr_cmp_buf() but with  the  data  from  ustr_cstr()  and  the
       length from ustr_len().

     Function:  ustr_cmp_subustr()
       Returns: Less then zero, zero or greater than zero depending on comparison
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to a constant Ustr string
       Type[2]: const struct Ustr *

       Parameter[3]: Position in the Ustr
       Type[3]: size_t

       Parameter[4]: Length to compare from the Ustr
       Type[4]: size_t

       Explanation:

         This function works like ustr_cmp() but with a limit on the data and length.

     Function:  ustr_cmp_cstr()
       Returns: Less then zero, zero or greater than zero depending on comparison
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to a constant C-style string
       Type[2]: const char *

       Explanation:

         This function works like ustr_cmp_buf() but with a length from strlen().

     Function:  ustr_cmp_fast_buf()
       Returns: Less then zero, zero or greater than zero depending on comparison
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to constant bytes, to compare
       Type[2]: const void *

       Parameter[3]: Length of comparison bytes
       Type[3]: size_t

       Explanation:

         This  function  works  like  ustr_cmp_buf() but the order of comparison is optimized for
       speed, but is much less friendly to humans.

     Function:  ustr_cmp_fast()
       Returns: Less then zero, zero or greater than zero depending on comparison
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to a constant Ustr string
       Type[2]: const struct Ustr *

       Explanation:

         This function works like ustr_cmp_fast_buf() but with the data from ustr_cstr() and  the
       length from ustr_len().

     Function:  ustr_cmp_fast_subustr()
       Returns: Less then zero, zero or greater than zero depending on comparison
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to a constant Ustr string
       Type[2]: const struct Ustr *

       Parameter[3]: Position in the Ustr
       Type[3]: size_t

       Parameter[4]: Length to compare from the Ustr
       Type[4]: size_t

       Explanation:

         This function works like ustr_cmp_fast() but with a limit on the data and length.

     Function:  ustr_cmp_fast_cstr()
       Returns: Less then zero, zero or greater than zero depending on comparison
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to a constant C-style string
       Type[2]: const char *

       Explanation:

         This function works like ustr_cmp_fast_buf() but with a length from strlen().

     Function:  ustr_cmp_case_buf()
       Returns: Less then zero, zero or greater than zero depending on comparison
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to constant bytes, to compare
       Type[2]: const void *

       Parameter[3]: Length of comparison bytes
       Type[3]: size_t

       Explanation:

         This function works like ustr_cmp_buf() but the order of comparison ignores ASCII case.

     Function:  ustr_cmp_case()
       Returns: Less then zero, zero or greater than zero depending on comparison
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to a constant Ustr string
       Type[2]: const struct Ustr *

       Explanation:

         This  function works like ustr_cmp_case_buf() but with the data from ustr_cstr() and the
       length from ustr_len().

     Function:  ustr_cmp_case_subustr()
       Returns: Less then zero, zero or greater than zero depending on comparison
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to a constant Ustr string
       Type[2]: const struct Ustr *

       Parameter[3]: Position in the Ustr
       Type[3]: size_t

       Parameter[4]: Length to compare from the Ustr
       Type[4]: size_t

       Explanation:

         This function works like ustr_cmp_case() but with a limit on the data and length.

     Function:  ustr_cmp_case_cstr()
       Returns: Less then zero, zero or greater than zero depending on comparison
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to a constant C-style string
       Type[2]: const char *

       Explanation:

         This function works like ustr_cmp_case_buf() but with a length from strlen().

     Function:  ustr_cmp_eq()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to a constant Ustr string
       Type[2]: const struct Ustr *

       Explanation:

         This function works like comparing ustr_cmp() against 0.

     Function:  ustr_cmp_buf_eq()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to constant bytes, to compare
       Type[2]: const void *

       Parameter[3]: Length of comparison bytes
       Type[3]: size_t

       Explanation:

         This function works like comparing ustr_cmp_buf() against 0.

     Function:  ustr_cmp_subustr_eq()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to a constant Ustr string
       Type[2]: const struct Ustr *

       Parameter[3]: Position in the Ustr
       Type[3]: size_t

       Parameter[4]: Length to compare from the Ustr
       Type[4]: size_t

       Explanation:

         This function works like comparing ustr_cmp_subustr() against 0.

     Function:  ustr_cmp_cstr_eq()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to a constant C-style string
       Type[2]: const char *

       Explanation:

         This function works like comparing ustr_cmp_cstr() against 0.

     Function:  ustr_cmp_case_eq()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to a constant Ustr string
       Type[2]: const struct Ustr *

       Explanation:

         This function works like comparing ustr_cmp_case() against 0.

     Function:  ustr_cmp_case_buf_eq()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to constant bytes, to compare
       Type[2]: const void *

       Parameter[3]: Length of comparison bytes
       Type[3]: size_t

       Explanation:

         This function works like comparing ustr_cmp_case_buf() against 0.

     Function:  ustr_cmp_case_subustr_eq()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to a constant Ustr string
       Type[2]: const struct Ustr *

       Parameter[3]: Position in the Ustr
       Type[3]: size_t

       Parameter[4]: Length to compare from the Ustr
       Type[4]: size_t

       Explanation:

         This function works like comparing ustr_cmp_case_subustr() against 0.

     Function:  ustr_cmp_case_cstr_eq()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to a constant C-style string
       Type[2]: const char *

       Explanation:

         This function works like comparing ustr_cmp_case_cstr() against 0.

     Function:  ustr_cmp_prefix_eq()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to a constant Ustr string
       Type[2]: const struct Ustr *

       Explanation:

         This function works like comparing ustr_cmp() against 0, but the comparison  is  limited
       to the length of the right hand side.

     Function:  ustr_cmp_prefix_buf_eq()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to constant bytes, to compare
       Type[2]: const void *

       Parameter[3]: Length of comparison bytes
       Type[3]: size_t

       Explanation:

         This  function  works  like  comparing  ustr_cmp_buf()  against 0, but the comparison is
       limited to the length of the right hand side (Parameter[3]).

     Function:  ustr_cmp_prefix_cstr_eq()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to a constant C-style string
       Type[2]: const char *

       Explanation:

         This function works like comparing ustr_cmp_cstr() against  0,  but  the  comparison  is
       limited to the length of the right hand side.

     Function:  ustr_cmp_prefix_subustr_eq()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to a constant Ustr string
       Type[2]: const struct Ustr *

       Parameter[3]: Position in the Ustr
       Type[3]: size_t

       Parameter[4]: Length to compare from the Ustr
       Type[4]: size_t

       Explanation:

         This  function  works like comparing ustr_cmp_subustr() against 0, but the comparison is
       limited to the given length (Parameter[4]).

     Function:  ustr_cmp_case_prefix_eq()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to a constant Ustr string
       Type[2]: const struct Ustr *

       Explanation:

         This function works like comparing ustr_cmp_case() against  0,  but  the  comparison  is
       limited to the length of the right hand side.

     Function:  ustr_cmp_case_prefix_buf_eq()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to constant bytes, to compare
       Type[2]: const void *

       Parameter[3]: Length of comparison bytes
       Type[3]: size_t

       Explanation:

         This  function works like comparing ustr_cmp_case_buf() against 0, but the comparison is
       limited to the length of the right hand side (Parameter[3]).

     Function:  ustr_cmp_case_prefix_cstr_eq()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to a constant C-style string
       Type[2]: const char *

       Explanation:

         This function works like comparing ustr_cmp_case_cstr() against 0, but the comparison is
       limited to the length of the right hand side.

     Function:  ustr_cmp_case_prefix_subustr_eq()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to a constant Ustr string
       Type[2]: const struct Ustr *

       Parameter[3]: Position in the Ustr
       Type[3]: size_t

       Parameter[4]: Length to compare from the Ustr
       Type[4]: size_t

       Explanation:

         This function works like comparing ustr_cmp_case_subustr() against 0, but the comparison
       is limited to the given length (Parameter[4]).

     Function:  ustr_cmp_suffix_eq()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to a constant Ustr string
       Type[2]: const struct Ustr *

       Explanation:

         This function works like ustr_cmp_prefix_eq() but compares the  end  of  the  left  hand
       side.

     Function:  ustr_cmp_suffix_buf_eq()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to constant bytes, to compare
       Type[2]: const void *

       Parameter[3]: Length of comparison bytes
       Type[3]: size_t

       Explanation:

         This  function works like ustr_cmp_prefix_buf_eq() but compares the end of the left hand
       side.

     Function:  ustr_cmp_suffix_cstr_eq()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to a constant C-style string
       Type[2]: const char *

       Explanation:

         This function works like ustr_cmp_prefix_cstr_eq() but compares the end of the left hand
       side.

     Function:  ustr_cmp_suffix_subustr_eq()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to a constant Ustr string
       Type[2]: const struct Ustr *

       Parameter[3]: Position in the Ustr
       Type[3]: size_t

       Parameter[4]: Length to compare from the Ustr
       Type[4]: size_t

       Explanation:

         This function works like comparing ustr_cmp_subustr() against 0, but compares the end of
       the left hand side.

     Function:  ustr_cmp_case_suffix_eq()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to a constant Ustr string
       Type[2]: const struct Ustr *

       Explanation:

         This function works like ustr_cmp_case_prefix_eq() but compares the end of the left hand
       side.

     Function:  ustr_cmp_case_suffix_buf_eq()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to constant bytes, to compare
       Type[2]: const void *

       Parameter[3]: Length of comparison bytes
       Type[3]: size_t

       Explanation:

         This  function works like ustr_cmp_case_prefix_buf_eq() but compares the end of the left
       hand side.

     Function:  ustr_cmp_case_suffix_cstr_eq()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to a constant C-style string
       Type[2]: const char *

       Explanation:

         This function works like ustr_cmp_case_prefix_cstr_eq() but compares the end of the left
       hand side.

     Function:  ustr_cmp_case_suffix_subustr_eq()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: A pointer to a constant Ustr string
       Type[2]: const struct Ustr *

       Parameter[3]: Position in the Ustr
       Type[3]: size_t

       Parameter[4]: Length to compare from the Ustr
       Type[4]: size_t

       Explanation:

         This  function  works like comparing ustr_cmp_case_subustr() against 0, but compares the
       end of the left hand side.

Searching for data in a Ustr

     Function:  ustr_srch_chr_fwd()
       Returns: Position in the Ustr, or zero if not found
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start searching at
       Type[2]: size_t

       Parameter[3]: Byte data to search for
       Type[3]: char

       Explanation:

         This function searches for the data (Parameter[3])  in  the  Ustr,  skipping  an  offset
       (Parameter[2]) number of bytes.

     Function:  ustr_srch_chr_rev()
       Returns: Position in the Ustr, or zero if not found
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start searching at
       Type[2]: size_t

       Parameter[3]: Byte data to search for
       Type[3]: char

       Explanation:

         This  function works like ustr_srch_chr_fwd() but it searches from the end of the string
       to the beginning.

       Note:

         The searching starts from the end of the string, and so the offset is  the  offset  from
       the  end.  However  the  position of a byte is always relative to the begining, so to do a
       loop you need to take the position from the length.

     Function:  ustr_srch_buf_fwd()
       Returns: Position in the Ustr, or zero if not found
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start searching at
       Type[2]: size_t

       Parameter[3]: A pointer to data to search for
       Type[3]: const void *

       Parameter[4]: Length of the data to search for
       Type[4]: size_t

       Explanation:

         This function searches for the data (Parameter[3]) of length (Parameter[4]) in the Ustr,
       skipping an offset (Parameter[2]) number of bytes.

     Function:  ustr_srch_buf_rev()
       Returns: Position in the Ustr, or zero if not found
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start searching at
       Type[2]: size_t

       Parameter[3]: A pointer to data to search for
       Type[3]: const void *

       Parameter[4]: Length of the data to search for
       Type[4]: size_t

       Explanation:

         This  function works like ustr_srch_buf_fwd() but it searches from the end of the string
       to the beginning.

       Note:

         The searching starts from the end of the string, and so the offset is  the  offset  from
       the  end.  However  the  position of a byte is always relative to the begining, so to do a
       loop you need to take the position from the length.

     Function:  ustr_srch_fwd()
       Returns: Position in the Ustr, or zero if not found
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start searching at
       Type[2]: size_t

       Parameter[3]: A pointer to a constant Ustr string, to search for
       Type[3]: const struct Ustr *

       Explanation:

         This function works like ustr_srch_buf_fwd() but it gets the  data  pointer  by  calling
       ustr_cstr() and the length by calling ustr_len() on the passed Ustr (Parameter[3]).

     Function:  ustr_srch_rev()
       Returns: Position in the Ustr, or zero if not found
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start searching at
       Type[2]: size_t

       Parameter[3]: A pointer to a constant Ustr string, to search for
       Type[3]: const struct Ustr *

       Explanation:

         This  function  works like ustr_srch_fwd() but it searches from the end of the string to
       the beginning.

       Note:

         The searching starts from the end of the string, and so the offset is  the  offset  from
       the  end.  However  the  position of a byte is always relative to the begining, so to do a
       loop you need to take the position from the length.

     Function:  ustr_srch_cstr_fwd()
       Returns: Position in the Ustr, or zero if not found
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start searching at
       Type[2]: size_t

       Parameter[3]: A pointer to C-style string data, to search for
       Type[3]: const char *

       Explanation:

         This function works like ustr_srch_buf_fwd() but it gets the length by calling  strlen()
       on the passed data (Parameter[3]).

     Function:  ustr_srch_cstr_rev()
       Returns: Position in the Ustr, or zero if not found
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start searching at
       Type[2]: size_t

       Parameter[3]: A pointer to C-style string data, to search for
       Type[3]: const char *

       Explanation:

         This function works like ustr_srch_cstr_fwd() but it searches from the end of the string
       to the beginning.

       Note:

         The searching starts from the end of the string, and so the offset is  the  offset  from
       the  end.  However  the  position of a byte is always relative to the begining, so to do a
       loop you need to take the position from the length.

     Function:  ustr_srch_subustr_fwd()
       Returns: Position in the Ustr, or zero if not found
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start searching at
       Type[2]: size_t

       Parameter[3]: A pointer to a constant Ustr string
       Type[3]: const struct Ustr *

       Parameter[4]: Position in the Ustr
       Type[4]: size_t

       Parameter[5]: Length of data to search, from the Ustr
       Type[5]: size_t

       Explanation:

         This function works like ustr_srch_fwd() but it moves the data to start at  the  correct
       position and limits the length to the value specified.

     Function:  ustr_srch_subustr_rev()
       Returns: Position in the Ustr, or zero if not found
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start searching at
       Type[2]:  size_t

       Parameter[3]: A pointer to a constant Ustr string
       Type[3]: const struct Ustr *

       Parameter[4]: Position in the Ustr
       Type[4]: size_t

       Parameter[5]: Length of data to search, from the Ustr
       Type[5]: size_t

       Explanation:

         This  function  works like ustr_srch_rev() but it moves the data to start at the correct
       position and limits the length to the value specified.

       Note:

         The searching starts from the end of the string, and so the offset is  the  offset  from
       the  end.  However  the  position of a byte is always relative to the begining, so to do a
       loop you need to take the position from the length.

     Function:  ustr_srch_case_chr_fwd()
       Returns: Position in the Ustr, or zero if not found
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start searching at
       Type[2]: size_t

       Parameter[3]: Byte data to search for
       Type[3]: char

       Explanation:

         This function works like ustr_srch_chr_fwd(), but treats ASCII uppercase  and  lowercase
       as equivalent.

     Function:  ustr_srch_case_chr_rev()
       Returns: Position in the Ustr, or zero if not found
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start searching at
       Type[2]: size_t

       Parameter[3]: Byte data to search for
       Type[3]: char

       Explanation:

         This  function  works like ustr_srch_chr_fwd(), but treats ASCII uppercase and lowercase
       as equivalent.

     Function:  ustr_srch_case_buf_fwd()
       Returns: Position in the Ustr, or zero if not found
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start searching at
       Type[2]: size_t

       Parameter[3]: A pointer to data to search for
       Type[3]: const void *

       Parameter[4]: Length of the data to search for
       Type[4]: size_t

       Explanation:

         This function works like ustr_srch_buf_fwd(), but treats ASCII uppercase  and  lowercase
       as equivalent.

     Function:  ustr_srch_case_buf_rev()
       Returns: Position in the Ustr, or zero if not found
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start searching at
       Type[2]: size_t

       Parameter[3]: A pointer to data to search for
       Type[3]: const void *

       Parameter[4]: Length of the data to search for
       Type[4]: size_t

       Explanation:

         This  function  works like ustr_srch_buf_rev(), but treats ASCII uppercase and lowercase
       as equivalent.

     Function:  ustr_srch_case_fwd()
       Returns: Position in the Ustr, or zero if not found
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start searching at
       Type[2]: size_t

       Parameter[3]: A pointer to a constant Ustr string, to search for
       Type[3]: const struct Ustr *

       Explanation:

         This function works like ustr_srch_fwd(), but treats ASCII uppercase  and  lowercase  as
       equivalent.

     Function:  ustr_srch_case_rev()
       Returns: Position in the Ustr, or zero if not found
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start searching at
       Type[2]: size_t

       Parameter[3]: A pointer to a constant Ustr string, to search for
       Type[3]: const struct Ustr *

       Explanation:

         This  function  works  like ustr_srch_rev(), but treats ASCII uppercase and lowercase as
       equivalent.

     Function:  ustr_srch_case_cstr_fwd()
       Returns: Position in the Ustr, or zero if not found
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start searching at
       Type[2]: size_t

       Parameter[3]: A pointer to C-style string data, to search for
       Type[3]: const char *

       Explanation:

         This function works like ustr_srch_cstr_fwd(), but treats ASCII uppercase and  lowercase
       as equivalent.

     Function:  ustr_srch_case_cstr_rev()
       Returns: Position in the Ustr, or zero if not found
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start searching at
       Type[2]: size_t

       Parameter[3]: A pointer to C-style string data, to search for
       Type[3]: const char *

       Explanation:

         This  function works like ustr_srch_cstr_rev(), but treats ASCII uppercase and lowercase
       as equivalent.

     Function:  ustr_srch_case_subustr_fwd()
       Returns: Position in the Ustr, or zero if not found
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start searching at
       Type[2]: size_t

       Parameter[3]: A pointer to a constant Ustr string
       Type[3]: const struct Ustr *

       Parameter[4]: Position in the Ustr
       Type[4]: size_t

       Parameter[5]: Length of data to search, from the Ustr
       Type[5]: size_t

       Explanation:

         This function  works  like  ustr_srch_subustr_fwd(),  but  treats  ASCII  uppercase  and
       lowercase as equivalent.

     Function:  ustr_srch_case_subustr_rev()
       Returns: Position in the Ustr, or zero if not found
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start searching at
       Type[2]:  size_t

       Parameter[3]: A pointer to a constant Ustr string
       Type[3]: const struct Ustr *

       Parameter[4]: Position in the Ustr
       Type[4]: size_t

       Parameter[5]: Length of data to search, from the Ustr
       Type[5]: size_t

       Explanation:

         This  function  works  like  ustr_srch_subustr_rev(),  but  treats  ASCII  uppercase and
       lowercase as equivalent.

Span lengths of data in a Ustr

     Function:  ustr_spn_chr_fwd()
       Returns: Number of bytes in the span
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string, to start spanning from
       Type[2]: size_t

       Parameter[3]: Byte data
       Type[3]: char

       Explanation:

         This function returns the length of the start  of  the  Ustr  (Parameter[1])  that  only
       contains  bytes  that are equal to the data (Parameter[3]), skipping offset (Parameter[2])
       bytes.

     Function:  ustr_spn_chr_rev()
       Returns: Number of bytes in the span
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string, to start spanning from
       Type[2]: size_t

       Parameter[3]: Byte data
       Type[3]: char

       Explanation:

         This function returns the length of  the  end  of  the  Ustr  (Parameter[1])  that  only
       contains  bytes  that are equal to the data (Parameter[3]), skipping offset (Parameter[2])
       bytes.

     Function:  ustr_spn_chrs_fwd()
       Returns: Number of bytes in the span
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string, to start spanning from
       Type[2]: size_t

       Parameter[3]: Array of byte data, for spanning
       Type[3]: const char *

       Parameter[4]: Length of byte data, for spanning
       Type[4]: size_t

       Explanation:

         This function returns the length of the start  of  the  Ustr  (Parameter[1])  that  only
       contains  bytes  that  are  equal  to any byte in the data (Parameter[3]), skipping offset
       (Parameter[2]) bytes.

     Function:  ustr_spn_chrs_rev()
       Returns: Number of bytes in the span
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string, to start spanning from
       Type[2]: size_t

       Parameter[3]: Array of byte data
       Type[3]: const char *

       Parameter[4]: Length of byte data
       Type[4]: size_t

       Explanation:

         This function returns the length of  the  end  of  the  Ustr  (Parameter[1])  that  only
       contains  bytes  that  are  equal  to any byte in the data (Parameter[3]), skipping offset
       (Parameter[2]) bytes.

     Function:  ustr_spn_fwd()
       Returns: Number of bytes in the span
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string, to start spanning from
       Type[2]: size_t

       Parameter[3]: A pointer to a constant Ustr string, containing spanning bytes
       Type[3]: const struct Ustr *

       Explanation:

         This function works like ustr_spn_buf_fwd() but passing ustr_cstr() and ustr_len()

     Function:  ustr_spn_rev()
       Returns: Number of bytes in the span
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string, to start spanning from
       Type[2]: size_t

       Parameter[3]: A pointer to a constant Ustr string, containing spanning bytes
       Type[3]: const struct Ustr *

       Explanation:

         This function works like ustr_spn_buf_rev() but passing ustr_cstr() and ustr_len()

     Function:  ustr_spn_cstr_fwd()
       Returns: Number of bytes in the span
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string, to start spanning from
       Type[2]: size_t

       Parameter[3]: A pointer to a constant C-style string, containing spanning bytes
       Type[3]: const char *

       Explanation:

         This function works like ustr_spn_buf_fwd() but passing strlen() for the length.

     Function:  ustr_spn_cstr_rev()
       Returns: Number of bytes in the span
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string, to start spanning from
       Type[2]: size_t

       Parameter[3]: A pointer to a constant C-style string, containing spanning bytes
       Type[3]: const char *

       Explanation:

         This function works like ustr_spn_buf_rev() but passing strlen() for the length.

     Function:  ustr_cspn_chr_fwd()
       Returns: Number of bytes not in the span
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string, to start compliment spanning from
       Type[2]: size_t

       Parameter[3]: Byte data
       Type[3]: char

       Explanation:

         This function returns the length of the start  of  the  Ustr  (Parameter[1])  that  only
       contains   bytes   that  are  not  equal  to  the  data  (Parameter[3]),  skipping  offset
       (Parameter[2]) bytes.

     Function:  ustr_cspn_chr_rev()
       Returns: Number of bytes not in the span
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string, to start compliment spanning from
       Type[2]: size_t

       Parameter[3]: Byte data
       Type[3]: char

       Explanation:

         This function returns the length of  the  end  of  the  Ustr  (Parameter[1])  that  only
       contains   bytes   that  are  not  equal  to  the  data  (Parameter[3]),  skipping  offset
       (Parameter[2]) bytes.

     Function:  ustr_cspn_chrs_fwd()
       Returns: Number of bytes not in the span
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string, to start compliment spanning from
       Type[2]: size_t

       Parameter[3]: Array of byte data
       Type[3]: const char *

       Parameter[4]: Length of byte data
       Type[4]: size_t

       Explanation:

         This function returns the length of the start  of  the  Ustr  (Parameter[1])  that  only
       contains  bytes that are not equal to any byte in the data (Parameter[3]), skipping offset
       (Parameter[2]) bytes.

     Function:  ustr_cspn_chrs_rev()
       Returns: Number of bytes not in the span
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string, to start compliment spanning from
       Type[2]: size_t

       Parameter[3]: Array of byte data
       Type[3]: const char *

       Parameter[4]: Length of byte data
       Type[4]: size_t

       Explanation:

         This function returns the length of  the  end  of  the  Ustr  (Parameter[1])  that  only
       contains  bytes that are not equal to any byte in the data (Parameter[3]), skipping offset
       (Parameter[2]) bytes.

     Function:  ustr_cspn_fwd()
       Returns: Number of bytes not in the span
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string, to start compliment spanning from
       Type[2]: size_t

       Parameter[3]: A pointer to a constant Ustr string, containing spanning bytes
       Type[3]: const struct Ustr *

       Explanation:

         This function works like ustr_cspn_buf_fwd() but passing ustr_cstr() and ustr_len()

     Function:  ustr_cspn_rev()
       Returns: Number of bytes not in the span
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string, to start compliment spanning from
       Type[2]: size_t

       Parameter[3]: A pointer to a constant Ustr string, containing spanning bytes
       Type[3]: const struct Ustr *

       Explanation:

         This function works like ustr_cspn_buf_rev() but passing ustr_cstr() and ustr_len()

     Function:  ustr_cspn_cstr_fwd()
       Returns: Number of bytes not in the span
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string, to start compliment spanning from
       Type[2]: size_t

       Parameter[3]: A pointer to a constant C-style string, containing spanning bytes
       Type[3]: const char *

       Explanation:

         This function works like ustr_cspn_buf_fwd() but passing strlen() for the length.

     Function:  ustr_cspn_cstr_rev()
       Returns: Number of bytes not in the span
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string, to start spanning from
       Type[2]: size_t

       Parameter[3]: A pointer to a constant C-style string, containing spanning bytes
       Type[3]: const char *

       Explanation:

         This function works like ustr_cspn_buf_rev() but passing strlen() for the length.

     Function:  ustr_utf8_spn_chrs_fwd()
       Returns: Number of UTF-8 characters not in the span
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr UTF-8 string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string, in UTF-8 characters, to start spanning from
       Type[2]: size_t

       Parameter[3]: A pointer to a constant C-style UTF-8 string
       Type[3]: const char *

       Parameter[4]: Length of the C-style UTF-8 string
       Type[4]: size_t

       Explanation:

         This function works like ustr_spn_chrs_fwd() but the return value,  offset,  and  length
       all use UTF-8 characters and not bytes.

       Note:

         This  is  much  slower  than  ustr_spn_chrs_fwd()  but  given "xy" as a multi-byte UTF-8
       character it understands that the span over "xyxz" is 1 UTF-8 character and not 3 bytes.

     Function:  ustr_utf8_spn_chrs_rev()
       Returns: Number of UTF-8 characters not in the span
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr UTF-8 string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string, in UTF-8 characters, to start spanning from
       Type[2]: size_t

       Parameter[3]: A pointer to a constant C-style UTF-8 string
       Type[3]: const char *

       Parameter[4]:
       Type[4]: size_t

       Explanation:

         This function works like ustr_spn_chrs_rev() but the return value,  offset,  and  length
       all use UTF-8 characters and not bytes.

       Note:

         This  is  much  slower  than  ustr_spn_chrs_rev()  but  given "xy" as a multi-byte UTF-8
       character it understands that the span over "xyxz" is 1 UTF-8 character and not 3 bytes.

     Function:  ustr_utf8_spn_fwd()
       Returns: Number of UTF-8 characters not in the span
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr UTF-8 string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string, in UTF-8 characters, to start spanning from
       Type[2]: size_t

       Parameter[3]: A pointer to a constant Ustr UTF-8 string
       Type[3]: const struct Ustr *

       Explanation:

         This function works like ustr_spn_fwd() but the return value, offset, and length all use
       UTF-8 characters and not bytes.

       Note:

         This  is  much slower than ustr_spn_fwd() but given "xy" as a multi-byte UTF-8 character
       it understands that the span over "xyxz" is 1 UTF-8 character and not 3 bytes.

     Function:  ustr_utf8_spn_rev()
       Returns: Number of UTF-8 characters not in the span
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr UTF-8 string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string, in UTF-8 characters, to start spanning from
       Type[2]: size_t

       Parameter[3]: A pointer to a constant Ustr UTF-8 string
       Type[3]: const struct Ustr *

       Explanation:

         This function works like ustr_spn_rev() but the return value, offset, and length all use
       UTF-8 characters and not bytes.

       Note:

         This  is  much slower than ustr_spn_rev() but given "xy" as a multi-byte UTF-8 character
       it understands that the span over "xyxz" is 1 UTF-8 character and not 3 bytes.

     Function:  ustr_utf8_spn_cstr_fwd()
       Returns: Number of UTF-8 characters not in the span
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr UTF-8 string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string, in UTF-8 characters, to start spanning from
       Type[2]: size_t

       Parameter[3]: A pointer to a constant C-style UTF-8 string
       Type[3]: const char *

       Explanation:

         This function works like ustr_spn_cstr_fwd() but the return value,  offset,  and  length
       all use UTF-8 characters and not bytes.

       Note:

         This  is  much  slower  than  ustr_spn_cstr_fwd()  but  given "xy" as a multi-byte UTF-8
       character it understands that the span over "xyxz" is 1 UTF-8 character and not 3 bytes.

     Function:  ustr_utf8_spn_cstr_rev()
       Returns: Number of UTF-8 characters not in the span
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr UTF-8 string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string, in UTF-8 characters, to start spanning from
       Type[2]: size_t

       Parameter[3]: A pointer to a constant C-style UTF-8 string
       Type[3]: const char *

       Explanation:

         This function works like ustr_spn_cstr_rev() but the return value,  offset,  and  length
       all use UTF-8 characters and not bytes.

       Note:

         This  is  much  slower  than  ustr_spn_cstr_rev()  but  given "xy" as a multi-byte UTF-8
       character it understands that the span over "xyxz" is 1 UTF-8 character and not 3 bytes.

     Function:  ustr_utf8_cspn_chrs_fwd()
       Returns: Number of UTF-8 characters not in the span
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr UTF-8 string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string, in UTF-8 characters, to start compliment spanning from
       Type[2]: size_t

       Parameter[3]: A pointer to a constant C-style UTF-8 string
       Type[3]: const char *

       Parameter[4]: Length of the C-style UTF-8 string
       Type[4]: size_t

       Explanation:

         This function works like ustr_cspn_chrs_fwd() but the return value, offset,  and  length
       all use UTF-8 characters and not bytes.

       Note:

         This  is  much  slower  than  ustr_cspn_chrs_fwd()  but given "xy" as a multi-byte UTF-8
       character it understands that the compliment span over "xzxy" is 1 UTF-8 character and not
       0 bytes.

     Function:  ustr_utf8_cspn_chrs_rev()
       Returns: Number of UTF-8 characters not in the span
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr UTF-8 string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string, in UTF-8 characters, to start compliment spanning from
       Type[2]: size_t

       Parameter[3]: A pointer to a constant C-style UTF-8 string
       Type[3]: const char *

       Parameter[4]: Length of the C-style UTF-8 string
       Type[4]: size_t

       Explanation:

         This  function  works like ustr_cspn_chrs_rev() but the return value, offset, and length
       all use UTF-8 characters and not bytes.

       Note:

         This is much slower than ustr_cspn_chrs_rev() but  given  "xy"  as  a  multi-byte  UTF-8
       character it understands that the compliment span over "xzxy" is 1 UTF-8 character and not
       0 bytes.

     Function:  ustr_utf8_cspn_fwd()
       Returns: Number of UTF-8 characters not in the span
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr UTF-8 string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string, in UTF-8 characters, to start compliment spanning from
       Type[2]: size_t

       Parameter[3]: A pointer to a constant Ustr UTF-8 string, containing spanning data
       Type[3]: const struct Ustr *

       Explanation:

         This function works like ustr_cspn_fwd() but the return value, offset,  and  length  all
       use UTF-8 characters and not bytes.

       Note:

         This  is much slower than ustr_cspn_fwd() but given "xy" as a multi-byte UTF-8 character
       it understands that the compliment span over "xzxy" is 1 UTF-8 character and not 0 bytes.

     Function:  ustr_utf8_cspn_rev()
       Returns: Number of UTF-8 characters not in the span
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr UTF-8 string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string, in UTF-8 characters, to start compliment spanning from
       Type[2]: size_t

       Parameter[3]: A pointer to constant Ustr UTF-8 string data, containing spanning data
       Type[3]: const struct Ustr *

       Explanation:

         This function works like ustr_cspn_rev() but the return value, offset,  and  length  all
       use UTF-8 characters and not bytes.

       Note:

         This  is much slower than ustr_cspn_rev() but given "xy" as a multi-byte UTF-8 character
       it understands that the compliment span over "xzxy" is 1 UTF-8 character and not 0 bytes.

     Function:  ustr_utf8_cspn_cstr_fwd()
       Returns: Number of UTF-8 characters not in the span
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr UTF-8 string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string, in UTF-8 characters, to start compliment spanning from
       Type[2]: size_t

       Parameter[3]: A pointer to constant C-style UTF-8 string data, containing spanning data
       Type[3]: const char *

       Explanation:

         This function works like ustr_cspn_cstr_fwd() but the return value, offset,  and  length
       all use UTF-8 characters and not bytes.

       Note:

         This  is  much  slower  than  ustr_cspn_cstr_fwd()  but given "xy" as a multi-byte UTF-8
       character it understands that the compliment span over "xzxy" is 1 UTF-8 character and not
       0 bytes.

     Function:  ustr_utf8_cspn_cstr_rev()
       Returns: Number of UTF-8 characters not in the span
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr UTF-8 string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string, in UTF-8 characters, to start compliment spanning from
       Type[2]: size_t

       Parameter[3]: A pointer to C-style UTF-8 string data, containing spanning data
       Type[3]: const char *

       Explanation:

         This  function  works like ustr_cspn_cstr_rev() but the return value, offset, and length
       all use UTF-8 characters and not bytes.

       Note:

         This is much slower than ustr_spn_cstr_rev()  but  given  "xy"  as  a  multi-byte  UTF-8
       character it understands that the compliment span over "xzxy" is 1 UTF-8 character and not
       0 bytes.

Doing IO from or to a Ustr

     Function:  ustr_io_get()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A pointer to a C file object
       Type[2]: FILE *

       Parameter[3]: Number of bytes to read
       Type[3]: size_t

       Parameter[4]: Returned number of bytes read
       Type[4]: size_t *

       Explanation:

         This function tries to read a minimum number of bytes from the  file  object,  into  the
       Ustr string. The exact number read is returned, unless (Parameter[4]) is NULL.

     Function:  ustr_io_getfile()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A pointer to a C file object
       Type[2]: FILE *

       Explanation:

         This function calls ustr_io_get() rpeatedly until EOF is encountered.

       Note:

         The  errno  value  when  this function ends could either be from fopen(), fread(), or if
       both of the those succeeded from fclose().

     Function:  ustr_io_getfilename()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A C-style string of a filename
       Type[2]: const char *

       Explanation:

         This function opens a specified file, and then calls ustr_io_getfile(). Finally  closing
       the FILE * object.

     Function:  ustr_io_getdelim()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A pointer to a C file object
       Type[2]: FILE *

       Parameter[3]: A delimiter byte to stop reading at
       Type[3]: char

       Explanation:

         This function reads bytes from the file until it hits the delimiter byte.

       Note:

         The  delimiter  is  included,  use ustr_del() to remove 1 byte from the end if you don't
       want it.
         This function assumes a delimiter will happen every 80 bytes or so.

     Function:  ustr_io_getline()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A pointer to a C file object
       Type[2]: FILE *

       Explanation:

         This function works like calling ustr_io_getdelim() with '\n' as the delimiter.

     Function:  ustr_io_put()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A pointer to a C file object
       Type[2]: FILE *

       Parameter[3]: Number of bytes to write
       Type[3]: size_t

       Explanation:

         This function is the opposite of ustr_io_get(), taking bytes from the beginning  of  the
       Ustr and writting them to the file.

       Note:

         Deleting  bytes  from the begining of a Ustr string is the most inefficient thing to do,
       so it is recommended to use ustr_io_putfile().

     Function:  ustr_io_putline()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A pointer to a C file object
       Type[2]: FILE *

       Parameter[3]: Number of bytes to write
       Type[3]: size_t

       Explanation:

         This function works like calling ustr_io_put(), and then writting a '\n' to the file.

       Note:

         This doesn't write a line from the Ustr to the file, if you want that call ustr_io_put()
       directly,  using  the return from ustr_srch_chr_fwd() (with a '\n') as the number of bytes
       argument.

     Function:  ustr_io_putfile()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A pointer to a C file object
       Type[2]: FILE *

       Explanation:

         This function works like calling ustr_io_put() with ustr_len() as the number of bytes.

     Function:  ustr_io_putfileline()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A pointer to a C file object
       Type[2]: FILE *

       Explanation:

         This function works like calling ustr_io_putline() with  ustr_len()  as  the  number  of
       bytes.

     Function:  ustr_io_putfilename()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A C-style string of a filename
       Type[2]: const char *

       Parameter[3]: A C-style string of a filemode (the second argument to fopen)
       Type[3]: const char *

       Explanation:

         This  function opens a specified file, and then calls ustr_io_putfile(). Finally closing
       the FILE * object.

       Note:

         The errno value when this function ends could either be from fopen(),  fwrite(),  or  if
       both of the those succeeded from fclose().

String substitution/replacement

     Function:  ustr_sub_undef()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr
       Type[1]: struct Ustr **

       Parameter[2]: Position where to start substitution
       Type[2]: size_t

       Parameter[3]: Length of undefined data
       Type[3]: size_t

       Explanation:

         The  Ustr  string  is expanded as required (possibly reallocated) so that it can contain
       length (Parameter[2]) data, from the required position. If the length is not zero the Ustr
       will be writable. Or it'll return USTR_FALSE (zero) on failure.

       Note:

         You  can  think of the operation as two seperate tasks, one which makes the current data
       in the Ustr undefined and the second which adds undefined data to the ustr  to  accomodate
       the desired length.

     Function:  ustr_sub_buf()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr
       Type[1]: struct Ustr **

       Parameter[2]: Position where to start substitution
       Type[2]: size_t

       Parameter[3]: Buffer containing substitution string
       Type[3]: const void *

       Parameter[4]: Length of buffer
       Type[4]: size_t

       Explanation:

         This  function works as if you had called ustr_sub_undef() and then copied the data into
       the new undefined space.

     Function:  ustr_sub_cstr()
       Returns: success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr
       Type[1]: struct Ustr **

       Parameter[2]: Position where to start substitution
       Type[2]: size_t

       Parameter[3]: A pointer to a constant C-style string, which is the substitution
       Type[3]: const char *

       Explanation:

         This function works like ustr_sub_buf() but the length is worked  out  automatically  by
       strlen().

     Function:  USTR_SUB_OSTR()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Position where to start substitution
       Type[2]: size_t

       Parameter[3]: A constant C-style string
       Type[3]: const char []

       Explanation:

         This  function  works as if you had called ustr_sub_buf() and passed sizeof() - 1 as the
       length.

     Function:  USTR_SUB_OBJ()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Position where to start substitution
       Type[2]: size_t

       Parameter[3]: A symbol
       Type[3]: ...

       Explanation:

         This function works as if you had called  ustr_sub_buf()  and  passed  sizeof()  as  the
       length.

       Note:

         In most cases you'll want to use USTR_SUB_OSTR().

     Function:  ustr_sub()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Position where to start substitution
       Type[2]: size_t

       Parameter[3]: A pointer to a constant Ustr string
       Type[3]: const struct Ustr *

       Explanation:

         This  function  works  as  if  you  had  called  ustr_sub_buf() with the ustr_cstr() and
       ustr_len() values of the Ustr string to be added. The exception being if you substitute  a
       ustr  into  itself,  while  only  having a single reference count, the simple method could
       access a free'd ustr data, but this function just works.

     Function:  ustr_sub_subustr()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Position where to start substitution
       Type[2]: size_t

       Parameter[3]: A pointer to a constant Ustr string
       Type[3]: const struct Ustr *

       Parameter[4]: Position in the Ustr
       Type[4]: size_t

       Parameter[5]: Length to substitute from the Ustr
       Type[5]: size_t

       Explanation:

         This function mostly as if you had called ustr_sub_buf() with the ustr_cstr() + position
       -  1 and length values of the Ustr string to be insed. The exception being if you insert a
       ustr to itself, while only having a single reference count, the simple method would access
       a free'd ustr data, but this function just works.

     Function:  ustr_sc_sub_undef()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr
       Type[1]: struct Ustr **

       Parameter[2]: Position where to start substitution
       Type[2]: size_t

       Parameter[3]: Length of substitution
       Type[3]: size_t

       Parameter[4]: Length of undefined data
       Type[4]: size_t

       Explanation:

         This  function works as if you had done ustr_del_subustr() followed by ustr_ins_undef(),
       however it is significantly more efficient.

     Function:  ustr_sc_sub_buf()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr
       Type[1]: struct Ustr **

       Parameter[2]: Position where to start substitution
       Type[2]: size_t

       Parameter[3]: Length of substitution
       Type[3]: size_t

       Parameter[4]: Buffer containting substitute data
       Type[4]: const void *

       Parameter[5]: Length of Buffer
       Type[5]: size_t

       Explanation:

         This function will substitute a specific number of characters in a Ustr  with  the  data
       from a buffer, this function does the job of one or more of ustr_add_buf(), ustr_sub_buf()
       and ustr_del().

     Function:  ustr_sc_sub_cstr()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr
       Type[1]: struct Ustr **

       Parameter[2]: Position where to start replacement
       Type[2]: size_t

       Parameter[3]: Length of substitution
       Type[3]: size_t

       Parameter[4]: A pointer to a constant C-style string, containing spanning bytes
       Type[4]: const char *

       Explanation:

         This function works like ustr_sc_sub_buf() but the length is worked out automatically by
       strlen().

     Function:  ustr_sc_sub()
       Returns: success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr
       Type[1]: struct Ustr **

       Parameter[2]: Position where to start substitution
       Type[2]: size_t

       Parameter[3]: Length of substitution
       Type[3]: size_t

       Parameter[4]: Pointer to a Ustr containing the substitute string
       Type[4]: const struct Ustr *

       Explanation:

         This  function  works  as  if  you had called ustr_sc_sub_buf() with the ustr_cstr() and
       ustr_len() values of the Ustr string to be added. The exception being if you substitute  a
       ustr  into  itself,  while  only  having a single reference count, the simple method could
       access a free'd ustr data, but this function just works.

     Function:  ustr_sc_sub_subustr()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr
       Type[1]: struct Ustr **

       Parameter[2]: Position where to start substitution
       Type[2]: size_t

       Parameter[3]: Length of substitution
       Type[3]: size_t

       Parameter[4]: A pointer to a constant Ustr string
       Type[4]: const struct Ustr *

       Parameter[5]: Position in the Ustr
       Type[5]: size_t

       Parameter[6]: Length to substitute from the Ustr
       Type[6]: size_t

       Explanation:

         This function mostly as if you had  called  ustr_sc_sub_buf()  with  the  ustr_cstr()  +
       position  - 1 and length values of the Ustr string to be insed. The exception being if you
       insert a ustr to itself, while only having a single reference  count,  the  simple  method
       would access a free'd ustr data, but this function just works.

     Function:  USTR_SC_SUB_OSTR()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Position where to start substitution
       Type[2]: size_t

       Parameter[3]: Length of substitution
       Type[3]: size_t

       Parameter[4]: A constant C-style string
       Type[4]: const char []

       Explanation:

         This  function  works  as if you had called ustr_sc_sub_buf() and passed sizeof() - 1 as
       the length.

     Function:  USTR_SC_SUB_OBJ()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Position where to start substitution
       Type[2]: size_t

       Parameter[3]: Length of substitution
       Type[3]: size_t

       Parameter[4]: A symbol
       Type[4]: ...

       Explanation:

         This function works as if you had called ustr_sc_sub_buf() and passed  sizeof()  as  the
       length.

       Note:

         In most cases you'll want to use USTR_SUB_OSTR().

     Function:  ustr_replace_buf()
       Returns: Number of tokens replaced
       Type: size_t

       Parameter[1]: Pointer to a pointer to a Ustr (haystack)
       Type[1]: struct Ustr **

       Parameter[2]: Buffer containting search data
       Type[2]: const void *

       Parameter[3]: Length of search buffer
       Type[3]: size_t

       Parameter[4]: Buffer containting replacement data
       Type[4]: const void *

       Parameter[5]: Length of replacement buffer
       Type[5]: size_t

       Parameter[6]: Maximum number of matches to replace (0 for unlimited)
       Type[6]: size_t

       Explanation:

         This  function  scans  the  "haystack"  (Parameter[1])  for  "needle" (Parameter[2]) and
       replaces max_replacements (Parameter[6]) matches with the "replacement" (Parameter[4]).

       Note:

         If max_replacements (Parameter[6]) is 0, this function will replace ALL occurrences.

     Function:  ustr_replace_cstr()
       Returns: Number of tokens replaced
       Type: size_t

       Parameter[1]: Pointer to a pointer to a Ustr (haystack)
       Type[1]: struct Ustr **

       Parameter[2]: A pointer to a constant C-style string, containing search bytes
       Type[2]: const char *

       Parameter[3]: A pointer to a constant C-style string, containing replacement bytes
       Type[3]: const char *

       Parameter[4]: Maximum number of matches to replace (0 for unlimited)
       Type[4]: size_t

       Explanation:

         This function works  like  ustr_replace_buf()  but  gets  the  lengths  for  the  buffer
       automatically from strlen().

     Function:  ustr_replace()
       Returns: Number of tokens replaced
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr (haystack)
       Type[1]: struct Ustr **

       Parameter[2]: Ustr to search for (needle)
       Type[2]: const struct Ustr *

       Parameter[3]: Ustr to replace needle with
       Type[3]: const struct Ustr *

       Parameter[4]: Maximum number of matches to replace (0 for unlimited)
       Type[4]: size_t

       Explanation:

         This  function  works  like  ustr_replace_buf()  but  gets  the  lengths  from  the ustr
       automatically.

     Function:  ustr_replace_rep_chr()
       Returns: number of replacements made
       Type: size_t

       Parameter[1]: pointer to a pointer to a Ustr to be modified
       Type[1]: struct Ustr **ps1

       Parameter[2]: character to replace
       Type[2]: char

       Parameter[3]: number of characters to replace
       Type[3]: size_t

       Parameter[4]: character to replace with
       Type[4]: char

       Parameter[5]: number of characters to replace with
       Type[5]: size_t nlen

       Parameter[6]: maximum number of replacements to make (use 0 for unlimited)
       Type[6]: size_t lim

       Explanation:

         This function replaces  a  repeating  sequence  of  characters  with  another  repeating
       sequence of characters.
         For example...

         Ustr *data = ustr_dup_cstr("xxxBxxCxDxxx");
         ustr_replace_rep_chr(&data,'x',2,'y',1, 0)

        ...would change data to be "yxByCxDyx".

       Note:

         Changing  the  same  letter the same number of times is considered a No-op since it is a
       vast performance improvement this way. So passing in  (&data,'y',2,'y',2 ,0) will  have  a
       return value of 0 and the string will be unchanged.

Splitting a Ustr

     Function:  ustr_split_buf()
       Returns: pointer to a Ustr representing the next token
       Type: struct Ustr *

       Parameter[1]: Pointer to a constant Ustr to be split
       Type[1]: const struct Ustr *

       Parameter[2]: Pointer to an offset
       Type[2]: size_t *

       Parameter[3]: Buffer to use as split search pattern
       Type[3]: const void *

       Parameter[4]: Length of buffer
       Type[4]: size_t

       Parameter[5]: Pointer to a Ustr to be used as the return value
       Type[5]: struct Ustr *

       Parameter[6]: Flags with the prefix USTR_FLAG_SPLIT_
       Type[6]: unsigned int

       Explanation:

         This  function  works in a manner similar to strtok(). Each time the function is called,
       the string inside of the buffer (Parameter[3]) is used as a search  pattern  at  which  to
       split. If the pattern is not found, the entire string will be returned. A USTR_NULL return
       value indicates there are no more tokens remaining.
         Parameter[5] is a a pointer to a Ustr where the return value will be placed.  Passing  a
       USTR_NULL  to  this  parameter  will  cause  the  string to be allocated and MUST be freed
       manually. If, however, you pass in a  non-null  Ustr  to  this  parameter,  each  call  to
       ustr_split_buf()  will  free  what  is in this pointer and place the new token there (when
       USTR_NULL is returned, nothing needs to be free'd).  For example, given...

         Ustr *data = ...;
         Ustr *tok = USTR_NULL;
         const char *sep = ",";
         size_t off = 0;
         unsigned int flags = USTR_FLAGS_SPLIT_DEF;

        ...there are two options...

         while ((tok = ustr_split_buf(data, &off, sep, strlen(sep), tok, flags)))
         {
           /* Do something with tok -- but next iteration of the loop will free
            * and overwrite tok, so you must ustr_dup() if you want to keep it */
         }
         /* tok is now NULL again after the loop */

        ...or...

         while ((tok = ustr_split_buf(data, &off, sep, strlen(sep), USTR_NULL, flags)))
         {
           /* Do something with tok, and it will NOT be freed in the next iteration of
            * the loop */
             ustr_free(tok); /* have to free to avoid mem leaks */
         }

        ...the former of which being the safer option.

       Note:

         There are several flags that will alter the behaviour of this  function,  all  of  which
       have a common with the default being USTR_FLAG_SPLIT_DEF.
         If  you  are  calling  this  function directly, it is very likely that you'd want to use
       ustr_split_cstr() instead.

     Function:  ustr_split()
       Returns: Pointer to a Ustr representing the next token
       Type: struct Ustr *

       Parameter[1]: Pointer to a constant Ustr to be split
       Type[1]: const struct Ustr *

       Parameter[2]: Pointer to an offset variable
       Type[2]: size_t *

       Parameter[3]: Pointer to a constant Ustr to use as the split search pattern
       Type[3]: const struct Ustr *

       Parameter[4]: Pointer to a Ustr where the return value will be placed
       Type[4]: struct Ustr *

       Parameter[5]: Flags
       Type[5]: unsigned int

       Explanation:

          Works like ustr_split_buf() but takes a Ustr as the split search pattern
         instead.

     Function:  ustr_split_cstr()
       Returns: Pointer to a Ustr representing the next token
       Type: struct Ustr *

       Parameter[1]: Pointer to a constant Ustr to be split
       Type[1]: const struct Ustr *

       Parameter[2]: Pointer to an offset variable
       Type[2]: size_t *

       Parameter[3]: C string to use as split search pattern
       Type[3]: const char *

       Parameter[4]: Pointer to a Ustr where the return value will be placed
       Type[4]: struct Ustr *

       Parameter[5]: Flags
       Type[5]: unsigned int

       Explanation:

         Works like ustr_split_buf() but takes a C string as the split  search  pattern,  and  so
       gets the length via. strlen().

     Function:  ustr_split_spn_chrs()
       Returns: Pointer to a Ustr representing the next token
       Type: struct Ustr *

       Parameter[1]: Pointer to a Ustr to be split
       Type[1]: const struct Ustr *

       Parameter[2]: Pointer to an offset variable
       Type[2]: size_t *

       Parameter[3]: String representing a set of bytes to use as split chars
       Type[3]: const char *

       Parameter[4]: Length of the string of set of bytes
       Type[4]: size_t

       Parameter[5]: Pointer to a Ustr where the return value will be placed
       Type[5]: struct Ustr *

       Parameter[6]: flags
       Type[6]: unsigned int

       Explanation:

         Works  like ustr_split_buf() but uses the individual ASCII bytes in the separator string
       (Parameter[3]) as search patterns. It will split if ANY of these individual characters are
       matched  (much  like  strtok()).  For  example:  if  splitting  "this, is,a test" with the
       separator string ", " the tokens returned would be {"this" "is" "a" "test"};

       Note:

         If you are calling this function directly, it is very likely  that  you'd  want  to  use
       ustr_split_spn_cstr() instead.

     Function:  ustr_split_spn_cstr()
       Returns: Pointer to a Ustr representing the next token
       Type: struct Ustr *

       Parameter[1]: Pointer to a Ustr to be split
       Type[1]: const struct Ustr *

       Parameter[2]: Pointer to an offset variable
       Type[2]: size_t *

       Parameter[3]: String representing a set of bytes to use as split chars
       Type[3]: const char *

       Parameter[4]: Pointer to a Ustr where the return value will be placed
       Type[4]: struct Ustr *

       Parameter[5]: flags
       Type[5]: unsigned int

       Explanation:

         Works like ustr_split_spn_chrs() but gets the length automatically via. strlen().

     Function:  ustr_split_spn()
       Returns: Pointer to a Ustr representing the next token
       Type: struct Ustr *

       Parameter[1]: Pointer to a constant Ustr to be split
       Type[1]: const struct Ustr *

       Parameter[2]: Pointer to an offset variable
       Type[2]: size_t *

       Parameter[3]: Pointer to a constant Ustr to use as the split search pattern
       Type[3]: const struct Ustr *

       Parameter[4]: Pointer to a Ustr where the return value will be placed
       Type[4]: struct Ustr *

       Parameter[5]: Flags
       Type[5]: unsigned int

       Explanation:

         Works like ustr_split_spn_chrs() but takes a Ustr as the split chars instead.

Dealing with UTF-8 in a Ustr

     Function:  ustr_utf8_valid()
       Returns: A boolean flag of either USTR_TRUE or USTR_FALSE
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Explanation:

         This function tries it's best to find out if the string is a valid utf-8 string.

     Function:  ustr_utf8_len()
       Returns: The number of the utf-8 characters in the Ustr
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Explanation:

         This function counts the number of utf-8 characters inn the Ustr.

       Note:

         This function gives undefined answers on strings that aren't utf-8 valid.

     Function:  ustr_utf8_width()
       Returns: ssize_t
       Type: ssize_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Explanation:

         This  function  returns  the  visible  width of the string, assuming it is a valid utf-8
       string. This is like converting to wide characters and using wcwidth().

     Function:  ustr_utf8_chars2bytes()
       Returns: Length of span in bytes
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Position of a span in utf-8 characters
       Type[2]: size_t

       Parameter[3]: Length of a span in utf-8 characters
       Type[3]: size_t

       Parameter[4]: Returns the position of the span in bytes
       Type[4]: size_t *

       Explanation:

         This function converts a span, in utf-8 characters, to the same span in bytes.

     Function:  ustr_utf8_bytes2chars()
       Returns: Returns the position of a span in utf-8 characters
       Type: size_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Position of a span in bytes
       Type[2]: size_t

       Parameter[3]: Length of a span in bytes
       Type[3]: size_t

       Parameter[4]: Returns length of a span in utf-8 characters
       Type[4]: size_t *

       Explanation:

         This function converts a span, in bytes, to the same span in utf-8 characters.

       Note:

         Because a byte span can start or end within a utf-8  character,  converting  the  return
       values  back  into bytes via. ustr_utf8_chars2bytes() may make the span be slightly bigger
       (position slightly earlier, and the length slightly longer).

     Function:  ustr_sc_utf8_reverse()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Explanation:

         This function reverses the utf-8 characters in the Ustr string, assuming it is  a  valid
       utf-8  string, so the last one becomes the first and the second to last becomes the second
       etc.

Parsing ASCII integer numbers from a Ustr

     Function:  ustr_parse_uintmaxx()
       Returns: Parsed number, or zero on error
       Type: uintmax_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start parsing at
       Type[2]: size_t

       Parameter[3]: Base (2-36) and flags, starting with USTR_FLAG_PARSE_NUM_
       Type[3]: unsigned int

       Parameter[4]: Absolute minimum value
       Type[4]: uintmax_t

       Parameter[5]: Absolute maximum value
       Type[5]: uintmax_t

       Parameter[6]: Thousands separator
       Type[6]: const char *

       Parameter[7]: Return length of parsed number
       Type[7]: size_t *

       Parameter[8]: Return error code, starting with USTR_TYPE_PARSE_NUM_ERR_
       Type[8]: unsigned int *

       Explanation:

         This function parses an ASCII representation of a  number  from  a  Ustr  (Parameter[1])
       starting at the offset (Parameter[2]).

       Note:

         If stdint.h isn't available this function won't be available.

     Function:  ustr_parse_uintmax()
       Returns: Parsed number, or zero on error
       Type: uintmax_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start parsing at
       Type[2]: size_t

       Parameter[3]: Base (2-36) and flags, starting with USTR_FLAG_PARSE_NUM_
       Type[3]: unsigned int

       Parameter[4]: Return length of parsed number
       Type[4]: size_t *

       Parameter[5]: Return error code, starting with USTR_TYPE_PARSE_NUM_ERR_
       Type[5]: unsigned int *

       Explanation:

         This function works like ustr_parse_uintmaxx() with the minimum and maximum values taken
       as 0 and UINTMAX_MAX, and the thousands separator as "_".

       Note:

         If stdint.h isn't available this function won't be available.

     Function:  ustr_parse_intmax()
       Returns: Parsed number, or zero on error
       Type: intmax_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start parsing at
       Type[2]: size_t

       Parameter[3]: Base (2-36) and flags, starting with USTR_FLAG_PARSE_NUM_
       Type[3]: unsigned int

       Parameter[4]: Return length of parsed number
       Type[4]: size_t *

       Parameter[5]: Return error code, starting with USTR_TYPE_PARSE_NUM_ERR_
       Type[5]: unsigned int *

       Explanation:

         This function works like ustr_parse_uintmaxx() with the minimum and maximum values taken
       as -INTMAX_MIN and INTMAX_MAX, and the thousands separator as "_".

       Note:

         If stdint.h isn't available this function won't be available.

     Function:  ustr_parse_ulongx()
       Returns: Parsed number, or zero on error
       Type: unsigned long

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start parsing at
       Type[2]:  size_t

       Parameter[3]: Base (2-36) and flags, starting with USTR_FLAG_PARSE_NUM_
       Type[3]:  unsigned int

       Parameter[4]: Absolute minimum value
       Type[4]:  unsigned long

       Parameter[5]: Absolute maximum value
       Type[5]:  unsigned long

       Parameter[6]: Thousands separator
       Type[6]: const char *

       Parameter[7]: Return length of parsed number
       Type[7]:  size_t *

       Parameter[8]: Return error code, starting with USTR_TYPE_PARSE_NUM_ERR_
       Type[8]: unsigned int *

       Explanation:

         This  function  works  like  ustr_parse_uintmaxx()  but  returns an unsigned long, it is
       always available even when stdint.h isn't.

     Function:  ustr_parse_ulong()
       Returns: Parsed number, or zero on error
       Type: unsigned long

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start parsing at
       Type[2]: size_t

       Parameter[3]: Base (2-36) and flags, starting with USTR_FLAG_PARSE_NUM_
       Type[3]: unsigned int

       Parameter[4]: Return length of parsed number
       Type[4]: size_t *

       Parameter[5]: Return error code, starting with USTR_TYPE_PARSE_NUM_ERR_
       Type[5]: unsigned int *

       Explanation:

         This function works like ustr_parse_ulongx() with the minimum and maximum  values  taken
       as 0 and ULONG_MAX, and the thousands separator as "_".

     Function:  ustr_parse_long()
       Returns: Parsed number, or zero on error
       Type: long

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start parsing at
       Type[2]: size_t

       Parameter[3]: Base (2-36) and flags, starting with USTR_FLAG_PARSE_NUM_
       Type[3]: unsigned int

       Parameter[4]: Return length of parsed number
       Type[4]: size_t *

       Parameter[5]: Return error code, starting with USTR_TYPE_PARSE_NUM_ERR_
       Type[5]: unsigned int *

       Explanation:

         This  function  works like ustr_parse_ulongx() with the minimum and maximum values taken
       as -LONG_MIN and LONG_MAX, and the thousands separator as "_".

     Function:  ustr_parse_uint()
       Returns: Parsed number, or zero on error
       Type: unsigned int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start parsing at
       Type[2]: size_t

       Parameter[3]: Base (2-36) and flags, starting with USTR_FLAG_PARSE_NUM_
       Type[3]: unsigned int

       Parameter[4]: Return length of parsed number
       Type[4]: size_t *

       Parameter[5]: Return error code, starting with USTR_TYPE_PARSE_NUM_ERR_
       Type[5]: unsigned int *

       Explanation:

         This function works like ustr_parse_ulongx() with the minimum and maximum  values  taken
       as 0 and UINT_MAX, and the thousands separator as "_".

     Function:  ustr_parse_int()
       Returns: Parsed number, or zero on error
       Type: int

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start parsing at
       Type[2]: size_t

       Parameter[3]: Base (2-36) and flags, starting with USTR_FLAG_PARSE_NUM_
       Type[3]: unsigned int

       Parameter[4]: Return length of parsed number
       Type[4]: size_t *

       Parameter[5]: Return error code, starting with USTR_TYPE_PARSE_NUM_ERR_
       Type[5]: unsigned int *

       Explanation:

         This  function  works like ustr_parse_ulongx() with the minimum and maximum values taken
       as -INT_MIN and INT_MAX, and the thousands separator as "_".

     Function:  ustr_parse_ushort()
       Returns: Parsed number, or zero on error
       Type: unsigned short

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start parsing at
       Type[2]: size_t

       Parameter[3]: Base (2-36) and flags, starting with USTR_FLAG_PARSE_NUM_
       Type[3]: unsigned int

       Parameter[4]: Return length of parsed number
       Type[4]: size_t *

       Parameter[5]: Return error code, starting with USTR_TYPE_PARSE_NUM_ERR_
       Type[5]: unsigned int *

       Explanation:

         This function works like ustr_parse_ulongx() with the minimum and maximum  values  taken
       as 0 and USHRT_MAX, and the thousands separator as "_".

     Function:  ustr_parse_short()
       Returns: Parsed number, or zero on error
       Type: short

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start parsing at
       Type[2]: size_t

       Parameter[3]: Base (2-36) and flags, starting with USTR_FLAG_PARSE_NUM_
       Type[3]: unsigned int

       Parameter[4]: Return length of parsed number
       Type[4]: size_t *

       Parameter[5]: Return error code, starting with USTR_TYPE_PARSE_NUM_ERR_
       Type[5]: unsigned int *

       Explanation:

         This  function  works like ustr_parse_ulongx() with the minimum and maximum values taken
       as -SHRT_MIN and SHRT_MAX, and the thousands separator as "_".

Misc shortcut helper functions for Ustrs

     Function:  ustr_sc_ensure_owner()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Explanation:

         This function makes sure that the Ustr string is owned when it returns (Ie. ustr_owner()
       returns USTR_TRUE), or it fails to allocate.

     Function:  ustr_sc_wstr()
       Returns: Writable pointer to the start of data in the Ustr, or NULL
       Type: char *

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Explanation:

         This function works like calling ustr_sc_ensure_owner(), to make sure the Ustr string is
       writable, and if that succeeds it returns ustr_wstr(). On failure it returns NULL.

     Function:  ustr_sc_export_subustr()
       Returns: A pointer to newly allocated block of memory
       Type: char *

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Position in the Ustr
       Type[2]: size_t

       Parameter[3]: Length to export from the Ustr
       Type[3]: size_t

       Parameter[4]: Allocation function (like malloc)
       Type[4]: void *(*)(size_t)

       Explanation:

         This function allocates a block of memory of size Length (Parameter[3]) + 1   using  the
       provided  allocation  function  (Parameter[4])  and copies the data starting from Position
       (Parameter[2]) within the ustr.

     Function:  ustr_sc_export()
       Returns: A pointer to newly allocated block of memory
       Type: char *

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Allocation function (like malloc)
       Type[2]: void *(*)(size_t)

       Explanation:

         This function works like calling ustr_sc_export_subustr() with a position  of  1  and  a
       length of ustr_len().

     Function:  ustrp_sc_export_subustrp()
       Returns: A pointer to newly allocated block of memory
       Type: char *

       Parameter[1]: Pointer to a Ustr pool object
       Type[1]: struct Ustr_pool *

       Parameter[2]: A pointer to a constant Ustr string
       Type[2]: const struct Ustr *

       Parameter[3]: Position in the Ustr
       Type[3]: size_t

       Parameter[4]: Length to export from the Ustr
       Type[4]: size_t

       Parameter[5]: Allocation function (like malloc), or NULL
       Type[5]: void *(*)(size_t)

       Explanation:

         This  function  allocates  a  block  of  memory of size Length (Parameter[4]) + 1  using
       either the provided allocation function (Parameter[5]), or from the  pool  object  if  the
       allocation  function  is  NUL,  and  copies the data starting from Position (Parameter[3])
       within the ustr.

     Function:  ustrp_sc_export()
       Returns: A pointer to newly allocated block of memory
       Type: char *

       Parameter[1]: Pointer to a Ustr pool object
       Type[1]: struct Ustr_pool *

       Parameter[2]: A pointer to a constant Ustr string
       Type[2]: const struct Ustr *

       Parameter[3]: Allocation function (like malloc)
       Type[3]: void *(*)(size_t)

       Explanation:

         This function works like calling ustrp_sc_export_subustrp() with a position of 1  and  a
       length of ustrp_len().

     Function:  ustr_sc_reverse()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Explanation:

         This  function  reverses  all  the bytes in the Ustr string, so the last one becomes the
       first and the second to last becomes the second etc.

     Function:  ustr_sc_tolower()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Explanation:

         This function changes any ASCII upper case bytes into ASCII lower case bytes.

     Function:  ustr_sc_toupper()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Explanation:

         This function changes any ASCII lower case bytes into ASCII upper case bytes.

     Function:  ustr_sc_ltrim_chrs()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Array of bytes, containing trimming data
       Type[2]: const char *

       Parameter[3]: Length of byte data
       Type[3]: size_t

       Explanation:

         This function deletes the bytes at the begining of the Ustr (Parameter[1]) that  are  in
       the span (Parameter[2]) of the specificed length (parameter[2]).

     Function:  ustr_sc_ltrim()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A pointer to a constant Ustr string, containing trimming bytes
       Type[2]: const struct Ustr *

       Explanation:

         This function works as if you had called ustr_sc_ltrim_chrs() and passed ustr_cstr() and
       ustr_len() values of the Ustr string (Parameter[2]).

     Function:  ustr_sc_ltrim_cstr()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A pointer to a constant C-style string, containing trimming bytes
       Type[2]: const char *

       Explanation:

         This function works as if you had called ustr_sc_ltrim_chrs() and passed strlen() as the
       length.

     Function:  ustr_sc_rtrim_chrs()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Array of bytes, containing trimming data
       Type[2]: const char *

       Parameter[3]: Length of byte data
       Type[3]: size_t

       Explanation:

         This  function  deletes  the bytes at the end of the Ustr (Parameter[1]) that are in the
       span (Parameter[2]) of the specificed length (parameter[2]).

     Function:  ustr_sc_rtrim()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A pointer to a constant Ustr string, containing trimming bytes
       Type[2]: const struct Ustr *

       Explanation:

         This function works as if you had called ustr_sc_rtrim_chrs() and passed ustr_cstr() and
       ustr_len() values of the Ustr string (Parameter[2]).

     Function:  ustr_sc_rtrim_cstr()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A pointer to a constant C-style string, containing trimming bytes
       Type[2]: const char *

       Explanation:

         This function works as if you had called ustr_sc_rtrim_chrs() and passed strlen() as the
       length.

     Function:  ustr_sc_trim_chrs()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Array of bytes, containing trimming data
       Type[2]: const char *

       Parameter[3]: Length of byte data
       Type[3]: size_t

       Explanation:

         This function deletes the bytes at the begining or end of the Ustr  (Parameter[1])  that
       are in the span (Parameter[2]) of the specificed length (parameter[2]).

       Note:

         Calling  this function is much more efficient than calling ustr_sc_rtrim_chrs() and then
       ustr_sc_ltrim_chrs(), as both ends are trimmed in a single pass.

     Function:  ustr_sc_trim()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A pointer to a constant Ustr string, containing trimming bytes
       Type[2]: const struct Ustr *

       Explanation:

         This function works as if you had called ustr_sc_trim_chrs() and passed ustr_cstr()  and
       ustr_len() values of the Ustr string (Parameter[2]).

     Function:  ustr_sc_trim_cstr()
       Returns: Success or failure
       Type: int

       Parameter[1]: A pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: A pointer to a constant C-style string, containing trimming bytes
       Type[2]: const char *

       Explanation:

         This  function works as if you had called ustr_sc_trim_chrs() and passed strlen() as the
       length.

Adding binary data to a Ustr

     Function:  ustr_add_b_uint16()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Binary value to add to the Ustr
       Type[2]: uint_least16_t

       Explanation:

         This function adds a binary  representation  of  a  value  (Parameter[2])  to  the  Ustr
       (Parameter[1]).

     Function:  ustr_add_b_uint32()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Binary value to add to the Ustr
       Type[2]: uint_least32_t

       Explanation:

         This  function  adds  a  binary  representation  of  a  value (Parameter[2]) to the Ustr
       (Parameter[1]).

     Function:  ustr_add_b_uint64()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Binary value to add to the Ustr
       Type[2]: uint_least64_t

       Explanation:

         This function adds a binary  representation  of  a  value  (Parameter[2])  to  the  Ustr
       (Parameter[1]).

Parsing binary data from a Ustr

     Function:  ustr_parse_b_uint16()
       Returns: uint_least16_t
       Type: uint_least16_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start parsing at
       Type[2]: size_t

       Explanation:

         This function parses a binary representation from a Ustr (Parameter[1])  starting at the
       offset (Parameter[2]).

     Function:  ustr_parse_b_uint32()
       Returns: uint_least32_t
       Type: uint_least32_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start parsing at
       Type[2]: size_t

       Explanation:

         This function parses a binary representation from a Ustr (Parameter[1])  starting at the
       offset (Parameter[2]).

     Function:  ustr_parse_b_uint64()
       Returns: uint_least64_t
       Type: uint_least64_t

       Parameter[1]: A pointer to a constant Ustr string
       Type[1]: const struct Ustr *

       Parameter[2]: Offset within string to start parsing at
       Type[2]: size_t

       Explanation:

         This function parses a binary representation from a Ustr (Parameter[1])  starting at the
       offset (Parameter[2]).

Misc. functions

     Function:  ustr_realloc()
       Returns: Success or failure
       Type: int

       Parameter[1]: Pointer to a pointer to a Ustr string
       Type[1]: struct Ustr **

       Parameter[2]: Size of allocation
       Type[2]: size_t

       Explanation:

         This function is re-sizes the Ustr to the specified size (Parameter[2]).
         This is mostly used to shrink a sized Ustr that is now  significantly  smaller  than  it
       once was. Although this function can also grow a Ustr.

       Note:

         To  have  a  size that isn't implied from the length the Ustr must store a size value as
       well as a length (ustr_sized() must return USTR_TRUE).

     Function:  ustr_cntl_opt()
       Returns: Success or failure
       Type: int

       Parameter[1]: Optional value starting with USTR_CNTL_OPT_
       Type[1]: int

       Parameter[2]: Arugments to option
       Type[2]: ...

       Explanation:

         This function views and/or changes global Ustr options,  like  whether  ustr's  have  an
       implicit or explicit size (USTR_CNTL_OPT_GET_HAS_SIZE).

Simple Ustr pool API

     Function:  ustr_pool_ll_make()
       Returns: Pointer to a Ustr pool object
       Type: struct Ustr_pool *

       Parameter[1]: Nothing
       Type[1]: void

       Explanation:

         This  allocates a new pool using the "linked list" strategy, each allocation in the pool
       is added to a linked list ... and any allocations not freed directly are freed by the pool
       when it is cleared or freed.

     Function:  ustr_pool_make_subpool()
       Returns: Pointer to a Ustr pool object
       Type: struct Ustr_pool *

       Parameter[1]: struct Ustr_pool *
       Type[1]: struct Ustr_pool *

       Explanation:

         This  allocates a new pool as a child of the passed in pool (Parameter[1]), The pool can
       be freed and cleared independantly of the parent pool however free and clear operations on
       the parent pool are automatically applied to all child pools.

     Function:  ustr_pool_free()
       Returns: Nothing
       Type: void

       Parameter[1]: Pointer to a Ustr pool object
       Type[1]: struct Ustr_pool *

       Explanation:

         This deallocates a pool, and all sub-pools.

       Note:

         This also operates on all sub-pools.

     Function:  ustr_pool_clear()
       Returns: Nothing
       Type: void

       Parameter[1]: Pointer to a Ustr pool object
       Type[1]: struct Ustr_pool *

       Explanation:

         This allows all the data in the pool to be reused, it may also free some/all of the data
       in the pool, from the pool API.

       Note:

         This also operates on all sub-pools.

SEE ALSO

       ustr_const(3)