Hello Eric, and thanks for your reply,
On Tuesday, April 15, 2008 at 12:58:16 -0600, Eric Blake wrote:
> Can you also find the implementations, as well as show us what struct
> FILE looks like?
>From libc 5.4.33 libio/ come attached files iofflush.c, iosetvbuf.c,
ioungetc.c, iofread.c, genops.c (for subfunctions), and libio.h (for the
FILE == _IO_FILE struct). I realize that some parts of information can
be in yet other files, so here is the whole libc source:
<URL:http://archive.debian.org/debian-archive/dists/bo/main/source/libs/libc_5.4.33.orig.tar.gz>
Alain.
/*
Copyright (C) 1993 Free Software Foundation
This file is part of the GNU IO Library. This library is free
software; you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option)
any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this library; see the file COPYING. If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
As a special exception, if you link this library with files
compiled with a GNU compiler to produce an executable, this does not cause
the resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why
the executable file might be covered by the GNU General Public License. */
#include "libioP.h"
#ifdef _LIBPTHREAD
#define _IO_fflush fflush
#endif
int
DEFUN(_IO_fflush, (fp),
register _IO_FILE *fp)
{
int result;
if (fp == NULL)
{
#ifdef _LIBPTHREAD
__libc_lock_lock (__libc_libio_lock);
#endif
result = _IO_flush_all();
#ifdef _LIBPTHREAD
__libc_lock_unlock (__libc_libio_lock);
#endif
}
else
{
CHECK_FILE(fp, EOF);
#ifdef _LIBPTHREAD
flockfile (fp);
#endif
result = _IO_SYNC (fp) ? EOF : 0;
#ifdef _LIBPTHREAD
funlockfile (fp);
#endif
}
return result;
}
#ifndef _LIBPTHREAD
#if defined(__ELF__) || defined(__GNU_LIBRARY__)
#include <gnu-stabs.h>
#ifdef weak_alias
weak_alias (_IO_fflush, fflush);
#endif
#endif
#endif
/*
Copyright (C) 1993 Free Software Foundation
This file is part of the GNU IO Library. This library is free
software; you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option)
any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this library; see the file COPYING. If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
As a special exception, if you link this library with files
compiled with a GNU compiler to produce an executable, this does not cause
the resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why
the executable file might be covered by the GNU General Public License. */
#include "libioP.h"
#define _IOFBF 0 /* Fully buffered. */
#define _IOLBF 1 /* Line buffered. */
#define _IONBF 2 /* No buffering. */
int
DEFUN(_IO_setvbuf, (fp, buf, mode, size),
_IO_FILE* fp AND char* buf AND int mode AND _IO_size_t size)
{
CHECK_FILE(fp, EOF);
switch (mode)
{
case _IOFBF:
fp->_IO_file_flags &= ~_IO_LINE_BUF|_IO_UNBUFFERED;
if (buf == NULL)
{
if (fp->_IO_buf_base == NULL)
{
/* There is no flag to distinguish between "fully buffered
mode has been explicitly set" as opposed to "line
buffering has not been explicitly set". In both
cases, _IO_LINE_BUF is off. If this is a tty, and
_IO_filedoalloc later gets called, it cannot know if
it should set the _IO_LINE_BUF flag (because that is
the default), or not (because we have explicitly asked
for fully buffered mode). So we make sure a buffer
gets allocated now, and explicitly turn off line
buffering.
A possibly cleaner alternative would be to add an
extra flag, but then flags are a finite resource. */
if (_IO_DOALLOCATE (fp) < 0)
return EOF;
fp->_IO_file_flags &= ~_IO_LINE_BUF;
}
return 0;
}
break;
case _IOLBF:
fp->_IO_file_flags &= ~_IO_UNBUFFERED;
fp->_IO_file_flags |= _IO_LINE_BUF;
if (buf == NULL)
return 0;
break;
case _IONBF:
buf = NULL;
size = 0;
break;
default:
return EOF;
}
return _IO_SETBUF (fp, buf, size) == NULL ? EOF : 0;
}
#if defined(__ELF__) || defined(__GNU_LIBRARY__)
#include <gnu-stabs.h>
#ifdef weak_alias
weak_alias (_IO_setvbuf, setvbuf);
#endif
#endif
/*
Copyright (C) 1993 Free Software Foundation
This file is part of the GNU IO Library. This library is free
software; you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option)
any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this library; see the file COPYING. If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
As a special exception, if you link this library with files
compiled with a GNU compiler to produce an executable, this does not cause
the resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why
the executable file might be covered by the GNU General Public License. */
#include "libioP.h"
int
DEFUN(_IO_ungetc, (c, fp),
int c AND _IO_FILE *fp)
{
CHECK_FILE(fp, EOF);
if (c == EOF)
return EOF;
return _IO_sputbackc(fp, (unsigned char)c);
}
#if defined(__ELF__) || defined(__GNU_LIBRARY__)
#include <gnu-stabs.h>
#ifdef weak_alias
weak_alias (_IO_ungetc, ungetc);
#endif
#endif
/*
Copyright (C) 1993 Free Software Foundation
This file is part of the GNU IO Library. This library is free
software; you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option)
any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this library; see the file COPYING. If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
As a special exception, if you link this library with files
compiled with a GNU compiler to produce an executable, this does not cause
the resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why
the executable file might be covered by the GNU General Public License. */
#include "libioP.h"
_IO_size_t
DEFUN(_IO_fread, (buf, size, count, fp),
void *buf AND _IO_size_t size AND _IO_size_t count AND _IO_FILE* fp)
{
_IO_size_t bytes_requested = size*count;
_IO_size_t bytes_read;
CHECK_FILE(fp, 0);
if (bytes_requested == 0)
return 0;
bytes_read = _IO_sgetn(fp, (char *)buf, bytes_requested);
return bytes_requested == bytes_read ? count : bytes_read / size;
}
#if defined(__ELF__) || defined(__GNU_LIBRARY__)
#include <gnu-stabs.h>
#ifdef weak_alias
weak_alias (_IO_fread, fread);
#endif
#endif
/*
Copyright (C) 1993, 1995 Free Software Foundation
This file is part of the GNU IO Library. This library is free
software; you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option)
any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this library; see the file COPYING. If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
As a special exception, if you link this library with files
compiled with a GNU compiler to produce an executable, this does not cause
the resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why
the executable file might be covered by the GNU General Public License. */
/* Generic or default I/O operations. */
#include "libioP.h"
#ifdef __STDC__
#include <stdlib.h>
#endif
#include <string.h>
void _IO_un_link( _IO_FILE *);
void _IO_link_in( _IO_FILE *);
_IO_size_t _IO_least_marker( register _IO_FILE * );
void _IO_switch_to_main_get_area( _IO_FILE * );
void _IO_switch_to_backup_area( register _IO_FILE * );
void _IO_free_backup_area( register _IO_FILE * );
int __overflow( _IO_FILE *, int );
static int save_for_backup( _IO_FILE * );
int __underflow( _IO_FILE * );
int __uflow( _IO_FILE * );
void _IO_setb( _IO_FILE *, char *, char *, int );
void _IO_doallocbuf( register _IO_FILE * );
int _IO_default_underflow( _IO_FILE * );
int _IO_default_uflow( _IO_FILE * );
_IO_size_t _IO_default_xsputn( register _IO_FILE *, const void *, _IO_size_t );
_IO_size_t _IO_sgetn( _IO_FILE *, void *, _IO_size_t );
_IO_size_t _IO_default_xsgetn( _IO_FILE *, void *, _IO_size_t );
int _IO_sync( register _IO_FILE * );
_IO_FILE* _IO_default_setbuf( register _IO_FILE *, char *, _IO_ssize_t );
_IO_pos_t _IO_default_seekpos( _IO_FILE *, _IO_pos_t, int );
int _IO_default_doallocate( _IO_FILE * );
void _IO_init( register _IO_FILE *, int );
int _IO_default_sync( _IO_FILE * );
void _IO_default_finish( _IO_FILE * );
_IO_pos_t _IO_default_seekoff( register _IO_FILE *, _IO_off_t, int, int );
int _IO_sputbackc( register _IO_FILE *, int );
int _IO_sungetc( register _IO_FILE * );
int _IO_set_column( register _IO_FILE *, int );
unsigned _IO_adjust_column( unsigned, const char *, int );
int _IO_get_column( register _IO_FILE * );
int _IO_flush_all( void );
void _IO_flush_all_linebuffered( void );
void _IO_unbuffer_all( void );
void _IO_cleanup( void );
void _IO_init_marker( struct _IO_marker *, _IO_FILE * );
void _IO_remove_marker( register struct _IO_marker * );
int _IO_marker_difference( struct _IO_marker *, struct _IO_marker * );
int _IO_marker_delta( struct _IO_marker * );
int _IO_seekmark( _IO_FILE *, struct _IO_marker *, int );
void _IO_unsave_markers( register _IO_FILE * );
int _IO_nobackup_pbackfail( register _IO_FILE *, int );
int _IO_default_pbackfail( register _IO_FILE *, int );
_IO_pos_t _IO_default_seek( _IO_FILE *, _IO_off_t, int );
int _IO_default_stat( _IO_FILE *, void * );
_IO_ssize_t _IO_default_read( register _IO_FILE *, void *, _IO_ssize_t );
_IO_ssize_t _IO_default_write( register _IO_FILE *, const void *,
_IO_ssize_t );
void
DEFUN(_IO_un_link, (fp),
_IO_FILE *fp)
{
if (fp->_flags & _IO_LINKED) {
_IO_FILE **f;
for (f = &_IO_list_all; *f != NULL; f = &(*f)->_chain) {
if (*f == fp) {
*f = fp->_chain;
break;
}
}
fp->_flags &= ~_IO_LINKED;
}
}
void
DEFUN(_IO_link_in, (fp),
_IO_FILE *fp)
{
if ((fp->_flags & _IO_LINKED) == 0) {
fp->_flags |= _IO_LINKED;
fp->_chain = _IO_list_all;
_IO_list_all = fp;
}
}
/* Return minimum _pos markers
Assumes the current get area is the main get area. */
_IO_size_t
DEFUN(_IO_least_marker, (fp),
register _IO_FILE *fp)
{
_IO_ssize_t least_so_far = fp->_IO_read_end - fp->_IO_read_base;
register struct _IO_marker *mark;
for (mark = fp->_markers; mark != NULL; mark = mark->_next)
if (mark->_pos < least_so_far)
least_so_far = mark->_pos;
return least_so_far;
}
/* Switch current get area from backup buffer to (start of) main get area. */
void
DEFUN(_IO_switch_to_main_get_area, (fp),
_IO_FILE *fp)
{
char *tmp;
fp->_flags &= ~_IO_IN_BACKUP;
/* Swap _IO_read_end and _IO_save_end. */
tmp = fp->_IO_read_end; fp->_IO_read_end= fp->_IO_save_end; fp->_IO_save_end=
tmp;
/* Swap _IO_read_base and _IO_save_base. */
tmp = fp->_IO_read_base; fp->_IO_read_base = fp->_IO_save_base;
fp->_IO_save_base = tmp;
fp->_IO_read_ptr = fp->_IO_read_base;
}
/* Switch current get area from main get area to (end of) backup area. */
void
DEFUN(_IO_switch_to_backup_area, (fp),
register _IO_FILE *fp)
{
char *tmp;
fp->_flags |= _IO_IN_BACKUP;
/* Swap _IO_read_end and _IO_save_end. */
tmp = fp->_IO_read_end; fp->_IO_read_end = fp->_IO_save_end; fp->_IO_save_end
= tmp;
/* Swap _gbase and _IO_save_base. */
tmp = fp->_IO_read_base; fp->_IO_read_base = fp->_IO_save_base;
fp->_IO_save_base = tmp;
fp->_IO_read_ptr = fp->_IO_read_end;
}
int
DEFUN(_IO_switch_to_get_mode, (fp),
register _IO_FILE *fp)
{
if (fp->_IO_write_ptr > fp->_IO_write_base)
if (_IO_OVERFLOW (fp, EOF) == EOF)
return EOF;
if (_IO_in_backup(fp))
fp->_IO_read_base = fp->_IO_backup_base;
else
{
fp->_IO_read_base = fp->_IO_buf_base;
if (fp->_IO_write_ptr > fp->_IO_read_end)
fp->_IO_read_end = fp->_IO_write_ptr;
}
fp->_IO_read_ptr = fp->_IO_write_ptr;
fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end = fp->_IO_read_ptr;
fp->_flags &= ~_IO_CURRENTLY_PUTTING;
return 0;
}
void
DEFUN(_IO_free_backup_area, (fp),
register _IO_FILE *fp)
{
if (_IO_in_backup (fp))
_IO_switch_to_main_get_area(fp); /* Just in case. */
free (fp->_IO_save_base);
fp->_IO_save_base = NULL;
fp->_IO_save_end = NULL;
fp->_IO_backup_base = NULL;
}
#if 0
int
DEFUN(_IO_switch_to_put_mode, (fp),
register _IO_FILE *fp)
{
fp->_IO_write_base = fp->_IO_read_ptr;
fp->_IO_write_ptr = fp->_IO_read_ptr;
/* Following is wrong if line- or un-buffered? */
fp->_IO_write_end = fp->_flags & _IO_IN_BACKUP ? fp->_IO_read_end :
fp->_IO_buf_end;
fp->_IO_read_ptr = fp->_IO_read_end;
fp->_IO_read_base = fp->_IO_read_end;
fp->_flags |= _IO_CURRENTLY_PUTTING;
return 0;
}
#endif
int
DEFUN(__overflow, (f, ch),
_IO_FILE *f AND int ch)
{
return _IO_OVERFLOW (f, ch);
}
static int
DEFUN(save_for_backup, (fp),
_IO_FILE *fp)
{
/* Append [_IO_read_base.._IO_read_end] to backup area. */
int least_mark = _IO_least_marker(fp);
/* needed_size is how much space we need in the backup area. */
int needed_size = (fp->_IO_read_end - fp->_IO_read_base) - least_mark;
int current_Bsize = fp->_IO_save_end - fp->_IO_save_base;
int avail; /* Extra space available for future expansion. */
int delta;
struct _IO_marker *mark;
if (needed_size > current_Bsize)
{
char *new_buffer;
avail = 100;
new_buffer = (char*)malloc(avail+needed_size);
if (new_buffer == NULL)
return EOF; /* FIXME */
if (least_mark < 0)
{
memcpy(new_buffer + avail,
fp->_IO_save_end + least_mark,
-least_mark);
memcpy(new_buffer +avail - least_mark,
fp->_IO_read_base,
fp->_IO_read_end - fp->_IO_read_base);
}
else
memcpy(new_buffer + avail,
fp->_IO_read_base + least_mark,
needed_size);
if (fp->_IO_save_base)
free (fp->_IO_save_base);
fp->_IO_save_base = new_buffer;
fp->_IO_save_end = new_buffer + avail + needed_size;
}
else
{
avail = current_Bsize - needed_size;
if (least_mark < 0)
{
memmove(fp->_IO_save_base + avail,
fp->_IO_save_end + least_mark,
-least_mark);
memcpy(fp->_IO_save_base + avail - least_mark,
fp->_IO_read_base,
fp->_IO_read_end - fp->_IO_read_base);
}
else if (needed_size > 0)
memcpy(fp->_IO_save_base + avail,
fp->_IO_read_base + least_mark,
needed_size);
}
/* FIXME: Dubious arithmetic if pointers are NULL */
fp->_IO_backup_base = fp->_IO_save_base + avail;
/* Adjust all the streammarkers. */
delta = fp->_IO_read_end - fp->_IO_read_base;
for (mark = fp->_markers; mark != NULL; mark = mark->_next)
mark->_pos -= delta;
return 0;
}
int
DEFUN(__underflow, (fp),
_IO_FILE *fp)
{
if (_IO_in_put_mode(fp))
if (_IO_switch_to_get_mode(fp) == EOF) return EOF;
if (fp->_IO_read_ptr < fp->_IO_read_end)
return *(unsigned char*)fp->_IO_read_ptr;
if (_IO_in_backup(fp))
{
_IO_switch_to_main_get_area(fp);
if (fp->_IO_read_ptr < fp->_IO_read_end)
return *fp->_IO_read_ptr;
}
if (_IO_have_markers(fp))
{
if (save_for_backup (fp))
return EOF;
}
else if (_IO_have_backup(fp))
_IO_free_backup_area(fp);
return _IO_UNDERFLOW (fp);
}
int
DEFUN(__uflow, (fp),
_IO_FILE *fp)
{
if (_IO_in_put_mode(fp))
if (_IO_switch_to_get_mode(fp) == EOF) return EOF;
if (fp->_IO_read_ptr < fp->_IO_read_end)
return *(unsigned char*)fp->_IO_read_ptr++;
if (_IO_in_backup(fp))
{
_IO_switch_to_main_get_area(fp);
if (fp->_IO_read_ptr < fp->_IO_read_end)
return *fp->_IO_read_ptr++;
}
if (_IO_have_markers(fp))
{
if (save_for_backup (fp))
return EOF;
}
else if (_IO_have_backup(fp))
_IO_free_backup_area(fp);
return _IO_UFLOW (fp);
}
void
DEFUN(_IO_setb, (f, b, eb, a),
_IO_FILE *f AND char *b AND char *eb AND int a)
{
if (f->_IO_buf_base && !(f->_flags & _IO_USER_BUF))
#ifdef __linux__
FREE_BUF(f->_IO_buf_base, _IO_blen(f));
#else
FREE_BUF(f->_IO_buf_base);
#endif
f->_IO_buf_base = b;
f->_IO_buf_end = eb;
if (a)
f->_flags &= ~_IO_USER_BUF;
else
f->_flags |= _IO_USER_BUF;
}
void
DEFUN(_IO_doallocbuf, (fp),
register _IO_FILE *fp)
{
if (fp->_IO_buf_base)
return;
if (!(fp->_flags & _IO_UNBUFFERED))
if (_IO_DOALLOCATE (fp) != EOF)
return;
_IO_setb(fp, fp->_shortbuf, fp->_shortbuf+1, 0);
}
int
DEFUN(_IO_default_underflow, (fp),
_IO_FILE *fp)
{
return EOF;
}
int
DEFUN(_IO_default_uflow, (fp),
_IO_FILE *fp)
{
int ch = _IO_UNDERFLOW (fp);
if (ch == EOF)
return EOF;
return *(unsigned char*)fp->_IO_read_ptr++;
}
_IO_size_t
DEFUN(_IO_default_xsputn, (f, data, n),
register _IO_FILE *f AND const void *data AND _IO_size_t n)
{
register const char *s = (char*) data;
register _IO_size_t more = n;
if (more <= 0)
return 0;
for (;;)
{
_IO_ssize_t count = f->_IO_write_end - f->_IO_write_ptr; /* Space
available. */
if (count > 0)
{
if (count > more)
count = more;
if (count > 20)
{
memcpy(f->_IO_write_ptr, s, count);
s += count;
f->_IO_write_ptr += count;
}
else if (count <= 0)
count = 0;
else
{
register char *p = f->_IO_write_ptr;
register _IO_ssize_t i;
for (i = count; --i >= 0; ) *p++ = *s++;
f->_IO_write_ptr = p;
}
more -= count;
}
if (more == 0 || __overflow(f, (unsigned char)*s++) == EOF)
break;
more--;
}
return n - more;
}
_IO_size_t
DEFUN(_IO_sgetn, (fp, data, n),
_IO_FILE *fp AND void *data AND _IO_size_t n)
{
/* FIXME handle putback buffer here! */
return _IO_XSGETN (fp, data, n);
}
_IO_size_t
DEFUN(_IO_default_xsgetn, (fp, data, n),
_IO_FILE *fp AND void *data AND _IO_size_t n)
{
register _IO_size_t more = n;
register char *s = (char*) data;
for (;;)
{
_IO_ssize_t count = fp->_IO_read_end - fp->_IO_read_ptr; /* Data
available. */
if (count > 0)
{
if (count > more)
count = more;
if (count > 20)
{
memcpy(s, fp->_IO_read_ptr, count);
s += count;
fp->_IO_read_ptr += count;
}
else if (count <= 0)
count = 0;
else
{
register char *p = fp->_IO_read_ptr;
register int i = (int)count;
while (--i >= 0) *s++ = *p++;
fp->_IO_read_ptr = p;
}
more -= count;
}
if (more == 0 || __underflow(fp) == EOF)
break;
}
return n - more;
}
int
DEFUN(_IO_sync, (fp),
register _IO_FILE *fp)
{
return 0;
}
_IO_FILE*
DEFUN(_IO_default_setbuf, (fp, p, len),
register _IO_FILE *fp AND char* p AND _IO_ssize_t len)
{
if (_IO_SYNC (fp) == EOF)
return NULL;
if (p == NULL || len == 0)
{
fp->_flags |= _IO_UNBUFFERED;
_IO_setb(fp, fp->_shortbuf, fp->_shortbuf+1, 0);
}
else
{
fp->_flags &= ~_IO_UNBUFFERED;
_IO_setb(fp, p, p+len, 0);
}
fp->_IO_write_base = fp->_IO_write_ptr = fp->_IO_write_end = 0;
fp->_IO_read_base = fp->_IO_read_ptr = fp->_IO_read_end = 0;
return fp;
}
_IO_pos_t
DEFUN(_IO_default_seekpos, (fp, pos, mode),
_IO_FILE *fp AND _IO_pos_t pos AND int mode)
{
return _IO_SEEKOFF (fp, _IO_pos_as_off(pos), 0, mode);
}
int
DEFUN(_IO_default_doallocate, (fp),
_IO_FILE *fp)
{
char *buf;
ALLOC_BUF(buf, _IO_BUFSIZ, EOF);
_IO_setb(fp, buf, buf+_IO_BUFSIZ, 1);
return 1;
}
void
DEFUN(_IO_init, (fp, flags),
register _IO_FILE *fp AND int flags)
{
fp->_flags = _IO_MAGIC|flags;
fp->_IO_buf_base = NULL;
fp->_IO_buf_end = NULL;
fp->_IO_read_base = NULL;
fp->_IO_read_ptr = NULL;
fp->_IO_read_end = NULL;
fp->_IO_write_base = NULL;
fp->_IO_write_ptr = NULL;
fp->_IO_write_end = NULL;
fp->_chain = NULL; /* Not necessary. */
fp->_IO_save_base = NULL;
fp->_IO_backup_base = NULL;
fp->_IO_save_end = NULL;
fp->_markers = NULL;
fp->_cur_column = 0;
fp->_fileno = -1;
}
int
DEFUN(_IO_default_sync, (fp),
_IO_FILE *fp)
{
return 0;
}
/* The way the C++ classes are mapped into the C functions in the
current implementation, this function can get called twice! */
void
DEFUN(_IO_default_finish, (fp),
_IO_FILE *fp)
{
struct _IO_marker *mark;
if (fp->_IO_buf_base && !(fp->_flags & _IO_USER_BUF))
{
#ifdef __linux__
FREE_BUF(fp->_IO_buf_base, _IO_blen(fp));
#else
FREE_BUF(fp->_IO_buf_base);
#endif
fp->_IO_buf_base = fp->_IO_buf_end = NULL;
}
for (mark = fp->_markers; mark != NULL; mark = mark->_next)
mark->_sbuf = NULL;
if (fp->_IO_save_base)
{
free (fp->_IO_save_base);
fp->_IO_save_base = NULL;
}
_IO_un_link(fp);
}
_IO_pos_t
DEFUN(_IO_default_seekoff, (fp, offset, dir, mode),
register _IO_FILE *fp AND _IO_off_t offset AND int dir AND int mode)
{
return _IO_pos_BAD;
}
int
DEFUN(_IO_sputbackc, (fp, c),
register _IO_FILE *fp AND int c)
{
int result;
if (fp->_IO_read_ptr > fp->_IO_read_base
&& (unsigned char)fp->_IO_read_ptr[-1] == (unsigned char)c)
{
fp->_IO_read_ptr--;
result = (unsigned char)c;
}
else
result = _IO_PBACKFAIL (fp, c);
if (result != EOF)
fp->_flags &= ~_IO_EOF_SEEN;
return result;
}
int
DEFUN(_IO_sungetc, (fp),
register _IO_FILE *fp)
{
int result;
if (fp->_IO_read_ptr > fp->_IO_read_base)
{
fp->_IO_read_ptr--;
result = (unsigned char)*fp->_IO_read_ptr;
}
else
result = _IO_PBACKFAIL (fp, EOF);
if (result != EOF)
fp->_flags &= ~_IO_EOF_SEEN;
return result;
}
#if 0 /* Work in progress */
void
DEFUN(_IO_set_column, (fp, c),
register _IO_FILE *fp AND int c)
{
if (c == -1)
fp->_column = -1;
else
fp->_column = c - (fp->_IO_write_ptr - fp->_IO_write_base);
}
#else
int
DEFUN(_IO_set_column, (fp, i),
register _IO_FILE *fp AND int i)
{
fp->_cur_column = i+1;
return 0;
}
#endif
unsigned
DEFUN(_IO_adjust_column, (start, line, count),
unsigned start AND const char *line AND int count)
{
register const char *ptr = line + count;
while (ptr > line)
if (*--ptr == '\n')
return line + count - ptr - 1;
return start + count;
}
int
DEFUN(_IO_get_column, (fp),
register _IO_FILE *fp)
{
if (fp->_cur_column)
return _IO_adjust_column(fp->_cur_column - 1,
fp->_IO_write_base,
fp->_IO_write_ptr - fp->_IO_write_base);
return -1;
}
int
DEFUN_VOID(_IO_flush_all)
{
int result = 0;
_IO_FILE *fp;
for (fp = _IO_list_all; fp != NULL; fp = fp->_chain)
if (fp->_IO_write_ptr > fp->_IO_write_base
&& _IO_OVERFLOW (fp, EOF) == EOF)
result = EOF;
return result;
}
void
DEFUN_VOID(_IO_flush_all_linebuffered)
{
_IO_FILE *fp;
for (fp = _IO_list_all; fp != NULL; fp = fp->_chain)
if ((fp->_flags & _IO_NO_WRITES) == 0 && fp->_flags & _IO_LINE_BUF)
_IO_OVERFLOW (fp, EOF);
}
void
DEFUN_VOID(_IO_unbuffer_all)
{
_IO_FILE *fp;
for (fp = _IO_list_all; fp != NULL; fp = fp->_chain)
if (! (fp->_flags & _IO_UNBUFFERED))
_IO_SETBUF (fp, NULL, 0);
}
void
DEFUN_VOID(_IO_cleanup)
{
__libc_lock_lock (__libc_libio_lock);
_IO_flush_all ();
/* We currently don't have a reliable mechanism for making sure that
C++ static destructors are executed in the correct order.
So it is possible that other static destructord might want to
write to cout - and they're supposed to be able to do so.
The following will make the standard streambufs be unbuffered,
which forces any output from late destructors to be written out. */
_IO_unbuffer_all ();
__libc_lock_unlock (__libc_libio_lock);
}
void
DEFUN(_IO_init_marker, (marker, fp),
struct _IO_marker *marker AND _IO_FILE *fp)
{
marker->_sbuf = fp;
if (_IO_in_put_mode(fp))
_IO_switch_to_get_mode(fp);
if (_IO_in_backup(fp))
marker->_pos = fp->_IO_read_ptr - fp->_IO_read_end;
else
marker->_pos = fp->_IO_read_ptr - fp->_IO_read_base;
/* Should perhaps sort the chain? */
marker->_next = fp->_markers;
fp->_markers = marker;
}
void
DEFUN(_IO_remove_marker, (marker),
register struct _IO_marker *marker)
{
/* Unlink from sb's chain. */
register struct _IO_marker **ptr = &marker->_sbuf->_markers;
for (; ; ptr = &(*ptr)->_next)
{
if (*ptr == NULL)
break;
else if (*ptr == marker)
{
*ptr = marker->_next;
return;
}
}
#if 0
if _sbuf has a backup area that is no longer needed, should we delete
it now, or wait until the next underflow?
#endif
}
#define BAD_DELTA EOF
int
DEFUN(_IO_marker_difference, (mark1, mark2),
struct _IO_marker *mark1 AND struct _IO_marker *mark2)
{
return mark1->_pos - mark2->_pos;
}
/* Return difference between MARK and current posistion of MARK's stream. */
int
DEFUN(_IO_marker_delta, (mark),
struct _IO_marker *mark)
{
int cur_pos;
if (mark->_sbuf == NULL)
return BAD_DELTA;
if (_IO_in_backup(mark->_sbuf))
cur_pos = mark->_sbuf->_IO_read_ptr - mark->_sbuf->_IO_read_end;
else
cur_pos = mark->_sbuf->_IO_read_ptr - mark->_sbuf->_IO_read_base;
return mark->_pos - cur_pos;
}
int
DEFUN(_IO_seekmark, (fp, mark, delta),
_IO_FILE *fp AND struct _IO_marker *mark AND int delta)
{
if (mark->_sbuf != fp)
return EOF;
if (mark->_pos >= 0)
{
if (_IO_in_backup(fp))
_IO_switch_to_main_get_area(fp);
fp->_IO_read_ptr = fp->_IO_read_base + mark->_pos;
}
else
{
if (!_IO_in_backup(fp))
_IO_switch_to_backup_area(fp);
fp->_IO_read_ptr = fp->_IO_read_end + mark->_pos;
}
return 0;
}
void
DEFUN(_IO_unsave_markers, (fp),
register _IO_FILE *fp)
{
register struct _IO_marker *mark = fp->_markers;
if (mark)
{
#ifdef TODO
streampos offset = seekoff(0, ios::cur, ios::in);
if (offset != EOF)
{
offset += eGptr() - Gbase();
for ( ; mark != NULL; mark = mark->_next)
mark->set_streampos(mark->_pos + offset);
}
else
{
for ( ; mark != NULL; mark = mark->_next)
mark->set_streampos(EOF);
}
#endif
fp->_markers = 0;
}
if (_IO_have_backup(fp))
_IO_free_backup_area(fp);
}
int
DEFUN(_IO_nobackup_pbackfail, (fp, c),
register _IO_FILE *fp AND int c)
{
if (fp->_IO_read_ptr > fp->_IO_read_base)
fp->_IO_read_ptr--;
if (c != EOF && *fp->_IO_read_ptr != c)
*fp->_IO_read_ptr = c;
return (unsigned char)c;
}
int
DEFUN(_IO_default_pbackfail, (fp, c),
register _IO_FILE *fp AND int c)
{
if (fp->_IO_read_ptr <= fp->_IO_read_base)
{
/* Need to handle a filebuf in write mode (switch to read mode).
FIXME!*/
if (_IO_have_backup(fp) && !_IO_in_backup(fp))
_IO_switch_to_backup_area(fp);
if (!_IO_have_backup(fp))
{
/* No backup buffer: allocate one. */
/* Use nshort buffer, if unused? (probably not) FIXME */
int backup_size = 128;
char *bbuf = (char*)malloc(backup_size);
if (bbuf == NULL)
return EOF;
fp->_IO_save_base = bbuf;
fp->_IO_save_end = fp->_IO_save_base + backup_size;
fp->_IO_backup_base = fp->_IO_save_end;
_IO_switch_to_backup_area(fp);
}
else if (fp->_IO_read_ptr <= fp->_IO_read_base)
{
/* Increase size of existing backup buffer. */
_IO_size_t new_size;
_IO_size_t old_size = fp->_IO_read_end - fp->_IO_read_base;
char *new_buf;
new_size = 2 * old_size;
new_buf = (char*)malloc(new_size);
if (new_buf == NULL)
return EOF;
memcpy(new_buf+(new_size-old_size), fp->_IO_read_base, old_size);
free (fp->_IO_read_base);
_IO_setg(fp,
new_buf, new_buf+(new_size-old_size), new_buf+new_size);
fp->_IO_backup_base = fp->_IO_read_ptr;
}
}
fp->_IO_read_ptr--;
if (c != EOF && *fp->_IO_read_ptr != c)
*fp->_IO_read_ptr = c;
return (unsigned char)*fp->_IO_read_ptr;
}
_IO_pos_t
DEFUN(_IO_default_seek, (fp, offset, dir),
_IO_FILE *fp AND _IO_off_t offset AND int dir)
{
return _IO_pos_BAD;
}
int
DEFUN(_IO_default_stat, (fp, st),
_IO_FILE *fp AND void* st)
{
return EOF;
}
_IO_ssize_t
DEFUN(_IO_default_read, (fp, data, n),
register _IO_FILE* fp AND void* data AND _IO_ssize_t n)
{
return -1;
}
_IO_ssize_t
DEFUN(_IO_default_write, (fp, data, n),
register _IO_FILE* fp AND const void* data AND _IO_ssize_t n)
{
return 0;
}
#ifdef TODO
#if defined(linux)
#define IO_CLEANUP ;
#endif
#ifdef IO_CLEANUP
IO_CLEANUP
#else
struct __io_defs {
__io_defs() { }
~__io_defs() { _IO_cleanup(); }
};
__io_defs io_defs__;
#endif
#endif /* TODO */
#if defined(__ELF__) || defined(__GNU_LIBRARY__)
#include <gnu-stabs.h>
#ifdef weak_alias
weak_alias (_IO_cleanup, _cleanup);
#endif
#endif
/*
Copyright (C) 1991, 1992, 1993, 1994 Free Software Foundation
This file is part of the GNU IO Library. This library is free
software; you can redistribute it and/or modify it under the
terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option)
any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this library; see the file COPYING. If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
As a special exception, if you link this library with files
compiled with a GNU compiler to produce an executable, this does not cause
the resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why
the executable file might be covered by the GNU General Public License. */
/* This is part of the iostream library. Written by Per Bothner. */
#ifndef _IO_STDIO_H
#define _IO_STDIO_H
#include <_G_config.h>
#define _IO_pos_t _G_fpos_t /* obsolete */
#define _IO_fpos_t _G_fpos_t
#define _IO_size_t _G_size_t
#define _IO_ssize_t _G_ssize_t
#define _IO_off_t _G_off_t
#define _IO_pid_t _G_pid_t
#define _IO_uid_t _G_uid_t
#define _IO_HAVE_SYS_WAIT _G_HAVE_SYS_WAIT
#define _IO_HAVE_ST_BLKSIZE _G_HAVE_ST_BLKSIZE
#define _IO_BUFSIZ _G_BUFSIZ
#define _IO_va_list _G_va_list
#ifdef _G_NEED_STDARG_H
/* This define avoids name pollution if we're using GNU stdarg.h */
#define __need___va_list
#include <stdarg.h>
#ifdef __GNUC_VA_LIST
#undef _IO_va_list
#define _IO_va_list __gnuc_va_list
#endif /* __GNUC_VA_LIST */
#endif
#ifndef __P
#if _G_HAVE_SYS_CDEFS
#include <sys/cdefs.h>
#else
#ifdef __STDC__
#define __P(protos) protos
#else
#define __P(protos) ()
#endif
#endif
#endif /*!__P*/
/* For backward compatibility */
#ifndef _PARAMS
#define _PARAMS(protos) __P(protos)
#endif /*!_PARAMS*/
#ifndef __STDC__
#define const
#endif
#ifndef __linux__
#define _IO_USE_DTOA
#endif
#define _IO_UNIFIED_JUMPTABLES 1
#if 0
#ifdef _IO_NEED_STDARG_H
#include <stdarg.h>
#endif
#endif
#ifndef EOF
#define EOF (-1)
#endif
#ifndef NULL
#if !defined(__cplusplus) || defined(__GNUC__)
#define NULL ((void*)0)
#else
#define NULL (0)
#endif
#endif
#define _IOS_INPUT 1
#define _IOS_OUTPUT 2
#define _IOS_ATEND 4
#define _IOS_APPEND 8
#define _IOS_TRUNC 16
#define _IOS_NOCREATE 32
#define _IOS_NOREPLACE 64
#define _IOS_BIN 128
/* Magic numbers and bits for the _flags field.
The magic numbers use the high-order bits of _flags;
the remaining bits are abailable for variable flags.
Note: The magic numbers must all be negative if stdio
emulation is desired. */
#define _IO_MAGIC 0xFBAD0000 /* Magic number */
#define _OLD_STDIO_MAGIC 0xFABC0000 /* Emulate old stdio. */
#define _IO_MAGIC_MASK 0xFFFF0000
#define _IO_USER_BUF 1 /* User owns buffer; don't delete it on close. */
#define _IO_UNBUFFERED 2
#define _IO_NO_READS 4 /* Reading not allowed */
#define _IO_NO_WRITES 8 /* Writing not allowd */
#define _IO_EOF_SEEN 0x10
#define _IO_ERR_SEEN 0x20
#define _IO_DELETE_DONT_CLOSE 0x40 /* Don't call close(_fileno) on cleanup. */
#define _IO_LINKED 0x80 /* Set if linked (using _chain) to
streambuf::_list_all.*/
#define _IO_IN_BACKUP 0x100
#define _IO_LINE_BUF 0x200
#define _IO_TIED_PUT_GET 0x400 /* Set if put and get pointer logicly tied. */
#define _IO_CURRENTLY_PUTTING 0x800
#define _IO_IS_APPENDING 0x1000
#define _IO_IS_FILEBUF 0x2000
/* These are "formatting flags" matching the iostream fmtflags enum values. */
#define _IO_SKIPWS 01
#define _IO_LEFT 02
#define _IO_RIGHT 04
#define _IO_INTERNAL 010
#define _IO_DEC 020
#define _IO_OCT 040
#define _IO_HEX 0100
#define _IO_SHOWBASE 0200
#define _IO_SHOWPOINT 0400
#define _IO_UPPERCASE 01000
#define _IO_SHOWPOS 02000
#define _IO_SCIENTIFIC 04000
#define _IO_FIXED 010000
#define _IO_UNITBUF 020000
#define _IO_STDIO 040000
#define _IO_DONT_CLOSE 0100000
/* The reentrent version of the libio implementation needs a semaphore for
each _IO_FILE struture. Because we don't know how the semaphore
will be implemented we try to be very general. */
struct _IO_lock_t {
void *ptr;
short int field1;
short int field2;
};
/* A streammarker remembers a position in a buffer. */
struct _IO_jump_t; struct _IO_FILE;
struct _IO_marker {
struct _IO_marker *_next;
struct _IO_FILE *_sbuf;
/* If _pos >= 0
it points to _buf->Gbase()+_pos. FIXME comment */
/* if _pos < 0, it points to _buf->eBptr()+_pos. FIXME comment */
int _pos;
#if 0
void set_streampos(streampos sp) { _spos = sp; }
void set_offset(int offset) { _pos = offset; _spos = (streampos)(-2); }
public:
streammarker(streambuf *sb);
~streammarker();
int saving() { return _spos == -2; }
int delta(streammarker&);
int delta();
#endif
};
#define _IO_file_flags _flags
struct _IO_FILE {
#ifdef __SVR4_I386_ABI_L1__
/* The following pointers correspond to the C++ streambuf protocol. */
/* Note: Tk uses the _IO_read_ptr and _IO_read_end fields directly. */
char* _IO_read_ptr; /* Current read pointer */
char* _IO_read_end; /* End of get area. */
char* _IO_read_base; /* Start of putback+get area. */
int _flags; /* High-order word is _IO_MAGIC; rest is flags. */
#else
int _flags; /* High-order word is _IO_MAGIC; rest is flags. */
/* The following pointers correspond to the C++ streambuf protocol. */
char* _IO_read_ptr; /* Current read pointer */
char* _IO_read_end; /* End of get area. */
char* _IO_read_base; /* Start of putback+get area. */
#endif
char* _IO_write_base; /* Start of put area. */
char* _IO_write_ptr; /* Current put pointer. */
char* _IO_write_end; /* End of put area. */
char* _IO_buf_base; /* Start of reserve area. */
char* _IO_buf_end; /* End of reserve area. */
/* The following fields are used to support backing up and undo. */
char *_IO_save_base; /* Pointer to start of non-current get area. */
char *_IO_backup_base; /* Pointer to first valid character of backup area */
char *_IO_save_end; /* Pointer to end of non-current get area. */
struct _IO_marker *_markers;
struct _IO_FILE *_chain;
int _fileno;
int _blksize;
_IO_off_t _offset;
#define __HAVE_COLUMN /* temporary */
/* 1+column number of pbase(); 0 is unknown. */
unsigned short _cur_column;
char _unused;
char _shortbuf[1];
/* char* _save_gptr; char* _save_egptr; */
struct _IO_lock_t _IO_lock;
};
#ifndef __cplusplus
typedef struct _IO_FILE _IO_FILE;
#endif
struct _IO_FILE_plus;
extern struct _IO_FILE_plus _IO_stdin_, _IO_stdout_, _IO_stderr_;
#define _IO_stdin ((_IO_FILE*)(&_IO_stdin_))
#define _IO_stdout ((_IO_FILE*)(&_IO_stdout_))
#define _IO_stderr ((_IO_FILE*)(&_IO_stderr_))
#ifdef __cplusplus
extern "C" {
#endif
extern int __underflow __P((_IO_FILE*));
extern int __uflow __P((_IO_FILE*));
extern int __overflow __P((_IO_FILE*, int));
#define _IO_getc(_fp) \
((_fp)->_IO_read_ptr >= (_fp)->_IO_read_end ? __uflow(_fp) \
: *(unsigned char*)(_fp)->_IO_read_ptr++)
#define _IO_peekc(_fp) \
((_fp)->_IO_read_ptr >= (_fp)->_IO_read_end \
&& __underflow(_fp) == EOF ? EOF \
: *(unsigned char*)(_fp)->_IO_read_ptr)
#define _IO_putc(_ch, _fp) \
(((_fp)->_IO_write_ptr >= (_fp)->_IO_write_end) \
? __overflow(_fp, (unsigned char)(_ch)) \
: (unsigned char)(*(_fp)->_IO_write_ptr++ = (_ch)))
#define _IO_feof(__fp) (((__fp)->_flags & _IO_EOF_SEEN) != 0)
#define _IO_ferror(__fp) (((__fp)->_flags & _IO_ERR_SEEN) != 0)
/* This one is for Emacs. */
#define _IO_PENDING_OUTPUT_COUNT(_fp) \
((_fp)->_IO_write_ptr - (_fp)->_IO_write_base)
extern int _IO_vfscanf __P((_IO_FILE*, const char*, _IO_va_list, int*));
extern int _IO_vfprintf __P((_IO_FILE*, const char*, _IO_va_list));
extern _IO_ssize_t _IO_padn __P((_IO_FILE *, int, _IO_ssize_t));
extern _IO_size_t _IO_sgetn __P((_IO_FILE *, void*, _IO_size_t));
extern _IO_fpos_t _IO_seekoff __P((_IO_FILE*, _IO_off_t, int, int));
extern _IO_fpos_t _IO_seekpos __P((_IO_FILE*, _IO_fpos_t, int));
extern void _IO_free_backup_area __P((_IO_FILE*));
#ifdef __cplusplus
}
#endif
#endif /* _IO_STDIO_H */
