version 1.29, 2006/10/10 21:38:16 |
version 1.30, 2010/01/12 23:22:14 |
|
|
/* $OpenBSD$ */ |
/* $OpenBSD$ */ |
|
|
/**************************************************************************** |
/**************************************************************************** |
* Copyright (c) 1998,1999,2000,2001 Free Software Foundation, Inc. * |
* Copyright (c) 1998-2007,2008 Free Software Foundation, Inc. * |
* * |
* * |
* Permission is hereby granted, free of charge, to any person obtaining a * |
* Permission is hereby granted, free of charge, to any person obtaining a * |
* copy of this software and associated documentation files (the * |
* copy of this software and associated documentation files (the * |
|
|
/**************************************************************************** |
/**************************************************************************** |
* Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995 * |
* Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995 * |
* and: Eric S. Raymond <esr@snark.thyrsus.com> * |
* and: Eric S. Raymond <esr@snark.thyrsus.com> * |
|
* and: Thomas E. Dickey 1996 on * |
****************************************************************************/ |
****************************************************************************/ |
|
|
/* |
/* |
|
|
#include <sys/stat.h> |
#include <sys/stat.h> |
|
|
#include <dump_entry.h> |
#include <dump_entry.h> |
#include <term_entry.h> |
|
#include <transform.h> |
#include <transform.h> |
|
|
MODULE_ID("$From: tic.c,v 1.85 2001/02/03 23:31:45 tom Exp $") |
MODULE_ID("$Id$") |
|
|
const char *_nc_progname = "tic"; |
const char *_nc_progname = "tic"; |
|
|
static FILE *log_fp; |
static FILE *log_fp; |
static FILE *tmp_fp; |
static FILE *tmp_fp; |
|
static bool capdump = FALSE; /* running as infotocap? */ |
|
static bool infodump = FALSE; /* running as captoinfo? */ |
static bool showsummary = FALSE; |
static bool showsummary = FALSE; |
static const char *to_remove; |
static const char *to_remove; |
|
|
static void (*save_check_termtype) (TERMTYPE *); |
static void (*save_check_termtype) (TERMTYPE *, bool); |
static void check_termtype(TERMTYPE * tt); |
static void check_termtype(TERMTYPE *tt, bool); |
|
|
static const char usage_string[] = "[-V] [-v[n]] [-e names] [-CILNRTcfrswx1] source-file\n"; |
static const char usage_string[] = "\ |
|
[-e names] \ |
|
[-o dir] \ |
|
[-R name] \ |
|
[-v[n]] \ |
|
[-V] \ |
|
[-w[n]] \ |
|
[-\ |
|
1\ |
|
a\ |
|
C\ |
|
c\ |
|
f\ |
|
G\ |
|
g\ |
|
I\ |
|
L\ |
|
N\ |
|
r\ |
|
s\ |
|
T\ |
|
t\ |
|
U\ |
|
x\ |
|
] \ |
|
source-file\n"; |
|
|
|
#if NO_LEAKS |
static void |
static void |
cleanup(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(char **namelst GCC_UNUSED) |
|
{ |
|
#if NO_LEAKS |
|
free_namelist(namelst); |
|
#endif |
if (tmp_fp != 0) |
if (tmp_fp != 0) |
fclose(tmp_fp); |
fclose(tmp_fp); |
if (to_remove != 0) { |
if (to_remove != 0) { |
|
|
failed(const char *msg) |
failed(const char *msg) |
{ |
{ |
perror(msg); |
perror(msg); |
cleanup(); |
cleanup((char **) 0); |
exit(EXIT_FAILURE); |
ExitProgram(EXIT_FAILURE); |
} |
} |
|
|
static void |
static void |
|
|
{ |
{ |
"Options:", |
"Options:", |
" -1 format translation output one capability per line", |
" -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", |
|
#if NCURSES_XNAMES |
#if NCURSES_XNAMES |
" -a retain commented-out capabilities (sets -x also)", |
" -a retain commented-out capabilities (sets -x also)", |
#endif |
#endif |
|
" -C translate entries to termcap source form", |
" -c check only, validate input without compiling or translating", |
" -c check only, validate input without compiling or translating", |
|
" -e<names> translate/compile only entries named by comma-separated list", |
" -f format complex strings for readability", |
" -f format complex strings for readability", |
" -G format %{number} to %'char'", |
" -G format %{number} to %'char'", |
" -g format %'char' to %{number}", |
" -g format %'char' to %{number}", |
" -e<names> translate/compile only entries named by comma-separated list", |
" -I translate entries to terminfo source form", |
|
" -L translate entries to full terminfo source form", |
|
" -N disable smart defaults for source translation", |
" -o<dir> set output directory for compiled entry writes", |
" -o<dir> set output directory for compiled entry writes", |
|
" -R<name> restrict translation to given terminfo/termcap version", |
" -r force resolution of all use entries in source translation", |
" -r force resolution of all use entries in source translation", |
" -s print summary statistics", |
" -s print summary statistics", |
|
" -T remove size-restrictions on compiled description", |
|
#if NCURSES_XNAMES |
|
" -t suppress commented-out capabilities", |
|
#endif |
|
" -U suppress post-processing of entries", |
|
" -V print version", |
" -v[n] set verbosity level", |
" -v[n] set verbosity level", |
" -w[n] set format width for translation output", |
" -w[n] set format width for translation output", |
#if NCURSES_XNAMES |
#if NCURSES_XNAMES |
|
|
fputs(tbl[j], stderr); |
fputs(tbl[j], stderr); |
putc('\n', stderr); |
putc('\n', stderr); |
} |
} |
exit(EXIT_FAILURE); |
ExitProgram(EXIT_FAILURE); |
} |
} |
|
|
#define L_BRACE '{' |
#define L_BRACE '{' |
|
|
d = result; |
d = result; |
t = s; |
t = s; |
while ((ch = *t++) != 0) { |
while ((ch = *t++) != 0) { |
*d++ = ch; |
*d++ = (char) ch; |
if (ch == '\\') { |
if (ch == '\\') { |
*d++ = *t++; |
*d++ = *t++; |
} else if ((ch == '%') |
} else if ((ch == '%') |
|
|
&& value < 127 |
&& value < 127 |
&& isprint((int) value)) { |
&& isprint((int) value)) { |
*d++ = S_QUOTE; |
*d++ = S_QUOTE; |
*d++ = (int) value; |
*d++ = (char) value; |
*d++ = S_QUOTE; |
*d++ = S_QUOTE; |
t = (v + 1); |
t = (v + 1); |
} |
} |
} |
} |
} |
} |
*d = 0; |
*d = 0; |
if (strlen(result) < strlen(s)) { |
if (strlen(result) < strlen(s)) { |
/* new string is same length as what is there, or shorter */ |
/* new string is same length as what is there, or shorter */ |
strlcpy(s, result, strlen(s)); |
strlcpy(s, result, strlen(s)); |
} |
} |
} |
} |
} |
} |
|
|
|
|
putchar(c); |
putchar(c); |
in_name = FALSE; |
in_name = FALSE; |
} else if (c != '>') { |
} else if (c != '>') { |
namebuf[used++] = c; |
namebuf[used++] = (char) c; |
} else { /* ah! candidate name! */ |
} else { /* ah! candidate name! */ |
char *up; |
char *up; |
NCURSES_CONST char *tp; |
NCURSES_CONST char *tp; |
|
|
if ((up = strchr(namebuf, '#')) != 0 |
if ((up = strchr(namebuf, '#')) != 0 |
|| (up = strchr(namebuf, '=')) != 0 |
|| (up = strchr(namebuf, '=')) != 0 |
|| ((up = strchr(namebuf, '@')) != 0 && up[1] == '>')) { |
|| ((up = strchr(namebuf, '@')) != 0 && up[1] == '>')) { |
(void) strlcpy(suffix, up, have); |
(void) strlcpy(suffix, up, have); |
*up = '\0'; |
*up = '\0'; |
} |
} |
|
|
|
|
static char * |
static char * |
stripped(char *src) |
stripped(char *src) |
{ |
{ |
while (isspace(CharOf(*src))) |
while (isspace(UChar(*src))) |
src++; |
src++; |
if (*src != '\0') { |
if (*src != '\0') { |
char *dst; |
char *dst; |
size_t len; |
size_t len; |
|
|
if ((dst = strdup(src)) == NULL) |
if ((dst = strdup(src)) == NULL) |
failed("strdup"); |
failed("strdup"); |
len = strlen(dst); |
len = strlen(dst); |
while (--len != 0 && isspace(CharOf(dst[len]))) |
while (--len != 0 && isspace(UChar(dst[len]))) |
dst[len] = '\0'; |
dst[len] = '\0'; |
return dst; |
return dst; |
} |
} |
|
|
|
|
if (fp == 0) { |
if (fp == 0) { |
fprintf(stderr, "%s: Can't open %s\n", _nc_progname, filename); |
fprintf(stderr, "%s: Can't open %s\n", _nc_progname, filename); |
exit(EXIT_FAILURE); |
ExitProgram(EXIT_FAILURE); |
} |
} |
if (fstat(fileno(fp), &sb) < 0 |
if (fstat(fileno(fp), &sb) < 0 |
|| (sb.st_mode & S_IFMT) != S_IFREG) { |
|| (sb.st_mode & S_IFMT) != S_IFREG) { |
fprintf(stderr, "%s: %s is not a file\n", _nc_progname, filename); |
fprintf(stderr, "%s: %s is not a file\n", _nc_progname, filename); |
exit(EXIT_FAILURE); |
ExitProgram(EXIT_FAILURE); |
} |
} |
return fp; |
return fp; |
} |
} |
|
|
/* Parse the "-e" option-value into a list of names */ |
/* Parse the "-e" option-value into a list of names */ |
static const char ** |
static char ** |
make_namelist(char *src) |
make_namelist(char *src) |
{ |
{ |
const char **dst = 0; |
char **dst = 0; |
|
|
char *s, *base; |
char *s, *base; |
unsigned pass, n, nn; |
unsigned pass, n, nn; |
|
|
if ((s = stripped(buffer)) != 0) { |
if ((s = stripped(buffer)) != 0) { |
if (dst != 0) |
if (dst != 0) |
dst[nn] = s; |
dst[nn] = s; |
|
else |
|
free(s); |
nn++; |
nn++; |
} |
} |
} |
} |
if (pass == 1) { |
if (pass == 1) { |
dst = typeCalloc(const char *, nn + 1); |
dst = typeCalloc(char *, nn + 1); |
rewind(fp); |
rewind(fp); |
} |
} |
} |
} |
|
|
break; |
break; |
} |
} |
if (pass == 1) |
if (pass == 1) |
dst = typeCalloc(const char *, nn + 1); |
dst = typeCalloc(char *, nn + 1); |
} |
} |
} |
} |
if (showsummary) { |
if (showsummary && (dst != 0)) { |
fprintf(log_fp, "Entries that will be compiled:\n"); |
fprintf(log_fp, "Entries that will be compiled:\n"); |
for (n = 0; dst[n] != 0; 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; |
return dst; |
} |
} |
|
|
static bool |
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? */ |
/* does entry in needle list match |-separated field in haystack? */ |
{ |
{ |
bool code = FALSE; |
bool code = FALSE; |
|
|
|
|
int width = 60; |
int width = 60; |
bool formatted = FALSE; /* reformat complex strings? */ |
bool formatted = FALSE; /* reformat complex strings? */ |
|
bool literal = FALSE; /* suppress post-processing? */ |
int numbers = 0; /* format "%'char'" to/from "%{number}" */ |
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 forceresolve = FALSE; /* force resolution */ |
bool limited = TRUE; |
bool limited = TRUE; |
char *tversion = (char *) NULL; |
char *tversion = (char *) NULL; |
const char *source_file = "terminfo"; |
const char *source_file = "terminfo"; |
const char **namelst = 0; |
char **namelst = 0; |
char *outdir = (char *) NULL; |
char *outdir = (char *) NULL; |
bool check_only = FALSE; |
bool check_only = FALSE; |
|
bool suppress_untranslatable = FALSE; |
|
|
log_fp = stderr; |
log_fp = stderr; |
|
|
_nc_progname = _nc_basename(argv[0]); |
_nc_progname = _nc_rootname(argv[0]); |
|
|
if ((infodump = (strcmp(_nc_progname, PROG_CAPTOINFO) == 0)) != FALSE) { |
if ((infodump = (strcmp(_nc_progname, PROG_CAPTOINFO) == 0)) != FALSE) { |
outform = F_TERMINFO; |
outform = F_TERMINFO; |
|
|
* be optional. |
* be optional. |
*/ |
*/ |
while ((this_opt = getopt(argc, argv, |
while ((this_opt = getopt(argc, argv, |
"0123456789CILNR:TVace:fGgo:rsvwx")) != -1) { |
"0123456789CILNR:TUVace:fGgo:rstvwx")) != -1) { |
if (isdigit(this_opt)) { |
if (isdigit(this_opt)) { |
switch (last_opt) { |
switch (last_opt) { |
case 'v': |
case 'v': |
|
|
break; |
break; |
case 'N': |
case 'N': |
smart_defaults = FALSE; |
smart_defaults = FALSE; |
|
literal = TRUE; |
break; |
break; |
case 'R': |
case 'R': |
tversion = optarg; |
tversion = optarg; |
|
|
case 'T': |
case 'T': |
limited = FALSE; |
limited = FALSE; |
break; |
break; |
|
case 'U': |
|
literal = TRUE; |
|
break; |
case 'V': |
case 'V': |
puts(curses_version()); |
puts(curses_version()); |
return EXIT_SUCCESS; |
cleanup(namelst); |
|
ExitProgram(EXIT_SUCCESS); |
case 'c': |
case 'c': |
check_only = TRUE; |
check_only = TRUE; |
break; |
break; |
|
|
width = 0; |
width = 0; |
break; |
break; |
#if NCURSES_XNAMES |
#if NCURSES_XNAMES |
|
case 't': |
|
_nc_disable_period = FALSE; |
|
suppress_untranslatable = TRUE; |
|
break; |
case 'a': |
case 'a': |
_nc_disable_period = TRUE; |
_nc_disable_period = TRUE; |
/* FALLTHRU */ |
/* FALLTHRU */ |
|
|
set_trace_level(debug_level); |
set_trace_level(debug_level); |
|
|
if (_nc_tracing) { |
if (_nc_tracing) { |
save_check_termtype = _nc_check_termtype; |
save_check_termtype = _nc_check_termtype2; |
_nc_check_termtype = check_termtype; |
_nc_check_termtype2 = check_termtype; |
} |
} |
#if !HAVE_BIG_CORE |
#if !HAVE_BIG_CORE |
/* |
/* |
|
|
if (namelst && (!infodump && !capdump)) { |
if (namelst && (!infodump && !capdump)) { |
(void) fprintf(stderr, |
(void) fprintf(stderr, |
"Sorry, -e can't be used without -I or -C\n"); |
"Sorry, -e can't be used without -I or -C\n"); |
cleanup(); |
cleanup(namelst); |
return EXIT_FAILURE; |
ExitProgram(EXIT_FAILURE); |
} |
} |
#endif /* HAVE_BIG_CORE */ |
#endif /* HAVE_BIG_CORE */ |
|
|
|
|
_nc_progname, |
_nc_progname, |
_nc_progname, |
_nc_progname, |
usage_string); |
usage_string); |
return EXIT_FAILURE; |
ExitProgram(EXIT_FAILURE); |
} |
} |
} else { |
} else { |
if (infodump == TRUE) { |
if (infodump == TRUE) { |
/* captoinfo's no-argument case */ |
/* captoinfo's no-argument case */ |
source_file = "/usr/share/misc/termcap"; |
source_file = "/etc/termcap"; |
if ((termcap = getenv("TERMCAP")) != 0 |
if ((termcap = getenv("TERMCAP")) != 0 |
&& (namelst = make_namelist(getenv("TERM"))) != 0) { |
&& (namelst = make_namelist(getenv("TERM"))) != 0) { |
strlcpy(my_tmpname, "/tmp/XXXXXXXXXX", sizeof my_tmpname); |
strlcpy(my_tmpname, "/tmp/XXXXXXXXXX", sizeof my_tmpname); |
|
|
tmp_fp = open_input(source_file); |
tmp_fp = open_input(source_file); |
to_remove = source_file; |
to_remove = source_file; |
} else { |
} else { |
failed("mkstemp"); |
failed("tmpnam"); |
} |
} |
} |
} |
} else { |
} else { |
|
|
_nc_progname, |
_nc_progname, |
_nc_progname, |
_nc_progname, |
usage_string); |
usage_string); |
cleanup(); |
cleanup(namelst); |
return EXIT_FAILURE; |
ExitProgram(EXIT_FAILURE); |
} |
} |
} |
} |
|
|
|
|
_nc_set_writedir(outdir); |
_nc_set_writedir(outdir); |
#endif /* HAVE_BIG_CORE */ |
#endif /* HAVE_BIG_CORE */ |
_nc_read_entry_source(tmp_fp, (char *) NULL, |
_nc_read_entry_source(tmp_fp, (char *) NULL, |
!smart_defaults, FALSE, |
!smart_defaults || literal, FALSE, |
(check_only || infodump || capdump) ? NULLHOOK : immedhook); |
((check_only || infodump || capdump) |
|
? NULLHOOK |
|
: immedhook)); |
|
|
/* do use resolution */ |
/* do use resolution */ |
if (check_only || (!infodump && !capdump) || forceresolve) { |
if (check_only || (!infodump && !capdump) || forceresolve) { |
if (!_nc_resolve_uses(TRUE) && !check_only) { |
if (!_nc_resolve_uses2(TRUE, literal) && !check_only) { |
cleanup(); |
cleanup(namelst); |
return EXIT_FAILURE; |
ExitProgram(EXIT_FAILURE); |
} |
} |
} |
} |
|
|
|
|
if (check_only && (capdump || infodump)) { |
if (check_only && (capdump || infodump)) { |
for_entry_list(qp) { |
for_entry_list(qp) { |
if (matches(namelst, qp->tterm.term_names)) { |
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)) |
if (len > (infodump ? MAX_TERMINFO_LENGTH : MAX_TERMCAP_LENGTH)) |
(void) fprintf(stderr, |
(void) fprintf(stderr, |
|
|
_nc_set_type(_nc_first_name(qp->tterm.term_names)); |
_nc_set_type(_nc_first_name(qp->tterm.term_names)); |
|
|
(void) fseek(tmp_fp, qp->cstart, SEEK_SET); |
(void) fseek(tmp_fp, qp->cstart, SEEK_SET); |
while (j--) { |
while (j-- > 0) { |
if (infodump) |
if (infodump) |
(void) putchar(fgetc(tmp_fp)); |
(void) putchar(fgetc(tmp_fp)); |
else |
else |
put_translate(fgetc(tmp_fp)); |
put_translate(fgetc(tmp_fp)); |
} |
} |
|
|
len = dump_entry(&qp->tterm, limited, numbers, NULL); |
dump_entry(&qp->tterm, suppress_untranslatable, |
for (j = 0; j < qp->nuses; j++) |
limited, numbers, NULL); |
len += dump_uses(qp->uses[j].name, !capdump); |
for (j = 0; j < (int) qp->nuses; j++) |
(void) putchar('\n'); |
dump_uses(qp->uses[j].name, !capdump); |
|
len = show_entry(); |
if (debug_level != 0 && !limited) |
if (debug_level != 0 && !limited) |
printf("# length=%d\n", len); |
printf("# length=%d\n", len); |
} |
} |
|
|
else |
else |
fprintf(log_fp, "No entries written\n"); |
fprintf(log_fp, "No entries written\n"); |
} |
} |
cleanup(); |
cleanup(namelst); |
return (EXIT_SUCCESS); |
ExitProgram(EXIT_SUCCESS); |
} |
} |
|
|
/* |
/* |
|
|
* references to locations in the arrays Booleans, Numbers, and Strings --- |
* references to locations in the arrays Booleans, Numbers, and Strings --- |
* precisely what's needed (see comp_parse.c). |
* precisely what's needed (see comp_parse.c). |
*/ |
*/ |
|
|
TERMINAL *cur_term; /* tweak to avoid linking lib_cur_term.c */ |
|
|
|
#undef CUR |
#undef CUR |
#define CUR tp-> |
#define CUR tp-> |
|
|
/* |
/* |
|
* Check if the alternate character-set capabilities are consistent. |
|
*/ |
|
static void |
|
check_acs(TERMTYPE *tp) |
|
{ |
|
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); |
|
} |
|
} |
|
} |
|
|
|
/* |
|
* Check if the color capabilities are consistent |
|
*/ |
|
static void |
|
check_colors(TERMTYPE *tp) |
|
{ |
|
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); |
|
|
|
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) |
|
&& !_nc_capcmp(set_foreground, set_a_foreground)) |
|
_nc_warning("expected setf/setaf to be different"); |
|
|
|
if (VALID_STRING(set_background) |
|
&& VALID_STRING(set_a_background) |
|
&& !_nc_capcmp(set_background, set_a_background)) |
|
_nc_warning("expected setb/setab to be different"); |
|
|
|
/* see: has_colors() */ |
|
if (VALID_NUMERIC(max_colors) && VALID_NUMERIC(max_pairs) |
|
&& (((set_foreground != NULL) |
|
&& (set_background != NULL)) |
|
|| ((set_a_foreground != NULL) |
|
&& (set_a_background != NULL)) |
|
|| set_color_pair)) { |
|
if (!VALID_STRING(orig_pair) && !VALID_STRING(orig_colors)) |
|
_nc_warning("expected either op/oc string for resetting colors"); |
|
} |
|
} |
|
|
|
static char |
|
keypad_final(const char *string) |
|
{ |
|
char result = '\0'; |
|
|
|
if (VALID_STRING(string) |
|
&& *string++ == '\033' |
|
&& *string++ == 'O' |
|
&& strlen(string) == 1) { |
|
result = *string; |
|
} |
|
|
|
return result; |
|
} |
|
|
|
static int |
|
keypad_index(const char *string) |
|
{ |
|
char *test; |
|
const char *list = "PQRSwxymtuvlqrsPpn"; /* app-keypad except "Enter" */ |
|
int ch; |
|
int result = -1; |
|
|
|
if ((ch = keypad_final(string)) != '\0') { |
|
test = strchr(list, ch); |
|
if (test != 0) |
|
result = (test - list); |
|
} |
|
return result; |
|
} |
|
|
|
#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(TERMTYPE *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]; |
|
int list[MAX_KP]; |
|
int increase = 0; |
|
int j, k, kk; |
|
int last; |
|
int 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: |
|
strlcat(show, " ka1", sizeof(show)); |
|
break; |
|
case 1: |
|
strlcat(show, " ka3", sizeof(show)); |
|
break; |
|
case 2: |
|
strlcat(show, " kb2", sizeof(show)); |
|
break; |
|
case 3: |
|
strlcat(show, " kc1", sizeof(show)); |
|
break; |
|
case 4: |
|
strlcat(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) |
|
strlcat(show, " ka1", sizeof(show)); |
|
if (keypad_index(key_a3) >= 0) |
|
strlcat(show, " ka3", sizeof(show)); |
|
if (keypad_index(key_b2) >= 0) |
|
strlcat(show, " kb2", sizeof(show)); |
|
if (keypad_index(key_c1) >= 0) |
|
strlcat(show, " kc1", sizeof(show)); |
|
if (keypad_index(key_c3) >= 0) |
|
strlcat(show, " kc3", sizeof(show)); |
|
if (*show != '\0') |
|
_nc_warning("vt100 keypad map incomplete:%s", show); |
|
} |
|
} |
|
|
|
/* |
* Returns the expected number of parameters for the given capability. |
* Returns the expected number of parameters for the given capability. |
*/ |
*/ |
static int |
static int |
expected_params(char *name) |
expected_params(const char *name) |
{ |
{ |
/* *INDENT-OFF* */ |
/* *INDENT-OFF* */ |
static const struct { |
static const struct { |
const char *name; |
const char *name; |
int count; |
int count; |
} table[] = { |
} table[] = { |
|
{ "S0", 1 }, /* 'screen' extension */ |
{ "birep", 2 }, |
{ "birep", 2 }, |
{ "chr", 1 }, |
{ "chr", 1 }, |
{ "colornm", 1 }, |
{ "colornm", 1 }, |
|
|
{ "sgr1", 6 }, |
{ "sgr1", 6 }, |
{ "slength", 1 }, |
{ "slength", 1 }, |
{ "slines", 1 }, |
{ "slines", 1 }, |
{ "smgbp", 2 }, |
{ "smgbp", 1 }, /* 2 if smgtp is not given */ |
{ "smglp", 2 }, |
{ "smglp", 1 }, |
{ "smglr", 2 }, |
{ "smglr", 2 }, |
{ "smgrp", 1 }, |
{ "smgrp", 1 }, |
{ "smgtb", 2 }, |
{ "smgtb", 2 }, |
|
|
* markers. |
* markers. |
*/ |
*/ |
static void |
static void |
check_params(TERMTYPE * tp, char *name, char *value) |
check_params(TERMTYPE *tp, const char *name, char *value) |
{ |
{ |
int expected = expected_params(name); |
int expected = expected_params(name); |
int actual = 0; |
int actual = 0; |
|
|
bool params[10]; |
bool params[10]; |
char *s = value; |
char *s = value; |
|
|
|
#ifdef set_top_margin_parm |
|
if (!strcmp(name, "smgbp") |
|
&& set_top_margin_parm == 0) |
|
expected = 2; |
|
#endif |
|
|
for (n = 0; n < 10; n++) |
for (n = 0; n < 10; n++) |
params[n] = FALSE; |
params[n] = FALSE; |
|
|
|
|
} |
} |
} |
} |
|
|
|
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; |
|
} |
|
|
|
/* |
* An sgr string may contain several settings other than the one we're |
* An sgr string may contain several settings other than the one we're |
* interested in, essentially sgr0 + rmacs + whatever. As long as the |
* interested in, essentially sgr0 + rmacs + whatever. As long as the |
* "whatever" is contained in the sgr string, that is close enough for our |
* "whatever" is contained in the sgr string, that is close enough for our |
* sanity check. |
* sanity check. |
*/ |
*/ |
static bool |
static bool |
similar_sgr(char *a, char *b) |
similar_sgr(int num, char *a, char *b) |
{ |
{ |
|
static const char *names[] = |
|
{ |
|
"none" |
|
,"standout" |
|
,"underline" |
|
,"reverse" |
|
,"blink" |
|
,"dim" |
|
,"bold" |
|
,"invis" |
|
,"protect" |
|
,"altcharset" |
|
}; |
|
char *base_a = a; |
|
char *base_b = b; |
|
int delaying = 0; |
|
|
while (*b != 0) { |
while (*b != 0) { |
while (*a != *b) { |
while (*a != *b) { |
if (*a == 0) |
if (*a == 0) { |
|
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", |
|
names[num], _nc_visbuf2(1, base_a), |
|
_nc_visbuf2(2, base_b), |
|
_nc_visbuf2(3, b)); |
|
} |
return FALSE; |
return FALSE; |
a++; |
} else if (delaying) { |
|
a = skip_delay(a); |
|
b = skip_delay(b); |
|
} else { |
|
a++; |
|
} |
} |
} |
|
switch (*a) { |
|
case '$': |
|
if (delaying == 0) |
|
delaying = 1; |
|
break; |
|
case '<': |
|
if (delaying == 1) |
|
delaying = 2; |
|
break; |
|
default: |
|
delaying = 0; |
|
break; |
|
} |
a++; |
a++; |
b++; |
b++; |
} |
} |
return TRUE; |
/* ignore delays on the end of the string */ |
|
a = ignore_delays(a); |
|
return ((num != 0) || (*a == 0)); |
} |
} |
|
|
static void |
static char * |
check_sgr(TERMTYPE * tp, char *zero, int num, char *cap, const char *name) |
check_sgr(TERMTYPE *tp, char *zero, int num, char *cap, const char *name) |
{ |
{ |
char *test = tparm(set_attributes, |
char *test; |
num == 1, |
|
num == 2, |
_nc_tparm_err = 0; |
num == 3, |
test = TPARM_9(set_attributes, |
num == 4, |
num == 1, |
num == 5, |
num == 2, |
num == 6, |
num == 3, |
num == 7, |
num == 4, |
num == 8, |
num == 5, |
num == 9); |
num == 6, |
|
num == 7, |
|
num == 8, |
|
num == 9); |
if (test != 0) { |
if (test != 0) { |
if (PRESENT(cap)) { |
if (PRESENT(cap)) { |
if (!similar_sgr(test, cap)) { |
if (!similar_sgr(num, test, cap)) { |
_nc_warning("%s differs from sgr(%d): %s", name, num, |
_nc_warning("%s differs from sgr(%d)\n\t%s=%s\n\tsgr(%d)=%s", |
_nc_visbuf(test)); |
name, num, |
|
name, _nc_visbuf2(1, cap), |
|
num, _nc_visbuf2(2, test)); |
} |
} |
} else if (strcmp(test, zero)) { |
} else if (_nc_capcmp(test, zero)) { |
_nc_warning("sgr(%d) present, but not %s", num, name); |
_nc_warning("sgr(%d) present, but not %s", num, name); |
} |
} |
} else if (PRESENT(cap)) { |
} else if (PRESENT(cap)) { |
_nc_warning("sgr(%d) missing, but %s present", num, name); |
_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) |
#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[256]; |
|
_nc_get_type(my_name); |
|
fprintf(stderr, "\"%s\", line %d, '%s' ", |
|
_nc_get_source(), |
|
_nc_curr_line, my_name); |
|
} |
|
} |
|
|
|
#else |
|
#define show_where(level) /* nothing */ |
|
#endif |
|
|
/* other sanity-checks (things that we don't want in the normal |
/* other sanity-checks (things that we don't want in the normal |
* logic that reads a terminfo entry) |
* logic that reads a terminfo entry) |
*/ |
*/ |
static void |
static void |
check_termtype(TERMTYPE * tp) |
check_termtype(TERMTYPE *tp, bool literal) |
{ |
{ |
bool conflict = FALSE; |
bool conflict = FALSE; |
unsigned j, k; |
unsigned j, k; |
|
|
* a given string (e.g., KEY_END and KEY_LL). But curses will only |
* a given string (e.g., KEY_END and KEY_LL). But curses will only |
* return one (the last one assigned). |
* return one (the last one assigned). |
*/ |
*/ |
memset(fkeys, 0, sizeof(fkeys)); |
if (!(_nc_syntax == SYN_TERMCAP && capdump)) { |
for (j = 0; _nc_tinfo_fkeys[j].code; j++) { |
memset(fkeys, 0, sizeof(fkeys)); |
char *a = tp->Strings[_nc_tinfo_fkeys[j].offset]; |
for (j = 0; _nc_tinfo_fkeys[j].code; j++) { |
bool first = TRUE; |
char *a = tp->Strings[_nc_tinfo_fkeys[j].offset]; |
if (!VALID_STRING(a)) |
bool first = TRUE; |
continue; |
if (!VALID_STRING(a)) |
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; |
continue; |
if (!strcmp(a, b)) { |
for (k = j + 1; _nc_tinfo_fkeys[k].code; k++) { |
fkeys[j] = 1; |
char *b = tp->Strings[_nc_tinfo_fkeys[k].offset]; |
fkeys[k] = 1; |
if (!VALID_STRING(b) |
if (first) { |
|| fkeys[k]) |
if (!conflict) { |
continue; |
_nc_warning("Conflicting key definitions (using the last)"); |
if (!_nc_capcmp(a, b)) { |
conflict = TRUE; |
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((int) _nc_tinfo_fkeys[j].code), |
|
keyname((int) _nc_tinfo_fkeys[k].code)); |
|
first = FALSE; |
|
} else { |
|
fprintf(stderr, ", %s", |
|
keyname((int) _nc_tinfo_fkeys[k].code)); |
} |
} |
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)); |
|
} |
} |
} |
} |
|
if (!first) |
|
fprintf(stderr, "\n"); |
} |
} |
if (!first) |
|
fprintf(stderr, "\n"); |
|
} |
} |
|
|
for (j = 0; j < NUM_STRINGS(tp); j++) { |
for (j = 0; j < NUM_STRINGS(tp); j++) { |
|
|
check_params(tp, ExtStrname(tp, j, strnames), a); |
check_params(tp, ExtStrname(tp, j, strnames), a); |
} |
} |
|
|
/* |
check_acs(tp); |
* Quick check for color. We could also check if the ANSI versus |
check_colors(tp); |
* non-ANSI strings are misused. |
check_keypad(tp); |
*/ |
|
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); |
|
|
|
/* |
/* |
* These may be mismatched because the terminal description relies on |
* These may be mismatched because the terminal description relies on |
* restoring the cursor visibility by resetting it. |
* restoring the cursor visibility by resetting it. |
|
|
ANDMISSING(cursor_visible, cursor_normal); |
ANDMISSING(cursor_visible, cursor_normal); |
|
|
if (PRESENT(cursor_visible) && PRESENT(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"); |
_nc_warning("cursor_visible is same as cursor_normal"); |
|
|
/* |
/* |
|
|
ANDMISSING(change_scroll_region, restore_cursor); |
ANDMISSING(change_scroll_region, restore_cursor); |
|
|
if (PRESENT(set_attributes)) { |
if (PRESENT(set_attributes)) { |
char *zero = tparm(set_attributes, 0, 0, 0, 0, 0, 0, 0, 0, 0); |
char *zero = 0; |
|
|
zero = strdup(zero); |
_nc_tparm_err = 0; |
CHECK_SGR(1, enter_standout_mode); |
if (PRESENT(exit_attribute_mode)) { |
CHECK_SGR(2, enter_underline_mode); |
zero = strdup(CHECK_SGR(0, exit_attribute_mode)); |
CHECK_SGR(3, enter_reverse_mode); |
} else { |
CHECK_SGR(4, enter_blink_mode); |
zero = strdup(TPARM_9(set_attributes, 0, 0, 0, 0, 0, 0, 0, 0, 0)); |
CHECK_SGR(5, enter_dim_mode); |
} |
CHECK_SGR(6, enter_bold_mode); |
if (_nc_tparm_err) |
CHECK_SGR(7, enter_secure_mode); |
_nc_warning("stack error in sgr(0) string"); |
CHECK_SGR(8, enter_protected_mode); |
|
CHECK_SGR(9, enter_alt_charset_mode); |
if (zero != 0) { |
free(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); |
|
} 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"); |
} |
} |
|
|
|
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))); |
|
free(check_sgr0); |
|
} else { |
|
DEBUG(2, |
|
("will not trim sgr0\n\toriginal sgr0=%s", |
|
_nc_visbuf(exit_attribute_mode))); |
|
} |
|
} |
|
} |
|
#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 |
* 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 |
* smir/rmir. Let's be nice and warn about that, too, even though |
* ncurses handles it. |
* ncurses handles it. |
*/ |
*/ |
if ((PRESENT(enter_insert_mode) || PRESENT(exit_insert_mode)) |
if ((PRESENT(enter_insert_mode) || PRESENT(exit_insert_mode)) |
&& (PRESENT(insert_character) || PRESENT(parm_ich))) { |
&& PRESENT(parm_ich)) { |
_nc_warning("non-curses applications may be confused by ich/ich1 with smir/rmir"); |
_nc_warning("non-curses applications may be confused by ich1 with smir/rmir"); |
} |
} |
|
|
/* |
/* |
* Finally, do the non-verbose checks |
* Finally, do the non-verbose checks |
*/ |
*/ |
if (save_check_termtype != 0) |
if (save_check_termtype != 0) |
save_check_termtype(tp); |
save_check_termtype(tp, literal); |
} |
} |