/*	$OpenBSD: safe_sprintf.c,v 1.2 1999/03/02 06:23:27 millert Exp $	*/

/****************************************************************************
 * Copyright (c) 1998 Free Software Foundation, Inc.                        *
 *                                                                          *
 * 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, distribute with modifications, 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 ABOVE 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.                               *
 *                                                                          *
 * Except as contained in this notice, the name(s) of the above copyright   *
 * holders shall not be used in advertising or otherwise to promote the     *
 * sale, use or other dealings in this Software without prior written       *
 * authorization.                                                           *
 ****************************************************************************/

/****************************************************************************
 *  Author: Thomas E. Dickey <dickey@clark.net> 1997                        *
 ****************************************************************************/

#include <curses.priv.h>
#include <ctype.h>

MODULE_ID("$From: safe_sprintf.c,v 1.10 1999/02/27 19:56:37 tom Exp $")

#if USE_SAFE_SPRINTF

typedef enum { Flags, Width, Prec, Type, Format } PRINTF;

#define VA_INTGR(type) ival = va_arg(ap, type)
#define VA_FLOAT(type) fval = va_arg(ap, type)
#define VA_POINT(type) pval = (void *)va_arg(ap, type)

/*
 * Scan a variable-argument list for printf to determine the number of
 * characters that would be emitted.
 */
static int
_nc_printf_length(const char *fmt, va_list ap)
{
	size_t length = BUFSIZ;
	char *buffer;
	char *format;
	int len = 0;

	if (fmt == 0 || *fmt == '\0')
		return -1;
	if ((format = typeMalloc(char, strlen(fmt)+1)) == 0)
		return -1;
	if ((buffer = typeMalloc(char, length)) == 0) {
		free(format);
		return -1;
	}

	while (*fmt != '\0') {
		if (*fmt == '%') {
			static char dummy[] = "";
			PRINTF state = Flags;
			char *pval   = dummy;	/* avoid const-cast */
			double fval  = 0.0;
			int done     = FALSE;
			int ival     = 0;
			int prec     = -1;
			int type     = 0;
			int used     = 0;
			int width    = -1;
			size_t f     = 0;

			format[f++] = *fmt;
			while (*++fmt != '\0' && len >= 0 && !done) {
				format[f++] = *fmt;

				if (isdigit(*fmt)) {
					int num = *fmt - '0';
					if (state == Flags && num != 0)
						state = Width;
					if (state == Width) {
						if (width < 0)
							width = 0;
						width = (width * 10) + num;
					} else if (state == Prec) {
						if (prec < 0)
							prec = 0;
						prec = (prec * 10) + num;
					}
				} else if (*fmt == '*') {
					VA_INTGR(int);
					if (state == Flags)
						state = Width;
					if (state == Width) {
						width = ival;
					} else if (state == Prec) {
						prec = ival;
					}
					sprintf(&format[--f], "%d", ival);
					f = strlen(format);
				} else if (isalpha(*fmt)) {
					done = TRUE;
					switch (*fmt) {
					case 'Z': /* FALLTHRU */
					case 'h': /* FALLTHRU */
					case 'l': /* FALLTHRU */
					case 'L': /* FALLTHRU */
						done = FALSE;
						type = *fmt;
						break;
					case 'i': /* FALLTHRU */
					case 'd': /* FALLTHRU */
					case 'u': /* FALLTHRU */
					case 'x': /* FALLTHRU */
					case 'X': /* FALLTHRU */
						if (type == 'l')
							VA_INTGR(long);
						else if (type == 'Z')
							VA_INTGR(size_t);
						else
							VA_INTGR(int);
						used = 'i';
						break;
					case 'f': /* FALLTHRU */
					case 'e': /* FALLTHRU */
					case 'E': /* FALLTHRU */
					case 'g': /* FALLTHRU */
					case 'G': /* FALLTHRU */
						if (type == 'L')
							VA_FLOAT(long double);
						else
							VA_FLOAT(double);
						used = 'f';
						break;
					case 'c':
						VA_INTGR(int);
						used = 'i';
						break;
					case 's':
						VA_POINT(char *);
						if (prec < 0)
							prec = strlen(pval);
						if (prec > (int)length) {
							length = length + prec;
							buffer = typeRealloc(char, length, buffer);
							if (buffer == 0) {
								free(format);
								return -1;
							}
						}
						used = 'p';
						break;
					case 'p':
						VA_POINT(void *);
						used = 'p';
						break;
					case 'n':
						VA_POINT(int *);
						used = 0;
						break;
					default:
						break;
					}
				} else if (*fmt == '.') {
					state = Prec;
				} else if (*fmt == '%') {
					done = TRUE;
					used = 'p';
				}
			}
			format[f] = '\0';
			switch (used) {
			case 'i':
				sprintf(buffer, format, ival);
				break;
			case 'f':
				sprintf(buffer, format, fval);
				break;
			default:
				sprintf(buffer, format, pval);
				break;
			}
			len += (int)strlen(buffer);
		} else {
			fmt++;
			len++;
		}
	}

	free(buffer);
	free(format);
	return len;
}
#endif

/*
 * Wrapper for vsprintf that allocates a buffer big enough to hold the result.
 */
char *
_nc_printf_string(const char *fmt, va_list ap)
{
#if USE_SAFE_SPRINTF
	char *buf = 0;
	int len = _nc_printf_length(fmt, ap);

	if (len > 0) {
		if ((buf = typeMalloc(char, len+1)) == 0)
			return(0);
		vsprintf(buf, fmt, ap);
	}
#else
	static int rows, cols;
	static char *buf;
	static size_t len;

	if (screen_lines > rows || screen_columns > cols) {
		if (screen_lines   > rows) rows = screen_lines;
		if (screen_columns > cols) cols = screen_columns;
		len = (rows * (cols + 1)) + 1;
		buf = typeRealloc(char, len, buf);
		if (buf == 0) {
			return(0);
		}
	}

	if (buf != 0) {
# if HAVE_VSNPRINTF
		vsnprintf(buf, len, fmt, ap);	/* GNU extension */
# else
		vsprintf(buf, fmt, ap);		/* ANSI */
# endif
	}
#endif
	return buf;
}