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.5 2006/01/22 03:43:37 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  *      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         }