Mon Apr 29 02:48:26 1996 Ulrich Drepper <drepper@cygnus.com>
[kopensolaris-gnu/glibc.git] / stdio / internals.c
1 /* Copyright (C) 1991, 92, 93, 94, 95, 96 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Library General Public License as
6 published by the Free Software Foundation; either version 2 of the
7 License, or (at your option) any later version.
8
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12 Library General Public License for more details.
13
14 You should have received a copy of the GNU Library General Public
15 License along with the GNU C Library; see the file COPYING.LIB.  If
16 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
17 Cambridge, MA 02139, USA.  */
18
19 #include <ansidecl.h>
20 #include <errno.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24
25
26 /* Make sure that FP has its functions set.  */
27 void
28 DEFUN(__stdio_check_funcs, (fp), register FILE *fp)
29 {
30   if (!fp->__seen)
31     {
32       /* Initialize the stream's info, including buffering info.
33          This may give a buffer, change I/O functions, etc.
34          If no buffer is set (and the stream is not made explicitly
35          unbuffered), we allocate a buffer below, using the bufsize
36          set by this function.  */
37       extern void EXFUN(__stdio_init_stream, (FILE *));
38       fp->__room_funcs = __default_room_functions;
39       fp->__io_funcs = __default_io_functions;
40       __stdio_init_stream (fp);
41       fp->__seen = 1;
42     }
43 }
44
45
46 /* Minimum size of a buffer we will allocate by default.
47    If this much memory is not available,
48    the stream in question will be made unbuffered instead.  */
49 #define MIN_BUFSIZE     128
50
51 /* Figure out what kind of buffering (none, line, or full)
52    and what buffer size to give FP.  */
53 static void
54 DEFUN(init_stream, (fp), register FILE *fp)
55 {
56   __stdio_check_funcs (fp);
57
58   if (fp->__buffer == NULL && !fp->__userbuf)
59     {
60       int save;
61
62       if (fp->__bufsize == 0)
63         fp->__bufsize = BUFSIZ;
64
65       /* Try to get however many bytes of buffering __stdio_pickbuf
66          specified, but if that much memory isn't available,
67          try half as much each time until it succeeds or the buffer
68          size becomes too small to be useful.  */
69       save = errno;
70       while (fp->__bufsize >= MIN_BUFSIZE)
71         {
72           fp->__buffer = (char *) malloc(fp->__bufsize);
73           if (fp->__buffer == NULL)
74             fp->__bufsize /= 2;
75           else
76             break;
77         }
78       errno = save;
79
80       if (fp->__buffer == NULL)
81         {
82           /* We can't get space for the buffer, so make it unbuffered.  */
83           fp->__userbuf = 1;
84           fp->__bufsize = 0;
85         }
86     }
87
88   if (fp->__bufp == NULL)
89     {
90       /* Set the buffer pointer to the beginning of the buffer.  */
91       fp->__bufp = fp->__buffer;
92       fp->__put_limit = fp->__get_limit = fp->__buffer;
93     }
94 }
95
96
97 /* Determine the current file position of STREAM if it is unknown.  */
98 int
99 DEFUN(__stdio_check_offset, (stream), FILE *stream)
100 {
101   init_stream (stream);
102
103   if (stream->__offset == (fpos_t) -1)
104     {
105       /* This stream's offset is unknown or unknowable.  */
106       if (stream->__io_funcs.__seek == NULL)
107         {
108           /* Unknowable.  */
109           errno = ESPIPE;
110           return EOF;
111         }
112       else
113         {
114           /* Unknown.  Find it out.  */
115           fpos_t pos = (fpos_t) 0;
116           if ((*stream->__io_funcs.__seek)(stream->__cookie,
117                                            &pos, SEEK_CUR) < 0)
118             {
119               if (errno == ESPIPE)
120                 /* Object is incapable of seeking.  */
121                 stream->__io_funcs.__seek = NULL;
122               return EOF;
123             }
124           stream->__offset = pos;
125         }
126     }
127
128   if (stream->__target == (fpos_t) -1)
129     /* This stream was opened on an existing object with
130        an unknown file position.  The position is now known.
131        Make this the target position.  */
132     stream->__target = stream->__offset;
133
134   return 0;
135 }
136
137
138 /* Move FP's file position to its target file position,
139    seeking as necessary and updating its `offset' field.
140    Sets ferror(FP) (and possibly errno) for errors.  */
141 static void
142 DEFUN(seek_to_target, (fp), FILE *fp)
143 {
144   int save = errno;
145   if (__stdio_check_offset (fp) == EOF)
146     {
147       if (errno == ESPIPE)
148         errno = save;
149       else
150         fp->__error = 1;
151     }
152   else if (fp->__target != fp->__offset)
153     {
154       /* We are not at the target file position.
155          Seek to that position.  */
156       if (fp->__io_funcs.__seek == NULL)
157         {
158           /* We can't seek!  */
159           errno = ESPIPE;
160           fp->__error = 1;
161         }
162       else
163         {
164           fpos_t pos = fp->__target;
165           if ((*fp->__io_funcs.__seek)(fp->__cookie, &pos, SEEK_SET) < 0)
166             /* Seek failed!  */
167             fp->__error = 1;
168           else
169             {
170               fp->__offset = pos;
171               if (pos != fp->__target)
172                 {
173                   /* Seek didn't go to the right place!
174                      This should never happen.  */
175 #ifdef EGRATUITOUS
176                   /* It happens in the Hurd when the io server doesn't
177                      obey the protocol for io_seek.  */
178                   errno = EGRATUITOUS;
179 #else
180                   /* I don't think this can happen in Unix.  */
181                   errno = ESPIPE; /* ??? */
182 #endif
183                   fp->__error = 1;
184                 }
185             }
186         }
187     }
188 }
189
190 /* Flush the buffer for FP.
191    If C is not EOF, it is also to be written.
192    If the stream is line buffered and C is a newline, it is written
193    to the output, otherwise it is put in the buffer after it has been
194    flushed to avoid a system call for a single character.
195    This is the default `output room' function.  */
196 static void
197 DEFUN(flushbuf, (fp, c),
198       register FILE *fp AND int c)
199 {
200   int flush_only = c == EOF;
201   size_t buffer_written;
202   size_t to_write;
203
204   /* Set if target and get_limit have already been twiddled appropriately.  */
205   int twiddled = 0;
206
207   if (fp->__put_limit == fp->__buffer)
208     {
209       /* The stream needs to be primed for writing.  */
210
211       size_t buffer_offset = 0;
212
213       if (fp->__target == -1)
214         /* For an unseekable object, data recently read bears no relation
215            to data we will write later.  Discard the buffer.  */
216         fp->__get_limit = fp->__buffer;
217       else
218         /* If the user has read some of the buffer, the target position
219            is incremented for each character he has read.  */
220         fp->__target += fp->__bufp - fp->__buffer;
221
222       if (fp->__mode.__read && fp->__room_funcs.__input != NULL &&
223           !fp->__mode.__append)
224         {
225           int save = errno;
226           CONST int aligned = (fp->__buffer == NULL ||
227                                __stdio_check_offset(fp) == EOF ||
228                                fp->__target % fp->__bufsize == 0);
229           errno = save;
230
231           if (!aligned)
232             {
233               /* Move to a block (buffer size) boundary and read in a block.
234                  Then the output will be written as a whole block, too.  */
235               CONST size_t o = fp->__target % fp->__bufsize;
236               fp->__target -= o;
237               if ((*fp->__room_funcs.__input)(fp) == EOF && ferror(fp))
238                 return;
239               else
240                 __clearerr(fp);
241
242               if (fp->__get_limit - fp->__buffer < o)
243                 /* Oops.  We didn't read enough (probably because we got EOF).
244                    Forget we even mentioned it.  */
245                 fp->__target += o;
246               else
247                 /* Start bufp as far into the buffer as we were into
248                    this block before we read it.  */
249                 buffer_offset = o;
250
251               /* The target position is now set to where the beginning of the
252                  buffer maps to; and the get_limit was set by the input-room
253                  function.  */
254               twiddled = 1;
255             }
256         }
257
258       if (fp->__buffer != NULL)
259         {
260           /* Set up to write output into the buffer.  */
261           fp->__put_limit = fp->__buffer + fp->__bufsize;
262           fp->__bufp = fp->__buffer + buffer_offset;
263
264           if (!flush_only)
265             {
266               /* Put C in the buffer to be written out.
267                  We only need to actually write it out now if
268                  it is a newline on a line-buffered stream.  */
269               *fp->__bufp++ = (unsigned char) c;
270               if (!fp->__linebuf || (unsigned char) c != '\n')
271                 {
272                   /* There is no need to flush C from the buffer right now.
273                      Record that nothing was written from the buffer,
274                      and go do clean-up at end.  */
275                   buffer_written = 0;
276                   goto end;
277                 }
278               else
279                 /* We put C in the buffer, so don't write it again later.  */
280                 flush_only = 1;
281             }
282         }
283
284       if (fp->__bufp - fp->__buffer <= buffer_offset && flush_only)
285         {
286           /* There is nothing new in the buffer, only data that
287              was read back aligned from the file.  */
288           buffer_written = 0;
289           goto end;
290         }
291     }
292
293   /* If there is read data in the buffer past what was written,
294      write all of that as well.  Otherwise, just write what has been
295      written into the buffer.  */
296   buffer_written = fp->__bufp - fp->__buffer;
297   to_write = (buffer_written == 0 ? 0 :
298               fp->__get_limit > fp->__bufp ?
299               fp->__get_limit - fp->__buffer :
300               buffer_written);
301
302   if (fp->__io_funcs.__write == NULL || (to_write == 0 && flush_only))
303     {
304       /* There is no writing function or we're coming from an fflush
305          call with nothing in the buffer, so just say the buffer's
306          been flushed, increment the file offset, and return.  */
307       fp->__bufp = fp->__buffer;
308       if (fp->__offset != -1)
309         fp->__offset += to_write;
310       goto end;
311     }
312
313   if (to_write > 0)
314     {
315       int wrote;
316
317       /* Go to the target file position.  Don't bother if appending;
318          the write will just ignore the file position anyway.  */
319       if (!fp->__mode.__append)
320         seek_to_target (fp);
321
322       if (!ferror(fp))
323         {
324           /* Write out the buffered data.  */
325           wrote = (*fp->__io_funcs.__write)(fp->__cookie, fp->__buffer,
326                                             to_write);
327           if (wrote > 0)
328             {
329               if (fp->__mode.__append)
330                 /* The write has written the data to the end of the file
331                    and updated the file position to after the data.  Don't
332                    bother to find the current position; we can get it
333                    later if we need it.  */
334                 fp->__offset = fp->__target = -1;
335               else if (fp->__offset != -1)
336                 /* Record that we've moved forward in the file.  */
337                 fp->__offset += wrote;
338             }
339           if (wrote < (int) to_write)
340             /* The writing function should always write
341                the whole buffer unless there is an error.  */
342             fp->__error = 1;
343         }
344     }
345
346   /* Reset the buffer pointer to the beginning of the buffer.  */
347   fp->__bufp = fp->__buffer;
348
349   /* If we're not just flushing, write the last character, C.  */
350   if (!flush_only && !ferror(fp))
351     {
352       if (fp->__buffer == NULL || (fp->__linebuf && (unsigned char) c == '\n'))
353         {
354           /* Either we're unbuffered, or we're line-buffered and
355              C is a newline, so really write it out immediately.  */
356           char cc = (unsigned char) c;
357           if ((*fp->__io_funcs.__write)(fp->__cookie, &cc, 1) < 1)
358             fp->__error = 1;
359           else if (fp->__offset != -1)
360             {
361               /* Record that we've moved forward in the file.  */
362               ++fp->__offset;
363               ++fp->__target;
364             }
365         }
366       else
367         /* Just put C in the buffer.  */
368         *fp->__bufp++ = (unsigned char) c;
369     }
370
371  end:
372
373   if (!twiddled)
374     {
375       if (fp->__target != -1)
376         /* The new target position moves up as
377            much as the user wrote into the buffer.  */
378         fp->__target += buffer_written;
379
380       /* Set the reading limit to the beginning of the buffer,
381          so the next `getc' will call __fillbf.  */
382       fp->__get_limit = fp->__buffer;
383     }
384
385   if (feof(fp) || ferror(fp))
386     fp->__bufp = fp->__put_limit;
387 }
388
389
390 /* Fill the buffer for FP and return the first character read (or EOF).
391    This is the default `input_room' function.  */
392 static int
393 DEFUN(fillbuf, (fp), register FILE *fp)
394 {
395   /* How far into the buffer we read we want to start bufp.  */
396   size_t buffer_offset = 0;
397   register char *buffer;
398   register size_t to_read, nread = 0;
399   /* This must be unsigned to avoid sign extension in return.  */
400   unsigned char c;
401
402   if (fp->__io_funcs.__read == NULL)
403     {
404       /* There is no read function, so always return EOF.  */
405       fp->__eof = 1;
406       goto end;
407     }
408
409   if (fp->__buffer == NULL)
410     {
411       /* We're unbuffered, so we want to read only one character.  */
412       buffer = (char *) &c;
413       to_read = 1;
414     }
415   else
416     {
417       /* We're buffered, so try to fill the buffer.  */
418       buffer = fp->__buffer;
419       to_read = fp->__bufsize;
420     }
421
422   /* We're reading, so we're not at the end-of-file.  */
423   fp->__eof = 0;
424
425   /* Go to the target file position.  */
426   {
427     int save = errno;
428     if (__stdio_check_offset (fp) == 0 && fp->__target != fp->__offset)
429       {
430         /* Move to a block (buffer size) boundary.  */
431         if (fp->__bufsize != 0)
432           {
433             buffer_offset = fp->__target % fp->__bufsize;
434             fp->__target -= buffer_offset;
435           }
436         seek_to_target (fp);
437       }
438     errno = save;
439   }
440
441   while (!ferror(fp) && !feof(fp) && nread <= buffer_offset)
442     {
443       /* Try to fill the buffer.  */
444       int count = (*fp->__io_funcs.__read)(fp->__cookie, buffer, to_read);
445       if (count == 0)
446         fp->__eof = 1;
447       else if (count < 0)
448         fp->__error = 1;
449       else
450         {
451           buffer += count;
452           nread += count;
453           to_read -= count;
454           if (fp->__offset != -1)
455             /* Record that we've moved forward in the file.  */
456             fp->__offset += count;
457         }
458     }
459
460   if (fp->__buffer == NULL)
461     /* There is no buffer, so return the character we read
462        without all the buffer pointer diddling.  */
463     return (feof(fp) || ferror(fp)) ? EOF : c;
464
465   /* Reset the buffer pointer to the beginning of the buffer
466      (plus whatever offset we may have set above).  */
467   fp->__bufp = fp->__buffer + buffer_offset;
468
469  end:;
470
471   if (feof(fp) || ferror(fp))
472     {
473       /* Set both end pointers to the beginning of the buffer so
474          the next i/o call will force a call to __fillbf/__flshfp.  */
475       fp->__put_limit = fp->__get_limit = fp->__buffer;
476       return EOF;
477     }
478
479   /* Set the end pointer to one past the last character we read.  */
480   fp->__get_limit = fp->__buffer + nread;
481
482   /* Make it so the next `putc' will call __flshfp.  */
483   fp->__put_limit = fp->__buffer;
484
485   /* Return the first character in the buffer.  */
486   return *((unsigned char *) (fp->__bufp++));
487 }
488
489
490 /* Default I/O and room functions.  */
491
492 extern __io_read_fn __stdio_read;
493 extern __io_write_fn __stdio_write;
494 extern __io_seek_fn __stdio_seek;
495 extern __io_close_fn __stdio_close;
496 extern __io_fileno_fn __stdio_fileno;
497 CONST __io_functions __default_io_functions =
498   {
499     __stdio_read, __stdio_write, __stdio_seek, __stdio_close, __stdio_fileno
500   };
501
502 CONST __room_functions __default_room_functions =
503   {
504     fillbuf, flushbuf
505   };
506
507
508 /* Flush the buffer for FP and also write C if FLUSH_ONLY is nonzero.
509    This is the function used by putc and fflush.  */
510 int
511 DEFUN(__flshfp, (fp, c),
512       register FILE *fp AND int c)
513 {
514   int flush_only = c == EOF;
515
516   if (!__validfp(fp) || !fp->__mode.__write)
517     {
518       errno = EINVAL;
519       return EOF;
520     }
521
522   if (ferror(fp))
523     return EOF;
524
525   if (fp->__pushed_back)
526     {
527       /* Discard the char pushed back by ungetc.  */
528       fp->__bufp = fp->__pushback_bufp;
529       fp->__pushed_back = 0;
530     }
531
532   /* Make sure the stream is initialized (has functions and buffering).  */
533   init_stream(fp);
534
535   /* Do this early, so a `putc' on such a stream will never return success.  */
536   if (fp->__room_funcs.__output == NULL)
537     {
538       /* A NULL `output room' function means
539          to always return an output error.  */
540       fp->__error = 1;
541       return EOF;
542     }
543
544   if (!flush_only &&
545       /* Will C fit into the buffer?
546          See below about linebuf_active.  */
547       fp->__bufp < (fp->__linebuf_active ? fp->__buffer + fp->__bufsize :
548                     fp->__put_limit))
549     {
550       /* The character will fit in the buffer, so put it there.  */
551       *fp->__bufp++ = (unsigned char) c;
552       if (fp->__linebuf && (unsigned char) c == '\n')
553         flush_only = 1;
554       else
555         return (unsigned char) c;
556     }
557
558   if (fp->__linebuf_active)
559     /* This is an active line-buffered stream, so its put-limit is set
560        to the beginning of the buffer in order to force a __flshfp call
561        on each putc (see below).  We undo this hack here (by setting
562        the limit to the end of the buffer) to simplify the interface
563        with the output-room function.  */
564     fp->__put_limit = fp->__buffer + fp->__bufsize;
565
566   /* Make room in the buffer.  */
567   (*fp->__room_funcs.__output) (fp, flush_only ? EOF : (unsigned char) c);
568
569   if (fp->__linebuf)
570     {
571       /* This is a line-buffered stream, and it is now ready to do
572          some output.  We call this an "active line-buffered stream".
573          We set the put_limit to the beginning of the buffer,
574          so the next `putc' call will force a call to this function.
575          Setting the linebuf_active flag tells the code above
576          (on the next call) to undo this hackery.  */
577       fp->__put_limit = fp->__buffer;
578       fp->__linebuf_active = 1;
579     }
580
581   if (ferror (fp))
582     return EOF;
583   if (flush_only)
584     return 0;
585   return (unsigned char) c;
586 }
587
588
589 /* Fill the buffer for FP and return the first character read.
590    This is the function used by getc.  */
591 int
592 DEFUN(__fillbf, (fp), register FILE *fp)
593 {
594   register int c;
595   fpos_t new_target;
596
597   if (!__validfp(fp) || !fp->__mode.__read)
598     {
599       errno = EINVAL;
600       return EOF;
601     }
602
603   if (fp->__pushed_back)
604     {
605       /* Return the char pushed back by ungetc.  */
606       fp->__bufp = fp->__pushback_bufp;
607       fp->__pushed_back = 0;
608       return fp->__pushback;
609     }
610
611   /* Make sure the stream is initialized (has functions and buffering). */
612   init_stream(fp);
613
614   /* If we're trying to read the first character of a new
615      line of input from an unbuffered or line buffered stream,
616      we must flush all line-buffered output streams. */
617   if (fp->__buffer == NULL || fp->__linebuf)
618     {
619       register FILE *f;
620       for (f = __stdio_head; f != NULL; f = f->__next)
621         if (__validfp (f) && f->__linebuf && f->__mode.__write)
622           (void) __flshfp (f, EOF);
623     }
624
625   /* Note we must do this after flushing all line-buffered
626      streams, or else __flshfp would undo it!  */
627   if (fp->__linebuf_active)
628     {
629       /* This is an active line-buffered stream, meaning it is in the midst
630          of writing, but has a bogus put_limit.  Restore it to normality.  */
631       fp->__put_limit = fp->__buffer + fp->__bufsize;
632       fp->__linebuf_active = 0;
633     }
634
635   /* We want the beginning of the buffer to now
636      map to just past the last data we read.  */
637   new_target = fp->__target + (fp->__get_limit - fp->__buffer);
638
639   if (fp->__put_limit > fp->__buffer)
640     {
641       /* There is written data in the buffer.
642          Flush it out.  */
643       if (fp->__room_funcs.__output == NULL)
644         fp->__error = 1;
645       else
646         (*fp->__room_funcs.__output) (fp, EOF);
647     }
648
649   fp->__target = new_target;
650
651   if (ferror(fp))
652     c = EOF;
653   else if (fp->__room_funcs.__input != NULL)
654     {
655       c = (*fp->__room_funcs.__input)(fp);
656       if (fp->__buffer == NULL)
657         /* This is an unbuffered stream, so the target sync above
658            won't do anything the next time around.  Instead, note that
659            we have read one character.  The (nonexistent) buffer now
660            maps to the position just past that character.  */
661         ++fp->__target;
662     }
663   else
664     {
665       /* A NULL `input_room' function means always return EOF.  */
666       fp->__eof = 1;
667       c = EOF;
668     }
669
670   return c;
671 }
672
673
674 /* Nuke a stream, but don't kill its link in the chain.  */
675 void
676 DEFUN(__invalidate, (stream), register FILE *stream)
677 {
678   /* Save its link.  */
679   register FILE *next = stream->__next;
680
681   /* Pulverize the fucker.  */
682   memset((PTR) stream, 0, sizeof(FILE));
683
684   /* Restore the deceased's link.  */
685   stream->__next = next;
686 }