/*
 * This source file is part of the bstring string library.  This code was
 * written by Paul Hsieh in 2002-2015, and is covered by the BSD open source
 * license and the GPL. Refer to the accompanying documentation for details
 * on usage and license.
 */

/*
 * bstrlib.h
 *
 * This file is the interface for the core bstring functions.
 */

#ifndef BSTRLIB_INCLUDE
#define BSTRLIB_INCLUDE

#ifdef __cplusplus
extern "C" {
#endif

#include <stdarg.h>
#include <string.h>
#include <limits.h>
#include <ctype.h>

struct bStream;

#if !defined(BSTRLIB_VSNP_OK) && !defined(BSTRLIB_NOVSNP)
#if defined(__TURBOC__) && !defined(__BORLANDC__)
#define BSTRLIB_NOVSNP
#endif
#endif

#define BSTR_ERR (-1)
#define BSTR_OK (0)
#define BSTR_BS_BUFF_LENGTH_GET (0)

typedef struct tagbstring* bstring;
typedef const struct tagbstring* const_bstring;

/* Copy functions */
#define cstr2bstr bfromcstr
extern bstring bfromcstr(const char* str);
extern bstring bfromcstr_for_nas_msg_container(const char* str, int len);
extern bstring bfromcstralloc(int mlen, const char* str);
extern bstring bfromcstrrangealloc(int minl, int maxl, const char* str);
extern bstring blk2bstr(const void* blk, int len);
extern char* bstr2cstr(const_bstring s, char z);
extern int bcstrfree(char* s);
extern bstring bstrcpy(const_bstring b1);
extern int bassign(bstring a, const_bstring b);
extern int bassignmidstr(bstring a, const_bstring b, int left, int len);
extern int bassigncstr(bstring a, const char* str);
extern int bassignblk(bstring a, const void* s, int len);

/* Destroy function */
extern int bdestroy(bstring b);

/* Space allocation hinting functions */
extern int balloc(bstring s, int len);
extern int ballocmin(bstring b, int len);

/* Substring extraction */
extern bstring bmidstr(const_bstring b, int left, int len);

/* Various standard manipulations */
extern int bconcat(bstring b0, const_bstring b1);
extern int bconchar(bstring b0, char c);
extern int bcatcstr(bstring b, const char* s);
extern int bcatblk(bstring b, const void* s, int len);
extern int binsert(bstring s1, int pos, const_bstring s2, unsigned char fill);
extern int binsertblk(
    bstring s1, int pos, const void* s2, int len, unsigned char fill);
extern int binsertch(bstring s1, int pos, int len, unsigned char fill);
extern int breplace(
    bstring b1, int pos, int len, const_bstring b2, unsigned char fill);
extern int bdelete(bstring s1, int pos, int len);
extern int bsetstr(bstring b0, int pos, const_bstring b1, unsigned char fill);
extern int btrunc(bstring b, int n);

/* Scan/search functions */
extern int bstricmp(const_bstring b0, const_bstring b1);
extern int bstrnicmp(const_bstring b0, const_bstring b1, int n);
extern int biseqcaseless(const_bstring b0, const_bstring b1);
extern int biseqcaselessblk(const_bstring b, const void* blk, int len);
extern int bisstemeqcaselessblk(const_bstring b0, const void* blk, int len);
extern int biseq(const_bstring b0, const_bstring b1);
extern int biseqblk(const_bstring b, const void* blk, int len);
extern int bisstemeqblk(const_bstring b0, const void* blk, int len);
extern int biseqcstr(const_bstring b, const char* s);
extern int biseqcstrcaseless(const_bstring b, const char* s);
extern int bstrcmp(const_bstring b0, const_bstring b1);
extern int bstrncmp(const_bstring b0, const_bstring b1, int n);
extern int binstr(const_bstring s1, int pos, const_bstring s2);
extern int binstrr(const_bstring s1, int pos, const_bstring s2);
extern int binstrcaseless(const_bstring s1, int pos, const_bstring s2);
extern int binstrrcaseless(const_bstring s1, int pos, const_bstring s2);
extern int bstrchrp(const_bstring b, int c, int pos);
extern int bstrrchrp(const_bstring b, int c, int pos);
#define bstrchr(b, c) bstrchrp((b), (c), 0)
#define bstrrchr(b, c) bstrrchrp((b), (c), blength(b) - 1)
extern int binchr(const_bstring b0, int pos, const_bstring b1);
extern int binchrr(const_bstring b0, int pos, const_bstring b1);
extern int bninchr(const_bstring b0, int pos, const_bstring b1);
extern int bninchrr(const_bstring b0, int pos, const_bstring b1);
extern int bfindreplace(
    bstring b, const_bstring find, const_bstring repl, int pos);
extern int bfindreplacecaseless(
    bstring b, const_bstring find, const_bstring repl, int pos);

/* List of string container functions */
struct bstrList {
  int qty, mlen;
  bstring* entry;
};
extern struct bstrList* bstrListCreate(void);
extern int bstrListDestroy(struct bstrList* sl);
extern int bstrListAlloc(struct bstrList* sl, int msz);
extern int bstrListAllocMin(struct bstrList* sl, int msz);

/* String split and join functions */
extern struct bstrList* bsplit(const_bstring str, unsigned char splitChar);
extern struct bstrList* bsplits(const_bstring str, const_bstring splitStr);
extern struct bstrList* bsplitstr(const_bstring str, const_bstring splitStr);
extern bstring bjoin(const struct bstrList* bl, const_bstring sep);
extern bstring bjoinblk(const struct bstrList* bl, const void* s, int len);
extern int bsplitcb(
    const_bstring str, unsigned char splitChar, int pos,
    int (*cb)(void* parm, int ofs, int len), void* parm);
extern int bsplitscb(
    const_bstring str, const_bstring splitStr, int pos,
    int (*cb)(void* parm, int ofs, int len), void* parm);
extern int bsplitstrcb(
    const_bstring str, const_bstring splitStr, int pos,
    int (*cb)(void* parm, int ofs, int len), void* parm);

/* Miscellaneous functions */
extern int bpattern(bstring b, int len);
extern int btoupper(bstring b);
extern int btolower(bstring b);
extern int bltrimws(bstring b);
extern int brtrimws(bstring b);
extern int btrimws(bstring b);

#if !defined(BSTRLIB_NOVSNP)
extern bstring bformat(const char* fmt, ...);
extern int bformata(bstring b, const char* fmt, ...);
extern int bassignformat(bstring b, const char* fmt, ...);
extern int bvcformata(bstring b, int count, const char* fmt, va_list arglist);

#define bvformata(ret, b, fmt, lastarg)                                        \
  {                                                                            \
    bstring bstrtmp_b       = (b);                                             \
    const char* bstrtmp_fmt = (fmt);                                           \
    int bstrtmp_r = BSTR_ERR, bstrtmp_sz = 16;                                 \
    for (;;) {                                                                 \
      va_list bstrtmp_arglist;                                                 \
      va_start(bstrtmp_arglist, lastarg);                                      \
      bstrtmp_r =                                                              \
          bvcformata(bstrtmp_b, bstrtmp_sz, bstrtmp_fmt, bstrtmp_arglist);     \
      va_end(bstrtmp_arglist);                                                 \
      if (bstrtmp_r >= 0) { /* Everything went ok */                           \
        bstrtmp_r = BSTR_OK;                                                   \
        break;                                                                 \
      } else if (-bstrtmp_r <= bstrtmp_sz) { /* A real error? */               \
        bstrtmp_r = BSTR_ERR;                                                  \
        break;                                                                 \
      }                                                                        \
      bstrtmp_sz = -bstrtmp_r; /* Doubled or target size */                    \
    }                                                                          \
    ret = bstrtmp_r;                                                           \
  }

#endif

typedef int (*bNgetc)(void* parm);
typedef size_t (*bNread)(void* buff, size_t elsize, size_t nelem, void* parm);

/* Input functions */
extern bstring bgets(bNgetc getcPtr, void* parm, char terminator);
extern bstring bread(bNread readPtr, void* parm);
extern int bgetsa(bstring b, bNgetc getcPtr, void* parm, char terminator);
extern int bassigngets(bstring b, bNgetc getcPtr, void* parm, char terminator);
extern int breada(bstring b, bNread readPtr, void* parm);

/* Stream functions */
extern struct bStream* bsopen(bNread readPtr, void* parm);
extern void* bsclose(struct bStream* s);
extern int bsbufflength(struct bStream* s, int sz);
extern int bsreadln(bstring b, struct bStream* s, char terminator);
extern int bsreadlns(bstring r, struct bStream* s, const_bstring term);
extern int bsread(bstring b, struct bStream* s, int n);
extern int bsreadlna(bstring b, struct bStream* s, char terminator);
extern int bsreadlnsa(bstring r, struct bStream* s, const_bstring term);
extern int bsreada(bstring b, struct bStream* s, int n);
extern int bsunread(struct bStream* s, const_bstring b);
extern int bspeek(bstring r, const struct bStream* s);
extern int bssplitscb(
    struct bStream* s, const_bstring splitStr,
    int (*cb)(void* parm, int ofs, const_bstring entry), void* parm);
extern int bssplitstrcb(
    struct bStream* s, const_bstring splitStr,
    int (*cb)(void* parm, int ofs, const_bstring entry), void* parm);
extern int bseof(const struct bStream* s);

struct tagbstring {
  int mlen;
  int slen;
  unsigned char* data;
};

/* Accessor macros */
#define blengthe(b, e)                                                         \
  (((b) == (void*) 0 || (b)->slen < 0) ? (int) (e) : ((b)->slen))
#define blength(b) (blengthe((b), 0))
#define bdataofse(b, o, e)                                                     \
  (((b) == (void*) 0 || (b)->data == (void*) 0) ? (char*) (e) :                \
                                                  ((char*) (b)->data) + (o))
#define bdataofs(b, o) (bdataofse((b), (o), (void*) 0))
#define bdatae(b, e) (bdataofse(b, 0, e))
#define bdata(b) (bdataofs(b, 0))
#define bchare(b, p, e)                                                        \
  ((((unsigned) (p)) < (unsigned) blength(b)) ? ((b)->data[(p)]) : (e))
#define bchar(b, p) bchare((b), (p), '\0')

/* Static constant string initialization macro */
#define bsStaticMlen(q, m)                                                     \
  { (m), (int) sizeof(q) - 1, (unsigned char*) ("" q "") }
#if defined(_MSC_VER)
#define bsStatic(q) bsStaticMlen(q, -32)
#endif
#ifndef bsStatic
#define bsStatic(q) bsStaticMlen(q, -__LINE__)
#endif

/* Static constant block parameter pair */
#define bsStaticBlkParms(q) ((void*) ("" q "")), ((int) sizeof(q) - 1)

#define bcatStatic(b, s) ((bcatblk)((b), bsStaticBlkParms(s)))
#define bfromStatic(s) ((blk2bstr)(bsStaticBlkParms(s)))
#define bassignStatic(b, s) ((bassignblk)((b), bsStaticBlkParms(s)))
#define binsertStatic(b, p, s, f)                                              \
  ((binsertblk)((b), (p), bsStaticBlkParms(s), (f)))
#define bjoinStatic(b, s) ((bjoinblk)((b), bsStaticBlkParms(s)))
#define biseqStatic(b, s) ((biseqblk)((b), bsStaticBlkParms(s)))
#define bisstemeqStatic(b, s) ((bisstemeqblk)((b), bsStaticBlkParms(s)))
#define biseqcaselessStatic(b, s) ((biseqcaselessblk)((b), bsStaticBlkParms(s)))
#define bisstemeqcaselessStatic(b, s)                                          \
  ((bisstemeqcaselessblk)((b), bsStaticBlkParms(s)))

/* Reference building macros */
#define cstr2tbstr btfromcstr
#define btfromcstr(t, s)                                                       \
  {                                                                            \
    (t).data = (unsigned char*) (s);                                           \
    (t).slen = ((t).data) ? ((int) (strlen)((char*) (t).data)) : 0;            \
    (t).mlen = -1;                                                             \
  }
#define blk2tbstr(t, s, l)                                                     \
  {                                                                            \
    (t).data = (unsigned char*) (s);                                           \
    (t).slen = l;                                                              \
    (t).mlen = -1;                                                             \
  }
#define btfromblk(t, s, l) blk2tbstr(t, s, l)
#define bmid2tbstr(t, b, p, l)                                                 \
  {                                                                            \
    const_bstring bstrtmp_s = (b);                                             \
    if (bstrtmp_s && bstrtmp_s->data && bstrtmp_s->slen >= 0) {                \
      int bstrtmp_left = (p);                                                  \
      int bstrtmp_len  = (l);                                                  \
      if (bstrtmp_left < 0) {                                                  \
        bstrtmp_len += bstrtmp_left;                                           \
        bstrtmp_left = 0;                                                      \
      }                                                                        \
      if (bstrtmp_len > bstrtmp_s->slen - bstrtmp_left)                        \
        bstrtmp_len = bstrtmp_s->slen - bstrtmp_left;                          \
      if (bstrtmp_len <= 0) {                                                  \
        (t).data = (unsigned char*) "";                                        \
        (t).slen = 0;                                                          \
      } else {                                                                 \
        (t).data = bstrtmp_s->data + bstrtmp_left;                             \
        (t).slen = bstrtmp_len;                                                \
      }                                                                        \
    } else {                                                                   \
      (t).data = (unsigned char*) "";                                          \
      (t).slen = 0;                                                            \
    }                                                                          \
    (t).mlen = -__LINE__;                                                      \
  }
#define btfromblkltrimws(t, s, l)                                              \
  {                                                                            \
    int bstrtmp_idx = 0, bstrtmp_len = (l);                                    \
    unsigned char* bstrtmp_s = (s);                                            \
    if (bstrtmp_s && bstrtmp_len >= 0) {                                       \
      for (; bstrtmp_idx < bstrtmp_len; bstrtmp_idx++) {                       \
        if (!isspace(bstrtmp_s[bstrtmp_idx])) break;                           \
      }                                                                        \
    }                                                                          \
    (t).data = bstrtmp_s + bstrtmp_idx;                                        \
    (t).slen = bstrtmp_len - bstrtmp_idx;                                      \
    (t).mlen = -__LINE__;                                                      \
  }
#define btfromblkrtrimws(t, s, l)                                              \
  {                                                                            \
    int bstrtmp_len          = (l) -1;                                         \
    unsigned char* bstrtmp_s = (s);                                            \
    if (bstrtmp_s && bstrtmp_len >= 0) {                                       \
      for (; bstrtmp_len >= 0; bstrtmp_len--) {                                \
        if (!isspace(bstrtmp_s[bstrtmp_len])) break;                           \
      }                                                                        \
    }                                                                          \
    (t).data = bstrtmp_s;                                                      \
    (t).slen = bstrtmp_len + 1;                                                \
    (t).mlen = -__LINE__;                                                      \
  }
#define btfromblktrimws(t, s, l)                                               \
  {                                                                            \
    int bstrtmp_idx = 0, bstrtmp_len = (l) -1;                                 \
    unsigned char* bstrtmp_s = (s);                                            \
    if (bstrtmp_s && bstrtmp_len >= 0) {                                       \
      for (; bstrtmp_idx <= bstrtmp_len; bstrtmp_idx++) {                      \
        if (!isspace(bstrtmp_s[bstrtmp_idx])) break;                           \
      }                                                                        \
      for (; bstrtmp_len >= bstrtmp_idx; bstrtmp_len--) {                      \
        if (!isspace(bstrtmp_s[bstrtmp_len])) break;                           \
      }                                                                        \
    }                                                                          \
    (t).data = bstrtmp_s + bstrtmp_idx;                                        \
    (t).slen = bstrtmp_len + 1 - bstrtmp_idx;                                  \
    (t).mlen = -__LINE__;                                                      \
  }

/* Write protection macros */
#define bwriteprotect(t)                                                       \
  {                                                                            \
    if ((t).mlen >= 0) (t).mlen = -1;                                          \
  }
#define bwriteallow(t)                                                         \
  {                                                                            \
    if ((t).mlen == -1) (t).mlen = (t).slen + ((t).slen == 0);                 \
  }
#define biswriteprotected(t) ((t).mlen <= 0)

#ifdef __cplusplus
}
#endif

#endif
