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