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