io.c revision 1.25
1 /* $NetBSD: io.c,v 1.25 2010/02/03 15:34:39 roy 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.25 2010/02/03 15:34:39 roy 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 <term.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 static char *outbuf = 0; /* translated output buffer */ 654 /* 655 * init_term() Terminal initialization -- setup termcap info 656 */ 657 void 658 init_term() 659 { 660 setupterm(NULL, 0, NULL); /* will exit if invalid term */ 661 if (!cursor_address) { 662 fprintf(stderr, "term does not have cursor_address.\n"); 663 exit(1); 664 } 665 if (!clr_eol) { 666 fprintf(stderr, "term does not have clr_eol.\n"); 667 exit(1); 668 } 669 if (!clear_screen) { 670 fprintf(stderr, "term does not have clear_screen.\n"); 671 exit(1); 672 } 673 if ((outbuf = malloc(BUFBIG + 16)) == 0) { /* get memory for 674 * decoded output buffer */ 675 fprintf(stderr, "Error malloc'ing memory for decoded output buffer\n"); 676 died(-285); /* malloc() failure */ 677 } 678 679 } 680 #endif /* VT100 */ 681 682 /* 683 * cl_line(x,y) Clear the whole line indicated by 'y' and leave cursor at [x,y] 684 */ 685 void 686 cl_line(x, y) 687 int x, y; 688 { 689 #ifdef VT100 690 cursor(x, y); 691 lprcat("\33[2K"); 692 #else /* VT100 */ 693 cursor(1, y); 694 *lpnt++ = CL_LINE; 695 cursor(x, y); 696 #endif /* VT100 */ 697 } 698 699 /* 700 * cl_up(x,y) Clear screen from [x,1] to current position. Leave cursor at [x,y] 701 */ 702 void 703 cl_up(x, y) 704 int x, y; 705 { 706 #ifdef VT100 707 cursor(x, y); 708 lprcat("\33[1J\33[2K"); 709 #else /* VT100 */ 710 int i; 711 cursor(1, 1); 712 for (i = 1; i <= y; i++) { 713 *lpnt++ = CL_LINE; 714 *lpnt++ = '\n'; 715 } 716 cursor(x, y); 717 #endif /* VT100 */ 718 } 719 720 /* 721 * cl_dn(x,y) Clear screen from [1,y] to end of display. Leave cursor at [x,y] 722 */ 723 void 724 cl_dn(x, y) 725 int x, y; 726 { 727 #ifdef VT100 728 cursor(x, y); 729 lprcat("\33[J\33[2K"); 730 #else /* VT100 */ 731 int i; 732 cursor(1, y); 733 if (!clr_eos) { 734 *lpnt++ = CL_LINE; 735 for (i = y; i <= 24; i++) { 736 *lpnt++ = CL_LINE; 737 if (i != 24) 738 *lpnt++ = '\n'; 739 } 740 cursor(x, y); 741 } else 742 *lpnt++ = CL_DOWN; 743 cursor(x, y); 744 #endif /* VT100 */ 745 } 746 747 /* 748 * standout(str) Print the argument string in inverse video (standout mode). 749 */ 750 void 751 standout(const char *str) 752 { 753 #ifdef VT100 754 setbold(); 755 while (*str) 756 *lpnt++ = *str++; 757 resetbold(); 758 #else /* VT100 */ 759 *lpnt++ = ST_START; 760 while (*str) 761 *lpnt++ = *str++; 762 *lpnt++ = ST_END; 763 #endif /* VT100 */ 764 } 765 766 /* 767 * set_score_output() Called when output should be literally printed. 768 */ 769 void 770 set_score_output() 771 { 772 enable_scroll = -1; 773 } 774 775 /* 776 * lflush() Flush the output buffer 777 * 778 * Returns nothing of value. 779 * for termcap version: Flush output in output buffer according to output 780 * status as indicated by `enable_scroll' 781 */ 782 #ifndef VT100 783 static int scrline = 18; /* line # for wraparound instead of scrolling 784 * if no DL */ 785 void 786 lflush() 787 { 788 int lpoint; 789 u_char *str; 790 static int curx = 0; 791 static int cury = 0; 792 793 if ((lpoint = lpnt - lpbuf) > 0) { 794 #ifdef EXTRA 795 c[BYTESOUT] += lpoint; 796 #endif 797 if (enable_scroll <= -1) { 798 flush_buf(); 799 if (write(io_outfd, lpbuf, lpoint) != lpoint) 800 write(2, "error writing to output file\n", 29); 801 lpnt = lpbuf; /* point back to beginning of buffer */ 802 return; 803 } 804 for (str = lpbuf; str < lpnt; str++) { 805 if (*str >= 32) { 806 ttputch(*str); 807 curx++; 808 } else 809 switch (*str) { 810 case CLEAR: 811 tputs(clear_screen, 0, ttputch); 812 curx = cury = 0; 813 break; 814 815 case CL_LINE: 816 tputs(clr_eol, 0, ttputch); 817 break; 818 819 case CL_DOWN: 820 tputs(clr_eos, 0, ttputch); 821 break; 822 823 case ST_START: 824 tputs(enter_standout_mode, 0, ttputch); 825 break; 826 827 case ST_END: 828 tputs(exit_standout_mode, 0, ttputch); 829 break; 830 831 case CURSOR: 832 curx = *++str - 1; 833 cury = *++str - 1; 834 tputs(vtparm(cursor_address, 835 cury, curx), 0, ttputch); 836 break; 837 838 case '\n': 839 if ((cury == 23) && enable_scroll) { 840 if (!delete_line || 841 !insert_line) 842 { /* wraparound or scroll? */ 843 if (++scrline > 23) 844 scrline = 19; 845 846 if (++scrline > 23) 847 scrline = 19; 848 tputs(vtparm( 849 cursor_address, 850 scrline, 0), 851 0, ttputch); 852 tputs(clr_eol, 0, 853 ttputch); 854 855 if (--scrline < 19) 856 scrline = 23; 857 tputs(vtparm( 858 cursor_address, 859 scrline, 0), 860 0, ttputch); 861 tputs(clr_eol, 0, 862 ttputch); 863 } else { 864 tputs(vtparm( 865 cursor_address, 866 19, 0), 867 0, ttputch); 868 tputs(delete_line, 0, 869 ttputch); 870 tputs(vtparm( 871 cursor_address, 872 23, 0), 873 0, ttputch); 874 /* 875 * tputs (AL, 0, 876 * ttputch); 877 */ 878 } 879 } else { 880 ttputch('\n'); 881 cury++; 882 } 883 curx = 0; 884 break; 885 886 default: 887 ttputch(*str); 888 curx++; 889 }; 890 } 891 } 892 lpnt = lpbuf; 893 flush_buf(); /* flush real output buffer now */ 894 } 895 #else /* VT100 */ 896 /* 897 * lflush() flush the output buffer 898 * 899 * Returns nothing of value. 900 */ 901 void 902 lflush() 903 { 904 int lpoint; 905 if ((lpoint = lpnt - lpbuf) > 0) { 906 #ifdef EXTRA 907 c[BYTESOUT] += lpoint; 908 #endif 909 if (write(io_outfd, lpbuf, lpoint) != lpoint) 910 write(2, "error writing to output file\n", 29); 911 } 912 lpnt = lpbuf; /* point back to beginning of buffer */ 913 } 914 #endif /* VT100 */ 915 916 #ifndef VT100 917 static int vindex = 0; 918 /* 919 * ttputch(ch) Print one character in decoded output buffer. 920 */ 921 static int 922 ttputch(int ch) 923 { 924 outbuf[vindex++] = ch; 925 if (vindex >= BUFBIG) 926 flush_buf(); 927 return (0); 928 } 929 930 /* 931 * flush_buf() Flush buffer with decoded output. 932 */ 933 static void 934 flush_buf() 935 { 936 if (vindex) 937 write(io_outfd, outbuf, vindex); 938 vindex = 0; 939 } 940 941 /* 942 * char *tmcapcnv(sd,ss) Routine to convert VT100 escapes to termcap 943 * format 944 * Processes only the \33[#m sequence (converts . files for termcap use 945 */ 946 char * 947 tmcapcnv(sd, ss) 948 char *sd, *ss; 949 { 950 int tmstate = 0; /* 0=normal, 1=\33 2=[ 3=# */ 951 char tmdigit = 0; /* the # in \33[#m */ 952 while (*ss) { 953 switch (tmstate) { 954 case 0: 955 if (*ss == '\33') { 956 tmstate++; 957 break; 958 } 959 ign: *sd++ = *ss; 960 ign2: tmstate = 0; 961 break; 962 case 1: 963 if (*ss != '[') 964 goto ign; 965 tmstate++; 966 break; 967 case 2: 968 if (isdigit((u_char)*ss)) { 969 tmdigit = *ss - '0'; 970 tmstate++; 971 break; 972 } 973 if (*ss == 'm') { 974 *sd++ = ST_END; 975 goto ign2; 976 } 977 goto ign; 978 case 3: 979 if (*ss == 'm') { 980 if (tmdigit) 981 *sd++ = ST_START; 982 else 983 *sd++ = ST_END; 984 goto ign2; 985 } 986 default: 987 goto ign; 988 }; 989 ss++; 990 } 991 *sd = 0; /* NULL terminator */ 992 return (sd); 993 } 994 #endif /* VT100 */ 995 996 /* 997 * beep() Routine to emit a beep if enabled (see no-beep in .larnopts) 998 */ 999 void 1000 beep() 1001 { 1002 if (!nobeep) 1003 *lpnt++ = '\7'; 1004 } 1005
Indexes created Wed Oct 01 19:09:53 GMT 2025