/**************************************************************************** * Copyright (c) 1998-2003,2004 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: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995               * *     and: Eric S. Raymond <esr@snark.thyrsus.com>                         * *     and: Thomas E. Dickey, 1996 on                                       * ****************************************************************************//* *	tparm.c * */#include <curses.priv.h>#include <ctype.h>#include <term.h>#include <tic.h>MODULE_ID("$Id: lib_tparm.c,v 1.68 2004/02/07 20:52:51 tom Exp $")/* *	char * *	tparm(string, ...) * *	Substitute the given parameters into the given string by the following *	rules (taken from terminfo(5)): * *	     Cursor addressing and other strings  requiring  parame- *	ters in the terminal are described by a parameterized string *	capability, with like escapes %x in  it.   For  example,  to *	address  the  cursor, the cup capability is given, using two *	parameters: the row and column to  address  to.   (Rows  and *	columns  are  numbered  from  zero and refer to the physical *	screen visible to the user, not to any  unseen  memory.)  If *	the terminal has memory relative cursor addressing, that can *	be indicated by * *	     The parameter mechanism uses  a  stack  and  special  % *	codes  to manipulate it.  Typically a sequence will push one *	of the parameters onto the stack and then print it  in  some *	format.  Often more complex operations are necessary. * *	     The % encodings have the following meanings: * *	     %%        outputs `%' *	     %c        print pop() like %c in printf() *	     %s        print pop() like %s in printf() *           %[[:]flags][width[.precision]][doxXs] *                     as in printf, flags are [-+#] and space *                     The ':' is used to avoid making %+ or %- *                     patterns (see below). * *	     %p[1-9]   push ith parm *	     %P[a-z]   set dynamic variable [a-z] to pop() *	     %g[a-z]   get dynamic variable [a-z] and push it *	     %P[A-Z]   set static variable [A-Z] to pop() *	     %g[A-Z]   get static variable [A-Z] and push it *	     %l        push strlen(pop) *	     %'c'      push char constant c *	     %{nn}     push integer constant nn * *	     %+ %- %* %/ %m *	               arithmetic (%m is mod): push(pop() op pop()) *	     %& %| %^  bit operations: push(pop() op pop()) *	     %= %> %<  logical operations: push(pop() op pop()) *	     %A %O     logical and & or operations for conditionals *	     %! %~     unary operations push(op pop()) *	     %i        add 1 to first two parms (for ANSI terminals) * *	     %? expr %t thenpart %e elsepart %; *	               if-then-else, %e elsepart is optional. *	               else-if's are possible ala Algol 68: *	               %? c1 %t b1 %e c2 %t b2 %e c3 %t b3 %e c4 %t b4 %e b5 %; * *	For those of the above operators which are binary and not commutative, *	the stack works in the usual way, with *			%gx %gy %m *	resulting in x mod y, not the reverse. */#define STACKSIZE	20typedef struct {    union {	int num;	char *str;    } data;    bool num_type;} stack_frame;NCURSES_EXPORT_VAR(int) _nc_tparm_err = 0;static stack_frame stack[STACKSIZE];static int stack_ptr;static const char *tparam_base = "";#ifdef TRACEstatic const char *tname;#endif /* TRACE */static char *out_buff;static size_t out_size;static size_t out_used;static char *fmt_buff;static size_t fmt_size;#if NO_LEAKSNCURSES_EXPORT(void)_nc_free_tparm(void){    if (out_buff != 0) {	FreeAndNull(out_buff);	out_size = 0;	out_used = 0;	FreeAndNull(fmt_buff);	fmt_size = 0;    }}#endifstatic inline voidget_space(size_t need){    need += out_used;    if (need > out_size) {	out_size = need * 2;	out_buff = typeRealloc(char, out_size, out_buff);	if (out_buff == 0)	    _nc_err_abort(MSG_NO_MEMORY);    }}static inline voidsave_text(const char *fmt, const char *s, int len){    size_t s_len = strlen(s);    if (len > (int) s_len)	s_len = len;    get_space(s_len + 1);    (void) sprintf(out_buff + out_used, fmt, s);    out_used += strlen(out_buff + out_used);}static inline voidsave_number(const char *fmt, int number, int len){    if (len < 30)	len = 30;		/* actually log10(MAX_INT)+1 */    get_space((unsigned) len + 1);    (void) sprintf(out_buff + out_used, fmt, number);    out_used += strlen(out_buff + out_used);}static inline voidsave_char(int c){    if (c == 0)	c = 0200;    get_space(1);    out_buff[out_used++] = c;}static inline voidnpush(int x){    if (stack_ptr < STACKSIZE) {	stack[stack_ptr].num_type = TRUE;	stack[stack_ptr].data.num = x;	stack_ptr++;    } else {	DEBUG(2, ("npush: stack overflow: %s", _nc_visbuf(tparam_base)));	_nc_tparm_err++;    }}static inline intnpop(void){    int result = 0;    if (stack_ptr > 0) {	stack_ptr--;	if (stack[stack_ptr].num_type)	    result = stack[stack_ptr].data.num;    } else {	DEBUG(2, ("npop: stack underflow: %s", _nc_visbuf(tparam_base)));	_nc_tparm_err++;    }    return result;}static inline voidspush(char *x){    if (stack_ptr < STACKSIZE) {	stack[stack_ptr].num_type = FALSE;	stack[stack_ptr].data.str = x;	stack_ptr++;    } else {	DEBUG(2, ("spush: stack overflow: %s", _nc_visbuf(tparam_base)));	_nc_tparm_err++;    }}static inline char *spop(void){    static char dummy[] = "";	/* avoid const-cast */    char *result = dummy;    if (stack_ptr > 0) {	stack_ptr--;	if (!stack[stack_ptr].num_type && stack[stack_ptr].data.str != 0)	    result = stack[stack_ptr].data.str;    } else {	DEBUG(2, ("spop: stack underflow: %s", _nc_visbuf(tparam_base)));	_nc_tparm_err++;    }    return result;}static inline const char *parse_format(const char *s, char *format, int *len){    *len = 0;    if (format != 0) {	bool done = FALSE;	bool allowminus = FALSE;	bool dot = FALSE;	bool err = FALSE;	char *fmt = format;	int my_width = 0;	int my_prec = 0;	int value = 0;	*len = 0;	*format++ = '%';	while (*s != '\0' && !done) {	    switch (*s) {	    case 'c':		/* FALLTHRU */	    case 'd':		/* FALLTHRU */	    case 'o':		/* FALLTHRU */	    case 'x':		/* FALLTHRU */	    case 'X':		/* FALLTHRU */	    case 's':		*format++ = *s;		done = TRUE;		break;	    case '.':		*format++ = *s++;		if (dot) {		    err = TRUE;		} else {	/* value before '.' is the width */		    dot = TRUE;		    my_width = value;		}		value = 0;		break;	    case '#':		*format++ = *s++;		break;	    case ' ':		*format++ = *s++;		break;	    case ':':		s++;		allowminus = TRUE;		break;	    case '-':		if (allowminus) {		    *format++ = *s++;		} else {		    done = TRUE;		}		break;	    default:		if (isdigit(UChar(*s))) {		    value = (value * 10) + (*s - '0');		    if (value > 10000)			err = TRUE;		    *format++ = *s++;		} else {		    done = TRUE;		}	    }	}	/*	 * If we found an error, ignore (and remove) the flags.	 */	if (err) {	    my_width = my_prec = value = 0;	    format = fmt;	    *format++ = '%';	    *format++ = *s;	}	/*	 * Any value after '.' is the precision.  If we did not see '.', then	 * the value is the width.	 */	if (dot)	    my_prec = value;	else	    my_width = value;	*format = '\0';	/* return maximum string length in print */	*len = (my_width > my_prec) ? my_width : my_prec;    }    return s;}#define isUPPER(c) ((c) >= 'A' && (c) <= 'Z')#define isLOWER(c) ((c) >= 'a' && (c) <= 'z')/* * Analyze the string to see how many parameters we need from the varargs list, * and what their types are.  We will only accept string parameters if they * appear as a %l or %s format following an explicit parameter reference (e.g., * %p2%s).  All other parameters are numbers. * * 'number' counts coarsely the number of pop's we see in the string, and * 'popcount' shows the highest parameter number in the string.  We would like * to simply use the latter count, but if we are reading termcap strings, there * may be cases that we cannot see the explicit parameter numbers. */NCURSES_EXPORT(int)_nc_tparm_analyze(const char *string, char *p_is_s[NUM_PARM], int *popcount){    size_t len2;    int i;    int lastpop = -1;    int len;    int number = 0;    const char *cp = string;    static char dummy[] = "";    if (cp == 0)	return 0;    if ((len2 = strlen(cp)) > fmt_size) {	fmt_size = len2 + fmt_size + 2;	if ((fmt_buff = typeRealloc(char, fmt_size, fmt_buff)) == 0)	      return 0;    }    memset(p_is_s, 0, sizeof(p_is_s[0]) * NUM_PARM);    *popcount = 0;    while ((cp - string) < (int) len2) {	if (*cp == '%') {	    cp++;	    cp = parse_format(cp, fmt_buff, &len);	    switch (*cp) {	    default:		break;	    case 'd':		/* FALLTHRU */	    case 'o':		/* FALLTHRU */	    case 'x':		/* FALLTHRU */	    case 'X':		/* FALLTHRU */	    case 'c':		/* FALLTHRU */		if (lastpop <= 0)		    number++;		lastpop = -1;