static int capcmp(const char *s, const char *t)
/* capability comparison function */
{
if (!VALID_STRING(s) && !VALID_STRING(t))
return(0);
else if (!VALID_STRING(s) || !VALID_STRING(t))
return(1);
if (ignorepads)
return(_nc_capcmp(s, t));
else
return(strcmp(s, t));
}
static int
capcmp(PredIdx idx, const char *s, const char *t)
/* capability comparison function */
{
if (!VALID_STRING(s) && !VALID_STRING(t))
return (s != t);
else if (!VALID_STRING(s) || !VALID_STRING(t))
return (1);
if ((idx == acs_chars_index) || !ignorepads)
return (strcmp(s, t));
else
return (_nc_capcmp(s, t));
}
static void
postprocess_termcap(TERMTYPE * tp, bool has_base)
{
char buf[MAX_LINE * 2 + 2];
string_desc result;
/*
* TERMCAP DEFAULTS AND OBSOLETE-CAPABILITY TRANSLATIONS
*
* This first part of the code is the functional inverse of the
* fragment in capdefaults.c.
* ----------------------------------------------------------------------
*/
/* if there was a tc entry, assume we picked up defaults via that */
if (!has_base) {
if (WANTED(init_3string) && termcap_init2)
init_3string = _nc_save_str(termcap_init2);
if (WANTED(reset_2string) && termcap_reset)
reset_2string = _nc_save_str(termcap_reset);
if (WANTED(carriage_return)) {
if (carriage_return_delay > 0) {
sprintf(buf, "%s$<%d>", C_CR, carriage_return_delay);
carriage_return = _nc_save_str(buf);
} else
carriage_return = _nc_save_str(C_CR);
}
if (WANTED(cursor_left)) {
if (backspace_delay > 0) {
sprintf(buf, "%s$<%d>", C_BS, backspace_delay);
cursor_left = _nc_save_str(buf);
} else if (backspaces_with_bs == 1)
cursor_left = _nc_save_str(C_BS);
else if (PRESENT(backspace_if_not_bs))
cursor_left = backspace_if_not_bs;
}
/* vi doesn't use "do", but it does seems to use nl (or '\n') instead */
if (WANTED(cursor_down)) {
if (PRESENT(linefeed_if_not_lf))
cursor_down = linefeed_if_not_lf;
else if (linefeed_is_newline != 1) {
if (new_line_delay > 0) {
sprintf(buf, "%s$<%d>", C_LF, new_line_delay);
cursor_down = _nc_save_str(buf);
} else
cursor_down = _nc_save_str(C_LF);
}
}
if (WANTED(scroll_forward) && crt_no_scrolling != 1) {
if (PRESENT(linefeed_if_not_lf))
cursor_down = linefeed_if_not_lf;
else if (linefeed_is_newline != 1) {
if (new_line_delay > 0) {
sprintf(buf, "%s$<%d>", C_LF, new_line_delay);
scroll_forward = _nc_save_str(buf);
} else
scroll_forward = _nc_save_str(C_LF);
}
}
if (WANTED(newline)) {
if (linefeed_is_newline == 1) {
if (new_line_delay > 0) {
sprintf(buf, "%s$<%d>", C_LF, new_line_delay);
newline = _nc_save_str(buf);
} else
newline = _nc_save_str(C_LF);
} else if (PRESENT(carriage_return) && PRESENT(scroll_forward)) {
_nc_str_init(&result, buf, sizeof(buf));
if (_nc_safe_strcat(&result, carriage_return)
&& _nc_safe_strcat(&result, scroll_forward))
newline = _nc_save_str(buf);
} else if (PRESENT(carriage_return) && PRESENT(cursor_down)) {
_nc_str_init(&result, buf, sizeof(buf));
if (_nc_safe_strcat(&result, carriage_return)
&& _nc_safe_strcat(&result, cursor_down))
newline = _nc_save_str(buf);
}
}
}
/*
* Inverse of capdefaults.c code ends here.
* ----------------------------------------------------------------------
*
* TERMCAP-TO TERMINFO MAPPINGS FOR SOURCE TRANSLATION
*
* These translations will *not* be inverted by tgetent().
*/
if (!has_base) {
/*
* We wait until now to decide if we've got a working cr because even
* one that doesn't work can be used for newline. Unfortunately the
* space allocated for it is wasted.
*/
if (return_does_clr_eol == 1 || no_correctly_working_cr == 1)
carriage_return = ABSENT_STRING;
/*
* Supposedly most termcap entries have ta now and '\t' is no longer a
* default, but it doesn't seem to be true...
*/
if (WANTED(tab)) {
if (horizontal_tab_delay > 0) {
sprintf(buf, "%s$<%d>", C_HT, horizontal_tab_delay);
tab = _nc_save_str(buf);
} else
tab = _nc_save_str(C_HT);
}
if (init_tabs == ABSENT_NUMERIC && has_hardware_tabs == TRUE)
init_tabs = 8;
/*
* Assume we can beep with ^G unless we're given bl@.
*/
if (WANTED(bell))
bell = _nc_save_str("\007");
}
/*
* Translate the old termcap :pt: capability to it#8 + ht=\t
*/
if (has_hardware_tabs == TRUE) {
if (init_tabs != 8 && init_tabs != ABSENT_NUMERIC)
_nc_warning("hardware tabs with a width other than 8: %d", init_tabs);
else {
if (tab && _nc_capcmp(tab, C_HT))
_nc_warning("hardware tabs with a non-^I tab string %s",
_nc_visbuf(tab));
else {
if (WANTED(tab))
tab = _nc_save_str(C_HT);
init_tabs = 8;
}
}
}
/*
* Now translate the ko capability, if there is one. This
* isn't from mytinfo...
*/
if (PRESENT(other_non_function_keys)) {
char *base = other_non_function_keys;
char *bp, *cp, *dp;
struct name_table_entry const *from_ptr;
struct name_table_entry const *to_ptr;
assoc const *ap;
char buf2[MAX_TERMINFO_LENGTH];
bool foundim;
/* we're going to use this for a special case later */
dp = strchr(other_non_function_keys, 'i');
foundim = (dp != 0) && (dp[1] == 'm');
/* look at each comma-separated capability in the ko string... */
for (base = other_non_function_keys;
(cp = strchr(base, ',')) != 0;
base = cp + 1) {
size_t len = cp - base;
for (ap = ko_xlate; ap->from; ap++)
if (len == strlen(ap->from)
&& strncmp(ap->from, base, len) == 0)
break;
if (!ap->to) {
_nc_warning("unknown capability `%.*s' in ko string",
(int) len, base);
continue;
} else if (ap->to == CANCELLED_STRING) /* ignore it */
continue;
/* now we know we found a match in ko_table, so... */
from_ptr = _nc_find_entry(ap->from, _nc_cap_hash_table);
to_ptr = _nc_find_entry(ap->to, _nc_info_hash_table);
if (!from_ptr || !to_ptr) /* should never happen! */
_nc_err_abort("ko translation table is invalid, I give up");
if (WANTED(tp->Strings[from_ptr->nte_index])) {
_nc_warning("no value for ko capability %s", ap->from);
continue;
}
if (tp->Strings[to_ptr->nte_index]) {
/* There's no point in warning about it if it's the same
* string; that's just an inefficiency.
*/
if (strcmp(
tp->Strings[from_ptr->nte_index],
tp->Strings[to_ptr->nte_index]) != 0)
_nc_warning("%s (%s) already has an explicit value %s, ignoring ko",
ap->to, ap->from,
_nc_visbuf(tp->Strings[to_ptr->nte_index]));
continue;
}
/*
* The magic moment -- copy the mapped key string over,
* stripping out padding.
*/
for (dp = buf2, bp = tp->Strings[from_ptr->nte_index]; *bp; bp++) {
if (bp[0] == '$' && bp[1] == '<') {
while (*bp && *bp != '>') {
++bp;
}
} else
*dp++ = *bp;
}
*dp++ = '\0';
tp->Strings[to_ptr->nte_index] = _nc_save_str(buf2);
}
/*
* Note: ko=im and ko=ic both want to grab the `Insert'
* keycap. There's a kich1 but no ksmir, so the ic capability
* got mapped to kich1 and im to kIC to avoid a collision.
* If the description has im but not ic, hack kIC back to kich1.
*/
if (foundim && WANTED(key_ic) && key_sic) {
key_ic = key_sic;
key_sic = ABSENT_STRING;
}
}
if (!hard_copy) {
if (WANTED(key_backspace))
key_backspace = _nc_save_str(C_BS);
if (WANTED(key_left))
key_left = _nc_save_str(C_BS);
if (WANTED(key_down))
key_down = _nc_save_str(C_LF);
}
/*
* Translate XENIX forms characters.
*/
if (PRESENT(acs_ulcorner) ||
PRESENT(acs_llcorner) ||
PRESENT(acs_urcorner) ||
PRESENT(acs_lrcorner) ||
PRESENT(acs_ltee) ||
PRESENT(acs_rtee) ||
PRESENT(acs_btee) ||
PRESENT(acs_ttee) ||
PRESENT(acs_hline) ||
PRESENT(acs_vline) ||
PRESENT(acs_plus)) {
char buf2[MAX_TERMCAP_LENGTH];
_nc_str_init(&result, buf2, sizeof(buf2));
_nc_safe_strcat(&result, acs_chars);
append_acs (&result, 'j', acs_lrcorner);
append_acs (&result, 'k', acs_urcorner);
append_acs (&result, 'l', acs_ulcorner);
append_acs (&result, 'm', acs_llcorner);
append_acs (&result, 'n', acs_plus);
append_acs (&result, 'q', acs_hline);
append_acs (&result, 't', acs_ltee);
append_acs (&result, 'u', acs_rtee);
append_acs (&result, 'v', acs_btee);
append_acs (&result, 'w', acs_ttee);
append_acs (&result, 'x', acs_vline);
if (buf2[0]) {
acs_chars = _nc_save_str(buf2);
_nc_warning("acsc string synthesized from XENIX capabilities");
}
} else if (acs_chars == 0
&& enter_alt_charset_mode != 0
&& exit_alt_charset_mode != 0) {
acs_chars =
_nc_save_str("``aaffggiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~");
}
}
static void analyze_string(const char *name, const char *cap, TERMTYPE *tp)
{
char buf[MAX_TERMINFO_LENGTH];
char buf2[MAX_TERMINFO_LENGTH];
const char *sp, *ep;
const assoc *ap;
if (cap == ABSENT_STRING || cap == CANCELLED_STRING)
return;
(void) printf("%s: ", name);
buf[0] = '\0';
for (sp = cap; *sp; sp++)
{
int i;
size_t len = 0;
const char *expansion = 0;
/* first, check other capabilities in this entry */
for (i = 0; i < STRCOUNT; i++)
{
char *cp = tp->Strings[i];
/* don't use soft-key capabilities */
if (strnames[i][0] == 'k' && strnames[i][0] == 'f')
continue;
if (cp != ABSENT_STRING && cp != CANCELLED_STRING && cp[0] && cp != cap)
{
len = strlen(cp);
(void) strncpy(buf2, sp, len);
buf2[len] = '\0';
if (_nc_capcmp(cp, buf2))
continue;
#define ISRS(s) (!strncmp((s), "is", 2) || !strncmp((s), "rs", 2))
/*
* Theoretically we just passed the test for translation
* (equality once the padding is stripped). However, there
* are a few more hoops that need to be jumped so that
* identical pairs of initialization and reset strings
* don't just refer to each other.
*/
if (ISRS(name) || ISRS(strnames[i]))
if (cap < cp)
continue;
#undef ISRS
expansion = strnames[i];
break;
}
}
/* now check the standard capabilities */
if (!expansion)
for (ap = std_caps; ap->from; ap++)
{
len = strlen(ap->from);
if (strncmp(ap->from, sp, len) == 0)
{
expansion = ap->to;
break;
}
}
/* now check for private-mode sequences */
if (!expansion
&& sp[0] == '\033' && sp[1] == '[' && sp[2] == '?'
&& (len = strspn(sp + 3, "0123456789;"))
&& ((sp[3 + len] == 'h') || (sp[3 + len] == 'l')))
{
char buf3[MAX_TERMINFO_LENGTH];
(void) strcpy(buf2, (sp[3 + len] == 'h') ? "DEC+" : "DEC-");
(void) strncpy(buf3, sp + 3, len);
len += 4;
buf3[len] = '\0';
ep = strtok(buf3, ";");
do {
bool found = FALSE;
for (ap = private_modes; ap->from; ap++)
{
size_t tlen = strlen(ap->from);
if (strncmp(ap->from, ep, tlen) == 0)
{
(void) strcat(buf2, ap->to);
found = TRUE;
break;
}
}
if (!found)
(void) strcat(buf2, ep);
(void) strcat(buf2, ";");
} while
((ep = strtok((char *)NULL, ";")));
buf2[strlen(buf2) - 1] = '\0';
expansion = buf2;
}
/* now check for ECMA highlight sequences */
if (!expansion
&& sp[0] == '\033' && sp[1] == '['
&& (len = strspn(sp + 2, "0123456789;"))
&& sp[2 + len] == 'm')
{
char buf3[MAX_TERMINFO_LENGTH];
(void) strcpy(buf2, "SGR:");
(void) strncpy(buf3, sp + 2, len);
len += 3;
buf3[len] = '\0';
ep = strtok(buf3, ";");
do {
bool found = FALSE;
for (ap = ecma_highlights; ap->from; ap++)
{
size_t tlen = strlen(ap->from);
if (strncmp(ap->from, ep, tlen) == 0)
{
(void) strcat(buf2, ap->to);
found = TRUE;
break;
}
}
if (!found)
(void) strcat(buf2, ep);
(void) strcat(buf2, ";");
} while
((ep = strtok((char *)NULL, ";")));
buf2[strlen(buf2) - 1] = '\0';
expansion = buf2;
}
/* now check for scroll region reset */
if (!expansion)
{
(void) sprintf(buf2, "\033[1;%dr", tp->Numbers[2]);
len = strlen(buf2);
if (strncmp(buf2, sp, len) == 0)
expansion = "RSR";
}
/* now check for home-down */
if (!expansion)
{
(void) sprintf(buf2, "\033[%d;1H", tp->Numbers[2]);
len = strlen(buf2);
if (strncmp(buf2, sp, len) == 0)
expansion = "LL";
}
/* now look at the expansion we got, if any */
if (expansion)
{
(void) sprintf(buf + strlen(buf), "{%s}", expansion);
sp += len - 1;
continue;
}
else
{
/* couldn't match anything */
buf2[0] = *sp;
buf2[1] = '\0';
(void) strcat(buf, _nc_tic_expand(buf2, outform==F_TERMINFO));
}
}
(void) printf("%s\n", buf);
}
static void
analyze_string(const char *name, const char *cap, TERMTYPE *tp)
{
char buf[MAX_TERMINFO_LENGTH];
char buf2[MAX_TERMINFO_LENGTH];
const char *sp;
const assoc *ap;
int tp_lines = tp->Numbers[2];
if (cap == ABSENT_STRING || cap == CANCELLED_STRING)
return;
(void) printf("%s: ", name);
buf[0] = '\0';
for (sp = cap; *sp; sp++) {
int i;
int csi;
size_t len = 0;
size_t next;
const char *expansion = 0;
char buf3[MAX_TERMINFO_LENGTH];
/* first, check other capabilities in this entry */
for (i = 0; i < STRCOUNT; i++) {
char *cp = tp->Strings[i];
/* don't use soft-key capabilities */
if (strnames[i][0] == 'k' && strnames[i][0] == 'f')
continue;
if (cp != ABSENT_STRING && cp != CANCELLED_STRING && cp[0] && cp
!= cap) {
len = strlen(cp);
(void) strncpy(buf2, sp, len);
buf2[len] = '\0';
if (_nc_capcmp(cp, buf2))
continue;
#define ISRS(s) (!strncmp((s), "is", 2) || !strncmp((s), "rs", 2))
/*
* Theoretically we just passed the test for translation
* (equality once the padding is stripped). However, there
* are a few more hoops that need to be jumped so that
* identical pairs of initialization and reset strings
* don't just refer to each other.
*/
if (ISRS(name) || ISRS(strnames[i]))
if (cap < cp)
continue;
#undef ISRS
expansion = strnames[i];
break;
}
}
/* now check the standard capabilities */
if (!expansion) {
csi = skip_csi(sp);
for (ap = std_caps; ap->from; ap++) {
size_t adj = csi ? 2 : 0;
len = strlen(ap->from);
if (csi && skip_csi(ap->from) != csi)
continue;
if (len > adj
&& strncmp(ap->from + adj, sp + csi, len - adj) == 0) {
expansion = ap->to;
len -= adj;
len += csi;
break;
}
}
}
/* now check for standard-mode sequences */
if (!expansion
&& (csi = skip_csi(sp)) != 0
&& (len = strspn(sp + csi, "0123456789;"))
&& (next = csi + len)
&& ((sp[next] == 'h') || (sp[next] == 'l'))) {
(void) strcpy(buf2, (sp[next] == 'h') ? "ECMA+" : "ECMA-");
(void) strncpy(buf3, sp + csi, len);
buf3[len] = '\0';
len += csi + 1;
expansion = lookup_params(std_modes, buf2, buf3);
}
/* now check for private-mode sequences */
if (!expansion
&& (csi = skip_csi(sp)) != 0
&& sp[csi] == '?'
&& (len = strspn(sp + csi + 1, "0123456789;"))
&& (next = csi + 1 + len)
&& ((sp[next] == 'h') || (sp[next] == 'l'))) {
(void) strcpy(buf2, (sp[next] == 'h') ? "DEC+" : "DEC-");
(void) strncpy(buf3, sp + csi + 1, len);
buf3[len] = '\0';
len += csi + 2;
expansion = lookup_params(private_modes, buf2, buf3);
}
/* now check for ECMA highlight sequences */
if (!expansion
&& (csi = skip_csi(sp)) != 0
&& (len = strspn(sp + csi, "0123456789;")) != 0
&& (next = csi + len)
&& sp[next] == 'm') {
(void) strcpy(buf2, "SGR:");
(void) strncpy(buf3, sp + csi, len);
buf3[len] = '\0';
len += csi + 1;
expansion = lookup_params(ecma_highlights, buf2, buf3);
}
if (!expansion
&& (csi = skip_csi(sp)) != 0
&& sp[csi] == 'm') {
len = csi + 1;
(void) strcpy(buf2, "SGR:");
strcat(buf2, ecma_highlights[0].to);
expansion = buf2;
}
/* now check for scroll region reset */
if (!expansion
&& (csi = skip_csi(sp)) != 0) {
if (sp[csi] == 'r') {
expansion = "RSR";
len = 1;
} else {
(void) sprintf(buf2, "1;%dr", tp_lines);
len = strlen(buf2);
if (strncmp(buf2, sp + csi, len) == 0)
expansion = "RSR";
}
len += csi;
}
/* now check for home-down */
if (!expansion
&& (csi = skip_csi(sp)) != 0) {
(void) sprintf(buf2, "%d;1H", tp_lines);
len = strlen(buf2);
if (strncmp(buf2, sp + csi, len) == 0) {
expansion = "LL";
} else {
(void) sprintf(buf2, "%dH", tp_lines);
len = strlen(buf2);
if (strncmp(buf2, sp + csi, len) == 0) {
expansion = "LL";
}
}
len += csi;
}
/* now look at the expansion we got, if any */
if (expansion) {
(void) sprintf(buf + strlen(buf), "{%s}", expansion);
sp += len - 1;
continue;
} else {
/* couldn't match anything */
buf2[0] = *sp;
buf2[1] = '\0';
(void) strcat(buf, TIC_EXPAND(buf2));
}
}
(void) printf("%s\n", buf);
}
