diplodocus.org Git - nmh/blob - docs/historical/mh-6.8.5/miscellany/less-177/ch.c

   1 /*
   2  * Low level character input from the input file.
   3  * We use these special purpose routines which optimize moving
   4  * both forward and backward from the current read pointer.
   5  */
   6
   7 #include "less.h"
   8
   9 public int file = -1;           /* File descriptor of the input file */
  10 public int ignore_eoi;
  11
  12 /*
  13  * Pool of buffers holding the most recently used blocks of the input file.
  14  */
  15 #define BUFSIZ  1024
  16 struct buf {
  17         struct buf *next, *prev;  /* Must be first to match struct filestate */
  18         long block;
  19         unsigned int datasize;
  20         unsigned char data[BUFSIZ];
  21 };
  22
  23 /*
  24  * The buffer pool is kept as a doubly-linked circular list,
  25  * in order from most- to least-recently used.
  26  * The circular list is anchored by the file state "thisfile".
  27  *
  28  * The file state is maintained in a filestate structure.
  29  * There are two such structures, one used when input is a pipe
  30  * and the other when input is an ordinary file.
  31  * This is so that we can leave a pipe, look and other files,
  32  * and return to the pipe without losing buffered data.
  33  * Buffered data can be reconstructed for a non-pipe file by
  34  * simply re-reading the file, but a pipe cannot be re-read.
  35  */
  36
  37 struct filestate {
  38         struct buf *next, *prev;   /* Must be first to match struct buf */
  39         POSITION fpos;
  40         int nbufs;
  41         long block;
  42         int offset;
  43         POSITION fsize;
  44 };
  45
  46 #define END_OF_CHAIN    ((struct buf *)thisfile)
  47 #define buf_head        thisfile->next
  48 #define buf_tail        thisfile->prev
  49 #define ch_nbufs        thisfile->nbufs
  50 #define ch_block        thisfile->block
  51 #define ch_offset       thisfile->offset
  52 #define ch_fpos         thisfile->fpos
  53 #define ch_fsize        thisfile->fsize
  54
  55 static struct filestate pipefile =
  56         { (struct buf *)&pipefile, (struct buf *)&pipefile };
  57
  58 static struct filestate nonpipefile =
  59         { (struct buf *)&nonpipefile, (struct buf *)&nonpipefile };
  60
  61 static struct filestate *thisfile;
  62
  63 extern int ispipe;
  64 extern int autobuf;
  65 extern int sigs;
  66 #if LOGFILE
  67 extern int logfile;
  68 extern char *namelogfile;
  69 #endif
  70
  71 static int ch_addbuf();
  72
  73
  74 /*
  75  * Get the character pointed to by the read pointer.
  76  * ch_get() is a macro which is more efficient to call
  77  * than fch_get (the function), in the usual case
  78  * that the block desired is at the head of the chain.
  79  */
  80 #define ch_get()   ((ch_block == buf_head->block && \
  81                      ch_offset < buf_head->datasize) ? \
  82                         buf_head->data[ch_offset] : fch_get())
  83         static int
  84 fch_get()
  85 {
  86         register struct buf *bp;
  87         register int n;
  88         register int slept;
  89         POSITION pos;
  90         POSITION len;
  91
  92         slept = 0;
  93
  94         /*
  95          * Look for a buffer holding the desired block.
  96          */
  97         for (bp = buf_head;  bp != END_OF_CHAIN;  bp = bp->next)
  98                 if (bp->block == ch_block)
  99                 {
 100                         if (ch_offset >= bp->datasize)
 101                                 /*
 102                                  * Need more data in this buffer.
 103                                  */
 104                                 goto read_more;
 105                         goto found;
 106                 }
 107         /*
 108          * Block is not in a buffer.
 109          * Take the least recently used buffer
 110          * and read the desired block into it.
 111          * If the LRU buffer has data in it,
 112          * and autobuf is true, and input is a pipe,
 113          * then try to allocate a new buffer first.
 114          */
 115         if (autobuf && ispipe && buf_tail->block != (long)(-1))
 116                 if (ch_addbuf(1))
 117                         /*
 118                          * Allocation failed: turn off autobuf.
 119                          */
 120                         autobuf = 0;
 121         bp = buf_tail;
 122         bp->block = ch_block;
 123         bp->datasize = 0;
 124
 125     read_more:
 126         pos = (ch_block * BUFSIZ) + bp->datasize;
 127         if ((len = ch_length()) != NULL_POSITION && pos >= len)
 128                 /*
 129                  * At end of file.
 130                  */
 131                 return (EOI);
 132
 133         if (pos != ch_fpos)
 134         {
 135                 /*
 136                  * Not at the correct position: must seek.
 137                  * If input is a pipe, we're in trouble (can't seek on a pipe).
 138                  * Some data has been lost: just return "?".
 139                  */
 140                 if (ispipe)
 141                         return ('?');
 142                 if (lseek(file, (offset_t)pos, 0) == BAD_LSEEK)
 143                 {
 144                         error("seek error", NULL_PARG);
 145                         quit(1);
 146                 }
 147                 ch_fpos = pos;
 148         }
 149
 150         /*
 151          * Read the block.
 152          * If we read less than a full block, that's ok.
 153          * We use partial block and pick up the rest next time.
 154          */
 155         n = iread(file, &bp->data[bp->datasize],
 156                 (unsigned int)(BUFSIZ - bp->datasize));
 157         if (n == READ_INTR)
 158                 return (EOI);
 159         if (n < 0)
 160         {
 161                 error("read error", NULL_PARG);
 162                 quit(1);
 163         }
 164         ch_fpos += n;
 165
 166 #if LOGFILE
 167         /*
 168          * If we have a log file, write the new data to it.
 169          */
 170         if (logfile >= 0 && n > 0)
 171                 write(logfile, (char *) &bp->data[bp->datasize], n);
 172 #endif
 173
 174         bp->datasize += n;
 175
 176         /*
 177          * If we have read to end of file, set ch_fsize to indicate
 178          * the position of the end of file.
 179          */
 180         if (n == 0)
 181         {
 182                 ch_fsize = pos;
 183                 if (ignore_eoi)
 184                 {
 185                         /*
 186                          * We are ignoring EOF.
 187                          * Wait a while, then try again.
 188                          */
 189                         if (!slept)
 190                                 ierror("Waiting for data", NULL_PARG);
 191                         sleep(1);
 192                         slept = 1;
 193                 }
 194                 if (sigs)
 195                         return (EOI);
 196         }
 197
 198     found:
 199         if (buf_head != bp)
 200         {
 201                 /*
 202                  * Move the buffer to the head of the buffer chain.
 203                  * This orders the buffer chain, most- to least-recently used.
 204                  */
 205                 bp->next->prev = bp->prev;
 206                 bp->prev->next = bp->next;
 207
 208                 bp->next = buf_head;
 209                 bp->prev = END_OF_CHAIN;
 210                 buf_head->prev = bp;
 211                 buf_head = bp;
 212         }
 213
 214         if (ch_offset >= bp->datasize)
 215                 /*
 216                  * After all that, we still don't have enough data.
 217                  * Go back and try again.
 218                  */
 219                 goto read_more;
 220
 221         return (bp->data[ch_offset]);
 222 }
 223
 224 #if LOGFILE
 225 /*
 226  * Close the logfile.
 227  * If we haven't read all of standard input into it, do that now.
 228  */
 229         public void
 230 end_logfile()
 231 {
 232         static int tried = 0;
 233
 234         if (logfile < 0)
 235                 return;
 236         if (!tried && ch_fsize == NULL_POSITION)
 237         {
 238                 tried = 1;
 239                 ierror("Finishing logfile", NULL_PARG);
 240                 while (ch_forw_get() != EOI)
 241                         if (sigs)
 242                                 break;
 243         }
 244         close(logfile);
 245         logfile = -1;
 246         namelogfile = NULL;
 247 }
 248
 249 /*
 250  * Start a log file AFTER less has already been running.
 251  * Invoked from the - command; see toggle_option().
 252  * Write all the existing buffered data to the log file.
 253  */
 254         public void
 255 sync_logfile()
 256 {
 257         register struct buf *bp;
 258         long block;
 259         long last_block;
 260
 261         last_block = (ch_fpos + BUFSIZ - 1) / BUFSIZ;
 262         for (block = 0;  block <= last_block;  block++)
 263                 for (bp = buf_head;  bp != END_OF_CHAIN;  bp = bp->next)
 264                         if (bp->block == block)
 265                         {
 266                                 write(logfile, (char *) bp->data, bp->datasize);
 267                                 break;
 268                         }
 269 }
 270
 271 #endif
 272
 273 /*
 274  * Determine if a specific block is currently in one of the buffers.
 275  */
 276         static int
 277 buffered(block)
 278         long block;
 279 {
 280         register struct buf *bp;
 281
 282         for (bp = buf_head;  bp != END_OF_CHAIN;  bp = bp->next)
 283                 if (bp->block == block)
 284                         return (1);
 285         return (0);
 286 }
 287
 288 /*
 289  * Seek to a specified position in the file.
 290  * Return 0 if successful, non-zero if can't seek there.
 291  */
 292         public int
 293 ch_seek(pos)
 294         register POSITION pos;
 295 {
 296         long new_block;
 297         POSITION len;
 298
 299         len = ch_length();
 300         if (pos < ch_zero() || (len != NULL_POSITION && pos > len))
 301                 return (1);
 302
 303         new_block = pos / BUFSIZ;
 304         if (ispipe && pos != ch_fpos && !buffered(new_block))
 305                 return (1);
 306         /*
 307          * Set read pointer.
 308          */
 309         ch_block = new_block;
 310         ch_offset = pos % BUFSIZ;
 311         return (0);
 312 }
 313
 314 /*
 315  * Seek to the end of the file.
 316  */
 317         public int
 318 ch_end_seek()
 319 {
 320         POSITION len;
 321
 322         if (!ispipe)
 323                 ch_fsize = filesize(file);
 324
 325         len = ch_length();
 326         if (len != NULL_POSITION)
 327                 return (ch_seek(len));
 328
 329         /*
 330          * Do it the slow way: read till end of data.
 331          */
 332         while (ch_forw_get() != EOI)
 333                 if (sigs)
 334                         return (1);
 335         return (0);
 336 }
 337
 338 /*
 339  * Seek to the beginning of the file, or as close to it as we can get.
 340  * We may not be able to seek there if input is a pipe and the
 341  * beginning of the pipe is no longer buffered.
 342  */
 343         public int
 344 ch_beg_seek()
 345 {
 346         register struct buf *bp, *firstbp;
 347
 348         /*
 349          * Try a plain ch_seek first.
 350          */
 351         if (ch_seek(ch_zero()) == 0)
 352                 return (0);
 353
 354         /*
 355          * Can't get to position 0.
 356          * Look thru the buffers for the one closest to position 0.
 357          */
 358         firstbp = bp = buf_head;
 359         if (bp == END_OF_CHAIN)
 360                 return (1);
 361         while ((bp = bp->next) != END_OF_CHAIN)
 362                 if (bp->block < firstbp->block)
 363                         firstbp = bp;
 364         ch_block = firstbp->block;
 365         ch_offset = 0;
 366         return (0);
 367 }
 368
 369 /*
 370  * Return the length of the file, if known.
 371  */
 372         public POSITION
 373 ch_length()
 374 {
 375         if (ignore_eoi)
 376                 return (NULL_POSITION);
 377         return (ch_fsize);
 378 }
 379
 380 /*
 381  * Return the current position in the file.
 382  */
 383 #define tellpos(blk,off)   ((POSITION)((((long)(blk)) * BUFSIZ) + (off)))
 384
 385         public POSITION
 386 ch_tell()
 387 {
 388         return (tellpos(ch_block, ch_offset));
 389 }
 390
 391 /*
 392  * Get the current char and post-increment the read pointer.
 393  */
 394         public int
 395 ch_forw_get()
 396 {
 397         register int c;
 398
 399         c = ch_get();
 400         if (c == EOI)
 401                 return (EOI);
 402         if (ch_offset < BUFSIZ-1)
 403                 ch_offset++;
 404         else
 405         {
 406 #if __ZOFFSET /* NOT WORKING */
 407                 if (ch_fsize != NULL_POSITION &&
 408                     tellpos(ch_block+1, 0) >= ch_fsize)
 409                         return (EOI);
 410 #endif
 411                 ch_block ++;
 412                 ch_offset = 0;
 413         }
 414         return (c);
 415 }
 416
 417 /*
 418  * Pre-decrement the read pointer and get the new current char.
 419  */
 420         public int
 421 ch_back_get()
 422 {
 423         if (ch_offset > 0)
 424                 ch_offset --;
 425         else
 426         {
 427 #if __ZOFFSET /* NOT WORKING */
 428                 if (tellpos(ch_block-1, BUFSIZ-1) < ch_zero())
 429                         return (EOI);
 430 #else
 431                 if (ch_block <= 0)
 432                         return (EOI);
 433 #endif
 434                 if (ispipe && !buffered(ch_block-1))
 435                         return (EOI);
 436                 ch_block--;
 437                 ch_offset = BUFSIZ-1;
 438         }
 439         return (ch_get());
 440 }
 441
 442 /*
 443  * Allocate buffers.
 444  * Caller wants us to have a total of at least want_nbufs buffers.
 445  */
 446         public int
 447 ch_nbuf(want_nbufs)
 448         int want_nbufs;
 449 {
 450         PARG parg;
 451
 452         if (ch_nbufs < want_nbufs && ch_addbuf(want_nbufs - ch_nbufs))
 453         {
 454                 /*
 455                  * Cannot allocate enough buffers.
 456                  * If we don't have ANY, then quit.
 457                  * Otherwise, just report the error and return.
 458                  */
 459                 parg.p_int = want_nbufs - ch_nbufs;
 460                 error("Cannot allocate %d buffers", &parg);
 461                 if (ch_nbufs == 0)
 462                         quit(1);
 463         }
 464         return (ch_nbufs);
 465 }
 466
 467 /*
 468  * Flush any saved file state, including buffer contents.
 469  */
 470         public void
 471 ch_flush()
 472 {
 473         register struct buf *bp;
 474
 475         if (ispipe)
 476         {
 477                 /*
 478                  * If input is a pipe, we don't flush buffer contents,
 479                  * since the contents can't be recovered.
 480                  */
 481                 ch_fsize = NULL_POSITION;
 482                 return;
 483         }
 484
 485         /*
 486          * Initialize all the buffers.
 487          */
 488         for (bp = buf_head;  bp != END_OF_CHAIN;  bp = bp->next)
 489                 bp->block = (long)(-1);
 490
 491         /*
 492          * Figure out the size of the file, if we can.
 493          */
 494         ch_fsize = filesize(file);
 495
 496         /*
 497          * Seek to a known position: the beginning of the file.
 498          */
 499         ch_fpos = 0;
 500         ch_block = ch_fpos / BUFSIZ;
 501         ch_offset = ch_fpos % BUFSIZ;
 502
 503         if (lseek(file, (offset_t)0, 0) == BAD_LSEEK)
 504         {
 505                 /*
 506                  * Warning only; even if the seek fails for some reason,
 507                  * there's a good chance we're at the beginning anyway.
 508                  * {{ I think this is bogus reasoning. }}
 509                  */
 510                 error("seek error to 0", NULL_PARG);
 511         }
 512 }
 513
 514 /*
 515  * Allocate some new buffers.
 516  * The buffers are added to the tail of the buffer chain.
 517  */
 518         static int
 519 ch_addbuf(nnew)
 520         int nnew;
 521 {
 522         register struct buf *bp;
 523         register struct buf *newbufs;
 524
 525         /*
 526          * We don't have enough buffers.
 527          * Allocate some new ones.
 528          */
 529         newbufs = (struct buf *) calloc(nnew, sizeof(struct buf));
 530         if (newbufs == NULL)
 531                 return (1);
 532
 533         /*
 534          * Initialize the new buffers and link them together.
 535          * Link them all onto the tail of the buffer list.
 536          */
 537         ch_nbufs += nnew;
 538         for (bp = &newbufs[0];  bp < &newbufs[nnew];  bp++)
 539         {
 540                 bp->next = bp + 1;
 541                 bp->prev = bp - 1;
 542                 bp->block = (long)(-1);
 543         }
 544         newbufs[nnew-1].next = END_OF_CHAIN;
 545         newbufs[0].prev = buf_tail;
 546         buf_tail->next = &newbufs[0];
 547         buf_tail = &newbufs[nnew-1];
 548         return (0);
 549 }
 550
 551 /*
 552  * Use the pipe file state.
 553  */
 554         public void
 555 ch_pipe()
 556 {
 557         thisfile = &pipefile;
 558 }
 559
 560 /*
 561  * Use the non-pipe file state.
 562  */
 563         public void
 564 ch_nonpipe()
 565 {
 566         thisfile = &nonpipefile;
 567 }