void postprocess_termcap(TERMTYPE *tp, bool has_base)
postprocess_termcap(TERMTYPE * tp, bool has_base)
void postprocess_termcap(TERMTYPE *tp, bool has_base){    char buf[MAX_LINE * 2 + 2];    /*     * 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)) {		strlcpy(buf, carriage_return, MAX_LINE+1);		strlcat(buf, scroll_forward, MAX_LINE+1);		newline = _nc_save_str(buf);	    } else if (PRESENT(carriage_return) && PRESENT(cursor_down)) {		strlcpy(buf, carriage_return, MAX_LINE+1);		strlcat(buf, cursor_down, MAX_LINE+1);		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	*dp, *cp = strtok(other_non_function_keys, ",");	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 && dp[1] == 'm';	/* look at each comma-separated capability in the ko string... */	do {	    for (ap = ko_xlate; ap->from; ap++)		if (strcmp(ap->from, cp) == 0)		    break;	    if (!ap->to)	    {		_nc_warning("unknown capability `%s' in ko string", cp);		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.	     */	    dp = buf2;	    for (cp = tp->Strings[from_ptr->nte_index]; *cp; cp++)	    {		if (cp[0] == '$' && cp[1] == '<')		{		    while (*cp && *cp != '>')			if (!*cp)			    break;		        else			    ++cp;		}		else		    *dp++ = *cp;	    }	    *dp++ = '\0';	    tp->Strings[to_ptr->nte_index] = _nc_save_str(buf2);	} while	    ((cp = strtok((char *)0, ",")) != 0);	/*	 * 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], *bp = buf2;	if (acs_chars)	{	    (void)strcpy(bp, acs_chars);	    bp += strlen(bp);	}	if (acs_ulcorner && acs_ulcorner[1] == '\0')	{	    *bp++ = 'l';	    *bp++ = *acs_ulcorner;	}	if (acs_llcorner && acs_llcorner[1] == '\0')	{	    *bp++ = 'm';	    *bp++ = *acs_llcorner;	}	if (acs_urcorner && acs_urcorner[1] == '\0')	{	    *bp++ = 'k';	    *bp++ = *acs_urcorner;	}	if (acs_lrcorner && acs_lrcorner[1] == '\0')	{	    *bp++ = 'j';	    *bp++ = *acs_lrcorner;	}	if (acs_ltee && acs_ltee[1] == '\0')	{	    *bp++ = 't';	    *bp++ = *acs_ltee;	}	if (acs_rtee && acs_rtee[1] == '\0')	{	    *bp++ = 'u';	    *bp++ = *acs_rtee;	}	if (acs_btee && acs_btee[1] == '\0')	{	    *bp++ = 'v';	    *bp++ = *acs_btee;	}	if (acs_ttee && acs_ttee[1] == '\0')	{	    *bp++ = 'w';	    *bp++ = *acs_ttee;	}	if (acs_hline && acs_hline[1] == '\0')	{	    *bp++ = 'q';	    *bp++ = *acs_hline;	}	if (acs_vline && acs_vline[1] == '\0')	{	    *bp++ = 'x';	    *bp++ = *acs_vline;	}	if (acs_plus)	{	    *bp++ = 'n';	    strcpy(bp, acs_plus);	    bp = buf2 + strlen(buf2);	}	if (bp != buf2)	{	    *bp++ = '\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{{||}}~~");    }}