![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fileops.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / libg++ / libio|
Return to fileops.c CVS log | Up to [Apple XNU] / GNUtools / libg++ / libio |
1.1 root 1: /*
2: Copyright (C) 1993 Free Software Foundation
3:
4: This file is part of the GNU IO Library. This library is free
5: software; you can redistribute it and/or modify it under the
6: terms of the GNU General Public License as published by the
7: Free Software Foundation; either version 2, or (at your option)
8: any later version.
9:
10: This library is distributed in the hope that it will be useful,
11: but WITHOUT ANY WARRANTY; without even the implied warranty of
12: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13: GNU General Public License for more details.
14:
15: You should have received a copy of the GNU General Public License
16: along with GNU CC; see the file COPYING. If not, write to
17: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
18:
19: As a special exception, if you link this library with files
20: compiled with a GNU compiler to produce an executable, this does not cause
21: the resulting executable to be covered by the GNU General Public License.
22: This exception does not however invalidate any other reasons why
23: the executable file might be covered by the GNU General Public License. */
24:
25: /* written by Per Bothner ([email protected]) */
26:
27: #define _POSIX_SOURCE
28: #include "libioP.h"
29: #include <fcntl.h>
30: #include <sys/types.h>
31: #include <sys/stat.h>
32: #include <string.h>
33: #include <errno.h>
34: #ifndef errno
35: extern int errno;
36: #endif
37:
38: /* An fstream can be in at most one of put mode, get mode, or putback mode.
39: Putback mode is a variant of get mode.
40:
41: In a filebuf, there is only one current position, instead of two
42: separate get and put pointers. In get mode, the current posistion
43: is that of gptr(); in put mode that of pptr().
44:
45: The position in the buffer that corresponds to the position
46: in external file system is file_ptr().
47: This is normally egptr(), except in putback mode, when it is _save_egptr.
48: If the field _fb._offset is >= 0, it gives the offset in
49: the file as a whole corresponding to eGptr(). (???)
50:
51: PUT MODE:
52: If a filebuf is in put mode, pbase() is non-NULL and equal to base().
53: Also, epptr() == ebuf().
54: Also, eback() == gptr() && gptr() == egptr().
55: The un-flushed character are those between pbase() and pptr().
56: GET MODE:
57: If a filebuf is in get or putback mode, eback() != egptr().
58: In get mode, the unread characters are between gptr() and egptr().
59: The OS file position corresponds to that of egptr().
60: PUTBACK MODE:
61: Putback mode is used to remember "excess" characters that have
62: been sputbackc'd in a separate putback buffer.
63: In putback mode, the get buffer points to the special putback buffer.
64: The unread characters are the characters between gptr() and egptr()
65: in the putback buffer, as well as the area between save_gptr()
66: and save_egptr(), which point into the original reserve buffer.
67: (The pointers save_gptr() and save_egptr() are the values
68: of gptr() and egptr() at the time putback mode was entered.)
69: The OS position corresponds to that of save_egptr().
70:
71: LINE BUFFERED OUTPUT:
72: During line buffered output, pbase()==base() && epptr()==base().
73: However, ptr() may be anywhere between base() and ebuf().
74: This forces a call to filebuf::overflow(int C) on every put.
75: If there is more space in the buffer, and C is not a '\n',
76: then C is inserted, and pptr() incremented.
77:
78: UNBUFFERED STREAMS:
79: If a filebuf is unbuffered(), the _shortbuf[1] is used as the buffer.
80: */
81:
82: #define CLOSED_FILEBUF_FLAGS \
83: (_IO_IS_FILEBUF+_IO_NO_READS+_IO_NO_WRITES+_IO_TIED_PUT_GET)
84:
85:
86: void
87: _IO_file_init(fp)
88: register _IO_FILE *fp;
89: {
90: fp->_offset = _IO_pos_0;
91:
92: _IO_link_in(fp);
93: fp->_fileno = -1;
94: }
95:
96: int
97: _IO_file_close_it(fp)
98: register _IO_FILE* fp;
99: {
100: int status;
101: if (!_IO_file_is_open(fp))
102: return EOF;
103:
104: /* This flushes as well as switching mode. */
105: if (fp->_IO_write_ptr > fp->_IO_write_base || _IO_in_put_mode(fp))
106: if (_IO_switch_to_get_mode(fp))
107: return EOF;
108:
109: _IO_unsave_markers(fp);
110:
111: status = fp->_jumps->__close(fp);
112:
113: /* Free buffer. */
114: _IO_setb(fp, NULL, NULL, 0);
115: _IO_setg(fp, NULL, NULL, NULL);
116: _IO_setp(fp, NULL, NULL);
117:
118: _IO_un_link(fp);
119: fp->_flags = _IO_MAGIC|CLOSED_FILEBUF_FLAGS;
120: fp->_fileno = EOF;
121: fp->_offset = _IO_pos_0;
122:
123: return status;
124: }
125:
126: void
127: _IO_file_finish(fp)
128: register _IO_FILE* fp;
129: {
130: if (!(fp->_flags & _IO_DELETE_DONT_CLOSE))
131: _IO_file_close_it(fp);
132: _IO_default_finish(fp);
133: }
134:
135: _IO_FILE *
136: _IO_file_fopen(fp, filename, mode)
137: register _IO_FILE *fp;
138: const char *filename;
139: const char *mode;
140: {
141: int oflags = 0, omode;
142: int read_write, fdesc;
143: int oprot = 0666;
144: if (_IO_file_is_open (fp))
145: return 0;
146: switch (*mode++) {
147: case 'r':
148: omode = O_RDONLY;
149: read_write = _IO_NO_WRITES;
150: break;
151: case 'w':
152: omode = O_WRONLY;
153: oflags = O_CREAT|O_TRUNC;
154: read_write = _IO_NO_READS;
155: break;
156: case 'a':
157: omode = O_WRONLY;
158: oflags = O_CREAT|O_APPEND;
159: read_write = _IO_NO_READS|_IO_IS_APPENDING;
160: break;
161: default:
162: errno = EINVAL;
163: return NULL;
164: }
165: if (mode[0] == '+' || (mode[0] == 'b' && mode[1] == '+')) {
166: omode = O_RDWR;
167: read_write &= _IO_IS_APPENDING;
168: }
169: fdesc = open(filename, omode|oflags, oprot);
170: if (fdesc < 0)
171: return NULL;
172: fp->_fileno = fdesc;
173: fp->_IO_file_flags =
174: _IO_mask_flags(fp, read_write,_IO_NO_READS+_IO_NO_WRITES+_IO_IS_APPENDING);
175: if (read_write & _IO_IS_APPENDING)
176: if (fp->_jumps->__seekoff(fp, (_IO_off_t)0, _IO_seek_end) == _IO_pos_BAD)
177: return NULL;
178: _IO_link_in(fp);
179: return fp;
180: }
181:
182: _IO_FILE*
183: _IO_file_attach(fp, fd)
184: _IO_FILE *fp;
185: int fd;
186: {
187: if (_IO_file_is_open(fp))
188: return NULL;
189: fp->_fileno = fd;
190: fp->_flags &= ~(_IO_NO_READS+_IO_NO_WRITES);
191: fp->_offset = _IO_pos_BAD;
192: return fp;
193: }
194:
195: int
196: _IO_file_setbuf(fp, p, len)
197: register _IO_FILE *fp;
198: char* p;
199: _IO_ssize_t len;
200: {
201: if (_IO_default_setbuf(fp, p, len) == EOF)
202: return EOF;
203:
204: fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end
205: = fp->_IO_buf_base;
206: _IO_setg(fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
207:
208: return 0;
209: }
210:
211: int
212: _IO_do_write(fp, data, to_do)
213: register _IO_FILE *fp;
214: const char* data;
215: _IO_size_t to_do;
216: {
217: _IO_size_t count;
218: if (to_do == 0)
219: return 0;
220: if (fp->_flags & _IO_IS_APPENDING)
221: /* On a system without a proper O_APPEND implementation,
222: you would need to sys_seek(0, SEEK_END) here, but is
223: is not needed nor desirable for Unix- or Posix-like systems.
224: Instead, just indicate that offset (before and after) is
225: unpredictable. */
226: fp->_offset = _IO_pos_BAD;
227: else if (fp->_IO_read_end != fp->_IO_write_base)
228: {
229: _IO_pos_t new_pos = fp->_jumps->__seek(fp, fp->_IO_write_base - fp->_IO_read_end, 1);
230: if (new_pos == _IO_pos_BAD)
231: return EOF;
232: fp->_offset = new_pos;
233: }
234: count = fp->_jumps->__write(fp, data, to_do);
235: if (fp->_cur_column)
236: fp->_cur_column = _IO_adjust_column(fp->_cur_column - 1, data, to_do) + 1;
237: _IO_setg(fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
238: fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_buf_base;
239: fp->_IO_write_end = (fp->_flags & _IO_LINE_BUF+_IO_UNBUFFERED) ? fp->_IO_buf_base
240: : fp->_IO_buf_end;
241: return count != to_do ? EOF : 0;
242: }
243:
244: int
245: _IO_file_underflow(fp)
246: register _IO_FILE *fp;
247: {
248: _IO_size_t count;
249: #if 0
250: /* SysV does not make this test; take it out for compatibility */
251: if (fp->_flags & _IO_EOF_SEEN)
252: return (EOF);
253: #endif
254:
255: if (fp->_flags & _IO_NO_READS)
256: return EOF;
257: if (fp->_IO_read_ptr < fp->_IO_read_end)
258: return *(unsigned char*)fp->_IO_read_ptr;
259:
260: if (fp->_IO_buf_base == NULL)
261: _IO_doallocbuf(fp);
262:
263: /* Flush all line buffered files before reading. */
264: /* FIXME This can/should be moved to genops ?? */
265: if (fp->_flags & (_IO_LINE_BUF|_IO_UNBUFFERED))
266: _IO_flush_all_linebuffered();
267:
268: _IO_switch_to_get_mode(fp);
269:
270: count = fp->_jumps->__read(fp, fp->_IO_buf_base,
271: fp->_IO_buf_end - fp->_IO_buf_base);
272: if (count <= 0)
273: {
274: if (count == 0)
275: fp->_flags |= _IO_EOF_SEEN;
276: else
277: fp->_flags |= _IO_ERR_SEEN, count = 0;
278: }
279: fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_buf_base;
280: fp->_IO_read_end = fp->_IO_buf_base + count;
281: fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end
282: = fp->_IO_buf_base;
283: if (count == 0)
284: return EOF;
285: if (fp->_offset != _IO_pos_BAD)
286: _IO_pos_adjust(fp->_offset, count);
287: return *(unsigned char*)fp->_IO_read_ptr;
288: }
289:
290: int _IO_file_overflow (f, ch)
291: register _IO_FILE* f;
292: int ch;
293: {
294: if (f->_flags & _IO_NO_WRITES) /* SET ERROR */
295: return EOF;
296: /* If current reading or no buffer allocated. */
297: if ((f->_flags & _IO_CURRENTLY_PUTTING) == 0)
298: {
299: /* Allocate a buffer if needed. */
300: if (f->_IO_buf_base == 0)
301: {
302: _IO_doallocbuf(f);
303: f->_IO_read_end = f->_IO_buf_base;
304: f->_IO_write_ptr = f->_IO_buf_base;
305: }
306: else /* Must be currently reading. */
307: f->_IO_write_ptr = f->_IO_read_ptr;
308: f->_IO_write_base = f->_IO_write_ptr;
309: f->_IO_write_end = f->_IO_buf_end;
310: f->_IO_read_base = f->_IO_read_ptr = f->_IO_read_end;
311:
312: if (f->_flags & _IO_LINE_BUF+_IO_UNBUFFERED)
313: f->_IO_write_end = f->_IO_write_ptr;
314: f->_flags |= _IO_CURRENTLY_PUTTING;
315: }
316: if (ch == EOF)
317: return _IO_do_flush(f);
318: if (f->_IO_write_ptr == f->_IO_buf_end ) /* Buffer is really full */
319: if (_IO_do_flush(f) == EOF)
320: return EOF;
321: *f->_IO_write_ptr++ = ch;
322: if ((f->_flags & _IO_UNBUFFERED)
323: || ((f->_flags & _IO_LINE_BUF) && ch == '\n'))
324: if (_IO_do_flush(f) == EOF)
325: return EOF;
326: return (unsigned char)ch;
327: }
328:
329: int
330: _IO_file_sync(fp)
331: register _IO_FILE* fp;
332: {
333: _IO_size_t delta;
334: /* char* ptr = cur_ptr(); */
335: if (fp->_IO_write_ptr > fp->_IO_write_base)
336: if (_IO_do_flush(fp)) return EOF;
337: delta = fp->_IO_read_ptr - fp->_IO_read_end;
338: if (delta != 0)
339: {
340: #ifdef TODO
341: if (_IO_in_backup(fp))
342: delta -= eGptr() - Gbase();
343: #endif
344: _IO_off_t new_pos = fp->_jumps->__seek(fp, delta, 1);
345: if (new_pos == (_IO_off_t)EOF)
346: return EOF;
347: fp->_offset = new_pos;
348: fp->_IO_read_end = fp->_IO_read_ptr;
349: }
350: /* FIXME: Cleanup - can this be shared? */
351: /* setg(base(), ptr, ptr); */
352: return 0;
353: }
354:
355: _IO_pos_t
356: _IO_file_seekoff(fp, offset, mode)
357: register _IO_FILE *fp;
358: _IO_off_t offset;
359: _IO_seekflags mode;
360: {
361: _IO_pos_t result;
362: _IO_off_t delta, new_offset;
363: long count;
364: int dir = mode & 3;
365:
366: if ((mode & _IO_seek_not_in) && (mode & _IO_seek_not_out))
367: dir = _IO_seek_cur, offset = 0; /* Don't move any pointers. */
368:
369: /* Flush unwritten characters.
370: (This may do an unneeded write if we seek within the buffer.
371: But to be able to switch to reading, we would need to set
372: egptr to ptr. That can't be done in the current design,
373: which assumes file_ptr() is eGptr. Anyway, since we probably
374: end up flushing when we close(), it doesn't make much difference.)
375: FIXME: simulate mem-papped files. */
376:
377: if (fp->_IO_write_ptr > fp->_IO_write_base || _IO_in_put_mode(fp))
378: if (_IO_switch_to_get_mode(fp)) return EOF;
379:
380: if (fp->_IO_buf_base == NULL)
381: {
382: _IO_doallocbuf(fp);
383: _IO_setp(fp, fp->_IO_buf_base, fp->_IO_buf_base);
384: _IO_setg(fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
385: }
386:
387: switch (dir)
388: {
389: case _IO_seek_cur:
390: if (fp->_offset == _IO_pos_BAD)
391: goto dumb;
392: /* Adjust for read-ahead (bytes is buffer). */
393: offset -= fp->_IO_read_end - fp->_IO_read_ptr;
394: /* Make offset absolute, assuming current pointer is file_ptr(). */
395: offset += _IO_pos_as_off(fp->_offset);
396:
397: dir = _IO_seek_set;
398: break;
399: case _IO_seek_set:
400: break;
401: case _IO_seek_end:
402: {
403: struct stat st;
404: if (fp->_jumps->__stat(fp, &st) == 0 && S_ISREG(st.st_mode))
405: {
406: offset += st.st_size;
407: dir = _IO_seek_set;
408: }
409: else
410: goto dumb;
411: }
412: }
413: /* At this point, dir==_IO_seek_set. */
414:
415: #ifdef TODO
416: /* If destination is within current buffer, optimize: */
417: if (fp->_offset != IO_pos_BAD && fp->_IO_read_base != NULL)
418: {
419: /* Offset relative to start of main get area. */
420: _IO_pos_t rel_offset = offset - _fb._offset
421: + (eGptr()-Gbase());
422: if (rel_offset >= 0)
423: {
424: if (_IO_in_backup(fp))
425: _IO_switch_to_main_get_area(fp);
426: if (rel_offset <= _IO_read_end - _IO_read_base)
427: {
428: _IO_setg(fp->_IO_buf_base, fp->_IO_buf_base + rel_offset,
429: fp->_IO_read_end);
430: _IO_setp(fp->_IO_buf_base, fp->_IO_buf_base);
431: return offset;
432: }
433: /* If we have streammarkers, seek forward by reading ahead. */
434: if (_IO_have_markers(fp))
435: {
436: int to_skip = rel_offset
437: - (fp->_IO_read_ptr - fp->_IO_read_base);
438: if (ignore(to_skip) != to_skip)
439: goto dumb;
440: return offset;
441: }
442: }
443: if (rel_offset < 0 && rel_offset >= Bbase() - Bptr())
444: {
445: if (!_IO_in_backup(fp))
446: _IO_switch_to_backup_area(fp);
447: gbump(fp->_IO_read_end + rel_offset - fp->_IO_read_ptr);
448: return offset;
449: }
450: }
451:
452: _IO_unsave_markers(fp);
453: #endif
454:
455: /* Try to seek to a block boundary, to improve kernel page management. */
456: new_offset = offset & ~(fp->_IO_buf_end - fp->_IO_buf_base - 1);
457: delta = offset - new_offset;
458: if (delta > fp->_IO_buf_end - fp->_IO_buf_base)
459: {
460: new_offset = offset;
461: delta = 0;
462: }
463: result = fp->_jumps->__seek(fp, new_offset, 0);
464: if (result < 0)
465: return EOF;
466: if (delta == 0)
467: count = 0;
468: else
469: {
470: count = fp->_jumps->__read(fp, fp->_IO_buf_base,
471: fp->_IO_buf_end - fp->_IO_buf_base);
472: if (count < delta)
473: {
474: /* We weren't allowed to read, but try to seek the remainder. */
475: offset = count == EOF ? delta : delta-count;
476: dir = _IO_seek_cur;
477: goto dumb;
478: }
479: }
480: _IO_setg(fp, fp->_IO_buf_base, fp->_IO_buf_base+delta, fp->_IO_buf_base+count);
481: _IO_setp(fp, fp->_IO_buf_base, fp->_IO_buf_base);
482: fp->_offset = result + count;
483: _IO_mask_flags(fp, 0, _IO_EOF_SEEN);
484: return offset;
485: dumb:
486:
487: _IO_unsave_markers(fp);
488: result = fp->_jumps->__seek(fp, offset, dir);
489: if (result != EOF)
490: _IO_mask_flags(fp, 0, _IO_EOF_SEEN);
491: fp->_offset = result;
492: _IO_setg(fp, fp->_IO_buf_base, fp->_IO_buf_base, fp->_IO_buf_base);
493: _IO_setp(fp, fp->_IO_buf_base, fp->_IO_buf_base);
494: return result;
495: }
496:
497: _IO_ssize_t
498: _IO_file_read(fp, buf, size)
499: register _IO_FILE* fp;
500: void* buf;
501: _IO_ssize_t size;
502: {
503: for (;;)
504: {
505: _IO_ssize_t count = _IO_read(fp->_fileno, buf, size);
506: #ifdef EINTR
507: if (errno == EINTR && count == -1)
508: continue;
509: #endif
510: return count;
511: }
512: }
513:
514: _IO_pos_t
515: _IO_file_seek(fp, offset, dir)
516: _IO_FILE *fp;
517: _IO_off_t offset;
518: int dir;
519: {
520: return _IO_lseek(fp->_fileno, offset, dir);
521: }
522:
523: int
524: _IO_file_stat(fp, st)
525: _IO_FILE *fp;
526: void* st;
527: {
528: return _IO_fstat(fp->_fileno, (struct stat*)st);
529: }
530:
531: int
532: _IO_file_close(fp)
533: _IO_FILE* fp;
534: {
535: return _IO_close(fp->_fileno);
536: }
537:
538: _IO_ssize_t
539: _IO_file_write(f, data, n)
540: register _IO_FILE* f;
541: const void* data;
542: _IO_ssize_t n;
543: {
544: _IO_ssize_t to_do = n;
545: while (to_do > 0)
546: {
547: _IO_ssize_t count = _IO_write(f->_fileno, data, to_do);
548: if (count == EOF)
549: {
550: #ifdef EINTR
551: if (errno == EINTR)
552: continue;
553: else
554: #endif
555: {
556: f->_flags |= _IO_ERR_SEEN;
557: break;
558: }
559: }
560: to_do -= count;
561: data = (void*)((char*)data + count);
562: }
563: n -= to_do;
564: if (f->_offset >= 0)
565: f->_offset += n;
566: return n;
567: }
568:
569: _IO_size_t
570: _IO_file_xsputn(f, data, n)
571: _IO_FILE *f;
572: const void *data;
573: _IO_size_t n;
574: {
575: register const char *s = data;
576: _IO_size_t to_do = n;
577: int must_flush = 0;
578: _IO_size_t count;
579:
580: if (n <= 0)
581: return 0;
582: /* This is an optimized implementation.
583: If the amount to be written straddles a block boundary
584: (or the filebuf is unbuffered), use sys_write directly. */
585:
586: /* First figure out how much space is available in the buffer. */
587: count = f->_IO_write_end - f->_IO_write_ptr; /* Space available. */
588: if ((f->_flags & _IO_LINE_BUF) && (f->_flags & _IO_CURRENTLY_PUTTING))
589: {
590: count = f->_IO_buf_end - f->_IO_write_ptr;
591: if (count >= n)
592: { register const char *p;
593: for (p = s + n; p > s; )
594: {
595: if (*--p == '\n') {
596: count = p - s + 1;
597: must_flush = 1;
598: break;
599: }
600: }
601: }
602: }
603: /* Then fill the buffer. */
604: if (count > 0)
605: {
606: if (count > to_do)
607: count = to_do;
608: if (count > 20) {
609: memcpy(f->_IO_write_ptr, s, count);
610: s += count;
611: }
612: else
613: {
614: register char *p = f->_IO_write_ptr;
615: register int i = (int)count;
616: while (--i >= 0) *p++ = *s++;
617: }
618: f->_IO_write_ptr += count;
619: to_do -= count;
620: }
621: if (to_do + must_flush > 0)
622: { _IO_size_t block_size, dont_write;
623: /* Next flush the (full) buffer. */
624: if (__overflow(f, EOF) == EOF)
625: return n - to_do;
626:
627: /* Try to maintain alignment: write a whole number of blocks.
628: dont_write is what gets left over. */
629: block_size = f->_IO_buf_end - f->_IO_buf_base;
630: dont_write = block_size >= 128 ? to_do % block_size : 0;
631:
632: count = to_do - dont_write;
633: if (_IO_do_write(f, s, count) == EOF)
634: return n - to_do;
635: to_do = dont_write;
636:
637: /* Now write out the remainder. Normally, this will fit in the
638: buffer, but it's somewhat messier for line-buffered files,
639: so we let _IO_xsputn handle the general case. */
640: if (dont_write)
641: to_do -= _IO_default_xsputn(f, s+count, dont_write);
642: }
643: return n - to_do;
644: }
645:
646: struct _IO_jump_t _IO_file_jumps = {
647: _IO_file_overflow,
648: _IO_file_underflow,
649: _IO_file_xsputn,
650: _IO_default_xsgetn,
651: _IO_file_read,
652: _IO_file_write,
653: _IO_file_doallocate,
654: _IO_default_pbackfail,
655: _IO_file_setbuf,
656: _IO_file_sync,
657: _IO_file_finish,
658: _IO_file_close,
659: _IO_file_stat,
660: _IO_file_seek,
661: _IO_file_seekoff,
662: _IO_default_seekpos,
663: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.