diff options
Diffstat (limited to 'libc')
132 files changed, 3024 insertions, 4715 deletions
diff --git a/libc/stdio/Makefile.in b/libc/stdio/Makefile.in index 3a6f739b4..5d4d74ed2 100644 --- a/libc/stdio/Makefile.in +++ b/libc/stdio/Makefile.in @@ -1,10 +1,12 @@ # Makefile for uClibc # # Copyright (C) 2000 by Lineo, inc. -# Copyright (C) 2004 Manuel Novoa III <mjn3@codepoet.org> -# Copyright (C) 2000-2005 Erik Andersen <andersen@uclibc.org> +# Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> +# Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> # -# Licensed under LGPL v2.1, see the file COPYING.LIB in this tarball for details. +# Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. +# +# Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. # # SUSv3 functions @@ -55,96 +57,51 @@ CUSRC := \ # putc_unlocked -> alias for fputc_unlocked # vfprintf and support functions -MSRC1 := vfprintf.c ifneq ($(USE_OLD_VFPRINTF),y) -MOBJ1 := \ - vfprintf.o \ - _ppfs_init.o _ppfs_prepargs.o _ppfs_setargs.o _ppfs_parsespec.o \ - register_printf_function.o parse_printf_format.o +VF_CSRC := \ + vfprintf.c \ + _ppfs_init.c _ppfs_prepargs.c _ppfs_setargs.c _ppfs_parsespec.c \ + register_printf_function.c parse_printf_format.c +CSRC += $(VF_CSRC) else -MOBJ1 := CSRC += old_vfprintf.c endif # vfscanf and support functions plus other *scanf funcs -MSRC2 := scanf.c -MOBJ2 := \ - vfscanf.o __scan_cookie.o __psfs_parse_spec.o __psfs_do_numeric.o \ - scanf.o sscanf.o fscanf.o vscanf.o vsscanf.o +CSRC += \ + vfscanf.c __scan_cookie.c __psfs_parse_spec.c __psfs_do_numeric.c \ + scanf.c sscanf.c fscanf.c vscanf.c vsscanf.c -CWSRC := ifeq ($(UCLIBC_HAS_WCHAR),y) -CWSRC += _wfwrite.c fwprintf.c swprintf.c vswprintf.c vwprintf.c wprintf.c \ +CSRC += _wfwrite.c fwprintf.c swprintf.c vswprintf.c vwprintf.c wprintf.c \ fwide.c ungetwc.c CUSRC += fgetwc.c getwchar.c fgetws.c fputwc.c putwchar.c fputws.c # getwc (fgetwc alias) getwc_unlocked (fgetwc_unlocked alias) # putwc (fputwc alias) putwc_unlocked (fputwc_unlocked alias) -MOBJ1 += vfwprintf.o -MOBJ2 += wscanf.o swscanf.o fwscanf.o vwscanf.o vswscanf.o vfwscanf.o +CSRC += vfwprintf.c +CSRC += wscanf.c swscanf.c fwscanf.c vwscanf.c vswscanf.c vfwscanf.c endif -CSRC += $(CUSRC) $(CWSRC) +CUSRC_UNLOCKED := $(patsubst %.c,%_unlocked.c,$(CUSRC)) -ifneq ($(DOMULTI),n) -STDIO_CSRC_NO_MULTI := fwrite.c fputc.c fputs.c fprintf.c _fpmaxtostr.c -CSRC := $(filter-out $(STDIO_CSRC_NO_MULTI),$(CSRC)) -endif -STDIO_MOBJ1_NO_MULTI := vfprintf.o vfwprintf.o register_printf_function.o -STDIO_MOBJ2_NO_MULTI := vfscanf.o vfwscanf.o fscanf.o -STDIO_MOBJ_NO_MULTI := $(STDIO_MOBJ1_NO_MULTI) $(STDIO_MOBJ2_NO_MULTI) +CSRC += $(CUSRC) $(CUSRC_UNLOCKED) STDIO_DIR := $(top_srcdir)libc/stdio STDIO_OUT := $(top_builddir)libc/stdio STDIO_SRC := $(patsubst %.c,$(STDIO_DIR)/%.c,$(CSRC)) STDIO_OBJ := $(patsubst %.c,$(STDIO_OUT)/%.o,$(CSRC)) -STDIO_CUSRC := $(patsubst %.c,$(STDIO_DIR)/%.c,$(CUSRC)) -STDIO_CUOBJ := $(patsubst %.c,$(STDIO_OUT)/%_unlocked.o,$(CUSRC)) - -STDIO_MSRC1 := $(patsubst %.c,$(STDIO_DIR)/%.c,$(MSRC1)) -STDIO_MSRC2 := $(patsubst %.c,$(STDIO_DIR)/%.c,$(MSRC2)) -STDIO_MOBJ1 := $(patsubst %.o,$(STDIO_OUT)/%.o,$(MOBJ1)) -STDIO_MOBJ2 := $(patsubst %.o,$(STDIO_OUT)/%.o,$(MOBJ2)) - -STDIO_MSRC := $(STDIO_MSRC1) $(STDIO_MSRC2) -STDIO_MOBJ := $(STDIO_MOBJ1) $(STDIO_MOBJ2) - -STDIO_DEF := $(patsubst %,-DL_%,$(subst .o,,$(filter-out $(STDIO_MOBJ_NO_MULTI),$(notdir $(STDIO_MOBJ))))) - -STDIO_OBJS := $(STDIO_OBJ) $(STDIO_MOBJ) $(STDIO_CUOBJ) - -STDIO_NO_MULTI := $(STDIO_CUOBJ) - -# these need special handling or rewrite to support multi-build -# CUOBJ -%_unlocked.o: %.c - $(compile.c) -D__DO_UNLOCKED -%_unlocked.os: %.c - $(compile.c) -D__DO_UNLOCKED +libc-y += $(STDIO_OBJ) -$(STDIO_MOBJ1): $(STDIO_MSRC1) - $(compile.m) - -$(STDIO_MOBJ1:.o=.os): $(STDIO_MSRC1) - $(compile.m) - -$(STDIO_MOBJ2): $(STDIO_MSRC2) - $(compile.m) - -$(STDIO_MOBJ2:.o=.os): $(STDIO_MSRC2) - $(compile.m) - -libc-a-y+=$(STDIO_OBJS) -libc-so-y+=$(STDIO_OBJS:.o=.os) - -CFLAGS-multi-y+=$(STDIO_DEF) -libc-multi-y+=$(STDIO_SRC) $(STDIO_MSRC) -libc-nomulti-y+=$(STDIO_NO_MULTI) -libc-nomulti-y+=$(patsubst %.c,$(STDIO_OUT)/%.o,$(STDIO_CSRC_NO_MULTI)) -libc-nomulti-y+=$(patsubst %.o,$(STDIO_OUT)/%.o,$(STDIO_MOBJ_NO_MULTI)) +ifneq ($(USE_OLD_VFPRINTF),y) +libc-nomulti-y += $(patsubst %.c,$(STDIO_OUT)/%.o,$(VF_CSRC)) +endif +ifeq ($(UCLIBC_HAS_WCHAR),y) +libc-nomulti-y += $(STDIO_OUT)/vfwprintf.o $(STDIO_OUT)/vfwscanf.o +endif -objclean-y+=stdio_objclean +objclean-y += stdio_objclean stdio_objclean: - $(RM) $(STDIO_OUT)/*.{o,os} + $(RM) $(STDIO_OUT)/*.{o,os,oS} diff --git a/libc/stdio/_READ.c b/libc/stdio/_READ.c index e27309c11..0c7febb3c 100644 --- a/libc/stdio/_READ.c +++ b/libc/stdio/_READ.c @@ -5,10 +5,11 @@ * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. */ -#define read __read - #include "_stdio.h" +libc_hidden_proto(read) +libc_hidden_proto(abort) + /* Given a reading stream without its end-of-file indicator set and * with no buffered input or ungots, read at most 'bufsize' bytes * into 'buf' (which may be the stream's __bufstart). diff --git a/libc/stdio/_WRITE.c b/libc/stdio/_WRITE.c index c2b0e7b5d..2bd0977fd 100644 --- a/libc/stdio/_WRITE.c +++ b/libc/stdio/_WRITE.c @@ -5,10 +5,10 @@ * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. */ -#define write __write - #include "_stdio.h" +libc_hidden_proto(write) + /* Given a writing stream with no buffered output, write the * data in 'buf' (which may be the stream's bufstart) of size * 'bufsize' to the stream. If a write error occurs, set the diff --git a/libc/stdio/__fsetlocking.c b/libc/stdio/__fsetlocking.c index 5b6070cc3..746a098f9 100644 --- a/libc/stdio/__fsetlocking.c +++ b/libc/stdio/__fsetlocking.c @@ -8,6 +8,11 @@ #include "_stdio.h" #include <stdio_ext.h> +libc_hidden_proto(__fsetlocking) +#ifdef __UCLIBC_HAS_THREADS__ +libc_hidden_proto(_stdio_user_locking) +#endif + /* Not threadsafe. */ /* Notes: @@ -15,7 +20,7 @@ * glibc treats invalid locking_mode args as FSETLOCKING_INTERNAL. */ -int attribute_hidden __fsetlocking_internal(FILE *stream, int locking_mode) +int __fsetlocking(FILE *stream, int locking_mode) { #ifdef __UCLIBC_HAS_THREADS__ int current = 1 + (stream->__user_locking & 1); @@ -43,5 +48,4 @@ int attribute_hidden __fsetlocking_internal(FILE *stream, int locking_mode) return FSETLOCKING_INTERNAL; #endif } - -strong_alias(__fsetlocking_internal,__fsetlocking) +libc_hidden_def(__fsetlocking) diff --git a/libc/stdio/__psfs_do_numeric.c b/libc/stdio/__psfs_do_numeric.c new file mode 100644 index 000000000..e3714776c --- /dev/null +++ b/libc/stdio/__psfs_do_numeric.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define L___psfs_do_numeric +#include "_scanf.c" diff --git a/libc/stdio/__psfs_parse_spec.c b/libc/stdio/__psfs_parse_spec.c new file mode 100644 index 000000000..cac9cda46 --- /dev/null +++ b/libc/stdio/__psfs_parse_spec.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define L___psfs_parse_spec +#include "_scanf.c" diff --git a/libc/stdio/__scan_cookie.c b/libc/stdio/__scan_cookie.c new file mode 100644 index 000000000..d5d53c4c5 --- /dev/null +++ b/libc/stdio/__scan_cookie.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define L___scan_cookie +#include "_scanf.c" diff --git a/libc/stdio/_cs_funcs.c b/libc/stdio/_cs_funcs.c index ef92048c0..38a8351e5 100644 --- a/libc/stdio/_cs_funcs.c +++ b/libc/stdio/_cs_funcs.c @@ -7,20 +7,29 @@ #include "_stdio.h" +libc_hidden_proto(read) +libc_hidden_proto(write) +libc_hidden_proto(close) +#ifdef __UCLIBC_HAS_LFS__ +libc_hidden_proto(lseek64) +#else +libc_hidden_proto(lseek) +#endif + /**********************************************************************/ #ifdef __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__ /**********************************************************************/ ssize_t attribute_hidden _cs_read(void *cookie, char *buf, size_t bufsize) { - return __read(*((int *) cookie), buf, bufsize); + return read(*((int *) cookie), buf, bufsize); } /**********************************************************************/ ssize_t attribute_hidden _cs_write(void *cookie, const char *buf, size_t bufsize) { - return __write(*((int *) cookie), (char *) buf, bufsize); + return write(*((int *) cookie), (char *) buf, bufsize); } /**********************************************************************/ @@ -30,9 +39,9 @@ int attribute_hidden _cs_seek(void *cookie, register __offmax_t *pos, int whence __offmax_t res; #ifdef __UCLIBC_HAS_LFS__ - res = __lseek64(*((int *) cookie), *pos, whence); + res = lseek64(*((int *) cookie), *pos, whence); #else - res = __lseek(*((int *) cookie), *pos, whence); + res = lseek(*((int *) cookie), *pos, whence); #endif return (res >= 0) ? ((*pos = res), 0) : ((int) res); @@ -42,7 +51,7 @@ int attribute_hidden _cs_seek(void *cookie, register __offmax_t *pos, int whence int attribute_hidden _cs_close(void *cookie) { - return __close(*((int *) cookie)); + return close(*((int *) cookie)); } /**********************************************************************/ @@ -54,9 +63,9 @@ int attribute_hidden __stdio_seek(FILE *stream, register __offmax_t *pos, int wh __offmax_t res; #ifdef __UCLIBC_HAS_LFS__ - res = __lseek64(stream->__filedes, *pos, whence); + res = lseek64(stream->__filedes, *pos, whence); #else - res = __lseek(stream->__filedes, *pos, whence); + res = lseek(stream->__filedes, *pos, whence); #endif return (res >= 0) ? ((*pos = res), 0) : ((int) res); diff --git a/libc/stdio/_flushlbf.c b/libc/stdio/_flushlbf.c index 31ed2fc55..8a551a746 100644 --- a/libc/stdio/_flushlbf.c +++ b/libc/stdio/_flushlbf.c @@ -8,6 +8,8 @@ #include "_stdio.h" #include <stdio_ext.h> +libc_hidden_proto(fflush_unlocked) + /* Solaris function -- * Flush all line buffered (writing) streams. */ diff --git a/libc/stdio/_fopen.c b/libc/stdio/_fopen.c index 33b7b89ad..4ca028275 100644 --- a/libc/stdio/_fopen.c +++ b/libc/stdio/_fopen.c @@ -5,10 +5,16 @@ * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. */ -#define isatty __isatty - #include "_stdio.h" +libc_hidden_proto(isatty) +libc_hidden_proto(open) +libc_hidden_proto(fcntl) + +#ifdef __UCLIBC_HAS_THREADS__ +libc_hidden_proto(_stdio_user_locking) +#endif + /* * Cases: * fopen64 : filename != NULL, stream == NULL, filedes == -2 @@ -100,12 +106,8 @@ FILE attribute_hidden *_stdio_fopen(intptr_t fname_or_mode, #ifdef __UCLIBC_HAS_THREADS__ /* We only initialize the mutex in the non-freopen case. */ /* stream->__user_locking = _stdio_user_locking; */ -#ifdef __USE_STDIO_FUTEXES__ - _IO_lock_init (stream->_lock); -#else __stdio_init_mutex(&stream->__lock); #endif -#endif } #ifdef __UCLIBC_MJN3_ONLY__ @@ -125,7 +127,7 @@ FILE attribute_hidden *_stdio_fopen(intptr_t fname_or_mode, /* NOTE: fopencookie needs changing if the basic check changes! */ if (((i & (((int) fname_or_mode) + 1)) != i) /* Basic agreement? */ || (((open_mode & ~((__mode_t) fname_or_mode)) & O_APPEND) - && __fcntl(filedes, F_SETFL, O_APPEND)) /* Need O_APPEND. */ + && fcntl(filedes, F_SETFL, O_APPEND)) /* Need O_APPEND. */ ) { goto DO_EINVAL; } @@ -134,7 +136,7 @@ FILE attribute_hidden *_stdio_fopen(intptr_t fname_or_mode, & O_LARGEFILE) ); } else { __STDIO_WHEN_LFS( if (filedes < -1) open_mode |= O_LARGEFILE ); - if ((stream->__filedes = __open(((const char *) fname_or_mode), + if ((stream->__filedes = open(((const char *) fname_or_mode), open_mode, 0666)) < 0) { goto FREE_STREAM; } @@ -196,12 +198,8 @@ FILE attribute_hidden *_stdio_fopen(intptr_t fname_or_mode, #ifdef __UCLIBC_HAS_THREADS__ /* Even in the freopen case, we reset the user locking flag. */ stream->__user_locking = _stdio_user_locking; -#ifdef __USE_STDIO_FUTEXES__ - /* _IO_lock_init (stream->_lock); */ -#else /* __stdio_init_mutex(&stream->__lock); */ #endif -#endif #ifdef __STDIO_HAS_OPENLIST __STDIO_THREADLOCK_OPENLIST; diff --git a/libc/stdio/_fpmaxtostr.c b/libc/stdio/_fpmaxtostr.c index 99fc9a9dd..9b87f64cf 100644 --- a/libc/stdio/_fpmaxtostr.c +++ b/libc/stdio/_fpmaxtostr.c @@ -11,6 +11,11 @@ #include <locale.h> #include <bits/uClibc_fpmax.h> +libc_hidden_proto(memset) +#ifdef __UCLIBC_HAS_LOCALE__ +libc_hidden_proto(__global_locale) +#endif + typedef size_t (__fp_outfunc_t)(FILE *fp, intptr_t type, intptr_t len, intptr_t buf); @@ -198,7 +203,9 @@ static const __fpmax_t exp16_table[] = { #define FPO_STR_WIDTH (0x80 | ' '); #define FPO_STR_PREC 'p' -ssize_t attribute_hidden _fpmaxtostr(FILE * fp, __fpmax_t x, struct printf_info *info, +ssize_t _fpmaxtostr(FILE * fp, __fpmax_t x, struct printf_info *info, + __fp_outfunc_t fp_outfunc) attribute_hidden; +ssize_t _fpmaxtostr(FILE * fp, __fpmax_t x, struct printf_info *info, __fp_outfunc_t fp_outfunc) { #ifdef __UCLIBC_HAS_HEXADECIMAL_FLOATS__ @@ -275,11 +282,11 @@ ssize_t attribute_hidden _fpmaxtostr(FILE * fp, __fpmax_t x, struct printf_info } if (x == 0) { /* Handle 0 now to avoid false positive. */ -#if 1 +#ifdef __UCLIBC_HAVE_SIGNED_ZERO__ if (zeroisnegative(x)) { /* Handle 'signed' zero. */ *sign_str = '-'; } -#endif +#endif /* __UCLIBC_HAVE_SIGNED_ZERO__ */ exp = -1; goto GENERATE_DIGITS; } @@ -417,7 +424,7 @@ ssize_t attribute_hidden _fpmaxtostr(FILE * fp, __fpmax_t x, struct printf_info if (mode == 'f') { round += exp; if (round < -1) { - __memset(buf, '0', DECIMAL_DIG); /* OK, since 'f' -> decimal case. */ + memset(buf, '0', DECIMAL_DIG); /* OK, since 'f' -> decimal case. */ exp = -1; round = -1; } diff --git a/libc/stdio/_fwrite.c b/libc/stdio/_fwrite.c index 600b15e6d..1e0f7ceee 100644 --- a/libc/stdio/_fwrite.c +++ b/libc/stdio/_fwrite.c @@ -5,11 +5,12 @@ * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. */ -#define memrchr __memrchr -#define memchr __memchr - #include "_stdio.h" +libc_hidden_proto(memchr) +libc_hidden_proto(memcpy) +libc_hidden_proto(memrchr) + #ifdef __STDIO_BUFFERS /* Either buffer data or (commit buffer if necessary and) write. */ @@ -35,7 +36,7 @@ size_t attribute_hidden __stdio_fwrite(const unsigned char * __restrict buffer, if (pending > bytes) { pending = bytes; } - __memcpy(stream->__bufpos, buffer, pending); + memcpy(stream->__bufpos, buffer, pending); stream->__bufpos += pending; __STDIO_STREAM_VALIDATE(stream); return bytes; @@ -43,7 +44,7 @@ size_t attribute_hidden __stdio_fwrite(const unsigned char * __restrict buffer, /* RETRY: */ if (bytes <= __STDIO_STREAM_BUFFER_WAVAIL(stream)) { - __memcpy(stream->__bufpos, buffer, bytes); + memcpy(stream->__bufpos, buffer, bytes); stream->__bufpos += bytes; if (__STDIO_STREAM_IS_LBF(stream) && memrchr(buffer, '\n', bytes) /* Search backwards. */ diff --git a/libc/stdio/_load_inttype.c b/libc/stdio/_load_inttype.c index e4dc61e9c..057f5f256 100644 --- a/libc/stdio/_load_inttype.c +++ b/libc/stdio/_load_inttype.c @@ -8,7 +8,8 @@ #include "_stdio.h" #include <printf.h> -uintmax_t attribute_hidden _load_inttype(int desttype, register const void *src, int uflag) +uintmax_t _load_inttype(int desttype, register const void *src, int uflag) attribute_hidden; +uintmax_t _load_inttype(int desttype, register const void *src, int uflag) { if (uflag >= 0) { /* unsigned */ #if LONG_MAX != INT_MAX diff --git a/libc/stdio/_ppfs_init.c b/libc/stdio/_ppfs_init.c new file mode 100644 index 000000000..80d8aeb96 --- /dev/null +++ b/libc/stdio/_ppfs_init.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define L__ppfs_init +#include "_vfprintf.c" diff --git a/libc/stdio/_ppfs_parsespec.c b/libc/stdio/_ppfs_parsespec.c new file mode 100644 index 000000000..a3e298801 --- /dev/null +++ b/libc/stdio/_ppfs_parsespec.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define L__ppfs_parsespec +#include "_vfprintf.c" diff --git a/libc/stdio/_ppfs_prepargs.c b/libc/stdio/_ppfs_prepargs.c new file mode 100644 index 000000000..a6efbf466 --- /dev/null +++ b/libc/stdio/_ppfs_prepargs.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define L__ppfs_prepargs +#include "_vfprintf.c" diff --git a/libc/stdio/_ppfs_setargs.c b/libc/stdio/_ppfs_setargs.c new file mode 100644 index 000000000..41214d993 --- /dev/null +++ b/libc/stdio/_ppfs_setargs.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define L__ppfs_setargs +#include "_vfprintf.c" diff --git a/libc/stdio/_stdio.c b/libc/stdio/_stdio.c index e8d90a800..a967bd0de 100644 --- a/libc/stdio/_stdio.c +++ b/libc/stdio/_stdio.c @@ -5,10 +5,11 @@ * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. */ -#define isatty __isatty - #include "_stdio.h" +libc_hidden_proto(memcpy) +libc_hidden_proto(isatty) + /* This is pretty much straight from uClibc, but with one important * difference. * @@ -129,12 +130,19 @@ static FILE _stdio_streams[] = { 0 ) }; +/* psm: moved to _stdio.h: libc_hidden_proto(stdin/stdout) */ FILE *stdin = _stdio_streams; +libc_hidden_data_def(stdin) FILE *stdout = _stdio_streams + 1; +libc_hidden_data_def(stdout) +libc_hidden_proto(stderr) FILE *stderr = _stdio_streams + 2; +libc_hidden_data_def(stderr) #ifdef __STDIO_GETC_MACRO +libc_hidden_proto(__stdin) FILE *__stdin = _stdio_streams; /* For getchar() macro. */ +libc_hidden_data_def(__stdin) #endif #ifdef __STDIO_PUTC_MACRO FILE *__stdout = _stdio_streams + 1; /* For putchar() macro. */ @@ -156,6 +164,7 @@ FILE *__stdout = _stdio_streams + 1; /* For putchar() macro. */ */ FILE *_stdio_openlist = _stdio_streams; +libc_hidden_data_def(_stdio_openlist) # ifdef __UCLIBC_HAS_THREADS__ # ifdef __USE_STDIO_FUTEXES__ @@ -164,6 +173,7 @@ _IO_lock_t _stdio_openlist_lock = _IO_lock_initializer; # else pthread_mutex_t _stdio_openlist_lock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP; # endif +libc_hidden_data_def(_stdio_openlist_lock) int _stdio_openlist_delflag = 0; # endif @@ -172,7 +182,9 @@ int _stdio_openlist_delflag = 0; #ifdef __UCLIBC_HAS_THREADS__ /* 2 if threading not initialized and 0 otherwise; */ +libc_hidden_proto(_stdio_user_locking) int _stdio_user_locking = 2; +libc_hidden_data_def(_stdio_user_locking) #ifndef __USE_STDIO_FUTEXES__ void attribute_hidden __stdio_init_mutex(pthread_mutex_t *m) @@ -180,7 +192,7 @@ void attribute_hidden __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)); + memcpy(m, &__stdio_mutex_initializer, sizeof(__stdio_mutex_initializer)); } #endif @@ -258,6 +270,7 @@ void attribute_hidden _stdio_term(void) #endif } +#if defined __STDIO_BUFFERS || !defined __UCLIBC__ void attribute_hidden _stdio_init(void) { #ifdef __STDIO_BUFFERS @@ -271,8 +284,9 @@ void attribute_hidden _stdio_init(void) /* _stdio_term is done automatically when exiting if stdio is used. * See misc/internals/__uClibc_main.c and and stdlib/atexit.c. */ atexit(_stdio_term); -#endif /* __UCLIBC__ */ +#endif } +#endif /**********************************************************************/ diff --git a/libc/stdio/_stdio.h b/libc/stdio/_stdio.h index 50229ffb0..83d43352b 100644 --- a/libc/stdio/_stdio.h +++ b/libc/stdio/_stdio.h @@ -5,8 +5,6 @@ * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. */ -#define _GNU_SOURCE - #include <features.h> #include <assert.h> #include <errno.h> @@ -18,51 +16,19 @@ #include <stdlib.h> #include <string.h> #include <unistd.h> - -extern int __vfprintf (FILE *__restrict __s, __const char *__restrict __format, - __gnuc_va_list __arg) attribute_hidden; - -extern int __vsnprintf (char *__restrict __s, size_t __maxlen, - __const char *__restrict __format, __gnuc_va_list __arg) - __THROW __attribute__ ((__format__ (__printf__, 3, 0))) attribute_hidden; - -extern int __vfscanf (FILE *__restrict __s, __const char *__restrict __format, - __gnuc_va_list __arg) - __attribute__ ((__format__ (__scanf__, 2, 0))) attribute_hidden; - -extern int __vsscanf (__const char *__restrict __s, - __const char *__restrict __format, __gnuc_va_list __arg) - __THROW __attribute__ ((__format__ (__scanf__, 2, 0))) attribute_hidden; - #ifdef __UCLIBC_HAS_WCHAR__ #include <wchar.h> +#endif -extern int __vfwprintf (__FILE *__restrict __s, - __const wchar_t *__restrict __format, - __gnuc_va_list __arg) attribute_hidden; - -extern int __vfwscanf (__FILE *__restrict __s, - __const wchar_t *__restrict __format, - __gnuc_va_list __arg) attribute_hidden; +libc_hidden_proto(stdin) +libc_hidden_proto(stdout) -extern int __vswscanf (__const wchar_t *__restrict __s, - __const wchar_t *__restrict __format, - __gnuc_va_list __arg) __THROW attribute_hidden; -#endif +libc_hidden_proto(_stdio_openlist) #ifdef __UCLIBC_HAS_THREADS__ #include <pthread.h> +libc_hidden_proto(_stdio_openlist_lock) -#ifdef __USE_STDIO_FUTEXES___ -#define __STDIO_THREADLOCK_OPENLIST \ - _IO_lock_lock(_stdio_openlist_lock) - -#define __STDIO_THREADUNLOCK_OPENLIST \ - _IO_lock_unlock(_stdio_openlist_lock) - -#define __STDIO_THREADTRYLOCK_OPENLIST \ - _IO_lock_trylock(_stdio_openlist_lock) -#else #define __STDIO_THREADLOCK_OPENLIST \ __pthread_mutex_lock(&_stdio_openlist_lock) @@ -71,9 +37,6 @@ extern int __vswscanf (__const wchar_t *__restrict __s, #define __STDIO_THREADTRYLOCK_OPENLIST \ __pthread_mutex_trylock(&_stdio_openlist_lock) -#endif - - #else @@ -300,8 +263,6 @@ extern int __stdio_trans2w(FILE *__restrict stream) attribute_hidden; extern int __stdio_trans2r_o(FILE *__restrict stream, int oflag) attribute_hidden; extern int __stdio_trans2w_o(FILE *__restrict stream, int oflag) attribute_hidden; -extern int __setvbuf (FILE *__restrict __stream, char *__restrict __buf, - int __modes, size_t __n) __THROW attribute_hidden; /**********************************************************************/ #ifdef __STDIO_BUFFERS @@ -389,46 +350,11 @@ extern int __setvbuf (FILE *__restrict __stream, char *__restrict __buf, #endif /* __STDIO_BUFFERS */ /**********************************************************************/ -extern int __fputs_unlocked(const char *__restrict s, FILE *__restrict stream) attribute_hidden; - -extern int __putchar_unlocked(int c); - - -extern size_t __fwrite_unlocked(const void *__restrict ptr, size_t size, - size_t nmemb, FILE *__restrict stream) attribute_hidden; - -extern size_t __fread_unlocked(void *__restrict ptr, size_t size, - size_t nmemb, FILE *__restrict stream) attribute_hidden; - -extern int __fputc_unlocked_internal(int c, FILE *stream) attribute_hidden; - -extern int __fflush_unlocked(FILE *stream) attribute_hidden; - extern int __stdio_adjust_position(FILE *__restrict stream, __offmax_t *pos) attribute_hidden; -extern void __clearerr_unlocked(FILE *stream); -extern int __feof_unlocked(FILE *stream); -extern int __ferror_unlocked(FILE *stream); - -extern int __fgetc_unlocked_internal(FILE *stream) attribute_hidden; -extern int __getc_unlocked(FILE *stream) attribute_hidden; -extern char *__fgets_unlocked(char *__restrict s, int n, - FILE * __restrict stream) attribute_hidden; - -extern int __fileno_unlocked(FILE *stream) attribute_hidden; - -extern int __getchar_unlocked(void) attribute_hidden; - -extern int __fseek(FILE *stream, long int offset, int whence) attribute_hidden; -extern long int __ftell(FILE *stream) attribute_hidden; -#ifdef __UCLIBC_HAS_LFS__ -extern int __fseeko64(FILE *stream, __off64_t offset, int whence) attribute_hidden; -extern __off64_t __ftello64(FILE *stream) attribute_hidden; -#endif - #ifdef __STDIO_HAS_OPENLIST /* Uses an implementation hack!!! */ -#define __STDIO_FLUSH_LBF_STREAMS __fflush_unlocked((FILE *) &_stdio_openlist) +#define __STDIO_FLUSH_LBF_STREAMS fflush_unlocked((FILE *) &_stdio_openlist) #else #define __STDIO_FLUSH_LBF_STREAMS ((void)0) #endif @@ -451,14 +377,6 @@ extern void _stdio_validate_FILE(const FILE *stream); /**********************************************************************/ -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) attribute_hidden; @@ -466,9 +384,6 @@ extern FILE *_stdio_fopen(intptr_t fname_or_mode, #ifdef __UCLIBC_HAS_WCHAR__ extern size_t _wstdio_fwrite(const wchar_t *__restrict ws, size_t n, FILE *__restrict stream) attribute_hidden; - -extern wint_t __fgetwc_unlocked(register FILE *stream) attribute_hidden; -extern wint_t __fputwc_unlocked(wchar_t wc, FILE *stream) attribute_hidden; #endif /**********************************************************************/ diff --git a/libc/stdio/_store_inttype.c b/libc/stdio/_store_inttype.c index 82fb894c6..6eb74fe86 100644 --- a/libc/stdio/_store_inttype.c +++ b/libc/stdio/_store_inttype.c @@ -28,7 +28,8 @@ /* We assume int may be short or long, but short and long are different. */ -void attribute_hidden _store_inttype(register void *dest, int desttype, uintmax_t val) +void _store_inttype(register void *dest, int desttype, uintmax_t val) attribute_hidden; +void _store_inttype(register void *dest, int desttype, uintmax_t val) { if (desttype == __PA_FLAG_CHAR) { /* assume char not int */ *((unsigned char *) dest) = val; diff --git a/libc/stdio/_trans2w.c b/libc/stdio/_trans2w.c index 650a5e1a0..ed1a583fc 100644 --- a/libc/stdio/_trans2w.c +++ b/libc/stdio/_trans2w.c @@ -7,6 +7,8 @@ #include "_stdio.h" +libc_hidden_proto(fseek) + /* Function to handle transition to writing. * Initialize or verify the stream's orientation (even if readonly). * Check that the stream is writable. @@ -64,7 +66,7 @@ int attribute_hidden __stdio_trans2w(FILE * __restrict stream) * the end even if not reading.*/ if (((__STDIO_STREAM_BUFFER_RAVAIL(stream)) || (stream->__modeflags & __FLAG_UNGOT)) - && __fseek(stream, 0L, + && fseek(stream, 0L, ((stream->__modeflags & __FLAG_APPEND) ? SEEK_END : SEEK_CUR)) ) { diff --git a/libc/stdio/_uintmaxtostr.c b/libc/stdio/_uintmaxtostr.c index bf92506d5..f9c83506e 100644 --- a/libc/stdio/_uintmaxtostr.c +++ b/libc/stdio/_uintmaxtostr.c @@ -11,6 +11,11 @@ #include <locale.h> #include <bits/uClibc_uintmaxtostr.h> +libc_hidden_proto(memcpy) +#ifdef __UCLIBC_HAS_LOCALE__ +libc_hidden_proto(__global_locale) +#endif + /* Avoid using long long / and % operations to cut down dependencies on * libgcc.a. Definitely helps on i386 at least. */ #if (INTMAX_MAX > INT_MAX) && (((INTMAX_MAX/INT_MAX)/2) - 2 <= INT_MAX) @@ -61,7 +66,7 @@ char attribute_hidden *_uintmaxtostr(register char * __restrict bufend, uintmax_ #ifndef __LOCALE_C_ONLY if (!grouping) { /* Finished a group. */ bufend -= __UCLIBC_CURLOCALE_DATA.thousands_sep_len; - __memcpy(bufend, __UCLIBC_CURLOCALE_DATA.thousands_sep, + memcpy(bufend, __UCLIBC_CURLOCALE_DATA.thousands_sep, __UCLIBC_CURLOCALE_DATA.thousands_sep_len); if (g[1] != 0) { /* g[1] == 0 means repeat last grouping. */ /* Note: g[1] == -1 means no further grouping. But since @@ -79,7 +84,7 @@ char attribute_hidden *_uintmaxtostr(register char * __restrict bufend, uintmax_ #ifndef __LOCALE_C_ONLY if (unlikely(outdigit)) { bufend -= __UCLIBC_CURLOCALE_DATA.outdigit_length[digit]; - __memcpy(bufend, + memcpy(bufend, (&__UCLIBC_CURLOCALE_DATA.outdigit0_mb)[digit], __UCLIBC_CURLOCALE_DATA.outdigit_length[digit]); } else @@ -104,7 +109,7 @@ char attribute_hidden *_uintmaxtostr(register char * __restrict bufend, uintmax_ #ifndef __LOCALE_C_ONLY if (!grouping) { /* Finished a group. */ bufend -= __UCLIBC_CURLOCALE_DATA.thousands_sep_len; - __memcpy(bufend, __UCLIBC_CURLOCALE_DATA.thousands_sep, + memcpy(bufend, __UCLIBC_CURLOCALE_DATA.thousands_sep, __UCLIBC_CURLOCALE_DATA.thousands_sep_len); if (g[1] != 0) { /* g[1] == 0 means repeat last grouping. */ /* Note: g[1] == -1 means no further grouping. But since @@ -131,7 +136,7 @@ char attribute_hidden *_uintmaxtostr(register char * __restrict bufend, uintmax_ #ifndef __LOCALE_C_ONLY if (unlikely(outdigit)) { bufend -= __UCLIBC_CURLOCALE_DATA.outdigit_length[digit]; - __memcpy(bufend, + memcpy(bufend, (&__UCLIBC_CURLOCALE_DATA.outdigit0_mb)[digit], __UCLIBC_CURLOCALE_DATA.outdigit_length[digit]); } else diff --git a/libc/stdio/_vfprintf.c b/libc/stdio/_vfprintf.c new file mode 100644 index 000000000..a32960f2e --- /dev/null +++ b/libc/stdio/_vfprintf.c @@ -0,0 +1,1951 @@ +/* Copyright (C) 2002-2004 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. + */ + +/* This code needs a lot of clean up. Some of that is on hold until uClibc + * gets a better configuration system (on Erik's todo list). + * The other cleanup will take place during the implementation/integration of + * the wide char (un)formatted i/o functions which I'm currently working on. + */ + +/* 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! */ + + +/* April 1, 2002 + * Initialize thread locks for fake files in vsnprintf and vdprintf. + * reported by Erik Andersen (andersen@codepoet.com) + * Fix an arg promotion handling bug in _do_one_spec for %c. + * reported by Ilguiz Latypov <ilatypov@superbt.com> + * + * May 10, 2002 + * Remove __isdigit and use new ctype.h version. + * Add conditional setting of QUAL_CHARS for size_t and ptrdiff_t. + * + * Aug 16, 2002 + * Fix two problems that showed up with the python 2.2.1 tests; one + * involving %o and one involving %f. + * + * Oct 28, 2002 + * Fix a problem in vasprintf (reported by vodz a while back) when built + * without custom stream support. In that case, it is necessary to do + * a va_copy. + * Make sure each va_copy has a matching va_end, as required by C99. + * + * Nov 4, 2002 + * Add locale-specific grouping support for integer decimal conversion. + * Add locale-specific decimal point support for floating point conversion. + * Note: grouping will have to wait for _dtostr() rewrite. + * Add printf wchar support for %lc (%C) and %ls (%S). + * Require printf format strings to be valid multibyte strings beginning and + * ending in their initial shift state, as per the stds. + * + * Nov 21, 2002 + * Add *wprintf functions. Currently they don't support floating point + * conversions. That will wait until the rewrite of _dtostr. + * + * Aug 1, 2003 + * Optional hexadecimal float notation support for %a/%A. + * Floating point output now works for *wprintf. + * Support for glibc locale-specific digit grouping for floats. + * Misc bug fixes. + * + * Aug 31, 2003 + * Fix precision bug for %g conversion specifier when using %f style. + * + * Sep 5, 2003 + * Implement *s*scanf for the non-buffered stdio case with old_vfprintf. + * + * Sep 23, 2003 + * vfprintf was not always checking for narrow stream orientation. + */ + +/* TODO: + * + * Should we validate that *printf format strings are valid multibyte + * strings in the current locale? ANSI/ISO C99 seems to imply this + * and Plauger's printf implementation in his Standard C Library book + * treats this as an error. + */ + +#define _ISOC99_SOURCE /* for ULLONG primarily... */ +#include <features.h> +#include "_stdio.h" +#include <stdlib.h> +#include <string.h> +#include <stddef.h> +#include <ctype.h> +#include <limits.h> +#include <stdarg.h> +#include <assert.h> +#include <stdint.h> +#include <errno.h> +#include <locale.h> + +#define __PRINTF_INFO_NO_BITFIELD +#include <printf.h> + +#ifdef __UCLIBC_HAS_THREADS__ +#include <stdio_ext.h> +#include <pthread.h> +#endif /* __UCLIBC_HAS_THREADS__ */ + +#ifdef __UCLIBC_HAS_WCHAR__ +#include <wchar.h> +#endif /* __UCLIBC_HAS_WCHAR__ */ + +#include <bits/uClibc_uintmaxtostr.h> +#include <bits/uClibc_va_copy.h> + +libc_hidden_proto(memcpy) +libc_hidden_proto(memset) +libc_hidden_proto(strlen) +libc_hidden_proto(strnlen) +libc_hidden_proto(__glibc_strerror_r) +libc_hidden_proto(fputs_unlocked) +libc_hidden_proto(abort) +#ifdef __UCLIBC_HAS_WCHAR__ +libc_hidden_proto(wcslen) +libc_hidden_proto(wcsnlen) +libc_hidden_proto(mbsrtowcs) +libc_hidden_proto(wcsrtombs) +libc_hidden_proto(btowc) +libc_hidden_proto(wcrtomb) +libc_hidden_proto(fputws) +#endif + +/* Some older or broken gcc toolchains define LONG_LONG_MAX but not + * LLONG_MAX. Since LLONG_MAX is part of the standard, that's what + * we use. So complain if we do not have it but should. + */ +#if !defined(LLONG_MAX) && defined(LONG_LONG_MAX) +#error Apparently, LONG_LONG_MAX is defined but LLONG_MAX is not. You need to fix your toolchain headers to support the standard macros for (unsigned) long long. +#endif + +/**********************************************************************/ +/* These provide some control over printf's feature set */ + +/* This is undefined below depeding on uClibc's configuration. */ +#define __STDIO_PRINTF_FLOAT 1 + +/* Now controlled by uClibc_stdio.h. */ +/* #define __UCLIBC_HAS_PRINTF_M_SPEC__ */ + + +/**********************************************************************/ + +#if defined(__UCLIBC__) && !defined(__UCLIBC_HAS_FLOATS__) +#undef __STDIO_PRINTF_FLOAT +#endif + +#ifdef __BCC__ +#undef __STDIO_PRINTF_FLOAT +#endif + +#ifdef __STDIO_PRINTF_FLOAT +#include <float.h> +#include <bits/uClibc_fpmax.h> +#else /* __STDIO_PRINTF_FLOAT */ +#undef L__fpmaxtostr +#endif /* __STDIO_PRINTF_FLOAT */ + + +#undef __STDIO_HAS_VSNPRINTF +#if defined(__STDIO_BUFFERS) || defined(__USE_OLD_VFPRINTF__) || defined(__UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__) +#define __STDIO_HAS_VSNPRINTF 1 +#endif + +/**********************************************************************/ + +/* Now controlled by uClibc_stdio.h. */ +/* #define __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ */ + +/* TODO -- move these to a configuration section? */ +#define MAX_FIELD_WIDTH 4095 + +#ifdef __UCLIBC_MJN3_ONLY__ +#ifdef L_register_printf_function +/* emit only once */ +#warning WISHLIST: Make MAX_USER_SPEC configurable? +#warning WISHLIST: Make MAX_ARGS_PER_SPEC configurable? +#endif +#endif /* __UCLIBC_MJN3_ONLY__ */ + +#ifdef __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ + +#define MAX_USER_SPEC 10 +#define MAX_ARGS_PER_SPEC 5 + +#else /* __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ */ + +#undef MAX_USER_SPEC +#define MAX_ARGS_PER_SPEC 1 + +#endif /* __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ */ + +#if MAX_ARGS_PER_SPEC < 1 +#error MAX_ARGS_PER_SPEC < 1! +#undef MAX_ARGS_PER_SPEC +#define MAX_ARGS_PER_SPEC 1 +#endif + +#if defined(NL_ARGMAX) && (NL_ARGMAX < 9) +#error NL_ARGMAX < 9! +#endif + +#if defined(NL_ARGMAX) && (NL_ARGMAX >= (MAX_ARGS_PER_SPEC + 2)) +#define MAX_ARGS NL_ARGMAX +#else +/* N for spec itself, plus 1 each for width and precision */ +#define MAX_ARGS (MAX_ARGS_PER_SPEC + 2) +#endif + +/**********************************************************************/ + +#define __PA_FLAG_INTMASK \ + (__PA_FLAG_CHAR|PA_FLAG_SHORT|__PA_FLAG_INT|PA_FLAG_LONG|PA_FLAG_LONG_LONG) + +#ifdef __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ +extern printf_function _custom_printf_handler[MAX_USER_SPEC] attribute_hidden; +extern printf_arginfo_function *_custom_printf_arginfo[MAX_USER_SPEC] attribute_hidden; +extern char *_custom_printf_spec attribute_hidden; +#endif /* __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ */ + +/**********************************************************************/ + +#define SPEC_FLAGS " +0-#'I" +enum { + FLAG_SPACE = 0x01, + FLAG_PLUS = 0x02, /* must be 2 * FLAG_SPACE */ + FLAG_ZERO = 0x04, + FLAG_MINUS = 0x08, /* must be 2 * FLAG_ZERO */ + FLAG_HASH = 0x10, + FLAG_THOUSANDS = 0x20, + FLAG_I18N = 0x40, /* only works for d, i, u */ + FLAG_WIDESTREAM = 0x80 +}; + +/**********************************************************************/ + +/* float layout 01234567890123456789 TODO: B?*/ +#define SPEC_CHARS "npxXoudifFeEgGaACScs" +enum { + CONV_n = 0, + CONV_p, + CONV_x, CONV_X, CONV_o, CONV_u, CONV_d, CONV_i, + CONV_f, CONV_F, CONV_e, CONV_E, CONV_g, CONV_G, CONV_a, CONV_A, + CONV_C, CONV_S, CONV_c, CONV_s, +#ifdef __UCLIBC_HAS_PRINTF_M_SPEC__ + CONV_m, +#endif + CONV_custom0 /* must be last */ +}; + +/* p x X o u d i */ +#define SPEC_BASE { 16, 16, 16, 8, 10, 10, 10 } + +#define SPEC_RANGES { CONV_n, CONV_p, CONV_i, CONV_A, \ + CONV_C, CONV_S, CONV_c, CONV_s, CONV_custom0 } + +#define SPEC_OR_MASK { \ + /* n */ (PA_FLAG_PTR|PA_INT), \ + /* p */ PA_POINTER, \ + /* oxXudi */ PA_INT, \ + /* fFeEgGaA */ PA_DOUBLE, \ + /* C */ PA_WCHAR, \ + /* S */ PA_WSTRING, \ + /* c */ PA_CHAR, \ + /* s */ PA_STRING, \ +} + +#define SPEC_AND_MASK { \ + /* n */ (PA_FLAG_PTR|__PA_INTMASK), \ + /* p */ PA_POINTER, \ + /* oxXudi */ (__PA_INTMASK), \ + /* fFeEgGaA */ (PA_FLAG_LONG_DOUBLE|PA_DOUBLE), \ + /* C */ (PA_WCHAR), \ + /* S */ (PA_WSTRING), \ + /* c */ (PA_CHAR), \ + /* s */ (PA_STRING), \ +} + +/**********************************************************************/ +/* + * In order to ease translation to what arginfo and _print_info._flags expect, + * we map: 0:int 1:char 2:longlong 4:long 8:short + * and then _flags |= (((q << 7) + q) & 0x701) and argtype |= (_flags & 0x701) + */ + +/* TODO -- Fix the table below to take into account stdint.h. */ +/* #ifndef LLONG_MAX */ +/* #error fix QUAL_CHARS for no long long! Affects 'L', 'j', 'q', 'll'. */ +/* #else */ +/* #if LLONG_MAX != INTMAX_MAX */ +/* #error fix QUAL_CHARS intmax_t entry 'j'! */ +/* #endif */ +/* #endif */ + +#ifdef PDS +#error PDS already defined! +#endif +#ifdef SS +#error SS already defined! +#endif +#ifdef IMS +#error IMS already defined! +#endif + +#if PTRDIFF_MAX == INT_MAX +#define PDS 0 +#elif PTRDIFF_MAX == LONG_MAX +#define PDS 4 +#elif defined(LLONG_MAX) && (PTRDIFF_MAX == LLONG_MAX) +#define PDS 8 +#else +#error fix QUAL_CHARS ptrdiff_t entry 't'! +#endif + +#if SIZE_MAX == UINT_MAX +#define SS 0 +#elif SIZE_MAX == ULONG_MAX +#define SS 4 +#elif defined(LLONG_MAX) && (SIZE_MAX == ULLONG_MAX) +#define SS 8 +#else +#error fix QUAL_CHARS size_t entries 'z', 'Z'! +#endif + +#if INTMAX_MAX == INT_MAX +#define IMS 0 +#elif INTMAX_MAX == LONG_MAX +#define IMS 4 +#elif defined(LLONG_MAX) && (INTMAX_MAX == LLONG_MAX) +#define IMS 8 +#else +#error fix QUAL_CHARS intmax_t entry 'j'! +#endif + +#define QUAL_CHARS { \ + /* j:(u)intmax_t z:(s)size_t t:ptrdiff_t \0:int */ \ + /* q:long_long Z:(s)size_t */ \ + 'h', 'l', 'L', 'j', 'z', 't', 'q', 'Z', 0, \ + 2, 4, 8, IMS, SS, PDS, 8, SS, 0, /* TODO -- fix!!! */\ + 1, 8 \ +} + +/**********************************************************************/ + +#ifdef __STDIO_VA_ARG_PTR +#ifdef __BCC__ +#define __va_arg_ptr(ap,type) (((type *)(ap += sizeof(type))) - 1) +#endif + +#if 1 +#ifdef __GNUC__ +/* TODO -- need other than for 386 as well! */ + +#ifndef __va_rounded_size +#define __va_rounded_size(TYPE) \ + (((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int)) +#endif +#define __va_arg_ptr(AP, TYPE) \ + (AP = (va_list) ((char *) (AP) + __va_rounded_size (TYPE)), \ + ((void *) ((char *) (AP) - __va_rounded_size (TYPE)))) +#endif +#endif +#endif /* __STDIO_VA_ARG_PTR */ + +#ifdef __va_arg_ptr +#define GET_VA_ARG(AP,F,TYPE,ARGS) (*(AP) = __va_arg_ptr(ARGS,TYPE)) +#define GET_ARG_VALUE(AP,F,TYPE) (*((TYPE *)(*(AP)))) +#else +typedef union { + wchar_t wc; + unsigned int u; + unsigned long ul; +#ifdef ULLONG_MAX + unsigned long long ull; +#endif +#ifdef __STDIO_PRINTF_FLOAT + double d; + long double ld; +#endif /* __STDIO_PRINTF_FLOAT */ + void *p; +} argvalue_t; + +#define GET_VA_ARG(AU,F,TYPE,ARGS) (AU->F = va_arg(ARGS,TYPE)) +#define GET_ARG_VALUE(AU,F,TYPE) ((TYPE)((AU)->F)) +#endif + +typedef struct { + const char *fmtpos; /* TODO: move below struct?? */ + struct printf_info info; +#ifdef NL_ARGMAX + int maxposarg; /* > 0 if args are positional, 0 if not, -1 if unknown */ +#endif /* NL_ARGMAX */ + int num_data_args; /* TODO: use sentinal??? */ + unsigned int conv_num; + unsigned char argnumber[4]; /* width | prec | 1st data | unused */ + int argtype[MAX_ARGS]; + va_list arg; +#ifdef __va_arg_ptr + void *argptr[MAX_ARGS]; +#else +/* if defined(NL_ARGMAX) || defined(__UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__) */ + /* While this is wasteful of space in the case where pos args aren't + * enabled, it is also needed to support custom printf handlers. */ + argvalue_t argvalue[MAX_ARGS]; +#endif +} ppfs_t; /* parse printf format state */ + +/**********************************************************************/ + +/* TODO: fix printf to return 0 and set errno if format error. Standard says + only returns -1 if sets error indicator for the stream. */ + +#ifdef __STDIO_PRINTF_FLOAT +typedef size_t (__fp_outfunc_t)(FILE *fp, intptr_t type, intptr_t len, + intptr_t buf); + +extern ssize_t _fpmaxtostr(FILE * fp, __fpmax_t x, struct printf_info *info, + __fp_outfunc_t fp_outfunc) attribute_hidden; +#endif + +extern int _ppfs_init(ppfs_t *ppfs, const char *fmt0) attribute_hidden; /* validates */ +extern void _ppfs_prepargs(ppfs_t *ppfs, va_list arg) attribute_hidden; /* sets posargptrs */ +extern void _ppfs_setargs(ppfs_t *ppfs) attribute_hidden; /* sets argptrs for current spec */ +extern int _ppfs_parsespec(ppfs_t *ppfs) attribute_hidden; /* parses specifier */ + +extern void _store_inttype(void *dest, int desttype, uintmax_t val) attribute_hidden; +extern uintmax_t _load_inttype(int desttype, const void *src, int uflag) attribute_hidden; + +/**********************************************************************/ +#ifdef L_parse_printf_format + +/* NOTE: This function differs from the glibc version in that parsing stops + * upon encountering an invalid conversion specifier. Since this is the way + * my printf functions work, I think it makes sense to do it that way here. + * Unfortunately, since glibc sets the return type as size_t, we have no way + * of returning that the template is illegal, other than returning 0. + */ + +size_t parse_printf_format(register const char *template, + size_t n, register int *argtypes) +{ + ppfs_t ppfs; + size_t i; + size_t count = 0; + + if (_ppfs_init(&ppfs, template) >= 0) { +#ifdef NL_ARGMAX + if (ppfs.maxposarg > 0) { /* Using positional args. */ + count = ppfs.maxposarg; + if (n > count) { + n = count; + } + for (i = 0 ; i < n ; i++) { + *argtypes++ = ppfs.argtype[i]; + } + } else { /* Not using positional args. */ +#endif /* NL_ARGMAX */ + while (*template) { + if ((*template == '%') && (*++template != '%')) { + ppfs.fmtpos = template; + _ppfs_parsespec(&ppfs); /* Can't fail. */ + template = ppfs.fmtpos; /* Update to one past spec end. */ + if (ppfs.info.width == INT_MIN) { + ++count; + if (n > 0) { + *argtypes++ = PA_INT; + --n; + } + } + if (ppfs.info.prec == INT_MIN) { + ++count; + if (n > 0) { + *argtypes++ = PA_INT; + --n; + } + } + for (i = 0 ; i < ppfs.num_data_args ; i++) { + if ((ppfs.argtype[i]) != __PA_NOARG) { + ++count; + if (n > 0) { + *argtypes++ = ppfs.argtype[i]; + --n; + } + } + } + } else { + ++template; + } + } +#ifdef NL_ARGMAX + } +#endif /* NL_ARGMAX */ + } + + return count; +} + +#endif +/**********************************************************************/ +#ifdef L__ppfs_init + +#ifdef __UCLIBC_HAS_LOCALE__ +libc_hidden_proto(__global_locale) +#endif + +int attribute_hidden _ppfs_init(register ppfs_t *ppfs, const char *fmt0) +{ + int r; + + /* First, zero out everything... argnumber[], argtype[], argptr[] */ + memset(ppfs, 0, sizeof(ppfs_t)); /* TODO: nonportable???? */ +#ifdef NL_ARGMAX + --ppfs->maxposarg; /* set to -1 */ +#endif /* NL_ARGMAX */ + ppfs->fmtpos = fmt0; +#ifdef __UCLIBC_MJN3_ONLY__ +#warning TODO: Make checking of the format string in C locale an option. +#endif +#ifdef __UCLIBC_HAS_LOCALE__ + /* To support old programs, don't check mb validity if in C locale. */ + if (((__UCLIBC_CURLOCALE_DATA).encoding) != __ctype_encoding_7_bit) { + /* ANSI/ISO C99 requires format string to be a valid multibyte string + * beginning and ending in its initial shift state. */ + static const char invalid_mbs[] = "Invalid multibyte format string."; + mbstate_t mbstate; + const char *p; + mbstate.__mask = 0; /* Initialize the mbstate. */ + p = fmt0; + if (mbsrtowcs(NULL, &p, SIZE_MAX, &mbstate) == ((size_t)(-1))) { + ppfs->fmtpos = invalid_mbs; + return -1; + } + } +#endif /* __UCLIBC_HAS_LOCALE__ */ + /* now set all argtypes to no-arg */ + { +#if 1 + /* TODO - use memset here since already "paid for"? */ + register int *p = ppfs->argtype; + + r = MAX_ARGS; + do { + *p++ = __PA_NOARG; + } while (--r); +#else + /* TODO -- get rid of this?? */ + register char *p = (char *) ((MAX_ARGS-1) * sizeof(int)); + + do { + *((int *)(((char *)ppfs) + ((int)p) + offsetof(ppfs_t,argtype))) = __PA_NOARG; + p -= sizeof(int); + } while (p); +#endif + } + + /* + * Run through the entire format string to validate it and initialize + * the positional arg numbers (if any). + */ + { + register const char *fmt = fmt0; + + while (*fmt) { + if ((*fmt == '%') && (*++fmt != '%')) { + ppfs->fmtpos = fmt; /* back up to the '%' */ + if ((r = _ppfs_parsespec(ppfs)) < 0) { + return -1; + } + fmt = ppfs->fmtpos; /* update to one past end of spec */ + } else { + ++fmt; + } + } + ppfs->fmtpos = fmt0; /* rewind */ + } + +#ifdef NL_MAX_ARG + /* If we have positional args, make sure we know all the types. */ + { + register int *p = ppfs->argtype; + r = ppfs->maxposarg; + while (--r >= 0) { + if ( *p == __PA_NOARG ) { /* missing arg type!!! */ + return -1; + } + ++p; + } + } +#endif /* NL_MAX_ARG */ + + return 0; +} +#endif +/**********************************************************************/ +#ifdef L__ppfs_prepargs +void attribute_hidden _ppfs_prepargs(register ppfs_t *ppfs, va_list arg) +{ + int i; + + va_copy(ppfs->arg, arg); + +#ifdef NL_ARGMAX + if ((i = ppfs->maxposarg) > 0) { /* init for positional args */ + ppfs->num_data_args = i; + ppfs->info.width = ppfs->info.prec = ppfs->maxposarg = 0; + _ppfs_setargs(ppfs); + ppfs->maxposarg = i; + } +#endif /* NL_ARGMAX */ +} +#endif +/**********************************************************************/ +#ifdef L__ppfs_setargs + +void attribute_hidden _ppfs_setargs(register ppfs_t *ppfs) +{ +#ifdef __va_arg_ptr + register void **p = ppfs->argptr; +#else + register argvalue_t *p = ppfs->argvalue; +#endif + int i; + +#ifdef NL_ARGMAX + if (ppfs->maxposarg == 0) { /* initing for or no pos args */ +#endif /* NL_ARGMAX */ + if (ppfs->info.width == INT_MIN) { + ppfs->info.width = +#ifdef __va_arg_ptr + *(int *) +#endif + GET_VA_ARG(p,u,unsigned int,ppfs->arg); + } + if (ppfs->info.prec == INT_MIN) { + ppfs->info.prec = +#ifdef __va_arg_ptr + *(int *) +#endif + GET_VA_ARG(p,u,unsigned int,ppfs->arg); + } + i = 0; + while (i < ppfs->num_data_args) { + switch(ppfs->argtype[i++]) { + case (PA_INT|PA_FLAG_LONG_LONG): +#ifdef ULLONG_MAX + GET_VA_ARG(p,ull,unsigned long long,ppfs->arg); + break; +#endif + case (PA_INT|PA_FLAG_LONG): +#if ULONG_MAX != UINT_MAX + GET_VA_ARG(p,ul,unsigned long,ppfs->arg); + break; +#endif + case PA_CHAR: /* TODO - be careful */ + /* ... users could use above and really want below!! */ + case (PA_INT|__PA_FLAG_CHAR):/* TODO -- translate this!!! */ + case (PA_INT|PA_FLAG_SHORT): + case PA_INT: + GET_VA_ARG(p,u,unsigned int,ppfs->arg); + break; + case PA_WCHAR: /* TODO -- assume int? */ + /* we're assuming wchar_t is at least an int */ + GET_VA_ARG(p,wc,wchar_t,ppfs->arg); + break; +#ifdef __STDIO_PRINTF_FLOAT + /* PA_FLOAT */ + case PA_DOUBLE: + GET_VA_ARG(p,d,double,ppfs->arg); + break; + case (PA_DOUBLE|PA_FLAG_LONG_DOUBLE): + GET_VA_ARG(p,ld,long double,ppfs->arg); + break; +#else /* __STDIO_PRINTF_FLOAT */ + case PA_DOUBLE: + case (PA_DOUBLE|PA_FLAG_LONG_DOUBLE): + assert(0); + continue; +#endif /* __STDIO_PRINTF_FLOAT */ + default: + /* TODO -- really need to ensure this can't happen */ + assert(ppfs->argtype[i-1] & PA_FLAG_PTR); + case PA_POINTER: + case PA_STRING: + case PA_WSTRING: + GET_VA_ARG(p,p,void *,ppfs->arg); + break; + case __PA_NOARG: + continue; + } + ++p; + } +#ifdef NL_ARGMAX + } else { + if (ppfs->info.width == INT_MIN) { + ppfs->info.width + = (int) GET_ARG_VALUE(p + ppfs->argnumber[0] - 1,u,unsigned int); + } + if (ppfs->info.prec == INT_MIN) { + ppfs->info.prec + = (int) GET_ARG_VALUE(p + ppfs->argnumber[1] - 1,u,unsigned int); + } + } +#endif /* NL_ARGMAX */ + + /* Now we know the width and precision. */ + if (ppfs->info.width < 0) { + ppfs->info.width = -ppfs->info.width; + PRINT_INFO_SET_FLAG(&(ppfs->info),left); + PRINT_INFO_CLR_FLAG(&(ppfs->info),space); + ppfs->info.pad = ' '; + } +#if 0 + /* NOTE -- keep neg for now so float knows! */ + if (ppfs->info.prec < 0) { /* spec says treat as omitted. */ + /* so use default prec... 1 for everything but floats and strings. */ + ppfs->info.prec = 1; + } +#endif +} +#endif +/**********************************************************************/ +#ifdef L__ppfs_parsespec + +#ifdef __UCLIBC_HAS_XLOCALE__ +libc_hidden_proto(__ctype_b_loc) +#else +libc_hidden_proto(__ctype_b) +#endif + +/* Notes: argtype differs from glibc for the following: + * mine glibc + * lc PA_WCHAR PA_CHAR the standard says %lc means %C + * ls PA_WSTRING PA_STRING the standard says %ls means %S + * {*}n {*}|PA_FLAG_PTR PA_FLAG_PTR size of n can be qualified + */ + +/* TODO: store positions of positional args */ + +/* TODO -- WARNING -- assumes aligned on integer boundaries!!! */ + +/* TODO -- disable if not using positional args!!! */ +#define _OVERLAPPING_DIFFERENT_ARGS + +/* TODO -- rethink this -- perhaps we should set to largest type??? */ + +#ifdef _OVERLAPPING_DIFFERENT_ARGS + +#define PROMOTED_SIZE_OF(X) ((sizeof(X) + sizeof(int) - 1) / sizeof(X)) + +static const short int type_codes[] = { + __PA_NOARG, /* must be first entry */ + PA_POINTER, + PA_STRING, + PA_WSTRING, + PA_CHAR, + PA_INT|PA_FLAG_SHORT, + PA_INT, + PA_INT|PA_FLAG_LONG, + PA_INT|PA_FLAG_LONG_LONG, + PA_WCHAR, +#ifdef __STDIO_PRINTF_FLOAT + /* PA_FLOAT, */ + PA_DOUBLE, + PA_DOUBLE|PA_FLAG_LONG_DOUBLE, +#endif /* __STDIO_PRINTF_FLOAT */ +}; + +static const unsigned char type_sizes[] = { + /* unknown type consumes no arg */ + 0, /* must be first entry */ + PROMOTED_SIZE_OF(void *), + PROMOTED_SIZE_OF(char *), + PROMOTED_SIZE_OF(wchar_t *), + PROMOTED_SIZE_OF(char), + PROMOTED_SIZE_OF(short), + PROMOTED_SIZE_OF(int), + PROMOTED_SIZE_OF(long), +#ifdef ULLONG_MAX + PROMOTED_SIZE_OF(long long), +#else + PROMOTED_SIZE_OF(long), /* TODO -- is this correct? (above too) */ +#endif + PROMOTED_SIZE_OF(wchar_t), +#ifdef __STDIO_PRINTF_FLOAT + /* PROMOTED_SIZE_OF(float), */ + PROMOTED_SIZE_OF(double), + PROMOTED_SIZE_OF(long double), +#endif /* __STDIO_PRINTF_FLOAT */ +}; + +static int _promoted_size(int argtype) +{ + register const short int *p; + + /* note -- since any unrecognized type is treated as a pointer */ + p = type_codes + sizeof(type_codes)/sizeof(type_codes[0]); + do { + if (*--p == argtype) { + break; + } + } while (p > type_codes); + + return type_sizes[(int)(p - type_codes)]; +} + +static int _is_equal_or_bigger_arg(int curtype, int newtype) +{ + /* Quick test */ + if (newtype == __PA_NOARG) { + return 0; + } + if ((curtype == __PA_NOARG) || (curtype == newtype)) { + return 1; + } + /* Ok... slot is already filled and types are different in name. */ + /* So, compare promoted sizes of curtype and newtype args. */ + return _promoted_size(curtype) <= _promoted_size(newtype); +} + +#else + +#define _is_equal_or_bigger_arg(C,N) (((C) == __PA_NOARG) || ((C) == (N))) + +#endif + +#ifdef __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ +/* TODO - do this differently? */ +static char _bss_custom_printf_spec[MAX_USER_SPEC]; /* 0-init'd for us. */ + +attribute_hidden char *_custom_printf_spec = _bss_custom_printf_spec; +attribute_hidden printf_arginfo_function *_custom_printf_arginfo[MAX_USER_SPEC]; +attribute_hidden printf_function _custom_printf_handler[MAX_USER_SPEC]; +#endif /* __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ */ + +int attribute_hidden _ppfs_parsespec(ppfs_t *ppfs) +{ + register const char *fmt; + register const char *p; + int preci; + int width; + int flags; + int dataargtype; + int i; + int dpoint; +#ifdef NL_ARGMAX + int maxposarg; +#endif /* NL_ARGMAX */ + int p_m_spec_chars; + int n; + int argtype[MAX_ARGS_PER_SPEC+2]; + int argnumber[3]; /* width, precision, 1st data arg */ + static const char spec_flags[] = SPEC_FLAGS; + static const char spec_chars[] = SPEC_CHARS;/* TODO: b? */ + static const char spec_ranges[] = SPEC_RANGES; + static const short spec_or_mask[] = SPEC_OR_MASK; + static const short spec_and_mask[] = SPEC_AND_MASK; + static const char qual_chars[] = QUAL_CHARS; +#ifdef __UCLIBC_HAS_WCHAR__ + char buf[32]; +#endif /* __UCLIBC_HAS_WCHAR__ */ + + /* WIDE note: we can test against '%' here since we don't allow */ + /* WIDE note: other mappings of '%' in the wide char set. */ + preci = -1; + argnumber[0] = 0; + argnumber[1] = 0; + argtype[0] = __PA_NOARG; + argtype[1] = __PA_NOARG; +#ifdef NL_ARGMAX + maxposarg = ppfs->maxposarg; +#endif /* NL_ARGMAX */ + +#ifdef __UCLIBC_HAS_WCHAR__ + /* This is somewhat lame, but saves a lot of code. If we're dealing with + * a wide stream, that means the format is a wchar string. So, copy it + * char-by-char into a normal char buffer for processing. Make the buffer + * (buf) big enough so that any reasonable format specifier will fit. + * While there a legal specifiers that won't, the all involve duplicate + * flags or outrageous field widths/precisions. */ + width = dpoint = 0; + if ((flags = ppfs->info._flags & FLAG_WIDESTREAM) == 0) { + fmt = ppfs->fmtpos; + } else { + fmt = buf + 1; + i = 0; + do { + if ((buf[i] = (char) (((wchar_t *) ppfs->fmtpos)[i-1])) + != (((wchar_t *) ppfs->fmtpos)[i-1]) + ) { + return -1; + } + } while (buf[i++]); + buf[sizeof(buf)-1] = 0; + } +#else /* __UCLIBC_HAS_WCHAR__ */ + width = flags = dpoint = 0; + fmt = ppfs->fmtpos; +#endif /* __UCLIBC_HAS_WCHAR__ */ + + assert(fmt[-1] == '%'); + assert(fmt[0] != '%'); + + /* Process arg pos and/or flags and/or width and/or precision. */ + width_precision: + p = fmt; + if (*fmt == '*') { + argtype[-dpoint] = PA_INT; + ++fmt; + } + i = 0; + while (isdigit(*fmt)) { + if (i < MAX_FIELD_WIDTH) { /* Avoid overflow. */ + i = (i * 10) + (*fmt - '0'); + } + ++fmt; + } + if (p[-1] == '%') { /* Check for a position. */ + + /* TODO: if val not in range, then error */ + +#ifdef NL_ARGMAX + if ((*fmt == '$') && (i > 0)) {/* Positional spec. */ + ++fmt; + if (maxposarg == 0) { + return -1; + } + if ((argnumber[2] = i) > maxposarg) { + maxposarg = i; + } + /* Now fall through to check flags. */ + } else { + if (maxposarg > 0) { +#ifdef __UCLIBC_HAS_PRINTF_M_SPEC__ +#ifdef __UCLIBC_MJN3_ONLY__ +#warning TODO: Support prec and width for %m when positional args used + /* Actually, positional arg processing will fail in general + * for specifiers that don't require an arg. */ +#endif /* __UCLIBC_MJN3_ONLY__ */ + if (*fmt == 'm') { + goto PREC_WIDTH; + } +#endif /* __UCLIBC_HAS_PRINTF_M_SPEC__ */ + return -1; + } + maxposarg = 0; /* Possible redundant store, but cuts size. */ + + if ((fmt > p) && (*p != '0')) { + goto PREC_WIDTH; + } + + fmt = p; /* Back up for possible '0's flag. */ + /* Now fall through to check flags. */ + } +#else /* NL_ARGMAX */ + if (*fmt == '$') { /* Positional spec. */ + return -1; + } + + if ((fmt > p) && (*p != '0')) { + goto PREC_WIDTH; + } + + fmt = p; /* Back up for possible '0's flag. */ + /* Now fall through to check flags. */ +#endif /* NL_ARGMAX */ + + restart_flags: /* Process flags. */ + i = 1; + p = spec_flags; + + do { + if (*fmt == *p++) { + ++fmt; + flags |= i; + goto restart_flags; + } + i += i; /* Better than i <<= 1 for bcc */ + } while (*p); + i = 0; + + /* If '+' then ignore ' ', and if '-' then ignore '0'. */ + /* Note: Need to ignore '0' when prec is an arg with val < 0, */ + /* but that test needs to wait until the arg is retrieved. */ + flags &= ~((flags & (FLAG_PLUS|FLAG_MINUS)) >> 1); + /* Note: Ignore '0' when prec is specified < 0 too (in printf). */ + + if (fmt[-1] != '%') { /* If we've done anything, loop for width. */ + goto width_precision; + } + } + PREC_WIDTH: + if (*p == '*') { /* Prec or width takes an arg. */ +#ifdef NL_ARGMAX + if (maxposarg) { + if ((*fmt++ != '$') || (i <= 0)) { + /* Using pos args and no $ or invalid arg number. */ + return -1; + } + argnumber[-dpoint] = i; + } else +#endif /* NL_ARGMAX */ + if (++p != fmt) { + /* Not using pos args but digits followed *. */ + return -1; + } + i = INT_MIN; + } + + if (!dpoint) { + width = i; + if (*fmt == '.') { + ++fmt; + dpoint = -1; /* To use as default precison. */ + goto width_precision; + } + } else { + preci = i; + } + + /* Process qualifier. */ + p = qual_chars; + do { + if (*fmt == *p) { + ++fmt; + break; + } + } while (*++p); + if ((p - qual_chars < 2) && (*fmt == *p)) { + p += ((sizeof(qual_chars)-2) / 2); + ++fmt; + } + dataargtype = ((int)(p[(sizeof(qual_chars)-2) / 2])) << 8; + + /* Process conversion specifier. */ + if (!*fmt) { + return -1; + } + + p = spec_chars; + + do { + if (*fmt == *p) { + p_m_spec_chars = p - spec_chars; + + if ((p_m_spec_chars >= CONV_c) + && (dataargtype & PA_FLAG_LONG)) { + p_m_spec_chars -= 2; /* lc -> C and ls -> S */ + } + + ppfs->conv_num = p_m_spec_chars; + p = spec_ranges-1; + while (p_m_spec_chars > *++p) {} + + i = p - spec_ranges; + argtype[2] = (dataargtype | spec_or_mask[i]) & spec_and_mask[i]; + p = spec_chars; + break; + } + } while(*++p); + + ppfs->info.spec = *fmt; + ppfs->info.prec = preci; + ppfs->info.width = width; + ppfs->info.pad = ((flags & FLAG_ZERO) ? '0' : ' '); + ppfs->info._flags = (flags & ~FLAG_ZERO) | (dataargtype & __PA_INTMASK); + ppfs->num_data_args = 1; + + if (!*p) { +#ifdef __UCLIBC_HAS_PRINTF_M_SPEC__ + if (*fmt == 'm') { + ppfs->conv_num = CONV_m; + ppfs->num_data_args = 0; + goto DONE; + } +#endif +#ifdef __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ + + /* Handle custom arg -- WARNING -- overwrites p!!! */ + ppfs->conv_num = CONV_custom0; + p = _custom_printf_spec; + do { + if (*p == *fmt) { + if ((ppfs->num_data_args + = ((*_custom_printf_arginfo[(int)(p-_custom_printf_spec)]) + (&(ppfs->info), MAX_ARGS_PER_SPEC, argtype+2))) + > MAX_ARGS_PER_SPEC) { + break; /* Error -- too many args! */ + } + goto DONE; + } + } while (++p < (_custom_printf_spec + MAX_USER_SPEC)); +#endif /* __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ */ + /* Otherwise error. */ + return -1; + } + +#if defined(__UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__) || defined(__UCLIBC_HAS_PRINTF_M_SPEC__) + DONE: +#endif + +#ifdef NL_ARGMAX + if (maxposarg > 0) { + i = 0; + do { + /* Update maxposarg and check that NL_ARGMAX is not exceeded. */ + n = ((i <= 2) + ? (ppfs->argnumber[i] = argnumber[i]) + : argnumber[2] + (i-2)); + if (n > maxposarg) { + if ((maxposarg = n) > NL_ARGMAX) { + return -1; + } + } + --n; + /* Record argtype with largest size (current, new). */ + if (_is_equal_or_bigger_arg(ppfs->argtype[n], argtype[i])) { + ppfs->argtype[n] = argtype[i]; + } + } while (++i < ppfs->num_data_args + 2); + } else { +#endif /* NL_ARGMAX */ + ppfs->argnumber[2] = 1; + memcpy(ppfs->argtype, argtype + 2, ppfs->num_data_args * sizeof(int)); +#ifdef NL_ARGMAX + } + + ppfs->maxposarg = maxposarg; +#endif /* NL_ARGMAX */ + +#ifdef __UCLIBC_HAS_WCHAR__ + if ((flags = ppfs->info._flags & FLAG_WIDESTREAM) == 0) { + ppfs->fmtpos = ++fmt; + } else { + ppfs->fmtpos = (const char *) (((const wchar_t *)(ppfs->fmtpos)) + + (fmt - buf) ); + } +#else /* __UCLIBC_HAS_WCHAR__ */ + ppfs->fmtpos = ++fmt; +#endif /* __UCLIBC_HAS_WCHAR__ */ + + return ppfs->num_data_args + 2; +} + +#endif +/**********************************************************************/ +#ifdef L_register_printf_function + +#ifdef __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ + +int register_printf_function(int spec, printf_function handler, + printf_arginfo_function arginfo) +{ + register char *r; + register char *p; + + if (spec && (arginfo != NULL)) { /* TODO -- check if spec is valid char */ + r = NULL; + p = _custom_printf_spec + MAX_USER_SPEC; + do { + --p; + if (!*p) { + r = p; + } +#ifdef __BCC__ + else /* bcc generates less code with fall-through */ +#endif + if (*p == spec) { + r = p; + p = _custom_printf_spec; + } + } while (p > _custom_printf_spec); + + if (r) { + if (handler) { + *r = spec; + _custom_printf_handler[(int)(r - p)] = handler; + _custom_printf_arginfo[(int)(r - p)] = arginfo; + } else { + *r = 0; + } + return 0; + } + /* TODO -- if asked to unregister a non-existent spec, return what? */ + } + return -1; +} + +#endif + +#endif +/**********************************************************************/ +#if defined(L_vfprintf) || defined(L_vfwprintf) + +/* We only support ascii digits (or their USC equivalent codes) in + * precision and width settings in *printf (wide) format strings. + * In other words, we don't currently support glibc's 'I' flag. + * We do accept it, but it is currently ignored. */ + +static size_t _charpad(FILE * __restrict stream, int padchar, size_t numpad); + +#ifdef L_vfprintf + +#define VFPRINTF vfprintf +#define FMT_TYPE char +#define OUTNSTR _outnstr +#define STRLEN strlen +#define _PPFS_init _ppfs_init +#define OUTPUT(F,S) fputs_unlocked(S,F) +/* #define _outnstr(stream, string, len) __stdio_fwrite(string, len, stream) */ +#define _outnstr(stream, string, len) ((len > 0) ? __stdio_fwrite(string, len, stream) : 0) +#define FP_OUT _fp_out_narrow + +#ifdef __STDIO_PRINTF_FLOAT + +static size_t _fp_out_narrow(FILE *fp, intptr_t type, intptr_t len, intptr_t buf) +{ + size_t r = 0; + + if (type & 0x80) { /* Some type of padding needed. */ + int buflen = strlen((const char *) buf); + if ((len -= buflen) > 0) { + if ((r = _charpad(fp, (type & 0x7f), len)) != len) { + return r; + } + } + len = buflen; + } + return r + OUTNSTR(fp, (const char *) buf, len); +} + +#endif /* __STDIO_PRINTF_FLOAT */ + +#else /* L_vfprintf */ + +#define VFPRINTF vfwprintf +#define FMT_TYPE wchar_t +#define OUTNSTR _outnwcs +#define STRLEN wcslen +#define _PPFS_init _ppwfs_init +#define OUTPUT(F,S) fputws(S,F) +#define _outnwcs(stream, wstring, len) _wstdio_fwrite(wstring, len, stream) +#define FP_OUT _fp_out_wide + +#ifdef __UCLIBC_HAS_LOCALE__ +libc_hidden_proto(__global_locale) +#endif + +static size_t _outnstr(FILE *stream, const char *s, size_t wclen) +{ + /* NOTE!!! len here is the number of wchars we want to generate!!! */ + wchar_t wbuf[64]; + mbstate_t mbstate; + size_t todo, r, n; + + mbstate.__mask = 0; + todo = wclen; + + while (todo) { + r = mbsrtowcs(wbuf, &s, + ((todo <= sizeof(wbuf)/sizeof(wbuf[0])) + ? todo + : sizeof(wbuf)/sizeof(wbuf[0])), + &mbstate); + assert(((ssize_t)r) > 0); + n = _outnwcs(stream, wbuf, r); + todo -= n; + if (n != r) { + break; + } + } + + return wclen - todo; +} + +#ifdef __STDIO_PRINTF_FLOAT + +#ifdef __UCLIBC_MJN3_ONLY__ +#warning TODO: Move defines from _fpmaxtostr. Put them in a common header. +#endif + +/* The following defines are from _fpmaxtostr.*/ +#define DIGITS_PER_BLOCK 9 +#define NUM_DIGIT_BLOCKS ((DECIMAL_DIG+DIGITS_PER_BLOCK-1)/DIGITS_PER_BLOCK) +#define BUF_SIZE ( 3 + NUM_DIGIT_BLOCKS * DIGITS_PER_BLOCK ) + +static size_t _fp_out_wide(FILE *fp, intptr_t type, intptr_t len, intptr_t buf) +{ + wchar_t wbuf[BUF_SIZE]; + const char *s = (const char *) buf; + size_t r = 0; + int i; + + if (type & 0x80) { /* Some type of padding needed */ + int buflen = strlen(s); + if ((len -= buflen) > 0) { + if ((r = _charpad(fp, (type & 0x7f), len)) != len) { + return r; + } + } + len = buflen; + } + + if (len > 0) { + i = 0; + do { +#ifdef __LOCALE_C_ONLY + wbuf[i] = s[i]; +#else /* __LOCALE_C_ONLY */ + +#ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ + if (s[i] == ',') { + wbuf[i] = __UCLIBC_CURLOCALE_DATA.thousands_sep_wc; + } else +#endif /* __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ */ + if (s[i] == '.') { + wbuf[i] = __UCLIBC_CURLOCALE_DATA.decimal_point_wc; + } else { + wbuf[i] = s[i]; + } +#endif /* __LOCALE_C_ONLY */ + + } while (++i < len); + + r += OUTNSTR(fp, wbuf, len); + } + + return r; +} + +#endif /* __STDIO_PRINTF_FLOAT */ + +static int _ppwfs_init(register ppfs_t *ppfs, const wchar_t *fmt0) +{ + static const wchar_t invalid_wcs[] = L"Invalid wide format string."; + int r; + + /* First, zero out everything... argnumber[], argtype[], argptr[] */ + memset(ppfs, 0, sizeof(ppfs_t)); /* TODO: nonportable???? */ +#ifdef NL_ARGMAX + --ppfs->maxposarg; /* set to -1 */ +#endif /* NL_ARGMAX */ + ppfs->fmtpos = (const char *) fmt0; + ppfs->info._flags = FLAG_WIDESTREAM; + + { + mbstate_t mbstate; + const wchar_t *p; + mbstate.__mask = 0; /* Initialize the mbstate. */ + p = fmt0; + if (wcsrtombs(NULL, &p, SIZE_MAX, &mbstate) == ((size_t)(-1))) { + ppfs->fmtpos = (const char *) invalid_wcs; + return -1; + } + } + + /* now set all argtypes to no-arg */ + { +#if 1 + /* TODO - use memset here since already "paid for"? */ + register int *p = ppfs->argtype; + + r = MAX_ARGS; + do { + *p++ = __PA_NOARG; + } while (--r); +#else + /* TODO -- get rid of this?? */ + register char *p = (char *) ((MAX_ARGS-1) * sizeof(int)); + + do { + *((int *)(((char *)ppfs) + ((int)p) + offsetof(ppfs_t,argtype))) = __PA_NOARG; + p -= sizeof(int); + } while (p); +#endif + } + + /* + * Run through the entire format string to validate it and initialize + * the positional arg numbers (if any). + */ + { + register const wchar_t *fmt = fmt0; + + while (*fmt) { + if ((*fmt == '%') && (*++fmt != '%')) { + ppfs->fmtpos = (const char *) fmt; /* back up to the '%' */ + if ((r = _ppfs_parsespec(ppfs)) < 0) { + return -1; + } + fmt = (const wchar_t *) ppfs->fmtpos; /* update to one past end of spec */ + } else { + ++fmt; + } + } + ppfs->fmtpos = (const char *) fmt0; /* rewind */ + } + +#ifdef NL_ARGMAX + /* If we have positional args, make sure we know all the types. */ + { + register int *p = ppfs->argtype; + r = ppfs->maxposarg; + while (--r >= 0) { + if ( *p == __PA_NOARG ) { /* missing arg type!!! */ + return -1; + } + ++p; + } + } +#endif /* NL_ARGMAX */ + + return 0; +} + +#endif /* L_vfprintf */ + +static size_t _charpad(FILE * __restrict stream, int padchar, size_t numpad) +{ + size_t todo = numpad; + + /* TODO -- Use a buffer to cut down on function calls... */ + FMT_TYPE pad[1]; + + *pad = padchar; + while (todo && (OUTNSTR(stream, pad, 1) == 1)) { + --todo; + } + + return numpad - todo; +} + +/* TODO -- Dynamically allocate work space to accomodate stack-poor archs? */ +static int _do_one_spec(FILE * __restrict stream, + register ppfs_t *ppfs, int *count) +{ + static const char spec_base[] = SPEC_BASE; +#ifdef L_vfprintf + static const char prefix[] = "+\0-\0 \0000x\0000X"; + /* 0 2 4 6 9 11*/ +#else /* L_vfprintf */ + static const wchar_t prefix[] = L"+\0-\0 \0000x\0000X"; +#endif /* L_vfprintf */ + enum { + PREFIX_PLUS = 0, + PREFIX_MINUS = 2, + PREFIX_SPACE = 4, + PREFIX_LWR_X = 6, + PREFIX_UPR_X = 9, + PREFIX_NONE = 11 + }; + +#ifdef __va_arg_ptr + const void * const *argptr; +#else + const void * argptr[MAX_ARGS_PER_SPEC]; +#endif + int *argtype; +#ifdef __UCLIBC_HAS_WCHAR__ + const wchar_t *ws = NULL; + mbstate_t mbstate; +#endif /* __UCLIBC_HAS_WCHAR__ */ + size_t slen; +#ifdef L_vfprintf +#define SLEN slen +#else + size_t SLEN; + wchar_t wbuf[2]; +#endif + int base; + int numpad; + int alphacase; + int numfill = 0; /* TODO: fix */ + int prefix_num = PREFIX_NONE; + char padchar = ' '; +#ifdef __UCLIBC_MJN3_ONLY__ +#warning TODO: Determine appropriate buf size. +#endif /* __UCLIBC_MJN3_ONLY__ */ + /* TODO: buf needs to be big enough for any possible error return strings + * and also for any locale-grouped long long integer strings generated. + * This should be large enough for any of the current archs/locales, but + * eventually this should be handled robustly. */ + char buf[128]; + +#ifdef NDEBUG + _ppfs_parsespec(ppfs); +#else + if (_ppfs_parsespec(ppfs) < 0) { /* TODO: just for debugging */ + abort(); + } +#endif + _ppfs_setargs(ppfs); + + argtype = ppfs->argtype + ppfs->argnumber[2] - 1; + /* Deal with the argptr vs argvalue issue. */ +#ifdef __va_arg_ptr + argptr = (const void * const *) ppfs->argptr; +#ifdef NL_ARGMAX + if (ppfs->maxposarg > 0) { /* Using positional args... */ + argptr += ppfs->argnumber[2] - 1; + } +#endif /* NL_ARGMAX */ +#else + /* Need to build a local copy... */ + { + register argvalue_t *p = ppfs->argvalue; + int i; +#ifdef NL_ARGMAX + if (ppfs->maxposarg > 0) { /* Using positional args... */ + p += ppfs->argnumber[2] - 1; + } +#endif /* NL_ARGMAX */ + for (i = 0 ; i < ppfs->num_data_args ; i++ ) { + argptr[i] = (void *) p++; + } + } +#endif + { + register char *s = NULL; /* TODO: Should s be unsigned char * ? */ + + if (ppfs->conv_num == CONV_n) { + _store_inttype(*(void **)*argptr, + ppfs->info._flags & __PA_INTMASK, + (intmax_t) (*count)); + return 0; + } + if (ppfs->conv_num <= CONV_i) { /* pointer or (un)signed int */ + alphacase = __UIM_LOWER; + +#ifdef __UCLIBC_MJN3_ONLY__ +#ifdef L_vfprintf +#warning CONSIDER: Should we ignore these flags if stub locale? What about custom specs? +#endif +#endif /* __UCLIBC_MJN3_ONLY__ */ + if ((base = spec_base[(int)(ppfs->conv_num - CONV_p)]) == 10) { + if (PRINT_INFO_FLAG_VAL(&(ppfs->info),group)) { + alphacase = __UIM_GROUP; + } + if (PRINT_INFO_FLAG_VAL(&(ppfs->info),i18n)) { + alphacase |= 0x80; + } + } + + if (ppfs->conv_num <= CONV_u) { /* pointer or unsigned int */ + if (ppfs->conv_num == CONV_X) { + alphacase = __UIM_UPPER; + } + if (ppfs->conv_num == CONV_p) { /* pointer */ + prefix_num = PREFIX_LWR_X; + } else { /* unsigned int */ + } + } else { /* signed int */ + base = -base; + } + if (ppfs->info.prec < 0) { /* Ignore '0' flag if prec specified. */ + padchar = ppfs->info.pad; + } +#ifdef __UCLIBC_MJN3_ONLY__ +#ifdef L_vfprintf +#warning CONSIDER: If using outdigits and/or grouping, how should we interpret precision? +#endif +#endif /* __UCLIBC_MJN3_ONLY__ */ + s = _uintmaxtostr(buf + sizeof(buf) - 1, + (uintmax_t) + _load_inttype(*argtype & __PA_INTMASK, + *argptr, base), base, alphacase); + if (ppfs->conv_num > CONV_u) { /* signed int */ + if (*s == '-') { + PRINT_INFO_SET_FLAG(&(ppfs->info),showsign); + ++s; /* handle '-' in the prefix string */ + prefix_num = PREFIX_MINUS; + } else if (PRINT_INFO_FLAG_VAL(&(ppfs->info),showsign)) { + prefix_num = PREFIX_PLUS; + } else if (PRINT_INFO_FLAG_VAL(&(ppfs->info),space)) { + prefix_num = PREFIX_SPACE; + } + } + slen = (char *)(buf + sizeof(buf) - 1) - s; +#ifdef L_vfwprintf + { + const char *q = s; + mbstate.__mask = 0; /* Initialize the mbstate. */ + SLEN = mbsrtowcs(NULL, &q, 0, &mbstate); + } +#endif + numfill = ((ppfs->info.prec < 0) ? 1 : ppfs->info.prec); + if (PRINT_INFO_FLAG_VAL(&(ppfs->info),alt)) { + if (ppfs->conv_num <= CONV_x) { /* x or p */ + prefix_num = PREFIX_LWR_X; + } + if (ppfs->conv_num == CONV_X) { + prefix_num = PREFIX_UPR_X; + } + if ((ppfs->conv_num == CONV_o) && (numfill <= SLEN)) { + numfill = ((*s == '0') ? 1 : SLEN + 1); + } + } + if (*s == '0') { + if (prefix_num >= PREFIX_LWR_X) { + prefix_num = PREFIX_NONE; + } + if (ppfs->conv_num == CONV_p) {/* null pointer */ + s = "(nil)"; +#ifdef L_vfwprintf + SLEN = +#endif + slen = 5; + numfill = 0; + } else if (numfill == 0) { /* if precision 0, no output */ +#ifdef L_vfwprintf + SLEN = +#endif + slen = 0; + } + } + numfill = ((numfill > SLEN) ? numfill - SLEN : 0); + } else if (ppfs->conv_num <= CONV_A) { /* floating point */ +#ifdef __STDIO_PRINTF_FLOAT + ssize_t nf; + nf = _fpmaxtostr(stream, + (__fpmax_t) + (PRINT_INFO_FLAG_VAL(&(ppfs->info),is_long_double) + ? *(long double *) *argptr + : (long double) (* (double *) *argptr)), + &ppfs->info, FP_OUT ); + if (nf < 0) { + return -1; + } + *count += nf; + + return 0; +#else /* __STDIO_PRINTF_FLOAT */ + return -1; /* TODO -- try to continue? */ +#endif /* __STDIO_PRINTF_FLOAT */ + } else if (ppfs->conv_num <= CONV_S) { /* wide char or string */ +#ifdef L_vfprintf + +#ifdef __UCLIBC_HAS_WCHAR__ + mbstate.__mask = 0; /* Initialize the mbstate. */ + if (ppfs->conv_num == CONV_S) { /* wide string */ + if (!(ws = *((const wchar_t **) *argptr))) { + goto NULL_STRING; + } + /* We use an awful uClibc-specific hack here, passing + * (char*) &ws as the conversion destination. This signals + * uClibc's wcsrtombs that we want a "restricted" length + * such that the mbs fits in a buffer of the specified + * size with no partial conversions. */ + if ((slen = wcsrtombs((char *) &ws, &ws, /* Use awful hack! */ + ((ppfs->info.prec >= 0) + ? ppfs->info.prec + : SIZE_MAX), &mbstate)) + == ((size_t)-1) + ) { + return -1; /* EILSEQ */ + } + } else { /* wide char */ + s = buf; + slen = wcrtomb(s, (*((const wchar_t *) *argptr)), &mbstate); + if (slen == ((size_t)-1)) { + return -1; /* EILSEQ */ + } + s[slen] = 0; /* TODO - Is this necessary? */ + } +#else /* __UCLIBC_HAS_WCHAR__ */ + return -1; +#endif /* __UCLIBC_HAS_WCHAR__ */ + } else if (ppfs->conv_num <= CONV_s) { /* char or string */ + if (ppfs->conv_num == CONV_s) { /* string */ + s = *((char **) (*argptr)); + if (s) { +#ifdef __UCLIBC_HAS_PRINTF_M_SPEC__ + SET_STRING_LEN: +#endif + slen = strnlen(s, ((ppfs->info.prec >= 0) + ? ppfs->info.prec : SIZE_MAX)); + } else { +#ifdef __UCLIBC_HAS_WCHAR__ + NULL_STRING: +#endif + s = "(null)"; + slen = 6; + } + } else { /* char */ + s = buf; + *s = (unsigned char)(*((const int *) *argptr)); + s[1] = 0; + slen = 1; + } + +#else /* L_vfprintf */ + + if (ppfs->conv_num == CONV_S) { /* wide string */ + ws = *((wchar_t **) (*argptr)); + if (!ws) { + goto NULL_STRING; + } + SLEN = wcsnlen(ws, ((ppfs->info.prec >= 0) + ? ppfs->info.prec : SIZE_MAX)); + } else { /* wide char */ + *wbuf = (wchar_t)(*((const wint_t *) *argptr)); + CHAR_CASE: + ws = wbuf; + wbuf[1] = 0; + SLEN = 1; + } + + } else if (ppfs->conv_num <= CONV_s) { /* char or string */ + + if (ppfs->conv_num == CONV_s) { /* string */ +#ifdef __UCLIBC_MJN3_ONLY__ +#warning TODO: Fix %s for vfwprintf... output upto illegal sequence? +#endif /* __UCLIBC_MJN3_ONLY__ */ + s = *((char **) (*argptr)); + if (s) { +#ifdef __UCLIBC_HAS_PRINTF_M_SPEC__ + SET_STRING_LEN: +#endif + /* We use an awful uClibc-specific hack here, passing + * (wchar_t*) &mbstate as the conversion destination. + * This signals uClibc's mbsrtowcs that we want a + * "restricted" length such that the mbs fits in a buffer + * of the specified size with no partial conversions. */ + { + const char *q = s; + mbstate.__mask = 0; /* Initialize the mbstate. */ + SLEN = mbsrtowcs((wchar_t *) &mbstate, &q, + ((ppfs->info.prec >= 0) + ? ppfs->info.prec : SIZE_MAX), + &mbstate); + } + if (SLEN == ((size_t)(-1))) { + return -1; /* EILSEQ */ + } + } else { + NULL_STRING: + s = "(null)"; + SLEN = slen = 6; + } + } else { /* char */ + *wbuf = btowc( (unsigned char)(*((const int *) *argptr)) ); + goto CHAR_CASE; + } + +#endif /* L_vfprintf */ + +#ifdef __UCLIBC_HAS_PRINTF_M_SPEC__ + } else if (ppfs->conv_num == CONV_m) { + s = __glibc_strerror_r(errno, buf, sizeof(buf)); + goto SET_STRING_LEN; +#endif + } else { +#ifdef __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ + assert(ppfs->conv_num == CONV_custom0); + + s = _custom_printf_spec; + do { + if (*s == ppfs->info.spec) { + int rv; + /* TODO -- check return value for sanity? */ + rv = (*_custom_printf_handler + [(int)(s-_custom_printf_spec)]) + (stream, &ppfs->info, argptr); + if (rv < 0) { + return -1; + } + *count += rv; + return 0; + } + } while (++s < (_custom_printf_spec + MAX_USER_SPEC)); +#endif /* __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ */ + assert(0); + return -1; + } + +#ifdef __UCLIBC_MJN3_ONLY__ +#ifdef L_vfprintf +#warning CONSIDER: If using outdigits and/or grouping, how should we pad? +#endif +#endif /* __UCLIBC_MJN3_ONLY__ */ + { + size_t t; + + t = SLEN + numfill; + if (prefix_num != PREFIX_NONE) { + t += ((prefix_num < PREFIX_LWR_X) ? 1 : 2); + } + numpad = ((ppfs->info.width > t) ? (ppfs->info.width - t) : 0); + *count += t + numpad; + } + if (padchar == '0') { /* TODO: check this */ + numfill += numpad; + numpad = 0; + } + + /* Now handle the output itself. */ + if (!PRINT_INFO_FLAG_VAL(&(ppfs->info),left)) { + if (_charpad(stream, ' ', numpad) != numpad) { + return -1; + } + numpad = 0; + } + OUTPUT(stream, prefix + prefix_num); + if (_charpad(stream, '0', numfill) != numfill) { + return -1; + } + +#ifdef L_vfprintf + +#ifdef __UCLIBC_HAS_WCHAR__ + if (!ws) { + assert(s); + if (_outnstr(stream, s, slen) != slen) { + return -1; + } + } else { /* wide string */ + size_t t; + mbstate.__mask = 0; /* Initialize the mbstate. */ + while (slen) { + t = (slen <= sizeof(buf)) ? slen : sizeof(buf); + t = wcsrtombs(buf, &ws, t, &mbstate); + assert (t != ((size_t)(-1))); + if (_outnstr(stream, buf, t) != t) { + return -1; + } + slen -= t; + } + } +#else /* __UCLIBC_HAS_WCHAR__ */ + if (_outnstr(stream, s, slen) != slen) { + return -1; + } +#endif /* __UCLIBC_HAS_WCHAR__ */ + +#else /* L_vfprintf */ + + if (!ws) { + assert(s); + if (_outnstr(stream, s, SLEN) != SLEN) { + return -1; + } + } else { + if (_outnwcs(stream, ws, SLEN) != SLEN) { + return -1; + } + } + +#endif /* L_vfprintf */ + if (_charpad(stream, ' ', numpad) != numpad) { + return -1; + } + } + + return 0; +} + +libc_hidden_proto(fprintf) + +libc_hidden_proto(VFPRINTF) +int VFPRINTF (FILE * __restrict stream, + register const FMT_TYPE * __restrict format, + va_list arg) +{ + ppfs_t ppfs; + int count, r; + register const FMT_TYPE *s; + __STDIO_AUTO_THREADLOCK_VAR; + + __STDIO_AUTO_THREADLOCK(stream); + + count = 0; + s = format; + + if +#ifdef L_vfprintf + (!__STDIO_STREAM_IS_NARROW_WRITING(stream) + && __STDIO_STREAM_TRANS_TO_WRITE(stream, __FLAG_NARROW)) +#else + (!__STDIO_STREAM_IS_WIDE_WRITING(stream) + && __STDIO_STREAM_TRANS_TO_WRITE(stream, __FLAG_WIDE)) +#endif + { + count = -1; + } else if (_PPFS_init(&ppfs, format) < 0) { /* Bad format string. */ + OUTNSTR(stream, (const FMT_TYPE *) ppfs.fmtpos, + STRLEN((const FMT_TYPE *)(ppfs.fmtpos))); +#if defined(L_vfprintf) && !defined(NDEBUG) + fprintf(stderr,"\nIMbS: \"%s\"\n\n", format); +#endif + count = -1; + } else { + _ppfs_prepargs(&ppfs, arg); /* This did a va_copy!!! */ + + do { + while (*format && (*format != '%')) { + ++format; + } + + if (format-s) { /* output any literal text in format string */ + if ( (r = OUTNSTR(stream, s, format-s)) != (format-s)) { + count = -1; + break; + } + count += r; + } + + if (!*format) { /* we're done */ + break; + } + + if (format[1] != '%') { /* if we get here, *format == '%' */ + /* TODO: _do_one_spec needs to know what the output funcs are!!! */ + ppfs.fmtpos = (const char *)(++format); + /* TODO: check -- should only fail on stream error */ + if ( (r = _do_one_spec(stream, &ppfs, &count)) < 0) { + count = -1; + break; + } + s = format = (const FMT_TYPE *) ppfs.fmtpos; + } else { /* %% means literal %, so start new string */ + s = ++format; + ++format; + } + } while (1); + + va_end(ppfs.arg); /* Need to clean up after va_copy! */ + } + +/* #if defined(L_vfprintf) && defined(__UCLIBC_HAS_WCHAR__) */ +/* DONE: */ +/* #endif */ + + __STDIO_AUTO_THREADUNLOCK(stream); + + return count; +} +libc_hidden_def(VFPRINTF) +#endif +/**********************************************************************/ diff --git a/libc/stdio/_wfwrite.c b/libc/stdio/_wfwrite.c index 792cff604..fb5c6b3ee 100644 --- a/libc/stdio/_wfwrite.c +++ b/libc/stdio/_wfwrite.c @@ -5,8 +5,6 @@ * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. */ -#define wmemcpy __wmemcpy - #include "_stdio.h" #include <wchar.h> @@ -17,9 +15,9 @@ #ifdef __UCLIBC_MJN3_ONLY__ #warning TODO: Fix prototype. #endif -extern size_t __wcsnrtombs(char *__restrict dst, - const wchar_t **__restrict src, - size_t NWC, size_t len, mbstate_t *__restrict ps) attribute_hidden; + +libc_hidden_proto(wmemcpy) +libc_hidden_proto(wcsnrtombs) size_t attribute_hidden _wstdio_fwrite(const wchar_t *__restrict ws, size_t n, register FILE *__restrict stream) @@ -55,7 +53,7 @@ size_t attribute_hidden _wstdio_fwrite(const wchar_t *__restrict ws, size_t n, pw = ws; while (n > count) { - r = __wcsnrtombs(buf, &pw, n-count, sizeof(buf), &stream->__state); + r = wcsnrtombs(buf, &pw, n-count, sizeof(buf), &stream->__state); if (r != ((size_t) -1)) { /* No encoding errors */ if (!r) { ++r; /* 0 is returned when nul is reached. */ diff --git a/libc/stdio/asprintf.c b/libc/stdio/asprintf.c index 207b35a3c..3f1992559 100644 --- a/libc/stdio/asprintf.c +++ b/libc/stdio/asprintf.c @@ -5,16 +5,21 @@ * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. */ -#define vasprintf __vasprintf +#include <features.h> +#ifdef __USE_GNU #include "_stdio.h" #include <stdarg.h> +libc_hidden_proto(asprintf) + +libc_hidden_proto(vasprintf) + #ifndef __STDIO_HAS_VSNPRINTF #warning Skipping asprintf and __asprintf since no vsnprintf! #else -int attribute_hidden __asprintf(char **__restrict buf, const char * __restrict format, ...) +int asprintf(char **__restrict buf, const char * __restrict format, ...) { va_list arg; int rv; @@ -25,7 +30,7 @@ int attribute_hidden __asprintf(char **__restrict buf, const char * __restrict f return rv; } +libc_hidden_def(asprintf) -strong_alias(__asprintf,asprintf) - +#endif #endif diff --git a/libc/stdio/clearerr.c b/libc/stdio/clearerr.c index cf1e623c7..a96ecaa89 100644 --- a/libc/stdio/clearerr.c +++ b/libc/stdio/clearerr.c @@ -7,18 +7,19 @@ #include "_stdio.h" +#undef clearerr #ifdef __DO_UNLOCKED -void __clearerr_unlocked(register FILE *stream) +#undef clearerr_unlocked +void clearerr_unlocked(register FILE *stream) { __STDIO_STREAM_VALIDATE(stream); __CLEARERR_UNLOCKED(stream); } -weak_alias(__clearerr_unlocked,clearerr_unlocked) #ifndef __UCLIBC_HAS_THREADS__ -weak_alias(__clearerr_unlocked,clearerr) +strong_alias(clearerr_unlocked,clearerr) #endif #elif defined __UCLIBC_HAS_THREADS__ diff --git a/libc/stdio/clearerr_unlocked.c b/libc/stdio/clearerr_unlocked.c new file mode 100644 index 000000000..1728d0378 --- /dev/null +++ b/libc/stdio/clearerr_unlocked.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define __DO_UNLOCKED +#include "clearerr.c" diff --git a/libc/stdio/ctermid.c b/libc/stdio/ctermid.c index 11e43f336..1cb8a0845 100644 --- a/libc/stdio/ctermid.c +++ b/libc/stdio/ctermid.c @@ -7,6 +7,8 @@ #include "_stdio.h" +libc_hidden_proto(strcpy) + char *ctermid(register char *s) { static char sbuf[L_ctermid]; @@ -21,6 +23,6 @@ char *ctermid(register char *s) return s; #else /* glibc always returns /dev/tty for linux. */ - return __strcpy((s ? s : sbuf), "/dev/tty"); + return strcpy((s ? s : sbuf), "/dev/tty"); #endif } diff --git a/libc/stdio/dprintf.c b/libc/stdio/dprintf.c index 1fc46c722..a8b2704b2 100644 --- a/libc/stdio/dprintf.c +++ b/libc/stdio/dprintf.c @@ -5,11 +5,14 @@ * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. */ -#define vdprintf __vdprintf +#include <features.h> +#ifdef __USE_GNU #include "_stdio.h" #include <stdarg.h> +libc_hidden_proto(vdprintf) + int dprintf(int filedes, const char * __restrict format, ...) { va_list arg; @@ -21,3 +24,4 @@ int dprintf(int filedes, const char * __restrict format, ...) return rv; } +#endif diff --git a/libc/stdio/fclose.c b/libc/stdio/fclose.c index e019ad53e..843599c0f 100644 --- a/libc/stdio/fclose.c +++ b/libc/stdio/fclose.c @@ -5,12 +5,13 @@ * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. */ -#define close __close - #include "_stdio.h" +libc_hidden_proto(fclose) + +libc_hidden_proto(close) +libc_hidden_proto(fflush_unlocked) -#undef fclose -int attribute_hidden __fclose(register FILE *stream) +int fclose(register FILE *stream) { int rv = 0; __STDIO_AUTO_THREADLOCK_VAR; @@ -47,7 +48,7 @@ int attribute_hidden __fclose(register FILE *stream) #ifdef __STDIO_BUFFERS /* Write any pending buffered chars. */ if (__STDIO_STREAM_IS_WRITING(stream)) { - rv = __fflush_unlocked(stream); + rv = fflush_unlocked(stream); } #endif @@ -87,4 +88,4 @@ int attribute_hidden __fclose(register FILE *stream) return rv; } -strong_alias(__fclose,fclose) +libc_hidden_def(fclose) diff --git a/libc/stdio/fcloseall.c b/libc/stdio/fcloseall.c index dbb600067..7d2422562 100644 --- a/libc/stdio/fcloseall.c +++ b/libc/stdio/fcloseall.c @@ -5,8 +5,13 @@ * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. */ +#include <features.h> + +#ifdef __USE_GNU #include "_stdio.h" +libc_hidden_proto(fclose) + /* 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 @@ -38,3 +43,4 @@ int fcloseall (void) #endif } +#endif diff --git a/libc/stdio/fdopen.c b/libc/stdio/fdopen.c index bca7f23fb..acf6231b2 100644 --- a/libc/stdio/fdopen.c +++ b/libc/stdio/fdopen.c @@ -7,12 +7,15 @@ #include "_stdio.h" -FILE attribute_hidden *__fdopen(int filedes, const char *mode) +libc_hidden_proto(fdopen) +libc_hidden_proto(fcntl) + +FILE *fdopen(int filedes, const char *mode) { intptr_t cur_mode; - return (((cur_mode = __fcntl(filedes, F_GETFL))) != -1) + return (((cur_mode = fcntl(filedes, F_GETFL))) != -1) ? _stdio_fopen(cur_mode, mode, NULL, filedes) : NULL; } -strong_alias(__fdopen,fdopen) +libc_hidden_def(fdopen) diff --git a/libc/stdio/feof.c b/libc/stdio/feof.c index b0528d5ae..e5f03b720 100644 --- a/libc/stdio/feof.c +++ b/libc/stdio/feof.c @@ -7,18 +7,19 @@ #include "_stdio.h" +#undef feof #ifdef __DO_UNLOCKED -int __feof_unlocked(register FILE *stream) +#undef feof_unlocked +int feof_unlocked(register FILE *stream) { __STDIO_STREAM_VALIDATE(stream); return __FEOF_UNLOCKED(stream); } -weak_alias(__feof_unlocked,feof_unlocked) #ifndef __UCLIBC_HAS_THREADS__ -weak_alias(__feof_unlocked,feof) +strong_alias(feof_unlocked,feof) #endif #elif defined __UCLIBC_HAS_THREADS__ diff --git a/libc/stdio/feof_unlocked.c b/libc/stdio/feof_unlocked.c new file mode 100644 index 000000000..4553f306b --- /dev/null +++ b/libc/stdio/feof_unlocked.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define __DO_UNLOCKED +#include "feof.c" diff --git a/libc/stdio/ferror.c b/libc/stdio/ferror.c index e8d19bfa4..947b89ed1 100644 --- a/libc/stdio/ferror.c +++ b/libc/stdio/ferror.c @@ -7,18 +7,19 @@ #include "_stdio.h" +#undef ferror #ifdef __DO_UNLOCKED -int __ferror_unlocked(register FILE *stream) +#undef ferror_unlocked +int ferror_unlocked(register FILE *stream) { __STDIO_STREAM_VALIDATE(stream); return __FERROR_UNLOCKED(stream); } -weak_alias(__ferror_unlocked,ferror_unlocked) #ifndef __UCLIBC_HAS_THREADS__ -weak_alias(__ferror_unlocked,ferror) +strong_alias(ferror_unlocked,ferror) #endif #elif defined __UCLIBC_HAS_THREADS__ diff --git a/libc/stdio/ferror_unlocked.c b/libc/stdio/ferror_unlocked.c new file mode 100644 index 000000000..19722b8bb --- /dev/null +++ b/libc/stdio/ferror_unlocked.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define __DO_UNLOCKED +#include "ferror.c" diff --git a/libc/stdio/fflush.c b/libc/stdio/fflush.c index 0a74afe3f..a2e1cf916 100644 --- a/libc/stdio/fflush.c +++ b/libc/stdio/fflush.c @@ -7,6 +7,8 @@ #include "_stdio.h" +libc_hidden_proto(fflush_unlocked) + #ifdef __DO_UNLOCKED #ifdef __UCLIBC_MJN3_ONLY__ @@ -14,6 +16,7 @@ #endif /* __UCLIBC_MJN3_ONLY__ */ #ifdef __UCLIBC_HAS_THREADS__ +libc_hidden_proto(_stdio_user_locking) /* Even if the stream is set to user-locking, we still need to lock * when all (lbf) writing streams are flushed. */ #define MY_STDIO_THREADLOCK(STREAM) \ @@ -31,7 +34,7 @@ #endif -int attribute_hidden __fflush_unlocked(register FILE *stream) +int fflush_unlocked(register FILE *stream) { #ifdef __STDIO_BUFFERS @@ -125,16 +128,18 @@ int attribute_hidden __fflush_unlocked(register FILE *stream) return 0; #endif /* __STDIO_BUFFERS */ } +libc_hidden_def(fflush_unlocked) -weak_alias(__fflush_unlocked,fflush_unlocked) #ifndef __UCLIBC_HAS_THREADS__ -hidden_strong_alias(__fflush_unlocked,__fflush) -weak_alias(__fflush_unlocked,fflush) +libc_hidden_proto(fflush) +strong_alias(fflush_unlocked,fflush) +libc_hidden_def(fflush) #endif #elif defined __UCLIBC_HAS_THREADS__ -int attribute_hidden __fflush(register FILE *stream) +libc_hidden_proto(fflush) +int fflush(register FILE *stream) { int retval; __STDIO_AUTO_THREADLOCK_VAR; @@ -147,15 +152,15 @@ int attribute_hidden __fflush(register FILE *stream) __STDIO_AUTO_THREADLOCK(stream); - retval = __fflush_unlocked(stream); + retval = fflush_unlocked(stream); __STDIO_AUTO_THREADUNLOCK(stream); } else { - retval = __fflush_unlocked(stream); + retval = fflush_unlocked(stream); } return retval; } -strong_alias(__fflush,fflush) +libc_hidden_def(fflush) #endif diff --git a/libc/stdio/fflush_unlocked.c b/libc/stdio/fflush_unlocked.c new file mode 100644 index 000000000..a6adb59c2 --- /dev/null +++ b/libc/stdio/fflush_unlocked.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define __DO_UNLOCKED +#include "fflush.c" diff --git a/libc/stdio/fgetc.c b/libc/stdio/fgetc.c index d83b6c92a..7eb2b6ea2 100644 --- a/libc/stdio/fgetc.c +++ b/libc/stdio/fgetc.c @@ -1,6 +1,7 @@ /* Copyright (C) 2004 Manuel Novoa III <mjn3@codepoet.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> * - * GNU Library General Public License (LGPL) version 2 or later. + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. * * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. */ @@ -12,9 +13,13 @@ #undef getc #undef getc_unlocked +libc_hidden_proto(__fgetc_unlocked) + #ifdef __DO_UNLOCKED -int attribute_hidden __fgetc_unlocked_internal(FILE *stream) +libc_hidden_proto(fflush_unlocked) + +int __fgetc_unlocked(FILE *stream) { __STDIO_STREAM_VALIDATE(stream); @@ -68,20 +73,32 @@ int attribute_hidden __fgetc_unlocked_internal(FILE *stream) return EOF; } +libc_hidden_def(__fgetc_unlocked) + +libc_hidden_proto(fgetc_unlocked) +strong_alias(__fgetc_unlocked,fgetc_unlocked) +libc_hidden_def(fgetc_unlocked) + +//libc_hidden_proto(__getc_unlocked) +//strong_alias(__fgetc_unlocked,__getc_unlocked) +//libc_hidden_def(__getc_unlocked) + +libc_hidden_proto(getc_unlocked) +strong_alias(__fgetc_unlocked,getc_unlocked) +libc_hidden_def(getc_unlocked) -strong_alias(__fgetc_unlocked_internal,__fgetc_unlocked) -weak_alias(__fgetc_unlocked_internal,fgetc_unlocked) -hidden_strong_alias(__fgetc_unlocked_internal,__getc_unlocked) -weak_alias(__fgetc_unlocked_internal,getc_unlocked) #ifndef __UCLIBC_HAS_THREADS__ -hidden_strong_alias(__fgetc_unlocked_internal,__fgetc) -weak_alias(__fgetc_unlocked_internal,fgetc) -weak_alias(__fgetc_unlocked_internal,getc) +libc_hidden_proto(fgetc) +strong_alias(__fgetc_unlocked,fgetc) +libc_hidden_def(fgetc) + +strong_alias(__fgetc_unlocked,getc) #endif #elif defined __UCLIBC_HAS_THREADS__ -int attribute_hidden __fgetc(register FILE *stream) +libc_hidden_proto(fgetc) +int fgetc(register FILE *stream) { if (stream->__user_locking != 0) { return __GETC_UNLOCKED_MACRO(stream); @@ -93,7 +110,8 @@ int attribute_hidden __fgetc(register FILE *stream) return retval; } } -strong_alias(__fgetc,fgetc) -weak_alias(__fgetc,getc) +libc_hidden_def(fgetc) + +strong_alias(fgetc,getc) #endif diff --git a/libc/stdio/fgetc_unlocked.c b/libc/stdio/fgetc_unlocked.c new file mode 100644 index 000000000..a20c7eef2 --- /dev/null +++ b/libc/stdio/fgetc_unlocked.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define __DO_UNLOCKED +#include "fgetc.c" diff --git a/libc/stdio/fgetpos.c b/libc/stdio/fgetpos.c index 03c18ab93..610737d36 100644 --- a/libc/stdio/fgetpos.c +++ b/libc/stdio/fgetpos.c @@ -8,9 +8,11 @@ #include "_stdio.h" #ifndef __DO_LARGEFILE -#define FTELL __ftell +#define FTELL ftell #endif +libc_hidden_proto(FTELL) + int fgetpos(FILE * __restrict stream, register fpos_t * __restrict pos) { #ifdef __STDIO_MBSTATE diff --git a/libc/stdio/fgetpos64.c b/libc/stdio/fgetpos64.c index 6f46746b1..32b7120aa 100644 --- a/libc/stdio/fgetpos64.c +++ b/libc/stdio/fgetpos64.c @@ -10,5 +10,5 @@ #define __DO_LARGEFILE #define fgetpos fgetpos64 #define fpos_t fpos64_t -#define FTELL __ftello64 +#define FTELL ftello64 #include "fgetpos.c" diff --git a/libc/stdio/fgets.c b/libc/stdio/fgets.c index 5baf63a58..5acaf91ed 100644 --- a/libc/stdio/fgets.c +++ b/libc/stdio/fgets.c @@ -7,9 +7,13 @@ #include "_stdio.h" +libc_hidden_proto(fgets_unlocked) + #ifdef __DO_UNLOCKED -char attribute_hidden *__fgets_unlocked(char *__restrict s, int n, +libc_hidden_proto(__fgetc_unlocked) + +char *fgets_unlocked(char *__restrict s, int n, register FILE * __restrict stream) { register char *p; @@ -34,7 +38,7 @@ char attribute_hidden *__fgets_unlocked(char *__restrict s, int n, break; } } else { - if ((c = __fgetc_unlocked_internal(stream)) == EOF) { + if ((c = __fgetc_unlocked(stream)) == EOF) { if (__FERROR_UNLOCKED(stream)) { goto ERROR; } @@ -57,17 +61,18 @@ char attribute_hidden *__fgets_unlocked(char *__restrict s, int n, ERROR: return NULL; } - -weak_alias(__fgets_unlocked,fgets_unlocked) +libc_hidden_def(fgets_unlocked) #ifndef __UCLIBC_HAS_THREADS__ -hidden_strong_alias(__fgets_unlocked,__fgets) -weak_alias(__fgets_unlocked,fgets) +libc_hidden_proto(fgets) +strong_alias(fgets_unlocked,fgets) +libc_hidden_def(fgets) #endif #elif defined __UCLIBC_HAS_THREADS__ -char attribute_hidden *__fgets(char *__restrict s, int n, +libc_hidden_proto(fgets) +char *fgets(char *__restrict s, int n, register FILE * __restrict stream) { char *retval; @@ -75,12 +80,12 @@ char attribute_hidden *__fgets(char *__restrict s, int n, __STDIO_AUTO_THREADLOCK(stream); - retval = __fgets_unlocked(s, n, stream); + retval = fgets_unlocked(s, n, stream); __STDIO_AUTO_THREADUNLOCK(stream); return retval; } -strong_alias(__fgets,fgets) +libc_hidden_def(fgets) #endif diff --git a/libc/stdio/fgets_unlocked.c b/libc/stdio/fgets_unlocked.c new file mode 100644 index 000000000..db0191305 --- /dev/null +++ b/libc/stdio/fgets_unlocked.c @@ -0,0 +1,14 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ + +#include <features.h> + +#ifdef __USE_GNU +# define __DO_UNLOCKED +# include "fgets.c" +#endif diff --git a/libc/stdio/fgetwc.c b/libc/stdio/fgetwc.c index 45ff86b80..062d825d6 100644 --- a/libc/stdio/fgetwc.c +++ b/libc/stdio/fgetwc.c @@ -5,10 +5,12 @@ * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. */ -#define mbrtowc __mbrtowc - #include "_stdio.h" +libc_hidden_proto(fgetwc_unlocked) + +libc_hidden_proto(mbrtowc) + #ifdef __DO_UNLOCKED static void munge_stream(register FILE *stream, unsigned char *buf) @@ -19,7 +21,7 @@ static void munge_stream(register FILE *stream, unsigned char *buf) __STDIO_STREAM_DISABLE_PUTC(stream); } -wint_t attribute_hidden __fgetwc_unlocked(register FILE *stream) +wint_t fgetwc_unlocked(register FILE *stream) { wint_t wi; wchar_t wc[1]; @@ -107,31 +109,34 @@ wint_t attribute_hidden __fgetwc_unlocked(register FILE *stream) return wi; } +libc_hidden_def(fgetwc_unlocked) -weak_alias(__fgetwc_unlocked,fgetwc_unlocked) -weak_alias(__fgetwc_unlocked,getwc_unlocked) +strong_alias(fgetwc_unlocked,getwc_unlocked) #ifndef __UCLIBC_HAS_THREADS__ -hidden_strong_alias(__fgetwc_unlocked,__fgetwc) -weak_alias(__fgetwc_unlocked,fgetwc) -weak_alias(__fgetwc_unlocked,getwc) +libc_hidden_proto(fgetwc) +strong_alias(fgetwc_unlocked,fgetwc) +libc_hidden_def(fgetwc) + +strong_alias(fgetwc_unlocked,getwc) #endif #elif defined __UCLIBC_HAS_THREADS__ -wint_t attribute_hidden __fgetwc(register FILE *stream) +libc_hidden_proto(fgetwc) +wint_t fgetwc(register FILE *stream) { wint_t retval; __STDIO_AUTO_THREADLOCK_VAR; __STDIO_AUTO_THREADLOCK(stream); - retval = __fgetwc_unlocked(stream); + retval = fgetwc_unlocked(stream); __STDIO_AUTO_THREADUNLOCK(stream); return retval; } -strong_alias(__fgetwc,fgetwc) -weak_alias(__fgetwc,getwc) +libc_hidden_def(fgetwc) +strong_alias(fgetwc,getwc) #endif diff --git a/libc/stdio/fgetwc_unlocked.c b/libc/stdio/fgetwc_unlocked.c new file mode 100644 index 000000000..8eab84393 --- /dev/null +++ b/libc/stdio/fgetwc_unlocked.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define __DO_UNLOCKED +#include "fgetwc.c" diff --git a/libc/stdio/fgetws.c b/libc/stdio/fgetws.c index fe8da002d..c7dcc7d2b 100644 --- a/libc/stdio/fgetws.c +++ b/libc/stdio/fgetws.c @@ -7,12 +7,13 @@ #include "_stdio.h" -extern wchar_t *__fgetws_unlocked(wchar_t *__restrict ws, int n, - FILE *__restrict stream) attribute_hidden; +libc_hidden_proto(fgetws_unlocked) + +libc_hidden_proto(fgetwc_unlocked) #ifdef __DO_UNLOCKED -wchar_t attribute_hidden *__fgetws_unlocked(wchar_t *__restrict ws, int n, +wchar_t *fgetws_unlocked(wchar_t *__restrict ws, int n, FILE *__restrict stream) { register wchar_t *p = ws; @@ -21,7 +22,7 @@ wchar_t attribute_hidden *__fgetws_unlocked(wchar_t *__restrict ws, int n, __STDIO_STREAM_VALIDATE(stream); while ((n > 1) - && ((wi = __fgetwc_unlocked(stream)) != WEOF) + && ((wi = fgetwc_unlocked(stream)) != WEOF) && ((*p++ = wi) != '\n') ) { --n; @@ -36,10 +37,10 @@ wchar_t attribute_hidden *__fgetws_unlocked(wchar_t *__restrict ws, int n, *p = 0; return ws; } +libc_hidden_def(fgetws_unlocked) -weak_alias(__fgetws_unlocked,fgetws_unlocked) #ifndef __UCLIBC_HAS_THREADS__ -weak_alias(__fgetws_unlocked,fgetws) +strong_alias(fgetws_unlocked,fgetws) #endif #elif defined __UCLIBC_HAS_THREADS__ @@ -51,7 +52,7 @@ wchar_t *fgetws(wchar_t *__restrict ws, int n, FILE *__restrict stream) __STDIO_AUTO_THREADLOCK(stream); - retval = __fgetws_unlocked(ws, n, stream); + retval = fgetws_unlocked(ws, n, stream); __STDIO_AUTO_THREADUNLOCK(stream); diff --git a/libc/stdio/fgetws_unlocked.c b/libc/stdio/fgetws_unlocked.c new file mode 100644 index 000000000..6dd58f20a --- /dev/null +++ b/libc/stdio/fgetws_unlocked.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define __DO_UNLOCKED +#include "fgetws.c" diff --git a/libc/stdio/fileno.c b/libc/stdio/fileno.c index bc1ade952..929936bfd 100644 --- a/libc/stdio/fileno.c +++ b/libc/stdio/fileno.c @@ -7,9 +7,11 @@ #include "_stdio.h" +libc_hidden_proto(fileno_unlocked) + #ifdef __DO_UNLOCKED -int attribute_hidden __fileno_unlocked(register FILE *stream) +int fileno_unlocked(register FILE *stream) { __STDIO_STREAM_VALIDATE(stream); @@ -20,27 +22,30 @@ int attribute_hidden __fileno_unlocked(register FILE *stream) __set_errno(EBADF); return -1; } +libc_hidden_def(fileno_unlocked) -weak_alias(__fileno_unlocked,fileno_unlocked) #ifndef __UCLIBC_HAS_THREADS__ -hidden_weak_alias(__fileno_unlocked,__fileno) -weak_alias(__fileno_unlocked,fileno) +libc_hidden_proto(fileno) +strong_alias(fileno_unlocked,fileno) +libc_hidden_def(fileno) #endif #elif defined __UCLIBC_HAS_THREADS__ -int attribute_hidden __fileno(register FILE *stream) +libc_hidden_proto(fileno) +int fileno(register FILE *stream) { int retval; __STDIO_AUTO_THREADLOCK_VAR; __STDIO_AUTO_THREADLOCK(stream); - retval = __fileno_unlocked(stream); + retval = fileno_unlocked(stream); __STDIO_AUTO_THREADUNLOCK(stream); return retval; } -strong_alias(__fileno,fileno) +libc_hidden_def(fileno) + #endif diff --git a/libc/stdio/fileno_unlocked.c b/libc/stdio/fileno_unlocked.c new file mode 100644 index 000000000..e50059296 --- /dev/null +++ b/libc/stdio/fileno_unlocked.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define __DO_UNLOCKED +#include "fileno.c" diff --git a/libc/stdio/fmemopen.c b/libc/stdio/fmemopen.c index fc7870258..a78d56efc 100644 --- a/libc/stdio/fmemopen.c +++ b/libc/stdio/fmemopen.c @@ -5,10 +5,14 @@ * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. */ -#define fopencookie __fopencookie +#include <features.h> +#ifdef __USE_GNU #include "_stdio.h" +libc_hidden_proto(memcpy) +libc_hidden_proto(fopencookie) + #ifndef __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__ #error no custom streams! #endif @@ -37,7 +41,7 @@ static ssize_t fmo_read(register void *cookie, char *buf, size_t bufsize) bufsize = count; } - __memcpy(buf, COOKIE->buf + COOKIE->pos, bufsize); + memcpy(buf, COOKIE->buf + COOKIE->pos, bufsize); COOKIE->pos += bufsize; return bufsize; @@ -64,7 +68,7 @@ static ssize_t fmo_write(register void *cookie, const char *buf, size_t bufsize) } } - __memcpy(COOKIE->buf + COOKIE->pos, buf, bufsize); + memcpy(COOKIE->buf + COOKIE->pos, buf, bufsize); COOKIE->pos += bufsize; if (COOKIE->pos > COOKIE->eof) { @@ -176,3 +180,4 @@ FILE *fmemopen(void *s, size_t len, const char *modes) return NULL; } +#endif diff --git a/libc/stdio/fopen.c b/libc/stdio/fopen.c index ad5d1aa92..ec14b5956 100644 --- a/libc/stdio/fopen.c +++ b/libc/stdio/fopen.c @@ -9,15 +9,14 @@ #ifndef __DO_LARGEFILE # define FILEDES_ARG (-1) -#undef __fopen #undef fopen #else -#undef __fopen64 #undef fopen64 #endif -FILE attribute_hidden *__fopen(const char * __restrict filename, const char * __restrict mode) +libc_hidden_proto(fopen) +FILE *fopen(const char * __restrict filename, const char * __restrict mode) { return _stdio_fopen(((intptr_t) filename), mode, NULL, FILEDES_ARG); } -strong_alias(__fopen,fopen) +libc_hidden_def(fopen) diff --git a/libc/stdio/fopen64.c b/libc/stdio/fopen64.c index c65e9a4e9..cbdb03d68 100644 --- a/libc/stdio/fopen64.c +++ b/libc/stdio/fopen64.c @@ -8,7 +8,6 @@ #include "_stdio.h" #define __DO_LARGEFILE -#define __fopen __fopen64 #undef fopen #define fopen fopen64 #define FILEDES_ARG (-2) diff --git a/libc/stdio/fopencookie.c b/libc/stdio/fopencookie.c index a70e17b80..0b7ed84b1 100644 --- a/libc/stdio/fopencookie.c +++ b/libc/stdio/fopencookie.c @@ -5,6 +5,9 @@ * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. */ +#include <features.h> + +#ifdef __USE_GNU #include "_stdio.h" #ifndef __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__ @@ -28,7 +31,8 @@ /* Currently no real reentrancy issues other than a possible double close(). */ #ifndef __BCC__ -FILE attribute_hidden *__fopencookie(void * __restrict cookie, const char * __restrict mode, +libc_hidden_proto(fopencookie) +FILE *fopencookie(void * __restrict cookie, const char * __restrict mode, cookie_io_functions_t io_functions) #else FILE *_fopencookie(void * __restrict cookie, const char * __restrict mode, @@ -58,5 +62,6 @@ FILE *_fopencookie(void * __restrict cookie, const char * __restrict mode, return stream; } #ifndef __BCC__ -strong_alias(__fopencookie,fopencookie) +libc_hidden_def(fopencookie) +#endif #endif diff --git a/libc/stdio/fprintf.c b/libc/stdio/fprintf.c index ee19c85a5..4f73441e1 100644 --- a/libc/stdio/fprintf.c +++ b/libc/stdio/fprintf.c @@ -8,16 +8,18 @@ #include "_stdio.h" #include <stdarg.h> -#undef fprintf -int attribute_hidden __fprintf(FILE * __restrict stream, const char * __restrict format, ...) +libc_hidden_proto(vfprintf) + +libc_hidden_proto(fprintf) +int fprintf(FILE * __restrict stream, const char * __restrict format, ...) { va_list arg; int rv; va_start(arg, format); - rv = __vfprintf(stream, format, arg); + rv = vfprintf(stream, format, arg); va_end(arg); return rv; } -strong_alias(__fprintf,fprintf) +libc_hidden_def(fprintf) diff --git a/libc/stdio/fputc.c b/libc/stdio/fputc.c index 4cc396e08..8c80bff27 100644 --- a/libc/stdio/fputc.c +++ b/libc/stdio/fputc.c @@ -12,9 +12,11 @@ #undef putc #undef putc_unlocked +libc_hidden_proto(__fputc_unlocked) + #ifdef __DO_UNLOCKED -int attribute_hidden __fputc_unlocked_internal(int c, register FILE *stream) +int __fputc_unlocked(int c, register FILE *stream) { __STDIO_STREAM_VALIDATE(stream); @@ -68,20 +70,25 @@ int attribute_hidden __fputc_unlocked_internal(int c, register FILE *stream) BAD: return EOF; } +libc_hidden_def(__fputc_unlocked) + +strong_alias(__fputc_unlocked,fputc_unlocked) -strong_alias(__fputc_unlocked_internal,__fputc_unlocked) -weak_alias(__fputc_unlocked_internal,fputc_unlocked) -weak_alias(__fputc_unlocked_internal,putc_unlocked) +libc_hidden_proto(putc_unlocked) +strong_alias(__fputc_unlocked,putc_unlocked) +libc_hidden_def(putc_unlocked) #ifndef __UCLIBC_HAS_THREADS__ -hidden_strong_alias(__fputc_unlocked_internal,__fputc) -weak_alias(__fputc_unlocked_internal,fputc) -hidden_strong_alias(__fputc_unlocked_internal,__putc) -weak_alias(__fputc_unlocked_internal,putc) +strong_alias(__fputc_unlocked,fputc) + +libc_hidden_proto(putc) +strong_alias(__fputc_unlocked,putc) +libc_hidden_def(putc) #endif #elif defined __UCLIBC_HAS_THREADS__ -int attribute_hidden __fputc(int c, register FILE *stream) +libc_hidden_proto(fputc) +int fputc(int c, register FILE *stream) { if (stream->__user_locking != 0) { return __PUTC_UNLOCKED_MACRO(c, stream); @@ -93,8 +100,10 @@ int attribute_hidden __fputc(int c, register FILE *stream) return retval; } } -strong_alias(__fputc,fputc) -hidden_strong_alias(__fputc,__putc) -weak_alias(__fputc,putc) +libc_hidden_def(fputc) + +libc_hidden_proto(putc) +strong_alias(fputc,putc) +libc_hidden_def(putc) #endif diff --git a/libc/stdio/fputc_unlocked.c b/libc/stdio/fputc_unlocked.c new file mode 100644 index 000000000..dc4c77a51 --- /dev/null +++ b/libc/stdio/fputc_unlocked.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define __DO_UNLOCKED +#include "fputc.c" diff --git a/libc/stdio/fputs.c b/libc/stdio/fputs.c index 64e7fd57f..4111491d6 100644 --- a/libc/stdio/fputs.c +++ b/libc/stdio/fputs.c @@ -7,6 +7,11 @@ #include "_stdio.h" +libc_hidden_proto(fputs_unlocked) + +libc_hidden_proto(strlen) +libc_hidden_proto(fwrite_unlocked) + /* Note: The standard says fputs returns a nonnegative number on * success. In this implementation, we return the length of the * string written on success. @@ -14,35 +19,37 @@ #ifdef __DO_UNLOCKED -int attribute_hidden __fputs_unlocked(register const char * __restrict s, +int fputs_unlocked(register const char * __restrict s, FILE * __restrict stream) { - size_t n = __strlen(s); + size_t n = strlen(s); - return ((__fwrite_unlocked(s, 1, n, stream) == n) ? n : EOF); + return ((fwrite_unlocked(s, 1, n, stream) == n) ? n : EOF); } +libc_hidden_def(fputs_unlocked) -weak_alias(__fputs_unlocked,fputs_unlocked) #ifndef __UCLIBC_HAS_THREADS__ -hidden_strong_alias(__fputs_unlocked,__fputs) -weak_alias(__fputs_unlocked,fputs) +libc_hidden_proto(fputs) +strong_alias(fputs_unlocked,fputs) +libc_hidden_def(fputs) #endif #elif defined __UCLIBC_HAS_THREADS__ -int attribute_hidden __fputs(const char * __restrict s, register FILE * __restrict stream) +libc_hidden_proto(fputs) +int fputs(const char * __restrict s, register FILE * __restrict stream) { int retval; __STDIO_AUTO_THREADLOCK_VAR; __STDIO_AUTO_THREADLOCK(stream); - retval = __fputs_unlocked(s, stream); + retval = fputs_unlocked(s, stream); __STDIO_AUTO_THREADUNLOCK(stream); return retval; } -strong_alias(__fputs,fputs) +libc_hidden_def(fputs) #endif diff --git a/libc/stdio/fputs_unlocked.c b/libc/stdio/fputs_unlocked.c new file mode 100644 index 000000000..c7ff3f59b --- /dev/null +++ b/libc/stdio/fputs_unlocked.c @@ -0,0 +1,14 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ + +#include <features.h> + +#ifdef __USE_GNU +# define __DO_UNLOCKED +# include "fputs.c" +#endif diff --git a/libc/stdio/fputwc.c b/libc/stdio/fputwc.c index 8f1178710..240c1e9c4 100644 --- a/libc/stdio/fputwc.c +++ b/libc/stdio/fputwc.c @@ -7,18 +7,20 @@ #include "_stdio.h" +libc_hidden_proto(fputwc_unlocked) + #ifdef __DO_UNLOCKED -wint_t attribute_hidden __fputwc_unlocked(wchar_t wc, FILE *stream) +wint_t fputwc_unlocked(wchar_t wc, FILE *stream) { return _wstdio_fwrite(&wc, 1, stream) ? wc : WEOF; } +libc_hidden_def(fputwc_unlocked) -weak_alias(__fputwc_unlocked,fputwc_unlocked) -weak_alias(__fputwc_unlocked,putwc_unlocked) +strong_alias(fputwc_unlocked,putwc_unlocked) #ifndef __UCLIBC_HAS_THREADS__ -weak_alias(__fputwc_unlocked,fputwc) -weak_alias(__fputwc_unlocked,putwc) +strong_alias(fputwc_unlocked,fputwc) +strong_alias(fputwc_unlocked,putwc) #endif #elif defined __UCLIBC_HAS_THREADS__ @@ -30,13 +32,13 @@ wint_t fputwc(wchar_t wc, register FILE *stream) __STDIO_AUTO_THREADLOCK(stream); - retval = __fputwc_unlocked(wc, stream); + retval = fputwc_unlocked(wc, stream); __STDIO_AUTO_THREADUNLOCK(stream); return retval; } -weak_alias(fputwc,putwc) +strong_alias(fputwc,putwc) #endif diff --git a/libc/stdio/fputwc_unlocked.c b/libc/stdio/fputwc_unlocked.c new file mode 100644 index 000000000..757cbd0d2 --- /dev/null +++ b/libc/stdio/fputwc_unlocked.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define __DO_UNLOCKED +#include "fputwc.c" diff --git a/libc/stdio/fputws.c b/libc/stdio/fputws.c index 74919d6ea..ecbc121dd 100644 --- a/libc/stdio/fputws.c +++ b/libc/stdio/fputws.c @@ -5,44 +5,45 @@ * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. */ -#define wcslen __wcslen - #include "_stdio.h" +libc_hidden_proto(fputws_unlocked) + +libc_hidden_proto(wcslen) + #ifdef __DO_UNLOCKED -int attribute_hidden __fputws_unlocked(const wchar_t *__restrict ws, +int fputws_unlocked(const wchar_t *__restrict ws, register FILE *__restrict stream) { size_t n = wcslen(ws); return (_wstdio_fwrite(ws, n, stream) == n) ? 0 : -1; } +libc_hidden_def(fputws_unlocked) -weak_alias(__fputws_unlocked,fputws_unlocked) #ifndef __UCLIBC_HAS_THREADS__ -hidden_strong_alias(__fputws_unlocked,__fputws) -weak_alias(__fputws_unlocked,fputws) +libc_hidden_proto(fputws) +strong_alias(fputws_unlocked,fputws) +libc_hidden_def(fputws) #endif #elif defined __UCLIBC_HAS_THREADS__ -extern int __fputws_unlocked(const wchar_t *__restrict ws, - FILE *__restrict stream) attribute_hidden; - -int attribute_hidden __fputws(const wchar_t *__restrict ws, register FILE *__restrict stream) +libc_hidden_proto(fputws) +int fputws(const wchar_t *__restrict ws, register FILE *__restrict stream) { int retval; __STDIO_AUTO_THREADLOCK_VAR; __STDIO_AUTO_THREADLOCK(stream); - retval = __fputws_unlocked(ws, stream); + retval = fputws_unlocked(ws, stream); __STDIO_AUTO_THREADUNLOCK(stream); return retval; } -strong_alias(__fputws,fputws) +libc_hidden_def(fputws) #endif diff --git a/libc/stdio/fputws_unlocked.c b/libc/stdio/fputws_unlocked.c new file mode 100644 index 000000000..b3a037771 --- /dev/null +++ b/libc/stdio/fputws_unlocked.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define __DO_UNLOCKED +#include "fputws.c" diff --git a/libc/stdio/fread.c b/libc/stdio/fread.c index 0defb36a0..c603a9d2e 100644 --- a/libc/stdio/fread.c +++ b/libc/stdio/fread.c @@ -7,9 +7,14 @@ #include "_stdio.h" +libc_hidden_proto(fread_unlocked) + #ifdef __DO_UNLOCKED -size_t attribute_hidden __fread_unlocked(void * __restrict ptr, size_t size, size_t nmemb, +libc_hidden_proto(memcpy) +libc_hidden_proto(fflush_unlocked) + +size_t fread_unlocked(void * __restrict ptr, size_t size, size_t nmemb, FILE * __restrict stream) { __STDIO_STREAM_VALIDATE(stream); @@ -44,7 +49,7 @@ size_t attribute_hidden __fread_unlocked(void * __restrict ptr, size_t size, siz if (avail > todo) { avail = todo; } - __memcpy(buffer, stream->__bufpos, avail); + memcpy(buffer, stream->__bufpos, avail); buffer += avail; stream->__bufpos += avail; if (!(todo -= avail)) { @@ -82,16 +87,18 @@ size_t attribute_hidden __fread_unlocked(void * __restrict ptr, size_t size, siz __STDIO_STREAM_VALIDATE(stream); return 0; } +libc_hidden_def(fread_unlocked) -weak_alias(__fread_unlocked,fread_unlocked) #ifndef __UCLIBC_HAS_THREADS__ -hidden_strong_alias(__fread_unlocked,__fread) -weak_alias(__fread_unlocked,fread) +libc_hidden_proto(fread) +strong_alias(fread_unlocked,fread) +libc_hidden_def(fread) #endif #elif defined __UCLIBC_HAS_THREADS__ -size_t attribute_hidden __fread(void * __restrict ptr, size_t size, size_t nmemb, +libc_hidden_proto(fread) +size_t fread(void * __restrict ptr, size_t size, size_t nmemb, register FILE * __restrict stream) { size_t retval; @@ -99,12 +106,12 @@ size_t attribute_hidden __fread(void * __restrict ptr, size_t size, size_t nmemb __STDIO_AUTO_THREADLOCK(stream); - retval = __fread_unlocked(ptr, size, nmemb, stream); + retval = fread_unlocked(ptr, size, nmemb, stream); __STDIO_AUTO_THREADUNLOCK(stream); return retval; } -strong_alias(__fread,fread) +libc_hidden_def(fread) #endif diff --git a/libc/stdio/fread_unlocked.c b/libc/stdio/fread_unlocked.c new file mode 100644 index 000000000..441edbb64 --- /dev/null +++ b/libc/stdio/fread_unlocked.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define __DO_UNLOCKED +#include "fread.c" diff --git a/libc/stdio/freopen.c b/libc/stdio/freopen.c index 7df035d48..7314807d3 100644 --- a/libc/stdio/freopen.c +++ b/libc/stdio/freopen.c @@ -7,6 +7,8 @@ #include "_stdio.h" +libc_hidden_proto(fclose) + #ifndef __DO_LARGEFILE # define FILEDES_ARG (-1) #endif diff --git a/libc/stdio/fscanf.c b/libc/stdio/fscanf.c new file mode 100644 index 000000000..102cb8d59 --- /dev/null +++ b/libc/stdio/fscanf.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define L_fscanf +#include "_scanf.c" diff --git a/libc/stdio/fseeko.c b/libc/stdio/fseeko.c index 190485775..f63ebad4e 100644 --- a/libc/stdio/fseeko.c +++ b/libc/stdio/fseeko.c @@ -12,15 +12,20 @@ #endif #ifndef __DO_LARGEFILE -# define FSEEK __fseek +# define FSEEK fseek # define OFFSET_TYPE long int #endif -int attribute_hidden FSEEK(register FILE *stream, OFFSET_TYPE offset, int whence) +#ifdef __UCLIBC_HAS_LFS__ +libc_hidden_proto(fseeko64) +#endif +libc_hidden_proto(fseek) + +int FSEEK(register FILE *stream, OFFSET_TYPE offset, int whence) { #if defined(__UCLIBC_HAS_LFS__) && !defined(__DO_LARGEFILE) - return __fseeko64(stream, offset, whence); + return fseeko64(stream, offset, whence); #else @@ -74,8 +79,8 @@ int attribute_hidden FSEEK(register FILE *stream, OFFSET_TYPE offset, int whence } #ifdef __DO_LARGEFILE -strong_alias(__fseeko64,fseeko64) +libc_hidden_def(fseeko64) #else -strong_alias(__fseek,fseek) -weak_alias(__fseek,fseeko) +libc_hidden_def(fseek) +strong_alias(fseek,fseeko) #endif diff --git a/libc/stdio/fseeko64.c b/libc/stdio/fseeko64.c index 5bc4ae34e..78cab1b5c 100644 --- a/libc/stdio/fseeko64.c +++ b/libc/stdio/fseeko64.c @@ -8,6 +8,6 @@ #include "_stdio.h" #define __DO_LARGEFILE -#define FSEEK __fseeko64 +#define FSEEK fseeko64 #define OFFSET_TYPE __off64_t #include "fseeko.c" diff --git a/libc/stdio/fsetpos.c b/libc/stdio/fsetpos.c index f33043f3b..d63adc024 100644 --- a/libc/stdio/fsetpos.c +++ b/libc/stdio/fsetpos.c @@ -8,9 +8,11 @@ #include "_stdio.h" #ifndef __DO_LARGEFILE -#define FSEEK __fseek +#define FSEEK fseek #endif +libc_hidden_proto(FSEEK) + int fsetpos(FILE *stream, register const fpos_t *pos) { #ifdef __STDIO_MBSTATE diff --git a/libc/stdio/fsetpos64.c b/libc/stdio/fsetpos64.c index bf7d574cb..82819a4fe 100644 --- a/libc/stdio/fsetpos64.c +++ b/libc/stdio/fsetpos64.c @@ -10,5 +10,5 @@ #define __DO_LARGEFILE #define fsetpos fsetpos64 #define fpos_t fpos64_t -#define FSEEK __fseeko64 +#define FSEEK fseeko64 #include "fsetpos.c" diff --git a/libc/stdio/ftello.c b/libc/stdio/ftello.c index 7f5c53126..4445471a4 100644 --- a/libc/stdio/ftello.c +++ b/libc/stdio/ftello.c @@ -7,16 +7,21 @@ #include "_stdio.h" +#ifdef __UCLIBC_HAS_LFS__ +libc_hidden_proto(ftello64) +#endif +libc_hidden_proto(ftell) + #ifndef __DO_LARGEFILE -# define FTELL __ftell +# define FTELL ftell # define OFFSET_TYPE long int #endif -OFFSET_TYPE attribute_hidden FTELL(register FILE *stream) +OFFSET_TYPE FTELL(register FILE *stream) { #if defined(__UCLIBC_HAS_LFS__) && !defined(__DO_LARGEFILE) - __offmax_t pos = __ftello64(stream); + __offmax_t pos = ftello64(stream); if ((sizeof(long) >= sizeof(__offmax_t)) || (((long) pos) == pos)) { return ((long) pos); @@ -47,8 +52,8 @@ OFFSET_TYPE attribute_hidden FTELL(register FILE *stream) } #ifdef __DO_LARGEFILE -weak_alias(__ftello64,ftello64) +libc_hidden_def(ftello64) #else -weak_alias(__ftell,ftell) -weak_alias(ftell,ftello) +libc_hidden_def(ftell) +strong_alias(ftell,ftello) #endif diff --git a/libc/stdio/ftello64.c b/libc/stdio/ftello64.c index 32a37d368..905834f39 100644 --- a/libc/stdio/ftello64.c +++ b/libc/stdio/ftello64.c @@ -8,6 +8,6 @@ #include "_stdio.h" #define __DO_LARGEFILE -#define FTELL __ftello64 +#define FTELL ftello64 #define OFFSET_TYPE __off64_t #include "ftello.c" diff --git a/libc/stdio/fwprintf.c b/libc/stdio/fwprintf.c index c81d40482..f2a1afbec 100644 --- a/libc/stdio/fwprintf.c +++ b/libc/stdio/fwprintf.c @@ -9,13 +9,15 @@ #include <stdarg.h> #include <wchar.h> +libc_hidden_proto(vfwprintf) + int fwprintf(FILE * __restrict stream, const wchar_t * __restrict format, ...) { va_list arg; int rv; va_start(arg, format); - rv = __vfwprintf(stream, format, arg); + rv = vfwprintf(stream, format, arg); va_end(arg); return rv; diff --git a/libc/stdio/fwrite.c b/libc/stdio/fwrite.c index abe24fbb7..7be794ab4 100644 --- a/libc/stdio/fwrite.c +++ b/libc/stdio/fwrite.c @@ -7,9 +7,11 @@ #include "_stdio.h" +libc_hidden_proto(fwrite_unlocked) + #ifdef __DO_UNLOCKED -size_t attribute_hidden __fwrite_unlocked(const void * __restrict ptr, size_t size, +size_t fwrite_unlocked(const void * __restrict ptr, size_t size, size_t nmemb, register FILE * __restrict stream) { __STDIO_STREAM_VALIDATE(stream); @@ -33,16 +35,18 @@ size_t attribute_hidden __fwrite_unlocked(const void * __restrict ptr, size_t si return 0; } +libc_hidden_def(fwrite_unlocked) -weak_alias(__fwrite_unlocked,fwrite_unlocked) #ifndef __UCLIBC_HAS_THREADS__ -hidden_strong_alias(__fwrite_unlocked,__fwrite) -weak_alias(__fwrite_unlocked,fwrite) +libc_hidden_proto(fwrite) +strong_alias(fwrite_unlocked,fwrite) +libc_hidden_def(fwrite) #endif #elif defined __UCLIBC_HAS_THREADS__ -size_t attribute_hidden __fwrite(const void * __restrict ptr, size_t size, +libc_hidden_proto(fwrite) +size_t fwrite(const void * __restrict ptr, size_t size, size_t nmemb, register FILE * __restrict stream) { size_t retval; @@ -50,12 +54,12 @@ size_t attribute_hidden __fwrite(const void * __restrict ptr, size_t size, __STDIO_AUTO_THREADLOCK(stream); - retval = __fwrite_unlocked(ptr, size, nmemb, stream); + retval = fwrite_unlocked(ptr, size, nmemb, stream); __STDIO_AUTO_THREADUNLOCK(stream); return retval; } -strong_alias(__fwrite,fwrite) +libc_hidden_def(fwrite) #endif diff --git a/libc/stdio/fwrite_unlocked.c b/libc/stdio/fwrite_unlocked.c new file mode 100644 index 000000000..0f9e026c0 --- /dev/null +++ b/libc/stdio/fwrite_unlocked.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define __DO_UNLOCKED +#include "fwrite.c" diff --git a/libc/stdio/fwscanf.c b/libc/stdio/fwscanf.c new file mode 100644 index 000000000..3409d00a0 --- /dev/null +++ b/libc/stdio/fwscanf.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define L_fwscanf +#include "_scanf.c" diff --git a/libc/stdio/getchar.c b/libc/stdio/getchar.c index d17704056..6da8307b6 100644 --- a/libc/stdio/getchar.c +++ b/libc/stdio/getchar.c @@ -7,21 +7,21 @@ #include "_stdio.h" -#undef getchar_unlocked -#undef getchar +libc_hidden_proto(__fgetc_unlocked) +#undef getchar #ifdef __DO_UNLOCKED -int attribute_hidden __getchar_unlocked(void) +#undef getchar_unlocked +int getchar_unlocked(void) { register FILE *stream = stdin; return __GETC_UNLOCKED_MACRO(stream); } -weak_alias(__getchar_unlocked,getchar_unlocked) #ifndef __UCLIBC_HAS_THREADS__ -weak_alias(__getchar_unlocked,getchar) +strong_alias(getchar_unlocked,getchar) #endif #elif defined __UCLIBC_HAS_THREADS__ diff --git a/libc/stdio/getchar_unlocked.c b/libc/stdio/getchar_unlocked.c new file mode 100644 index 000000000..60ea25129 --- /dev/null +++ b/libc/stdio/getchar_unlocked.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define __DO_UNLOCKED +#include "getchar.c" diff --git a/libc/stdio/getdelim.c b/libc/stdio/getdelim.c index e1b808340..21c86f400 100644 --- a/libc/stdio/getdelim.c +++ b/libc/stdio/getdelim.c @@ -5,8 +5,15 @@ * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. */ +#include <features.h> + +#ifdef __USE_GNU #include "_stdio.h" +libc_hidden_proto(getdelim) + +libc_hidden_proto(__fgetc_unlocked) + /* Note: There is a defect in this function. (size_t vs ssize_t). */ /* glibc function -- @@ -20,7 +27,7 @@ #define GETDELIM_GROWBY 64 -ssize_t attribute_hidden __getdelim(char **__restrict lineptr, size_t *__restrict n, +ssize_t getdelim(char **__restrict lineptr, size_t *__restrict n, int delimiter, register FILE *__restrict stream) { register char *buf; @@ -73,5 +80,5 @@ ssize_t attribute_hidden __getdelim(char **__restrict lineptr, size_t *__restric return pos; } - -strong_alias(__getdelim,getdelim) +libc_hidden_def(getdelim) +#endif diff --git a/libc/stdio/getline.c b/libc/stdio/getline.c index 943526abe..22b67b831 100644 --- a/libc/stdio/getline.c +++ b/libc/stdio/getline.c @@ -5,13 +5,19 @@ * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. */ -#define getdelim __getdelim +#include <features.h> +#ifdef __USE_GNU #include "_stdio.h" -ssize_t attribute_hidden __getline(char **__restrict lineptr, size_t *__restrict n, +libc_hidden_proto(getline) + +libc_hidden_proto(getdelim) + +ssize_t getline(char **__restrict lineptr, size_t *__restrict n, FILE *__restrict stream) { return getdelim(lineptr, n, '\n', stream); } -strong_alias(__getline,getline) +libc_hidden_def(getline) +#endif diff --git a/libc/stdio/gets.c b/libc/stdio/gets.c index 1badd8152..5ff7869dc 100644 --- a/libc/stdio/gets.c +++ b/libc/stdio/gets.c @@ -11,6 +11,14 @@ link_warning(gets, "the 'gets' function is dangerous and should not be used.") /* UNSAFE FUNCTION -- do not bother optimizing */ +libc_hidden_proto(getchar_unlocked) +libc_hidden_proto(__fgetc_unlocked) +#ifdef __STDIO_GETC_MACRO +libc_hidden_proto(__stdin) +#else +#define __stdin stdin +#endif + char *gets(char *s) { register char *p = s; @@ -21,7 +29,7 @@ char *gets(char *s) /* Note: don't worry about performance here... this shouldn't be used! * Therefore, force actual function call. */ - while (((c = __getchar_unlocked()) != EOF) && ((*p = c) != '\n')) { + while (((c = getchar_unlocked()) != EOF) && ((*p = c) != '\n')) { ++p; } if ((c == EOF) || (s == p)) { diff --git a/libc/stdio/getw.c b/libc/stdio/getw.c index 6b3b9e5e7..e3aeda92c 100644 --- a/libc/stdio/getw.c +++ b/libc/stdio/getw.c @@ -7,12 +7,14 @@ #include "_stdio.h" +libc_hidden_proto(fread_unlocked) + /* SUSv2 Legacy function -- need not be reentrant. */ int getw(FILE *stream) { int aw; - return (__fread_unlocked((void *) &aw, sizeof(int), 1, stream) != 0) + return (fread_unlocked((void *) &aw, sizeof(int), 1, stream) != 0) ? aw : EOF; } diff --git a/libc/stdio/getwchar.c b/libc/stdio/getwchar.c index 90e5a032e..9c480b564 100644 --- a/libc/stdio/getwchar.c +++ b/libc/stdio/getwchar.c @@ -9,23 +9,24 @@ #ifdef __DO_UNLOCKED -wint_t __getwchar_unlocked(void) +libc_hidden_proto(fgetwc_unlocked) + +wint_t getwchar_unlocked(void) { - return __fgetwc_unlocked(stdin); + return fgetwc_unlocked(stdin); } -weak_alias(__getwchar_unlocked,getwchar_unlocked) #ifndef __UCLIBC_HAS_THREADS__ -weak_alias(__getwchar_unlocked,getwchar) +strong_alias(getwchar_unlocked,getwchar) #endif #elif defined __UCLIBC_HAS_THREADS__ -extern wint_t __fgetwc (__FILE *__stream) attribute_hidden; +libc_hidden_proto(fgetwc) wint_t getwchar(void) { - return __fgetwc(stdin); + return fgetwc(stdin); } #endif diff --git a/libc/stdio/getwchar_unlocked.c b/libc/stdio/getwchar_unlocked.c new file mode 100644 index 000000000..af4a9e888 --- /dev/null +++ b/libc/stdio/getwchar_unlocked.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define __DO_UNLOCKED +#include "getwchar.c" diff --git a/libc/stdio/old_vfprintf.c b/libc/stdio/old_vfprintf.c index ce6bde1a4..f81ef8688 100644 --- a/libc/stdio/old_vfprintf.c +++ b/libc/stdio/old_vfprintf.c @@ -127,10 +127,7 @@ /**************************************************************************/ -#define strnlen __strnlen - #define _ISOC99_SOURCE /* for ULLONG primarily... */ -#define _GNU_SOURCE /* for strnlen */ #include "_stdio.h" /* #include <stdio.h> */ #include <stdarg.h> @@ -148,6 +145,13 @@ #include <pthread.h> #endif /* __UCLIBC_HAS_THREADS__ */ +libc_hidden_proto(strlen) +libc_hidden_proto(strnlen) +libc_hidden_proto(memcpy) +libc_hidden_proto(putc_unlocked) +libc_hidden_proto(__fputc_unlocked) +libc_hidden_proto(__glibc_strerror_r) + /* #undef __UCLIBC_HAS_FLOATS__ */ /* #undef WANT_FLOAT_ERROR */ /* #define WANT_FLOAT_ERROR 1 */ @@ -166,7 +170,7 @@ #ifdef __STDIO_BUFFERS -#define PUTC(C,F) __putc_unlocked((C),(F)) +#define PUTC(C,F) putc_unlocked((C),(F)) #define OUTNSTR _outnstr #define _outnstr(stream, string, len) __stdio_fwrite(string, len, stream) @@ -190,7 +194,7 @@ static void _outnstr(FILE *stream, const unsigned char *s, size_t n) if (r > n) { r = n; } - __memcpy(f->bufpos, s, r); + memcpy(f->bufpos, s, r); f->bufpos += r; } } @@ -199,7 +203,7 @@ static void _outnstr(FILE *stream, const unsigned char *s, size_t n) static void putc_unlocked_sprintf(int c, __FILE_vsnprintf *f) { if (!__STDIO_STREAM_IS_FAKE_VSNPRINTF_NB(&f->f)) { - __putc_unlocked(c, &f->f); + putc_unlocked(c, &f->f); } else if (f->bufpos < f->bufend) { *f->bufpos++ = c; } @@ -236,7 +240,7 @@ static void _charpad(FILE * __restrict stream, int padchar, size_t numpad) static void _fp_out_narrow(FILE *fp, intptr_t type, intptr_t len, intptr_t buf) { if (type & 0x80) { /* Some type of padding needed. */ - int buflen = __strlen((const char *) buf); + int buflen = strlen((const char *) buf); if ((len -= buflen) > 0) { _charpad(fp, (type & 0x7f), len); } @@ -341,7 +345,8 @@ static const char u_spec[] = "%nbopxXudics"; /* u_radix[i] <-> u_spec[i+2] for unsigned entries only */ static const char u_radix[] = "\x02\x08\x10\x10\x10\x0a"; -int attribute_hidden __vfprintf(FILE * __restrict op, register const char * __restrict fmt, +libc_hidden_proto(vfprintf) +int vfprintf(FILE * __restrict op, register const char * __restrict fmt, va_list ap) { union { @@ -450,7 +455,7 @@ int attribute_hidden __vfprintf(FILE * __restrict op, register const char * __re if (*fmt == 'm') { flag[FLAG_PLUS] = '\0'; flag[FLAG_0_PAD] = ' '; - p = __glibc_strerror_r_internal(errno, tmp, sizeof(tmp)); + p = __glibc_strerror_r(errno, tmp, sizeof(tmp)); goto print; } #endif @@ -711,4 +716,4 @@ int attribute_hidden __vfprintf(FILE * __restrict op, register const char * __re return i; } -strong_alias(__vfprintf,vfprintf) +libc_hidden_def(vfprintf) diff --git a/libc/stdio/open_memstream.c b/libc/stdio/open_memstream.c index f750cd11c..25c2f9f61 100644 --- a/libc/stdio/open_memstream.c +++ b/libc/stdio/open_memstream.c @@ -5,10 +5,15 @@ * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. */ -#define fopencookie __fopencookie +#include <features.h> +#ifdef __USE_GNU #include "_stdio.h" +libc_hidden_proto(memcpy) +libc_hidden_proto(memset) +libc_hidden_proto(fopencookie) + #ifndef __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__ #error no custom streams! #endif @@ -53,7 +58,7 @@ static ssize_t oms_write(register void *cookie, const char *buf, size_t bufsize) } } - __memcpy(COOKIE->buf + COOKIE->pos, buf, bufsize); + memcpy(COOKIE->buf + COOKIE->pos, buf, bufsize); COOKIE->pos += bufsize; if (COOKIE->pos > COOKIE->eof) { @@ -92,7 +97,7 @@ static int oms_seek(register void *cookie, __offmax_t *pos, int whence) if (buf) { *COOKIE->bufloc = COOKIE->buf = buf; COOKIE->len = leastlen; - __memset(buf + COOKIE->eof, leastlen - COOKIE->eof, 0); /* 0-fill */ + memset(buf + COOKIE->eof, leastlen - COOKIE->eof, 0); /* 0-fill */ } else { /* TODO: check glibc errno setting... */ return -1; @@ -102,7 +107,7 @@ static int oms_seek(register void *cookie, __offmax_t *pos, int whence) *pos = COOKIE->pos = --leastlen; if (leastlen > COOKIE->eof) { - __memset(COOKIE->buf + COOKIE->eof, leastlen - COOKIE->eof, 0); + memset(COOKIE->buf + COOKIE->eof, leastlen - COOKIE->eof, 0); *COOKIE->sizeloc = COOKIE->eof; } @@ -126,7 +131,8 @@ static const cookie_io_functions_t _oms_io_funcs = { * (ie replace the FILE buffer with the cookie buffer and update FILE bufstart, * etc. whenever we seek). */ -FILE attribute_hidden *__open_memstream(char **__restrict bufloc, size_t *__restrict sizeloc) +libc_hidden_proto(open_memstream) +FILE *open_memstream(char **__restrict bufloc, size_t *__restrict sizeloc) { register __oms_cookie *cookie; register FILE *fp; @@ -162,4 +168,5 @@ FILE attribute_hidden *__open_memstream(char **__restrict bufloc, size_t *__rest return NULL; } -strong_alias(__open_memstream,open_memstream) +libc_hidden_def(open_memstream) +#endif diff --git a/libc/stdio/parse_printf_format.c b/libc/stdio/parse_printf_format.c new file mode 100644 index 000000000..38266b3de --- /dev/null +++ b/libc/stdio/parse_printf_format.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define L_parse_printf_format +#include "_vfprintf.c" diff --git a/libc/stdio/perror.c b/libc/stdio/perror.c index 9edcf4efb..2c3cbbdb5 100644 --- a/libc/stdio/perror.c +++ b/libc/stdio/perror.c @@ -7,11 +7,16 @@ #include "_stdio.h" +libc_hidden_proto(fprintf) +libc_hidden_proto(__glibc_strerror_r) +libc_hidden_proto(stderr) + #ifdef __UCLIBC_MJN3_ONLY__ #warning CONSIDER: Increase buffer size for error message (non-%m case)? #endif -void attribute_hidden __perror(register const char *s) +libc_hidden_proto(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 @@ -30,8 +35,8 @@ void attribute_hidden __perror(register const char *s) { char buf[64]; fprintf(stderr, "%s%s%s\n", s, sep, - __glibc_strerror_r_internal(errno, buf, sizeof(buf))); + __glibc_strerror_r(errno, buf, sizeof(buf))); } #endif } -strong_alias(__perror,perror) +libc_hidden_def(perror) diff --git a/libc/stdio/popen.c b/libc/stdio/popen.c index f84a27a3c..2163d7f8c 100644 --- a/libc/stdio/popen.c +++ b/libc/stdio/popen.c @@ -1,6 +1,7 @@ /* Copyright (C) 2004 Manuel Novoa III <mjn3@codepoet.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> * - * GNU Library General Public License (LGPL) version 2 or later. + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. * * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. */ @@ -14,26 +15,29 @@ * Fix failure exit code for failed execve(). */ -#define waitpid __waitpid -#define execl __execl -#define dup2 __dup2 -#define fdopen __fdopen -#define pipe __pipe -#define vfork __vfork -#define fork __fork - #include <stdio.h> #include <stdlib.h> #include <errno.h> #include <unistd.h> #include <sys/wait.h> +libc_hidden_proto(close) +libc_hidden_proto(_exit) +libc_hidden_proto(waitpid) +libc_hidden_proto(execl) +libc_hidden_proto(dup2) +libc_hidden_proto(fdopen) +libc_hidden_proto(pipe) +libc_hidden_proto(vfork) +libc_hidden_proto(fclose) + /* uClinux-2.0 has vfork, but Linux 2.0 doesn't */ #include <sys/syscall.h> #if ! defined __NR_vfork # define vfork fork # define VFORK_LOCK ((void) 0) # define VFORK_UNLOCK ((void) 0) +libc_hidden_proto(fork) #endif #ifdef __UCLIBC_HAS_THREADS__ @@ -88,36 +92,36 @@ FILE *popen(const char *command, const char *modes) parent_fd = pipe_fd[1-child_writing]; if (!(fp = fdopen(parent_fd, modes))) { - __close(parent_fd); - __close(child_fd); + close(parent_fd); + close(child_fd); goto FREE_PI; } VFORK_LOCK; if ((pid = vfork()) == 0) { /* Child of vfork... */ - __close(parent_fd); + close(parent_fd); if (child_fd != child_writing) { dup2(child_fd, child_writing); - __close(child_fd); + close(child_fd); } /* SUSv3 requires that any previously popen()'d streams in the * parent shall be closed in the child. */ for (po = popen_list ; po ; po = po->next) { - __close(po->f->__filedes); + close(po->f->__filedes); } execl("/bin/sh", "sh", "-c", command, (char *)0); /* SUSv3 mandates an exit code of 127 for the child if the * command interpreter can not be invoked. */ - _exit_internal(127); + _exit(127); } VFORK_UNLOCK; /* We need to close the child filedes whether vfork failed or * it succeeded and we're in the parent. */ - __close(child_fd); + close(child_fd); if (pid > 0) { /* Parent of vfork... */ pi->pid = pid; diff --git a/libc/stdio/printf.c b/libc/stdio/printf.c index 82326a9c3..617561fec 100644 --- a/libc/stdio/printf.c +++ b/libc/stdio/printf.c @@ -8,15 +8,18 @@ #include "_stdio.h" #include <stdarg.h> -int attribute_hidden __printf(const char * __restrict format, ...) +libc_hidden_proto(vfprintf) + +libc_hidden_proto(printf) +int printf(const char * __restrict format, ...) { va_list arg; int rv; va_start(arg, format); - rv = __vfprintf(stdout, format, arg); + rv = vfprintf(stdout, format, arg); va_end(arg); return rv; } -strong_alias(__printf,printf) +libc_hidden_def(printf) diff --git a/libc/stdio/putchar.c b/libc/stdio/putchar.c index e503b9484..b54a7a815 100644 --- a/libc/stdio/putchar.c +++ b/libc/stdio/putchar.c @@ -7,21 +7,21 @@ #include "_stdio.h" -#undef putchar_unlocked -#undef putchar +libc_hidden_proto(__fputc_unlocked) +#undef putchar #ifdef __DO_UNLOCKED -int __putchar_unlocked(int c) +#undef putchar_unlocked +int putchar_unlocked(int c) { register FILE *stream = stdout; return __PUTC_UNLOCKED_MACRO(c, stream); } -weak_alias(__putchar_unlocked,putchar_unlocked) #ifndef __UCLIBC_HAS_THREADS__ -weak_alias(__putchar_unlocked,putchar) +strong_alias(putchar_unlocked,putchar) #endif #elif defined __UCLIBC_HAS_THREADS__ diff --git a/libc/stdio/putchar_unlocked.c b/libc/stdio/putchar_unlocked.c new file mode 100644 index 000000000..6d6ec471a --- /dev/null +++ b/libc/stdio/putchar_unlocked.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define __DO_UNLOCKED +#include "putchar.c" diff --git a/libc/stdio/puts.c b/libc/stdio/puts.c index 3a510325b..08525b2f6 100644 --- a/libc/stdio/puts.c +++ b/libc/stdio/puts.c @@ -7,6 +7,9 @@ #include "_stdio.h" +libc_hidden_proto(__fputc_unlocked) +libc_hidden_proto(fputs_unlocked) + int puts(register const char * __restrict s) { register FILE *stream = stdout; /* This helps bcc optimize. */ @@ -20,9 +23,9 @@ int puts(register const char * __restrict s) * then we could have a newline in the buffer of an LBF stream. */ /* Note: Nonportable as fputs need only return nonnegative on success. */ - if ((n = __fputs_unlocked(s, stream)) != EOF) { + if ((n = fputs_unlocked(s, stream)) != EOF) { ++n; - if (__fputc_unlocked_internal('\n', stream) == EOF) { + if (__fputc_unlocked('\n', stream) == EOF) { n = EOF; } } diff --git a/libc/stdio/putw.c b/libc/stdio/putw.c index 5dfa06890..469e44aea 100644 --- a/libc/stdio/putw.c +++ b/libc/stdio/putw.c @@ -7,6 +7,8 @@ #include "_stdio.h" +libc_hidden_proto(fwrite_unlocked) + /* SUSv2 Legacy function -- need not be reentrant. */ int putw(int w, FILE *stream) @@ -20,9 +22,9 @@ int putw(int w, FILE *stream) #endif #if EOF == -1 - return __fwrite_unlocked((void *) PW, sizeof(int), 1, stream) - 1; + return fwrite_unlocked((void *) PW, sizeof(int), 1, stream) - 1; #else - return (__fwrite_unlocked((void *) PW, sizeof(int), 1, stream) != 0) + return (fwrite_unlocked((void *) PW, sizeof(int), 1, stream) != 0) ? 0 : EOF; #endif } diff --git a/libc/stdio/putwchar.c b/libc/stdio/putwchar.c index d093656e6..7a6501c28 100644 --- a/libc/stdio/putwchar.c +++ b/libc/stdio/putwchar.c @@ -9,23 +9,26 @@ #ifdef __DO_UNLOCKED -wint_t __putwchar_unlocked(wchar_t wc) +libc_hidden_proto(fputwc_unlocked) + +wint_t putwchar_unlocked(wchar_t wc) { - return __fputwc_unlocked(wc, stdout); + return fputwc_unlocked(wc, stdout); } -weak_alias(__putwchar_unlocked,putwchar_unlocked) #ifndef __UCLIBC_HAS_THREADS__ -weak_alias(__putwchar_unlocked,putwchar) +strong_alias(putwchar_unlocked,putwchar) #endif #elif defined __UCLIBC_HAS_THREADS__ -extern int __fputc (int __c, FILE *__stream) attribute_hidden; +libc_hidden_proto(__fputc_unlocked) +/* psm: should this be fputwc? */ +libc_hidden_proto(fputc) wint_t putwchar(wchar_t wc) { - return __fputc(wc, stdout); + return fputc(wc, stdout); } #endif diff --git a/libc/stdio/putwchar_unlocked.c b/libc/stdio/putwchar_unlocked.c new file mode 100644 index 000000000..5b0c60006 --- /dev/null +++ b/libc/stdio/putwchar_unlocked.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define __DO_UNLOCKED +#include "putwchar.c" diff --git a/libc/stdio/register_printf_function.c b/libc/stdio/register_printf_function.c new file mode 100644 index 000000000..c6b3240a7 --- /dev/null +++ b/libc/stdio/register_printf_function.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define L_register_printf_function +#include "_vfprintf.c" diff --git a/libc/stdio/remove.c b/libc/stdio/remove.c index 2d4fedcc1..04ab12edb 100644 --- a/libc/stdio/remove.c +++ b/libc/stdio/remove.c @@ -5,21 +5,22 @@ * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. */ -#define rmdir __rmdir -#define unlink __unlink - #include "_stdio.h" #include <unistd.h> #include <errno.h> +libc_hidden_proto(rmdir) +libc_hidden_proto(unlink) + /* SUSv3 states: * If path does not name a directory, remove(path) shall be equivalent * to unlink(path). If path names a directory, remove(path) shall be * equivalent to rmdir(path). */ -int attribute_hidden __remove(register const char *filename) +libc_hidden_proto(remove) +int remove(register const char *filename) { int saved_errno = errno; int rv; @@ -30,4 +31,4 @@ int attribute_hidden __remove(register const char *filename) } return rv; } -strong_alias(__remove,remove) +libc_hidden_def(remove) diff --git a/libc/stdio/rewind.c b/libc/stdio/rewind.c index 8e0acc2d0..e04d7a086 100644 --- a/libc/stdio/rewind.c +++ b/libc/stdio/rewind.c @@ -7,15 +7,18 @@ #include "_stdio.h" -void attribute_hidden __rewind(register FILE *stream) +libc_hidden_proto(fseek) + +libc_hidden_proto(rewind) +void rewind(register FILE *stream) { __STDIO_AUTO_THREADLOCK_VAR; __STDIO_AUTO_THREADLOCK(stream); __STDIO_STREAM_CLEAR_ERROR(stream); /* Clear the error indicator */ - __fseek(stream, 0L, SEEK_SET); /* first since fseek could set it. */ + fseek(stream, 0L, SEEK_SET); /* first since fseek could set it. */ __STDIO_AUTO_THREADUNLOCK(stream); } -strong_alias(__rewind,rewind) +libc_hidden_def(rewind) diff --git a/libc/stdio/scanf.c b/libc/stdio/scanf.c index ddc2bd75f..4943c88df 100644 --- a/libc/stdio/scanf.c +++ b/libc/stdio/scanf.c @@ -1,2258 +1,9 @@ -/* Copyright (C) 2002-2004 Manuel Novoa III +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> * - * 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. + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. * - * 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. - */ - -/* Aug 1, 2003 - * New *scanf implementation with lots of bug fixes and *wscanf support. - * Also now optionally supports hexadecimal float notation, positional - * args, and glibc locale-specific digit grouping. Should now be - * standards compliant. - * - * Aug 18, 2003 - * Bug fix: scanf %lc,%ls,%l[ would always set mb_fail on eof or error, - * even when just starting a new mb char. - * Bug fix: wscanf would incorrectly unget in certain situations. - * - * Sep 5, 2003 - * Bug fix: store flag wasn't respected if no positional args. - * Implement vs{n}scanf for the non-buffered stdio no-wchar case. - * - * Sep 13, 2003 - * Bug fix: Fix a problem reported by Atsushi Nemoto <anemo@mba.ocn.ne.jp> - * for environments where long and long long are the same. - * - * Sep 21, 2003 - * Ugh... EOF handling by scanf was completely broken. :-( Regretably, - * I got my mind fixed in one mode and didn't comply with the standards. - * Things should be fixed now, but comparision testing is difficult when - * glibc's scanf is broken and they stubbornly refuse to even acknowledge - * that it is... even when confronted by specific examples from the C99 - * standards and from an official C standard defect report. - */ - -#define wcslen __wcslen -#define mbsrtowcs __mbsrtowcs -#define mbrtowc __mbrtowc -#define ungetc __ungetc -#define ungetwc __ungetwc -#define iswspace __iswspace -#define wcrtomb __wcrtomb - -#define _ISOC99_SOURCE /* for LLONG_MAX primarily... */ -#define _GNU_SOURCE -#include <features.h> -#include "_stdio.h" -#include <stdlib.h> -#include <unistd.h> -#include <ctype.h> -#include <string.h> -#include <stdarg.h> -#include <stdint.h> -#include <errno.h> -#include <printf.h> - -#ifdef __UCLIBC_HAS_WCHAR__ -#include <bits/uClibc_uwchar.h> -#include <wchar.h> -#include <wctype.h> -#endif /* __UCLIBC_HAS_WCHAR__ */ - -#include <langinfo.h> -#include <locale.h> - -#include <assert.h> -#include <limits.h> - -#ifdef __UCLIBC_HAS_THREADS__ -#include <stdio_ext.h> -#include <pthread.h> -#endif /* __UCLIBC_HAS_THREADS__ */ - -#ifdef __UCLIBC_HAS_FLOATS__ -#include <float.h> -#include <bits/uClibc_fpmax.h> -#endif /* __UCLIBC_HAS_FLOATS__ */ - -#ifdef __UCLIBC_HAS_SCANF_GLIBC_A_FLAG__ -#ifdef L_vfscanf -/* only emit this once */ -#warning Forcing undef of __UCLIBC_HAS_SCANF_GLIBC_A_FLAG__ until implemented! -#endif -#undef __UCLIBC_HAS_SCANF_GLIBC_A_FLAG__ -#endif - -#undef __STDIO_HAS_VSSCANF -#if defined(__STDIO_BUFFERS) || !defined(__UCLIBC_HAS_WCHAR__) || defined(__UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__) -#define __STDIO_HAS_VSSCANF 1 - -#if !defined(__STDIO_BUFFERS) && !defined(__UCLIBC_HAS_WCHAR__) -typedef struct { - FILE f; - unsigned char *bufread; /* pointer to 1 past end of buffer */ - unsigned char *bufpos; -} __FILE_vsscanf; -#endif - -#endif - -extern void _store_inttype(void *dest, int desttype, uintmax_t val); - -#if defined(ULLONG_MAX) && (LLONG_MAX > LONG_MAX) - -extern unsigned long long -_stdlib_strto_ll(register const char * __restrict str, - char ** __restrict endptr, int base, int sflag); -#if (ULLONG_MAX == UINTMAX_MAX) -#define STRTOUIM(s,e,b,sf) _stdlib_strto_ll(s,e,b,sf) -#endif - -#else /* defined(ULLONG_MAX) && (LLONG_MAX > LONG_MAX) */ - -extern unsigned long -_stdlib_strto_l(register const char * __restrict str, - char ** __restrict endptr, int base, int sflag); - -#if (ULONG_MAX == UINTMAX_MAX) -#define STRTOUIM(s,e,b,sf) _stdlib_strto_l(s,e,b,sf) -#endif - -#endif /* defined(ULLONG_MAX) && (LLONG_MAX > LONG_MAX) */ - -#ifndef STRTOUIM -#error STRTOUIM conversion function is undefined! -#endif - -/**********************************************************************/ - -/* The standards require EOF < 0. */ -#if EOF >= CHAR_MIN -#define __isdigit_char_or_EOF(C) __isdigit_char((C)) -#else -#define __isdigit_char_or_EOF(C) __isdigit_int((C)) -#endif - -/**********************************************************************/ -#ifdef L_fscanf - -int attribute_hidden __fscanf(FILE * __restrict stream, const char * __restrict format, ...) -{ - va_list arg; - int rv; - - va_start(arg, format); - rv = __vfscanf(stream, format, arg); - va_end(arg); - - return rv; -} -strong_alias(__fscanf,fscanf) - -#endif -/**********************************************************************/ -#ifdef L_scanf - -int scanf(const char * __restrict format, ...) -{ - va_list arg; - int rv; - - va_start(arg, format); - rv = __vfscanf(stdin, format, arg); - va_end(arg); - - return rv; -} - -#endif -/**********************************************************************/ -#ifdef L_sscanf - -#ifdef __STDIO_HAS_VSSCANF - -int attribute_hidden __sscanf(const char * __restrict str, const char * __restrict format, ...) -{ - va_list arg; - int rv; - - va_start(arg, format); - rv = __vsscanf(str, format, arg); - va_end(arg); - - return rv; -} -strong_alias(__sscanf,sscanf) - -#else /* __STDIO_HAS_VSSCANF */ -#warning Skipping sscanf since no vsscanf! -#endif /* __STDIO_HAS_VSSCANF */ - -#endif -/**********************************************************************/ -#ifdef L_vscanf - -int attribute_hidden __vscanf(const char * __restrict format, va_list arg) -{ - return __vfscanf(stdin, format, arg); -} -strong_alias(__vscanf,vscanf) - -#endif -/**********************************************************************/ -#ifdef L_vsscanf - -#ifdef __UCLIBC_MJN3_ONLY__ -#warning WISHLIST: Implement vsscanf for non-buf and no custom stream case. -#endif /* __UCLIBC_MJN3_ONLY__ */ - -#ifdef __STDIO_BUFFERS - -int attribute_hidden __vsscanf(__const char *sp, __const char *fmt, va_list ap) -{ - FILE f; - -/* __STDIO_STREAM_RESET_GCS(&f); */ -#ifdef __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__ - f.__cookie = &(f.__filedes); - f.__gcs.read = NULL; - f.__gcs.write = NULL; - f.__gcs.seek = NULL; - f.__gcs.close = NULL; -#endif - - f.__filedes = __STDIO_STREAM_FAKE_VSSCANF_FILEDES; - f.__modeflags = (__FLAG_NARROW|__FLAG_READONLY|__FLAG_READING); - -#ifdef __UCLIBC_HAS_WCHAR__ - f.__ungot_width[0] = 0; -#endif -#ifdef __STDIO_MBSTATE - __INIT_MBSTATE(&(f.__state)); -#endif - -#ifdef __UCLIBC_HAS_THREADS__ - f.__user_locking = 1; /* Set user locking. */ -#ifdef __USE_STDIO_FUTEXES__ - _IO_lock_init (f._lock); -#else - __stdio_init_mutex(&f.__lock); -#endif -#endif - f.__nextopen = NULL; - - /* Set these last since __bufgetc initialization depends on - * __user_locking and only gets set if user locking is on. */ - f.__bufstart = - f.__bufpos = (unsigned char *) ((void *) sp); - f.__bufread = - f.__bufend = f.__bufstart + __strlen(sp); - __STDIO_STREAM_ENABLE_GETC(&f); - __STDIO_STREAM_DISABLE_PUTC(&f); - - return __vfscanf(&f, fmt, ap); -} -strong_alias(__vsscanf,vsscanf) - -#elif !defined(__UCLIBC_HAS_WCHAR__) - -int attribute_hidden __vsscanf(__const char *sp, __const char *fmt, va_list ap) -{ - __FILE_vsscanf f; - - f.bufpos = (unsigned char *) ((void *) sp); - f.bufread = f.bufpos + __strlen(sp); - -/* __STDIO_STREAM_RESET_GCS(&f.f); */ -#ifdef __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__ - f.f.__cookie = &(f.f.__filedes); - f.f.__gcs.read = NULL; - f.f.__gcs.write = NULL; - f.f.__gcs.seek = NULL; - f.f.__gcs.close = NULL; -#endif - - f.f.__filedes = __STDIO_STREAM_FAKE_VSSCANF_FILEDES_NB; - f.f.__modeflags = (__FLAG_NARROW|__FLAG_READONLY|__FLAG_READING); - -/* #ifdef __UCLIBC_HAS_WCHAR__ */ -/* f.f.__ungot_width[0] = 0; */ -/* #endif */ -#ifdef __STDIO_MBSTATE -#error __STDIO_MBSTATE is defined! -/* __INIT_MBSTATE(&(f.f.__state)); */ -#endif - -#ifdef __UCLIBC_HAS_THREADS__ - f.f.__user_locking = 1; /* Set user locking. */ -#ifdef __USE_STDIO_FUTEXES__ - _IO_lock_init (f.f._lock); -#else - __stdio_init_mutex(&f.f.__lock); -#endif -#endif - f.f.__nextopen = NULL; - - return __vfscanf(&f.f, fmt, ap); -} -strong_alias(__vsscanf,vsscanf) - -#elif defined(__UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__) - -int attribute_hidden __vsscanf(__const char *sp, __const char *fmt, va_list ap) -{ - FILE *f; - int rv = EOF; - - if ((f = fmemopen((char *)sp, __strlen(sp), "r")) != NULL) { - rv = __vfscanf(f, fmt, ap); - fclose(f); - } - - return rv; -} -strong_alias(__vsscanf,vsscanf) - -#else -#warning Skipping vsscanf since no buffering, no custom streams, and wchar enabled! -#ifdef __STDIO_HAS_VSSCANF -#error WHOA! __STDIO_HAS_VSSCANF is defined! -#endif -#endif - -#endif -/**********************************************************************/ -#ifdef L_fwscanf - -int fwscanf(FILE * __restrict stream, const wchar_t * __restrict format, ...) -{ - va_list arg; - int rv; - - va_start(arg, format); - rv = __vfwscanf(stream, format, arg); - va_end(arg); - - return rv; -} - -#endif -/**********************************************************************/ -#ifdef L_wscanf - -int wscanf(const wchar_t * __restrict format, ...) -{ - va_list arg; - int rv; - - va_start(arg, format); - rv = __vfwscanf(stdin, format, arg); - va_end(arg); - - return rv; -} - -#endif -/**********************************************************************/ -#ifdef L_swscanf - -#ifdef __STDIO_BUFFERS - -int swscanf(const wchar_t * __restrict str, const wchar_t * __restrict format, - ...) -{ - va_list arg; - int rv; - - va_start(arg, format); - rv = __vswscanf(str, format, arg); - va_end(arg); - - return rv; -} -#else /* __STDIO_BUFFERS */ -#warning Skipping swscanf since no buffering! -#endif /* __STDIO_BUFFERS */ - -#endif -/**********************************************************************/ -#ifdef L_vwscanf - -int vwscanf(const wchar_t * __restrict format, va_list arg) -{ - return __vfwscanf(stdin, format, arg); -} - -#endif -/**********************************************************************/ -#ifdef L_vswscanf - -#ifdef __STDIO_BUFFERS - -int attribute_hidden __vswscanf(const wchar_t * __restrict str, const wchar_t * __restrict format, - va_list arg) -{ - FILE f; - - f.__bufstart = - f.__bufpos = (char *) str; - f.__bufread = - f.__bufend = (char *)(str + wcslen(str)); - __STDIO_STREAM_DISABLE_GETC(&f); - __STDIO_STREAM_DISABLE_PUTC(&f); - -/* __STDIO_STREAM_RESET_GCS(&f); */ -#ifdef __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__ - f.__cookie = &(f.__filedes); - f.__gcs.read = NULL; - f.__gcs.write = NULL; - f.__gcs.seek = NULL; - f.__gcs.close = NULL; -#endif - - f.__filedes = __STDIO_STREAM_FAKE_VSWSCANF_FILEDES; - f.__modeflags = (__FLAG_WIDE|__FLAG_READONLY|__FLAG_READING); - -#ifdef __UCLIBC_HAS_WCHAR__ - f.__ungot_width[0] = 0; -#endif /* __UCLIBC_HAS_WCHAR__ */ -#ifdef __STDIO_MBSTATE - __INIT_MBSTATE(&(f.__state)); -#endif /* __STDIO_MBSTATE */ - -#ifdef __UCLIBC_HAS_THREADS__ - f.__user_locking = 1; /* Set user locking. */ -#ifdef __USE_STDIO_FUTEXES__ - _IO_lock_init (f._lock); -#else - __stdio_init_mutex(&f.__lock); -#endif -#endif - f.__nextopen = NULL; - - return __vfwscanf(&f, format, arg); -} -strong_alias(__vswscanf,vswscanf) -#else /* __STDIO_BUFFERS */ -#warning Skipping vswscanf since no buffering! -#endif /* __STDIO_BUFFERS */ - -#endif -/**********************************************************************/ -/**********************************************************************/ - - - -/* float layout 0123456789012345678901 repeat n for "l[" */ -#define SPEC_CHARS "npxXoudifFeEgGaACSncs[" -/* npxXoudif eEgG CS cs[ */ - -/* NOTE: Ordering is important! In particular, CONV_LEFTBRACKET - * must immediately precede CONV_c. */ - -enum { - CONV_n = 0, - CONV_p, - CONV_x, CONV_X, CONV_o, CONV_u, CONV_d, CONV_i, - CONV_f, CONV_F, CONV_e, CONV_E, CONV_g, CONV_G, CONV_a, CONV_A, - CONV_C, CONV_S, CONV_LEFTBRACKET, CONV_c, CONV_s, CONV_leftbracket, - CONV_percent, CONV_whitespace /* not in SPEC_* and no flags */ -}; - -#ifdef __UCLIBC_HAS_FLOATS__ -#ifdef __UCLIBC_HAS_HEXADECIMAL_FLOATS__ -/* p x X o u d i f F e E g G a A */ -#define SPEC_BASE { 16, 16, 16, 8, 10, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0 } -#else -/* p x X o u d i f F e E g G a A */ -#define SPEC_BASE { 16, 16, 16, 8, 10, 10, 0, 10, 10, 10, 10, 10, 10, 10, 10 } -#endif -#else /* __UCLIBC_HAS_FLOATS__ */ -/* p x X o u d i f F e E g G a A */ -#define SPEC_BASE { 16, 16, 16, 8, 10, 10, 0 } -#endif /* __UCLIBC_HAS_FLOATS__ */ - -#ifdef __UCLIBC_MJN3_ONLY__ -#ifdef L_vfscanf -/* emit once */ -#warning CONSIDER: Add a '0' flag to eat 0 padding when grouping? -#endif -#endif /* __UCLIBC_MJN3_ONLY__ */ - -#define SPEC_FLAGS "*'I" - -enum { - FLAG_SURPRESS = 0x10, /* MUST BE 1ST!! See DO_FLAGS. */ - FLAG_THOUSANDS = 0x20, - FLAG_I18N = 0x40, /* only works for d, i, u */ - FLAG_MALLOC = 0x80, /* only works for s, S, and [ (and l[)*/ -}; - - -#define SPEC_RANGES { CONV_n, CONV_p, CONV_i, CONV_A, \ - CONV_C, CONV_LEFTBRACKET, \ - CONV_c, CONV_leftbracket } - -/* Note: We treat L and ll as synonymous... for ints and floats. */ - -#define SPEC_ALLOWED_FLAGS { \ - /* n */ (0x0f|FLAG_SURPRESS), \ - /* p */ ( 0|FLAG_SURPRESS), \ - /* oxXudi */ (0x0f|FLAG_SURPRESS|FLAG_THOUSANDS|FLAG_I18N), \ - /* fFeEgGaA */ (0x0c|FLAG_SURPRESS|FLAG_THOUSANDS|FLAG_I18N), \ - /* C */ ( 0|FLAG_SURPRESS), \ - /* S and l[ */ ( 0|FLAG_SURPRESS|FLAG_MALLOC), \ - /* c */ (0x04|FLAG_SURPRESS), \ - /* s and [ */ (0x04|FLAG_SURPRESS|FLAG_MALLOC), \ -} - - -/**********************************************************************/ -/* - * In order to ease translation to what arginfo and _print_info._flags expect, - * we map: 0:int 1:char 2:longlong 4:long 8:short - * and then _flags |= (((q << 7) + q) & 0x701) and argtype |= (_flags & 0x701) - */ - -/* TODO -- Fix the table below to take into account stdint.h. */ -/* #ifndef LLONG_MAX */ -/* #error fix QUAL_CHARS for no long long! Affects 'L', 'j', 'q', 'll'. */ -/* #else */ -/* #if LLONG_MAX != INTMAX_MAX */ -/* #error fix QUAL_CHARS intmax_t entry 'j'! */ -/* #endif */ -/* #endif */ - -#ifdef PDS -#error PDS already defined! -#endif -#ifdef SS -#error SS already defined! -#endif -#ifdef IMS -#error IMS already defined! -#endif - -#if PTRDIFF_MAX == INT_MAX -#define PDS 0 -#elif PTRDIFF_MAX == LONG_MAX -#define PDS 4 -#elif defined(LLONG_MAX) && (PTRDIFF_MAX == LLONG_MAX) -#define PDS 8 -#else -#error fix QUAL_CHARS ptrdiff_t entry 't'! -#endif - -#if SIZE_MAX == UINT_MAX -#define SS 0 -#elif SIZE_MAX == ULONG_MAX -#define SS 4 -#elif defined(LLONG_MAX) && (SIZE_MAX == ULLONG_MAX) -#define SS 8 -#else -#error fix QUAL_CHARS size_t entries 'z', 'Z'! -#endif - -#if INTMAX_MAX == INT_MAX -#define IMS 0 -#elif INTMAX_MAX == LONG_MAX -#define IMS 4 -#elif defined(LLONG_MAX) && (INTMAX_MAX == LLONG_MAX) -#define IMS 8 -#else -#error fix QUAL_CHARS ptrdiff_t entry 't'! -#endif - -#define QUAL_CHARS { \ - /* j:(u)intmax_t z:(s)size_t t:ptrdiff_t \0:int q:long_long */ \ - 'h', 'l', 'L', 'j', 'z', 't', 'q', 0, \ - 2, 4, 8, IMS, SS, PDS, 8, 0, /* TODO -- fix!!! */\ - 1, 8 } - - -/**********************************************************************/ - -#ifdef L_vfwscanf -#if WINT_MIN > EOF -#error Unfortunately, we currently need wint_t to be able to store EOF. Sorry. -#endif -#define W_EOF WEOF -#define Wint wint_t -#define Wchar wchar_t -#define Wuchar __uwchar_t -#define ISSPACE(C) iswspace((C)) -#define HIDDEN_VFSCANF __vfwscanf -#define VFSCANF vfwscanf -#define GETC(SC) (SC)->sc_getc((SC)) -#else -typedef unsigned char __uchar_t; -#define W_EOF EOF -#define Wint int -#define Wchar char -#define Wuchar __uchar_t -#define ISSPACE(C) isspace((C)) -#define HIDDEN_VFSCANF __vfscanf -#define VFSCANF vfscanf -#ifdef __UCLIBC_HAS_WCHAR__ -#define GETC(SC) (SC)->sc_getc((SC)) -#else /* __UCLIBC_HAS_WCHAR__ */ -#define GETC(SC) __getc_unlocked((SC)->fp) -#endif /* __UCLIBC_HAS_WCHAR__ */ -#endif - -struct scan_cookie { - Wint cc; - Wint ungot_char; - FILE *fp; - int nread; - int width; - -#ifdef __UCLIBC_HAS_WCHAR__ - wchar_t app_ungot; /* Match FILE struct member type. */ - unsigned char ungot_wchar_width; -#else /* __UCLIBC_HAS_WCHAR__ */ - unsigned char app_ungot; /* Match FILE struct member type. */ -#endif /* __UCLIBC_HAS_WCHAR__ */ - - char ungot_flag; - -#ifdef __UCLIBC_HAS_WCHAR__ - char ungot_wflag; /* vfwscanf */ - char mb_fail; /* vfscanf */ - mbstate_t mbstate; /* vfscanf */ - wint_t wc; - wint_t ungot_wchar; /* to support __scan_getc */ - int (*sc_getc)(struct scan_cookie *); -#endif /* __UCLIBC_HAS_WCHAR__ */ - -#ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ - const char *grouping; - const unsigned char *thousands_sep; - int tslen; -#ifdef __UCLIBC_HAS_WCHAR__ - wchar_t thousands_sep_wc; -#endif /* __UCLIBC_HAS_WCHAR__ */ -#endif /* __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ */ - -#ifdef __UCLIBC_HAS_FLOATS__ - const unsigned char *decpt; - int decpt_len; -#ifdef __UCLIBC_HAS_WCHAR__ - wchar_t decpt_wc; -#endif /* __UCLIBC_HAS_WCHAR__ */ - const unsigned char *fake_decpt; -#endif /* __UCLIBC_HAS_FLOATS__ */ - -}; - -typedef struct { -#if defined(NL_ARGMAX) && (NL_ARGMAX > 0) -#if NL_ARGMAX > 10 -#warning NL_ARGMAX > 10, and space is allocated on the stack for positional args. -#endif - void *pos_args[NL_ARGMAX]; - int num_pos_args; /* Must start at -1. */ - int cur_pos_arg; -#endif /* defined(NL_ARGMAX) && (NL_ARGMAX > 0) */ - void *cur_ptr; - const unsigned char *fmt; - int cnt, dataargtype, conv_num, max_width; - unsigned char store, flags; -} psfs_t; /* parse scanf format state */ - - -/**********************************************************************/ -/**********************************************************************/ - -extern void __init_scan_cookie(register struct scan_cookie *sc, - register FILE *fp) attribute_hidden; -extern int __scan_getc(register struct scan_cookie *sc) attribute_hidden; -extern void __scan_ungetc(register struct scan_cookie *sc) attribute_hidden; - -#ifdef __UCLIBC_HAS_FLOATS__ -extern int __scan_strtold(long double *ld, struct scan_cookie *sc); -#endif /* __UCLIBC_HAS_FLOATS__ */ - -extern int __psfs_parse_spec(psfs_t *psfs) attribute_hidden; -extern int __psfs_do_numeric(psfs_t *psfs, struct scan_cookie *sc) attribute_hidden; - -/**********************************************************************/ -#ifdef L___scan_cookie - -#ifdef __UCLIBC_MJN3_ONLY__ -#warning TODO: Remove dependence on decpt_str and fake_decpt in stub locale mode. -#endif -#ifndef __UCLIBC_HAS_LOCALE__ -static const char decpt_str[] = "."; -#endif - -void attribute_hidden __init_scan_cookie(register struct scan_cookie *sc, - register FILE *fp) -{ - sc->fp = fp; - sc->nread = 0; - sc->ungot_flag = 0; - sc->app_ungot = ((fp->__modeflags & __FLAG_UNGOT) ? fp->__ungot[1] : 0); -#ifdef __UCLIBC_HAS_WCHAR__ - sc->ungot_wflag = 0; /* vfwscanf */ - sc->mb_fail = 0; -#endif /* __UCLIBC_HAS_WCHAR__ */ - -#ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ - if (*(sc->grouping = __UCLIBC_CURLOCALE_DATA.grouping)) { - sc->thousands_sep = __UCLIBC_CURLOCALE_DATA.thousands_sep; - sc->tslen = __UCLIBC_CURLOCALE_DATA.thousands_sep_len; -#ifdef __UCLIBC_HAS_WCHAR__ - sc->thousands_sep_wc = __UCLIBC_CURLOCALE_DATA.thousands_sep_wc; -#endif /* __UCLIBC_HAS_WCHAR__ */ - } -#endif /* __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ */ - -#ifdef __UCLIBC_HAS_FLOATS__ -#ifdef __UCLIBC_HAS_LOCALE__ - sc->decpt = __UCLIBC_CURLOCALE_DATA.decimal_point; - sc->decpt_len = __UCLIBC_CURLOCALE_DATA.decimal_point_len; -#else /* __UCLIBC_HAS_LOCALE__ */ - sc->fake_decpt = sc->decpt = decpt_str; - sc->decpt_len = 1; -#endif /* __UCLIBC_HAS_LOCALE__ */ -#ifdef __UCLIBC_HAS_WCHAR__ -#ifdef __UCLIBC_HAS_LOCALE__ - sc->decpt_wc = __UCLIBC_CURLOCALE_DATA.decimal_point_wc; -#else - sc->decpt_wc = '.'; -#endif -#endif /* __UCLIBC_HAS_WCHAR__ */ -#endif /* __UCLIBC_HAS_FLOATS__ */ - -} - -int attribute_hidden __scan_getc(register struct scan_cookie *sc) -{ - int c; - -#ifdef __UCLIBC_HAS_WCHAR__ - assert(!sc->mb_fail); -#endif /* __UCLIBC_HAS_WCHAR__ */ - - sc->cc = EOF; - - if (--sc->width < 0) { - sc->ungot_flag |= 2; - return -1; - } - - if (sc->ungot_flag == 0) { -#if !defined(__STDIO_BUFFERS) && !defined(__UCLIBC_HAS_WCHAR__) - if (!__STDIO_STREAM_IS_FAKE_VSSCANF_NB(sc->fp)) { - c = GETC(sc); - } else { - __FILE_vsscanf *fv = (__FILE_vsscanf *)(sc->fp); - if (fv->bufpos < fv->bufread) { - c = *fv->bufpos++; - } else { - c = EOF; - sc->fp->__modeflags |= __FLAG_EOF; - } - } - if (c == EOF) { - sc->ungot_flag |= 2; - return -1; - } -#else - if ((c = GETC(sc)) == EOF) { - sc->ungot_flag |= 2; - return -1; - } -#endif - sc->ungot_char = c; - } else { - assert(sc->ungot_flag == 1); - sc->ungot_flag = 0; - } - - ++sc->nread; - return sc->cc = sc->ungot_char; -} - -void attribute_hidden __scan_ungetc(register struct scan_cookie *sc) -{ - ++sc->width; - if (sc->ungot_flag == 2) { /* last was EOF */ - sc->ungot_flag = 0; - sc->cc = sc->ungot_char; - } else if (sc->ungot_flag == 0) { - sc->ungot_flag = 1; - --sc->nread; - } else { - assert(0); - } -} - -#endif -/**********************************************************************/ -#ifdef L___psfs_parse_spec - -#ifdef SPEC_FLAGS -static const unsigned char spec_flags[] = SPEC_FLAGS; -#endif /* SPEC_FLAGS */ -static const unsigned char spec_chars[] = SPEC_CHARS; -static const unsigned char qual_chars[] = QUAL_CHARS; -static const unsigned char spec_ranges[] = SPEC_RANGES; -static const unsigned short spec_allowed[] = SPEC_ALLOWED_FLAGS; - -int attribute_hidden __psfs_parse_spec(register psfs_t *psfs) -{ - const unsigned char *p; - const unsigned char *fmt0 = psfs->fmt; - int i; -#ifdef SPEC_FLAGS - int j; -#endif -#if defined(NL_ARGMAX) && (NL_ARGMAX > 0) - unsigned char fail = 0; - - i = 0; /* Do this here to avoid a warning. */ - - if (!__isdigit_char(*psfs->fmt)) { /* Not a positional arg. */ - fail = 1; - goto DO_FLAGS; - } - - /* parse the positional arg (or width) value */ - do { - if (i <= ((INT_MAX - 9)/10)) { - i = (i * 10) + (*psfs->fmt++ - '0'); - } - } while (__isdigit_char(*psfs->fmt)); - - if (*psfs->fmt != '$') { /* This is a max field width. */ - if (psfs->num_pos_args >= 0) { /* Already saw a pos arg! */ - goto ERROR_EINVAL; - } - psfs->max_width = i; - psfs->num_pos_args = -2; - goto DO_QUALIFIER; - } - ++psfs->fmt; /* Advance past '$'. */ -#endif /* defined(NL_ARGMAX) && (NL_ARGMAX > 0) */ - -#if defined(SPEC_FLAGS) || (defined(NL_ARGMAX) && (NL_ARGMAX > 0)) - DO_FLAGS: -#endif /* defined(SPEC_FLAGS) || (defined(NL_ARGMAX) && (NL_ARGMAX > 0)) */ -#ifdef SPEC_FLAGS - p = spec_flags; - j = FLAG_SURPRESS; - do { - if (*p == *psfs->fmt) { - ++psfs->fmt; - psfs->flags |= j; - goto DO_FLAGS; - } - j += j; - } while (*++p); - - if (psfs->flags & FLAG_SURPRESS) { /* Suppress assignment. */ - psfs->store = 0; - goto DO_WIDTH; - } -#else /* SPEC_FLAGS */ - if (*psfs->fmt == '*') { /* Suppress assignment. */ - ++psfs->fmt; - psfs->store = 0; - goto DO_WIDTH; - } -#endif /* SPEC_FLAGS */ - - -#if defined(NL_ARGMAX) && (NL_ARGMAX > 0) - if (fail) { - /* Must be a non-positional arg */ - if (psfs->num_pos_args >= 0) { /* Already saw a pos arg! */ - goto ERROR_EINVAL; - } - psfs->num_pos_args = -2; - } else { - if ((psfs->num_pos_args == -2) || (((unsigned int)(--i)) >= NL_ARGMAX)) { - /* Already saw a non-pos arg or (0-based) num too large. */ - goto ERROR_EINVAL; - } - psfs->cur_pos_arg = i; - } -#endif /* defined(NL_ARGMAX) && (NL_ARGMAX > 0) */ - - DO_WIDTH: - for (i = 0 ; __isdigit_char(*psfs->fmt) ; ) { - if (i <= ((INT_MAX - 9)/10)) { - i = (i * 10) + (*psfs->fmt++ - '0'); - psfs->max_width = i; - } - } - -#if defined(NL_ARGMAX) && (NL_ARGMAX > 0) - DO_QUALIFIER: -#endif /* defined(NL_ARGMAX) && (NL_ARGMAX > 0) */ - p = qual_chars; - do { - if (*psfs->fmt == *p) { - ++psfs->fmt; - break; - } - } while (*++p); - if ((p - qual_chars < 2) && (*psfs->fmt == *p)) { - p += ((sizeof(qual_chars)-2) / 2); - ++psfs->fmt; - } - psfs->dataargtype = ((int)(p[(sizeof(qual_chars)-2) / 2])) << 8; - -#ifdef __UCLIBC_MJN3_ONLY__ -#warning CONSIDER: Should we validate that psfs->max_width > 0 in __psfs_parse_spec()? It would avoid whitespace consumption... -#warning CONSIDER: Should INT_MAX be a valid width (%c/%C)? See __psfs_parse_spec(). -#endif /* __UCLIBC_MJN3_ONLY__ */ - - p = spec_chars; - do { - if (*psfs->fmt == *p) { - int p_m_spec_chars = p - spec_chars; - -#ifdef __UCLIBC_HAS_SCANF_GLIBC_A_FLAG__ -#error implement gnu a flag - if ((*p == 'a') - && ((psfs->fmt[1] == '[') || ((psfs->fmt[1]|0x20) == 's')) - ) { /* Assumes ascii for 's' and 'S' test. */ - psfs->flags |= FLAG_MALLOC; - ++psfs->fmt; - ++p; - continue; /* The related conversions follow 'a'. */ - } -#endif /* __UCLIBC_HAS_SCANF_GLIBC_A_FLAG__ */ - - for (p = spec_ranges; p_m_spec_chars > *p ; ++p) {} - if (((psfs->dataargtype >> 8) | psfs->flags) - & ~spec_allowed[(int)(p - spec_ranges)] - ) { - goto ERROR_EINVAL; - } - - if ((p_m_spec_chars >= CONV_c) - && (psfs->dataargtype & PA_FLAG_LONG)) { - p_m_spec_chars -= 3; /* lc -> C, ls -> S, l[ -> ?? */ - } - - psfs->conv_num = p_m_spec_chars; - return psfs->fmt - fmt0; - } - if (!*++p) { - ERROR_EINVAL: - __set_errno(EINVAL); - return -1; - } - } while(1); - - assert(0); -} - -#endif -/**********************************************************************/ -#if defined(L_vfscanf) || defined(L_vfwscanf) - -#ifdef __UCLIBC_HAS_WCHAR__ -#ifdef L_vfscanf -static int sc_getc(register struct scan_cookie *sc) -{ - return (__getc_unlocked)(sc->fp); /* Disable the macro. */ -} - -static int scan_getwc(register struct scan_cookie *sc) -{ - size_t r; - int width; - wchar_t wc[1]; - char b[1]; - - if (--sc->width < 0) { - sc->ungot_flag |= 2; - return -1; - } - - width = sc->width; /* Preserve width. */ - sc->width = INT_MAX; /* MB_CUR_MAX can invoke a function. */ - - assert(!sc->mb_fail); - - r = (size_t)(-3); - while (__scan_getc(sc) >= 0) { - *b = sc->cc; - - r = mbrtowc(wc, b, 1, &sc->mbstate); - if (((ssize_t) r) >= 0) { /* Successful completion of a wc. */ - sc->wc = *wc; - goto SUCCESS; - } else if (r == ((size_t) -2)) { - /* Potentially valid but incomplete. */ - continue; - } - break; - } - - if (r == ((size_t)(-3))) { /* EOF or ERROR on first read */ - sc->wc = WEOF; - r = (size_t)(-1); - } else { - /* If we reach here, either r == ((size_t)-1) and - * mbrtowc set errno to EILSEQ, or r == ((size_t)-2) - * and stream is in an error state or at EOF with a - * partially complete wchar. */ - __set_errno(EILSEQ); /* In case of incomplete conversion. */ - sc->mb_fail = 1; - } - - SUCCESS: - sc->width = width; /* Restore width. */ - - return (int)((ssize_t) r); -} - -#endif /* L_vfscanf */ - -#ifdef L_vfwscanf - -/* This gets called by __scan_getc. __scan_getc is called by vfwscanf - * when the next wide char is expected to be valid ascii (digits). + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. */ -static int sc_getc(register struct scan_cookie *sc) -{ - wint_t wc; - - if (__STDIO_STREAM_IS_FAKE_VSWSCANF(sc->fp)) { - if (sc->fp->__bufpos < sc->fp->__bufend) { - wc = *((wchar_t *)(sc->fp->__bufpos)); - sc->fp->__bufpos += sizeof(wchar_t); - } else { - sc->fp->__modeflags |= __FLAG_EOF; - return EOF; - } - } else if ((wc = __fgetwc_unlocked(sc->fp)) == WEOF) { - return EOF; - } - - sc->ungot_wflag = 1; - sc->ungot_wchar = wc; - sc->ungot_wchar_width = sc->fp->__ungot_width[0]; - -#ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ - if (wc == sc->thousands_sep_wc) { - wc = ','; - } else -#endif /* __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ */ -#ifdef __UCLIBC_HAS_FLOATS__ - if (wc == sc->decpt_wc) { - wc = '.'; - } else -#endif /* __UCLIBC_HAS_FLOATS__ */ - if (!__isascii(wc)) { - wc = '?'; - } - sc->wc = sc->ungot_char = wc; - - return (int) wc; -} - -static int scan_getwc(register struct scan_cookie *sc) -{ - wint_t wc; - - sc->wc = WEOF; - - if (--sc->width < 0) { - sc->ungot_flag |= 2; - return -1; - } - - if (sc->ungot_flag == 0) { - if (__STDIO_STREAM_IS_FAKE_VSWSCANF(sc->fp)) { - if (sc->fp->__bufpos < sc->fp->__bufend) { - wc = *((wchar_t *)(sc->fp->__bufpos)); - sc->fp->__bufpos += sizeof(wchar_t); - } else { - sc->ungot_flag |= 2; - return -1; - } - } else if ((wc = __fgetwc_unlocked(sc->fp)) == WEOF) { - sc->ungot_flag |= 2; - return -1; - } - sc->ungot_wflag = 1; - sc->ungot_char = wc; - sc->ungot_wchar_width = sc->fp->__ungot_width[0]; - } else { - assert(sc->ungot_flag == 1); - sc->ungot_flag = 0; - } - - ++sc->nread; - sc->wc = sc->ungot_char; - - return 0; -} - - -#endif /* L_vfwscanf */ -#endif /* __UCLIBC_HAS_WCHAR__ */ - -static __inline void kill_scan_cookie(register struct scan_cookie *sc) -{ -#ifdef L_vfscanf - - if (sc->ungot_flag & 1) { -#if !defined(__STDIO_BUFFERS) && !defined(__UCLIBC_HAS_WCHAR__) - if (!__STDIO_STREAM_IS_FAKE_VSSCANF_NB(sc->fp)) { - ungetc(sc->ungot_char, sc->fp); - } -#else - ungetc(sc->ungot_char, sc->fp); -#endif - /* Deal with distiction between user and scanf ungots. */ - if (sc->nread == 0) { /* Only one char was read... app ungot? */ - sc->fp->__ungot[1] = sc->app_ungot; /* restore ungot state. */ - } else { - sc->fp->__ungot[1] = 0; - } - } - -#else - - if ((sc->ungot_flag & 1) && (sc->ungot_wflag & 1) - && !__STDIO_STREAM_IS_FAKE_VSWSCANF(sc->fp) - && (sc->fp->__state.__mask == 0) - ) { - ungetwc(sc->ungot_char, sc->fp); - /* Deal with distiction between user and scanf ungots. */ - if (sc->nread == 0) { /* Only one char was read... app ungot? */ - sc->fp->__ungot[1] = sc->app_ungot; /* restore ungot state. */ - } else { - sc->fp->__ungot[1] = 0; - } - sc->fp->__ungot_width[1] = sc->ungot_wchar_width; - } - -#endif -} - -#ifdef L_vfwscanf -#ifdef __UCLIBC_HAS_FLOATS__ -static const char fake_decpt_str[] = "."; -#endif -#ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ -static const char fake_thousands_sep_str[] = ","; -#endif -#endif /* L_vfwscanf */ - - -int attribute_hidden HIDDEN_VFSCANF (FILE *__restrict fp, const Wchar *__restrict format, va_list arg) -{ - const Wuchar *fmt; - unsigned char *b; - - -#ifdef L_vfwscanf - wchar_t wbuf[1]; - wchar_t *wb; -#endif /* L_vfwscanf */ - -#ifdef __UCLIBC_HAS_WCHAR__ - mbstate_t mbstate; -#endif /* __UCLIBC_HAS_WCHAR__ */ - - struct scan_cookie sc; - psfs_t psfs; - - int i; - -#ifdef __UCLIBC_MJN3_ONLY__ -#warning TODO: Fix MAX_DIGITS. We do not do binary, so...! -#endif -#define MAX_DIGITS 65 /* Allow one leading 0. */ - unsigned char buf[MAX_DIGITS+2]; -#ifdef L_vfscanf - unsigned char scanset[UCHAR_MAX + 1]; - unsigned char invert; /* Careful! Meaning changes. */ -#endif /* L_vfscanf */ - unsigned char fail; - unsigned char zero_conversions = 1; - __STDIO_AUTO_THREADLOCK_VAR; - -#ifdef __UCLIBC_MJN3_ONLY__ -#warning TODO: Make checking of the format string in C locale an option. -#endif - /* To support old programs, don't check mb validity if in C locale. */ -#if defined(__UCLIBC_HAS_LOCALE__) && !defined(L_vfwscanf) - /* ANSI/ISO C99 requires format string to be a valid multibyte string - * beginning and ending in its initial shift state. */ - if (((__UCLIBC_CURLOCALE_DATA).encoding) != __ctype_encoding_7_bit) { - const char *p = format; - mbstate.__mask = 0; /* Initialize the mbstate. */ - if (mbsrtowcs(NULL, &p, SIZE_MAX, &mbstate) == ((size_t)(-1))) { - __set_errno(EINVAL); /* Format string is invalid. */ - return 0; - } - } -#endif /* defined(__UCLIBC_HAS_LOCALE__) && !defined(L_vfwscanf) */ - -#if defined(NL_ARGMAX) && (NL_ARGMAX > 0) - psfs.num_pos_args = -1; /* Must start at -1. */ - /* Initialize positional arg ptrs to NULL. */ - __memset(psfs.pos_args, 0, sizeof(psfs.pos_args)); -#endif /* defined(NL_ARGMAX) && (NL_ARGMAX > 0) */ - - __STDIO_AUTO_THREADLOCK(fp); - - __STDIO_STREAM_VALIDATE(fp); - - __init_scan_cookie(&sc,fp); -#ifdef __UCLIBC_HAS_WCHAR__ - sc.sc_getc = sc_getc; - sc.ungot_wchar_width = sc.fp->__ungot_width[1]; - -#ifdef L_vfwscanf - -#ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ - if (*sc.grouping) { - sc.thousands_sep = fake_thousands_sep_str; - sc.tslen = 1; - } -#endif /* __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ */ - -#ifdef __UCLIBC_HAS_FLOATS__ - sc.fake_decpt = fake_decpt_str; -#endif /* __UCLIBC_HAS_FLOATS__ */ - -#else /* L_vfwscanf */ - -#ifdef __UCLIBC_HAS_FLOATS__ - sc.fake_decpt = sc.decpt; -#endif /* __UCLIBC_HAS_FLOATS__ */ - -#endif /* L_vfwscanf */ - -#endif /* __UCLIBC_HAS_WCHAR__ */ - psfs.cnt = 0; - - /* Note: If we ever wanted to support non-nice codesets, we - * would really need to do a mb->wc conversion here in the - * vfscanf case. Related changes would have to be made in - * the code that follows... basicly wherever fmt appears. */ - for (fmt = (const Wuchar *) format ; *fmt ; /* ++fmt */) { - - psfs.store = 1; - psfs.flags = 0; -#ifndef NDEBUG - psfs.cur_ptr = NULL; /* Debugging aid. */ -#endif /* NDEBUG */ - - - sc.ungot_flag &= 1; /* Clear (possible fake) EOF. */ - sc.width = psfs.max_width = INT_MAX; - - /* Note: According to the standards, vfscanf does use isspace - * here. So, if we did a mb->wc conversion, we would have to do - * something like - * ((((__uwchar_t)wc) < UCHAR_MAX) && isspace(wc)) - * because wc might not be in the allowed domain. */ - if (ISSPACE(*fmt)) { - do { - ++fmt; - } while (ISSPACE(*fmt)); - --fmt; - psfs.conv_num = CONV_whitespace; - goto DO_WHITESPACE; - } - - if (*fmt == '%') { /* Conversion specification. */ - if (*++fmt == '%') { /* Remember, '%' eats whitespace too. */ - /* Note: The standard says no conversion occurs. - * So do not reset zero_conversions flag. */ - psfs.conv_num = CONV_percent; - goto DO_CONVERSION; - } - - -#ifdef L_vfscanf - psfs.fmt = fmt; -#else /* L_vfscanf */ - { - const __uwchar_t *wf = fmt; - psfs.fmt = b = buf; - - while (*wf && __isascii(*wf) && (b < buf + sizeof(buf) - 1)) { - *b++ = *wf++; - } -#ifdef __UCLIBC_HAS_SCANF_GLIBC_A_FLAG__ -#error this is wrong... we need to ched in __psfs_parse_spec instead since this checks last char in buffer and conversion my have stopped before it. - if ((*b == 'a') && ((*wf == '[') || ((*wf|0x20) == 's'))) { - goto DONE; /* Spec was excessively long. */ - } -#endif /* __UCLIBC_HAS_SCANF_GLIBC_A_FLAG__ */ - *b = 0; - if (b == buf) { /* Bad conversion specifier! */ - goto DONE; - } - } -#endif /* L_vfscanf */ - if ((i = __psfs_parse_spec(&psfs)) < 0) { /* Bad conversion specifier! */ - goto DONE; - } - fmt += i; - - if (psfs.store) { -#if defined(NL_ARGMAX) && (NL_ARGMAX > 0) - if (psfs.num_pos_args == -2) { - psfs.cur_ptr = va_arg(arg, void *); - } else { - while (psfs.cur_pos_arg > psfs.num_pos_args) { - psfs.pos_args[++psfs.num_pos_args] = va_arg(arg, void *); - } - psfs.cur_ptr = psfs.pos_args[psfs.cur_pos_arg]; - } -#else /* defined(NL_ARGMAX) && (NL_ARGMAX > 0) */ - psfs.cur_ptr = va_arg(arg, void *); -#endif /* defined(NL_ARGMAX) && (NL_ARGMAX > 0) */ - } - - DO_CONVERSION: - /* First, consume white-space if not n, c, [, C, or l[. */ - if ((((1L << CONV_n)|(1L << CONV_C)|(1L << CONV_c) - |(1L << CONV_LEFTBRACKET)|(1L << CONV_leftbracket)) - & (1L << psfs.conv_num)) == 0 - ) { - DO_WHITESPACE: - while ((__scan_getc(&sc) >= 0) -#ifdef L_vfscanf - && isspace(sc.cc) -#else /* L_vfscanf */ - && iswspace(sc.wc) -#endif /* L_vfscanf */ - ) {} - __scan_ungetc(&sc); - if (psfs.conv_num == CONV_whitespace) { - goto NEXT_FMT; - } - } - - sc.width = psfs.max_width; /* Now limit the max width. */ - - if (sc.width == 0) { /* 0 width is forbidden. */ - goto DONE; - } - - - if (psfs.conv_num == CONV_percent) { - goto MATCH_CHAR; - } - - if (psfs.conv_num == CONV_n) { -#ifdef __UCLIBC_MJN3_ONLY__ -#warning CONSIDER: Should %n count as a conversion as far as EOF return value? -#endif -/* zero_conversions = 0; */ - if (psfs.store) { - _store_inttype(psfs.cur_ptr, psfs.dataargtype, - (uintmax_t) sc.nread); - } - goto NEXT_FMT; - } - - if (psfs.conv_num <= CONV_A) { /* pointer, integer, or float spec */ - int r = __psfs_do_numeric(&psfs, &sc); -#ifndef L_vfscanf - if (sc.ungot_wflag == 1) { /* fix up '?', '.', and ',' hacks */ - sc.cc = sc.ungot_char = sc.ungot_wchar; - } -#endif - if (r != -1) { /* Either success or a matching failure. */ - zero_conversions = 0; - } - if (r < 0) { - goto DONE; - } - goto NEXT_FMT; - } - - /* Do string conversions here since they are not common code. */ - - -#ifdef L_vfscanf - - if -#ifdef __UCLIBC_HAS_WCHAR__ - (psfs.conv_num >= CONV_LEFTBRACKET) -#else /* __UCLIBC_HAS_WCHAR__ */ - (psfs.conv_num >= CONV_c) -#endif /* __UCLIBC_HAS_WCHAR__ */ - { - b = (psfs.store ? ((unsigned char *) psfs.cur_ptr) : buf); - fail = 1; - - - if (psfs.conv_num == CONV_c) { - if (sc.width == INT_MAX) { - sc.width = 1; - } - - while (__scan_getc(&sc) >= 0) { - zero_conversions = 0; - *b = sc.cc; - b += psfs.store; - } - __scan_ungetc(&sc); - if (sc.width > 0) { /* Failed to read all required. */ - goto DONE; - } - psfs.cnt += psfs.store; - goto NEXT_FMT; - } - - if (psfs.conv_num == CONV_s) { - /* Yes, believe it or not, a %s conversion can store nuls. */ - while ((__scan_getc(&sc) >= 0) && !isspace(sc.cc)) { - zero_conversions = 0; - *b = sc.cc; - b += psfs.store; - fail = 0; - } - } else { -#ifdef __UCLIBC_HAS_WCHAR__ - assert((psfs.conv_num == CONV_LEFTBRACKET) || \ - (psfs.conv_num == CONV_leftbracket)); -#else /* __UCLIBC_HAS_WCHAR__ */ - assert((psfs.conv_num == CONV_leftbracket)); -#endif /* __UCLIBC_HAS_WCHAR__ */ - - invert = 0; - - if (*++fmt == '^') { - ++fmt; - invert = 1; - } - __memset(scanset, invert, sizeof(scanset)); - invert = 1-invert; - - if (*fmt == ']') { - scanset[(int)(']')] = invert; - ++fmt; - } - - while (*fmt != ']') { - if (!*fmt) { /* No closing ']'. */ - goto DONE; - } - if ((*fmt == '-') && (fmt[1] != ']') - && (fmt[-1] < fmt[1]) /* sorted? */ - ) { /* range */ - ++fmt; - i = fmt[-2]; - /* Note: scanset[i] should already have been done - * in the previous iteration. */ - do { - scanset[++i] = invert; - } while (i < *fmt); - /* Safe to fall through, and a bit smaller. */ - } - /* literal char */ - scanset[(int) *fmt] = invert; - ++fmt; - } - -#ifdef __UCLIBC_HAS_WCHAR__ - if (psfs.conv_num == CONV_LEFTBRACKET) { - goto DO_LEFTBRACKET; - } -#endif /* __UCLIBC_HAS_WCHAR__ */ - - - while (__scan_getc(&sc) >= 0) { - zero_conversions = 0; - if (!scanset[sc.cc]) { - break; - } - *b = sc.cc; - b += psfs.store; - fail = 0; - } - } - /* Common tail for processing of %s and %[. */ - - __scan_ungetc(&sc); - if (fail) { /* nothing stored! */ - goto DONE; - } - *b = 0; /* Nul-terminate string. */ - psfs.cnt += psfs.store; - goto NEXT_FMT; - } - -#ifdef __UCLIBC_HAS_WCHAR__ - DO_LEFTBRACKET: /* Need to do common wide init. */ - if (psfs.conv_num >= CONV_C) { - wchar_t wbuf[1]; - wchar_t *wb; - - sc.mbstate.__mask = 0; - - wb = (psfs.store ? ((wchar_t *) psfs.cur_ptr) : wbuf); - fail = 1; - - if (psfs.conv_num == CONV_C) { - if (sc.width == INT_MAX) { - sc.width = 1; - } - - while (scan_getwc(&sc) >= 0) { - zero_conversions = 0; - assert(sc.width >= 0); - *wb = sc.wc; - wb += psfs.store; - } - - __scan_ungetc(&sc); - if (sc.width > 0) { /* Failed to read all required. */ - goto DONE; - } - psfs.cnt += psfs.store; - goto NEXT_FMT; - } - - - if (psfs.conv_num == CONV_S) { - /* Yes, believe it or not, a %s conversion can store nuls. */ - while (scan_getwc(&sc) >= 0) { - zero_conversions = 0; - if ((((__uwchar_t)(sc.wc)) <= UCHAR_MAX) && isspace(sc.wc)) { - break; - } - *wb = sc.wc; - wb += psfs.store; - fail = 0; - } - } else { - assert(psfs.conv_num == CONV_LEFTBRACKET); - - while (scan_getwc(&sc) >= 0) { - zero_conversions = 0; - if (((__uwchar_t) sc.wc) <= UCHAR_MAX) { - if (!scanset[sc.wc]) { - break; - } - } else if (invert) { - break; - } - *wb = sc.wc; - wb += psfs.store; - fail = 0; - } - } - /* Common tail for processing of %ls and %l[. */ - - __scan_ungetc(&sc); - if (fail || sc.mb_fail) { /* Nothing stored or mb error. */ - goto DONE; - } - *wb = 0; /* Nul-terminate string. */ - psfs.cnt += psfs.store; - goto NEXT_FMT; - - } - -#endif /* __UCLIBC_HAS_WCHAR__ */ -#else /* L_vfscanf */ - - if (psfs.conv_num >= CONV_C) { - b = buf; - wb = wbuf; - if (psfs.conv_num >= CONV_c) { - mbstate.__mask = 0; /* Initialize the mbstate. */ - if (psfs.store) { - b = (unsigned char *) psfs.cur_ptr; - } - } else { - if (psfs.store) { - wb = (wchar_t *) psfs.cur_ptr; - } - } - fail = 1; - - - if ((psfs.conv_num == CONV_C) || (psfs.conv_num == CONV_c)) { - if (sc.width == INT_MAX) { - sc.width = 1; - } - - while (scan_getwc(&sc) >= 0) { - zero_conversions = 0; - if (psfs.conv_num == CONV_C) { - *wb = sc.wc; - wb += psfs.store; - } else { - i = wcrtomb(b, sc.wc, &mbstate); - if (i < 0) { /* Conversion failure. */ - goto DONE_DO_UNGET; - } - if (psfs.store) { - b += i; - } - } - } - __scan_ungetc(&sc); - if (sc.width > 0) { /* Failed to read all required. */ - goto DONE; - } - psfs.cnt += psfs.store; - goto NEXT_FMT; - } - - if ((psfs.conv_num == CONV_S) || (psfs.conv_num == CONV_s)) { - /* Yes, believe it or not, a %s conversion can store nuls. */ - while (scan_getwc(&sc) >= 0) { - zero_conversions = 0; - if (iswspace(sc.wc)) { - break; - } - if (psfs.conv_num == CONV_S) { - *wb = sc.wc; - wb += psfs.store; - } else { - i = wcrtomb(b, sc.wc, &mbstate); - if (i < 0) { /* Conversion failure. */ - goto DONE_DO_UNGET; - } - if (psfs.store) { - b += i; - } - } - fail = 0; - } - } else { - const wchar_t *sss; - const wchar_t *ssp; - unsigned char invert = 0; - - assert((psfs.conv_num == CONV_LEFTBRACKET) - || (psfs.conv_num == CONV_leftbracket)); - - if (*++fmt == '^') { - ++fmt; - invert = 1; - } - sss = (const wchar_t *) fmt; - if (*fmt == ']') { - ++fmt; - } - while (*fmt != ']') { - if (!*fmt) { /* No closing ']'. */ - goto DONE; - } - if ((*fmt == '-') && (fmt[1] != ']') - && (fmt[-1] < fmt[1]) /* sorted? */ - ) { /* range */ - ++fmt; - } - ++fmt; - } - /* Ok... a valid scanset spec. */ - - while (scan_getwc(&sc) >= 0) { - zero_conversions = 0; - ssp = sss; - do { /* We know sss < fmt. */ - if (*ssp == '-') { /* possible range... */ - /* Note: We accept a-c-e (ordered) as - * equivalent to a-e. */ - if (ssp > sss) { - if ((++ssp < (const wchar_t *) fmt) - && (ssp[-2] < *ssp) /* sorted? */ - ) { /* yes */ - if ((sc.wc >= ssp[-2]) - && (sc.wc <= *ssp)) { - break; - } - continue; /* not in range */ - } - --ssp; /* oops... '-' at end, so back up */ - } - /* false alarm... a literal '-' */ - } - if (sc.wc == *ssp) { /* Matched literal char. */ - break; - } - } while (++ssp < (const wchar_t *) fmt); - - if ((ssp == (const wchar_t *) fmt) ^ invert) { - /* no match and not inverting - * or match and inverting */ - break; - } - if (psfs.conv_num == CONV_LEFTBRACKET) { - *wb = sc.wc; - wb += psfs.store; - } else { - i = wcrtomb(b, sc.wc, &mbstate); - if (i < 0) { /* Conversion failure. */ - goto DONE_DO_UNGET; - } - if (psfs.store) { - b += i; - } - } - fail = 0; - } - } - /* Common tail for processing of %s and %[. */ - - __scan_ungetc(&sc); - if (fail) { /* nothing stored! */ - goto DONE; - } - *wb = 0; /* Nul-terminate string. */ - *b = 0; - psfs.cnt += psfs.store; - goto NEXT_FMT; - } - -#endif /* L_vfscanf */ - - assert(0); - goto DONE; - } /* conversion specification */ - - MATCH_CHAR: - if (__scan_getc(&sc) != *fmt) { -#ifdef L_vfwscanf - DONE_DO_UNGET: -#endif /* L_vfwscanf */ - __scan_ungetc(&sc); - goto DONE; - } - - NEXT_FMT: - ++fmt; - if (__FERROR_UNLOCKED(fp)) { - break; - } - } - - DONE: - if (__FERROR_UNLOCKED(fp) || (*fmt && zero_conversions && __FEOF_UNLOCKED(fp))) { - psfs.cnt = EOF; /* Yes, vfwscanf also returns EOF. */ - } - - kill_scan_cookie(&sc); - - __STDIO_STREAM_VALIDATE(fp); - - __STDIO_AUTO_THREADUNLOCK(fp); - - return psfs.cnt; -} -strong_alias(HIDDEN_VFSCANF,VFSCANF) -#endif -/**********************************************************************/ -#ifdef L___psfs_do_numeric - -static const unsigned char spec_base[] = SPEC_BASE; -static const unsigned char nil_string[] = "(nil)"; - -int attribute_hidden __psfs_do_numeric(psfs_t *psfs, struct scan_cookie *sc) -{ - unsigned char *b; - const unsigned char *p; - -#ifdef __UCLIBC_HAS_FLOATS__ - int exp_adjust = 0; -#endif -#ifdef __UCLIBC_MJN3_ONLY__ -#warning TODO: Fix MAX_DIGITS. We do not do binary, so...! -#warning TODO: Fix buf! -#endif -#define MAX_DIGITS 65 /* Allow one leading 0. */ - unsigned char buf[MAX_DIGITS+2+ 100]; - unsigned char usflag, base; - unsigned char nonzero = 0; - unsigned char seendigit = 0; - - -#ifdef __UCLIBC_MJN3_ONLY__ -#warning CONSIDER: What should be returned for an invalid conversion specifier? -#endif -#ifndef __UCLIBC_HAS_FLOATS__ - if (psfs->conv_num > CONV_i) { /* floating point */ - goto DONE; - } -#endif - - base = spec_base[psfs->conv_num - CONV_p]; - usflag = (psfs->conv_num <= CONV_u); /* (1)0 if (un)signed */ - b = buf; - - - if (psfs->conv_num == CONV_p) { /* Pointer */ - p = nil_string; - do { - if ((__scan_getc(sc) < 0) || (*p != sc->cc)) { - __scan_ungetc(sc); - if (p > nil_string) { - /* We matched at least the '(' so even if we - * are at eof, we can not match a pointer. */ - return -2; /* Matching failure */ - } - break; - } - if (!*++p) { /* Matched (nil), so no unget necessary. */ - if (psfs->store) { - ++psfs->cnt; - _store_inttype(psfs->cur_ptr, psfs->dataargtype, - (uintmax_t) NULL); - } - return 0; - } - } while (1); - -#ifdef __UCLIBC_MJN3_ONLY__ -#warning CONSIDER: Should we require a 0x prefix and disallow +/- for pointer %p? -#endif /* __UCLIBC_MJN3_ONLY__ */ - } - - __scan_getc(sc); - if (sc->cc < 0) { - return -1; /* Input failure (nothing read yet). */ - } - - if ((sc->cc == '+') || (sc->cc == '-')) { /* Handle leading sign.*/ - *b++ = sc->cc; - __scan_getc(sc); - } - - if ((base & 0xef) == 0) { /* 0xef is ~16, so 16 or 0. */ - if (sc->cc == '0') { /* Possibly set base and handle prefix. */ - __scan_getc(sc); - if ((sc->cc|0x20) == 'x') { /* Assumes ascii.. x or X. */ - if (__scan_getc(sc) < 0) { - /* Either EOF or error (including wc outside char range). - * If EOF or error, this is a matching failure (we read 0x). - * If wc outside char range, this is also a matching failure. - * Hence, we do an unget (although not really necessary here - * and fail. */ - goto DONE_DO_UNGET; /* matching failure */ - } - base = 16; /* Base 16 for sure now. */ -#ifdef __UCLIBC_HAS_HEXADECIMAL_FLOATS__ - /* The prefix is required for hexadecimal floats. */ - *b++ = '0'; - *b++ = 'x'; -#endif /* __UCLIBC_HAS_HEXADECIMAL_FLOATS__ */ - } else { /* oops... back up */ - __scan_ungetc(sc); - sc->cc = '0'; /* NASTY HACK! */ - - base = (base >> 1) + 8; /* 0->8, 16->16. no 'if' */ -#ifdef __UCLIBC_HAS_FLOATS__ - if (psfs->conv_num > CONV_i) { /* floating point */ - base = 10; - } -#endif - } - } else if (!base) { - base = 10; - } - } - - /***************** digit grouping **********************/ -#ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ - - if ((psfs->flags & FLAG_THOUSANDS) && (base == 10) - && *(p = sc->grouping) - ) { - - int nblk1, nblk2, nbmax, lastblock, pass, i; - - -#ifdef __UCLIBC_MJN3_ONLY__ -#warning CONSIDER: Should we initalize the grouping blocks in __init_scan_cookie()? -#endif /* __UCLIBC_MJN3_ONLY__ */ - nbmax = nblk2 = nblk1 = *p; - if (*++p) { - nblk2 = *p; - if (nbmax < nblk2) { - nbmax = nblk2; - } - assert(!p[1]); - } - - /* Note: for printf, if 0 and \' flags appear then - * grouping is done before 0-padding. Should we - * strip leading 0's first? Or add a 0 flag? */ - - /* For vfwscanf, sc_getc translates, so the value of sc->cc is - * either EOF or a char. */ - - if (!__isdigit_char_or_EOF(sc->cc)) { /* No starting digit! */ -#ifdef __UCLIBC_HAS_FLOATS__ - if (psfs->conv_num > CONV_i) { /* floating point */ - goto NO_STARTING_DIGIT; - } -#endif - goto DONE_DO_UNGET; - } - - if (sc->cc == '0') { - seendigit = 1; - *b++ = '0'; /* Store the first 0. */ -#ifdef __UCLIBC_MJN3_ONLY__ -#warning CONSIDER: Should leading 0s be skipped before digit grouping? (printf 0 pad) -#endif /* __UCLIBC_MJN3_ONLY__ */ -#if 0 - do { /* But ignore all subsequent 0s. */ - __scan_getc(sc); - } while (sc->cc == '0'); -#endif - } - pass = 0; - lastblock = 0; - do { - i = 0; - while (__isdigit_char_or_EOF(sc->cc)) { - seendigit = 1; - if (i == nbmax) { /* too many digits for a block */ -#ifdef __UCLIBC_HAS_SCANF_LENIENT_DIGIT_GROUPING__ - if (!pass) { /* treat as nongrouped */ - if (nonzero) { - goto DO_NO_GROUP; - } - goto DO_TRIM_LEADING_ZEROS; - } -#endif - if (nbmax > nblk1) { - goto DONE_DO_UNGET; /* matching failure */ - } - goto DONE_GROUPING_DO_UNGET; /* nbmax == nblk1 */ - } - ++i; - - if (nonzero || (sc->cc != '0')) { - if (b < buf + MAX_DIGITS) { - *b++ = sc->cc; - nonzero = 1; -#ifdef __UCLIBC_HAS_FLOATS__ - } else { - ++exp_adjust; -#endif - } - } - - __scan_getc(sc); - } - - if (i) { /* we saw digits digits */ - if ((i == nblk2) || ((i < nblk2) && !pass)) { - /* (possible) outer grp */ - p = sc->thousands_sep; - if (*p == sc->cc) { /* first byte matches... */ - /* so check if grouping mb char */ - /* Since 1st matched, either match or fail now - * unless EOF (yuk) */ - __scan_getc(sc); - MBG_LOOP: - if (!*++p) { /* is a grouping mb char */ - lastblock = i; - ++pass; - continue; - } - if (*p == sc->cc) { - __scan_getc(sc); - goto MBG_LOOP; - } - /* bad grouping mb char! */ - __scan_ungetc(sc); - if ((sc->cc >= 0) || (p > sc->thousands_sep + 1)) { -#ifdef __UCLIBC_HAS_FLOATS__ - /* We failed to match a thousep mb char, and - * we've read too much to recover. But if - * this is a floating point conversion and - * the initial portion of the decpt mb char - * matches, then we may still be able to - * recover. */ - int k = p - sc->thousands_sep - 1; - - if ((psfs->conv_num > CONV_i) /* float conversion */ - && (!pass || (i == nblk1)) /* possible last */ - && !__memcmp(sc->thousands_sep, sc->fake_decpt, k) - /* and prefix matched, so could be decpt */ - ) { - __scan_getc(sc); - p = sc->fake_decpt + k; - do { - if (!*++p) { - __strcpy(b, sc->decpt); - b += sc->decpt_len; - goto GOT_DECPT; - } - if (*p != sc->cc) { - __scan_ungetc(sc); - break; /* failed */ - } - __scan_getc(sc); - } while (1); - } -#endif /* __UCLIBC_HAS_FLOATS__ */ - goto DONE; - } - /* was EOF and 1st, so recoverable. */ - } - } - if ((i == nblk1) || ((i < nblk1) && !pass)) { - /* got an inner group */ - goto DONE_GROUPING_DO_UNGET; - } - goto DONE_DO_UNGET; /* Matching failure. */ - } /* i != 0 */ - - assert(pass); - - goto DONE_DO_UNGET; - } while (1); - - assert(0); /* Should never get here. */ - } - -#endif /***************** digit grouping **********************/ - - /* Not grouping so first trim all but one leading 0. */ -#ifdef __UCLIBC_HAS_SCANF_LENIENT_DIGIT_GROUPING__ - DO_TRIM_LEADING_ZEROS: -#endif /* __UCLIBC_HAS_SCANF_LENIENT_DIGIT_GROUPING__ */ - if (sc->cc == '0') { - seendigit = 1; - *b++ = '0'; /* Store the first 0. */ - do { /* But ignore all subsequent 0s. */ - __scan_getc(sc); - } while (sc->cc == '0'); - } - -#ifdef __UCLIBC_HAS_SCANF_LENIENT_DIGIT_GROUPING__ - DO_NO_GROUP: -#endif /* __UCLIBC_HAS_SCANF_LENIENT_DIGIT_GROUPING__ */ - /* At this point, we're ready to start reading digits. */ - -#define valid_digit(cc,base) (isxdigit(cc) && ((base == 16) || (cc - '0' < base))) - - while (valid_digit(sc->cc,base)) { /* Now for significant digits.*/ - if (b - buf < MAX_DIGITS) { - nonzero = seendigit = 1; /* Set nonzero too 0s trimmed above. */ - *b++ = sc->cc; -#ifdef __UCLIBC_HAS_FLOATS__ - } else { - ++exp_adjust; -#endif - } - __scan_getc(sc); - } - -#ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ - DONE_GROUPING_DO_UNGET: -#endif /* __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ */ - if (psfs->conv_num <= CONV_i) { /* integer conversion */ - __scan_ungetc(sc); - *b = 0; /* null-terminate */ - if (!seendigit) { - goto DONE; /* No digits! */ - } - if (psfs->store) { - if (*buf == '-') { - usflag = 0; - } - ++psfs->cnt; - _store_inttype(psfs->cur_ptr, psfs->dataargtype, - (uintmax_t) STRTOUIM(buf, NULL, base, 1-usflag)); - } - return 0; - } - -#ifdef __UCLIBC_HAS_FLOATS__ - - /* At this point, we have everything left of the decimal point or exponent. */ -#ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ - NO_STARTING_DIGIT: -#endif - p = sc->fake_decpt; - do { - if (!*p) { - __strcpy(b, sc->decpt); - b += sc->decpt_len; - break; - } - if (*p != sc->cc) { - if (p > sc->fake_decpt) { - goto DONE_DO_UNGET; /* matching failure (read some of decpt) */ - } - goto DO_DIGIT_CHECK; - } - ++p; - __scan_getc(sc); - } while (1); - -#ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ - GOT_DECPT: -#endif - if (!nonzero) { - if (sc->cc == '0') { - assert(exp_adjust == 0); - *b++ = '0'; - ++exp_adjust; - seendigit = 1; - do { - --exp_adjust; - __scan_getc(sc); - } while (sc->cc == '0'); - } - } - - while (valid_digit(sc->cc,base)) { /* Process fractional digits.*/ - if (b - buf < MAX_DIGITS) { - seendigit = 1; - *b++ = sc->cc; - } - __scan_getc(sc); - } - - DO_DIGIT_CHECK: - /* Hmm... no decimal point. */ - if (!seendigit) { - static const unsigned char nan_inf_str[] = "an\0nfinity"; - - if (base == 16) { /* We had a prefix, but no digits! */ - goto DONE_DO_UNGET; /* matching failure */ - } - - /* Avoid tolower problems for INFINITY in the tr_TR locale. (yuk)*/ -#undef TOLOWER -#define TOLOWER(C) ((C)|0x20) - - switch (TOLOWER(sc->cc)) { - case 'i': - p = nan_inf_str + 3; - break; - case 'n': - p = nan_inf_str; - break; - default: - /* No digits and not inf or nan. */ - goto DONE_DO_UNGET; - } - - *b++ = sc->cc; - - do { - __scan_getc(sc); - if (TOLOWER(sc->cc) == *p) { - *b++ = sc->cc; - ++p; - continue; - } - if (!*p || (p == nan_inf_str + 5)) { /* match nan/infinity or inf */ - goto GOT_FLOAT; - } - /* Unrecoverable. Even if on 1st char, we had no digits. */ - goto DONE_DO_UNGET; - } while (1); - } - - /* If we get here, we had some digits. */ - - if ( -#ifdef __UCLIBC_HAS_HEXADECIMAL_FLOATS__ - ((base == 16) && (((sc->cc)|0x20) == 'p')) || -#endif - (((sc->cc)|0x20) == 'e') - ) { /* Process an exponent. */ - *b++ = sc->cc; - - __scan_getc(sc); - if (sc->cc < 0) { - goto DONE_DO_UNGET; /* matching failure.. no exponent digits */ - } - - if ((sc->cc == '+') || (sc->cc == '-')) { /* Signed exponent? */ - *b++ = sc->cc; - __scan_getc(sc); - } - -#ifdef __UCLIBC_MJN3_ONLY__ -#warning TODO: Fix MAX_EXP_DIGITS! -#endif -#define MAX_EXP_DIGITS 20 - assert(seendigit); - seendigit = 0; - nonzero = 0; - - if (sc->cc == '0') { - seendigit = 1; - *b++ = '0'; - do { - __scan_getc(sc); - } while (sc->cc == '0'); - } - - while (__isdigit_char_or_EOF(sc->cc)) { /* Exponent digits (base 10).*/ - if (seendigit < MAX_EXP_DIGITS) { - ++seendigit; - *b++ = sc->cc; - } - __scan_getc(sc); - } - - if (!seendigit) { /* No digits. Unrecoverable. */ - goto DONE_DO_UNGET; - } - } - - - GOT_FLOAT: - *b = 0; - { - __fpmax_t x; - char *e; - x = __strtofpmax(buf, &e, exp_adjust); - assert(!*e); - if (psfs->store) { - if (psfs->dataargtype & PA_FLAG_LONG_LONG) { - *((long double *)psfs->cur_ptr) = (long double) x; - } else if (psfs->dataargtype & PA_FLAG_LONG) { - *((double *)psfs->cur_ptr) = (double) x; - } else { - *((float *)psfs->cur_ptr) = (float) x; - } - ++psfs->cnt; - } - __scan_ungetc(sc); - return 0; - } -#endif /* __UCLIBC_HAS_FLOATS__ */ - - DONE_DO_UNGET: - __scan_ungetc(sc); - DONE: - return -2; /* Matching failure. */ - -} -#endif -/**********************************************************************/ +#define L_scanf +#include "_scanf.c" diff --git a/libc/stdio/setbuf.c b/libc/stdio/setbuf.c index 02a4736ac..6de2c91a1 100644 --- a/libc/stdio/setbuf.c +++ b/libc/stdio/setbuf.c @@ -7,9 +7,11 @@ #include "_stdio.h" +libc_hidden_proto(setvbuf) + void setbuf(FILE * __restrict stream, register char * __restrict buf) { #ifdef __STDIO_BUFFERS - __setvbuf(stream, buf, ((buf != NULL) ? _IOFBF : _IONBF), BUFSIZ); + setvbuf(stream, buf, ((buf != NULL) ? _IOFBF : _IONBF), BUFSIZ); #endif } diff --git a/libc/stdio/setbuffer.c b/libc/stdio/setbuffer.c index d1f12a1af..3ca4fb7f8 100644 --- a/libc/stdio/setbuffer.c +++ b/libc/stdio/setbuffer.c @@ -7,6 +7,8 @@ #include "_stdio.h" +libc_hidden_proto(setvbuf) + /* A BSD function. The implementation matches the linux man page, * except that we do not bother calling setvbuf if not configured * for stream buffering. @@ -16,6 +18,6 @@ void setbuffer(FILE * __restrict stream, register char * __restrict buf, size_t size) { #ifdef __STDIO_BUFFERS - __setvbuf(stream, buf, (buf ? _IOFBF : _IONBF), size); + setvbuf(stream, buf, (buf ? _IOFBF : _IONBF), size); #endif } diff --git a/libc/stdio/setlinebuf.c b/libc/stdio/setlinebuf.c index 56e89e11b..29b2bdeac 100644 --- a/libc/stdio/setlinebuf.c +++ b/libc/stdio/setlinebuf.c @@ -7,6 +7,8 @@ #include "_stdio.h" +libc_hidden_proto(setvbuf) + /* A BSD function. The implementation matches the linux man page, * except that we do not bother calling setvbuf if not configured * for stream buffering. @@ -15,6 +17,6 @@ void setlinebuf(FILE * __restrict stream) { #ifdef __STDIO_BUFFERS - __setvbuf(stream, NULL, _IOLBF, (size_t) 0); + setvbuf(stream, NULL, _IOLBF, (size_t) 0); #endif } diff --git a/libc/stdio/setvbuf.c b/libc/stdio/setvbuf.c index d12d1576a..c1566504a 100644 --- a/libc/stdio/setvbuf.c +++ b/libc/stdio/setvbuf.c @@ -14,7 +14,8 @@ #error Assumption violated for buffering mode flags #endif -int attribute_hidden __setvbuf(register FILE * __restrict stream, register char * __restrict buf, +libc_hidden_proto(setvbuf) +int setvbuf(register FILE * __restrict stream, register char * __restrict buf, int mode, size_t size) { #ifdef __STDIO_BUFFERS @@ -104,4 +105,4 @@ int attribute_hidden __setvbuf(register FILE * __restrict stream, register char #endif } -strong_alias(__setvbuf,setvbuf) +libc_hidden_def(setvbuf) diff --git a/libc/stdio/snprintf.c b/libc/stdio/snprintf.c index a1ea79fc0..ef9c69215 100644 --- a/libc/stdio/snprintf.c +++ b/libc/stdio/snprintf.c @@ -12,17 +12,20 @@ #warning Skipping snprintf since no vsnprintf! #else -int attribute_hidden __snprintf(char *__restrict buf, size_t size, +libc_hidden_proto(vsnprintf) + +libc_hidden_proto(snprintf) +int snprintf(char *__restrict buf, size_t size, const char * __restrict format, ...) { va_list arg; int rv; va_start(arg, format); - rv = __vsnprintf(buf, size, format, arg); + rv = vsnprintf(buf, size, format, arg); va_end(arg); return rv; } -strong_alias(__snprintf,snprintf) +libc_hidden_def(snprintf) #endif diff --git a/libc/stdio/sprintf.c b/libc/stdio/sprintf.c index 5778c011d..360245366 100644 --- a/libc/stdio/sprintf.c +++ b/libc/stdio/sprintf.c @@ -12,17 +12,20 @@ #warning Skipping sprintf since no vsnprintf! #else -int attribute_hidden __sprintf(char *__restrict buf, const char * __restrict format, ...) +libc_hidden_proto(vsnprintf) + +libc_hidden_proto(sprintf) +int sprintf(char *__restrict buf, const char * __restrict format, ...) { va_list arg; int rv; va_start(arg, format); - rv = __vsnprintf(buf, SIZE_MAX, format, arg); + rv = vsnprintf(buf, SIZE_MAX, format, arg); va_end(arg); return rv; } -strong_alias(__sprintf,sprintf) +libc_hidden_def(sprintf) #endif diff --git a/libc/stdio/sscanf.c b/libc/stdio/sscanf.c new file mode 100644 index 000000000..f53c06545 --- /dev/null +++ b/libc/stdio/sscanf.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define L_sscanf +#include "_scanf.c" diff --git a/libc/stdio/swprintf.c b/libc/stdio/swprintf.c index b373df8bd..0c209fe4b 100644 --- a/libc/stdio/swprintf.c +++ b/libc/stdio/swprintf.c @@ -5,12 +5,12 @@ * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. */ -#define vswprintf __vswprintf - #include "_stdio.h" #include <stdarg.h> #include <wchar.h> +libc_hidden_proto(vswprintf) + #ifndef __STDIO_BUFFERS #warning Skipping swprintf since no buffering! #else /* __STDIO_BUFFERS */ diff --git a/libc/stdio/swscanf.c b/libc/stdio/swscanf.c new file mode 100644 index 000000000..06f8cb75f --- /dev/null +++ b/libc/stdio/swscanf.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define L_swscanf +#include "_scanf.c" diff --git a/libc/stdio/tempnam.c b/libc/stdio/tempnam.c index d626dc0f8..43cbf781b 100644 --- a/libc/stdio/tempnam.c +++ b/libc/stdio/tempnam.c @@ -20,6 +20,8 @@ #include <string.h> #include "../misc/internals/tempname.h" +libc_hidden_proto(strdup) + /* Generate a unique temporary filename using up to five characters of PFX if it is not NULL. The directory to put this file in is searched for as follows: First the environment variable "TMPDIR" is checked. @@ -38,6 +40,6 @@ tempnam (const char *dir, const char *pfx) if (__gen_tempname (buf, __GT_NOCREATE)) return NULL; - return __strdup (buf); + return strdup (buf); } diff --git a/libc/stdio/tmpfile.c b/libc/stdio/tmpfile.c index 606fcc436..f83944539 100644 --- a/libc/stdio/tmpfile.c +++ b/libc/stdio/tmpfile.c @@ -16,14 +16,15 @@ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ -#define fdopen __fdopen -#define remove __remove - #include <features.h> #include <stdio.h> #include <unistd.h> #include "../misc/internals/tempname.h" +libc_hidden_proto(fdopen) +libc_hidden_proto(remove) +libc_hidden_proto(close) + /* This returns a new stream opened on a temporary file (generated by tmpnam). The file is opened with mode "w+b" (binary read/write). If we couldn't generate a unique filename or the file couldn't @@ -45,10 +46,10 @@ FILE * tmpfile (void) (void) remove (buf); if ((f = fdopen (fd, "w+b")) == NULL) - __close (fd); + close (fd); return f; } #ifdef __UCLIBC_HAS_LFS__ -weak_alias(tmpfile,tmpfile64) +strong_alias(tmpfile,tmpfile64) #endif diff --git a/libc/stdio/tmpnam.c b/libc/stdio/tmpnam.c index df2399e66..bc4ffeb6a 100644 --- a/libc/stdio/tmpnam.c +++ b/libc/stdio/tmpnam.c @@ -1,48 +1,55 @@ -/* Copyright (C) 1991, 1993, 1996, 1997, 1998 Free Software Foundation, Inc. +/* Copyright (C) 1991,1993,1996-1999,2000 Free Software Foundation, Inc. This file is part of the GNU C Library. The GNU C 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. + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. The GNU C 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. + Lesser General Public License for more details. - You should have received a copy of the GNU Library General Public - License along with the GNU C Library; see the file COPYING.LIB. If not, - write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA. */ #include <stdio.h> #include <string.h> #include "../misc/internals/tempname.h" +libc_hidden_proto(memcpy) + static char tmpnam_buffer[L_tmpnam]; /* Generate a unique filename in P_tmpdir. - This function is *not* thread safe when S == NULL! -*/ -char * tmpnam (char *s) + + This function is *not* thread safe! */ +char * +tmpnam (char *s) { - /* By using two buffers we manage to be thread safe in the case - where S != NULL. */ - char tmpbuf[L_tmpnam]; + /* By using two buffers we manage to be thread safe in the case + where S != NULL. */ + char tmpbufmem[L_tmpnam]; + char *tmpbuf = s ?: tmpbufmem; - /* In the following call we use the buffer pointed to by S if - non-NULL although we don't know the size. But we limit the size - to L_tmpnam characters in any case. */ - if (__path_search (s ? : tmpbuf, L_tmpnam, NULL, NULL, 0)) - return NULL; + /* In the following call we use the buffer pointed to by S if + non-NULL although we don't know the size. But we limit the size + to L_tmpnam characters in any case. */ + if (__builtin_expect (__path_search (tmpbuf, L_tmpnam, NULL, NULL, 0), + 0)) + return NULL; - if (__gen_tempname (s ? : tmpbuf, __GT_NOCREATE)) - return NULL; + if (__builtin_expect (__gen_tempname (tmpbuf, __GT_NOCREATE), 0)) + return NULL; - if (s == NULL) - return (char *) __memcpy (tmpnam_buffer, tmpbuf, L_tmpnam); + if (s == NULL) + return (char *) memcpy (tmpnam_buffer, tmpbuf, L_tmpnam); - return s; + return s; } +link_warning (tmpnam, + "the use of `tmpnam' is dangerous, better use `mkstemp'") diff --git a/libc/stdio/ungetc.c b/libc/stdio/ungetc.c index de3f1d16b..d900928b2 100644 --- a/libc/stdio/ungetc.c +++ b/libc/stdio/ungetc.c @@ -24,7 +24,8 @@ * (See section 7.19.6.2 of the C9X rationale -- WG14/N897.) */ -int attribute_hidden __ungetc(int c, register FILE *stream) +libc_hidden_proto(ungetc) +int ungetc(int c, register FILE *stream) { __STDIO_AUTO_THREADLOCK_VAR; @@ -75,4 +76,4 @@ int attribute_hidden __ungetc(int c, register FILE *stream) return c; } -strong_alias(__ungetc,ungetc) +libc_hidden_def(ungetc) diff --git a/libc/stdio/ungetwc.c b/libc/stdio/ungetwc.c index c6a99dd9d..579022240 100644 --- a/libc/stdio/ungetwc.c +++ b/libc/stdio/ungetwc.c @@ -12,7 +12,8 @@ * as reset stream->__ungot_width[1] for use by _stdio_adjpos(). */ -wint_t attribute_hidden __ungetwc(wint_t c, register FILE *stream) +libc_hidden_proto(ungetwc) +wint_t ungetwc(wint_t c, register FILE *stream) { __STDIO_AUTO_THREADLOCK_VAR; @@ -46,4 +47,4 @@ wint_t attribute_hidden __ungetwc(wint_t c, register FILE *stream) return c; } -strong_alias(__ungetwc,ungetwc) +libc_hidden_def(ungetwc) diff --git a/libc/stdio/vasprintf.c b/libc/stdio/vasprintf.c index ca110cbd1..7a34f6870 100644 --- a/libc/stdio/vasprintf.c +++ b/libc/stdio/vasprintf.c @@ -5,12 +5,14 @@ * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. */ -#define open_memstream __open_memstream +#include <features.h> +#ifdef __USE_GNU #include "_stdio.h" #include <stdarg.h> #include <bits/uClibc_va_copy.h> + #ifdef __UCLIBC_MJN3_ONLY__ /* Do the memstream stuff inline to avoid fclose and the openlist? */ #warning CONSIDER: avoid open_memstream call? @@ -20,7 +22,16 @@ #warning Skipping vasprintf since no vsnprintf! #else -int attribute_hidden __vasprintf(char **__restrict buf, const char * __restrict format, +#ifdef __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__ +libc_hidden_proto(open_memstream) +libc_hidden_proto(fclose) +libc_hidden_proto(vfprintf) +#else +libc_hidden_proto(vsnprintf) +#endif + +libc_hidden_proto(vasprintf) +int vasprintf(char **__restrict buf, const char * __restrict format, va_list arg) { #ifdef __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__ @@ -32,7 +43,7 @@ int attribute_hidden __vasprintf(char **__restrict buf, const char * __restrict *buf = NULL; if ((f = open_memstream(buf, &size)) != NULL) { - rv = __vfprintf(f, format, arg); + rv = vfprintf(f, format, arg); fclose(f); if (rv < 0) { free(*buf); @@ -54,14 +65,14 @@ int attribute_hidden __vasprintf(char **__restrict buf, const char * __restrict int rv; va_copy(arg2, arg); - rv = __vsnprintf(NULL, 0, format, arg2); + rv = vsnprintf(NULL, 0, format, arg2); va_end(arg2); *buf = NULL; if (rv >= 0) { if ((*buf = malloc(++rv)) != NULL) { - if ((rv = __vsnprintf(*buf, rv, format, arg)) < 0) { + if ((rv = vsnprintf(*buf, rv, format, arg)) < 0) { free(*buf); *buf = NULL; } @@ -74,6 +85,7 @@ int attribute_hidden __vasprintf(char **__restrict buf, const char * __restrict #endif /* __UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__ */ } -strong_alias(__vasprintf,vasprintf) +libc_hidden_def(vasprintf) #endif +#endif diff --git a/libc/stdio/vdprintf.c b/libc/stdio/vdprintf.c index 4e066f169..67adf47be 100644 --- a/libc/stdio/vdprintf.c +++ b/libc/stdio/vdprintf.c @@ -5,10 +5,17 @@ * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. */ +#include <features.h> + +#ifdef __USE_GNU #include "_stdio.h" #include <stdarg.h> -int attribute_hidden __vdprintf(int filedes, const char * __restrict format, va_list arg) +libc_hidden_proto(vfprintf) +libc_hidden_proto(fflush_unlocked) + +libc_hidden_proto(vdprintf) +int vdprintf(int filedes, const char * __restrict format, va_list arg) { FILE f; int rv; @@ -51,11 +58,11 @@ int attribute_hidden __vdprintf(int filedes, const char * __restrict format, va_ #endif f.__nextopen = NULL; - rv = __vfprintf(&f, format, arg); + rv = vfprintf(&f, format, arg); #ifdef __STDIO_BUFFERS /* If not buffering, then fflush is unnecessary. */ - if ((rv > 0) && __fflush_unlocked(&f)) { + if ((rv > 0) && fflush_unlocked(&f)) { rv = -1; } #endif @@ -64,4 +71,5 @@ int attribute_hidden __vdprintf(int filedes, const char * __restrict format, va_ return rv; } -strong_alias(__vdprintf,vdprintf) +libc_hidden_def(vdprintf) +#endif diff --git a/libc/stdio/vfprintf.c b/libc/stdio/vfprintf.c index bdbf0c788..78b725fd9 100644 --- a/libc/stdio/vfprintf.c +++ b/libc/stdio/vfprintf.c @@ -1,1929 +1,9 @@ -/* Copyright (C) 2002-2004 Manuel Novoa III - * My stdio library for linux and (soon) elks. +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> * - * 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. + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. * - * 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. - */ - -/* This code needs a lot of clean up. Some of that is on hold until uClibc - * gets a better configuration system (on Erik's todo list). - * The other cleanup will take place during the implementation/integration of - * the wide char (un)formatted i/o functions which I'm currently working on. - */ - -/* 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! */ - - -/* April 1, 2002 - * Initialize thread locks for fake files in vsnprintf and vdprintf. - * reported by Erik Andersen (andersen@codepoet.com) - * Fix an arg promotion handling bug in _do_one_spec for %c. - * reported by Ilguiz Latypov <ilatypov@superbt.com> - * - * May 10, 2002 - * Remove __isdigit and use new ctype.h version. - * Add conditional setting of QUAL_CHARS for size_t and ptrdiff_t. - * - * Aug 16, 2002 - * Fix two problems that showed up with the python 2.2.1 tests; one - * involving %o and one involving %f. - * - * Oct 28, 2002 - * Fix a problem in vasprintf (reported by vodz a while back) when built - * without custom stream support. In that case, it is necessary to do - * a va_copy. - * Make sure each va_copy has a matching va_end, as required by C99. - * - * Nov 4, 2002 - * Add locale-specific grouping support for integer decimal conversion. - * Add locale-specific decimal point support for floating point conversion. - * Note: grouping will have to wait for _dtostr() rewrite. - * Add printf wchar support for %lc (%C) and %ls (%S). - * Require printf format strings to be valid multibyte strings beginning and - * ending in their initial shift state, as per the stds. - * - * Nov 21, 2002 - * Add *wprintf functions. Currently they don't support floating point - * conversions. That will wait until the rewrite of _dtostr. - * - * Aug 1, 2003 - * Optional hexadecimal float notation support for %a/%A. - * Floating point output now works for *wprintf. - * Support for glibc locale-specific digit grouping for floats. - * Misc bug fixes. - * - * Aug 31, 2003 - * Fix precision bug for %g conversion specifier when using %f style. - * - * Sep 5, 2003 - * Implement *s*scanf for the non-buffered stdio case with old_vfprintf. - * - * Sep 23, 2003 - * vfprintf was not always checking for narrow stream orientation. - */ - -/* TODO: - * - * Should we validate that *printf format strings are valid multibyte - * strings in the current locale? ANSI/ISO C99 seems to imply this - * and Plauger's printf implementation in his Standard C Library book - * treats this as an error. - */ - -#define strnlen __strnlen -#define wcslen __wcslen -#define wcsnlen __wcsnlen -#define wcsrtombs __wcsrtombs -#define mbsrtowcs __mbsrtowcs -#define btowc __btowc -#define wcrtomb __wcrtomb -#define fputws __fputws - -#define _ISOC99_SOURCE /* for ULLONG primarily... */ -#define _GNU_SOURCE -#include <features.h> -#include "_stdio.h" -#include <stdlib.h> -#include <string.h> -#include <stddef.h> -#include <ctype.h> -#include <limits.h> -#include <stdarg.h> -#include <assert.h> -#include <stdint.h> -#include <errno.h> -#include <locale.h> - -#define __PRINTF_INFO_NO_BITFIELD -#include <printf.h> - -#ifdef __UCLIBC_HAS_THREADS__ -#include <stdio_ext.h> -#include <pthread.h> -#endif /* __UCLIBC_HAS_THREADS__ */ - -#ifdef __UCLIBC_HAS_WCHAR__ -#include <wchar.h> -#endif /* __UCLIBC_HAS_WCHAR__ */ - -#include <bits/uClibc_uintmaxtostr.h> -#include <bits/uClibc_va_copy.h> - -/* Some older or broken gcc toolchains define LONG_LONG_MAX but not - * LLONG_MAX. Since LLONG_MAX is part of the standard, that's what - * we use. So complain if we do not have it but should. - */ -#if !defined(LLONG_MAX) && defined(LONG_LONG_MAX) -#error Apparently, LONG_LONG_MAX is defined but LLONG_MAX is not. You need to fix your toolchain headers to support the standard macros for (unsigned) long long. -#endif - -/**********************************************************************/ -/* These provide some control over printf's feature set */ - -/* This is undefined below depeding on uClibc's configuration. */ -#define __STDIO_PRINTF_FLOAT 1 - -/* Now controlled by uClibc_stdio.h. */ -/* #define __UCLIBC_HAS_PRINTF_M_SPEC__ */ - - -/**********************************************************************/ - -#if defined(__UCLIBC__) && !defined(__UCLIBC_HAS_FLOATS__) -#undef __STDIO_PRINTF_FLOAT -#endif - -#ifdef __BCC__ -#undef __STDIO_PRINTF_FLOAT -#endif - -#ifdef __STDIO_PRINTF_FLOAT -#include <float.h> -#include <bits/uClibc_fpmax.h> -#else /* __STDIO_PRINTF_FLOAT */ -#undef L__fpmaxtostr -#endif /* __STDIO_PRINTF_FLOAT */ - - -#undef __STDIO_HAS_VSNPRINTF -#if defined(__STDIO_BUFFERS) || defined(__USE_OLD_VFPRINTF__) || defined(__UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__) -#define __STDIO_HAS_VSNPRINTF 1 -#endif - -/**********************************************************************/ - -/* Now controlled by uClibc_stdio.h. */ -/* #define __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ */ - -/* TODO -- move these to a configuration section? */ -#define MAX_FIELD_WIDTH 4095 - -#ifdef __UCLIBC_MJN3_ONLY__ -#ifdef L_register_printf_function -/* emit only once */ -#warning WISHLIST: Make MAX_USER_SPEC configurable? -#warning WISHLIST: Make MAX_ARGS_PER_SPEC configurable? -#endif -#endif /* __UCLIBC_MJN3_ONLY__ */ - -#ifdef __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ - -#define MAX_USER_SPEC 10 -#define MAX_ARGS_PER_SPEC 5 - -#else /* __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ */ - -#undef MAX_USER_SPEC -#define MAX_ARGS_PER_SPEC 1 - -#endif /* __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ */ - -#if MAX_ARGS_PER_SPEC < 1 -#error MAX_ARGS_PER_SPEC < 1! -#undef MAX_ARGS_PER_SPEC -#define MAX_ARGS_PER_SPEC 1 -#endif - -#if defined(NL_ARGMAX) && (NL_ARGMAX < 9) -#error NL_ARGMAX < 9! -#endif - -#if defined(NL_ARGMAX) && (NL_ARGMAX >= (MAX_ARGS_PER_SPEC + 2)) -#define MAX_ARGS NL_ARGMAX -#else -/* N for spec itself, plus 1 each for width and precision */ -#define MAX_ARGS (MAX_ARGS_PER_SPEC + 2) -#endif - -/**********************************************************************/ - -#define __PA_FLAG_INTMASK \ - (__PA_FLAG_CHAR|PA_FLAG_SHORT|__PA_FLAG_INT|PA_FLAG_LONG|PA_FLAG_LONG_LONG) - -#ifdef __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ -extern printf_function _custom_printf_handler[MAX_USER_SPEC]; -extern printf_arginfo_function *_custom_printf_arginfo[MAX_USER_SPEC]; -extern char *_custom_printf_spec; -#endif /* __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ */ - -/**********************************************************************/ - -#define SPEC_FLAGS " +0-#'I" -enum { - FLAG_SPACE = 0x01, - FLAG_PLUS = 0x02, /* must be 2 * FLAG_SPACE */ - FLAG_ZERO = 0x04, - FLAG_MINUS = 0x08, /* must be 2 * FLAG_ZERO */ - FLAG_HASH = 0x10, - FLAG_THOUSANDS = 0x20, - FLAG_I18N = 0x40, /* only works for d, i, u */ - FLAG_WIDESTREAM = 0x80 -}; - -/**********************************************************************/ - -/* float layout 01234567890123456789 TODO: B?*/ -#define SPEC_CHARS "npxXoudifFeEgGaACScs" -enum { - CONV_n = 0, - CONV_p, - CONV_x, CONV_X, CONV_o, CONV_u, CONV_d, CONV_i, - CONV_f, CONV_F, CONV_e, CONV_E, CONV_g, CONV_G, CONV_a, CONV_A, - CONV_C, CONV_S, CONV_c, CONV_s, -#ifdef __UCLIBC_HAS_PRINTF_M_SPEC__ - CONV_m, -#endif - CONV_custom0 /* must be last */ -}; - -/* p x X o u d i */ -#define SPEC_BASE { 16, 16, 16, 8, 10, 10, 10 } - -#define SPEC_RANGES { CONV_n, CONV_p, CONV_i, CONV_A, \ - CONV_C, CONV_S, CONV_c, CONV_s, CONV_custom0 } - -#define SPEC_OR_MASK { \ - /* n */ (PA_FLAG_PTR|PA_INT), \ - /* p */ PA_POINTER, \ - /* oxXudi */ PA_INT, \ - /* fFeEgGaA */ PA_DOUBLE, \ - /* C */ PA_WCHAR, \ - /* S */ PA_WSTRING, \ - /* c */ PA_CHAR, \ - /* s */ PA_STRING, \ -} - -#define SPEC_AND_MASK { \ - /* n */ (PA_FLAG_PTR|__PA_INTMASK), \ - /* p */ PA_POINTER, \ - /* oxXudi */ (__PA_INTMASK), \ - /* fFeEgGaA */ (PA_FLAG_LONG_DOUBLE|PA_DOUBLE), \ - /* C */ (PA_WCHAR), \ - /* S */ (PA_WSTRING), \ - /* c */ (PA_CHAR), \ - /* s */ (PA_STRING), \ -} - -/**********************************************************************/ -/* - * In order to ease translation to what arginfo and _print_info._flags expect, - * we map: 0:int 1:char 2:longlong 4:long 8:short - * and then _flags |= (((q << 7) + q) & 0x701) and argtype |= (_flags & 0x701) - */ - -/* TODO -- Fix the table below to take into account stdint.h. */ -/* #ifndef LLONG_MAX */ -/* #error fix QUAL_CHARS for no long long! Affects 'L', 'j', 'q', 'll'. */ -/* #else */ -/* #if LLONG_MAX != INTMAX_MAX */ -/* #error fix QUAL_CHARS intmax_t entry 'j'! */ -/* #endif */ -/* #endif */ - -#ifdef PDS -#error PDS already defined! -#endif -#ifdef SS -#error SS already defined! -#endif -#ifdef IMS -#error IMS already defined! -#endif - -#if PTRDIFF_MAX == INT_MAX -#define PDS 0 -#elif PTRDIFF_MAX == LONG_MAX -#define PDS 4 -#elif defined(LLONG_MAX) && (PTRDIFF_MAX == LLONG_MAX) -#define PDS 8 -#else -#error fix QUAL_CHARS ptrdiff_t entry 't'! -#endif - -#if SIZE_MAX == UINT_MAX -#define SS 0 -#elif SIZE_MAX == ULONG_MAX -#define SS 4 -#elif defined(LLONG_MAX) && (SIZE_MAX == ULLONG_MAX) -#define SS 8 -#else -#error fix QUAL_CHARS size_t entries 'z', 'Z'! -#endif - -#if INTMAX_MAX == INT_MAX -#define IMS 0 -#elif INTMAX_MAX == LONG_MAX -#define IMS 4 -#elif defined(LLONG_MAX) && (INTMAX_MAX == LLONG_MAX) -#define IMS 8 -#else -#error fix QUAL_CHARS intmax_t entry 'j'! -#endif - -#define QUAL_CHARS { \ - /* j:(u)intmax_t z:(s)size_t t:ptrdiff_t \0:int */ \ - /* q:long_long Z:(s)size_t */ \ - 'h', 'l', 'L', 'j', 'z', 't', 'q', 'Z', 0, \ - 2, 4, 8, IMS, SS, PDS, 8, SS, 0, /* TODO -- fix!!! */\ - 1, 8 \ -} - -/**********************************************************************/ - -#ifdef __STDIO_VA_ARG_PTR -#ifdef __BCC__ -#define __va_arg_ptr(ap,type) (((type *)(ap += sizeof(type))) - 1) -#endif - -#if 1 -#ifdef __GNUC__ -/* TODO -- need other than for 386 as well! */ - -#ifndef __va_rounded_size -#define __va_rounded_size(TYPE) \ - (((sizeof (TYPE) + sizeof (int) - 1) / sizeof (int)) * sizeof (int)) -#endif -#define __va_arg_ptr(AP, TYPE) \ - (AP = (va_list) ((char *) (AP) + __va_rounded_size (TYPE)), \ - ((void *) ((char *) (AP) - __va_rounded_size (TYPE)))) -#endif -#endif -#endif /* __STDIO_VA_ARG_PTR */ - -#ifdef __va_arg_ptr -#define GET_VA_ARG(AP,F,TYPE,ARGS) (*(AP) = __va_arg_ptr(ARGS,TYPE)) -#define GET_ARG_VALUE(AP,F,TYPE) (*((TYPE *)(*(AP)))) -#else -typedef union { - wchar_t wc; - unsigned int u; - unsigned long ul; -#ifdef ULLONG_MAX - unsigned long long ull; -#endif -#ifdef __STDIO_PRINTF_FLOAT - double d; - long double ld; -#endif /* __STDIO_PRINTF_FLOAT */ - void *p; -} argvalue_t; - -#define GET_VA_ARG(AU,F,TYPE,ARGS) (AU->F = va_arg(ARGS,TYPE)) -#define GET_ARG_VALUE(AU,F,TYPE) ((TYPE)((AU)->F)) -#endif - -typedef struct { - const char *fmtpos; /* TODO: move below struct?? */ - struct printf_info info; -#ifdef NL_ARGMAX - int maxposarg; /* > 0 if args are positional, 0 if not, -1 if unknown */ -#endif /* NL_ARGMAX */ - int num_data_args; /* TODO: use sentinal??? */ - unsigned int conv_num; - unsigned char argnumber[4]; /* width | prec | 1st data | unused */ - int argtype[MAX_ARGS]; - va_list arg; -#ifdef __va_arg_ptr - void *argptr[MAX_ARGS]; -#else -/* if defined(NL_ARGMAX) || defined(__UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__) */ - /* While this is wasteful of space in the case where pos args aren't - * enabled, it is also needed to support custom printf handlers. */ - argvalue_t argvalue[MAX_ARGS]; -#endif -} ppfs_t; /* parse printf format state */ - -/**********************************************************************/ - -/* TODO: fix printf to return 0 and set errno if format error. Standard says - only returns -1 if sets error indicator for the stream. */ - -#ifdef __STDIO_PRINTF_FLOAT -typedef size_t (__fp_outfunc_t)(FILE *fp, intptr_t type, intptr_t len, - intptr_t buf); - -extern ssize_t _fpmaxtostr(FILE * fp, __fpmax_t x, struct printf_info *info, - __fp_outfunc_t fp_outfunc) attribute_hidden; -#endif - -extern int _ppfs_init(ppfs_t *ppfs, const char *fmt0) attribute_hidden; /* validates */ -extern void _ppfs_prepargs(ppfs_t *ppfs, va_list arg) attribute_hidden; /* sets posargptrs */ -extern void _ppfs_setargs(ppfs_t *ppfs) attribute_hidden; /* sets argptrs for current spec */ -extern int _ppfs_parsespec(ppfs_t *ppfs) attribute_hidden; /* parses specifier */ - -extern void _store_inttype(void *dest, int desttype, uintmax_t val) attribute_hidden; -extern uintmax_t _load_inttype(int desttype, const void *src, int uflag) attribute_hidden; - -/**********************************************************************/ -#ifdef L_parse_printf_format - -/* NOTE: This function differs from the glibc version in that parsing stops - * upon encountering an invalid conversion specifier. Since this is the way - * my printf functions work, I think it makes sense to do it that way here. - * Unfortunately, since glibc sets the return type as size_t, we have no way - * of returning that the template is illegal, other than returning 0. - */ - -size_t parse_printf_format(register const char *template, - size_t n, register int *argtypes) -{ - ppfs_t ppfs; - size_t i; - size_t count = 0; - - if (_ppfs_init(&ppfs, template) >= 0) { -#ifdef NL_ARGMAX - if (ppfs.maxposarg > 0) { /* Using positional args. */ - count = ppfs.maxposarg; - if (n > count) { - n = count; - } - for (i = 0 ; i < n ; i++) { - *argtypes++ = ppfs.argtype[i]; - } - } else { /* Not using positional args. */ -#endif /* NL_ARGMAX */ - while (*template) { - if ((*template == '%') && (*++template != '%')) { - ppfs.fmtpos = template; - _ppfs_parsespec(&ppfs); /* Can't fail. */ - template = ppfs.fmtpos; /* Update to one past spec end. */ - if (ppfs.info.width == INT_MIN) { - ++count; - if (n > 0) { - *argtypes++ = PA_INT; - --n; - } - } - if (ppfs.info.prec == INT_MIN) { - ++count; - if (n > 0) { - *argtypes++ = PA_INT; - --n; - } - } - for (i = 0 ; i < ppfs.num_data_args ; i++) { - if ((ppfs.argtype[i]) != __PA_NOARG) { - ++count; - if (n > 0) { - *argtypes++ = ppfs.argtype[i]; - --n; - } - } - } - } else { - ++template; - } - } -#ifdef NL_ARGMAX - } -#endif /* NL_ARGMAX */ - } - - return count; -} - -#endif -/**********************************************************************/ -#ifdef L__ppfs_init - -int attribute_hidden _ppfs_init(register ppfs_t *ppfs, const char *fmt0) -{ - int r; - - /* First, zero out everything... argnumber[], argtype[], argptr[] */ - __memset(ppfs, 0, sizeof(ppfs_t)); /* TODO: nonportable???? */ -#ifdef NL_ARGMAX - --ppfs->maxposarg; /* set to -1 */ -#endif /* NL_ARGMAX */ - ppfs->fmtpos = fmt0; -#ifdef __UCLIBC_MJN3_ONLY__ -#warning TODO: Make checking of the format string in C locale an option. -#endif -#ifdef __UCLIBC_HAS_LOCALE__ - /* To support old programs, don't check mb validity if in C locale. */ - if (((__UCLIBC_CURLOCALE_DATA).encoding) != __ctype_encoding_7_bit) { - /* ANSI/ISO C99 requires format string to be a valid multibyte string - * beginning and ending in its initial shift state. */ - static const char invalid_mbs[] = "Invalid multibyte format string."; - mbstate_t mbstate; - const char *p; - mbstate.__mask = 0; /* Initialize the mbstate. */ - p = fmt0; - if (mbsrtowcs(NULL, &p, SIZE_MAX, &mbstate) == ((size_t)(-1))) { - ppfs->fmtpos = invalid_mbs; - return -1; - } - } -#endif /* __UCLIBC_HAS_LOCALE__ */ - /* now set all argtypes to no-arg */ - { -#if 1 - /* TODO - use memset here since already "paid for"? */ - register int *p = ppfs->argtype; - - r = MAX_ARGS; - do { - *p++ = __PA_NOARG; - } while (--r); -#else - /* TODO -- get rid of this?? */ - register char *p = (char *) ((MAX_ARGS-1) * sizeof(int)); - - do { - *((int *)(((char *)ppfs) + ((int)p) + offsetof(ppfs_t,argtype))) = __PA_NOARG; - p -= sizeof(int); - } while (p); -#endif - } - - /* - * Run through the entire format string to validate it and initialize - * the positional arg numbers (if any). - */ - { - register const char *fmt = fmt0; - - while (*fmt) { - if ((*fmt == '%') && (*++fmt != '%')) { - ppfs->fmtpos = fmt; /* back up to the '%' */ - if ((r = _ppfs_parsespec(ppfs)) < 0) { - return -1; - } - fmt = ppfs->fmtpos; /* update to one past end of spec */ - } else { - ++fmt; - } - } - ppfs->fmtpos = fmt0; /* rewind */ - } - -#ifdef NL_MAX_ARG - /* If we have positional args, make sure we know all the types. */ - { - register int *p = ppfs->argtype; - r = ppfs->maxposarg; - while (--r >= 0) { - if ( *p == __PA_NOARG ) { /* missing arg type!!! */ - return -1; - } - ++p; - } - } -#endif /* NL_MAX_ARG */ - - return 0; -} -#endif -/**********************************************************************/ -#ifdef L__ppfs_prepargs -void attribute_hidden _ppfs_prepargs(register ppfs_t *ppfs, va_list arg) -{ - int i; - - va_copy(ppfs->arg, arg); - -#ifdef NL_ARGMAX - if ((i = ppfs->maxposarg) > 0) { /* init for positional args */ - ppfs->num_data_args = i; - ppfs->info.width = ppfs->info.prec = ppfs->maxposarg = 0; - _ppfs_setargs(ppfs); - ppfs->maxposarg = i; - } -#endif /* NL_ARGMAX */ -} -#endif -/**********************************************************************/ -#ifdef L__ppfs_setargs - -void attribute_hidden _ppfs_setargs(register ppfs_t *ppfs) -{ -#ifdef __va_arg_ptr - register void **p = ppfs->argptr; -#else - register argvalue_t *p = ppfs->argvalue; -#endif - int i; - -#ifdef NL_ARGMAX - if (ppfs->maxposarg == 0) { /* initing for or no pos args */ -#endif /* NL_ARGMAX */ - if (ppfs->info.width == INT_MIN) { - ppfs->info.width = -#ifdef __va_arg_ptr - *(int *) -#endif - GET_VA_ARG(p,u,unsigned int,ppfs->arg); - } - if (ppfs->info.prec == INT_MIN) { - ppfs->info.prec = -#ifdef __va_arg_ptr - *(int *) -#endif - GET_VA_ARG(p,u,unsigned int,ppfs->arg); - } - i = 0; - while (i < ppfs->num_data_args) { - switch(ppfs->argtype[i++]) { - case (PA_INT|PA_FLAG_LONG_LONG): -#ifdef ULLONG_MAX - GET_VA_ARG(p,ull,unsigned long long,ppfs->arg); - break; -#endif - case (PA_INT|PA_FLAG_LONG): -#if ULONG_MAX != UINT_MAX - GET_VA_ARG(p,ul,unsigned long,ppfs->arg); - break; -#endif - case PA_CHAR: /* TODO - be careful */ - /* ... users could use above and really want below!! */ - case (PA_INT|__PA_FLAG_CHAR):/* TODO -- translate this!!! */ - case (PA_INT|PA_FLAG_SHORT): - case PA_INT: - GET_VA_ARG(p,u,unsigned int,ppfs->arg); - break; - case PA_WCHAR: /* TODO -- assume int? */ - /* we're assuming wchar_t is at least an int */ - GET_VA_ARG(p,wc,wchar_t,ppfs->arg); - break; -#ifdef __STDIO_PRINTF_FLOAT - /* PA_FLOAT */ - case PA_DOUBLE: - GET_VA_ARG(p,d,double,ppfs->arg); - break; - case (PA_DOUBLE|PA_FLAG_LONG_DOUBLE): - GET_VA_ARG(p,ld,long double,ppfs->arg); - break; -#else /* __STDIO_PRINTF_FLOAT */ - case PA_DOUBLE: - case (PA_DOUBLE|PA_FLAG_LONG_DOUBLE): - assert(0); - continue; -#endif /* __STDIO_PRINTF_FLOAT */ - default: - /* TODO -- really need to ensure this can't happen */ - assert(ppfs->argtype[i-1] & PA_FLAG_PTR); - case PA_POINTER: - case PA_STRING: - case PA_WSTRING: - GET_VA_ARG(p,p,void *,ppfs->arg); - break; - case __PA_NOARG: - continue; - } - ++p; - } -#ifdef NL_ARGMAX - } else { - if (ppfs->info.width == INT_MIN) { - ppfs->info.width - = (int) GET_ARG_VALUE(p + ppfs->argnumber[0] - 1,u,unsigned int); - } - if (ppfs->info.prec == INT_MIN) { - ppfs->info.prec - = (int) GET_ARG_VALUE(p + ppfs->argnumber[1] - 1,u,unsigned int); - } - } -#endif /* NL_ARGMAX */ - - /* Now we know the width and precision. */ - if (ppfs->info.width < 0) { - ppfs->info.width = -ppfs->info.width; - PRINT_INFO_SET_FLAG(&(ppfs->info),left); - PRINT_INFO_CLR_FLAG(&(ppfs->info),space); - ppfs->info.pad = ' '; - } -#if 0 - /* NOTE -- keep neg for now so float knows! */ - if (ppfs->info.prec < 0) { /* spec says treat as omitted. */ - /* so use default prec... 1 for everything but floats and strings. */ - ppfs->info.prec = 1; - } -#endif -} -#endif -/**********************************************************************/ -#ifdef L__ppfs_parsespec - -/* Notes: argtype differs from glibc for the following: - * mine glibc - * lc PA_WCHAR PA_CHAR the standard says %lc means %C - * ls PA_WSTRING PA_STRING the standard says %ls means %S - * {*}n {*}|PA_FLAG_PTR PA_FLAG_PTR size of n can be qualified + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. */ - -/* TODO: store positions of positional args */ - -/* TODO -- WARNING -- assumes aligned on integer boundaries!!! */ - -/* TODO -- disable if not using positional args!!! */ -#define _OVERLAPPING_DIFFERENT_ARGS - -/* TODO -- rethink this -- perhaps we should set to largest type??? */ - -#ifdef _OVERLAPPING_DIFFERENT_ARGS - -#define PROMOTED_SIZE_OF(X) ((sizeof(X) + sizeof(int) - 1) / sizeof(X)) - -static const short int type_codes[] = { - __PA_NOARG, /* must be first entry */ - PA_POINTER, - PA_STRING, - PA_WSTRING, - PA_CHAR, - PA_INT|PA_FLAG_SHORT, - PA_INT, - PA_INT|PA_FLAG_LONG, - PA_INT|PA_FLAG_LONG_LONG, - PA_WCHAR, -#ifdef __STDIO_PRINTF_FLOAT - /* PA_FLOAT, */ - PA_DOUBLE, - PA_DOUBLE|PA_FLAG_LONG_DOUBLE, -#endif /* __STDIO_PRINTF_FLOAT */ -}; - -static const unsigned char type_sizes[] = { - /* unknown type consumes no arg */ - 0, /* must be first entry */ - PROMOTED_SIZE_OF(void *), - PROMOTED_SIZE_OF(char *), - PROMOTED_SIZE_OF(wchar_t *), - PROMOTED_SIZE_OF(char), - PROMOTED_SIZE_OF(short), - PROMOTED_SIZE_OF(int), - PROMOTED_SIZE_OF(long), -#ifdef ULLONG_MAX - PROMOTED_SIZE_OF(long long), -#else - PROMOTED_SIZE_OF(long), /* TODO -- is this correct? (above too) */ -#endif - PROMOTED_SIZE_OF(wchar_t), -#ifdef __STDIO_PRINTF_FLOAT - /* PROMOTED_SIZE_OF(float), */ - PROMOTED_SIZE_OF(double), - PROMOTED_SIZE_OF(long double), -#endif /* __STDIO_PRINTF_FLOAT */ -}; - -static int _promoted_size(int argtype) -{ - register const short int *p; - - /* note -- since any unrecognized type is treated as a pointer */ - p = type_codes + sizeof(type_codes)/sizeof(type_codes[0]); - do { - if (*--p == argtype) { - break; - } - } while (p > type_codes); - - return type_sizes[(int)(p - type_codes)]; -} - -static int _is_equal_or_bigger_arg(int curtype, int newtype) -{ - /* Quick test */ - if (newtype == __PA_NOARG) { - return 0; - } - if ((curtype == __PA_NOARG) || (curtype == newtype)) { - return 1; - } - /* Ok... slot is already filled and types are different in name. */ - /* So, compare promoted sizes of curtype and newtype args. */ - return _promoted_size(curtype) <= _promoted_size(newtype); -} - -#else - -#define _is_equal_or_bigger_arg(C,N) (((C) == __PA_NOARG) || ((C) == (N))) - -#endif - -#ifdef __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ -/* TODO - do this differently? */ -static char _bss_custom_printf_spec[MAX_USER_SPEC]; /* 0-init'd for us. */ - -char *_custom_printf_spec = _bss_custom_printf_spec; -printf_arginfo_function *_custom_printf_arginfo[MAX_USER_SPEC]; -printf_function _custom_printf_handler[MAX_USER_SPEC]; -#endif /* __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ */ - -int attribute_hidden _ppfs_parsespec(ppfs_t *ppfs) -{ - register const char *fmt; - register const char *p; - int preci; - int width; - int flags; - int dataargtype; - int i; - int dpoint; -#ifdef NL_ARGMAX - int maxposarg; -#endif /* NL_ARGMAX */ - int p_m_spec_chars; - int n; - int argtype[MAX_ARGS_PER_SPEC+2]; - int argnumber[3]; /* width, precision, 1st data arg */ - static const char spec_flags[] = SPEC_FLAGS; - static const char spec_chars[] = SPEC_CHARS;/* TODO: b? */ - static const char spec_ranges[] = SPEC_RANGES; - static const short spec_or_mask[] = SPEC_OR_MASK; - static const short spec_and_mask[] = SPEC_AND_MASK; - static const char qual_chars[] = QUAL_CHARS; -#ifdef __UCLIBC_HAS_WCHAR__ - char buf[32]; -#endif /* __UCLIBC_HAS_WCHAR__ */ - - /* WIDE note: we can test against '%' here since we don't allow */ - /* WIDE note: other mappings of '%' in the wide char set. */ - preci = -1; - argnumber[0] = 0; - argnumber[1] = 0; - argtype[0] = __PA_NOARG; - argtype[1] = __PA_NOARG; -#ifdef NL_ARGMAX - maxposarg = ppfs->maxposarg; -#endif /* NL_ARGMAX */ - -#ifdef __UCLIBC_HAS_WCHAR__ - /* This is somewhat lame, but saves a lot of code. If we're dealing with - * a wide stream, that means the format is a wchar string. So, copy it - * char-by-char into a normal char buffer for processing. Make the buffer - * (buf) big enough so that any reasonable format specifier will fit. - * While there a legal specifiers that won't, the all involve duplicate - * flags or outrageous field widths/precisions. */ - width = dpoint = 0; - if ((flags = ppfs->info._flags & FLAG_WIDESTREAM) == 0) { - fmt = ppfs->fmtpos; - } else { - fmt = buf + 1; - i = 0; - do { - if ((buf[i] = (char) (((wchar_t *) ppfs->fmtpos)[i-1])) - != (((wchar_t *) ppfs->fmtpos)[i-1]) - ) { - return -1; - } - } while (buf[i++]); - buf[sizeof(buf)-1] = 0; - } -#else /* __UCLIBC_HAS_WCHAR__ */ - width = flags = dpoint = 0; - fmt = ppfs->fmtpos; -#endif /* __UCLIBC_HAS_WCHAR__ */ - - assert(fmt[-1] == '%'); - assert(fmt[0] != '%'); - - /* Process arg pos and/or flags and/or width and/or precision. */ - width_precision: - p = fmt; - if (*fmt == '*') { - argtype[-dpoint] = PA_INT; - ++fmt; - } - i = 0; - while (isdigit(*fmt)) { - if (i < MAX_FIELD_WIDTH) { /* Avoid overflow. */ - i = (i * 10) + (*fmt - '0'); - } - ++fmt; - } - if (p[-1] == '%') { /* Check for a position. */ - - /* TODO: if val not in range, then error */ - -#ifdef NL_ARGMAX - if ((*fmt == '$') && (i > 0)) {/* Positional spec. */ - ++fmt; - if (maxposarg == 0) { - return -1; - } - if ((argnumber[2] = i) > maxposarg) { - maxposarg = i; - } - /* Now fall through to check flags. */ - } else { - if (maxposarg > 0) { -#ifdef __UCLIBC_HAS_PRINTF_M_SPEC__ -#ifdef __UCLIBC_MJN3_ONLY__ -#warning TODO: Support prec and width for %m when positional args used - /* Actually, positional arg processing will fail in general - * for specifiers that don't require an arg. */ -#endif /* __UCLIBC_MJN3_ONLY__ */ - if (*fmt == 'm') { - goto PREC_WIDTH; - } -#endif /* __UCLIBC_HAS_PRINTF_M_SPEC__ */ - return -1; - } - maxposarg = 0; /* Possible redundant store, but cuts size. */ - - if ((fmt > p) && (*p != '0')) { - goto PREC_WIDTH; - } - - fmt = p; /* Back up for possible '0's flag. */ - /* Now fall through to check flags. */ - } -#else /* NL_ARGMAX */ - if (*fmt == '$') { /* Positional spec. */ - return -1; - } - - if ((fmt > p) && (*p != '0')) { - goto PREC_WIDTH; - } - - fmt = p; /* Back up for possible '0's flag. */ - /* Now fall through to check flags. */ -#endif /* NL_ARGMAX */ - - restart_flags: /* Process flags. */ - i = 1; - p = spec_flags; - - do { - if (*fmt == *p++) { - ++fmt; - flags |= i; - goto restart_flags; - } - i += i; /* Better than i <<= 1 for bcc */ - } while (*p); - i = 0; - - /* If '+' then ignore ' ', and if '-' then ignore '0'. */ - /* Note: Need to ignore '0' when prec is an arg with val < 0, */ - /* but that test needs to wait until the arg is retrieved. */ - flags &= ~((flags & (FLAG_PLUS|FLAG_MINUS)) >> 1); - /* Note: Ignore '0' when prec is specified < 0 too (in printf). */ - - if (fmt[-1] != '%') { /* If we've done anything, loop for width. */ - goto width_precision; - } - } - PREC_WIDTH: - if (*p == '*') { /* Prec or width takes an arg. */ -#ifdef NL_ARGMAX - if (maxposarg) { - if ((*fmt++ != '$') || (i <= 0)) { - /* Using pos args and no $ or invalid arg number. */ - return -1; - } - argnumber[-dpoint] = i; - } else -#endif /* NL_ARGMAX */ - if (++p != fmt) { - /* Not using pos args but digits followed *. */ - return -1; - } - i = INT_MIN; - } - - if (!dpoint) { - width = i; - if (*fmt == '.') { - ++fmt; - dpoint = -1; /* To use as default precison. */ - goto width_precision; - } - } else { - preci = i; - } - - /* Process qualifier. */ - p = qual_chars; - do { - if (*fmt == *p) { - ++fmt; - break; - } - } while (*++p); - if ((p - qual_chars < 2) && (*fmt == *p)) { - p += ((sizeof(qual_chars)-2) / 2); - ++fmt; - } - dataargtype = ((int)(p[(sizeof(qual_chars)-2) / 2])) << 8; - - /* Process conversion specifier. */ - if (!*fmt) { - return -1; - } - - p = spec_chars; - - do { - if (*fmt == *p) { - p_m_spec_chars = p - spec_chars; - - if ((p_m_spec_chars >= CONV_c) - && (dataargtype & PA_FLAG_LONG)) { - p_m_spec_chars -= 2; /* lc -> C and ls -> S */ - } - - ppfs->conv_num = p_m_spec_chars; - p = spec_ranges-1; - while (p_m_spec_chars > *++p) {} - - i = p - spec_ranges; - argtype[2] = (dataargtype | spec_or_mask[i]) & spec_and_mask[i]; - p = spec_chars; - break; - } - } while(*++p); - - ppfs->info.spec = *fmt; - ppfs->info.prec = preci; - ppfs->info.width = width; - ppfs->info.pad = ((flags & FLAG_ZERO) ? '0' : ' '); - ppfs->info._flags = (flags & ~FLAG_ZERO) | (dataargtype & __PA_INTMASK); - ppfs->num_data_args = 1; - - if (!*p) { -#ifdef __UCLIBC_HAS_PRINTF_M_SPEC__ - if (*fmt == 'm') { - ppfs->conv_num = CONV_m; - ppfs->num_data_args = 0; - goto DONE; - } -#endif -#ifdef __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ - - /* Handle custom arg -- WARNING -- overwrites p!!! */ - ppfs->conv_num = CONV_custom0; - p = _custom_printf_spec; - do { - if (*p == *fmt) { - if ((ppfs->num_data_args - = ((*_custom_printf_arginfo[(int)(p-_custom_printf_spec)]) - (&(ppfs->info), MAX_ARGS_PER_SPEC, argtype+2))) - > MAX_ARGS_PER_SPEC) { - break; /* Error -- too many args! */ - } - goto DONE; - } - } while (++p < (_custom_printf_spec + MAX_USER_SPEC)); -#endif /* __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ */ - /* Otherwise error. */ - return -1; - } - -#if defined(__UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__) || defined(__UCLIBC_HAS_PRINTF_M_SPEC__) - DONE: -#endif - -#ifdef NL_ARGMAX - if (maxposarg > 0) { - i = 0; - do { - /* Update maxposarg and check that NL_ARGMAX is not exceeded. */ - n = ((i <= 2) - ? (ppfs->argnumber[i] = argnumber[i]) - : argnumber[2] + (i-2)); - if (n > maxposarg) { - if ((maxposarg = n) > NL_ARGMAX) { - return -1; - } - } - --n; - /* Record argtype with largest size (current, new). */ - if (_is_equal_or_bigger_arg(ppfs->argtype[n], argtype[i])) { - ppfs->argtype[n] = argtype[i]; - } - } while (++i < ppfs->num_data_args + 2); - } else { -#endif /* NL_ARGMAX */ - ppfs->argnumber[2] = 1; - __memcpy(ppfs->argtype, argtype + 2, ppfs->num_data_args * sizeof(int)); -#ifdef NL_ARGMAX - } - - ppfs->maxposarg = maxposarg; -#endif /* NL_ARGMAX */ - -#ifdef __UCLIBC_HAS_WCHAR__ - if ((flags = ppfs->info._flags & FLAG_WIDESTREAM) == 0) { - ppfs->fmtpos = ++fmt; - } else { - ppfs->fmtpos = (const char *) (((const wchar_t *)(ppfs->fmtpos)) - + (fmt - buf) ); - } -#else /* __UCLIBC_HAS_WCHAR__ */ - ppfs->fmtpos = ++fmt; -#endif /* __UCLIBC_HAS_WCHAR__ */ - - return ppfs->num_data_args + 2; -} - -#endif -/**********************************************************************/ -#ifdef L_register_printf_function - -#ifdef __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ - -int register_printf_function(int spec, printf_function handler, - printf_arginfo_function arginfo) -{ - register char *r; - register char *p; - - if (spec && (arginfo != NULL)) { /* TODO -- check if spec is valid char */ - r = NULL; - p = _custom_printf_spec + MAX_USER_SPEC; - do { - --p; - if (!*p) { - r = p; - } -#ifdef __BCC__ - else /* bcc generates less code with fall-through */ -#endif - if (*p == spec) { - r = p; - p = _custom_printf_spec; - } - } while (p > _custom_printf_spec); - - if (r) { - if (handler) { - *r = spec; - _custom_printf_handler[(int)(r - p)] = handler; - _custom_printf_arginfo[(int)(r - p)] = arginfo; - } else { - *r = 0; - } - return 0; - } - /* TODO -- if asked to unregister a non-existent spec, return what? */ - } - return -1; -} - -#endif - -#endif -/**********************************************************************/ -#if defined(L_vfprintf) || defined(L_vfwprintf) - -/* We only support ascii digits (or their USC equivalent codes) in - * precision and width settings in *printf (wide) format strings. - * In other words, we don't currently support glibc's 'I' flag. - * We do accept it, but it is currently ignored. */ - -static size_t _charpad(FILE * __restrict stream, int padchar, size_t numpad); - -#ifdef L_vfprintf - -#define HIDDEN_VFPRINTF __vfprintf -#define VFPRINTF vfprintf -#define FMT_TYPE char -#define OUTNSTR _outnstr -#define STRLEN __strlen -#define _PPFS_init _ppfs_init -#define OUTPUT(F,S) __fputs_unlocked(S,F) -/* #define _outnstr(stream, string, len) __stdio_fwrite(string, len, stream) */ -#define _outnstr(stream, string, len) ((len > 0) ? __stdio_fwrite(string, len, stream) : 0) -#define FP_OUT _fp_out_narrow - -#ifdef __STDIO_PRINTF_FLOAT - -static size_t _fp_out_narrow(FILE *fp, intptr_t type, intptr_t len, intptr_t buf) -{ - size_t r = 0; - - if (type & 0x80) { /* Some type of padding needed. */ - int buflen = __strlen((const char *) buf); - if ((len -= buflen) > 0) { - if ((r = _charpad(fp, (type & 0x7f), len)) != len) { - return r; - } - } - len = buflen; - } - return r + OUTNSTR(fp, (const char *) buf, len); -} - -#endif /* __STDIO_PRINTF_FLOAT */ - -#else /* L_vfprintf */ - -#define HIDDEN_VFPRINTF __vfwprintf -#define VFPRINTF vfwprintf -#define FMT_TYPE wchar_t -#define OUTNSTR _outnwcs -#define STRLEN wcslen -#define _PPFS_init _ppwfs_init -#define OUTPUT(F,S) fputws(S,F) -#define _outnwcs(stream, wstring, len) _wstdio_fwrite(wstring, len, stream) -#define FP_OUT _fp_out_wide - -static size_t _outnstr(FILE *stream, const char *s, size_t wclen) -{ - /* NOTE!!! len here is the number of wchars we want to generate!!! */ - wchar_t wbuf[64]; - mbstate_t mbstate; - size_t todo, r, n; - - mbstate.__mask = 0; - todo = wclen; - - while (todo) { - r = mbsrtowcs(wbuf, &s, - ((todo <= sizeof(wbuf)/sizeof(wbuf[0])) - ? todo - : sizeof(wbuf)/sizeof(wbuf[0])), - &mbstate); - assert(((ssize_t)r) > 0); - n = _outnwcs(stream, wbuf, r); - todo -= n; - if (n != r) { - break; - } - } - - return wclen - todo; -} - -#ifdef __STDIO_PRINTF_FLOAT - -#ifdef __UCLIBC_MJN3_ONLY__ -#warning TODO: Move defines from _fpmaxtostr. Put them in a common header. -#endif - -/* The following defines are from _fpmaxtostr.*/ -#define DIGITS_PER_BLOCK 9 -#define NUM_DIGIT_BLOCKS ((DECIMAL_DIG+DIGITS_PER_BLOCK-1)/DIGITS_PER_BLOCK) -#define BUF_SIZE ( 3 + NUM_DIGIT_BLOCKS * DIGITS_PER_BLOCK ) - -static size_t _fp_out_wide(FILE *fp, intptr_t type, intptr_t len, intptr_t buf) -{ - wchar_t wbuf[BUF_SIZE]; - const char *s = (const char *) buf; - size_t r = 0; - int i; - - if (type & 0x80) { /* Some type of padding needed */ - int buflen = __strlen(s); - if ((len -= buflen) > 0) { - if ((r = _charpad(fp, (type & 0x7f), len)) != len) { - return r; - } - } - len = buflen; - } - - if (len > 0) { - i = 0; - do { -#ifdef __LOCALE_C_ONLY - wbuf[i] = s[i]; -#else /* __LOCALE_C_ONLY */ - -#ifdef __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ - if (s[i] == ',') { - wbuf[i] = __UCLIBC_CURLOCALE_DATA.thousands_sep_wc; - } else -#endif /* __UCLIBC_HAS_GLIBC_DIGIT_GROUPING__ */ - if (s[i] == '.') { - wbuf[i] = __UCLIBC_CURLOCALE_DATA.decimal_point_wc; - } else { - wbuf[i] = s[i]; - } -#endif /* __LOCALE_C_ONLY */ - - } while (++i < len); - - r += OUTNSTR(fp, wbuf, len); - } - - return r; -} - -#endif /* __STDIO_PRINTF_FLOAT */ - -static int _ppwfs_init(register ppfs_t *ppfs, const wchar_t *fmt0) -{ - static const wchar_t invalid_wcs[] = L"Invalid wide format string."; - int r; - - /* First, zero out everything... argnumber[], argtype[], argptr[] */ - __memset(ppfs, 0, sizeof(ppfs_t)); /* TODO: nonportable???? */ -#ifdef NL_ARGMAX - --ppfs->maxposarg; /* set to -1 */ -#endif /* NL_ARGMAX */ - ppfs->fmtpos = (const char *) fmt0; - ppfs->info._flags = FLAG_WIDESTREAM; - - { - mbstate_t mbstate; - const wchar_t *p; - mbstate.__mask = 0; /* Initialize the mbstate. */ - p = fmt0; - if (wcsrtombs(NULL, &p, SIZE_MAX, &mbstate) == ((size_t)(-1))) { - ppfs->fmtpos = (const char *) invalid_wcs; - return -1; - } - } - - /* now set all argtypes to no-arg */ - { -#if 1 - /* TODO - use memset here since already "paid for"? */ - register int *p = ppfs->argtype; - - r = MAX_ARGS; - do { - *p++ = __PA_NOARG; - } while (--r); -#else - /* TODO -- get rid of this?? */ - register char *p = (char *) ((MAX_ARGS-1) * sizeof(int)); - - do { - *((int *)(((char *)ppfs) + ((int)p) + offsetof(ppfs_t,argtype))) = __PA_NOARG; - p -= sizeof(int); - } while (p); -#endif - } - - /* - * Run through the entire format string to validate it and initialize - * the positional arg numbers (if any). - */ - { - register const wchar_t *fmt = fmt0; - - while (*fmt) { - if ((*fmt == '%') && (*++fmt != '%')) { - ppfs->fmtpos = (const char *) fmt; /* back up to the '%' */ - if ((r = _ppfs_parsespec(ppfs)) < 0) { - return -1; - } - fmt = (const wchar_t *) ppfs->fmtpos; /* update to one past end of spec */ - } else { - ++fmt; - } - } - ppfs->fmtpos = (const char *) fmt0; /* rewind */ - } - -#ifdef NL_ARGMAX - /* If we have positional args, make sure we know all the types. */ - { - register int *p = ppfs->argtype; - r = ppfs->maxposarg; - while (--r >= 0) { - if ( *p == __PA_NOARG ) { /* missing arg type!!! */ - return -1; - } - ++p; - } - } -#endif /* NL_ARGMAX */ - - return 0; -} - -#endif /* L_vfprintf */ - -static size_t _charpad(FILE * __restrict stream, int padchar, size_t numpad) -{ - size_t todo = numpad; - - /* TODO -- Use a buffer to cut down on function calls... */ - FMT_TYPE pad[1]; - - *pad = padchar; - while (todo && (OUTNSTR(stream, pad, 1) == 1)) { - --todo; - } - - return numpad - todo; -} - -/* TODO -- Dynamically allocate work space to accomodate stack-poor archs? */ -static int _do_one_spec(FILE * __restrict stream, - register ppfs_t *ppfs, int *count) -{ - static const char spec_base[] = SPEC_BASE; -#ifdef L_vfprintf - static const char prefix[] = "+\0-\0 \0000x\0000X"; - /* 0 2 4 6 9 11*/ -#else /* L_vfprintf */ - static const wchar_t prefix[] = L"+\0-\0 \0000x\0000X"; -#endif /* L_vfprintf */ - enum { - PREFIX_PLUS = 0, - PREFIX_MINUS = 2, - PREFIX_SPACE = 4, - PREFIX_LWR_X = 6, - PREFIX_UPR_X = 9, - PREFIX_NONE = 11 - }; - -#ifdef __va_arg_ptr - const void * const *argptr; -#else - const void * argptr[MAX_ARGS_PER_SPEC]; -#endif - int *argtype; -#ifdef __UCLIBC_HAS_WCHAR__ - const wchar_t *ws = NULL; - mbstate_t mbstate; -#endif /* __UCLIBC_HAS_WCHAR__ */ - size_t slen; -#ifdef L_vfprintf -#define SLEN slen -#else - size_t SLEN; - wchar_t wbuf[2]; -#endif - int base; - int numpad; - int alphacase; - int numfill = 0; /* TODO: fix */ - int prefix_num = PREFIX_NONE; - char padchar = ' '; -#ifdef __UCLIBC_MJN3_ONLY__ -#warning TODO: Determine appropriate buf size. -#endif /* __UCLIBC_MJN3_ONLY__ */ - /* TODO: buf needs to be big enough for any possible error return strings - * and also for any locale-grouped long long integer strings generated. - * This should be large enough for any of the current archs/locales, but - * eventually this should be handled robustly. */ - char buf[128]; - -#ifdef NDEBUG - _ppfs_parsespec(ppfs); -#else - if (_ppfs_parsespec(ppfs) < 0) { /* TODO: just for debugging */ - abort(); - } -#endif - _ppfs_setargs(ppfs); - - argtype = ppfs->argtype + ppfs->argnumber[2] - 1; - /* Deal with the argptr vs argvalue issue. */ -#ifdef __va_arg_ptr - argptr = (const void * const *) ppfs->argptr; -#ifdef NL_ARGMAX - if (ppfs->maxposarg > 0) { /* Using positional args... */ - argptr += ppfs->argnumber[2] - 1; - } -#endif /* NL_ARGMAX */ -#else - /* Need to build a local copy... */ - { - register argvalue_t *p = ppfs->argvalue; - int i; -#ifdef NL_ARGMAX - if (ppfs->maxposarg > 0) { /* Using positional args... */ - p += ppfs->argnumber[2] - 1; - } -#endif /* NL_ARGMAX */ - for (i = 0 ; i < ppfs->num_data_args ; i++ ) { - argptr[i] = (void *) p++; - } - } -#endif - { - register char *s = NULL; /* TODO: Should s be unsigned char * ? */ - - if (ppfs->conv_num == CONV_n) { - _store_inttype(*(void **)*argptr, - ppfs->info._flags & __PA_INTMASK, - (intmax_t) (*count)); - return 0; - } - if (ppfs->conv_num <= CONV_i) { /* pointer or (un)signed int */ - alphacase = __UIM_LOWER; - -#ifdef __UCLIBC_MJN3_ONLY__ -#ifdef L_vfprintf -#warning CONSIDER: Should we ignore these flags if stub locale? What about custom specs? -#endif -#endif /* __UCLIBC_MJN3_ONLY__ */ - if ((base = spec_base[(int)(ppfs->conv_num - CONV_p)]) == 10) { - if (PRINT_INFO_FLAG_VAL(&(ppfs->info),group)) { - alphacase = __UIM_GROUP; - } - if (PRINT_INFO_FLAG_VAL(&(ppfs->info),i18n)) { - alphacase |= 0x80; - } - } - - if (ppfs->conv_num <= CONV_u) { /* pointer or unsigned int */ - if (ppfs->conv_num == CONV_X) { - alphacase = __UIM_UPPER; - } - if (ppfs->conv_num == CONV_p) { /* pointer */ - prefix_num = PREFIX_LWR_X; - } else { /* unsigned int */ - } - } else { /* signed int */ - base = -base; - } - if (ppfs->info.prec < 0) { /* Ignore '0' flag if prec specified. */ - padchar = ppfs->info.pad; - } -#ifdef __UCLIBC_MJN3_ONLY__ -#ifdef L_vfprintf -#warning CONSIDER: If using outdigits and/or grouping, how should we interpret precision? -#endif -#endif /* __UCLIBC_MJN3_ONLY__ */ - s = _uintmaxtostr(buf + sizeof(buf) - 1, - (uintmax_t) - _load_inttype(*argtype & __PA_INTMASK, - *argptr, base), base, alphacase); - if (ppfs->conv_num > CONV_u) { /* signed int */ - if (*s == '-') { - PRINT_INFO_SET_FLAG(&(ppfs->info),showsign); - ++s; /* handle '-' in the prefix string */ - prefix_num = PREFIX_MINUS; - } else if (PRINT_INFO_FLAG_VAL(&(ppfs->info),showsign)) { - prefix_num = PREFIX_PLUS; - } else if (PRINT_INFO_FLAG_VAL(&(ppfs->info),space)) { - prefix_num = PREFIX_SPACE; - } - } - slen = (char *)(buf + sizeof(buf) - 1) - s; -#ifdef L_vfwprintf - { - const char *q = s; - mbstate.__mask = 0; /* Initialize the mbstate. */ - SLEN = mbsrtowcs(NULL, &q, 0, &mbstate); - } -#endif - numfill = ((ppfs->info.prec < 0) ? 1 : ppfs->info.prec); - if (PRINT_INFO_FLAG_VAL(&(ppfs->info),alt)) { - if (ppfs->conv_num <= CONV_x) { /* x or p */ - prefix_num = PREFIX_LWR_X; - } - if (ppfs->conv_num == CONV_X) { - prefix_num = PREFIX_UPR_X; - } - if ((ppfs->conv_num == CONV_o) && (numfill <= SLEN)) { - numfill = ((*s == '0') ? 1 : SLEN + 1); - } - } - if (*s == '0') { - if (prefix_num >= PREFIX_LWR_X) { - prefix_num = PREFIX_NONE; - } - if (ppfs->conv_num == CONV_p) {/* null pointer */ - s = "(nil)"; -#ifdef L_vfwprintf - SLEN = -#endif - slen = 5; - numfill = 0; - } else if (numfill == 0) { /* if precision 0, no output */ -#ifdef L_vfwprintf - SLEN = -#endif - slen = 0; - } - } - numfill = ((numfill > SLEN) ? numfill - SLEN : 0); - } else if (ppfs->conv_num <= CONV_A) { /* floating point */ -#ifdef __STDIO_PRINTF_FLOAT - ssize_t nf; - nf = _fpmaxtostr(stream, - (__fpmax_t) - (PRINT_INFO_FLAG_VAL(&(ppfs->info),is_long_double) - ? *(long double *) *argptr - : (long double) (* (double *) *argptr)), - &ppfs->info, FP_OUT ); - if (nf < 0) { - return -1; - } - *count += nf; - - return 0; -#else /* __STDIO_PRINTF_FLOAT */ - return -1; /* TODO -- try to continue? */ -#endif /* __STDIO_PRINTF_FLOAT */ - } else if (ppfs->conv_num <= CONV_S) { /* wide char or string */ -#ifdef L_vfprintf - -#ifdef __UCLIBC_HAS_WCHAR__ - mbstate.__mask = 0; /* Initialize the mbstate. */ - if (ppfs->conv_num == CONV_S) { /* wide string */ - if (!(ws = *((const wchar_t **) *argptr))) { - goto NULL_STRING; - } - /* We use an awful uClibc-specific hack here, passing - * (char*) &ws as the conversion destination. This signals - * uClibc's wcsrtombs that we want a "restricted" length - * such that the mbs fits in a buffer of the specified - * size with no partial conversions. */ - if ((slen = wcsrtombs((char *) &ws, &ws, /* Use awful hack! */ - ((ppfs->info.prec >= 0) - ? ppfs->info.prec - : SIZE_MAX), &mbstate)) - == ((size_t)-1) - ) { - return -1; /* EILSEQ */ - } - } else { /* wide char */ - s = buf; - slen = wcrtomb(s, (*((const wchar_t *) *argptr)), &mbstate); - if (slen == ((size_t)-1)) { - return -1; /* EILSEQ */ - } - s[slen] = 0; /* TODO - Is this necessary? */ - } -#else /* __UCLIBC_HAS_WCHAR__ */ - return -1; -#endif /* __UCLIBC_HAS_WCHAR__ */ - } else if (ppfs->conv_num <= CONV_s) { /* char or string */ - if (ppfs->conv_num == CONV_s) { /* string */ - s = *((char **) (*argptr)); - if (s) { -#ifdef __UCLIBC_HAS_PRINTF_M_SPEC__ - SET_STRING_LEN: -#endif - slen = strnlen(s, ((ppfs->info.prec >= 0) - ? ppfs->info.prec : SIZE_MAX)); - } else { -#ifdef __UCLIBC_HAS_WCHAR__ - NULL_STRING: -#endif - s = "(null)"; - slen = 6; - } - } else { /* char */ - s = buf; - *s = (unsigned char)(*((const int *) *argptr)); - s[1] = 0; - slen = 1; - } - -#else /* L_vfprintf */ - - if (ppfs->conv_num == CONV_S) { /* wide string */ - ws = *((wchar_t **) (*argptr)); - if (!ws) { - goto NULL_STRING; - } - SLEN = wcsnlen(ws, ((ppfs->info.prec >= 0) - ? ppfs->info.prec : SIZE_MAX)); - } else { /* wide char */ - *wbuf = (wchar_t)(*((const wint_t *) *argptr)); - CHAR_CASE: - ws = wbuf; - wbuf[1] = 0; - SLEN = 1; - } - - } else if (ppfs->conv_num <= CONV_s) { /* char or string */ - - if (ppfs->conv_num == CONV_s) { /* string */ -#ifdef __UCLIBC_MJN3_ONLY__ -#warning TODO: Fix %s for vfwprintf... output upto illegal sequence? -#endif /* __UCLIBC_MJN3_ONLY__ */ - s = *((char **) (*argptr)); - if (s) { -#ifdef __UCLIBC_HAS_PRINTF_M_SPEC__ - SET_STRING_LEN: -#endif - /* We use an awful uClibc-specific hack here, passing - * (wchar_t*) &mbstate as the conversion destination. - * This signals uClibc's mbsrtowcs that we want a - * "restricted" length such that the mbs fits in a buffer - * of the specified size with no partial conversions. */ - { - const char *q = s; - mbstate.__mask = 0; /* Initialize the mbstate. */ - SLEN = mbsrtowcs((wchar_t *) &mbstate, &q, - ((ppfs->info.prec >= 0) - ? ppfs->info.prec : SIZE_MAX), - &mbstate); - } - if (SLEN == ((size_t)(-1))) { - return -1; /* EILSEQ */ - } - } else { - NULL_STRING: - s = "(null)"; - SLEN = slen = 6; - } - } else { /* char */ - *wbuf = btowc( (unsigned char)(*((const int *) *argptr)) ); - goto CHAR_CASE; - } - -#endif /* L_vfprintf */ - -#ifdef __UCLIBC_HAS_PRINTF_M_SPEC__ - } else if (ppfs->conv_num == CONV_m) { - s = __glibc_strerror_r_internal(errno, buf, sizeof(buf)); - goto SET_STRING_LEN; -#endif - } else { -#ifdef __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ - assert(ppfs->conv_num == CONV_custom0); - - s = _custom_printf_spec; - do { - if (*s == ppfs->info.spec) { - int rv; - /* TODO -- check return value for sanity? */ - rv = (*_custom_printf_handler - [(int)(s-_custom_printf_spec)]) - (stream, &ppfs->info, argptr); - if (rv < 0) { - return -1; - } - *count += rv; - return 0; - } - } while (++s < (_custom_printf_spec + MAX_USER_SPEC)); -#endif /* __UCLIBC_HAS_GLIBC_CUSTOM_PRINTF__ */ - assert(0); - return -1; - } - -#ifdef __UCLIBC_MJN3_ONLY__ -#ifdef L_vfprintf -#warning CONSIDER: If using outdigits and/or grouping, how should we pad? -#endif -#endif /* __UCLIBC_MJN3_ONLY__ */ - { - size_t t; - - t = SLEN + numfill; - if (prefix_num != PREFIX_NONE) { - t += ((prefix_num < PREFIX_LWR_X) ? 1 : 2); - } - numpad = ((ppfs->info.width > t) ? (ppfs->info.width - t) : 0); - *count += t + numpad; - } - if (padchar == '0') { /* TODO: check this */ - numfill += numpad; - numpad = 0; - } - - /* Now handle the output itself. */ - if (!PRINT_INFO_FLAG_VAL(&(ppfs->info),left)) { - if (_charpad(stream, ' ', numpad) != numpad) { - return -1; - } - numpad = 0; - } - OUTPUT(stream, prefix + prefix_num); - if (_charpad(stream, '0', numfill) != numfill) { - return -1; - } - -#ifdef L_vfprintf - -#ifdef __UCLIBC_HAS_WCHAR__ - if (!ws) { - assert(s); - if (_outnstr(stream, s, slen) != slen) { - return -1; - } - } else { /* wide string */ - size_t t; - mbstate.__mask = 0; /* Initialize the mbstate. */ - while (slen) { - t = (slen <= sizeof(buf)) ? slen : sizeof(buf); - t = wcsrtombs(buf, &ws, t, &mbstate); - assert (t != ((size_t)(-1))); - if (_outnstr(stream, buf, t) != t) { - return -1; - } - slen -= t; - } - } -#else /* __UCLIBC_HAS_WCHAR__ */ - if (_outnstr(stream, s, slen) != slen) { - return -1; - } -#endif /* __UCLIBC_HAS_WCHAR__ */ - -#else /* L_vfprintf */ - - if (!ws) { - assert(s); - if (_outnstr(stream, s, SLEN) != SLEN) { - return -1; - } - } else { - if (_outnwcs(stream, ws, SLEN) != SLEN) { - return -1; - } - } - -#endif /* L_vfprintf */ - if (_charpad(stream, ' ', numpad) != numpad) { - return -1; - } - } - - return 0; -} - -int attribute_hidden HIDDEN_VFPRINTF (FILE * __restrict stream, - register const FMT_TYPE * __restrict format, - va_list arg) -{ - ppfs_t ppfs; - int count, r; - register const FMT_TYPE *s; - __STDIO_AUTO_THREADLOCK_VAR; - - __STDIO_AUTO_THREADLOCK(stream); - - count = 0; - s = format; - - if -#ifdef L_vfprintf - (!__STDIO_STREAM_IS_NARROW_WRITING(stream) - && __STDIO_STREAM_TRANS_TO_WRITE(stream, __FLAG_NARROW)) -#else - (!__STDIO_STREAM_IS_WIDE_WRITING(stream) - && __STDIO_STREAM_TRANS_TO_WRITE(stream, __FLAG_WIDE)) -#endif - { - count = -1; - } else if (_PPFS_init(&ppfs, format) < 0) { /* Bad format string. */ - OUTNSTR(stream, (const FMT_TYPE *) ppfs.fmtpos, - STRLEN((const FMT_TYPE *)(ppfs.fmtpos))); -#if defined(L_vfprintf) && !defined(NDEBUG) - fprintf(stderr,"\nIMbS: \"%s\"\n\n", format); -#endif - count = -1; - } else { - _ppfs_prepargs(&ppfs, arg); /* This did a va_copy!!! */ - - do { - while (*format && (*format != '%')) { - ++format; - } - - if (format-s) { /* output any literal text in format string */ - if ( (r = OUTNSTR(stream, s, format-s)) != (format-s)) { - count = -1; - break; - } - count += r; - } - - if (!*format) { /* we're done */ - break; - } - - if (format[1] != '%') { /* if we get here, *format == '%' */ - /* TODO: _do_one_spec needs to know what the output funcs are!!! */ - ppfs.fmtpos = (const char *)(++format); - /* TODO: check -- should only fail on stream error */ - if ( (r = _do_one_spec(stream, &ppfs, &count)) < 0) { - count = -1; - break; - } - s = format = (const FMT_TYPE *) ppfs.fmtpos; - } else { /* %% means literal %, so start new string */ - s = ++format; - ++format; - } - } while (1); - - va_end(ppfs.arg); /* Need to clean up after va_copy! */ - } - -/* #if defined(L_vfprintf) && defined(__UCLIBC_HAS_WCHAR__) */ -/* DONE: */ -/* #endif */ - - __STDIO_AUTO_THREADUNLOCK(stream); - - return count; -} -strong_alias(HIDDEN_VFPRINTF,VFPRINTF) -#endif -/**********************************************************************/ +#define L_vfprintf +#include "_vfprintf.c" diff --git a/libc/stdio/vfscanf.c b/libc/stdio/vfscanf.c new file mode 100644 index 000000000..b13ff8db8 --- /dev/null +++ b/libc/stdio/vfscanf.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define L_vfscanf +#include "_scanf.c" diff --git a/libc/stdio/vfwprintf.c b/libc/stdio/vfwprintf.c new file mode 100644 index 000000000..323b90015 --- /dev/null +++ b/libc/stdio/vfwprintf.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define L_vfwprintf +#include "_vfprintf.c" diff --git a/libc/stdio/vfwscanf.c b/libc/stdio/vfwscanf.c new file mode 100644 index 000000000..ac982b4f1 --- /dev/null +++ b/libc/stdio/vfwscanf.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define L_vfwscanf +#include "_scanf.c" diff --git a/libc/stdio/vprintf.c b/libc/stdio/vprintf.c index 9c0e07514..7848a078d 100644 --- a/libc/stdio/vprintf.c +++ b/libc/stdio/vprintf.c @@ -8,7 +8,9 @@ #include "_stdio.h" #include <stdarg.h> +libc_hidden_proto(vfprintf) + int vprintf(const char * __restrict format, va_list arg) { - return __vfprintf(stdout, format, arg); + return vfprintf(stdout, format, arg); } diff --git a/libc/stdio/vscanf.c b/libc/stdio/vscanf.c new file mode 100644 index 000000000..834fe92ee --- /dev/null +++ b/libc/stdio/vscanf.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define L_vscanf +#include "_scanf.c" diff --git a/libc/stdio/vsnprintf.c b/libc/stdio/vsnprintf.c index c926b2ad7..ab6154848 100644 --- a/libc/stdio/vsnprintf.c +++ b/libc/stdio/vsnprintf.c @@ -8,13 +8,17 @@ #include "_stdio.h" #include <stdarg.h> +libc_hidden_proto(vsnprintf) + +libc_hidden_proto(vfprintf) + #ifdef __UCLIBC_MJN3_ONLY__ #warning WISHLIST: Implement vsnprintf for non-buffered and no custom stream case. #endif /* __UCLIBC_MJN3_ONLY__ */ #ifdef __STDIO_BUFFERS -int attribute_hidden __vsnprintf(char *__restrict buf, size_t size, +int vsnprintf(char *__restrict buf, size_t size, const char * __restrict format, va_list arg) { FILE f; @@ -61,7 +65,7 @@ int attribute_hidden __vsnprintf(char *__restrict buf, size_t size, __STDIO_STREAM_DISABLE_GETC(&f); __STDIO_STREAM_ENABLE_PUTC(&f); - rv = __vfprintf(&f, format, arg); + rv = vfprintf(&f, format, arg); if (size) { if (f.__bufpos == f.__bufend) { --f.__bufpos; @@ -70,7 +74,7 @@ int attribute_hidden __vsnprintf(char *__restrict buf, size_t size, } return rv; } -strong_alias(__vsnprintf,vsnprintf) +libc_hidden_def(vsnprintf) #elif defined(__USE_OLD_VFPRINTF__) @@ -80,7 +84,7 @@ typedef struct { unsigned char *bufpos; } __FILE_vsnprintf; -int attribute_hidden __vsnprintf(char *__restrict buf, size_t size, +int vsnprintf(char *__restrict buf, size_t size, const char * __restrict format, va_list arg) { __FILE_vsnprintf f; @@ -122,7 +126,7 @@ int attribute_hidden __vsnprintf(char *__restrict buf, size_t size, #endif f.f.__nextopen = NULL; - rv = __vfprintf((FILE *) &f, format, arg); + rv = vfprintf((FILE *) &f, format, arg); if (size) { if (f.bufpos == f.bufend) { --f.bufpos; @@ -131,7 +135,7 @@ int attribute_hidden __vsnprintf(char *__restrict buf, size_t size, } return rv; } -strong_alias(__vsnprintf,vsnprintf) +libc_hidden_def(vsnprintf) #elif defined(__UCLIBC_HAS_GLIBC_CUSTOM_STREAMS__) @@ -173,7 +177,7 @@ static ssize_t snpf_write(register void *cookie, const char *buf, #undef COOKIE -int attribute_hidden __vsnprintf(char *__restrict buf, size_t size, +int vsnprintf(char *__restrict buf, size_t size, const char * __restrict format, va_list arg) { FILE f; @@ -211,11 +215,11 @@ int attribute_hidden __vsnprintf(char *__restrict buf, size_t size, #endif f.__nextopen = NULL; - rv = __vfprintf(&f, format, arg); + rv = vfprintf(&f, format, arg); return rv; } -strong_alias(__vsnprintf,vsnprintf) +libc_hidden_def(vsnprintf) #else #warning Skipping vsnprintf since no buffering, no custom streams, and not old vfprintf! diff --git a/libc/stdio/vsprintf.c b/libc/stdio/vsprintf.c index a7d5e08f5..8e27c19d9 100644 --- a/libc/stdio/vsprintf.c +++ b/libc/stdio/vsprintf.c @@ -12,10 +12,12 @@ #warning Skipping vsprintf since no vsnprintf! #else +libc_hidden_proto(vsnprintf) + int vsprintf(char *__restrict buf, const char * __restrict format, va_list arg) { - return __vsnprintf(buf, SIZE_MAX, format, arg); + return vsnprintf(buf, SIZE_MAX, format, arg); } #endif diff --git a/libc/stdio/vsscanf.c b/libc/stdio/vsscanf.c new file mode 100644 index 000000000..882c2713e --- /dev/null +++ b/libc/stdio/vsscanf.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define L_vsscanf +#include "_scanf.c" diff --git a/libc/stdio/vswprintf.c b/libc/stdio/vswprintf.c index c9e73cf87..d95de51a2 100644 --- a/libc/stdio/vswprintf.c +++ b/libc/stdio/vswprintf.c @@ -9,11 +9,15 @@ #include <stdarg.h> #include <wchar.h> +libc_hidden_proto(vswprintf) + +libc_hidden_proto(vfwprintf) + #ifndef __STDIO_BUFFERS #warning Skipping vswprintf since no buffering! #else /* __STDIO_BUFFERS */ -int attribute_hidden __vswprintf(wchar_t *__restrict buf, size_t size, +int vswprintf(wchar_t *__restrict buf, size_t size, const wchar_t * __restrict format, va_list arg) { FILE f; @@ -56,7 +60,7 @@ int attribute_hidden __vswprintf(wchar_t *__restrict buf, size_t size, __STDIO_STREAM_DISABLE_GETC(&f); __STDIO_STREAM_DISABLE_PUTC(&f); - rv = __vfwprintf(&f, format, arg); + rv = vfwprintf(&f, format, arg); /* NOTE: Return behaviour differs from snprintf... */ if (f.__bufpos == f.__bufend) { @@ -70,6 +74,6 @@ int attribute_hidden __vswprintf(wchar_t *__restrict buf, size_t size, } return rv; } -strong_alias(__vswprintf,vswprintf) +libc_hidden_def(vswprintf) #endif /* __STDIO_BUFFERS */ diff --git a/libc/stdio/vswscanf.c b/libc/stdio/vswscanf.c new file mode 100644 index 000000000..fddb60209 --- /dev/null +++ b/libc/stdio/vswscanf.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define L_vswscanf +#include "_scanf.c" diff --git a/libc/stdio/vwprintf.c b/libc/stdio/vwprintf.c index 8c3401846..1c32887a4 100644 --- a/libc/stdio/vwprintf.c +++ b/libc/stdio/vwprintf.c @@ -9,7 +9,9 @@ #include <stdarg.h> #include <wchar.h> +libc_hidden_proto(vfwprintf) + int vwprintf(const wchar_t * __restrict format, va_list arg) { - return __vfwprintf(stdout, format, arg); + return vfwprintf(stdout, format, arg); } diff --git a/libc/stdio/vwscanf.c b/libc/stdio/vwscanf.c new file mode 100644 index 000000000..9e21a271e --- /dev/null +++ b/libc/stdio/vwscanf.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define L_vwscanf +#include "_scanf.c" diff --git a/libc/stdio/wprintf.c b/libc/stdio/wprintf.c index 00f5ef514..9dc274aec 100644 --- a/libc/stdio/wprintf.c +++ b/libc/stdio/wprintf.c @@ -9,13 +9,15 @@ #include <stdarg.h> #include <wchar.h> +libc_hidden_proto(vfwprintf) + int wprintf(const wchar_t * __restrict format, ...) { va_list arg; int rv; va_start(arg, format); - rv = __vfwprintf(stdout, format, arg); + rv = vfwprintf(stdout, format, arg); va_end(arg); return rv; diff --git a/libc/stdio/wscanf.c b/libc/stdio/wscanf.c new file mode 100644 index 000000000..d354d527f --- /dev/null +++ b/libc/stdio/wscanf.c @@ -0,0 +1,9 @@ +/* Copyright (C) 2004 Manuel Novoa III <mjn3@uclibc.org> + * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> + * + * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. + * + * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. + */ +#define L_wscanf +#include "_scanf.c" |