if (nlen >= sizeof(cbuf)) nlen = sizeof(cbuf) - 1;
vs_line(sp, smp, yp, xp)	SCR *sp;	SMAP *smp;	size_t *xp, *yp;{	CHAR_T *kp;	GS *gp;	SMAP *tsmp;	size_t chlen, cno_cnt, cols_per_screen, len, nlen;	size_t offset_in_char, offset_in_line, oldx, oldy;	size_t scno, skip_cols, skip_screens;	int ch, dne, is_cached, is_partial, is_tab;	int list_tab, list_dollar;	char *p, *cbp, *ecbp, cbuf[128];#if defined(DEBUG) && 0	TRACE(sp, "vs_line: row %u: line: %u off: %u\n",	    smp - HMAP, smp->lno, smp->off);#endif	/*	 * If ex modifies the screen after ex output is already on the screen,	 * don't touch it -- we'll get scrolling wrong, at best.	 */	if (!F_ISSET(sp, SC_TINPUT_INFO) && VIP(sp)->totalcount > 1)		return (0);	if (F_ISSET(sp, SC_SCR_EXWROTE) && smp - HMAP != LASTLINE(sp))		return (0);	/*	 * Assume that, if the cache entry for the line is filled in, the	 * line is already on the screen, and all we need to do is return	 * the cursor position.  If the calling routine doesn't need the	 * cursor position, we can just return.	 */	is_cached = SMAP_CACHE(smp);	if (yp == NULL && is_cached)		return (0);	/*	 * A nasty side effect of this routine is that it returns the screen	 * position for the "current" character.  Not pretty, but this is the	 * only routine that really knows what's out there.	 *	 * Move to the line.  This routine can be called by vs_sm_position(),	 * which uses it to fill in the cache entry so it can figure out what	 * the real contents of the screen are.  Because of this, we have to	 * return to whereever we started from.	 */	gp = sp->gp;	(void)gp->scr_cursor(sp, &oldy, &oldx);	(void)gp->scr_move(sp, smp - HMAP, 0);	/* Get the line. */	dne = db_get(sp, smp->lno, 0, &p, &len);	/*	 * Special case if we're printing the info/mode line.  Skip printing	 * the leading number, as well as other minor setup.  The only time	 * this code paints the mode line is when the user is entering text	 * for a ":" command, so we can put the code here instead of dealing	 * with the empty line logic below.  This is a kludge, but it's pretty	 * much confined to this module.	 *	 * Set the number of columns for this screen.	 * Set the number of chars or screens to skip until a character is to	 * be displayed.	 */	cols_per_screen = sp->cols;	if (O_ISSET(sp, O_LEFTRIGHT)) {		skip_screens = 0;		skip_cols = smp->coff;	} else {		skip_screens = smp->soff - 1;		skip_cols = skip_screens * cols_per_screen;	}	list_tab = O_ISSET(sp, O_LIST);	if (F_ISSET(sp, SC_TINPUT_INFO))		list_dollar = 0;	else {		list_dollar = list_tab;		/*		 * If O_NUMBER is set, the line doesn't exist and it's line		 * number 1, i.e., an empty file, display the line number.		 *		 * If O_NUMBER is set, the line exists and the first character		 * on the screen is the first character in the line, display		 * the line number.		 *		 * !!!		 * If O_NUMBER set, decrement the number of columns in the		 * first screen.  DO NOT CHANGE THIS -- IT'S RIGHT!  The		 * rest of the code expects this to reflect the number of		 * columns in the first screen, regardless of the number of		 * columns we're going to skip.		 */		if (O_ISSET(sp, O_NUMBER)) {			cols_per_screen -= O_NUMBER_LENGTH;			if ((!dne || smp->lno == 1) && skip_cols == 0) {				nlen = snprintf(cbuf,				    sizeof(cbuf), O_NUMBER_FMT, smp->lno);				(void)gp->scr_addstr(sp, cbuf, nlen);			}		}	}	/*	 * Special case non-existent lines and the first line of an empty	 * file.  In both cases, the cursor position is 0, but corrected	 * as necessary for the O_NUMBER field, if it was displayed.	 */	if (dne || len == 0) {		/* Fill in the cursor. */		if (yp != NULL && smp->lno == sp->lno) {			*yp = smp - HMAP;			*xp = sp->cols - cols_per_screen;		}		/* If the line is on the screen, quit. */		if (is_cached)			goto ret1;		/* Set line cache information. */		smp->c_sboff = smp->c_eboff = 0;		smp->c_scoff = smp->c_eclen = 0;		/*		 * Lots of special cases for empty lines, but they only apply		 * if we're displaying the first screen of the line.		 */		if (skip_cols == 0)			if (dne) {				if (smp->lno == 1) {					if (list_dollar) {						ch = '$';						goto empty;					}				} else {					ch = '~';					goto empty;				}			} else				if (list_dollar) {					ch = '$';empty:					(void)gp->scr_addstr(sp,					    KEY_NAME(sp, ch), KEY_LEN(sp, ch));				}		(void)gp->scr_clrtoeol(sp);		(void)gp->scr_move(sp, oldy, oldx);		return (0);	}	/*	 * If we just wrote this or a previous line, we cached the starting	 * and ending positions of that line.  The way it works is we keep	 * information about the lines displayed in the SMAP.  If we're	 * painting the screen in the forward direction, this saves us from	 * reformatting the physical line for every line on the screen.  This	 * wins big on binary files with 10K lines.	 *	 * Test for the first screen of the line, then the current screen line,	 * then the line behind us, then do the hard work.  Note, it doesn't	 * do us any good to have a line in front of us -- it would be really	 * hard to try and figure out tabs in the reverse direction, i.e. how	 * many spaces a tab takes up in the reverse direction depends on	 * what characters preceded it.	 *	 * Test for the first screen of the line.	 */	if (skip_cols == 0) {		smp->c_sboff = offset_in_line = 0;		smp->c_scoff = offset_in_char = 0;		p = &p[offset_in_line];		goto display;	}	/* Test to see if we've seen this exact line before. */	if (is_cached) {		offset_in_line = smp->c_sboff;		offset_in_char = smp->c_scoff;		p = &p[offset_in_line];		/* Set cols_per_screen to 2nd and later line length. */		if (O_ISSET(sp, O_LEFTRIGHT) || skip_cols > cols_per_screen)			cols_per_screen = sp->cols;		goto display;	}	/* Test to see if we saw an earlier part of this line before. */	if (smp != HMAP &&	    SMAP_CACHE(tsmp = smp - 1) && tsmp->lno == smp->lno) {		if (tsmp->c_eclen != tsmp->c_ecsize) {			offset_in_line = tsmp->c_eboff;			offset_in_char = tsmp->c_eclen;		} else {			offset_in_line = tsmp->c_eboff + 1;			offset_in_char = 0;		}		/* Put starting info for this line in the cache. */		smp->c_sboff = offset_in_line;		smp->c_scoff = offset_in_char;		p = &p[offset_in_line];		/* Set cols_per_screen to 2nd and later line length. */		if (O_ISSET(sp, O_LEFTRIGHT) || skip_cols > cols_per_screen)			cols_per_screen = sp->cols;		goto display;	}	scno = 0;	offset_in_line = 0;	offset_in_char = 0;	/* Do it the hard way, for leftright scrolling screens. */	if (O_ISSET(sp, O_LEFTRIGHT)) {		for (; offset_in_line < len; ++offset_in_line) {			chlen = (ch = *(u_char *)p++) == '\t' && !list_tab ?			    TAB_OFF(scno) : KEY_LEN(sp, ch);			if ((scno += chlen) >= skip_cols)				break;		}		/* Set cols_per_screen to 2nd and later line length. */		cols_per_screen = sp->cols;		/* Put starting info for this line in the cache. */		if (scno != skip_cols) {			smp->c_sboff = offset_in_line;			smp->c_scoff =			    offset_in_char = chlen - (scno - skip_cols);			--p;		} else {			smp->c_sboff = ++offset_in_line;			smp->c_scoff = 0;		}	}	/* Do it the hard way, for historic line-folding screens. */	else {		for (; offset_in_line < len; ++offset_in_line) {			chlen = (ch = *(u_char *)p++) == '\t' && !list_tab ?			    TAB_OFF(scno) : KEY_LEN(sp, ch);			if ((scno += chlen) < cols_per_screen)				continue;			scno -= cols_per_screen;			/* Set cols_per_screen to 2nd and later line length. */			cols_per_screen = sp->cols;			/*			 * If crossed the last skipped screen boundary, start			 * displaying the characters.			 */			if (--skip_screens == 0)				break;		}		/* Put starting info for this line in the cache. */		if (scno != 0) {			smp->c_sboff = offset_in_line;			smp->c_scoff = offset_in_char = chlen - scno;			--p;		} else {			smp->c_sboff = ++offset_in_line;			smp->c_scoff = 0;		}	}display:	/*	 * Set the number of characters to skip before reaching the cursor	 * character.  Offset by 1 and use 0 as a flag value.  Vs_line is	 * called repeatedly with a valid pointer to a cursor position.	 * Don't fill anything in unless it's the right line and the right	 * character, and the right part of the character...	 */	if (yp == NULL ||	    smp->lno != sp->lno || sp->cno < offset_in_line ||	    offset_in_line + cols_per_screen < sp->cno) {		cno_cnt = 0;		/* If the line is on the screen, quit. */		if (is_cached)			goto ret1;	} else		cno_cnt = (sp->cno - offset_in_line) + 1;	/* This is the loop that actually displays characters. */	ecbp = (cbp = cbuf) + sizeof(cbuf) - 1;	for (is_partial = 0, scno = 0;	    offset_in_line < len; ++offset_in_line, offset_in_char = 0) {		if ((ch = *(u_char *)p++) == '\t' && !list_tab) {			scno += chlen = TAB_OFF(scno) - offset_in_char;			is_tab = 1;		} else {			scno += chlen = KEY_LEN(sp, ch) - offset_in_char;			is_tab = 0;		}		/*		 * Only display up to the right-hand column.  Set a flag if		 * the entire character wasn't displayed for use in setting		 * the cursor.  If reached the end of the line, set the cache		 * info for the screen.  Don't worry about there not being		 * characters to display on the next screen, its lno/off won't		 * match up in that case.		 */		if (scno >= cols_per_screen) {			if (is_tab == 1) {				chlen -= scno - cols_per_screen;				smp->c_ecsize = smp->c_eclen = chlen;				scno = cols_per_screen;			} else {				smp->c_ecsize = chlen;				chlen -= scno - cols_per_screen;				smp->c_eclen = chlen;				if (scno > cols_per_screen)					is_partial = 1;			}			smp->c_eboff = offset_in_line;			/* Terminate the loop. */			offset_in_line = len;		}		/*		 * If the caller wants the cursor value, and this was the		 * cursor character, set the value.  There are two ways to		 * put the cursor on a character -- if it's normal display		 * mode, it goes on the last column of the character.  If		 * it's input mode, it goes on the first.  In normal mode,		 * set the cursor only if the entire character was displayed.		 */		if (cno_cnt &&		    --cno_cnt == 0 && (F_ISSET(sp, SC_TINPUT) || !is_partial)) {			*yp = smp - HMAP;			if (F_ISSET(sp, SC_TINPUT))				*xp = scno - chlen;			else				*xp = scno - 1;			if (O_ISSET(sp, O_NUMBER) &&			    !F_ISSET(sp, SC_TINPUT_INFO) && skip_cols == 0)				*xp += O_NUMBER_LENGTH;			/* If the line is on the screen, quit. */			if (is_cached)				goto ret1;		}		/* If the line is on the screen, don't display anything. */		if (is_cached)			continue;#define	FLUSH {								\	*cbp = '\0';							\	(void)gp->scr_addstr(sp, cbuf, cbp - cbuf);			\	cbp = cbuf;							\}		/*		 * Display the character.  We do tab expansion here because		 * the screen interface doesn't have any way to set the tab		 * length.  Note, it's theoretically possible for chlen to		 * be larger than cbuf, if the user set a impossibly large		 * tabstop.		 */		if (is_tab)			while (chlen--) {				if (cbp >= ecbp)					FLUSH;				*cbp++ = TABCH;			}		else {			if (cbp + chlen >= ecbp)				FLUSH;			for (kp = KEY_NAME(sp, ch) + offset_in_char; chlen--;)				*cbp++ = *kp++;		}	}	if (scno < cols_per_screen) {		/* If didn't paint the whole line, update the cache. */		smp->c_ecsize = smp->c_eclen = KEY_LEN(sp, ch);		smp->c_eboff = len - 1;		/*		 * If not the info/mode line, and O_LIST set, and at the		 * end of the line, and the line ended on this screen,		 * add a trailing $.		 */		if (list_dollar) {			++scno;			chlen = KEY_LEN(sp, '$');			if (cbp + chlen >= ecbp)				FLUSH;			for (kp = KEY_NAME(sp, '$'); chlen--;)				*cbp++ = *kp++;		}		/* If still didn't paint the whole line, clear the rest. */		if (scno < cols_per_screen)			(void)gp->scr_clrtoeol(sp);	}	/* Flush any buffered characters. */	if (cbp > cbuf)		FLUSH;ret1:	(void)gp->scr_move(sp, oldy, oldx);	return (0);}