X-Git-Url: https://ncurses.scripts.mit.edu/?p=ncurses.git;a=blobdiff_plain;f=progs%2Ftic.c;h=618419c847ce5300104f99b998de7d00a7376069;hp=53fa7225a65285cc6979c3037b08499fa4daccd1;hb=c6f54649ed4bf49ec27a522816984d2290201438;hpb=8b06e371ed1bce3dd6f37138e6becb5e1a562fe0;ds=sidebyside diff --git a/progs/tic.c b/progs/tic.c index 53fa7225..618419c8 100644 --- a/progs/tic.c +++ b/progs/tic.c @@ -1,5 +1,5 @@ /**************************************************************************** - * Copyright (c) 1998-2011,2012 Free Software Foundation, Inc. * + * Copyright (c) 1998-2013,2014 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 * @@ -43,10 +43,14 @@ #include #include +#include #include +#include #include -MODULE_ID("$Id: tic.c,v 1.162 2012/02/22 23:59:45 tom Exp $") +MODULE_ID("$Id: tic.c,v 1.207 2014/06/15 00:36:45 tom Exp $") + +#define STDIN_NAME "" const char *_nc_progname = "tic"; @@ -55,6 +59,7 @@ static FILE *tmp_fp; static bool capdump = FALSE; /* running as infotocap? */ static bool infodump = FALSE; /* running as captoinfo? */ static bool showsummary = FALSE; +static char **namelst = 0; static const char *to_remove; static void (*save_check_termtype) (TERMTYPE *, bool); @@ -103,8 +108,10 @@ free_namelist(char **src) #endif static void -cleanup(char **namelst GCC_UNUSED) +cleanup(void) { + int rc; + #if NO_LEAKS free_namelist(namelst); #endif @@ -112,10 +119,12 @@ cleanup(char **namelst GCC_UNUSED) fclose(tmp_fp); if (to_remove != 0) { #if HAVE_REMOVE - remove(to_remove); + rc = remove(to_remove); #else - unlink(to_remove); + rc = unlink(to_remove); #endif + if (rc != 0) + perror(to_remove); } } @@ -123,7 +132,6 @@ static void failed(const char *msg) { perror(msg); - cleanup((char **) 0); ExitProgram(EXIT_FAILURE); } @@ -137,7 +145,6 @@ usage(void) #if NCURSES_XNAMES " -a retain commented-out capabilities (sets -x also)", #endif - " -K translate entries to termcap source form with BSD syntax", " -C translate entries to termcap source form", " -D print list of tic's database locations (first must be writable)", " -c check only, validate input without compiling or translating", @@ -146,6 +153,7 @@ usage(void) " -G format %{number} to %'char'", " -g format %'char' to %{number}", " -I translate entries to terminfo source form", + " -K translate entries to termcap source form with BSD syntax", " -L translate entries to full terminfo source form", " -N disable smart defaults for source translation", " -o set output directory for compiled entry writes", @@ -292,8 +300,10 @@ put_translate(int c) if (in_name) { if (used + 1 >= have) { have += 132; - namebuf = typeRealloc(char, have, namebuf); - suffix = typeRealloc(char, have, suffix); + if ((namebuf = typeRealloc(char, have, namebuf)) == 0) + failed("put_translate namebuf"); + if ((suffix = typeRealloc(char, have, suffix)) == 0) + failed("put_translate suffix"); } if (c == '\n' || c == '@') { namebuf[used++] = '\0'; @@ -365,19 +375,102 @@ stripped(char *src) } static FILE * -open_input(const char *filename) +open_tempfile(char *filename) +{ + FILE *result = 0; + + _nc_STRCPY(filename, "/tmp/XXXXXX", PATH_MAX); +#if HAVE_MKSTEMP + { + int oldmask = (int) umask(077); + int fd = mkstemp(filename); + if (fd >= 0) + result = fdopen(fd, "w"); + umask((mode_t) oldmask); + } +#else + if (tmpnam(filename) != 0) + result = fopen(filename, "w"); +#endif + return result; +} + +static FILE * +copy_input(FILE *source, const char *filename, char *alt_file) { - FILE *fp = fopen(filename, "r"); + char my_altfile[PATH_MAX]; + FILE *result = 0; + FILE *target = 0; + int ch; + + if (alt_file == 0) + alt_file = my_altfile; + + if (source == 0) { + failed("copy_input (source)"); + } else if ((target = open_tempfile(alt_file)) == 0) { + failed("copy_input (target)"); + } else { + clearerr(source); + for (;;) { + ch = fgetc(source); + if (feof(source)) { + break; + } else if (ferror(source)) { + failed(filename); + } else if (ch == 0) { + /* don't loop in case someone wants to convert /dev/zero */ + fprintf(stderr, "%s: %s is not a text-file\n", _nc_progname, filename); + ExitProgram(EXIT_FAILURE); + } + fputc(ch, target); + } + fclose(source); + /* + * rewind() does not force the target file's data to disk (not does + * fflush()...). So open a second stream on the data and then close + * the one that we were writing on before starting to read from the + * second stream. + */ + result = fopen(alt_file, "r+"); + fclose(target); + to_remove = strdup(alt_file); + } + return result; +} + +static FILE * +open_input(const char *filename, char *alt_file) +{ + FILE *fp; struct stat sb; + int mode; - if (fp == 0) { - fprintf(stderr, "%s: Can't open %s\n", _nc_progname, filename); + if (!strcmp(filename, "-")) { + fp = copy_input(stdin, STDIN_NAME, alt_file); + } else if (stat(filename, &sb) < 0) { + fprintf(stderr, "%s: %s %s\n", _nc_progname, filename, strerror(errno)); ExitProgram(EXIT_FAILURE); - } - if (fstat(fileno(fp), &sb) < 0 - || (sb.st_mode & S_IFMT) != S_IFREG) { + } else if ((mode = (sb.st_mode & S_IFMT)) == S_IFDIR + || (mode != S_IFREG && mode != S_IFCHR && mode != S_IFIFO)) { fprintf(stderr, "%s: %s is not a file\n", _nc_progname, filename); ExitProgram(EXIT_FAILURE); + } else { + fp = fopen(filename, "r"); + + if (fp == 0) { + fprintf(stderr, "%s: Can't open %s\n", _nc_progname, filename); + ExitProgram(EXIT_FAILURE); + } + if (mode != S_IFREG) { + if (alt_file != 0) { + FILE *fp2 = copy_input(fp, filename, alt_file); + fp = fp2; + } else { + fprintf(stderr, "%s: %s is not a file\n", _nc_progname, filename); + ExitProgram(EXIT_FAILURE); + } + } } return fp; } @@ -395,7 +488,7 @@ make_namelist(char *src) if (src == 0) { /* EMPTY */ ; } else if (strchr(src, '/') != 0) { /* a filename */ - FILE *fp = open_input(src); + FILE *fp = open_input(src, (char *) 0); for (pass = 1; pass <= 2; pass++) { nn = 0; @@ -409,7 +502,8 @@ make_namelist(char *src) } } if (pass == 1) { - dst = typeCalloc(char *, nn + 1); + if ((dst = typeCalloc(char *, nn + 1)) == 0) + failed("make_namelist"); rewind(fp); } } @@ -431,8 +525,10 @@ make_namelist(char *src) if (mark == '\0') break; } - if (pass == 1) - dst = typeCalloc(char *, nn + 1); + if (pass == 1) { + if ((dst = typeCalloc(char *, nn + 1)) == 0) + failed("make_namelist"); + } } } if (showsummary && (dst != 0)) { @@ -462,22 +558,7 @@ matches(char **needle, const char *haystack) return (code); } -static FILE * -open_tempfile(char *name) -{ - FILE *result = 0; -#if HAVE_MKSTEMP - int fd = mkstemp(name); - if (fd >= 0) - result = fdopen(fd, "w"); -#else - if (tmpnam(name) != 0) - result = fopen(name, "w"); -#endif - return result; -} - -static const char * +static char * valid_db_path(const char *nominal) { struct stat sb; @@ -486,6 +567,8 @@ valid_db_path(const char *nominal) size_t need = strlen(nominal) + sizeof(suffix); char *result = malloc(need); + if (result == 0) + failed("valid_db_path"); _nc_STRCPY(result, nominal, need); if (strcmp(result + need - sizeof(suffix), suffix)) { _nc_STRCAT(result, suffix, need); @@ -546,7 +629,7 @@ static void show_databases(const char *outdir) { bool specific = (outdir != 0) || getenv("TERMINFO") != 0; - const char *result; + char *result; const char *tried = 0; if (outdir == 0) { @@ -554,6 +637,7 @@ show_databases(const char *outdir) } if ((result = valid_db_path(outdir)) != 0) { printf("%s\n", result); + free(result); } else { tried = outdir; } @@ -561,6 +645,7 @@ show_databases(const char *outdir) if ((outdir = _nc_home_terminfo())) { if ((result = valid_db_path(outdir)) != 0) { printf("%s\n", result); + free(result); } else if (!specific) { tried = outdir; } @@ -582,6 +667,7 @@ 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; @@ -602,7 +688,6 @@ main(int argc, char *argv[]) bool limited = TRUE; char *tversion = (char *) NULL; const char *source_file = "terminfo"; - char **namelst = 0; char *outdir = (char *) NULL; bool check_only = FALSE; bool suppress_untranslatable = FALSE; @@ -610,6 +695,7 @@ main(int argc, char *argv[]) log_fp = stderr; _nc_progname = _nc_rootname(argv[0]); + atexit(cleanup); if ((infodump = same_program(_nc_progname, PROG_CAPTOINFO)) != FALSE) { outform = F_TERMINFO; @@ -699,7 +785,6 @@ main(int argc, char *argv[]) break; case 'V': puts(curses_version()); - cleanup(namelst); ExitProgram(EXIT_SUCCESS); case 'c': check_only = TRUE; @@ -771,7 +856,6 @@ main(int argc, char *argv[]) (void) fprintf(stderr, "%s: Sorry, -e can't be used without -I or -C\n", _nc_progname); - cleanup(namelst); ExitProgram(EXIT_FAILURE); } #endif /* HAVE_BIG_CORE */ @@ -796,14 +880,11 @@ main(int argc, char *argv[]) /* file exists */ source_file = termcap; } else { - _nc_STRCPY(my_tmpname, - "/tmp/XXXXXX", - sizeof(my_tmpname)); if ((tmp_fp = open_tempfile(my_tmpname)) != 0) { source_file = my_tmpname; fprintf(tmp_fp, "%s\n", termcap); fclose(tmp_fp); - tmp_fp = open_input(source_file); + tmp_fp = open_input(source_file, (char *) 0); to_remove = source_file; } else { failed("tmpnam"); @@ -817,24 +898,28 @@ main(int argc, char *argv[]) _nc_progname, _nc_progname, usage_string); - cleanup(namelst); ExitProgram(EXIT_FAILURE); } } - if (tmp_fp == 0) - tmp_fp = open_input(source_file); + if (tmp_fp == 0) { + tmp_fp = open_input(source_file, my_altfile); + if (!strcmp(source_file, "-")) { + source_file = STDIN_NAME; + } + } - if (infodump) + if (infodump) { dump_init(tversion, smart_defaults ? outform : F_LITERAL, sortmode, width, height, debug_level, formatted); - else if (capdump) + } else if (capdump) { dump_init(tversion, outform, sortmode, width, height, debug_level, FALSE); + } /* parse entries out of the source file */ _nc_set_source(source_file); @@ -851,13 +936,12 @@ main(int argc, char *argv[]) /* do use resolution */ if (check_only || (!infodump && !capdump) || forceresolve) { if (!_nc_resolve_uses2(TRUE, literal) && !check_only) { - cleanup(namelst); ExitProgram(EXIT_FAILURE); } } /* length check */ - if (check_only && (capdump || infodump)) { + if (check_only && limited && (capdump || infodump)) { for_entry_list(qp) { if (matches(namelst, qp->tterm.term_names)) { int len = fmt_entry(&qp->tterm, NULL, FALSE, TRUE, infodump, numbers); @@ -946,7 +1030,6 @@ main(int argc, char *argv[]) else fprintf(log_fp, "No entries written\n"); } - cleanup(namelst); ExitProgram(EXIT_SUCCESS); } @@ -1033,6 +1116,17 @@ check_colors(TERMTYPE *tp) if (!VALID_STRING(orig_pair) && !VALID_STRING(orig_colors)) _nc_warning("expected either op/oc string for resetting colors"); } + if (can_change) { + if (!VALID_STRING(initialize_pair) && + !VALID_STRING(initialize_color)) { + _nc_warning("expected initc or initp because ccc is given"); + } + } else { + if (VALID_STRING(initialize_pair) || + VALID_STRING(initialize_color)) { + _nc_warning("expected ccc because initc is given"); + } + } } static char @@ -1059,7 +1153,7 @@ keypad_index(const char *string) long result = -1; if ((ch = keypad_final(string)) != '\0') { - test = strchr(list, ch); + test = (strchr) (list, ch); if (test != 0) result = (long) (test - list); } @@ -1143,6 +1237,19 @@ check_ansi_cursor(char *list[4]) } #define EXPECTED(name) if (!PRESENT(name)) _nc_warning("expected " #name) +#define UNEXPECTED(name) if (PRESENT(name)) _nc_warning("unexpected " #name ", for %s", why) + +static void +check_noaddress(TERMTYPE *tp, const char *why) +{ + UNEXPECTED(column_address); + UNEXPECTED(cursor_address); + UNEXPECTED(cursor_home); + UNEXPECTED(cursor_mem_address); + UNEXPECTED(cursor_to_ll); + UNEXPECTED(row_address); + UNEXPECTED(row_address); +} static void check_cursor(TERMTYPE *tp) @@ -1150,13 +1257,55 @@ check_cursor(TERMTYPE *tp) int count; char *list[4]; + if (hard_copy) { + check_noaddress(tp, "hard_copy"); + } else if (generic_type) { + check_noaddress(tp, "generic_type"); + } else if (strchr(tp->term_names, '+') == 0) { + int y = 0; + int x = 0; + if (PRESENT(column_address)) + ++y; + if (PRESENT(cursor_address)) + y = x = 10; + if (PRESENT(cursor_home)) + ++y, ++x; + if (PRESENT(cursor_mem_address)) + y = x = 10; + if (PRESENT(cursor_to_ll)) + ++y, ++x; + if (PRESENT(row_address)) + ++x; + if (PRESENT(cursor_down)) + ++y; + if (PRESENT(cursor_up)) + ++y; + if (PRESENT(cursor_left)) + ++x; + if (PRESENT(cursor_right)) + ++x; + if (x < 2 && y < 2) { + _nc_warning("terminal lacks cursor addressing"); + } else { + if (x < 2) + _nc_warning("terminal lacks cursor column-addressing"); + if (y < 2) + _nc_warning("terminal lacks cursor row-addressing"); + } + } + + /* it is rare to have an insert-line feature without a matching delete */ + ANDMISSING(parm_insert_line, insert_line); + ANDMISSING(parm_delete_line, delete_line); + ANDMISSING(parm_insert_line, parm_delete_line); + /* if we have a parameterized form, then the non-parameterized is easy */ ANDMISSING(parm_down_cursor, cursor_down); ANDMISSING(parm_up_cursor, cursor_up); ANDMISSING(parm_left_cursor, cursor_left); ANDMISSING(parm_right_cursor, cursor_right); - /* Given any of a set of cursor movement, the whole set should be present. + /* Given any of a set of cursor movement, the whole set should be present. * Technically this is not true (we could use cursor_address to fill in * unsupported controls), but it is likely. */ @@ -1323,6 +1472,12 @@ check_keypad(TERMTYPE *tp) if (*show != '\0') _nc_warning("vt100 keypad map incomplete:%s", show); } + + /* + * These warnings are useful for consistency checks - it is possible that + * there are real terminals with mismatches in these + */ + ANDMISSING(key_ic, key_dc); } static void @@ -1351,6 +1506,74 @@ check_printer(TERMTYPE *tp) ANDMISSING(parm_up_micro, micro_up); } +static bool +uses_SGR_39_49(const char *value) +{ + return (strstr(value, "39;49") != 0 + || strstr(value, "49;39") != 0); +} + +/* + * Check consistency of termcap extensions related to "screen". + */ +static void +check_screen(TERMTYPE *tp) +{ +#if NCURSES_XNAMES + if (_nc_user_definable) { + int have_XT = tigetflag("XT"); + int have_XM = tigetflag("XM"); + int have_bce = back_color_erase; + bool have_kmouse = FALSE; + bool use_sgr_39_49 = FALSE; + char *name = _nc_first_name(tp->term_names); + + if (!VALID_BOOLEAN(have_bce)) { + have_bce = FALSE; + } + if (!VALID_BOOLEAN(have_XM)) { + have_XM = FALSE; + } + if (!VALID_BOOLEAN(have_XT)) { + have_XT = FALSE; + } + if (VALID_STRING(key_mouse)) { + have_kmouse = !strcmp("\033[M", key_mouse); + } + if (VALID_STRING(orig_colors)) { + use_sgr_39_49 = uses_SGR_39_49(orig_colors); + } else if (VALID_STRING(orig_pair)) { + use_sgr_39_49 = uses_SGR_39_49(orig_pair); + } + + 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"); + } else if (have_XT) { + if (!have_kmouse && have_bce) { + if (VALID_STRING(key_mouse)) { + _nc_warning("Value of kmous inconsistent with screen's usage"); + } else { + _nc_warning("Expected kmous capability with XT"); + } + } + if (!have_bce && max_colors > 0) + _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"); + 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"); + } + } +#endif +} + /* * Returns the expected number of parameters for the given capability. */ @@ -1453,7 +1676,7 @@ check_params(TERMTYPE *tp, const char *name, char *value) int expected = expected_params(name); int actual = 0; int n; - bool params[10]; + bool params[NUM_PARM]; char *s = value; #ifdef set_top_margin_parm @@ -1462,7 +1685,7 @@ check_params(TERMTYPE *tp, const char *name, char *value) expected = 2; #endif - for (n = 0; n < 10; n++) + for (n = 0; n < NUM_PARM; n++) params[n] = FALSE; while (*s != 0) { @@ -1500,6 +1723,225 @@ check_params(TERMTYPE *tp, const char *name, char *value) } } +static char * +check_1_infotocap(const char *name, NCURSES_CONST char *value, int count) +{ + int k; + int ignored; + long numbers[1 + NUM_PARM]; + char *strings[1 + NUM_PARM]; + char *p_is_s[NUM_PARM]; + char *result; + char blob[NUM_PARM * 10]; + char *next = blob; + + *next++ = '\0'; + for (k = 1; k <= NUM_PARM; k++) { + numbers[k] = count; + sprintf(next, "XYZ%d", count); + strings[k] = next; + next += strlen(next) + 1; + } + + switch (tparm_type(name)) { + case Num_Str: + result = TPARM_2(value, numbers[1], strings[2]); + break; + case Num_Str_Str: + result = TPARM_3(value, numbers[1], strings[2], strings[3]); + break; + case Numbers: + default: + (void) _nc_tparm_analyze(value, p_is_s, &ignored); +#define myParam(n) (p_is_s[n - 1] != 0 ? ((TPARM_ARG) strings[n]) : numbers[n]) + result = TPARM_9(value, + myParam(1), + myParam(2), + myParam(3), + myParam(4), + myParam(5), + myParam(6), + myParam(7), + myParam(8), + myParam(9)); + break; + } + return result; +} + +#define IsDelay(ch) ((ch) == '.' || isdigit(UChar(ch))) + +static const char * +parse_delay_value(const char *src, double *delays, int *always) +{ + int star = 0; + + *delays = 0.0; + if (always) + *always = 0; + + while (isdigit(UChar(*src))) { + (*delays) = (*delays) * 10 + (*src++ - '0'); + } + if (*src == '.') { + int gotdot = 1; + + ++src; + while (isdigit(UChar(*src))) { + gotdot *= 10; + (*delays) += (*src++ - '0') / gotdot; + } + } + while (*src == '*' || *src == '/') { + if (always == 0 && *src == '/') + break; + if (*src++ == '*') { + star = 1; + } else { + *always = 1; + } + } + if (star) + *delays = -(*delays); + return src; +} + +static const char * +parse_ti_delay(const char *ti, double *delays) +{ + *delays = 0.0; + while (*ti != '\0') { + if (*ti == '\\') { + ++ti; + } + if (ti[0] == '$' + && ti[1] == '<' + && IsDelay(UChar(ti[2]))) { + int ignored; + const char *last = parse_delay_value(ti + 2, delays, &ignored); + if (*last == '>') { + ti = last; + } + } else { + ++ti; + } + } + return ti; +} + +static const char * +parse_tc_delay(const char *tc, double *delays) +{ + return parse_delay_value(tc, delays, (int *) 0); +} + +/* + * Compare terminfo- and termcap-strings, factoring out delays. + */ +static bool +same_ti_tc(const char *ti, const char *tc, bool * embedded) +{ + bool same = TRUE; + double ti_delay = 0.0; + double tc_delay = 0.0; + const char *ti_last; + + *embedded = FALSE; + ti_last = parse_ti_delay(ti, &ti_delay); + tc = parse_tc_delay(tc, &tc_delay); + + while ((ti < ti_last) && *tc) { + if (*ti == '\\' && ispunct(UChar(ti[1]))) { + ++ti; + if ((*ti == '^') && !strncmp(tc, "\\136", 4)) { + ti += 1; + tc += 4; + continue; + } + } else if (ti[0] == '$' && ti[1] == '<') { + double no_delay; + const char *ss = parse_ti_delay(ti, &no_delay); + if (ss != ti) { + *embedded = TRUE; + ti = ss; + continue; + } + } + if (*tc == '\\' && ispunct(UChar(tc[1]))) { + ++tc; + } + if (*ti++ != *tc++) { + same = FALSE; + break; + } + } + + if (*embedded) { + if (same) { + same = FALSE; + } else { + *embedded = FALSE; /* report only one problem */ + } + } + + return same; +} + +/* + * Check terminfo to termcap translation. + */ +static void +check_infotocap(TERMTYPE *tp, int i, char *value) +{ + const char *name = ExtStrname(tp, i, strnames); + int params = ((i < (int) SIZEOF(parametrized)) + ? parametrized[i] + : 0); + int to_char = 0; + char *ti_value; + char *tc_value; + bool embedded; + + if ((ti_value = _nc_tic_expand(value, TRUE, to_char)) == ABSENT_STRING) { + _nc_warning("tic-expansion of %s failed", name); + } else if ((tc_value = _nc_infotocap(name, ti_value, params)) == ABSENT_STRING) { + _nc_warning("tic-conversion of %s failed", name); + } else if (params > 0) { + int limit = 5; + int count; + bool first = TRUE; + + if (!strcmp(name, "setf") + || !strcmp(name, "setb") + || !strcmp(name, "setaf") + || !strcmp(name, "setab")) { + limit = max_colors; + } + for (count = 0; count < limit; ++count) { + char *ti_check = check_1_infotocap(name, ti_value, count); + char *tc_check = check_1_infotocap(name, tc_value, count); + + if (strcmp(ti_check, tc_check)) { + if (first) { + fprintf(stderr, "check_infotocap(%s)\n", name); + fprintf(stderr, "...ti '%s'\n", ti_value); + fprintf(stderr, "...tc '%s'\n", tc_value); + first = FALSE; + } + _nc_warning("tparm-conversion of %s(%d) differs between\n\tterminfo %s\n\ttermcap %s", + name, count, ti_check, tc_check); + } + } + } else if (params == 0 && !same_ti_tc(ti_value, tc_value, &embedded)) { + if (embedded) { + _nc_warning("termcap equivalent of %s cannot use embedded delay", name); + } else { + _nc_warning("tic-conversion of %s changed value\n\tfrom %s\n\tto %s", + name, ti_value, tc_value); + } + } +} + static char * skip_delay(char *s) { @@ -1662,7 +2104,7 @@ static void show_where(unsigned level) { if (_nc_tracing >= DEBUG_LEVEL(level)) { - char my_name[256]; + char my_name[MAX_NAME_SIZE]; _nc_get_type(my_name); _tracef("\"%s\", line %d, '%s'", _nc_get_source(), @@ -1674,60 +2116,129 @@ show_where(unsigned level) #define show_where(level) /* nothing */ #endif -/* other sanity-checks (things that we don't want in the normal - * logic that reads a terminfo entry) +typedef struct { + int keycode; + const char *name; + const char *value; +} NAME_VALUE; + +static NAME_VALUE * +get_fkey_list(TERMTYPE *tp) +{ + NAME_VALUE *result = typeMalloc(NAME_VALUE, NUM_STRINGS(tp) + 1); + const struct tinfo_fkeys *all_fkeys = _nc_tinfo_fkeys; + int used = 0; + int j; + + if (result == 0) + failed("get_fkey_list"); + + for (j = 0; all_fkeys[j].code; j++) { + char *a = tp->Strings[all_fkeys[j].offset]; + if (VALID_STRING(a)) { + result[used].keycode = (int) all_fkeys[j].code; + result[used].name = strnames[all_fkeys[j].offset]; + result[used].value = a; + ++used; + } + } +#if NCURSES_XNAMES + for (j = STRCOUNT; j < NUM_STRINGS(tp); ++j) { + const char *name = ExtStrname(tp, j, strnames); + if (*name == 'k') { + result[used].keycode = -1; + result[used].name = name; + result[used].value = tp->Strings[j]; + ++used; + } + } +#endif + result[used].keycode = 0; + return result; +} + +static void +show_fkey_name(NAME_VALUE * data) +{ + if (data->keycode > 0) { + fprintf(stderr, " %s", keyname(data->keycode)); + fprintf(stderr, " (capability \"%s\")", data->name); + } else { + fprintf(stderr, " capability \"%s\"", data->name); + } +} + +/* + * A terminal entry may contain more than one keycode assigned to a given + * string (e.g., KEY_END and KEY_LL). But curses will only return one (the + * last one assigned). */ static void -check_termtype(TERMTYPE *tp, bool literal) +check_conflict(TERMTYPE *tp) { bool conflict = FALSE; unsigned j, k; - char fkeys[STRCOUNT]; - /* - * A terminal entry may contain more than one keycode assigned to - * a given string (e.g., KEY_END and KEY_LL). But curses will only - * return one (the last one assigned). - */ if (!(_nc_syntax == SYN_TERMCAP && capdump)) { - memset(fkeys, 0, sizeof(fkeys)); - for (j = 0; _nc_tinfo_fkeys[j].code; j++) { - char *a = tp->Strings[_nc_tinfo_fkeys[j].offset]; + char *check = calloc((size_t) (NUM_STRINGS(tp) + 1), sizeof(char)); + NAME_VALUE *given = get_fkey_list(tp); + + if (check == 0) + failed("check_termtype"); + + 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; _nc_tinfo_fkeys[k].code; k++) { - char *b = tp->Strings[_nc_tinfo_fkeys[k].offset]; - if (!VALID_STRING(b) - || fkeys[k]) + + for (k = j + 1; given[k].keycode; k++) { + const char *b = given[k].value; + if (check[k]) continue; if (!_nc_capcmp(a, b)) { - fkeys[j] = 1; - fkeys[k] = 1; + check[j] = 1; + check[k] = 1; if (first) { if (!conflict) { _nc_warning("Conflicting key definitions (using the last)"); conflict = TRUE; } - fprintf(stderr, "... %s is the same as %s", - keyname((int) _nc_tinfo_fkeys[j].code), - keyname((int) _nc_tinfo_fkeys[k].code)); + fprintf(stderr, "..."); + show_fkey_name(given + j); + fprintf(stderr, " is the same as"); + show_fkey_name(given + k); first = FALSE; } else { - fprintf(stderr, ", %s", - keyname((int) _nc_tinfo_fkeys[k].code)); + fprintf(stderr, ", "); + show_fkey_name(given + k); } } } if (!first) fprintf(stderr, "\n"); } + free(given); + free(check); } +} + +/* other sanity-checks (things that we don't want in the normal + * logic that reads a terminfo entry) + */ +static void +check_termtype(TERMTYPE *tp, bool literal) +{ + unsigned j; - for (j = 0; j < NUM_STRINGS(tp); j++) { + check_conflict(tp); + + for_each_string(j, tp) { char *a = tp->Strings[j]; - if (VALID_STRING(a)) + if (VALID_STRING(a)) { check_params(tp, ExtStrname(tp, (int) j, strnames), a); + if (capdump) { + check_infotocap(tp, (int) j, a); + } + } } check_acs(tp); @@ -1735,6 +2246,7 @@ check_termtype(TERMTYPE *tp, bool literal) check_cursor(tp); check_keypad(tp); check_printer(tp); + check_screen(tp); /* * These may be mismatched because the terminal description relies on