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