/****************************************************************************
- * Copyright (c) 1998-2016,2017 Free Software Foundation, Inc. *
+ * Copyright (c) 1998-2018,2019 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 *
#include <parametrized.h>
#include <transform.h>
-MODULE_ID("$Id: tic.c,v 1.233 2017/07/15 17:40:19 tom Exp $")
+MODULE_ID("$Id: tic.c,v 1.271 2019/03/17 00:46:55 tom Exp $")
#define STDIN_NAME "<stdin>"
static bool capdump = FALSE; /* running as infotocap? */
static bool infodump = FALSE; /* running as captoinfo? */
static bool showsummary = FALSE;
+static unsigned debug_level;
static char **namelst = 0;
static const char *to_remove;
+#if NCURSES_XNAMES
+static bool using_extensions = FALSE;
+#endif
+
static void (*save_check_termtype) (TERMTYPE2 *, bool);
static void check_termtype(TERMTYPE2 *tt, bool);
*target = (*target * 10) + (source - '0');
}
-#define VtoTrace(opt) (unsigned) ((opt > 0) ? opt : (opt == 0))
-
int
main(int argc, char *argv[])
{
char my_tmpname[PATH_MAX];
char my_altfile[PATH_MAX];
int v_opt = -1;
- unsigned debug_level;
int smart_defaults = TRUE;
char *termcap;
ENTRY *qp;
/* FALLTHRU */
case 'x':
use_extended_names(TRUE);
+ using_extensions = TRUE;
break;
#endif
default:
static void
check_acs(TERMTYPE2 *tp)
{
+ int vt100_smacs = 0;
+ int vt100_rmacs = 0;
+ int vt100_enacs = 0;
+
+ /*
+ * ena_acs is not always necessary, but if it is present, the enter/exit
+ * capabilities should be.
+ */
+ ANDMISSING(ena_acs, enter_alt_charset_mode);
+ ANDMISSING(ena_acs, exit_alt_charset_mode);
+ PAIRED(exit_alt_charset_mode, exit_alt_charset_mode);
+
+ /*
+ * vt100-like is frequently used, but perhaps ena_acs is missing, etc.
+ */
+ if (VALID_STRING(enter_alt_charset_mode)) {
+ vt100_smacs = (!strcmp("\033(0", enter_alt_charset_mode)
+ ? 2
+ : (!strcmp("\016", enter_alt_charset_mode)
+ ? 1
+ : 0));
+ }
+ if (VALID_STRING(exit_alt_charset_mode)) {
+ vt100_rmacs = (!strcmp("\033(B", exit_alt_charset_mode)
+ ? 2
+ : (!strcmp("\017", exit_alt_charset_mode)
+ ? 1
+ : 0));
+ }
+ if (VALID_STRING(ena_acs)) {
+ vt100_enacs = (!strcmp("\033(B\033)0", ena_acs)
+ ? 2
+ : 0);
+ }
+ if (vt100_rmacs && vt100_smacs && (vt100_rmacs != vt100_smacs)) {
+ _nc_warning("rmacs/smacs are inconsistent");
+ }
+ if ((vt100_rmacs == 2) && (vt100_smacs == 2) && vt100_enacs) {
+ _nc_warning("rmacs/smacs make enacs redundant");
+ }
+ if ((vt100_rmacs == 1) && (vt100_smacs == 1) && !vt100_enacs) {
+ _nc_warning("VT100-style rmacs/smacs require enacs");
+ }
+
if (VALID_STRING(acs_chars)) {
const char *boxes = "lmkjtuvwqxn";
char mapped[256];
}
}
+static bool
+same_color(NCURSES_CONST char *oldcap, NCURSES_CONST char *newcap, int limit)
+{
+ bool result = FALSE;
+ if (limit > 16)
+ limit = 16;
+ if (limit >= 8) {
+ int n;
+ int same;
+ for (n = same = 0; n < limit; ++n) {
+ char *oldvalue = strdup(TPARM_1(oldcap, n));
+ char *newvalue = strdup(TPARM_1(newcap, n));
+ same += !strcmp(oldvalue, newvalue);
+ free(oldvalue);
+ free(newvalue);
+ }
+ result = (same == limit);
+ }
+ return result;
+}
+
/*
* Check if the color capabilities are consistent
*/
PAIRED(set_color_pair, initialize_pair);
if (VALID_STRING(set_foreground)
- && VALID_STRING(set_a_foreground)
- && !_nc_capcmp(set_foreground, set_a_foreground))
- _nc_warning("expected setf/setaf to be different");
+ && VALID_STRING(set_a_foreground)) {
+ if (!_nc_capcmp(set_foreground, set_a_foreground)) {
+ _nc_warning("expected setf/setaf to be different");
+ } else if (same_color(set_foreground, set_a_foreground, max_colors)) {
+ _nc_warning("setf/setaf are equivalent");
+ }
+ }
if (VALID_STRING(set_background)
- && VALID_STRING(set_a_background)
- && !_nc_capcmp(set_background, set_a_background))
- _nc_warning("expected setb/setab to be different");
+ && VALID_STRING(set_a_background)) {
+ if (!_nc_capcmp(set_background, set_a_background)) {
+ _nc_warning("expected setb/setab to be different");
+ } else if (same_color(set_background, set_a_background, max_colors)) {
+ _nc_warning("setb/setab are equivalent");
+ }
+ }
/* see: has_colors() */
if (VALID_NUMERIC(max_colors) && VALID_NUMERIC(max_pairs)
- && (((set_foreground != NULL)
- && (set_background != NULL))
- || ((set_a_foreground != NULL)
- && (set_a_background != NULL))
+ && ((VALID_STRING(set_foreground)
+ && VALID_STRING(set_background))
+ || (VALID_STRING(set_a_foreground)
+ && VALID_STRING(set_a_background))
|| set_color_pair)) {
if (!VALID_STRING(orig_pair) && !VALID_STRING(orig_colors))
_nc_warning("expected either op/oc string for resetting colors");
static void
check_printer(TERMTYPE2 *tp)
{
+ (void) tp;
+#if defined(enter_doublewide_mode) && defined(exit_doublewide_mode)
PAIRED(enter_doublewide_mode, exit_doublewide_mode);
+#endif
+#if defined(enter_italics_mode) && defined(exit_italics_mode)
PAIRED(enter_italics_mode, exit_italics_mode);
+#endif
+#if defined(enter_leftward_mode) && defined(exit_leftward_mode)
PAIRED(enter_leftward_mode, exit_leftward_mode);
+#endif
+#if defined(enter_micro_mode) && defined(exit_micro_mode)
PAIRED(enter_micro_mode, exit_micro_mode);
+#endif
+#if defined(enter_shadow_mode) && defined(exit_shadow_mode)
PAIRED(enter_shadow_mode, exit_shadow_mode);
+#endif
+#if defined(enter_subscript_mode) && defined(exit_subscript_mode)
PAIRED(enter_subscript_mode, exit_subscript_mode);
+#endif
+#if defined(enter_superscript_mode) && defined(exit_superscript_mode)
PAIRED(enter_superscript_mode, exit_superscript_mode);
+#endif
+#if defined(enter_upward_mode) && defined(exit_upward_mode)
PAIRED(enter_upward_mode, exit_upward_mode);
+#endif
+#if defined(start_char_set_def) && defined(stop_char_set_def)
ANDMISSING(start_char_set_def, stop_char_set_def);
+#endif
/* if we have a parameterized form, then the non-parameterized is easy */
+#if defined(set_bottom_margin_parm) && defined(set_bottom_margin)
ANDMISSING(set_bottom_margin_parm, set_bottom_margin);
+#endif
+#if defined(set_left_margin_parm) && defined(set_left_margin)
ANDMISSING(set_left_margin_parm, set_left_margin);
+#endif
+#if defined(set_right_margin_parm) && defined(set_right_margin)
ANDMISSING(set_right_margin_parm, set_right_margin);
+#endif
+#if defined(set_top_margin_parm) && defined(set_top_margin)
ANDMISSING(set_top_margin_parm, set_top_margin);
+#endif
+#if defined(parm_down_micro) && defined(micro_down)
ANDMISSING(parm_down_micro, micro_down);
+#endif
+#if defined(parm_left_micro) && defined(micro_left)
ANDMISSING(parm_left_micro, micro_left);
+#endif
+#if defined(parm_right_micro) && defined(micro_right)
ANDMISSING(parm_right_micro, micro_right);
+#endif
+#if defined(parm_up_micro) && defined(micro_up)
ANDMISSING(parm_up_micro, micro_up);
+#endif
}
static bool
bool have_kmouse = FALSE;
bool use_sgr_39_49 = FALSE;
char *name = _nc_first_name(tp->term_names);
+ bool is_screen = !strncmp(name, "screen", 6);
+ bool screen_base = (is_screen
+ && strchr(name, '.') == 0);
if (!VALID_BOOLEAN(have_bce)) {
have_bce = FALSE;
}
if (have_XM && have_XT) {
- _nc_warning("Screen's XT capability conflicts with XM");
- } else if (have_XT
- && strstr(name, "screen") != 0
- && strchr(name, '.') != 0) {
- _nc_warning("Screen's \"screen\" entries should not have XT set");
+ _nc_warning("screen's XT capability conflicts with XM");
+ } else if (have_XT && screen_base) {
+ _nc_warning("screen's \"screen\" entries should not have XT set");
} else if (have_XT) {
- if (!have_kmouse && have_bce) {
+ if (!have_kmouse && is_screen) {
if (VALID_STRING(key_mouse)) {
- _nc_warning("Value of kmous inconsistent with screen's usage");
+ _nc_warning("value of kmous inconsistent with screen's usage");
} else {
- _nc_warning("Expected kmous capability with XT");
+ _nc_warning("expected kmous capability with XT");
}
}
if (!have_bce && max_colors > 0)
- _nc_warning("Expected bce capability with XT");
+ _nc_warning("expected bce capability with XT");
if (!use_sgr_39_49 && have_bce && max_colors > 0)
- _nc_warning("Expected orig_colors capability with XT to have 39/49 parameters");
+ _nc_warning("expected orig_colors capability with XT to have 39/49 parameters");
if (VALID_STRING(to_status_line))
_nc_warning("\"tsl\" capability is redundant, given XT");
} else {
- if (have_kmouse && !have_XM)
- _nc_warning("Expected XT to be set, given kmous");
+ if (have_kmouse
+ && !have_XM
+ && !screen_base && strchr(name, '+') == 0) {
+ _nc_warning("expected XT to be set, given kmous");
+ }
}
}
#endif
return result;
}
+/*
+ * Check for user-capabilities that happen to be used in ncurses' terminal
+ * database.
+ */
+static struct user_table_entry const *
+lookup_user_capability(const char *name)
+{
+ struct user_table_entry const *result = 0;
+ if (*name != 'k') {
+ result = _nc_find_user_entry(name);
+ }
+ return result;
+}
+
+/*
+ * If a given name is likely to be a user-capability, return the number of
+ * parameters it would be used with. If not, return -1.
+ *
+ * ncurses assumes that u6 could be used for getting the cursor-position, but
+ * that is not implemented. Make a special case for that, to quiet needless
+ * warnings.
+ *
+ * The other string-capability extensions (see terminfo.src) which could have
+ * parameters such as "Ss", "%u", are not used by ncurses. But we check those
+ * anyway, to validate the terminfo database.
+ */
+static int
+is_user_capability(const char *name)
+{
+ int result = -1;
+ if (name[0] == 'u' &&
+ (name[1] >= '0' && name[1] <= '9') &&
+ name[2] == '\0') {
+ result = (name[1] == '6') ? 2 : 0;
+ } else if (using_extensions) {
+ struct user_table_entry const *p = lookup_user_capability(name);
+ if (p != 0) {
+ result = (int) p->ute_argc;
+ }
+ }
+ return result;
+}
+
/*
* Make a quick sanity check for the parameters which are used in the given
* strings. If there are no "%p" tokens, then there should be no other "%"
* markers.
*/
static void
-check_params(TERMTYPE2 *tp, const char *name, char *value)
+check_params(TERMTYPE2 *tp, const char *name, char *value, int extended)
{
int expected = expected_params(name);
int actual = 0;
s++;
}
+ if (extended) {
+ int check = is_user_capability(name);
+ if (check != actual) {
+ _nc_warning("extended %s capability has %d parameters, expected %d",
+ name, actual, check);
+ } else if (debug_level > 1) {
+ _nc_warning("extended %s capability has %d parameters, as expected",
+ name, actual);
+ }
+ expected = actual;
+ }
+
if (params[0]) {
_nc_warning("%s refers to parameter 0 (%%p0), which is not allowed", name);
}
_nc_warning("%s omits parameter %d", name, n);
}
}
+
+ /*
+ * Counting "%p" markers does not account for termcap expressions which
+ * may not have been fully translated. Also, tparm does its own analysis.
+ * Report differences here.
+ */
+ if (actual >= 0) {
+ char *p_is_s[NUM_PARM];
+ int popcount;
+ int analyzed = _nc_tparm_analyze(value, p_is_s, &popcount);
+ if (analyzed < popcount) {
+ analyzed = popcount;
+ }
+ if (actual != analyzed && expected != analyzed) {
+ int user_cap = is_user_capability(name);
+ if ((user_cap == analyzed) && using_extensions) {
+ ; /* ignore */
+ } else if (user_cap >= 0) {
+ _nc_warning("tparm will use %d parameters for %s, expected %d",
+ analyzed, name, user_cap);
+ } else {
+ _nc_warning("tparm analyzed %d parameters for %s, expected %d",
+ analyzed, name, actual);
+ }
+ }
+ }
}
static bool
}
static void
-check_delays(const char *name, const char *value)
+check_delays(TERMTYPE2 *tp, const char *name, const char *value)
{
const char *p, *q;
const char *first = 0;
_nc_warning("function-key %s has delay", name);
} else if (proportional && !line_capability(name)) {
_nc_warning("non-line capability using proportional delay: %s", name);
+ } else if (!xon_xoff &&
+ !mandatory &&
+ strchr(_nc_first_name(tp->term_names), '+') == 0) {
+ _nc_warning("%s in %s is used since no xon/xoff",
+ (proportional
+ ? "proportional delay"
+ : "delay"),
+ name);
}
} else {
p = q - 1; /* restart scan */
myParam(9));
break;
}
- return result;
+ return strdup(result);
}
#define IsDelay(ch) ((ch) == '.' || isdigit(UChar(ch)))
|| !strcmp(name, "setb")
|| !strcmp(name, "setaf")
|| !strcmp(name, "setab")) {
- limit = max_colors;
+ if ((limit = max_colors) > 16)
+ limit = 16;
}
for (count = 0; count < limit; ++count) {
char *ti_check = check_1_infotocap(name, ti_value, count);
_nc_warning("tparm-conversion of %s(%d) differs between\n\tterminfo %s\n\ttermcap %s",
name, count, ti_check, tc_check);
}
+ free(ti_check);
+ free(tc_check);
}
} else if (params == 0 && !same_ti_tc(ti_value, tc_value, &embedded)) {
if (embedded) {
;
} else if (b[0] == '$'
&& b[1] == '<') {
- _nc_warning("Did not find delay %s", _nc_visbuf(b));
+ _nc_warning("did not find delay %s", _nc_visbuf(b));
} else {
_nc_warning("checking sgr(%s) %s\n\tcompare to %s\n\tunmatched %s",
sgr_names[num], _nc_visbuf2(1, base_a),
NAME_VALUE *given = get_fkey_list(tp);
if (check == 0)
- failed("check_termtype");
+ failed("check_conflict");
for (j = 0; given[j].keycode; ++j) {
const char *a = given[j].value;
bool first = TRUE;
+ if (!VALID_STRING(a))
+ continue;
+
for (k = j + 1; given[k].keycode; k++) {
const char *b = given[k].value;
+
+ if (!VALID_STRING(b))
+ continue;
if (check[k])
continue;
+
if (!_nc_capcmp(a, b)) {
check[j] = 1;
check[k] = 1;
if (first) {
if (!conflict) {
- _nc_warning("Conflicting key definitions (using the last)");
+ _nc_warning("conflicting key definitions (using the last)");
conflict = TRUE;
}
fprintf(stderr, "...");
if (!first)
fprintf(stderr, "\n");
}
+#if NCURSES_XNAMES
+ if (using_extensions) {
+ /* *INDENT-OFF* */
+ static struct {
+ const char *xcurses;
+ const char *shifted;
+ } table[] = {
+ { "kDC", NULL },
+ { "kDN", "kind" },
+ { "kEND", NULL },
+ { "kHOM", NULL },
+ { "kLFT", NULL },
+ { "kNXT", NULL },
+ { "kPRV", NULL },
+ { "kRIT", NULL },
+ { "kUP", "kri" },
+ { NULL, NULL },
+ };
+ /* *INDENT-ON* */
+
+ /*
+ * SVr4 curses defines the "xcurses" names listed above except for
+ * the special cases in the "shifted" column. When using these
+ * names for xterm's extensions, that was confusing, and resulted
+ * in adding extended capabilities with "2" (shift) suffix. This
+ * check warns about unnecessary use of extensions for this quirk.
+ */
+ for (j = 0; given[j].keycode; ++j) {
+ const char *find = given[j].name;
+ int value;
+ char ch;
+
+ if (!VALID_STRING(given[j].value))
+ continue;
+
+ for (k = 0; table[k].xcurses; ++k) {
+ const char *test = table[k].xcurses;
+ size_t size = strlen(test);
+
+ if (!strncmp(find, test, size) && strcmp(find, test)) {
+ switch (sscanf(find + size, "%d%c", &value, &ch)) {
+ case 1:
+ if (value == 2) {
+ _nc_warning("expected '%s' rather than '%s'",
+ (table[k].shifted
+ ? table[k].shifted
+ : test), find);
+ } else if (value < 2 || value > 15) {
+ _nc_warning("expected numeric 2..15 '%s'", find);
+ }
+ break;
+ default:
+ _nc_warning("expected numeric suffix for '%s'", find);
+ break;
+ }
+ break;
+ }
+ }
+ }
+ }
+#endif
free(given);
free(check);
}
}
}
+static int
+standard_type(const char *name)
+{
+ int result = -1;
+ const struct name_table_entry *np;
+
+ if ((np = _nc_find_entry(name, _nc_get_hash_table(0))) != 0) {
+ result = np->nte_type;
+ }
+ return result;
+}
+
+static const char *
+name_of_type(int type)
+{
+ const char *result = "unknown";
+ switch (type) {
+ case BOOLEAN:
+ result = "boolean";
+ break;
+ case NUMBER:
+ result = "number";
+ break;
+ case STRING:
+ result = "string";
+ break;
+ }
+ return result;
+}
+
+static void
+check_user_capability_type(const char *name, int actual)
+{
+ if (lookup_user_capability(name) == 0) {
+ int expected = standard_type(name);
+ if (expected >= 0) {
+ _nc_warning("expected %s to be %s, but actually %s",
+ name,
+ name_of_type(actual),
+ name_of_type(expected)
+ );
+ } else if (*name != 'k') {
+ _nc_warning("undocumented %s capability %s",
+ name_of_type(actual),
+ name);
+ }
+ }
+}
+
/* other sanity-checks (things that we don't want in the normal
* logic that reads a terminfo entry)
*/
for_each_string(j, tp) {
char *a = tp->Strings[j];
if (VALID_STRING(a)) {
- check_params(tp, ExtStrname(tp, (int) j, strnames), a);
- check_delays(ExtStrname(tp, (int) j, strnames), a);
+ const char *name = ExtStrname(tp, (int) j, strnames);
+ /*
+ * If we expect parameters, or if there might be parameters,
+ * check for consistent number of parameters.
+ */
+ if (j >= SIZEOF(parametrized) ||
+ is_user_capability(name) >= 0 ||
+ parametrized[j] > 0) {
+ check_params(tp, name, a, (j >= STRCOUNT));
+ }
+ check_delays(tp, ExtStrname(tp, (int) j, strnames), a);
if (capdump) {
check_infotocap(tp, (int) j, a);
}
}
}
+#if NCURSES_XNAMES
+ /* in extended mode, verify that each extension is expected type */
+ for_each_ext_boolean(j, tp) {
+ check_user_capability_type(ExtBoolname(tp, (int) j, strnames), BOOLEAN);
+ }
+ for_each_ext_number(j, tp) {
+ check_user_capability_type(ExtNumname(tp, (int) j, strnames), NUMBER);
+ }
+ for_each_ext_string(j, tp) {
+ check_user_capability_type(ExtStrname(tp, (int) j, strnames), STRING);
+ }
+#endif /* NCURSES_XNAMES */
check_acs(tp);
check_colors(tp);
_nc_visbuf(exit_attribute_mode)));
}
}
+#if defined(exit_italics_mode)
CHECK_SGR0(exit_italics_mode);
+#endif
CHECK_SGR0(exit_standout_mode);
CHECK_SGR0(exit_underline_mode);
if (check_sgr0 != exit_attribute_mode) {