|
0
|
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 }
|
