 @@ -1,160 +1,163 @@
-/* $NetBSD: term_private.h,v 1.10 2012/06/03 23:19:10 joerg Exp $ */
+/* $NetBSD: term_private.h,v 1.11 2013/01/24 10:41:28 roy Exp $ */
 /*
- * Copyright (c) 2009, 2010 The NetBSD Foundation, Inc.
+ * Copyright (c) 2009, 2010, 2013 The NetBSD Foundation, Inc.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Roy Marples.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #ifndef _TERM_PRIVATE_H_
 #define	_TERM_PRIVATE_H_
 /* This header should only be used by libterminfo, tic and infocmp. */
 /* The terminfo database structure is private to us,
  * so it's documented here.
  * terminfo defines the largest number as 32767 and the largest
  * compiled entry as 4093 bytes long.
  * Thus, we store all numbers as uint16_t, including string length.
  * All strings are prefixed by length, including the null terminator.
  * The largest string length we can handle is 65535 bytes,
  * including the null terminator.
  * The largest capability block we can handle is 65535 bytes.
  * This means that we exceed the current terminfo defined limits.
+ *
  * Version 1 capabilities are defined as:
  * header byte (always 1)
  * name
  * description,
  * cap length, num flags, index, char,
  * cap length, num numbers, index, number,
  * cap length, num strings, index, string,
  * cap length, num undefined caps, name, type (char), flag, number, string
+ *
  * Version 2 entries are aliases and defined as:
  * header byte (always 2)
  * 32bit id of the corresponding terminal in the file
  * name
+ *
  * The database itself is created using cdbw(3) and the numbers are
  * always stored as little endian.
  */
 #include <sys/types.h>
 #define _TERMINFO
 /* We use the same ncurses tic macros so that our data is identical
  * when a caller uses the long name macros to access te terminfo data
  * directly. */
 #define ABSENT_BOOLEAN		((signed char)-1)       /* 255 */
 #define ABSENT_NUMERIC		(-1)
 #define ABSENT_STRING		(char *)0
 #define CANCELLED_BOOLEAN	((signed char)-2)       /* 254 */
 #define CANCELLED_NUMERIC	(-2)
 #define CANCELLED_STRING	(char *)(-1)
 #define VALID_BOOLEAN(s) ((unsigned char)(s) <= 1)	/* reject "-1" */
 #define VALID_NUMERIC(s) ((s) >= 0)
 #define VALID_STRING(s)  ((s) != CANCELLED_STRING && (s) != ABSENT_STRING)
 typedef struct {
 	const char *id;
 	char type;
 	char flag;
 	short num;
 	const char *str;
 } TERMUSERDEF;
 typedef struct {
 	int fildes;
 	/* We need to expose these so that the macros work */
 	const char *name;
 	const char *desc;
 	signed char *flags;
 	short *nums;
 	const char **strs;
 	/* Storage area for terminfo data */
 	char *_area;
 	size_t _arealen;
 	size_t _nuserdefs;
 	TERMUSERDEF *_userdefs;
 	/* So we don't rely on the global ospeed */
 	short _ospeed;
 	/* Output buffer for tparm */
 	char *_buf;
 	size_t _buflen;
 	size_t _bufpos;
 	/* A-Z static variables for tparm  */
 	long _snums[26];
 	/* aliases of the terminal, | separated */
 	const char *_alias;
 } TERMINAL;
 extern const char *	_ti_database;
 ssize_t		_ti_flagindex(const char *);
 ssize_t		_ti_numindex(const char *);
 ssize_t		_ti_strindex(const char *);
 const char *	_ti_flagid(ssize_t);
 const char *	_ti_numid(ssize_t);
 const char *	_ti_strid(ssize_t);
 int		_ti_getterm(TERMINAL *, const char *, int);
 void		_ti_setospeed(TERMINAL *);
 /* libterminfo can compile terminfo strings too */
 #define TIC_WARNING	(1 << 0)
 #define TIC_DESCRIPTION	(1 << 1)
 #define TIC_ALIAS	(1 << 2)
 #define TIC_COMMENT	(1 << 3)
 #define TIC_EXTRA	(1 << 4)
 #define UINT16_T_MAX 0xffff
 typedef struct {
 	char *buf;
 	size_t buflen;
 	size_t bufpos;
 	size_t entries;
 } TBUF;
 typedef struct {
 	char *name;
 	char *alias;
 	char *desc;
 	TBUF flags;
 	TBUF nums;
 	TBUF strs;
 	TBUF extras;
 } TIC;
 char *_ti_grow_tbuf(TBUF *, size_t);
 char *_ti_get_token(char **, char);
 char *_ti_find_cap(TBUF *, char,  short);
 char *_ti_find_extra(TBUF *, const char *);
 size_t _ti_store_extra(TIC *, int, char *, char, char, short,
     char *, size_t, int);
 TIC *_ti_compile(char *, int);
 ssize_t _ti_flatten(uint8_t **, const TIC *);
 void _ti_freetic(TIC *);
 #define TPARM_MAX 9	/* not likely to change */
 int _ti_parm_analyse(const char *, int *, int);
 #endif

 @@ -1,569 +1,582 @@
-/* $NetBSD: tparm.c,v 1.11 2013/01/24 10:28:28 roy Exp $ */
+/* $NetBSD: tparm.c,v 1.12 2013/01/24 10:41:28 roy Exp $ */
 /*
- * Copyright (c) 2009, 2011 The NetBSD Foundation, Inc.
+ * Copyright (c) 2009, 2011, 2013 The NetBSD Foundation, Inc.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Roy Marples.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: tparm.c,v 1.11 2013/01/24 10:28:28 roy Exp $");
+__RCSID("$NetBSD: tparm.c,v 1.12 2013/01/24 10:41:28 roy Exp $");
 #include <sys/param.h>
 #include <assert.h>
 #include <ctype.h>
 #include <errno.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <term_private.h>
 #include <term.h>
 #define LONG_STR_MAX ((CHAR_BIT * sizeof(long)) / 3)
-#define BUFINC 128 /* Size to increament the terminal buffer by */
+#define BUFINC 128	/* Size to increament the terminal buffer by */
 static TERMINAL *dumbterm; /* For non thread safe functions */
 typedef struct {
 	long nums[20];
 	char *strings[20];
 	size_t offset;
 } TPSTACK;
 typedef struct {
 	long num;
 	char *string;
 } TPVAR;
 static int
 push(long num, char *string, TPSTACK *stack)
+{
 	if (stack->offset >= sizeof(stack->nums)) {
 		errno = E2BIG;
 		return -1;
+	}
 	stack->nums[stack->offset] = num;
 	stack->strings[stack->offset] = string;
 	stack->offset++;
 	return 0;
+}
 static int
 pop(long *num, char **string, TPSTACK *stack)
+{
 	if (stack->offset == 0) {
 		if (num)
 			*num = 0;
 		if (string)
 			*string = NULL;
 		errno = E2BIG;
 		return -1;
+	}
 	stack->offset--;
 	if (num)
 		*num = stack->nums[stack->offset];
 	if (string)
 		*string = stack->strings[stack->offset];
 	return 0;
+}
 static char *
 checkbuf(TERMINAL *term, size_t len)
+{
 	char *buf;
 	if (term->_bufpos + len >= term->_buflen) {
 		len = term->_buflen + MAX(len, BUFINC);
 		buf = realloc(term->_buf, len);
 		if (buf == NULL)
 			return NULL;
 		term->_buf = buf;
 		term->_buflen = len;
+	}
 	return term->_buf;
+}
 static size_t
 ochar(TERMINAL *term, int c)
+{
 	if (c == 0)
 		c = 0200;
 	/* Check we have space and a terminator */
 	if (checkbuf(term, 2) == NULL)
 		return 0;
 	term->_buf[term->_bufpos++] = (char)c;
 	return 1;
+}
 static size_t
 onum(TERMINAL *term, const char *fmt, int num, unsigned int len)
+{
 	size_t l;
 	if (len < LONG_STR_MAX)
 		len = LONG_STR_MAX;
 	if (checkbuf(term, len + 2) == NULL)
 		return 0;
 	l = sprintf(term->_buf + term->_bufpos, fmt, num);
 	term->_bufpos += l;
 	return l;
+}
 /*
   Make a pass through the string so we can work out
   which parameters are ints and which are char *.
   Basically we only use char * if %p[1-9] is followed by %l or %s.
 */
 int
 _ti_parm_analyse(const char *str, int *piss, int piss_len)
+{
 	int nparm, lpop;
 	char c;
 	nparm = 0;
 	lpop = -1;
 	while ((c = *str++) != '\0') {
 		if (c != '%')
 			continue;
 		c = *str++;
 		switch (c) {
 			case 'l': /* FALLTHROUGH */
 			case 's':
 				if (lpop > 0) {
 					if (lpop <= piss_len)
 						piss[lpop - 1] = 1;
 					else if (piss)
 						errno = E2BIG;
+				}
 				break;
 			case 'p':
 				c = *str++;
 				if (c < '1' || c > '9') {
 					errno = EINVAL;
 					continue;
 				} else {
 					lpop = c - '0';
 					if (lpop > nparm)
 						nparm = lpop;
+				}
 				break;
 			default:
 				lpop = -1;
+		}
+	}
 	return nparm;
+}
 static char *
 _ti_tiparm(TERMINAL *term, const char *str, int va_long, va_list parms)
+{
 	const char *sp;
 	char c, fmt[64], *fp, *ostr;
 	long val, val2;
 	long dnums[26]; /* dynamic variables a-z, not preserved */
 	size_t l, max;
 	TPSTACK stack;
-	TPVAR params[9];
+	TPVAR params[TPARM_MAX];
 	unsigned int done, dot, minus, width, precision, olen;
-	int piss[9]; /* Parameter IS String - piss ;) */
+	int piss[TPARM_MAX]; /* Parameter IS String - piss ;) */
 	if (str == NULL)
 		return NULL;
 	/*
 	  If not passed a terminal, malloc a dummy one.
 	  This means we can preserve buffers and variables per terminal and
 	  still work with non thread safe functions (which sadly are still the
 	  norm and standard).
 	*/
 	if (term == NULL) {
 		if (dumbterm == NULL) {
 			dumbterm = malloc(sizeof(*dumbterm));
 			if (dumbterm == NULL)
 				return NULL;
 			dumbterm->_buflen = 0;
+		}
 		term = dumbterm;
+	}
 	term->_bufpos = 0;
 	/* Ensure we have an initial buffer */
 	if (term->_buflen == 0) {
 		term->_buf = malloc(BUFINC);
 		if (term->_buf == NULL)
 			return NULL;
 		term->_buflen = BUFINC;
+	}
 	/*
 	  Make a first pass through the string so we can work out
 	  which parameters are ints and which are char *.
 	  Basically we only use char * if %p[1-9] is followed by %l or %s.
 	*/
 	memset(&piss, 0, sizeof(piss));
-	max = 0;
+	max = _ti_parm_analyse(str, piss, TPARM_MAX);
 	sp = str;
 	while ((c = *sp++) != '\0') {
 		if (c != '%')
 			continue;
 		c = *sp++;
 		if (c == '\0')
 			break;
 		if (c != 'p')
 			continue;
 		c = *sp++;
 		if (c < '1' || c > '9') {
 			errno = EINVAL;
 			continue;
 		l = c - '0';
 		if (l > max)
 			max = l;
 		if (*sp != '%')
 			continue;
 		/* Skip formatting */
 		sp++;
 		while (*sp == '.' || *sp == '#' || *sp == ' ' || *sp == ':' ||
 		    *sp == '-' || isdigit((unsigned char)*sp))
 			sp++;
 		if (*sp == 'l' || *sp == 's')
 			piss[l - 1] = 1;
 	/* Put our parameters into variables */
 	memset(&params, 0, sizeof(params));
 	for (l = 0; l < max; l++) {
 		if (piss[l])
 			params[l].string = va_arg(parms, char *);
 		else if (va_long)
 			params[l].num = va_arg(parms, long);
 		else
 			params[l].num = (long)va_arg(parms, int);
+	}
 	memset(&stack, 0, sizeof(stack));
 	while ((c = *str++) != '\0') {
 		if (c != '%' || (c = *str++) == '%') {
 			if (c == '\0')
 				break;
 			if (ochar(term, c) == 0)
 				return NULL;
 			continue;
+		}
 		/* Handle formatting. */
 		fp = fmt;
 		*fp++ = '%';
 		done = dot = minus = width = precision = 0;
 		val = 0;
 		while (done == 0 && (size_t)(fp - fmt) < sizeof(fmt)) {
 			switch (c) {
 			case 'c': /* FALLTHROUGH */
 			case 's':
 				*fp++ = c;
 				done = 1;
 				break;
 			case 'd': /* FALLTHROUGH */
 			case 'o': /* FALLTHROUGH */
 			case 'x': /* FALLTHROUGH */
 			case 'X': /* FALLTHROUGH */
 				*fp++ = 'l';
 				*fp++ = c;
 				done = 1;
 				break;
 			case '#': /* FALLTHROUGH */
 			case ' ':
 				*fp++ = c;
 				break;
 			case '.':
 				*fp++ = c;
 				if (dot == 0) {
 					dot = 1;
 					width = val;
 				} else
 					done = 2;
 				val = 0;
 				break;
 			case ':':
 				minus = 1;
 				break;
 			case '-':
 				if (minus)
 					*fp++ = c;
 				else
 					done = 1;
 				break;
 			default:
 				if (isdigit((unsigned char)c)) {
 					val = (val * 10) + (c - '0');
 					if (val > 10000)
 						done = 2;
 					else
 						*fp++ = c;
 				} else
 					done = 1;
+			}
 			if (done == 0)
 				c = *str++;
+		}
 		if (done == 2) {
 			/* Found an error in the format */
 			fp = fmt + 1;
 			*fp = *str;
 			olen = 0;
 		} else {
 			if (dot == 0)
 				width = val;
 			else
 				precision = val;
 			olen = MAX(width, precision);
+		}
 		*fp++ = '\0';
 		/* Handle commands */
 		switch (c) {
 		case 'c':
 			pop(&val, NULL, &stack);
 			if (ochar(term, (unsigned char)val) == 0)
 				return NULL;
 			break;
 		case 's':
 			pop(NULL, &ostr, &stack);
 			if (ostr != NULL) {
 				l = strlen(ostr);
 				if (l < (size_t)olen)
 					l = olen;
 				if (checkbuf(term, (size_t)(l + 1)) == NULL)
 					return NULL;
 				l = sprintf(term->_buf + term->_bufpos,
 				    fmt, ostr);
 				term->_bufpos += l;
+			}
 			break;
 		case 'l':
 			pop(NULL, &ostr, &stack);
 			if (ostr == NULL)
 				l = 0;
 			else
 				l = strlen(ostr);
 #ifdef NCURSES_COMPAT_57
 			if (onum(term, "%ld", (long)l, 0) == 0)
 				return NULL;
 #else
 			push((long)l, NULL, &stack);
 #endif
 			break;
 		case 'd': /* FALLTHROUGH */
 		case 'o': /* FALLTHROUGH */
 		case 'x': /* FALLTHROUGH */
 		case 'X':
 			pop(&val, NULL, &stack);
 			if (onum(term, fmt, (int)val, olen) == 0)
 				return NULL;
 			break;
 		case 'p':
 			if (*str < '1' || *str > '9')
 				break;
 			l = *str++ - '1';
 			if (push(params[l].num, params[l].string, &stack))
 				return NULL;
 			break;
 		case 'P':
 			pop(&val, NULL, &stack);
 			if (*str >= 'a' && *str <= 'z')
 				dnums[*str - 'a'] = val;
 			else if (*str >= 'A' && *str <= 'Z')
 				term->_snums[*str - 'A'] = val;
 			break;
 		case 'g':
 			if (*str >= 'a' && *str <= 'z') {
 				if (push(dnums[*str - 'a'], NULL, &stack))
 					return NULL;
 			} else if (*str >= 'A' && *str <= 'Z') {
 				if (push(term->_snums[*str - 'A'],
 					NULL, &stack))
 					return NULL;
+			}
 			break;
 		case 'i':
 			if (piss[0] == 0)
 				params[0].num++;
 			if (piss[1] == 0)
 				params[1].num++;
 			break;
 		case '\'':
 			if (push((long)(unsigned char)*str++, NULL, &stack))
 				return NULL;
 			while (*str != '\0' && *str != '\'')
 				str++;
 			if (*str == '\'')
 				str++;
 			break;
 		case '{':
 			val = 0;
 			for (; isdigit((unsigned char)*str);  str++)
 				val = (val * 10) + (*str - '0');
 			if (push(val, NULL, &stack))
 				return NULL;
 			while (*str != '\0' && *str != '}')
 				str++;
 			if (*str == '}')
 				str++;
 			break;
 		case '+': /* FALLTHROUGH */
 		case '-': /* FALLTHROUGH */
 		case '*': /* FALLTHROUGH */
 		case '/': /* FALLTHROUGH */
 		case 'm': /* FALLTHROUGH */
 		case 'A': /* FALLTHROUGH */
 		case 'O': /* FALLTHROUGH */
 		case '&': /* FALLTHROUGH */
 		case '|': /* FALLTHROUGH */
 		case '^': /* FALLTHROUGH */
 		case '=': /* FALLTHROUGH */
 		case '<': /* FALLTHROUGH */
 		case '>':
 			pop(&val, NULL, &stack);
 			pop(&val2, NULL, &stack);
 			switch (c) {
 			case '+':
 				val = val + val2;
 				break;
 			case '-':
 				val = val2 - val;
 				break;
 			case '*':
 				val = val * val2;
 				break;
 			case '/':
 				val = val ? val2 / val : 0;
 				break;
 			case 'm':
 				val = val ? val2 % val : 0;
 				break;
 			case 'A':
 				val = val && val2;
 				break;
 			case 'O':
 				val = val || val2;
 				break;
 			case '&':
 				val = val & val2;
 				break;
 			case '|':
 				val = val | val2;
 				break;
 			case '^':
 				val = val ^ val2;
 				break;
 			case '=':
 				val = val == val2;
 				break;
 			case '<':
 				val = val2 < val;
 				break;
 			case '>':
 				val = val2 > val;
 				break;
+			}
 			if (push(val, NULL, &stack))
 				return NULL;
 			break;
 		case '!':
 		case '~':
 			pop(&val, NULL, &stack);
 			switch (c) {
 			case '!':
 				val = !val;
 				break;
 			case '~':
 				val = ~val;
 				break;
+			}
 			if (push(val, NULL, &stack))
 				return NULL;
 			break;
 		case '?': /* if */
 			break;
 		case 't': /* then */
 			pop(&val, NULL, &stack);
 			if (val == 0) {
 				l = 0;
 				for (; *str != '\0'; str++) {
 					if (*str != '%')
 						continue;
 					str++;
 					if (*str == '?')
 						l++;
 					else if (*str == ';') {
 						if (l > 0)
 							l--;
 						else {
 							str++;
 							break;
+						}
 					} else if (*str == 'e' && l == 0) {
 						str++;
 						break;
+					}
+				}
+			}
 			break;
 		case 'e': /* else */
 			l = 0;
 			for (; *str != '\0'; str++) {
 				if (*str != '%')
 					continue;
 				str++;
 				if (*str == '?')
 					l++;
 				else if (*str == ';') {
 					if (l > 0)
 						l--;
 					else {
 						str++;
 						break;
+					}
+				}
+			}
 			break;
 		case ';': /* fi */
 			break;
+		}
+	}
 	term->_buf[term->_bufpos] = '\0';
 	return term->_buf;
+}
 char *
 ti_tiparm(TERMINAL *term, const char *str, ...)
+{
 	va_list va;
 	char *ret;
 	_DIAGASSERT(term != NULL);
 	_DIAGASSERT(str != NULL);
 	va_start(va, str);
 	ret = _ti_tiparm(term, str, 0, va);
 	va_end(va);
 	return ret;
+}
 char *
 tiparm(const char *str, ...)
+{
 	va_list va;
 	char *ret;
 	_DIAGASSERT(str != NULL);
 	va_start(va, str);
 	ret = _ti_tiparm(NULL, str, 0, va);
 	va_end(va);
 	return ret;
+}
 /* Same as tiparm, but accepts long instead of int for the numeric params.
  * Currently there is no need for this to be a public interface and is only
  * consumed by tparm. If we need this to be public, and I really cannot
  * imagine why, then we would need ti_tlparm() as well. */
 static char *
 tlparm(const char *str, ...)
+{
 	va_list va;
 	char *ret;
 	_DIAGASSERT(str != NULL);
 	va_start(va, str);
 	ret = _ti_tiparm(NULL, str, 1, va);
 	va_end(va);
 	return ret;
+}
 char *
 tparm(const char *str,
     long p1, long p2, long p3, long p4, long p5,
     long p6, long p7, long p8, long p9)
+{
 	return tlparm(str, p1, p2, p3, p4, p5, p6, p7, p8, p9);
+}

 @@ -1,237 +1,202 @@
-/*	$NetBSD: tput.c,v 1.22 2011/10/04 12:23:14 roy Exp $	*/
+/*	$NetBSD: tput.c,v 1.23 2013/01/24 10:41:29 roy Exp $	*/
 /*-
  * Copyright (c) 1980, 1988, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #include <sys/cdefs.h>
 #ifndef lint
 __COPYRIGHT("@(#) Copyright (c) 1980, 1988, 1993\
  The Regents of the University of California.  All rights reserved.");
 #endif /* not lint */
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)tput.c	8.3 (Berkeley) 4/28/95";
 #endif
-__RCSID("$NetBSD: tput.c,v 1.22 2011/10/04 12:23:14 roy Exp $");
+__RCSID("$NetBSD: tput.c,v 1.23 2013/01/24 10:41:29 roy Exp $");
 #endif /* not lint */
 #include <termios.h>
 #include <err.h>
 #include <errno.h>
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <term_private.h>
 #include <term.h>
 #include <termcap.h>
 #include <unistd.h>
 static int    outc(int);
 static void   usage(void) __dead;
 static char **process(const char *, const char *, char **);
 int
 main(int argc, char **argv)
+{
 	int ch, exitval, n;
 	char *term;
 	const char *p, *s;
 	size_t pl;
 	term = NULL;
 	while ((ch = getopt(argc, argv, "T:")) != -1)
 		switch(ch) {
 		case 'T':
 			term = optarg;
 			break;
 		case '?':
 		default:
 			usage();
+		}
 	argc -= optind;
 	argv += optind;
 	if (!term && !(term = getenv("TERM")))
 		errx(2, "No terminal type specified and no TERM "
 		    "variable set in the environment.");
 	setupterm(term, 0, NULL);
 	for (exitval = 0; (p = *argv) != NULL; ++argv) {
 		switch (*p) {
 		case 'c':
 			if (!strcmp(p, "clear"))
 				p = "clear";
 			break;
 		case 'i':
 			if (!strcmp(p, "init")) {
 				s = tigetstr("is1");
 				if (s != NULL)
 					tputs(s, 0, outc);
 				p = "is2";
+			}
 			break;
 		case 'l':
 			if (!strcmp(p, "longname")) {
 				(void)printf("%s\n", longname());
 				continue;
+			}
 			break;
 		case 'r':
 			if (!strcmp(p, "reset")) {
 				s = tigetstr("rs1");
 				if (s != NULL)
 					tputs(s, 0, outc);
 				p = "rs2";
+			}
 			break;
+		}
 		pl = strlen(p);
 		if (((s = tigetstr(p)) != NULL && s != (char *)-1) ||
 		    (pl <= 2 && (s = tgetstr(p, NULL)) != NULL))
 			argv = process(p, s, argv);
 		else if ((((n = tigetnum(p)) != -1 && n != -2 ) ||
 			   (pl <= 2 && (n = tgetnum(p)) != -1)))
 			(void)printf("%d\n", n);
 		else {
 			exitval = tigetflag(p);
 			if (exitval == -1) {
 				if (pl <= 2)
 					exitval = !tgetflag(p);
 				else
 					exitval = 1;
 			} else
 				exitval = !exitval;
+		}
 		if (argv == NULL)
 			break;
+	}
 	return argv ? exitval : 2;
+}
 static char **
 process(const char *cap, const char *str, char **argv)
+{
 	static const char errfew[] =
 	    "Not enough arguments (%d) for capability `%s'";
 	static const char erresc[] =
-	    "Unknown %% escape `%c' for capability `%s'";
+	    "Unknown %% escape (%s) for capability `%s'";
-	char c, l;
+	static const char errnum[] =
-	const char *p;
+	    "Expected a numeric argument [%d] (%s) for capability `%s'";
-	int arg_need, p1, p2, p3, p4, p5, p6, p7, p8, p9;
+	int i, nparams, piss[TPARM_MAX];
 	long nums[TPARM_MAX];
 	char *strs[TPARM_MAX], *tmp;
 	/* Count how many values we need for this capability. */
-	arg_need = 0;
+	errno = 0;
-	p = str;
+	memset(&piss, 0, sizeof(piss));
-	while ((c = *p++) != '\0') {
+	nparams = _ti_parm_analyse(str, piss, TPARM_MAX);
-		if (c != '%')
+	if (errno == EINVAL)
-			continue;
+		errx(2, erresc, str, cap);
 		c = *p++;
-		if (c == '\0')
+	/* Create our arrays of integers and strings */
-			break;
+	for (i = 0; i < nparams; i++) {
-		if (c != 'p')
+		if (*++argv == NULL || *argv[0] == '\0')
-			continue;
+			errx(2, errfew, nparams, cap);
-		c = *p++;
+		if (piss[i])
-		if (c < '1' || c > '9')
+			strs[i] = *argv;
-			errx(2, erresc, c, cap);
+		else {
-		l = c - '0';
+			errno = 0;
-		if (l > arg_need)
+			nums[i] = strtol(*argv, &tmp, 0);
-			arg_need = l;
+			if ((errno == ERANGE &&
 			    (nums[i] == LONG_MIN || nums[i] == LONG_MAX)) ||
 			    (errno != 0 && nums[i] == 0) ||
-#define NEXT_ARG							      \
+			    tmp == str ||
-	{								      \
+			    *tmp != '\0')
-		if (*++argv == NULL || *argv[0] == '\0')		      \
+				errx(2, errnum, i + 1, *argv, cap);
 			errx(2, errfew, 1, cap);			      \
 		if (piss[i])
 			printf ("str %d %s\n", i, strs[i]);
 		else
 			printf ("num %d %ld\n", i, nums[i]);
+	}
-	if (arg_need > 0) {
+	/* And output */
-		NEXT_ARG;
+#define p(i)	(i <= nparams ? \
-		p1 = atoi(*argv);
+		    (piss[i - 1] ? (long)strs[i - 1] : nums[i - 1]) : 0)
-	} else
+	puts(tparm(str, p(1), p(2), p(3), p(4), p(5), p(6), p(7), p(8), p(9)));
 		p1 = 0;
 	if (arg_need > 1) {
 		NEXT_ARG;
 		p2 = atoi(*argv);
 	} else
 		p2 = 0;
 	if (arg_need > 2) {
 		NEXT_ARG;
 		p3 = atoi(*argv);
 	} else
 		p3 = 0;
 	if (arg_need > 3) {
 		NEXT_ARG;
 		p4 = atoi(*argv);
 	} else
 		p4 = 0;
 	if (arg_need > 4) {
 		NEXT_ARG;
 		p5 = atoi(*argv);
 	} else
 		p5 = 0;
 	if (arg_need > 5) {
 		NEXT_ARG;
 		p6 = atoi(*argv);
 	} else
 		p6 = 0;
 	if (arg_need > 6) {
 		NEXT_ARG;
 		p7 = atoi(*argv);
 	} else
 		p7 = 0;
 	if (arg_need > 7) {
 		NEXT_ARG;
 		p8 = atoi(*argv);
 	} else
 		p8 = 0;
 	if (arg_need > 8) {
 		NEXT_ARG;
 		p9 = atoi(*argv);
 	} else
 		p9 = 0;
 	/* And print them. */
 	(void)tputs(tparm(str, p1, p2, p3, p4, p5, p6, p7, p8, p9), 0, outc);
 	return argv;
+}
 static int
 outc(int c)
+{
 	return putchar(c);
+}
 static void
 usage(void)
+{
 	(void)fprintf(stderr,
 	    "Usage: %s [-T term] attribute [attribute-args] ...\n",
 	    getprogname());
 	exit(2);
+}

 @@ -1,10 +1,12 @@
-#	$NetBSD: Makefile,v 1.10 2010/02/03 15:34:46 roy Exp $
+#	$NetBSD: Makefile,v 1.11 2013/01/24 10:41:28 roy Exp $
 #	@(#)Makefile	8.1 (Berkeley) 6/6/93
 PROG=	tput
 DPADD=	${LIBTERMINFO}
 LDADD=	-lterminfo
 MLINKS=	tput.1 clear.1
 SCRIPTS=clear.sh
 CPPFLAGS+=	-I${.CURDIR}/../../lib/libterminfo
 .include <bsd.prog.mk>