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