diff options
Diffstat (limited to 'libc/stdio/_stdio.h')
| -rw-r--r-- | libc/stdio/_stdio.h | 436 |
1 files changed, 436 insertions, 0 deletions
diff --git a/libc/stdio/_stdio.h b/libc/stdio/_stdio.h new file mode 100644 index 000000000..aedcc526a --- /dev/null +++ b/libc/stdio/_stdio.h @@ -0,0 +1,436 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@codepoet.org> + * + * GNU Library General Public License (LGPL) version 2 or later. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ + +#define _GNU_SOURCE + +#include <assert.h> +#include <errno.h> +#include <fcntl.h> +#include <limits.h> +#include <signal.h> +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +#ifdef __UCLIBC_HAS_WCHAR__ +#include <wchar.h> +#endif + +#ifdef __UCLIBC_HAS_THREADS__ +#include <pthread.h> + +#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) + +#else + +#define __STDIO_THREADLOCK_OPENLIST ((void)0) +#define __STDIO_THREADUNLOCK_OPENLIST ((void)0) + +#endif + +#define __UNDEFINED_OR_NONPORTABLE ((void)0) + +/**********************************************************************/ +#ifdef __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__ + +extern __ssize_t _cs_read(void *cookie, char *buf, size_t bufsize); +extern __ssize_t _cs_write(void *cookie, const char *buf, size_t bufsize); +extern int _cs_seek(void *cookie, __offmax_t *pos, int whence); +extern int _cs_close(void *cookie); + +#define __STDIO_STREAM_RESET_GCS(S) \ + (S)->__cookie = &((S)->__filedes); \ + (S)->__gcs.read = _cs_read; \ + (S)->__gcs.write = _cs_write; \ + (S)->__gcs.seek = _cs_seek; \ + (S)->__gcs.close = _cs_close + + +#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 __SEEK(STREAMPTR,PPOS,WHENCE) \ + ((((STREAMPTR)->__gcs.seek) == NULL) ? -1 : \ + (((STREAMPTR)->__gcs.seek)((STREAMPTR)->__cookie,(PPOS),(WHENCE)))) +#define __CLOSE(STREAMPTR) \ + ((((STREAMPTR)->__gcs.close) == NULL) ? 0 : \ + (((STREAMPTR)->__gcs.close)((STREAMPTR)->__cookie))) + +#else /* __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__ */ + +#define __STDIO_STREAM_RESET_GCS(S) ((void)0) + +#define __READ(STREAMPTR,BUF,SIZE) \ + (read((STREAMPTR)->__filedes,(BUF),(SIZE))) +#define __WRITE(STREAMPTR,BUF,SIZE) \ + (write((STREAMPTR)->__filedes,(BUF),(SIZE))) +#define __SEEK(STREAMPTR,PPOS,WHENCE) \ + (__stdio_seek((STREAMPTR),(PPOS),(WHENCE))) +#define __CLOSE(STREAMPTR) \ + (close((STREAMPTR)->__filedes)) + +#endif /* __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__ */ + +/**********************************************************************/ +#ifdef __UCLIBC_HAS_WCHAR__ + +#define __STDIO_STREAM_TRANS_TO_WRITE(S,O) __stdio_trans2w_o((S), (O)) +#define __STDIO_STREAM_TRANS_TO_READ(S,O) __stdio_trans2r_o((S), (O)) + +#else + +#define __STDIO_STREAM_TRANS_TO_WRITE(S,O) __stdio_trans2w((S)) +#define __STDIO_STREAM_TRANS_TO_READ(S,O) __stdio_trans2r((S)) + +#endif +/**********************************************************************/ + +#define __STDIO_STREAM_IS_READING(S) ((S)->__modeflags & __MASK_READING) +#define __STDIO_STREAM_IS_WRITING(S) ((S)->__modeflags & __FLAG_WRITING) + +#define __STDIO_STREAM_SET_READING(S) ((S)->__modeflags |= __FLAG_READING) +#define __STDIO_STREAM_SET_WRITING(S) ((S)->__modeflags |= __FLAG_WRITING) + +#define __STDIO_STREAM_IS_READING_OR_READONLY(S) \ + ((S)->__modeflags & (__MASK_READING|__FLAG_READONLY)) + +#define __STDIO_STREAM_IS_WRITING_OR_WRITEONLY(S) \ + ((S)->__modeflags & (__FLAG_WRITING|__FLAG_WRITEONLY)) + +#define __STDIO_STREAM_IS_READONLY(S) ((S)->__modeflags & __FLAG_READONLY) +#define __STDIO_STREAM_IS_WRITEONLY(S) ((S)->__modeflags & __FLAG_WRITEONLY) + + +/**********************************************************************/ +#ifdef __UCLIBC_HAS_WCHAR__ + +#define __STDIO_STREAM_IS_NARROW_WRITING(S) \ + (((S)->__modeflags & (__FLAG_WRITING|__FLAG_NARROW)) \ + == (__FLAG_WRITING|__FLAG_NARROW)) + +#define __STDIO_STREAM_IS_WIDE_WRITING(S) \ + (((S)->__modeflags & (__FLAG_WRITING|__FLAG_WIDE)) \ + == (__FLAG_WRITING|__FLAG_WIDE)) + +#if (__FLAG_NARROW <= __MASK_READING) +#error assumption violated regarding __FLAG_NARROW +#endif + +#define __STDIO_STREAM_IS_NARROW_READING(S) \ + (((S)->__modeflags & (__MASK_READING|__FLAG_NARROW)) > __FLAG_NARROW) + +#define __STDIO_STREAM_IS_WIDE_READING(S) \ + (((S)->__modeflags & (__MASK_READING|__FLAG_WIDE)) > __FLAG_WIDE) + +#define __STDIO_STREAM_IS_NARROW(S) ((S)->__modeflags & __FLAG_NARROW) +#define __STDIO_STREAM_IS_WIDE(S) ((S)->__modeflags & __FLAG_WIDE) + +#define __STDIO_STREAM_SET_NARROW(S) \ + ((void)((S)->__modeflags |= __FLAG_NARROW)) +#define __STDIO_STREAM_SET_WIDE(S) \ + ((void)((S)->__modeflags |= __FLAG_WIDE)) + +#else + +#define __STDIO_STREAM_IS_NARROW_WRITING(S) __STDIO_STREAM_IS_WRITING(S) + +#define __STDIO_STREAM_IS_NARROW_READING(S) __STDIO_STREAM_IS_READING(S) + +#define __STDIO_STREAM_IS_NARROW(S) (1) +#define __STDIO_STREAM_IS_WIDE(S) (0) + +#define __STDIO_STREAM_SET_NARROW(S) ((void)0) +#define __STDIO_STREAM_SET_WIDE(S) ((void)0) + +#endif +/**********************************************************************/ + +#define __STDIO_STREAM_SET_EOF(S) \ + ((void)((S)->__modeflags |= __FLAG_EOF)) +#define __STDIO_STREAM_SET_ERROR(S) \ + ((void)((S)->__modeflags |= __FLAG_ERROR)) + +#define __STDIO_STREAM_CLEAR_EOF(S) \ + ((void)((S)->__modeflags &= ~__FLAG_EOF)) +#define __STDIO_STREAM_CLEAR_ERROR(S) \ + ((void)((S)->__modeflags &= ~__FLAG_ERROR)) + +#define __STDIO_STREAM_CLEAR_READING_AND_UNGOTS(S) \ + ((void)((S)->__modeflags &= ~__MASK_READING)) +#define __STDIO_STREAM_CLEAR_WRITING(S) \ + ((void)((S)->__modeflags &= ~__FLAG_WRITING)) + +#ifdef __UCLIBC_HAS_STDIO_GETC_MACRO__ +# define __STDIO_STREAM_DISABLE_GETC(S) \ + ((void)((S)->__bufgetc_u = (S)->__bufstart)) +# define __STDIO_STREAM_ENABLE_GETC(S) \ + ((void)((S)->__bufgetc_u = (S)->__bufread)) +# define __STDIO_STREAM_CAN_USE_BUFFER_GET(S) \ + ((S)->__bufpos < (S)->__bufgetc_u) +#else +# define __STDIO_STREAM_DISABLE_GETC(S) ((void)0) +# define __STDIO_STREAM_ENABLE_GETC(S) ((void)0) +# define __STDIO_STREAM_CAN_USE_BUFFER_GET(S) (0) +#endif + +#ifdef __UCLIBC_HAS_STDIO_PUTC_MACRO__ +# define __STDIO_STREAM_DISABLE_PUTC(S) \ + ((void)((S)->__bufputc_u = (S)->__bufstart)) +# define __STDIO_STREAM_ENABLE_PUTC(S) \ + ((void)((S)->__bufputc_u = (S)->__bufend)) +# define __STDIO_STREAM_CAN_USE_BUFFER_ADD(S) \ + ((S)->__bufpos < (S)->__bufputc_u) +#else +# define __STDIO_STREAM_DISABLE_PUTC(S) ((void)0) +# define __STDIO_STREAM_ENABLE_PUTC(S) ((void)0) +# define __STDIO_STREAM_CAN_USE_BUFFER_ADD(S) (0) +#endif + +#ifdef __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__ +#define __STDIO_STREAM_IS_CUSTOM(S) ((S)->__cookie != &((S)->__filedes)) +#else +#define __STDIO_STREAM_IS_CUSTOM(S) (0) +#endif + +/**********************************************************************/ + +#ifdef __STDIO_BUFFERS +#define __STDIO_STREAM_FREE_BUFFER(S) \ + do { if ((S)->__modeflags & __FLAG_FREEBUF) free((S)->__bufstart); } while (0) +#else +#define __STDIO_STREAM_FREE_BUFFER(S) ((void)0) +#endif + +#define __STDIO_STREAM_FREE_FILE(S) \ + do { if ((S)->__modeflags & __FLAG_FREEFILE) free((S)); } while (0) + + +#ifdef __UCLIBC_HAS_LFS__ +#define __STDIO_WHEN_LFS(E) E +#else +#define __STDIO_WHEN_LFS(E) ((void)0) +#endif + +/**********************************************************************/ +/* The following return 0 on success. */ + +#ifdef __STDIO_BUFFERS +/* Assume stream in valid writing state. Do not reset writing flag + * or disble putc macro unless error. */ +/* Should we assume that buffer is not empty to avoid a check? */ +extern size_t __stdio_wcommit(FILE *__restrict stream); + +/* Remember to fail if at EOF! */ +extern size_t __stdio_rfill(FILE *__restrict stream); + +extern size_t __stdio_fwrite(const unsigned char *__restrict buffer, + size_t bytes, FILE *__restrict stream); +#else + +#define __stdio_fwrite(B,N,S) __stdio_WRITE((S),(B),(N)) + +#endif + +extern size_t __stdio_WRITE(FILE *stream, const unsigned char *buf, + size_t bufsize); +extern size_t __stdio_READ(FILE *stream, unsigned char *buf, size_t bufsize); + +extern int __stdio_trans2r(FILE *__restrict stream); +extern int __stdio_trans2w(FILE *__restrict stream); + +extern int __stdio_trans2r_o(FILE *__restrict stream, int oflag); +extern int __stdio_trans2w_o(FILE *__restrict stream, int oflag); + +/**********************************************************************/ +#ifdef __STDIO_BUFFERS + +#define __STDIO_STREAM_IS_FBF(S) (!((S)->__modeflags & __MASK_BUFMODE)) +#define __STDIO_STREAM_IS_LBF(S) ((S)->__modeflags & __FLAG_LBF) +#define __STDIO_STREAM_IS_NBF(S) ((S)->__modeflags & __FLAG_NBF) + +#define __STDIO_STREAM_BUFFER_SIZE(S) ((S)->__bufend - (S)->__bufstart) + +/* Valid when writing... */ +#define __STDIO_STREAM_BUFFER_ADD(S,C) (*(S)->__bufpos++ = (C)) +#define __STDIO_STREAM_BUFFER_UNADD(S) (--(S)->__bufpos) +#define __STDIO_STREAM_BUFFER_WAVAIL(S) ((S)->__bufend - (S)->__bufpos) +#define __STDIO_STREAM_BUFFER_WUSED(S) ((S)->__bufpos - (S)->__bufstart) +#define __STDIO_COMMIT_WRITE_BUFFER(S) __stdio_wcommit((S)) +#ifdef __UCLIBC_HAS_WCHAR__ +#define __STDIO_STREAM_IS_NARROW_FBF(S) \ + (!((S)->__modeflags & (__MASK_BUFMODE|__FLAG_WIDE))) +#else +#define __STDIO_STREAM_IS_NARROW_FBF(S) __STDIO_STREAM_IS_FBF((S)) +#endif + +/* Valid when reading... */ +#define __STDIO_STREAM_BUFFER_RAVAIL(S) ((S)->__bufread - (S)->__bufpos) +#define __STDIO_STREAM_BUFFER_GET(S) (*(S)->__bufpos++) +#define __STDIO_FILL_READ_BUFFER(S) __stdio_rfill((S)) + +#define __STDIO_STREAM_INIT_BUFREAD_BUFPOS(S) \ + (S)->__bufread = (S)->__bufpos = (S)->__bufstart + + +#define __STDIO_STREAM_FAKE_VSNPRINTF_FILEDES (-2) +#define __STDIO_STREAM_FAKE_VSSCANF_FILEDES (-2) +#define __STDIO_STREAM_FAKE_VSWPRINTF_FILEDES (-3) +#define __STDIO_STREAM_FAKE_VSWSCANF_FILEDES (-3) + +#define __STDIO_STREAM_IS_FAKE_VSNPRINTF(S) \ + ((S)->__filedes == __STDIO_STREAM_FAKE_VSNPRINTF_FILEDES) +#define __STDIO_STREAM_IS_FAKE_VSSCANF(S) \ + ((S)->__filedes == __STDIO_STREAM_FAKE_VSSCANF_FILEDES) +#define __STDIO_STREAM_IS_FAKE_VSWPRINTF(S) \ + ((S)->__filedes == __STDIO_STREAM_FAKE_VSWPRINTF_FILEDES) +#define __STDIO_STREAM_IS_FAKE_VSWSCANF(S) \ + ((S)->__filedes == __STDIO_STREAM_FAKE_VSWSCANF_FILEDES) + +#else /* __STDIO_BUFFERS */ + +#define __STDIO_STREAM_IS_FBF(S) (0) +#define __STDIO_STREAM_IS_LBF(S) (0) +#define __STDIO_STREAM_IS_NBF(S) (1) + +#define __STDIO_STREAM_BUFFER_SIZE(S) (0) +#define __STDIO_STREAM_BUFFER_ADD(S,C) ((void)0) +#define __STDIO_STREAM_BUFFER_UNADD(S) ((void)0) +#define __STDIO_STREAM_BUFFER_WAVAIL(S) (0) +#define __STDIO_STREAM_BUFFER_WUSED(S) (0) +#define __STDIO_COMMIT_WRITE_BUFFER(S) (0) +#define __STDIO_STREAM_IS_NARROW_FBF(S) (0) + +#define __STDIO_STREAM_BUFFER_RAVAIL(S) (0) +#define __STDIO_STREAM_BUFFER_GET(S) (EOF) +#define __STDIO_FILL_READ_BUFFER(S) (0) +#define __STDIO_STREAM_INIT_BUFREAD_BUFPOS(S) ((void)0) + +#undef __STDIO_STREAM_FAKE_VSNPRINTF_FILEDES +#undef __STDIO_STREAM_FAKE_VSSCANF_FILEDES +#undef __STDIO_STREAM_FAKE_VSWPRINTF_FILEDES + +#define __STDIO_STREAM_IS_FAKE_VSNPRINTF(S) (0) +#define __STDIO_STREAM_IS_FAKE_VSSCANF(S) (0) +#undef __STDIO_STREAM_IS_FAKE_VSWPRINTF + +# ifdef __USE_OLD_VFPRINTF__ +# define __STDIO_STREAM_FAKE_VSNPRINTF_FILEDES_NB (-2) +# define __STDIO_STREAM_IS_FAKE_VSNPRINTF_NB(S) \ + ((S)->__filedes == __STDIO_STREAM_FAKE_VSNPRINTF_FILEDES_NB) +# endif + +# ifndef __UCLIBC_HAS_WCHAR__ +# define __STDIO_STREAM_FAKE_VSSCANF_FILEDES_NB (-2) +# define __STDIO_STREAM_IS_FAKE_VSSCANF_NB(S) \ + ((S)->__filedes == __STDIO_STREAM_FAKE_VSSCANF_FILEDES_NB) +# endif + +#endif /* __STDIO_BUFFERS */ +/**********************************************************************/ + +extern int __fputs_unlocked(const char *__restrict s, FILE *__restrict stream); + +extern int __putchar_unlocked(int c); + + +extern size_t __fwrite_unlocked(const void *__restrict ptr, size_t size, + size_t nmemb, FILE *__restrict stream); + +extern size_t __fread_unlocked(void *__restrict ptr, size_t size, + size_t nmemb, FILE *__restrict stream); + +extern int __fputc_unlocked(int c, FILE *stream); + +extern int __fflush_unlocked(FILE *stream); + +extern int __stdio_adjust_position(FILE *__restrict stream, __offmax_t *pos); + +extern void __clearerr_unlocked(FILE *stream); +extern int __feof_unlocked(FILE *stream); +extern int __ferror_unlocked(FILE *stream); + +extern int __fgetc_unlocked(FILE *stream); +extern char *__fgets_unlocked(char *__restrict s, int n, + FILE * __restrict stream); + +extern int __fileno_unlocked(FILE *stream); + +extern int __getchar_unlocked(void); + +#ifdef __UCLIBC_HAS_LFS__ +extern int __fseeko64(FILE *stream, __off64_t offset, int whence); +extern __off64_t __ftello64(FILE *stream); +#endif + +#ifdef __STDIO_HAS_OPENLIST + /* Uses an implementation hack!!! */ +#define __STDIO_FLUSH_LBF_STREAMS __fflush_unlocked((FILE *) &_stdio_openlist) +#else +#define __STDIO_FLUSH_LBF_STREAMS ((void)0) +#endif + +#ifdef NDEBUG +#define __STDIO_STREAM_VALIDATE(S) ((void)0) +#else +extern void _stdio_validate_FILE(const FILE *stream); +#define __STDIO_STREAM_VALIDATE(S) _stdio_validate_FILE((S)) +#endif + +#ifdef __STDIO_MBSTATE +#define __COPY_MBSTATE(dest,src) \ + ((void)((dest)->__mask = (src)->__mask, (dest)->__wc = (src)->__wc)) +#define __INIT_MBSTATE(dest) ((void)((dest)->__mask = 0)) +#else +#define __COPY_MBSTATE(dest,src) ((void)0) +#define __INIT_MBSTATE(dest) ((void)0) +#endif + +/**********************************************************************/ + +extern int _stdio_adjpos(FILE *__restrict stream, __offmax_t * pos); +extern int _stdio_lseek(FILE *stream, __offmax_t *pos, int whence); + +extern size_t _stdio_fwrite(const unsigned char *buffer, size_t bytes, + FILE *stream); +extern size_t _stdio_fread(unsigned char *buffer, size_t bytes, + FILE *stream); + +extern FILE *_stdio_fopen(intptr_t fname_or_mode, + const char *__restrict mode, + FILE *__restrict stream, int filedes); + +#ifdef __UCLIBC_HAS_WCHAR__ +extern size_t _wstdio_fwrite(const wchar_t *__restrict ws, size_t n, + FILE *__restrict stream); + +extern wint_t __fgetwc_unlocked(register FILE *stream); +extern wint_t __fputwc_unlocked(wchar_t wc, FILE *stream); +#endif + +/**********************************************************************/ +/* Only use the macro below if you know fp is a valid FILE for a valid fd. + * This is _not_ true for custom streams! */ +#define __FILENO_UNLOCKED(fp) ((fp)->__filedes) + +#define __FEOF_OR_FERROR_UNLOCKED(stream) \ + ((stream)->__modeflags & (__FLAG_EOF|__FLAG_ERROR)) + +#if defined(__STDIO_BUFFERS) || defined(__USE_OLD_VFPRINTF__) || defined(__UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__) +#define __STDIO_HAS_VSNPRINTF 1 +#endif |