/****************************************************************************
- * Copyright 2018-2019,2020 Thomas E. Dickey *
+ * Copyright 2018-2021,2023 Thomas E. Dickey *
* Copyright 1998-2016,2017 Free Software Foundation, Inc. *
* *
* Permission is hereby granted, free of charge, to any person obtaining a *
#include <ctype.h>
#include <tic.h>
-MODULE_ID("$Id: lib_tparm.c,v 1.127 2020/06/13 21:59:52 tom Exp $")
+MODULE_ID("$Id: lib_tparm.c,v 1.153 2023/11/04 19:28:41 tom Exp $")
/*
* char *
NCURSES_EXPORT_VAR(int) _nc_tparm_err = 0;
-#define TPS(var) _nc_prescreen.tparm_state.var
+#define TPS(var) tps->var
#define popcount _nc_popcount /* workaround for NetBSD 6.0 defect */
+#define get_tparm_state(term) \
+ (term != NULL \
+ ? &(term->tparm_state) \
+ : &(_nc_prescreen.tparm_state))
+
#define isUPPER(c) ((c) >= 'A' && (c) <= 'Z')
#define isLOWER(c) ((c) >= 'a' && (c) <= 'z')
#define tc_BUMP() if (level < 0 && number < 2) number++
#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 */
}
#endif
-#if NO_LEAKS
#if HAVE_TSEARCH
static void
-visit_nodes(const void *nodep, const VISIT which, const int depth)
+visit_nodes(const void *nodep, VISIT which, int depth)
{
(void) depth;
if (which == preorder || which == leaf) {
#endif
NCURSES_EXPORT(void)
-_nc_free_tparm(void)
+_nc_free_tparm(TERMINAL *termp)
{
+ TPARM_STATE *tps = get_tparm_state(termp);
#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);
+ delete_tparm = typeCalloc(TPARM_DATA *, MyCount);
+ if (delete_tparm != NULL) {
+ which_tparm = 0;
+ twalk(MyCache, visit_nodes);
+ for (which_tparm = 0; which_tparm < MyCount; ++which_tparm) {
+ TPARM_DATA *ptr = delete_tparm[which_tparm];
+ if (ptr != NULL) {
+ tdelete(ptr, &MyCache, cmp_format);
+ free((char *) ptr->format);
+ free(ptr);
+ }
+ }
+ which_tparm = 0;
+ twalk(MyCache, visit_nodes);
+ FreeAndNull(delete_tparm);
}
- which_tparm = 0;
- twalk(MyCache, visit_nodes);
- FreeAndNull(delete_tparm);
MyCount = 0;
which_tparm = 0;
}
FreeAndNull(TPS(fmt_buff));
TPS(fmt_size) = 0;
}
-#endif
-static NCURSES_INLINE void
-get_space(size_t need)
+static int
+tparm_error(TPARM_STATE *tps, const char *message)
{
- need += TPS(out_used);
- if (need > TPS(out_size)) {
- TPS(out_size) = need * 2;
- TYPE_REALLOC(char, TPS(out_size), TPS(out_buff));
- }
+ (void) tps;
+ (void) message;
+ DEBUG(2, ("%s: %s", message, _nc_visbuf(TPS(tparam_base))));
+ return ++_nc_tparm_err;
+}
+
+#define get_space(tps, need) \
+{ \
+ size_t need2get = need + TPS(out_used); \
+ if (need2get > TPS(out_size)) { \
+ TPS(out_size) = need2get * 2; \
+ TYPE_REALLOC(char, TPS(out_size), TPS(out_buff)); \
+ } \
}
+#if NCURSES_EXPANDED
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);
+ (get_space) (TPARM_STATE *tps, size_t need) {
+ get_space(tps, need);
+}
- _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));
+#undef get_space
+#endif
+
+#define save_text(tps, fmt, s, len) \
+{ \
+ size_t s_len = (size_t) len + strlen(s) + strlen(fmt); \
+ get_space(tps, 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)); \
}
+#if NCURSES_EXPANDED
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);
+ (save_text) (TPARM_STATE *tps, const char *fmt, const char *s, int len) {
+ save_text(tps, fmt, s, len);
+}
- _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));
+#undef save_text
+#endif
+
+#define save_number(tps, fmt, number, len) \
+{ \
+ size_t s_len = (size_t) len + 30 + strlen(fmt); \
+ get_space(tps, 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)); \
}
+#if NCURSES_EXPANDED
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;
+ (save_number) (TPARM_STATE *tps, const char *fmt, int number, int len) {
+ save_number(tps, fmt, number, len);
}
+#undef save_number
+#endif
+
+#define save_char(tps, c) \
+{ \
+ get_space(tps, (size_t) 1); \
+ TPS(out_buff)[TPS(out_used)++] = (char) ((c == 0) ? 0200 : c); \
+}
+
+#if NCURSES_EXPANDED
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++;
- }
+ (save_char) (TPARM_STATE *tps, int c) {
+ save_char(tps, c);
}
-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;
+#undef save_char
+#endif
+
+#define npush(tps, 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 { \
+ (void) tparm_error(tps, "npush: stack overflow"); \
+ } \
}
+#if NCURSES_EXPANDED
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++;
- }
+ (npush) (TPARM_STATE *tps, int x) {
+ npush(tps, x);
+}
+
+#undef npush
+#endif
+
+#define spush(tps, 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 { \
+ (void) tparm_error(tps, "spush: stack overflow"); \
+ } \
+}
+
+#if NCURSES_EXPANDED
+static NCURSES_INLINE void
+ (spush) (TPARM_STATE *tps, char *x) {
+ spush(tps, x);
+}
+
+#undef spush
+#endif
+
+#define npop(tps) \
+ ((TPS(stack_ptr)-- > 0) \
+ ? ((TPS(stack)[TPS(stack_ptr)].num_type) \
+ ? TPS(stack)[TPS(stack_ptr)].data.num \
+ : 0) \
+ : (tparm_error(tps, "npop: stack underflow"), \
+ TPS(stack_ptr) = 0))
+
+#if NCURSES_EXPANDED
+static NCURSES_INLINE int
+ (npop) (TPARM_STATE *tps) {
+ return npop(tps);
}
+#undef npop
+#endif
+
+#define spop(tps) \
+ ((TPS(stack_ptr)-- > 0) \
+ ? ((!TPS(stack)[TPS(stack_ptr)].num_type \
+ && TPS(stack)[TPS(stack_ptr)].data.str != 0) \
+ ? TPS(stack)[TPS(stack_ptr)].data.str \
+ : dummy) \
+ : (tparm_error(tps, "spop: stack underflow"), \
+ dummy))
+#if NCURSES_EXPANDED
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;
+ (spop) (TPARM_STATE *tps) {
+ return spop(tps);
}
+#undef spop
+#endif
static NCURSES_INLINE const char *
parse_format(const char *s, char *format, int *len)
* 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)
+_nc_tparm_analyze(TERMINAL *term, const char *string, char **p_is_s, int *popcount)
{
+ TPARM_STATE *tps = get_tparm_state(term);
size_t len2;
int i;
int lastpop = -1;
* TODO: cache the result so that this is done once per capability per term.
*/
static int
-tparm_setup(const char *string, TPARM_DATA * result)
+tparm_setup(TERMINAL *term, const char *string, TPARM_DATA *result)
{
+ TPARM_STATE *tps = get_tparm_state(term);
int rc = OK;
TPS(out_used) = 0;
memset(result, 0, sizeof(*result));
- if (string == NULL) {
- TR(TRACE_CALLS, ("%s: format is null", TPS(tname)));
+ if (!VALID_STRING(string)) {
+ TR(TRACE_CALLS, ("%s: format is invalid", TPS(tname)));
rc = ERR;
} else {
#if HAVE_TSEARCH
result->format = string;
if ((ft = tfind(result, &MyCache, cmp_format)) != 0) {
+ size_t len2;
fs = *(TPARM_DATA **) ft;
*result = *fs;
+ if ((len2 = strlen(string)) + 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 ERR;
+ }
} else
#endif
{
* 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->num_parsed = _nc_tparm_analyze(term, string,
result->p_is_s,
&(result->num_popped));
if (TPS(fmt_buff) == 0) {
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);
+ result->num_actual = Max(result->num_popped, result->num_parsed);
for (n = 0; n < result->num_actual; ++n) {
if (result->p_is_s[n])
if ((fs = typeCalloc(TPARM_DATA, 1)) != 0) {
*fs = *result;
if ((fs->format = strdup(string)) != 0) {
- if ((ft = tsearch(fs, &MyCache, cmp_format)) != 0) {
+ if (tsearch(fs, &MyCache, cmp_format) != 0) {
++MyCount;
} else {
+ free(fs);
rc = ERR;
}
} else {
+ free(fs);
rc = ERR;
}
} else {
* 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)
+tparm_copy_valist(TPARM_DATA *data, int use_TPARM_ARG, va_list ap)
{
int i;
* will expand termcap strings OK.
*/
static bool
-tparm_tc_compat(TPARM_DATA * data)
+tparm_tc_compat(TPARM_STATE *tps, TPARM_DATA *data)
{
bool termcap_hack = FALSE;
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]);
+ if (data->p_is_s[i]) {
+ spush(tps, data->p_is_s[i]);
+ } else {
+ npush(tps, (int) data->param[i]);
+ }
}
}
return termcap_hack;
#ifdef TRACE
static void
-tparm_trace_call(const char *string, TPARM_DATA * data)
+tparm_trace_call(TPARM_STATE *tps, 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);
+ save_text(tps, ", %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);
+ save_number(tps, ", %d", (int) data->param[i], 0);
}
}
_tracef(T_CALLED("%s(%s%s)"), TPS(tname), _nc_visbuf(string), TPS(out_buff));
}
#else
-#define tparm_trace_call(string, data) /* nothing */
+#define tparm_trace_call(tps, string, data) /* nothing */
#endif /* TRACE */
+#define init_vars(name) \
+ if (!name##_used) { \
+ name##_used = TRUE; \
+ memset(name##_vars, 0, sizeof(name##_vars)); \
+ }
+
static NCURSES_INLINE char *
-tparam_internal(const char *string, TPARM_DATA * data)
+tparam_internal(TPARM_STATE *tps, const char *string, TPARM_DATA *data)
{
int number;
int len;
int level;
int x, y;
int i;
+ const char *s;
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);
+ bool termcap_hack = tparm_tc_compat(tps, data);
+ /*
+ * SVr4 curses stores variables 'A' to 'Z' in the TERMINAL structure (so
+ * they are initialized once to zero), and variables 'a' to 'z' on the
+ * stack in tparm, referring to the former as "static" and the latter as
+ * "dynamic". However, it makes no check to ensure that the "dynamic"
+ * variables are initialized.
+ *
+ * Solaris xpg4 curses makes no distinction between the upper/lower, and
+ * stores the common set of 26 variables on the stack, without initializing
+ * them.
+ *
+ * In ncurses, both sets of variables are initialized on the first use.
+ */
+ bool dynamic_used = FALSE;
+ int dynamic_vars[NUM_VARS];
+
+ tparm_trace_call(tps, string, data);
+
+ if (TPS(fmt_buff) == NULL) {
+ T((T_RETURN("<null>")));
+ return NULL;
+ }
while ((cp - string) < (int) len2) {
if (*cp != '%') {
- save_char(UChar(*cp));
+ save_char(tps, UChar(*cp));
} else {
TPS(tparam_base) = cp++;
cp = parse_format(cp, TPS(fmt_buff), &len);
default:
break;
case '%':
- save_char('%');
+ save_char(tps, '%');
break;
case 'd': /* FALLTHRU */
case 'o': /* FALLTHRU */
case 'x': /* FALLTHRU */
case 'X': /* FALLTHRU */
- save_number(TPS(fmt_buff), npop(), len);
+ x = npop(tps);
+ save_number(tps, TPS(fmt_buff), x, len);
break;
case 'c': /* FALLTHRU */
- save_char(npop());
+ x = npop(tps);
+ save_char(tps, x);
break;
#ifdef EXP_XTERM_1005
case 'u':
{
unsigned char target[10];
- unsigned source = (unsigned) npop();
+ unsigned source = (unsigned) npop(tps);
int rc = _nc_conv_to_utf8(target, source, (unsigned)
sizeof(target));
int n;
for (n = 0; n < rc; ++n) {
- save_char(target[n]);
+ save_char(tps, target[n]);
}
}
break;
#endif
case 'l':
- npush((int) strlen(spop()));
+ s = spop(tps);
+ npush(tps, (int) strlen(s));
break;
case 's':
- save_text(TPS(fmt_buff), spop(), len);
+ s = spop(tps);
+ save_text(tps, TPS(fmt_buff), s, len);
break;
case 'p':
i = (UChar(*cp) - '1');
if (i >= 0 && i < NUM_PARM) {
if (data->p_is_s[i]) {
- spush(data->p_is_s[i]);
+ spush(tps, data->p_is_s[i]);
} else {
- npush((int) data->param[i]);
+ npush(tps, (int) data->param[i]);
}
}
break;
cp++;
if (isUPPER(*cp)) {
i = (UChar(*cp) - 'A');
- TPS(static_vars)[i] = npop();
+ TPS(static_vars)[i] = npop(tps);
} else if (isLOWER(*cp)) {
i = (UChar(*cp) - 'a');
- TPS(dynamic_var)[i] = npop();
+ init_vars(dynamic);
+ dynamic_vars[i] = npop(tps);
}
break;
cp++;
if (isUPPER(*cp)) {
i = (UChar(*cp) - 'A');
- npush(TPS(static_vars)[i]);
+ npush(tps, TPS(static_vars)[i]);
} else if (isLOWER(*cp)) {
i = (UChar(*cp) - 'a');
- npush(TPS(dynamic_var)[i]);
+ init_vars(dynamic);
+ npush(tps, dynamic_vars[i]);
}
break;
case S_QUOTE:
cp++;
- npush(UChar(*cp));
+ npush(tps, UChar(*cp));
cp++;
break;
number = (number * 10) + (UChar(*cp) - '0');
cp++;
}
- npush(number);
+ npush(tps, number);
break;
case '+':
- npush(npop() + npop());
+ y = npop(tps);
+ x = npop(tps);
+ npush(tps, x + y);
break;
case '-':
- y = npop();
- x = npop();
- npush(x - y);
+ y = npop(tps);
+ x = npop(tps);
+ npush(tps, x - y);
break;
case '*':
- npush(npop() * npop());
+ y = npop(tps);
+ x = npop(tps);
+ npush(tps, x * y);
break;
case '/':
- y = npop();
- x = npop();
- npush(y ? (x / y) : 0);
+ y = npop(tps);
+ x = npop(tps);
+ npush(tps, y ? (x / y) : 0);
break;
case 'm':
- y = npop();
- x = npop();
- npush(y ? (x % y) : 0);
+ y = npop(tps);
+ x = npop(tps);
+ npush(tps, y ? (x % y) : 0);
break;
case 'A':
- y = npop();
- x = npop();
- npush(y && x);
+ y = npop(tps);
+ x = npop(tps);
+ npush(tps, y && x);
break;
case 'O':
- y = npop();
- x = npop();
- npush(y || x);
+ y = npop(tps);
+ x = npop(tps);
+ npush(tps, y || x);
break;
case '&':
- npush(npop() & npop());
+ y = npop(tps);
+ x = npop(tps);
+ npush(tps, x & y);
break;
case '|':
- npush(npop() | npop());
+ y = npop(tps);
+ x = npop(tps);
+ npush(tps, x | y);
break;
case '^':
- npush(npop() ^ npop());
+ y = npop(tps);
+ x = npop(tps);
+ npush(tps, x ^ y);
break;
case '=':
- y = npop();
- x = npop();
- npush(x == y);
+ y = npop(tps);
+ x = npop(tps);
+ npush(tps, x == y);
break;
case '<':
- y = npop();
- x = npop();
- npush(x < y);
+ y = npop(tps);
+ x = npop(tps);
+ npush(tps, x < y);
break;
case '>':
- y = npop();
- x = npop();
- npush(x > y);
+ y = npop(tps);
+ x = npop(tps);
+ npush(tps, x > y);
break;
case '!':
- npush(!npop());
+ x = npop(tps);
+ npush(tps, !x);
break;
case '~':
- npush(~npop());
+ x = npop(tps);
+ npush(tps, ~x);
break;
case 'i':
break;
case 't':
- x = npop();
+ x = npop(tps);
if (!x) {
/* scan forward for %e or %; at level zero */
cp++;
cp++;
} /* endwhile (*cp) */
- get_space((size_t) 1);
+ get_space(tps, (size_t) 1);
TPS(out_buff)[TPS(out_used)] = '\0';
+ if (TPS(stack_ptr) && !_nc_tparm_err) {
+ DEBUG(2, ("tparm: stack has %d item%s on return",
+ TPS(stack_ptr),
+ TPS(stack_ptr) == 1 ? "" : "s"));
+ _nc_tparm_err++;
+ }
+
T((T_RETURN("%s"), _nc_visbuf(TPS(out_buff))));
return (TPS(out_buff));
}
+#ifdef CUR
+/*
+ * Only a few standard capabilities accept string parameters. The others that
+ * are parameterized accept only numeric parameters.
+ */
+static bool
+check_string_caps(TPARM_DATA *data, const char *string)
+{
+ bool result = FALSE;
+
+#define CHECK_CAP(name) (VALID_STRING(name) && !strcmp(name, string))
+
+ /*
+ * Disallow string parameters unless we can check them against a terminal
+ * description.
+ */
+ if (cur_term != NULL) {
+ int want_type = 0;
+
+ if (CHECK_CAP(pkey_key))
+ want_type = 2; /* function key #1, type string #2 */
+ else if (CHECK_CAP(pkey_local))
+ want_type = 2; /* function key #1, execute string #2 */
+ else if (CHECK_CAP(pkey_xmit))
+ want_type = 2; /* function key #1, transmit string #2 */
+ else if (CHECK_CAP(plab_norm))
+ want_type = 2; /* label #1, show string #2 */
+#ifdef pkey_plab
+ else if (CHECK_CAP(pkey_plab))
+ want_type = 6; /* function key #1, type string #2, show string #3 */
+#endif
+#if NCURSES_XNAMES
+ else {
+ char *check;
+
+ check = tigetstr("Cs");
+ if (CHECK_CAP(check))
+ want_type = 1; /* style #1 */
+
+ check = tigetstr("Ms");
+ if (CHECK_CAP(check))
+ want_type = 3; /* storage unit #1, content #2 */
+ }
+#endif
+
+ if (want_type == data->tparm_type) {
+ result = TRUE;
+ } else {
+ T(("unexpected string-parameter"));
+ }
+ }
+ return result;
+}
+
+#define ValidCap(allow_strings) (myData.tparm_type == 0 || \
+ (allow_strings && \
+ check_string_caps(&myData, string)))
+#else
+#define ValidCap(allow_strings) 1
+#endif
+
#if NCURSES_TPARM_VARARGS
NCURSES_EXPORT(char *)
tparm(const char *string, ...)
{
+ TPARM_STATE *tps = get_tparm_state(cur_term);
TPARM_DATA myData;
- va_list ap;
char *result = NULL;
_nc_tparm_err = 0;
#ifdef TRACE
- TPS(tname) = "tparm";
+ tps->tname = "tparm";
#endif /* TRACE */
- if (tparm_setup(string, &myData) == OK) {
+ if (tparm_setup(cur_term, string, &myData) == OK && ValidCap(TRUE)) {
+ va_list ap;
va_start(ap, string);
tparm_copy_valist(&myData, TRUE, ap);
va_end(ap);
- result = tparam_internal(string, &myData);
+ result = tparam_internal(tps, string, &myData);
}
return result;
}
TPARM_ARG a8,
TPARM_ARG a9)
{
+ TPARM_STATE *tps = get_tparm_state(cur_term);
TPARM_DATA myData;
char *result = NULL;
_nc_tparm_err = 0;
#ifdef TRACE
- TPS(tname) = "tparm";
+ tps->tname = "tparm";
#endif /* TRACE */
- if (tparm_setup(string, &myData) == OK) {
+#define string_ok (sizeof(char*) <= sizeof(TPARM_ARG))
+
+ if (tparm_setup(cur_term, string, &myData) == OK && ValidCap(string_ok)) {
myData.param[0] = a1;
myData.param[1] = a2;
myData.param[7] = a8;
myData.param[8] = a9;
- result = tparam_internal(string, &myData);
+ result = tparam_internal(tps, string, &myData);
}
return result;
}
NCURSES_EXPORT(char *)
tiparm(const char *string, ...)
{
+ TPARM_STATE *tps = get_tparm_state(cur_term);
TPARM_DATA myData;
- va_list ap;
char *result = NULL;
_nc_tparm_err = 0;
#ifdef TRACE
- TPS(tname) = "tiparm";
+ tps->tname = "tiparm";
#endif /* TRACE */
- if (tparm_setup(string, &myData) == OK) {
+ if (tparm_setup(cur_term, string, &myData) == OK && ValidCap(TRUE)) {
+ va_list ap;
va_start(ap, string);
tparm_copy_valist(&myData, FALSE, ap);
va_end(ap);
- result = tparam_internal(string, &myData);
+ result = tparam_internal(tps, string, &myData);
}
return result;
}
/*
- * The internal-use flavor ensures that the parameters are numbers, not strings
+ * Use tparm if the formatting string matches the expected number of parameters
+ * counting string-parameters.
*/
NCURSES_EXPORT(char *)
-_nc_tiparm(int expected, const char *string, ...)
+tiparm_s(int num_expected, int tparm_type, const char *string, ...)
{
+ TPARM_STATE *tps = get_tparm_state(cur_term);
TPARM_DATA myData;
- va_list ap;
char *result = NULL;
_nc_tparm_err = 0;
#ifdef TRACE
- TPS(tname) = "_nc_tiparm";
+ tps->tname = "tiparm_s";
#endif /* TRACE */
-
- if (tparm_setup(string, &myData) == OK
- && myData.num_actual <= expected
- && myData.tparm_type == 0) {
+ if (num_expected >= 0 &&
+ num_expected <= 9 &&
+ tparm_type >= 0 &&
+ tparm_type < 7 && /* limit to 2 string parameters */
+ tparm_setup(cur_term, string, &myData) == OK &&
+ myData.tparm_type == tparm_type &&
+ myData.num_actual == num_expected) {
+ va_list ap;
va_start(ap, string);
tparm_copy_valist(&myData, FALSE, ap);
va_end(ap);
- result = tparam_internal(string, &myData);
+ result = tparam_internal(tps, string, &myData);
+ }
+ return result;
+}
+
+/*
+ * Analyze the formatting string, return the analysis.
+ */
+NCURSES_EXPORT(int)
+tiscan_s(int *num_expected, int *tparm_type, const char *string)
+{
+ TPARM_DATA myData;
+ int result = ERR;
+
+#ifdef TRACE
+ TPARM_STATE *tps = get_tparm_state(cur_term);
+ tps->tname = "tiscan_s";
+#endif /* TRACE */
+
+ if (tparm_setup(cur_term, string, &myData) == OK) {
+ *num_expected = myData.num_actual;
+ *tparm_type = myData.tparm_type;
+ result = OK;
}
return result;
}
+
+/*
+ * The internal-use flavor ensures that parameters are numbers, not strings.
+ * In addition to ensuring that they are numbers, it ensures that the parameter
+ * count is consistent with intended usage.
+ *
+ * Unlike the general-purpose tparm/tiparm, these internal calls are fairly
+ * well defined:
+ *
+ * expected == 0 - not applicable
+ * expected == 1 - set color, or vertical/horizontal addressing
+ * expected == 2 - cursor addressing
+ * expected == 4 - initialize color or color pair
+ * expected == 9 - set attributes
+ *
+ * Only for the last case (set attributes) should a parameter be optional.
+ * Also, a capability which calls for more parameters than expected should be
+ * ignored.
+ *
+ * Return a null if the parameter-checks fail. Otherwise, return a pointer to
+ * the formatted capability string.
+ */
+NCURSES_EXPORT(char *)
+_nc_tiparm(int expected, const char *string, ...)
+{
+ TPARM_STATE *tps = get_tparm_state(cur_term);
+ TPARM_DATA myData;
+ char *result = NULL;
+
+ _nc_tparm_err = 0;
+ T((T_CALLED("_nc_tiparm(%d, %s, ...)"), expected, _nc_visbuf(string)));
+#ifdef TRACE
+ tps->tname = "_nc_tiparm";
+#endif /* TRACE */
+
+ if (tparm_setup(cur_term, string, &myData) == OK && ValidCap(FALSE)) {
+#ifdef CUR
+ if (myData.num_actual != expected && cur_term != NULL) {
+ int needed = expected;
+ if (CHECK_CAP(to_status_line)) {
+ needed = 0; /* allow for xterm's status line */
+ } else if (CHECK_CAP(set_a_background)) {
+ needed = 0; /* allow for monochrome fakers */
+ } else if (CHECK_CAP(set_a_foreground)) {
+ needed = 0;
+ } else if (CHECK_CAP(set_background)) {
+ needed = 0;
+ } else if (CHECK_CAP(set_foreground)) {
+ needed = 0;
+ }
+#if NCURSES_XNAMES
+ else {
+ char *check;
+
+ check = tigetstr("xm");
+ if (CHECK_CAP(check)) {
+ needed = 3;
+ }
+ check = tigetstr("S0");
+ if (CHECK_CAP(check)) {
+ needed = 0; /* used in screen-base */
+ }
+ }
+#endif
+ if (myData.num_actual >= needed && myData.num_actual <= expected)
+ expected = myData.num_actual;
+ }
+#endif
+ if (myData.num_actual == 0 && expected) {
+ T(("missing parameter%s, expected %s%d",
+ expected > 1 ? "s" : "",
+ expected == 9 ? "up to " : "",
+ expected));
+ } else if (myData.num_actual > expected) {
+ T(("too many parameters, have %d, expected %d",
+ myData.num_actual,
+ expected));
+ } else if (expected != 9 && myData.num_actual != expected) {
+ T(("expected %d parameters, have %d",
+ myData.num_actual,
+ expected));
+ } else {
+ va_list ap;
+
+ va_start(ap, string);
+ tparm_copy_valist(&myData, FALSE, ap);
+ va_end(ap);
+
+ result = tparam_internal(tps, string, &myData);
+ }
+ }
+ returnPtr(result);
+}
+
+/*
+ * Improve tic's checks by resetting the terminfo "static variables" before
+ * calling functions which may update them.
+ */
+NCURSES_EXPORT(void)
+_nc_reset_tparm(TERMINAL *term)
+{
+ TPARM_STATE *tps = get_tparm_state(term);
+ memset(TPS(static_vars), 0, sizeof(TPS(static_vars)));
+}
projects / ncurses.git / blobdiff