CFLAGS += -D_LIBC_REENTRANT
endif
-# Locale support is required for wide char support.
-ifneq ($(strip $(HAS_LOCALE)),true)
- HAS_WCHAR:=false
-endif
-
# TARGET_PREFIX is the directory under which which the uClibc runtime
# environment will be installed and used on the target system. The
# result will look something like the following:
The function should return the number of characters written,
or -1 for errors. */
-typedef int printf_function (FILE *__stream,
+typedef int (*printf_function) (FILE *__stream,
__const struct printf_info *__info,
__const void *__const *__args);
# define __ldiv_t_defined 1
#endif
+#ifdef __UCLIBC_HAS_LONG_LONG__
#if defined __USE_ISOC99 && !defined __lldiv_t_defined
/* Returned by `lldiv'. */
__extension__ typedef struct
} lldiv_t;
# define __lldiv_t_defined 1
#endif
+#endif /* __UCLIBC_HAS_LONG_LONG__ */
/* The largest number rand will return (same as INT_MAX). */
extern size_t _stdlib_mb_cur_max (void) __THROW;
#endif
+#ifdef __UCLIBC_HAS_FLOATS__
/* Convert a string to a floating-point number. */
extern double atof (__const char *__nptr) __THROW __attribute_pure__;
+#endif /* __UCLIBC_HAS_FLOATS__ */
/* Convert a string to an integer. */
extern int atoi (__const char *__nptr) __THROW __attribute_pure__;
/* Convert a string to a long integer. */
extern long int atol (__const char *__nptr) __THROW __attribute_pure__;
+#ifdef __UCLIBC_HAS_LONG_LONG__
#if defined __USE_ISOC99 || (defined __GNUC__ && defined __USE_MISC)
/* Convert a string to a long long integer. */
__extension__ extern long long int atoll (__const char *__nptr)
__THROW __attribute_pure__;
#endif
+#endif /* __UCLIBC_HAS_LONG_LONG__ */
+#ifdef __UCLIBC_HAS_FLOATS__
/* Convert a string to a floating-point number. */
extern double strtod (__const char *__restrict __nptr,
char **__restrict __endptr) __THROW;
extern long double strtold (__const char *__restrict __nptr,
char **__restrict __endptr) __THROW;
#endif
+#endif /* __UCLIBC_HAS_FLOATS__ */
/* Convert a string to a long integer. */
extern long int strtol (__const char *__restrict __nptr,
char **__restrict __endptr, int __base)
__THROW;
+#ifdef __UCLIBC_HAS_LONG_LONG__
#if defined __GNUC__ && defined __USE_BSD
/* Convert a string to a quadword integer. */
__extension__
char **__restrict __endptr, int __base)
__THROW;
#endif /* ISO C99 or GCC and use MISC. */
+#endif /* __UCLIBC_HAS_LONG_LONG__ */
#if 0
/* The internal entry points for `strtoX' take an extra flag argument
saying whether or not to parse locale-dependent number grouping. */
+#ifdef __UCLIBC_HAS_FLOATS__
extern double __strtod_internal (__const char *__restrict __nptr,
char **__restrict __endptr, int __group)
__THROW;
extern long double __strtold_internal (__const char *__restrict __nptr,
char **__restrict __endptr,
int __group) __THROW;
+#endif /* __UCLIBC_HAS_FLOATS__ */
#ifndef __strtol_internal_defined
extern long int __strtol_internal (__const char *__restrict __nptr,
char **__restrict __endptr,
int __base, int __group) __THROW;
# define __strtoul_internal_defined 1
#endif
+#ifdef __UCLIBC_HAS_LONG_LONG__
#if defined __GNUC__ || defined __USE_ISOC99
# ifndef __strtoll_internal_defined
__extension__
# define __strtoull_internal_defined 1
# endif
#endif /* GCC */
+#endif /* __UCLIBC_HAS_LONG_LONG__ */
#ifdef __USE_EXTERN_INLINES
/* Define inline functions which call the internal entry points. */
#if defined __USE_SVID || defined __USE_XOPEN
/* System V style 48-bit random number generator functions. */
+#ifdef __UCLIBC_HAS_FLOATS__
/* Return non-negative, double-precision floating-point value in [0.0,1.0). */
extern double drand48 (void) __THROW;
extern double erand48 (unsigned short int __xsubi[3]) __THROW;
+#endif /* __UCLIBC_HAS_FLOATS__ */
/* Return non-negative, long integer in [0,2^31). */
extern long int lrand48 (void) __THROW;
unsigned short int __old_x[3]; /* Old state. */
unsigned short int __c; /* Additive const. in congruential formula. */
unsigned short int __init; /* Flag for initializing. */
+#ifdef __UCLIBC_HAS_LONG_LONG__
unsigned long long int __a; /* Factor in congruential formula. */
+#endif /* __UCLIBC_HAS_LONG_LONG__ */
};
+#ifdef __UCLIBC_HAS_FLOATS__
/* Return non-negative, double-precision floating-point value in [0.0,1.0). */
extern int drand48_r (struct drand48_data *__restrict __buffer,
double *__restrict __result) __THROW;
extern int erand48_r (unsigned short int __xsubi[3],
struct drand48_data *__restrict __buffer,
double *__restrict __result) __THROW;
+#endif /* __UCLIBC_HAS_FLOATS__ */
/* Return non-negative, long integer in [0,2^31). */
extern int lrand48_r (struct drand48_data *__restrict __buffer,
/* Return the absolute value of X. */
extern int abs (int __x) __THROW __attribute__ ((__const__));
extern long int labs (long int __x) __THROW __attribute__ ((__const__));
+#ifdef __UCLIBC_HAS_LONG_LONG__
#ifdef __USE_ISOC99
__extension__ extern long long int llabs (long long int __x)
__THROW __attribute__ ((__const__));
#endif
+#endif /* #ifdef __UCLIBC_HAS_LONG_LONG__ */
/* Return the `div_t', `ldiv_t' or `lldiv_t' representation
__THROW __attribute__ ((__const__));
extern ldiv_t ldiv (long int __numer, long int __denom)
__THROW __attribute__ ((__const__));
+#ifdef __UCLIBC_HAS_LONG_LONG__
#ifdef __USE_ISOC99
__extension__ extern lldiv_t lldiv (long long int __numer,
long long int __denom)
__THROW __attribute__ ((__const__));
#endif
+#endif /* __UCLIBC_HAS_LONG_LONG__ */
+#ifdef __UCLIBC_HAS_FLOATS__
#if defined __USE_SVID || defined __USE_XOPEN_EXTENDED
/* Convert floating point numbers to strings. The returned values are
valid only until another call to the same function. */
char *__restrict __buf, size_t __len) __THROW;
# endif /* misc */
#endif /* use MISC || use X/Open Unix */
+#endif /* __UCLIBC_HAS_FLOATS__ */
#ifdef __UCLIBC_HAS_WCHAR__
/* Return the length of the multibyte character
#undef assert
void __assert(const char *assertion, const char * filename,
- int linenumber, const char * function)
+ int linenumber, register const char * function)
{
char buf[__BUFLEN_INT10TOSTR];
#include <stdint.h>
#include <assert.h>
-#ifdef __LOCALE_C_ONLY
-
-#ifdef __WCHAR_ENABLED
-#error wide char support requires full locale support
-#endif
-
-#else /* __LOCALE_C_ONLY */
+#ifndef __LOCALE_C_ONLY
#define CUR_LOCALE_SPEC (__global_locale.cur_locale)
#undef CODESET_LIST
* ctype, numeric, monetary, time, collate, messages, all
*/
+#define C_LC_ALL 6
/* Combine the data to avoid size penalty for seperate char arrays when
* compiler aligns objects. The original code is left in as documentation. */
#define cat_start nl_data
-#define C_locale_data nl_data + LC_ALL + 1 + 78
+#define C_locale_data (nl_data + C_LC_ALL + 1 + 78)
-static const unsigned char nl_data[LC_ALL + 1 + 78 + 300] = {
-/* static const unsigned char cat_start[LC_ALL + 1] = { */
+static const unsigned char nl_data[C_LC_ALL + 1 + 78 + 300] = {
+/* static const unsigned char cat_start[C_LC_ALL + 1] = { */
'\x00', '\x01', '\x04', '\x1a', '\x4c', '\x4c', '\x4e',
/* }; */
/* static const unsigned char item_offset[78] = { */
unsigned int c;
unsigned int i;
- if ((c = _NL_ITEM_CATEGORY(item)) < LC_ALL) {
+ if ((c = _NL_ITEM_CATEGORY(item)) < C_LC_ALL) {
if ((i = cat_start[c] + _NL_ITEM_INDEX(item)) < cat_start[c+1]) {
/* return (char *) C_locale_data + item_offset[i] + (i & 64); */
- return (char *) C_locale_data + nl_data[LC_ALL+1+i] + (i & 64);
+ return (char *) C_locale_data + nl_data[C_LC_ALL+1+i] + (i & 64);
}
}
return (char *) cat_start; /* Conveniently, this is the empty string. */
#endif
/* TODO - This stuff belongs in some include/bits/ file. */
-#ifndef __BCC__
#undef CLK_TCK
#if (TARGET_ARCH == alpha) || (TARGET_ARCH == ia64)
#define CLK_TCK 1024
#else
#define CLK_TCK 100
#endif
-#endif
/* The era code is currently unfinished. */
/* #define ENABLE_ERA_CODE */
}
#ifdef __BCC__
- /* TODO - check */
d = p[5] - 1;
- days = -719163L + d*365 + ((d/4) - (d/100) + (d/400) + p[3] + p[7]);
+ days = -719163L + ((long)d)*365 + ((d/4) - (d/100) + (d/400) + p[3] + p[7]);
secs = p[0] + 60*( p[1] + 60*((long)(p[2])) )
+ _time_tzinfo[timeptr->tm_isdst > 0].gmt_offset;
if (secs < 0) {
TOPDIR=../../../
include $(TOPDIR)Rules.mak
-MSRC= wchar.c
-MOBJ= btowc.o wctob.o mbsinit.o mbrlen.o mbrtowc.o wcrtomb.o mbsrtowcs.o \
- wcsrtombs.o _wchar_utf8sntowcs.o _wchar_wcstoutf8s.o \
+MSRC1= wchar.c
+MOBJ1= btowc.o wctob.o mbsinit.o mbrlen.o mbrtowc.o wcrtomb.o mbsrtowcs.o \
+ wcsrtombs.o _wchar_utf8sntowcs.o _wchar_wcsntoutf8s.o \
__mbsnrtowcs.o __wcsnrtombs.o
-OBJS=$(MOBJ)
+MSRC2= wstdio.c
+MOBJ2= fwide.o \
+ fgetwc.o getwchar.o fgetws.o \
+ fputwc.o putwchar.o fputws.o \
+ ungetwc.o
+# getwc (fgetwc alias) getwc_unlocked (fgetwc_unlocked alias)
+# putwc (fputwc alias) putwc_unlocked (fputwc_unlocked alias)
+
+# wcwidth wcswidth
+# wcstod wcstof wcstold
+# wcstol wcstoul wcstoq wcstouq wcstoll wcstoull
+# fwprintf wprintf swprintf vfwprintf vwprintf vswprintf
+# fwscanf wscanf swscanf vfwscanf vwscanf vswscanf
+# wcsftime
+
+OBJS=$(MOBJ1) $(MOBJ2)
all: $(OBJS) $(LIBC)
ar-target: $(OBJS)
$(AR) $(ARFLAGS) $(LIBC) $(OBJS)
-$(MOBJ): $(MSRC)
+$(MOBJ1): $(MSRC1)
+ $(CC) $(CFLAGS) -DL_$* $< -c -o $*.o
+ $(STRIPTOOL) -x -R .note -R .comment $*.o
+
+$(MOBJ2): $(MSRC2)
$(CC) $(CFLAGS) -DL_$* $< -c -o $*.o
$(STRIPTOOL) -x -R .note -R .comment $*.o
* an issue for uClibc, but may be for ELKS. I'm currently not sure
* if I'll use 16-bit, 32-bit, or configureable wchars in ELKS.
*
+ * July 1, 2002
+ *
+ * Fixed _wchar_utf8sntowcs() for the max number of wchars == 0 case.
+ * Fixed nul-char bug in btowc(), and another in __mbsnrtowcs() for 8-bit
+ * locales.
+ * Enabled building of a C/POSIX-locale-only version, so full locale support
+ * no longer needs to be enabled.
+ *
* Manuel
*/
#include <locale.h>
#include <wchar.h>
+#ifdef __UCLIBC_HAS_LOCALE__
#define ENCODING (__global_locale.encoding)
+#warning implement __CTYPE_HAS_UTF_8_LOCALES!
+#define __CTYPE_HAS_UTF_8_LOCALES
+#else
+#define ENCODING (__ctype_encoding_7_bit)
+#undef __CTYPE_HAS_8_BIT_LOCALES
+#undef __CTYPE_HAS_UTF_8_LOCALES
+#undef L__wchar_utf8sntowcs
+#undef L__wchar_wcsntoutf8s
+#endif
#if WCHAR_MAX > 0xffffU
#define UTF_8_MAX_LEN 6
/* #define KUHN */
-#warning implement __CTYPE_HAS_UTF_8_LOCALES!
-#define __CTYPE_HAS_UTF_8_LOCALES
-
/* Implementation-specific work functions. */
extern size_t _wchar_utf8sntowcs(wchar_t *__restrict pwc, size_t wn,
wint_t btowc(int c)
{
+#ifdef __CTYPE_HAS_8_BIT_LOCALES
+
wchar_t wc;
unsigned char buf[1];
mbstate_t mbstate;
if (c != EOF) {
*buf = (unsigned char) c;
mbstate.mask = 0; /* Initialize the mbstate. */
- if (mbrtowc(&wc, buf, 1, &mbstate) == 1) {
+ if (mbrtowc(&wc, buf, 1, &mbstate) <= 1) {
return wc;
}
}
return WEOF;
+
+#else /* __CTYPE_HAS_8_BIT_LOCALES */
+
+ /* If we don't have 8-bit locale support, then this is trivial since
+ * anything outside of 0-0x7f is illegal in C/POSIX and UTF-8 locales. */
+ return (((unsigned int)c) < 0x80) ? c : WEOF;
+
+#endif /* __CTYPE_HAS_8_BIT_LOCALES */
}
#endif
int wctob(wint_t c)
{
+#ifdef __CTYPE_HAS_8_BIT_LOCALES
+
unsigned char buf[MB_LEN_MAX];
return (wcrtomb(buf, c, NULL) == 1) ? *buf : EOF;
+
+#else /* __CTYPE_HAS_8_BIT_LOCALES */
+
+ /* If we don't have 8-bit locale support, then this is trivial since
+ * anything outside of 0-0x7f is illegal in C/POSIX and UTF-8 locales. */
+
+ /* TODO: need unsigned version of wint_t... */
+/* return (((unsigned int)c) < 0x80) ? c : WEOF; */
+ return ((c >= 0) && (c < 0x80)) ? c : EOF;
+
+#endif /* __CTYPE_HAS_8_BIT_LOCALES */
}
#endif
#ifdef L_mbrlen
size_t mbrlen(const char *__restrict s, size_t n, mbstate_t *__restrict ps)
+ __attribute__ ((__weak__, __alias__("__mbrlen")));
+
+size_t __mbrlen(const char *__restrict s, size_t n, mbstate_t *__restrict ps)
{
static mbstate_t mbstate; /* Rely on bss 0-init. */
/* Need to do this here since mbsrtowcs doesn't allow incompletes. */
if (ENCODING == __ctype_encoding_utf8) {
r = _wchar_utf8sntowcs(pwc, 1, &p, n, ps, 1);
- return (r == 1) ? (p-s) : r;
+ return (r == 1) ? (p-s) : r; /* Need to return 0 if nul char. */
}
#endif
wn = SIZE_MAX;
incr = 0;
}
-#warning fix _wchar_utf8sntowcs to allow wn == 0!
- assert(wn > 0); /* TODO: fix this!! */
- count = wn;
+ /* This is really here only to support the glibc extension function
+ * __mbsnrtowcs which apparently returns 0 if wn == 0 without any
+ * check on the validity of the mbstate. */
+ if (!(count = wn)) {
+ return 0;
+ }
if ((mask = (__uwchar_t) ps->mask) != 0) { /* A continuation... */
#ifdef DECODER
#endif
/**********************************************************************/
-#ifdef L__wchar_wcstoutf8s
+#ifdef L__wchar_wcsntoutf8s
size_t _wchar_wcsntoutf8s(char *__restrict s, size_t n,
const wchar_t **__restrict src, size_t wn)
if (!wc) {
goto BAD;
}
- } else if (!wc) {
+ }
+ if (!(*dst = wc)) {
s = NULL;
break;
}
- ++s;
- *dst = wc;
dst += incr;
+ ++s;
--count;
}
if (dst != wcbuf) {
if (ENCODING == __ctype_encoding_utf8) {
return _wchar_wcsntoutf8s(dst, len, src, NWC);
}
-#endif
+#endif /* __CTYPE_HAS_UTF_8_LOCALES */
incr = 1;
if (!dst) {
/* #define __WCHAR_REPLACEMENT_CHAR '?' */
#ifdef __WCHAR_REPLACEMENT_CHAR
*dst = (unsigned char) ( u ? u : __WCHAR_REPLACEMENT_CHAR );
-#else
+#else /* __WCHAR_REPLACEMENT_CHAR */
if (!u) {
goto BAD;
}
*dst = (unsigned char) u;
-#endif
+#endif /* __WCHAR_REPLACEMENT_CHAR */
}
++s;
dst += incr;
}
return len - count;
}
-#endif
+#endif /* __CTYPE_HAS_8_BIT_LOCALES */
assert(ENCODING == __ctype_encoding_7_bit);
--- /dev/null
+
+/*
+ * ANSI/ISO C99 says
+
+ 9 Although both text and binary wideÂoriented streams are conceptually sequences of wide
+ characters, the external file associated with a wideÂoriented stream is a sequence of
+ multibyte characters, generalized as follows:
+ --- Multibyte encodings within files may contain embedded null bytes (unlike multibyte
+ encodings valid for use internal to the program).
+ --- A file need not begin nor end in the initial shift state. 225)
+
+ * How do we deal with this?
+
+ * Should auto_wr_transition init the mbstate object?
+*/
+
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <wchar.h>
+#include <limits.h>
+#include <errno.h>
+#include <assert.h>
+
+#ifndef __STDIO_THREADSAFE
+
+#ifdef __BCC__
+#define UNLOCKED_STREAM(RETURNTYPE,NAME,PARAMS,ARGS,STREAM) \
+asm(".text\nexport _" "NAME" "_unlocked\n_" "NAME" "_unlocked = _" "NAME"); \
+RETURNTYPE NAME PARAMS
+#else
+#define UNLOCKED_STREAM(RETURNTYPE,NAME,PARAMS,ARGS,STREAM) \
+strong_alias(NAME,NAME##_unlocked) \
+RETURNTYPE NAME PARAMS
+#endif
+
+#define UNLOCKED(RETURNTYPE,NAME,PARAMS,ARGS) \
+ UNLOCKED_STREAM(RETURNTYPE,NAME,PARAMS,ARGS,stream)
+
+#ifdef __BCC__
+#define UNLOCKED_VOID_RETURN(NAME,PARAMS,ARGS) \
+asm(".text\nexport _" "NAME" "_unlocked\n_" "NAME" "_unlocked = _" "NAME"); \
+void NAME PARAMS
+#else
+#define UNLOCKED_VOID_RETURN(NAME,PARAMS,ARGS) \
+strong_alias(NAME,NAME##_unlocked) \
+void NAME PARAMS
+#endif
+
+#define __STDIO_THREADLOCK_OPENLIST
+#define __STDIO_THREADUNLOCK_OPENLIST
+
+#else /* __STDIO_THREADSAFE */
+
+#include <pthread.h>
+
+#define UNLOCKED_STREAM(RETURNTYPE,NAME,PARAMS,ARGS,STREAM) \
+RETURNTYPE NAME PARAMS \
+{ \
+ RETURNTYPE retval; \
+ __STDIO_THREADLOCK(STREAM); \
+ retval = NAME##_unlocked ARGS ; \
+ __STDIO_THREADUNLOCK(STREAM); \
+ return retval; \
+} \
+RETURNTYPE NAME##_unlocked PARAMS
+
+#define UNLOCKED(RETURNTYPE,NAME,PARAMS,ARGS) \
+ UNLOCKED_STREAM(RETURNTYPE,NAME,PARAMS,ARGS,stream)
+
+#define UNLOCKED_VOID_RETURN(NAME,PARAMS,ARGS) \
+void NAME PARAMS \
+{ \
+ __STDIO_THREADLOCK(stream); \
+ NAME##_unlocked ARGS ; \
+ __STDIO_THREADUNLOCK(stream); \
+} \
+void NAME##_unlocked PARAMS
+
+#define __STDIO_THREADLOCK_OPENLIST \
+ pthread_mutex_lock(&_stdio_openlist_lock)
+
+#define __STDIO_THREADUNLOCK_OPENLIST \
+ pthread_mutex_unlock(&_stdio_openlist_lock)
+
+#define __STDIO_THREADTRYLOCK_OPENLIST \
+ pthread_mutex_trylock(&_stdio_openlist_lock)
+
+#endif /* __STDIO_THREADSAFE */
+
+#ifndef __STDIO_BUFFERS
+#error stdio buffers are currently required for wide i/o
+#endif
+
+/**********************************************************************/
+#ifdef L_fwide
+
+/* TODO: According to SUSv3 should return EBADF if invalid stream. */
+
+int fwide(register FILE *stream, int mode)
+{
+ __STDIO_THREADLOCK(stream);
+
+ if (mode && !(stream->modeflags & (__FLAG_WIDE|__FLAG_NARROW))) {
+ stream->modeflags |= ((mode > 0) ? __FLAG_WIDE : __FLAG_NARROW);
+ }
+
+ mode = (stream->modeflags & __FLAG_WIDE)
+ - (stream->modeflags & __FLAG_NARROW);
+
+ __STDIO_THREADUNLOCK(stream);
+
+ return mode;
+}
+
+#endif
+/**********************************************************************/
+#ifdef L_fgetwc
+
+static void munge_stream(register FILE *stream, unsigned char *buf)
+{
+#ifdef __STDIO_GETC_MACRO
+ stream->bufgetc =
+#endif
+#ifdef __STDIO_PUTC_MACRO
+ stream->bufputc =
+#endif
+ stream->bufpos = stream->bufread = stream->bufend = stream->bufstart = buf;
+}
+
+UNLOCKED(wint_t,fgetwc,(register FILE *stream),(stream))
+{
+ wint_t wi;
+ wchar_t wc[1];
+ int n;
+ size_t r;
+ unsigned char c[1];
+ unsigned char sbuf[1];
+ unsigned char ungot_width; /* Support ftell after wscanf ungetwc. */
+
+ wi = WEOF; /* Prepare for failure. */
+
+ if (stream->modeflags & __FLAG_NARROW) {
+ stream->modeflags |= __FLAG_ERROR;
+ __set_errno(EBADF);
+ goto DONE;
+ }
+ stream->modeflags |= __FLAG_WIDE;
+
+ if (stream->modeflags & __MASK_UNGOT) {/* Any ungetwc()s? */
+ assert( (stream->modeflags & (__FLAG_READING|__FLAG_ERROR))
+ == __FLAG_READING);
+ wi = stream->ungot[(--stream->modeflags) & __MASK_UNGOT];
+ stream->ungot[1] = 0;
+ goto DONE;
+ }
+
+ if (!stream->bufstart) { /* Ugh... stream isn't buffered! */
+ /* Munge the stream temporarily to use a 1-byte buffer. */
+ munge_stream(stream, sbuf);
+ ++stream->bufend;
+ }
+
+ ungot_width = 0;
+
+ LOOP:
+ if ((n = stream->bufread - stream->bufpos) == 0) {
+ goto FILL_BUFFER;
+ }
+
+ r = mbrtowc(wc, stream->bufpos, n, &stream->state);
+ if (((ssize_t) r) >= 0) { /* Single byte... */
+ if (r == 0) { /* Nul wide char... means 0 byte for us so */
+ ++r; /* increment r and handle below as single. */
+ }
+ stream->bufpos += r;
+ stream->ungot_width[0] = ungot_width + r;
+ wi = *wc;
+ goto DONE;
+ }
+
+ if (r == ((size_t) -2)) {
+ /* Potentially valid but incomplete and no more buffered. */
+ stream->bufpos += n; /* Update bufpos for stream. */
+ ungot_width += n;
+ FILL_BUFFER:
+ if (_stdio_fread(c, (size_t) 1, stream) > 0) {
+ assert(stream->bufpos == stream->bufstart + 1);
+ *--stream->bufpos = *c; /* Insert byte into buffer. */
+ goto LOOP;
+ }
+ if (!__FERROR(stream)) { /* EOF with no error. */
+ if (!stream->state.mask) { /* No partially complete wchar. */
+ goto DONE;
+ }
+ /* EOF but partially complete wchar. */
+ /* TODO: should EILSEQ be set? */
+ __set_errno(EILSEQ);
+ }
+ }
+
+ /* 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. Make sure stream's
+ * error indicator is set. */
+ stream->modeflags |= __FLAG_ERROR;
+
+ DONE:
+ if (stream->bufstart == sbuf) { /* Need to un-munge the stream. */
+ munge_stream(stream, NULL);
+ }
+
+ return wi;
+}
+
+strong_alias(fgetwc_unlocked,getwc_unlocked);
+strong_alias(fgetwc,getwc);
+
+#endif
+/**********************************************************************/
+#ifdef L_getwchar
+
+UNLOCKED_STREAM(wint_t,getwchar,(void),(),stdin)
+{
+ register FILE *stream = stdin; /* This helps bcc optimize. */
+
+ return fgetwc_unlocked(stream);
+}
+
+#endif
+/**********************************************************************/
+#ifdef L_fgetws
+
+UNLOCKED(wchar_t *,fgetws,(wchar_t *__restrict ws, int n,
+ FILE *__restrict stream),(ws, n, stream))
+{
+ register wchar_t *p = ws;
+ wint_t wi;
+
+ while ((n > 1)
+ && ((wi = fgetwc_unlocked(stream)) != WEOF)
+ && ((*p++ = wi) != '\n')
+ ) {
+ --n;
+ }
+ if (p == ws) {
+ /* TODO -- should we set errno? */
+/* if (n <= 0) { */
+/* errno = EINVAL; */
+/* } */
+ return NULL;
+ }
+ *p = 0;
+ return ws;
+}
+
+#endif
+/**********************************************************************/
+#ifdef L_fputwc
+
+UNLOCKED(wint_t,fputwc,(wchar_t wc, FILE *stream),(wc, stream))
+{
+#if 0
+ size_t r;
+ char buf[MB_LEN_MAX];
+
+ if (stream->modeflags & __FLAG_NARROW) {
+ stream->modeflags |= __FLAG_ERROR;
+ __set_errno(EBADF);
+ return WEOF;
+ }
+ stream->modeflags |= __FLAG_WIDE;
+
+ /* TODO:
+ * If stream is in reading state with bad mbstate object, what to do?
+ * Should we check the state first? Should we check error indicator?
+ * Should we check reading or even read-only?
+ */
+ /* It looks like the only ANSI/ISO C99 - blessed way of manipulating
+ * the stream's mbstate object is through fgetpos/fsetpos. */
+ r = wcrtomb(buf, wc, &stream->state);
+
+ return (r != ((size_t) -1) && (r == _stdio_fwrite(buf, r, stream)))
+ ? wc : WEOF;
+
+#elif 0
+
+ /* this is broken if wc == 0 !!! */
+ wchar_t wbuf[2];
+
+ wbuf[0] = wc;
+ wbuf[1] = 0;
+
+ return (fputws_unlocked(wbuf, stream) > 0) ? wc : WEOF;
+
+#else
+
+ size_t n;
+ char buf[MB_LEN_MAX];
+
+ if (stream->modeflags & __FLAG_NARROW) {
+ stream->modeflags |= __FLAG_ERROR;
+ __set_errno(EBADF);
+ return WEOF;
+ }
+ stream->modeflags |= __FLAG_WIDE;
+
+ return (((n = wcrtomb(buf, wc, &stream->state)) != ((size_t)-1)) /* EILSEQ */
+ && (_stdio_fwrite(buf, n, stream) != n))/* Didn't write everything. */
+ ? wc : WEOF;
+
+#endif
+}
+
+strong_alias(fputwc_unlocked,putwc_unlocked);
+strong_alias(fputwc,putwc);
+
+#endif
+/**********************************************************************/
+#ifdef L_putwchar
+
+UNLOCKED_STREAM(wint_t,putwchar,(wchar_t wc),(wc),stdout)
+{
+ register FILE *stream = stdout; /* This helps bcc optimize. */
+
+ return fputwc_unlocked(wc, stream);
+}
+
+#endif
+/**********************************************************************/
+#ifdef L_fputws
+
+UNLOCKED(int,fputws,(const wchar_t *__restrict ws,
+ register FILE *__restrict stream),(ws, stream))
+{
+#if 1
+ size_t n;
+ char buf[64];
+
+ if (stream->modeflags & __FLAG_NARROW) {
+ stream->modeflags |= __FLAG_ERROR;
+ __set_errno(EBADF);
+ return -1;
+ }
+ stream->modeflags |= __FLAG_WIDE;
+
+ while ((n = wcsrtombs(buf, &ws, sizeof(buf), &stream->state)) != 0) {
+ /* Wasn't an empty wide string. */
+ if ((n == ((size_t) -1))/* Encoding error! */
+ || (_stdio_fwrite(buf, n, stream) != n)/* Didn't write everything. */
+ ) {
+ return -1;
+ }
+ if (!ws) { /* Done? */
+ break;
+ }
+ }
+
+ return 1;
+
+
+
+
+#elif 1
+ int result;
+ size_t n;
+ size_t len;
+ register char *s;
+ unsigned char *bufend;
+ char sbuf[MB_LEN_MAX];
+
+ if (stream->modeflags & __FLAG_NARROW) {
+ RETURN_BADF:
+ stream->modeflags |= __FLAG_ERROR;
+ __set_errno(EBADF);
+ return -1;
+ }
+ stream->modeflags |= __FLAG_WIDE;
+
+ /* Note: What follows is setup grabbed from _stdio_fwrite and modified
+ * slightly. Since this is a wide stream, we can ignore bufgetc and
+ * bufputc if present. They always == bufstart.
+ * It is unfortunate that we need to duplicate so much code here, but
+ * we need to do the stream setup before starting the wc->mb conversion. */
+
+ if ((stream->modeflags & __FLAG_READONLY)
+#ifndef __STDIO_AUTO_RW_TRANSITION
+ /* ANSI/ISO requires either at EOF or currently not reading. */
+ || ((stream->modeflags & (__FLAG_READING|__FLAG_EOF))
+ == __FLAG_READING)
+#endif /* __STDIO_AUTO_RW_TRANSITION */
+ ) {
+ /* TODO: This is for posix behavior if readonly. To save space, we
+ * use this errno for write attempt while reading, as no errno is
+ * specified by posix for this case, even though the restriction is
+ * mentioned in fopen(). */
+ goto RETURN_BADF;
+ }
+
+#ifdef __STDIO_AUTO_RW_TRANSITION
+ /* If reading, deal with ungots and read-buffered chars. */
+ if (stream->modeflags & __FLAG_READING) {
+ if (((stream->bufpos < stream->bufread)
+ || (stream->modeflags & __MASK_UNGOT))
+ /* If appending, we might as well seek to end to save a seek. */
+ /* TODO: set EOF in fseek when appropriate? */
+ && fseek(stream, 0L,
+ ((stream->modeflags & __FLAG_APPEND)
+ ? SEEK_END : SEEK_CUR))
+ ) {
+ /* Note: This differs from glibc's apparent behavior of
+ not setting the error flag and discarding the buffered
+ read data. */
+ stream->modeflags |= __FLAG_ERROR; /* fseek may not set this. */
+ return -1; /* Fail if we need to fseek but can't. */
+ }
+ /* Always reset even if fseek called (saves a test). */
+ stream->bufpos = stream->bufread = stream->bufstart;
+ stream->modeflags &= ~__FLAG_READING;
+ }
+#endif
+
+ /* Ok, the boilerplate from _stdio_fwrite is done. */
+
+ if (stream->bufpos > stream->bufstart) { /* Pending writes.. */
+ /* This is a performance penalty, but it simplifies the code below.
+ * If this is removed, the buffer sharing and while loop condition
+ * need to be modified below (at least). We at least save a little
+ * on the overhead by calling _stdio_fwrite directly instead of
+ * fflush_unlocked. */
+ if (_stdio_fwrite(NULL, 0, stream) > 0) {/* fflush incomplete! */
+ return -1;
+ }
+ }
+
+ stream->modeflags |= __FLAG_WRITING; /* Ensure Writing flag is set. */
+
+ /* Next, we "steal" the stream's buffer and do the wc->mb conversion
+ * straight into it. This will cause the equivalent of an fflush
+ * for each string write. :-( */
+
+ bufend = NULL;
+ s = stream->bufstart;
+
+ if ((len = stream->bufend - stream->bufstart) < MB_LEN_MAX) {
+ /* Stream is unbuffered or buffer is too small, so deactivate. */
+ bufend = stream->bufend;
+ stream->bufend = stream->bufstart;
+ s = sbuf;
+ len = MB_LEN_MAX;
+ }
+
+ result = 1; /* Assume success. */
+ while (ws && (n = wcsrtombs(s, &ws, len, &stream->state)) != 0) {
+ if ((n == ((size_t) -1)) /* Encoding error! */
+ /* TODO - maybe call write directly? but what about custom streams? */
+ || (_stdio_fwrite(s, n, stream) != n)/* Didn't write everything. */
+ ) {
+ result = -1;
+ break;
+ }
+ }
+
+ if (bufend) { /* If deactivated stream buffer, renable it. */
+ stream->bufend = bufend;
+ }
+
+ return result;
+
+#else /* slow, dumb version */
+ while (*ws) {
+ if (fputwc_unlocked(*ws, stream) == WEOF) {
+ return -1;
+ }
+ ++ws;
+ }
+ return 1;
+#endif
+}
+
+#endif
+/**********************************************************************/
+#ifdef L_ungetwc
+/*
+ * Note: This is the application-callable ungetwc. If wscanf calls this, it
+ * should also set stream->ungot[1] to 0 if this is the only ungot.
+ */
+
+/* Reentrant. */
+
+wint_t ungetwc(wint_t c, register FILE *stream)
+{
+ __STDIO_THREADLOCK(stream);
+
+ __stdio_validate_FILE(stream); /* debugging only */
+
+ if (stream->modeflags & __FLAG_NARROW) {
+ stream->modeflags |= __FLAG_ERROR;
+ c = WEOF;
+ goto DONE;
+ }
+ stream->modeflags |= __FLAG_WIDE;
+
+ /* If can't read or there's been an error, or c == EOF, or ungot slots
+ * already filled, then return EOF */
+ if ((stream->modeflags
+ & (__MASK_UNGOT2|__FLAG_WRITEONLY
+#ifndef __STDIO_AUTO_RW_TRANSITION
+ |__FLAG_WRITING /* Note: technically no, but yes in spirit */
+#endif /* __STDIO_AUTO_RW_TRANSITION */
+ ))
+ || ((stream->modeflags & __MASK_UNGOT1) && (stream->ungot[1]))
+ || (c == WEOF) ) {
+ c = WEOF;
+ goto DONE;;
+ }
+
+/* ungot_width */
+
+#ifdef __STDIO_BUFFERS
+ /* TODO: shouldn't allow writing??? */
+ if (stream->modeflags & __FLAG_WRITING) {
+ fflush_unlocked(stream); /* Commit any write-buffered chars. */
+ }
+#endif /* __STDIO_BUFFERS */
+
+ /* Clear EOF and WRITING flags, and set READING FLAG */
+ stream->modeflags &= ~(__FLAG_EOF|__FLAG_WRITING);
+ stream->modeflags |= __FLAG_READING;
+ stream->ungot[1] = 1; /* Flag as app ungetc call; wscanf fixes up. */
+ stream->ungot[(stream->modeflags++) & __MASK_UNGOT] = c;
+
+ __stdio_validate_FILE(stream); /* debugging only */
+
+ DONE:
+ __STDIO_THREADUNLOCK(stream);
+
+ return c;
+}
+
+#endif
+/**********************************************************************/
#include <string.h>
#include <errno.h>
#include <locale.h>
+#include <ctype.h>
/* We know wide char support is enabled. We wouldn't be here otherwise. */
* towctrans function. */
/* #define SMALL_UPLOW */
+#ifndef __LOCALE_C_ONLY
#define __WCTYPE_WITH_LOCALE
+#endif
/**********************************************************************/
/**********************************************************************/
#ifdef L_iswctype
+#warning duh... replace the range-based classification with table lookup!
+
+#ifdef __WCTYPE_WITH_LOCALE
+
#warning TODO: need to fix locale ctype table lookup stuff
#if 0
extern const char ctype_range[];
return 0;
}
+#else
+
+static const unsigned char WCctype[] = {
+ __CTYPE_cntrl_nonspace | (__CTYPE_cntrl_nonspace << 4),
+ __CTYPE_cntrl_nonspace | (__CTYPE_cntrl_nonspace << 4),
+ __CTYPE_cntrl_nonspace | (__CTYPE_cntrl_nonspace << 4),
+ __CTYPE_cntrl_nonspace | (__CTYPE_cntrl_nonspace << 4),
+ __CTYPE_cntrl_nonspace | (__CTYPE_cntrl_space_blank << 4),
+ __CTYPE_cntrl_space_nonblank | (__CTYPE_cntrl_space_nonblank << 4),
+ __CTYPE_cntrl_space_nonblank | (__CTYPE_cntrl_space_nonblank << 4),
+ __CTYPE_cntrl_nonspace | (__CTYPE_cntrl_nonspace << 4),
+ __CTYPE_cntrl_nonspace | (__CTYPE_cntrl_nonspace << 4),
+ __CTYPE_cntrl_nonspace | (__CTYPE_cntrl_nonspace << 4),
+ __CTYPE_cntrl_nonspace | (__CTYPE_cntrl_nonspace << 4),
+ __CTYPE_cntrl_nonspace | (__CTYPE_cntrl_nonspace << 4),
+ __CTYPE_cntrl_nonspace | (__CTYPE_cntrl_nonspace << 4),
+ __CTYPE_cntrl_nonspace | (__CTYPE_cntrl_nonspace << 4),
+ __CTYPE_cntrl_nonspace | (__CTYPE_cntrl_nonspace << 4),
+ __CTYPE_cntrl_nonspace | (__CTYPE_cntrl_nonspace << 4),
+ __CTYPE_print_space_blank | (__CTYPE_punct << 4),
+ __CTYPE_punct | (__CTYPE_punct << 4),
+ __CTYPE_punct | (__CTYPE_punct << 4),
+ __CTYPE_punct | (__CTYPE_punct << 4),
+ __CTYPE_punct | (__CTYPE_punct << 4),
+ __CTYPE_punct | (__CTYPE_punct << 4),
+ __CTYPE_punct | (__CTYPE_punct << 4),
+ __CTYPE_punct | (__CTYPE_punct << 4),
+ __CTYPE_digit | (__CTYPE_digit << 4),
+ __CTYPE_digit | (__CTYPE_digit << 4),
+ __CTYPE_digit | (__CTYPE_digit << 4),
+ __CTYPE_digit | (__CTYPE_digit << 4),
+ __CTYPE_digit | (__CTYPE_digit << 4),
+ __CTYPE_punct | (__CTYPE_punct << 4),
+ __CTYPE_punct | (__CTYPE_punct << 4),
+ __CTYPE_punct | (__CTYPE_punct << 4),
+ __CTYPE_punct | (__CTYPE_alpha_upper << 4),
+ __CTYPE_alpha_upper | (__CTYPE_alpha_upper << 4),
+ __CTYPE_alpha_upper | (__CTYPE_alpha_upper << 4),
+ __CTYPE_alpha_upper | (__CTYPE_alpha_upper << 4),
+ __CTYPE_alpha_upper | (__CTYPE_alpha_upper << 4),
+ __CTYPE_alpha_upper | (__CTYPE_alpha_upper << 4),
+ __CTYPE_alpha_upper | (__CTYPE_alpha_upper << 4),
+ __CTYPE_alpha_upper | (__CTYPE_alpha_upper << 4),
+ __CTYPE_alpha_upper | (__CTYPE_alpha_upper << 4),
+ __CTYPE_alpha_upper | (__CTYPE_alpha_upper << 4),
+ __CTYPE_alpha_upper | (__CTYPE_alpha_upper << 4),
+ __CTYPE_alpha_upper | (__CTYPE_alpha_upper << 4),
+ __CTYPE_alpha_upper | (__CTYPE_alpha_upper << 4),
+ __CTYPE_alpha_upper | (__CTYPE_punct << 4),
+ __CTYPE_punct | (__CTYPE_punct << 4),
+ __CTYPE_punct | (__CTYPE_punct << 4),
+ __CTYPE_punct | (__CTYPE_alpha_lower << 4),
+ __CTYPE_alpha_lower | (__CTYPE_alpha_lower << 4),
+ __CTYPE_alpha_lower | (__CTYPE_alpha_lower << 4),
+ __CTYPE_alpha_lower | (__CTYPE_alpha_lower << 4),
+ __CTYPE_alpha_lower | (__CTYPE_alpha_lower << 4),
+ __CTYPE_alpha_lower | (__CTYPE_alpha_lower << 4),
+ __CTYPE_alpha_lower | (__CTYPE_alpha_lower << 4),
+ __CTYPE_alpha_lower | (__CTYPE_alpha_lower << 4),
+ __CTYPE_alpha_lower | (__CTYPE_alpha_lower << 4),
+ __CTYPE_alpha_lower | (__CTYPE_alpha_lower << 4),
+ __CTYPE_alpha_lower | (__CTYPE_alpha_lower << 4),
+ __CTYPE_alpha_lower | (__CTYPE_alpha_lower << 4),
+ __CTYPE_alpha_lower | (__CTYPE_alpha_lower << 4),
+ __CTYPE_alpha_lower | (__CTYPE_punct << 4),
+ __CTYPE_punct | (__CTYPE_punct << 4),
+ __CTYPE_punct | (__CTYPE_cntrl_nonspace << 4),
+};
+
+static const char ctype_range[] = {
+ __CTYPE_RANGES
+};
+
+int iswctype(wint_t wc, wctype_t desc)
+{
+ unsigned char d = __CTYPE_unclassified;
+
+ if (((__uwchar_t) wc) <= 0x7f) {
+ if (desc < _CTYPE_iswxdigit) {
+ d = WCctype[wc >> 1];
+ d = (wc & 1) ? (d >> 4) : (d & 0xf);
+
+ return ( ((unsigned char)(d - ctype_range[2*desc]))
+ <= ctype_range[2*desc + 1] )
+ && ((desc != _CTYPE_iswblank) || (d & 1));
+ }
+
+ if (desc == _CTYPE_iswxdigit) {
+ return __C_isxdigit(((char) wc));
+ }
+ }
+ return 0;
+}
+
+#endif
+
#endif
/**********************************************************************/
#ifdef L_towctrans
#endif
-#else
+#else /* __WCTYPE_WITH_LOCALE */
+/* Minimal support for C/POSIX locale. */
-#endif
+wint_t towctrans(wint_t wc, wctrans_t desc)
+{
+ if (((unsigned int)(desc - _CTYPE_tolower))
+ <= (_CTYPE_toupper - _CTYPE_tolower)
+ ) {
+ /* Transliteration is either tolower or toupper. */
+ if (((__uwchar_t) wc) <= 0x7f) {
+ return (desc == _CTYPE_tolower) ? _tolower(wc) : _toupper(wc);
+ }
+ } else {
+ __set_errno(EINVAL); /* Invalid transliteration. */
+ }
+ return wc;
+}
+
+#endif /* __WCTYPE_WITH_LOCALE */
#endif
/**********************************************************************/
__fsetlocking.o flockfile.o ftrylockfile.o funlockfile.o \
_stdio_fopen.o _stdio_fread.o _stdio_fwrite.o _stdio_adjpos.o \
_stdio_lseek.o _stdio_init.o \
- _stdio_fsfopen.o _stdio_fdout.o _uintmaxtostr.o _stdio_strerror_r.o
+ _stdio_fsfopen.o _stdio_fdout.o _uintmaxtostr.o _stdio_strerror_r.o \
+ getdelim.o getline.o ctermid.o
# ifeq ($(DOLFS),true)
# MOBJ += fopen64.o freopen64.o ftello64.o fseeko64.o fsetpos64.o fgetpos64.o
MSRC3=scanf.c
MOBJ3=scanf.o sscanf.o fscanf.o vscanf.o vsscanf.o vfscanf.o
-CSRC=popen.c getdelim.c getline.c tmpfile.c tmpnam.c \
- tmpnam_r.c tempnam.c ctermid.c
+CSRC=popen.c tmpfile.c tmpnam.c tmpnam_r.c tempnam.c
ifeq ($(USE_OLD_VFPRINTF),true)
CSRC += old_vfprintf.c
endif
/* #define __isdigit(c) (((unsigned int)(c - '0')) < 10) */
+#if defined(__UCLIBC_HAS_FLOATS__)
extern size_t _dtostr(FILE * fp, long double x, struct printf_info *info);
+#endif
enum {
va_list ap)
{
int i, cnt, lval, len;
- char *p;
+ register char *p;
const char *fmt0;
int preci, width;
#define upcase i
p = _uintmaxtostr((tmp + sizeof(tmp) - 1),
((lval>1) /* TODO -- longlong/long/int/short/char */
? va_arg(ap, uintmax_t)
- : (uintmax_t) ((long long) /* sign-extend! */
+ : (uintmax_t) ((intmax_t) /* sign-extend! */
va_arg(ap, long))),
-radix, upcase);
#define __PA_FLAG_INTMASK \
(__PA_FLAG_CHAR|PA_FLAG_SHORT|__PA_FLAG_INT|PA_FLAG_LONG|PA_FLAG_LONG_LONG)
-extern printf_function *_custom_printf_handler[MAX_USER_SPEC];
+extern printf_function _custom_printf_handler[MAX_USER_SPEC];
extern printf_arginfo_function *_custom_printf_arginfo[MAX_USER_SPEC];
extern char *_custom_printf_spec;
*/
/* 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
+/* #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!
#ifdef SS
#error SS already defined!
#endif
+#ifdef IMS
+#error IMS already defined!
+#endif
#if PTRDIFF_MAX == INT_MAX
#define PDS 0
#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 Z:(s)size_t */ \
'h', 'l', 'L', 'j', 'z', 't', 'q', 'Z', 0, \
- 2, 4, 8, 8, SS, PDS, 8, SS, 0, /* TODO -- fix!!! */\
+ 2, 4, 8, IMS, SS, PDS, 8, SS, 0, /* TODO -- fix!!! */\
1, 8 \
}
*/
size_t parse_printf_format(register const char *template,
- size_t n, int *argtypes)
+ size_t n, register int *argtypes)
{
ppfs_t ppfs;
size_t i;
/**********************************************************************/
#ifdef L__do_one_spec
-printf_function *_custom_printf_handler[MAX_USER_SPEC];
+printf_function _custom_printf_handler[MAX_USER_SPEC];
extern void _store_inttype(void *dest, int desttype, uintmax_t val);
extern uintmax_t _load_inttype(int desttype, const void *src, int uflag);
#endif
/**********************************************************************/
#ifdef L_vsnprintf
+
#ifdef __STDIO_BUFFERS
int vsnprintf(char *__restrict buf, size_t size,
const char * __restrict format, va_list arg)
#ifdef __STDIO_GETC_MACRO
f.bufgetc =
#endif
- f.bufrpos = f.bufwpos = f.bufstart = buf;
+ f.bufpos = f.bufread = f.bufstart = buf;
if (size > SIZE_MAX - (size_t) buf) {
size = SIZE_MAX - (size_t) buf;
f.filedes = -2; /* for debugging */
f.modeflags = (__FLAG_NARROW|__FLAG_WRITEONLY|__FLAG_WRITING);
+#ifdef __STDIO_MBSTATE
+ __INIT_MBSTATE(&(f.state));
+#endif /* __STDIO_MBSTATE */
+
#ifdef __STDIO_THREADSAFE
__stdio_init_mutex(&f.lock);
#endif
rv = vfprintf(&f, format, arg);
if (size) {
- if (f.bufwpos == f.bufend) {
- --f.bufwpos;
+ if (f.bufpos == f.bufend) {
+ --f.bufpos;
}
- *f.bufwpos = 0;
+ *f.bufpos = 0;
}
return rv;
}
#define COOKIE ((__snpf_cookie *) cookie)
-static ssize_t snpf_write(void *cookie, const char *buf, size_t bufsize)
+static ssize_t snpf_write(register void *cookie, const char *buf,
+ size_t bufsize)
{
size_t count;
- char *p;
+ register char *p;
/* Note: bufsize < SSIZE_MAX because of _stdio_WRITE. */
f.filedes = -1; /* For debugging. */
f.modeflags = (__FLAG_NARROW|__FLAG_WRITEONLY|__FLAG_WRITING);
+#ifdef __STDIO_MBSTATE
+ __INIT_MBSTATE(&(f.state));
+#endif /* __STDIO_MBSTATE */
+
#ifdef __STDIO_THREADSAFE
__stdio_init_mutex(&f.lock);
#endif
#endif
/**********************************************************************/
#ifdef L_vdprintf
+
int vdprintf(int filedes, const char * __restrict format, va_list arg)
{
FILE f;
#ifdef __STDIO_GETC_MACRO
f.bufgetc =
#endif
- f.bufrpos = f.bufwpos = f.bufstart = buf;
+ f.bufpos = f.bufread = f.bufstart = buf;
#ifdef __STDIO_PUTC_MACRO
f.bufputc =
#endif
f.filedes = filedes;
f.modeflags = (__FLAG_NARROW|__FLAG_WRITEONLY|__FLAG_WRITING);
+#ifdef __STDIO_MBSTATE
+ __INIT_MBSTATE(&(f.state));
+#endif /* __STDIO_MBSTATE */
+
#ifdef __STDIO_THREADSAFE
__stdio_init_mutex(&f.lock);
#endif
return fflush(&f) ? -1 : rv;
}
+
#endif
/**********************************************************************/
#ifdef L_vasprintf
#endif
/**********************************************************************/
#ifdef L_fprintf
+
int fprintf(FILE * __restrict stream, const char * __restrict format, ...)
{
va_list arg;
return rv;
}
+
#endif
/**********************************************************************/
#ifdef L_snprintf
#endif
/**********************************************************************/
#ifdef L_dprintf
+
int dprintf(int filedes, const char * __restrict format, ...)
{
va_list arg;
return rv;
}
+
#endif
/**********************************************************************/
#ifdef L_asprintf
/**********************************************************************/
#ifdef L__load_inttype
-extern uintmax_t _load_inttype(int desttype, const void *src, int uflag)
+extern uintmax_t _load_inttype(int desttype, register const void *src,
+ int uflag)
{
if (uflag >= 0) { /* unsigned */
#if LONG_MAX != INT_MAX
* implementation doesn't for the "100ergs" case mentioned above.
*/
+#define _ISOC99_SOURCE /* for LLONG_MAX primarily... */
#define _GNU_SOURCE
-#include <features.h>
-#if defined(__UCLIBC__) && !defined(__USE_ISOC99)
-#define __USE_ISOC99
-#endif
-
#define _STDIO_UTILITY
#include <stdio.h>
#include <stdlib.h>
string->filedes = -2; /* for debugging */
string->modeflags = (__FLAG_NARROW|__FLAG_READONLY);
- string->bufstart = string->bufrpos = (unsigned char *) ((void *) sp);
+ string->bufstart = string->bufpos = (unsigned char *) ((void *) sp);
string->bufgetc = (char *) ((unsigned) -1);
+#ifdef __STDIO_MBSTATE
+ __INIT_MBSTATE(&(string->state));
+#endif /* __STDIO_MBSTATE */
+
#ifdef __STDIO_THREADSAFE
__stdio_init_mutex(&string->lock);
#endif
extern unsigned long
_stdlib_strto_l(register const char * __restrict str,
char ** __restrict endptr, int base, int sflag);
+#ifdef LLONG_MAX
extern unsigned long long
_stdlib_strto_ll(register const char * __restrict str,
char ** __restrict endptr, int base, int sflag);
+#endif
struct scan_cookie {
FILE *fp;
/* radix[i] <-> spec[i+5] o u p x X i d */
static const char radix[] = { 8, 10, 16, 16, 16, 0, 10 };
-static void init_scan_cookie(struct scan_cookie *sc, FILE *fp)
+static void init_scan_cookie(register struct scan_cookie *sc,
+ register FILE *fp)
{
sc->fp = fp;
sc->nread = 0;
/* TODO -- what about literal '\0' chars in a file??? */
-static int scan_getc_nw(struct scan_cookie *sc)
+static int scan_getc_nw(register struct scan_cookie *sc)
{
if (sc->ungot_flag == 0) {
sc->ungot_char = getc(sc->fp);
return sc->ungot_char;
}
-static int scan_getc(struct scan_cookie *sc)
+static int scan_getc(register struct scan_cookie *sc)
{
if (sc->ungot_flag == 0) {
sc->ungot_char = getc(sc->fp);
return sc->ungot_char;
}
-static void scan_ungetc(struct scan_cookie *sc)
+static void scan_ungetc(register struct scan_cookie *sc)
{
if (sc->ungot_flag != 0) {
assert(sc->width < 0);
}
}
-static void kill_scan_cookie(struct scan_cookie *sc)
+static void kill_scan_cookie(register struct scan_cookie *sc)
{
if (sc->ungot_flag) {
ungetc(sc->ungot_char,sc->fp);
}
}
-int vfscanf(fp, format, ap)
-FILE *fp;
-const char *format;
-va_list ap;
+int vfscanf(FILE *fp, const char *format, va_list ap)
{
#ifdef __UCLIBC_HAS_LONG_LONG__
#define STRTO_L_(s,e,b,sf) _stdlib_strto_ll(s,e,b,sf)
#endif
UV_TYPE uv;
struct scan_cookie sc;
- unsigned const char *fmt;
+ register unsigned const char *fmt;
const char *p;
- unsigned char *b;
+ register unsigned char *b;
void *vp;
int cc, i, cnt;
signed char lval;
*((unsigned int *)vp) = (unsigned int)uv;
break;
#endif
- case -1:
+ case (signed char)(-1):
if (usflag) {
if (uv > USHRT_MAX) {
uv = USHRT_MAX;
}
*((unsigned short *)vp) = (unsigned short)uv;
break;
- case -2:
+ case (signed char)(-2):
if (usflag) {
if (uv > UCHAR_MAX) {
uv = UCHAR_MAX;
*
* ATTENTION! ATTENTION! ATTENTION! ATTENTION! ATTENTION! */
+/* Before we include anything, convert L_ctermid to L_ctermid_function
+ * and undef L_ctermid if defined. This is necessary as L_ctermid is
+ * a SUSv3 standard macro defined in stdio.h. */
+#ifdef L_ctermid
+#define L_ctermid_function
+#undef L_ctermid
+#endif
+
#define _ISOC99_SOURCE /* for ULLONG primarily... */
#define _GNU_SOURCE
#define _STDIO_UTILITY /* for _stdio_fdout and _uintmaxtostr. */
/**********************************************************************/
-/* TODO -- make this the default except for bcc with it's broken preproc? */
-#ifdef __UCLIBC__
-#define _stdin stdin
-#define _stdout stdout
-#define _stderr stderr
-#endif /* __UCLIBC__ */
-
-/**********************************************************************/
-
#ifndef __STDIO_THREADSAFE
+#ifdef __BCC__
+#define UNLOCKED_STREAM(RETURNTYPE,NAME,PARAMS,ARGS,STREAM) \
+asm(".text\nexport _" "NAME" "_unlocked\n_" "NAME" "_unlocked = _" "NAME"); \
+RETURNTYPE NAME PARAMS
+#else
#define UNLOCKED_STREAM(RETURNTYPE,NAME,PARAMS,ARGS,STREAM) \
strong_alias(NAME,NAME##_unlocked) \
RETURNTYPE NAME PARAMS
+#endif
#define UNLOCKED(RETURNTYPE,NAME,PARAMS,ARGS) \
UNLOCKED_STREAM(RETURNTYPE,NAME,PARAMS,ARGS,stream)
+#ifdef __BCC__
+#define UNLOCKED_VOID_RETURN(NAME,PARAMS,ARGS) \
+asm(".text\nexport _" "NAME" "_unlocked\n_" "NAME" "_unlocked = _" "NAME"); \
+void NAME PARAMS
+#else
#define UNLOCKED_VOID_RETURN(NAME,PARAMS,ARGS) \
strong_alias(NAME,NAME##_unlocked) \
void NAME PARAMS
+#endif
#define __STDIO_THREADLOCK_OPENLIST
#define __STDIO_THREADUNLOCK_OPENLIST
#define __STDIO_FILE_INIT_CUSTOM_STREAM(stream)
#endif
+#ifdef __STDIO_MBSTATE
+#define __STDIO_FILE_INIT_MBSTATE \
+ { 0, 0 },
+#else
+#define __STDIO_FILE_INIT_MBSTATE
+#endif
+
+
#ifdef __STDIO_THREADSAFE
#define __STDIO_FILE_INIT_THREADSAFE \
0, PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP,
__STDIO_FILE_INIT_BUFGETC((buf)) \
__STDIO_FILE_INIT_BUFPUTC((buf)) \
__STDIO_FILE_INIT_CUSTOM_STREAM(stream) \
+ __STDIO_FILE_INIT_MBSTATE \
__STDIO_FILE_INIT_THREADSAFE \
} /* TODO: mbstate and builtin buf */
-#ifdef __STDIO_MBSTATE_DATA
-extern void _init_mbstate(mbstate_t *dest);
-
-#define __COMMA_CLEAN_MBSTATE , 0
-#define __COPY_MBSTATE(dest,src) memcpy(dest, src, sizeof(mbstate_t))
-#define __INIT_MBSTATE(dest) _init_mbstate(dest)
-#else
-#define __COMMA_CLEAN_MBSTATE
-#define __COPY_MBSTATE(dest,src)
-#define __INIT_MBSTATE(dest)
-#endif
-
#ifdef __STDIO_GLIBC_CUSTOM_STREAMS
/* TODO -- what does glibc do for undefined funcs? errno set? */
/* SUSv2 Legacy function -- need not be reentrant. */
-int getw (register FILE *stream)
+int getw(FILE *stream)
{
int aw[1];
/* SUSv2 Legacy function -- need not be reentrant. */
-int putw (int w, register FILE *stream)
+int putw(int w, FILE *stream)
{
int aw[1];
#endif
/**********************************************************************/
+#ifdef L_ctermid_function
+
+/* Not required to be reentrant. */
+
+char *ctermid(register char *s)
+{
+ static char sbuf[L_ctermid];
+
+#ifdef __BCC__
+ /* Currently elks doesn't support /dev/tty. */
+ if (!s) {
+ s = sbuf;
+ }
+ *s = 0;
+
+ return s;
+#else
+ /* glibc always returns /dev/tty for linux. */
+ return strcpy((s ? s : sbuf), "/dev/tty");
+#endif
+}
+
+#endif
+/**********************************************************************/
/* BSD functions */
/**********************************************************************/
#ifdef L_setbuffer
#define COOKIE ((__fmo_cookie *) cookie)
-static ssize_t fmo_read(void *cookie, register char *buf, size_t bufsize)
+static ssize_t fmo_read(register void *cookie, char *buf, size_t bufsize)
{
size_t count = COOKIE->len - COOKIE->pos;
return bufsize;
}
-static ssize_t fmo_write(void *cookie, register const char *buf, size_t bufsize)
+static ssize_t fmo_write(register void *cookie, const char *buf, size_t bufsize)
{
size_t count;
}
/* glibc doesn't allow seeking, but it has in-buffer seeks... we don't. */
-static int fmo_seek(void *cookie, __offmax_t *pos, int whence)
+static int fmo_seek(register void *cookie, __offmax_t *pos, int whence)
{
__offmax_t p = *pos;
return 0;
}
-static int fmo_close(void *cookie)
+static int fmo_close(register void *cookie)
{
if (COOKIE->dynbuf) {
free(COOKIE->buf);
FILE *fmemopen(void *s, size_t len, const char *modes)
{
FILE *fp;
- __fmo_cookie *cookie;
+ register __fmo_cookie *cookie;
size_t i;
if ((cookie = malloc(sizeof(__fmo_cookie))) != NULL) {
/* { */
/* } */
-static ssize_t oms_write(void *cookie, const char *buf, size_t bufsize)
+static ssize_t oms_write(register void *cookie, const char *buf, size_t bufsize)
{
- char *newbuf;
+ register char *newbuf;
size_t count;
/* Note: we already know bufsize < SSIZE_MAX... */
return bufsize;
}
-static int oms_seek(void *cookie, __offmax_t *pos, int whence)
+static int oms_seek(register void *cookie, __offmax_t *pos, int whence)
{
__offmax_t p = *pos;
- char *buf;
+ register char *buf;
size_t leastlen;
/* Note: fseek already checks that whence is legal, so don't check here
FILE *open_memstream(char **__restrict bufloc, size_t *__restrict sizeloc)
{
- __oms_cookie *cookie;
- FILE *fp;
+ register __oms_cookie *cookie;
+ register FILE *fp;
if ((cookie = malloc(sizeof(__oms_cookie))) != NULL) {
if ((cookie->buf = malloc(cookie->len = BUFSIZ)) == NULL) {
#ifndef __BCC__
-FILE *fopencookie (void * __restrict cookie, const char * __restrict mode,
- cookie_io_functions_t io_functions)
+FILE *fopencookie(void * __restrict cookie, const char * __restrict mode,
+ cookie_io_functions_t io_functions)
{
FILE *stream;
int fd;
* instead.
*/
-FILE *_fopencookie (void * __restrict cookie, const char * __restrict mode,
- cookie_io_functions_t *io_functions)
+FILE *_fopencookie(void * __restrict cookie, const char * __restrict mode,
+ register cookie_io_functions_t *io_functions)
{
- FILE *stream;
+ register FILE *stream;
if ((stream = _stdio_fopen("/dev/null", mode, NULL, -1)) != NULL) {
int fd = stream->filedes;
#ifdef __STDIO_GETC_MACRO
stream->bufgetc = /* Must disable getc. */
#endif
- stream->bufwpos = stream->bufrpos = stream->bufstart; /* Reset pointers. */
+ stream->bufpos = stream->bufread = stream->bufstart; /* Reset pointers. */
#endif /* __STDIO_BUFFERS */
/* Reset r/w flags and clear ungots. */
stream->modeflags &= ~(__FLAG_READING|__FLAG_WRITING|__MASK_UNGOT);
/* Not reentrant. */
#ifdef __STDIO_WIDE
-#warning TODO -- implement __fpending for wide streams! */
-#else /* __STDIO_WIDE */
+#warning unlike the glibc version, this __fpending returns bytes in buffer for wide streams too!
+
+link_warning(__fpending, "This version of __fpending returns bytes remaining in buffer for both narrow and wide streams. glibc's version returns wide chars in buffer for the wide stream case.")
+
+#endif /* __STDIO_WIDE */
+
size_t __fpending(register FILE * __restrict stream)
{
#ifdef __STDIO_BUFFERS
/* TODO -- should we check this? should we set errno? just assert? */
return (stream->modeflags & (__FLAG_READING|__FLAG_READONLY))
- ? 0 : (stream->bufwpos - stream->bufstart);
+ ? 0 : (stream->bufpos - stream->bufstart);
#else /* __STDIO_BUFFERS */
return 0;
#endif /* __STDIO_BUFFERS */
}
-#endif /* __STDIO_WIDE */
#endif
/**********************************************************************/
#endif
/**********************************************************************/
+#ifdef L_getline
+
+ssize_t getline(char **__restrict lineptr, size_t *__restrict n,
+ FILE *__restrict stream)
+{
+ return __getdelim(lineptr, n, '\n', stream);
+}
+
+#endif
+/**********************************************************************/
+#ifdef L_getdelim
+
+weak_alias(__getdelim,getdelim);
+
+#define GETDELIM_GROWBY 64
+
+ssize_t __getdelim(char **__restrict lineptr, size_t *__restrict n,
+ int delimiter, register FILE *__restrict stream)
+{
+ register char *buf;
+ size_t pos;
+ int c;
+
+ if (!lineptr || !n || !stream) { /* Be compatable with glibc... even */
+ __set_errno(EINVAL); /* though I think we should assert here */
+ return -1; /* if anything. */
+ }
+
+ if (!(buf = *lineptr)) { /* If passed NULL for buffer, */
+ *n = 0; /* ignore value passed and treat size as 0. */
+ }
+ pos = 1; /* Make sure we have space for terminating nul. */
+
+ __STDIO_THREADLOCK(stream);
+
+ do {
+ if (pos >= *n) {
+ if (!(buf = realloc(buf, *n + GETDELIM_GROWBY))) {
+ __set_errno(ENOMEM); /* Emulate old uClibc implementation. */
+ break;
+ }
+ *n += GETDELIM_GROWBY;
+ *lineptr = buf;
+ }
+ } while (((c = getc(stream)) != EOF) && ((buf[pos++ - 1] = c) != delimiter));
+
+ __STDIO_THREADUNLOCK(stream);
+
+ if (--pos) {
+ buf[pos] = 0;
+ return pos;
+ }
+
+ return -1; /* Either initial realloc failed or first read was EOF. */
+}
+
+#endif
+/**********************************************************************/
/* my extension functions */
/**********************************************************************/
#ifdef L__stdio_fsfopen
* then the file position is treated as unknown.
*/
-
/* Internal function -- not reentrant. */
-int _stdio_adjpos(register FILE * __restrict stream,
- register __offmax_t *pos)
+int _stdio_adjpos(register FILE * __restrict stream, register __offmax_t *pos)
{
__offmax_t r;
int cor = stream->modeflags & __MASK_UNGOT; /* handle ungots */
/* Assumed narrow stream so correct if wide. */
if (cor && (stream->modeflags & __FLAG_WIDE)) {
cor = cor - 1 + stream->ungot_width[0];
- if ((stream->ungot_width[0] == 0) /* don't know byte count or */
- || ((stream->modeflags & __MASK_UNGOT) > 1)) { /* app case */
- return -1;
+ if (((stream->modeflags & __MASK_UNGOT) > 1) || stream->ungot[1]) {
+ return -1; /* App did ungetwc, so position is indeterminate. */
}
+ assert(stream->ungot_width[0] > 0);
}
#endif /* __STDIO_WIDE */
#ifdef __STDIO_BUFFERS
if (stream->modeflags & __FLAG_WRITING) {
- cor -= (stream->bufwpos - stream->bufstart); /* pending writes */
+ cor -= (stream->bufpos - stream->bufstart); /* pending writes */
}
if (stream->modeflags & __FLAG_READING) {
- cor += (stream->bufwpos - stream->bufrpos); /* extra's read */
+ cor += (stream->bufread - stream->bufpos); /* extra's read */
}
#endif /* __STDIO_BUFFERS */
/* Internal function -- not reentrant. */
-int _stdio_lseek(FILE *stream, __offmax_t *pos, int whence)
+int _stdio_lseek(register FILE *stream, register __offmax_t *pos, int whence)
{
__offmax_t res;
/* Unlike write, it's ok for read to return fewer than bufsize, since
* we may not need all of them. */
-static ssize_t _stdio_READ(FILE *stream, void *buf, size_t bufsize)
+static ssize_t _stdio_READ(register FILE *stream, unsigned char *buf, size_t bufsize)
{
ssize_t rv;
/* Internal function -- not reentrant. */
-size_t _stdio_fread(unsigned char *buffer, size_t bytes,
- register FILE *stream)
+size_t _stdio_fread(unsigned char *buffer, size_t bytes, register FILE *stream)
{
__stdio_validate_FILE(stream); /* debugging only */
if (stream->modeflags & __MASK_BUFMODE) {
/* If the stream is readable and not fully buffered, we must first
* flush all line buffered output streams. Do this before the
- * error check as this may be a read/write line-buffered stream. */
- fflush((FILE *) &_stdio_openlist); /* Uses an implementation hack!!! */
+ * error check as this may be a read/write line-buffered stream.
+ * Note: Uses an implementation-specific hack!!! */
+ fflush_unlocked((FILE *) &_stdio_openlist);
}
#ifdef __STDIO_AUTO_RW_TRANSITION
- if ((stream->modeflags & __FLAG_WRITING) && (fflush(stream) == EOF)) {
+ if ((stream->modeflags & __FLAG_WRITING)
+ && (fflush_unlocked(stream) == EOF)
+ ) {
return 0; /* Fail if we need to fflush but can't. */
}
#endif /* __STDIO_AUTO_RW_TRANSITION */
/* Now get any other needed chars from the buffer or the file. */
FROM_BUF:
- while (bytes && (stream->bufrpos < stream->bufwpos)) {
+ while (bytes && (stream->bufpos < stream->bufread)) {
--bytes;
- *p++ = *stream->bufrpos++;
+ *p++ = *stream->bufpos++;
}
if (bytes > 0) {
ssize_t len;
/* The buffer is exhausted, but we still need chars. */
- stream->bufrpos = stream->bufwpos = stream->bufstart;
+ stream->bufpos = stream->bufread = stream->bufstart;
- if (bytes <= stream->bufend - stream->bufwpos) {
+ if (bytes <= stream->bufend - stream->bufread) {
/* We have sufficient space in the buffer. */
- len = _stdio_READ(stream, stream->bufwpos,
- stream->bufend - stream->bufwpos);
+ len = _stdio_READ(stream, stream->bufread,
+ stream->bufend - stream->bufread);
if (len > 0) {
- stream->bufwpos += len;
+ stream->bufread += len;
goto FROM_BUF;
}
} else {
#ifdef __STDIO_GETC_MACRO
if (!(stream->modeflags & (__FLAG_WIDE|__MASK_UNGOT|__MASK_BUFMODE))) {
- stream->bufgetc = stream->bufwpos; /* Enable getc macro. */
+ stream->bufgetc = stream->bufread; /* Enable getc macro. */
}
#endif
*deals correctly with bufsize > SSIZE_MAX... not much on an issue on linux
* but definitly could be on Elks. Also on Elks, always loops for EINTR..
* Returns number of bytes written, so a short write indicates an error */
-static size_t _stdio_WRITE(FILE *stream, const void *buf, size_t bufsize)
+static size_t _stdio_WRITE(register FILE *stream,
+ register const unsigned char *buf, size_t bufsize)
{
size_t todo;
ssize_t rv, stodo;
/* Internal function -- not reentrant. */
size_t _stdio_fwrite(const unsigned char *buffer, size_t bytes,
- register FILE *stream)
+ register FILE *stream)
{
#ifdef __STDIO_BUFFERS
register const unsigned char *p;
#ifdef __STDIO_AUTO_RW_TRANSITION
/* If reading, deal with ungots and read-buffered chars. */
if (stream->modeflags & __FLAG_READING) {
- if (((stream->bufrpos < stream->bufwpos)
+ if (((stream->bufpos < stream->bufread)
|| (stream->modeflags & __MASK_UNGOT))
/* If appending, we might as well seek to end to save a seek. */
/* TODO: set EOF in fseek when appropriate? */
#ifdef __STDIO_GETC_MACRO
stream->bufgetc =
#endif /* __STDIO_GETC_MACRO */
- stream->bufrpos = stream->bufwpos = stream->bufstart;
+ stream->bufpos = stream->bufread = stream->bufstart;
}
#endif
if (!buffer) { /* fflush the stream */
FFLUSH:
{
- size_t count = stream->bufwpos - stream->bufstart;
+ size_t count = stream->bufpos - stream->bufstart;
p = stream->bufstart;
if (stream->filedes == -2) { /* TODO -- document this hack! */
count -= rv;
}
- stream->bufwpos = stream->bufstart;
+ stream->bufpos = stream->bufstart;
while (count) {
- *stream->bufwpos++ = *p++;
+ *stream->bufpos++ = *p++;
--count;
}
if (!buffer) { /* fflush case... */
__stdio_validate_FILE(stream); /* debugging only */
- return stream->bufwpos - stream->bufstart;
+ return stream->bufpos - stream->bufstart;
}
}
}
#if 1
/* TODO: If the stream is buffered, we may be able to omit. */
- if ((stream->bufwpos == stream->bufstart) /* buf empty */
+ if ((stream->bufpos == stream->bufstart) /* buf empty */
&& (stream->bufend - stream->bufstart <= bytes) /* fills */
&& (stream->filedes != -2)) { /* not strinf fake file */
/* so want to do a direct write of supplied buffer */
#endif
/* otherwise buffer not empty and/or data fits */
{
- size_t count = stream->bufend - stream->bufwpos;
+ size_t count = stream->bufend - stream->bufpos;
p = buffer;
if (count > bytes) {
bytes -= count;
while (count) {
- *stream->bufwpos++ = *buffer++;
+ *stream->bufpos++ = *buffer++;
--count;
}
__STDIO_THREADLOCK(stream);
#ifdef __STDIO_BUFFERS
- assert(stream->bufstart <= stream->bufrpos);
- assert(stream->bufrpos <= stream->bufwpos);
- assert(stream->bufwpos <= stream->bufend);
- assert(stream->bufwpos <= stream->bufend);
+ assert(stream->bufstart <= stream->bufread);
+ if (stream->modeflags & (__FLAG_READING)) {
+ assert(stream->bufpos <= stream->bufread);
+ }
+ assert(stream->bufread <= stream->bufend);
+ assert(stream->bufpos <= stream->bufend);
if ((stream->modeflags & __MASK_BUFMODE) == __FLAG_NBF) {
assert(stream->bufstart == stream->bufend);
}
#endif
#ifdef __STDIO_GETC_MACRO
assert(stream->bufstart <= stream->bufgetc);
- assert(stream->bufgetc <= stream->bufwpos);
+ assert(stream->bufgetc <= stream->bufread);
if (stream->bufstart < stream->bufgetc) {
assert(stream->modeflags & (__FLAG_READING));
assert(!(stream->modeflags
2, 0, 0, 0 )
};
-FILE *_stdin = _stdio_streams + 0;
-FILE *_stdout = _stdio_streams + 1;
-FILE *_stderr = _stdio_streams + 2;
+FILE *stdin = _stdio_streams + 0;
+FILE *stdout = _stdio_streams + 1;
+FILE *stderr = _stdio_streams + 2;
#if defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS)
void _stdio_term(void)
{
#if defined(__STDIO_GLIBC_CUSTOM_STREAMS) || defined(__STDIO_THREADSAFE)
- FILE *ptr;
+ register FILE *ptr;
#endif
/* TODO: if called via a signal handler for a signal mid _stdio_fwrite,
/* TODO -- set an alarm and flush each file "by hand"? to avoid blocking? */
/* Now flush all streams. */
- fflush(NULL);
+ fflush_unlocked(NULL);
#endif /* __STDIO_BUFFERS */
/* Next close all custom streams in case of any special cleanup, but
/* TODO: "unbuffer" files like glibc does? Inconsistent with
* custom stream handling above, but that's necessary to deal
* with special user-defined close behavior. */
- stream->bufwpos = stream->bufrpos = stream->bufend
+ stream->bufpos = stream->bufread = stream->bufend
#ifdef __STDIO_GETC_MACRO
= stream->bufgetc
#endif
#ifdef __STDIO_BUFFERS
if (stream->modeflags & __FLAG_WRITING) {
- rv = fflush(stream); /* Write any pending buffered chars. */
- } /* Also disables putc macro if used. */
+ rv = fflush_unlocked(stream); /* Write any pending buffered chars. */
+ } /* Also disables putc macro if used. */
#ifdef __STDIO_GETC_MACRO
/* Not necessary after fflush, but always do this to reduce size. */
/* Internal function -- reentrant (locks open file list) */
FILE *_stdio_fopen(const char * __restrict filename,
- register const char * __restrict mode,
- register FILE * __restrict stream, int filedes)
+ register const char * __restrict mode,
+ register FILE * __restrict stream, int filedes)
{
__mode_t open_mode;
#ifdef __STDIO_PUTC_MACRO
stream->bufputc =
#endif
- stream->bufwpos = stream->bufrpos = stream->bufstart;
+ stream->bufpos = stream->bufread = stream->bufstart;
#endif /* __STDIO_BUFFERS */
#ifdef __STDIO_GLIBC_CUSTOM_STREAMS
stream->gcs.close = _cs_close;
#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */
+#ifdef __STDIO_MBSTATE
+ __INIT_MBSTATE(&(stream->state));
+#endif /* __STDIO_MBSTATE */
+
#ifdef __STDIO_THREADSAFE
__stdio_init_mutex(&stream->lock);
#endif /* __STDIO_THREADSAFE */
* TODO: Apparently linux allows setting append mode. Implement?
*/
unsigned short dynmode;
- FILE *fp;
+ register FILE *fp;
__STDIO_THREADLOCK(stream);
/* This also removes the stream for the open file list. */
dynmode =
#ifdef __STDIO_BUFFERS
- // __MASK_BUFMODE | /* TODO: check */
+ /* __MASK_BUFMODE | */ /* TODO: check */
#endif /* __STDIO_BUFFERS */
(stream->modeflags & (__FLAG_FREEBUF|__FLAG_FREEFILE));
/* Reentrant. */
-/* TODO -- is it collecting the common work (40 bytes) into a function? */
+/* TODO -- is it worth collecting the common work (40 bytes) in a function? */
FILE *freopen64(const char * __restrict filename, const char * __restrict mode,
register FILE * __restrict stream)
{
unsigned short dynmode;
- FILE *fp;
+ register FILE *fp;
__STDIO_THREADLOCK(stream);
/* This also removes the stream for the open file list. */
dynmode =
#ifdef __STDIO_BUFFERS
- // __MASK_BUFMODE | /* TODO: check */
+ /* __MASK_BUFMODE | */ /* TODO: check */
#endif /* __STDIO_BUFFERS */
(stream->modeflags & (__FLAG_FREEBUF|__FLAG_FREEFILE));
#ifdef __STDIO_PUTC_MACRO
stream->bufputc =
#endif
- stream->bufwpos = stream->bufrpos = stream->bufstart = buf;
+ stream->bufpos = stream->bufread = stream->bufstart = buf;
stream->bufend = buf + size;
}
/* Reentrancy handled by UNLOCKED() macro. */
-UNLOCKED_STREAM(int,getchar,(void),(),_stdin)
+UNLOCKED_STREAM(int,getchar,(void),(),stdin)
{
- register FILE *stream = _stdin; /* This helps bcc optimize. */
+ register FILE *stream = stdin; /* This helps bcc optimize. */
return __GETC(stream);
}
char *gets(char *s) /* WARNING!!! UNSAFE FUNCTION!!! */
{
- register FILE *stream = _stdin; /* This helps bcc optimize. */
+ register FILE *stream = stdin; /* This helps bcc optimize. */
register char *p = s;
int c;
/* Note: don't worry about performance here... this shouldn't be used!
* Therefore, force actual function call. */
- while (((c = (*getc)(stream)) != EOF) && ((*p = c) != '\n')) {
+ while (((c = (getc_unlocked)(stream)) != EOF) && ((*p = c) != '\n')) {
++p;
}
if ((c == EOF) || (s == p)) {
/* Reentrancy handled by UNLOCKED() macro. */
-UNLOCKED_STREAM(int,putchar,(int c),(c),_stdout)
+UNLOCKED_STREAM(int,putchar,(int c),(c),stdout)
{
- register FILE *stream = _stdout; /* This helps bcc optimize. */
+ register FILE *stream = stdout; /* This helps bcc optimize. */
return __PUTC(c, stream);
}
int puts(register const char *s)
{
- register FILE *stream = _stdout; /* This helps bcc optimize. */
+ register FILE *stream = stdout; /* This helps bcc optimize. */
int n;
__STDIO_THREADLOCK(stream);
- n = fputs(s,stream) + 1;
+ n = fputs_unlocked(s,stream) + 1;
if (
#if 1
- fputc('\n',stream)
+ fputc_unlocked('\n',stream)
#else
- fputs("\n",stream)
+ fputs_unlocked("\n",stream)
#endif
== EOF) {
n = EOF;
#ifdef __STDIO_BUFFERS
/* TODO: shouldn't allow writing??? */
if (stream->modeflags & __FLAG_WRITING) {
- fflush(stream); /* Commit any write-buffered chars. */
+ fflush_unlocked(stream); /* Commit any write-buffered chars. */
}
#endif /* __STDIO_BUFFERS */
int fgetpos64(FILE * __restrict stream, register fpos64_t * __restrict pos)
{
+#ifdef __STDIO_MBSTATE
int retval;
__STDIO_THREADLOCK(stream);
retval = ((pos != NULL) && ((pos->__pos = ftello64(stream)) >= 0))
- ? (
-#ifdef __STDIO_MBSTATE_DATA
- __COPY_MBSTATE(&(pos->__mbstate), &(stream->mbstate)),
-#endif /* __STDIO_MBSTATE_DATA */
- 0)
+ ? (__COPY_MBSTATE(&(pos->__mbstate), &(stream->state)), 0)
: (__set_errno(EINVAL), -1);
__STDIO_THREADUNLOCK(stream);
return retval;
+#else
+ return ((pos != NULL) && ((pos->__pos = ftello64(stream)) >= 0))
+ ? 0 : (__set_errno(EINVAL), -1);
+#endif
}
#ifndef L_fgetpos64
#endif
/**********************************************************************/
#ifdef L_fseek
-strong_alias(fseek, fseeko);
+strong_alias(fseek,fseeko);
#endif
#if defined(L_fseek) && defined(__STDIO_LARGE_FILES)
if (
#ifdef __STDIO_BUFFERS
/* First commit any pending buffered writes. */
- ((stream->modeflags & __FLAG_WRITING) && fflush(stream)) ||
+ ((stream->modeflags & __FLAG_WRITING) && fflush_unlocked(stream)) ||
#endif /* __STDIO_BUFFERS */
((whence == SEEK_CUR) && (_stdio_adjpos(stream, pos) < 0))
|| (_stdio_lseek(stream, pos, whence) < 0)
#ifdef __STDIO_GETC_MACRO
stream->bufgetc = /* Must disable getc. */
#endif
- stream->bufwpos = stream->bufrpos = stream->bufstart;
+ stream->bufpos = stream->bufread = stream->bufstart;
#endif /* __STDIO_BUFFERS */
stream->modeflags &=
~(__FLAG_READING|__FLAG_WRITING|__FLAG_EOF|__MASK_UNGOT);
-#ifdef __STDIO_MBSTATE_DATA
+#ifdef __STDIO_MBSTATE
/* TODO: don't clear state if don't move? */
- __INIT_MBSTATE(&(stream->mbstate));
-#endif /* __STDIO_MBSTATE_DATA */
+ __INIT_MBSTATE(&(stream->state));
+#endif /* __STDIO_MBSTATE */
__stdio_validate_FILE(stream); /* debugging only */
retval = 0;
__set_errno(EINVAL);
return EOF;
}
-#ifdef __STDIO_MBSTATE_DATA
-#error unimplemented and non-reentrant besides!
+#ifdef __STDIO_MBSTATE
{
int retval;
+
+ __STDIO_THREADLOCK(stream);
+
if ((retval = fseeko64(stream, pos->__pos, SEEK_SET)) == 0) {
- __COPY_MBSTATE(&(stream->mbstate), &(pos->__mbstate));
+ __COPY_MBSTATE(&(stream->state), &(pos->__mbstate));
}
+
+ __STDIO_THREADUNLOCK(stream);
+
return retval;
}
-#else /* __STDIO_MBSTATE_DATA */
+#else /* __STDIO_MBSTATE */
return fseeko64(stream, pos->__pos, SEEK_SET);
-#endif /* __STDIO_MBSTATE_DATA */
+#endif /* __STDIO_MBSTATE */
}
#ifndef L_fsetpos64
#endif
/**********************************************************************/
#ifdef L_ftell
-strong_alias(ftell, ftello);
+strong_alias(ftell,ftello);
#endif
#if defined(L_ftell) && defined(__STDIO_LARGE_FILES)
__CLEARERR(stream); /* Clear errors first and then seek */
fseek(stream, 0L, SEEK_SET); /* in case there is an error seeking. */
+#ifdef __STDIO_MBSTATE
+ /* TODO: Is it correct to re-init the stream's state? I think so... */
+ __INIT_MBSTATE(&(stream->state));
+#endif /* __STDIO_MBSTATE */
__STDIO_THREADUNLOCK(stream);
}
#if 1
#ifdef __STDIO_PRINTF_M_SPEC
- fprintf(_stderr, "%s%s%m\n", s, sep); /* Use the gnu %m feature. */
+ fprintf(stderr, "%s%s%m\n", s, sep); /* Use the gnu %m feature. */
#else
{
char buf[64];
- fprintf(_stderr, "%s%s%s\n", s, sep,
+ fprintf(stderr, "%s%s%s\n", s, sep,
_stdio_strerror_r(errno, buf, sizeof(buf)));
}
#endif
void _stdio_fdout(int fd, ...)
{
va_list arg;
- const char *p;
+ register const char *p;
va_start(arg, fd);
while ((p = va_arg(arg, const char *)) != NULL) {
#define INTERNAL_DIV_MOD
#endif
-char *_uintmaxtostr(char * __restrict bufend, uintmax_t uval,
- int base, __UIM_CASE alphacase)
+char *_uintmaxtostr(register char * __restrict bufend, uintmax_t uval,
+ int base, __UIM_CASE alphacase)
{
int negative;
unsigned int digit;
static const char unknown[] = "Unknown error";
-char *_stdio_strerror_r(int err, char *buf, size_t buflen)
+char *_stdio_strerror_r(int err, register char *buf, size_t buflen)
{
int errsave;
#define UTF_8_MAX_LEN 3
#endif
+#ifdef __UCLIBC_HAS_LOCALE__
#define ENCODING (__global_locale.encoding)
+#warning implement __CTYPE_HAS_UTF_8_LOCALES!
+#define __CTYPE_HAS_UTF_8_LOCALES
+#else
+#define ENCODING (__ctype_encoding_7_bit)
+#undef __CTYPE_HAS_8_BIT_LOCALES
+#undef __CTYPE_HAS_UTF_8_LOCALES
+#undef L__wchar_utf8sntowcs
+#undef L__wchar_wcsntoutf8s
+#endif
#endif
size_t _stdlib_mb_cur_max(void)
{
+#ifdef __CTYPE_HAS_UTF_8_LOCALES
return __global_locale.mb_cur_max;
+#else
+#ifdef __CTYPE_HAS_8_BIT_LOCALES
+#warning need to change this when/if transliteration is implemented
+#endif
+ return 1;
+#endif
}
#endif
/**********************************************************************/
#ifdef L_mblen
-#warning implement __CTYPE_HAS_UTF_8_LOCALES!
-#define __CTYPE_HAS_UTF_8_LOCALES
-
int mblen(register const char *s, size_t n)
{
static mbstate_t state;
/**********************************************************************/
#ifdef L_mbtowc
-#warning implement __CTYPE_HAS_UTF_8_LOCALES!
-#define __CTYPE_HAS_UTF_8_LOCALES
-
int mbtowc(wchar_t *__restrict pwc, register const char *__restrict s, size_t n)
{
static mbstate_t state;
/**********************************************************************/
#ifdef L_wctomb
-#warning implement __CTYPE_HAS_UTF_8_LOCALES!
-#define __CTYPE_HAS_UTF_8_LOCALES
-
/* Note: We completely ignore state in all currently supported conversions. */
int wctomb(register char *__restrict s, wchar_t swc)
wcsnlen.o wcspbrk.o wcsrchr.o wcsspn.o wcsstr.o wcstok.o wmemchr.o \
wmemcmp.o wmemcpy.o wmemmove.o wmempcpy.o wmemset.o
+# wcscoll wcsxfrm wcpcpy wcpncpy
+
MSRC1=strsignal.c
MOBJ1=strsignal.o psignal.o
#ifndef L_wcscmp
#warning implement strcoll and remove weak alias (or enable for C locale only)
-weak_alias(strcmp, strcoll);
+weak_alias(strcmp,strcoll);
#endif
int Wstrcmp(register const Wchar *s1, register const Wchar *s2)
#define __LC_ALL 6
/**********************************************************************/
-#if defined(_LIBC) && !defined(__LOCALE_C_ONLY)
-
-#include <stddef.h>
-#include <stdint.h>
-#include <bits/uClibc_locale_data.h>
+#ifdef _LIBC
/* TODO: This really needs to be somewhere else... */
#include <limits.h>
#error Can not determine an appropriate type for __uwchar_t!
#endif
+#endif
+
+/**********************************************************************/
+#if defined(_LIBC) && !defined(__LOCALE_C_ONLY)
+
+#include <stddef.h>
+#include <stdint.h>
+#include <bits/uClibc_locale_data.h>
extern void _locale_set(const unsigned char *p);
#define __STDIO_LARGE_FILES
#endif /* __UCLIBC_HAVE_LFS__ */
+#ifdef __UCLIBC_HAS_WCHAR__
+#define __STDIO_WIDE
+#endif
+
/* Make sure defines related to large files are consistent. */
#ifdef _LIBC
/* These are the stdio configuration options. Keep them here until
uClibc's configuration process gets reworked. */
-/* #define __STDIO_WIDE */
#ifdef __STDIO_WIDE
-typedef int __wchar_t; /* TODO: temporary, as not currently uClibc */
+#define __need_wchar_t
+#include <stddef.h>
+/* Note: we don't really need mbstate for 8-bit locales. We do for UTF-8.
+ * For now, always use it. */
+#define __STDIO_MBSTATE
+#define __need_mbstate_t
+#include <wchar.h>
#endif
#define __STDIO_BUFFERS
typedef struct {
__off_t __pos;
-/* __mbstate_t __state; */
+#ifdef __STDIO_MBSTATE
+ __mbstate_t __mbstate;
+#endif
} __stdio_fpos_t;
+#ifdef __STDIO_LARGE_FILES
typedef struct {
__off64_t __pos;
-/* __mbstate_t __state; */
+#ifdef __STDIO_MBSTATE
+ __mbstate_t __mbstate;
+#endif
} __stdio_fpos64_t;
+#endif
/**********************************************************************/
unsigned short modeflags;
/* There could be a hole here, but modeflags is used most.*/
#ifdef __STDIO_WIDE
+ /* TOOD - ungot_width could be combined with ungot. But what about hole? */
unsigned char ungot_width[2];
- __wchar_t ungot[2];
+ wchar_t ungot[2];
#else /* __STDIO_WIDE */
unsigned char ungot[2];
#endif /* __STDIO_WIDE */
#ifdef __STDIO_BUFFERS
unsigned char *bufstart; /* pointer to buffer */
unsigned char *bufend; /* pointer to 1 past end of buffer */
- unsigned char *bufwpos; /* pointer to 1 past last buffered */
- unsigned char *bufrpos; /* pointer to next readable buffered */
+ unsigned char *bufpos;
+ unsigned char *bufread; /* pointer to 1 past last buffered read char. */
#ifdef __STDIO_GETC_MACRO
unsigned char *bufgetc; /* 1 past last readable by getc */
#endif /* __STDIO_GETC_MACRO */
void *cookie;
_IO_cookie_io_functions_t gcs;
#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */
+#ifdef __STDIO_MBSTATE
+ __mbstate_t state;
+#endif
#ifdef __STDIO_THREADSAFE
int user_locking;
pthread_mutex_t lock;
/**********************************************************************/
+#ifdef __STDIO_MBSTATE
+#define __COPY_MBSTATE(dest,src) ((dest)->mask = (src)->mask, (dest)->wc = (src)->wc)
+#define __INIT_MBSTATE(dest) ((dest)->mask = 0)
+#else
+#define __COPY_MBSTATE(dest,src)
+#define __INIT_MBSTATE(dest)
+#endif
+
+/**********************************************************************/
+
/* TODO -- thread safety issues */
#define __CLEARERR(stream) \
((stream)->modeflags &= ~(__FLAG_EOF|__FLAG_ERROR), (void)0)
*/
#ifdef __STDIO_GETC_MACRO
-#define __GETC(stream) ( ((stream)->bufrpos < (stream)->bufgetc) \
- ? (*(stream)->bufrpos++) \
+#define __GETC(stream) ( ((stream)->bufpos < (stream)->bufgetc) \
+ ? (*(stream)->bufpos++) \
: fgetc_unlocked(stream) )
#else /* __STDIO_GETC_MACRO */
#define __GETC(stream) fgetc_unlocked(stream)
#endif /* __STDIO_GETC_MACRO */
#ifdef __STDIO_PUTC_MACRO
-#define __PUTC(c, stream) ( ((stream)->bufwpos < (stream)->bufputc) \
- ? (*(stream)->bufwpos++) = (c) \
+#define __PUTC(c, stream) ( ((stream)->bufpos < (stream)->bufputc) \
+ ? (*(stream)->bufpos++) = (c) \
: fputc_unlocked((c),(stream)) )
#else /* __STDIO_PUTC_MACRO */
#define __PUTC(c, stream) fputc_unlocked(c, stream);
/* TODO: note done above.. typedef struct __stdio_file_struct _UC_FILE; */
typedef __stdio_fpos_t _UC_fpos_t;
+#ifdef __STDIO_LARGE_FILES
typedef __stdio_fpos64_t _UC_fpos64_t;
+#endif
#define _UC_IOFBF _STDIO_IOFBF /* Fully buffered. */
#define _UC_IOLBF _STDIO_IOLBF /* Line buffered. */
OSDN Git Service
