![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to io.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / games / larn|
Return to io.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / games / larn |
1.1 ! root 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: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.