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