1 /* 2 * Copyright (C) 1984-2012 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 64 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() 148 { 149 register struct buf *bp; 150 register struct bufnode *bn; 151 register int n; 152 register int slept; 153 register 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 * If so, force the file to be closed and 328 * reopened. */ 329 struct stat st; 330 int r = stat(get_filename(curr_ifile), &st); 331 if (r == 0 && (st.st_ino != curr_ino || 332 st.st_dev != curr_dev)) 333 { 334 /* screen_trashed=2 causes 335 * make_display to reopen the file. */ 336 screen_trashed = 2; 337 return (EOI); 338 } 339 } 340 #endif 341 } 342 if (sigs) 343 return (EOI); 344 } 345 346 found: 347 if (ch_bufhead != bn) 348 { 349 /* 350 * Move the buffer to the head of the buffer chain. 351 * This orders the buffer chain, most- to least-recently used. 352 */ 353 BUF_RM(bn); 354 BUF_INS_HEAD(bn); 355 356 /* 357 * Move to head of hash chain too. 358 */ 359 BUF_HASH_RM(bn); 360 BUF_HASH_INS(bn, h); 361 } 362 363 if (ch_offset >= bp->datasize) 364 /* 365 * After all that, we still don't have enough data. 366 * Go back and try again. 367 */ 368 goto read_more; 369 370 return (bp->data[ch_offset]); 371 } 372 373 /* 374 * ch_ungetchar is a rather kludgy and limited way to push 375 * a single char onto an input file descriptor. 376 */ 377 public void 378 ch_ungetchar(c) 379 int c; 380 { 381 if (c != -1 && ch_ungotchar != -1) 382 error("ch_ungetchar overrun", NULL_PARG); 383 ch_ungotchar = c; 384 } 385 386 #if LOGFILE 387 /* 388 * Close the logfile. 389 * If we haven't read all of standard input into it, do that now. 390 */ 391 public void 392 end_logfile() 393 { 394 static int tried = FALSE; 395 396 if (logfile < 0) 397 return; 398 if (!tried && ch_fsize == NULL_POSITION) 399 { 400 tried = TRUE; 401 ierror("Finishing logfile", NULL_PARG); 402 while (ch_forw_get() != EOI) 403 if (ABORT_SIGS()) 404 break; 405 } 406 close(logfile); 407 logfile = -1; 408 namelogfile = NULL; 409 } 410 411 /* 412 * Start a log file AFTER less has already been running. 413 * Invoked from the - command; see toggle_option(). 414 * Write all the existing buffered data to the log file. 415 */ 416 public void 417 sync_logfile() 418 { 419 register struct buf *bp; 420 register struct bufnode *bn; 421 int warned = FALSE; 422 BLOCKNUM block; 423 BLOCKNUM nblocks; 424 425 nblocks = (ch_fpos + LBUFSIZE - 1) / LBUFSIZE; 426 for (block = 0; block < nblocks; block++) 427 { 428 int wrote = FALSE; 429 FOR_BUFS(bn) 430 { 431 bp = bufnode_buf(bn); 432 if (bp->block == block) 433 { 434 write(logfile, (char *) bp->data, bp->datasize); 435 wrote = TRUE; 436 break; 437 } 438 } 439 if (!wrote && !warned) 440 { 441 error("Warning: log file is incomplete", 442 NULL_PARG); 443 warned = TRUE; 444 } 445 } 446 } 447 448 #endif 449 450 /* 451 * Determine if a specific block is currently in one of the buffers. 452 */ 453 static int 454 buffered(block) 455 BLOCKNUM block; 456 { 457 register struct buf *bp; 458 register struct bufnode *bn; 459 register int h; 460 461 h = BUFHASH(block); 462 FOR_BUFS_IN_CHAIN(h, bn) 463 { 464 bp = bufnode_buf(bn); 465 if (bp->block == block) 466 return (TRUE); 467 } 468 return (FALSE); 469 } 470 471 /* 472 * Seek to a specified position in the file. 473 * Return 0 if successful, non-zero if can't seek there. 474 */ 475 public int 476 ch_seek(pos) 477 register POSITION pos; 478 { 479 BLOCKNUM new_block; 480 POSITION len; 481 482 if (thisfile == NULL) 483 return (0); 484 485 len = ch_length(); 486 if (pos < ch_zero() || (len != NULL_POSITION && pos > len)) 487 return (1); 488 489 new_block = pos / LBUFSIZE; 490 if (!(ch_flags & CH_CANSEEK) && pos != ch_fpos && !buffered(new_block)) 491 { 492 if (ch_fpos > pos) 493 return (1); 494 while (ch_fpos < pos) 495 { 496 if (ch_forw_get() == EOI) 497 return (1); 498 if (ABORT_SIGS()) 499 return (1); 500 } 501 return (0); 502 } 503 /* 504 * Set read pointer. 505 */ 506 ch_block = new_block; 507 ch_offset = pos % LBUFSIZE; 508 return (0); 509 } 510 511 /* 512 * Seek to the end of the file. 513 */ 514 public int 515 ch_end_seek() 516 { 517 POSITION len; 518 519 if (thisfile == NULL) 520 return (0); 521 522 if (ch_flags & CH_CANSEEK) 523 ch_fsize = filesize(ch_file); 524 525 len = ch_length(); 526 if (len != NULL_POSITION) 527 return (ch_seek(len)); 528 529 /* 530 * Do it the slow way: read till end of data. 531 */ 532 while (ch_forw_get() != EOI) 533 if (ABORT_SIGS()) 534 return (1); 535 return (0); 536 } 537 538 /* 539 * Seek to the beginning of the file, or as close to it as we can get. 540 * We may not be able to seek there if input is a pipe and the 541 * beginning of the pipe is no longer buffered. 542 */ 543 public int 544 ch_beg_seek() 545 { 546 register struct bufnode *bn; 547 register struct bufnode *firstbn; 548 549 /* 550 * Try a plain ch_seek first. 551 */ 552 if (ch_seek(ch_zero()) == 0) 553 return (0); 554 555 /* 556 * Can't get to position 0. 557 * Look thru the buffers for the one closest to position 0. 558 */ 559 firstbn = ch_bufhead; 560 if (firstbn == END_OF_CHAIN) 561 return (1); 562 FOR_BUFS(bn) 563 { 564 if (bufnode_buf(bn)->block < bufnode_buf(firstbn)->block) 565 firstbn = bn; 566 } 567 ch_block = bufnode_buf(firstbn)->block; 568 ch_offset = 0; 569 return (0); 570 } 571 572 /* 573 * Return the length of the file, if known. 574 */ 575 public POSITION 576 ch_length() 577 { 578 if (thisfile == NULL) 579 return (NULL_POSITION); 580 if (ignore_eoi) 581 return (NULL_POSITION); 582 if (ch_flags & CH_HELPFILE) 583 return (size_helpdata); 584 if (ch_flags & CH_NODATA) 585 return (0); 586 return (ch_fsize); 587 } 588 589 /* 590 * Return the current position in the file. 591 */ 592 public POSITION 593 ch_tell() 594 { 595 if (thisfile == NULL) 596 return (NULL_POSITION); 597 return (ch_block * LBUFSIZE) + ch_offset; 598 } 599 600 /* 601 * Get the current char and post-increment the read pointer. 602 */ 603 public int 604 ch_forw_get() 605 { 606 register int c; 607 608 if (thisfile == NULL) 609 return (EOI); 610 c = ch_get(); 611 if (c == EOI) 612 return (EOI); 613 if (ch_offset < LBUFSIZE-1) 614 ch_offset++; 615 else 616 { 617 ch_block ++; 618 ch_offset = 0; 619 } 620 return (c); 621 } 622 623 /* 624 * Pre-decrement the read pointer and get the new current char. 625 */ 626 public int 627 ch_back_get() 628 { 629 if (thisfile == NULL) 630 return (EOI); 631 if (ch_offset > 0) 632 ch_offset --; 633 else 634 { 635 if (ch_block <= 0) 636 return (EOI); 637 if (!(ch_flags & CH_CANSEEK) && !buffered(ch_block-1)) 638 return (EOI); 639 ch_block--; 640 ch_offset = LBUFSIZE-1; 641 } 642 return (ch_get()); 643 } 644 645 /* 646 * Set max amount of buffer space. 647 * bufspace is in units of 1024 bytes. -1 mean no limit. 648 */ 649 public void 650 ch_setbufspace(bufspace) 651 int bufspace; 652 { 653 if (bufspace < 0) 654 maxbufs = -1; 655 else 656 { 657 maxbufs = ((bufspace * 1024) + LBUFSIZE-1) / LBUFSIZE; 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 667 ch_flush() 668 { 669 register struct bufnode *bn; 670 671 if (thisfile == NULL) 672 return; 673 674 if (!(ch_flags & CH_CANSEEK)) 675 { 676 /* 677 * If input is a pipe, we don't flush buffer contents, 678 * since the contents can't be recovered. 679 */ 680 ch_fsize = NULL_POSITION; 681 return; 682 } 683 684 /* 685 * Initialize all the buffers. 686 */ 687 FOR_BUFS(bn) 688 { 689 bufnode_buf(bn)->block = -1; 690 } 691 692 /* 693 * Figure out the size of the file, if we can. 694 */ 695 ch_fsize = filesize(ch_file); 696 697 /* 698 * Seek to a known position: the beginning of the file. 699 */ 700 ch_fpos = 0; 701 ch_block = 0; /* ch_fpos / LBUFSIZE; */ 702 ch_offset = 0; /* ch_fpos % LBUFSIZE; */ 703 704 #if 1 705 /* 706 * This is a kludge to workaround a Linux kernel bug: files in 707 * /proc have a size of 0 according to fstat() but have readable 708 * data. They are sometimes, but not always, seekable. 709 * Force them to be non-seekable here. 710 */ 711 if (ch_fsize == 0) 712 { 713 ch_fsize = NULL_POSITION; 714 ch_flags &= ~CH_CANSEEK; 715 } 716 #endif 717 718 if (lseek(ch_file, (off_t)0, SEEK_SET) == BAD_LSEEK) 719 { 720 /* 721 * Warning only; even if the seek fails for some reason, 722 * there's a good chance we're at the beginning anyway. 723 * {{ I think this is bogus reasoning. }} 724 */ 725 error("seek error to 0", NULL_PARG); 726 } 727 } 728 729 /* 730 * Allocate a new buffer. 731 * The buffer is added to the tail of the buffer chain. 732 */ 733 static int 734 ch_addbuf() 735 { 736 register struct buf *bp; 737 register struct bufnode *bn; 738 739 /* 740 * Allocate and initialize a new buffer and link it 741 * onto the tail of the buffer list. 742 */ 743 bp = (struct buf *) calloc(1, sizeof(struct buf)); 744 if (bp == NULL) 745 return (1); 746 ch_nbufs++; 747 bp->block = -1; 748 bn = &bp->node; 749 750 BUF_INS_TAIL(bn); 751 BUF_HASH_INS(bn, 0); 752 return (0); 753 } 754 755 /* 756 * 757 */ 758 static void 759 init_hashtbl() 760 { 761 register int h; 762 763 for (h = 0; h < BUFHASH_SIZE; h++) 764 { 765 thisfile->hashtbl[h].hnext = END_OF_HCHAIN(h); 766 thisfile->hashtbl[h].hprev = END_OF_HCHAIN(h); 767 } 768 } 769 770 /* 771 * Delete all buffers for this file. 772 */ 773 static void 774 ch_delbufs() 775 { 776 register struct bufnode *bn; 777 778 while (ch_bufhead != END_OF_CHAIN) 779 { 780 bn = ch_bufhead; 781 BUF_RM(bn); 782 free(bufnode_buf(bn)); 783 } 784 ch_nbufs = 0; 785 init_hashtbl(); 786 } 787 788 /* 789 * Is it possible to seek on a file descriptor? 790 */ 791 public int 792 seekable(f) 793 int f; 794 { 795 #if MSDOS_COMPILER 796 extern int fd0; 797 if (f == fd0 && !isatty(fd0)) 798 { 799 /* 800 * In MS-DOS, pipes are seekable. Check for 801 * standard input, and pretend it is not seekable. 802 */ 803 return (0); 804 } 805 #endif 806 return (lseek(f, (off_t)1, SEEK_SET) != BAD_LSEEK); 807 } 808 809 /* 810 * Force EOF to be at the current read position. 811 * This is used after an ignore_eof read, during which the EOF may change. 812 */ 813 public void 814 ch_set_eof() 815 { 816 ch_fsize = ch_fpos; 817 } 818 819 820 /* 821 * Initialize file state for a new file. 822 */ 823 public void 824 ch_init(f, flags) 825 int f; 826 int flags; 827 { 828 /* 829 * See if we already have a filestate for this file. 830 */ 831 thisfile = (struct filestate *) get_filestate(curr_ifile); 832 if (thisfile == NULL) 833 { 834 /* 835 * Allocate and initialize a new filestate. 836 */ 837 thisfile = (struct filestate *) 838 calloc(1, sizeof(struct filestate)); 839 thisfile->buflist.next = thisfile->buflist.prev = END_OF_CHAIN; 840 thisfile->nbufs = 0; 841 thisfile->flags = 0; 842 thisfile->fpos = 0; 843 thisfile->block = 0; 844 thisfile->offset = 0; 845 thisfile->file = -1; 846 thisfile->fsize = NULL_POSITION; 847 ch_flags = flags; 848 init_hashtbl(); 849 /* 850 * Try to seek; set CH_CANSEEK if it works. 851 */ 852 if ((flags & CH_CANSEEK) && !seekable(f)) 853 ch_flags &= ~CH_CANSEEK; 854 set_filestate(curr_ifile, (void *) thisfile); 855 } 856 if (thisfile->file == -1) 857 thisfile->file = f; 858 ch_flush(); 859 } 860 861 /* 862 * Close a filestate. 863 */ 864 public void 865 ch_close() 866 { 867 int keepstate = FALSE; 868 869 if (thisfile == NULL) 870 return; 871 872 if (ch_flags & (CH_CANSEEK|CH_POPENED|CH_HELPFILE)) 873 { 874 /* 875 * We can seek or re-open, so we don't need to keep buffers. 876 */ 877 ch_delbufs(); 878 } else 879 keepstate = TRUE; 880 if (!(ch_flags & CH_KEEPOPEN)) 881 { 882 /* 883 * We don't need to keep the file descriptor open 884 * (because we can re-open it.) 885 * But don't really close it if it was opened via popen(), 886 * because pclose() wants to close it. 887 */ 888 if (!(ch_flags & (CH_POPENED|CH_HELPFILE))) 889 close(ch_file); 890 ch_file = -1; 891 } else 892 keepstate = TRUE; 893 if (!keepstate) 894 { 895 /* 896 * We don't even need to keep the filestate structure. 897 */ 898 free(thisfile); 899 thisfile = NULL; 900 set_filestate(curr_ifile, (void *) NULL); 901 } 902 } 903 904 /* 905 * Return ch_flags for the current file. 906 */ 907 public int 908 ch_getflags() 909 { 910 if (thisfile == NULL) 911 return (0); 912 return (ch_flags); 913 } 914 915 #if 0 916 public void 917 ch_dump(struct filestate *fs) 918 { 919 struct buf *bp; 920 struct bufnode *bn; 921 unsigned char *s; 922 923 if (fs == NULL) 924 { 925 printf(" --no filestate\n"); 926 return; 927 } 928 printf(" file %d, flags %x, fpos %x, fsize %x, blk/off %x/%x\n", 929 fs->file, fs->flags, fs->fpos, 930 fs->fsize, fs->block, fs->offset); 931 printf(" %d bufs:\n", fs->nbufs); 932 for (bn = fs->next; bn != &fs->buflist; bn = bn->next) 933 { 934 bp = bufnode_buf(bn); 935 printf("%x: blk %x, size %x \"", 936 bp, bp->block, bp->datasize); 937 for (s = bp->data; s < bp->data + 30; s++) 938 if (*s >= ' ' && *s < 0x7F) 939 printf("%c", *s); 940 else 941 printf("."); 942 printf("\"\n"); 943 } 944 } 945 #endif 946