Formerly ../stdio/internals.c.~38~
[kopensolaris-gnu/glibc.git] / stdio / internals.c
1 /* Copyright (C) 1991, 1992 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   if (__stdio_check_offset (fp) == EOF)
137     fp->__error = 1;
138   else if (fp->__target != fp->__offset)
139     {
140       /* We are not at the target file position.
141          Seek to that position.  */
142       if (fp->__io_funcs.__seek == NULL)
143         {
144           /* We can't seek!  */
145           errno = ESPIPE;
146           fp->__error = 1;
147         }
148       else
149         {
150           fpos_t pos = fp->__target;
151           if ((*fp->__io_funcs.__seek)(fp->__cookie, &pos, SEEK_SET) < 0)
152             /* Seek failed!  */
153             fp->__error = 1;
154           else
155             {
156               fp->__offset = pos;
157               if (pos != fp->__target)
158                 /* Seek didn't go to the right place!  */
159                 fp->__error = 1;
160             }
161         }
162     }
163 }
164
165 /* Flush the buffer for FP.
166    If C is not EOF, it is also to be written.
167    If the stream is line buffered and C is a newline, it is written
168    to the output, otherwise it is put in the buffer after it has been
169    flushed to avoid a system call for a single character.
170    This is the default `output room' function.  */
171 static void
172 DEFUN(flushbuf, (fp, c),
173       register FILE *fp AND int c)
174 {
175   int flush_only = c == EOF;
176   size_t buffer_written;
177   size_t to_write;
178
179   /* Set if target and get_limit have already been twiddled appropriately.  */
180   int twiddled = 0;
181
182   if (fp->__put_limit == fp->__buffer)
183     {
184       /* The stream needs to be primed for writing.  */
185
186       size_t buffer_offset = 0;
187
188       /* If the user has read some of the buffer, the target position
189          is incremented for each character he has read.  */
190       fp->__target += fp->__bufp - fp->__buffer;
191
192       if (fp->__mode.__read && fp->__room_funcs.__input != NULL &&
193           !fp->__mode.__append)
194         {
195           int save = errno;
196           CONST int aligned = (__stdio_check_offset(fp) == EOF ||
197                                fp->__target % fp->__bufsize == 0);
198           errno = save;
199
200           if (!aligned)
201             {
202               /* Move to a block (buffer size) boundary and read in a block.
203                  Then the output will be written as a whole block, too.  */
204               CONST size_t o = fp->__target % fp->__bufsize;
205               fp->__target -= o;
206               if ((*fp->__room_funcs.__input)(fp) == EOF && ferror(fp))
207                 return;
208               else
209                 __clearerr(fp);
210
211               if (fp->__get_limit - fp->__buffer < o)
212                 /* Oops.  We didn't read enough (probably because we got EOF).
213                    Forget we even mentioned it.  */
214                 fp->__target += o;
215               else
216                 /* Start bufp as far into the buffer as we were into
217                    this block before we read it.  */
218                 buffer_offset = o;
219             }
220
221           /* The target position is now set to where the beginning of the
222              buffer maps to; and the get_limit was set by the input-room
223              function.  */
224           twiddled = 1;
225         }
226
227       if (fp->__buffer != NULL)
228         {
229           /* Set up to write output into the buffer.  */
230           fp->__put_limit = fp->__buffer + fp->__bufsize;
231           fp->__bufp = fp->__buffer + buffer_offset;
232           if (!flush_only)
233             {
234               *fp->__bufp++ = (unsigned char) c;
235               if (!fp->__linebuf || (unsigned char) c != '\n')
236                 return;
237               flush_only = 1;
238             }
239         }
240     }
241
242   /* If there is read data in the buffer past what was written,
243      write all of that as well.  Otherwise, just write what has been
244      written into the buffer.  */
245   buffer_written = fp->__bufp - fp->__buffer;
246   to_write = (buffer_written == 0 ? 0 :
247               fp->__get_limit > fp->__bufp ?
248               fp->__get_limit - fp->__buffer :
249               buffer_written);
250
251   if (fp->__io_funcs.__write == NULL || (to_write == 0 && flush_only))
252     {
253       /* There is no writing function or we're coming from an fflush
254          call with nothing in the buffer, so just say the buffer's
255          been flushed, increment the file offset, and return.  */
256       fp->__bufp = fp->__buffer;
257       fp->__offset += to_write;
258       goto end;
259     }
260
261   if (to_write > 0)
262     {
263       int wrote;
264
265       /* Go to the target file position.  Don't bother if appending;
266          the write will just ignore the file position anyway.  */
267       if (!fp->__mode.__append)
268         seek_to_target (fp);
269
270       if (!ferror(fp))
271         {
272           /* Write out the buffered data.  */
273           wrote = (*fp->__io_funcs.__write)(fp->__cookie, fp->__buffer,
274                                             to_write);
275           if (wrote > 0)
276             {
277               if (fp->__mode.__append)
278                 /* The write has written the data to the end of the file
279                    and updated the file position to after the data.  Don't
280                    bother to find the current position; we can get it
281                    later if we need it.  */
282                 fp->__offset = fp->__target = -1;
283               else
284                 /* Record that we've moved forward in the file.  */
285                 fp->__offset += wrote;
286             }
287           if (wrote < (int) to_write)
288             /* The writing function should always write
289                the whole buffer unless there is an error.  */
290             fp->__error = 1;
291         }
292     }
293
294   /* Reset the buffer pointer to the beginning of the buffer.  */
295   fp->__bufp = fp->__buffer;
296
297   /* If we're not just flushing, write the last character, C.  */
298   if (!flush_only && !ferror(fp))
299     {
300       if (fp->__buffer == NULL || (fp->__linebuf && (unsigned char) c == '\n'))
301         {
302           /* Either we're unbuffered, or we're line-buffered and
303              C is a newline, so really write it out immediately.  */
304           char cc = (unsigned char) c;
305           if ((*fp->__io_funcs.__write)(fp->__cookie, &cc, 1) < 1)
306             fp->__error = 1;
307           else
308             {
309               /* Record that we've moved forward in the file.  */
310               ++fp->__offset;
311               ++fp->__target;
312             }
313         }
314       else
315         /* Just put C in the buffer.  */
316         *fp->__bufp++ = (unsigned char) c;
317     }
318
319  end:
320
321   if (!twiddled)
322     {
323       /* The new target position moves up as
324          much as the user wrote into the buffer.  */
325       fp->__target += buffer_written;
326
327       /* Set the reading limit to the beginning of the buffer,
328          so the next `getc' will call __fillbf.  */
329       fp->__get_limit = fp->__buffer;
330     }
331
332   if (feof(fp) || ferror(fp))
333     fp->__bufp = fp->__put_limit;
334 }
335
336
337 /* Fill the buffer for FP and return the first character read (or EOF).
338    This is the default `input_room' function.  */
339 static int
340 DEFUN(fillbuf, (fp), register FILE *fp)
341 {
342   /* How far into the buffer we read we want to start bufp.  */
343   size_t buffer_offset = 0;
344   register char *buffer;
345   register size_t to_read, nread = 0;
346   char c;
347
348   if (fp->__io_funcs.__read == NULL)
349     {
350       /* There is no read function, so always return EOF.  */
351       fp->__eof = 1;
352       goto end;
353     }
354
355   if (fp->__buffer == NULL)
356     {
357       /* We're unbuffered, so we want to read only one character.  */
358       buffer = &c;
359       to_read = 1;
360     }
361   else
362     {
363       /* We're buffered, so try to fill the buffer.  */
364       buffer = fp->__buffer;
365       to_read = fp->__bufsize;
366     }
367
368   /* We're reading, so we're not at the end-of-file.  */
369   fp->__eof = 0;
370
371   /* Go to the target file position.  */
372   {
373     int save = errno;
374     if (__stdio_check_offset (fp) == 0 && fp->__target != fp->__offset)
375       {
376         /* Move to a block (buffer size) boundary.  */
377         if (fp->__bufsize != 0)
378           {
379             buffer_offset = fp->__target % fp->__bufsize;
380             fp->__target -= buffer_offset;
381           }
382         seek_to_target (fp);
383       }
384     errno = save;
385   }
386
387   while (!ferror(fp) && !feof(fp) && nread <= buffer_offset)
388     {
389       /* Try to fill the buffer.  */
390       int count = (*fp->__io_funcs.__read)(fp->__cookie, buffer, to_read);
391       if (count == 0)
392         fp->__eof = 1;
393       else if (count < 0)
394         fp->__error = 1;
395       else
396         {
397           buffer += count;
398           nread += count;
399           to_read -= count;
400           /* Record that we've moved forward in the file.  */
401           fp->__offset += count;
402         }
403     }
404
405   if (fp->__buffer == NULL)
406     /* There is no buffer, so return the character we read
407        without all the buffer pointer diddling.  */
408     return (feof(fp) || ferror(fp)) ? EOF : c;
409
410   /* Reset the buffer pointer to the beginning of the buffer
411      (plus whatever offset we may have set above).  */
412   fp->__bufp = fp->__buffer + buffer_offset;
413
414  end:;
415
416   if (feof(fp) || ferror(fp))
417     {
418       /* Set both end pointers to the beginning of the buffer so
419          the next i/o call will force a call to __fillbf/__flshfp.  */
420       fp->__put_limit = fp->__get_limit = fp->__buffer;
421       return EOF;
422     }
423
424   /* Set the end pointer to one past the last character we read.  */
425   fp->__get_limit = fp->__buffer + nread;
426
427   /* Make it so the next `putc' will call __flshfp.  */
428   fp->__put_limit = fp->__buffer;
429
430   /* Return the first character in the buffer.  */
431   return (unsigned char) *fp->__bufp++;
432 }
433
434
435 /* Default I/O and room functions.  */
436
437 extern __io_read __stdio_read;
438 extern __io_write __stdio_write;
439 extern __io_seek __stdio_seek;
440 extern __io_close __stdio_close;
441 CONST __io_functions __default_io_functions =
442   {
443     __stdio_read, __stdio_write, __stdio_seek, __stdio_close
444   };
445
446 CONST __room_functions __default_room_functions =
447   {
448     fillbuf, flushbuf
449   };
450
451
452 /* Flush the buffer for FP and also write C if FLUSH_ONLY is nonzero.
453    This is the function used by putc and fflush.  */
454 int
455 DEFUN(__flshfp, (fp, c),
456       register FILE *fp AND int c)
457 {
458   int flush_only = c == EOF;
459
460   if (!__validfp(fp) || !fp->__mode.__write)
461     {
462       errno = EINVAL;
463       return EOF;
464     }
465
466   if (ferror(fp))
467     return EOF;
468
469   /* Make sure the stream is initialized (has functions and buffering).  */
470   init_stream(fp);
471
472   if (!flush_only && fp->__get_limit == fp->__buffer &&
473       fp->__bufp > fp->__buffer && fp->__bufp < fp->__buffer + fp->__bufsize)
474     {
475       /* The character will fit in the buffer, so put it there.  */
476       *fp->__bufp++ = (unsigned char) c;
477       if (fp->__linebuf && (unsigned char) c == '\n')
478         flush_only = 1;
479       else
480         return (unsigned char) c;
481     }
482
483   if (fp->__room_funcs.__output == NULL)
484     {
485       /* A NULL `output room' function means
486          to always return an output error.  */
487       fp->__error = 1;
488       return EOF;
489     }
490
491   if (!flush_only || fp->__bufp > fp->__buffer)
492     {
493       if (fp->__linebuf && fp->__bufp > fp->__buffer)
494         /* This is a line-buffered stream, so its put-limit is
495            set to the beginning of the buffer in order to force
496            a __flshfp call on each putc.  We undo this hack here
497            (by setting the limit to the end of the buffer) to simplify
498            the interface with the output-room function.
499            However, we must make sure we don't do this if there isn't
500            actually anything in the buffer, because in that case we
501            want to give the output-room function a chance to prime
502            the stream for writing in whatever fashion turns it on.  */
503         fp->__put_limit = fp->__buffer + fp->__bufsize;
504
505       /* Make room in the buffer.  */
506       (*fp->__room_funcs.__output)(fp, flush_only ? EOF : (unsigned char) c);
507
508       if (fp->__linebuf)
509         /* Set the end pointer to the beginning of the buffer,
510            so the next `putc' call will force a call to this function
511            (see comment above about line-buffered streams).  */
512         fp->__put_limit = fp->__buffer;
513     }
514
515   if (ferror (fp))
516     return EOF;
517   if (flush_only)
518     return 0;
519   return (unsigned char) c;
520 }
521
522
523 /* Fill the buffer for FP and return the first character read.
524    This is the function used by getc.  */
525 int
526 DEFUN(__fillbf, (fp), register FILE *fp)
527 {
528   register int c;
529   fpos_t new_target;
530
531   if (!__validfp(fp) || !fp->__mode.__read)
532     {
533       errno = EINVAL;
534       return EOF;
535     }
536
537   if (fp->__pushed_back)
538     {
539       /* Return the char pushed back by ungetc.  */
540       fp->__bufp = fp->__pushback_bufp;
541       fp->__pushed_back = 0;
542       return fp->__pushback;
543     }
544
545   /* Make sure the stream is initialized (has functions and buffering). */
546   init_stream(fp);
547
548   /* If we're trying to read the first character of a new
549      line of input from an unbuffered or line buffered stream,
550      we must flush all line-buffered output streams. */
551   if (fp->__buffer == NULL || fp->__linebuf)
552     {
553       register FILE *f;
554       for (f = __stdio_head; f != NULL; f = f->__next)
555         if (__validfp(f) && f->__linebuf && f->__mode.__write &&
556             f->__put_limit > f->__buffer)
557           (void) __flshfp(f, EOF);
558     }
559
560   /* We want the beginning of the buffer to now
561      map to just past the last data we read.  */
562   new_target = fp->__target + (fp->__get_limit - fp->__buffer);
563
564   if (fp->__put_limit > fp->__buffer)
565     {
566       /* There is written data in the buffer.
567          Flush it out.  */
568       if (fp->__room_funcs.__output == NULL)
569         fp->__error = 1;
570       else
571         (*fp->__room_funcs.__output)(fp, EOF);
572     }
573
574   fp->__target = new_target;
575
576   if (ferror(fp))
577     c = EOF;
578   else if (fp->__room_funcs.__input != NULL)
579     {
580       c = (*fp->__room_funcs.__input)(fp);
581       if (fp->__buffer == NULL)
582         /* This is an unbuffered stream, so the target sync above
583            won't do anything the next time around.  Instead, note that
584            we have read one character.  The (nonexistent) buffer now
585            maps to the position just past that character.  */
586         ++fp->__target;
587     }
588   else
589     {
590       /* A NULL `input_room' function means always return EOF.  */
591       fp->__eof = 1;
592       c = EOF;
593     }
594
595   return c;
596 }
597
598
599 /* Nuke a stream, but don't kill its link in the chain.  */
600 void
601 DEFUN(__invalidate, (stream), register FILE *stream)
602 {
603   /* Save its link.  */
604   register FILE *next = stream->__next;
605
606   /* Pulverize the fucker.  */
607   memset((PTR) stream, 0, sizeof(FILE));
608
609   /* Restore the deceased's link.  */
610   stream->__next = next;
611 }
612
613
614 /* Abort with an error message.  */
615 __NORETURN
616 void
617 DEFUN(__libc_fatal, (message), CONST char *message)
618 {
619   __stdio_errmsg(message, strlen(message));
620   abort();
621 }