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