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