Home | History | Annotate | Line # | Download | only in common_source
fancy.c revision 1.3 
      1 /*	$NetBSD: fancy.c,v 1.3 1995/03/21 15:05:40 cgd Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1980, 1993
      5  *	The Regents of the University of California.  All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. All advertising materials mentioning features or use of this software
     16  *    must display the following acknowledgement:
     17  *	This product includes software developed by the University of
     18  *	California, Berkeley and its contributors.
     19  * 4. Neither the name of the University nor the names of its contributors
     20  *    may be used to endorse or promote products derived from this software
     21  *    without specific prior written permission.
     22  *
     23  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     33  * SUCH DAMAGE.
     34  */
     35 
     36 #ifndef lint
     37 #if 0
     38 static char sccsid[] = "@(#)fancy.c	8.1 (Berkeley) 5/31/93";
     39 #else
     40 static char rcsid[] = "$NetBSD: fancy.c,v 1.3 1995/03/21 15:05:40 cgd Exp $";
     41 #endif
     42 #endif /* not lint */
     43 
     44 #include "back.h"
     45 
     46 char	PC;			/* padding character */
     47 char	*BC;			/* backspace sequence */
     48 char	*CD;			/* clear to end of screen sequence */
     49 char	*CE;			/* clear to end of line sequence */
     50 char	*CL;			/* clear screen sequence */
     51 char	*CM;			/* cursor movement instructions */
     52 char	*HO;			/* home cursor sequence */
     53 char	*MC;			/* column cursor movement map */
     54 char	*ML;			/* row cursor movement map */
     55 char	*ND;			/* forward cursor sequence */
     56 char	*UP;			/* up cursor sequence */
     57 
     58 int	lHO;			/* length of HO */
     59 int	lBC;			/* length of BC */
     60 int	lND;			/* length of ND */
     61 int	lUP;			/* length of UP */
     62 int	CO;			/* number of columns */
     63 int	LI;			/* number of lines */
     64 int	*linect;		/* array of lengths of lines on screen
     65 				   (the actual screen is not stored) */
     66 
     67 				/* two letter codes */
     68 char	tcap[] = "bccdceclcmhomcmlndup";
     69 				/* corresponding strings */
     70 char	**tstr[] = { &BC, &CD, &CE, &CL, &CM, &HO, &MC, &ML, &ND, &UP };
     71 
     72 int	buffnum;		/* pointer to output buffer */
     73 
     74 char	tbuf[1024];		/* buffer for decoded termcap entries */
     75 
     76 int	oldb[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
     77 
     78 int	oldr;
     79 int	oldw;
     80 						/* "real" cursor positions, so
     81 						 * it knows when to reposition.
     82 						 * These are -1 if curr and curc
     83 						 * are accurate */
     84 int	realr;
     85 int	realc;
     86 
     87 void	addbuf();
     88 
     89 fboard ()  {
     90 	register int	i, j, l;
     91 
     92 	curmove (0,0);				/* do top line */
     93 	for (i = 0; i < 53; i++)
     94 		fancyc ('_');
     95 
     96 	curmove (15,0);				/* do botttom line */
     97 	for (i = 0; i < 53; i++)
     98 		fancyc ('_');
     99 
    100 	l = 1;					/* do vertical lines */
    101 	for (i = 52; i > -1; i -= 28)  {
    102 		curmove ( (l == 1? 1: 15) ,i);
    103 		fancyc ('|');
    104 		for (j = 0; j < 14; j++)  {
    105 			curmove (curr+l,curc-1);
    106 			fancyc ('|');
    107 		}
    108 		if (i == 24)
    109 			i += 32;
    110 		l = -l;				/* alternate directions */
    111 	}
    112 
    113 	curmove (2,1);				/* label positions 13-18 */
    114 	for (i = 13; i < 18; i++)  {
    115 		fancyc ('1');
    116 		fancyc ((i % 10)+'0');
    117 		curmove (curr,curc+2);
    118 	}
    119 	fancyc ('1');
    120 	fancyc ('8');
    121 
    122 	curmove (2,29);				/* label positions 19-24 */
    123 	fancyc ('1');
    124 	fancyc ('9');
    125 	for (i = 20; i < 25; i++)  {
    126 		curmove (curr,curc+2);
    127 		fancyc ('2');
    128 		fancyc ((i % 10)+'0');
    129 	}
    130 
    131 	curmove (14,1);				/* label positions 12-7 */
    132 	fancyc ('1');
    133 	fancyc ('2');
    134 	for (i = 11; i > 6; i--)  {
    135 		curmove (curr,curc+2);
    136 		fancyc (i > 9? '1': ' ');
    137 		fancyc ((i % 10)+'0');
    138 	}
    139 
    140 	curmove (14,30);			/* label positions 6-1 */
    141 	fancyc ('6');
    142 	for (i = 5; i > 0; i--) {
    143 		curmove (curr,curc+3);
    144 		fancyc (i+'0');
    145 	}
    146 
    147 	for (i = 12; i > 6; i--)		/* print positions 12-7 */
    148 		if (board[i])
    149 			bsect (board[i],13,1+4*(12-i),-1);
    150 
    151 	if (board[0])				/* print red men on bar */
    152 		bsect (board[0],13,25,-1);
    153 
    154 	for (i = 6; i > 0; i--)			/* print positions 6-1 */
    155 		if (board[i])
    156 			bsect (board[i],13,29+4*(6-i),-1);
    157 
    158 	l = (off[1] < 0? off[1]+15: off[1]);	/* print white's home */
    159 	bsect (l,3,54,1);
    160 
    161 	curmove (8,25);				/* print the word BAR */
    162 	fancyc ('B');
    163 	fancyc ('A');
    164 	fancyc ('R');
    165 
    166 	for (i = 13; i < 19; i++)		/* print positions 13-18 */
    167 		if (board[i])
    168 			bsect (board[i],3,1+4*(i-13),1);
    169 
    170 	if (board[25])				/* print white's men on bar */
    171 		bsect (board[25],3,25,1);
    172 
    173 	for (i = 19; i < 25; i++)		/* print positions 19-24 */
    174 		if (board[i])
    175 			bsect (board[i],3,29+4*(i-19),1);
    176 
    177 	l = (off[0] < 0? off[0]+15: off[0]);	/* print red's home */
    178 	bsect (-l,13,54,-1);
    179 
    180 	for (i = 0; i < 26; i++)		/* save board position
    181 						 * for refresh later */
    182 		oldb[i] = board[i];
    183 	oldr = (off[1] < 0? off[1]+15: off[1]);
    184 	oldw = -(off[0] < 0? off[0]+15: off[0]);
    185 }
    186 
    187 /*
    189  * bsect (b,rpos,cpos,cnext)
    190  *	Print the contents of a board position.  "b" has the value of the
    191  * position, "rpos" is the row to start printing, "cpos" is the column to
    192  * start printing, and "cnext" is positive if the position starts at the top
    193  * and negative if it starts at the bottom.  The value of "cpos" is checked
    194  * to see if the position is a player's home, since those are printed
    195  * differently.
    196  */
    197 
    198 bsect (b,rpos,cpos,cnext)
    199 int	b;					/* contents of position */
    200 int	rpos;					/* row of position */
    201 int	cpos;					/* column of position */
    202 int	cnext;					/* direction of position */
    203 
    204 {
    205 	register int	j;			/* index */
    206 	register int	n;			/* number of men on position */
    207 	register int	bct;			/* counter */
    208 	int		k;			/* index */
    209 	char		pc;			/* color of men on position */
    210 
    211 	n = abs(b);				/* initialize n and pc */
    212 	pc = (b > 0? 'r': 'w');
    213 
    214 	if (n < 6 && cpos < 54)			/* position cursor at start */
    215 		curmove (rpos,cpos+1);
    216 	else
    217 		curmove (rpos,cpos);
    218 
    219 	for (j = 0; j < 5; j++)  {		/* print position row by row */
    220 
    221 		for (k = 0; k < 15; k += 5)		/* print men */
    222 			if (n > j+k)
    223 				fancyc (pc);
    224 
    225 		if (j < 4)  {				/* figure how far to
    226 							 * back up for next
    227 							 * row */
    228 			if (n < 6)  {			/* stop if none left */
    229 				if (j+1 == n)
    230 					break;
    231 				bct = 1;		/* single column */
    232 			} else  {
    233 				if (n < 11)  {		/* two columns */
    234 					if (cpos == 54)  {	/* home pos */
    235 						if (j+5 >= n)
    236 							bct = 1;
    237 						else
    238 							bct = 2;
    239 					}
    240 					if (cpos < 54)  {	/* not home */
    241 						if (j+6 >= n)
    242 							bct = 1;
    243 						else
    244 							bct = 2;
    245 					}
    246 				} else  {		/* three columns */
    247 					if (j+10 >= n)
    248 						bct = 2;
    249 					else
    250 						bct = 3;
    251 				}
    252 			}
    253 			curmove (curr+cnext,curc-bct);	/* reposition cursor */
    254 		}
    255 	}
    256 }
    257 
    258 refresh()  {
    260 	register int	i, r, c;
    261 
    262 	r = curr;				/* save current position */
    263 	c = curc;
    264 
    265 	for (i = 12; i > 6; i--)		/* fix positions 12-7 */
    266 		if (board[i] != oldb[i])  {
    267 			fixpos (oldb[i],board[i],13,1+(12-i)*4,-1);
    268 			oldb[i] = board[i];
    269 		}
    270 
    271 	if (board[0] != oldb[0])  {		/* fix red men on bar */
    272 		fixpos (oldb[0],board[0],13,25,-1);
    273 		oldb[0] = board[0];
    274 	}
    275 
    276 	for (i = 6; i > 0; i--)			/* fix positions 6-1 */
    277 		if (board[i] != oldb[i])  {
    278 			fixpos (oldb[i],board[i],13,29+(6-i)*4,-1);
    279 			oldb[i] = board[i];
    280 		}
    281 
    282 	i = -(off[0] < 0? off[0]+15: off[0]);	/* fix white's home */
    283 	if (oldw != i)  {
    284 		fixpos (oldw,i,13,54,-1);
    285 		oldw = i;
    286 	}
    287 
    288 	for (i = 13; i < 19; i++)		/* fix positions 13-18 */
    289 		if (board[i] != oldb[i])  {
    290 			fixpos (oldb[i],board[i],3,1+(i-13)*4,1);
    291 			oldb[i] = board[i];
    292 		}
    293 
    294 	if (board[25] != oldb[25])  {		/* fix white men on bar */
    295 		fixpos (oldb[25],board[25],3,25,1);
    296 		oldb[25] = board[25];
    297 	}
    298 
    299 	for (i = 19; i < 25; i++)		/* fix positions 19-24 */
    300 		if (board[i] != oldb[i])  {
    301 			fixpos (oldb[i],board[i],3,29+(i-19)*4,1);
    302 			oldb[i] = board[i];
    303 		}
    304 
    305 	i = (off[1] < 0? off[1]+15: off[1]);	/* fix red's home */
    306 	if (oldr != i)  {
    307 		fixpos (oldr,i,3,54,1);
    308 		oldr = i;
    309 	}
    310 
    311 	curmove (r,c);				/* return to saved position */
    312 	newpos();
    313 	buflush();
    314 }
    315 
    316 fixpos (old,new,r,c,inc)
    318 int	old, new, r, c, inc;
    319 
    320 {
    321 	register int	o, n, nv;
    322 	int		ov, nc;
    323 	char		col;
    324 
    325 	if (old*new >= 0)  {
    326 		ov = abs(old);
    327 		nv = abs(new);
    328 		col = (old+new > 0? 'r': 'w');
    329 		o = (ov-1)/5;
    330 		n = (nv-1)/5;
    331 		if (o == n)  {
    332 			if (o == 2)
    333 				nc = c+2;
    334 			if (o == 1)
    335 				nc = c < 54? c: c+1;
    336 			if (o == 0)
    337 				nc = c < 54? c+1: c;
    338 			if (ov > nv)
    339 				fixcol (r+inc*(nv-n*5),nc,abs(ov-nv),' ',inc);
    340 			else
    341 				fixcol (r+inc*(ov-o*5),nc,abs(ov-nv),col,inc);
    342 			return;
    343 		} else  {
    344 			if (c < 54)  {
    345 				if (o+n == 1)  {
    346 					if (n)  {
    347 						fixcol (r,c,abs(nv-5),col,inc);
    348 						if (ov != 5)
    349 							fixcol (r+inc*ov,c+1,abs(ov-5),col,inc);
    350 					} else  {
    351 						fixcol (r,c,abs(ov-5),' ',inc);
    352 						if (nv != 5)
    353 							fixcol (r+inc*nv,c+1,abs(nv-5),' ',inc);
    354 					}
    355 					return;
    356 				}
    357 				if (n == 2)  {
    358 					if (ov != 10)
    359 						fixcol (r+inc*(ov-5),c,abs(ov-10),col,inc);
    360 					fixcol (r,c+2,abs(nv-10),col,inc);
    361 				} else  {
    362 					if (nv != 10)
    363 						fixcol (r+inc*(nv-5),c,abs(nv-10),' ',inc);
    364 					fixcol (r,c+2,abs(ov-10),' ',inc);
    365 				}
    366 				return;
    367 			}
    368 			if (n > o)  {
    369 				fixcol (r+inc*(ov%5),c+o,abs(5*n-ov),col,inc);
    370 				if (nv != 5*n)
    371 					fixcol (r,c+n,abs(5*n-nv),col,inc);
    372 			} else  {
    373 				fixcol (r+inc*(nv%5),c+n,abs(5*n-nv),' ',inc);
    374 				if (ov != 5*o)
    375 					fixcol (r,c+o,abs(5*o-ov),' ',inc);
    376 			}
    377 			return;
    378 		}
    379 	}
    380 	nv = abs(new);
    381 	fixcol (r,c+1,nv,new > 0? 'r': 'w',inc);
    382 	if (abs(old) <= abs(new))
    383 		return;
    384 	fixcol (r+inc*new,c+1,abs(old+new),' ',inc);
    385 }
    386 
    387 fixcol (r,c,l,ch,inc)
    388 register int	l, ch;
    389 int		r, c, inc;
    390 
    391 {
    392 	register int	i;
    393 
    394 	curmove (r,c);
    395 	fancyc (ch);
    396 	for (i = 1; i < l; i++)  {
    397 		curmove (curr+inc,curc-1);
    398 		fancyc (ch);
    399 	}
    400 }
    401 
    402 curmove (r,c)
    404 register int	r, c;
    405 
    406 {
    407 	if (curr == r && curc == c)
    408 		return;
    409 	if (realr == -1)  {
    410 		realr = curr;
    411 		realc = curc;
    412 	}
    413 	curr = r;
    414 	curc = c;
    415 }
    416 
    417 newpos ()  {
    418 	register int	r;		/* destination row */
    419 	register int	c;		/* destination column */
    420 	register int	mode = -1;	/* mode of movement */
    421 
    422 	int	count = 1000;		/* character count */
    423 	int	i;			/* index */
    424 	int	j;			/* index */
    425 	int	n;			/* temporary variable */
    426 	char	*m;			/* string containing CM movement */
    427 
    428 
    429 	if (realr == -1)		/* see if already there */
    430 		return;
    431 
    432 	r = curr;			/* set current and dest. positions */
    433 	c = curc;
    434 	curr = realr;
    435 	curc = realc;
    436 
    437 					/* double check position */
    438 	if (curr == r && curc == c)  {
    439 		realr = realc = -1;
    440 		return;
    441 	}
    442 
    443 	if (CM)  {			/* try CM to get there */
    444 		mode = 0;
    445 		m = (char *)tgoto (CM,c,r);
    446 		count = strlen (m);
    447 	}
    448 
    449 					/* try HO and local movement */
    450 	if (HO && (n = r+c*lND+lHO) < count)  {
    451 		mode = 1;
    452 		count = n;
    453 	}
    454 
    455 					/* try various LF combinations */
    456 	if (r >= curr)  {
    457 						/* CR, LF, and ND */
    458 		if ((n = (r-curr)+c*lND+1) < count)  {
    459 			mode = 2;
    460 			count = n;
    461 		}
    462 						/* LF, ND */
    463 		if (c >= curc && (n = (r-curr)+(c-curc)*lND) < count)  {
    464 			mode = 3;
    465 			count = n;
    466 		}
    467 						/* LF, BS */
    468 		if (c < curc && (n = (r-curr)+(curc-c)*lBC) < count)  {
    469 			mode = 4;
    470 			count = n;
    471 		}
    472 	}
    473 
    474 					/* try corresponding UP combinations */
    475 	if (r < curr)  {
    476 						/* CR, UP, and ND */
    477 		if ((n = (curr-r)*lUP+c*lND+1) < count)  {
    478 			mode = 5;
    479 			count = n;
    480 		}
    481 						/* UP and ND */
    482 		if (c >= curc && (n = (curr-r)*lUP+(c-curc)*lND) < count)  {
    483 			mode = 6;
    484 			count = n;
    485 		}
    486 						/* UP and BS */
    487 		if (c < curc && (n = (curr-r)*lUP+(curc-c)*lBC) < count)  {
    488 			mode = 7;
    489 			count = n;
    490 		}
    491 	}
    492 
    493 						/* space over */
    494 	if (curr == r && c > curc && linect[r] < curc && c-curc < count)
    495 		mode = 8;
    496 
    497 	switch (mode)  {
    498 
    499 	case -1:				/* error! */
    500 		write (2,"\r\nInternal cursor error.\r\n",26);
    501 		getout();
    502 
    503 						/* direct cursor motion */
    504 	case  0:
    505 		tputs (m,abs(curr-r),addbuf);
    506 		break;
    507 
    508 						/* relative to "home" */
    509 	case  1:
    510 		tputs (HO,r,addbuf);
    511 		for (i = 0; i < r; i++)
    512 			addbuf ('\012');
    513 		for (i = 0; i < c; i++)
    514 			tputs (ND,1,addbuf);
    515 		break;
    516 
    517 						/* CR and down and over */
    518 	case  2:
    519 		addbuf ('\015');
    520 		for (i = 0; i < r-curr; i++)
    521 			addbuf ('\012');
    522 		for (i = 0; i < c; i++)
    523 			tputs (ND,1,addbuf);
    524 		break;
    525 
    526 						/* down and over */
    527 	case  3:
    528 		for (i = 0; i < r-curr; i++)
    529 			addbuf ('\012');
    530 		for (i = 0; i < c-curc; i++)
    531 			tputs (ND,1,addbuf);
    532 		break;
    533 
    534 						/* down and back */
    535 	case  4:
    536 		for (i = 0; i < r-curr; i++)
    537 			addbuf ('\012');
    538 		for (i = 0; i < curc-c; i++)
    539 			addbuf ('\010');
    540 		break;
    541 
    542 						/* CR and up and over */
    543 	case  5:
    544 		addbuf ('\015');
    545 		for (i = 0; i < curr-r; i++)
    546 			tputs (UP,1,addbuf);
    547 		for (i = 0; i < c; i++)
    548 			tputs (ND,1,addbuf);
    549 		break;
    550 
    551 						/* up and over */
    552 	case  6:
    553 		for (i = 0; i < curr-r; i++)
    554 			tputs (UP,1,addbuf);
    555 		for (i = 0; i < c-curc; i++)
    556 			tputs (ND,1,addbuf);
    557 		break;
    558 
    559 						/* up and back */
    560 	case  7:
    561 		for (i = 0; i < curr-r; i++)
    562 			tputs (UP,1,addbuf);
    563 		for (i = 0; i < curc-c; i++)  {
    564 			if (BC)
    565 				tputs (BC,1,addbuf);
    566 			else
    567 				addbuf ('\010');
    568 		}
    569 		break;
    570 
    571 						/* safe space */
    572 	case  8:
    573 		for (i = 0; i < c-curc; i++)
    574 			addbuf (' ');
    575 	}
    576 
    577 						/* fix positions */
    578 	curr = r;
    579 	curc = c;
    580 	realr = -1;
    581 	realc = -1;
    582 }
    583 
    584 clear ()  {
    586 	register int	i;
    587 
    588 					/* double space if can't clear */
    589 	if (CL == 0)  {
    590 		writel ("\n\n");
    591 		return;
    592 	}
    593 
    594 	curr = curc = 0;		/* fix position markers */
    595 	realr = realc = -1;
    596 	for (i = 0; i < 24; i++)	/* clear line counts */
    597 		linect[i] = -1;
    598 	buffnum = -1;			/* ignore leftover buffer contents */
    599 	tputs (CL,CO,addbuf);		/* put CL in buffer */
    600 }
    601 
    602 tos ()  {				/* home cursor */
    603 	curmove (0,0);
    604 }
    605 
    606 fancyc (c)
    608 register char	c;			/* character to output */
    609 {
    610 	register int	sp;		/* counts spaces in a tab */
    611 
    612 	if (c == '\007')  {		/* bells go in blindly */
    613 		addbuf (c);
    614 		return;
    615 	}
    616 
    617 					/* process tabs, use spaces if the
    618 					 * the tab should be erasing things,
    619 					 * otherwise use cursor movement
    620 					 * routines.  Note this does not use
    621 					 * hardware tabs at all. */
    622 	if (c == '\t')  {
    623 		sp = (curc+8) & (~ 7);		/* compute spaces */
    624 						/* check line length */
    625 		if (linect[curr] >= curc || sp < 4)  {
    626 			for (; sp > curc; sp--)
    627 				addbuf (' ');
    628 			curc = sp;		/* fix curc */
    629 		} else
    630 			curmove (curr,sp);
    631 		return;
    632 	}
    633 
    634 					/* do newline be calling newline */
    635 	if (c == '\n')  {
    636 		newline();
    637 		return;
    638 	}
    639 
    640 					/* ignore any other control chars */
    641 	if (c < ' ')
    642 		return;
    643 
    644 					/* if an erasing space or non-space,
    645 					 * just add it to buffer.  Otherwise
    646 					 * use cursor movement routine, so that
    647 					 * multiple spaces will be grouped
    648 					 * together */
    649 	if (c > ' ' || linect[curr] >= curc)  {
    650 		newpos ();			/* make sure position correct */
    651 		addbuf (c);			/* add character to buffer */
    652 						/* fix line length */
    653 		if (c == ' ' && linect[curr] == curc)
    654 			linect[curr]--;
    655 		else if (linect[curr] < curc)
    656 			linect[curr] = curc;
    657 		curc++;				/* fix curc */
    658 	} else
    659 					/* use cursor movement routine */
    660 		curmove (curr,curc+1);
    661 }
    662 
    663 clend()  {
    665 	register int	i;
    666 	register char	*s;
    667 
    668 
    669 	if (CD)  {
    670 		tputs (CD,CO-curr,addbuf);
    671 		for (i = curr; i < LI; i++)
    672 			linect[i] = -1;
    673 		return;
    674 	}
    675 
    676 	curmove (i = curr,0);
    677 	cline();
    678 	while (curr < LI-1)  {
    679 		curmove (curr+1,0);
    680 		if (linect[curr] > -1)
    681 			cline ();
    682 	}
    683 	curmove (i,0);
    684 }
    685 
    686 cline ()  {
    687 	register int	i;
    688 	register int	c;
    689 	register char	*s;
    690 
    691 	if (curc > linect[curr])
    692 		return;
    693 	newpos ();
    694 	if (CE)  {
    695 		tputs (CE,1,addbuf);
    696 		linect[curr] = curc-1;
    697 	} else  {
    698 		c = curc-1;
    699 		while (linect[curr] > c)  {
    700 			addbuf (' ');
    701 			curc++;
    702 			linect[curr]--;
    703 		}
    704 		curmove (curr,c+1);
    705 	}
    706 }
    707 
    708 newline ()  {
    709 	cline();
    710 	if (curr == LI-1)
    711 		curmove (begscr,0);
    712 	else
    713 		curmove (curr+1,0);
    714 }
    715 
    716 getcaps (s)
    718 register char	*s;
    719 
    720 {
    721 	register char	*code;		/* two letter code */
    722 	register char	***cap;		/* pointer to cap string */
    723 	char		*bufp;		/* pointer to cap buffer */
    724 	char		tentry[1024];	/* temporary uncoded caps buffer */
    725 
    726 	tgetent (tentry,s);		/* get uncoded termcap entry */
    727 
    728 	LI = tgetnum ("li");		/* get number of lines */
    729 	if (LI == -1)
    730 		LI = 12;
    731 	CO = tgetnum ("co");		/* get number of columns */
    732 	if (CO == -1)
    733 		CO = 65;
    734 
    735 	bufp = tbuf;			/* get padding character */
    736 	tgetstr ("pc",&bufp);
    737 	if (bufp != tbuf)
    738 		PC = *tbuf;
    739 	else
    740 		PC = 0;
    741 
    742 	bufp = tbuf;			/* get string entries */
    743 	cap = tstr;
    744 	for (code = tcap; *code; code += 2)
    745 		**cap++ = (char *)tgetstr (code,&bufp);
    746 
    747 					/* get pertinent lengths */
    748 	if (HO)
    749 		lHO = strlen (HO);
    750 	if (BC)
    751 		lBC = strlen (BC);
    752 	else
    753 		lBC = 1;
    754 	if (UP)
    755 		lUP = strlen (UP);
    756 	if (ND)
    757 		lND = strlen (ND);
    758 	if (LI < 24 || CO < 72 || !(CL && UP && ND))
    759 		return (0);
    760 	linect = (int *)calloc (LI+1,sizeof(int));
    761 	return (1);
    762 }
    763