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