xref: /netbsd/games/larn/io.c (revision bf9ec67e) 
1 /*	$NetBSD: io.c,v 1.14 2002/05/26 00:12:13 wiz Exp $	*/
2 
3 /*
4  * io.c			 Larn is copyrighted 1986 by Noah Morgan.
5  *
6  * Below are the functions in this file:
7  *
8  * setupvt100() 	Subroutine to set up terminal in correct mode for game
9  * clearvt100()  	Subroutine to clean up terminal when the game is over
10  * lgetchar() 		Routine to read in one character from the terminal
11  * scbr()			Function to set cbreak -echo for the terminal
12  * sncbr()			Function to set -cbreak echo for the terminal
13  * newgame() 		Subroutine to save the initial time and seed rnd()
14  *
15  * FILE OUTPUT ROUTINES
16  *
17  * lprintf(format,args . . .)	printf to the output buffer lprint(integer)
18  * end binary integer to output buffer lwrite(buf,len)
19  * rite a buffer to the output buffer lprcat(str)
20  * ent string to output buffer
21  *
22  * FILE OUTPUT MACROS (in header.h)
23  *
24  * lprc(character)				put the character into the output
25  * buffer
26  *
27  * FILE INPUT ROUTINES
28  *
29  * long lgetc()				read one character from input buffer
30  * long lrint()				read one integer from input buffer
31  * lrfill(address,number)		put input bytes into a buffer char
32  * *lgetw()				get a whitespace ended word from
33  * input char *lgetl()				get a \n or EOF ended line
34  * from input
35  *
36  * FILE OPEN / CLOSE ROUTINES
37  *
38  * lcreat(filename)			create a new file for write
39  * lopen(filename)				open a file for read
40  * lappend(filename)			open for append to an existing file
41  * lrclose()					close the input file
42  * lwclose()					close output file lflush()
43  * lush the output buffer
44  *
45  * Other Routines
46  *
47  * cursor(x,y)					position cursor at [x,y]
48  * cursors()					position cursor at [1,24]
49  * (saves memory) cl_line(x,y)         		Clear line at [1,y] and leave
50  * cursor at [x,y] cl_up(x,y)    				Clear screen
51  * from [x,1] to current line. cl_dn(x,y)
52  * lear screen from [1,y] to end of display. standout(str)
53  * rint the string in standout mode. set_score_output()
54  * alled when output should be literally printed. * xputchar(ch)
55  * rint one character in decoded output buffer. * flush_buf()
56  * lush buffer with decoded output. * init_term()
57  * erminal initialization -- setup termcap info *	char *tmcapcnv(sd,ss)
58  * outine to convert VT100 \33's to termcap format beep()
59  * e to emit a beep if enabled (see no-beep in .larnopts)
60  *
61  * Note: ** entries are available only in termcap mode.
62  */
63 #include <sys/cdefs.h>
64 #ifndef lint
65 __RCSID("$NetBSD: io.c,v 1.14 2002/05/26 00:12:13 wiz Exp $");
66 #endif /* not lint */
67 
68 #include "header.h"
69 #include "extern.h"
70 #include <string.h>
71 #include <unistd.h>
72 #include <stdlib.h>
73 #include <termcap.h>
74 #include <fcntl.h>
75 #include <errno.h>
76 
77 #ifdef TERMIO
78 #include <termio.h>
79 #define sgttyb termio
80 #define stty(_a,_b) ioctl(_a,TCSETA,_b)
81 #define gtty(_a,_b) ioctl(_a,TCGETA,_b)
82 #endif
83 #ifdef TERMIOS
84 #include <termios.h>
85 #define sgttyb termios
86 #define stty(_a,_b) tcsetattr(_a,TCSADRAIN,_b)
87 #define gtty(_a,_b) tcgetattr(_a,_b)
88 #endif
89 
90 #if defined(TERMIO) || defined(TERMIOS)
91 static int      rawflg = 0;
92 static char     saveeof, saveeol;
93 #define doraw(_a) \
94 	if(!rawflg) { \
95 		++rawflg; \
96 		saveeof = _a.c_cc[VMIN]; \
97 		saveeol = _a.c_cc[VTIME]; \
98 	} \
99     	_a.c_cc[VMIN] = 1; \
100 	_a.c_cc[VTIME] = 1; \
101 	_a.c_lflag &= ~(ICANON|ECHO|ECHOE|ECHOK|ECHONL)
102 #define unraw(_a) \
103 	_a.c_cc[VMIN] = saveeof; \
104 	_a.c_cc[VTIME] = saveeol; \
105 	_a.c_lflag |= ICANON|ECHO|ECHOE|ECHOK|ECHONL
106 
107 #else	/* not TERMIO or TERMIOS */
108 
109 #ifndef BSD
110 #define CBREAK RAW		/* V7 has no CBREAK */
111 #endif
112 
113 #define doraw(_a) (_a.sg_flags |= CBREAK,_a.sg_flags &= ~ECHO)
114 #define unraw(_a) (_a.sg_flags &= ~CBREAK,_a.sg_flags |= ECHO)
115 #include <sgtty.h>
116 #endif	/* not TERMIO or TERMIOS */
117 
118 #ifndef NOVARARGS	/* if we have varargs */
119 #include <stdarg.h>
120 #else	/* NOVARARGS */	/* if we don't have varargs */
121 typedef char   *va_list;
122 #define va_dcl int va_alist;
123 #define va_start(plist) plist = (char *) &va_alist
124 #define va_end(plist)
125 #define va_arg(plist,mode) ((mode *)(plist += sizeof(mode)))[-1]
126 #endif	/* NOVARARGS */
127 
128 #define LINBUFSIZE 128	/* size of the lgetw() and lgetl() buffer */
129 int             lfd;	/* output file numbers */
130 int             fd;	/* input file numbers */
131 static struct sgttyb ttx;/* storage for the tty modes */
132 static int      ipoint = MAXIBUF, iepoint = MAXIBUF;	/* input buffering
133 							 * pointers    */
134 static char     lgetwbuf[LINBUFSIZE];	/* get line (word) buffer */
135 
136 /*
137  *	setupvt100() Subroutine to set up terminal in correct mode for game
138  *
139  *	Attributes off, clear screen, set scrolling region, set tty mode
140  */
141 void
142 setupvt100()
143 {
144 	clear();
145 	setscroll();
146 	scbr();			/* system("stty cbreak -echo"); */
147 }
148 
149 /*
150  *	clearvt100() 	Subroutine to clean up terminal when the game is over
151  *
152  *	Attributes off, clear screen, unset scrolling region, restore tty mode
153  */
154 void
155 clearvt100()
156 {
157 	resetscroll();
158 	clear();
159 	sncbr();		/* system("stty -cbreak echo"); */
160 }
161 
162 /*
163  *	lgetchar() 	Routine to read in one character from the terminal
164  */
165 int
166 lgetchar()
167 {
168 	char            byt;
169 #ifdef EXTRA
170 	c[BYTESIN]++;
171 #endif
172 	lflush();		/* be sure output buffer is flushed */
173 	read(0, &byt, 1);	/* get byte from terminal */
174 	return (byt);
175 }
176 
177 /*
178  *	scbr()		Function to set cbreak -echo for the terminal
179  *
180  *	like: system("stty cbreak -echo")
181  */
182 void
183 scbr()
184 {
185 	gtty(0, &ttx);
186 	doraw(ttx);
187 	stty(0, &ttx);
188 }
189 
190 /*
191  *	sncbr()		Function to set -cbreak echo for the terminal
192  *
193  *	like: system("stty -cbreak echo")
194  */
195 void
196 sncbr()
197 {
198 	gtty(0, &ttx);
199 	unraw(ttx);
200 	stty(0, &ttx);
201 }
202 
203 /*
204  *	newgame() 	Subroutine to save the initial time and seed rnd()
205  */
206 void
207 newgame()
208 {
209 	long  *p, *pe;
210 	for (p = c, pe = c + 100; p < pe; *p++ = 0);
211 	time(&initialtime);
212 	srand(initialtime);
213 	lcreat((char *) 0);	/* open buffering for output to terminal */
214 }
215 
216 /*
217  *	lprintf(format,args . . .)		printf to the output buffer
218  *		char *format;
219  *		??? args . . .
220  *
221  *	Enter with the format string in "format", as per printf() usage
222  *		and any needed arguments following it
223  *	Note: lprintf() only supports %s, %c and %d, with width modifier and left
224  *		or right justification.
225  *	No correct checking for output buffer overflow is done, but flushes
226  *		are done beforehand if needed.
227  *	Returns nothing of value.
228  */
229 #ifdef lint
230 /* VARARGS */
231 lprintf(str)
232 	char           *str;
233 {
234 	char           *str2;
235 	str2 = str;
236 	str = str2;		/* to make lint happy */
237 }
238 /* VARARGS */
239 sprintf(str)
240 	char           *str;
241 {
242 	char           *str2;
243 	str2 = str;
244 	str = str2;		/* to make lint happy */
245 }
246 #else	/* lint */
247 /* VARARGS */
248 void lprintf(const char *fmt, ...)
249 {
250 	va_list         ap;	/* pointer for variable argument list */
251 	char  *outb, *tmpb;
252 	long   wide, left, cont, n;	/* data for lprintf	 */
253 	char            db[12];	/* %d buffer in lprintf	 */
254 
255 	va_start(ap, fmt);
256 	if (lpnt >= lpend)
257 		lflush();
258 	outb = lpnt;
259 	for (;;) {
260 		while (*fmt != '%')
261 			if (*fmt)
262 				*outb++ = *fmt++;
263 			else {
264 				lpnt = outb;
265 				va_end(ap);
266 				return;
267 			}
268 		wide = 0;
269 		left = 1;
270 		cont = 1;
271 		while (cont)
272 			switch (*(++fmt)) {
273 			case 'd':
274 				n = va_arg(ap, long);
275 				if (n < 0) {
276 					n = -n;
277 					*outb++ = '-';
278 					if (wide)
279 						--wide;
280 				}
281 				tmpb = db + 11;
282 				*tmpb = (char) (n % 10 + '0');
283 				while (n > 9)
284 					*(--tmpb) = (char) ((n /= 10) % 10 + '0');
285 				if (wide == 0)
286 					while (tmpb < db + 12)
287 						*outb++ = *tmpb++;
288 				else {
289 					wide -= db - tmpb + 12;
290 					if (left)
291 						while (wide-- > 0)
292 							*outb++ = ' ';
293 					while (tmpb < db + 12)
294 						*outb++ = *tmpb++;
295 					if (left == 0)
296 						while (wide-- > 0)
297 							*outb++ = ' ';
298 				}
299 				cont = 0;
300 				break;
301 
302 			case 's':
303 				tmpb = va_arg(ap, char *);
304 				if (wide == 0) {
305 					while ((*outb++ = *tmpb++) != '\0')
306 						continue;
307 					--outb;
308 				} else {
309 					n = wide - strlen(tmpb);
310 					if (left)
311 						while (n-- > 0)
312 							*outb++ = ' ';
313 					while ((*outb++ = *tmpb++) != '\0')
314 						continue;
315 					--outb;
316 					if (left == 0)
317 						while (n-- > 0)
318 							*outb++ = ' ';
319 				}
320 				cont = 0;
321 				break;
322 
323 			case 'c':
324 				*outb++ = va_arg(ap, int);
325 				cont = 0;
326 				break;
327 
328 			case '0':
329 			case '1':
330 			case '2':
331 			case '3':
332 			case '4':
333 			case '5':
334 			case '6':
335 			case '7':
336 			case '8':
337 			case '9':
338 				wide = 10 * wide + *fmt - '0';
339 				break;
340 
341 			case '-':
342 				left = 0;
343 				break;
344 
345 			default:
346 				*outb++ = *fmt;
347 				cont = 0;
348 				break;
349 			};
350 		fmt++;
351 	}
352 	va_end(ap);
353 }
354 #endif	/* lint */
355 
356 /*
357  *	lprint(long-integer)	send binary integer to output buffer
358  *		long integer;
359  *
360  *		+---------+---------+---------+---------+
361  *		|   high  |	    |	      |	  low	|
362  *		|  order  |	    |	      |  order	|
363  *		|   byte  |	    |	      |	  byte	|
364  *		+---------+---------+---------+---------+
365  *	        31  ---  24 23 --- 16 15 ---  8 7  ---   0
366  *
367  *	The save order is low order first, to high order (4 bytes total)
368  *	and is written to be system independent.
369  *	No checking for output buffer overflow is done, but flushes if needed!
370  *	Returns nothing of value.
371  */
372 void
373 lprint(x)
374 	long   x;
375 {
376 	if (lpnt >= lpend)
377 		lflush();
378 	*lpnt++ = 255 & x;
379 	*lpnt++ = 255 & (x >> 8);
380 	*lpnt++ = 255 & (x >> 16);
381 	*lpnt++ = 255 & (x >> 24);
382 }
383 
384 /*
385  *	lwrite(buf,len)		write a buffer to the output buffer
386  *		char *buf;
387  *		int len;
388  *
389  *	Enter with the address and number of bytes to write out
390  *	Returns nothing of value
391  */
392 void
393 lwrite(buf, len)
394 	char  *buf;
395 	int             len;
396 {
397 	char  *str;
398 	int    num2;
399 	if (len > 399) {	/* don't copy data if can just write it */
400 #ifdef EXTRA
401 		c[BYTESOUT] += len;
402 #endif
403 
404 #ifndef VT100
405 		for (str = buf; len > 0; --len)
406 			lprc(*str++);
407 #else	/* VT100 */
408 		lflush();
409 		write(lfd, buf, len);
410 #endif	/* VT100 */
411 	} else
412 		while (len) {
413 			if (lpnt >= lpend)
414 				lflush();	/* if buffer is full flush it	 */
415 			num2 = lpbuf + BUFBIG - lpnt;	/* # bytes left in
416 							 * output buffer	 */
417 			if (num2 > len)
418 				num2 = len;
419 			str = lpnt;
420 			len -= num2;
421 			while (num2--)
422 				*str++ = *buf++;	/* copy in the bytes */
423 			lpnt = str;
424 		}
425 }
426 
427 /*
428  *	long lgetc()	Read one character from input buffer
429  *
430  *  Returns 0 if EOF, otherwise the character
431  */
432 long
433 lgetc()
434 {
435 	int    i;
436 	if (ipoint != iepoint)
437 		return (inbuffer[ipoint++]);
438 	if (iepoint != MAXIBUF)
439 		return (0);
440 	if ((i = read(fd, inbuffer, MAXIBUF)) <= 0) {
441 		if (i != 0)
442 			write(1, "error reading from input file\n", 30);
443 		iepoint = ipoint = 0;
444 		return (0);
445 	}
446 	ipoint = 1;
447 	iepoint = i;
448 	return (*inbuffer);
449 }
450 
451 /*
452  *	long lrint()	Read one integer from input buffer
453  *
454  *		+---------+---------+---------+---------+
455  *		|   high  |	    |	      |	  low	|
456  *		|  order  |	    |	      |  order	|
457  *		|   byte  |	    |	      |	  byte	|
458  *		+---------+---------+---------+---------+
459  *	       31  ---  24 23 --- 16 15 ---  8 7  ---   0
460  *
461  *	The save order is low order first, to high order (4 bytes total)
462  *	Returns the int read
463  */
464 long
465 lrint()
466 {
467 	unsigned long i;
468 	i = 255 & lgetc();
469 	i |= (255 & lgetc()) << 8;
470 	i |= (255 & lgetc()) << 16;
471 	i |= (255 & lgetc()) << 24;
472 	return (i);
473 }
474 
475 /*
476  *	lrfill(address,number)		put input bytes into a buffer
477  *		char *address;
478  *		int number;
479  *
480  *	Reads "number" bytes into the buffer pointed to by "address".
481  *	Returns nothing of value
482  */
483 void
484 lrfill(adr, num)
485 	char  *adr;
486 	int             num;
487 {
488 	char  *pnt;
489 	int    num2;
490 	while (num) {
491 		if (iepoint == ipoint) {
492 			if (num > 5) {	/* fast way */
493 				if (read(fd, adr, num) != num)
494 					write(2, "error reading from input file\n", 30);
495 				num = 0;
496 			} else {
497 				*adr++ = lgetc();
498 				--num;
499 			}
500 		} else {
501 			num2 = iepoint - ipoint;	/* # of bytes left in
502 							 * the buffer	 */
503 			if (num2 > num)
504 				num2 = num;
505 			pnt = inbuffer + ipoint;
506 			num -= num2;
507 			ipoint += num2;
508 			while (num2--)
509 				*adr++ = *pnt++;
510 		}
511 	}
512 }
513 
514 /*
515  *	char *lgetw()			Get a whitespace ended word from input
516  *
517  *	Returns pointer to a buffer that contains word.  If EOF, returns a NULL
518  */
519 char *
520 lgetw()
521 {
522 	char  *lgp, cc;
523 	int    n = LINBUFSIZE, quote = 0;
524 	lgp = lgetwbuf;
525 	do
526 		cc = lgetc();
527 	while ((cc <= 32) && (cc > '\0'));	/* eat whitespace */
528 	for (;; --n, cc = lgetc()) {
529 		if ((cc == '\0') && (lgp == lgetwbuf))
530 			return (NULL);	/* EOF */
531 		if ((n <= 1) || ((cc <= 32) && (quote == 0))) {
532 			*lgp = '\0';
533 			return (lgetwbuf);
534 		}
535 		if (cc != '"')
536 			*lgp++ = cc;
537 		else
538 			quote ^= 1;
539 	}
540 }
541 
542 /*
543  *	char *lgetl()	Function to read in a line ended by newline or EOF
544  *
545  * Returns pointer to a buffer that contains the line.  If EOF, returns NULL
546  */
547 char *
548 lgetl()
549 {
550 	int    i = LINBUFSIZE, ch;
551 	char  *str = lgetwbuf;
552 	for (;; --i) {
553 		if ((*str++ = ch = lgetc()) == '\0') {
554 			if (str == lgetwbuf + 1)
555 				return (NULL);	/* EOF */
556 	ot:		*str = '\0';
557 			return (lgetwbuf);	/* line ended by EOF */
558 		}
559 		if ((ch == '\n') || (i <= 1))
560 			goto ot;/* line ended by \n */
561 	}
562 }
563 
564 /*
565  *	lcreat(filename)			Create a new file for write
566  *		char *filename;
567  *
568  *	lcreat((char*)0); means to the terminal
569  *	Returns -1 if error, otherwise the file descriptor opened.
570  */
571 int
572 lcreat(str)
573 	char *str;
574 {
575 	lpnt = lpbuf;
576 	lpend = lpbuf + BUFBIG;
577 	if (str == NULL)
578 		return (lfd = 1);
579 	if ((lfd = creat(str, 0644)) < 0) {
580 		lfd = 1;
581 		lprintf("error creating file <%s>: %s\n", str,
582 			strerror(errno));
583 		lflush();
584 		return (-1);
585 	}
586 	return (lfd);
587 }
588 
589 /*
590  *	lopen(filename)			Open a file for read
591  *		char *filename;
592  *
593  *	lopen(0) means from the terminal
594  *	Returns -1 if error, otherwise the file descriptor opened.
595  */
596 int
597 lopen(str)
598 	char           *str;
599 {
600 	ipoint = iepoint = MAXIBUF;
601 	if (str == NULL)
602 		return (fd = 0);
603 	if ((fd = open(str, 0)) < 0) {
604 		lwclose();
605 		lfd = 1;
606 		lpnt = lpbuf;
607 		return (-1);
608 	}
609 	return (fd);
610 }
611 
612 /*
613  *	lappend(filename)		Open for append to an existing file
614  *		char *filename;
615  *
616  *	lappend(0) means to the terminal
617  *	Returns -1 if error, otherwise the file descriptor opened.
618  */
619 int
620 lappend(str)
621 	char           *str;
622 {
623 	lpnt = lpbuf;
624 	lpend = lpbuf + BUFBIG;
625 	if (str == NULL)
626 		return (lfd = 1);
627 	if ((lfd = open(str, 2)) < 0) {
628 		lfd = 1;
629 		return (-1);
630 	}
631 	lseek(lfd, 0, 2);	/* seek to end of file */
632 	return (lfd);
633 }
634 
635 /*
636  *	lrclose() close the input file
637  *
638  *	Returns nothing of value.
639  */
640 void
641 lrclose()
642 {
643 	if (fd > 0)
644 		close(fd);
645 }
646 
647 /*
648  *	lwclose() close output file flushing if needed
649  *
650  *	Returns nothing of value.
651  */
652 void
653 lwclose()
654 {
655 	lflush();
656 	if (lfd > 2)
657 		close(lfd);
658 }
659 
660 /*
661  *	lprcat(string)	append a string to the output buffer
662  *			    	avoids calls to lprintf (time consuming)
663  */
664 void
665 lprcat(str)
666 	char  *str;
667 {
668 	char  *str2;
669 	if (lpnt >= lpend)
670 		lflush();
671 	str2 = lpnt;
672 	while ((*str2++ = *str++) != '\0')
673 		continue;
674 	lpnt = str2 - 1;
675 }
676 
677 #ifdef VT100
678 /*
679  *	cursor(x,y) 		Subroutine to set the cursor position
680  *
681  *	x and y are the cursor coordinates, and lpbuff is the output buffer where
682  *	escape sequence will be placed.
683  */
684 static char    *y_num[] = {
685 "\33[", "\33[", "\33[2", "\33[3", "\33[4", "\33[5", "\33[6",
686 "\33[7", "\33[8", "\33[9", "\33[10", "\33[11", "\33[12", "\33[13", "\33[14",
687 "\33[15", "\33[16", "\33[17", "\33[18", "\33[19", "\33[20", "\33[21", "\33[22",
688 "\33[23", "\33[24"};
689 
690 static char    *x_num[] = {
691 "H", "H", ";2H", ";3H", ";4H", ";5H", ";6H", ";7H", ";8H", ";9H",
692 ";10H", ";11H", ";12H", ";13H", ";14H", ";15H", ";16H", ";17H", ";18H", ";19H",
693 ";20H", ";21H", ";22H", ";23H", ";24H", ";25H", ";26H", ";27H", ";28H", ";29H",
694 ";30H", ";31H", ";32H", ";33H", ";34H", ";35H", ";36H", ";37H", ";38H", ";39H",
695 ";40H", ";41H", ";42H", ";43H", ";44H", ";45H", ";46H", ";47H", ";48H", ";49H",
696 ";50H", ";51H", ";52H", ";53H", ";54H", ";55H", ";56H", ";57H", ";58H", ";59H",
697 ";60H", ";61H", ";62H", ";63H", ";64H", ";65H", ";66H", ";67H", ";68H", ";69H",
698 ";70H", ";71H", ";72H", ";73H", ";74H", ";75H", ";76H", ";77H", ";78H", ";79H",
699 ";80H"};
700 
701 void
702 cursor(x, y)
703 	int             x, y;
704 {
705 	char  *p;
706 	if (lpnt >= lpend)
707 		lflush();
708 
709 	p = y_num[y];		/* get the string to print */
710 	while (*p)
711 		*lpnt++ = *p++;	/* print the string */
712 
713 	p = x_num[x];		/* get the string to print */
714 	while (*p)
715 		*lpnt++ = *p++;	/* print the string */
716 }
717 #else	/* VT100 */
718 /*
719  * cursor(x,y)	  Put cursor at specified coordinates staring at [1,1] (termcap)
720  */
721 void
722 cursor(x, y)
723 	int             x, y;
724 {
725 	if (lpnt >= lpend)
726 		lflush();
727 
728 	*lpnt++ = CURSOR;
729 	*lpnt++ = x;
730 	*lpnt++ = y;
731 }
732 #endif	/* VT100 */
733 
734 /*
735  *	Routine to position cursor at beginning of 24th line
736  */
737 void
738 cursors()
739 {
740 	cursor(1, 24);
741 }
742 
743 #ifndef VT100
744 /*
745  * Warning: ringing the bell is control code 7. Don't use in defines.
746  * Don't change the order of these defines.
747  * Also used in helpfiles. Codes used in helpfiles should be \E[1 to \E[7 with
748  * obvious meanings.
749  */
750 
751 struct tinfo   *info;
752 char           *CM, *CE, *CD, *CL, *SO, *SE, *AL, *DL;	/* Termcap capabilities */
753 static char    *outbuf = 0;	/* translated output buffer */
754 
755 /*
756  * init_term()		Terminal initialization -- setup termcap info
757  */
758 void
759 init_term()
760 {
761 	char           *term;
762 
763 	switch (t_getent(&info, term = getenv("TERM"))) {
764 	case -1:
765 		write(2, "Cannot open termcap file.\n", 26);
766 		exit(1);
767 	case 0:
768 		write(2, "Cannot find entry of ", 21);
769 		write(2, term, strlen(term));
770 		write(2, " in termcap\n", 12);
771 		exit(1);
772 	};
773 
774 	CM = t_agetstr(info, "cm");	/* Cursor motion */
775 	CE = t_agetstr(info, "ce");	/* Clear to eoln */
776 	CL = t_agetstr(info, "cl");	/* Clear screen */
777 
778 	/* OPTIONAL */
779 	AL = t_agetstr(info, "al");	/* Insert line */
780 	DL = t_agetstr(info, "dl");	/* Delete line */
781 	SO = t_agetstr(info, "so");	/* Begin standout mode */
782 	SE = t_agetstr(info, "se");	/* End standout mode */
783 	CD = t_agetstr(info, "cd");	/* Clear to end of display */
784 
785 	if (!CM) {		/* can't find cursor motion entry */
786 		write(2, "Sorry, for a ", 13);
787 		write(2, term, strlen(term));
788 		write(2, ", I can't find the cursor motion entry in termcap\n", 50);
789 		exit(1);
790 	}
791 	if (!CE) {		/* can't find clear to end of line entry */
792 		write(2, "Sorry, for a ", 13);
793 		write(2, term, strlen(term));
794 		write(2, ", I can't find the clear to end of line entry in termcap\n", 57);
795 		exit(1);
796 	}
797 	if (!CL) {		/* can't find clear entire screen entry */
798 		write(2, "Sorry, for a ", 13);
799 		write(2, term, strlen(term));
800 		write(2, ", I can't find the clear entire screen entry in termcap\n", 56);
801 		exit(1);
802 	}
803 	if ((outbuf = malloc(BUFBIG + 16)) == 0) {	/* get memory for
804 							 * decoded output buffer */
805 		write(2, "Error malloc'ing memory for decoded output buffer\n", 50);
806 		died(-285);	/* malloc() failure */
807 	}
808 }
809 #endif	/* VT100 */
810 
811 /*
812  * cl_line(x,y)  Clear the whole line indicated by 'y' and leave cursor at [x,y]
813  */
814 void
815 cl_line(x, y)
816 	int             x, y;
817 {
818 #ifdef VT100
819 	cursor(x, y);
820 	lprcat("\33[2K");
821 #else	/* VT100 */
822 	cursor(1, y);
823 	*lpnt++ = CL_LINE;
824 	cursor(x, y);
825 #endif	/* VT100 */
826 }
827 
828 /*
829  * cl_up(x,y) Clear screen from [x,1] to current position. Leave cursor at [x,y]
830  */
831 void
832 cl_up(x, y)
833 	int    x, y;
834 {
835 #ifdef VT100
836 	cursor(x, y);
837 	lprcat("\33[1J\33[2K");
838 #else	/* VT100 */
839 	int    i;
840 	cursor(1, 1);
841 	for (i = 1; i <= y; i++) {
842 		*lpnt++ = CL_LINE;
843 		*lpnt++ = '\n';
844 	}
845 	cursor(x, y);
846 #endif	/* VT100 */
847 }
848 
849 /*
850  * cl_dn(x,y) 	Clear screen from [1,y] to end of display. Leave cursor at [x,y]
851  */
852 void
853 cl_dn(x, y)
854 	int    x, y;
855 {
856 #ifdef VT100
857 	cursor(x, y);
858 	lprcat("\33[J\33[2K");
859 #else	/* VT100 */
860 	int    i;
861 	cursor(1, y);
862 	if (!CD) {
863 		*lpnt++ = CL_LINE;
864 		for (i = y; i <= 24; i++) {
865 			*lpnt++ = CL_LINE;
866 			if (i != 24)
867 				*lpnt++ = '\n';
868 		}
869 		cursor(x, y);
870 	} else
871 		*lpnt++ = CL_DOWN;
872 	cursor(x, y);
873 #endif	/* VT100 */
874 }
875 
876 /*
877  * standout(str)	Print the argument string in inverse video (standout mode).
878  */
879 void
880 standout(str)
881 	char  *str;
882 {
883 #ifdef VT100
884 	setbold();
885 	while (*str)
886 		*lpnt++ = *str++;
887 	resetbold();
888 #else	/* VT100 */
889 	*lpnt++ = ST_START;
890 	while (*str)
891 		*lpnt++ = *str++;
892 	*lpnt++ = ST_END;
893 #endif	/* VT100 */
894 }
895 
896 /*
897  * set_score_output() 	Called when output should be literally printed.
898  */
899 void
900 set_score_output()
901 {
902 	enable_scroll = -1;
903 }
904 
905 /*
906  *	lflush()	Flush the output buffer
907  *
908  *	Returns nothing of value.
909  *	for termcap version: Flush output in output buffer according to output
910  *	status as indicated by `enable_scroll'
911  */
912 #ifndef VT100
913 static int      scrline = 18;	/* line # for wraparound instead of scrolling
914 				 * if no DL */
915 void
916 lflush()
917 {
918 	int    lpoint;
919 	u_char  *str;
920 	static int      curx = 0;
921 	static int      cury = 0;
922 	char tgoto_buf[256];
923 
924 	if ((lpoint = lpnt - lpbuf) > 0) {
925 #ifdef EXTRA
926 		c[BYTESOUT] += lpoint;
927 #endif
928 		if (enable_scroll <= -1) {
929 			flush_buf();
930 			if (write(lfd, lpbuf, lpoint) != lpoint)
931 				write(2, "error writing to output file\n", 29);
932 			lpnt = lpbuf;	/* point back to beginning of buffer */
933 			return;
934 		}
935 		for (str = lpbuf; str < lpnt; str++) {
936 			if (*str >= 32) {
937 				xputchar(*str);
938 				curx++;
939 			} else
940 				switch (*str) {
941 				case CLEAR:
942 					tputs(CL, 0, xputchar);
943 					curx = cury = 0;
944 					break;
945 
946 				case CL_LINE:
947 					tputs(CE, 0, xputchar);
948 					break;
949 
950 				case CL_DOWN:
951 					tputs(CD, 0, xputchar);
952 					break;
953 
954 				case ST_START:
955 					tputs(SO, 0, xputchar);
956 					break;
957 
958 				case ST_END:
959 					tputs(SE, 0, xputchar);
960 					break;
961 
962 				case CURSOR:
963 					curx = *++str - 1;
964 					cury = *++str - 1;
965 					if (t_goto(info, CM, curx, cury,
966 						   tgoto_buf, 255) == 0)
967 						tputs(tgoto_buf, 0, xputchar);
968 					break;
969 
970 				case '\n':
971 					if ((cury == 23) && enable_scroll) {
972 						if (!DL || !AL) {	/* wraparound or scroll? */
973 							if (++scrline > 23)
974 								scrline = 19;
975 
976 							if (++scrline > 23)
977 								scrline = 19;
978 							if (t_goto(info, CM, 0,
979 								   scrline,
980 								   tgoto_buf,
981 								   255) == 0)
982 								tputs(tgoto_buf,
983 								      0,
984 								      xputchar);
985 							tputs(CE, 0, xputchar);
986 
987 							if (--scrline < 19)
988 								scrline = 23;
989 							if (t_goto(info, CM, 0,
990 								   scrline,
991 								   tgoto_buf,
992 								   255) == 0)
993 								tputs(tgoto_buf,
994 								      0,
995 								      xputchar);
996 							tputs(CE, 0, xputchar);
997 						} else {
998 							if (t_goto(info, CM, 0,
999 								   19,
1000 								   tgoto_buf,
1001 								   255) == 0)
1002 								tputs(tgoto_buf,
1003 								      0,
1004 								      xputchar);
1005 							tputs(DL, 0, xputchar);
1006 							if (t_goto(info, CM, 0,
1007 								   23,
1008 								   tgoto_buf,
1009 								   255) == 0)
1010 								tputs(tgoto_buf,
1011 								      0,
1012 								      xputchar);
1013 							/*
1014 							 * tputs (AL, 0,
1015 							 * xputchar);
1016 							 */
1017 						}
1018 					} else {
1019 						xputchar('\n');
1020 						cury++;
1021 					}
1022 					curx = 0;
1023 					break;
1024 
1025 				default:
1026 					xputchar(*str);
1027 					curx++;
1028 				};
1029 		}
1030 	}
1031 	lpnt = lpbuf;
1032 	flush_buf();		/* flush real output buffer now */
1033 }
1034 #else	/* VT100 */
1035 /*
1036  *	lflush()		flush the output buffer
1037  *
1038  *	Returns nothing of value.
1039  */
1040 void
1041 lflush()
1042 {
1043 	int    lpoint;
1044 	if ((lpoint = lpnt - lpbuf) > 0) {
1045 #ifdef EXTRA
1046 		c[BYTESOUT] += lpoint;
1047 #endif
1048 		if (write(lfd, lpbuf, lpoint) != lpoint)
1049 			write(2, "error writing to output file\n", 29);
1050 	}
1051 	lpnt = lpbuf;		/* point back to beginning of buffer */
1052 }
1053 #endif	/* VT100 */
1054 
1055 #ifndef VT100
1056 static int      vindex = 0;
1057 /*
1058  * xputchar(ch)		Print one character in decoded output buffer.
1059  */
1060 int
1061 xputchar(c)
1062 	int             c;
1063 {
1064 	outbuf[vindex++] = c;
1065 	if (vindex >= BUFBIG)
1066 		flush_buf();
1067 	return (0);
1068 }
1069 
1070 /*
1071  * flush_buf()			Flush buffer with decoded output.
1072  */
1073 void
1074 flush_buf()
1075 {
1076 	if (vindex)
1077 		write(lfd, outbuf, vindex);
1078 	vindex = 0;
1079 }
1080 
1081 /*
1082  *	char *tmcapcnv(sd,ss)  Routine to convert VT100 escapes to termcap
1083  *	format
1084  *	Processes only the \33[#m sequence (converts . files for termcap use
1085  */
1086 char *
1087 tmcapcnv(sd, ss)
1088 	char  *sd, *ss;
1089 {
1090 	int    tmstate = 0;	/* 0=normal, 1=\33 2=[ 3=# */
1091 	char            tmdigit = 0;	/* the # in \33[#m */
1092 	while (*ss) {
1093 		switch (tmstate) {
1094 		case 0:
1095 			if (*ss == '\33') {
1096 				tmstate++;
1097 				break;
1098 			}
1099 	ign:		*sd++ = *ss;
1100 	ign2:		tmstate = 0;
1101 			break;
1102 		case 1:
1103 			if (*ss != '[')
1104 				goto ign;
1105 			tmstate++;
1106 			break;
1107 		case 2:
1108 			if (isdigit((u_char)*ss)) {
1109 				tmdigit = *ss - '0';
1110 				tmstate++;
1111 				break;
1112 			}
1113 			if (*ss == 'm') {
1114 				*sd++ = ST_END;
1115 				goto ign2;
1116 			}
1117 			goto ign;
1118 		case 3:
1119 			if (*ss == 'm') {
1120 				if (tmdigit)
1121 					*sd++ = ST_START;
1122 				else
1123 					*sd++ = ST_END;
1124 				goto ign2;
1125 			}
1126 		default:
1127 			goto ign;
1128 		};
1129 		ss++;
1130 	}
1131 	*sd = 0;		/* NULL terminator */
1132 	return (sd);
1133 }
1134 #endif	/* VT100 */
1135 
1136 /*
1137  *	beep()	Routine to emit a beep if enabled (see no-beep in .larnopts)
1138  */
1139 void
1140 beep()
1141 {
1142 	if (!nobeep)
1143 		*lpnt++ = '\7';
1144 }
1145