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