static void
postprocess_terminfo(TERMTYPE * tp)
{
/*
* TERMINFO-TO-TERMINFO MAPPINGS FOR SOURCE TRANSLATION
* ----------------------------------------------------------------------
*/
/*
* Translate AIX forms characters.
*/
if (PRESENT(box_chars_1)) {
char buf2[MAX_TERMCAP_LENGTH];
string_desc result;
_nc_str_init(&result, buf2, sizeof(buf2));
_nc_safe_strcat(&result, acs_chars);
append_acs0 (&result, 'l', box_chars_1[0]); /* ACS_ULCORNER */
append_acs0 (&result, 'q', box_chars_1[1]); /* ACS_HLINE */
append_acs0 (&result, 'k', box_chars_1[2]); /* ACS_URCORNER */
append_acs0 (&result, 'x', box_chars_1[3]); /* ACS_VLINE */
append_acs0 (&result, 'j', box_chars_1[4]); /* ACS_LRCORNER */
append_acs0 (&result, 'm', box_chars_1[5]); /* ACS_LLCORNER */
append_acs0 (&result, 'w', box_chars_1[6]); /* ACS_TTEE */
append_acs0 (&result, 'u', box_chars_1[7]); /* ACS_RTEE */
append_acs0 (&result, 'v', box_chars_1[8]); /* ACS_BTEE */
append_acs0 (&result, 't', box_chars_1[9]); /* ACS_LTEE */
append_acs0 (&result, 'n', box_chars_1[10]); /* ACS_PLUS */
if (buf2[0]) {
acs_chars = _nc_save_str(buf2);
_nc_warning("acsc string synthesized from AIX capabilities");
box_chars_1 = ABSENT_STRING;
}
}
/*
* ----------------------------------------------------------------------
*/
}
static int
relative_move(string_desc * target, int from_y, int from_x, int to_y, int
to_x, bool ovw)
/* move via local motions (cuu/cuu1/cud/cud1/cub1/cub/cuf1/cuf/vpa/hpa) */
{
string_desc save;
int n, vcost = 0, hcost = 0;
(void) _nc_str_copy(&save, target);
if (to_y != from_y) {
vcost = INFINITY;
if (row_address != 0
&& _nc_safe_strcat(target, TPARM_1(row_address, to_y))) {
vcost = SP->_vpa_cost;
}
if (to_y > from_y) {
n = (to_y - from_y);
if (parm_down_cursor
&& SP->_cud_cost < vcost
&& _nc_safe_strcat(_nc_str_copy(target, &save),
TPARM_1(parm_down_cursor, n))) {
vcost = SP->_cud_cost;
}
if (cursor_down
&& (*cursor_down != '\n' || SP->_nl)
&& (n * SP->_cud1_cost < vcost)) {
vcost = repeated_append(_nc_str_copy(target, &save), 0,
SP->_cud1_cost, n, cursor_down);
}
} else { /* (to_y < from_y) */
n = (from_y - to_y);
if (parm_up_cursor
&& SP->_cuu_cost < vcost
&& _nc_safe_strcat(_nc_str_copy(target, &save),
TPARM_1(parm_up_cursor, n))) {
vcost = SP->_cuu_cost;
}
if (cursor_up && (n * SP->_cuu1_cost < vcost)) {
vcost = repeated_append(_nc_str_copy(target, &save), 0,
SP->_cuu1_cost, n, cursor_up);
}
}
if (vcost == INFINITY)
return (INFINITY);
}
save = *target;
if (to_x != from_x) {
char str[OPT_SIZE];
string_desc check;
hcost = INFINITY;
if (column_address
&& _nc_safe_strcat(_nc_str_copy(target, &save),
TPARM_1(column_address, to_x))) {
hcost = SP->_hpa_cost;
}
if (to_x > from_x) {
n = to_x - from_x;
if (parm_right_cursor
&& SP->_cuf_cost < hcost
&& _nc_safe_strcat(_nc_str_copy(target, &save),
TPARM_1(parm_right_cursor, n))) {
hcost = SP->_cuf_cost;
}
if (cursor_right) {
int lhcost = 0;
(void) _nc_str_init(&check, str, sizeof(str));
#if USE_HARD_TABS
/* use hard tabs, if we have them, to do as much as possible */
if (init_tabs > 0 && tab) {
int nxt, fr;
for (fr = from_x; (nxt = NEXTTAB(fr)) <= to_x; fr = nxt) {
lhcost = repeated_append(&check, lhcost,
SP->_ht_cost, 1, tab);
if (lhcost == INFINITY)
break;
}
n = to_x - fr;
from_x = fr;
}
#endif /* USE_HARD_TABS */
if (n <= 0 || n >= (int) check.s_size)
ovw = FALSE;
#if BSD_TPUTS
/*
* If we're allowing BSD-style padding in tputs, don't generate
* a string with a leading digit. Otherwise, that will be
* interpreted as a padding value rather than sent to the
* screen.
*/
if (ovw
&& n > 0
&& n < (int) check.s_size
&& vcost == 0
&& str[0] == '\0') {
int wanted = CharOf(WANT_CHAR(to_y, from_x));
if (is8bits(wanted) && isdigit(wanted))
ovw = FALSE;
}
#endif
/*
* If we have no attribute changes, overwrite is cheaper.
* Note: must suppress this by passing in ovw = FALSE whenever
* WANT_CHAR would return invalid data. In particular, this
* is true between the time a hardware scroll has been done
* and the time the structure WANT_CHAR would access has been
* updated.
*/
if (ovw) {
int i;
for (i = 0; i < n; i++) {
NCURSES_CH_T ch = WANT_CHAR(to_y, from_x + i);
if (!SameAttrOf(ch, SCREEN_ATTRS(SP))
#if USE_WIDEC_SUPPORT
|| !Charable(ch)
#endif
) {
ovw = FALSE;
break;
}
}
}
if (ovw) {
int i;
for (i = 0; i < n; i++)
*check.s_tail++ = CharOf(WANT_CHAR(to_y, from_x + i));
*check.s_tail = '\0';
check.s_size -= n;
lhcost += n * SP->_char_padding;
} else {
lhcost = repeated_append(&check, lhcost, SP->_cuf1_cost,
n, cursor_right);
}
if (lhcost < hcost
&& _nc_safe_strcat(_nc_str_copy(target, &save), str)) {
hcost = lhcost;
}
}
} else { /* (to_x < from_x) */
n = from_x - to_x;
if (parm_left_cursor
&& SP->_cub_cost < hcost
&& _nc_safe_strcat(_nc_str_copy(target, &save),
TPARM_1(parm_left_cursor, n))) {
hcost = SP->_cub_cost;
}
if (cursor_left) {
int lhcost = 0;
(void) _nc_str_init(&check, str, sizeof(str));
#if USE_HARD_TABS
if (init_tabs > 0 && back_tab) {
int nxt, fr;
for (fr = from_x; (nxt = LASTTAB(fr)) >= to_x; fr = nxt) {
lhcost = repeated_append(&check, lhcost,
SP->_cbt_cost, 1, back_tab);
if (lhcost == INFINITY)
break;
}
n = fr - to_x;
}
#endif /* USE_HARD_TABS */
lhcost = repeated_append(&check, lhcost, SP->_cub1_cost, n, cursor_left);
if (lhcost < hcost
&& _nc_safe_strcat(_nc_str_copy(target, &save), str)) {
hcost = lhcost;
}
}
}
if (hcost == INFINITY)
return (INFINITY);
}
return (vcost + hcost);
}
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{{||}}~~");
}
}
_nc_str_null
(string_desc * dst, size_t len)
{
return _nc_str_init(dst, 0, len);
}
