--- /dev/null
+/* Copyright (C) 1991-1993,1995-1999,2000,2001 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 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
+ Lesser General Public License for more details.
+
+ 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. */
+
+/* March 11, 2001 Manuel Novoa III
+ *
+ * Modified as appropriate for my new stdio lib.
+ */
+
+#ifndef _PRINTF_H
+
+#define _PRINTF_H 1
+#include <features.h>
+
+__BEGIN_DECLS
+
+#define __need_FILE
+#include <stdio.h>
+#define __need_size_t
+#define __need_wchar_t
+#include <stddef.h>
+
+/* WARNING -- This is definitely nonportable... but it seems to work
+ * with gcc, which is currently the only "supported" compiler.
+ * The library code uses bitmasks for space-efficiency (you can't
+ * set/test multiple bitfields in one operation). Unfortunatly, we
+ * need to support bitfields since that's what glibc uses. So, we take
+ * advantage of how gcc lays out bitfields to create an appropriate
+ * mapping. By defining __PRINTF_INFO_NO_BITFIELD we access the
+ * bitfields using bitmasks in a single flag variable.
+ *
+ * WARNING -- This may very well fail if built with -fpack-struct!!!
+ *
+ * TODO -- Add a validation test.
+ * TODO -- Add an option to build in a shim translation function if
+ * the bitfield<->bitmask mapping fails.
+ */
+/* #define __PRINTF_INFO_NO_BITFIELD */
+#include <endian.h>
+
+struct printf_info
+{
+ int prec; /* Precision. */
+ int width; /* Width. */
+#ifdef __STDIO_WIDE /* TODO: temporary fix for uClibc */
+ wchar_t spec; /* Format letter. */
+#else
+ int spec;
+#endif
+#ifndef __PRINTF_INFO_NO_BITFIELD
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+ unsigned int space:1; /* Space flag. */
+ unsigned int showsign:1; /* + flag. */
+ unsigned int extra:1; /* For special use. */
+ unsigned int left:1; /* - flag. */
+ unsigned int alt:1; /* # flag. */
+ unsigned int group:1; /* ' flag. */
+ unsigned int i18n:1; /* I flag. */
+ unsigned int wide:1; /* Nonzero for wide character streams. */
+ unsigned int is_char:1; /* hh flag. */
+ unsigned int is_short:1; /* h flag. */
+ unsigned int is_long:1; /* l flag. */
+ unsigned int is_long_double:1;/* L flag. */
+
+#elif __BYTE_ORDER == __BIG_ENDIAN
+
+ unsigned int __padding:20;/* non-gnu -- total of 32 bits on 32bit arch */
+ unsigned int is_long_double:1;/* L flag. */
+ unsigned int is_long:1; /* l flag. */
+ unsigned int is_short:1; /* h flag. */
+ unsigned int is_char:1; /* hh flag. */
+ unsigned int wide:1; /* Nonzero for wide character streams. */
+ unsigned int i18n:1; /* I flag. */
+ unsigned int group:1; /* ' flag. */
+ unsigned int alt:1; /* # flag. */
+ unsigned int left:1; /* - flag. */
+ unsigned int extra:1; /* For special use. */
+ unsigned int showsign:1; /* + flag. */
+ unsigned int space:1; /* Space flag. */
+
+#else
+#error unsupported byte order!
+#endif
+
+#define PRINT_INFO_FLAG_VAL(INFO_PTR,BITFIELD) (INFO_PTR)->BITFIELD
+#define PRINT_INFO_SET_FLAG(INFO_PTR,BITFIELD) (INFO_PTR)->BITFIELD = 1
+#define PRINT_INFO_CLR_FLAG(INFO_PTR,BITFIELD) (INFO_PTR)->BITFIELD = 0
+#define PRINT_INFO_SET_extra(INFO_PTR,VAL) (INFO_PTR)->extra = (VAL)
+
+#else /* __PRINTF_INFO_NO_BITFIELD */
+
+ unsigned int _flags; /* non-gnu */
+#define __PRINT_INFO_FLAG_space (1<<0)
+#define __PRINT_INFO_FLAG_showsign (1<<1)
+#define __PRINT_INFO_FLAG_extra (1<<2)
+#define __PRINT_INFO_FLAG_left (1<<3)
+#define __PRINT_INFO_FLAG_alt (1<<4)
+#define __PRINT_INFO_FLAG_group (1<<5)
+#define __PRINT_INFO_FLAG_i18n (1<<6)
+#define __PRINT_INFO_FLAG_wide (1<<7)
+
+#define __PRINT_INFO_FLAG_is_char (1<<8)
+#define __PRINT_INFO_FLAG_is_short (1<<9)
+#define __PRINT_INFO_FLAG_is_long (1<<10)
+#define __PRINT_INFO_FLAG_is_long_double (1<<11)
+
+#if defined(__STDC__) && __STDC__
+#define PRINT_INFO_FLAG_VAL(INFO_PTR,BITFIELD) \
+ ((INFO_PTR)->_flags & __PRINT_INFO_FLAG_##BITFIELD)
+#define PRINT_INFO_SET_FLAG(INFO_PTR,BITFIELD) \
+ ((INFO_PTR)->_flags |= __PRINT_INFO_FLAG_##BITFIELD)
+#define PRINT_INFO_CLR_FLAG(INFO_PTR,BITFIELD) \
+ ((INFO_PTR)->_flags &= ~__PRINT_INFO_FLAG_##BITFIELD)
+#else
+#define PRINT_INFO_FLAG_VAL(INFO_PTR,BITFIELD) \
+ ((INFO_PTR)->_flags & __PRINT_INFO_FLAG_/**/BITFIELD)
+#define PRINT_INFO_SET_FLAG(INFO_PTR,BITFIELD) \
+ ((INFO_PTR)->_flags |= __PRINT_INFO_FLAG_/**/BITFIELD)
+#define PRINT_INFO_CLR_FLAG(INFO_PTR,BITFIELD) \
+ ((INFO_PTR)->_flags &= ~__PRINT_INFO_FLAG_/**/BITFIELD)
+#endif
+#define PRINT_INFO_SET_extra(INFO_PTR,VAL) \
+ ((INFO_PTR)->_flags |= (((INFO_PTR)->_flags & ~1) | ((VAL) & 1)))
+#endif /* __PRINTF_INFO_NO_BITFIELD */
+#ifdef __STDIO_WIDE /* TODO: temporary fix for uClibc */
+ wchar_t pad; /* Padding character. */
+#else
+ int pad;
+#endif
+};
+
+
+/* Type of a printf specifier-handler function.
+ STREAM is the FILE on which to write output.
+ INFO gives information about the format specification.
+ ARGS is a vector of pointers to the argument data;
+ the number of pointers will be the number returned
+ by the associated arginfo function for the same INFO.
+
+ The function should return the number of characters written,
+ or -1 for errors. */
+
+typedef int printf_function (FILE *__stream,
+ __const struct printf_info *__info,
+ __const void *__const *__args);
+
+/* Type of a printf specifier-arginfo function.
+ INFO gives information about the format specification.
+ N, ARGTYPES, and return value are as for parse_printf_format. */
+
+typedef int printf_arginfo_function (__const struct printf_info *__info,
+ size_t __n, int *__argtypes);
+
+
+/* Register FUNC to be called to format SPEC specifiers; ARGINFO must be
+ specified to determine how many arguments a SPEC conversion requires and
+ what their types are. */
+
+extern int register_printf_function (int __spec, printf_function __func,
+ printf_arginfo_function __arginfo);
+
+
+/* Parse FMT, and fill in N elements of ARGTYPES with the
+ types needed for the conversions FMT specifies. Returns
+ the number of arguments required by FMT.
+
+ The ARGINFO function registered with a user-defined format is passed a
+ `struct printf_info' describing the format spec being parsed. A width
+ or precision of INT_MIN means a `*' was used to indicate that the
+ width/precision will come from an arg. The function should fill in the
+ array it is passed with the types of the arguments it wants, and return
+ the number of arguments it wants. */
+
+extern size_t parse_printf_format (__const char *__restrict __fmt, size_t __n,
+ int *__restrict __argtypes) __THROW;
+
+
+/* Codes returned by `parse_printf_format' for basic types.
+
+ These values cover all the standard format specifications.
+ Users can add new values after PA_LAST for their own types. */
+
+/* WARNING -- The above is not entirely true, even for glibc.
+ * As far as the library code is concerned, such args are treated
+ * as 'your type' pointers if qualified by PA_FLAG_PTR. If they
+ * aren't qualified as pointers, I _think_ glibc just ignores them
+ * and carries on. I think it should be treated as an error. */
+
+enum
+{ /* C type: */
+ PA_INT, /* int */
+ PA_CHAR, /* int, cast to char */
+ PA_WCHAR, /* wide char */
+ PA_STRING, /* const char *, a '\0'-terminated string */
+ PA_WSTRING, /* const wchar_t *, wide character string */
+ PA_POINTER, /* void * */
+ PA_FLOAT, /* float */
+ PA_DOUBLE, /* double */
+ __PA_NOARG, /* non-glibc -- signals non-arg width or prec */
+ PA_LAST
+};
+
+/* Flag bits that can be set in a type returned by `parse_printf_format'. */
+/* WARNING -- These differ in value from what glibc uses. */
+#define PA_FLAG_MASK (0xff00)
+#define __PA_FLAG_CHAR (0x0100) /* non-gnu -- to deal with hh */
+#define PA_FLAG_SHORT (0x0200)
+#define PA_FLAG_LONG (0x0400)
+#define PA_FLAG_LONG_LONG (0x0800)
+#define PA_FLAG_LONG_DOUBLE PA_FLAG_LONG_LONG
+#define PA_FLAG_PTR (0x1000) /* TODO -- make dynamic??? */
+
+#define __PA_INTMASK (0x0f00) /* non-gnu -- all int flags */
+
+/* Function which can be registered as `printf'-handlers. */
+
+/* Print floating point value using using abbreviations for the orders
+ of magnitude used for numbers ('k' for kilo, 'm' for mega etc). If
+ the format specifier is a uppercase character powers of 1000 are
+ used. Otherwise powers of 1024. */
+extern int printf_size (FILE *__restrict __fp,
+ __const struct printf_info *__info,
+ __const void *__const *__restrict __args) __THROW;
+
+/* This is the appropriate argument information function for `printf_size'. */
+extern int printf_size_info (__const struct printf_info *__restrict
+ __info, size_t __n, int *__restrict __argtypes)
+ __THROW;
+
+
+__END_DECLS
+
+#endif /* printf.h */
-/* Define ISO C stdio on top of C++ iostreams.
+/*
Copyright (C) 1991, 1994-1999, 2000, 2001, 2002 Free Software Foundation, Inc.
This file is part of the GNU C Library.
# define __need_FILE
# define __need___FILE
#endif /* Don't need FILE. */
-#include <sys/types.h>
#if !defined __FILE_defined && defined __need_FILE
/* The opaque type of streams. This is the definition used elsewhere. */
-
-/* when you add or change fields here, be sure to change the initialization
- * in stdio_init and fopen */
-
-struct _UC_FILE {
- unsigned char *bufpos; /* the next byte to write to or read from */
- unsigned char *bufread; /* the end of data returned by last read() */
- unsigned char *bufwrite; /* 1 + highest address writable by macro */
- unsigned char *bufstart; /* the start of the buffer */
- unsigned char *bufend; /* the end of the buffer; ie the byte after the last
- malloc()ed byte */
- struct _UC_FILE * next;
-
- int fd; /* the file descriptor associated with the stream */
-
- unsigned char mode;
- unsigned char ungot;
- unsigned char unbuf[2]; /* The buffer for 'unbuffered' streams */
-};
-
typedef struct _UC_FILE FILE;
# define __FILE_defined 1
#ifdef _STDIO_H
#undef _STDIO_USES_IOSTREAM
+#include <sys/types.h>
+
+#include <bits/uClibc_stdio.h>
+
/* This define avoids name pollution if we're using GNU stdarg.h */
# define __need___va_list
#include <stdarg.h>
-
/* The type of the second argument to `fgetpos' and `fsetpos'. */
#ifndef __USE_FILE_OFFSET64
-typedef __off_t fpos_t;
+typedef _UC_fpos_t fpos_t;
#else
-typedef __off64_t fpos_t;
+typedef _UC_fpos64_t fpos_t;
#endif
#ifdef __USE_LARGEFILE64
-typedef __off64_t fpos64_t;
+typedef _UC_fpos64_t fpos64_t;
#endif
/* The possibilities for the third argument to `setvbuf'. */
-#define _IOFBF 0 /* Fully buffered. */
-#define _IOLBF 1 /* Line buffered. */
-#define _IONBF 2 /* No buffering. */
-
-/* Possible states for a file stream -- internal use only */
-#define __MODE_BUF 0x03 /* Modal buffering dependent on isatty */
-#define __MODE_FREEBUF 0x04 /* Buffer allocated by stdio code, can free */
-#define __MODE_FREEFIL 0x08 /* FILE allocated by stdio code, can free */
-#define __MODE_UNGOT 0x10 /* Buffer has been polluted by ungetc */
-#define __MODE_TIED 0x20 /* FILE is tied with stdin/stdout */
-#define __MODE_EOF 0x40 /* EOF status */
-#define __MODE_ERR 0x80 /* Error status */
+#define _IOFBF _UC_IOFBF /* Fully buffered. */
+#define _IOLBF _UC_IOLBF /* Line buffered. */
+#define _IONBF _UC_IONBF /* No buffering. */
/* Default buffer size. */
#ifndef BUFSIZ
-# define BUFSIZ (512)
+# define BUFSIZ _UC_BUFSIZ
#endif
extern FILE *stdin; /* Standard input stream. */
extern FILE *stdout; /* Standard output stream. */
extern FILE *stderr; /* Standard error output stream. */
+#ifdef __STDC__
/* C89/C99 say they're macros. Make them happy. */
#define stdin stdin
#define stdout stdout
#define stderr stderr
+#endif
/* Remove file FILENAME. */
extern int remove (__const char *__filename) __THROW;
extern int fflush_unlocked (FILE *__stream) __THROW;
#endif
-#if 0
-/*#ifdef __USE_GNU*/
+#ifdef __USE_GNU
/* Close all streams. */
extern int fcloseall (void) __THROW;
#endif
extern FILE *fdopen (int __fd, __const char *__modes) __THROW;
#endif
-#if 0
-/*#ifdef __USE_GNU*/
+#ifdef __USE_GNU
+#ifdef __STDIO_GLIBC_CUSTOM_STREAMS
/* Create a new stream that refers to the given magic cookie,
and uses the given functions for input and output. */
extern FILE *fopencookie (void *__restrict __magic_cookie,
extern FILE *open_memstream (char **__restrict __bufloc,
size_t *__restrict __sizeloc) __THROW;
#endif
+#endif
/* If BUF is NULL, make STREAM unbuffered.
/* The C standard explicitly says this is a macro, so we always do the
optimization for it. */
-#define getc(stream) \
- (((stream)->bufpos >= (stream)->bufread) ? fgetc(stream): \
- (*(stream)->bufpos++))
+#define getc(_fp) __GETC(_fp)
#if defined __USE_POSIX || defined __USE_MISC
/* These are defined in POSIX.1:1996. */
/* The C standard explicitly says this can be a macro,
so we always do the optimization for it. */
-#define putc(c, stream) \
- (((stream)->bufpos >= (stream)->bufwrite) ? fputc((c), (stream)) \
- : (unsigned char) (*(stream)->bufpos++ = (c)) )
+#define putc(_ch, _fp) __PUTC(_ch, _fp)
#ifdef __USE_MISC
/* Faster version when locking is not necessary. */
extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
__THROW;
-#if 0
-/*#ifdef __USE_GNU*/
+#ifdef __USE_GNU
/* This function does the same as `fgets' but does not lock the stream. */
extern char *fgets_unlocked (char *__restrict __s, int __n,
FILE *__restrict __stream) __THROW;
NULL), pointing to *N characters of space. It is realloc'd as
necessary. Returns the number of characters read (not including the
null terminator), or -1 on error or EOF. */
-extern ssize_t __getdelim (char **__restrict __lineptr,
+extern __ssize_t __getdelim (char **__restrict __lineptr,
size_t *__restrict __n, int __delimiter,
FILE *__restrict __stream) __THROW;
-extern ssize_t getdelim (char **__restrict __lineptr,
+extern __ssize_t getdelim (char **__restrict __lineptr,
size_t *__restrict __n, int __delimiter,
FILE *__restrict __stream) __THROW;
/* Like `getdelim', but reads up to a newline. */
-extern ssize_t getline (char **__restrict __lineptr,
+extern __ssize_t getline (char **__restrict __lineptr,
size_t *__restrict __n,
FILE *__restrict __stream) __THROW;
#endif
extern int fputs (__const char *__restrict __s, FILE *__restrict __stream)
__THROW;
-#if 0
-/*#ifdef __USE_GNU*/
+#ifdef __USE_GNU
/* This function does the same as `fputs' but does not lock the stream. */
extern int fputs_unlocked (__const char *__restrict __s,
FILE *__restrict __stream) __THROW;
extern __const char *__const sys_errlist[];
#endif
#if 0
-/*#ifdef __USE_GNU*/
+/* #ifdef __USE_GNU */
extern int _sys_nerr;
extern __const char *__const _sys_errlist[];
#endif
#ifdef __USE_POSIX
/* Return the system file descriptor for STREAM. */
extern int fileno (FILE *__stream) __THROW;
-/* Only use the macro below if you know fp is a valid FILE for a valid fd. */
-#define __fileno(fp) ((fp)->fd)
#endif /* Use POSIX. */
#ifdef __USE_MISC
#if 0
-/*#ifdef __USE_GNU*/
+/* #ifdef __USE_GNU */
struct obstack; /* See <obstack.h>. */
/* Write formatted output to an obstack. */
#endif /* Use GNU. */
-#if defined __USE_POSIX || defined __USE_MISC
+#if (defined __USE_POSIX || defined __USE_MISC) && defined __UCLIBC_HAS_THREADS__
/* These are defined in POSIX.1:1996. */
/* Acquire ownership of STREAM. */
/* If we are compiling with optimizing read this file. It contains
several optimizing inline functions and macros. */
-#ifdef __USE_EXTERN_INLINES
+#if 0
+/* #ifdef __USE_EXTERN_INLINES */
# include <bits/stdio.h>
#endif
--- /dev/null
+/* Functions to access FILE structure internals.
+ Copyright (C) 2000, 2001 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 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
+ Lesser General Public License for more details.
+
+ 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. */
+
+/* This header contains the same definitions as the header of the same name
+ on Sun's Solaris OS. */
+
+#ifndef _STDIO_EXT_H
+#define _STDIO_EXT_H 1
+
+#include <stdio.h>
+
+enum
+{
+ /* Query current state of the locking status. */
+ FSETLOCKING_QUERY = 0,
+#define FSETLOCKING_QUERY FSETLOCKING_QUERY
+ /* The library protects all uses of the stream functions, except for
+ uses of the *_unlocked functions, by calls equivalent to flockfile(). */
+ FSETLOCKING_INTERNAL,
+#define FSETLOCKING_INTERNAL FSETLOCKING_INTERNAL
+ /* The user will take care of locking. */
+ FSETLOCKING_BYCALLER
+#define FSETLOCKING_BYCALLER FSETLOCKING_BYCALLER
+};
+
+
+__BEGIN_DECLS
+
+/* Return the size of the buffer of FP in bytes currently in use by
+ the given stream. */
+extern size_t __fbufsize (FILE *__fp);
+
+
+/* Return non-zero value iff the stream FP is opened readonly, or if the
+ last operation on the stream was a read operation. */
+extern int __freading (FILE *__fp);
+
+/* Return non-zero value iff the stream FP is opened write-only or
+ append-only, or if the last operation on the stream was a write
+ operation. */
+extern int __fwriting (FILE *__fp);
+
+
+/* Return non-zero value iff stream FP is not opened write-only or
+ append-only. */
+extern int __freadable (FILE *__fp);
+
+/* Return non-zero value iff stream FP is not opened read-only. */
+extern int __fwritable (FILE *__fp);
+
+
+/* Return non-zero value iff the stream FP is line-buffered. */
+extern int __flbf (FILE *__fp);
+
+
+/* Discard all pending buffered I/O on the stream FP. */
+extern void __fpurge (FILE *__fp);
+
+/* Return amount of output in bytes pending on a stream FP. */
+extern size_t __fpending (FILE *__fp);
+
+/* Flush all line-buffered files. */
+extern void _flushlbf (void);
+
+
+/* Set locking status of stream FP to TYPE. */
+extern int __fsetlocking (FILE *__fp, int __type);
+
+__END_DECLS
+
+#endif /* stdio_ext.h */
* are smaller than the previous functions and don't require static buffers.
* In the process, removed the reference to strcat and cut object size of
* inet_ntoa in half (from 190 bytes down to 94).
+ *
+ * Manuel Novoa III Feb 2002
+ *
+ * Changed to use _int10tostr.
*/
#define __FORCE_GLIBC
#include <features.h>
+#define _STDIO_UTILITY /* For _int10tostr. */
+#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <netinet/in.h>
#ifdef L_inet_ntoa
-#include <limits.h>
-
-#if (ULONG_MAX >> 32)
-/* We're set up for 32 bit unsigned longs */
-#error need to check size allocation for static buffer 'buf'
-#endif
-
-extern char *__ultostr(char *buf, unsigned long uval, int base, int uppercase);
-
char *inet_ntoa(in)
struct in_addr in;
{
q = 0;
p = buf + sizeof(buf) - 1;
for (i=0 ; i < 4 ; i++ ) {
- p = __ultostr(p, addr & 0xff, 10, 0 ) - 1;
+ p = _int10tostr(p, addr & 0xff) - 1;
addr >>= 8;
if (q) {
*q = '.';
- * This file is part of the Linux-8086 C library and is distributed
- * under the GNU Library General Public License.
- */
-
-/*
- * Manuel Novoa III Dec 2000
+/* Copyright (C) 2002 Manuel Novoa III
+ * An __assert() function compatible with the modified glibc assert.h
+ * that is used by uClibc.
+ *
+ * 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.
*
- * Converted to use my new (un)signed long (long) to string routines, which
- * are smaller than the previous functions and don't require static buffers.
+ * 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.
*/
-#include <unistd.h>
-#include <string.h>
+#define _STDIO_UTILITY /* For _stdio_fdout and _int10tostr. */
+#include <stdio.h>
#include <stdlib.h>
-#include <limits.h>
-
-#if (INT_MAX >> 31)
-/* We're set up for 32 bit ints */
-#error need to check size allocation for buffer 'buf'
-#endif
-
-extern char *__ltostr(char *buf, unsigned long uval, int base, int uppercase);
+#include <unistd.h>
-static void errput(str)
-const char *str;
-{
- write(2, str, strlen(str));
-}
+/* Get the prototype from assert.h as a double-check. */
+#undef NDEBUG
+#include <assert.h>
+#undef assert
-void __assert(assertion, filename, linenumber, function)
-const char *assertion;
-const char *filename;
-int linenumber;
-const char *function;
+void __assert(const char *assertion, const char * filename,
+ int linenumber, const char * function)
{
- char buf[12];
+ char buf[__BUFLEN_INT10TOSTR];
- errput(filename);
- errput(":");
- errput(__ltostr(buf + sizeof(buf) - 1, linenumber, 10, 0));
- errput(function ? ": " : "");
- errput(function ? function : "");
- errput(function ? "() " : "");
- errput(": Assertion \"");
- errput(assertion);
- errput("\" failed.\n");
+ _stdio_fdout(STDERR_FILENO,
+#if 0
+ program_name, /* TODO: support program_name like glibc? */
+ ": ",
+#endif
+ filename,
+ ":",
+ _int10tostr(buf+sizeof(buf)-1, linenumber),
+ ": ",
+ /* Function name isn't available with some compilers. */
+ ((function == NULL) ? "?function?" : function),
+ ": Assertion `",
+ assertion,
+ "' failed.\n",
+ NULL
+ );
abort();
}
TOPDIR=../../../
include $(TOPDIR)Rules.mak
-CSRC=ultostr.c ltostr.c __uClibc_main.c tempname.c errno.c __errno_location.c __h_errno_location.c
-ifeq ($(HAS_FLOATING_POINT),true)
- CSRC += dtostr.c zoicheck.c
-endif
-ifeq ($(HAS_LONG_LONG),true)
- CSRC += ulltostr.c lltostr.c
-endif
+CSRC=__uClibc_main.c tempname.c errno.c __errno_location.c __h_errno_location.c
COBJS=$(patsubst %.c,%.o, $(CSRC))
OBJS=$(COBJS)
#ifdef HAVE_ELF
weak_alias(__environ, environ);
-extern void weak_function __init_stdio(void);
-extern void weak_function __stdio_flush_buffers(void);
+extern void weak_function _stdio_init(void);
+extern void weak_function _stdio_term(void);
extern int *weak_const_function __errno_location (void);
extern int *weak_const_function __h_errno_location (void);
#else
-extern void __init_stdio(void);
-extern void __stdio_flush_buffers(void);
+extern void _stdio_init(void);
+extern void _stdio_term(void);
extern int *__errno_location (void);
extern int *__h_errno_location (void);
#endif
* Initialize stdio here. In the static library case, this will
* be bypassed if not needed because of the weak alias above.
*/
- if (__init_stdio)
- __init_stdio();
+ if (_stdio_init)
+ _stdio_init();
/*
* Note: It is possible that any initialization done above could
/*
* Define an empty function and use it as a weak alias for the stdio
* initialization routine. That way we don't pull in all the stdio
- * code unless we need to. Similarly, do the same for __stdio_flush_buffers
+ * code unless we need to. Similarly, do the same for _stdio_term
* so as not to include atexit unnecessarily.
*
* NOTE!!! This is only true for the _static_ case!!!
void __uClibc_empty_func(void)
{
}
-weak_alias(__uClibc_empty_func, __init_stdio);
-weak_alias(__uClibc_empty_func, __stdio_flush_buffers);
+weak_alias(__uClibc_empty_func, _stdio_init);
+weak_alias(__uClibc_empty_func, _stdio_term);
#endif
#endif
+++ /dev/null
-/*
- * Copyright (C) 2000, 2001 Manuel Novoa III
- *
- * Function: int __dtostr(FILE * fp, size_t size, long double x,
- * char flag[], int width, int preci, char mode)
- *
- * This was written for uClibc to provide floating point support for
- * the printf functions. It handles +/- infinity and nan on i386.
- *
- * Notes:
- *
- * At most MAX_DIGITS significant digits are kept. Any trailing digits
- * are treated as 0 as they are really just the results of rounding noise
- * anyway. If you want to do better, use an arbitary precision arithmetic
- * package. ;-)
- *
- * It should also be fairly portable, as not assumptions are made about the
- * bit-layout of doubles.
- *
- * It should be too difficult to convert this to handle long doubles on i386.
- * For information, see the comments below.
- *
- * TODO:
- * long double and/or float version? (note: for float can trim code some).
- *
- * Decrease the size. This is really much bigger than I'd like.
- */
-
-/*****************************************************************************/
-/* Don't change anything that follows unless you know what you're doing. */
-/*****************************************************************************/
-
-/*
- * Configuration for the scaling power table. Ignoring denormals, you
- * should have 2**EXP_TABLE_SIZE >= LDBL_MAX_EXP >= 2**(EXP_TABLE_SIZE-1).
- * The minimum for standard C is 6. For IEEE 8bit doubles, 9 suffices.
- * For long doubles on i386, use 13.
- */
-#define EXP_TABLE_SIZE 13
-
-/*
- * Set this to the maximum number of digits you want converted.
- * Conversion is done in blocks of DIGITS_PER_BLOCK (9 by default) digits.
- * (20) 17 digits suffices to uniquely determine a (long) double on i386.
- */
-#define MAX_DIGITS 20
-
-/*
- * Set this to the smallest integer type capable of storing a pointer.
- */
-#define INT_OR_PTR int
-
-/*
- * This is really only used to check for infinities. The macro produces
- * smaller code for i386 and, since this is tested before any floating point
- * calculations, it doesn't appear to suffer from the excess precision problem
- * caused by the FPU that strtod had. If it causes problems, call the function
- * and compile zoicheck.c with -ffloat-store.
- */
-#define _zero_or_inf_check(x) ( x == (x/4) )
-
-/*
- * Fairly portable nan check. Bitwise for i386 generated larger code.
- * If you have a better version, comment this out.
- */
-#define isnan(x) (x != x)
-
-/*****************************************************************************/
-/* Don't change anything that follows peroid!!! ;-) */
-/*****************************************************************************/
-
-#include <stdio.h>
-#include <string.h>
-#include <assert.h>
-#include <float.h>
-#include <limits.h>
-
-extern int fnprintf(FILE * fp, size_t size, const char *fmt, ...);
-
-/* from printf.c -- should really be in an internal header file */
-enum {
- FLAG_PLUS = 0,
- FLAG_MINUS_LJUSTIFY,
- FLAG_HASH,
- FLAG_0_PAD,
- FLAG_SPACE,
-};
-
-/*****************************************************************************/
-
-/*
- * Set things up for the scaling power table.
- */
-
-#if EXP_TABLE_SIZE < 6
-#error EXP_TABLE_SIZE should be at least 6 to comply with standards
-#endif
-
-#define EXP_TABLE_MAX (1U<<(EXP_TABLE_SIZE-1))
-
-/*
- * Only bother checking if this is too small.
- */
-
-#if LDBL_MAX_10_EXP/2 > EXP_TABLE_MAX
-#error larger EXP_TABLE_SIZE needed
-#endif
-
-/*
- * With 32 bit ints, we can get 9 digits per block.
- */
-#define DIGITS_PER_BLOCK 9
-
-#if (INT_MAX >> 30)
-#define DIGIT_BLOCK_TYPE int
-#define DB_FMT "%.*d"
-#elif (LONG_MAX >> 30)
-#define DIGIT_BLOCK_TYPE long
-#define DB_FMT "%.*ld"
-#else
-#error need at least 32 bit longs
-#endif
-
-/* Are there actually any machines where this might fail? */
-#if 'A' > 'a'
-#error ordering assumption violated : 'A' > 'a'
-#endif
-
-/* Maximum number of calls to fnprintf to output double. */
-#define MAX_CALLS 8
-
-/*****************************************************************************/
-
-#define NUM_DIGIT_BLOCKS ((MAX_DIGITS+DIGITS_PER_BLOCK-1)/DIGITS_PER_BLOCK)
-
-/* extra space for '-', '.', 'e+###', and nul */
-#define BUF_SIZE ( 3 + NUM_DIGIT_BLOCKS * DIGITS_PER_BLOCK )
-/*****************************************************************************/
-
-static const char *fmts[] = {
- "%0*d", "%.*s", ".", "inf", "INF", "nan", "NAN", "%*s"
-};
-
-/*****************************************************************************/
-
-int __dtostr(FILE * fp, size_t size, long double x,
- char flag[], int width, int preci, char mode)
-{
- long double exp_table[EXP_TABLE_SIZE];
- long double p10;
- DIGIT_BLOCK_TYPE digit_block; /* int of at least 32 bits */
- int i, j;
- int round, o_exp;
- int exp, exp_neg;
- char *s;
- char *e;
- char buf[BUF_SIZE];
- INT_OR_PTR pc_fwi[2*MAX_CALLS];
- INT_OR_PTR *ppc;
- char exp_buf[8];
- char drvr[8];
- char *pdrvr;
- int npc;
- int cnt;
- char sign_str[2];
- char o_mode;
-
- /* check that INT_OR_PTR is sufficiently large */
- assert( sizeof(INT_OR_PTR) == sizeof(char *) );
-
- *sign_str = flag[FLAG_PLUS];
- *(sign_str+1) = 0;
- if (isnan(x)) { /* nan check */
- pdrvr = drvr + 1;
- *pdrvr++ = 5 + (mode < 'a');
- pc_fwi[2] = 3;
- flag[FLAG_0_PAD] = 0;
- goto EXIT_SPECIAL;
- }
-
- if (x == 0) { /* handle 0 now to avoid false positive */
- exp = -1;
- goto GENERATE_DIGITS;
- }
-
- if (x < 0) { /* convert negatives to positives */
- *sign_str = '-';
- x = -x;
- }
-
- if (_zero_or_inf_check(x)) { /* must be inf since zero handled above */
- pdrvr = drvr + 1;
- *pdrvr++ = 3 + + (mode < 'a');
- pc_fwi[2] = 3;
- flag[FLAG_0_PAD] = 0;
- goto EXIT_SPECIAL;
- }
-
- /* need to build the scaling table */
- for (i = 0, p10 = 10 ; i < EXP_TABLE_SIZE ; i++) {
- exp_table[i] = p10;
- p10 *= p10;
- }
-
- exp_neg = 0;
- if (x < 1e8) { /* do we need to scale up or down? */
- exp_neg = 1;
- }
-
- exp = DIGITS_PER_BLOCK - 1;
-
- i = EXP_TABLE_SIZE;
- j = EXP_TABLE_MAX;
- while ( i-- ) { /* scale x such that 1e8 <= x < 1e9 */
- if (exp_neg) {
- if (x * exp_table[i] < 1e9) {
- x *= exp_table[i];
- exp -= j;
- }
- } else {
- if (x / exp_table[i] >= 1e8) {
- x /= exp_table[i];
- exp += j;
- }
- }
- j >>= 1;
- }
- if (x >= 1e9) { /* handle bad rounding case */
- x /= 10;
- ++exp;
- }
- assert(x < 1e9);
-
- GENERATE_DIGITS:
- s = buf + 2; /* leave space for '\0' and '0' */
-
- for (i = 0 ; i < NUM_DIGIT_BLOCKS ; ++i ) {
- digit_block = (DIGIT_BLOCK_TYPE) x;
- x = (x - digit_block) * 1e9;
- s += sprintf(s, DB_FMT, DIGITS_PER_BLOCK, digit_block);
- }
-
- /*************************************************************************/
-
- *exp_buf = 'e';
- if (mode < 'a') {
- *exp_buf = 'E';
- mode += ('a' - 'A');
- }
-
- o_mode = mode;
-
- round = preci;
-
- if ((mode == 'g') && (round > 0)){
- --round;
- }
-
- if (mode == 'f') {
- round += exp;
- }
-
- s = buf;
- *s++ = 0; /* terminator for rounding and 0-triming */
- *s = '0'; /* space to round */
-
- i = 0;
- e = s + MAX_DIGITS + 1;
- if (round < MAX_DIGITS) {
- e = s + round + 2;
- if (*e >= '5') {
- i = 1;
- }
- }
-
- do { /* handle rounding and trim trailing 0s */
- *--e += i; /* add the carry */
- } while ((*e == '0') || (*e > '9'));
-
- o_exp = exp;
- if (e <= s) { /* we carried into extra digit */
- ++o_exp;
- e = s; /* needed if all 0s */
- } else {
- ++s;
- }
- *++e = 0; /* ending nul char */
-
- if ((mode == 'g') && ((o_exp >= -4) && (o_exp <= round))) {
- mode = 'f';
- }
-
- exp = o_exp;
- if (mode != 'f') {
- o_exp = 0;
- }
-
- if (o_exp < 0) {
- *--s = '0'; /* fake the first digit */
- }
-
- pdrvr = drvr+1;
- ppc = pc_fwi+2;
-
- *pdrvr++ = 0;
- *ppc++ = 1;
- *ppc++ = (INT_OR_PTR)(*s++ - '0');
-
- i = e - s; /* total digits */
- if (o_exp >= 0) {
- if (o_exp >= i) { /* all digit(s) left of decimal */
- *pdrvr++ = 1;
- *ppc++ = i;
- *ppc++ = (INT_OR_PTR)(s);
- o_exp -= i;
- i = 0;
- if (o_exp>0) { /* have 0s left of decimal */
- *pdrvr++ = 0;
- *ppc++ = o_exp;
- *ppc++ = 0;
- }
- } else if (o_exp > 0) { /* decimal between digits */
- *pdrvr++ = 1;
- *ppc++ = o_exp;
- *ppc++ = (INT_OR_PTR)(s);
- s += o_exp;
- i -= o_exp;
- }
- o_exp = -1;
- }
-
- if (flag[FLAG_HASH] || (i) || ((o_mode != 'g') && (preci > 0))) {
- *pdrvr++ = 2; /* need decimal */
- *ppc++ = 1; /* needed for width calc */
- ppc++;
- }
-
- if (++o_exp < 0) { /* have 0s right of decimal */
- *pdrvr++ = 0;
- *ppc++ = -o_exp;
- *ppc++ = 0;
- }
- if (i) { /* have digit(s) right of decimal */
- *pdrvr++ = 1;
- *ppc++ = i;
- *ppc++ = (INT_OR_PTR)(s);
- }
-
- if (o_mode != 'g') {
- i -= o_exp;
- if (i < preci) { /* have 0s right of digits */
- i = preci - i;
- *pdrvr++ = 0;
- *ppc++ = i;
- *ppc++ = 0;
- }
- }
-
- /* build exponent string */
- if (mode != 'f') {
- *pdrvr++ = 1;
- *ppc++ = sprintf(exp_buf,"%c%+.2d", *exp_buf, exp);
- *ppc++ = (INT_OR_PTR) exp_buf;
- }
-
- EXIT_SPECIAL:
- npc = pdrvr - drvr;
- ppc = pc_fwi + 2;
- for (i=1 ; i< npc ; i++) {
- width -= *(ppc++);
- ppc++;
- }
- i = 0;
- if (*sign_str) {
- i = 1;
- }
- width -= i;
- if (width <= 0) {
- width = 0;
- } else {
- if (flag[FLAG_MINUS_LJUSTIFY]) { /* padding on right */
- ++npc;
- *pdrvr++ = 7;
- *ppc = width;
- *++ppc = (INT_OR_PTR)("");
- width = 0;
- } else if (flag[FLAG_0_PAD] == '0') { /* 0 padding */
- pc_fwi[2] += width;
- width = 0;
- }
- }
- *drvr = 7;
- ppc = pc_fwi;
- *ppc++ = width + i;
- *ppc = (INT_OR_PTR) sign_str;
-
- pdrvr = drvr;
- ppc = pc_fwi;
- cnt = 0;
- for (i=0 ; i<npc ; i++) {
-#if 1
- fnprintf(fp, size, fmts[(int)(*pdrvr++)], (INT_OR_PTR)(*(ppc)),
- (INT_OR_PTR)(*(ppc+1)));
-#else
- j = fnprintf(fp, size, fmts[(int)(*pdrvr++)], (INT_OR_PTR)(*(ppc)),
- (INT_OR_PTR)(*(ppc+1)));
- assert(j == *ppc);
-#endif
- if (size > *ppc) {
- size -= *ppc;
- }
- cnt += *ppc; /* to avoid problems if j == -1 */
- ppc += 2;
- }
-
- return cnt;
-}
-
-
-
-
-
-
+++ /dev/null
-/*
- * Copyright (C) 2000 Manuel Novoa III
- *
- * Note: buf is a pointer to the END of the buffer passed.
- * Call like this:
- * char buf[SIZE], *p;
- * p = __lltostr(buf + sizeof(buf) - 1, ...)
- * For long longs of 64 bits, appropriate buffer sizes are:
- * base = 2 66 = 1 (possible -) sign + 64 digits + 1 nul
- * base = 10 21 = 1 (possible -) sign + 19 digits + 1 nul
- * base = 16 18 = 1 (possible -) sign + 16 hex digits + 1 nul
- */
-
-extern char *__ulltostr(char *buf, unsigned long long uval, int base,
- int uppercase);
-
-char *__lltostr(char *buf, long long val, int base, int uppercase)
-{
- unsigned long long uval;
- char *pos;
- int negative;
-
- negative = 0;
- if (val < 0) {
- negative = 1;
- uval = ((unsigned long long)(-(1+val))) + 1;
- } else {
- uval = val;
- }
-
-
- pos = __ulltostr(buf, uval, base, uppercase);
-
- if (pos && negative) {
- *--pos = '-';
- }
-
- return pos;
-}
+++ /dev/null
-/*
- * Copyright (C) 2000 Manuel Novoa III
- *
- * Note: buf is a pointer to the END of the buffer passed.
- * Call like this:
- * char buf[SIZE], *p;
- * p = __ltostr(buf + sizeof(buf) - 1, ...)
- *
- * For longs of 32 bits, appropriate buffer sizes are:
- * base = 2 34 = 1 (possible -) sign + 32 digits + 1 nul
- * base = 10 12 = 1 (possible -) sign + 10 digits + 1 nul
- * base = 16 10 = 1 (possible -) sign + 8 hex digits + 1 nul
- */
-
-extern char *__ultostr(char *buf, unsigned long uval, int base, int uppercase);
-
-char *__ltostr(char *buf, long val, int base, int uppercase)
-{
- unsigned long uval;
- char *pos;
- int negative;
-
- negative = 0;
- if (val < 0) {
- negative = 1;
- uval = ((unsigned long)(-(1+val))) + 1;
- } else {
- uval = val;
- }
-
-
- pos = __ultostr(buf, uval, base, uppercase);
-
- if (pos && negative) {
- *--pos = '-';
- }
-
- return pos;
-}
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+/* March 11, 2002 Manuel Novoa III
+ *
+ * Modify code to remove dependency on libgcc long long arith support funcs.
+ */
+
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
char *XXXXXX;
static uint64_t value;
struct timeval tv;
+ uint32_t high, low, rh;
+ unsigned int k;
int count, fd;
int save_errno = errno;
+ int i;
len = strlen (tmpl);
if (len < 6 || strcmp (&tmpl[len - 6], "XXXXXX"))
for (count = 0; count < TMP_MAX; value += 7777, ++count)
{
- uint64_t v = value;
-
- /* Fill in the random bits. */
- XXXXXX[0] = letters[v % 62];
- v /= 62;
- XXXXXX[1] = letters[v % 62];
- v /= 62;
- XXXXXX[2] = letters[v % 62];
- v /= 62;
- XXXXXX[3] = letters[v % 62];
- v /= 62;
- XXXXXX[4] = letters[v % 62];
- v /= 62;
- XXXXXX[5] = letters[v % 62];
+ low = value & UINT32_MAX;
+ high = value >> 32;
+
+ for (i = 0 ; i < 6 ; i++) {
+ rh = high % 62;
+ high /= 62;
+#define L ((UINT32_MAX % 62 + 1) % 62)
+ k = (low % 62) + (L * rh);
+#undef L
+#define H ((UINT32_MAX / 62) + ((UINT32_MAX % 62 + 1) / 62))
+ low = (low / 62) + (H * rh) + (k / 62);
+#undef H
+ k %= 62;
+ XXXXXX[i] = letters[k];
+ }
if (openit)
{
+++ /dev/null
-/*
- * Copyright (C) 2000 Manuel Novoa III
- *
- * Note: buf is a pointer to the END of the buffer passed.
- * Call like this:
- * char buf[SIZE], *p;
- * p = __ulltostr(buf + sizeof(buf) - 1, ...)
- *
- * For long longs of 64 bits, appropriate buffer sizes are:
- * base = 2 65 = 64 digits + 1 nul
- * base = 10 20 = 19 digits + 1 nul
- * base = 16 17 = 16 hex digits + 1 nul
- */
-
-char *__ulltostr(char *buf, unsigned long long uval, int base, int uppercase)
-{
- int digit;
-
- if ((base < 2) || (base > 36)) {
- return 0;
- }
-
- *buf = '\0';
-
- do {
- digit = uval % base;
- uval /= base;
-
- /* note: slightly slower but generates less code */
- *--buf = '0' + digit;
- if (digit > 9) {
- *buf = (uppercase ? 'A' : 'a') + digit - 10;
- }
- } while (uval);
-
- return buf;
-}
+++ /dev/null
-/*
- * Copyright (C) 2000 Manuel Novoa III
- *
- * Note: buf is a pointer to the END of the buffer passed.
- * Call like this;
- * char buf[SIZE], *p;
- * p = __ultostr(buf + sizeof(buf) - 1, ...)
- *
- * For longs of 32 bits, appropriate buffer sizes are:
- * base = 2 33 = 32 digits + 1 nul
- * base = 10 11 = 10 digits + 1 nul
- * base = 16 9 = 8 hex digits + 1 nul
- */
-
-char *__ultostr(char *buf, unsigned long uval, int base, int uppercase)
-{
- int digit;
-
- if ((base < 2) || (base > 36)) {
- return 0;
- }
-
- *buf = '\0';
-
- do {
- digit = uval % base;
- uval /= base;
-
- /* note: slightly slower but generates less code */
- *--buf = '0' + digit;
- if (digit > 9) {
- *buf = (uppercase ? 'A' : 'a') + digit - 10;
- }
- } while (uval);
-
- return buf;
-}
+++ /dev/null
-
-/*
- * Copyright (C) 2000 Manuel Novoa III
- *
- * This is a utility routine for strtod errno support.
- * As the name implies, it checks if a double is either 0 or +/-infinity.
- * Doing this inline doesn't work on i386 because of excess precission
- * stored in the FPU.
- *
- * TODO: Check bitmasks directly?
- */
-
-int _zero_or_inf_check(double x)
-{
- return ( x == x/4 );
-}
TOPDIR=../../
include $(TOPDIR)Rules.mak
-MSRC=stdio.c
-MOBJ=_stdio_init.o _alloc_stdio_buffer.o _free_stdio_buffer_of_file.o \
- _free_stdio_stream.o clearerr.o feof.o ferror.o fileno.o setbuffer.o \
- setvbuf.o setbuf.o setlinebuf.o fclose.o _fopen.o fopen.o freopen.o \
- fdopen.o fflush.o fsfopen.o fseek.o rewind.o ftell.o fgetpos.o fsetpos.o \
- fputc.o fgetc.o fgets.o gets.o fputs.o puts.o ungetc.o fread.o fwrite.o \
- getchar.o putchar.o _uClibc_fwrite.o _uClibc_fread.o fopen64.o getc.o putc.o
-
-MSRC2=printf.c
-MOBJ2=printf.o sprintf.o fprintf.o vprintf.o vsprintf.o vfprintf.o snprintf.o \
- vsnprintf.o asprintf.o vfnprintf.o fnprintf.o vdprintf.o
+# Set to true to use the old vfprintf instead of the new. The old is roughly
+# C89 compliant, but doesn't deal with qualifiers on %n and doesn't deal with
+# %h correctly or %hh at all on the interger conversions. But on i386 it is
+# over 1.5k smaller than the new code. Of course, the new code fixes the
+# above mentioned deficiencies and adds custom specifier support similar to
+# glibc, as well as handling positional args. This option is here temporarily
+# until the configuration system gets rewritten. Note also that the old
+# vfprintf code will be rewritten at some point to bring it into at least C89
+# standards compliance.
+
+USE_OLD_VFPRINTF = false
+
+# Note: The *64.o objects are empty when compiled without large file support.
+# To not build them at all, remove the appropriate line from the MOBJ
+# definition and uncomment the DOLFS test below.
+
+# Note: Use the libpthreads of: flockfile.o ftrylockfile.o funlockfile.o
+# Also, maybe move __fsetlocking.o as well?
+
+MSRC = stdio.c
+MOBJ = fclose.o fflush.o fopen.o freopen.o perror.o remove.o \
+ setbuf.o setvbuf.o fgetc.o fgets.o fputc.o fputs.o \
+ getc.o getchar.o gets.o putc.o putchar.o puts.o \
+ ungetc.o fread.o fwrite.o fgetpos.o fseek.o fsetpos.o ftell.o \
+ rewind.o clearerr.o feof.o ferror.o \
+ fileno.o fdopen.o getw.o putw.o setbuffer.o setlinebuf.o fcloseall.o \
+ fopen64.o freopen64.o ftello64.o fseeko64.o fsetpos64.o fgetpos64.o \
+ __fbufsize.o __freading.o __fwriting.o __freadable.o __fwritable.o \
+ __flbf.o __fpurge.o __fpending.o _flushlbf.o \
+ fopencookie.o fmemopen.o open_memstream.o \
+ __fsetlocking.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
+
+# ifeq ($(DOLFS),true)
+# MOBJ += fopen64.o freopen64.o ftello64.o fseeko64.o fsetpos64.o fgetpos64.o
+# endif
+
+MSRC2= printf.c
+MOBJ2= vsnprintf.o vdprintf.o vasprintf.o vprintf.o vsprintf.o \
+ fprintf.o snprintf.o dprintf.o asprintf.o printf.o sprintf.o
+
+ifneq ($(USE_OLD_VFPRINTF),true)
+ MOBJ2 += _ppfs_init.o _ppfs_prepargs.o _ppfs_setargs.o \
+ _ppfs_parsespec.o _do_one_spec.o vfprintf.o \
+ _store_inttype.o _load_inttype.o \
+ register_printf_function.o parse_printf_format.o
+endif
+
+
+
+ifeq ($(HAS_FLOATING_POINT),true)
+ MOBJ2 += _dtostr.o
+endif
MSRC3=scanf.c
MOBJ3=scanf.o sscanf.o fscanf.o vscanf.o vsscanf.o vfscanf.o
-CSRC=popen.c perror.c remove.c getdelim.c getline.c tmpfile.c tmpnam.c \
- tmpnam_r.c tempnam.c ctermid.c getw.c putw.c
+CSRC=popen.c getdelim.c getline.c tmpfile.c tmpnam.c \
+ tmpnam_r.c tempnam.c ctermid.c
+ifeq ($(USE_OLD_VFPRINTF),true)
+ CSRC += old_vfprintf.c
+endif
COBJS=$(patsubst %.c,%.o, $(CSRC))
-OBJS=$(MOBJ) $(MOBJ2) $(MOBJ3) $(COBJS)
+OBJS=$(MOBJ) $(MOBJ2) $(MOBJ3) $(COBJS)
all: $(OBJS) $(LIBC)
+++ /dev/null
-/* Copyright (C) 1991, 1997, 1998 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 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
- Lesser General Public License for more details.
-
- 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>
-
-#ifdef USE_IN_LIBIO
-# include <libio/iolibio.h>
-# define fread(p, m, n, s) _IO_fread (p, m, n, s)
-#endif
-
-/* Read a word (int) from STREAM. */
-int
-getw (FILE *stream)
-{
- int w;
-
- /* Is there a better way? */
- if (fread ((void *) &w, sizeof (w), 1, stream) != 1)
- return EOF;
- return w;
-}
--- /dev/null
+/*
+ * This file based on printf.c from 'Dlibs' on the atari ST (RdeBath)
+ *
+ *
+ * Dale Schumacher 399 Beacon Ave.
+ * (alias: Dalnefre') St. Paul, MN 55104
+ * "It's not reality that's important, but how you perceive things."
+ */
+
+/* Altered to use stdarg, made the core function vfnprintf.
+ * Hooked into the stdio package using 'inside information'
+ * Altered sizeof() assumptions, now assumes all integers except chars
+ * will be either
+ * sizeof(xxx) == sizeof(long) or sizeof(xxx) == sizeof(short)
+ *
+ * -RDB
+ */
+
+/*
+ * Manuel Novoa III Dec 2000
+ *
+ * The previous vfnprintf routine was almost completely rewritten with the
+ * goal of fixing some shortcomings and reducing object size.
+ *
+ * The summary of changes:
+ *
+ * Converted print conversion specification parsing from one big switch
+ * to a method using string tables. This new method verifies that the
+ * conversion flags, field width, precision, qualifier, and specifier
+ * appear in the correct order. Many questionable specifications were
+ * accepted by the previous code. This new method also resulted in a
+ * substantial reduction in object size of about 330 bytes (20%) from
+ * the old version (1627 bytes) on i386, even with the following
+ * improvements.
+ *
+ * Implemented %n specifier as required by the standards.
+ * Implemented proper handling of precision for int types.
+ * Implemented # for hex and pointer, fixed error for octal rep of 0.
+ * Implemented return of -1 on stream error.
+ *
+ * Added optional support for the GNU extension %m which prints the string
+ * corresponding the errno.
+ *
+ * Added optional support for long long ints and unsigned long long ints
+ * using the conversion qualifiers "ll", "L", or "q" (like glibc).
+ *
+ * Added optional support for doubles in a very limited form. None of
+ * the formating options are obeyed. The string returned by __dtostr
+ * is printed directly.
+ *
+ * Converted to use my (un)signed long (long) to string routines, which are
+ * smaller than the previous functions and don't require static buffers.
+ *
+ * Other Modifications:
+ * Modified sprintf, snprintf, vsprintf, vsnprintf to share on fake-file.
+ */
+
+/*
+ * Manuel Novoa III Jan 2001
+ *
+ * Removed fake file from *s*printf functions because of possible problems
+ * if called recursively. Instead, have sprintf, snprintf, and vsprintf
+ * call vsnprintf which allocates a fake file on the stack.
+ * Removed WANT_FPUTC option. Always use standard putc macro to avoid
+ * problems with the fake file used by the *s*printf functions.
+ * Fixed bug parsing flags -- did not restart scan.
+ * Added function asprintf.
+ * Fixed 0-pad prefixing bug.
+ * Converted sizeof(int) == sizeof(long) tests to compile time vs run time.
+ * This saves 112 bytes of code on i386.
+ * Fixed precision bug -- when negative set to default.
+ * Added function fnprintf to support __dtostr.
+ * Added floating point support for doubles. Yeah!
+ *
+ *
+ * 1) printf("%c",0) returned 0 instead of 1.
+ * 2) unrolled loop in asprintf to reduce size and remove compile warning.
+ *
+ *
+ * June 2001
+ * 1) fix %p so that "0x" is prepended to outputed hex val
+ * 2) fix %p so that "(nil)" is output for (void *)0 to match glibc
+ *
+ */
+
+/*****************************************************************************/
+/* OPTIONS */
+/*****************************************************************************/
+/* The optional support for long longs and doubles comes in two forms.
+ *
+ * 1) Normal (or partial for doubles) output support. Set to 1 to turn on.
+ * Adds about 130 bytes for doubles, about 220 bytes for long longs,
+ * and about 275 for both to the base code size of 1163 on i386.
+ */
+
+/* These are now set in uClibc_config.h based on Config. */
+/*
+#define __UCLIBC_HAS_FLOATS__ 1
+*/
+
+/* 2) An error message is inserted into the stream, an arg of the
+ * appropriate size is removed from the arglist, and processing
+ * continues. This is adds less code and may be useful in some
+ * cases. Set to 1 to turn on. Adds about 50 bytes for doubles,
+ * about 140 bytes for long longs, and about 175 bytes for both
+ * to the base code size of 1163 on i386.
+ */
+
+#define WANT_FLOAT_ERROR 0
+
+/*
+ * Set to support GNU extension of %m to print string corresponding to errno.
+ *
+ * Warning: This adds about 50 bytes (i386) to the code but it also pulls in
+ * strerror and the corresponding string table which together are about 3.8k.
+ */
+
+#define WANT_GNU_ERRNO 0
+
+/**************************************************************************/
+
+#define _GNU_SOURCE /* for strnlen */
+#define _STDIO_UTILITY
+#include <stdio.h>
+#include <stdarg.h>
+#include <limits.h>
+#include <string.h>
+#include <errno.h>
+
+#define __PRINTF_INFO_NO_BITFIELD
+#include <printf.h>
+
+#ifdef __STDIO_THREADSAFE
+#include <pthread.h>
+#endif /* __STDIO_THREADSAFE */
+
+/* #undef __UCLIBC_HAS_FLOATS__ */
+/* #undef WANT_FLOAT_ERROR */
+/* #define WANT_FLOAT_ERROR 1 */
+
+#define __isdigit(c) (((unsigned int)(c - '0')) < 10)
+
+extern size_t _dtostr(FILE * fp, long double x, struct printf_info *info);
+
+
+enum {
+ FLAG_PLUS = 0,
+ FLAG_MINUS_LJUSTIFY,
+ FLAG_HASH,
+ FLAG_0_PAD,
+ FLAG_SPACE,
+};
+
+/* layout 01234 */
+static const char spec[] = "+-#0 ";
+
+static const char qual[] = "hlLq";
+
+#if !defined(__UCLIBC_HAS_FLOATS__) && WANT_FLOAT_ERROR
+static const char dbl_err[] = "<DOUBLE>";
+#endif
+
+#if defined(__UCLIBC_HAS_FLOATS__) || WANT_FLOAT_ERROR
+/* layout 012345678901234567 */
+static const char u_spec[] = "%nbopxXudicsfgGeEaA";
+#else
+/* layout 0123456789012 */
+static const char u_spec[] = "%nbopxXudics";
+#endif
+
+/* WARNING: u_spec and u_radix need to stay in agreement!!! */
+/* u_radix[i] <-> u_spec[i+2] for unsigned entries only */
+static const char u_radix[] = "\x02\x08\x10\x10\x10\x0a";
+
+int vfprintf(FILE * __restrict op, register const char * __restrict fmt,
+ va_list ap)
+{
+ int i, cnt, lval, len;
+ char *p;
+ const char *fmt0;
+ int preci, width;
+#define upcase i
+ int radix, dpoint /*, upcase*/;
+ char tmp[65]; /* TODO - determing needed size from headers */
+ char flag[sizeof(spec)];
+
+ __STDIO_THREADLOCK(op);
+
+ cnt = 0;
+
+ while (*fmt) {
+ if (*fmt == '%') {
+ fmt0 = fmt; /* save our position in case of bad format */
+ ++fmt;
+ width = -1; /* min field width */
+ preci = -5; /* max string width or mininum digits */
+ radix = 10; /* number base */
+ dpoint = 0; /* found decimal point */
+#if INT_MAX != LONG_MAX
+ lval = 0; /* sizeof(int) != sizeof(long) */
+#else
+ lval = 1; /* sizeof(int) == sizeof(long) */
+#endif
+
+ /* init flags */
+ for (p =(char *) spec ; *p ; p++) {
+ flag[p-spec] = '\0';
+ }
+ flag[FLAG_0_PAD] = ' ';
+
+ /* process optional flags */
+ for (p = (char *)spec ; *p ; ) {
+ if (*fmt == *p) {
+ flag[p-spec] = *fmt++;
+ p = (char *)spec; /* restart scan */
+ } else {
+ p++;
+ }
+ }
+
+ if (!flag[FLAG_PLUS]) {
+ flag[FLAG_PLUS] = flag[FLAG_SPACE];
+ }
+
+ /* process optional width and precision */
+ do {
+ if (*fmt == '.') {
+ ++fmt;
+ dpoint = 1;
+ }
+ if (*fmt == '*') { /* parameter width value */
+ ++fmt;
+ i = va_arg(ap, int);
+ } else {
+ for ( i = 0 ; (*fmt >= '0') && (*fmt <= '9') ; ++fmt ) {
+ i = (i * 10) + (*fmt - '0');
+ }
+ }
+
+ if (dpoint) {
+ preci = i;
+ if (i<0) {
+ preci = -5;
+ }
+ } else {
+ width = i;
+ if (i<0) {
+ width = -i;
+ flag[FLAG_MINUS_LJUSTIFY] = 1;
+ }
+ }
+ } while ((*fmt == '.') && !dpoint );
+
+ /* process optional qualifier */
+ for (p = (char *) qual ; *p ; p++) {
+ if (*p == *fmt) {
+ lval = p - qual;
+ ++fmt; /* TODO - hh */
+ if ((*p == 'l') && (*fmt == *p)) {
+ ++lval;
+ ++fmt;
+ }
+ }
+ }
+
+#if WANT_GNU_ERRNO
+ if (*fmt == 'm') {
+ flag[FLAG_PLUS] = '\0';
+ flag[FLAG_0_PAD] = ' ';
+ p = strerror(errno);
+ goto print;
+ }
+#endif
+
+ /* process format specifier */
+ for (p = (char *) u_spec ; *p ; p++) {
+ if (*fmt != *p) continue;
+ if (p-u_spec < 1) { /* print a % */
+ goto charout;
+ }
+ if (p-u_spec < 2) { /* store output count in int ptr */
+ *(va_arg(ap, int *)) = cnt;
+ goto nextfmt;
+ }
+ if (p-u_spec < 8) { /* unsigned conversion */
+ radix = u_radix[p-u_spec-2];
+ upcase = ((*p == 'x') ? __UIM_LOWER : __UIM_UPPER);
+ if (*p == 'p') {
+ lval = (sizeof(char *) == sizeof(long));
+ upcase = __UIM_LOWER;
+ flag[FLAG_HASH] = 'p';
+ }
+
+ p = _uintmaxtostr((tmp + sizeof(tmp) - 1),
+ ((lval>1) /* TODO -- longlong/long/int/short/char */
+ ? va_arg(ap, uintmax_t)
+ : (uintmax_t)
+ va_arg(ap, unsigned long)),
+ radix, upcase);
+
+ flag[FLAG_PLUS] = '\0'; /* meaningless for unsigned */
+ if (*p != '0') { /* non-zero */
+ if (flag[FLAG_HASH]) {
+ if (radix == 8) {
+ *--p = '0'; /* add leadding zero */
+ } else if (radix != 10) { /* either 2 or 16 */
+ flag[FLAG_PLUS] = '0';
+ *--p = 'b';
+ if (radix == 16) {
+ *p = 'x';
+ if (*fmt == 'X') {
+ *p = 'X';
+ }
+ }
+ }
+ }
+ } else if (flag[FLAG_HASH] == 'p') { /* null pointer */
+ p = "(nil)";
+ }
+ } else if (p-u_spec < 10) { /* signed conversion */
+
+ 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! */
+ va_arg(ap, long))),
+ -radix, upcase);
+
+ } else if (p-u_spec < 12) { /* character or string */
+ flag[FLAG_PLUS] = '\0';
+ flag[FLAG_0_PAD] = ' ';
+ if (*p == 'c') { /* character */
+ p = tmp;
+ *p = va_arg(ap, int);
+ /* This takes care of the "%c",0 case */
+ len = 1;
+ goto print_len_set;
+ } else { /* string */
+ p = va_arg(ap, char *);
+ if (!p) {
+ p = "(null)";
+ preci = 6;
+ } else {
+ if (preci < 0) {
+ preci = INT_MAX;
+ }
+ }
+ len = strnlen(p, preci);
+ goto print_len_set;
+ }
+#if defined(__UCLIBC_HAS_FLOATS__) || WANT_FLOAT_ERROR
+ } else if (p-u_spec < 27) { /* floating point */
+#endif /* defined(__UCLIBC_HAS_FLOATS__) || WANT_FLOAT_ERROR */
+#if defined(__UCLIBC_HAS_FLOATS__)
+ struct printf_info info;
+ if (preci < 0) {
+ preci = 6;
+ }
+ info.width = width;
+ info.prec = preci;
+ info.spec = *fmt;
+ info.pad = flag[FLAG_0_PAD];
+ info._flags = 0;
+ if (flag[FLAG_PLUS] == '+') {
+ PRINT_INFO_SET_FLAG(&info,showsign);
+ } else if (flag[FLAG_PLUS] == ' ') {
+ PRINT_INFO_SET_FLAG(&info,space);
+ }
+ if (flag[FLAG_HASH]) {
+ PRINT_INFO_SET_FLAG(&info,alt);
+ }
+ if (flag[FLAG_MINUS_LJUSTIFY]) {
+ PRINT_INFO_SET_FLAG(&info,left);
+ }
+ cnt += _dtostr(op,
+ ((lval > 1)
+ ? va_arg(ap, long double)
+ : (long double) va_arg(ap, double)),
+ &info);
+ goto nextfmt;
+#elif WANT_FLOAT_ERROR
+ (void) ((lval > 1) ? va_arg(ap, long double)
+ : va_arg(ap, double)); /* carry on */
+ p = (char *) dbl_err;
+#endif /* defined(__UCLIBC_HAS_FLOATS__) */
+ }
+
+#if WANT_GNU_ERRNO
+ print:
+#endif
+ { /* this used to be printfield */
+ /* cheaper than strlen call */
+/* for ( len = 0 ; p[len] ; len++ ) { } */
+ len = strnlen(p, SIZE_MAX);
+ print_len_set:
+ if ((*p == '-')
+#if WANT_GNU_ERRNO
+ && (*fmt != 'm')
+#endif
+ && (*fmt != 's')) {
+ flag[FLAG_PLUS] = *p++;
+ --len;
+ }
+ if (flag[FLAG_PLUS]) {
+ ++len;
+ ++preci;
+ if (flag[FLAG_PLUS] == '0') { /* base 16 */
+ ++preci; /* account for x or X */
+ }
+ }
+
+ if (preci >= 0) {
+ if ((*fmt == 's')
+#if WANT_GNU_ERRNO
+ || (*fmt == 'm')
+#endif
+ ) {
+ if (len > preci) {
+ len = preci;
+ } else {
+ preci = len;
+ }
+ }
+ preci -= len;
+ if (preci < 0) {
+ preci = 0;
+ }
+ width -= preci;
+ }
+
+ width -= len;
+ if (width < 0) {
+ width = 0;
+ }
+
+ if (preci < 0) {
+ preci = 0;
+ if (!flag[FLAG_MINUS_LJUSTIFY]
+ /* && flag[FLAG_PLUS] */
+ && (flag[FLAG_0_PAD] == '0')) {
+ preci = width;
+ width = 0;
+ }
+ }
+
+ while (width + len + preci) {
+ unsigned char ch;
+ /* right padding || left padding */
+ if ((!len && !preci)
+ || (width && !flag[FLAG_MINUS_LJUSTIFY])) {
+ ch = ' ';
+ --width;
+ } else if (flag[FLAG_PLUS]) {
+ ch = flag[FLAG_PLUS]; /* sign */
+ if (flag[FLAG_PLUS]=='0') { /* base 16 case */
+ flag[FLAG_PLUS] = *p++; /* get the x|X */
+ } else {
+ flag[FLAG_PLUS] = '\0';
+ }
+ --len;
+ } else if (preci) {
+ ch = '0';
+ --preci;
+ } else {
+ ch = *p++; /* main field */
+ --len;
+ }
+ ++cnt;
+ putc(ch, op);
+ }
+ }
+ goto nextfmt;
+ }
+
+ fmt = fmt0; /* this was an illegal format */
+ }
+
+ charout:
+ ++cnt;
+ putc(*fmt, op); /* normal char out */
+
+ nextfmt:
+ ++fmt;
+ }
+
+ i = (__FERROR(op)) ? -1 : cnt;
+
+ __STDIO_THREADLOCK(op);
+
+ return i;
+}
+++ /dev/null
-#include <string.h>
-#include <stdio.h>
-#include <errno.h>
-
-/*
- * Manuel Novoa III Feb 2001
- *
- * Replaced old version that did write(2,...)'s with a version using
- * stream functions. If the program is calling perror, it's a safe
- * bet that printf and friends are used as well. It is also possible
- * that the calling program could buffer stderr, or reassign it.
- * Also, the old version did not conform the standards when the
- * passed char * was either NULL or pointed to an empty string.
- */
-
-void perror(__const char *str)
-{
- static const char perror_str[] = ": ";
- const char *sep;
-
- sep = perror_str;
- if (!(str && *str)) { /* Caller did not supply a prefix message */
- sep += 2; /* or passed an empty string. */
- str = sep;
- }
- fprintf(stderr, "%s%s%s\n", str, sep, strerror(errno));
-}
+++ /dev/null
-/*
- * This file based on printf.c from 'Dlibs' on the atari ST (RdeBath)
- *
- *
- * Dale Schumacher 399 Beacon Ave.
- * (alias: Dalnefre') St. Paul, MN 55104
- * "It's not reality that's important, but how you perceive things."
- */
-
-/* Altered to use stdarg, made the core function vfnprintf.
- * Hooked into the stdio package using 'inside information'
- * Altered sizeof() assumptions, now assumes all integers except chars
- * will be either
- * sizeof(xxx) == sizeof(long) or sizeof(xxx) == sizeof(short)
- *
- * -RDB
- */
-
-/*
- * Manuel Novoa III Dec 2000
- *
- * The previous vfnprintf routine was almost completely rewritten with the
- * goal of fixing some shortcomings and reducing object size.
- *
- * The summary of changes:
- *
- * Converted print conversion specification parsing from one big switch
- * to a method using string tables. This new method verifies that the
- * conversion flags, field width, precision, qualifier, and specifier
- * appear in the correct order. Many questionable specifications were
- * accepted by the previous code. This new method also resulted in a
- * substantial reduction in object size of about 330 bytes (20%) from
- * the old version (1627 bytes) on i386, even with the following
- * improvements.
- *
- * Implemented %n specifier as required by the standards.
- * Implemented proper handling of precision for int types.
- * Implemented # for hex and pointer, fixed error for octal rep of 0.
- * Implemented return of -1 on stream error.
- *
- * Added optional support for the GNU extension %m which prints the string
- * corresponding the errno.
- *
- * Added optional support for long long ints and unsigned long long ints
- * using the conversion qualifiers "ll", "L", or "q" (like glibc).
- *
- * Added optional support for doubles in a very limited form. None of
- * the formating options are obeyed. The string returned by __dtostr
- * is printed directly.
- *
- * Converted to use my (un)signed long (long) to string routines, which are
- * smaller than the previous functions and don't require static buffers.
- *
- * Other Modifications:
- * Modified sprintf, snprintf, vsprintf, vsnprintf to share on fake-file.
- */
-
-/*
- * Manuel Novoa III Jan 2001
- *
- * Removed fake file from *s*printf functions because of possible problems
- * if called recursively. Instead, have sprintf, snprintf, and vsprintf
- * call vsnprintf which allocates a fake file on the stack.
- * Removed WANT_FPUTC option. Always use standard putc macro to avoid
- * problems with the fake file used by the *s*printf functions.
- * Fixed bug parsing flags -- did not restart scan.
- * Added function asprintf.
- * Fixed 0-pad prefixing bug.
- * Converted sizeof(int) == sizeof(long) tests to compile time vs run time.
- * This saves 112 bytes of code on i386.
- * Fixed precision bug -- when negative set to default.
- * Added function fnprintf to support __dtostr.
- * Added floating point support for doubles. Yeah!
- *
- *
- * 1) printf("%c",0) returned 0 instead of 1.
- * 2) unrolled loop in asprintf to reduce size and remove compile warning.
- *
- *
- * June 2001
- * 1) fix %p so that "0x" is prepended to outputed hex val
- * 2) fix %p so that "(nil)" is output for (void *)0 to match glibc
- *
- */
-
-/*****************************************************************************/
-/* OPTIONS */
-/*****************************************************************************/
-/* The optional support for long longs and doubles comes in two forms.
- *
- * 1) Normal (or partial for doubles) output support. Set to 1 to turn on.
- * Adds about 130 bytes for doubles, about 220 bytes for long longs,
- * and about 275 for both to the base code size of 1163 on i386.
- */
-
-/* These are now set in uClibc_config.h based on Config. */
-/*
-#define __UCLIBC_HAS_LONG_LONG__ 1
-#define __UCLIBC_HAS_FLOATS__ 1
-*/
-
-/* 2) An error message is inserted into the stream, an arg of the
- * appropriate size is removed from the arglist, and processing
- * continues. This is adds less code and may be useful in some
- * cases. Set to 1 to turn on. Adds about 50 bytes for doubles,
- * about 140 bytes for long longs, and about 175 bytes for both
- * to the base code size of 1163 on i386.
- */
-
-#define WANT_LONG_LONG_ERROR 0
-#define WANT_FLOAT_ERROR 0
-
-/*
- * Set to support GNU extension of %m to print string corresponding to errno.
- *
- * Warning: This adds about 50 bytes (i386) to the code but it also pulls in
- * strerror and the corresponding string table which together are about 3.8k.
- */
-
-#define WANT_GNU_ERRNO 0
-
-/**************************************************************************/
-
-#include <sys/types.h>
-#include <fcntl.h>
-#include <string.h>
-#include <stdlib.h>
-#include <limits.h>
-#include <assert.h>
-
-#if WANT_GNU_ERRNO
-#include <errno.h>
-#endif
-
-#ifdef __STDC__
-#include <stdarg.h>
-#define va_strt va_start
-#else
-#include <varargs.h>
-#define va_strt(p,i) va_start(p)
-#endif
-
-#include "stdio.h"
-
-extern int vfnprintf(FILE * op, size_t max_size,
- register __const char *fmt, register va_list ap);
-
-#ifdef L_printf
-int printf(const char *fmt, ...)
-{
- va_list ptr;
- int rv;
-
- va_strt(ptr, fmt);
- rv = vfnprintf(stdout, -1, fmt, ptr);
- va_end(ptr);
- return rv;
-}
-#endif
-
-#ifdef L_asprintf
-int asprintf(char **app, const char *fmt, ...)
-{
- va_list ptr;
- int rv;
- char *p;
-
- /*
- * First iteration - find out size of buffer required and allocate it.
- */
- va_strt(ptr, fmt);
- rv = vsnprintf(NULL, 0, fmt, ptr);
- va_end(ptr);
-
- p = malloc(++rv); /* allocate the buffer */
- *app = p;
- if (!p) {
- return -1;
- }
-
- /*
- * Second iteration - actually produce output.
- */
- va_strt(ptr, fmt);
- rv = vsnprintf(p, rv, fmt, ptr);
- va_end(ptr);
-
- return rv;
-}
-#endif
-
-#ifdef L_sprintf
-int sprintf(char *sp, const char *fmt, ...)
-{
- va_list ptr;
- int rv;
-
- va_strt(ptr, fmt);
- rv = vsnprintf(sp, -1, fmt, ptr);
- va_end(ptr);
- return rv;
-}
-#endif
-
-
-#ifdef L_snprintf
-int snprintf(char *sp, size_t size, const char *fmt, ...)
-{
- va_list ptr;
- int rv;
-
- va_strt(ptr, fmt);
- rv = vsnprintf(sp, size, fmt, ptr);
- va_end(ptr);
- return rv;
-}
-#endif
-
-#ifdef L_fprintf
-int fprintf(FILE * fp, const char *fmt, ...)
-{
- va_list ptr;
- int rv;
-
- va_strt(ptr, fmt);
- rv = vfnprintf(fp, -1, fmt, ptr);
- va_end(ptr);
- return rv;
-}
-#endif
-
-#ifdef L_fnprintf
-int fnprintf(FILE * fp, size_t size, const char *fmt, ...)
-{
- va_list ptr;
- int rv;
-
- va_strt(ptr, fmt);
- rv = vfnprintf(fp, size, fmt, ptr);
- va_end(ptr);
- return rv;
-}
-#endif
-
-#ifdef L_vprintf
-int vprintf(const char *fmt, va_list ap)
-{
- return vfprintf(stdout, fmt, ap);
-}
-#endif
-
-#ifdef L_vfprintf
-
-int vfprintf(FILE * op, register __const char *fmt, register va_list ap)
-{
- return vfnprintf(op, -1, fmt, ap);
-}
-
-#endif
-
-#ifdef L_vsprintf
-int vsprintf(char *sp, __const char *fmt, va_list ap)
-{
- return vsnprintf(sp, -1, fmt, ap);
-}
-#endif
-
-#ifdef L_vsnprintf
-int vsnprintf(char *sp, size_t size, __const char *fmt, va_list ap)
-{
- int rv;
- FILE f;
-
- /*
- * As we're only using the putc macro in vfnprintf, we don't need to
- * initialize all FILE f's fields.
- */
- f.bufwrite = (char *) ((unsigned) -1);
- f.bufpos = sp;
- f.mode = _IOFBF;
-
- rv = vfnprintf(&f, size, fmt, ap);
- if (size) { /* If this is going to a buffer, */
- *(f.bufpos) = 0; /* don't forget to nul-terminate. */
- }
- return rv;
-}
-#endif
-
-#ifdef L_vdprintf
-/*
- * Note: If fd has an associated buffered FILE, bad things happen.
- */
-extern int vdprintf(int fd, const char *fmt, va_list ap)
-{
- char buf[BUFSIZ];
- FILE f = {buf, 0, buf+sizeof(buf), buf, buf+sizeof(buf), 0, fd, _IOFBF};
- int rv;
-
- rv = vfnprintf(&f, -1, fmt, ap);
-
- if (fflush(&f)) {
- return -1;
- }
-
- return rv;
-}
-#endif
-
-#ifdef L_vfnprintf
-
-extern char *__ultostr(char *buf, unsigned long uval, int base, int uppercase);
-extern char *__ltostr(char *buf, long val, int base, int uppercase);
-extern char *__ulltostr(char *buf, unsigned long long uval, int base, int uppercase);
-extern char *__lltostr(char *buf, long long val, int base, int uppercase);
-extern int __dtostr(FILE * fp, size_t size, long double x,
- char flag[], int width, int preci, char mode);
-
-enum {
- FLAG_PLUS = 0,
- FLAG_MINUS_LJUSTIFY,
- FLAG_HASH,
- FLAG_0_PAD,
- FLAG_SPACE,
-};
-
-/* layout 01234 */
-static const char spec[] = "+-#0 ";
-
-#if defined(__UCLIBC_HAS_LONG_LONG__) || WANT_LONG_LONG_ERROR
-static const char qual[] = "hlLq";
-#else
-static const char qual[] = "hl";
-#endif
-
-#if !defined(__UCLIBC_HAS_LONG_LONG__) && WANT_LONG_LONG_ERROR
-static const char ll_err[] = "<LONG-LONG>";
-#endif
-
-#if !defined(__UCLIBC_HAS_FLOATS__) && WANT_FLOAT_ERROR
-static const char dbl_err[] = "<DOUBLE>";
-#endif
-
-#if defined(__UCLIBC_HAS_FLOATS__) || WANT_FLOAT_ERROR
-/* layout 012345678901234567 */
-static const char u_spec[] = "%nbopxXudicsfgGeEaA";
-#else
-/* layout 0123456789012 */
-static const char u_spec[] = "%nbopxXudics";
-#endif
-
-/* WARNING: u_spec and u_radix need to stay in agreement!!! */
-/* u_radix[i] <-> u_spec[i+2] for unsigned entries only */
-static const char u_radix[] = "\x02\x08\x10\x10\x10\x0a";
-
-int vfnprintf(FILE * op, size_t max_size, const char *fmt, va_list ap)
-{
- int i, cnt, lval, len;
- char *p;
- const char *fmt0;
- int buffer_mode;
- int preci, width;
-#define upcase i
- int radix, dpoint /*, upcase*/;
-#if defined(__UCLIBC_HAS_LONG_LONG__)
- char tmp[65];
-#else
- char tmp[33];
-#endif
- char flag[sizeof(spec)];
-
- cnt = 0;
-
- /* This speeds things up a bit for line unbuffered */
- buffer_mode = (op->mode & __MODE_BUF);
- op->mode &= (~__MODE_BUF);
-
- while (*fmt) {
- if (*fmt == '%') {
- fmt0 = fmt; /* save our position in case of bad format */
- ++fmt;
- width = -1; /* min field width */
- preci = -5; /* max string width or mininum digits */
- radix = 10; /* number base */
- dpoint = 0; /* found decimal point */
-#if INT_MAX != LONG_MAX
- lval = 0; /* sizeof(int) != sizeof(long) */
-#else
- lval = 1; /* sizeof(int) == sizeof(long) */
-#endif
-
- tmp[1] = 0; /* set things up for %c -- better done here */
-
- /* init flags */
- for (p =(char *) spec ; *p ; p++) {
- flag[p-spec] = '\0';
- }
- flag[FLAG_0_PAD] = ' ';
-
- /* process optional flags */
- for (p = (char *)spec ; *p ; ) {
- if (*fmt == *p) {
- flag[p-spec] = *fmt++;
- p = (char *)spec; /* restart scan */
- } else {
- p++;
- }
- }
-
- if (!flag[FLAG_PLUS]) {
- flag[FLAG_PLUS] = flag[FLAG_SPACE];
- }
-
- /* process optional width and precision */
- do {
- if (*fmt == '.') {
- ++fmt;
- dpoint = 1;
- }
- if (*fmt == '*') { /* parameter width value */
- ++fmt;
- i = va_arg(ap, int);
- } else {
- for ( i = 0 ; (*fmt >= '0') && (*fmt <= '9') ; ++fmt ) {
- i = (i * 10) + (*fmt - '0');
- }
- }
-
- if (dpoint) {
- preci = i;
- if (i<0) {
- preci = -5;
- }
- } else {
- width = i;
- if (i<0) {
- width = -i;
- flag[FLAG_MINUS_LJUSTIFY] = 1;
- }
- }
- } while ((*fmt == '.') && !dpoint );
-
- /* process optional qualifier */
- for (p = (char *) qual ; *p ; p++) {
- if (*p == *fmt) {
- lval = p - qual;
- ++fmt;
-#if defined(__UCLIBC_HAS_LONG_LONG__) || WANT_LONG_LONG_ERROR
- if ((*p == 'l') && (*fmt == *p)) {
- ++lval;
- ++fmt;
- }
-#endif /* defined(__UCLIBC_HAS_LONG_LONG__) || WANT_LONG_LONG_ERROR */
- }
- }
-
-#if WANT_GNU_ERRNO
- if (*fmt == 'm') {
- flag[FLAG_PLUS] = '\0';
- flag[FLAG_0_PAD] = ' ';
- p = strerror(errno);
- goto print;
- }
-#endif
-
- /* process format specifier */
- for (p = (char *) u_spec ; *p ; p++) {
- if (*fmt != *p) continue;
- if (p-u_spec < 1) { /* print a % */
- goto charout;
- }
- if (p-u_spec < 2) { /* store output count in int ptr */
- *(va_arg(ap, int *)) = cnt;
- goto nextfmt;
- }
- if (p-u_spec < 8) { /* unsigned conversion */
- radix = u_radix[p-u_spec-2];
- upcase = ((int)'x') - *p;
- if (*p == 'p') {
- lval = (sizeof(char *) == sizeof(long));
- upcase = 0;
- flag[FLAG_HASH] = 'p';
- }
-#if defined(__UCLIBC_HAS_LONG_LONG__) || WANT_LONG_LONG_ERROR
- if (lval >= 2) {
-#if defined(__UCLIBC_HAS_LONG_LONG__)
- p = __ulltostr(tmp + sizeof(tmp) - 1,
- va_arg(ap, unsigned long long),
- radix, upcase);
-#else
- (void) va_arg(ap, unsigned long long); /* cary on */
- p = (char *) ll_err;
-#endif /* defined(__UCLIBC_HAS_LONG_LONG__) */
- } else {
-#endif /* defined(__UCLIBC_HAS_LONG_LONG__) || WANT_LONG_LONG_ERROR */
-#if UINT_MAX != ULONG_MAX
- /* sizeof(unsigned int) != sizeof(unsigned long) */
- p = __ultostr(tmp + sizeof(tmp) - 1, (unsigned long)
- ((lval)
- ? va_arg(ap, unsigned long)
- : va_arg(ap, unsigned int)),
- radix, upcase);
-#else
- /* sizeof(unsigned int) == sizeof(unsigned long) */
- p = __ultostr(tmp + sizeof(tmp) - 1, (unsigned long)
- va_arg(ap, unsigned long),
- radix, upcase);
-#endif
-#if defined(__UCLIBC_HAS_LONG_LONG__) || WANT_LONG_LONG_ERROR
- }
-#endif /* defined(__UCLIBC_HAS_LONG_LONG__) || WANT_LONG_LONG_ERROR */
- flag[FLAG_PLUS] = '\0'; /* meaningless for unsigned */
- if (*p != '0') { /* non-zero */
- if (flag[FLAG_HASH]) {
- if (radix == 8) {
- *--p = '0'; /* add leadding zero */
- } else if (radix != 10) { /* either 2 or 16 */
- flag[FLAG_PLUS] = '0';
- *--p = 'b';
- if (radix == 16) {
- *p = 'x';
- if (*fmt == 'X') {
- *p = 'X';
- }
- }
- }
- }
- } else if (flag[FLAG_HASH] == 'p') { /* null pointer */
- p = "(nil)";
- }
- } else if (p-u_spec < 10) { /* signed conversion */
-#if defined(__UCLIBC_HAS_LONG_LONG__) || WANT_LONG_LONG_ERROR
- if (lval >= 2) {
-#if defined(__UCLIBC_HAS_LONG_LONG__)
- p = __lltostr(tmp + sizeof(tmp) - 1,
- va_arg(ap, long long), 10, 0);
-#else
- (void) va_arg(ap, long long); /* carry on */
- p = (char *) ll_err;
-#endif /* defined(__UCLIBC_HAS_LONG_LONG__) */
- } else {
-#endif /* defined(__UCLIBC_HAS_LONG_LONG__) || WANT_LONG_LONG_ERROR */
-#if INT_MAX != LONG_MAX
- /* sizeof(int) != sizeof(long) */
- p = __ltostr(tmp + sizeof(tmp) - 1, (long)
- ((lval)
- ? va_arg(ap, long)
- : va_arg(ap, int)), 10, 0);
-#else
- /* sizeof(int) == sizeof(long) */
- p = __ltostr(tmp + sizeof(tmp) - 1, (long)
- va_arg(ap, long), 10, 0);
-#endif
-#if defined(__UCLIBC_HAS_LONG_LONG__) || WANT_LONG_LONG_ERROR
- }
-#endif /* defined(__UCLIBC_HAS_LONG_LONG__) || WANT_LONG_LONG_ERROR */
- } else if (p-u_spec < 12) { /* character or string */
- flag[FLAG_PLUS] = '\0';
- flag[FLAG_0_PAD] = ' ';
- if (*p == 'c') { /* character */
- p = tmp;
- *p = va_arg(ap, int);
- /* This takes care of the "%c",0 case */
- len = 1;
- goto print_len_set;
- } else { /* string */
- p = va_arg(ap, char *);
- if (!p) {
- p = "(null)";
- }
- }
-#if defined(__UCLIBC_HAS_FLOATS__) || WANT_FLOAT_ERROR
- } else if (p-u_spec < 27) { /* floating point */
-#endif /* defined(__UCLIBC_HAS_FLOATS__) || WANT_FLOAT_ERROR */
-#if defined(__UCLIBC_HAS_FLOATS__)
- if (preci < 0) {
- preci = 6;
- }
- cnt += __dtostr(op,
- (max_size > cnt ? max_size - cnt : 0),
- (long double) ((lval > 1)
- ? va_arg(ap, long double)
- : va_arg(ap, double)),
- flag, width, preci, *fmt);
- goto nextfmt;
-#elif WANT_FLOAT_ERROR
- (void) ((lval > 1) ? va_arg(ap, long double)
- : va_arg(ap, double)); /* carry on */
- p = (char *) dbl_err;
-#endif /* defined(__UCLIBC_HAS_FLOATS__) */
- }
-
-#if WANT_GNU_ERRNO
- print:
-#endif
- { /* this used to be printfield */
- /* cheaper than strlen call */
- for ( len = 0 ; p[len] ; len++ ) { }
- print_len_set:
- if ((*p == '-')
-#if WANT_GNU_ERRNO
- && (*fmt != 'm')
-#endif
- && (*fmt != 's')) {
- flag[FLAG_PLUS] = *p++;
- --len;
- }
- if (flag[FLAG_PLUS]) {
- ++len;
- ++preci;
- if (flag[FLAG_PLUS] == '0') { /* base 16 */
- ++preci; /* account for x or X */
- }
- }
-
- if (preci >= 0) {
- if ((*fmt == 's')
-#if WANT_GNU_ERRNO
- || (*fmt == 'm')
-#endif
- ) {
- if (len > preci) {
- len = preci;
- } else {
- preci = len;
- }
- }
- preci -= len;
- if (preci < 0) {
- preci = 0;
- }
- width -= preci;
- }
-
- width -= len;
- if (width < 0) {
- width = 0;
- }
-
- if (preci < 0) {
- preci = 0;
- if (!flag[FLAG_MINUS_LJUSTIFY]
- /* && flag[FLAG_PLUS] */
- && (flag[FLAG_0_PAD] == '0')) {
- preci = width;
- width = 0;
- }
- }
-
- while (width + len + preci) {
- unsigned char ch;
- /* right padding || left padding */
- if ((!len && !preci)
- || (width && !flag[FLAG_MINUS_LJUSTIFY])) {
- ch = ' ';
- --width;
- } else if (flag[FLAG_PLUS]) {
- ch = flag[FLAG_PLUS]; /* sign */
- if (flag[FLAG_PLUS]=='0') { /* base 16 case */
- flag[FLAG_PLUS] = *p++; /* get the x|X */
- } else {
- flag[FLAG_PLUS] = '\0';
- }
- --len;
- } else if (preci) {
- ch = '0';
- --preci;
- } else {
- ch = *p++; /* main field */
- --len;
- }
-
- if (++cnt < max_size) {
- putc(ch, op);
- }
- if ((ch == '\n') && (buffer_mode == _IOLBF)) {
- fflush(op);
- }
- }
- }
- goto nextfmt;
- }
-
- fmt = fmt0; /* this was an illegal format */
- }
-
- charout:
- if (++cnt < max_size) {
- putc(*fmt, op); /* normal char out */
- }
- if ((*fmt == '\n') && (buffer_mode == _IOLBF)) {
- fflush(op);
- }
-
- nextfmt:
- ++fmt;
- }
-
- op->mode |= buffer_mode;
- if (buffer_mode == _IOLBF) {
- op->bufwrite = op->bufpos;
- }
-
- if (ferror(op)) {
- cnt = -1;
- }
- return (cnt);
-}
-
-#endif
-
+++ /dev/null
-/* Copyright (C) 1991, 1997, 1998 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 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
- Lesser General Public License for more details.
-
- 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>
-
-#ifdef USE_IN_LIBIO
-# include <libio/iolibio.h>
-# define fwrite(p, n, m, s) _IO_fwrite (p, n, m, s)
-#endif
-
-/* Write the word (int) W to STREAM. */
-int
-putw (int w, FILE *stream)
-{
- /* Is there a better way? */
- if (fwrite ((const void *) &w, sizeof (w), 1, stream) < 1)
- return EOF;
- return 0;
-}
+++ /dev/null
- * This file is part of the Linux-8086 C library and is distributed
- * under the GNU Library General Public License.
- */
-#include <unistd.h>
-#include <string.h>
-#include <sys/types.h>
-#include <errno.h>
-
-int remove(src)
-__const char *src;
-{
- extern int errno;
- int er = errno;
- int rv = unlink(src);
-
- if (rv < 0 && errno == EISDIR)
- rv = rmdir(src);
- if (rv >= 0)
- __set_errno(er);
- return rv;
-}
-
* implementation doesn't for the "100ergs" case mentioned above.
*/
-#include <stdlib.h>
-#include <unistd.h>
+#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>
+#include <unistd.h>
#include <ctype.h>
#include <string.h>
#include <stdarg.h>
+#ifdef __STDIO_THREADSAFE
+#include <pthread.h>
+#endif /* __STDIO_THREADSAFE */
+
#ifdef L_scanf
#ifdef __STDC__
int scanf(const char *fmt, ...)
#endif
#ifdef L_sscanf
-#ifdef __STDC__
-int sscanf(const char *sp, const char *fmt, ...)
+#if !defined(__STDIO_BUFFERS) && !defined(__STDIO_GLIBC_CUSTOM_STREAMS)
+#warning skipping sscanf since no buffering and no custom streams!
#else
-int sscanf(sp, fmt, va_alist)
-__const char *sp;
-__const char *fmt;
-va_dcl
-#endif
-{
- FILE string[1] = {
- {0, (unsigned char *) ((unsigned) -1), 0, 0, (char *) ((unsigned) -1),
- 0, -1, _IOFBF}
- };
+int sscanf(const char *sp, const char *fmt, ...)
+{
va_list ptr;
int rv;
- string->bufpos = (unsigned char *) ((void *) sp);
va_start(ptr, fmt);
- rv = vfscanf(string, fmt, ptr);
+ rv = vsscanf(sp, fmt, ptr);
va_end(ptr);
return rv;
}
+
+#endif
#endif
#ifdef L_fscanf
#endif
#ifdef L_vsscanf
+#ifdef __STDIO_BUFFERS
int vsscanf(__const char *sp, __const char *fmt, va_list ap)
{
- FILE string[1] = {
- {0, (unsigned char *) ((unsigned) -1), 0, 0, (char *) ((unsigned) -1),
- 0, -1, _IOFBF}
- };
+ FILE string[1];
+
+ string->filedes = -2; /* for debugging */
+ string->modeflags = (__FLAG_NARROW|__FLAG_READONLY);
+ string->bufstart = string->bufrpos = (unsigned char *) ((void *) sp);
+ string->bufgetc = (char *) ((unsigned) -1);
- string->bufpos = (unsigned char *) sp;
return vfscanf(string, fmt, ap);
}
+#else /* __STDIO_BUFFERS */
+#ifdef __STDIO_GLIBC_CUSTOM_STREAMS
+int vsscanf(__const char *sp, __const char *fmt, va_list ap)
+{
+ FILE *f;
+ int rv;
+
+ if ((f = fmemopen((char *)sp, strlen(sp), "r")) == NULL) {
+ return -1;
+ }
+ rv = vfscanf(f, fmt, ap);
+ fclose(f);
+
+ return rv;
+}
+#else /* __STDIO_GLIBC_CUSTOM_STREAMS */
+#warning skipping vsscanf since no buffering and no custom streams!
+#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */
+#endif /* __STDIO_BUFFERS */
#endif
#ifdef L_vfscanf
int width_flag;
int ungot_char;
int ungot_flag;
+ int app_ungot;
};
#ifdef __UCLIBC_HAS_LONG_LONG__
sc->nread = 0;
sc->width_flag = 0;
sc->ungot_flag = 0;
+ sc->app_ungot = ((fp->modeflags & __MASK_UNGOT) ? fp->ungot[1] : 0);
}
+/* TODO -- what about literal '\0' chars in a file??? */
+
static int scan_getc_nw(struct scan_cookie *sc)
{
if (sc->ungot_flag == 0) {
{
if (sc->ungot_flag) {
ungetc(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. */
+ }
}
}
unsigned char buf[MAX_DIGITS+2];
unsigned char scanset[UCHAR_MAX + 1];
+ __STDIO_THREADLOCK(fp);
+
init_scan_cookie(&sc,fp);
fmt = (unsigned const char *) format;
goto done;
}
/* Unrecognized specifier! */
- goto done;
+ goto RETURN_cnt;
} if (isspace(*fmt)) { /* Consume all whitespace. */
while (isspace(scan_getc_nw(&sc)))
{}
kill_scan_cookie(&sc);
if ((sc.ungot_char <= 0) && (cnt == 0) && (*fmt)) {
- return (EOF);
+ cnt = EOF;
}
+ RETURN_cnt:
+ __STDIO_THREADUNLOCK(fp);
+
return (cnt);
}
+++ /dev/null
- * This file is part of the Linux-8086 C library and is distributed
- * under the GNU Library General Public License.
- */
-
-/* This is an implementation of the C standard IO package.
- *
- * Updates:
- * 29-Sep-2000 W. Greathouse 1. fgetc copying beyond end of buffer
- * 2. stdout needs flushed when input requested on
- * stdin.
- * 3. bufend was set incorrectly to 4 bytes beyond
- * bufin (sizeof a pointer) instead of BUFSIZ.
- * This resulted in 4 byte buffers for full
- * buffered stdin and stdout and an 8 byte
- * buffer for the unbuffered stderr!
- */
-
-/*
- * Feb 27, 2001 Manuel Novoa III
- *
- * Most of the core functionality has been completely rewritten.
- * A number of functions have been added as well, as mandated by C89.
- *
- * An extension function "fsfopen" has been added:
- * Open a file using an automatically (stack) or statically allocated FILE.
- * The FILE * returned behaves just as any other FILE * with respect to the
- * stdio functions, but be aware of the following:
- * NOTE: The buffer used for the file is FILE's builtin 2-byte buffer, so
- * setting a new buffer is probably advisable.
- * NOTE: This function is primarily intended to be used for stack-allocated
- * FILEs when uClibc stdio has no dynamic memory support.
- * For the statically allocated case, it is probably better to increase
- * the value of FIXED_STREAMS in stdio.c.
- * WARNING: If allocated on the stack, make sure you call fclose before the
- * stack memory is reclaimed!
- */
-
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <sys/types.h>
-#include <malloc.h>
-#include <errno.h>
-#include <string.h>
-#include <assert.h>
-#include <limits.h>
-
-extern off_t _uClibc_fwrite(const unsigned char *buf, off_t bytes, FILE *fp);
-extern off_t _uClibc_fread(unsigned char *buf, off_t bytes, FILE *fp);
-
-/* Used internally to actually open files */
-extern FILE *__fopen __P((__const char *__restrict __filename, int __fd,
- FILE *__restrict __stream, __const char *__restrict __mode,
- int extra_modes));
-
-/* Note: This def of READING is ok since 1st ungetc puts in buf. */
-#define READING(fp) (fp->bufstart < fp->bufread)
-#define WRITING(fp) (fp->bufwrite > fp->bufstart)
-
-#define READABLE(fp) (fp->bufread != 0)
-#define WRITEABLE(fp) (fp->bufwrite != 0)
-#define EOF_OR_ERROR(fp) (fp->mode & (__MODE_EOF | __MODE_ERR))
-
-/***********************************************************************/
-/* BUILD TIME OPTIONS */
-/***********************************************************************/
-/*
- * FIXED_STREAMS must be >= 3 and FIXED_BUFFERS must be >= 2.
- * As a feature, these can be increased, although this is probably
- * only useful if DISABLE_DYNAMIC is set to 1 below.
- */
-
-#define FIXED_STREAMS 3
-#define FIXED_BUFFERS 2
-
-/*
- * As a feature, you can build uClibc with no dynamic allocation done
- * by the stdio package. Just set DISABLE_DYNAMIC to nonzero. Note that
- * use of asprintf, getdelim, or getline will pull malloc into the link.
- *
- * Note: You can't trust FOPEN_MAX if DISABLE_DYNAMIC != 0.
- */
-#define DISABLE_DYNAMIC 0
-
-/*
- * As a feature, you can try to allow setvbuf calls after file operations.
- * Setting FLEXIBLE_SETVBUF to nonzero will cause setvbuf to try to fflush
- * any buffered writes or sync the file position for buffered reads. If it
- * is successful, the buffer change can then take place.
- */
-#define FLEXIBLE_SETVBUF 0
-/***********************************************************************/
-
-#if DISABLE_DYNAMIC != 0
-#undef malloc
-#undef free
-#define malloc(x) 0
-#define free(x)
-#endif
-
-extern FILE *__IO_list; /* For fflush. */
-extern FILE *_free_file_list;
-extern char _free_buffer_index;
-extern FILE _stdio_streams[FIXED_STREAMS];
-extern unsigned char _fixed_buffers[FIXED_BUFFERS * BUFSIZ];
-
-extern unsigned char *_alloc_stdio_buffer(size_t size);
-extern void _free_stdio_buffer_of_file(FILE *fp);
-extern void _free_stdio_stream(FILE *fp);
-
-#ifdef L__alloc_stdio_buffer
-unsigned char *_alloc_stdio_buffer(size_t size)
-{
- unsigned char *buf;
-
- if ((size == BUFSIZ) && (_free_buffer_index < FIXED_BUFFERS)) {
- buf = _fixed_buffers + ((unsigned int)_free_buffer_index) * BUFSIZ;
- _free_buffer_index = *buf;
- return buf;
- }
- return malloc(size);
-}
-#endif
-
-#ifdef L__free_stdio_buffer_of_file
-void _free_stdio_buffer_of_file(FILE *fp)
-{
- unsigned char *buf;
-
- if (!(fp->mode & __MODE_FREEBUF)) {
- return;
- }
- fp->mode &= ~(__MODE_FREEBUF);
- buf = fp->bufstart;
-
- if ((buf >= _fixed_buffers)
- && (buf < _fixed_buffers + (FIXED_BUFFERS * BUFSIZ))) {
- *buf = _free_buffer_index;
- _free_buffer_index = (buf - _fixed_buffers)/BUFSIZ;
- return;
- }
- free(buf);
-}
-#endif
-
-#ifdef L__stdio_init
-
-#if FIXED_BUFFERS < 2
-#error FIXED_BUFFERS must be >= 2
-#endif
-
-#if FIXED_BUFFERS >= UCHAR_MAX
-#error FIXED_BUFFERS must be < UCHAR_MAX
-#endif
-
-#define bufin (_fixed_buffers)
-#define bufout (_fixed_buffers + BUFSIZ)
-#define buferr (_stdio_streams[2].unbuf) /* Stderr is unbuffered */
-
-unsigned char _fixed_buffers[FIXED_BUFFERS * BUFSIZ];
-
-#if FIXED_STREAMS < 3
-#error FIXED_STREAMS must be >= 3
-#endif
-
-FILE _stdio_streams[FIXED_STREAMS] = {
- {bufin, bufin, 0, bufin, bufin + BUFSIZ,
- _stdio_streams + 1,
- 0, _IOFBF | __MODE_FREEFIL | __MODE_FREEBUF | __MODE_TIED },
- {bufout, 0, bufout, bufout, bufout + BUFSIZ,
- _stdio_streams + 2,
- 1, _IOFBF | __MODE_FREEFIL | __MODE_FREEBUF | __MODE_TIED },
- {buferr, 0, buferr, buferr, buferr + 1,
- NULL,
- 2, _IONBF | __MODE_FREEFIL }
-};
-
-FILE *stdin = _stdio_streams + 0;
-FILE *stdout = _stdio_streams + 1;
-FILE *stderr = _stdio_streams + 2;
-
-/*
- * Note: the following forces linking of the __init_stdio function if
- * any of the stdio functions are used since they all call fflush directly
- * or indirectly.
- */
-FILE *__IO_list = _stdio_streams; /* For fflush. */
-
-FILE *_free_file_list = 0;
-char _free_buffer_index = FIXED_BUFFERS;
-
-/*
- * __stdio_flush_buffers is automatically when exiting if stdio is used.
- * See misc/internals/__uClibc_main.c and and stdlib/atexit.c.
- */
-void __stdio_flush_buffers(void)
-{
- FILE *fp;
- for (fp = __IO_list; fp; fp = fp->next) {
- if (WRITEABLE(fp)) {
- /* Set the underlying fd to non-block mode to ensure
- * that calls to _exit() and abort() will not block */
- int opts;
- opts = fcntl(fp->fd, F_GETFL);
- fcntl(fp->fd, F_SETFL, opts|O_NONBLOCK);
- fflush(fp);
- fcntl(fp->fd, F_SETFL, opts);
- }
- }
-}
-
-/*
- * __init_stdio is automatically by __uClibc_main if stdio is used.
- */
-void __init_stdio(void)
-{
-#if (FIXED_BUFFERS > 2) || (FIXED_STREAMS > 3)
- int i;
-#endif
-#if FIXED_BUFFERS > 2
- _free_buffer_index = 2;
- for ( i = 2 ; i < FIXED_BUFFERS ; i++ ) {
- _fixed_buffers[i*BUFSIZ] = i;
- }
-#endif
-#if FIXED_STREAMS > 3
- _free_file_list = _stdio_streams + 3;
- for ( i = 3 ; i < FIXED_STREAMS-1 ; i++ ) {
- _stdio_streams[i].next = _stdio_streams + i + 1;
- }
- _stdio_streams[i].next = 0;
-#endif
-
-#if _IOFBF != 0 || _IOLBF != 1
-#error Assumption violated -- values of _IOFBF and/or _IOLBF
-/* This asssumption is also made in _fopen. */
-#endif
-
- /* stdout uses line buffering when connected to a tty. */
- _stdio_streams[1].mode |= isatty(1);
-}
-#endif
-
-#ifdef L_fputc
-int fputc(int c, FILE *fp)
-{
- unsigned char buf[1];
-
- *buf = (unsigned char) c;
-
- if (_uClibc_fwrite(buf, 1, fp)) {
- return (unsigned char) c;
- }
- return EOF;
-}
-#endif
-
-#ifdef L_fgetc
-int fgetc(FILE *fp)
-{
- unsigned char buf[1];
-
- if (_uClibc_fread(buf, 1, fp)) {
- return *buf;
- }
- return EOF;
-}
-#endif
-
-#ifdef L_fflush
-int fflush(FILE *fp)
-{
- int rv;
-
- rv = 0;
-
- if (fp == NULL) { /* On NULL flush the lot. */
- for (fp = __IO_list; fp; fp = fp->next) {
- if (WRITEABLE(fp) && fflush(fp)) {
- rv = EOF;
- }
- }
- } else if (WRITING(fp)) { /* Output buffer contents. */
- _uClibc_fwrite(NULL, 0, fp);
- if (fp->mode & __MODE_ERR) {
- rv = -1;
- }
- } else if (!WRITEABLE(fp)) { /* File opened read-only!!! */
- /*
- * According to info, glibc returns an error when the file is opened
- * in read-only mode.
- * ANSI says behavior in this case is undefined but also says you
- * shouldn't flush a stream you were reading from.
- */
- __set_errno(EBADF); /* Should we set stream error indicator? */
- rv = -1;
- }
-
- return rv;
-}
-#endif
-
-#ifdef L_fgets
-/* Nothing special here ... */
-char *fgets(char *s, int count, FILE *fp)
-{
- int ch;
- char *p;
-
- p = s;
- while (count-- > 1) { /* Guard against count arg == INT_MIN. */
- ch = getc(fp);
- if (ch == EOF) {
- break;
- }
- *p++ = ch;
- if (ch == '\n') {
- break;
- }
- }
- if (ferror(fp) || (s == p)) {
- return 0;
- }
- *p = 0;
- return s;
-}
-#endif
-
-#ifdef L_gets
-link_warning (gets, "the `gets' function is dangerous and should not be used.")
-char *gets(char *str) /* This is an UNSAFE function! */
-{
- /*
- * Strictly speaking, this implementation is incorrect as the number
- * of chars gets can read should be unlimited. However, I can't
- * imagine anyone wanting to gets() into a buffer bigger than INT_MAX.
- *
- * Besides, this function is inherently unsafe and shouldn't be used.
- */
- return fgets(str, INT_MAX, stdin);
-}
-#endif
-
-#ifdef L_fputs
-int fputs(const char *str, FILE *fp)
-{
- int n;
-
- n = strlen(str);
-
- _uClibc_fwrite((const unsigned char *)str, n, fp);
- if (fp->mode & __MODE_ERR) {
- n = EOF;
- }
- return n;
-}
-#endif
-
-#ifdef L_puts
-int puts(const char *str)
-{
- int n;
-
- n = fputs(str, stdout); /* Let next fputc handle EOF or error. */
- if (fputc('\n', stdout) == EOF) { /* Don't use putc since we want to */
- return EOF; /* fflush stdout if it is line buffered. */
- }
- return n + 1;
-}
-#endif
-
-#ifdef L_fread
-/*
- * fread will often be used to read in large chunks of data calling read()
- * directly can be a big win in this case. Beware also fgetc calls this
- * function to fill the buffer.
- */
-size_t fread(buf, size, nelm, fp)
-void *buf;
-size_t size;
-size_t nelm;
-FILE *fp;
-{
- unsigned char *p;
- unsigned char *q;
-
-#warning TODO: handle possible overflow of size * nelm
- p = (unsigned char *) buf;
- q = p + (size * nelm);
-
- while ((p < q) && !EOF_OR_ERROR(fp)) {
- p += _uClibc_fread(p, q - p, fp);
- }
- return (p - (unsigned char *) buf)/size;
-}
-#endif
-
-#ifdef L__uClibc_fread
-off_t _uClibc_fread(unsigned char *buf, off_t bytes, FILE *fp)
-{
- unsigned char *p;
- off_t len;
-
- if (!READABLE(fp)) {
- fp->mode |= __MODE_ERR;
- } else if (WRITING(fp)) {
- fflush(fp);
- } else if (fp->mode & stdout->mode & __MODE_TIED) {
- fflush(stdout);
- }
- if (EOF_OR_ERROR(fp) || (bytes <= 0)) {
- return 0;
- }
-
- p = (unsigned char *) buf;
-
- if (fp->mode & __MODE_UNGOT) { /* If we had an ungetc'd char, */
- fp->mode ^= __MODE_UNGOT; /* reset the flag and return it. */
- *p++ = fp->ungot;
- --bytes;
- }
-
- FROM_BUF:
- len = fp->bufread - fp->bufpos;
- if (len > bytes) { /* Enough buffered */
- len = bytes;
- }
-
- bytes -= len;
- while (len--) {
- *p++ = *fp->bufpos++;
- }
-
- if (bytes && !EOF_OR_ERROR(fp)) { /* More requested but buffer empty. */
- if (bytes < fp->bufend - fp->bufstart) {
- fp->bufpos = fp->bufread = fp->bufstart; /* Reset pointers. */
- fp->bufread += _uClibc_fread(fp->bufstart,
- fp->bufend - fp->bufstart, fp);
- goto FROM_BUF;
- }
-
- len = read(fp->fd, p, (unsigned) bytes);
- if (len < 0) {
- fp->mode |= __MODE_ERR;
- } else {
- p += len;
- if (len == 0) {
- fp->mode |= __MODE_EOF;
- }
- }
- }
-
- return (p - (unsigned char *)buf);
-
-}
-#endif
-
-#ifdef L_fwrite
-/*
- * Like fread, fwrite will often be used to write out large chunks of
- * data; calling write() directly can be a big win in this case.
- *
- * But first we check to see if there's space in the buffer.
- */
-size_t fwrite(buf, size, nelm, fp)
-const void *buf;
-size_t size;
-size_t nelm;
-FILE *fp;
-{
- off_t bytes;
-
-#warning TODO: handle possible overflow for bytes
- bytes = size * nelm; /* How many bytes do we want? */
-
- bytes = _uClibc_fwrite((const unsigned char *)buf, bytes, fp);
-
- return bytes/size;
-}
-#endif
-
-#ifdef L__uClibc_fwrite
-/*
- * If buf == NULL, fflush.
- * If buf != NULL, (fflush and) write
- * Returns number of chars written from fp buffer _OR_ from buf.
- */
-
-off_t _uClibc_fwrite(const unsigned char *buf, off_t bytes, FILE *fp)
-{
- unsigned char *p;
- int rv, had_newline;
-
- /*
- * Fail if stream isn't writable, if we were reading and get an error
- * changing over to write mode (ie. can't update stream position),
- * or if the stream was already in an error state.
- */
- if (!WRITEABLE(fp)) { /* Fail if stream isn't writable. */
- fp->mode |= __MODE_ERR;
- } else if (READING(fp)) { /* If read buffer isn't empty, */
- fseek(fp, 0, SEEK_CUR); /* stop reading and update position. */
- } else if (READABLE(fp)) {
- fp->bufread = fp->bufstart; /* Reset start of read buffer. */
- }
- if (EOF_OR_ERROR(fp)) {
- return 0;
- }
-
- p = (unsigned char *)buf;
- if (p && (fp->bufpos + bytes <= fp->bufend)) { /* Enough buffer space? */
- had_newline = 0;
- while (bytes--) {
- if (*p == '\n') {
- had_newline = 1;
- }
- *fp->bufpos++ = *p++;
- }
- if (fp->bufpos < fp->bufend) { /* Buffer is not full. */
- fp->bufwrite = fp->bufend;
- if ((fp->mode & __MODE_BUF) == _IOLBF) {
- fp->bufwrite = fp->bufpos;
- if (had_newline) {
- goto FFLUSH;
- }
- }
- goto DONE;
- }
- FFLUSH:
- /* If we get here, either buffer is full or we need to flush anyway. */
- buf = fp->bufpos - (p - (unsigned char *)buf);
- p = NULL;
- }
- if (!p) { /* buf == NULL means fflush */
- p = fp->bufstart;
- bytes = fp->bufpos - p;
- fp->bufpos = fp->bufwrite = p;
- } else if (fp->bufpos > fp->bufstart) { /* If there are buffered chars, */
- _uClibc_fwrite(NULL, 0, fp); /* write them. */
- if (ferror(fp)) {
- return 0;
- }
- }
-
- while (bytes) {
- if ((rv = write(fp->fd, p, bytes)) < 0) {
- rv = 0;
- break;
- }
- p += rv;
- bytes -= rv;
- }
- if (bytes) {
- fp->mode |= __MODE_ERR;
- }
-
- DONE:
- return (p - (unsigned char *)buf);
-}
-#endif
-
-#ifdef L_rewind
-void rewind(fp)
-FILE *fp;
-{
- clearerr(fp); /* Clear errors first, then seek in case */
- fseek(fp, 0, SEEK_SET); /* there is an error seeking. */
-}
-#endif
-
-#ifdef L_fseek
-int fseek(FILE *fp, long int offset, int ref)
-{
-#if SEEK_SET != 0 || SEEK_CUR != 1 || SEEK_END != 2
-#error Assumption violated -- values of SEEK_SET, SEEK_CUR, SEEK_END
-#endif
-
- if ((ref < 0) || (ref > 2)) {
- __set_errno(EINVAL);
- return -1;
- }
-
- if (WRITING(fp)) {
- fflush(fp); /* We'll deal with errors below. */
- /* After fflush, bufpos is at CUR. */
- } else if (READING(fp)) {
- if (ref == SEEK_CUR) {
- /* Correct offset to take into account position in buffer. */
- offset -= (fp->bufread - fp->bufpos);
- if (fp->mode & __MODE_UNGOT) { /* If we had an ungetc'd char, */
- --offset; /* adjust offset (clear flag below). */
- }
- }
- }
-
- if ((fp->mode & __MODE_ERR) ||
- (((ref != SEEK_CUR) || offset) && (lseek(fp->fd, offset, ref) < 0))) {
- return -1;
- }
-
- if (READING(fp)) {
- fp->bufpos = fp->bufread = fp->bufstart;
- }
- fp->mode &= ~(__MODE_EOF | __MODE_UNGOT);
-
- return 0;
-}
-#endif
-
-#ifdef L_ftell
-long ftell(fp)
-FILE *fp;
-{
- /* Note: can't do fflush here since it would discard any ungetc's. */
- off_t pos;
-
- pos = lseek(fp->fd, 0, SEEK_CUR); /* Get kernels idea of position. */
- if (pos < 0) {
- return -1;
- }
-
- if (WRITING(fp)) {
- pos += (fp->bufpos - fp->bufstart); /* Adjust for buffer position. */
- } else if (READING(fp)) {
- pos -= (fp->bufread - fp->bufpos); /* Adjust for buffer position. */
- if (fp->mode & __MODE_UNGOT) {
- --pos;
- }
- if (pos < 0) { /* ungetcs at start of file? */
- __set_errno(EIO);
- pos = -1;
- }
- }
-
- return pos;
-}
-#endif
-
-#ifdef L__fopen
-/*
- * This Fopen is all three of fopen, fdopen and freopen. The macros in
- * stdio.h show the other names.
- */
-static __inline FILE *_alloc_stdio_stream(void)
-{
- FILE *fp;
-
- if (_free_file_list) {
- fp = _free_file_list;
- _free_file_list = fp->next;
- } else if (!(fp = malloc(sizeof(FILE)))) {
- return 0;
- }
- fp->mode = __MODE_FREEFIL | _IOFBF;
- /* Initially set to use builtin buffer of FILE structure. */
- fp->bufstart = fp->unbuf;
- fp->bufend = fp->unbuf + sizeof(fp->unbuf);
- return fp;
-}
-
-FILE *__fopen(fname, fd, fp, mode, extra_modes)
-const char *fname;
-int fd;
-FILE *fp;
-const char *mode;
-int extra_modes;
-{
- FILE *nfp;
- unsigned char *p;
- int open_mode;
- int cur_mode;
-
- nfp = fp;
-
- /* Parse the mode string arg. */
- switch (*mode++) {
- case 'r': /* read */
- open_mode = O_RDONLY | extra_modes;
- break;
- case 'w': /* write (create or truncate)*/
- open_mode = (O_WRONLY | O_CREAT | O_TRUNC | extra_modes);
- break;
- case 'a': /* write (create or append) */
- open_mode = (O_WRONLY | O_CREAT | O_APPEND | extra_modes);
- break;
- default: /* illegal mode */
- __set_errno(EINVAL);
- goto _fopen_ERROR;
- }
-
- if ((*mode == 'b')) { /* binary mode (nop for uClibc) */
- ++mode;
- }
-
-
-#if O_RDONLY != 0 || O_WRONLY != 1 || O_RDWR != 2
-#error Assumption violated concerning open mode constants!
-#endif
-
- if (*mode == '+') { /* read-write */
- ++mode;
- open_mode &= ~(O_RDONLY | O_WRONLY);
- open_mode |= O_RDWR;
- }
-
- while (*mode) { /* ignore everything else except ... */
- if (*mode == 'x') { /* open exclusive -- GNU extension */
- open_mode |= O_EXCL;
- }
- ++mode;
- }
-
- if (fp == 0) { /* We need a FILE so allocate it before */
- if (!(nfp = _alloc_stdio_stream())) {
- return 0;
- }
- }
-
- if (fname) { /* Open the file itself */
- fd = open(fname, open_mode, 0666);
- } else { /* fdopen -- check mode is compatible. */
-#if O_ACCMODE != 3 || O_RDONLY != 0 || O_WRONLY != 1 || O_RDWR != 2
-#error Assumption violated - mode constants
-#endif
- cur_mode = fcntl(fd, F_GETFL);
- if (cur_mode == -1) {
- fd = -1;
- } else if (!(cur_mode & O_RDWR)
- && ((cur_mode ^ open_mode) & O_ACCMODE)) {
- __set_errno(EINVAL);
- fd = -1;
- }
- }
-
- if (fd < 0) { /* Error from open or bad arg passed. */
- _fopen_ERROR:
- if (nfp) {
- _free_stdio_stream(nfp);
- }
- return 0;
- }
-
- nfp->fd = fd; /* Set FILE's fd before adding to open list. */
-
- if (fp == 0) { /* Not freopen so... */
- nfp->next = __IO_list; /* use newly created FILE and */
- __IO_list = nfp; /* add it to the list of open files. */
-
- if ((p = _alloc_stdio_buffer(BUFSIZ)) != 0) {
- nfp->bufstart = p;
- nfp->bufend = p + BUFSIZ;
- nfp->mode |= __MODE_FREEBUF;
- }
- }
-
- /* Ok, file's ready clear the buffer and save important bits */
- nfp->bufpos = nfp->bufstart;
- nfp->mode |= isatty(fd);
- nfp->bufread = nfp->bufwrite = 0;
- if (!(open_mode & O_WRONLY)) {
- nfp->bufread = nfp->bufstart;
- }
- if (open_mode & (O_WRONLY | O_RDWR)) {
- nfp->bufwrite = nfp->bufstart;
- }
-
- return nfp;
-}
-#endif
-
-#ifdef L_fclose
-int fclose(fp)
-FILE *fp;
-{
- FILE *prev;
- FILE *ptr;
- int rv;
-
- rv = 0;
- if (WRITING(fp)) { /* If there are buffered chars to write... */
- rv = fflush(fp); /* write them. */
- }
- if (close(fp->fd)) { /* Need to close even if fflush fails. */
- rv = EOF;
- }
-
- prev = 0; /* Remove file from open list. */
- for (ptr = __IO_list; ptr ; ptr = ptr->next) {
- if (ptr == fp) {
- if (prev == 0) {
- __IO_list = fp->next;
- } else {
- prev->next = fp->next;
- }
- break;
- }
- prev = ptr;
- }
-
- _free_stdio_stream(fp); /* Finally free the stream if necessary. */
-
- return rv;
-}
-#endif
-
-#ifdef L__free_stdio_stream
-/* The following is only called by fclose and _fopen. */
-void _free_stdio_stream(FILE *fp)
-{
- _free_stdio_buffer_of_file(fp); /* Free buffer if necessary. */
-
- if (!(fp->mode & __MODE_FREEFIL)) {
- return;
- }
-
- /* Note: we generally won't bother checking for bad pointers here. */
- if ((fp >= _stdio_streams) && (fp < _stdio_streams + FIXED_STREAMS)) {
- assert( (fp - _stdio_streams) % ((_stdio_streams+1) -_stdio_streams)
- == 0 );
- fp->next = _free_file_list;
- _free_file_list = fp;
- return;
- }
- free(fp);
-}
-#endif
-
-#ifdef L_setbuffer
-void setbuffer(FILE *fp, char *buf, size_t size)
-{
- int mode;
-
- mode = _IOFBF;
- if (!buf) {
- mode = _IONBF;
- }
- setvbuf(fp, buf, mode, size);
-}
-#endif
-
-#ifdef L_setvbuf
-int setvbuf(FILE *fp, char *ubuf, int mode, size_t size)
-{
- unsigned char *buf = ubuf;
- int allocated_buf_flag;
-
- if ((mode < 0) || (mode > 2)) { /* Illegal mode. */
- return EOF;
- }
-
-#if FLEXIBLE_SETVBUF
- /* C89 standard requires no ops before setvbuf, but we can be flexible. */
- /* NOTE: This will trash any chars ungetc'd!!! */
- if (fseek(fp, 0, SEEK_CUR)) {
- return EOF;
- }
-#endif
-
- /* Note: If size == 2 we could use FILE's builting buffer as well, but */
- /* I don't think the benefit is worth the code size increase. */
- if ((mode == _IONBF) || (size < 1)) {
- size = 1; /* size == 1 _REQUIRED_ for _IONBF!!! */
- buf = fp->unbuf;
- }
-
- fp->mode &= ~(__MODE_BUF); /* Clear current mode */
- fp->mode |= mode; /* and set new one. */
-
- allocated_buf_flag = 0;
- if ((!buf) && (size != (fp->bufend - fp->bufstart))) {
- /* No buffer supplied and requested size different from current. */
- allocated_buf_flag = __MODE_FREEBUF;
- if (!(buf = _alloc_stdio_buffer(size))) {
- return EOF; /* Keep current buffer. */
- }
- }
-
- if (buf && (buf != fp->bufstart)) { /* Want different buffer. */
- _free_stdio_buffer_of_file(fp); /* Free the old buffer. */
- fp->mode |= allocated_buf_flag; /* Allocated? or FILE's builtin. */
- fp->bufstart = buf;
- fp->bufend = buf + size;
- fp->bufpos = fp->bufstart;
- if (READABLE(fp)) {
- fp->bufread = fp->bufstart;
- }
- if (WRITEABLE(fp)) {
- fp->bufwrite = fp->bufstart;
- }
- }
-
- return 0;
-}
-#endif
-
-#ifdef L_setbuf
-void setbuf(FILE *fp, char *buf)
-{
- int mode;
-
- mode = _IOFBF;
- if (!buf) {
- mode = _IONBF;
- }
- setvbuf(fp, buf, mode, BUFSIZ);
-}
-#endif
-
-#ifdef L_setlinebuf
-void setlinebuf(FILE *fp)
-{
- setvbuf(fp, NULL, _IOLBF, BUFSIZ);
-}
-#endif
-
-#ifdef L_ungetc
-/*
- * NOTE: Only one character of pushback is guaranteed, although sometimes
- * it is possible to do more. You have 1 plus as many characters of pushback
- * as have been read since that last buffer-fill.
- */
-int ungetc(c, fp)
-int c;
-FILE *fp;
-{
- unsigned char *p;
-
- /* If can't read or there's been an error, or c == EOF, or ungot slot
- * already filled, then return EOF */
- /*
- * This can only happen if an fgetc triggered a read (that filled
- * the buffer for case 2 above) and then we ungetc 3 chars.
- */
- if (!READABLE(fp) || (fp->mode & (__MODE_UNGOT | __MODE_ERR))
- || (c == EOF) ) {
- return EOF;
- }
-
- if (WRITING(fp)) { /* Commit any write-buffered chars. */
- fflush(fp);
- }
-
- if (fp->bufpos > fp->bufstart) { /* We have space before bufpos. */
- p = --fp->bufpos;
- } else if (fp->bufread == fp->bufpos) { /* Buffer is empty. */
- p = fp->bufread++;
- } else {
- fp->mode |= __MODE_UNGOT;
- p = &(fp->ungot);
- }
- fp->mode &= ~(__MODE_EOF); /* Clear EOF indicator. */
-
- if (*p != (unsigned char) c) { /* Don't store if same, because could */
- *p = (unsigned char) c; /* be sscanf from a const string!!! */
- }
-
- return c;
-}
-#endif
-
-#ifdef L_fopen
-#undef fopen
-FILE *fopen(const char *__restrict filename,
- const char *__restrict mode)
-{
- return __fopen(filename, -1, NULL, mode, 0);
-}
-#endif
-
-#ifdef L_freopen
-FILE *freopen(__const char *__restrict filename,
- __const char *__restrict mode, FILE *__restrict fp)
-{
- /* fflush file, close the old fd, and reset modes. */
- if (WRITING(fp)) { /* If anything in the write buffer... */
- fflush(fp); /* write it. */
- }
- close(fp->fd); /* Close the file. */
- fp->mode &= (__MODE_FREEFIL | __MODE_FREEBUF); /* Reset the FILE modes. */
- fp->mode |= _IOFBF;
-
- return __fopen(filename, -1, fp, mode, 0);
-}
-#endif
-
-#ifdef L_fsfopen
-FILE *fsfopen(__const char *__restrict filename,
- __const char *__restrict mode, FILE *__restrict fp)
-{
- fp->mode = _IOFBF;
- fp->bufstart = fp->unbuf;
- fp->bufend = fp->unbuf + sizeof(fp->unbuf);
-
- return __fopen(filename, -1, fp, mode, 0);
-}
-#endif
-
-#ifdef L_fdopen
-#undef fdopen
-FILE *fdopen(int fd, __const char *mode)
-{
- return __fopen(NULL, fd, NULL, mode, 0);
-}
-#endif
-
-
-#ifdef L_getc
-#undef getc
-int getc(FILE *stream)
-{
- return(((stream)->bufpos >= (stream)->bufread)? fgetc(stream) :
- (*(stream)->bufpos++));
-}
-#endif
-
-#ifdef L_putc
-#undef putc
-int putc(int c, FILE *stream)
-{
- return(((stream)->bufpos >= (stream)->bufwrite)? fputc((c), (stream)) :
- (unsigned char) (*(stream)->bufpos++ = (c)) );
-}
-#endif
-
-#ifdef L_getchar
-#undef getchar
-int getchar(void)
-{
- return getc(stdin);
-}
-#endif
-
-#ifdef L_putchar
-#undef putchar
-int putchar(int c)
-{
- return putc(c, stdout);
-}
-#endif
-
-#ifdef L_clearerr
-#undef clearerr
-void clearerr(FILE *fp)
-{
- fp->mode &= ~(__MODE_EOF | __MODE_ERR);
-}
-#endif
-
-#ifdef L_feof
-#undef feof
-int feof(FILE *fp)
-{
- return fp->mode & __MODE_EOF;
-}
-#endif
-
-#ifdef L_ferror
-#undef ferror
-int ferror(FILE *fp)
-{
- return fp->mode & __MODE_ERR;
-}
-#endif
-
-#ifdef L_fileno
-int fileno(FILE *fp)
-{
- return fp->fd;
-}
-#endif
-
-#ifdef L_fgetpos
-int fgetpos(FILE *fp, fpos_t *pos)
-{
- fpos_t p;
-
- if (!pos) { /* NULL pointer. */
- __set_errno(EINVAL);
- return -1;
- }
-
- if ((p = ftell(fp)) < 0) { /* ftell failed. */
- return -1; /* errno set by ftell. */
- }
-
- *pos = p;
- return 0;
-}
-#endif
-
-#ifdef L_fsetpos
-int fsetpos(FILE *fp, __const fpos_t *pos)
-{
- if (pos) { /* Pointer ok. */
- return fseek(fp, *pos, SEEK_SET);
- }
- __set_errno(EINVAL); /* NULL pointer. */
- return EOF;
-}
-#endif
-
-#ifdef L_fopen64
-#ifdef __UCLIBC_HAVE_LFS__
-#ifndef O_LARGEFILE
-#define O_LARGEFILE 0100000
-#endif
-FILE *fopen64(const char *__restrict filename,
- const char *__restrict mode)
-{
- return __fopen(filename, -1, NULL, mode, O_LARGEFILE);
-}
-#endif /* __UCLIBC_HAVE_LFS__ */
-#endif
-
* Changed name of __cleanup to __uClibc_cleanup.
* Moved declaration of __uClibc_cleanup to __uClibc_main
* where it is initialized with (possibly weak alias)
- * __stdio_flush_buffers.
+ * _stdio_term.
*
* Jul 2001 Steve Thayer
*
#endif
#ifdef L_exit
-extern void weak_function __stdio_flush_buffers(void);
+extern void weak_function _stdio_term(void);
void (*__exit_cleanup) (int) = 0;
/*
__exit_cleanup(rv);
}
- /* Clean up everything else */
- if (__stdio_flush_buffers)
- __stdio_flush_buffers();
+ /* If we are using stdio, try to shut it down. At the very least,
+ * this will attempt to commit all buffered writes. It may also
+ * unbuffer all writable files, or close them outright.
+ * Check the stdio routines for details. */
+ if (_stdio_term)
+ _stdio_term();
_exit(rv);
}
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+#define _STDIO_UTILITY /* For _int10tostr. */
+#include <stdio.h>
#include <errno.h>
#include <paths.h>
#include <stdlib.h>
#include <termios.h>
#include <unistd.h>
+
#if !defined UNIX98PTY_ONLY
/* Check if DEV corresponds to a master pseudo terminal device. */
/* Directory where we can find the slave pty nodes. */
#define _PATH_DEVPTS "/dev/pts/"
-extern char *__ultostr(char *buf, unsigned long uval, int base, int uppercase);
-
/* Store at most BUFLEN characters of the pathname of the slave pseudo
terminal associated with the master FD is open on in BUF.
Return 0 on success, otherwise an error number. */
#ifdef TIOCGPTN
if (ioctl (fd, TIOCGPTN, &ptyno) == 0)
{
- /* Buffer we use to print the number in. For a maximum size for
- `int' of 8 bytes we never need more than 20 digits. */
- char numbuf[21];
+ /* Buffer we use to print the number in. */
+ char numbuf[__BUFLEN_INT10TOSTR];
static const char devpts[] = _PATH_DEVPTS;
char *p;
- numbuf[20] = '\0';
- p = __ultostr (&numbuf[sizeof numbuf - 1], ptyno, 10, 0);
+ p = _int10tostr(&numbuf[sizeof numbuf - 1], ptyno);
if (buflen < sizeof devpts + &numbuf[sizeof numbuf - 1] - p)
{
*
* Added the option WANT_ERRORLIST for low-memory applications to omit the
* error message strings and only output the error number.
+ *
+ * Manuel Novoa III Feb 2002
+ *
+ * Change to _int10tostr and fix a bug in end-of-buf arg.
*/
#define WANT_ERRORLIST 1
+#define _STDIO_UTILITY /* For _int10tostr. */
#include <stdio.h>
#include <string.h>
#include <errno.h>
-#include <limits.h>
-
-#if (INT_MAX >> 31)
-/* We're set up for 32 bit ints */
-#error need to check size allocation for static buffer 'retbuf'
-#endif
-
-extern char *__ltostr(char *buf, long uval, int base, int uppercase);
-
#if WANT_ERRORLIST
static char retbuf[48];
#else
+#if __BUFLEN_INT10TOSTR > 12
+#error currently set up for 32 bit ints max!
+#endif
static char retbuf[33]; /* 33 is sufficient for 32 bit ints */
#endif
static const char unknown_error[] = "Unknown Error: errno"; /* = */
}
#endif
- /* unknown error */
- pos = __ltostr(retbuf + sizeof(retbuf) + 1, err, 10, 0)
- - sizeof(unknown_error); /* leave space for the '=' */
+ /* unknown error -- leave space for the '=' */
+ pos = _int10tostr(retbuf+sizeof(retbuf)-1, err) - sizeof(unknown_error);
strcpy(pos, unknown_error);
*(pos + sizeof(unknown_error) - 1) = '=';
return pos;
#endif
p = strerror(INT_MIN);
- j = strlen(p)+1;
- if (j > max) {
+ j = retbuf+sizeof(retbuf) - p;
+ if ( > max) {
max = j;
printf("strerror.c - Test of INT_MIN: <%s> %d\n", p, j);
}
*
* Added the option WANT_SIGLIST for low-memory applications to omit the
* signal message strings and only output the signal number.
+ *
+ * Manuel Novoa III Feb 2002
+ *
+ * Change to use _int10tostr and fix a bug in end-of-buf arg.
*/
#define WANT_SIGLIST 1
+
+#define _STDIO_UTILITY /* For _int10tostr. */
+#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <signal.h>
-#include <limits.h>
+#ifndef __USE_GNU
#define __USE_GNU
-#include <string.h>
-
-#if (INT_MAX >> 31)
-/* We're set up for 32 bit ints */
-#error need to check size allocation for static buffer 'retbuf'
#endif
-
-extern char *__ltostr(char *buf, long uval, int base, int uppercase);
+#include <string.h>
/********************** Function strsignal ************************************/
#ifdef L_strsignal
#define NUM_KNOWN_SIGNALS 32
+#if __BUFLEN_INT10TOSTR > 12
+#error currently set up for 32 bit ints max!
+#endif
+
static char retbuf[28]; /* 28 is sufficient for 32 bit ints */
static const char unknown_signal[] = "Unknown Signal:";
}
#endif
- pos = __ltostr(retbuf + sizeof(unknown_signal) + 1, sig, 10, 0)
- - sizeof(unknown_signal);
+ pos = _int10tostr(retbuf+sizeof(retbuf)-1, sig) - sizeof(unknown_signal);
strcpy(pos, unknown_signal);
*(pos + sizeof(unknown_signal) - 1) = ' ';
return pos;
/********************** Function psignal ************************************/
#ifdef L_psignal
-#include <stdio.h>
-
void psignal(int sig, const char *s)
{
fprintf(stderr, "%s: %s\n", s, strsignal(sig));
#endif
p = strsignal(INT_MIN);
- j = strlen(p)+1;
+ j = retbuf+sizeof(retbuf) - p;
if (j > max) max = j;
/*printf("strsignal.c - Test of INT_MIN: <%s> %d\n", p, j);*/
--- /dev/null
+/* Copyright (C) 2002 Manuel Novoa III
+ * Header for my stdio library for linux and (soon) elks.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/* ATTENTION! ATTENTION! ATTENTION! ATTENTION! ATTENTION!
+ *
+ * This code is currently under development. Also, I plan to port
+ * it to elks which is a 16-bit environment with a fairly limited
+ * compiler. Therefore, please refrain from modifying this code
+ * and, instead, pass any bug-fixes, etc. to me. Thanks. Manuel
+ *
+ * ATTENTION! ATTENTION! ATTENTION! ATTENTION! ATTENTION! */
+
+#ifndef _STDIO_H
+#error Always include <stdio.h> rather than <bits/uClibc_stdio.h>
+#endif
+
+/**********************************************************************/
+#ifdef __UCLIBC__
+
+#ifdef __UCLIBC_HAS_THREADS__
+#define __STDIO_THREADSAFE
+#endif
+
+#ifdef __UCLIBC_HAVE_LFS__
+#define __STDIO_LARGE_FILES
+#endif /* __UCLIBC_HAVE_LFS__ */
+
+/* Make sure defines related to large files are consistent. */
+#ifdef _LIBC
+
+#ifdef __UCLIBC_HAVE_LFS__
+#undef __USE_LARGEFILE
+#undef __USE_LARGEFILE64
+#undef __USE_FILE_OFFSET64
+/* if we're actually building uClibc with large file support, only define... */
+#define __USE_LARGEFILE64 1
+#endif /* __UCLIBC_HAVE_LFS__ */
+
+#else /* not _LIBC */
+
+#ifndef __UCLIBC_HAVE_LFS__
+#if defined(__LARGEFILE64_SOURCE) || defined(__USE_LARGEFILE64) \
+ || defined(__USE_FILE_OFFSET64)
+#error Sorry... uClibc was built without large file support!
+#endif
+#endif /* __UCLIBC_HAVE_LFS__ */
+
+#endif /* _LIBC */
+
+#endif /* __UCLIBC__ */
+/**********************************************************************/
+/* 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 */
+#endif
+
+#define __STDIO_BUFFERS
+#define __STDIO_GETC_MACRO
+#define __STDIO_PUTC_MACRO
+
+/* For uClibc, these are currently handled above. */
+/* #define __STDIO_LARGE_FILES */
+#define __STDIO_THREADSAFE
+
+/* L mode extension for fopen. */
+#define __STDIO_FOPEN_LARGEFILE_MODE
+
+/* size of builtin buf -- only tested with 0 */
+#define _STDIO_BUILTIN_BUF_SIZE 0
+
+/* TODO - enable features based on __STDIO_GLIBC_FEATURES */
+
+/* #define __STDIO_GLIBC_FEATURES */
+#define __STDIO_AUTO_RW_TRANSITION
+#define __STDIO_FOPEN_EXCLUSIVE_MODE
+#define __STDIO_PRINTF_M_SPEC
+#define __STDIO_GLIBC_CUSTOM_STREAMS
+
+
+/* ANSI/ISO mandate at least 256. */
+#define _STDIO_BUFSIZ 256
+
+/* Currently unimplemented/untested */
+/* #define __STDIO_FLEXIBLE_SETVBUF */
+
+/**********************************************************************/
+/* TODO -- posix or gnu -- belongs in limits.h and >= 9 for sus */
+/* NOTE: for us it is currently _always_ 9 */
+#define NL_ARGMAX 9
+
+/* TODO -- where should this go? */
+#ifndef O_LARGEFILE
+#define O_LARGEFILE 0100000
+#endif
+
+/**********************************************************************/
+
+/* These are consistency checks on the different options */
+
+#ifndef __STDIO_BUFFERS
+#undef __STDIO_GETC_MACRO
+#undef __STDIO_PUTC_MACRO
+#endif
+
+#ifdef __BCC__
+#undef __STDIO_LARGE_FILES
+#endif
+
+#ifndef __STDIO_LARGE_FILES
+#undef __STDIO_FOPEN_LARGEFILE_MODE
+#endif
+
+/**********************************************************************/
+
+#ifdef __STDIO_THREADSAFE
+/* Need this for pthread_mutex_t. */
+#include <bits/pthreadtypes.h>
+
+#define __STDIO_THREADLOCK(STREAM) \
+ if ((STREAM)->user_locking == 0) { \
+ pthread_mutex_lock(&(STREAM)->lock); \
+ }
+
+#define __STDIO_THREADUNLOCK(STREAM) \
+ if ((STREAM)->user_locking == 0) { \
+ pthread_mutex_unlock(&(STREAM)->lock); \
+ }
+
+#define __STDIO_THREADTRYLOCK(STREAM) \
+ if ((STREAM)->user_locking == 0) { \
+ pthread_mutex_trylock(&(STREAM)->lock); \
+ }
+
+#else /* __STDIO_THREADSAFE */
+
+#define __STDIO_THREADLOCK(STREAM)
+#define __STDIO_THREADUNLOCK(STREAM)
+#define __STDIO_THREADTRYLOCK(STREAM)
+
+#endif /* __STDIO_THREADSAFE */
+
+/* This file may eventually have two personalities:
+ 1) core stuff (similar to glibc's libio.h)
+ 2) extern inlines (for glibc's bits/stdio.h)
+ Right now, only (1) is implemented. */
+
+#define _STDIO_IOFBF 0 /* Fully buffered. */
+#define _STDIO_IOLBF 1 /* Line buffered. */
+#define _STDIO_IONBF 2 /* No buffering. */
+
+typedef struct {
+ __off_t __pos;
+/* __mbstate_t __state; */
+} __stdio_fpos_t;
+
+typedef struct {
+ __off64_t __pos;
+/* __mbstate_t __state; */
+} __stdio_fpos64_t;
+
+
+/**********************************************************************/
+#ifdef __STDIO_LARGE_FILES
+typedef __off64_t __offmax_t; /* TODO -- rename this? */
+#else
+typedef __off_t __offmax_t; /* TODO -- rename this? */
+#endif
+
+/**********************************************************************/
+
+#ifdef __STDIO_GLIBC_CUSTOM_STREAMS
+
+typedef __ssize_t __io_read_fn(void *cookie,
+ char *buf, size_t bufsize);
+typedef __ssize_t __io_write_fn(void *cookie,
+ const char *buf, size_t bufsize);
+/* NOTE: GLIBC difference!!! -- fopencookie seek function
+ * For glibc, the type of pos is always (__off64_t *) but in our case
+ * it is type (__off_t *) when the lib is built without large file support.
+ */
+typedef int __io_seek_fn(void *cookie,
+ __offmax_t *pos, int whence);
+typedef int __io_close_fn(void *cookie);
+
+typedef struct {
+ __io_read_fn *read;
+ __io_write_fn *write;
+ __io_seek_fn *seek;
+ __io_close_fn *close;
+} _IO_cookie_io_functions_t;
+
+#if defined(_LIBC) || defined(_GNU_SOURCE)
+typedef __io_read_fn cookie_read_function_t;
+typedef __io_write_fn cookie_write_function_t;
+typedef __io_seek_fn cookie_seek_function_t;
+typedef __io_close_fn cookie_close_function_t;
+
+typedef _IO_cookie_io_functions_t cookie_io_functions_t;
+#endif /* _GNU_SOURCE */
+
+#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */
+
+/*
+ * ungot scheme:
+ * 0 0 none
+ * 0 1 one user (unused ungot is 1) or one scanf (unused ungot is 0)
+ * 1 0 must be scanf[0] and user[1]
+ * 1 1 illegal -- could be used to signal safe for setbuf
+ */
+
+#ifdef __UCLIBC__
+#define __stdio_file_struct _UC_FILE
+#endif
+
+struct __stdio_file_struct {
+ unsigned short modeflags;
+ /* There could be a hole here, but modeflags is used most.*/
+#ifdef __STDIO_WIDE
+ unsigned char ungot_width[2];
+ __wchar_t ungot[2];
+#else /* __STDIO_WIDE */
+ unsigned char ungot[2];
+#endif /* __STDIO_WIDE */
+ int filedes;
+#if defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS)
+ struct __stdio_file_struct *nextopen;
+#endif /* defined(__STDIO_BUFFERS) || defined(__STDIO_GLIBC_CUSTOM_STREAMS) */
+#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 */
+#ifdef __STDIO_GETC_MACRO
+ unsigned char *bufgetc; /* 1 past last readable by getc */
+#endif /* __STDIO_GETC_MACRO */
+#ifdef __STDIO_PUTC_MACRO
+ unsigned char *bufputc; /* 1 past last writeable by putc */
+#endif /* __STDIO_PUTC_MACRO */
+#endif /* __STDIO_BUFFERS */
+#ifdef __STDIO_GLIBC_CUSTOM_STREAMS
+ void *cookie;
+ _IO_cookie_io_functions_t gcs;
+#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */
+#ifdef __STDIO_THREADSAFE
+ int user_locking;
+ pthread_mutex_t lock;
+#endif
+/* Everything after this is unimplemented... and may be trashed. */
+#if __STDIO_BUILTIN_BUF_SIZE > 0
+ unsigned char builtinbuf[__STDIO_BUILTIN_BUF_SIZE];
+#endif /* __STDIO_BUILTIN_BUF_SIZE > 0 */
+};
+
+
+/***********************************************************************/
+
+#define __MASK_UNGOT (0x0002|0x0001)
+#define __MASK_UNGOT1 0x0001
+#define __MASK_UNGOT2 0x0002
+#define __FLAG_EOF 0x0004 /* EOF reached? */
+#define __FLAG_ERROR 0x0008 /* stream in error state? */
+#define __FLAG_WRITEONLY 0x0010 /* unreadable */
+#define __FLAG_READONLY 0x0020 /* unwriteable */
+#define __FLAG_FREEFILE 0x0040 /* free FILE struct after use */
+#define __FLAG_NARROW 0x0080
+
+#define __FLAG_FBF 0 /* convenience value */
+#define __FLAG_LBF 0x0100
+#define __FLAG_NBF 0x0200
+#define __MASK_BUFMODE 0x0300
+
+#define __FLAG_APPEND 0x0400
+#define __FLAG_WIDE 0x0800
+
+#define __FLAG_READING 0x1000
+#define __FLAG_WRITING 0x2000
+
+#define __FLAG_FREEBUF 0x4000 /* free buffer after use */
+#define __FLAG_LARGEFILE 0x8000
+
+/**********************************************************************/
+
+#ifdef __STDIO_GLIBC_CUSTOM_STREAMS
+extern __ssize_t _cs_read(void *cookie, char *buf, size_t bufsize);
+extern __ssize_t _cs_write(void *cookie, const char *buf, size_t bufsize);
+extern int _cs_seek(void *cookie, __offmax_t *pos, int whence);
+extern int _cs_close(void *cookie);
+#endif /* __STDIO_GLIBC_CUSTOM_STREAMS */
+
+/**********************************************************************/
+
+/* TODO -- thread safety issues */
+#define __CLEARERR(stream) \
+ ((stream)->modeflags &= ~(__FLAG_EOF|__FLAG_ERROR), (void)0)
+#define __FEOF(stream) ((stream)->modeflags & __FLAG_EOF)
+#define __FERROR(stream) ((stream)->modeflags & __FLAG_ERROR)
+
+#define __FEOF_OR_FERROR(stream) \
+ ((stream)->modeflags & (__FLAG_EOF|__FLAG_ERROR))
+
+
+/* TODO: check this
+ * If we want to implement the getc and putc macros, we need to take
+ * into account wide streams. So... would need two additional variables
+ * if we have wide streams (bufread and bufwrite), and one otherwise
+ * (bufwrite). getc would be effective for FBF streams. It isn't for
+ * LBF streams because other LBF streams need to be flushed. putc
+ * thouch is only effective for FBF streams. Of course, to support
+ * threads, we have to use functions.
+ */
+
+#ifdef __STDIO_GETC_MACRO
+#define __GETC(stream) ( ((stream)->bufrpos < (stream)->bufgetc) \
+ ? (*(stream)->bufrpos++) \
+ : 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) \
+ : fputc_unlocked((c),(stream)) )
+#else /* __STDIO_PUTC_MACRO */
+#define __PUTC(c, stream) fputc_unlocked(c, stream);
+#endif /* __STDIO_PUTC_MACRO */
+
+
+#if 0
+/* TODO: disabled for now */
+/* Masking macros for the above _are_ allowed by the standard. */
+#define clearerr(stream) __CLEARERR(stream)
+#define feof(stream) __FEOF(stream)
+#define ferror(stream) __FERROR(stream)
+#endif
+
+#if 0
+/* TODO -- what about custom streams!!! */
+/* Only use the macro below if you know fp is a valid FILE for a valid fd. */
+#define __fileno(fp) ((fp)->filedes)
+#endif
+
+/**********************************************************************
+ * PROTOTYPES OF INTERNAL FUNCTIONS
+ **********************************************************************/
+
+extern FILE *_stdio_openlist;
+
+#ifdef __STDIO_THREADSAFE
+extern pthread_mutex_t _stdio_openlist_lock;
+extern void __stdio_init_mutex(pthread_mutex_t *m);
+#endif
+
+extern int _stdio_adjpos(FILE * __restrict stream, __offmax_t * pos);
+extern int _stdio_lseek(FILE *stream, __offmax_t *pos, int whence);
+/* TODO: beware of signals with _stdio_fwrite!!!! */
+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(const char * __restrict filename,
+ const char * __restrict mode,
+ FILE * __restrict stream, int filedes);
+
+extern FILE *_stdio_fsfopen(const char * __restrict filename,
+ const char * __restrict mode,
+ register FILE * __restrict stream);
+
+extern void _stdio_init(void);
+extern void _stdio_term(void);
+
+#ifndef NDEBUG
+extern void __stdio_validate_FILE(FILE *stream);
+#else
+#define __stdio_validate_FILE(stream) ((void)0)
+#endif
+
+/**********************************************************************
+ * UTILITY functions
+ **********************************************************************/
+#ifdef _STDIO_UTILITY
+
+#include <features.h>
+#include <limits.h>
+#include <stdint.h>
+
+#if UINTMAX_MAX <= 4294967295UL
+#define __UIM_BUFLEN 12 /* 10 digits + 1 nul + 1 sign */
+#elif UINTMAX_MAX <= 18446744073709551615ULL
+#define __UIM_BUFLEN 22 /* 20 digits + 1 nul + 1 sign */
+#else
+#error unknown number of digits for intmax_t!
+#endif
+
+#ifdef ULLONG_MAX /* --------------- */
+#if ULLONG_MAX <= 4294967295UL
+#define __UIM_BUFLEN_LLONG 12 /* 10 digits + 1 nul + 1 sign */
+#elif ULLONG_MAX <= 18446744073709551615ULL
+#define __UIM_BUFLEN_LLONG 22 /* 20 digits + 1 nul + 1 sign */
+#else
+#error unknown number of digits for long long!
+#endif
+#endif /* ULLONG_MAX ----------------------------- */
+
+#if ULONG_MAX <= 4294967295UL
+#define __UIM_BUFLEN_LONG 12 /* 10 digits + 1 nul + 1 sign */
+#elif ULONG_MAX <= 18446744073709551615ULL
+#define __UIM_BUFLEN_LONG 22 /* 20 digits + 1 nul + 1 sign */
+#else
+#error unknown number of digits for long!
+#endif
+
+#if UINT_MAX <= 65536U
+#define __UIM_BUFLEN_INT 7 /* 10 digits + 1 nul + 1 sign */
+#elif UINT_MAX <= 4294967295UL
+#define __UIM_BUFLEN_INT 12 /* 10 digits + 1 nul + 1 sign */
+#else
+#error unknown number of digits for int!
+#endif
+
+typedef enum {
+ __UIM_DECIMAL = 0,
+ __UIM_LOWER = 'a' - 10,
+ __UIM_UPPER = 'A' - 10,
+} __UIM_CASE;
+
+/* Write a NULL-terminated list of "char *" args to file descriptor fd.
+ * For an example of usage, see __assert.c.
+ */
+extern void _stdio_fdout(int fd, ...);
+
+/* Convert the int val to a string in base abs(base). val is treated as
+ * an unsigned ??? int type if base > 0, and signed if base < 0. This
+ * is an internal function with _no_ error checking done unless assert()s
+ * are enabled.
+ *
+ * Note: bufend is a pointer to the END of the buffer passed.
+ * Call like this:
+ * char buf[SIZE], *p;
+ * p = _xltostr(buf + sizeof(buf) - 1, {unsigned int}, 10, __UIM_DECIMAL)
+ * p = _xltostr(buf + sizeof(buf) - 1, {int}, -10, __UIM_DECIMAL)
+ *
+ * WARNING: If base > 10, case _must_be_ either __UIM_LOWER or __UIM_UPPER
+ * for lower and upper case alphas respectively.
+ * WARNING: If val is really a signed type, make sure base is negative!
+ * Otherwise, you could overflow your buffer.
+ */
+extern char *_uintmaxtostr(char * __restrict bufend, uintmax_t uval,
+ int base, __UIM_CASE alphacase);
+
+/* TODO -- make this either a (possibly inline) function? */
+#ifndef __BCC__
+#define _int10tostr(bufend, intval) \
+ _uintmaxtostr((bufend), (intval), -10, __UIM_DECIMAL)
+#else /* bcc doesn't do prototypes, we need to explicitly cast */
+#define _int10tostr(bufend, intval) \
+ _uintmaxtostr((bufend), (uintmax_t)(intval), -10, __UIM_DECIMAL)
+#endif
+
+#define __BUFLEN_INT10TOSTR __UIM_BUFLEN_INT
+
+#endif /* _STDIO_UTILITY */
+/**********************************************************************/
+/* uClibc translations */
+/**********************************************************************/
+
+/* TODO: note done above.. typedef struct __stdio_file_struct _UC_FILE; */
+typedef __stdio_fpos_t _UC_fpos_t;
+typedef __stdio_fpos64_t _UC_fpos64_t;
+
+#define _UC_IOFBF _STDIO_IOFBF /* Fully buffered. */
+#define _UC_IOLBF _STDIO_IOLBF /* Line buffered. */
+#define _UC_IONBF _STDIO_IONBF /* No buffering. */
+
+#define _UC_BUFSIZ _STDIO_BUFSIZ
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
-#include <bits/libc-lock.h>
+/* #include <bits/libc-lock.h> */
#include <stdio.h>
#include <pthread.h>
-#ifdef USE_IN_LIBIO
-#include "../libio/libioP.h"
-#endif
-
void
__flockfile (FILE *stream)
{
-#ifdef USE_IN_LIBIO
- __pthread_mutex_lock (stream->_lock);
-#else
-#endif
+ pthread_mutex_lock(&stream->lock);
}
-#ifdef USE_IN_LIBIO
-#undef _IO_flockfile
-strong_alias (__flockfile, _IO_flockfile)
-#endif
weak_alias (__flockfile, flockfile);
void
__funlockfile (FILE *stream)
{
-#ifdef USE_IN_LIBIO
- __pthread_mutex_unlock (stream->_lock);
-#else
-#endif
+ pthread_mutex_unlock(&stream->lock);
}
-#ifdef USE_IN_LIBIO
-#undef _IO_funlockfile
-strong_alias (__funlockfile, _IO_funlockfile)
-#endif
weak_alias (__funlockfile, funlockfile);
int
__ftrylockfile (FILE *stream)
{
-#ifdef USE_IN_LIBIO
- return __pthread_mutex_trylock (stream->_lock);
-#else
- return 0;
-#endif
+ return pthread_mutex_trylock(&stream->lock);
}
-#ifdef USE_IN_LIBIO
-strong_alias (__ftrylockfile, _IO_ftrylockfile)
-#endif
weak_alias (__ftrylockfile, ftrylockfile);
void
__fresetlockfiles (void)
{
-#ifdef USE_IN_LIBIO
- _IO_FILE *fp;
+ FILE *fp;
pthread_mutexattr_t attr;
- __pthread_mutexattr_init (&attr);
- __pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE_NP);
+ pthread_mutexattr_init(&attr);
+ pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
- for (fp = _IO_list_all; fp != NULL; fp = fp->_chain)
- __pthread_mutex_init (fp->_lock, &attr);
+ for (fp = _stdio_openlist; fp != NULL; fp = fp->nextopen)
+ pthread_mutex_init(&fp->lock, &attr);
- __pthread_mutexattr_destroy (&attr);
-#endif
+ pthread_mutexattr_destroy(&attr);
}
projects / uclibc-ng.git / commitdiff