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