text: /****************************************************************************
   * Copyright 2018-2019,2020 Thomas E. Dickey                                *
   * Copyright 1998-2016,2017 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
   *
   */
  
  #define entry _ncu_entry
  #define ENTRY _ncu_ENTRY
  
  #include <curses.priv.h>
  
  #undef entry
  #undef ENTRY
  
  #if HAVE_TSEARCH
  #include <search.h>
  #endif
  
  #include <ctype.h>
  #include <tic.h>
  
  MODULE_ID("$Id: lib_tparm.c,v 1.127 2020/06/13 21:59:52 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 escapes like %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.
   */
  
  NCURSES_EXPORT_VAR(int) _nc_tparm_err = 0;
  
  #define TPS(var) _nc_prescreen.tparm_state.var
  #define popcount _nc_popcount	/* workaround for NetBSD 6.0 defect */
  
  #define isUPPER(c) ((c) >= 'A' && (c) <= 'Z')
  #define isLOWER(c) ((c) >= 'a' && (c) <= 'z')
  #define tc_BUMP()  if (level < 0 && number < 2) number++
  
  typedef struct {
      const char *format;		/* format-string can be used as cache-key */
      int tparm_type;		/* bit-set for each string-parameter */
      int num_actual;
      int num_parsed;
      int num_popped;
      TPARM_ARG param[NUM_PARM];
      char *p_is_s[NUM_PARM];
  } TPARM_DATA;
  
  #if HAVE_TSEARCH
  #define MyCache _nc_globals.cached_tparm
  #define MyCount _nc_globals.count_tparm
  #if NO_LEAKS
  static int which_tparm;
  static TPARM_DATA **delete_tparm;
  #endif
  #endif /* HAVE_TSEARCH */
  
  static char dummy[] = "";	/* avoid const-cast */
  
  #if HAVE_TSEARCH
  static int
  cmp_format(const void *p, const void *q)
  {
      const char *a = *(char *const *) p;
      const char *b = *(char *const *) q;
      return strcmp(a, b);
  }
  #endif
  
  #if NO_LEAKS
  #if HAVE_TSEARCH
  static void
  visit_nodes(const void *nodep, const VISIT which, const int depth)
  {
      (void) depth;
      if (which == preorder || which == leaf) {
  	delete_tparm[which_tparm] = *(TPARM_DATA **) nodep;
  	which_tparm++;
      }
  }
  #endif
  
  NCURSES_EXPORT(void)
  _nc_free_tparm(void)
  {
  #if HAVE_TSEARCH
      if (MyCount != 0) {
  	delete_tparm = typeMalloc(TPARM_DATA *, MyCount);
  	which_tparm = 0;
  	twalk(MyCache, visit_nodes);
  	for (which_tparm = 0; which_tparm < MyCount; ++which_tparm) {
  	    TPARM_DATA *ptr = delete_tparm[which_tparm];
  	    tdelete(ptr, &MyCache, cmp_format);
  	    free((char *) ptr->format);
  	    free(ptr);
  	}
  	which_tparm = 0;
  	twalk(MyCache, visit_nodes);
  	FreeAndNull(delete_tparm);
  	MyCount = 0;
  	which_tparm = 0;
      }
  #endif
      FreeAndNull(TPS(out_buff));
      TPS(out_size) = 0;
      TPS(out_used) = 0;
  
      FreeAndNull(TPS(fmt_buff));
      TPS(fmt_size) = 0;
  }
  #endif
  
  static NCURSES_INLINE void
  get_space(size_t need)
  {
      need += TPS(out_used);
      if (need > TPS(out_size)) {
  	TPS(out_size) = need * 2;
  	TYPE_REALLOC(char, TPS(out_size), TPS(out_buff));
      }
  }
  
  static NCURSES_INLINE void
  save_text(const char *fmt, const char *s, int len)
  {
      size_t s_len = (size_t) len + strlen(s) + strlen(fmt);
      get_space(s_len + 1);
  
      _nc_SPRINTF(TPS(out_buff) + TPS(out_used),
  		_nc_SLIMIT(TPS(out_size) - TPS(out_used))
  		fmt, s);
      TPS(out_used) += strlen(TPS(out_buff) + TPS(out_used));
  }
  
  static NCURSES_INLINE void
  save_number(const char *fmt, int number, int len)
  {
      size_t s_len = (size_t) len + 30 + strlen(fmt);
      get_space(s_len + 1);
  
      _nc_SPRINTF(TPS(out_buff) + TPS(out_used),
  		_nc_SLIMIT(TPS(out_size) - TPS(out_used))
  		fmt, number);
      TPS(out_used) += strlen(TPS(out_buff) + TPS(out_used));
  }
  
  static NCURSES_INLINE void
  save_char(int c)
  {
      if (c == 0)
  	c = 0200;
      get_space((size_t) 1);
      TPS(out_buff)[TPS(out_used)++] = (char) c;
  }
  
  static NCURSES_INLINE void
  npush(int x)
  {
      if (TPS(stack_ptr) < STACKSIZE) {
  	TPS(stack)[TPS(stack_ptr)].num_type = TRUE;
  	TPS(stack)[TPS(stack_ptr)].data.num = x;
  	TPS(stack_ptr)++;
      } else {
  	DEBUG(2, ("npush: stack overflow: %s", _nc_visbuf(TPS(tparam_base))));
  	_nc_tparm_err++;
      }
  }
  
  static NCURSES_INLINE int
  npop(void)
  {
      int result = 0;
      if (TPS(stack_ptr) > 0) {
  	TPS(stack_ptr)--;
  	if (TPS(stack)[TPS(stack_ptr)].num_type)
  	    result = TPS(stack)[TPS(stack_ptr)].data.num;
      } else {
  	DEBUG(2, ("npop: stack underflow: %s", _nc_visbuf(TPS(tparam_base))));
  	_nc_tparm_err++;
      }
      return result;
  }
  
  static NCURSES_INLINE void
  spush(char *x)
  {
      if (TPS(stack_ptr) < STACKSIZE) {
  	TPS(stack)[TPS(stack_ptr)].num_type = FALSE;
  	TPS(stack)[TPS(stack_ptr)].data.str = x;
  	TPS(stack_ptr)++;
      } else {
  	DEBUG(2, ("spush: stack overflow: %s", _nc_visbuf(TPS(tparam_base))));
  	_nc_tparm_err++;
      }
  }
  
  static NCURSES_INLINE char *
  spop(void)
  {
      char *result = dummy;
      if (TPS(stack_ptr) > 0) {
  	TPS(stack_ptr)--;
  	if (!TPS(stack)[TPS(stack_ptr)].num_type
  	    && TPS(stack)[TPS(stack_ptr)].data.str != 0)
  	    result = TPS(stack)[TPS(stack_ptr)].data.str;
      } else {
  	DEBUG(2, ("spop: stack underflow: %s", _nc_visbuf(TPS(tparam_base))));
  	_nc_tparm_err++;
      }
      return result;
  }
  
  static NCURSES_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':
  #ifdef EXP_XTERM_1005
  	    case 'u':
  #endif
  		*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;
  }
  
  /*
   * 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;
      int level = -1;
      const char *cp = string;
  
      if (cp == 0)
  	return 0;
  
      if ((len2 = strlen(cp)) + 2 > TPS(fmt_size)) {
  	TPS(fmt_size) += len2 + 2;
  	TPS(fmt_buff) = typeRealloc(char, TPS(fmt_size), TPS(fmt_buff));
  	if (TPS(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, TPS(fmt_buff), &len);
  	    switch (*cp) {
  	    default:
  		break;
  
  	    case 'd':		/* FALLTHRU */
  	    case 'o':		/* FALLTHRU */
  	    case 'x':		/* FALLTHRU */
  	    case 'X':		/* FALLTHRU */
  	    case 'c':		/* FALLTHRU */
  #ifdef EXP_XTERM_1005
  	    case 'u':
  #endif
  		if (lastpop <= 0) {
  		    tc_BUMP();
  		}
  		level -= 1;
  		lastpop = -1;
  		break;
  
  	    case 'l':
  	    case 's':
  		if (lastpop > 0) {
  		    level -= 1;
  		    p_is_s[lastpop - 1] = dummy;
  		}
  		tc_BUMP();
  		break;
  
  	    case 'p':
  		cp++;
  		i = (UChar(*cp) - '0');
  		if (i >= 0 && i <= NUM_PARM) {
  		    ++level;
  		    lastpop = i;
  		    if (lastpop > *popcount)
  			*popcount = lastpop;
  		}
  		break;
  
  	    case 'P':
  		++cp;
  		break;
  
  	    case 'g':
  		++level;
  		cp++;
  		break;
  
  	    case S_QUOTE:
  		++level;
  		cp += 2;
  		lastpop = -1;
  		break;
  
  	    case L_BRACE:
  		++level;
  		cp++;
  		while (isdigit(UChar(*cp))) {
  		    cp++;
  		}
  		break;
  
  	    case '+':
  	    case '-':
  	    case '*':
  	    case '/':
  	    case 'm':
  	    case 'A':
  	    case 'O':
  	    case '&':
  	    case '|':
  	    case '^':
  	    case '=':
  	    case '<':
  	    case '>':
  		tc_BUMP();
  		level -= 1;	/* pop 2, operate, push 1 */
  		lastpop = -1;
  		break;
  
  	    case '!':
  	    case '~':
  		tc_BUMP();
  		lastpop = -1;
  		break;
  
  	    case 'i':
  		/* will add 1 to first (usually two) parameters */
  		break;
  	    }
  	}
  	if (*cp != '\0')
  	    cp++;
      }
  
      if (number > NUM_PARM)
  	number = NUM_PARM;
      return number;
  }
  
  /*
   * Analyze the capability string, finding the number of parameters and their
   * types.
   *
   * TODO: cache the result so that this is done once per capability per term.
   */
  static int
  tparm_setup(const char *string, TPARM_DATA * result)
  {
      int rc = OK;
  
      TPS(out_used) = 0;
      memset(result, 0, sizeof(*result));
  
      if (string == NULL) {
  	TR(TRACE_CALLS, ("%s: format is null", TPS(tname)));
  	rc = ERR;
      } else {
  #if HAVE_TSEARCH
  	TPARM_DATA *fs;
  	void *ft;
  
  	result->format = string;
  	if ((ft = tfind(result, &MyCache, cmp_format)) != 0) {
  	    fs = *(TPARM_DATA **) ft;
  	    *result = *fs;
  	} else
  #endif
  	{
  	    /*
  	     * Find the highest parameter-number referred to in the format
  	     * string.  Use this value to limit the number of arguments copied
  	     * from the variable-length argument list.
  	     */
  	    result->num_parsed = _nc_tparm_analyze(string,
  						   result->p_is_s,
  						   &(result->num_popped));
  	    if (TPS(fmt_buff) == 0) {
  		TR(TRACE_CALLS, ("%s: error in analysis", TPS(tname)));
  		rc = ERR;
  	    } else {
  		int n;
  
  		if (result->num_parsed > NUM_PARM)
  		    result->num_parsed = NUM_PARM;
  		if (result->num_popped > NUM_PARM)
  		    result->num_popped = NUM_PARM;
  		result->num_actual = max(result->num_popped, result->num_parsed);
  
  		for (n = 0; n < result->num_actual; ++n) {
  		    if (result->p_is_s[n])
  			result->tparm_type |= (1 << n);
  		}
  #if HAVE_TSEARCH
  		if ((fs = typeCalloc(TPARM_DATA, 1)) != 0) {
  		    *fs = *result;
  		    if ((fs->format = strdup(string)) != 0) {
  			if ((ft = tsearch(fs, &MyCache, cmp_format)) != 0) {
  			    ++MyCount;
  			} else {
  			    rc = ERR;
  			}
  		    } else {
  			rc = ERR;
  		    }
  		} else {
  		    rc = ERR;
  		}
  #endif
  	    }
  	}
      }
  
      return rc;
  }
  
  /*
   * A few caps (such as plab_norm) have string-valued parms.  We'll have to
   * assume that the caller knows the difference, since a char* and an int may
   * not be the same size on the stack.  The normal prototype for tparm uses 9
   * long's, which is consistent with our va_arg() usage.
   */
  static void
  tparm_copy_valist(TPARM_DATA * data, int use_TPARM_ARG, va_list ap)
  {
      int i;
  
      for (i = 0; i < data->num_actual; i++) {
  	if (data->p_is_s[i] != 0) {
  	    char *value = va_arg(ap, char *);
  	    if (value == 0)
  		value = dummy;
  	    data->p_is_s[i] = value;
  	    data->param[i] = 0;
  	} else if (use_TPARM_ARG) {
  	    data->param[i] = va_arg(ap, TPARM_ARG);
  	} else {
  	    data->param[i] = (TPARM_ARG) va_arg(ap, int);
  	}
      }
  }
  
  /*
   * This is a termcap compatibility hack.  If there are no explicit pop
   * operations in the string, load the stack in such a way that successive pops
   * will grab successive parameters.  That will make the expansion of (for
   * example) \E[%d;%dH work correctly in termcap style, which means tparam()
   * will expand termcap strings OK.
   */
  static bool
  tparm_tc_compat(TPARM_DATA * data)
  {
      bool termcap_hack = FALSE;
  
      TPS(stack_ptr) = 0;
  
      if (data->num_popped == 0) {
  	int i;
  
  	termcap_hack = TRUE;
  	for (i = data->num_parsed - 1; i >= 0; i--) {
  	    if (data->p_is_s[i])
  		spush(data->p_is_s[i]);
  	    else
  		npush((int) data->param[i]);
  	}
      }
      return termcap_hack;
  }
  
  #ifdef TRACE
  static void
  tparm_trace_call(const char *string, TPARM_DATA * data)
  {
      if (USE_TRACEF(TRACE_CALLS)) {
  	int i;
  	for (i = 0; i < data->num_actual; i++) {
  	    if (data->p_is_s[i] != 0) {
  		save_text(", %s", _nc_visbuf(data->p_is_s[i]), 0);
  	    } else if ((long) data->param[i] > MAX_OF_TYPE(NCURSES_INT2) ||
  		       (long) data->param[i] < 0) {
  		_tracef("BUG: problem with tparm parameter #%d of %d",
  			i + 1, data->num_actual);
  		break;
  	    } else {
  		save_number(", %d", (int) data->param[i], 0);
  	    }
  	}
  	_tracef(T_CALLED("%s(%s%s)"), TPS(tname), _nc_visbuf(string), TPS(out_buff));
  	TPS(out_used) = 0;
  	_nc_unlock_global(tracef);
      }
  }
  
  #else
  #define tparm_trace_call(string, data)	/* nothing */
  #endif /* TRACE */
  
  static NCURSES_INLINE char *
  tparam_internal(const char *string, TPARM_DATA * data)
  {
      int number;
      int len;
      int level;
      int x, y;
      int i;
      const char *cp = string;
      size_t len2 = strlen(cp);
      bool incremented_two = FALSE;
      bool termcap_hack = tparm_tc_compat(data);
  
      tparm_trace_call(string, data);
  
      while ((cp - string) < (int) len2) {
  	if (*cp != '%') {
  	    save_char(UChar(*cp));
  	} else {
  	    TPS(tparam_base) = cp++;
  	    cp = parse_format(cp, TPS(fmt_buff), &len);
  	    switch (*cp) {
  	    default:
  		break;
  	    case '%':
  		save_char('%');
  		break;
  
  	    case 'd':		/* FALLTHRU */
  	    case 'o':		/* FALLTHRU */
  	    case 'x':		/* FALLTHRU */
  	    case 'X':		/* FALLTHRU */
  		save_number(TPS(fmt_buff), npop(), len);
  		break;
  
  	    case 'c':		/* FALLTHRU */
  		save_char(npop());
  		break;
  
  #ifdef EXP_XTERM_1005
  	    case 'u':
  		{
  		    unsigned char target[10];
  		    unsigned source = (unsigned) npop();
  		    int rc = _nc_conv_to_utf8(target, source, (unsigned)
  					      sizeof(target));
  		    int n;
  		    for (n = 0; n < rc; ++n) {
  			save_char(target[n]);
  		    }
  		}
  		break;
  #endif
  	    case 'l':
  		npush((int) strlen(spop()));
  		break;
  
  	    case 's':
  		save_text(TPS(fmt_buff), spop(), len);
  		break;
  
  	    case 'p':
  		cp++;
  		i = (UChar(*cp) - '1');
  		if (i >= 0 && i < NUM_PARM) {
  		    if (data->p_is_s[i]) {
  			spush(data->p_is_s[i]);
  		    } else {
  			npush((int) data->param[i]);
  		    }
  		}
  		break;
  
  	    case 'P':
  		cp++;
  		if (isUPPER(*cp)) {
  		    i = (UChar(*cp) - 'A');
  		    TPS(static_vars)[i] = npop();
  		} else if (isLOWER(*cp)) {
  		    i = (UChar(*cp) - 'a');
  		    TPS(dynamic_var)[i] = npop();
  		}
  		break;
  
  	    case 'g':
  		cp++;
  		if (isUPPER(*cp)) {
  		    i = (UChar(*cp) - 'A');
  		    npush(TPS(static_vars)[i]);
  		} else if (isLOWER(*cp)) {
  		    i = (UChar(*cp) - 'a');
  		    npush(TPS(dynamic_var)[i]);
  		}
  		break;
  
  	    case S_QUOTE:
  		cp++;
  		npush(UChar(*cp));
  		cp++;
  		break;
  
  	    case L_BRACE:
  		number = 0;
  		cp++;
  		while (isdigit(UChar(*cp))) {
  		    number = (number * 10) + (UChar(*cp) - '0');
  		    cp++;
  		}
  		npush(number);
  		break;
  
  	    case '+':
  		npush(npop() + npop());
  		break;
  
  	    case '-':
  		y = npop();
  		x = npop();
  		npush(x - y);
  		break;
  
  	    case '*':
  		npush(npop() * npop());
  		break;
  
  	    case '/':
  		y = npop();
  		x = npop();
  		npush(y ? (x / y) : 0);
  		break;
  
  	    case 'm':
  		y = npop();
  		x = npop();
  		npush(y ? (x % y) : 0);
  		break;
  
  	    case 'A':
  		y = npop();
  		x = npop();
  		npush(y && x);
  		break;
  
  	    case 'O':
  		y = npop();
  		x = npop();
  		npush(y || x);
  		break;
  
  	    case '&':
  		npush(npop() & npop());
  		break;
  
  	    case '|':
  		npush(npop() | npop());
  		break;
  
  	    case '^':
  		npush(npop() ^ npop());
  		break;
  
  	    case '=':
  		y = npop();
  		x = npop();
  		npush(x == y);
  		break;
  
  	    case '<':
  		y = npop();
  		x = npop();
  		npush(x < y);
  		break;
  
  	    case '>':
  		y = npop();
  		x = npop();
  		npush(x > y);
  		break;
  
  	    case '!':
  		npush(!npop());
  		break;
  
  	    case '~':
  		npush(~npop());
  		break;
  
  	    case 'i':
  		/*
  		 * Increment the first two parameters -- if they are numbers
  		 * rather than strings.  As a side effect, assign into the
  		 * stack; if this is termcap, then the stack was populated
  		 * using the termcap hack above rather than via the terminfo
  		 * 'p' case.
  		 */
  		if (!incremented_two) {
  		    incremented_two = TRUE;
  		    if (data->p_is_s[0] == 0) {
  			data->param[0]++;
  			if (termcap_hack)
  			    TPS(stack)[0].data.num = (int) data->param[0];
  		    }
  		    if (data->p_is_s[1] == 0) {
  			data->param[1]++;
  			if (termcap_hack)
  			    TPS(stack)[1].data.num = (int) data->param[1];
  		    }
  		}
  		break;
  
  	    case '?':
  		break;
  
  	    case 't':
  		x = npop();
  		if (!x) {
  		    /* scan forward for %e or %; at level zero */
  		    cp++;
  		    level = 0;
  		    while (*cp) {
  			if (*cp == '%') {
  			    cp++;
  			    if (*cp == '?')
  				level++;
  			    else if (*cp == ';') {
  				if (level > 0)
  				    level--;
  				else
  				    break;
  			    } else if (*cp == 'e' && level == 0)
  				break;
  			}
  
  			if (*cp)
  			    cp++;
  		    }
  		}
  		break;
  
  	    case 'e':
  		/* scan forward for a %; at level zero */
  		cp++;
  		level = 0;
  		while (*cp) {
  		    if (*cp == '%') {
  			cp++;
  			if (*cp == '?')
  			    level++;
  			else if (*cp == ';') {
  			    if (level > 0)
  				level--;
  			    else
  				break;
  			}
  		    }
  
  		    if (*cp)
  			cp++;
  		}
  		break;
  
  	    case ';':
  		break;
  
  	    }			/* endswitch (*cp) */
  	}			/* endelse (*cp == '%') */
  
  	if (*cp == '\0')
  	    break;
  
  	cp++;
      }				/* endwhile (*cp) */
  
      get_space((size_t) 1);
      TPS(out_buff)[TPS(out_used)] = '\0';
  
      T((T_RETURN("%s"), _nc_visbuf(TPS(out_buff))));
      return (TPS(out_buff));
  }
  
  #if NCURSES_TPARM_VARARGS
  
  NCURSES_EXPORT(char *)
  tparm(const char *string, ...)
  {
      TPARM_DATA myData;
      va_list ap;
      char *result = NULL;
  
      _nc_tparm_err = 0;
  #ifdef TRACE
      TPS(tname) = "tparm";
  #endif /* TRACE */
  
      if (tparm_setup(string, &myData) == OK) {
  
  	va_start(ap, string);
  	tparm_copy_valist(&myData, TRUE, ap);
  	va_end(ap);
  
  	result = tparam_internal(string, &myData);
      }
      return result;
  }
  
  #else /* !NCURSES_TPARM_VARARGS */
  
  NCURSES_EXPORT(char *)
  tparm(const char *string,
        TPARM_ARG a1,
        TPARM_ARG a2,
        TPARM_ARG a3,
        TPARM_ARG a4,
        TPARM_ARG a5,
        TPARM_ARG a6,
        TPARM_ARG a7,
        TPARM_ARG a8,
        TPARM_ARG a9)
  {
      TPARM_DATA myData;
      char *result = NULL;
  
      _nc_tparm_err = 0;
  #ifdef TRACE
      TPS(tname) = "tparm";
  #endif /* TRACE */
  
      if (tparm_setup(string, &myData) == OK) {
  
  	myData.param[0] = a1;
  	myData.param[1] = a2;
  	myData.param[2] = a3;
  	myData.param[3] = a4;
  	myData.param[4] = a5;
  	myData.param[5] = a6;
  	myData.param[6] = a7;
  	myData.param[7] = a8;
  	myData.param[8] = a9;
  
  	result = tparam_internal(string, &myData);
      }
      return result;
  }
  
  #endif /* NCURSES_TPARM_VARARGS */
  
  NCURSES_EXPORT(char *)
  tiparm(const char *string, ...)
  {
      TPARM_DATA myData;
      va_list ap;
      char *result = NULL;
  
      _nc_tparm_err = 0;
  #ifdef TRACE
      TPS(tname) = "tiparm";
  #endif /* TRACE */
  
      if (tparm_setup(string, &myData) == OK) {
  
  	va_start(ap, string);
  	tparm_copy_valist(&myData, FALSE, ap);
  	va_end(ap);
  
  	result = tparam_internal(string, &myData);
      }
      return result;
  }
  
  /*
   * The internal-use flavor ensures that the parameters are numbers, not strings
   */
  NCURSES_EXPORT(char *)
  _nc_tiparm(int expected, const char *string, ...)
  {
      TPARM_DATA myData;
      va_list ap;
      char *result = NULL;
  
      _nc_tparm_err = 0;
  #ifdef TRACE
      TPS(tname) = "_nc_tiparm";
  #endif /* TRACE */
  
      if (tparm_setup(string, &myData) == OK
  	&& myData.num_actual <= expected
  	&& myData.tparm_type == 0) {
  
  	va_start(ap, string);
  	tparm_copy_valist(&myData, FALSE, ap);
  	va_end(ap);
  
  	result = tparam_internal(string, &myData);
      }
      return result;
  }
  