/*
 * $Id: printbuf.c,v 1.5 2006/01/26 02:16:28 mclark Exp $
 *
 * Copyright (c) 2004, 2005 Metaparadigm Pte. Ltd.
 * Michael Clark <michael@metaparadigm.com>
 *
 * This library is free software; you can redistribute it and/or modify
 * it under the terms of the MIT license. See COPYING for details.
 *
 */

#include "config.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#if HAVE_STDARG_H
# include <stdarg.h>
#else /* !HAVE_STDARG_H */
# error Not enough var arg support!
#endif /* HAVE_STDARG_H */

#include "bits.h"
#include "debug.h"
#include "printbuf.h"

struct printbuf *printbuf_new()
{
	struct printbuf *p;

	if (!(p = calloc(1, sizeof(struct printbuf))))
		return NULL;
	p->size = 32;
	p->bpos = 0;
	if (!(p->buf = malloc(p->size))) {
		free(p);
		return NULL;
	}
	return p;
}


int printbuf_memappend(struct printbuf *p, char *buf, int size)
{
	char *t;
	if (p->size - p->bpos <= size) {
		int new_size = max(p->size * 2, p->bpos + size + 8);
#ifdef PRINTBUF_DEBUG
		mc_debug("printbuf_memappend: realloc " "bpos=%d wrsize=%d old_size=%d new_size=%d\n", p->bpos, size, p->size, new_size);
#endif /* PRINTBUF_DEBUG */
		if (!(t = realloc(p->buf, new_size)))
			return -1;
		p->size = new_size;
		p->buf = t;
	}
	memcpy(p->buf + p->bpos, buf, size);
	p->bpos += size;
	p->buf[p->bpos] = '\0';
	return size;
}

#if !HAVE_VSNPRINTF && defined(WIN32)
# define vsnprintf _vsnprintf
#elif !HAVE_VSNPRINTF			/* !HAVE_VSNPRINTF */
# error Need vsnprintf!
#endif /* !HAVE_VSNPRINTF && defined(WIN32) */

#if !HAVE_VASPRINTF
/* CAW: compliant version of vasprintf */
static int vasprintf(char **buf, const char *fmt, va_list ap)
{
#ifndef WIN32
	static char _T_emptybuffer = '\0';
#endif /* !defined(WIN32) */
	int chars;
	char *b;

	if (!buf) {
		return -1;
	}
#ifdef WIN32
	chars = _vscprintf(fmt, ap) + 1;
#else /* !defined(WIN32) */
	/* CAW: RAWR! We have to hope to god here that vsnprintf doesn't overwrite
	   our buffer like on some 64bit sun systems.... but hey, its time to move on */
	chars = vsnprintf(&_T_emptybuffer, 0, fmt, ap) + 1;
	if (chars < 0) {
		chars *= -1;
	}							/* CAW: old glibc versions have this problem */
#endif /* defined(WIN32) */

	b = (char *) malloc(sizeof(char) * chars);
	if (!b) {
		return -1;
	}

	if ((chars = vsprintf(b, fmt, ap)) < 0) {
		free(b);
	} else {
		*buf = b;
	}

	return chars;
}
#endif /* !HAVE_VASPRINTF */

int sprintbuf(struct printbuf *p, const char *msg, ...)
{
	va_list ap;
	char *t;
	int size;
	char buf[128];

	/* user stack buffer first */
	va_start(ap, msg);
	size = vsnprintf(buf, 128, msg, ap);
	va_end(ap);
	/* if string is greater than stack buffer, then use dynamic string
	   with vasprintf.  Note: some implementation of vsnprintf return -1
	   if output is truncated whereas some return the number of bytes that
	   would have been writen - this code handles both cases. */
	if (size == -1 || size > 127) {
		int ret;
		va_start(ap, msg);
		if ((size = vasprintf(&t, msg, ap)) == -1)
			return -1;
		va_end(ap);
		ret = printbuf_memappend(p, t, size);
		free(t);
		return ret;
	} else {
		return printbuf_memappend(p, buf, size);
	}
}

void printbuf_reset(struct printbuf *p)
{
	p->buf[0] = '\0';
	p->bpos = 0;
}

void printbuf_free(struct printbuf *p)
{
	if (p) {
		free(p->buf);
		free(p);
	}
}
