X-Git-Url: https://ncurses.scripts.mit.edu/?p=ncurses.git;a=blobdiff_plain;f=progs%2Ftic.c;h=ae172ece9fc93f4f17617f3a381cbb5f8e818592;hp=620704fca633edcf2cf39a828f12b8d68ce9b0ef;hb=73dd18dba5148d708638caa25c085d82f704e972;hpb=c633e5103a29a38532cf1925257b91cea33fd090;ds=sidebyside diff --git a/progs/tic.c b/progs/tic.c index 620704fc..ae172ece 100644 --- a/progs/tic.c +++ b/progs/tic.c @@ -1,5 +1,6 @@ /**************************************************************************** - * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc. * + * Copyright 2018-2019,2020 Thomas E. Dickey * + * Copyright 1998-2017,2018 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 * @@ -29,11 +30,13 @@ /**************************************************************************** * Author: Zeyd M. Ben-Halim 1992,1995 * * and: Eric S. Raymond * + * and: Thomas E. Dickey 1996 on * ****************************************************************************/ /* * tic.c --- Main program for terminfo compiler * by Eric S. Raymond + * and Thomas E Dickey * */ @@ -41,34 +44,94 @@ #include #include -#include +#include +#include +#include #include -MODULE_ID("$Id: tic.c,v 1.83 2000/10/14 17:30:26 tom Exp $") +MODULE_ID("$Id: tic.c,v 1.286 2020/05/31 21:05:44 tom Exp $") + +#define STDIN_NAME "" const char *_nc_progname = "tic"; static FILE *log_fp; static FILE *tmp_fp; +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; -static void (*save_check_termtype) (TERMTYPE *); -static void check_termtype(TERMTYPE * tt); +#if NCURSES_XNAMES +static bool using_extensions = FALSE; +#endif -static const char usage_string[] = "[-V] [-v[n]] [-e names] [-CILNRTcfrswx1] source-file\n"; +static void (*save_check_termtype) (TERMTYPE2 *, bool); +static void check_termtype(TERMTYPE2 *tt, bool); + +static const char usage_string[] = "\ +[-e names] \ +[-o dir] \ +[-R name] \ +[-v[n]] \ +[-V] \ +[-w[n]] \ +[-\ +1\ +a\ +C\ +D\ +c\ +f\ +G\ +g\ +I\ +K\ +L\ +N\ +r\ +s\ +T\ +t\ +U\ +x\ +] \ +source-file\n"; + +#if NO_LEAKS +static void +free_namelist(char **src) +{ + if (src != 0) { + int n; + for (n = 0; src[n] != 0; ++n) + free(src[n]); + free(src); + } +} +#endif static void cleanup(void) { + int rc; + +#if NO_LEAKS + free_namelist(namelst); + _nc_leaks_dump_entry(); +#endif if (tmp_fp != 0) 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); } } @@ -76,57 +139,64 @@ static void failed(const char *msg) { perror(msg); - cleanup(); - exit(EXIT_FAILURE); + ExitProgram(EXIT_FAILURE); } static void usage(void) { - static const char *const tbl[] = +#define DATA(s) s "\n" + static const char options_string[] = { - "Options:", - " -1 format translation output one capability per line", - " -C translate entries to termcap source form", - " -I translate entries to terminfo source form", - " -L translate entries to full terminfo source form", - " -N disable smart defaults for source translation", - " -R restrict translation to given terminfo/termcap version", - " -T remove size-restrictions on compiled description", - " -V print version", + DATA("Options:") + DATA(" -0 format translation output all capabilities on one line") + DATA(" -1 format translation output one capability per line") +#if NCURSES_XNAMES + DATA(" -a retain commented-out capabilities (sets -x also)") +#endif + DATA(" -C translate entries to termcap source form") + DATA(" -D print list of tic's database locations (first must be writable)") + DATA(" -c check only, validate input without compiling or translating") + DATA(" -e translate/compile only entries named by comma-separated list") + DATA(" -f format complex strings for readability") + DATA(" -G format %{number} to %'char'") + DATA(" -g format %'char' to %{number}") + DATA(" -I translate entries to terminfo source form") + DATA(" -K translate entries to termcap source form with BSD syntax") + DATA(" -L translate entries to full terminfo source form") + DATA(" -N disable smart defaults for source translation") + DATA(" -o set output directory for compiled entry writes") + DATA(" -Q[n] dump compiled description") + DATA(" -q brief listing, removes headers") + DATA(" -R restrict translation to given terminfo/termcap version") + DATA(" -r force resolution of all use entries in source translation") + DATA(" -s print summary statistics") + DATA(" -T remove size-restrictions on compiled description") #if NCURSES_XNAMES - " -a retain commented-out capabilities (sets -x also)", + DATA(" -t suppress commented-out capabilities") #endif - " -c check only, validate input without compiling or translating", - " -f format complex strings for readability", - " -G format %{number} to %'char'", - " -g format %'char' to %{number}", - " -e translate/compile only entries named by comma-separated list", - " -o set output directory for compiled entry writes", - " -r force resolution of all use entries in source translation", - " -s print summary statistics", - " -v[n] set verbosity level", - " -w[n] set format width for translation output", + DATA(" -U suppress post-processing of entries") + DATA(" -V print version") + DATA(" -W wrap long strings according to -w[n] option") + DATA(" -v[n] set verbosity level") + DATA(" -w[n] set format width for translation output") #if NCURSES_XNAMES - " -x treat unknown capabilities as user-defined", + DATA(" -x treat unknown capabilities as user-defined") #endif - "", - "Parameters:", - " file to translate or compile" + DATA("") + DATA("Parameters:") + DATA(" file to translate or compile") }; - size_t j; +#undef DATA fprintf(stderr, "Usage: %s %s\n", _nc_progname, usage_string); - for (j = 0; j < SIZEOF(tbl); j++) { - fputs(tbl[j], stderr); - putc('\n', stderr); - } - exit(EXIT_FAILURE); + fputs(options_string, stderr); + ExitProgram(EXIT_FAILURE); } #define L_BRACE '{' #define R_BRACE '}' -#define S_QUOTE '\''; +#define S_QUOTE '\'' static void write_it(ENTRY * ep) @@ -147,9 +217,10 @@ write_it(ENTRY * ep) d = result; t = s; while ((ch = *t++) != 0) { - *d++ = ch; + *d++ = (char) ch; if (ch == '\\') { - *d++ = *t++; + if ((*d++ = *t++) == '\0') + break; } else if ((ch == '%') && (*t == L_BRACE)) { char *v = 0; @@ -161,7 +232,7 @@ write_it(ENTRY * ep) && value < 127 && isprint((int) value)) { *d++ = S_QUOTE; - *d++ = (int) value; + *d++ = (char) value; *d++ = S_QUOTE; t = (v + 1); } @@ -169,12 +240,12 @@ write_it(ENTRY * ep) } *d = 0; if (strlen(result) < strlen(s)) - strcpy(s, result); + _nc_STRCPY(s, result, strlen(s) + 1); } } _nc_set_type(_nc_first_name(ep->tterm.term_names)); - _nc_curr_line = ep->startline; + _nc_curr_line = (int) ep->startline; _nc_write_entry(&ep->tterm); } @@ -239,8 +310,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'; @@ -249,7 +322,7 @@ put_translate(int c) putchar(c); in_name = FALSE; } else if (c != '>') { - namebuf[used++] = c; + namebuf[used++] = (char) c; } else { /* ah! candidate name! */ char *up; NCURSES_CONST char *tp; @@ -261,7 +334,7 @@ put_translate(int c) if ((up = strchr(namebuf, '#')) != 0 || (up = strchr(namebuf, '=')) != 0 || ((up = strchr(namebuf, '@')) != 0 && up[1] == '>')) { - (void) strcpy(suffix, up); + _nc_STRCPY(suffix, up, have); *up = '\0'; } @@ -292,41 +365,131 @@ put_translate(int c) static char * stripped(char *src) { - while (isspace(*src)) + char *dst = 0; + + while (isspace(UChar(*src))) src++; + if (*src != '\0') { - char *dst = strcpy(malloc(strlen(src) + 1), src); - size_t len = strlen(dst); - while (--len != 0 && isspace(dst[len])) - dst[len] = '\0'; - return dst; + size_t len; + + if ((dst = strdup(src)) == NULL) { + failed("strdup"); + } else { + len = strlen(dst); + while (--len != 0 && isspace(UChar(dst[len]))) + dst[len] = '\0'; + } } - return 0; + return dst; } static FILE * -open_input(const char *filename) +open_tempfile(char *filename) { - FILE *fp = fopen(filename, "r"); - struct stat sb; + 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) +{ + char my_altfile[PATH_MAX]; + FILE *result = 0; + FILE *target = 0; + int ch; - if (fp == 0) { - fprintf(stderr, "%s: Can't open %s\n", _nc_progname, filename); - exit(EXIT_FAILURE); + 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); } - if (fstat(fileno(fp), &sb) < 0 - || (sb.st_mode & S_IFMT) != S_IFREG) { + return result; +} + +static FILE * +open_input(const char *filename, char *alt_file) +{ + FILE *fp; + struct stat sb; + int mode; + + 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); + } 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); - exit(EXIT_FAILURE); + 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; } /* Parse the "-e" option-value into a list of names */ -static const char ** +static char ** make_namelist(char *src) { - const char **dst = 0; + char **dst = 0; char *s, *base; unsigned pass, n, nn; @@ -335,7 +498,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; @@ -343,11 +506,14 @@ make_namelist(char *src) if ((s = stripped(buffer)) != 0) { if (dst != 0) dst[nn] = s; + else + free(s); nn++; } } if (pass == 1) { - dst = typeCalloc(const char *, nn + 1); + if ((dst = typeCalloc(char *, nn + 1)) == 0) + failed("make_namelist"); rewind(fp); } } @@ -369,20 +535,22 @@ make_namelist(char *src) if (mark == '\0') break; } - if (pass == 1) - dst = typeCalloc(const char *, nn + 1); + if (pass == 1) { + if ((dst = typeCalloc(char *, nn + 1)) == 0) + failed("make_namelist"); + } } } - if (showsummary) { + if (showsummary && (dst != 0)) { fprintf(log_fp, "Entries that will be compiled:\n"); for (n = 0; dst[n] != 0; n++) - fprintf(log_fp, "%d:%s\n", n + 1, dst[n]); + fprintf(log_fp, "%u:%s\n", n + 1, dst[n]); } return dst; } static bool -matches(const char **needle, const char *haystack) +matches(char **needle, const char *haystack) /* does entry in needle list match |-separated field in haystack? */ { bool code = FALSE; @@ -400,26 +568,121 @@ matches(const char **needle, const char *haystack) return (code); } -static FILE * -open_tempfile(char *name) +static char * +valid_db_path(const char *nominal) { - FILE *result = 0; -#if HAVE_MKSTEMP - int fd = mkstemp(name); - if (fd >= 0) - result = fdopen(fd, "w"); + struct stat sb; +#if USE_HASHED_DB + char suffix[] = DBM_SUFFIX; + 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); + } +#else + char *result = strdup(nominal); +#endif + + DEBUG(1, ("** stat(%s)", result)); + if (stat(result, &sb) >= 0) { +#if USE_HASHED_DB + if (!S_ISREG(sb.st_mode) + || access(result, R_OK | W_OK) != 0) { + DEBUG(1, ("...not a writable file")); + free(result); + result = 0; + } #else - if (tmpnam(name) != 0) - result = fopen(name, "w"); + if (!S_ISDIR(sb.st_mode) + || access(result, R_OK | W_OK | X_OK) != 0) { + DEBUG(1, ("...not a writable directory")); + free(result); + result = 0; + } #endif + } else { + /* check if parent is directory and is writable */ + unsigned leaf = _nc_pathlast(result); + + DEBUG(1, ("...not found")); + if (leaf) { + char save = result[leaf]; + result[leaf] = 0; + if (stat(result, &sb) >= 0 + && S_ISDIR(sb.st_mode) + && access(result, R_OK | W_OK | X_OK) == 0) { + result[leaf] = save; + } else { + DEBUG(1, ("...parent directory %s is not writable", result)); + free(result); + result = 0; + } + } else { + DEBUG(1, ("... no parent directory")); + free(result); + result = 0; + } + } return result; } +/* + * Show the databases to which tic could write. The location to which it + * writes is always the first one. If none are writable, print an error + * message. + */ +static void +show_databases(const char *outdir) +{ + bool specific = (outdir != 0) || getenv("TERMINFO") != 0; + char *result; + const char *tried = 0; + + if (outdir == 0) { + outdir = _nc_tic_dir(0); + } + if ((result = valid_db_path(outdir)) != 0) { + printf("%s\n", result); + free(result); + } else { + tried = outdir; + } + + if ((outdir = _nc_home_terminfo())) { + if ((result = valid_db_path(outdir)) != 0) { + printf("%s\n", result); + free(result); + } else if (!specific) { + tried = outdir; + } + } + + /* + * If we can write in neither location, give an error message. + */ + if (tried) { + fflush(stdout); + fprintf(stderr, "%s: %s (no permission)\n", _nc_progname, tried); + ExitProgram(EXIT_FAILURE); + } +} + +static void +add_digit(int *target, int source) +{ + *target = (*target * 10) + (source - '0'); +} + int main(int argc, char *argv[]) { char my_tmpname[PATH_MAX]; - int v_opt = -1, debug_level; + char my_altfile[PATH_MAX]; + int v_opt = -1; int smart_defaults = TRUE; char *termcap; ENTRY *qp; @@ -430,33 +693,38 @@ main(int argc, char *argv[]) int sortmode = S_TERMINFO; /* sort_mode */ int width = 60; + int height = 65535; bool formatted = FALSE; /* reformat complex strings? */ + bool literal = FALSE; /* suppress post-processing? */ int numbers = 0; /* format "%'char'" to/from "%{number}" */ - bool infodump = FALSE; /* running as captoinfo? */ - bool capdump = FALSE; /* running as infotocap? */ bool forceresolve = FALSE; /* force resolution */ bool limited = TRUE; char *tversion = (char *) NULL; const char *source_file = "terminfo"; - const char **namelst = 0; char *outdir = (char *) NULL; bool check_only = FALSE; + bool suppress_untranslatable = FALSE; + int quickdump = 0; + bool quiet = FALSE; + bool wrap_strings = FALSE; log_fp = stderr; - _nc_progname = _nc_basename(argv[0]); + _nc_progname = _nc_rootname(argv[0]); + atexit(cleanup); - if ((infodump = (strcmp(_nc_progname, PROG_CAPTOINFO) == 0)) != FALSE) { + if ((infodump = same_program(_nc_progname, PROG_CAPTOINFO)) != FALSE) { outform = F_TERMINFO; sortmode = S_TERMINFO; } - if ((capdump = (strcmp(_nc_progname, PROG_INFOTOCAP) == 0)) != FALSE) { + if ((capdump = same_program(_nc_progname, PROG_INFOTOCAP)) != FALSE) { outform = F_TERMCAP; sortmode = S_TERMCAP; } #if NCURSES_XNAMES use_extended_names(FALSE); #endif + _nc_strict_bsd = 0; /* * Processing arguments is a little complicated, since someone made a @@ -464,29 +732,53 @@ main(int argc, char *argv[]) * be optional. */ while ((this_opt = getopt(argc, argv, - "0123456789CILNR:TVace:fGgo:rsvwx")) != EOF) { + "0123456789CDIKLNQR:TUVWace:fGgo:qrstvwx")) != -1) { if (isdigit(this_opt)) { switch (last_opt) { + case 'Q': + add_digit(&quickdump, this_opt); + break; case 'v': - v_opt = (v_opt * 10) + (this_opt - '0'); + add_digit(&v_opt, this_opt); break; case 'w': - width = (width * 10) + (this_opt - '0'); + add_digit(&width, this_opt); break; default: - if (this_opt != '1') + switch (this_opt) { + case '0': + last_opt = this_opt; + width = 65535; + height = 1; + break; + case '1': + last_opt = this_opt; + width = 0; + break; + default: usage(); - last_opt = this_opt; - width = 0; + } } continue; } switch (this_opt) { + case 'K': + _nc_strict_bsd = 1; + /* the initial version of -K in 20110730 fell-thru here, but the + * same flag is useful when reading sources -TD + */ + break; case 'C': capdump = TRUE; outform = F_TERMCAP; sortmode = S_TERMCAP; break; + case 'D': + debug_level = VtoTrace(v_opt); + set_trace_level(debug_level); + show_databases(outdir); + ExitProgram(EXIT_SUCCESS); + break; case 'I': infodump = TRUE; outform = F_TERMINFO; @@ -499,6 +791,10 @@ main(int argc, char *argv[]) break; case 'N': smart_defaults = FALSE; + literal = TRUE; + break; + case 'Q': + quickdump = 0; break; case 'R': tversion = optarg; @@ -506,9 +802,15 @@ main(int argc, char *argv[]) case 'T': limited = FALSE; break; + case 'U': + literal = TRUE; + break; case 'V': puts(curses_version()); - return EXIT_SUCCESS; + ExitProgram(EXIT_SUCCESS); + case 'W': + wrap_strings = TRUE; + break; case 'c': check_only = TRUE; break; @@ -527,6 +829,9 @@ main(int argc, char *argv[]) case 'o': outdir = optarg; break; + case 'q': + quiet = TRUE; + break; case 'r': forceresolve = TRUE; break; @@ -540,11 +845,16 @@ main(int argc, char *argv[]) width = 0; break; #if NCURSES_XNAMES + case 't': + _nc_disable_period = FALSE; + suppress_untranslatable = TRUE; + break; case 'a': _nc_disable_period = TRUE; /* FALLTHRU */ case 'x': use_extended_names(TRUE); + using_extensions = TRUE; break; #endif default: @@ -553,12 +863,12 @@ main(int argc, char *argv[]) last_opt = this_opt; } - debug_level = (v_opt > 0) ? v_opt : (v_opt == 0); + debug_level = VtoTrace(v_opt); set_trace_level(debug_level); if (_nc_tracing) { - save_check_termtype = _nc_check_termtype; - _nc_check_termtype = check_termtype; + save_check_termtype = _nc_check_termtype2; + _nc_check_termtype2 = check_termtype; } #if !HAVE_BIG_CORE /* @@ -573,9 +883,9 @@ main(int argc, char *argv[]) */ if (namelst && (!infodump && !capdump)) { (void) fprintf(stderr, - "Sorry, -e can't be used without -I or -C\n"); - cleanup(); - return EXIT_FAILURE; + "%s: Sorry, -e can't be used without -I or -C\n", + _nc_progname); + ExitProgram(EXIT_FAILURE); } #endif /* HAVE_BIG_CORE */ @@ -587,7 +897,7 @@ main(int argc, char *argv[]) _nc_progname, _nc_progname, usage_string); - return EXIT_FAILURE; + ExitProgram(EXIT_FAILURE); } } else { if (infodump == TRUE) { @@ -598,16 +908,16 @@ main(int argc, char *argv[]) if (access(termcap, F_OK) == 0) { /* file exists */ source_file = termcap; - } else if ((tmp_fp = open_tempfile(strcpy(my_tmpname, - "/tmp/XXXXXX"))) - != 0) { - source_file = my_tmpname; - fprintf(tmp_fp, "%s\n", termcap); - fclose(tmp_fp); - tmp_fp = open_input(source_file); - to_remove = source_file; } else { - failed("tmpnam"); + 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, (char *) 0); + to_remove = source_file; + } else { + failed("tmpnam"); + } } } } else { @@ -617,24 +927,32 @@ main(int argc, char *argv[]) _nc_progname, _nc_progname, usage_string); - cleanup(); - return EXIT_FAILURE; + 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 || check_only) { dump_init(tversion, - smart_defaults - ? outform - : F_LITERAL, - sortmode, width, debug_level, formatted); - else if (capdump) + (smart_defaults + ? outform + : F_LITERAL), + sortmode, + wrap_strings, width, height, + debug_level, formatted || check_only, check_only, quickdump); + } else if (capdump) { dump_init(tversion, outform, - sortmode, width, debug_level, FALSE); + sortmode, + wrap_strings, width, height, + debug_level, FALSE, FALSE, FALSE); + } /* parse entries out of the source file */ _nc_set_source(source_file); @@ -643,26 +961,28 @@ main(int argc, char *argv[]) _nc_set_writedir(outdir); #endif /* HAVE_BIG_CORE */ _nc_read_entry_source(tmp_fp, (char *) NULL, - !smart_defaults, FALSE, - (check_only || infodump || capdump) ? NULLHOOK : immedhook); + !smart_defaults || literal, FALSE, + ((check_only || infodump || capdump) + ? NULLHOOK + : immedhook)); /* do use resolution */ if (check_only || (!infodump && !capdump) || forceresolve) { - if (!_nc_resolve_uses(TRUE) && !check_only) { - cleanup(); - return EXIT_FAILURE; + if (!_nc_resolve_uses2(TRUE, literal) && !check_only) { + 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, TRUE, infodump, numbers); + int len = fmt_entry(&qp->tterm, NULL, FALSE, TRUE, infodump, numbers); if (len > (infodump ? MAX_TERMINFO_LENGTH : MAX_TERMCAP_LENGTH)) (void) fprintf(stderr, - "warning: resolved %s entry is %d bytes long\n", + "%s: resolved %s entry is %d bytes long\n", + _nc_progname, _nc_first_name(qp->tterm.term_names), len); } @@ -670,7 +990,21 @@ main(int argc, char *argv[]) } /* write or dump all entries */ - if (!check_only) { + if (check_only) { + /* this is in case infotocap() generates warnings */ + _nc_curr_col = _nc_curr_line = -1; + + for_entry_list(qp) { + if (matches(namelst, qp->tterm.term_names)) { + /* this is in case infotocap() generates warnings */ + _nc_set_type(_nc_first_name(qp->tterm.term_names)); + _nc_curr_line = (int) qp->startline; + repair_acsc(&qp->tterm); + dump_entry(&qp->tterm, suppress_untranslatable, + limited, numbers, NULL); + } + } + } else { if (!infodump && !capdump) { _nc_set_writedir(outdir); for_entry_list(qp) { @@ -683,29 +1017,37 @@ main(int argc, char *argv[]) for_entry_list(qp) { if (matches(namelst, qp->tterm.term_names)) { - int j = qp->cend - qp->cstart; + long j = qp->cend - qp->cstart; int len = 0; /* this is in case infotocap() generates warnings */ _nc_set_type(_nc_first_name(qp->tterm.term_names)); - (void) fseek(tmp_fp, qp->cstart, SEEK_SET); - while (j--) { - if (infodump) - (void) putchar(fgetc(tmp_fp)); - else - put_translate(fgetc(tmp_fp)); + if (!quiet) { + (void) fseek(tmp_fp, qp->cstart, SEEK_SET); + while (j-- > 0) { + int ch = fgetc(tmp_fp); + if (ch == EOF || ferror(tmp_fp)) { + break; + } else if (infodump) { + (void) putchar(ch); + } else { + put_translate(ch); + } + } } - len = dump_entry(&qp->tterm, limited, numbers, NULL); - for (j = 0; j < qp->nuses; j++) - len += dump_uses(qp->uses[j].name, !capdump); - (void) putchar('\n'); + repair_acsc(&qp->tterm); + dump_entry(&qp->tterm, suppress_untranslatable, + limited, numbers, NULL); + for (j = 0; j < (long) qp->nuses; j++) + dump_uses(qp->uses[j].name, !capdump); + len = show_entry(); if (debug_level != 0 && !limited) printf("# length=%d\n", len); } } - if (!namelst) { + if (!namelst && _nc_tail && !quiet) { int c, oldc = '\0'; bool in_comment = FALSE; bool trailing_comment = FALSE; @@ -742,8 +1084,7 @@ main(int argc, char *argv[]) else fprintf(log_fp, "No entries written\n"); } - cleanup(); - return (EXIT_SUCCESS); + ExitProgram(EXIT_SUCCESS); } /* @@ -751,268 +1092,1875 @@ main(int argc, char *argv[]) * references to locations in the arrays Booleans, Numbers, and Strings --- * precisely what's needed (see comp_parse.c). */ - -TERMINAL *cur_term; /* tweak to avoid linking lib_cur_term.c */ - #undef CUR #define CUR tp-> /* - * Returns the expected number of parameters for the given capability. + * Check if the alternate character-set capabilities are consistent. */ -static int -expected_params(char *name) +static void +check_acs(TERMTYPE2 *tp) { - /* *INDENT-OFF* */ - static const struct { - const char *name; - int count; - } table[] = { - { "birep", 2 }, - { "chr", 1 }, - { "colornm", 1 }, - { "cpi", 1 }, - { "csnm", 1 }, - { "csr", 2 }, - { "cub", 1 }, - { "cud", 1 }, - { "cuf", 1 }, - { "cup", 2 }, - { "cuu", 1 }, - { "cvr", 1 }, - { "cwin", 5 }, - { "dch", 1 }, - { "defc", 3 }, - { "dial", 1 }, - { "dispc", 1 }, - { "dl", 1 }, - { "ech", 1 }, - { "getm", 1 }, - { "hpa", 1 }, - { "ich", 1 }, - { "il", 1 }, - { "indn", 1 }, - { "initc", 4 }, - { "initp", 7 }, - { "lpi", 1 }, - { "mc5p", 1 }, - { "mrcup", 2 }, - { "mvpa", 1 }, - { "pfkey", 2 }, - { "pfloc", 2 }, - { "pfx", 2 }, - { "pfxl", 3 }, - { "pln", 2 }, - { "qdial", 1 }, - { "rcsd", 1 }, - { "rep", 2 }, - { "rin", 1 }, - { "sclk", 3 }, - { "scp", 1 }, - { "scs", 1 }, - { "scsd", 2 }, - { "setab", 1 }, - { "setaf", 1 }, - { "setb", 1 }, - { "setcolor", 1 }, - { "setf", 1 }, - { "sgr", 9 }, - { "sgr1", 6 }, - { "slength", 1 }, - { "slines", 1 }, - { "smgbp", 2 }, - { "smglp", 2 }, - { "smglr", 2 }, - { "smgrp", 1 }, - { "smgtb", 2 }, - { "smgtp", 1 }, - { "tsl", 1 }, - { "u6", -1 }, - { "vpa", 1 }, - { "wind", 4 }, - { "wingo", 1 }, - }; - /* *INDENT-ON* */ + int vt100_smacs = 0; + int vt100_rmacs = 0; + int vt100_enacs = 0; - unsigned n; - int result = 0; /* function-keys, etc., use none */ + /* + * 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); - for (n = 0; n < SIZEOF(table); n++) { - if (!strcmp(name, table[n].name)) { - result = table[n].count; - break; + /* + * 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]; + char missing[256]; + const char *p; + char *q; + + memset(mapped, 0, sizeof(mapped)); + for (p = acs_chars; *p != '\0'; p += 2) { + if (p[1] == '\0') { + _nc_warning("acsc has odd number of characters"); + break; + } + mapped[UChar(p[0])] = p[1]; + } + + if (mapped[UChar('I')] && !mapped[UChar('i')]) { + _nc_warning("acsc refers to 'I', which is probably an error"); + } + + for (p = boxes, q = missing; *p != '\0'; ++p) { + if (!mapped[UChar(p[0])]) { + *q++ = p[0]; + } + } + *q = '\0'; + + assert(strlen(missing) <= strlen(boxes)); + if (*missing != '\0' && strcmp(missing, boxes)) { + _nc_warning("acsc is missing some line-drawing mapping: %s", missing); } } +} +static char * +safe_strdup(const char *value) +{ + if (value == NULL) + value = ""; + return strdup(value); +} + +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 = safe_strdup(TIPARM_1(oldcap, n)); + char *newvalue = safe_strdup(TIPARM_1(newcap, n)); + same += !strcmp(oldvalue, newvalue); + free(oldvalue); + free(newvalue); + } + result = (same == limit); + } 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. + * Check if the color capabilities are consistent */ static void -check_params(TERMTYPE * tp, char *name, char *value) +check_colors(TERMTYPE2 *tp) { - int expected = expected_params(name); - int actual = 0; - int n; - bool params[10]; - char *s = value; + char *value; - for (n = 0; n < 10; n++) - params[n] = FALSE; + if ((max_colors > 0) != (max_pairs > 0) + || ((max_colors > max_pairs) && (initialize_pair == 0))) + _nc_warning("inconsistent values for max_colors (%d) and max_pairs (%d)", + max_colors, max_pairs); - while (*s != 0) { - if (*s == '%') { - if (*++s == '\0') { - _nc_warning("expected character after %% in %s", name); - break; - } else if (*s == 'p') { - if (*++s == '\0' || !isdigit((int) *s)) { - _nc_warning("expected digit after %%p in %s", name); - return; - } else { - n = (*s - '0'); - if (n > actual) - actual = n; - params[n] = TRUE; - } - } + PAIRED(set_foreground, set_background); + PAIRED(set_a_foreground, set_a_background); + PAIRED(set_color_pair, initialize_pair); + + if (VALID_STRING(set_foreground) + && 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"); } - s++; } - if (params[0]) { - _nc_warning("%s refers to parameter 0 (%%p0), which is not allowed", name); + if (VALID_STRING(set_background) + && 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"); + } } - if (value == set_attributes || expected < 0) { - ; - } else if (expected != actual) { - _nc_warning("%s uses %d parameters, expected %d", name, - actual, expected); - for (n = 1; n < actual; n++) { - if (!params[n]) - _nc_warning("%s omits parameter %d", name, n); + + /* see: has_colors() */ + if (VALID_NUMERIC(max_colors) && VALID_NUMERIC(max_pairs) + && ((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"); + } + 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"); + } + } + value = tigetstr("RGB"); + if (VALID_STRING(value)) { + int r, g, b; + char bad; + int code = sscanf(value, "%d/%d/%d%c", &r, &g, &b, &bad); + if (code != 3 || r <= 0 || g <= 0 || b <= 0) { + _nc_warning("unexpected value for RGB capability: %s", value); } } } -/* - * An sgr string may contain several settings other than the one we're - * interested in, essentially sgr0 + rmacs + whatever. As long as the - * "whatever" is contained in the sgr string, that is close enough for our - * sanity check. - */ -static bool -similar_sgr(char *a, char *b) +static int +csi_length(const char *value) { - while (*b != 0) { - while (*a != *b) { - if (*a == 0) - return FALSE; - a++; - } - a++; - b++; + int result = 0; + + if (value[0] == '\033' && value[1] == '[') { + result = 2; + } else if (UChar(value[0]) == 0x9a) { + result = 1; } - return TRUE; + return result; } -static void -check_sgr(TERMTYPE * tp, char *zero, int num, char *cap, const char *name) +static char +keypad_final(const char *string) { - char *test = tparm(set_attributes, - num == 1, - num == 2, - num == 3, - num == 4, - num == 5, - num == 6, - num == 7, - num == 8, - num == 9); - if (test != 0) { - if (PRESENT(cap)) { - if (!similar_sgr(test, cap)) { - _nc_warning("%s differs from sgr(%d): %s", name, num, - _nc_visbuf(test)); - } - } else if (strcmp(test, zero)) { - _nc_warning("sgr(%d) present, but not %s", num, name); - } - } else if (PRESENT(cap)) { - _nc_warning("sgr(%d) missing, but %s present", num, name); + char result = '\0'; + + if (VALID_STRING(string) + && *string++ == '\033' + && *string++ == 'O' + && strlen(string) == 1) { + result = *string; } + + return result; } -#define CHECK_SGR(num,name) check_sgr(tp, zero, num, name, #name) +static long +keypad_index(const char *string) +{ + char *test; + const char *list = "PQRSwxymtuvlqrsPpn"; /* app-keypad except "Enter" */ + int ch; + long result = -1; -/* other sanity-checks (things that we don't want in the normal - * logic that reads a terminfo entry) + if ((ch = keypad_final(string)) != '\0') { + test = (strchr) (list, ch); + if (test != 0) + result = (long) (test - list); + } + return result; +} + +/* + * list[] is down, up, left, right + * "left" may be ^H rather than \E[D + * "down" may be ^J rather than \E[B + * But up/right are generally consistently escape sequences for ANSI terminals. */ static void -check_termtype(TERMTYPE * tp) +check_ansi_cursor(char *list[4]) { - 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). - */ - memset(fkeys, 0, sizeof(fkeys)); - for (j = 0; _nc_tinfo_fkeys[j].code; j++) { - char *a = tp->Strings[_nc_tinfo_fkeys[j].offset]; - 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]) - continue; - if (!strcmp(a, b)) { - fkeys[j] = 1; - fkeys[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(_nc_tinfo_fkeys[j].code), - keyname(_nc_tinfo_fkeys[k].code)); - first = FALSE; - } else { - fprintf(stderr, ", %s", - keyname(_nc_tinfo_fkeys[k].code)); - } + int j, k; + int want; + size_t suffix; + bool skip[4]; + bool repeated = FALSE; + + for (j = 0; j < 4; ++j) { + skip[j] = FALSE; + for (k = 0; k < j; ++k) { + if (j != k + && !strcmp(list[j], list[k])) { + char *value = _nc_tic_expand(list[k], TRUE, 0); + _nc_warning("repeated cursor control %s\n", value); + repeated = TRUE; } } - if (!first) - fprintf(stderr, "\n"); } - - for (j = 0; j < NUM_STRINGS(tp); j++) { + if (!repeated) { + char *up = list[1]; + size_t prefix = (size_t) csi_length(up); + + if (prefix) { + suffix = prefix; + while (up[suffix] && isdigit(UChar(up[suffix]))) + ++suffix; + } + if (prefix && up[suffix] == 'A') { + skip[1] = TRUE; + if (!strcmp(list[0], "\n")) + skip[0] = TRUE; + if (!strcmp(list[2], "\b")) + skip[2] = TRUE; + + for (j = 0; j < 4; ++j) { + if (skip[j] || strlen(list[j]) == 1) + continue; + if (memcmp(list[j], up, prefix)) { + char *value = _nc_tic_expand(list[j], TRUE, 0); + _nc_warning("inconsistent prefix for %s\n", value); + continue; + } + if (strlen(list[j]) < suffix) { + char *value = _nc_tic_expand(list[j], TRUE, 0); + _nc_warning("inconsistent length for %s, expected %d\n", + value, (int) suffix + 1); + continue; + } + want = "BADC"[j]; + if (list[j][suffix] != want) { + char *value = _nc_tic_expand(list[j], TRUE, 0); + _nc_warning("inconsistent suffix for %s, expected %c, have %c\n", + value, want, list[j][suffix]); + } + } + } + } +} + +#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(TERMTYPE2 *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(TERMTYPE2 *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. + * Technically this is not true (we could use cursor_address to fill in + * unsupported controls), but it is likely. + */ + count = 0; + if (PRESENT(parm_down_cursor)) { + list[count++] = parm_down_cursor; + } + if (PRESENT(parm_up_cursor)) { + list[count++] = parm_up_cursor; + } + if (PRESENT(parm_left_cursor)) { + list[count++] = parm_left_cursor; + } + if (PRESENT(parm_right_cursor)) { + list[count++] = parm_right_cursor; + } + if (count == 4) { + check_ansi_cursor(list); + } else if (count != 0) { + EXPECTED(parm_down_cursor); + EXPECTED(parm_up_cursor); + EXPECTED(parm_left_cursor); + EXPECTED(parm_right_cursor); + } + + count = 0; + if (PRESENT(cursor_down)) { + list[count++] = cursor_down; + } + if (PRESENT(cursor_up)) { + list[count++] = cursor_up; + } + if (PRESENT(cursor_left)) { + list[count++] = cursor_left; + } + if (PRESENT(cursor_right)) { + list[count++] = cursor_right; + } + if (count == 4) { + check_ansi_cursor(list); + } else if (count != 0) { + count = 0; + if (PRESENT(cursor_down) && strcmp(cursor_down, "\n")) + ++count; + if (PRESENT(cursor_left) && strcmp(cursor_left, "\b")) + ++count; + if (PRESENT(cursor_up) && strlen(cursor_up) > 1) + ++count; + if (PRESENT(cursor_right) && strlen(cursor_right) > 1) + ++count; + if (count) { + EXPECTED(cursor_down); + EXPECTED(cursor_up); + EXPECTED(cursor_left); + EXPECTED(cursor_right); + } + } +} + +#define MAX_KP 5 +/* + * Do a quick sanity-check for vt100-style keypads to see if the 5-key keypad + * is mapped inconsistently. + */ +static void +check_keypad(TERMTYPE2 *tp) +{ + char show[80]; + + if (VALID_STRING(key_a1) && + VALID_STRING(key_a3) && + VALID_STRING(key_b2) && + VALID_STRING(key_c1) && + VALID_STRING(key_c3)) { + char final[MAX_KP + 1]; + long list[MAX_KP]; + int increase = 0; + int j, k, kk; + long last; + long test; + + final[0] = keypad_final(key_a1); + final[1] = keypad_final(key_a3); + final[2] = keypad_final(key_b2); + final[3] = keypad_final(key_c1); + final[4] = keypad_final(key_c3); + final[5] = '\0'; + + /* special case: legacy coding using 1,2,3,0,. on the bottom */ + assert(strlen(final) <= MAX_KP); + if (!strcmp(final, "qsrpn")) + return; + + list[0] = keypad_index(key_a1); + list[1] = keypad_index(key_a3); + list[2] = keypad_index(key_b2); + list[3] = keypad_index(key_c1); + list[4] = keypad_index(key_c3); + + /* check that they're all vt100 keys */ + for (j = 0; j < MAX_KP; ++j) { + if (list[j] < 0) { + return; + } + } + + /* check if they're all in increasing order */ + for (j = 1; j < MAX_KP; ++j) { + if (list[j] > list[j - 1]) { + ++increase; + } + } + if (increase != (MAX_KP - 1)) { + show[0] = '\0'; + + for (j = 0, last = -1; j < MAX_KP; ++j) { + for (k = 0, kk = -1, test = 100; k < 5; ++k) { + if (list[k] > last && + list[k] < test) { + test = list[k]; + kk = k; + } + } + last = test; + assert(strlen(show) < (MAX_KP * 4)); + switch (kk) { + case 0: + _nc_STRCAT(show, " ka1", sizeof(show)); + break; + case 1: + _nc_STRCAT(show, " ka3", sizeof(show)); + break; + case 2: + _nc_STRCAT(show, " kb2", sizeof(show)); + break; + case 3: + _nc_STRCAT(show, " kc1", sizeof(show)); + break; + case 4: + _nc_STRCAT(show, " kc3", sizeof(show)); + break; + } + } + + _nc_warning("vt100 keypad order inconsistent: %s", show); + } + + } else if (VALID_STRING(key_a1) || + VALID_STRING(key_a3) || + VALID_STRING(key_b2) || + VALID_STRING(key_c1) || + VALID_STRING(key_c3)) { + show[0] = '\0'; + if (keypad_index(key_a1) >= 0) + _nc_STRCAT(show, " ka1", sizeof(show)); + if (keypad_index(key_a3) >= 0) + _nc_STRCAT(show, " ka3", sizeof(show)); + if (keypad_index(key_b2) >= 0) + _nc_STRCAT(show, " kb2", sizeof(show)); + if (keypad_index(key_c1) >= 0) + _nc_STRCAT(show, " kc1", sizeof(show)); + if (keypad_index(key_c3) >= 0) + _nc_STRCAT(show, " kc3", sizeof(show)); + 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 +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 +} + +#if NCURSES_XNAMES +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(TERMTYPE2 *tp) +{ + 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); + bool is_screen = !strncmp(name, "screen", 6); + bool screen_base = (is_screen + && strchr(name, '.') == 0); + + 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 && screen_base) { + _nc_warning("screen's \"screen\" entries should not have XT set"); + } else if (have_XT) { + if (!have_kmouse && is_screen) { + 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 + && !screen_base && strchr(name, '+') == 0) { + _nc_warning("expected XT to be set, given kmous"); + } + } + } +} +#else +#define check_screen(tp) /* nothing */ +#endif + +/* + * Returns the expected number of parameters for the given capability. + */ +static int +expected_params(const char *name) +{ +#define DATA(name,count) { { name }, count } + /* *INDENT-OFF* */ + static const struct { + const char name[9]; + int count; + } table[] = { + DATA( "S0", 1 ), /* 'screen' extension */ + DATA( "birep", 2 ), + DATA( "chr", 1 ), + DATA( "colornm", 1 ), + DATA( "cpi", 1 ), + DATA( "csnm", 1 ), + DATA( "csr", 2 ), + DATA( "cub", 1 ), + DATA( "cud", 1 ), + DATA( "cuf", 1 ), + DATA( "cup", 2 ), + DATA( "cuu", 1 ), + DATA( "cvr", 1 ), + DATA( "cwin", 5 ), + DATA( "dch", 1 ), + DATA( "defc", 3 ), + DATA( "dial", 1 ), + DATA( "dispc", 1 ), + DATA( "dl", 1 ), + DATA( "ech", 1 ), + DATA( "getm", 1 ), + DATA( "hpa", 1 ), + DATA( "ich", 1 ), + DATA( "il", 1 ), + DATA( "indn", 1 ), + DATA( "initc", 4 ), + DATA( "initp", 7 ), + DATA( "lpi", 1 ), + DATA( "mc5p", 1 ), + DATA( "mrcup", 2 ), + DATA( "mvpa", 1 ), + DATA( "pfkey", 2 ), + DATA( "pfloc", 2 ), + DATA( "pfx", 2 ), + DATA( "pfxl", 3 ), + DATA( "pln", 2 ), + DATA( "qdial", 1 ), + DATA( "rcsd", 1 ), + DATA( "rep", 2 ), + DATA( "rin", 1 ), + DATA( "sclk", 3 ), + DATA( "scp", 1 ), + DATA( "scs", 1 ), + DATA( "scsd", 2 ), + DATA( "setab", 1 ), + DATA( "setaf", 1 ), + DATA( "setb", 1 ), + DATA( "setcolor", 1 ), + DATA( "setf", 1 ), + DATA( "sgr", 9 ), + DATA( "sgr1", 6 ), + DATA( "slength", 1 ), + DATA( "slines", 1 ), + DATA( "smgbp", 1 ), /* 2 if smgtp is not given */ + DATA( "smglp", 1 ), + DATA( "smglr", 2 ), + DATA( "smgrp", 1 ), + DATA( "smgtb", 2 ), + DATA( "smgtp", 1 ), + DATA( "tsl", 1 ), + DATA( "u6", -1 ), + DATA( "vpa", 1 ), + DATA( "wind", 4 ), + DATA( "wingo", 1 ), + }; + /* *INDENT-ON* */ +#undef DATA + + unsigned n; + int result = 0; /* function-keys, etc., use none */ + + for (n = 0; n < SIZEOF(table); n++) { + if (!strcmp(name, table[n].name)) { + result = table[n].count; + break; + } + } + + return result; +} + +/* + * Check for user-capabilities that happen to be used in ncurses' terminal + * database. + */ +#if NCURSES_XNAMES +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; +} +#endif + +/* + * 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; + } +#if NCURSES_XNAMES + else if (using_extensions) { + struct user_table_entry const *p = lookup_user_capability(name); + if (p != 0) { + result = (int) p->ute_argc; + } + } +#endif + 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, int extended) +{ + int expected = expected_params(name); + int actual = 0; + int n; + bool params[1 + NUM_PARM]; + char *s = value; + +#ifdef set_top_margin_parm + if (!strcmp(name, "smgbp") + && set_top_margin_parm == 0) + expected = 2; +#endif + + for (n = 0; n <= NUM_PARM; n++) + params[n] = FALSE; + + while (*s != 0) { + if (*s == '%') { + if (*++s == '\0') { + _nc_warning("expected character after %% in %s", name); + break; + } else if (*s == 'p') { + if (*++s == '\0' || !isdigit((int) *s)) { + _nc_warning("expected digit after %%p in %s", name); + return; + } else { + n = (*s - '0'); + if (n > actual) + actual = n; + params[n] = TRUE; + } + } + } + s++; + } + +#if NCURSES_XNAMES + if (extended) { + int check = is_user_capability(name); + if (check != actual && (check >= 0 && actual >= 0)) { + _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; + } +#else + (void) extended; +#endif + + if (params[0]) { + _nc_warning("%s refers to parameter 0 (%%p0), which is not allowed", name); + } + if (value == set_attributes || expected < 0) { + ; + } else if (expected != actual) { + _nc_warning("%s uses %d parameters, expected %d", name, + actual, expected); + for (n = 1; n < actual; n++) { + if (!params[n]) + _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) { +#if NCURSES_XNAMES + 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 +#endif + { + _nc_warning("tparm analyzed %d parameters for %s, expected %d", + analyzed, name, actual); + } + } + } +} + +static bool +line_capability(const char *name) +{ + bool result = FALSE; + static const char *table[] = + { + "csr", /* change_scroll_region */ + "clear", /* clear_screen */ + "ed", /* clr_eos */ + "cwin", /* create_window */ + "cup", /* cursor_address */ + "cud1", /* cursor_down */ + "home", /* cursor_home */ + "mrcup", /* cursor_mem_address */ + "ll", /* cursor_to_ll */ + "cuu1", /* cursor_up */ + "dl1", /* delete_line */ + "hd", /* down_half_line */ + "flash", /* flash_screen */ + "ff", /* form_feed */ + "il1", /* insert_line */ + "nel", /* newline */ + "dl", /* parm_delete_line */ + "cud", /* parm_down_cursor */ + "indn", /* parm_index */ + "il", /* parm_insert_line */ + "rin", /* parm_rindex */ + "cuu", /* parm_up_cursor */ + "mc0", /* print_screen */ + "vpa", /* row_address */ + "ind", /* scroll_forward */ + "ri", /* scroll_reverse */ + "hu", /* up_half_line */ + }; + size_t n; + for (n = 0; n < SIZEOF(table); ++n) { + if (!strcmp(name, table[n])) { + result = TRUE; + break; + } + } + return result; +} + +/* + * Check for DEC VT100 private mode for reverse video. + */ +static const char * +skip_DECSCNM(const char *value, int *flag) +{ + *flag = -1; + if (value != 0) { + int skip = csi_length(value); + if (skip > 0 && + value[skip++] == '?' && + value[skip++] == '5') { + if (value[skip] == 'h') { + *flag = 1; + } else if (value[skip] == 'l') { + *flag = 0; + } + value += skip + 1; + } + } + return value; +} + +static void +check_delays(TERMTYPE2 *tp, const char *name, const char *value) +{ + const char *p, *q; + const char *first = 0; + const char *last = 0; + + for (p = value; *p != '\0'; ++p) { + if (p[0] == '$' && p[1] == '<') { + const char *base = p + 2; + const char *mark = 0; + bool maybe = TRUE; + bool mixed = FALSE; + int proportional = 0; + int mandatory = 0; + + first = p; + + for (q = base; *q != '\0'; ++q) { + if (*q == '>') { + if (mark == 0) + mark = q; + break; + } else if (*q == '*' || *q == '/') { + if (*q == '*') + ++proportional; + if (*q == '/') + ++mandatory; + if (mark == 0) + mark = q; + } else if (!(isalnum(UChar(*q)) || strchr("+-.", *q) != 0)) { + maybe = FALSE; + break; + } else if (proportional || mandatory) { + mixed = TRUE; + } + } + last = *q ? (q + 1) : q; + if (*q == '\0') { + maybe = FALSE; /* just an isolated "$<" */ + } else if (maybe) { + float check_f; + char check_c; + int rc = sscanf(base, "%f%c", &check_f, &check_c); + if ((rc != 2) || (check_c != *mark) || mixed) { + _nc_warning("syntax error in %s delay '%.*s'", name, + (int) (q - base), base); + } else if (*name == 'k') { + _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 */ + } + } + } + + if (!strcmp(name, "flash") || + !strcmp(name, "beep")) { + + if (first != 0) { + if (first == value || *last == 0) { + /* + * Delay is on one end or the other. + */ + _nc_warning("expected delay embedded within %s", name); + } + } else { + int flag; + + /* + * Check for missing delay when using VT100 reverse-video. + * A real VT100 might not need this, but terminal emulators do. + */ + if ((p = skip_DECSCNM(value, &flag)) != 0 && + flag > 0 && + (q = skip_DECSCNM(p, &flag)) != 0 && + flag == 0) { + _nc_warning("expected a delay in %s", name); + } + } + } +} + +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; + _nc_SPRINTF(next, + _nc_SLIMIT(sizeof(blob) - (size_t) (next - blob)) + "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: +#define myParam(n) numbers[n] + result = TIPARM_9(value, + myParam(1), + myParam(2), + myParam(3), + myParam(4), + myParam(5), + myParam(6), + myParam(7), + myParam(8), + myParam(9)); +#undef myParam + break; + 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)); +#undef myParam + break; + } + return strdup(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(TERMTYPE2 *tp, int i, const char *value) +{ + const char *name = ExtStrname(tp, i, strnames); + int params = ((i < (int) SIZEOF(parametrized)) + ? parametrized[i] + : ((*value == 'k') + ? 0 + : has_params(value))); + int to_char = 0; + char *ti_value; + char *tc_value; + bool embedded; + + assert(SIZEOF(parametrized) == STRCOUNT); + 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")) { + if ((limit = max_colors) > 16) + limit = 16; + } + 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); + } + free(ti_check); + free(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) +{ + while (*s == '/' || isdigit(UChar(*s))) + ++s; + return s; +} + +/* + * Skip a delay altogether, e.g., when comparing a simple string to sgr, + * the latter may have a worst-case delay on the end. + */ +static char * +ignore_delays(char *s) +{ + int delaying = 0; + + do { + switch (*s) { + case '$': + if (delaying == 0) + delaying = 1; + break; + case '<': + if (delaying == 1) + delaying = 2; + break; + case '\0': + delaying = 0; + break; + default: + if (delaying) { + s = skip_delay(s); + if (*s == '>') + ++s; + delaying = 0; + } + break; + } + if (delaying) + ++s; + } while (delaying); + return s; +} + +#define DATA(name) { #name } +static const char sgr_names[][11] = +{ + DATA(none), + DATA(standout), + DATA(underline), + DATA(reverse), + DATA(blink), + DATA(dim), + DATA(bold), + DATA(invis), + DATA(protect), + DATA(altcharset), + "" +}; +#undef DATA + +/* + * An sgr string may contain several settings other than the one we're + * interested in, essentially sgr0 + rmacs + whatever. As long as the + * "whatever" is contained in the sgr string, that is close enough for our + * sanity check. + */ +static bool +similar_sgr(int num, char *a, char *b) +{ + char *base_a = a; + char *base_b = b; + int delaying = 0; + + while (*b != 0) { + while (*a != *b) { + if (*a == 0) { + if (num < 0) { + ; + } else if (b[0] == '$' + && b[1] == '<') { + _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), + _nc_visbuf2(2, base_b), + _nc_visbuf2(3, b)); + } + return FALSE; + } else if (delaying) { + a = skip_delay(a); + b = skip_delay(b); + } else if ((*b == '0' || (*b == ';')) && *a == 'm') { + b++; + } else { + a++; + } + } + switch (*a) { + case '$': + if (delaying == 0) + delaying = 1; + break; + case '<': + if (delaying == 1) + delaying = 2; + break; + default: + delaying = 0; + break; + } + a++; + b++; + } + /* ignore delays on the end of the string */ + a = ignore_delays(a); + return ((num != 0) || (*a == 0)); +} + +static char * +check_sgr(TERMTYPE2 *tp, char *zero, int num, char *cap, const char *name) +{ + char *test; + + _nc_tparm_err = 0; + test = TIPARM_9(set_attributes, + num == 1, + num == 2, + num == 3, + num == 4, + num == 5, + num == 6, + num == 7, + num == 8, + num == 9); + if (test != 0) { + if (PRESENT(cap)) { + if (!similar_sgr(num, test, cap)) { + _nc_warning("%s differs from sgr(%d)\n\t%s=%s\n\tsgr(%d)=%s", + name, num, + name, _nc_visbuf2(1, cap), + num, _nc_visbuf2(2, test)); + } + } else if (_nc_capcmp(test, zero)) { + _nc_warning("sgr(%d) present, but not %s", num, name); + } + } else if (PRESENT(cap)) { + _nc_warning("sgr(%d) missing, but %s present", num, name); + } + if (_nc_tparm_err) + _nc_warning("stack error in sgr(%d) string", num); + return test; +} + +#define CHECK_SGR(num,name) check_sgr(tp, zero, num, name, #name) + +#ifdef TRACE +/* + * If tic is compiled with TRACE, we'll be able to see the output from the + * DEBUG() macro. But since it doesn't use traceon(), it always goes to + * the standard error. Use this function to make it simpler to follow the + * resulting debug traces. + */ +static void +show_where(unsigned level) +{ + if (_nc_tracing >= DEBUG_LEVEL(level)) { + char my_name[MAX_NAME_SIZE]; + _nc_get_type(my_name); + _tracef("\"%s\", line %d, '%s'", + _nc_get_source(), + _nc_curr_line, my_name); + } +} + +#else +#define show_where(level) /* nothing */ +#endif + +typedef struct { + int keycode; + const char *name; + const char *value; +} NAME_VALUE; + +static NAME_VALUE * +get_fkey_list(TERMTYPE2 *tp) +{ + NAME_VALUE *result = typeMalloc(NAME_VALUE, NUM_STRINGS(tp) + 1); + const struct tinfo_fkeys *all_fkeys = _nc_tinfo_fkeys; + int used = 0; + unsigned 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, (int) 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_conflict(TERMTYPE2 *tp) +{ + bool conflict = FALSE; + unsigned j, k; + + if (!(_nc_syntax == SYN_TERMCAP && capdump)) { + char *check = calloc((size_t) (NUM_STRINGS(tp) + 1), sizeof(char)); + NAME_VALUE *given = get_fkey_list(tp); + + if (check == 0) + 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)"); + conflict = TRUE; + } + fprintf(stderr, "..."); + show_fkey_name(given + j); + fprintf(stderr, " is the same as"); + show_fkey_name(given + k); + first = FALSE; + } else { + fprintf(stderr, ", "); + show_fkey_name(given + k); + } + } + } + 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); + } +} + +/* + * Exiting a video mode should not duplicate sgr0 + */ +static void +check_exit_attribute(const char *name, char *test, char *trimmed, char *untrimmed) +{ + if (VALID_STRING(test) && (trimmed != 0)) { + if (similar_sgr(-1, trimmed, test) || + similar_sgr(-1, untrimmed, test)) { + _nc_warning("%s matches exit_attribute_mode", name); + } + } +} + +/* + * Returns true if the string looks like a standard SGR string. + */ +static bool +is_sgr_string(char *value) +{ + bool result = FALSE; + + if (VALID_STRING(value)) { + int skip = csi_length(value); + + if (skip) { + int ch; + + result = TRUE; + value += skip; + while ((ch = UChar(*value++)) != '\0') { + if (isdigit(ch) || ch == ';') { + ; + } else if (ch == 'm' && *value == '\0') { + ; + } else { + result = FALSE; + break; + } + } + } + } + return result; +} + +/* + * Check if the given capability contains a given SGR attribute. + */ +static void +check_sgr_param(TERMTYPE2 *tp, int code, const char *name, char *value) +{ + if (VALID_STRING(value)) { + int ncv = ((code != 0) ? (1 << (code - 1)) : 0); + char *test = tgoto(value, 0, 0); + if (is_sgr_string(test)) { + int param = 0; + int count = 0; + int skips = 0; + int color = (value == set_a_foreground || + value == set_a_background || + value == set_foreground || + value == set_background); + while (*test != 0) { + if (isdigit(UChar(*test))) { + param = 10 * param + (*test - '0'); + ++count; + } else { + if (count) { + /* + * Avoid unnecessary warning for xterm 256color codes. + */ + if (color && (param == 38 || param == 48)) + skips = 3; + if ((skips-- <= 0) && (param == code)) + break; + } + count = 0; + param = 0; + } + ++test; + } + if (count != 0 && param == code) { + if (code == 0 || + no_color_video < 0 || + !(no_color_video & ncv)) { + _nc_warning("\"%s\" SGR-attribute used in %s", + sgr_names[code], + name); + } + } + } + } +} + +#if NCURSES_XNAMES +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); + } + } +} +#endif + +/* other sanity-checks (things that we don't want in the normal + * logic that reads a terminfo entry) + */ +static void +check_termtype(TERMTYPE2 *tp, bool literal) +{ + unsigned j; + + check_conflict(tp); + + for_each_string(j, tp) { char *a = tp->Strings[j]; - if (VALID_STRING(a)) - check_params(tp, ExtStrname(tp, j, strnames), a); + if (VALID_STRING(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); + check_cursor(tp); + check_keypad(tp); + check_printer(tp); + check_screen(tp); /* - * Quick check for color. We could also check if the ANSI versus - * non-ANSI strings are misused. + * These are probably both or none. */ - if ((max_colors > 0) != (max_pairs > 0) - || (max_colors > max_pairs)) - _nc_warning("inconsistent values for max_colors and max_pairs"); - - PAIRED(set_foreground, set_background); - PAIRED(set_a_foreground, set_a_background); + PAIRED(parm_index, parm_rindex); + PAIRED(parm_ich, parm_dch); /* * These may be mismatched because the terminal description relies on @@ -1022,7 +2970,7 @@ check_termtype(TERMTYPE * tp) ANDMISSING(cursor_visible, cursor_normal); if (PRESENT(cursor_visible) && PRESENT(cursor_normal) - && !strcmp(cursor_visible, cursor_normal)) + && !_nc_capcmp(cursor_visible, cursor_normal)) _nc_warning("cursor_visible is same as cursor_normal"); /* @@ -1033,36 +2981,109 @@ check_termtype(TERMTYPE * tp) ANDMISSING(change_scroll_region, save_cursor); ANDMISSING(change_scroll_region, restore_cursor); + /* + * If we can clear tabs, we should be able to initialize them. + */ + ANDMISSING(clear_all_tabs, set_tab); + if (PRESENT(set_attributes)) { - char *zero = tparm(set_attributes, 0, 0, 0, 0, 0, 0, 0, 0, 0); + char *zero = 0; - zero = strdup(zero); - CHECK_SGR(1, enter_standout_mode); - CHECK_SGR(2, enter_underline_mode); - CHECK_SGR(3, enter_reverse_mode); - CHECK_SGR(4, enter_blink_mode); - CHECK_SGR(5, enter_dim_mode); - CHECK_SGR(6, enter_bold_mode); - CHECK_SGR(7, enter_secure_mode); - CHECK_SGR(8, enter_protected_mode); - CHECK_SGR(9, enter_alt_charset_mode); - free(zero); + _nc_tparm_err = 0; + if (PRESENT(exit_attribute_mode)) { + zero = strdup(CHECK_SGR(0, exit_attribute_mode)); + } else { + zero = strdup(TIPARM_9(set_attributes, 0, 0, 0, 0, 0, 0, 0, 0, 0)); + } + if (_nc_tparm_err) + _nc_warning("stack error in sgr(0) string"); + + if (zero != 0) { + CHECK_SGR(1, enter_standout_mode); + CHECK_SGR(2, enter_underline_mode); + CHECK_SGR(3, enter_reverse_mode); + CHECK_SGR(4, enter_blink_mode); + CHECK_SGR(5, enter_dim_mode); + CHECK_SGR(6, enter_bold_mode); + CHECK_SGR(7, enter_secure_mode); + CHECK_SGR(8, enter_protected_mode); + CHECK_SGR(9, enter_alt_charset_mode); + free(zero); + } else { + _nc_warning("sgr(0) did not return a value"); + } + } else if (PRESENT(exit_attribute_mode) && + set_attributes != CANCELLED_STRING) { + if (_nc_syntax == SYN_TERMINFO) + _nc_warning("missing sgr string"); + } +#define CHECK_SGR0(name) check_exit_attribute(#name, name, check_sgr0, exit_attribute_mode) + if (PRESENT(exit_attribute_mode)) { + char *check_sgr0 = _nc_trim_sgr0(tp); + + if (check_sgr0 == 0 || *check_sgr0 == '\0') { + _nc_warning("trimmed sgr0 is empty"); + } else { + show_where(2); + if (check_sgr0 != exit_attribute_mode) { + DEBUG(2, + ("will trim sgr0\n\toriginal sgr0=%s\n\ttrimmed sgr0=%s", + _nc_visbuf2(1, exit_attribute_mode), + _nc_visbuf2(2, check_sgr0))); + } else { + DEBUG(2, + ("will not trim sgr0\n\toriginal sgr0=%s", + _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) { + free(check_sgr0); + } } +#define CHECK_SGR_PARAM(code, name) check_sgr_param(tp, (int)code, #name, name) + for (j = 0; *sgr_names[j] != '\0'; ++j) { + CHECK_SGR_PARAM(j, set_a_foreground); + CHECK_SGR_PARAM(j, set_a_background); + CHECK_SGR_PARAM(j, set_foreground); + CHECK_SGR_PARAM(j, set_background); + } +#ifdef TRACE + show_where(2); + if (!auto_right_margin) { + DEBUG(2, + ("can write to lower-right directly")); + } else if (PRESENT(enter_am_mode) && PRESENT(exit_am_mode)) { + DEBUG(2, + ("can write to lower-right by suppressing automargin")); + } else if ((PRESENT(enter_insert_mode) && PRESENT(exit_insert_mode)) + || PRESENT(insert_character) || PRESENT(parm_ich)) { + DEBUG(2, + ("can write to lower-right by using inserts")); + } else { + DEBUG(2, + ("cannot write to lower-right")); + } +#endif /* * Some standard applications (e.g., vi) and some non-curses - * applications (e.g., jove) get confused if we have both ich/ich1 and + * applications (e.g., jove) get confused if we have both ich1 and * smir/rmir. Let's be nice and warn about that, too, even though * ncurses handles it. */ if ((PRESENT(enter_insert_mode) || PRESENT(exit_insert_mode)) - && (PRESENT(insert_character) || PRESENT(parm_ich))) { - _nc_warning("non-curses applications may be confused by ich/ich1 with smir/rmir"); + && PRESENT(insert_character)) { + _nc_warning("non-curses applications may be confused by ich1 with smir/rmir"); } /* * Finally, do the non-verbose checks */ if (save_check_termtype != 0) - save_check_termtype(tp); + save_check_termtype(tp, literal); }