![[BACK]](/icons/back.gif){kind=icon}
Return to ch.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / less|
Return to ch.c CVS log | Up to [local] / src / usr.bin / less |
1.1 ! etheisen 1: /*
! 2: * Copyright (c) 1984,1985,1989,1994,1995 Mark Nudelman
! 3: * All rights reserved.
! 4: *
! 5: * Redistribution and use in source and binary forms, with or without
! 6: * modification, are permitted provided that the following conditions
! 7: * are met:
! 8: * 1. Redistributions of source code must retain the above copyright
! 9: * notice, this list of conditions and the following disclaimer.
! 10: * 2. Redistributions in binary form must reproduce the above copyright
! 11: * notice in the documentation and/or other materials provided with
! 12: * the distribution.
! 13: *
! 14: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY
! 15: * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 16: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
! 17: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE
! 18: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
! 19: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
! 20: * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
! 21: * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
! 22: * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
! 23: * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
! 24: * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 25: */
! 26:
! 27:
! 28: /*
! 29: * Low level character input from the input file.
! 30: * We use these special purpose routines which optimize moving
! 31: * both forward and backward from the current read pointer.
! 32: */
! 33:
! 34: #include "less.h"
! 35:
! 36: public int ignore_eoi;
! 37:
! 38: /*
! 39: * Pool of buffers holding the most recently used blocks of the input file.
! 40: * The buffer pool is kept as a doubly-linked circular list,
! 41: * in order from most- to least-recently used.
! 42: * The circular list is anchored by the file state "thisfile".
! 43: */
! 44: #define LBUFSIZE 1024
! 45: struct buf {
! 46: struct buf *next, *prev; /* Must be first to match struct filestate */
! 47: long block;
! 48: unsigned int datasize;
! 49: unsigned char data[LBUFSIZE];
! 50: };
! 51:
! 52: /*
! 53: * The file state is maintained in a filestate structure.
! 54: * A pointer to the filestate is kept in the ifile structure.
! 55: */
! 56: struct filestate {
! 57: /* -- Following members must match struct buf */
! 58: struct buf *buf_next, *buf_prev;
! 59: long buf_block;
! 60: /* -- End of struct buf copy */
! 61: int file;
! 62: int flags;
! 63: POSITION fpos;
! 64: int nbufs;
! 65: long block;
! 66: int offset;
! 67: POSITION fsize;
! 68: };
! 69:
! 70:
! 71: #define END_OF_CHAIN ((struct buf *)thisfile)
! 72: #define ch_bufhead thisfile->buf_next
! 73: #define ch_buftail thisfile->buf_prev
! 74: #define ch_nbufs thisfile->nbufs
! 75: #define ch_block thisfile->block
! 76: #define ch_offset thisfile->offset
! 77: #define ch_fpos thisfile->fpos
! 78: #define ch_fsize thisfile->fsize
! 79: #define ch_flags thisfile->flags
! 80: #define ch_file thisfile->file
! 81:
! 82: static struct filestate *thisfile;
! 83: static int ch_ungotchar = -1;
! 84:
! 85: extern int autobuf;
! 86: extern int sigs;
! 87: extern int cbufs;
! 88: extern IFILE curr_ifile;
! 89: #if LOGFILE
! 90: extern int logfile;
! 91: extern char *namelogfile;
! 92: #endif
! 93:
! 94: static int ch_addbuf();
! 95:
! 96:
! 97: /*
! 98: * Get the character pointed to by the read pointer.
! 99: * ch_get() is a macro which is more efficient to call
! 100: * than fch_get (the function), in the usual case
! 101: * that the block desired is at the head of the chain.
! 102: */
! 103: #define ch_get() ((ch_block == ch_bufhead->block && \
! 104: ch_offset < ch_bufhead->datasize) ? \
! 105: ch_bufhead->data[ch_offset] : fch_get())
! 106: int
! 107: fch_get()
! 108: {
! 109: register struct buf *bp;
! 110: register int n;
! 111: register int slept;
! 112: POSITION pos;
! 113: POSITION len;
! 114:
! 115: slept = FALSE;
! 116:
! 117: /*
! 118: * Look for a buffer holding the desired block.
! 119: */
! 120: for (bp = ch_bufhead; bp != END_OF_CHAIN; bp = bp->next)
! 121: if (bp->block == ch_block)
! 122: {
! 123: if (ch_offset >= bp->datasize)
! 124: /*
! 125: * Need more data in this buffer.
! 126: */
! 127: goto read_more;
! 128: goto found;
! 129: }
! 130: /*
! 131: * Block is not in a buffer.
! 132: * Take the least recently used buffer
! 133: * and read the desired block into it.
! 134: * If the LRU buffer has data in it,
! 135: * then maybe allocate a new buffer.
! 136: */
! 137: if (ch_buftail == END_OF_CHAIN || ch_buftail->block != (long)(-1))
! 138: {
! 139: /*
! 140: * There is no empty buffer to use.
! 141: * Allocate a new buffer if:
! 142: * 1. We can't seek on this file and -b is not in effect; or
! 143: * 2. We haven't allocated the max buffers for this file yet.
! 144: */
! 145: if ((autobuf && !(ch_flags & CH_CANSEEK)) ||
! 146: (cbufs == -1 || ch_nbufs < cbufs))
! 147: if (ch_addbuf())
! 148: /*
! 149: * Allocation failed: turn off autobuf.
! 150: */
! 151: autobuf = OPT_OFF;
! 152: }
! 153: bp = ch_buftail;
! 154: bp->block = ch_block;
! 155: bp->datasize = 0;
! 156:
! 157: read_more:
! 158: pos = (ch_block * LBUFSIZE) + bp->datasize;
! 159: if ((len = ch_length()) != NULL_POSITION && pos >= len)
! 160: /*
! 161: * At end of file.
! 162: */
! 163: return (EOI);
! 164:
! 165: if (pos != ch_fpos)
! 166: {
! 167: /*
! 168: * Not at the correct position: must seek.
! 169: * If input is a pipe, we're in trouble (can't seek on a pipe).
! 170: * Some data has been lost: just return "?".
! 171: */
! 172: if (!(ch_flags & CH_CANSEEK))
! 173: return ('?');
! 174: if (lseek(ch_file, (off_t)pos, 0) == BAD_LSEEK)
! 175: {
! 176: error("seek error", NULL_PARG);
! 177: clear_eol();
! 178: return (EOI);
! 179: }
! 180: ch_fpos = pos;
! 181: }
! 182:
! 183: /*
! 184: * Read the block.
! 185: * If we read less than a full block, that's ok.
! 186: * We use partial block and pick up the rest next time.
! 187: */
! 188: if (ch_ungotchar == -1)
! 189: {
! 190: n = iread(ch_file, &bp->data[bp->datasize],
! 191: (unsigned int)(LBUFSIZE - bp->datasize));
! 192: } else
! 193: {
! 194: bp->data[bp->datasize] = ch_ungotchar;
! 195: n = 1;
! 196: ch_ungotchar = -1;
! 197: }
! 198:
! 199: if (n == READ_INTR)
! 200: return (EOI);
! 201: if (n < 0)
! 202: {
! 203: error("read error", NULL_PARG);
! 204: clear_eol();
! 205: n = 0;
! 206: }
! 207:
! 208: #if LOGFILE
! 209: /*
! 210: * If we have a log file, write the new data to it.
! 211: */
! 212: if (logfile >= 0 && n > 0)
! 213: write(logfile, (char *) &bp->data[bp->datasize], n);
! 214: #endif
! 215:
! 216: ch_fpos += n;
! 217: bp->datasize += n;
! 218:
! 219: /*
! 220: * If we have read to end of file, set ch_fsize to indicate
! 221: * the position of the end of file.
! 222: */
! 223: if (n == 0)
! 224: {
! 225: ch_fsize = pos;
! 226: if (ignore_eoi)
! 227: {
! 228: /*
! 229: * We are ignoring EOF.
! 230: * Wait a while, then try again.
! 231: */
! 232: if (!slept)
! 233: ierror("Waiting for data", NULL_PARG);
! 234: #if !MSOFTC
! 235: sleep(1);
! 236: #endif
! 237: slept = TRUE;
! 238: }
! 239: if (ABORT_SIGS())
! 240: return (EOI);
! 241: }
! 242:
! 243: found:
! 244: if (ch_bufhead != bp)
! 245: {
! 246: /*
! 247: * Move the buffer to the head of the buffer chain.
! 248: * This orders the buffer chain, most- to least-recently used.
! 249: */
! 250: bp->next->prev = bp->prev;
! 251: bp->prev->next = bp->next;
! 252:
! 253: bp->next = ch_bufhead;
! 254: bp->prev = END_OF_CHAIN;
! 255: ch_bufhead->prev = bp;
! 256: ch_bufhead = bp;
! 257: }
! 258:
! 259: if (ch_offset >= bp->datasize)
! 260: /*
! 261: * After all that, we still don't have enough data.
! 262: * Go back and try again.
! 263: */
! 264: goto read_more;
! 265:
! 266: return (bp->data[ch_offset]);
! 267: }
! 268:
! 269: /*
! 270: * ch_ungetchar is a rather kludgy and limited way to push
! 271: * a single char onto an input file descriptor.
! 272: */
! 273: public void
! 274: ch_ungetchar(c)
! 275: int c;
! 276: {
! 277: if (c != -1 && ch_ungotchar != -1)
! 278: error("ch_ungetchar overrun", NULL_PARG);
! 279: ch_ungotchar = c;
! 280: }
! 281:
! 282: #if LOGFILE
! 283: /*
! 284: * Close the logfile.
! 285: * If we haven't read all of standard input into it, do that now.
! 286: */
! 287: public void
! 288: end_logfile()
! 289: {
! 290: static int tried = FALSE;
! 291:
! 292: if (logfile < 0)
! 293: return;
! 294: if (!tried && ch_fsize == NULL_POSITION)
! 295: {
! 296: tried = TRUE;
! 297: ierror("Finishing logfile", NULL_PARG);
! 298: while (ch_forw_get() != EOI)
! 299: if (ABORT_SIGS())
! 300: break;
! 301: }
! 302: close(logfile);
! 303: logfile = -1;
! 304: namelogfile = NULL;
! 305: }
! 306:
! 307: /*
! 308: * Start a log file AFTER less has already been running.
! 309: * Invoked from the - command; see toggle_option().
! 310: * Write all the existing buffered data to the log file.
! 311: */
! 312: public void
! 313: sync_logfile()
! 314: {
! 315: register struct buf *bp;
! 316: int warned = FALSE;
! 317: long block;
! 318: long nblocks;
! 319:
! 320: nblocks = (ch_fpos + LBUFSIZE - 1) / LBUFSIZE;
! 321: for (block = 0; block < nblocks; block++)
! 322: {
! 323: for (bp = ch_bufhead; ; bp = bp->next)
! 324: {
! 325: if (bp == END_OF_CHAIN)
! 326: {
! 327: if (!warned)
! 328: {
! 329: error("Warning: log file is incomplete",
! 330: NULL_PARG);
! 331: warned = TRUE;
! 332: }
! 333: break;
! 334: }
! 335: if (bp->block == block)
! 336: {
! 337: write(logfile, (char *) bp->data, bp->datasize);
! 338: break;
! 339: }
! 340: }
! 341: }
! 342: }
! 343:
! 344: #endif
! 345:
! 346: /*
! 347: * Determine if a specific block is currently in one of the buffers.
! 348: */
! 349: static int
! 350: buffered(block)
! 351: long block;
! 352: {
! 353: register struct buf *bp;
! 354:
! 355: for (bp = ch_bufhead; bp != END_OF_CHAIN; bp = bp->next)
! 356: if (bp->block == block)
! 357: return (TRUE);
! 358: return (FALSE);
! 359: }
! 360:
! 361: /*
! 362: * Seek to a specified position in the file.
! 363: * Return 0 if successful, non-zero if can't seek there.
! 364: */
! 365: public int
! 366: ch_seek(pos)
! 367: register POSITION pos;
! 368: {
! 369: long new_block;
! 370: POSITION len;
! 371:
! 372: len = ch_length();
! 373: if (pos < ch_zero() || (len != NULL_POSITION && pos > len))
! 374: return (1);
! 375:
! 376: new_block = pos / LBUFSIZE;
! 377: if (!(ch_flags & CH_CANSEEK) && pos != ch_fpos && !buffered(new_block))
! 378: {
! 379: if (ch_fpos > pos)
! 380: return (1);
! 381: while (ch_fpos < pos)
! 382: {
! 383: if (ch_forw_get() == EOI)
! 384: return (1);
! 385: if (ABORT_SIGS())
! 386: return (1);
! 387: }
! 388: return (0);
! 389: }
! 390: /*
! 391: * Set read pointer.
! 392: */
! 393: ch_block = new_block;
! 394: ch_offset = pos % LBUFSIZE;
! 395: return (0);
! 396: }
! 397:
! 398: /*
! 399: * Seek to the end of the file.
! 400: */
! 401: public int
! 402: ch_end_seek()
! 403: {
! 404: POSITION len;
! 405:
! 406: if (ch_flags & CH_CANSEEK)
! 407: ch_fsize = filesize(ch_file);
! 408:
! 409: len = ch_length();
! 410: if (len != NULL_POSITION)
! 411: return (ch_seek(len));
! 412:
! 413: /*
! 414: * Do it the slow way: read till end of data.
! 415: */
! 416: while (ch_forw_get() != EOI)
! 417: if (ABORT_SIGS())
! 418: return (1);
! 419: return (0);
! 420: }
! 421:
! 422: /*
! 423: * Seek to the beginning of the file, or as close to it as we can get.
! 424: * We may not be able to seek there if input is a pipe and the
! 425: * beginning of the pipe is no longer buffered.
! 426: */
! 427: public int
! 428: ch_beg_seek()
! 429: {
! 430: register struct buf *bp, *firstbp;
! 431:
! 432: /*
! 433: * Try a plain ch_seek first.
! 434: */
! 435: if (ch_seek(ch_zero()) == 0)
! 436: return (0);
! 437:
! 438: /*
! 439: * Can't get to position 0.
! 440: * Look thru the buffers for the one closest to position 0.
! 441: */
! 442: firstbp = bp = ch_bufhead;
! 443: if (bp == END_OF_CHAIN)
! 444: return (1);
! 445: while ((bp = bp->next) != END_OF_CHAIN)
! 446: if (bp->block < firstbp->block)
! 447: firstbp = bp;
! 448: ch_block = firstbp->block;
! 449: ch_offset = 0;
! 450: return (0);
! 451: }
! 452:
! 453: /*
! 454: * Return the length of the file, if known.
! 455: */
! 456: public POSITION
! 457: ch_length()
! 458: {
! 459: if (ignore_eoi)
! 460: return (NULL_POSITION);
! 461: return (ch_fsize);
! 462: }
! 463:
! 464: /*
! 465: * Return the current position in the file.
! 466: */
! 467: #define tellpos(blk,off) ((POSITION)((((long)(blk)) * LBUFSIZE) + (off)))
! 468:
! 469: public POSITION
! 470: ch_tell()
! 471: {
! 472: return (tellpos(ch_block, ch_offset));
! 473: }
! 474:
! 475: /*
! 476: * Get the current char and post-increment the read pointer.
! 477: */
! 478: public int
! 479: ch_forw_get()
! 480: {
! 481: register int c;
! 482:
! 483: c = ch_get();
! 484: if (c == EOI)
! 485: return (EOI);
! 486: if (ch_offset < LBUFSIZE-1)
! 487: ch_offset++;
! 488: else
! 489: {
! 490: ch_block ++;
! 491: ch_offset = 0;
! 492: }
! 493: return (c);
! 494: }
! 495:
! 496: /*
! 497: * Pre-decrement the read pointer and get the new current char.
! 498: */
! 499: public int
! 500: ch_back_get()
! 501: {
! 502: if (ch_offset > 0)
! 503: ch_offset --;
! 504: else
! 505: {
! 506: if (ch_block <= 0)
! 507: return (EOI);
! 508: if (!(ch_flags & CH_CANSEEK) && !buffered(ch_block-1))
! 509: return (EOI);
! 510: ch_block--;
! 511: ch_offset = LBUFSIZE-1;
! 512: }
! 513: return (ch_get());
! 514: }
! 515:
! 516: /*
! 517: * Allocate buffers.
! 518: * Caller wants us to have a total of at least want_nbufs buffers.
! 519: */
! 520: public int
! 521: ch_nbuf(want_nbufs)
! 522: int want_nbufs;
! 523: {
! 524: PARG parg;
! 525:
! 526: while (ch_nbufs < want_nbufs)
! 527: {
! 528: if (ch_addbuf())
! 529: {
! 530: /*
! 531: * Cannot allocate enough buffers.
! 532: * If we don't have ANY, then quit.
! 533: * Otherwise, just report the error and return.
! 534: */
! 535: parg.p_int = want_nbufs - ch_nbufs;
! 536: error("Cannot allocate %d buffers", &parg);
! 537: if (ch_nbufs == 0)
! 538: quit(QUIT_ERROR);
! 539: break;
! 540: }
! 541: }
! 542: return (ch_nbufs);
! 543: }
! 544:
! 545: /*
! 546: * Flush (discard) any saved file state, including buffer contents.
! 547: */
! 548: public void
! 549: ch_flush()
! 550: {
! 551: register struct buf *bp;
! 552:
! 553: if (!(ch_flags & CH_CANSEEK))
! 554: {
! 555: /*
! 556: * If input is a pipe, we don't flush buffer contents,
! 557: * since the contents can't be recovered.
! 558: */
! 559: ch_fsize = NULL_POSITION;
! 560: return;
! 561: }
! 562:
! 563: /*
! 564: * Initialize all the buffers.
! 565: */
! 566: for (bp = ch_bufhead; bp != END_OF_CHAIN; bp = bp->next)
! 567: bp->block = (long)(-1);
! 568:
! 569: /*
! 570: * Figure out the size of the file, if we can.
! 571: */
! 572: ch_fsize = filesize(ch_file);
! 573:
! 574: /*
! 575: * Seek to a known position: the beginning of the file.
! 576: */
! 577: ch_fpos = 0;
! 578: ch_block = 0; /* ch_fpos / LBUFSIZE; */
! 579: ch_offset = 0; /* ch_fpos % LBUFSIZE; */
! 580:
! 581: if (lseek(ch_file, (off_t)0, 0) == BAD_LSEEK)
! 582: {
! 583: /*
! 584: * Warning only; even if the seek fails for some reason,
! 585: * there's a good chance we're at the beginning anyway.
! 586: * {{ I think this is bogus reasoning. }}
! 587: */
! 588: error("seek error to 0", NULL_PARG);
! 589: }
! 590: }
! 591:
! 592: /*
! 593: * Allocate a new buffer.
! 594: * The buffer is added to the tail of the buffer chain.
! 595: */
! 596: static int
! 597: ch_addbuf()
! 598: {
! 599: register struct buf *bp;
! 600:
! 601: /*
! 602: * Allocate and initialize a new buffer and link it
! 603: * onto the tail of the buffer list.
! 604: */
! 605: bp = (struct buf *) calloc(1, sizeof(struct buf));
! 606: if (bp == NULL)
! 607: return (1);
! 608: ch_nbufs++;
! 609: bp->block = (long)(-1);
! 610: bp->next = END_OF_CHAIN;
! 611: bp->prev = ch_buftail;
! 612: ch_buftail->next = bp;
! 613: ch_buftail = bp;
! 614: return (0);
! 615: }
! 616:
! 617: /*
! 618: * Delete all buffers for this file.
! 619: */
! 620: static void
! 621: ch_delbufs()
! 622: {
! 623: register struct buf *bp;
! 624:
! 625: while (ch_bufhead != END_OF_CHAIN)
! 626: {
! 627: bp = ch_bufhead;
! 628: bp->next->prev = bp->prev;;
! 629: bp->prev->next = bp->next;
! 630: free(bp);
! 631: }
! 632: ch_nbufs = 0;
! 633: }
! 634:
! 635: /*
! 636: * Is it possible to seek on a file descriptor?
! 637: */
! 638: public int
! 639: seekable(f)
! 640: int f;
! 641: {
! 642: return (lseek(f, (off_t)1, 0) != BAD_LSEEK);
! 643: }
! 644:
! 645: /*
! 646: * Initialize file state for a new file.
! 647: */
! 648: public void
! 649: ch_init(f, flags)
! 650: int f;
! 651: int flags;
! 652: {
! 653: /*
! 654: * See if we already have a filestate for this file.
! 655: */
! 656: thisfile = (struct filestate *) get_filestate(curr_ifile);
! 657: if (thisfile == NULL)
! 658: {
! 659: /*
! 660: * Allocate and initialize a new filestate.
! 661: */
! 662: thisfile = (struct filestate *)
! 663: calloc(1, sizeof(struct filestate));
! 664: thisfile->buf_next = thisfile->buf_prev = END_OF_CHAIN;
! 665: thisfile->buf_block = (long)(-1);
! 666: thisfile->nbufs = 0;
! 667: thisfile->flags = 0;
! 668: thisfile->fpos = 0;
! 669: thisfile->block = 0;
! 670: thisfile->offset = 0;
! 671: thisfile->file = -1;
! 672: thisfile->fsize = NULL_POSITION;
! 673: ch_flags = flags;
! 674: /*
! 675: * Try to seek; set CH_CANSEEK if it works.
! 676: */
! 677: if (seekable(f))
! 678: ch_flags |= CH_CANSEEK;
! 679: set_filestate(curr_ifile, (void *) thisfile);
! 680: }
! 681: if (thisfile->file == -1)
! 682: thisfile->file = f;
! 683: ch_flush();
! 684: }
! 685:
! 686: /*
! 687: * Close a filestate.
! 688: */
! 689: public void
! 690: ch_close()
! 691: {
! 692: int keepstate = FALSE;
! 693:
! 694: if (ch_flags & (CH_CANSEEK|CH_POPENED))
! 695: {
! 696: /*
! 697: * We can seek or re-open, so we don't need to keep buffers.
! 698: */
! 699: ch_delbufs();
! 700: } else
! 701: keepstate = TRUE;
! 702: if (!(ch_flags & CH_KEEPOPEN))
! 703: {
! 704: /*
! 705: * We don't need to keep the file descriptor open
! 706: * (because we can re-open it.)
! 707: * But don't really close it if it was opened via popen(),
! 708: * because pclose() wants to close it.
! 709: */
! 710: if (!(ch_flags & CH_POPENED))
! 711: close(ch_file);
! 712: ch_file = -1;
! 713: } else
! 714: keepstate = TRUE;
! 715: if (!keepstate)
! 716: {
! 717: /*
! 718: * We don't even need to keep the filestate structure.
! 719: */
! 720: free(thisfile);
! 721: thisfile = NULL;
! 722: set_filestate(curr_ifile, (void *) NULL);
! 723: }
! 724: }
! 725:
! 726: /*
! 727: * Return ch_flags for the current file.
! 728: */
! 729: public int
! 730: ch_getflags()
! 731: {
! 732: return (ch_flags);
! 733: }
! 734:
! 735: #if 0
! 736: public void
! 737: ch_dump(struct filestate *fs)
! 738: {
! 739: struct buf *bp;
! 740: unsigned char *s;
! 741:
! 742: if (fs == NULL)
! 743: {
! 744: printf(" --no filestate\n");
! 745: return;
! 746: }
! 747: printf(" file %d, flags %x, fpos %x, fsize %x, blk/off %x/%x\n",
! 748: fs->file, fs->flags, fs->fpos,
! 749: fs->fsize, fs->block, fs->offset);
! 750: printf(" %d bufs:\n", fs->nbufs);
! 751: for (bp = fs->buf_next; bp != (struct buf *)fs; bp = bp->next)
! 752: {
! 753: printf("%x: blk %x, size %x \"",
! 754: bp, bp->block, bp->datasize);
! 755: for (s = bp->data; s < bp->data + 30; s++)
! 756: if (*s >= ' ' && *s < 0x7F)
! 757: printf("%c", *s);
! 758: else
! 759: printf(".");
! 760: printf("\"\n");
! 761: }
! 762: }
! 763: #endif