/* strbuf - String buffer routines

 *

 * Copyright (c) 2010-2012  Mark Pulford <mark@kyne.com.au>

 *

 * Permission is hereby granted, free of charge, to any person obtaining

 * a copy of this software and associated documentation files (the

 * "Software"), to deal in the Software without restriction, including

 * without limitation the rights to use, copy, modify, merge, publish,

 * distribute, sublicense, and/or sell copies of the Software, and to

 * permit persons to whom the Software is furnished to do so, subject to

 * the following conditions:

 *

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 */

#include <stdio.h>

#include <stdlib.h>

#include <stdarg.h>

#include <string.h>

#include "strbuf.h"

#include "small/ibuf.h"

static void die(const char *fmt, ...)

{

    va_list arg;

    va_start(arg, fmt);

    vfprintf(stderr, fmt, arg);

    va_end(arg);

    fprintf(stderr, "\n");

    exit(-1);

}

void strbuf_create(strbuf_t *s, int len, struct ibuf *ibuf)

{

    int size;

    if (len <= 0)

        size = STRBUF_DEFAULT_SIZE;

    else

        size = len + 1;         /* \0 terminator */

    s->buf = ibuf_reserve(ibuf, size);

    s->size = size;

    s->length = 0;

    s->increment = STRBUF_DEFAULT_INCREMENT;

    s->reallocs = 0;

    s->debug = 0;

    s->ibuf = ibuf;

    if (!s->buf)

        die("Out of memory");

    strbuf_ensure_null(s);

}

void strbuf_set_increment(strbuf_t *s, int increment)

{

    /* Increment > 0:  Linear buffer growth rate

     * Increment < -1: Exponential buffer growth rate */

    if (increment == 0 || increment == -1)

        die("BUG: Invalid string increment");

    s->increment = increment;

}

static inline void debug_stats(strbuf_t *s)

{

    if (s->debug) {

        fprintf(stderr, "strbuf(%lx) reallocs: %d, length: %d, size: %d\n",

                (long)s, s->reallocs, s->length, s->size);

    }

}

void strbuf_destroy(strbuf_t *s)

{

    debug_stats(s);

}

static int calculate_new_size(strbuf_t *s, int len)

{

    int reqsize, newsize;

    if (len <= 0)

        die("BUG: Invalid strbuf length requested");

    /* Ensure there is room for optional NULL termination */

    reqsize = len + 1;

    /* If the user has requested to shrink the buffer, do it exactly */

    if (s->size > reqsize)

        return reqsize;

    newsize = s->size;

    if (s->increment < 0) {

        /* Exponential sizing */

        while (newsize < reqsize)

            newsize *= -s->increment;

    } else {

        /* Linear sizing */

        newsize = ((newsize + s->increment - 1) / s->increment) * s->increment;

    }

    return newsize;

}

/* Ensure strbuf can handle a string length bytes long (ignoring NULL

 * optional termination). */

void strbuf_resize(strbuf_t *s, int len)

{

    int newsize;

    newsize = calculate_new_size(s, len);

    if (s->debug > 1) {

        fprintf(stderr, "strbuf(%lx) resize: %d => %d\n",

                (long)s, s->size, newsize);

    }

    s->size = newsize;

    struct ibuf *ibuf = s->ibuf;

    /*

     * Propagate the write position to enable memcpy() when realloc happens

     * inside of the ibuf.

     */

    ibuf->wpos += s->length;

    s->buf = ibuf_reserve(ibuf, newsize - s->length) - s->length;

    /*

     * But then it is reverted because memcpy() of the old data is done, and the

     * write position + capacity are managed by strbuf itself.

     */

    ibuf->wpos = s->buf;

    if (!s->buf)

        die("Out of memory");

    s->reallocs++;

}

void strbuf_append_string(strbuf_t *s, const char *str)

{

    int space, i;

    space = strbuf_empty_length(s);

    for (i = 0; str[i]; i++) {

        if (space < 1) {

            strbuf_resize(s, s->length + 1);

            space = strbuf_empty_length(s);

        }

        s->buf[s->length] = str[i];

        s->length++;

        space--;

    }

}

/* strbuf_append_fmt() should only be used when an upper bound

 * is known for the output string. */

void strbuf_append_fmt(strbuf_t *s, int len, const char *fmt, ...)

{

    va_list arg;

    int fmt_len;

    strbuf_ensure_empty_length(s, len);

    va_start(arg, fmt);

    fmt_len = vsnprintf(s->buf + s->length, len, fmt, arg);

    va_end(arg);

    if (fmt_len < 0)

        die("BUG: Unable to convert number");  /* This should never happen.. */

    s->length += fmt_len;

}

/* strbuf_append_fmt_retry() can be used when the there is no known

 * upper bound for the output string. */

void strbuf_append_fmt_retry(strbuf_t *s, const char *fmt, ...)

{

    va_list arg;

    int fmt_len, try;

    int empty_len;

    /* If the first attempt to append fails, resize the buffer appropriately

     * and try again */

    for (try = 0; ; try++) {

        va_start(arg, fmt);

        /* Append the new formatted string */

        /* fmt_len is the length of the string required, excluding the

         * trailing NULL */

        empty_len = strbuf_empty_length(s);

        /* Add 1 since there is also space to store the terminating NULL. */

        fmt_len = vsnprintf(s->buf + s->length, empty_len + 1, fmt, arg);

        va_end(arg);

        if (fmt_len <= empty_len)

            break;  /* SUCCESS */

        if (try > 0)

            die("BUG: length of formatted string changed");

        strbuf_resize(s, s->length + fmt_len);

    }

    s->length += fmt_len;

}

/* vi:ai et sw=4 ts=4:

 */