update from main archive
[kopensolaris-gnu/glibc.git] / stdio / fseek.c
1 /* Copyright (C) 1991, 92, 93, 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
22
23 /* Move the file position of STREAM to OFFSET
24    bytes from the beginning of the file if WHENCE
25    is SEEK_SET, the end of the file is it is SEEK_END,
26    or the current position if it is SEEK_CUR.  */
27 int
28 fseek (stream, offset, whence)
29      register FILE *stream;
30      long int offset;
31      int whence;
32 {
33   long int o;
34
35   if (!__validfp (stream))
36     {
37       __set_errno (EINVAL);
38       return EOF;
39     }
40
41   /* Write out any pending data.  */
42   if (stream->__mode.__write && __flshfp (stream, EOF) == EOF)
43     return EOF;
44
45   /* Make sure we know the current offset info.  */
46   stream->__offset = -1;
47   if (__stdio_check_offset (stream) == EOF)
48     return EOF;
49
50   /* We are moving the file position, so we are no longer at EOF.  */
51   stream->__eof = 0;
52
53   if (stream->__pushed_back)
54     {
55       /* Discard the character pushed back by ungetc.  */
56       stream->__bufp = stream->__pushback_bufp;
57       stream->__pushed_back = 0;
58     }
59
60   /* Check the WHENCE argument for validity, and process OFFSET
61      into an absolute position in O.  By the end of this switch,
62      either we have returned, or O contains an absolute position.  */
63   o = offset;
64   switch (whence)
65     {
66     default:
67       __set_errno (EINVAL);
68       return EOF;
69
70     case SEEK_END:
71       /* We don't know where the end of the file is,
72          so seek to the position in the file the user asked
73          for, and then look where that is.  */
74       if (stream->__io_funcs.__seek == NULL)
75         {
76           __set_errno (ESPIPE);
77           return EOF;
78         }
79       else
80         {
81           fpos_t pos = (fpos_t) o;
82           if ((*stream->__io_funcs.__seek)
83               (stream->__cookie, &pos, SEEK_END) < 0)
84             {
85               if (errno == ESPIPE)
86                 stream->__io_funcs.__seek = NULL;
87               return EOF;
88             }
89           stream->__offset = pos;
90           /* Make O be absolute, rather than
91              relative to the end of the file.  */
92           o = pos;
93         }
94
95       /* Fall through to try an absolute seek.  */
96
97     case SEEK_SET:
98       /* Make O be relative to the buffer.  */
99       o -= stream->__target;
100       /* Make O be relative to the current position in the buffer.  */
101       o -= stream->__bufp - stream->__buffer;
102
103       /* Fall through to see if we can do it by
104          moving the pointer around in the buffer.  */
105
106     case SEEK_CUR:
107       /* If the offset is small enough, we can just
108          move the pointer around in the buffer.  */
109
110 #if 0   /* Why did I think this would ever work???  */
111       if (stream->__put_limit > stream->__buffer)
112         {
113           /* We are writing.  */
114           if (stream->__bufp + o >= stream->__buffer &&
115               stream->__put_limit > stream->__bufp + o &&
116               stream->__get_limit > stream->__bufp + o)
117             {
118               /* We have read all the data we will change soon.
119                  We can just move the pointer around.  */
120               stream->__bufp += o;
121               return 0;
122             }
123           else
124             {
125               /* Flush the buffer.  */
126               if (__flshfp(stream, EOF) == EOF)
127                 return EOF;
128             }
129         } else
130 #endif
131       if (o < 0 ?
132           (-o <= stream->__bufp - stream->__buffer) :
133           (o <= stream->__get_limit - stream->__bufp))
134         {
135           stream->__bufp += o;
136           return 0;
137         }
138
139       /* Turn it into an absolute seek.  */
140       o += stream->__bufp - stream->__buffer;
141       o += stream->__target;
142       break;
143     }
144
145   if (o < 0)
146     {
147       /* Negative file position is meaningless.  */
148       __set_errno (EINVAL);
149       return -1;
150     }
151
152   /* O is now an absolute position, the new target.  */
153   stream->__target = o;
154
155   /* Set bufp and both end pointers to the beginning of the buffer.
156      The next i/o will force a call to the input/output room function.  */
157   stream->__bufp
158     = stream->__get_limit = stream->__put_limit = stream->__buffer;
159
160   /* Make sure __flshfp doesn't think the put_limit is at the beginning
161      of the buffer because of line-buffering magic.  */
162   stream->__linebuf_active = 0;
163
164   /* If there is no seek function, seeks always fail.  */
165   if (stream->__io_funcs.__seek == NULL)
166     {
167       /* This is preemptive, since we don't actually do the seeking.
168          But it makes more sense for fseek to to fail with ESPIPE
169          than for the next reading or writing operation to fail
170          that way.  */
171       __set_errno (ESPIPE);
172       return EOF;
173     }
174
175   /* Don't actually seek.  The next reading or writing operation
176      will force a call to the input or output room function,
177      which will move to the target file position before reading or writing.  */
178   return 0;
179 }