path: root/libc/stdio/stdio.c

/*  Copyright (C) 2002     Manuel Novoa III
 *  My stdio library for linux and (soon) elks.
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Library General Public
 *  License as published by the Free Software Foundation; either
 *  version 2 of the License, 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
 *  Library General Public License for more details.
 *
 *  You should have received a copy of the GNU Library General Public
 *  License along with this library; if not, write to the Free
 *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

/*  ATTENTION!   ATTENTION!   ATTENTION!   ATTENTION!   ATTENTION!
 *
 *  This code is currently under development.  Also, I plan to port
 *  it to elks which is a 16-bit environment with a fairly limited
 *  compiler.  Therefore, please refrain from modifying this code
 *  and, instead, pass any bug-fixes, etc. to me.  Thanks.  Manuel
 *
 *  ATTENTION!   ATTENTION!   ATTENTION!   ATTENTION!   ATTENTION! */

/* Before we include anything, convert L_ctermid to L_ctermid_function
 * and undef L_ctermid if defined.  This is necessary as L_ctermid is
 * a SUSv3 standard macro defined in stdio.h. */
#ifdef L_ctermid
#define L_ctermid_function
#undef L_ctermid
#endif

#define _ISOC99_SOURCE			/* for ULLONG primarily... */
#define _GNU_SOURCE
#define _STDIO_UTILITY			/* for _stdio_fdout and _uintmaxtostr. */
#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <stdint.h>
#include <stdarg.h>
#include <errno.h>
#include <assert.h>
#include <stdio_ext.h>
#include <unistd.h>
#include <fcntl.h>

#ifndef O_LARGEFILE		/* uClibc undefines this if no large file support. */
#ifdef __STDIO_LARGE_FILES
#error missing define for O_LARGEFILE!
#endif
#define O_LARGEFILE		0
#endif

/**********************************************************************/
/* First deal with some build issues... */

#ifndef __STDIO_THREADSAFE
/* Just build empty object files if any of these were defined. */
/* Note though that we do keep the various *_unlocked names as aliases. */
#undef L___fsetlocking
#undef L___flockfile
#undef L___ftrylockfile
#undef L___funlockfile
#endif

#ifndef __STDIO_LARGE_FILES
/* Just build empty object files if any of these were defined. */
#undef L_fopen64
#undef L_freopen64
#undef L_ftello64
#undef L_fseeko64
#undef L_fsetpos64
#undef L_fgetpos64
#endif

/**********************************************************************/

#ifndef __STDIO_THREADSAFE

#ifdef __BCC__
#define UNLOCKED_STREAM(RETURNTYPE,NAME,PARAMS,ARGS,STREAM) \
asm(".text\nexport _" "NAME" "_unlocked\n_" "NAME" "_unlocked = _" "NAME"); \
RETURNTYPE NAME PARAMS
#else
#define UNLOCKED_STREAM(RETURNTYPE,NAME,PARAMS,ARGS,STREAM) \
strong_alias(NAME,NAME##_unlocked) \
RETURNTYPE NAME PARAMS
#endif

#define UNLOCKED(RETURNTYPE,NAME,PARAMS,ARGS) \
	UNLOCKED_STREAM(RETURNTYPE,NAME,PARAMS,ARGS,stream)

#ifdef __BCC__
#define UNLOCKED_VOID_RETURN(NAME,PARAMS,ARGS) \
asm(".text\nexport _" "NAME" "_unlocked\n_" "NAME" "_unlocked = _" "NAME"); \
void NAME PARAMS
#else
#define UNLOCKED_VOID_RETURN(NAME,PARAMS,ARGS) \
strong_alias(NAME,NAME##_unlocked) \
void NAME PARAMS
#endif

#define __STDIO_THREADLOCK_OPENLIST
#define __STDIO_THREADUNLOCK_OPENLIST

#else  /* __STDIO_THREADSAFE */

#include <pthread.h>

#define UNLOCKED_STREAM(RETURNTYPE,NAME,PARAMS,ARGS,STREAM) \
RETURNTYPE NAME PARAMS \
{ \
	RETURNTYPE retval; \
	__STDIO_THREADLOCK(STREAM); \
	retval = NAME##_unlocked ARGS ; \
	__STDIO_THREADUNLOCK(STREAM); \
	return retval; \
} \
RETURNTYPE NAME##_unlocked PARAMS

#define UNLOCKED(RETURNTYPE,NAME,PARAMS,ARGS) \
	UNLOCKED_STREAM(RETURNTYPE,NAME,PARAMS,ARGS,stream)

#define UNLOCKED_VOID_RETURN(NAME,PARAMS,ARGS) \
void NAME PARAMS \
{ \
	__STDIO_THREADLOCK(stream); \
	NAME##_unlocked ARGS ; \
	__STDIO_THREADUNLOCK(stream); \
} \
void NAME##_unlocked PARAMS

#define __STDIO_THREADLOCK_OPENLIST \
	pthread_mutex_lock(&_stdio_openlist_lock)

#define __STDIO_THREADUNLOCK_OPENLIST \
	pthread_mutex_unlock(&_stdio_openlist_lock)

#define __STDIO_THREADTRYLOCK_OPENLIST \
	pthread_mutex_trylock(&_stdio_openlist_lock)

#endif /* __STDIO_THREADSAFE */

/**********************************************************************/

#ifdef __STDIO_WIDE
#define __STDIO_FILE_INIT_UNGOT		{ 0, 0 }, { 0, 0 },
#else
#define __STDIO_FILE_INIT_UNGOT		{ 0, 0 },
#endif

#ifdef __STDIO_GETC_MACRO
#define __STDIO_FILE_INIT_BUFGETC(x) x,
#else
#define __STDIO_FILE_INIT_BUFGETC(x)
#endif

#ifdef __STDIO_PUTC_MACRO
#define __STDIO_FILE_INIT_BUFPUTC(x) x,
#else
#define __STDIO_FILE_INIT_BUFPUTC(x)
#endif

#if defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS)
#define __STDIO_FILE_INIT_NEXT(next)	(next),
#else  /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */
#define __STDIO_FILE_INIT_NEXT(next)
#endif /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */

#ifdef __STDIO_BUFFERS
#define __STDIO_FILE_INIT_BUFFERS(buf,bufsize) \
	(buf), (buf)+(bufsize), (buf), (buf),
#else
#define __STDIO_FILE_INIT_BUFFERS(buf,bufsize)
#endif

#ifdef __STDIO_GLIBC_CUSTOM_STREAMS
#define __STDIO_FILE_INIT_CUSTOM_STREAM(stream) \
	&((stream).filedes), { _cs_read, _cs_write, NULL, _cs_close },
#else
#define __STDIO_FILE_INIT_CUSTOM_STREAM(stream)
#endif

#ifdef __STDIO_MBSTATE
#define __STDIO_FILE_INIT_MBSTATE \
	{ 0, 0 },
#else
#define __STDIO_FILE_INIT_MBSTATE
#endif


#ifdef __STDIO_THREADSAFE
#define __STDIO_FILE_INIT_THREADSAFE \
	0, PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP,
#else
#define __STDIO_FILE_INIT_THREADSAFE
#endif

#define __STDIO_INIT_FILE_STRUCT(stream, flags, filedes, next, buf, bufsize) \
	{ (flags), \
	__STDIO_FILE_INIT_UNGOT \
	(filedes), \
	__STDIO_FILE_INIT_NEXT(next) \
	__STDIO_FILE_INIT_BUFFERS(buf,bufsize) \
	__STDIO_FILE_INIT_BUFGETC((buf)) \
	__STDIO_FILE_INIT_BUFPUTC((buf)) \
	__STDIO_FILE_INIT_CUSTOM_STREAM(stream) \
	__STDIO_FILE_INIT_MBSTATE \
	__STDIO_FILE_INIT_THREADSAFE \
} /* TODO: mbstate and builtin buf */

#ifdef __STDIO_GLIBC_CUSTOM_STREAMS

/* TODO -- what does glibc do for undefined funcs?  errno set? */
#define __READ(STREAMPTR,BUF,SIZE) \
	((((STREAMPTR)->gcs.read) == NULL) ? -1 : \
	(((STREAMPTR)->gcs.read)((STREAMPTR)->cookie,(BUF),(SIZE))))
#define __WRITE(STREAMPTR,BUF,SIZE) \
	((((STREAMPTR)->gcs.write) == NULL) ? -1 : \
	(((STREAMPTR)->gcs.write)((STREAMPTR)->cookie,(BUF),(SIZE))))
#define __CLOSE(STREAMPTR) \
	((((STREAMPTR)->gcs.close) == NULL) ? 0 : \
	(((STREAMPTR)->gcs.close)((STREAMPTR)->cookie)))

#else  /* __STDIO_GLIBC_CUSTOM_STREAMS */

#define __READ(STREAMPTR,BUF,SIZE) \
	(read((STREAMPTR)->filedes,(BUF),(SIZE)))
#define __WRITE(STREAMPTR,BUF,SIZE) \
	(write((STREAMPTR)->filedes,(BUF),(SIZE)))
#define __CLOSE(STREAMPTR) \
	(close((STREAMPTR)->filedes))

#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */

/**********************************************************************/
/* POSIX functions */
/**********************************************************************/
#ifdef L_getw

/* SUSv2 Legacy function -- need not be reentrant. */

int getw(FILE *stream)
{
	int aw[1];

#ifdef __STDIO_WIDE

	return (fread((void *)aw, sizeof(int), 1, stream) > 0) ? (*aw) : EOF;

#else  /* __STDIO_WIDE */

	return (_stdio_fread((unsigned char *)(aw), sizeof(int), stream)
			== sizeof(int)) ? (*aw) : EOF;

#endif /* __STDIO_WIDE */
}

#endif
/**********************************************************************/
#ifdef L_putw

/* SUSv2 Legacy function -- need not be reentrant. */

int putw(int w, FILE *stream)
{
	int aw[1];

	*aw = w;					/* In case 'w' is in a register... */

#ifdef __STDIO_WIDE

	return (fwrite((void *)aw, sizeof(int), 1, stream) == 1) ? 0 : EOF;

#else  /* __STDIO_WIDE */

	return (_stdio_fwrite((unsigned char *)aw, sizeof(int), stream)
			== sizeof(int)) ? 0 : EOF;

#endif /* __STDIO_WIDE */
}

#endif
/**********************************************************************/
#ifdef L_fileno

/* Reentrancy handled by UNLOCKED() macro. */

UNLOCKED(int,fileno,(register FILE *stream),(stream))
{
#ifdef __STDIO_GLIBC_CUSTOM_STREAMS
	return ( ((stream->cookie == &(stream->filedes)) && (stream->filedes >= 0))
			 ? stream->filedes
			 : (__set_errno(EBADF), -1) );
#else  /* __STDIO_GLIBC_CUSTOM_STREAMS */
	return (stream->filedes >= 0) ? stream->filedes : (__set_errno(EBADF), -1);
#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */
}

#endif
/**********************************************************************/
#ifdef L_fdopen

/* No reentrancy issues. */

FILE *fdopen(int filedes, const char *mode)
{
	register char *cur_mode;	/* TODO -- replace by intptr_t?? */

	return (((int)(cur_mode = (char *) fcntl(filedes, F_GETFL))) != -1)
		? _stdio_fopen(cur_mode, mode, NULL, filedes) 
		: NULL;
}

#endif
/**********************************************************************/
#ifdef L_fopen64

/* No reentrancy issues. */

FILE *fopen64(const char * __restrict filename, const char * __restrict mode)
{
	return _stdio_fopen(filename, mode, NULL, -2);
}

#endif
/**********************************************************************/
#ifdef L_ctermid_function

/* Not required to be reentrant. */

char *ctermid(register char *s)
{
	static char sbuf[L_ctermid];

#ifdef __BCC__
	/* Currently elks doesn't support /dev/tty. */
	if (!s) {
		s = sbuf;
	}
	*s = 0;

	return s;
#else
	/* glibc always returns /dev/tty for linux. */
	return strcpy((s ? s : sbuf), "/dev/tty");
#endif
}

#endif
/**********************************************************************/
/* BSD functions */
/**********************************************************************/
#ifdef L_setbuffer

/* No reentrancy issues. */

void setbuffer(FILE * __restrict stream, register char * __restrict buf,
			   size_t size)
{
#ifdef __STDIO_BUFFERS
	setvbuf(stream, buf, (buf ? _IOFBF : _IONBF), size);
#else  /* __STDIO_BUFFERS */
	/* Nothing to do. */
#endif /* __STDIO_BUFFERS */
}

#endif
/**********************************************************************/
#ifdef L_setlinebuf

/* No reentrancy issues. */

void setlinebuf(FILE * __restrict stream)
{
#ifdef __STDIO_BUFFERS
	setvbuf(stream, NULL, _IOLBF, (size_t) 0);
#else  /* __STDIO_BUFFERS */
	/* Nothing to do. */
#endif /* __STDIO_BUFFERS */
}

#endif
/**********************************************************************/
/* GLIBC functions */
/**********************************************************************/
#ifdef L_fcloseall

/* NOTE: GLIBC difference!!! -- fcloseall
 * According to the info pages, glibc actually fclose()s all open files.
 * Apparently, glibc's new version only fflush()s and unbuffers all
 * writing streams to cope with unordered destruction of c++ static
 * objects.  Here we implement the old behavior as default.
 */

/* Not reentrant. */

int fcloseall (void)
{
#if defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS)
	register FILE *stream;
	int rv;

	_stdio_term();				/* Let _stdio_term() do all the work. */

	rv = 0;
	for (stream = _stdio_openlist ; stream ; stream = stream->nextopen) {
		if (stream->modeflags & (__FLAG_WRITING|__FLAG_ERROR)) {
			/* TODO -- is this correct?  Maybe ferror set before flush...
			* could check if pending writable but what if term unbuffers?
			* in that case, could clear error flag... */
			rv = EOF;			/* Only care about failed writes. */
		}
	}

	/* Make sure _stdio_term() does nothing on exit. */
	_stdio_openlist = NULL;

	return rv;
#else  /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */

	return 0;

#endif /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */
}

#endif
/**********************************************************************/
#ifdef L_fmemopen
#ifdef __STDIO_GLIBC_CUSTOM_STREAMS

typedef struct {
	size_t pos;
	size_t len;
	size_t eof;
	int dynbuf;
	unsigned char *buf;
	FILE *fp;
} __fmo_cookie;

#define COOKIE ((__fmo_cookie *) cookie)

static ssize_t fmo_read(register void *cookie, char *buf, size_t bufsize)
{
	size_t count = COOKIE->len - COOKIE->pos;

	/* Note: bufsize < SSIZE_MAX because of _stdio_READ. */

	if (bufsize > count) {
		bufsize = count;
	}

#if 1							/* TODO - choose code option */
	memcpy(buf, COOKIE->buf + COOKIE->pos, bufsize);
	COOKIE->pos += bufsize;
#else
	{
		register char *p = COOKIE->buf + COOKIE->pos;

		count = bufsize;
		while (count) {
			*buf++ = *p++;
			--count;
		}
		COOKIE->pos += bufsize;
	}
#endif

	return bufsize;
}

static ssize_t fmo_write(register void *cookie, const char *buf, size_t bufsize)
{
	size_t count;

	/* Note: bufsize < SSIZE_MAX because of _stdio_WRITE. */

	/* If appending, need to seek to end of file!!!! */
	if (COOKIE->fp->modeflags & __FLAG_APPEND) {
		COOKIE->pos = COOKIE->eof;
	}

	count = COOKIE->len - COOKIE->pos;

	if (bufsize > count) {
		bufsize = count;
		if (count == 0) {		/* We're at the end of the buffer... */
			__set_errno(EFBIG);
			return -1;
		}
	}

#if 1							/* TODO - choose code option */
	memcpy(COOKIE->buf + COOKIE->pos, buf, bufsize);
	COOKIE->pos += bufsize;

	if (COOKIE->pos > COOKIE->eof) {
		COOKIE->eof = COOKIE->pos;
		if (bufsize < count) {	/* New eof and still room in buffer? */
			*(COOKIE->buf + COOKIE->pos) = 0;
		}
	}

#else
	{
		register char *p = COOKIE->buf + COOKIE->pos;
		size_t i = bufsize;

		while (i > 0) {
			*p++ = *buf++;
			--i;
		}
		COOKIE->pos += bufsize;

		if (COOKIE->pos > COOKIE->eof) {
			COOKIE->eof = COOKIE->pos;
			if (bufsize < count) {	/* New eof and still room in buffer? */
				*p = 0;
			}
		}
	}

#endif

	return bufsize;
}

/* glibc doesn't allow seeking, but it has in-buffer seeks... we don't. */
static int fmo_seek(register void *cookie, __offmax_t *pos, int whence)
{
	__offmax_t p = *pos;

	/* Note: fseek already checks that whence is legal, so don't check here
	 * unless debugging. */
	assert(((unsigned int) whence) <= 2);

	if (whence != SEEK_SET) {
		p += (whence == SEEK_CUR) ? COOKIE->pos : /* SEEK_END */ COOKIE->eof;
	}

	/* Note: glibc only allows seeking in the buffer.  We'll actually restrict
	 * to the data. */
	/* Check for offset < 0, offset > eof, or offset overflow... */
	if (((uintmax_t) p) > COOKIE->eof) {
		return -1;
	}

	COOKIE->pos = *pos = p;
	return 0;
}

static int fmo_close(register void *cookie)
{
	if (COOKIE->dynbuf) {
		free(COOKIE->buf);
	}
	free(cookie);
	return 0;
}

#undef COOKIE

static const cookie_io_functions_t _fmo_io_funcs = {
	fmo_read, fmo_write, fmo_seek, fmo_close
};

/* TODO: If we have buffers enabled, it might be worthwile to add a pointer
 * to the FILE in the cookie and have read, write, and seek operate directly
 * on the buffer itself (ie replace the FILE buffer with the cookie buffer
 * and update FILE bufstart, etc. whenever we seek). */

FILE *fmemopen(void *s, size_t len, const char *modes)
{
	FILE *fp;
	register __fmo_cookie *cookie;
	size_t i;

	if ((cookie = malloc(sizeof(__fmo_cookie))) != NULL) {
		cookie->len = len;
		cookie->eof = cookie->pos = 0; /* pos and eof adjusted below. */
		cookie->dynbuf = 0;
		if (((cookie->buf = s) == NULL) && (len > 0)) {
			if ((cookie->buf = malloc(len)) == NULL) {
				goto EXIT_cookie;
			}
			cookie->dynbuf = 1;
			*cookie->buf = 0;	/* If we're appending, treat as empty file. */
		}
		
#ifndef __BCC__
		fp = fopencookie(cookie, modes, _fmo_io_funcs);
#else
		fp = fopencookie(cookie, modes, &_fmo_io_funcs);
#endif
		/* Note: We don't need to worry about locking fp in the thread case
		 * as the only possible access would be a close or flush with
		 * nothing currently in the FILE's write buffer. */

		if (fp != NULL) {
			cookie->fp = fp;
			if ((fp->modeflags & __FLAG_APPEND) && (len > 0)) {
				for (i = 0 ; i < len ; i++) {
					if (cookie->buf[i] == 0) {
						break;
					}
				}
				cookie->eof = cookie->pos = i; /* Adjust eof and pos. */
			}
			return fp;
		}
	}

	if (!s) {
		free(cookie->buf);
	}
 EXIT_cookie:
	free(cookie);

	return NULL;
}

#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */
#endif
/**********************************************************************/
#ifdef L_open_memstream
#ifdef __STDIO_GLIBC_CUSTOM_STREAMS

#define COOKIE ((__oms_cookie *) cookie)

typedef struct {
	char *buf;
	size_t len;
	size_t pos;
	size_t eof;
	char **bufloc;
	size_t *sizeloc;
} __oms_cookie;

/* Nothing to do here, as memstreams are write-only. */
/*  static ssize_t oms_read(void *cookie, char *buf, size_t bufsize) */
/*  { */
/*  } */

static ssize_t oms_write(register void *cookie, const char *buf, size_t bufsize)
{
	register char *newbuf;
	size_t count;

	/* Note: we already know bufsize < SSIZE_MAX... */

	count = COOKIE->len - COOKIE->pos - 1;
	assert(COOKIE->pos < COOKIE->len); /* Always nul-terminate! */

	if (bufsize > count) {
		newbuf = realloc(COOKIE->buf, COOKIE->len + bufsize - count);
		if (newbuf) {
			*COOKIE->bufloc = COOKIE->buf = newbuf;
			COOKIE->len += (bufsize - count);
		} else {
			bufsize = count;
			if (count == 0) {
				__set_errno(EFBIG);	/* TODO: check glibc errno setting... */
				return -1;
			}
		}
	}

	memcpy(COOKIE->buf + COOKIE->pos, buf, bufsize);
	COOKIE->pos += bufsize;

	if (COOKIE->pos > COOKIE->eof) {
		*COOKIE->sizeloc = COOKIE->eof = COOKIE->pos;
		COOKIE->buf[COOKIE->eof] = 0; /* Need to nul-terminate. */
	}

	return bufsize;
}

static int oms_seek(register void *cookie, __offmax_t *pos, int whence)
{
	__offmax_t p = *pos;
	register char *buf;
	size_t leastlen;

	/* Note: fseek already checks that whence is legal, so don't check here
	 * unless debugging. */
	assert(((unsigned int) whence) <= 2);

	if (whence != SEEK_SET) {
		p += (whence == SEEK_CUR) ? COOKIE->pos : /* SEEK_END */ COOKIE->eof;
	}

	/* Note: glibc only allows seeking in the buffer.  We'll actually restrict
	 * to the data. */
	/* Check for offset < 0, offset >= too big (need nul), or overflow... */
	if (((uintmax_t) p) >= SIZE_MAX - 1) {
		return -1;
	}

	leastlen = ((size_t) p) + 1; /* New pos + 1 for nul if necessary. */

	if (leastlen >= COOKIE->len) { /* Need to grow buffer... */
		buf = realloc(COOKIE->buf, leastlen);
		if (buf) {
			*COOKIE->bufloc = COOKIE->buf = buf;
			COOKIE->len = leastlen;
			memset(buf + COOKIE->eof, leastlen - COOKIE->eof, 0); /* 0-fill */
		} else {
			/* TODO: check glibc errno setting... */
			return -1;
		}
	}

	*pos = COOKIE->pos = --leastlen;

	if (leastlen > COOKIE->eof) {
		memset(COOKIE->buf + COOKIE->eof, leastlen - COOKIE->eof, 0);
		*COOKIE->sizeloc = COOKIE->eof;
	}

	return 0;
}

static int oms_close(void *cookie)
{
	free(cookie);
	return 0;
}

#undef COOKIE

static const cookie_io_functions_t _oms_io_funcs = {
	NULL, oms_write, oms_seek, oms_close
};

/* TODO: If we have buffers enabled, it might be worthwile to add a pointer
 * to the FILE in the cookie and operate directly on the buffer itself
 * (ie replace the FILE buffer with the cookie buffer and update FILE bufstart,
 * etc. whenever we seek). */

FILE *open_memstream(char **__restrict bufloc, size_t *__restrict sizeloc)
{
	register __oms_cookie *cookie;
	register FILE *fp;

	if ((cookie = malloc(sizeof(__oms_cookie))) != NULL) {
		if ((cookie->buf = malloc(cookie->len = BUFSIZ)) == NULL) {
			goto EXIT_cookie;
		}
		*cookie->buf = 0;		/* Set nul terminator for buffer. */
		*(cookie->bufloc = bufloc) = cookie->buf;
		*(cookie->sizeloc = sizeloc) = cookie->eof = cookie->pos = 0;
		
#ifndef __BCC__
		fp = fopencookie(cookie, "w", _oms_io_funcs);
#else
		fp = fopencookie(cookie, "w", &_oms_io_funcs);
#endif
		/* Note: We don't need to worry about locking fp in the thread case
		 * as the only possible access would be a close or flush with
		 * nothing currently in the FILE's write buffer. */

		if (fp != NULL) {
			return fp;
		}
	}

	if (cookie->buf != NULL) {
		free(cookie->buf);
	}
 EXIT_cookie:
	free(cookie);

	return NULL;
}

#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */
#endif
/**********************************************************************/
#ifdef L_fopencookie
#ifdef __STDIO_GLIBC_CUSTOM_STREAMS

/* NOTE: GLIBC difference!!! -- fopencookie
 * According to the info pages, glibc allows seeking within buffers even if
 * no seek function is supplied.  We don't. */

/* NOTE: GLIBC difference!!! -- fopencookie
 * When compiled without large file support, the offset pointer for the
 * cookie_seek function is off_t * and not off64_t * as for glibc. */

/* TODO: rewrite _stdio_fopen() to avoid the fopencookie() kludge. */

/* Currently no real reentrancy issues other than a possible double close(). */

#ifndef __BCC__

FILE *fopencookie(void * __restrict cookie, const char * __restrict mode,
				  cookie_io_functions_t io_functions)
{
	FILE *stream;
	int fd;

	if ((stream = _stdio_fopen("/dev/null", mode, NULL, -1)) != NULL) {
		fd = stream->filedes;
		stream->filedes = -1;
		close(fd);
		stream->gcs = io_functions;
		stream->cookie = cookie;
	}

#if !defined(__STDIO_BUFFERS) && !defined(__STDIO_THREADSAFE)
	/* I we don't have buffers or threads, we only need to worry about
	 * custom streams on the open list, as no flushing is necessary and
	 * no locking of possible underlying normal streams need be done.
	 * We do need to explicitly close custom streams on termination of stdio,
	 * and we need to lock the list as it can be modified by fclose(). */
	__STDIO_THREADLOCK_OPENLIST;
	stream->nextopen = _stdio_openlist;	/* New files are inserted at */
	_stdio_openlist = stream;			/*   the head of the list. */
	__STDIO_THREADUNLOCK_OPENLIST;
#endif /* !defined(__STDIO_BUFFERS) && !defined(__STDIO_THREADSAFE) */

	return stream;
}

#else  /* __BCC__ */

/* NOTE: GLIBC difference!!! -- fopencookie (bcc only)
 * Since bcc doesn't support passing of structs, we define fopencookie as a
 * macro in terms of _fopencookie which takes a struct * for the io functions
 * instead.
 */

FILE *_fopencookie(void * __restrict cookie, const char * __restrict mode,
				   register cookie_io_functions_t *io_functions)
{
	register FILE *stream;

	if ((stream = _stdio_fopen("/dev/null", mode, NULL, -1)) != NULL) {
		int fd = stream->filedes;
		stream->filedes = -1;
		close(fd);
		stream->gcs.read  = io_functions->read;
		stream->gcs.write = io_functions->write;
		stream->gcs.seek  = io_functions->seek;
		stream->gcs.close = io_functions->close;
		stream->cookie = cookie;
	}

#if !defined(__STDIO_BUFFERS) && !defined(__STDIO_THREADSAFE)
	/* I we don't have buffers or threads, we only need to worry about
	 * custom streams on the open list, as no flushing is necessary and
	 * no locking of possible underlying normal streams need be done.
	 * We do need to explicitly close custom streams on termination of stdio,
	 * and we need to lock the list as it can be modified by fclose(). */
	__STDIO_THREADLOCK_OPENLIST;
	stream->nextopen = _stdio_openlist;	/* New files are inserted at */
	_stdio_openlist = stream;			/*   the head of the list. */
	__STDIO_THREADUNLOCK_OPENLIST;
#endif /* !defined(__STDIO_BUFFERS) && !defined(__STDIO_THREADSAFE) */

	return stream;
}

#endif  /* __BCC__ */

#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */
#endif
/**********************************************************************/
#ifdef L___fbufsize

/* Not reentrant. */

size_t __fbufsize(register FILE * __restrict stream)
{
#ifdef __STDIO_BUFFERS
	return (stream->modeflags & __FLAG_NBF)
		? 0 : (stream->bufend - stream->bufstart);
#else  /* __STDIO_BUFFERS */
	return 0;
#endif /* __STDIO_BUFFERS */
}

#endif
/**********************************************************************/
#ifdef L___freading

/* No reentrancy issues. */

int __freading(FILE * __restrict stream)
{
	return stream->modeflags & (__FLAG_READING|__FLAG_READONLY);
}

#endif
/**********************************************************************/
#ifdef L___fwriting

/* No reentrancy issues. */

int __fwriting(FILE * __restrict stream)
{
	return stream->modeflags & (__FLAG_WRITING|__FLAG_WRITEONLY);
}

#endif
/**********************************************************************/
#ifdef L___freadable

/* No reentrancy issues. */

int __freadable(FILE * __restrict stream)
{
	return ~(stream->modeflags & __FLAG_WRITEONLY);
}

#endif
/**********************************************************************/
#ifdef L___fwritable

/* No reentrancy issues. */

int __fwritable(FILE * __restrict stream)
{
	return ~(stream->modeflags & __FLAG_READONLY);
}

#endif
/**********************************************************************/
#ifdef L___flbf

/* No reentrancy issues. */

int __flbf(FILE * __restrict stream)
{
#ifdef __STDIO_BUFFERS
	return (stream->modeflags & __FLAG_LBF);
#else  /* __STDIO_BUFFERS */
	/* TODO -- Even though there is no buffer, return flag setting? */
	return __FLAG_NBF;
#endif /* __STDIO_BUFFERS */
}

#endif
/**********************************************************************/
#ifdef L___fpurge

/* Not reentrant. */

void __fpurge(register FILE * __restrict stream)
{
#ifdef __STDIO_BUFFERS
#ifdef __STDIO_PUTC_MACRO
	stream->bufputc =			/* Must disable putc. */
#endif /* __STDIO_PUTC_MACRO */
#ifdef __STDIO_GETC_MACRO
	stream->bufgetc =			/* Must disable getc. */
#endif
	stream->bufpos = stream->bufread = stream->bufstart; /* Reset pointers. */
#endif /* __STDIO_BUFFERS */
	/* Reset r/w flags and clear ungots. */
	stream->modeflags &= ~(__FLAG_READING|__FLAG_WRITING|__MASK_UNGOT);
}

#endif
/**********************************************************************/
#ifdef L___fpending

/* Not reentrant. */

#ifdef __STDIO_WIDE
#warning unlike the glibc version, this __fpending returns bytes in buffer for wide streams too!

link_warning(__fpending, "This version of __fpending returns bytes remaining in buffer for both narrow and wide streams.  glibc's version returns wide chars in buffer for the wide stream case.")

#endif  /* __STDIO_WIDE */

size_t __fpending(register FILE * __restrict stream)
{
#ifdef __STDIO_BUFFERS
	/* TODO -- should we check this?  should we set errno?  just assert? */
	return (stream->modeflags & (__FLAG_READING|__FLAG_READONLY))
		? 0 : (stream->bufpos - stream->bufstart);
#else  /* __STDIO_BUFFERS */
	return 0;
#endif /* __STDIO_BUFFERS */
}

#endif
/**********************************************************************/
#ifdef L__flushlbf

/* No reentrancy issues. */

void _flushlbf(void)
{
#ifdef __STDIO_BUFFERS
	fflush((FILE *) &_stdio_openlist); /* Uses an implementation hack!!! */
#else  /* __STDIO_BUFFERS */
	/* Nothing to do. */
#endif /* __STDIO_BUFFERS */
}

#endif
/**********************************************************************/
#ifdef L___fsetlocking

/* No (serious) reentrancy issues -- return value could be incorrect. */
/* TODO -- fix race */

int __fsetlocking(FILE *stream, int locking_mode)
{
	int old_mode;

	assert((FSETLOCKING_QUERY == 0) && (FSETLOCKING_INTERNAL == 1)
		   && (FSETLOCKING_BYCALLER == 2));

	assert(((unsigned int) locking_mode) <= 2);

	/* Note: don't even bother locking here... */

	old_mode  = stream->user_locking;

	if (locking_mode != FSETLOCKING_QUERY) {
		/* In case we're not debugging, treat any unknown as a request to
		 * set internal locking, in order to match glibc behavior. */
		stream->user_locking = ((locking_mode == FSETLOCKING_BYCALLER)
								? FSETLOCKING_BYCALLER
								: FSETLOCKING_INTERNAL);
	}

	return old_mode;
}

#endif
/**********************************************************************/
#ifdef L_flockfile

void flockfile(FILE *stream)
{
#ifdef __STDIO_THREADSAFE
	pthread_mutex_lock(&stream->lock);
#endif
}

#endif
/**********************************************************************/
#ifdef L_ftrylockfile

int ftrylockfile(FILE *stream)
{
#ifdef __STDIO_THREADSAFE
	return pthread_mutex_trylock(&stream->lock);
#else
	return 1;
#endif
}

#endif
/**********************************************************************/
#ifdef L_funlockfile

void funlockfile(FILE *stream)
{
#ifdef __STDIO_THREADSAFE
	pthread_mutex_unlock(&stream->lock);
#endif
}

#endif
/**********************************************************************/
#ifdef L_getline

ssize_t getline(char **__restrict lineptr, size_t *__restrict n,
				FILE *__restrict stream)
{
	return __getdelim(lineptr, n, '\n', stream);
}

#endif
/**********************************************************************/
#ifdef L_getdelim

weak_alias(__getdelim,getdelim);

#define GETDELIM_GROWBY		64

ssize_t __getdelim(char **__restrict lineptr, size_t *__restrict n,
				   int delimiter, register FILE *__restrict stream)
{
	register char *buf;
	size_t pos;
	int c;

	if (!lineptr || !n || !stream) { /* Be compatable with glibc... even */
		__set_errno(EINVAL);	/* though I think we should assert here */
		return -1;				/* if anything. */
	}

	if (!(buf = *lineptr)) {	/* If passed NULL for buffer, */
		*n = 0;					/* ignore value passed and treat size as 0. */
	}
	pos = 1;			/* Make sure we have space for terminating nul. */

	__STDIO_THREADLOCK(stream);

	do {
		if (pos >= *n) {
			if (!(buf = realloc(buf, *n + GETDELIM_GROWBY))) {
				__set_errno(ENOMEM); /* Emulate old uClibc implementation. */
				break;
			}
			*n += GETDELIM_GROWBY;
			*lineptr = buf;
		}
	} while (((c = getc(stream)) != EOF) && ((buf[pos++ - 1] = c) != delimiter));

	__STDIO_THREADUNLOCK(stream);

	if (--pos) {
		buf[pos] = 0;
		return pos;
	}

	return -1;		/* Either initial realloc failed or first read was EOF. */
}

#endif
/**********************************************************************/
/* my extension functions */
/**********************************************************************/
#ifdef L__stdio_fsfopen
/*
 * Stack|Static File open -- open a file where the FILE is either
 * stack or staticly allocated.
 */

/* No reentrancy issues. */

FILE *_stdio_fsfopen(const char * __restrict filename,
					 const char * __restrict mode,
					 register FILE * __restrict stream)
{
#ifdef __STDIO_BUFFERS
	stream->modeflags = __FLAG_FBF;
#if __STDIO_BUILTIN_BUF_SIZE > 0
	stream->bufstart = stream->builtinbuf;
	stream->bufend = stream->builtinbuf + sizeof(stream->builtinbuf);
#else  /* __STDIO_BUILTIN_BUF_SIZE > 0 */
	stream->bufend = stream->bufstart = NULL;
#endif /* __STDIO_BUILTIN_BUF_SIZE > 0 */
#endif /* __STDIO_BUFFERS */

	return _stdio_fopen(filename, mode, stream, -1);
}
#endif
/**********************************************************************/
/* stdio internal functions */
/**********************************************************************/
#ifdef L__stdio_adjpos
/*
 * ANSI/ISO p. 370: The file positioning indicator is unspecified after
 * a successful call to ungetwc.
 * Note however, that this applies only to _user_ calls to ungetwc.  We
 * need to allow for internal calls by scanf.  So we store the byte count
 * of the first ungot wide char in ungot0_bytes.  If it is 0 (user case)
 * then the file position is treated as unknown.
 */

/* Internal function -- not reentrant. */

int _stdio_adjpos(register FILE * __restrict stream, register __offmax_t *pos)
{
	__offmax_t r;
	int cor = stream->modeflags & __MASK_UNGOT;	/* handle ungots */

#ifdef __STDIO_WIDE
	/* Assumed narrow stream so correct if wide. */
	if (cor && (stream->modeflags & __FLAG_WIDE)) {
		cor = cor - 1 + stream->ungot_width[0];
		if (((stream->modeflags & __MASK_UNGOT) > 1) || stream->ungot[1]) {
			return -1; /* App did ungetwc, so position is indeterminate. */
		}
		assert(stream->ungot_width[0] > 0);
	}
#endif /* __STDIO_WIDE */
#ifdef __STDIO_BUFFERS
	if (stream->modeflags & __FLAG_WRITING) {
		cor -= (stream->bufpos - stream->bufstart); /* pending writes */
	}
	if (stream->modeflags & __FLAG_READING) {
		cor += (stream->bufread - stream->bufpos); /* extra's read */
	}
#endif /* __STDIO_BUFFERS */

	r = *pos;
	return ((*pos -= cor) > r) ? -cor : cor;
}

#endif
/**********************************************************************/
#ifdef L__stdio_lseek
/*
 * This function is only called by fseek and ftell.
 * fseek -- doesn't care about pos val, just success or failure.
 * ftell -- needs pos val but offset == 0 and whence == SET_CUR.
 */

/* Internal function -- not reentrant. */

int _stdio_lseek(register FILE *stream, register __offmax_t *pos, int whence)
{
	__offmax_t res;

#ifdef __STDIO_GLIBC_CUSTOM_STREAMS
	if (stream->cookie != &stream->filedes) {
		return (((stream->gcs.seek == NULL)
				 || ((stream->gcs.seek)(stream->cookie, pos, whence) < 0))
				? -1 : 0);
	}
#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */
#ifdef __STDIO_LARGE_FILES
	res = lseek64(stream->filedes, *pos, whence);
#else
	res = lseek(stream->filedes, *pos, whence);
#endif /* __STDIO_LARGE_FILES */
	return (res >= 0) ? ((*pos = res), 0) : -1;
}

#endif
/**********************************************************************/
#ifdef L__stdio_fread
/*
 * NOTE!!! This routine is meant to be callable by both narrow and wide
 * functions.  However, if called by a wide function, there must be
 * NO pending ungetwc()s!!!
 */

/* Unlike write, it's ok for read to return fewer than bufsize, since
 * we may not need all of them. */
static ssize_t _stdio_READ(register FILE *stream, unsigned char *buf, size_t bufsize)
{
	ssize_t rv;

	if (bufsize == 0) {
		return 0;
	}

	if (bufsize > SSIZE_MAX) {
		bufsize = SSIZE_MAX;
	}

#ifdef __BCC__
 TRY_READ:
#endif
	rv = __READ(stream, buf, bufsize);
	if (rv > 0) {
#ifdef __STDIO_GLIBC_CUSTOM_STREAMS
		assert(rv <= bufsize);	/* buggy user handler... TODO: check? */
		if (rv > bufsize) {	/* Num reported written > number requested */
			rv = bufsize;		/* Treat as a full read??? */
		}
#endif
	} else if (rv == 0) {
		stream->modeflags |= __FLAG_EOF;
	} else {
#ifdef __BCC__
		if (errno == EINTR) {
			goto TRY_READ;
		}
#endif
		stream->modeflags |= __FLAG_ERROR;
		rv = 0;
	}

	return rv;
}

/* Internal function -- not reentrant. */

size_t _stdio_fread(unsigned char *buffer, size_t bytes, register FILE *stream)
{
	__stdio_validate_FILE(stream); /* debugging only */

#ifdef __STDIO_BUFFERS

	if (stream->modeflags 
#ifdef __STDIO_AUTO_RW_TRANSITION
		& (__FLAG_WRITEONLY)
#else  /* __STDIO_AUTO_RW_TRANSITION */
		/* ANSI/ISO and SUSv3 require not currently writing. */
		& (__FLAG_WRITEONLY|__FLAG_WRITING)
#endif /* __STDIO_AUTO_RW_TRANSITION */
		) {
#ifdef __STDIO_PUTC_MACRO
		stream->bufputc = stream->bufstart;	/* Must disable putc. */
#endif /* __STDIO_PUTC_MACRO */
		stream->modeflags |= __FLAG_ERROR;
		/* TODO: This is for posix behavior if writeonly.  To save space, we
		 * use this errno for read attempt while writing, as no errno is
		 * specified by posix for this case, even though the restriction is
		 * mentioned in fopen(). */
		__set_errno(EBADF);
		return 0;
	}

	/* We need to disable putc and getc macros in case of error */
#if defined(__STDIO_PUTC_MACRO) || defined(__STDIO_GETC_MACRO)
#ifdef __STDIO_PUTC_MACRO
	stream->bufputc =
#endif /* __STDIO_GETC_MACRO */
#ifdef __STDIO_GETC_MACRO
	stream->bufgetc =
#endif /* __STDIO_GETC_MACRO */
	stream->bufstart;
#endif /*  defined(__STDIO_PUTC_MACRO) || defined(__STDIO_GETC_MACRO) */

	if (stream->modeflags & __MASK_BUFMODE) {
		/* If the stream is readable and not fully buffered, we must first
		 * flush all line buffered output streams.  Do this before the
		 * error check as this may be a read/write line-buffered stream.
		 * Note: Uses an implementation-specific hack!!! */
		fflush_unlocked((FILE *) &_stdio_openlist);
	}

#ifdef __STDIO_AUTO_RW_TRANSITION
	if ((stream->modeflags & __FLAG_WRITING)
		&& (fflush_unlocked(stream) == EOF)
		) {
		return 0;				/* Fail if we need to fflush but can't. */
	}
#endif /* __STDIO_AUTO_RW_TRANSITION */

	stream->modeflags |= __FLAG_READING; /* Make sure Reading flag is set. */

	{
		register unsigned char *p = (unsigned char *) buffer;

		/* First, grab appropriate ungetc() chars.  NOT FOR WIDE ORIENTATED! */
		while (bytes && (stream->modeflags & __MASK_UNGOT)) {
#ifdef __STDIO_WIDE
			assert(stream->modeflags & __FLAG_NARROW);
#endif /* __STDIO_WIDE */
			*p++ = stream->ungot[(--stream->modeflags) & __MASK_UNGOT];
			stream->ungot[1] = 0;
			--bytes;
		}

		/* Now get any other needed chars from the buffer or the file. */
	FROM_BUF:
		while (bytes && (stream->bufpos < stream->bufread)) {
			--bytes;
			*p++ = *stream->bufpos++;
		}

		if (bytes > 0) {
			ssize_t len;

			/* The buffer is exhausted, but we still need chars.  */
			stream->bufpos = stream->bufread = stream->bufstart;

			if (bytes <= stream->bufend - stream->bufread) {
				/* We have sufficient space in the buffer. */
				len = _stdio_READ(stream, stream->bufread,
								  stream->bufend - stream->bufread);
				if (len > 0) {
					stream->bufread += len;
					goto FROM_BUF;
				}
			} else {
				/* More bytes needed than fit in the buffer, so read */
				/* directly into caller's buffer. */
				len = _stdio_READ(stream, p, bytes);
				if (len > 0) {
					p += len;
					bytes -= len;
					goto FROM_BUF; /* Redundant work, but stops extra read. */
				}
			}
		}

#ifdef __STDIO_GETC_MACRO
		if (!(stream->modeflags & (__FLAG_WIDE|__MASK_UNGOT|__MASK_BUFMODE))) {
			stream->bufgetc = stream->bufread; /* Enable getc macro. */
		}
#endif

		__stdio_validate_FILE(stream); /* debugging only */
		return (p - (unsigned char *)buffer);
	}

#else  /* __STDIO_BUFFERS --------------------------------------- */

	if (stream->modeflags 
#ifdef __STDIO_AUTO_RW_TRANSITION
		& (__FLAG_WRITEONLY)
#else  /* __STDIO_AUTO_RW_TRANSITION */
		/* ANSI/ISO and SUSv3 require not currently writing. */
		& (__FLAG_WRITEONLY|__FLAG_WRITING)
#endif /* __STDIO_AUTO_RW_TRANSITION */
		) {
		stream->modeflags |= __FLAG_ERROR;
		/* TODO: This is for posix behavior if writeonly.  To save space, we
		 * use this errno for read attempt while writing, as no errno is
		 * specified by posix for this case, even though the restriction is
		 * mentioned in fopen(). */
		__set_errno(EBADF);
		return 0;
	}

#ifdef __STDIO_AUTO_RW_TRANSITION
	stream->modeflags &= ~(__FLAG_WRITING);	/* Make sure Writing flag clear. */
#endif /* __STDIO_AUTO_RW_TRANSITION */

	stream->modeflags |= __FLAG_READING; /* Make sure Reading flag is set. */

	{
		register unsigned char *p = (unsigned char *) buffer;

		/* First, grab appropriate ungetc() chars.  NOT FOR WIDE ORIENTATED! */
		while (bytes && (stream->modeflags & __MASK_UNGOT)) {
#ifdef __STDIO_WIDE
			assert(stream->modeflags & __FLAG_NARROW);
#endif /* __STDIO_WIDE */
			*p++ = stream->ungot[(--stream->modeflags) & __MASK_UNGOT];
			stream->ungot[1] = 0;
			--bytes;
		}	

		while (bytes > 0) {
			ssize_t len = _stdio_READ(stream, p, (unsigned) bytes);
			if (len == 0) {
				break;
			}
			p += len;
			bytes -= len;
		}

		__stdio_validate_FILE(stream); /* debugging only */
		return (p - (unsigned char *)buffer);
	}

#endif /* __STDIO_BUFFERS */
}

#endif
/**********************************************************************/
#ifdef L__stdio_fwrite
/*
 * If buffer == NULL, attempt to fflush and return number of chars
 * remaining in buffer (0 if successful fflush).
 */

/* WARNING!!!! Current standards say that termination due to an asyncronous
 * signal may not result in stdio streams being flushed.  This libary makes
 * an effort to do so but there is no way, short of blocking signals for
 * each _stdio_fwrite call, that we can maintain the correct state if a
 * signal is recieved mid-call.  So any stream in mid-_stdio_fwrite could
 * not some flush data or even duplicate-flush some data.  It is possible
 * to avoid the duplicate-flush case by setting/clearing the stream
 * error flag before/after the write process, but it doesn't seem worth
 * the trouble. */

/* Like standard write, but always does a full write unless error plus
 *deals correctly with bufsize > SSIZE_MAX... not much on an issue on linux
 * but definitly could be on Elks.  Also on Elks, always loops for EINTR..
 * Returns number of bytes written, so a short write indicates an error */
static size_t _stdio_WRITE(register FILE *stream,
						   register const unsigned char *buf, size_t bufsize)
{
	size_t todo;
	ssize_t rv, stodo;

	todo = bufsize;

	while (todo) {
		stodo = (todo <= SSIZE_MAX) ? todo : SSIZE_MAX;
		rv = __WRITE(stream, buf, stodo);
		if (rv >= 0) {
#ifdef __STDIO_GLIBC_CUSTOM_STREAMS
			assert(rv <= stodo);	/* buggy user handler... TODO: check? */
			if (rv > stodo) {	/* Num reported written > number requested */
				rv = stodo;		/* Treat as a full write??? */
			}
#endif
			todo -= rv;
			buf += rv;
		} else
#ifdef __BCC__
			if (errno != EINTR)
#endif
		{
			stream->modeflags |= __FLAG_ERROR;
			break;
		}
	}

	return bufsize - todo;
}

/* Internal function -- not reentrant. */

size_t _stdio_fwrite(const unsigned char *buffer, size_t bytes,
					 register FILE *stream)
{
#ifdef __STDIO_BUFFERS
	register const unsigned char *p;

	__stdio_validate_FILE(stream); /* debugging only */

	if ((stream->modeflags & __FLAG_READONLY)
#ifndef __STDIO_AUTO_RW_TRANSITION
	/* ANSI/ISO requires either at EOF or currently not reading. */
		|| ((stream->modeflags & (__FLAG_READING|__FLAG_EOF))
			== __FLAG_READING)
#endif /* __STDIO_AUTO_RW_TRANSITION */
		) {
		stream->modeflags |= __FLAG_ERROR;
		/* TODO: This is for posix behavior if readonly.  To save space, we
		 * use this errno for write attempt while reading, as no errno is
		 * specified by posix for this case, even though the restriction is
		 * mentioned in fopen(). */
		__set_errno(EBADF);
		return 0;
	}

#ifdef __STDIO_AUTO_RW_TRANSITION
	/* If reading, deal with ungots and read-buffered chars. */
	if (stream->modeflags & __FLAG_READING) {
		if (((stream->bufpos < stream->bufread)
			 || (stream->modeflags & __MASK_UNGOT))
			/* If appending, we might as well seek to end to save a seek. */
			/* TODO: set EOF in fseek when appropriate? */
			&& fseek(stream, 0L, 
					 ((stream->modeflags & __FLAG_APPEND)
					  ? SEEK_END : SEEK_CUR))
			) {
			/* Note: This differs from glibc's apparent behavior of
			   not setting the error flag and discarding the buffered
			   read data. */
			stream->modeflags |= __FLAG_ERROR; /* fseek may not set this. */
			return 0;			/* Fail if we need to fseek but can't. */
		}
		/* Always reset even if fseek called (saves a test). */
#ifdef __STDIO_GETC_MACRO
		stream->bufgetc =
#endif /* __STDIO_GETC_MACRO */
		stream->bufpos = stream->bufread = stream->bufstart;
	}
#endif

#ifdef __STDIO_PUTC_MACRO
	/* We need to disable putc macro in case of error */
	stream->bufputc = stream->bufstart;
#endif /* __STDIO_GETC_MACRO */

	/* Clear both reading and writing flags.  We need to clear the writing
	 * flag in case we're fflush()ing or in case of an error. */
	stream->modeflags &= ~(__FLAG_READING|__FLAG_WRITING);

	{
		const unsigned char *buf0 = buffer;

		if (!buffer) {				/* fflush the stream */
		FFLUSH:
			{
				size_t count = stream->bufpos - stream->bufstart;
				p = stream->bufstart;

				if (stream->filedes == -2) { /* TODO -- document this hack! */
					stream->modeflags |= __FLAG_WRITING;
					return (!buffer) ? 0 : ((buffer - buf0) + bytes);
				}

				{
					size_t rv = _stdio_WRITE(stream, p, count);
					p += rv;
					count -= rv;
				}
			
				stream->bufpos = stream->bufstart;
				while (count) {
					*stream->bufpos++ = *p++;
					--count;
				}

				if (!buffer) {	/* fflush case... */
					__stdio_validate_FILE(stream); /* debugging only */
					return stream->bufpos - stream->bufstart;
				}
			}
		}

#if 1
		/* TODO: If the stream is buffered, we may be able to omit. */
		if ((stream->bufpos == stream->bufstart) /* buf empty */
			&& (stream->bufend - stream->bufstart <= bytes)	/* fills */
			&& (stream->filedes != -2)) { /* not strinf fake file */
			/* so want to do a direct write of supplied buffer */
			{
				size_t rv = _stdio_WRITE(stream, buffer, bytes);
				buffer += rv;
				bytes -= rv;
			}
		} else
#endif
		/* otherwise buffer not empty and/or data fits */
		{
			size_t count = stream->bufend - stream->bufpos;
			p = buffer;

			if (count > bytes) {
				count = bytes;
			}
			bytes -= count;

			while (count) {
				*stream->bufpos++ = *buffer++;
				--count;
			}

			if (bytes) {
				goto FFLUSH;
			}

			if (stream->modeflags & __FLAG_LBF) {
				while (p < buffer) { /* check for newline. */
					if (*p++ == '\n') {
						goto FFLUSH;
					}
				}
			}
		}

#ifdef __STDIO_PUTC_MACRO
		if (!(stream->modeflags & (__FLAG_WIDE|__MASK_BUFMODE))) {
			/* Not wide, no errors and fully buffered, so enable putc macro. */
			stream->bufputc = stream->bufend;
		}
#endif /* __STDIO_GETC_MACRO */
		stream->modeflags |= __FLAG_WRITING; /* Ensure Writing flag is set. */

		__stdio_validate_FILE(stream); /* debugging only */
		return buffer - buf0;

	}

#else  /* __STDIO_BUFFERS --------------------------------------- */

	__stdio_validate_FILE(stream); /* debugging only */

	if ((stream->modeflags & __FLAG_READONLY)
#ifndef __STDIO_AUTO_RW_TRANSITION
	/* ANSI/ISO requires either at EOF or currently not reading. */
		|| ((stream->modeflags & (__FLAG_READING|__FLAG_EOF))
			== __FLAG_READING)
#endif /* __STDIO_AUTO_RW_TRANSITION */
		) {
		stream->modeflags |= __FLAG_ERROR;
		/* TODO: This is for posix behavior if readonly.  To save space, we
		 * use this errno for write attempt while reading, as no errno is
		 * specified by posix for this case, even though the restriction is
		 * mentioned in fopen(). */
		__set_errno(EBADF);
		return 0;
	}

	/* We always clear the reading flag in case at EOF. */
	stream->modeflags &= ~(__FLAG_READING);
	/* Unlike the buffered case, we set the writing flag now since we don't
	 * need to do anything here for fflush(). */
	stream->modeflags |= __FLAG_WRITING;

	{
		register unsigned char *p = (unsigned char *) buffer;

		ssize_t rv = _stdio_WRITE(stream, p, bytes);

		p += rv;
		bytes -= rv;

		__stdio_validate_FILE(stream); /* debugging only */
		return (p - (unsigned char *)buffer);
	}

#endif /* __STDIO_BUFFERS *****************************************/
}

#endif
/**********************************************************************/
#ifdef L__stdio_init

/* Internal functions -- _stdio_init() and __stdio_validate_FILE
 * are not reentrant, but _stdio_term() is through fflush().
 * Also, the _cs_{read|write|close} functions are not reentrant. */

#ifndef NDEBUG
void __stdio_validate_FILE(FILE *stream)
{
	if (stream->filedes == -2) { /* fake FILE for sprintf, scanf, etc. */
		return;
	}

	__STDIO_THREADLOCK(stream);

#ifdef __STDIO_BUFFERS
	assert(stream->bufstart <= stream->bufread);
	if (stream->modeflags & (__FLAG_READING)) {
		assert(stream->bufpos <= stream->bufread);
	}
	assert(stream->bufread <= stream->bufend);
	assert(stream->bufpos <= stream->bufend);
	if ((stream->modeflags & __MASK_BUFMODE) == __FLAG_NBF) {
		assert(stream->bufstart == stream->bufend);
	}
	assert((stream->modeflags & __MASK_BUFMODE) <= __FLAG_NBF);
#endif
#ifdef __STDIO_PUTC_MACRO
	assert(stream->bufstart <= stream->bufputc);
	assert(stream->bufputc <= stream->bufend);
	if (stream->bufstart < stream->bufputc) {
		assert(stream->bufputc == stream->bufend);
		assert(stream->modeflags & (__FLAG_WRITING));
		assert(!(stream->modeflags
				 & (__FLAG_WIDE|__MASK_BUFMODE|__MASK_UNGOT|__FLAG_READONLY))
			   );
	}
#endif
#ifdef __STDIO_GETC_MACRO
	assert(stream->bufstart <= stream->bufgetc);
	assert(stream->bufgetc <= stream->bufread);
	if (stream->bufstart < stream->bufgetc) {
		assert(stream->modeflags & (__FLAG_READING));
		assert(!(stream->modeflags
				 & (__FLAG_WIDE|__MASK_BUFMODE|__MASK_UNGOT|__FLAG_WRITEONLY))
			   );
	}
#endif
	assert((stream->modeflags & __MASK_UNGOT) != __MASK_UNGOT);
	if (stream->modeflags & __MASK_UNGOT1) {
		assert(stream->ungot[1] <= 1);
	}
	if (stream->modeflags & __MASK_UNGOT) {
		assert(!(stream->modeflags & __FLAG_EOF));
	}
	assert((stream->modeflags & (__FLAG_READONLY|__FLAG_WRITEONLY))
		   != (__FLAG_READONLY|__FLAG_WRITEONLY));

	/* TODO -- filepos?  ungot_width?  filedes?  nextopen? */

	__STDIO_THREADUNLOCK(stream);
}
#endif

#ifdef __STDIO_GLIBC_CUSTOM_STREAMS
ssize_t _cs_read(void *cookie, char *buf, size_t bufsize)
{
	return read(*((int *) cookie), buf, bufsize);
}

ssize_t _cs_write(void *cookie, const char *buf, size_t bufsize)
{
	return write(*((int *) cookie), (char *) buf, bufsize);
}

int _cs_close(void *cookie)
{
	return close(*((int *) cookie));
}
#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */

#ifdef __STDIO_BUFFERS
static unsigned char _fixed_buffers[2 * BUFSIZ];
#define bufin (_fixed_buffers)
#define bufout (_fixed_buffers + BUFSIZ)
#endif /* __STDIO_BUFFERS */

static FILE _stdio_streams[] = {
	__STDIO_INIT_FILE_STRUCT(_stdio_streams[0], __FLAG_LBF|__FLAG_READONLY, \
							 0, _stdio_streams + 1, bufin, BUFSIZ ),
	__STDIO_INIT_FILE_STRUCT(_stdio_streams[1], __FLAG_LBF|__FLAG_WRITEONLY, \
							 1, _stdio_streams + 2, bufout, BUFSIZ ), 
	__STDIO_INIT_FILE_STRUCT(_stdio_streams[2], __FLAG_NBF|__FLAG_WRITEONLY, \
							 2, 0, 0, 0 )
};

FILE *stdin = _stdio_streams + 0;
FILE *stdout = _stdio_streams + 1;
FILE *stderr = _stdio_streams + 2;

#if defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS)

#ifdef __STDIO_BUFFERS
FILE *_stdio_openlist = _stdio_streams;
#else  /* __STDIO_BUFFERS */
FILE *_stdio_openlist = NULL;
#endif /* __STDIO_BUFFERS */

#ifdef __STDIO_THREADSAFE
pthread_mutex_t _stdio_openlist_lock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;


void __stdio_init_mutex(pthread_mutex_t *m)
{
	static const pthread_mutex_t __stdio_mutex_initializer
		= PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;

	memcpy(m, &__stdio_mutex_initializer, sizeof(__stdio_mutex_initializer));
}
#endif /* __STDIO_THREADSAFE */

/* TODO - do we need to lock things, or do we just assume we're the only
 * remaining thread? */

/* Note: We assume here that we are the only remaining thread. */
void _stdio_term(void)
{
#if defined(__STDIO_GLIBC_CUSTOM_STREAMS) || defined(__STDIO_THREADSAFE)
	register FILE *ptr;
#endif

	/* TODO: if called via a signal handler for a signal mid _stdio_fwrite,
	 * the stream may be in an unstable state... what do we do?
	 * perhaps set error flag before and clear when done if successful? */

#ifdef __STDIO_THREADSAFE
	/* First, forceably unlock the open file list and all files.
	 * Note: Set locking mode to "by caller" to save some overhead later. */
	__stdio_init_mutex(&_stdio_openlist_lock);
	for (ptr = _stdio_openlist ; ptr ; ptr = ptr->nextopen ) {
		ptr->user_locking = FSETLOCKING_BYCALLER;
		__stdio_init_mutex(&ptr->lock);
	}
#endif /* __STDIO_THREADSAFE */

#ifdef __STDIO_BUFFERS
	/* TODO -- set an alarm and flush each file "by hand"? to avoid blocking? */

	/* Now flush all streams. */
	fflush_unlocked(NULL);
#endif /* __STDIO_BUFFERS */

	/* Next close all custom streams in case of any special cleanup, but
	 * don't use fclose() because that pulls in free and malloc.  Also,
	 * don't worry about removing them from the list.  Just set the cookie
	 * pointer to NULL so that an error will be generated if someone tries
	 * to use the stream. */
#ifdef __STDIO_GLIBC_CUSTOM_STREAMS
	for (ptr = _stdio_openlist ; ptr ; ptr = ptr->nextopen ) {
		if (ptr->cookie != &ptr->filedes) {	/* custom stream */
			__CLOSE(ptr);
			ptr->cookie = NULL;	/* Generate an error if used later. */
#if 0
/*  #ifdef __STDIO_BUFFERS */
		} else {
			/* TODO: "unbuffer" files like glibc does?  Inconsistent with
			 * custom stream handling above, but that's necessary to deal
			 * with special user-defined close behavior. */
			stream->bufpos = stream->bufread = stream->bufend
#ifdef __STDIO_GETC_MACRO
				= stream->bufgetc
#endif
#ifdef __STDIO_PUTC_MACRO
				= stream->bufputc
#endif
				= stream->bufstart;
#endif /* __STDIO_BUFFERS */
		}
	}
#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */
}


#if defined(__STDIO_BUFFERS) || !defined(__UCLIBC__)
void _stdio_init(void)
{
#ifdef __STDIO_BUFFERS
	/* stdin and stdout uses line buffering when connected to a tty. */
	_stdio_streams[0].modeflags ^= (1-isatty(0)) * __FLAG_LBF;
	_stdio_streams[1].modeflags ^= (1-isatty(1)) * __FLAG_LBF;
#endif /* __STDIO_BUFFERS */
#ifndef __UCLIBC__
/* __stdio_term is automatically when exiting if stdio is used.
 * See misc/internals/__uClibc_main.c and and stdlib/atexit.c. */
	atexit(_stdio_term);
#endif /* __UCLIBC__ */
}
#endif /* defined(__STDIO_BUFFERS) || !defined(__UCLIBC__) */
#endif /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */

#endif
/**********************************************************************/
/* ANSI/ISO functions. */
/**********************************************************************/
#ifdef L_remove
#include <unistd.h>
#include <errno.h>

/* No reentrancy issues. */

int remove(register const char *filename)
{
	int old_errno = errno;

	/* SUSv3 says equivalent to rmdir() if a directory, and unlink()
	 * otherwise.  Hence, we need to try rmdir() first. */

	return (((rmdir(filename) == 0)
			 || ((errno == ENOTDIR)
				 && ((__set_errno(old_errno), unlink(filename)) == 0)))
			? 0 : -1);
}
#endif
/**********************************************************************/
/* rename is a syscall
#ifdef L_rename
int rename(const char *old, const char *new);
#endif
*/
/**********************************************************************/
/* TODO: tmpfile */
/*  #ifdef L_tmpfile */
/*  FILE *tmpfile(void); */
/*  #endif */
/**********************************************************************/
/* TODO: tmpname */
/*  #ifdef L_tmpname */
/*  char *tmpname(char *s); */
/*  #endif */
/**********************************************************************/
#ifdef L_fclose

/* We need to be careful here to avoid deadlock when threading, as we
 * need to lock both the file and the open file list.  This can clash
 * with fflush.  Since fflush is much more common, we do the extra
 * work here. */

int fclose(register FILE *stream)
{
#if defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS)

	register FILE *ptr;
	int rv = 0;

#ifdef __STDIO_THREADSAFE
	/* Need two non-heirchal mutexs... be careful to avoid deadlock*/
	do {
		__STDIO_THREADLOCK(stream);
		if (__STDIO_THREADTRYLOCK_OPENLIST == 0) {
			break;
		}
		__STDIO_THREADUNLOCK(stream);
		usleep(10000);
	} while (1);
#endif /* __STDIO_THREADSAFE */

	__stdio_validate_FILE(stream); /* debugging only */

#ifdef __STDIO_BUFFERS
	if (stream->modeflags & __FLAG_WRITING) {
		rv = fflush_unlocked(stream); /* Write any pending buffered chars. */
	}								  /* Also disables putc macro if used. */

#ifdef __STDIO_GETC_MACRO
	/* Not necessary after fflush, but always do this to reduce size. */
	stream->bufgetc = stream->bufstart;	/* Disable getc macro for safety. */
#endif /* __STDIO_GETC_MACRO */
#endif /* __STDIO_BUFFERS */

	/* Remove file from open list before closing file descriptor. */
	ptr = _stdio_openlist;
	if (ptr == stream) {
		_stdio_openlist = stream->nextopen;
	} else {
		while (ptr) {
			if (ptr->nextopen == stream) {
				ptr->nextopen = stream->nextopen;
				break;
			}
			ptr = ptr->nextopen;
		}
	}
	__STDIO_THREADUNLOCK_OPENLIST; /* We're done with the open file list. */

	if (__CLOSE(stream) < 0) {	/* Must close even if fflush failed. */
		rv = EOF;
	}
#ifdef __STDIO_GLIBC_CUSTOM_STREAMS
	stream->cookie = NULL;		/* To aid debugging... */
#endif
	stream->filedes = -1;		/* To aid debugging... */

#ifdef __STDIO_BUFFERS
	if (stream->modeflags & __FLAG_FREEBUF) {
		free(stream->bufstart);
	}
#endif /* __STDIO_BUFFERS */

	/* TODO -- leave the stream locked to catch any dangling refs? */
	__STDIO_THREADUNLOCK(stream);

	/* At this point, any dangling refs to the stream are the result of
	 * a programming bug... so free the unlocked stream. */
	if (stream->modeflags & __FLAG_FREEFILE) {
		free(stream);
	}

	return rv;

#else  /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */

	int rv = 0;

	__STDIO_THREADLOCK(stream);

	__stdio_validate_FILE(stream); /* debugging only */

	if (__CLOSE(stream) < 0) {	/* Must close even if fflush failed. */
		rv = EOF;
	}

#ifdef __STDIO_GLIBC_CUSTOM_STREAMS
	stream->cookie = NULL;		/* To aid debugging... */
#endif
	stream->filedes = -1;		/* To aid debugging... */

	__STDIO_THREADUNLOCK(stream);

	/* At this point, any dangling refs to the stream are the result of
	 * a programming bug... so free the unlocked stream. */
	if (stream->modeflags & __FLAG_FREEFILE) {
		free(stream);
	}

	return rv;

#endif /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS )*/
}

#endif
/**********************************************************************/
#ifdef L_fflush

/*
 * Special cases:
 *   stream == NULL means fflush all writing streams (ANSI/ISO).
 *   stream == (FILE *) &_stdio_openlist -- implementation-specific hack
 *      meaning fflush all line buffered writing streams
 */

/*
 * NOTE: ANSI/ISO difference!!!  According to the standard, fflush is only
 * defined for write-only streams, or read/write streams whose last op
 * was a write.  However, reading is allowed for a read/write stream if
 * a file positioning operation was done (fseek, fsetpos) even though there
 * is no guarantee of flushing the write data in that case.  Hence, for
 * this case we keep a flag to indicate whether or not the buffer needs to
 * be flushed even if the last operation was a read.  This falls under the
 * implementation-defined behavior.  Otherwise, we would need to flush
 * every time we did fseek, etc. even if we were still in the buffer's range.
 */

/* Since the stream pointer arg is allowed to be NULL, or the address of the
 * stdio open file list if stdio is buffered in this implementation, we can't
 * use the UNLOCKED() macro here. */

#ifndef __STDIO_THREADSAFE
strong_alias(fflush_unlocked,fflush)
#else  /* __STDIO_THREADSAFE */
int fflush(register FILE *stream)
{
	int retval;

	if ((stream != NULL)
#ifdef __STDIO_BUFFERS
		&& (stream != (FILE *) &_stdio_openlist)
#endif /* __STDIO_BUFFERS */
		) {
		__STDIO_THREADLOCK(stream);
		retval = fflush_unlocked(stream);
		__STDIO_THREADUNLOCK(stream);
	} else {
		retval = fflush_unlocked(stream);
	}

	return retval;
}
#endif /* __STDIO_THREADSAFE */

int fflush_unlocked(register FILE *stream)
{
#ifdef __STDIO_BUFFERS

	int rv = 0;
	unsigned short mask = (__FLAG_NBF|__FLAG_LBF);

#ifndef NDEBUG
	if ((stream != NULL) && (stream != (FILE *) &_stdio_openlist)) {
		__stdio_validate_FILE(stream); /* debugging only */
	}
#endif

	if (stream == (FILE *) &_stdio_openlist) { /* fflush all line-buffered */
		stream = NULL;
		mask = __FLAG_LBF;
	}

	if (stream == NULL) {		/* flush all (line) buffered writing streams */
		/* Note -- We have to lock the list even in the unlocked function. */
		__STDIO_THREADLOCK_OPENLIST;
		/* TODO -- Can we work around locking the list to avoid keeping it
		 * locked if the write blocks? */
		for (stream = _stdio_openlist; stream; stream = stream->nextopen) {
			if (((stream->modeflags ^ __FLAG_NBF) & mask)
				&& (stream->modeflags & __FLAG_WRITING)
				&& fflush(stream)) {
				rv = EOF;
			}
		}
		__STDIO_THREADUNLOCK_OPENLIST;
	} else if (stream->modeflags & __FLAG_WRITING) {
		if (_stdio_fwrite(NULL, 0, stream) > 0) { /* flush buffer contents. */
			rv = -1;			/* Not all chars written. */
		}
	} else if (stream->modeflags & (__FLAG_READONLY|__FLAG_READING)) {
		/* TODO - __FLAG_READING too?  check glibc behavior */
		/* According to info, glibc returns an error when the file is opened
		 * in read-only mode.
		 * ANSI/ISO says behavior in this case is undefined but also says you
		 * shouldn't flush a stream you were reading from.
		 */
		stream->modeflags |= __FLAG_ERROR; /* TODO - check glibc behavior */
		__set_errno(EBADF);
		rv = -1;
	}

#ifndef NDEBUG
	if ((stream != NULL) && (stream != (FILE *) &_stdio_openlist)) {
		__stdio_validate_FILE(stream); /* debugging only */
	}
#endif
	return rv;

#else  /* __STDIO_BUFFERS --------------------------------------- */

#ifndef NDEBUG
	if ((stream != NULL) && (stream != (FILE *) &_stdio_openlist)) {
		__stdio_validate_FILE(stream); /* debugging only */
	}
#endif

	/* TODO -- check glibc behavior regarding error indicator */
	return ((stream != NULL)
			&& (stream->modeflags & (__FLAG_READONLY|__FLAG_READING))
			? ((stream->modeflags |= __FLAG_ERROR), __set_errno(EBADF), EOF)
			: 0 );

#endif /* __STDIO_BUFFERS */
}
#endif
/**********************************************************************/
#ifdef L_fopen

/* No reentrancy issues. */

FILE *fopen(const char * __restrict filename, const char * __restrict mode)
{
	return _stdio_fopen(filename, mode, NULL, -1);
}

#endif
/**********************************************************************/
#ifdef L__stdio_fopen

/*
 * Cases:
 *  fopen    : filename != NULL, stream == NULL, filedes == -1
 *  freopen  : filename != NULL, stream != NULL, filedes == -1
 *  fdopen   : filename == NULL, stream == NULL, filedes valid
 *  fsfopen  : filename != NULL, stream != NULL, filedes == -1
 *  fopen64  : filename != NULL, stream == NULL, filedes == -2
 */

#if O_ACCMODE != 3 || O_RDONLY != 0 || O_WRONLY != 1 || O_RDWR != 2
#error Assumption violated - mode constants
#endif

/* Internal function -- reentrant (locks open file list) */

FILE *_stdio_fopen(const char * __restrict filename,
				   register const char * __restrict mode,
				   register FILE * __restrict stream, int filedes)
{
	__mode_t open_mode;

	/* parse mode */
	open_mode = O_RDONLY;
	if (*mode != 'r') {			/* not read */
		open_mode = (O_WRONLY | O_CREAT | O_TRUNC);
		if (*mode != 'w') {		/* not write (create or truncate)*/
			open_mode = (O_WRONLY | O_CREAT | O_APPEND);
			if (*mode != 'a') {	/* not write (create or append) */
				__set_errno(EINVAL); /* then illegal mode */
				if (stream) {	/* If this is freopen, free the stream. */
					goto FREE_STREAM;
				}
				return NULL;
			}
		}
	}

	if ((*++mode == 'b')) {		/* binary mode (NOP currently) */
		++mode;
	}

	if (*mode == '+') {			/* read-write */
		++mode;
		open_mode &= ~(O_RDONLY | O_WRONLY);
		open_mode |= O_RDWR;
	}

#if defined(__STDIO_GNU_FEATURE) || defined(__STDIO_FOPEN_LARGEFILE_MODE)
	while (*mode) {				/* ignore everything else except ... */
#ifdef __STDIO_FOPEN_EXCLUSIVE_MODE
		if (*mode++ == 'x') {	/* open exclusive -- glibc extension */
			open_mode |= O_EXCL;
		}
#endif /* __STDIO_FOPEN_EXCLUSIVE_MODE */
#ifdef __STDIO_FOPEN_LARGEFILE_MODE
		if (*mode++ == 'F') {	/* open large file */
			open_mode |= O_LARGEFILE;
		}
#endif /* __STDIO_FOPEN_LARGEFILE_MODE */
	}
#endif /* __STDIO_FOPEN_EXCLUSIVE_MODE or __STDIO_FOPEN_LARGEFILE_MODE def'd */

#ifdef __BCC__
	mode = filename;			/* TODO:  help BCC with register allocation. */
#define filename mode
#endif /* __BCC__ */

	if (!stream) {				/* Need to allocate a FILE. */
#ifdef __STDIO_BUFFERS
		if ((stream = malloc(sizeof(FILE))) == NULL) {
			return stream;
		}
		stream->modeflags = __FLAG_FREEFILE;
		if ((stream->bufstart = malloc(BUFSIZ)) != 0) {
			stream->bufend = stream->bufstart + BUFSIZ;
			stream->modeflags |= __FLAG_FREEBUF;
		} else {
#if __STDIO_BUILTIN_BUF_SIZE > 0
			stream->bufstart = stream->unbuf;
			stream->bufend = stream->unbuf + sizeof(stream->unbuf);
#else  /* __STDIO_BUILTIN_BUF_SIZE > 0 */
			stream->bufstart = stream->bufend = NULL;
#endif /* __STDIO_BUILTIN_BUF_SIZE > 0 */
		}
#else  /* __STDIO_BUFFERS */
		if ((stream = malloc(sizeof(FILE))) == NULL) {
			return stream;
		}
		stream->modeflags = __FLAG_FREEFILE;
#endif /* __STDIO_BUFFERS */
	}

	if (filedes >= 0) {			/* Handle fdopen trickery. */
		/*
		 * NOTE: it is insufficient to just check R/W/RW agreement.
		 * We must also check for append mode agreement, as well as
		 * largefile agreement if applicable.
		 */
		int i = (open_mode & (O_ACCMODE|O_APPEND|O_LARGEFILE)) + 1;

		if ((i & (((int) filename) + 1)) != i) {
			__set_errno(EINVAL);
			filedes = -1;
		}
		stream->filedes = filedes;
	} else {
#ifdef __STDIO_LARGE_FILES
		if (filedes < -1) {
			open_mode |= O_LARGEFILE;
		}
#endif /* __STDIO_LARGE_FILES */
		stream->filedes = open(filename, open_mode, 0666);
	}

	if (stream->filedes < 0) {
	FREE_STREAM:
#ifdef __STDIO_BUFFERS
		if (stream->modeflags & __FLAG_FREEBUF) {
			free(stream->bufstart);
		}
#endif /* __STDIO_BUFFERS */
		if (stream->modeflags & __FLAG_FREEFILE) {
			free(stream);
		}
		return NULL;
	}

	stream->modeflags |=
#ifdef __STDIO_BUFFERS
		(isatty(stream->filedes) * __FLAG_LBF) |
#endif /* __STDIO_BUFFERS */
#if (O_APPEND == __FLAG_APPEND) \
&& ((O_LARGEFILE == __FLAG_LARGEFILE) || (O_LARGEFILE == 0))
		(open_mode & (O_APPEND|O_LARGEFILE)) | /* i386 linux and elks */
#else  /* (O_APPEND == __FLAG_APPEND) && (O_LARGEFILE == __FLAG_LARGEFILE) */
		((open_mode & O_APPEND) ? __FLAG_APPEND : 0) |
#ifdef __STDIO_LARGE_FILES
		((open_mode & O_LARGEFILE) ? __FLAG_LARGEFILE : 0) |
#endif /* __STDIO_LARGE_FILES */
#endif /* (O_APPEND == __FLAG_APPEND) && (O_LARGEFILE == __FLAG_LARGEFILE) */
		((((open_mode & O_ACCMODE) + 1) ^ 0x03) * __FLAG_WRITEONLY);

#ifdef __STDIO_BUFFERS
#ifdef __STDIO_GETC_MACRO
	stream->bufgetc =
#endif
#ifdef __STDIO_PUTC_MACRO
	stream->bufputc =
#endif
	stream->bufpos = stream->bufread = stream->bufstart;
#endif /* __STDIO_BUFFERS */

#ifdef __STDIO_GLIBC_CUSTOM_STREAMS
	stream->cookie = &(stream->filedes);
	stream->gcs.read = _cs_read;
	stream->gcs.write = _cs_write;
	stream->gcs.seek = 0;		/* The internal seek func handles normals. */
	stream->gcs.close = _cs_close;
#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */

#ifdef __STDIO_MBSTATE
	__INIT_MBSTATE(&(stream->state));
#endif /* __STDIO_MBSTATE */

#ifdef __STDIO_THREADSAFE
	__stdio_init_mutex(&stream->lock);
#endif /* __STDIO_THREADSAFE */

#if defined(__STDIO_BUFFERS) \
|| (defined(__STDIO_THREADSAFE) && defined(__STDIO_GLIBC_CUSTOM_STREAMS))
	__STDIO_THREADLOCK_OPENLIST;
	stream->nextopen = _stdio_openlist;	/* New files are inserted at */
	_stdio_openlist = stream;			/*   the head of the list. */
	__STDIO_THREADUNLOCK_OPENLIST;
#endif

	__stdio_validate_FILE(stream); /* debugging only */
	return stream;
#ifdef __BCC__
#undef filename
#endif /* __BCC__ */
}

#endif
/**********************************************************************/
#ifdef L_freopen

/* Reentrant. */

FILE *freopen(const char * __restrict filename, const char * __restrict mode,
			  register FILE * __restrict stream)
{
	/*
	 * ANSI/ISO allow (implementation-defined) change of mode for an
	 * existing file if filename is NULL.  It doesn't look like Linux
	 * supports this, so we don't here.
	 *
	 * NOTE: Whether or not the stream is free'd on failure is unclear
	 *       w.r.t. ANSI/ISO.  This implementation chooses to free the
	 *       stream and associated buffer if they were dynamically
	 *       allocated.
	 * TODO: Check the above.
	 * TODO: Apparently linux allows setting append mode.  Implement?
	 */
	unsigned short dynmode;
	register FILE *fp;

	__STDIO_THREADLOCK(stream);

	/* First, flush and close, but don't deallocate, the stream. */
	/* This also removes the stream for the open file list. */
	dynmode = 
#ifdef __STDIO_BUFFERS
		/*		__MASK_BUFMODE | */		/* TODO: check */
#endif /* __STDIO_BUFFERS */
		(stream->modeflags & (__FLAG_FREEBUF|__FLAG_FREEFILE));

	stream->modeflags &= ~(__FLAG_FREEBUF|__FLAG_FREEFILE);
	fclose(stream);				/* Failures are ignored. */
	stream->modeflags = dynmode;

	fp = _stdio_fopen(filename, mode, stream, -1);

	__STDIO_THREADUNLOCK(stream);

	return fp;
}
#endif
/**********************************************************************/
#ifdef L_freopen64

/* Reentrant. */

/* TODO -- is it worth collecting the common work (40 bytes) in a function? */
FILE *freopen64(const char * __restrict filename, const char * __restrict mode,
				register FILE * __restrict stream)
{
	unsigned short dynmode;
	register FILE *fp;

	__STDIO_THREADLOCK(stream);

	/* First, flush and close, but don't deallocate, the stream. */
	/* This also removes the stream for the open file list. */
	dynmode = 
#ifdef __STDIO_BUFFERS
		/*		__MASK_BUFMODE | */		/* TODO: check */
#endif /* __STDIO_BUFFERS */
		(stream->modeflags & (__FLAG_FREEBUF|__FLAG_FREEFILE));

	stream->modeflags &= ~(__FLAG_FREEBUF|__FLAG_FREEFILE);
	fclose(stream);				/* Failures are ignored. */
	stream->modeflags = dynmode;

	fp = _stdio_fopen(filename, mode, stream, -2); /* TODO -- magic const */

	__STDIO_THREADUNLOCK(stream);

	return fp;
}

#endif
/**********************************************************************/
#ifdef L_setbuf

/* Reentrant through setvbuf(). */

void setbuf(FILE * __restrict stream, register char * __restrict buf)
{
#ifdef __STDIO_BUFFERS
	int mode;

	mode = (buf != NULL) ? _IOFBF : _IONBF;
	setvbuf(stream, buf, mode, BUFSIZ);
#else  /* __STDIO_BUFFERS */
	/* TODO -- assert on stream? */
	/* Nothing to do. */
#endif /* __STDIO_BUFFERS */
}

#endif
/**********************************************************************/
#ifdef L_setvbuf

/* Reentrant. */

int setvbuf(register FILE * __restrict stream, register char * __restrict buf,
			int mode, size_t size)
{
#ifdef __STDIO_BUFFERS

	int allocated_buf_flag;
	int rv = EOF;

	__STDIO_THREADLOCK(stream);

	__stdio_validate_FILE(stream); /* debugging only */

	if (((unsigned int) mode) > 2) { /* Illegal mode. */
		/* TODO -- set an errno? */
		goto DONE;
	}

#ifdef __STDIO_FLEXIBLE_SETVBUF
	/* C89 standard requires no ops before setvbuf, but we can be flexible. */
	/* NOTE: This will trash any chars ungetc'd!!! */
	/* TODO: hmm could preserve unget count since ungot slots aren't changed (true?)
	 * but this will fail when buffered chars read from a pipe unless the user buf
	 * is big enough to copy everything over. */
	if (fseek(stream, 0L, SEEK_CUR)) {
		goto DONE;
	}
#else  /* __STDIO_FLEXIBLE_SETVBUF */
	/*
	 * Note: ANSI/ISO requires setvbuf to be called after opening the file
	 * but before any other operation other than a failed setvbuf call.
	 * We'll cheat here and only test if the wide or narrow mode flag has
	 * been set; i.e. no read or write (or unget or fwide) operations have
	 * taken place.
	 */
#ifdef __STDIO_WIDE
	if (stream->modeflags & (__FLAG_WIDE|__FLAG_NARROW)) {
		goto DONE;
	}
#else  /* __STDIO_WIDE */
	/* Note: This only checks if not currently reading or writing. */
	if (stream->modeflags & (__FLAG_READING|__FLAG_WRITING)) {
		goto DONE;
	}
#endif /* __STDIO_WIDE */
#endif /* __STDIO_FLEXIBLE_SETVBUF */

	if (mode == _IONBF) {
		size = 0;
		buf = NULL;
	} else if (!buf && !size) {
		/* If buf==NULL && size==0 && either _IOFBF or _IOLBF, keep
		 * current buffer and only set buffering mode. */
		size = stream->bufend - stream->bufstart;
	}

	stream->modeflags &= ~(__MASK_BUFMODE);	/* Clear current mode */
	stream->modeflags |= mode * __FLAG_LBF;	/* and set new one. */

	allocated_buf_flag = 0;
	if ((!buf) && (size != (stream->bufend - stream->bufstart))) {
		/* No buffer supplied and requested size different from current. */
		/* If size == 0, create a (hopefully) bogus non-null pointer... */
		if (!(buf = ((size > 0)
					 ? ((allocated_buf_flag = __FLAG_FREEBUF), malloc(size))
					 : ((char *)NULL) + 1))
			) {
			/* TODO -- should we really keep current buffer if it was passed
			 * to us earlier by the app? */
			goto DONE;		/* Keep current buffer. */
		}
	}

	/* TODO: setvbuf "signal" safety */
	if (buf && (buf != (char *) stream->bufstart)) { /* Want new buffer. */
		if (stream->modeflags & __FLAG_FREEBUF) {
			stream->modeflags &= ~(__FLAG_FREEBUF);
			free(stream->bufstart);
		}
		stream->modeflags |= allocated_buf_flag;	/* Free-able buffer? */
#ifdef __STDIO_GETC_MACRO
		stream->bufgetc =
#endif
#ifdef __STDIO_PUTC_MACRO
		stream->bufputc =
#endif
		stream->bufpos = stream->bufread = stream->bufstart = buf;
		stream->bufend = buf + size;
	}

	__stdio_validate_FILE(stream); /* debugging only */

	rv = 0;

 DONE:
	__STDIO_THREADUNLOCK(stream);

	return rv;

#else  /* __STDIO_BUFFERS */
	__stdio_validate_FILE(stream); /* debugging only */
	/* TODO -- set errno for illegal mode? */

	return EOF;
#endif /* __STDIO_BUFFERS */
}

#endif
/**********************************************************************
int fprintf(FILE * __restrict stream, const char * __restrict format, ...);
int fscanf(FILE * __restrict stream, const char * __restrict format, ...);
int printf(const char * __restrict format, ...);
int scanf(const char * __restrict format, ...);
int snprintf(char * __restrict s, size_t n,
					const char * __restrict format, ...);
int sprintf(char * __restrict s, const char * __restrict format, ...);
int sscanf(char * __restrict s, const char * __restrict format, ...);
int vfprintf(FILE * __restrict stream, const char * __restrict format,
					va_list arg);
int vfscanf(FILE * __restrict stream, const char * __restrict format,
				   va_list arg);
int vprintf(const char * __restrict format, va_list arg);
int vscanf(const char * __restrict format, va_list arg);
int vsnprintf(char * __restrict s, size_t n,
					 const char * __restrict format, va_list arg);
int vsprintf(char * __restrict s, const char * __restrict format,
					va_list arg);
int vsscanf(char * __restrict s, const char * __restrict format,
				   va_list arg);
**********************************************************************/
#ifdef L_fgetc

/* Reentrancy handled by UNLOCKED() macro. */

UNLOCKED(int,fgetc,(FILE *stream),(stream))
{
	unsigned char buf[1];

#ifdef __STDIO_WIDE

	return (fread(buf, (size_t) 1, (size_t) 1, stream) > 0) ? *buf : EOF;

#else  /* __STDIO_WIDE */

	return (_stdio_fread(buf, (size_t) 1, stream) > 0) ? *buf : EOF;

#endif /* __STDIO_WIDE */
}

#endif
/**********************************************************************/
#ifdef L_fgets

/* Reentrancy handled by UNLOCKED() macro. */

UNLOCKED(char *,fgets,
		 (char *__restrict s, int n, register FILE * __restrict stream),
		 (s, n, stream))
{
	register char *p;
	int c;

	p = s;
	while ((n > 1) && ((c = getc(stream)) != EOF) && ((*p++ = c) != '\n')) {
		--n;
	}
	if (p == s) {
		/* TODO -- should we set errno? */
/*  		if (n <= 0) { */
/*  			errno = EINVAL; */
/*  		} */
		return NULL;
	}
	*p = 0;
	return s;
}

#endif
/**********************************************************************/
#ifdef L_fputc

/* Reentrancy handled by UNLOCKED() macro. */

UNLOCKED(int,fputc,(int c, FILE *stream),(c,stream))
{
	unsigned char buf[1];

	*buf = (unsigned char) c;

#ifdef __STDIO_WIDE

	return (fwrite(buf, (size_t) 1, (size_t) 1, stream) > 0) ? (*buf) : EOF;

#else  /* __STDIO_WIDE */

	return (_stdio_fwrite(buf, (size_t) 1, stream) > 0) ? (*buf) : EOF;

#endif /* __STDIO_WIDE */
}
#endif
/**********************************************************************/
#ifdef L_fputs

/* Reentrancy handled by UNLOCKED() macro. */

UNLOCKED(int,fputs,
		 (register const char * __restrict s, FILE * __restrict stream),
		 (s, stream))
{
	size_t n = strlen(s);

#ifdef __STDIO_WIDE

	return (fwrite(s, n, (size_t) 1, stream) > 0) ? n : EOF;

#else  /* __STDIO_WIDE */

	return (_stdio_fwrite(s, n, stream) == n) ? n : EOF;

#endif /* __STDIO_WIDE */
}

#endif
/**********************************************************************/
#ifdef L_getc
#undef getc

/* Reentrancy handled by UNLOCKED() macro. */

UNLOCKED(int,getc,(register FILE *stream),(stream))
{
	return __GETC(stream);		/* Invoke the macro. */
}

#endif
/**********************************************************************/
#ifdef L_getchar
#undef getchar					/* Just in case. */

/* Reentrancy handled by UNLOCKED() macro. */

UNLOCKED_STREAM(int,getchar,(void),(),stdin)
{
	register FILE *stream = stdin; /* This helps bcc optimize. */

	return __GETC(stream);
}

#endif
/**********************************************************************/
#ifdef L_gets

link_warning(gets, "the 'gets' function is dangerous and should not be used.")

/* Reentrant. */

char *gets(char *s)				/* WARNING!!! UNSAFE FUNCTION!!! */
{
	register FILE *stream = stdin;	/* This helps bcc optimize. */
	register char *p = s;
	int c;

	__STDIO_THREADLOCK(stream);

	/* Note: don't worry about performance here... this shouldn't be used!
	 * Therefore, force actual function call. */
	while (((c = (getc_unlocked)(stream)) != EOF) && ((*p = c) != '\n')) {
		++p;
	}
	if ((c == EOF) || (s == p)) {
		s = NULL;
	} else {
		*p = 0;
	}

	__STDIO_THREADUNLOCK(stream);

	return s;
}

#endif
/**********************************************************************/
#ifdef L_putc
#undef putc

/* Reentrancy handled by UNLOCKED() macro. */

UNLOCKED(int,putc,(int c, register FILE *stream),(c,stream))
{
	return __PUTC(c, stream);	/* Invoke the macro. */
}

#endif
/**********************************************************************/
#ifdef L_putchar
#undef putchar					/* Just in case. */

/* Reentrancy handled by UNLOCKED() macro. */

UNLOCKED_STREAM(int,putchar,(int c),(c),stdout)
{
	register FILE *stream = stdout; /* This helps bcc optimize. */

	return __PUTC(c, stream);
}

#endif
/**********************************************************************/
#ifdef L_puts

/* Reentrant. */

int puts(register const char *s)
{
	register FILE *stream = stdout; /* This helps bcc optimize. */
	int n;

	__STDIO_THREADLOCK(stream);

	n = fputs_unlocked(s,stream) + 1;
	if (
#if 1
		fputc_unlocked('\n',stream)
#else
		fputs_unlocked("\n",stream)
#endif
		== EOF) {
		n = EOF;
	}

	__STDIO_THREADUNLOCK(stream);

	return n;
}

#endif
/**********************************************************************/
#ifdef L_ungetc
/*
 * Note: This is the application-callable ungetc.  If scanf calls this, it
 * should also set stream->ungot[1] to 0 if this is the only ungot.
 */

/* Reentrant. */

int ungetc(int c, register FILE *stream)
{
	__STDIO_THREADLOCK(stream);

	__stdio_validate_FILE(stream); /* debugging only */

#ifdef __STDIO_WIDE
	if (stream->modeflags & __FLAG_WIDE) {
		stream->modeflags |= __FLAG_ERROR;
		c = EOF;
		goto DONE;
	}
	stream->modeflags |= __FLAG_NARROW;
#endif /* __STDIO_WIDE */

	/* If can't read or there's been an error, or c == EOF, or ungot slots
	 * already filled, then return EOF */
	if ((stream->modeflags
		 & (__MASK_UNGOT2|__FLAG_WRITEONLY
#ifndef __STDIO_AUTO_RW_TRANSITION
			|__FLAG_WRITING		/* Note: technically no, but yes in spirit */
#endif /* __STDIO_AUTO_RW_TRANSITION */
			))
		|| ((stream->modeflags & __MASK_UNGOT1) && (stream->ungot[1]))
		|| (c == EOF) ) {
		c = EOF;
		goto DONE;;
	}

#ifdef __STDIO_BUFFERS
								/* TODO: shouldn't allow writing??? */
	if (stream->modeflags & __FLAG_WRITING) {
		fflush_unlocked(stream); /* Commit any write-buffered chars. */
	}
#endif /* __STDIO_BUFFERS */

	/* Clear EOF and WRITING flags, and set READING FLAG */
	stream->modeflags &= ~(__FLAG_EOF|__FLAG_WRITING);
	stream->modeflags |= __FLAG_READING;
	stream->ungot[1] = 1;		/* Flag as app ungetc call; scanf fixes up. */
	stream->ungot[(stream->modeflags++) & __MASK_UNGOT] = c;

#ifdef __STDIO_GETC_MACRO
	stream->bufgetc = stream->bufstart;	/* Must disable getc macro. */
#endif

	__stdio_validate_FILE(stream); /* debugging only */

 DONE:
	__STDIO_THREADUNLOCK(stream);

	return c;
}

#endif
/**********************************************************************/
#ifdef L_fread
/* NOTE: Surely ptr cannot point to a buffer of size > SIZE_MAX.
 * Therefore, we treat the case size * nmemb > SIZE_MAX as an error,
 * and include an assert() for it. */

/* Reentrancy handled by UNLOCKED() macro. */

UNLOCKED(size_t,fread,
		 (void * __restrict ptr, size_t size, size_t nmemb,
		  FILE * __restrict stream),
		 (ptr,size,nmemb,stream))
{
#ifdef __STDIO_WIDE
	if (stream->modeflags & __FLAG_WIDE) {
		stream->modeflags |= __FLAG_ERROR;
		/* TODO -- errno?  it this correct? */
		return 0;
	}
	stream->modeflags |= __FLAG_NARROW;
#endif /* __STDIO_WIDE */

	return (size == 0)
		? 0
		: (	assert( ((size_t)(-1)) / size >= nmemb ),
			_stdio_fread(ptr, nmemb * size, stream) / size );
}

#endif
/**********************************************************************/
#ifdef L_fwrite
/* NOTE: Surely ptr cannot point to a buffer of size > SIZE_MAX.
 * Therefore, we treat the case size * nmemb > SIZE_MAX as an error,
 * and include an assert() for it. */

/* Reentrancy handled by UNLOCKED() macro. */

UNLOCKED(size_t,fwrite,
		 (const void * __restrict ptr, size_t size, size_t nmemb,
		  FILE * __restrict stream),
		 (ptr,size,nmemb,stream))
{
#ifdef __STDIO_WIDE
	if (stream->modeflags & __FLAG_WIDE) {
		stream->modeflags |= __FLAG_ERROR;
		/* TODO -- errno?  it this correct? */
		return 0;
	}
	stream->modeflags |= __FLAG_NARROW;
#endif /* __STDIO_WIDE */

	return (size == 0)
		? 0
		: (	assert( ((size_t)(-1)) / size >= nmemb ),
			_stdio_fwrite(ptr, nmemb * size, stream) / size );
}

#endif
/**********************************************************************/
#if defined(L_fgetpos) || defined(L_fgetpos64)

/* Reentrant -- fgetpos() and fgetpos64(). */

#if defined(L_fgetpos) && defined(L_fgetpos64)
#error L_fgetpos and L_fgetpos64 are defined simultaneously!
#endif

#ifndef L_fgetpos64
#define fgetpos64	fgetpos
#define fpos64_t	fpos_t
#define ftello64	ftell
#endif


int fgetpos64(FILE * __restrict stream, register fpos64_t * __restrict pos)
{
#ifdef __STDIO_MBSTATE
	int retval;

	__STDIO_THREADLOCK(stream);

	retval = ((pos != NULL) && ((pos->__pos = ftello64(stream)) >= 0))
		? (__COPY_MBSTATE(&(pos->__mbstate), &(stream->state)), 0)
		: (__set_errno(EINVAL), -1);

	__STDIO_THREADUNLOCK(stream);

	return retval;
#else
	return ((pos != NULL) && ((pos->__pos = ftello64(stream)) >= 0))
		? 0 : (__set_errno(EINVAL), -1);
#endif
}

#ifndef L_fgetpos64
#undef fgetpos64
#undef fpos64_t
#undef ftello64
#endif

#endif
/**********************************************************************/
#ifdef L_fseek
strong_alias(fseek,fseeko);
#endif

#if defined(L_fseek) && defined(__STDIO_LARGE_FILES)

int fseek(register FILE *stream, long int offset, int whence)
{
	return fseeko64(stream, offset, whence);
}

#endif

#if defined(L_fseeko64) || (defined(L_fseek) && !defined(__STDIO_LARGE_FILES))

#ifndef L_fseeko64
#define fseeko64	fseek
#define __off64_t	long int
#endif

/* Reentrant -- fseek(), fseeko(), fseeko64() */

int fseeko64(register FILE *stream, __off64_t offset, int whence)
{
#if SEEK_SET != 0 || SEEK_CUR != 1 || SEEK_END != 2
#error Assumption violated -- values of SEEK_SET, SEEK_CUR, SEEK_END
#endif
	__offmax_t pos[1];
	int retval;

	if ( ((unsigned int) whence) > 2 ) {
		__set_errno(EINVAL);
		return -1;
	}

	__STDIO_THREADLOCK(stream);

	__stdio_validate_FILE(stream); /* debugging only */

	retval = -1;
	*pos = offset;
	if (
#ifdef __STDIO_BUFFERS
		/* First commit any pending buffered writes. */
		((stream->modeflags & __FLAG_WRITING) && fflush_unlocked(stream)) ||
#endif /* __STDIO_BUFFERS */
		((whence == SEEK_CUR) && (_stdio_adjpos(stream, pos) < 0))
		|| (_stdio_lseek(stream, pos, whence) < 0)
		) {
		__stdio_validate_FILE(stream); /* debugging only */
		goto DONE;
	}

#ifdef __STDIO_BUFFERS
	/* only needed if reading but do it anyway to avoid test */
#ifdef __STDIO_GETC_MACRO
	stream->bufgetc =			/* Must disable getc. */
#endif
	stream->bufpos = stream->bufread = stream->bufstart;
#endif /* __STDIO_BUFFERS */

	stream->modeflags &=
		~(__FLAG_READING|__FLAG_WRITING|__FLAG_EOF|__MASK_UNGOT);

#ifdef __STDIO_MBSTATE
	/* TODO: don't clear state if don't move? */
	__INIT_MBSTATE(&(stream->state));
#endif /* __STDIO_MBSTATE */
	__stdio_validate_FILE(stream); /* debugging only */

	retval = 0;

 DONE:
	__STDIO_THREADUNLOCK(stream);

	return retval;
}

#ifndef L_fseeko64
#undef fseeko64
#undef __off64_t
#endif

#endif
/**********************************************************************/
#if defined(L_fsetpos) || defined(L_fsetpos64)

#if defined(L_fsetpos) && defined(L_fsetpos64)
#error L_fsetpos and L_fsetpos64 are defined simultaneously!
#endif

#ifndef L_fsetpos64
#define fsetpos64	fsetpos
#define fpos64_t	fpos_t
#define fseeko64	fseek
#endif

/* Reentrant -- fgetpos{64}() through fseek{64}(). */

int fsetpos64(FILE *stream, register const fpos64_t *pos)
{
	if (!pos) {
		__set_errno(EINVAL);
		return EOF;
	}
#ifdef __STDIO_MBSTATE
	{
		int retval;

		__STDIO_THREADLOCK(stream);

		if ((retval = fseeko64(stream, pos->__pos, SEEK_SET)) == 0) {
			__COPY_MBSTATE(&(stream->state), &(pos->__mbstate));
		}

		__STDIO_THREADUNLOCK(stream);

		return retval;
	}
#else  /* __STDIO_MBSTATE */
	return fseeko64(stream, pos->__pos, SEEK_SET);
#endif /* __STDIO_MBSTATE */
}

#ifndef L_fsetpos64
#undef fsetpos64
#undef fpos64_t
#undef fseeko64
#endif

#endif
/**********************************************************************/
#ifdef L_ftell
strong_alias(ftell,ftello);
#endif

#if defined(L_ftell) && defined(__STDIO_LARGE_FILES)
long int ftell(register FILE *stream)
{
	__offmax_t pos = ftello64(stream);

	return (pos == ((long int) pos)) ? pos : (__set_errno(EOVERFLOW), -1);
}
#endif

#if defined(L_ftello64) || (defined(L_ftell) && !defined(__STDIO_LARGE_FILES))

#ifndef L_ftello64
#define ftello64	ftell
#define __off64_t	long int
#endif

/* Reentrant -- ftell, ftello, ftello64. */

__off64_t ftello64(register FILE *stream)
{
	__offmax_t pos[1];
	__off64_t retval;

	__STDIO_THREADLOCK(stream);

	retval = (((*pos = 0), (_stdio_lseek(stream, pos, SEEK_CUR) < 0))
			  || (_stdio_adjpos(stream, pos) < 0)) ? -1 : *pos;

	__STDIO_THREADUNLOCK(stream);

	return retval;
}

#ifndef L_ftello64
#undef ftello64
#undef __off64_t
#endif

#endif
/**********************************************************************/
#ifdef L_rewind

void rewind(register FILE *stream)
{
	__STDIO_THREADLOCK(stream);

	__CLEARERR(stream);			/* Clear errors first and then seek */
	fseek(stream, 0L, SEEK_SET); /* in case there is an error seeking. */
#ifdef __STDIO_MBSTATE
	/* TODO: Is it correct to re-init the stream's state?  I think so... */
	__INIT_MBSTATE(&(stream->state));
#endif /* __STDIO_MBSTATE */

	__STDIO_THREADUNLOCK(stream);
}

#endif
/**********************************************************************/
#ifdef L_clearerr
#undef clearerr

/* Reentrancy handled by UNLOCKED_VOID_RETURN() macro. */

UNLOCKED_VOID_RETURN(clearerr,(FILE *stream),(stream))
{
	__CLEARERR(stream);
}

#endif
/**********************************************************************/
#ifdef L_feof
#undef feof

/* Reentrancy handled by UNLOCKED() macro. */

UNLOCKED(int,feof,(FILE *stream),(stream))
{
	return __FEOF(stream);
}

#endif
/**********************************************************************/
#ifdef L_ferror
#undef ferror

/* Reentrancy handled by UNLOCKED() macro. */

UNLOCKED(int,ferror,(FILE *stream),(stream))
{
	return __FERROR(stream);
}

#endif
/**********************************************************************/
#ifdef L_perror

void perror(register const char *s)
{
	/* If the program is calling perror, it's a safe bet that printf and
	 * friends are used as well.  It is also possible that the calling
	 * program could buffer stderr, or reassign it. */

	register const char *sep;

	sep = ": ";
	if (!(s && *s)) {			/* Caller did not supply a prefix message */
		s = (sep += 2);			/* or passed an empty string. */
	}

#if 1
#ifdef __STDIO_PRINTF_M_SPEC
	fprintf(stderr, "%s%s%m\n", s, sep); /* Use the gnu %m feature. */
#else
	{
		char buf[64];
		fprintf(stderr, "%s%s%s\n", s, sep,
				_glibc_strerror_r(errno, buf, sizeof(buf)));
	}
#endif
#else
	/* Note: Assumes stderr not closed or buffered. */
	{
		char buf[64];

		__STDIO_THREADLOCK(stderr);
		_stdio_fdout(STDERR_FILENO, s, sep,
					 _glibc_strerror_r(errno, buf, sizeof(buf)));
		__STDIO_THREADUNLOCK(stderr);
	}
#endif
}

#endif
/**********************************************************************/
/* UTILITY funcs */
/**********************************************************************/
#ifdef L__stdio_fdout

/* Not reentrant -- TODO: lock associated stream if a know file descriptor? */

void _stdio_fdout(int fd, ...)
{
	va_list arg;
	register const char *p;

	va_start(arg, fd);
	while ((p = va_arg(arg, const char *)) != NULL) {
		write(fd, p, strlen(p));
	}
	va_end(arg);
}

#endif
/**********************************************************************/
#ifdef L__uintmaxtostr

/* Avoid using long long / and % operations to cut down dependencies on
 * libgcc.a.  Definitely helps on i386 at least. */
#if (UINTMAX_MAX > UINT_MAX) && ((UINTMAX_MAX/UINT_MAX) - 2 <= UINT_MAX)
#define INTERNAL_DIV_MOD
#endif

char *_uintmaxtostr(register char * __restrict bufend, uintmax_t uval,
					int base, __UIM_CASE alphacase)
{
    int negative;
    unsigned int digit;
#ifdef INTERNAL_DIV_MOD
	unsigned int H, L, high, low, rh;
#endif

	negative = 0;
	if (base < 0) {				/* signed value */
		base = -base;
		if (uval > INTMAX_MAX) {
			uval = -uval;
			negative = 1;
		}
	}

	/* this is an internal routine -- we shouldn't need to check this */
	assert(!((base < 2) || (base > 36)));

    *bufend = '\0';

#ifndef INTERNAL_DIV_MOD
    do {
		digit = uval % base;
		uval /= base;

		*--bufend = ( (digit < 10) ? digit + '0' : digit + alphacase );
    } while (uval);

#else  /* ************************************************** */

	H = (UINT_MAX / base);
	L = UINT_MAX % base + 1;
	if (L == base) {
		++H;
		L = 0;
	}
	low = (unsigned int) uval;
	high = (unsigned int) (uval >> (sizeof(unsigned int) * CHAR_BIT));

    do {
		rh = high % base;
		high /= base;
		digit = (low % base) + (L * rh);
		low = (low / base) + (H * rh) + (digit / base);
		digit %= base;
		
		*--bufend = ( (digit < 10) ? digit + '0' : digit + alphacase );
    } while (low | high);

#endif /******************************************************/

    if (negative) {
		*--bufend = '-';
    }

    return bufend;
}
#undef INTERNAL_DIV_MOD

#endif
/**********************************************************************/