diff options
Diffstat (limited to 'newlib/libc/stdio/open_memstream.c')
| -rw-r--r-- | newlib/libc/stdio/open_memstream.c | 330 |
1 files changed, 330 insertions, 0 deletions
diff --git a/newlib/libc/stdio/open_memstream.c b/newlib/libc/stdio/open_memstream.c new file mode 100644 index 000000000..6a0680fbd --- /dev/null +++ b/newlib/libc/stdio/open_memstream.c @@ -0,0 +1,330 @@ +/* Copyright (C) 2007 Eric Blake + * Permission to use, copy, modify, and distribute this software + * is freely granted, provided that this notice is preserved. + */ + +/* +FUNCTION +<<open_memstream>>---open a write stream around an arbitrary-length string + +INDEX + open_memstream + +ANSI_SYNOPSIS + #include <stdio.h> + FILE *open_memstream(char **restrict <[buf]>, + size_t *restrict <[size]>); + +DESCRIPTION +<<open_memstream>> creates a seekable <<FILE>> stream that wraps an +arbitrary-length buffer, created as if by <<malloc>>. The current +contents of *<[buf]> are ignored; this implementation uses *<[size]> +as a hint of the maximum size expected, but does not fail if the hint +was wrong. The parameters <[buf]> and <[size]> are later stored +through following any call to <<fflush>> or <<fclose>>, set to the +current address and usable size of the allocated string; although +after fflush, the pointer is only valid until another stream operation +that results in a write. Behavior is undefined if the user alters +either *<[buf]> or *<[size]> prior to <<fclose>>. + +The stream is write-only, since the user can directly read *<[buf]> +after a flush; see <<fmemopen>> for a way to wrap a string with a +readable stream. The user is responsible for calling <<free>> on +the final *<[buf]> after <<fclose>>. + +Any time the stream is flushed, a NUL byte is written at the current +position (but is not counted in the buffer length), so that the string +is always NUL-terminated after at most *<[size]> bytes. However, data +previously written beyond the current stream offset is not lost, and +the NUL byte written during a flush is restored to its previous value +when seeking elsewhere in the string. + +RETURNS +The return value is an open FILE pointer on success. On error, +<<NULL>> is returned, and <<errno>> will be set to EINVAL if <[buf]> +or <[size]> is NULL, ENOMEM if memory could not be allocated, or +EMFILE if too many streams are already open. + +PORTABILITY +This function is being added to POSIX 200x, but is not in POSIX 2001. + +Supporting OS subroutines required: <<sbrk>>. +*/ + +#include <stdio.h> +#include <errno.h> +#include <string.h> +#include <sys/lock.h> +#include "local.h" + +#ifndef __LARGE64_FILES +# define OFF_T off_t +#else +# define OFF_T _off64_t +#endif + +/* Describe details of an open memstream. */ +typedef struct memstream { + void *storage; /* storage to free on close */ + char **pbuf; /* pointer to the current buffer */ + size_t *psize; /* pointer to the current size, smaller of pos or eof */ + size_t pos; /* current position */ + size_t eof; /* current file size */ + size_t max; /* current malloc buffer size, always > eof */ + char saved; /* saved character that lived at *psize before NUL */ +} memstream; + +/* Write up to non-zero N bytes of BUF into the stream described by COOKIE, + returning the number of bytes written or EOF on failure. */ +static _READ_WRITE_RETURN_TYPE +_DEFUN(memwriter, (ptr, cookie, buf, n), + struct _reent *ptr _AND + void *cookie _AND + const char *buf _AND + int n) +{ + memstream *c = (memstream *) cookie; + char *cbuf = *c->pbuf; + + /* size_t is unsigned, but off_t is signed. Don't let stream get so + big that user cannot do ftello. */ + if (sizeof (OFF_T) == sizeof (size_t) && (ssize_t) (c->pos + n) < 0) + { + ptr->_errno = EFBIG; + return EOF; + } + /* Grow the buffer, if necessary. Choose a geometric growth factor + to avoid quadratic realloc behavior, but use a rate less than + (1+sqrt(5))/2 to accomodate malloc overhead. Overallocate, so + that we can add a trailing \0 without reallocating. The new + allocation should thus be max(prev_size*1.5, c->pos+n+1). */ + if (c->pos + n >= c->max) + { + size_t newsize = c->max * 3 / 2; + if (newsize < c->pos + n + 1) + newsize = c->pos + n + 1; + cbuf = _realloc_r (ptr, cbuf, newsize); + if (! cbuf) + return EOF; /* errno already set to ENOMEM */ + *c->pbuf = cbuf; + c->max = newsize; + } + /* If we have previously done a seek beyond eof, ensure all + intermediate bytes are NUL. */ + if (c->pos > c->eof) + memset (cbuf + c->eof, '\0', c->pos - c->eof); + memcpy (cbuf + c->pos, buf, n); + c->pos += n; + /* If the user has previously written further, remember what the + trailing NUL is overwriting. Otherwise, extend the stream. */ + if (c->pos > c->eof) + c->eof = c->pos; + else + c->saved = cbuf[c->pos]; + cbuf[c->pos] = '\0'; + *c->psize = c->pos; + return n; +} + +/* Seek to position POS relative to WHENCE within stream described by + COOKIE; return resulting position or fail with EOF. */ +static _fpos_t +_DEFUN(memseeker, (ptr, cookie, pos, whence), + struct _reent *ptr _AND + void *cookie _AND + _fpos_t pos _AND + int whence) +{ + memstream *c = (memstream *) cookie; + OFF_T offset = (OFF_T) pos; + + if (whence == SEEK_CUR) + offset += c->pos; + else if (whence == SEEK_END) + offset += c->eof; + if (offset < 0) + { + ptr->_errno = EINVAL; + offset = -1; + } + else if ((size_t) offset != offset) + { + ptr->_errno = ENOSPC; + offset = -1; + } +#ifdef __LARGE64_FILES + else if ((_fpos_t) offset != offset) + { + ptr->_errno = EOVERFLOW; + offset = -1; + } +#endif /* __LARGE64_FILES */ + else + { + if (c->pos < c->eof) + { + (*c->pbuf)[c->pos] = c->saved; + c->saved = '\0'; + } + c->pos = offset; + if (c->pos < c->eof) + { + c->saved = (*c->pbuf)[c->pos]; + (*c->pbuf)[c->pos] = '\0'; + *c->psize = c->pos; + } + else + *c->psize = c->eof; + } + return (_fpos_t) offset; +} + +/* Seek to position POS relative to WHENCE within stream described by + COOKIE; return resulting position or fail with EOF. */ +#ifdef __LARGE64_FILES +static _fpos64_t +_DEFUN(memseeker64, (ptr, cookie, pos, whence), + struct _reent *ptr _AND + void *cookie _AND + _fpos64_t pos _AND + int whence) +{ + _off64_t offset = (_off64_t) pos; + memstream *c = (memstream *) cookie; + + if (whence == SEEK_CUR) + offset += c->pos; + else if (whence == SEEK_END) + offset += c->eof; + if (offset < 0) + { + ptr->_errno = EINVAL; + offset = -1; + } + else if ((size_t) offset != offset) + { + ptr->_errno = ENOSPC; + offset = -1; + } + else + { + if (c->pos < c->eof) + { + (*c->pbuf)[c->pos] = c->saved; + c->saved = '\0'; + } + c->pos = offset; + if (c->pos < c->eof) + { + c->saved = (*c->pbuf)[c->pos]; + (*c->pbuf)[c->pos] = '\0'; + *c->psize = c->pos; + } + else + *c->psize = c->eof; + } + return (_fpos64_t) offset; +} +#endif /* __LARGE64_FILES */ + +/* Reclaim resources used by stream described by COOKIE. */ +static int +_DEFUN(memcloser, (ptr, cookie), + struct _reent *ptr _AND + void *cookie) +{ + memstream *c = (memstream *) cookie; + char *buf; + + /* Be nice and try to reduce any unused memory. */ + buf = _realloc_r (ptr, *c->pbuf, *c->psize + 1); + if (buf) + *c->pbuf = buf; + _free_r (ptr, c->storage); + return 0; +} + +/* Open a memstream that tracks a dynamic buffer in BUF and SIZE. + Return the new stream, or fail with NULL. */ +FILE * +_DEFUN(_open_memstream_r, (ptr, buf, size), + struct _reent *ptr _AND + char **buf _AND + size_t *size) +{ + FILE *fp; + memstream *c; + int flags; + + if (!buf || !size) + { + ptr->_errno = EINVAL; + return NULL; + } + if ((fp = __sfp (ptr)) == NULL) + return NULL; + if ((c = (memstream *) _malloc_r (ptr, sizeof *c)) == NULL) + { + __sfp_lock_acquire (); + fp->_flags = 0; /* release */ +#ifndef __SINGLE_THREAD__ + __lock_close_recursive (fp->_lock); +#endif + __sfp_lock_release (); + return NULL; + } + /* Use *size as a hint for initial sizing, but bound the initial + malloc between 64 bytes (same as asprintf, to avoid frequent + mallocs on small strings) and 64k bytes (to avoid overusing the + heap if *size was garbage). */ + c->max = *size; + if (c->max < 64) + c->max = 64; + else if (c->max > 64 * 1024) + c->max = 64 * 1024; + *size = 0; + *buf = _malloc_r (ptr, c->max); + if (!*buf) + { + __sfp_lock_acquire (); + fp->_flags = 0; /* release */ +#ifndef __SINGLE_THREAD__ + __lock_close_recursive (fp->_lock); +#endif + __sfp_lock_release (); + _free_r (ptr, c); + return NULL; + } + **buf = '\0'; + + c->storage = c; + c->pbuf = buf; + c->psize = size; + c->eof = 0; + c->saved = '\0'; + + _flockfile (fp); + fp->_file = -1; + fp->_flags = __SWR; + fp->_cookie = c; + fp->_read = NULL; + fp->_write = memwriter; + fp->_seek = memseeker; +#ifdef __LARGE64_FILES + fp->_seek64 = memseeker64; + fp->_flags |= __SL64; +#endif + fp->_close = memcloser; + _funlockfile (fp); + return fp; +} + +#ifndef _REENT_ONLY +FILE * +_DEFUN(open_memstream, (buf, size), + char **buf _AND + size_t *size) +{ + return _open_memstream_r (_REENT, buf, size); +} +#endif /* !_REENT_ONLY */ |