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