Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/mg/tty.c	Lines:	0	158	0.0 %
Date:	2017-11-07	Branches:	0	120	0.0 %


/*	$OpenBSD: tty.c,v 1.36 2015/11/18 18:44:50 jasper Exp $	*/

/* This file is in the public domain. */

/*
 * Terminfo display driver
 *
 * Terminfo is a terminal information database and routines to describe
 * terminals on most modern UNIX systems.  Many other systems have adopted
 * this as a reasonable way to allow for widely varying and ever changing
 * varieties of terminal types.	 This should be used where practical.
 */
/*
 * Known problems: If you have a terminal with no clear to end of screen and
 * memory of lines below the ones visible on the screen, display will be
 * wrong in some cases.  I doubt that any such terminal was ever made, but I
 * thought everyone with delete line would have clear to end of screen too...
 *
 * Code for terminals without clear to end of screen and/or clear to end of line
 * has not been extensively tested.
 *
 * Cost calculations are very rough.  Costs of insert/delete line may be far
 * from the truth.  This is accentuated by display.c not knowing about
 * multi-line insert/delete.
 *
 * Using scrolling region vs insert/delete line should probably be based on cost
 * rather than the assumption that scrolling region operations look better.
 */

#include <sys/ioctl.h>
#include <sys/queue.h>
#include <sys/types.h>
#include <sys/time.h>
#include <signal.h>
#include <stdio.h>
#include <term.h>

#include "def.h"

static int	 charcost(const char *);

static int	 cci;
static int	 insdel;	/* Do we have both insert & delete line? */
static const char	*scroll_fwd;	/* How to scroll forward. */

static void	 winchhandler(int);

/* ARGSUSED */
static void
winchhandler(int sig)
{
	winch_flag = 1;
}

/*
 * Initialize the terminal when the editor
 * gets started up.
 */
void
ttinit(void)
{
	int errret;

	if (setupterm(NULL, 1, &errret))
		panic("Terminal setup failed");

	signal(SIGWINCH, winchhandler);
	signal(SIGCONT, winchhandler);
	siginterrupt(SIGWINCH, 1);

	scroll_fwd = scroll_forward;
	if (scroll_fwd == NULL || *scroll_fwd == '\0') {
		/* this is what GNU Emacs does */
		scroll_fwd = parm_down_cursor;
		if (scroll_fwd == NULL || *scroll_fwd == '\0')
			scroll_fwd = "\n";
	}

	if (cursor_address == NULL || cursor_up == NULL)
		panic("This terminal is too stupid to run mg");

	/* set nrow & ncol */
	ttresize();

	if (!clr_eol)
		tceeol = ncol;
	else
		tceeol = charcost(clr_eol);

	/* Estimate cost of inserting a line */
	if (change_scroll_region && scroll_reverse)
		tcinsl = charcost(change_scroll_region) * 2 +
		    charcost(scroll_reverse);
	else if (parm_insert_line)
		tcinsl = charcost(parm_insert_line);
	else if (insert_line)
		tcinsl = charcost(insert_line);
	else
		/* make this cost high enough */
		tcinsl = nrow * ncol;

	/* Estimate cost of deleting a line */
	if (change_scroll_region)
		tcdell = charcost(change_scroll_region) * 2 +
		    charcost(scroll_fwd);
	else if (parm_delete_line)
		tcdell = charcost(parm_delete_line);
	else if (delete_line)
		tcdell = charcost(delete_line);
	else
		/* make this cost high enough */
		tcdell = nrow * ncol;

	/* Flag to indicate that we can both insert and delete lines */
	insdel = (insert_line || parm_insert_line) &&
	    (delete_line || parm_delete_line);

	if (enter_ca_mode)
		/* enter application mode */
		putpad(enter_ca_mode, 1);

	ttresize();
}

/*
 * Re-initialize the terminal when the editor is resumed.
 * The keypad_xmit doesn't really belong here but...
 */
void
ttreinit(void)
{
	/* check if file was modified while we were gone */
	if (fchecktime(curbp) != TRUE) {
		curbp->b_flag |= BFDIRTY;
	}

	if (enter_ca_mode)
		/* enter application mode */
		putpad(enter_ca_mode, 1);

	if (keypad_xmit)
		/* turn on keypad */
		putpad(keypad_xmit, 1);

	ttresize();
}

/*
 * Clean up the terminal, in anticipation of a return to the command
 * interpreter. This is a no-op on the ANSI display. On the SCALD display,
 * it sets the window back to half screen scrolling. Perhaps it should
 * query the display for the increment, and put it back to what it was.
 */
void
tttidy(void)
{
	ttykeymaptidy();

	/* set the term back to normal mode */
	if (exit_ca_mode)
		putpad(exit_ca_mode, 1);
}

/*
 * Move the cursor to the specified origin 0 row and column position. Try to
 * optimize out extra moves; redisplay may have left the cursor in the right
 * location last time!
 */
void
ttmove(int row, int col)
{
	if (ttrow != row || ttcol != col) {
		putpad(tgoto(cursor_address, col, row), 1);
		ttrow = row;
		ttcol = col;
	}
}

/*
 * Erase to end of line.
 */
void
tteeol(void)
{
	int	i;

	if (clr_eol)
		putpad(clr_eol, 1);
	else {
		i = ncol - ttcol;
		while (i--)
			ttputc(' ');
		ttrow = ttcol = HUGE;
	}
}

/*
 * Erase to end of page.
 */
void
tteeop(void)
{
	int	line;

	if (clr_eos)
		putpad(clr_eos, nrow - ttrow);
	else {
		putpad(clr_eol, 1);
		if (insdel)
			ttdell(ttrow + 1, lines, lines - ttrow - 1);
		else {
			/* do it by hand */
			for (line = ttrow + 1; line <= lines; ++line) {
				ttmove(line, 0);
				tteeol();
			}
		}
		ttrow = ttcol = HUGE;
	}
}

/*
 * Make a noise.
 */
void
ttbeep(void)
{
	putpad(bell, 1);
	ttflush();
}

/*
 * Insert nchunk blank line(s) onto the screen, scrolling the last line on
 * the screen off the bottom.  Use the scrolling region if possible for a
 * smoother display.  If there is no scrolling region, use a set of insert
 * and delete line sequences.
 */
void
ttinsl(int row, int bot, int nchunk)
{
	int	i, nl;

	/* One line special cases */
	if (row == bot) {
		ttmove(row, 0);
		tteeol();
		return;
	}
	/* Use scroll region and back index */
	if (change_scroll_region && scroll_reverse) {
		nl = bot - row;
		ttwindow(row, bot);
		ttmove(row, 0);
		while (nchunk--)
			putpad(scroll_reverse, nl);
		ttnowindow();
		return;
	/* else use insert/delete line */
	} else if (insdel) {
		ttmove(1 + bot - nchunk, 0);
		nl = nrow - ttrow;
		if (parm_delete_line)
			putpad(tgoto(parm_delete_line, 0, nchunk), nl);
		else
			/* For all lines in the chunk */
			for (i = 0; i < nchunk; i++)
				putpad(delete_line, nl);
		ttmove(row, 0);

		/* ttmove() changes ttrow */
		nl = nrow - ttrow;

		if (parm_insert_line)
			putpad(tgoto(parm_insert_line, 0, nchunk), nl);
		else
			/* For all lines in the chunk */
			for (i = 0; i < nchunk; i++)
				putpad(insert_line, nl);
		ttrow = HUGE;
		ttcol = HUGE;
	} else
		panic("ttinsl: Can't insert/delete line");
}

/*
 * Delete nchunk line(s) from "row", replacing the bottom line on the
 * screen with a blank line.  Unless we're using the scrolling region,
 * this is done with crafty sequences of insert and delete lines.  The
 * presence of the echo area makes a boundary condition go away.
 */
void
ttdell(int row, int bot, int nchunk)
{
	int	i, nl;

	/* One line special cases */
	if (row == bot) {
		ttmove(row, 0);
		tteeol();
		return;
	}
	/* scrolling region */
	if (change_scroll_region) {
		nl = bot - row;
		ttwindow(row, bot);
		ttmove(bot, 0);
		while (nchunk--)
			putpad(scroll_fwd, nl);
		ttnowindow();
	/* else use insert/delete line */
	} else if (insdel) {
		ttmove(row, 0);
		nl = nrow - ttrow;
		if (parm_delete_line)
			putpad(tgoto(parm_delete_line, 0, nchunk), nl);
		else
			/* For all lines in the chunk */
			for (i = 0; i < nchunk; i++)
				putpad(delete_line, nl);
		ttmove(1 + bot - nchunk, 0);

		/* ttmove() changes ttrow */
		nl = nrow - ttrow;

		if (parm_insert_line)
			putpad(tgoto(parm_insert_line, 0, nchunk), nl);
		else
			/* For all lines in the chunk */
			for (i = 0; i < nchunk; i++)
				putpad(insert_line, nl);
		ttrow = HUGE;
		ttcol = HUGE;
	} else
		panic("ttdell: Can't insert/delete line");
}

/*
 * This routine sets the scrolling window on the display to go from line
 * "top" to line "bot" (origin 0, inclusive).  The caller checks for the
 * pathological 1-line scroll window which doesn't work right and avoids
 * it.  The "ttrow" and "ttcol" variables are set to a crazy value to
 * ensure that the next call to "ttmove" does not turn into a no-op (the
 * window adjustment moves the cursor).
 */
void
ttwindow(int top, int bot)
{
	if (change_scroll_region && (tttop != top || ttbot != bot)) {
		putpad(tgoto(change_scroll_region, bot, top), nrow - ttrow);
		ttrow = HUGE;	/* Unknown.		 */
		ttcol = HUGE;
		tttop = top;	/* Remember region.	 */
		ttbot = bot;
	}
}

/*
 * Switch to full screen scroll. This is used by "spawn.c" just before it
 * suspends the editor and by "display.c" when it is getting ready to
 * exit.  This function does a full screen scroll by telling the terminal
 * to set a scrolling region that is lines or nrow rows high, whichever is
 * larger.  This behavior seems to work right on systems where you can set
 * your terminal size.
 */
void
ttnowindow(void)
{
	if (change_scroll_region) {
		putpad(tgoto(change_scroll_region,
		    (nrow > lines ? nrow : lines) - 1, 0), nrow - ttrow);
		ttrow = HUGE;	/* Unknown.		 */
		ttcol = HUGE;
		tttop = HUGE;	/* No scroll region.	 */
		ttbot = HUGE;
	}
}

/*
 * Set the current writing color to the specified color. Watch for color
 * changes that are not going to do anything (the color is already right)
 * and don't send anything to the display.  The rainbow version does this
 * in putline.s on a line by line basis, so don't bother sending out the
 * color shift.
 */
void
ttcolor(int color)
{
	if (color != tthue) {
		if (color == CTEXT)
			/* normal video */
			putpad(exit_standout_mode, 1);
		else if (color == CMODE)
			/* reverse video */
			putpad(enter_standout_mode, 1);
		/* save the color */
		tthue = color;
	}
}

/*
 * This routine is called by the "refresh the screen" command to try
 * to resize the display. Look in "window.c" to see how
 * the caller deals with a change.
 *
 * We use `newrow' and `newcol' so vtresize() know the difference between the
 * new and old settings.
 */
void
ttresize(void)
{
	int newrow = 0, newcol = 0;

	struct	winsize winsize;

	if (ioctl(0, TIOCGWINSZ, &winsize) == 0) {
		newrow = winsize.ws_row;
		newcol = winsize.ws_col;
	}
	if ((newrow <= 0 || newcol <= 0) &&
	    ((newrow = lines) <= 0 || (newcol = columns) <= 0)) {
		newrow = 24;
		newcol = 80;
	}
	if (vtresize(1, newrow, newcol) != TRUE)
		panic("vtresize failed");
}

/*
 * fake char output for charcost()
 */
/* ARGSUSED */
static int
fakec(int c)
{
	cci++;
	return (0);
}

/* calculate the cost of doing string s */
static int
charcost(const char *s)
{
	cci = 0;

	tputs(s, nrow, fakec);
	return (cci);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: tty.c,v 1.36 2015/11/18 18:44:50 jasper Exp $ */
2
3			/* This file is in the public domain. */
4
5			/*
6			* Terminfo display driver
7			*
8			* Terminfo is a terminal information database and routines to describe
9			* terminals on most modern UNIX systems. Many other systems have adopted
10			* this as a reasonable way to allow for widely varying and ever changing
11			* varieties of terminal types. This should be used where practical.
12			*/
13			/*
14			* Known problems: If you have a terminal with no clear to end of screen and
15			* memory of lines below the ones visible on the screen, display will be
16			* wrong in some cases. I doubt that any such terminal was ever made, but I
17			* thought everyone with delete line would have clear to end of screen too...
18			*
19			* Code for terminals without clear to end of screen and/or clear to end of line
20			* has not been extensively tested.
21			*
22			* Cost calculations are very rough. Costs of insert/delete line may be far
23			* from the truth. This is accentuated by display.c not knowing about
24			* multi-line insert/delete.
25			*
26			* Using scrolling region vs insert/delete line should probably be based on cost
27			* rather than the assumption that scrolling region operations look better.
28			*/
29
30			#include <sys/ioctl.h>
31			#include <sys/queue.h>
32			#include <sys/types.h>
33			#include <sys/time.h>
34			#include <signal.h>
35			#include <stdio.h>
36			#include <term.h>
37
38			#include "def.h"
39
40			static int charcost(const char *);
41
42			static int cci;
43			static int insdel; /* Do we have both insert & delete line? */
44			static const char scroll_fwd; / How to scroll forward. */
45
46			static void winchhandler(int);
47
48			/* ARGSUSED */
49			static void
50			winchhandler(int sig)
51			{
52			winch_flag = 1;
53			}
54
55			/*
56			* Initialize the terminal when the editor
57			* gets started up.
58			*/
59			void
60			ttinit(void)
61			{
62			int errret;
63
64			if (setupterm(NULL, 1, &errret))
65			panic("Terminal setup failed");
66
67			signal(SIGWINCH, winchhandler);
68			signal(SIGCONT, winchhandler);
69			siginterrupt(SIGWINCH, 1);
70
71			scroll_fwd = scroll_forward;
72			if (scroll_fwd == NULL \|\| *scroll_fwd == '\0') {
73			/* this is what GNU Emacs does */
74			scroll_fwd = parm_down_cursor;
75			if (scroll_fwd == NULL \|\| *scroll_fwd == '\0')
76			scroll_fwd = "\n";
77			}
78
79			if (cursor_address == NULL \|\| cursor_up == NULL)
80			panic("This terminal is too stupid to run mg");
81
82			/* set nrow & ncol */
83			ttresize();
84
85			if (!clr_eol)
86			tceeol = ncol;
87			else
88			tceeol = charcost(clr_eol);
89
90			/* Estimate cost of inserting a line */
91			if (change_scroll_region && scroll_reverse)
92			tcinsl = charcost(change_scroll_region) * 2 +
93			charcost(scroll_reverse);
94			else if (parm_insert_line)
95			tcinsl = charcost(parm_insert_line);
96			else if (insert_line)
97			tcinsl = charcost(insert_line);
98			else
99			/* make this cost high enough */
100			tcinsl = nrow * ncol;
101
102			/* Estimate cost of deleting a line */
103			if (change_scroll_region)
104			tcdell = charcost(change_scroll_region) * 2 +
105			charcost(scroll_fwd);
106			else if (parm_delete_line)
107			tcdell = charcost(parm_delete_line);
108			else if (delete_line)
109			tcdell = charcost(delete_line);
110			else
111			/* make this cost high enough */
112			tcdell = nrow * ncol;
113
114			/* Flag to indicate that we can both insert and delete lines */
115			insdel = (insert_line \|\| parm_insert_line) &&
116			(delete_line \|\| parm_delete_line);
117
118			if (enter_ca_mode)
119			/* enter application mode */
120			putpad(enter_ca_mode, 1);
121
122			ttresize();
123			}
124
125			/*
126			* Re-initialize the terminal when the editor is resumed.
127			* The keypad_xmit doesn't really belong here but...
128			*/
129			void
130			ttreinit(void)
131			{
132			/* check if file was modified while we were gone */
133			if (fchecktime(curbp) != TRUE) {
134			curbp->b_flag \|= BFDIRTY;
135			}
136
137			if (enter_ca_mode)
138			/* enter application mode */
139			putpad(enter_ca_mode, 1);
140
141			if (keypad_xmit)
142			/* turn on keypad */
143			putpad(keypad_xmit, 1);
144
145			ttresize();
146			}
147
148			/*
149			* Clean up the terminal, in anticipation of a return to the command
150			* interpreter. This is a no-op on the ANSI display. On the SCALD display,
151			* it sets the window back to half screen scrolling. Perhaps it should
152			* query the display for the increment, and put it back to what it was.
153			*/
154			void
155			tttidy(void)
156			{
157			ttykeymaptidy();
158
159			/* set the term back to normal mode */
160			if (exit_ca_mode)
161			putpad(exit_ca_mode, 1);
162			}
163
164			/*
165			* Move the cursor to the specified origin 0 row and column position. Try to
166			* optimize out extra moves; redisplay may have left the cursor in the right
167			* location last time!
168			*/
169			void
170			ttmove(int row, int col)
171			{
172			if (ttrow != row \|\| ttcol != col) {
173			putpad(tgoto(cursor_address, col, row), 1);
174			ttrow = row;
175			ttcol = col;
176			}
177			}
178
179			/*
180			* Erase to end of line.
181			*/
182			void
183			tteeol(void)
184			{
185			int i;
186
187			if (clr_eol)
188			putpad(clr_eol, 1);
189			else {
190			i = ncol - ttcol;
191			while (i--)
192			ttputc(' ');
193			ttrow = ttcol = HUGE;
194			}
195			}
196
197			/*
198			* Erase to end of page.
199			*/
200			void
201			tteeop(void)
202			{
203			int line;
204
205			if (clr_eos)
206			putpad(clr_eos, nrow - ttrow);
207			else {
208			putpad(clr_eol, 1);
209			if (insdel)
210			ttdell(ttrow + 1, lines, lines - ttrow - 1);
211			else {
212			/* do it by hand */
213			for (line = ttrow + 1; line <= lines; ++line) {
214			ttmove(line, 0);
215			tteeol();
216			}
217			}
218			ttrow = ttcol = HUGE;
219			}
220			}
221
222			/*
223			* Make a noise.
224			*/
225			void
226			ttbeep(void)
227			{
228			putpad(bell, 1);
229			ttflush();
230			}
231
232			/*
233			* Insert nchunk blank line(s) onto the screen, scrolling the last line on
234			* the screen off the bottom. Use the scrolling region if possible for a
235			* smoother display. If there is no scrolling region, use a set of insert
236			* and delete line sequences.
237			*/
238			void
239			ttinsl(int row, int bot, int nchunk)
240			{
241			int i, nl;
242
243			/* One line special cases */
244			if (row == bot) {
245			ttmove(row, 0);
246			tteeol();
247			return;
248			}
249			/* Use scroll region and back index */
250			if (change_scroll_region && scroll_reverse) {
251			nl = bot - row;
252			ttwindow(row, bot);
253			ttmove(row, 0);
254			while (nchunk--)
255			putpad(scroll_reverse, nl);
256			ttnowindow();
257			return;
258			/* else use insert/delete line */
259			} else if (insdel) {
260			ttmove(1 + bot - nchunk, 0);
261			nl = nrow - ttrow;
262			if (parm_delete_line)
263			putpad(tgoto(parm_delete_line, 0, nchunk), nl);
264			else
265			/* For all lines in the chunk */
266			for (i = 0; i < nchunk; i++)
267			putpad(delete_line, nl);
268			ttmove(row, 0);
269
270			/* ttmove() changes ttrow */
271			nl = nrow - ttrow;
272
273			if (parm_insert_line)
274			putpad(tgoto(parm_insert_line, 0, nchunk), nl);
275			else
276			/* For all lines in the chunk */
277			for (i = 0; i < nchunk; i++)
278			putpad(insert_line, nl);
279			ttrow = HUGE;
280			ttcol = HUGE;
281			} else
282			panic("ttinsl: Can't insert/delete line");
283			}
284
285			/*
286			* Delete nchunk line(s) from "row", replacing the bottom line on the
287			* screen with a blank line. Unless we're using the scrolling region,
288			* this is done with crafty sequences of insert and delete lines. The
289			* presence of the echo area makes a boundary condition go away.
290			*/
291			void
292			ttdell(int row, int bot, int nchunk)
293			{
294			int i, nl;
295
296			/* One line special cases */
297			if (row == bot) {
298			ttmove(row, 0);
299			tteeol();
300			return;
301			}
302			/* scrolling region */
303			if (change_scroll_region) {
304			nl = bot - row;
305			ttwindow(row, bot);
306			ttmove(bot, 0);
307			while (nchunk--)
308			putpad(scroll_fwd, nl);
309			ttnowindow();
310			/* else use insert/delete line */
311			} else if (insdel) {
312			ttmove(row, 0);
313			nl = nrow - ttrow;
314			if (parm_delete_line)
315			putpad(tgoto(parm_delete_line, 0, nchunk), nl);
316			else
317			/* For all lines in the chunk */
318			for (i = 0; i < nchunk; i++)
319			putpad(delete_line, nl);
320			ttmove(1 + bot - nchunk, 0);
321
322			/* ttmove() changes ttrow */
323			nl = nrow - ttrow;
324
325			if (parm_insert_line)
326			putpad(tgoto(parm_insert_line, 0, nchunk), nl);
327			else
328			/* For all lines in the chunk */
329			for (i = 0; i < nchunk; i++)
330			putpad(insert_line, nl);
331			ttrow = HUGE;
332			ttcol = HUGE;
333			} else
334			panic("ttdell: Can't insert/delete line");
335			}
336
337			/*
338			* This routine sets the scrolling window on the display to go from line
339			* "top" to line "bot" (origin 0, inclusive). The caller checks for the
340			* pathological 1-line scroll window which doesn't work right and avoids
341			* it. The "ttrow" and "ttcol" variables are set to a crazy value to
342			* ensure that the next call to "ttmove" does not turn into a no-op (the
343			* window adjustment moves the cursor).
344			*/
345			void
346			ttwindow(int top, int bot)
347			{
348			if (change_scroll_region && (tttop != top \|\| ttbot != bot)) {
349			putpad(tgoto(change_scroll_region, bot, top), nrow - ttrow);
350			ttrow = HUGE; /* Unknown. */
351			ttcol = HUGE;
352			tttop = top; /* Remember region. */
353			ttbot = bot;
354			}
355			}
356
357			/*
358			* Switch to full screen scroll. This is used by "spawn.c" just before it
359			* suspends the editor and by "display.c" when it is getting ready to
360			* exit. This function does a full screen scroll by telling the terminal
361			* to set a scrolling region that is lines or nrow rows high, whichever is
362			* larger. This behavior seems to work right on systems where you can set
363			* your terminal size.
364			*/
365			void
366			ttnowindow(void)
367			{
368			if (change_scroll_region) {
369			putpad(tgoto(change_scroll_region,
370			(nrow > lines ? nrow : lines) - 1, 0), nrow - ttrow);
371			ttrow = HUGE; /* Unknown. */
372			ttcol = HUGE;
373			tttop = HUGE; /* No scroll region. */
374			ttbot = HUGE;
375			}
376			}
377
378			/*
379			* Set the current writing color to the specified color. Watch for color
380			* changes that are not going to do anything (the color is already right)
381			* and don't send anything to the display. The rainbow version does this
382			* in putline.s on a line by line basis, so don't bother sending out the
383			* color shift.
384			*/
385			void
386			ttcolor(int color)
387			{
388			if (color != tthue) {
389			if (color == CTEXT)
390			/* normal video */
391			putpad(exit_standout_mode, 1);
392			else if (color == CMODE)
393			/* reverse video */
394			putpad(enter_standout_mode, 1);
395			/* save the color */
396			tthue = color;
397			}
398			}
399
400			/*
401			* This routine is called by the "refresh the screen" command to try
402			* to resize the display. Look in "window.c" to see how
403			* the caller deals with a change.
404			*
405			* We use `newrow' and `newcol' so vtresize() know the difference between the
406			* new and old settings.
407			*/
408			void
409			ttresize(void)
410			{
411			int newrow = 0, newcol = 0;
412
413			struct winsize winsize;
414
415			if (ioctl(0, TIOCGWINSZ, &winsize) == 0) {
416			newrow = winsize.ws_row;
417			newcol = winsize.ws_col;
418			}
419			if ((newrow <= 0 \|\| newcol <= 0) &&
420			((newrow = lines) <= 0 \|\| (newcol = columns) <= 0)) {
421			newrow = 24;
422			newcol = 80;
423			}
424			if (vtresize(1, newrow, newcol) != TRUE)
425			panic("vtresize failed");
426			}
427
428			/*
429			* fake char output for charcost()
430			*/
431			/* ARGSUSED */
432			static int
433			fakec(int c)
434			{
435			cci++;
436			return (0);
437			}
438
439			/* calculate the cost of doing string s */
440			static int
441			charcost(const char *s)
442			{
443			cci = 0;
444
445			tputs(s, nrow, fakec);
446			return (cci);
447			}