1 /* 2 * Copyright (C) 1984-2019 Mark Nudelman 3 * 4 * You may distribute under the terms of either the GNU General Public 5 * License or the Less License, as specified in the README file. 6 * 7 * For more information, see the README file. 8 */ 9 10 11 /* 12 * Low level character input from the input file. 13 * We use these special purpose routines which optimize moving 14 * both forward and backward from the current read pointer. 15 */ 16 17 #include "less.h" 18 #if MSDOS_COMPILER==WIN32C 19 #include <errno.h> 20 #include <windows.h> 21 #endif 22 23 #if HAVE_STAT_INO 24 #include <sys/stat.h> 25 extern dev_t curr_dev; 26 extern ino_t curr_ino; 27 #endif 28 29 typedef POSITION BLOCKNUM; 30 31 public int ignore_eoi; 32 33 /* 34 * Pool of buffers holding the most recently used blocks of the input file. 35 * The buffer pool is kept as a doubly-linked circular list, 36 * in order from most- to least-recently used. 37 * The circular list is anchored by the file state "thisfile". 38 */ 39 struct bufnode { 40 struct bufnode *next, *prev; 41 struct bufnode *hnext, *hprev; 42 }; 43 44 #define LBUFSIZE 8192 45 struct buf { 46 struct bufnode node; 47 BLOCKNUM block; 48 unsigned int datasize; 49 unsigned char data[LBUFSIZE]; 50 }; 51 #define bufnode_buf(bn) ((struct buf *) bn) 52 53 /* 54 * The file state is maintained in a filestate structure. 55 * A pointer to the filestate is kept in the ifile structure. 56 */ 57 #define BUFHASH_SIZE 1024 58 struct filestate { 59 struct bufnode buflist; 60 struct bufnode hashtbl[BUFHASH_SIZE]; 61 int file; 62 int flags; 63 POSITION fpos; 64 int nbufs; 65 BLOCKNUM block; 66 unsigned int offset; 67 POSITION fsize; 68 }; 69 70 #define ch_bufhead thisfile->buflist.next 71 #define ch_buftail thisfile->buflist.prev 72 #define ch_nbufs thisfile->nbufs 73 #define ch_block thisfile->block 74 #define ch_offset thisfile->offset 75 #define ch_fpos thisfile->fpos 76 #define ch_fsize thisfile->fsize 77 #define ch_flags thisfile->flags 78 #define ch_file thisfile->file 79 80 #define END_OF_CHAIN (&thisfile->buflist) 81 #define END_OF_HCHAIN(h) (&thisfile->hashtbl[h]) 82 #define BUFHASH(blk) ((blk) & (BUFHASH_SIZE-1)) 83 84 /* 85 * Macros to manipulate the list of buffers in thisfile->buflist. 86 */ 87 #define FOR_BUFS(bn) \ 88 for (bn = ch_bufhead; bn != END_OF_CHAIN; bn = bn->next) 89 90 #define BUF_RM(bn) \ 91 (bn)->next->prev = (bn)->prev; \ 92 (bn)->prev->next = (bn)->next; 93 94 #define BUF_INS_HEAD(bn) \ 95 (bn)->next = ch_bufhead; \ 96 (bn)->prev = END_OF_CHAIN; \ 97 ch_bufhead->prev = (bn); \ 98 ch_bufhead = (bn); 99 100 #define BUF_INS_TAIL(bn) \ 101 (bn)->next = END_OF_CHAIN; \ 102 (bn)->prev = ch_buftail; \ 103 ch_buftail->next = (bn); \ 104 ch_buftail = (bn); 105 106 /* 107 * Macros to manipulate the list of buffers in thisfile->hashtbl[n]. 108 */ 109 #define FOR_BUFS_IN_CHAIN(h,bn) \ 110 for (bn = thisfile->hashtbl[h].hnext; \ 111 bn != END_OF_HCHAIN(h); bn = bn->hnext) 112 113 #define BUF_HASH_RM(bn) \ 114 (bn)->hnext->hprev = (bn)->hprev; \ 115 (bn)->hprev->hnext = (bn)->hnext; 116 117 #define BUF_HASH_INS(bn,h) \ 118 (bn)->hnext = thisfile->hashtbl[h].hnext; \ 119 (bn)->hprev = END_OF_HCHAIN(h); \ 120 thisfile->hashtbl[h].hnext->hprev = (bn); \ 121 thisfile->hashtbl[h].hnext = (bn); 122 123 static struct filestate *thisfile; 124 static int ch_ungotchar = -1; 125 static int maxbufs = -1; 126 127 extern int autobuf; 128 extern int sigs; 129 extern int secure; 130 extern int screen_trashed; 131 extern int follow_mode; 132 extern constant char helpdata[]; 133 extern constant int size_helpdata; 134 extern IFILE curr_ifile; 135 #if LOGFILE 136 extern int logfile; 137 extern char *namelogfile; 138 #endif 139 140 static int ch_addbuf(); 141 142 143 /* 144 * Get the character pointed to by the read pointer. 145 */ 146 int 147 ch_get(VOID_PARAM) 148 { 149 struct buf *bp; 150 struct bufnode *bn; 151 int n; 152 int slept; 153 int h; 154 POSITION pos; 155 POSITION len; 156 157 if (thisfile == NULL) 158 return (EOI); 159 160 /* 161 * Quick check for the common case where 162 * the desired char is in the head buffer. 163 */ 164 if (ch_bufhead != END_OF_CHAIN) 165 { 166 bp = bufnode_buf(ch_bufhead); 167 if (ch_block == bp->block && ch_offset < bp->datasize) 168 return bp->data[ch_offset]; 169 } 170 171 slept = FALSE; 172 173 /* 174 * Look for a buffer holding the desired block. 175 */ 176 h = BUFHASH(ch_block); 177 FOR_BUFS_IN_CHAIN(h, bn) 178 { 179 bp = bufnode_buf(bn); 180 if (bp->block == ch_block) 181 { 182 if (ch_offset >= bp->datasize) 183 /* 184 * Need more data in this buffer. 185 */ 186 break; 187 goto found; 188 } 189 } 190 if (bn == END_OF_HCHAIN(h)) 191 { 192 /* 193 * Block is not in a buffer. 194 * Take the least recently used buffer 195 * and read the desired block into it. 196 * If the LRU buffer has data in it, 197 * then maybe allocate a new buffer. 198 */ 199 if (ch_buftail == END_OF_CHAIN || 200 bufnode_buf(ch_buftail)->block != -1) 201 { 202 /* 203 * There is no empty buffer to use. 204 * Allocate a new buffer if: 205 * 1. We can't seek on this file and -b is not in effect; or 206 * 2. We haven't allocated the max buffers for this file yet. 207 */ 208 if ((autobuf && !(ch_flags & CH_CANSEEK)) || 209 (maxbufs < 0 || ch_nbufs < maxbufs)) 210 if (ch_addbuf()) 211 /* 212 * Allocation failed: turn off autobuf. 213 */ 214 autobuf = OPT_OFF; 215 } 216 bn = ch_buftail; 217 bp = bufnode_buf(bn); 218 BUF_HASH_RM(bn); /* Remove from old hash chain. */ 219 bp->block = ch_block; 220 bp->datasize = 0; 221 BUF_HASH_INS(bn, h); /* Insert into new hash chain. */ 222 } 223 224 read_more: 225 pos = (ch_block * LBUFSIZE) + bp->datasize; 226 if ((len = ch_length()) != NULL_POSITION && pos >= len) 227 /* 228 * At end of file. 229 */ 230 return (EOI); 231 232 if (pos != ch_fpos) 233 { 234 /* 235 * Not at the correct position: must seek. 236 * If input is a pipe, we're in trouble (can't seek on a pipe). 237 * Some data has been lost: just return "?". 238 */ 239 if (!(ch_flags & CH_CANSEEK)) 240 return ('?'); 241 if (lseek(ch_file, (off_t)pos, SEEK_SET) == BAD_LSEEK) 242 { 243 error("seek error", NULL_PARG); 244 clear_eol(); 245 return (EOI); 246 } 247 ch_fpos = pos; 248 } 249 250 /* 251 * Read the block. 252 * If we read less than a full block, that's ok. 253 * We use partial block and pick up the rest next time. 254 */ 255 if (ch_ungotchar != -1) 256 { 257 bp->data[bp->datasize] = ch_ungotchar; 258 n = 1; 259 ch_ungotchar = -1; 260 } else if (ch_flags & CH_HELPFILE) 261 { 262 bp->data[bp->datasize] = helpdata[ch_fpos]; 263 n = 1; 264 } else 265 { 266 n = iread(ch_file, &bp->data[bp->datasize], 267 (unsigned int)(LBUFSIZE - bp->datasize)); 268 } 269 270 if (n == READ_INTR) 271 return (EOI); 272 if (n < 0) 273 { 274 #if MSDOS_COMPILER==WIN32C 275 if (errno != EPIPE) 276 #endif 277 { 278 error("read error", NULL_PARG); 279 clear_eol(); 280 } 281 n = 0; 282 } 283 284 #if LOGFILE 285 /* 286 * If we have a log file, write the new data to it. 287 */ 288 if (!secure && logfile >= 0 && n > 0) 289 write(logfile, (char *) &bp->data[bp->datasize], n); 290 #endif 291 292 ch_fpos += n; 293 bp->datasize += n; 294 295 /* 296 * If we have read to end of file, set ch_fsize to indicate 297 * the position of the end of file. 298 */ 299 if (n == 0) 300 { 301 ch_fsize = pos; 302 if (ignore_eoi) 303 { 304 /* 305 * We are ignoring EOF. 306 * Wait a while, then try again. 307 */ 308 if (!slept) 309 { 310 PARG parg; 311 parg.p_string = wait_message(); 312 ierror("%s", &parg); 313 } 314 #if !MSDOS_COMPILER 315 sleep(1); 316 #else 317 #if MSDOS_COMPILER==WIN32C 318 Sleep(1000); 319 #endif 320 #endif 321 slept = TRUE; 322 323 #if HAVE_STAT_INO 324 if (follow_mode == FOLLOW_NAME) 325 { 326 /* See whether the file's i-number has changed, 327 * or the file has shrunk. 328 * If so, force the file to be closed and 329 * reopened. */ 330 struct stat st; 331 POSITION curr_pos = ch_tell(); 332 int r = stat(get_filename(curr_ifile), &st); 333 if (r == 0 && (st.st_ino != curr_ino || 334 st.st_dev != curr_dev || 335 (curr_pos != NULL_POSITION && st.st_size < curr_pos))) 336 { 337 /* screen_trashed=2 causes 338 * make_display to reopen the file. */ 339 screen_trashed = 2; 340 return (EOI); 341 } 342 } 343 #endif 344 } 345 if (sigs) 346 return (EOI); 347 } 348 349 found: 350 if (ch_bufhead != bn) 351 { 352 /* 353 * Move the buffer to the head of the buffer chain. 354 * This orders the buffer chain, most- to least-recently used. 355 */ 356 BUF_RM(bn); 357 BUF_INS_HEAD(bn); 358 359 /* 360 * Move to head of hash chain too. 361 */ 362 BUF_HASH_RM(bn); 363 BUF_HASH_INS(bn, h); 364 } 365 366 if (ch_offset >= bp->datasize) 367 /* 368 * After all that, we still don't have enough data. 369 * Go back and try again. 370 */ 371 goto read_more; 372 373 return (bp->data[ch_offset]); 374 } 375 376 /* 377 * ch_ungetchar is a rather kludgy and limited way to push 378 * a single char onto an input file descriptor. 379 */ 380 public void 381 ch_ungetchar(c) 382 int c; 383 { 384 if (c != -1 && ch_ungotchar != -1) 385 error("ch_ungetchar overrun", NULL_PARG); 386 ch_ungotchar = c; 387 } 388 389 #if LOGFILE 390 /* 391 * Close the logfile. 392 * If we haven't read all of standard input into it, do that now. 393 */ 394 public void 395 end_logfile(VOID_PARAM) 396 { 397 static int tried = FALSE; 398 399 if (logfile < 0) 400 return; 401 if (!tried && ch_fsize == NULL_POSITION) 402 { 403 tried = TRUE; 404 ierror("Finishing logfile", NULL_PARG); 405 while (ch_forw_get() != EOI) 406 if (ABORT_SIGS()) 407 break; 408 } 409 close(logfile); 410 logfile = -1; 411 namelogfile = NULL; 412 } 413 414 /* 415 * Start a log file AFTER less has already been running. 416 * Invoked from the - command; see toggle_option(). 417 * Write all the existing buffered data to the log file. 418 */ 419 public void 420 sync_logfile(VOID_PARAM) 421 { 422 struct buf *bp; 423 struct bufnode *bn; 424 int warned = FALSE; 425 BLOCKNUM block; 426 BLOCKNUM nblocks; 427 428 nblocks = (ch_fpos + LBUFSIZE - 1) / LBUFSIZE; 429 for (block = 0; block < nblocks; block++) 430 { 431 int wrote = FALSE; 432 FOR_BUFS(bn) 433 { 434 bp = bufnode_buf(bn); 435 if (bp->block == block) 436 { 437 write(logfile, (char *) bp->data, bp->datasize); 438 wrote = TRUE; 439 break; 440 } 441 } 442 if (!wrote && !warned) 443 { 444 error("Warning: log file is incomplete", 445 NULL_PARG); 446 warned = TRUE; 447 } 448 } 449 } 450 451 #endif 452 453 /* 454 * Determine if a specific block is currently in one of the buffers. 455 */ 456 static int 457 buffered(block) 458 BLOCKNUM block; 459 { 460 struct buf *bp; 461 struct bufnode *bn; 462 int h; 463 464 h = BUFHASH(block); 465 FOR_BUFS_IN_CHAIN(h, bn) 466 { 467 bp = bufnode_buf(bn); 468 if (bp->block == block) 469 return (TRUE); 470 } 471 return (FALSE); 472 } 473 474 /* 475 * Seek to a specified position in the file. 476 * Return 0 if successful, non-zero if can't seek there. 477 */ 478 public int 479 ch_seek(pos) 480 POSITION pos; 481 { 482 BLOCKNUM new_block; 483 POSITION len; 484 485 if (thisfile == NULL) 486 return (0); 487 488 len = ch_length(); 489 if (pos < ch_zero() || (len != NULL_POSITION && pos > len)) 490 return (1); 491 492 new_block = pos / LBUFSIZE; 493 if (!(ch_flags & CH_CANSEEK) && pos != ch_fpos && !buffered(new_block)) 494 { 495 if (ch_fpos > pos) 496 return (1); 497 while (ch_fpos < pos) 498 { 499 if (ch_forw_get() == EOI) 500 return (1); 501 if (ABORT_SIGS()) 502 return (1); 503 } 504 return (0); 505 } 506 /* 507 * Set read pointer. 508 */ 509 ch_block = new_block; 510 ch_offset = pos % LBUFSIZE; 511 return (0); 512 } 513 514 /* 515 * Seek to the end of the file. 516 */ 517 public int 518 ch_end_seek(VOID_PARAM) 519 { 520 POSITION len; 521 522 if (thisfile == NULL) 523 return (0); 524 525 if (ch_flags & CH_CANSEEK) 526 ch_fsize = filesize(ch_file); 527 528 len = ch_length(); 529 if (len != NULL_POSITION) 530 return (ch_seek(len)); 531 532 /* 533 * Do it the slow way: read till end of data. 534 */ 535 while (ch_forw_get() != EOI) 536 if (ABORT_SIGS()) 537 return (1); 538 return (0); 539 } 540 541 /* 542 * Seek to the last position in the file that is currently buffered. 543 */ 544 public int 545 ch_end_buffer_seek(VOID_PARAM) 546 { 547 struct buf *bp; 548 struct bufnode *bn; 549 POSITION buf_pos; 550 POSITION end_pos; 551 552 if (thisfile == NULL || (ch_flags & CH_CANSEEK)) 553 return (ch_end_seek()); 554 555 end_pos = 0; 556 FOR_BUFS(bn) 557 { 558 bp = bufnode_buf(bn); 559 buf_pos = (bp->block * LBUFSIZE) + bp->datasize; 560 if (buf_pos > end_pos) 561 end_pos = buf_pos; 562 } 563 564 return (ch_seek(end_pos)); 565 } 566 567 /* 568 * Seek to the beginning of the file, or as close to it as we can get. 569 * We may not be able to seek there if input is a pipe and the 570 * beginning of the pipe is no longer buffered. 571 */ 572 public int 573 ch_beg_seek(VOID_PARAM) 574 { 575 struct bufnode *bn; 576 struct bufnode *firstbn; 577 578 /* 579 * Try a plain ch_seek first. 580 */ 581 if (ch_seek(ch_zero()) == 0) 582 return (0); 583 584 /* 585 * Can't get to position 0. 586 * Look thru the buffers for the one closest to position 0. 587 */ 588 firstbn = ch_bufhead; 589 if (firstbn == END_OF_CHAIN) 590 return (1); 591 FOR_BUFS(bn) 592 { 593 if (bufnode_buf(bn)->block < bufnode_buf(firstbn)->block) 594 firstbn = bn; 595 } 596 ch_block = bufnode_buf(firstbn)->block; 597 ch_offset = 0; 598 return (0); 599 } 600 601 /* 602 * Return the length of the file, if known. 603 */ 604 public POSITION 605 ch_length(VOID_PARAM) 606 { 607 if (thisfile == NULL) 608 return (NULL_POSITION); 609 if (ignore_eoi) 610 return (NULL_POSITION); 611 if (ch_flags & CH_HELPFILE) 612 return (size_helpdata); 613 if (ch_flags & CH_NODATA) 614 return (0); 615 return (ch_fsize); 616 } 617 618 /* 619 * Return the current position in the file. 620 */ 621 public POSITION 622 ch_tell(VOID_PARAM) 623 { 624 if (thisfile == NULL) 625 return (NULL_POSITION); 626 return (ch_block * LBUFSIZE) + ch_offset; 627 } 628 629 /* 630 * Get the current char and post-increment the read pointer. 631 */ 632 public int 633 ch_forw_get(VOID_PARAM) 634 { 635 int c; 636 637 if (thisfile == NULL) 638 return (EOI); 639 c = ch_get(); 640 if (c == EOI) 641 return (EOI); 642 if (ch_offset < LBUFSIZE-1) 643 ch_offset++; 644 else 645 { 646 ch_block ++; 647 ch_offset = 0; 648 } 649 return (c); 650 } 651 652 /* 653 * Pre-decrement the read pointer and get the new current char. 654 */ 655 public int 656 ch_back_get(VOID_PARAM) 657 { 658 if (thisfile == NULL) 659 return (EOI); 660 if (ch_offset > 0) 661 ch_offset --; 662 else 663 { 664 if (ch_block <= 0) 665 return (EOI); 666 if (!(ch_flags & CH_CANSEEK) && !buffered(ch_block-1)) 667 return (EOI); 668 ch_block--; 669 ch_offset = LBUFSIZE-1; 670 } 671 return (ch_get()); 672 } 673 674 /* 675 * Set max amount of buffer space. 676 * bufspace is in units of 1024 bytes. -1 mean no limit. 677 */ 678 public void 679 ch_setbufspace(bufspace) 680 int bufspace; 681 { 682 if (bufspace < 0) 683 maxbufs = -1; 684 else 685 { 686 maxbufs = ((bufspace * 1024) + LBUFSIZE-1) / LBUFSIZE; 687 if (maxbufs < 1) 688 maxbufs = 1; 689 } 690 } 691 692 /* 693 * Flush (discard) any saved file state, including buffer contents. 694 */ 695 public void 696 ch_flush(VOID_PARAM) 697 { 698 struct bufnode *bn; 699 700 if (thisfile == NULL) 701 return; 702 703 if (!(ch_flags & CH_CANSEEK)) 704 { 705 /* 706 * If input is a pipe, we don't flush buffer contents, 707 * since the contents can't be recovered. 708 */ 709 ch_fsize = NULL_POSITION; 710 return; 711 } 712 713 /* 714 * Initialize all the buffers. 715 */ 716 FOR_BUFS(bn) 717 { 718 bufnode_buf(bn)->block = -1; 719 } 720 721 /* 722 * Figure out the size of the file, if we can. 723 */ 724 ch_fsize = filesize(ch_file); 725 726 /* 727 * Seek to a known position: the beginning of the file. 728 */ 729 ch_fpos = 0; 730 ch_block = 0; /* ch_fpos / LBUFSIZE; */ 731 ch_offset = 0; /* ch_fpos % LBUFSIZE; */ 732 733 #if 1 734 /* 735 * This is a kludge to workaround a Linux kernel bug: files in 736 * /proc have a size of 0 according to fstat() but have readable 737 * data. They are sometimes, but not always, seekable. 738 * Force them to be non-seekable here. 739 */ 740 if (ch_fsize == 0) 741 { 742 ch_fsize = NULL_POSITION; 743 ch_flags &= ~CH_CANSEEK; 744 } 745 #endif 746 747 if (lseek(ch_file, (off_t)0, SEEK_SET) == BAD_LSEEK) 748 { 749 /* 750 * Warning only; even if the seek fails for some reason, 751 * there's a good chance we're at the beginning anyway. 752 * {{ I think this is bogus reasoning. }} 753 */ 754 error("seek error to 0", NULL_PARG); 755 } 756 } 757 758 /* 759 * Allocate a new buffer. 760 * The buffer is added to the tail of the buffer chain. 761 */ 762 static int 763 ch_addbuf(VOID_PARAM) 764 { 765 struct buf *bp; 766 struct bufnode *bn; 767 768 /* 769 * Allocate and initialize a new buffer and link it 770 * onto the tail of the buffer list. 771 */ 772 bp = (struct buf *) calloc(1, sizeof(struct buf)); 773 if (bp == NULL) 774 return (1); 775 ch_nbufs++; 776 bp->block = -1; 777 bn = &bp->node; 778 779 BUF_INS_TAIL(bn); 780 BUF_HASH_INS(bn, 0); 781 return (0); 782 } 783 784 /* 785 * 786 */ 787 static void 788 init_hashtbl(VOID_PARAM) 789 { 790 int h; 791 792 for (h = 0; h < BUFHASH_SIZE; h++) 793 { 794 thisfile->hashtbl[h].hnext = END_OF_HCHAIN(h); 795 thisfile->hashtbl[h].hprev = END_OF_HCHAIN(h); 796 } 797 } 798 799 /* 800 * Delete all buffers for this file. 801 */ 802 static void 803 ch_delbufs(VOID_PARAM) 804 { 805 struct bufnode *bn; 806 807 while (ch_bufhead != END_OF_CHAIN) 808 { 809 bn = ch_bufhead; 810 BUF_RM(bn); 811 free(bufnode_buf(bn)); 812 } 813 ch_nbufs = 0; 814 init_hashtbl(); 815 } 816 817 /* 818 * Is it possible to seek on a file descriptor? 819 */ 820 public int 821 seekable(f) 822 int f; 823 { 824 #if MSDOS_COMPILER 825 extern int fd0; 826 if (f == fd0 && !isatty(fd0)) 827 { 828 /* 829 * In MS-DOS, pipes are seekable. Check for 830 * standard input, and pretend it is not seekable. 831 */ 832 return (0); 833 } 834 #endif 835 return (lseek(f, (off_t)1, SEEK_SET) != BAD_LSEEK); 836 } 837 838 /* 839 * Force EOF to be at the current read position. 840 * This is used after an ignore_eof read, during which the EOF may change. 841 */ 842 public void 843 ch_set_eof(VOID_PARAM) 844 { 845 ch_fsize = ch_fpos; 846 } 847 848 849 /* 850 * Initialize file state for a new file. 851 */ 852 public void 853 ch_init(f, flags) 854 int f; 855 int flags; 856 { 857 /* 858 * See if we already have a filestate for this file. 859 */ 860 thisfile = (struct filestate *) get_filestate(curr_ifile); 861 if (thisfile == NULL) 862 { 863 /* 864 * Allocate and initialize a new filestate. 865 */ 866 thisfile = (struct filestate *) 867 calloc(1, sizeof(struct filestate)); 868 thisfile->buflist.next = thisfile->buflist.prev = END_OF_CHAIN; 869 thisfile->nbufs = 0; 870 thisfile->flags = flags; 871 thisfile->fpos = 0; 872 thisfile->block = 0; 873 thisfile->offset = 0; 874 thisfile->file = -1; 875 thisfile->fsize = NULL_POSITION; 876 init_hashtbl(); 877 /* 878 * Try to seek; set CH_CANSEEK if it works. 879 */ 880 if ((flags & CH_CANSEEK) && !seekable(f)) 881 ch_flags &= ~CH_CANSEEK; 882 set_filestate(curr_ifile, (void *) thisfile); 883 } 884 if (thisfile->file == -1) 885 thisfile->file = f; 886 ch_flush(); 887 } 888 889 /* 890 * Close a filestate. 891 */ 892 public void 893 ch_close(VOID_PARAM) 894 { 895 int keepstate = FALSE; 896 897 if (thisfile == NULL) 898 return; 899 900 if ((ch_flags & (CH_CANSEEK|CH_POPENED|CH_HELPFILE)) && !(ch_flags & CH_KEEPOPEN)) 901 { 902 /* 903 * We can seek or re-open, so we don't need to keep buffers. 904 */ 905 ch_delbufs(); 906 } else 907 keepstate = TRUE; 908 if (!(ch_flags & CH_KEEPOPEN)) 909 { 910 /* 911 * We don't need to keep the file descriptor open 912 * (because we can re-open it.) 913 * But don't really close it if it was opened via popen(), 914 * because pclose() wants to close it. 915 */ 916 if (!(ch_flags & (CH_POPENED|CH_HELPFILE))) 917 close(ch_file); 918 ch_file = -1; 919 } else 920 keepstate = TRUE; 921 if (!keepstate) 922 { 923 /* 924 * We don't even need to keep the filestate structure. 925 */ 926 free(thisfile); 927 thisfile = NULL; 928 set_filestate(curr_ifile, (void *) NULL); 929 } 930 } 931 932 /* 933 * Return ch_flags for the current file. 934 */ 935 public int 936 ch_getflags(VOID_PARAM) 937 { 938 if (thisfile == NULL) 939 return (0); 940 return (ch_flags); 941 } 942 943 #if 0 944 public void 945 ch_dump(struct filestate *fs) 946 { 947 struct buf *bp; 948 struct bufnode *bn; 949 unsigned char *s; 950 951 if (fs == NULL) 952 { 953 printf(" --no filestate\n"); 954 return; 955 } 956 printf(" file %d, flags %x, fpos %x, fsize %x, blk/off %x/%x\n", 957 fs->file, fs->flags, fs->fpos, 958 fs->fsize, fs->block, fs->offset); 959 printf(" %d bufs:\n", fs->nbufs); 960 for (bn = fs->next; bn != &fs->buflist; bn = bn->next) 961 { 962 bp = bufnode_buf(bn); 963 printf("%x: blk %x, size %x \"", 964 bp, bp->block, bp->datasize); 965 for (s = bp->data; s < bp->data + 30; s++) 966 if (*s >= ' ' && *s < 0x7F) 967 printf("%c", *s); 968 else 969 printf("."); 970 printf("\"\n"); 971 } 972 } 973 #endif 974