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