/*
 * dstring.c --
 *
 *	Implementation of the dynamic string abstract data type.
 *
 * Copyright (c) 2006 Juergen Schoenwaelder, International University Bremen.
 *
 * See the file "COPYING" for information on usage and redistribution
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 *
 * @(#) $Id: smilint.c 1867 2004-10-06 13:45:31Z strauss $
 */

#include <config.h>

#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <stdio.h>
#ifdef HAVE_WIN_H
#include "win.h"
#endif

#include "dstring.h"

#if !defined va_copy
# if defined __va_copy
#  define va_copy __va_copy			/* C99 draft proposal */
# else
#  define va_copy(lhs,rhs) (lhs) = (rhs)
# endif
#endif

#if 0
/* These functions should not be needed if inlining works properly. */
char*
dstring_str(dstring_t *ds)
{
    return ds ? ds->str : NULL;
}

size_t
dstring_len(dstring_t *ds)
{
    return ds ? ds->len : 0;
}
#endif

static inline dstring_t*
dstring_grow(dstring_t *ds, size_t len)
{
    if (ds) {
        ds->str = realloc(ds->str, len + 1);
        if (! ds->str) {
            exit(EXIT_FAILURE);
        }
        ds->str[len] = '\0';
        ds->len = len;
    }
    return ds;
}

dstring_t*
dstring_new(void)
{
    dstring_t *ds;

    ds = calloc(1, sizeof(dstring_t));
    if (! ds) {
        exit(EXIT_FAILURE);
    }
    return dstring_grow(ds, 0);
}

dstring_t*
dstring_delete(dstring_t *ds)
{
    if (ds) {
        if (ds->str) free(ds->str);
        free(ds);
    }
    return NULL;
}

dstring_t*
dstring_assign(dstring_t *ds, const char *s)
{
    if (ds && s) {
        ds = dstring_grow(ds, strlen(s));
        strcpy(ds->str, s);
    }
    return ds;
}

dstring_t*
dstring_append(dstring_t *ds, const char *s)
{
    if (ds && s) {
        ds = dstring_grow(ds, ds->len + strlen(s));
        strcat(ds->str, s);
    }
    return ds;
}


dstring_t*
dstring_append_char(dstring_t *ds, const char c)
{
    if (ds) {
        ds = dstring_grow(ds, ds->len + 1);
	ds->str[ds->len-1] = c;
    }
    return ds;
}


dstring_t*
dstring_concat(dstring_t *ds, ...)
{
    va_list ap;
    const char *s;

    if (ds) {
        va_start(ap, ds);
        for (s = va_arg(ap, char*); s; s = va_arg(ap, char*)) {
            ds = dstring_append(ds, s);
        }
        va_end(ap);
    }
    return ds;
}

dstring_t*
dstring_append_printf(dstring_t *ds, const char *format, ...)
{
    va_list ap;

    va_start(ap, format);
    ds = dstring_append_vprintf(ds, format, ap);
    va_end(ap);
    return ds;
}

dstring_t *
dstring_append_vprintf(dstring_t *ds, const char *format, va_list _ap)
{
    int n, o;
    va_list ap;
    
    if (ds) {
	o = ds->len;
        while (1) {
            va_copy(ap, _ap);
            n = vsnprintf(ds->str + o, ds->len+1 - o, format, ap);
            va_end(ap);
            if (n > -1 && n+o <= ds->len) {
                if (n+o < ds->len) {
                    dstring_truncate(ds, n+o);
                }
                return ds;
            }
            if (n > 0) {
                ds = dstring_grow(ds, n + o);	                /* C99 */
            } else {
                ds = dstring_grow(ds, ds->len + ds->len);       /* GLIBC */
            }
        }
    }

    return ds;
}

dstring_t*
dstring_printf(dstring_t *ds, const char *format, ...)
{
    va_list ap;

    va_start(ap, format);
    ds = dstring_vprintf(ds, format, ap);
    va_end(ap);
    return ds;
}

dstring_t*
dstring_vprintf(dstring_t *ds, const char *format, va_list _ap)
{
    int n;
    va_list ap;

    if (ds) {
        while (1) {
            va_copy(ap, _ap);
            n = vsnprintf(ds->str, ds->len+1, format, ap);
            va_end(ap);
            if (n > -1 && n <= ds->len) {
                if (n < ds->len) {
                    dstring_truncate(ds, n);
                }
                return ds;
            }
            if (n > 0) {
                ds = dstring_grow(ds, n);                       /* C99 */
            } else {
                ds = dstring_grow(ds, ds->len + ds->len);       /* GLIBC */
            }
        }
    }
    return ds;
}

dstring_t*
dstring_truncate(dstring_t *ds, int len)
{
    if (ds && len < ds->len) {
        ds = dstring_grow(ds, len);
    }
    return ds;
}

dstring_t*
dstring_expand(dstring_t *ds, int len, char fill)
{
    if (ds && len > ds->len) {
        int i, old = ds->len;
        ds = dstring_grow(ds, len);
        for (i = old; i < len; i++) {
            ds->str[i] = fill;
        }
    }
    return ds;
}